Merge branch 'main' into zachmu/cross-schema-fks

Author: zachmu

core/rootvalue.go

@@ -303,6 +303,16 @@ func (root *RootValue) GetTableNames(ctx context.Context, schemaName string) ([]
 // HandlePostMerge implements the interface doltdb.RootValue.
 func (root *RootValue) HandlePostMerge(ctx context.Context, ourRoot, theirRoot, ancRoot doltdb.RootValue) (doltdb.RootValue, error) {
 	// Handle sequences
+	_, err := root.handlePostSequencesMerge(ctx, ourRoot, theirRoot, ancRoot)
+	if err != nil {
+		return nil, err
+	}
+	// Handle types
+	return root.handlePostTypesMerge(ctx, ourRoot, theirRoot, ancRoot)
+}
+
+// handlePostSequencesMerge merges sequences.
+func (root *RootValue) handlePostSequencesMerge(ctx context.Context, ourRoot, theirRoot, ancRoot doltdb.RootValue) (doltdb.RootValue, error) {
 	ourSequence, err := ourRoot.(*RootValue).GetSequences(ctx)
 	if err != nil {
 		return nil, err
@@ -322,6 +332,27 @@ func (root *RootValue) HandlePostMerge(ctx context.Context, ourRoot, theirRoot,
 	return root.PutSequences(ctx, mergedSequence)
 }
 
+// handlePostTypesMerge merges types.
+func (root *RootValue) handlePostTypesMerge(ctx context.Context, ourRoot, theirRoot, ancRoot doltdb.RootValue) (doltdb.RootValue, error) {
+	ourTypes, err := ourRoot.(*RootValue).GetTypes(ctx)
+	if err != nil {
+		return nil, err
+	}
+	theirTypes, err := theirRoot.(*RootValue).GetTypes(ctx)
+	if err != nil {
+		return nil, err
+	}
+	ancTypes, err := ancRoot.(*RootValue).GetTypes(ctx)
+	if err != nil {
+		return nil, err
+	}
+	mergedTypes, err := typecollection.Merge(ctx, ourTypes, theirTypes, ancTypes)
+	if err != nil {
+		return nil, err
+	}
+	return root.PutTypes(ctx, mergedTypes)
+}
+
 // HashOf implements the interface doltdb.RootValue.
 func (root *RootValue) HashOf() (hash.Hash, error) {
 	if root.hash.IsEmpty() {

core/typecollection/merge.go

@@ -0,0 +1,68 @@
+// Copyright 2024 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package typecollection
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/dolthub/doltgresql/server/types"
+)
+
+// Merge handles merging sequences on our root and their root.
+func Merge(ctx context.Context, ourCollection, theirCollection, ancCollection *TypeCollection) (*TypeCollection, error) {
+	mergedCollection := ourCollection.Clone()
+	err := theirCollection.IterateTypes(func(schema string, theirType *types.Type) error {
+		// If we don't have the type, then we simply add it
+		mergedType, exists := mergedCollection.GetType(schema, theirType.Name)
+		if !exists {
+			newSeq := *theirType
+			return mergedCollection.CreateType(schema, &newSeq)
+		}
+
+		// Different types with the same name cannot be merged. (e.g.: 'domain' type and 'base' type with the same name)
+		if mergedType.TypType != theirType.TypType {
+			return fmt.Errorf(`cannot merge type "%s" because type types do not match: '%s' and '%s'"`, theirType.Name, mergedType.TypType, theirType.TypType)
+		}
+
+		switch theirType.TypType {
+		case types.TypeType_Domain:
+			if mergedType.BaseTypeOID != theirType.BaseTypeOID {
+				// TODO: we can extend on this in the future (e.g.: maybe uses preferred type?)
+				return fmt.Errorf(`base types of domain type "%s" do not match`, theirType.Name)
+			}
+			if mergedType.Default == "" {
+				mergedType.Default = theirType.Default
+			} else if theirType.Default != "" && mergedType.Default != theirType.Default {
+				return fmt.Errorf(`default values of domain type "%s" do not match`, theirType.Name)
+			}
+			// if either of types defined as NOT NULL, take NOT NULL
+			if mergedType.NotNull || theirType.NotNull {
+				mergedType.NotNull = true
+			}
+			if len(theirType.Checks) > 0 {
+				// TODO: check for duplicate check constraints
+				mergedType.Checks = append(mergedType.Checks, theirType.Checks...)
+			}
+		default:
+			// TODO: support merge for other types. (base, range, etc.)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return mergedCollection, nil
+}

core/typecollection/serialization.go

@@ -46,12 +46,13 @@ func (pgs *TypeCollection) Serialize(ctx context.Context) ([]byte, error) {
 		writer.VariableUint(uint64(len(nameMapKeys)))
 		for _, nameMapKey := range nameMapKeys {
 			typ := nameMap[nameMapKey]
+			writer.Uint32(typ.Oid)
 			writer.String(typ.Name)
 			writer.String(typ.Owner)
 			writer.Int16(typ.Length)
 			writer.Bool(typ.PassedByVal)
-			writer.String(string(typ.Typ))
-			writer.String(string(typ.Category))
+			writer.String(string(typ.TypType))
+			writer.String(string(typ.TypCategory))
 			writer.Bool(typ.IsPreferred)
 			writer.Bool(typ.IsDefined)
 			writer.String(typ.Delimiter)
@@ -110,13 +111,14 @@ func Deserialize(ctx context.Context, data []byte) (*TypeCollection, error) {
 		numOfTypes := reader.VariableUint()
 		nameMap := make(map[string]*types.Type)
 		for j := uint64(0); j < numOfTypes; j++ {
-			typ := &types.Type{}
+			typ := &types.Type{Schema: schemaName}
+			typ.Oid = reader.Uint32()
 			typ.Name = reader.String()
 			typ.Owner = reader.String()
 			typ.Length = reader.Int16()
 			typ.PassedByVal = reader.Bool()
-			typ.Typ = types.TypeType(reader.String())
-			typ.Category = types.TypeCategory(reader.String())
+			typ.TypType = types.TypeType(reader.String())
+			typ.TypCategory = types.TypeCategory(reader.String())
 			typ.IsPreferred = reader.Bool()
 			typ.IsDefined = reader.Bool()
 			typ.Delimiter = reader.String()

core/typecollection/typecollection.go

@@ -48,7 +48,7 @@ func (pgs *TypeCollection) GetDomainType(schName, typName string) (*types.Type,
 	defer pgs.mutex.RUnlock()
 
 	if nameMap, ok := pgs.schemaMap[schName]; ok {
-		if typ, ok := nameMap[typName]; ok && typ.Typ == types.TypeType_Domain {
+		if typ, ok := nameMap[typName]; ok && typ.TypType == types.TypeType_Domain {
 			return typ, true
 		}
 	}

postgres/parser/parser/parse.go

@@ -38,6 +38,7 @@ import (
 	"strings"
 
 	"github.com/cockroachdb/errors"
+	vitess "github.com/dolthub/vitess/go/vt/sqlparser"
 
 	"github.com/dolthub/doltgresql/postgres/parser/pgcode"
 	"github.com/dolthub/doltgresql/postgres/parser/pgerror"
@@ -120,8 +121,10 @@ func (p *Parser) parseOneWithDepth(depth int, sql string) (Statement, error) {
 	if err != nil {
 		return Statement{}, err
 	}
-	if len(stmts) != 1 {
+	if len(stmts) > 1 {
 		return Statement{}, errors.AssertionFailedf("expected 1 statement, but found %d", len(stmts))
+	} else if len(stmts) == 0 {
+		return Statement{}, vitess.ErrEmpty
 	}
 	return stmts[0], nil
 }

postgres/parser/parser/sql/sql_parser.go

@@ -56,7 +56,7 @@ func (p *PostgresParser) ParseWithOptions(ctx context.Context, query string, del
 		return nil, "", "", fmt.Errorf("only a single statement at a time is currently supported")
 	}
 	if len(stmts) == 0 {
-		return nil, q, "", nil
+		return nil, q, "", vitess.ErrEmpty
 	}
 
 	vitessAST, err := ast.Convert(stmts[0])

server/ast/drop_domain.go

@@ -20,26 +20,28 @@ import (
 	vitess "github.com/dolthub/vitess/go/vt/sqlparser"
 
 	"github.com/dolthub/doltgresql/postgres/parser/sem/tree"
+	pgnodes "github.com/dolthub/doltgresql/server/node"
 )
 
 // nodeDropDomain handles *tree.DropDomain nodes.
 func nodeDropDomain(node *tree.DropDomain) (vitess.Statement, error) {
-	return nil, fmt.Errorf("DROP DOMAIN is not supported yet")
-	//if node == nil {
-	//	return nil, nil
-	//}
-	//if len(node.Names) != 1 {
-	//	return nil, fmt.Errorf("dropping multiple domains in DROP DOMAIN is not yet supported")
-	//}
-	//name, err := nodeTableName(&node.Names[0])
-	//if err != nil {
-	//	return nil, err
-	//}
-	//if len(name.DbQualifier.String()) > 0 {
-	//	return nil, fmt.Errorf("DROP DOMAIN is currently only supported for the current database")
-	//}
-	//return vitess.InjectedStatement{
-	//	Statement: pgnodes.NewDropDomain(node.IfExists, name.SchemaQualifier.String(), name.Name.String(), node.DropBehavior == tree.DropCascade),
-	//	Children:  nil,
-	//}, nil
+	if node == nil {
+		return nil, nil
+	}
+	if len(node.Names) != 1 {
+		return nil, fmt.Errorf("dropping multiple domains in DROP DOMAIN is not yet supported")
+	}
+	name, err := nodeTableName(&node.Names[0])
+	if err != nil {
+		return nil, err
+	}
+	return vitess.InjectedStatement{
+		Statement: pgnodes.NewDropDomain(
+			node.IfExists,
+			name.DbQualifier.String(),
+			name.SchemaQualifier.String(),
+			name.Name.String(),
+			node.DropBehavior == tree.DropCascade),
+		Children: nil,
+	}, nil
 }

server/functions/current_schema.go

@@ -18,6 +18,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/doltgresql/server/functions/framework"
+	"github.com/dolthub/doltgresql/server/settings"
 	pgtypes "github.com/dolthub/doltgresql/server/types"
 )
 
@@ -33,7 +34,7 @@ var current_schema = framework.Function0{
 	IsNonDeterministic: true,
 	Strict:             true,
 	Callable: func(ctx *sql.Context) (any, error) {
-		schemas, err := GetCurrentSchemas(ctx)
+		schemas, err := settings.GetCurrentSchemas(ctx)
 		if err != nil {
 			return nil, err
 		}

server/functions/current_schemas.go

@@ -15,12 +15,11 @@
 package functions
 
 import (
-	"strings"
-
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/doltgresql/postgres/parser/sessiondata"
 	"github.com/dolthub/doltgresql/server/functions/framework"
+	"github.com/dolthub/doltgresql/server/settings"
 	pgtypes "github.com/dolthub/doltgresql/server/types"
 )
 
@@ -41,7 +40,7 @@ var current_schemas = framework.Function1{
 		if val.(bool) {
 			schemas = append(schemas, sessiondata.PgCatalogName)
 		}
-		searchPaths, err := GetCurrentSchemas(ctx)
+		searchPaths, err := settings.GetCurrentSchemas(ctx)
 		if err != nil {
 			return nil, err
 		}
@@ -51,24 +50,3 @@ var current_schemas = framework.Function1{
 		return schemas, nil
 	},
 }
-
-// GetCurrentSchemas returns all the schemas in the search_path setting, with elements like "$user" excluded
-func GetCurrentSchemas(ctx *sql.Context) ([]string, error) {
-	searchPathVar, err := ctx.GetSessionVariable(ctx, "search_path")
-	if err != nil {
-		return nil, err
-	}
-
-	pathElems := strings.Split(searchPathVar.(string), ",")
-	var path []string
-
-	for _, schemaName := range pathElems {
-		schemaName = strings.Trim(schemaName, " ")
-		if schemaName == "\"$user\"" {
-			continue
-		}
-		path = append(path, schemaName)
-	}
-
-	return path, nil
-}

server/functions/init.go

@@ -106,6 +106,7 @@ func Init() {
 	initRpad()
 	initRtrim()
 	initScale()
+	initSetConfig()
 	initSetVal()
 	initShobjDescription()
 	initSign()