sandwich 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

sandwich/dialects/postgres.py

@@ -0,0 +1,107 @@
+from typing import Tuple
+
+from sqlalchemy import dialects, Table, text
+
+from src.sandwich.dialects.base import DialectHandler
+
+
+class PostgresDialectHandler(DialectHandler):
+    """Dialect handler for PostgreSQL.
+
+    NOTE: This is a stub implementation. All methods need to be implemented
+    based on PostgreSQL syntax and conventions.
+    """
+
+    def get_boolean_type(self):
+        return dialects.postgresql.BOOLEAN
+
+    def get_proc_name_format(self, schema: str, operation: str, entity_name: str) -> str:
+        """Get Postgres procedure naming format."""
+        # Postgres uses lowercase with underscores by convention
+        operation_lower = operation.lower()
+        return f"{schema}.{operation_lower}_{entity_name}"
+
+    def apply_proc_template(self, proc_name: str, sql_body: str, header: str) -> str:
+        """Wrap SQL body in Postgres procedure template with error handling."""
+        # TODO: Implement Postgres procedure template
+        # Postgres uses CREATE OR REPLACE PROCEDURE/FUNCTION with PL/pgSQL
+        # Error handling uses EXCEPTION blocks
+        # Logging integration needed
+        raise NotImplementedError("Postgres procedure template not yet implemented")
+
+    def make_stg_materialization_proc(
+        self,
+        entity_name: str,
+        header: str
+    ) -> Tuple[str, str]:
+        """Generate Postgres staging materialization procedure."""
+        # TODO: Implement using CREATE OR REPLACE and DROP/CREATE TABLE pattern
+        raise NotImplementedError("Postgres staging materialization not yet implemented")
+
+    def make_hub_proc(
+        self,
+        hub_table: Table,
+        bk_keys: list,
+        header: str
+    ) -> Tuple[str, str]:
+        """Generate Postgres hub population procedure."""
+        # TODO: Implement using INSERT...ON CONFLICT or NOT EXISTS pattern
+        raise NotImplementedError("Postgres hub procedure not yet implemented")
+
+    def make_sdc2_sat_proc(
+        self,
+        sat_table: Table,
+        hk_name: str,
+        hashdiff_col: str,
+        is_available_col: str,
+        loaddate_col: str,
+        stg_schema: str,
+        header: str
+    ) -> Tuple[str, str]:
+        """Generate Postgres satellite population procedure."""
+        # TODO: Implement using CTE and window functions (similar to MSSQL but with Postgres syntax)
+        # Use CURRENT_TIMESTAMP instead of SYSDATETIME()
+        # Use BOOLEAN type instead of BIT
+        raise NotImplementedError("Postgres satellite procedure not yet implemented")
+
+    def make_scd2_dim_proc(
+        self,
+        dim_table: Table,
+        bk_keys: list,
+        header: str
+    ) -> Tuple[str, str]:
+        """Generate Postgres dimension SCD2 recalculation procedure."""
+        # TODO: Implement using TRUNCATE and INSERT with window functions
+        # Use LAG/LEAD for SCD2 date calculations
+        # Use INTERVAL for date arithmetic instead of DATEADD
+        raise NotImplementedError("Postgres dimension procedure not yet implemented")
+
+    def make_job_proc(
+        self,
+        entity_name: str,
+        hub_proc_name: str,
+        sat_proc_name: str,
+        dim_proc_name: str,
+        stg_proc_name: str | None,
+        header: str
+    ) -> Tuple[str, str]:
+        """Generate Postgres job orchestration procedure."""
+        # TODO: Implement using CALL statements for other procedures
+        # Pass execution_id through procedure parameters
+        raise NotImplementedError("Postgres job procedure not yet implemented")
+
+    def make_drop_proc(
+        self,
+        entity_name: str,
+        stg_schema: str,
+        job_proc_name: str,
+        stg_proc_name: str | None,
+        hub_proc_name: str,
+        sat_proc_name: str,
+        dim_proc_name: str,
+        header: str
+    ) -> Tuple[str, str]:
+        """Generate Postgres cleanup/drop procedure."""
+        # TODO: Implement using DROP IF EXISTS for tables and procedures
+        # Update core.entities with deletion timestamp
+        raise NotImplementedError("Postgres drop procedure not yet implemented")

sandwich/dialects/utils.py

