sql: add ALTER TABLE ... DROP STORED to the declerative schema changer

Previously, `ALTER TABLE ... DROP STORED` would run with the legacy
schema changer. This change enables the comment be run by the
declerative schema changer.

Epic: none

Fixes: #139603

Release note (sql change): `ALTER TABLE ... DROP STORED` will use the
declerative schema changer to run.

Author: shghasemi

pkg/ccl/schemachangerccl/sctestbackupccl/backup_base_generated_test.go

@@ -8,6 +8,7 @@ go_library(
         "alter_table_add_column.go",
         "alter_table_add_constraint.go",
         "alter_table_alter_column_drop_not_null.go",
+        "alter_table_alter_column_drop_stored.go",
         "alter_table_alter_column_set_default.go",
         "alter_table_alter_column_set_not_null.go",
         "alter_table_alter_column_set_on_update.go",

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

@@ -43,6 +43,7 @@ var supportedAlterTableStatements = map[reflect.Type]supportedAlterTableCommand{
 	reflect.TypeOf((*tree.AlterTableDropNotNull)(nil)):        {fn: alterTableDropNotNull, on: true, checks: isV253Active},
 	reflect.TypeOf((*tree.AlterTableSetOnUpdate)(nil)):        {fn: alterTableSetOnUpdate, on: true, checks: isV254Active},
 	reflect.TypeOf((*tree.AlterTableRenameColumn)(nil)):       {fn: alterTableRenameColumn, on: true, checks: isV254Active},
+	reflect.TypeOf((*tree.AlterTableDropStored)(nil)):         {fn: alterTableDropStored, on: true, checks: isV261Active},
 }
 
 func init() {

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

@@ -0,0 +1,69 @@
+// 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"
+)
+
+func alterTableDropStored(
+	b BuildCtx,
+	tn *tree.TableName,
+	tbl *scpb.Table,
+	stmt tree.Statement,
+	t *tree.AlterTableDropStored,
+) {
+	alterColumnPreChecks(b, tn, tbl, t.Column)
+	colElems := b.ResolveColumn(tbl.TableID, t.Column, ResolveParams{
+		RequiredPrivilege: privilege.CREATE,
+	})
+	colElem := colElems.FilterColumn().MustGetOneElement()
+	columnID := colElem.ColumnID
+	// Block alters on system columns.
+	panicIfSystemColumn(colElem, t.Column)
+	// Ensure that the column is stored (not virtual)
+	panicIfVirtualColumn(b, tbl.TableID, columnID, t.Column)
+	// Retrieve the compute expression element
+	exprElem := retrieveColumnComputeExpressionElem(b, tbl.TableID, columnID)
+	// Ensure that the column is computed
+	if exprElem == nil {
+		panic(pgerror.Newf(
+			pgcode.InvalidColumnDefinition,
+			"column %q is not a computed column",
+			tree.ErrString(&t.Column)))
+	}
+	b.Drop(exprElem)
+}
+
+// panicIfVirtualColumn blocks operation if the column is virtual.
+func panicIfVirtualColumn(
+	b BuildCtx, tableID catid.DescID, columnID catid.ColumnID, columnName tree.Name,
+) {
+	colTypeEl := mustRetrieveColumnTypeElem(b, tableID, columnID)
+	if colTypeEl.IsVirtual {
+		panic(pgerror.Newf(
+			pgcode.InvalidColumnDefinition,
+			"column %q is not a stored computed column",
+			tree.ErrString(&columnName)))
+	}
+}
+
+// retrieveColumnComputeExpressionElem returns the compute expression
+// element of the column. Returns nil if no expression exists and for
+// older versions that store the expression as part of the ColumnType
+func retrieveColumnComputeExpressionElem(
+	b BuildCtx, tableID catid.DescID, columnID catid.ColumnID,
+) (expr *scpb.ColumnComputeExpression) {
+	return b.QueryByID(tableID).FilterColumnComputeExpression().Filter(func(
+		_ scpb.Status, _ scpb.TargetStatus, e *scpb.ColumnComputeExpression) bool {
+		return e.ColumnID == columnID
+	}).MustGetZeroOrOneElement()
+}

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

@@ -227,3 +227,8 @@ var isV253Active = func(_ tree.NodeFormatter, _ sessiondatapb.NewSchemaChangerMo
 var isV254Active = func(_ tree.NodeFormatter, _ sessiondatapb.NewSchemaChangerMode, activeVersion clusterversion.ClusterVersion) bool {
 	return activeVersion.IsActive(clusterversion.V25_4)
 }
+
+var isV261Active = func(_ tree.NodeFormatter, _ sessiondatapb.NewSchemaChangerMode, activeVersion clusterversion.ClusterVersion) bool {
+	// change the cluster version once V26_1 is created
+	return activeVersion.IsActive(clusterversion.V25_4)
+}

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

@@ -12,10 +12,6 @@ CREATE TABLE defaultdb.foo (
 );
 ----
 
-unimplemented
-ALTER TABLE defaultdb.foo ALTER COLUMN i DROP STORED
-----
-
 unimplemented
 ALTER TABLE defaultdb.foo RENAME CONSTRAINT foobar TO baz
 ----

pkg/sql/schemachanger/scbuild/testdata/unimplemented_alter_table

@@ -0,0 +1,7 @@
+setup
+CREATE TABLE t (i INT PRIMARY KEY, j INT AS (i + 1) STORED);
+----
+
+test
+ALTER TABLE t ALTER COLUMN j DROP STORED
+----

pkg/sql/schemachanger/sctest_generated_test.go

@@ -0,0 +1,42 @@
+/* setup */
+CREATE TABLE t (i INT PRIMARY KEY, j INT AS (i + 1) STORED);
+
+/* test */
+EXPLAIN (DDL) ALTER TABLE t ALTER COLUMN j DROP STORED;
+----
+Schema change plan for ALTER TABLE ‹defaultdb›.‹public›.‹t› ALTER COLUMN ‹j› DROP STORED;
+ ├── StatementPhase
+ │    └── Stage 1 of 1 in StatementPhase
+ │         ├── 1 element transitioning toward TRANSIENT_PUBLIC
+ │         │    └── PUBLIC → ABSENT TableSchemaLocked:{DescID: 104 (t)}
+ │         ├── 1 element transitioning toward ABSENT
+ │         │    └── PUBLIC → ABSENT ColumnComputeExpression:{DescID: 104 (t), ColumnID: 2 (j), ReferencedColumnIDs: [1], Usage: REGULAR}
+ │         └── 2 Mutation operations
+ │              ├── SetTableSchemaLocked {"TableID":104}
+ │              └── RemoveColumnComputeExpression {"ColumnID":2,"TableID":104}
+ ├── PreCommitPhase
+ │    ├── Stage 1 of 2 in PreCommitPhase
+ │    │    ├── 1 element transitioning toward TRANSIENT_PUBLIC
+ │    │    │    └── ABSENT → PUBLIC TableSchemaLocked:{DescID: 104 (t)}
+ │    │    ├── 1 element transitioning toward ABSENT
+ │    │    │    └── ABSENT → PUBLIC ColumnComputeExpression:{DescID: 104 (t), ColumnID: 2 (j), ReferencedColumnIDs: [1], Usage: REGULAR}
+ │    │    └── 1 Mutation operation
+ │    │         └── UndoAllInTxnImmediateMutationOpSideEffects
+ │    └── Stage 2 of 2 in PreCommitPhase
+ │         ├── 1 element transitioning toward TRANSIENT_PUBLIC
+ │         │    └── PUBLIC → ABSENT TableSchemaLocked:{DescID: 104 (t)}
+ │         ├── 1 element transitioning toward ABSENT
+ │         │    └── PUBLIC → ABSENT ColumnComputeExpression:{DescID: 104 (t), ColumnID: 2 (j), ReferencedColumnIDs: [1], Usage: REGULAR}
+ │         └── 4 Mutation operations
+ │              ├── SetTableSchemaLocked {"TableID":104}
+ │              ├── RemoveColumnComputeExpression {"ColumnID":2,"TableID":104}
+ │              ├── SetJobStateOnDescriptor {"DescriptorID":104,"Initialize":true}
+ │              └── CreateSchemaChangerJob {"RunningStatus":"Pending: Updatin..."}
+ └── PostCommitPhase
+      └── Stage 1 of 1 in PostCommitPhase
+           ├── 1 element transitioning toward TRANSIENT_PUBLIC
+           │    └── ABSENT → TRANSIENT_PUBLIC TableSchemaLocked:{DescID: 104 (t)}
+           └── 3 Mutation operations
+                ├── SetTableSchemaLocked {"Locked":true,"TableID":104}
+                ├── RemoveJobStateFromDescriptor {"DescriptorID":104}
+                └── UpdateSchemaChangerJob {"IsNonCancelable":true,"RunningStatus":"all stages compl..."}

pkg/sql/schemachanger/testdata/end_to_end/alter_table_alter_column_drop_stored/alter_table_alter_column_drop_stored.definition

@@ -0,0 +1,8 @@
+/* setup */
+CREATE TABLE t (i INT PRIMARY KEY, j INT AS (i + 1) STORED);
+
+/* test */
+EXPLAIN (DDL, SHAPE) ALTER TABLE t ALTER COLUMN j DROP STORED;
+----
+Schema change plan for ALTER TABLE ‹defaultdb›.‹public›.‹t› ALTER COLUMN ‹j› DROP STORED;
+ └── execute 2 system table mutations transactions