pytrilogy 0.0.3.51__tar.gz → 0.0.3.53__tar.gz

{pytrilogy-0.0.3.51/pytrilogy.egg-info → pytrilogy-0.0.3.53}/PKG-INFO

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

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/pytrilogy.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ trilogy/core/graph_models.py
 trilogy/core/internal.py
 trilogy/core/optimization.py
 trilogy/core/query_processor.py
+trilogy/core/utility.py
 trilogy/core/models/__init__.py
 trilogy/core/models/author.py
 trilogy/core/models/build.py

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/tests/test_functions.py

@@ -261,6 +261,9 @@ def test_string_functions(test_environment):
     property strpos_name <- strpos(category_name, 'a');
     property like_name <- like(category_name, 'a%');
     property like_alt <- category_name like 'a%';
+    property regex_contains <- regexp_contains(category_name, 'a');
+    property regex_substring <- regexp_extract(category_name, 'a');
+    property regex_replace <- regexp_replace(category_name, 'a', 'b');
 
     select
         test_name,

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/tests/test_parse_engine.py

@@ -46,6 +46,36 @@ FROM a
 """
 
 
+def test_parse_datatype_in_datasource():
+    env = Environment()
+    x = ParseToObjects(environment=env)
+    test_text = """
+key x int;
+property x.timestamp timestamp;
+
+datasource funky (
+    x: x,
+    timestamp:timestamp)
+address fun;
+
+"""
+    x.set_text(test_text)
+
+    tokens = PARSER.parse(test_text)
+    x.transform(tokens)
+    x.run_second_parse_pass()
+
+
+TEXT2 = """
+const a <- 1;
+
+select
+    a,
+FROM a
+;
+"""
+
+
 def test_from_error():
     env = Environment()
 

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/tests/test_parsing.py

@@ -92,7 +92,12 @@ def test_arg_to_datatype():
 
 
 def test_argument_to_purpose(test_environment: Environment):
-    assert argument_to_purpose(1.00) == Purpose.CONSTANT
+    assert (
+        argument_to_purpose(
+            1.00,
+        )
+        == Purpose.CONSTANT
+    )
     assert argument_to_purpose("test") == Purpose.CONSTANT
     assert argument_to_purpose(test_environment.concepts["order_id"]) == Purpose.KEY
     assert (
@@ -100,19 +105,22 @@ def test_argument_to_purpose(test_environment: Environment):
             [
                 "test",
                 1.00,
-            ]
+            ],
+            test_environment,
         )
         == Purpose.CONSTANT
     )
     assert (
         function_args_to_output_purpose(
-            ["test", 1.00, test_environment.concepts["order_id"]]
+            ["test", 1.00, test_environment.concepts["order_id"]], test_environment
         )
         == Purpose.PROPERTY
     )
     unnest_env, parsed = parse_text("const random <- unnest([1,2,3,4]);")
     assert (
-        function_args_to_output_purpose([unnest_env.concepts["random"]])
+        function_args_to_output_purpose(
+            [unnest_env.concepts["random"]], test_environment
+        )
         == Purpose.PROPERTY
     )
 
@@ -488,7 +496,7 @@ select x;
 
     results = Dialects.DUCK_DB.default_executor().generate_sql(text)[0]
 
-    assert '"abc:def" as test' in results
+    assert '"abc:def" as "test"' in results
 
     text = """
 key x int;
@@ -508,7 +516,7 @@ select x;
 
     results = Dialects.DUCK_DB.default_executor().generate_sql(text)[0]
 
-    assert "abcdef as test" in results, results
+    assert '"abcdef" as "test"' in results, results
 
 
 def test_datasource_where_equivalent():

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/tests/test_show.py

@@ -53,5 +53,5 @@ def test_show_bigquery():
         .fetchall()
     )
     assert (
-        "FULL JOIN cheerful on 1=1" in query[0]["__preql_internal_query_text"]
+        'FULL JOIN "cheerful" on 1=1' in query[0]["__preql_internal_query_text"]
     ), query[0]["__preql_internal_query_text"]

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/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.51"
+__version__ = "0.0.3.53"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/core/enums.py

@@ -181,6 +181,11 @@ class FunctionType(Enum):
     STRPOS = "strpos"
     CONTAINS = "contains"
 
