chore(release): update package version to 1.0.73

A composite [pk] entry inside an Indexes block (e.g. (a, b) [pk]) was
silently dropped: models.Index has no way to represent a primary key,
so the attribute was parsed and ignored, producing neither a PK nor a
meaningful index. It's now converted into a PrimaryKeyConstraint.

Also, Column.Sequence was never set by the DBML reader, so composite
PKs assembled from column-level [pk] attributes fell back to
alphabetical Name sorting instead of declaration order. Columns now
get a per-table sequence counter reflecting the order they were
declared.

.gitea/workflows/release.yml

@@ -222,6 +222,7 @@ jobs:
             PKGDIR="relspec_${PKGVER}_${GOARCH}"
             mkdir -p "${PKGDIR}/DEBIAN"
             mkdir -p "${PKGDIR}/usr/bin"
+            chmod -R 0755 "${PKGDIR}"
 
             install -m755 relspec "${PKGDIR}/usr/bin/relspec"
 

README.md

@@ -164,7 +164,12 @@ type, selected via `--types sqltypes`. See the
 [`pkg/sqltypes` README](./pkg/sqltypes/README.md) for the full type
 reference, or the [`bun`](./pkg/writers/bun/README.md) /
 [`gorm`](./pkg/writers/gorm/README.md) writer docs for the `--types` flag
