sql-blocks 0.2.4__tar.gz → 0.2.9__tar.gz

{sql_blocks-0.2.4/sql_blocks.egg-info → sql_blocks-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.2.4
+Version: 0.2.9
 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-0.2.4 → sql_blocks-0.2.9}/pyproject.toml

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

{sql_blocks-0.2.4 → sql_blocks-0.2.9}/setup.py

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

{sql_blocks-0.2.4 → sql_blocks-0.2.9}/sql_blocks/sql_blocks.py

@@ -7,20 +7,18 @@ PATTERN_SUFFIX = '( [A-Za-z_]+)'
 DISTINCT_PREFX = '(DISTINCT|distinct)'
 
 KEYWORD = {
-    'SELECT': (',{}', 'SELECT *', DISTINCT_PREFX),
-    'FROM': ('{}', '', PATTERN_SUFFIX),
-    'WHERE': ('{}AND ', '', ''),
-    'GROUP BY': (',{}', '', PATTERN_SUFFIX),
-    'ORDER BY': (',{}', '', PATTERN_SUFFIX),
-    'LIMIT': (' ', '', ''),
-}
-#              ^    ^        ^
-#              |    |        |
-#              |    |        +----- pattern to compare fields
-#              |    |
-#              |    +----- default when empty (SELECT * ...)
-#              |
-#              +-------- separator
+    'SELECT':   (',{}',     DISTINCT_PREFX),
+    'FROM':     ('{}',      PATTERN_SUFFIX),
+    'WHERE':    ('{}AND ',  ''),
+    'GROUP BY': (',{}',     PATTERN_SUFFIX),
+    'ORDER BY': (',{}',     PATTERN_SUFFIX),
+    'LIMIT':    (' ',       ''),
+}                                                    
+#                  ^          ^
+#                  |          |
+#                  |          +----- pattern to compare fields
+#                  |
+#                  +-------- separator
 
 SELECT, FROM, WHERE, GROUP_BY, ORDER_BY, LIMIT = KEYWORD.keys()
 USUAL_KEYS = [SELECT, WHERE, GROUP_BY, ORDER_BY, LIMIT]
@@ -69,27 +67,34 @@ 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:
+            if not exact:
+                return source
+            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][1] 
+        if exact:
+            if key == WHERE:
+                pattern = r'["\']| '
+            pattern += f'|{PATTERN_PREFIX}'
+        separator = self.get_separator(key)
         s1 = field_set(search_list)
         s2 = field_set(self.values.get(key, []))
         if exact:
@@ -413,6 +418,222 @@ class Rule:
     def apply(cls, target: 'Select'):
         ...
 
