pytrilogy 0.3.138__cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

trilogy/dialect/postgres.py

@@ -0,0 +1,91 @@
+from typing import Any, Callable, Mapping
+
+from jinja2 import Template
+
+from trilogy.core.enums import DatePart, FunctionType, WindowType
+from trilogy.dialect.base import BaseDialect
+
+
+def date_diff(first: str, second: str, grain: DatePart) -> str:
+    grain = DatePart(grain)
+    if grain == DatePart.YEAR:
+        return f"date_part('year', {second}) - date_part('year', {first})"
+    elif grain == DatePart.MONTH:
+        return f"12 * {date_diff(first, second, DatePart.YEAR)} + date_part('month', {second}) - date_part('month', {first})"
+    elif grain == DatePart.DAY:
+        return f"date_part('day', {second} - {first})"
+    elif grain == DatePart.HOUR:
+        return f"{date_diff(first, second, DatePart.DAY)} *24 + date_part('hour', {second} - {first})"
+    elif grain == DatePart.MINUTE:
+        return f"{date_diff(first, second, DatePart.HOUR)} *60 + date_part('minute', {second} - {first})"
+    elif grain == DatePart.SECOND:
+        return f"{date_diff(first, second, DatePart.MINUTE)} *60 + date_part('second', {second} - {first})"
+    else:
+        raise NotImplementedError(f"Date diff not implemented for grain {grain}")
+
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.SPLIT: lambda x, types: f"string_to_array({x[0]}, {x[1]})",
+    FunctionType.DATE_TRUNCATE: lambda x, types: f"date_trunc('{x[1]}', {x[0]})",
+    FunctionType.DATE_ADD: lambda x, types: f"({x[0]} + INTERVAL '{x[2]} {x[1]}')",
+    FunctionType.DATE_PART: lambda x, types: f"date_part('{x[1]}', {x[0]})",
+    FunctionType.DATE_DIFF: lambda x, types: date_diff(x[0], x[1], x[2]),
+    FunctionType.IS_NULL: lambda x, types: f"{x[0]} IS NULL",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT_DISTINCT: lambda args, types: f"CASE WHEN{args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.COUNT: lambda args, types: f"CASE WHEN {args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.SUM: lambda args, types: f"{args[0]}",
+    FunctionType.AVG: lambda args, types: f"{args[0]}",
+}
+
+PG_SQL_TEMPLATE = Template(
+    """{%- if output %}
+DROP TABLE IF EXISTS {{ output.address.location }};
+CREATE TABLE {{ output.address.location }} AS
+{% endif %}{%- if ctes %}
+WITH {% for cte in ctes %}
+{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+{%- if full_select -%}
+{{full_select}}
+{%- else -%}
+SELECT
+{%- for select in select_columns %}
+    {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
+{% if base %}FROM
+    {{ base }}{% endif %}{% if joins %}
+{% for join in joins %}
+{{ join }}
+{% endfor %}{% endif %}
+{% if where %}WHERE
+    {{ where }}
+{% endif %}
+{%- if group_by %}GROUP BY {% for group in group_by %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
+{%- if order_by %}
+ORDER BY {% for order in order_by %}
+    {{ order }}{% if not loop.last %},{% endif %}
+{% endfor %}{% endif %}
+{%- if limit is not none %}
+LIMIT {{ limit }}{% endif %}{% endif %}
+"""
+)
+
+MAX_IDENTIFIER_LENGTH = 50
+
+
+class PostgresDialect(BaseDialect):
+    WINDOW_FUNCTION_MAP = {**BaseDialect.WINDOW_FUNCTION_MAP, **WINDOW_FUNCTION_MAP}
+    FUNCTION_MAP = {**BaseDialect.FUNCTION_MAP, **FUNCTION_MAP}
+    FUNCTION_GRAIN_MATCH_MAP = {
+        **BaseDialect.FUNCTION_GRAIN_MATCH_MAP,
+        **FUNCTION_GRAIN_MATCH_MAP,
+    }
+    QUOTE_CHARACTER = '"'
+    SQL_TEMPLATE = PG_SQL_TEMPLATE

trilogy/dialect/presto.py

