Support ALTER TABLE for SQLite

internal/sqlite/catalog.go

@@ -0,0 +1,8 @@
+package sqlite
+
+import "github.com/kyleconroy/sqlc/internal/sql/catalog"
+
+func NewCatalog() *catalog.Catalog {
+	c := catalog.New("main")
+	return c
+}

internal/sqlite/catalog_test.go

@@ -0,0 +1,269 @@
+package sqlite
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/kyleconroy/sqlc/internal/sql/ast"
+	"github.com/kyleconroy/sqlc/internal/sql/catalog"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+)
+
+func TestUpdate(t *testing.T) {
+	p := NewParser()
+
+	for i, tc := range []struct {
+		stmt string
+		s    *catalog.Schema
+	}{
+		{
+			`
+			CREATE TABLE foo (bar text);
+			`,
+			&catalog.Schema{
+				Name: "main",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Name: "foo"},
+						Columns: []*catalog.Column{
+							{
+								Name: "bar",
+								Type: ast.TypeName{Name: "text"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`
+			CREATE TABLE foo (bar text);
+			ALTER TABLE foo RENAME TO baz;
+			`,
+			&catalog.Schema{
+				Name: "main",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Name: "baz"},
+						Columns: []*catalog.Column{
+							{
+								Name: "bar",
+								Type: ast.TypeName{Name: "text"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`
+			CREATE TABLE foo (bar text);
+			ALTER TABLE foo ADD COLUMN baz bool;
+			`,
+			&catalog.Schema{
+				Name: "main",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Name: "foo"},
+						Columns: []*catalog.Column{
+							{
+								Name: "bar",
+								Type: ast.TypeName{Name: "text"},
+							},
+							{
+								Name: "baz",
+								Type: ast.TypeName{Name: "bool"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`
+			CREATE TABLE foo (bar text);
+			ALTER TABLE foo RENAME COLUMN bar TO baz;
+			`,
+			&catalog.Schema{
+				Name: "main",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Name: "foo"},
+						Columns: []*catalog.Column{
+							{
+								Name: "baz",
+								Type: ast.TypeName{Name: "text"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`
+			CREATE TABLE foo (bar text);
+			ALTER TABLE foo RENAME bar TO baz;
+			`,
+			&catalog.Schema{
+				Name: "main",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Name: "foo"},
+						Columns: []*catalog.Column{
+							{
+								Name: "baz",
+								Type: ast.TypeName{Name: "text"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`
+			ATTACH ':memory:' as ns;
+			CREATE TABLE ns.foo (bar text);
+			`,
+			&catalog.Schema{
+				Name: "ns",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Schema: "ns", Name: "foo"},
+						Columns: []*catalog.Column{
+							{
+								Name: "bar",
+								Type: ast.TypeName{Name: "text"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`
+			ATTACH ':memory:' as ns;
+			CREATE TABLE ns.foo (bar text);
+			ALTER TABLE ns.foo RENAME TO baz;
+			`,
+			&catalog.Schema{
+				Name: "ns",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Schema: "ns", Name: "baz"},
+						Columns: []*catalog.Column{
+							{
+								Name: "bar",
+								Type: ast.TypeName{Name: "text"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`
+			ATTACH ':memory:' as ns;
+			CREATE TABLE ns.foo (bar text);
+			ALTER TABLE ns.foo ADD COLUMN baz bool;
+			`,
+			&catalog.Schema{
+				Name: "ns",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Schema: "ns", Name: "foo"},
+						Columns: []*catalog.Column{
+							{
+								Name: "bar",
+								Type: ast.TypeName{Name: "text"},
+							},
+							{
+								Name: "baz",
+								Type: ast.TypeName{Name: "bool"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`
+			ATTACH ':memory:' as ns;
+			CREATE TABLE ns.foo (bar text);
+			ALTER TABLE ns.foo RENAME COLUMN bar TO baz;
+			`,
+			&catalog.Schema{
+				Name: "ns",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Schema: "ns", Name: "foo"},
+						Columns: []*catalog.Column{
+							{
+								Name: "baz",
+								Type: ast.TypeName{Name: "text"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`
+			ATTACH ':memory:' as ns;
+			CREATE TABLE ns.foo (bar text);
+			ALTER TABLE ns.foo RENAME bar TO baz;
+			`,
+			&catalog.Schema{
+				Name: "ns",
+				Tables: []*catalog.Table{
+					{
+						Rel: &ast.TableName{Schema: "ns", Name: "foo"},
+						Columns: []*catalog.Column{
+							{
+								Name: "baz",
+								Type: ast.TypeName{Name: "text"},
+							},
+						},
+					},
+				},
+			},
+		},
+	} {
+		test := tc
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			stmts, err := p.Parse(strings.NewReader(test.stmt))
+			if err != nil {
+				t.Log(test.stmt)
+				t.Fatal(err)
+			}
+
+			c := NewCatalog()
+			if err := c.Build(stmts); err != nil {
+				t.Log(test.stmt)
+				t.Fatal(err)
+			}
+
+			e := NewCatalog()
+			if test.s != nil {
+				var replaced bool
+				for i := range e.Schemas {
+					if e.Schemas[i].Name == test.s.Name {
+						e.Schemas[i] = test.s
+						replaced = true
+						break
+					}
+				}
+				if !replaced {
+					e.Schemas = append(e.Schemas, test.s)
+				}
+			}
+
+			if diff := cmp.Diff(e, c, cmpopts.EquateEmpty()); diff != "" {
+				t.Log(test.stmt)
+				t.Errorf("catalog mismatch:\n%s", diff)
+			}
+		})
+	}
+}

internal/sqlite/listener.go

@@ -39,12 +39,34 @@ func (l *listener) EnterAlter_table_stmt(c *parser.Alter_table_stmtContext) {
 		return
 	}
 
-	stmt := &ast.AlterTableStmt{
-		Table: parseTableName(c),
-		Cmds:  &ast.List{},
+	if newTable, ok := c.New_table_name().(*parser.New_table_nameContext); ok {
+		name := newTable.Any_name().GetText()
+		stmt := &ast.RenameTableStmt{
+			Table:   parseTableName(c),
+			NewName: &name,
+		}
+		l.stmt = &ast.RawStmt{Stmt: stmt}
+		return
+	}
+
+	if newCol, ok := c.New_column_name().(*parser.New_column_nameContext); ok {
+		name := newCol.Any_name().GetText()
+		stmt := &ast.RenameColumnStmt{
+			Table: parseTableName(c),
+			Col: &ast.ColumnRef{
+				Name: c.Column_name().GetText(),
+			},
+			NewName: &name,
+		}
+		l.stmt = &ast.RawStmt{Stmt: stmt}
+		return
 	}
 
 	if def, ok := c.Column_def().(*parser.Column_defContext); ok {
+		stmt := &ast.AlterTableStmt{
+			Table: parseTableName(c),
+			Cmds:  &ast.List{},
+		}
 		name := def.Column_name().GetText()
 		stmt.Cmds.Items = append(stmt.Cmds.Items, &ast.AlterTableCmd{
 			Name:    &name,
@@ -56,10 +78,23 @@ func (l *listener) EnterAlter_table_stmt(c *parser.Alter_table_stmtContext) {
 				},
 			},
 		})
+		l.stmt = &ast.RawStmt{Stmt: stmt}
+		return
 	}
 
-	l.stmt = &ast.RawStmt{Stmt: stmt}
+}
+
+func (l *listener) EnterAttach_stmt(c *parser.Attach_stmtContext) {
+	if l.busy() {
+		return
+	}
 
+	name := c.Database_name().GetText()
+	stmt := &ast.CreateSchemaStmt{
+		Name: &name,
+	}
+
+	l.stmt = &ast.RawStmt{Stmt: stmt}
 }
 
 func (l *listener) EnterCreate_table_stmt(c *parser.Create_table_stmtContext) {
@@ -149,3 +184,5 @@ func (l *listener) EnterFactored_select_stmt(c *parser.Factored_select_stmtConte
 	}
 	l.stmt = &ast.RawStmt{Stmt: sel}
 }
+
+var _ parser.SQLiteListener = (*listener)(nil)

internal/sqlite/parser/Makefile

@@ -1,2 +1,2 @@
 sqlite_parser.go: SQLite.g4
-	antlr -Dlanguage=Go -visitor SQLite.g4
+	antlr -Dlanguage=Go SQLite.g4

internal/sqlite/parser/SQLite.g4

@@ -74,6 +74,7 @@ sql_stmt
 alter_table_stmt
  : K_ALTER K_TABLE ( database_name '.' )? table_name
    ( K_RENAME K_TO new_table_name
+   | K_RENAME K_COLUMN? column_name K_TO new_column_name
    | K_ADD K_COLUMN? column_def
    )
  ;
@@ -633,6 +634,10 @@ column_name
  : any_name
  ;
 
+new_column_name 
+ : any_name
+ ;
+
 collation_name 
  : any_name
  ;