etlplus 0.6.1__py3-none-any.whl → 0.7.1__py3-none-any.whl

etlplus/database/__init__.py

@@ -1,8 +1,11 @@
 """
 :mod:`etlplus.database` package.
 
-This package defines database-related utilities for ETLPlus, including:
+Database utilities for:
 - DDL rendering and schema management.
+- Schema parsing from configuration files.
+- Dynamic ORM generation.
+- Database engine/session management.
 """
 
 from __future__ import annotations
@@ -11,13 +14,29 @@ from .ddl import load_table_spec
 from .ddl import render_table_sql
 from .ddl import render_tables
 from .ddl import render_tables_to_string
+from .engine import engine
+from .engine import load_database_url_from_config
+from .engine import make_engine
+from .engine import session
+from .orm import build_models
+from .orm import load_and_build_models
+from .schema import load_table_specs
 
 # SECTION: EXPORTS ========================================================== #
 
 
 __all__ = [
+    # Functions
+    'build_models',
+    'load_and_build_models',
+    'load_database_url_from_config',
     'load_table_spec',
+    'load_table_specs',
+    'make_engine',
     'render_table_sql',
     'render_tables',
     'render_tables_to_string',
+    # Singletons
+    'engine',
+    'session',
 ]

etlplus/database/ddl.py

@@ -1,5 +1,5 @@
 """
-:mod:`etlplus.ddl` module.
+:mod:`etlplus.database.ddl` module.
 
 DDL rendering utilities for pipeline table schemas.
 

etlplus/database/engine.py

@@ -0,0 +1,146 @@
+"""
+:mod:`etlplus.database.engine` module.
+
+Lightweight engine/session factory with optional config-driven URL loading.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from sqlalchemy import create_engine
+from sqlalchemy.engine import Engine
+from sqlalchemy.orm import sessionmaker
+
+from ..file import File
+
+# SECTION: EXPORTS ========================================================== #
+
+
+__all__ = [
+    # Functions
+    'load_database_url_from_config',
+    'make_engine',
+    # Singletons
+    'engine',
+    'session',
+]
+
+
+# SECTION: INTERNAL CONSTANTS =============================================== #
+
+
+DATABASE_URL: str = (
+    os.getenv('DATABASE_URL')
+    or os.getenv('DATABASE_DSN')
+    or 'sqlite+pysqlite:///:memory:'
+)
+
+
+# SECTION: INTERNAL FUNCTIONS =============================================== #
+
+
+def _resolve_url_from_mapping(cfg: Mapping[str, Any]) -> str | None:
+    """
+    Return a URL/DSN from a mapping if present.
+
+    Parameters
+    ----------
+    cfg : Mapping[str, Any]
+        Configuration mapping potentially containing connection fields.
+
+    Returns
+    -------
+    str | None
+        Resolved URL/DSN string, if present.
+    """
+    conn = cfg.get('connection_string') or cfg.get('url') or cfg.get('dsn')
+    if isinstance(conn, str) and conn.strip():
+        return conn.strip()
+
+    # Some configs nest defaults.
+    # E.g., databases: { mssql: { default: {...} } }
+    default_cfg = cfg.get('default')
+    if isinstance(default_cfg, Mapping):
+        return _resolve_url_from_mapping(default_cfg)
+
+    return None
+
+
+# SECTION: FUNCTIONS ======================================================== #
+
+
+def load_database_url_from_config(
+    path: str | Path,
+    *,
+    name: str | None = None,
+) -> str:
+    """
+    Extract a database URL/DSN from a YAML/JSON config file.
+
+    The loader is schema-tolerant: it looks for a top-level "databases" map
+    and then for a named entry (``name``). Each entry may contain either a
+    ``connection_string``/``url``/``dsn`` or a nested ``default`` block with
+    those fields.
+
+    Parameters
+    ----------
+    path : str | Path
+        Location of the configuration file.
+    name : str | None, optional
+        Named database entry under the ``databases`` map (default:
+        ``default``).
+
+    Returns
+    -------
+    str
+        Resolved database URL/DSN string.
+
+    Raises
+    ------
+    KeyError
+        If the specified database entry is not found.
+    TypeError
+        If the config structure is invalid.
+    ValueError
+        If no connection string/URL/DSN is found for the specified entry.
+    """
+    cfg = File.read_file(Path(path))
+    if not isinstance(cfg, Mapping):
+        raise TypeError('Database config must be a mapping')
+
+    databases = cfg.get('databases') if isinstance(cfg, Mapping) else None
+    if not isinstance(databases, Mapping):
+        raise KeyError('Config missing top-level "databases" mapping')
+
+    target = name or 'default'
+    entry = databases.get(target)
+    if entry is None:
+        raise KeyError(f'Database entry "{target}" not found in config')
+    if not isinstance(entry, Mapping):
+        raise TypeError(f'Database entry "{target}" must be a mapping')
+
+    url = _resolve_url_from_mapping(entry)
+    if not url:
+        raise ValueError(
+            f'Database entry "{target}" lacks connection_string/url/dsn',
+        )
+    return url
+
+
+def make_engine(url: str | None = None, **engine_kwargs: Any) -> Engine:
+    """Create a SQLAlchemy Engine, defaulting to env config if no URL given."""
+
+    resolved_url = url or DATABASE_URL
+    return create_engine(resolved_url, pool_pre_ping=True, **engine_kwargs)
+
+
+# SECTION: SINGLETONS ======================================================= #
+
+
+# Default engine/session for callers that rely on module-level singletons.
+engine = make_engine()
+session = sessionmaker(bind=engine, autoflush=False, autocommit=False)