@@ -0,0 +1,147 @@
+from datetime import datetime
+from typing import Any
+
+from sqlalchemy import Engine, Connection, Table, text, TextClause
+
+from src.sandwich import SANDWICH_VERSION
+from .. import errors as err
+from src.sandwich.modeling import modeling_metadata
+
+from . import ddl_mssql, ddl_postgres
+
+def get_columns_list(table: Table, sep: str = ", ", alias: str = None):
+    alias = alias + "." if alias else ""
+    return sep.join([f"{alias or ''}[{fld.name}]" for fld in table.columns.values()])
+
+def get_string_to_hash_ddl_mssql(columns_count: int) -> str:
+    if columns_count < 2 or columns_count > 100:
+        raise ValueError("columns_count must be between 2 and 100")
+
+    params_list_str = ",\n\t".join([f"@StrValue{v} nvarchar(1000)" for v in range(1, columns_count + 1)])
+    concat_list_str = ", ';',\n\t\t\t".join(
+        [f"rtrim(ltrim(isnull(@StrValue{v}, '')))" for v in range(1, columns_count + 1)])
+
+    # language=sql
+    func = f"""
+create or alter function [core].[StringToHash{columns_count}]
+(
+{params_list_str}
+) returns char(40) as
+begin
+declare @result char(40);
+set @result = upper(convert(char(40), hashbytes('sha1',
+    upper(concat(
+        {concat_list_str}
+    ))
+), 2));
+return @result;
+end"""
+    return func
+
+def get_string_to_hash_ddl_postgres(columns_count: int) -> str:
+    if columns_count < 2 or columns_count > 100:
+        raise ValueError("columns_count must be between 2 and 100")
+
+    params_list_str = ",\n\t".join([f"p_str_value{v} text" for v in range(1, columns_count + 1)])
+    concat_list_str = ", ';',\n\t\t\t".join(
+        [f"upper(trim(coalesce(p_str_value{v}, '')))" for v in range(1, columns_count + 1)])
+
+    # language=sql
+    func = f"""
+create or replace function core.string_to_hash{columns_count}(
+{params_list_str}
+) returns char(40)
+language plpgsql
+as $$
+declare
+result char(40);
+begin
+result :=
+    upper(
+        encode(
+            digest(
+                concat(
+                    {concat_list_str}
+                ),
+                'sha1'
+            ),
+            'hex'
+        )
+    );
+return cast(result as char(40));
+end;
+$$;"""
+    return func
+
+def initialize_database(conn: Engine | Connection, dialect: str = "mssql",
+                        str_to_hash_count:int = 66,
+                        verbose: bool = False,
+                        drop_entities_table: bool = False) -> None:
+    init_scripts: dict[str, str] = {}
+    header = modeling_metadata.HEADER_TEMPLATE.format(
+        created_on=datetime.now(),
+        updated_on=datetime.now(),
+        version=SANDWICH_VERSION,
+        entity_name="SYSTEM")
+
+    if dialect == "mssql":
+        init_scripts["create_schemas"] = ddl_mssql.create_schemas
+        if drop_entities_table:
+            init_scripts["drop_entities_table"] = "drop table if exists [core].[entities];"
+        init_scripts["create_entities_table"] = ddl_mssql.create_entities_table
+        init_scripts["create_func_StringToHash1"] = header + ddl_mssql.create_func_StringToHash
+        for i in range(2, str_to_hash_count):
+            init_scripts[f"create_func_StringToHash{i}"] = header + get_string_to_hash_ddl_mssql(i)
+        init_scripts["create_table_ExecutionLog"] = ddl_mssql.create_table_ExecutionLog
+        init_scripts["create_table_ErrorLog"] = ddl_mssql.create_table_ErrorLog
+        init_scripts["create_proc_LogExecution"] = header + ddl_mssql.create_proc_LogExecution
+    elif dialect == "postgres":
+        init_scripts["create_extensions"] = ddl_postgres.create_extensions
+        init_scripts["create_schemas"] = ddl_postgres.create_schemas
+        if drop_entities_table:
+            init_scripts["drop_entities_table"] = "drop table if exists core.entities"
+        init_scripts["create_entities_table"] = ddl_postgres.create_entities_table
+        init_scripts["create_func_StringToHash1"] = ddl_postgres.create_func_StringToHash
+        for i in range(2, str_to_hash_count):
+            init_scripts[f"create_func_StringToHash{i}"] = get_string_to_hash_ddl_postgres(i)
+        init_scripts["create_table_ExecutionLog"] = ddl_postgres.create_table_ExecutionLog
+        init_scripts["create_table_ErrorLog"] = ddl_postgres.create_table_ErrorLog
+        init_scripts["create_proc_LogExecution"] = ddl_postgres.create_proc_LogExecution
+    else:
+        raise err.Dv2NotYetImplementedForDialectError(dialect)
+
+    for name, script in init_scripts.items():
+        if verbose:
+            print(f"[ok] Executing script: {name}")
+        conn.execute(text(script))
+
+def get_proc_definition_dml_mssql(proc_param_name: str) -> TextClause:
+    return text(f"""
+       SELECT sm.definition
+       FROM sys.sql_modules sm
+                JOIN sys.objects o ON sm.object_id = o.object_id
+                JOIN sys.schemas s ON o.schema_id = s.schema_id
+       WHERE o.type = 'P'
+         AND '['+s.name+'].['+o.name+']' = :{proc_param_name}
+       """)
+
+def parse_auto_generated_header(full_proc_text: str) -> dict[str, Any]:
+    started = False
+    rows_in_header = 0
+    result: dict[str, Any] = {}
+    for ln in full_proc_text.splitlines():
+        if started:
+            rows_in_header += 1
+            if ln.lstrip().startswith("Created on"):
+                result["created_on"] = ln.split(":", 1)[1].strip()
+            elif ln.lstrip().startswith("Updated on"):
+                result["updated_on"] = ln.split(":", 1)[1].strip()
+            elif ln.strip() == "*/":
+                break
+            else:
+                continue
+        if ln.strip() == "/*":
+            started = True
+            continue
+    result["rows_in_header"] = rows_in_header - 1 if rows_in_header > 0 else 0
+    return result

