sql-blocks 0.0.6__tar.gz → 0.0.8__tar.gz

{sql_blocks-0.0.6/sql_blocks.egg-info → sql_blocks-0.0.8}/PKG-INFO

@@ -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.6 → sql_blocks-0.0.8}/README.md

@@ -291,10 +291,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.6 → sql_blocks-0.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sql_blocks"
-version = "0.0.6"
+version = "0.0.8"
 authors = [
   { name="Julio Cascalles", email="julio.cascalles@outlook.com" },
 ]

{sql_blocks-0.0.6 → sql_blocks-0.0.8}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup
 
 setup(
     name = 'sql_blocks',
-    version = '0.0.6',
+    version = '0.0.8',
     author = 'Júlio Cascalles',
     author_email = 'julio.cascalles@outlook.com',
     packages = ['sql_blocks'],

sql_blocks-0.0.8/sql_blocks/__init__.py

@@ -0,0 +1 @@
+from sql_blocks import *

{sql_blocks-0.0.6 → sql_blocks-0.0.8}/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 → sql_blocks-0.0.8/sql_blocks.egg-info}/PKG-INFO

@@ -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.6 → sql_blocks-0.0.8}/sql_blocks.egg-info/SOURCES.txt

@@ -7,5 +7,4 @@ sql_blocks/sql_blocks.py
 sql_blocks.egg-info/PKG-INFO
 sql_blocks.egg-info/SOURCES.txt
 sql_blocks.egg-info/dependency_links.txt
-sql_blocks.egg-info/top_level.txt
-tests/tests.py
+sql_blocks.egg-info/top_level.txt

sql_blocks-0.0.6/sql_blocks/__init__.py

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

sql_blocks-0.0.6/tests/tests.py

@@ -1,110 +0,0 @@
-from sql_blocks.sql_blocks import *
-
-
-Select.join_type = JoinType.LEFT
-OrderBy.sort = SortType.DESC
-
-def best_movies() -> SelectIN:
-    return SelectIN(
-        'Review r',  movie=[GroupBy, Distinct], rate=Having.avg(Where.gt(4.5))
-    )
-
-def detached_objects() -> tuple:
-    def select_actor() -> Select:
-        return Select('Actor a', cast=ForeignKey('Cast'),
-            name=NamedField('actors_name'), age=Between(45, 69)
-        )
-    def select_cast() -> Select:
-        return Select(
-            Cast=Table('role'), id=PrimaryKey, movie=ForeignKey('Movie'),
-        )
-    def select_movie() -> Select:
-        return Select('Movie m', title=Field,
-            release_date=[OrderBy, Field], id=PrimaryKey,
-            OR=Options(
-                genre=Where.eq('Sci-Fi'), awards=Where.like('Oscar')
-            ), director=[Where.like('Coppola'), Field, OrderBy]
-        )
-    return select_actor(), select_cast(), select_movie()
-
-def query_reference() -> Select:
-    return Select('Actor a', age=Between(45, 69),
-        cast=Select(
-            Cast=Table('role'), id=PrimaryKey,
-            movie=Select(
-                'Movie m', title=Field,
-                release_date=[OrderBy, Field],
-                id=[
-                    SelectIN(
-                        'Review r', movie=[GroupBy, Distinct],
-                        rate=Having.avg(Where.gt(4.5))
-                    ),
-                    PrimaryKey
-                ], OR=Options(
-                    genre=Where.eq('Sci-Fi'), awards=Where.like('Oscar')
-                )
-            ) # --- Movie
-        ), # ------- Cast
-        name=NamedField('actors_name'),
-    ) # ----------- Actor
-
-SINGLE_CONDITION_GENRE = "( m.genre = 'Sci-Fi' OR m.awards LIKE '%Oscar%' )"
-SUB_QUERIES_CONDITIONS = """
-    m.genre NOT in (SELECT g.id from Genres g where g.name in ('sci-fi', 'horror', 'distopia'))
-    AND (m.hashtag = '#cult' OR m.awards LIKE '%Oscar%')
-    AND m.id IN (select DISTINCT r.movie FROM Review r GROUP BY r.movie HAVING Avg(r.rate) > 4.5)
-"""
-
-def single_text_to_objects(conditions: str=SINGLE_CONDITION_GENRE):
-    return Select.parse(f'''
-        SELECT
-                cas.role,
-                m.title,
-                m.release_date,
-                a.name as actors_name
-        FROM
-                Actor a
-                LEFT JOIN Cast cas ON (a.cast = cas.id)
-                LEFT JOIN Movie m ON (cas.movie = m.id)
-        WHERE
-                {conditions}
-                AND a.age <= 69 AND a.age >= 45
-        ORDER BY
-                m.release_date DESC
-    ''')
-
-def many_texts_to_objects():
-    ForeignKey.references = {
-        ('Actor', 'Cast'): ('cast', 'id'),
-        ('Cast', 'Movie'): ('movie', 'id'),
-    }
-    actor = Select.parse('''
-        SELECT name as actors_name FROM Actor a
-        WHERE a.age >= 45 AND a.age <= 69
-    ''')[0]
-    cast = Select.parse('SELECT role FROM Cast')[0]
-    movie = Select.parse("""
-        SELECT title, release_date FROM Movie m ORDER BY release_date DESC
-        WHERE ( m.genre = 'Sci-Fi' OR m.awards LIKE '%Oscar%' ) GROUP BY director
-    """)[0]
-    return actor, cast, movie
-
-def two_queries_same_table() -> Select:
-    txt1 = """SELECT p.name, p.category
-    ,p.price,p.promotional FROM product p
-        where p.category in (6,14,29,35,78)
-    AND p.Status = p.last_st ORDER BY p.EAN"""
-    txt2 = """select stock_amount, EAN,Name       ,expiration_date
-    from PRODUCT where price < 357.46 and status = Last_ST order by ean"""
-    return Select.parse(txt1)[0] + Select.parse(txt2)[0]
-
-def select_product() -> Select:
-    return Select(
-        Product=Table('name,promotional,stock_amount,expiration_date'),
-        category=[Where.list([6,14,29,35,78]),Field], EAN=[Field, OrderBy],
-        price=[Where.lt(357.46),Field], status=Where('= Last_st')
-    )
-
-def extract_subqueries() -> dict:
-    query_list = single_text_to_objects(SUB_QUERIES_CONDITIONS)
-    return {query.table_name: query for query in query_list}