sandwich 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

sandwich/dialects/mssql.py

@@ -0,0 +1,271 @@
+"""MSSQL dialect handler for SQL code generation."""
+from typing import Tuple
+
+from sqlalchemy import dialects, Table
+
+from .base import DialectHandler
+from .utils import get_columns_list
+
+class MssqlDialectHandler(DialectHandler):
+    """Dialect handler for Microsoft SQL Server."""
+
+    def get_boolean_type(self):
+        return dialects.mssql.BIT
+
+    def get_proc_name_format(self, schema: str, operation: str, entity_name: str) -> str:
+        """Get MSSQL procedure naming format."""
+        return f"[{schema}].[{operation}_{entity_name}]"
+
+    def apply_proc_template(self, proc_name: str, sql_body: str, header: str) -> str:
+        """Wrap SQL body in MSSQL procedure template with error handling."""
+        # language=sql
+        proc_template_sql = f"""
+{header}
+create or alter proc {proc_name} (@parent_executionID bigint = null) as
+begin
+    set nocount on;
+
+    declare @executionID bigint;
+    exec core.LogExecution @@PROCID, null, @executionID out, @parent_executionID;
+
+begin try
+    {sql_body}
+    exec core.LogExecution @@PROCID, @executionID, @executionID out;
+end try
+begin catch
+    declare @err table (ErrorID int);
+    declare @ErrorMessage NVARCHAR(4000);
+    declare @ErrorSeverity INT;
+    declare @ErrorState INT;
+
+    set @ErrorMessage = ERROR_MESSAGE();
+    set @ErrorSeverity = ERROR_SEVERITY();
+    set @ErrorState = ERROR_STATE();
+
+    insert into core.ErrorLog
+    output inserted.ErrorID into @err
+    values (
+        SUSER_SNAME(),
+        ERROR_NUMBER(),
+        @ErrorState,
+        @ErrorSeverity,
+        ERROR_LINE(),
+        ERROR_PROCEDURE(),
+        @ErrorMessage,
+        getdate()
+    );
+
+    update [core].[ExecutionLog]
+    set [errorID] = (select ErrorID from @err)
+    , [end_timestamp] = getdate()
+    where [executionID] = @executionID;
+
+    RAISERROR (
+        @ErrorMessage,
+        @ErrorSeverity,
+        @ErrorState
+    );
+end catch
+end
+"""
+        return proc_template_sql
+
+    def make_stg_materialization_proc(self, entity_name: str, header: str) -> Tuple[str, str, str]:
+        proc_name = self.get_proc_name_format("elt", f"Populate_stg", entity_name)
+
+        # language=sql
+        proc_body = f"""
+    if object_id('stg.{entity_name}') is not null drop table stg.{entity_name};
+    select *
+    into stg.{entity_name}
+    from proxy.{entity_name};
+"""
+        proc_code = self.apply_proc_template(proc_name, proc_body, header)
+        return proc_code, proc_name, f"exec {proc_name}"
+
+    def make_hub_proc(self, hub_table: Table, bk_keys: list, header: str) -> Tuple[str, str, str]:
+        proc_name = self.get_proc_name_format("elt", f"Populate_{hub_table.schema}", hub_table.name)
+        where_fields_list_str = " and ".join([f"hub.[{bk[0]}] = stg.[{bk[0]}]" for bk in bk_keys])
+        columns_list = get_columns_list(hub_table)
+
+        # language=sql
+        proc_body = f"""
+    insert into [{hub_table.schema}].[{hub_table.name}]
+    ({columns_list})
+    select distinct {get_columns_list(hub_table, alias="stg")}
+    from stg.[{hub_table.name}] as stg
+    where not exists (
+        select *
+        from [{hub_table.schema}].[{hub_table.name}] as hub
+        where {where_fields_list_str}
+    );
+"""
+        proc_code = self.apply_proc_template(proc_name, proc_body, header)
+        return proc_code, proc_name, f"exec {proc_name}"
+
+    def make_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, str]:
+        proc_name = self.get_proc_name_format("elt", f"Populate_{sat_table.schema}", sat_table.name)
+        columns_list = get_columns_list(sat_table)
+
+        def smart_replace(column_name: str) -> str:
+            if column_name == "LoadDate":
+                result = "sysdatetime() as [LoadDate]"
+            elif column_name == "IsAvailable":
+                result = "cast(0 as bit) as [IsAvailable]"
+            else:
+                result = f"sat.[{column_name}]"
+            return result
+
+        select_columns_list = ", ".join([smart_replace(col.name) for col in sat_table.columns.values()])
+
+        if stg_schema == "proxy":
+            stg_table_name = f"stg.[{sat_table.name}]"
+            materialization_stmt = ""
+        else:
+            stg_table_name = "#materialized"
+            materialization_stmt = f"""
+    select distinct {columns_list}
+    into #materialized
+    -- drop table #materialized
+    from stg.[{sat_table.name}];
+"""
+
+        # language=sql
+        proc_body = f"""{materialization_stmt}
+    with ranked_history as
+    (
+        select {columns_list}
+        , row_number() over (partition by [{hk_name}] order by [{loaddate_col}] desc) [DescRank]
+        from [{sat_table.schema}].[{sat_table.name}]
+    )
+    insert into [{sat_table.schema}].[{sat_table.name}]
+    ({columns_list})
+    select {get_columns_list(sat_table, alias="stg")}
+    from {stg_table_name} stg
+    where not exists (
+        select *
+        from ranked_history sat
+        where sat.[DescRank] = 1
+        and stg.[{hk_name}] = sat.[{hk_name}]
+        and stg.[{hashdiff_col}] = sat.[{hashdiff_col}]
+        and sat.[{is_available_col}] = 1
+    )
+
+    union all
+
+    select {select_columns_list}
+    from ranked_history sat
+    where not exists (
+        select *
+        from {stg_table_name} stg
+        where stg.[{hk_name}] = sat.[{hk_name}]
+    )
+    and sat.[DescRank] = 1
+    and sat.[{is_available_col}] = 1;
+"""
+        proc_code = self.apply_proc_template(proc_name, proc_body, header)
+        return proc_code, proc_name, f"exec {proc_name}"
+
+    def make_dim_scd2_proc(
+        self,
+        dim_table: Table,
+        bk_keys: list,
+        header: str
+    ) -> Tuple[str, str, str]:
+        proc_name = self.get_proc_name_format("elt", f"Recalculate_{dim_table.schema}", dim_table.name)
+        columns_list = get_columns_list(dim_table)
+        pk_keys = lambda: ", ".join([f"sat.[{bk[0]}]" for bk in bk_keys])
+
+        def smart_replace(column_name: str) -> str:
+            if column_name == "DateFrom":
+                result = "sat.LoadDate as [DateFrom]"
+            elif column_name == "DateTo":
+                result = f"lead(dateadd(microsecond, -1, sat.LoadDate), 1, '9999-12-31 23:59:59.9999999') over (partition by {pk_keys()} order by sat.LoadDate) [DateTo]"
+            elif column_name == "IsCurrent":
+                result = f"iif(lead(sat.LoadDate) over (partition by {pk_keys()} order by sat.LoadDate) is null, 1, 0) [IsCurrent]"
+            else:
+                result = f"sat.[{column_name}]"
+            return result
+
+        select_columns_list = "\n\t, ".join([smart_replace(col.name) for col in dim_table.columns.values()])
+
+        # language=sql
+        proc_body = f"""
+    truncate table [{dim_table.schema}].[{dim_table.name}];
+
+    insert into [{dim_table.schema}].[{dim_table.name}]
+    ({columns_list})
+    select {select_columns_list}
+    from sat.[{dim_table.name}] sat
+"""
+        proc_code = self.apply_proc_template(proc_name, proc_body, header)
+        return proc_code, proc_name, f"exec {proc_name}"
+
+    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, str]:
+        """Generate MSSQL job orchestration procedure."""
+        proc_name = f"[job].[Run_all_related_to_{entity_name}]"
+
+        stg_call = f"    exec {stg_proc_name} @executionID;\n" if stg_proc_name else ""
+
+        # language=sql
+        proc_body = f"""
+{stg_call}    exec {hub_proc_name} @executionID;
+    exec {sat_proc_name} @executionID;
+    exec {dim_proc_name} @executionID;
+"""
+        proc_code = self.apply_proc_template(proc_name, proc_body, header)
+        return proc_code, proc_name, f"exec {proc_name}"
+
+    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, str]:
+        """Generate MSSQL cleanup/drop procedure."""
+        proc_name = f"[meta].[Drop_all_related_to_{entity_name}]"
+
+        stg_drops = f"""
+    drop table if exists [stg].[{entity_name}];
+    drop procedure if exists {stg_proc_name};
+""" if stg_schema == "proxy" else ""
+
+        # language=sql
+        proc_body = f"""{stg_drops}
+    drop table if exists [dim].[{entity_name}];
+    drop procedure if exists {dim_proc_name};
+    drop table if exists [sat].[{entity_name}];
+    drop procedure if exists {sat_proc_name};
+    drop table if exists [hub].[{entity_name}];
+    drop procedure if exists {hub_proc_name};
+    drop procedure if exists {job_proc_name};
+
+    update core.[entities]
+    set [deleted] = sysdatetime()
+    , [is_deleted] = 1
+    where [entity_name] = '{entity_name}'
+"""
+        proc_code = self.apply_proc_template(proc_name, proc_body, header)
+        return proc_code, proc_name, f"exec {proc_name}"

