sql-blocks 0.1.4__py3-none-any.whl → 0.2.1__py3-none-any.whl

sql_blocks/sql_blocks.py

@@ -176,17 +176,27 @@ class ExpressionField:
             a=main.alias, f=name, t=main.table_name
         )
 
+class FieldList:
+    separator = ','
 
-class Table:
-    def __init__(self, fields: list=[]):
+    def __init__(self, fields: list=[], class_types = [Field]):
         if isinstance(fields, str):
-            fields = [f.strip() for f in fields.split(',')]
+            fields = [
+                f.strip() for f in fields.split(self.separator)
+            ]
         self.fields = fields
+        self.class_types = class_types
 
     def add(self, name: str, main: SQLObject):
-        main.set_table(name)
         for field in self.fields:
-            Field.add(field, main)
+            for class_type in self.class_types:
+                class_type.add(field, main)
+
+
+class Table(FieldList):
+    def add(self, name: str, main: SQLObject):
+        main.set_table(name)
+        super().add(name, main)
 
 
 class PrimaryKey:
@@ -237,7 +247,7 @@ class Where:
         return cls.__constructor('=', value)
 
     @classmethod
-    def like(cls, value: str):
+    def contains(cls, value: str):
         return cls(f"LIKE '%{value}%'")
    
     @classmethod
@@ -261,7 +271,7 @@ class Where:
         return cls('IS NULL')
     
     @classmethod
-    def list(cls, values):
+    def inside(cls, values):
         if isinstance(values, list):
             values = ','.join(quoted(v) for v in values)
         return cls(f'IN ({values})')
@@ -272,6 +282,12 @@ class Where:
         ))
 
 
+eq, contains, gt, gte, lt, lte, is_null, inside = (
+    getattr(Where, method) for method in 
+    ('eq', 'contains', 'gt', 'gte', 'lt', 'lte', 'is_null', 'inside')
+) 
+
+
 class Not(Where):
     prefix = 'NOT '
 
@@ -346,9 +362,12 @@ class OrderBy:
     sort: SortType = SortType.ASC
     @classmethod
     def add(cls, name: str, main: SQLObject):
-        if main.alias:
+        found = re.findall(r'^_\d', name)
+        if found:
+            name = found[0].replace('_', '')
+        elif main.alias:
             name = f'{main.alias}.{name}'
-        main.values.setdefault(ORDER_BY, []).append(name + cls.sort.value)
+        main.values.setdefault(ORDER_BY, []).append(name+cls.sort.value)
 
 
 class GroupBy:
@@ -414,38 +433,39 @@ class Select(SQLObject):
             self.values.setdefault(key, []).append(value)
 
     def add(self, name: str, main: SQLObject):
-        new_tables = [
+        old_tables = main.values.get(FROM, [])
+        new_tables = set([
             '{jt}JOIN {tb} {a2} ON ({a1}.{f1} = {a2}.{f2})'.format(
                 jt=self.join_type.value,
                 tb=self.table_name,
                 a1=main.alias, f1=name,
                 a2=self.alias, f2=self.key_field
             )
-        ]
-        if new_tables not in main.values.get(FROM, []):
-            new_tables += self.values[FROM][1:]
-            main.values.setdefault(FROM, []).extend(new_tables)
+        ] + old_tables[1:])
+        main.values[FROM] = old_tables[:1] + list(new_tables)
         for key in USUAL_KEYS:
             main.update_values(key, self.values.get(key, []))
 
     def __add__(self, other: SQLObject):
-        if self.table_name.lower() == other.table_name.lower():
+        from copy import deepcopy
+        query = deepcopy(self)
+        if query.table_name.lower() == other.table_name.lower():
             for key in USUAL_KEYS:
-                self.update_values(key, other.values.get(key, []))
-            return self
-        foreign_field, primary_key = ForeignKey.find(self, other)
+                query.update_values(key, other.values.get(key, []))
+            return query
+        foreign_field, primary_key = ForeignKey.find(query, other)
         if not foreign_field:
-            foreign_field, primary_key = ForeignKey.find(other, self)
+            foreign_field, primary_key = ForeignKey.find(other, query)
             if foreign_field:
                 if primary_key:
-                    PrimaryKey.add(primary_key, self)
-                self.add(foreign_field, other)
+                    PrimaryKey.add(primary_key, query)
+                query.add(foreign_field, other)
                 return other
-            raise ValueError(f'No relationship found between {self.table_name} and {other.table_name}.')
+            raise ValueError(f'No relationship found between {query.table_name} and {other.table_name}.')
         elif primary_key:
             PrimaryKey.add(primary_key, other)
-        other.add(foreign_field, self)
-        return self
+        other.add(foreign_field, query)
+        return query
 
     def __str__(self) -> str:
         TABULATION = '\n\t' if self.break_lines else ' '
@@ -557,13 +577,22 @@ class Select(SQLObject):
         for rule in rules:
             rule.apply(self)
 
+    def add_fields(self, fields: list, order_by: bool=False, group_by:bool=False):
+        class_types = [Field]
+        if order_by:
+            class_types += [OrderBy]
+        if group_by:
+            class_types += [GroupBy]
+        FieldList(fields, class_types).add('', self)
+
+
 
 class SelectIN(Select):
     condition_class = Where
 
     def add(self, name: str, main: SQLObject):
         self.break_lines = False
-        self.condition_class.list(self).add(name, main)
+        self.condition_class.inside(self).add(name, main)
 
 SubSelect = SelectIN
 
@@ -578,6 +607,7 @@ class RulePutLimit(Rule):
         if need_limit:
             target.limit()
 
+
 class RuleSelectIN(Rule):
     @classmethod
     def apply(cls, target: Select):
@@ -592,6 +622,7 @@ class RuleSelectIN(Rule):
                     ','.join(t.split('=')[-1].strip() for t in tokens)
                 )
 
+
 class RuleAutoField(Rule):
     @classmethod
     def apply(cls, target: Select):
@@ -603,13 +634,11 @@ class RuleAutoField(Rule):
             s2 = set(target.values[ORDER_BY])
             target.values.setdefault(SELECT, []).extend( list(s2-s1) )
 
+
 class RuleLogicalOp(Rule):
-    REVERSE = {
-        ">=": "<",
-        "<=": ">",
-        "<>": "=",
-        "=": "<>"
-    }
+    REVERSE = {">=": "<", "<=": ">", "=": "<>"}
+    REVERSE |= {v: k for k, v in REVERSE.items()}
+
     @classmethod
     def apply(cls, target: Select):
         REGEX = re.compile('({})'.format(
@@ -617,13 +646,14 @@ class RuleLogicalOp(Rule):
         ))
         for i, condition in enumerate(target.values.get(WHERE, [])):
             expr = re.sub('\n|\t', ' ', condition)
-            tokens = [t for t in re.split(r'(NOT\b|not\b)',expr) if t.strip()]
-            if len(tokens) < 2 or not REGEX.findall(tokens[-1]):
+            if not re.search(r'\b(NOT|not)\b', expr):
                 continue
-            tokens = REGEX.split(tokens[-1])
-            tokens[1] = cls.REVERSE[tokens[1]]
+            tokens = [t.strip() for t in re.split(r'NOT\b|not\b|(<|>|=)', expr) if t]
+            op = ''.join(tokens[1: len(tokens)-1])
+            tokens = [tokens[0], cls.REVERSE[op], tokens[-1]]
             target.values[WHERE][i] = ' '.join(tokens)
 