sandwich/dwh/__init__.py

@@ -0,0 +1,82 @@
+from datetime import datetime
+
+from sqlalchemy import Connection, Engine, MetaData, select, Table, text, RowMapping, Sequence
+
+from sandwich.dialects import DialectHandlerFactory
+from sandwich.modeling import get_stg_info, infer_template, Dv2SystemInfo, Dv2Entity, StgInfo
+from sandwich.modeling.strategies import SchemaGenerator, StrategyFactory
+
+
+def _register_entity(entity_name: str, template: str, conn: Engine | Connection,
+                         verbose: bool = False) -> datetime:
+    entities = Table("entities", MetaData(), schema="core", autoload_with=conn)
+    created_result = conn.execute(select(entities.c.created).where(entity_name == entities.c.entity_name)).scalar_one_or_none()
+
+    if created_result is None:
+        created_result = datetime.now()
+        conn.execute(entities.insert().values(entity_name=entity_name, template=template, created=created_result))
+        if verbose:
+            print(f"[ok] Registered `{entity_name}` for `{template}`")
+    else:
+        _update_entity(entity_name, conn, entities, verbose=verbose)
+
+    return created_result
+
+def _update_entity(entity_name: str, conn: Engine | Connection, sys_entities: Table, verbose: bool = False) -> None:
+    conn.execute(
+        sys_entities.update().where(entity_name == sys_entities.c.entity_name).values(updated=datetime.now(), is_deleted=False))
+    if verbose:
+        print(f"[ok] Updated `{entity_name}`")
+
+
+def generate_schema(schema_generator: SchemaGenerator, registered_on: datetime, conn: Engine | Connection,
+                    verbose: bool = False) -> None:
+    tables = schema_generator.make_tables()
+    for table_type, table in tables.items():
+        if table is not None:
+            table.create(conn, checkfirst=True)
+            if verbose:
+                print(f"[ok] Created table [{table.schema}].[{table.name}]")
+
+    procedures = schema_generator.make_procedures(tables, registered_on)
+    for proc_type, (proc_code, proc_name, _) in procedures.items():
+        conn.execute(text(proc_code))
+        if verbose:
+            print(f"[ok] Created or altered {proc_name}")
+
+
+def _generate_schema_for_entity(stg_info: StgInfo, conn: Engine | Connection, dialect: str,
+                                registered_on: datetime, template: str | None, verbose: bool = False) -> None:
+    validator = StrategyFactory.create_validator(template)
+    sys_info = get_system_info(conn)
+    validation_result = validator.validate_staging(stg_info, sys_info)
+    dialect_handler = DialectHandlerFactory.create_handler(dialect)
+    schema_generator = StrategyFactory.create_generator(dialect_handler, validation_result)
+    generate_schema(schema_generator, registered_on, conn, verbose=verbose)
+
+
+def register_and_create_entity(entity_name: str, conn: Engine | Connection, dialect: str, template: str | None = None,
+                               schema: str = "stg", verbose: bool = False) -> None:
+    stg_info = get_stg_info(entity_name, schema, conn)
+    if template is None:
+        template = infer_template(stg_info)
+    registered_on = _register_entity(entity_name, template, conn)
+    _generate_schema_for_entity(stg_info, conn, dialect, registered_on, template, verbose=verbose)
+
+
+def update_registered_entities(conn: Engine | Connection, dialect: str, schema: str = "stg",
+                               verbose: bool = False) -> None:
+    sys_info = get_system_info(conn)
+    for en in sys_info.entities_list:
+        stg_info = get_stg_info(en.entity_name, schema, conn)
+        _update_entity(en.entity_name, conn, sys_info.sys_entities, verbose=verbose)
+        _generate_schema_for_entity(stg_info, conn, dialect, en.created_on, en.template, verbose=verbose)
+
+
+def get_system_info(conn: Engine | Connection):
+    sys_entities = Table("entities", MetaData(), schema="core", autoload_with=conn)
+    select_result = conn.execute(sys_entities.select().where(~sys_entities.c.is_deleted))
+    return Dv2SystemInfo(
+        [Dv2Entity(en["entity_name"], en["template"], en["created"]) for en in select_result.mappings().all()],
+        sys_entities
+    )

