sql-blocks 0.2.6__tar.gz → 0.31.13__tar.gz

{sql_blocks-0.2.6/sql_blocks.egg-info → sql_blocks-0.31.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.2.6
+Version: 0.31.13
 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
@@ -417,3 +417,102 @@ ORDER BY
 * `<-` connects to the table on the left
 * `->` connects to the table on the right
 * `^` Put the field in the ORDER BY clause
+* `@` Immediately after the table name, it indicates the grouping field.
+* `$` For SQL functions like **avg**$_field_, **sum**$_field_, **count**$_field_...
+
+
+---
+## `detect` function
+
+It is useful to write a query in a few lines, without specifying the script type (cypher, mongoDB, SQL, Neo4J...)
+### Examples:
+
+> **1 - Relationship**
+```
+query = detect(
+    'MATCH(c:Customer)<-[:Order]->(p:Product)RETURN c, p'
+)
+print(query)
+```
+##### output:
+    SELECT * FROM
+        Order ord
+        LEFT JOIN Customer cus ON (ord.customer_id = cus.id)
+        RIGHT JOIN Product pro ON (ord.product_id = pro.id)
+> **2 - Grouping**
+```
+query = detect(
+    'People@gender(avg$age?region="SOUTH"^count$qtde)'
+)
+print(query)
+```
+##### output:
+    SELECT
+            peo.gender,
+            Avg(peo.age),
+            Count(*) as qtde
+    FROM
+            People peo
+    WHERE
+            peo.region = "SOUTH"
+    GROUP BY
+            peo.gender
+    ORDER BY
+            peo.qtde
+
+> **3 - Many conditions...**
+```
+    print( detect('''
+        db.people.find({
+            {
+                $or: [
+                    status:{$eq:"B"},
+                    age:{$lt:50}
+                ]
+            },
+            age:{$gte:18},  status:{$eq:"A"}
+        },{
+            name: 1, user_id: 1
+        }).sort({
+            user_id: -1
+        })
+    ''') )
+```
+#### output:
+    SELECT
+            peo.name,
+            peo.user_id
+    FROM
+            people peo
+    WHERE
+            ( peo. = 'B' OR peo.age < 50 ) AND
+            peo.age >= 18 AND
+            peo.status = 'A'
+    ORDER BY
+            peo.user_id DESC
+
+> **4 - Relations with same table twice (or more)**
+
+Automatically assigns aliases to each side of the relationship (In this example, one user invites another to add to their contact list)
+```
+    print( detect(
+        'User(^name,id) <-Contact(requester,guest)-> User(id,name)'
+       # ^^^ u1                                        ^^^ u2
+    ) )
+```
+    SELECT
+            u1.name,
+            u2.name
+    FROM
+            Contact con
+            RIGHT JOIN User u2 ON (con.guest = u2.id)
+            LEFT JOIN User u1 ON (con.requester = u1.id)
+    ORDER BY
+            u1.name
+
+---
+### `translate_to` method
+It consists of the inverse process of parsing: From a Select object, it returns the text to a script in any of the languages ​​below:
+* QueryLanguage - default
+* MongoDBLanguage
+* Neo4JLanguage

{sql_blocks-0.2.6 → sql_blocks-0.31.13}/README.md

@@ -402,3 +402,102 @@ ORDER BY
 * `<-` connects to the table on the left
 * `->` connects to the table on the right
 * `^` Put the field in the ORDER BY clause
+* `@` Immediately after the table name, it indicates the grouping field.
+* `$` For SQL functions like **avg**$_field_, **sum**$_field_, **count**$_field_...
+
+
+---
+## `detect` function
+
+It is useful to write a query in a few lines, without specifying the script type (cypher, mongoDB, SQL, Neo4J...)
+### Examples:
+
+> **1 - Relationship**
+```
+query = detect(
+    'MATCH(c:Customer)<-[:Order]->(p:Product)RETURN c, p'
+)
+print(query)
+```
+##### output:
+    SELECT * FROM
+        Order ord
+        LEFT JOIN Customer cus ON (ord.customer_id = cus.id)
+        RIGHT JOIN Product pro ON (ord.product_id = pro.id)
+> **2 - Grouping**
+```
+query = detect(
+    'People@gender(avg$age?region="SOUTH"^count$qtde)'
+)
+print(query)
+```
+##### output:
+    SELECT
+            peo.gender,
+            Avg(peo.age),
+            Count(*) as qtde
+    FROM
+            People peo
+    WHERE
+            peo.region = "SOUTH"
+    GROUP BY
+            peo.gender
+    ORDER BY
+            peo.qtde
+
+> **3 - Many conditions...**
+```
+    print( detect('''
+        db.people.find({
+            {
+                $or: [
+                    status:{$eq:"B"},
+                    age:{$lt:50}
+                ]
+            },
+            age:{$gte:18},  status:{$eq:"A"}
+        },{
+            name: 1, user_id: 1
+        }).sort({
+            user_id: -1
+        })
+    ''') )
+```
+#### output:
+    SELECT
+            peo.name,
+            peo.user_id
+    FROM
+            people peo
+    WHERE
+            ( peo. = 'B' OR peo.age < 50 ) AND
+            peo.age >= 18 AND
+            peo.status = 'A'
+    ORDER BY
+            peo.user_id DESC
+
+> **4 - Relations with same table twice (or more)**
+
+Automatically assigns aliases to each side of the relationship (In this example, one user invites another to add to their contact list)
+```
+    print( detect(
+        'User(^name,id) <-Contact(requester,guest)-> User(id,name)'
+       # ^^^ u1                                        ^^^ u2
+    ) )
+```
+    SELECT
+            u1.name,
+            u2.name
+    FROM
+            Contact con
+            RIGHT JOIN User u2 ON (con.guest = u2.id)
+            LEFT JOIN User u1 ON (con.requester = u1.id)
+    ORDER BY
+            u1.name
+
+---
+### `translate_to` method
+It consists of the inverse process of parsing: From a Select object, it returns the text to a script in any of the languages ​​below:
+* QueryLanguage - default
+* MongoDBLanguage
+* Neo4JLanguage

{sql_blocks-0.2.6 → sql_blocks-0.31.13}/pyproject.toml

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

{sql_blocks-0.2.6 → sql_blocks-0.31.13}/setup.py

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

{sql_blocks-0.2.6 → sql_blocks-0.31.13}/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 ', '', r'["\']'),
-    '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]
@@ -70,6 +68,8 @@ class SQLObject:
 
     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)
@@ -89,10 +89,10 @@ class SQLObject:
                 for string in disassemble(source)
                 for fld in re.split(separator, string)
             )       
