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

sandwich/modeling/strategies/link2fact.py

@@ -0,0 +1,225 @@
+"""Link to Fact strategy implementations."""
+from datetime import datetime
+from typing import Tuple
+
+from sqlalchemy import Column, MetaData, Table, UniqueConstraint
+
+from sandwich import SANDWICH_VERSION
+from sandwich.dialects.base import DialectHandler
+from sandwich.modeling import modeling_metadata, StgInfo, Dv2SystemInfo
+
+from .base import BaseValidator, SchemaGenerator, ValidationResult
+
+
+class Link2FactValidator(BaseValidator):
+    def __init__(self, template: str):
+        super().__init__(template)
+        self._on_validate_staging = self._validate_staging
+
+    @staticmethod
+    def _validate_staging(stg_info: StgInfo, sys_info: Dv2SystemInfo) -> None:
+        # -----------------
+        # hk
+        # -----------------
+        hk_count = len(stg_info.hk_keys)
+        stg_full_name = f"stg.{stg_info.stg_name}"
+
+        # so only exactly 2 or 3 columns allowed right now
+        if hk_count < 2: # own and at least one foreign
+            raise Exception(f"At least 2 hk columns expected in `{stg_full_name}` for the `link2fact` template")
+        if hk_count > 3:
+            raise Exception(f"{hk_count} hk columns in `{stg_full_name}` for the `link2fact` template?! Are you sure?")
+        if stg_info.degenerate_field is None:
+            raise Exception(f"Degenerate field is required for `{stg_full_name}` for the `link2fact` template")
+
+        # hk_key = (key_name, key_type)
+        hk_keys_copy = list(stg_info.hk_keys.keys()).copy()
+        is_own_hk_found = False
+        expected_own_hk_column_name = f"hk_{stg_info.stg_name}"
+
+        for hk_name in stg_info.hk_keys.keys():
+            if hk_name == expected_own_hk_column_name:
+                hk_keys_copy.remove(hk_name)
+                is_own_hk_found = True
+            else:
+                # check that `name` from `hk_[name]` is existing entity
+                for en in sys_info.entities_list:
+                    if hk_name == f"hk_{en.entity_name}":
+                        hk_keys_copy.remove(hk_name)
+
+        if not is_own_hk_found:
+            raise Exception(f"Column `{expected_own_hk_column_name}` has not been found in `{stg_full_name}`")
+
+        if len(hk_keys_copy) > 0:
+            raise Exception(f"There are no entities related to `{", ".join(hk_keys_copy)}` columns in the `{stg_full_name}`")
+
+        # -----------------
+        # BKs
+        # -----------------
+        # it should be a warning, not an error
+        if len(stg_info.bk_keys) > 0:
+            raise Exception("You dont need bk columns for the `link2fact` template")
+
+
+class Link2FactSchemaGenerator(SchemaGenerator):
+
+    def __init__(self, dialect_handler: DialectHandler, validation_result: ValidationResult):
+        self.dialect_handler = dialect_handler
+        self._validation_result = validation_result
+
+    def make_tables(self) -> dict[str, Table]:
+        return {
+            "link": self.make_link_table(),
+            "sat": self.make_sat_table(),
+            #"fact": self.make_fact_table(),
+        }
+
+    def make_link_table(self) -> Table:
+        entity_name = self._validation_result.entity_name
+
+        # Create link table
+        link_table = Table(entity_name, MetaData(), schema="link")
+        uks: list[str] = []
+
+        # HKs (own and FKs)
+        for hk_key in self._validation_result.hk_keys:
+            if hk_key[0] == f"hk_{entity_name}":
+                col = Column(hk_key[0], hk_key[1], primary_key=True)
+            else:
+                uks.append(hk_key[0])
+                col = Column(hk_key[0], hk_key[1], nullable=False)
+            link_table.append_column(col)
+        dg_key = self._validation_result.degenerate_field
+        link_table.append_column(Column(dg_key[0], dg_key[1], nullable=False))
+        uks.append(dg_key[0])
+        link_table.append_constraint(UniqueConstraint(*uks))
+
+        # LoadDate
+        load_date = modeling_metadata.loaddate
+        load_date_type = self._validation_result.system_column_types[load_date]
+        load_date_col = Column(load_date, load_date_type, nullable=False)
+        link_table.append_column(load_date_col)
+
+        # RecordSource
+        record_source = modeling_metadata.recordsource
+        record_source_type = self._validation_result.system_column_types[record_source]
+        record_source_col = Column(record_source, record_source_type, nullable=False)
+        link_table.append_column(record_source_col)
+
+        return link_table
+
+    def make_sat_table(self) -> Table:
+        entity_name = self._validation_result.entity_name
+
+        # Create sat table
+        sat_table = Table(entity_name, MetaData(), schema="sat")
+
+        # own HK
+        for hk_key in self._validation_result.hk_keys:
+            if hk_key[0] == f"hk_{entity_name}":
+                col = Column(hk_key[0], hk_key[1], primary_key=True)
+                sat_table.append_column(col)
+        # for transactional links
+        dg_key = self._validation_result.degenerate_field
+        if dg_key is not None:
+            sat_table.append_column(Column(dg_key[0], dg_key[1], nullable=False))
+
+
+        # LoadDate
+        load_date = modeling_metadata.loaddate
+        load_date_type = self._validation_result.system_column_types[load_date]
+        load_date_col = Column(load_date, load_date_type, nullable=False)
+        sat_table.append_column(load_date_col)
+
+        # RecordSource
+        record_source = modeling_metadata.recordsource
+        record_source_type = self._validation_result.system_column_types[record_source]
+        record_source_col = Column(record_source, record_source_type, nullable=False)
+        sat_table.append_column(record_source_col)
+
+        for (name_, type_) in self._validation_result.business_column_types.items():
+            col = Column(name_, type_, nullable=True)
+            sat_table.append_column(col)
+
+        return sat_table
+
+    def make_fact_table(self) -> Table:
+        entity_name = self._validation_result.entity_name
+
+        # Create a fact table
+        fact_table = Table(entity_name, MetaData(), schema="fact")
+
+        # not own HKs only
+        for hk_key in self._validation_result.hk_keys:
+            if hk_key[0] != f"hk_{entity_name}":
+                col = Column(hk_key[0], hk_key[1], primary_key=True)
+                fact_table.append_column(col)
+
+        for (name_, type_) in self._validation_result.business_column_types.items():
+            col = Column(name_, type_, nullable=True)
+            fact_table.append_column(col)
+
+        return fact_table
+
+    def make_procedures(self, tables: dict[str, Table]
+                        , entity_registration_date: datetime = datetime.now()) -> dict[str, Tuple[str, str, str]]:
+        procedures = {}
+
+        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
+        )
+
+        stg_proc_name = None
+        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)
+
+        link_table = tables["link"]
+        link_proc_code, link_proc_name, link_call_stmt = self.dialect_handler.make_link_proc(
+            link_table=link_table,
+            hk_keys=self._validation_result.hk_keys + [self._validation_result.degenerate_field],
+            header=header
+        )
+        procedures["link"] = (link_proc_code, link_proc_name, link_call_stmt)
+
+        sat_table = tables["sat"]
+        sat_proc_code, sat_proc_name, sat_call_stmt = self.dialect_handler.make_scd0_sat_proc(
+            sat_table=sat_table,
+            header=header
+        )
+        procedures["sat"] = (sat_proc_code, sat_proc_name, sat_call_stmt)
+
+        # job procedure
+        job_proc_names = [] # order-sensitive
+        if self._validation_result.stg_schema == "proxy":
+            job_proc_names.append(stg_proc_name)
+        job_proc_names.extend([link_proc_name, sat_proc_name])
+        job_proc_code, job_proc_name, job_call_stmt = self.dialect_handler.make_job_proc(
+            entity_name=self._validation_result.entity_name,
+            proc_names=job_proc_names,
+            header=header
+        )
+        procedures["job"] = (job_proc_code, job_proc_name, job_call_stmt)
+
+        # drop procedure
+        drop_table_schemas = ["link", "sat"]
+        if self._validation_result.stg_schema == "proxy":
+            drop_table_schemas.append("stg")
+        drop_proc_names = [link_proc_name, sat_proc_name]
+        if self._validation_result.stg_schema == "proxy":
+            drop_proc_names.append(stg_proc_name)
+        drop_proc_code, drop_proc_name, drop_call_stmt = self.dialect_handler.make_drop_proc(
+            entity_name=self._validation_result.entity_name,
+            table_schemas=drop_table_schemas,
+            procedures=drop_proc_names,
+            header=header
+        )
+        procedures["drop"] = (drop_proc_code, drop_proc_name, drop_call_stmt)
+
+        return procedures

