datalex-cli 0.1.1__py3-none-any.whl

datalex_core/dialects/_common.py

@@ -0,0 +1,48 @@
+"""Helpers shared by dialect plugins."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from datalex_core.datalex.types import LogicalType
+
+
+def physical_override(column: Dict[str, Any], dialect: str) -> Optional[str]:
+    """Return the per-dialect physical type override for a column, or None."""
+    physical = column.get("physical") or {}
+    entry = physical.get(dialect)
+    if isinstance(entry, dict):
+        return entry.get("type")
+    return None
+
+
+def physical_raw_ddl(column: Dict[str, Any], dialect: str) -> Optional[str]:
+    physical = column.get("physical") or {}
+    entry = physical.get(dialect)
+    if isinstance(entry, dict):
+        return entry.get("raw_ddl")
+    return None
+
+
+def qualified_table_name(entity: Dict[str, Any], quote, dialect: str) -> str:
+    physical = entity.get("physical_name") or entity.get("name")
+    parts: List[str] = []
+    for key in ("database", "schema"):
+        val = entity.get(key)
+        if val:
+            parts.append(str(val))
+    parts.append(str(physical))
+    return ".".join(quote(p) for p in parts)
+
+
+def primary_key_columns(entity: Dict[str, Any]) -> List[str]:
+    pks: List[str] = []
+    for col in entity.get("columns", []) or []:
+        if col.get("primary_key"):
+            pks.append(col["name"])
+        else:
+            for c in col.get("constraints") or []:
+                if c.get("type") == "primary_key":
+                    pks.append(col["name"])
+                    break
+    return pks

datalex_core/dialects/base.py

@@ -0,0 +1,47 @@
+"""DialectPlugin protocol.
+
+A dialect plugin is a pure function bundle: given a DataLex entity (dict) it
+renders DDL, migration ALTERs, GRANTs, and type strings. No hidden state.
+
+Each plugin exposes:
+  * `name` — canonical lowercase dialect name (`postgres`, `snowflake`, ...)
+  * `render_type(logical_type, column)` — map a logical type to a physical type string
+  * `render_entity(entity)` — emit CREATE TABLE / VIEW etc.
+  * `render_alter(old_entity, new_entity)` — emit ALTER statements for a diff
+  * `render_grant(policy, entity)` — emit GRANT statements for an access policy
+  * `quote(identifier)` — dialect-correct identifier quoting
+
+The registry calls `register_dialect(plugin)` at import time; downstream code
+calls `get_dialect(name)` to retrieve it.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Protocol, runtime_checkable
+
+from datalex_core.datalex.types import LogicalType
+
+
+@dataclass
+class RenderContext:
+    """Contextual hints passed to render_type. Dialect plugins can ignore it."""
+    entity: Optional[Dict[str, Any]] = None
+    column: Optional[Dict[str, Any]] = None
+
+
+@runtime_checkable
+class DialectPlugin(Protocol):
+    name: str
+
+    def quote(self, identifier: str) -> str: ...
+
+    def render_type(self, logical: LogicalType, ctx: RenderContext) -> str: ...
+
+    def render_entity(self, entity: Dict[str, Any]) -> str: ...
+
+    def render_alter(
+        self, old_entity: Optional[Dict[str, Any]], new_entity: Optional[Dict[str, Any]]
+    ) -> List[str]: ...
+
+    def render_grant(self, policy: Dict[str, Any], entity: Dict[str, Any]) -> List[str]: ...

datalex_core/dialects/postgres.py