-(`sqltypes`, `stdlib`, or `baselib`).
+(`sqltypes`, `stdlib`, or `baselib`). PostgreSQL array columns are the one
+exception: the `bun` writer always generates native Go slices (`[]string`,
+`[]int32`, …) with an explicit `array` bun tag, regardless of `--types` —
+see [`bun`'s `--array-nullable`](./pkg/writers/bun/README.md#nullablearrays)
+flag for nullable-array handling. The `SqlXxxArray` wrapper types remain
+available in `pkg/sqltypes` and are still used by the `gorm` writer.
 
 ## Contributing
 

cmd/relspec/convert.go

@@ -54,6 +54,7 @@ var (
 	convertSchemaFilter    string
 	convertFlattenSchema   bool
 	convertNullableTypes   string
+	convertNullableArrays  string
 	convertContinueOnError bool
 	convertExtraFields     string
 )
@@ -180,6 +181,7 @@ func init() {
 	convertCmd.Flags().StringVar(&convertSchemaFilter, "schema", "", "Filter to a specific schema by name (required for formats like dctx that only support single schemas)")
 	convertCmd.Flags().BoolVar(&convertFlattenSchema, "flatten-schema", false, "Flatten schema.table names to schema_table (useful for databases like SQLite that do not support schemas)")
 	convertCmd.Flags().StringVar(&convertNullableTypes, "types", "", "Nullable type package for code-gen writers (bun/gorm): 'baselib' (default, Go pointer types), 'stdlib' (database/sql), or 'sqltypes'")
+	convertCmd.Flags().StringVar(&convertNullableArrays, "array-nullable", "", "Nullable PostgreSQL array representation for the Bun writer in stdlib/baselib --types mode: 'slice' (default, plain slice) or 'pointer_slice' (*[]T, distinguishes NULL from '{}')")
 	convertCmd.Flags().BoolVar(&convertContinueOnError, "continue-on-error", false, "Prepend \\set ON_ERROR_STOP off to generated SQL so psql continues past errors (pgsql output only)")
 	convertCmd.Flags().StringVar(&convertExtraFields, "extra-fields", "", "Path to JSON file containing extra Bun model fields to inject (bun output only); fields support target_table, name, type, bun_tag, json_tag, comment")
 
@@ -248,7 +250,7 @@ func runConvert(cmd *cobra.Command, args []string) error {
 		fmt.Fprintf(os.Stderr, "      Schema: %s\n", convertSchemaFilter)
 	}
 
-	if err := writeDatabase(db, convertTargetType, convertTargetPath, convertPackageName, convertSchemaFilter, convertFlattenSchema, convertNullableTypes, convertContinueOnError, convertExtraFields); err != nil {
+	if err := writeDatabase(db, convertTargetType, convertTargetPath, convertPackageName, convertSchemaFilter, convertFlattenSchema, convertNullableTypes, convertNullableArrays, convertContinueOnError, convertExtraFields); err != nil {
 		return fmt.Errorf("failed to write target: %w", err)
 	}
 
@@ -388,10 +390,10 @@ func readDatabaseForConvert(dbType, filePath, connString string) (*models.Databa
 	return db, nil
 }
 
-func writeDatabase(db *models.Database, dbType, outputPath, packageName, schemaFilter string, flattenSchema bool, nullableTypes string, continueOnError bool, extraFields string) error {
+func writeDatabase(db *models.Database, dbType, outputPath, packageName, schemaFilter string, flattenSchema bool, nullableTypes, nullableArrays string, continueOnError bool, extraFields string) error {
 	var writer writers.Writer
 
-	writerOpts := newWriterOptions(outputPath, packageName, flattenSchema, nullableTypes, continueOnError)
+	writerOpts := newWriterOptions(outputPath, packageName, flattenSchema, nullableTypes, nullableArrays, continueOnError)
 	if extraFields != "" {
 		if !strings.EqualFold(dbType, "bun") {
 			return fmt.Errorf("--extra-fields is only supported for Bun output")

cmd/relspec/diff.go

@@ -16,6 +16,7 @@ import (
 	"git.warky.dev/wdevs/relspecgo/pkg/readers/drawdb"
 	"git.warky.dev/wdevs/relspecgo/pkg/readers/json"
 	"git.warky.dev/wdevs/relspecgo/pkg/readers/pgsql"
+	"git.warky.dev/wdevs/relspecgo/pkg/readers/sqldir"
 	"git.warky.dev/wdevs/relspecgo/pkg/readers/sqlite"
 	"git.warky.dev/wdevs/relspecgo/pkg/readers/yaml"
 )
@@ -87,11 +88,11 @@ Examples:
 }
 
 func init() {
-	diffCmd.Flags().StringVar(&sourceType, "from", "", "Source database format (dbml, dctx, drawdb, json, yaml, pgsql)")
+	diffCmd.Flags().StringVar(&sourceType, "from", "", "Source database format (dbml, dctx, drawdb, json, yaml, pgsql, sqldir)")
 	diffCmd.Flags().StringVar(&sourcePath, "from-path", "", "Source file path (for file-based formats)")
 	diffCmd.Flags().StringVar(&sourceConn, "from-conn", "", "Source connection string (for database formats)")
 
-	diffCmd.Flags().StringVar(&targetType, "to", "", "Target database format (dbml, dctx, drawdb, json, yaml, pgsql)")
+	diffCmd.Flags().StringVar(&targetType, "to", "", "Target database format (dbml, dctx, drawdb, json, yaml, pgsql, sqldir)")
 	diffCmd.Flags().StringVar(&targetPath, "to-path", "", "Target file path (for file-based formats)")
 	diffCmd.Flags().StringVar(&targetConn, "to-conn", "", "Target connection string (for database formats)")
 
@@ -129,10 +130,12 @@ func runDiff(cmd *cobra.Command, args []string) error {
 
 	fmt.Fprintf(os.Stderr, "      ✓ Successfully read database '%s'\n", sourceDB.Name)
 	sourceTables := 0
+	sourceScripts := 0
 	for _, schema := range sourceDB.Schemas {
 		sourceTables += len(schema.Tables)
+		sourceScripts += len(schema.Scripts)
 	}
-	fmt.Fprintf(os.Stderr, "      Found: %d schema(s), %d table(s)\n\n", len(sourceDB.Schemas), sourceTables)
+	fmt.Fprintf(os.Stderr, "      Found: %d schema(s), %d table(s), %d script(s)\n\n", len(sourceDB.Schemas), sourceTables, sourceScripts)
 
 	// Read target database
 	fmt.Fprintf(os.Stderr, "[2/3] Reading target schema...\n")
@@ -151,10 +154,12 @@ func runDiff(cmd *cobra.Command, args []string) error {
 
 	fmt.Fprintf(os.Stderr, "      ✓ Successfully read database '%s'\n", targetDB.Name)
 	targetTables := 0
+	targetScripts := 0
 	for _, schema := range targetDB.Schemas {
 		targetTables += len(schema.Tables)
+		targetScripts += len(schema.Scripts)
 	}
-	fmt.Fprintf(os.Stderr, "      Found: %d schema(s), %d table(s)\n\n", len(targetDB.Schemas), targetTables)
+	fmt.Fprintf(os.Stderr, "      Found: %d schema(s), %d table(s), %d script(s)\n\n", len(targetDB.Schemas), targetTables, targetScripts)
 
 	// Compare databases
 	fmt.Fprintf(os.Stderr, "[3/3] Comparing schemas...\n")
@@ -165,7 +170,8 @@ func runDiff(cmd *cobra.Command, args []string) error {
 		summary.Tables.Missing + summary.Tables.Extra + summary.Tables.Modified +
 		summary.Columns.Missing + summary.Columns.Extra + summary.Columns.Modified +
 		summary.Indexes.Missing + summary.Indexes.Extra + summary.Indexes.Modified +
-		summary.Constraints.Missing + summary.Constraints.Extra + summary.Constraints.Modified
+		summary.Constraints.Missing + summary.Constraints.Extra + summary.Constraints.Modified +
+		summary.Scripts.Missing + summary.Scripts.Extra + summary.Scripts.Modified
 
 	fmt.Fprintf(os.Stderr, "      ✓ Comparison complete\n")
 	fmt.Fprintf(os.Stderr, "      Found: %d difference(s)\n\n", totalDiffs)
@@ -249,6 +255,12 @@ func readDatabase(dbType, filePath, connString, label string) (*models.Database,
 		}
 		reader = yaml.NewReader(&readers.ReaderOptions{FilePath: filePath})
 
+	case "sqldir", "scripts", "scriptdir":
+		if filePath == "" {
+			return nil, fmt.Errorf("%s: file path is required for SQL directory format", label)
+		}
+		reader = sqldir.NewReader(&readers.ReaderOptions{FilePath: filePath})
+
 	case "pgsql", "postgres", "postgresql":
 		if connString == "" {
 			return nil, fmt.Errorf("%s: connection string is required for PostgreSQL format", label)

cmd/relspec/diff_sqldir_test.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestReadDatabaseSupportsSQLDir(t *testing.T) {
+	tempDir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(tempDir, "1_001_create_users.sql"), []byte("CREATE TABLE users (id int);"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(tempDir, "1_002_seed_users.pgsql"), []byte("INSERT INTO users (id) VALUES (1);"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := readDatabase("sqldir", tempDir, "", "source")
+	if err != nil {
+		t.Fatalf("readDatabase failed: %v", err)
+	}
+	if len(db.Schemas) != 1 {
+		t.Fatalf("expected 1 schema, got %d", len(db.Schemas))
+	}
+	if got := len(db.Schemas[0].Scripts); got != 2 {
+		t.Fatalf("expected 2 scripts, got %d", got)
+	}
+}

cmd/relspec/edit.go

@@ -323,31 +323,31 @@ func writeDatabaseForEdit(dbType, filePath, connString string, db *models.Databa
 
 	switch strings.ToLower(dbType) {
 	case "dbml":
-		writer = wdbml.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wdbml.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "dctx":
-		writer = wdctx.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wdctx.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "drawdb":
-		writer = wdrawdb.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wdrawdb.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "graphql":
-		writer = wgraphql.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wgraphql.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "json":
-		writer = wjson.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wjson.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "yaml":
-		writer = wyaml.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wyaml.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "gorm":
-		writer = wgorm.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wgorm.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "bun":
-		writer = wbun.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wbun.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "drizzle":
-		writer = wdrizzle.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wdrizzle.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "prisma":
-		writer = wprisma.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wprisma.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "typeorm":
-		writer = wtypeorm.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wtypeorm.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "sqlite", "sqlite3":
-		writer = wsqlite.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wsqlite.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	case "pgsql":
-		writer = wpgsql.NewWriter(newWriterOptions(filePath, "", false, "", false))
+		writer = wpgsql.NewWriter(newWriterOptions(filePath, "", false, "", "", false))
 	default:
 		return fmt.Errorf("%s: unsupported format: %s", label, dbType)
 	}

cmd/relspec/main.go

@@ -6,6 +6,7 @@ import (
 )
 
 func main() {
+	printVersionHeader(os.Args[1:])
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)

cmd/relspec/merge.go

@@ -117,7 +117,7 @@ func init() {
 	// Output flags
 	mergeCmd.Flags().StringVar(&mergeOutputType, "output", "", "Output format (required): dbml, dctx, drawdb, graphql, json, yaml, gorm, bun, drizzle, prisma, typeorm, pgsql")
 	mergeCmd.Flags().StringVar(&mergeOutputPath, "output-path", "", "Output file path (required for file-based formats)")
-	mergeCmd.Flags().StringVar(&mergeOutputConn, "output-conn", "", "Output connection string (for pgsql)")
+	mergeCmd.Flags().StringVar(&mergeOutputConn, "output-conn", "", "Output connection string (for pgsql) or database file path (for sqlite, to execute DDL directly instead of writing a .sql file)")
 
 	// Merge options
 	mergeCmd.Flags().BoolVar(&mergeSkipDomains, "skip-domains", false, "Skip domains during merge")
@@ -375,61 +375,69 @@ func writeDatabaseForMerge(dbType, filePath, connString string, db *models.Datab
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for DBML format", label)
 		}
-		writer = wdbml.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wdbml.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "dctx":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for DCTX format", label)
 		}
-		writer = wdctx.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wdctx.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "drawdb":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for DrawDB format", label)
 		}
-		writer = wdrawdb.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wdrawdb.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "graphql":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for GraphQL format", label)
 		}
-		writer = wgraphql.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wgraphql.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "json":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for JSON format", label)
 		}
-		writer = wjson.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wjson.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "yaml":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for YAML format", label)
 		}
-		writer = wyaml.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wyaml.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "gorm":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for GORM format", label)
 		}
-		writer = wgorm.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wgorm.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "bun":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for Bun format", label)
 		}
-		writer = wbun.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wbun.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "drizzle":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for Drizzle format", label)
 		}
-		writer = wdrizzle.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wdrizzle.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "prisma":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for Prisma format", label)
 		}
-		writer = wprisma.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wprisma.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "typeorm":
 		if filePath == "" {
 			return fmt.Errorf("%s: file path is required for TypeORM format", label)
 		}
-		writer = wtypeorm.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writer = wtypeorm.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", "", false))
 	case "sqlite", "sqlite3":
-		writer = wsqlite.NewWriter(newWriterOptions(filePath, "", flattenSchema, "", false))
+		writerOpts := newWriterOptions(filePath, "", flattenSchema, "", "", false)
+		if connString != "" {
+			// Execute DDL directly against the SQLite database file instead
+			// of writing a .sql script.
+			writerOpts.Metadata = map[string]interface{}{
+				"connection_string": connString,
+			}
+		}
+		writer = wsqlite.NewWriter(writerOpts)
 	case "pgsql":
-		writerOpts := newWriterOptions(filePath, "", flattenSchema, "", false)
+		writerOpts := newWriterOptions(filePath, "", flattenSchema, "", "", false)
 		if connString != "" {
 			writerOpts.Metadata = map[string]interface{}{
 				"connection_string": connString,

cmd/relspec/prisma_options.go

@@ -13,12 +13,13 @@ func newReaderOptions(filePath, connString string) *readers.ReaderOptions {
 	}
 }
 
-func newWriterOptions(outputPath, packageName string, flattenSchema bool, nullableTypes string, continueOnError bool) *writers.WriterOptions {
+func newWriterOptions(outputPath, packageName string, flattenSchema bool, nullableTypes, nullableArrays string, continueOnError bool) *writers.WriterOptions {
 	return &writers.WriterOptions{
 		OutputPath:      outputPath,
 		PackageName:     packageName,
 		FlattenSchema:   flattenSchema,
 		NullableTypes:   nullableTypes,
+		NullableArrays:  nullableArrays,
 		Prisma7:         prisma7,
 		ContinueOnError: continueOnError,
 	}

cmd/relspec/report.go

@@ -0,0 +1,243 @@
+package main
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/spf13/cobra"
+)
+
+const (
+	reportAPIBase   = "https://git.warky.dev/api/v1/repos/wdevs/relspecgo/issues"
+	reportRateLimit = time.Minute
+	reportTokenB64  = "OGQ4ODlhNmY2ZjQ5NjY5OTA5MTJhYTIyZjcyNzExMTNjZTEyZTRhMQ=="
+	reportStateFile = "report_state.json"
+)
+
+var (
+	reportBody  string
+	reportName  string
+	reportEmail string
+)
+
+var reportCmd = &cobra.Command{
+	Use:   "report",
+	Short: "Report a bug or feature request against RelSpec",
+	Long:  "Report a bug or feature request directly to the RelSpec issue tracker.",
+}
+
+var reportBugCmd = &cobra.Command{
+	Use:   "bug <title>",
+	Short: "Report a bug",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return submitReport("Bug", args[0], reportBody, reportName, reportEmail)
+	},
+}
+
+var reportFeatureCmd = &cobra.Command{
+	Use:   "feature <title>",
+	Short: "Report a feature request",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return submitReport("Feature", args[0], reportBody, reportName, reportEmail)
+	},
+}
+
+func init() {
+	for _, c := range []*cobra.Command{reportBugCmd, reportFeatureCmd} {
+		c.Flags().StringVar(&reportBody, "body", "", "Detailed description of the report")
+		c.Flags().StringVar(&reportName, "name", "", "Optional name, if you'd like feedback on this report")
+		c.Flags().StringVar(&reportEmail, "email", "", "Optional email address, if you'd like feedback on this report")
+	}
+	reportCmd.AddCommand(reportBugCmd)
+	reportCmd.AddCommand(reportFeatureCmd)
+}
+
+type reportState struct {
+	LastReport time.Time `json:"last_report"`
+	MachineID  string    `json:"machine_id,omitempty"`
+}
+
+func reportStateDir() (string, error) {
+	configDir, err := os.UserConfigDir()
+	if err != nil {
+		return "", err
+	}
+	dir := filepath.Join(configDir, "relspec")
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return "", err
+	}
+	return dir, nil
+}
+
+func loadReportState() (reportState, string, error) {
+	dir, err := reportStateDir()
+	if err != nil {
+		return reportState{}, "", err
+	}
+	path := filepath.Join(dir, reportStateFile)
+
+	var state reportState
+	data, err := os.ReadFile(path)
+	if err == nil {
+		_ = json.Unmarshal(data, &state)
+	}
+	return state, path, nil
+}
+
+func saveReportState(path string, state reportState) error {
+	data, err := json.MarshalIndent(state, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(path, data, 0o600)
+}
+
+// systemUniqueID returns the OS machine id, falling back to a locally
+// persisted UUID if the platform-specific id cannot be read.
+func systemUniqueID(state reportState, statePath string) (string, error) {
+	if id, err := osMachineID(); err == nil && id != "" {
+		return id, nil
+	}
+
+	if state.MachineID != "" {
+		return state.MachineID, nil
+	}
+
+	id := uuid.NewString()
+	state.MachineID = id
+	if err := saveReportState(statePath, state); err != nil {
+		return "", err
+	}
+	return id, nil
+}
+
+func osMachineID() (string, error) {
+	switch runtime.GOOS {
+	case "linux":
+		for _, path := range []string{"/etc/machine-id", "/var/lib/dbus/machine-id"} {
+			data, err := os.ReadFile(path)
+			if err == nil {
+				return strings.TrimSpace(string(data)), nil
+			}
+		}
+		return "", fmt.Errorf("no machine-id file found")
+	case "darwin":
+		out, err := exec.Command("ioreg", "-rd1", "-c", "IOPlatformExpertDevice").Output()
+		if err != nil {
+			return "", err
+		}
+		re := regexp.MustCompile(`"IOPlatformUUID"\s*=\s*"([^"]+)"`)
+		match := re.FindSubmatch(out)
+		if match == nil {
+			return "", fmt.Errorf("IOPlatformUUID not found")
+		}
+		return string(match[1]), nil
+	case "windows":
+		out, err := exec.Command("reg", "query", `HKLM\SOFTWARE\Microsoft\Cryptography`, "/v", "MachineGuid").Output()
+		if err != nil {
+			return "", err
+		}
+		re := regexp.MustCompile(`MachineGuid\s+REG_SZ\s+(\S+)`)
+		match := re.FindSubmatch(out)
+		if match == nil {
+			return "", fmt.Errorf("MachineGuid not found")
+		}
+		return string(match[1]), nil
+	default:
+		return "", fmt.Errorf("unsupported platform: %s", runtime.GOOS)
+	}
+}
+
+func reportToken() (string, error) {
+	decoded, err := base64.StdEncoding.DecodeString(reportTokenB64)
+	if err != nil {
+		return "", fmt.Errorf("decode report token: %w", err)
+	}
+	return string(decoded), nil
+}
+
+type createIssueRequest struct {
+	Title string `json:"title"`
+	Body  string `json:"body"`
+}
+
+func submitReport(kind, title, body, name, email string) error {
+	state, statePath, err := loadReportState()
+	if err != nil {
+		return fmt.Errorf("load report state: %w", err)
+	}
+
+	if !state.LastReport.IsZero() {
+		if wait := reportRateLimit - time.Since(state.LastReport); wait > 0 {
+			return fmt.Errorf("please wait %s before submitting another report", wait.Round(time.Second))
+		}
+	}
+
+	id, err := systemUniqueID(state, statePath)
+	if err != nil {
+		return fmt.Errorf("determine system id: %w", err)
+	}
+
+	token, err := reportToken()
+	if err != nil {
+		return err
+	}
+
+	fullTitle := fmt.Sprintf("[%s] %s (id: %s)", kind, title, id)
+
+	fullBody := body
+	if name != "" || email != "" {
+		var contact []string
+		if name != "" {
+			contact = append(contact, "Name: "+name)
+		}
+		if email != "" {
+			contact = append(contact, "Email: "+email)
+		}
+		fullBody = strings.TrimSpace(fullBody + "\n\n---\n" + strings.Join(contact, "\n"))
+	}
+
+	payload, err := json.Marshal(createIssueRequest{Title: fullTitle, Body: fullBody})
+	if err != nil {
+		return fmt.Errorf("build request: %w", err)
+	}
+
+	req, err := http.NewRequest(http.MethodPost, reportAPIBase, bytes.NewReader(payload))
+	if err != nil {
+		return fmt.Errorf("build request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "token "+token)
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("submit report: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusCreated {
+		return fmt.Errorf("submit report: unexpected status %s", resp.Status)
+	}
+
+	state.LastReport = time.Now()
+	state.MachineID = id
+	if err := saveReportState(statePath, state); err != nil {
+		return fmt.Errorf("save report state: %w", err)
+	}
+
+	fmt.Printf("Report submitted: %s\n", fullTitle)
+	return nil
+}

cmd/relspec/root.go

@@ -13,6 +13,7 @@ var (
 	version   = "dev"
 	buildDate = "unknown"
 	prisma7   bool
+	noVersion bool
 )
 
 func init() {
@@ -54,9 +55,6 @@ bidirectional conversion between various database schema formats.
 It reads database schemas from multiple sources (live databases, DBML,
 DCTX, DrawDB, etc.) and writes them to various formats (GORM, Bun,
 JSON, YAML, SQL, etc.).`,
-	PersistentPreRun: func(cmd *cobra.Command, args []string) {
-		fmt.Printf("RelSpec %s (built: %s)\n\n", version, buildDate)
-	},
 }
 
 func init() {
@@ -70,5 +68,24 @@ func init() {
 	rootCmd.AddCommand(mergeCmd)
 	rootCmd.AddCommand(splitCmd)
 	rootCmd.AddCommand(versionCmd)
+	rootCmd.AddCommand(reportCmd)
 	rootCmd.PersistentFlags().BoolVar(&prisma7, "prisma7", false, "Use Prisma 7 generator conventions when reading/writing Prisma schemas")
+	rootCmd.PersistentFlags().BoolVar(&noVersion, "no-version", false, "Suppress the RelSpec version header")
+}
+
+// printVersionHeader prints the "RelSpec <version> (built: <date>)" banner
+// that precedes all command output. It is invoked from main() before cobra
+// parses/executes anything, so it runs even for --help and bare invocations.
+// It is skipped when --no-version is present, or when the version subcommand
+// is being run (which prints its own, more detailed output).
+func printVersionHeader(args []string) {
+	for _, a := range args {
+		if a == "--no-version" {
+			return
+		}
+	}
+	if len(args) > 0 && args[0] == "version" {
+		return
+	}
+	fmt.Printf("RelSpec %s (built: %s)\n\n", version, buildDate)
 }

cmd/relspec/split.go

@@ -11,18 +11,19 @@ import (
 )
 
 var (
-	splitSourceType    string
-	splitSourcePath    string
-	splitSourceConn    string
-	splitTargetType    string
-	splitTargetPath    string
-	splitSchemas       string
-	splitTables        string
-	splitPackageName   string
-	splitDatabaseName  string
-	splitExcludeSchema string
-	splitExcludeTables string
-	splitNullableTypes string
+	splitSourceType     string
+	splitSourcePath     string
+	splitSourceConn     string
+	splitTargetType     string
+	splitTargetPath     string
+	splitSchemas        string
+	splitTables         string
+	splitPackageName    string
+	splitDatabaseName   string
+	splitExcludeSchema  string
+	splitExcludeTables  string
+	splitNullableTypes  string
+	splitNullableArrays string
 )
 
 var splitCmd = &cobra.Command{
@@ -112,6 +113,7 @@ func init() {
 	splitCmd.Flags().StringVar(&splitExcludeSchema, "exclude-schema", "", "Comma-separated list of schema names to exclude")
 	splitCmd.Flags().StringVar(&splitExcludeTables, "exclude-tables", "", "Comma-separated list of table names to exclude (case-insensitive)")
 	splitCmd.Flags().StringVar(&splitNullableTypes, "types", "", "Nullable type package for code-gen writers (bun/gorm): 'baselib' (default, Go pointer types), 'stdlib' (database/sql), or 'sqltypes'")
+	splitCmd.Flags().StringVar(&splitNullableArrays, "array-nullable", "", "Nullable PostgreSQL array representation for the Bun writer in stdlib/baselib --types mode: 'slice' (default, plain slice) or 'pointer_slice' (*[]T, distinguishes NULL from '{}')")
 
 	err := splitCmd.MarkFlagRequired("from")
 	if err != nil {
@@ -188,6 +190,7 @@ func runSplit(cmd *cobra.Command, args []string) error {
 		"",    // no schema filter for split
 		false, // no flatten-schema for split
 		splitNullableTypes,
+		splitNullableArrays,
 		false, // no continue-on-error for split
 		"",    // no extra fields for split
 	)

docs/SCRIPTS_COMMAND.md

@@ -85,6 +85,23 @@ migrations/
 
 All files will be found and executed in Priority→Sequence order regardless of directory structure.
 
+## External File Embedding
+
+Script SQL can embed nearby text or binary files before execution using `-- @embed` directives:
+
+```sql
+-- @embed: path=assets/message.txt var=:message mode=text
+-- @embed: path=assets/photo.bin var=:payload mode=base64
+INSERT INTO assets (message, payload)
+VALUES (:message, decode(:payload, 'base64')::bytea);
+```
+
+- `path`: File path resolved relative to the SQL file containing the directive
+- `var`: Named placeholder to replace, such as `:message`
+- `mode`: `text` embeds an escaped SQL string literal; `base64` embeds a base64 string literal
+
+The directive comment is removed from the SQL, and every matching placeholder is replaced before the script is listed or executed.
+
 ## Commands
 
 ### relspec scripts list

go.mod

@@ -11,6 +11,7 @@ require (
 	github.com/spf13/cobra v1.10.2
 	github.com/stretchr/testify v1.11.1
 	github.com/uptrace/bun v1.2.18
+	github.com/uptrace/bun/dialect/pgdialect v1.2.18
 	golang.org/x/text v0.37.0
 	gopkg.in/yaml.v3 v3.0.1
 	modernc.org/sqlite v1.50.1
@@ -25,6 +26,7 @@ require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/lucasb-eyer/go-colorful v1.4.0 // indirect
@@ -41,6 +43,7 @@ require (
 	github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect
 	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
 	golang.org/x/crypto v0.51.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/sys v0.44.0 // indirect
 	golang.org/x/term v0.43.0 // indirect
 	golang.org/x/tools v0.45.0 // indirect

go.sum

@@ -92,6 +92,8 @@ github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc h1:9lRDQMhESg+zvGYm
 github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc/go.mod h1:bciPuU6GHm1iF1pBvUfxfsH0Wmnc2VbpgvbI9ZWuIRs=
 github.com/uptrace/bun v1.2.18 h1:3HnRcMfS6OBPMG1eSOzlbFJ/X/AyMEJb7rMxE6VQvDU=
 github.com/uptrace/bun v1.2.18/go.mod h1:wNltaKJk4JtOt4SG5I5zmA7v0/Mzjh1+/S906Rayd3Y=
+github.com/uptrace/bun/dialect/pgdialect v1.2.18 h1:IZ6nM2+OYrL8lkEAy7UkSEZvoa3vluTAUlZfPtlRB2k=
+github.com/uptrace/bun/dialect/pgdialect v1.2.18/go.mod h1:Tqdf4QP1okrGYpXfodXvCOK6Ob1OOTwSaoAzCgBB3IU=
 github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8=
 github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok=
 github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=

linux/arch/PKGBUILD

@@ -1,6 +1,6 @@
 # Maintainer: Hein (Warky Devs) <hein@warky.dev>
 pkgname=relspec
-pkgver=1.0.63
+pkgver=1.0.73
 pkgrel=1
 pkgdesc="RelSpec is a comprehensive database relations management tool that reads, transforms, and writes database table specifications across multiple formats and ORMs."
 arch=('x86_64' 'aarch64')

linux/centos/relspec.spec

@@ -1,5 +1,5 @@
 Name:           relspec
-Version:        1.0.63
+Version:        1.0.73
 Release:        1%{?dist}
 Summary:        RelSpec is a comprehensive database relations management tool that reads, transforms, and writes database table specifications across multiple formats and ORMs.
 

pkg/assetloader/embed.go

@@ -0,0 +1,165 @@
+package assetloader
+
+import (
+	"encoding/base64"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+const ScriptSourcePathMetadataKey = "source_path"
+
+var (
+	embedDirectivePattern = regexp.MustCompile(`(?m)^\s*--\s*@embed:\s*(.+?)\s*$`)
+	embedAttrPattern      = regexp.MustCompile(`([a-zA-Z_][a-zA-Z0-9_]*)=("[^"]*"|'[^']*'|\S+)`)
+	embedVarPattern       = regexp.MustCompile(`^:[a-zA-Z_][a-zA-Z0-9_]*$`)
+)
+
+// ProcessEmbedDirectives expands SQL comments in the form:
+//
+//	-- @embed: path=... var=:... mode=text|base64
+//
+// Paths are resolved relative to sqlPath. Text mode embeds a quoted UTF-8 SQL
+// string literal. Base64 mode embeds a quoted base64 literal suitable for
+// decode(:var, 'base64').
+func ProcessEmbedDirectives(sqlPath, sql string) (string, error) {
+	directives := embedDirectivePattern.FindAllStringSubmatch(sql, -1)
+	if len(directives) == 0 {
+		return sql, nil
+	}
+
+	if sqlPath == "" {
+		return "", fmt.Errorf("sql path is required for embed directives")
+	}
+
+	result := embedDirectivePattern.ReplaceAllString(sql, "")
+	for i, directive := range directives {
+		literal, placeholder, err := embedDirectiveLiteral(sqlPath, directive[1], i+1)
+		if err != nil {
+			return "", err
+		}
+		if !embedPlaceholderPattern(placeholder).MatchString(result) {
+			return "", fmt.Errorf("%s embed directive %d: placeholder %s not found", sqlPath, i+1, placeholder)
+		}
+		result = replaceEmbedPlaceholder(result, placeholder, literal)
+	}
+
+	return result, nil
+}
+
+func embedDirectiveLiteral(sqlPath, raw string, directiveNumber int) (literal, placeholder string, err error) {
+	attrs, err := parseEmbedAttrs(raw)
+	if err != nil {
+		return "", "", fmt.Errorf("%s embed directive %d: %w", sqlPath, directiveNumber, err)
+	}
+
+	pathValue := attrs["path"]
+	varValue := attrs["var"]
+	modeValue := attrs["mode"]
+	if pathValue == "" {
+		return "", "", fmt.Errorf("%s embed directive %d: missing path", sqlPath, directiveNumber)
+	}
+	if !embedVarPattern.MatchString(varValue) {
+		return "", "", fmt.Errorf("%s embed directive %d: var must be a named placeholder like :asset", sqlPath, directiveNumber)
+	}
+	if modeValue != "text" && modeValue != "base64" {
+		return "", "", fmt.Errorf("%s embed directive %d: mode must be text or base64", sqlPath, directiveNumber)
+	}
+
+	resolved := filepath.Join(filepath.Dir(sqlPath), filepath.Clean(pathValue))
+	data, err := os.ReadFile(resolved)
+	if err != nil {
+		return "", "", fmt.Errorf("%s embed directive %d: reading %s: %w", sqlPath, directiveNumber, resolved, err)
+	}
+
+	switch modeValue {
+	case "text":
+		if !utf8.Valid(data) {
+			return "", "", fmt.Errorf("%s embed directive %d: %s is not valid UTF-8", sqlPath, directiveNumber, resolved)
+		}
+		literal, err := sqlStringLiteral(string(data))
+		if err != nil {
+			return "", "", fmt.Errorf("%s embed directive %d: %w", sqlPath, directiveNumber, err)
+		}
+		return literal, varValue, nil
+	case "base64":
+		literal, err := sqlStringLiteral(base64.StdEncoding.EncodeToString(data))
+		if err != nil {
+			return "", "", fmt.Errorf("%s embed directive %d: %w", sqlPath, directiveNumber, err)
+		}
+		return literal, varValue, nil
+	default:
+		return "", "", fmt.Errorf("%s embed directive %d: mode must be text or base64", sqlPath, directiveNumber)
+	}
+}
+
+func parseEmbedAttrs(raw string) (map[string]string, error) {
+	attrs := map[string]string{}
+	matches := embedAttrPattern.FindAllStringSubmatchIndex(raw, -1)
+	if len(matches) == 0 {
+		return nil, fmt.Errorf("expected path, var, and mode attributes")
+	}
+
+	lastEnd := 0
+	for _, match := range matches {
+		gap := strings.TrimSpace(raw[lastEnd:match[0]])
+		if gap != "" {
+			return nil, fmt.Errorf("invalid attribute syntax near %q", gap)
+		}
+
+		key := raw[match[2]:match[3]]
+		value := raw[match[4]:match[5]]
+		if _, exists := attrs[key]; exists {
+			return nil, fmt.Errorf("duplicate attribute %q", key)
+		}
+		unquoted, err := unquoteEmbedValue(value)
+		if err != nil {
+			return nil, fmt.Errorf("invalid %s value: %w", key, err)
+		}
+		attrs[key] = unquoted
+		lastEnd = match[1]
+	}
+	if tail := strings.TrimSpace(raw[lastEnd:]); tail != "" {
+		return nil, fmt.Errorf("invalid attribute syntax near %q", tail)
+	}
+
+	for key := range attrs {
+		if key != "path" && key != "var" && key != "mode" {
+			return nil, fmt.Errorf("unknown attribute %q", key)
+		}
+	}
+
+	return attrs, nil
+}
+
+func unquoteEmbedValue(value string) (string, error) {
+	if len(value) < 2 {
+		return value, nil
+	}
+	if value[0] == '"' {
+		return strconv.Unquote(value)
+	}
+	if value[0] == '\'' && value[len(value)-1] == '\'' {
+		return value[1 : len(value)-1], nil
+	}
+	return value, nil
+}
+
+func sqlStringLiteral(value string) (string, error) {
+	if strings.ContainsRune(value, '\x00') {
+		return "", fmt.Errorf("embedded text contains NUL byte")
+	}
+	return "'" + strings.ReplaceAll(value, "'", "''") + "'", nil
+}
+
+func replaceEmbedPlaceholder(sql, placeholder, literal string) string {
+	return embedPlaceholderPattern(placeholder).ReplaceAllString(sql, "${1}"+literal+"${2}")
+}
+
+func embedPlaceholderPattern(placeholder string) *regexp.Regexp {
+	return regexp.MustCompile(`(^|[^a-zA-Z0-9_:])` + regexp.QuoteMeta(placeholder) + `([^a-zA-Z0-9_]|$)`)
+}

pkg/assetloader/embed_test.go

@@ -0,0 +1,143 @@
+package assetloader
+
+import (
+	"encoding/base64"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestProcessEmbedDirectives_TextLiteralEscapesQuotes(t *testing.T) {
+	dir := t.TempDir()
+	sqlPath := filepath.Join(dir, "1_001_seed.sql")
+	if err := os.WriteFile(filepath.Join(dir, "body.txt"), []byte("Line 1\nIt's fine"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := ProcessEmbedDirectives(sqlPath, `
+-- @embed: path=body.txt var=:body mode=text
+INSERT INTO notes (body) VALUES (:body);
+`)
+	if err != nil {
+		t.Fatalf("ProcessEmbedDirectives failed: %v", err)
+	}
+	if !strings.Contains(got, "VALUES ('Line 1\nIt''s fine');") {
+		t.Fatalf("embedded SQL did not contain escaped text literal:\n%s", got)
+	}
+	if strings.Contains(got, "VALUES (:body);") {
+		t.Fatalf("placeholder was not replaced:\n%s", got)
+	}
+}
+
+func TestProcessEmbedDirectives_Base64Literal(t *testing.T) {
+	dir := t.TempDir()
+	sqlPath := filepath.Join(dir, "1_001_seed.sql")
+	binary := []byte{0x00, 0xff, 0x10, 0x20}
+	if err := os.WriteFile(filepath.Join(dir, "blob.bin"), binary, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := ProcessEmbedDirectives(sqlPath, `
+-- @embed: path=blob.bin var=:payload mode=base64
+INSERT INTO files (payload) VALUES (decode(:payload, 'base64')::bytea);
+`)
+	if err != nil {
+		t.Fatalf("ProcessEmbedDirectives failed: %v", err)
+	}
+	want := "decode('" + base64.StdEncoding.EncodeToString(binary) + "', 'base64')::bytea"
+	if !strings.Contains(got, want) {
+		t.Fatalf("embedded SQL did not contain base64 literal %q:\n%s", want, got)
+	}
+}
+
+func TestProcessEmbedDirectives_RelativeToSQLFile(t *testing.T) {
+	root := t.TempDir()
+	sqlDir := filepath.Join(root, "nested", "seed")
+	if err := os.MkdirAll(filepath.Join(sqlDir, "assets"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	sqlPath := filepath.Join(sqlDir, "1_001_seed.sql")
+	if err := os.WriteFile(filepath.Join(sqlDir, "assets", "body.txt"), []byte("relative body"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := ProcessEmbedDirectives(sqlPath, `
+-- @embed: path=assets/body.txt var=:body mode=text
+SELECT :body;
+`)
+	if err != nil {
+		t.Fatalf("ProcessEmbedDirectives failed: %v", err)
+	}
+	if !strings.Contains(got, "SELECT 'relative body';") {
+		t.Fatalf("path was not resolved relative to SQL file:\n%s", got)
+	}
+}
+
+func TestProcessEmbedDirectives_InvalidDirectiveAndFiles(t *testing.T) {
+	dir := t.TempDir()
+	sqlPath := filepath.Join(dir, "1_001_seed.sql")
+	if err := os.WriteFile(filepath.Join(dir, "body.txt"), []byte("ok"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "binary.txt"), []byte{0xff, 0xfe}, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	tests := []struct {
+		name string
+		sql  string
+	}{
+		{
+			name: "missing mode",
+			sql:  "-- @embed: path=body.txt var=:body\nSELECT :body;",
+		},
+		{
+			name: "invalid var",
+			sql:  "-- @embed: path=body.txt var=body mode=text\nSELECT :body;",
+		},
+		{
+			name: "missing file",
+			sql:  "-- @embed: path=missing.txt var=:body mode=text\nSELECT :body;",
+		},
+		{
+			name: "invalid utf8 text",
+			sql:  "-- @embed: path=binary.txt var=:body mode=text\nSELECT :body;",
+		},
+		{
+			name: "placeholder not found",
+			sql:  "-- @embed: path=body.txt var=:body mode=text\nSELECT 1;",
+		},
+		{
+			name: "unknown attribute",
+			sql:  "-- @embed: path=body.txt var=:body mode=text extra=yes\nSELECT :body;",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if _, err := ProcessEmbedDirectives(sqlPath, tt.sql); err == nil {
+				t.Fatal("expected error, got nil")
+			}
+		})
+	}
+}
+
+func TestProcessEmbedDirectives_DoesNotReplacePlaceholderPrefix(t *testing.T) {
+	dir := t.TempDir()
+	sqlPath := filepath.Join(dir, "1_001_seed.sql")
+	if err := os.WriteFile(filepath.Join(dir, "body.txt"), []byte("ok"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := ProcessEmbedDirectives(sqlPath, `
+-- @embed: path=body.txt var=:body mode=text
+SELECT :body, :body_extra;
+`)
+	if err != nil {
+		t.Fatalf("ProcessEmbedDirectives failed: %v", err)
+	}
+	if !strings.Contains(got, "SELECT 'ok', :body_extra;") {
+		t.Fatalf("placeholder boundary was not respected:\n%s", got)
+	}
+}

pkg/diff/diff.go

@@ -1,11 +1,24 @@
 package diff
 
 import (
+	"fmt"
 	"reflect"
+	"sort"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 )
 
+// sortedKeys returns a map's keys sorted alphabetically, so callers get a
+// deterministic iteration order instead of Go's randomized map order.
+func sortedKeys[T any](m map[string]T) []string {
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
 // CompareDatabases compares two database models and returns the differences
 func CompareDatabases(source, target *models.Database) *DiffResult {
 	result := &DiffResult{
@@ -34,7 +47,8 @@ func compareSchemas(source, target []*models.Schema) *SchemaDiff {
 	}
 
 	// Find missing and modified schemas
-	for name, srcSchema := range sourceMap {
+	for _, name := range sortedKeys(sourceMap) {
+		srcSchema := sourceMap[name]
 		if tgtSchema, exists := targetMap[name]; !exists {
 			diff.Missing = append(diff.Missing, srcSchema)
 		} else {
@@ -45,7 +59,8 @@ func compareSchemas(source, target []*models.Schema) *SchemaDiff {
 	}
 
 	// Find extra schemas
-	for name, tgtSchema := range targetMap {
+	for _, name := range sortedKeys(targetMap) {
+		tgtSchema := targetMap[name]
 		if _, exists := sourceMap[name]; !exists {
 			diff.Extra = append(diff.Extra, tgtSchema)
 		}
@@ -82,6 +97,13 @@ func compareSchemaDetails(source, target *models.Schema) *SchemaChange {
 		hasChanges = true
 	}
 
+	// Compare scripts
+	scriptDiff := compareScripts(source.Scripts, target.Scripts)
+	if !isEmpty(scriptDiff) {
+		change.Scripts = scriptDiff
+		hasChanges = true
+	}
+
 	if !hasChanges {
 		return nil
 	}
@@ -106,7 +128,8 @@ func compareTables(source, target []*models.Table) *TableDiff {
 	}
 
 	// Find missing and modified tables
-	for name, srcTable := range sourceMap {
+	for _, name := range sortedKeys(sourceMap) {
+		srcTable := sourceMap[name]
 		if tgtTable, exists := targetMap[name]; !exists {
 			diff.Missing = append(diff.Missing, srcTable)
 		} else {
@@ -117,7 +140,8 @@ func compareTables(source, target []*models.Table) *TableDiff {
 	}
 
 	// Find extra tables
-	for name, tgtTable := range targetMap {
+	for _, name := range sortedKeys(targetMap) {
+		tgtTable := targetMap[name]
 		if _, exists := sourceMap[name]; !exists {
 			diff.Extra = append(diff.Extra, tgtTable)
 		}
@@ -176,7 +200,8 @@ func compareColumns(source, target map[string]*models.Column) *ColumnDiff {
 	}
 
 	// Find missing and modified columns
-	for name, srcCol := range source {
+	for _, name := range sortedKeys(source) {
+		srcCol := source[name]
 		if tgtCol, exists := target[name]; !exists {
 			diff.Missing = append(diff.Missing, srcCol)
 		} else {
@@ -192,7 +217,8 @@ func compareColumns(source, target map[string]*models.Column) *ColumnDiff {
 	}
 
 	// Find extra columns
-	for name, tgtCol := range target {
+	for _, name := range sortedKeys(target) {
+		tgtCol := target[name]
 		if _, exists := source[name]; !exists {
 			diff.Extra = append(diff.Extra, tgtCol)
 		}
@@ -240,7 +266,8 @@ func compareIndexes(source, target map[string]*models.Index) *IndexDiff {
 	}
 
 	// Find missing and modified indexes
-	for name, srcIdx := range source {
+	for _, name := range sortedKeys(source) {
+		srcIdx := source[name]
 		if tgtIdx, exists := target[name]; !exists {
 			diff.Missing = append(diff.Missing, srcIdx)
 		} else {
@@ -256,7 +283,8 @@ func compareIndexes(source, target map[string]*models.Index) *IndexDiff {
 	}
 
 	// Find extra indexes
-	for name, tgtIdx := range target {
+	for _, name := range sortedKeys(target) {
+		tgtIdx := target[name]
 		if _, exists := source[name]; !exists {
 			diff.Extra = append(diff.Extra, tgtIdx)
 		}
@@ -292,7 +320,8 @@ func compareConstraints(source, target map[string]*models.Constraint) *Constrain
 	}
 
 	// Find missing and modified constraints
-	for name, srcCon := range source {
+	for _, name := range sortedKeys(source) {
+		srcCon := source[name]
 		if tgtCon, exists := target[name]; !exists {
 			diff.Missing = append(diff.Missing, srcCon)
 		} else {
@@ -308,7 +337,8 @@ func compareConstraints(source, target map[string]*models.Constraint) *Constrain
 	}
 
 	// Find extra constraints
-	for name, tgtCon := range target {
+	for _, name := range sortedKeys(target) {
+		tgtCon := target[name]
 		if _, exists := source[name]; !exists {
 			diff.Extra = append(diff.Extra, tgtCon)
 		}
@@ -350,7 +380,8 @@ func compareRelationships(source, target map[string]*models.Relationship) *Relat
 	}
 
 	// Find missing and modified relationships
-	for name, srcRel := range source {
+	for _, name := range sortedKeys(source) {
+		srcRel := source[name]
 		if tgtRel, exists := target[name]; !exists {
 			diff.Missing = append(diff.Missing, srcRel)
 		} else {
@@ -366,7 +397,8 @@ func compareRelationships(source, target map[string]*models.Relationship) *Relat
 	}
 
 	// Find extra relationships
-	for name, tgtRel := range target {
+	for _, name := range sortedKeys(target) {
+		tgtRel := target[name]
 		if _, exists := source[name]; !exists {
 			diff.Extra = append(diff.Extra, tgtRel)
 		}
@@ -415,7 +447,8 @@ func compareViews(source, target []*models.View) *ViewDiff {
 	}
 
 	// Find missing and modified views
-	for name, srcView := range sourceMap {
+	for _, name := range sortedKeys(sourceMap) {
+		srcView := sourceMap[name]
 		if tgtView, exists := targetMap[name]; !exists {
 			diff.Missing = append(diff.Missing, srcView)
 		} else {
@@ -431,7 +464,8 @@ func compareViews(source, target []*models.View) *ViewDiff {
 	}
 
 	// Find extra views
-	for name, tgtView := range targetMap {
+	for _, name := range sortedKeys(targetMap) {
+		tgtView := targetMap[name]
 		if _, exists := sourceMap[name]; !exists {
 			diff.Extra = append(diff.Extra, tgtView)
 		}
@@ -468,7 +502,8 @@ func compareSequences(source, target []*models.Sequence) *SequenceDiff {
 	}
 
 	// Find missing and modified sequences
-	for name, srcSeq := range sourceMap {
+	for _, name := range sortedKeys(sourceMap) {
+		srcSeq := sourceMap[name]
 		if tgtSeq, exists := targetMap[name]; !exists {
 			diff.Missing = append(diff.Missing, srcSeq)
 		} else {
@@ -484,7 +519,8 @@ func compareSequences(source, target []*models.Sequence) *SequenceDiff {
 	}
 
 	// Find extra sequences
-	for name, tgtSeq := range targetMap {
+	for _, name := range sortedKeys(targetMap) {
+		tgtSeq := targetMap[name]
 		if _, exists := sourceMap[name]; !exists {
 			diff.Extra = append(diff.Extra, tgtSeq)
 		}
@@ -515,6 +551,79 @@ func compareSequenceDetails(source, target *models.Sequence) map[string]any {
 	return changes
 }
 
+func compareScripts(source, target []*models.Script) *ScriptDiff {
+	diff := &ScriptDiff{
+		Missing:  make([]*models.Script, 0),
+		Extra:    make([]*models.Script, 0),
+		Modified: make([]*ScriptChange, 0),
+	}
+
+	sourceMap := make(map[string]*models.Script)
+	targetMap := make(map[string]*models.Script)
+
+	for _, s := range source {
+		sourceMap[scriptCompareKey(s)] = s
+	}
+	for _, s := range target {
+		targetMap[scriptCompareKey(s)] = s
+	}
+
+	for _, name := range sortedKeys(sourceMap) {
+		srcScript := sourceMap[name]
+		if tgtScript, exists := targetMap[name]; !exists {
+			diff.Missing = append(diff.Missing, srcScript)
+		} else if changes := compareScriptDetails(srcScript, tgtScript); len(changes) > 0 {
+			diff.Modified = append(diff.Modified, &ScriptChange{
+				Name:    srcScript.Name,
+				Source:  srcScript,
+				Target:  tgtScript,
+				Changes: changes,
+			})
+		}
+	}
+
+	for _, name := range sortedKeys(targetMap) {
+		tgtScript := targetMap[name]
+		if _, exists := sourceMap[name]; !exists {
+			diff.Extra = append(diff.Extra, tgtScript)
+		}
+	}
+
+	return diff
+}
+
+func scriptCompareKey(script *models.Script) string {
+	return fmt.Sprintf("%d:%d:%s", script.Priority, script.Sequence, script.SQLName())
+}
+
+func compareScriptDetails(source, target *models.Script) map[string]any {
+	changes := make(map[string]any)
+
+	if source.SQL != target.SQL {
+		changes["sql"] = map[string]string{"source": source.SQL, "target": target.SQL}
+	}
+	if source.Rollback != target.Rollback {
+		changes["rollback"] = map[string]string{"source": source.Rollback, "target": target.Rollback}
+	}
+	if !reflect.DeepEqual(source.RunAfter, target.RunAfter) {
+		changes["run_after"] = map[string][]string{"source": source.RunAfter, "target": target.RunAfter}
+	}
+	if source.Schema != target.Schema {
+		changes["schema"] = map[string]string{"source": source.Schema, "target": target.Schema}
+	}
+	if source.Version != target.Version {
+		changes["version"] = map[string]string{"source": source.Version, "target": target.Version}
+	}
+	if source.Priority != target.Priority {
+		changes["priority"] = map[string]int{"source": source.Priority, "target": target.Priority}
+	}
+	if source.Sequence != target.Sequence {
+		changes["sequence"] = map[string]uint{"source": source.Sequence, "target": target.Sequence}
+	}
+
+	return changes
+}
+
 // Helper function to check if a diff is empty
 func isEmpty(v any) bool {
 	switch d := v.(type) {
@@ -532,6 +641,8 @@ func isEmpty(v any) bool {
 		return len(d.Missing) == 0 && len(d.Extra) == 0 && len(d.Modified) == 0
 	case *SequenceDiff:
 		return len(d.Missing) == 0 && len(d.Extra) == 0 && len(d.Modified) == 0
+	case *ScriptDiff:
+		return len(d.Missing) == 0 && len(d.Extra) == 0 && len(d.Modified) == 0
 	default:
 		return false
 	}
@@ -588,6 +699,11 @@ func ComputeSummary(result *DiffResult) *Summary {
 				summary.Sequences.Extra += len(schemaChange.Sequences.Extra)
 				summary.Sequences.Modified += len(schemaChange.Sequences.Modified)
 			}
+			if schemaChange.Scripts != nil {
+				summary.Scripts.Missing += len(schemaChange.Scripts.Missing)
+				summary.Scripts.Extra += len(schemaChange.Scripts.Extra)
+				summary.Scripts.Modified += len(schemaChange.Scripts.Modified)
+			}
 		}
 	}
 

pkg/diff/diff_test.go

@@ -1,6 +1,7 @@
 package diff
 
 import (
+	"reflect"
 	"testing"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
@@ -140,6 +141,46 @@ func TestCompareColumns(t *testing.T) {
 	}
 }
 
+// TestCompareColumns_Deterministic verifies that Missing/Extra entries are
+// always reported in the same (alphabetical) order across repeated calls,
+// instead of following Go's randomized map iteration order over the
+// source/target column maps.
+func TestCompareColumns_Deterministic(t *testing.T) {
+	source := map[string]*models.Column{
+		"zeta":  {Name: "zeta", Type: "text"},
+		"alpha": {Name: "alpha", Type: "text"},
+		"mu":    {Name: "mu", Type: "text"},
+	}
+	target := map[string]*models.Column{
+		"omega":   {Name: "omega", Type: "text"},
+		"delta":   {Name: "delta", Type: "text"},
+		"charlie": {Name: "charlie", Type: "text"},
+	}
+
+	wantMissing := []string{"alpha", "mu", "zeta"}
+	wantExtra := []string{"charlie", "delta", "omega"}
+
+	for i := 0; i < 25; i++ {
+		got := compareColumns(source, target)
+
+		gotMissing := make([]string, len(got.Missing))
+		for j, c := range got.Missing {
+			gotMissing[j] = c.Name
+		}
+		gotExtra := make([]string, len(got.Extra))
+		for j, c := range got.Extra {
+			gotExtra[j] = c.Name
+		}
+
+		if !reflect.DeepEqual(gotMissing, wantMissing) {
+			t.Fatalf("compareColumns() Missing = %v, want %v (run %d)", gotMissing, wantMissing, i)
+		}
+		if !reflect.DeepEqual(gotExtra, wantExtra) {
+			t.Fatalf("compareColumns() Extra = %v, want %v (run %d)", gotExtra, wantExtra, i)
+		}
+	}
+}
+
 func TestCompareColumnDetails(t *testing.T) {
 	tests := []struct {
 		name   string
@@ -484,6 +525,78 @@ func TestCompareSchemas(t *testing.T) {
 	}
 }
 
+func TestCompareScripts(t *testing.T) {
+	tests := []struct {
+		name   string
+		source []*models.Script
+		target []*models.Script
+		want   func(*ScriptDiff) bool
+	}{
+		{
+			name:   "identical scripts",
+			source: []*models.Script{{Name: "create_users", SQL: "CREATE TABLE users (id int);", Priority: 1, Sequence: 1}},
+			target: []*models.Script{{Name: "create_users", SQL: "CREATE TABLE users (id int);", Priority: 1, Sequence: 1}},
+			want: func(d *ScriptDiff) bool {
+				return len(d.Missing) == 0 && len(d.Extra) == 0 && len(d.Modified) == 0
+			},
+		},
+		{
+			name:   "missing script",
+			source: []*models.Script{{Name: "create_users", SQL: "CREATE TABLE users (id int);"}},
+			target: []*models.Script{},
+			want: func(d *ScriptDiff) bool {
+				return len(d.Missing) == 1 && d.Missing[0].Name == "create_users"
+			},
+		},
+		{
+			name:   "extra script",
+			source: []*models.Script{},
+			target: []*models.Script{{Name: "create_users", SQL: "CREATE TABLE users (id int);"}},
+			want: func(d *ScriptDiff) bool {
+				return len(d.Extra) == 1 && d.Extra[0].Name == "create_users"
+			},
+		},
+		{
+			name:   "modified script sql",
+			source: []*models.Script{{Name: "create_users", SQL: "CREATE TABLE users (id int);"}},
+			target: []*models.Script{{Name: "create_users", SQL: "CREATE TABLE users (id bigint);"}},
+			want: func(d *ScriptDiff) bool {
+				return len(d.Modified) == 1 && d.Modified[0].Name == "create_users" && d.Modified[0].Changes["sql"] != nil
+			},
+		},
+		{
+			name:   "different script order is different identity",
+			source: []*models.Script{{Name: "create_users", SQL: "SELECT 1;", Priority: 1, Sequence: 1}},
+			target: []*models.Script{{Name: "create_users", SQL: "SELECT 1;", Priority: 2, Sequence: 3}},
+			want: func(d *ScriptDiff) bool {
+				return len(d.Missing) == 1 && len(d.Extra) == 1 && len(d.Modified) == 0
+			},
+		},
+		{
+			name: "same descriptive names remain distinct",
+			source: []*models.Script{
+				{Name: "alter_users", SQL: "SELECT 1;", Priority: 1, Sequence: 1},
+				{Name: "alter_users", SQL: "SELECT 2;", Priority: 1, Sequence: 2},
+			},
+			target: []*models.Script{
+				{Name: "alter_users", SQL: "SELECT 1;", Priority: 1, Sequence: 1},
+			},
+			want: func(d *ScriptDiff) bool {
+				return len(d.Missing) == 1 && d.Missing[0].Sequence == 2
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := compareScripts(tt.source, tt.target)
+			if !tt.want(got) {
+				t.Errorf("compareScripts() result doesn't match expectations")
+			}
+		})
+	}
+}
+
 func TestIsEmpty(t *testing.T) {
 	tests := []struct {
 		name string
@@ -499,6 +612,8 @@ func TestIsEmpty(t *testing.T) {
 		{"TableDiff with extra", &TableDiff{Missing: []*models.Table{}, Extra: []*models.Table{{Name: "users"}}, Modified: []*TableChange{}}, false},
 		{"empty ConstraintDiff", &ConstraintDiff{Missing: []*models.Constraint{}, Extra: []*models.Constraint{}, Modified: []*ConstraintChange{}}, true},
 		{"empty RelationshipDiff", &RelationshipDiff{Missing: []*models.Relationship{}, Extra: []*models.Relationship{}, Modified: []*RelationshipChange{}}, true},
+		{"empty ScriptDiff", &ScriptDiff{Missing: []*models.Script{}, Extra: []*models.Script{}, Modified: []*ScriptChange{}}, true},
+		{"ScriptDiff with modified", &ScriptDiff{Missing: []*models.Script{}, Extra: []*models.Script{}, Modified: []*ScriptChange{{Name: "create_users"}}}, false},
 	}
 
 	for _, tt := range tests {
@@ -545,6 +660,26 @@ func TestComputeSummary(t *testing.T) {
 				return s.Schemas.Missing == 1 && s.Schemas.Extra == 2 && s.Schemas.Modified == 1
 			},
 		},
+		{
+			name: "scripts with differences",
+			result: &DiffResult{
+				Schemas: &SchemaDiff{
+					Modified: []*SchemaChange{
+						{
+							Name: "public",
+							Scripts: &ScriptDiff{
+								Missing:  []*models.Script{{Name: "missing_script"}},
+								Extra:    []*models.Script{{Name: "extra_script"}, {Name: "seed_data"}},
+								Modified: []*ScriptChange{{Name: "changed_script"}},
+							},
+						},
+					},
+				},
+			},
+			want: func(s *Summary) bool {
+				return s.Scripts.Missing == 1 && s.Scripts.Extra == 2 && s.Scripts.Modified == 1
+			},
+		},
 	}
 
 	for _, tt := range tests {

pkg/diff/formatters.go

@@ -158,6 +158,21 @@ func formatSummary(result *DiffResult, w io.Writer) error {
 		fmt.Fprintf(w, "\n")
 	}
 
+	// Scripts
+	if summary.Scripts.Missing > 0 || summary.Scripts.Extra > 0 || summary.Scripts.Modified > 0 {
+		fmt.Fprintf(w, "Scripts:\n")
+		if summary.Scripts.Missing > 0 {
+			fmt.Fprintf(w, "  Missing:  %d\n", summary.Scripts.Missing)
+		}
+		if summary.Scripts.Extra > 0 {
+			fmt.Fprintf(w, "  Extra:    %d\n", summary.Scripts.Extra)
+		}
+		if summary.Scripts.Modified > 0 {
+			fmt.Fprintf(w, "  Modified: %d\n", summary.Scripts.Modified)
+		}
+		fmt.Fprintf(w, "\n")
+	}
+
 	// Check if there are no differences
 	if summary.Schemas.Missing == 0 && summary.Schemas.Extra == 0 && summary.Schemas.Modified == 0 &&
 		summary.Tables.Missing == 0 && summary.Tables.Extra == 0 && summary.Tables.Modified == 0 &&
@@ -166,7 +181,8 @@ func formatSummary(result *DiffResult, w io.Writer) error {
 		summary.Constraints.Missing == 0 && summary.Constraints.Extra == 0 && summary.Constraints.Modified == 0 &&
 		summary.Relationships.Missing == 0 && summary.Relationships.Extra == 0 && summary.Relationships.Modified == 0 &&
 		summary.Views.Missing == 0 && summary.Views.Extra == 0 && summary.Views.Modified == 0 &&
-		summary.Sequences.Missing == 0 && summary.Sequences.Extra == 0 && summary.Sequences.Modified == 0 {
+		summary.Sequences.Missing == 0 && summary.Sequences.Extra == 0 && summary.Sequences.Modified == 0 &&
+		summary.Scripts.Missing == 0 && summary.Scripts.Extra == 0 && summary.Scripts.Modified == 0 {
 		fmt.Fprintf(w, "No differences found.\n")
 	}
 
@@ -448,6 +464,26 @@ const htmlTemplate = `<!DOCTYPE html>
                 </div>
             </div>
             {{end}}
+
+            {{if or .Summary.Scripts.Missing .Summary.Scripts.Extra .Summary.Scripts.Modified}}
+            <div class="summary-item">
+                <h3>Scripts</h3>
+                <div class="count-group">
+                    <div class="count">
+                        <span class="count-label">Missing</span>
+                        <span class="count-value missing">{{.Summary.Scripts.Missing}}</span>
+                    </div>
+                    <div class="count">
+                        <span class="count-label">Extra</span>
+                        <span class="count-value extra">{{.Summary.Scripts.Extra}}</span>
+                    </div>
+                    <div class="count">
+                        <span class="count-label">Modified</span>
+                        <span class="count-value modified">{{.Summary.Scripts.Modified}}</span>
+                    </div>
+                </div>
+            </div>
+            {{end}}
         </div>
     </div>
 
@@ -588,6 +624,35 @@ const htmlTemplate = `<!DOCTYPE html>
                 </ul>
                 {{end}}
             {{end}}
+
+            {{if .Scripts}}
+                {{if .Scripts.Missing}}
+                <h4>Missing Scripts</h4>
+                <ul class="item-list">
+                    {{range .Scripts.Missing}}
+                    <li class="missing">{{.Name}}</li>
+                    {{end}}
+                </ul>
+                {{end}}
+
+                {{if .Scripts.Extra}}
+                <h4>Extra Scripts</h4>
+                <ul class="item-list">
+                    {{range .Scripts.Extra}}
+                    <li class="extra">{{.Name}}</li>
+                    {{end}}
+                </ul>
+                {{end}}
+
+                {{if .Scripts.Modified}}
+                <h4>Modified Scripts</h4>
+                <ul class="item-list">
+                    {{range .Scripts.Modified}}
+                    <li class="modified">{{.Name}}</li>
+                    {{end}}
+                </ul>
+                {{end}}
+            {{end}}
         </div>
         {{end}}
     </div>

pkg/diff/formatters_test.go

@@ -104,6 +104,26 @@ func TestFormatSummary(t *testing.T) {
 			},
 			wantStr: []string{"Tables:", "Missing:  1", "Extra:    1", "Modified: 1"},
 		},
+		{
+			name: "with script differences",
+			result: &DiffResult{
+				Source: "source",
+				Target: "target",
+				Schemas: &SchemaDiff{
+					Modified: []*SchemaChange{
+						{
+							Name: "public",
+							Scripts: &ScriptDiff{
+								Missing:  []*models.Script{{Name: "create_users"}},
+								Extra:    []*models.Script{{Name: "seed_users"}},
+								Modified: []*ScriptChange{{Name: "add_indexes"}},
+							},
+						},
+					},
+				},
+			},
+			wantStr: []string{"Scripts:", "Missing:  1", "Extra:    1", "Modified: 1"},
+		},
 	}
 
 	for _, tt := range tests {
@@ -237,6 +257,31 @@ func TestFormatHTML(t *testing.T) {
 				"text",
 			},
 		},
+		{
+			name: "with script modifications",
+			result: &DiffResult{
+				Source: "source",
+				Target: "target",
+				Schemas: &SchemaDiff{
+					Modified: []*SchemaChange{
+						{
+							Name: "public",
+							Scripts: &ScriptDiff{
+								Missing:  []*models.Script{{Name: "create_users"}},
+								Extra:    []*models.Script{{Name: "seed_users"}},
+								Modified: []*ScriptChange{{Name: "add_indexes"}},
+							},
+						},
+					},
+				},
+			},
+			wantStr: []string{
+				"Scripts",
+				"create_users",
+				"seed_users",
+				"add_indexes",
+			},
+		},
 	}
 
 	for _, tt := range tests {

pkg/diff/types.go

@@ -22,6 +22,7 @@ type SchemaChange struct {
 	Tables    *TableDiff    `json:"tables,omitempty"`
 	Views     *ViewDiff     `json:"views,omitempty"`
 	Sequences *SequenceDiff `json:"sequences,omitempty"`
+	Scripts   *ScriptDiff   `json:"scripts,omitempty"`
 }
 
 // TableDiff represents differences in tables
@@ -131,6 +132,21 @@ type SequenceChange struct {
 	Changes map[string]any   `json:"changes"`
 }
 
+// ScriptDiff represents differences in migration scripts.
+type ScriptDiff struct {
+	Missing  []*models.Script `json:"missing"`  // Scripts in source but not in target
+	Extra    []*models.Script `json:"extra"`    // Scripts in target but not in source
+	Modified []*ScriptChange  `json:"modified"` // Scripts that exist in both but differ
+}
+
+// ScriptChange represents a modified migration script.
+type ScriptChange struct {
+	Name    string         `json:"name"`
+	Source  *models.Script `json:"source"`
+	Target  *models.Script `json:"target"`
+	Changes map[string]any `json:"changes"`
+}
+
 // Summary provides counts for quick overview
 type Summary struct {
 	Schemas       SchemaSummary       `json:"schemas"`
@@ -141,6 +157,7 @@ type Summary struct {
 	Relationships RelationshipSummary `json:"relationships"`
 	Views         ViewSummary         `json:"views"`
 	Sequences     SequenceSummary     `json:"sequences"`
+	Scripts       ScriptSummary       `json:"scripts"`
 }
 
 type SchemaSummary struct {
@@ -190,3 +207,9 @@ type SequenceSummary struct {
 	Extra    int `json:"extra"`
 	Modified int `json:"modified"`
 }
+
+type ScriptSummary struct {
+	Missing  int `json:"missing"`
+	Extra    int `json:"extra"`
+	Modified int `json:"modified"`
+}

pkg/inspector/inspector.go

@@ -2,6 +2,7 @@ package inspector
 
 import (
 	"fmt"
+	"sort"
 	"time"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
@@ -54,8 +55,15 @@ func NewInspector(db *models.Database, config *Config) *Inspector {
 func (i *Inspector) Inspect() (*InspectorReport, error) {
 	results := []ValidationResult{}
 
-	// Run all enabled validators
-	for ruleName, rule := range i.config.Rules {
+	// Run all enabled validators in deterministic (alphabetical) rule-name order
+	ruleNames := make([]string, 0, len(i.config.Rules))
+	for ruleName := range i.config.Rules {
+		ruleNames = append(ruleNames, ruleName)
+	}
+	sort.Strings(ruleNames)
+
+	for _, ruleName := range ruleNames {
+		rule := i.config.Rules[ruleName]
 		if !rule.IsEnabled() {
 			continue
 		}

pkg/inspector/inspector_test.go

@@ -51,6 +51,45 @@ func TestInspect(t *testing.T) {
 	}
 }
 
+// TestInspect_Deterministic verifies that repeated Inspect() calls against
+// the same database and config produce violations in the same order, instead
+// of following Go's randomized map iteration order over config.Rules and the
+// per-table Columns/Constraints/Indexes maps.
+func TestInspect_Deterministic(t *testing.T) {
+	db := createTestDatabase()
+	config := GetDefaultConfig()
+
+	inspector := NewInspector(db, config)
+
+	first, err := inspector.Inspect()
+	if err != nil {
+		t.Fatalf("Inspect() returned error: %v", err)
+	}
+
+	wantOrder := make([]string, len(first.Violations))
+	for i, v := range first.Violations {
+		wantOrder[i] = v.RuleName + "|" + v.Location
+	}
+
+	for i := 0; i < 25; i++ {
+		report, err := inspector.Inspect()
+		if err != nil {
+			t.Fatalf("Inspect() returned error on run %d: %v", i, err)
+		}
+
+		if len(report.Violations) != len(wantOrder) {
+			t.Fatalf("run %d: got %d violations, want %d", i, len(report.Violations), len(wantOrder))
+		}
+
+		for j, v := range report.Violations {
+			got := v.RuleName + "|" + v.Location
+			if got != wantOrder[j] {
+				t.Fatalf("run %d: violation[%d] = %q, want %q", i, j, got, wantOrder[j])
+			}
+		}
+	}
+}
+
 func TestInspectWithDisabledRules(t *testing.T) {
 	db := createTestDatabase()
 	config := GetDefaultConfig()

pkg/inspector/report.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"sort"
 	"strings"
 	"time"
 )
@@ -199,12 +200,18 @@ func (f *MarkdownFormatter) formatContext(context map[string]interface{}) string
 		"column": true,
 	}
 
-	for key, value := range context {
+	keys := make([]string, 0, len(context))
+	for key := range context {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	for _, key := range keys {
 		if skipKeys[key] {
 			continue
 		}
 
-		parts = append(parts, fmt.Sprintf("%s=%v", key, value))
+		parts = append(parts, fmt.Sprintf("%s=%v", key, context[key]))
 	}
 
 	return strings.Join(parts, ", ")

pkg/inspector/validators.go

@@ -2,12 +2,54 @@ package inspector
 
 import (
 	"regexp"
+	"sort"
 	"strings"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/pgsql"
 )
 
+// sortedKeys returns a map's keys sorted alphabetically, so validators report
+// violations in a deterministic order instead of Go's randomized map order.
+func sortedKeys[T any](m map[string]T) []string {
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+// sortColumns returns columns sorted by Sequence then Name for deterministic output.
+func sortColumns(columns map[string]*models.Column) []*models.Column {
+	result := make([]*models.Column, 0, len(columns))
+	for _, col := range columns {
+		result = append(result, col)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortConstraints returns constraints sorted by Sequence then Name for deterministic output.
+func sortConstraints(constraints map[string]*models.Constraint) []*models.Constraint {
+	result := make([]*models.Constraint, 0, len(constraints))
+	for _, c := range constraints {
+		result = append(result, c)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
 // validatePrimaryKeyNaming checks that primary key column names match a pattern
 func validatePrimaryKeyNaming(db *models.Database, rule Rule, ruleName string) []ValidationResult {
 	results := []ValidationResult{}
@@ -18,7 +60,7 @@ func validatePrimaryKeyNaming(db *models.Database, rule Rule, ruleName string) [
 
 	for _, schema := range db.Schemas {
 		for _, table := range schema.Tables {
-			for _, col := range table.Columns {
+			for _, col := range sortColumns(table.Columns) {
 				if col.IsPrimaryKey {
 					location := formatLocation(schema.Name, table.Name, col.Name)
 					passed := pattern.MatchString(col.Name)
@@ -49,7 +91,7 @@ func validatePrimaryKeyDatatype(db *models.Database, rule Rule, ruleName string)
 
 	for _, schema := range db.Schemas {
 		for _, table := range schema.Tables {
-			for _, col := range table.Columns {
+			for _, col := range sortColumns(table.Columns) {
 				if col.IsPrimaryKey {
 					location := formatLocation(schema.Name, table.Name, col.Name)
 
@@ -84,7 +126,7 @@ func validatePrimaryKeyAutoIncrement(db *models.Database, rule Rule, ruleName st
 
 	for _, schema := range db.Schemas {
 		for _, table := range schema.Tables {
-			for _, col := range table.Columns {
+			for _, col := range sortColumns(table.Columns) {
 				if col.IsPrimaryKey {
 					location := formatLocation(schema.Name, table.Name, col.Name)
 
@@ -125,7 +167,7 @@ func validateForeignKeyColumnNaming(db *models.Database, rule Rule, ruleName str
 	for _, schema := range db.Schemas {
 		for _, table := range schema.Tables {
 			// Check foreign key constraints
-			for _, constraint := range table.Constraints {
+			for _, constraint := range sortConstraints(table.Constraints) {
 				if constraint.Type == models.ForeignKeyConstraint {
 					for _, colName := range constraint.Columns {
 						location := formatLocation(schema.Name, table.Name, colName)
@@ -163,7 +205,7 @@ func validateForeignKeyConstraintNaming(db *models.Database, rule Rule, ruleName
 
 	for _, schema := range db.Schemas {
 		for _, table := range schema.Tables {
-			for _, constraint := range table.Constraints {
+			for _, constraint := range sortConstraints(table.Constraints) {
 				if constraint.Type == models.ForeignKeyConstraint {
 					location := formatLocation(schema.Name, table.Name, "")
 					passed := pattern.MatchString(constraint.Name)
@@ -209,7 +251,7 @@ func validateForeignKeyIndex(db *models.Database, rule Rule, ruleName string) []
 			}
 
 			// Check if each FK column has an index
-			for fkCol := range fkColumns {
+			for _, fkCol := range sortedKeys(fkColumns) {
 				hasIndex := false
 
 				// Check table indexes
@@ -282,7 +324,7 @@ func validateColumnNamingCase(db *models.Database, rule Rule, ruleName string) [
 
 	for _, schema := range db.Schemas {
 		for _, table := range schema.Tables {
-			for _, col := range table.Columns {
+			for _, col := range sortColumns(table.Columns) {
 				location := formatLocation(schema.Name, table.Name, col.Name)
 				passed := pattern.MatchString(col.Name)
 
@@ -339,7 +381,7 @@ func validateColumnNameLength(db *models.Database, rule Rule, ruleName string) [
 
 	for _, schema := range db.Schemas {
 		for _, table := range schema.Tables {
-			for _, col := range table.Columns {
+			for _, col := range sortColumns(table.Columns) {
 				location := formatLocation(schema.Name, table.Name, col.Name)
 				passed := len(col.Name) <= rule.MaxLength
 
@@ -396,7 +438,7 @@ func validateReservedKeywords(db *models.Database, rule Rule, ruleName string) [
 
 			// Check column names
 			if rule.CheckColumns {
-				for _, col := range table.Columns {
+				for _, col := range sortColumns(table.Columns) {
 					location := formatLocation(schema.Name, table.Name, col.Name)
 					passed := !keywords[strings.ToUpper(col.Name)]
 
@@ -479,7 +521,7 @@ func validateOrphanedForeignKey(db *models.Database, rule Rule, ruleName string)
 	// Check all foreign key constraints
 	for _, schema := range db.Schemas {
 		for _, table := range schema.Tables {
-			for _, constraint := range table.Constraints {
+			for _, constraint := range sortConstraints(table.Constraints) {
 				if constraint.Type == models.ForeignKeyConstraint {
 					// Build referenced table key
 					refSchema := constraint.ReferencedSchema
@@ -522,7 +564,7 @@ func validateCircularDependency(db *models.Database, rule Rule, ruleName string)
 		for _, table := range schema.Tables {
 			tableKey := schema.Name + "." + table.Name
 
-			for _, constraint := range table.Constraints {
+			for _, constraint := range sortConstraints(table.Constraints) {
 				if constraint.Type == models.ForeignKeyConstraint {
 					refSchema := constraint.ReferencedSchema
 					if refSchema == "" {
@@ -537,7 +579,7 @@ func validateCircularDependency(db *models.Database, rule Rule, ruleName string)
 	}
 
 	// Check for cycles using DFS
-	for tableKey := range dependencies {
+	for _, tableKey := range sortedKeys(dependencies) {
 		visited := make(map[string]bool)
 		recStack := make(map[string]bool)
 

pkg/merge/merge.go

@@ -5,6 +5,7 @@ package merge
 
 import (
 	"fmt"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -156,8 +157,17 @@ func (r *MergeResult) mergeColumns(table *models.Table, srcTable *models.Table)
 		existingColumns[colName] = table.Columns[colName]
 	}
 
-	// Merge columns
-	for colName, srcCol := range srcTable.Columns {
+	// Merge columns in deterministic (alphabetical) order so that, when a
+	// TypeConflicts entry is recorded, its position in the report doesn't
+	// depend on Go's randomized map iteration order.
+	srcColNames := make([]string, 0, len(srcTable.Columns))
+	for colName := range srcTable.Columns {
+		srcColNames = append(srcColNames, colName)
+	}
+	sort.Strings(srcColNames)
+
+	for _, colName := range srcColNames {
+		srcCol := srcTable.Columns[colName]
 		if tgtCol, exists := existingColumns[colName]; !exists {
 			// Column doesn't exist, add it
 			newCol := cloneColumn(srcCol)
@@ -482,7 +492,12 @@ func extractTypeParts(col *models.Column) (baseType string, length, precision, s
 		}
 	}
 
-	typeName = pgsql.NormalizePGType(typeName)
+	// serial/bigserial/smallserial are sugar over an integer column plus a
+	// sequence default; PostgreSQL itself reports the underlying integer
+	// type back for such columns, so treat them as equivalent here to avoid
+	// spurious conflicts between a DBML "bigserial" source and a live-read
+	// "bigint" target (or vice versa).
+	typeName = pgsql.SerialUnderlyingType(typeName)
 
 	return typeName, length, precision, scale
 }

pkg/merge/merge_test.go

@@ -196,6 +196,50 @@ func TestMergeColumns_TypeConflictIsDetected(t *testing.T) {
 	}
 }
 
+func TestMergeColumns_SerialVsUnderlyingIntegerIsNotAConflict(t *testing.T) {
+	target := &models.Database{
+		Schemas: []*models.Schema{
+			{
+				Name: "public",
+				Tables: []*models.Table{
+					{
+						Name:   "users",
+						Schema: "public",
+						Columns: map[string]*models.Column{
+							// As reported back by a live PostgreSQL read of an
+							// existing serial primary key column.
+							"id": {Name: "id", Type: "bigint"},
+						},
+					},
+				},
+			},
+		},
+	}
+	source := &models.Database{
+		Schemas: []*models.Schema{
+			{
+				Name: "public",
+				Tables: []*models.Table{
+					{
+						Name:   "users",
+						Schema: "public",
+						Columns: map[string]*models.Column{
+							// As declared in a DBML source spec.
+							"id": {Name: "id", Type: "bigserial"},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	result := MergeDatabases(target, source, nil)
+
+	if len(result.TypeConflicts) != 0 {
+		t.Fatalf("Expected no type conflicts for bigserial vs bigint, got %d: %+v", len(result.TypeConflicts), result.TypeConflicts)
+	}
+}
+
 func TestMergeConstraints_NewConstraint(t *testing.T) {
 	target := &models.Database{
 		Schemas: []*models.Schema{

pkg/models/flatview.go

@@ -1,6 +1,9 @@
 package models
 
-import "fmt"
+import (
+	"fmt"
+	"sort"
+)
 
 // Flat/Denormalized Views
 //
@@ -56,6 +59,10 @@ func (d *Database) ToFlatColumns() []*FlatColumn {
 		}
 	}
 
+	sort.Slice(flatColumns, func(i, j int) bool {
+		return flatColumns[i].FullyQualifiedName < flatColumns[j].FullyQualifiedName
+	})
+
 	return flatColumns
 }
 
@@ -148,6 +155,10 @@ func (d *Database) ToFlatConstraints() []*FlatConstraint {
 		}
 	}
 
+	sort.Slice(flatConstraints, func(i, j int) bool {
+		return flatConstraints[i].FullyQualifiedName < flatConstraints[j].FullyQualifiedName
+	})
+
 	return flatConstraints
 }
 
@@ -198,5 +209,16 @@ func (d *Database) ToFlatRelationships() []*FlatRelationship {
 		}
 	}
 
+	sort.Slice(flatRelationships, func(i, j int) bool {
+		a, b := flatRelationships[i], flatRelationships[j]
+		if a.FromFQN != b.FromFQN {
+			return a.FromFQN < b.FromFQN
+		}
+		if a.RelationshipName != b.RelationshipName {
+			return a.RelationshipName < b.RelationshipName
+		}
+		return a.ToFQN < b.ToFQN
+	})
+
 	return flatRelationships
 }

pkg/models/models.go

@@ -5,6 +5,7 @@
 package models
 
 import (
+	"sort"
 	"strings"
 	"time"
 
@@ -141,15 +142,28 @@ func (d *Table) SQLName() string {
 
 // GetPrimaryKey returns the primary key column for the table, or nil if none exists.
 func (m Table) GetPrimaryKey() *Column {
+	var pk *Column
 	for _, column := range m.Columns {
-		if column.IsPrimaryKey {
-			return column
+		if !column.IsPrimaryKey {
+			continue
+		}
+		if pk == nil || columnLess(column, pk) {
+			pk = column
 		}
 	}
-	return nil
+	return pk
 }
 
-// GetForeignKeys returns all foreign key constraints for the table.
+// columnLess reports whether a should sort before b, by Sequence then Name.
+func columnLess(a, b *Column) bool {
+	if a.Sequence > 0 && b.Sequence > 0 {
+		return a.Sequence < b.Sequence
+	}
+	return a.Name < b.Name
+}
+
+// GetForeignKeys returns all foreign key constraints for the table, sorted
+// deterministically by Sequence then Name.
 func (m Table) GetForeignKeys() []*Constraint {
 	keys := make([]*Constraint, 0)
 
@@ -158,6 +172,12 @@ func (m Table) GetForeignKeys() []*Constraint {
 			keys = append(keys, c)
 		}
 	}
+	sort.Slice(keys, func(i, j int) bool {
+		if keys[i].Sequence > 0 && keys[j].Sequence > 0 {
+			return keys[i].Sequence < keys[j].Sequence
+		}
+		return keys[i].Name < keys[j].Name
+	})
 	return keys
 }
 
@@ -350,16 +370,17 @@ const (
 // Script represents a database migration or initialization script.
 // Scripts can have dependencies and rollback capabilities.
 type Script struct {
-	Name        string   `json:"name" yaml:"name" xml:"name"`
-	Description string   `json:"description" yaml:"description" xml:"description"`
-	SQL         string   `json:"sql" yaml:"sql" xml:"sql"`
-	Rollback    string   `json:"rollback,omitempty" yaml:"rollback,omitempty" xml:"rollback,omitempty"`
-	RunAfter    []string `json:"run_after,omitempty" yaml:"run_after,omitempty" xml:"run_after,omitempty"`
-	Schema      string   `json:"schema,omitempty" yaml:"schema,omitempty" xml:"schema,omitempty"`
-	Version     string   `json:"version,omitempty" yaml:"version,omitempty" xml:"version,omitempty"`
-	Priority    int      `json:"priority,omitempty" yaml:"priority,omitempty" xml:"priority,omitempty"`
-	Sequence    uint     `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
-	GUID        string   `json:"guid" yaml:"guid" xml:"guid"`
+	Name        string         `json:"name" yaml:"name" xml:"name"`
+	Description string         `json:"description" yaml:"description" xml:"description"`
+	SQL         string         `json:"sql" yaml:"sql" xml:"sql"`
+	Rollback    string         `json:"rollback,omitempty" yaml:"rollback,omitempty" xml:"rollback,omitempty"`
+	RunAfter    []string       `json:"run_after,omitempty" yaml:"run_after,omitempty" xml:"run_after,omitempty"`
+	Schema      string         `json:"schema,omitempty" yaml:"schema,omitempty" xml:"schema,omitempty"`
+	Version     string         `json:"version,omitempty" yaml:"version,omitempty" xml:"version,omitempty"`
+	Priority    int            `json:"priority,omitempty" yaml:"priority,omitempty" xml:"priority,omitempty"`
+	Sequence    uint           `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
+	GUID        string         `json:"guid" yaml:"guid" xml:"guid"`
+	Metadata    map[string]any `json:"metadata,omitempty" yaml:"metadata,omitempty" xml:"-"`
 }
 
 // SQLName returns the script name in lowercase for SQL compatibility.
@@ -468,6 +489,7 @@ func InitScript(name string) *Script {
 	return &Script{
 		Name:     name,
 		RunAfter: make([]string, 0),
+		Metadata: make(map[string]any),
 		GUID:     uuid.New().String(),
 	}
 }

pkg/pgsql/datatypes.go

@@ -193,6 +193,28 @@ func IsKnownPGBaseType(baseType string) bool {
 	return ok
 }
 
+// serialUnderlyingType maps each serial pseudo-type to the integer type
+// PostgreSQL actually stores the column as. serial/bigserial/smallserial are
+// not real types: they are sugar for an integer column plus a sequence
+// default, and pg_catalog (and information_schema) always reports the
+// underlying integer type back for such columns.
+var serialUnderlyingType = map[string]string{
+	"serial":      "integer",
+	"bigserial":   "bigint",
+	"smallserial": "smallint",
+}
+
+// SerialUnderlyingType returns the underlying integer type for a serial
+// pseudo-type (e.g. "bigserial" -> "bigint"). If baseType (after
+// NormalizePGType) is not a serial type, it is returned unchanged.
+func SerialUnderlyingType(baseType string) string {
+	normalized := NormalizePGType(baseType)
+	if underlying, ok := serialUnderlyingType[normalized]; ok {
+		return underlying
+	}
+	return normalized
+}
+
 func IsGoType(pTypeName string) bool {
 	for k := range GoToStdTypes {
 		if strings.EqualFold(pTypeName, k) {

pkg/readers/dbml/reader.go

@@ -434,6 +434,7 @@ func (r *Reader) parseDBML(content string) (*models.Database, error) {
 	var currentSchema string
 	var inIndexes bool
 	var inTable bool
+	var columnSeq uint
 
 	tableRegex := regexp.MustCompile(`^Table\s+(.+?)\s*{`)
 	refRegex := regexp.MustCompile(`^Ref:\s+(.+)`)
@@ -469,6 +470,7 @@ func (r *Reader) parseDBML(content string) (*models.Database, error) {
 			currentTable = models.InitTable(tableName, currentSchema)
 			inTable = true
 			inIndexes = false
+			columnSeq = 0
 			continue
 		}
 
@@ -497,6 +499,17 @@ func (r *Reader) parseDBML(content string) (*models.Database, error) {
 
 		// Parse index definition
 		if inIndexes && currentTable != nil {
+			// A composite `[pk]` entry inside an Indexes block declares the
+			// table's primary key (DBML's way of expressing multi-column PKs
+			// that can't be attached to a single column). It must become a
+			// primary key constraint, not a plain index, or the PK is lost.
+			if indexLineHasPKAttr(line) {
+				if constraint := r.parsePrimaryKeyIndex(line, currentTable.Name, currentSchema); constraint != nil {
+					currentTable.Constraints[constraint.Name] = constraint
+				}
+				continue
+			}
+
 			index := r.parseIndex(line, currentTable.Name, currentSchema)
 			if index != nil {
 				currentTable.Indexes[index.Name] = index
@@ -516,6 +529,8 @@ func (r *Reader) parseDBML(content string) (*models.Database, error) {
 		if inTable && !inIndexes && currentTable != nil {
 			column, constraint := r.parseColumn(line, currentTable.Name, currentSchema)
 			if column != nil {
+				columnSeq++
+				column.Sequence = columnSeq
 				currentTable.Columns[column.Name] = column
 			}
 			if constraint != nil {
@@ -743,9 +758,10 @@ func stripWrappingQuotes(s string) string {
 	return s
 }
 
-// parseIndex parses a DBML index definition
-func (r *Reader) parseIndex(line, tableName, schemaName string) *models.Index {
-	// Format: (columns) [attributes] OR columnname [attributes]
+// indexLineColumns extracts the column list from an Indexes-block entry,
+// e.g. "(col1, col2) [attrs]" or "columnname [attrs]", preserving
+// declaration order.
+func indexLineColumns(line string) []string {
 	var columns []string
 
 	// Find the attributes section to avoid parsing parentheses in notes/attributes
@@ -776,6 +792,56 @@ func (r *Reader) parseIndex(line, tableName, schemaName string) *models.Index {
 		}
 	}
 
+	return columns
+}
+
+// indexLineAttrs extracts and splits the bracketed attribute list of an
+// Indexes-block entry, e.g. "[pk]" or "[unique, name: 'foo']".
+func indexLineAttrs(line string) []string {
+	attrStart := strings.Index(line, "[")
+	attrEnd := strings.Index(line, "]")
+	if attrStart < 0 || attrEnd < 0 || attrStart >= attrEnd {
+		return nil
+	}
+
+	var attrs []string
+	for _, attr := range strings.Split(line[attrStart+1:attrEnd], ",") {
+		attrs = append(attrs, strings.TrimSpace(attr))
+	}
+	return attrs
+}
+
+// indexLineHasPKAttr reports whether an Indexes-block entry carries a `pk`
+// attribute, e.g. "(artifact_id, sha256) [pk]". DBML uses this form to
+// declare composite primary keys that can't be attached to a single column.
+func indexLineHasPKAttr(line string) bool {
+	for _, attr := range indexLineAttrs(line) {
+		if attr == "pk" || attr == "primary key" {
+			return true
+		}
+	}
+	return false
+}
+
+// parsePrimaryKeyIndex converts a composite `[pk]` entry from an Indexes
+// block into a primary key constraint, preserving the declared column order.
+func (r *Reader) parsePrimaryKeyIndex(line, tableName, schemaName string) *models.Constraint {
+	columns := indexLineColumns(line)
+	if len(columns) == 0 {
+		return nil
+	}
+
+	constraint := models.InitConstraint("pk_"+tableName, models.PrimaryKeyConstraint)
+	constraint.Schema = schemaName
+	constraint.Table = tableName
+	constraint.Columns = columns
+	return constraint
+}
+
+// parseIndex parses a DBML index definition
+func (r *Reader) parseIndex(line, tableName, schemaName string) *models.Index {
+	// Format: (columns) [attributes] OR columnname [attributes]
+	columns := indexLineColumns(line)
 	if len(columns) == 0 {
 		return nil
 	}
@@ -786,26 +852,15 @@ func (r *Reader) parseIndex(line, tableName, schemaName string) *models.Index {
 	index.Columns = columns
 
 	// Parse attributes
-	if strings.Contains(line, "[") && strings.Contains(line, "]") {
-		attrStart := strings.Index(line, "[")
-		attrEnd := strings.Index(line, "]")
-		if attrStart < attrEnd {
-			attrs := line[attrStart+1 : attrEnd]
-			attrList := strings.Split(attrs, ",")
-
-			for _, attr := range attrList {
-				attr = strings.TrimSpace(attr)
-
-				if attr == "unique" {
-					index.Unique = true
-				} else if strings.HasPrefix(attr, "name:") {
-					name := strings.TrimSpace(strings.TrimPrefix(attr, "name:"))
-					index.Name = strings.Trim(name, "'\"")
-				} else if strings.HasPrefix(attr, "type:") {
-					indexType := strings.TrimSpace(strings.TrimPrefix(attr, "type:"))
-					index.Type = strings.Trim(indexType, "'\"")
-				}
-			}
+	for _, attr := range indexLineAttrs(line) {
+		if attr == "unique" {
+			index.Unique = true
+		} else if strings.HasPrefix(attr, "name:") {
+			name := strings.TrimSpace(strings.TrimPrefix(attr, "name:"))
+			index.Name = strings.Trim(name, "'\"")
+		} else if strings.HasPrefix(attr, "type:") {
+			indexType := strings.TrimSpace(strings.TrimPrefix(attr, "type:"))
+			index.Type = strings.Trim(indexType, "'\"")
 		}
 	}
 

pkg/readers/dbml/reader_test.go

@@ -932,3 +932,97 @@ func TestHasCommentedRefs(t *testing.T) {
 		})
 	}
 }
+
+// TestReader_CompositePKIndex verifies that a composite `[pk]` entry inside
+// an Indexes block is turned into a primary key constraint, in declaration
+// order, rather than being silently dropped.
+func TestReader_CompositePKIndex(t *testing.T) {
+	dbmlContent := `Table artifact_blob {
+  artifact_id integer [not null]
+  sha256 text [not null]
+  size integer
+
+  Indexes {
+    (artifact_id, sha256) [pk]
+  }
+}
+`
+	dir := t.TempDir()
+	path := filepath.Join(dir, "composite_pk.dbml")
+	if err := os.WriteFile(path, []byte(dbmlContent), 0644); err != nil {
+		t.Fatalf("failed to write fixture: %v", err)
+	}
+
+	reader := NewReader(&readers.ReaderOptions{FilePath: path})
+	db, err := reader.ReadDatabase()
+	if err != nil {
+		t.Fatalf("ReadDatabase() error = %v", err)
+	}
+
+	table := db.Schemas[0].Tables[0]
+
+	var pk *models.Constraint
+	for _, c := range table.Constraints {
+		if c.Type == models.PrimaryKeyConstraint {
+			pk = c
+			break
+		}
+	}
+	if pk == nil {
+		t.Fatal("expected a primary key constraint, got none")
+	}
+	want := []string{"artifact_id", "sha256"}
+	if len(pk.Columns) != len(want) {
+		t.Fatalf("expected PK columns %v, got %v", want, pk.Columns)
+	}
+	for i, col := range want {
+		if pk.Columns[i] != col {
+			t.Errorf("PK column[%d] = %q, want %q (order must match declaration)", i, pk.Columns[i], col)
+		}
+	}
+
+	// No plain index should be emitted for the pk-only entry.
+	if len(table.Indexes) != 0 {
+		t.Errorf("expected no plain indexes from a [pk] Indexes entry, got %v", table.Indexes)
+	}
+}
+
+// TestReader_ColumnPKOrderPreserved verifies that composite primary keys
+// declared via column-level [pk] attributes keep declaration order (via
+// Column.Sequence) instead of falling back to alphabetical sorting.
+func TestReader_ColumnPKOrderPreserved(t *testing.T) {
+	dbmlContent := `Table snapshot_artifact {
+  snapshot_id integer [pk, not null]
+  artifact_id integer [pk, not null]
+}
+`
+	dir := t.TempDir()
+	path := filepath.Join(dir, "column_pk_order.dbml")
+	if err := os.WriteFile(path, []byte(dbmlContent), 0644); err != nil {
+		t.Fatalf("failed to write fixture: %v", err)
+	}
+
+	reader := NewReader(&readers.ReaderOptions{FilePath: path})
+	db, err := reader.ReadDatabase()
+	if err != nil {
+		t.Fatalf("ReadDatabase() error = %v", err)
+	}
+
+	table := db.Schemas[0].Tables[0]
+
+	snapshotCol, ok := table.Columns["snapshot_id"]
+	if !ok {
+		t.Fatal("column 'snapshot_id' not found")
+	}
+	artifactCol, ok := table.Columns["artifact_id"]
+	if !ok {
+		t.Fatal("column 'artifact_id' not found")
+	}
+
+	if snapshotCol.Sequence == 0 || artifactCol.Sequence == 0 {
+		t.Fatalf("expected non-zero Sequence values, got snapshot_id=%d artifact_id=%d", snapshotCol.Sequence, artifactCol.Sequence)
+	}
+	if snapshotCol.Sequence >= artifactCol.Sequence {
+		t.Errorf("expected snapshot_id (declared first) to have a lower Sequence than artifact_id, got %d >= %d", snapshotCol.Sequence, artifactCol.Sequence)
+	}
+}

pkg/readers/dctx/reader.go

@@ -4,6 +4,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"os"
+	"sort"
 	"strings"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
@@ -373,7 +374,13 @@ func (r *Reader) convertKey(dctxKey *models.DCTXKey, table *models.Table, fieldG
 	if len(columns) == 0 {
 		if dctxKey.Primary {
 			// Look for common primary key column patterns
+			colNames := make([]string, 0, len(table.Columns))
 			for colName := range table.Columns {
+				colNames = append(colNames, colName)
+			}
+			sort.Strings(colNames)
+
+			for _, colName := range colNames {
 				colNameLower := strings.ToLower(colName)
 				if strings.HasPrefix(colNameLower, "rid_") || strings.HasSuffix(colNameLower, "id") {
 					columns = append(columns, colName)

pkg/readers/prisma/reader.go

@@ -820,17 +820,31 @@ func (r *Reader) createImplicitJoinTable(model1, model2 string, tableMap map[str
 	tableMap[joinTableName] = joinTable
 }
 
-// getPrimaryKeyColumn returns the primary key column of a table
+// getPrimaryKeyColumn returns the primary key column of a table. For tables
+// with a composite primary key, the column with the lowest Sequence (or,
+// failing that, the alphabetically first Name) is returned deterministically.
 func (r *Reader) getPrimaryKeyColumn(table *models.Table) *models.Column {
 	if table == nil {
 		return nil
 	}
 
+	var pk *models.Column
 	for _, col := range table.Columns {
-		if col.IsPrimaryKey {
-			return col
+		if !col.IsPrimaryKey {
+			continue
+		}
+		if pk == nil {
+			pk = col
+			continue
+		}
+		if col.Sequence > 0 && pk.Sequence > 0 {
+			if col.Sequence < pk.Sequence {
+				pk = col
+			}
+		} else if col.Name < pk.Name {
+			pk = col
 		}
 	}
 
-	return nil
+	return pk
 }

pkg/readers/sqldir/README.md

@@ -45,6 +45,21 @@ migrations/
 - `1_001_test.txt` - Wrong extension
 - `readme.md` - Not a SQL file
 
+## External File Embedding
+
+SQL files can include external files with `-- @embed` directives. File paths are resolved relative to the SQL file being read.
+
+```sql
+-- @embed: path=assets/message.txt var=:message mode=text
+-- @embed: path=assets/payload.bin var=:payload mode=base64
+INSERT INTO assets (message, payload)
+VALUES (:message, decode(:payload, 'base64')::bytea);
+```
+
+- `mode=text` reads UTF-8 text and replaces the placeholder with an escaped SQL string literal.
+- `mode=base64` reads any bytes and replaces the placeholder with a base64 SQL string literal.
+- The placeholder must be named, for example `:message`, and must appear in the SQL body.
+
 ## Usage
 
 ### Basic Usage

pkg/readers/sqldir/reader.go

@@ -7,6 +7,7 @@ import (
 	"regexp"
 	"strconv"
 
+	"git.warky.dev/wdevs/relspecgo/pkg/assetloader"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/readers"
 )
@@ -151,6 +152,10 @@ func (r *Reader) readScripts() ([]*models.Script, error) {
 		if err != nil {
 			return fmt.Errorf("failed to read file %s: %w", path, err)
 		}
+		sql, err := assetloader.ProcessEmbedDirectives(path, string(content))
+		if err != nil {
+			return err
+		}
 
 		// Get relative path from base directory
 		relPath, err := filepath.Rel(r.options.FilePath, path)
@@ -161,9 +166,10 @@ func (r *Reader) readScripts() ([]*models.Script, error) {
 		// Create Script model
 		script := models.InitScript(name)
 		script.Description = fmt.Sprintf("SQL script from %s", relPath)
-		script.SQL = string(content)
+		script.SQL = sql
 		script.Priority = priority
 		script.Sequence = uint(sequence)
+		script.Metadata[assetloader.ScriptSourcePathMetadataKey] = path
 
 		scripts = append(scripts, script)
 

pkg/readers/sqldir/reader_test.go

@@ -1,8 +1,10 @@
 package sqldir
 
 import (
+	"encoding/base64"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/readers"
@@ -18,12 +20,12 @@ func TestReader_ReadDatabase(t *testing.T) {
 
 	// Create test SQL files with both underscore and hyphen separators
 	testFiles := map[string]string{
-		"1_001_create_users.sql":  "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT);",
-		"1_002_create_posts.sql":  "CREATE TABLE posts (id SERIAL PRIMARY KEY, user_id INT);",
-		"2_001_add_indexes.sql":   "CREATE INDEX idx_posts_user_id ON posts(user_id);",
-		"1_003_seed_data.pgsql":   "INSERT INTO users (name) VALUES ('Alice'), ('Bob');",
+		"1_001_create_users.sql":   "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT);",
+		"1_002_create_posts.sql":   "CREATE TABLE posts (id SERIAL PRIMARY KEY, user_id INT);",
+		"2_001_add_indexes.sql":    "CREATE INDEX idx_posts_user_id ON posts(user_id);",
+		"1_003_seed_data.pgsql":    "INSERT INTO users (name) VALUES ('Alice'), ('Bob');",
 		"10-10-create-newid.pgsql": "CREATE TABLE newid (id SERIAL PRIMARY KEY);",
-		"2-005-add-column.sql":    "ALTER TABLE users ADD COLUMN email TEXT;",
+		"2-005-add-column.sql":     "ALTER TABLE users ADD COLUMN email TEXT;",
 	}
 
 	for filename, content := range testFiles {
@@ -267,10 +269,10 @@ func TestReader_HyphenFormat(t *testing.T) {
 
 	// Create test files with hyphen separators
 	testFiles := map[string]string{
-		"1-001-create-table.sql":  "CREATE TABLE test (id INT);",
-		"1-002-insert-data.pgsql": "INSERT INTO test VALUES (1);",
+		"1-001-create-table.sql":   "CREATE TABLE test (id INT);",
+		"1-002-insert-data.pgsql":  "INSERT INTO test VALUES (1);",
 		"10-10-create-newid.pgsql": "CREATE TABLE newid (id SERIAL);",
-		"2-005-add-index.sql":     "CREATE INDEX idx_test ON test(id);",
+		"2-005-add-index.sql":      "CREATE INDEX idx_test ON test(id);",
 	}
 
 	for filename, content := range testFiles {
@@ -301,10 +303,10 @@ func TestReader_HyphenFormat(t *testing.T) {
 		priority int
 		sequence uint
 	}{
-		"create-table":  {1, 1},
-		"insert-data":   {1, 2},
-		"add-index":     {2, 5},
-		"create-newid":  {10, 10},
+		"create-table": {1, 1},
+		"insert-data":  {1, 2},
+		"add-index":    {2, 5},
+		"create-newid": {10, 10},
 	}
 
 	for _, script := range schema.Scripts {
@@ -435,3 +437,61 @@ func TestReader_SkipSymlinks(t *testing.T) {
 		t.Error("Symlink script should have been skipped but was found")
 	}
 }
+
+func TestReader_EmbedDirectives(t *testing.T) {
+	tempDir := t.TempDir()
+	assetDir := filepath.Join(tempDir, "assets")
+	if err := os.MkdirAll(assetDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(assetDir, "message.txt"), []byte("Reader's text"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	binary := []byte{0x00, 0x01, 0xfe, 0xff}
+	if err := os.WriteFile(filepath.Join(assetDir, "payload.bin"), binary, 0o644); err != nil {
+		t.Fatal(err)
+	}
+	sql := `
+-- @embed: path=assets/message.txt var=:message mode=text
+-- @embed: path=assets/payload.bin var=:payload mode=base64
+INSERT INTO assets (message, payload) VALUES (:message, decode(:payload, 'base64')::bytea);
+`
+	if err := os.WriteFile(filepath.Join(tempDir, "1_001_embed.sql"), []byte(sql), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	reader := NewReader(&readers.ReaderOptions{FilePath: tempDir})
+	db, err := reader.ReadDatabase()
+	if err != nil {
+		t.Fatalf("ReadDatabase failed: %v", err)
+	}
+	if len(db.Schemas[0].Scripts) != 1 {
+		t.Fatalf("expected 1 script, got %d", len(db.Schemas[0].Scripts))
+	}
+
+	got := db.Schemas[0].Scripts[0].SQL
+	if !strings.Contains(got, "'Reader''s text'") {
+		t.Fatalf("text asset was not embedded as an escaped SQL literal:\n%s", got)
+	}
+	wantBase64 := "decode('" + base64.StdEncoding.EncodeToString(binary) + "', 'base64')::bytea"
+	if !strings.Contains(got, wantBase64) {
+		t.Fatalf("binary asset was not embedded as a base64 SQL literal:\n%s", got)
+	}
+}
+
+func TestReader_EmbedDirectiveErrors(t *testing.T) {
+	tempDir := t.TempDir()
+	sql := "-- @embed: path=missing.txt var=:message mode=text\nSELECT :message;"
+	if err := os.WriteFile(filepath.Join(tempDir, "1_001_embed.sql"), []byte(sql), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	reader := NewReader(&readers.ReaderOptions{FilePath: tempDir})
+	_, err := reader.ReadDatabase()
+	if err == nil {
+		t.Fatal("expected embed error, got nil")
+	}
+	if !strings.Contains(err.Error(), "missing.txt") {
+		t.Fatalf("expected missing file in error, got %v", err)
+	}
+}

pkg/readers/typeorm/reader.go

@@ -806,17 +806,31 @@ func (r *Reader) createManyToManyJoinTable(entity1, entity2 string, tableMap map
 	tableMap[joinTableName] = joinTable
 }
 
-// getPrimaryKeyColumn returns the primary key column of a table
+// getPrimaryKeyColumn returns the primary key column of a table. For tables
+// with a composite primary key, the column with the lowest Sequence (or,
+// failing that, the alphabetically first Name) is returned deterministically.
 func (r *Reader) getPrimaryKeyColumn(table *models.Table) *models.Column {
 	if table == nil {
 		return nil
 	}
 
+	var pk *models.Column
 	for _, col := range table.Columns {
-		if col.IsPrimaryKey {
-			return col
+		if !col.IsPrimaryKey {
+			continue
+		}
+		if pk == nil {
+			pk = col
+			continue
+		}
+		if col.Sequence > 0 && pk.Sequence > 0 {
+			if col.Sequence < pk.Sequence {
+				pk = col
+			}
+		} else if col.Name < pk.Name {
+			pk = col
 		}
 	}
 
-	return nil
+	return pk
 }

pkg/reflectutil/helpers.go

@@ -1,7 +1,9 @@
 package reflectutil
 
 import (
+	"fmt"
 	"reflect"
+	"sort"
 	"strings"
 )
 
@@ -134,7 +136,7 @@ func MapKeys(i interface{}) []interface{} {
 		return []interface{}{}
 	}
 
-	keys := v.MapKeys()
+	keys := sortedMapKeys(v)
 	result := make([]interface{}, len(keys))
 	for i, key := range keys {
 		result[i] = key.Interface()
@@ -155,14 +157,39 @@ func MapValues(i interface{}) []interface{} {
 		return []interface{}{}
 	}
 
-	result := make([]interface{}, 0, v.Len())
-	iter := v.MapRange()
-	for iter.Next() {
-		result = append(result, iter.Value().Interface())
+	keys := sortedMapKeys(v)
+	result := make([]interface{}, 0, len(keys))
+	for _, key := range keys {
+		result = append(result, v.MapIndex(key).Interface())
 	}
 	return result
 }
 
+func sortedMapKeys(v reflect.Value) []reflect.Value {
+	keys := v.MapKeys()
+	sort.SliceStable(keys, func(i, j int) bool {
+		return mapKeyLess(keys[i], keys[j])
+	})
+	return keys
+}
+
+func mapKeyLess(a, b reflect.Value) bool {
+	switch a.Kind() {
+	case reflect.String:
+		return a.String() < b.String()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return a.Int() < b.Int()
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return a.Uint() < b.Uint()
+	case reflect.Float32, reflect.Float64:
+		return a.Float() < b.Float()
+	case reflect.Bool:
+		return !a.Bool() && b.Bool()
+	default:
+		return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface())
+	}
+}
+
 // MapGet safely gets a value from a map by key
 // Returns nil if key doesn't exist or not a map
 func MapGet(m interface{}, key interface{}) interface{} {

pkg/ui/editor.go

@@ -2,6 +2,7 @@ package ui
 
 import (
 	"fmt"
+	"sort"
 
 	"github.com/rivo/tview"
 
@@ -69,5 +70,6 @@ func getColumnNames(table *models.Table) []string {
 	for name := range table.Columns {
 		names = append(names, name)
 	}
+	sort.Strings(names)
 	return names
 }

pkg/ui/relation_dataops.go

@@ -1,6 +1,10 @@
 package ui
 
-import "git.warky.dev/wdevs/relspecgo/pkg/models"
+import (
+	"sort"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
 
 // Relationship data operations - business logic for relationship management
 
@@ -111,5 +115,6 @@ func (se *SchemaEditor) GetRelationshipNames(schemaIndex, tableIndex int) []stri
 	for name := range table.Relationships {
 		names = append(names, name)
 	}
+	sort.Strings(names)
 	return names
 }

pkg/writers/bun/README.md

@@ -88,11 +88,11 @@ import (
 type User struct {
     bun.BaseModel `bun:"table:users,alias:u"`
 
-    ID        int64                     `bun:"id,type:uuid,pk," json:"id"`
-    Username  string                    `bun:"username,type:text,notnull," json:"username"`
-    Email     sql_types.SqlString       `bun:"email,type:text,nullzero," json:"email"`
-    Tags      sql_types.SqlStringArray  `bun:"tags,type:text[],default:'{}',notnull," json:"tags"`
-    CreatedAt sql_types.SqlTimeStamp    `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+    ID        int64                  `bun:"id,type:uuid,pk," json:"id"`
+    Username  string                 `bun:"username,type:text,notnull," json:"username"`
+    Email     sql_types.SqlString    `bun:"email,type:text,nullzero," json:"email"`
+    Tags      []string               `bun:"tags,type:text[],array,default:'{}',notnull," json:"tags"`
+    CreatedAt sql_types.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
 }
 ```
 
@@ -113,7 +113,7 @@ type User struct {
     ID        string         `bun:"id,type:uuid,pk," json:"id"`
     Username  string         `bun:"username,type:text,notnull," json:"username"`
     Email     sql.NullString `bun:"email,type:text,nullzero," json:"email"`
-    Tags      []string       `bun:"tags,type:text[],default:'{}',notnull," json:"tags"`
+    Tags      []string       `bun:"tags,type:text[],array,default:'{}',notnull," json:"tags"`
     CreatedAt time.Time      `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
 }
 ```
@@ -145,11 +145,17 @@ The nullable type package is selected with `--types` (or `WriterOptions.Nullable
 | `numeric`, `decimal` | `float64` | `SqlFloat64` | `sql.NullFloat64` |
 | `uuid` | `string` | `SqlUUID` | `sql.NullString` |
 | `jsonb` | `string` | `SqlJSONB` | `sql.NullString` |
-| `text[]` | `SqlStringArray` | `SqlStringArray` | `[]string` |
-| `integer[]` | `SqlInt32Array` | `SqlInt32Array` | `[]int32` |
-| `uuid[]` | `SqlUUIDArray` | `SqlUUIDArray` | `[]string` |
+| `text[]` | `[]string`† | `[]string`† | `[]string`† |
+| `integer[]` | `[]int32`† | `[]int32`† | `[]int32`† |
+| `uuid[]` | `[]string`† | `[]string`† | `[]string`† |
 | `vector` | `SqlVector` | `SqlVector` | `[]float32` |
 
+† Array columns always use a plain native Go slice with an explicit `array`
+bun tag (`bun:"tags,type:text[],array,..."`), in every `--types` mode — the
+`SqlXxxArray` wrapper types are never used, since bun's pgdialect scans/appends
+native slices directly. Regardless of NOT NULL, unless `--array-nullable
+pointer_slice` is set — see [NullableArrays](#nullablearrays) below.
+
 \* In sqltypes mode, NOT NULL timestamps use `SqlTimeStamp` (not `time.Time`) unless the base type is a simple integer or boolean. In stdlib mode, NOT NULL timestamps use `time.Time`.
 
 ## Writer Options
@@ -174,6 +180,34 @@ options := &writers.WriterOptions{
 }
 ```
 
+### NullableArrays
+
+Controls how nullable PostgreSQL array columns are represented in stdlib/baselib
+`--types` mode (no effect in `sqltypes` mode, which always uses the `SqlXxxArray`
+wrapper types). Set via the `--array-nullable` CLI flag or `WriterOptions.NullableArrays`:
+
+```go
+// Default: every array column is a plain slice, e.g. []string.
+// SQL NULL and '{}' both scan into a nil/zero-length slice, so callers
+// cannot distinguish them.
+options := &writers.WriterOptions{
+    NullableArrays: writers.NullableArraysSlice,
+}
+
+// Nullable array columns become a pointer to a slice, e.g. *[]string.
+// A nil pointer means SQL NULL; a non-nil pointer to an empty slice
+// means '{}'. NOT NULL array columns are unaffected and stay plain slices.
+options := &writers.WriterOptions{
+    NullableArrays: writers.NullableArraysPointerSlice,
+}
+```
+
+```
+tags []string   `bun:"tags,type:text[],notnull,"`   // NOT NULL, either mode
+tags []string   `bun:"tags,type:text[],nullzero,"`   // nullable, default (slice)
+tags *[]string  `bun:"tags,type:text[],nullzero,"`   // nullable, pointer_slice
+```
+
 ### Metadata Options
 
 ```go
@@ -248,7 +282,7 @@ Example `extra-fields.json`:
 - Model names are derived from table names (singularized, PascalCase)
 - Table aliases are auto-generated from table names
 - Nullable columns use plain Go pointer types (`*string`, `*time.Time`, …) by default; pass `--types sqltypes` to use `sql_types.SqlString`, `sql_types.SqlTimeStamp`, etc., or `--types stdlib` to use `sql.NullString`, `sql.NullTime`, etc.
-- Array columns use plain Go slices (`[]string`, `[]int32`, …) by default; `--types sqltypes` uses `sql_types.SqlStringArray`, `sql_types.SqlInt32Array`, etc.
+- Array columns always use plain Go slices (`[]string`, `[]int32`, …) with an explicit `array` bun tag, regardless of `--types`; pass `--array-nullable pointer_slice` to use `*[]string` etc. for nullable array columns.
 - Multi-file mode: one file per table named `sql_{schema}_{table}.go`
 - Generated code is auto-formatted
 - JSON tags are automatically added

pkg/writers/bun/array_integration_test.go

@@ -0,0 +1,141 @@
+package bun_test
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"testing"
+
+	_ "github.com/jackc/pgx/v5/stdlib"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/dialect/pgdialect"
+)
+
+// TestBunArrayColumns_NativeSlice verifies against a live PostgreSQL
+// database (issue #13) that RelSpec's generated Bun array tags round-trip
+// correctly through Bun's own pgdialect for both NOT NULL and nullable
+// columns: NULL, '{}', and populated arrays must all scan and insert
+// without a "bun: Scan(unsupported ...)" error.
+//
+// Requires the RELSPEC_TEST_PG_CONN environment variable, e.g.:
+//
+//	RELSPEC_TEST_PG_CONN="postgres://postgres:postgres@localhost:5432/relspec_test?sslmode=disable"
+func TestBunArrayColumns_NativeSlice(t *testing.T) {
+	connStr := os.Getenv("RELSPEC_TEST_PG_CONN")
+	if connStr == "" {
+		t.Skip("Skipping Bun array integration test: RELSPEC_TEST_PG_CONN environment variable not set")
+	}
+
+	sqldb, err := sql.Open("pgx", connStr)
+	if err != nil {
+		t.Fatalf("open connection: %v", err)
+	}
+	defer sqldb.Close()
+
+	db := bun.NewDB(sqldb, pgdialect.New())
+	ctx := context.Background()
+
+	type notNullArrayRow struct {
+		bun.BaseModel `bun:"table:relspec_test_arr_notnull"`
+		ID            int64    `bun:"id,pk,autoincrement"`
+		Tags          []string `bun:"tags,type:text[],notnull"`
+	}
+
+	type nullableArrayRow struct {
+		bun.BaseModel `bun:"table:relspec_test_arr_nullable"`
+		ID            int64     `bun:"id,pk,autoincrement"`
+		Tags          *[]string `bun:"tags,type:text[]"`
+	}
+
+	if _, err := db.NewDropTable().Model((*notNullArrayRow)(nil)).IfExists().Exec(ctx); err != nil {
+		t.Fatalf("drop table: %v", err)
+	}
+	if _, err := db.NewDropTable().Model((*nullableArrayRow)(nil)).IfExists().Exec(ctx); err != nil {
+		t.Fatalf("drop table: %v", err)
+	}
+	if _, err := db.NewCreateTable().Model((*notNullArrayRow)(nil)).Exec(ctx); err != nil {
+		t.Fatalf("create not-null table: %v", err)
+	}
+	if _, err := db.NewCreateTable().Model((*nullableArrayRow)(nil)).Exec(ctx); err != nil {
+		t.Fatalf("create nullable table: %v", err)
+	}
+	t.Cleanup(func() {
+		db.NewDropTable().Model((*notNullArrayRow)(nil)).IfExists().Exec(ctx)
+		db.NewDropTable().Model((*nullableArrayRow)(nil)).IfExists().Exec(ctx)
+	})
+
+	t.Run("not null populated array", func(t *testing.T) {
+		row := &notNullArrayRow{Tags: []string{"a", "b", "c"}}
+		if _, err := db.NewInsert().Model(row).Exec(ctx); err != nil {
+			t.Fatalf("insert: %v", err)
+		}
+		var out notNullArrayRow
+		if err := db.NewSelect().Model(&out).Where("id = ?", row.ID).Scan(ctx); err != nil {
+			t.Fatalf("select: %v", err)
+		}
+		if len(out.Tags) != 3 || out.Tags[0] != "a" || out.Tags[2] != "c" {
+			t.Errorf("Tags = %v, want [a b c]", out.Tags)
+		}
+	})
+
+	t.Run("not null empty array", func(t *testing.T) {
+		row := &notNullArrayRow{Tags: []string{}}
+		if _, err := db.NewInsert().Model(row).Exec(ctx); err != nil {
+			t.Fatalf("insert: %v", err)
+		}
+		var out notNullArrayRow
+		if err := db.NewSelect().Model(&out).Where("id = ?", row.ID).Scan(ctx); err != nil {
+			t.Fatalf("select: %v", err)
+		}
+		if len(out.Tags) != 0 {
+			t.Errorf("Tags = %v, want empty", out.Tags)
+		}
+	})
+
+	t.Run("nullable NULL", func(t *testing.T) {
+		row := &nullableArrayRow{Tags: nil}
+		if _, err := db.NewInsert().Model(row).Exec(ctx); err != nil {
+			t.Fatalf("insert: %v", err)
+		}
+		var out nullableArrayRow
+		if err := db.NewSelect().Model(&out).Where("id = ?", row.ID).Scan(ctx); err != nil {
+			t.Fatalf("select: %v", err)
+		}
+		if out.Tags != nil {
+			t.Errorf("Tags = %v, want nil (SQL NULL)", *out.Tags)
+		}
+	})
+
+	t.Run("nullable empty array", func(t *testing.T) {
+		empty := []string{}
+		row := &nullableArrayRow{Tags: &empty}
+		if _, err := db.NewInsert().Model(row).Exec(ctx); err != nil {
+			t.Fatalf("insert: %v", err)
+		}
+		var out nullableArrayRow
+		if err := db.NewSelect().Model(&out).Where("id = ?", row.ID).Scan(ctx); err != nil {
+			t.Fatalf("select: %v", err)
+		}
+		if out.Tags == nil {
+			t.Fatalf("Tags = nil, want non-nil pointer to empty slice")
+		}
+		if len(*out.Tags) != 0 {
+			t.Errorf("Tags = %v, want empty slice", *out.Tags)
+		}
+	})
+
+	t.Run("nullable populated array", func(t *testing.T) {
+		tags := []string{"x", "y"}
+		row := &nullableArrayRow{Tags: &tags}
+		if _, err := db.NewInsert().Model(row).Exec(ctx); err != nil {
+			t.Fatalf("insert: %v", err)
+		}
+		var out nullableArrayRow
+		if err := db.NewSelect().Model(&out).Where("id = ?", row.ID).Scan(ctx); err != nil {
+			t.Fatalf("select: %v", err)
+		}
+		if out.Tags == nil || len(*out.Tags) != 2 || (*out.Tags)[0] != "x" {
+			t.Errorf("Tags = %v, want [x y]", out.Tags)
+		}
+	})
+}

pkg/writers/bun/template_data.go

@@ -220,8 +220,11 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper, fl
 		Prefix:        GeneratePrefix(table.Name),
 	}
 
+	// Convert columns to fields (sorted by sequence or name)
+	columns := sortColumns(table.Columns)
+
 	// Find primary key
-	for _, col := range table.Columns {
+	for _, col := range columns {
 		if col.IsPrimaryKey {
 			// Sanitize column name to remove backticks
 			safeName := writers.SanitizeStructTagValue(col.Name)
@@ -240,8 +243,6 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper, fl
 		}
 	}
 
-	// Convert columns to fields (sorted by sequence or name)
-	columns := sortColumns(table.Columns)
 	for _, col := range columns {
 		field := columnToField(col, table, typeMapper)
 		// Check for name collision with generated methods and rename if needed
@@ -335,6 +336,21 @@ func sortConstraints(constraints map[string]*models.Constraint) []*models.Constr
 	return result
 }
 
+// sortIndexes sorts indexes by sequence, then by name
+func sortIndexes(indexes map[string]*models.Index) []*models.Index {
+	result := make([]*models.Index, 0, len(indexes))
+	for _, idx := range indexes {
+		result = append(result, idx)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
 // sortColumns sorts columns by sequence, then by name
 func sortColumns(columns map[string]*models.Column) []*models.Column {
 	result := make([]*models.Column, 0, len(columns))

pkg/writers/bun/type_mapper.go

@@ -13,26 +13,37 @@ import (
 type TypeMapper struct {
 	sqlTypesAlias string
 	typeStyle     string // writers.NullableTypeSqlTypes | writers.NullableTypeStdlib | writers.NullableTypeBaselib
+	arrayNullable string // writers.NullableArraysSlice | writers.NullableArraysPointerSlice
 }
 
 // NewTypeMapper creates a new TypeMapper.
 // typeStyle should be writers.NullableTypeSqlTypes, writers.NullableTypeStdlib, or
 // writers.NullableTypeBaselib; an empty string defaults to baselib.
-func NewTypeMapper(typeStyle string) *TypeMapper {
+// arrayNullable should be writers.NullableArraysSlice or
+// writers.NullableArraysPointerSlice; an empty string defaults to slice.
+func NewTypeMapper(typeStyle, arrayNullable string) *TypeMapper {
 	if typeStyle == "" {
 		typeStyle = writers.NullableTypeBaselib
 	}
+	if arrayNullable == "" {
+		arrayNullable = writers.NullableArraysSlice
+	}
 	return &TypeMapper{
 		sqlTypesAlias: "sql_types",
 		typeStyle:     typeStyle,
+		arrayNullable: arrayNullable,
 	}
 }
 
 // SQLTypeToGoType converts a SQL type to its Go equivalent.
 func (tm *TypeMapper) SQLTypeToGoType(sqlType string, notNull bool) string {
-	// Array types are handled separately for both styles.
+	// Array columns always use a native Go slice, regardless of typeStyle.
 	if pgsql.IsArrayType(sqlType) {
-		return tm.arrayGoType(tm.extractBaseType(sqlType))
+		goType := tm.arrayGoType(tm.extractBaseType(sqlType))
+		if !notNull && tm.arrayNullable == writers.NullableArraysPointerSlice {
+			goType = "*" + goType
+		}
+		return goType
 	}
 
 	baseType := tm.extractBaseType(sqlType)
@@ -188,34 +199,13 @@ func (tm *TypeMapper) bunGoType(sqlType string) string {
 
 // arrayGoType returns the Go type for a PostgreSQL array column.
 // The baseElemType is the canonical base type (e.g. "text", "integer").
+//
+// Array columns always use a plain native Go slice, even in sqltypes mode:
+// bun's pgdialect scans native slices directly, and the SqlXxxArray wrapper
+// types are not usable as array columns (their Scan/Append are bypassed
+// whenever the "array" bun tag is set, which is required for arrays).
 func (tm *TypeMapper) arrayGoType(baseElemType string) string {
-	if tm.typeStyle == writers.NullableTypeStdlib || tm.typeStyle == writers.NullableTypeBaselib {
-		return tm.stdlibArrayGoType(baseElemType)
-	}
-	typeMap := map[string]string{
-		"text": tm.sqlTypesAlias + ".SqlStringArray", "varchar": tm.sqlTypesAlias + ".SqlStringArray",
-		"char": tm.sqlTypesAlias + ".SqlStringArray", "character": tm.sqlTypesAlias + ".SqlStringArray",
-		"citext": tm.sqlTypesAlias + ".SqlStringArray", "bpchar": tm.sqlTypesAlias + ".SqlStringArray",
-		"inet": tm.sqlTypesAlias + ".SqlStringArray", "cidr": tm.sqlTypesAlias + ".SqlStringArray",
-		"macaddr": tm.sqlTypesAlias + ".SqlStringArray",
-		"json":    tm.sqlTypesAlias + ".SqlStringArray", "jsonb": tm.sqlTypesAlias + ".SqlStringArray",
-		"integer": tm.sqlTypesAlias + ".SqlInt32Array", "int": tm.sqlTypesAlias + ".SqlInt32Array",
-		"int4": tm.sqlTypesAlias + ".SqlInt32Array", "serial": tm.sqlTypesAlias + ".SqlInt32Array",
-		"smallint": tm.sqlTypesAlias + ".SqlInt16Array", "int2": tm.sqlTypesAlias + ".SqlInt16Array",
-		"smallserial": tm.sqlTypesAlias + ".SqlInt16Array",
-		"bigint":      tm.sqlTypesAlias + ".SqlInt64Array", "int8": tm.sqlTypesAlias + ".SqlInt64Array",
-		"bigserial": tm.sqlTypesAlias + ".SqlInt64Array",
-		"real":      tm.sqlTypesAlias + ".SqlFloat32Array", "float4": tm.sqlTypesAlias + ".SqlFloat32Array",
-		"double precision": tm.sqlTypesAlias + ".SqlFloat64Array", "float8": tm.sqlTypesAlias + ".SqlFloat64Array",
-		"numeric": tm.sqlTypesAlias + ".SqlFloat64Array", "decimal": tm.sqlTypesAlias + ".SqlFloat64Array",
-		"money":   tm.sqlTypesAlias + ".SqlFloat64Array",
-		"boolean": tm.sqlTypesAlias + ".SqlBoolArray", "bool": tm.sqlTypesAlias + ".SqlBoolArray",
-		"uuid": tm.sqlTypesAlias + ".SqlUUIDArray",
-	}
-	if goType, ok := typeMap[baseElemType]; ok {
-		return goType
-	}
-	return tm.sqlTypesAlias + ".SqlStringArray"
+	return tm.stdlibArrayGoType(baseElemType)
 }
 
 // rawGoType returns the plain Go type for a NOT NULL column in stdlib mode.
@@ -361,7 +351,7 @@ func (tm *TypeMapper) BuildBunTag(column *models.Column, table *models.Table) st
 			}
 		}
 		parts = append(parts, fmt.Sprintf("type:%s", typeStr))
-		if isArray && tm.typeStyle == writers.NullableTypeStdlib {
+		if isArray {
 			parts = append(parts, "array")
 		}
 	}
@@ -393,7 +383,7 @@ func (tm *TypeMapper) BuildBunTag(column *models.Column, table *models.Table) st
 
 	// Check for indexes (unique indexes should be added to tag)
 	if table != nil {
-		for _, index := range table.Indexes {
+		for _, index := range sortIndexes(table.Indexes) {
 			if !index.Unique {
 				continue
 			}

pkg/writers/bun/writer.go

@@ -24,7 +24,7 @@ type Writer struct {
 func NewWriter(options *writers.WriterOptions) *Writer {
 	w := &Writer{
 		options:    options,
-		typeMapper: NewTypeMapper(options.NullableTypes),
+		typeMapper: NewTypeMapper(options.NullableTypes, options.NullableArrays),
 		config:     LoadMethodConfigFromMetadata(options.Metadata),
 	}
 

pkg/writers/bun/writer_test.go

@@ -556,7 +556,7 @@ func TestWriter_FieldNameCollision(t *testing.T) {
 }
 
 func TestTypeMapper_SQLTypeToGoType_Bun(t *testing.T) {
-	mapper := NewTypeMapper("")
+	mapper := NewTypeMapper("", "")
 
 	tests := []struct {
 		sqlType string
@@ -701,7 +701,7 @@ func TestWriter_StringPrimaryKeyHelpers_Bun(t *testing.T) {
 }
 
 func TestTypeMapper_BuildBunTag(t *testing.T) {
-	mapper := NewTypeMapper("")
+	mapper := NewTypeMapper("", "")
 
 	tests := []struct {
 		name   string
@@ -827,29 +827,115 @@ func TestTypeMapper_BuildBunTag(t *testing.T) {
 					t.Errorf("BuildBunTag() = %q, missing %q", result, part)
 				}
 			}
-			// sqltypes mode must NOT add "array" — SqlXxxArray uses sql.Scanner
-			if strings.Contains(result, ",array,") || strings.HasSuffix(result, ",array,") {
-				t.Errorf("BuildBunTag() = %q, must not contain 'array' in sqltypes mode", result)
+			// Array columns always carry the "array" tag, telling bun's
+			// pgdialect to scan/append the native Go slice as a PostgreSQL array.
+			if strings.HasSuffix(tt.column.Type, "[]") && !strings.Contains(result, ",array,") {
+				t.Errorf("BuildBunTag() = %q, expected 'array' tag", result)
 			}
 		})
 	}
 }
 
-func TestTypeMapper_BuildBunTag_StdlibArrayHasArrayTag(t *testing.T) {
-	mapper := NewTypeMapper(writers.NullableTypeStdlib)
-
-	cases := []struct {
-		name   string
-		column *models.Column
-	}{
-		{name: "text array", column: &models.Column{Name: "tags", Type: "text[]"}},
-		{name: "integer array", column: &models.Column{Name: "scores", Type: "integer[]", NotNull: true}},
+// TestTypeMapper_BuildBunTag_MultipleUniqueIndexesDeterministic verifies that
+// when a column belongs to more than one unique index, the "unique:" tag
+// fragments always appear in the same order across repeated calls, instead
+// of following Go's randomized map iteration order over Table.Indexes.
+func TestTypeMapper_BuildBunTag_MultipleUniqueIndexesDeterministic(t *testing.T) {
+	mapper := NewTypeMapper("", "")
+	table := &models.Table{
+		Name: "accounts",
+		Indexes: map[string]*models.Index{
+			"idx_z_accounts_email_tenant": {
+				Name:    "idx_z_accounts_email_tenant",
+				Columns: []string{"email", "tenant_id"},
+				Unique:  true,
+			},
+			"idx_a_accounts_email_region": {
+				Name:    "idx_a_accounts_email_region",
+				Columns: []string{"email", "region_id"},
+				Unique:  true,
+			},
+		},
 	}
+	column := &models.Column{Name: "email", Type: "varchar", Length: 255, NotNull: true}
+
+	first := mapper.BuildBunTag(column, table)
+	for i := 0; i < 50; i++ {
+		got := mapper.BuildBunTag(column, table)
+		if got != first {
+			t.Fatalf("BuildBunTag() is non-deterministic across calls: %q vs %q", first, got)
+		}
+	}
+
+	wantOrder := "unique:idx_a_accounts_email_region,unique:idx_z_accounts_email_tenant,"
+	if !strings.Contains(first, wantOrder) {
+		t.Errorf("BuildBunTag() = %q, want unique tags sorted by index name: %q", first, wantOrder)
+	}
+}
+
+// TestTypeMapper_BuildBunTag_ArraysAreNativeInEveryMode verifies that array
+// columns always use a plain "text[]"-style type and the native Go slice
+// type plus an explicit "array" tag, regardless of NullableTypes style
+// (sqltypes/stdlib/baselib). bun's pgdialect scans/appends native slices
+// directly; the SqlXxxArray wrapper types are never used for array columns.
+func TestTypeMapper_BuildBunTag_ArraysAreNativeInEveryMode(t *testing.T) {
+	for _, style := range []string{writers.NullableTypeSqlTypes, writers.NullableTypeStdlib, writers.NullableTypeBaselib} {
+		t.Run(style, func(t *testing.T) {
+			mapper := NewTypeMapper(style, "")
+
+			cases := []struct {
+				name       string
+				column     *models.Column
+				wantSubstr string
+			}{
+				{name: "text array", column: &models.Column{Name: "tags", Type: "text[]"}, wantSubstr: "type:text[],array,"},
+				{name: "varchar array", column: &models.Column{Name: "labels", Type: "varchar[]"}, wantSubstr: "type:varchar[],array,"},
+				{name: "integer array", column: &models.Column{Name: "scores", Type: "integer[]", NotNull: true}, wantSubstr: "type:integer[],array,"},
+				{name: "boolean array", column: &models.Column{Name: "flags", Type: "boolean[]"}, wantSubstr: "type:boolean[],array,"},
+				{name: "uuid array", column: &models.Column{Name: "ids", Type: "uuid[]"}, wantSubstr: "type:uuid[],array,"},
+			}
+			for _, tt := range cases {
+				t.Run(tt.name, func(t *testing.T) {
+					result := mapper.BuildBunTag(tt.column, nil)
+					if !strings.Contains(result, tt.wantSubstr) {
+						t.Errorf("BuildBunTag() = %q, missing %q", result, tt.wantSubstr)
+					}
+					goType := mapper.SQLTypeToGoType(tt.column.Type, tt.column.NotNull)
+					if strings.Contains(goType, "sql_types") {
+						t.Errorf("SQLTypeToGoType() = %q, array columns must use a native Go slice, not an sql_types wrapper", goType)
+					}
+				})
+			}
+		})
+	}
+}
+
+// TestTypeMapper_SQLTypeToGoType_ArrayNullable verifies that nullable array
+// columns become a pointer-to-slice when NullableArrays is
+// "pointer_slice", so callers can distinguish SQL NULL (nil pointer) from
+// '{}' (pointer to an empty slice); NOT NULL columns are unaffected.
+func TestTypeMapper_SQLTypeToGoType_ArrayNullable(t *testing.T) {
+	cases := []struct {
+		name          string
+		typeStyle     string
+		arrayNullable string
+		sqlType       string
+		notNull       bool
+		want          string
+	}{
+		{name: "baselib nullable slice (default)", typeStyle: writers.NullableTypeBaselib, arrayNullable: "", sqlType: "text[]", notNull: false, want: "[]string"},
+		{name: "baselib nullable pointer_slice", typeStyle: writers.NullableTypeBaselib, arrayNullable: writers.NullableArraysPointerSlice, sqlType: "text[]", notNull: false, want: "*[]string"},
+		{name: "baselib not null pointer_slice unaffected", typeStyle: writers.NullableTypeBaselib, arrayNullable: writers.NullableArraysPointerSlice, sqlType: "text[]", notNull: true, want: "[]string"},
+		{name: "stdlib nullable pointer_slice", typeStyle: writers.NullableTypeStdlib, arrayNullable: writers.NullableArraysPointerSlice, sqlType: "integer[]", notNull: false, want: "*[]int32"},
+		{name: "sqltypes nullable pointer_slice (arrays are always native)", typeStyle: writers.NullableTypeSqlTypes, arrayNullable: writers.NullableArraysPointerSlice, sqlType: "text[]", notNull: false, want: "*[]string"},
+	}
+
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
-			result := mapper.BuildBunTag(tt.column, nil)
-			if !strings.Contains(result, "array") {
-				t.Errorf("BuildBunTag() = %q, expected 'array' in stdlib mode", result)
+			mapper := NewTypeMapper(tt.typeStyle, tt.arrayNullable)
+			got := mapper.SQLTypeToGoType(tt.sqlType, tt.notNull)
+			if got != tt.want {
+				t.Errorf("SQLTypeToGoType(%q, %v) = %q, want %q", tt.sqlType, tt.notNull, got, tt.want)
 			}
 		})
 	}
@@ -1016,7 +1102,7 @@ func TestExtraFields_InMultiFile(t *testing.T) {
 }
 
 func TestTypeMapper_BuildBunTag_PreservesExplicitTypeModifiers(t *testing.T) {
-	mapper := NewTypeMapper("")
+	mapper := NewTypeMapper("", "")
 
 	col := &models.Column{
 		Name:      "embedding",

pkg/writers/dbml/writer.go

@@ -3,6 +3,7 @@ package dbml
 import (
 	"fmt"
 	"os"
+	"sort"
 	"strings"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
@@ -78,7 +79,7 @@ func (w *Writer) databaseToDBML(d *models.Database) string {
 	sb.WriteString("\n// Relationships\n")
 	for _, schema := range d.Schemas {
 		for _, table := range schema.Tables {
-			for _, constraint := range table.Constraints {
+			for _, constraint := range sortConstraints(table.Constraints) {
 				if constraint.Type == models.ForeignKeyConstraint {
 					sb.WriteString(w.constraintToDBML(constraint, table))
 				}
@@ -112,7 +113,7 @@ func (w *Writer) tableToDBML(t *models.Table) string {
 	tableName := fmt.Sprintf("%s.%s", t.Schema, t.Name)
 	fmt.Fprintf(&sb, "Table %s {\n", tableName)
 
-	for _, column := range t.Columns {
+	for _, column := range sortColumns(t.Columns) {
 		fmt.Fprintf(&sb, "  %s %s", column.Name, column.Type)
 
 		var attrs []string
@@ -149,7 +150,7 @@ func (w *Writer) tableToDBML(t *models.Table) string {
 
 	if len(t.Indexes) > 0 {
 		sb.WriteString("\n  indexes {\n")
-		for _, index := range t.Indexes {
+		for _, index := range sortIndexes(t.Indexes) {
 			var indexAttrs []string
 			if index.Unique {
 				indexAttrs = append(indexAttrs, "unique")
@@ -230,3 +231,48 @@ func (w *Writer) constraintToDBML(c *models.Constraint, t *models.Table) string
 
 	return refLine + "\n"
 }
+
+// sortColumns returns columns sorted by Sequence then Name for deterministic output.
+func sortColumns(columns map[string]*models.Column) []*models.Column {
+	result := make([]*models.Column, 0, len(columns))
+	for _, col := range columns {
+		result = append(result, col)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortConstraints returns constraints sorted by Sequence then Name for deterministic output.
+func sortConstraints(constraints map[string]*models.Constraint) []*models.Constraint {
+	result := make([]*models.Constraint, 0, len(constraints))
+	for _, c := range constraints {
+		result = append(result, c)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortIndexes returns indexes sorted by Sequence then Name for deterministic output.
+func sortIndexes(indexes map[string]*models.Index) []*models.Index {
+	result := make([]*models.Index, 0, len(indexes))
+	for _, idx := range indexes {
+		result = append(result, idx)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}

pkg/writers/dctx/writer.go

@@ -66,7 +66,14 @@ func (w *Writer) WriteSchema(schema *models.Schema) error {
 
 	// Add table-level relationships
 	for _, table := range tableSlice {
-		for _, rel := range table.Relationships {
+		relNames := make([]string, 0, len(table.Relationships))
+		for name := range table.Relationships {
+			relNames = append(relNames, name)
+		}
+		sort.Strings(relNames)
+
+		for _, relName := range relNames {
+			rel := table.Relationships[relName]
 			// Check if this relationship is already in the list (avoid duplicates)
 			isDuplicate := false
 			for _, existing := range allRelations {

pkg/writers/drawdb/writer.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"sort"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
@@ -175,7 +176,7 @@ func (w *Writer) databaseToDrawDB(d *models.Database) *DrawDBSchema {
 	// Add relationships
 	for _, schemaModel := range d.Schemas {
 		for _, table := range schemaModel.Tables {
-			for _, constraint := range table.Constraints {
+			for _, constraint := range sortConstraints(table.Constraints) {
 				if constraint.Type == models.ForeignKeyConstraint && constraint.ReferencedTable != "" {
 					startTableKey := fmt.Sprintf("%s.%s", schemaModel.Name, table.Name)
 					endTableKey := fmt.Sprintf("%s.%s", constraint.ReferencedSchema, constraint.ReferencedTable)
@@ -306,7 +307,7 @@ func (w *Writer) convertTableToDrawDB(table *models.Table, schemaName string, ta
 	}
 
 	// Add fields
-	for _, column := range table.Columns {
+	for _, column := range sortColumns(table.Columns) {
 		field := &DrawDBField{
 			ID:        fieldID,
 			Name:      column.Name,
@@ -339,7 +340,7 @@ func (w *Writer) convertTableToDrawDB(table *models.Table, schemaName string, ta
 
 	// Add indexes
 	indexID := 0
-	for _, index := range table.Indexes {
+	for _, index := range sortIndexes(table.Indexes) {
 		drawIndex := &DrawDBIndex{
 			ID:     indexID,
 			Name:   index.Name,
@@ -393,3 +394,48 @@ func getColorForIndex(index int) string {
 	}
 	return colors[index%len(colors)]
 }
+
+// sortColumns returns columns sorted by Sequence then Name for deterministic output.
+func sortColumns(columns map[string]*models.Column) []*models.Column {
+	result := make([]*models.Column, 0, len(columns))
+	for _, col := range columns {
+		result = append(result, col)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortConstraints returns constraints sorted by Sequence then Name for deterministic output.
+func sortConstraints(constraints map[string]*models.Constraint) []*models.Constraint {
+	result := make([]*models.Constraint, 0, len(constraints))
+	for _, c := range constraints {
+		result = append(result, c)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortIndexes returns indexes sorted by Sequence then Name for deterministic output.
+func sortIndexes(indexes map[string]*models.Index) []*models.Index {
+	result := make([]*models.Index, 0, len(indexes))
+	for _, idx := range indexes {
+		result = append(result, idx)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}

pkg/writers/drizzle/writer.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
@@ -250,7 +251,7 @@ func (w *Writer) buildTableData(table *models.Table, schema *models.Schema, db *
 	indexColumnFields := make(map[string]bool)
 
 	// Add indexes (excluding single-column unique indexes, which are handled inline)
-	for _, index := range table.Indexes {
+	for _, index := range sortIndexes(table.Indexes) {
 		// Skip single-column unique indexes (handled by .unique() modifier)
 		if index.Unique && len(index.Columns) == 1 {
 			continue
@@ -270,7 +271,7 @@ func (w *Writer) buildTableData(table *models.Table, schema *models.Schema, db *
 	}
 
 	// Add multi-column unique constraints as unique indexes
-	for _, constraint := range table.Constraints {
+	for _, constraint := range sortConstraints(table.Constraints) {
 		if constraint.Type == models.UniqueConstraint && len(constraint.Columns) > 1 {
 			// Create a unique index for this constraint
 			indexData := &IndexData{
@@ -316,6 +317,36 @@ func (w *Writer) buildTableData(table *models.Table, schema *models.Schema, db *
 	return tableData
 }
 
+// sortIndexes returns indexes sorted by Sequence then Name for deterministic output.
+func sortIndexes(indexes map[string]*models.Index) []*models.Index {
+	result := make([]*models.Index, 0, len(indexes))
+	for _, idx := range indexes {
+		result = append(result, idx)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortConstraints returns constraints sorted by Sequence then Name for deterministic output.
+func sortConstraints(constraints map[string]*models.Constraint) []*models.Constraint {
+	result := make([]*models.Constraint, 0, len(constraints))
+	for _, c := range constraints {
+		result = append(result, c)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
 // sortStrings sorts a slice of strings in place
 func sortStrings(strs []string) {
 	for i := 0; i < len(strs); i++ {
@@ -422,7 +453,8 @@ func (w *Writer) getTableEnumNames(table *models.Table, schema *models.Schema, e
 	enumNames := make([]string, 0)
 	seen := make(map[string]bool)
 
-	for _, col := range table.Columns {
+	for _, colName := range w.getSortedColumnNames(table) {
+		col := table.Columns[colName]
 		if enumMap[col.Type] || enumMap[strings.ToLower(col.Type)] {
 			// Find the enum in schema
 			for _, enum := range schema.Enums {

pkg/writers/gorm/template_data.go

@@ -134,8 +134,11 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper, fl
 		Prefix:        GeneratePrefix(table.Name),
 	}
 
+	// Convert columns to fields (sorted by sequence or name)
+	columns := sortColumns(table.Columns)
+
 	// Find primary key
-	for _, col := range table.Columns {
+	for _, col := range columns {
 		if col.IsPrimaryKey {
 			// Sanitize column name to remove backticks
 			safeName := writers.SanitizeStructTagValue(col.Name)
@@ -153,8 +156,6 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper, fl
 		}
 	}
 
-	// Convert columns to fields (sorted by sequence or name)
-	columns := sortColumns(table.Columns)
 	for _, col := range columns {
 		field := columnToField(col, table, typeMapper)
 		// Check for name collision with generated methods and rename if needed
@@ -248,6 +249,21 @@ func sortConstraints(constraints map[string]*models.Constraint) []*models.Constr
 	return result
 }
 
+// sortIndexes sorts indexes by sequence, then by name
+func sortIndexes(indexes map[string]*models.Index) []*models.Index {
+	result := make([]*models.Index, 0, len(indexes))
+	for _, idx := range indexes {
+		result = append(result, idx)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
 // sortColumns sorts columns by sequence, then by name
 func sortColumns(columns map[string]*models.Column) []*models.Column {
 	result := make([]*models.Column, 0, len(columns))

pkg/writers/gorm/type_mapper.go

@@ -415,7 +415,7 @@ func (tm *TypeMapper) BuildGormTag(column *models.Column, table *models.Table) s
 
 	// Check for unique constraint
 	if table != nil {
-		for _, constraint := range table.Constraints {
+		for _, constraint := range sortConstraints(table.Constraints) {
 			if constraint.Type == models.UniqueConstraint {
 				for _, col := range constraint.Columns {
 					if col == column.Name {
@@ -431,7 +431,7 @@ func (tm *TypeMapper) BuildGormTag(column *models.Column, table *models.Table) s
 		}
 
 		// Check for index
-		for _, index := range table.Indexes {
+		for _, index := range sortIndexes(table.Indexes) {
 			for _, col := range index.Columns {
 				if col == column.Name {
 					if index.Unique {

pkg/writers/gorm/writer_test.go

@@ -757,3 +757,48 @@ func TestTypeMapper_BuildGormTag_PreservesExplicitTypeModifiers(t *testing.T) {
 		t.Fatalf("type modifier appears duplicated in %q", tag)
 	}
 }
+
+// TestTypeMapper_BuildGormTag_MultipleUniqueIndexesDeterministic verifies
+// that when a column belongs to a unique constraint and more than one
+// unique index, the "uniqueIndex:" tag fragments always appear in the same
+// order across repeated calls, instead of following Go's randomized map
+// iteration order over Table.Constraints and Table.Indexes.
+func TestTypeMapper_BuildGormTag_MultipleUniqueIndexesDeterministic(t *testing.T) {
+	mapper := NewTypeMapper("")
+	table := &models.Table{
+		Name: "accounts",
+		Constraints: map[string]*models.Constraint{
+			"uq_z_accounts_email": {
+				Name:    "uq_z_accounts_email",
+				Type:    models.UniqueConstraint,
+				Columns: []string{"email"},
+			},
+		},
+		Indexes: map[string]*models.Index{
+			"idx_z_accounts_email_tenant": {
+				Name:    "idx_z_accounts_email_tenant",
+				Columns: []string{"email", "tenant_id"},
+				Unique:  true,
+			},
+			"idx_a_accounts_email_region": {
+				Name:    "idx_a_accounts_email_region",
+				Columns: []string{"email", "region_id"},
+				Unique:  true,
+			},
+		},
+	}
+	column := &models.Column{Name: "email", Type: "varchar", Length: 255, NotNull: true}
+
+	first := mapper.BuildGormTag(column, table)
+	for i := 0; i < 50; i++ {
+		got := mapper.BuildGormTag(column, table)
+		if got != first {
+			t.Fatalf("BuildGormTag() is non-deterministic across calls: %q vs %q", first, got)
+		}
+	}
+
+	wantOrder := "uniqueIndex:uq_z_accounts_email;uniqueIndex:idx_a_accounts_email_region;uniqueIndex:idx_z_accounts_email_tenant"
+	if !strings.Contains(first, wantOrder) {
+		t.Errorf("BuildGormTag() = %q, want uniqueIndex tags sorted (constraint before indexes, indexes by name): %q", first, wantOrder)
+	}
+}

pkg/writers/graphql/writer.go

@@ -233,7 +233,8 @@ func (w *Writer) tableToGraphQL(table *models.Table, db *models.Database, schema
 	// Add relation fields
 	relationFields = w.generateRelationFields(table, db, schema)
 
-	// Write fields in order: ID, scalars (sorted), relations (sorted)
+	// Write fields in order: ID (sorted), scalars (sorted), relations (sorted)
+	sort.Strings(idFields)
 	for _, field := range idFields {
 		sb.WriteString(field + "\n")
 	}

pkg/writers/pgsql/README.md

@@ -169,6 +169,7 @@ When `include_audit` is enabled, adds:
 - Constraint actions (CASCADE, RESTRICT, SET NULL)
 - Partial indexes
 - Function-based indexes
+- Concurrent index creation (`CREATE INDEX CONCURRENTLY`) via `Index.Concurrent`
 - Check constraints with expressions
 
 ## Data Types

pkg/writers/pgsql/migration_writer.go

@@ -239,7 +239,8 @@ func (w *MigrationWriter) generateDropScripts(model *models.Schema, current *mod
 		}
 
 		// Check each constraint in current database
-		for constraintName, currentConstraint := range currentTable.Constraints {
+		for _, currentConstraint := range sortConstraints(currentTable.Constraints) {
+			constraintName := currentConstraint.Name
 			modelConstraint, existsInModel := modelTable.Constraints[constraintName]
 
 			shouldDrop := false
@@ -252,7 +253,8 @@ func (w *MigrationWriter) generateDropScripts(model *models.Schema, current *mod
 			if shouldDrop && currentConstraint.Type == models.PrimaryKeyConstraint {
 				// Drop FK constraints that depend on this PK before dropping the PK itself.
 				for _, otherTable := range current.Tables {
-					for fkName, fkConstraint := range otherTable.Constraints {
+					for _, fkConstraint := range sortConstraints(otherTable.Constraints) {
+						fkName := fkConstraint.Name
 						if fkConstraint.Type != models.ForeignKeyConstraint {
 							continue
 						}
@@ -310,7 +312,8 @@ func (w *MigrationWriter) generateDropScripts(model *models.Schema, current *mod
 		}
 
 		// Check indexes
-		for indexName, currentIndex := range currentTable.Indexes {
+		for _, currentIndex := range sortIndexes(currentTable.Indexes) {
+			indexName := currentIndex.Name
 			modelIndex, existsInModel := modelTable.Indexes[indexName]
 
 			shouldDrop := false
@@ -401,19 +404,12 @@ func (w *MigrationWriter) generateAlterTableScripts(schema *models.Schema, model
 	}
 
 	// Check each model column
-	for _, modelCol := range modelTable.Columns {
+	for _, modelCol := range sortColumns(modelTable.Columns) {
 		currentCol, exists := currentColumns[strings.ToLower(modelCol.Name)]
 
 		if !exists {
 			// Column doesn't exist, add it
-			defaultVal := ""
-			if modelCol.Default != nil {
-				if value, ok := modelCol.Default.(string); ok {
-					defaultVal = writers.QuoteDefaultValue(value, modelCol.Type)
-				} else {
-					defaultVal = fmt.Sprintf("%v", modelCol.Default)
-				}
-			}
+			_, defaultVal := formatColumnDefaultSQL(modelCol)
 
 			sql, err := w.executor.ExecuteAddColumn(AddColumnData{
 				SchemaName: schema.Name,
@@ -439,12 +435,14 @@ func (w *MigrationWriter) generateAlterTableScripts(schema *models.Schema, model
 		} else if !columnsEqual(modelCol, currentCol) {
 			// Column exists but properties changed
 			if !columnTypesEqual(modelCol, currentCol) {
-				sql, err := w.executor.ExecuteAlterColumnType(AlterColumnTypeData{
-					SchemaName: schema.Name,
-					TableName:  modelTable.Name,
-					ColumnName: modelCol.Name,
-					NewType:    effectiveAlterColumnSQLType(modelCol),
-					UsingExpr:  buildAlterColumnUsingExpression(modelCol.Name, effectiveAlterColumnSQLType(modelCol)),
+				newType := effectiveAlterColumnSQLType(modelCol)
+				sql, err := w.executor.ExecuteAlterColumnTypeWithCheck(AlterColumnTypeWithCheckData{
+					SchemaName:      schema.Name,
+					TableName:       modelTable.Name,
+					ColumnName:      modelCol.Name,
+					NewType:         newType,
+					EquivalentTypes: equivalentTypeListSQL(newType),
+					UsingExpr:       buildAlterColumnUsingExpression(modelCol.Name, newType),
 				})
 				if err != nil {
 					return nil, err
@@ -462,18 +460,10 @@ func (w *MigrationWriter) generateAlterTableScripts(schema *models.Schema, model
 			}
 
 			// Check default value changes
-			if fmt.Sprintf("%v", modelCol.Default) != fmt.Sprintf("%v", currentCol.Default) {
-				setDefault := modelCol.Default != nil
-				defaultVal := ""
-				if setDefault {
-					if value, ok := modelCol.Default.(string); ok {
-						defaultVal = writers.QuoteDefaultValue(value, modelCol.Type)
-					} else {
-						defaultVal = fmt.Sprintf("%v", modelCol.Default)
-					}
-				}
+			if !columnDefaultsEqual(modelCol.Default, currentCol.Default) {
+				setDefault, defaultVal := formatColumnDefaultSQL(modelCol)
 
-				sql, err := w.executor.ExecuteAlterColumnDefault(AlterColumnDefaultData{
+				sql, err := w.executor.ExecuteAlterColumnDefaultWithCheck(AlterColumnDefaultWithCheckData{
 					SchemaName:   schema.Name,
 					TableName:    modelTable.Name,
 					ColumnName:   modelCol.Name,
@@ -494,6 +484,29 @@ func (w *MigrationWriter) generateAlterTableScripts(schema *models.Schema, model
 				}
 				scripts = append(scripts, script)
 			}
+
+			// Check nullability changes
+			if modelCol.NotNull != currentCol.NotNull {
+				sql, err := w.executor.ExecuteAlterColumnNullabilityWithCheck(AlterColumnNullabilityWithCheckData{
+					SchemaName: schema.Name,
+					TableName:  modelTable.Name,
+					ColumnName: modelCol.Name,
+					NotNull:    modelCol.NotNull,
+				})
+				if err != nil {
+					return nil, err
+				}
+
+				script := MigrationScript{
+					ObjectName: fmt.Sprintf("%s.%s.%s", schema.Name, modelTable.Name, modelCol.Name),
+					ObjectType: "alter column nullability",
+					Schema:     schema.Name,
+					Priority:   145,
+					Sequence:   len(scripts),
+					Body:       sql,
+				}
+				scripts = append(scripts, script)
+			}
 		}
 	}
 
@@ -518,7 +531,8 @@ func (w *MigrationWriter) generateIndexScripts(model *models.Schema, current *mo
 
 		// Process primary keys first - check explicit constraints
 		foundExplicitPK := false
-		for constraintName, constraint := range modelTable.Constraints {
+		for _, constraint := range sortConstraints(modelTable.Constraints) {
+			constraintName := constraint.Name
 			if constraint.Type == models.PrimaryKeyConstraint {
 				foundExplicitPK = true
 				shouldCreate := true
@@ -603,7 +617,8 @@ func (w *MigrationWriter) generateIndexScripts(model *models.Schema, current *mo
 		}
 
 		// Process indexes
-		for indexName, modelIndex := range modelTable.Indexes {
+		for _, modelIndex := range sortIndexes(modelTable.Indexes) {
+			indexName := modelIndex.Name
 			// Skip primary key indexes
 			if strings.HasPrefix(strings.ToLower(indexName), "pk_") {
 				continue
@@ -637,6 +652,7 @@ func (w *MigrationWriter) generateIndexScripts(model *models.Schema, current *mo
 					IndexType:  indexType,
 					Columns:    strings.Join(columnExprs, ", "),
 					Unique:     modelIndex.Unique,
+					Concurrent: modelIndex.Concurrent,
 				})
 				if err != nil {
 					return nil, err
@@ -697,7 +713,8 @@ func (w *MigrationWriter) generateForeignKeyScripts(model *models.Schema, curren
 		currentTable := currentTables[strings.ToLower(modelTable.Name)]
 
 		// Process each constraint
-		for constraintName, constraint := range modelTable.Constraints {
+		for _, constraint := range sortConstraints(modelTable.Constraints) {
+			constraintName := constraint.Name
 			if constraint.Type != models.ForeignKeyConstraint {
 				continue
 			}
@@ -787,7 +804,7 @@ func (w *MigrationWriter) generateCommentScripts(model *models.Schema, current *
 		}
 
 		// Column comments
-		for _, col := range modelTable.Columns {
+		for _, col := range sortColumns(modelTable.Columns) {
 			if col.Description != "" {
 				sql, err := w.executor.ExecuteCommentColumn(CommentColumnData{
 					SchemaName: model.Name,
@@ -940,7 +957,24 @@ func columnsEqual(col1, col2 *models.Column) bool {
 	}
 	return columnTypesEqual(col1, col2) &&
 		col1.NotNull == col2.NotNull &&
-		fmt.Sprintf("%v", col1.Default) == fmt.Sprintf("%v", col2.Default)
+		columnDefaultsEqual(col1.Default, col2.Default)
+}
+
+// columnDefaultsEqual compares column defaults for drift detection, stripping
+// MySQL-style backticks (e.g. from GORM tags) so a model default of
+// "`now()`" is recognised as equal to a live default of "now()".
+func columnDefaultsEqual(default1, default2 interface{}) bool {
+	return normalizeDefaultForCompare(default1) == normalizeDefaultForCompare(default2)
+}
+
+func normalizeDefaultForCompare(value interface{}) string {
+	if value == nil {
+		return ""
+	}
+	if s, ok := value.(string); ok {
+		return strings.TrimSpace(stripBackticks(s))
+	}
+	return fmt.Sprintf("%v", value)
 }
 
 func columnTypesEqual(col1, col2 *models.Column) bool {

pkg/writers/pgsql/migration_writer_test.go

@@ -136,6 +136,89 @@ func TestWriteMigration_AltersColumnTypeWhenActualTypeDiffers(t *testing.T) {
 	}
 }
 
+func TestWriteMigration_AltersColumnTypeFallsBackToRenameAndAddOnConversionFailure(t *testing.T) {
+	current := models.InitDatabase("testdb")
+	currentSchema := models.InitSchema("public")
+	currentTable := models.InitTable("learnings", "public")
+	currentDetails := models.InitColumn("details", "learnings", "public")
+	currentDetails.Type = "varchar(50)"
+	currentTable.Columns["details"] = currentDetails
+	currentSchema.Tables = append(currentSchema.Tables, currentTable)
+	current.Schemas = append(current.Schemas, currentSchema)
+
+	model := models.InitDatabase("testdb")
+	modelSchema := models.InitSchema("public")
+	modelTable := models.InitTable("learnings", "public")
+	modelDetails := models.InitColumn("details", "learnings", "public")
+	modelDetails.Type = "integer"
+	modelTable.Columns["details"] = modelDetails
+	modelSchema.Tables = append(modelSchema.Tables, modelTable)
+	model.Schemas = append(model.Schemas, modelSchema)
+
+	var buf bytes.Buffer
+	writer, err := NewMigrationWriter(&writers.WriterOptions{})
+	if err != nil {
+		t.Fatalf("Failed to create writer: %v", err)
+	}
+	writer.writer = &buf
+
+	if err := writer.WriteMigration(model, current); err != nil {
+		t.Fatalf("WriteMigration failed: %v", err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "EXCEPTION WHEN OTHERS THEN") {
+		t.Fatalf("expected migration to guard the type conversion with an exception handler, got:\n%s", output)
+	}
+	if !strings.Contains(output, "RENAME COLUMN details TO %I") {
+		t.Fatalf("expected migration to rename the old column (derived from the live type) on conversion failure, got:\n%s", output)
+	}
+	if !strings.Contains(output, "renamed_column := 'details_' || trim(both '_' from regexp_replace(lower(current_type)") {
+		t.Fatalf("expected migration to derive the renamed column name from the live type, got:\n%s", output)
+	}
+	if !strings.Contains(output, "ADD COLUMN details integer") {
+		t.Fatalf("expected migration to add a fresh column with the new type on conversion failure, got:\n%s", output)
+	}
+}
+
+func TestWriteMigration_AltersColumnNullabilityWhenNotNullDiffers(t *testing.T) {
+	current := models.InitDatabase("testdb")
+	currentSchema := models.InitSchema("public")
+	currentTable := models.InitTable("service_instance", "public")
+	currentType := models.InitColumn("rid_service_instance_type", "service_instance", "public")
+	currentType.Type = "text"
+	currentType.NotNull = true
+	currentTable.Columns["rid_service_instance_type"] = currentType
+	currentSchema.Tables = append(currentSchema.Tables, currentTable)
+	current.Schemas = append(current.Schemas, currentSchema)
+
+	model := models.InitDatabase("testdb")
+	modelSchema := models.InitSchema("public")
+	modelTable := models.InitTable("service_instance", "public")
+	modelType := models.InitColumn("rid_service_instance_type", "service_instance", "public")
+	modelType.Type = "text"
+	modelType.NotNull = false
+	modelTable.Columns["rid_service_instance_type"] = modelType
+	modelSchema.Tables = append(modelSchema.Tables, modelTable)
+	model.Schemas = append(model.Schemas, modelSchema)
+
+	var buf bytes.Buffer
+	writer, err := NewMigrationWriter(&writers.WriterOptions{})
+	if err != nil {
+		t.Fatalf("Failed to create writer: %v", err)
+	}
+	writer.writer = &buf
+
+	if err := writer.WriteMigration(model, current); err != nil {
+		t.Fatalf("WriteMigration failed: %v", err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "ALTER COLUMN rid_service_instance_type DROP NOT NULL") {
+		t.Fatalf("expected migration to drop NOT NULL on existing column, got:\n%s", output)
+	}
+}
+
 func TestWriteMigration_UsesStorageTypeForSerialAlterStatements(t *testing.T) {
 	current := models.InitDatabase("testdb")
 	currentSchema := models.InitSchema("public")
@@ -251,6 +334,46 @@ func TestWriteMigration_DoesNotAlterEquivalentNormalizedColumnType(t *testing.T)
 	}
 }
 
+func TestWriteMigration_ConcurrentIndex(t *testing.T) {
+	current := models.InitDatabase("testdb")
+	currentSchema := models.InitSchema("public")
+	current.Schemas = append(current.Schemas, currentSchema)
+
+	model := models.InitDatabase("testdb")
+	modelSchema := models.InitSchema("public")
+
+	table := models.InitTable("articles", "public")
+	titleCol := models.InitColumn("title", "articles", "public")
+	titleCol.Type = "text"
+	table.Columns["title"] = titleCol
+
+	index := &models.Index{
+		Name:       "idx_articles_title",
+		Columns:    []string{"title"},
+		Concurrent: true,
+	}
+	table.Indexes[index.Name] = index
+
+	modelSchema.Tables = append(modelSchema.Tables, table)
+	model.Schemas = append(model.Schemas, modelSchema)
+
+	var buf bytes.Buffer
+	writer, err := NewMigrationWriter(&writers.WriterOptions{})
+	if err != nil {
+		t.Fatalf("Failed to create writer: %v", err)
+	}
+	writer.writer = &buf
+
+	if err := writer.WriteMigration(model, current); err != nil {
+		t.Fatalf("WriteMigration failed: %v", err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "CREATE INDEX CONCURRENTLY IF NOT EXISTS") {
+		t.Fatalf("expected CONCURRENTLY create index statement, got:\n%s", output)
+	}
+}
+
 func TestWriteMigration_GinIndexOnTextUsesTrigramOperatorClass(t *testing.T) {
 	current := models.InitDatabase("testdb")
 	currentSchema := models.InitSchema("public")

pkg/writers/pgsql/templates.go

@@ -89,15 +89,10 @@ type AddColumnData struct {
 	NotNull    bool
 }
 
-// AlterColumnTypeData contains data for alter column type template
-type AlterColumnTypeData struct {
-	SchemaName string
-	TableName  string
-	ColumnName string
-	NewType    string
-	UsingExpr  string
-}
-
+// AlterColumnTypeWithCheckData contains data for the guarded alter column
+// type template, which only alters existing columns whose live type
+// differs from the desired one, and falls back to renaming the old column
+// and adding a fresh one when the in-place conversion is not possible.
 type AlterColumnTypeWithCheckData struct {
 	SchemaName      string
 	TableName       string
@@ -107,8 +102,10 @@ type AlterColumnTypeWithCheckData struct {
 	UsingExpr       string
 }
 
-// AlterColumnDefaultData contains data for alter column default template
-type AlterColumnDefaultData struct {
+// AlterColumnDefaultWithCheckData contains data for the guarded alter
+// column default template, which only alters existing columns whose live
+// default differs from the desired one.
+type AlterColumnDefaultWithCheckData struct {
 	SchemaName   string
 	TableName    string
 	ColumnName   string
@@ -116,6 +113,16 @@ type AlterColumnDefaultData struct {
 	DefaultValue string
 }
 
+// AlterColumnNullabilityWithCheckData contains data for the guarded alter
+// column nullability template, which only alters existing columns whose
+// live NOT NULL state differs from the desired one.
+type AlterColumnNullabilityWithCheckData struct {
+	SchemaName string
+	TableName  string
+	ColumnName string
+	NotNull    bool
+}
+
 // CreatePrimaryKeyData contains data for create primary key template
 type CreatePrimaryKeyData struct {
 	SchemaName     string
@@ -132,6 +139,7 @@ type CreateIndexData struct {
 	IndexType  string
 	Columns    string
 	Unique     bool
+	Concurrent bool
 }
 
 // CreateForeignKeyData contains data for create foreign key template
@@ -302,16 +310,9 @@ func (te *TemplateExecutor) ExecuteAddColumn(data AddColumnData) (string, error)
 	return buf.String(), nil
 }
 
-// ExecuteAlterColumnType executes the alter column type template
-func (te *TemplateExecutor) ExecuteAlterColumnType(data AlterColumnTypeData) (string, error) {
-	var buf bytes.Buffer
-	err := te.templates.ExecuteTemplate(&buf, "alter_column_type.tmpl", data)
-	if err != nil {
-		return "", fmt.Errorf("failed to execute alter_column_type template: %w", err)
-	}
-	return buf.String(), nil
-}
-
+// ExecuteAlterColumnTypeWithCheck executes the guarded alter column type
+// template shared by the full-schema writer and the diff-based migration
+// writer.
 func (te *TemplateExecutor) ExecuteAlterColumnTypeWithCheck(data AlterColumnTypeWithCheckData) (string, error) {
 	var buf bytes.Buffer
 	err := te.templates.ExecuteTemplate(&buf, "alter_column_type_with_check.tmpl", data)
@@ -321,12 +322,25 @@ func (te *TemplateExecutor) ExecuteAlterColumnTypeWithCheck(data AlterColumnType
 	return buf.String(), nil
 }
 
-// ExecuteAlterColumnDefault executes the alter column default template
-func (te *TemplateExecutor) ExecuteAlterColumnDefault(data AlterColumnDefaultData) (string, error) {
+// ExecuteAlterColumnDefaultWithCheck executes the guarded alter column
+// default template shared by the full-schema writer and the diff-based
+// migration writer.
+func (te *TemplateExecutor) ExecuteAlterColumnDefaultWithCheck(data AlterColumnDefaultWithCheckData) (string, error) {
 	var buf bytes.Buffer
-	err := te.templates.ExecuteTemplate(&buf, "alter_column_default.tmpl", data)
+	err := te.templates.ExecuteTemplate(&buf, "alter_column_default_with_check.tmpl", data)
 	if err != nil {
-		return "", fmt.Errorf("failed to execute alter_column_default template: %w", err)
+		return "", fmt.Errorf("failed to execute alter_column_default_with_check template: %w", err)
+	}
+	return buf.String(), nil
+}
+
+// ExecuteAlterColumnNullabilityWithCheck executes the guarded alter column
+// nullability template.
+func (te *TemplateExecutor) ExecuteAlterColumnNullabilityWithCheck(data AlterColumnNullabilityWithCheckData) (string, error) {
+	var buf bytes.Buffer
+	err := te.templates.ExecuteTemplate(&buf, "alter_column_nullability_with_check.tmpl", data)
+	if err != nil {
+		return "", fmt.Errorf("failed to execute alter_column_nullability_with_check template: %w", err)
 	}
 	return buf.String(), nil
 }
@@ -517,7 +531,7 @@ func BuildCreateTableData(schemaName string, table *models.Table) CreateTableDat
 		}
 		if col.Default != nil {
 			if value, ok := col.Default.(string); ok {
-				colData.Default = writers.QuoteDefaultValue(value, col.Type)
+				colData.Default = writers.QuoteDefaultValue(stripBackticks(value), col.Type)
 			} else {
 				colData.Default = fmt.Sprintf("%v", col.Default)
 			}
@@ -545,7 +559,7 @@ func BuildAuditFunctionData(
 
 	// Build list of audited columns
 	auditedColumns := make([]*models.Column, 0)
-	for _, col := range table.Columns {
+	for _, col := range sortColumns(table.Columns) {
 		if col.Name == pk.Name {
 			continue
 		}

pkg/writers/pgsql/templates/alter_column_default.tmpl

@@ -1,7 +0,0 @@
-{{- if .SetDefault -}}
-ALTER TABLE {{qual_table .SchemaName .TableName}}
-  ALTER COLUMN {{quote_ident .ColumnName}} SET DEFAULT {{.DefaultValue}};
-{{- else -}}
-ALTER TABLE {{qual_table .SchemaName .TableName}}
-  ALTER COLUMN {{quote_ident .ColumnName}} DROP DEFAULT;
-{{- end -}}

pkg/writers/pgsql/templates/alter_column_default_with_check.tmpl

@@ -0,0 +1,29 @@
+DO $$
+DECLARE
+  current_default text;
+BEGIN
+  SELECT pg_catalog.pg_get_expr(d.adbin, d.adrelid)
+    INTO current_default
+  FROM pg_attribute a
+  JOIN pg_class t ON t.oid = a.attrelid
+  JOIN pg_namespace n ON n.oid = t.relnamespace
+  LEFT JOIN pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+  WHERE n.nspname = '{{.SchemaName}}'
+    AND t.relname = '{{.TableName}}'
+    AND a.attname = '{{.ColumnName}}'
+    AND a.attnum > 0
+    AND NOT a.attisdropped;
+
+{{- if .SetDefault }}
+  IF current_default IS DISTINCT FROM {{quote .DefaultValue}} THEN
+    ALTER TABLE {{qual_table .SchemaName .TableName}}
+      ALTER COLUMN {{quote_ident .ColumnName}} SET DEFAULT {{.DefaultValue}};
+  END IF;
+{{- else }}
+  IF current_default IS NOT NULL THEN
+    ALTER TABLE {{qual_table .SchemaName .TableName}}
+      ALTER COLUMN {{quote_ident .ColumnName}} DROP DEFAULT;
+  END IF;
+{{- end }}
+END;
+$$;

pkg/writers/pgsql/templates/alter_column_nullability_with_check.tmpl

@@ -0,0 +1,26 @@
+DO $$
+DECLARE
+  current_not_null boolean;
+BEGIN
+  SELECT a.attnotnull
+    INTO current_not_null
+  FROM pg_attribute a
+  JOIN pg_class t ON t.oid = a.attrelid
+  JOIN pg_namespace n ON n.oid = t.relnamespace
+  WHERE n.nspname = '{{.SchemaName}}'
+    AND t.relname = '{{.TableName}}'
+    AND a.attname = '{{.ColumnName}}'
+    AND a.attnum > 0
+    AND NOT a.attisdropped;
+
+  IF current_not_null IS NOT NULL AND current_not_null IS DISTINCT FROM {{.NotNull}} THEN
+{{- if .NotNull }}
+    ALTER TABLE {{qual_table .SchemaName .TableName}}
+      ALTER COLUMN {{quote_ident .ColumnName}} SET NOT NULL;
+{{- else }}
+    ALTER TABLE {{qual_table .SchemaName .TableName}}
+      ALTER COLUMN {{quote_ident .ColumnName}} DROP NOT NULL;
+{{- end }}
+  END IF;
+END;
+$$;

pkg/writers/pgsql/templates/alter_column_type.tmpl

@@ -1,2 +0,0 @@
-ALTER TABLE {{qual_table .SchemaName .TableName}}
-  ALTER COLUMN {{quote_ident .ColumnName}} TYPE {{.NewType}}{{if .UsingExpr}} USING {{.UsingExpr}}{{end}};

pkg/writers/pgsql/templates/alter_column_type_with_check.tmpl

@@ -1,6 +1,7 @@
 DO $$
 DECLARE
   current_type text;
+  renamed_column text;
 BEGIN
   SELECT pg_catalog.format_type(a.atttypid, a.atttypmod)
     INTO current_type
@@ -15,8 +16,15 @@ BEGIN
 
   IF current_type IS NOT NULL
      AND current_type <> ALL(ARRAY[{{.EquivalentTypes}}]) THEN
-    ALTER TABLE {{qual_table .SchemaName .TableName}}
-      ALTER COLUMN {{quote_ident .ColumnName}} TYPE {{.NewType}}{{if .UsingExpr}} USING {{.UsingExpr}}{{end}};
+    BEGIN
+      ALTER TABLE {{qual_table .SchemaName .TableName}}
+        ALTER COLUMN {{quote_ident .ColumnName}} TYPE {{.NewType}}{{if .UsingExpr}} USING {{.UsingExpr}}{{end}};
+    EXCEPTION WHEN OTHERS THEN
+      renamed_column := '{{.ColumnName}}_' || trim(both '_' from regexp_replace(lower(current_type), '[^a-z0-9]+', '_', 'g'));
+      EXECUTE format('ALTER TABLE {{qual_table .SchemaName .TableName}} RENAME COLUMN {{quote_ident .ColumnName}} TO %I', renamed_column);
+      ALTER TABLE {{qual_table .SchemaName .TableName}}
+        ADD COLUMN {{quote_ident .ColumnName}} {{.NewType}};
+    END;
   END IF;
 END;
 $$;

pkg/writers/pgsql/templates/create_index.tmpl

@@ -1,2 +1,2 @@
-CREATE {{if .Unique}}UNIQUE {{end}}INDEX IF NOT EXISTS {{quote_ident .IndexName}}
+CREATE {{if .Unique}}UNIQUE {{end}}INDEX {{if .Concurrent}}CONCURRENTLY {{end}}IF NOT EXISTS {{quote_ident .IndexName}}
   ON {{qual_table .SchemaName .TableName}} USING {{.IndexType}} ({{.Columns}});

pkg/writers/pgsql/writer.go

@@ -199,7 +199,7 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 	for _, table := range schema.Tables {
 		// First check for explicit PrimaryKeyConstraint
 		var pkConstraint *models.Constraint
-		for _, constraint := range table.Constraints {
+		for _, constraint := range sortConstraints(table.Constraints) {
 			if constraint.Type == models.PrimaryKeyConstraint {
 				pkConstraint = constraint
 				break
@@ -255,7 +255,7 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 
 	// Phase 5: Indexes
 	for _, table := range schema.Tables {
-		for _, index := range table.Indexes {
+		for _, index := range sortIndexes(table.Indexes) {
 			// Skip primary key indexes
 			if strings.HasSuffix(index.Name, "_pkey") {
 				continue
@@ -298,7 +298,7 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 
 	// Phase 5.5: Unique constraints
 	for _, table := range schema.Tables {
-		for _, constraint := range table.Constraints {
+		for _, constraint := range sortConstraints(table.Constraints) {
 			if constraint.Type != models.UniqueConstraint {
 				continue
 			}
@@ -321,7 +321,7 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 
 	// Phase 5.7: Check constraints
 	for _, table := range schema.Tables {
-		for _, constraint := range table.Constraints {
+		for _, constraint := range sortConstraints(table.Constraints) {
 			if constraint.Type != models.CheckConstraint {
 				continue
 			}
@@ -344,7 +344,7 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 
 	// Phase 6: Foreign keys
 	for _, table := range schema.Tables {
-		for _, constraint := range table.Constraints {
+		for _, constraint := range sortConstraints(table.Constraints) {
 			if constraint.Type != models.ForeignKeyConstraint {
 				continue
 			}
@@ -394,7 +394,7 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 			statements = append(statements, stmt)
 		}
 
-		for _, column := range table.Columns {
+		for _, column := range sortColumns(table.Columns) {
 			if column.Comment != "" {
 				stmt := fmt.Sprintf("COMMENT ON COLUMN %s.%s IS '%s'",
 					w.qualTable(schema.SQLName(), table.SQLName()), column.SQLName(), escapeQuote(column.Comment))
@@ -475,6 +475,75 @@ func (w *Writer) GenerateAlterColumnTypeStatements(schema *models.Schema) ([]str
 	return statements, nil
 }
 
+// GenerateAlterColumnDefaultStatements generates guarded ALTER TABLE
+// statements to bring existing columns' DEFAULT clause in line with the
+// model, safe to run against a database that already has the columns.
+func (w *Writer) GenerateAlterColumnDefaultStatements(schema *models.Schema) ([]string, error) {
+	statements := []string{}
+
+	statements = append(statements, fmt.Sprintf("-- Alter column defaults for schema: %s", schema.Name))
+
+	for _, table := range schema.Tables {
+		columns := getSortedColumns(table.Columns)
+		for _, col := range columns {
+			setDefault, defaultVal := formatColumnDefaultSQL(col)
+			stmt, err := w.executor.ExecuteAlterColumnDefaultWithCheck(AlterColumnDefaultWithCheckData{
+				SchemaName:   schema.Name,
+				TableName:    table.Name,
+				ColumnName:   col.Name,
+				SetDefault:   setDefault,
+				DefaultValue: defaultVal,
+			})
+			if err != nil {
+				return nil, fmt.Errorf("failed to generate alter column default for %s.%s.%s: %w", schema.Name, table.Name, col.Name, err)
+			}
+			statements = append(statements, stmt)
+		}
+	}
+
+	return statements, nil
+}
+
+// formatColumnDefaultSQL renders a column's model-level default into the
+// SQL literal/expression used by ALTER COLUMN ... SET DEFAULT, shared by
+// the full-schema writer and the diff-based migration writer.
+func formatColumnDefaultSQL(col *models.Column) (setDefault bool, defaultVal string) {
+	if col.Default == nil {
+		return false, ""
+	}
+	if value, ok := col.Default.(string); ok {
+		return true, writers.QuoteDefaultValue(stripBackticks(value), col.Type)
+	}
+	return true, fmt.Sprintf("%v", col.Default)
+}
+
+// GenerateAlterColumnNullabilityStatements generates guarded ALTER TABLE
+// statements to bring existing columns' NOT NULL state in line with the
+// model, safe to run against a database that already has the columns.
+func (w *Writer) GenerateAlterColumnNullabilityStatements(schema *models.Schema) ([]string, error) {
+	statements := []string{}
+
+	statements = append(statements, fmt.Sprintf("-- Alter column nullability for schema: %s", schema.Name))
+
+	for _, table := range schema.Tables {
+		columns := getSortedColumns(table.Columns)
+		for _, col := range columns {
+			stmt, err := w.executor.ExecuteAlterColumnNullabilityWithCheck(AlterColumnNullabilityWithCheckData{
+				SchemaName: schema.Name,
+				TableName:  table.Name,
+				ColumnName: col.Name,
+				NotNull:    col.NotNull,
+			})
+			if err != nil {
+				return nil, fmt.Errorf("failed to generate alter column nullability for %s.%s.%s: %w", schema.Name, table.Name, col.Name, err)
+			}
+			statements = append(statements, stmt)
+		}
+	}
+
+	return statements, nil
+}
+
 // GenerateAddColumnsForDatabase generates ALTER TABLE ADD COLUMN statements for the entire database
 func (w *Writer) GenerateAddColumnsForDatabase(db *models.Database) ([]string, error) {
 	statements := []string{}
@@ -641,6 +710,14 @@ func (w *Writer) WriteSchema(schema *models.Schema) error {
 		return err
 	}
 
+	if err := w.writeAlterColumnDefaults(schema); err != nil {
+		return err
+	}
+
+	if err := w.writeAlterColumnNullability(schema); err != nil {
+		return err
+	}
+
 	// Phase 4: Create primary keys (priority 160)
 	if err := w.writePrimaryKeys(schema); err != nil {
 		return err
@@ -859,6 +936,36 @@ func (w *Writer) writeAlterColumnTypes(schema *models.Schema) error {
 	return nil
 }
 
+func (w *Writer) writeAlterColumnDefaults(schema *models.Schema) error {
+	fmt.Fprintf(w.writer, "-- Alter column defaults for schema: %s\n", schema.Name)
+
+	statements, err := w.GenerateAlterColumnDefaultStatements(schema)
+	if err != nil {
+		return err
+	}
+	for _, stmt := range statements[1:] {
+		fmt.Fprint(w.writer, stmt)
+		fmt.Fprint(w.writer, "\n")
+	}
+
+	return nil
+}
+
+func (w *Writer) writeAlterColumnNullability(schema *models.Schema) error {
+	fmt.Fprintf(w.writer, "-- Alter column nullability for schema: %s\n", schema.Name)
+
+	statements, err := w.GenerateAlterColumnNullabilityStatements(schema)
+	if err != nil {
+		return err
+	}
+	for _, stmt := range statements[1:] {
+		fmt.Fprint(w.writer, stmt)
+		fmt.Fprint(w.writer, "\n")
+	}
+
+	return nil
+}
+
 // writePrimaryKeys generates ALTER TABLE statements for primary keys
 func (w *Writer) writePrimaryKeys(schema *models.Schema) error {
 	fmt.Fprintf(w.writer, "-- Primary keys for schema: %s\n", schema.Name)
@@ -866,10 +973,9 @@ func (w *Writer) writePrimaryKeys(schema *models.Schema) error {
 	for _, table := range schema.Tables {
 		// Find primary key constraint
 		var pkConstraint *models.Constraint
-		for name, constraint := range table.Constraints {
+		for _, constraint := range sortConstraints(table.Constraints) {
 			if constraint.Type == models.PrimaryKeyConstraint {
 				pkConstraint = constraint
-				_ = name // Use the name variable
 				break
 			}
 		}
@@ -991,8 +1097,13 @@ func (w *Writer) writeIndexes(schema *models.Schema) error {
 				whereClause = fmt.Sprintf(" WHERE %s", index.Where)
 			}
 
-			fmt.Fprintf(w.writer, "CREATE %sINDEX IF NOT EXISTS %s\n",
-				unique, indexName)
+			concurrently := ""
+			if index.Concurrent {
+				concurrently = "CONCURRENTLY "
+			}
+
+			fmt.Fprintf(w.writer, "CREATE %sINDEX %sIF NOT EXISTS %s\n",
+				unique, concurrently, indexName)
 			fmt.Fprintf(w.writer, "  ON %s USING %s (%s)%s;\n\n",
 				w.qualTable(schema.SQLName(), table.SQLName()), indexType, strings.Join(columnExprs, ", "), whereClause)
 		}
@@ -1475,6 +1586,51 @@ func resolveIndexColumn(table *models.Table, colName string) (*models.Column, bo
 	return nil, false
 }
 
+// sortColumns returns columns sorted by Sequence then Name for deterministic output.
+func sortColumns(columns map[string]*models.Column) []*models.Column {
+	result := make([]*models.Column, 0, len(columns))
+	for _, col := range columns {
+		result = append(result, col)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortConstraints returns constraints sorted by Sequence then Name for deterministic output.
+func sortConstraints(constraints map[string]*models.Constraint) []*models.Constraint {
+	result := make([]*models.Constraint, 0, len(constraints))
+	for _, c := range constraints {
+		result = append(result, c)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortIndexes returns indexes sorted by Sequence then Name for deterministic output.
+func sortIndexes(indexes map[string]*models.Index) []*models.Index {
+	result := make([]*models.Index, 0, len(indexes))
+	for _, idx := range indexes {
+		result = append(result, idx)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
 // formatStringList formats a list of strings as a SQL-safe comma-separated quoted list
 func formatStringList(items []string) string {
 	quoted := make([]string, len(items))

pkg/writers/pgsql/writer_test.go

@@ -87,6 +87,41 @@ func TestWriteDatabase(t *testing.T) {
 	}
 }
 
+func TestWriteDatabase_ConcurrentIndex(t *testing.T) {
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("public")
+
+	table := models.InitTable("users", "public")
+
+	emailCol := models.InitColumn("email", "users", "public")
+	emailCol.Type = "text"
+	table.Columns["email"] = emailCol
+
+	concurrentIndex := &models.Index{
+		Name:       "idx_users_email",
+		Columns:    []string{"email"},
+		Concurrent: true,
+	}
+	table.Indexes["idx_users_email"] = concurrentIndex
+
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+
+	var buf bytes.Buffer
+	writer := NewWriter(&writers.WriterOptions{})
+	writer.writer = &buf
+
+	if err := writer.WriteDatabase(db); err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	output := buf.String()
+
+	if !strings.Contains(output, "CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_users_email") {
+		t.Errorf("Output missing CONCURRENTLY index creation:\n%s", output)
+	}
+}
+
 func TestWriteDatabase_GinIndexOnTextArrayDoesNotUseTrigramOperatorClass(t *testing.T) {
 	db := models.InitDatabase("testdb")
 	schema := models.InitSchema("public")
@@ -1106,6 +1141,144 @@ func TestWriteSchema_EmitsGuardedAlterColumnTypeStatements(t *testing.T) {
 	}
 }
 
+func TestWriteSchema_EmitsGuardedAlterColumnDefaultStatements(t *testing.T) {
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("public")
+
+	table := models.InitTable("agent_skills", "public")
+
+	statusCol := models.InitColumn("status", "agent_skills", "public")
+	statusCol.Type = "text"
+	statusCol.Default = "active"
+	table.Columns["status"] = statusCol
+
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+
+	var buf bytes.Buffer
+	writer := NewWriter(&writers.WriterOptions{})
+	writer.writer = &buf
+
+	if err := writer.WriteDatabase(db); err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "-- Alter column defaults for schema: public") {
+		t.Fatalf("expected alter column default section, got:\n%s", output)
+	}
+	if !strings.Contains(output, "pg_get_expr(d.adbin, d.adrelid)") {
+		t.Fatalf("expected guarded live-default check, got:\n%s", output)
+	}
+	if !strings.Contains(output, "ALTER COLUMN status SET DEFAULT 'active'") {
+		t.Fatalf("expected guarded SET DEFAULT for status column, got:\n%s", output)
+	}
+}
+
+func TestWriteSchema_AlterColumnDefaultStripsBackticksFromFunctionExpression(t *testing.T) {
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("public")
+
+	table := models.InitTable("agent_skills", "public")
+
+	updatedAtCol := models.InitColumn("updatedat", "agent_skills", "public")
+	updatedAtCol.Type = "timestamp"
+	updatedAtCol.Default = "`now()`"
+	table.Columns["updatedat"] = updatedAtCol
+
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+
+	var buf bytes.Buffer
+	writer := NewWriter(&writers.WriterOptions{})
+	writer.writer = &buf
+
+	if err := writer.WriteDatabase(db); err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	output := buf.String()
+	if strings.Contains(output, "`") {
+		t.Fatalf("expected no backticks in generated SQL, got:\n%s", output)
+	}
+	if !strings.Contains(output, "ALTER COLUMN updatedat SET DEFAULT now()") {
+		t.Fatalf("expected guarded SET DEFAULT now() without backticks, got:\n%s", output)
+	}
+}
+
+func TestWriteSchema_GuardedAlterColumnTypeFallsBackOnConversionFailure(t *testing.T) {
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("public")
+
+	table := models.InitTable("agent_skills", "public")
+
+	nameCol := models.InitColumn("name", "agent_skills", "public")
+	nameCol.Type = "integer"
+	table.Columns["name"] = nameCol
+
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+
+	var buf bytes.Buffer
+	writer := NewWriter(&writers.WriterOptions{})
+	writer.writer = &buf
+
+	if err := writer.WriteDatabase(db); err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "EXCEPTION WHEN OTHERS THEN") {
+		t.Fatalf("expected guarded alter to fall back on conversion failure, got:\n%s", output)
+	}
+	if !strings.Contains(output, "renamed_column := 'name_' || trim(both '_' from regexp_replace(lower(current_type)") {
+		t.Fatalf("expected fallback to derive a renamed column name from the live type, got:\n%s", output)
+	}
+	if !strings.Contains(output, "RENAME COLUMN name TO %I") {
+		t.Fatalf("expected fallback to rename the existing column, got:\n%s", output)
+	}
+	if !strings.Contains(output, "ADD COLUMN name integer") {
+		t.Fatalf("expected fallback to add a fresh column with the new type, got:\n%s", output)
+	}
+}
+
+func TestWriteSchema_EmitsGuardedAlterColumnNullabilityStatements(t *testing.T) {
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("origin")
+
+	table := models.InitTable("service_instance", "origin")
+
+	typeCol := models.InitColumn("rid_service_instance_type", "service_instance", "origin")
+	typeCol.Type = "text"
+	typeCol.NotNull = false
+	table.Columns["rid_service_instance_type"] = typeCol
+
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+
+	var buf bytes.Buffer
+	writer := NewWriter(&writers.WriterOptions{})
+	writer.writer = &buf
+
+	if err := writer.WriteDatabase(db); err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "-- Alter column nullability for schema: origin") {
+		t.Fatalf("expected alter column nullability section, got:\n%s", output)
+	}
+	if !strings.Contains(output, "a.attnotnull") {
+		t.Fatalf("expected guarded live-nullability check, got:\n%s", output)
+	}
+	if !strings.Contains(output, "current_not_null IS DISTINCT FROM false") {
+		t.Fatalf("expected guard comparing live nullability against desired value, got:\n%s", output)
+	}
+	if !strings.Contains(output, "ALTER COLUMN rid_service_instance_type DROP NOT NULL") {
+		t.Fatalf("expected guarded DROP NOT NULL for nullable column, got:\n%s", output)
+	}
+}
+
 func TestWriteSchema_UsesStorageTypeForSerialAlterStatements(t *testing.T) {
 	db := models.InitDatabase("testdb")
 	schema := models.InitSchema("public")

pkg/writers/prisma/writer.go

@@ -549,14 +549,14 @@ func (w *Writer) generateBlockAttributes(table *models.Table) string {
 	}
 
 	// @@unique for multi-column unique constraints
-	for _, constraint := range table.Constraints {
+	for _, constraint := range sortConstraints(table.Constraints) {
 		if constraint.Type == models.UniqueConstraint && len(constraint.Columns) > 1 {
 			fmt.Fprintf(&sb, "  @@unique([%s])\n", strings.Join(constraint.Columns, ", "))
 		}
 	}
 
 	// @@index for indexes
-	for _, index := range table.Indexes {
+	for _, index := range sortIndexes(table.Indexes) {
 		if !index.Unique { // Unique indexes are handled by @@unique
 			fmt.Fprintf(&sb, "  @@index([%s])\n", strings.Join(index.Columns, ", "))
 		}
@@ -564,3 +564,33 @@ func (w *Writer) generateBlockAttributes(table *models.Table) string {
 
 	return sb.String()
 }
+
+// sortConstraints returns constraints sorted by Sequence then Name for deterministic output.
+func sortConstraints(constraints map[string]*models.Constraint) []*models.Constraint {
+	result := make([]*models.Constraint, 0, len(constraints))
+	for _, c := range constraints {
+		result = append(result, c)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortIndexes returns indexes sorted by Sequence then Name for deterministic output.
+func sortIndexes(indexes map[string]*models.Index) []*models.Index {
+	result := make([]*models.Index, 0, len(indexes))
+	for _, idx := range indexes {
+		result = append(result, idx)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}

pkg/writers/sqlexec/writer.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/jackc/pgx/v5"
 
+	"git.warky.dev/wdevs/relspecgo/pkg/assetloader"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/pgsql"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
@@ -138,7 +139,28 @@ func (w *Writer) executeScripts(ctx context.Context, conn *pgx.Conn, scripts []*
 			script.Name, script.Priority, script.Sequence)
 
 		// Execute the SQL script
-		_, err := conn.Exec(ctx, script.SQL)
+		sql, err := processEmbedDirectives(script)
+		if err != nil {
+			if ignoreErrors {
+				fmt.Printf("⚠ Error preparing %s: %v (continuing due to --ignore-errors)\n", script.Name, err)
+				failedScripts = append(failedScripts, struct {
+					name     string
+					priority int
+					sequence uint
+					err      error
+				}{
+					name:     script.Name,
+					priority: script.Priority,
+					sequence: script.Sequence,
+					err:      err,
+				})
+				continue
+			}
+			return fmt.Errorf("script %s (Priority=%d, Sequence=%d): %w",
+				script.Name, script.Priority, script.Sequence, err)
+		}
+
+		_, err = conn.Exec(ctx, sql)
 		if err != nil {
 			if ignoreErrors {
 				fmt.Printf("⚠ Error executing %s: %v (continuing due to --ignore-errors)\n", script.Name, err)
@@ -179,3 +201,11 @@ func (w *Writer) executeScripts(ctx context.Context, conn *pgx.Conn, scripts []*
 
 	return nil
 }
+
+func processEmbedDirectives(script *models.Script) (string, error) {
+	sqlPath, _ := script.Metadata[assetloader.ScriptSourcePathMetadataKey].(string)
+	if sqlPath == "" {
+		return script.SQL, nil
+	}
+	return assetloader.ProcessEmbedDirectives(sqlPath, script.SQL)
+}

pkg/writers/sqlexec/writer_test.go

@@ -1,8 +1,12 @@
 package sqlexec
 
 import (
+	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 
+	"git.warky.dev/wdevs/relspecgo/pkg/assetloader"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
@@ -216,3 +220,36 @@ func TestWriter_WriteSchema_EmptyScripts(t *testing.T) {
 //     // Verify results
 //     // Cleanup
 // }
+
+func TestProcessEmbedDirectives_UsesScriptSourcePath(t *testing.T) {
+	dir := t.TempDir()
+	sqlPath := filepath.Join(dir, "1_001_seed.sql")
+	if err := os.WriteFile(filepath.Join(dir, "body.txt"), []byte("writer text"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	script := models.InitScript("seed")
+	script.SQL = "-- @embed: path=body.txt var=:body mode=text\nSELECT :body;"
+	script.Metadata[assetloader.ScriptSourcePathMetadataKey] = sqlPath
+
+	got, err := processEmbedDirectives(script)
+	if err != nil {
+		t.Fatalf("processEmbedDirectives failed: %v", err)
+	}
+	if !strings.Contains(got, "SELECT 'writer text';") {
+		t.Fatalf("script embed directive was not processed:\n%s", got)
+	}
+}
+
+func TestProcessEmbedDirectives_NoSourcePathLeavesSQLUnchanged(t *testing.T) {
+	script := models.InitScript("seed")
+	script.SQL = "-- @embed: path=missing.txt var=:body mode=text\nSELECT :body;"
+
+	got, err := processEmbedDirectives(script)
+	if err != nil {
+		t.Fatalf("processEmbedDirectives failed: %v", err)
+	}
+	if got != script.SQL {
+		t.Fatalf("expected unchanged SQL without source path, got:\n%s", got)
+	}
+}

pkg/writers/sqlite/README.md

@@ -4,13 +4,14 @@ SQLite DDL (Data Definition Language) writer for RelSpec. Converts database sche
 
 ## Features
 
-- **Automatic Schema Flattening** - SQLite doesn't support PostgreSQL-style schemas, so table names are automatically flattened (e.g., `public.users` → `public_users`)
+- **Schema Flattening** - SQLite doesn't support PostgreSQL-style schemas. Non-default schema names are flattened into table name prefixes (e.g., `auth.sessions` → `auth_sessions`); the default schema (`public`/`main`) is left as bare table names (e.g., `public.users` → `users`)
 - **Type Mapping** - Converts PostgreSQL data types to SQLite type affinities (TEXT, INTEGER, REAL, NUMERIC, BLOB)
 - **Auto-Increment Detection** - Automatically converts SERIAL types and auto-increment columns to `INTEGER PRIMARY KEY AUTOINCREMENT`
 - **Function Translation** - Converts PostgreSQL functions to SQLite equivalents (e.g., `now()` → `CURRENT_TIMESTAMP`)
 - **Boolean Handling** - Maps boolean values to INTEGER (true=1, false=0)
-- **Constraint Generation** - Creates indexes, unique constraints, and documents foreign keys
+- **Constraint Generation** - Creates indexes, unique constraints, and inline `FOREIGN KEY` clauses in `CREATE TABLE`
 - **Identifier Quoting** - Properly quotes identifiers using double quotes
+- **Direct Execution** - Can execute the generated DDL directly against a `.db` file instead of writing a `.sql` script (see below)
 
 ## Usage
 
@@ -30,15 +31,26 @@ relspec convert --from dbml --from-path schema.dbml \
 
 ### Multi-Schema Databases
 
-SQLite doesn't support schemas, so multi-schema databases are automatically flattened:
+SQLite doesn't support schemas, so multi-schema databases are automatically flattened. The default schema (`public`/`main`) keeps bare table names; other schemas are prefixed to avoid collisions:
 
 ```bash
 # Input has auth.users and public.posts
-# Output will have auth_users and public_posts
+# Output will have auth_users and posts
 relspec convert --from json --from-path multi_schema.json \
                 --to sqlite --to-path flattened.sql
 ```
 
+### Direct Execution Against a Database File
+
+`relspec merge` can execute the generated DDL directly against a SQLite file instead of writing a `.sql` script, by passing the file path as `--output-conn`:
+
+```bash
+relspec merge --source dbml --source-path schema.dbml \
+              --output sqlite --output-conn ./app.db
+```
+
+Passing `--output-conn` opens `./app.db` and applies the schema directly; passing `--output-path` instead (or omitting `--output-conn`) writes a `.sql` script as before.
+
 ## Type Mapping
 
 | PostgreSQL Type | SQLite Affinity | Examples |
@@ -87,17 +99,17 @@ CREATE TABLE "users" (
 
 ## Foreign Keys
 
-Foreign keys are generated as commented-out ALTER TABLE statements for reference:
+SQLite has no `ALTER TABLE ADD CONSTRAINT`, so foreign keys are generated as inline `FOREIGN KEY` clauses inside `CREATE TABLE`, exactly as SQLite requires:
 
 ```sql
--- Foreign key: fk_posts_user_id
--- ALTER TABLE "posts" ADD CONSTRAINT "posts_fk_posts_user_id"
---   FOREIGN KEY ("user_id")
---   REFERENCES "users" ("id");
--- Note: Foreign keys should be defined in CREATE TABLE for better SQLite compatibility
+CREATE TABLE "posts" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+    "user_id" INTEGER NOT NULL,
+    FOREIGN KEY ("user_id") REFERENCES "users" ("id") ON DELETE CASCADE
+);
 ```
 
-For production use, define foreign keys directly in the CREATE TABLE statement or execute the ALTER TABLE commands after creating all tables.
+`PRAGMA foreign_keys = ON;` is emitted at the top of the output (and executed first in direct-execution mode) so these constraints are actually enforced.
 
 ## Constraints
 
@@ -112,11 +124,10 @@ Generated SQL follows this order:
 
 1. Header comments
 2. `PRAGMA foreign_keys = ON;`
-3. CREATE TABLE statements (sorted by schema, then table)
+3. CREATE TABLE statements (sorted by schema, then table), with primary keys and foreign keys defined inline
 4. CREATE INDEX statements
 5. CREATE UNIQUE INDEX statements (for unique constraints)
 6. Check constraint comments
-7. Foreign key comments
 
 ## Example
 
@@ -145,7 +156,7 @@ CREATE TABLE public.posts (
 -- SQLite Database Schema
 -- Database: mydb
 -- Generated by RelSpec
--- Note: Schema names have been flattened (e.g., public.users -> public_users)
+-- Note: SQLite has no schema concept; non-default schema names are flattened into table name prefixes (e.g., auth.sessions -> auth_sessions)
 
 -- Enable foreign key constraints
 PRAGMA foreign_keys = ON;
@@ -160,22 +171,17 @@ CREATE TABLE "auth_users" (
 
 CREATE UNIQUE INDEX "auth_users_users_username_key" ON "auth_users" ("username");
 
--- Schema: public (flattened into table names)
-
-CREATE TABLE "public_posts" (
+CREATE TABLE "posts" (
     "id" INTEGER PRIMARY KEY AUTOINCREMENT,
     "user_id" INTEGER NOT NULL,
     "title" TEXT NOT NULL,
-    "published" INTEGER DEFAULT 0
+    "published" INTEGER DEFAULT 0,
+    FOREIGN KEY ("user_id") REFERENCES "auth_users" ("id")
 );
-
--- Foreign key: posts_user_id_fkey
--- ALTER TABLE "public_posts" ADD CONSTRAINT "public_posts_posts_user_id_fkey"
---   FOREIGN KEY ("user_id")
---   REFERENCES "auth_users" ("id");
--- Note: Foreign keys should be defined in CREATE TABLE for better SQLite compatibility
 ```
 
+Note that `public.posts` becomes bare `posts` (the default schema isn't prefixed), while `auth.users` becomes `auth_users` (a non-default schema is), and the foreign key to `auth_users` is defined inline rather than as a separate statement.
+
 ## Programmatic Usage
 
 ```go
@@ -208,8 +214,9 @@ func main() {
 
 ## Notes
 
-- Schema flattening is **always enabled** for SQLite output (cannot be disabled)
+- Schema flattening is **always enabled** for SQLite output (cannot be disabled); the default schema (`public`/`main`) produces bare table names, other schemas are prefixed
 - Constraint and index names are prefixed with the flattened table name to avoid collisions
 - Generated SQL is compatible with SQLite 3.x
-- Foreign key constraints require `PRAGMA foreign_keys = ON;` to be enforced
+- Foreign key constraints require `PRAGMA foreign_keys = ON;` to be enforced, which is emitted (and, in direct-execution mode, run) before any `CREATE TABLE`
+- Setting `Metadata["connection_string"]` to a `.db` file path (or passing `--output-conn` to `relspec merge`) executes the DDL directly against that file instead of writing a `.sql` script
 - For complex schemas, review and test the generated SQL before use in production

pkg/writers/sqlite/templates.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"embed"
 	"fmt"
+	"sort"
 	"text/template"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
@@ -39,10 +40,22 @@ func NewTemplateExecutor(opts *writers.WriterOptions) (*TemplateExecutor, error)
 
 // TableTemplateData contains data for table template
 type TableTemplateData struct {
-	Schema     string
-	Name       string
-	Columns    []*models.Column
-	PrimaryKey *models.Constraint
+	Schema      string
+	Name        string
+	Columns     []*models.Column
+	PrimaryKey  *models.Constraint
+	ForeignKeys []ForeignKeyTemplateData
+}
+
+// ForeignKeyTemplateData contains data for an inline FOREIGN KEY clause
+type ForeignKeyTemplateData struct {
+	Name           string
+	Columns        []string
+	ForeignSchema  string
+	ForeignTable   string
+	ForeignColumns []string
+	OnDelete       string
+	OnUpdate       string
 }
 
 // IndexTemplateData contains data for index template
@@ -119,29 +132,15 @@ func (te *TemplateExecutor) ExecuteCreateCheckConstraint(data ConstraintTemplate
 	return buf.String(), nil
 }
 
-// ExecuteCreateForeignKey executes the create foreign key template
-func (te *TemplateExecutor) ExecuteCreateForeignKey(data ConstraintTemplateData) (string, error) {
-	var buf bytes.Buffer
-	err := te.templates.ExecuteTemplate(&buf, "create_foreign_key.tmpl", data)
-	if err != nil {
-		return "", fmt.Errorf("failed to execute create_foreign_key template: %w", err)
-	}
-	return buf.String(), nil
-}
-
 // Helper functions to build template data from models
 
 // BuildTableTemplateData builds TableTemplateData from a models.Table
 func BuildTableTemplateData(schema string, table *models.Table) TableTemplateData {
-	// Get sorted columns
-	columns := make([]*models.Column, 0, len(table.Columns))
-	for _, col := range table.Columns {
-		columns = append(columns, col)
-	}
+	columns := sortColumns(table.Columns)
 
 	// Find primary key constraint
 	var pk *models.Constraint
-	for _, constraint := range table.Constraints {
+	for _, constraint := range sortConstraints(table.Constraints) {
 		if constraint.Type == models.PrimaryKeyConstraint {
 			pk = constraint
 			break
@@ -151,7 +150,7 @@ func BuildTableTemplateData(schema string, table *models.Table) TableTemplateDat
 	// If no explicit primary key constraint, build one from columns with IsPrimaryKey=true
 	if pk == nil {
 		pkCols := []string{}
-		for _, col := range table.Columns {
+		for _, col := range columns {
 			if col.IsPrimaryKey {
 				pkCols = append(pkCols, col.Name)
 			}
@@ -165,10 +164,79 @@ func BuildTableTemplateData(schema string, table *models.Table) TableTemplateDat
 		}
 	}
 
+	// Collect foreign keys for inline FOREIGN KEY clauses
+	var fks []ForeignKeyTemplateData
+	for _, constraint := range sortConstraints(table.Constraints) {
+		if constraint.Type != models.ForeignKeyConstraint {
+			continue
+		}
+
+		refSchema := tableSchemaName(constraint.ReferencedSchema)
+		if refSchema == "" {
+			refSchema = schema
+		}
+
+		fks = append(fks, ForeignKeyTemplateData{
+			Name:           constraint.Name,
+			Columns:        constraint.Columns,
+			ForeignSchema:  refSchema,
+			ForeignTable:   constraint.ReferencedTable,
+			ForeignColumns: constraint.ReferencedColumns,
+			OnDelete:       constraint.OnDelete,
+			OnUpdate:       constraint.OnUpdate,
+		})
+	}
+
 	return TableTemplateData{
-		Schema:     schema,
-		Name:       table.Name,
-		Columns:    columns,
-		PrimaryKey: pk,
+		Schema:      schema,
+		Name:        table.Name,
+		Columns:     columns,
+		PrimaryKey:  pk,
+		ForeignKeys: fks,
 	}
 }
+
+// sortColumns returns columns sorted by Sequence then Name for deterministic output.
+func sortColumns(columns map[string]*models.Column) []*models.Column {
+	result := make([]*models.Column, 0, len(columns))
+	for _, col := range columns {
+		result = append(result, col)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortConstraints returns constraints sorted by Sequence then Name for deterministic output.
+func sortConstraints(constraints map[string]*models.Constraint) []*models.Constraint {
+	result := make([]*models.Constraint, 0, len(constraints))
+	for _, c := range constraints {
+		result = append(result, c)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}
+
+// sortIndexes returns indexes sorted by Sequence then Name for deterministic output.
+func sortIndexes(indexes map[string]*models.Index) []*models.Index {
+	result := make([]*models.Index, 0, len(indexes))
+	for _, idx := range indexes {
+		result = append(result, idx)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		if result[i].Sequence > 0 && result[j].Sequence > 0 {
+			return result[i].Sequence < result[j].Sequence
+		}
+		return result[i].Name < result[j].Name
+	})
+	return result
+}

pkg/writers/sqlite/templates/create_foreign_key.tmpl

@@ -1,6 +0,0 @@
--- Foreign key: {{.Name}}
--- ALTER TABLE {{quote_ident (qualified_table_name .Schema .Table)}} ADD CONSTRAINT {{quote_ident (format_constraint_name .Schema .Table .Name)}}
---   FOREIGN KEY ({{range $i, $col := .Columns}}{{if $i}}, {{end}}{{quote_ident $col}}{{end}})
---   REFERENCES {{quote_ident (qualified_table_name .ForeignSchema .ForeignTable)}} ({{range $i, $col := .ForeignColumns}}{{if $i}}, {{end}}{{quote_ident $col}}{{end}})
---   {{if .OnDelete}}ON DELETE {{.OnDelete}}{{end}}{{if .OnUpdate}} ON UPDATE {{.OnUpdate}}{{end}};
--- Note: Foreign keys should be defined in CREATE TABLE for better SQLite compatibility

pkg/writers/sqlite/templates/create_table.tmpl

@@ -6,4 +6,7 @@ CREATE TABLE {{quote_ident (qualified_table_name .Schema .Name)}} (
 {{- if and .PrimaryKey (not $hasAutoIncrement)}}{{if gt (len .Columns) 0}},{{end}}
     PRIMARY KEY ({{range $i, $colName := .PrimaryKey.Columns}}{{if $i}}, {{end}}{{quote_ident $colName}}{{end}})
 {{- end}}
+{{- range .ForeignKeys}},
+    FOREIGN KEY ({{range $i, $col := .Columns}}{{if $i}}, {{end}}{{quote_ident $col}}{{end}}) REFERENCES {{quote_ident (qualified_table_name .ForeignSchema .ForeignTable)}} ({{range $i, $col := .ForeignColumns}}{{if $i}}, {{end}}{{quote_ident $col}}{{end}}){{if .OnDelete}} ON DELETE {{.OnDelete}}{{end}}{{if .OnUpdate}} ON UPDATE {{.OnUpdate}}{{end}}
+{{- end}}
 );

pkg/writers/sqlite/writer.go

@@ -1,11 +1,15 @@
 package sqlite
 
 import (
+	"context"
+	"database/sql"
 	"fmt"
 	"io"
 	"os"
 	"strings"
 
+	_ "modernc.org/sqlite" // SQLite driver
+
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
@@ -30,8 +34,16 @@ func NewWriter(options *writers.WriterOptions) *Writer {
 	}
 }
 
-// WriteDatabase writes the entire database schema as SQLite SQL
+// WriteDatabase writes the entire database schema as SQLite SQL.
+//
+// If Metadata["connection_string"] is set (a path to a SQLite database file),
+// the generated DDL is executed directly against that file instead of being
+// written out as a .sql script.
 func (w *Writer) WriteDatabase(db *models.Database) error {
+	if dbPath, ok := w.options.Metadata["connection_string"].(string); ok && dbPath != "" {
+		return w.executeDatabaseSQL(db, dbPath)
+	}
+
 	var writer io.Writer
 	var file *os.File
 	var err error
@@ -52,12 +64,16 @@ func (w *Writer) WriteDatabase(db *models.Database) error {
 	}
 
 	w.writer = writer
+	return w.writeContent(db)
+}
 
+// writeContent writes the header, pragma, and every schema's DDL to w.writer.
+func (w *Writer) writeContent(db *models.Database) error {
 	// Write header comment
 	fmt.Fprintf(w.writer, "-- SQLite Database Schema\n")
 	fmt.Fprintf(w.writer, "-- Database: %s\n", db.Name)
 	fmt.Fprintf(w.writer, "-- Generated by RelSpec\n")
-	fmt.Fprintf(w.writer, "-- Note: Schema names have been flattened (e.g., public.users -> public_users)\n\n")
+	fmt.Fprintf(w.writer, "-- Note: SQLite has no schema concept; non-default schema names are flattened into table name prefixes (e.g., auth.sessions -> auth_sessions)\n\n")
 
 	// Enable foreign keys
 	pragma, err := w.executor.ExecutePragmaForeignKeys()
@@ -76,48 +92,134 @@ func (w *Writer) WriteDatabase(db *models.Database) error {
 	return nil
 }
 
+// statementCollector captures each Write call as a single SQL statement (or
+// comment line), matching the writer's convention of one Fprintf per statement.
+type statementCollector struct {
+	statements []string
+}
+
+func (c *statementCollector) Write(p []byte) (int, error) {
+	if s := strings.TrimSpace(string(p)); s != "" {
+		c.statements = append(c.statements, s)
+	}
+	return len(p), nil
+}
+
+// executeDatabaseSQL generates the DDL for db and executes it directly
+// against the SQLite database file at dbPath.
+func (w *Writer) executeDatabaseSQL(db *models.Database, dbPath string) error {
+	collector := &statementCollector{}
+	w.writer = collector
+	if err := w.writeContent(db); err != nil {
+		return fmt.Errorf("failed to generate SQL statements: %w", err)
+	}
+
+	conn, err := sql.Open("sqlite", dbPath)
+	if err != nil {
+		return fmt.Errorf("failed to open sqlite database %q: %w", dbPath, err)
+	}
+	defer conn.Close()
+
+	ctx := context.Background()
+	ignoreErrors := false
+	if val, ok := w.options.Metadata["ignore_errors"].(bool); ok {
+		ignoreErrors = val
+	}
+
+	total, executed := 0, 0
+	var execErrors []string
+	for _, stmt := range collector.statements {
+		if strings.HasPrefix(stmt, "--") {
+			continue
+		}
+
+		total++
+		if _, err := conn.ExecContext(ctx, stmt); err != nil {
+			execErrors = append(execErrors, fmt.Sprintf("statement %d (%s): %v", total, truncateStatement(stmt), err))
+			if !ignoreErrors {
+				break
+			}
+			continue
+		}
+		executed++
+	}
+
+	w.options.Metadata["execution_total"] = total
+	w.options.Metadata["execution_success"] = executed
+	w.options.Metadata["execution_failed"] = len(execErrors)
+
+	if len(execErrors) > 0 {
+		return fmt.Errorf("failed to execute %d/%d statement(s) against %q:\n%s", len(execErrors), total, dbPath, strings.Join(execErrors, "\n"))
+	}
+
+	return nil
+}
+
+// truncateStatement shortens a SQL statement for error messages.
+func truncateStatement(stmt string) string {
+	const maxLen = 80
+	stmt = strings.Join(strings.Fields(stmt), " ")
+	if len(stmt) > maxLen {
+		return stmt[:maxLen] + "..."
+	}
+	return stmt
+}
+
+// defaultSchemaNames are treated as "no schema" for SQLite output: SQLite has
+// no schema concept, and a lone default schema (e.g. DBML's implicit "public")
+// should produce bare table names rather than a "public_" prefix.
+var defaultSchemaNames = map[string]bool{
+	"public": true,
+	"main":   true,
+}
+
+// tableSchemaName returns the schema name to use for table/constraint naming,
+// collapsing default schema names to "" so they aren't prefixed onto table names.
+func tableSchemaName(schema string) string {
+	if defaultSchemaNames[strings.ToLower(schema)] {
+		return ""
+	}
+	return schema
+}
+
 // WriteSchema writes a single schema as SQLite SQL
 func (w *Writer) WriteSchema(schema *models.Schema) error {
-	// SQLite doesn't have schemas, so we just write a comment
-	if schema.Name != "" {
+	tableSchema := tableSchemaName(schema.Name)
+
+	// SQLite doesn't have schemas, so we just write a comment (skip for the
+	// default schema, since its tables aren't actually being prefixed)
+	if tableSchema != "" {
 		fmt.Fprintf(w.writer, "-- Schema: %s (flattened into table names)\n\n", schema.Name)
 	}
 
 	// Phase 1: Create tables
 	for _, table := range schema.Tables {
-		if err := w.writeTable(schema.Name, table); err != nil {
+		if err := w.writeTable(tableSchema, table); err != nil {
 			return fmt.Errorf("failed to write table %s: %w", table.Name, err)
 		}
 	}
 
 	// Phase 2: Create indexes
 	for _, table := range schema.Tables {
-		if err := w.writeIndexes(schema.Name, table); err != nil {
+		if err := w.writeIndexes(tableSchema, table); err != nil {
 			return fmt.Errorf("failed to write indexes for table %s: %w", table.Name, err)
 		}
 	}
 
 	// Phase 3: Create unique constraints (as unique indexes)
 	for _, table := range schema.Tables {
-		if err := w.writeUniqueConstraints(schema.Name, table); err != nil {
+		if err := w.writeUniqueConstraints(tableSchema, table); err != nil {
 			return fmt.Errorf("failed to write unique constraints for table %s: %w", table.Name, err)
 		}
 	}
 
 	// Phase 4: Check constraints (as comments, since SQLite requires them in CREATE TABLE)
 	for _, table := range schema.Tables {
-		if err := w.writeCheckConstraints(schema.Name, table); err != nil {
+		if err := w.writeCheckConstraints(tableSchema, table); err != nil {
 			return fmt.Errorf("failed to write check constraints for table %s: %w", table.Name, err)
 		}
 	}
 
-	// Phase 5: Foreign keys (as comments for compatibility)
-	for _, table := range schema.Tables {
-		if err := w.writeForeignKeys(schema.Name, table); err != nil {
-			return fmt.Errorf("failed to write foreign keys for table %s: %w", table.Name, err)
-		}
-	}
-
 	return nil
 }
 
@@ -143,7 +245,7 @@ func (w *Writer) writeTable(schema string, table *models.Table) error {
 
 // writeIndexes writes indexes for a table
 func (w *Writer) writeIndexes(schema string, table *models.Table) error {
-	for _, index := range table.Indexes {
+	for _, index := range sortIndexes(table.Indexes) {
 		// Skip primary key indexes
 		if strings.HasSuffix(index.Name, "_pkey") {
 			continue
@@ -174,7 +276,7 @@ func (w *Writer) writeIndexes(schema string, table *models.Table) error {
 
 // writeUniqueConstraints writes unique constraints as unique indexes
 func (w *Writer) writeUniqueConstraints(schema string, table *models.Table) error {
-	for _, constraint := range table.Constraints {
+	for _, constraint := range sortConstraints(table.Constraints) {
 		if constraint.Type != models.UniqueConstraint {
 			continue
 		}
@@ -195,7 +297,7 @@ func (w *Writer) writeUniqueConstraints(schema string, table *models.Table) erro
 	}
 
 	// Also handle unique indexes from the Indexes map
-	for _, index := range table.Indexes {
+	for _, index := range sortIndexes(table.Indexes) {
 		if !index.Unique {
 			continue
 		}
@@ -232,7 +334,7 @@ func (w *Writer) writeUniqueConstraints(schema string, table *models.Table) erro
 
 // writeCheckConstraints writes check constraints as comments
 func (w *Writer) writeCheckConstraints(schema string, table *models.Table) error {
-	for _, constraint := range table.Constraints {
+	for _, constraint := range sortConstraints(table.Constraints) {
 		if constraint.Type != models.CheckConstraint {
 			continue
 		}
@@ -254,38 +356,3 @@ func (w *Writer) writeCheckConstraints(schema string, table *models.Table) error
 
 	return nil
 }
-
-// writeForeignKeys writes foreign keys as comments
-func (w *Writer) writeForeignKeys(schema string, table *models.Table) error {
-	for _, constraint := range table.Constraints {
-		if constraint.Type != models.ForeignKeyConstraint {
-			continue
-		}
-
-		refSchema := constraint.ReferencedSchema
-		if refSchema == "" {
-			refSchema = schema
-		}
-
-		data := ConstraintTemplateData{
-			Schema:         schema,
-			Table:          table.Name,
-			Name:           constraint.Name,
-			Columns:        constraint.Columns,
-			ForeignSchema:  refSchema,
-			ForeignTable:   constraint.ReferencedTable,
-			ForeignColumns: constraint.ReferencedColumns,
-			OnDelete:       constraint.OnDelete,
-			OnUpdate:       constraint.OnUpdate,
-		}
-
-		sql, err := w.executor.ExecuteCreateForeignKey(data)
-		if err != nil {
-			return fmt.Errorf("failed to execute create foreign key template: %w", err)
-		}
-
-		fmt.Fprintf(w.writer, "%s\n", sql)
-	}
-
-	return nil
-}

pkg/writers/sqlite/writer_test.go

@@ -85,8 +85,11 @@ func TestWriteDatabase(t *testing.T) {
 		t.Error("Expected CREATE TABLE statement")
 	}
 
-	if !strings.Contains(output, "\"public_users\"") {
-		t.Error("Expected flattened table name public_users")
+	if !strings.Contains(output, "\"users\"") {
+		t.Error("Expected bare table name users (default schema should not be prefixed)")
+	}
+	if strings.Contains(output, "\"public_users\"") {
+		t.Error("Did not expect flattened table name public_users for the default public schema")
 	}
 
 	if !strings.Contains(output, "INTEGER PRIMARY KEY AUTOINCREMENT") {
@@ -322,13 +325,15 @@ func TestWriteSchema_MultiSchema(t *testing.T) {
 
 	output := buf.String()
 
-	// Check for flattened table names from both schemas
+	// Non-default schemas are still prefixed to avoid name collisions...
 	if !strings.Contains(output, "\"auth_sessions\"") {
 		t.Error("Expected flattened table name auth_sessions")
 	}
 
-	if !strings.Contains(output, "\"public_posts\"") {
-		t.Error("Expected flattened table name public_posts")
+	// ...but the default "public" schema is not, since it's typically the
+	// only schema and bare names read better (and match e.g. DBML output).
+	if !strings.Contains(output, "\"posts\"") {
+		t.Error("Expected bare table name posts")
 	}
 }
 

pkg/writers/template/writer_test.go

@@ -0,0 +1,87 @@
+package template
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
+)
+
+func TestWriterTableIndexValuesDeterministic(t *testing.T) {
+	dir := t.TempDir()
+	templatePath := filepath.Join(dir, "indexes.tmpl")
+	outputDir := filepath.Join(dir, "out")
+	outputPath := filepath.Join(outputDir, "accounts.txt")
+	templateBody := "{{range values .Table.Indexes}}{{.Name}}:{{join .Columns \",\"}}\n{{end}}"
+
+	if err := os.MkdirAll(outputDir, 0755); err != nil {
+		t.Fatalf("create output dir: %v", err)
+	}
+	if err := os.WriteFile(templatePath, []byte(templateBody), 0644); err != nil {
+		t.Fatalf("write template: %v", err)
+	}
+
+	db := databaseWithMultipleIndexes()
+	var first []byte
+	const runs = 100
+	for i := 0; i < runs; i++ {
+		writer, err := NewWriter(&writers.WriterOptions{
+			OutputPath: outputDir,
+			Metadata: map[string]interface{}{
+				"template_path": templatePath,
+				"mode":          string(TableMode),
+			},
+		})
+		if err != nil {
+			t.Fatalf("new writer: %v", err)
+		}
+
+		if err := writer.WriteDatabase(db); err != nil {
+			t.Fatalf("write database run %d: %v", i, err)
+		}
+
+		got, err := os.ReadFile(outputPath)
+		if err != nil {
+			t.Fatalf("read output run %d: %v", i, err)
+		}
+
+		if i == 0 {
+			first = got
+			continue
+		}
+		if string(got) != string(first) {
+			t.Fatalf("run %d output differed from first run\nfirst:\n%s\nrun %d:\n%s", i, first, i, got)
+		}
+	}
+
+	want := strings.Join([]string{
+		"idx_accounts_email:email",
+		"idx_accounts_last_login:last_login",
+		"idx_accounts_name:name",
+		"idx_accounts_status:status",
+		"idx_accounts_tenant:tenant_id",
+		"",
+	}, "\n")
+	if string(first) != want {
+		t.Fatalf("unexpected index order\nwant:\n%s\ngot:\n%s", want, first)
+	}
+}
+
+func databaseWithMultipleIndexes() *models.Database {
+	db := models.InitDatabase("test")
+	schema := models.InitSchema("public")
+	table := models.InitTable("accounts", "public")
+
+	table.Indexes["idx_accounts_status"] = &models.Index{Name: "idx_accounts_status", Table: table.Name, Schema: schema.Name, Columns: []string{"status"}}
+	table.Indexes["idx_accounts_email"] = &models.Index{Name: "idx_accounts_email", Table: table.Name, Schema: schema.Name, Columns: []string{"email"}}
+	table.Indexes["idx_accounts_tenant"] = &models.Index{Name: "idx_accounts_tenant", Table: table.Name, Schema: schema.Name, Columns: []string{"tenant_id"}}
+	table.Indexes["idx_accounts_name"] = &models.Index{Name: "idx_accounts_name", Table: table.Name, Schema: schema.Name, Columns: []string{"name"}}
+	table.Indexes["idx_accounts_last_login"] = &models.Index{Name: "idx_accounts_last_login", Table: table.Name, Schema: schema.Name, Columns: []string{"last_login"}}
+
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+	return db
+}

pkg/writers/typeorm/writer.go

@@ -531,7 +531,13 @@ func (w *Writer) generateInverseRelations(table *models.Table, schema *models.Sc
 
 // generateManyToManyRelations generates @ManyToMany fields
 func (w *Writer) generateManyToManyRelations(table *models.Table, schema *models.Schema, joinTables map[string]bool, sb *strings.Builder) {
-	for joinTableName := range joinTables {
+	joinTableNames := make([]string, 0, len(joinTables))
+	for name := range joinTables {
+		joinTableNames = append(joinTableNames, name)
+	}
+	sort.Strings(joinTableNames)
+
+	for _, joinTableName := range joinTableNames {
 		joinTable := w.findTable(joinTableName, schema)
 		if joinTable == nil {
 			continue

pkg/writers/writer.go

@@ -37,6 +37,23 @@ const (
 	NullableTypeBaselib = "baselib"
 )
 
+// NullableArrays constants control how nullable PostgreSQL array columns are
+// represented in native-slice code-generation writers (Bun in stdlib/baselib
+// mode).
+const (
+	// NullableArraysSlice represents every array column (nullable or not) as
+	// a plain slice ([]string, []int32, …). SQL NULL and '{}' both scan into
+	// a zero-length/nil slice, so callers cannot distinguish them. This is
+	// the default.
+	NullableArraysSlice = "slice"
+
+	// NullableArraysPointerSlice represents nullable array columns as a
+	// pointer to a slice (*[]string, *[]int32, …), so callers can
+	// distinguish SQL NULL (nil pointer) from '{}' (pointer to an empty
+	// slice). NOT NULL array columns are unaffected and remain plain slices.
+	NullableArraysPointerSlice = "pointer_slice"
+)
+
 // WriterOptions contains common options for writers
 type WriterOptions struct {
 	// OutputPath is the path where the output should be written
@@ -57,6 +74,15 @@ type WriterOptions struct {
 	//   "baselib" (default)     — plain Go pointer types (*string, *int32, …)
 	NullableTypes string
 
+	// NullableArrays selects how nullable PostgreSQL array columns are
+	// represented in native-slice code-generation writers (bun). Accepted values:
+	//   "slice" (default)      — plain slice for every array column
+	//   "pointer_slice"        — pointer-to-slice for nullable array columns,
+	//                            distinguishing SQL NULL from '{}'
+	// Has no effect in "sqltypes" NullableTypes mode, which always uses the
+	// SqlXxxArray wrapper types.
+	NullableArrays string
+
 	// Prisma7 enables Prisma 7-specific output for Prisma writers.
 	Prisma7 bool
 
@@ -122,6 +148,26 @@ func SanitizeFilename(name string) string {
 // Examples (boolean):   "true"         → "true"
 // Examples (bigint):    "0"            → "0"
 // Examples (timestamp): "now()"        → "now()"   (function call – never quoted)
+// bareKeywordDefaults are PostgreSQL default-value keywords that are
+// expressions, not string literals, even though they contain no
+// parentheses (e.g. "CURRENT_DATE" rather than "now()"). They must never be
+// wrapped in quotes.
+var bareKeywordDefaults = map[string]bool{
+	"current_date":      true,
+	"current_time":      true,
+	"current_timestamp": true,
+	"localtime":         true,
+	"localtimestamp":    true,
+	"current_user":      true,
+	"session_user":      true,
+	"current_role":      true,
+	"current_catalog":   true,
+	"current_schema":    true,
+	"null":              true,
+	"true":              true,
+	"false":             true,
+}
+
 func QuoteDefaultValue(value, sqlType string) string {
 	value = strings.TrimSpace(value)
 
@@ -132,6 +178,12 @@ func QuoteDefaultValue(value, sqlType string) string {
 		return value
 	}
 
+	// Bare keyword expressions (e.g. CURRENT_DATE) are never quoted,
+	// regardless of column type.
+	if bareKeywordDefaults[strings.ToLower(value)] {
+		return value
+	}
+
 	// Normalise the SQL type: lowercase, strip length/precision suffix.
 	baseType := strings.ToLower(strings.TrimSpace(sqlType))
 	if idx := strings.Index(baseType, "("); idx > 0 {

pkg/writers/writer_test.go

@@ -41,6 +41,24 @@ func TestQuoteDefaultValue(t *testing.T) {
 			sqlType: "timestamptz",
 			want:    "now()",
 		},
+		{
+			name:    "bare keyword default CURRENT_DATE is not quoted",
+			value:   "CURRENT_DATE",
+			sqlType: "date",
+			want:    "CURRENT_DATE",
+		},
+		{
+			name:    "bare keyword default is case insensitive",
+			value:   "current_timestamp",
+			sqlType: "timestamptz",
+			want:    "current_timestamp",
+		},
+		{
+			name:    "bare keyword default localtime is not quoted",
+			value:   "LOCALTIME",
+			sqlType: "time",
+			want:    "LOCALTIME",
+		},
 	}
 
 	for _, tt := range tests {

vendor/github.com/jackc/pgx/v5/pgxpool/batch_results.go

@@ -0,0 +1,52 @@
+package pgxpool
+
+import (
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+)
+
+type errBatchResults struct {
+	err error
+}
+
+func (br errBatchResults) Exec() (pgconn.CommandTag, error) {
+	return pgconn.CommandTag{}, br.err
+}
+
+func (br errBatchResults) Query() (pgx.Rows, error) {
+	return errRows{err: br.err}, br.err
+}
+
+func (br errBatchResults) QueryRow() pgx.Row {
+	return errRow{err: br.err}
+}
+
+func (br errBatchResults) Close() error {
+	return br.err
+}
+
+type poolBatchResults struct {
+	br pgx.BatchResults
+	c  *Conn
+}
+
+func (br *poolBatchResults) Exec() (pgconn.CommandTag, error) {
+	return br.br.Exec()
+}
+
+func (br *poolBatchResults) Query() (pgx.Rows, error) {
+	return br.br.Query()
+}
+
+func (br *poolBatchResults) QueryRow() pgx.Row {
+	return br.br.QueryRow()
+}
+
+func (br *poolBatchResults) Close() error {
+	err := br.br.Close()
+	if br.c != nil {
+		br.c.Release()
+		br.c = nil
+	}
+	return err
+}

vendor/github.com/jackc/pgx/v5/pgxpool/conn.go

@@ -0,0 +1,134 @@
+package pgxpool
+
+import (
+	"context"
+	"sync/atomic"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/puddle/v2"
+)
+
+// Conn is an acquired *pgx.Conn from a Pool.
+type Conn struct {
+	res *puddle.Resource[*connResource]
+	p   *Pool
+}
+
+// Release returns c to the pool it was acquired from. Once Release has been called, other methods must not be called.
+// However, it is safe to call Release multiple times. Subsequent calls after the first will be ignored.
+func (c *Conn) Release() {
+	if c.res == nil {
+		return
+	}
+
+	conn := c.Conn()
+	res := c.res
+	c.res = nil
+
+	if c.p.releaseTracer != nil {
+		c.p.releaseTracer.TraceRelease(c.p, TraceReleaseData{Conn: conn})
+	}
+
+	if conn.IsClosed() || conn.PgConn().IsBusy() || conn.PgConn().TxStatus() != 'I' {
+		res.Destroy()
+		// Signal to the health check to run since we just destroyed a connections
+		// and we might be below minConns now
+		c.p.triggerHealthCheck()
+		return
+	}
+
+	// If the pool is consistently being used, we might never get to check the
+	// lifetime of a connection since we only check idle connections in checkConnsHealth
+	// so we also check the lifetime here and force a health check
+	if c.p.isExpired(res) {
+		atomic.AddInt64(&c.p.lifetimeDestroyCount, 1)
+		res.Destroy()
+		// Signal to the health check to run since we just destroyed a connections
+		// and we might be below minConns now
+		c.p.triggerHealthCheck()
+		return
+	}
+
+	if c.p.afterRelease == nil {
+		res.Release()
+		return
+	}
+
+	go func() {
+		if c.p.afterRelease(conn) {
+			res.Release()
+		} else {
+			res.Destroy()
+			// Signal to the health check to run since we just destroyed a connections
+			// and we might be below minConns now
+			c.p.triggerHealthCheck()
+		}
+	}()
+}
+
+// Hijack assumes ownership of the connection from the pool. Caller is responsible for closing the connection. Hijack
+// will panic if called on an already released or hijacked connection.
+func (c *Conn) Hijack() *pgx.Conn {
+	if c.res == nil {
+		panic("cannot hijack already released or hijacked connection")
+	}
+
+	conn := c.Conn()
+	res := c.res
+	c.res = nil
+
+	res.Hijack()
+
+	return conn
+}
+
+func (c *Conn) Exec(ctx context.Context, sql string, arguments ...any) (pgconn.CommandTag, error) {
+	return c.Conn().Exec(ctx, sql, arguments...)
+}
+
+func (c *Conn) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
+	return c.Conn().Query(ctx, sql, args...)
+}
+
+func (c *Conn) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row {
+	return c.Conn().QueryRow(ctx, sql, args...)
+}
+
+func (c *Conn) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
+	return c.Conn().SendBatch(ctx, b)
+}
+
+func (c *Conn) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
+	return c.Conn().CopyFrom(ctx, tableName, columnNames, rowSrc)
+}
+
+// Begin starts a transaction block from the *Conn without explicitly setting a transaction mode (see BeginTx with TxOptions if transaction mode is required).
+func (c *Conn) Begin(ctx context.Context) (pgx.Tx, error) {
+	return c.Conn().Begin(ctx)
+}
+
+// BeginTx starts a transaction block from the *Conn with txOptions determining the transaction mode.
+func (c *Conn) BeginTx(ctx context.Context, txOptions pgx.TxOptions) (pgx.Tx, error) {
+	return c.Conn().BeginTx(ctx, txOptions)
+}
+
+func (c *Conn) Ping(ctx context.Context) error {
+	return c.Conn().Ping(ctx)
+}
+
+func (c *Conn) Conn() *pgx.Conn {
+	return c.connResource().conn
+}
+
+func (c *Conn) connResource() *connResource {
+	return c.res.Value()
+}
+
+func (c *Conn) getPoolRow(r pgx.Row) *poolRow {
+	return c.connResource().getPoolRow(c, r)
+}
+
+func (c *Conn) getPoolRows(r pgx.Rows) *poolRows {
+	return c.connResource().getPoolRows(c, r)
+}

vendor/github.com/jackc/pgx/v5/pgxpool/doc.go

@@ -0,0 +1,27 @@
+// Package pgxpool is a concurrency-safe connection pool for pgx.
+/*
+pgxpool implements a nearly identical interface to pgx connections.
+
+Creating a Pool
+
+The primary way of creating a pool is with [pgxpool.New]:
+
+    pool, err := pgxpool.New(context.Background(), os.Getenv("DATABASE_URL"))
+
+The database connection string can be in URL or keyword/value format. PostgreSQL settings, pgx settings, and pool settings can be
+specified here. In addition, a config struct can be created by [ParseConfig].
+
+    config, err := pgxpool.ParseConfig(os.Getenv("DATABASE_URL"))
+    if err != nil {
+        // ...
+    }
+    config.AfterConnect = func(ctx context.Context, conn *pgx.Conn) error {
+        // do something with every new connection
+    }
+
+    pool, err := pgxpool.NewWithConfig(context.Background(), config)
+
+A pool returns without waiting for any connections to be established. Acquire a connection immediately after creating
+the pool to check if a connection can successfully be established.
+*/
+package pgxpool

vendor/github.com/jackc/pgx/v5/pgxpool/pool.go

@@ -0,0 +1,832 @@
+package pgxpool
+
+import (
+	"context"
+	"errors"
+	"math/rand/v2"
+	"runtime"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/puddle/v2"
+)
+
+var (
+	defaultMaxConns          = int32(4)
+	defaultMinConns          = int32(0)
+	defaultMinIdleConns      = int32(0)
+	defaultMaxConnLifetime   = time.Hour
+	defaultMaxConnIdleTime   = time.Minute * 30
+	defaultHealthCheckPeriod = time.Minute
+)
+
+type connResource struct {
+	conn       *pgx.Conn
+	conns      []Conn
+	poolRows   []poolRow
+	poolRowss  []poolRows
+	maxAgeTime time.Time
+}
+
+func (cr *connResource) getConn(p *Pool, res *puddle.Resource[*connResource]) *Conn {
+	if len(cr.conns) == 0 {
+		cr.conns = make([]Conn, 128)
+	}
+
+	c := &cr.conns[len(cr.conns)-1]
+	cr.conns = cr.conns[0 : len(cr.conns)-1]
+
+	c.res = res
+	c.p = p
+
+	return c
+}
+
+func (cr *connResource) getPoolRow(c *Conn, r pgx.Row) *poolRow {
+	if len(cr.poolRows) == 0 {
+		cr.poolRows = make([]poolRow, 128)
+	}
+
+	pr := &cr.poolRows[len(cr.poolRows)-1]
+	cr.poolRows = cr.poolRows[0 : len(cr.poolRows)-1]
+
+	pr.c = c
+	pr.r = r
+
+	return pr
+}
+
+func (cr *connResource) getPoolRows(c *Conn, r pgx.Rows) *poolRows {
+	if len(cr.poolRowss) == 0 {
+		cr.poolRowss = make([]poolRows, 128)
+	}
+
+	pr := &cr.poolRowss[len(cr.poolRowss)-1]
+	cr.poolRowss = cr.poolRowss[0 : len(cr.poolRowss)-1]
+
+	pr.c = c
+	pr.r = r
+
+	return pr
+}
+
+// Pool allows for connection reuse.
+type Pool struct {
+	// 64 bit fields accessed with atomics must be at beginning of struct to guarantee alignment for certain 32-bit
+	// architectures. See BUGS section of https://pkg.go.dev/sync/atomic and https://github.com/jackc/pgx/issues/1288.
+	newConnsCount        int64
+	lifetimeDestroyCount int64
+	idleDestroyCount     int64
+
+	p                     *puddle.Pool[*connResource]
+	config                *Config
+	beforeConnect         func(context.Context, *pgx.ConnConfig) error
+	afterConnect          func(context.Context, *pgx.Conn) error
+	prepareConn           func(context.Context, *pgx.Conn) (bool, error)
+	afterRelease          func(*pgx.Conn) bool
+	beforeClose           func(*pgx.Conn)
+	shouldPing            func(context.Context, ShouldPingParams) bool
+	minConns              int32
+	minIdleConns          int32
+	maxConns              int32
+	maxConnLifetime       time.Duration
+	maxConnLifetimeJitter time.Duration
+	maxConnIdleTime       time.Duration
+	healthCheckPeriod     time.Duration
+	pingTimeout           time.Duration
+
+	healthCheckMu    sync.Mutex
+	healthCheckTimer *time.Timer
+
+	healthCheckChan chan struct{}
+
+	acquireTracer AcquireTracer
+	releaseTracer ReleaseTracer
+
+	closeOnce sync.Once
+	closeChan chan struct{}
+}
+
+// ShouldPingParams are the parameters passed to ShouldPing.
+type ShouldPingParams struct {
+	Conn         *pgx.Conn
+	IdleDuration time.Duration
+}
+
+// Config is the configuration struct for creating a pool. It must be created by [ParseConfig] and then it can be
+// modified.
+type Config struct {
+	ConnConfig *pgx.ConnConfig
+
+	// BeforeConnect is called before a new connection is made. It is passed a copy of the underlying [pgx.ConnConfig] and
+	// will not impact any existing open connections.
+	BeforeConnect func(context.Context, *pgx.ConnConfig) error
+
+	// AfterConnect is called after a connection is established, but before it is added to the pool.
+	AfterConnect func(context.Context, *pgx.Conn) error
+
+	// BeforeAcquire is called before a connection is acquired from the pool. It must return true to allow the
+	// acquisition or false to indicate that the connection should be destroyed and a different connection should be
+	// acquired.
+	//
+	// Deprecated: Use PrepareConn instead. If both PrepareConn and BeforeAcquire are set, PrepareConn will take
+	// precedence, ignoring BeforeAcquire.
+	BeforeAcquire func(context.Context, *pgx.Conn) bool
+
+	// PrepareConn is called before a connection is acquired from the pool. If this function returns true, the connection
+	// is considered valid, otherwise the connection is destroyed. If the function returns a non-nil error, the instigating
+	// query will fail with the returned error.
+	//
+	// Specifically, this means that:
+	//
+	// 	- If it returns true and a nil error, the query proceeds as normal.
+	// 	- If it returns true and an error, the connection will be returned to the pool, and the instigating query will fail with the returned error.
+	// 	- If it returns false, and an error, the connection will be destroyed, and the query will fail with the returned error.
+	// 	- If it returns false and a nil error, the connection will be destroyed, and the instigating query will be retried on a new connection.
+	PrepareConn func(context.Context, *pgx.Conn) (bool, error)
+
+	// AfterRelease is called after a connection is released, but before it is returned to the pool. It must return true to
+	// return the connection to the pool or false to destroy the connection.
+	AfterRelease func(*pgx.Conn) bool
+
+	// BeforeClose is called right before a connection is closed and removed from the pool.
+	BeforeClose func(*pgx.Conn)
+
+	// ShouldPing is called after a connection is acquired from the pool. If it returns true, the connection is pinged to check for liveness.
+	// If this func is not set, the default behavior is to ping connections that have been idle for at least 1 second.
+	ShouldPing func(context.Context, ShouldPingParams) bool
+
+	// MaxConnLifetime is the duration since creation after which a connection will be automatically closed.
+	MaxConnLifetime time.Duration
+
+	// MaxConnLifetimeJitter is the duration after MaxConnLifetime to randomly decide to close a connection.
+	// This helps prevent all connections from being closed at the exact same time, starving the pool.
+	MaxConnLifetimeJitter time.Duration
+
+	// MaxConnIdleTime is the duration after which an idle connection will be automatically closed by the health check.
+	MaxConnIdleTime time.Duration
+
+	// PingTimeout is the maximum amount of time to wait for a connection to pong before considering it as unhealthy and
+	// destroying it. If zero, the default is no timeout.
+	PingTimeout time.Duration
+
+	// MaxConns is the maximum size of the pool. The default is the greater of 4 or runtime.NumCPU().
+	MaxConns int32
+
+	// MinConns is the minimum size of the pool. After connection closes, the pool might dip below MinConns. A low
+	// number of MinConns might mean the pool is empty after MaxConnLifetime until the health check has a chance
+	// to create new connections.
+	MinConns int32
+
+	// MinIdleConns is the minimum number of idle connections in the pool. You can increase this to ensure that
+	// there are always idle connections available. This can help reduce tail latencies during request processing,
+	// as you can avoid the latency of establishing a new connection while handling requests. It is superior
+	// to MinConns for this purpose.
+	// Similar to MinConns, the pool might temporarily dip below MinIdleConns after connection closes.
+	MinIdleConns int32
+
+	// HealthCheckPeriod is the duration between checks of the health of idle connections.
+	HealthCheckPeriod time.Duration
+
+	createdByParseConfig bool // Used to enforce created by ParseConfig rule.
+}
+
+// Copy returns a deep copy of the config that is safe to use and modify.
+// The only exception is the tls.Config:
+// according to the tls.Config docs it must not be modified after creation.
+func (c *Config) Copy() *Config {
+	newConfig := new(Config)
+	*newConfig = *c
+	newConfig.ConnConfig = c.ConnConfig.Copy()
+	return newConfig
+}
+
+// ConnString returns the connection string as parsed by pgxpool.ParseConfig into pgxpool.Config.
+func (c *Config) ConnString() string { return c.ConnConfig.ConnString() }
+
+// New creates a new Pool. See [ParseConfig] for information on connString format.
+func New(ctx context.Context, connString string) (*Pool, error) {
+	config, err := ParseConfig(connString)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewWithConfig(ctx, config)
+}
+
+// NewWithConfig creates a new [Pool]. config must have been created by [ParseConfig].
+func NewWithConfig(ctx context.Context, config *Config) (*Pool, error) {
+	// Default values are set in ParseConfig. Enforce initial creation by ParseConfig rather than setting defaults from
+	// zero values.
+	if !config.createdByParseConfig {
+		panic("config must be created by ParseConfig")
+	}
+
+	prepareConn := config.PrepareConn
+	if prepareConn == nil && config.BeforeAcquire != nil {
+		prepareConn = func(ctx context.Context, conn *pgx.Conn) (bool, error) {
+			return config.BeforeAcquire(ctx, conn), nil
+		}
+	}
+
+	p := &Pool{
+		config:                config,
+		beforeConnect:         config.BeforeConnect,
+		afterConnect:          config.AfterConnect,
+		prepareConn:           prepareConn,
+		afterRelease:          config.AfterRelease,
+		beforeClose:           config.BeforeClose,
+		minConns:              config.MinConns,
+		minIdleConns:          config.MinIdleConns,
+		maxConns:              config.MaxConns,
+		maxConnLifetime:       config.MaxConnLifetime,
+		maxConnLifetimeJitter: config.MaxConnLifetimeJitter,
+		maxConnIdleTime:       config.MaxConnIdleTime,
+		pingTimeout:           config.PingTimeout,
+		healthCheckPeriod:     config.HealthCheckPeriod,
+		healthCheckChan:       make(chan struct{}, 1),
+		closeChan:             make(chan struct{}),
+	}
+
+	if t, ok := config.ConnConfig.Tracer.(AcquireTracer); ok {
+		p.acquireTracer = t
+	}
+
+	if t, ok := config.ConnConfig.Tracer.(ReleaseTracer); ok {
+		p.releaseTracer = t
+	}
+
+	if config.ShouldPing != nil {
+		p.shouldPing = config.ShouldPing
+	} else {
+		p.shouldPing = func(ctx context.Context, params ShouldPingParams) bool {
+			return params.IdleDuration > time.Second
+		}
+	}
+
+	var err error
+	p.p, err = puddle.NewPool(
+		&puddle.Config[*connResource]{
+			Constructor: func(ctx context.Context) (*connResource, error) {
+				atomic.AddInt64(&p.newConnsCount, 1)
+				connConfig := p.config.ConnConfig.Copy()
+
+				// Connection will continue in background even if Acquire is canceled. Ensure that a connect won't hang forever.
+				if connConfig.ConnectTimeout <= 0 {
+					connConfig.ConnectTimeout = 2 * time.Minute
+				}
+
+				if p.beforeConnect != nil {
+					if err := p.beforeConnect(ctx, connConfig); err != nil {
+						return nil, err
+					}
+				}
+
+				conn, err := pgx.ConnectConfig(ctx, connConfig)
+				if err != nil {
+					return nil, err
+				}
+
+				if p.afterConnect != nil {
+					err = p.afterConnect(ctx, conn)
+					if err != nil {
+						conn.Close(ctx)
+						return nil, err
+					}
+				}
+
+				jitterSecs := rand.Float64() * config.MaxConnLifetimeJitter.Seconds()
+				maxAgeTime := time.Now().Add(config.MaxConnLifetime).Add(time.Duration(jitterSecs) * time.Second)
+
+				cr := &connResource{
+					conn:       conn,
+					conns:      make([]Conn, 64),
+					poolRows:   make([]poolRow, 64),
+					poolRowss:  make([]poolRows, 64),
+					maxAgeTime: maxAgeTime,
+				}
+
+				return cr, nil
+			},
+			Destructor: func(value *connResource) {
+				ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+				conn := value.conn
+				if p.beforeClose != nil {
+					p.beforeClose(conn)
+				}
+				conn.Close(ctx)
+				select {
+				case <-conn.PgConn().CleanupDone():
+				case <-ctx.Done():
+				}
+				cancel()
+			},
+			MaxSize: config.MaxConns,
+		},
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	go func() {
+		targetIdleResources := max(int(p.minConns), int(p.minIdleConns))
+		p.createIdleResources(ctx, targetIdleResources)
+		p.backgroundHealthCheck()
+	}()
+
+	return p, nil
+}
+
+// ParseConfig builds a Config from connString. It parses connString with the same behavior as [pgx.ParseConfig] with the
+// addition of the following variables:
+//
+//   - pool_max_conns: integer greater than 0 (default 4)
+//   - pool_min_conns: integer 0 or greater (default 0)
+//   - pool_max_conn_lifetime: duration string (default 1 hour)
+//   - pool_max_conn_idle_time: duration string (default 30 minutes)
+//   - pool_health_check_period: duration string (default 1 minute)
+//   - pool_max_conn_lifetime_jitter: duration string (default 0)
+//
+// See Config for definitions of these arguments.
+//
+//	# Example Keyword/Value
+//	user=jack password=secret host=pg.example.com port=5432 dbname=mydb sslmode=verify-ca pool_max_conns=10 pool_max_conn_lifetime=1h30m
+//
+//	# Example URL
+//	postgres://jack:secret@pg.example.com:5432/mydb?sslmode=verify-ca&pool_max_conns=10&pool_max_conn_lifetime=1h30m
+func ParseConfig(connString string) (*Config, error) {
+	connConfig, err := pgx.ParseConfig(connString)
+	if err != nil {
+		return nil, err
+	}
+
+	config := &Config{
+		ConnConfig:           connConfig,
+		createdByParseConfig: true,
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_max_conns"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_max_conns")
+		n, err := strconv.ParseInt(s, 10, 32)
+		if err != nil {
+			return nil, pgconn.NewParseConfigError(connString, "cannot parse pool_max_conns", err)
+		}
+		if n < 1 {
+			return nil, pgconn.NewParseConfigError(connString, "pool_max_conns too small", err)
+		}
+		config.MaxConns = int32(n)
+	} else {
+		config.MaxConns = defaultMaxConns
+		if numCPU := int32(runtime.NumCPU()); numCPU > config.MaxConns {
+			config.MaxConns = numCPU
+		}
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_min_conns"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_min_conns")
+		n, err := strconv.ParseInt(s, 10, 32)
+		if err != nil {
+			return nil, pgconn.NewParseConfigError(connString, "cannot parse pool_min_conns", err)
+		}
+		config.MinConns = int32(n)
+	} else {
+		config.MinConns = defaultMinConns
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_min_idle_conns"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_min_idle_conns")
+		n, err := strconv.ParseInt(s, 10, 32)
+		if err != nil {
+			return nil, pgconn.NewParseConfigError(connString, "cannot parse pool_min_idle_conns", err)
+		}
+		config.MinIdleConns = int32(n)
+	} else {
+		config.MinIdleConns = defaultMinIdleConns
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_max_conn_lifetime"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_max_conn_lifetime")
+		d, err := time.ParseDuration(s)
+		if err != nil {
+			return nil, pgconn.NewParseConfigError(connString, "cannot parse pool_max_conn_lifetime", err)
+		}
+		config.MaxConnLifetime = d
+	} else {
+		config.MaxConnLifetime = defaultMaxConnLifetime
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_max_conn_idle_time"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_max_conn_idle_time")
+		d, err := time.ParseDuration(s)
+		if err != nil {
+			return nil, pgconn.NewParseConfigError(connString, "cannot parse pool_max_conn_idle_time", err)
+		}
+		config.MaxConnIdleTime = d
+	} else {
+		config.MaxConnIdleTime = defaultMaxConnIdleTime
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_health_check_period"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_health_check_period")
+		d, err := time.ParseDuration(s)
+		if err != nil {
+			return nil, pgconn.NewParseConfigError(connString, "cannot parse pool_health_check_period", err)
+		}
+		config.HealthCheckPeriod = d
+	} else {
+		config.HealthCheckPeriod = defaultHealthCheckPeriod
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_max_conn_lifetime_jitter"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_max_conn_lifetime_jitter")
+		d, err := time.ParseDuration(s)
+		if err != nil {
+			return nil, pgconn.NewParseConfigError(connString, "cannot parse pool_max_conn_lifetime_jitter", err)
+		}
+		config.MaxConnLifetimeJitter = d
+	}
+
+	return config, nil
+}
+
+// Close closes all connections in the pool and rejects future [Pool.Acquire] calls. Blocks until all connections are returned
+// to pool and closed.
+func (p *Pool) Close() {
+	p.closeOnce.Do(func() {
+		close(p.closeChan)
+		p.p.Close()
+	})
+}
+
+func (p *Pool) isExpired(res *puddle.Resource[*connResource]) bool {
+	return time.Now().After(res.Value().maxAgeTime)
+}
+
+func (p *Pool) triggerHealthCheck() {
+	const healthCheckDelay = 500 * time.Millisecond
+
+	p.healthCheckMu.Lock()
+	defer p.healthCheckMu.Unlock()
+
+	if p.healthCheckTimer == nil {
+		// Destroy is asynchronous so we give it time to actually remove itself from
+		// the pool otherwise we might try to check the pool size too soon
+		p.healthCheckTimer = time.AfterFunc(healthCheckDelay, func() {
+			select {
+			case <-p.closeChan:
+			case p.healthCheckChan <- struct{}{}:
+			default:
+			}
+		})
+		return
+	}
+
+	p.healthCheckTimer.Reset(healthCheckDelay)
+}
+
+func (p *Pool) backgroundHealthCheck() {
+	ticker := time.NewTicker(p.healthCheckPeriod)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-p.closeChan:
+			return
+		case <-p.healthCheckChan:
+			p.checkHealth()
+		case <-ticker.C:
+			p.checkHealth()
+		}
+	}
+}
+
+func (p *Pool) checkHealth() {
+	for {
+		// If checkMinConns failed we don't destroy any connections since we couldn't
+		// even get to minConns
+		if err := p.checkMinConns(); err != nil {
+			// Should we log this error somewhere?
+			break
+		}
+		if !p.checkConnsHealth() {
+			// Since we didn't destroy any connections we can stop looping
+			break
+		}
+		// Technically Destroy is asynchronous but 500ms should be enough for it to
+		// remove it from the underlying pool
+		select {
+		case <-p.closeChan:
+			return
+		case <-time.After(500 * time.Millisecond):
+		}
+	}
+}
+
+// checkConnsHealth will check all idle connections, destroy a connection if
+// it's idle or too old, and returns true if any were destroyed
+func (p *Pool) checkConnsHealth() bool {
+	var destroyed bool
+	totalConns := p.Stat().TotalConns()
+	resources := p.p.AcquireAllIdle()
+	for _, res := range resources {
+		// We're okay going under minConns if the lifetime is up
+		if p.isExpired(res) && totalConns >= p.minConns {
+			atomic.AddInt64(&p.lifetimeDestroyCount, 1)
+			res.Destroy()
+			destroyed = true
+			// Since Destroy is async we manually decrement totalConns.
+			totalConns--
+		} else if res.IdleDuration() > p.maxConnIdleTime && totalConns > p.minConns {
+			atomic.AddInt64(&p.idleDestroyCount, 1)
+			res.Destroy()
+			destroyed = true
+			// Since Destroy is async we manually decrement totalConns.
+			totalConns--
+		} else {
+			res.ReleaseUnused()
+		}
+	}
+	return destroyed
+}
+
+func (p *Pool) checkMinConns() error {
+	// TotalConns can include ones that are being destroyed but we should have
+	// sleep(500ms) around all of the destroys to help prevent that from throwing
+	// off this check
+
+	// Create the number of connections needed to get to both minConns and minIdleConns
+	stat := p.Stat()
+	toCreate := max(p.minConns-stat.TotalConns(), p.minIdleConns-stat.IdleConns())
+	if toCreate > 0 {
+		return p.createIdleResources(context.Background(), int(toCreate))
+	}
+	return nil
+}
+
+func (p *Pool) createIdleResources(parentCtx context.Context, targetResources int) error {
+	ctx, cancel := context.WithCancel(parentCtx)
+	defer cancel()
+
+	errs := make(chan error, targetResources)
+
+	for range targetResources {
+		go func() {
+			err := p.p.CreateResource(ctx)
+			// Ignore ErrNotAvailable since it means that the pool has become full since we started creating resource.
+			if err == puddle.ErrNotAvailable {
+				err = nil
+			}
+			errs <- err
+		}()
+	}
+
+	var firstError error
+	for range targetResources {
+		err := <-errs
+		if err != nil && firstError == nil {
+			cancel()
+			firstError = err
+		}
+	}
+
+	return firstError
+}
+
+// Acquire returns a connection ([Conn]) from the [Pool].
+func (p *Pool) Acquire(ctx context.Context) (c *Conn, err error) {
+	if p.acquireTracer != nil {
+		ctx = p.acquireTracer.TraceAcquireStart(ctx, p, TraceAcquireStartData{})
+		defer func() {
+			var conn *pgx.Conn
+			if c != nil {
+				conn = c.Conn()
+			}
+			p.acquireTracer.TraceAcquireEnd(ctx, p, TraceAcquireEndData{Conn: conn, Err: err})
+		}()
+	}
+
+	// Try to acquire from the connection pool up to maxConns + 1 times, so that
+	// any that fatal errors would empty the pool and still at least try 1 fresh
+	// connection.
+	for range int(p.maxConns) + 1 {
+		res, err := p.p.Acquire(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		cr := res.Value()
+
+		shouldPingParams := ShouldPingParams{Conn: cr.conn, IdleDuration: res.IdleDuration()}
+		if p.shouldPing(ctx, shouldPingParams) {
+			err := func() error {
+				pingCtx := ctx
+				if p.pingTimeout > 0 {
+					var cancel context.CancelFunc
+					pingCtx, cancel = context.WithTimeout(ctx, p.pingTimeout)
+					defer cancel()
+				}
+				return cr.conn.Ping(pingCtx)
+			}()
+			if err != nil {
+				res.Destroy()
+				continue
+			}
+		}
+
+		if p.prepareConn != nil {
+			ok, err := p.prepareConn(ctx, cr.conn)
+			if !ok {
+				res.Destroy()
+			}
+			if err != nil {
+				if ok {
+					res.Release()
+				}
+				return nil, err
+			}
+			if !ok {
+				continue
+			}
+		}
+
+		return cr.getConn(p, res), nil
+	}
+	return nil, errors.New("pgxpool: too many failed attempts acquiring connection; likely bug in PrepareConn, BeforeAcquire, or ShouldPing hook")
+}
+
+// AcquireFunc acquires a [Conn] and calls f with that [Conn]. ctx will only affect the [Pool.Acquire]. It has no effect on the
+// call of f. The return value is either an error acquiring the [Conn] or the return value of f. The [Conn] is
+// automatically released after the call of f.
+func (p *Pool) AcquireFunc(ctx context.Context, f func(*Conn) error) error {
+	conn, err := p.Acquire(ctx)
+	if err != nil {
+		return err
+	}
+	defer conn.Release()
+
+	return f(conn)
+}
+
+// AcquireAllIdle atomically acquires all currently idle connections. Its intended use is for health check and
+// keep-alive functionality. It does not update pool statistics.
+func (p *Pool) AcquireAllIdle(ctx context.Context) []*Conn {
+	resources := p.p.AcquireAllIdle()
+	conns := make([]*Conn, 0, len(resources))
+	for _, res := range resources {
+		cr := res.Value()
+		if p.prepareConn != nil {
+			ok, err := p.prepareConn(ctx, cr.conn)
+			if !ok || err != nil {
+				res.Destroy()
+				continue
+			}
+		}
+		conns = append(conns, cr.getConn(p, res))
+	}
+
+	return conns
+}
+
+// Reset closes all connections, but leaves the pool open. It is intended for use when an error is detected that would
+// disrupt all connections (such as a network interruption or a server state change).
+//
+// It is safe to reset a pool while connections are checked out. Those connections will be closed when they are returned
+// to the pool.
+func (p *Pool) Reset() {
+	p.p.Reset()
+}
+
+// Config returns a copy of config that was used to initialize this [Pool].
+func (p *Pool) Config() *Config { return p.config.Copy() }
+
+// Stat returns a pgxpool.Stat struct with a snapshot of Pool statistics.
+func (p *Pool) Stat() *Stat {
+	return &Stat{
+		s:                    p.p.Stat(),
+		newConnsCount:        atomic.LoadInt64(&p.newConnsCount),
+		lifetimeDestroyCount: atomic.LoadInt64(&p.lifetimeDestroyCount),
+		idleDestroyCount:     atomic.LoadInt64(&p.idleDestroyCount),
+	}
+}
+
+// Exec acquires a connection from the [Pool] and executes the given SQL.
+// SQL can be either a prepared statement name or an SQL string.
+// Arguments should be referenced positionally from the SQL string as $1, $2, etc.
+// The acquired connection is returned to the pool when the [Pool.Exec] function returns.
+func (p *Pool) Exec(ctx context.Context, sql string, arguments ...any) (pgconn.CommandTag, error) {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return pgconn.CommandTag{}, err
+	}
+	defer c.Release()
+
+	return c.Exec(ctx, sql, arguments...)
+}
+
+// Query acquires a connection and executes a query that returns [pgx.Rows].
+// Arguments should be referenced positionally from the SQL string as $1, $2, etc.
+// See [pgx.Rows] documentation to close the returned [pgx.Rows] and return the acquired connection to the [Pool].
+//
+// If there is an error, the returned [pgx.Rows] will be returned in an error state.
+// If preferred, ignore the error returned from [Pool.Query] and handle errors using the returned [pgx.Rows].
+//
+// For extra control over how the query is executed, the types [pgx.QueryExecMode], [pgx.QueryResultFormats], and
+// [pgx.QueryResultFormatsByOID] may be used as the first args to control exactly how the query is executed. This is rarely
+// needed. See the documentation for those types for details.
+func (p *Pool) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return errRows{err: err}, err
+	}
+
+	rows, err := c.Query(ctx, sql, args...)
+	if err != nil {
+		c.Release()
+		return errRows{err: err}, err
+	}
+
+	return c.getPoolRows(rows), nil
+}
+
+// QueryRow acquires a connection and executes a query that is expected
+// to return at most one row ([pgx.Row]). Errors are deferred until [pgx.Row]'s
+// Scan method is called. If the query selects no rows, [pgx.Row]'s Scan will
+// return [pgx.ErrNoRows]. Otherwise, [pgx.Row]'s Scan scans the first selected row
+// and discards the rest. The acquired connection is returned to the [Pool] when
+// [pgx.Row]'s Scan method is called.
+//
+// Arguments should be referenced positionally from the SQL string as $1, $2, etc.
+//
+// For extra control over how the query is executed, the types [pgx.QueryExecMode], [pgx.QueryResultFormats], and
+// [pgx.QueryResultFormatsByOID] may be used as the first args to control exactly how the query is executed. This is rarely
+// needed. See the documentation for those types for details.
+func (p *Pool) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return errRow{err: err}
+	}
+
+	row := c.QueryRow(ctx, sql, args...)
+	return c.getPoolRow(row)
+}
+
+func (p *Pool) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return errBatchResults{err: err}
+	}
+
+	br := c.SendBatch(ctx, b)
+	return &poolBatchResults{br: br, c: c}
+}
+
+// Begin acquires a connection from the [Pool] and starts a transaction. Unlike [database/sql], the context only affects the begin command. i.e. there is no
+// auto-rollback on context cancellation. Begin initiates a transaction block without explicitly setting a transaction mode for the block (see [Pool.BeginTx] with [pgx.TxOptions] if transaction mode is required).
+// [*Tx] is returned, which implements the [pgx.Tx] interface.
+// [Tx.Commit] or [Tx.Rollback] must be called on the returned transaction to finalize the transaction block.
+func (p *Pool) Begin(ctx context.Context) (pgx.Tx, error) {
+	return p.BeginTx(ctx, pgx.TxOptions{})
+}
+
+// BeginTx acquires a connection from the [Pool] and starts a transaction with [pgx.TxOptions] determining the transaction mode.
+// Unlike [database/sql], the context only affects the begin command. i.e. there is no auto-rollback on context cancellation.
+// [*Tx] is returned, which implements the [pgx.Tx] interface.
+// [Tx.Commit] or [Tx.Rollback] must be called on the returned transaction to finalize the transaction block.
+func (p *Pool) BeginTx(ctx context.Context, txOptions pgx.TxOptions) (pgx.Tx, error) {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	t, err := c.BeginTx(ctx, txOptions)
+	if err != nil {
+		c.Release()
+		return nil, err
+	}
+
+	return &Tx{t: t, c: c}, nil
+}
+
+func (p *Pool) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return 0, err
+	}
+	defer c.Release()
+
+	return c.Conn().CopyFrom(ctx, tableName, columnNames, rowSrc)
+}
+
+// Ping acquires a connection from the [Pool] and executes an empty sql statement against it.
+// If the sql returns without error, the database [Pool.Ping] is considered successful, otherwise, the error is returned.
+func (p *Pool) Ping(ctx context.Context) error {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return err
+	}
+	defer c.Release()
+	return c.Ping(ctx)
+}

vendor/github.com/jackc/pgx/v5/pgxpool/rows.go

@@ -0,0 +1,116 @@
+package pgxpool
+
+import (
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+)
+
+type errRows struct {
+	err error
+}
+
+func (errRows) Close()                                       {}
+func (e errRows) Err() error                                 { return e.err }
+func (errRows) CommandTag() pgconn.CommandTag                { return pgconn.CommandTag{} }
+func (errRows) FieldDescriptions() []pgconn.FieldDescription { return nil }
+func (errRows) Next() bool                                   { return false }
+func (e errRows) Scan(dest ...any) error                     { return e.err }
+func (e errRows) Values() ([]any, error)                     { return nil, e.err }
+func (e errRows) RawValues() [][]byte                        { return nil }
+func (e errRows) Conn() *pgx.Conn                            { return nil }
+
+type errRow struct {
+	err error
+}
+
+func (e errRow) Scan(dest ...any) error { return e.err }
+
+type poolRows struct {
+	r   pgx.Rows
+	c   *Conn
+	err error
+}
+
+func (rows *poolRows) Close() {
+	rows.r.Close()
+	if rows.c != nil {
+		rows.c.Release()
+		rows.c = nil
+	}
+}
+
+func (rows *poolRows) Err() error {
+	if rows.err != nil {
+		return rows.err
+	}
+	return rows.r.Err()
+}
+
+func (rows *poolRows) CommandTag() pgconn.CommandTag {
+	return rows.r.CommandTag()
+}
+
+func (rows *poolRows) FieldDescriptions() []pgconn.FieldDescription {
+	return rows.r.FieldDescriptions()
+}
+
+func (rows *poolRows) Next() bool {
+	if rows.err != nil {
+		return false
+	}
+
+	n := rows.r.Next()
+	if !n {
+		rows.Close()
+	}
+	return n
+}
+
+func (rows *poolRows) Scan(dest ...any) error {
+	err := rows.r.Scan(dest...)
+	if err != nil {
+		rows.Close()
+	}
+	return err
+}
+
+func (rows *poolRows) Values() ([]any, error) {
+	values, err := rows.r.Values()
+	if err != nil {
+		rows.Close()
+	}
+	return values, err
+}
+
+func (rows *poolRows) RawValues() [][]byte {
+	return rows.r.RawValues()
+}
+
+func (rows *poolRows) Conn() *pgx.Conn {
+	return rows.r.Conn()
+}
+
+type poolRow struct {
+	r   pgx.Row
+	c   *Conn
+	err error
+}
+
+func (row *poolRow) Scan(dest ...any) error {
+	if row.err != nil {
+		return row.err
+	}
+
+	panicked := true
+	defer func() {
+		if panicked && row.c != nil {
+			row.c.Release()
+		}
+	}()
+	err := row.r.Scan(dest...)
+	panicked = false
+	if row.c != nil {
+		row.c.Release()
+	}
+	return err
+}

vendor/github.com/jackc/pgx/v5/pgxpool/stat.go

@@ -0,0 +1,91 @@
+package pgxpool
+
+import (
+	"time"
+
+	"github.com/jackc/puddle/v2"
+)
+
+// Stat is a snapshot of Pool statistics.
+type Stat struct {
+	s                    *puddle.Stat
+	newConnsCount        int64
+	lifetimeDestroyCount int64
+	idleDestroyCount     int64
+}
+
+// AcquireCount returns the cumulative count of successful acquires from the pool.
+func (s *Stat) AcquireCount() int64 {
+	return s.s.AcquireCount()
+}
+
+// AcquireDuration returns the total duration of all successful acquires from
+// the pool.
+func (s *Stat) AcquireDuration() time.Duration {
+	return s.s.AcquireDuration()
+}
+
+// AcquiredConns returns the number of currently acquired connections in the pool.
+func (s *Stat) AcquiredConns() int32 {
+	return s.s.AcquiredResources()
+}
+
+// CanceledAcquireCount returns the cumulative count of acquires from the pool
+// that were canceled by a context.
+func (s *Stat) CanceledAcquireCount() int64 {
+	return s.s.CanceledAcquireCount()
+}
+
+// ConstructingConns returns the number of conns with construction in progress in
+// the pool.
+func (s *Stat) ConstructingConns() int32 {
+	return s.s.ConstructingResources()
+}
+
+// EmptyAcquireCount returns the cumulative count of successful acquires from the pool
+// that waited for a resource to be released or constructed because the pool was
+// empty.
+func (s *Stat) EmptyAcquireCount() int64 {
+	return s.s.EmptyAcquireCount()
+}
+
+// IdleConns returns the number of currently idle conns in the pool.
+func (s *Stat) IdleConns() int32 {
+	return s.s.IdleResources()
+}
+
+// MaxConns returns the maximum size of the pool.
+func (s *Stat) MaxConns() int32 {
+	return s.s.MaxResources()
+}
+
+// TotalConns returns the total number of resources currently in the pool.
+// The value is the sum of ConstructingConns, AcquiredConns, and
+// IdleConns.
+func (s *Stat) TotalConns() int32 {
+	return s.s.TotalResources()
+}
+
+// NewConnsCount returns the cumulative count of new connections opened.
+func (s *Stat) NewConnsCount() int64 {
+	return s.newConnsCount
+}
+
+// MaxLifetimeDestroyCount returns the cumulative count of connections destroyed
+// because they exceeded MaxConnLifetime.
+func (s *Stat) MaxLifetimeDestroyCount() int64 {
+	return s.lifetimeDestroyCount
+}
+
+// MaxIdleDestroyCount returns the cumulative count of connections destroyed because
+// they exceeded MaxConnIdleTime.
+func (s *Stat) MaxIdleDestroyCount() int64 {
+	return s.idleDestroyCount
+}
+
+// EmptyAcquireWaitTime returns the cumulative time waited for successful acquires
+// from the pool for a resource to be released or constructed because the pool was
+// empty.
+func (s *Stat) EmptyAcquireWaitTime() time.Duration {
+	return s.s.EmptyAcquireWaitTime()
+}

vendor/github.com/jackc/pgx/v5/pgxpool/tracer.go

@@ -0,0 +1,33 @@
+package pgxpool
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// AcquireTracer traces Acquire.
+type AcquireTracer interface {
+	// TraceAcquireStart is called at the beginning of Acquire.
+	// The returned context is used for the rest of the call and will be passed to the TraceAcquireEnd.
+	TraceAcquireStart(ctx context.Context, pool *Pool, data TraceAcquireStartData) context.Context
+	// TraceAcquireEnd is called when a connection has been acquired.
+	TraceAcquireEnd(ctx context.Context, pool *Pool, data TraceAcquireEndData)
+}
+
+type TraceAcquireStartData struct{}
+
+type TraceAcquireEndData struct {
+	Conn *pgx.Conn
+	Err  error
+}
+
+// ReleaseTracer traces Release.
+type ReleaseTracer interface {
+	// TraceRelease is called at the beginning of Release.
+	TraceRelease(pool *Pool, data TraceReleaseData)
+}
+
+type TraceReleaseData struct {
+	Conn *pgx.Conn
+}

vendor/github.com/jackc/pgx/v5/pgxpool/tx.go

@@ -0,0 +1,83 @@
+package pgxpool
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+)
+
+// Tx represents a database transaction acquired from a Pool.
+type Tx struct {
+	t pgx.Tx
+	c *Conn
+}
+
+// Begin starts a pseudo nested transaction implemented with a savepoint.
+func (tx *Tx) Begin(ctx context.Context) (pgx.Tx, error) {
+	return tx.t.Begin(ctx)
+}
+
+// Commit commits the transaction and returns the associated connection back to the Pool. Commit will return an error
+// where errors.Is(ErrTxClosed) is true if the Tx is already closed, but is otherwise safe to call multiple times. If
+// the commit fails with a rollback status (e.g. the transaction was already in a broken state) then ErrTxCommitRollback
+// will be returned.
+func (tx *Tx) Commit(ctx context.Context) error {
+	err := tx.t.Commit(ctx)
+	if tx.c != nil {
+		tx.c.Release()
+		tx.c = nil
+	}
+	return err
+}
+
+// Rollback rolls back the transaction and returns the associated connection back to the Pool. Rollback will return
+// where an error where errors.Is(ErrTxClosed) is true if the Tx is already closed, but is otherwise safe to call
+// multiple times. Hence, defer tx.Rollback() is safe even if tx.Commit() will be called first in a non-error condition.
+func (tx *Tx) Rollback(ctx context.Context) error {
+	err := tx.t.Rollback(ctx)
+	if tx.c != nil {
+		tx.c.Release()
+		tx.c = nil
+	}
+	return err
+}
+
+func (tx *Tx) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
+	return tx.t.CopyFrom(ctx, tableName, columnNames, rowSrc)
+}
+
+func (tx *Tx) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
+	return tx.t.SendBatch(ctx, b)
+}
+
+func (tx *Tx) LargeObjects() pgx.LargeObjects {
+	return tx.t.LargeObjects()
+}
+
+// Prepare creates a prepared statement with name and sql. If the name is empty,
+// an anonymous prepared statement will be used. sql can contain placeholders
+// for bound parameters. These placeholders are referenced positionally as $1, $2, etc.
+//
+// Prepare is idempotent; i.e. it is safe to call Prepare multiple times with the same
+// name and sql arguments. This allows a code path to Prepare and Query/Exec without
+// needing to first check whether the statement has already been prepared.
+func (tx *Tx) Prepare(ctx context.Context, name, sql string) (*pgconn.StatementDescription, error) {
+	return tx.t.Prepare(ctx, name, sql)
+}
+
+func (tx *Tx) Exec(ctx context.Context, sql string, arguments ...any) (pgconn.CommandTag, error) {
+	return tx.t.Exec(ctx, sql, arguments...)
+}
+
+func (tx *Tx) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
+	return tx.t.Query(ctx, sql, args...)
+}
+
+func (tx *Tx) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row {
+	return tx.t.QueryRow(ctx, sql, args...)
+}
+
+func (tx *Tx) Conn() *pgx.Conn {
+	return tx.t.Conn()
+}

vendor/github.com/jackc/pgx/v5/stdlib/sql.go

@@ -0,0 +1,909 @@
+// Package stdlib is the compatibility layer from pgx to database/sql.
+//
+// A database/sql connection can be established through sql.Open.
+//
+//	db, err := sql.Open("pgx", "postgres://pgx_md5:secret@localhost:5432/pgx_test?sslmode=disable")
+//	if err != nil {
+//	  return err
+//	}
+//
+// Or from a keyword/value string.
+//
+//	db, err := sql.Open("pgx", "user=postgres password=secret host=localhost port=5432 database=pgx_test sslmode=disable")
+//	if err != nil {
+//	  return err
+//	}
+//
+// Or from a *pgxpool.Pool.
+//
+//	pool, err := pgxpool.New(context.Background(), os.Getenv("DATABASE_URL"))
+//	if err != nil {
+//	  return err
+//	}
+//
+//	db := stdlib.OpenDBFromPool(pool)
+//
+// Or a pgx.ConnConfig can be used to set configuration not accessible via connection string. In this case the
+// pgx.ConnConfig must first be registered with the driver. This registration returns a connection string which is used
+// with sql.Open.
+//
+//	connConfig, _ := pgx.ParseConfig(os.Getenv("DATABASE_URL"))
+//	connConfig.Tracer = &tracelog.TraceLog{Logger: myLogger, LogLevel: tracelog.LogLevelInfo}
+//	connStr := stdlib.RegisterConnConfig(connConfig)
+//	db, _ := sql.Open("pgx", connStr)
+//
+// pgx uses standard PostgreSQL positional parameters in queries. e.g. $1, $2. It does not support named parameters.
+//
+//	db.QueryRow("select * from users where id=$1", userID)
+//
+// (*sql.Conn) Raw() can be used to get a *pgx.Conn from the standard database/sql.DB connection pool. This allows
+// operations that use pgx specific functionality.
+//
+//	// Given db is a *sql.DB
+//	conn, err := db.Conn(context.Background())
+//	if err != nil {
+//	  // handle error from acquiring connection from DB pool
+//	}
+//
+//	err = conn.Raw(func(driverConn any) error {
+//	  conn := driverConn.(*stdlib.Conn).Conn() // conn is a *pgx.Conn
+//	  // Do pgx specific stuff with conn
+//	  conn.CopyFrom(...)
+//	  return nil
+//	})
+//	if err != nil {
+//	  // handle error that occurred while using *pgx.Conn
+//	}
+//
+// # PostgreSQL Specific Data Types
+//
+// The pgtype package provides support for PostgreSQL specific types. *pgtype.Map.SQLScanner is an adapter that makes
+// these types usable as a sql.Scanner.
+//
+//	m := pgtype.NewMap()
+//	var a []int64
+//	err := db.QueryRow("select '{1,2,3}'::bigint[]").Scan(m.SQLScanner(&a))
+package stdlib
+
+import (
+	"context"
+	"database/sql"
+	"database/sql/driver"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"math/rand/v2"
+	"reflect"
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Only intrinsic types should be binary format with database/sql.
+var databaseSQLResultFormats pgx.QueryResultFormatsByOID
+
+var pgxDriver *Driver
+
+func init() {
+	pgxDriver = &Driver{
+		configs: make(map[string]*pgx.ConnConfig),
+	}
+
+	// if pgx driver was already registered by different pgx major version then we
+	// skip registration under the default name.
+	if !slices.Contains(sql.Drivers(), "pgx") {
+		sql.Register("pgx", pgxDriver)
+	}
+	sql.Register("pgx/v5", pgxDriver)
+
+	databaseSQLResultFormats = pgx.QueryResultFormatsByOID{
+		pgtype.BoolOID:        1,
+		pgtype.ByteaOID:       1,
+		pgtype.CIDOID:         1,
+		pgtype.DateOID:        1,
+		pgtype.Float4OID:      1,
+		pgtype.Float8OID:      1,
+		pgtype.Int2OID:        1,
+		pgtype.Int4OID:        1,
+		pgtype.Int8OID:        1,
+		pgtype.OIDOID:         1,
+		pgtype.TimestampOID:   1,
+		pgtype.TimestamptzOID: 1,
+		pgtype.XIDOID:         1,
+	}
+}
+
+// OptionOpenDB options for configuring the driver when opening a new db pool.
+type OptionOpenDB func(*connector)
+
+// ShouldPingParams are passed to OptionShouldPing to decide whether to ping before reusing a connection.
+type ShouldPingParams struct {
+	// Conn is the underlying pgx connection.
+	Conn *pgx.Conn
+	// IdleDuration is how long it has been since ResetSession last ran.
+	IdleDuration time.Duration
+}
+
+// OptionShouldPing controls whether stdlib should issue a liveness ping before reusing a connection.
+// If the function returns true, stdlib will ping.
+// If it returns false, stdlib will skip the ping.
+// If not provided, default is ping only when IdleDuration > 1s.
+func OptionShouldPing(f func(context.Context, ShouldPingParams) bool) OptionOpenDB {
+	return func(dc *connector) { dc.ShouldPing = f }
+}
+
+// OptionBeforeConnect provides a callback for before connect. It is passed a shallow copy of the ConnConfig that will
+// be used to connect, so only its immediate members should be modified. Used only if db is opened with *pgx.ConnConfig.
+func OptionBeforeConnect(bc func(context.Context, *pgx.ConnConfig) error) OptionOpenDB {
+	return func(dc *connector) {
+		dc.BeforeConnect = bc
+	}
+}
+
+// OptionAfterConnect provides a callback for after connect. Used only if db is opened with *pgx.ConnConfig.
+func OptionAfterConnect(ac func(context.Context, *pgx.Conn) error) OptionOpenDB {
+	return func(dc *connector) {
+		dc.AfterConnect = ac
+	}
+}
+
+// OptionResetSession provides a callback that can be used to add custom logic prior to executing a query on the
+// connection if the connection has been used before.
+// If ResetSessionFunc returns ErrBadConn error the connection will be discarded.
+func OptionResetSession(rs func(context.Context, *pgx.Conn) error) OptionOpenDB {
+	return func(dc *connector) {
+		dc.ResetSession = rs
+	}
+}
+
+// RandomizeHostOrderFunc is a BeforeConnect hook that randomizes the host order in the provided connConfig, so that a
+// new host becomes primary each time. This is useful to distribute connections for multi-master databases like
+// CockroachDB. If you use this you likely should set https://golang.org/pkg/database/sql/#DB.SetConnMaxLifetime as well
+// to ensure that connections are periodically rebalanced across your nodes.
+func RandomizeHostOrderFunc(ctx context.Context, connConfig *pgx.ConnConfig) error {
+	if len(connConfig.Fallbacks) == 0 {
+		return nil
+	}
+
+	newFallbacks := append([]*pgconn.FallbackConfig{{
+		Host:      connConfig.Host,
+		Port:      connConfig.Port,
+		TLSConfig: connConfig.TLSConfig,
+	}}, connConfig.Fallbacks...)
+
+	rand.Shuffle(len(newFallbacks), func(i, j int) {
+		newFallbacks[i], newFallbacks[j] = newFallbacks[j], newFallbacks[i]
+	})
+
+	// Use the one that sorted last as the primary and keep the rest as the fallbacks
+	newPrimary := newFallbacks[len(newFallbacks)-1]
+	connConfig.Host = newPrimary.Host
+	connConfig.Port = newPrimary.Port
+	connConfig.TLSConfig = newPrimary.TLSConfig
+	connConfig.Fallbacks = newFallbacks[:len(newFallbacks)-1]
+	return nil
+}
+
+func GetConnector(config pgx.ConnConfig, opts ...OptionOpenDB) driver.Connector {
+	c := connector{
+		ConnConfig:    config,
+		BeforeConnect: func(context.Context, *pgx.ConnConfig) error { return nil }, // noop before connect by default
+		AfterConnect:  func(context.Context, *pgx.Conn) error { return nil },       // noop after connect by default
+		ResetSession:  func(context.Context, *pgx.Conn) error { return nil },       // noop reset session by default
+		driver:        pgxDriver,
+	}
+
+	for _, opt := range opts {
+		opt(&c)
+	}
+	return c
+}
+
+// GetPoolConnector creates a new driver.Connector from the given *pgxpool.Pool. By using this be sure to set the
+// maximum idle connections of the *sql.DB created with this connector to zero since they must be managed from the
+// *pgxpool.Pool. This is required to avoid acquiring all the connections from the pgxpool and starving any direct
+// users of the pgxpool.
+func GetPoolConnector(pool *pgxpool.Pool, opts ...OptionOpenDB) driver.Connector {
+	c := connector{
+		pool:         pool,
+		ResetSession: func(context.Context, *pgx.Conn) error { return nil }, // noop reset session by default
+		driver:       pgxDriver,
+	}
+
+	for _, opt := range opts {
+		opt(&c)
+	}
+
+	return c
+}
+
+func OpenDB(config pgx.ConnConfig, opts ...OptionOpenDB) *sql.DB {
+	c := GetConnector(config, opts...)
+	return sql.OpenDB(c)
+}
+
+// OpenDBFromPool creates a new *sql.DB from the given *pgxpool.Pool. Note that this method automatically sets the
+// maximum number of idle connections in *sql.DB to zero, since they must be managed from the *pgxpool.Pool. This is
+// required to avoid acquiring all the connections from the pgxpool and starving any direct users of the pgxpool. Note
+// that closing the returned *sql.DB will not close the *pgxpool.Pool.
+func OpenDBFromPool(pool *pgxpool.Pool, opts ...OptionOpenDB) *sql.DB {
+	c := GetPoolConnector(pool, opts...)
+	db := sql.OpenDB(c)
+	db.SetMaxIdleConns(0)
+	return db
+}
+
+type connector struct {
+	pgx.ConnConfig
+	pool          *pgxpool.Pool
+	BeforeConnect func(context.Context, *pgx.ConnConfig) error // function to call before creation of every new connection
+	AfterConnect  func(context.Context, *pgx.Conn) error       // function to call after creation of every new connection
+	ResetSession  func(context.Context, *pgx.Conn) error       // function is called before a connection is reused
+	ShouldPing    func(context.Context, ShouldPingParams) bool // function to decide if stdlib should ping before reusing a connection
+	driver        *Driver
+}
+
+// Connect implement driver.Connector interface
+func (c connector) Connect(ctx context.Context) (driver.Conn, error) {
+	var (
+		connConfig pgx.ConnConfig
+		conn       *pgx.Conn
+		close      func(context.Context) error
+		err        error
+	)
+
+	if c.pool == nil {
+		// Create a shallow copy of the config, so that BeforeConnect can safely modify it
+		connConfig = c.ConnConfig
+
+		if err = c.BeforeConnect(ctx, &connConfig); err != nil {
+			return nil, err
+		}
+
+		if conn, err = pgx.ConnectConfig(ctx, &connConfig); err != nil {
+			return nil, err
+		}
+
+		if err = c.AfterConnect(ctx, conn); err != nil {
+			return nil, err
+		}
+
+		close = conn.Close
+	} else {
+		var pconn *pgxpool.Conn
+
+		pconn, err = c.pool.Acquire(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		conn = pconn.Conn()
+
+		close = func(_ context.Context) error {
+			pconn.Release()
+			return nil
+		}
+	}
+
+	return &Conn{
+		conn:             conn,
+		close:            close,
+		driver:           c.driver,
+		connConfig:       connConfig,
+		resetSessionFunc: c.ResetSession,
+		shouldPing:       c.ShouldPing,
+		psRefCounts:      make(map[*pgconn.StatementDescription]int),
+	}, nil
+}
+
+// Driver implement driver.Connector interface
+func (c connector) Driver() driver.Driver {
+	return c.driver
+}
+
+// GetDefaultDriver returns the driver initialized in the init function
+// and used when the pgx driver is registered.
+func GetDefaultDriver() driver.Driver {
+	return pgxDriver
+}
+
+type Driver struct {
+	configMutex sync.Mutex
+	configs     map[string]*pgx.ConnConfig
+	sequence    int
+}
+
+func (d *Driver) Open(name string) (driver.Conn, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) // Ensure eventual timeout
+	defer cancel()
+
+	connector, err := d.OpenConnector(name)
+	if err != nil {
+		return nil, err
+	}
+	return connector.Connect(ctx)
+}
+
+func (d *Driver) OpenConnector(name string) (driver.Connector, error) {
+	return &driverConnector{driver: d, name: name}, nil
+}
+
+func (d *Driver) registerConnConfig(c *pgx.ConnConfig) string {
+	d.configMutex.Lock()
+	connStr := fmt.Sprintf("registeredConnConfig%d", d.sequence)
+	d.sequence++
+	d.configs[connStr] = c
+	d.configMutex.Unlock()
+	return connStr
+}
+
+func (d *Driver) unregisterConnConfig(connStr string) {
+	d.configMutex.Lock()
+	delete(d.configs, connStr)
+	d.configMutex.Unlock()
+}
+
+type driverConnector struct {
+	driver *Driver
+	name   string
+}
+
+func (dc *driverConnector) Connect(ctx context.Context) (driver.Conn, error) {
+	var connConfig *pgx.ConnConfig
+
+	dc.driver.configMutex.Lock()
+	connConfig = dc.driver.configs[dc.name]
+	dc.driver.configMutex.Unlock()
+
+	if connConfig == nil {
+		var err error
+		connConfig, err = pgx.ParseConfig(dc.name)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	conn, err := pgx.ConnectConfig(ctx, connConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	c := &Conn{
+		conn:             conn,
+		close:            conn.Close,
+		driver:           dc.driver,
+		connConfig:       *connConfig,
+		resetSessionFunc: func(context.Context, *pgx.Conn) error { return nil },
+		psRefCounts:      make(map[*pgconn.StatementDescription]int),
+	}
+
+	return c, nil
+}
+
+func (dc *driverConnector) Driver() driver.Driver {
+	return dc.driver
+}
+
+// RegisterConnConfig registers a ConnConfig and returns the connection string to use with Open.
+func RegisterConnConfig(c *pgx.ConnConfig) string {
+	return pgxDriver.registerConnConfig(c)
+}
+
+// UnregisterConnConfig removes the ConnConfig registration for connStr.
+func UnregisterConnConfig(connStr string) {
+	pgxDriver.unregisterConnConfig(connStr)
+}
+
+type Conn struct {
+	conn                 *pgx.Conn
+	close                func(context.Context) error
+	driver               *Driver
+	connConfig           pgx.ConnConfig
+	resetSessionFunc     func(context.Context, *pgx.Conn) error       // Function is called before a connection is reused
+	shouldPing           func(context.Context, ShouldPingParams) bool // Function to decide if stdlib should ping before reusing a connection
+	lastResetSessionTime time.Time
+
+	// psRefCounts contains reference counts for prepared statements. Prepare uses the underlying pgx logic to generate
+	// deterministic statement names from the statement text. If this query has already been prepared then the existing
+	// *pgconn.StatementDescription will be returned. However, this means that if Close is called on the returned Stmt
+	// then the underlying prepared statement will be closed even when the underlying prepared statement is still in use
+	// by another database/sql Stmt. To prevent this psRefCounts keeps track of how many database/sql statements are using
+	// the same underlying statement and only closes the underlying statement when the reference count reaches 0.
+	psRefCounts map[*pgconn.StatementDescription]int
+}
+
+// Conn returns the underlying *pgx.Conn
+func (c *Conn) Conn() *pgx.Conn {
+	return c.conn
+}
+
+func (c *Conn) Prepare(query string) (driver.Stmt, error) {
+	return c.PrepareContext(context.Background(), query)
+}
+
+func (c *Conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
+	if c.conn.IsClosed() {
+		return nil, driver.ErrBadConn
+	}
+
+	sd, err := c.conn.Prepare(ctx, query, query)
+	if err != nil {
+		return nil, err
+	}
+	c.psRefCounts[sd]++
+
+	return &Stmt{sd: sd, conn: c}, nil
+}
+
+func (c *Conn) Close() error {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+	return c.close(ctx)
+}
+
+func (c *Conn) Begin() (driver.Tx, error) {
+	return c.BeginTx(context.Background(), driver.TxOptions{})
+}
+
+func (c *Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
+	if c.conn.IsClosed() {
+		return nil, driver.ErrBadConn
+	}
+
+	var pgxOpts pgx.TxOptions
+	switch sql.IsolationLevel(opts.Isolation) {
+	case sql.LevelDefault:
+	case sql.LevelReadUncommitted:
+		pgxOpts.IsoLevel = pgx.ReadUncommitted
+	case sql.LevelReadCommitted:
+		pgxOpts.IsoLevel = pgx.ReadCommitted
+	case sql.LevelRepeatableRead, sql.LevelSnapshot:
+		pgxOpts.IsoLevel = pgx.RepeatableRead
+	case sql.LevelSerializable:
+		pgxOpts.IsoLevel = pgx.Serializable
+	default:
+		return nil, fmt.Errorf("unsupported isolation: %v", opts.Isolation)
+	}
+
+	if opts.ReadOnly {
+		pgxOpts.AccessMode = pgx.ReadOnly
+	}
+
+	tx, err := c.conn.BeginTx(ctx, pgxOpts)
+	if err != nil {
+		return nil, err
+	}
+
+	return wrapTx{ctx: ctx, tx: tx}, nil
+}
+
+func (c *Conn) ExecContext(ctx context.Context, query string, argsV []driver.NamedValue) (driver.Result, error) {
+	if c.conn.IsClosed() {
+		return nil, driver.ErrBadConn
+	}
+
+	args := make([]any, len(argsV))
+	convertNamedArguments(args, argsV)
+
+	commandTag, err := c.conn.Exec(ctx, query, args...)
+	// if we got a network error before we had a chance to send the query, retry
+	if err != nil {
+		if pgconn.SafeToRetry(err) {
+			return nil, driver.ErrBadConn
+		}
+	}
+	return driver.RowsAffected(commandTag.RowsAffected()), err
+}
+
+func (c *Conn) QueryContext(ctx context.Context, query string, argsV []driver.NamedValue) (driver.Rows, error) {
+	if c.conn.IsClosed() {
+		return nil, driver.ErrBadConn
+	}
+
+	args := make([]any, 1+len(argsV))
+	args[0] = databaseSQLResultFormats
+	convertNamedArguments(args[1:], argsV)
+
+	rows, err := c.conn.Query(ctx, query, args...)
+	if err != nil {
+		if pgconn.SafeToRetry(err) {
+			return nil, driver.ErrBadConn
+		}
+		return nil, err
+	}
+
+	// Preload first row because otherwise we won't know what columns are available when database/sql asks.
+	more := rows.Next()
+	if err = rows.Err(); err != nil {
+		rows.Close()
+		return nil, err
+	}
+	return &Rows{conn: c, rows: rows, skipNext: true, skipNextMore: more}, nil
+}
+
+func (c *Conn) Ping(ctx context.Context) error {
+	if c.conn.IsClosed() {
+		return driver.ErrBadConn
+	}
+
+	err := c.conn.Ping(ctx)
+	if err != nil {
+		// A Ping failure implies some sort of fatal state. The connection is almost certainly already closed by the
+		// failure, but manually close it just to be sure.
+		c.Close()
+		return driver.ErrBadConn
+	}
+
+	return nil
+}
+
+func (c *Conn) CheckNamedValue(*driver.NamedValue) error {
+	// Underlying pgx supports sql.Scanner and driver.Valuer interfaces natively. So everything can be passed through directly.
+	return nil
+}
+
+func (c *Conn) ResetSession(ctx context.Context) error {
+	if c.conn.IsClosed() {
+		return driver.ErrBadConn
+	}
+
+	// Discard connection if it has an open transaction. This can happen if the
+	// application did not properly commit or rollback a transaction.
+	if c.conn.PgConn().TxStatus() != 'I' {
+		return driver.ErrBadConn
+	}
+
+	now := time.Now()
+	idle := now.Sub(c.lastResetSessionTime)
+
+	doPing := idle > time.Second // default behavior: ping only if idle > 1s
+
+	if c.shouldPing != nil {
+		doPing = c.shouldPing(ctx, ShouldPingParams{
+			Conn:         c.conn,
+			IdleDuration: idle,
+		})
+	}
+
+	if doPing {
+		if err := c.conn.PgConn().Ping(ctx); err != nil {
+			return driver.ErrBadConn
+		}
+	}
+
+	c.lastResetSessionTime = now
+
+	return c.resetSessionFunc(ctx, c.conn)
+}
+
+type Stmt struct {
+	sd   *pgconn.StatementDescription
+	conn *Conn
+}
+
+func (s *Stmt) Close() error {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+
+	refCount := s.conn.psRefCounts[s.sd]
+	if refCount == 1 {
+		delete(s.conn.psRefCounts, s.sd)
+	} else {
+		s.conn.psRefCounts[s.sd]--
+		return nil
+	}
+
+	return s.conn.conn.Deallocate(ctx, s.sd.SQL)
+}
+
+func (s *Stmt) NumInput() int {
+	return len(s.sd.ParamOIDs)
+}
+
+func (s *Stmt) Exec(argsV []driver.Value) (driver.Result, error) {
+	return nil, errors.New("Stmt.Exec deprecated and not implemented")
+}
+
+func (s *Stmt) ExecContext(ctx context.Context, argsV []driver.NamedValue) (driver.Result, error) {
+	return s.conn.ExecContext(ctx, s.sd.SQL, argsV)
+}
+
+func (s *Stmt) Query(argsV []driver.Value) (driver.Rows, error) {
+	return nil, errors.New("Stmt.Query deprecated and not implemented")
+}
+
+func (s *Stmt) QueryContext(ctx context.Context, argsV []driver.NamedValue) (driver.Rows, error) {
+	return s.conn.QueryContext(ctx, s.sd.SQL, argsV)
+}
+
+type rowValueFunc func(src []byte) (driver.Value, error)
+
+type Rows struct {
+	conn         *Conn
+	rows         pgx.Rows
+	valueFuncs   []rowValueFunc
+	skipNext     bool
+	skipNextMore bool
+
+	columnNames []string
+}
+
+func (r *Rows) Columns() []string {
+	if r.columnNames == nil {
+		fields := r.rows.FieldDescriptions()
+		r.columnNames = make([]string, len(fields))
+		for i, fd := range fields {
+			r.columnNames[i] = string(fd.Name)
+		}
+	}
+
+	return r.columnNames
+}
+
+// ColumnTypeDatabaseTypeName returns the database system type name. If the name is unknown the OID is returned.
+func (r *Rows) ColumnTypeDatabaseTypeName(index int) string {
+	if dt, ok := r.conn.conn.TypeMap().TypeForOID(r.rows.FieldDescriptions()[index].DataTypeOID); ok {
+		return strings.ToUpper(dt.Name)
+	}
+
+	return strconv.FormatInt(int64(r.rows.FieldDescriptions()[index].DataTypeOID), 10)
+}
+
+const varHeaderSize = 4
+
+// ColumnTypeLength returns the length of the column type if the column is a
+// variable length type. If the column is not a variable length type ok
+// should return false.
+func (r *Rows) ColumnTypeLength(index int) (int64, bool) {
+	fd := r.rows.FieldDescriptions()[index]
+
+	switch fd.DataTypeOID {
+	case pgtype.TextOID, pgtype.ByteaOID:
+		return math.MaxInt64, true
+	case pgtype.VarcharOID, pgtype.BPCharOID:
+		return int64(fd.TypeModifier - varHeaderSize), true
+	case pgtype.VarbitOID:
+		return int64(fd.TypeModifier), true
+	default:
+		return 0, false
+	}
+}
+
+// ColumnTypePrecisionScale should return the precision and scale for decimal
+// types. If not applicable, ok should be false.
+func (r *Rows) ColumnTypePrecisionScale(index int) (precision, scale int64, ok bool) {
+	fd := r.rows.FieldDescriptions()[index]
+
+	switch fd.DataTypeOID {
+	case pgtype.NumericOID:
+		mod := fd.TypeModifier - varHeaderSize
+		precision = int64((mod >> 16) & 0xffff)
+		scale = int64(mod & 0xffff)
+		return precision, scale, true
+	default:
+		return 0, 0, false
+	}
+}
+
+// ColumnTypeScanType returns the value type that can be used to scan types into.
+func (r *Rows) ColumnTypeScanType(index int) reflect.Type {
+	fd := r.rows.FieldDescriptions()[index]
+
+	switch fd.DataTypeOID {
+	case pgtype.Float8OID:
+		return reflect.TypeFor[float64]()
+	case pgtype.Float4OID:
+		return reflect.TypeFor[float32]()
+	case pgtype.Int8OID:
+		return reflect.TypeFor[int64]()
+	case pgtype.Int4OID:
+		return reflect.TypeFor[int32]()
+	case pgtype.Int2OID:
+		return reflect.TypeFor[int16]()
+	case pgtype.BoolOID:
+		return reflect.TypeFor[bool]()
+	case pgtype.NumericOID:
+		return reflect.TypeFor[float64]()
+	case pgtype.DateOID, pgtype.TimestampOID, pgtype.TimestamptzOID:
+		return reflect.TypeFor[time.Time]()
+	case pgtype.ByteaOID:
+		return reflect.TypeFor[[]byte]()
+	default:
+		return reflect.TypeFor[string]()
+	}
+}
+
+func (r *Rows) Close() error {
+	r.rows.Close()
+	return r.rows.Err()
+}
+
+func (r *Rows) Next(dest []driver.Value) error {
+	m := r.conn.conn.TypeMap()
+	fieldDescriptions := r.rows.FieldDescriptions()
+
+	if r.valueFuncs == nil {
+		r.valueFuncs = make([]rowValueFunc, len(fieldDescriptions))
+
+		for i, fd := range fieldDescriptions {
+			dataTypeOID := fd.DataTypeOID
+			format := fd.Format
+
+			switch fd.DataTypeOID {
+			case pgtype.BoolOID:
+				var d bool
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					return d, err
+				}
+			case pgtype.ByteaOID:
+				var d []byte
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					return d, err
+				}
+			case pgtype.CIDOID, pgtype.OIDOID, pgtype.XIDOID:
+				var d pgtype.Uint32
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					if err != nil {
+						return nil, err
+					}
+					return d.Value()
+				}
+			case pgtype.DateOID:
+				var d pgtype.Date
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					if err != nil {
+						return nil, err
+					}
+					return d.Value()
+				}
+			case pgtype.Float4OID:
+				var d float32
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					return float64(d), err
+				}
+			case pgtype.Float8OID:
+				var d float64
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					return d, err
+				}
+			case pgtype.Int2OID:
+				var d int16
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					return int64(d), err
+				}
+			case pgtype.Int4OID:
+				var d int32
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					return int64(d), err
+				}
+			case pgtype.Int8OID:
+				var d int64
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					return d, err
+				}
+			case pgtype.JSONOID, pgtype.JSONBOID:
+				var d []byte
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					if err != nil {
+						return nil, err
+					}
+					return d, nil
+				}
+			case pgtype.TimestampOID:
+				var d pgtype.Timestamp
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					if err != nil {
+						return nil, err
+					}
+					return d.Value()
+				}
+			case pgtype.TimestamptzOID:
+				var d pgtype.Timestamptz
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					if err != nil {
+						return nil, err
+					}
+					return d.Value()
+				}
+			case pgtype.XMLOID:
+				var d []byte
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					if err != nil {
+						return nil, err
+					}
+					return d, nil
+				}
+			default:
+				var d string
+				scanPlan := m.PlanScan(dataTypeOID, format, &d)
+				r.valueFuncs[i] = func(src []byte) (driver.Value, error) {
+					err := scanPlan.Scan(src, &d)
+					return d, err
+				}
+			}
+		}
+	}
+
+	var more bool
+	if r.skipNext {
+		more = r.skipNextMore
+		r.skipNext = false
+	} else {
+		more = r.rows.Next()
+	}
+
+	if !more {
+		if r.rows.Err() == nil {
+			return io.EOF
+		} else {
+			return r.rows.Err()
+		}
+	}
+
+	for i, rv := range r.rows.RawValues() {
+		if rv != nil {
+			var err error
+			dest[i], err = r.valueFuncs[i](rv)
+			if err != nil {
+				return fmt.Errorf("convert field %d failed: %w", i, err)
+			}
+		} else {
+			dest[i] = nil
+		}
+	}
+
+	return nil
+}
+
+func convertNamedArguments(args []any, argsV []driver.NamedValue) {
+	for i, v := range argsV {
+		if v.Value != nil {
+			args[i] = v.Value.(any)
+		} else {
+			args[i] = nil
+		}
+	}
+}
+
+type wrapTx struct {
+	ctx context.Context
+	tx  pgx.Tx
+}
+
+func (wtx wrapTx) Commit() error { return wtx.tx.Commit(wtx.ctx) }
+
+func (wtx wrapTx) Rollback() error { return wtx.tx.Rollback(wtx.ctx) }

vendor/github.com/jackc/puddle/v2/CHANGELOG.md

@@ -0,0 +1,79 @@
+# 2.2.2 (September 10, 2024)
+
+* Add empty acquire time to stats (Maxim Ivanov)
+* Stop importing nanotime from runtime via linkname (maypok86)
+
+# 2.2.1 (July 15, 2023)
+
+* Fix: CreateResource cannot overflow pool. This changes documented behavior of CreateResource. Previously,
+  CreateResource could create a resource even if the pool was full. This could cause the pool to overflow. While this
+  was documented, it was documenting incorrect behavior. CreateResource now returns an error if the pool is full.
+
+# 2.2.0 (February 11, 2023)
+
+* Use Go 1.19 atomics and drop go.uber.org/atomic dependency
+
+# 2.1.2 (November 12, 2022)
+
+* Restore support to Go 1.18 via go.uber.org/atomic
+
+# 2.1.1 (November 11, 2022)
+
+* Fix create resource concurrently with Stat call race
+
+# 2.1.0 (October 28, 2022)
+
+* Concurrency control is now implemented with a semaphore. This simplifies some internal logic, resolves a few error conditions (including a deadlock), and improves performance. (Jan Dubsky)
+* Go 1.19 is now required for the improved atomic support.
+
+# 2.0.1 (October 28, 2022)
+
+* Fix race condition when Close is called concurrently with multiple constructors
+
+# 2.0.0 (September 17, 2022)
+
+* Use generics instead of interface{} (Столяров Владимир Алексеевич)
+* Add Reset
+* Do not cancel resource construction when Acquire is canceled
+* NewPool takes Config
+
+# 1.3.0 (August 27, 2022)
+
+* Acquire creates resources in background to allow creation to continue after Acquire is canceled (James Hartig)
+
+# 1.2.1 (December 2, 2021)
+
+* TryAcquire now does not block when background constructing resource
+
+# 1.2.0 (November 20, 2021)
+
+* Add TryAcquire (A. Jensen)
+* Fix: remove memory leak / unintentionally pinned memory when shrinking slices (Alexander Staubo)
+* Fix: Do not leave pool locked after panic from nil context
+
+# 1.1.4 (September 11, 2021)
+
+* Fix: Deadlock in CreateResource if pool was closed during resource acquisition (Dmitriy Matrenichev)
+
+# 1.1.3 (December 3, 2020)
+
+* Fix: Failed resource creation could cause concurrent Acquire to hang. (Evgeny Vanslov)
+
+# 1.1.2 (September 26, 2020)
+
+* Fix: Resource.Destroy no longer removes itself from the pool before its destructor has completed.
+* Fix: Prevent crash when pool is closed while resource is being created.
+
+# 1.1.1 (April 2, 2020)
+
+* Pool.Close can be safely called multiple times
+* AcquireAllIDle immediately returns nil if pool is closed
+* CreateResource checks if pool is closed before taking any action
+* Fix potential race condition when CreateResource and Close are called concurrently. CreateResource now checks if pool is closed before adding newly created resource to pool.
+
+# 1.1.0 (February 5, 2020)
+
+* Use runtime.nanotime for faster tracking of acquire time and last usage time.
+* Track resource idle time to enable client health check logic. (Patrick Ellul)
+* Add CreateResource to construct a new resource without acquiring it. (Patrick Ellul)
+* Fix deadlock race when acquire is cancelled. (Michael Tharp)

vendor/github.com/jackc/puddle/v2/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2018 Jack Christensen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/jackc/puddle/v2/README.md

@@ -0,0 +1,80 @@
+[![Go Reference](https://pkg.go.dev/badge/github.com/jackc/puddle/v2.svg)](https://pkg.go.dev/github.com/jackc/puddle/v2)
+![Build Status](https://github.com/jackc/puddle/actions/workflows/ci.yml/badge.svg)
+
+# Puddle
+
+Puddle is a tiny generic resource pool library for Go that uses the standard
+context library to signal cancellation of acquires. It is designed to contain
+the minimum functionality required for a resource pool. It can be used directly
+or it can be used as the base for a domain specific resource pool. For example,
+a database connection pool may use puddle internally and implement health checks
+and keep-alive behavior without needing to implement any concurrent code of its
+own.
+
+## Features
+
+* Acquire cancellation via context standard library
+* Statistics API for monitoring pool pressure
+* No dependencies outside of standard library and golang.org/x/sync
+* High performance
+* 100% test coverage of reachable code
+
+## Example Usage
+
+```go
+package main
+
+import (
+	"context"
+	"log"
+	"net"
+
+	"github.com/jackc/puddle/v2"
+)
+
+func main() {
+	constructor := func(context.Context) (net.Conn, error) {
+		return net.Dial("tcp", "127.0.0.1:8080")
+	}
+	destructor := func(value net.Conn) {
+		value.Close()
+	}
+	maxPoolSize := int32(10)
+
+	pool, err := puddle.NewPool(&puddle.Config[net.Conn]{Constructor: constructor, Destructor: destructor, MaxSize: maxPoolSize})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Acquire resource from the pool.
+	res, err := pool.Acquire(context.Background())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Use resource.
+	_, err = res.Value().Write([]byte{1})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Release when done.
+	res.Release()
+}
+```
+
+## Status
+
+Puddle is stable and feature complete.
+
+* Bug reports and fixes are welcome.
+* New features will usually not be accepted if they can be feasibly implemented in a wrapper.
+* Performance optimizations will usually not be accepted unless the performance issue rises to the level of a bug.
+
+## Supported Go Versions
+
+puddle supports the same versions of Go that are supported by the Go project. For [Go](https://golang.org/doc/devel/release.html#policy) that is the two most recent major releases. This means puddle supports Go 1.19 and higher.
+
+## License
+
+MIT

vendor/github.com/jackc/puddle/v2/context.go

@@ -0,0 +1,24 @@
+package puddle
+
+import (
+	"context"
+	"time"
+)
+
+// valueCancelCtx combines two contexts into one. One context is used for values and the other is used for cancellation.
+type valueCancelCtx struct {
+	valueCtx  context.Context
+	cancelCtx context.Context
+}
+
+func (ctx *valueCancelCtx) Deadline() (time.Time, bool) { return ctx.cancelCtx.Deadline() }
+func (ctx *valueCancelCtx) Done() <-chan struct{}       { return ctx.cancelCtx.Done() }
+func (ctx *valueCancelCtx) Err() error                  { return ctx.cancelCtx.Err() }
+func (ctx *valueCancelCtx) Value(key any) any           { return ctx.valueCtx.Value(key) }
+
+func newValueCancelCtx(valueCtx, cancelContext context.Context) context.Context {
+	return &valueCancelCtx{
+		valueCtx:  valueCtx,
+		cancelCtx: cancelContext,
+	}
+}

vendor/github.com/jackc/puddle/v2/doc.go

@@ -0,0 +1,11 @@
+// Package puddle is a generic resource pool with type-parametrized api.
+/*
+
+Puddle is a tiny generic resource pool library for Go that uses the standard
+context library to signal cancellation of acquires. It is designed to contain
+the minimum functionality a resource pool needs that cannot be implemented
+without concurrency concerns. For example, a database connection pool may use
+puddle internally and implement health checks and keep-alive behavior without
+needing to implement any concurrent code of its own.
+*/
+package puddle

vendor/github.com/jackc/puddle/v2/internal/genstack/gen_stack.go

@@ -0,0 +1,85 @@
+package genstack
+
+// GenStack implements a generational stack.
+//
+// GenStack works as common stack except for the fact that all elements in the
+// older generation are guaranteed to be popped before any element in the newer
+// generation. New elements are always pushed to the current (newest)
+// generation.
+//
+// We could also say that GenStack behaves as a stack in case of a single
+// generation, but it behaves as a queue of individual generation stacks.
+type GenStack[T any] struct {
+	// We can represent arbitrary number of generations using 2 stacks. The
+	// new stack stores all new pushes and the old stack serves all reads.
+	// Old stack can represent multiple generations. If old == new, then all
+	// elements pushed in previous (not current) generations have already
+	// been popped.
+
+	old *stack[T]
+	new *stack[T]
+}
+
+// NewGenStack creates a new empty GenStack.
+func NewGenStack[T any]() *GenStack[T] {
+	s := &stack[T]{}
+	return &GenStack[T]{
+		old: s,
+		new: s,
+	}
+}
+
+func (s *GenStack[T]) Pop() (T, bool) {
+	// Pushes always append to the new stack, so if the old once becomes
+	// empty, it will remail empty forever.
+	if s.old.len() == 0 && s.old != s.new {
+		s.old = s.new
+	}
+
+	if s.old.len() == 0 {
+		var zero T
+		return zero, false
+	}
+
+	return s.old.pop(), true
+}
+
+// Push pushes a new element at the top of the stack.
+func (s *GenStack[T]) Push(v T) { s.new.push(v) }
+
+// NextGen starts a new stack generation.
+func (s *GenStack[T]) NextGen() {
+	if s.old == s.new {
+		s.new = &stack[T]{}
+		return
+	}
+
+	// We need to pop from the old stack to the top of the new stack. Let's
+	// have an example:
+	//
+	//   Old: <bottom> 4 3 2 1
+	//   New: <bottom> 8 7 6 5
+	//   PopOrder: 1 2 3 4 5 6 7 8
+	//
+	//
+	// To preserve pop order, we have to take all elements from the old
+	// stack and push them to the top of new stack:
+	//
+	//   New: 8 7 6 5 4 3 2 1
+	//
+	s.new.push(s.old.takeAll()...)
+
+	// We have the old stack allocated and empty, so why not to reuse it as
+	// new new stack.
+	s.old, s.new = s.new, s.old
+}
+
+// Len returns number of elements in the stack.
+func (s *GenStack[T]) Len() int {
+	l := s.old.len()
+	if s.old != s.new {
+		l += s.new.len()
+	}
+
+	return l
+}

vendor/github.com/jackc/puddle/v2/internal/genstack/stack.go

@@ -0,0 +1,39 @@
+package genstack
+
+// stack is a wrapper around an array implementing a stack.
+//
+// We cannot use slice to represent the stack because append might change the
+// pointer value of the slice. That would be an issue in GenStack
+// implementation.
+type stack[T any] struct {
+	arr []T
+}
+
+// push pushes a new element at the top of a stack.
+func (s *stack[T]) push(vs ...T) { s.arr = append(s.arr, vs...) }
+
+// pop pops the stack top-most element.
+//
+// If stack length is zero, this method panics.
+func (s *stack[T]) pop() T {
+	idx := s.len() - 1
+	val := s.arr[idx]
+
+	// Avoid memory leak
+	var zero T
+	s.arr[idx] = zero
+
+	s.arr = s.arr[:idx]
+	return val
+}
+
+// takeAll returns all elements in the stack in order as they are stored - i.e.
+// the top-most stack element is the last one.
+func (s *stack[T]) takeAll() []T {
+	arr := s.arr
+	s.arr = nil
+	return arr
+}
+
+// len returns number of elements in the stack.
+func (s *stack[T]) len() int { return len(s.arr) }

vendor/github.com/jackc/puddle/v2/log.go

@@ -0,0 +1,32 @@
+package puddle
+
+import "unsafe"
+
+type ints interface {
+	int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64
+}
+
+// log2Int returns log2 of an integer. This function panics if val < 0. For val
+// == 0, returns 0.
+func log2Int[T ints](val T) uint8 {
+	if val <= 0 {
+		panic("log2 of non-positive number does not exist")
+	}
+
+	return log2IntRange(val, 0, uint8(8*unsafe.Sizeof(val)))
+}
+
+func log2IntRange[T ints](val T, begin, end uint8) uint8 {
+	length := end - begin
+	if length == 1 {
+		return begin
+	}
+
+	delim := begin + length/2
+	mask := T(1) << delim
+	if mask > val {
+		return log2IntRange(val, begin, delim)
+	} else {
+		return log2IntRange(val, delim, end)
+	}
+}