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

sandwich/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+SANDWICH_VERSION = version("sandwich")

sandwich/dialects/__init__.py

@@ -0,0 +1,12 @@
+"""Dialects package for SQL code generation."""
+from src.sandwich.dialects.base import DialectHandler
+from src.sandwich.dialects.factory import DialectHandlerFactory
+from src.sandwich.dialects.mssql import MssqlDialectHandler
+from src.sandwich.dialects.postgres import PostgresDialectHandler
+
+__all__ = [
+    "DialectHandler",
+    "DialectHandlerFactory",
+    "MssqlDialectHandler",
+    "PostgresDialectHandler",
+]

sandwich/dialects/base.py

@@ -0,0 +1,166 @@
+from abc import ABC, abstractmethod
+from typing import Tuple
+
+from sqlalchemy import Table
+
+class DialectHandler(ABC):
+    @abstractmethod
+    def get_boolean_type(self): ...
+
+    @abstractmethod
+    def get_proc_name_format(self, schema: str, operation: str, entity_name: str) -> str:
+        pass
+
+    @abstractmethod
+    def apply_proc_template(self, proc_name: str, sql_body: str, header: str) -> str:
+        """Wrap SQL body in procedure template with error handling and logging.
+
+        Args:
+            proc_name: Name of the procedure
+            sql_body: The main SQL logic to execute
+            header: Auto-generated header comment
+
+        Returns:
+            Complete procedure definition
+        """
+        pass
+
+    @abstractmethod
+    def make_stg_materialization_proc(
+        self,
+        entity_name: str,
+        header: str
+    ) -> Tuple[str, str, str]:
+        """Generate staging table materialization procedure.
+
+        Args:
+            entity_name: Entity name
+            columns_list: Comma-separated list of columns
+            header: Auto-generated header comment
+
+        Returns:
+            Tuple of (procedure_code, procedure_name)
+        """
+        pass
+
+    @abstractmethod
+    def make_hub_proc(
+        self,
+        hub_table: Table,
+        bk_keys: list,
+        header: str
+    ) -> Tuple[str, str, str]:
+        """Generate hub population procedure.
+
+        Args:
+            hub_table: SQLAlchemy Table object for hub
+            bk_keys: List of business key tuples (name, type)
+            columns_list: Comma-separated list of columns
+            header: Auto-generated header comment
+
+        Returns:
+            Tuple of (procedure_code, procedure_name)
+        """
+        pass
+
+    @abstractmethod
+    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]:
+        """Generate satellite population procedure.
+
+        Args:
+            sat_table: SQLAlchemy Table object for satellite
+            hk_name: Hash key column name
+            hashdiff_col: Hash diff column name
+            is_available_col: Is available column name
+            loaddate_col: Load date column name
+            columns_list: Comma-separated list of columns
+            stg_schema: Staging schema name ('stg' or 'proxy')
+            header: Auto-generated header comment
+
+        Returns:
+            Tuple of (procedure_code, procedure_name)
+        """
+        pass
+
+    @abstractmethod
+    def make_dim_scd2_proc(
+        self,
+        dim_table: Table,
+        bk_keys: list,
+        header: str
+    ) -> Tuple[str, str, str]:
+        """Generate dimension SCD2 recalculation procedure.
+
+        Args:
+            dim_table: SQLAlchemy Table object for dimension
+            bk_keys: List of business key tuples (name, type)
+            columns_list: Comma-separated list of columns
+            header: Auto-generated header comment
+
+        Returns:
+            Tuple of (procedure_code, procedure_name)
+        """
+        pass
+
+    @abstractmethod
+    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 main job orchestration procedure.
+
+        Args:
+            entity_name: Entity name
+            hub_proc_name: Name of hub population procedure
+            sat_proc_name: Name of satellite population procedure
+            dim_proc_name: Name of dimension recalculation procedure
+            stg_proc_name: Name of staging materialization procedure (optional)
+            header: Auto-generated header comment
+
+        Returns:
+            Tuple of (procedure_code, procedure_name)
+        """
+        pass
+
+    @abstractmethod
+    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 cleanup/drop procedure for all entity objects.
+
+        Args:
+            entity_name: Entity name
+            stg_schema: Staging schema name ('stg' or 'proxy')
+            job_proc_name: Name of job orchestration procedure
+            stg_proc_name: Name of staging materialization procedure (optional)
+            hub_proc_name: Name of hub population procedure
+            sat_proc_name: Name of satellite population procedure
+            dim_proc_name: Name of dimension recalculation procedure
+            header: Auto-generated header comment
+
+        Returns:
+            Tuple of (procedure_code, procedure_name)
+        """
+        pass

sandwich/dialects/ddl_mssql.py

