chore: import upstream snapshot with attribution

2026-07-13 12:32:25 +08:00
commit e014feafe1
2285 changed files with 1131979 additions and 0 deletions
@@ -0,0 +1,134 @@
+// Copyright 2025 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 framework
+
+import (
+	"github.com/dolthub/go-mysql-server/sql"
+
+	"github.com/dolthub/doltgresql/core"
+	"github.com/dolthub/doltgresql/core/extensions"
+	"github.com/dolthub/doltgresql/core/id"
+	pgtypes "github.com/dolthub/doltgresql/server/types"
+)
+
+// FunctionProvider is the special sql.FunctionProvider for Doltgres that allows us to handle functions that
+// are created by users.
+type FunctionProvider struct{}
+
+var _ sql.FunctionProvider = (*FunctionProvider)(nil)
+
+// Function implements the interface sql.FunctionProvider.
+func (fp *FunctionProvider) Function(ctx *sql.Context, schema, name string) (sql.Function, bool) {
+	// TODO: this should be configurable from within Dolt, rather than set on an external variable
+	if !core.IsContextValid(ctx) {
+		return nil, false
+	}
+	funcCollection, err := core.GetFunctionsCollectionFromContext(ctx, "")
+	if err != nil {
+		return nil, false
+	}
+	typesCollection, err := core.GetTypesCollectionFromContext(ctx, "")
+	if err != nil {
+		return nil, false
+	}
+	// TODO: this should search all schemas in the search path, but the search path doesn't handle pg_catalog yet
+	funcName := id.NewFunction("pg_catalog", name)
+	overloads, err := funcCollection.GetFunctionOverloads(ctx, funcName)
+	if err != nil {
+		return nil, false
+	}
+	if len(overloads) == 0 {
+		if schema == "" {
+			currentSchema, err := core.GetCurrentSchema(ctx)
+			if err != nil {
+				return nil, false
+			}
+			schema = currentSchema
+		}
+		funcName = id.NewFunction(schema, name)
+		overloads, err = funcCollection.GetFunctionOverloads(ctx, funcName)
+		if err != nil {
+			return nil, false
+		}
+		if len(overloads) == 0 {
+			return nil, false
+		}
+	}
+
+	overloadTree := NewOverloads()
+	for _, overload := range overloads {
+		returnType, err := typesCollection.GetType(ctx, overload.ReturnType)
+		if err != nil || returnType == nil {
+			return nil, false
+		}
+
+		paramTypes := make([]*pgtypes.DoltgresType, len(overload.ParameterTypes))
+		for i, paramType := range overload.ParameterTypes {
+			paramTypes[i], err = typesCollection.GetType(ctx, paramType)
+			if err != nil || paramTypes[i] == nil {
+				return nil, false
+			}
+		}
+		if len(overload.ExtensionName) > 0 {
+			if err = overloadTree.Add(CFunction{
+				ID:                 overload.ID,
+				ReturnType:         returnType,
+				ParameterTypes:     paramTypes,
+				Variadic:           overload.Variadic,
+				IsNonDeterministic: overload.IsNonDeterministic,
+				Strict:             overload.Strict,
+				ExtensionName:      extensions.LibraryIdentifier(overload.ExtensionName),
+				ExtensionSymbol:    overload.ExtensionSymbol,
+			}); err != nil {
+				return nil, false
+			}
+		} else if len(overload.SQLDefinition) > 0 {
+			if err = overloadTree.Add(SQLFunction{
+				ID:                 overload.ID,
+				ReturnType:         returnType,
+				ParameterNames:     overload.ParameterNames,
+				ParameterTypes:     paramTypes,
+				ParameterDefaults:  overload.ParameterDefaults,
+				Variadic:           overload.Variadic,
+				IsNonDeterministic: overload.IsNonDeterministic,
+				Strict:             overload.Strict,
+				SqlStatement:       overload.SQLDefinition,
+				SetOf:              overload.SetOf,
+			}); err != nil {
+				return nil, false
+			}
+		} else {
+			if err = overloadTree.Add(InterpretedFunction{
+				ID:                 overload.ID,
+				ReturnType:         returnType,
+				ParameterNames:     overload.ParameterNames,
+				ParameterTypes:     paramTypes,
+				Variadic:           overload.Variadic,
+				IsNonDeterministic: overload.IsNonDeterministic,
+				Strict:             overload.Strict,
+				SRF:                overload.SetOf,
+				Statements:         overload.Operations,
+			}); err != nil {
+				return nil, false
+			}
+		}
+	}
+	return sql.FunctionN{
+		Name: name,
+		Fn: func(ctx *sql.Context, params ...sql.Expression) (sql.Expression, error) {
+			return NewCompiledFunction(ctx, name, params, overloadTree, false), nil
+		},
+	}, true
+}