schemachanger: implement ALTER COLUMN [SET | DROP] ON UPDATE in declarative

This adds support for setting and dropping ON UPDATE expressions to the
declarative schema changer. No new elements were needed, so this was
pretty straightforward.

Release note: None

Author: rafiss

pkg/ccl/schemachangerccl/sctestbackupccl/backup_base_generated_test.go

@@ -1010,6 +1010,11 @@ func rewriteSchemaChangerState(
 				// just drop the target.
 				removeElementAtCurrentIdx()
 				continue
+			case *scpb.ColumnOnUpdateExpression:
+				// IF there is any dependency missing for column ON UPDATE expression,
+				// we just drop the target.
+				removeElementAtCurrentIdx()
+				continue
 			case *scpb.SequenceOwner:
 				// If a sequence owner is missing the sequence, then the sequence
 				// was already dropped and this element can be safely removed.

pkg/sql/catalog/rewrite/rewrite.go

@@ -10,6 +10,7 @@ go_library(
         "alter_table_alter_column_drop_not_null.go",
         "alter_table_alter_column_set_default.go",
         "alter_table_alter_column_set_not_null.go",
+        "alter_table_alter_column_set_on_update.go",
         "alter_table_alter_column_type.go",
         "alter_table_alter_primary_key.go",
         "alter_table_drop_column.go",

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

@@ -38,6 +38,7 @@ var supportedAlterTableStatements = map[reflect.Type]supportedAlterTableCommand{
 	reflect.TypeOf((*tree.AlterTableDropConstraint)(nil)):     {fn: alterTableDropConstraint, on: true, checks: nil},
 	reflect.TypeOf((*tree.AlterTableValidateConstraint)(nil)): {fn: alterTableValidateConstraint, on: true, checks: nil},
 	reflect.TypeOf((*tree.AlterTableSetDefault)(nil)):         {fn: alterTableSetDefault, on: true, checks: nil},
+	reflect.TypeOf((*tree.AlterTableSetOnUpdate)(nil)):        {fn: alterTableSetOnUpdate, on: true, checks: isV254Active},
 	reflect.TypeOf((*tree.AlterTableAlterColumnType)(nil)):    {fn: alterTableAlterColumnType, on: true, checks: nil},
 	reflect.TypeOf((*tree.AlterTableSetRLSMode)(nil)):         {fn: alterTableSetRLSMode, on: true, checks: isV252Active},
 	reflect.TypeOf((*tree.AlterTableDropNotNull)(nil)):        {fn: alterTableDropNotNull, on: true, checks: isV253Active},

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

@@ -80,7 +80,7 @@ func panicIfInvalidNonComputedColumnExpr(
 	}
 
 	colType := mustRetrieveColumnTypeElem(b, tbl.TableID, col.ColumnID)
-	typedNewExpr, _, err := sanitizeColumnExpression(context.Background(), b.SemaCtx(), newExpr, colType, schemaChange)
+	typedNewExpr, _, err := sanitizeColumnExpression(b, b.SemaCtx(), newExpr, colType, schemaChange)
 	if err != nil {
 		panic(err)
 	}

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

@@ -0,0 +1,51 @@
+// 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/schemachanger/scpb"
+	"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
+)
+
+func alterTableSetOnUpdate(
+	b BuildCtx,
+	tn *tree.TableName,
+	tbl *scpb.Table,
+	stmt tree.Statement,
+	t *tree.AlterTableSetOnUpdate,
+) {
+	alterColumnPreChecks(b, tn, tbl, t.Column)
+	colID := getColumnIDFromColumnName(b, tbl.TableID, t.Column, true /* required */)
+	col := mustRetrieveColumnElem(b, tbl.TableID, colID)
+	oldOnUpdateExpr := retrieveColumnOnUpdateExpressionElem(b, tbl.TableID, colID)
+	colType := mustRetrieveColumnTypeElem(b, tbl.TableID, colID)
+
+	// Block alters on system columns.
+	panicIfSystemColumn(col, t.Column.String())
+
+	// Block disallowed operations on computed columns.
+	panicIfComputedColumn(b, tn.ObjectName, colType, t.Column.String(), t.Expr)
+
+	// For DROP ON UPDATE.
+	if t.Expr == nil {
+		if oldOnUpdateExpr != nil {
+			b.Drop(oldOnUpdateExpr)
+		}
+		return
+	}
+
+	// If our target column already has an ON UPDATE expression, we want to drop it first.
+	if oldOnUpdateExpr != nil {
+		b.Drop(oldOnUpdateExpr)
+	}
+	typedExpr := panicIfInvalidNonComputedColumnExpr(b, tbl, tn.ToUnresolvedObjectName(), col, t.Column.String(), t.Expr, tree.ColumnOnUpdateExpr)
+
+	b.Add(&scpb.ColumnOnUpdateExpression{
+		TableID:    tbl.TableID,
+		ColumnID:   colID,
+		Expression: *b.WrapExpression(tbl.TableID, typedExpr),
+	})
+}

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

@@ -221,3 +221,7 @@ var isV252Active = func(_ tree.NodeFormatter, _ sessiondatapb.NewSchemaChangerMo
 var isV253Active = func(_ tree.NodeFormatter, _ sessiondatapb.NewSchemaChangerMode, activeVersion clusterversion.ClusterVersion) bool {
 	return activeVersion.IsActive(clusterversion.V25_3)
 }
+
+var isV254Active = func(_ tree.NodeFormatter, _ sessiondatapb.NewSchemaChangerMode, activeVersion clusterversion.ClusterVersion) bool {
+	return activeVersion.IsActive(clusterversion.V25_4)
+}