dbly 0.3.0__tar.gz → 0.6.0__tar.gz

{dbly-0.3.0 → dbly-0.6.0}/CHANGELOG.md

@@ -7,6 +7,72 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.6.0] — 2026-07-24
+
+### Added
+
+- **`dbly export` — reverse direction.** Introspect a live database and emit its DDL as a SQL
+  script, optionally transpiled to another engine with `--dialect` (postgres | oracle |
+  sqlserver | sqlite). Tables and views are converted across dialects (tables rebuilt from the
+  live column set — constraints/indexes are not reconstructed, and a warning says so);
+  procedural objects (function/procedure/trigger/package/type) are emitted **verbatim** in the
+  source dialect. Scope with `--schema`; write to a file with `--out`. dbly's own `dbly_state`
+  ledger is never exported.
+
+## [0.5.0] — 2026-07-24
+
+### Added
+
+- **Partial deploy / check.** `plan`, `apply` and `check` take `--schema NAME` (the folder
+  under `object_root`; repeatable, case-insensitive) and `--path SUBPATH` (any subtree under
+  `object_root`; repeatable) to scope the operation to part of the repo — e.g. deploy only
+  `bas/`. Both filters AND together; orphan reporting is scoped to the same selection.
+
+### Changed
+
+- **Redesigned `check` output.** Drift is now grouped with an explicit direction —
+  *"Only in the repo — will be created on apply"* vs. *"Only in the database — not in the
+  repo"* — with per-group counts, a summary tally, and `+`/`−` markers for column drift
+  (`+` in the repo but missing from the DB, `−` in the DB but not the repo). The header shows
+  the ref (decorated) and the active scope.
+
+## [0.4.1] — 2026-07-23
+
+### Changed
+
+- **Quiet by default.** sqlglot's per-statement fallback WARNINGs (it echoes any procedural /
+  engine-specific DDL it can't fully parse) and SQLAlchemy's "Did not recognize type" warnings
+  (e.g. PostGIS `geometry`) flooded the output on real repos. Both are now silenced; pass
+  `--debug` to see them again.
+
+## [0.4.0] — 2026-07-23
+
+### Added
+
+- **Project configuration (`dbly.toml`).** An optional file at the repo root, for repos that
+  need more than a single connection profile:
+  - `object_root` — the subtree the declarative object files live under. The schema hint is
+    taken from the first path segment *below* this root, so a layout like
+    `pgsql/schema/<schema>/<obj>` maps to the right schema instead of the literal top folder.
+  - `environment` — default engine/dialect when a profile omits `environment=`.
+  - `[targets]` — named connection profiles, so `dbly plan --target dev` resolves to a
+    profile path.
+  - `ignore` — extra ignore patterns (gitwildmatch), merged with `.dbignore` (e.g. to skip a
+    handful of files a parser cannot read).
+
+  Absent config → unchanged behaviour (`object_root="."`, `--target` is a profile path).
+
+### Fixed
+
+- **Case-insensitive identifier matching on PostgreSQL.** Postgres folds unquoted identifiers
+  to lower case, so a DDL `CREATE TABLE FOO` lives as `foo`. `plan` (`table_exists`/
+  `get_columns`) and `check` looked the object up by the *declared* name and either planned a
+  spurious full `CREATE` or crashed with `NoSuchTableError`. Both now resolve the object
+  case-insensitively and reflect it by its real, live identity.
+- **`check` no longer aborts on a single unreflectable table.** A table whose columns cannot
+  be introspected is reported as advisory `unreadable` and the drift scan continues, instead
+  of failing the whole run.
+
 ## [0.3.0] — 2026-07-21
 
 ### Added

