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

sql_blocks/sql_blocks.py

@@ -4,15 +4,14 @@ import re
 
 PATTERN_PREFIX = '([^0-9 ]+[.])'
 PATTERN_SUFFIX = '( [A-Za-z_]+)'
-SUFFIX_AND_PRE = f'{PATTERN_SUFFIX}|{PATTERN_PREFIX}'
-DISTINCT_PREFX = f'(DISTINCT|distinct)|{PATTERN_PREFIX}'
+DISTINCT_PREFX = '(DISTINCT|distinct)'
 
 KEYWORD = {
     'SELECT': (',{}', 'SELECT *', DISTINCT_PREFX),
     'FROM': ('{}', '', PATTERN_SUFFIX),
     'WHERE': ('{}AND ', '', ''),
-    'GROUP BY': (',{}', '', SUFFIX_AND_PRE),
-    'ORDER BY': (',{}', '', SUFFIX_AND_PRE),
+    'GROUP BY': (',{}', '', PATTERN_SUFFIX),
+    'ORDER BY': (',{}', '', PATTERN_SUFFIX),
     'LIMIT': (' ', '', ''),
 }
 #              ^    ^        ^
@@ -69,16 +68,18 @@ class SQLObject:
         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:
+    def diff(self, key: str, search_list: list, exact: bool=False) -> set:
         def cleanup(fld: str) -> str:
-            if symmetrical:
+            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 key == WHERE and symmetrical:
-            pattern = f'{PATTERN_PREFIX}| '
+        if exact:
+            if key == WHERE:
+                pattern = ' '
+            pattern += f'|{PATTERN_PREFIX}'
         separator = self.get_separator(key)
         def field_set(source: list) -> set:
             return set(
@@ -91,7 +92,7 @@ class SQLObject:
             )       
         s1 = field_set(search_list)
         s2 = field_set(self.values.get(key, []))
-        if symmetrical:
+        if exact:
             return s1.symmetric_difference(s2)
         return s1 - s2
 
@@ -412,6 +413,160 @@ class Rule:
     def apply(cls, target: 'Select'):
         ...
 
+class Parser:
+    REGEX = {}
+
+    def prepare(self):
+        ...
+
+    def __init__(self, txt: str, class_type):
+        self.queries = []
+        if not self.REGEX:
+            self.prepare()
+        self.class_type = class_type
+        self.eval(txt)
+
+    def eval(self, txt: str):
+        ...
+
+
+class SQLParser(Parser):
+    REGEX = {}
+
+    def prepare(self):
+        keywords = '|'.join(k + r'\b' for k in KEYWORD)
+        flags = re.IGNORECASE + re.MULTILINE
+        self.REGEX['keywords'] = re.compile(f'({keywords}|[*])', flags)
+        self.REGEX['subquery'] = re.compile(r'(\w\.)*\w+ +in +\(SELECT.*?\)', flags)
+
+    def eval(self, txt: str):
+        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
+        result = {}
+        found = self.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-1]
+            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
+                target_class = NotSelectIN
+            else:
+                target_class = SelectIN
+            obj = SQLParser(
+                ' '.join(re.sub(r'^\(', '', s.strip()) for s in inner),
+                class_type=target_class
+            ).queries[0]
+            result[obj.alias] = obj
+            txt = txt[:start-1] + txt[end+1:]
+            found = self.REGEX['subquery'].search(txt)
+        tokens = [t.strip() for t in self.REGEX['keywords'].split(txt) if t.strip()]
+        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]
+                obj1: SQLObject = result[a1]
+                obj2: SQLObject = result[a2]
+                PrimaryKey.add(f2, obj2)
+                ForeignKey(obj2.table_name).add(f1, obj1)
+            else:
+                obj = self.class_type(item)
+                for key in USUAL_KEYS:
+                    if not key in values:
+                        continue
+                    separator = self.class_type.get_separator(key)
+                    obj.values[key] = [
+                        Field.format(fld, obj)
+                        for fld in re.split(separator, values[key])
+                        if (fld != '*' and len(tables) == 1) or obj.match(fld)
+                    ]
+                result[obj.alias] = obj
+        self.queries = list( result.values() )
+
+
+class Cypher(Parser):
+    REGEX = {}
+    TOKEN_METHODS = {}
+
+    def prepare(self):
+        self.REGEX['separator'] = re.compile(r'([(,?)^]|->|<-)')
+        self.REGEX['condition'] = re.compile(r'(^\w+)|([<>=])')
+        self.TOKEN_METHODS = {
+            '(': self.add_field,  '?': self.add_where,
+            ',': self.add_field,  '^': self.add_order,
+            ')': self.new_query,  '->': self.left_ftable,
+            '<-': self.right_ftable,
+        }
+
+    def new_query(self, token: str):
+        if token.isidentifier():
+            self.queries.append( self.class_type(token) )
+
+    def add_where(self, token: str):
+        field, *condition = [
+            t for t in self.REGEX['condition'].split(token) if t
+        ]
+        Where(' '.join(condition)).add(field, self.queries[-1])
+    
+    def add_order(self, token: str):
+        FieldList(token, [Field, OrderBy]).add('', self.queries[-1])
+
+    def add_field(self, token: str):
+        FieldList(token, [Field]).add('', self.queries[-1])
+
+    def left_ftable(self, token: str):
+        self.new_query(token)
+        self.join_type = JoinType.LEFT
+
+    def right_ftable(self, token: str):
+        self.new_query(token)
+        self.join_type = JoinType.RIGHT
+
+    def add_foreign_key(self, token: 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:
+            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
+
+    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:
+                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)
+
 
 class JoinType(Enum):
     INNER = ''
