sql-blocks 0.31.21__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,26 +449,40 @@ class Between:
         Where.lte(self.end).add(name, main)
 
 
+class Clause:
+    @classmethod
+    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():
+            name = f'{main.alias}.{name}'
+        return name
+
+
 class SortType(Enum):
     ASC = ''
     DESC = ' DESC'
 
-class OrderBy:
+
+class OrderBy(Clause):
     sort: SortType = SortType.ASC
+
     @classmethod
     def add(cls, name: str, main: SQLObject):
-        found = re.findall(r'^_\d', name)
-        if found:
-            name = found[0].replace('_', '')
-        elif main.alias:
-            name = f'{main.alias}.{name}'
+        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:
@@ -858,7 +960,11 @@ class CypherParser(Parser):
         else:
             if not curr.values.get(SELECT):
                 raise IndexError(f'Foreign Key not found for {curr.table_name}.')
-            foreign_fld = curr.values[SELECT][0].split('.')[-1]
+            fields = [
+                fld for fld in curr.values[SELECT]
+                if fld not in curr.values.get(GROUP_BY, [])
+            ]
+            foreign_fld = fields[0].split('.')[-1]
             curr.delete(foreign_fld, [SELECT])
             if curr.join_type == JoinType.RIGHT:
                 pk_field, foreign_fld = foreign_fld, pk_field
@@ -1087,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
 
@@ -1252,15 +1357,3 @@ def detect(text: str) -> Select:
     for query in query_list[1:]:
         result += query
     return result
-
-
-if __name__ == "__main__":
-    print('@'*100)
-    print( detect(
-        '''
-            Company(?jobs > 10, id)
-            <- Person(work_at ^name, friend_of) ->
-            Person(id ?skill="pANDas")
-        '''                #   ^^^---- Test for confusion with the AND operator
-    ) )
-    print('@'*100)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.31.21
+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
@@ -390,7 +390,7 @@ a, c, m = Select.parse(
         <- Cast(actor_id, movie_id) ->
         Movie(id ^title)
     """,
-    Cypher 
+    CypherParser
     # ^^^ recognizes syntax like Neo4J queries
 )
 ```
@@ -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,13 +460,13 @@ print(query)
     ORDER BY
             peo.qtde
 
-> **3 - Many conditions...**
+> **13.3 - Many conditions...**
 ```
     print( detect('''
         db.people.find({
             {
                 $or: [
-                    status:{$eq:"B"},
+                    {status:{$eq:"B"}},
                     age:{$lt:50}
                 ]
             },
@@ -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.21.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=jtK4yfyLCQZYrom2Aj_En6Hvlc3mbvAI1TOnC4AK72U,42823
-sql_blocks-0.31.21.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-0.31.21.dist-info/METADATA,sha256=lDrOFqAT1hC8lEp9plVXngNJ7m_2ZnJ8qRywx_PVUCo,12195
-sql_blocks-0.31.21.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-0.31.21.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-0.31.21.dist-info/RECORD,,