sql-blocks 1.25.112__py3-none-any.whl → 1.25.514__py3-none-any.whl

sql_blocks/sql_blocks.py

@@ -42,23 +42,34 @@ class SQLObject:
         if not table_name:
             return
         cls = SQLObject
+        is_file_name = any([
+            '/' in table_name, '.' in table_name
+        ])
+        ref = table_name
+        if is_file_name:
+            ref = table_name.split('/')[-1].split('.')[0]
         if cls.ALIAS_FUNC:
-            self.__alias = cls.ALIAS_FUNC(table_name)
+            self.__alias = cls.ALIAS_FUNC(ref)
         elif ' ' in table_name.strip():
             table_name, self.__alias = table_name.split()
-        elif '_' in table_name:
+        elif '_' in ref:
             self.__alias = ''.join(
                 word[0].lower()
-                for word in table_name.split('_')
+                for word in ref.split('_')
             )
         else:
-            self.__alias = table_name.lower()[:3]
+            self.__alias = ref.lower()[:3]
         self.values.setdefault(FROM, []).append(f'{table_name} {self.alias}')
 
     @property
     def table_name(self) -> str:
         return self.values[FROM][0].split()[0]
     
+    def set_file_format(self, pattern: str):
+        if '{' not in pattern:
+            pattern = '{}' + pattern
+        self.values[FROM][0] = pattern.format(self.aka())
+
     @property
     def alias(self) -> str:
         if self.__alias:
@@ -70,6 +81,16 @@ class SQLObject:
         appendix = {WHERE: r'\s+and\s+|', FROM: r'\s+join\s+|\s+JOIN\s+'}
         return KEYWORD[key][0].format(appendix.get(key, ''))
 
+    @staticmethod
+    def is_named_field(fld: str, name: str='') -> bool:
+        return re.search(fr'(\s+as\s+|\s+AS\s+){name}', fld)
+
+    def has_named_field(self, name: str) -> bool:
+        return any(
+            self.is_named_field(fld, name)
+            for fld in self.values.get(SELECT, [])
+        )
+
     def diff(self, key: str, search_list: list, exact: bool=False) -> set:
         def disassemble(source: list) -> list:
             if not exact:
@@ -78,16 +99,17 @@ class SQLObject:
             for fld in source:
                 result += re.split(r'([=()]|<>|\s+ON\s+|\s+on\s+)', fld)
             return result
-        def cleanup(fld: str) -> str:
+        def cleanup(text: str) -> str:
+            text = re.sub(r'[\n\t]', ' ', text)
             if exact:
