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

{sql_blocks-0.2.9/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.9
+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.9 → 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.9 → sql_blocks-0.31.13}/pyproject.toml

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

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

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

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

@@ -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):
@@ -442,7 +443,7 @@ class QueryLanguage:
         return  self.join_with_tabs(values, ' AND ')
 
     def sort_by(self, values: list) -> str:
-        return  self.join_with_tabs(values)
+        return self.join_with_tabs(values)
 
     def set_group(self, values: list) -> str:
         return  self.join_with_tabs(values, ',')
@@ -475,8 +476,8 @@ class QueryLanguage:
             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
+            text = method(values)
+            self.result[ref] = self.prefix(key) + text
         return self.pattern.format(**self.result).strip()
 
 class MongoDBLanguage(QueryLanguage):
@@ -572,11 +573,13 @@ class MongoDBLanguage(QueryLanguage):
 
 
 class Neo4JLanguage(QueryLanguage):
-    pattern = 'MATCH {_from} RETURN {aliases}'
-    has_default = {key: False for key in KEYWORD}
+    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:
-        return ''
+        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(
@@ -589,12 +592,13 @@ class Neo4JLanguage(QueryLanguage):
             found = re.search(
                 r'^(left|right)\s+', txt, re.IGNORECASE
             )
-            pos = 'core'
+            pos, end, i = 'core', 0, 0
             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()
+                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]
@@ -604,23 +608,27 @@ class Neo4JLanguage(QueryLanguage):
             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)
+        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 '<>%'
+                char in condition for char in '<>'
             )
+            where_list.append(condition)
             if '=' not in condition or other_comparisions:
-                raise NotImplementedError('Only comparisons with equality are available for now.')
+                continue
             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 ''
+            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 ''
@@ -628,9 +636,15 @@ class Neo4JLanguage(QueryLanguage):
     def __init__(self, target: 'Select'):
         super().__init__(target)
         self.aliases = {}
-        self.KEYWORDS = [WHERE, FROM]
+        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 ''
 
 
@@ -662,9 +676,10 @@ 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):
@@ -748,12 +763,18 @@ 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,
@@ -762,24 +783,52 @@ class Cypher(Parser):
             '->': self.right_ftable,
         }
         self.method = self.new_query
+        self.aliases = {}
 
-    def new_query(self, token: str, join_type = JoinType.INNER):
-        if token.isidentifier():
-            query = self.class_type(token)
-            self.queries.append(query)
-            query.join_type = join_type
+    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:
@@ -807,8 +856,11 @@ class Cypher(Parser):
                 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)
 
@@ -831,21 +883,25 @@ class Cypher(Parser):
                 self.method(token)
             if token in ')]' and has_side_table():
                 self.add_foreign_key('')
-            self.method = self.TOKEN_METHODS.get(token)
+            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, join_type = JoinType.INNER):
-        super().new_query(token.split(':')[-1], join_type)
+        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(':', '='))
@@ -973,6 +1029,7 @@ class MongoParser(Parser):
 class Select(SQLObject):
     join_type: JoinType = JoinType.INNER
     REGEX = {}
+    EQUIVALENT_NAMES = {}
 
     def __init__(self, table_name: str='', **values):
         super().__init__(table_name)
@@ -988,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
             )
@@ -1151,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.9 → 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.9
+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