refactor: Decouple db.db from gql (sourcenetwork#912)

* Replace relationManager call with collection logic

Removes odd function from collection/db abi that uses gql schema manager for internal query logic.

* Decouple db type from gql parser

Decouples the `defra.db` type from the gql.parser, allowing other query languages to (in theory) be swapped in instead.  Does not expose this decoupling to users, as that requires futher thought and design.

* Remove misuse of mapper types from collection func

Function now uses the request model.  Keeps things more cleanly seperated, at a small performance cost.

* Rename planner constructor

* Remove unhelpful func

* Remove executor

* Move mapper internal to planner

Declares it's usage to be internal to the planner package, hopefull discouraging it's usage outside, and hopefully clarifying it's purpose. Is a straight cut-paste, no logic has changed in this commit.

Author: AndrewSisley

client/db.go

@@ -26,7 +26,6 @@ type DB interface {
 	GetCollectionByName(context.Context, string) (Collection, error)
 	GetCollectionBySchemaID(context.Context, string) (Collection, error)
 	GetAllCollections(ctx context.Context) ([]Collection, error)
-	GetRelationshipIdField(fieldName, targetType, thisType string) (string, error)
 
 	Root() ds.Batching
 	Blockstore() blockstore.Blockstore

client/descriptions.go

@@ -40,6 +40,18 @@ func (col CollectionDescription) GetField(name string) (FieldDescription, bool)
 	return FieldDescription{}, false
 }
 
+// GetRelation returns the field that supports the relation of the given name.
+func (col CollectionDescription) GetRelation(name string) (FieldDescription, bool) {
+	if !col.Schema.IsEmpty() {
+		for _, field := range col.Schema.Fields {
+			if field.RelationName == name {
+				return field, true
+			}
+		}
+	}
+	return FieldDescription{}, false
+}
+
 func (col CollectionDescription) GetPrimaryIndex() IndexDescription {
 	return col.Indexes[0]
 }

core/parser.go

@@ -0,0 +1,52 @@
+// Copyright 2022 Democratized Data Foundation
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package core
+
+import (
+	"context"
+
+	"github.com/sourcenetwork/defradb/client"
+	"github.com/sourcenetwork/defradb/client/request"
+)
+
+type SchemaDefinition struct {
+	// The name of this schema definition.
+	Name string
+
+	// The serialized definition of this schema definition.
+	// todo: this needs to be properly typed and handled according to
+	// https://github.com/sourcenetwork/defradb/issues/863
+	Body []byte
+}
+
+type Schema struct {
+	// The individual declarations of types defined by this schema.
+	Definitions []SchemaDefinition
+
+	// The collection descriptions created from/defined by this schema.
+	Descriptions []client.CollectionDescription
+}
+
+// Parser represents the object responsible for handling stuff specific to
+// a query language.  This includes schema and query parsing, and introspection.
+type Parser interface {
+	// Returns true if the given string is an introspection request.
+	IsIntrospection(request string) bool
+
+	// Executes the given introspection request.
+	ExecuteIntrospection(request string) *client.QueryResult
+
+	// Parses the given request, returning a strongly typed model of that request.
+	Parse(request string) (*request.Request, []error)
+
+	// Adds the given schema to this parser's model.
+	AddSchema(ctx context.Context, schema string) (*Schema, error)
+}

db/collection_update.go

@@ -23,7 +23,6 @@ import (
 	"github.com/sourcenetwork/defradb/core"
 	"github.com/sourcenetwork/defradb/datastore"
 	"github.com/sourcenetwork/defradb/errors"
-	"github.com/sourcenetwork/defradb/mapper"
 	"github.com/sourcenetwork/defradb/planner"
 	"github.com/sourcenetwork/defradb/query/graphql/parser"
 )
@@ -598,81 +597,64 @@ func (c *collection) makeSelectionQuery(
 	txn datastore.Txn,
 	filter any,
 ) (planner.Query, error) {
-	mapping := c.createMapping()
-	var f *mapper.Filter
+	var f client.Option[request.Filter]
 	var err error
 	switch fval := filter.(type) {
 	case string:
 		if fval == "" {
 			return nil, errors.New("invalid filter")
 		}
-		var p client.Option[request.Filter]
-		p, err = parser.NewFilterFromString(fval)
+
+		f, err = parser.NewFilterFromString(fval)
 		if err != nil {
 			return nil, err
 		}
-		f = mapper.ToFilter(p, mapping)
-	case *mapper.Filter:
+	case client.Option[request.Filter]:
 		f = fval
 	default:
 		return nil, errors.New("invalid filter")
 	}
 	if filter == "" {
 		return nil, errors.New("invalid filter")
 	}
-	slct, err := c.makeSelectLocal(f, mapping)
+	slct, err := c.makeSelectLocal(f)
 	if err != nil {
 		return nil, err
 	}
 
-	return c.db.queryExecutor.MakeSelectQuery(ctx, c.db, txn, slct)
+	planner := planner.New(ctx, c.db, txn)
+	return planner.MakePlan(&request.Request{
+		Queries: []*request.OperationDefinition{
+			{
+				Selections: []request.Selection{
+					slct,
+				},
+			},
+		},
+	})
 }
 
-func (c *collection) makeSelectLocal(filter *mapper.Filter, mapping *core.DocumentMapping) (*mapper.Select, error) {
-	slct := &mapper.Select{
-		Targetable: mapper.Targetable{
-			Field: mapper.Field{
-				Name: c.Name(),
-			},
-			Filter: filter,
+func (c *collection) makeSelectLocal(filter client.Option[request.Filter]) (*request.Select, error) {
+	slct := &request.Select{
+		Field: request.Field{
+			Name: c.Name(),
 		},
-		Fields:          make([]mapper.Requestable, len(c.desc.Schema.Fields)),
-		DocumentMapping: *mapping,
+		Filter: filter,
+		Fields: make([]request.Selection, 0),
 	}
 
 	for _, fd := range c.Schema().Fields {
 		if fd.IsObject() {
 			continue
 		}
-		index := int(fd.ID)
-		slct.Fields = append(slct.Fields, &mapper.Field{
-			Index: index,
-			Name:  fd.Name,
+		slct.Fields = append(slct.Fields, &request.Field{
+			Name: fd.Name,
 		})
 	}
 
 	return slct, nil
 }
 
-func (c *collection) createMapping() *core.DocumentMapping {
-	mapping := core.NewDocumentMapping()
-	mapping.Add(core.DocKeyFieldIndex, request.DocKeyFieldName)
-	for _, fd := range c.Schema().Fields {
-		if fd.IsObject() {
-			continue
-		}
-		index := int(fd.ID)
-		mapping.Add(index, fd.Name)
-		mapping.RenderKeys = append(mapping.RenderKeys,
-			core.RenderKey{
-				Index: index,
-				Key:   fd.Name,
-			},
-		)
-	}
-	return mapping
-}
-
 // getTypeAndCollectionForPatch parses the Patch op path values
 // and compares it against the collection schema.
 // If it's within the schema, then patchIsSubType is false

db/db.go

@@ -30,8 +30,7 @@ import (
 	"github.com/sourcenetwork/defradb/events"
 	"github.com/sourcenetwork/defradb/logging"
 	"github.com/sourcenetwork/defradb/merkle/crdt"
-	"github.com/sourcenetwork/defradb/planner"
-	"github.com/sourcenetwork/defradb/query/graphql/schema"
+	"github.com/sourcenetwork/defradb/query/graphql"
 )
 
 var (
@@ -61,8 +60,7 @@ type db struct {
 
 	events client.Events
 
-	schema        *schema.SchemaManager
-	queryExecutor *planner.QueryExecutor
+	parser core.Parser
 
 	// The options used to init the database
 	options any
@@ -92,14 +90,7 @@ func newDB(ctx context.Context, rootstore ds.Batching, options ...Option) (*db,
 	multistore := datastore.MultiStoreFrom(root)
 	crdtFactory := crdt.DefaultFactory.WithStores(multistore)
 
-	log.Debug(ctx, "Loading: schema manager")
-	sm, err := schema.NewSchemaManager()
-	if err != nil {
-		return nil, err
-	}
-
-	log.Debug(ctx, "Loading: query executor")
-	exec, err := planner.NewQueryExecutor(sm)
+	parser, err := graphql.NewParser()
 	if err != nil {
 		return nil, err
 	}
@@ -110,9 +101,8 @@ func newDB(ctx context.Context, rootstore ds.Batching, options ...Option) (*db,
 
 		crdtFactory: &crdtFactory,
 
-		schema:        sm,
-		queryExecutor: exec,
-		options:       options,
+		parser:  parser,
+		options: options,
 	}
 
 	// apply options
@@ -190,23 +180,6 @@ func (db *db) PrintDump(ctx context.Context) error {
 	return printStore(ctx, db.multistore.Rootstore())
 }
 
-func (db *db) Executor() *planner.QueryExecutor {
-	return db.queryExecutor
-}
-
-func (db *db) GetRelationshipIdField(fieldName, targetType, thisType string) (string, error) {
-	rm := db.schema.Relations
-	rel := rm.GetRelationByDescription(fieldName, targetType, thisType)
-	if rel == nil {
-		return "", errors.New("relation does not exists")
-	}
-	subtypefieldname, _, ok := rel.GetFieldFromSchemaType(targetType)
-	if !ok {
-		return "", errors.New("relation is missing referenced field")
-	}
-	return subtypefieldname, nil
-}
-
 // Close is called when we are shutting down the database.
 // This is the place for any last minute cleanup or releasing of resources (i.e.: Badger instance).
 func (db *db) Close(ctx context.Context) {

db/query.go

@@ -14,10 +14,9 @@ import (
 	"context"
 	"strings"
 
-	gql "github.com/graphql-go/graphql"
-
 	"github.com/sourcenetwork/defradb/client"
 	"github.com/sourcenetwork/defradb/datastore"
+	"github.com/sourcenetwork/defradb/planner"
 )
 
 func (db *db) ExecQuery(ctx context.Context, query string) *client.QueryResult {
@@ -34,7 +33,18 @@ func (db *db) ExecQuery(ctx context.Context, query string) *client.QueryResult {
 	}
 	defer txn.Discard(ctx)
 
-	results, err := db.queryExecutor.ExecQuery(ctx, db, txn, query)
+	request, errors := db.parser.Parse(query)
+	if len(errors) > 0 {
+		errorStrings := make([]any, len(errors))
+		for i, err := range errors {
+			errorStrings[i] = err.Error()
+		}
+		res.Errors = errorStrings
+		return res
+	}
+
+	planner := planner.New(ctx, db, txn)
+	results, err := planner.RunRequest(ctx, request)
 	if err != nil {
 		res.Errors = []any{err.Error()}
 		return res
@@ -54,13 +64,24 @@ func (db *db) ExecTransactionalQuery(
 	query string,
 	txn datastore.Txn,
 ) *client.QueryResult {
-	res := &client.QueryResult{}
-	// check if its Introspection query
-	if strings.Contains(query, "IntrospectionQuery") {
+	if db.parser.IsIntrospection(query) {
 		return db.ExecIntrospection(query)
 	}
 
-	results, err := db.queryExecutor.ExecQuery(ctx, db, txn, query)
+	res := &client.QueryResult{}
+
+	request, errors := db.parser.Parse(query)
+	if len(errors) > 0 {
+		errorStrings := make([]any, len(errors))
+		for i, err := range errors {
+			errorStrings[i] = err.Error()
+		}
+		res.Errors = errorStrings
+		return res
+	}
+
+	planner := planner.New(ctx, db, txn)
+	results, err := planner.RunRequest(ctx, request)
 	if err != nil {
 		res.Errors = []any{err.Error()}
 		return res
@@ -71,20 +92,5 @@ func (db *db) ExecTransactionalQuery(
 }
 
 func (db *db) ExecIntrospection(query string) *client.QueryResult {
-	schema := db.schema.Schema()
-	// t := schema.Type("userFilterArg")
-	// spew.Dump(t.(*gql.InputObject).Fields())
-	params := gql.Params{Schema: *schema, RequestString: query}
-	r := gql.Do(params)
-
-	res := &client.QueryResult{
-		Data:   r.Data,
-		Errors: make([]any, len(r.Errors)),
-	}
-
-	for i, err := range r.Errors {
-		res.Errors[i] = err
-	}
-
-	return res
+	return db.parser.ExecuteIntrospection(query)
 }