sql-blocks 0.2.3__py3-none-any.whl → 0.2.6__py3-none-any.whl

sql_blocks/sql_blocks.py

@@ -9,7 +9,7 @@ DISTINCT_PREFX = '(DISTINCT|distinct)'
 KEYWORD = {
     'SELECT': (',{}', 'SELECT *', DISTINCT_PREFX),
     'FROM': ('{}', '', PATTERN_SUFFIX),
-    'WHERE': ('{}AND ', '', ''),
+    'WHERE': ('{}AND ', '', r'["\']'),
     'GROUP BY': (',{}', '', PATTERN_SUFFIX),
     'ORDER BY': (',{}', '', PATTERN_SUFFIX),
     'LIMIT': (' ', '', ''),
@@ -69,27 +69,32 @@ class SQLObject:
         return KEYWORD[key][0].format(appendix.get(key, ''))
 
     def diff(self, key: str, search_list: list, exact: bool=False) -> set:
+        def disassemble(source: list) -> list:
+            result = []
+            for fld in source:
+                result += re.split(r'([=()]|<>|\s+ON\s+|\s+on\s+)', fld)
+            return result
         def cleanup(fld: str) -> str:
             if exact:
                 fld = fld.lower()
             return fld.strip()
         def is_named_field(fld: str) -> bool:
             return key == SELECT and re.search(' as | AS ', fld)
-        pattern = KEYWORD[key][2] 
-        if exact:
-            if key == WHERE:
-                pattern = ' '
-            pattern += f'|{PATTERN_PREFIX}'
-        separator = self.get_separator(key)
         def field_set(source: list) -> set:
             return set(
                 (
                     fld if is_named_field(fld) else
                     re.sub(pattern, '', cleanup(fld))
                 )
-                for string in source
+                for string in disassemble(source)
                 for fld in re.split(separator, string)
             )       
+        pattern = KEYWORD[key][2] 
+        if exact:
+            if key == WHERE:
+                pattern = ' '
+            pattern += f'|{PATTERN_PREFIX}'
+        separator = self.get_separator(key)
         s1 = field_set(search_list)
         s2 = field_set(self.values.get(key, []))
         if exact:
@@ -421,14 +426,30 @@ class Parser:
 
     def __init__(self, txt: str, class_type):
         self.queries = []
-        if not self.REGEX:
-            self.prepare()
+        self.prepare()
         self.class_type = class_type
         self.eval(txt)
 
     def eval(self, txt: str):
         ...
 
+    @staticmethod
+    def remove_spaces(script: str) -> str:
+        is_string = False
+        result = []
+        for token in re.split(r'(")', script):
+            if token == '"':
+                is_string = not is_string
+            if not is_string:
+                token = re.sub(r'\s+', '', token)
+            result.append(token)
+        return ''.join(result)
+
+    def get_tokens(self, txt: str) -> list:
+        return self.REGEX['separator'].split(
+            self.remove_spaces(txt)
+        )
+
 
 class SQLParser(Parser):
     REGEX = {}
@@ -506,17 +527,18 @@ class SQLParser(Parser):
 
 class Cypher(Parser):
     REGEX = {}
-    TOKEN_METHODS = {}
 
     def prepare(self):
-        self.REGEX['separator'] = re.compile(r'([(,?)^]|->|<-)')
+        self.REGEX['separator'] = re.compile(r'([(,?)^{}[\]]|->|<-)')
         self.REGEX['condition'] = re.compile(r'(^\w+)|([<>=])')
+        self.join_type = JoinType.INNER
         self.TOKEN_METHODS = {
             '(': self.add_field,  '?': self.add_where,
             ',': self.add_field,  '^': self.add_order,
             ')': self.new_query,  '->': self.left_ftable,
             '<-': self.right_ftable,
         }
+        self.method = self.new_query
 
     def new_query(self, token: str):
         if token.isidentifier():
@@ -542,31 +564,170 @@ class Cypher(Parser):
         self.new_query(token)
         self.join_type = JoinType.RIGHT
 
-    def add_foreign_key(self, token: str):
+    def add_foreign_key(self, token: str, pk_field: str=''):
         curr, last = [self.queries[i] for i in (-1, -2)]
-        pk_field = last.values[SELECT][-1].split('.')[-1]
-        last.delete(pk_field, [SELECT])
+        if not pk_field:
+            if not last.values.get(SELECT):
+                return
+            pk_field = last.values[SELECT][-1].split('.')[-1]
+            last.delete(pk_field, [SELECT])
         if self.join_type == JoinType.RIGHT:
             curr, last = last, curr
-            pk_field, token = token, pk_field
-        last.key_field = pk_field
+        if '{}' in token:
+            token = token.format(
+                curr.table_name.lower()
+            )
         k = ForeignKey.get_key(last, curr)
-        ForeignKey.references[k] = (pk_field, token)
+        ForeignKey.references[k] = (token, pk_field)
         self.join_type = JoinType.INNER
 
     def eval(self, txt: str):
-        self.join_type = JoinType.INNER
-        self.method = self.new_query
-        for token in self.REGEX['separator'].split( re.sub(r'\s+', '', txt) ):
+        for token in self.get_tokens(txt):
             if not token:
                 continue
             if self.method:
                 self.method(token)
-            if token == '(' and self.join_type != JoinType.INNER:
+            if token in '([' and self.join_type != JoinType.INNER:
                 self.method = self.add_foreign_key
             else:
                 self.method = self.TOKEN_METHODS.get(token)
 
+class Neo4JParser(Cypher):
+    def prepare(self):
+        super().prepare()
+        self.TOKEN_METHODS = {
+            '(': self.new_query,  '{': self.add_where,
+            '->': self.left_ftable, '<-': self.right_ftable,
+            '[': self.new_query
+        }
+        self.method = None
+
+    def new_query(self, token: str):
+        super().new_query(token.split(':')[-1])
+
+    def add_where(self, token: str):
+        super().add_where(token.replace(':', '='))
+
+    def add_foreign_key(self, token: str, pk_field: str='') -> tuple:
+        self.new_query(token)
+        return super().add_foreign_key('{}_id', 'id')
+
+# ----------------------------
+class MongoParser(Parser):
+    REGEX = {}
+
+    def prepare(self):
+        self.REGEX['separator'] = re.compile(r'([({[\]},)])')
+
+    def new_query(self, token: str):
+        if not token:
+            return
+        *table, function = token.split('.')
+        self.param_type = self.PARAM_BY_FUNCTION.get(function)
+        if not self.param_type:            
+            raise SyntaxError(f'Unknown function {function}')
+        if table and table[0]:
+            self.queries.append( self.class_type(table[-1]) )
+
+    def param_is_where(self) -> bool:
+        return self.param_type == Where or isinstance(self.param_type, Where)
+
+    def next_param(self, token: str):
+        if self.param_type == GroupBy:
+            self.param_type = Field
+        self.get_param(token)
+
+    def get_param(self, token: str):
+        if not ':' in token:
+            return
+        field, value = token.split(':')
+        is_function = field.startswith('$')
+        if not value and not is_function:
+            if self.param_is_where():
+                self.last_field = field
+            return
+        if self.param_is_where():
+            if is_function:
+                function = field
+                field = self.last_field
+                self.last_field = ''
+            else:
+                function = '$eq'
+            if '"' in value:
+                value = value.replace('"', '')
+            elif value and value[0].isnumeric():
+                numeric_type = float if len(value.split('.')) == 2 else int
+                value = numeric_type(value)
+            self.param_type = self.CONDITIONS[function](value)
+            if function == '$or':
+                return
+        elif self.param_type == GroupBy:
+            if field != '_id':
+                return
+            field = re.sub('"|[$]', '', value)
+        elif self.param_type == OrderBy and value == '-1':
+            OrderBy.sort = SortType.DESC
+        elif field.startswith('$'):
+            field = '{}({})'.format(
+                field.replace('$', ''), value
+            )
+        if self.where_list is not None and self.param_is_where():
+            self.where_list[field] = self.param_type
+            return
+        self.param_type.add(field, self.queries[-1])
+
+    def close_brackets(self, token: str):
+        self.brackets[token] -= 1
+        if self.param_is_where() and self.brackets[token] == 0:
+            if self.where_list is not None:
+                Options(**self.where_list).add('OR', self.queries[-1])
+                self.where_list = None
+            if token == '{':
+                self.param_type = Field
+
+    def begin_conditions(self, value: str):
+        self.where_list = {}
+        return Where
+
+    def increment_brackets(self, value: str):
+        self.brackets[value] += 1
+
+    def eval(self, txt: str):
+        self.method = self.new_query
+        self.last_field = ''
+        self.where_list = None
+        self.PARAM_BY_FUNCTION = {
+            'find': Where, 'aggregate': GroupBy, 'sort': OrderBy
+        }
+        BRACKET_PAIR = {'}': '{', ']': '['}
+        self.brackets = {char: 0 for char in BRACKET_PAIR.values()}
+        self.CONDITIONS = {
+            '$in': lambda value: contains(value),
+            '$gt': lambda value: gt(value),
+            '$gte' : lambda value: gte(value),
+            '$lt': lambda value: lt(value),
+            '$lte' : lambda value: lte(value),
+            '$eq': lambda value: eq(value),
+            '$ne': lambda value: Not.eq(value),
+            '$or': self.begin_conditions,
+        }
+        self.TOKEN_METHODS = {
+            '{': self.get_param, ',': self.next_param, ')': self.new_query, 
+        }
+        for token in self.get_tokens(txt):
+            if not token:
+                continue
+            if self.method:
+                self.method(token)
+            if token in self.brackets:
+                self.increment_brackets(token)
+            elif token in BRACKET_PAIR:
+                self.close_brackets(
+                    BRACKET_PAIR[token]
+                )
+            self.method = self.TOKEN_METHODS.get(token)
+# ----------------------------
+
 
 class JoinType(Enum):
     INNER = ''

{sql_blocks-0.2.3.dist-info → sql_blocks-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.2.3
+Version: 0.2.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
@@ -381,3 +381,39 @@ m2 = Select(
         created_at=[Field, GroupBy, OrderBy]
     )
 ```
+
+### 13 - Change parser engine
+```
+a, c, m = Select.parse(
+    """
+        Actor(name, id ?age = 40)
+        <- Cast(actor_id, movie_id) ->
+        Movie(id ^title)
+    """,
+    Cypher 
+    # ^^^ recognizes syntax like Neo4J queries
+)
+```
+
+**print(a+c+m)**
+```
+SELECT
+        act.name,
+        mov.title
+FROM
+        Cast cas
+        JOIN Movie mov ON (cas.movie_id = mov.id)
+        JOIN Actor act ON (cas.actor_id = act.id)
+WHERE
+        act.age = 40
+ORDER BY
+        mov.title
+```
+---
+> **Separators and meaning:**
+* `(  )`  Delimits a table and its fields
+* `,` Separate fields
+* `?` For simple conditions (> < = <>)
+* `<-` connects to the table on the left
+* `->` connects to the table on the right
+* `^` Put the field in the ORDER BY clause

sql_blocks-0.2.6.dist-info/RECORD

@@ -0,0 +1,7 @@
+sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
+sql_blocks/sql_blocks.py,sha256=IT3XUhBdOA1MawoSaw-oMm1v4yv16fDwqcu21sGnIQs,30086
+sql_blocks-0.2.6.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+sql_blocks-0.2.6.dist-info/METADATA,sha256=4A--jCZFBGeVn_fXcF41szBc_4ReMJrVKr9WWqJZnZA,9675
+sql_blocks-0.2.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sql_blocks-0.2.6.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
+sql_blocks-0.2.6.dist-info/RECORD,,

sql_blocks-0.2.3.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=xWP7coiy5Tj8YU_WgtkN8J8tc9-0_BaE-bYljPdEp6o,24361
-sql_blocks-0.2.3.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-0.2.3.dist-info/METADATA,sha256=0bRpoB8KehBZ40kf-pXyOvrVcozTUZo-BsC3Aq5xn2I,8892
-sql_blocks-0.2.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-0.2.3.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-0.2.3.dist-info/RECORD,,