-        pattern = KEYWORD[key][2] 
+        pattern = KEYWORD[key][1] 
         if exact:
             if key == WHERE:
-                pattern = ' '
+                pattern = r'["\']| '
             pattern += f'|{PATTERN_PREFIX}'
         separator = self.get_separator(key)
         s1 = field_set(search_list)
@@ -219,6 +219,7 @@ class ForeignKey:
 
     @staticmethod
     def get_key(obj1: SQLObject, obj2: SQLObject) -> tuple:
+        # [To-Do] including alias will allow to relate the same table twice
         return obj1.table_name, obj2.table_name
 
     def add(self, name: str, main: SQLObject):
@@ -418,6 +419,235 @@ 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 = method(values)
+            self.result[ref] = self.prefix(key) + 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}{where}RETURN {select}{order_by}'
+    has_default = {WHERE: False, FROM: False, ORDER_BY: True, SELECT: True}
+
+    def add_field(self, values: list) -> str:
+        if values:
+            return self.join_with_tabs(values, ',')
+        return self.TABULATION + ','.join(self.aliases.keys())
+
+    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, end, i = 'core', 0, 0
+            if found:
+                start, end = found.span()
+                pos = txt[start:end-1].lower()
+                i = 1
+            tokens = re.split(r'JOIN\s+|ON\s+', txt[end:])
+            txt = tokens[i].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)
+        return self.TABULATION + '{left}{core}{right}'.format(**nodes)
+        
+
+    def extract_conditions(self, values: list) -> str:
+        equalities = {}
+        where_list = []
+        for condition in values:
+            other_comparisions = any(
+                char in condition for char in '<>'
+            )
+            where_list.append(condition)
+            if '=' not in condition or other_comparisions:
+                continue
+            alias, field, const = re.split(r'[.=]', condition)
+            begin, end = '{', '}'
+            equalities[alias] = f'{begin}{field}:{const}{end}'
+        if len(equalities) == len(where_list):
+            self.aliases.update(equalities)
+            self.has_default[WHERE] = True
+            return self.LINE_BREAK
+        return self.join_with_tabs(where_list, ' AND ') + self.LINE_BREAK
+
+    def set_group(self, values: list) -> str:
+        return ''
+
+    def __init__(self, target: 'Select'):
+        super().__init__(target)
+        self.aliases = {}
+        self.KEYWORDS = [WHERE, FROM, ORDER_BY, SELECT]
+
+    def prefix(self, key: str):
+        default_prefix = any([
+            (key == WHERE and not self.has_default[WHERE]),
+            key == ORDER_BY
+        ])
+        if default_prefix:
+            return super().prefix(key)
+        return ''
+
+
 class Parser:
     REGEX = {}
 
