pgdevkit 0.3.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

pgdevkit/areas.py

@@ -0,0 +1,64 @@
+"""Optional `-- area: NAME[, NAME...]` tag recognized in the leading comment
+block of a migration file or a `database/` code file (blank lines and `--`
+comments at the very top, stopping at the first real statement — like a file
+header). A file may declare more than one area, either as a comma-separated
+list on one line or across several `-- area:` lines (the areas union).
+
+A file with no such directive is "untagged" and is treated as shared/common:
+`only` filters always keep untagged files, and `exclude` filters never drop
+them — only a file that explicitly declares an excluded area is dropped.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_AREA_LINE = re.compile(r"^\s*--\s*area\s*:\s*(.+?)\s*$", re.IGNORECASE)
+
+
+def parse_areas(content: str) -> frozenset[str]:
+    """Area names declared in `content`'s leading comment block."""
+    areas: set[str] = set()
+    for line in content.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if not stripped.startswith("--"):
+            break
+        m = _AREA_LINE.match(stripped)
+        if m:
+            areas.update(a.strip() for a in m.group(1).split(",") if a.strip())
+    return frozenset(areas)
+
+
+def file_areas(path: Path) -> frozenset[str]:
+    """Area names declared in the file at `path`."""
+    return parse_areas(path.read_text(encoding="utf-8"))
+
+
+def area_allowed(
+    areas: frozenset[str],
+    *,
+    only: frozenset[str] | None = None,
+    exclude: frozenset[str] | None = None,
+) -> bool:
+    """Whether a file that declares `areas` passes an `only`/`exclude` filter."""
+    if exclude and areas & exclude:
+        return False
+    if only and areas and not (areas & only):
+        return False
+    return True
+
+
+def filter_by_area(
+    paths: list[Path],
+    *,
+    only: frozenset[str] | None = None,
+    exclude: frozenset[str] | None = None,
+) -> list[Path]:
+    """`paths` restricted by an `only`/`exclude` area filter. Returns `paths`
+    unchanged (no file reads) when neither filter is set."""
+    if not only and not exclude:
+        return paths
+    return [p for p in paths if area_allowed(file_areas(p), only=only, exclude=exclude)]

pgdevkit/cli.py

@@ -23,6 +23,17 @@ app = typer.Typer(name="pgdb", help="PostgreSQL database schema tools")
 console = Console()
 err_console = Console(stderr=True)
 
+_AREA_OPTION = typer.Option(
+    [], "--area", help="Restrict to files declaring this area (repeatable); untagged files always stay in scope"
+)
+_EXCLUDE_AREA_OPTION = typer.Option(
+    [], "--exclude-area", help="Skip files declaring this area (repeatable); untagged files are never excluded"
+)
+
+
+def _as_area_set(values: list[str]) -> frozenset[str] | None:
+    return frozenset(values) if values else None
+
 testdb_app = typer.Typer(name="testdb", help="Manage the shared local Postgres test container")
 app.add_typer(testdb_app, name="testdb")
 
@@ -46,12 +57,20 @@ def compare(
     ),
     report_extra_db: bool = typer.Option(False, "--report-extra-db", help="Report objects in DB but not in scripts"),
     dialect: str = typer.Option("postgres", "--dialect", help="postgres (default) or mssql"),
+    area: list[str] = _AREA_OPTION,
+    exclude_area: list[str] = _EXCLUDE_AREA_OPTION,
     scripts_dir: Path = typer.Argument(..., help="Directory containing SQL scripts"),
 ) -> None:
     """Compare SQL scripts to a live database and report differences."""
     if not scripts_dir.is_dir():
         err_console.print(f"[red]Error:[/red] {scripts_dir} is not a directory")
         raise typer.Exit(2)
