dblift 2.5.2__tar.gz → 2.6.1__tar.gz

{dblift-2.5.2 → dblift-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 2.5.2
+Version: 2.6.1
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -46,6 +46,7 @@ Requires-Dist: types-PyYAML>=6.0.12.12; extra == "dev"
 Requires-Dist: types-setuptools; extra == "dev"
 Requires-Dist: pre-commit>=4.0.0; extra == "dev"
 Requires-Dist: Cython>=3.0.0; extra == "dev"
+Requires-Dist: setuptools>=83.0.0; extra == "dev"
 Requires-Dist: bandit>=1.7.9; extra == "dev"
 Requires-Dist: pip-audit>=2.7.3; extra == "dev"
 Requires-Dist: radon>=6.0.1; extra == "dev"
@@ -88,6 +89,8 @@ Requires-Dist: psycopg[binary]>=3.1; extra == "cockroachdb"
 Provides-Extra: redshift
 Requires-Dist: sqlalchemy-redshift>=1.0.0; extra == "redshift"
 Requires-Dist: redshift-connector>=2.1.0; extra == "redshift"
+Provides-Extra: snowflake
+Requires-Dist: snowflake-sqlalchemy>=1.11.0; extra == "snowflake"
 Provides-Extra: fastapi
 Requires-Dist: fastapi>=0.100; extra == "fastapi"
 Provides-Extra: flask
@@ -444,15 +447,26 @@ def migrate(context: MigrationContext) -> None:
             f"INSERT INTO {schema_prefix}roles (code, label) VALUES (?, ?)",
             [code, label],
         )
+```
+
+> **Undo is a separate script, not a function.** DBLift does not call an
+> `undo()` function inside a `V*.py` migration. To make a Python migration
+> reversible, add a companion undo script `U2__seed_lookup_tables.py` that
+> exposes its own `migrate(context)` performing the reverse change — exactly
+> like the `U*.sql` undo files described in
+> [Rolling Back Changes](#rolling-back-changes). `dblift undo` runs that
+> companion script; the `Undoable` column in `dblift info` reflects whether a
+> matching `U*` file exists.
 
-def undo(context: MigrationContext) -> None:
-    """Optional rollback for `dblift undo`."""
+```python
+# migrations/U2__seed_lookup_tables.py  (undo companion for V2)
+from api import MigrationContext
+
+def migrate(context: MigrationContext) -> None:
+    """Reverse V2 by removing the seeded lookup rows."""
     if context.dry_run:
         return
-    context.execute(
-        "DELETE FROM roles WHERE code IN (?, ?)",
-        ["admin", "user"],
-    )
+    context.execute("DELETE FROM roles WHERE code IN (?, ?)", ["admin", "user"])
 ```
 
 ---
@@ -725,6 +739,53 @@ migrations:
       recursive: false                     # Dict format (per-directory setting)
 ```
 
+### Configuration Sources and Precedence
+
+The `dblift.yaml` file is only one of three ways to supply configuration. Every
+setting can also be passed as a **command-line flag** or an **environment
+variable**, which is convenient for CI pipelines and for keeping secrets out of
+files. When the same setting comes from more than one source, the higher-priority
+source wins:
+
+```
+command-line flag  >  environment variable  >  dblift.yaml  >  values embedded in the database URL
+```
+
+The database connection settings are the most common to override:
+
+| Setting | `dblift.yaml` key | Environment variable | CLI flag |
+|---------|-------------------|----------------------|----------|
+| Connection URL | `database.url` | `DBLIFT_DB_URL` | `--db-url` |
+| Username | `database.username` | `DBLIFT_DB_USERNAME` | `--db-username` |
+| Password | `database.password` | `DBLIFT_DB_PASSWORD` | `--db-password` |
+| Schema | `database.schema` | `DBLIFT_DB_SCHEMA` | `--db-schema` |
+| Scripts directory | `migrations.directory` | — | `--scripts` |
+| Strict ordering | `strict_mode` (top level) | `DBLIFT_STRICT_MODE` | `--strict` |
+
+For example, the same run configured three ways:
+
+```bash
+# 1. Everything from dblift.yaml
+dblift migrate
+
+# 2. Connection from the environment (nothing sensitive on disk)
+export DBLIFT_DB_URL="postgresql+psycopg://localhost:5432/mydb"
+export DBLIFT_DB_PASSWORD="s3cret"
+dblift migrate
+
+# 3. Overriding a file-based config on the command line (e.g. targeting staging)
+dblift migrate --db-url "postgresql+psycopg://staging:5432/mydb" --scripts ./migrations
+```
+
+Non-database settings follow the same pattern: the environment variable is the
+setting name upper-cased with a `DBLIFT_` prefix (for example `--installed-by` ↔
+`DBLIFT_INSTALLED_BY`). For the authoritative, always-current list of every
+setting and its three surfaces, run:
+
+```bash
+dblift config --list
+```
+
 ### Supported Databases
 
 DBLift works with these databases:
@@ -734,6 +795,7 @@ DBLift works with these databases:
 | PostgreSQL | `postgresql+psycopg://localhost:5432/mydb` | `dblift[postgresql]` |
 | CockroachDB | `postgresql+psycopg://localhost:26257/mydb` | `dblift[cockroachdb]` |
 | Redshift | `postgresql+psycopg://cluster.example.com:5439/dev` | `dblift[redshift]` |
+| Snowflake | `snowflake://user:password@account_identifier/database/schema?warehouse=WH&role=ROLE` | `dblift[snowflake]` |
 | SQL Server | `mssql+pymssql://localhost:1433/mydb` | `dblift[sqlserver]` |
 | Oracle | `oracle+oracledb://localhost:1521?sid=SID` | `dblift[oracle]` |
 | MySQL | `mysql+pymysql://localhost:3306/mydb` | `dblift[mysql]` |

{dblift-2.5.2 → dblift-2.6.1}/README.md

@@ -342,15 +342,26 @@ def migrate(context: MigrationContext) -> None:
             f"INSERT INTO {schema_prefix}roles (code, label) VALUES (?, ?)",
             [code, label],
         )
+```
+
+> **Undo is a separate script, not a function.** DBLift does not call an
+> `undo()` function inside a `V*.py` migration. To make a Python migration
+> reversible, add a companion undo script `U2__seed_lookup_tables.py` that
+> exposes its own `migrate(context)` performing the reverse change — exactly
+> like the `U*.sql` undo files described in
+> [Rolling Back Changes](#rolling-back-changes). `dblift undo` runs that
+> companion script; the `Undoable` column in `dblift info` reflects whether a
+> matching `U*` file exists.
 
-def undo(context: MigrationContext) -> None:
-    """Optional rollback for `dblift undo`."""
+```python
+# migrations/U2__seed_lookup_tables.py  (undo companion for V2)
+from api import MigrationContext
+
+def migrate(context: MigrationContext) -> None:
+    """Reverse V2 by removing the seeded lookup rows."""
     if context.dry_run:
         return
-    context.execute(
-        "DELETE FROM roles WHERE code IN (?, ?)",
-        ["admin", "user"],
-    )
+    context.execute("DELETE FROM roles WHERE code IN (?, ?)", ["admin", "user"])
 ```
 
 ---
@@ -623,6 +634,53 @@ migrations:
       recursive: false                     # Dict format (per-directory setting)
 ```
 
+### Configuration Sources and Precedence
+
+The `dblift.yaml` file is only one of three ways to supply configuration. Every
+setting can also be passed as a **command-line flag** or an **environment
+variable**, which is convenient for CI pipelines and for keeping secrets out of
+files. When the same setting comes from more than one source, the higher-priority
+source wins:
+
+```
+command-line flag  >  environment variable  >  dblift.yaml  >  values embedded in the database URL
+```
+
+The database connection settings are the most common to override:
+
+| Setting | `dblift.yaml` key | Environment variable | CLI flag |
+|---------|-------------------|----------------------|----------|
+| Connection URL | `database.url` | `DBLIFT_DB_URL` | `--db-url` |
+| Username | `database.username` | `DBLIFT_DB_USERNAME` | `--db-username` |
+| Password | `database.password` | `DBLIFT_DB_PASSWORD` | `--db-password` |
+| Schema | `database.schema` | `DBLIFT_DB_SCHEMA` | `--db-schema` |
+| Scripts directory | `migrations.directory` | — | `--scripts` |
+| Strict ordering | `strict_mode` (top level) | `DBLIFT_STRICT_MODE` | `--strict` |
+
+For example, the same run configured three ways:
+
+```bash
+# 1. Everything from dblift.yaml
+dblift migrate
+
+# 2. Connection from the environment (nothing sensitive on disk)
+export DBLIFT_DB_URL="postgresql+psycopg://localhost:5432/mydb"
+export DBLIFT_DB_PASSWORD="s3cret"
+dblift migrate
+
+# 3. Overriding a file-based config on the command line (e.g. targeting staging)
+dblift migrate --db-url "postgresql+psycopg://staging:5432/mydb" --scripts ./migrations
+```
+
+Non-database settings follow the same pattern: the environment variable is the
+setting name upper-cased with a `DBLIFT_` prefix (for example `--installed-by` ↔
+`DBLIFT_INSTALLED_BY`). For the authoritative, always-current list of every
+setting and its three surfaces, run:
+
+```bash
+dblift config --list
+```
+
 ### Supported Databases
 
 DBLift works with these databases:
@@ -632,6 +690,7 @@ DBLift works with these databases:
 | PostgreSQL | `postgresql+psycopg://localhost:5432/mydb` | `dblift[postgresql]` |
 | CockroachDB | `postgresql+psycopg://localhost:26257/mydb` | `dblift[cockroachdb]` |
 | Redshift | `postgresql+psycopg://cluster.example.com:5439/dev` | `dblift[redshift]` |
+| Snowflake | `snowflake://user:password@account_identifier/database/schema?warehouse=WH&role=ROLE` | `dblift[snowflake]` |
 | SQL Server | `mssql+pymssql://localhost:1433/mydb` | `dblift[sqlserver]` |
 | Oracle | `oracle+oracledb://localhost:1521?sid=SID` | `dblift[oracle]` |
 | MySQL | `mysql+pymysql://localhost:3306/mydb` | `dblift[mysql]` |

{dblift-2.5.2 → dblift-2.6.1}/cli/_command_handlers.py

@@ -22,6 +22,7 @@ from cli.handlers.migrate import _handle_migrate
 from cli.handlers.repair import _handle_repair
 from cli.handlers.undo import _handle_undo
 from cli.handlers.validate import _handle_validate
+from cli.premium_manifest import PremiumCommand, premium_stub_index, render_upsell
 from core.seams.tier_resolver import resolve_tier
 
 _COMMAND_HANDLERS: Dict[str, Callable[[CliCommandContext], Tuple[bool, Any]]] = {
@@ -44,6 +45,31 @@ if _builtin_conflicts:
 _COMMAND_HANDLERS.update(_extension_handlers)
 del _extension_handlers, _builtin_conflicts
 
+
+def _make_premium_stub_handler(
+    cmd: "PremiumCommand",
+) -> Callable[[CliCommandContext], Tuple[bool, Any]]:
+    """Build a handler that reports the upsell message and fails.
+
+    Only reachable in chained invocations (``dblift migrate diff``): a stub
+    in first position short-circuits in ``cli/main.py`` before any config
+    or database work, with the dedicated ``EXIT_LICENSE_REQUIRED`` code.
+    """
+
+    def _handle_premium_stub(ctx: CliCommandContext) -> Tuple[bool, Any]:
+        ctx.log.error(render_upsell(cmd))
+        return False, None
+
+    return _handle_premium_stub
+
+
+# Gap-fill AFTER extension merge so entry-point registrations always win:
+# with the paid runtime installed, the real handlers already own these
+# names and PREMIUM_STUB_COMMANDS is empty.
+PREMIUM_STUB_COMMANDS: Dict[str, "PremiumCommand"] = premium_stub_index(_COMMAND_HANDLERS)
+for _stub_cmd in PREMIUM_STUB_COMMANDS.values():
+    _COMMAND_HANDLERS[_stub_cmd.name] = _make_premium_stub_handler(_stub_cmd)
+
 _AVAILABLE_COMMANDS = (
     list(_COMMAND_HANDLERS.keys()) + ["db", "config"] + list(load_terminal_commands())
 )

{dblift-2.5.2 → dblift-2.6.1}/cli/_constants.py

@@ -22,3 +22,9 @@ from __future__ import annotations
 MACHINE_READABLE_FORMATS: frozenset[str] = frozenset(
     {"json", "sarif", "github-actions", "gitlab", "compact"}
 )
+
+# Exit code for "this command needs a paid edition or a higher license
+# tier": returned by the OSS premium-command stubs (cli/premium_manifest.py)
+# so scripts and CI pipelines can branch on entitlement without parsing
+# stderr. Distinct from 1 (command failure) and 2 (argparse usage error).
+EXIT_LICENSE_REQUIRED: int = 4

{dblift-2.5.2 → dblift-2.6.1}/cli/_parser_setup.py

@@ -308,6 +308,34 @@ def _register_builtin_command_parsers(
     return registered
 
 
+def _register_premium_stub_parsers(parser: argparse.ArgumentParser) -> None:
+    """Add stub subparsers for paid commands with no registered extension.
+
+    Must run AFTER ``load_command_extensions`` so real entry-point parsers
+    always win: with the paid runtime installed the manifest entries are
+    already in ``subparsers.choices`` and no stub is created. The stub
+    swallows any arguments via ``REMAINDER`` (and disables ``-h``) so every
+    invocation shape — ``dblift diff``, ``dblift diff --anything``,
+    ``dblift diff --help`` — reaches the upsell message instead of an
+    argparse usage error.
+    """
+    from cli.premium_manifest import premium_commands_missing_from
+
+    subparser_actions = [
+        action for action in parser._actions if isinstance(action, argparse._SubParsersAction)
+    ]
+    if not subparser_actions:
+        return
+    subparsers = subparser_actions[0]
+    for cmd in premium_commands_missing_from(subparsers.choices):
+        stub = subparsers.add_parser(
+            cmd.name,
+            help=f"{cmd.summary} [{cmd.edition}]",
+            add_help=False,
+        )
+        stub.add_argument("stub_args", nargs=argparse.REMAINDER, help=argparse.SUPPRESS)
+
+
 def create_parser(
     exit_on_error: bool = True, suppress_errors: bool = False
 ) -> argparse.ArgumentParser:
@@ -485,6 +513,8 @@ def create_parser(
         help="List all properties and how to set them (config key / env var / CLI flag)",
     )
     import_module("cli.extensions").load_command_extensions(parser)
+    # Stubs fill whatever gaps the extensions left — never the reverse.
+    _register_premium_stub_parsers(parser)
     # Emit registry-derived flags LAST, after every subparser (built-in and
     # extension) is registered, so the tree walk in _add_registry_flags can see
     # subcommand-only flags and skip them instead of shadowing them on the root.

{dblift-2.5.2 → dblift-2.6.1}/cli/main.py

@@ -23,6 +23,7 @@ _mask_database_url = mask_database_url
 from cli._command_handlers import (  # noqa: F401
     _AVAILABLE_COMMANDS,
     _COMMAND_HANDLERS,
+    PREMIUM_STUB_COMMANDS,
     CliCommandContext,
     _extract_version_filters,
     _handle_baseline,
@@ -51,9 +52,11 @@ from cli._config_helpers import (  # noqa: F401
     _validate_db_config,
     _validate_log_format_for_cli,
 )
+from cli._constants import EXIT_LICENSE_REQUIRED
 from cli._output import CommandOutput, from_args
 from cli._parser_setup import create_parser, parse_with_selective_errors
 from cli.extensions import load_terminal_commands
+from cli.premium_manifest import render_upsell
 from core.seams.feature_loading import load_feature_extensions
 from core.seams.license_info import get_license_info
 
@@ -309,6 +312,17 @@ def _parse_argv_and_load_config(argv: List[str]) -> _CliContext:
             sys.exit(0)
         sys.exit(terminal_commands[commands[0]](args))
 
+    # Premium-command stubs short-circuit here — before argparse builds the
+    # namespace and before any config/database work — because the stub's only
+    # behaviour is the upsell message: subcommand flags the OSS parser doesn't
+    # know (e.g. ``diff --snapshot-model``) must not fail as usage errors, and
+    # a missing database config must not bury the message. Chained invocations
+    # (stub not in first position) are covered by the gap-fill handlers in
+    # cli/_command_handlers.py instead.
+    if commands and commands[0] in PREMIUM_STUB_COMMANDS:
+        CommandOutput("console").error(render_upsell(PREMIUM_STUB_COMMANDS[commands[0]]))
+        sys.exit(EXIT_LICENSE_REQUIRED)
+
     args, _unknown_args = _build_args_namespace(commands, global_arguments, subcommand_args)
 
     if hasattr(args, "version") and args.version:

dblift-2.6.1/cli/premium_manifest.py

@@ -0,0 +1,101 @@
+"""Catalog of paid dblift commands surfaced as stubs in the OSS CLI.
+
+This module is the ONLY place OSS code may name paid-edition commands
+(2026-07 amendment to the tier-architecture naming invariant: the
+unidirectional dependency rule is untouched — OSS still imports nothing
+from a higher tier — but this one file may carry a declarative catalog so
+the OSS CLI can advertise paid commands instead of silently omitting them).
+
+It is pure data plus rendering helpers. When the paid runtime is installed,
+its entry-point registrations run first and the stubs for those commands
+are never created (see ``_register_premium_stub_parsers`` in
+``cli/_parser_setup.py`` and the gap-fill block in
+``cli/_command_handlers.py``), so precedence is structural, not conditional.
+
+The paid monorepo carries a CI check that diffs this catalog against the
+commands its packages actually register — keep entries in sync with the
+real command surface, never ahead of it.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Iterable, Tuple
+
+UPGRADE_URL = "https://dblift.com/upgrade"
+
+
+@dataclass(frozen=True)
+class PremiumCommand:
+    """Declarative descriptor for a command that exists only in a paid edition."""
+
+    name: str
+    edition: str  # human-facing label: "Pro" or "Enterprise"
+    summary: str  # one-line help, mirrored from the paid parser registration
+
+
+PREMIUM_COMMANDS: Tuple[PremiumCommand, ...] = (
+    PremiumCommand(
+        "diff",
+        "Pro",
+        "Compare applied migrations against live database schema (drift detection)",
+    ),
+    PremiumCommand(
+        "export-schema",
+        "Pro",
+        "Export database schema to SQL migration file(s)",
+    ),
+    PremiumCommand(
+        "validate-sql",
+        "Pro",
+        "Validate SQL files with business rules and performance analysis",
+    ),
+    PremiumCommand(
+        "data",
+        "Pro",
+        "Manage data corrections - audited DML with plan/apply/undo",
+    ),
+    PremiumCommand(
+        "snapshot",
+        "Enterprise",
+        "Export database schema snapshot to JSON model file",
+    ),
+    PremiumCommand(
+        "plan",
+        "Enterprise",
+        "Build an offline migration plan from a snapshot model",
+    ),
+    PremiumCommand(
+        "preflight",
+        "Enterprise",
+        "Run deployment preflight checks from a snapshot model",
+    ),
+)
+
+
+def premium_commands_missing_from(
+    registered: Iterable[str],
+) -> Tuple[PremiumCommand, ...]:
+    """Manifest entries with no real registration among ``registered``.
+
+    Callers pass the names already claimed by builtins and entry-point
+    extensions; anything returned needs a stub. With the paid runtime
+    installed this is empty and the OSS surface is untouched.
+    """
+    taken = set(registered)
+    return tuple(cmd for cmd in PREMIUM_COMMANDS if cmd.name not in taken)
+
+
+def premium_stub_index(registered: Iterable[str]) -> Dict[str, PremiumCommand]:
+    """Like :func:`premium_commands_missing_from`, keyed by command name."""
+    return {cmd.name: cmd for cmd in premium_commands_missing_from(registered)}
+
+
+def render_upsell(cmd: PremiumCommand) -> str:
+    """Message shown when a stubbed paid command is invoked in OSS."""
+    return (
+        f"'{cmd.name}' is a dblift {cmd.edition} command and is not included "
+        f"in the open-source edition.\n"
+        f"  {cmd.summary}.\n"
+        f"Learn more and upgrade: {UPGRADE_URL}"
+    )

dblift-2.6.1/db/plugins/_pg_compatible.py

@@ -0,0 +1,150 @@
+"""Factory for PostgreSQL-wire-compatible distribution plugins.
+
+Several engines (Neon, Supabase, Aurora PostgreSQL, AlloyDB, YugabyteDB,
+TimescaleDB, Citus) speak the PostgreSQL wire protocol and reuse PostgreSQL's
+provider, config, SQLAlchemy URL builder, and ``psycopg`` driver wholesale.
+Their only per-engine content is *identity*, not *behavior*:
+
+* a ``canonical_dialect_key`` on the provider, and
+* a quirks subclass that resets the two "reference dialect" flags to ``False``
+  (exactly one registered plugin — PostgreSQL — may own each, see
+  :meth:`ProviderRegistry.reference_dialect_name`).
+
+Historically each such engine shipped three near-identical files
+(``provider.py`` / ``quirks.py`` / ``plugin.py``) that differed only by a name
+string. This module collapses that boilerplate: :func:`make_pg_compatible_plugin`
+builds the provider class, the quirks class, and the :class:`PluginInfo` from a
+single dialect name, so a new PG-wire engine is one declaration in its
+``plugin.py``.
+
+Engines with genuine behavioral differences (CockroachDB's table locking,
+Redshift's catalog/history SQL) are **not** built here — they keep hand-written
+provider/quirks classes.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, List, Optional, Type
+
+from db.base_provider import BaseProvider
+from db.plugins.postgresql.provider import PostgreSqlProvider
+from db.plugins.postgresql.quirks import PostgresqlQuirks
+from db.plugins.postgresql.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+
+def _class_stem(dialect: str) -> str:
+    """Derive the CamelCase class-name stem from a dialect key.
+
+    ``"neon"`` -> ``"Neon"``; ``"aurora-postgresql"`` -> ``"AuroraPostgresql"``.
+    Kept deliberately simple (``str.capitalize`` per hyphen segment) so the
+    generated names match the ``<Stem>Provider`` / ``<Stem>Quirks`` strings the
+    plugin-contract tests assert.
+    """
+    return "".join(part.capitalize() for part in dialect.split("-"))
+
+
+def _register_global(cls: type) -> type:
+    """Expose a factory-built class as a module global.
+
+    ``type(...)`` sets ``__module__`` to this module, so ``pickle`` (and
+    anything resolving a class by qualified name, e.g. multiprocessing in
+    ``spawn`` mode) looks the class up as ``db.plugins._pg_compatible.<Name>``.
+    Registering it here makes that lookup succeed instead of raising
+    ``AttributeError``, and also lets callers ``from db.plugins._pg_compatible
+    import NeonProvider`` if they need the class directly.
+    """
+    globals()[cls.__name__] = cls
+    return cls
+
+
+def make_pg_compatible_provider(dialect: str) -> Type[PostgreSqlProvider]:
+    """Build a PostgreSQL provider subclass carrying only a distinct identity."""
+    stem = _class_stem(dialect)
+    return _register_global(
+        type(
+            f"{stem}Provider",
+            (PostgreSqlProvider,),
+            {
+                "__module__": __name__,
+                "__doc__": (
+                    f"{stem} provider — wire-compatible with PostgreSQL; reuses the "
+                    "PostgreSQL provider with a distinct dialect identity."
+                ),
+                "canonical_dialect_key": dialect,
+            },
+        )
+    )
+
+
+def make_pg_compatible_quirks(dialect: str) -> Type[PostgresqlQuirks]:
+    """Build a PostgreSQL quirks subclass that drops the reference-dialect flags.
+
+    The two flags are set in the class body (not per instance) because
+    :meth:`ProviderRegistry.canonical_dialect_name_for_capability` reads
+    ``vars(quirks_class)`` — only a class-level override makes this engine a
+    non-owner of the ANSI-reference and sqlglot-read-fallback capabilities,
+    preserving PostgreSQL as the single owner of each.
+    """
+    stem = _class_stem(dialect)
+
+    def __init__(self: PostgresqlQuirks, dialect_name: str = dialect) -> None:
+        # type()-built classes have no __class__ cell, so ``super()`` is
+        # unavailable — call the base initializer explicitly.
+        PostgresqlQuirks.__init__(self, dialect_name=dialect_name)
+
+    return _register_global(
+        type(
+            f"{stem}Quirks",
+            (PostgresqlQuirks,),
+            {
+                "__module__": __name__,
+                "__doc__": (
+                    f"{stem} quirks, inheriting every PostgreSQL quirk. Only the "
+                    "reference-dialect flags are reset so PostgreSQL stays the sole "
+                    "owner of each."
+                ),
+                "is_ansi_reference_dialect": False,
+                "is_default_sqlglot_read_fallback": False,
+                "__init__": __init__,
+            },
+        )
+    )
+
+
+def make_pg_compatible_plugin(
+    dialect: str,
+    description: str,
+    *,
+    dialects: Optional[List[str]] = None,
+    version: str = "1.0.0",
+    sqlalchemy_url_builder: Callable[..., str] = build_sqlalchemy_url,
+    native_driver_module: str = "psycopg",
+) -> PluginInfo:
+    """Assemble the :class:`PluginInfo` for a PostgreSQL-wire-compatible engine.
+
+    Reuses PostgreSQL's config (``config_dialect="postgresql"``), URL builder,
+    and driver; only the identity (provider/quirks classes + dialect key) is
+    engine-specific. ``dialects`` defaults to ``[dialect]``.
+    """
+    provider_class: Type[BaseProvider] = make_pg_compatible_provider(dialect)
+    quirks_class = make_pg_compatible_quirks(dialect)
+    return PluginInfo(
+        name=dialect,
+        version=version,
+        description=description,
+        dialects=dialects if dialects is not None else [dialect],
+        provider_class=provider_class,
+        transport="native",
+        quirks_class=quirks_class,
+        config_dialect="postgresql",  # lint: allow-dialect-string: reuse PG config class
+        sqlalchemy_url_builder=sqlalchemy_url_builder,
+        native_driver_module=native_driver_module,
+    )
+
+
+__all__ = [
+    "make_pg_compatible_provider",
+    "make_pg_compatible_quirks",
+    "make_pg_compatible_plugin",
+]

dblift-2.6.1/db/plugins/alloydb/__init__.py

@@ -0,0 +1,12 @@
+"""Google AlloyDB for PostgreSQL database provider plugin package (PostgreSQL-compatible).
+
+The provider and quirks classes are built by the shared factory invoked in
+``plugin.py`` (:mod:`db.plugins._pg_compatible`); this package intentionally
+ships no ``provider.py`` / ``quirks.py``.
+"""
+
+__plugin_name__ = "alloydb"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Google AlloyDB for PostgreSQL database provider"
+__plugin_dialects__ = ["alloydb"]
+__plugin_transport__ = "native"

dblift-2.6.1/db/plugins/alloydb/plugin.py

@@ -0,0 +1,18 @@
+"""Entry-point declaration for the alloydb plugin.
+
+This engine is wire-compatible with PostgreSQL, so it reuses PostgreSQL's
+provider, config, SQLAlchemy URL builder, and ``psycopg`` driver through the
+shared factory in :mod:`db.plugins._pg_compatible`, attaching only a distinct
+dialect identity. Users keep their ``postgresql://`` connection string and
+select this engine via ``type: alloydb``.
+"""
+
+from __future__ import annotations
+
+from db.plugins._pg_compatible import make_pg_compatible_plugin
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = make_pg_compatible_plugin(
+    "alloydb",
+    "Google AlloyDB for PostgreSQL database provider",
+)

dblift-2.6.1/db/plugins/aurora_postgresql/__init__.py

@@ -0,0 +1,12 @@
+"""Amazon Aurora PostgreSQL database provider plugin package (PostgreSQL-compatible).
+
+The provider and quirks classes are built by the shared factory invoked in
+``plugin.py`` (:mod:`db.plugins._pg_compatible`); this package intentionally
+ships no ``provider.py`` / ``quirks.py``.
+"""
+
+__plugin_name__ = "aurora-postgresql"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Amazon Aurora PostgreSQL database provider"
+__plugin_dialects__ = ["aurora-postgresql"]
+__plugin_transport__ = "native"

dblift-2.6.1/db/plugins/aurora_postgresql/plugin.py

@@ -0,0 +1,18 @@
+"""Entry-point declaration for the aurora-postgresql plugin.
+
+This engine is wire-compatible with PostgreSQL, so it reuses PostgreSQL's
+provider, config, SQLAlchemy URL builder, and ``psycopg`` driver through the
+shared factory in :mod:`db.plugins._pg_compatible`, attaching only a distinct
+dialect identity. Users keep their ``postgresql://`` connection string and
+select this engine via ``type: aurora-postgresql``.
+"""
+
+from __future__ import annotations
+
+from db.plugins._pg_compatible import make_pg_compatible_plugin
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = make_pg_compatible_plugin(
+    "aurora-postgresql",
+    "Amazon Aurora PostgreSQL database provider",
+)

dblift-2.6.1/db/plugins/citus/__init__.py

@@ -0,0 +1,12 @@
+"""Citus (distributed PostgreSQL) database provider plugin package (PostgreSQL-compatible).
+
+The provider and quirks classes are built by the shared factory invoked in
+``plugin.py`` (:mod:`db.plugins._pg_compatible`); this package intentionally
+ships no ``provider.py`` / ``quirks.py``.
+"""
+
+__plugin_name__ = "citus"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Citus (distributed PostgreSQL) database provider"
+__plugin_dialects__ = ["citus"]
+__plugin_transport__ = "native"