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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.0.2
+Version: 0.0.4
 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
@@ -53,10 +53,9 @@ You can specify your own alias:  `a = Select('Actor a')`
     `a = Select( 'Actor a', age=Between(45, 69) )`
 
     3.2 -- Sub-queries:
-
 ```
 query = Select('Movie m', title=Field,
-    id=SubSelect(
+    id=SelectIN(
         'Review r',
         rate=Where.gt(4.5),
         movie_id=Distinct
@@ -85,6 +84,16 @@ query = Select('Movie m', title=Field,
 ```
 > Could be AND=Options(...)
 
+3.4 -- Negative conditions use the _Not_ class instead of _Where_
+```
+based_on_book=Not.is_null()
+```
+
+3.5 -- List of values
+```
+hash_tag=Where.list(['space', 'monster', 'gore'])
+```
+
 ---
 ### 4 - A field can be two things at the same time:
 
@@ -92,7 +101,7 @@ query = Select('Movie m', title=Field,
     - 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:
     ```    
-    SubSelect(
+    SelectIN(
         'Review r', movie=[GroupBy, Distinct],
         rate=Having.avg(Where.gt(4.5))
     )
@@ -274,7 +283,7 @@ m = Select...
 
 9.3
 ```
-best_movies = SubSelect(
+best_movies = SelectIN(
     Review=Table('role'),
     rate=[GroupBy, Having.avg(Where.gt(4.5))]
 )
@@ -292,5 +301,15 @@ m2 = Select(
 **m1 == m2 # --- True!**
 
 ---
----
 
+### 10 - CASE...WHEN...THEN
+    Select(
+        'Product',
+        label=Case('price').when(
+            lt(50), 'cheap'
+        ).when(
+            gt(100), 'expensive'
+        ).else_value(
+            'normal'
+        )
+    )

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

@@ -38,10 +38,9 @@ You can specify your own alias:  `a = Select('Actor a')`
     `a = Select( 'Actor a', age=Between(45, 69) )`
 
     3.2 -- Sub-queries:
-
 ```
 query = Select('Movie m', title=Field,
-    id=SubSelect(
+    id=SelectIN(
         'Review r',
         rate=Where.gt(4.5),
         movie_id=Distinct
@@ -70,6 +69,16 @@ query = Select('Movie m', title=Field,
 ```
 > Could be AND=Options(...)
 
+3.4 -- Negative conditions use the _Not_ class instead of _Where_
+```
+based_on_book=Not.is_null()
+```
+
+3.5 -- List of values
+```
+hash_tag=Where.list(['space', 'monster', 'gore'])
+```
+
 ---
 ### 4 - A field can be two things at the same time:
 
@@ -77,7 +86,7 @@ query = Select('Movie m', title=Field,
     - 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:
     ```    
-    SubSelect(
+    SelectIN(
         'Review r', movie=[GroupBy, Distinct],
         rate=Having.avg(Where.gt(4.5))
     )
@@ -259,7 +268,7 @@ m = Select...
 
 9.3
 ```
-best_movies = SubSelect(
+best_movies = SelectIN(
     Review=Table('role'),
     rate=[GroupBy, Having.avg(Where.gt(4.5))]
 )
@@ -277,5 +286,15 @@ m2 = Select(
 **m1 == m2 # --- True!**
 
 ---
----
 
+### 10 - CASE...WHEN...THEN
+    Select(
+        'Product',
+        label=Case('price').when(
+            lt(50), 'cheap'
+        ).when(
+            gt(100), 'expensive'
+        ).else_value(
+            'normal'
+        )
+    )

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

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

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

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

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

@@ -1,4 +1,6 @@
 from enum import Enum
+import re
+
 
 KEYWORD = {
     'SELECT': (',{}', 'SELECT *'),
@@ -54,9 +56,10 @@ class Field:
 
     @classmethod
     def format(cls, name: str, main: SQLObject) -> str:
+        name = name.strip()
         if name == '_':
             name = '*'
-        else:
+        elif '.' not in name:
             name = f'{main.alias}.{name}'
         if Function in cls.__bases__:
             name = f'{cls.__name__}({name})'
@@ -124,14 +127,19 @@ class ForeignKey:
     def __init__(self, table_name: str):
         self.table_name = table_name
 
+    @staticmethod
+    def get_key(obj1: SQLObject, obj2: SQLObject) -> tuple:
+        return obj1.table_name, obj2.table_name
+
     def add(self, name: str, main: SQLObject):
-        key = f'{main.table_name}_{self.table_name}'
-        ForeignKey.references[key] = name
+        key = self.get_key(main, self)
+        ForeignKey.references[key] = (name, '')
 
     @classmethod
-    def find(cls, obj1: SQLObject, obj2: SQLObject) -> list:
-        key = f'{obj1.table_name}_{obj2.table_name}'
-        return cls.references.get(key, '').split('_')
+    def find(cls, obj1: SQLObject, obj2: SQLObject) -> tuple:
+        key = cls.get_key(obj1, obj2)
+        a, b = cls.references.get(key, ('', ''))
+        return a, (b or obj2.key_field)
 
 
 def quoted(value) -> str:
@@ -314,7 +322,7 @@ class JoinType(Enum):
 
 class Select(SQLObject):
     join_type: JoinType = JoinType.INNER
-    REGEX = None
+    REGEX = {}
 
     def __init__(self, table_name: str='', **values):
         super().__init__(table_name)
@@ -341,17 +349,17 @@ class Select(SQLObject):
             update_values(key, self.values.get(key, []))
 
     def __add__(self, other: SQLObject):
-        foreign_field, *primary_key = ForeignKey.find(self, other)
+        foreign_field, primary_key = ForeignKey.find(self, other)
         if not foreign_field:
-            foreign_field, *primary_key = ForeignKey.find(other, self)
+            foreign_field, primary_key = ForeignKey.find(other, self)
             if foreign_field:
                 if primary_key:
-                    PrimaryKey.add(primary_key[0], self)
+                    PrimaryKey.add(primary_key, self)
                 self.add(foreign_field, other)
                 return other
             raise ValueError(f'No relationship found between {self.table_name} and {other.table_name}.')
         elif primary_key:
-            PrimaryKey.add(primary_key[0], other)
+            PrimaryKey.add(primary_key, other)
         other.add(foreign_field, self)
         return self
 
@@ -391,15 +399,52 @@ class Select(SQLObject):
 
     @classmethod
     def parse(cls, txt: str) -> list[SQLObject]:
-        import re
-        txt = re.sub(' +', ' ', re.sub('\n|\t', ' ', txt))
+        def find_last_word(pos: int) -> int:
+            SPACE, WORD = 1, 2
+            found = set()
+            for i in range(pos, 0, -1):
+                if txt[i] in [' ', '\t', '\n']:
+                    if sum(found) == 3:
+                        return i
+                    found.add(SPACE)
+                if txt[i].isalpha():
+                    found.add(WORD)
+                elif txt[i] == '.':
+                    found.remove(WORD)
+        def find_parenthesis(pos: int) -> int:
+            for i in range(pos, len(txt)-1):
+                if txt[i] == ')':
+                    return i+1
         if not cls.REGEX:
-            keywords = '|'.join(KEYWORD)
-            cls.REGEX = re.compile(f'({keywords})', re.IGNORECASE)
-        tokens = [t.strip() for t in cls.REGEX.split(txt) if t.strip()]
-        values = {k: 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()]
+            keywords = '|'.join(k + r'\b' for k in KEYWORD)
+            flags = re.IGNORECASE + re.MULTILINE
+            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)
+        while found:
+            start, end = found.span()
+            inner = txt[start: end]
+            if inner.count('(') > inner.count(')'):
+                end = find_parenthesis(end)
+                inner = txt[start: end]
+            fld, *inner = re.split(r' IN | in', inner, maxsplit=1)
+            if fld.upper() == 'NOT':
+                pos = find_last_word(start)
+                fld = txt[pos: start].strip() # [To-Do] Use the value of `fld`
+                start = pos
+                class_type = NotSelectIN
+            else:
+                class_type = SelectIN
+            obj = class_type.parse(
+                ' '.join(re.sub(r'^\(', '', s.strip()) for s in inner)
+            )[0]
+            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)]
+        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:
             if '=' in item:
                 a1, f1, a2, f2 = [r.strip() for r in re.split('[().=]', item) if r]
@@ -412,23 +457,55 @@ class Select(SQLObject):
                 for key in USUAL_KEYS:
                     if not key in values:
                         continue
-                    separator = KEYWORD[key][0].format(
-                        ' ' if key == WHERE else ''
-                    )
+                    separator = KEYWORD[key][0].format('')
                     fields = [
-                        fld.strip() for fld in re.split(
+                        Field.format(fld, obj)
+                        for fld in re.split(
                             separator, values[key]
                         ) if len(tables) == 1
-                        or re.findall(f'^[( ]*{obj.alias}\.', fld)
-                    ]
-                    obj.values[key] = [
-                        f'{obj.alias}.{f}' if not '.' in f else f for f in fields
+                        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() )
 
+class SelectIN(Select):
+    condition_class = Where
 
-class SubSelect(Select):
     def add(self, name: str, main: SQLObject):
         self.break_lines = False
-        Where.list(self).add(name, main)
+        self.condition_class.list(self).add(name, main)
+
+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.2 → sql_blocks-0.0.4/sql_blocks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.0.2
+Version: 0.0.4
 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
@@ -53,10 +53,9 @@ You can specify your own alias:  `a = Select('Actor a')`
     `a = Select( 'Actor a', age=Between(45, 69) )`
 
     3.2 -- Sub-queries:
-
 ```
 query = Select('Movie m', title=Field,
-    id=SubSelect(
+    id=SelectIN(
         'Review r',
         rate=Where.gt(4.5),
         movie_id=Distinct
@@ -85,6 +84,16 @@ query = Select('Movie m', title=Field,
 ```
 > Could be AND=Options(...)
 
+3.4 -- Negative conditions use the _Not_ class instead of _Where_
+```
+based_on_book=Not.is_null()
+```
+
+3.5 -- List of values
+```
+hash_tag=Where.list(['space', 'monster', 'gore'])
+```
+
 ---
 ### 4 - A field can be two things at the same time:
 
@@ -92,7 +101,7 @@ query = Select('Movie m', title=Field,
     - 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:
     ```    
-    SubSelect(
+    SelectIN(
         'Review r', movie=[GroupBy, Distinct],
         rate=Having.avg(Where.gt(4.5))
     )
@@ -274,7 +283,7 @@ m = Select...
 
 9.3
 ```
-best_movies = SubSelect(
+best_movies = SelectIN(
     Review=Table('role'),
     rate=[GroupBy, Having.avg(Where.gt(4.5))]
 )
@@ -292,5 +301,15 @@ m2 = Select(
 **m1 == m2 # --- True!**
 
 ---
----
 
+### 10 - CASE...WHEN...THEN
+    Select(
+        'Product',
+        label=Case('price').when(
+            lt(50), 'cheap'
+        ).when(
+            gt(100), 'expensive'
+        ).else_value(
+            'normal'
+        )
+    )

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

@@ -68,8 +68,8 @@ def single_text_to_objects():
 
 def many_texts_to_objects():
     ForeignKey.references = {
-        'Actor_Cast': 'cast_id',
-        'Cast_Movie': 'movie_id',
+        ('Actor', 'Cast'): ('cast', 'id'),
+        ('Cast', 'Movie'): ('movie', 'id'),
     }
     actor = Select.parse('''
         SELECT name as actors_name FROM Actor a