sql-blocks 1.25.518999999999__py3-none-any.whl → 1.25.610999999999__py3-none-any.whl

sql_blocks/sql_blocks.py

@@ -103,10 +103,16 @@ class SQLObject:
                 result += re.split(r'([=()]|<>|\s+ON\s+|\s+on\s+)', fld)
             return result
         def cleanup(text: str) -> str:
+            if re.search(r'^CASE\b', text):
+                return text
             text = re.sub(r'[\n\t]', ' ', text)
             if exact:
                 text = text.lower()
             return text.strip()
+        def split_fields(text: str) -> list:
+            if key == SELECT:
+                return Case.parse(text)
+            return re.split(separator, text)
         def field_set(source: list) -> set:
             return set(
                 (
@@ -116,7 +122,7 @@ class SQLObject:
                     re.sub(pattern, '', cleanup(fld))
                 )
                 for string in disassemble(source)
-                for fld in re.split(separator, string)
+                for fld in split_fields(string)
             )       
         pattern = KEYWORD[key][1] 
         if exact:
@@ -131,6 +137,7 @@ class SQLObject:
         return s1 - s2
 
     def delete(self, search: str, keys: list=USUAL_KEYS, exact: bool=False):
+        search = re.escape(search)
         if exact:
             not_match = lambda item: not re.search(fr'\w*[.]*{search}$', item)
         else:
@@ -641,11 +648,19 @@ class Case:
         self.__conditions = {}
         self.default = None
         self.field = field
+        self.current_condition = None
+        self.fields = []
 
-    def when(self, condition: Where, result):
+    def when(self, condition: Where, result=None):
+        self.current_condition = condition
+        if result is None:            
+            return self
+        return self.then(result)
+    
+    def then(self, result):
         if isinstance(result, str):
             result = quoted(result)
-        self.__conditions[result] = condition
+        self.__conditions[result] = self.current_condition
         return self
     
     def else_value(self, default):
@@ -654,17 +669,67 @@ class Case:
         self.default = default
         return self
     
-    def add(self, name: str, main: SQLObject):
-        field = Field.format(self.field, main)
+    def format(self, name: str, field: str='') -> str:
         default = self.default
-        name = 'CASE \n{}\n\tEND AS {}'.format(
+        if not field:
+            field = self.field
+        return 'CASE \n{}\n\tEND AS {}'.format(
             '\n'.join(
                 f'\t\tWHEN {field} {cond.content} THEN {res}'
                 for res, cond in self.__conditions.items()
             ) + (f'\n\t\tELSE {default}' if default else ''),
             name
         )
-        main.values.setdefault(SELECT, []).append(name)
+
+    def add(self, name: str, main: SQLObject):
+        main.values.setdefault(SELECT, []).append(
+            self.format(
+                name, Field.format(self.field, main)
+            )
+        )
+
+    @classmethod
+    def parse(cls, expr: str) -> list:
+        result = []
+        block: 'Case' = None        
+        # ---- functions of keywords: -----------------
+        def _when(word: str):
+            field, condition = word.split(' ', maxsplit=1)
+            condition = Where(condition)
+            if not block:
+                return cls(field).when(condition)
+            return block.when(condition)
+        def _then(word: str):
+            return block.then( eval(word) )
+        def _else(word: str):
+            return block.else_value( eval(word) )
+        def _end(word: str):
+            name, *rest = [t.strip() for t in re.split(r'\s+AS\s+|[,]', word) if t]
+            block.fields.append(
+                block.format(name)
+            )
+            block.fields += rest
+            return block
+        # -------------------------------------------------
+        KEYWORDS = {
+            'WHEN': _when, 'THEN': _then,
+            'ELSE': _else, 'END':  _end,
+        }
+        RESERVED_WORDS = ['CASE'] + list(KEYWORDS)
+        REGEX = '|'.join(fr'\b{word}\b' for word in RESERVED_WORDS)
+        expr = re.sub(r'\s+', ' ', expr)
+        tokens = [t for t in re.split(f'({REGEX})', expr) if t.strip()]
+        last_word = ''
+        while tokens:
+            word = tokens.pop(0)
+            if last_word in KEYWORDS:
+                block = KEYWORDS[last_word](word)
+                result += block.fields
+                block.fields = []
+            elif word not in RESERVED_WORDS:
+                result.append(word)
+            last_word = word
+        return result
 
 
 class Options:
@@ -1437,7 +1502,11 @@ class CypherParser(Parser):
                     raise ValueError(f'Unknown function `{func_name}`.')
                 if ':' in token:
                     token, field_alias = token.split(':')
-                    class_type = class_type().As(field_alias)
+                    if extra_classes == [OrderBy]:
+                        class_type = class_type().As(field_alias, OrderBy)
+                        extra_classes = []
+                    else:
+                        class_type = class_type().As(field_alias)
                 class_list = [class_type]
         class_list += extra_classes
         FieldList(token, class_list).add('', self.queries[-1])
@@ -2043,20 +2112,3 @@ def detect(text: str, join_queries: bool = True, format: str='') -> Select | lis
 # ===========================================================================================//
 
 
-if __name__ == "__main__":
-    query = detect("""
-        SELECT
-            e.gender, d.region,
-            Avg(e.age)
-        FROM
-            Employees e
-            JOIN Departments d ON (e.depto_id = d.id)
-        WHERE
-            e.name LIKE 'A%'
-        GROUP BY
-            e.gender, d.region
-        ORDER BY
-            d.region DESC
-    """)
-    PandasLanguage.file_extension = FileExtension.XLSX
-    print( query.translate_to(PandasLanguage) )

{sql_blocks-1.25.518999999999.dist-info → sql_blocks-1.25.610999999999.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 1.25.518999999999
+Version: 1.25.610999999999
 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

sql_blocks-1.25.610999999999.dist-info/RECORD

@@ -0,0 +1,7 @@
+sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
+sql_blocks/sql_blocks.py,sha256=tdfGConHw2iosex_BSXAWxYTGufPyOVMSTyi3g6gqpM,71400
+sql_blocks-1.25.610999999999.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+sql_blocks-1.25.610999999999.dist-info/METADATA,sha256=09DIeKq_SinVNKt0OyYQQDOZ2_DDR6CmoP_n99t4ZXA,22235
+sql_blocks-1.25.610999999999.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sql_blocks-1.25.610999999999.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
+sql_blocks-1.25.610999999999.dist-info/RECORD,,

sql_blocks-1.25.518999999999.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=UOjajzxiH5_aS_P_Xr5hPYCxOl7W-vw2u4Jdjps7phw,69333
-sql_blocks-1.25.518999999999.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-1.25.518999999999.dist-info/METADATA,sha256=mnArOHyZC4RZFRliEmbybSiZaYz-4ciaSFNbHaODG-I,22235
-sql_blocks-1.25.518999999999.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-1.25.518999999999.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-1.25.518999999999.dist-info/RECORD,,