sandwich/{strategies → modeling/strategies}/scd2dim.py

@@ -3,22 +3,20 @@ from typing import Iterator, Tuple
 
 from sqlalchemy import Column, MetaData, Table, UniqueConstraint
 
-from src.sandwich import SANDWICH_VERSION
-from src.sandwich.dialects.base import DialectHandler
-from src.sandwich.modeling import modeling_metadata, StgInfo
+from sandwich import SANDWICH_VERSION
+from sandwich.dialects.base import DialectHandler
+from sandwich.modeling import modeling_metadata, StgInfo, Dv2SystemInfo
 
-from .base import Validator, SchemaGenerator, ValidationResult
+from .base import BaseValidator, SchemaGenerator, ValidationResult
 
 
-class Scd2DimValidator(Validator):
-
-    def validate_staging(self, stg_info: StgInfo, verbose: bool = False) -> ValidationResult:
-        """Validate staging table or view for `scd2dim` template.
-
-        Raises: Exception"""
-        if verbose:
-            raise Exception("verbose is not implemented yet")
+class Scd2DimValidator(BaseValidator):
+    def __init__(self, template: str):
+        super().__init__(template)
+        self._on_validate_staging = self._validate_staging
 
+    @staticmethod
+    def _validate_staging(stg_info: StgInfo, _: Dv2SystemInfo) -> None:
         # -----------------
         # hk
         # -----------------