+
 class RuleDateFuncReplace(Rule):
     """
     SQL algorithm by Ralff Matias

{sql_blocks-0.1.4.dist-info → sql_blocks-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.1.4
+Version: 0.2.1
 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
@@ -24,7 +24,7 @@ _Note that an alias "act" has been added._
 You can specify your own alias:  `a = Select('Actor a')`
 
 ---
-### 2 - You can also add a field, like this...
+### 2 - You can also add a field, contains this...
 
 * a = Select('Actor a', **name=Field**)
 
@@ -55,12 +55,12 @@ You can specify your own alias:  `a = Select('Actor a')`
 ---
 
 ### 3 - To set conditions, use **Where**:
-* For example, `a = Select(... age=Where.gt(45) )`
+* For example, `a = Select(... age=gt(45) )`
 
     Some possible conditions:
-    * field=Where.eq(value) - ...the field is EQUAL to the value;
-    * field=Where.gt(value) - ...the field is GREATER than the value;
-    * field=Where.lt(value) - ...the field is LESS than the value;
+    * field=eq(value) - ...the field is EQUAL to the value;
+    * field=gt(value) - ...the field is GREATER than the value;
+    * field=lt(value) - ...the field is LESS than the value;
 
     3.1 -- If you want to filter the field on a range of values:
     
@@ -71,7 +71,7 @@ You can specify your own alias:  `a = Select('Actor a')`
 query = Select('Movie m', title=Field,
     id=SelectIN(
         'Review r',
-        rate=Where.gt(4.5),
+        rate=gt(4.5),
         movie_id=Distinct
     )
 )
@@ -92,8 +92,8 @@ query = Select('Movie m', title=Field,
 3.3 -- Optional conditions:
 ```
     OR=Options(
-        genre=Where.eq("Sci-Fi"),
-        awards=Where.like("Oscar")
+        genre=eq("Sci-Fi"),
+        awards=contains("Oscar")
     )
 ```
 > Could be AND=Options(...)
@@ -105,7 +105,7 @@ based_on_book=Not.is_null()
 
 3.5 -- List of values
 ```
-hash_tag=Where.list(['space', 'monster', 'gore'])
+hash_tag=inside(['space', 'monster', 'gore'])
 ```
 
 ---
@@ -113,11 +113,11 @@ hash_tag=Where.list(['space', 'monster', 'gore'])
 
 * m = Select('Movie m' release_date=[Field, OrderBy])
     - This means that the field will appear in the results and also that the query will be ordered by that field.
-* Applying **GROUP BY** to item 3.2, it would look like this:
+* Applying **GROUP BY** to item 3.2, it would look contains this:
     ```    
     SelectIN(
         'Review r', movie=[GroupBy, Distinct],
-        rate=Having.avg(Where.gt(4.5))
+        rate=Having.avg(gt(4.5))
     )
     ```
 ---
@@ -299,7 +299,7 @@ m = Select...
 ```
 best_movies = SelectIN(
     Review=Table('role'),
-    rate=[GroupBy, Having.avg(Where.gt(4.5))]
+    rate=[GroupBy, Having.avg(gt(4.5))]
 )
 m1 = Select(
     Movie=Table('title,release_date'),
@@ -320,9 +320,9 @@ m2 = Select(
     Select(
         'Product',
         label=Case('price').when(
-            Where.lt(50), 'cheap'
+            lt(50), 'cheap'
         ).when(
-            Where.gt(100), 'expensive'
+            gt(100), 'expensive'
         ).else_value(
             'normal'
         )
@@ -360,3 +360,22 @@ m2 = Select(
 * Replace `YEAR` function with date range comparison.
 
 > The method allows you to select which rules you want to apply in the optimization...Or define your own rules!
+
+---
+
+### 12 - Adding multiple fields at once
+```
+    query = Select('post p')
+    query.add_fields(
+        'user_id, created_at',
+        order_by=True, group_by=True
+    )
+```
+...is the same as...
+```
+    query = Select(
+        'post p',
+        user_id=[Field, GroupBy, OrderBy],
+        created_at=[Field, GroupBy, OrderBy]
+    )
+```

sql_blocks-0.2.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
+sql_blocks/sql_blocks.py,sha256=5WBEFqik86gcV4WwPHx4R2e2vMeA1D_et1C9oEMnoQw,21600
+sql_blocks-0.2.1.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+sql_blocks-0.2.1.dist-info/METADATA,sha256=g5YLLFr736iWjO8dD0pO7nph5xEbyG6fynoAKo9-XtI,8804
+sql_blocks-0.2.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sql_blocks-0.2.1.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
+sql_blocks-0.2.1.dist-info/RECORD,,

sql_blocks-0.1.4.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=wj54KGT9Bnbo9Jtyn_jA6lbHhgkmGirRUp6ZHq9ilZ8,20654
-sql_blocks-0.1.4.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-0.1.4.dist-info/METADATA,sha256=DWqKIgeFG_wjr8u4qusK-bcb_cgbxHXZ3DNFUXmMwKo,8503
-sql_blocks-0.1.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-0.1.4.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-0.1.4.dist-info/RECORD,,