sql-blocks 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

sql_blocks/__init__.py

@@ -1 +1 @@
-from sql_blocks.sql_blocks import *
+from sql_blocks import *

sql_blocks/sql_blocks.py

@@ -10,26 +10,32 @@ DISTINCT_SF_PR = f'(DISTINCT|distinct)|{SUFFIX_AND_PRE}'
 KEYWORD = {
     'SELECT': (',{}', 'SELECT *', DISTINCT_SF_PR),
     'FROM': ('{}', '', PATTERN_SUFFIX),
-    'WHERE': ('{}AND ', '', PATTERN_PREFIX),
+    'WHERE': ('{}AND ', '', ''),
     'GROUP BY': (',{}', '', SUFFIX_AND_PRE),
     'ORDER BY': (',{}', '', SUFFIX_AND_PRE),
     'LIMIT': (' ', '', ''),
 }
-#             ^     ^        ^
-#             |     |        |
-#             |     |        +----- pattern to compare fields
-#             |     |
-#             |     +----- default when empty (SELECT * ...)
-#             |
-#             +-------- separator
+#              ^    ^        ^
+#              |    |        |
+#              |    |        +----- pattern to compare fields
+#              |    |
+#              |    +----- default when empty (SELECT * ...)
+#              |
+#              +-------- separator
 
 SELECT, FROM, WHERE, GROUP_BY, ORDER_BY, LIMIT = KEYWORD.keys()
-USUAL_KEYS = [SELECT, WHERE, GROUP_BY, ORDER_BY]
+USUAL_KEYS = [SELECT, WHERE, GROUP_BY, ORDER_BY, LIMIT]
 
 
 class SQLObject:
+    ALIAS_FUNC = lambda t: t.lower()[:3]
+    """    ^^^^^^^^^^^^^^^^^^^^^^^^
+    You can change the behavior by assigning 
+    a user function to SQLObject.ALIAS_FUNC
+    """
+
     def __init__(self, table_name: str=''):
-        self.alias = ''
+        self.__alias = ''
         self.values = {}
         self.key_field = ''
         self.set_table(table_name)
@@ -37,20 +43,26 @@ class SQLObject:
     def set_table(self, table_name: str):
         if not table_name:
             return
-        if ' ' in table_name:
-            table_name, self.alias = table_name.split()
+        if ' ' in table_name.strip():
+            table_name, self.__alias = table_name.split()
         elif '_' in table_name:
