cleanup

mdb/collection.go

@@ -21,10 +21,10 @@ type Collection[T any] struct {
 	sanitize func(*T)
 	validate func(*T) error
 
-	indices       []*Index[T]
-	uniqueIndices []*Index[T]
+	indices       []Index[T]
+	uniqueIndices []Index[T]
 
-	ByID *Index[T]
+	ByID Index[T]
 
 	buf *bytes.Buffer
 }
@@ -65,8 +65,8 @@ func NewCollection[T any](db *Database, name string, conf *CollectionConfig[T])
 		copy:          conf.Copy,
 		sanitize:      conf.Sanitize,
 		validate:      conf.Validate,
-		indices:       []*Index[T]{},
-		uniqueIndices: []*Index[T]{},
+		indices:       []Index[T]{},
+		uniqueIndices: []Index[T]{},
 		buf:           &bytes.Buffer{},
 	}
 
@@ -92,7 +92,7 @@ func NewCollection[T any](db *Database, name string, conf *CollectionConfig[T])
 	return c
 }
 
-func (c *Collection[T]) Name() string {
+func (c Collection[T]) Name() string {
 	return c.name
 }
 
@@ -108,8 +108,35 @@ type indexConfig[T any] struct {
 	Include func(item *T) bool
 }
 
+func (c Collection[T]) Get(tx *Snapshot, id uint64) (*T, bool) {
+	x := new(T)
+	c.setID(x, id)
+	return c.ByID.Get(tx, x)
+}
+
+func (c Collection[T]) List(tx *Snapshot, ids []uint64, out []*T) []*T {
+	if len(ids) == 0 {
+		return out[:0]
+	}
+
+	if cap(out) < len(ids) {
+		out = make([]*T, len(ids))
+	}
+	out = out[:0]
+
+	for _, id := range ids {
+		item, ok := c.Get(tx, id)
+		if ok {
+			out = append(out, item)
+		}
+	}
+
+	return out
+}
+
 // AddIndex: Add an index to the collection.
-func (c *Collection[T]) addIndex(conf indexConfig[T]) *Index[T] {
+func (c *Collection[T]) addIndex(conf indexConfig[T]) Index[T] {
+
 	var less func(*T, *T) bool
 
 	if conf.Unique {
@@ -133,8 +160,7 @@ func (c *Collection[T]) addIndex(conf indexConfig[T]) *Index[T] {
 		BTree: btree.NewG(256, less),
 	}
 
-	index := &Index[T]{
-		db:           c.db,
+	index := Index[T]{
 		collectionID: c.collectionID,
 		name:         conf.Name,
 		indexID:      c.getState(c.db.Snapshot()).addIndex(indexState),
@@ -150,26 +176,7 @@ func (c *Collection[T]) addIndex(conf indexConfig[T]) *Index[T] {
 	return index
 }
 
-func (c *Collection[T]) Get(tx *Snapshot, id uint64) *T {
-	if tx == nil {
-		tx = c.db.Snapshot()
-	}
-	item := new(T)
-	c.setID(item, id)
-	return c.ByID.Get(tx, item)
-}
-
-func (c *Collection[T]) Insert(tx *Snapshot, userItem *T) error {
-	if tx == nil {
-		return c.db.Update(func(tx *Snapshot) error {
-			return c.insert(tx, userItem)
-		})
-	}
-
-	return c.insert(tx, userItem)
-}
-
-func (c *Collection[T]) insert(tx *Snapshot, userItem *T) error {
+func (c Collection[T]) Insert(tx *Snapshot, userItem *T) error {
 	if err := c.ensureMutable(tx); err != nil {
 		return err
 	}
@@ -196,16 +203,7 @@ func (c *Collection[T]) insert(tx *Snapshot, userItem *T) error {
 	return nil
 }
 
-func (c *Collection[T]) Update(tx *Snapshot, userItem *T) error {
-	if tx == nil {
-		return c.db.Update(func(tx *Snapshot) error {
-			return c.update(tx, userItem)
-		})
-	}
-	return c.update(tx, userItem)
-}
-
-func (c *Collection[T]) update(tx *Snapshot, userItem *T) error {
+func (c Collection[T]) Update(tx *Snapshot, userItem *T) error {
 	if err := c.ensureMutable(tx); err != nil {
 		return err
 	}
@@ -237,16 +235,7 @@ func (c *Collection[T]) update(tx *Snapshot, userItem *T) error {
 	return nil
 }
 
-func (c *Collection[T]) Upsert(tx *Snapshot, item *T) error {
-	if tx == nil {
-		return c.db.Update(func(tx *Snapshot) error {
-			return c.upsert(tx, item)
-		})
-	}
-	return c.upsert(tx, item)
-}
-
-func (c *Collection[T]) upsert(tx *Snapshot, item *T) error {
+func (c Collection[T]) Upsert(tx *Snapshot, item *T) error {
 	err := c.Insert(tx, item)
 	if err == nil {
 		return nil
@@ -257,16 +246,7 @@ func (c *Collection[T]) upsert(tx *Snapshot, item *T) error {
 	return err
 }
 
-func (c *Collection[T]) Delete(tx *Snapshot, itemID uint64) error {
-	if tx == nil {
-		return c.db.Update(func(tx *Snapshot) error {
-			return c.delete(tx, itemID)
-		})
-	}
-	return c.delete(tx, itemID)
-}
-
-func (c *Collection[T]) delete(tx *Snapshot, itemID uint64) error {
+func (c Collection[T]) Delete(tx *Snapshot, itemID uint64) error {
 	if err := c.ensureMutable(tx); err != nil {
 		return err
 	}
@@ -274,17 +254,13 @@ func (c *Collection[T]) delete(tx *Snapshot, itemID uint64) error {
 	return c.deleteItem(tx, itemID)
 }
 
-func (c *Collection[T]) Count(tx *Snapshot) int {
-	return c.ByID.Count(tx)
-}
-
-func (c *Collection[T]) getByID(tx *Snapshot, itemID uint64) (*T, bool) {
+func (c Collection[T]) getByID(tx *Snapshot, itemID uint64) (*T, bool) {
 	x := new(T)
 	c.setID(x, itemID)
 	return c.ByID.get(tx, x)
 }
 
-func (c *Collection[T]) ensureMutable(tx *Snapshot) error {
+func (c Collection[T]) ensureMutable(tx *Snapshot) error {
 	if !tx.writable() {
 		return errs.ReadOnly
 	}
@@ -298,7 +274,7 @@ func (c *Collection[T]) ensureMutable(tx *Snapshot) error {
 }
 
 // For initial data loading.
-func (c *Collection[T]) insertItem(tx *Snapshot, itemID uint64, data []byte) error {
+func (c Collection[T]) insertItem(tx *Snapshot, itemID uint64, data []byte) error {
 	item := new(T)
 	if err := json.Unmarshal(data, item); err != nil {
 		return errs.Encoding.WithErr(err).WithCollection(c.name)
@@ -319,7 +295,7 @@ func (c *Collection[T]) insertItem(tx *Snapshot, itemID uint64, data []byte) err
 	return nil
 }
 
-func (c *Collection[T]) deleteItem(tx *Snapshot, itemID uint64) error {
+func (c Collection[T]) deleteItem(tx *Snapshot, itemID uint64) error {
 	item, ok := c.getByID(tx, itemID)
 	if !ok {
 		return errs.NotFound
@@ -336,7 +312,7 @@ func (c *Collection[T]) deleteItem(tx *Snapshot, itemID uint64) error {
 
 // upsertItem inserts or updates the item with itemID and the given serialized
 // form. It's called by
-func (c *Collection[T]) upsertItem(tx *Snapshot, itemID uint64, data []byte) error {
+func (c Collection[T]) upsertItem(tx *Snapshot, itemID uint64, data []byte) error {
 	item, ok := c.getByID(tx, itemID)
 	if ok {
 		tx.delete(c.collectionID, itemID)
@@ -359,14 +335,14 @@ func (c *Collection[T]) upsertItem(tx *Snapshot, itemID uint64, data []byte) err
 	return nil
 }
 
-func (c *Collection[T]) getID(t *T) uint64 {
+func (c Collection[T]) getID(t *T) uint64 {
 	return *((*uint64)(unsafe.Pointer(t)))
 }
 
-func (c *Collection[T]) setID(t *T, id uint64) {
+func (c Collection[T]) setID(t *T, id uint64) {
 	*((*uint64)(unsafe.Pointer(t))) = id
 }
 
-func (c *Collection[T]) getState(tx *Snapshot) *collectionState[T] {
+func (c Collection[T]) getState(tx *Snapshot) *collectionState[T] {
 	return tx.collections[c.collectionID].(*collectionState[T])
 }

mdb/db-testcases_test.go

@@ -54,8 +54,8 @@ var testDBTestCases = []DBTestCase{{
 		Name: "Update",
 
 		Update: func(t *testing.T, db TestDB, tx *Snapshot) error {
-			user := db.Users.ByID.Get(tx, &User{ID: 1})
-			if user == nil {
+			user, ok := db.Users.ByID.Get(tx, &User{ID: 1})
+			if !ok {
 				return errs.NotFound
 			}
 			user.Name = "Bob"
@@ -323,8 +323,8 @@ var testDBTestCases = []DBTestCase{{
 		Name: "Update",
 
 		Update: func(t *testing.T, db TestDB, tx *Snapshot) error {
-			user := db.Users.ByID.Get(tx, &User{ID: 1})
-			if user == nil {
+			user, ok := db.Users.ByID.Get(tx, &User{ID: 1})
+			if !ok {
 				return errs.NotFound
 			}
 			user.Name = "Bob"
@@ -493,8 +493,8 @@ var testDBTestCases = []DBTestCase{{
 		Name: "Update",
 
 		Update: func(t *testing.T, db TestDB, tx *Snapshot) error {
-			u := db.Users.ByID.Get(tx, &User{ID: 2})
-			if u == nil {
+			u, ok := db.Users.ByID.Get(tx, &User{ID: 2})
+			if !ok {
 				return errs.NotFound
 			}
 
@@ -609,16 +609,16 @@ var testDBTestCases = []DBTestCase{{
 		Update: func(t *testing.T, db TestDB, tx *Snapshot) error {
 			expected := &User{ID: 1, Name: "Alice", Email: "a@b.com"}
 
-			u := db.Users.ByID.Get(tx, &User{ID: 1})
-			if u == nil {
+			u, ok := db.Users.ByID.Get(tx, &User{ID: 1})
+			if !ok {
 				return errs.NotFound
 			}
 			if !reflect.DeepEqual(u, expected) {
 				return errors.New("Not equal (id)")
 			}
 
-			u = db.Users.ByEmail.Get(tx, &User{Email: "a@b.com"})
-			if u == nil {
+			u, ok = db.Users.ByEmail.Get(tx, &User{Email: "a@b.com"})
+			if !ok {
 				return errs.NotFound
 			}
 			if !reflect.DeepEqual(u, expected) {
@@ -637,11 +637,11 @@ var testDBTestCases = []DBTestCase{{
 		Name: "Get not found",
 
 		Update: func(t *testing.T, db TestDB, tx *Snapshot) error {
-			if u := db.Users.ByID.Get(tx, &User{ID: 2}); u != nil {
+			if _, ok := db.Users.ByID.Get(tx, &User{ID: 2}); ok {
 				return errors.New("Found (id)")
 			}
 
-			if u := db.Users.ByEmail.Get(tx, &User{Email: "x@b.com"}); u != nil {
+			if _, ok := db.Users.ByEmail.Get(tx, &User{Email: "x@b.com"}); ok {
 				return errors.New("Found (email)")
 			}
 
@@ -753,8 +753,8 @@ var testDBTestCases = []DBTestCase{{
 					return true
 				}
 
-				prev := db.Users.ByID.Get(tx, &User{ID: u.ID - 1})
-				if prev == nil {
+				prev, ok := db.Users.ByID.Get(tx, &User{ID: u.ID - 1})
+				if !ok {
 					err = errors.New("Previous user not found")
 					return false
 				}
@@ -811,8 +811,8 @@ var testDBTestCases = []DBTestCase{{
 					return true
 				}
 
-				prev := db.Users.ByID.Get(tx, &User{ID: u.ID + 1})
-				if prev == nil {
+				prev, ok := db.Users.ByID.Get(tx, &User{ID: u.ID + 1})
+				if !ok {
 					err = errors.New("Previous user not found")
 					return false
 				}

mdb/db-testlist_test.go

@@ -123,7 +123,7 @@ func TestDBList(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.Name, func(t *testing.T) {
 			tx := db.Snapshot()
-			l := db.UserData.ByName.List(tx, &tc.Args, nil)
+			l := db.UserData.ByName.List(tx, tc.Args, nil)
 			if len(l) != len(tc.Expected) {
 				t.Fatal(tc.Name, l)
 			}

mdb/db-testrunner_test.go

@@ -134,23 +134,23 @@ func checkSlicesEqual[T any](t *testing.T, name string, actual, expected []T) {
 	}
 }
 
-func checkMinMaxEqual[T any](t *testing.T, name string, tx *Snapshot, index *Index[T], expected []T) {
+func checkMinMaxEqual[T any](t *testing.T, name string, tx *Snapshot, index Index[T], expected []T) {
 	if len(expected) == 0 {
-		if min := index.Min(tx); min != nil {
+		if min, ok := index.Min(tx); ok {
 			t.Fatal(min)
 		}
-		if max := index.Max(tx); max != nil {
+		if max, ok := index.Max(tx); ok {
 			t.Fatal(max)
 		}
 		return
 	}
 
-	min := index.Min(tx)
-	if min == nil {
+	min, ok := index.Min(tx)
+	if !ok {
 		t.Fatal("No min")
 	}
-	max := index.Max(tx)
-	if max == nil {
+	max, ok := index.Max(tx)
+	if !ok {
 		t.Fatal("No max")
 	}
 

mdb/db-userdata_test.go

@@ -14,7 +14,7 @@ type UserDataItem struct {
 
 type UserData struct {
 	*Collection[UserDataItem]
-	ByName *Index[UserDataItem] // Unique index on (Token).
+	ByName Index[UserDataItem] // Unique index on (Token).
 }
 
 func NewUserDataCollection(db *Database) UserData {

mdb/db-users_test.go

@@ -12,9 +12,9 @@ type User struct {
 
 type Users struct {
 	*Collection[User]
-	ByEmail   *Index[User] // Unique index on (Email).
-	ByName    *Index[User] // Index on (Name).
-	ByBlocked *Index[User] // Partial index on (Blocked,Email).
+	ByEmail   Index[User] // Unique index on (Email).
+	ByName    Index[User] // Index on (Name).
+	ByBlocked Index[User] // Partial index on (Blocked,Email).
 }
 
 func NewUserCollection(db *Database) Users {

mdb/equality_test.go

@@ -21,8 +21,8 @@ func (i Index[T]) AssertEqual(t *testing.T, tx1, tx2 *Snapshot) {
 
 	errStr := ""
 	i.Ascend(tx1, func(item1 *T) bool {
-		item2 := i.Get(tx2, item1)
-		if item2 == nil {
+		item2, ok := i.Get(tx2, item1)
+		if !ok {
 			errStr = fmt.Sprintf("Indices don't match. %v not found.", item1)
 			return false
 		}

mdb/index.go

@@ -10,7 +10,7 @@ func NewIndex[T any](
 	c *Collection[T],
 	name string,
 	compare func(lhs, rhs *T) int,
-) *Index[T] {
+) Index[T] {
 	return c.addIndex(indexConfig[T]{
 		Name:    name,
 		Unique:  false,
@@ -24,7 +24,7 @@ func NewPartialIndex[T any](
 	name string,
 	compare func(lhs, rhs *T) int,
 	include func(*T) bool,
-) *Index[T] {
+) Index[T] {
 	return c.addIndex(indexConfig[T]{
 		Name:    name,
 		Unique:  false,
@@ -37,7 +37,7 @@ func NewUniqueIndex[T any](
 	c *Collection[T],
 	name string,
 	compare func(lhs, rhs *T) int,
-) *Index[T] {
+) Index[T] {
 	return c.addIndex(indexConfig[T]{
 		Name:    name,
 		Unique:  true,
@@ -51,7 +51,7 @@ func NewUniquePartialIndex[T any](
 	name string,
 	compare func(lhs, rhs *T) int,
 	include func(*T) bool,
-) *Index[T] {
+) Index[T] {
 	return c.addIndex(indexConfig[T]{
 		Name:    name,
 		Unique:  true,
@@ -63,7 +63,6 @@ func NewUniquePartialIndex[T any](
 // ----------------------------------------------------------------------------
 
 type Index[T any] struct {
-	db           *Database
 	name         string
 	collectionID uint64
 	indexID      uint64
@@ -71,69 +70,57 @@ type Index[T any] struct {
 	copy         func(*T) *T
 }
 
-func (i *Index[T]) ensureSnapshot(tx *Snapshot) *Snapshot {
-	if tx == nil {
-		tx = i.db.Snapshot()
+func (i Index[T]) Get(tx *Snapshot, in *T) (item *T, ok bool) {
+	tPtr, ok := i.get(tx, in)
+	if !ok {
+		return item, false
 	}
-	return tx
+	return i.copy(tPtr), true
 }
 
-func (i *Index[T]) Get(tx *Snapshot, in *T) *T {
-	tx = i.ensureSnapshot(tx)
-	if tPtr, ok := i.get(tx, in); ok {
-		return i.copy(tPtr)
-	}
-	return nil
-}
-
-func (i *Index[T]) get(tx *Snapshot, in *T) (*T, bool) {
+func (i Index[T]) get(tx *Snapshot, in *T) (*T, bool) {
 	return i.btree(tx).Get(in)
 }
 
-func (i *Index[T]) Has(tx *Snapshot, in *T) bool {
-	tx = i.ensureSnapshot(tx)
+func (i Index[T]) Has(tx *Snapshot, in *T) bool {
 	return i.btree(tx).Has(in)
 }
 
-func (i *Index[T]) Min(tx *Snapshot) *T {
-	tx = i.ensureSnapshot(tx)
-	if tPtr, ok := i.btree(tx).Min(); ok {
-		return i.copy(tPtr)
+func (i Index[T]) Min(tx *Snapshot) (item *T, ok bool) {
+	tPtr, ok := i.btree(tx).Min()
+	if !ok {
+		return item, false
 	}
-	return nil
+	return i.copy(tPtr), true
 }
 
-func (i *Index[T]) Max(tx *Snapshot) *T {
-	tx = i.ensureSnapshot(tx)
-	if tPtr, ok := i.btree(tx).Max(); ok {
-		return i.copy(tPtr)
+func (i Index[T]) Max(tx *Snapshot) (item *T, ok bool) {
+	tPtr, ok := i.btree(tx).Max()
+	if !ok {
+		return item, false
 	}
-	return nil
+	return i.copy(tPtr), true
 }
 
-func (i *Index[T]) Ascend(tx *Snapshot, each func(*T) bool) {
-	tx = i.ensureSnapshot(tx)
+func (i Index[T]) Ascend(tx *Snapshot, each func(*T) bool) {
 	i.btreeForIter(tx).Ascend(func(t *T) bool {
 		return each(i.copy(t))
 	})
 }
 
-func (i *Index[T]) AscendAfter(tx *Snapshot, after *T, each func(*T) bool) {
-	tx = i.ensureSnapshot(tx)
+func (i Index[T]) AscendAfter(tx *Snapshot, after *T, each func(*T) bool) {
 	i.btreeForIter(tx).AscendGreaterOrEqual(after, func(t *T) bool {
 		return each(i.copy(t))
 	})
 }
 
-func (i *Index[T]) Descend(tx *Snapshot, each func(*T) bool) {
-	tx = i.ensureSnapshot(tx)
+func (i Index[T]) Descend(tx *Snapshot, each func(*T) bool) {
 	i.btreeForIter(tx).Descend(func(t *T) bool {
 		return each(i.copy(t))
 	})
 }
 
-func (i *Index[T]) DescendAfter(tx *Snapshot, after *T, each func(*T) bool) {
-	tx = i.ensureSnapshot(tx)
+func (i Index[T]) DescendAfter(tx *Snapshot, after *T, each func(*T) bool) {
 	i.btreeForIter(tx).DescendLessOrEqual(after, func(t *T) bool {
 		return each(i.copy(t))
 	})
@@ -146,12 +133,7 @@ type ListArgs[T any] struct {
 	Limit int           // Maximum number of items to return. 0 => All.
 }
 
-func (i *Index[T]) List(tx *Snapshot, args *ListArgs[T], out []*T) []*T {
-	tx = i.ensureSnapshot(tx)
-	if args == nil {
-		args = &ListArgs[T]{}
-	}
-
+func (i Index[T]) List(tx *Snapshot, args ListArgs[T], out []*T) []*T {
 	if args.Limit < 0 {
 		return nil
 	}
@@ -192,18 +174,13 @@ func (i *Index[T]) List(tx *Snapshot, args *ListArgs[T], out []*T) []*T {
 	return items
 }
 
-func (i *Index[T]) Count(tx *Snapshot) int {
-	tx = i.ensureSnapshot(tx)
-	return i.btree(tx).Len()
-}
-
 // ----------------------------------------------------------------------------
 
-func (i *Index[T]) insertConflict(tx *Snapshot, item *T) bool {
+func (i Index[T]) insertConflict(tx *Snapshot, item *T) bool {
 	return i.btree(tx).Has(item)
 }
 
-func (i *Index[T]) updateConflict(tx *Snapshot, item *T) bool {
+func (i Index[T]) updateConflict(tx *Snapshot, item *T) bool {
 	current, ok := i.btree(tx).Get(item)
 	return ok && i.getID(current) != i.getID(item)
 }
@@ -211,7 +188,7 @@ func (i *Index[T]) updateConflict(tx *Snapshot, item *T) bool {
 // This should only be called after insertConflict. Additionally, the caller
 // should ensure that the index has been properly cloned for write before
 // writing.
-func (i *Index[T]) insert(tx *Snapshot, item *T) {
+func (i Index[T]) insert(tx *Snapshot, item *T) {
 	if i.include != nil && !i.include(item) {
 		return
 	}
@@ -219,7 +196,7 @@ func (i *Index[T]) insert(tx *Snapshot, item *T) {
 	i.btree(tx).ReplaceOrInsert(item)
 }
 
-func (i *Index[T]) update(tx *Snapshot, old, new *T) {
+func (i Index[T]) update(tx *Snapshot, old, new *T) {
 	bt := i.btree(tx)
 	bt.Delete(old)
 
@@ -227,22 +204,22 @@ func (i *Index[T]) update(tx *Snapshot, old, new *T) {
 	i.insert(tx, new)
 }
 
-func (i *Index[T]) delete(tx *Snapshot, item *T) {
+func (i Index[T]) delete(tx *Snapshot, item *T) {
 	i.btree(tx).Delete(item)
 }
 
 // ----------------------------------------------------------------------------
 
-func (i *Index[T]) getState(tx *Snapshot) indexState[T] {
+func (i Index[T]) getState(tx *Snapshot) indexState[T] {
 	return tx.collections[i.collectionID].(*collectionState[T]).Indices[i.indexID]
 }
 
 // Get the current btree for get/has/update/delete, etc.
-func (i *Index[T]) btree(tx *Snapshot) *btree.BTreeG[*T] {
+func (i Index[T]) btree(tx *Snapshot) *btree.BTreeG[*T] {
 	return i.getState(tx).BTree
 }
 
-func (i *Index[T]) btreeForIter(tx *Snapshot) *btree.BTreeG[*T] {
+func (i Index[T]) btreeForIter(tx *Snapshot) *btree.BTreeG[*T] {
 	cState := tx.collections[i.collectionID].(*collectionState[T])
 	bt := cState.Indices[i.indexID].BTree
 
@@ -254,6 +231,6 @@ func (i *Index[T]) btreeForIter(tx *Snapshot) *btree.BTreeG[*T] {
 	return bt
 }
 
-func (i *Index[T]) getID(t *T) uint64 {
+func (i Index[T]) getID(t *T) uint64 {
 	return *((*uint64)(unsafe.Pointer(t)))
 }

mdb/testdb_test.go

@@ -133,8 +133,8 @@ func (db DataDB) modifyOnce() {
 func (db DataDB) ComputeCRC(tx *Snapshot) uint32 {
 	h := crc32.NewIEEE()
 	for dataID := uint64(1); dataID < 10; dataID++ {
-		d := db.Datas.ByID.Get(tx, &DataItem{ID: dataID})
-		if d == nil {
+		d, ok := db.Datas.ByID.Get(tx, &DataItem{ID: dataID})
+		if !ok {
 			continue
 		}
 		h.Write(d.Data)
@@ -143,8 +143,8 @@ func (db DataDB) ComputeCRC(tx *Snapshot) uint32 {
 }
 
 func (db DataDB) ReadCRC(tx *Snapshot) uint32 {
-	r := db.CRCs.ByID.Get(tx, &CRCItem{ID: 1})
-	if r == nil {
+	r, ok := db.CRCs.ByID.Get(tx, &CRCItem{ID: 1})
+	if !ok {
 		return 0
 	}
 	return r.CRC32

mdb/testing/crashconsistency/main.go

@@ -136,8 +136,8 @@ func (db DataDB) modifyOnce() {
 func (db DataDB) ComputeCRC(tx *mdb.Snapshot) uint32 {
 	h := crc32.NewIEEE()
 	for dataID := uint64(1); dataID < 10; dataID++ {
-		d := db.Datas.ByID.Get(tx, &DataItem{ID: dataID})
-		if d == nil {
+		d, ok := db.Datas.ByID.Get(tx, &DataItem{ID: dataID})
+		if !ok {
 			continue
 		}
 		h.Write(d.Data)
@@ -146,8 +146,8 @@ func (db DataDB) ComputeCRC(tx *mdb.Snapshot) uint32 {
 }
 
 func (db DataDB) ReadCRC(tx *mdb.Snapshot) uint32 {
-	r := db.CRCs.ByID.Get(tx, &CRCItem{ID: 1})
-	if r == nil {
+	r, ok := db.CRCs.ByID.Get(tx, &CRCItem{ID: 1})
+	if !ok {
 		return 0
 	}
 	return r.CRC32