+    # STRING REGEX
+    REGEXP_CONTAINS = "regexp_contains"
+    REGEXP_EXTRACT = "regexp_extract"
+    REGEXP_REPLACE = "regexp_replace"
+
     # Dates
     DATE = "date"
     DATETIME = "datetime"

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/core/functions.py

@@ -360,6 +360,24 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type=DataType.STRING,
         arg_count=1,
     ),
+    FunctionType.REGEXP_CONTAINS: FunctionConfig(
+        valid_inputs={DataType.STRING},
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.BOOL,
+        arg_count=2,
+    ),
+    FunctionType.REGEXP_EXTRACT: FunctionConfig(
+        valid_inputs={DataType.STRING},
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.STRING,
+        arg_count=2,
+    ),
+    FunctionType.REGEXP_REPLACE: FunctionConfig(
+        valid_inputs={DataType.STRING},
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.STRING,
+        arg_count=3,
+    ),
     FunctionType.DATE: FunctionConfig(
         valid_inputs={
             DataType.DATE,
@@ -809,13 +827,14 @@ def create_function_derived_concept(
     namespace: str,
     operator: FunctionType,
     arguments: list[Concept],
+    environment: Environment,
     output_type: Optional[
         DataType | ListType | StructType | MapType | NumericType | TraitDataType
     ] = None,
     output_purpose: Optional[Purpose] = None,
 ) -> Concept:
     purpose = (
-        function_args_to_output_purpose(arguments)
+        function_args_to_output_purpose(arguments, environment=environment)
         if output_purpose is None
         else output_purpose
     )
@@ -868,13 +887,15 @@ def argument_to_purpose(arg) -> Purpose:
         raise ValueError(f"Cannot parse arg purpose for {arg} of type {type(arg)}")
 
 
-def function_args_to_output_purpose(args) -> Purpose:
+def function_args_to_output_purpose(args, environment: Environment) -> Purpose:
     has_metric = False
     has_non_constant = False
     has_non_single_row_constant = False
     if not args:
         return Purpose.CONSTANT
     for arg in args:
+        if isinstance(arg, ConceptRef):
+            arg = environment.concepts[arg.address]
         purpose = argument_to_purpose(arg)
         if purpose == Purpose.METRIC:
             has_metric = True

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/core/models/author.py

@@ -25,6 +25,7 @@ from pydantic import (
     ValidationInfo,
     computed_field,
     field_validator,
+    model_validator,
 )
 
 from trilogy.constants import DEFAULT_NAMESPACE, MagicConstants
@@ -621,8 +622,8 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
             return v.reference
         return v
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
+    @model_validator(mode="after")
+    def validate_comparison(self):
         if self.operator in (ComparisonOperator.IS, ComparisonOperator.IS_NOT):
             if self.right != MagicConstants.NULL and DataType.BOOL != arg_to_datatype(
                 self.right
@@ -632,7 +633,6 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
                 )
         elif self.operator in (ComparisonOperator.IN, ComparisonOperator.NOT_IN):
             right_type = arg_to_datatype(self.right)
-
             if isinstance(right_type, ListType) and not is_compatible_datatype(
                 arg_to_datatype(self.left), right_type.value_data_type
             ):
@@ -653,6 +653,8 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
                     f"Cannot compare {arg_to_datatype(self.left)} and {arg_to_datatype(self.right)} of different types with operator {self.operator} in {str(self)}"
                 )
 
+        return self
+
     def __add__(self, other):
         if other is None:
             return self
@@ -1022,7 +1024,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         keys = self.keys
 
         if self.is_aggregate and isinstance(new_lineage, Function) and grain.components:
-            grain_components = [
+            grain_components: list[ConceptRef | Concept] = [
                 environment.concepts[c].reference for c in grain.components
             ]
             new_lineage = AggregateWrapper(function=new_lineage, by=grain_components)
@@ -1847,9 +1849,6 @@ class AggregateWrapper(Mergeable, DataTyped, ConceptArgs, Namespaced, BaseModel)
     function: Function
     by: List[ConceptRef | Concept] = Field(default_factory=list)
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
     @field_validator("by", mode="before")
     @classmethod
     def enforce_concept_ref(cls, v):

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/core/models/build.py

@@ -262,11 +262,8 @@ class BuildGrain(BaseModel):
     components: set[str] = Field(default_factory=set)
     where_clause: Optional[BuildWhereClause] = None
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
     def without_condition(self):
-        return BuildGrain(components=self.components)
+        return BuildGrain.model_construct(components=self.components)
 
     @classmethod
     def from_concepts(
@@ -321,12 +318,12 @@ class BuildGrain(BaseModel):
                 # raise NotImplementedError(
                 #     f"Cannot merge grains with where clauses, self {self.where_clause} other {other.where_clause}"
                 # )
-        return BuildGrain(
+        return BuildGrain.model_construct(
             components=self.components.union(other.components), where_clause=where
         )
 
     def __sub__(self, other: "BuildGrain") -> "BuildGrain":
-        return BuildGrain(
+        return BuildGrain.model_construct(
             components=self.components.difference(other.components),
             where_clause=self.where_clause,
         )
@@ -637,9 +634,6 @@ class BuildComparison(BuildConceptArgs, ConstantInlineable, BaseModel):
     ]
     operator: ComparisonOperator
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-
     def __add__(self, other):
         if other is None:
             return self

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/core/models/execute.py

@@ -1,9 +1,16 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Any, Dict, List, Optional, Set, Union
-
-from pydantic import BaseModel, Field, ValidationInfo, computed_field, field_validator
+from typing import Dict, List, Optional, Set, Union
+
+from pydantic import (
+    BaseModel,
+    Field,
+    ValidationInfo,
+    computed_field,
+    field_validator,
+    model_validator,
+)
 
 from trilogy.constants import CONFIG, logger
 from trilogy.core.constants import CONSTANT_DATASET
@@ -30,6 +37,7 @@ from trilogy.core.models.build import (
     LooseBuildConceptList,
 )
 from trilogy.core.models.datasource import Address
+from trilogy.core.utility import safe_quote
 from trilogy.utility import unique
 
 LOGGER_PREFIX = "[MODELS_EXECUTE]"
@@ -194,6 +202,7 @@ class CTE(BaseModel):
             self.base_name_override = ds_being_inlined.safe_location
             self.base_alias_override = ds_being_inlined.safe_identifier
 
+        # if we have a join to the parent, we need to remove it
         for join in self.joins:
             if isinstance(join, InstantiatedUnnestJoin):
                 continue
@@ -315,17 +324,20 @@ class CTE(BaseModel):
         return self.source.name
 
     @property
-    def quote_address(self) -> dict[str, bool]:
-
-        return {
-            candidate.safe_identifier: (
-                candidate.address.quoted and not candidate.address.is_query
-                if isinstance(candidate, BuildDatasource)
-                and isinstance(candidate.address, Address)
-                else False
-            )
-            for candidate in self.source.datasources
-        }
+    def quote_address(self) -> bool:
+        if self.is_root_datasource:
+            root = self.source.datasources[0]
+            if isinstance(root, BuildDatasource) and isinstance(root.address, Address):
+                return not root.address.is_query
+            return True
+        elif not self.source.datasources:
+            return False
+        base = self.source.datasources[0]
+        if isinstance(base, BuildDatasource):
+            if isinstance(base.address, Address):
+                return not base.address.is_query
+            return True
+        return True
 
     @property
     def base_alias(self) -> str:
@@ -473,8 +485,8 @@ class BaseJoin(BaseModel):
     left_datasource: Optional[Union[BuildDatasource, "QueryDatasource"]] = None
     concept_pairs: list[ConceptPair] | None = None
 
-    def __init__(self, **data: Any):
-        super().__init__(**data)
+    @model_validator(mode="after")
+    def validate_join(self) -> "BaseJoin":
         if (
             self.left_datasource
             and self.left_datasource.identifier == self.right_datasource.identifier
@@ -483,14 +495,18 @@ class BaseJoin(BaseModel):
                 f"Cannot join a dataself to itself, joining {self.left_datasource} and"
                 f" {self.right_datasource}"
             )
-        final_concepts = []
 
-        # if we have a list of concept pairs
+        # Early returns maintained as in original code
         if self.concept_pairs:
-            return
+            return self
+
         if self.concepts == []:
-            return
+            return self
+
+        # Validation logic
+        final_concepts = []
         assert self.left_datasource and self.right_datasource
+
         for concept in self.concepts or []:
             include = True
             for ds in [self.left_datasource, self.right_datasource]:
@@ -507,6 +523,7 @@ class BaseJoin(BaseModel):
                     )
             if include:
                 final_concepts.append(concept)
+
         if not final_concepts and self.concepts:
             # if one datasource only has constants
             # we can join on 1=1
@@ -519,11 +536,11 @@ class BaseJoin(BaseModel):
                     ]
                 ):
                     self.concepts = []
-                    return
+                    return self
                 # if everything is at abstract grain, we can skip joins
                 if all([c.grain.abstract for c in ds.output_concepts]):
                     self.concepts = []
-                    return
+                    return self
 
             left_keys = [c.address for c in self.left_datasource.output_concepts]
             right_keys = [c.address for c in self.right_datasource.output_concepts]
@@ -535,7 +552,9 @@ class BaseJoin(BaseModel):
                 f" right_keys {right_keys},"
                 f" provided join concepts {match_concepts}"
             )