@@ -0,0 +1,148 @@
+# language=sql
+create_entities_table = """
+if object_id('core.entities') is null
+begin
+    create table core.entities (
+        [entity_id] bigint primary key identity,
+        [entity_name] varchar(100) not null,
+        [template] varchar(50) not null,
+        [created] datetime2(7) not null default sysdatetime(),
+        [updated] datetime2(7) not null default sysdatetime(),
+        [is_deleted] bit not null default 0,
+        [deleted] datetime2(7) default null,
+        unique ([entity_name])
+    );
+end
+"""
+
+# language=sql
+create_proc_register_entity = """
+create or alter proc core.register_entity (
+	@entity_name varchar(100),
+	@template varchar(50)
+) as
+begin
+	set nocount on;
+
+	if exists (
+		select *
+		from core.[entities]
+		where [entity_name] = @entity_name
+	)
+	begin
+		update core.[entities]
+		set [updated] = sysdatetime(), [is_deleted] = 0
+		where [entity_name] = @entity_name
+	end
+	else begin
+		insert into core.[entities]
+		([entity_name], [template])
+		values (@entity_name, @template)
+	end
+end
+"""
+
+# language=sql
+create_table_ExecutionLog = """
+if object_id('core.ExecutionLog') is null
+begin
+    create table [core].[ExecutionLog](
+        [executionID] [bigint] identity(1,1) primary key NOT NULL,
+        [procid] [int] NOT NULL,
+        [begin_timestamp] [datetime2](7) NOT NULL default (getdate()),
+        [end_timestamp] [datetime2](7) NULL default (NULL),
+        [errorID] [int] NULL,
+        [procname] [varchar](200) NULL,
+        [parent_executionID] [bigint] NULL
+    )
+end
+"""
+
+# language=sql
+create_table_ErrorLog = """
+if object_id('core.ErrorLog') is null
+begin
+    create table [core].[ErrorLog](
+        [ErrorID] [int] IDENTITY(1,1) NOT NULL,
+        [UserName] [varchar](100) NULL,
+        [ErrorNumber] [int] NULL,
+        [ErrorState] [int] NULL,
+        [ErrorSeverity] [int] NULL,
+        [ErrorLine] [int] NULL,
+        [ErrorProcedure] [varchar](max) NULL,
+        [ErrorMessage] [varchar](max) NULL,
+        [ErrorDateTime] [datetime] NULL
+    );
+end
+"""
+
+# language=sql
+create_func_StringToHash = """
+create or alter function [core].[StringToHash1]
+(
+	@StrValue1 nvarchar(1000)
+) returns char(40) as
+begin
+	declare @result char(40);
+	set @result = upper(convert(char(40), hashbytes('sha1',
+		upper(rtrim(ltrim(isnull(@StrValue1, ''))))
+	), 2));
+	return @result;
+end
+"""
+
+# language=sql
+create_schemas = """
+if schema_id('core') is null
+    exec ('create schema core')
+if schema_id('stg') is null
+    exec ('create schema stg')
+if schema_id('hub') is null
+    exec ('create schema hub')
+if schema_id('sat') is null
+    exec ('create schema sat')
+if schema_id('dim') is null
+    exec ('create schema dim')
+if schema_id('fact') is null
+    exec ('create schema fact')
+if schema_id('elt') is null
+    exec ('create schema elt')
+if schema_id('job') is null
+    exec ('create schema job')
+if schema_id('meta') is null
+    exec ('create schema meta')
+if schema_id('proxy') is null
+    exec ('create schema proxy')
+"""
+
+# language=sql
+create_proc_LogExecution = """
+create or alter proc [core].[LogExecution]
+(
+	@procid int,
+	@executionID_in bigint,
+	@executionID_out bigint out,
+	@parent_executionID bigint = null
+) as
+begin
+	set nocount on;
+
+	if @executionID_in is not null
+	begin
+		update [core].[ExecutionLog]
+		set [end_timestamp] = getdate()
+		where executionID = @executionID_in;
+
+		set @executionID_out = @executionID_in;
+	end else
+	begin
+
+		declare @out table (executionID int);
+		insert into [core].[ExecutionLog] (procid, procname, parent_executionID) output inserted.executionID
+		into @out
+		values (@procid, object_name(@procid), @parent_executionID);
+
+		set @executionID_out = (select executionID from @out);
+	end
+end
+"""

sandwich/dialects/ddl_postgres.py