-            self.alias = ''.join(
+            self.__alias = ''.join(
                 word[0].lower()
                 for word in table_name.split('_')
             )
         else:
-            self.alias = table_name.lower()[:3]
+            self.__alias = SQLObject.ALIAS_FUNC(table_name)
         self.values.setdefault(FROM, []).append(f'{table_name} {self.alias}')
 
     @property
     def table_name(self) -> str:
         return self.values[FROM][0].split()[0]
+    
+    @property
+    def alias(self) -> str:
+        if self.__alias:
+            return self.__alias
+        return self.table_name
  
     @staticmethod
     def get_separator(key: str) -> str:
@@ -58,11 +70,17 @@ class SQLObject:
         return KEYWORD[key][0].format(appendix.get(key, ''))
 
     def diff(self, key: str, search_list: list, symmetrical: bool=False) -> set:
-        pattern = KEYWORD[key][2]
+        def cleanup(fld: str) -> str:
+            if symmetrical:
+                fld = fld.lower()
+            return fld.strip()
+        pattern = KEYWORD[key][2] 
+        if key == WHERE and symmetrical:
+            pattern = f'{PATTERN_PREFIX}| '
         separator = self.get_separator(key)
         def field_set(source: list) -> set:
             return set(
-                re.sub(pattern, '', fld.strip()).lower()
+                re.sub(pattern, '', cleanup(fld))
                 for string in source
                 for fld in re.split(separator, string)
             )       
@@ -90,9 +108,9 @@ class Field:
     @classmethod
     def format(cls, name: str, main: SQLObject) -> str:
         name = name.strip()
-        if name == '_':
+        if name in ('_', '*'):
             name = '*'
-        elif '.' not in name:
+        elif not re.findall('[.()0-9]', name):
             name = f'{main.alias}.{name}'
         if Function in cls.__bases__:
             name = f'{cls.__name__}({name})'
@@ -185,7 +203,7 @@ class Where:
     prefix = ''
 
     def __init__(self, expr: str):
-        self.expr = f'{self.prefix}{expr}'
+        self.expr = expr
 
     @classmethod
     def __constructor(cls, operator: str, value):
@@ -226,8 +244,8 @@ class Where:
         return cls(f'IN ({values})')
 
     def add(self, name: str, main: SQLObject):
-        main.values.setdefault(WHERE, []).append('{} {}'.format(
-            Field.format(name, main), self.expr
+        main.values.setdefault(WHERE, []).append('{}{} {}'.format(
+            self.prefix, Field.format(name, main), self.expr
         ))
 
 
@@ -347,6 +365,12 @@ class Having:
         return cls(Count, condition)
 
 
+class Rule:
+    @classmethod
+    def apply(cls, target: 'Select'):
+        ...
+
+
 class JoinType(Enum):
     INNER = ''
     LEFT = 'LEFT '
@@ -367,16 +391,17 @@ class Select(SQLObject):
             self.values.setdefault(key, []).append(value)
 
     def add(self, name: str, main: SQLObject):
-        main.update_values(
-            FROM, [
-                '{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
-                )
-            ] + self.values[FROM][1:]
-        )
+        new_tables = [
+            '{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)
         for key in USUAL_KEYS:
             main.update_values(key, self.values.get(key, []))
 
@@ -424,13 +449,16 @@ class Select(SQLObject):
                 return False
         return True
 
-    def limit(self, row_count: int, offset: int=0):
+    def limit(self, row_count: int=100, offset: int=0):
         result = [str(row_count)]
         if offset > 0:
             result.append(f'OFFSET {offset}')
         self.values.setdefault(LIMIT, result)
         return self
 
+    def match(self, expr: str) -> bool:
+        return re.findall(f'\b*{self.alias}[.]', expr) != []
+
     @classmethod
     def parse(cls, txt: str) -> list[SQLObject]:
         def find_last_word(pos: int) -> int:
@@ -452,7 +480,7 @@ class Select(SQLObject):
         if not cls.REGEX:
             keywords = '|'.join(k + r'\b' for k in KEYWORD)
             flags = re.IGNORECASE + re.MULTILINE
-            cls.REGEX['keywords'] = re.compile(f'({keywords})', flags)
+            cls.REGEX['keywords'] = re.compile(f'({keywords}|[*])', flags)
             cls.REGEX['subquery'] = re.compile(r'(\w\.)*\w+ +in +\(SELECT.*?\)', flags)
         result = {}
         found = cls.REGEX['subquery'].search(txt)
@@ -476,7 +504,7 @@ class Select(SQLObject):
             result[obj.alias] = obj
             txt = txt[:start-1] + txt[end+1:]
             found = cls.REGEX['subquery'].search(txt)
-        tokens = [t.strip() for t in cls.REGEX['keywords'].split(txt) if re.findall(r'\w+', t)]
+        tokens = [t.strip() for t in cls.REGEX['keywords'].split(txt) if t.strip()]
         values = {k.upper(): v for k, v in zip(tokens[::2], tokens[1::2])}
         tables = [t.strip() for t in re.split('JOIN|LEFT|RIGHT|ON', values[FROM]) if t.strip()]
         for item in tables:
@@ -495,11 +523,18 @@ class Select(SQLObject):
                     obj.values[key] = [
                         Field.format(fld, obj)
                         for fld in re.split(separator, values[key])
-                        if len(tables) == 1 or re.findall(f'\b*{obj.alias}[.]', fld)
+                        if (fld != '*' and len(tables) == 1) or obj.match(fld)
                     ]
                 result[obj.alias] = obj
         return list( result.values() )
 
+    def optimize(self, rules: list[Rule]=None):
+        if not rules:
+            rules = Rule.__subclasses__()
+        for rule in rules:
+            rule.apply(self)
+
+
 class SelectIN(Select):
     condition_class = Where
 
@@ -511,3 +546,76 @@ SubSelect = SelectIN
 
 class NotSelectIN(SelectIN):
     condition_class = Not
+
+
+class RulePutLimit(Rule):
+    @classmethod
+    def apply(cls, target: Select):
+        need_limit = any(not target.values.get(key) for key in (WHERE, SELECT))
+        if need_limit:
+            target.limit()
+
+class RuleSelectIN(Rule):
+    @classmethod
+    def apply(cls, target: Select):
+        for i, condition in enumerate(target.values[WHERE]):
+            tokens = re.split(' or | OR ', re.sub('\n|\t|[()]', ' ', condition))
+            if len(tokens) < 2:
+                continue
+            fields = [t.split('=')[0].split('.')[-1].lower().strip() for t in tokens]
+            if len(set(fields)) == 1:
+                target.values[WHERE][i] = '{} IN ({})'.format(
+                    Field.format(fields[0], target),
+                    ','.join(t.split('=')[-1].strip() for t in tokens)
+                )
+
+class RuleAutoField(Rule):
+    @classmethod
+    def apply(cls, target: Select):
+        if target.values.get(GROUP_BY):
+            target.values[SELECT] = target.values[GROUP_BY]
+            target.values[ORDER_BY] = []
+        elif target.values.get(ORDER_BY):
+            s1 = set(target.values.get(SELECT, []))
+            s2 = set(target.values[ORDER_BY])
+            target.values.setdefault(SELECT, []).extend( list(s2-s1) )
+
+class RuleLogicalOp(Rule):
+    REVERSE = {
+        ">=": "<",
+        "<=": ">",
+        "<>": "=",
+        "=": "<>"
+    }
+    @classmethod
+    def apply(cls, target: Select):
+        REGEX = re.compile('({})'.format(
+            '|'.join(cls.REVERSE)
+        ))
+        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]):
+                continue
+            tokens = REGEX.split(tokens[-1])
+            tokens[1] = cls.REVERSE[tokens[1]]
+            target.values[WHERE][i] = ' '.join(tokens)
+
+class RuleDateFuncReplace(Rule):
+    """
+    SQL algorithm by Ralff Matias
+    """
+    REGEX = re.compile(r'(\bYEAR[(]|\byear[(]|=|[)])')
+
+    @classmethod
+    def apply(cls, target: Select):
+        for i, condition in enumerate(target.values.get(WHERE, [])):
+            tokens = [
+                t.strip() for t in cls.REGEX.split(condition) if t.strip()
+            ]
+            if len(tokens) < 3:
+                continue
+            func, field, *rest, year = tokens
+            temp = Select(f'{target.table_name} {target.alias}')
+            Between(f'{year}-01-01', f'{year}-12-31').add(field, temp)
+            target.values[WHERE][i] = ' AND '.join(temp.values[WHERE])

{sql_blocks-0.0.6.dist-info → sql_blocks-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.0.6
+Version: 0.0.8
 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
@@ -306,10 +306,43 @@ 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'
         )
     )
