feat(cli): add batch command to convert many inputs in one run

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

CONTRIBUTING.md

@@ -1,145 +1,91 @@
 # Contributing to RelSpec
 
-Thank you for your interest in contributing to RelSpec.
+## Setup
 
-## Development Setup
+- Go 1.25+ (see `go.mod`), Git
+- Optional: golangci-lint, Docker/Podman (PostgreSQL integration tests)
 
-### Prerequisites
-- Go 1.21 or higher
-- Git
-- (Optional) golangci-lint for linting
-- (Optional) Docker for database testing
-
-### Getting Started
-
-1. Clone the repository:
 ```bash
-git clone https://github.com/wdevs/relspecgo.git
+git clone git@git.warky.dev:wdevs/relspecgo.git
 cd relspecgo
+make deps
+make build        # outputs build/relspec
 ```
 
-2. Install dependencies:
+## Make Targets
-```bash
-go mod download
-```
 
-3. Run tests:
+| Target                  | Purpose                                              |
-```bash
+|-------------------------|------------------------------------------------------|
-go test ./...
+| `make test`             | Unit tests (race detection, coverage)                |
-```
+| `make test-integration` | Integration tests (needs `RELSPEC_TEST_PG_CONN`)     |
+| `make docker-test`      | PostgreSQL integration tests via Docker/Podman       |
+| `make lint`             | golangci-lint                                        |
+| `make fmt` / `fmt-check`| gofumpt + goimports                                  |
+| `make check`            | vet, fmt-check, staticcheck, govulncheck             |
+| `make coverage`         | Coverage report                                      |
 
-4. Build the project:
+Single test: `go test -run TestName ./pkg/readers/dbml`
-```bash
-go build -o relspec ./cmd/relspec
-```
 
-## Project Structure
+## Layout
 
 ```
-relspecgo/
+cmd/relspec/      CLI commands (convert, diff, merge, split, edit, inspect, job, ...)
-├── cmd/              # CLI application entry point
+pkg/models/       Core model: Database > Schema > Table > Column/Constraint/Index/Relationship
-├── pkg/
+pkg/readers/<fmt> One reader per format
-│   ├── readers/      # Input format readers (XML, JSON, DCTX, DB, GORM, Bun)
+pkg/writers/<fmt> One writer per format
-│   ├── writers/      # Output format writers (GORM, Bun, JSON, YAML)
+pkg/diff, merge, inspector, jobs, transform, ui, pgsql, sqltypes ...
-│   ├── models/       # Internal data models for relations
+examples/         Sample files
-│   └── transform/    # Transformation and validation logic
+tests/            Integration tests and assets
-├── examples/         # Usage examples and sample files
+docs/             Feature docs
-├── tests/            # Integration tests
-└── .claude/          # Claude Code configuration and commands
 ```
 
-## Adding New Readers
+## Adding a Reader
 
-To add a new input format reader:
+1. Create `pkg/readers/<format>/reader.go` with `NewReader(options *readers.ReaderOptions)`.
+2. Implement `readers.Reader`: `ReadDatabase`, `ReadSchema`, `ReadTable`.
+3. Add `reader_test.go` in the same package.
+4. Register the format in the CLI switches (`cmd/relspec/convert.go`, `diff.go`, `edit.go`, ...).
+5. Add a `README.md` in the reader directory.
 
-1. Create a new file in `pkg/readers/` (e.g., `myformat_reader.go`)
+## Adding a Writer
-2. Implement the `Reader` interface:
-```go
-type Reader interface {
-    Read(source string) (*models.Schema, error)
-}
-```
-3. Add tests in `pkg/readers/myformat_reader_test.go`
-4. Register the reader in the CLI
 
-## Adding New Writers
+1. Create `pkg/writers/<format>/writer.go` with `NewWriter(options *writers.WriterOptions)`.
+2. Implement `writers.Writer`: `WriteDatabase`, `WriteSchema`, `WriteTable`.
+3. Add `writer_test.go` in the same package.
+4. Register the format in the CLI switches.
+5. Add a `README.md` in the writer directory.
 
-To add a new output format writer:
+## Code Rules
 
-1. Create a new file in `pkg/writers/` (e.g., `myformat_writer.go`)
+- Format with gofumpt/goimports (`make fmt`); `make check` must pass.
-2. Implement the `Writer` interface:
+- Iterate `Table.Columns`, `Constraints`, `Indexes`, `Relationships` in sorted order (maps are unordered; output must be deterministic).
-```go
+- Every writer stamps `buildinfo.GeneratedComment()` in its file header.
-type Writer interface {
+- Comment exported functions and types.
-    Write(schema *models.Schema, destination string) error
-}
-```
-3. Add tests in `pkg/writers/myformat_writer_test.go`
-4. Register the writer in the CLI
-
-## Code Style
-
-- Follow standard Go conventions
-- Use `gofmt` for formatting
-- Run `go vet` to check for issues
-- Use meaningful variable and function names
-- Add comments for exported functions and types
 
 ## Testing
 
-- Write unit tests for all new functionality
+- Tests live in the same package as the code.
-- Aim for >80% code coverage
+- Table-driven tests; cover positive and negative cases.
-- Use table-driven tests where appropriate
+- Reuse existing test data in `tests/` and `examples/` before adding new data.
-- Include both positive and negative test cases
+- Tests run with `-race`.
 
-### Running Tests
+## Commits
 
-```bash
+- Format: `type(scope): description`
-# All tests
+- Types: `feat`, `fix`, `docs`, `test`, `refactor`, `chore`, `ci`
-go test ./...
+- Keep commits focused. Reference issues where applicable.
 
-# With coverage
+## Pull Requests
-go test -cover ./...
 
-# Verbose output
+1. Branch from `master`.
-go test -v ./...
+2. Add tests; `make test` and `make check` pass.
+3. Update docs/README if behaviour changes.
+4. Open a PR with a clear description.
 
-# Specific package
+## Security
-go test ./pkg/readers/...
-```
 
-## Committing Changes
+Do not report vulnerabilities in public issues. See [SECURITY.md](SECURITY.md).
-
-- Write clear, descriptive commit messages
-- Follow conventional commits format: `type(scope): description`
-  - Types: feat, fix, docs, test, refactor, chore
-  - Example: `feat(readers): add PostgreSQL support`
-- Keep commits focused and atomic
-- Reference issues in commit messages when applicable
-
-## Pull Request Process
-
-1. Create a feature branch from `master`
-2. Make your changes
-3. Add tests for new functionality
-4. Ensure all tests pass
-5. Update documentation if needed
-6. Submit a pull request with a clear description
-
-## Claude Code Commands
-
-This project includes Claude Code slash commands for common tasks:
-
-- `/test` - Run all tests
-- `/build` - Build the binary
-- `/lint` - Run linters
-- `/coverage` - Generate coverage report
-
-## Questions or Issues?
-
-- Open an issue for bugs or feature requests
-- Start a discussion for questions or ideas
-- Check existing issues before creating new ones
 
 ## License
 
-By contributing to RelSpec, you agree that your contributions will be licensed under the Apache License 2.0.
+Contributions are licensed under the Apache License 2.0.

Makefile

@@ -1,4 +1,4 @@
-.PHONY: all build test test-unit test-integration lint coverage clean install help docker-up docker-down docker-test docker-test-integration start stop release release-version godoc vet fmt fmt-check staticcheck govulncheck check
+.PHONY: all build test test-unit test-integration lint coverage clean install help docker-up docker-down docker-test docker-test-integration start stop release release-version rerelease godoc vet fmt fmt-check staticcheck govulncheck check
 
 # Binary name
 BINARY_NAME=relspec
@@ -243,7 +243,7 @@ release: lint fmt-check test build ## Run lint, format check, tests, build, then
 	git push origin "$$version"; \
 	echo "Tag $$version created and pushed to remote repository."
 
-release-version: ## Auto-increment patch version, update VERSION/package files, commit, tag, and push
+release-version: lint fmt-check ## Run lint and format check, then auto-increment patch version, update VERSION/package files, commit, tag, and push
 	@CURRENT=$$([ -f VERSION ] && cat VERSION | tr -d '[:space:]' || (git describe --tags --abbrev=0 2>/dev/null | sed 's/^v//') || echo "0.0.0"); \
 	MAJOR=$$(echo $$CURRENT | cut -d. -f1); \
 	MINOR=$$(echo $$CURRENT | cut -d. -f2); \
@@ -260,5 +260,13 @@ release-version: ## Auto-increment patch version, update VERSION/package files,
 	git push origin HEAD "$$NEXT"; \
 	echo "Pushed $$NEXT — release workflow triggered"
 
+rerelease: lint fmt-check ## Move the latest tag to HEAD and force push it
+	@TAG=$$(git describe --tags --abbrev=0 2>/dev/null); \
+	if [ -z "$$TAG" ]; then echo "No existing tags found"; exit 1; fi; \
+	echo "Moving $$TAG to $$(git rev-parse --short HEAD)"; \
+	git tag -f -a "$$TAG" -m "Release $$TAG" HEAD; \
+	git push --force origin "$$TAG"; \
+	echo "Pushed $$TAG — release workflow triggered"
+
 help: ## Display this help screen
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}'

README.md

@@ -23,6 +23,8 @@ go install -v git.warky.dev/wdevs/relspecgo/cmd/relspec@latest
 | **Readers** | `bun` `dbml` `dctx` `drawdb` `drizzle` `gorm` `graphql` `json` `mssql` `pgsql` `prisma` `sqldir` `sqlite` `typeorm` `yaml` |
 | **Writers** | `bun` `dbml` `dctx` `drawdb` `drizzle` `gorm` `graphql` `json` `mssql` `pgsql` `prisma` `sqlexec` `sqlite` `template` `typeorm` `yaml` |
 
+See [docs/FORMAT_EXAMPLES.md](docs/FORMAT_EXAMPLES.md) for usage examples covering every format.
+
 ## Commands
 
 ### `convert` — Schema conversion