+
         self.concepts = final_concepts
+        return self
 
     @property
     def unique_id(self) -> str:
@@ -912,8 +931,8 @@ class Join(BaseModel):
     def right_ref(self) -> str:
         if self.quote:
             if self.right_cte.identifier in self.inlined_ctes:
-                return f"{self.quote}{self.right_cte.source.datasources[0].safe_location}{self.quote} as {self.right_cte.source.datasources[0].safe_identifier}"
-            return self.right_cte.safe_identifier
+                return f"{safe_quote(self.right_cte.source.datasources[0].safe_location, self.quote)} as {self.quote}{self.right_cte.source.datasources[0].safe_identifier}{self.quote}"
+            return f"{self.quote}{self.right_cte.safe_identifier}{self.quote}"
         if self.right_cte.identifier in self.inlined_ctes:
             return f"{self.right_cte.source.datasources[0].safe_location} as {self.right_cte.source.datasources[0].safe_identifier}"
         return self.right_cte.safe_identifier

pytrilogy-0.0.3.53/trilogy/core/utility.py

@@ -0,0 +1,8 @@
+def safe_quote(string: str, quote_char: str):
+    # split dotted identifiers
+    # TODO: evaluate if we need smarter parsing for strings that could actually include .
+    if string.startswith("https://"):
+        # it's a url, no splitting
+        return f"{quote_char}{string}{quote_char}"
+    components = string.split(".")
+    return ".".join([f"{quote_char}{string}{quote_char}" for string in components])

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/dialect/base.py