{dbly-0.3.0 → dbly-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbly
-Version: 0.3.0
+Version: 0.6.0
 Summary: State-based, cross-engine database deployment — git-driven, parser-assisted, SQL-first.
 Project-URL: Homepage, https://angrydata.info/dbly
 Project-URL: Repository, https://github.com/angrydat/dbly
@@ -93,6 +93,27 @@ changes the diff can't do safely (renaming a column, moving data), drop an order
 it touches defers to it for that deploy. On a fresh database, migrations are *baselined*
 (recorded, not run) since the object files already describe the end state.
 
+## Project configuration (optional)
+
+For anything beyond the defaults, drop a `dbly.toml` at the repo root. It's optional — without
+it, `--target` is a profile path and the schema is the first folder segment.
+
+```toml
+object_root = "pgsql/schema"     # objects live here; schema = first segment BELOW this root
+environment = "postgres"         # default engine when a profile omits environment=
+ignore = ["**/*_1252.sql"]       # extra ignore patterns, merged with .dbignore
+
+[targets]                        # dbly plan --target dev  →  resolves to the profile path
+dev  = "conn/dev.properties"
+beta = "conn/beta.properties"
+prod = "conn/prod.properties"
+```
+
+`object_root` is the key that lets dbly sit on an existing repo whose objects live deeper than
+the top level (e.g. `pgsql/schema/<schema>/<object>`): the schema is derived *relative to the
+root*, so `pgsql/schema/sales/customer.tbl` maps to schema `sales`, not `pgsql`. Put root-level
+keys (`object_root`, `environment`, `ignore`) **before** the `[targets]` table (TOML rule).
+
 ## Connect
 
 A connection profile (reuses the familiar `connection.properties` format):
@@ -125,8 +146,17 @@ dbly check  --target prod.connection.properties
 
 # greenfield only: run privileged groundwork once under a superuser profile
 dbly init   --init-target super.connection.properties
+
+# reverse: export a live database as a DDL script — optionally in another engine's dialect
+dbly export --target prod.connection.properties
+dbly export --target prod.connection.properties --dialect postgres --out schema.sql
 ```
 
+`export` is the inverse of deploy: tables and views transpile across dialects; procedural
+objects (functions, procedures, triggers) are emitted verbatim in the source dialect. Scope it
+with `--schema`. `plan`, `apply` and `check` likewise take `--schema NAME` / `--path SUBPATH`
+to work on part of the repo (e.g. deploy only `bas/`).
+
 **Typical workflow:** edit your object files → commit → `dbly plan` to review → `dbly apply`.
 
 Deploying a *subset* of features is just choosing the git ref you deploy (a release tag or

{dbly-0.3.0 → dbly-0.6.0}/README.md

@@ -54,6 +54,27 @@ changes the diff can't do safely (renaming a column, moving data), drop an order
 it touches defers to it for that deploy. On a fresh database, migrations are *baselined*
 (recorded, not run) since the object files already describe the end state.
 
+## Project configuration (optional)
+
+For anything beyond the defaults, drop a `dbly.toml` at the repo root. It's optional — without
+it, `--target` is a profile path and the schema is the first folder segment.
+
+```toml
+object_root = "pgsql/schema"     # objects live here; schema = first segment BELOW this root
+environment = "postgres"         # default engine when a profile omits environment=
+ignore = ["**/*_1252.sql"]       # extra ignore patterns, merged with .dbignore
+
+[targets]                        # dbly plan --target dev  →  resolves to the profile path
+dev  = "conn/dev.properties"
+beta = "conn/beta.properties"
+prod = "conn/prod.properties"
+```
+
+`object_root` is the key that lets dbly sit on an existing repo whose objects live deeper than
+the top level (e.g. `pgsql/schema/<schema>/<object>`): the schema is derived *relative to the
+root*, so `pgsql/schema/sales/customer.tbl` maps to schema `sales`, not `pgsql`. Put root-level
+keys (`object_root`, `environment`, `ignore`) **before** the `[targets]` table (TOML rule).
+
 ## Connect
 
 A connection profile (reuses the familiar `connection.properties` format):
@@ -86,8 +107,17 @@ dbly check  --target prod.connection.properties
 
 # greenfield only: run privileged groundwork once under a superuser profile
 dbly init   --init-target super.connection.properties
+
+# reverse: export a live database as a DDL script — optionally in another engine's dialect
+dbly export --target prod.connection.properties
+dbly export --target prod.connection.properties --dialect postgres --out schema.sql
 ```
 
+`export` is the inverse of deploy: tables and views transpile across dialects; procedural
+objects (functions, procedures, triggers) are emitted verbatim in the source dialect. Scope it
+with `--schema`. `plan`, `apply` and `check` likewise take `--schema NAME` / `--path SUBPATH`
+to work on part of the repo (e.g. deploy only `bas/`).
+
 **Typical workflow:** edit your object files → commit → `dbly plan` to review → `dbly apply`.
 
 Deploying a *subset* of features is just choosing the git ref you deploy (a release tag or

{dbly-0.3.0 → dbly-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dbly"
-version = "0.3.0"
+version = "0.6.0"
 description = "State-based, cross-engine database deployment — git-driven, parser-assisted, SQL-first."
 readme = "README.md"
 license = { text = "MIT" }

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/__init__.py

@@ -4,4 +4,4 @@ git (what changed) + sqlglot (what it is) + live introspection (what's really th
 See CONCEPT.md for the design rationale.
 """
 
-__version__ = "0.3.0"
+__version__ = "0.6.0"

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/adapters/mssql.py

@@ -106,7 +106,8 @@ class MssqlAdapter(Adapter):
                 if kind is None:
                     continue
                 h = canonical_hash(src, dialect="tsql") if kind in hashed else None
-                obj = LiveObject(kind, ObjectId(schema, name), h)
+                # OBJECT_DEFINITION is NULL for tables (their DDL is rebuilt from columns).
+                obj = LiveObject(kind, ObjectId(schema, name), h, src)
                 found[obj.key()] = obj
             for schema, name in conn.execute(idx):
                 obj = LiveObject(ObjectKind.INDEX, ObjectId(schema, name))

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/adapters/oracle.py

@@ -155,6 +155,7 @@ class OracleAdapter(Adapter):
             "('FUNCTION','PROCEDURE','TRIGGER','PACKAGE','PACKAGE BODY','TYPE') "
             "ORDER BY name, type, line"
         )
+        views = text("SELECT view_name, text FROM all_views WHERE owner = USER")
         owner = self.default_schema  # objects are filtered by owner = USER — carry it on the id
         found: dict[str, LiveObject] = {}
         src_text: dict[str, list[str]] = {}
@@ -171,9 +172,16 @@ class OracleAdapter(Adapter):
                     continue
                 key = LiveObject(kind, ObjectId(owner, name)).key()
                 src_text.setdefault(key, []).append(line or "")
+            for name, vtext in conn.execute(views):
+                key = LiveObject(ObjectKind.VIEW, ObjectId(owner, name)).key()
+                if key in found and vtext is not None:
+                    found[key].definition = f"CREATE VIEW {owner}.{name} AS\n{vtext}"
         for key, lines in src_text.items():
             if key in found:
-                found[key].source_hash = canonical_hash("".join(lines), dialect="oracle")
+                body = "".join(lines)
+                found[key].source_hash = canonical_hash(body, dialect="oracle")
+                # all_source starts at "FUNCTION foo…"/"PROCEDURE…"; prefix CREATE OR REPLACE.
+                found[key].definition = "CREATE OR REPLACE " + body.lstrip()
         return list(found.values())
 
     def add_column_sql(self, table: ObjectId, col: Column) -> str:

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/adapters/postgres.py

@@ -26,13 +26,49 @@ class PostgresAdapter(Adapter):
     transactional_ddl = True
     default_schema = "public"
 
+    def _resolve(self, schema: str | None, name: str) -> tuple[str, str] | None:
+        """Find a relation case-insensitively, returning its real (schema, name).
+
+        Postgres folds unquoted identifiers to lower case, so a DDL ``CREATE TABLE FOO`` lives
+        as ``foo``; the desired name (as written) need not match verbatim. Exact matches are
+        preferred over case-folded ones when both exist.
+        """
+        params = {"n": name}
+        schema_pred = ""
+        if schema is not None:
+            schema_pred = "AND lower(n.nspname) = lower(:s) "
+            params["s"] = schema
+        q = text(
+            "SELECT n.nspname, c.relname FROM pg_class c "
+            "JOIN pg_namespace n ON n.oid = c.relnamespace "
+            f"WHERE lower(c.relname) = lower(:n) {schema_pred}"
+            "AND c.relkind IN ('r','p','v','m') "
+            "ORDER BY (c.relname = :n) DESC LIMIT 1"
+        )
+        with self.engine.connect() as conn:
+            row = conn.execute(q, params).first()
+        return (row[0], row[1]) if row else None
+
     def table_exists(self, schema: str | None, name: str) -> bool:
-        insp = inspect(self.engine)
-        return insp.has_table(name, schema=schema)
+        params = {"n": name}
+        schema_pred = ""
+        if schema is not None:
+            schema_pred = "AND lower(n.nspname) = lower(:s) "
+            params["s"] = schema
+        with self.engine.connect() as conn:
+            return conn.execute(
+                text(
+                    "SELECT 1 FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace "
+                    f"WHERE lower(c.relname) = lower(:n) {schema_pred}"
+                    "AND c.relkind IN ('r','p') LIMIT 1"
+                ),
+                params,
+            ).first() is not None
 
     def get_columns(self, schema: str | None, name: str) -> list[Column]:
         insp = inspect(self.engine)
-        cols = insp.get_columns(name, schema=schema)
+        rs, rn = self._resolve(schema, name) or (schema, name)
+        cols = insp.get_columns(rn, schema=rs)
         return [
             Column(
                 name=c["name"],
@@ -90,16 +126,19 @@ class PostgresAdapter(Adapter):
                 kind = self._RELKIND.get(relkind)
                 if kind is None:
                     continue
-                h = canonical_hash(src, dialect="postgres") if kind is ObjectKind.VIEW else None
-                obj = LiveObject(kind, ObjectId(schema, name), h)
+                is_view = kind is ObjectKind.VIEW
+                h = canonical_hash(src, dialect="postgres") if is_view else None
+                defn = f"CREATE VIEW {schema}.{name} AS\n{src}" if is_view and src else None
+                obj = LiveObject(kind, ObjectId(schema, name), h, defn)
                 found[obj.key()] = obj
             for schema, name, prokind, src in conn.execute(routines):
                 kind = ObjectKind.PROCEDURE if prokind == "p" else ObjectKind.FUNCTION
-                obj = LiveObject(kind, ObjectId(schema, name), canonical_hash(src, dialect="postgres"))
+                obj = LiveObject(kind, ObjectId(schema, name),
+                                 canonical_hash(src, dialect="postgres"), src)
                 found[obj.key()] = obj
             for schema, name, src in conn.execute(triggers):
                 obj = LiveObject(ObjectKind.TRIGGER, ObjectId(schema, name),
-                                 canonical_hash(src, dialect="postgres"))
+                                 canonical_hash(src, dialect="postgres"), src)
                 found[obj.key()] = obj
         return list(found.values())
 

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/adapters/sqlite.py

@@ -67,7 +67,7 @@ class SqliteAdapter(Adapter):
                     continue
                 h = (canonical_hash(sql, dialect="sqlite")
                      if kind in (ObjectKind.VIEW, ObjectKind.TRIGGER) else None)
-                obj = LiveObject(kind, ObjectId(None, name), h)
+                obj = LiveObject(kind, ObjectId(None, name), h, sql)  # sqlite_master.sql = full DDL
                 out[obj.key()] = obj
         return list(out.values())
 

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/cli.py

@@ -8,19 +8,22 @@
 """
 from __future__ import annotations
 
+import logging
+import warnings
 from pathlib import Path
 from typing import Optional
 
 import typer
 from rich.console import Console
 
-from dbly import __version__, drift, hooks, initializer, report
+from dbly import __version__, drift, export as export_mod, hooks, initializer, report
 from dbly.adapters import get_adapter
-from dbly.config import resolve_target
+from dbly.config import ConnectionConfig, load_profile, resolve_target
 from dbly.engine import detect_dialect
 from dbly.parsing import sqlglot_dialect
 from dbly.planner import build_plan
 from dbly.model import Plan, Severity
+from dbly.project import ProjectConfig, load_project
 from dbly.repo import WORKTREE, Repo
 
 app = typer.Typer(
@@ -39,13 +42,67 @@ def _version(value: bool) -> None:
         raise typer.Exit()
 
 
+def _quiet_parser_noise(debug: bool) -> None:
+    """Silence third-party parser/introspection chatter unless --debug.
+
+    sqlglot logs a WARNING (echoing the statement) every time it can't fully parse procedural
+    or engine-specific DDL and falls back to a raw command — expected and harmless for dbly,
+    but it floods real repos. SQLAlchemy likewise warns on types it doesn't model (e.g. PostGIS
+    ``geometry``), which dbly doesn't need for column identity.
+    """
+    if debug:
+        logging.getLogger("sqlglot").setLevel(logging.DEBUG)
+        return
+    logging.getLogger("sqlglot").setLevel(logging.ERROR)
+    warnings.filterwarnings("ignore", message="Did not recognize type")
+
+
 @app.callback()
 def _main(
     version: bool = typer.Option(  # noqa: ARG001
         False, "--version", callback=_version, is_eager=True, help="Show version and exit."
     ),
+    debug: bool = typer.Option(
+        False, "--debug", help="show parser/introspection diagnostics (sqlglot, SQLAlchemy)."
+    ),
 ) -> None:
-    pass
+    _quiet_parser_noise(debug)
+
+
+def _open_repo(
+    repo_path: Path, project: ProjectConfig,
+    *, schemas: Optional[list[str]] = None, paths: Optional[list[str]] = None,
+) -> Repo:
+    return Repo(
+        repo_path,
+        object_root=project.object_root,
+        extra_ignore=project.ignore,
+        select_schemas=schemas or None,
+        select_paths=paths or None,
+    )
+
+
+def _scope_label(schemas: Optional[list[str]], paths: Optional[list[str]]) -> Optional[str]:
+    bits = []
+    if schemas:
+        bits.append("schema=" + ",".join(schemas))
+    if paths:
+        bits.append("path=" + ",".join(paths))
+    return " ".join(bits) or None
+
+
+def _resolve_target(project: ProjectConfig, repo_path: Path, target: str) -> ConnectionConfig:
+    """Resolve ``--target``: a named target from ``dbly.toml`` [targets], else a profile path.
+
+    The project's ``environment`` fills in when the profile omits ``environment=``.
+    """
+    if target in project.targets:
+        cfg = load_profile(repo_path / project.targets[target])
+    else:
+        cfg = resolve_target(target)
+    if cfg.environment is None and project.environment:
+        cfg.environment = project.environment
+    return cfg
 
 
 def _decorations(repo_path: Path, plan: Plan) -> dict[str, str]:
@@ -67,9 +124,11 @@ def _decorations(repo_path: Path, plan: Plan) -> dict[str, str]:
 def _make_plan(
     repo_path: Path, target: str, from_ref: Optional[str], to_ref: str,
     *, worktree: bool = False,
+    schemas: Optional[list[str]] = None, paths: Optional[list[str]] = None,
 ) -> Plan:
-    repo = Repo(repo_path)
-    cfg = resolve_target(target)
+    project = load_project(repo_path)
+    repo = _open_repo(repo_path, project, schemas=schemas, paths=paths)
+    cfg = _resolve_target(project, repo_path, target)
     dialect = sqlglot_dialect(detect_dialect(cfg))
     adapter = get_adapter(cfg)
     try:
@@ -104,16 +163,23 @@ def plan(
         help="plan against the working tree (uncommitted + untracked object files), "
              "not a git ref — for the fast edit→plan loop.",
     ),
+    schema: Optional[list[str]] = typer.Option(
+        None, "--schema", help="limit to these schemas (folder under object_root); repeatable."
+    ),
+    path: Optional[list[str]] = typer.Option(
+        None, "--path", help="limit to this subpath under object_root; repeatable."
+    ),
 ) -> None:
     """Compute and show the deployment plan."""
-    plan_obj = _make_plan(repo_path, target, from_ref, to, worktree=worktree)
+    plan_obj = _make_plan(repo_path, target, from_ref, to, worktree=worktree,
+                          schemas=schema, paths=path)
     report.render_plan(plan_obj, console, ref_names=_decorations(repo_path, plan_obj))
     if out:
         out.write_text(report.plan_to_yaml(plan_obj), encoding="utf-8")
         console.print(f"\n[dim]plan (YAML) written to {out}[/dim]")
     if sql:
         # state_table_ddl / record_deploy_sql are pure string builders — no DB connection.
-        adapter = get_adapter(resolve_target(target))
+        adapter = get_adapter(_resolve_target(load_project(repo_path), repo_path, target))
         try:
             script = report.plan_to_sql(
                 plan_obj,
@@ -139,13 +205,19 @@ def apply(
     py_interpreter: str = typer.Option(
         "python", "--py-interpreter", help="interpreter for .py hooks (e.g. ArcGIS propy)."
     ),
+    schema: Optional[list[str]] = typer.Option(
+        None, "--schema", help="limit to these schemas (folder under object_root); repeatable."
+    ),
+    path: Optional[list[str]] = typer.Option(
+        None, "--path", help="limit to this subpath under object_root; repeatable."
+    ),
 ) -> None:
     """Apply a plan to the target database (re-computes one unless a file is given)."""
     if plan_file is not None:
         plan_obj = report.plan_from_yaml(plan_file.read_text(encoding="utf-8"))
         target = plan_obj.target
     else:
-        plan_obj = _make_plan(repo_path, target, from_ref, to)
+        plan_obj = _make_plan(repo_path, target, from_ref, to, schemas=schema, paths=path)
 
     report.render_plan(plan_obj, console, ref_names=_decorations(repo_path, plan_obj))
 
@@ -165,8 +237,9 @@ def apply(
         console.print("[green]nothing to apply.[/green]")
         return
 
-    repo = Repo(repo_path)
-    cfg = resolve_target(target)
+    project = load_project(repo_path)
+    repo = _open_repo(repo_path, project)
+    cfg = _resolve_target(project, repo_path, target)
     adapter = get_adapter(cfg)
     try:
         _run_hooks(repo, "pre", py_interpreter)
@@ -204,12 +277,13 @@ def init(
 
     Greenfield only — brownfield (a handed-over database) skips this entirely.
     """
-    repo = Repo(repo_path)
+    project = load_project(repo_path)
+    repo = _open_repo(repo_path, project)
     scripts = initializer.discover_init_scripts(repo.root, init_dir)
     if not scripts:
         console.print(f"[yellow]no init scripts in {init_dir}/ — nothing to do.[/yellow]")
         return
-    adapter = get_adapter(resolve_target(init_target))
+    adapter = get_adapter(_resolve_target(project, repo_path, init_target))
     try:
         for s in scripts:
             adapter.run_init_script(s.read_text(encoding="utf-8"))
@@ -268,37 +342,78 @@ def check(
         False, "--worktree", "--dirty",
         help="compare the working tree (uncommitted + untracked) against the DB, not a git ref.",
     ),
+    schema: Optional[list[str]] = typer.Option(
+        None, "--schema", help="limit to these schemas (folder under object_root); repeatable."
+    ),
+    path: Optional[list[str]] = typer.Option(
+        None, "--path", help="limit to this subpath under object_root; repeatable."
+    ),
 ) -> None:
     """Detect drift: compare the desired state at <to> against the live database."""
-    repo = Repo(repo_path)
-    cfg = resolve_target(target)
+    project = load_project(repo_path)
+    repo = _open_repo(repo_path, project, schemas=schema, paths=path)
+    cfg = _resolve_target(project, repo_path, target)
     dialect = sqlglot_dialect(detect_dialect(cfg))
+    resolved_to = repo.resolve_ref(WORKTREE if worktree else to)
     adapter = get_adapter(cfg)
     try:
         rep = drift.compute_drift(
-            repo, adapter,
-            to_ref=repo.resolve_ref(WORKTREE if worktree else to),
-            dialect=dialect, include_orphans=orphans,
+            repo, adapter, to_ref=resolved_to, dialect=dialect, include_orphans=orphans,
         )
     finally:
         adapter.dispose()
 
-    if rep.clean:
-        console.print("[green]no drift — database matches the desired state.[/green]")
-        return
+    report.render_drift(
+        rep, console, target=target, ref=resolved_to,
+        ref_names=_decorations(repo_path, Plan(target=target, from_ref=None, to_ref=resolved_to)),
+        scope=_scope_label(schema, path),
+    )
+    if not rep.clean:
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def export(
+    target: str = typer.Option(..., "--target", help="connection profile or named target."),
+    dialect: Optional[str] = typer.Option(
+        None, "--dialect",
+        help="transpile to another engine (postgres|oracle|sqlserver|sqlite). "
+             "Default: keep the source engine's dialect.",
+    ),
+    out: Optional[Path] = typer.Option(None, "--out", help="write the DDL script to a file."),
+    schema: Optional[list[str]] = typer.Option(
+        None, "--schema", help="limit to these live schemas; repeatable."
+    ),
+    repo_path: Path = typer.Option(Path("."), "--repo", help="repo root (for dbly.toml targets)."),
+) -> None:
+    """Export a live database as a DDL script — the reverse of deploy, optionally cross-dialect.
 
-    for kind, oid in rep.missing:
-        console.print(f"[yellow]missing[/yellow]   {kind.value} {oid}  (in repo, not in DB)")
-    for cd in rep.columns:
-        if cd.added:
-            console.print(f"[yellow]columns[/yellow]   {cd.table}  to add: {', '.join(cd.added)}")
-        if cd.removed:
-            console.print(f"[red]columns[/red]   {cd.table}  only in DB: {', '.join(cd.removed)}")
-    for kind, oid in rep.definitions:
-        console.print(f"[yellow]changed[/yellow]   {kind.value} {oid}  (definition differs — advisory)")
-    for kind, oid in rep.orphaned:
-        console.print(f"[dim]orphaned[/dim]  {kind.value} {oid}  (in DB, not in repo)")
-    raise typer.Exit(code=1)
+    Tables/views transpile across dialects; procedural objects are emitted verbatim.
+    """
+    project = load_project(repo_path)
+    cfg = _resolve_target(project, repo_path, target)
+    source_dialect = sqlglot_dialect(detect_dialect(cfg))
+    target_dialect = sqlglot_dialect(dialect) if dialect else None
+    if dialect and target_dialect is None:
+        err.print(f"[red]unknown --dialect {dialect!r}[/red] (postgres|oracle|sqlserver|sqlite)")
+        raise typer.Exit(code=2)
+
+    adapter = get_adapter(cfg)
+    try:
+        result = export_mod.export_ddl(
+            adapter, source_dialect=source_dialect,
+            target_dialect=target_dialect, schemas=schema or None,
+        )
+    finally:
+        adapter.dispose()
+
+    if out:
+        out.write_text(result.ddl, encoding="utf-8")
+        console.print(f"[green]exported[/green] {result.object_count} object(s) → {out}")
+    else:
+        console.print(result.ddl)
+    for w in result.warnings:
+        err.print(f"[yellow]![/yellow] {w}")
 
 
 def _run_hooks(repo: Repo, phase: str, py_interpreter: str) -> None:

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/drift.py

@@ -36,6 +36,7 @@ class DriftReport:
     orphaned: list[tuple[ObjectKind, ObjectId]] = field(default_factory=list)
     columns: list[ColumnDrift] = field(default_factory=list)
     definitions: list[tuple[ObjectKind, ObjectId]] = field(default_factory=list)
+    unreadable: list[tuple[ObjectKind, ObjectId]] = field(default_factory=list)  # reflection failed (advisory)
 
     @property
     def clean(self) -> bool:
@@ -77,13 +78,25 @@ def compute_drift(
             report.missing.append((obj.kind, obj.id))
 
     if include_orphans:
+        sel = repo.select_schemas  # scope orphans to the same subset as desired discovery
         for key, o in live.items():
-            if key not in desired:
-                report.orphaned.append((o.kind, o.id))
+            if key in desired:
+                continue
+            if sel is not None and (o.id.schema is None or o.id.schema.lower() not in sel):
+                continue
+            report.orphaned.append((o.kind, o.id))
 
     for key, obj in desired.items():
         if obj.kind is ObjectKind.TABLE and key in live:
-            actual = {c.key() for c in adapter.get_columns(obj.id.schema, obj.id.name)}
+            # Reflect columns by the LIVE object's identity — the engine may have folded the
+            # declared name's case (unquoted `FOO` → `foo` on Postgres), so the desired name
+            # need not exist verbatim. A table that cannot be reflected is skipped, not fatal.
+            live_id = live[key].id
+            try:
+                actual = {c.key() for c in adapter.get_columns(live_id.schema, live_id.name)}
+            except Exception:  # noqa: BLE001 — one odd table must not abort the whole check
+                report.unreadable.append((obj.kind, obj.id))
+                continue
             want = {c.key() for c in parsing.desired_columns(obj.sql, dialect=dialect)}
             added, removed = sorted(want - actual), sorted(actual - want)
             if added or removed:

dbly-0.6.0/src/dbly/export.py

@@ -0,0 +1,127 @@
+"""Reverse direction — introspect a live database and emit its DDL (``dbly export``).
+
+The inverse of the deploy path: read what actually exists and render it as a SQL script,
+optionally transpiled to another engine's dialect. Honest scope (CONCEPT.md §10):
+
+* **tables / views** are *structural* — sqlglot transpiles them across dialects reliably.
+  Tables are rebuilt from the live column set (name, type, nullability, default); constraints
+  and indexes are **not** reconstructed (a warning says so).
+* **functions / procedures / triggers / packages / types** carry procedural bodies sqlglot
+  cannot transpile. They are emitted **verbatim** in the source dialect; requesting a
+  different target dialect keeps them as-is and adds a warning.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import sqlglot
+
+from dbly.adapters.base import Adapter
+from dbly.model import LiveObject, ObjectId, ObjectKind
+
+# emit order: providers before dependants (best-effort; FK ordering between tables is not solved)
+_ORDER = {
+    ObjectKind.SEQUENCE: 0, ObjectKind.TYPE: 1, ObjectKind.TABLE: 2, ObjectKind.INDEX: 3,
+    ObjectKind.VIEW: 4, ObjectKind.FUNCTION: 5, ObjectKind.PROCEDURE: 6,
+    ObjectKind.PACKAGE: 7, ObjectKind.TRIGGER: 8, ObjectKind.GRANT: 9, ObjectKind.UNKNOWN: 10,
+}
+_STRUCTURAL = {ObjectKind.TABLE, ObjectKind.VIEW}
+_PROCEDURAL = {
+    ObjectKind.FUNCTION, ObjectKind.PROCEDURE, ObjectKind.TRIGGER,
+    ObjectKind.PACKAGE, ObjectKind.TYPE,
+}
+
+
+@dataclass(slots=True)
+class ExportResult:
+    ddl: str
+    warnings: list[str] = field(default_factory=list)
+    object_count: int = 0
+
+
+def _create_table_sql(adapter: Adapter, oid: ObjectId, dialect: str | None) -> str:
+    cols = adapter.get_columns(oid.schema, oid.name)
+    lines = []
+    for c in cols:
+        piece = f"  {c.name} {c.type}"
+        if c.default is not None:
+            piece += f" DEFAULT {c.default}"
+        if not c.nullable:
+            piece += " NOT NULL"
+        lines.append(piece)
+    body = ",\n".join(lines)
+    return f"CREATE TABLE {oid} (\n{body}\n);"
+
+
+def _transpile(sql: str, *, read: str | None, write: str | None) -> str:
+    """Transpile one statement; on any failure the caller keeps the verbatim source."""
+    out = sqlglot.transpile(sql, read=read, write=write)
+    return ";\n".join(s.rstrip(";") for s in out) + ";"
+
+
+def export_ddl(
+    adapter: Adapter,
+    *,
+    source_dialect: str | None,
+    target_dialect: str | None = None,
+    schemas: list[str] | None = None,
+) -> ExportResult:
+    """Render the live database as a DDL script (optionally transpiled to ``target_dialect``)."""
+    sel = {s.lower() for s in schemas} if schemas else None
+    live: list[LiveObject] = [
+        o for o in adapter.inventory()
+        if o.key() != "table:dbly_state"                       # never export dbly's own ledger
+        and (sel is None or (o.id.schema and o.id.schema.lower() in sel))
+    ]
+    live.sort(key=lambda o: (_ORDER.get(o.kind, 99), str(o.id).lower()))
+
+    cross = bool(target_dialect and target_dialect != source_dialect)
+    warnings: list[str] = []
+    if cross:
+        warnings.append(
+            f"transpiling {source_dialect} → {target_dialect}: tables/views are converted; "
+            "procedural objects (function/procedure/trigger/package/type) are emitted verbatim"
+        )
+    warned_table = False
+
+    parts: list[str] = [
+        "-- dbly export — DDL reconstructed from a live database. Review before running.",
+        f"-- source dialect: {source_dialect or '?'}"
+        + (f"   target dialect: {target_dialect}" if cross else ""),
+        "",
+    ]
+    count = 0
+    for o in live:
+        if o.kind is ObjectKind.TABLE:
+            if o.definition:                        # engine gave us the real DDL (e.g. SQLite)
+                raw = o.definition.rstrip().rstrip(";") + ";"
+            else:                                   # rebuilt from columns — flag the limits once
+                if not warned_table:
+                    warnings.append(
+                        "tables are rebuilt from columns only — primary keys, foreign keys, "
+                        "checks and indexes are not reconstructed"
+                    )
+                    warned_table = True
+                raw = _create_table_sql(adapter, o.id, source_dialect)
+        elif o.definition:
+            raw = o.definition.rstrip().rstrip(";") + ";"
+        else:
+            warnings.append(f"{o.kind.value} {o.id}: no definition available — skipped")
+            continue
+
+        sql = raw
+        if cross:
+            if o.kind in _STRUCTURAL:
+                try:
+                    sql = _transpile(raw, read=source_dialect, write=target_dialect)
+                except Exception as exc:  # noqa: BLE001 — fall back to verbatim, flag it
+                    warnings.append(f"{o.kind.value} {o.id}: could not transpile ({exc}); verbatim")
+            elif o.kind in _PROCEDURAL:
+                warnings.append(f"{o.kind.value} {o.id}: emitted verbatim ({source_dialect})")
+
+        parts.append(f"-- {o.kind.value} {o.id}")
+        parts.append(sql)
+        parts.append("")
+        count += 1
+
+    return ExportResult(ddl="\n".join(parts), warnings=warnings, object_count=count)

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/model.py

@@ -94,11 +94,14 @@ class LiveObject:
 
     ``source_hash`` is a canonicalized hash of the definition for procedural/definitional
     objects (views, functions, procedures, triggers) — used for advisory drift detection.
+    ``definition`` is the raw DDL/source as the engine reports it (``None`` for plain tables,
+    whose DDL is reconstructed from columns) — used by ``dbly export``.
     """
 
     kind: ObjectKind
     id: ObjectId
     source_hash: str | None = None
+    definition: str | None = None
 
     def key(self) -> str:
         return f"{self.kind.value}:{self.id.key()}"

dbly-0.6.0/src/dbly/project.py

@@ -0,0 +1,54 @@
+"""Project configuration — an optional ``dbly.toml`` at the repository root.
+
+The flag-driven workflow (``--target <profile>`` + ``.dbignore``) stays the default; a
+``dbly.toml`` adds the terraform-style project setup a real repo needs:
+
+* **object_root** — the subtree the declarative object files live under. The schema hint is the
+  first path segment *below* this root, so a repo laid out as ``pgsql/schema/<schema>/<obj>``
+  maps to the right schema instead of the literal top folder.
+* **environment** — the default engine/dialect when a profile omits ``environment=``.
+* **[targets]** — named connection profiles, so ``dbly plan --target dev`` resolves to a
+  profile path instead of spelling it out each time.
+* **ignore** — extra ignore patterns (gitwildmatch), merged with ``.dbignore`` — e.g. to
+  exclude a handful of files a parser cannot read.
+
+Absent config → :class:`ProjectConfig` defaults (``object_root="."``, no named targets), i.e.
+the previous behaviour unchanged.
+"""
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+CONFIG_NAME = "dbly.toml"
+
+
+@dataclass(slots=True)
+class ProjectConfig:
+    object_root: str = "."
+    environment: str | None = None
+    targets: dict[str, str] = field(default_factory=dict)
+    ignore: list[str] = field(default_factory=list)
+
+
+def load_project(repo_root: Path) -> ProjectConfig:
+    """Load ``<repo_root>/dbly.toml`` if present, else return defaults."""
+    path = repo_root / CONFIG_NAME
+    if not path.exists():
+        return ProjectConfig()
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+
+    targets = data.get("targets") or {}
+    if not isinstance(targets, dict):
+        raise ValueError(f"{CONFIG_NAME}: [targets] must be a table of name = \"profile-path\"")
+    ignore = data.get("ignore") or []
+    if not isinstance(ignore, list):
+        raise ValueError(f"{CONFIG_NAME}: ignore must be a list of patterns")
+
+    return ProjectConfig(
+        object_root=str(data.get("object_root", ".")),
+        environment=data.get("environment"),
+        targets={str(k): str(v) for k, v in targets.items()},
+        ignore=[str(p) for p in ignore],
+    )

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/repo.py

@@ -27,11 +27,26 @@ class FileChange:
 
 
 class Repo:
-    def __init__(self, root: Path):
+    def __init__(
+        self,
+        root: Path,
+        *,
+        object_root: str | None = None,
+        extra_ignore: list[str] | None = None,
+        select_schemas: list[str] | None = None,
+        select_paths: list[str] | None = None,
+    ):
         self.root = root.resolve()
         if not (self.root / ".git").exists():
             raise ValueError(f"not a git repository: {self.root}")
-        self._ignore = self._load_dbignore()
+        # the subtree object files live under; the schema hint is the first segment *below* it.
+        self.object_root = (
+            Path(object_root) if object_root and object_root not in (".", "") else None
+        )
+        # optional subset selection (deploy/check only part of the tree)
+        self.select_schemas = {s.lower() for s in select_schemas} if select_schemas else None
+        self.select_paths = [Path(p) for p in select_paths] if select_paths else None
+        self._ignore = self._load_dbignore(extra_ignore or [])
 
     def _git(self, *args: str) -> str:
         out = subprocess.run(
@@ -42,10 +57,10 @@ class Repo:
         )
         return out.stdout
 
-    def _load_dbignore(self) -> pathspec.PathSpec:
+    def _load_dbignore(self, extra: list[str]) -> pathspec.PathSpec:
         f = self.root / ".dbignore"
         lines = f.read_text(encoding="utf-8").splitlines() if f.exists() else []
-        return pathspec.PathSpec.from_lines("gitwildmatch", lines)
+        return pathspec.PathSpec.from_lines("gitwildmatch", [*lines, *extra])
 
     def is_ignored(self, rel: Path) -> bool:
         return self._ignore.match_file(rel.as_posix())
@@ -58,9 +73,33 @@ class Repo:
     def _is_migration(rel: Path) -> bool:
         return len(rel.parts) > 0 and rel.parts[0] == MIGRATIONS_DIR
 
+    def _under_object_root(self, rel: Path) -> bool:
+        if self.object_root is None:
+            return True
+        return rel == self.object_root or self.object_root in rel.parents
+
+    def _selected(self, rel: Path) -> bool:
+        """Honour an optional subset selection (``--schema`` / ``--path``). Both AND together."""
+        if self.select_paths is not None:
+            base = self.object_root or Path()
+            prefixes = [base / p for p in self.select_paths]
+            if not any(rel == pre or pre in rel.parents for pre in prefixes):
+                return False
+        if self.select_schemas is not None:
+            sch = self.schema_for(rel)
+            if sch is None or sch.lower() not in self.select_schemas:
+                return False
+        return True
+
     def _is_object(self, rel: Path) -> bool:
-        """A deployable declarative object file (SQL, not a migration, not ignored)."""
-        return self._is_sql(rel) and not self._is_migration(rel) and not self.is_ignored(rel)
+        """A deployable declarative object file (SQL, under object_root, selected, not ignored)."""
+        return (
+            self._is_sql(rel)
+            and not self._is_migration(rel)
+            and self._under_object_root(rel)
+            and self._selected(rel)
+            and not self.is_ignored(rel)
+        )
 
     def _untracked_files(self) -> list[Path]:
         """New files in the working tree not yet added to git (``git status`` "??")."""
@@ -169,8 +208,16 @@ class Repo:
     def schema_for(self, rel: Path) -> str | None:
         """Best-practice convention: the first path segment names the DB schema.
 
-        Only a *hint* — the parser overrides it when the DDL is schema-qualified.
-        Returns None when the file sits at the repo root.
+        With an ``object_root`` set, the segment is taken *relative to that root* — so
+        ``pgsql/schema/bas/foo.tbl`` under root ``pgsql/schema`` yields schema ``bas``.
+        Only a *hint* — the parser overrides it when the DDL is schema-qualified. Returns
+        None when the file sits directly at the (object) root.
         """
-        parts = rel.parts
+        r = rel
+        if self.object_root is not None:
+            try:
+                r = rel.relative_to(self.object_root)
+            except ValueError:
+                return None
+        parts = r.parts
         return parts[0] if len(parts) > 1 else None

{dbly-0.3.0 → dbly-0.6.0}/src/dbly/report.py

@@ -6,6 +6,7 @@ express: ordering, severity, source provenance and warnings.
 from __future__ import annotations
 
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import yaml
 from rich.console import Console
@@ -13,6 +14,9 @@ from rich.table import Table
 
 from dbly.model import Migration, ObjectId, ObjectKind, Plan, Severity, Step
 
+if TYPE_CHECKING:
+    from dbly.drift import DriftReport
+
 
 def _decorate_ref(ref: str | None, ref_names: dict[str, str] | None) -> str:
     """Render a ref for the plan header: git-style ``<names> (<short-sha>)`` when known."""
@@ -74,6 +78,78 @@ def render_plan(
         )
 
 
+def render_drift(
+    rep: DriftReport,
+    console: Console,
+    *,
+    target: str,
+    ref: str,
+    ref_names: dict[str, str] | None = None,
+    scope: str | None = None,
+) -> None:
+    """Render a drift report with explicit direction, grouping and counts (CONCEPT.md §9).
+
+    The old output was one flat line per item and never made clear *which way* a difference
+    ran. Here each group states the direction in its heading, and column drift uses ``+`` (in
+    the repo, missing from the DB) vs. ``−`` (in the DB, not in the repo).
+    """
+    head = f"[bold]Drift[/bold] for [cyan]{target}[/cyan]  {_decorate_ref(ref, ref_names)}"
+    if scope:
+        head += f"  [dim](scope: {scope})[/dim]"
+    console.print(head)
+
+    if rep.clean and not rep.unreadable:
+        console.print("[green]✓ no drift — the database matches the desired state.[/green]")
+        return
+
+    n_add = sum(len(cd.added) for cd in rep.columns)
+    n_del = sum(len(cd.removed) for cd in rep.columns)
+    tally = [
+        f"[yellow]{len(rep.missing)}[/yellow] to create",
+        f"[red]{len(rep.orphaned)}[/red] orphaned" if rep.orphaned else None,
+        f"[yellow]{len(rep.columns)}[/yellow] tables with column drift"
+        f" ([green]+{n_add}[/green]/[red]−{n_del}[/red])" if rep.columns else None,
+        f"[yellow]{len(rep.definitions)}[/yellow] changed definitions" if rep.definitions else None,
+        f"[dim]{len(rep.unreadable)} unreadable[/dim]" if rep.unreadable else None,
+    ]
+    console.print("  " + "  ·  ".join(t for t in tally if t) + "\n")
+
+    def _section(title: str, style: str, rows: list[str]) -> None:
+        if not rows:
+            return
+        console.print(f"[{style} bold]{title}[/{style} bold]  [dim]({len(rows)})[/dim]")
+        for r in rows:
+            console.print(f"  {r}")
+        console.print()
+
+    _section(
+        "Only in the repo — will be created on apply", "yellow",
+        [f"{k.value:9} {oid}" for k, oid in rep.missing],
+    )
+    _section(
+        "Only in the database — not in the repo", "red",
+        [f"{k.value:9} {oid}" for k, oid in rep.orphaned],
+    )
+    if rep.columns:
+        console.print(f"[yellow bold]Column drift[/yellow bold]  [dim]({len(rep.columns)})[/dim]")
+        console.print("  [dim](+ in repo, missing from DB · − in DB, not in repo)[/dim]")
+        for cd in rep.columns:
+            console.print(f"  {cd.table}")
+            if cd.added:
+                console.print(f"    [green]+ {', '.join(cd.added)}[/green]")
+            if cd.removed:
+                console.print(f"    [red]− {', '.join(cd.removed)}[/red]")
+        console.print()
+    _section(
+        "Definition differs — advisory", "yellow",
+        [f"{k.value:9} {oid}" for k, oid in rep.definitions],
+    )
+    _section(
+        "Could not introspect — advisory", "dim",
+        [f"{k.value:9} {oid}" for k, oid in rep.unreadable],
+    )
+
+
 def plan_to_sql(plan: Plan, *, state_ddl: str | None = None, record_sql: str | None = None) -> str:
     """Render the plan as a single, ordered vanilla-SQL script (CONCEPT.md §7).
 

{dbly-0.3.0 → dbly-0.6.0}/tests/test_integration.py

@@ -368,3 +368,114 @@ def test_repo_ref_names_decorates_tag_and_branch(tmp_path: Path):
     names = repo.ref_names(sha)
     assert "v0.1" in names
     assert any(n in ("main", "master") for n in names)  # the current branch points here too
+
+
+def test_object_root_scopes_discovery_and_schema(tmp_path: Path):
+    """object_root: schema = first segment BELOW the root; files outside it are ignored."""
+    from dbly import parsing
+    repo_root = tmp_path / "db"
+    (repo_root / "pgsql" / "schema" / "bas").mkdir(parents=True)
+    (repo_root / "ora").mkdir(parents=True)
+    _init_repo(repo_root)
+    # unqualified CREATE (schema comes from the folder), under pgsql/schema/bas
+    (repo_root / "pgsql" / "schema" / "bas" / "kunde.tbl").write_text(
+        "CREATE TABLE IF NOT EXISTS kunde (id INTEGER, name TEXT);", encoding="utf-8"
+    )
+    # an Oracle file outside object_root must NOT be discovered
+    (repo_root / "ora" / "irrelevant.tbl").write_text(
+        "CREATE TABLE junk (id NUMBER);", encoding="utf-8"
+    )
+    _commit(repo_root, "v1")
+
+    repo = Repo(repo_root, object_root="pgsql/schema")
+    files = repo.list_files("HEAD")
+    assert files == [Path("pgsql/schema/bas/kunde.tbl")]          # ora/ excluded
+    assert repo.schema_for(files[0]) == "bas"                      # segment below object_root
+
+    # parse with that hint → object id carries the real schema, not "pgsql"
+    sql = repo.read_at("HEAD", files[0])
+    obj = parsing.parse_file(sql, files[0], default_schema=repo.schema_for(files[0]),
+                             dialect="postgres")[0]
+    assert str(obj.id) == "bas.kunde"
+
+
+def test_extra_ignore_excludes_unparseable_files(tmp_path: Path):
+    repo_root = tmp_path / "db"
+    (repo_root / "schema" / "app").mkdir(parents=True)
+    _init_repo(repo_root)
+    (repo_root / "schema" / "app" / "good.tbl").write_text(
+        "CREATE TABLE app.good (id INTEGER);", encoding="utf-8"
+    )
+    (repo_root / "schema" / "app" / "bad.vw").write_text(
+        "CREATE VIEW app.bad AS SELECT 1;", encoding="utf-8"
+    )
+    _commit(repo_root, "v1")
+
+    repo = Repo(repo_root, object_root="schema", extra_ignore=["schema/app/bad.vw"])
+    files = repo.list_files("HEAD")
+    assert Path("schema/app/good.tbl") in files
+    assert Path("schema/app/bad.vw") not in files                 # ignored via extra_ignore
+
+
+def test_select_schemas_and_paths_scope_discovery(tmp_path: Path):
+    repo_root = tmp_path / "db"
+    for sub in ("pgsql/schema/bas", "pgsql/schema/bas/domains", "pgsql/schema/gzp"):
+        (repo_root / sub).mkdir(parents=True)
+    _init_repo(repo_root)
+    (repo_root / "pgsql/schema/bas/kunde.tbl").write_text("CREATE TABLE bas.kunde (id int);", encoding="utf-8")
+    (repo_root / "pgsql/schema/bas/domains/d_typ.tbl").write_text("CREATE TABLE bas.d_typ (id int);", encoding="utf-8")
+    (repo_root / "pgsql/schema/gzp/plan.tbl").write_text("CREATE TABLE gzp.plan (id int);", encoding="utf-8")
+    _commit(repo_root, "v1")
+
+    # --schema bas → only the bas subtree (incl. bas/domains), not gzp
+    r_schema = Repo(repo_root, object_root="pgsql/schema", select_schemas=["bas"])
+    got = {p.as_posix() for p in r_schema.list_files("HEAD")}
+    assert got == {"pgsql/schema/bas/kunde.tbl", "pgsql/schema/bas/domains/d_typ.tbl"}
+
+    # --schema is case-insensitive
+    assert {p.as_posix() for p in Repo(repo_root, object_root="pgsql/schema",
+            select_schemas=["BAS"]).list_files("HEAD")} == got
+
+    # --path bas/domains → only that subpath
+    r_path = Repo(repo_root, object_root="pgsql/schema", select_paths=["bas/domains"])
+    assert {p.as_posix() for p in r_path.list_files("HEAD")} == {"pgsql/schema/bas/domains/d_typ.tbl"}
+
+    # no selection → everything under object_root
+    assert len(Repo(repo_root, object_root="pgsql/schema").list_files("HEAD")) == 3
+
+
+def test_export_roundtrip_and_cross_dialect(tmp_path: Path):
+    from dbly.export import export_ddl
+    repo_root = tmp_path / "db"
+    repo_root.mkdir()
+    _init_repo(repo_root)
+    (repo_root / "kunde.tbl").write_text(
+        "CREATE TABLE IF NOT EXISTS kunde (id INTEGER, name TEXT NOT NULL);", encoding="utf-8"
+    )
+    (repo_root / "v_kunde.vw").write_text(
+        "CREATE VIEW v_kunde AS SELECT id, name FROM kunde;", encoding="utf-8"
+    )
+    ref = _commit(repo_root, "v1")
+    db = tmp_path / "exp.db"
+    adapter = SqliteAdapter(ConnectionConfig(environment="sqlite", service=str(db)))
+    repo = Repo(repo_root)
+    adapter.apply([s.sql for s in build_plan(repo, adapter, from_ref=None, to_ref=ref,
+                   target="sqlite", dialect="sqlite").steps])
+
+    # same-dialect export: table + view present, table before view
+    res = export_ddl(adapter, source_dialect="sqlite")
+    assert res.object_count == 2
+    assert "CREATE TABLE" in res.ddl and "kunde" in res.ddl
+    assert res.ddl.index("kunde") < res.ddl.index("v_kunde")     # dependency order
+    assert "NOT NULL" in res.ddl                                  # SQLite keeps its stored DDL
+
+    # cross-dialect export to postgres: structural objects transpile, no crash
+    res_pg = export_ddl(adapter, source_dialect="sqlite", target_dialect="postgres")
+    assert res_pg.object_count == 2
+    assert "CREATE TABLE" in res_pg.ddl
+    assert any("transpiling sqlite → postgres" in w for w in res_pg.warnings)
+
+    # dbly_state ledger is never exported
+    adapter.ensure_state_table()
+    assert "dbly_state" not in export_ddl(adapter, source_dialect="sqlite").ddl
+    adapter.dispose()

{dbly-0.3.0 → dbly-0.6.0}/tests/test_parsing.py

@@ -160,3 +160,21 @@ def test_decorate_ref_git_style():
     assert report._decorate_ref("WORKTREE", None) == "working tree"
     assert report._decorate_ref("9ff5e440abc", {"9ff5e440abc": "v0.1, main"}) == "v0.1, main (9ff5e440)"
     assert report._decorate_ref("deadbeef", None) == "deadbeef"  # no names → raw sha
+
+
+def test_render_drift_shows_direction_and_counts(capsys):
+    from rich.console import Console
+    from dbly.drift import ColumnDrift, DriftReport
+    rep = DriftReport()
+    rep.missing.append((ObjectKind.TABLE, __import__("dbly.model", fromlist=["ObjectId"]).ObjectId("bas", "neu")))
+    rep.columns.append(ColumnDrift(
+        __import__("dbly.model", fromlist=["ObjectId"]).ObjectId("bas", "kunde"),
+        added=["email"], removed=["legacy"]))
+    report.render_drift(rep, Console(force_terminal=False, width=200),
+                        target="dev", ref="abc1234", scope="schema=bas")
+    out = capsys.readouterr().out
+    assert "Only in the repo" in out          # explicit direction, not just "missing"
+    assert "Column drift" in out
+    assert "+ email" in out and "− legacy" in out   # + = add to DB, − = only in DB
+    assert "1 to create" in out               # summary tally
+    assert "scope: schema=bas" in out          # scope shown in header

dbly-0.6.0/tests/test_project.py

@@ -0,0 +1,35 @@
+"""Tests for dbly.toml project configuration and object_root scoping."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from dbly.project import ProjectConfig, load_project
+
+
+def test_load_project_absent_returns_defaults(tmp_path: Path):
+    cfg = load_project(tmp_path)
+    assert cfg == ProjectConfig()
+    assert cfg.object_root == "." and cfg.targets == {} and cfg.ignore == []
+
+
+def test_load_project_parses_toml(tmp_path: Path):
+    (tmp_path / "dbly.toml").write_text(
+        """
+        object_root = "pgsql/schema"
+        environment = "postgres"
+        ignore = ["pgsql/schema/ggn/vw_bad.vw", "**/deploy-*.sql"]
+
+        [targets]
+        dev  = "test/dbly.dev.properties"
+        prod = "test/dbly.prod.properties"
+        """,
+        encoding="utf-8",
+    )
+    cfg = load_project(tmp_path)
+    assert cfg.object_root == "pgsql/schema"
+    assert cfg.environment == "postgres"
+    assert cfg.targets == {
+        "dev": "test/dbly.dev.properties",
+        "prod": "test/dbly.prod.properties",
+    }
+    assert "**/deploy-*.sql" in cfg.ignore