sql-blocks 1.25.1801__py3-none-any.whl → 1.25.1021229__py3-none-any.whl

sql_blocks/sql_blocks.py

@@ -42,23 +42,34 @@ class SQLObject:
         if not table_name:
             return
         cls = SQLObject
+        is_file_name = any([
+            '/' in table_name, '.' in table_name
+        ])
+        ref = table_name
+        if is_file_name:
+            ref = table_name.split('/')[-1].split('.')[0]
         if cls.ALIAS_FUNC:
-            self.__alias = cls.ALIAS_FUNC(table_name)
+            self.__alias = cls.ALIAS_FUNC(ref)
         elif ' ' in table_name.strip():
             table_name, self.__alias = table_name.split()
-        elif '_' in table_name:
+        elif '_' in ref:
             self.__alias = ''.join(
                 word[0].lower()
-                for word in table_name.split('_')
+                for word in ref.split('_')
             )
         else:
-            self.__alias = table_name.lower()[:3]
+            self.__alias = ref.lower()[:3]
         self.values.setdefault(FROM, []).append(f'{table_name} {self.alias}')
 
     @property
     def table_name(self) -> str:
         return self.values[FROM][0].split()[0]
     
+    def set_file_format(self, pattern: str):
+        if '{' not in pattern:
+            pattern = '{}' + pattern
+        self.values[FROM][0] = pattern.format(self.aka())
+
     @property
     def alias(self) -> str:
         if self.__alias:
@@ -335,6 +346,9 @@ class Cast(Function):
     ...
 
 
+FUNCTION_CLASS = {f.__name__.lower(): f for f in Function.__subclasses__()}
+
+
 class ExpressionField:
     def __init__(self, expr: str):
         self.expr = expr
@@ -357,15 +371,20 @@ class ExpressionField:
 class FieldList:
     separator = ','
 
-    def __init__(self, fields: list=[], class_types = [Field]):
+    def __init__(self, fields: list=[], class_types = [Field], ziped: bool=False):
         if isinstance(fields, str):
             fields = [
                 f.strip() for f in fields.split(self.separator)
             ]
         self.fields = fields
         self.class_types = class_types
+        self.ziped = ziped
 
     def add(self, name: str, main: SQLObject):
+        if self.ziped:  # --- One class per field...
+            for field, class_type in zip(self.fields, self.class_types):
+                class_type.add(field, main)
+            return
         for field in self.fields:
             for class_type in self.class_types:
                 class_type.add(field, main)
@@ -420,23 +439,23 @@ class Position(Enum):
 class Where:
     prefix = ''
 
-    def __init__(self, expr: str):
-        self.expr = expr
+    def __init__(self, content: str):
+        self.content = content
 
     @classmethod
     def __constructor(cls, operator: str, value):
-        return cls(expr=f'{operator} {quoted(value)}')
+        return cls(f'{operator} {quoted(value)}')
 
     @classmethod
     def eq(cls, value):
         return cls.__constructor('=', value)
 
     @classmethod
-    def contains(cls, content: str, pos: Position = Position.Middle):
+    def contains(cls, text: str, pos: Position = Position.Middle):
         return cls(
             "LIKE '{}{}{}'".format(
                 '%' if pos != Position.StartsWith else '',
-                content,
+                text,
                 '%' if pos != Position.EndsWith else ''
             )
         )
@@ -467,9 +486,47 @@ class Where:
             values = ','.join(quoted(v) for v in values)
         return cls(f'IN ({values})')
 
+    @classmethod
+    def formula(cls, formula: str):
+        where = cls( ExpressionField(formula) )
+        where.add = where.add_expression
+        return where
+
+    def add_expression(self, name: str, main: SQLObject):
+        self.content = self.content.format(name, main)
+        main.values.setdefault(WHERE, []).append('{} {}'.format(
+            self.prefix, self.content
+        ))
+
+    @classmethod
+    def join(cls, query: SQLObject):
+        where = cls(query)
+        where.add = where.add_join
+        return where
+
+    def add_join(self, name: str, main: SQLObject):
+        query = self.content
+        main.values[FROM].append(f',{query.table_name} {query.alias}')
+        for key in USUAL_KEYS:
+            main.update_values(key, query.values.get(key, []))
+        main.values.setdefault(WHERE, []).append('({a1}.{f1} = {a2}.{f2})'.format(
+            a1=main.alias, f1=name,
+            a2=query.alias, f2=query.key_field
+        ))
+
     def add(self, name: str, main: SQLObject):
