dbtk 0.8.2__tar.gz → 0.8.4__tar.gz

{dbtk-0.8.2 → dbtk-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbtk
-Version: 0.8.2
+Version: 0.8.4
 Summary: Data Benders Toolkit - A lightweight toolkit for data integration, ELT and ETL
 Author: Scott Bailey <scottrbailey@gmail.com>
 License: MIT
@@ -43,7 +43,6 @@ Requires-Dist: usaddress==0.5.10; python_version < "3.7" and extra == "recommend
 Requires-Dist: usaddress>=0.5.11; python_version >= "3.7" and extra == "recommended"
 Provides-Extra: postgresql
 Requires-Dist: psycopg2-binary>=2.9; extra == "postgresql"
-Requires-Dist: psycopg[binary]>=3.1; extra == "postgresql"
 Provides-Extra: oracle
 Requires-Dist: oracledb>=1.0; python_version >= "3.7" and extra == "oracle"
 Requires-Dist: cx_Oracle>=8.0; python_version < "3.7" and extra == "oracle"
@@ -58,8 +57,13 @@ Requires-Dist: openpyxl>=3.0.0; extra == "all"
 Requires-Dist: xlrd>=1.2.0; extra == "all"
 Requires-Dist: phonenumbers>=8.12.0; extra == "all"
 Requires-Dist: python-dateutil>=2.8.0; extra == "all"
-Requires-Dist: usaddress==0.5.10; python_version < "3.7" and extra == "all"
 Requires-Dist: usaddress>=0.5.11; python_version >= "3.7" and extra == "all"
+Requires-Dist: usaddress==0.5.10; python_version < "3.7" and extra == "all"
+Requires-Dist: oracledb>=1.0; python_version >= "3.7" and extra == "all"
+Requires-Dist: cx_Oracle>=8.0; python_version < "3.7" and extra == "all"
+Requires-Dist: psycopg2-binary>=2.9; extra == "all"
+Requires-Dist: pymysql>=1.0; extra == "all"
+Requires-Dist: pyodbc<5.0,>=4.0.21; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-cov>=2.10; extra == "dev"
@@ -110,13 +114,17 @@ that you stay in control. When something breaks, you know exactly where to look.
 The architecture is intentionally layered — use what you need, skip what you don't:
 
 ```
+Configuration   → encrypted YAML, env vars, named connections, driver overrides, smart logging
+Connection      → consistent connection and parameter handling, clean reference hierarchy
 Record          → ergonomic row handling, memory-efficient at scale
 Table           → field mapping, transforms, validation, upserts
 DataSurge       → batched inserts with progress tracking and stats
 BulkSurge       → direct bulk loads (SQL*Loader, BCP, COPY) for maximum throughput
-readers/writers → consistent API across every file format and compression type
+Readers/Writers → consistent API across every file format and compression type
 ```
 
+<img src="https://raw.githubusercontent.com/scottrbailey/dbtk/main/docs/assets/dbtk_flowchart.png" width="800" align="center" />
+
 When developers convert existing jobs to DBTK, the result can be **half to a quarter the
 original code**. That reduction comes from specific things DBTK just handles:
 
@@ -137,7 +145,7 @@ finish the job and think *"that was satisfyingly elegant"* — not because corne
 because the tool was collaborating with you instead of making you fight it.
 
 **Speed and Memory** The primary objective of DBTK is to give data integrators an elegant toolkit to speed up your development.
-But DBTK's throughput and memory usage are very good. BulkSurge streaming from a polars and doing direct loads to PostgreSQL will
+But DBTK's throughput and memory usage are very good. BulkSurge streaming from polars and doing direct loads to PostgreSQL will
 process 1M rows in 3-4 seconds. But even with a standard Python csv reader and numerous column transforms, DataSurge is able to
 write 1M rows to every supported database in 5-10 seconds.
 

{dbtk-0.8.2 → dbtk-0.8.4}/README.md

@@ -39,13 +39,17 @@ that you stay in control. When something breaks, you know exactly where to look.
 The architecture is intentionally layered — use what you need, skip what you don't:
 
 ```
+Configuration   → encrypted YAML, env vars, named connections, driver overrides, smart logging
+Connection      → consistent connection and parameter handling, clean reference hierarchy
 Record          → ergonomic row handling, memory-efficient at scale
 Table           → field mapping, transforms, validation, upserts
 DataSurge       → batched inserts with progress tracking and stats
 BulkSurge       → direct bulk loads (SQL*Loader, BCP, COPY) for maximum throughput
-readers/writers → consistent API across every file format and compression type
+Readers/Writers → consistent API across every file format and compression type
 ```
 
+<img src="https://raw.githubusercontent.com/scottrbailey/dbtk/main/docs/assets/dbtk_flowchart.png" width="800" align="center" />
+
 When developers convert existing jobs to DBTK, the result can be **half to a quarter the
 original code**. That reduction comes from specific things DBTK just handles:
 
@@ -66,7 +70,7 @@ finish the job and think *"that was satisfyingly elegant"* — not because corne
 because the tool was collaborating with you instead of making you fight it.
 
 **Speed and Memory** The primary objective of DBTK is to give data integrators an elegant toolkit to speed up your development.
-But DBTK's throughput and memory usage are very good. BulkSurge streaming from a polars and doing direct loads to PostgreSQL will
+But DBTK's throughput and memory usage are very good. BulkSurge streaming from polars and doing direct loads to PostgreSQL will
 process 1M rows in 3-4 seconds. But even with a standard Python csv reader and numerous column transforms, DataSurge is able to
 write 1M rows to every supported database in 5-10 seconds.
 

{dbtk-0.8.2 → dbtk-0.8.4}/dbtk/__init__.py

@@ -29,13 +29,15 @@ Direct connections:
     cursor = db.cursor()  # Returns Record objects
 """
 
-__version__ = '0.8.0'
+__version__ = '0.8.4'
 __author__ = 'Scott Bailey <scottrbailey@gmail.com>'
 
 from .database import Database
 from .config import connect, set_config_file
-from .cursors import Cursor
+from .cursors import Cursor, PreparedStatement
 from .logging_utils import setup_logging, cleanup_old_logs, errors_logged
+from .record import fixed_record_factory, FixedWidthRecord
+from .utils import FixedColumn
 from . import readers
 from . import writers
 from . import etl
@@ -45,6 +47,10 @@ __all__ = [
     'connect',
     'Database',
     'Cursor',
+    'PreparedStatement',
+    'FixedColumn',
+    'FixedWidthRecord',
+    'fixed_record_factory',
     'etl',
     'readers',
     'writers',

{dbtk-0.8.2 → dbtk-0.8.4}/dbtk/cli.py

@@ -4,6 +4,7 @@ import argparse
 import importlib.util
 import sys
 from .database import _get_all_drivers
+from .record import fixed_record_factory
 from . import config
 
 try:
@@ -51,18 +52,23 @@ def checkup():
             deps.append(dep.split('>=')[0].split('==')[0].split('<')[0].strip())
 
     installed = {_name_cleanup(d.name): d.version for d in distributions()}
-
-    print(f"{'Package':<20} {'Status':<8} {'Version'}")
-    print("-" * 40)
+    package_rec = fixed_record_factory([('Package', 22), ('Status', 8), ('Version', 15)])
+    driver_rec = fixed_record_factory([('DB Driver', 22), ('Priority*', 10),
+                                      ('Status', 9), ('Version', 8), ('Notes', 41)])
+    row = package_rec(*package_rec._fields)
+    print(row.to_line(True))
+    print("-" * row._line_len)
 
     for dep in deps:
         clean = dep.replace('-', '_')
         status = "✓" if _is_installed(clean) else "✗"
         version = installed.get(clean.lower(), '-')
-        print(f"{dep:<20} {status:<8} {version}")
-
-    print("\nDB Drivers           Priority* Status   Version")
-    print("-" * 56)
+        row = package_rec(dep, status, version)
+        print(row.to_line(True))
+    print("")
+    row = driver_rec(*driver_rec._fields)
+    print(row.to_line(True))
+    print("-" * 80)
     all_drivers = _get_all_drivers()
     by_type = {}
 
@@ -80,9 +86,6 @@ def checkup():
         drivers = sorted(by_type[db_type], key=lambda x: x[0])
         print(f"{db_type}")  # ← bold header
         for pri, name, info in drivers:
-            # ── 2-space indent for hierarchy
-            display_name = f"  {name}"  # ← indented
-
             try:
                 # see if driver has 'module' attribute to use instead of name
                 module_name = info.get('module', name)
@@ -90,7 +93,7 @@ def checkup():
                 version = installed.get(_name_cleanup(module_name), '--    ')
                 status = "✓" if spec else "✗"
             except ModuleNotFoundError:
-                version = '--   '
+                version = '--'
                 status = "✗"
             odbc_driver_name = info.get("odbc_driver_name")
             if odbc_driver_name:
@@ -101,8 +104,8 @@ def checkup():
                     note = f'({info.get("note")})'
                 else:
                     note = ''
-
-            print(f"{display_name:<20} {pri:<9} {status:<8} {version} {note}")
+            row = driver_rec(f'  {name}', pri, status, version, note)
+            print(row.to_line(True))
 
     print("\n* Lower priority = preferred")
 

{dbtk-0.8.2 → dbtk-0.8.4}/dbtk/config.py

@@ -208,7 +208,7 @@ class ConfigManager:
     4. ``~/.config/dbtk.yml`` (user config directory)
     5. ``~/.config/dbtk.yaml`` (user config directory)
 
-    If no config is found, creates a sample config at ``~/.config/dbtk.yml``.
+    If no config is found, creates a sample config at ``~/.config/dbtk_sample.yml``.
 
     Parameters
     ----------
@@ -252,7 +252,7 @@ class ConfigManager:
     * Connections require 'type' field (postgres, oracle, mysql, etc.)
     * Encrypted passwords require DBTK_ENCRYPTION_KEY environment variable
     * Environment variables can be used with ${VAR_NAME} syntax
-    * Sample config is created at ~/.config/dbtk.yml on first run if no config exists
+    * Sample config is created at ~/.config/dbtk_sample.yml on first run if no config exists
     """
 
     def __init__(self, config_file: Optional[Union[str, Path]] = None):
@@ -337,6 +337,11 @@ class ConfigManager:
             if not isinstance(config, dict):
                 raise ValueError(f"Invalid config file {self.config_file}.")
 
+            # Normalize empty/null sections to empty dicts
+            for section in ('connections', 'passwords', 'drivers'):
+                if config.get(section) is None:
+                    config[section] = {}
+
             # Validate connections section if it exists
             if 'connections' in config:
                 for name, conn in config.get('connections', {}).items():
@@ -968,15 +973,22 @@ def setup_config() -> None:
             print("Cancelled.")
             return
 
-    # Copy dbtk_sample.yml to target location
+    # Write user config from sample, minus the example connections/passwords
     sample_path = Path(__file__).parent / 'dbtk_sample.yml'
     if not sample_path.exists():
         print(f"⚠ Sample config not found at {sample_path}")
         print("Cannot continue without sample file.")
         return
 
-    shutil.copy(sample_path, config_path)
-    print(f"\n✓ Created config from sample at {config_path}")
+    with open(sample_path) as f:
+        config_data = yaml.safe_load(f) or {}
+    # keep settings but clear out example connections, passwords and drivers sections
+    config_data['connections'] = {}
+    config_data['passwords'] = {}
+    config_data['drivers'] = {}
+    with open(config_path, 'w') as f:
+        yaml.safe_dump(config_data, f, default_flow_style=False, sort_keys=False)
+    print(f"\n✓ Created config at {config_path}")
 
     # Also copy sample to ~/.config for reference
     user_sample_path = Path.home() / '.config' / 'dbtk_sample.yml'
@@ -1065,19 +1077,9 @@ def setup_config() -> None:
     print("Database Connections")
     print("-"*60)
 
-    # Load the config we just created
-    with open(config_path) as f:
-        config_data = yaml.safe_load(f)
-
     if 'connections' not in config_data:
         config_data['connections'] = {}
 
-    print(dedent("""\
-    Warning: The config file created has lots of comments that will be lost if you continue.
-    The YAML format was designed to be readable and it is recommended to just edit in the 
-    text editor of your choice. If you do continue and overwrite the comments, a fully commented
-    sample is also available at ~/.config/dbtk_sample.yml.
-    """))
     add_connection = input("\nAdd a database connection now? [y/N]: ").strip().lower()
     edits = 0
     while add_connection in ('y', 'yes'):
@@ -1170,7 +1172,6 @@ def setup_config() -> None:
         add_connection = input("\nAdd another connection? [y/N]: ").strip().lower()
 
     if edits:
-        # Write updated config file
         with open(config_path, 'w') as f:
             yaml.safe_dump(config_data, f, default_flow_style=False, sort_keys=False)
 

{dbtk-0.8.2 → dbtk-0.8.4}/dbtk/cursors.py

@@ -4,6 +4,7 @@ Cursor classes that wrap database cursors and provide different return types.
 All cursors delegate to the underlying database cursor stored in _cursor.
 """
 
+import inspect
 import logging
 from pathlib import Path
 from typing import List, Any, Optional, Iterator, Callable, Union
@@ -16,6 +17,21 @@ logger = logging.getLogger(__name__)
 __all__ = ['Cursor', 'PreparedStatement']
 
 
+def _resolve_sql_path(filename: Union[str, Path], caller_file: str) -> Path:
+    """Resolve a SQL filename to an existing path.
+
+    Checks the path as given first (absolute or relative to CWD), then falls
+    back to the directory containing *caller_file* so that scripts can refer to
+    sibling SQL files by bare name.
+    """
+    path = Path(filename)
+    if not path.is_absolute() and not path.exists():
+        candidate = Path(caller_file).parent / path
+        if candidate.exists():
+            return candidate
+    return path
+
+
 class PreparedStatement:
     """
     A prepared SQL statement loaded from a file with cached parameter mapping.
@@ -94,11 +110,12 @@ class PreparedStatement:
 
 class Cursor:
     """
-    Basic cursor that returns query results as lists.
+    Cursor that returns query results as Records.
 
-    This is the base class for all DBTK cursor types. It wraps database-specific cursor
-    objects and provides a consistent interface plus additional functionality like SQL
-    file execution, parameter conversion, and prepared statements.
+    It wraps database-specific cursor objects and provides a consistent interface plus additional
+    functionality like SQL file execution, parameter conversion, and prepared statements.
+    It also maintains a clean reference hierarchy to the connection (cursor.connection) and
+    to the driver (cursor.connection.driver)
 
     Cursor returns Record objects, which provide flexible access via dictionary keys,
     attributes, or integer indices.
@@ -123,8 +140,8 @@ class Cursor:
     -------
     ::
 
-        # Usually created via Database.cursor()
-        cursor = db.cursor('list')
+        db = dbtk.connect('prod_ods')
+        cursor = db.cursor()
         cursor.execute("SELECT id, name, email FROM users WHERE status = :status",
                       {'status': 'active'})
 
@@ -404,9 +421,40 @@ class Cursor:
                 self._create_record_factory()
         return True
 
-    def execute(self, query: str, bind_vars: tuple = ()) -> None:
-        """Execute a database query."""
+    def execute(self, query: str,
+                bind_vars: Union[tuple, dict] = (),
+                convert_params: bool = False) -> None:
+        """
+        Execute a database query.
+
+        Pass convert_params=True to have the query rewritten to the cursor's paramstyle
+        and parameters handled automatically (same as PreparedStatement and execute_file).
+
+        Parameters
+        ----------
+        bind_vars : tuple or dict, default ()
+            Bind parameters to pass to the database.
+
+            When convert_params is False (the default), passed directly to the
+            underlying cursor and must already be in the format required by the
+            cursor's paramstyle.
+
+            When convert_params is True, must be a dict (or Record).
+
+        convert_params : bool, default False
+            If True, parameter order will be extracted from the query and the query
+            will be rewritten to match the cursor's paramstyle. Missing parameters
+            will be defaulted to None and extra parameters will be ignored.
+        """
+
         self._row_factory_invalid = True
+        if convert_params:
+            if not hasattr(bind_vars, 'items'):
+                if bind_vars:
+                    raise ValueError(f'bind_vars must be a dict when convert_params=True')
+                bind_vars = {}
+            query, param_names = process_sql_parameters(query, self.paramstyle)
+            bind_vars = self.prepare_params(param_names, bind_vars)
 
         if self.debug:
             logger.debug(f'Query:\n{query}')
@@ -433,7 +481,8 @@ class Cursor:
         executed multiple times, use prepare_file() instead for better performance.
 
         Args:
-            filename: Path to SQL file (relative to CWD)
+            filename: Path to SQL file. Resolved relative to CWD first; if not
+                found there, falls back to the directory of the calling script.
             bind_vars: Dictionary of named parameters
             **kwargs:
                 encoding: File encoding (default: utf-8-sig)
@@ -445,10 +494,11 @@ class Cursor:
             cursor.execute_file('queries/get_user.sql', {'user_id': 123})
         """
         encoding = kwargs.get('encoding', 'utf-8-sig')
+        path = _resolve_sql_path(filename, inspect.stack()[1].filename)
 
         try:
             # Read SQL from file
-            with open(filename, encoding=encoding) as f:
+            with open(path, encoding=encoding) as f:
                 sql = f.read()
 
             # Transform SQL for this cursor's paramstyle
@@ -466,7 +516,7 @@ class Cursor:
         except Exception as e:
             statement = locals().get('transformed_sql', 'N/A')
             logger.error(
-                f"Error executing SQL file: {filename}\n"
+                f"Error executing SQL file: {path}\n"
                 f"Transformed SQL: {statement}\n"
                 f"Parameters: {bind_vars}"
             )
@@ -480,7 +530,8 @@ class Cursor:
         The returned PreparedStatement can be executed multiple times efficiently.
 
         Args:
-            filename: Path to SQL file (relative to CWD)
+            filename: Path to SQL file. Resolved relative to CWD first; if not
+                found there, falls back to the directory of the calling script.
             encoding: File encoding (default: utf-8-sig)
 
         Returns:
@@ -494,7 +545,32 @@ class Cursor:
             for user in users:
                 stmt.execute({'user_id': user.id, 'name': user.name})
         """
-        return PreparedStatement(self, filename=filename, encoding=encoding)
+        path = _resolve_sql_path(filename, inspect.stack()[1].filename)
+        return PreparedStatement(self, filename=path, encoding=encoding)
+
+    def prepare_query(self, query: str) -> PreparedStatement:
+        """
+        Prepare a SQL statement from a query string for repeated execution.
+
+        The parameter conversion is performed once.
+        The returned PreparedStatement can be executed multiple times efficiently.
+
+        Args:
+            query:
+
+        Returns:
+            PreparedStatement object
+
+        Example
+        -------
+        ::
+
+            stmt = cursor.prepare_query('SELECT * FROM users WHERE user_id = :user_id')
+            for user in users:
+                stmt.execute({'user_id': user.id})
+        """
+        return PreparedStatement(self, query=query)
+
 
     def executemany(self, query: str, bind_vars: List[tuple]) -> None:
         """Execute a query against multiple parameter sets."""

{dbtk-0.8.2 → dbtk-0.8.4}/dbtk/database.py

@@ -22,7 +22,7 @@ def _hide_password(kwargs):
     """Replace password with '********' to be printable"""
     parms = kwargs.copy()
     for key, val in parms.items():
-        if key in ('password', 'PWD', 'passwd'):
+        if key in ('password', 'pwd', 'PWD', 'passwd'):
             parms[key] = '********'
     return parms
 
@@ -133,16 +133,27 @@ DRIVERS = {
         'database_type': 'sqlserver',
         'module': 'pyodbc',
         'priority': 11,
-        'param_map': {'host': 'SERVER', 'database': 'DATABASE', 'user': 'UID', 'password': 'PWD'},
-        'required_params': [{'host', 'database', 'user'}, {'dsn'}],
-        'optional_params': {'password', 'port', 'driver', 'trusted_connection', 'encrypt', 'trustservercertificate'},
+        'param_map': {'host': 'server', 'user': 'uid', 'password': 'pwd'},
+        'required_params': [{'host', 'database', 'user'}, {'host', 'database', 'trusted_connection'}, {'dsn'}],
+        'optional_params': {'password', 'port', 'driver', 'encrypt', 'trustservercertificate'},
+        'connection_method': 'odbc_string',
+        'odbc_driver_name': 'ODBC Driver 18 for SQL Server',
+        'default_port': 1433
+    },
+    'pyodbc_sqlserver_17': {
+        'database_type': 'sqlserver',
+        'module': 'pyodbc',
+        'priority': 12,
+        'param_map': {'host': 'server', 'user': 'uid', 'password': 'pwd'},
+        'required_params': [{'host', 'database', 'user'}, {'host', 'database', 'trusted_connection'}, {'dsn'}],
+        'optional_params': {'password', 'port', 'driver', 'encrypt', 'trustservercertificate'},
         'connection_method': 'odbc_string',
         'odbc_driver_name': 'ODBC Driver 17 for SQL Server',
         'default_port': 1433
     },
     'pymssql': {
         'database_type': 'sqlserver',
-        'priority': 12,
+        'priority': 13,
         'param_map': {},
         'required_params': [{'host', 'database', 'user'}],
         'optional_params': {'password', 'port', 'timeout', 'login_timeout', 'charset', 'as_dict', 'appname'},
@@ -155,7 +166,7 @@ DRIVERS = {
         'database_type': 'postgres',
         'module': 'pyodbc',
         'priority': 14,
-        'param_map': {'host': 'SERVER', 'database': 'DATABASE', 'user': 'UID', 'password': 'PWD'},
+        'param_map': {'host': 'server', 'user': 'uid', 'password': 'pwd'},
         'required_params': [{'host', 'database', 'user'}, {'dsn'}],
         'optional_params': {'password', 'port'},
         'connection_method': 'odbc_string',
@@ -166,7 +177,7 @@ DRIVERS = {
         'database_type': 'mysql',
         'module': 'pyodbc',
         'priority': 16,
-        'param_map': {'host': 'SERVER', 'database': 'DATABASE', 'user': 'UID', 'password': 'PWD'},
+        'param_map': {'host': 'server', 'user': 'uid', 'password': 'pwd'},
         'required_params': [{'host', 'database', 'user'}],
         'optional_params': {'password', 'port'},
         'connection_method': 'odbc_string',
@@ -177,7 +188,7 @@ DRIVERS = {
         'database_type': 'oracle',
         'module': 'pyodbc',
         'priority': 13,
-        'param_map': {'host': 'SERVER', 'database': 'DATABASE', 'user': 'UID', 'password': 'PWD'},
+        'param_map': {'host': 'server', 'user': 'uid', 'password': 'pwd'},
         'required_params': [{'host', 'database', 'user'}],
         'optional_params': {'password', 'port'},
         'connection_method': 'odbc_string',
@@ -201,6 +212,12 @@ DRIVERS = {
 def register_user_drivers(drivers_config: dict) -> None:
     """Register drivers from config file."""
     global _user_drivers
+    for info in drivers_config.values():
+        # lowercase keys for optional_params and param_map
+        if 'optional_params' in info:
+            info['optional_params'] = {p.lower() for p in info['optional_params']}
+        if 'param_map' in info:
+            info['param_map'] = {k.lower(): v.lower()  for k,v in info['param_map'].items()}
     _user_drivers.update(drivers_config)
 
 
@@ -305,6 +322,10 @@ def _validate_connection_params(driver_name: str, config_only: bool = False, **p
     driver_info = DRIVERS[driver_name]
     database_type = driver_info['database_type']
 
+    # Normalize param keys to lowercase so callers can pass TrustServerCertificate,
+    # Port, etc. without being silently ignored.
+    params = {k.lower(): v for k, v in params.items()}
+
     # Initialize with config-only parameters if needed
     validated_params = {}
     if config_only and 'encrypted_password' in params:
@@ -348,6 +369,8 @@ def _validate_connection_params(driver_name: str, config_only: bool = False, **p
         if key in all_valid_params or (config_only and key == 'encrypted_password'):
             mapped_key = param_map.get(key, key)
             validated_params[mapped_key] = value
+        else:
+            logger.warning(f"Unknown parameter '{key}' for driver '{driver_name}' — ignoring")
 
     return validated_params
 
@@ -358,30 +381,20 @@ def _get_connection_string(**kwargs) -> str:
 
 
 def _get_odbc_string(**kwargs) -> str:
-    """Build ODBC connection string"""
-    port = kwargs.pop('port', None)
-    if port and 'SERVER' in kwargs and '\\' not in kwargs['SERVER']:
-        kwargs['SERVER'] += f',{port}'
-    printable = ';'.join([f"{key.upper()}={value}" for key, value in _hide_password(kwargs).items()])
-    logger.debug(f'ODBC connection string: {printable}')
-    return ';'.join([f"{key.upper()}={value}" for key, value in kwargs.items()])
-
-
-def _get_odbc_connection_string(**kwargs) -> str:
     """ Get connection string for ODBC from keyword arguments."""
-    # logger.debug(f'Generating ODBC connection string from: {_hide_password(kwargs)}')
     if 'dsn' in kwargs and kwargs['dsn']:
         # DSN only send DSN and password if present
         conn_str = f"DSN={kwargs['dsn']}"
         printable_conn_str = conn_str
-        if 'PWD' in kwargs:
-            conn_str += f";PWD={kwargs['PWD']}"
-            printable_conn_str += f";PWD=******"
+        if 'pwd' in kwargs:
+            conn_str += f";PWD={kwargs['pwd']}"
+            printable_conn_str += ";PWD=******"
     else:
         odbc_driver_name = kwargs.pop('odbc_driver_name', None)
         if 'port' in kwargs:
-            kwargs['SERVER'] += f',{kwargs.pop("port")}'
-        params = {key.upper(): value for key, value in kwargs.items()}
+            kwargs['server'] += f',{kwargs.pop("port")}'
+        params = {key.upper(): ('yes' if value is True else 'no' if value is False else value)
+                  for key, value in kwargs.items()}
         conn_str = ";".join([f"{key}={value}" for key, value in params.items()])
         printable_conn_str = ";".join([f"{key}={value}" for key, value in _hide_password(params).items()])
         if odbc_driver_name:
@@ -471,7 +484,7 @@ class Database:
     # Attributes stored locally, others delegated to _connection
     _local_attrs = [
         '_connection', 'database_type', 'database_name', 'driver',
-        'connection_name', 'placeholder', '_cursor_settings'
+        'connection_name', 'placeholder', '_cursor_settings', '_dialect'
     ]
 
     def __init__(self, connection, driver,
@@ -516,11 +529,11 @@ class Database:
         self.connection_name = connection_name
 
         if database_name is None:
-            database_name = (connection.get('database') or
-                            connection.get('service_name') or
-                            connection.get('dbname') or
-                            connection.get('db'))
-
+            if hasattr(connection, 'database'):
+                database_name = connection.database
+            elif hasattr(driver, 'SQL_DATABASE_NAME'):
+                # pyodbc probably from DSN
+                database_name = connection.getinfo(driver.SQL_DATABASE_NAME)
         self.database_name = database_name
 
         # Set parameter placeholder based on adapter style
@@ -533,6 +546,9 @@ class Database:
         else:
             self.database_type = 'unknown'
 
+        from .dialects import get_dialect
+        self._dialect = get_dialect(self.database_type)
+
         logger.debug(f"Cursor Database.__init__ cursor_settings: {cursor_settings}")
         if cursor_settings:
             self._cursor_settings = {key: val for key, val in cursor_settings.items()
@@ -540,6 +556,11 @@ class Database:
         else:
             self._cursor_settings = dict()
 
+    @property
+    def dialect(self):
+        """Database dialect instance providing SQL generation and schema introspection."""
+        return self._dialect
+
     def __getattr__(self, key: str) -> Any:
         """Delegate attribute access to underlying connection."""
         if key == '__name__':
@@ -765,7 +786,7 @@ class Database:
                 params['dsn'] = db_driver.makedsn(host, port, service_name=service_name)
             connection = db_driver.connect(**params)
         elif driver_conf['connection_method'] == 'odbc_string':
-            cx_string = _get_odbc_string(DRIVER=driver_conf.get('odbc_driver_name', None), **params)
+            cx_string = _get_odbc_string(odbc_driver_name=driver_conf.get('odbc_driver_name', None), **params)
             connection = db_driver.connect(cx_string)
         else:
             raise ValueError(f"Unknown connection method ({driver_conf['connection_method']}) for driver '{driver_name}'")