-                fld = fld.lower()
-            return fld.strip()
-        def is_named_field(fld: str) -> bool:
-            return key == SELECT and re.search(r'\s+as\s+|\s+AS\s+', fld)
+                text = text.lower()
+            return text.strip()
         def field_set(source: list) -> set:
             return set(
                 (
-                    fld if is_named_field(fld) else
+                    fld 
+                    if key == SELECT and self.is_named_field(fld, key) 
+                    else
                     re.sub(pattern, '', cleanup(fld))
                 )
                 for string in disassemble(source)
@@ -105,18 +127,22 @@ class SQLObject:
             return s1.symmetric_difference(s2)
         return s1 - s2
 
-    def delete(self, search: str, keys: list=USUAL_KEYS):
+    def delete(self, search: str, keys: list=USUAL_KEYS, exact: bool=False):
+        if exact:
+            not_match = lambda item: not re.search(fr'\w*[.]*{search}$', item)
+        else:
+            not_match = lambda item: search not in item
         for key in keys:
-            result = []
-            for item in self.values.get(key, []):
-                if search not in item:
-                    result.append(item)
-            self.values[key] = result
+            self.values[key] = [
+                item for item in self.values.get(key, [])
+                if not_match(item)
+            ]
 
 
 SQL_CONST_SYSDATE = 'SYSDATE'
 SQL_CONST_CURR_DATE = 'Current_date'
-SQL_CONSTS = [SQL_CONST_SYSDATE, SQL_CONST_CURR_DATE]
+SQL_ROW_NUM = 'ROWNUM'
+SQL_CONSTS = [SQL_CONST_SYSDATE, SQL_CONST_CURR_DATE, SQL_ROW_NUM]
 
 
 class Field:
@@ -133,7 +159,7 @@ class Field:
         name = name.strip()
         if name in ('_', '*'):
             name = '*'
-        elif not is_const():
+        elif not is_const() and not main.has_named_field(name):
             name = f'{main.alias}.{name}'
         if Function in cls.__bases__:
             name = f'{cls.__name__}({name})'
@@ -171,15 +197,35 @@ class Dialect(Enum):
     POSTGRESQL = 3
     MYSQL = 4
 
+SQL_TYPES = 'CHAR INT DATE FLOAT ANY'.split()
+CHAR, INT, DATE, FLOAT, ANY  =  SQL_TYPES
+
 class Function:
     dialect = Dialect.ANSI
+    inputs = None
+    output = None
+    separator = ', '
+    auto_convert = True
+    append_param = False
 
     def __init__(self, *params: list):
+        def set_func_types(param):
+            if self.auto_convert and isinstance(param, Function):
+                func = param
+                main_param = self.inputs[0]
+                unfriendly = all([
+                    func.output != main_param,
+                    func.output != ANY,
+                    main_param  != ANY
+                ])
+                if unfriendly:
+                    return Cast(func, main_param)
+            return param
         # --- Replace class methods by instance methods: ------
         self.add = self.__add
         self.format = self.__format
         # -----------------------------------------------------
-        self.params = [str(p) for p in params]
+        self.params = [set_func_types(p) for p in params]
         self.field_class = Field
         self.pattern = self.get_pattern()
         self.extra = {}
@@ -196,14 +242,35 @@ class Function:
     def __str__(self) -> str:
         return self.pattern.format(
             func_name=self.__class__.__name__,
-            params=', '.join(self.params)
+            params=self.separator.join(str(p) for p in self.params)
         )
 
+    @classmethod
+    def help(cls) -> str:
+        descr = ' '.join(B.__name__ for B in cls.__bases__)
+        params = cls.inputs or ''
+        return cls().get_pattern().format(
+            func_name=f'{descr} {cls.__name__}',
+            params=cls.separator.join(str(p) for p in params)
+        ) + f'  Return {cls.output}'
+
+    def set_main_param(self, name: str, main: SQLObject) -> bool:
+        nested_functions = [
+            param for param in self.params if isinstance(param, Function)
+        ]
+        for func in nested_functions:
+            if func.inputs:
+                func.set_main_param(name, main)
+                return
+        new_params = [Field.format(name, main)]
+        if self.append_param:
+            self.params += new_params
+        else:
+            self.params = new_params + self.params         
+
     def __format(self, name: str, main: SQLObject) -> str:
         if name not in '*_':
-            self.params = [
-                Field.format(name, main)
-            ] + self.params
+            self.set_main_param(name, main)
         return str(self)
 
     @classmethod
@@ -223,6 +290,9 @@ class Function:
 
 # ---- String Functions: ---------------------------------
 class SubString(Function):
+    inputs = [CHAR, INT, INT]
+    output = CHAR
+
     def get_pattern(self) -> str:
         if self.dialect in (Dialect.ORACLE, Dialect.MYSQL):
             return 'Substr({params})'
@@ -230,31 +300,55 @@ class SubString(Function):
 
 # ---- Numeric Functions: --------------------------------
 class Round(Function):
-    ...
+    inputs = [FLOAT]
+    output = FLOAT
 
 # --- Date Functions: ------------------------------------
 class DateDiff(Function):
-    def get_pattern(self) -> str:
+    inputs = [DATE]
+    output = DATE
+    append_param = True
+
+    def __str__(self) -> str:
         def is_field_or_func(name: str) -> bool:
-            return re.sub('[()]', '', name).isidentifier()
+            candidate = re.sub(
+                '[()]', '', name.split('.')[-1]
+            )
+            return candidate.isidentifier()
         if self.dialect != Dialect.SQL_SERVER:
+            params = [str(p) for p in self.params]
             return ' - '.join(
                 p if is_field_or_func(p) else f"'{p}'"
-                for p in self.params
+                for p in params
             )  # <====  Date subtract
-        return super().get_pattern()
+        return super().__str__()
+
+
+class DatePart(Function):
+    inputs = [DATE]
+    output = INT
 
-class Year(Function):
     def get_pattern(self) -> str:
+        interval = self.__class__.__name__
         database_type = {
-            Dialect.ORACLE: 'Extract(YEAR FROM {params})',
-            Dialect.POSTGRESQL: "Date_Part('year', {params})",
+            Dialect.ORACLE: 'Extract('+interval+' FROM {params})',
+            Dialect.POSTGRESQL: "Date_Part('"+interval+"', {params})",
         }
         if self.dialect in database_type:
             return database_type[self.dialect]
         return super().get_pattern()
 
+class Year(DatePart):
+    ...
+class Month(DatePart):
+    ...
+class Day(DatePart):
+    ...
+
+
 class Current_Date(Function):
+    output = DATE
+
     def get_pattern(self) -> str:
         database_type = {
             Dialect.ORACLE: SQL_CONST_SYSDATE,
@@ -277,14 +371,15 @@ class Frame:
         keywords = ''
         for field, obj in args.items():
             is_valid = any([
-                obj is class_type # or isinstance(obj, class_type)
-                for class_type in (OrderBy, Partition)
+                obj is OrderBy,
+                obj is Partition,
+                isinstance(obj, Rows),
             ])
             if not is_valid:
                 continue
             keywords += '{}{} {}'.format(
                 '\n\t\t' if self.break_lines else ' ',
-                obj.cls_to_str(), field
+                obj.cls_to_str(), field if field != '_' else ''
             )
         if keywords and self.break_lines:
             keywords += '\n\t'
@@ -293,7 +388,8 @@ class Frame:
 
 
 class Aggregate(Frame):
-    ...
+    inputs = [FLOAT]
+    output = FLOAT
 
 class Window(Frame):
     ...
@@ -312,20 +408,30 @@ class Count(Aggregate, Function):
 
 # ---- Window Functions: -----------------------------------
 class Row_Number(Window, Function):
-    ... 
+    output = INT
+
 class Rank(Window, Function):
-    ... 
+    output = INT
+
 class Lag(Window, Function):
-    ...
+    output = ANY
+
 class Lead(Window, Function):
-    ...
+    output = ANY
 
 
 # ---- Conversions and other Functions: ---------------------
 class Coalesce(Function):
-    ...
+    inputs = [ANY]
+    output = ANY
+    
 class Cast(Function):
-    ...
+    inputs = [ANY]
+    output = ANY
+    separator = ' As '
+
+
+FUNCTION_CLASS = {f.__name__.lower(): f for f in Function.__subclasses__()}
 
 
 class ExpressionField:
@@ -350,15 +456,20 @@ class ExpressionField:
 class FieldList:
     separator = ','
 
-    def __init__(self, fields: list=[], class_types = [Field]):
+    def __init__(self, fields: list=[], class_types = [Field], ziped: bool=False):
         if isinstance(fields, str):
             fields = [
                 f.strip() for f in fields.split(self.separator)
             ]
         self.fields = fields
         self.class_types = class_types
+        self.ziped = ziped
 
     def add(self, name: str, main: SQLObject):
+        if self.ziped:  # --- One class per field...
+            for field, class_type in zip(self.fields, self.class_types):
+                class_type.add(field, main)
+            return
         for field in self.fields:
             for class_type in self.class_types:
                 class_type.add(field, main)
@@ -400,36 +511,40 @@ class ForeignKey:
 
 def quoted(value) -> str:
     if isinstance(value, str):
+        if re.search(r'\bor\b', value, re.IGNORECASE):
+            raise PermissionError('Possible SQL injection attempt')
         value = f"'{value}'"
     return str(value)
 
 
 class Position(Enum):
+    StartsWith = -1
     Middle = 0
-    StartsWith = 1
-    EndsWith = 2
+    EndsWith = 1
 
 
 class Where:
     prefix = ''
 
-    def __init__(self, expr: str):
-        self.expr = expr
+    def __init__(self, content: str):
+        self.content = content
 
     @classmethod
     def __constructor(cls, operator: str, value):
-        return cls(expr=f'{operator} {quoted(value)}')
+        return cls(f'{operator} {quoted(value)}')
 
     @classmethod
     def eq(cls, value):
         return cls.__constructor('=', value)
 
     @classmethod
-    def contains(cls, content: str, pos: Position = Position.Middle):
+    def contains(cls, text: str, pos: int | Position = Position.Middle):
+        if isinstance(pos, int):
+            pos = Position(pos)
         return cls(
             "LIKE '{}{}{}'".format(
                 '%' if pos != Position.StartsWith else '',
-                content,
+                text,
                 '%' if pos != Position.EndsWith else ''
             )
         )
@@ -460,9 +575,43 @@ class Where:
             values = ','.join(quoted(v) for v in values)
         return cls(f'IN ({values})')
 
+    @classmethod
+    def formula(cls, formula: str):
+        where = cls( ExpressionField(formula) )
+        where.add = where.add_expression
+        return where
+
+    def add_expression(self, name: str, main: SQLObject):
+        self.content = self.content.format(name, main)
+        main.values.setdefault(WHERE, []).append('{} {}'.format(
+            self.prefix, self.content
+        ))
+
+    @classmethod
+    def join(cls, query: SQLObject):
+        where = cls(query)
+        where.add = where.add_join
+        return where
+
+    def add_join(self, name: str, main: SQLObject):
+        query = self.content
+        main.values[FROM].append(f',{query.table_name} {query.alias}')
+        for key in USUAL_KEYS:
+            main.update_values(key, query.values.get(key, []))
+        if query.key_field:
+            main.values.setdefault(WHERE, []).append('({a1}.{f1} = {a2}.{f2})'.format(
+                a1=main.alias, f1=name,
+                a2=query.alias, f2=query.key_field
+            ))
+
     def add(self, name: str, main: SQLObject):
+        func_type = FUNCTION_CLASS.get(name.lower())
+        if func_type:
+            name = func_type.format('*', main)
+        elif not main.has_named_field(name):
+            name = Field.format(name, main)
         main.values.setdefault(WHERE, []).append('{}{} {}'.format(
-            self.prefix, Field.format(name, main), self.expr
+            self.prefix, name, self.content
         ))
 
 
@@ -470,6 +619,10 @@ eq, contains, gt, gte, lt, lte, is_null, inside = (
     getattr(Where, method) for method in 
     ('eq', 'contains', 'gt', 'gte', 'lt', 'lte', 'is_null', 'inside')
 ) 
+startswith, endswith = [
+    lambda x: contains(x, Position.StartsWith),
+    lambda x: contains(x, Position.EndsWith)
+]
 
 
 class Not(Where):
@@ -477,7 +630,7 @@ class Not(Where):
 
     @classmethod
     def eq(cls, value):
-        return Where(expr=f'<> {quoted(value)}')
+        return Where(f'<> {quoted(value)}')
 
 
 class Case:
@@ -486,22 +639,26 @@ class Case:
         self.default = None
         self.field = field
 
-    def when(self, condition: Where, result: str):
+    def when(self, condition: Where, result):
+        if isinstance(result, str):
+            result = quoted(result)
         self.__conditions[result] = condition
         return self
     
-    def else_value(self, default: str):
+    def else_value(self, default):
+        if isinstance(default, str):
+            default = quoted(default)
         self.default = default
         return self
     
     def add(self, name: str, main: SQLObject):
         field = Field.format(self.field, main)
-        default = quoted(self.default)
+        default = self.default
         name = 'CASE \n{}\n\tEND AS {}'.format(
             '\n'.join(
-                f'\t\tWHEN {field} {cond.expr} THEN {quoted(res)}'
+                f'\t\tWHEN {field} {cond.content} THEN {res}'
                 for res, cond in self.__conditions.items()
-            ) + f'\n\t\tELSE {default}' if default else '',
+            ) + (f'\n\t\tELSE {default}' if default else ''),
             name
         )
         main.values.setdefault(SELECT, []).append(name)
@@ -512,42 +669,69 @@ class Options:
         self.__children: dict = values
 
     def add(self, logical_separator: str, main: SQLObject):
-        if logical_separator not in ('AND', 'OR'):
+        if logical_separator.upper() not in ('AND', 'OR'):
             raise ValueError('`logical_separator` must be AND or OR')
-        conditions: list[str] = []
+        temp = Select(f'{main.table_name} {main.alias}')
         child: Where
         for field, child in self.__children.items():
-            conditions.append(' {} {} '.format(
-                Field.format(field, main), child.expr
-            ))
+            child.add(field, temp)
         main.values.setdefault(WHERE, []).append(
-            '(' + logical_separator.join(conditions) + ')'
+            '(' + f'\n\t{logical_separator} '.join(temp.values[WHERE]) + ')'
         )
 
 
 class Between:
+    is_literal: bool = False
+
     def __init__(self, start, end):
         if start > end:
             start, end = end, start
         self.start = start
         self.end = end
 
+    def literal(self) -> Where:
+        return Where('BETWEEN {} AND {}'.format(
+            self.start, self.end
+        ))
+
     def add(self, name: str, main:SQLObject):
-        Where.gte(self.start).add(name, main),
+        if self.is_literal:
+            return self.literal().add(name, main)
+        Where.gte(self.start).add(name, main)
         Where.lte(self.end).add(name, main)
 
+class SameDay(Between):
+    def __init__(self, date: str):
+        super().__init__(
+            f'{date} 00:00:00',
+            f'{date} 23:59:59',
+        )
+
+
+class Range(Case):
+    INC_FUNCTION = lambda x: x + 1
+
+    def __init__(self, field: str, values: dict):
+        super().__init__(field)
+        start = 0
+        cls = self.__class__
+        for label, value in sorted(values.items(), key=lambda item: item[1]):
+            self.when(
+                Between(start, value).literal(), label
+            )
+            start = cls.INC_FUNCTION(value)
+
 
 class Clause:
     @classmethod
     def format(cls, name: str, main: SQLObject) -> str:
         def is_function() -> bool:
             diff = main.diff(SELECT, [name.lower()], True)
-            FUNCTION_CLASS = {f.__name__.lower(): f for f in Function.__subclasses__()}
             return diff.intersection(FUNCTION_CLASS)
         found = re.findall(r'^_\d', name)
         if found:
             name = found[0].replace('_', '')
-        elif main.alias and not is_function():
+        elif '.' not in name and main.alias and not is_function():
             name = f'{main.alias}.{name}'
         return name
 
@@ -556,6 +740,34 @@ class SortType(Enum):
     ASC = ''
     DESC = ' DESC'
 
+class Row:
+    def __init__(self, value: int=0):
+        self.value = value
+
+    def __str__(self) -> str:
+        return '{} {}'.format(
+            'UNBOUNDED' if self.value == 0 else self.value,
+            self.__class__.__name__.upper()
+        )
+
+class Preceding(Row):
+    ...
+class Following(Row):
+    ...
+class Current(Row):
+    def __str__(self) -> str:
+        return 'CURRENT ROW'
+
+class Rows:
+    def __init__(self, *rows: list[Row]):
+        self.rows = rows
+
+    def cls_to_str(self) -> str:
+        return 'ROWS {}{}'.format(
+            'BETWEEN ' if len(self.rows) > 1 else '',
+            ' AND '.join(str(row) for row in self.rows)
+        )
+
 
 class OrderBy(Clause):
     sort: SortType = SortType.ASC
@@ -590,7 +802,7 @@ class Having:
 
     def add(self, name: str, main:SQLObject):
         main.values[GROUP_BY][-1] += ' HAVING {} {}'.format(
-            self.function.format(name, main), self.condition.expr
+            self.function.format(name, main), self.condition.content
         )
     
     @classmethod
@@ -620,12 +832,20 @@ class Rule:
         ...
 
 class QueryLanguage:
-    pattern = '{select}{_from}{where}{group_by}{order_by}'
+    pattern = '{select}{_from}{where}{group_by}{order_by}{limit}'
     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 remove_alias(text: str) -> str:
+        value, sep = '', ''
+        text = re.sub('[\n\t]', ' ', text)
+        if ':' in text:
+            text, value = text.split(':', maxsplit=1)
+            sep = ':'
+        return '{}{}{}'.format(
+            ''.join(re.split(r'\w+[.]', text)),
+            sep, value.replace("'", '"')
+        )
 
     def join_with_tabs(self, values: list, sep: str='') -> str:
         sep = sep + self.TABULATION
@@ -643,18 +863,21 @@ 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, ',')
 