+        func_type = FUNCTION_CLASS.get(name.lower())
+        exists = any(
+            main.is_named_field(fld, SELECT)
+            for fld in main.values.get(SELECT, [])
+            if name in fld
+        )
+        if func_type:
+            name = func_type.format('*', main)
+        elif not exists:
+            name = Field.format(name, main)
         main.values.setdefault(WHERE, []).append('{}{} {}'.format(
-            self.prefix, Field.format(name, main), self.expr
+            self.prefix, name, self.content
         ))
 
 
@@ -477,6 +534,10 @@ eq, contains, gt, gte, lt, lte, is_null, inside = (
     getattr(Where, method) for method in 
     ('eq', 'contains', 'gt', 'gte', 'lt', 'lte', 'is_null', 'inside')
 ) 
+startswith, endswith = [
+    lambda x: contains(x, Position.StartsWith),
+    lambda x: contains(x, Position.EndsWith)
+]
 
 
 class Not(Where):
@@ -484,7 +545,7 @@ class Not(Where):
 
     @classmethod
     def eq(cls, value):
-        return Where(expr=f'<> {quoted(value)}')
+        return Where(f'<> {quoted(value)}')
 
 
 class Case:
@@ -525,7 +586,7 @@ class Options:
         child: Where
         for field, child in self.__children.items():
             conditions.append(' {} {} '.format(
-                Field.format(field, main), child.expr
+                Field.format(field, main), child.content
             ))
         main.values.setdefault(WHERE, []).append(
             '(' + logical_separator.join(conditions) + ')'
@@ -549,12 +610,11 @@ class Clause:
     def format(cls, name: str, main: SQLObject) -> str:
         def is_function() -> bool:
             diff = main.diff(SELECT, [name.lower()], True)
-            FUNCTION_CLASS = {f.__name__.lower(): f for f in Function.__subclasses__()}
             return diff.intersection(FUNCTION_CLASS)
         found = re.findall(r'^_\d', name)
         if found:
             name = found[0].replace('_', '')
-        elif main.alias and not is_function():
+        elif '.' not in name and main.alias and not is_function():
             name = f'{main.alias}.{name}'
         return name
 
@@ -625,7 +685,7 @@ class Having:
 
     def add(self, name: str, main:SQLObject):
         main.values[GROUP_BY][-1] += ' HAVING {} {}'.format(
-            self.function.format(name, main), self.condition.expr
+            self.function.format(name, main), self.condition.content
         )
     
     @classmethod
@@ -996,8 +1056,11 @@ class SQLParser(Parser):
                     if not key in values:
                         continue
                     separator = self.class_type.get_separator(key)
+                    cls = {
+                        ORDER_BY: OrderBy, GROUP_BY: GroupBy
+                    }.get(key, Field)
                     obj.values[key] = [
-                        Field.format(fld, obj)
+                        cls.format(fld, obj)
                         for fld in re.split(separator, values[key])
                         if (fld != '*' and len(tables) == 1) or obj.match(fld, key)
                     ]
@@ -1059,7 +1122,11 @@ class CypherParser(Parser):
         if token in self.TOKEN_METHODS:
             return
         class_list = [Field]
-        if '$' in token:
+        if '*' in token:
+            token = token.replace('*', '')
+            self.queries[-1].key_field = token
+            return
+        elif '$' in token:
             func_name, token = token.split('$')
             if func_name == 'count':
                 if not token:
@@ -1068,7 +1135,6 @@ class CypherParser(Parser):
                 Count().As(token, extra_classes).add(pk_field, self.queries[-1])
                 return
             else:
-                FUNCTION_CLASS = {f.__name__.lower(): f for f in Function.__subclasses__()}
                 class_list = [ FUNCTION_CLASS[func_name] ]
         class_list += extra_classes
         FieldList(token, class_list).add('', self.queries[-1])
@@ -1084,10 +1150,13 @@ class CypherParser(Parser):
     def add_foreign_key(self, token: str, pk_field: str=''):
         curr, last = [self.queries[i] for i in (-1, -2)]
         if not pk_field:
-            if not last.values.get(SELECT):
-                raise IndexError(f'Primary Key not found for {last.table_name}.')
-            pk_field = last.values[SELECT][-1].split('.')[-1]
-            last.delete(pk_field, [SELECT], exact=True)
+            if last.key_field:
+                pk_field = last.key_field
+            else:
+                if not last.values.get(SELECT):
+                    raise IndexError(f'Primary Key not found for {last.table_name}.')
+                pk_field = last.values[SELECT][-1].split('.')[-1]
+                last.delete(pk_field, [SELECT], exact=True)
         if '{}' in token:
             foreign_fld = token.format(
                 last.table_name.lower()
@@ -1405,6 +1474,88 @@ class NotSelectIN(SelectIN):
     condition_class = Not
 
 
+class CTE(Select):
+    prefix = ''
+
+    def __init__(self, table_name: str, query_list: list[Select]):
+        super().__init__(table_name)
+        for query in query_list:
+            query.break_lines = False
+        self.query_list = query_list
+        self.break_lines = False
+
+    def __str__(self) -> str:
+        # ---------------------------------------------------------
+        def justify(query: Select) -> str:
+            result, line = [], ''
+            keywords = '|'.join(KEYWORD)
+            for word in re.split(fr'({keywords}|AND|OR|,)', str(query)):
+                if len(line) >= 65:
+                    result.append(line)
+                    line = ''
+                line += word
+            if line:
+                result.append(line)
+            return '\n    '.join(result)
+        # ---------------------------------------------------------
+        return 'WITH {}{} AS (\n    {}\n){}'.format(
+            self.prefix, self.table_name, 
+            '\nUNION ALL\n    '.join(
+                justify(q) for q in self.query_list
+            ), super().__str__()
+        )
+
+class Recursive(CTE):
+    prefix = 'RECURSIVE '
+
+    def __str__(self) -> str:
+        if len(self.query_list) > 1:
+            self.query_list[-1].values[FROM].append(
+                f', {self.table_name} {self.alias}')
+        return super().__str__()
+
+    @classmethod
+    def create(cls, name: str, pattern: str, formula: str, init_value, format: str=''):
+        SQLObject.ALIAS_FUNC = None
+        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
+        )
+        pk_field = get_field(t1, 0)
+        foreign_key = ''
+        for num in re.findall(r'\[(\d+)\]', formula):
+            num = int(num)
+            if not foreign_key:
+                foreign_key = get_field(t2, num-1)
+                formula = formula.replace(f'[{num}]', '%')
+            else:
+                formula = formula.replace(f'[{num}]', get_field(t2, num-1))
+        Where.eq(init_value).add(pk_field, t1)
+        Where.formula(formula).add(foreign_key or pk_field, t2)
+        return cls(name, [t1, t2])
+
+    def join(self, pattern: str, fields: list | str, format: str):
+        if isinstance(fields, str):
+            count = len( fields.split(',') )
+        else:
+            count = len(fields)
+        queries = detect(
+            pattern*count, join_queries=False, format=format
+        )
+        FieldList(fields, queries, ziped=True).add('', self)
+        self.break_lines = True
+
+    def counter(self, name: str, start, increment: str='+1'):
+        for i, query in enumerate(self.query_list):
+            if i == 0:
+                Field.add(f'{start} AS {name}', query)
+            else:
+                Field.add(f'({name}{increment}) AS {name}', query)
+
+
+# ----- Rules -----
+
 class RulePutLimit(Rule):
     @classmethod
     def apply(cls, target: Select):
@@ -1519,7 +1670,7 @@ def parser_class(text: str) -> Parser:
     return None
 
 
-def detect(text: str, join_queries: bool = True) -> Select:
+def detect(text: str, join_queries: bool = True, format: str='') -> Select | list[Select]:
     from collections import Counter
     parser = parser_class(text)
     if not parser:
@@ -1530,11 +1681,14 @@ def detect(text: str, join_queries: bool = True) -> Select:
                 continue
             pos = [ f.span() for f in re.finditer(fr'({table})[(]', text) ]
             for begin, end in pos[::-1]:
-                new_name = f'{table}_{count}'  # See set_table (line 45)
+                new_name = f'{table}_{count}'  # See set_table (line 55)
                 Select.EQUIVALENT_NAMES[new_name] = table
                 text = text[:begin] + new_name + '(' + text[end:]
                 count -= 1
     query_list = Select.parse(text, parser)
+    if format:
+        for query in query_list:
+            query.set_file_format(format)
     if not join_queries:
         return query_list
     result = query_list[0]
@@ -1543,15 +1697,3 @@ def detect(text: str, join_queries: bool = True) -> Select:
     return result
 
 
-if __name__ == '__main__':
-    for dialect in Dialect:
-        Function.dialect = dialect
-        print(f'--------------{dialect.name}--------------')
-        query = Select(
-            'Installments',
-            _=DateDiff(
-                Current_Date(),
-                'due_date'
-            ).As('elapsed_time')
-        ).limit(10)
-        print(query)

{sql_blocks-1.25.1801.dist-info → sql_blocks-1.25.1021229.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 1.25.1801
+Version: 1.25.1021229
 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
@@ -98,10 +98,7 @@ query = Select('Movie m', title=Field,
         awards=contains("Oscar")
     )
     AND=Options(
-        ..., name=contains(
-            'Chris',
-            Position.StartsWith
-        )
+        ..., name=startswith('Chris')
     )
 ```
 
@@ -115,6 +112,16 @@ based_on_book=Not.is_null()
 hash_tag=inside(['space', 'monster', 'gore'])
 ```
 
+3.6 -- Combining ExpressionField with Where condition:
+* The **formula** method allows you to write an expression as a condition:
+```
+query=Select(
+    'Folks f2',
+    id=Where.formula('({af} = a.father OR {af} = a.mother)')
+)
+```
+> Results: `WHERE...f2.id = a.father OR f2.id = a.mother`
+
 ---
 ### 4 - A field can be two things at the same time:
 
@@ -143,6 +150,35 @@ FROM
     JOIN Cast c ON (a.cast = c.id)    
 ```
 
+---
+**5.1  Multiple tables without JOIN**
+> Warning: This is **NOT** recommended!  ⛔
+
+
+#### Example:
+    singer = Select(
+        "Singer artist", id=PrimaryKey,
+        name=NamedField('artist_name')
+    )
+    album = Select (
+        "Album album",
+        name=NamedField('album_name'),
+        artist_id=Where.join(singer), #  <===== 👀
+    )
+**>> print(query)**    
+
+    SELECT
+            album.name as album_name,
+            artist.name as artist_name,
+            album.year_recorded
+    FROM
+            Album album
+            ,Singer artist
+    WHERE
+            (album.artist_id = artist.id)
+
+
+
 ---
 ### 6 - The reverse process (parse):
 ```
@@ -373,7 +409,7 @@ m2 = Select(
     query = Select(
         'Installments i', due_date=Field,  customer=Select(
             'Customer c', id=PrimaryKey,
-            name=contains('Smith', Position.EndsWith)
+            name=endswith('Smith')
         )
     )
     print(query)
@@ -453,6 +489,7 @@ ORDER BY
 * `^` Put the field in the ORDER BY clause
 * `@` Immediately after the table name, it indicates the grouping field.
 * `$` For SQL functions like **avg**$_field_, **sum**$_field_, **count**$_field_...
+* `*` Sets the primary key field.
 
 
 ---
@@ -631,3 +668,121 @@ For example, if your query is going to run on Oracle, do the following:
 
 `Function.dialect = Dialect.ORACLE`
 
+---
+
+### 17 - CTE and Recursive classes
+
+* **17.1 - _CTE class_**
+```
+    query = Select(
+        'SocialMedia s', post=Count, reaction=Sum, user=GroupBy
+    )
+    print( CTE('Metrics', [query]) )
+```
+The result is...
+```
+    WITH Metrics AS (
+            SELECT Count(s.post), Sum(s.reaction) FROM SocialMedia s GROUP BY user
+    )SELECT * FROM Metrics
+```
+
+* **17.2 - _Recursive class_**
+```
+q1 = Select(
+    'SocialMedia me', name=[ eq(MY_NAME), Field ]
+)
+q2 = Select(
+    'SocialMedia you' name=Field, id=Where.formula('{af} = n.friend')
+)
+print( Recursive('Network', [q1, q2]) )
+```
+The result is...
+```
+WITH RECURSIVE Network AS (
+        SELECT me.name FROM SocialMedia me WHERE 
+        me.name = 'Júlio Cascalles'
+UNION ALL
+        SELECT you.name FROM SocialMedia you , Network n
+        WHERE  you.id = n.friend
+)SELECT * FROM Network
+```
+
+* **17.2.1 - The `create` method** ... parameters :
+    - name: The name of the CTE
+    - pattern: A cypher script that defines the tables used
+    - formula: The format for `Where.formula` method _(*)_
+    - init_value: The value for the condition in the first table
+    - format (optional): If tables are files or internet hiperlinks, you may especify the extension and/or folder...
+> Example: 
+```
+    R = Recursive.create(
+        'Route R', 'Flyght(departure, arrival)',
+        '[2] = R.[1]',  'JFK',  format='.csv'
+    ) #                  ^^^--- Flyghts from JFK airport
+```
+_...Creates a recursive CTE called Route, using Flyght table, where the recursivity condition is Flyght.arrival equals to Route.departure_
+>> (*) -- Note that [1] and [2] refers to first field and second field. 😉
+
+Result:
+
+    WITH RECURSIVE Route AS (
+            SELECT f1.departure, f1.arrival
+            FROM Flyght.csv f1
+            WHERE f1.departure = 'JFK'
+    UNION ALL
+            SELECT f2.departure, f2.arrival
+            FROM Flyght.csv f2
+            , Route R
+            WHERE  f2.arrival = R.departure
+    )SELECT * FROM Route R
+
+**17.2.2 - The `join` method** 
+
+In the previous example, if you add this code...
+`R.join('Airport(*id,name)', 'departure, arrival', format='.csv')`
+
+...The result would be:
+
+    WITH RECURSIVE Route AS (
+        SELECT f1.departure, f1.arrival
+        FROM Flyght.csv f1
+        WHERE f1.departure = 'JFK'
+    UNION ALL
+        SELECT f2.departure, f2.arrival
+        FROM Flyght.csv f2
+        , Route R
+        WHERE  f2.arrival = R.departure
+    )SELECT
+        a1.name, a2.name
+    FROM
+        Route R
+        JOIN Airport.csv a2 ON (R.arrival = a2.id)
+        JOIN Airport.csv a1 ON (R.departure = a1.id)
+
+
+**17.2.3 - The `counter` method** 
+Adds an increment field in queries inside CTE:
+> Examples:
+* `R.counter('stops', 0)` # -- counter starts with 0 and increment +1
+* `R2.counter('generation', 5, '- 1')` # -- for the code below...
+```
+R2 = Recursive.create(
+    'Ancestors a', 'People(id,name,father,mother,birth)',
+    '(% = a.father OR % = a.mother)', 32630, '.parquet'
+)
+```
+...Results:
+
+    WITH RECURSIVE Ancestors AS (
+        SELECT p1.id, p1.name, p1.father, p1.mother, p1.birth,
+        5 AS generation  /* <<---- Most current generation ------------*/
+        FROM People.parquet p1 WHERE p1.id = 32630
+    UNION ALL
+        SELECT p2.id, p2.name, p2.father, p2.mother, p2.birth,
+        (generation- 1) AS generation /* <<-- Previous generation -----*/
+        FROM People.parquet p2 , Ancestors a WHERE  (p2.id = a.father OR p2.id = a.mother)
+    )SELECT * FROM Ancestors a
+
+
+>> Note: Comments added later.
+---

sql_blocks-1.25.1021229.dist-info/RECORD

@@ -0,0 +1,7 @@
+sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
+sql_blocks/sql_blocks.py,sha256=VW8n2nWu7RREnns8dmYruhlvzGBCA3EeuBKiXCjClmE,56975
+sql_blocks-1.25.1021229.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+sql_blocks-1.25.1021229.dist-info/METADATA,sha256=XXScfi4okZQLPPHvVvi2bd6YsvQQLb5ry2_mmOLThU4,19573
+sql_blocks-1.25.1021229.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sql_blocks-1.25.1021229.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
+sql_blocks-1.25.1021229.dist-info/RECORD,,

sql_blocks-1.25.1801.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=iFS3drlQaazFkbBBFIH58RPZt4Lhe6R2Xqi_Ujef7Bg,51893
-sql_blocks-1.25.1801.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-1.25.1801.dist-info/METADATA,sha256=WnwFnhle4YXNyeC6dBVAnQmUqJiboT1CDhbvRHOmEQY,15027
-sql_blocks-1.25.1801.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-1.25.1801.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-1.25.1801.dist-info/RECORD,,