@@ -0,0 +1,164 @@
+"""Postgres dialect plugin."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from datalex_core.datalex.types import LogicalType
+from datalex_core.dialects.base import DialectPlugin, RenderContext
+from datalex_core.dialects.registry import register_dialect
+from datalex_core.dialects._common import (
+    physical_override,
+    physical_raw_ddl,
+    primary_key_columns,
+    qualified_table_name,
+)
+
+
+_PRIMITIVE_MAP = {
+    "string": "TEXT",
+    "text": "TEXT",
+    "integer": "INTEGER",
+    "bigint": "BIGINT",
+    "float": "DOUBLE PRECISION",
+    "boolean": "BOOLEAN",
+    "date": "DATE",
+    "timestamp": "TIMESTAMP",
+    "timestamp_tz": "TIMESTAMPTZ",
+    "interval": "INTERVAL",
+    "uuid": "UUID",
+    "json": "JSONB",
+    "binary": "BYTEA",
+}
+
+
+class PostgresDialect:
+    name = "postgres"
+
+    def quote(self, identifier: str) -> str:
+        # Double-quote every identifier and escape embedded double quotes.
+        escaped = identifier.replace('"', '""')
+        return f'"{escaped}"'
+
+    def render_type(self, logical: LogicalType, ctx: RenderContext) -> str:
+        column = ctx.column or {}
+        override = physical_override(column, self.name)
+        if override:
+            return override
+        raw = physical_raw_ddl(column, self.name)
+        if raw:
+            return raw
+
+        if logical.kind == "array":
+            inner = self.render_type(logical.children[0], ctx)
+            return f"{inner}[]"
+        if logical.kind == "map":
+            return "JSONB"
+        if logical.kind == "struct":
+            return "JSONB"
+        if logical.kind == "decimal":
+            if logical.params:
+                return f"NUMERIC({','.join(str(p) for p in logical.params)})"
+            return "NUMERIC"
+        if logical.kind == "string" and logical.params:
+            return f"VARCHAR({logical.params[0]})"
+        if logical.kind == "binary" and logical.params:
+            return "BYTEA"
+
+        return _PRIMITIVE_MAP.get(logical.kind, logical.kind.upper())
+
+    def render_entity(self, entity: Dict[str, Any]) -> str:
+        from datalex_core.datalex.types import parse_type  # local to avoid cycles
+
+        name = qualified_table_name(entity, self.quote, self.name)
+        lines: List[str] = [f"CREATE TABLE {name} ("]
+
+        col_lines: List[str] = []
+        for col in entity.get("columns", []) or []:
+            logical = parse_type(col.get("type", "string"))
+            sql_type = self.render_type(logical, RenderContext(entity=entity, column=col))
+            piece = f"  {self.quote(col['name'])} {sql_type}"
+            if col.get("nullable") is False or col.get("primary_key"):
+                piece += " NOT NULL"
+            default = col.get("default")
+            if default is not None:
+                piece += f" DEFAULT {_format_default(default)}"
+            col_lines.append(piece)
+
+        pks = primary_key_columns(entity)
+        if pks:
+            cols = ", ".join(self.quote(c) for c in pks)
+            col_lines.append(f"  PRIMARY KEY ({cols})")
+
+        lines.append(",\n".join(col_lines))
+        lines.append(");")
+
+        fk_lines: List[str] = []
+        for col in entity.get("columns", []) or []:
+            ref = col.get("references")
+            if not ref:
+                continue
+            target = ref.get("entity")
+            target_col = ref.get("column")
+            on_delete = ref.get("on_delete")
+            fk_name = f"fk_{entity['name']}_{col['name']}"
+            fk = (
+                f"ALTER TABLE {name} ADD CONSTRAINT "
+                f"{self.quote(fk_name)} "
+                f"FOREIGN KEY ({self.quote(col['name'])}) "
+                f"REFERENCES {self.quote(target)} ({self.quote(target_col)})"
+            )
+            if on_delete:
+                fk += f" ON DELETE {on_delete.upper().replace('_', ' ')}"
+            fk_lines.append(fk + ";")
+
+        idx_lines: List[str] = []
+        for idx in entity.get("indexes", []) or []:
+            unique = "UNIQUE " if idx.get("unique") else ""
+            cols = ", ".join(self.quote(c) for c in idx.get("columns", []))
+            idx_lines.append(
+                f"CREATE {unique}INDEX {self.quote(idx['name'])} ON {name} ({cols});"
+            )
+
+        return "\n".join(lines + ([""] if fk_lines or idx_lines else []) + fk_lines + idx_lines).rstrip() + "\n"
+
+    def render_alter(
+        self,
+        old_entity: Optional[Dict[str, Any]],
+        new_entity: Optional[Dict[str, Any]],
+    ) -> List[str]:
+        # Minimal first pass — rely on the diff engine for richer output in Phase B.
+        statements: List[str] = []
+        if old_entity is None and new_entity is not None:
+            statements.append(self.render_entity(new_entity))
+            return statements
+        if new_entity is None and old_entity is not None:
+            statements.append(
+                f"DROP TABLE {qualified_table_name(old_entity, self.quote, self.name)};"
+            )
+            return statements
+        return statements
+
+    def render_grant(self, policy: Dict[str, Any], entity: Dict[str, Any]) -> List[str]:
+        out: List[str] = []
+        target = qualified_table_name(entity, self.quote, self.name)
+        for grant in policy.get("grants", []) or []:
+            privs = ", ".join(grant.get("privileges", []))
+            principal = grant.get("principal")
+            if not principal:
+                continue
+            out.append(f"GRANT {privs} ON {target} TO {principal};")
+        return out
+
+
+def _format_default(value: Any) -> str:
+    if isinstance(value, bool):
+        return "TRUE" if value else "FALSE"
+    if isinstance(value, (int, float)):
+        return str(value)
+    if value is None:
+        return "NULL"
+    return "'" + str(value).replace("'", "''") + "'"
+
+
+register_dialect(PostgresDialect())

datalex_core/dialects/registry.py

@@ -0,0 +1,36 @@
+"""Runtime registry of DialectPlugin instances.
+
+Dialects self-register at import time by calling `register_dialect(...)`.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+from datalex_core.dialects.base import DialectPlugin
+
+
+_REGISTRY: Dict[str, DialectPlugin] = {}
+
+
+def register_dialect(plugin: DialectPlugin) -> None:
+    if not isinstance(plugin, DialectPlugin):
+        raise TypeError(f"{plugin!r} does not implement DialectPlugin")
+    _REGISTRY[plugin.name] = plugin
+
+
+def get_dialect(name: str) -> Optional[DialectPlugin]:
+    return _REGISTRY.get(name)
+
+
+def known_dialects() -> List[str]:
+    return sorted(_REGISTRY.keys())
+
+
+def require_dialect(name: str) -> DialectPlugin:
+    plugin = get_dialect(name)
+    if plugin is None:
+        raise KeyError(
+            f"Dialect '{name}' is not registered. Known: {', '.join(known_dialects())}"
+        )
+    return plugin