+    def set_limit(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.KEYWORDS = [SELECT, FROM, WHERE, GROUP_BY, ORDER_BY, LIMIT]
         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,
+            WHERE: self.extract_conditions, LIMIT: self.set_limit,
             ORDER_BY: self.sort_by, GROUP_BY: self.set_group,
         }
         self.result = {}
@@ -690,7 +913,8 @@ class MongoDBLanguage(QueryLanguage):
     LOGICAL_OP_TO_MONGO_FUNC = {
         '>': '$gt',  '>=': '$gte',
         '<': '$lt',  '<=': '$lte',
-        '=': '$eq',  '<>': '$ne',
+        '=': '$eq',  '<>': '$ne', 
+        'like': '$regex', 'LIKE': '$regex',
     }
     OPERATORS = '|'.join(op for op in LOGICAL_OP_TO_MONGO_FUNC)
     REGEX = {
@@ -743,7 +967,7 @@ class MongoDBLanguage(QueryLanguage):
             field, *op, const = tokens
             op = ''.join(op)
             expr = '{begin}{op}:{const}{end}'.format(
-                begin='{', const=const, end='}',
+                begin='{', const=const.replace('%', '.*'), end='}',
                 op=cls.LOGICAL_OP_TO_MONGO_FUNC[op],                
             )
             where_list.append(f'{field}:{expr}')
@@ -852,6 +1076,55 @@ class Neo4JLanguage(QueryLanguage):
         return ''
 
 
+class DatabricksLanguage(QueryLanguage):
+    pattern = '{_from}{where}{group_by}{order_by}{select}{limit}'
+    has_default = {key: bool(key == SELECT) for key in KEYWORD}
+
+    def __init__(self, target: 'Select'):
+        super().__init__(target)
+        self.aggregation_fields = []
+
+    def add_field(self, values: list) -> str:
+        AGG_FUNCS = '|'.join(cls.__name__ for cls in Aggregate.__subclasses__())
+        # --------------------------------------------------------------
+        def is_agg_field(fld: str) -> bool:
+            return re.findall(fr'({AGG_FUNCS})[(]', fld, re.IGNORECASE)
+        # --------------------------------------------------------------
+        new_values = []
+        for val in values:
+            if is_agg_field(val):
+                self.aggregation_fields.append(val)
+            else:
+                new_values.append(val)
+        values = new_values        
+        return super().add_field(values)
+
+    def prefix(self, key: str) -> str:
+        def get_aggregate() -> str:
+            return 'AGGREGATE {} '.format(
+                ','.join(self.aggregation_fields)
+            ) 
+        return '{}{}{}{}{}'.format(
+            '|> ' if key != FROM else '',
+            self.LINE_BREAK,
+            get_aggregate() if key == GROUP_BY else '',
+            key, self.TABULATION
+        )
+
+    # 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, ',')
+
+
+
 class Parser:
     REGEX = {}
 
@@ -958,10 +1231,13 @@ class SQLParser(Parser):
                     if not key in values:
                         continue
                     separator = self.class_type.get_separator(key)
+                    cls = {
+                        ORDER_BY: OrderBy, GROUP_BY: GroupBy
+                    }.get(key, Field)
                     obj.values[key] = [
-                        Field.format(fld, obj)
+                        cls.format(fld, obj)
                         for fld in re.split(separator, values[key])
-                        if (fld != '*' and len(tables) == 1) or obj.match(fld)
+                        if (fld != '*' and len(tables) == 1) or obj.match(fld, key)
                     ]
                 result[obj.alias] = obj
         self.queries = list( result.values() )
@@ -1021,16 +1297,26 @@ class CypherParser(Parser):
         if token in self.TOKEN_METHODS:
             return
         class_list = [Field]
-        if '$' in token:
+        if '*' in token:
+            token = token.replace('*', '')
+            self.queries[-1].key_field = token
+            return
+        elif '$' 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 = []
+                pk_field = self.queries[-1].key_field or 'id'
+                Count().As(token, extra_classes).add(pk_field, self.queries[-1])
+                return
             else:
-                FUNCTION_CLASS = {f.__name__.lower(): f for f in Function.__subclasses__()}
-                class_list = [ FUNCTION_CLASS[func_name] ]
+                class_type = FUNCTION_CLASS.get(func_name)
+                if not class_type:
+                    raise ValueError(f'Unknown function `{func_name}`.')
+                if ':' in token:
+                    token, field_alias = token.split(':')
+                    class_type = class_type().As(field_alias)
+                class_list = [class_type]
         class_list += extra_classes
         FieldList(token, class_list).add('', self.queries[-1])
 
@@ -1045,10 +1331,13 @@ class CypherParser(Parser):
     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):
