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,252 @@
+// 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 node
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"strings"
+
+	"github.com/cockroachdb/errors"
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/plan"
+	vitess "github.com/dolthub/vitess/go/vt/sqlparser"
+
+	"github.com/dolthub/doltgresql/core"
+	"github.com/dolthub/doltgresql/core/id"
+	"github.com/dolthub/doltgresql/core/sequences"
+	pgexprs "github.com/dolthub/doltgresql/server/expression"
+	"github.com/dolthub/doltgresql/server/functions/framework"
+	"github.com/dolthub/doltgresql/server/tables"
+	pgtypes "github.com/dolthub/doltgresql/server/types"
+)
+
+// CreateSequence handles the CREATE SEQUENCE statement, along with SERIAL type definitions.
+type CreateSequence struct {
+	schema      string
+	ifNotExists bool
+	fromAlter   bool
+	sequence    *sequences.Sequence
+}
+
+var _ sql.ExecSourceRel = (*CreateSequence)(nil)
+var _ vitess.Injectable = (*CreateSequence)(nil)
+
+// NewCreateSequence returns a new *CreateSequence.
+func NewCreateSequence(ifNotExists bool, schema string, fromAlter bool, sequence *sequences.Sequence) *CreateSequence {
+	return &CreateSequence{
+		schema:      schema,
+		ifNotExists: ifNotExists,
+		fromAlter:   fromAlter,
+		sequence:    sequence,
+	}
+}
+
+// Children implements the interface sql.ExecSourceRel.
+func (c *CreateSequence) Children() []sql.Node {
+	return nil
+}
+
+// IsReadOnly implements the interface sql.ExecSourceRel.
+func (c *CreateSequence) IsReadOnly() bool {
+	return false
+}
+
+// Resolved implements the interface sql.ExecSourceRel.
+func (c *CreateSequence) Resolved() bool {
+	return true
+}
+
+// RowIter implements the interface sql.ExecSourceRel.
+func (c *CreateSequence) RowIter(ctx *sql.Context, r sql.Row) (sql.RowIter, error) {
+	if strings.HasPrefix(strings.ToLower(c.sequence.Id.SequenceName()), "dolt") {
+		return nil, errors.Errorf("sequences cannot be prefixed with 'dolt'")
+	}
+	schema, err := core.GetSchemaName(ctx, nil, c.schema)
+	if err != nil {
+		return nil, err
+	}
+	// The sequence won't have the schema filled in, so we have to do that now
+	c.sequence.Id = id.NewSequence(schema, c.sequence.Id.SequenceName())
+
+	// Check that the sequence name is free across all relation types (tables, sequences, views, indexes).
+	// GetSqlDatabaseFromContext returns a plain sqle.Database (not a PgDatabase), so we wrap it
+	// with tables.WrapSqleDatabase before calling GetSchema so that ValidateNewRelationName is available.
+	// TODO: Consider always wrapping the returned db from GetSqlDatabaseFromContext()
+	rawDb, err := core.GetSqlDatabaseFromContext(ctx, "")
+	if err != nil {
+		return nil, err
+	}
+	if rawDb != nil {
+		if sdb, ok := rawDb.(sqle.Database); ok {
+			pgDb := tables.WrapSqleDatabase(sdb)
+			if schemaDb, found, dbErr := pgDb.GetSchema(ctx, schema); dbErr != nil {
+				return nil, dbErr
+			} else if found {
+				if v, ok := schemaDb.(sql.SchemaObjectNameValidator); ok {
+					nameAlreadyUsed, err := v.ValidateNewSequenceName(ctx, c.sequence.Id.SequenceName(), c.ifNotExists)
+					if err != nil {
+						return nil, err
+					} else if nameAlreadyUsed && c.ifNotExists {
+						return sql.RowsToRowIter(), nil
+					}
+				}
+			} else if !found {
+				return nil, fmt.Errorf(`schema "%s" not found`, schema)
+			}
+		}
+	}
+	// Check that the OWNED BY is valid, if it exists
+	var table sql.Table
+	var tableSch sql.Schema
+	var tableColumn *sql.Column
+	if c.sequence.OwnerTable.IsValid() {
+		// The table will only have its name set, so we need to fill in the schema as well
+		c.sequence.OwnerTable = id.NewTable(schema, c.sequence.OwnerTable.TableName())
+		relationType, err := core.GetRelationType(ctx, schema, c.sequence.OwnerTable.TableName())
+		if err != nil {
+			return nil, err
+		}
+		if relationType == core.RelationType_DoesNotExist {
+			return nil, errors.Errorf(`relation "%s" does not exist`, c.sequence.OwnerTable.TableName())
+		} else if relationType != core.RelationType_Table {
+			return nil, errors.Errorf(`sequence cannot be owned by relation "%s"`, c.sequence.OwnerTable.TableName())
+		}
+
+		table, err = core.GetSqlTableFromContext(ctx, "", doltdb.TableName{Name: c.sequence.OwnerTable.TableName(), Schema: schema})
+		if err != nil {
+			return nil, err
+		}
+		if table == nil {
+			return nil, errors.Errorf(`table "%s" cannot be found but says it exists`, c.sequence.OwnerTable.TableName())
+		}
+		tableSch = table.Schema(ctx)
+		for _, col := range tableSch {
+			if col.Name == c.sequence.OwnerColumn {
+				tableColumn = col.Copy()
+				break
+			}
+		}
+		if tableColumn == nil {
+			return nil, errors.Errorf(`column "%s" of relation "%s" does not exist`,
+				c.sequence.OwnerColumn, c.sequence.OwnerTable.TableName())
+		}
+		// If this is from an ALTER TABLE statement, then we have to adjust the type since we didn't have that information earlier
+		if c.fromAlter {
+			dgType, ok := tableColumn.Type.(*pgtypes.DoltgresType)
+			if !ok {
+				return nil, errors.Errorf(`column "%s" of relation "%s" has unexpected type: "%s"`,
+					c.sequence.OwnerColumn, c.sequence.OwnerTable.TableName(), tableColumn.Type.String())
+			}
+			switch dgType.ID {
+			case pgtypes.Int16.ID:
+				c.sequence.DataTypeID = pgtypes.Int16.ID
+				if c.sequence.Minimum < int64(math.MinInt16) {
+					c.sequence.Minimum = int64(math.MinInt16)
+				}
+				if c.sequence.Maximum > int64(math.MaxInt16) {
+					c.sequence.Maximum = int64(math.MaxInt16)
+				}
+			case pgtypes.Int32.ID:
+				c.sequence.DataTypeID = pgtypes.Int32.ID
+				if c.sequence.Minimum < int64(math.MinInt32) {
+					c.sequence.Minimum = int64(math.MinInt32)
+				}
+				if c.sequence.Maximum > int64(math.MaxInt32) {
+					c.sequence.Maximum = int64(math.MaxInt32)
+				}
+			case pgtypes.Int64.ID:
+				c.sequence.DataTypeID = pgtypes.Int64.ID
+				// Minimum and Maximum are already set to the Int64 values
+			default:
+				// Not sure what we should do if we encounter a non-integer type, so we'll error for now
+				return nil, errors.Errorf(`column "%s" of relation "%s" has an unsupported type: "%s"`,
+					c.sequence.OwnerColumn, c.sequence.OwnerTable.TableName(), tableColumn.Type.String())
+			}
+		}
+	}
+	// Create the sequence since we know it's completely valid
+	// TODO: we always create the sequence in the current database, but there's no need to require this, and in fact we
+	//  need to support it to create a sequence on another branch than the current one
+	collection, err := core.GetSequencesCollectionFromContext(ctx, ctx.GetCurrentDatabase())
+	if err != nil {
+		return nil, err
+	}
+	if err = collection.CreateSequence(ctx, c.sequence); err != nil {
+		return nil, err
+	}
+	if c.fromAlter {
+		if tableColumn == nil {
+			// This check is to satisfy the linter
+			return nil, errors.New(`somehow unable to find the matching table column which should have failed a previous step`)
+		}
+		// TODO: What happens when we add a sequence to a column that already has a default value? We'll error until we find out
+		if tableColumn.Default != nil || tableColumn.Generated != nil {
+			return nil, errors.New(`cannot add a sequence to a column that already has a default value`)
+		}
+		alterableTable, ok := table.(*sqle.AlterableDoltTable)
+		if !ok {
+			return nil, errors.Errorf(`expected a Dolt table but received "%T"`, table)
+		}
+		// TODO: Do we need to convert to a TableName and then call String? Are we reliant on the specific way it's formatted?
+		//  This is how it's done in the analyzer for SERIAL types, so assuming it's for a good reason.
+		seqName := doltdb.TableName{Name: c.sequence.Id.SequenceName(), Schema: c.sequence.Id.SchemaName()}.String()
+		nextVal, foundFunc, err := framework.GetFunction(ctx, "nextval", pgexprs.NewTextLiteral(seqName))
+		if err != nil {
+			return nil, err
+		}
+		if !foundFunc {
+			return nil, errors.Errorf(`function "nextval" could not be found`)
+		}
+		tableColumn.Default = &sql.ColumnDefaultValue{
+			Expr:          nextVal,
+			OutType:       tableColumn.Type.(*pgtypes.DoltgresType),
+			Literal:       false,
+			ReturnNil:     false,
+			Parenthesized: false,
+		}
+		err = alterableTable.ModifyColumn(ctx, tableColumn.Name, tableColumn, nil)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return sql.RowsToRowIter(), nil
+}
+
+// Schema implements the interface sql.ExecSourceRel.
+func (c *CreateSequence) Schema(ctx *sql.Context) sql.Schema {
+	return nil
+}
+
+// String implements the interface sql.ExecSourceRel.
+func (c *CreateSequence) String() string {
+	return "CREATE SEQUENCE"
+}
+
+// WithChildren implements the interface sql.ExecSourceRel.
+func (c *CreateSequence) WithChildren(ctx *sql.Context, children ...sql.Node) (sql.Node, error) {
+	return plan.NillaryWithChildren(c, children...)
+}
+
+// WithResolvedChildren implements the interface vitess.Injectable.
+func (c *CreateSequence) WithResolvedChildren(ctx context.Context, children []any) (any, error) {
+	if len(children) != 0 {
+		return nil, ErrVitessChildCount.New(0, len(children))
+	}
+	return c, nil
+}