Adding back the regclass_text overload, for performance reasons, since text->regclass->text conversion is very slow.

Author: fulghum

server/functions/nextval.go

@@ -24,9 +24,36 @@ import (
 
 // initNextVal registers the functions to the catalog.
 func initNextVal() {
+	framework.RegisterFunction(nextval_text)
 	framework.RegisterFunction(nextval_regclass)
 }
 
+// nextval_text represents the PostgreSQL function of the same name, taking the same parameters.
+//
+// TODO: Even though we can implicitly convert a text param to a regclass param, it's an expensive process
+// to convert it to a regclass, then convert the regclass back into the relation name, so we provide an overload
+// that takes a text param directly, in addition to the function form that takes a regclass. Once we can optimize
+// the regclass to text conversion, we can potentially remove this overload.
+var nextval_text = framework.Function1{
+	Name:               "nextval",
+	Return:             pgtypes.Int64,
+	Parameters:         [1]pgtypes.DoltgresType{pgtypes.Text},
+	IsNonDeterministic: true,
+	Strict:             true,
+	Callable: func(ctx *sql.Context, _ [2]pgtypes.DoltgresType, val any) (any, error) {
+		schema, sequence, err := parseRelationName(ctx, val.(string))
+		if err != nil {
+			return nil, err
+		}
+
+		collection, err := core.GetSequencesCollectionFromContext(ctx)
+		if err != nil {
+			return nil, err
+		}
+		return collection.NextVal(schema, sequence)
+	},
+}
+
 // nextval_regclass represents the PostgreSQL function of the same name, taking the same parameters.
 var nextval_regclass = framework.Function1{
 	Name:               "nextval",

server/types/text.go

@@ -106,6 +106,10 @@ func (b TextType) Convert(val any) (any, sql.ConvertInRange, error) {
 
 // Equals implements the DoltgresType interface.
 func (b TextType) Equals(otherType sql.Type) bool {
+	if _, ok := otherType.(TextType); !ok {
+		return false
+	}
+
 	if otherExtendedType, ok := otherType.(types.ExtendedType); ok {
 		return bytes.Equal(MustSerializeType(b), MustSerializeType(otherExtendedType))
 	}