pytrilogy 0.0.1.107__tar.gz → 0.0.1.109__tar.gz

{pytrilogy-0.0.1.107/pytrilogy.egg-info → pytrilogy-0.0.1.109}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytrilogy
-Version: 0.0.1.107
+Version: 0.0.1.109
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytrilogy
-Version: 0.0.1.107
+Version: 0.0.1.109
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/pytrilogy.egg-info/SOURCES.txt

@@ -52,12 +52,12 @@ trilogy/core/processing/utility.py
 trilogy/core/processing/node_generators/__init__.py
 trilogy/core/processing/node_generators/basic_node.py
 trilogy/core/processing/node_generators/common.py
-trilogy/core/processing/node_generators/concept_merge.py
+trilogy/core/processing/node_generators/concept_merge_node.py
 trilogy/core/processing/node_generators/filter_node.py
 trilogy/core/processing/node_generators/group_node.py
 trilogy/core/processing/node_generators/group_to_node.py
-trilogy/core/processing/node_generators/merge_node.py
 trilogy/core/processing/node_generators/multiselect_node.py
+trilogy/core/processing/node_generators/node_merge_node.py
 trilogy/core/processing/node_generators/rowset_node.py
 trilogy/core/processing/node_generators/select_node.py
 trilogy/core/processing/node_generators/unnest_node.py
@@ -81,7 +81,6 @@ trilogy/dialect/postgres.py
 trilogy/dialect/presto.py
 trilogy/dialect/snowflake.py
 trilogy/dialect/sql_server.py
-trilogy/docs/__init__.py
 trilogy/hooks/__init__.py
 trilogy/hooks/base_hook.py
 trilogy/hooks/graph_hook.py

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.executor import Executor
 from trilogy.parser import parse
 from trilogy.constants import CONFIG
 
-__version__ = "0.0.1.107"
+__version__ = "0.0.1.109"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/env_processor.py