-                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 last.key_field:
+                pk_field = last.key_field
+            else:
+                if not last.values.get(SELECT):
+                    raise IndexError(f'Primary Key not found for {last.table_name}.')
+                pk_field = last.values[SELECT][-1].split('.')[-1]
+                last.delete(pk_field, [SELECT], exact=True)
         if '{}' in token:
             foreign_fld = token.format(
                 last.table_name.lower()
@@ -1063,12 +1352,11 @@ class CypherParser(Parser):
                 if fld not in curr.values.get(GROUP_BY, [])
             ]
             foreign_fld = fields[0].split('.')[-1]
-            curr.delete(foreign_fld, [SELECT])
+            curr.delete(foreign_fld, [SELECT], exact=True)
             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)
 
@@ -1192,7 +1480,18 @@ class MongoParser(Parser):
 
     def begin_conditions(self, value: str):
         self.where_list = {}
+        self.field_method = self.first_ORfield
         return Where
+    
+    def first_ORfield(self, text: str):
+        if text.startswith('$'):
+            return
+        found = re.search(r'\w+[:]', text)
+        if not found:
+            return
+        self.field_method = None
+        p1, p2 = found.span()
+        self.last_field = text[p1: p2-1]
 
     def increment_brackets(self, value: str):
         self.brackets[value] += 1