@@ -503,73 +658,8 @@ class Select(SQLObject):
         return re.findall(f'\b*{self.alias}[.]', expr) != []
 
     @classmethod
-    def parse(cls, txt: str) -> list[SQLObject]:
-        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(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-1]
-            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 t.strip()]
-        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]
-                obj1: SQLObject = result[a1]
-                obj2: SQLObject = result[a2]
-                PrimaryKey.add(f2, obj2)
-                ForeignKey(obj2.table_name).add(f1, obj1)
-            else:
-                obj = cls(item)
-                for key in USUAL_KEYS:
-                    if not key in values:
-                        continue
-                    separator = cls.get_separator(key)
-                    obj.values[key] = [
-                        Field.format(fld, obj)
-                        for fld in re.split(separator, values[key])
-                        if (fld != '*' and len(tables) == 1) or obj.match(fld)
-                    ]
-                result[obj.alias] = obj
-        return list( result.values() )
+    def parse(cls, txt: str, parser: Parser = SQLParser) -> list[SQLObject]:
+        return parser(txt, cls).queries
 
     def optimize(self, rules: list[Rule]=None):
         if not rules:
@@ -646,7 +736,7 @@ class RuleLogicalOp(Rule):
         ))
         for i, condition in enumerate(target.values.get(WHERE, [])):
             expr = re.sub('\n|\t', ' ', condition)
-            if not re.search(r'\b(NOT|not)\b', expr):
+            if not re.search(r'\b(NOT|not).*[<>=]', expr):
                 continue
             tokens = [t.strip() for t in re.split(r'NOT\b|not\b|(<|>|=)', expr) if t]
             op = ''.join(tokens[1: len(tokens)-1])

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.2.1
+Version: 0.2.3
 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
@@ -62,11 +62,13 @@ You can specify your own alias:  `a = Select('Actor a')`
     * field=gt(value) - ...the field is GREATER than the value;
     * field=lt(value) - ...the field is LESS than the value;
 
-    3.1 -- If you want to filter the field on a range of values:
-    
-    `a = Select( 'Actor a', age=Between(45, 69) )`
+> You may use Where.**eq**, Where.**gt**, Where.**lt** ... or simply **eq**, **gt**, **lt** ... 😉
+
+3.1 -- If you want to filter the field on a range of values:
+
+`a = Select( 'Actor a', age=Between(45, 69) )`
 
-    3.2 -- Sub-queries:
+3.2 -- Sub-queries:
 ```
 query = Select('Movie m', title=Field,
     id=SelectIN(

sql_blocks-0.2.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+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,,

sql_blocks-0.2.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=5WBEFqik86gcV4WwPHx4R2e2vMeA1D_et1C9oEMnoQw,21600
-sql_blocks-0.2.1.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-0.2.1.dist-info/METADATA,sha256=g5YLLFr736iWjO8dD0pO7nph5xEbyG6fynoAKo9-XtI,8804
-sql_blocks-0.2.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-0.2.1.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-0.2.1.dist-info/RECORD,,