sql-blocks 0.31.89__py3-none-any.whl → 1.25__py3-none-any.whl

sql_blocks/sql_blocks.py

@@ -22,6 +22,7 @@ KEYWORD = {
 
 SELECT, FROM, WHERE, GROUP_BY, ORDER_BY, LIMIT = KEYWORD.keys()
 USUAL_KEYS = [SELECT, WHERE, GROUP_BY, ORDER_BY, LIMIT]
+TO_LIST = lambda x: x if isinstance(x, list) else [x]
 
 
 class SQLObject:
@@ -110,9 +111,6 @@ class SQLObject:
             self.values[key] = result
 
 
-class Function:
-    ...
-
 class Field:
     prefix = ''
 
@@ -134,17 +132,6 @@ class Field:
         )
 
 
-class Avg(Function, Field):
-    ...
-class Min(Function, Field):
-    ...
-class Max(Function, Field):
-    ...
-class Sum(Function, Field):
-    ...
-class Count(Function, Field):
-    ...
-
 class Distinct(Field):
     prefix = 'DISTINCT '
 
@@ -163,6 +150,107 @@ class NamedField:
         )
 
 
+class Function:
+    instance: dict = {}
+
+    def __init__(self, *params: list):
+        func_name = self.__class__.__name__
+        Function.instance[func_name] = self
+        self.params = [str(p) for p in params]
+        self.class_type = Field
+        self.pattern = '{}({})'
+        self.extra = {}
+    
+    def As(self, field_alias: str, modifiers=None):
+        if modifiers:
+            for mod in TO_LIST(modifiers):
+                self.extra[field_alias] = mod
+        self.class_type = NamedField(field_alias)
+        return self
+
+    @classmethod
+    def format(cls, name: str, main: SQLObject) -> str:
+        obj = cls.get_instance()
+        params = [
+            Field.format(name, main)
+        ] + obj.params
+        return obj.pattern.format(
+            cls.__name__,
+            ', '.join(params)
+        )
+
+    def __add(self, name: str, main: SQLObject):
+        name = self.format(name, main)
+        self.class_type.add(name, main)
+        if self.extra:
+            main.__call__(**self.extra)
+
+    @classmethod
+    def get_instance(cls):
+        obj = Function.instance.get(cls.__name__)
+        if not obj:
+            obj = cls()
+        return obj
+
+    @classmethod
+    def add(cls, name: str, main: SQLObject):
+        cls.get_instance().__add(name, main)
+
+
+# ---- String Functions: ---------------------------------
+class SubString(Function):
+    ...
+
+# ---- Numeric Functions: --------------------------------
+class Round(Function):
+    ...
+
+# --- Date Functions: ------------------------------------
+class DateDiff(Function):
+    ...
+class Extract(Function):
+    ...
+class DatePart(Function):
+    ...
+class Current_Date(Function):
+    ...
+
+class Aggregate:
+    break_lines: bool = True
+
+    def over(self, **args):
+        keywords = ' '.join(
+            '{}{} BY {}'.format(
+                '\n\t\t' if self.break_lines else '',
+                key.upper(), args[key]
+            ) for key in ('partition', 'order')
+            if key in args
+        )
+        if keywords and self.break_lines:
+            keywords += '\n\t'
+        self.pattern = '{}({})' + f' OVER({keywords})'
+        return self
+
+
+# ---- Aggregate Functions: -------------------------------
+class Avg(Aggregate, Function):
+    ...
+class Min(Aggregate, Function):
+    ...
+class Max(Aggregate, Function):
+    ...
+class Sum(Aggregate, Function):
+    ...
+class Count(Aggregate, Function):
+    ...
+
+# ---- Conversions and other Functions: ---------------------
+class Coalesce(Function):
+    ...
+class Cast(Function):
+    ...
+
+
 class ExpressionField:
     def __init__(self, expr: str):
         self.expr = expr
@@ -361,14 +449,9 @@ class Between:
         Where.lte(self.end).add(name, main)
 
 
-class SortType(Enum):
-    ASC = ''
-    DESC = ' DESC'
-
-class OrderBy:
-    sort: SortType = SortType.ASC
+class Clause:
     @classmethod
-    def add(cls, name: str, main: SQLObject):
+    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__()}
@@ -378,13 +461,28 @@ class OrderBy:
             name = found[0].replace('_', '')
         elif main.alias and not is_function():
             name = f'{main.alias}.{name}'
+        return name
+
+
+class SortType(Enum):
+    ASC = ''
+    DESC = ' DESC'
+
+
+class OrderBy(Clause):
+    sort: SortType = SortType.ASC
+
+    @classmethod
+    def add(cls, name: str, main: SQLObject):
+        name = cls.format(name, main)
         main.values.setdefault(ORDER_BY, []).append(name+cls.sort.value)
 
 
-class GroupBy:
-    @staticmethod
-    def add(name: str, main: SQLObject):
-        main.values.setdefault(GROUP_BY, []).append(f'{main.alias}.{name}')
+class GroupBy(Clause):
+    @classmethod
+    def add(cls, name: str, main: SQLObject):
+        name = cls.format(name, main)
+        main.values.setdefault(GROUP_BY, []).append(name)
 
 
 class Having:
@@ -1095,9 +1193,8 @@ class Select(SQLObject):
         return self.translate_to(QueryLanguage)
    
     def __call__(self, **values):
-        to_list = lambda x: x if isinstance(x, list) else [x]
         for name, params in values.items():
-            for obj in to_list(params):
+            for obj in TO_LIST(params):
                 obj.add(name, self)
         return self
 
@@ -1260,22 +1357,3 @@ def detect(text: str) -> Select:
     for query in query_list[1:]:
         result += query
     return result
-
-
-if __name__ == "__main__":
-    print('░▒▓▒░'*20)
-    p, c, a = Select.parse(
-        '''
-            Professor(?nome="Júlio Cascalles", id)
-            <- Curso@disciplina(professor, aluno) ->
-            Aluno(id ^count$qtd_alunos)
-        ''', CypherParser
-    )
-    print(p)
-    print('-'*50)
-    print(c)
-    print('-'*50)
-    print(a)
-    print('='*50)
-    print(a + c + p)
-    print('░▒▓▒░'*20)

{sql_blocks-0.31.89.dist-info → sql_blocks-1.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.31.89
+Version: 1.25
 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
@@ -427,7 +427,7 @@ ORDER BY
 It is useful to write a query in a few lines, without specifying the script type (cypher, mongoDB, SQL, Neo4J...)
 ### Examples:
 
-> **1 - Relationship**
+> **13.1 - Relationship**
 ```
 query = detect(
     'MATCH(c:Customer)<-[:Order]->(p:Product)RETURN c, p'
@@ -439,7 +439,7 @@ print(query)
         Order ord
         LEFT JOIN Customer cus ON (ord.customer_id = cus.id)
         RIGHT JOIN Product pro ON (ord.product_id = pro.id)
-> **2 - Grouping**
+> **13.2 - Grouping**
 ```
 query = detect(
     'People@gender(avg$age?region="SOUTH"^count$qtde)'
@@ -460,7 +460,7 @@ print(query)
     ORDER BY
             peo.qtde
 
-> **3 - Many conditions...**
+> **13.3 - Many conditions...**
 ```
     print( detect('''
         db.people.find({
@@ -491,7 +491,7 @@ print(query)
     ORDER BY
             peo.user_id DESC
 
-> **4 - Relations with same table twice (or more)**
+> **13.4 - Relations with same table twice (or more)**
 
 Automatically assigns aliases to each side of the relationship (In this example, one user invites another to add to their contact list)
 ```
@@ -516,3 +516,54 @@ It consists of the inverse process of parsing: From a Select object, it returns
 * QueryLanguage - default
 * MongoDBLanguage
 * Neo4JLanguage
+
+---
+### 14 - Window Function
+
+Aggregation functions (Avg, Min, Max, Sum, Count) have the **over** method...
+
+    query=Select(
+        'Enrollment e',
+        payment=Sum().over(
+            partition='student_id', order='due_date'
+        ).As('sum_per_student')
+    )
+
+...that generates the following query:
+
+```
+SELECT
+        Sum(e.payment) OVER(
+                PARTITION BY student_id
+                ORDER BY due_date
+        ) as sum_per_student
+FROM
+        Enrollment e
+```
+---
+### 15 - The `As` method:
+    query=Select(
+        'Customers c',
+        phone=[
+            Not.is_null(),
+            SubString(1, 4).As('area_code', GroupBy)
+        ],
+        customer_id=[
+            Count().As('customer_count', OrderBy),
+            Having.count(gt(5))
+        ]
+    )
+You can use the result of a function as a new field -- and optionally use it in ORDER BY and/or GROUP BY clause(s):
+```
+SELECT
+        SubString(c.phone, 1, 4) as area_code,
+        Count(c.customer_id) as customer_count
+FROM
+        Customers c
+WHERE
+        NOT c.phone IS NULL
+GROUP BY
+        area_code HAVING Count(c.customer_id) > 5
+ORDER BY
+        customer_count
+```

sql_blocks-1.25.dist-info/RECORD

@@ -0,0 +1,7 @@
+sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
+sql_blocks/sql_blocks.py,sha256=QxopGbzRtBgG_9oAs1ovBATFplDqrzEFSLwyKbOL-W8,45499
+sql_blocks-1.25.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+sql_blocks-1.25.dist-info/METADATA,sha256=cvHewfK05stZRHfWZeyIMMtKRjdOGxZN38o94JkVS-U,13421
+sql_blocks-1.25.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sql_blocks-1.25.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
+sql_blocks-1.25.dist-info/RECORD,,

sql_blocks-0.31.89.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=nsIT8JEeYHw3KIkzAUHUdzUAR_i2asJmdytsvW0hYKc,43342
-sql_blocks-0.31.89.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-0.31.89.dist-info/METADATA,sha256=xKHVfM76nzvZBr-TYC5_PN4bAvYW9oWoi5ChPIPdbDE,12202
-sql_blocks-0.31.89.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-0.31.89.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-0.31.89.dist-info/RECORD,,