@@ -21,6 +21,8 @@ def generate_graph(
             for source in concept.sources:
                 generic = source.with_default_grain()
                 g.add_edge(generic, node_name)
+
+                # link the concept to the generic source
                 if concept.derivation == PurposeLineage.MERGE:
                     g.add_edge(node_name, generic)
     for _, dataset in environment.datasources.items():

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/models.py

@@ -496,13 +496,31 @@ class Concept(Namespaced, SelectGrain, BaseModel):
     @property
     def sources(self) -> List["Concept"]:
         if self.lineage:
-            output = []
-            for item in self.lineage.arguments:
-                if isinstance(item, Concept):
-                    if item.address == self.address:
-                        raise SyntaxError(f"Concept {self.address} references itself")
-                    output.append(item)
-                    output += item.sources
+            output: List[Concept] = []
+
+            def get_sources(
+                expr: Union[
+                    Function,
+                    WindowItem,
+                    FilterItem,
+                    AggregateWrapper,
+                    RowsetItem,
+                    MultiSelectStatement | MergeStatement,
+                ],
+                output: List[Concept],
+            ):
+                for item in expr.arguments:
+                    if isinstance(item, Concept):
+                        if item.address == self.address:
+                            raise SyntaxError(
+                                f"Concept {self.address} references itself"
+                            )
+                        output.append(item)
+                        output += item.sources
+                    elif isinstance(item, Function):
+                        get_sources(item, output)
+
+            get_sources(self.lineage, output)
             return output
         return []
 
@@ -1512,7 +1530,7 @@ class MergeStatement(Namespaced, BaseModel):
                 if z.address == x.address:
                     return z
         raise SyntaxError(
-            f"Could not find upstream map for multiselect {str(concept)} on cte ({cte})"
+            f"Could not find upstream map for multiselect {str(concept)} on cte ({cte.name})"
         )
 
     def with_namespace(self, namespace: str) -> "MergeStatement":
@@ -1779,6 +1797,7 @@ class QueryDatasource(BaseModel):
     source_type: SourceType = SourceType.SELECT
     partial_concepts: List[Concept] = Field(default_factory=list)
     join_derived_concepts: List[Concept] = Field(default_factory=list)
+    hidden_concepts: List[Concept] = Field(default_factory=list)
     force_group: bool | None = None
 
     @property
@@ -1997,6 +2016,7 @@ class CTE(BaseModel):
     condition: Optional[Union["Conditional", "Comparison", "Parenthetical"]] = None
     partial_concepts: List[Concept] = Field(default_factory=list)
     join_derived_concepts: List[Concept] = Field(default_factory=list)
+    hidden_concepts: List[Concept] = Field(default_factory=list)
     order_by: Optional[OrderBy] = None
     limit: Optional[int] = None
     requires_nesting: bool = True
@@ -2433,6 +2453,7 @@ class Environment(BaseModel):
     cte_name_map: Dict[str, str] = Field(default_factory=dict)
 
     materialized_concepts: List[Concept] = Field(default_factory=list)
+    merged_concepts: Dict[str, Concept] = Field(default_factory=dict)
     _parse_count: int = 0
 
     @classmethod
@@ -2460,7 +2481,7 @@ class Environment(BaseModel):
             f.write(self.model_dump_json())
         return ppath
 
-    def gen_materialized_concepts(self) -> None:
+    def gen_concept_list_caches(self) -> None:
         concrete_addresses = set()
         for datasource in self.datasources.values():
             for concept in datasource.output_concepts:
@@ -2468,6 +2489,12 @@ class Environment(BaseModel):
         self.materialized_concepts = [
             c for c in self.concepts.values() if c.address in concrete_addresses
         ]
+        for concept in self.concepts.values():
+            if concept.derivation == PurposeLineage.MERGE:
+                ms = concept.lineage
+                assert isinstance(ms, MergeStatement)
+                for parent in ms.concepts:
+                    self.merged_concepts[parent.address] = concept
 
     def validate_concept(self, lookup: str, meta: Meta | None = None):
         existing: Concept = self.concepts.get(lookup)  # type: ignore
@@ -2503,7 +2530,7 @@ class Environment(BaseModel):
             self.concepts[f"{alias}.{key}"] = concept.with_namespace(alias)
         for key, datasource in environment.datasources.items():
             self.datasources[f"{alias}.{key}"] = datasource.with_namespace(alias)
-        self.gen_materialized_concepts()
+        self.gen_concept_list_caches()
         return self
 
     def add_file_import(self, path: str, alias: str, env: Environment | None = None):
@@ -2602,7 +2629,7 @@ class Environment(BaseModel):
             from trilogy.core.environment_helpers import generate_related_concepts
 
             generate_related_concepts(concept, self)
-        self.gen_materialized_concepts()
+        self.gen_concept_list_caches()
         return concept
 
     def add_datasource(
@@ -2612,12 +2639,12 @@ class Environment(BaseModel):
     ):
         if not datasource.namespace or datasource.namespace == DEFAULT_NAMESPACE:
             self.datasources[datasource.name] = datasource
-            self.gen_materialized_concepts()
+            self.gen_concept_list_caches()
             return datasource
         self.datasources[datasource.namespace + "." + datasource.identifier] = (
             datasource
         )
-        self.gen_materialized_concepts()
+        self.gen_concept_list_caches()
         return datasource
 
 

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/optimization.py

@@ -136,6 +136,6 @@ def optimize_ctes(
             select.where_clause.conditional if select.where_clause else None
         )
         root_cte.requires_nesting = False
-        sort_select_output(cte, select)
+        sort_select_output(root_cte, select)
 
     return filter_irrelevant_ctes(input, root_cte)

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/processing/concept_strategies_v3.py

@@ -337,7 +337,9 @@ def generate_node(
 
 
 def validate_stack(
-    stack: List[StrategyNode], concepts: List[Concept], accept_partial: bool = False
+    stack: List[StrategyNode],
+    concepts: List[Concept],
+    accept_partial: bool = False,
 ) -> tuple[ValidationResult, set[str], set[str], set[str]]:
     found_map = defaultdict(set)
     found_addresses: set[str] = set()
@@ -357,6 +359,7 @@ def validate_stack(
                 if accept_partial:
                     found_addresses.add(concept.address)
                     found_map[str(node)].add(concept)
+    # zip in those we know we found
     if not all([c.address in found_addresses for c in concepts]):
         return (
             ValidationResult.INCOMPLETE,
@@ -388,7 +391,7 @@ def search_concepts(
     hist = history.get_history(mandatory_list, accept_partial)
     if hist is not False:
         logger.info(
-            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Returning search node from history"
+            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Returning search node from history for {[c.address for c in mandatory_list]} with accept_partial {accept_partial}"
         )
         assert not isinstance(hist, bool)
         return hist
@@ -454,7 +457,6 @@ def _search_concepts(
             if node:
                 stack.append(node)
                 node.resolve()
-                found.add(priority_concept.address)
                 # these concepts should not be attempted to be sourced again
                 # as fetching them requires operating on a subset of concepts
                 if priority_concept.derivation in [
@@ -473,11 +475,12 @@ def _search_concepts(
         complete, found, missing, partial = validate_stack(
             stack, mandatory_list, accept_partial
         )
-        # early exit if we have a complete stack with one node
+
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} finished concept loop for {priority_concept} flag for accepting partial addresses is "
             f" {accept_partial} (complete: {complete}), have {found} from {[n for n in stack]} (missing {missing} partial {partial}), attempted {attempted}"
         )
+        # early exit if we have a complete stack with one node
         # we can only early exit if we have a complete stack
         # and we are not looking for more non-partial sources
         if complete == ValidationResult.COMPLETE and (
@@ -514,6 +517,10 @@ def _search_concepts(
             parents=stack,
             depth=depth,
             partial_concepts=all_partial,
+            # always hide merge concepts
+            hidden_concepts=[
+                x for x in mandatory_list if x.derivation == PurposeLineage.MERGE
+            ],
         )
 
         # ensure we can resolve our final merge

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/processing/node_generators/__init__.py

@@ -5,10 +5,10 @@ from .group_to_node import gen_group_to_node
 from .basic_node import gen_basic_node
 from .select_node import gen_select_node
 from .unnest_node import gen_unnest_node
-from .merge_node import gen_merge_node
+from .node_merge_node import gen_merge_node
 from .rowset_node import gen_rowset_node
 from .multiselect_node import gen_multiselect_node
-from .concept_merge import gen_concept_merge_node
+from .concept_merge_node import gen_concept_merge_node
 
 __all__ = [
     "gen_filter_node",

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/processing/node_generators/common.py

@@ -196,6 +196,7 @@ def gen_enrichment_node(
     log_lambda(
         f"{str(type(base_node).__name__)} returning merge node with group node + enrichment node"
     )
+
     return MergeNode(
         input_concepts=unique(
             join_keys + extra_required + base_node.output_concepts, "address"

pytrilogy-0.0.1.107/trilogy/core/processing/node_generators/concept_merge.py → pytrilogy-0.0.1.109/trilogy/core/processing/node_generators/concept_merge_node.py

@@ -7,27 +7,30 @@ from trilogy.core.processing.nodes import MergeNode, NodeJoin, History
 from trilogy.core.processing.nodes.base_node import concept_list_to_grain, StrategyNode
 from typing import List
 
-from trilogy.core.enums import JoinType
+from trilogy.core.enums import JoinType, PurposeLineage
 from trilogy.constants import logger
 from trilogy.core.processing.utility import padding
 from trilogy.core.processing.node_generators.common import concept_to_relevant_joins
 from itertools import combinations
 from trilogy.core.processing.node_generators.common import resolve_join_order
+from trilogy.utility import unique
+
 
 LOGGER_PREFIX = "[GEN_CONCEPT_MERGE_NODE]"
 
 
-def merge_joins(base: MergeStatement, parents: List[StrategyNode]) -> List[NodeJoin]:
+def merge_joins(
+    parents: List[StrategyNode], merge_concepts: List[Concept]
+) -> List[NodeJoin]:
     output = []
     for left, right in combinations(parents, 2):
         output.append(
             NodeJoin(
                 left_node=left,
                 right_node=right,
-                concepts=[
-                    base.merge_concept,
-                ],
+                concepts=merge_concepts,
                 join_type=JoinType.FULL,
+                filter_to_mutual=True,
             )
         )
     return resolve_join_order(output)
@@ -50,37 +53,70 @@ def gen_concept_merge_node(
     lineage: MergeStatement = concept.lineage
 
     base_parents: List[StrategyNode] = []
+
+    # get additional concepts that should be merged across the environments
+    additional_merge: List[Concept] = [*lineage.concepts]
+    for x in local_optional:
+        if x.address in environment.merged_concepts:
+            ms = environment.merged_concepts[x.address].lineage
+            assert isinstance(ms, MergeStatement)
+            additional_merge += ms.concepts
+
     for select in lineage.concepts:
         # if it's a merge concept, filter it out of the optional
         sub_optional = [
             x
             for x in local_optional
-            if x.address not in lineage.concepts_lcl and x.namespace == select.namespace
+            if x.address not in environment.merged_concepts
+            and x.namespace == select.namespace
+        ]
+
+        sub_additional_merge = [
+            x for x in additional_merge if x.namespace == select.namespace
         ]
+        sub_optional += sub_additional_merge
+        final: List[Concept] = unique([select] + sub_optional, "address")
         snode: StrategyNode = source_concepts(
-            mandatory_list=[select] + sub_optional,
+            mandatory_list=final,
             environment=environment,
             g=g,
             depth=depth + 1,
             history=history,
         )
+
         if not snode:
             logger.info(
                 f"{padding(depth)}{LOGGER_PREFIX} Cannot generate merge node for {concept}"
             )
             return None
-        snode.add_output_concept(lineage.merge_concept)
+        for x in sub_additional_merge:
+            snode.add_output_concept(environment.merged_concepts[x.address])
         base_parents.append(snode)
 
-    node_joins = merge_joins(lineage, base_parents)
+    node_joins = merge_joins(
+        base_parents,
+        unique(
+            [environment.merged_concepts[x.address] for x in additional_merge],
+            "address",
+        ),
+    )
 
     enrichment = set([x.address for x in local_optional])
-    outputs = [x for y in base_parents for x in y.output_concepts]
+    outputs = [
+        x
+        for y in base_parents
+        for x in y.output_concepts
+        if x.derivation != PurposeLineage.MERGE
+    ]
 
     additional_relevant = [x for x in outputs if x.address in enrichment]
+    final_outputs = outputs + additional_relevant + [concept]
     node = MergeNode(
         input_concepts=[x for y in base_parents for x in y.output_concepts],
-        output_concepts=outputs + additional_relevant + [concept],
+        output_concepts=[x for x in final_outputs],
+        hidden_concepts=[
+            x for x in final_outputs if x.derivation == PurposeLineage.MERGE
+        ],
         environment=environment,
         g=g,
         depth=depth,
@@ -127,9 +163,19 @@ def gen_concept_merge_node(
         )
         return node
 
+    # we still need the hidden concepts to be returned to the search
+    # since they must be on the final node
+    # to avoid further recursion
+    # TODO: let the downstream search know they were found
     return MergeNode(
         input_concepts=enrich_node.output_concepts + node.output_concepts,
+        # also filter out the
         output_concepts=node.output_concepts + local_optional,
+        hidden_concepts=[
+            x
+            for x in node.output_concepts + local_optional
+            if x.derivation == PurposeLineage.MERGE
+        ],
         environment=environment,
         g=g,
         depth=depth,

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/processing/node_generators/rowset_node.py

@@ -10,7 +10,7 @@ from trilogy.core.processing.nodes import MergeNode, NodeJoin, History, Strategy
 from trilogy.core.processing.nodes.base_node import concept_list_to_grain
 from typing import List
 
-from trilogy.core.enums import JoinType
+from trilogy.core.enums import JoinType, PurposeLineage
 from trilogy.constants import logger
 from trilogy.core.processing.utility import padding
 from trilogy.core.processing.node_generators.common import concept_to_relevant_joins
@@ -53,7 +53,7 @@ def gen_rowset_node(
         return None
     node.conditions = select.where_clause.conditional if select.where_clause else None
     # rebuild any cached info with the new condition clause
-    node.rebuild_cache()
+
     enrichment = set([x.address for x in local_optional])
     rowset_relevant = [
         x
@@ -71,9 +71,15 @@ def gen_rowset_node(
     if select.where_clause:
         for item in additional_relevant:
             node.partial_concepts.append(item)
-
+    node.hidden_concepts = [
+        x
+        for x in node.output_concepts
+        if x.address not in [y.address for y in local_optional + [concept]]
+        and x.derivation != PurposeLineage.ROWSET
+    ]
     # assume grain to be output of select
     # but don't include anything aggregate at this point
+    node.rebuild_cache()
     assert node.resolution_cache
     node.resolution_cache.grain = concept_list_to_grain(
         node.output_concepts, parent_sources=node.resolution_cache.datasources

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/processing/nodes/__init__.py

@@ -27,12 +27,18 @@ class History(BaseModel):
         self,
         search: list[Concept],
         accept_partial: bool = False,
+        parent_key: str = "",
     ) -> StrategyNode | None | bool:
+        key = self._concepts_to_lookup(
+            search,
+            accept_partial,
+        )
+        if parent_key and parent_key == key:
+            raise ValueError(
+                f"Parent key {parent_key} is the same as the current key {key}"
+            )
         return self.history.get(
-            self._concepts_to_lookup(
-                search,
-                accept_partial,
-            ),
+            key,
             False,
         )
 

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/processing/nodes/base_node.py

@@ -107,6 +107,7 @@ class StrategyNode:
         conditions: Conditional | Comparison | Parenthetical | None = None,
         force_group: bool | None = None,
         grain: Optional[Grain] = None,
+        hidden_concepts: List[Concept] | None = None,
     ):
         self.input_concepts: List[Concept] = (
             unique(input_concepts, "address") if input_concepts else []
@@ -129,6 +130,7 @@ class StrategyNode:
         self.grain = grain
         self.force_group = force_group
         self.tainted = False
+        self.hidden_concepts = hidden_concepts or []
         for parent in self.parents:
             if not parent:
                 raise SyntaxError("Unresolvable parent")
@@ -182,6 +184,7 @@ class StrategyNode:
 
     def rebuild_cache(self) -> QueryDatasource:
         self.tainted = True
+        self.output_lcl = LooseConceptList(concepts=self.output_concepts)
         if not self.resolution_cache:
             return self.resolve()
         self.resolution_cache = None

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/processing/nodes/merge_node.py

@@ -104,6 +104,7 @@ class MergeNode(StrategyNode):
         depth: int = 0,
         grain: Grain | None = None,
         conditions: Conditional | None = None,
+        hidden_concepts: List[Concept] | None = None,
     ):
         super().__init__(
             input_concepts=input_concepts,
@@ -117,6 +118,7 @@ class MergeNode(StrategyNode):
             force_group=force_group,
             grain=grain,
             conditions=conditions,
+            hidden_concepts=hidden_concepts,
         )
         self.join_concepts = join_concepts
         self.force_join_type = force_join_type
@@ -205,6 +207,7 @@ class MergeNode(StrategyNode):
             joins = self.translate_node_joins(final_joins)
         else:
             return []
+
         for join in joins:
             logger.info(
                 f"{self.logging_prefix}{LOGGER_PREFIX} final join {join.join_type} {[str(c) for c in join.concepts]}"
@@ -327,5 +330,6 @@ class MergeNode(StrategyNode):
             partial_concepts=self.partial_concepts,
             force_group=force_group,
             condition=self.conditions,
+            hidden_concepts=self.hidden_concepts,
         )
         return qds

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/core/query_processor.py

@@ -216,6 +216,7 @@ def datasource_to_ctes(
         condition=query_datasource.condition,
         partial_concepts=query_datasource.partial_concepts,
         join_derived_concepts=query_datasource.join_derived_concepts,
+        hidden_concepts=query_datasource.hidden_concepts,
     )
     if cte.grain != query_datasource.grain:
         raise ValueError("Grain was corrupted in CTE generation")

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/dialect/base.py

@@ -437,6 +437,7 @@ class BaseDialect:
                 self.render_concept_sql(c, cte)
                 for c in cte.output_columns
                 if c.address not in [y.address for y in cte.join_derived_concepts]
+                and c.address not in [y.address for y in cte.hidden_concepts]
             ] + [
                 f"{self.QUOTE_CHARACTER}{c.safe_address}{self.QUOTE_CHARACTER}"
                 for c in cte.join_derived_concepts
@@ -444,7 +445,9 @@ class BaseDialect:
         else:
             # otherwse, assume we are unnesting directly in the select
             select_columns = [
-                self.render_concept_sql(c, cte) for c in cte.output_columns
+                self.render_concept_sql(c, cte)
+                for c in cte.output_columns
+                if c.address not in [y.address for y in cte.hidden_concepts]
             ]
         return CompiledCTE(
             name=cte.name,

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/dialect/config.py

@@ -100,22 +100,7 @@ class PrestoConfig(DialectConfig):
         return f"presto://{self.username}:{self.password}@{self.host}:{self.port}/{self.catalog}"
 
 
-class TrinoConfig(DialectConfig):
-    def __init__(
-        self,
-        host: str,
-        port: int,
-        username: str,
-        password: str,
-        catalog: str,
-        schema: str | None = None,
-    ):
-        self.host = host
-        self.port = port
-        self.username = username
-        self.password = password
-        self.catalog = catalog
-        self.schema = schema
+class TrinoConfig(PrestoConfig):
 
     def connection_string(self) -> str:
         if self.schema:

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/dialect/presto.py

@@ -27,6 +27,9 @@ FUNCTION_MAP = {
     FunctionType.QUARTER: lambda x: f"EXTRACT(QUARTER from {x[0]})",
     # math
     FunctionType.DIVIDE: lambda x: f"SAFE_DIVIDE({x[0]},{x[1]})",
+    FunctionType.DATE_ADD: lambda x: f"DATE_ADD('{x[1]}', {x[2]}, {x[0]})",
+    FunctionType.CURRENT_DATE: lambda x: "CURRENT_DATE",
+    FunctionType.CURRENT_DATETIME: lambda x: "CURRENT_TIMESTAMP",
 }
 
 FUNCTION_GRAIN_MATCH_MAP = {
@@ -42,11 +45,10 @@ CREATE OR REPLACE TABLE {{ output.address }} AS
 {% endif %}{%- if ctes %}
 WITH {% for cte in ctes %}
 {{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
-
-SELECT
 {%- if full_select -%}
 {{full_select}}
-{%- else -%}
+{%- else %}
+SELECT
 {%- for select in select_columns %}
     {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
 {% if base %}FROM

{pytrilogy-0.0.1.107 → pytrilogy-0.0.1.109}/trilogy/parsing/parse_engine.py

@@ -981,13 +981,13 @@ class ParseToObjects(Transformer):
 
     @v_args(meta=True)
     def merge_statement(self, meta: Meta, args) -> MergeStatement:
-
         parsed = [self.environment.concepts[x] for x in args]
         datatypes = {x.datatype for x in parsed}
-        if not len(datatypes) == 1:
+        if not len(datatypes) == 1 and self.environment.concepts.fail_on_missing:
+            type_dict = {x.address: x.datatype for x in parsed}
             raise SyntaxError(
-                f"Cannot merge concepts with different datatypes {datatypes}"
-                f"line: {meta.line} concepts: {[x.address for x in parsed]}"
+                f"Cannot merge concepts with different datatype"
+                f"line: {meta.line} concepts: {type_dict}"
             )
         merge = MergeStatement(concepts=parsed, datatype=datatypes.pop())
         new = merge.merge_concept