public/jldb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 17 Wiki Activity

Allow nil Snapshot for most ops, CRUD for collection

Browse Source
This commit is contained in:
jdl
2023-11-21 17:41:55 +01:00
parent 3c9e5505ab
commit 9078335d70
8 changed files with 110 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
mdb/collection.go
View File

@@ -108,33 +108,6 @@ type indexConfig[T any] struct {
Include func(item *T) bool Include func(item *T) bool
} }
// A shortcut for c.ByID.Get(tx, &Item{ID:id}).
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]) GetList(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. // 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 var less func(*T, *T) bool
@@ -161,6 +134,7 @@ func (c *Collection[T]) addIndex(conf indexConfig[T]) *Index[T] {
} }
index := &Index[T]{ index := &Index[T]{
db: c.db,
collectionID: c.collectionID, collectionID: c.collectionID,
name: conf.Name, name: conf.Name,
indexID: c.getState(c.db.Snapshot()).addIndex(indexState), indexID: c.getState(c.db.Snapshot()).addIndex(indexState),
@@ -176,7 +150,26 @@ func (c *Collection[T]) addIndex(conf indexConfig[T]) *Index[T] {
return index 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 { 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 {
if err := c.ensureMutable(tx); err != nil { if err := c.ensureMutable(tx); err != nil {
return err return err
} }
@@ -204,6 +197,15 @@ func (c *Collection[T]) Insert(tx *Snapshot, userItem *T) error {
} }
func (c *Collection[T]) Update(tx *Snapshot, userItem *T) error { 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 {
if err := c.ensureMutable(tx); err != nil { if err := c.ensureMutable(tx); err != nil {
return err return err
} }
@@ -235,19 +237,16 @@ func (c *Collection[T]) Update(tx *Snapshot, userItem *T) error {
return nil return nil
} }
func (c *Collection[T]) UpdateFunc(tx *Snapshot, id uint64, update func(item *T) error) error { func (c *Collection[T]) Upsert(tx *Snapshot, item *T) error {
item, ok := c.getByID(tx, id) if tx == nil {
if !ok { return c.db.Update(func(tx *Snapshot) error {
return errs.NotFound return c.upsert(tx, item)
})
} }
itemCopy := c.copy(item) return c.upsert(tx, item)
if err := update(itemCopy); err != nil {
return err
}
return c.Update(tx, itemCopy)
} }
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) err := c.Insert(tx, item)
if err == nil { if err == nil {
return nil return nil
@@ -258,21 +257,16 @@ func (c *Collection[T]) Upsert(tx *Snapshot, item *T) error {
return err return err
} }
func (c *Collection[T]) UpsertFunc(tx *Snapshot, id uint64, update func(item *T) error) error {
item, ok := c.getByID(tx, id)
if !ok {
item = new(T)
c.setID(item, id)
}
itemCopy := c.copy(item)
if err := update(itemCopy); err != nil {
return err
}
return c.Upsert(tx, itemCopy)
}
func (c *Collection[T]) Delete(tx *Snapshot, itemID uint64) error { 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 {
if err := c.ensureMutable(tx); err != nil { if err := c.ensureMutable(tx); err != nil {
return err return err
} }

32
mdb/db-testcases_test.go
View File

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

2
mdb/db-testlist_test.go
View File

@@ -123,7 +123,7 @@ func TestDBList(t *testing.T) {
for _, tc := range cases { for _, tc := range cases {
t.Run(tc.Name, func(t *testing.T) { t.Run(tc.Name, func(t *testing.T) {
tx := db.Snapshot() 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) { if len(l) != len(tc.Expected) {
t.Fatal(tc.Name, l) t.Fatal(tc.Name, l)
} }

12
mdb/db-testrunner_test.go
View File

@@ -136,21 +136,21 @@ 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 len(expected) == 0 {
if min, ok := index.Min(tx); ok { if min := index.Min(tx); min != nil {
t.Fatal(min) t.Fatal(min)
} }
if max, ok := index.Max(tx); ok { if max := index.Max(tx); max != nil {
t.Fatal(max) t.Fatal(max)
} }
return return
} }
min, ok := index.Min(tx) min := index.Min(tx)
if !ok { if min == nil {
t.Fatal("No min") t.Fatal("No min")
} }
max, ok := index.Max(tx) max := index.Max(tx)
if !ok { if max == nil {
t.Fatal("No max") t.Fatal("No max")
} }

4
mdb/equality_test.go
View File

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

50
mdb/index.go
View File

@@ -63,6 +63,7 @@ func NewUniquePartialIndex[T any](
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
type Index[T any] struct { type Index[T any] struct {
db *Database
name string name string
collectionID uint64 collectionID uint64
indexID uint64 indexID uint64
@@ -70,12 +71,19 @@ type Index[T any] struct {
copy func(*T) *T copy func(*T) *T
} }
func (i *Index[T]) Get(tx *Snapshot, in *T) (item *T, ok bool) { func (i *Index[T]) ensureSnapshot(tx *Snapshot) *Snapshot {
tPtr, ok := i.get(tx, in) if tx == nil {
if !ok { tx = i.db.Snapshot()
return item, false
} }
return i.copy(tPtr), true return tx
}
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) {
@@ -83,44 +91,49 @@ func (i *Index[T]) get(tx *Snapshot, in *T) (*T, bool) {
} }
func (i *Index[T]) Has(tx *Snapshot, in *T) bool { func (i *Index[T]) Has(tx *Snapshot, in *T) bool {
tx = i.ensureSnapshot(tx)
return i.btree(tx).Has(in) return i.btree(tx).Has(in)
} }
func (i *Index[T]) Min(tx *Snapshot) (item *T, ok bool) { func (i *Index[T]) Min(tx *Snapshot) *T {
tPtr, ok := i.btree(tx).Min() tx = i.ensureSnapshot(tx)
if !ok { if tPtr, ok := i.btree(tx).Min(); ok {
return item, false return i.copy(tPtr)
} }
return i.copy(tPtr), true return nil
} }
func (i *Index[T]) Max(tx *Snapshot) (item *T, ok bool) { func (i *Index[T]) Max(tx *Snapshot) *T {
tPtr, ok := i.btree(tx).Max() tx = i.ensureSnapshot(tx)
if !ok { if tPtr, ok := i.btree(tx).Max(); ok {
return item, false return i.copy(tPtr)
} }
return i.copy(tPtr), true return nil
} }
func (i *Index[T]) Ascend(tx *Snapshot, each func(*T) bool) { func (i *Index[T]) Ascend(tx *Snapshot, each func(*T) bool) {
tx = i.ensureSnapshot(tx)
i.btreeForIter(tx).Ascend(func(t *T) bool { i.btreeForIter(tx).Ascend(func(t *T) bool {
return each(i.copy(t)) return each(i.copy(t))
}) })
} }
func (i *Index[T]) AscendAfter(tx *Snapshot, after *T, each func(*T) bool) { func (i *Index[T]) AscendAfter(tx *Snapshot, after *T, each func(*T) bool) {
tx = i.ensureSnapshot(tx)
i.btreeForIter(tx).AscendGreaterOrEqual(after, func(t *T) bool { i.btreeForIter(tx).AscendGreaterOrEqual(after, func(t *T) bool {
return each(i.copy(t)) return each(i.copy(t))
}) })
} }
func (i *Index[T]) Descend(tx *Snapshot, each func(*T) bool) { func (i *Index[T]) Descend(tx *Snapshot, each func(*T) bool) {
tx = i.ensureSnapshot(tx)
i.btreeForIter(tx).Descend(func(t *T) bool { i.btreeForIter(tx).Descend(func(t *T) bool {
return each(i.copy(t)) return each(i.copy(t))
}) })
} }
func (i *Index[T]) DescendAfter(tx *Snapshot, after *T, each func(*T) bool) { func (i *Index[T]) DescendAfter(tx *Snapshot, after *T, each func(*T) bool) {
tx = i.ensureSnapshot(tx)
i.btreeForIter(tx).DescendLessOrEqual(after, func(t *T) bool { i.btreeForIter(tx).DescendLessOrEqual(after, func(t *T) bool {
return each(i.copy(t)) return each(i.copy(t))
}) })
@@ -133,7 +146,12 @@ type ListArgs[T any] struct {
Limit int // Maximum number of items to return. 0 => All. Limit int // Maximum number of items to return. 0 => All.
} }
func (i *Index[T]) List(tx *Snapshot, args ListArgs[T], out []*T) []*T { func (i *Index[T]) List(tx *Snapshot, args *ListArgs[T], out []*T) []*T {
tx = i.ensureSnapshot(tx)
if args == nil {
args = &ListArgs[T]{}
}
if args.Limit < 0 { if args.Limit < 0 {
return nil return nil
} }

8
mdb/testdb_test.go
View File

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

8
mdb/testing/crashconsistency/main.go
View File

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