@@ -42,6 +44,17 @@ relspec convert --from pgsql --from-conn "postgres://..." --to sqlite --to-path
 relspec convert --from json --from-list "a.json,b.json" --to yaml --to-path merged.yaml
 ```
 
+### `batch` — Convert many inputs in one run
+
+Converts each input independently (one output per input, unlike `--from-list`
+which merges). `--input` takes paths or globs; outputs go to `--to-dir`.
+Use `--keep-going` to continue past failures (exit is still non-zero) and
+`--dry-run` to validate without writing. For named workflows see `relspec job run`.
+
+```bash
+relspec batch --from dbml --input "schemas/*.dbml" --to json --to-dir out/
+```
+
 PostgreSQL connections opened by relspec set `application_name` by default to
 `relspecgo/<version>` (with component suffixes internally, e.g. readers/writers).
 If you need a custom value, provide `application_name` explicitly in the connection

SECURITY.md

@@ -0,0 +1,12 @@
+# Security Policy
+
+## Supported versions
+Security fixes are released for the latest minor version of RelSpec.
+
+## Reporting a vulnerability
+Please do not open a public issue for security problems.
+
+Report privately by email: warkydevs@gmail.com
+
+Reports are reviewed on a best-effort basis. No response time or fix timeline is
+guaranteed. Reporters may be credited in the release notes if they wish.

TODO.md

@@ -4,20 +4,25 @@
 
 - [✔️] **Database Inspector**
   - [✔️] PostgreSQL driver (reader + writer)
-  - [ ] MySQL driver
+  - [ ] MySQL driver (only MariaDB datatype conversion in pkg/mariadb, no reader/writer)
   - [✔️] SQLite driver (reader + writer with automatic schema flattening)
-  - [ ] MSSQL driver
+  - [✔️] MSSQL driver (reader + writer, generated and identity columns)
   - [✔️] Foreign key detection
   - [✔️] Index extraction
   - [✔️] .sql file generation (PostgreSQL, SQLite)
 - [✔️] .dbml: Database Markup Language (DBML) for textual schema representation.
 - [✔️] Prisma schema support (PSL format) .prisma
+- [ ] Sequelize (Typescript/Javascript)  (Use templates, 💲 Someone can do this, not me)
 - [✔️] Drizzle ORM support .ts (TypeScript / JavaScript) (Mr. Edd wanted to move from Prisma to Drizzle. If you are bugs, you are welcome to do pull requests or issues)
 - [☠️] Entity Framework (.NET) model .edmx (Fuck no, EDMX files were bloated, verbose XML nightmares—hard to merge, error-prone, and a pain in teams. Microsoft wisely ditched them in EF Core for code-first. Classic overkill from old MS era.)
 - [✔️] TypeORM support
-- [] .hbm.xml / schema.xml: Hibernate/Propel mappings (Java/PHP) (💲 Someone can do this, not me)
+- [ ] .hbm.xml / schema.xml: Hibernate/Propel mappings (Java/PHP) (Use templates, 💲 Someone can do this, not me)
-- [ ] Django models.py (Python classes), Sequelize migrations (JS) (💲 Someone can do this, not me)
+- [ ] Django models.py (Python classes), Sequelize migrations (JS) (Use templates, 💲 Someone can do this, not me)
-- [] .avsc: Avro schema (JSON format for data serialization) (💲 Someone can do this, not me)
+- [ ] SQLAlchemy, Python (Use templates, 💲 Someone can do this, not me)
+- [ ] .avsc: Avro schema (JSON format for data serialization) (Use templates, 💲 Someone can do this, not me)
+- [ ] Rails schema in db/schema.rb (Use templates, 💲 Someone can do this, not me)
+- [ ] Laravel migration (Use templates, 💲 Someone can do this, not me)
+- [ ] Hibernate / JPA (Use templates, 💲 Someone can do this, not me)
 - [✔️] GraphQL schema generation
 
 ## UI
@@ -39,13 +44,19 @@
 
 ## Advanced Features
 
-- [ ] Dry-run mode for validation
+- [ ] Dry-run mode for validation (only `job run --dry-run`; not on convert/merge/split)
-- [x] Diff tool for comparing specifications
+- [✔️] Diff tool for comparing specifications
-- [ ] Migration script generation
+- [✔️] Migration script generation (PostgreSQL diff, live database by default for direct output)
 - [ ] Custom type mapping configuration
-- [ ] Batch processing support
+- [ ] Batch processing support (partial: job files run named workflows via `relspec job run`)
 - [ ] Watch mode for auto-regeneration
 
+## Distribution
+
+- [ ] NSIS Windows installer
+  - [ ] Check https://git.warky.dev/wdevs/relspecgo/releases for new releases and prompt to update
+- [ ] CI pipeline to build and publish the Windows installer
+
 ## Future Considerations
 
 - [ ] Web UI for visual editing

VERSION

@@ -1 +1 @@
-1.0.83
+1.0.85

cmd/relspec/batch.go

@@ -0,0 +1,214 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	batchSourceType      string
+	batchInputs          []string
+	batchTargetType      string
+	batchTargetDir       string
+	batchPackageName     string
+	batchSchemaFilter    string
+	batchFlattenSchema   bool
+	batchNullableTypes   string
+	batchNullableArrays  string
+	batchContinueOnError bool
+	batchKeepGoing       bool
+	batchDryRun          bool
+)
+
+var batchCmd = &cobra.Command{
+	Use:   "batch",
+	Short: "Convert many input files to a target format in one run",
+	Long: `Convert each input file independently to the target format.
+
+Unlike 'convert --from-list', which merges all inputs into one output, batch
+mode writes one output per input into --to-dir. The output is named after the
+input file (without its extension). Directory-style targets (gorm, bun,
+drizzle) get a sub-directory per input.
+
+Inputs are given with --input, which accepts file paths and glob patterns and
+may be repeated or comma-separated. Inputs are processed in sorted order and
+duplicates are removed. The command exits non-zero if any input fails.
+
+For named, multi-step workflows use 'relspec job run' instead.
+
+Examples:
+  # Convert every DBML file in a directory to JSON
+  relspec batch --from dbml --input "schemas/*.dbml" --to json --to-dir out/
+
+  # Convert specific files to GORM models, one package directory per input
+  relspec batch --from json --input a.json,b.json \
+                --to gorm --to-dir models/ --package models
+
+  # Validate everything first, writing nothing
+  relspec batch --from yaml --input "specs/*.yaml" --to pgsql --to-dir sql/ --dry-run
+
+  # Report all failures instead of stopping at the first
+  relspec batch --from json --input "*.json" --to yaml --to-dir out/ --keep-going`,
+	RunE: runBatch,
+}
+
+func init() {
+	batchCmd.Flags().StringVar(&batchSourceType, "from", "", "Source format for every input (dbml, dctx, drawdb, graphql, json, yaml, gorm, bun, drizzle, prisma, typeorm, sqlite)")
+	batchCmd.Flags().StringSliceVar(&batchInputs, "input", nil, "Input file path or glob pattern (repeatable, comma-separated)")
+	batchCmd.Flags().StringVar(&batchTargetType, "to", "", "Target format")
+	batchCmd.Flags().StringVar(&batchTargetDir, "to-dir", "", "Output directory; one output per input is written here")
+	batchCmd.Flags().StringVar(&batchPackageName, "package", "", "Package name (for code generation formats like gorm/bun)")
+	batchCmd.Flags().StringVar(&batchSchemaFilter, "schema", "", "Filter to a specific schema by name")
+	batchCmd.Flags().BoolVar(&batchFlattenSchema, "flatten-schema", false, "Flatten schema.table names to schema_table")
+	batchCmd.Flags().StringVar(&batchNullableTypes, "types", "", "Nullable type package for code-gen writers (bun/gorm)")
+	batchCmd.Flags().StringVar(&batchNullableArrays, "array-nullable", "", "Nullable array representation for the Bun writer")
+	batchCmd.Flags().BoolVar(&batchContinueOnError, "continue-on-error", false, "Prepend \\set ON_ERROR_STOP off to generated SQL (pgsql output only)")
+	batchCmd.Flags().BoolVar(&batchKeepGoing, "keep-going", false, "Process remaining inputs after a failure; still exits non-zero")
+	batchCmd.Flags().BoolVar(&batchDryRun, "dry-run", false, "Read and validate every input and print the plan without writing any output")
+
+	for _, f := range []string{"from", "input", "to", "to-dir"} {
+		if err := batchCmd.MarkFlagRequired(f); err != nil {
+			fmt.Fprintf(os.Stderr, "Error marking %s flag as required: %v\n", f, err)
+		}
+	}
+}
+
+// batchDirTargets are writers that emit a directory of files rather than one file.
+var batchDirTargets = map[string]bool{"gorm": true, "bun": true, "drizzle": true}
+
+// batchExtensions maps single-file target formats to their output extension.
+var batchExtensions = map[string]string{
+	"dbml": ".dbml", "dctx": ".dctx", "drawdb": ".ddb", "json": ".json",
+	"yaml": ".yaml", "yml": ".yaml", "pgsql": ".sql", "postgres": ".sql",
+	"postgresql": ".sql", "sql": ".sql", "mssql": ".sql", "sqlserver": ".sql",
+	"mssql2016": ".sql", "mssql2017": ".sql", "mssql2019": ".sql", "mssql2022": ".sql",
+	"sqlite": ".sql", "sqlite3": ".sql", "prisma": ".prisma", "typeorm": ".ts",
+	"graphql": ".graphql", "gql": ".graphql",
+}
+
+// expandBatchInputs resolves paths and glob patterns into a sorted,
+// de-duplicated file list. A pattern that matches nothing is an error.
+func expandBatchInputs(patterns []string) ([]string, error) {
+	seen := map[string]bool{}
+	var files []string
+	for _, p := range patterns {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		matches, err := filepath.Glob(p)
+		if err != nil {
+			return nil, fmt.Errorf("invalid pattern %q: %w", p, err)
+		}
+		if len(matches) == 0 {
+			return nil, fmt.Errorf("no files match %q", p)
+		}
+		for _, m := range matches {
+			if !seen[m] {
+				seen[m] = true
+				files = append(files, m)
+			}
+		}
+	}
+	if len(files) == 0 {
+		return nil, fmt.Errorf("no input files given")
+	}
+	sort.Strings(files)
+	return files, nil
+}
+
+// batchOutputPaths returns the output path for each input. It errors when two
+// inputs would collide on the same output name.
+func batchOutputPaths(files []string, targetType, dir string) ([]string, error) {
+	key := strings.ToLower(targetType)
+	ext := ""
+	if !batchDirTargets[key] {
+		var ok bool
+		if ext, ok = batchExtensions[key]; !ok {
+			return nil, fmt.Errorf("unsupported target format: %s", targetType)
+		}
+	}
+	outs := make([]string, len(files))
+	owner := map[string]string{}
+	for i, f := range files {
+		stem := strings.TrimSuffix(filepath.Base(f), filepath.Ext(f))
+		out := filepath.Join(dir, stem+ext)
+		if prev, dup := owner[out]; dup {
+			return nil, fmt.Errorf("inputs %s and %s would both write %s", prev, f, out)
+		}
+		owner[out] = f
+		outs[i] = out
+	}
+	return outs, nil
+}
+
+func runBatch(cmd *cobra.Command, args []string) error {
+	files, err := expandBatchInputs(batchInputs)
+	if err != nil {
+		return err
+	}
+	outs, err := batchOutputPaths(files, batchTargetType, batchTargetDir)
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintf(os.Stderr, "\n=== RelSpec Batch Converter ===\n")
+	fmt.Fprintf(os.Stderr, "Started at: %s\n", getCurrentTimestamp())
+	fmt.Fprintf(os.Stderr, "Inputs: %d file(s), %s -> %s\n\n", len(files), batchSourceType, batchTargetType)
+
+	out := outWriter(cmd)
+	if batchDryRun {
+		fmt.Fprintf(out, "RelSpec batch plan (dry run - nothing written):\n")
+	}
+
+	var failed []string
+	for i, f := range files {
+		fmt.Fprintf(os.Stderr, "[%d/%d] %s -> %s\n", i+1, len(files), f, outs[i])
+		if err := processBatchItem(cmd, f, outs[i]); err != nil {
+			fmt.Fprintf(os.Stderr, "      ✗ %v\n", err)
+			failed = append(failed, fmt.Sprintf("%s: %v", f, err))
+			if !batchKeepGoing {
+				break
+			}
+			continue
+		}
+		fmt.Fprintf(os.Stderr, "      ✓ done\n")
+	}
+
+	fmt.Fprintf(os.Stderr, "\n=== Batch Complete: %d ok, %d failed ===\n", len(files)-len(failed), len(failed))
+	if len(failed) > 0 {
+		return fmt.Errorf("batch finished with %d failure(s):\n  %s", len(failed), strings.Join(failed, "\n  "))
+	}
+	return nil
+}
+
+func processBatchItem(cmd *cobra.Command, in, outPath string) error {
+	db, err := readDatabaseForConvert(batchSourceType, in, "")
+	if err != nil {
+		return fmt.Errorf("failed to read source: %w", err)
+	}
+	finalizeCommentedRefs(db, stderrWarn)
+
+	if batchDryRun {
+		if err := validateWriteTarget(db, batchTargetType, batchPackageName, batchSchemaFilter, ""); err != nil {
+			return fmt.Errorf("dry run validation failed: %w", err)
+		}
+		w := outWriter(cmd)
+		fmt.Fprintf(w, "  %s -> %s (database '%s')\n", in, outPath, db.Name)
+		printDryRunPlan(w, db)
+		return nil
+	}
+
+	if err := os.MkdirAll(batchTargetDir, 0o755); err != nil {
+		return fmt.Errorf("failed to create output directory: %w", err)
+	}
+	if err := writeDatabase(db, batchTargetType, outPath, batchPackageName, batchSchemaFilter, batchFlattenSchema, batchNullableTypes, batchNullableArrays, batchContinueOnError, ""); err != nil {
+		return fmt.Errorf("failed to write target: %w", err)
+	}
+	return nil
+}

cmd/relspec/batch_test.go

@@ -0,0 +1,143 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func saveBatchState(t *testing.T) {
+	t.Helper()
+	a, b, c, d, e, f, g := batchSourceType, batchInputs, batchTargetType, batchTargetDir, batchPackageName, batchKeepGoing, batchDryRun
+	t.Cleanup(func() {
+		batchSourceType, batchInputs, batchTargetType, batchTargetDir, batchPackageName, batchKeepGoing, batchDryRun = a, b, c, d, e, f, g
+	})
+}
+
+func TestRunBatch_ConvertsEachInput(t *testing.T) {
+	saveBatchState(t)
+	dir := t.TempDir()
+	writeTestJSON(t, filepath.Join(dir, "a.json"), []string{"users"})
+	writeTestJSON(t, filepath.Join(dir, "b.json"), []string{"posts"})
+	outDir := filepath.Join(dir, "out")
+
+	batchSourceType, batchTargetType, batchTargetDir = "json", "yaml", outDir
+	batchPackageName, batchKeepGoing, batchDryRun = "", false, false
+	batchInputs = []string{filepath.Join(dir, "*.json")}
+
+	cmd, _ := newDryRunCmd()
+	if err := runBatch(cmd, nil); err != nil {
+		t.Fatalf("batch: %v", err)
+	}
+	for _, name := range []string{"a.yaml", "b.yaml"} {
+		if _, err := os.Stat(filepath.Join(outDir, name)); err != nil {
+			t.Errorf("expected %s: %v", name, err)
+		}
+	}
+}
+
+func TestRunBatch_DryRunWritesNothing(t *testing.T) {
+	saveBatchState(t)
+	dir := t.TempDir()
+	writeTestJSON(t, filepath.Join(dir, "a.json"), []string{"users"})
+	outDir := filepath.Join(dir, "out")
+
+	batchSourceType, batchTargetType, batchTargetDir = "json", "yaml", outDir
+	batchPackageName, batchKeepGoing, batchDryRun = "", false, true
+	batchInputs = []string{filepath.Join(dir, "a.json")}
+
+	cmd, buf := newDryRunCmd()
+	if err := runBatch(cmd, nil); err != nil {
+		t.Fatalf("dry run: %v", err)
+	}
+	if _, err := os.Stat(outDir); !os.IsNotExist(err) {
+		t.Fatal("dry run must not create the output directory")
+	}
+	if !strings.Contains(buf.String(), "users") || !strings.Contains(buf.String(), "a.yaml") {
+		t.Errorf("plan incomplete:\n%s", buf.String())
+	}
+}
+
+func TestRunBatch_FailureHandling(t *testing.T) {
+	saveBatchState(t)
+	dir := t.TempDir()
+	writeTestJSON(t, filepath.Join(dir, "a.json"), []string{"users"})
+	if err := os.WriteFile(filepath.Join(dir, "b.json"), []byte("{not json"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	writeTestJSON(t, filepath.Join(dir, "c.json"), []string{"posts"})
+	outDir := filepath.Join(dir, "out")
+
+	batchSourceType, batchTargetType, batchTargetDir = "json", "yaml", outDir
+	batchPackageName, batchDryRun = "", false
+	batchInputs = []string{filepath.Join(dir, "*.json")}
+	cmd, _ := newDryRunCmd()
+
+	// Default: stop at first failure.
+	batchKeepGoing = false
+	err := runBatch(cmd, nil)
+	if err == nil || !strings.Contains(err.Error(), "b.json") {
+		t.Fatalf("expected failure naming b.json, got %v", err)
+	}
+	if _, statErr := os.Stat(filepath.Join(outDir, "c.yaml")); !os.IsNotExist(statErr) {
+		t.Error("c.json should not be processed without --keep-going")
+	}
+
+	// --keep-going: remaining inputs are processed, exit still fails.
+	batchKeepGoing = true
+	if err := runBatch(cmd, nil); err == nil {
+		t.Fatal("expected non-zero result with --keep-going")
+	}
+	if _, statErr := os.Stat(filepath.Join(outDir, "c.yaml")); statErr != nil {
+		t.Errorf("c.yaml should be written with --keep-going: %v", statErr)
+	}
+}
+
+func TestExpandBatchInputs(t *testing.T) {
+	dir := t.TempDir()
+	for _, n := range []string{"b.json", "a.json"} {
+		if err := os.WriteFile(filepath.Join(dir, n), []byte("{}"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	got, err := expandBatchInputs([]string{filepath.Join(dir, "*.json"), filepath.Join(dir, "a.json")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 2 || filepath.Base(got[0]) != "a.json" || filepath.Base(got[1]) != "b.json" {
+		t.Errorf("want sorted deduped [a b], got %v", got)
+	}
+	if _, err := expandBatchInputs([]string{filepath.Join(dir, "*.nope")}); err == nil {
+		t.Error("unmatched pattern should error")
+	}
+}
+
+func TestBatchOutputPaths(t *testing.T) {
+	tests := []struct {
+		name    string
+		files   []string
+		target  string
+		want    []string
+		wantErr string
+	}{
+		{"file target", []string{"x/a.dbml"}, "json", []string{"out/a.json"}, ""},
+		{"dir target", []string{"x/a.json"}, "gorm", []string{"out/a"}, ""},
+		{"collision", []string{"x/a.json", "y/a.json"}, "yaml", nil, "both write"},
+		{"unsupported", []string{"a.json"}, "nope", nil, "unsupported target"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := batchOutputPaths(tt.files, tt.target, "out")
+			if tt.wantErr != "" {
+				if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
+					t.Fatalf("want error %q, got %v", tt.wantErr, err)
+				}
+				return
+			}
+			if err != nil || len(got) != len(tt.want) || got[0] != filepath.FromSlash(tt.want[0]) {
+				t.Fatalf("got %v, %v; want %v", got, err, tt.want)
+			}
+		})
+	}
+}

cmd/relspec/convert.go

@@ -3,6 +3,7 @@ package main
 import (
 	stdjson "encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"strings"
 	"time"
@@ -57,6 +58,7 @@ var (
 	convertNullableArrays  string
 	convertContinueOnError bool
 	convertExtraFields     string
+	convertDryRun          bool
 )
 
 var convertCmd = &cobra.Command{
@@ -185,6 +187,8 @@ func init() {
 	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")
 
+	convertCmd.Flags().BoolVar(&convertDryRun, "dry-run", false, "Read and validate the input and print the plan without writing any output")
+
 	err := convertCmd.MarkFlagRequired("from")
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error marking from flag as required: %v\n", err)
@@ -240,6 +244,22 @@ func runConvert(cmd *cobra.Command, args []string) error {
 	}
 	fmt.Fprintf(os.Stderr, "      Found: %d table(s)\n\n", totalTables)
 
+	if convertDryRun {
+		if err := validateWriteTarget(db, convertTargetType, convertPackageName, convertSchemaFilter, convertExtraFields); err != nil {
+			return fmt.Errorf("dry run validation failed: %w", err)
+		}
+		out := outWriter(cmd)
+		fmt.Fprintf(out, "RelSpec convert plan (dry run - nothing written):\n")
+		fmt.Fprintf(out, "  Input:  %s database '%s'\n", convertSourceType, db.Name)
+		fmt.Fprintf(out, "  Output: %s -> %s\n", convertTargetType, convertTargetPath)
+		if convertSchemaFilter != "" {
+			fmt.Fprintf(out, "  Schema filter: %s\n", convertSchemaFilter)
+		}
+		printDryRunPlan(out, db)
+		fmt.Fprintf(os.Stderr, "=== Dry run complete: no output written ===\n\n")
+		return nil
+	}
+
 	// Write to target format
 	fmt.Fprintf(os.Stderr, "[2/2] Writing to target format...\n")
 	fmt.Fprintf(os.Stderr, "      Format: %s\n", convertTargetType)
@@ -408,23 +428,12 @@ func writeDatabase(db *models.Database, dbType, outputPath, packageName, schemaF
 
 	writerOpts := newWriterOptions(outputPath, packageName, flattenSchema, nullableTypes, nullableArrays, continueOnError)
 	if extraFields != "" {
-		if !strings.EqualFold(dbType, "bun") {
+		extraFieldsJSON, err := loadExtraFields(dbType, extraFields)
-			return fmt.Errorf("--extra-fields is only supported for Bun output")
-		}
-		extraFieldsJSON, err := os.ReadFile(extraFields)
 		if err != nil {
-			return fmt.Errorf("failed to read --extra-fields file %q: %w", extraFields, err)
+			return err
-		}
-
-		var parsed []wbun.ExtraFieldConfig
-		if err := stdjson.Unmarshal(extraFieldsJSON, &parsed); err != nil {
-			return fmt.Errorf("invalid --extra-fields JSON in %q: %w", extraFields, err)
-		}
-		if len(parsed) == 0 {
-			return fmt.Errorf("--extra-fields must contain at least one field")
 		}
 		writerOpts.Metadata = map[string]interface{}{
-			"extra_fields": string(extraFieldsJSON),
+			"extra_fields": extraFieldsJSON,
 		}
 	}
 
@@ -529,6 +538,95 @@ func writeDatabase(db *models.Database, dbType, outputPath, packageName, schemaF
 	return nil
 }
 
+// loadExtraFields reads and validates the --extra-fields JSON file, returning
+// its raw content.
+func loadExtraFields(dbType, path string) (string, error) {
+	if !strings.EqualFold(dbType, "bun") {
+		return "", fmt.Errorf("--extra-fields is only supported for Bun output")
+	}
+	extraFieldsJSON, err := os.ReadFile(path)
+	if err != nil {
+		return "", fmt.Errorf("failed to read --extra-fields file %q: %w", path, err)
+	}
+
+	var parsed []wbun.ExtraFieldConfig
+	if err := stdjson.Unmarshal(extraFieldsJSON, &parsed); err != nil {
+		return "", fmt.Errorf("invalid --extra-fields JSON in %q: %w", path, err)
+	}
+	if len(parsed) == 0 {
+		return "", fmt.Errorf("--extra-fields must contain at least one field")
+	}
+	return string(extraFieldsJSON), nil
+}
+
+// validateWriteTarget performs the checks writeDatabase makes before writing,
+// without constructing a writer or touching the output path. Used by --dry-run.
+func validateWriteTarget(db *models.Database, dbType, packageName, schemaFilter, extraFields string) error {
+	if extraFields != "" {
+		if _, err := loadExtraFields(dbType, extraFields); err != nil {
+			return err
+		}
+	}
+
+	switch strings.ToLower(dbType) {
+	case "dbml", "dctx", "drawdb", "json", "yaml", "yml", "drizzle",
+		"pgsql", "postgres", "postgresql", "sql",
+		"mssql", "sqlserver", "mssql2016", "mssql2017", "mssql2019", "mssql2022",
+		"sqlite", "sqlite3", "prisma", "typeorm", "graphql", "gql":
+	case "gorm", "bun":
+		if packageName == "" {
+			return fmt.Errorf("package name is required for %s format (use --package flag)", dbType)
+		}
+	default:
+		return fmt.Errorf("unsupported target format: %s", dbType)
+	}
+
+	if schemaFilter != "" {
+		for _, schema := range db.Schemas {
+			if schema.Name == schemaFilter {
+				return nil
+			}
+		}
+		return fmt.Errorf("schema '%s' not found in database. Available schemas: %v",
+			schemaFilter, getSchemaNames(db))
+	}
+
+	if strings.EqualFold(dbType, "dctx") {
+		if len(db.Schemas) == 0 {
+			return fmt.Errorf("no schemas found in database")
+		}
+		if len(db.Schemas) > 1 {
+			return fmt.Errorf("multiple schemas found, please specify which schema to export using --schema flag. Available schemas: %v",
+				getSchemaNames(db))
+		}
+	}
+	return nil
+}
+
+// outWriter returns the command's stdout, falling back to os.Stdout when the
+// command is nil (tests call the run functions directly).
+func outWriter(cmd *cobra.Command) io.Writer {
+	if cmd == nil {
+		return os.Stdout
+	}
+	return cmd.OutOrStdout()
+}
+
+// printDryRunPlan prints the schemas and tables that would be written.
+func printDryRunPlan(out io.Writer, db *models.Database) {
+	for _, schema := range db.Schemas {
+		names := make([]string, 0, len(schema.Tables))
+		for _, t := range schema.Tables {
+			names = append(names, t.Name)
+		}
+		fmt.Fprintf(out, "    schema %q: %d table(s)", schema.Name, len(schema.Tables))
+		if len(names) > 0 {
+			fmt.Fprintf(out, " [%s]", strings.Join(names, ", "))
+		}
+		fmt.Fprintln(out)
+	}
+}
+
 // getSchemaNames returns a slice of schema names from a database
 func getSchemaNames(db *models.Database) []string {
 	names := make([]string, len(db.Schemas))

cmd/relspec/dry_run_test.go

@@ -0,0 +1,158 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+func newDryRunCmd() (*cobra.Command, *bytes.Buffer) {
+	var buf bytes.Buffer
+	cmd := &cobra.Command{}
+	cmd.SetOut(&buf)
+	return cmd, &buf
+}
+
+func TestRunConvert_DryRunWritesNothing(t *testing.T) {
+	defer func(a, b, c, d string, e bool) {
+		convertSourceType, convertSourcePath, convertTargetType, convertTargetPath, convertDryRun = a, b, c, d, e
+	}(convertSourceType, convertSourcePath, convertTargetType, convertTargetPath, convertDryRun)
+
+	dir := t.TempDir()
+	in := filepath.Join(dir, "in.json")
+	out := filepath.Join(dir, "out.json")
+	writeTestJSON(t, in, []string{"users", "posts"})
+
+	convertSourceType, convertSourcePath = "json", in
+	convertTargetType, convertTargetPath = "json", out
+	convertDryRun = true
+
+	cmd, buf := newDryRunCmd()
+	if err := runConvert(cmd, nil); err != nil {
+		t.Fatalf("dry run: %v", err)
+	}
+	if _, err := os.Stat(out); !os.IsNotExist(err) {
+		t.Fatal("dry run must not create the output file")
+	}
+	for _, want := range []string{"dry run", "users", "posts", out} {
+		if !strings.Contains(buf.String(), want) {
+			t.Errorf("plan missing %q:\n%s", want, buf.String())
+		}
+	}
+
+	// Normal behavior is unchanged.
+	convertDryRun = false
+	if err := runConvert(cmd, nil); err != nil {
+		t.Fatalf("real run: %v", err)
+	}
+	if _, err := os.Stat(out); err != nil {
+		t.Fatalf("real run should write output: %v", err)
+	}
+}
+
+func TestRunConvert_DryRunValidatesTarget(t *testing.T) {
+	defer func(a, b, c, d string, e bool) {
+		convertSourceType, convertSourcePath, convertTargetType, convertTargetPath, convertDryRun = a, b, c, d, e
+	}(convertSourceType, convertSourcePath, convertTargetType, convertTargetPath, convertDryRun)
+
+	dir := t.TempDir()
+	in := filepath.Join(dir, "in.json")
+	out := filepath.Join(dir, "models")
+	writeTestJSON(t, in, []string{"users"})
+
+	convertSourceType, convertSourcePath = "json", in
+	convertDryRun = true
+
+	// gorm without --package must fail validation, as a real run would.
+	convertTargetType, convertTargetPath = "gorm", out
+	cmd, _ := newDryRunCmd()
+	err := runConvert(cmd, nil)
+	if err == nil || !strings.Contains(err.Error(), "package name is required") {
+		t.Fatalf("expected package validation error, got %v", err)
+	}
+
+	convertTargetType = "nope"
+	err = runConvert(cmd, nil)
+	if err == nil || !strings.Contains(err.Error(), "unsupported target format") {
+		t.Fatalf("expected unsupported format error, got %v", err)
+	}
+	if _, statErr := os.Stat(out); !os.IsNotExist(statErr) {
+		t.Fatal("dry run must not create the output path")
+	}
+}
+
+func TestRunSplit_DryRunWritesNothing(t *testing.T) {
+	defer func(a, b, c, d, e string, f bool) {
+		splitSourceType, splitSourcePath, splitTargetType, splitTargetPath, splitTables, splitDryRun = a, b, c, d, e, f
+	}(splitSourceType, splitSourcePath, splitTargetType, splitTargetPath, splitTables, splitDryRun)
+
+	dir := t.TempDir()
+	in := filepath.Join(dir, "in.json")
+	out := filepath.Join(dir, "subset.json")
+	writeTestJSON(t, in, []string{"users", "posts", "comments"})
+
+	splitSourceType, splitSourcePath = "json", in
+	splitTargetType, splitTargetPath = "json", out
+	splitTables = "users,posts"
+	splitDryRun = true
+
+	cmd, buf := newDryRunCmd()
+	if err := runSplit(cmd, nil); err != nil {
+		t.Fatalf("dry run: %v", err)
+	}
+	if _, err := os.Stat(out); !os.IsNotExist(err) {
+		t.Fatal("dry run must not create the output file")
+	}
+	got := buf.String()
+	if !strings.Contains(got, "2 table(s)") || strings.Contains(got, "comments") {
+		t.Errorf("plan should show only the 2 selected tables:\n%s", got)
+	}
+
+	// A selection that matches nothing fails validation in dry-run too.
+	splitTables = "does_not_exist"
+	if err := runSplit(cmd, nil); err == nil {
+		t.Fatal("expected error for empty selection")
+	}
+}
+
+func TestRunMerge_DryRunWritesNothing(t *testing.T) {
+	saved := saveMergeState()
+	defer restoreMergeState(saved)
+	defer func(v bool) { mergeDryRun = v }(mergeDryRun)
+
+	dir := t.TempDir()
+	target := filepath.Join(dir, "target.json")
+	source := filepath.Join(dir, "source.json")
+	out := filepath.Join(dir, "merged.json")
+	writeTestJSON(t, target, []string{"users"})
+	writeTestJSON(t, source, []string{"posts"})
+
+	mergeTargetType, mergeTargetPath, mergeTargetConn = "json", target, ""
+	mergeSourceType, mergeSourcePath, mergeSourceConn = "json", source, ""
+	mergeFromList = nil
+	mergeOutputType, mergeOutputPath, mergeOutputConn = "json", out, ""
+	mergeSkipTables, mergeReportPath = "", ""
+	mergeDryRun = true
+
+	cmd, buf := newDryRunCmd()
+	if err := runMerge(cmd, nil); err != nil {
+		t.Fatalf("dry run: %v", err)
+	}
+	if _, err := os.Stat(out); !os.IsNotExist(err) {
+		t.Fatal("dry run must not create the output file")
+	}
+	for _, want := range []string{"dry run", "users", "posts", out} {
+		if !strings.Contains(buf.String(), want) {
+			t.Errorf("plan missing %q:\n%s", want, buf.String())
+		}
+	}
+
+	mergeOutputType = "nope"
+	if err := runMerge(cmd, nil); err == nil || !strings.Contains(err.Error(), "unsupported format") {
+		t.Fatalf("expected unsupported output format error, got %v", err)
+	}
+}

cmd/relspec/job.go

@@ -844,7 +844,7 @@ func writeJobOutput(rj *resolvedJob, db *models.Database, lg *jobLogger) error {
 		}
 		lg.logf("writing output to database env:%s", rj.outputConnEnv)
 		writerOpts := newWriterOptions("", o.Package, o.FlattenSchema, o.Types, o.ArrayNullable, o.ContinueOnError)
-		writerOpts.Metadata = map[string]interface{}{"connection_string": rj.outputConn}
+		writerOpts.Metadata = map[string]interface{}{"connection_string": rj.outputConn, "full_ddl": o.FullDDL}
 		return wpgsql.NewWriter(writerOpts).WriteDatabase(db)
 	}
 

cmd/relspec/merge.go

@@ -59,7 +59,9 @@ var (
 	mergeSkipTables    string // Comma-separated table names to skip
 	mergeVerbose       bool
 	mergeReportPath    string // Path to write merge report
+	mergeFullDDL       bool   // Execute full DDL instead of diffing the live pgsql database
 	mergeFlattenSchema bool
+	mergeDryRun        bool
 )
 
 var mergeCmd = &cobra.Command{
@@ -127,7 +129,9 @@ func init() {
 	mergeCmd.Flags().BoolVar(&mergeSkipSequences, "skip-sequences", false, "Skip sequences during merge")
 	mergeCmd.Flags().StringVar(&mergeSkipTables, "skip-tables", "", "Comma-separated list of table names to skip during merge")
 	mergeCmd.Flags().BoolVar(&mergeVerbose, "verbose", false, "Show verbose output")
+	mergeCmd.Flags().BoolVar(&mergeFullDDL, "full-ddl", false, "pgsql database output: execute the full DDL instead of only the differences from the live database")
 	mergeCmd.Flags().StringVar(&mergeReportPath, "merge-report", "", "Path to write merge report (JSON format)")
+	mergeCmd.Flags().BoolVar(&mergeDryRun, "dry-run", false, "Read and merge in memory, then print the merge plan without writing any output")
 	mergeCmd.Flags().BoolVar(&mergeFlattenSchema, "flatten-schema", false, "Flatten schema.table names to schema_table (useful for databases like SQLite that do not support schemas)")
 }
 
@@ -262,6 +266,29 @@ func runMerge(cmd *cobra.Command, args []string) error {
 			merge.GetColumnTypeConflictSummary(result, 10))
 	}
 
+	if mergeDryRun {
+		if !isMergeOutputFormat(mergeOutputType) {
+			return fmt.Errorf("dry run validation failed: Output: unsupported format '%s'", mergeOutputType)
+		}
+		out := outWriter(cmd)
+		fmt.Fprintf(out, "RelSpec merge plan (dry run - nothing written):\n")
+		fmt.Fprintf(out, "  Target: %s database '%s'\n", mergeTargetType, targetDB.Name)
+		fmt.Fprintf(out, "  Source: %s database '%s'\n", mergeSourceType, sourceDB.Name)
+		switch {
+		case mergeOutputPath != "":
+			fmt.Fprintf(out, "  Output: %s -> %s\n", mergeOutputType, mergeOutputPath)
+		case mergeOutputConn != "":
+			fmt.Fprintf(out, "  Output: %s -> %s\n", mergeOutputType, maskPassword(mergeOutputConn))
+		default:
+			fmt.Fprintf(out, "  Output: %s\n", mergeOutputType)
+		}
+		fmt.Fprintf(out, "  Result:\n")
+		printDryRunPlan(out, targetDB)
+		fmt.Fprintf(out, "\n%s\n", merge.GetMergeSummary(result))
+		fmt.Fprintf(os.Stderr, "\n=== Dry run complete: no output written ===\n")
+		return nil
+	}
+
 	// Step 4: Write output
 	fmt.Fprintf(os.Stderr, "\n[4/4] Writing output...\n")
 	fmt.Fprintf(os.Stderr, "      Format: %s\n", mergeOutputType)
@@ -283,6 +310,16 @@ func runMerge(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
+// isMergeOutputFormat reports whether writeDatabaseForMerge supports dbType.
+func isMergeOutputFormat(dbType string) bool {
+	switch strings.ToLower(dbType) {
+	case "dbml", "dctx", "drawdb", "graphql", "json", "yaml", "gorm", "bun",
+		"drizzle", "prisma", "typeorm", "sqlite", "sqlite3", "pgsql":
+		return true
+	}
+	return false
+}
+
 func readDatabaseForMerge(dbType, filePath, connString, label string) (*models.Database, error) {
 	var reader readers.Reader
 
@@ -443,6 +480,7 @@ func writeDatabaseForMerge(dbType, filePath, connString string, db *models.Datab
 		if connString != "" {
 			writerOpts.Metadata = map[string]interface{}{
 				"connection_string": connString,
+				"full_ddl":          mergeFullDDL,
 			}
 			// Add report path if merge report is enabled
 			if mergeReportPath != "" {

cmd/relspec/root.go

@@ -32,6 +32,7 @@ JSON, YAML, SQL, etc.).`,
 
 func init() {
 	rootCmd.AddCommand(convertCmd)
+	rootCmd.AddCommand(batchCmd)
 	rootCmd.AddCommand(diffCmd)
 	rootCmd.AddCommand(inspectCmd)
 	rootCmd.AddCommand(scriptsCmd)

cmd/relspec/split.go

@@ -24,6 +24,7 @@ var (
 	splitExcludeTables  string
 	splitNullableTypes  string
 	splitNullableArrays string
+	splitDryRun         bool
 )
 
 var splitCmd = &cobra.Command{
@@ -115,6 +116,8 @@ func init() {
 	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 '{}')")
 
+	splitCmd.Flags().BoolVar(&splitDryRun, "dry-run", false, "Read, filter and validate the selection and print the plan without writing any output")
+
 	err := splitCmd.MarkFlagRequired("from")
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error marking from flag as required: %v\n", err)
@@ -174,6 +177,26 @@ func runSplit(cmd *cobra.Command, args []string) error {
 	}
 	fmt.Fprintf(os.Stderr, "      ✓ Filtered to: %d schema(s), %d table(s)\n\n", len(filteredDB.Schemas), filteredTables)
 
+	if splitDryRun {
+		if err := validateWriteTarget(filteredDB, splitTargetType, splitPackageName, "", ""); err != nil {
+			return fmt.Errorf("dry run validation failed: %w", err)
+		}
+		out := outWriter(cmd)
+		fmt.Fprintf(out, "RelSpec split plan (dry run - nothing written):\n")
+		fmt.Fprintf(out, "  Input:  %s database '%s'\n", splitSourceType, db.Name)
+		fmt.Fprintf(out, "  Output: %s -> %s\n", splitTargetType, splitTargetPath)
+		fmt.Fprintf(out, "  Selection: %s\n", splitSelection{
+			Schemas:        parseCommaSeparated(splitSchemas),
+			Tables:         parseCommaSeparated(splitTables),
+			ExcludeSchemas: parseCommaSeparated(splitExcludeSchema),
+			ExcludeTables:  parseCommaSeparated(splitExcludeTables),
+			DatabaseName:   splitDatabaseName,
+		}.summary())
+		printDryRunPlan(out, filteredDB)
+		fmt.Fprintf(os.Stderr, "=== Dry run complete: no output written ===\n\n")
+		return nil
+	}
+
 	// Write to target format
 	fmt.Fprintf(os.Stderr, "[3/3] Writing to target format...\n")
 	fmt.Fprintf(os.Stderr, "      Format: %s\n", splitTargetType)

docs/FORMAT_EXAMPLES.md

@@ -0,0 +1,103 @@
+# Format Usage Examples
+
+Examples for `relspec convert` covering the file-based reader and writer
+formats. The "Writers" and "Readers" sections below were run against
+`examples/test_schema.dbml`. The cross-format and live-database examples were
+not run; they follow the flags shown in `relspec convert --help` and require
+matching input files or reachable databases.
+
+Any reader can be combined with any writer: pick `--from`/`--from-path` for the
+source and `--to`/`--to-path` for the target. Add `--silent` to suppress progress
+output.
+
+## Writers: DBML to every format
+
+```bash
+S="--from dbml --from-path examples/test_schema.dbml"
+
+relspec convert $S --to json    --to-path schema.json
+relspec convert $S --to yaml    --to-path schema.yaml
+relspec convert $S --to dctx    --to-path schema.dctx
+relspec convert $S --to drawdb  --to-path schema.drawdb.json
+relspec convert $S --to graphql --to-path schema.graphql
+relspec convert $S --to prisma  --to-path schema.prisma
+relspec convert $S --to pgsql   --to-path schema.pg.sql
+relspec convert $S --to mssql   --to-path schema.mssql.sql
+relspec convert $S --to sqlite  --to-path schema.sqlite.sql
+relspec convert $S --to drizzle --to-path schema.ts
+relspec convert $S --to typeorm --to-path entities.ts
+relspec convert $S --to gorm    --to-path models.go --package models
+relspec convert $S --to bun     --to-path models.go --package models
+```
+
+Notes:
+
+- Code-generation writers (`gorm`, `bun`) take `--package`. They also accept
+  `--types baselib|stdlib|sqltypes` to choose the nullable type package.
+- When `--to-path` is a directory it must already exist.
+- `sqlite` output automatically flattens `schema.table` names. Use
+  `--flatten-schema` for other formats if the target has no schema support.
+- `dctx` supports a single schema only; use `--schema <name>` to select one.
+
+## Readers: file-based formats into DBML (or JSON where noted)
+
+```bash
+relspec convert --from json     --from-path schema.json         --to dbml --to-path out.dbml
+relspec convert --from yaml     --from-path schema.yaml         --to dbml --to-path out.dbml
+relspec convert --from dctx     --from-path schema.dctx         --to dbml --to-path out.dbml
+relspec convert --from drawdb   --from-path schema.drawdb.json  --to dbml --to-path out.dbml
+relspec convert --from graphql  --from-path schema.graphql      --to dbml --to-path out.dbml
+relspec convert --from prisma   --from-path schema.prisma       --to dbml --to-path out.dbml
+relspec convert --from drizzle  --from-path schema.ts           --to dbml --to-path out.dbml
+relspec convert --from typeorm  --from-path entities.ts         --to dbml --to-path out.dbml
+relspec convert --from bun      --from-path models.go           --to dbml --to-path out.dbml
+relspec convert --from gorm     --from-path models.go           --to json --to-path out.json
+```
+
+Code-first readers (`gorm`, `bun`, `drizzle`, `typeorm`) accept a single file or a
+directory of model files.
+
+> Known issue: reading GORM models and writing DBML currently panics in the DBML
+> writer (`pkg/writers/dbml/writer.go`, `constraintToDBML`). Use another target
+> such as JSON until this is fixed.
+
+## Cross-format combinations
+
+```bash
+# ORM models to SQL DDL
+relspec convert --from gorm --from-path models.go --to pgsql --to-path schema.sql
+
+# Prisma to Drizzle
+relspec convert --from prisma --from-path schema.prisma --to drizzle --to-path schema.ts
+
+# DrawDB diagram to GraphQL
+relspec convert --from drawdb --from-path diagram.json --to graphql --to-path schema.graphql
+
+# Merge several files while converting
+relspec convert --from json --from-list "a.json,b.json" --to yaml --to-path merged.yaml
+```
+
+## Live databases
+
+These need a reachable database:
+
+```bash
+# PostgreSQL
+relspec convert --from pgsql --from-conn "postgres://user:pass@localhost:5432/mydb" \
+                --to dbml --to-path schema.dbml
+
+# SQL Server
+relspec convert --from mssql --from-conn "<mssql connection string>" \
+                --to json --to-path schema.json
+
+# SQLite database file (--from-conn takes the file path)
+relspec convert --from sqlite --from-conn ./app.db --to dbml --to-path schema.dbml
+```
+
+## Formats outside `convert`
+
+- `sqldir` (SQL script directory reader) and `sqlexec` (SQL execution writer) are
+  used by `relspec scripts` and `relspec job`, and `sqldir` by `relspec diff`.
+  See [SCRIPTS_COMMAND.md](SCRIPTS_COMMAND.md) and [JOB_FILES.md](JOB_FILES.md).
+- The `template` writer is exposed through `relspec templ`. See
+  [TEMPLATE_MODE.md](TEMPLATE_MODE.md).

docs/JOB_FILES.md

@@ -187,6 +187,8 @@ jobs:
       format: pgsql
       path: build/schema.sql                   # file output, OR:
       conn_env: TARGET_DB_URL                  # execute against DB (pgsql only)
+                                               # default: reads live DB, executes only the diff
+                                               # (file output = full DDL); set options.full_ddl to force full DDL
       overwrite: false                         # default false
     options:
       flatten_schema: false
@@ -195,6 +197,7 @@ jobs:
       types: sqltypes                           # Bun/GORM nullable types: baselib|stdlib|sqltypes
       array_nullable: pointer_slice             # Bun: slice|pointer_slice
       continue_on_error: false                 # pgsql / scripts-exec output
+      full_ddl: false                          # pgsql database output: true = run full DDL; default diffs against live DB
       skip_relations: false                    # merge only
       skip_enums: false
       skip_views: false

linux/arch/PKGBUILD

@@ -1,6 +1,6 @@
 # Maintainer: Hein (Warky Devs) <hein@warky.dev>
 pkgname=relspec
-pkgver=1.0.83
+pkgver=1.0.85
 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.83
+Version:        1.0.85
 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/jobs/jobs.go

@@ -285,11 +285,14 @@ type Options struct {
 	Types           string `yaml:"types"`
 	ArrayNullable   string `yaml:"array_nullable"`
 	ContinueOnError bool   `yaml:"continue_on_error"`
-	SkipRelations   bool   `yaml:"skip_relations"`
+	// FullDDL makes direct pgsql output execute the full idempotent DDL instead of
-	SkipEnums       bool   `yaml:"skip_enums"`
+	// diffing against the live database first.
-	SkipViews       bool   `yaml:"skip_views"`
+	FullDDL       bool `yaml:"full_ddl"`
-	SkipDomains     bool   `yaml:"skip_domains"`
+	SkipRelations bool `yaml:"skip_relations"`
-	SkipSequences   bool   `yaml:"skip_sequences"`
+	SkipEnums     bool `yaml:"skip_enums"`
+	SkipViews     bool `yaml:"skip_views"`
+	SkipDomains   bool `yaml:"skip_domains"`
+	SkipSequences bool `yaml:"skip_sequences"`
 }
 
 // Dir returns the directory that a job's relative paths resolve against:

pkg/readers/bun/README.md

@@ -64,6 +64,8 @@ The reader recognizes the following Bun struct tags:
 - `autoincrement` - Auto-increment column
 - `default` - Default value
 - `unique` - Unique constraint
+- `generated` - Generated column marker (`Generated`; expression is not in the tag)
+- `identity` - Identity column marker (`Identity`, `ALWAYS`)
 - `rel` - Relationship definition
 
 ## Example Bun Model

pkg/readers/bun/generated_column_test.go

@@ -0,0 +1,48 @@
+package bun
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/readers"
+)
+
+func TestReader_GeneratedAndIdentityMarkers(t *testing.T) {
+	src := `package models
+
+import "github.com/uptrace/bun"
+
+type Person struct {
+	bun.BaseModel ` + "`bun:\"table:people,alias:p\"`" + `
+
+	ID       int64  ` + "`bun:\"id,pk,type:bigint,autoincrement,identity\"`" + `
+	Seq      int64  ` + "`bun:\"seq,type:bigint,scanonly,identity,notnull\"`" + `
+	FullName string ` + "`bun:\"full_name,type:text,scanonly,generated,nullzero\"`" + `
+	First    string ` + "`bun:\"first,type:text,nullzero\"`" + `
+}
+`
+	path := filepath.Join(t.TempDir(), "person.go")
+	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := NewReader(&readers.ReaderOptions{FilePath: path}).ReadDatabase()
+	if err != nil {
+		t.Fatalf("ReadDatabase() error = %v", err)
+	}
+	cols := db.Schemas[0].Tables[0].Columns
+
+	if !cols["id"].Identity || cols["id"].IdentityGeneration != "ALWAYS" {
+		t.Errorf("id: identity = %v/%q, want true/ALWAYS", cols["id"].Identity, cols["id"].IdentityGeneration)
+	}
+	if !cols["seq"].Identity || cols["seq"].IdentityGeneration != "ALWAYS" {
+		t.Errorf("seq: identity = %v/%q, want true/ALWAYS", cols["seq"].Identity, cols["seq"].IdentityGeneration)
+	}
+	if !cols["full_name"].Generated {
+		t.Error("full_name should be generated")
+	}
+	if cols["first"].Generated || cols["first"].Identity {
+		t.Error("first must be an ordinary column")
+	}
+}

pkg/readers/bun/reader.go

@@ -659,6 +659,13 @@ func (r *Reader) parseColumn(fieldName string, fieldType ast.Expr, tag string, s
 			hasExplicitNullableMarker = true
 		case "autoincrement":
 			column.AutoIncrement = true
+		case "generated":
+			// GENERATED ... STORED marker written by the Bun writer; the expression is not in the tag
+			column.Generated = true
+		case "identity":
+			// GENERATED ALWAYS AS IDENTITY marker written by the Bun writer
+			column.Identity = true
+			column.IdentityGeneration = "ALWAYS"
 		case "default":
 			// Default value from Bun tag (e.g., default:gen_random_uuid())
 			column.Default = value

pkg/readers/dbml/README.md

@@ -157,6 +157,7 @@ grammar and the supported-directive matrix.
 
 ## Notes
 
+- Column notes `GENERATED ALWAYS AS (expr) STORED` and `GENERATED ALWAYS|BY DEFAULT AS IDENTITY` set `Generated`/`GenerationExpression` and `Identity`/`IdentityGeneration`; they are not kept as comments
 - DBML is designed for database documentation and diagramming
 - Schema name defaults to `public`
 - Relationship cardinality is preserved

pkg/readers/dbml/generated_columns.go

@@ -0,0 +1,38 @@
+package dbml
+
+import (
+	"regexp"
+	"strings"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
+
+var (
+	generatedNoteRegex = regexp.MustCompile(`(?is)^GENERATED\s+ALWAYS\s+AS\s*\((.*)\)\s*STORED$`)
+	identityNoteRegex  = regexp.MustCompile(`(?i)^GENERATED\s+(ALWAYS|BY\s+DEFAULT)\s+AS\s+IDENTITY$`)
+)
+
+// applyColumnMarkerNote interprets a column note written by the DBML writer for
+// GENERATED ... STORED and GENERATED ... AS IDENTITY columns, setting the matching
+// model fields. It returns true when the note was a marker, in which case it is not
+// a user comment.
+func applyColumnMarkerNote(column *models.Column, rawNote string) bool {
+	note := strings.TrimSpace(rawNote)
+	if len(note) >= 2 && (note[0] == '\'' || note[0] == '"') && note[len(note)-1] == note[0] {
+		note = note[1 : len(note)-1]
+	}
+	note = strings.ReplaceAll(strings.ReplaceAll(note, `\'`, `'`), `\\`, `\`)
+	note = strings.TrimSpace(note)
+
+	if m := generatedNoteRegex.FindStringSubmatch(note); m != nil {
+		column.Generated = true
+		column.GenerationExpression = strings.TrimSpace(m[1])
+		return true
+	}
+	if m := identityNoteRegex.FindStringSubmatch(note); m != nil {
+		column.Identity = true
+		column.IdentityGeneration = strings.Join(strings.Fields(strings.ToUpper(m[1])), " ")
+		return true
+	}
+	return false
+}

pkg/readers/dbml/reader.go

@@ -804,7 +804,9 @@ func (r *Reader) parseColumn(line, tableName, schemaName string) (*models.Column
 			} else if strings.HasPrefix(attr, "note:") {
 				// Parse column note/comment
 				note := strings.TrimSpace(strings.TrimPrefix(attr, "note:"))
-				column.Comment = strings.Trim(note, "'\"")
+				if !applyColumnMarkerNote(column, note) {
+					column.Comment = strings.Trim(note, "'\"")
+				}
 			} else if strings.HasPrefix(attr, "ref:") {
 				// Parse inline reference
 				// DBML semantics depend on context:

pkg/readers/drizzle/README.md

@@ -85,6 +85,7 @@ export const postsRelations = relations(posts, ({ one }) => ({
 
 ## Notes
 
+- `.generatedAlwaysAs(sql`expr`)` sets `Generated` + `GenerationExpression`; `.generatedAlwaysAsIdentity()` / `.generatedByDefaultAsIdentity()` set `Identity` + `IdentityGeneration`
 - Supports both PostgreSQL and MySQL Drizzle schemas
 - Extracts relationship information from `relations` definitions
 - Schema defaults to `public` for PostgreSQL

pkg/readers/drizzle/reader.go

@@ -495,9 +495,24 @@ func (r *Reader) parseColumnModifiers(line string, column *models.Column, table
 		}
 	}
 
-	// Check for .generatedAlwaysAsIdentity()
+	// Check for .generatedAlwaysAsIdentity() / .generatedByDefaultAsIdentity()
 	if strings.Contains(line, ".generatedAlwaysAsIdentity()") {
 		column.AutoIncrement = true
+		column.Identity = true
+		column.IdentityGeneration = "ALWAYS"
+	}
+	if strings.Contains(line, ".generatedByDefaultAsIdentity()") {
+		column.AutoIncrement = true
+		column.Identity = true
+		column.IdentityGeneration = "BY DEFAULT"
+	}
+
+	// Check for .generatedAlwaysAs(sql`expr`) (generated column)
+	if idx := strings.Index(line, ".generatedAlwaysAs("); idx != -1 {
+		if expr, ok := parseGeneratedAlwaysAs(line[idx+len(".generatedAlwaysAs("):]); ok {
+			column.Generated = true
+			column.GenerationExpression = expr
+		}
 	}
 
 	// Check for .references(() => otherTable.column)
@@ -615,3 +630,34 @@ func (r *Reader) varNameToTableName(varName string) string {
 	// For now, assume variable name matches table name
 	return varName
 }
+
+// parseGeneratedAlwaysAs extracts the SQL expression from the argument list of
+// generatedAlwaysAs(...), which follows the opening parenthesis in rest. The expression is
+// the contents of a sql`...` template (backticks inside it are escaped with a backslash)
+// or, failing that, a quoted string.
+func parseGeneratedAlwaysAs(rest string) (string, bool) {
+	rest = strings.TrimSpace(rest)
+	rest = strings.TrimPrefix(rest, "sql")
+	if rest == "" {
+		return "", false
+	}
+	quote := rest[0]
+	if quote != '`' && quote != '\'' && quote != '"' {
+		return "", false
+	}
+
+	var sb strings.Builder
+	for i := 1; i < len(rest); i++ {
+		ch := rest[i]
+		if ch == '\\' && i+1 < len(rest) {
+			i++
+			sb.WriteByte(rest[i])
+			continue
+		}
+		if ch == quote {
+			return strings.TrimSpace(sb.String()), true
+		}
+		sb.WriteByte(ch)
+	}
+	return "", false
+}

pkg/readers/gorm/README.md

@@ -78,6 +78,8 @@ The reader recognizes the following GORM struct tags:
 - `not null` - NOT NULL constraint
 - `autoIncrement` - Auto-increment column
 - `default` - Default value
+- `generated` - Generated column marker (`Generated`; expression is not in the tag)
+- `identity` - Identity column marker (`Identity`, `ALWAYS`)
 - `size` - Column size/length
 - `index` - Create index
 - `uniqueIndex` - Create unique index

pkg/readers/gorm/generated_column_test.go

@@ -0,0 +1,48 @@
+package gorm
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/readers"
+)
+
+func TestReader_GeneratedAndIdentityMarkers(t *testing.T) {
+	src := `package models
+
+type Person struct {
+	ID       int64  ` + "`gorm:\"column:id;primaryKey;autoIncrement;type:bigint;identity\"`" + `
+	Seq      int64  ` + "`gorm:\"column:seq;type:bigint;<-:false;identity;not null\"`" + `
+	FullName string ` + "`gorm:\"column:full_name;type:text;<-:false;generated\"`" + `
+	First    string ` + "`gorm:\"column:first;type:text\"`" + `
+}
+
+func (Person) TableName() string {
+	return "people"
+}
+`
+	path := filepath.Join(t.TempDir(), "person.go")
+	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := NewReader(&readers.ReaderOptions{FilePath: path}).ReadDatabase()
+	if err != nil {
+		t.Fatalf("ReadDatabase() error = %v", err)
+	}
+	cols := db.Schemas[0].Tables[0].Columns
+
+	if !cols["id"].Identity || cols["id"].IdentityGeneration != "ALWAYS" {
+		t.Errorf("id: identity = %v/%q, want true/ALWAYS", cols["id"].Identity, cols["id"].IdentityGeneration)
+	}
+	if !cols["seq"].Identity {
+		t.Error("seq should be identity")
+	}
+	if !cols["full_name"].Generated {
+		t.Error("full_name should be generated")
+	}
+	if cols["first"].Generated || cols["first"].Identity {
+		t.Error("first must be an ordinary column")
+	}
+}

pkg/readers/gorm/reader.go

@@ -726,6 +726,15 @@ func (r *Reader) parseColumn(fieldName string, fieldType ast.Expr, tag string, s
 	if _, ok := parts["autoincrement"]; ok {
 		column.AutoIncrement = true
 	}
+	if _, ok := parts["generated"]; ok {
+		// GENERATED ... STORED marker written by the GORM writer; the expression is not in the tag
+		column.Generated = true
+	}
+	if _, ok := parts["identity"]; ok {
+		// GENERATED ALWAYS AS IDENTITY marker written by the GORM writer
+		column.Identity = true
+		column.IdentityGeneration = "ALWAYS"
+	}
 	if def, ok := parts["default"]; ok {
 		// Default value from GORM tag (e.g., default:gen_random_uuid())
 		column.Default = def

pkg/readers/mssql/README.md

@@ -25,6 +25,11 @@ sqlserver://user:pass@192.168.1.100:1433/production
 sqlserver://localhost/testdb?encrypt=disable
 ```
 
+## Computed and Identity Columns
+
+- `sys.computed_columns` -> `Generated` + `GenerationExpression` (outer parentheses removed; persisted or not)
+- Identity columns -> `Identity` + `IdentityGeneration = ALWAYS`
+
 ## Supported Constraints
 
 - Primary Keys

pkg/readers/mssql/queries.go

@@ -104,8 +104,12 @@ func (r *Reader) queryColumns(schemaName string) (map[string]map[string]*models.
 			c.numeric_precision,
 			c.numeric_scale,
 			ISNULL(ep.value, '') as description,
-			COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), c.column_name, 'IsIdentity') as is_identity
+			COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), c.column_name, 'IsIdentity') as is_identity,
+			cc.definition as computed_definition
 		FROM information_schema.columns c
+		LEFT JOIN sys.computed_columns cc
+			ON cc.object_id = OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name))
+			AND cc.name = c.column_name
 		LEFT JOIN sys.extended_properties ep
 			ON ep.major_id = OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name))
 			AND ep.minor_id = COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), c.column_name, 'ColumnId')
@@ -127,8 +131,9 @@ func (r *Reader) queryColumns(schemaName string) (map[string]map[string]*models.
 		var schema, tableName, columnName, isNullable, dataType, description string
 		var ordinalPosition int
 		var columnDefault, charMaxLength, numPrecision, numScale, isIdentity *int
+		var computedDefinition *string
 
-		if err := rows.Scan(&schema, &tableName, &columnName, &ordinalPosition, &columnDefault, &isNullable, &dataType, &charMaxLength, &numPrecision, &numScale, &description, &isIdentity); err != nil {
+		if err := rows.Scan(&schema, &tableName, &columnName, &ordinalPosition, &columnDefault, &isNullable, &dataType, &charMaxLength, &numPrecision, &numScale, &description, &isIdentity, &computedDefinition); err != nil {
 			return nil, err
 		}
 
@@ -144,6 +149,14 @@ func (r *Reader) queryColumns(schemaName string) (map[string]map[string]*models.
 		// Check if this is an identity column (auto-increment)
 		if isIdentity != nil && *isIdentity == 1 {
 			column.AutoIncrement = true
+			column.Identity = true
+			column.IdentityGeneration = "ALWAYS"
+		}
+
+		// Computed columns report their expression wrapped in an extra pair of parentheses
+		if computedDefinition != nil && strings.TrimSpace(*computedDefinition) != "" {
+			column.Generated = true
+			column.GenerationExpression = trimOuterParens(*computedDefinition)
 		}
 
 		if charMaxLength != nil && *charMaxLength > 0 {
@@ -414,3 +427,25 @@ func (r *Reader) queryIndexes(schemaName string) (map[string][]*models.Index, er
 
 	return indexes, rows.Err()
 }
+
+// trimOuterParens removes one pair of parentheses wrapping the whole expression, as
+// SQL Server stores computed column definitions.
+func trimOuterParens(expr string) string {
+	expr = strings.TrimSpace(expr)
+	if len(expr) < 2 || expr[0] != '(' || expr[len(expr)-1] != ')' {
+		return expr
+	}
+	depth := 0
+	for i := 0; i < len(expr); i++ {
+		switch expr[i] {
+		case '(':
+			depth++
+		case ')':
+			depth--
+			if depth == 0 && i != len(expr)-1 {
+				return expr
+			}
+		}
+	}
+	return strings.TrimSpace(expr[1 : len(expr)-1])
+}

pkg/readers/mssql/reader_test.go

@@ -85,3 +85,18 @@ func TestConvertMSSQLToCanonical(t *testing.T) {
 		})
 	}
 }
+
+func TestTrimOuterParens(t *testing.T) {
+	tests := map[string]string{
+		"(([a])+([b]))":   "([a])+([b])",
+		"([a]+[b])":       "[a]+[b]",
+		"([a])+([b])":     "([a])+([b])",
+		"[a]+[b]":         "[a]+[b]",
+		"  (upper([a])) ": "upper([a])",
+	}
+	for in, want := range tests {
+		if got := trimOuterParens(in); got != want {
+			t.Errorf("trimOuterParens(%q) = %q, want %q", in, got, want)
+		}
+	}
+}

pkg/readers/pgsql/queries.go

@@ -422,31 +422,35 @@ func (r *Reader) queryPrimaryKeys(schemaName string) (map[string]*models.Constra
 // queryForeignKeys retrieves all foreign key constraints for a schema
 // Returns map[schema.table][]*Constraint
 func (r *Reader) queryForeignKeys(schemaName string) (map[string][]*models.Constraint, error) {
+	// Columns are paired by position from pg_constraint so composite keys are not
+	// cross-joined (information_schema.constraint_column_usage has no ordering).
+	actionCase := func(col string) string {
+		return `CASE ` + col + ` WHEN 'a' THEN 'NO ACTION' WHEN 'r' THEN 'RESTRICT' WHEN 'c' THEN 'CASCADE' WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT' END`
+	}
 	query := `
 		SELECT
-			tc.table_schema,
+			ns.nspname AS table_schema,
-			tc.table_name,
+			cl.relname AS table_name,
-			tc.constraint_name,
+			con.conname AS constraint_name,
-			kcu.table_schema as foreign_table_schema,
+			ns.nspname AS foreign_table_schema,
-			kcu.table_name as foreign_table_name,
+			cl.relname AS foreign_table_name,
-			kcu.column_name as foreign_column,
+			att.attname AS foreign_column,
-			ccu.table_schema as referenced_table_schema,
+			fns.nspname AS referenced_table_schema,
-			ccu.table_name as referenced_table_name,
+			fcl.relname AS referenced_table_name,
-			ccu.column_name as referenced_column,
+			fatt.attname AS referenced_column,
-			rc.update_rule,
+			` + actionCase("con.confupdtype") + ` AS update_rule,
-			rc.delete_rule
+			` + actionCase("con.confdeltype") + ` AS delete_rule
-		FROM information_schema.table_constraints tc
+		FROM pg_catalog.pg_constraint con
-		JOIN information_schema.key_column_usage kcu
+		JOIN pg_catalog.pg_class cl ON cl.oid = con.conrelid
-			ON tc.constraint_name = kcu.constraint_name
+		JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
-			AND tc.table_schema = kcu.table_schema
+		JOIN pg_catalog.pg_class fcl ON fcl.oid = con.confrelid
-		JOIN information_schema.constraint_column_usage ccu
+		JOIN pg_catalog.pg_namespace fns ON fns.oid = fcl.relnamespace
-			ON ccu.constraint_name = tc.constraint_name
+		CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS k(attnum, fattnum, ord)
-		JOIN information_schema.referential_constraints rc
+		JOIN pg_catalog.pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = k.attnum
-			ON rc.constraint_name = tc.constraint_name
+		JOIN pg_catalog.pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = k.fattnum
-			AND rc.constraint_schema = tc.table_schema
+		WHERE con.contype = 'f'
-		WHERE tc.constraint_type = 'FOREIGN KEY'
+		  AND ns.nspname = $1
-		  AND tc.table_schema = $1
+		ORDER BY ns.nspname, cl.relname, con.conname, k.ord
-		ORDER BY tc.table_schema, tc.table_name, tc.constraint_name, kcu.ordinal_position
 	`
 
 	rows, err := r.conn.Query(r.ctx, query, schemaName)

pkg/readers/pgsql/reader_test.go

@@ -1,10 +1,14 @@
 package pgsql
 
 import (
+	"context"
 	"os"
 	"reflect"
+	"strings"
 	"testing"
 
+	"github.com/jackc/pgx/v5"
+
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/readers"
 )
@@ -499,3 +503,60 @@ func TestMapDataType_ExtensionTypesPreserveModifiers(t *testing.T) {
 		})
 	}
 }
+
+func TestReader_CompositeForeignKeyColumnsArePairedOnce(t *testing.T) {
+	connStr := getTestConnectionString(t)
+
+	ctx := context.Background()
+	conn, err := pgx.Connect(ctx, connStr)
+	if err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer conn.Close(ctx)
+
+	const schema = "relspec_fk_test"
+	setup := []string{
+		"DROP SCHEMA IF EXISTS " + schema + " CASCADE",
+		"CREATE SCHEMA " + schema,
+		"CREATE TABLE " + schema + ".parent (a int, b int, PRIMARY KEY (a, b))",
+		"CREATE TABLE " + schema + ".child (x int, y int, CONSTRAINT fk_child_parent FOREIGN KEY (x, y) REFERENCES " + schema + ".parent (a, b) ON DELETE CASCADE)",
+	}
+	for _, stmt := range setup {
+		if _, err := conn.Exec(ctx, stmt); err != nil {
+			t.Fatalf("setup %q: %v", stmt, err)
+		}
+	}
+	defer conn.Exec(ctx, "DROP SCHEMA IF EXISTS "+schema+" CASCADE")
+
+	reader := NewReader(&readers.ReaderOptions{ConnectionString: connStr})
+	db, err := reader.ReadDatabase()
+	if err != nil {
+		t.Fatalf("ReadDatabase: %v", err)
+	}
+
+	for _, s := range db.Schemas {
+		if s.Name != schema {
+			continue
+		}
+		for _, tbl := range s.Tables {
+			if tbl.Name != "child" {
+				continue
+			}
+			fk := tbl.Constraints["fk_child_parent"]
+			if fk == nil {
+				t.Fatal("foreign key fk_child_parent not read")
+			}
+			if got := strings.Join(fk.Columns, ","); got != "x,y" {
+				t.Errorf("columns = %q, want x,y", got)
+			}
+			if got := strings.Join(fk.ReferencedColumns, ","); got != "a,b" {
+				t.Errorf("referenced columns = %q, want a,b", got)
+			}
+			if fk.OnDelete != "CASCADE" || fk.OnUpdate != "NO ACTION" {
+				t.Errorf("rules = %s/%s, want CASCADE/NO ACTION", fk.OnDelete, fk.OnUpdate)
+			}
+			return
+		}
+	}
+	t.Fatal("test schema/table not found in read result")
+}

pkg/readers/sqlite/README.md

@@ -40,6 +40,7 @@ options := &readers.ReaderOptions{
 - Uses pure Go driver (modernc.org/sqlite) - no CGo required
 - Supports both file path and connection string
 - Auto-increment detection for INTEGER PRIMARY KEY columns
+- Generated columns (virtual and stored) are read via `PRAGMA table_xinfo`; the expression is parsed from the `CREATE TABLE` SQL
 - Foreign keys require `PRAGMA foreign_keys = ON` to be set
 
 ## Example Schema

pkg/readers/sqlite/generated.go

@@ -0,0 +1,116 @@
+package sqlite
+
+import (
+	"regexp"
+	"strings"
+)
+
+var generatedAsRegex = regexp.MustCompile(`(?is)\bAS\s*\(`)
+
+// parseGeneratedExpression extracts the expression of a generated column from a CREATE
+// TABLE statement, e.g. `full TEXT GENERATED ALWAYS AS (a || b) STORED` yields `a || b`.
+// It returns "" when the column or its expression cannot be found.
+func parseGeneratedExpression(createSQL, columnName string) string {
+	open := strings.Index(createSQL, "(")
+	if open < 0 {
+		return ""
+	}
+
+	for _, def := range splitTopLevel(createSQL[open+1:]) {
+		if !strings.EqualFold(firstIdentifier(def), columnName) {
+			continue
+		}
+		loc := generatedAsRegex.FindStringIndex(def)
+		if loc == nil {
+			return ""
+		}
+		return balancedParens(def[loc[1]-1:])
+	}
+	return ""
+}
+
+// splitTopLevel splits a table body on commas that are outside parentheses and quotes,
+// stopping at the parenthesis that closes the body.
+func splitTopLevel(body string) []string {
+	var parts []string
+	depth := 0
+	var quote byte
+	start := 0
+	for i := 0; i < len(body); i++ {
+		ch := body[i]
+		if quote != 0 {
+			if ch == quote {
+				quote = 0
+			}
+			continue
+		}
+		switch ch {
+		case '\'', '"', '`':
+			quote = ch
+		case '[':
+			quote = ']'
+		case '(':
+			depth++
+		case ')':
+			if depth == 0 {
+				return append(parts, body[start:i])
+			}
+			depth--
+		case ',':
+			if depth == 0 {
+				parts = append(parts, body[start:i])
+				start = i + 1
+			}
+		}
+	}
+	return append(parts, body[start:])
+}
+
+// firstIdentifier returns the first (possibly quoted) identifier of a column definition.
+func firstIdentifier(def string) string {
+	def = strings.TrimSpace(def)
+	if def == "" {
+		return ""
+	}
+	switch def[0] {
+	case '"', '\'', '`':
+		if end := strings.IndexByte(def[1:], def[0]); end >= 0 {
+			return def[1 : 1+end]
+		}
+	case '[':
+		if end := strings.IndexByte(def, ']'); end >= 0 {
+			return def[1:end]
+		}
+	}
+	if end := strings.IndexAny(def, " \t\r\n"); end >= 0 {
+		return def[:end]
+	}
+	return def
+}
+
+// balancedParens returns the text inside the parenthesis group that starts at s[0].
+func balancedParens(s string) string {
+	depth := 0
+	var quote byte
+	for i := 0; i < len(s); i++ {
+		ch := s[i]
+		if quote != 0 {
+			if ch == quote {
+				quote = 0
+			}
+			continue
+		}
+		switch ch {
+		case '\'', '"':
+			quote = ch
+		case '(':
+			depth++
+		case ')':
+			depth--
+			if depth == 0 {
+				return strings.TrimSpace(s[1:i])
+			}
+		}
+	}
+	return ""
+}

pkg/readers/sqlite/generated_test.go

@@ -0,0 +1,64 @@
+package sqlite
+
+import (
+	"database/sql"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/readers"
+)
+
+func TestParseGeneratedExpression(t *testing.T) {
+	createSQL := `CREATE TABLE people (
+		id INTEGER PRIMARY KEY,
+		"first" TEXT,
+		last TEXT,
+		full_name TEXT GENERATED ALWAYS AS (coalesce("first", '') || ' ' || last) STORED,
+		initials TEXT AS (substr("first", 1, 1) || substr(last, 1, 1)),
+		plain TEXT NOT NULL
+	)`
+
+	tests := []struct {
+		column string
+		want   string
+	}{
+		{"full_name", `coalesce("first", '') || ' ' || last`},
+		{"initials", `substr("first", 1, 1) || substr(last, 1, 1)`},
+		{"plain", ""},
+		{"missing", ""},
+	}
+	for _, tt := range tests {
+		t.Run(tt.column, func(t *testing.T) {
+			assert.Equal(t, tt.want, parseGeneratedExpression(createSQL, tt.column))
+		})
+	}
+}
+
+func TestReader_GeneratedColumns(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "gen.db")
+	db, err := sql.Open("sqlite", dbPath)
+	require.NoError(t, err)
+	_, err = db.Exec(`CREATE TABLE people (
+		id INTEGER PRIMARY KEY,
+		first TEXT,
+		last TEXT,
+		full_name TEXT GENERATED ALWAYS AS (first || ' ' || last) STORED,
+		initials TEXT AS (substr(first, 1, 1) || substr(last, 1, 1))
+	)`)
+	require.NoError(t, err)
+	require.NoError(t, db.Close())
+
+	got, err := NewReader(&readers.ReaderOptions{FilePath: dbPath}).ReadDatabase()
+	require.NoError(t, err)
+
+	cols := got.Schemas[0].Tables[0].Columns
+	require.Contains(t, cols, "full_name", "generated columns must be read")
+	assert.True(t, cols["full_name"].Generated)
+	assert.Equal(t, "first || ' ' || last", cols["full_name"].GenerationExpression)
+	assert.True(t, cols["initials"].Generated)
+	assert.Equal(t, "substr(first, 1, 1) || substr(last, 1, 1)", cols["initials"].GenerationExpression)
+	assert.False(t, cols["first"].Generated)
+}

pkg/readers/sqlite/queries.go

@@ -75,7 +75,8 @@ func (r *Reader) queryViews() ([]*models.View, error) {
 
 // queryColumns retrieves all columns for a given table or view
 func (r *Reader) queryColumns(tableName string) (map[string]*models.Column, error) {
-	query := fmt.Sprintf("PRAGMA table_info(%s)", tableName)
+	// table_xinfo, unlike table_info, also lists generated columns (hidden = 2 virtual, 3 stored)
+	query := fmt.Sprintf("PRAGMA table_xinfo(%s)", tableName)
 
 	rows, err := r.db.QueryContext(r.ctx, query)
 	if err != nil {
@@ -84,24 +85,38 @@ func (r *Reader) queryColumns(tableName string) (map[string]*models.Column, erro
 	defer rows.Close()
 
 	columns := make(map[string]*models.Column)
+	var tableSQL string
+	tableSQLLoaded := false
 
 	for rows.Next() {
 		var cid int
 		var name, dataType string
-		var notNull, pk int
+		var notNull, pk, hidden int
 		var defaultValue *string
 
-		if err := rows.Scan(&cid, &name, &dataType, &notNull, &defaultValue, &pk); err != nil {
+		if err := rows.Scan(&cid, &name, &dataType, &notNull, &defaultValue, &pk, &hidden); err != nil {
 			return nil, err
 		}
 
+		// Hidden virtual-table columns (hidden = 1) are not part of the schema
+		if hidden == 1 {
+			continue
+		}
+
 		column := models.InitColumn(name, tableName, "main")
 		column.Type = r.mapDataType(strings.ToUpper(dataType))
 		column.NotNull = (notNull == 1)
 		column.IsPrimaryKey = (pk > 0)
 		column.Sequence = uint(cid + 1)
 
-		if defaultValue != nil {
+		if hidden == 2 || hidden == 3 {
+			column.Generated = true
+			if !tableSQLLoaded {
+				tableSQL = r.tableSQL(tableName)
+				tableSQLLoaded = true
+			}
+			column.GenerationExpression = parseGeneratedExpression(tableSQL, name)
+		} else if defaultValue != nil {
 			column.Default = *defaultValue
 		}
 
@@ -116,6 +131,16 @@ func (r *Reader) queryColumns(tableName string) (map[string]*models.Column, erro
 	return columns, rows.Err()
 }
 
+// tableSQL returns the CREATE TABLE statement of a table, or "" when it cannot be read.
+func (r *Reader) tableSQL(tableName string) string {
+	var sql string
+	err := r.db.QueryRowContext(r.ctx, `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?`, tableName).Scan(&sql)
+	if err != nil {
+		return ""
+	}
+	return sql
+}
+
 // isAutoIncrement checks if a column is autoincrement
 func (r *Reader) isAutoIncrement(tableName, columnName string) bool {
 	// Check sqlite_sequence table or parse CREATE TABLE statement

pkg/readers/typeorm/README.md

@@ -114,6 +114,8 @@ export class Post {
 - `@JoinColumn()` - Foreign key column
 - `@Index()` - Index definition
 - `@Unique()` - Unique constraint
+- `asExpression` / `generatedType` - Generated column (`Generated` + `GenerationExpression`)
+- `@PrimaryGeneratedColumn('identity')`, `@Generated('identity')`, `generatedIdentity` - Identity column
 
 ## Notes
 

pkg/readers/typeorm/reader.go

@@ -128,7 +128,6 @@ func (r *Reader) extractEntities(content string) []entityInfo {
 	scanner := bufio.NewScanner(strings.NewReader(content))
 
 	entityRegex := regexp.MustCompile(`^export\s+class\s+(\w+)`)
-	decoratorRegex := regexp.MustCompile(`^\s*@(\w+)(\([^)]*\))?`)
 	fieldRegex := regexp.MustCompile(`^\s*(\w+):\s*([^;]+);`)
 
 	var currentEntity *entityInfo
@@ -145,8 +144,7 @@ func (r *Reader) extractEntities(content string) []entityInfo {
 		}
 
 		// Check for decorator
-		if matches := decoratorRegex.FindStringSubmatch(trimmed); matches != nil {
+		if decorator, ok := matchDecorator(trimmed); ok {
-			decorator := matches[0]
 			pendingDecorators = append(pendingDecorators, decorator)
 			continue
 		}
@@ -488,7 +486,11 @@ func (r *Reader) parseColumnDecorator(decorator string, column *models.Column, t
 		column.IsPrimaryKey = true
 		column.NotNull = true
 
-		if strings.Contains(decorator, "'uuid'") {
+		if strings.Contains(decorator, "'identity'") {
+			column.AutoIncrement = true
+			column.Identity = true
+			column.IdentityGeneration = parseGeneratedIdentity(decorator)
+		} else if strings.Contains(decorator, "'uuid'") {
 			column.Type = "uuid"
 			column.Default = "gen_random_uuid()"
 		} else if strings.Contains(decorator, "'increment'") || strings.Contains(decorator, "()") {
@@ -497,6 +499,17 @@ func (r *Reader) parseColumnDecorator(decorator string, column *models.Column, t
 		return
 	}
 
+	// @Generated('identity') on a non-key column; generatedIdentity is read from @Column
+	if strings.HasPrefix(decorator, "@Generated") {
+		if strings.Contains(decorator, "'identity'") {
+			column.Identity = true
+			if column.IdentityGeneration == "" {
+				column.IdentityGeneration = "BY DEFAULT"
+			}
+		}
+		return
+	}
+
 	// @Column
 	if strings.HasPrefix(decorator, "@Column") {
 		r.parseColumnOptions(decorator, column, table)
@@ -586,6 +599,14 @@ func (r *Reader) parseColumnOptions(decorator string, column *models.Column, tab
 		}
 	}
 
+	if matches := asExpressionRegex.FindStringSubmatch(content); matches != nil {
+		column.Generated = true
+		column.GenerationExpression = unescapeSingleQuoted(matches[1])
+	}
+	if strings.Contains(content, "generatedIdentity") {
+		column.IdentityGeneration = parseGeneratedIdentity(content)
+	}
+
 	if strings.Contains(content, "nullable: true") || strings.Contains(content, "nullable:true") {
 		column.NotNull = false
 	}
@@ -834,3 +855,72 @@ func (r *Reader) getPrimaryKeyColumn(table *models.Table) *models.Column {
 
 	return pk
 }
+
+var (
+	asExpressionRegex       = regexp.MustCompile(`asExpression:\s*'((?:\\.|[^\\'])*)'`)
+	generatedIdentityRegexp = regexp.MustCompile(`generatedIdentity:\s*['"](ALWAYS|BY DEFAULT)['"]`)
+)
+
+// parseGeneratedIdentity returns the identity generation mode named in a decorator
+// ("ALWAYS" or "BY DEFAULT"), defaulting to "BY DEFAULT" as TypeORM does.
+func parseGeneratedIdentity(decorator string) string {
+	if matches := generatedIdentityRegexp.FindStringSubmatch(decorator); matches != nil {
+		return matches[1]
+	}
+	return "BY DEFAULT"
+}
+
+// unescapeSingleQuoted reverses escaping applied inside a quoted TypeScript string.
+func unescapeSingleQuoted(s string) string {
+	var sb strings.Builder
+	for i := 0; i < len(s); i++ {
+		if s[i] == '\\' && i+1 < len(s) {
+			i++
+		}
+		sb.WriteByte(s[i])
+	}
+	return sb.String()
+}
+
+var decoratorNameRegex = regexp.MustCompile(`^@\w+`)
+
+// matchDecorator returns the decorator at the start of line, including its argument list.
+// Parentheses inside quoted strings (e.g. a generated column expression) do not end it.
+func matchDecorator(line string) (string, bool) {
+	name := decoratorNameRegex.FindString(line)
+	if name == "" {
+		return "", false
+	}
+	rest := line[len(name):]
+	if !strings.HasPrefix(rest, "(") {
+		return name, true
+	}
+
+	depth := 0
+	var quote byte
+	for i := 0; i < len(rest); i++ {
+		ch := rest[i]
+		if quote != 0 {
+			switch ch {
+			case '\\':
+				i++
+			case quote:
+				quote = 0
+			}
+			continue
+		}
+		switch ch {
+		case '\'', '"', '`':
+			quote = ch
+		case '(':
+			depth++
+		case ')':
+			depth--
+			if depth == 0 {
+				return name + rest[:i+1], true
+			}
+		}
+	}
+	// Unterminated argument list: keep the whole line, as a best effort
+	return line, true
+}

pkg/ui/domain_screens.go

@@ -207,6 +207,10 @@ func (se *SchemaEditor) showDomainEditor(index int, domain *models.Domain) {
 		se.showDomainList()
 	})
 
+	form.AddButton("Tables", func() {
+		se.showDomainTables(index)
+	})
+
 	form.AddButton("Delete", func() {
 		se.showDeleteDomainConfirm(index)
 	})

pkg/ui/main_menu.go

@@ -39,6 +39,18 @@ func (se *SchemaEditor) createMainMenu() tview.Primitive {
 		AddItem("Manage Domains", "View, create, edit, and delete domains", 'd', func() {
 			se.showDomainList()
 		}).
+		AddItem("Manage Indexes", "View, create, edit, and delete table indexes", 'x', func() {
+			se.showObjectList(se.indexKind())
+		}).
+		AddItem("Manage Views", "View, create, edit, and delete views", 'v', func() {
+			se.showObjectList(se.viewKind())
+		}).
+		AddItem("Manage Sequences", "View, create, edit, and delete sequences", 'u', func() {
+			se.showObjectList(se.sequenceKind())
+		}).
+		AddItem("Manage Scripts", "View, create, edit, and delete SQL scripts", 'c', func() {
+			se.showObjectList(se.scriptKind())
+		}).
 		AddItem("Import & Merge", "Import and merge schema from another database", 'i', func() {
 			se.showImportScreen()
 		}).

pkg/ui/object_dataops.go

@@ -0,0 +1,263 @@
+package ui
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
+
+// Data operations for indexes, views, sequences, scripts and domain/table assignment.
+
+func (se *SchemaEditor) schemaAt(schemaIndex int) (*models.Schema, error) {
+	if schemaIndex < 0 || schemaIndex >= len(se.db.Schemas) {
+		return nil, errors.New("schema not found")
+	}
+	return se.db.Schemas[schemaIndex], nil
+}
+
+func (se *SchemaEditor) tableAt(schemaIndex, tableIndex int) (*models.Schema, *models.Table, error) {
+	schema, err := se.schemaAt(schemaIndex)
+	if err != nil {
+		return nil, nil, err
+	}
+	if tableIndex < 0 || tableIndex >= len(schema.Tables) {
+		return nil, nil, errors.New("table not found")
+	}
+	return schema, schema.Tables[tableIndex], nil
+}
+
+// splitList splits a comma separated list, trimming blanks and dropping empty entries.
+func splitList(s string) []string {
+	parts := make([]string, 0)
+	for _, p := range strings.Split(s, ",") {
+		if p = strings.TrimSpace(p); p != "" {
+			parts = append(parts, p)
+		}
+	}
+	return parts
+}
+
+// SaveIndex adds an index to a table. When oldName is non-empty the index of that
+// name is replaced (and renamed if needed).
+func (se *SchemaEditor) SaveIndex(schemaIndex, tableIndex int, oldName string, idx *models.Index) error {
+	schema, table, err := se.tableAt(schemaIndex, tableIndex)
+	if err != nil {
+		return err
+	}
+	idx.Name = strings.TrimSpace(idx.Name)
+	if idx.Name == "" {
+		return errors.New("index name is required")
+	}
+	if len(idx.Columns) == 0 {
+		return errors.New("index needs at least one column")
+	}
+	for _, c := range idx.Columns {
+		if _, ok := table.Columns[c]; !ok {
+			return fmt.Errorf("column %q not found in table %s", c, table.Name)
+		}
+	}
+	if _, exists := table.Indexes[idx.Name]; exists && idx.Name != oldName {
+		return fmt.Errorf("index %q already exists", idx.Name)
+	}
+	if table.Indexes == nil {
+		table.Indexes = make(map[string]*models.Index)
+	}
+	if oldName != "" {
+		delete(table.Indexes, oldName)
+	}
+	idx.Table = table.Name
+	idx.Schema = schema.Name
+	table.Indexes[idx.Name] = idx
+	table.UpdateDate()
+	se.db.UpdateDate()
+	return nil
+}
+
+// DeleteIndex removes an index from a table.
+func (se *SchemaEditor) DeleteIndex(schemaIndex, tableIndex int, name string) bool {
+	_, table, err := se.tableAt(schemaIndex, tableIndex)
+	if err != nil {
+		return false
+	}
+	if _, ok := table.Indexes[name]; !ok {
+		return false
+	}
+	delete(table.Indexes, name)
+	table.UpdateDate()
+	se.db.UpdateDate()
+	return true
+}
+
+// SaveView adds a view to a schema, or replaces the one at position at (use -1 to add).
+func (se *SchemaEditor) SaveView(schemaIndex, at int, v *models.View) error {
+	schema, err := se.schemaAt(schemaIndex)
+	if err != nil {
+		return err
+	}
+	v.Name = strings.TrimSpace(v.Name)
+	if v.Name == "" {
+		return errors.New("view name is required")
+	}
+	if strings.TrimSpace(v.Definition) == "" {
+		return errors.New("view definition is required")
+	}
+	for i, o := range schema.Views {
+		if i != at && o.Name == v.Name {
+			return fmt.Errorf("view %q already exists", v.Name)
+		}
+	}
+	v.Schema = schema.Name
+	if at >= 0 && at < len(schema.Views) {
+		schema.Views[at] = v
+	} else {
+		schema.Views = append(schema.Views, v)
+	}
+	schema.UpdateDate()
+	se.db.UpdateDate()
+	return nil
+}
+
+// DeleteView removes the view at position at.
+func (se *SchemaEditor) DeleteView(schemaIndex, at int) bool {
+	schema, err := se.schemaAt(schemaIndex)
+	if err != nil || at < 0 || at >= len(schema.Views) {
+		return false
+	}
+	schema.Views = append(schema.Views[:at], schema.Views[at+1:]...)
+	schema.UpdateDate()
+	se.db.UpdateDate()
+	return true
+}
+
+// SaveSequence adds a sequence to a schema, or replaces the one at position at (use -1 to add).
+func (se *SchemaEditor) SaveSequence(schemaIndex, at int, s *models.Sequence) error {
+	schema, err := se.schemaAt(schemaIndex)
+	if err != nil {
+		return err
+	}
+	s.Name = strings.TrimSpace(s.Name)
+	if s.Name == "" {
+		return errors.New("sequence name is required")
+	}
+	if s.IncrementBy == 0 {
+		return errors.New("increment must not be zero")
+	}
+	for i, o := range schema.Sequences {
+		if i != at && o.Name == s.Name {
+			return fmt.Errorf("sequence %q already exists", s.Name)
+		}
+	}
+	s.Schema = schema.Name
+	if at >= 0 && at < len(schema.Sequences) {
+		schema.Sequences[at] = s
+	} else {
+		schema.Sequences = append(schema.Sequences, s)
+	}
+	schema.UpdateDate()
+	se.db.UpdateDate()
+	return nil
+}
+
+// DeleteSequence removes the sequence at position at.
+func (se *SchemaEditor) DeleteSequence(schemaIndex, at int) bool {
+	schema, err := se.schemaAt(schemaIndex)
+	if err != nil || at < 0 || at >= len(schema.Sequences) {
+		return false
+	}
+	schema.Sequences = append(schema.Sequences[:at], schema.Sequences[at+1:]...)
+	schema.UpdateDate()
+	se.db.UpdateDate()
+	return true
+}
+
+// SaveScript adds a script to a schema, or replaces the one at position at (use -1 to add).
+func (se *SchemaEditor) SaveScript(schemaIndex, at int, s *models.Script) error {
+	schema, err := se.schemaAt(schemaIndex)
+	if err != nil {
+		return err
+	}
+	s.Name = strings.TrimSpace(s.Name)
+	if s.Name == "" {
+		return errors.New("script name is required")
+	}
+	if strings.TrimSpace(s.SQL) == "" {
+		return errors.New("script SQL is required")
+	}
+	for i, o := range schema.Scripts {
+		if i != at && o.Name == s.Name {
+			return fmt.Errorf("script %q already exists", s.Name)
+		}
+	}
+	s.Schema = schema.Name
+	if at >= 0 && at < len(schema.Scripts) {
+		schema.Scripts[at] = s
+	} else {
+		schema.Scripts = append(schema.Scripts, s)
+	}
+	schema.UpdateDate()
+	se.db.UpdateDate()
+	return nil
+}
+
+// DeleteScript removes the script at position at.
+func (se *SchemaEditor) DeleteScript(schemaIndex, at int) bool {
+	schema, err := se.schemaAt(schemaIndex)
+	if err != nil || at < 0 || at >= len(schema.Scripts) {
+		return false
+	}
+	schema.Scripts = append(schema.Scripts[:at], schema.Scripts[at+1:]...)
+	schema.UpdateDate()
+	se.db.UpdateDate()
+	return true
+}
+
+// AssignTableToDomain adds a reference to schemaName.tableName to the domain at domainIndex.
+func (se *SchemaEditor) AssignTableToDomain(domainIndex int, schemaName, tableName string) error {
+	if domainIndex < 0 || domainIndex >= len(se.db.Domains) {
+		return errors.New("domain not found")
+	}
+	domain := se.db.Domains[domainIndex]
+	var table *models.Table
+	for _, s := range se.db.Schemas {
+		if s.Name != schemaName {
+			continue
+		}
+		for _, t := range s.Tables {
+			if t.Name == tableName {
+				table = t
+			}
+		}
+	}
+	if table == nil {
+		return fmt.Errorf("table %s.%s not found", schemaName, tableName)
+	}
+	for _, dt := range domain.Tables {
+		if dt.SchemaName == schemaName && dt.TableName == tableName {
+			return fmt.Errorf("table %s.%s is already in domain %s", schemaName, tableName, domain.Name)
+		}
+	}
+	dt := models.InitDomainTable(tableName, schemaName)
+	dt.RefTable = table
+	dt.Sequence = uint(len(domain.Tables))
+	domain.Tables = append(domain.Tables, dt)
+	se.db.UpdateDate()
+	return nil
+}
+
+// UnassignTableFromDomain removes the reference to schemaName.tableName from the domain.
+func (se *SchemaEditor) UnassignTableFromDomain(domainIndex int, schemaName, tableName string) bool {
+	if domainIndex < 0 || domainIndex >= len(se.db.Domains) {
+		return false
+	}
+	domain := se.db.Domains[domainIndex]
+	for i, dt := range domain.Tables {
+		if dt.SchemaName == schemaName && dt.TableName == tableName {
+			domain.Tables = append(domain.Tables[:i], domain.Tables[i+1:]...)
+			se.db.UpdateDate()
+			return true
+		}
+	}
+	return false
+}

pkg/ui/object_dataops_test.go

@@ -0,0 +1,136 @@
+package ui
+
+import (
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
+
+func newTestEditor() *SchemaEditor {
+	db := models.InitDatabase("test")
+	schema := models.InitSchema("public")
+	table := models.InitTable("users", "public")
+	table.Columns["id"] = models.InitColumn("id", "users", "public")
+	table.Columns["email"] = models.InitColumn("email", "users", "public")
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+	return &SchemaEditor{db: db}
+}
+
+func TestSaveIndex(t *testing.T) {
+	se := newTestEditor()
+	table := se.db.Schemas[0].Tables[0]
+
+	tests := []struct {
+		name    string
+		old     string
+		idx     *models.Index
+		wantErr bool
+	}{
+		{"valid", "", &models.Index{Name: "idx_email", Columns: []string{"email"}, Unique: true}, false},
+		{"duplicate", "", &models.Index{Name: "idx_email", Columns: []string{"email"}}, true},
+		{"missing name", "", &models.Index{Columns: []string{"email"}}, true},
+		{"no columns", "", &models.Index{Name: "idx_none"}, true},
+		{"unknown column", "", &models.Index{Name: "idx_bad", Columns: []string{"nope"}}, true},
+		{"rename", "idx_email", &models.Index{Name: "idx_email2", Columns: []string{"email", "id"}}, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := se.SaveIndex(0, 0, tt.old, tt.idx); (err != nil) != tt.wantErr {
+				t.Fatalf("err = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+	if _, ok := table.Indexes["idx_email"]; ok {
+		t.Error("renamed index should be gone under old name")
+	}
+	if idx := table.Indexes["idx_email2"]; idx == nil || idx.Table != "users" || idx.Schema != "public" {
+		t.Errorf("unexpected renamed index: %+v", idx)
+	}
+	if !se.DeleteIndex(0, 0, "idx_email2") || se.DeleteIndex(0, 0, "idx_email2") {
+		t.Error("delete should succeed once")
+	}
+}
+
+func TestSaveViewSequenceScript(t *testing.T) {
+	se := newTestEditor()
+	schema := se.db.Schemas[0]
+
+	if err := se.SaveView(0, -1, &models.View{Name: "v", Definition: "select 1"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := se.SaveView(0, -1, &models.View{Name: "v", Definition: "select 2"}); err == nil {
+		t.Error("duplicate view accepted")
+	}
+	if err := se.SaveView(0, 0, &models.View{Name: "v", Definition: "select 3"}); err != nil {
+		t.Errorf("editing in place should not conflict: %v", err)
+	}
+	if err := se.SaveView(0, -1, &models.View{Name: "w"}); err == nil {
+		t.Error("view without definition accepted")
+	}
+	if len(schema.Views) != 1 || schema.Views[0].Definition != "select 3" || schema.Views[0].Schema != "public" {
+		t.Errorf("unexpected views: %+v", schema.Views)
+	}
+	if !se.DeleteView(0, 0) || se.DeleteView(0, 0) {
+		t.Error("view delete mismatch")
+	}
+
+	if err := se.SaveSequence(0, -1, &models.Sequence{Name: "s", IncrementBy: 1, StartValue: 1}); err != nil {
+		t.Fatal(err)
+	}
+	if err := se.SaveSequence(0, -1, &models.Sequence{Name: "z"}); err == nil {
+		t.Error("zero increment accepted")
+	}
+	if !se.DeleteSequence(0, 0) || len(schema.Sequences) != 0 {
+		t.Error("sequence delete failed")
+	}
+
+	if err := se.SaveScript(0, -1, &models.Script{Name: "init", SQL: "select 1"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := se.SaveScript(0, -1, &models.Script{Name: "empty"}); err == nil {
+		t.Error("script without SQL accepted")
+	}
+	if err := se.SaveScript(5, -1, &models.Script{Name: "x", SQL: "y"}); err == nil {
+		t.Error("bad schema index accepted")
+	}
+	if !se.DeleteScript(0, 0) || len(schema.Scripts) != 0 {
+		t.Error("script delete failed")
+	}
+}
+
+func TestDomainTableAssignment(t *testing.T) {
+	se := newTestEditor()
+	se.createDomainNoUI("core")
+
+	if err := se.AssignTableToDomain(0, "public", "users"); err != nil {
+		t.Fatal(err)
+	}
+	if err := se.AssignTableToDomain(0, "public", "users"); err == nil {
+		t.Error("duplicate assignment accepted")
+	}
+	if err := se.AssignTableToDomain(0, "public", "missing"); err == nil {
+		t.Error("unknown table accepted")
+	}
+	if err := se.AssignTableToDomain(3, "public", "users"); err == nil {
+		t.Error("bad domain index accepted")
+	}
+	dt := se.db.Domains[0].Tables[0]
+	if dt.RefTable != se.db.Schemas[0].Tables[0] {
+		t.Error("RefTable not linked")
+	}
+	if !se.UnassignTableFromDomain(0, "public", "users") || se.UnassignTableFromDomain(0, "public", "users") {
+		t.Error("unassign mismatch")
+	}
+}
+
+func (se *SchemaEditor) createDomainNoUI(name string) {
+	se.db.Domains = append(se.db.Domains, models.InitDomain(name))
+}
+
+func TestSplitList(t *testing.T) {
+	got := splitList(" a, b,, c ,")
+	if len(got) != 3 || got[0] != "a" || got[2] != "c" {
+		t.Errorf("got %v", got)
+	}
+}

pkg/ui/object_screens.go

@@ -0,0 +1,476 @@
+package ui
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/gdamore/tcell/v2"
+	"github.com/rivo/tview"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
+
+// objectLocation identifies where a new object is created: a schema, and for indexes also a table.
+type objectLocation struct {
+	label       string
+	schemaIndex int
+	tableIndex  int
+}
+
+// objectRow is one existing object shown in an object list.
+type objectRow struct {
+	cells       []string
+	schemaIndex int
+	tableIndex  int
+	at          int    // position within the schema slice (views, sequences, scripts)
+	name        string // map key (indexes)
+}
+
+// objectKind describes how a kind of schema object is listed and edited.
+type objectKind struct {
+	page      string
+	title     string
+	singular  string
+	headers   []string
+	rows      func() []objectRow
+	locations func() []objectLocation
+	// buildForm adds the editable fields to the form for row (nil when creating) and
+	// returns a function that validates and saves the values at the given location.
+	buildForm func(form *tview.Form, row *objectRow) func(loc objectLocation) error
+	remove    func(row objectRow) bool
+}
+
+func (se *SchemaEditor) schemaLocations() []objectLocation {
+	locs := make([]objectLocation, 0, len(se.db.Schemas))
+	for si, s := range se.db.Schemas {
+		locs = append(locs, objectLocation{label: s.Name, schemaIndex: si, tableIndex: -1})
+	}
+	return locs
+}
+
+func (se *SchemaEditor) tableLocations() []objectLocation {
+	locs := make([]objectLocation, 0)
+	for si, s := range se.db.Schemas {
+		for ti, t := range s.Tables {
+			locs = append(locs, objectLocation{label: s.Name + "." + t.Name, schemaIndex: si, tableIndex: ti})
+		}
+	}
+	return locs
+}
+
+func (se *SchemaEditor) indexKind() objectKind {
+	return objectKind{
+		page:      "indexes",
+		title:     "Manage Indexes",
+		singular:  "Index",
+		headers:   []string{"Name", "Schema", "Table", "Type", "Unique", "Columns"},
+		locations: se.tableLocations,
+		rows: func() []objectRow {
+			var rows []objectRow
+			for si, s := range se.db.Schemas {
+				for ti, t := range s.Tables {
+					for _, name := range sortedKeys(t.Indexes) {
+						idx := t.Indexes[name]
+						rows = append(rows, objectRow{
+							cells:       []string{idx.Name, s.Name, t.Name, idx.Type, strconv.FormatBool(idx.Unique), strings.Join(idx.Columns, ",")},
+							schemaIndex: si, tableIndex: ti, name: name,
+						})
+					}
+				}
+			}
+			return rows
+		},
+		buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
+			idx := models.InitIndex("", "", "")
+			idx.Type = "btree"
+			if row != nil {
+				idx = se.db.Schemas[row.schemaIndex].Tables[row.tableIndex].Indexes[row.name]
+			}
+			name, columns, typ, where := idx.Name, strings.Join(idx.Columns, ", "), idx.Type, idx.Where
+			unique := idx.Unique
+			form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
+			form.AddInputField("Columns (comma separated)", columns, 50, nil, func(v string) { columns = v })
+			form.AddInputField("Type", typ, 20, nil, func(v string) { typ = v })
+			form.AddCheckbox("Unique", unique, func(v bool) { unique = v })
+			form.AddInputField("Where", where, 50, nil, func(v string) { where = v })
+			return func(loc objectLocation) error {
+				oldName := ""
+				if row != nil {
+					oldName = row.name
+				}
+				next := *idx
+				next.Name, next.Columns, next.Type, next.Unique, next.Where = name, splitList(columns), typ, unique, where
+				return se.SaveIndex(loc.schemaIndex, loc.tableIndex, oldName, &next)
+			}
+		},
+		remove: func(r objectRow) bool { return se.DeleteIndex(r.schemaIndex, r.tableIndex, r.name) },
+	}
+}
+
+func (se *SchemaEditor) viewKind() objectKind {
+	return objectKind{
+		page:      "views",
+		title:     "Manage Views",
+		singular:  "View",
+		headers:   []string{"Name", "Schema", "Description"},
+		locations: se.schemaLocations,
+		rows: func() []objectRow {
+			var rows []objectRow
+			for si, s := range se.db.Schemas {
+				for i, v := range s.Views {
+					rows = append(rows, objectRow{cells: []string{v.Name, s.Name, v.Description}, schemaIndex: si, at: i})
+				}
+			}
+			return rows
+		},
+		buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
+			view := models.InitView("", "")
+			at := -1
+			if row != nil {
+				view, at = se.db.Schemas[row.schemaIndex].Views[row.at], row.at
+			}
+			name, desc, def := view.Name, view.Description, view.Definition
+			form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
+			form.AddInputField("Description", desc, 50, nil, func(v string) { desc = v })
+			form.AddTextArea("Definition (SQL)", def, 60, 8, 0, func(v string) { def = v })
+			return func(loc objectLocation) error {
+				next := *view
+				next.Name, next.Description, next.Definition = name, desc, def
+				return se.SaveView(loc.schemaIndex, at, &next)
+			}
+		},
+		remove: func(r objectRow) bool { return se.DeleteView(r.schemaIndex, r.at) },
+	}
+}
+
+func (se *SchemaEditor) sequenceKind() objectKind {
+	return objectKind{
+		page:      "sequences",
+		title:     "Manage Sequences",
+		singular:  "Sequence",
+		headers:   []string{"Name", "Schema", "Start", "Increment", "Cycle", "Description"},
+		locations: se.schemaLocations,
+		rows: func() []objectRow {
+			var rows []objectRow
+			for si, s := range se.db.Schemas {
+				for i, q := range s.Sequences {
+					rows = append(rows, objectRow{
+						cells: []string{q.Name, s.Name, strconv.FormatInt(q.StartValue, 10), strconv.FormatInt(q.IncrementBy, 10), strconv.FormatBool(q.Cycle), q.Description}, schemaIndex: si, at: i,
+					})
+				}
+			}
+			return rows
+		},
+		buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
+			seq := models.InitSequence("", "")
+			at := -1
+			if row != nil {
+				seq, at = se.db.Schemas[row.schemaIndex].Sequences[row.at], row.at
+			}
+			name, desc := seq.Name, seq.Description
+			start, incr := strconv.FormatInt(seq.StartValue, 10), strconv.FormatInt(seq.IncrementBy, 10)
+			minV, maxV := strconv.FormatInt(seq.MinValue, 10), strconv.FormatInt(seq.MaxValue, 10)
+			cycle := seq.Cycle
+			form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
+			form.AddInputField("Description", desc, 50, nil, func(v string) { desc = v })
+			form.AddInputField("Start", start, 20, nil, func(v string) { start = v })
+			form.AddInputField("Increment", incr, 20, nil, func(v string) { incr = v })
+			form.AddInputField("Min (0 = none)", minV, 20, nil, func(v string) { minV = v })
+			form.AddInputField("Max (0 = none)", maxV, 20, nil, func(v string) { maxV = v })
+			form.AddCheckbox("Cycle", cycle, func(v bool) { cycle = v })
+			return func(loc objectLocation) error {
+				next := *seq
+				next.Name, next.Description, next.Cycle = name, desc, cycle
+				for _, f := range []struct {
+					label string
+					text  string
+					dst   *int64
+				}{{"start", start, &next.StartValue}, {"increment", incr, &next.IncrementBy}, {"min", minV, &next.MinValue}, {"max", maxV, &next.MaxValue}} {
+					n, err := strconv.ParseInt(strings.TrimSpace(f.text), 10, 64)
+					if err != nil {
+						return fmt.Errorf("%s must be an integer", f.label)
+					}
+					*f.dst = n
+				}
+				return se.SaveSequence(loc.schemaIndex, at, &next)
+			}
+		},
+		remove: func(r objectRow) bool { return se.DeleteSequence(r.schemaIndex, r.at) },
+	}
+}
+
+func (se *SchemaEditor) scriptKind() objectKind {
+	return objectKind{
+		page:      "scripts",
+		title:     "Manage Scripts",
+		singular:  "Script",
+		headers:   []string{"Name", "Schema", "Version", "Priority", "Description"},
+		locations: se.schemaLocations,
+		rows: func() []objectRow {
+			var rows []objectRow
+			for si, s := range se.db.Schemas {
+				for i, sc := range s.Scripts {
+					rows = append(rows, objectRow{cells: []string{sc.Name, s.Name, sc.Version, strconv.Itoa(sc.Priority), sc.Description}, schemaIndex: si, at: i})
+				}
+			}
+			return rows
+		},
+		buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
+			script := models.InitScript("")
+			at := -1
+			if row != nil {
+				script, at = se.db.Schemas[row.schemaIndex].Scripts[row.at], row.at
+			}
+			name, desc, version, sql, rollback := script.Name, script.Description, script.Version, script.SQL, script.Rollback
+			priority, runAfter := strconv.Itoa(script.Priority), strings.Join(script.RunAfter, ", ")
+			form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
+			form.AddInputField("Description", desc, 50, nil, func(v string) { desc = v })
+			form.AddInputField("Version", version, 20, nil, func(v string) { version = v })
+			form.AddInputField("Priority", priority, 10, nil, func(v string) { priority = v })
+			form.AddInputField("Run after (comma separated)", runAfter, 50, nil, func(v string) { runAfter = v })
+			form.AddTextArea("SQL", sql, 60, 8, 0, func(v string) { sql = v })
+			form.AddTextArea("Rollback SQL", rollback, 60, 4, 0, func(v string) { rollback = v })
+			return func(loc objectLocation) error {
+				prio, err := strconv.Atoi(strings.TrimSpace(priority))
+				if err != nil {
+					return fmt.Errorf("priority must be an integer")
+				}
+				next := *script
+				next.Name, next.Description, next.Version, next.Priority = name, desc, version, prio
+				next.RunAfter, next.SQL, next.Rollback = splitList(runAfter), sql, rollback
+				return se.SaveScript(loc.schemaIndex, at, &next)
+			}
+		},
+		remove: func(r objectRow) bool { return se.DeleteScript(r.schemaIndex, r.at) },
+	}
+}
+
+func sortedKeys[V any](m map[string]V) []string {
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+// showObjectList displays all objects of a kind across schemas.
+func (se *SchemaEditor) showObjectList(k objectKind) {
+	flex := tview.NewFlex().SetDirection(tview.FlexRow)
+	title := tview.NewTextView().SetText("[::b]" + k.title).SetDynamicColors(true).SetTextAlign(tview.AlignCenter)
+
+	table := tview.NewTable().SetBorders(true).SetSelectable(true, false).SetFixed(1, 0)
+	for i, h := range k.headers {
+		table.SetCell(0, i, tview.NewTableCell(h).SetTextColor(tcell.ColorYellow).SetSelectable(false).SetAlign(tview.AlignLeft))
+	}
+	rows := k.rows()
+	for r, row := range rows {
+		for c, text := range row.cells {
+			table.SetCell(r+1, c, tview.NewTableCell(text).SetSelectable(true))
+		}
+	}
+	table.SetTitle(" " + k.title[len("Manage "):] + " ").SetBorder(true).SetTitleAlign(tview.AlignLeft)
+
+	back := func() {
+		se.pages.SwitchToPage("main")
+		se.pages.RemovePage(k.page)
+	}
+	btnNew := tview.NewButton("New " + k.singular + " [n]").SetSelectedFunc(func() { se.showObjectForm(k, nil) })
+	btnBack := tview.NewButton("Back [b]").SetSelectedFunc(back)
+	btnNew.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+		switch event.Key() {
+		case tcell.KeyBacktab:
+			se.app.SetFocus(table)
+			return nil
+		case tcell.KeyTab:
+			se.app.SetFocus(btnBack)
+			return nil
+		}
+		return event
+	})
+	btnBack.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+		switch event.Key() {
+		case tcell.KeyBacktab:
+			se.app.SetFocus(btnNew)
+			return nil
+		case tcell.KeyTab:
+			se.app.SetFocus(table)
+			return nil
+		}
+		return event
+	})
+	btnFlex := tview.NewFlex().AddItem(btnNew, 0, 1, true).AddItem(btnBack, 0, 1, false)
+
+	table.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+		switch {
+		case event.Key() == tcell.KeyEscape, event.Rune() == 'b':
+			back()
+			return nil
+		case event.Key() == tcell.KeyTab:
+			se.app.SetFocus(btnNew)
+			return nil
+		case event.Key() == tcell.KeyEnter:
+			if row, _ := table.GetSelection(); row > 0 && row <= len(rows) {
+				se.showObjectForm(k, &rows[row-1])
+				return nil
+			}
+		case event.Rune() == 'n':
+			se.showObjectForm(k, nil)
+			return nil
+		}
+		return event
+	})
+
+	flex.AddItem(title, 1, 0, false).AddItem(table, 0, 1, true).AddItem(btnFlex, 1, 0, false)
+	se.pages.AddPage(k.page, flex, true, true)
+}
+
+// showObjectForm shows the create (row == nil) or edit form for an object.
+func (se *SchemaEditor) showObjectForm(k objectKind, row *objectRow) {
+	formPage := k.page + "-form"
+	form := tview.NewForm()
+	errView := tview.NewTextView().SetDynamicColors(true)
+
+	locs := k.locations()
+	loc := objectLocation{schemaIndex: -1, tableIndex: -1}
+	switch {
+	case row != nil:
+		loc = objectLocation{schemaIndex: row.schemaIndex, tableIndex: row.tableIndex}
+	case len(locs) > 0:
+		loc = locs[0]
+		labels := make([]string, len(locs))
+		for i, l := range locs {
+			labels[i] = l.label
+		}
+		form.AddDropDown("Location", labels, 0, func(_ string, i int) { loc = locs[i] })
+	}
+
+	save := k.buildForm(form, row)
+
+	closeForm := func() {
+		se.pages.RemovePage(formPage)
+		se.pages.RemovePage(k.page)
+		se.showObjectList(k)
+	}
+	form.AddButton("Save", func() {
+		if err := save(loc); err != nil {
+			errView.SetText("[red]" + tview.Escape(err.Error()))
+			return
+		}
+		closeForm()
+	})
+	if row != nil {
+		form.AddButton("Delete", func() {
+			modal := tview.NewModal().
+				SetText(fmt.Sprintf("Delete %s '%s'? This action cannot be undone.", strings.ToLower(k.singular), row.cells[0])).
+				AddButtons([]string{"Cancel", "Delete"}).
+				SetDoneFunc(func(_ int, label string) {
+					se.pages.RemovePage(formPage + "-delete")
+					if label == "Delete" {
+						k.remove(*row)
+						closeForm()
+					}
+				})
+			se.pages.AddAndSwitchToPage(formPage+"-delete", modal, true)
+		})
+	}
+	form.AddButton("Back", closeForm)
+
+	verb := "New"
+	if row != nil {
+		verb = "Edit"
+	}
+	form.SetBorder(true).SetTitle(" " + verb + " " + k.singular + " ").SetTitleAlign(tview.AlignLeft)
+	form.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+		if event.Key() == tcell.KeyEscape {
+			se.showExitConfirmation(formPage, k.page)
+			return nil
+		}
+		return event
+	})
+
+	if len(locs) == 0 && row == nil {
+		errView.SetText("[red]No schema/table available. Create one first.")
+	}
+	flex := tview.NewFlex().SetDirection(tview.FlexRow).AddItem(form, 0, 1, true).AddItem(errView, 1, 0, false)
+	se.pages.AddPage(formPage, flex, true, true)
+}
+
+// showDomainTables lists the tables assigned to a domain and allows assigning/unassigning.
+func (se *SchemaEditor) showDomainTables(domainIndex int) {
+	if domainIndex < 0 || domainIndex >= len(se.db.Domains) {
+		return
+	}
+	domain := se.db.Domains[domainIndex]
+	page := "domain-tables"
+	list := tview.NewList().ShowSecondaryText(true)
+	refresh := func() {
+		se.pages.RemovePage(page)
+		se.showDomainTables(domainIndex)
+	}
+
+	for _, dt := range domain.Tables {
+		dt := dt
+		list.AddItem(dt.SchemaName+"."+dt.TableName, "Enter to remove from domain", 0, func() {
+			se.UnassignTableFromDomain(domainIndex, dt.SchemaName, dt.TableName)
+			refresh()
+		})
+	}
+	list.AddItem("[Assign Table]", "Add a table to this domain", 'a', func() {
+		se.showAssignDomainTable(domainIndex, refresh)
+	})
+	list.AddItem("[Back]", "Return to domain", 'b', func() {
+		se.pages.RemovePage(page)
+	})
+	list.SetBorder(true).SetTitle(" Domain " + domain.Name + " - Tables ").SetTitleAlign(tview.AlignLeft)
+	list.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+		if event.Key() == tcell.KeyEscape {
+			se.pages.RemovePage(page)
+			return nil
+		}
+		return event
+	})
+	se.pages.AddPage(page, list, true, true)
+}
+
+// showAssignDomainTable shows a form to pick a table not yet in the domain.
+func (se *SchemaEditor) showAssignDomainTable(domainIndex int, done func()) {
+	page := "assign-domain-table"
+	domain := se.db.Domains[domainIndex]
+	var options []string
+	var refs []models.DomainTable
+	for _, s := range se.db.Schemas {
+		for _, t := range s.Tables {
+			taken := false
+			for _, dt := range domain.Tables {
+				taken = taken || (dt.SchemaName == s.Name && dt.TableName == t.Name)
+			}
+			if !taken {
+				options = append(options, s.Name+"."+t.Name)
+				refs = append(refs, models.DomainTable{SchemaName: s.Name, TableName: t.Name})
+			}
+		}
+	}
+	form := tview.NewForm()
+	selected := 0
+	form.AddDropDown("Table", options, 0, func(_ string, i int) { selected = i })
+	form.AddButton("Assign", func() {
+		if len(refs) > 0 {
+			_ = se.AssignTableToDomain(domainIndex, refs[selected].SchemaName, refs[selected].TableName)
+		}
+		se.pages.RemovePage(page)
+		done()
+	})
+	form.AddButton("Back", func() { se.pages.RemovePage(page) })
+	form.SetBorder(true).SetTitle(" Assign Table ").SetTitleAlign(tview.AlignLeft)
+	form.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+		if event.Key() == tcell.KeyEscape {
+			se.pages.RemovePage(page)
+			return nil
+		}
+		return event
+	})
+	se.pages.AddPage(page, form, true, true)
+}

pkg/writers/bun/README.md

@@ -129,6 +129,9 @@ type User struct {
 - `default` - Default value
 - `rel` - Relationship definition
 - `type` - Explicit SQL type
+- `scanonly` - Excluded from INSERT/UPDATE: `GENERATED ... STORED` columns, and `GENERATED ALWAYS AS IDENTITY` columns that are not the primary key
+- `generated` - Marks a `GENERATED ... STORED` column
+- `identity` - Marks a `GENERATED ALWAYS AS IDENTITY` column (a primary key gets only this marker, since Bun drops `scanonly` fields from the PK list)
 
 ## Type Mapping
 

pkg/writers/bun/generated_column_test.go

@@ -0,0 +1,46 @@
+package bun
+
+import (
+	"strings"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
+
+func TestBuildBunTag_GeneratedColumn(t *testing.T) {
+	mapper := NewTypeMapper("", "")
+
+	generated := models.InitColumn("full_name", "users", "public")
+	generated.Type = "text"
+	generated.Generated = true
+	generated.GenerationExpression = "first || ' ' || last"
+
+	plain := models.InitColumn("first", "users", "public")
+	plain.Type = "text"
+
+	tests := []struct {
+		name   string
+		column *models.Column
+		want   bool
+	}{
+		{"generated column is scanonly and marked", generated, true},
+		{"ordinary column is untouched", plain, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tag := mapper.BuildBunTag(tt.column, nil)
+			parts := strings.Split(tag, ",")
+			has := func(s string) bool {
+				for _, p := range parts {
+					if p == s {
+						return true
+					}
+				}
+				return false
+			}
+			if has("scanonly") != tt.want || has("generated") != tt.want {
+				t.Errorf("tag %q: scanonly/generated present = %v/%v, want %v", tag, has("scanonly"), has("generated"), tt.want)
+			}
+		})
+	}
+}

pkg/writers/bun/identity_column_test.go

@@ -0,0 +1,49 @@
+package bun
+
+import (
+	"strings"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
+
+func TestBuildBunTag_IdentityColumn(t *testing.T) {
+	mapper := NewTypeMapper("", "")
+
+	build := func(pk, identity bool, generation string) *models.Column {
+		col := models.InitColumn("id", "users", "public")
+		col.Type = "bigint"
+		col.IsPrimaryKey = pk
+		col.Identity = identity
+		col.IdentityGeneration = generation
+		return col
+	}
+
+	tests := []struct {
+		name       string
+		column     *models.Column
+		wantFlag   bool
+		wantMarker bool
+	}{
+		{"always identity non-pk is write-blocked", build(false, true, "ALWAYS"), true, true},
+		{"always identity pk is only marked", build(true, true, "ALWAYS"), false, true},
+		{"by default identity is writable", build(false, true, "BY DEFAULT"), false, false},
+		{"non-identity is untouched", build(false, false, ""), false, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tag := mapper.BuildBunTag(tt.column, nil)
+			has := func(s string) bool {
+				for _, p := range strings.Split(tag, ",") {
+					if p == s {
+						return true
+					}
+				}
+				return false
+			}
+			if has("scanonly") != tt.wantFlag || has("identity") != tt.wantMarker {
+				t.Errorf("tag %q: scanonly/identity = %v/%v, want %v/%v", tag, has("scanonly"), has("identity"), tt.wantFlag, tt.wantMarker)
+			}
+		})
+	}
+}

pkg/writers/bun/template_data.go

@@ -6,7 +6,6 @@ import (
 	"sort"
 	"strings"
 
-	"git.warky.dev/wdevs/relspecgo/pkg/buildinfo"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
@@ -14,7 +13,6 @@ import (
 // TemplateData represents the data passed to the template for code generation
 type TemplateData struct {
 	PackageName string
-	GeneratedBy string
 	Imports     []string
 	Models      []*ModelData
 	Config      *MethodConfig
@@ -167,7 +165,6 @@ func NewTemplateData(packageName string, config *MethodConfig) *TemplateData {
 
 	return &TemplateData{
 		PackageName: packageName,
-		GeneratedBy: buildinfo.GeneratedComment(),
 		Imports:     make([]string, 0),
 		Models:      make([]*ModelData, 0),
 		Config:      config,

pkg/writers/bun/templates.go

@@ -7,8 +7,7 @@ import (
 
 // modelTemplate defines the template for generating Bun models
 const modelTemplate = `// Code generated by relspecgo. DO NOT EDIT.
-{{if .GeneratedBy}}// {{.GeneratedBy}}
+package {{.PackageName}}
-{{end}}package {{.PackageName}}
 
 {{if .Imports -}}
 import (

pkg/writers/bun/type_mapper.go

@@ -366,6 +366,22 @@ func (tm *TypeMapper) BuildBunTag(column *models.Column, table *models.Table) st
 		parts = append(parts, "autoincrement")
 	}
 
+	// GENERATED ALWAYS ... STORED columns are computed by the database and cannot be
+	// written: scanonly keeps them out of INSERT/UPDATE, generated marks why.
+	if column.Generated {
+		parts = append(parts, "scanonly", "generated")
+	}
+
+	// GENERATED ALWAYS AS IDENTITY rejects explicit values. Bun drops scanonly fields
+	// from the table's PK list, so a primary key only gets the marker; its zero value
+	// is already sent as DEFAULT via autoincrement.
+	if column.Identity && strings.EqualFold(column.IdentityGeneration, "ALWAYS") {
+		if !column.IsPrimaryKey {
+			parts = append(parts, "scanonly")
+		}
+		parts = append(parts, "identity")
+	}
+
 	// Default value
 	if column.Default != nil {
 		// Sanitize default value to remove backticks, then quote based on column type

pkg/writers/bun/writer_test.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 	"testing"
 
-	"git.warky.dev/wdevs/relspecgo/pkg/buildinfo"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
@@ -121,7 +120,7 @@ func TestWriter_WriteTable_MultilineDescriptionProducesValidGo(t *testing.T) {
 	}
 }
 
-func TestWriter_WriteTable_EmbedsRelspecVersionHeader(t *testing.T) {
+func TestWriter_WriteTable_HeaderIsVersionFree(t *testing.T) {
 	table := models.InitTable("users", "public")
 	table.Columns["id"] = &models.Column{Name: "id", Type: "bigint", IsPrimaryKey: true, NotNull: true, Sequence: 1}
 
@@ -141,19 +140,14 @@ func TestWriter_WriteTable_EmbedsRelspecVersionHeader(t *testing.T) {
 		t.Fatalf("generated code is invalid Go: %v\n%s", err, src)
 	}
 
-	wantHeader := "// " + buildinfo.GeneratedComment()
+	// Output must be reproducible: no version or build date in the header.
-	if !strings.Contains(src, wantHeader) {
+	if strings.Contains(src, "(built: ") || strings.Contains(src, "RelSpec ") {
-		t.Errorf("generated code missing RelSpec version header %q\n%s", wantHeader, src)
+		t.Errorf("generated code still carries a version header\n%s", src)
 	}
-	// The provenance comment must sit between the "Code generated" marker and the package clause.
+	// The "Code generated" marker must sit directly above the package clause.
-	genIdx := strings.Index(src, "// Code generated by relspecgo. DO NOT EDIT.")
+	want := "// Code generated by relspecgo. DO NOT EDIT.\npackage models"
-	hdrIdx := strings.Index(src, wantHeader)
+	if !strings.Contains(src, want) {
-	pkgIdx := strings.Index(src, "package models")
+		t.Errorf("header not immediately followed by package clause\n%s", src)
-	if genIdx < 0 || hdrIdx < 0 || pkgIdx < 0 || !(genIdx < hdrIdx && hdrIdx < pkgIdx) {
-		t.Errorf("RelSpec version header is misplaced (gen=%d hdr=%d pkg=%d)\n%s", genIdx, hdrIdx, pkgIdx, src)
-	}
-	if !strings.Contains(wantHeader, "RelSpec ") || !strings.Contains(wantHeader, "(built: ") {
-		t.Errorf("version header not in expected 'RelSpec <version> (built: <date>)' form: %q", wantHeader)
 	}
 }
 

pkg/writers/dbml/README.md

@@ -111,6 +111,8 @@ Table table_name {
 - `unique` - Unique constraint
 - `default: value` - Default value
 - `note: 'text'` - Column note
+- `note: 'GENERATED ALWAYS AS (expr) STORED'` - Generated column (`Generated`, `GenerationExpression`)
+- `note: 'GENERATED ALWAYS|BY DEFAULT AS IDENTITY'` - Identity column (`Identity`, `IdentityGeneration`)
 
 ### Relationships
 ```dbml

pkg/writers/dbml/generated_columns_test.go

@@ -0,0 +1,77 @@
+package dbml
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/readers"
+	dbmlreader "git.warky.dev/wdevs/relspecgo/pkg/readers/dbml"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
+)
+
+func TestGeneratedAndIdentityColumnsRoundTrip(t *testing.T) {
+	table := models.InitTable("people", "public")
+
+	id := models.InitColumn("id", "people", "public")
+	id.Type = "bigint"
+	id.IsPrimaryKey = true
+	id.AutoIncrement = true
+	id.Identity = true
+	id.IdentityGeneration = "ALWAYS"
+	table.Columns["id"] = id
+
+	seq := models.InitColumn("seq", "people", "public")
+	seq.Type = "integer"
+	seq.Identity = true
+	seq.IdentityGeneration = "BY DEFAULT"
+	table.Columns["seq"] = seq
+
+	full := models.InitColumn("full_name", "people", "public")
+	full.Type = "text"
+	full.Generated = true
+	full.GenerationExpression = "first || ' ' || last"
+	table.Columns["full_name"] = full
+
+	plain := models.InitColumn("first", "people", "public")
+	plain.Type = "text"
+	plain.Comment = "given name"
+	table.Columns["first"] = plain
+
+	schema := models.InitSchema("public")
+	schema.Tables = append(schema.Tables, table)
+	db := models.InitDatabase("testdb")
+	db.Schemas = append(db.Schemas, schema)
+
+	out := filepath.Join(t.TempDir(), "people.dbml")
+	require.NoError(t, NewWriter(&writers.WriterOptions{OutputPath: out}).WriteDatabase(db))
+
+	content, err := os.ReadFile(out)
+	require.NoError(t, err)
+	assert.Contains(t, string(content), "GENERATED ALWAYS AS (first || \\' \\' || last) STORED")
+	assert.Contains(t, string(content), "GENERATED ALWAYS AS IDENTITY")
+	assert.Contains(t, string(content), "GENERATED BY DEFAULT AS IDENTITY")
+
+	got, err := dbmlreader.NewReader(&readers.ReaderOptions{FilePath: out}).ReadDatabase()
+	require.NoError(t, err)
+	cols := got.Schemas[0].Tables[0].Columns
+
+	assert.True(t, cols["id"].Identity)
+	assert.Equal(t, "ALWAYS", cols["id"].IdentityGeneration)
+	assert.Empty(t, cols["id"].Comment, "marker note must not become a comment")
+
+	assert.True(t, cols["seq"].Identity)
+	assert.Equal(t, "BY DEFAULT", cols["seq"].IdentityGeneration)
+
+	assert.True(t, cols["full_name"].Generated)
+	assert.Equal(t, "first || ' ' || last", cols["full_name"].GenerationExpression)
+	assert.Empty(t, cols["full_name"].Comment)
+
+	assert.False(t, cols["first"].Generated)
+	assert.False(t, cols["first"].Identity)
+	assert.Equal(t, "given name", cols["first"].Comment)
+}

pkg/writers/dbml/writer.go

@@ -114,6 +114,24 @@ func (w *Writer) schemaToDBML(schema *models.Schema) string {
 	return sb.String()
 }
 
+// columnMarkerNote returns the note marking a column the database computes itself
+// (GENERATED ... STORED, or GENERATED ... AS IDENTITY), or "" for an ordinary column.
+// The DBML reader turns the note back into the model's Generated/Identity fields.
+func columnMarkerNote(column *models.Column) string {
+	switch {
+	case column.Generated:
+		return fmt.Sprintf("GENERATED ALWAYS AS (%s) STORED", column.GenerationExpression)
+	case column.Identity && column.IdentityGeneration != "":
+		return fmt.Sprintf("GENERATED %s AS IDENTITY", strings.ToUpper(column.IdentityGeneration))
+	}
+	return ""
+}
+
+// escapeNote escapes a value for use inside a single-quoted DBML note.
+func escapeNote(s string) string {
+	return strings.ReplaceAll(strings.ReplaceAll(s, `\`, `\\`), `'`, `\'`)
+}
+
 // tableToDBML converts a Table to DBML format string
 func (w *Writer) tableToDBML(t *models.Table) string {
 	var sb strings.Builder
@@ -146,6 +164,10 @@ func (w *Writer) tableToDBML(t *models.Table) string {
 			}
 		}
 
+		if marker := columnMarkerNote(column); marker != "" {
+			attrs = append(attrs, fmt.Sprintf("note: '%s'", escapeNote(marker)))
+		}
+
 		if len(attrs) > 0 {
 			fmt.Fprintf(&sb, " [%s]", strings.Join(attrs, ", "))
 		}

pkg/writers/drizzle/README.md

@@ -113,6 +113,7 @@ export const postsRelations = relations(posts, ({ one }) => ({
 
 ## Notes
 
+- Generated columns: `.generatedAlwaysAs(sql`expr`)`; identity columns: `.generatedAlwaysAsIdentity()` / `.generatedByDefaultAsIdentity()`
 - Table names and column names are preserved as-is
 - Relationships are generated as separate relation definitions
 - Constraint actions (CASCADE, etc.) are included in references

pkg/writers/drizzle/generated_columns_test.go

@@ -0,0 +1,71 @@
+package drizzle
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/readers"
+	drizzlereader "git.warky.dev/wdevs/relspecgo/pkg/readers/drizzle"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
+)
+
+func TestGeneratedAndIdentityColumnsRoundTrip(t *testing.T) {
+	table := models.InitTable("people", "public")
+
+	id := models.InitColumn("id", "people", "public")
+	id.Type = "bigint"
+	id.IsPrimaryKey = true
+	id.AutoIncrement = true
+	id.Identity = true
+	id.IdentityGeneration = "ALWAYS"
+	table.Columns["id"] = id
+
+	seq := models.InitColumn("seq", "people", "public")
+	seq.Type = "integer"
+	seq.AutoIncrement = true
+	seq.Identity = true
+	seq.IdentityGeneration = "BY DEFAULT"
+	table.Columns["seq"] = seq
+
+	first := models.InitColumn("first", "people", "public")
+	first.Type = "text"
+	table.Columns["first"] = first
+
+	full := models.InitColumn("full_name", "people", "public")
+	full.Type = "text"
+	full.Generated = true
+	full.GenerationExpression = "first || ' ' || upper(first)"
+	table.Columns["full_name"] = full
+
+	schema := models.InitSchema("public")
+	schema.Tables = append(schema.Tables, table)
+	db := models.InitDatabase("testdb")
+	db.Schemas = append(db.Schemas, schema)
+
+	out := filepath.Join(t.TempDir(), "schema.ts")
+	require.NoError(t, NewWriter(&writers.WriterOptions{OutputPath: out}).WriteDatabase(db))
+
+	content, err := os.ReadFile(out)
+	require.NoError(t, err)
+	assert.Contains(t, string(content), "generatedAlwaysAs(sql`first || ' ' || upper(first)`)")
+	assert.Contains(t, string(content), "generatedAlwaysAsIdentity()")
+	assert.Contains(t, string(content), "generatedByDefaultAsIdentity()")
+
+	got, err := drizzlereader.NewReader(&readers.ReaderOptions{FilePath: out}).ReadDatabase()
+	require.NoError(t, err)
+	cols := got.Schemas[0].Tables[0].Columns
+
+	assert.True(t, cols["id"].Identity)
+	assert.Equal(t, "ALWAYS", cols["id"].IdentityGeneration)
+	assert.True(t, cols["seq"].Identity)
+	assert.Equal(t, "BY DEFAULT", cols["seq"].IdentityGeneration)
+	assert.True(t, cols["full_name"].Generated)
+	assert.Equal(t, "first || ' ' || upper(first)", cols["full_name"].GenerationExpression)
+	assert.False(t, cols["first"].Generated)
+	assert.False(t, cols["first"].Identity)
+}

pkg/writers/drizzle/template_data.go

@@ -4,16 +4,14 @@ import (
 	"sort"
 	"strings"
 
-	"git.warky.dev/wdevs/relspecgo/pkg/buildinfo"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 )
 
 // TemplateData represents the data passed to the template for code generation
 type TemplateData struct {
-	GeneratedBy string
+	Imports []string
-	Imports     []string
+	Enums   []*EnumData
-	Enums       []*EnumData
+	Tables  []*TableData
-	Tables      []*TableData
 }
 
 // EnumData represents an enum in the schema
@@ -61,10 +59,9 @@ type IndexData struct {
 // NewTemplateData creates a new TemplateData
 func NewTemplateData() *TemplateData {
 	return &TemplateData{
-		GeneratedBy: buildinfo.GeneratedComment(),
+		Imports: make([]string, 0),
-		Imports:     make([]string, 0),
+		Enums:   make([]*EnumData, 0),
-		Enums:       make([]*EnumData, 0),
+		Tables:  make([]*TableData, 0),
-		Tables:      make([]*TableData, 0),
 	}
 }
 

pkg/writers/drizzle/templates.go

@@ -7,8 +7,7 @@ import (
 
 // schemaTemplate defines the template for generating Drizzle schemas
 const schemaTemplate = `// Code generated by relspecgo. DO NOT EDIT.
-{{if .GeneratedBy}}// {{.GeneratedBy}}
+{{range .Imports}}{{.}}
-{{end}}{{range .Imports}}{{.}}
 {{end}}
 {{if .Enums}}
 // Enums

pkg/writers/drizzle/type_mapper.go

@@ -140,7 +140,13 @@ func (tm *TypeMapper) buildColumnModifiers(col *models.Column, table *models.Tab
 	}
 
 	// Default value
-	if col.AutoIncrement {
+	if col.Generated && col.GenerationExpression != "" {
+		// GENERATED ALWAYS AS (expr) STORED
+		expr := strings.ReplaceAll(col.GenerationExpression, "`", "\\`")
+		modifiers = append(modifiers, fmt.Sprintf("generatedAlwaysAs(sql`%s`)", expr))
+	} else if col.Identity && strings.EqualFold(col.IdentityGeneration, "BY DEFAULT") {
+		modifiers = append(modifiers, "generatedByDefaultAsIdentity()")
+	} else if col.AutoIncrement || col.Identity {
 		// For auto-increment, use generatedAlwaysAsIdentity()
 		modifiers = append(modifiers, "generatedAlwaysAsIdentity()")
 	} else if col.Default != nil {

pkg/writers/gorm/README.md

@@ -203,6 +203,14 @@ The writer automatically generates relationship fields:
 - Relationship field names use 3-letter prefixes
 - Includes proper `gorm` tags with `foreignKey` and `references`
 
+## Read-only Columns
+
+| Column | Tags |
+|---|---|
+| `GENERATED ... STORED` | `<-:false;generated` |
+| `GENERATED ALWAYS AS IDENTITY`, not PK | `<-:false;identity` |
+| `GENERATED ALWAYS AS IDENTITY`, PK | `identity` only |
+
 ## Notes
 
 - Model names are prefixed with "Model" (e.g., `ModelUser`)

pkg/writers/gorm/generated_column_test.go

@@ -0,0 +1,45 @@
+package gorm
+
+import (
+	"strings"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
+
+func TestBuildGormTag_GeneratedColumn(t *testing.T) {
+	mapper := NewTypeMapper("")
+
+	generated := models.InitColumn("full_name", "users", "public")
+	generated.Type = "text"
+	generated.Generated = true
+
+	plain := models.InitColumn("first", "users", "public")
+	plain.Type = "text"
+
+	tests := []struct {
+		name   string
+		column *models.Column
+		want   bool
+	}{
+		{"generated column is write-disabled and marked", generated, true},
+		{"ordinary column is untouched", plain, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tag := mapper.BuildGormTag(tt.column, nil)
+			parts := strings.Split(tag, ";")
+			has := func(s string) bool {
+				for _, p := range parts {
+					if p == s {
+						return true
+					}
+				}
+				return false
+			}
+			if has("<-:false") != tt.want || has("generated") != tt.want {
+				t.Errorf("tag %q: <-:false/generated present = %v/%v, want %v", tag, has("<-:false"), has("generated"), tt.want)
+			}
+		})
+	}
+}

pkg/writers/gorm/identity_column_test.go

@@ -0,0 +1,49 @@
+package gorm
+
+import (
+	"strings"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
+
+func TestBuildGormTag_IdentityColumn(t *testing.T) {
+	mapper := NewTypeMapper("")
+
+	build := func(pk, identity bool, generation string) *models.Column {
+		col := models.InitColumn("id", "users", "public")
+		col.Type = "bigint"
+		col.IsPrimaryKey = pk
+		col.Identity = identity
+		col.IdentityGeneration = generation
+		return col
+	}
+
+	tests := []struct {
+		name       string
+		column     *models.Column
+		wantFlag   bool
+		wantMarker bool
+	}{
+		{"always identity non-pk is write-blocked", build(false, true, "ALWAYS"), true, true},
+		{"always identity pk is only marked", build(true, true, "ALWAYS"), false, true},
+		{"by default identity is writable", build(false, true, "BY DEFAULT"), false, false},
+		{"non-identity is untouched", build(false, false, ""), false, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tag := mapper.BuildGormTag(tt.column, nil)
+			has := func(s string) bool {
+				for _, p := range strings.Split(tag, ";") {
+					if p == s {
+						return true
+					}
+				}
+				return false
+			}
+			if has("<-:false") != tt.wantFlag || has("identity") != tt.wantMarker {
+				t.Errorf("tag %q: <-:false/identity = %v/%v, want %v/%v", tag, has("<-:false"), has("identity"), tt.wantFlag, tt.wantMarker)
+			}
+		})
+	}
+}

pkg/writers/gorm/template_data.go

@@ -4,7 +4,6 @@ import (
 	"sort"
 	"strings"
 
-	"git.warky.dev/wdevs/relspecgo/pkg/buildinfo"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
@@ -12,7 +11,6 @@ import (
 // TemplateData represents the data passed to the template for code generation
 type TemplateData struct {
 	PackageName string
-	GeneratedBy string
 	Imports     []string
 	Models      []*ModelData
 	Config      *MethodConfig
@@ -81,7 +79,6 @@ func NewTemplateData(packageName string, config *MethodConfig) *TemplateData {
 
 	return &TemplateData{
 		PackageName: packageName,
-		GeneratedBy: buildinfo.GeneratedComment(),
 		Imports:     make([]string, 0),
 		Models:      make([]*ModelData, 0),
 		Config:      config,

pkg/writers/gorm/templates.go

@@ -7,8 +7,7 @@ import (
 
 // modelTemplate defines the template for generating GORM models
 const modelTemplate = `// Code generated by relspecgo. DO NOT EDIT.
-{{if .GeneratedBy}}// {{.GeneratedBy}}
+package {{.PackageName}}
-{{end}}package {{.PackageName}}
 
 {{if .Imports -}}
 import (

pkg/writers/gorm/type_mapper.go

@@ -401,6 +401,21 @@ func (tm *TypeMapper) BuildGormTag(column *models.Column, table *models.Table) s
 		parts = append(parts, "autoIncrement")
 	}
 
+	// GENERATED ALWAYS ... STORED columns are computed by the database and cannot be
+	// written: disable write permission so GORM leaves them out of INSERT/UPDATE, and mark why.
+	if column.Generated {
+		parts = append(parts, "<-:false", "generated")
+	}
+
+	// GENERATED ALWAYS AS IDENTITY rejects explicit values. A primary key only gets the
+	// marker so it keeps its normal create/return behavior.
+	if column.Identity && strings.EqualFold(column.IdentityGeneration, "ALWAYS") {
+		if !column.IsPrimaryKey {
+			parts = append(parts, "<-:false")
+		}
+		parts = append(parts, "identity")
+	}
+
 	// Not null (skip if primary key, as it's implied)
 	if column.NotNull && !column.IsPrimaryKey {
 		parts = append(parts, "not null")

pkg/writers/mssql/README.md

@@ -127,4 +127,5 @@ go test ./pkg/writers/mssql/...
 - Views are not currently supported in the writer
 - Sequences are not supported (MSSQL uses IDENTITY instead)
 - Partitioning and advanced features are not supported
-- Generated DDL assumes no triggers or computed columns
+- Generated DDL assumes no triggers
+- Generated columns are written as computed columns `[col] AS (expr) PERSISTED` (no type, no DEFAULT); identity columns as `IDENTITY(1,1)`

pkg/writers/mssql/writer.go

@@ -11,7 +11,6 @@ import (
 
 	_ "github.com/microsoft/go-mssqldb" // MSSQL driver
 
-	"git.warky.dev/wdevs/relspecgo/pkg/buildinfo"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/mssql"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
@@ -69,7 +68,7 @@ func (w *Writer) WriteDatabase(db *models.Database) error {
 	// Write header comment
 	fmt.Fprintf(w.writer, "-- MSSQL Database Schema\n")
 	fmt.Fprintf(w.writer, "-- Database: %s\n", db.Name)
-	fmt.Fprintf(w.writer, "-- Generated by %s\n\n", buildinfo.GeneratedComment())
+	fmt.Fprintf(w.writer, "-- Generated by RelSpec\n\n")
 
 	// Process each schema in the database
 	for _, schema := range db.Schemas {
@@ -188,6 +187,16 @@ func (w *Writer) writeCreateTable(schema *models.Schema, table *models.Table) er
 func (w *Writer) generateColumnDefinition(col *models.Column) string {
 	parts := []string{fmt.Sprintf("[%s]", col.Name)}
 
+	// Computed column: "name AS (expr) PERSISTED" has no data type and cannot carry
+	// IDENTITY or a DEFAULT. PERSISTED mirrors the stored semantics of Column.Generated.
+	if col.Generated && col.GenerationExpression != "" {
+		parts = append(parts, fmt.Sprintf("AS (%s) PERSISTED", col.GenerationExpression))
+		if col.NotNull {
+			parts = append(parts, "NOT NULL")
+		}
+		return strings.Join(parts, " ")
+	}
+
 	// Type with length/precision
 	baseType := mssql.ConvertCanonicalToMSSQL(col.Type)
 	typeStr := baseType
@@ -216,7 +225,7 @@ func (w *Writer) generateColumnDefinition(col *models.Column) string {
 	parts = append(parts, typeStr)
 
 	// IDENTITY for auto-increment
-	if col.AutoIncrement {
+	if col.AutoIncrement || col.Identity {
 		parts = append(parts, "IDENTITY(1,1)")
 	}
 
@@ -478,7 +487,7 @@ func (w *Writer) executeDatabaseSQL(db *models.Database, connString string) erro
 	statements := []string{}
 	statements = append(statements, "-- MSSQL Database Schema")
 	statements = append(statements, fmt.Sprintf("-- Database: %s", db.Name))
-	statements = append(statements, "-- Generated by "+buildinfo.GeneratedComment())
+	statements = append(statements, "-- Generated by RelSpec")
 
 	for _, schema := range db.Schemas {
 		if err := w.generateSchemaStatements(schema, &statements); err != nil {

pkg/writers/mssql/writer_test.go

@@ -204,3 +204,19 @@ func TestWriteComments(t *testing.T) {
 	assert.Contains(t, output, "User accounts table")
 	assert.Contains(t, output, "Primary key")
 }
+
+func TestGenerateColumnDefinition_ComputedAndIdentity(t *testing.T) {
+	writer := NewWriter(&writers.WriterOptions{})
+
+	computed := &models.Column{
+		Name:                 "full_name",
+		Type:                 "string",
+		Generated:            true,
+		GenerationExpression: "[first] + ' ' + [last]",
+		Default:              "ignored",
+	}
+	assert.Equal(t, "[full_name] AS ([first] + ' ' + [last]) PERSISTED", writer.generateColumnDefinition(computed))
+
+	identity := &models.Column{Name: "id", Type: "int", NotNull: true, Identity: true, IdentityGeneration: "ALWAYS"}
+	assert.Equal(t, "[id] INT IDENTITY(1,1) NOT NULL", writer.generateColumnDefinition(identity))
+}

pkg/writers/pgsql/README.md

@@ -164,6 +164,12 @@ When `include_audit` is enabled, adds:
 ## PostgreSQL-Specific Features
 
 - Serial types (SERIAL, BIGSERIAL)
+- Generated columns: `GENERATED ALWAYS AS (expr) STORED` (`Column.Generated` + `GenerationExpression`)
+- Identity columns: `GENERATED ALWAYS|BY DEFAULT AS IDENTITY` (`Column.Identity` + `IdentityGeneration`)
+- Generated/identity columns never carry a `DEFAULT`; emitted in `CREATE TABLE` and `ADD COLUMN` (full DDL and migration)
+- Existing generated/identity columns are not diffed (expression changes are not applied)
+- PK sequence = the `nextval()` default's sequence; `setval` moves it past `MAX(pk)`, forward only
+- `serial`/`bigserial` columns without a model default keep their `nextval()` default in diffs
 - Advanced types (UUID, JSONB, ARRAY)
 - Schema-qualified names
 - Constraint actions (CASCADE, RESTRICT, SET NULL)

pkg/writers/pgsql/diff_statements_test.go

@@ -0,0 +1,409 @@
+package pgsql
+
+import (
+	"strings"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
+)
+
+// diffTestDB builds a database with one table per spec: name -> column name -> type.
+func diffTestDB(schemaName string, tables map[string]map[string]string) *models.Database {
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema(schemaName)
+	for tName, cols := range tables {
+		table := models.InitTable(tName, schemaName)
+		seq := 1
+		for cName, cType := range cols {
+			col := models.InitColumn(cName, tName, schemaName)
+			col.Type = cType
+			col.Sequence = uint(seq)
+			seq++
+			table.Columns[cName] = col
+		}
+		schema.Tables = append(schema.Tables, table)
+	}
+	db.Schemas = append(db.Schemas, schema)
+	return db
+}
+
+func diffJoin(stmts []string) string { return strings.Join(stmts, "\n") }
+
+func TestDiffStatements(t *testing.T) {
+	tests := []struct {
+		name        string
+		model       func() *models.Database
+		current     func() *models.Database
+		wantContain []string
+		wantAbsent  []string
+		wantEmpty   bool
+	}{
+		{
+			name: "identical schemas produce no statements",
+			model: func() *models.Database {
+				return diffTestDB("public", map[string]map[string]string{"users": {"id": "integer", "email": "text"}})
+			},
+			current: func() *models.Database {
+				return diffTestDB("public", map[string]map[string]string{"users": {"id": "integer", "email": "text"}})
+			},
+			wantEmpty: true,
+		},
+		{
+			name: "missing table is created",
+			model: func() *models.Database {
+				return diffTestDB("public", map[string]map[string]string{"users": {"id": "integer"}, "posts": {"id": "integer"}})
+			},
+			current: func() *models.Database {
+				return diffTestDB("public", map[string]map[string]string{"users": {"id": "integer"}})
+			},
+			wantContain: []string{"CREATE TABLE IF NOT EXISTS public.posts"},
+			wantAbsent:  []string{"public.users"},
+		},
+		{
+			name: "missing column is added and existing columns are skipped",
+			model: func() *models.Database {
+				return diffTestDB("public", map[string]map[string]string{"users": {"id": "integer", "email": "text"}})
+			},
+			current: func() *models.Database {
+				return diffTestDB("public", map[string]map[string]string{"users": {"id": "integer"}})
+			},
+			wantContain: []string{"ADD COLUMN IF NOT EXISTS email text"},
+			wantAbsent:  []string{"COLUMN id"},
+		},
+		{
+			name: "changed column type is altered",
+			model: func() *models.Database {
+				return diffTestDB("public", map[string]map[string]string{"users": {"id": "bigint"}})
+			},
+			current: func() *models.Database {
+				return diffTestDB("public", map[string]map[string]string{"users": {"id": "integer"}})
+			},
+			wantContain: []string{"ALTER COLUMN id TYPE bigint"},
+		},
+		{
+			name: "missing non-public schema is created before its tables",
+			model: func() *models.Database {
+				return diffTestDB("app", map[string]map[string]string{"users": {"id": "integer"}})
+			},
+			current: func() *models.Database { return models.InitDatabase("testdb") },
+			wantContain: []string{
+				"CREATE SCHEMA IF NOT EXISTS app",
+				"CREATE TABLE IF NOT EXISTS app.users",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			w := NewWriter(&writers.WriterOptions{})
+			stmts, err := w.diffStatements(tt.model(), tt.current())
+			if err != nil {
+				t.Fatalf("diffStatements failed: %v", err)
+			}
+			out := diffJoin(stmts)
+
+			if tt.wantEmpty && len(stmts) != 0 {
+				t.Fatalf("expected no statements, got:\n%s", out)
+			}
+			for _, want := range tt.wantContain {
+				if !strings.Contains(out, want) {
+					t.Errorf("missing %q in:\n%s", want, out)
+				}
+			}
+			for _, absent := range tt.wantAbsent {
+				if strings.Contains(out, absent) {
+					t.Errorf("unexpected %q in:\n%s", absent, out)
+				}
+			}
+		})
+	}
+}
+
+func TestDiffStatements_SchemaCreatedBeforeTables(t *testing.T) {
+	w := NewWriter(&writers.WriterOptions{})
+	model := diffTestDB("app", map[string]map[string]string{"users": {"id": "integer"}})
+	stmts, err := w.diffStatements(model, models.InitDatabase("testdb"))
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+
+	schemaIdx, tableIdx := -1, -1
+	for i, s := range stmts {
+		if strings.Contains(s, "CREATE SCHEMA") {
+			schemaIdx = i
+		}
+		if strings.Contains(s, "CREATE TABLE") {
+			tableIdx = i
+		}
+	}
+	if schemaIdx < 0 || tableIdx < 0 || schemaIdx > tableIdx {
+		t.Fatalf("expected CREATE SCHEMA before CREATE TABLE, got:\n%s", diffJoin(stmts))
+	}
+}
+
+func TestDiffStatements_NewTableCreatesPrimaryKeySequence(t *testing.T) {
+	model := models.InitDatabase("testdb")
+	schema := models.InitSchema("public")
+	table := models.InitTable("users", "public")
+	id := models.InitColumn("id", "users", "public")
+	id.Type = "integer"
+	id.IsPrimaryKey = true
+	id.Default = "nextval('public.users_id_seq'::regclass)"
+	table.Columns["id"] = id
+	schema.Tables = append(schema.Tables, table)
+	model.Schemas = append(model.Schemas, schema)
+
+	w := NewWriter(&writers.WriterOptions{})
+	stmts, err := w.diffStatements(model, models.InitDatabase("testdb"))
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	out := diffJoin(stmts)
+	if !strings.Contains(out, "CREATE SEQUENCE IF NOT EXISTS public.users_id_seq") {
+		t.Fatalf("expected sequence creation, got:\n%s", out)
+	}
+
+	// Existing table: sequence must not be re-emitted.
+	current := models.InitDatabase("testdb")
+	cs := models.InitSchema("public")
+	cs.Tables = append(cs.Tables, table)
+	current.Schemas = append(current.Schemas, cs)
+	stmts, err = w.diffStatements(model, current)
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	if strings.Contains(diffJoin(stmts), "CREATE SEQUENCE") {
+		t.Fatalf("sequence emitted for existing table:\n%s", diffJoin(stmts))
+	}
+}
+
+func TestDiffStatements_NewIndexAndChangedIndexRecreated(t *testing.T) {
+	build := func(cols ...string) *models.Database {
+		db := diffTestDB("public", map[string]map[string]string{"users": {"id": "integer", "email": "text", "name": "text"}})
+		table := db.Schemas[0].Tables[0]
+		table.Indexes["idx_users_lookup"] = &models.Index{Name: "idx_users_lookup", Columns: cols}
+		return db
+	}
+	w := NewWriter(&writers.WriterOptions{})
+
+	// Index missing in current.
+	noIdx := diffTestDB("public", map[string]map[string]string{"users": {"id": "integer", "email": "text", "name": "text"}})
+	stmts, err := w.diffStatements(build("email"), noIdx)
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	if !strings.Contains(diffJoin(stmts), "CREATE INDEX IF NOT EXISTS idx_users_lookup") {
+		t.Fatalf("expected index creation, got:\n%s", diffJoin(stmts))
+	}
+
+	// Index unchanged.
+	stmts, err = w.diffStatements(build("email"), build("email"))
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	if len(stmts) != 0 {
+		t.Fatalf("expected no statements for identical index, got:\n%s", diffJoin(stmts))
+	}
+
+	// Index definition changed: dropped and recreated.
+	stmts, err = w.diffStatements(build("name"), build("email"))
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	out := diffJoin(stmts)
+	dropIdx := strings.Index(out, "DROP INDEX")
+	createIdx := strings.Index(out, "CREATE INDEX")
+	if dropIdx < 0 || createIdx < 0 || dropIdx > createIdx {
+		t.Fatalf("expected DROP INDEX before CREATE INDEX, got:\n%s", out)
+	}
+}
+
+func TestDiffStatements_FlattenSchemaRejected(t *testing.T) {
+	w := NewWriter(&writers.WriterOptions{FlattenSchema: true})
+	if _, err := w.generateLiveDiffStatements(models.InitDatabase("x"), "postgres://unused"); err == nil {
+		t.Fatal("expected error so the caller falls back to full DDL")
+	}
+}
+
+func TestDiffStatements_LiveDatabaseRepresentationsAreNotDifferences(t *testing.T) {
+	build := func(live bool) *models.Database {
+		db := models.InitDatabase("testdb")
+		schema := models.InitSchema("public")
+
+		parent := models.InitTable("parent", "public")
+		parentID := models.InitColumn("id_parent", "parent", "public")
+		parentCurrentType := "bigserial"
+		if live {
+			parentCurrentType = "bigint"
+		}
+		parentID.Type = parentCurrentType
+		parentID.IsPrimaryKey = true
+		parentID.NotNull = true
+		parent.Columns["id_parent"] = parentID
+		if live {
+			// A live database reports the PK as a named constraint and the unique
+			// constraint's backing index as an index too.
+			parent.Constraints["pk_public_parent"] = &models.Constraint{
+				Name: "pk_public_parent", Type: models.PrimaryKeyConstraint, Columns: []string{"id_parent"},
+			}
+		}
+		guid := models.InitColumn("guid", "parent", "public")
+		guid.Type = "uuid"
+		parent.Columns["guid"] = guid
+		parent.Constraints["ukey_parent_guid"] = &models.Constraint{
+			Name: "ukey_parent_guid", Type: models.UniqueConstraint, Columns: []string{"guid"},
+		}
+		if live {
+			parent.Indexes["ukey_parent_guid"] = &models.Index{Name: "ukey_parent_guid", Unique: true, Columns: []string{"guid"}, Type: "btree"}
+		}
+
+		// numeric(10,0) vs numeric(10); quoted default vs unquoted default with cast.
+		amount := models.InitColumn("amount", "parent", "public")
+		amount.Type = "numeric(10,0)"
+		tags := models.InitColumn("tags", "parent", "public")
+		tags.Type = "jsonb"
+		tags.Default = "`'[]'`"
+		if live {
+			amount.Type = "numeric"
+			amount.Precision = 10
+			tags.Default = "[]"
+		}
+		parent.Columns["amount"] = amount
+		parent.Columns["tags"] = tags
+
+		parent.Indexes["idx_parent_amount"] = &models.Index{Name: "idx_parent_amount", Columns: []string{"amount"}}
+		if live {
+			parent.Indexes["idx_parent_amount"].Type = "btree"
+		}
+
+		child := models.InitTable("child", "public")
+		cid := models.InitColumn("id_child", "child", "public")
+		cid.Type = "integer"
+		child.Columns["id_child"] = cid
+		rid := models.InitColumn("rid_parent", "child", "public")
+		rid.Type = "bigint"
+		child.Columns["rid_parent"] = rid
+		action := "restrict"
+		if live {
+			action = "RESTRICT"
+		}
+		child.Constraints["fk_child_rid_parent"] = &models.Constraint{
+			Name: "fk_child_rid_parent", Type: models.ForeignKeyConstraint, Columns: []string{"rid_parent"},
+			ReferencedTable: "parent", ReferencedSchema: "public", ReferencedColumns: []string{"id_parent"},
+			OnDelete: action, OnUpdate: action,
+		}
+
+		parent.Description = "Parent\ntable"
+		if live {
+			parent.Description = "Parent\ntable\n"
+		}
+
+		schema.Tables = append(schema.Tables, parent, child)
+		db.Schemas = append(db.Schemas, schema)
+		return db
+	}
+
+	w := NewWriter(&writers.WriterOptions{})
+	stmts, err := w.diffStatements(build(false), build(true))
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	if len(stmts) != 0 {
+		t.Fatalf("expected live representations to match the model, got:\n%s", diffJoin(stmts))
+	}
+}
+
+func TestDiffStatements_ChangedPrimaryKeyIsRecreated(t *testing.T) {
+	model := diffTestDB("public", map[string]map[string]string{"users": {"id": "integer", "tenant": "integer"}})
+	model.Schemas[0].Tables[0].Columns["tenant"].IsPrimaryKey = true
+
+	current := diffTestDB("public", map[string]map[string]string{"users": {"id": "integer", "tenant": "integer"}})
+	current.Schemas[0].Tables[0].Columns["id"].IsPrimaryKey = true
+	current.Schemas[0].Tables[0].Constraints["pk_public_users"] = &models.Constraint{
+		Name: "pk_public_users", Type: models.PrimaryKeyConstraint, Columns: []string{"id"},
+	}
+
+	w := NewWriter(&writers.WriterOptions{})
+	stmts, err := w.diffStatements(model, current)
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	if !strings.Contains(diffJoin(stmts), "DROP CONSTRAINT IF EXISTS pk_public_users") {
+		t.Fatalf("expected old primary key to be dropped, got:\n%s", diffJoin(stmts))
+	}
+}
+
+func TestDiffStatements_ChangedCommentEmitted(t *testing.T) {
+	model := diffTestDB("public", map[string]map[string]string{"users": {"id": "integer"}})
+	model.Schemas[0].Tables[0].Description = "new"
+	current := diffTestDB("public", map[string]map[string]string{"users": {"id": "integer"}})
+	current.Schemas[0].Tables[0].Description = "old"
+
+	w := NewWriter(&writers.WriterOptions{})
+	stmts, err := w.diffStatements(model, current)
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	if !strings.Contains(diffJoin(stmts), "COMMENT ON TABLE public.users IS 'new'") {
+		t.Fatalf("expected changed comment, got:\n%s", diffJoin(stmts))
+	}
+}
+
+func TestDiffStatements_TruncatedConstraintNameMatches(t *testing.T) {
+	long := "fk_individual_actor_relationship_rid_typelookup_relationship_type"
+	if len(long) <= maxIdentifierBytes {
+		t.Fatal("test name must exceed the identifier limit")
+	}
+	build := func(name string) *models.Database {
+		db := diffTestDB("public", map[string]map[string]string{
+			"parent": {"id": "integer"},
+			"child":  {"rid": "integer"},
+		})
+		for _, tbl := range db.Schemas[0].Tables {
+			if tbl.Name == "child" {
+				tbl.Constraints[name] = &models.Constraint{
+					Name: name, Type: models.ForeignKeyConstraint, Columns: []string{"rid"},
+					ReferencedTable: "parent", ReferencedSchema: "public", ReferencedColumns: []string{"id"},
+				}
+			}
+		}
+		return db
+	}
+
+	w := NewWriter(&writers.WriterOptions{})
+	stmts, err := w.diffStatements(build(long), build(pgIdentifier(long)))
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	if len(stmts) != 0 {
+		t.Fatalf("expected truncated live name to match, got:\n%s", diffJoin(stmts))
+	}
+}
+
+func TestColumnDefaultsEqual_LiveRepresentations(t *testing.T) {
+	tests := []struct {
+		name       string
+		model, cur interface{}
+		want       bool
+	}{
+		{"cast wrapped in parentheses", "gen_random_uuid()::text", "(gen_random_uuid())::text", true},
+		{"jsonb re-spaced array", `'["openid","profile","email"]'`, `'["openid", "profile", "email"]'::jsonb`, true},
+		{"backticked function", "`now()`", "now()", true},
+		{"quoted literal with cast", "'[]'", "'[]'::jsonb", true},
+		{"jsonb array already unquoted by the reader", `'["openid","profile"]'`, `["openid", "profile"]`, true},
+		{"text with spaces and braces", "`'{actor} #{actor_id} - {chartofaccount}'`", "{actor} #{actor_id} - {chartofaccount}", true},
+		{"cast on plain function stays equal", "gen_random_uuid()::text", "gen_random_uuid()::text", true},
+		{"different jsonb content", `'["a"]'`, `'["b"]'::jsonb`, false},
+		{"different function", "gen_random_uuid()::text", "(now())::text", false},
+		{"different literal", "'active'", "'inactive'::text", false},
+		{"nil vs value", nil, "now()", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := columnDefaultsEqual(tt.model, tt.cur); got != tt.want {
+				t.Errorf("columnDefaultsEqual(%v, %v) = %v, want %v", tt.model, tt.cur, got, tt.want)
+			}
+		})
+	}
+}

pkg/writers/pgsql/generated_column_test.go

@@ -0,0 +1,101 @@
+package pgsql
+
+import (
+	"strings"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
+)
+
+func generationTestTable(withColumns bool) *models.Table {
+	table := models.InitTable("people", "public")
+
+	first := models.InitColumn("first", "people", "public")
+	first.Type = "text"
+	first.Sequence = 1
+	table.Columns["first"] = first
+
+	if !withColumns {
+		return table
+	}
+
+	full := models.InitColumn("full_name", "people", "public")
+	full.Type = "text"
+	full.Sequence = 2
+	full.Generated = true
+	full.GenerationExpression = "first || ' ' || last"
+	full.Default = "ignored"
+	table.Columns["full_name"] = full
+
+	ident := models.InitColumn("seq", "people", "public")
+	ident.Type = "bigint"
+	ident.Sequence = 3
+	ident.NotNull = true
+	ident.Identity = true
+	ident.IdentityGeneration = "ALWAYS"
+	table.Columns["seq"] = ident
+
+	return table
+}
+
+func generationTestDB(table *models.Table) *models.Database {
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("public")
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+	return db
+}
+
+func TestGeneratedColumns_MigrationCreateAndAddColumn(t *testing.T) {
+	want := []string{
+		"GENERATED ALWAYS AS (first || ' ' || last) STORED",
+		"GENERATED ALWAYS AS IDENTITY",
+	}
+
+	tests := []struct {
+		name    string
+		current *models.Database
+	}{
+		{"new table", models.InitDatabase("testdb")},
+		{"new columns on existing table", generationTestDB(generationTestTable(false))},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			w := NewWriter(&writers.WriterOptions{})
+			stmts, err := w.diffStatements(generationTestDB(generationTestTable(true)), tt.current)
+			if err != nil {
+				t.Fatalf("diffStatements failed: %v", err)
+			}
+			out := diffJoin(stmts)
+			for _, s := range want {
+				if !strings.Contains(out, s) {
+					t.Errorf("missing %q:\n%s", s, out)
+				}
+			}
+			if strings.Contains(out, "DEFAULT ignored") || strings.Contains(out, "DEFAULT 'ignored'") {
+				t.Errorf("generated column must not carry a DEFAULT:\n%s", out)
+			}
+		})
+	}
+}
+
+func TestGeneratedColumns_FullDDL(t *testing.T) {
+	w := NewWriter(&writers.WriterOptions{})
+	stmts, err := w.GenerateDatabaseStatements(generationTestDB(generationTestTable(true)))
+	if err != nil {
+		t.Fatalf("GenerateDatabaseStatements failed: %v", err)
+	}
+	out := diffJoin(stmts)
+	for _, s := range []string{
+		"full_name text GENERATED ALWAYS AS (first || ' ' || last) STORED",
+		"seq bigint GENERATED ALWAYS AS IDENTITY NOT NULL",
+	} {
+		if !strings.Contains(out, s) {
+			t.Errorf("missing %q:\n%s", s, out)
+		}
+	}
+	if strings.Contains(out, "DEFAULT 'ignored'") {
+		t.Errorf("generated column must not carry a DEFAULT:\n%s", out)
+	}
+}

pkg/writers/pgsql/migration_writer.go

@@ -1,13 +1,14 @@
 package pgsql
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
 	"sort"
 	"strings"
 
-	"git.warky.dev/wdevs/relspecgo/pkg/buildinfo"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/pgsql"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
@@ -47,10 +48,11 @@ func NewMigrationWriter(options *writers.WriterOptions) (*MigrationWriter, error
 	}, nil
 }
 
-// WriteMigration generates migration scripts using templates
+// GenerateScripts computes the differential migration scripts between current and model,
-func (w *MigrationWriter) WriteMigration(model, current *models.Database) error {
+// sorted by priority and sequence.
+func (w *MigrationWriter) GenerateScripts(model, current *models.Database) ([]MigrationScript, error) {
 	if model == nil {
-		return fmt.Errorf("model database is required")
+		return nil, fmt.Errorf("model database is required")
 	}
 	if w.options == nil {
 		w.options = &writers.WriterOptions{}
@@ -59,26 +61,6 @@ func (w *MigrationWriter) WriteMigration(model, current *models.Database) error
 		current = models.InitDatabase(model.Name)
 	}
 
-	var writer io.Writer
-	var file *os.File
-	var err error
-
-	// Use existing writer if already set (for testing)
-	if w.writer != nil {
-		writer = w.writer
-	} else if w.options.OutputPath != "" {
-		file, err = os.Create(w.options.OutputPath)
-		if err != nil {
-			return fmt.Errorf("failed to create output file: %w", err)
-		}
-		defer file.Close()
-		writer = file
-	} else {
-		writer = os.Stdout
-	}
-
-	w.writer = writer
-
 	// Check if audit is configured in metadata
 	var auditConfig *AuditConfig
 	if w.options.Metadata != nil {
@@ -94,7 +76,7 @@ func (w *MigrationWriter) WriteMigration(model, current *models.Database) error
 	if auditConfig != nil && len(auditConfig.EnabledTables) > 0 {
 		auditTableScript, err := w.generateAuditTablesScript(auditConfig)
 		if err != nil {
-			return fmt.Errorf("failed to generate audit tables: %w", err)
+			return nil, fmt.Errorf("failed to generate audit tables: %w", err)
 		}
 		scripts = append(scripts, auditTableScript...)
 	}
@@ -120,7 +102,7 @@ func (w *MigrationWriter) WriteMigration(model, current *models.Database) error
 		// Generate schema-level scripts
 		schemaScripts, err := w.generateSchemaScripts(modelSchema, currentSchema)
 		if err != nil {
-			return fmt.Errorf("failed to generate schema scripts: %w", err)
+			return nil, fmt.Errorf("failed to generate schema scripts: %w", err)
 		}
 		scripts = append(scripts, schemaScripts...)
 
@@ -128,7 +110,7 @@ func (w *MigrationWriter) WriteMigration(model, current *models.Database) error
 		if auditConfig != nil {
 			auditScripts, err := w.generateAuditScripts(modelSchema, auditConfig)
 			if err != nil {
-				return fmt.Errorf("failed to generate audit scripts: %w", err)
+				return nil, fmt.Errorf("failed to generate audit scripts: %w", err)
 			}
 			scripts = append(scripts, auditScripts...)
 		}
@@ -142,9 +124,48 @@ func (w *MigrationWriter) WriteMigration(model, current *models.Database) error
 		return scripts[i].Sequence < scripts[j].Sequence
 	})
 
+	return scripts, nil
+}
+
+// WriteMigration generates migration scripts using templates
+func (w *MigrationWriter) WriteMigration(model, current *models.Database) error {
+	if model == nil {
+		return fmt.Errorf("model database is required")
+	}
+	if w.options == nil {
+		w.options = &writers.WriterOptions{}
+	}
+	if current == nil {
+		current = models.InitDatabase(model.Name)
+	}
+
+	scripts, err := w.GenerateScripts(model, current)
+	if err != nil {
+		return err
+	}
+
+	var writer io.Writer
+	var file *os.File
+
+	// Use existing writer if already set (for testing)
+	if w.writer != nil {
+		writer = w.writer
+	} else if w.options.OutputPath != "" {
+		file, err = os.Create(w.options.OutputPath)
+		if err != nil {
+			return fmt.Errorf("failed to create output file: %w", err)
+		}
+		defer file.Close()
+		writer = file
+	} else {
+		writer = os.Stdout
+	}
+
+	w.writer = writer
+
 	// Write header
 	fmt.Fprintf(w.writer, "-- PostgreSQL Migration Script\n")
-	fmt.Fprintf(w.writer, "-- Generated by %s\n", buildinfo.GeneratedComment())
+	fmt.Fprintf(w.writer, "-- Generated by RelSpec\n")
 	fmt.Fprintf(w.writer, "-- Source: %s -> %s\n", current.Name, model.Name)
 	if w.options.ContinueOnError {
 		fmt.Fprintf(w.writer, "\\set ON_ERROR_STOP off\n")
@@ -242,10 +263,14 @@ func (w *MigrationWriter) generateDropScripts(model, current *models.Schema) ([]
 		// Check each constraint in current database
 		for _, currentConstraint := range sortConstraints(currentTable.Constraints) {
 			constraintName := currentConstraint.Name
-			modelConstraint, existsInModel := modelTable.Constraints[constraintName]
+			modelConstraint, existsInModel := lookupConstraint(modelTable.Constraints, constraintName)
 
 			shouldDrop := false
-			if !existsInModel {
+			if currentConstraint.Type == models.PrimaryKeyConstraint {
+				// Model primary keys usually live on the columns (not as a named constraint), so
+				// compare by key columns instead of constraint name.
+				shouldDrop = !primaryKeyColumnsMatch(modelTable, currentConstraint)
+			} else if !existsInModel {
 				shouldDrop = true
 			} else if !constraintsEqual(modelConstraint, currentConstraint) {
 				shouldDrop = true
@@ -317,6 +342,12 @@ func (w *MigrationWriter) generateDropScripts(model, current *models.Schema) ([]
 			indexName := currentIndex.Name
 			modelIndex, existsInModel := modelTable.Indexes[indexName]
 
+			// A live database reports the index backing a unique/primary constraint as an
+			// index too; it belongs to the constraint and is handled there.
+			if _, backsConstraint := currentTable.Constraints[indexName]; backsConstraint {
+				continue
+			}
+
 			shouldDrop := false
 			if !existsInModel {
 				shouldDrop = true
@@ -411,6 +442,7 @@ func (w *MigrationWriter) generateAlterTableScripts(schema *models.Schema, model
 		if !exists {
 			// Column doesn't exist, add it
 			_, defaultVal := formatColumnDefaultSQL(modelCol)
+			generated, identity := columnGenerationClauses(modelCol)
 
 			sql, err := w.executor.ExecuteAddColumn(AddColumnData{
 				SchemaName: schema.Name,
@@ -419,6 +451,8 @@ func (w *MigrationWriter) generateAlterTableScripts(schema *models.Schema, model
 				ColumnType: effectiveColumnSQLType(modelCol),
 				Default:    defaultVal,
 				NotNull:    modelCol.NotNull,
+				Generated:  generated,
+				Identity:   identity,
 			})
 			if err != nil {
 				return nil, err
@@ -471,7 +505,7 @@ func (w *MigrationWriter) generateAlterTableScripts(schema *models.Schema, model
 			}
 
 			// Check default value changes
-			if !columnDefaultsEqual(modelCol.Default, currentCol.Default) {
+			if !isSerialWithoutDefault(modelCol) && !columnDefaultsEqual(modelCol.Default, currentCol.Default) {
 				setDefault, defaultVal := formatColumnDefaultSQL(modelCol)
 
 				sql, err := w.executor.ExecuteAlterColumnDefaultWithCheck(AlterColumnDefaultWithCheckData{
@@ -748,7 +782,7 @@ func (w *MigrationWriter) generateForeignKeyScripts(model, current *models.Schem
 			if !shouldCreate {
 				if currentTable == nil {
 					shouldCreate = true
-				} else if currentConstraint, exists := currentTable.Constraints[constraintName]; !exists {
+				} else if currentConstraint, exists := lookupConstraint(currentTable.Constraints, constraintName); !exists {
 					shouldCreate = true
 				} else if !constraintsEqual(constraint, currentConstraint) {
 					shouldCreate = true
@@ -800,12 +834,20 @@ func (w *MigrationWriter) generateForeignKeyScripts(model, current *models.Schem
 // generateCommentScripts generates COMMENT ON scripts using templates
 func (w *MigrationWriter) generateCommentScripts(model, current *models.Schema) ([]MigrationScript, error) {
 	scripts := make([]MigrationScript, 0)
-	_ = current // TODO: Compare with current schema to only add new/changed comments
+
+	currentTables := make(map[string]*models.Table)
+	if current != nil {
+		for _, table := range current.Tables {
+			currentTables[strings.ToLower(table.Name)] = table
+		}
+	}
 
 	// Process each model table
 	for _, modelTable := range model.Tables {
-		// Table comment
+		currentTable := currentTables[strings.ToLower(modelTable.Name)]
-		if modelTable.Description != "" {
+
+		// Table comment (skipped when the live table already carries the same comment)
+		if modelTable.Description != "" && (currentTable == nil || strings.TrimSpace(currentTable.Description) != strings.TrimSpace(modelTable.Description)) {
 			sql, err := w.executor.ExecuteCommentTable(CommentTableData{
 				SchemaName: model.Name,
 				TableName:  modelTable.Name,
@@ -828,7 +870,7 @@ func (w *MigrationWriter) generateCommentScripts(model, current *models.Schema)
 
 		// Column comments
 		for _, col := range sortColumns(modelTable.Columns) {
-			if col.Description != "" {
+			if col.Description != "" && !currentColumnHasDescription(currentTable, col) {
 				sql, err := w.executor.ExecuteCommentColumn(CommentColumnData{
 					SchemaName: model.Name,
 					TableName:  modelTable.Name,
@@ -995,18 +1037,80 @@ func normalizeDefaultForCompare(value interface{}) string {
 		return ""
 	}
 	if s, ok := value.(string); ok {
-		return strings.TrimSpace(stripBackticks(s))
+		return normalizeDefaultLiteral(strings.TrimSpace(stripBackticks(s)))
 	}
 	return fmt.Sprintf("%v", value)
 }
 
+// normalizeDefaultLiteral removes a trailing ::type cast and the quotes around a plain string
+// literal, so a DBML default ('[]') and the one a live database reports ('[]'::jsonb) compare equal.
+func normalizeDefaultLiteral(s string) string {
+	if strings.HasPrefix(s, "'") {
+		if end := strings.LastIndex(s, "'"); end > 0 {
+			rest := strings.TrimSpace(s[end+1:])
+			if rest == "" || strings.HasPrefix(rest, "::") {
+				return normalizeJSONLiteral(strings.ReplaceAll(s[1:end], "''", "'"))
+			}
+		}
+		return s
+	}
+	if strings.HasPrefix(s, "(") && strings.Contains(s, ")::") {
+		return normalizeCastExpression(s)
+	}
+	return normalizeJSONLiteral(s)
+}
+
+// normalizeJSONLiteral compacts JSON text, since jsonb reports defaults re-spaced
+// ('["a", "b"]') while the model usually holds them minified.
+func normalizeJSONLiteral(s string) string {
+	if !strings.HasPrefix(s, "[") && !strings.HasPrefix(s, "{") {
+		return s
+	}
+	var buf bytes.Buffer
+	if err := json.Compact(&buf, []byte(s)); err != nil {
+		return s
+	}
+	return buf.String()
+}
+
+// normalizeCastExpression strips whitespace and the redundant parentheses PostgreSQL adds
+// around an expression it casts: (gen_random_uuid())::text -> gen_random_uuid()::text.
+func normalizeCastExpression(s string) string {
+	s = strings.Join(strings.Fields(s), "")
+	for strings.HasPrefix(s, "(") {
+		end := strings.LastIndex(s, ")::")
+		if end < 0 {
+			break
+		}
+		inner := s[1:end]
+		depth := 0
+		balanced := true
+		for _, r := range inner {
+			if r == '(' {
+				depth++
+			} else if r == ')' {
+				depth--
+				if depth < 0 {
+					balanced = false
+					break
+				}
+			}
+		}
+		if !balanced || depth != 0 {
+			break
+		}
+		s = inner + s[end+1:]
+	}
+	return s
+}
+
 func columnTypesEqual(col1, col2 *models.Column) bool {
 	if col1 == nil || col2 == nil {
 		return false
 	}
 	return strings.EqualFold(
-		pgsql.NormalizeEquivalentSQLType(effectiveColumnSQLType(col1)),
+		normalizeZeroScale(pgsql.NormalizeEquivalentSQLType(effectiveAlterColumnSQLType(col1))),
-		pgsql.NormalizeEquivalentSQLType(effectiveColumnSQLType(col2)),
+		normalizeZeroScale(pgsql.NormalizeEquivalentSQLType(effectiveAlterColumnSQLType(col2))),
 	)
 }
 
@@ -1042,7 +1146,7 @@ func constraintsEqual(c1, c2 *models.Constraint) bool {
 				return false
 			}
 		}
-		if c1.OnDelete != c2.OnDelete || c1.OnUpdate != c2.OnUpdate {
+		if !fkActionsEqual(c1.OnDelete, c2.OnDelete) || !fkActionsEqual(c1.OnUpdate, c2.OnUpdate) {
 			return false
 		}
 	}
@@ -1058,7 +1162,7 @@ func indexesEqual(idx1, idx2 *models.Index) bool {
 	if idx1.Unique != idx2.Unique {
 		return false
 	}
-	if !strings.EqualFold(idx1.Type, idx2.Type) {
+	if !strings.EqualFold(normalizeIndexMethod(idx1.Type), normalizeIndexMethod(idx2.Type)) {
 		return false
 	}
 	if len(idx1.Columns) != len(idx2.Columns) {
@@ -1078,6 +1182,104 @@ func indexesEqual(idx1, idx2 *models.Index) bool {
 	return indexHintsEqual(indexStorageParameters(idx1.Comment), indexStorageParameters(idx2.Comment))
 }
 
+// normalizeZeroScale turns numeric(p,0) into numeric(p); PostgreSQL treats them as the same type.
+func normalizeZeroScale(sqlType string) string {
+	if i := strings.Index(sqlType, "("); i >= 0 && strings.HasSuffix(sqlType, ",0)") && !strings.Contains(sqlType[i:], "[") {
+		return strings.TrimSuffix(sqlType, ",0)") + ")"
+	}
+	return sqlType
+}
+
+// maxIdentifierBytes is PostgreSQL's identifier length limit; longer names are truncated on creation.
+const maxIdentifierBytes = 63
+
+// pgIdentifier returns name as PostgreSQL stores it (truncated to 63 bytes).
+func pgIdentifier(name string) string {
+	if len(name) > maxIdentifierBytes {
+		return name[:maxIdentifierBytes]
+	}
+	return name
+}
+
+// lookupConstraint finds a constraint by name, also matching names that differ only because
+// PostgreSQL truncated an over-long identifier.
+func lookupConstraint(constraints map[string]*models.Constraint, name string) (*models.Constraint, bool) {
+	if c, ok := constraints[name]; ok {
+		return c, true
+	}
+	want := pgIdentifier(name)
+	for n, c := range constraints {
+		if pgIdentifier(n) == want {
+			return c, true
+		}
+	}
+	return nil, false
+}
+
+// currentColumnHasDescription reports whether the live table's column already carries
+// the model column's comment.
+func currentColumnHasDescription(currentTable *models.Table, col *models.Column) bool {
+	if currentTable == nil {
+		return false
+	}
+	for _, cc := range currentTable.Columns {
+		if strings.EqualFold(cc.Name, col.Name) {
+			return strings.TrimSpace(cc.Description) == strings.TrimSpace(col.Description)
+		}
+	}
+	return false
+}
+
+// primaryKeyColumnsMatch reports whether the model table's primary key (an explicit PK
+// constraint or columns flagged IsPrimaryKey) has the same columns, in order, as current.
+func primaryKeyColumnsMatch(modelTable *models.Table, current *models.Constraint) bool {
+	var modelCols []string
+	for _, c := range sortConstraints(modelTable.Constraints) {
+		if c.Type == models.PrimaryKeyConstraint {
+			modelCols = c.Columns
+			break
+		}
+	}
+	if modelCols == nil {
+		for _, col := range getSortedColumns(modelTable.Columns) {
+			if col.IsPrimaryKey {
+				modelCols = append(modelCols, col.Name)
+			}
+		}
+	}
+	if len(modelCols) != len(current.Columns) {
+		return false
+	}
+	for i, col := range modelCols {
+		if !strings.EqualFold(col, current.Columns[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// normalizeIndexMethod maps an unspecified index method to PostgreSQL's default (btree),
+// which is what a live database reports for it.
+func normalizeIndexMethod(method string) string {
+	if strings.TrimSpace(method) == "" {
+		return "btree"
+	}
+	return method
+}
+
+// fkActionsEqual compares referential actions case-insensitively, treating an unspecified
+// action as PostgreSQL's default (NO ACTION).
+func fkActionsEqual(a, b string) bool {
+	norm := func(s string) string {
+		s = strings.ToUpper(strings.TrimSpace(s))
+		if s == "" {
+			return "NO ACTION"
+		}
+		return s
+	}
+	return norm(a) == norm(b)
+}
+
 // indexHintsEqual compares two optional index hints, treating an unspecified hint as a match.
 func indexHintsEqual(hint1, hint2 string) bool {
 	if hint1 == "" || hint2 == "" {

pkg/writers/pgsql/serial_sequence_test.go

@@ -0,0 +1,163 @@
+package pgsql
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
+)
+
+func serialTestTable(colType string, def interface{}) *models.Table {
+	table := models.InitTable("login_event", "identity")
+	id := models.InitColumn("id_login_event", "login_event", "identity")
+	id.Type = colType
+	id.IsPrimaryKey = true
+	id.Default = def
+	table.Columns["id_login_event"] = id
+	return table
+}
+
+func serialTestDB(table *models.Table) *models.Database {
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("identity")
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+	return db
+}
+
+func TestSequences_FollowPrimaryKeyDefault(t *testing.T) {
+	tests := []struct {
+		name        string
+		table       *models.Table
+		wantContain []string
+		wantAbsent  []string
+	}{
+		{
+			name:  "nextval default uses its own sequence",
+			table: serialTestTable("bigint", "nextval('identity.login_event_id_login_event_seq'::regclass)"),
+			wantContain: []string{
+				"login_event_id_login_event_seq",
+				"setval(",
+			},
+			wantAbsent: []string{"identity_login_event_id_login_event"},
+		},
+		{
+			name:       "no default creates no sequence",
+			table:      serialTestTable("bigint", nil),
+			wantAbsent: []string{"CREATE SEQUENCE", "setval("},
+		},
+		{
+			name:       "bigserial without default creates no extra sequence",
+			table:      serialTestTable("bigserial", nil),
+			wantAbsent: []string{"CREATE SEQUENCE", "setval(", "identity_login_event_id_login_event"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			w := NewWriter(&writers.WriterOptions{})
+			w.writer = &buf
+			if err := w.WriteDatabase(serialTestDB(tt.table)); err != nil {
+				t.Fatalf("WriteDatabase failed: %v", err)
+			}
+			full := buf.String()
+
+			stmts, err := w.GenerateDatabaseStatements(serialTestDB(tt.table))
+			if err != nil {
+				t.Fatalf("GenerateDatabaseStatements failed: %v", err)
+			}
+			for label, out := range map[string]string{"WriteDatabase": full, "GenerateDatabaseStatements": diffJoin(stmts)} {
+				for _, s := range tt.wantContain {
+					if !strings.Contains(out, s) {
+						t.Errorf("%s: missing %q\n%s", label, s, out)
+					}
+				}
+				for _, s := range tt.wantAbsent {
+					if strings.Contains(out, s) {
+						t.Errorf("%s: unexpected %q\n%s", label, s, out)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestSetSequenceValue_OnlyMovesForwardPastData(t *testing.T) {
+	w := NewWriter(&writers.WriterOptions{})
+	table := serialTestTable("bigint", "nextval('identity.login_event_id_login_event_seq'::regclass)")
+	stmt, err := w.primaryKeySetvalStatement(serialTestDB(table).Schemas[0], table)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"MAX(", "is_called", "m_cnt > m_next", ", m_cnt, false)"} {
+		if !strings.Contains(stmt, want) {
+			t.Errorf("setval statement missing %q:\n%s", want, stmt)
+		}
+	}
+}
+
+func TestDiffStatements_ExistingTableNewSequenceIsSetPastData(t *testing.T) {
+	def := "nextval('identity.login_event_id_login_event_seq'::regclass)"
+	model := serialTestDB(serialTestTable("bigint", def))
+	current := serialTestDB(serialTestTable("bigint", nil))
+
+	w := NewWriter(&writers.WriterOptions{})
+	stmts, err := w.diffStatements(model, current)
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	out := diffJoin(stmts)
+	seqIdx := strings.Index(out, "CREATE SEQUENCE IF NOT EXISTS identity.login_event_id_login_event_seq")
+	setvalIdx := strings.Index(out, "setval(")
+	if seqIdx < 0 || setvalIdx < 0 || seqIdx > setvalIdx {
+		t.Fatalf("expected sequence creation before setval, got:\n%s", out)
+	}
+
+	// Sequence already present in the database: nothing to create or move.
+	current.Schemas[0].Sequences = append(current.Schemas[0].Sequences,
+		models.InitSequence("login_event_id_login_event_seq", "identity"))
+	stmts, err = w.diffStatements(model, current)
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	if strings.Contains(diffJoin(stmts), "setval(") || strings.Contains(diffJoin(stmts), "CREATE SEQUENCE") {
+		t.Fatalf("existing sequence must be left alone:\n%s", diffJoin(stmts))
+	}
+}
+
+func TestSerialWithoutDefault_DoesNotDropExistingDefault(t *testing.T) {
+	def := "nextval('identity.login_event_id_login_event_seq'::regclass)"
+	model := serialTestDB(serialTestTable("bigserial", nil))
+	current := serialTestDB(serialTestTable("bigserial", def))
+
+	w := NewWriter(&writers.WriterOptions{})
+	stmts, err := w.diffStatements(model, current)
+	if err != nil {
+		t.Fatalf("diffStatements failed: %v", err)
+	}
+	if strings.Contains(strings.ToUpper(diffJoin(stmts)), "DROP DEFAULT") {
+		t.Fatalf("serial default must not be dropped:\n%s", diffJoin(stmts))
+	}
+
+	alter, err := w.GenerateAlterColumnDefaultStatements(model.Schemas[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(strings.ToUpper(diffJoin(alter)), "DROP DEFAULT") {
+		t.Fatalf("full-DDL path must not drop serial default:\n%s", diffJoin(alter))
+	}
+
+	// A plain bigint with no model default still has its default dropped.
+	model = serialTestDB(serialTestTable("bigint", nil))
+	current = serialTestDB(serialTestTable("bigint", def))
+	stmts, err = w.diffStatements(model, current)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(strings.ToUpper(diffJoin(stmts)), "DROP DEFAULT") {
+		t.Fatalf("non-serial default removal should still be emitted:\n%s", diffJoin(stmts))
+	}
+}

pkg/writers/pgsql/templates.go

@@ -77,6 +77,10 @@ type ColumnData struct {
 	Type    string
 	Default string
 	NotNull bool
+	// Generated is the expression of a GENERATED ALWAYS AS (...) STORED column.
+	Generated string
+	// Identity is "ALWAYS" or "BY DEFAULT" for a GENERATED ... AS IDENTITY column.
+	Identity string
 }
 
 // AddColumnData contains data for add column template
@@ -87,6 +91,10 @@ type AddColumnData struct {
 	ColumnType string
 	Default    string
 	NotNull    bool
+	// Generated is the expression of a GENERATED ALWAYS AS (...) STORED column.
+	Generated string
+	// Identity is "ALWAYS" or "BY DEFAULT" for a GENERATED ... AS IDENTITY column.
+	Identity string
 }
 
 // AlterColumnTypeWithCheckData contains data for the guarded alter column
@@ -520,6 +528,19 @@ func (te *TemplateExecutor) ExecuteCreatePrimaryKeyWithAutoGenCheck(data CreateP
 
 // Helper functions to build template data from models
 
+// columnGenerationClauses returns the generation expression of a GENERATED ... STORED
+// column and the generation mode of an identity column ("" for each that does not apply).
+// Such columns cannot carry a DEFAULT.
+func columnGenerationClauses(col *models.Column) (generated, identity string) {
+	if col.Generated && col.GenerationExpression != "" {
+		return col.GenerationExpression, ""
+	}
+	if col.Identity && col.IdentityGeneration != "" {
+		return "", strings.ToUpper(col.IdentityGeneration)
+	}
+	return "", ""
+}
+
 // BuildCreateTableData builds CreateTableData from a models.Table
 func BuildCreateTableData(schemaName string, table *models.Table) CreateTableData {
 	columns := make([]ColumnData, 0, len(table.Columns))
@@ -532,7 +553,8 @@ func BuildCreateTableData(schemaName string, table *models.Table) CreateTableDat
 			Type:    col.Type,
 			NotNull: col.NotNull,
 		}
-		if col.Default != nil {
+		colData.Generated, colData.Identity = columnGenerationClauses(col)
+		if col.Default != nil && colData.Generated == "" && colData.Identity == "" {
 			if value, ok := col.Default.(string); ok {
 				colData.Default = writers.QuoteDefaultValue(stripBackticks(value), col.Type)
 			} else {

pkg/writers/pgsql/templates/add_column.tmpl

@@ -1,4 +1,6 @@
 ALTER TABLE {{qual_table .SchemaName .TableName}}
   ADD COLUMN IF NOT EXISTS {{quote_ident .ColumnName}} {{.ColumnType}}
-{{- if .Default}} DEFAULT {{.Default}}{{end}}
+{{- if .Generated}} GENERATED ALWAYS AS ({{.Generated}}) STORED{{end}}
+{{- if .Identity}} GENERATED {{.Identity}} AS IDENTITY{{end}}
+{{- if and .Default (not .Generated) (not .Identity)}} DEFAULT {{.Default}}{{end}}
 {{- if .NotNull}} NOT NULL{{end}};

pkg/writers/pgsql/templates/create_table.tmpl

@@ -2,7 +2,9 @@ CREATE TABLE IF NOT EXISTS {{qual_table .SchemaName .TableName}} (
 {{- range $i, $col := .Columns}}
 {{- if $i}},{{end}}
   {{quote_ident $col.Name}} {{$col.Type}}
-{{- if $col.Default}} DEFAULT {{$col.Default}}{{end}}
+{{- if $col.Generated}} GENERATED ALWAYS AS ({{$col.Generated}}) STORED{{end}}
+{{- if $col.Identity}} GENERATED {{$col.Identity}} AS IDENTITY{{end}}
+{{- if and $col.Default (not $col.Generated) (not $col.Identity)}} DEFAULT {{$col.Default}}{{end}}
 {{- if $col.NotNull}} NOT NULL{{end}}
 {{- end}}
 );

pkg/writers/pgsql/templates/fragments.tmpl

@@ -3,7 +3,9 @@
 {{/* Column definition fragment */}}
 {{- define "column_definition" -}}
 {{.Name}} {{.Type}}
-{{- if .Default}} DEFAULT {{.Default}}{{end}}
+{{- if .Generated}} GENERATED ALWAYS AS ({{.Generated}}) STORED{{end}}
+{{- if .Identity}} GENERATED {{.Identity}} AS IDENTITY{{end}}
+{{- if and .Default (not .Generated) (not .Identity)}} DEFAULT {{.Default}}{{end}}
 {{- if .NotNull}} NOT NULL{{end}}
 {{- end -}}
 

pkg/writers/pgsql/templates/set_sequence_value.tmpl

@@ -1,6 +1,7 @@
 DO $$
 DECLARE
   m_cnt bigint;
+  m_next bigint;
 BEGIN
   IF EXISTS (
     SELECT 1 FROM pg_class c
@@ -12,8 +13,15 @@ BEGIN
     SELECT COALESCE(MAX({{quote_ident .ColumnName}}), 0) + 1
     FROM {{qual_table .SchemaName .TableName}}
     INTO m_cnt;
-    
+
-    PERFORM setval('{{qual_table_raw .SchemaName .SequenceName}}'::regclass, m_cnt);
+    SELECT CASE WHEN is_called THEN last_value + 1 ELSE last_value END
+    FROM {{qual_table .SchemaName .SequenceName}}
+    INTO m_next;
+
+    -- Only move the sequence forward; never rewind one that is already past the data.
+    IF m_cnt > m_next THEN
+      PERFORM setval('{{qual_table_raw .SchemaName .SequenceName}}'::regclass, m_cnt, false);
+    END IF;
   END IF;
 END;
 $$;

pkg/writers/pgsql/writer.go

@@ -12,9 +12,10 @@ import (
 	"sync"
 	"time"
 
-	"git.warky.dev/wdevs/relspecgo/pkg/buildinfo"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/pgsql"
+	"git.warky.dev/wdevs/relspecgo/pkg/readers"
+	rpgsql "git.warky.dev/wdevs/relspecgo/pkg/readers/pgsql"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
 
@@ -102,7 +103,7 @@ func (w *Writer) WriteDatabase(db *models.Database) error {
 	// Write header comment
 	fmt.Fprintf(w.writer, "-- PostgreSQL Database Schema\n")
 	fmt.Fprintf(w.writer, "-- Database: %s\n", db.Name)
-	fmt.Fprintf(w.writer, "-- Generated by %s\n", buildinfo.GeneratedComment())
+	fmt.Fprintf(w.writer, "-- Generated by RelSpec\n")
 	if w.options.ContinueOnError {
 		fmt.Fprintf(w.writer, "\\set ON_ERROR_STOP off\n")
 	}
@@ -126,7 +127,7 @@ func (w *Writer) GenerateDatabaseStatements(db *models.Database) ([]string, erro
 	// Add header comment
 	statements = append(statements, "-- PostgreSQL Database Schema")
 	statements = append(statements, fmt.Sprintf("-- Database: %s", db.Name))
-	statements = append(statements, "-- Generated by "+buildinfo.GeneratedComment())
+	statements = append(statements, "-- Generated by RelSpec")
 
 	// Process each schema in the database
 	for _, schema := range db.Schemas {
@@ -140,6 +141,50 @@ func (w *Writer) GenerateDatabaseStatements(db *models.Database) ([]string, erro
 	return statements, nil
 }
 
+// primaryKeySequenceName returns the name of the sequence behind a table's integer
+// primary key nextval() default, or "" when the key has no such default.
+func primaryKeySequenceName(table *models.Table) string {
+	pk := table.GetPrimaryKey()
+	if pk == nil || !isIntegerType(pk.Type) || pk.Default == nil {
+		return ""
+	}
+
+	defaultStr, ok := pk.Default.(string)
+	if !ok || !strings.Contains(strings.ToLower(defaultStr), "nextval") {
+		return ""
+	}
+
+	return extractSequenceName(defaultStr)
+}
+
+// primaryKeySequenceStatement returns the CREATE SEQUENCE statement backing a table's
+// integer primary key nextval() default, or "" when the table has no such sequence.
+func (w *Writer) primaryKeySequenceStatement(schema *models.Schema, table *models.Table) string {
+	seqName := primaryKeySequenceName(table)
+	if seqName == "" {
+		return ""
+	}
+
+	return fmt.Sprintf("CREATE SEQUENCE IF NOT EXISTS %s\n  INCREMENT 1\n  MINVALUE 1\n  MAXVALUE 9223372036854775807\n  START 1\n  CACHE 1",
+		w.qualTable(schema.SQLName(), seqName))
+}
+
+// primaryKeySetvalStatement returns the statement that moves a table's primary key
+// sequence past the existing rows, or "" when the table has no such sequence.
+func (w *Writer) primaryKeySetvalStatement(schema *models.Schema, table *models.Table) (string, error) {
+	seqName := primaryKeySequenceName(table)
+	if seqName == "" {
+		return "", nil
+	}
+	pk := table.GetPrimaryKey()
+	return w.executor.ExecuteSetSequenceValue(SetSequenceValueData{
+		SchemaName:   schema.Name,
+		TableName:    table.Name,
+		SequenceName: seqName,
+		ColumnName:   pk.Name,
+	})
+}
+
 // GenerateSchemaStatements generates SQL statements as a list for a single schema
 func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, error) {
 	statements := []string{}
@@ -160,24 +205,9 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 
 	// Phase 2: Create sequences
 	for _, table := range schema.Tables {
-		pk := table.GetPrimaryKey()
+		if stmt := w.primaryKeySequenceStatement(schema, table); stmt != "" {
-		if pk == nil || !isIntegerType(pk.Type) || pk.Default == "" {
+			statements = append(statements, stmt)
-			continue
 		}
-
-		defaultStr, ok := pk.Default.(string)
-		if !ok || !strings.Contains(strings.ToLower(defaultStr), "nextval") {
-			continue
-		}
-
-		seqName := extractSequenceName(defaultStr)
-		if seqName == "" {
-			continue
-		}
-
-		stmt := fmt.Sprintf("CREATE SEQUENCE IF NOT EXISTS %s\n  INCREMENT 1\n  MINVALUE 1\n  MAXVALUE 9223372036854775807\n  START 1\n  CACHE 1",
-			w.qualTable(schema.SQLName(), seqName))
-		statements = append(statements, stmt)
 	}
 
 	// Phase 3: Create tables
@@ -392,6 +422,17 @@ func (w *Writer) GenerateSchemaStatements(schema *models.Schema) ([]string, erro
 		}
 	}
 
+	// Phase 6.5: Move primary key sequences past existing rows
+	for _, table := range schema.Tables {
+		stmt, err := w.primaryKeySetvalStatement(schema, table)
+		if err != nil {
+			return nil, fmt.Errorf("failed to generate set sequence value for %s.%s: %w", schema.Name, table.Name, err)
+		}
+		if stmt != "" {
+			statements = append(statements, stmt)
+		}
+	}
+
 	// Phase 7: Comments
 	for _, table := range schema.Tables {
 		if table.Comment != "" {
@@ -506,6 +547,11 @@ func (w *Writer) GenerateAlterColumnDefaultStatements(schema *models.Schema) ([]
 				// backing sequence), so there is nothing for this generator to manage.
 				continue
 			}
+			if isSerialWithoutDefault(col) {
+				// serial/bigserial columns get their nextval() default from the
+				// type itself; a model with no explicit default must not drop it.
+				continue
+			}
 			setDefault, defaultVal := formatColumnDefaultSQL(col)
 			stmt, err := w.executor.ExecuteAlterColumnDefaultWithCheck(AlterColumnDefaultWithCheckData{
 				SchemaName:   schema.Name,
@@ -524,6 +570,19 @@ func (w *Writer) GenerateAlterColumnDefaultStatements(schema *models.Schema) ([]
 	return statements, nil
 }
 
+// isSerialWithoutDefault reports whether col is a serial-family column with no
+// explicit default, i.e. one whose nextval() default is implied by its type.
+func isSerialWithoutDefault(col *models.Column) bool {
+	if col == nil || col.Default != nil {
+		return false
+	}
+	switch strings.ToLower(strings.TrimSpace(col.Type)) {
+	case "serial", "bigserial", "smallserial", "serial4", "serial8", "serial2":
+		return true
+	}
+	return false
+}
+
 // 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.
@@ -570,7 +629,7 @@ func (w *Writer) GenerateAddColumnsForDatabase(db *models.Database) ([]string, e
 
 	statements = append(statements, "-- Add missing columns to existing tables")
 	statements = append(statements, fmt.Sprintf("-- Database: %s", db.Name))
-	statements = append(statements, "-- Generated by "+buildinfo.GeneratedComment())
+	statements = append(statements, "-- Generated by RelSpec")
 
 	for _, schema := range db.Schemas {
 		schemaStatements, err := w.GenerateAddColumnStatements(schema)
@@ -873,18 +932,12 @@ func (w *Writer) writeSequences(schema *models.Schema) error {
 	fmt.Fprintf(w.writer, "-- Sequences for schema: %s\n", schema.Name)
 
 	for _, table := range schema.Tables {
-		pk := table.GetPrimaryKey()
+		// Only create the sequence the primary key's nextval() default uses
-		if pk == nil {
+		seqName := primaryKeySequenceName(table)
+		if seqName == "" {
 			continue
 		}
 
-		// Only create sequences for integer-type PKs with identity
-		if !isIntegerType(pk.Type) {
-			continue
-		}
-
-		seqName := fmt.Sprintf("identity_%s_%s", table.SQLName(), pk.SQLName())
-
 		data := CreateSequenceData{
 			SchemaName:   schema.Name,
 			SequenceName: seqName,
@@ -1424,12 +1477,11 @@ func (w *Writer) writeSetSequenceValues(schema *models.Schema) error {
 	fmt.Fprintf(w.writer, "-- Set sequence values for schema: %s\n", schema.Name)
 
 	for _, table := range schema.Tables {
-		pk := table.GetPrimaryKey()
+		seqName := primaryKeySequenceName(table)
-		if pk == nil || !isIntegerType(pk.Type) {
+		if seqName == "" {
 			continue
 		}
-
+		pk := table.GetPrimaryKey()
-		seqName := fmt.Sprintf("identity_%s_%s", table.SQLName(), pk.SQLName())
 
 		// Use template executor to generate set sequence value statement
 		data := SetSequenceValueData{
@@ -1994,7 +2046,9 @@ func extractSequenceName(defaultExpr string) string {
 	return fullName
 }
 
-// executeDatabaseSQL executes SQL statements directly on a PostgreSQL database
+// executeDatabaseSQL applies db to a PostgreSQL database. By default it reads the live schema
+// and executes only the differences; Metadata["full_ddl"]=true (or a failed/unsupported live
+// read) executes the full idempotent DDL instead.
 func (w *Writer) executeDatabaseSQL(db *models.Database, connString string) error {
 	// Initialize execution report
 	w.executionReport = &ExecutionReport{
@@ -2003,13 +2057,145 @@ func (w *Writer) executeDatabaseSQL(db *models.Database, connString string) erro
 		Errors:    make([]ExecutionError, 0),
 	}
 
-	// Generating a large schema can take time before any statement is executed.
+	var statements []string
-	fmt.Fprintln(os.Stderr, "      → Generating PostgreSQL statements...")
+	if fullDDL, _ := w.options.Metadata["full_ddl"].(bool); !fullDDL {
-	statements, err := w.GenerateDatabaseStatements(db)
+		diffStatements, err := w.generateLiveDiffStatements(db, connString)
-	if err != nil {
+		if err != nil {
-		return fmt.Errorf("failed to generate SQL statements: %w", err)
+			fmt.Fprintf(os.Stderr, "⚠ Warning: live diff unavailable (%v); falling back to full DDL\n", err)
+		} else {
+			statements = diffStatements
+			if len(statements) == 0 {
+				w.executionReport.EndTime = getCurrentTimestamp()
+				fmt.Fprintln(os.Stderr, "✓ Database is already up to date; nothing to execute")
+				return w.finishReport()
+			}
+		}
 	}
 
+	if statements == nil {
+		// Generating a large schema can take time before any statement is executed.
+		fmt.Fprintln(os.Stderr, "      → Generating PostgreSQL statements...")
+		var err error
+		statements, err = w.GenerateDatabaseStatements(db)
+		if err != nil {
+			return fmt.Errorf("failed to generate SQL statements: %w", err)
+		}
+	}
+
+	return w.executeStatements(statements, connString)
+}
+
+// generateLiveDiffStatements reads the live database and returns only the statements needed
+// to bring it in line with db. An error means the diff could not be computed.
+func (w *Writer) generateLiveDiffStatements(db *models.Database, connString string) ([]string, error) {
+	if w.options.FlattenSchema {
+		return nil, fmt.Errorf("flatten_schema output cannot be compared with the live schemas")
+	}
+
+	fmt.Fprintln(os.Stderr, "      → Reading live database to compute differences...")
+	current, err := rpgsql.NewReader(&readers.ReaderOptions{ConnectionString: connString}).ReadDatabase()
+	if err != nil {
+		return nil, fmt.Errorf("failed to read live database: %w", err)
+	}
+
+	return w.diffStatements(db, current)
+}
+
+// diffStatements returns the ordered statements that migrate current to model.
+func (w *Writer) diffStatements(model, current *models.Database) ([]string, error) {
+	currentSchemas := make(map[string]*models.Schema)
+	for _, cs := range current.Schemas {
+		if cs != nil {
+			currentSchemas[strings.ToLower(cs.Name)] = cs
+		}
+	}
+
+	statements := []string{}
+	// Primary key sequences that must be moved past existing rows once the
+	// migration scripts (which set the column defaults) have run.
+	var setvalStatements []string
+	for _, schema := range model.Schemas {
+		if schema == nil {
+			continue
+		}
+		if err := w.checkDirectives(schema); err != nil {
+			return nil, err
+		}
+
+		cs := currentSchemas[strings.ToLower(schema.Name)]
+		if cs == nil && schema.Name != "public" {
+			statements = append(statements,
+				fmt.Sprintf("-- Schema: %s", schema.Name),
+				fmt.Sprintf("CREATE SCHEMA IF NOT EXISTS %s", schema.SQLName()))
+		}
+
+		existing := make(map[string]*models.Table)
+		knownSequences := make(map[string]bool)
+		if cs != nil {
+			for _, t := range cs.Tables {
+				existing[strings.ToLower(t.Name)] = t
+			}
+			for _, seq := range cs.Sequences {
+				knownSequences[strings.ToLower(seq.Name)] = true
+			}
+		}
+		for _, table := range schema.Tables {
+			currentTable, ok := existing[strings.ToLower(table.Name)]
+			if !ok {
+				// New table: no rows yet, so the sequence only needs creating.
+				if stmt := w.primaryKeySequenceStatement(schema, table); stmt != "" {
+					statements = append(statements, stmt)
+				}
+				continue
+			}
+
+			// Existing table whose primary key is being pointed at a sequence the
+			// database does not have yet: create it and move it past the data,
+			// otherwise it restarts at 1 and collides with existing rows.
+			seqName := primaryKeySequenceName(table)
+			if seqName == "" || knownSequences[strings.ToLower(seqName)] {
+				continue
+			}
+			if cpk := currentTable.GetPrimaryKey(); cpk != nil && columnDefaultsEqual(table.GetPrimaryKey().Default, cpk.Default) {
+				continue
+			}
+			statements = append(statements, w.primaryKeySequenceStatement(schema, table))
+			setval, err := w.primaryKeySetvalStatement(schema, table)
+			if err != nil {
+				return nil, fmt.Errorf("failed to generate set sequence value for %s.%s: %w", schema.Name, table.Name, err)
+			}
+			setvalStatements = append(setvalStatements, setval)
+		}
+	}
+
+	mw, err := NewMigrationWriter(w.options)
+	if err != nil {
+		return nil, err
+	}
+	scripts, err := mw.GenerateScripts(model, current)
+	if err != nil {
+		return nil, fmt.Errorf("failed to generate migration scripts: %w", err)
+	}
+
+	lastSchema := ""
+	for _, script := range scripts {
+		body := strings.TrimSpace(script.Body)
+		if body == "" {
+			continue
+		}
+		if script.Schema != "" && script.Schema != lastSchema {
+			statements = append(statements, fmt.Sprintf("-- Schema: %s", script.Schema))
+			lastSchema = script.Schema
+		}
+		statements = append(statements, body)
+	}
+	statements = append(statements, setvalStatements...)
+
+	return statements, nil
+}
+
+// executeStatements runs statements one by one against the database and writes the report.
+func (w *Writer) executeStatements(statements []string, connString string) error {
 	w.executionReport.TotalStatements = len(statements)
 
 	// Connect to database
@@ -2109,7 +2295,11 @@ func (w *Writer) executeDatabaseSQL(db *models.Database, connString string) erro
 	}
 
 	w.executionReport.EndTime = getCurrentTimestamp()
+	return w.finishReport()
+}
 
+// finishReport writes the optional report file and prints the execution summary.
+func (w *Writer) finishReport() error {
 	// Write report if path is specified
 	if reportPath, ok := w.options.Metadata["report_path"].(string); ok && reportPath != "" {
 		if err := w.writeReport(reportPath); err != nil {

pkg/writers/sqlite/README.md

@@ -229,6 +229,7 @@ func main() {
 
 ## Notes
 
+- Generated columns are written as `col TYPE GENERATED ALWAYS AS (expr) STORED` (no DEFAULT)
 - 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

pkg/writers/sqlite/templates/create_table.tmpl

@@ -1,7 +1,7 @@
 CREATE TABLE {{quote_ident (qualified_table_name .Schema .Name)}} (
 {{- $hasAutoIncrement := false}}
 {{- range $i, $col := .Columns}}{{if $i}},{{end}}
-    {{quote_ident $col.Name}} {{map_type $col.Type}}{{column_collate $col}}{{if is_autoincrement $col}}{{$hasAutoIncrement = true}} PRIMARY KEY AUTOINCREMENT{{else}}{{if $col.NotNull}} NOT NULL{{end}}{{if ne (format_default $col) ""}} DEFAULT {{format_default $col}}{{end}}{{end}}
+    {{quote_ident $col.Name}} {{map_type $col.Type}}{{column_collate $col}}{{if and $col.Generated $col.GenerationExpression}} GENERATED ALWAYS AS ({{$col.GenerationExpression}}) STORED{{if $col.NotNull}} NOT NULL{{end}}{{else if is_autoincrement $col}}{{$hasAutoIncrement = true}} PRIMARY KEY AUTOINCREMENT{{else}}{{if $col.NotNull}} NOT NULL{{end}}{{if ne (format_default $col) ""}} DEFAULT {{format_default $col}}{{end}}{{end}}
 {{- end}}
 {{- 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}})

pkg/writers/sqlite/writer.go

@@ -10,7 +10,6 @@ import (
 
 	_ "modernc.org/sqlite" // SQLite driver
 
-	"git.warky.dev/wdevs/relspecgo/pkg/buildinfo"
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
@@ -73,7 +72,7 @@ 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 %s\n", buildinfo.GeneratedComment())
+	fmt.Fprintf(w.writer, "-- Generated by RelSpec\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

pkg/writers/sqlite/writer_test.go

@@ -421,3 +421,39 @@ func TestQuoteIdentifier(t *testing.T) {
 		}
 	}
 }
+
+func TestWriteDatabase_GeneratedColumn(t *testing.T) {
+	table := models.InitTable("people", "public")
+	first := models.InitColumn("first", "people", "public")
+	first.Type = "text"
+	first.Sequence = 1
+	table.Columns["first"] = first
+	full := models.InitColumn("full_name", "people", "public")
+	full.Type = "text"
+	full.Sequence = 2
+	full.NotNull = true
+	full.Generated = true
+	full.GenerationExpression = "first || ' ' || first"
+	full.Default = "ignored"
+	table.Columns["full_name"] = full
+
+	schema := models.InitSchema("public")
+	schema.Tables = append(schema.Tables, table)
+	db := models.InitDatabase("testdb")
+	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)
+	}
+
+	want := `"full_name" TEXT GENERATED ALWAYS AS (first || ' ' || first) STORED NOT NULL`
+	if !strings.Contains(buf.String(), want) {
+		t.Errorf("missing %q in:\n%s", want, buf.String())
+	}
+	if strings.Contains(buf.String(), "DEFAULT") && strings.Contains(buf.String(), "ignored") {
+		t.Errorf("generated column must not carry a DEFAULT:\n%s", buf.String())
+	}
+}

pkg/writers/typeorm/README.md

@@ -146,6 +146,12 @@ export class Post {
 })
 ```
 
+Generated and identity columns:
+
+- `asExpression: '...'`, `generatedType: 'STORED'` - generated column (no default)
+- `@PrimaryGeneratedColumn('identity', { generatedIdentity: 'ALWAYS' })` - identity primary key
+- `@Generated('identity')` + `generatedIdentity: '...'` - identity column that is not the primary key
+
 ## Type Mapping
 
 | SQL Type | TypeScript Type | TypeORM Type |

pkg/writers/typeorm/generated_columns_test.go

@@ -0,0 +1,76 @@
+package typeorm
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/readers"
+	typeormreader "git.warky.dev/wdevs/relspecgo/pkg/readers/typeorm"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
+)
+
+func TestGeneratedAndIdentityColumnsRoundTrip(t *testing.T) {
+	table := models.InitTable("people", "public")
+
+	id := models.InitColumn("id", "people", "public")
+	id.Type = "bigint"
+	id.IsPrimaryKey = true
+	id.NotNull = true
+	id.AutoIncrement = true
+	id.Identity = true
+	id.IdentityGeneration = "ALWAYS"
+	table.Columns["id"] = id
+
+	seq := models.InitColumn("seq", "people", "public")
+	seq.Type = "integer"
+	seq.NotNull = true
+	seq.Identity = true
+	seq.IdentityGeneration = "BY DEFAULT"
+	table.Columns["seq"] = seq
+
+	first := models.InitColumn("first", "people", "public")
+	first.Type = "text"
+	first.NotNull = true
+	table.Columns["first"] = first
+
+	full := models.InitColumn("full_name", "people", "public")
+	full.Type = "text"
+	full.NotNull = true
+	full.Generated = true
+	full.GenerationExpression = "first || ' ' || upper(first)"
+	table.Columns["full_name"] = full
+
+	schema := models.InitSchema("public")
+	schema.Tables = append(schema.Tables, table)
+	db := models.InitDatabase("testdb")
+	db.Schemas = append(db.Schemas, schema)
+
+	out := filepath.Join(t.TempDir(), "entities.ts")
+	require.NoError(t, NewWriter(&writers.WriterOptions{OutputPath: out}).WriteDatabase(db))
+
+	content, err := os.ReadFile(out)
+	require.NoError(t, err)
+	assert.Contains(t, string(content), `asExpression: 'first || \' \' || upper(first)'`)
+	assert.Contains(t, string(content), "generatedType: 'STORED'")
+	assert.Contains(t, string(content), "@PrimaryGeneratedColumn('identity', { generatedIdentity: 'ALWAYS' })")
+	assert.Contains(t, string(content), "@Generated('identity')")
+	assert.Contains(t, string(content), "Generated } from 'typeorm'")
+
+	got, err := typeormreader.NewReader(&readers.ReaderOptions{FilePath: out}).ReadDatabase()
+	require.NoError(t, err)
+	cols := got.Schemas[0].Tables[0].Columns
+
+	assert.True(t, cols["id"].Identity)
+	assert.Equal(t, "ALWAYS", cols["id"].IdentityGeneration)
+	assert.True(t, cols["seq"].Identity)
+	assert.Equal(t, "BY DEFAULT", cols["seq"].IdentityGeneration)
+	assert.True(t, cols["full_name"].Generated)
+	assert.Equal(t, "first || ' ' || upper(first)", cols["full_name"].GenerationExpression)
+	assert.False(t, cols["first"].Generated)
+	assert.False(t, cols["first"].Identity)
+}

pkg/writers/typeorm/writer.go

@@ -97,6 +97,7 @@ func (w *Writer) generateImports(db *models.Database) string {
 	needsCreateDate := false
 	needsUpdateDate := false
 	needsViewEntity := false
+	needsGenerated := false
 
 	for _, schema := range db.Schemas {
 		// Check for views
@@ -107,6 +108,9 @@ func (w *Writer) generateImports(db *models.Database) string {
 		for _, table := range schema.Tables {
 			// Check for timestamp columns
 			for _, col := range table.Columns {
+				if isNonKeyIdentity(col) {
+					needsGenerated = true
+				}
 				if col.Default == "now()" {
 					needsCreateDate = true
 				}
@@ -161,6 +165,9 @@ func (w *Writer) generateImports(db *models.Database) string {
 	if needsViewEntity {
 		imports = append(imports, "ViewEntity")
 	}
+	if needsGenerated {
+		imports = append(imports, "Generated")
+	}
 
 	return fmt.Sprintf("import { %s } from 'typeorm';\n", strings.Join(imports, ", "))
 }
@@ -299,14 +306,16 @@ func (w *Writer) columnToField(col *models.Column, table *models.Table) string {
 
 	// Generate decorator
 	if col.IsPrimaryKey {
-		if col.AutoIncrement {
+		if col.Identity && col.IdentityGeneration != "" {
+			fmt.Fprintf(&sb, "  @PrimaryGeneratedColumn('identity', { generatedIdentity: '%s' })\n", strings.ToUpper(col.IdentityGeneration))
+		} else if col.AutoIncrement {
 			sb.WriteString("  @PrimaryGeneratedColumn('increment')\n")
 		} else if col.Type == "uuid" || strings.Contains(fmt.Sprint(col.Default), "uuid") {
 			sb.WriteString("  @PrimaryGeneratedColumn('uuid')\n")
 		} else {
 			sb.WriteString("  @PrimaryGeneratedColumn()\n")
 		}
-	} else if col.Default == "now()" {
+	} else if col.Default == "now()" && !col.Generated {
 		sb.WriteString("  @CreateDateColumn()\n")
 	} else if strings.Contains(col.Comment, "auto-update") {
 		sb.WriteString("  @UpdateDateColumn()\n")
@@ -318,6 +327,9 @@ func (w *Writer) columnToField(col *models.Column, table *models.Table) string {
 		} else {
 			sb.WriteString("  @Column()\n")
 		}
+		if isNonKeyIdentity(col) {
+			sb.WriteString("  @Generated('identity')\n")
+		}
 	}
 
 	// Generate field declaration
@@ -351,8 +363,18 @@ func (w *Writer) buildColumnOptions(col *models.Column, table *models.Table) str
 		options = append(options, "unique: true")
 	}
 
+	// Generated column (GENERATED ALWAYS AS (expr) STORED)
+	if col.Generated && col.GenerationExpression != "" {
+		options = append(options, fmt.Sprintf("asExpression: '%s'", escapeSingleQuoted(col.GenerationExpression)), "generatedType: 'STORED'")
+	}
+
+	// Identity column that is not the primary key
+	if isNonKeyIdentity(col) {
+		options = append(options, fmt.Sprintf("generatedIdentity: '%s'", strings.ToUpper(col.IdentityGeneration)))
+	}
+
 	// Default
-	if col.Default != nil && col.Default != "now()" {
+	if !col.Generated && !col.Identity && col.Default != nil && col.Default != "now()" {
 		defaultStr := fmt.Sprint(col.Default)
 		if defaultStr != "" {
 			options = append(options, fmt.Sprintf("default: '%s'", defaultStr))
@@ -362,6 +384,16 @@ func (w *Writer) buildColumnOptions(col *models.Column, table *models.Table) str
 	return strings.Join(options, ", ")
 }
 
+// isNonKeyIdentity reports whether col is a GENERATED ... AS IDENTITY column outside the primary key.
+func isNonKeyIdentity(col *models.Column) bool {
+	return col.Identity && col.IdentityGeneration != "" && !col.IsPrimaryKey
+}
+
+// escapeSingleQuoted escapes a value for use inside a single-quoted TypeScript string.
+func escapeSingleQuoted(s string) string {
+	return strings.ReplaceAll(strings.ReplaceAll(s, `\`, `\\`), `'`, `\'`)
+}
+
 // needsExplicitType checks if a SQL type needs explicit type declaration
 func (w *Writer) needsExplicitType(sqlType string) bool {
 	// Types that don't map cleanly to TypeScript types need explicit declaration

tests/_plans/README.md

@@ -0,0 +1,50 @@
+# Test Coverage Plans
+
+Baseline: 51.0% total statements (2026-10-03, after PRs #41-#43).
+Scope: pgsql, sqlexec, template, plus non-reader/writer packages. Other readers/writers deferred.
+
+## Order
+
+| # | Plan | Package(s) | Now |
+|---|------|-----------|-----|
+| 1 | [pgsql.md](pgsql.md) | readers/pgsql, writers/pgsql, pkg/pgsql | 16.0 / 74.0 / 87.8 |
+| 2 | [sqlexec.md](sqlexec.md) | writers/sqlexec | 19.4 |
+| 3 | [template.md](template.md) | writers/template | 8.5 |
+| 4 | [models.md](models.md) | pkg/models | 20.4 |
+| 5 | [cmd.md](cmd.md) | cmd/relspec, pkg/jobs | 49.3 / 72.0 |
+| 6 | [ui.md](ui.md) | pkg/ui | 3.8 |
+| 7 | [diff-merge.md](diff-merge.md) | pkg/diff, pkg/merge | 65.5 / 75.1 |
+| 8 | [sqltypes.md](sqltypes.md) | pkg/sqltypes | 67.0 |
+
+## Conventions
+
+- Same package as code under test; table-driven; must pass `-race`.
+- Existing data first: `tests/assets/*`, `examples/*.dbml`, `tests/postgres/init.sql`, `tests/postgres/issue21`. Generate new data only where listed under "Data needed".
+- New fixtures go in `tests/assets/<format>/` or package `testdata/`.
+- Live-DB tests: skip unless the env var is set (pattern in `pkg/readers/pgsql/reader_test.go`). Use `tests/dbtest/dbtest.sh` (podman/docker; see `tests/dbtest/README.md`):
+  - `dbtest.sh up|down <postgres|mssql|mysql|all>`
+  - `eval "$(dbtest.sh env postgres)"` sets `RELSPEC_TEST_PG_CONN` (mssql: `RELSPEC_TEST_MSSQL_CONN`, mysql: `RELSPEC_TEST_MYSQL_CONN`)
+  - `dbtest.sh test <db> [pkgs]` runs up, `go test`, down
+- Fixtures for live DBs: postgres `tests/postgres/init.sql`, mssql `test_data/mssql/test_schema.sql`, mysql `tests/dbtest/init/mysql.sql`.
+- Prerequisite: working container networking (currently blocked until reboot into matching kernel; `tun` module).
+- Prefer pure-function tests over DB tests wherever the logic can be isolated.
+- Output assertions must not depend on map order (see memory: map iteration determinism).
+
+## Targets
+
+| Package | Target |
+|---------|--------|
+| pgsql (all three) | >= 85 |
+| sqlexec | >= 80 |
+| template | >= 85 |
+| models | >= 80 |
+| cmd/relspec | >= 65 |
+| jobs | >= 85 |
+| ui | >= 40 (data ops/pure helpers; screens via smoke tests) |
+| diff, merge | >= 85 |
+| sqltypes | >= 85 |
+
+## Verify
+
+- `go test -race -coverprofile=c.out ./pkg/<pkg>/` then `go tool cover -func=c.out`
+- `make test` before commit

tests/_plans/cmd.md

@@ -0,0 +1,29 @@
+# Plan: cmd/relspec (49.3%) and pkg/jobs (72.0%)
+
+## Existing
+- cmd tests: convert_from_list, diff_sqldir, dry_run (#41), job, merge_from_list, templ_from_list
+- jobs: `jobs_test.go`
+
+## cmd/relspec
+
+| Area | Gap | Approach |
+|------|-----|----------|
+| convert | `readDatabaseForConvert` 22%, `writeDatabase` 36%, `validateWriteTarget` 44%, `loadExtraFields`, `getSchemaNames`, `stderrWarn` | Table-driven per format using `tests/assets`; unsupported format, missing package, bad extra-fields JSON/empty/non-bun, schema filter not found, dctx multi-schema |
+| merge | `readDatabaseForMerge` 18%, `writeDatabaseForMerge` 14%, `expandPath`, `parseSkipTables`, `isMergeOutputFormat` | Table-driven formats; globs; skip-list parsing |
+| diff | `runDiff`, `readDatabase`, `maskPasswordInDiff` | File-based inputs; password masking cases |
+| inspect | `runInspect`, `readDatabaseForInspect`, `filterDatabaseBySchema` | File-based input; schema filter |
+| scripts | `runScriptsList` | Use `pkg/readers/sqldir` fixtures; execute path live via dbtest postgres |
+| assets | `runAssetsList`, `runAssetsExecute` | List against temp dir; execute live via dbtest postgres |
+| edit | `runEdit`, `readDatabaseForEdit`, `writeDatabaseForEdit` | Test read/write helpers only; skip TUI loop |
+| report | state dir, load/save state, token, machine id, `submitReport` | Temp HOME; submit against `httptest` server; never hit real endpoint |
+| root/main | `printVersionHeader`, `hasSilentFlag` | Pure |
+| dry-run | merge/split paths | Add merge dry-run and split dry-run tests (convert covered) |
+
+## pkg/jobs
+- `ResolvedLogPolicy`, `Dir`, `validateTemplInput` (0%), `validateOutput` (44%): table-driven valid/invalid job definitions.
+- Existing job files: `examples/jobs`.
+
+## Live DB cases (dbtest)
+- `runScriptsExecute`, `runAssetsExecute`, job script-exec, `readDatabaseForConvert/Merge/Inspect` for pgsql, and pgsql merge/convert output: `tests/dbtest/dbtest.sh test postgres ./cmd/relspec/`.
+- mssql source reads (convert/inspect): `dbtest.sh up mssql`, env `RELSPEC_TEST_MSSQL_CONN`; fixture `test_data/mssql/test_schema.sql`.
+- Skip when env var unset.

tests/_plans/diff-merge.md

@@ -0,0 +1,29 @@
+# Plan: pkg/diff (65.5%) and pkg/merge (75.1%)
+
+## Existing
+- diff: `diff_test.go`, `formatters_test.go`
+- merge: `merge_test.go`
+
+## pkg/diff
+
+| Func | Now | Cases |
+|------|-----|-------|
+| `compareSchemaDetails` | 0% | Description/owner/options changed |
+| `compareConstraintDetails`, `normalizeConstraintAction` | 0% | Columns, referenced table, on-update/on-delete variants and case/default normalisation |
+| `compareRelationshipDetails` | 0% | Changed endpoints/type |
+| `compareViews`, `compareViewDetails` | 0% | Added/removed/changed definition |
+| `compareSequences`, `compareSequenceDetails` | 0% | Added/removed/changed increment/min/max/start |
+
+Data: pair `examples/test_schema.dbml` and `test_schema_modified.dbml`; add view/sequence changes in code-built fixtures.
+
+## pkg/merge
+
+| Func | Now | Cases |
+|------|-----|-------|
+| `mergeSequences`, `cloneSequence` | 33% / 0% | New, existing, conflicting; clone is deep |
+| `cloneSchema` | 48% | Views, sequences, scripts, indexes cloned independently |
+| `extractTypeParts` | 48% | Precision/scale, arrays, schema-qualified, no modifiers |
+| `GetColumnTypeConflictSummary`, `min` | 0% | Limit truncation, zero conflicts |
+
+## Live DB cases (dbtest)
+- pgsql live diff/merge against a real DB: `dbtest.sh test postgres`; reuse `tests/postgres/init.sql` as the live side and `examples/test_schema*.dbml` as the desired side.

tests/_plans/models.md

@@ -0,0 +1,18 @@
+# Plan: pkg/models (20.4%)
+
+## Existing
+- `directives_test.go`
+
+## Gaps
+
+| File | Funcs | Cases |
+|------|-------|-------|
+| `models.go` | All `SQLName` methods, `UpdateDate`, `GetPrimaryKey`, `columnLess`, `GetForeignKeys` | Case handling, empty/nil maps, composite PK ordering, FK filtering |
+| `models.go` | `Init*` constructors (Database, Schema, Table, Column, Index, Relation, Relationship, Constraint, Script, View, Sequence, Domain, DomainTable, Enum) | Maps/slices non-nil, name set, defaults |
+| `sorting.go` | 20 Sort* funcs | By name and by sequence; ties; map variants return sorted slice; input not mutated where documented |
+| `flatview.go` | ToFlatColumns, ToFlatTables, ToFlatConstraints, ToFlatRelationships | Multi-schema, empty db, deterministic order |
+| `summaryview.go` | ToSummary | Counts across object types |
+| `directives.go` | `directiveFromAny` (22%) | Each input type branch, invalid type |
+
+## Data needed
+- One shared in-test builder for a multi-schema Database (reuse `tests/assets/dbml/complex.dbml` via reader only if no import cycle; otherwise build in code).

tests/_plans/pgsql.md

@@ -0,0 +1,38 @@
+# Plan: PostgreSQL
+
+## Tooling
+- Live tests: `tests/dbtest/dbtest.sh test postgres` (defaults to readers/pgsql, writers/pgsql, writers/sqlexec) or `up postgres` + `eval "$(tests/dbtest/dbtest.sh env postgres)"`.
+- Isolation: each live test creates and drops its own schema; shared fixture DB comes from `init.sql`.
+
+## Existing
+- Reader tests: `pkg/readers/pgsql/reader_test.go` (live tests skipped without `RELSPEC_TEST_PG_CONN`; pure tests: MapDataType, ParseIndexDefinition, DeriveRelationship, composite FK)
+- Writer tests: diff_statements, directives, extensions, generated_column, migration_writer, serial_sequence
+- Data: `tests/postgres/init.sql`, `tests/postgres/issue21`, `tests/assets/dbml/*`, `examples/test_schema*.dbml`
+
+## readers/pgsql (16.0%)
+
+| Item | Gap | Approach |
+|------|-----|----------|
+| `normalizePostgresDefault` (queries.go) | 0% | Pure; table-driven: casts, nextval, functions, quoted literals, NULL |
+| `countColumns/Constraints/Indexes` | 0% | Pure; build Database fixtures |
+| `ReadDatabase/ReadSchema/ReadTable` | ~0% | Live; run against `init.sql` DB; assert counts, PK/FK/unique/check/index, views, sequences, extensions |
+| `query*` (11 funcs) | 0% | Covered via live ReadDatabase; add one live case per object type |
+| `close` | 0% | Live; connection released after read and on error |
+
+Data needed: extend `tests/postgres/init.sql` (loaded by dbtest on `up`; apply changes with `dbtest.sh restart postgres`) with a view, sequence, check constraint, partial index, extension, composite FK (verify what already exists first).
+
+## writers/pgsql (74.0%)
+
+| Item | Gap | Approach |
+|------|-----|----------|
+| `extractTableNameFromCreate`, `extractStatementContext`, `extractSQLStringValue`, `parseQualifiedIdent`, `firstBareIdent`, `firstIdentAfterKeyword`, `stripQuotes`, `buildStmtContext`, `detectStatementType`, `truncateStatement` | 0% | Pure; table-driven; quoted/qualified/unquoted idents, each statement type, long statements |
+| `getCurrentTimestamp`, `finishReport`, `writeReport` | 0% | Report written to temp file; JSON shape, counts, failed statements |
+| `executeStatements`, `executeDatabaseSQL` | 0% | Live; success, failure with continue-on-error, failure stop, report output |
+| `generateLiveDiffStatements` | 28.6% | Live; empty DB, drifted DB, identical DB |
+| `currentColumnHasDescription`, `ExecuteCommentColumn` | 0% | Migration writer fixtures with comments added/removed/changed |
+| `template_functions.go` `filter`, `mapFunc` | 0% | Pure |
+
+Reuse `tests/integration/failed_statements_example.txt` for failed-statement report cases. Ad-hoc SQL setup: `dbtest.sh exec postgres <file>`.
+
+## pkg/pgsql (87.8%)
+- Spot-check uncovered funcs after the above; add keyword/datatype edge cases only.

tests/_plans/sqlexec.md

@@ -0,0 +1,20 @@
+# Plan: writers/sqlexec (19.4%)
+
+## Existing
+- `writer_test.go`: constructor, nil DB, missing conn string, empty scripts, script sorting, embed directives
+
+## Gaps
+
+| Item | Now | Approach |
+|------|-----|----------|
+| `Options` | 0% | Trivial getter |
+| `WriteDatabase` | 31.2% | Multi-schema; error from one schema aborts; context/connect failure |
+| `executeScripts` | 0% | Live via dbtest postgres (`RELSPEC_TEST_PG_CONN`); ordering by priority/sequence, failing script reports script name, empty SQL skipped, transaction/partial-apply behaviour as implemented |
+| `WriteSchema` | partial | Connection error path, success path live |
+
+## Data needed
+- Small script set (3-4 scripts, mixed priority, one failing) as fixtures; check `tests/assets` and `pkg/readers/sqldir` testdata first.
+- Cleanup: each live test uses a throwaway schema and drops it.
+
+## Decision
+- Live-only via `tests/dbtest/dbtest.sh test postgres ./pkg/writers/sqlexec/`; no connection interface or mock.

tests/_plans/sqltypes.md

@@ -0,0 +1,14 @@
+# Plan: pkg/sqltypes (67.0%)
+
+## Existing
+- array types, fromstring, sql types, yaml/xml, struct json, uuid integration tests
+
+## Gaps
+
+| Area | Funcs | Approach |
+|------|-------|----------|
+| Array types | MarshalYAML/UnmarshalYAML/MarshalXML/UnmarshalXML across each array type; some `UnmarshalJSON/MarshalJSON` | One round-trip test per array type (reuse helper from `sql_types_yaml_xml_test.go`) |
+| Scalar types | `Value` (3 types), `MarshalJSON/UnmarshalJSON` for date, `Int64` (31%), `Float64` (40%) | Valid, null, invalid string, overflow |
+| Constructors | `SqlTimeStampNow`, `SqlDateNow`, `SqlTimeNow`, `NewSql`, `NewSqlFloat32`, `ToJSONDT` | Assert non-zero/valid and approximately now |
+
+No data needed.

tests/_plans/template.md

@@ -0,0 +1,23 @@
+# Plan: writers/template (8.5%)
+
+## Existing
+- `writer_test.go`: deterministic table index values only
+
+## Approach
+Pure helper functions; one test file per source file, table-driven. Then render tests through the writer.
+
+| File | Funcs | Cases |
+|------|-------|-------|
+| `filters.go` | FilterTables, FilterTablesByPattern, FilterColumns, FilterColumnsByType, FilterPrimaryKeys, FilterForeignKeys, FilterUniqueConstraints, FilterCheckConstraints, FilterNullable, FilterNotNull, matchPattern | Empty input, no match, glob patterns, nil maps |
+| `formatters.go` | ToJSON, ToJSONPretty, ToYAML, Indent, IndentWith, Escape, EscapeQuotes, Comment, QuoteString, UnquoteString | Empty string, multiline, special chars, marshal failure |
+| `loop_helpers.go` | Enumerate, Batch, Chunk, Reverse, First, Last, Skip, Take, Concat, Unique, SortBy, GroupBy, CountIf, getFieldValue, compareValues | Empty, n > len, n <= 0, non-slice input, missing field |
+| `safe_access.go` | Get, GetOr, GetPath, GetPathOr, SafeIndex, SafeIndexOr, Has, HasPath, Keys, Merge, Pick, Omit, SliceContains, IndexOf, Pluck | nil, missing key, nested path, out-of-range |
+| `string_helpers.go` | ToUpper, ToLower, ToCamelCase, and rest | Empty, snake/kebab/space input, unicode |
+| `errors.go` | Error, Unwrap, NewTemplate{Load,Parse,Execute}Error | errors.Is/As, message contents |
+| `funcmap.go` | BuildFuncMap | Every registered name resolves and is callable |
+| `type_mappers.go`, `template_data.go` | check after above | |
+| `writer.go` | WriteDatabase/Schema/Table, modes | Template load/parse/execute error paths; per-table, per-schema, whole-db modes; output to file vs stdout |
+
+## Data needed
+- 2-3 small template fixtures in `pkg/writers/template/testdata/` (valid, parse error, execute error).
+- Schema input: reuse `tests/assets/dbml/simple.dbml` / `complex.dbml`.

tests/_plans/ui.md

@@ -0,0 +1,27 @@
+# Plan: pkg/ui (3.8%)
+
+## Existing
+- `object_dataops_test.go` (indexes, views, sequences, scripts, domain assignment)
+- Rules: `pkg/ui/ui_rules.md`
+
+## Layers
+
+| Layer | Files | Testable? | Approach |
+|-------|-------|-----------|----------|
+| Data ops | column_, relation_, domain_, schema_, table_, database_dataops.go | Yes, pure | CRUD tests per file: create, duplicate, update/rename, delete, not-found, bounds, UpdateDate side effects |
+| Pure helpers | `sortedKeys`, `schemaLocations`, `tableLocations`, `getColumnNames`, `parseSkipTablesUI`, help-text getters | Yes | Table-driven |
+| Kind definitions | `indexKind/viewKind/sequenceKind/scriptKind` | Yes | Assert row builders and form-to-model mapping without rendering |
+| Load/save | `loadDatabase`, `saveDatabase`, `createNewDatabase`, `importAndMergeDatabase`, `performMerge` | Partly | Temp files from `tests/assets`; verify format dispatch and error paths; avoid UI dialogs |
+| Screens | *_screens.go, dialogs.go, main_menu.go | Yes, via simulation | tview app on tcell SimulationScreen; inject key events; assert navigation, form submit mutates model, cancel leaves it unchanged, delete confirm paths |
+
+## Order
+1. Data ops (largest gain, no tview)
+2. Pure helpers and kinds
+3. Load/save logic
+4. Screen tests on simulation screen (menu, lists, forms, confirm dialogs, load/save)
+
+## Decision
+- Screen smoke tests via tview simulation screen are in scope (tcell `SimulationScreen`); drive keys/events, assert no panic and expected state.
+
+## Live DB cases (dbtest)
+- Load/save and import-merge from a live pgsql source: `dbtest.sh up postgres`; skip when `RELSPEC_TEST_PG_CONN` unset.

tests/dbtest/README.md

@@ -0,0 +1,45 @@
+# dbtest: container test databases
+
+Podman (preferred) or Docker. One tool for postgres, mssql, mysql.
+
+## Commands
+
+| Command | Action |
+|---|---|
+| `./tests/dbtest/dbtest.sh up <db\|all>` | Start, wait for ready, run init |
+| `down <db\|all>` | Stop and remove |
+| `restart <db>` | Fresh container |
+| `status <db\|all>` | State and connection string |
+| `env <db\|all>` | Print `export` line for the test env var |
+| `test <db> [pkgs]` | up, `go test`, down |
+| `shell <db>` | Interactive client |
+| `exec <db> <file>` | Run SQL file |
+| `logs <db>` | Container logs |
+
+## Databases
+
+| db | Port | Env var | Init | Default test pkgs |
+|---|---|---|---|---|
+| postgres | 5439 | `RELSPEC_TEST_PG_CONN` | `tests/postgres/init.sql` | readers/pgsql, writers/pgsql, writers/sqlexec |
+| mssql | 1439 | `RELSPEC_TEST_MSSQL_CONN` | `test_data/mssql/test_schema.sql` (creates `RelSpecTest`) | readers/mssql, writers/mssql |
+| mysql | 3309 | `RELSPEC_TEST_MYSQL_CONN` | `tests/dbtest/init/mysql.sql` | none (no Go driver/reader yet) |
+
+## Env
+
+| Var | Effect |
+|---|---|
+| `DBTEST_RUNTIME` | Force `podman` or `docker` |
+| `DBTEST_TIMEOUT` | Ready wait, seconds (default 120) |
+| `DBTEST_KEEP=1` | Keep container after `test` |
+| `DBTEST_GOFLAGS` | Extra `go test` flags |
+
+## Add a database
+
+1. Add `dbs/<name>.sh` defining: `DB_NAME DB_IMAGE DB_CONTAINER DB_PORT DB_INTERNAL_PORT DB_ENV DB_INIT_MOUNT DB_CONN_VAR DB_CONN DB_DEFAULT_PKGS` and functions `db_ready db_post_init db_shell db_exec_file`.
+2. Add the name to `ALL_DBS` in `dbtest.sh`.
+
+## Notes
+
+- Containers are named `relspec-test-<db>`; existing `tests/postgres/*.sh` and `make docker-*` use the same postgres name/port 5439 and remain independent.
+- mssql needs ~2GB RAM and takes longer to become ready.
+- Tests skip when the env var is unset.

tests/dbtest/dbs/mssql.sh

@@ -0,0 +1,17 @@
+# SQL Server container definition (sourced by dbtest.sh)
+DB_NAME=mssql
+DB_IMAGE=mcr.microsoft.com/mssql/server:2022-latest
+DB_CONTAINER=relspec-test-mssql
+DB_PORT=1439
+DB_INTERNAL_PORT=1433
+DB_ENV=(-e ACCEPT_EULA=Y -e "MSSQL_SA_PASSWORD=StrongPassword123!" -e MSSQL_PID=Express)
+DB_INIT_MOUNT="$ROOT/test_data/mssql/test_schema.sql:/init/test_schema.sql"
+DB_CONN_VAR=RELSPEC_TEST_MSSQL_CONN
+DB_CONN="sqlserver://sa:StrongPassword123!@localhost:1439?database=RelSpecTest"
+DB_DEFAULT_PKGS="./pkg/readers/mssql/ ./pkg/writers/mssql/"
+
+_sqlcmd() { rt exec -i "$DB_CONTAINER" /opt/mssql-tools18/bin/sqlcmd -C -S localhost -U sa -P 'StrongPassword123!' "$@"; }
+db_ready()  { _sqlcmd -Q "SELECT 1" >/dev/null 2>&1; }
+db_post_init() { _sqlcmd -b -i /init/test_schema.sql >/dev/null; }
+db_shell()  { rt exec -it "$DB_CONTAINER" /opt/mssql-tools18/bin/sqlcmd -C -S localhost -U sa -P 'StrongPassword123!' -d RelSpecTest "$@"; }
+db_exec_file() { _sqlcmd -b -d RelSpecTest < "$1"; }

tests/dbtest/dbs/mysql.sh

@@ -0,0 +1,16 @@
+# MySQL container definition (sourced by dbtest.sh)
+DB_NAME=mysql
+DB_IMAGE=docker.io/library/mysql:8.4
+DB_CONTAINER=relspec-test-mysql
+DB_PORT=3309
+DB_INTERNAL_PORT=3306
+DB_ENV=(-e MYSQL_ROOT_PASSWORD=relspec_root_password -e MYSQL_DATABASE=relspec_test -e MYSQL_USER=relspec -e MYSQL_PASSWORD=relspec_test_password)
+DB_INIT_MOUNT="$ROOT/tests/dbtest/init/mysql.sql:/docker-entrypoint-initdb.d/init.sql"
+DB_CONN_VAR=RELSPEC_TEST_MYSQL_CONN
+DB_CONN="relspec:relspec_test_password@tcp(localhost:3309)/relspec_test"
+DB_DEFAULT_PKGS=""
+
+db_ready()  { rt exec "$DB_CONTAINER" mysqladmin ping -h 127.0.0.1 -urelspec -prelspec_test_password --silent >/dev/null 2>&1; }
+db_post_init() { :; }
+db_shell()  { rt exec -it "$DB_CONTAINER" mysql -urelspec -prelspec_test_password relspec_test "$@"; }
+db_exec_file() { rt exec -i "$DB_CONTAINER" mysql -urelspec -prelspec_test_password relspec_test < "$1"; }