pytrilogy 0.0.3.115__tar.gz → 0.0.3.117__tar.gz

{pytrilogy-0.0.3.115/pytrilogy.egg-info → pytrilogy-0.0.3.117}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.115
+Version: 0.0.3.117
 Summary: Declarative, typed query language that compiles to SQL.
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.115
+Version: 0.0.3.117
 Summary: Declarative, typed query language that compiles to SQL.
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/tests/test_functions.py

@@ -168,7 +168,7 @@ def test_date_functions(test_environment):
 
     for dialect in TEST_DIALECTS:
         engine = None
-        if isinstance(dialect, BigqueryDialect):
+        if isinstance(dialect, DuckDBDialect):
             engine = Dialects.DUCK_DB.default_executor(environment=test_environment)
         dialect.compile_statement(process_query(test_environment, select))
         if engine:
@@ -308,16 +308,43 @@ def test_string_functions(test_environment):
     property regex_replace <- regexp_replace(category_name, 'a', 'b');
 
     select
+        category_id,
         test_name,
         upper_name,
         lower_name,
         substring_name,
         strpos_name,
+        like_name,
+        like_alt,
+        regex_contains,
+        regex_substring,
+        regex_replace,
+        hash(category_name, md5) -> hash_md5,
+        hash(category_name, sha1) -> hash_sha1,
+        hash(category_name, sha256) -> hash_sha256,
+        # hash(category_name, sha512) -> hash_sha512
     ;"""
     env, parsed = parse(declarations, environment=test_environment)
     select: SelectStatement = parsed[-1]
     for dialect in TEST_DIALECTS:
+        engine = None
+        if isinstance(dialect, DuckDBDialect):
+            engine = Dialects.DUCK_DB.default_executor(environment=test_environment)
         dialect.compile_statement(process_query(test_environment, select))
+        if engine:
+            engine.execute_raw_sql(
+                """CREATE TABLE tblCategory AS
+SELECT 
+    2 category_id,
+    'category_a' as category_name
+UNION ALL
+SELECT 
+    3 category_id,
+    'category_b' as category_name;"""
+            )
+            results = engine.execute_query(select)
+            assert results
+            assert results.fetchall()
 
 
 def test_case_function(test_environment):

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.dialect.enums import Dialects
 from trilogy.executor import Executor
 from trilogy.parser import parse
 
-__version__ = "0.0.3.115"
+__version__ = "0.0.3.117"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/constants.py

@@ -31,6 +31,7 @@ class Optimizations:
     constant_inlining: bool = True
     constant_inline_cutoff: int = 10
     direct_return: bool = True
+    hide_unused_concepts: bool = True
 
 
 @dataclass

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/enums.py

@@ -217,6 +217,7 @@ class FunctionType(Enum):
     CONTAINS = "contains"
     TRIM = "trim"
     REPLACE = "replace"
+    HASH = "hash"
 
     # STRING REGEX
     REGEXP_CONTAINS = "regexp_contains"

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/functions.py

@@ -928,6 +928,14 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type=DataType.TIMESTAMP,
         arg_count=1,
     ),
+    FunctionType.HASH: FunctionConfig(
+        valid_inputs={
+            DataType.STRING,
+        },
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.STRING,
+        arg_count=2,
+    ),
 }
 
 EXCLUDED_FUNCTIONS = {

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/models/author.py

@@ -865,6 +865,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
             AggregateWrapper,
             RowsetItem,
             MultiSelectLineage,
+            Comparison,
         ]
     ] = None
     namespace: str = Field(default=DEFAULT_NAMESPACE, validate_default=True)
@@ -1079,6 +1080,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         | AggregateWrapper
         | RowsetItem
         | MultiSelectLineage
+        | Comparison
         | None,
         Grain,
         set[str] | None,
@@ -1178,6 +1180,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
                     AggregateWrapper,
                     RowsetItem,
                     MultiSelectLineage,
+                    Comparison,
                 ],
                 output: List[ConceptRef],
             ):
@@ -1204,6 +1207,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
     def calculate_derivation(self, lineage, purpose: Purpose) -> Derivation:
         from trilogy.core.models.build import (
             BuildAggregateWrapper,
+            BuildComparison,
             BuildFilterItem,
             BuildFunction,
             BuildMultiSelectLineage,
@@ -1221,6 +1225,8 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         #     return Derivation.PARENTHETICAL
         elif lineage and isinstance(lineage, (BuildRowsetItem, RowsetItem)):
             return Derivation.ROWSET
+        elif lineage and isinstance(lineage, BuildComparison):
+            return Derivation.BASIC
         elif lineage and isinstance(
             lineage, (BuildMultiSelectLineage, MultiSelectLineage)
         ):
@@ -2133,6 +2139,89 @@ class AlignClause(Namespaced, BaseModel):
         )
 
 
+class DeriveItem(Namespaced, DataTyped, ConceptArgs, Mergeable, BaseModel):
+    expr: Expr
+    name: str
+    namespace: str
+
+    @property
+    def derived_concept(self) -> str:
+        return f"{self.namespace}.{self.name}"
+        # return ConceptRef(
+        #     address=f"{self.namespace}.{self.name}",
+        #     datatype=arg_to_datatype(self.expr),
+        # )
+
+    def with_namespace(self, namespace):
+        return DeriveItem.model_construct(
+            expr=(self.expr.with_namespace(namespace) if self.expr else None),
+            name=self.name,
+            namespace=namespace,
+        )
+
+    def with_merge(
+        self, source: Concept, target: Concept, modifiers: List[Modifier]
+    ) -> "DeriveItem":
+        return DeriveItem.model_construct(
+            expr=(
+                self.expr.with_merge(source, target, modifiers)
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+            name=self.name,
+            namespace=self.namespace,
+        )
+
+    def with_reference_replacement(self, source, target):
+        return DeriveItem.model_construct(
+            expr=(
+                self.expr.with_reference_replacement(source, target)
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+            name=self.name,
+            namespace=self.namespace,
+        )
+
+
+class DeriveClause(Mergeable, Namespaced, BaseModel):
+    items: List[DeriveItem]
+
+    def with_namespace(self, namespace: str) -> "DeriveClause":
+        return DeriveClause.model_construct(
+            items=[
+                x.with_namespace(namespace) if isinstance(x, Namespaced) else x
+                for x in self.items
+            ]
+        )
+
+    def with_merge(
+        self, source: Concept, target: Concept, modifiers: List[Modifier]
+    ) -> "DeriveClause":
+        return DeriveClause.model_construct(
+            items=[
+                (
+                    x.with_merge(source, target, modifiers)
+                    if isinstance(x, Mergeable)
+                    else x
+                )
+                for x in self.items
+            ]
+        )
+
+    def with_reference_replacement(self, source, target):
+        return DeriveClause.model_construct(
+            items=[
+                (
+                    x.with_reference_replacement(source, target)
+                    if isinstance(x, Mergeable)
+                    else x
+                )
+                for x in self.items
+            ]
+        )
+
+
 class SelectLineage(Mergeable, Namespaced, BaseModel):
     selection: List[ConceptRef]
     hidden_components: set[str]
@@ -2177,15 +2266,40 @@ class SelectLineage(Mergeable, Namespaced, BaseModel):
             ),
         )
 
+    def with_namespace(self, namespace):
+        return SelectLineage.model_construct(
+            selection=[x.with_namespace(namespace) for x in self.selection],
+            hidden_components=self.hidden_components,
+            local_concepts={
+                x: y.with_namespace(namespace) for x, y in self.local_concepts.items()
+            },
+            order_by=self.order_by.with_namespace(namespace) if self.order_by else None,
+            limit=self.limit,
+            meta=self.meta,
+            grain=self.grain.with_namespace(namespace),
+            where_clause=(
+                self.where_clause.with_namespace(namespace)
+                if self.where_clause
+                else None
+            ),
+            having_clause=(
+                self.having_clause.with_namespace(namespace)
+                if self.having_clause
+                else None
+            ),
+        )
+
 
 class MultiSelectLineage(Mergeable, ConceptArgs, Namespaced, BaseModel):
     selects: List[SelectLineage]
     align: AlignClause
+
     namespace: str
     order_by: Optional[OrderBy] = None
     limit: Optional[int] = None
     where_clause: Union["WhereClause", None] = Field(default=None)
     having_clause: Union["HavingClause", None] = Field(default=None)
+    derive: DeriveClause | None = None
     hidden_components: set[str]
 
     @property
@@ -2211,6 +2325,11 @@ class MultiSelectLineage(Mergeable, ConceptArgs, Namespaced, BaseModel):
         new = MultiSelectLineage.model_construct(
             selects=[s.with_merge(source, target, modifiers) for s in self.selects],
             align=self.align,
+            derive=(
+                self.derive.with_merge(source, target, modifiers)
+                if self.derive
+                else None
+            ),
             namespace=self.namespace,
             hidden_components=self.hidden_components,
             order_by=(
@@ -2236,6 +2355,7 @@ class MultiSelectLineage(Mergeable, ConceptArgs, Namespaced, BaseModel):
         return MultiSelectLineage.model_construct(
             selects=[c.with_namespace(namespace) for c in self.selects],
             align=self.align.with_namespace(namespace),
+            derive=self.derive.with_namespace(namespace) if self.derive else None,
             namespace=namespace,
             hidden_components=self.hidden_components,
             order_by=self.order_by.with_namespace(namespace) if self.order_by else None,
@@ -2257,6 +2377,9 @@ class MultiSelectLineage(Mergeable, ConceptArgs, Namespaced, BaseModel):
         output = set()
         for item in self.align.items:
             output.add(item.aligned_concept)
+        if self.derive:
+            for ditem in self.derive.items:
+                output.add(ditem.derived_concept)
         return output
 
     @property

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/models/build.py

@@ -48,6 +48,8 @@ from trilogy.core.models.author import (
     Concept,
     ConceptRef,
     Conditional,
+    DeriveClause,
+    DeriveItem,
     FilterItem,
     FuncArgs,
     Function,
@@ -247,7 +249,7 @@ class BuildParamaterizedConceptReference(DataTyped):
     concept: BuildConcept
 
     def __str__(self):
-        return f":{self.concept.address}"
+        return f":{self.concept.address.replace('.', '_')}"
 
     @property
     def safe_address(self) -> str:
@@ -1268,6 +1270,22 @@ class BuildAlignClause:
     items: List[BuildAlignItem]
 
 
+@dataclass
+class BuildDeriveClause:
+    items: List[BuildDeriveItem]
+
+
+@dataclass
+class BuildDeriveItem:
+    expr: BuildExpr
+    name: str
+    namespace: str = field(default=DEFAULT_NAMESPACE)
+
+    @property
+    def address(self) -> str:
+        return f"{self.namespace}.{self.name}"
+
+
 @dataclass
 class BuildSelectLineage:
     selection: List[BuildConcept]
@@ -1299,12 +1317,16 @@ class BuildMultiSelectLineage(BuildConceptArgs):
     limit: Optional[int] = None
     where_clause: Union["BuildWhereClause", None] = field(default=None)
     having_clause: Union["BuildHavingClause", None] = field(default=None)
+    derive: BuildDeriveClause | None = None
 
     @property
     def derived_concepts(self) -> set[str]:
         output = set()
         for item in self.align.items:
             output.add(item.aligned_concept)
+        if self.derive:
+            for ditem in self.derive.items:
+                output.add(ditem.address)
         return output
 
     @property
@@ -1312,10 +1334,12 @@ class BuildMultiSelectLineage(BuildConceptArgs):
         return self.build_output_components
 
     @property
-    def derived_concept(self) -> set[str]:
-        output = set()
-        for item in self.align.items:
-            output.add(item.aligned_concept)
+    def calculated_derivations(self) -> set[str]:
+        output: set[str] = set()
+        if not self.derive:
+            return output
+        for item in self.derive.items:
+            output.add(item.address)
         return output
 
     @property
@@ -1335,6 +1359,7 @@ class BuildMultiSelectLineage(BuildConceptArgs):
                 for c in x.concepts:
                     if c.address in cte.output_lcl:
                         return c
+
         raise SyntaxError(
             f"Could not find upstream map for multiselect {str(concept)} on cte ({cte})"
         )
@@ -1961,6 +1986,28 @@ class Factory:
     def _build_align_clause(self, base: AlignClause) -> BuildAlignClause:
         return BuildAlignClause(items=[self._build_align_item(x) for x in base.items])
 
+    @build.register
+    def _(self, base: DeriveItem) -> BuildDeriveItem:
+        return self._build_derive_item(base)
+
+    def _build_derive_item(self, base: DeriveItem) -> BuildDeriveItem:
+        expr: Concept | FuncArgs = base.expr
+        validation = requires_concept_nesting(expr)
+        if validation:
+            expr, _ = self.instantiate_concept(validation)
+        return BuildDeriveItem(
+            expr=self.build(expr),
+            name=base.name,
+            namespace=base.namespace,
+        )
+
+    @build.register
+    def _(self, base: DeriveClause) -> BuildDeriveClause:
+        return self._build_derive_clause(base)
+
+    def _build_derive_clause(self, base: DeriveClause) -> BuildDeriveClause:
+        return BuildDeriveClause(items=[self.build(x) for x in base.items])
+
     @build.register
     def _(self, base: RowsetItem) -> BuildRowsetItem:
         return self._build_rowset_item(base)
@@ -2162,6 +2209,7 @@ class Factory:
             selects=base.selects,
             grain=final_grain,
             align=factory.build(base.align),
+            derive=factory.build(base.derive) if base.derive else None,
             # self.align.with_select_context(
             #     local_build_cache, self.grain, environment
             # ),

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/models/environment.py

@@ -413,7 +413,8 @@ class Environment(BaseModel):
             self.imports[alias].append(imp_stm)
         # we can't exit early
         # as there may be new concepts
-        for k, concept in source.concepts.items():
+        iteration: list[tuple[str, Concept]] = list(source.concepts.items())
+        for k, concept in iteration:
             # skip internal namespace
             if INTERNAL_NAMESPACE in concept.address:
                 continue

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/optimization.py

@@ -228,7 +228,8 @@ def optimize_ctes(
         REGISTERED_RULES.append(PredicatePushdown())
     if CONFIG.optimizations.predicate_pushdown:
         REGISTERED_RULES.append(PredicatePushdownRemove())
-    REGISTERED_RULES.append(HideUnusedConcepts())
+    if CONFIG.optimizations.hide_unused_concepts:
+        REGISTERED_RULES.append(HideUnusedConcepts())
     for rule in REGISTERED_RULES:
         loops = 0
         complete = False
@@ -242,7 +243,7 @@ def optimize_ctes(
                 actions_taken = actions_taken or opt
             complete = not actions_taken
             loops += 1
-            input = reorder_ctes(filter_irrelevant_ctes(input, root_cte))
+        input = reorder_ctes(filter_irrelevant_ctes(input, root_cte))
         logger.info(
             f"[Optimization] Finished checking for {type(rule).__name__} after {loops} loop(s)"
         )

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/optimizations/hide_unused_concept.py

@@ -39,11 +39,7 @@ class HideUnusedConcepts(OptimizationRule):
         self.log(
             f"Hiding unused concepts {[x.address for x in add_to_hidden]} from {cte.name} (used: {used}, all: {[x.address for x in cte.output_columns]})"
         )
-        candidates = [
-            x.address
-            for x in cte.output_columns
-            if x.address not in used and x.address not in cte.hidden_concepts
-        ]
+        candidates = [x.address for x in cte.output_columns if x.address not in used]
         if len(candidates) == len(set([x.address for x in cte.output_columns])):
             # pop one out
             candidates.pop()

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/processing/concept_strategies_v3.py

@@ -496,6 +496,8 @@ def _search_concepts(
         conditions=conditions,
     )
     partial: set[str] = set()
+    virtual: set[str] = set()
+    complete = ValidationResult.INCOMPLETE
     while context.incomplete:
 
         priority_concept = get_priority_concept(

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/processing/node_generators/basic_node.py

@@ -7,7 +7,7 @@ from trilogy.core.models.build_environment import BuildEnvironment
 from trilogy.core.processing.node_generators.common import (
     resolve_function_parent_concepts,
 )
-from trilogy.core.processing.nodes import History, StrategyNode
+from trilogy.core.processing.nodes import ConstantNode, History, StrategyNode
 from trilogy.utility import unique
 
 LOGGER_PREFIX = "[GEN_BASIC_NODE]"
@@ -51,11 +51,14 @@ def gen_basic_node(
     )
     synonyms: list[BuildConcept] = []
     ignored_optional: set[str] = set()
-    assert isinstance(concept.lineage, BuildFunction)
+
     # when we are getting an attribute, if there is anything else
     # that is an attribute of the same struct in local optional
     # select that value for discovery as well
-    if concept.lineage.operator == FunctionType.ATTR_ACCESS:
+    if (
+        isinstance(concept.lineage, BuildFunction)
+        and concept.lineage.operator == FunctionType.ATTR_ACCESS
+    ):
         logger.info(
             f"{depth_prefix}{LOGGER_PREFIX} checking for synonyms for attribute access"
         )
@@ -106,20 +109,28 @@ def gen_basic_node(
     logger.info(
         f"{depth_prefix}{LOGGER_PREFIX} Fetching parents {[x.address for x in all_parents]}"
     )
-    parent_node: StrategyNode | None = source_concepts(
-        mandatory_list=all_parents,
-        environment=environment,
-        g=g,
-        depth=depth + 1,
-        history=history,
-        conditions=conditions,
-    )
+    if all_parents:
+        parent_node: StrategyNode | None = source_concepts(
+            mandatory_list=all_parents,
+            environment=environment,
+            g=g,
+            depth=depth + 1,
+            history=history,
+            conditions=conditions,
+        )
 
-    if not parent_node:
-        logger.info(
-            f"{depth_prefix}{LOGGER_PREFIX} No basic node could be generated for {concept}"
+        if not parent_node:
+            logger.info(
+                f"{depth_prefix}{LOGGER_PREFIX} No basic node could be generated for {concept}"
+            )
+            return None
+    else:
+        return ConstantNode(
+            input_concepts=[],
+            output_concepts=[concept],
+            environment=environment,
+            depth=depth,
         )
-        return None
     if parent_node.source_type != SourceType.CONSTANT:
         parent_node.source_type = SourceType.BASIC
     parent_node.add_output_concept(concept)

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/processing/node_generators/common.py

@@ -4,6 +4,7 @@ from typing import Callable, List, Tuple
 from trilogy.core.enums import Derivation, Purpose
 from trilogy.core.models.build import (
     BuildAggregateWrapper,
+    BuildComparison,
     BuildConcept,
     BuildFilterItem,
     BuildFunction,
@@ -26,7 +27,9 @@ FUNCTION_TYPES = (BuildFunction,)
 def resolve_function_parent_concepts(
     concept: BuildConcept, environment: BuildEnvironment
 ) -> List[BuildConcept]:
-    if not isinstance(concept.lineage, (*FUNCTION_TYPES, *AGGREGATE_TYPES)):
+    if not isinstance(
+        concept.lineage, (*FUNCTION_TYPES, *AGGREGATE_TYPES, BuildComparison)
+    ):
         raise ValueError(
             f"Concept {concept} lineage is not function or aggregate, is {type(concept.lineage)}"
         )

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/processing/node_generators/multiselect_node.py

@@ -157,19 +157,19 @@ def gen_multiselect_node(
     possible_joins = concept_to_relevant_joins(additional_relevant)
     if not local_optional:
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} no enrichment required for rowset node; exiting early"
+            f"{padding(depth)}{LOGGER_PREFIX} no enrichment required for multiselect node; exiting early"
         )
         return node
     if not possible_joins:
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} no possible joins for rowset node; exiting early"
+            f"{padding(depth)}{LOGGER_PREFIX} no possible joins for multiselect node; exiting early"
         )
         return node
     if all(
         [x.address in [y.address for y in node.output_concepts] for x in local_optional]
     ):
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} all enriched concepts returned from base rowset node; exiting early"
+            f"{padding(depth)}{LOGGER_PREFIX} all enriched concepts returned from base multiselect node; exiting early"
         )
         return node
     logger.info(

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/core/statements/author.py

@@ -21,6 +21,7 @@ from trilogy.core.models.author import (
     Concept,
     ConceptRef,
     CustomType,
+    DeriveClause,
     Expr,
     FilterItem,
     Function,
@@ -352,11 +353,13 @@ class MultiSelectStatement(HasUUID, SelectTypeMixin, BaseModel):
     local_concepts: Annotated[
         EnvironmentConceptDict, PlainValidator(validate_concepts)
     ] = Field(default_factory=EnvironmentConceptDict)
+    derive: DeriveClause | None = None
 
     def as_lineage(self, environment: Environment):
         return MultiSelectLineage(
             selects=[x.as_lineage(environment) for x in self.selects],
             align=self.align,
+            derive=self.derive,
             namespace=self.namespace,
             # derived_concepts = self.derived_concepts,
             limit=self.limit,

{pytrilogy-0.0.3.115 → pytrilogy-0.0.3.117}/trilogy/dialect/base.py

@@ -176,6 +176,20 @@ def struct_arg(args):
     return [f"{x[1]}: {x[0]}" for x in zip(args[::2], args[1::2])]
 
 
+def hash_from_args(val, hash_type):
+    hash_type = hash_type[1:-1]
+    if hash_type.lower() == "md5":
+        return f"md5({val})"
+    elif hash_type.lower() == "sha1":
+        return f"sha1({val})"
+    elif hash_type.lower() == "sha256":
+        return f"sha256({val})"
+    elif hash_type.lower() == "sha512":
+        return f"sha512({val})"
+    else:
+        raise ValueError(f"Unsupported hash type: {hash_type}")
+
+
 FUNCTION_MAP = {
     # generic types
     FunctionType.ALIAS: lambda x: f"{x[0]}",
@@ -260,6 +274,7 @@ FUNCTION_MAP = {
     FunctionType.REGEXP_REPLACE: lambda x: f"REGEXP_REPLACE({x[0]},{x[1]}, {x[2]})",
     FunctionType.TRIM: lambda x: f"TRIM({x[0]})",
     FunctionType.REPLACE: lambda x: f"REPLACE({x[0]},{x[1]},{x[2]})",
+    FunctionType.HASH: lambda x: hash_from_args(x[0], x[1]),
     # FunctionType.NOT_LIKE: lambda x: f" CASE WHEN {x[0]} like {x[1]} THEN 0 ELSE 1 END",
     # date types
     FunctionType.DATE_TRUNCATE: lambda x: f"date_trunc({x[0]},{x[1]})",
@@ -484,7 +499,20 @@ class BaseDialect:
             elif isinstance(c.lineage, BuildRowsetItem):
                 rval = f"{self.render_concept_sql(c.lineage.content, cte=cte, alias=False, raise_invalid=raise_invalid)}"
             elif isinstance(c.lineage, BuildMultiSelectLineage):
-                rval = f"{self.render_concept_sql(c.lineage.find_source(c, cte), cte=cte, alias=False, raise_invalid=raise_invalid)}"
+                if c.address in c.lineage.calculated_derivations:
+                    assert c.lineage.derive is not None
+                    for x in c.lineage.derive.items:
+                        if x.address == c.address:
+                            rval = self.render_expr(
+                                x.expr,
+                                cte=cte,
+                                raise_invalid=raise_invalid,
+                            )
+                            break
+                else:
+                    rval = f"{self.render_concept_sql(c.lineage.find_source(c, cte), cte=cte, alias=False, raise_invalid=raise_invalid)}"
+            elif isinstance(c.lineage, BuildComparison):
+                rval = f"{self.render_expr(c.lineage.left, cte=cte, raise_invalid=raise_invalid)} {c.lineage.operator.value} {self.render_expr(c.lineage.right, cte=cte, raise_invalid=raise_invalid)}"
             elif isinstance(c.lineage, AGGREGATE_ITEMS):
                 args = [
                     self.render_expr(v, cte)  # , alias=False)
@@ -816,7 +844,7 @@ class BaseDialect:
             if self.rendering.parameters:
                 if e.concept.namespace == DEFAULT_NAMESPACE:
                     return f":{e.concept.name}"
-                return f":{e.concept.address}"
+                return f":{e.concept.address.replace('.', '_')}"
             elif e.concept.lineage:
                 return self.render_expr(e.concept.lineage, cte=cte, cte_map=cte_map)
             return f"{self.QUOTE_CHARACTER}{e.concept.address}{self.QUOTE_CHARACTER}"