sandwich/errors.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+class _Dv2TemplatedError(Exception):
+    """Override `_template` with a string using `{value}` placeholder and optionally `{field}` placeholder.
+    Example: `_template = "User with {field}={value} not found"`
+    """
+
+    _template: str
+
+    def __init__(self, value: Any, field: str | None = None):
+        template = getattr(self, "_template", None)
+        if not template:
+            raise NotImplementedError("_template is not implemented")
+
+        if field:
+            message = template.format(field=field, value=value)
+        else:
+            message = template.format(value=value)
+
+        super().__init__(message)
+
+class Dv2NotYetImplementedForDialectError(_Dv2TemplatedError):
+    _template = "Not yet implemented for '{value}' dialect"
+    def __init__(self, value: Any):
+        super().__init__(value)

sandwich/modeling/__init__.py

@@ -0,0 +1,120 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Tuple
+
+from sqlalchemy import Table, Engine, Connection, MetaData
+
+@dataclass(frozen=True)
+class Dv2Entity:
+    entity_name: str
+    template: str
+    created_on: datetime
+
+
+@dataclass(frozen=True)
+class StgInfo:
+    stg_name: str
+    stg_schema: str
+    hk_keys: dict[str, Any]
+    bk_keys: dict[str, Any]
+    sys_columns: dict[str, Any]
+    bus_columns: dict[str, Any]
+    degenerate_field: Tuple[str, Any] | None = None
+
+@dataclass(frozen=True)
+class Dv2SystemInfo:
+    entities_list: list[Dv2Entity]
+    sys_entities: Table
+
+class Dv2ModelingMetadata:
+    HEADER_TEMPLATE = """/* 
+    =====================================================================
+    AUTO-GENERATED CODE — DO NOT EDIT MANUALLY
+    =====================================================================
+
+    This stored procedure was automatically generated by:
+      sandwich (https://pypi.org/project/sandwich/)
+
+    Manual changes are discouraged.
+    This file may be regenerated at any time, and all manual edits
+    will be overwritten.
+
+    Created on   : {created_on:%Y-%m-%d %H:%M:%S}
+    Updated on   : {updated_on:%Y-%m-%d %H:%M:%S}
+    Generator    : sandwich v{version}
+    Entity name  : {entity_name}
+
+    =====================================================================
+*/
+"""
+    loaddate = "LoadDate"
+    recordsource = "RecordSource"
+    hashdiff = "HashDiff"
+    is_available = "IsAvailable"
+    names: list[str] = [loaddate, recordsource, hashdiff, is_available]
+    # _dialects_config: dict[str, dict[str, str]] = {
+    #     "mssql": {
+    #         loaddate: "DATETIME2",
+    #         recordsource: "VARCHAR(200)",
+    #         hashdiff: "CHAR(40)",
+    #         is_available: "BIT",
+    #     },
+    #     "postgres": {
+    #         loaddate: "TIMESTAMP",
+    #         recordsource: "TEXT",
+    #         hashdiff: "CHAR(40)",
+    #         is_available: "BOOLEAN",
+    #     },
+    # }
+    def __init__(self):
+        #self.dialect = dialect
+
+        #self.column_types = self._dialects_config[self.dialect]
+        self.required_columns: list[str] = [self.loaddate, self.recordsource]
+
+modeling_metadata = Dv2ModelingMetadata()
+
+def get_stg_info(entity_name: str, schema: str, conn: Engine | Connection) -> StgInfo:
+    stg = Table(entity_name, MetaData(), schema=schema, autoload_with=conn)
+
+    hk_keys: dict[str, Any] = {}
+    bk_keys: dict[str, Any] = {}
+    sys_columns: dict[str, Any] = {}
+    bus_columns: dict[str, Any] = {}
+    degenerate_field: Tuple[str, Any] | None = None
+
+    for col in stg.columns.values():
+        if col.name.startswith("hk_"): # hash key
+            hk_keys[col.name] = col.type
+        elif col.name.startswith("bk_"): # business key
+            bk_keys[col.name] = col.type
+        elif col.name.startswith("dg_"): # degenerate field (transactional links only)
+            degenerate_field = (col.name, col.type)
+        elif col.name.startswith("sg_"): # surrogate key
+            raise Exception(f"sg column '{col.name}' is not implemented yet")
+        elif col.name in modeling_metadata.names:
+            # type_name = metadata.column_types[col.name]
+            # if not str(col.type).startswith(type_name):
+            #     raise Exception(f"{col.name} column must be `{type_name}` type, but it is `{str(col.type)}`")
+            sys_columns[col.name] = col.type
+        else:
+            bus_columns[col.name] = col.type
+
+    return StgInfo(
+        stg_name=stg.name,
+        stg_schema=stg.schema,
+        hk_keys=hk_keys,
+        bk_keys=bk_keys,
+        sys_columns=sys_columns,
+        bus_columns=bus_columns,
+        degenerate_field=degenerate_field,
+    )
+
+def infer_template(stg_info: StgInfo):
+    hk_count = len(stg_info.hk_keys)
+    if hk_count == 0:
+        raise Exception("hk column is required for `scd2dim` validation")
+    elif hk_count > 1:
+        return "link2fact"
+    else:
+        return "scd2dim"