@@ -74,6 +74,7 @@ from trilogy.core.statements.execute import (
     ProcessedRawSQLStatement,
     ProcessedShowStatement,
 )
+from trilogy.core.utility import safe_quote
 from trilogy.dialect.common import render_join, render_unnest
 from trilogy.hooks.base_hook import BaseHook
 
@@ -204,6 +205,9 @@ FUNCTION_MAP = {
     FunctionType.SUBSTRING: lambda x: f"SUBSTRING({x[0]},{x[1]},{x[2]})",
     FunctionType.STRPOS: lambda x: f"STRPOS({x[0]},{x[1]})",
     FunctionType.CONTAINS: lambda x: f"CONTAINS({x[0]},{x[1]})",
+    FunctionType.REGEXP_CONTAINS: lambda x: f"REGEXP_CONTAINS({x[0]},{x[1]})",
+    FunctionType.REGEXP_EXTRACT: lambda x: f"REGEXP_EXTRACT({x[0]},{x[1]})",
+    FunctionType.REGEXP_REPLACE: lambda x: f"REGEXP_REPLACE({x[0]},{x[1]}, {x[2]})",
     # 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]})",
@@ -270,13 +274,6 @@ ORDER BY{% for order in order_by %}
 )
 
 
-def safe_quote(string: str, quote_char: str):
-    # split dotted identifiers
-    # TODO: evaluate if we need smarter parsing for strings that could actually include .
-    components = string.split(".")
-    return ".".join([f"{quote_char}{string}{quote_char}" for string in components])
-
-
 def safe_get_cte_value(coalesce, cte: CTE | UnionCTE, c: BuildConcept, quote_char: str):
     address = c.address
     raw = cte.source_map.get(address, None)