@@ -446,9 +676,17 @@ class Parser:
         return ''.join(result)
 
     def get_tokens(self, txt: str) -> list:
-        return self.REGEX['separator'].split(
-            self.remove_spaces(txt)
-        )
+        return [
+            self.remove_spaces(t)
+            for t in self.REGEX['separator'].split(txt)            
+        ]
+
+
+class JoinType(Enum):
+    INNER = ''
+    LEFT = 'LEFT '
+    RIGHT = 'RIGHT '
+    FULL = 'FULL '
 
 
 class SQLParser(Parser):
@@ -525,91 +763,150 @@ class SQLParser(Parser):
         self.queries = list( result.values() )
 
 
-class Cypher(Parser):
+class CypherParser(Parser):
     REGEX = {}
+    CHAR_SET = r'[(,?)^{}[\]]'
+    KEYWORDS = '|'.join(
+        fr'\s+{word}\s+'
+        for word in "where return WHERE RETURN and AND".split()
+    )
 
     def prepare(self):
-        self.REGEX['separator'] = re.compile(r'([(,?)^{}[\]]|->|<-)')
+        self.REGEX['separator'] = re.compile(fr'({self.CHAR_SET}|->|<-|{self.KEYWORDS})')
         self.REGEX['condition'] = re.compile(r'(^\w+)|([<>=])')
+        self.REGEX['alias_pos'] = re.compile(r'(\w+)[.](\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
+        self.aliases = {}
 
-    def new_query(self, token: str):
-        if token.isidentifier():
-            self.queries.append( self.class_type(token) )
+    def new_query(self, token: str, join_type = JoinType.INNER, alias: str=''):
+        token, *group_fields = token.split('@')
+        if not token.isidentifier():
+            return
+        table_name = f'{token} {alias}' if alias else token
+        query = self.class_type(table_name)
+        if not alias:
+            alias = query.alias
+        self.queries.append(query)
+        self.aliases[alias] = query
+        FieldList(group_fields, [Field, GroupBy]).add('', query)
+        query.join_type = join_type
 
     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])
+        elements = [t for t in self.REGEX['alias_pos'].split(token) if t]
+        if len(elements) == 3:
+            alias, field, *condition = elements
+            query = self.aliases[alias]
+        else:
+            field, *condition = [
+                t for t in self.REGEX['condition'].split(token) if t
+            ]
+            query = self.queries[-1]
+        Where(' '.join(condition)).add(field, query)
     
     def add_order(self, token: str):
-        FieldList(token, [Field, OrderBy]).add('', self.queries[-1])
+        self.add_field(token, [OrderBy])
 
-    def add_field(self, token: str):
-        FieldList(token, [Field]).add('', self.queries[-1])
+    def add_field(self, token: str, extra_classes: list['type']=[]):
+        if token in self.TOKEN_METHODS:
+            return
+        class_list = [Field]
+        if '$' in token:
+            func_name, token = token.split('$')
+            if func_name == 'count':
+                if not token:
+                    token = 'count_1'
+                NamedField(token, Count).add('*', self.queries[-1])
+                class_list = []
+            else:
+                FUNCTION_CLASS = {f.__name__.lower(): f for f in Function.__subclasses__()}
+                class_list = [ FUNCTION_CLASS[func_name] ]
+        class_list += extra_classes
+        FieldList(token, class_list).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, pk_field: str=''):
         curr, last = [self.queries[i] for i in (-1, -2)]
         if not pk_field:
             if not last.values.get(SELECT):