+    if report_extra_db and (area or exclude_area):
+        console.print(
+            "[yellow]⚠[/yellow]  --report-extra-db with --area/--exclude-area will report every DB object "
+            "outside the filtered area(s) as \"missing in scripts\", since the live database has no concept "
+            "of areas — only the scripts side is filtered."
+        )
 
     try:
         conninfo = build_conninfo(
@@ -71,7 +90,9 @@ def compare(
         raise typer.Exit(2)
 
     with console.status("Parsing SQL scripts..."):
-        scripts_schema = parse_directory(scripts_dir, dialect=backend.dialect)
+        scripts_schema = parse_directory(
+            scripts_dir, dialect=backend.dialect, areas=_as_area_set(area), exclude_areas=_as_area_set(exclude_area)
+        )
 
     with console.status("Introspecting database..."):
         db_schema = backend.introspect(conninfo)
@@ -110,7 +131,11 @@ def fetch_missing(
     only: list[str] = typer.Option([], "--only", help="Only fetch schema.name (repeatable); default is everything"),
 ) -> None:
     """Find tables/views/functions that exist in the database but aren't
-    tracked under scripts_dir, and reverse-engineer their DDL into new files."""
+    tracked under scripts_dir, and reverse-engineer their DDL into new files.
+
+    No --area/--exclude-area here (unlike compare/migrate): this diffs the
+    full live database against scripts, so filtering the scripts side by
+    area would misreport objects tracked under other areas as missing."""
     if not scripts_dir.is_dir():
         err_console.print(f"[red]Error:[/red] {scripts_dir} is not a directory")
         raise typer.Exit(2)
@@ -245,6 +270,8 @@ def migrate_check(
         help="schema.table recording applied migrations "
         "(default: tool.pgdevkit.migrations_table in pyproject.toml, else public.schema_migrations)",
     ),
+    area: list[str] = _AREA_OPTION,
+    exclude_area: list[str] = _EXCLUDE_AREA_OPTION,
 ) -> None:
     """List which migration files under migrations_dir are applied vs. pending."""
     if not migrations_dir.is_dir():
@@ -253,7 +280,9 @@ def migrate_check(
 
     conninfo = build_conninfo(url, entra_user)
     tracking_table = tracking_table or migrate.default_tracking_table(migrations_dir)
-    local_files = migrate.list_migration_files(migrations_dir)
+    local_files = migrate.list_migration_files(
+        migrations_dir, areas=_as_area_set(area), exclude_areas=_as_area_set(exclude_area)
+    )
     try:
         applied = migrate.applied_migrations(conninfo, tracking_table)
     except migrate.TrackingTableMissing:
@@ -292,6 +321,8 @@ def migrate_apply(
     ),
     ask: bool = typer.Option(False, "--ask", help="Show and confirm each migration before running it"),
     yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirm-target prompt"),
+    area: list[str] = _AREA_OPTION,
+    exclude_area: list[str] = _EXCLUDE_AREA_OPTION,
 ) -> None:
     """Apply pending migration files, in filename order, tracking each in tracking_table."""
     if not migrations_dir.is_dir():
@@ -300,6 +331,7 @@ def migrate_apply(
 
     conninfo = build_conninfo(url, entra_user)
     tracking_table = tracking_table or migrate.default_tracking_table(migrations_dir)
+    areas, exclude_areas = _as_area_set(area), _as_area_set(exclude_area)
     target_desc = url.rsplit("@", 1)[-1] if "@" in url else url
     if not yes:
         typer.confirm(f"About to run migrations against {target_desc}. Continue?", abort=True)
@@ -308,12 +340,14 @@ def migrate_apply(
         targets = [migrations_dir / file]
     else:
         try:
-            targets = migrate.pending_migrations(migrations_dir, conninfo, tracking_table)
+            targets = migrate.pending_migrations(
+                migrations_dir, conninfo, tracking_table, areas=areas, exclude_areas=exclude_areas
+            )
         except migrate.TrackingTableMissing:
             err_console.print(
                 f"[yellow]⚠[/yellow]  {tracking_table} not found — treating every migration as pending"
             )
-            targets = migrate.list_migration_files(migrations_dir)
+            targets = migrate.list_migration_files(migrations_dir, areas=areas, exclude_areas=exclude_areas)
 
     if not targets:
         console.print("No pending migrations.")

pgdevkit/fetch_missing.py

@@ -9,7 +9,7 @@ import psycopg
 
 from .diff import DiffKind, compute_diff
 from .introspect import introspect_db
-from .parser import parse_directory
+from .parser import IGNORED_DIR_NAMES, parse_directory
 
 _LAYER_PREFIX_RE = re.compile(r"^\d+_?")
 
@@ -41,7 +41,7 @@ def layer_folder_for(scripts_dir: Path, schema: str) -> Path:
     if no existing folder matches."""
     if scripts_dir.is_dir():
         for entry in scripts_dir.iterdir():
-            if not entry.is_dir() or entry.name in ("migrations", "_migration_scripts"):
+            if not entry.is_dir() or entry.name in ("migrations", "_migration_scripts") or entry.name in IGNORED_DIR_NAMES:
                 continue
             if _LAYER_PREFIX_RE.sub("", entry.name).lower() == schema.lower():
                 return entry
@@ -50,7 +50,12 @@ def layer_folder_for(scripts_dir: Path, schema: str) -> Path:
 
 def find_missing_objects(scripts_dir: Path, conninfo: str) -> list[MissingObject]:
     """Tables, views, and functions that exist in the live database but
-    aren't tracked as .sql files under scripts_dir."""
+    aren't tracked as .sql files under scripts_dir.
+
+    Deliberately not area-filterable: this diffs the *full* database against
+    scripts with report_extra_db=True, so narrowing the scripts side to one
+    area would make every object tracked only under a different area look
+    "missing" too — and --write would reconstruct a duplicate file for it."""
     scripts = parse_directory(scripts_dir)
     db = introspect_db(conninfo)
     diffs = compute_diff(scripts, db, report_extra_db=True)

pgdevkit/migrate.py

@@ -18,6 +18,8 @@ import sqlglot
 from psycopg import errors as pg_errors
 from psycopg import sql as pg_sql
 
+from .areas import filter_by_area
+
 _IDENTIFIER = r"[A-Za-z_][A-Za-z0-9_]*"
 _DEFAULT_TRACKING_TABLE = "public.schema_migrations"
 
@@ -274,8 +276,14 @@ def already_fully_applied(conninfo: str, path: Path) -> bool:
         return all(_target_exists(con, cast(tuple[str, ...], t)) for t in targets)
 
 
-def list_migration_files(migrations_dir: Path) -> list[Path]:
-    return sorted(migrations_dir.glob("*.sql"))
+def list_migration_files(
+    migrations_dir: Path,
+    *,
+    areas: frozenset[str] | None = None,
+    exclude_areas: frozenset[str] | None = None,
+) -> list[Path]:
+    files = sorted(migrations_dir.glob("*.sql"))
+    return filter_by_area(files, only=areas, exclude=exclude_areas)
 
 
 def applied_migrations(conninfo: str, tracking_table: str) -> dict[str, tuple[datetime, str]]:
@@ -291,9 +299,17 @@ def applied_migrations(conninfo: str, tracking_table: str) -> dict[str, tuple[da
         return {r[0]: (r[1], r[2]) for r in rows}
 
 
-def pending_migrations(migrations_dir: Path, conninfo: str, tracking_table: str) -> list[Path]:
+def pending_migrations(
+    migrations_dir: Path,
+    conninfo: str,
+    tracking_table: str,
+    *,
+    areas: frozenset[str] | None = None,
+    exclude_areas: frozenset[str] | None = None,
+) -> list[Path]:
     applied = applied_migrations(conninfo, tracking_table)
-    return [p for p in list_migration_files(migrations_dir) if p.name not in applied]
+    files = list_migration_files(migrations_dir, areas=areas, exclude_areas=exclude_areas)
+    return [p for p in files if p.name not in applied]
 
 
 def record_applied(conninfo: str, tracking_table: str, filename: str) -> bool:

pgdevkit/parser.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import re
 import logging
 from pathlib import Path
@@ -7,6 +8,7 @@ from pathlib import Path
 import sqlglot
 import sqlglot.expressions as exp
 
+from .areas import area_allowed, parse_areas
 from .dialect import Dialect, POSTGRES, resolve_dialect
 from .models import (
     ColumnDef, ConstraintDef, CompositeTypeDef, DatabaseSchema,
@@ -15,6 +17,14 @@ from .models import (
 
 logger = logging.getLogger(__name__)
 
+# Tooling/scratch dirs that can end up inside a database/ tree (e.g. git
+# worktrees checked out under database/.worktree for isolated test DBs) but
+# never hold real schema content.
+IGNORED_DIR_NAMES = {
+    ".worktree", ".worktrees", ".claude", ".vscode", "node_modules",
+    "__pycache__", ".pytest_cache", ".mypy_cache", ".ruff_cache",
+}
+
 # Regex to extract dollar-quoted body (Postgres-only construct)
 _DOLLAR_BODY = re.compile(r'\$(\w*)\$(.*?)\$\1\$', re.DOTALL | re.IGNORECASE)
 
@@ -31,16 +41,38 @@ _DO_COMPOSITE = re.compile(
 )
 
 
-def parse_directory(scripts_dir: Path, *, dialect: str | Dialect = "postgres") -> DatabaseSchema:
+def _iter_sql_files(scripts_dir: Path):
+    for root, dirs, files in os.walk(scripts_dir):
+        dirs[:] = [d for d in dirs if d not in IGNORED_DIR_NAMES]
+        for name in files:
+            if name.endswith(".sql"):
+                yield Path(root) / name
+
+
+def parse_directory(
+    scripts_dir: Path,
+    *,
+    dialect: str | Dialect = "postgres",
+    areas: frozenset[str] | None = None,
+    exclude_areas: frozenset[str] | None = None,
+) -> DatabaseSchema:
     resolved = resolve_dialect(dialect)
     db_schema = DatabaseSchema()
-    for sql_file in sorted(scripts_dir.rglob("*.sql")):
-        _parse_file(sql_file, db_schema, resolved)
+    for sql_file in sorted(_iter_sql_files(scripts_dir)):
+        # Read once and reuse for both the area check and parsing, rather than
+        # filtering the file list up front (which would need its own read).
+        content = sql_file.read_text(encoding="utf-8")
+        if (areas or exclude_areas) and not area_allowed(parse_areas(content), only=areas, exclude=exclude_areas):
+            continue
+        _parse_file(sql_file, db_schema, resolved, content=content)
     return db_schema
 
 
-def _parse_file(path: Path, db_schema: DatabaseSchema, dialect: Dialect = POSTGRES) -> None:
-    content = path.read_text(encoding="utf-8")
+def _parse_file(
+    path: Path, db_schema: DatabaseSchema, dialect: Dialect = POSTGRES, content: str | None = None
+) -> None:
+    if content is None:
+        content = path.read_text(encoding="utf-8")
     try:
         exprs = sqlglot.parse(content, dialect=dialect.sqlglot_name, error_level=sqlglot.ErrorLevel.WARN)
     except Exception as e:

pgdevkit/testdb/schema.py

@@ -15,6 +15,7 @@ from psycopg.sql import SQL, Identifier, Placeholder
 
 from ..db.complex_types import ComplexHelper
 from ..dialect import Dialect, POSTGRES
+from ..parser import IGNORED_DIR_NAMES
 
 logger = logging.getLogger(__name__)
 logging.getLogger("sqlglot").setLevel(logging.ERROR)
@@ -121,7 +122,8 @@ def _get_sql_deps(sql: str, dialect: Dialect = POSTGRES) -> set[str]:
 def _iter_sql_files(database_dir: Path, dialect: Dialect = POSTGRES):
     """Yield (Path, sql_content) pairs in dependency-safe execution order."""
     files: list[Path] = []
-    for root, _, dbfiles in os.walk(database_dir):
+    for root, dirs, dbfiles in os.walk(database_dir):
+        dirs[:] = [d for d in dirs if d not in IGNORED_DIR_NAMES]
         if "_migration_scripts" in root or "migrations" in root:
             continue
         for file in dbfiles:

{pgdevkit-0.3.6.dist-info → pgdevkit-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pgdevkit
-Version: 0.3.6
+Version: 0.4.0
 Summary: A helper for developing with Postgres
 Requires-Python: >=3.14
 Requires-Dist: docker>=7.1.0
@@ -79,6 +79,62 @@ which parses/introspects/diffs like any other column type; see
 handled on the CRUD side (write-side serialization only, no auto-parsing on
 read — `mssql-python` doesn't distinguish `json` columns from `nvarchar`).
 
+### Area tagging and filtering
+
+Any migration file or `database/` code file can declare one or more areas by
+starting with a `-- area:` comment:
+
+```sql
+-- area: billing
+CREATE TABLE billing.invoices (id int primary key);
+```
+
+A file can declare more than one area, either comma-separated on one line
+(`-- area: billing, reporting`) or across several `-- area:` lines — the
+declared areas union. The directive is only recognized in the file's leading
+comment block (blank lines and `--` comments at the very top, stopping at the
+first real statement); a `-- area:` comment later in the file doesn't count.
+A file with no directive is untagged, and untagged files are treated as
+shared/common.
+
+`pgdb compare`, `pgdb migrate check`, and `pgdb migrate apply` all accept:
+
+- `--area NAME` (repeatable) — restrict to files declaring one of the given
+  areas, **plus every untagged file** (untagged files always stay in scope).
+- `--exclude-area NAME` (repeatable) — drop files declaring one of the given
+  areas; untagged files are never dropped by this.
+
+Both can be combined; a file matching both an included and an excluded area
+is excluded. Passing neither option applies no filtering (the default,
+unchanged behavior).
+
+```bash
+pgdb migrate apply path/to/database/_migration_scripts --url ... --area billing
+pgdb compare path/to/database/ --url ... --exclude-area reporting
+```
+
+`compare`'s default report (no `--report-extra-db`) only checks that the
+filtered scripts exist correctly in the DB, so it composes safely with area
+filtering. Passing `--report-extra-db` together with an area filter also
+reports every DB object outside the filtered area(s) as "missing in
+scripts" — since the live database has no concept of areas, only the
+scripts side is filtered — so treat that combination's "missing in scripts"
+results with that in mind (the CLI prints a warning when you combine them).
+
+`pgdb fetch-missing` deliberately has **no** `--area`/`--exclude-area`: it
+diffs the full database against scripts to find genuinely untracked
+objects, so narrowing the scripts side by area would make every object
+tracked only under a different area look "missing" too — and `--write`
+would then reconstruct a duplicate file for something that already exists.
+
+`pgdevkit.areas` exposes the same logic for scripting:
+`parse_areas`/`file_areas` read a file's declared areas, and
+`area_allowed`/`filter_by_area` apply the `only`/`exclude` semantics above.
+`pgdevkit.migrate.list_migration_files`/`pending_migrations` and
+`pgdevkit.parser.parse_directory` take the same `areas`/`exclude_areas`
+keyword arguments (`pgdevkit.fetch_missing.find_missing_objects` doesn't,
+for the reason above).
+
 ## `pgdb testdb`
 
 Manages a single shared, Podman-backed Postgres container for local tests
@@ -259,3 +315,29 @@ async with pool.connection() as con:
     widget = await pg_retrieve(con, Widget, {"id": 1})
     await pg_upsert(con, Widget(id=1, name="thing"), Widget)
 ```
+
+## Releasing
+
+Bump `version` in `pyproject.toml` as part of your PR, same as any other
+change. Once that PR merges to `main` and the `Python Test` workflow passes
+for that commit, `.github/workflows/auto-release.yml` automatically tags it
+`vX.Y.Z`, cuts a GitHub Release (skipping if that version was already
+released, e.g. a merge that didn't touch the version), and dispatches
+`python-publish.yml` to publish it to PyPI — no manual release step, and no
+extra secret to configure. Two non-obvious GitHub Actions quirks shaped
+this (see the comments at the top of `auto-release.yml` for the full
+reasoning, since both were hit and confirmed the hard way):
+
+- A release created with the default `GITHUB_TOKEN` does **not** trigger
+  other workflows' `release: published` listeners (an anti-recursion
+  safeguard) — `workflow_dispatch` is the documented exception, so
+  `auto-release.yml` dispatches `python-publish.yml` directly (`gh workflow
+  run`) instead of relying on the release to cascade into it.
+- `python-publish.yml` deliberately stays a plain, directly-triggered
+  top-level workflow rather than something `auto-release.yml` calls via
+  `workflow_call`: PyPI's OIDC trusted publishing does not support
+  reusable/called workflows and silently rejects the token in that shape.
+
+`workflow_dispatch` (or an actual GitHub UI release) on `python-publish.yml`
+still works as a manual fallback if you ever need to re-publish a version
+without going through `auto-release.yml`.

{pgdevkit-0.3.6.dist-info → pgdevkit-0.4.0.dist-info}/RECORD

@@ -1,15 +1,16 @@
 pgdevkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pgdevkit/cli.py,sha256=xP4fZB0Dg3wivhb00DcP2w2Vnp8BRyaR2o1wD7jopFc,17574
+pgdevkit/areas.py,sha256=iEmOObYxhZyDFl2iQVf1OQJN4JtZ-H3EL-qMfxYZdSQ,2203
+pgdevkit/cli.py,sha256=gZt4BlEuw4hhMq0dyMRCe1a3-Ci23yUDg-6Sc_H-OSo,19193
 pgdevkit/connection.py,sha256=x49aXKsJfyOsDTlqURs9idQUWaD-RO-XdtAqsG3guBI,4000
 pgdevkit/dialect.py,sha256=PL5Y8QPZNnoHIvAPomczGQX7IjZwxMgKGuREX80SwFA,3105
 pgdevkit/diff.py,sha256=Y2TbjwpFHYik0wZDhoI--9EAlIfp4AUg8BUubkOXyUg,9295
-pgdevkit/fetch_missing.py,sha256=1-2NBDCQNtirywO9Ucm775UKSACfAzcnQlp-4Jh2weE,8136
+pgdevkit/fetch_missing.py,sha256=vb8hXWBKMWgqkxHso5SuhX9l6rxNXfaybAEsajPLYow,8495
 pgdevkit/introspect.py,sha256=QYIlRuZk4lBHGxaW7zb_kFRIuNfi3AxH0Q2F_GKzlVI,7870
 pgdevkit/lakebase.py,sha256=0PABOk4p-2klLTY8QAUibQf9QeyNHKywUWEWGdkUY8k,3165
-pgdevkit/migrate.py,sha256=pU7xVssJiAHfFFU60DP2cwpjQ1Tf8Hscc_Q6wIqeSfM,13677
+pgdevkit/migrate.py,sha256=_8U-TG4MRZQasdm0UticdbM4rhthoZ9QSF9L4NX3Xq8,14057
 pgdevkit/models.py,sha256=dAZ8f7pgDsxoLVrDWsM4h0qwJ0pOzXDdWMGsnjrW80E,2103
 pgdevkit/mssql_introspect.py,sha256=Fhv1N4zHYEDZ0PEy0OIpawUmoIFeoi-Lm97pmEyDmYY,12031
-pgdevkit/parser.py,sha256=X1P8RbogRhsWc-H9w3IPlDo2blKpI33cJTvDzOXze1Y,15367
+pgdevkit/parser.py,sha256=RWtCDx98OU3T7fmEA7ZZN82Fqo6wlbv03O_BEKwZGQo,16561
 pgdevkit/backends/__init__.py,sha256=ys4VBglMImRtnudJBlTPVBNevDMRippuwAJOz0yRKiY,610
 pgdevkit/backends/base.py,sha256=0i0KLCYVWlpVFnUoq2t0LCRE_abyWPPIhw1bMxmW9KQ,1048
 pgdevkit/backends/mssql.py,sha256=pocBdoQ14ZnYLutXEOStVmJvmpclXGs3gaxHN0uJCMk,1068
@@ -30,7 +31,7 @@ pgdevkit/testdb/constants.py,sha256=xi8uIoEgN9LrRkr41j3mmWB9PqqU0r8aCUb2JJXBAs0,
 pgdevkit/testdb/container.py,sha256=kELTb6qaECAO9a5Bwvx1btv6i5QKRFAa9PX6auWymNo,2807
 pgdevkit/testdb/naming.py,sha256=Kyk5qEfxUkbggUG5bD7U7CJ_kAET332VPQNB-O5kvTY,1318
 pgdevkit/testdb/query.py,sha256=iYpy_EoYIq5USfwr6pNktmDjcGi_yQx0vHvjHZNGRr0,3854
-pgdevkit/testdb/schema.py,sha256=vw75HsiMvZPmMWaD5P2DeOaEKS86qksRXHDtOc8SjJE,11941
+pgdevkit/testdb/schema.py,sha256=0N0Q_BQGh2kuAqa_j-DdbjYlTUOOZSEtaoUOApxQg_Y,12049
 pgdevkit/testdb/mssql/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
 pgdevkit/testdb/mssql/api.py,sha256=42RAuJeiZlK1WJaTIYoj6l8GEAbEyt6LgAoF3G2jxnw,7537
 pgdevkit/testdb/mssql/constants.py,sha256=7n_NcYuhabbtb18CqG_H_rRbI7Wb_qu_l4nKk3281vI,2847
@@ -39,7 +40,7 @@ pgdevkit/docs/database-layout.md,sha256=4GBwv4PA2cKHl2BxwLd-awLOe9he9ie4X6CpQWjI
 pgdevkit/skills/pgdevkit/SKILL.md,sha256=6uxe6BQwOLexGiBpf00VTFTHOiWJo5k2Qqzu172rb4I,12156
 pgdevkit/skills/pgdevkit/references/dynamic-sql.md,sha256=aTR1sx81moiTwaMaiOecaqk-9rT8y5Zxz7W1BoC3vK0,2774
 pgdevkit/skills/pgdevkit/references/temporal-tables.md,sha256=LwZnItvQWI7bB0oRHxIfUc0ynnq7N0V5Mnv-QHvFN3Q,1364
-pgdevkit-0.3.6.dist-info/METADATA,sha256=DxmlfQZ0M5gVVrHhHHz-748Eu6-leFPurFjplxOZyQU,11346
-pgdevkit-0.3.6.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-pgdevkit-0.3.6.dist-info/entry_points.txt,sha256=FK2P55lf0WaGlOZJIINOGgCt8WB7ep0OnPsgnrp80bg,42
-pgdevkit-0.3.6.dist-info/RECORD,,
+pgdevkit-0.4.0.dist-info/METADATA,sha256=KgPFnAsptfih47V8mmLRNJ43aKBq013EWMH2M3EgDhs,15524
+pgdevkit-0.4.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+pgdevkit-0.4.0.dist-info/entry_points.txt,sha256=FK2P55lf0WaGlOZJIINOGgCt8WB7ep0OnPsgnrp80bg,42
+pgdevkit-0.4.0.dist-info/RECORD,,