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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.2.2
+Version: 0.2.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
@@ -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.2 → sql_blocks-0.2.4}/README.md

@@ -365,4 +365,40 @@ m2 = Select(
         user_id=[Field, GroupBy, OrderBy],
         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.2 → sql_blocks-0.2.4}/pyproject.toml

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

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

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

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

@@ -413,6 +413,276 @@ 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 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.REGEX['separator'].split( re.sub(r'\s+', '', 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 = ''
@@ -504,73 +774,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:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.2.2
+Version: 0.2.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
@@ -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