fix: robustly strip psql meta commands

internal/cmd/createdb.go

@@ -10,8 +10,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/sqlc-dev/sqlc/internal/config"
 	"github.com/sqlc-dev/sqlc/internal/dbmanager"
-	"github.com/sqlc-dev/sqlc/internal/migrations"
-	"github.com/sqlc-dev/sqlc/internal/sql/sqlpath"
+	"github.com/sqlc-dev/sqlc/internal/schemautil"
 )
 
 var createDBCmd = &cobra.Command{
@@ -76,17 +75,12 @@ func CreateDB(ctx context.Context, dir, filename, querySetName string, o *Option
 	}
 
 	var ddl []string
-	files, err := sqlpath.Glob(queryset.Schema)
+	ddl, err = schemautil.LoadSchemasForApply(queryset.Schema, string(queryset.Engine), func(warning string) {
+		fmt.Fprintln(o.Stderr, warning)
+	})
 	if err != nil {
 		return err
 	}
-	for _, schema := range files {
-		contents, err := os.ReadFile(schema)
-		if err != nil {
-			return fmt.Errorf("read file: %w", err)
-		}
-		ddl = append(ddl, migrations.RemoveRollbackStatements(string(contents)))
-	}
 
 	now := time.Now().UTC().UnixNano()
 	client := dbmanager.NewClient(conf.Servers)

internal/cmd/generate.go

@@ -306,6 +306,9 @@ func parse(ctx context.Context, name, dir string, sql config.SQL, combo config.C
 		return nil, true
 	}
 	if err := c.ParseCatalog(sql.Schema); err != nil {
+		for _, warning := range c.Warnings() {
+			fmt.Fprintln(stderr, warning)
+		}
 		fmt.Fprintf(stderr, "# package %s\n", name)
 		if parserErr, ok := err.(*multierr.Error); ok {
 			for _, fileErr := range parserErr.Errs() {
@@ -316,6 +319,9 @@ func parse(ctx context.Context, name, dir string, sql config.SQL, combo config.C
 		}
 		return nil, true
 	}
+	for _, warning := range c.Warnings() {
+		fmt.Fprintln(stderr, warning)
+	}
 	if parserOpts.Debug.DumpCatalog {
 		debug.Dump(c.Catalog())
 	}

internal/cmd/process.go

@@ -122,12 +122,12 @@ func processQuerySets(ctx context.Context, rp ResultProcessor, conf *config.Conf
 	if err := grp.Wait(); err != nil {
 		return err
 	}
-	if errored {
-		for i, _ := range stderrs {
-			if _, err := io.Copy(stderr, &stderrs[i]); err != nil {
-				return err
-			}
+	for i := range stderrs {
+		if _, err := io.Copy(stderr, &stderrs[i]); err != nil {
+			return err
 		}
+	}
+	if errored {
 		return fmt.Errorf("errored")
 	}
 	return nil

internal/cmd/verify.go

@@ -14,11 +14,10 @@ import (
 
 	"github.com/sqlc-dev/sqlc/internal/config"
 	"github.com/sqlc-dev/sqlc/internal/dbmanager"
-	"github.com/sqlc-dev/sqlc/internal/migrations"
 	"github.com/sqlc-dev/sqlc/internal/plugin"
 	"github.com/sqlc-dev/sqlc/internal/quickdb"
 	pb "github.com/sqlc-dev/sqlc/internal/quickdb/v1"
-	"github.com/sqlc-dev/sqlc/internal/sql/sqlpath"
+	"github.com/sqlc-dev/sqlc/internal/schemautil"
 )
 
 func init() {
@@ -93,17 +92,12 @@ func Verify(ctx context.Context, dir, filename string, opts *Options) error {
 
 			// Read the schema files into memory, removing rollback statements
 			var ddl []string
-			files, err := sqlpath.Glob(current.Schema)
+			ddl, err = schemautil.LoadSchemasForApply(current.Schema, string(current.Engine), func(warning string) {
+				fmt.Fprintln(stderr, warning)
+			})
 			if err != nil {
 				return err
 			}
-			for _, schema := range files {
-				contents, err := os.ReadFile(schema)
-				if err != nil {
-					return fmt.Errorf("read file: %w", err)
-				}
-				ddl = append(ddl, migrations.RemoveRollbackStatements(string(contents)))
-			}
 
 			var codegen plugin.GenerateRequest
 			if err := proto.Unmarshal(qs.CodegenRequest.Contents, &codegen); err != nil {

internal/cmd/vet.go

@@ -27,12 +27,11 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/config"
 	"github.com/sqlc-dev/sqlc/internal/dbmanager"
 	"github.com/sqlc-dev/sqlc/internal/debug"
-	"github.com/sqlc-dev/sqlc/internal/migrations"
 	"github.com/sqlc-dev/sqlc/internal/opts"
 	"github.com/sqlc-dev/sqlc/internal/plugin"
 	"github.com/sqlc-dev/sqlc/internal/quickdb"
+	"github.com/sqlc-dev/sqlc/internal/schemautil"
 	"github.com/sqlc-dev/sqlc/internal/shfmt"
-	"github.com/sqlc-dev/sqlc/internal/sql/sqlpath"
 	"github.com/sqlc-dev/sqlc/internal/vet"
 )
 
@@ -422,18 +421,12 @@ func (c *checker) fetchDatabaseUri(ctx context.Context, s config.SQL) (string, f
 		c.Client = dbmanager.NewClient(c.Conf.Servers)
 	})
 
-	var ddl []string
-	files, err := sqlpath.Glob(s.Schema)
+	ddl, err := schemautil.LoadSchemasForApply(s.Schema, string(s.Engine), func(warning string) {
+		fmt.Fprintln(c.Stderr, warning)
+	})
 	if err != nil {
 		return "", cleanup, err
 	}
-	for _, schema := range files {
-		contents, err := os.ReadFile(schema)
-		if err != nil {
-			return "", cleanup, fmt.Errorf("read file: %w", err)
-		}
-		ddl = append(ddl, migrations.RemoveRollbackStatements(string(contents)))
-	}
 
 	resp, err := c.Client.CreateDatabase(ctx, &dbmanager.CreateDatabaseRequest{
 		Engine:     string(s.Engine),
@@ -540,18 +533,15 @@ func (c *checker) checkSQL(ctx context.Context, s config.SQL) error {
 			defer db.Close()
 			// For in-memory SQLite databases, apply migrations
 			if isInMemorySQLite(dburl) {
-				files, err := sqlpath.Glob(s.Schema)
+				ddl, err := schemautil.LoadSchemasForApply(s.Schema, string(s.Engine), func(warning string) {
+					fmt.Fprintln(c.Stderr, warning)
+				})
 				if err != nil {
 					return fmt.Errorf("schema: %w", err)
 				}
-				for _, schema := range files {
-					contents, err := os.ReadFile(schema)
-					if err != nil {
-						return fmt.Errorf("read schema file: %w", err)
-					}
-					ddl := migrations.RemoveRollbackStatements(string(contents))
-					if _, err := db.ExecContext(ctx, ddl); err != nil {
-						return fmt.Errorf("apply schema %s: %w", schema, err)
+				for _, stmt := range ddl {
+					if _, err := db.ExecContext(ctx, stmt); err != nil {
+						return fmt.Errorf("apply schema: %w", err)
 					}
 				}
 			}

internal/compiler/compile.go

@@ -38,8 +38,12 @@ func (c *Compiler) parseCatalog(schemas []string) error {
 			merr.Add(filename, "", 0, err)
 			continue
 		}
-		contents := migrations.RemoveRollbackStatements(string(blob))
-		contents = migrations.RemovePsqlMetaCommands(contents)
+		contents, warnings, err := migrations.PreprocessSchema(string(blob), string(c.conf.Engine))
+		if err != nil {
+			merr.Add(filename, string(blob), 0, err)
+			continue
+		}
+		c.warns = append(c.warns, warnings...)
 		c.schema = append(c.schema, contents)
 
 		// In database-only mode, we parse the schema to validate syntax

internal/compiler/engine.go

@@ -28,6 +28,7 @@ type Compiler struct {
 	selector selector
 
 	schema []string
+	warns  []string
 
 	// databaseOnlyMode indicates that the compiler should use database-only analysis
 	// and skip building the internal catalog from schema files (analyzer.database: only)
@@ -138,6 +139,12 @@ func (c *Compiler) Result() *Result {
 	return c.result
 }
 
+// Warnings returns a copy of any non-fatal schema preprocessing warnings
+// collected while parsing the catalog.
+func (c *Compiler) Warnings() []string {
+	return append([]string(nil), c.warns...)
+}
+
 func (c *Compiler) Close(ctx context.Context) {
 	if c.analyzer != nil {
 		c.analyzer.Close(ctx)

internal/endtoend/testdata/pg_dump/exec.json

@@ -1,6 +1,3 @@
 {
-    "contexts": ["base"],
-    "meta": {
-        "invalid_schema": true
-    }
+    "contexts": ["base"]
 }