dbly 0.4.0__tar.gz → 0.6.0__tar.gz

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

@@ -7,6 +7,44 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbly
-Version: 0.4.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
@@ -146,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.4.0 → dbly-0.6.0}/README.md

@@ -107,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.4.0 → dbly-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dbly"
-version = "0.4.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.4.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.4.0"
+__version__ = "0.6.0"

{dbly-0.4.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.4.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.4.0 → dbly-0.6.0}/src/dbly/adapters/postgres.py

@@ -126,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.4.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.4.0 → dbly-0.6.0}/src/dbly/cli.py

@@ -8,13 +8,15 @@
 """
 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 ConnectionConfig, load_profile, resolve_target
 from dbly.engine import detect_dialect
@@ -40,17 +42,53 @@ 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 _open_repo(repo_path: Path, project: ProjectConfig) -> Repo:
-    return Repo(repo_path, object_root=project.object_root, extra_ignore=project.ignore)
+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:
@@ -86,9 +124,10 @@ 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:
     project = load_project(repo_path)
-    repo = _open_repo(repo_path, project)
+    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)
@@ -124,9 +163,16 @@ 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")
@@ -159,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))
 
@@ -290,43 +342,80 @@ 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."""
     project = load_project(repo_path)
-    repo = _open_repo(repo_path, project)
+    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 and not rep.unreadable:
-        console.print("[green]no drift — database matches the desired state.[/green]")
-        return
-
-    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)")
-    for kind, oid in rep.unreadable:
-        console.print(f"[dim]unreadable[/dim] {kind.value} {oid}  (columns could not be reflected — advisory)")
+    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.
+
+    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:
     for hook in hooks.discover_hooks(repo.root, phase):
         if hook.suffix.lower() == ".py":

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

@@ -78,9 +78,13 @@ 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:

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.4.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.4.0 → dbly-0.6.0}/src/dbly/repo.py

@@ -33,6 +33,8 @@ class Repo:
         *,
         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():
@@ -41,6 +43,9 @@ class Repo:
         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:
@@ -73,12 +78,26 @@ class Repo:
             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, under object_root, not a migration/ignored)."""
+        """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)
         )
 

{dbly-0.4.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.4.0 → dbly-0.6.0}/tests/test_integration.py

@@ -415,3 +415,67 @@ def test_extra_ignore_excludes_unparseable_files(tmp_path: Path):
     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.4.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