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

{sql_blocks-0.2.3/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.3
+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.3 → 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.3 → sql_blocks-0.2.4}/pyproject.toml

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

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

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

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

@@ -567,6 +567,122 @@ class Cypher(Parser):
             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 = ''

{sql_blocks-0.2.3 → 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.3
+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