@@ -1201,6 +1500,7 @@ class MongoParser(Parser):
         self.method = self.new_query
         self.last_field = ''
         self.where_list = None
+        self.field_method = None
         self.PARAM_BY_FUNCTION = {
             'find': Where, 'aggregate': GroupBy, 'sort': OrderBy
         }
@@ -1230,13 +1530,14 @@ class MongoParser(Parser):
                 self.close_brackets(
                     BRACKET_PAIR[token]
                 )
+            elif self.field_method:
+                self.field_method(token)
             self.method = self.TOKEN_METHODS.get(token)
 # ----------------------------
 
 
 class Select(SQLObject):
     join_type: JoinType = JoinType.INNER
-    REGEX = {}
     EQUIVALENT_NAMES = {}
 
     def __init__(self, table_name: str='', **values):
@@ -1254,21 +1555,30 @@ class Select(SQLObject):
 
     def add(self, name: str, main: SQLObject):
         old_tables = main.values.get(FROM, [])
-        new_tables = set([
-            '{jt}JOIN {tb} {a2} ON ({a1}.{f1} = {a2}.{f2})'.format(
+        if len(self.values[FROM]) > 1:
+            old_tables += self.values[FROM][1:]
+        new_tables = []
+        row = '{jt}JOIN {tb} {a2} ON ({a1}.{f1} = {a2}.{f2})'.format(
                 jt=self.join_type.value,
                 tb=self.aka(),
                 a1=main.alias, f1=name,
                 a2=self.alias, f2=self.key_field
             )
-        ] + old_tables[1:])
-        main.values[FROM] = old_tables[:1] + list(new_tables)
+        if row not in old_tables[1:]:
+            new_tables.append(row)
+        main.values[FROM] = old_tables[:1] + new_tables + old_tables[1:]
         for key in USUAL_KEYS:
             main.update_values(key, self.values.get(key, []))
 
-    def __add__(self, other: SQLObject):
+    def copy(self) -> SQLObject:
         from copy import deepcopy
-        query = deepcopy(self)
+        return deepcopy(self)
+
+    def no_relation_error(self, other: SQLObject):
+        raise ValueError(f'No relationship found between {self.table_name} and {other.table_name}.')
+
+    def __add__(self, other: SQLObject):
+        query = self.copy()
         if query.table_name.lower() == other.table_name.lower():
             for key in USUAL_KEYS:
                 query.update_values(key, other.values.get(key, []))
@@ -1281,7 +1591,7 @@ class Select(SQLObject):
                     PrimaryKey.add(primary_key, query)
                 query.add(foreign_field, other)
                 return other
-            raise ValueError(f'No relationship found between {query.table_name} and {other.table_name}.')
+            self.no_relation_error(other) # === raise ERROR ...  ===
         elif primary_key:
             PrimaryKey.add(primary_key, other)
         other.add(foreign_field, query)
@@ -1301,16 +1611,48 @@ class Select(SQLObject):
             if self.diff(key, other.values.get(key, []), True):
                 return False
         return True
+    
+    def __sub__(self, other: SQLObject) -> SQLObject:        
+        fk_field, primary_k = ForeignKey.find(self, other)
+        if fk_field:
+            query = self.copy()
+            other = other.copy()
+        else:
+            fk_field, primary_k = ForeignKey.find(other, self)
+            if not fk_field:
+                self.no_relation_error(other) # === raise ERROR ...  ===
+            query = other.copy()
+            other = self.copy()
+        query.__class__ = NotSelectIN
+        Field.add(fk_field, query)
+        query.add(primary_k, other)
+        return other
 
     def limit(self, row_count: int=100, offset: int=0):
-        result = [str(row_count)]
-        if offset > 0:
-            result.append(f'OFFSET {offset}')
-        self.values.setdefault(LIMIT, result)
+        if Function.dialect == Dialect.SQL_SERVER:
+            fields = self.values.get(SELECT)
+            if fields:
+                fields[0] = f'SELECT TOP({row_count}) {fields[0]}'
+            else:
+                self.values[SELECT] = [f'SELECT TOP({row_count}) *']
+            return self
+        if Function.dialect == Dialect.ORACLE:
+            Where.gte(row_count).add(SQL_ROW_NUM, self)
+            if offset > 0:
+                Where.lte(row_count+offset).add(SQL_ROW_NUM, self)
+            return self
+        self.values[LIMIT] = ['{}{}'.format(
+            row_count, f' OFFSET {offset}' if offset > 0 else ''
+        )]
         return self
 
-    def match(self, expr: str) -> bool:
-        return re.findall(f'\b*{self.alias}[.]', expr) != []
+    def match(self, field: str, key: str) -> bool:
+        '''
+        Recognizes if the field is from the current table
+        '''
+        if key in (ORDER_BY, GROUP_BY) and '.' not in field:
+            return self.has_named_field(field)
+        return re.findall(f'\b*{self.alias}[.]', field) != []
 
     @classmethod
     def parse(cls, txt: str, parser: Parser = SQLParser) -> list[SQLObject]:
@@ -1322,12 +1664,10 @@ class Select(SQLObject):
         for rule in rules:
             rule.apply(self)
 
-    def add_fields(self, fields: list, order_by: bool=False, group_by:bool=False):
-        class_types = [Field]
-        if order_by:
-            class_types += [OrderBy]
-        if group_by:
-            class_types += [GroupBy]
+    def add_fields(self, fields: list, class_types=None):
+        if not class_types:
+            class_types = []
+        class_types += [Field]
         FieldList(fields, class_types).add('', self)
 
     def translate_to(self, language: QueryLanguage) -> str:
@@ -1347,6 +1687,95 @@ class NotSelectIN(SelectIN):
     condition_class = Not
 
 
+class CTE(Select):
+    prefix = ''
+
+    def __init__(self, table_name: str, query_list: list[Select]):
+        super().__init__(table_name)
+        for query in query_list:
+            query.break_lines = False
+        self.query_list = query_list
+        self.break_lines = False
+
+    def __str__(self) -> str:
+        size = 0
+        for key in USUAL_KEYS:
+            size += sum(len(v) for v in self.values.get(key, []) if '\n' not in v)
+        if size > 70:
+            self.break_lines = True
+        # ---------------------------------------------------------
+        def justify(query: Select) -> str:
+            result, line = [], ''
+            keywords = '|'.join(KEYWORD)
+            for word in re.split(fr'({keywords}|AND|OR|,)', str(query)):
+                if len(line) >= 50:
+                    result.append(line)
+                    line = ''
+                line += word
+            if line:
+                result.append(line)
+            return '\n    '.join(result)
+        # ---------------------------------------------------------
+        return 'WITH {}{} AS (\n    {}\n){}'.format(
+            self.prefix, self.table_name, 
+            '\nUNION ALL\n    '.join(
+                justify(q) for q in self.query_list
+            ), super().__str__()
+        )
+
+    def join(self, pattern: str, fields: list | str, format: str=''):
+        if isinstance(fields, str):
+            count = len( fields.split(',') )
+        else:
+            count = len(fields)
+        queries = detect(
+            pattern*count, join_queries=False, format=format
+        )
+        FieldList(fields, queries, ziped=True).add('', self)
+        self.break_lines = True
+        return self
+
+class Recursive(CTE):
+    prefix = 'RECURSIVE '
+
+    def __str__(self) -> str:
+        if len(self.query_list) > 1:
+            self.query_list[-1].values[FROM].append(
+                f', {self.table_name} {self.alias}')
+        return super().__str__()
+
+    @classmethod
+    def create(cls, name: str, pattern: str, formula: str, init_value, format: str=''):
+        SQLObject.ALIAS_FUNC = None
+        def get_field(obj: SQLObject, pos: int) -> str:
+            return obj.values[SELECT][pos].split('.')[-1]
+        t1, t2 = detect(
+            pattern*2, join_queries=False, format=format
+        )
+        pk_field = get_field(t1, 0)
+        foreign_key = ''
+        for num in re.findall(r'\[(\d+)\]', formula):
+            num = int(num)
+            if not foreign_key:
+                foreign_key = get_field(t2, num-1)
+                formula = formula.replace(f'[{num}]', '%')
+            else:
+                formula = formula.replace(f'[{num}]', get_field(t2, num-1))
+        Where.eq(init_value).add(pk_field, t1)
+        Where.formula(formula).add(foreign_key or pk_field, t2)
+        return cls(name, [t1, t2])
+
+    def counter(self, name: str, start, increment: str='+1'):
+        for i, query in enumerate(self.query_list):
+            if i == 0:
+                Field.add(f'{start} AS {name}', query)
+            else:
+                Field.add(f'({name}{increment}) AS {name}', query)
+        return self
+
+
+# ----- Rules -----
+
 class RulePutLimit(Rule):
     @classmethod
     def apply(cls, target: Select):
@@ -1410,6 +1839,8 @@ class RuleDateFuncReplace(Rule):
     @classmethod
     def apply(cls, target: Select):
         for i, condition in enumerate(target.values.get(WHERE, [])):
+            if not '(' in condition:
+                continue
             tokens = [
                 t.strip() for t in cls.REGEX.split(condition) if t.strip()
             ]
@@ -1431,12 +1862,13 @@ class RuleReplaceJoinBySubselect(Rule):
             more_relations = any([
                 ref[0] == query.table_name for ref in ForeignKey.references
             ])
-            invalid = any([
+            keep_join = any([
                 len( query.values.get(SELECT, []) ) > 0,
                 len( query.values.get(WHERE, []) ) == 0,
                 not fk_field, more_relations
             ])
-            if invalid:
+            if keep_join:
+                query.add(fk_field, main)
                 continue
             query.__class__ = SubSelect
             Field.add(primary_k, query)
@@ -1460,7 +1892,7 @@ def parser_class(text: str) -> Parser:
     return None
 
 
-def detect(text: str) -> Select:    
+def detect(text: str, join_queries: bool = True, format: str='') -> Select | list[Select]:
     from collections import Counter
     parser = parser_class(text)
     if not parser:
@@ -1471,14 +1903,65 @@ def detect(text: str) -> Select:
                 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)
+                new_name = f'{table}_{count}'  # See set_table (line 55)
                 Select.EQUIVALENT_NAMES[new_name] = table
                 text = text[:begin] + new_name + '(' + text[end:]
                 count -= 1
     query_list = Select.parse(text, parser)
+    if format:
+        for query in query_list:
+            query.set_file_format(format)
+    if not join_queries:
+        return query_list
     result = query_list[0]
     for query in query_list[1:]:
         result += query
     return result
-
-
+# ===========================================================================================//
+
+
+if __name__ == "__main__":
+    # def identifica_suspeitos() -> Select:
+    #     """Mostra quais pessoas tem caracteríosticas iguais à descrição do suspeito"""
+    #     Select.join_type = JoinType.LEFT
+    #     return Select(
+    #         'Suspeito s', id=Field,
+    #         _=Where.join( 
+    #             Select('Pessoa p',
+    #                 OR=Options(
+    #                     pessoa=Where('= s.id'),
+    #                     altura=Where.formula('ABS(% - s.{f}) < 0.5'),
+    #                     peso=Where.formula('ABS(% - s.{f}) < 0.5'),
+    #                     cabelo=Where.formula('% = s.{f}'),
+    #                     olhos=Where.formula('% = s.{f}'),
+    #                     sexo=Where.formula('% = s.{f}'),
+    #                 ), 
+    #                 nome=Field
+    #             )
+    #         )
+    #     )
+    # query = identifica_suspeitos()
+    # print('='*50)
+    # print(query)
+    # print('-'*50)
+    script = '''
+    db.people.find({
+            {
+                $or: [
+                    status:{$eq:"B"},
+                    age:{$lt:50}
+                ]
+            },
+            age:{$gte:18},  status:{$eq:"A"}
+    },{
+            name: 1, user_id: 1
+    }).sort({
+    '''
+    print('='*50)
+    q1 = Select.parse(script, MongoParser)[0]
+    print(q1)
+    print('-'*50)
+    q2 = q1.translate_to(MongoDBLanguage)
+    print(q2)
+    # print('-'*50)
+    print('='*50)