sandwich/modeling/strategies/__init__.py

@@ -0,0 +1,15 @@
+from .base import SchemaGenerator, Validator
+from .factory import StrategyFactory
+from .link2fact import Link2FactValidator, Link2FactSchemaGenerator
+from .scd2dim import Scd2DimValidator, Scd2DimSchemaGenerator
+
+__all__ = [
+    "Validator",
+    "SchemaGenerator",
+    "StrategyFactory",
+    "Scd2DimValidator",
+    "Scd2DimSchemaGenerator",
+    "Link2FactValidator",
+    "Link2FactSchemaGenerator",
+]
+

sandwich/modeling/strategies/base.py

@@ -0,0 +1,94 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Callable, Tuple
+
+from sqlalchemy import Table
+
+from sandwich.modeling import Dv2SystemInfo, modeling_metadata, StgInfo
+
+@dataclass(frozen=True)
+class ValidationResult:
+    stg_schema: str
+    entity_name: str
+    bk_keys: list[Tuple[str, Any]]
+    hk_keys: list[Tuple[str, Any]]
+    business_column_types: dict[str, Any]
+    system_column_types: dict[str, Any]
+    template: str
+    degenerate_field: Tuple[str, Any] | None = None
+
+class Validator(ABC):
+    @abstractmethod
+    def validate_staging(self, stg_info: StgInfo, sys_info: Dv2SystemInfo, verbose: bool = False) -> ValidationResult:
+        pass
+
+class BaseValidator(Validator):
+    def __init__(self, template: str):
+        self._on_validate_staging: Callable[[StgInfo, Dv2SystemInfo], None] | None = None
+        self.template = template
+
+    def validate_staging(self, stg_info: StgInfo, sys_info: Dv2SystemInfo, verbose: bool = False) -> ValidationResult:
+        """Validate staging table or view for `scd2dim` template.
+
+        Raises: Exception"""
+        if verbose:
+            raise Exception("verbose is not implemented yet")
+
+        system_column_names = stg_info.sys_columns.keys()
+
+        # universal check - all dv2 raw objects should be auditable
+        for required_col in modeling_metadata.required_columns:
+            if required_col not in system_column_names:
+                raise Exception(f"{required_col} column is required")
+
+        if self._on_validate_staging is not None:
+            self._on_validate_staging(stg_info, sys_info)
+
+        # todo: ValidationResult is not required whatsoever
+        return ValidationResult(
+            stg_schema=stg_info.stg_schema,
+            entity_name=stg_info.stg_name,
+            bk_keys=[(nm, tp) for nm, tp in stg_info.bk_keys.items()],
+            hk_keys=[(nm, tp) for nm, tp in stg_info.hk_keys.items()],
+            degenerate_field = stg_info.degenerate_field,
+            business_column_types=stg_info.bus_columns,
+            system_column_types=stg_info.sys_columns,
+            template=self.template
+        )
+
+
+
+class SchemaGenerator(ABC):
+    @abstractmethod
+    def make_tables(self) -> dict[str, Table]:
+        pass
+
+    @abstractmethod
+    def make_procedures(
+        self,
+        tables: dict[str, Table],
+        entity_registration_date: datetime = datetime.now()
+    ) -> dict[str, Tuple[str, str, str]]:
+        pass
+
+# class BaseSchemaGenerator(SchemaGenerator):
+#     def __init__(self, dialect_handler: DialectHandler, validation_result: ValidationResult):
+#         self.dialect_handler = dialect_handler
+#         self._validation_result = validation_result
+#         self._on_make_proc: Callable[[Table, datetime], Tuple[str, str, str]] | None = None
+#
+#     def make_proc(self, tbl: Table, entity_registration_date: datetime) -> Tuple[str, str, str]:
+#         header = modeling_metadata.HEADER_TEMPLATE.format(
+#             created_on=entity_registration_date,
+#             updated_on=datetime.now(),
+#             version=SANDWICH_VERSION,
+#             entity_name=self._validation_result.entity_name
+#         )
+#
+#         if self._validation_result.stg_schema == "proxy":
+#             stg_proc_code, stg_proc_name, stg_call_stmt = self.dialect_handler.make_stg_materialization_proc(
+#                 entity_name=self._validation_result.entity_name,
+#                 header=header
+#             )
+#             procedures["stg"] = (stg_proc_code, stg_proc_name, stg_call_stmt)