-                return
+                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 self.join_type == JoinType.RIGHT:
-            curr, last = last, curr
         if '{}' in token:
-            token = token.format(
+            foreign_fld = token.format(
+                last.table_name.lower()
+                if last.join_type == JoinType.LEFT else
                 curr.table_name.lower()
             )
-        k = ForeignKey.get_key(last, curr)
-        ForeignKey.references[k] = (token, pk_field)
-        self.join_type = JoinType.INNER
+        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:
+                pk_field, foreign_fld = foreign_fld, pk_field
+        if curr.join_type == JoinType.RIGHT:
+            curr, last = last, curr
+            # pk_field, foreign_fld = foreign_fld, pk_field
+        k = ForeignKey.get_key(curr, last)
+        ForeignKey.references[k] = (foreign_fld, pk_field)
+
+    def fk_charset(self) -> str:
+        return '(['
 
     def eval(self, txt: str):
+        # ====================================
+        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:
+            if not token or (token in '([' and self.method):
                 continue
             if self.method:
                 self.method(token)
-            if token in '([' 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.upper())
+        # ====================================
 
-class Neo4JParser(Cypher):
+class Neo4JParser(CypherParser):
     def prepare(self):
         super().prepare()
         self.TOKEN_METHODS = {
-            '(': self.new_query,  '{': self.add_where,
-            '->': self.left_ftable, '<-': self.right_ftable,
-            '[': self.new_query
+            '(': self.new_query,  '{': self.add_where, '[': self.new_query,
+            '<-': self.left_ftable, '->': self.right_ftable,            
+            'WHERE': self.add_where, 'AND': self.add_where, 
         }
         self.method = None
+        self.aliases = {}
 
-    def new_query(self, token: str):
-        super().new_query(token.split(':')[-1])
+    def new_query(self, token: str, join_type = JoinType.INNER):
+        alias = ''
+        if ':' in token:
+            alias, token = token.split(':')
+        super().new_query(token, join_type, alias)
 
     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')
 
 # ----------------------------
@@ -729,15 +1026,10 @@ class MongoParser(Parser):
 # ----------------------------
 
 
-class JoinType(Enum):
-    INNER = ''
-    LEFT = 'LEFT '
-    RIGHT = 'RIGHT '
-    FULL = 'FULL '
-
 class Select(SQLObject):
     join_type: JoinType = JoinType.INNER
     REGEX = {}
+    EQUIVALENT_NAMES = {}
 
     def __init__(self, table_name: str='', **values):
         super().__init__(table_name)
@@ -753,7 +1045,7 @@ class Select(SQLObject):
         new_tables = set([
             '{jt}JOIN {tb} {a2} ON ({a1}.{f1} = {a2}.{f2})'.format(
                 jt=self.join_type.value,
-                tb=self.table_name,
+                tb=self.EQUIVALENT_NAMES.get(self.table_name, self.table_name),
                 a1=main.alias, f1=name,
                 a2=self.alias, f2=self.key_field
             )
@@ -784,16 +1076,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]
@@ -836,6 +1119,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):
@@ -863,7 +1148,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]
@@ -909,7 +1194,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):
@@ -923,3 +1208,48 @@ class RuleDateFuncReplace(Rule):
             temp = Select(f'{target.table_name} {target.alias}')
             Between(f'{year}-01-01', f'{year}-12-31').add(field, temp)
             target.values[WHERE][i] = ' AND '.join(temp.values[WHERE])
