pytrilogy 0.0.1.104__tar.gz → 0.0.1.105__tar.gz

{pytrilogy-0.0.1.104/pytrilogy.egg-info → pytrilogy-0.0.1.105}/PKG-INFO

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

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/__init__.py

@@ -3,6 +3,6 @@ from trilogy.dialect.enums import Dialects
 from trilogy.executor import Executor
 from trilogy.parser import parse
 
-__version__ = "0.0.1.104"
+__version__ = "0.0.1.105"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment"]

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/core/models.py

@@ -113,15 +113,27 @@ NAMESPACED_TYPES = Union[
 
 
 class Namespaced(ABC):
-    pass
 
     def with_namespace(self, namespace: str):
         raise NotImplementedError
 
 
-class SelectGrain(ABC):
-    pass
+class ConceptArgs(ABC):
+
+    @property
+    def concept_arguments(self) -> List["Concept"]:
+        raise NotImplementedError
+
+    @property
+    def existence_arguments(self) -> List["Concept"]:
+        return []
+
+    @property
+    def row_arguments(self) -> List["Concept"]:
+        return self.concept_arguments
 
+
+class SelectGrain(ABC):
     def with_select_grain(self, grain: Grain):
         raise NotImplementedError
 
@@ -1395,16 +1407,11 @@ class MultiSelectStatement(Namespaced, BaseModel):
         return output
 
     def find_source(self, concept: Concept, cte: CTE) -> Concept:
-        all = []
         for x in self.align.items:
             if concept.name == x.alias:
                 for c in x.concepts:
                     if c.address in cte.output_lcl:
-                        all.append(c)
-
-        if len(all) == 1:
-            return all[0]
-
+                        return c
         raise SyntaxError(
             f"Could not find upstream map for multiselect {str(concept)} on cte ({cte})"
         )
@@ -2546,7 +2553,7 @@ class LazyEnvironment(Environment):
         return super().__getattribute__(name)
 
 
-class Comparison(Namespaced, SelectGrain, BaseModel):
+class Comparison(ConceptArgs, Namespaced, SelectGrain, BaseModel):
     left: Union[
         int,
         str,
@@ -2598,7 +2605,7 @@ class Comparison(Namespaced, SelectGrain, BaseModel):
         return f"{str(self.left)} {self.operator.value} {str(self.right)}"
 
     def with_namespace(self, namespace: str):
-        return Comparison(
+        return self.__class__(
             left=(
                 self.left.with_namespace(namespace)
                 if isinstance(self.left, Namespaced)
@@ -2613,7 +2620,7 @@ class Comparison(Namespaced, SelectGrain, BaseModel):
         )
 
     def with_select_grain(self, grain: Grain):
-        return Comparison(
+        return self.__class__(
             left=(
                 self.left.with_select_grain(grain)
                 if isinstance(self.left, SelectGrain)
@@ -2632,7 +2639,9 @@ class Comparison(Namespaced, SelectGrain, BaseModel):
         output: List[Concept] = []
         if isinstance(self.left, (Concept,)):
             output += [self.left]
-        if isinstance(self.left, (Conditional, Parenthetical)):
+        if isinstance(
+            self.left, (Comparison, SubselectComparison, Conditional, Parenthetical)
+        ):
             output += self.left.input
         if isinstance(self.left, FilterItem):
             output += self.left.concept_arguments
@@ -2641,7 +2650,9 @@ class Comparison(Namespaced, SelectGrain, BaseModel):
 
         if isinstance(self.right, (Concept,)):
             output += [self.right]
-        if isinstance(self.right, (Conditional, Parenthetical)):
+        if isinstance(
+            self.right, (Comparison, SubselectComparison, Conditional, Parenthetical)
+        ):
             output += self.right.input
         if isinstance(self.right, FilterItem):
             output += self.right.concept_arguments
@@ -2658,8 +2669,31 @@ class Comparison(Namespaced, SelectGrain, BaseModel):
         return output
 
 
+class SubselectComparison(Comparison):
+
+    @property
+    def row_arguments(self) -> List[Concept]:
+        return get_concept_arguments(self.left)
+
+    @property
+    def existence_arguments(self) -> List[Concept]:
+        return get_concept_arguments(self.right)
+
+    def with_select_grain(self, grain: Grain):
+        # there's no need to pass the select grain through to a subselect comparison
+        return self.__class__(
+            left=(
+                self.left.with_select_grain(grain)
+                if isinstance(self.left, SelectGrain)
+                else self.left
+            ),
+            right=self.right,
+            operator=self.operator,
+        )
+
+
 class CaseWhen(Namespaced, SelectGrain, BaseModel):
-    comparison: Conditional | Comparison
+    comparison: Conditional | SubselectComparison | Comparison
     expr: "Expr"
 
     @property
@@ -2726,7 +2760,7 @@ class CaseElse(Namespaced, SelectGrain, BaseModel):
         )
 
 
-class Conditional(Namespaced, SelectGrain, BaseModel):
+class Conditional(ConceptArgs, Namespaced, SelectGrain, BaseModel):
     left: Union[
         int,
         str,
@@ -2821,6 +2855,32 @@ class Conditional(Namespaced, SelectGrain, BaseModel):
         output += get_concept_arguments(self.right)
         return output
 
+    @property
+    def row_arguments(self) -> List[Concept]:
+        output = []
+        if isinstance(self.left, ConceptArgs):
+            output += self.left.row_arguments
+        else:
+            output += get_concept_arguments(self.left)
+        if isinstance(self.right, ConceptArgs):
+            output += self.right.row_arguments
+        else:
+            output += get_concept_arguments(self.right)
+        return output
+
+    @property
+    def existence_arguments(self) -> List[Concept]:
+        output = []
+        if isinstance(self.left, ConceptArgs):
+            output += self.left.existence_arguments
+        else:
+            output += get_concept_arguments(self.left)
+        if isinstance(self.right, ConceptArgs):
+            output += self.right.existence_arguments
+        else:
+            output += get_concept_arguments(self.right)
+        return output
+
 
 class AggregateWrapper(Namespaced, SelectGrain, BaseModel):
     function: Function
@@ -2864,8 +2924,8 @@ class AggregateWrapper(Namespaced, SelectGrain, BaseModel):
         return AggregateWrapper(function=self.function.with_select_grain(grain), by=by)
 
 
-class WhereClause(Namespaced, SelectGrain, BaseModel):
-    conditional: Union[Comparison, Conditional, "Parenthetical"]
+class WhereClause(ConceptArgs, Namespaced, SelectGrain, BaseModel):
+    conditional: Union[SubselectComparison, Comparison, Conditional, "Parenthetical"]
 
     @property
     def input(self) -> List[Concept]:
@@ -2875,6 +2935,14 @@ class WhereClause(Namespaced, SelectGrain, BaseModel):
     def concept_arguments(self) -> List[Concept]:
         return self.conditional.concept_arguments
 
+    @property
+    def row_arguments(self) -> List[Concept]:
+        return self.conditional.row_arguments
+
+    @property
+    def existence_arguments(self) -> List[Concept]:
+        return self.conditional.existence_arguments
+
     def with_namespace(self, namespace: str) -> WhereClause:
         return WhereClause(conditional=self.conditional.with_namespace(namespace))
 
@@ -3062,7 +3130,7 @@ class RowsetItem(Namespaced, BaseModel):
         return [self.content]
 
 
-class Parenthetical(Namespaced, SelectGrain, BaseModel):
+class Parenthetical(ConceptArgs, Namespaced, SelectGrain, BaseModel):
     content: "Expr"
 
     def __str__(self):
@@ -3106,6 +3174,18 @@ class Parenthetical(Namespaced, SelectGrain, BaseModel):
             base.append(x)
         return base
 
+    @property
+    def row_arguments(self) -> List[Concept]:
+        if isinstance(self.content, ConceptArgs):
+            return self.content.row_arguments
+        return self.concept_arguments
+
+    @property
+    def existence_arguments(self) -> List[Concept]:
+        if isinstance(self.content, ConceptArgs):
+            return self.content.existence_arguments
+        return self.concept_arguments
+
     @property
     def input(self):
         base = []

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/core/processing/concept_strategies_v3.py

@@ -317,6 +317,7 @@ def generate_node(
         return gen_basic_node(
             concept, local_optional, environment, g, depth + 1, source_concepts, history
         )
+
     elif concept.derivation == PurposeLineage.ROOT:
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating select node with optional {[x.address for x in local_optional]}"

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/core/processing/node_generators/common.py

@@ -45,21 +45,33 @@ def resolve_function_parent_concepts(concept: Concept) -> List[Concept]:
     return unique(concept.lineage.concept_arguments, "address")
 
 
-def resolve_filter_parent_concepts(concept: Concept) -> Tuple[Concept, List[Concept]]:
+def resolve_filter_parent_concepts(
+    concept: Concept,
+) -> Tuple[Concept, List[Concept], List[Concept]]:
     if not isinstance(concept.lineage, FilterItem):
-        raise ValueError
+        raise ValueError(
+            f"Concept {concept} lineage is not filter item, is {type(concept.lineage)}"
+        )
     direct_parent = concept.lineage.content
-    base = [direct_parent]
-    base += concept.lineage.where.concept_arguments
+    base_existence = []
+    base_rows = [direct_parent]
+    base_rows += concept.lineage.where.row_arguments
+    base_existence += concept.lineage.where.existence_arguments
     if direct_parent.grain:
-        base += direct_parent.grain.components_copy
+        base_rows += direct_parent.grain.components_copy
     if (
         isinstance(direct_parent, Concept)
         and direct_parent.purpose == Purpose.PROPERTY
         and direct_parent.keys
     ):
-        base += direct_parent.keys
-    return concept.lineage.content, unique(base, "address")
+        base_rows += direct_parent.keys
+    if concept.lineage.where.existence_arguments:
+        return (
+            concept.lineage.content,
+            unique(base_rows, "address"),
+            unique(base_existence, "address"),
+        )
+    return concept.lineage.content, unique(base_rows, "address"), []
 
 
 def gen_property_enrichment_node(

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/core/processing/node_generators/filter_node.py

@@ -11,7 +11,7 @@ from trilogy.core.processing.node_generators.common import (
     resolve_filter_parent_concepts,
 )
 from trilogy.constants import logger
-from trilogy.core.processing.utility import padding
+from trilogy.core.processing.utility import padding, unique
 from trilogy.core.processing.node_generators.common import concept_to_relevant_joins
 
 LOGGER_PREFIX = "[GEN_FILTER_NODE]"
@@ -26,30 +26,57 @@ def gen_filter_node(
     source_concepts,
     history: History | None = None,
 ) -> MergeNode | FilterNode | None:
-    immediate_parent, parent_concepts = resolve_filter_parent_concepts(concept)
+    immediate_parent, parent_row_concepts, parent_existence_concepts = (
+        resolve_filter_parent_concepts(concept)
+    )
 
-    logger.info(f"{padding(depth)}{LOGGER_PREFIX} fetching filter node parents")
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} fetching filter node row parents {[x.address for x in parent_row_concepts]}"
+    )
+    core_parents = []
     parent = source_concepts(
-        mandatory_list=parent_concepts,
+        mandatory_list=parent_row_concepts,
         environment=environment,
         g=g,
         depth=depth + 1,
         history=history,
     )
+
     if not parent:
         return None
+    core_parents.append(parent)
+    if parent_existence_concepts:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} fetching filter node existence parents {[x.address for x in parent_existence_concepts]}"
+        )
+        parent_existence = source_concepts(
+            mandatory_list=parent_existence_concepts,
+            environment=environment,
+            g=g,
+            depth=depth + 1,
+            history=history,
+        )
+        if not parent_existence:
+            return None
+        core_parents.append(parent_existence)
+
     filter_node = FilterNode(
-        input_concepts=[immediate_parent] + parent_concepts,
-        output_concepts=[concept, immediate_parent] + parent_concepts,
+        input_concepts=unique(
+            [immediate_parent] + parent_row_concepts + parent_existence_concepts,
+            "address",
+        ),
+        output_concepts=[concept, immediate_parent] + parent_row_concepts,
         environment=environment,
         g=g,
-        parents=[parent],
+        parents=core_parents,
     )
-    if not local_optional:
+    if not local_optional or all(
+        [x.address in [y.address for y in parent_row_concepts] for x in local_optional]
+    ):
         return filter_node
     enrich_node = source_concepts(  # this fetches the parent + join keys
         # to then connect to the rest of the query
-        mandatory_list=[immediate_parent] + parent_concepts + local_optional,
+        mandatory_list=[immediate_parent] + parent_row_concepts + local_optional,
         environment=environment,
         g=g,
         depth=depth + 1,
@@ -75,7 +102,7 @@ def gen_filter_node(
                 left_node=enrich_node,
                 right_node=filter_node,
                 concepts=concept_to_relevant_joins(
-                    [immediate_parent] + parent_concepts
+                    [immediate_parent] + parent_row_concepts
                 ),
                 join_type=JoinType.LEFT_OUTER,
                 filter_to_mutual=False,

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/core/processing/node_generators/merge_node.py

@@ -87,8 +87,18 @@ def gen_merge_node(
 ) -> Optional[MergeNode]:
     join_candidates: List[PathInfo] = []
     # anchor on datasources
+    final_all_concepts = []
+    # implicit_upstream = {}
+    for x in all_concepts:
+        # if x.derivation in (PurposeLineage.AGGREGATE, PurposeLineage.BASIC):
+        #     final_all_concepts +=resolve_function_parent_concepts(x)
+        # elif x.derivation == PurposeLineage.FILTER:
+        #     final_all_concepts +=resolve_filter_parent_concepts(x)
+        # else:
+        #     final_all_concepts.append(x)
+        final_all_concepts.append(x)
     for datasource in environment.datasources.values():
-        path = identify_ds_join_paths(all_concepts, g, datasource, accept_partial)
+        path = identify_ds_join_paths(final_all_concepts, g, datasource, accept_partial)
         if path and path.reduced_concepts:
             join_candidates.append(path)
     join_candidates.sort(key=lambda x: sum([len(v) for v in x.paths.values()]))

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/dialect/base.py

@@ -22,6 +22,7 @@ from trilogy.core.models import (
     CompiledCTE,
     Conditional,
     Comparison,
+    SubselectComparison,
     OrderItem,
     WindowItem,
     FilterItem,
@@ -273,14 +274,13 @@ class BaseDialect:
                 ]
                 rval = f"{self.WINDOW_FUNCTION_MAP[c.lineage.type](concept = self.render_concept_sql(c.lineage.content, cte=cte, alias=False), window=','.join(rendered_over_components), sort=','.join(rendered_order_components))}"  # noqa: E501
             elif isinstance(c.lineage, FilterItem):
-                rval = f"CASE WHEN {self.render_expr(c.lineage.where.conditional)} THEN {self.render_concept_sql(c.lineage.content, cte=cte, alias=False)} ELSE NULL END"
+                rval = f"CASE WHEN {self.render_expr(c.lineage.where.conditional, cte=cte)} THEN {self.render_concept_sql(c.lineage.content, cte=cte, alias=False)} ELSE NULL END"
             elif isinstance(c.lineage, RowsetItem):
                 rval = f"{self.render_concept_sql(c.lineage.content, cte=cte, alias=False)}"
             elif isinstance(c.lineage, MultiSelectStatement):
                 rval = f"{self.render_concept_sql(c.lineage.find_source(c, cte), cte=cte, alias=False)}"
             elif isinstance(c.lineage, MergeStatement):
                 rval = f"{self.render_concept_sql(c.lineage.find_source(c, cte), cte=cte, alias=False)}"
-                #  rval = f"{self.FUNCTION_MAP[FunctionType.COALESCE](*[self.render_concept_sql(parent, cte=cte, alias=False) for parent in c.lineage.find_sources(c, cte)])}"
             elif isinstance(c.lineage, AggregateWrapper):
                 args = [
                     self.render_expr(v, cte)  # , alias=False)
@@ -330,6 +330,7 @@ class BaseDialect:
             Function,
             Conditional,
             Comparison,
+            SubselectComparison,
             Concept,
             str,
             int,
@@ -358,7 +359,15 @@ class BaseDialect:
         # if isinstance(e, Concept):
         #     cte = cte or cte_map.get(e.address, None)
 
-        if isinstance(e, Comparison):
+        if isinstance(e, SubselectComparison):
+            assert cte, "Subselects must be rendered with a CTE in context"
+            if isinstance(e.right, Concept):
+                return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} (select {self.render_expr(e.right, cte=cte, cte_map=cte_map)} from {cte.source_map[e.right.address][0]})"
+            else:
+                raise NotImplementedError(
+                    f"Subselects must be a concept, got {e.right}"
+                )
+        elif isinstance(e, Comparison):
             return f"{self.render_expr(e.left, cte=cte, cte_map=cte_map)} {e.operator.value} {self.render_expr(e.right, cte=cte, cte_map=cte_map)}"
         elif isinstance(e, Conditional):
             # conditions need to be nested in parentheses

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/parsing/common.py

@@ -174,3 +174,33 @@ def agg_wrapper_to_concept(
         keys=tuple(parent.by) if parent.by else keys,
     )
     return out
+
+
+def arbitrary_to_concept(
+    parent: (
+        AggregateWrapper
+        | WindowItem
+        | FilterItem
+        | Function
+        | ListWrapper
+        | int
+        | float
+        | str
+    ),
+    namespace: str,
+    name: str,
+    metadata: Metadata | None = None,
+    purpose: Purpose | None = None,
+) -> Concept:
+    if isinstance(parent, AggregateWrapper):
+        return agg_wrapper_to_concept(parent, namespace, name, metadata, purpose)
+    elif isinstance(parent, WindowItem):
+        return window_item_to_concept(parent, name, namespace, purpose, metadata)
+    elif isinstance(parent, FilterItem):
+        return filter_item_to_concept(parent, name, namespace, purpose, metadata)
+    elif isinstance(parent, Function):
+        return function_to_concept(parent, name, namespace)
+    elif isinstance(parent, ListWrapper):
+        return constant_to_concept(parent, name, namespace, purpose, metadata)
+    else:
+        return constant_to_concept(parent, name, namespace, purpose, metadata)

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/parsing/parse_engine.py

@@ -17,6 +17,7 @@ from trilogy.constants import (
     DEFAULT_NAMESPACE,
     NULL_VALUE,
     VIRTUAL_CONCEPT_PREFIX,
+    MagicConstants,
 )
 from trilogy.core.enums import (
     BooleanOperator,
@@ -62,6 +63,7 @@ from trilogy.core.models import (
     ColumnAssignment,
     Comment,
     Comparison,
+    SubselectComparison,
     Concept,
     ConceptTransform,
     Conditional,
@@ -108,6 +110,7 @@ from trilogy.parsing.common import (
     function_to_concept,
     filter_item_to_concept,
     constant_to_concept,
+    arbitrary_to_concept,
 )
 
 CONSTANT_TYPES = (int, float, str, bool, ListWrapper)
@@ -187,9 +190,9 @@ grammar = r"""
 
     // FUNCTION blocks
     function: raw_function
-    function_binding_item: IDENTIFIER data_type
+    function_binding_item: IDENTIFIER ":" data_type
     function_binding_list: (function_binding_item ",")* function_binding_item ","?
-    raw_function: "def" "rawsql"  IDENTIFIER  "("  function_binding_list ")" "-" ">" data_type "as"i MULTILINE_STRING
+    raw_function: "bind" "sql"  IDENTIFIER  "("  function_binding_list ")" "-" ">" data_type "as"i MULTILINE_STRING
 
     
     // user_id where state = Mexico
@@ -246,7 +249,9 @@ grammar = r"""
 
     COMPARISON_OPERATOR: (/is[\s]+not/ | "is" |"=" | ">" | "<" | ">=" | "<=" | "!="  )
     
-    comparison: (expr COMPARISON_OPERATOR expr) | (expr array_comparison expr_tuple) 
+    comparison: (expr COMPARISON_OPERATOR expr) | (expr array_comparison expr_tuple)
+
+    subselect_comparison: expr array_comparison expr
     
     expr_tuple: "("  (expr ",")* expr ","?  ")"
 
@@ -258,7 +263,7 @@ grammar = r"""
 
     parenthetical: "(" (conditional | expr) ")"
     
-    expr:  window_item | filter_item | comparison | fgroup |  aggregate_functions | unnest | _string_functions | _math_functions | _generic_functions | _constant_functions| _date_functions |  literal |  expr_reference  | index_access | attr_access |  parenthetical
+    expr:  window_item | filter_item | comparison | subselect_comparison | fgroup |  aggregate_functions | unnest | _string_functions | _math_functions | _generic_functions | _constant_functions| _date_functions |  literal |  expr_reference  | index_access | attr_access |  parenthetical
     
     // functions
     
@@ -525,43 +530,11 @@ class ParseToObjects(Transformer):
                     concept.metadata.line_number = meta.line
                 self.environment.add_concept(concept, meta=meta)
                 final.append(concept)
-            elif isinstance(arg, FilterItem):
+            elif isinstance(
+                arg, (FilterItem, WindowItem, AggregateWrapper, ListWrapper)
+            ):
                 id_hash = string_to_hash(str(arg))
-                concept = filter_item_to_concept(
-                    arg,
-                    name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
-                    namespace=self.environment.namespace,
-                )
-                if concept.metadata:
-                    concept.metadata.line_number = meta.line
-                self.environment.add_concept(concept, meta=meta)
-                final.append(concept)
-            elif isinstance(arg, WindowItem):
-                id_hash = string_to_hash(str(arg))
-                concept = window_item_to_concept(
-                    arg,
-                    namespace=self.environment.namespace,
-                    name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
-                )
-                if concept.metadata:
-                    concept.metadata.line_number = meta.line
-                self.environment.add_concept(concept, meta=meta)
-                final.append(concept)
-            elif isinstance(arg, AggregateWrapper):
-                id_hash = string_to_hash(str(arg))
-                concept = agg_wrapper_to_concept(
-                    arg,
-                    namespace=self.environment.namespace,
-                    name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
-                )
-                if concept.metadata:
-                    concept.metadata.line_number = meta.line
-                self.environment.add_concept(concept, meta=meta)
-                final.append(concept)
-            # we don't need virtual types for most constants
-            elif isinstance(arg, (ListWrapper)):
-                id_hash = string_to_hash(str(arg))
-                concept = constant_to_concept(
+                concept = arbitrary_to_concept(
                     arg,
                     name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
                     namespace=self.environment.namespace,
@@ -570,6 +543,7 @@ class ParseToObjects(Transformer):
                     concept.metadata.line_number = meta.line
                 self.environment.add_concept(concept, meta=meta)
                 final.append(concept)
+
             else:
                 final.append(arg)
         return final
@@ -773,8 +747,10 @@ class ParseToObjects(Transformer):
         while isinstance(source_value, Parenthetical):
             source_value = source_value.content
 
-        if isinstance(source_value, FilterItem):
-            concept = filter_item_to_concept(
+        if isinstance(
+            source_value, (FilterItem, WindowItem, AggregateWrapper, Function)
+        ):
+            concept = arbitrary_to_concept(
                 source_value,
                 name=name,
                 namespace=namespace,
@@ -782,31 +758,6 @@ class ParseToObjects(Transformer):
                 metadata=metadata,
             )
 
-            if concept.metadata:
-                concept.metadata.line_number = meta.line
-            self.environment.add_concept(concept, meta=meta)
-            return ConceptDerivation(concept=concept)
-        elif isinstance(source_value, WindowItem):
-
-            concept = window_item_to_concept(
-                source_value,
-                name=name,
-                namespace=namespace,
-                purpose=purpose,
-                metadata=metadata,
-            )
-            if concept.metadata:
-                concept.metadata.line_number = meta.line
-            self.environment.add_concept(concept, meta=meta)
-            return ConceptDerivation(concept=concept)
-        elif isinstance(source_value, AggregateWrapper):
-            concept = agg_wrapper_to_concept(
-                source_value,
-                namespace=namespace,
-                name=name,
-                metadata=metadata,
-                purpose=purpose,
-            )
             if concept.metadata:
                 concept.metadata.line_number = meta.line
             self.environment.add_concept(concept, meta=meta)
@@ -824,19 +775,6 @@ class ParseToObjects(Transformer):
             self.environment.add_concept(concept, meta=meta)
             return ConceptDerivation(concept=concept)
 
-        elif isinstance(source_value, Function):
-            function: Function = source_value
-
-            concept = function_to_concept(
-                function,
-                name=name,
-                namespace=namespace,
-            )
-            if concept.metadata:
-                concept.metadata.line_number = meta.line
-            self.environment.add_concept(concept, meta=meta)
-            return ConceptDerivation(concept=concept)
-
         raise SyntaxError(
             f"Received invalid type {type(args[2])} {args[2]} as input to select"
             " transform"
@@ -1219,7 +1157,14 @@ class ParseToObjects(Transformer):
     def where(self, args):
         root = args[0]
         if not isinstance(root, (Comparison, Conditional, Parenthetical)):
-            root = Comparison(left=root, right=True, operator=ComparisonOperator.EQ)
+            if arg_to_datatype(root) == DataType.BOOL:
+                root = Comparison(left=root, right=True, operator=ComparisonOperator.EQ)
+            else:
+                root = Comparison(
+                    left=root,
+                    right=MagicConstants.NULL,
+                    operator=ComparisonOperator.IS_NOT,
+                )
         return WhereClause(conditional=root)
 
     @v_args(meta=True)
@@ -1232,7 +1177,6 @@ class ParseToObjects(Transformer):
 
     @v_args(meta=True)
     def raw_function(self, meta: Meta, args) -> Function:
-        print(args)
         identity = args[0]
         fargs = args[1]
         output = args[2]
@@ -1273,6 +1217,22 @@ class ParseToObjects(Transformer):
     def comparison(self, args) -> Comparison:
         return Comparison(left=args[0], right=args[2], operator=args[1])
 
+    @v_args(meta=True)
+    def subselect_comparison(self, meta: Meta, args) -> SubselectComparison:
+        right = args[2]
+        if not isinstance(right, Concept):
+            right = arbitrary_to_concept(
+                right,
+                namespace=self.environment.namespace,
+                name=f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(right))}",
+            )
+            self.environment.add_concept(right)
+        return SubselectComparison(
+            left=args[0],
+            right=right,
+            operator=args[1],
+        )
+
     def expr_tuple(self, args):
         return Parenthetical(content=args)
 

{pytrilogy-0.0.1.104 → pytrilogy-0.0.1.105}/trilogy/parsing/render.py

@@ -298,128 +298,6 @@ class Renderer:
     def _(self, arg: "FilterItem"):
         return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
 
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
-    @to_string.register
-    def _(self, arg: "ImportStatement"):
-        return f"import {arg.path} as {arg.alias};"
-
-    @to_string.register
-    def _(self, arg: "WindowItem"):
-        over = ",".join(self.to_string(c) for c in arg.over)
-        order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
-            return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
-            )
-        return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
-
-    @to_string.register
-    def _(self, arg: "FilterItem"):
-        return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
-
     @to_string.register
     def _(self, arg: "ImportStatement"):
         return f"import {arg.path} as {arg.alias};"