+class QueryLanguage:
+    pattern = '{select}{_from}{where}{group_by}{order_by}'
+    has_default = {key: bool(key == SELECT) for key in KEYWORD}
+
+    @staticmethod
+    def remove_alias(fld: str) -> str:
+        return ''.join(re.split(r'\w+[.]', fld))
+
+    def join_with_tabs(self, values: list, sep: str='') -> str:
+        sep = sep + self.TABULATION
+        return sep.join(v for v in values if v)
+
+    def add_field(self, values: list) -> str:
+        if not values:
+            return '*'
+        return  self.join_with_tabs(values, ',')
+
+    def get_tables(self, values: list) -> str:
+        return  self.join_with_tabs(values)
+
+    def extract_conditions(self, values: list) -> str:
+        return  self.join_with_tabs(values, ' AND ')
+
+    def sort_by(self, values: list) -> str:
+        return  self.join_with_tabs(values)
+
+    def set_group(self, values: list) -> str:
+        return  self.join_with_tabs(values, ',')
+
+    def __init__(self, target: 'Select'):
+        self.KEYWORDS = [SELECT, FROM, WHERE, GROUP_BY, ORDER_BY]
+        self.TABULATION = '\n\t' if target.break_lines else ' '
+        self.LINE_BREAK = '\n' if target.break_lines else ' '
+        self.TOKEN_METHODS = {
+            SELECT: self.add_field, FROM: self.get_tables, 
+            WHERE: self.extract_conditions,
+            ORDER_BY: self.sort_by, GROUP_BY: self.set_group,
+        }
+        self.result = {}
+        self.target = target
+
+    def pair(self, key: str) -> str:
+        if key == FROM:
+            return '_from'
+        return key.lower().replace(' ', '_')
+
+    def prefix(self, key: str) -> str:
+        return self.LINE_BREAK + key + self.TABULATION
+
+    def convert(self) -> str:
+        for key in self.KEYWORDS:
+            method = self.TOKEN_METHODS.get(key)
+            ref = self.pair(key)
+            values = self.target.values.get(key, [])
+            if not method or (not values and not self.has_default[key]):
+                self.result[ref] = ''
+                continue
+            text = self.prefix(key) + method(values)
+            self.result[ref] = text
+        return self.pattern.format(**self.result).strip()
+
+class MongoDBLanguage(QueryLanguage):
+    pattern = '{_from}.{function}({where}{select}{group_by}){order_by}'
+    has_default = {key: False for key in KEYWORD}
+    LOGICAL_OP_TO_MONGO_FUNC = {
+        '>': '$gt',  '>=': '$gte',
+        '<': '$lt',  '<=': '$lte',
+        '=': '$eq',  '<>': '$ne',
+    }
+    OPERATORS = '|'.join(op for op in LOGICAL_OP_TO_MONGO_FUNC)
+    REGEX = {
+        'options': re.compile(r'\s+or\s+|\s+OR\s+'),
+        'condition': re.compile(fr'({OPERATORS})')
+    }
+
+    def join_with_tabs(self, values: list, sep: str=',') -> str:
+        def format_field(fld):
+            return '{indent}{fld}'.format(
+                fld=self.remove_alias(fld),
+                indent=self.TABULATION
+            )
+        return '{begin}{content}{line_break}{end}'.format(
+            begin='{',
+            content= sep.join(
+                format_field(fld) for fld in values if fld
+            ),
+            end='}', line_break=self.LINE_BREAK,
+        )
+
+    def add_field(self, values: list) -> str:
+        if self.result['function'] == 'aggregate':
+            return ''
+        return ',{content}'.format(
+            content=self.join_with_tabs([f'{fld}: 1' for fld in values]),
+        )
+
+    def get_tables(self, values: list) -> str:
+        return values[0].split()[0].lower()
+
+    @classmethod
+    def mongo_where_list(cls, values: list) -> list:
+        OR_REGEX = cls.REGEX['options']
+        where_list = []
+        for condition in values:
+            if OR_REGEX.findall(condition):
+                condition = re.sub('[()]', '', condition)
+                expr = '{begin}$or: [{content}]{end}'.format(
+                    content=','.join(
+                        cls.mongo_where_list( OR_REGEX.split(condition) )
+                    ), begin='{', end='}',
+                )
+                where_list.append(expr)
+                continue
+            tokens = cls.REGEX['condition'].split( 
+                cls.remove_alias(condition) 
+            )
+            tokens = [t.strip() for t in tokens if t]
+            field, *op, const = tokens
+            op = ''.join(op)
+            expr = '{begin}{op}:{const}{end}'.format(
+                begin='{', const=const, end='}',
+                op=cls.LOGICAL_OP_TO_MONGO_FUNC[op],                
+            )
+            where_list.append(f'{field}:{expr}')
+        return where_list
+    
+    def extract_conditions(self, values: list) -> str:
+        return self.join_with_tabs(
+            self.mongo_where_list(values)
+        )
+
+    def sort_by(self, values: list) -> str:
+        return  ".sort({begin}{indent}{field}:{flag}{line_break}{end})".format(
+            begin='{', field=self.remove_alias(values[0].split()[0]), 
+            flag=-1 if OrderBy.sort == SortType.DESC else 1,
+            end='}', indent=self.TABULATION, line_break=self.LINE_BREAK,
+        )
+
+    def set_group(self, values: list) -> str:
+        self.result['function'] = 'aggregate'
+        return '{"$group" : {_id:"$%%", count:{$sum:1}}}'.replace(
+            '%%', self.remove_alias( values[0] )
+        )
+    
+    def __init__(self, target: 'Select'):
+        super().__init__(target)
+        self.result['function'] = 'find'
+        self.KEYWORDS = [GROUP_BY, SELECT, FROM, WHERE, ORDER_BY]
+
+    def prefix(self, key: str):
+        return ''
+
+
+class Neo4JLanguage(QueryLanguage):
+    pattern = 'MATCH {_from} RETURN {aliases}'
+    has_default = {key: False for key in KEYWORD}
+
+    def add_field(self, values: list) -> str:
+        return ''
+
+    def get_tables(self, values: list) -> str:
+        NODE_FORMAT = dict(
+            left='({}:{}{})<-',
+            core='[{}:{}{}]',
+            right='->({}:{}{})'
+        )
+        nodes = {k: '' for k in NODE_FORMAT}
+        for txt in values:
+            found = re.search(
+                r'^(left|right)\s+', txt, re.IGNORECASE
+            )
+            pos = 'core'
+            if found:
+                start, end = found.span()
+                pos = txt[start:end-1].lower()
+                tokens = re.split(r'JOIN\s+|ON\s+', txt[end:])
+                txt = tokens[1].strip()
+            table_name, *alias = txt.split()
+            if alias:
+                alias = alias[0]
+            else:
+                alias = SQLObject.ALIAS_FUNC(table_name)
+            condition = self.aliases.get(alias, '')
+            if not condition:
+                self.aliases[alias] = ''
+            nodes[pos] = NODE_FORMAT[pos].format(alias, table_name, condition)
+        self.result['aliases'] = ','.join(self.aliases.keys())
+        return '{left}{core}{right}'.format(**nodes)
+
+    def extract_conditions(self, values: list) -> str:
+        for condition in values:
+            other_comparisions = any(
+                char in condition for char in '<>%'
+            )
+            if '=' not in condition or other_comparisions:
+                raise NotImplementedError('Only comparisons with equality are available for now.')
+            alias, field, const = re.split(r'[.=]', condition)
+            begin, end = '{', '}'
+            self.aliases[alias] = f'{begin}{field}:{const}{end}'
+        return ''  # --- WHERE [*other_comparisions*] ...
+
+    def sort_by(self, values: list) -> str:
+        return ''
+
+    def set_group(self, values: list) -> str:
+        return ''
+
+    def __init__(self, target: 'Select'):
+        super().__init__(target)
+        self.aliases = {}
+        self.KEYWORDS = [WHERE, FROM]
+
+    def prefix(self, key: str):
+        return ''
+
+
 class Parser:
     REGEX = {}
 
