pytrilogy 0.0.3.94__py3-none-any.whl → 0.0.3.96__py3-none-any.whl

trilogy/dialect/base.py

@@ -72,14 +72,17 @@ from trilogy.core.statements.author import (
     RowsetDerivationStatement,
     SelectStatement,
     ShowStatement,
+    ValidateStatement,
 )
 from trilogy.core.statements.execute import (
+    PROCESSED_STATEMENT_TYPES,
     ProcessedCopyStatement,
     ProcessedQuery,
     ProcessedQueryPersist,
     ProcessedRawSQLStatement,
     ProcessedShowStatement,
     ProcessedStaticValueOutput,
+    ProcessedValidateStatement,
 )
 from trilogy.core.utility import safe_quote
 from trilogy.dialect.common import render_join, render_unnest
@@ -343,6 +346,7 @@ class BaseDialect:
     COMPLEX_DATATYPE_MAP = COMPLEX_DATATYPE_MAP
     UNNEST_MODE = UnnestMode.CROSS_APPLY
     GROUP_MODE = GroupMode.AUTO
+    EXPLAIN_KEYWORD = "EXPLAIN"
 
     def __init__(self, rendering: Rendering | None = None):
         self.rendering = rendering or CONFIG.rendering
@@ -1025,21 +1029,11 @@ class BaseDialect:
             | RawSQLStatement
             | MergeStatementV2
             | CopyStatement
+            | ValidateStatement
         ],
         hooks: Optional[List[BaseHook]] = None,
-    ) -> List[
-        ProcessedQuery
-        | ProcessedQueryPersist
-        | ProcessedShowStatement
-        | ProcessedRawSQLStatement
-    ]:
-        output: List[
-            ProcessedQuery
-            | ProcessedQueryPersist
-            | ProcessedShowStatement
-            | ProcessedRawSQLStatement
-            | ProcessedCopyStatement
-        ] = []
+    ) -> List[PROCESSED_STATEMENT_TYPES]:
+        output: List[PROCESSED_STATEMENT_TYPES] = []
         for statement in statements:
             if isinstance(statement, PersistStatement):
                 if hooks:
@@ -1089,10 +1083,39 @@ class BaseDialect:
                     output.append(
                         self.create_show_output(environment, statement.content)
                     )
+                elif isinstance(statement.content, ValidateStatement):
+                    output.append(
+                        ProcessedShowStatement(
+                            output_columns=[
+                                environment.concepts[
+                                    DEFAULT_CONCEPTS["label"].address
+                                ].reference,
+                                environment.concepts[
+                                    DEFAULT_CONCEPTS["query_text"].address
+                                ].reference,
+                                environment.concepts[
+                                    DEFAULT_CONCEPTS["expected"].address
+                                ].reference,
+                            ],
+                            output_values=[
+                                ProcessedValidateStatement(
+                                    scope=statement.content.scope,
+                                    targets=statement.content.targets,
+                                )
+                            ],
+                        )
+                    )
                 else:
                     raise NotImplementedError(type(statement.content))
             elif isinstance(statement, RawSQLStatement):
                 output.append(ProcessedRawSQLStatement(text=statement.text))