datalex_core/dialects/snowflake.py

@@ -0,0 +1,129 @@
+"""Snowflake dialect plugin."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from datalex_core.datalex.types import LogicalType
+from datalex_core.dialects.base import DialectPlugin, RenderContext
+from datalex_core.dialects.registry import register_dialect
+from datalex_core.dialects._common import (
+    physical_override,
+    physical_raw_ddl,
+    primary_key_columns,
+    qualified_table_name,
+)
+
+
+_PRIMITIVE_MAP = {
+    "string": "VARCHAR",
+    "text": "VARCHAR",
+    "integer": "NUMBER(38,0)",
+    "bigint": "NUMBER(38,0)",
+    "float": "FLOAT",
+    "boolean": "BOOLEAN",
+    "date": "DATE",
+    "timestamp": "TIMESTAMP_NTZ",
+    "timestamp_tz": "TIMESTAMP_TZ",
+    "interval": "VARCHAR",
+    "uuid": "VARCHAR",
+    "json": "VARIANT",
+    "binary": "BINARY",
+}
+
+
+class SnowflakeDialect:
+    name = "snowflake"
+
+    def quote(self, identifier: str) -> str:
+        # Snowflake identifiers are case-sensitive when quoted; prefer uppercase.
+        escaped = identifier.replace('"', '""')
+        return f'"{escaped.upper()}"'
+
+    def render_type(self, logical: LogicalType, ctx: RenderContext) -> str:
+        column = ctx.column or {}
+        override = physical_override(column, self.name)
+        if override:
+            return override
+        raw = physical_raw_ddl(column, self.name)
+        if raw:
+            return raw
+
+        if logical.kind == "array":
+            return "ARRAY"
+        if logical.kind == "map":
+            return "OBJECT"
+        if logical.kind == "struct":
+            return "OBJECT"
+        if logical.kind == "decimal":
+            if logical.params:
+                return f"NUMBER({','.join(str(p) for p in logical.params)})"
+            return "NUMBER"
+        if logical.kind == "string" and logical.params:
+            return f"VARCHAR({logical.params[0]})"
+
+        return _PRIMITIVE_MAP.get(logical.kind, logical.kind.upper())
+
+    def render_entity(self, entity: Dict[str, Any]) -> str:
+        from datalex_core.datalex.types import parse_type
+
+        name = qualified_table_name(entity, self.quote, self.name)
+        lines: List[str] = [f"CREATE OR REPLACE TABLE {name} ("]
+
+        col_lines: List[str] = []
+        for col in entity.get("columns", []) or []:
+            logical = parse_type(col.get("type", "string"))
+            sql_type = self.render_type(logical, RenderContext(entity=entity, column=col))
+            piece = f"  {self.quote(col['name'])} {sql_type}"
+            if col.get("nullable") is False or col.get("primary_key"):
+                piece += " NOT NULL"
+            default = col.get("default")
+            if default is not None:
+                piece += f" DEFAULT {_format_default(default)}"
+            col_lines.append(piece)
+
+        pks = primary_key_columns(entity)
+        if pks:
+            col_lines.append(
+                f"  PRIMARY KEY ({', '.join(self.quote(c) for c in pks)})"
+            )
+
+        lines.append(",\n".join(col_lines))
+        lines.append(");")
+
+        return "\n".join(lines) + "\n"
+
+    def render_alter(
+        self,
+        old_entity: Optional[Dict[str, Any]],
+        new_entity: Optional[Dict[str, Any]],
+    ) -> List[str]:
+        if old_entity is None and new_entity is not None:
+            return [self.render_entity(new_entity)]
+        if new_entity is None and old_entity is not None:
+            return [f"DROP TABLE IF EXISTS {qualified_table_name(old_entity, self.quote, self.name)};"]
+        return []
+
+    def render_grant(self, policy: Dict[str, Any], entity: Dict[str, Any]) -> List[str]:
+        out: List[str] = []
+        target = qualified_table_name(entity, self.quote, self.name)
+        for grant in policy.get("grants", []) or []:
+            privs = ", ".join(grant.get("privileges", []))
+            principal = grant.get("principal")
+            if not principal:
+                continue
+            out.append(f"GRANT {privs} ON TABLE {target} TO ROLE {principal};")
+        return out
+
+
+def _format_default(value: Any) -> str:
+    if isinstance(value, bool):
+        return "TRUE" if value else "FALSE"
+    if isinstance(value, (int, float)):
+        return str(value)
+    if value is None:
+        return "NULL"
+    return "'" + str(value).replace("'", "''") + "'"
+
+
+register_dialect(SnowflakeDialect())