etlplus/database/orm.py

@@ -0,0 +1,347 @@
+"""
+:mod:`etlplus.database.orm` module.
+
+Dynamic SQLAlchemy model generation from YAML table specs.
+
+Usage
+-----
+>>> from etlplus.database.orm import load_and_build_models
+>>> registry = load_and_build_models('examples/configs/ddl_spec.yml')
+>>> Player = registry['dbo.Customers']
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from sqlalchemy import Boolean
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Date
+from sqlalchemy import DateTime
+from sqlalchemy import Enum
+from sqlalchemy import Float
+from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy import Index
+from sqlalchemy import Integer
+from sqlalchemy import LargeBinary
+from sqlalchemy import Numeric
+from sqlalchemy import PrimaryKeyConstraint
+from sqlalchemy import String
+from sqlalchemy import Text
+from sqlalchemy import Time
+from sqlalchemy import UniqueConstraint
+from sqlalchemy import text
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import mapped_column
+from sqlalchemy.types import TypeEngine
+
+from .schema import ForeignKeySpec
+from .schema import TableSpec
+from .schema import load_table_specs
+
+# SECTION: INTERNAL CONSTANTS =============================================== #
+
+__all__ = [
+    # Classes
+    'Base',
+    # Functions
+    'build_models',
+    'load_and_build_models',
+    'resolve_type',
+]
+
+
+_TYPE_MAPPING: dict[str, Callable[[list[int]], TypeEngine]] = {
+    'int': lambda _: Integer(),
+    'integer': lambda _: Integer(),
+    'bigint': lambda _: Integer(),
+    'smallint': lambda _: Integer(),
+    'bool': lambda _: Boolean(),
+    'boolean': lambda _: Boolean(),
+    'uuid': lambda _: PG_UUID(as_uuid=True),
+    'uniqueidentifier': lambda _: PG_UUID(as_uuid=True),
+    'rowversion': lambda _: LargeBinary(),
+    'varbinary': lambda _: LargeBinary(),
+    'blob': lambda _: LargeBinary(),
+    'text': lambda _: Text(),
+    'string': lambda _: Text(),
+    'varchar': lambda p: String(length=p[0]) if p else String(),
+    'nvarchar': lambda p: String(length=p[0]) if p else String(),
+    'char': lambda p: String(length=p[0] if p else 1),
+    'nchar': lambda p: String(length=p[0] if p else 1),
+    'numeric': lambda p: Numeric(
+        precision=p[0] if p else None,
+        scale=p[1] if len(p) > 1 else None,
+    ),
+    'decimal': lambda p: Numeric(
+        precision=p[0] if p else None,
+        scale=p[1] if len(p) > 1 else None,
+    ),
+    'float': lambda _: Float(),
+    'real': lambda _: Float(),
+    'double': lambda _: Float(),
+    'datetime': lambda _: DateTime(timezone=True),
+    'datetime2': lambda _: DateTime(timezone=True),
+    'timestamp': lambda _: DateTime(timezone=True),
+    'date': lambda _: Date(),
+    'time': lambda _: Time(),
+    'json': lambda _: JSONB(),
+    'jsonb': lambda _: JSONB(),
+}
+
+
+# SECTION: CLASSES ========================================================== #
+
+
+class Base(DeclarativeBase):
+    """Base class for all ORM models."""
+
+
+# SECTION: INTERNAL FUNCTIONS =============================================== #
+
+
+def _class_name(
+    table: str,
+) -> str:
+    """
+    Convert table name to PascalCase class name.
+
+    Parameters
+    ----------
+    table : str
+        Table name.
+
+    Returns
+    -------
+    str
+        PascalCase class name.
+    """
+    parts = re.split(r'[^A-Za-z0-9]+', table)
+    return ''.join(p.capitalize() for p in parts if p)
+
+
+def _parse_type_decl(
+    type_str: str,
+) -> tuple[str, list[int]]:
+    """
+    Parse a type declaration string into its name and parameters.
+
+    Parameters
+    ----------
+    type_str : str
+        Type declaration string, e.g., "varchar(255)".
+
+    Returns
+    -------
+    tuple[str, list[int]]
+        A tuple containing the type name and a list of integer parameters.
+    """
+    m = re.match(
+        r'^(?P<name>[A-Za-z0-9_]+)(?:\((?P<params>[^)]*)\))?$',
+        type_str.strip(),
+    )
+    if not m:
+        return type_str.lower(), []
+    name = m.group('name').lower()
+    params_raw = m.group('params')
+    if not params_raw:
+        return name, []
+    params = [p.strip() for p in params_raw.split(',') if p.strip()]
+    parsed: list[int] = []
+    for p in params:
+        try:
+            parsed.append(int(p))
+        except ValueError:
+            continue
+    return name, parsed
+
+
+def _table_kwargs(
+    spec: TableSpec,
+) -> dict[str, str]:
+    """
+    Generate table keyword arguments based on the table specification.
+
+    Parameters
+    ----------
+    spec : TableSpec
+        Table specification.
+
+    Returns
+    -------
+    dict[str, str]
+        Dictionary of table keyword arguments.
+    """
+    kwargs: dict[str, str] = {}
+    if spec.schema_name:
+        kwargs['schema'] = spec.schema_name
+    return kwargs
+
+
+# SECTION: FUNCTIONS ======================================================== #
+
+
+def build_models(
+    specs: list[TableSpec],
+    *,
+    base: type[DeclarativeBase] = Base,
+) -> dict[str, type[DeclarativeBase]]:
+    """
+    Build SQLAlchemy ORM models from table specifications.
+    Parameters
+    ----------
+    specs : list[TableSpec]
+        List of table specifications.
+    base : type[DeclarativeBase], optional
+        Base class for the ORM models (default: :class:`Base`).
+    Returns
+    -------
+    dict[str, type[DeclarativeBase]]
+        Registry mapping fully qualified table names to ORM model classes.
+    """
+    registry: dict[str, type[DeclarativeBase]] = {}
+
+    for spec in specs:
+        table_args: list[object] = []
+        table_kwargs = _table_kwargs(spec)
+        pk_cols = set(spec.primary_key.columns) if spec.primary_key else set()
+
+        # Pre-handle multi-column constraints.
+        if spec.primary_key and len(spec.primary_key.columns) > 1:
+            table_args.append(
+                PrimaryKeyConstraint(
+                    *spec.primary_key.columns,
+                    name=spec.primary_key.name,
+                ),
+            )
+        for uc in spec.unique_constraints:
+            table_args.append(UniqueConstraint(*uc.columns, name=uc.name))
+        for idx in spec.indexes:
+            table_args.append(
+                Index(
+                    idx.name,
+                    *idx.columns,
+                    unique=idx.unique,
+                    postgresql_where=text(idx.where) if idx.where else None,
+                ),
+            )
+        composite_fks = [fk for fk in spec.foreign_keys if len(fk.columns) > 1]
+        for fk in composite_fks:
+            table_args.append(
+                ForeignKeyConstraint(
+                    fk.columns,
+                    [f'{fk.ref_table}.{c}' for c in fk.ref_columns],
+                    ondelete=fk.ondelete,
+                ),
+            )
+
+        fk_by_column = {
+            fk.columns[0]: fk
+            for fk in spec.foreign_keys
+            if len(fk.columns) == 1 and len(fk.ref_columns) == 1
+        }
+
+        attrs: dict[str, object] = {'__tablename__': spec.table}
+
+        for col in spec.columns:
+            col_fk: ForeignKeySpec | None = fk_by_column.get(col.name)
+            fk_arg = (
+                ForeignKey(
+                    f'{col_fk.ref_table}.{col_fk.ref_columns[0]}',
+                    ondelete=col_fk.ondelete,
+                )
+                if col_fk
+                else None
+            )
+            col_type: TypeEngine = (
+                Enum(*col.enum, name=f'{spec.table}_{col.name}_enum')
+                if col.enum
+                else resolve_type(col.type)
+            )
+            fk_args: list[ForeignKey] = []
+            if fk_arg:
+                fk_args.append(fk_arg)
+
+            kwargs: dict[str, Any] = {
+                'nullable': col.nullable,
+                'primary_key': col.name in pk_cols and len(pk_cols) == 1,
+                'unique': col.unique,
+            }
+            if col.default:
+                kwargs['server_default'] = text(col.default)
+            if col.identity:
+                kwargs['autoincrement'] = True
+
+            attrs[col.name] = mapped_column(*fk_args, type_=col_type, **kwargs)
+
+            if col.check:
+                table_args.append(
+                    CheckConstraint(
+                        col.check,
+                        name=f'ck_{spec.table}_{col.name}',
+                    ),
+                )
+
+        if table_args or table_kwargs:
+            args_tuple = tuple(table_args)
+            attrs['__table_args__'] = (
+                (*args_tuple, table_kwargs) if table_kwargs else args_tuple
+            )
+
+        cls_name = _class_name(spec.table)
+        model_cls = type(cls_name, (base,), attrs)
+        registry[spec.fq_name] = model_cls
+
+    return registry
+
+
+def load_and_build_models(
+    path: str | Path,
+    *,
+    base: type[DeclarativeBase] = Base,
+) -> dict[str, type[DeclarativeBase]]:
+    """
+    Load table specifications from a file and build SQLAlchemy models.
+
+    Parameters
+    ----------
+    path : str | Path
+        Path to the YAML file containing table specifications.
+    base : type[DeclarativeBase], optional
+        Base class for the ORM models (default: :class:`Base`).
+
+    Returns
+    -------
+    dict[str, type[DeclarativeBase]]
+        Registry mapping fully qualified table names to ORM model classes.
+    """
+    return build_models(load_table_specs(path), base=base)
+
+
+def resolve_type(
+    type_str: str,
+) -> TypeEngine:
+    """
+    Resolve a string type declaration to a SQLAlchemy :class:`TypeEngine`.
+
+    Parameters
+    ----------
+    type_str : str
+        String representation of the type declaration.
+
+    Returns
+    -------
+    TypeEngine
+        SQLAlchemy type engine instance corresponding to the type declaration.
+    """
+    name, params = _parse_type_decl(type_str)
+    factory = _TYPE_MAPPING.get(name)
+    if factory:
+        return factory(params)
+    return Text()

etlplus/database/schema.py

@@ -0,0 +1,273 @@
+"""
+:mod:`etlplus.database.schema` module.
+
+Helpers for loading and translating YAML definitions of database table schema
+specifications into Pydantic models for dynamic SQLAlchemy generation.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+from typing import ClassVar
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from pydantic import Field
+
+from ..file import File
+
+# SECTION: EXPORTS ========================================================== #
+
+
+__all__ = [
+    # Classes
+    'ColumnSpec',
+    'ForeignKeySpec',
+    'IdentitySpec',
+    'IndexSpec',
+    'PrimaryKeySpec',
+    'UniqueConstraintSpec',
+    'TableSpec',
+    # Functions
+    'load_table_specs',
+]
+
+
+# SECTION: CLASSES ========================================================== #
+
+
+class ColumnSpec(BaseModel):
+    """
+    Column specification suitable for ODBC / SQLite DDL.
+
+    Attributes
+    ----------
+    model_config : ClassVar[ConfigDict]
+        Pydantic model configuration.
+    name : str
+        Unquoted column name.
+    type : str
+        SQL type string, e.g., INT, NVARCHAR(100).
+    nullable : bool
+        True if NULL values are allowed.
+    default : str | None
+        Default value expression, or None if no default.
+    identity : IdentitySpec | None
+        Identity specification, or None if not an identity column.
+    check : str | None
+        Check constraint expression, or None if no check constraint.
+    enum : list[str] | None
+        List of allowed string values for enum-like columns, or None.
+    unique : bool
+        True if the column has a UNIQUE constraint.
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra='forbid')
+
+    name: str
+    type: str = Field(description='SQL type string, e.g., INT, NVARCHAR(100)')
+    nullable: bool = True
+    default: str | None = None
+    identity: IdentitySpec | None = None
+    check: str | None = None
+    enum: list[str] | None = None
+    unique: bool = False
+
+
+class ForeignKeySpec(BaseModel):
+    """
+    Foreign key specification.
+
+    Attributes
+    ----------
+    model_config : ClassVar[ConfigDict]
+        Pydantic model configuration.
+    columns : list[str]
+        List of local column names.
+    ref_table : str
+        Referenced table name.
+    ref_columns : list[str]
+        List of referenced column names.
+    ondelete : str | None
+        ON DELETE action, or None.
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra='forbid')
+
+    columns: list[str]
+    ref_table: str
+    ref_columns: list[str]
+    ondelete: str | None = None
+
+
+class IdentitySpec(BaseModel):
+    """
+    Identity specification.
+
+    Attributes
+    ----------
+    model_config : ClassVar[ConfigDict]
+        Pydantic model configuration.
+    seed : int | None
+        Identity seed value (default: 1).
+    increment : int | None
+        Identity increment value (default: 1).
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra='forbid')
+
+    seed: int | None = Field(default=None, ge=1)
+    increment: int | None = Field(default=None, ge=1)
+
+
+class IndexSpec(BaseModel):
+    """
+    Index specification.
+
+    Attributes
+    ----------
+    model_config : ClassVar[ConfigDict]
+        Pydantic model configuration.
+    name : str
+        Index name.
+    columns : list[str]
+        List of column names included in the index.
+    unique : bool
+        True if the index is unique.
+    where : str | None
+        Optional WHERE clause for filtered indexes.
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra='forbid')
+
+    name: str
+    columns: list[str]
+    unique: bool = False
+    where: str | None = None
+
+
+class PrimaryKeySpec(BaseModel):
+    """
+    Primary key specification.
+
+    Attributes
+    ----------
+    model_config : ClassVar[ConfigDict]
+        Pydantic model configuration.
+    name : str | None
+        Primary key constraint name, or None if unnamed.
+    columns : list[str]
+        List of column names included in the primary key.
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra='forbid')
+
+    name: str | None = None
+    columns: list[str]
+
+
+class UniqueConstraintSpec(BaseModel):
+    """
+    Unique constraint specification.
+
+    Attributes
+    ----------
+    model_config : ClassVar[ConfigDict]
+        Pydantic model configuration.
+    name : str | None
+        Unique constraint name, or None if unnamed.
+    columns : list[str]
+        List of column names included in the unique constraint.
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra='forbid')
+
+    name: str | None = None
+    columns: list[str]
+
+
+class TableSpec(BaseModel):
+    """
+    Table specification.
+
+    Attributes
+    ----------
+    model_config : ClassVar[ConfigDict]
+        Pydantic model configuration.
+    table : str
+        Table name.
+    schema_name : str | None
+        Schema name, or None if not specified.
+    create_schema : bool
+        Whether to create the schema if it does not exist.
+    columns : list[ColumnSpec]
+        List of column specifications.
+    primary_key : PrimaryKeySpec | None
+        Primary key specification, or None if no primary key.
+    unique_constraints : list[UniqueConstraintSpec]
+        List of unique constraint specifications.
+    indexes : list[IndexSpec]
+        List of index specifications.
+    foreign_keys : list[ForeignKeySpec]
+        List of foreign key specifications.
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra='forbid')
+
+    table: str = Field(alias='name')
+    schema_name: str | None = Field(default=None, alias='schema')
+    create_schema: bool = False
+    columns: list[ColumnSpec]
+    primary_key: PrimaryKeySpec | None = None
+    unique_constraints: list[UniqueConstraintSpec] = Field(
+        default_factory=list,
+    )
+    indexes: list[IndexSpec] = Field(default_factory=list)
+    foreign_keys: list[ForeignKeySpec] = Field(default_factory=list)
+
+    # -- Properties -- #
+
+    @property
+    def fq_name(self) -> str:
+        """
+        Fully qualified table name, including schema if specified.
+        """
+        return (
+            f'{self.schema_name}.{self.table}'
+            if self.schema_name
+            else self.table
+        )
+
+
+# SECTION: FUNCTIONS ======================================================== #
+
+
+def load_table_specs(
+    path: str | Path,
+) -> list[TableSpec]:
+    """
+    Load table specifications from a YAML file.
+
+    Parameters
+    ----------
+    path : str | Path
+        Path to the YAML file containing table specifications.
+
+    Returns
+    -------
+    list[TableSpec]
+        A list of TableSpec instances parsed from the YAML file.
+    """
+    data = File.read_file(Path(path))
+    if not data:
+        return []
+
+    if isinstance(data, dict) and 'table_schemas' in data:
+        items: list[Any] = data['table_schemas'] or []
+    elif isinstance(data, list):
+        items = data
+    else:
+        items = [data]
+
+    return [TableSpec.model_validate(item) for item in items]

{etlplus-0.6.1.dist-info → etlplus-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: etlplus
-Version: 0.6.1
+Version: 0.7.1
 Summary: A Swiss Army knife for simple ETL operations
 Home-page: https://github.com/Dagitali/ETLPlus
 Author: ETLPlus Team
@@ -21,7 +21,10 @@ Requires-Dist: jinja2>=3.1.6
 Requires-Dist: pyodbc>=5.3.0
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pandas>=2.3.3
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: PyYAML>=6.0.3
 Requires-Dist: requests>=2.32.5
+Requires-Dist: SQLAlchemy>=2.0.45
 Requires-Dist: typer>=0.21.0
 Provides-Extra: dev
 Requires-Dist: black>=25.9.0; extra == "dev"

{etlplus-0.6.1.dist-info → etlplus-0.7.1.dist-info}/RECORD

@@ -41,16 +41,19 @@ etlplus/config/pipeline.py,sha256=Va4MQY6KEyKqHGMKPmh09ZcGpx95br-iNUjpkqtzVbw,95
 etlplus/config/profile.py,sha256=Ss2zedQGjkaGSpvBLTD4SZaWViMJ7TJPLB8Q2_BTpPg,1898
 etlplus/config/types.py,sha256=a0epJ3z16HQ5bY3Ctf8s_cQPa3f0HHcwdOcjCP2xoG4,4954
 etlplus/config/utils.py,sha256=4SUHMkt5bKBhMhiJm-DrnmE2Q4TfOgdNCKz8PJDS27o,3443
-etlplus/database/__init__.py,sha256=MNaqpiPNTMbwbHxdh865GXS3q4H4dkAn2YLl3GFQU8E,525
-etlplus/database/ddl.py,sha256=Hvg1PwwaIMU3y8emMWml4CzvQGvvg6KZfsHo3-EWJjg,7738
+etlplus/database/__init__.py,sha256=0gWnMlQiVHS6SVUxIT9zklQUHU36y-2RF_gN1cx7icg,1018
+etlplus/database/ddl.py,sha256=lIar9KIOoBRslp_P0DnpoMDXzkjt64J5-iVV7CeSV_M,7747
+etlplus/database/engine.py,sha256=54f-XtNKIuogJhsLV9cX_xPoBwcl_HNJTL5HqMCi8kw,3986
+etlplus/database/orm.py,sha256=StjeguokM70oNKq7mNXLyc4_mYUZR-EKW3oGRlsd8QE,9962
+etlplus/database/schema.py,sha256=BmRP2wwX2xex1phLm0tnHrP6A2AQgguA-hSLnK0xwwc,7003
 etlplus/templates/__init__.py,sha256=tsniN7XJYs3NwYxJ6c2HD5upHP3CDkLx-bQCMt97UOM,106
 etlplus/templates/ddl.sql.j2,sha256=s8fMWvcb4eaJVXkifuib1aQPljtZ8buuyB_uA-ZdU3Q,4734
 etlplus/templates/view.sql.j2,sha256=Iy8DHfhq5yyvrUKDxqp_aHIEXY4Tm6j4wT7YDEFWAhk,2180
 etlplus/validation/__init__.py,sha256=Pe5Xg1_EA4uiNZGYu5WTF3j7odjmyxnAJ8rcioaplSQ,1254
 etlplus/validation/utils.py,sha256=Mtqg449VIke0ziy_wd2r6yrwJzQkA1iulZC87FzXMjo,10201
-etlplus-0.6.1.dist-info/licenses/LICENSE,sha256=MuNO63i6kWmgnV2pbP2SLqP54mk1BGmu7CmbtxMmT-U,1069
-etlplus-0.6.1.dist-info/METADATA,sha256=NX1ADs4_MZ3J9QLGj7bPRyXc43HJJxfOzfcmIg3VYHc,19288
-etlplus-0.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-etlplus-0.6.1.dist-info/entry_points.txt,sha256=6w-2-jzuPa55spzK34h-UKh2JTEShh38adFRONNP9QE,45
-etlplus-0.6.1.dist-info/top_level.txt,sha256=aWWF-udn_sLGuHTM6W6MLh99ArS9ROkUWO8Mi8y1_2U,8
-etlplus-0.6.1.dist-info/RECORD,,
+etlplus-0.7.1.dist-info/licenses/LICENSE,sha256=MuNO63i6kWmgnV2pbP2SLqP54mk1BGmu7CmbtxMmT-U,1069
+etlplus-0.7.1.dist-info/METADATA,sha256=Y2MYm3-8rGosgvY29er_Pt_j9qxgBVndnRXK3k0xUBM,19383
+etlplus-0.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+etlplus-0.7.1.dist-info/entry_points.txt,sha256=6w-2-jzuPa55spzK34h-UKh2JTEShh38adFRONNP9QE,45
+etlplus-0.7.1.dist-info/top_level.txt,sha256=aWWF-udn_sLGuHTM6W6MLh99ArS9ROkUWO8Mi8y1_2U,8
+etlplus-0.7.1.dist-info/RECORD,,