implement modifying table comments

Author: angelamayxie

memory/table.go

@@ -74,6 +74,7 @@ var _ sql.TruncateableTable = (*Table)(nil)
 var _ sql.AlterableTable = (*Table)(nil)
 var _ sql.IndexAlterableTable = (*Table)(nil)
 var _ sql.CollationAlterableTable = (*Table)(nil)
+var _ sql.CommentAlterableTable = (*Table)(nil)
 var _ sql.ForeignKeyTable = (*Table)(nil)
 var _ sql.CheckAlterableTable = (*Table)(nil)
 var _ sql.RewritableTable = (*Table)(nil)
@@ -2164,6 +2165,13 @@ func (t *Table) ModifyDefaultCollation(ctx *sql.Context, collation sql.Collation
 	return nil
 }
 
+//ModifyComment implements sql.CommentAlterableTable
+func (t *Table) ModifyComment(ctx *sql.Context, comment string) error {
+	data := t.sessionTableData(ctx)
+	data.comment = comment
+	return nil
+}
+
 // Filters implements the sql.FilteredTable interface.
 func (t *Table) Filters() []sql.Expression {
 	return t.filters

sql/errors.go

@@ -409,6 +409,9 @@ var (
 	// ErrAlterTableCollationNotSupported is thrown when the table doesn't support ALTER TABLE COLLATE statements
 	ErrAlterTableCollationNotSupported = errors.NewKind("table %s cannot have its collation altered")
 
+	// ErrAlterTableCommentNotSupported is thrown when the table doesn't support ALTER TABLE COMMENT statements
+	ErrAlterTableCommentNotSupported = errors.NewKind("table %s cannot have its comment altered")
+
 	// ErrCollationNotSupportedOnUniqueTextIndex is thrown when a unique index is created on a TEXT column, with no
 	// prefix length specified, and the collation is case-insensitive or accent-insensitive, meaning we can't
 	// reliably use a content-hashed field to detect uniqueness.

sql/plan/alter_table.go

@@ -968,3 +968,67 @@ func (atc *AlterTableCollation) WithChildren(children ...sql.Node) (sql.Node, er
 	natc.Table = children[0]
 	return &natc, nil
 }
+
+type AlterTableComment struct {
+	ddlNode
+	Table   sql.Node
+	Comment string
+}
+
+var _ sql.Node = (*AlterTableComment)(nil)
+var _ sql.Databaser = (*AlterTableComment)(nil)
+
+func NewAlterTableComment(table *ResolvedTable, comment string) *AlterTableComment {
+	return &AlterTableComment{
+		ddlNode: ddlNode{Db: table.SqlDatabase},
+		Table:   table,
+		Comment: comment,
+	}
+}
+
+// WithDatabase implements the interface sql.Databaser
+func (atc *AlterTableComment) WithDatabase(db sql.Database) (sql.Node, error) {
+	natc := *atc
+	natc.Db = db
+	return &natc, nil
+}
+
+// IsReadOnly implements the interface sql.Node
+func (atc *AlterTableComment) IsReadOnly() bool {
+	return false
+}
+
+// String implements the interface sql.Node
+func (atc *AlterTableComment) String() string {
+	return fmt.Sprintf("alter table %s comment %s", atc.Table.String(), atc.Comment)
+}
+
+// DebugString implements the interface sql.Node
+func (atc *AlterTableComment) DebugString() string {
+	return atc.String()
+}
+
+// Resolved implements the interface sql.Node
+func (atc *AlterTableComment) Resolved() bool {
+	return atc.Table.Resolved() && atc.ddlNode.Resolved()
+}
+
+// Schema implements the interface sql.Node
+func (atc *AlterTableComment) Schema() sql.Schema {
+	return atc.Table.Schema()
+}
+
+// Children implements the interface sql.Node
+func (atc *AlterTableComment) Children() []sql.Node {
+	return []sql.Node{atc.Table}
+}
+
+// WithChildren implements the interface sql.Node
+func (atc *AlterTableComment) WithChildren(children ...sql.Node) (sql.Node, error) {
+	if len(children) != 1 {
+		return nil, sql.ErrInvalidChildrenNumber.New(atc, len(children), 1)
+	}
+	natc := *atc
+	natc.Table = children[0]
+	return &natc, nil
+}

sql/planbuilder/ddl.go

@@ -650,6 +650,10 @@ func (b *Builder) buildAlterTableClause(inScope *scope, ddl *ast.DDL) []*scope {
 			outScopes = append(outScopes, b.buildAlterCollationSpec(tableScope, ddl, rt))
 		}
 
+		if ddl.AlterCommentSpec != nil {
+			outScopes = append(outScopes, b.buildAlterCommentSpec(tableScope, ddl, rt))
+		}
+
 		if ddl.NotNullSpec != nil {
 			outScopes = append(outScopes, b.buildAlterNotNull(tableScope, ddl, rt))
 		}
@@ -1176,6 +1180,12 @@ func (b *Builder) buildAlterCollationSpec(inScope *scope, ddl *ast.DDL, table *p
 	return
 }
 
+func (b *Builder) buildAlterCommentSpec(inScope *scope, ddl *ast.DDL, table *plan.ResolvedTable) (outScope *scope) {
+	outScope = inScope
+	outScope.node = plan.NewAlterTableComment(table, ddl.AlterCommentSpec.Comment)
+	return
+}
+
 func (b *Builder) buildDefaultExpression(inScope *scope, defaultExpr ast.Expr) *sql.ColumnDefaultValue {
 	if defaultExpr == nil {
 		return nil

sql/rowexec/ddl.go

@@ -1196,6 +1196,18 @@ func (b *BaseBuilder) buildAlterTableCollation(ctx *sql.Context, n *plan.AlterTa
 	return rowIterWithOkResultWithZeroRowsAffected(), alterable.ModifyDefaultCollation(ctx, n.Collation)
 }
 
+func (b *BaseBuilder) buildAlterTableComment(ctx *sql.Context, n *plan.AlterTableComment, row sql.Row) (sql.RowIter, error) {
+	tbl, err := getTableFromDatabase(ctx, n.Database(), n.Table)
+	if err != nil {
+		return nil, err
+	}
+	alterable, ok := tbl.(sql.CommentAlterableTable)
+	if !ok {
+		return nil, sql.ErrAlterTableCommentNotSupported.New(tbl.Name())
+	}
+	return rowIterWithOkResultWithZeroRowsAffected(), alterable.ModifyComment(ctx, n.Comment)
+}
+
 func (b *BaseBuilder) buildCreateForeignKey(ctx *sql.Context, n *plan.CreateForeignKey, row sql.Row) (sql.RowIter, error) {
 	db, err := n.DbProvider.Database(ctx, n.FkDef.Database)
 	if err != nil {

sql/rowexec/node_builder.gen.go

@@ -50,6 +50,8 @@ func (b *BaseBuilder) buildNodeExecNoAnalyze(ctx *sql.Context, n sql.Node, row s
 		return b.buildCreateForeignKey(ctx, n, row)
 	case *plan.AlterTableCollation:
 		return b.buildAlterTableCollation(ctx, n, row)
+	case *plan.AlterTableComment:
+		return b.buildAlterTableComment(ctx, n, row)
 	case *plan.CreateRole:
 		return b.buildCreateRole(ctx, n, row)
 	case *plan.Loop:

sql/tables.go

@@ -249,6 +249,13 @@ type CollationAlterableTable interface {
 	ModifyDefaultCollation(ctx *Context, collation CollationID) error
 }
 
+// CommentAlterableTable represents a table that supports altering its comment.
+type CommentAlterableTable interface {
+	Table
+	// ModifyComment modifies the table's comment
+	ModifyComment(ctx *Context, comment string) error
+}
+
 // PrimaryKeyTable is a table with a primary key.
 type PrimaryKeyTable interface {
 	// PrimaryKeySchema returns this table's PrimaryKeySchema