+
+
+def parser_class(text: str) -> Parser:
+    PARSER_REGEX = [
+        (r'select.*from', SQLParser),
+        (r'[.](find|aggregate)[(]', MongoParser),
+        (r'[(\[]\w*[:]\w+', Neo4JParser),
+        (r'^\w+[@]*\w*[(]', CypherParser)
+    ]
+    text = Parser.remove_spaces(text)
+    for regex, class_type in PARSER_REGEX:
+        if re.findall(regex, text, re.IGNORECASE):
+            return class_type
+    return None
+
+
+def detect(text: str) -> Select:    
+    from collections import Counter
+    parser = parser_class(text)
+    if not parser:
+        raise SyntaxError('Unknown parser class')
+    if parser == CypherParser:
+        for table, count in Counter( re.findall(r'(\w+)[(]', text) ).most_common():
+            if count < 2:
+                continue
+            pos = [ f.span() for f in re.finditer(fr'({table})[(]', text) ]
+            for begin, end in pos[::-1]:
+                new_name = f'{table}_{count}'  # See set_table (line 45)
+                Select.EQUIVALENT_NAMES[new_name] = table
+                text = text[:begin] + new_name + '(' + text[end:]
+                count -= 1
+    query_list = Select.parse(text, parser)
+    result = query_list[0]
+    for query in query_list[1:]:
+        result += query
+    return result
+
+
+if __name__ == "__main__":
+    print('@'*100)
+    print( detect(
+        # 'User(^name?role="Manager",id)<-Contact(requester, guest)->User(id,name)'
+        'User(^name,id) <-Contact(requester,guest)-> User(id,name)'
+    ) )
+    print('@'*100)

{sql_blocks-0.2.6 → sql_blocks-0.31.13/sql_blocks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 0.2.6
+Version: 0.31.13
 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
@@ -417,3 +417,102 @@ ORDER BY
 * `<-` connects to the table on the left
 * `->` connects to the table on the right
 * `^` Put the field in the ORDER BY clause
+* `@` Immediately after the table name, it indicates the grouping field.
+* `$` For SQL functions like **avg**$_field_, **sum**$_field_, **count**$_field_...
+
+
+---
+## `detect` function
+
+It is useful to write a query in a few lines, without specifying the script type (cypher, mongoDB, SQL, Neo4J...)
+### Examples:
+
+> **1 - Relationship**
+```
+query = detect(
+    'MATCH(c:Customer)<-[:Order]->(p:Product)RETURN c, p'
+)
+print(query)
+```
+##### output:
+    SELECT * FROM
+        Order ord
+        LEFT JOIN Customer cus ON (ord.customer_id = cus.id)
+        RIGHT JOIN Product pro ON (ord.product_id = pro.id)
+> **2 - Grouping**
+```
+query = detect(
+    'People@gender(avg$age?region="SOUTH"^count$qtde)'
+)
+print(query)
+```
+##### output:
+    SELECT
+            peo.gender,
+            Avg(peo.age),
+            Count(*) as qtde
+    FROM
+            People peo
+    WHERE
+            peo.region = "SOUTH"
+    GROUP BY
+            peo.gender
+    ORDER BY
+            peo.qtde
+
+> **3 - Many conditions...**
+```
+    print( detect('''
+        db.people.find({
+            {
+                $or: [
+                    status:{$eq:"B"},
+                    age:{$lt:50}
+                ]
+            },
+            age:{$gte:18},  status:{$eq:"A"}
+        },{
+            name: 1, user_id: 1
+        }).sort({
+            user_id: -1
+        })
+    ''') )
+```
+#### output:
+    SELECT
+            peo.name,
+            peo.user_id
+    FROM
+            people peo
+    WHERE
+            ( peo. = 'B' OR peo.age < 50 ) AND
+            peo.age >= 18 AND
+            peo.status = 'A'
+    ORDER BY
+            peo.user_id DESC
+
+> **4 - Relations with same table twice (or more)**
+
+Automatically assigns aliases to each side of the relationship (In this example, one user invites another to add to their contact list)
+```
+    print( detect(
+        'User(^name,id) <-Contact(requester,guest)-> User(id,name)'
+       # ^^^ u1                                        ^^^ u2
+    ) )
+```
+    SELECT
+            u1.name,
+            u2.name
+    FROM
+            Contact con
+            RIGHT JOIN User u2 ON (con.guest = u2.id)
+            LEFT JOIN User u1 ON (con.requester = u1.id)
+    ORDER BY
+            u1.name
+
+---
+### `translate_to` method
+It consists of the inverse process of parsing: From a Select object, it returns the text to a script in any of the languages ​​below:
+* QueryLanguage - default
+* MongoDBLanguage
+* Neo4JLanguage