@@ -0,0 +1,104 @@
+from typing import Any, Callable, Mapping
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, GroupMode, UnnestMode, WindowType
+from trilogy.core.models.core import DataType
+from trilogy.dialect.base import BaseDialect
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.COUNT: lambda x, types: f"count({x[0]})",
+    FunctionType.SUM: lambda x, types: f"sum({x[0]})",
+    FunctionType.LENGTH: lambda x, types: f"length({x[0]})",
+    FunctionType.AVG: lambda x, types: f"avg({x[0]})",
+    FunctionType.INDEX_ACCESS: lambda x, types: f"element_at({x[0]},{x[1]})",
+    FunctionType.MAP_ACCESS: lambda x, types: f"{x[0]}[{x[1]}]",
+    FunctionType.LIKE: lambda x, types: (
+        f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
+    ),
+    FunctionType.MINUTE: lambda x, types: f"EXTRACT(MINUTE from {x[0]})",
+    FunctionType.SECOND: lambda x, types: f"EXTRACT(SECOND from {x[0]})",
+    FunctionType.HOUR: lambda x, types: f"EXTRACT(HOUR from {x[0]})",
+    FunctionType.DAY_OF_WEEK: lambda x, types: f"EXTRACT(DAYOFWEEK from {x[0]})",
+    FunctionType.DAY: lambda x, types: f"EXTRACT(DAY from {x[0]})",
+    FunctionType.YEAR: lambda x, types: f"EXTRACT(YEAR from {x[0]})",
+    FunctionType.MONTH: lambda x, types: f"EXTRACT(MONTH from {x[0]})",
+    FunctionType.WEEK: lambda x, types: f"EXTRACT(WEEK from {x[0]})",
+    FunctionType.QUARTER: lambda x, types: f"EXTRACT(QUARTER from {x[0]})",
+    # math
+    FunctionType.DIVIDE: lambda x, types: f"{x[0]}/{x[1]}",
+    FunctionType.DATE_ADD: lambda x, types: f"DATE_ADD('{x[1]}', {x[2]}, {x[0]})",
+    FunctionType.CURRENT_DATE: lambda x, types: "CURRENT_DATE",
+    FunctionType.CURRENT_DATETIME: lambda x, types: "CURRENT_TIMESTAMP",
+    FunctionType.ARRAY: lambda x, types: f"ARRAY[{', '.join(x)}]",
+    # regex
+    FunctionType.REGEXP_CONTAINS: lambda x, types: f"REGEXP_LIKE({x[0]}, {x[1]})",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT_DISTINCT: lambda args, types: f"CASE WHEN{args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.COUNT: lambda args, types: f"CASE WHEN {args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.SUM: lambda args, types: f"{args[0]}",
+    FunctionType.AVG: lambda args, types: f"{args[0]}",
+}
+
+SQL_TEMPLATE = Template(
+    """{%- if output %}
+{{output}}
+{% endif %}{%- if ctes %}
+WITH {% for cte in ctes %}
+{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+{%- if full_select -%}
+{{full_select}}
+{%- else -%}
+SELECT
+{%- for select in select_columns %}
+    {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
+{% if base %}FROM
+    {{ base }}{% endif %}{% if joins %}
+{% for join in joins %}
+{{ join }}
+{% endfor %}{% endif %}
+{% if where %}WHERE
+    {{ where }}
+{% endif %}
+{%- if group_by %}GROUP BY {% for group in group_by %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
+{%- if order_by %}
+ORDER BY {% for order in order_by %}
+    {{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+{%- if limit is not none %}
+LIMIT {{ limit }}{% endif %}{% endif %}
+"""
+)
+MAX_IDENTIFIER_LENGTH = 50
+
+
+class PrestoDialect(BaseDialect):
+    WINDOW_FUNCTION_MAP = {**BaseDialect.WINDOW_FUNCTION_MAP, **WINDOW_FUNCTION_MAP}
+    FUNCTION_MAP = {**BaseDialect.FUNCTION_MAP, **FUNCTION_MAP}
+    FUNCTION_GRAIN_MATCH_MAP = {
+        **BaseDialect.FUNCTION_GRAIN_MATCH_MAP,
+        **FUNCTION_GRAIN_MATCH_MAP,
+    }
+    QUOTE_CHARACTER = '"'
+    SQL_TEMPLATE = SQL_TEMPLATE
+    DATATYPE_MAP = {
+        **BaseDialect.DATATYPE_MAP,
+        DataType.NUMERIC: "DECIMAL",
+        DataType.STRING: "VARCHAR",
+    }
+    UNNEST_MODE = UnnestMode.PRESTO
+    GROUP_MODE = GroupMode.BY_INDEX
+    ALIAS_ORDER_REFERENCING_ALLOWED = (
+        False  # some complex presto functions don't support aliasing
+    )
+
+
+class TrinoDialect(PrestoDialect):
+    pass