+
+---
+
+### 11 - optimize method
+    p1 = Select.parse("""
+            SELECT * FROM Product p
+            WHERE (p.category = 'Gizmo'
+                    OR p.category = 'Gadget'
+                    OR p.category = 'Doohickey')
+                AND NOT price <= 387.64
+                AND YEAR(last_sale) = 2024
+            ORDER BY
+                category
+        """)[0]
+        p1.optimize() #  <<===============
+        p2 = Select.parse("""
+            SELECT category FROM Product p
+            WHERE category IN ('Gizmo','Gadget','Doohickey')
+                and p.price > 387.64
+                and p.last_sale >= '2024-01-01'
+                and p.last_sale <= '2024-12-31'
+            ORDER BY p.category LIMIT 100
+        """)[0]
+        p1 == p2 # --- True!
+
+ This will...
+* Replace `OR` conditions to `SELECT IN ...`
+* Put `LIMIT` if no fields or conditions defined;
+* Normalizes inverted conditions;
+* Auto includes fields present in `ORDER/GROUP BY`;
+* 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!

sql_blocks-0.0.8.dist-info/RECORD

@@ -0,0 +1,7 @@
+sql_blocks/__init__.py,sha256=TodC5q-UEdYEz9v1RRoogVqqRcsKnZRY1WDGinrI2zo,26
+sql_blocks/sql_blocks.py,sha256=mC8TTgAXrGL0X_Zn5GPv2HytlaRKm9jpcUyaSnepFOs,19963
+sql_blocks-0.0.8.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+sql_blocks-0.0.8.dist-info/METADATA,sha256=B7L8E2UI-0GWHsDVPWibQsMrp69wzP4XRfXOOfg5GV4,8190
+sql_blocks-0.0.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sql_blocks-0.0.8.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
+sql_blocks-0.0.8.dist-info/RECORD,,

sql_blocks-0.0.6.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=Fs636uSwXTxlzHH9SCOxmGTgt2MjhQ6Pf6v92CRtQ9E,16229
-sql_blocks-0.0.6.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-0.0.6.dist-info/METADATA,sha256=-2-vPw1nkpqKvlp0l2Bt8VF_sBZ_TM8BGf-Nmk8X2oo,7037
-sql_blocks-0.0.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-0.0.6.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-0.0.6.dist-info/RECORD,,