@@ -421,14 +642,37 @@ 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 JoinType(Enum):
+    INNER = ''
+    LEFT = 'LEFT '
+    RIGHT = 'RIGHT '
+    FULL = 'FULL '
+
 
 class SQLParser(Parser):
     REGEX = {}
@@ -506,21 +750,24 @@ 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.new_query,  '<-': self.left_ftable,
+            '->': self.right_ftable,
         }
+        self.method = self.new_query
 
-    def new_query(self, token: str):
+    def new_query(self, token: str, join_type = JoinType.INNER):
         if token.isidentifier():
-            self.queries.append( self.class_type(token) )
+            query = self.class_type(token)
+            self.queries.append(query)
+            query.join_type = join_type
 
     def add_where(self, token: str):
         field, *condition = [
@@ -535,37 +782,76 @@ class Cypher(Parser):
         FieldList(token, [Field]).add('', self.queries[-1])
 
     def left_ftable(self, token: str):
+        if self.queries:
+            self.queries[-1].join_type = JoinType.LEFT
         self.new_query(token)
-        self.join_type = JoinType.LEFT
 
     def right_ftable(self, token: str):
-        self.new_query(token)
-        self.join_type = JoinType.RIGHT
+        self.new_query(token, 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 self.join_type == JoinType.RIGHT:
+        if not pk_field:
+            if not last.values.get(SELECT):
+                raise IndexError(f'Primary Key not found for {last.table_name}.')
+            pk_field = last.values[SELECT][-1].split('.')[-1]
+            last.delete(pk_field, [SELECT])
+        if '{}' in token:
+            foreign_fld = token.format(
+                last.table_name.lower()
+                if last.join_type == JoinType.LEFT else
+                curr.table_name.lower()
+            )
+        else:
+            if not curr.values.get(SELECT):
+                raise IndexError(f'Foreign Key not found for {curr.table_name}.')
+            foreign_fld = curr.values[SELECT][0].split('.')[-1]
+            curr.delete(foreign_fld, [SELECT])
+        if curr.join_type == JoinType.RIGHT:
             curr, last = last, curr
-            pk_field, token = token, pk_field
-        last.key_field = pk_field
-        k = ForeignKey.get_key(last, curr)
-        ForeignKey.references[k] = (pk_field, token)
-        self.join_type = JoinType.INNER
+        k = ForeignKey.get_key(curr, last)
+        ForeignKey.references[k] = (foreign_fld, pk_field)
+
+    def fk_charset(self) -> str:
+        return '(['
 
     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) ):