@@ -47,40 +45,21 @@ class Scd2DimValidator(Validator):
 
         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")
-
-        # scd2dim specific validations
         if modeling_metadata.hashdiff not in system_column_names:
             raise Exception(f"{modeling_metadata.hashdiff} column is required for scd2dim validation")
         if modeling_metadata.is_available not in system_column_names:
             raise Exception(f"{modeling_metadata.is_available} column is required for scd2dim validation")
 
-        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_key=hk_key,
-            business_column_types=stg_info.bus_columns,
-            system_column_types=stg_info.sys_columns,
-        )
-
 class Scd2DimSchemaGenerator(SchemaGenerator):
 
     def __init__(self, dialect_handler: DialectHandler, validation_result: ValidationResult):
         self.dialect_handler = dialect_handler
         self._validation_result = validation_result
 
-    @property
-    def entity_info(self) -> ValidationResult:
-        return self._validation_result
-
     def make_tables(self) -> dict[str, Table]:
         entity_name = self._validation_result.entity_name
         bk_keys = self._validation_result.bk_keys
-        hk_key = self._validation_result.hk_key
+        hk_key = self._validation_result.hk_keys[0]
         business_column_types = self._validation_result.business_column_types
         system_column_types = self._validation_result.system_column_types
 
@@ -199,9 +178,9 @@ class Scd2DimSchemaGenerator(SchemaGenerator):
 
         # Generate sat procedure
         sat_table = tables["sat"]