trilogy/dialect/results.py

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+from typing import Any, List
+
+from trilogy.core.models.author import ConceptRef
+from trilogy.engine import ResultProtocol
+
+
+@dataclass
+class MockResult(ResultProtocol):
+    values: list["MockResultRow"]
+    columns: list[str]
+
+    def __init__(self, values: list[Any], columns: list[str]):
+        processed: list[MockResultRow] = []
+        for x in values:
+            if isinstance(x, dict):
+                processed.append(MockResultRow(x))
+            elif isinstance(x, MockResultRow):
+                processed.append(x)
+            else:
+                raise ValueError(
+                    f"Cannot process value of type {type(x)} in MockResult"
+                )
+        self.columns = columns
+        self.values = processed
+
+    def __iter__(self):
+        while self.values:
+            yield self.values.pop(0)
+
+    def fetchall(self):
+        return self.values
+
+    def fetchone(self):
+        if self.values:
+            return self.values.pop(0)
+        return None
+
+    def fetchmany(self, size: int):
+        rval = self.values[:size]
+        self.values = self.values[size:]
+        return rval
+
+    def keys(self):
+        return self.columns
+
+    def as_dict(self):
+        return [x.as_dict() if isinstance(x, MockResultRow) else x for x in self.values]
+
+
+@dataclass
+class MockResultRow:
+    _values: dict[str, Any]
+
+    def as_dict(self):
+        return self._values
+
+    def __str__(self) -> str:
+        return str(self._values)
+
+    def __repr__(self) -> str:
+        return repr(self._values)
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self._values:
+            return self._values[name]
+        return super().__getattribute__(name)
+
+    def __getitem__(self, key: str) -> Any:
+        return self._values[key]
+
+    def __iter__(self):
+        return iter(self._values.values())
+
+    def values(self):
+        return self._values.values()
+
+    def keys(self):
+        return self._values.keys()
+
+
+def generate_result_set(
+    columns: List[ConceptRef], output_data: list[Any]
+) -> MockResult:
+    """Generate a mock result set from columns and output data."""
+    names = [x.address.replace(".", "_") for x in columns]
+    return MockResult(
+        values=[dict(zip(names, [row])) for row in output_data], columns=names
+    )

trilogy/dialect/snowflake.py

@@ -0,0 +1,90 @@
+from typing import Any, Callable, Mapping
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, UnnestMode, WindowType
+from trilogy.dialect.base import BaseDialect
+
+ENV_SNOWFLAKE_PW = "PREQL_SNOWFLAKE_PW"
+ENV_SNOWFLAKE_USER = "PREQL_SNOWFLAKE_USER"
+ENV_SNOWFLAKE_ACCOUNT = "PREQL_SNOWFLAKE_ACCOUNT"
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.COUNT: lambda x, types: f"count({x[0]})",
+    FunctionType.SUM: lambda x, types: f"sum({x[0]})",
+    FunctionType.LENGTH: lambda x, types: f"length({x[0]})",
+    FunctionType.AVG: lambda x, types: f"avg({x[0]})",
+    FunctionType.LIKE: lambda x, types: (
+        f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
+    ),
+    FunctionType.MINUTE: lambda x, types: f"EXTRACT(MINUTE from {x[0]})",
+    FunctionType.SECOND: lambda x, types: f"EXTRACT(SECOND from {x[0]})",
+    FunctionType.HOUR: lambda x, types: f"EXTRACT(HOUR from {x[0]})",
+    FunctionType.DAY_OF_WEEK: lambda x, types: f"EXTRACT(DAYOFWEEK from {x[0]})",
+    FunctionType.DAY: lambda x, types: f"EXTRACT(DAY from {x[0]})",
+    FunctionType.YEAR: lambda x, types: f"EXTRACT(YEAR from {x[0]})",
+    FunctionType.MONTH: lambda x, types: f"EXTRACT(MONTH from {x[0]})",
+    FunctionType.WEEK: lambda x, types: f"EXTRACT(WEEK from {x[0]})",
+    FunctionType.QUARTER: lambda x, types: f"EXTRACT(QUARTER from {x[0]})",
+    # math
+    FunctionType.POWER: lambda x, types: f"POWER({x[0]}, {x[1]})",
+    FunctionType.DIVIDE: lambda x, types: f"DIV0({x[0]},{x[1]})",
+    FunctionType.UNNEST: lambda x, types: f"table(flatten({x[0]}))",
+    FunctionType.ARRAY: lambda x, types: f"ARRAY_CONSTRUCT({', '.join(x)})",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT_DISTINCT: lambda args, types: f"CASE WHEN{args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.COUNT: lambda args, types: f"CASE WHEN {args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.SUM: lambda args, types: f"{args[0]}",
+    FunctionType.AVG: lambda args, types: f"{args[0]}",
+}
+
+
+SNOWFLAKE_SQL_TEMPLATE = Template(
+    """{%- if output %}
+{{output}}
+{% endif %}{%- if ctes %}
+WITH {% if recursive%}RECURSIVE{% endif %}{% for cte in ctes %}
+"{{cte.name}}" as ({{cte.statement}}){% if not loop.last %},{% endif %}{% else %}
+{% endfor %}{% endif %}
+{%- if full_select -%}
+{{full_select}}
+{%- else -%}
+
+SELECT
+{%- for select in select_columns %}
+    {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
+{% if base %}FROM
+    {{ base }}{% endif %}{% if joins %}{% for join in joins %}
+    {{ join }}{% endfor %}{% endif %}
+{% if where %}WHERE
+    {{ where }}
+{% endif %}
+{%- if group_by %}GROUP BY {% for group in group_by %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
+{%- if order_by %}
+ORDER BY {% for order in order_by %}
+    {{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+{%- if limit is not none %}
+LIMIT {{ limit }}{% endif %}{% endif %}
+"""
+)
+MAX_IDENTIFIER_LENGTH = 50
+
+
+class SnowflakeDialect(BaseDialect):
+    WINDOW_FUNCTION_MAP = {**BaseDialect.WINDOW_FUNCTION_MAP, **WINDOW_FUNCTION_MAP}
+    FUNCTION_MAP = {**BaseDialect.FUNCTION_MAP, **FUNCTION_MAP}
+    FUNCTION_GRAIN_MATCH_MAP = {
+        **BaseDialect.FUNCTION_GRAIN_MATCH_MAP,
+        **FUNCTION_GRAIN_MATCH_MAP,
+    }
+    QUOTE_CHARACTER = '"'
+    SQL_TEMPLATE = SNOWFLAKE_SQL_TEMPLATE
+    UNNEST_MODE = UnnestMode.SNOWFLAKE