sandwich/dialects/postgres.py

@@ -0,0 +1,108 @@
+"""Postgres dialect handler for SQL code generation."""
+from typing import Tuple
+
+from sqlalchemy import dialects, Table
+
+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_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_dim_scd2_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,149 @@
+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_proc_register_entity"] = header + ddl_mssql.create_proc_register_entity
+        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_proc_register_entity"] = ddl_postgres.create_proc_register_entity
+        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/dv2_helper.py

@@ -0,0 +1,98 @@
+from datetime import datetime
+
+from sqlalchemy import Connection, Engine, MetaData, Table, select, text
+
+from src.sandwich.dialects import DialectHandlerFactory
+from src.sandwich.modeling import get_stg_info, infer_template
+from src.sandwich.strategies import StrategyFactory
+
+from . import errors as err
+
+
+class Dv2Helper:
+
+    def __init__(self, stg: Table, dialect: str = "mssql", template: str | None = None):
+        stg_info = get_stg_info(stg)
+        if template is None:
+            template = infer_template(stg_info)
+        if template not in ("scd2dim", "link2fact"):
+            raise ValueError(
+                f"Template '{template}' is not supported. Supported templates: scd2dim, link2fact"
+            )
+
+        # legacy fields
+        self.stg_table = stg
+        self.entity_name = stg.name
+        self.template = template
+
+        self.dialect = dialect
+        self.dialect_handler = DialectHandlerFactory.create_handler(dialect)
+        self.validator = StrategyFactory.create_validator(template)
+        self.validation_result = self.validator.validate_staging(stg_info)
+        self.schema_generator = StrategyFactory.create_generator(template,
+                                                                 self.dialect_handler,
+                                                                 self.validation_result)
+
+        # Convenience properties (for backward compatibility if needed)
+        self.bk_keys = self.validation_result.bk_keys
+        self.hk_key = self.validation_result.hk_key
+        self.business_column_types = self.validation_result.business_column_types
+        self.system_column_types = self.validation_result.system_column_types
+
+    def call_register_entity(self, conn: Engine | Connection) -> datetime:
+        if self.dialect == "mssql":
+            call_stmt = "exec core.[register_entity] :entity_name, :template"
+        elif self.dialect == "postgres":
+            call_stmt = "call core.register_entity (:entity_name, :template)"
+        else:
+            raise err.Dv2NotYetImplementedForDialectError(self.dialect)
+
+        conn.execute(
+            text(call_stmt),
+            {
+                "entity_name": self.entity_name,
+                "template": self.template,
+            })
+
+        entities = Table("entities", MetaData(), schema="core", autoload_with=conn)
+        stmt = select(entities.c.created).where(self.entity_name == entities.c.entity_name)
+        return conn.execute(stmt).scalar_one()
+
+    # def call_job_proc(self, conn: Engine | Connection, parent_execution_id: int = -1) -> None:
+    #     job_proc_name = self.schema_generator.get_job_proc_name(self.entity_name, self.dialect)
+    #
+    #     if self.dialect == "mssql":
+    #         call_stmt = f"exec {job_proc_name} :parent_executionID"
+    #     else:
+    #         raise err.Dv2NotYetImplementedForDialectError(self.dialect)
+    #
+    #     conn.execute(text(call_stmt), {"parent_executionID": parent_execution_id})
+
+    def generate_schema(self, conn: Engine | Connection, verbose: bool = False) -> None:
+        registered_on = self.call_register_entity(conn)
+        if verbose:
+            print(f"[ok] Registered `{self.entity_name}` for `{self.template}`")
+
+        tables = self.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 = self.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}")
+
+    @classmethod
+    def update_registered_entities(cls, conn: Engine | Connection, dialect: str = "mssql",
+                                   verbose: bool = False):
+        metadata = MetaData()
+        entities = Table("entities", metadata, schema="core", autoload_with=conn)
+        select_result = conn.execute(entities.select().where(~entities.c.is_deleted))
+        for row in select_result.mappings().all():
+            stg = Table(row["entity_name"], metadata, schema="stg", autoload_with=conn)
+            dv2 = cls(stg, dialect=dialect, template=row["template"])
+            dv2.generate_schema(conn, verbose=verbose)

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)