dblift 2.1.1__tar.gz → 2.2.1__tar.gz

{dblift-2.1.1 → dblift-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 2.1.1
+Version: 2.2.1
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

dblift-2.2.1/api/__init__.py

@@ -0,0 +1,16 @@
+"""Public API for DBLift library integration.
+
+This module provides a clean Python API for using DBLift programmatically,
+enabling integration with IDEs, CI/CD pipelines, and other development tools.
+"""
+
+from api.client import DBLiftClient
+from api.events import EventEmitter, EventType
+from api.migrations import MigrationContext
+
+__all__ = [  # noqa: F822
+    "DBLiftClient",
+    "EventEmitter",
+    "EventType",
+    "MigrationContext",
+]

{dblift-2.1.1 → dblift-2.2.1}/api/_client_operations.py

@@ -1,4 +1,8 @@
-"""Private operation helpers for OSS :mod:`api.client`."""
+"""Private operation helpers for :mod:`api.client`.
+
+Keep large operation bodies out of ``DBLiftClient`` so the public client class
+stays readable while preserving the same public methods and behavior.
+"""
 
 from __future__ import annotations
 
@@ -19,7 +23,7 @@ def _heuristic_statement_count_from_sql(sql_text: str) -> int:
 
 
 def _apply_sql_script_warning_scan(
-    result: GenerateUndoScriptResult,
+    result: Union[Any, GenerateUndoScriptResult],
     sql_text: str,
 ) -> None:
     """Set manual-review flag and collect per-line warnings from generated SQL text."""

{dblift-2.1.1 → dblift-2.2.1}/api/client.py

@@ -1,7 +1,6 @@
 """Main client for programmatic access to DBLift."""
 
 from functools import wraps
-from importlib import import_module
 from pathlib import Path
 from types import TracebackType
 from typing import (
@@ -25,10 +24,7 @@ from api._client_factory import (
     normalize_migrations_dirs,
     resolve_config_or_raise,
 )
-from api._client_operations import (
-    generate_undo_script_operation,
-    generate_undo_scripts_operation,
-)
+from api._client_operations import generate_undo_script_operation, generate_undo_scripts_operation
 from api.events import EventEmitter, EventType, use_client_emitter
 from config import DbliftConfig
 from core.logger.results import (
@@ -44,6 +40,7 @@ from core.logger.results import (
 )
 from core.migration.executor.migration_executor import MigrationExecutor
 from core.seams.event_listeners import attach_registered_listeners
+from core.seams.feature_loading import load_feature_extensions
 from db.base_provider import BaseProvider
 from db.provider_interfaces import ConnectionProvider, TransactionalProvider
 
@@ -119,6 +116,13 @@ class DBLiftClient:
             log_file: Optional log file path; omit to keep ``config`` values
             **kwargs: Additional configuration options
         """
+        # Feature registrations from installed add-on packages must load for
+        # every client construction path, not just CLI startup — otherwise the
+        # runtime-check and tier-resolver seams would silently no-op for
+        # API-only usage. Idempotent (module-level once-flag), so double-loading
+        # with the CLI's own call is harmless.
+        load_feature_extensions()
+
         # Resolve config before logger so defaults come from merged config (e.g. from file).
         config = resolve_config_or_raise(provider, config)
 

{dblift-2.1.1 → dblift-2.2.1}/cli/_command_handlers.py

@@ -43,7 +43,9 @@ if _builtin_conflicts:
 _COMMAND_HANDLERS.update(_extension_handlers)
 del _extension_handlers, _builtin_conflicts
 
-_AVAILABLE_COMMANDS = list(_COMMAND_HANDLERS.keys()) + ["db"] + list(load_terminal_commands())
+_AVAILABLE_COMMANDS = (
+    list(_COMMAND_HANDLERS.keys()) + ["db", "config"] + list(load_terminal_commands())
+)
 
 
 def execute_single_command(

{dblift-2.1.1 → dblift-2.2.1}/cli/_config_helpers.py

@@ -35,15 +35,37 @@ _SUBCOMMAND_BOOLEAN_FLAGS = frozenset(
         "--clean-disabled",
         "--clean-enabled",
         "--dry-run",
+        "--generate-sql",
+        "--ignore-unmanaged",
+        "--include-drops",
+        "--keep-container",
+        "--managed-only",
         "--mark-as-executed",
+        "--no-performance",
         "--show-sql",
+        "--rehearse-rollback",
+        "--skip-replay",
         "--skip-validation",
+        "--skip-validate-sql",
+        "--split-by-type",
         "--strict",
+        "--unmanaged-only",
         "--validate-only",
     }
 )
 
 
+def _command_handler_attr(command: Optional[str], attr_name: str, default: Any = None) -> Any:
+    if not command:
+        return default
+    from cli._command_handlers import _COMMAND_HANDLERS
+
+    handler = _COMMAND_HANDLERS.get(command)
+    if handler is None:
+        return default
+    return getattr(handler, attr_name, default)
+
+
 def _extract_commands_from_argv(
     argv_list: List[str],
     available_commands: List[str],
@@ -257,16 +279,21 @@ def _load_and_merge_config(args: argparse.Namespace, log: Any) -> Any:
         db_overrides["schema"] = args.database_schema
 
     if db_overrides:
-        # Resolve secret URIs in CLI overrides.
-        from config.secrets._resolver import resolve_secret_refs
+        command = getattr(args, "command", None)
+        commands_list = getattr(args, "commands_list", None) or ([command] if command else [])
+        is_offline = len(commands_list) == 1 and bool(
+            _command_handler_attr(command, "_dblift_skip_secret_resolution", False)
+        )
+        if not is_offline:
+            from config.secrets._resolver import resolve_secret_refs
 
-        try:
-            db_overrides = resolve_secret_refs({"database": db_overrides}, config.secrets).get(
-                "database", db_overrides
-            )
-        except SecretsResolutionError as e:
-            print(f"Error: {e}", file=sys.stderr)
-            sys.exit(1)
+            try:
+                db_overrides = resolve_secret_refs({"database": db_overrides}, config.secrets).get(
+                    "database", db_overrides
+                )
+            except SecretsResolutionError as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
         config.database = ConfigBuilder.merge_database_overrides(config.database, db_overrides)
 
     if log:
@@ -321,7 +348,7 @@ def _validate_db_config(
     if commands and commands[0] == "db":
         return
 
-    migration_commands = [
+    migration_commands = {
         "migrate",
         "undo",
         "clean",
@@ -330,7 +357,9 @@ def _validate_db_config(
         "repair",
         "import-flyway",
         "baseline",
-    ]
+    }
+    if _command_handler_attr(args.command, "_dblift_validate_db_config", False):
+        migration_commands.add(args.command)
     if args.command not in migration_commands:
         return
 

{dblift-2.1.1 → dblift-2.2.1}/cli/_output.py

@@ -13,7 +13,8 @@ dispatch in ``cli/main.py`` re-derive the same predicate:
     else:
         ctx.log.info(payload)          # routed through ConsoleLog
 
-That duplication has already caused banner-routing regressions. ADR-0005 added the
+That duplication has already caused two regressions (PR 158 banner fix
++ PR-01 machine-format scope). ADR-0005 added the
 `MACHINE_READABLE_FORMATS` set as a single source of truth; this
 module does the same for the *routing* decision itself.
 

{dblift-2.1.1 → dblift-2.2.1}/cli/_parser_setup.py

@@ -106,6 +106,57 @@ def _make_history_table_parent() -> argparse.ArgumentParser:
     return p
 
 
+def _add_registry_flags(parser: argparse.ArgumentParser) -> None:
+    """Emit a --flag for every registry property that lacks one.
+
+    Skips properties that are cli_only, cli_exempt, nested (database.*), or
+    already covered by a legacy flag recorded in cli_aliases. Ensures any NEW
+    persistent property added to the registry automatically gets a CLI flag,
+    so the CLI surface can never silently drift from config/env again.
+    """
+    from config.property_registry import PROPERTY_REGISTRY
+
+    deferred_specs = {"max_snapshots", "snapshot_table"}
+
+    # Collect option strings across the WHOLE tree (root + every subparser), not
+    # just the root parser. Many registry properties (e.g. --tags,
+    # --target-version, --snapshot-table) intentionally live only on specific
+    # subcommands; a root-only ``existing`` set would treat them as missing and
+    # emit a duplicate root flag, colliding with the subparser dest. This helper
+    # therefore runs AFTER subparsers are registered so the tree walk sees them.
+    existing: set[str] = set()
+
+    def _collect(p: argparse.ArgumentParser) -> None:
+        for action in p._actions:
+            existing.update(action.option_strings)
+            choices = getattr(action, "choices", None)
+            if isinstance(choices, dict):
+                for sub in choices.values():
+                    if isinstance(sub, argparse.ArgumentParser):
+                        _collect(sub)
+
+    _collect(parser)
+    for spec in PROPERTY_REGISTRY:
+        if spec.cli_only or spec.cli_exempt or "." in spec.name:
+            continue
+        if spec.name in deferred_specs:
+            continue
+        if spec.cli_aliases:
+            continue  # legacy flag (e.g. --table, --strict) already provides the surface
+        if spec.cli in existing:
+            continue
+        if spec.type == "bool":
+            parser.add_argument(
+                spec.cli, dest=spec.name, action="store_true", default=None, help=spec.help
+            )
+        elif spec.type == "int":
+            parser.add_argument(spec.cli, dest=spec.name, type=int, default=None, help=spec.help)
+        elif spec.type == "float":
+            parser.add_argument(spec.cli, dest=spec.name, type=float, default=None, help=spec.help)
+        else:
+            parser.add_argument(spec.cli, dest=spec.name, default=None, help=spec.help)
+
+
 def _make_snapshot_table_parent() -> argparse.ArgumentParser:
     """Parent parser for explicit snapshot storage commands."""
     p = argparse.ArgumentParser(add_help=False)
@@ -155,7 +206,7 @@ def _make_filter_parent() -> argparse.ArgumentParser:
 
 # NOTE: ``--target-version`` is intentionally NOT extracted into a parent
 # parser. Its help text is genuinely command-specific (migrate / undo /
-# diff each describe a different intent) and unifying it would degrade
+# validate each describe a different intent) and unifying it would degrade
 # `--help` output. Each subparser adds it explicitly in
 # ``_add_diff_and_target_options`` so the user-facing string stays
 # accurate. See Bugbot review on PR-09.
@@ -185,13 +236,12 @@ def _add_baseline_options(baseline_parser: argparse.ArgumentParser) -> None:
 
 
 def _add_diff_and_target_options(
-    diff_parser: argparse.ArgumentParser | None,
     migrate_parser: argparse.ArgumentParser,
     undo_parser: argparse.ArgumentParser,
     validate_parser: argparse.ArgumentParser,
     clean_parser: argparse.ArgumentParser,
 ) -> None:
-    """Configure diff/migrate/undo/validate/clean subcommand-specific options.
+    """Configure migrate/undo/validate/clean subcommand-specific options.
 
     ``--target-version`` is added per-command (rather than via a shared
     parent parser) because each command has a meaningfully different
@@ -243,6 +293,21 @@ def _add_diff_and_target_options(
     )
 
 
+def _register_builtin_command_parsers(
+    parser: argparse.ArgumentParser,
+) -> list[argparse.ArgumentParser]:
+    """Register first-party command parsers that remain in the OSS CLI."""
+    subparser_actions = [
+        action for action in parser._actions if isinstance(action, argparse._SubParsersAction)
+    ]
+    if not subparser_actions:
+        return []
+
+    registered: list[argparse.ArgumentParser] = []
+
+    return registered
+
+
 def create_parser(
     exit_on_error: bool = True, suppress_errors: bool = False
 ) -> argparse.ArgumentParser:
@@ -307,6 +372,11 @@ def create_parser(
         ),
     )
     parser.add_argument("--dry-run", action="store_true", help="Dry run mode")
+    parser.add_argument(
+        "--installed-by",
+        dest="installed_by",
+        help="Value recorded in the installed_by column (default: database username)",
+    )
     parser.add_argument("--log-dir", default="logs", help="Log directory")
     parser.add_argument("--log-format", default="text", help="Log format (text, json, html)")
     parser.add_argument(
@@ -389,10 +459,10 @@ def create_parser(
         default="flyway_schema_history",
         help="Source Flyway schema history table name (default: flyway_schema_history)",
     )
-    builtin_extension_parsers: list[argparse.ArgumentParser] = []
+    builtin_extension_parsers = _register_builtin_command_parsers(parser)
     # Configure arguments via extracted functions
     _add_baseline_options(baseline_parser)
-    _add_diff_and_target_options(None, migrate_parser, undo_parser, validate_parser, clean_parser)
+    _add_diff_and_target_options(migrate_parser, undo_parser, validate_parser, clean_parser)
     # info --format option (JSON output for scripting)
     info_parser.add_argument(
         "--format",
@@ -404,7 +474,21 @@ def create_parser(
     db_parser = subparsers.add_parser("db", help="Database utility commands")
     db_subparsers = db_parser.add_subparsers(dest="db_command", required=True)
     setup_db_utils_parser(db_subparsers)
+    # Configuration introspection: `dblift config --list` prints every persistent
+    # property and its three surfaces (config key / env var / CLI flag). Distinct
+    # from the global `--config <path>` option — a subcommand named ``config`` and
+    # an optional ``--config`` flag do not collide in argparse.
+    config_parser = subparsers.add_parser("config", help="Inspect dblift configuration")
+    config_parser.add_argument(
+        "--list",
+        action="store_true",
+        help="List all properties and how to set them (config key / env var / CLI flag)",
+    )
     import_module("cli.extensions").load_command_extensions(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.
+    _add_registry_flags(parser)
     if suppress_errors:
         all_subparsers = [
             migrate_parser,

dblift-2.2.1/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""First-party CLI command handlers that own their own dispatch."""

dblift-2.2.1/cli/commands/config_command.py

@@ -0,0 +1,48 @@
+"""``dblift config --list`` — print every persistent property and its surfaces."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from config.property_registry import PROPERTY_REGISTRY, PropertySpec
+from core.logger.console import render_records_table
+
+
+def _cli_display(spec: PropertySpec) -> str:
+    """The real CLI flag for a property: '(none)' if cli-exempt, the legacy
+    alias if one is registered, else the derived flag."""
+    if spec.cli_exempt:
+        return "(none)"
+    if spec.cli_aliases:
+        return str(spec.cli_aliases[0])
+    return spec.cli
+
+
+def build_property_table() -> List[Dict[str, str]]:
+    """Return one row per registry property with its config key, env var, CLI flag, and default."""
+    rows: List[Dict[str, str]] = []
+    for spec in PROPERTY_REGISTRY:
+        rows.append(
+            {
+                "name": spec.name,
+                "config": spec.name,
+                "env": spec.env,
+                "cli": _cli_display(spec),
+                "default": "" if spec.default is None else str(spec.default),
+            }
+        )
+    return rows
+
+
+def run_config_command(args: Any) -> int:
+    """Print the property/env/CLI surface table for ``dblift config --list``; return 0."""
+    rows = build_property_table()
+    table = render_records_table(
+        [("PROPERTY", "left"), ("ENV VAR", "left"), ("CLI FLAG", "left")],
+        [[r["name"], r["env"], r["cli"]] for r in rows],
+        title="dblift configuration properties",
+    )
+    print(
+        table
+    )  # lint: allow-print  config --list self-documentation (pre-CommandOutput short-circuit)
+    return 0

{dblift-2.1.1 → dblift-2.2.1}/cli/handlers/_shared.py

@@ -12,11 +12,9 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from core.features import FeatureTier
-
-# Flyway-compatible migration filename patterns used to skip non-migration
-# SQL files when scanning a directory (e.g. leftover temp files, schema
-# dumps) so only intentional migration scripts are
+# Flyway-compatible migration filename patterns — used by SQL-file validation to
+# skip non-migration SQL files when scanning a directory (e.g. leftover
+# temp files, schema dumps) so only intentional migration scripts are
 # checked. Explicitly-listed files are always validated regardless of name.
 _MIGRATION_FILENAME_RE = re.compile(
     r"^[VRUBvrub][\d_.]*__.*\.sql$",
@@ -61,9 +59,21 @@ class CliCommandContext:
     # Migration configuration
     placeholders: Dict[str, Any] = field(default_factory=dict)
     dir_recursive_map: Dict[Path, bool] = field(default_factory=dict)
-    # License tier for feature-level gates. execute_single_command supplies
-    # the real CLI-resolved tier; the default keeps direct handler tests terse.
-    license_tier: FeatureTier = FeatureTier.ENTERPRISE
+    # License tier for feature-level gates. Opaque to OSS (see
+    # core.seams.tier_resolver) — execute_single_command supplies the real
+    # CLI-resolved tier; paid-tier handler tests must pass their own tier
+    # explicitly since OSS no longer has a permissive default to fall back on.
+    license_tier: Any = None
+
+
+@dataclass
+class ConfigOnlyClient:
+    """Config-only stand-in for commands that do not need a live provider."""
+
+    config: Any
+
+
+ValidateSqlConfigClient = ConfigOnlyClient
 
 
 def _set_command_completed(log: Any, result: Any, command_type: str) -> None:
@@ -92,7 +102,7 @@ def emit_rendered_output(
 ) -> None:
     """Dispatch a rendered command output to machine channel, logger, and/or file.
 
-    Used by command handlers that follow the same machine/human/file
+    Shared by extension report handlers that follow the same machine/human/file
     dispatch pattern once the command-specific rendering is done.
     """
     if command_output.is_machine_format:
@@ -111,7 +121,7 @@ def emit_rendered_output(
 
 
 def _extract_version_filters(args: Any) -> tuple[Any, Any, Any, Any, Any]:
-    """Extract version/tag filter arguments common to migrate, undo, validate, info, diff handlers.
+    """Extract version/tag filter arguments common to filtered migration handlers.
 
     Returns:
         Tuple (target_version, versions, exclude_versions, tags, exclude_tags),

{dblift-2.1.1 → dblift-2.2.1}/cli/main.py

@@ -50,13 +50,9 @@ from cli._config_helpers import (  # noqa: F401
     _validate_log_format_for_cli,
 )
 from cli._output import CommandOutput, from_args
-from cli._parser_setup import (  # noqa: F401
-    _add_baseline_options,
-    _add_diff_and_target_options,
-    create_parser,
-    parse_with_selective_errors,
-)
+from cli._parser_setup import create_parser, parse_with_selective_errors
 from cli.extensions import load_terminal_commands
+from core.seams.feature_loading import load_feature_extensions
 
 # Module-level placeholder; main() uses a local 'log' variable (no global declaration)
 log = None
@@ -102,6 +98,13 @@ _GLOBAL_ONLY_ARGS: List[str] = [
     "--quiet",
     "-q",
     "--no-progress",
+    # Root-only value flags. They live only on the root parser, so — like the
+    # other root-only value flags above — they must be classified global or the
+    # argv preprocessor relocates them past the subcommand token and the
+    # subparser rejects them as "unrecognized arguments". Covered by
+    # tests/unit/cli/test_global_only_args_completeness.py.
+    "--installed-by",
+    "--max-snapshots",
 ]
 
 # Tool-level flag aliases for subcommands that take their own version-like
@@ -154,6 +157,7 @@ def main() -> None:
     from core.logger.console import install_rich_traceback
 
     install_rich_traceback()
+    load_feature_extensions()
 
     ctx = _parse_argv_and_load_config(sys.argv[1:])
     command_output = _setup_logging_and_output(ctx)
@@ -227,12 +231,22 @@ def _parse_argv_and_load_config(argv: List[str]) -> _CliContext:
     if not commands and hasattr(args, "command"):
         commands = [args.command]
 
+    # `dblift config --list` is offline self-documentation: it reads only the
+    # property registry, so it short-circuits here — before any config/db load —
+    # exactly like the `db` subcommand path below. Listing is the command's only
+    # behaviour today, so it runs whether or not --list was passed.
+    if commands and commands[0] == "config":
+        from cli.commands.config_command import run_config_command
+
+        sys.exit(run_config_command(args))
+
     log = LogFactory.get_log("Dblift")
     parser = create_parser()
     # Validate log format before any config load so bogus --log-format fails with argparse
     # UX (and so db/* commands are covered — _validate_db_config skips early for "db").
     _validate_log_format_for_cli(args, parser)
-    # Attach the full command list so load_config can see chained invocations.
+    # Attach the full command list so config loading can distinguish
+    # single-command config-only flows from chained invocations.
     args.commands_list = commands
     config = None if commands[0] == "db" else _load_and_merge_config(args, log)
     _validate_db_config(args, config, parser, commands)
@@ -258,6 +272,15 @@ def _build_terminal_args(
     return args
 
 
+def _command_handler_attr(command: Optional[str], attr_name: str, default: Any = None) -> Any:
+    if not command:
+        return default
+    handler = _COMMAND_HANDLERS.get(command)
+    if handler is None:
+        return default
+    return getattr(handler, attr_name, default)
+
+
 def _setup_logging_and_output(ctx: _CliContext) -> CommandOutput:
     """Phase 3: configure logging, build :class:`CommandOutput`.
 
@@ -287,12 +310,26 @@ def _setup_logging_and_output(ctx: _CliContext) -> CommandOutput:
     assert ctx.config is not None
     ctx.log = _configure_logging(ctx.args, ctx.config, ctx.parser)
 
+    _apply_configured_output_format(ctx)
+
     # Banner routing is centralised in :class:`cli._output.CommandOutput`
     # (ADR-0008 supersedes ADR-0005's suppression approach). Machine
     # mode routes the banner to stderr; human mode keeps it on stdout.
     return from_args(ctx.args)
 
 
+def _apply_configured_output_format(ctx: _CliContext) -> None:
+    """Use handler-provided config defaults before top-level banner routing."""
+    if len(ctx.commands) != 1 or getattr(ctx.args, "format", None):
+        return
+    resolver = _command_handler_attr(ctx.commands[0], "_dblift_configured_output_format")
+    if not callable(resolver):
+        return
+    output_format = resolver(ctx.args, ctx.config)
+    if output_format:
+        ctx.args.format = output_format
+
+
 def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
     """Phase 4: build full workflow context and run the command loop.
 
@@ -316,7 +353,6 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
         ctx.log.debug(f"Using placeholders: {placeholders}")
 
     ctx.config.journal_enabled = True
-    ctx.config.journal_dir = None
     if getattr(ctx.args, "strict", False):
         ctx.config.strict_mode = True
         ctx.log.info(
@@ -344,6 +380,13 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
         # in base_command does not re-emit it (it also has no format awareness).
         if main_header:
             base_command._console_main_header_printed = True  # type: ignore[attr-defined]
+            for command in ctx.commands:
+                handler = _COMMAND_HANDLERS.get(command)
+                if handler is None:
+                    continue
+                command_module = sys.modules.get(handler.__module__)
+                if command_module is not None:
+                    command_module._console_main_header_printed = True  # type: ignore[attr-defined]
 
         for cmd_index, command in enumerate(ctx.commands):
             if len(ctx.commands) > 1 and cmd_index > 0:

{dblift-2.1.1 → dblift-2.2.1}/config/database_config.py

@@ -199,9 +199,9 @@ def _apply_url_overrides(cls: Type["BaseDatabaseConfig"], data: Dict[str, Any])
         if url_lower.startswith("jdbc:"):
             raise ValueError("Legacy database URLs are no longer supported; use a SQLAlchemy URL")
         # _allow_incomplete is set when the URL could not be parsed (e.g. an
-        # unresolved secret URI in offline mode). Skip hydration/inference so
-        # an unresolved secret URI doesn't mutate fields before a connection
-        # is opened.
+        # unresolved secret URI in offline mode). Skip hydration/inference so that
+        # `dblift plan` with `database.url: vault://...` doesn't mutate fields from
+        # the secret URI before a connection is opened.
         if data.get("_allow_incomplete"):
             return
         if ProviderRegistry.is_native_dialect(db_type):