sql-blocks 1.20250710__tar.gz → 1.20250712__tar.gz

{sql_blocks-1.20250710/sql_blocks.egg-info → sql_blocks-1.20250712}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 1.20250710
+Version: 1.20250712
 Summary: Allows you to create objects for parts of SQL query commands. Also to combine these objects by joining them, adding or removing parts...
 Home-page: https://github.com/julio-cascalles/sql_blocks
 Author: Júlio Cascalles
@@ -948,7 +948,7 @@ R2 = Recursive.create(
 >> Note: Comments added later.
 ---
 
-### CTEFactory class
+### 17.3 - CTEFactory class
 CTEFactory exchanges subqueries for CTEs, simply by passing the text of the "dirty" query:
 
 *Example*:
@@ -992,4 +992,27 @@ results...
     ORDER BY
             u001.name
 ```
+
+#### 17.3.1 - You can also pass a Cypher script like in the example below:
+
+![image](assets/CTEFactory.png)
+
+results...
+```
+WITH Annual_Sales_per_Vendor AS (
+    SELECT ven.name as vendors_name, Year(sal.ref_date) as ref_year
+    , Sum(sal.quantity) as qty_sold FROM Vendor ven LEFT JOIN Sales sal ON (ven.id = sal.vendor)
+    GROUP BY ven.name, ref_year
+)
+SELECT
+        aspv.ref_year,
+        aspv.qty_sold,
+        aspv.vendors_name,
+        goa.target
+FROM
+        Annual_Sales_per_Vendor aspv
+        RIGHT JOIN Goal goa ON (aspv.ref_year = goa.year)
+```
+
+
 ---

{sql_blocks-1.20250710 → sql_blocks-1.20250712}/README.md

@@ -933,7 +933,7 @@ R2 = Recursive.create(
 >> Note: Comments added later.
 ---
 
-### CTEFactory class
+### 17.3 - CTEFactory class
 CTEFactory exchanges subqueries for CTEs, simply by passing the text of the "dirty" query:
 
 *Example*:
@@ -977,4 +977,27 @@ results...
     ORDER BY
             u001.name
 ```
----
+
+#### 17.3.1 - You can also pass a Cypher script like in the example below:
+
+![image](assets/CTEFactory.png)
+
+results...
+```
+WITH Annual_Sales_per_Vendor AS (
+    SELECT ven.name as vendors_name, Year(sal.ref_date) as ref_year
+    , Sum(sal.quantity) as qty_sold FROM Vendor ven LEFT JOIN Sales sal ON (ven.id = sal.vendor)
+    GROUP BY ven.name, ref_year
+)
+SELECT
+        aspv.ref_year,
+        aspv.qty_sold,
+        aspv.vendors_name,
+        goa.target
+FROM
+        Annual_Sales_per_Vendor aspv
+        RIGHT JOIN Goal goa ON (aspv.ref_year = goa.year)
+```
+
+
+---

{sql_blocks-1.20250710 → sql_blocks-1.20250712}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sql_blocks"
-version = "1.20250710"
+version = "1.20250712"
 authors = [
   { name="Julio Cascalles", email="julio.cascalles@outlook.com" },
 ]

{sql_blocks-1.20250710 → sql_blocks-1.20250712}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup
 
 setup(
     name = 'sql_blocks',
-    version = '1.20250710',
+    version = '1.20250712',
     author = 'Júlio Cascalles',
     author_email = 'julio.cascalles@outlook.com',
     packages = ['sql_blocks'],

{sql_blocks-1.20250710 → sql_blocks-1.20250712}/sql_blocks/sql_blocks.py

@@ -221,11 +221,12 @@ class Code:
     def As(self, field_alias: str, modifiers=None):
         if modifiers:
             self.extra[field_alias] = TO_LIST(modifiers)
-        self.field_class = NamedField(field_alias)
+        if field_alias:
+            self.field_class = NamedField(field_alias)
         return self
     
     def format(self, name: str, main: SQLObject) -> str:
-        raise NotImplementedError('Use child classes instead of this one')
+        return Field.format(name, main)
 
     def __add(self, name: str, main: SQLObject):
         name = self.format(name, main)
@@ -335,6 +336,10 @@ class Round(Function):
     inputs = [FLOAT]
     output = FLOAT
 
+class Trunc(Function):
+    inputs = [FLOAT]
+    output = FLOAT
+
 # --- Date Functions: ------------------------------------
 class DateDiff(Function):
     inputs = [DATE]
@@ -1674,38 +1679,58 @@ class CypherParser(Parser):
         Where(' '.join(condition)).add(field, query)
     
     def add_order(self, token: str):
-        self.add_field(token, [OrderBy])
+        self.add_field(token, sorted=True)
 
-    def add_field(self, token: str, extra_classes: list['type']=[]):
+    def add_field(self, token: str, sorted: bool = False):
         if token in self.TOKEN_METHODS:
             return
-        class_list = [Field]
         if '*' in token:
-            token = token.replace('*', '')
-            self.queries[-1].key_field = token
+            pk_field = token.replace('*', '')
+            if not pk_field.isidentifier():
+                pos = int(pk_field or '1')-1
+                pk_field = self.queries[-1].values[SELECT][pos]
+            self.queries[-1].key_field = pk_field.split('.')[-1]
             return
-        elif '$' in token:
-            func_name, token = token.split('$')
-            if func_name == 'count':
-                if not token:
-                    token = 'count_1'
-                pk_field = self.queries[-1].key_field or 'id'
-                Count().As(token, extra_classes).add(pk_field, self.queries[-1])
-                return
-            else:
-                class_type = FUNCTION_CLASS.get(func_name)
+        # -------------------------------------------------------
+        def field_params() -> dict:
+            ROLE_OF_SEPARATOR = {
+                '$': 'function',
+                ':': 'alias',
+                '@': 'group',
+                '!': 'field',
+            }
+            REGEX_FIELD = r'([{}])'.format(''.join(ROLE_OF_SEPARATOR))
+            elements = re.split(REGEX_FIELD, token+'!')
+            return {
+                ROLE_OF_SEPARATOR[k]: v 
+                for k, v in zip(elements[1::2], elements[::2])
+            }
+        def run(function: str='', alias: str='', group: str='', field: str=''):
+            is_count = function == 'count'
+            if alias or is_count:
+                field, alias = alias, field
+            extra_classes = [OrderBy] if sorted else []
+            if group:
+                if not field:
+                    field = group
+                elif not alias:
+                    alias = group
+                extra_classes += [GroupBy]
+            if function:                
+                if is_count and not field:
+                    field = self.queries[-1].key_field or 'id'
+                class_type = FUNCTION_CLASS.get(function)
                 if not class_type:
-                    raise ValueError(f'Unknown function `{func_name}`.')
-                if ':' in token:
-                    token, field_alias = token.split(':')
-                    if extra_classes == [OrderBy]:
-                        class_type = class_type().As(field_alias, OrderBy)
-                        extra_classes = []
-                    else:
-                        class_type = class_type().As(field_alias)
-                class_list = [class_type]
-        class_list += extra_classes
-        FieldList(token, class_list).add('', self.queries[-1])
+                    raise ValueError(f'Unknown function `{function}`.')
+                class_list = [ class_type().As(alias, extra_classes) ]
+            elif alias:
+                class_list = [NamedField(alias)] + extra_classes
+            else:
+                class_list = [Field] + extra_classes
+            FieldList(field, class_list).add('', self.queries[-1])
+        # -------------------------------------------------------
+        run( **field_params() )
+        # -------------------------------------------------------
 
     def left_ftable(self, token: str):
         if self.queries:
@@ -2117,7 +2142,7 @@ class CTE(Select):
         else:
             count = len(fields)
         queries = detect(
-            pattern*count, join_queries=False, format=format
+            pattern*count, join_method=None, format=format
         )
         FieldList(fields, queries, ziped=True).add('', self)
         self.break_lines = True
@@ -2138,7 +2163,7 @@ class Recursive(CTE):
         def get_field(obj: SQLObject, pos: int) -> str:
             return obj.values[SELECT][pos].split('.')[-1]
         t1, t2 = detect(
-            pattern*2, join_queries=False, format=format
+            pattern*2, join_method=None, format=format
         )
         pk_field = get_field(t1, 0)
         foreign_key = ''
@@ -2167,12 +2192,31 @@ MAIN_TAG = '__main__'
 class CTEFactory:
     def __init__(self, txt: str):
         """
-        Syntax:
+        SQL syntax:
         ---
-        **SELECT ...
+        **SELECT field, field
         FROM** ( `sub_query1` ) **AS** `alias_1`
         JOIN ( `sub_query2` ) **AS** `alias_2` **ON** `__join__`
+        
+        Cypher syntax:
+        ---
+        Table1(field, `function$`field`:alias`, `group@`) <- Table2(field)
+        `...`MainTable(field)
         """
+        self.main = None
+        if parser_class(txt) == CypherParser:
+            if '...' in txt:
+                txt, other = txt.split('...')
+                self.main = detect(other)
+                alias = self.main.table_name
+            query_list = Select.parse(txt, CypherParser)
+            if not self.main:
+                alias = '_'.join(query.table_name for query in query_list)
+                self.main = Select(alias)
+                self.main.break_lines = False
+            query = join_queries(query_list)
+            self.cte_list = [CTE(alias, [query])]
+            return 
         summary = self.extract_subqueries(txt)
         self.main = detect( summary.pop(MAIN_TAG) )
         self.cte_list = [
@@ -2351,8 +2395,13 @@ def parser_class(text: str) -> Parser:
             return class_type
     return None
 
+def join_queries(query_list: list) -> Select:
+    result = query_list[0]
+    for query in query_list[1:]:
+        result += query
+    return result
 
-def detect(text: str, join_queries: bool = True, format: str='') -> Select | list[Select]:
+def detect(text: str, join_method = join_queries, format: str='') -> Select | list[Select]:
     from collections import Counter
     parser = parser_class(text)
     if not parser:
@@ -2367,34 +2416,29 @@ def detect(text: str, join_queries: bool = True, format: str='') -> Select | lis
                 Select.EQUIVALENT_NAMES[new_name] = table
                 text = text[:begin] + new_name + '(' + text[end:]
                 count -= 1
-    query_list = Select.parse(text, parser)
+    result = Select.parse(text, parser)
     if format:
-        for query in query_list:
+        for query in result:
             query.set_file_format(format)
-    if not join_queries:
-        return query_list
-    result = query_list[0]
-    for query in query_list[1:]:
-        result += query
+    if join_method:
+        result = join_method(result)
     return result
 # ===========================================================================================//
 
 if __name__ == "__main__":
-    query = Select(
-        'Sales s', #quantity=Sum().As('qty_sold'),
-        ref_date=GroupBy(
-            ref_year=Year, qty_sold=Sum('quantity'),
-            vendor=Select(
-                'Vendor v', id=[PrimaryKey, NamedField('vendor_id')], name=Field
-            ),
-            prod_id=Field
-        )
-    )
-    cte = CTE('Sales_by_year', [query])(
-        _=Where.join(
-            Select('Goal G'), dict(
-                prod_id='product', ref_year='year', vendor_id='vendor'
-            )
-        )
+    cte = CTEFactory(
+        "Sales(year$ref_date:ref_year@, sum$quantity:qty_sold, vendor) <- Vendor(id, name:vendors_name@)"
+        # ^^^   ^^^           ^^^
+        #  |     |             |                                       ^^^            ^^^
+        #  |     |             |                                        |              |
+        #  |     |             |         Relate Sales to Vendor --------+              |
+        #  |     |             |                                                       |
+        #  |     |             +---- Call it `ref_year` and group it                   |
+        #  |     |                                                                     |
+        #  |     +-- Extracts the year from the `ref_date` field                       |
+        #  |                                                                           |
+        #  +--- The Sales table                                                        |
+        #                               Also groups by vendor´s name ------------------+ 
+        "...Annual_Sales_per_Vendor(ref_year, qty_sold, vendors_name, *) -> Goal(year, target)"
     )
-    print(cte)
+    print(cte)

{sql_blocks-1.20250710 → sql_blocks-1.20250712/sql_blocks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 1.20250710
+Version: 1.20250712
 Summary: Allows you to create objects for parts of SQL query commands. Also to combine these objects by joining them, adding or removing parts...
 Home-page: https://github.com/julio-cascalles/sql_blocks
 Author: Júlio Cascalles
@@ -948,7 +948,7 @@ R2 = Recursive.create(
 >> Note: Comments added later.
 ---
 
-### CTEFactory class
+### 17.3 - CTEFactory class
 CTEFactory exchanges subqueries for CTEs, simply by passing the text of the "dirty" query:
 
 *Example*:
@@ -992,4 +992,27 @@ results...
     ORDER BY
             u001.name
 ```
+
+#### 17.3.1 - You can also pass a Cypher script like in the example below:
+
+![image](assets/CTEFactory.png)
+
+results...
+```
+WITH Annual_Sales_per_Vendor AS (
+    SELECT ven.name as vendors_name, Year(sal.ref_date) as ref_year
+    , Sum(sal.quantity) as qty_sold FROM Vendor ven LEFT JOIN Sales sal ON (ven.id = sal.vendor)
+    GROUP BY ven.name, ref_year
+)
+SELECT
+        aspv.ref_year,
+        aspv.qty_sold,
+        aspv.vendors_name,
+        goa.target
+FROM
+        Annual_Sales_per_Vendor aspv
+        RIGHT JOIN Goal goa ON (aspv.ref_year = goa.year)
+```
+
+
 ---