-            if not token:
+        # ====================================
+        def has_side_table() -> bool:
+            count = 0 if len(self.queries) < 2 else sum(
+                q.join_type != JoinType.INNER
+                for q in self.queries[-2:]
+            )
+            return count > 0
+        # -----------------------------------
+        for token in self.get_tokens(txt):
+            if not token or (token in '([' and self.method):
                 continue
             if self.method:
                 self.method(token)
-            if token == '(' and self.join_type != JoinType.INNER:
-                self.method = self.add_foreign_key
-            else:
-                self.method = self.TOKEN_METHODS.get(token)
+            if token in ')]' and has_side_table():
+                self.add_foreign_key('')
+            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, join_type = JoinType.INNER):
+        super().new_query(token.split(':')[-1], join_type)
+
+    def add_where(self, token: str):
+        super().add_where(token.replace(':', '='))
+
+    def add_foreign_key(self, token: str, pk_field: str='') -> tuple:
+        return super().add_foreign_key('{}_id', 'id')
 
 # ----------------------------
 class MongoParser(Parser):
@@ -669,7 +955,7 @@ class MongoParser(Parser):
         self.TOKEN_METHODS = {
             '{': self.get_param, ',': self.next_param, ')': 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:
@@ -684,12 +970,6 @@ class MongoParser(Parser):
 # ----------------------------
 
 
-class JoinType(Enum):
-    INNER = ''
-    LEFT = 'LEFT '
-    RIGHT = 'RIGHT '
-    FULL = 'FULL '
-
 class Select(SQLObject):
     join_type: JoinType = JoinType.INNER
     REGEX = {}
@@ -739,16 +1019,7 @@ class Select(SQLObject):
         return query
 
     def __str__(self) -> str:
-        TABULATION = '\n\t' if self.break_lines else ' '
-        LINE_BREAK = '\n' if self.break_lines else ' '
-        DEFAULT = lambda key: KEYWORD[key][1]
-        FMT_SEP = lambda key: KEYWORD[key][0].format(TABULATION)
-        select, _from, where, groupBy, orderBy, limit = [
-            DEFAULT(key) if not self.values.get(key) else "{}{}{}{}".format(
-                LINE_BREAK, key, TABULATION, FMT_SEP(key).join(self.values[key])
-            ) for key in KEYWORD
-        ]
-        return f'{select}{_from}{where}{groupBy}{orderBy}{limit}'.strip()
+        return self.translate_to(QueryLanguage)
    
     def __call__(self, **values):
         to_list = lambda x: x if isinstance(x, list) else [x]
@@ -791,6 +1062,8 @@ class Select(SQLObject):
             class_types += [GroupBy]
         FieldList(fields, class_types).add('', self)
 
+    def translate_to(self, language: QueryLanguage) -> str:
+        return language(self).convert()
 
 
 class SelectIN(Select):
@@ -818,7 +1091,7 @@ 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))
+            tokens = re.split(r'\s+or\s+|\s+OR\s+', re.sub('\n|\t|[()]', ' ', condition))
             if len(tokens) < 2:
                 continue
             fields = [t.split('=')[0].split('.')[-1].lower().strip() for t in tokens]
@@ -864,7 +1137,7 @@ class RuleDateFuncReplace(Rule):
     """
     SQL algorithm by Ralff Matias
     """
-    REGEX = re.compile(r'(\bYEAR[(]|\byear[(]|=|[)])')
+    REGEX = re.compile(r'(YEAR[(]|year[(]|=|[)])')
 
     @classmethod
     def apply(cls, target: Select):

{sql_blocks-0.2.4 → sql_blocks-0.2.9/sql_blocks.egg-info}/PKG-INFO

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