Skip to content
This repository was archived by the owner on Sep 5, 2025. It is now read-only.

feat: update interface to driver and db #56

Closed
jairad26 wants to merge 4 commits into from
Closed

feat: update interface to driver and db #56

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
d18adf5
update interface to driver and db
jairad26 Jan 10, 2025
392d287
whoops
jairad26 Jan 10, 2025
a9842e5
refactor around drivers and dbs, drivers do the core db work, db is a…
jairad26 Jan 10, 2025
66739f1
changelog
jairad26 Jan 10, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions CHANGELOG.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,8 @@
- fix: alter schema on reverse edge after querying schema
[#55](https://github.com/hypermodeinc/modusDB/pull/55)

- feat: update interface to driver and db [#56](https://github.com/hypermodeinc/modusDB/pull/56)

## 2025-01-02 - Version 0.1.0

Baseline for the changelog.
Expand Down
92 changes: 46 additions & 46 deletions api.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,52 +18,52 @@ import (
"github.com/hypermodeinc/modusdb/api/structreflect"
)

func Create[T any](db *DB, object T, ns ...uint64) (uint64, T, error) {
db.mutex.Lock()
defer db.mutex.Unlock()
if len(ns) > 1 {
func Create[T any](driver *Driver, object T, dbId ...uint64) (uint64, T, error) {
driver.mutex.Lock()
defer driver.mutex.Unlock()
if len(dbId) > 1 {
return 0, object, fmt.Errorf("only one namespace is allowed")
}
ctx, n, err := getDefaultNamespace(db, ns...)
ctx, db, err := getDefaultDB(driver, dbId...)
if err != nil {
return 0, object, err
}

gid, err := db.z.nextUID()
gid, err := driver.z.nextUID()
if err != nil {
return 0, object, err
}

dms := make([]*dql.Mutation, 0)
sch := &schema.ParsedSchema{}
err = generateSetDqlMutationsAndSchema[T](ctx, n, object, gid, &dms, sch)
err = generateSetDqlMutationsAndSchema[T](ctx, db, object, gid, &dms, sch)
if err != nil {
return 0, object, err
}

err = n.alterSchemaWithParsed(ctx, sch)
err = driver.alterSchemaWithParsed(ctx, sch)
if err != nil {
return 0, object, err
}

err = applyDqlMutations(ctx, db, dms)
err = applyDqlMutations(ctx, driver, dms)
if err != nil {
return 0, object, err
}

return getByGid[T](ctx, n, gid)
return getByGid[T](ctx, db, gid)
}

func Upsert[T any](db *DB, object T, ns ...uint64) (uint64, T, bool, error) {
func Upsert[T any](driver *Driver, object T, dbId ...uint64) (uint64, T, bool, error) {

var wasFound bool
db.mutex.Lock()
defer db.mutex.Unlock()
if len(ns) > 1 {
driver.mutex.Lock()
defer driver.mutex.Unlock()
if len(dbId) > 1 {
return 0, object, false, fmt.Errorf("only one namespace is allowed")
}

ctx, n, err := getDefaultNamespace(db, ns...)
ctx, db, err := getDefaultDB(driver, dbId...)
if err != nil {
return 0, object, false, err
}
Expand All @@ -82,106 +82,106 @@ func Upsert[T any](db *DB, object T, ns ...uint64) (uint64, T, bool, error) {

dms := make([]*dql.Mutation, 0)
sch := &schema.ParsedSchema{}
err = generateSetDqlMutationsAndSchema[T](ctx, n, object, gid, &dms, sch)
err = generateSetDqlMutationsAndSchema[T](ctx, db, object, gid, &dms, sch)
if err != nil {
return 0, object, false, err
}

err = n.alterSchemaWithParsed(ctx, sch)
err = db.driver.alterSchemaWithParsed(ctx, sch)
if err != nil {
return 0, object, false, err
}

if gid != 0 || cf != nil {
gid, err = getExistingObject[T](ctx, n, gid, cf, object)
gid, err = getExistingObject[T](ctx, db, gid, cf, object)
if err != nil && err != apiutils.ErrNoObjFound {
return 0, object, false, err
}
wasFound = err == nil
}

if gid == 0 {
gid, err = db.z.nextUID()
gid, err = driver.z.nextUID()
if err != nil {
return 0, object, false, err
}
}

dms = make([]*dql.Mutation, 0)
err = generateSetDqlMutationsAndSchema[T](ctx, n, object, gid, &dms, sch)
err = generateSetDqlMutationsAndSchema[T](ctx, db, object, gid, &dms, sch)
if err != nil {
return 0, object, false, err
}

err = applyDqlMutations(ctx, db, dms)
err = applyDqlMutations(ctx, driver, dms)
if err != nil {
return 0, object, false, err
}

gid, object, err = getByGid[T](ctx, n, gid)
gid, object, err = getByGid[T](ctx, db, gid)
if err != nil {
return 0, object, false, err
}

return gid, object, wasFound, nil
}

func Get[T any, R UniqueField](db *DB, uniqueField R, ns ...uint64) (uint64, T, error) {
db.mutex.Lock()
defer db.mutex.Unlock()
func Get[T any, R UniqueField](driver *Driver, uniqueField R, dbId ...uint64) (uint64, T, error) {
driver.mutex.Lock()
defer driver.mutex.Unlock()
var obj T
if len(ns) > 1 {
if len(dbId) > 1 {
return 0, obj, fmt.Errorf("only one namespace is allowed")
}
ctx, n, err := getDefaultNamespace(db, ns...)
ctx, db, err := getDefaultDB(driver, dbId...)
if err != nil {
return 0, obj, err
}
if uid, ok := any(uniqueField).(uint64); ok {
return getByGid[T](ctx, n, uid)
return getByGid[T](ctx, db, uid)
}

if cf, ok := any(uniqueField).(ConstrainedField); ok {
return getByConstrainedField[T](ctx, n, cf)
return getByConstrainedField[T](ctx, db, cf)
}

return 0, obj, fmt.Errorf("invalid unique field type")
}

func Query[T any](db *DB, queryParams QueryParams, ns ...uint64) ([]uint64, []T, error) {
db.mutex.Lock()
defer db.mutex.Unlock()
if len(ns) > 1 {
func Query[T any](driver *Driver, queryParams QueryParams, dbId ...uint64) ([]uint64, []T, error) {
driver.mutex.Lock()
defer driver.mutex.Unlock()
if len(dbId) > 1 {
return nil, nil, fmt.Errorf("only one namespace is allowed")
}
ctx, n, err := getDefaultNamespace(db, ns...)
ctx, db, err := getDefaultDB(driver, dbId...)
if err != nil {
return nil, nil, err
}

return executeQuery[T](ctx, n, queryParams, true)
return executeQuery[T](ctx, db, queryParams, true)
}

func Delete[T any, R UniqueField](db *DB, uniqueField R, ns ...uint64) (uint64, T, error) {
db.mutex.Lock()
defer db.mutex.Unlock()
func Delete[T any, R UniqueField](driver *Driver, uniqueField R, dbId ...uint64) (uint64, T, error) {
driver.mutex.Lock()
defer driver.mutex.Unlock()
var zeroObj T
if len(ns) > 1 {
if len(dbId) > 1 {
return 0, zeroObj, fmt.Errorf("only one namespace is allowed")
}
ctx, n, err := getDefaultNamespace(db, ns...)
ctx, db, err := getDefaultDB(driver, dbId...)
if err != nil {
return 0, zeroObj, err
}
if uid, ok := any(uniqueField).(uint64); ok {
uid, obj, err := getByGid[T](ctx, n, uid)
uid, obj, err := getByGid[T](ctx, db, uid)
if err != nil {
return 0, zeroObj, err
}

dms := generateDeleteDqlMutations(n, uid)
dms := generateDeleteDqlMutations(db, uid)

err = applyDqlMutations(ctx, db, dms)
err = applyDqlMutations(ctx, driver, dms)
if err != nil {
return 0, zeroObj, err
}
Expand All @@ -190,14 +190,14 @@ func Delete[T any, R UniqueField](db *DB, uniqueField R, ns ...uint64) (uint64,
}

if cf, ok := any(uniqueField).(ConstrainedField); ok {
uid, obj, err := getByConstrainedField[T](ctx, n, cf)
uid, obj, err := getByConstrainedField[T](ctx, db, cf)
if err != nil {
return 0, zeroObj, err
}

dms := generateDeleteDqlMutations(n, uid)
dms := generateDeleteDqlMutations(db, uid)

err = applyDqlMutations(ctx, db, dms)
err = applyDqlMutations(ctx, driver, dms)
if err != nil {
return 0, zeroObj, err
}
Expand Down
20 changes: 10 additions & 10 deletions api_mutation_gen.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,7 +26,7 @@ import (
"github.com/hypermodeinc/modusdb/api/structreflect"
)

func generateSetDqlMutationsAndSchema[T any](ctx context.Context, n *Namespace, object T,
func generateSetDqlMutationsAndSchema[T any](ctx context.Context, d *DB, object T,
gid uint64, dms *[]*dql.Mutation, sch *schema.ParsedSchema) error {
t := reflect.TypeOf(object)
if t.Kind() != reflect.Struct {
Expand All @@ -49,7 +49,7 @@ func generateSetDqlMutationsAndSchema[T any](ctx context.Context, n *Namespace,
if tagMaps.JsonToReverseEdge[jsonName] != "" {
reverseEdgeStr := tagMaps.JsonToReverseEdge[jsonName]
typeName := strings.Split(reverseEdgeStr, ".")[0]
currSchema, err := getSchema(ctx, n)
currSchema, err := getSchema(ctx, d)
if err != nil {
return err
}
Expand All @@ -70,7 +70,7 @@ func generateSetDqlMutationsAndSchema[T any](ctx context.Context, n *Namespace,
}

if !(typeFound && predicateFound) {
if err := mutations.HandleReverseEdge(jsonName, reflectValueType, n.ID(), sch,
if err := mutations.HandleReverseEdge(jsonName, reflectValueType, d.ID(), sch,
reverseEdgeStr); err != nil {
return err
}
Expand All @@ -82,17 +82,17 @@ func generateSetDqlMutationsAndSchema[T any](ctx context.Context, n *Namespace,
continue
}

value, err = processStructValue(ctx, value, n)
value, err = processStructValue(ctx, value, d)
if err != nil {
return err
}

value, err = processPointerValue(ctx, value, n)
value, err = processPointerValue(ctx, value, d)
if err != nil {
return err
}

nquad, u, err := mutations.CreateNQuadAndSchema(value, gid, jsonName, t, n.ID())
nquad, u, err := mutations.CreateNQuadAndSchema(value, gid, jsonName, t, d.ID())
if err != nil {
return err
}
Expand All @@ -111,7 +111,7 @@ func generateSetDqlMutationsAndSchema[T any](ctx context.Context, n *Namespace,
}

sch.Types = append(sch.Types, &pb.TypeUpdate{
TypeName: apiutils.AddNamespace(n.ID(), t.Name()),
TypeName: apiutils.AddNamespace(d.ID(), t.Name()),
Fields: sch.Preds,
})

Expand All @@ -120,7 +120,7 @@ func generateSetDqlMutationsAndSchema[T any](ctx context.Context, n *Namespace,
return err
}
typeNquad := &api.NQuad{
Namespace: n.ID(),
Namespace: d.ID(),
Subject: fmt.Sprint(gid),
Predicate: "dgraph.type",
ObjectValue: val,
Expand All @@ -134,11 +134,11 @@ func generateSetDqlMutationsAndSchema[T any](ctx context.Context, n *Namespace,
return nil
}

func generateDeleteDqlMutations(n *Namespace, gid uint64) []*dql.Mutation {
func generateDeleteDqlMutations(d *DB, gid uint64) []*dql.Mutation {
return []*dql.Mutation{{
Del: []*api.NQuad{
{
Namespace: n.ID(),
Namespace: d.ID(),
Subject: fmt.Sprint(gid),
Predicate: x.Star,
ObjectValue: &api.Value{
Expand Down
Loading
Loading