sql-blocks 1.25.19011849__py3-none-any.whl → 1.25.30011511__py3-none-any.whl

sql_blocks/sql_blocks.py

@@ -42,17 +42,23 @@ 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
@@ -423,12 +429,12 @@ 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):
@@ -470,6 +476,34 @@ 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(
@@ -482,7 +516,7 @@ class Where:
         elif not exists:
             name = Field.format(name, main)
         main.values.setdefault(WHERE, []).append('{}{} {}'.format(
-            self.prefix, name, self.expr
+            self.prefix, name, self.content
         ))
 
 
@@ -490,6 +524,7 @@ 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, pos) for pos in Position if pos.value]
 
 
 class Not(Where):
@@ -497,7 +532,7 @@ class Not(Where):
 
     @classmethod
     def eq(cls, value):
-        return Where(expr=f'<> {quoted(value)}')
+        return Where(f'<> {quoted(value)}')
 
 
 class Case:
@@ -538,7 +573,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) + ')'
@@ -637,7 +672,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
@@ -1419,6 +1454,47 @@ class NotSelectIN(SelectIN):
     condition_class = Not
 
 
+class CTE:
+    prefix = ''
+
+    def __init__(self, name: str, query_list: list[Select]):
+        self.name = name
+        for query in query_list:
+            query.break_lines = False
+        self.query_list = query_list
+
+    def format(self, query: Select) -> str:
+        LINE_MAX_SIZE = 50
+        result, line = [], ''
+        for word in str(query).split(' '):
+            if len(line) >= LINE_MAX_SIZE and word in KEYWORD:
+                result.append(line)
+                line = ''
+            line += word + ' '
+        if line:
+            result.append(line)
+        return '\n\t'.join(result)
+
+    def __str__(self) -> str:
+        return 'WITH {prefix}{name} AS (\n\t{queries}\n)SELECT * FROM {name}'.format(
+            prefix=self.prefix, name=self.name, 
+            queries='\nUNION ALL\n\t'.join(
+                self.format(q) for q in self.query_list
+            )
+        )
+
+class Recursive(CTE):
+    prefix = 'RECURSIVE '
+
+    def __str__(self) -> str:
+        if len(self.query_list) > 1:
+            alias = self.name[0].lower()
+            self.query_list[-1].values[FROM].append(f', {self.name} {alias}')
+        return super().__str__()
+
+
+# ----- Rules -----
+
 class RulePutLimit(Rule):
     @classmethod
     def apply(cls, target: Select):
@@ -1533,7 +1609,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) -> Select | list[Select]:
     from collections import Counter
     parser = parser_class(text)
     if not parser:
@@ -1556,24 +1632,3 @@ def detect(text: str, join_queries: bool = True) -> Select:
         result += query
     return result
 
-
-if __name__ == '__main__':
-    # query = Select(
-    #     'Tips t',
-    #     tip=[Field, Lag().over(day=OrderBy).As('last')],
-    #     diff=[
-    #         ExpressionField('Round(tip-last, 2) as {f}'),
-    #         Not.is_null()
-    #     ]
-    # )
-    p, c, a = Select.parse('''
-    Professor(?nome="Júlio Cascalles", id)
-    <- Curso@disciplina(professor, aluno) ->
-    Aluno(id ^count$qtd_alunos)
-    ''', CypherParser)
-    query = p + c + a
-    print(query)
-    print('------------------')
-    query.optimize([RuleReplaceJoinBySubselect])
-    # ==============================================
-    print(query)

{sql_blocks-1.25.19011849.dist-info → sql_blocks-1.25.30011511.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 1.25.19011849
+Version: 1.25.30011511
 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
@@ -115,6 +115,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:
 
@@ -631,3 +641,39 @@ For example, if your query is going to run on Oracle, do the following:
 
 `Function.dialect = Dialect.ORACLE`
 
+---
+
+### 17 - CTE and Recursive classes
+
+* **_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
+```
+
+* **_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
+```

sql_blocks-1.25.30011511.dist-info/RECORD

@@ -0,0 +1,7 @@
+sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
+sql_blocks/sql_blocks.py,sha256=fTEX1TEkjr-uUg_aLVmkwVM5Ul3UQyvsW6Vw7z_TCQQ,54398
+sql_blocks-1.25.30011511.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+sql_blocks-1.25.30011511.dist-info/METADATA,sha256=Hqo-6uZ0zLVyhvw7H9E1Hc7vGT5Ny6Kjxy2nzTqIEn0,16187
+sql_blocks-1.25.30011511.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sql_blocks-1.25.30011511.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
+sql_blocks-1.25.30011511.dist-info/RECORD,,

sql_blocks-1.25.19011849.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=nMIOewFh6X7vC0UNKs4mdqz4F_gpCSvtF0oAkocEGHw,52542
-sql_blocks-1.25.19011849.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-1.25.19011849.dist-info/METADATA,sha256=jp-OY-e66KmW-tXSklUT3l5-01CX0jfCCPJ6iANNpSY,15031
-sql_blocks-1.25.19011849.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-1.25.19011849.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-1.25.19011849.dist-info/RECORD,,