-        sat_proc_code, sat_proc_name, sat_call_stmt = self.dialect_handler.make_sat_proc(
+        sat_proc_code, sat_proc_name, sat_call_stmt = self.dialect_handler.make_scd2_sat_proc(
             sat_table=sat_table,
-            hk_name=self._validation_result.hk_key[0],
+            hk_name=self._validation_result.hk_keys[0][0],
             hashdiff_col=modeling_metadata.hashdiff,
             is_available_col=modeling_metadata.is_available,
             loaddate_col=modeling_metadata.loaddate,
@@ -212,7 +191,7 @@ class Scd2DimSchemaGenerator(SchemaGenerator):
 
         # Generate dim procedure
         dim_table = tables["dim"]
-        dim_proc_code, dim_proc_name, dim_call_stmt = self.dialect_handler.make_dim_scd2_proc(
+        dim_proc_code, dim_proc_name, dim_call_stmt = self.dialect_handler.make_scd2_dim_proc(
             dim_table=dim_table,
             bk_keys=self._validation_result.bk_keys,
             header=header
@@ -220,25 +199,28 @@ class Scd2DimSchemaGenerator(SchemaGenerator):
         procedures["dim"] = (dim_proc_code, dim_proc_name, dim_call_stmt)
 
         # Generate job procedure
+        job_proc_names = [] # order-sensitive
+        if self._validation_result.stg_schema == "proxy":
+            job_proc_names.append(stg_proc_name)
+        job_proc_names.extend([hub_proc_name, sat_proc_name, dim_proc_name])
         job_proc_code, job_proc_name, job_call_stmt = self.dialect_handler.make_job_proc(
             entity_name=self._validation_result.entity_name,
-            hub_proc_name=hub_proc_name,
-            sat_proc_name=sat_proc_name,
-            dim_proc_name=dim_proc_name,
-            stg_proc_name=stg_proc_name,
+            proc_names=job_proc_names,
             header=header
         )
         procedures["job"] = (job_proc_code, job_proc_name, job_call_stmt)
 
         # Generate drop procedure
+        drop_table_schemas = ["hub", "sat", "dim"]
+        if self._validation_result.stg_schema == "proxy":
+            drop_table_schemas.append("stg")
+        drop_proc_names = [job_proc_name, hub_proc_name, sat_proc_name, dim_proc_name]
+        if self._validation_result.stg_schema == "proxy":
+            drop_proc_names.append(stg_proc_name)
         drop_proc_code, drop_proc_name, drop_call_stmt = self.dialect_handler.make_drop_proc(
             entity_name=self._validation_result.entity_name,
-            stg_schema=self._validation_result.stg_schema,
-            job_proc_name=job_proc_name,
-            stg_proc_name=stg_proc_name,
-            hub_proc_name=hub_proc_name,
-            sat_proc_name=sat_proc_name,
-            dim_proc_name=dim_proc_name,
+            table_schemas=drop_table_schemas,
+            procedures=drop_proc_names,
             header=header
         )
         procedures["drop"] = (drop_proc_code, drop_proc_name, drop_call_stmt)

{sandwich-0.2.2.dist-info → sandwich-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sandwich
-Version: 0.2.2
+Version: 0.3.0
 Summary: DataVault 2.0 code gen
 Keywords: DWH,Data Vault 2.0
 Author: Andrey Morozov
@@ -124,14 +124,14 @@ select cast(31 as bigint) [bk_id]
 |                    |                        |                            | DateTo             |
 
 ### link2fact profile columns mapping:
-| stg                | link                   | sat                        | fact |
-|--------------------|------------------------|----------------------------|------|
-| HKs...             | (uk)(fk)HKs...         |                            |      |
-| hk_`[entity_name]` | (pk)hk_`[entity_name]` | (pk)(fk)hk_`[entity_name]` |      |
-| degenerate_field   | (uk)degenerate_field   | degenerate_field           |      |
-| LoadDate           | LoadDate               | LoadDate                   |      |
-| RecordSource       | RecordSource           | RecordSource               |      |
-| FLDs...            |                        | FLDs...                    |      |
+| stg                | link                           | sat                        | fact |
+|--------------------|--------------------------------|----------------------------|------|
+| HKs...             | (uk)(fk)hk_`other_entity_name` |                            |      |
+| hk_`[entity_name]` | (pk)hk_`[entity_name]`         | (pk)(fk)hk_`[entity_name]` |      |
+| <degenerate_field> | (uk)<degenerate_field>         | <degenerate_field>         |      |
+| LoadDate           | LoadDate                       | LoadDate                   |      |
+| RecordSource       | RecordSource                   | RecordSource               |      |
+| FLDs...            |                                | FLDs...                    |      |
 
 
 ### Schemas:
@@ -147,11 +147,13 @@ select cast(31 as bigint) [bk_id]
 * `proxy` - source data for a materialized staging area (meant for wrapping external data sources as SQL views)
 
 ### DV2-related schemas layering
-| LoB*  | staging | raw vault | business vault | information vault |
-|-------|---------|-----------|----------------|-------------------|
-| proxy | stg     | hub       | sal            | dim               |
-|       |         | sat       |                | fact              |
-|       |         | link      |                |                   |
+    data -> ELT -> report
+
+| LoB* data | staging (E) | raw vault (L) | business vault (T) | information vault |
+|-----------|-------------|---------------|--------------------|-------------------|
+|           | stg         | hub           | sal                | dim               |
+|           | proxy       | sat           |                    | fact              |
+|           | pool        | link          |                    |                   |
 _* Line of Business applications_
 
 ### Usage diagram
@@ -174,4 +176,4 @@ _* Line of Business applications_
           +           +--------+          +---------------+
           +                           
 
-```
+```

sandwich-0.3.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+sandwich/__init__.py,sha256=DiQSmvml9OXujAYHILR4jz8UjoxbMvxFgRIlsdRza1E,80
+sandwich/dialects/__init__.py,sha256=zQ4oigT3yqjZyl_IL_Tc-GmyoJar_Oqj_bGyiRVdSjg,415
+sandwich/dialects/base.py,sha256=5wRh4T4e-SJbB-8eYtyQhd01HG-c0-x52tda7HFzSGs,3759
+sandwich/dialects/ddl_mssql.py,sha256=VkwkJ373hDQNe2y9d9M3YJCdeCJmleUzk1hxvJjEhbA,3362
+sandwich/dialects/ddl_postgres.py,sha256=Mdk2dAcSp8Nwc0p98nCnRtQ3vT09lH-cJVa6SdLLuwg,2995
+sandwich/dialects/factory.py,sha256=-mpWGKp8NRmTFCXVlhbTsGhR0oAwOEdm-xnBolwWrQo,911
+sandwich/dialects/mssql.py,sha256=laSPSfZR38aP3DBDHxv0YKwXC60kevVpyqjUmVu1xhk,10226
+sandwich/dialects/postgres.py,sha256=8wVuqKqVxT0Mch6opK81qAyP-UaVDz5OvCuC5LEbe-U,4030
+sandwich/dialects/utils.py,sha256=mdFp5jkJquhnYB3wiRjRunsGcHtmpcbjBzzgONfbM7w,5774
+sandwich/dwh/__init__.py,sha256=e1Pev1TtNBO0rikHY8GrkfjcSdu8ow7xadlqvpiIHwE,4157
+sandwich/errors.py,sha256=kIJmYbUf9wOnshJbFHwhqxZ3qEEdVtOy5Dcb2bSdnAk,872
+sandwich/main.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sandwich/modeling/__init__.py,sha256=owIplBqXoHBoiQ2D_zmckaFsXcXEl4kgT3HwBqPuLUU,4091
+sandwich/modeling/strategies/__init__.py,sha256=VePgBfvPCLl4_GJIWlbN-VbWjB7iD0ztPjMYuzIsi3U,403
+sandwich/modeling/strategies/base.py,sha256=_5mWrQEmyx5BESIxaZ6eC7GZjCoFQNJ9p0gXqDfGBVA,3583
+sandwich/modeling/strategies/factory.py,sha256=Lc1MugJ-3g335lcXb3H4mVJgD0toDTYR-dmsK6-n1Yw,1598
+sandwich/modeling/strategies/link2fact.py,sha256=KPaccOWqMmpiXA6U9Pb7IAhSQAl-xN3QaiX4jVcWRIY,9229
+sandwich/modeling/strategies/scd2dim.py,sha256=qHlMj800lk6W7ipT9LsM_sND-EqYVttE5qIqEGGHmk8,10194
+sandwich/py.typed,sha256=70pF0eMpuZgOyb0zFSE07ugId_AoU5z6CpLlVfg3pik,34
+sandwich-0.3.0.dist-info/WHEEL,sha256=YUH1mBqsx8Dh2cQG2rlcuRYUhJddG9iClegy4IgnHik,79
+sandwich-0.3.0.dist-info/entry_points.txt,sha256=0GSrDEOq9Qo5CwxppoVq-HNcILK65PchNmI6J0ripq8,44
+sandwich-0.3.0.dist-info/METADATA,sha256=KccsRqwgn-UPVEDAUkmfekTHaYw3SVRlJW-0RByVnAM,9127
+sandwich-0.3.0.dist-info/RECORD,,

sandwich/dv2_helper.py

@@ -1,98 +0,0 @@
-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/strategies/base.py

@@ -1,44 +0,0 @@
-from abc import ABC, abstractmethod
-from datetime import datetime
-from typing import Any, Tuple
-
-from sqlalchemy import Table
-
-from src.sandwich.modeling import StgInfo
-
-class ValidationResult:
-    def __init__(self, stg_schema: str, entity_name: str
-                 , bk_keys: list[Tuple[str, Any]]
-                 , hk_key: Tuple[str, Any]
-                 , business_column_types: dict[str, Any]
-                 , system_column_types: dict[str, Any]):
-        self.stg_schema = stg_schema
-        self.entity_name = entity_name
-        self.bk_keys = bk_keys
-        self.hk_key = hk_key
-        self.business_column_types = business_column_types
-        self.system_column_types = system_column_types
-
-class Validator(ABC):
-    @abstractmethod
-    def validate_staging(self, stg_info: StgInfo, verbose: bool = False) -> ValidationResult:
-        pass
-
-
-class SchemaGenerator(ABC):
-    @property
-    @abstractmethod
-    def entity_info(self) -> ValidationResult: ...
-
-    @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
-

sandwich/strategies/link2fact.py

@@ -1,91 +0,0 @@
-"""Link to Fact strategy implementations."""
-from datetime import datetime
-from typing import Tuple
-
-from sqlalchemy import Table
-
-from src.sandwich.dialects.base import DialectHandler
-
-from .base import Validator, SchemaGenerator, ValidationResult
-
-
-class Link2FactValidator(Validator):
-
-    def validate_staging(self, stg_info: StgInfo, verbose: bool = False) -> dict:
-        """Validate staging table for link2fact mode."""
-        if verbose:
-            raise Exception("verbose is not implemented yet")
-
-        # TODO: Implement link2fact specific validation logic
-        # This will likely be different from scd2dim validation
-        # For example: checking for link keys, fact columns, etc.
-
-        bk_keys = []
-        hk_key = None
-        business_column_types = {}
-        system_column_types = {}
-        link_keys = []  # New concept for link2fact
-        fact_columns = []  # New concept for link2fact
-
-        # Placeholder validation logic
-        for col in stg_table.columns.values():
-            # TODO: Implement column classification for link2fact mode
-            pass
-
-        return {
-            "stg_schema": stg_table.schema,
-            "entity_name": stg_table.name,
-            "bk_keys": bk_keys,
-            "hk_key": hk_key,
-            "business_column_types": business_column_types,
-            "system_column_types": system_column_types,
-            "link_keys": link_keys,
-            "fact_columns": fact_columns,
-        }
-
-
-class Link2FactSchemaGenerator(SchemaGenerator):
-
-    def __init__(self, dialect_handler: DialectHandler, validation_result: ValidationResult):
-        self.dialect_handler = dialect_handler
-        self._validation_result = validation_result
-
-    @property
-    def entity_info(self) -> ValidationResult:
-        return self._validation_result
-
-    def make_tables(self) -> dict[str, Table]:
-        """Create link and fact tables for link2fact mode."""
-        # TODO: Implement link2fact table creation
-        # This will create different table structures than scd2dim
-        # For example: link table, fact table (instead of hub/sat/dim)
-
-        entity_name = self._validation_result.entity_name
-
-        # Placeholder - actual implementation needed
-        link_table: Table | None = None
-        fact_table: Table | None = None
-
-        return {
-            "link": link_table,
-            "fact": fact_table,
-        }
-
-    def make_procedures(
-        self,
-        tables: dict[str, Table],
-        entity_registration_date: datetime,
-    ) -> dict[str, Tuple[str, str]]:
-        """Generate procedures for link2fact mode."""
-        procedures = {}
-
-        # TODO: Implement link2fact procedure generation using dialect_handler
-        # This will generate different procedures than scd2dim
-        # For example: link population, fact population, aggregation logic, etc.
-
-        # When implementing, use self.dialect_handler methods to generate SQL
-        # Example:
-        # link_proc_code, link_proc_name = self.dialect_handler.make_link_proc(...)
-        # procedures["link"] = (link_proc_code, link_proc_name)
-
-        return procedures