sqlite: Use convert functions instead of the listener

internal/cmd/generate.go

@@ -226,9 +226,9 @@ func parse(e Env, name, dir string, sql config.SQL, combo config.CombinedSetting
 		}
 		return q, false
 
-	case config.EnginePostgreSQL:
+	case config.EnginePostgreSQL, config.EngineXLemon:
 		var eng postgreEngine
-		if e.ExperimentalParser {
+		if e.ExperimentalParser || sql.Engine == config.EngineXLemon {
 			eng = compiler.NewEngine(sql, combo)
 		} else {
 			eng = &dinosqlEngine{}
@@ -257,7 +257,7 @@ func parse(e Env, name, dir string, sql config.SQL, combo config.CombinedSetting
 		}
 		return eng.Result(), false
 
-	case config.EngineXLemon, config.EngineXDolphin, config.EngineXElephant:
+	case config.EngineXDolphin, config.EngineXElephant:
 		r, err := compiler.Run(sql, combo)
 		if err != nil {
 			fmt.Fprintf(stderr, "# package %s\n", name)

internal/compiler/go_type.go

@@ -157,7 +157,7 @@ func (r *Result) goInnerType(col *Column, settings config.CombinedSettings) stri
 			return "interface{}"
 		}
 		if rel.Schema == "" {
-			rel.Schema = "public"
+			rel.Schema = r.Catalog.DefaultSchema
 		}
 
 		for _, schema := range r.Catalog.Schemas {
@@ -168,7 +168,7 @@ func (r *Result) goInnerType(col *Column, settings config.CombinedSettings) stri
 				switch t := typ.(type) {
 				case *catalog.Enum:
 					if rel.Name == t.Name && rel.Schema == schema.Name {
-						if schema.Name == "public" {
+						if schema.Name == r.Catalog.DefaultSchema {
 							return golang.StructName(t.Name, settings)
 						}
 						return golang.StructName(schema.Name+"_"+t.Name, settings)

internal/compiler/result.go

@@ -47,7 +47,7 @@ func (r *Result) Structs(settings config.CombinedSettings) []golang.Struct {
 		}
 		for _, table := range schema.Tables {
 			var tableName string
-			if schema.Name == "public" {
+			if schema.Name == r.Catalog.DefaultSchema {
 				tableName = table.Rel.Name
 			} else {
 				tableName = schema.Name + "_" + table.Rel.Name
@@ -90,7 +90,7 @@ func (r *Result) Enums(settings config.CombinedSettings) []golang.Enum {
 				continue
 			}
 			var enumName string
-			if schema.Name == "public" {
+			if schema.Name == r.Catalog.DefaultSchema {
 				enumName = enum.Name
 			} else {
 				enumName = schema.Name + "_" + enum.Name

internal/endtoend/testdata/experimental_lemon/query.sql

@@ -6,12 +6,10 @@ CREATE TABLE bar (
         baz text NOT NULL 
 );
 
-SELECT bar FROM foo;
+CREATE TABLE baz (name text);
+ALTER TABLE baz ADD COLUMN email text;
 
-DROP TABLE bar;
-DROP TABLE IF EXISTS bar;
-DROP TABLE IF EXISTS baz;
+-- name: ListFoo :many
+SELECT bar FROM foo;
 
 
-CREATE TABLE baz (name text);
-ALTER TABLE baz ADD COLUMN email text;

internal/sqlite/convert.go

@@ -0,0 +1,254 @@
+package sqlite
+
+import (
+	"github.com/antlr/antlr4/runtime/Go/antlr"
+
+	"github.com/kyleconroy/sqlc/internal/sql/ast"
+	"github.com/kyleconroy/sqlc/internal/sql/ast/pg"
+	"github.com/kyleconroy/sqlc/internal/sqlite/parser"
+)
+
+type node interface {
+	GetParser() antlr.Parser
+}
+
+func convertAlter_table_stmtContext(c *parser.Alter_table_stmtContext) ast.Node {
+	if newTable, ok := c.New_table_name().(*parser.New_table_nameContext); ok {
+		name := newTable.Any_name().GetText()
+		return &ast.RenameTableStmt{
+			Table:   parseTableName(c),
+			NewName: &name,
+		}
+	}
+
+	if newCol, ok := c.New_column_name().(*parser.New_column_nameContext); ok {
+		name := newCol.Any_name().GetText()
+		return &ast.RenameColumnStmt{
+			Table: parseTableName(c),
+			Col: &ast.ColumnRef{
+				Name: c.Column_name().GetText(),
+			},
+			NewName: &name,
+		}
+	}
+
+	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,
+			Subtype: ast.AT_AddColumn,
+			Def: &ast.ColumnDef{
+				Colname: name,
+				TypeName: &ast.TypeName{
+					Name: def.Type_name().GetText(),
+				},
+			},
+		})
+		return stmt
+	}
+
+	return &ast.TODO{}
+}
+
+func convertAttach_stmtContext(c *parser.Attach_stmtContext) ast.Node {
+	name := c.Database_name().GetText()
+	return &ast.CreateSchemaStmt{
+		Name: &name,
+	}
+}
+
+func convertCreate_table_stmtContext(c *parser.Create_table_stmtContext) ast.Node {
+	stmt := &ast.CreateTableStmt{
+		Name:        parseTableName(c),
+		IfNotExists: c.K_EXISTS() != nil,
+	}
+	for _, idef := range c.AllColumn_def() {
+		if def, ok := idef.(*parser.Column_defContext); ok {
+			stmt.Cols = append(stmt.Cols, &ast.ColumnDef{
+				Colname: def.Column_name().GetText(),
+				TypeName: &ast.TypeName{
+					Name: def.Type_name().GetText(),
+				},
+			})
+		}
+	}
+	return stmt
+}
+
+func convertDrop_table_stmtContext(c *parser.Drop_table_stmtContext) ast.Node {
+	return &ast.DropTableStmt{
+		IfExists: c.K_EXISTS() != nil,
+		Tables:   []*ast.TableName{parseTableName(c)},
+	}
+}
+
+func convertFactored_select_stmtContext(c *parser.Factored_select_stmtContext) ast.Node {
+	var tables []ast.Node
+	var cols []ast.Node
+	for _, icore := range c.AllSelect_core() {
+		core, ok := icore.(*parser.Select_coreContext)
+		if !ok {
+			continue
+		}
+		for _, icol := range core.AllResult_column() {
+			col, ok := icol.(*parser.Result_columnContext)
+			if !ok {
+				continue
+			}
+			iexpr := col.Expr()
+			if iexpr == nil {
+				continue
+			}
+			expr, ok := iexpr.(*parser.ExprContext)
+			if !ok {
+				continue
+			}
+			cols = append(cols, &ast.ResTarget{
+				Val: &ast.ColumnRef{
+					Name: expr.Column_name().GetText(),
+				},
+			})
+		}
+		for _, ifrom := range core.AllTable_or_subquery() {
+			from, ok := ifrom.(*parser.Table_or_subqueryContext)
+			if !ok {
+				continue
+			}
+			name := ast.TableName{
+				Name: from.Table_name().GetText(),
+			}
+			if from.Schema_name() != nil {
+				name.Schema = from.Schema_name().GetText()
+			}
+			tables = append(tables, &name)
+		}
+	}
+	return &pg.SelectStmt{
+		FromClause: &ast.List{Items: tables},
+		TargetList: &ast.List{Items: cols},
+	}
+}
+
+func convertSql_stmtContext(n *parser.Sql_stmtContext) ast.Node {
+	if stmt := n.Alter_table_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Analyze_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Attach_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Begin_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Commit_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Compound_select_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Create_index_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Create_table_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Create_trigger_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Create_view_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Create_virtual_table_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Delete_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Delete_stmt_limited(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Detach_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Drop_index_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Drop_table_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Drop_trigger_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Drop_view_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Factored_select_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Insert_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Pragma_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Reindex_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Release_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Rollback_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Savepoint_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Simple_select_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Select_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Update_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Update_stmt_limited(); stmt != nil {
+		return convert(stmt)
+	}
+	if stmt := n.Vacuum_stmt(); stmt != nil {
+		return convert(stmt)
+	}
+	return nil
+}
+
+func convert(node node) ast.Node {
+	switch n := node.(type) {
+
+	case *parser.Alter_table_stmtContext:
+		return convertAlter_table_stmtContext(n)
+
+	case *parser.Attach_stmtContext:
+		return convertAttach_stmtContext(n)
+
+	case *parser.Create_table_stmtContext:
+		return convertCreate_table_stmtContext(n)
+
+	case *parser.Drop_table_stmtContext:
+		return convertDrop_table_stmtContext(n)
+
+	case *parser.Factored_select_stmtContext:
+		return convertFactored_select_stmtContext(n)
+
+	case *parser.Sql_stmtContext:
+		return convertSql_stmtContext(n)
+
+	default:
+		return &ast.TODO{}
+	}
+}