@@ -285,12 +282,17 @@ def safe_get_cte_value(coalesce, cte: CTE | UnionCTE, c: BuildConcept, quote_cha
         return None
     if isinstance(raw, str):
         rendered = cte.get_alias(c, raw)
-        return f"{raw}.{safe_quote(rendered, quote_char)}"
+        return f"{quote_char}{raw}{quote_char}.{safe_quote(rendered, quote_char)}"
     if isinstance(raw, list) and len(raw) == 1:
         rendered = cte.get_alias(c, raw[0])
-        return f"{raw[0]}.{safe_quote(rendered, quote_char)}"
+        return f"{quote_char}{raw[0]}{quote_char}.{safe_quote(rendered, quote_char)}"
     return coalesce(
-        sorted([f"{x}.{safe_quote(cte.get_alias(c, x), quote_char)}" for x in raw])
+        sorted(
+            [
+                f"{quote_char}{x}{quote_char}.{safe_quote(cte.get_alias(c, x), quote_char)}"
+                for x in raw
+            ]
+        )
     )
 
 
@@ -783,12 +785,12 @@ class BaseDialect:
             else:
                 source = None
         else:
-            if cte.quote_address.get(cte.source.datasources[0].safe_identifier, False):
-                source = f"{self.QUOTE_CHARACTER}{cte.base_name}{self.QUOTE_CHARACTER}"
+            if cte.quote_address:
+                source = safe_quote(cte.base_name, self.QUOTE_CHARACTER)
             else:
                 source = cte.base_name
             if cte.base_name != cte.base_alias:
-                source = f"{source} as {cte.base_alias}"
+                source = f"{source} as {self.QUOTE_CHARACTER}{cte.base_alias}{self.QUOTE_CHARACTER}"
         if not cte.render_from_clause:
             final_joins = []
         else:

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/dialect/bigquery.py

@@ -18,6 +18,7 @@ FUNCTION_MAP = {
     FunctionType.LIKE: lambda x: (
         f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
     ),
+    FunctionType.IS_NULL: lambda x: f"CASE WHEN {x[0]} IS NULL THEN True ELSE False END",
     FunctionType.MINUTE: lambda x: f"EXTRACT(MINUTE from {x[0]})",
     FunctionType.SECOND: lambda x: f"EXTRACT(SECOND from {x[0]})",
     FunctionType.HOUR: lambda x: f"EXTRACT(HOUR from {x[0]})",

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/dialect/common.py

@@ -63,8 +63,8 @@ def render_join_concept(
         elif isinstance(raw_content, BuildFunction):
             rval = render_expr(raw_content, cte=cte)
             return rval
-        return f"{name}.{quote_character}{raw_content}{quote_character}"
-    return f"{name}.{quote_character}{concept.safe_address}{quote_character}"
+        return f"{quote_character}{name}{quote_character}.{quote_character}{raw_content}{quote_character}"
+    return f"{quote_character}{name}{quote_character}.{quote_character}{concept.safe_address}{quote_character}"
 
 
 def render_join(
@@ -91,8 +91,9 @@ def render_join(
         return f"FULL JOIN {render_unnest(unnest_mode, quote_character, join.object_to_unnest, render_expr_func, cte)}"
     # left_name = join.left_name
     right_name = join.right_name
-    if cte.quote_address.get(join.right_name, False):
-        join.quote = quote_character
+    join.quote = quote_character
+    # if cte.quote_address.get(join.right_name, False):
+    #     join.quote = quote_character
     right_base = join.right_ref
     base_joinkeys = []
     if join.joinkey_pairs:

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/parsing/common.py

@@ -62,7 +62,7 @@ def process_function_arg(
             operator=FunctionType.PARENTHETICAL,
             arguments=processed,
             output_datatype=arg_to_datatype(processed[0]),
-            output_purpose=function_args_to_output_purpose(processed),
+            output_purpose=function_args_to_output_purpose(processed, environment),
         )
     elif isinstance(arg, Function):
         # if it's not an aggregate function, we can skip the virtual concepts
@@ -140,7 +140,7 @@ def get_purpose_and_keys(
     args: Tuple[ConceptRef | Concept, ...] | None,
     environment: Environment,
 ) -> Tuple[Purpose, set[str] | None]:
-    local_purpose = purpose or function_args_to_output_purpose(args)
+    local_purpose = purpose or function_args_to_output_purpose(args, environment)
     if local_purpose in (Purpose.PROPERTY, Purpose.METRIC) and args:
         keys = concept_list_to_keys(args, environment)
     else:
@@ -548,7 +548,7 @@ def filter_item_to_concept(
 
     else:
         raise NotImplementedError(
-            f"Filter item with non ref content {parent.content} not yet supported"
+            f"Filter item with non ref content {parent.content} ({type(parent.content)}) not yet supported"
         )
     modifiers = get_upstream_modifiers(
         cparent.concept_arguments, environment=environment

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/parsing/parse_engine.py

@@ -1257,16 +1257,21 @@ class ParseToObjects(Transformer):
             intersection = base.locally_derived.intersection(pre_keys)
             if intersection:
                 for x in intersection:
-                    if (
-                        base.local_concepts[x].derivation
-                        == self.environment.concepts[x].derivation
+                    if str(base.local_concepts[x].lineage) == str(
+                        self.environment.concepts[x].lineage
                     ):
+                        local = base.local_concepts[x]
+                        friendly_name = (
+                            local.name
+                            if local.namespace == DEFAULT_NAMESPACE
+                            else local.namespace
+                        )
                         raise NameShadowError(
-                            f"Select statement {base} derives concept {x} with identical derivation as named concept. Use the named concept directly."
+                            f"Select statement {base} creates a new concept '{friendly_name}' with identical definition as the existing concept '{friendly_name}'. Replace {base.local_concepts[x].lineage} with a direct reference to {friendly_name}."
                         )
                 else:
                     raise NameShadowError(
-                        f"Select statement {base} creates new derived concepts {list(intersection)} with identical name(s) to existing concept(s). If these are identical, reference the concept directly. Otherwise alias your column as a new name."
+                        f"Select statement {base} creates new named concepts from calculations {list(intersection)} with identical name(s) to existing concept(s). Use new unique names for these."
                     )
         return base
 
@@ -1739,9 +1744,27 @@ class ParseToObjects(Transformer):
         return self.function_factory.create_function(args, FunctionType.SUBSTRING, meta)
 
     @v_args(meta=True)
-    def lower(self, meta, args):
+    def flower(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.LOWER, meta)
 
+    @v_args(meta=True)
+    def fregexp_contains(self, meta, args):
+        return self.function_factory.create_function(
+            args, FunctionType.REGEXP_CONTAINS, meta
+        )
+
+    @v_args(meta=True)
+    def fregexp_extract(self, meta, args):
+        return self.function_factory.create_function(
+            args, FunctionType.REGEXP_EXTRACT, meta
+        )
+
+    @v_args(meta=True)
+    def fregexp_replace(self, meta, args):
+        return self.function_factory.create_function(
+            args, FunctionType.REGEXP_REPLACE, meta
+        )
+
     # date functions
     @v_args(meta=True)
     def fdate(self, meta, args):

{pytrilogy-0.0.3.51 → pytrilogy-0.0.3.53}/trilogy/parsing/trilogy.lark

@@ -267,7 +267,7 @@
     _UPPER.1: "upper("i
     upper: _UPPER expr ")"
     _LOWER.1: "lower("i
-    lower: _LOWER expr ")"  
+    flower: _LOWER expr ")"  
     _SPLIT.1: "split("i  
     fsplit: _SPLIT expr "," string_lit ")"
     _STRPOS.1: "strpos("i
@@ -276,8 +276,14 @@
     fcontains: _CONTAINS expr "," expr ")"
     _SUBSTRING.1: "substring("i
     fsubstring: _SUBSTRING expr "," expr "," expr ")"
-    
-    _string_functions: like | ilike | upper | lower | fsplit | fstrpos | fsubstring | fcontains
+    _REGEXP_EXTRACT.1: "regexp_extract("
+    fregexp_extract: _REGEXP_EXTRACT expr "," expr ")"
+    _REGEXP_CONTAINS.1: "regexp_contains("
+    fregexp_contains: _REGEXP_CONTAINS expr "," expr  ")"
+    _REGEXP_REPLACE.1: "regexp_replace("
+    fregexp_replace: _REGEXP_REPLACE expr "," expr "," expr   ")"
+
+    _string_functions: like | ilike | upper | flower | fsplit | fstrpos | fsubstring | fcontains | fregexp_extract | fregexp_contains | fregexp_replace
     
     // special aggregate
     _GROUP.1: "group("i
@@ -311,7 +317,8 @@
     _DATE.1: "date("i
     fdate:  _DATE expr ")"
     fdatetime: "datetime"i "(" expr ")"
-    ftimestamp: "timestamp"i "(" expr ")"
+    _TIMESTAMP.1: "timestamp("i
+    ftimestamp: _TIMESTAMP expr ")"
     
     _SECOND.1: "second("i
     fsecond: _SECOND expr ")"