trilogy/dialect/sql_server.py

@@ -0,0 +1,92 @@
+from typing import Any, Callable, Mapping
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, WindowType
+from trilogy.core.statements.execute import (
+    PROCESSED_STATEMENT_TYPES,
+    ProcessedQuery,
+    ProcessedQueryPersist,
+)
+from trilogy.dialect.base import BaseDialect
+from trilogy.utility import string_to_hash
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.COUNT: lambda args, types: f"count({args[0]})",
+    FunctionType.SUM: lambda args, types: f"sum({args[0]})",
+    FunctionType.AVG: lambda args, types: f"avg({args[0]})",
+    FunctionType.LENGTH: lambda args, types: f"length({args[0]})",
+    FunctionType.LIKE: lambda args, types: (
+        f" CASE WHEN {args[0]} like {args[1]} THEN True ELSE False END"
+    ),
+    FunctionType.CONCAT: lambda args, types: (
+        f"CONCAT({','.join([f''' '{a}' ''' for a in args])})"
+    ),
+}
+
+# if an aggregate function is called on a source that is at the same grain as the aggregate
+# we may return a static value
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT_DISTINCT: lambda args, types: f"CASE WHEN{args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.COUNT: lambda args, types: f"CASE WHEN {args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.SUM: lambda args, types: f"{args[0]}",
+    FunctionType.AVG: lambda args, types: f"{args[0]}",
+}
+
+TSQL_TEMPLATE = Template(
+    """{%- if ctes %}
+WITH {% for cte in ctes %}
+{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+{%- if full_select -%}{{full_select}}
+{%- else -%}{%- if comment %}
+-- {{ comment }}{%- endif -%}
+SELECT
+{%- if limit is not none %}
+TOP {{ limit }}{% endif %}
+{%- for select in select_columns %}
+    {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
+{% if base %}FROM
+    {{ base }}{% endif %}{% if joins %}
+{% for join in joins %}
+{{ join }}
+{% endfor %}{% endif %}
+{% if where %}WHERE
+    {{ where }}
+{% endif %}
+{%- if group_by %}
+GROUP BY {% for group in group_by %}
+    {{group}}{% if not loop.last %},{% endif %}
+{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
+{%- if order_by %}
+ORDER BY {% for order in order_by %}
+    {{ order }}{% if not loop.last %},{% endif %}
+{% endfor %}{% endif %}{% endif %}
+"""
+)
+
+MAX_IDENTIFIER_LENGTH = 128
+
+
+class SqlServerDialect(BaseDialect):
+    WINDOW_FUNCTION_MAP = {**BaseDialect.WINDOW_FUNCTION_MAP, **WINDOW_FUNCTION_MAP}
+    FUNCTION_MAP = {**BaseDialect.FUNCTION_MAP, **FUNCTION_MAP}
+    FUNCTION_GRAIN_MATCH_MAP = {
+        **BaseDialect.FUNCTION_GRAIN_MATCH_MAP,
+        **FUNCTION_GRAIN_MATCH_MAP,
+    }
+    QUOTE_CHARACTER = '"'
+    SQL_TEMPLATE = TSQL_TEMPLATE
+
+    def compile_statement(self, query: PROCESSED_STATEMENT_TYPES) -> str:
+        base = super().compile_statement(query)
+        if isinstance(query, (ProcessedQuery, ProcessedQueryPersist)):
+            for cte in query.ctes:
+                if len(cte.name) > MAX_IDENTIFIER_LENGTH:
+                    new_name = f"rhash_{string_to_hash(cte.name)}"
+                    base = base.replace(cte.name, new_name)
+        return base

