sql: add ALTER TABLE ... SET SCHEMA to the declerative schema changer

This change adds support for `ALTER TABLE ... SET SCHEMA` to the
declarative schema changer. Before, this operation was ran by the
legacy schema changer.

Epic CRDB-31281

Fixes #155989
Release note (sql change): `ALTER TABLE ... SET SCHEMA` is supported by
the declerative schema changer.

Author: shghasemi

pkg/ccl/schemachangerccl/sctestbackupccl/backup_base_generated_test.go

@@ -249,8 +249,9 @@ USE defaultdb;
 			dscExpectedErr: `pq: cannot rename relation "defaultdb.public.t" because function "f" depends on it`,
 		},
 		{
-			stmt:        "ALTER TABLE t SET SCHEMA test_sc",
-			expectedErr: `pq: cannot set schema on relation "t" because function "f" depends on it`,
+			stmt:           "ALTER TABLE t SET SCHEMA test_sc",
+			expectedErr:    `pq: cannot set schema on relation "t" because function "f" depends on it`,
+			dscExpectedErr: `pq: cannot set schema on relation "defaultdb.public.t" because function "f" depends on it`,
 		},
 		{
 			stmt:        "ALTER TABLE t DROP COLUMN d",

pkg/sql/drop_function_test.go

@@ -4508,6 +4508,24 @@ RESET create_table_with_schema_locked
 
 subtest end
 
+subtest alter_table_set_schema
+
+statement ok
+CREATE TABLE non_public (c int);
+CREATE SCHEMA sc1;
+SELECT * FROM non_public;
+ALTER TABLE non_public SET SCHEMA sc1;
+
+statement error pgcode 42P01 relation "non_public" does not exist
+SELECT * FROM non_public
+
+statement ok
+SELECT * from sc1.non_public;
+DROP TABLE sc1.non_public;
+DROP SCHEMA sc1;
+
+subtest end
+
 subtest alter_primary_key_using_dropped_column
 
 statement ok

pkg/sql/logictest/testdata/logic_test/alter_table

@@ -21,6 +21,7 @@ go_library(
         "alter_table_rename_column.go",
         "alter_table_rename_constraint.go",
         "alter_table_set_rls_mode.go",
+        "alter_table_set_schema.go",
         "alter_table_validate_constraint.go",
         "comment_on.go",
         "configure_zone.go",

pkg/sql/schemachanger/scbuild/internal/scbuildstmt/BUILD.bazel

@@ -0,0 +1,106 @@
+// Copyright 2025 The Cockroach Authors.
+//
+// Use of this software is governed by the CockroachDB Software License
+// included in the /LICENSE file.
+
+package scbuildstmt
+
+import (
+	"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgcode"
+	"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgerror"
+	"github.com/cockroachdb/cockroach/pkg/sql/privilege"
+	"github.com/cockroachdb/cockroach/pkg/sql/schemachanger/scpb"
+	"github.com/cockroachdb/cockroach/pkg/sql/sem/catid"
+	"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
+)
+
+// AlterTableSetSchema implements ALTER TABLE ... SET SCHEMA ... for the declarative schema changer.
+// It sets the schema for a table, view, or sequence.
+// Requires privileges: DROP on source table/view/sequence, CREATE on destination schema.
+func AlterTableSetSchema(b BuildCtx, n *tree.AlterTableSetSchema) {
+	// Resolve any type of object
+	elts := b.ResolveRelation(n.Name, ResolveParams{
+		IsExistenceOptional: n.IfExists,
+		RequiredPrivilege:   privilege.DROP,
+	})
+	// IF EXISTS was specified, and the object doesn't exist, so this is a no-op.
+	if elts == nil && n.IfExists {
+		return
+	}
+	// Validate the object type matches what was requested.
+	validateObjectType(elts, n.Name.ToTableName().ObjectName, n.IsSequence, n.IsView, n.IsMaterialized)
+
+	// get descId based on type to retrieve the namespace
+	descID, element, isTemp := getAlterTableTargetElement(elts)
+	// Ensure that table is not temporary
+	if isTemp {
+		panic(pgerror.Newf(pgcode.FeatureNotSupported,
+			"cannot move objects into or out of temporary schemas"))
+	}
+	// Get the fully qualified object name.
+	currName := getAlterTableQualifiedObjectName(n.Name, b)
+	newName := currName
+	newName.SchemaName = n.Schema
+	// Check for name-based dependencies
+	checkNameBasedDependencies(b, descID, element, currName, "set schema on")
+
+	// Get the schema ID directly from the namespace element
+	currNamespace := mustRetrieveNamespaceElem(b, descID)
+	currSchemaID := currNamespace.SchemaID
+	newSchema := resolveSchemaByName(b, n.Schema, currNamespace.DatabaseID)
+	newSchemaID := newSchema.SchemaID
+	// Ensure that new schema is not temporary or virtual
+	panicIfSchemaIsTemporaryOrVirtual(newSchema)
+	// If new schema is the same as the curr schema, do a no-op
+	if currSchemaID == newSchemaID {
+		return
+	}
+
+	// Increment telemetry counter
+	b.IncrementSchemaChangeAlterCounter(tree.GetTableType(n.IsSequence, n.IsView, n.IsMaterialized), n.TelemetryName())
+	// Check for name conflicts
+	checkTableNameConflicts(b, currName, newName, currNamespace)
+
+	// drop the old namespace and add a new one
+	newNamespace := *currNamespace
+	newNamespace.SchemaID = newSchemaID
+	b.Drop(currNamespace)
+	b.Add(&newNamespace)
+
+	// drop old schema child and add new one
+	currSchemaChild := b.QueryByID(descID).FilterSchemaChild().MustGetOneElement()
+	newSchemaChild := scpb.SchemaChild{
+		ChildObjectID: descID,
+		SchemaID:      newSchemaID,
+	}
+	b.Drop(currSchemaChild)
+	b.Add(&newSchemaChild)
+
+}
+
+func resolveSchemaByName(b BuildCtx, schemaName tree.Name, databaseID catid.DescID) *scpb.Schema {
+	dbElts := b.QueryByID(databaseID)
+	dbNamespace := dbElts.FilterNamespace().MustGetOneElement()
+	// Resolve the new schema to get its elements
+	newSchemaPrefix := tree.ObjectNamePrefix{
+		CatalogName:     tree.Name(dbNamespace.Name),
+		SchemaName:      schemaName,
+		ExplicitCatalog: true,
+		ExplicitSchema:  true,
+	}
+	newSchema := b.ResolveSchema(newSchemaPrefix, ResolveParams{
+		RequiredPrivilege: privilege.CREATE,
+	}).FilterSchema().MustGetOneElement()
+	return newSchema
+}
+
+func panicIfSchemaIsTemporaryOrVirtual(newSchema *scpb.Schema) {
+	if newSchema.IsTemporary {
+		panic(pgerror.Newf(pgcode.FeatureNotSupported,
+			"cannot move objects into or out of temporary schemas"))
+	}
+	if newSchema.IsVirtual {
+		panic(pgerror.Newf(pgcode.FeatureNotSupported,
+			"cannot move objects into or out of virtual schemas"))
+	}
+}

pkg/sql/schemachanger/scbuild/internal/scbuildstmt/alter_table_set_schema.go

@@ -73,6 +73,7 @@ var supportedStatements = map[reflect.Type]supportedStatement{
 	reflect.TypeOf((*tree.SetZoneConfig)(nil)):       {fn: SetZoneConfig, statementTags: []string{tree.ConfigureZoneTag}, on: true, checks: isV251Active},
 	reflect.TypeOf((*tree.Truncate)(nil)):            {fn: Truncate, statementTags: []string{tree.TruncateTag}, on: true, checks: isV254Active},
 	reflect.TypeOf((*tree.RenameTable)(nil)):         {fn: RenameTable, statementTags: []string{tree.AlterTableTag}, on: true, checks: isV254Active},
+	reflect.TypeOf((*tree.AlterTableSetSchema)(nil)): {fn: AlterTableSetSchema, statementTags: []string{tree.AlterTableTag}, on: true, checks: isV261Active},
 }
 
 // supportedStatementTags tracks statement tags which are implemented

pkg/sql/schemachanger/scbuild/internal/scbuildstmt/process.go

@@ -32,43 +32,16 @@ func RenameTable(b BuildCtx, n *tree.RenameTable) {
 	}
 
 	// Validate the object type matches what was requested.
-	validateObjectType(elts, n)
+	validateObjectType(elts, n.Name.ToTableName().ObjectName, n.IsSequence, n.IsView, n.IsMaterialized)
 
 	// Get the fully qualified object name.
-	objectName := n.Name.ToTableName()
-	dbElts, scElts := b.ResolveTargetObject(n.Name, privilege.CREATE /* this should be 0 */)
-	_, _, scName := scpb.FindNamespace(scElts)
-	_, _, dbname := scpb.FindNamespace(dbElts)
-	objectName.SchemaName = tree.Name(scName.Name)
-	objectName.CatalogName = tree.Name(dbname.Name)
-	objectName.ExplicitCatalog = true
-	objectName.ExplicitSchema = true
+	objectName := getAlterTableQualifiedObjectName(n.Name, b)
 
 	// Get the descriptor ID for further processing.
-	var targetDescriptorID catid.DescID
-	var targetElement scpb.Element
-	_, _, tbl := scpb.FindTable(elts)
-	if tbl != nil {
-		targetElement = tbl
-		targetDescriptorID = tbl.TableID
-	}
-	if n.IsView || targetDescriptorID == 0 {
-		_, _, view := scpb.FindView(elts)
-		if view != nil {
-			targetElement = view
-			targetDescriptorID = view.ViewID
-		}
-	}
-	if n.IsSequence || targetDescriptorID == 0 {
-		_, _, seq := scpb.FindSequence(elts)
-		if seq != nil {
-			targetElement = seq
-			targetDescriptorID = seq.SequenceID
-		}
-	}
+	targetDescriptorID, targetElement, _ := getAlterTableTargetElement(elts)
 
 	// Check for name-based dependencies that would prevent renaming.
-	checkNameBasedDependencies(b, targetDescriptorID, targetElement, objectName)
+	checkNameBasedDependencies(b, targetDescriptorID, targetElement, objectName, "rename")
 
 	// Need CREATE privilege on database to match legacy schema changer behavior.
 	b.ResolveDatabase(objectName.CatalogName, ResolveParams{RequiredPrivilege: privilege.CREATE})
@@ -104,6 +77,7 @@ func RenameTable(b BuildCtx, n *tree.RenameTable) {
 	newName.ExplicitCatalog = true
 	newName.ExplicitSchema = true
 	checkTableNameConflicts(b, objectName, newName, currentNS)
+	validateTableRename(b, objectName, newName)
 
 	// Check if the new name is the same as the old name (no-op case).
 	if currentNS.Name == string(newName.ObjectName) {
@@ -129,6 +103,18 @@ func RenameTable(b BuildCtx, n *tree.RenameTable) {
 	b.LogEventForExistingPayload(newNS, renameEvent)
 }
 
+func getAlterTableQualifiedObjectName(name *tree.UnresolvedObjectName, b BuildCtx) tree.TableName {
+	objectName := name.ToTableName()
+	dbElts, scElts := b.ResolveTargetObject(name, privilege.CREATE /* this should be 0 */)
+	_, _, scName := scpb.FindNamespace(scElts)
+	_, _, dbname := scpb.FindNamespace(dbElts)
+	objectName.SchemaName = tree.Name(scName.Name)
+	objectName.CatalogName = tree.Name(dbname.Name)
+	objectName.ExplicitCatalog = true
+	objectName.ExplicitSchema = true
+	return objectName
+}
+
 // validateTableRename performs validation checks before renaming a table.
 func validateTableRename(b BuildCtx, currentName tree.TableName, newName tree.TableName) {
 	// The legacy schema changer used to check the CREATE privilege on the
@@ -187,34 +173,51 @@ func checkTableNameConflicts(
 		}
 		panic(sqlerrors.NewRelationAlreadyExistsError(newName.String()))
 	}
+}
 
-	validateTableRename(b, currentName, newName)
+func getAlterTableTargetElement(
+	elts ElementResultSet,
+) (descID catid.DescID, element scpb.Element, isTemp bool) {
+	if tbl := elts.FilterTable().MustGetZeroOrOneElement(); tbl != nil {
+		element = tbl
+		descID = tbl.TableID
+		isTemp = tbl.IsTemporary
+	} else if view := elts.FilterView().MustGetZeroOrOneElement(); view != nil {
+		element = view
+		descID = view.ViewID
+		isTemp = view.IsTemporary
+	} else if seq := elts.FilterSequence().MustGetZeroOrOneElement(); seq != nil {
+		element = seq
+		descID = seq.SequenceID
+		isTemp = seq.IsTemporary
+	}
+	return descID, element, isTemp
 }
 
 // validateObjectType validates that the resolved object type matches what was
 // requested in the statement. Note that we allow ALTER TABLE to be used for
 // views or sequences, just like in Postgres.
-func validateObjectType(elts ElementResultSet, n *tree.RenameTable) {
+func validateObjectType(
+	elts ElementResultSet, objectName tree.Name, isSequence bool, isView bool, isMaterialized bool,
+) {
 	_, _, view := scpb.FindView(elts)
 	_, _, seq := scpb.FindSequence(elts)
 
-	objectName := n.Name.ToTableName().ObjectName
-
-	if n.IsView && view == nil {
+	if isView && view == nil {
 		// User asked for view but we found something else.
 		panic(pgerror.Newf(pgcode.WrongObjectType, "%q is not a view", objectName))
-	} else if n.IsSequence && seq == nil {
+	} else if isSequence && seq == nil {
 		// User asked for sequence but we found something else.
 		panic(pgerror.Newf(pgcode.WrongObjectType, "%q is not a sequence", objectName))
 	}
 
 	if view != nil {
 		// Validate view type (materialized vs non-materialized).
-		if view.IsMaterialized && !n.IsMaterialized {
+		if view.IsMaterialized && !isMaterialized {
 			panic(errors.WithHint(pgerror.Newf(pgcode.WrongObjectType, "%q is a materialized view", objectName),
 				"use the corresponding MATERIALIZED VIEW command"))
 		}
-		if !view.IsMaterialized && n.IsMaterialized {
+		if !view.IsMaterialized && isMaterialized {
 			panic(pgerror.Newf(pgcode.WrongObjectType, "%q is not a materialized view", objectName))
 		}
 	}
@@ -223,7 +226,7 @@ func validateObjectType(elts ElementResultSet, n *tree.RenameTable) {
 // checkNameBasedDependencies validates that no objects depend on this object
 // via its name.
 func checkNameBasedDependencies(
-	b BuildCtx, descriptorID catid.DescID, element scpb.Element, objectName tree.TableName,
+	b BuildCtx, descriptorID catid.DescID, element scpb.Element, objectName tree.TableName, op string,
 ) {
 	switch element.(type) {
 	case *scpb.Sequence:
@@ -238,14 +241,14 @@ func checkNameBasedDependencies(
 			// blocked.
 			viewElts := b.QueryByID(backRefElem.ViewID)
 			_, _, viewNS := scpb.FindNamespace(viewElts)
-			panic(sqlerrors.NewDependentBlocksOpError("rename", "relation", objectName.String(), "view", viewNS.Name))
+			panic(sqlerrors.NewDependentBlocksOpError(op, "relation", objectName.String(), "view", viewNS.Name))
 		case *scpb.FunctionName:
 			funcElem := b.QueryByID(backRefElem.FunctionID).FilterFunction().MustGetOneElement()
 			funcType := "function"
 			if funcElem.IsProcedure {
 				funcType = "procedure"
 			}
-			panic(sqlerrors.NewDependentBlocksOpError("rename", "relation", objectName.String(), funcType, backRefElem.Name))
+			panic(sqlerrors.NewDependentBlocksOpError(op, "relation", objectName.String(), funcType, backRefElem.Name))
 		case *scpb.TriggerDeps:
 			for _, usesRelation := range backRefElem.UsesRelations {
 				if usesRelation.ID == descriptorID {
@@ -255,9 +258,8 @@ func checkNameBasedDependencies(
 					dependentTriggerName := backRefs.FilterTriggerName().Filter(func(_ scpb.Status, _ scpb.TargetStatus, e *scpb.TriggerName) bool {
 						return e.TriggerID == dependentTriggerID && e.TableID == dependentTableID
 					}).MustGetOneElement()
-					panic(sqlerrors.NewDependentObjectErrorf(
-						"cannot rename relation %q because trigger %q on table %q depends on it",
-						objectName.String(), dependentTriggerName.Name, dependentTableNS.Name,
+					panic(sqlerrors.NewDependentBlocksOpError(
+						op, "relation", objectName.String(), dependentTriggerName.Name, dependentTableNS.Name,
 					))
 				}
 			}