pytrilogy 0.0.2.29__tar.gz → 0.0.2.31__tar.gz

{pytrilogy-0.0.2.29/pytrilogy.egg-info → pytrilogy-0.0.2.31}/PKG-INFO

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

{pytrilogy-0.0.2.29 → pytrilogy-0.0.2.31/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.2.29 → pytrilogy-0.0.2.31}/tests/test_functions.py

@@ -212,6 +212,27 @@ def test_case_function(test_environment):
         assert test_environment.concepts["test_upper_case"].datatype == DataType.BOOL
 
 
+def test_case_like_function(test_environment):
+    declarations = """
+    property test_like <- CASE WHEN category_name like '%abc%' then True else False END;
+    select
+        category_name,
+        test_like
+    ;"""
+    env, parsed = parse(declarations, environment=test_environment)
+    assert (
+        test_environment.concepts["category_name"]
+        in test_environment.concepts["test_like"].lineage.concept_arguments
+    )
+    select: SelectStatement = parsed[-1]
+    for dialect in TEST_DIALECTS:
+        compiled = dialect.compile_statement(process_query(test_environment, select))
+        assert "CASE" in compiled
+        assert "ELSE" in compiled
+        assert "END" in compiled
+        assert test_environment.concepts["test_like"].datatype == DataType.BOOL
+
+
 def test_split_and_index_function(test_environment):
     declarations = """
     constant test_string <- 'abc_def';

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

{pytrilogy-0.0.2.29 → pytrilogy-0.0.2.31}/trilogy/parsing/parse_engine.py

@@ -162,6 +162,21 @@ def parse_concept_reference(
     return lookup, namespace, name, parent
 
 
+def expr_to_boolean(
+    root,
+) -> Union[Comparison, Conditional, SubselectComparison, Parenthetical]:
+    if not isinstance(root, (Comparison, Conditional, Parenthetical)):
+        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 root
+
+
 def unwrap_transformation(
     input: Union[
         FilterItem,
@@ -1022,15 +1037,7 @@ class ParseToObjects(Transformer):
 
     def where(self, args):
         root = args[0]
-        if not isinstance(root, (Comparison, Conditional, Parenthetical)):
-            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,
-                )
+        root = expr_to_boolean(root)
         return WhereClause(conditional=root)
 
     def having(self, args):
@@ -1838,7 +1845,8 @@ class ParseToObjects(Transformer):
     @v_args(meta=True)
     def fcase_when(self, meta, args) -> CaseWhen:
         args = process_function_args(args, meta=meta, environment=self.environment)
-        return CaseWhen(comparison=args[0], expr=args[1])
+        root = expr_to_boolean(args[0])
+        return CaseWhen(comparison=root, expr=args[1])
 
     @v_args(meta=True)
     def fcase_else(self, meta, args) -> CaseElse:

{pytrilogy-0.0.2.29 → pytrilogy-0.0.2.31}/trilogy/parsing/render.py

@@ -386,13 +386,31 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "Function"):
-        inputs = ",".join(self.to_string(c) for c in arg.arguments)
+        args = [self.to_string(c) for c in arg.arguments]
+
+        if arg.operator == FunctionType.SUBTRACT:
+            return f"{args[0]} - {args[1]}"
+        if arg.operator == FunctionType.ADD:
+            return f"{args[0]} + {args[1]}"
+        if arg.operator == FunctionType.MULTIPLY:
+            return f"{args[0]} * {args[1]}"
+        if arg.operator == FunctionType.DIVIDE:
+            return f"{args[0]} / {args[1]}"
+        if arg.operator == FunctionType.MOD:
+            return f"{args[0]} % {args[1]}"
+
+        inputs = ",".join(args)
+
         if arg.operator == FunctionType.CONSTANT:
             return f"{inputs}"
         if arg.operator == FunctionType.CAST:
             return f"CAST({self.to_string(arg.arguments[0])} AS {self.to_string(arg.arguments[1])})"
         if arg.operator == FunctionType.INDEX_ACCESS:
             return f"{self.to_string(arg.arguments[0])}[{self.to_string(arg.arguments[1])}]"
+
+        if arg.operator == FunctionType.CASE:
+            inputs = "\n".join(args)
+            return f"CASE {inputs}\nEND"
         return f"{arg.operator.value}({inputs})"
 
     @to_string.register