trilogy/engine.py

@@ -0,0 +1,48 @@
+from typing import Any, Generator, List, Optional, Protocol
+
+from trilogy.core.models.environment import Environment
+
+
+class ResultProtocol(Protocol):
+
+    def fetchall(self) -> List[Any]: ...
+
+    def keys(self) -> List[str]: ...
+
+    def fetchone(self) -> Optional[Any]: ...
+
+    def fetchmany(self, size: int) -> List[Any]: ...
+
+    def __iter__(self) -> Generator[Any, None, None]: ...
+
+
+class EngineConnection(Protocol):
+    pass
+
+    def execute(self, statement: str, parameters: Any | None = None) -> ResultProtocol:
+        pass
+
+    def commit(self):
+        raise NotImplementedError()
+
+    def begin(self):
+        raise NotImplementedError()
+
+    def rollback(self):
+        raise NotImplementedError()
+
+    def close(self) -> None:
+        return
+
+
+class ExecutionEngine(Protocol):
+    pass
+
+    def connect(self) -> EngineConnection:
+        pass
+
+    def setup(self, env: Environment, connection):
+        pass
+
+    def dispose(self, close: bool = True):
+        pass

trilogy/execution/config.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from tomllib import loads
+
+from trilogy.dialect import (
+    BigQueryConfig,
+    DialectConfig,
+    DuckDBConfig,
+    PostgresConfig,
+    PrestoConfig,
+    SnowflakeConfig,
+    SQLServerConfig,
+)
+from trilogy.dialect.enums import Dialects
+
+DEFAULT_PARALLELISM = 4
+
+
+@dataclass
+class RuntimeConfig:
+
+    startup_trilogy: list[Path]
+    startup_sql: list[Path]
+    parallelism: int = DEFAULT_PARALLELISM
+    engine_dialect: Dialects | None = None
+    engine_config: DialectConfig | None = None
+
+
+def load_config_file(path: Path) -> RuntimeConfig:
+    with open(path, "r") as f:
+        toml_content = f.read()
+    config_data = loads(toml_content)
+
+    engine_raw: dict = config_data.get("engine", {})
+    engine_config_raw = engine_raw.get("config", {})
+    engine = Dialects(engine_raw.get("dialect")) if engine_raw.get("dialect") else None
+    engine_config: DialectConfig | None
+    if engine:
+        if engine == Dialects.DUCK_DB:
+            engine_config = (
+                DuckDBConfig(**engine_config_raw) if engine_config_raw else None
+            )
+        elif engine == Dialects.POSTGRES:
+            engine_config = (
+                PostgresConfig(**engine_config_raw) if engine_config_raw else None
+            )
+        elif engine == Dialects.PRESTO:
+            engine_config = (
+                PrestoConfig(**engine_config_raw) if engine_config_raw else None
+            )
+        elif engine == Dialects.SNOWFLAKE:
+            engine_config = (
+                SnowflakeConfig(**engine_config_raw) if engine_config_raw else None
+            )
+        elif engine == Dialects.SQL_SERVER:
+            engine_config = (
+                SQLServerConfig(**engine_config_raw) if engine_config_raw else None
+            )
+        elif engine == Dialects.BIGQUERY:
+            engine_config = (
+                BigQueryConfig(**engine_config_raw) if engine_config_raw else None
+            )
+        else:
+            engine_config = None
+    else:
+        engine_config = None
+    setup: dict = config_data.get("setup", {})
+    return RuntimeConfig(
+        startup_trilogy=[Path(p) for p in setup.get("trilogy", [])],
+        startup_sql=[Path(p) for p in setup.get("sql", [])],
+        parallelism=config_data.get("parallelism", DEFAULT_PARALLELISM),
+        engine_dialect=engine,
+        engine_config=engine_config,
+    )