sandwich/modeling/strategies/factory.py

@@ -0,0 +1,39 @@
+from src.sandwich.dialects import DialectHandler
+
+from .base import Validator, SchemaGenerator, ValidationResult
+from .link2fact import Link2FactValidator, Link2FactSchemaGenerator
+from .scd2dim import Scd2DimValidator, Scd2DimSchemaGenerator
+
+
+class StrategyFactory:
+    _strategies = {
+        "scd2dim": (Scd2DimValidator, Scd2DimSchemaGenerator),
+        "link2fact": (Link2FactValidator, Link2FactSchemaGenerator),
+    }
+
+    @classmethod
+    def register_strategy(cls, template_name: str, validator_class, generator_class):
+        cls._strategies[template_name] = (validator_class, generator_class)
+
+    @classmethod
+    def create_validator(cls, template: str) -> Validator:
+        if template not in cls._strategies:
+            available = ", ".join(cls._strategies.keys())
+            raise ValueError(f"Unknown template '{template}'. Available templates: {available}")
+
+        validator_class, _ = cls._strategies[template]
+        return validator_class(template)
+
+    @classmethod
+    def create_generator(cls, dialect_handler: DialectHandler, validation_result: ValidationResult) -> SchemaGenerator:
+        template = validation_result.template
+        if template not in cls._strategies:
+            available = ", ".join(cls._strategies.keys())
+            raise ValueError(f"Unknown template '{template}'. Available templates: {available}")
+
+        _, generator_class = cls._strategies[template]
+        return generator_class(dialect_handler, validation_result)
+
+    @classmethod
+    def get_available_templates(cls) -> list[str]:
+        return list(cls._strategies.keys())