@@ -0,0 +1,132 @@
+# language=sql
+create_extensions = """
+create extension if not exists pgcrypto;
+"""
+
+# language=sql
+create_entities_table = """
+CREATE TABLE IF NOT EXISTS core.entities (
+    entity_id BIGSERIAL PRIMARY KEY,
+    entity_name VARCHAR(100) NOT NULL,
+    template VARCHAR(50) NOT NULL,
+    created TIMESTAMP NOT NULL DEFAULT NOW(),
+    updated TIMESTAMP NOT NULL DEFAULT NOW(),
+    is_deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    deleted TIMESTAMP DEFAULT NULL,
+    UNIQUE (entity_name)
+);
+"""
+
+# language=sql
+create_proc_register_entity = """
+CREATE OR REPLACE PROCEDURE core.register_entity(
+    p_entity_name VARCHAR(100),
+    p_gen_path VARCHAR(50)
+)
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    INSERT INTO core.entities (entity_name, template)
+    VALUES (p_entity_name, p_gen_path)
+    ON CONFLICT (entity_name) DO UPDATE
+    SET updated = NOW(),
+        is_deleted = FALSE;
+END;
+$$;
+"""
+
+# language=sql
+create_func_StringToHash= """
+create or replace function core.string_to_hash1(str_value text)
+returns char(40)
+language plpgsql
+as $$
+declare
+    result char(40);
+begin
+    if str_value is null
+       or str_value in ('(unknown)', 'empty')
+    then
+        result := repeat('0', 40);
+    else
+        result :=
+            upper(
+                encode(
+                    digest(upper(trim(str_value)), 'sha1'),
+                    'hex'
+                )
+            );
+    end if;
+
+    return cast(result as char(40));
+end;
+$$;
+"""
+
+# language=sql
+create_table_ExecutionLog = """
+CREATE TABLE IF NOT EXISTS core.ExecutionLog (
+    executionID BIGSERIAL PRIMARY KEY,
+    procid INT NOT NULL,
+    begin_timestamp TIMESTAMP NOT NULL DEFAULT NOW(),
+    end_timestamp TIMESTAMP DEFAULT NULL,
+    errorID INT DEFAULT NULL,
+    procname VARCHAR(200) DEFAULT NULL,
+    parent_executionID BIGINT DEFAULT NULL
+);
+"""
+
+# language=sql
+create_table_ErrorLog = """
+CREATE TABLE IF NOT EXISTS core.ErrorLog (
+    ErrorID SERIAL PRIMARY KEY,
+    UserName VARCHAR(100) DEFAULT NULL,
+    ErrorNumber INT DEFAULT NULL,
+    ErrorState INT DEFAULT NULL,
+    ErrorSeverity INT DEFAULT NULL,
+    ErrorLine INT DEFAULT NULL,
+    ErrorProcedure TEXT DEFAULT NULL,
+    ErrorMessage TEXT DEFAULT NULL,
+    ErrorDateTime TIMESTAMP DEFAULT NULL
+);
+"""
+
+# language=sql
+create_proc_LogExecution = """
+CREATE OR REPLACE PROCEDURE core.LogExecution(
+    p_procid INT,
+    p_executionID_in BIGINT,
+    INOUT p_executionID_out BIGINT,
+    p_parent_executionID BIGINT DEFAULT NULL
+)
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    IF p_executionID_in IS NOT NULL THEN
+        UPDATE core.ExecutionLog
+        SET end_timestamp = NOW()
+        WHERE executionID = p_executionID_in;
+
+        p_executionID_out := p_executionID_in;
+    ELSE
+        INSERT INTO core.ExecutionLog (procid, procname, parent_executionID)
+        VALUES (p_procid, NULL, p_parent_executionID)
+        RETURNING executionID INTO p_executionID_out;
+    END IF;
+END;
+$$;
+"""
+
+# language=sql
+create_schemas = f"""
+CREATE SCHEMA IF NOT EXISTS core;
+CREATE SCHEMA IF NOT EXISTS stg;
+CREATE SCHEMA IF NOT EXISTS hub;
+CREATE SCHEMA IF NOT EXISTS sat;
+CREATE SCHEMA IF NOT EXISTS dim;
+CREATE SCHEMA IF NOT EXISTS fact;
+CREATE SCHEMA IF NOT EXISTS elt;
+CREATE SCHEMA IF NOT EXISTS job;
+CREATE SCHEMA IF NOT EXISTS meta;
+CREATE SCHEMA IF NOT EXISTS proxy;
+"""

sandwich/dialects/factory.py

@@ -0,0 +1,27 @@
+from src.sandwich.dialects.base import DialectHandler
+from src.sandwich.dialects.mssql import MssqlDialectHandler
+from src.sandwich.dialects.postgres import PostgresDialectHandler
+
+
+class DialectHandlerFactory:
+    _handlers = {
+        "mssql": MssqlDialectHandler,
+        "postgres": PostgresDialectHandler,
+    }
+
+    @classmethod
+    def register_dialect(cls, dialect_name: str, handler_class):
+        cls._handlers[dialect_name] = handler_class
+
+    @classmethod
+    def create_handler(cls, dialect: str) -> DialectHandler:
+        if dialect not in cls._handlers:
+            available = ", ".join(cls._handlers.keys())
+            raise ValueError(f"Unknown dialect '{dialect}'. Available dialects: {available}")
+
+        handler_class = cls._handlers[dialect]
+        return handler_class()
+
+    @classmethod
+    def get_available_dialects(cls) -> list[str]:
+        return list(cls._handlers.keys())