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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.0.4
+Version: 0.0.6
 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
@@ -249,13 +249,13 @@ m = Select...
 9.1
 ```
         a1 = Select.parse('''
-                SELECT gender, max(age) FROM Actor act
+                SELECT gender, Max(act.age) FROM Actor act
                 WHERE act.age <= 69 AND act.age >= 45
                 GROUP BY gender
             ''')[0]
 
         a2 = Select('Actor',
-            age=Between(45, 69), gender=GroupBy,
+            age=[ Between(45, 69), Max ],
             gender=[GroupBy, Field]
         )       
 ```
@@ -306,9 +306,9 @@ m2 = Select(
     Select(
         'Product',
         label=Case('price').when(
-            lt(50), 'cheap'
+            Where.lt(50), 'cheap'
         ).when(
-            gt(100), 'expensive'
+            Where.gt(100), 'expensive'
         ).else_value(
             'normal'
         )

{sql_blocks-0.0.4 → sql_blocks-0.0.6}/README.md

@@ -234,13 +234,13 @@ m = Select...
 9.1
 ```
         a1 = Select.parse('''
-                SELECT gender, max(age) FROM Actor act
+                SELECT gender, Max(act.age) FROM Actor act
                 WHERE act.age <= 69 AND act.age >= 45
                 GROUP BY gender
             ''')[0]
 
         a2 = Select('Actor',
-            age=Between(45, 69), gender=GroupBy,
+            age=[ Between(45, 69), Max ],
             gender=[GroupBy, Field]
         )       
 ```
@@ -291,9 +291,9 @@ m2 = Select(
     Select(
         'Product',
         label=Case('price').when(
-            lt(50), 'cheap'
+            Where.lt(50), 'cheap'
         ).when(
-            gt(100), 'expensive'
+            Where.gt(100), 'expensive'
         ).else_value(
             'normal'
         )

{sql_blocks-0.0.4 → sql_blocks-0.0.6}/pyproject.toml

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

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

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

sql_blocks-0.0.6/sql_blocks/__init__.py

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

{sql_blocks-0.0.4 → sql_blocks-0.0.6}/sql_blocks/sql_blocks.py

@@ -2,14 +2,27 @@ from enum import Enum
 import re
 
 
+PATTERN_PREFIX = '([^0-9 ]+[.])'
+PATTERN_SUFFIX = '( [A-Za-z_]+)'
+SUFFIX_AND_PRE = f'{PATTERN_SUFFIX}|{PATTERN_PREFIX}'
+DISTINCT_SF_PR = f'(DISTINCT|distinct)|{SUFFIX_AND_PRE}'
+
 KEYWORD = {
-    'SELECT': (',{}', 'SELECT *'),
-    'FROM': ('{}', ''),
-    'WHERE': ('{}AND ', ''),
-    'GROUP BY': (',{}', ''),
-    'ORDER BY': (',{}', ''),
-    'LIMIT': (' ', ''),
+    'SELECT': (',{}', 'SELECT *', DISTINCT_SF_PR),
+    'FROM': ('{}', '', PATTERN_SUFFIX),
+    'WHERE': ('{}AND ', '', PATTERN_PREFIX),
+    'GROUP BY': (',{}', '', SUFFIX_AND_PRE),
+    'ORDER BY': (',{}', '', SUFFIX_AND_PRE),
+    'LIMIT': (' ', '', ''),
 }
+#             ^     ^        ^
+#             |     |        |
+#             |     |        +----- 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]
 
@@ -39,6 +52,26 @@ class SQLObject:
     def table_name(self) -> str:
         return self.values[FROM][0].split()[0]
  
+    @staticmethod
+    def get_separator(key: str) -> str:
+        appendix = {WHERE: 'and|', FROM: 'join|JOIN'}
+        return KEYWORD[key][0].format(appendix.get(key, ''))
+
+    def diff(self, key: str, search_list: list, symmetrical: bool=False) -> set:
+        pattern = KEYWORD[key][2]
+        separator = self.get_separator(key)
+        def field_set(source: list) -> set:
+            return set(
+                re.sub(pattern, '', fld.strip()).lower()
+                for string in source
+                for fld in re.split(separator, string)
+            )       
+        s1 = field_set(search_list)
+        s2 = field_set(self.values.get(key, []))
+        if symmetrical:
+            return s1.symmetric_difference(s2)
+        return s1 - s2
+
     def delete(self, search: str, keys: list=USUAL_KEYS):
         for key in keys:
             result = []
@@ -329,13 +362,12 @@ class Select(SQLObject):
         self.__call__(**values)
         self.break_lines = True
 
+    def update_values(self, key: str, new_values: list):
+        for value in self.diff(key, new_values):
+            self.values.setdefault(key, []).append(value)
+
     def add(self, name: str, main: SQLObject):
-        def update_values(key: str, new_values: list):
-            for value in new_values:
-                old_values = main.values.get(key, [])
-                if value not in old_values:
-                    main.values[key] = old_values + [value]
-        update_values(
+        main.update_values(
             FROM, [
                 '{jt}JOIN {tb} {a2} ON ({a1}.{f1} = {a2}.{f2})'.format(
                     jt=self.join_type.value,
@@ -346,9 +378,13 @@ class Select(SQLObject):
             ] + self.values[FROM][1:]
         )
         for key in USUAL_KEYS:
-            update_values(key, self.values.get(key, []))
+            main.update_values(key, self.values.get(key, []))
 
     def __add__(self, other: SQLObject):
+        if self.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)
         if not foreign_field:
             foreign_field, primary_key = ForeignKey.find(other, self)
@@ -383,10 +419,8 @@ class Select(SQLObject):
         return self
 
     def __eq__(self, other: SQLObject) -> bool:
-        def sorted_values(obj: SQLObject, key: str) -> list:
-            return sorted(obj.values.get(key, []))
         for key in KEYWORD:
-            if sorted_values(self, key) != sorted_values(other, key):
+            if self.diff(key, other.values.get(key, []), True):
                 return False
         return True
 
@@ -427,7 +461,7 @@ class Select(SQLObject):
             inner = txt[start: end]
             if inner.count('(') > inner.count(')'):
                 end = find_parenthesis(end)
-                inner = txt[start: end]
+                inner = txt[start: end-1]
             fld, *inner = re.split(r' IN | in', inner, maxsplit=1)
             if fld.upper() == 'NOT':
                 pos = find_last_word(start)
@@ -457,15 +491,12 @@ class Select(SQLObject):
                 for key in USUAL_KEYS:
                     if not key in values:
                         continue
-                    separator = KEYWORD[key][0].format('')
-                    fields = [
+                    separator = cls.get_separator(key)
+                    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)
+                        for fld in re.split(separator, values[key])
+                        if len(tables) == 1 or re.findall(f'\b*{obj.alias}[.]', fld)
                     ]
-                    obj.values[key] = [ f for f in fields if f.strip() ]
                 result[obj.alias] = obj
         return list( result.values() )
 
@@ -480,32 +511,3 @@ SubSelect = SelectIN
 
 class NotSelectIN(SelectIN):
     condition_class = Not
-
-
-if __name__ == "__main__":
-    query_list = Select.parse("""
-        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
-                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)
-                AND a.age <= 69 AND a.age >= 45
-        ORDER BY
-                m.release_date
-    """)
-    for query in query_list:
-        descr = ' {} ({}) '.format(
-            query.table_name,
-            query.__class__.__name__
-        )
-        print(descr.center(50, '-'))
-        print(query)
-    print('='*50)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.0.4
+Version: 0.0.6
 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
@@ -249,13 +249,13 @@ m = Select...
 9.1
 ```
         a1 = Select.parse('''
-                SELECT gender, max(age) FROM Actor act
+                SELECT gender, Max(act.age) FROM Actor act
                 WHERE act.age <= 69 AND act.age >= 45
                 GROUP BY gender
             ''')[0]
 
         a2 = Select('Actor',
-            age=Between(45, 69), gender=GroupBy,
+            age=[ Between(45, 69), Max ],
             gender=[GroupBy, Field]
         )       
 ```
@@ -306,9 +306,9 @@ m2 = Select(
     Select(
         'Product',
         label=Case('price').when(
-            lt(50), 'cheap'
+            Where.lt(50), 'cheap'
         ).when(
-            gt(100), 'expensive'
+            Where.gt(100), 'expensive'
         ).else_value(
             'normal'
         )

{sql_blocks-0.0.4 → sql_blocks-0.0.6}/tests/tests.py

@@ -4,8 +4,8 @@ from sql_blocks.sql_blocks import *
 Select.join_type = JoinType.LEFT
 OrderBy.sort = SortType.DESC
 
-def best_movies() -> SubSelect:
-    return SubSelect(
+def best_movies() -> SelectIN:
+    return SelectIN(
         'Review r',  movie=[GroupBy, Distinct], rate=Having.avg(Where.gt(4.5))
     )
 
@@ -35,7 +35,7 @@ def query_reference() -> Select:
                 'Movie m', title=Field,
                 release_date=[OrderBy, Field],
                 id=[
-                    SubSelect(
+                    SelectIN(
                         'Review r', movie=[GroupBy, Distinct],
                         rate=Having.avg(Where.gt(4.5))
                     ),
@@ -48,8 +48,15 @@ def query_reference() -> Select:
         name=NamedField('actors_name'),
     ) # ----------- Actor
 
-def single_text_to_objects():
-    return Select.parse('''
+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,
@@ -60,7 +67,7 @@ def single_text_to_objects():
                 LEFT JOIN Cast cas ON (a.cast = cas.id)
                 LEFT JOIN Movie m ON (cas.movie = m.id)
         WHERE
-                ( m.genre = 'Sci-Fi' OR m.awards LIKE '%Oscar%' )
+                {conditions}
                 AND a.age <= 69 AND a.age >= 45
         ORDER BY
                 m.release_date DESC
@@ -81,3 +88,23 @@ def many_texts_to_objects():
         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}

sql_blocks-0.0.4/sql_blocks/__init__.py

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