+            elif isinstance(statement, ValidateStatement):
+                output.append(
+                    ProcessedValidateStatement(
+                        scope=statement.scope,
+                        targets=statement.targets,
+                    )
+                )
             elif isinstance(
                 statement,
                 (
@@ -1111,18 +1134,22 @@ class BaseDialect:
 
     def compile_statement(
         self,
-        query: (
-            ProcessedQuery
-            | ProcessedQueryPersist
-            | ProcessedShowStatement
-            | ProcessedRawSQLStatement
-        ),
+        query: PROCESSED_STATEMENT_TYPES,
     ) -> str:
         if isinstance(query, ProcessedShowStatement):
-            return ";\n".join([str(x) for x in query.output_values])
+            return ";\n".join(
+                [
+                    f'{self.EXPLAIN_KEYWORD} {self.compile_statement(x)}'
+                    for x in query.output_values
+                    if isinstance(x, (ProcessedQuery, ProcessedCopyStatement))
+                ]
+            )
         elif isinstance(query, ProcessedRawSQLStatement):
             return query.text
 
+        elif isinstance(query, ProcessedValidateStatement):
+            return "select 1;"
+
         recursive = any(isinstance(x, RecursiveCTE) for x in query.ctes)
 
         compiled_ctes = self.generate_ctes(query)
@@ -1139,7 +1166,7 @@ class BaseDialect:
         if CONFIG.strict_mode and INVALID_REFERENCE_STRING(1) in final:
             raise ValueError(
                 f"Invalid reference string found in query: {final}, this should never"
-                " occur. Please create a GitHub issue to report this."
+                " occur. Please create an issue to report this."
             )
         logger.info(f"{LOGGER_PREFIX} Compiled query: {final}")
         return final

trilogy/dialect/metadata.py

@@ -0,0 +1,233 @@
+from dataclasses import dataclass
+from typing import Any, List, Optional
+
+from trilogy.core.models.author import ConceptRef
+from trilogy.core.models.datasource import Datasource
+from trilogy.core.models.environment import Environment
+from trilogy.core.statements.author import (
+    ConceptDeclarationStatement,
+    ImportStatement,
+    MergeStatementV2,
+)
+from trilogy.core.statements.execute import (
+    ProcessedShowStatement,
+    ProcessedStaticValueOutput,
+    ProcessedValidateStatement,
+)
+from trilogy.core.validation.common import ValidationTest
+from trilogy.dialect.base import BaseDialect
+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 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
+    )
+
+
+def handle_concept_declaration(query: ConceptDeclarationStatement) -> MockResult:
+    """Handle concept declaration statements without execution."""
+    concept = query.concept
+    return MockResult(
+        [
+            {
+                "address": concept.address,
+                "type": concept.datatype.value,
+                "purpose": concept.purpose.value,
+                "derivation": concept.derivation.value,
+            }
+        ],
+        ["address", "type", "purpose", "derivation"],
+    )
+
+
+def handle_datasource(query: Datasource) -> MockResult:
+    """Handle datasource queries without execution."""
+    return MockResult(
+        [
+            {
+                "name": query.name,
+            }
+        ],
+        ["name"],
+    )
+
+
+def handle_import_statement(query: ImportStatement) -> MockResult:
+    """Handle import statements without execution."""
+    return MockResult(
+        [
+            {
+                "path": query.path,
+                "alias": query.alias,
+            }
+        ],
+        ["path", "alias"],
+    )
+
+
+def handle_merge_statement(
+    query: MergeStatementV2, environment: Environment
+) -> MockResult:
+    """Handle merge statements by updating environment and returning result."""
+    for concept in query.sources:
+        environment.merge_concept(
+            concept, query.targets[concept.address], modifiers=query.modifiers
+        )
+
+    return MockResult(
+        [
+            {
+                "sources": ",".join([x.address for x in query.sources]),
+                "targets": ",".join([x.address for _, x in query.targets.items()]),
+            }
+        ],
+        ["source", "target"],
+    )
+
+
+def handle_processed_show_statement(
+    query: ProcessedShowStatement, compiled_statements: list[str]
+) -> MockResult:
+    """Handle processed show statements without execution."""
+
+    return generate_result_set(query.output_columns, compiled_statements)
+
+
+def raw_validation_to_result(
+    raw: list[ValidationTest], generator: Optional[BaseDialect] = None
+) -> Optional[MockResult]:
+    """Convert raw validation tests to mock result."""
+    if not raw:
+        return None
+    output = []
+    for row in raw:
+        if row.raw_query and generator and not row.generated_query:
+            try:
+                row.generated_query = generator.compile_statement(row.raw_query)
+            except Exception as e:
+                row.generated_query = f"Error generating query: {e}"
+        output.append(
+            {
+                "check_type": row.check_type.value,
+                "expected": row.expected,
+                "result": str(row.result) if row.result else None,
+                "ran": row.ran,
+                "query": row.generated_query if row.generated_query else "",
+            }
+        )
+    return MockResult(output, ["check_type", "expected", "result", "ran", "query"])
+
+
+def handle_processed_validate_statement(
+    query: ProcessedValidateStatement, dialect: BaseDialect, validate_environment_func
+) -> Optional[MockResult]:
+    """Handle processed validate statements."""
+    results = validate_environment_func(query.scope, query.targets)
+    return raw_validation_to_result(results, dialect)
+
+
+def handle_show_statement_outputs(
+    statement: ProcessedShowStatement,
+    compiled_statements: list[str],
+    environment: Environment,
+    dialect: BaseDialect,
+) -> list[MockResult]:
+    """Handle show statement outputs without execution."""
+    output = []
+    for x in statement.output_values:
+        if isinstance(x, ProcessedStaticValueOutput):
+            output.append(generate_result_set(statement.output_columns, x.values))
+        elif compiled_statements:
+
+            output.append(
+                generate_result_set(
+                    statement.output_columns,
+                    compiled_statements,
+                )
+            )
+        elif isinstance(x, ProcessedValidateStatement):
+            from trilogy.core.validation.environment import validate_environment
+
+            raw = validate_environment(environment, x.scope, x.targets)
+            results = raw_validation_to_result(raw, dialect)
+            if results:
+                output.append(results)
+        else:
+            raise NotImplementedError(f"Cannot show type {type(x)} in show statement")
+    return output

trilogy/dialect/sql_server.py

@@ -8,6 +8,7 @@ from trilogy.core.statements.execute import (
     ProcessedQueryPersist,
     ProcessedRawSQLStatement,
     ProcessedShowStatement,
+    ProcessedValidateStatement,
 )
 from trilogy.dialect.base import BaseDialect
 from trilogy.utility import string_to_hash
@@ -90,10 +91,11 @@ class SqlServerDialect(BaseDialect):
             | ProcessedQueryPersist
             | ProcessedShowStatement
             | ProcessedRawSQLStatement
+            | ProcessedValidateStatement
         ),
     ) -> str:
         base = super().compile_statement(query)
-        if isinstance(base, (ProcessedQuery, ProcessedQueryPersist)):
+        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)}"

trilogy/engine.py

@@ -1,21 +1,27 @@
-from typing import Any, Protocol
+from typing import Any, Generator, List, Optional, Protocol
 
 from sqlalchemy.engine import Connection, CursorResult, Engine
 
 from trilogy.core.models.environment import Environment
 
 
-class EngineResult(Protocol):
-    pass
+class ResultProtocol(Protocol):
 
-    def fetchall(self) -> list[tuple]:
-        pass
+    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) -> EngineResult:
+    def execute(self, statement: str, parameters: Any | None = None) -> ResultProtocol:
         pass
 
     def commit(self):
@@ -39,13 +45,25 @@ class ExecutionEngine(Protocol):
 
 
 ### Begin default SQLAlchemy implementation
-class SqlAlchemyResult(EngineResult):
+class SqlAlchemyResult:
     def __init__(self, result: CursorResult):
         self.result = result
 
     def fetchall(self):
         return self.result.fetchall()
 
+    def keys(self):
+        return self.result.keys()
+
+    def fetchone(self):
+        return self.result.fetchone()
+
+    def fetchmany(self, size: int):
+        return self.result.fetchmany(size)
+
+    def __iter__(self):
+        return iter(self.result)
+
 
 class SqlAlchemyConnection(EngineConnection):
     def __init__(self, connection: Connection):