sql-blocks 1.25.13__py3-none-any.whl → 1.25.51__py3-none-any.whl

sql_blocks/sql_blocks.py

@@ -26,7 +26,7 @@ TO_LIST = lambda x: x if isinstance(x, list) else [x]
 
 
 class SQLObject:
-    ALIAS_FUNC = lambda t: t.lower()[:3]
+    ALIAS_FUNC = None
     """    ^^^^^^^^^^^^^^^^^^^^^^^^
     You can change the behavior by assigning 
     a user function to SQLObject.ALIAS_FUNC
@@ -41,21 +41,35 @@ class SQLObject:
     def set_table(self, table_name: str):
         if not table_name:
             return
-        if ' ' in table_name.strip():
+        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(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 = SQLObject.ALIAS_FUNC(table_name)
+            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:
@@ -67,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:
@@ -79,12 +103,12 @@ class SQLObject:
             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)
         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)
@@ -102,13 +126,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_ROW_NUM = 'ROWNUM'
+SQL_CONSTS = [SQL_CONST_SYSDATE, SQL_CONST_CURR_DATE, SQL_ROW_NUM]
 
 
 class Field:
@@ -116,10 +149,16 @@ class Field:
 
     @classmethod
     def format(cls, name: str, main: SQLObject) -> str:
+        def is_const() -> bool:
+            return any([
+                re.findall('[.()0-9]', name),
+                name in SQL_CONSTS,
+                re.findall(r'\w+\s*[+-]\s*\w+', name)
+            ])
         name = name.strip()
         if name in ('_', '*'):
             name = '*'
-        elif not re.findall('[.()0-9]', name):
+        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})'
@@ -150,35 +189,89 @@ class NamedField:
         )
 
 
+class Dialect(Enum):
+    ANSI = 0
+    SQL_SERVER = 1
+    ORACLE = 2
+    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.pattern = self.get_pattern()
         self.extra = {}
     
+    def get_pattern(self) -> str:
+        return '{func_name}({params})'
+
     def As(self, field_alias: str, modifiers=None):
         if modifiers:
             self.extra[field_alias] = TO_LIST(modifiers)
         self.field_class = NamedField(field_alias)
         return self
 
-    def __format(self, name: str, main: SQLObject) -> str:
-        if name in '*_' and self.params:
-            params = self.params
-        else:
-            params = [
-                Field.format(name, main)
-            ] + self.params
+    def __str__(self) -> str:
         return self.pattern.format(
-            self.__class__.__name__,
-            ', '.join(params)
+            func_name=self.__class__.__name__,
+            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.set_main_param(name, main)
+        return str(self)
+
     @classmethod
     def format(cls, name: str, main: SQLObject):
         return cls().__format(name, main)
@@ -196,39 +289,110 @@ 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})'
+        return super().get_pattern()
 
 # ---- Numeric Functions: --------------------------------
 class Round(Function):
-    ...
+    inputs = [FLOAT]
+    output = FLOAT
 
 # --- Date Functions: ------------------------------------
 class DateDiff(Function):
+    inputs = [DATE]
+    output = DATE
+    append_param = True
+
+    def __str__(self) -> str:
+        def is_field_or_func(name: str) -> bool:
+            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 params
+            )  # <====  Date subtract
+        return super().__str__()
+
+
+class DatePart(Function):
+    inputs = [DATE]
+    output = INT
+
+    def get_pattern(self) -> str:
+        interval = self.__class__.__name__
+        database_type = {
+            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 Extract(Function):
+class Month(DatePart):
     ...
-class DatePart(Function):
+class Day(DatePart):
     ...
+
+
 class Current_Date(Function):
-    ...
+    output = DATE
+
+    def get_pattern(self) -> str:
+        database_type = {
+            Dialect.ORACLE: SQL_CONST_SYSDATE,
+            Dialect.POSTGRESQL: SQL_CONST_CURR_DATE,
+            Dialect.SQL_SERVER: 'getDate()'
+        }
+        if self.dialect in database_type:
+            return database_type[self.dialect]
+        return super().get_pattern()
+# --------------------------------------------------------
 
-class Aggregate:
+class Frame:
     break_lines: bool = True
 
     def over(self, **args):
-        keywords = ' '.join(
-            '{}{} BY {}'.format(
-                '\n\t\t' if self.break_lines else '',
-                key.upper(), args[key]
-            ) for key in ('partition', 'order')
-            if key in args
-        )
+        """
+        How to use:
+            over(field1=OrderBy, field2=Partition)
+        """
+        keywords = ''
+        for field, obj in args.items():
+            is_valid = any([
+                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 if field != '_' else ''
+            )
         if keywords and self.break_lines:
             keywords += '\n\t'
-        self.pattern = '{}({})' + f' OVER({keywords})'
+        self.pattern = self.get_pattern() + f' OVER({keywords})'
         return self
 
 
+class Aggregate(Frame):
+    inputs = [FLOAT]
+    output = FLOAT
+
+class Window(Frame):
+    ...
+
 # ---- Aggregate Functions: -------------------------------
 class Avg(Aggregate, Function):
     ...
@@ -241,11 +405,32 @@ class Sum(Aggregate, Function):
 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:
@@ -270,15 +455,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)
@@ -320,27 +510,43 @@ 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
+    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, value: str):
-        return cls(f"LIKE '%{value}%'")
+    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 '',
+                text,
+                '%' if pos != Position.EndsWith else ''
+            )
+        )
    
     @classmethod
     def gt(cls, value):
@@ -368,9 +574,42 @@ 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, []))
+        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
         ))
 
 
@@ -378,6 +617,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):
@@ -385,7 +628,7 @@ class Not(Where):
 
     @classmethod
     def eq(cls, value):
-        return Where(expr=f'<> {quoted(value)}')
+        return Where(f'<> {quoted(value)}')
 
 
 class Case:
@@ -394,22 +637,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)
@@ -420,14 +667,13 @@ class Options:
         self.__children: dict = values
 
     def add(self, logical_separator: str, main: SQLObject):
-        """
-        `logical_separator` must be AND or OR
-        """
+        if logical_separator not in ('AND', 'OR'):
+            raise ValueError('`logical_separator` must be AND or OR')
         conditions: list[str] = []
         child: Where
         for field, child in self.__children.items():
             conditions.append(' {} {} '.format(
-                Field.format(field, main), child.expr
+                Field.format(field, main), child.content
             ))
         main.values.setdefault(WHERE, []).append(
             '(' + logical_separator.join(conditions) + ')'
@@ -435,28 +681,57 @@ class Options:
 
 
 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
 
@@ -465,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
@@ -474,6 +777,16 @@ class OrderBy(Clause):
         name = cls.format(name, main)
         main.values.setdefault(ORDER_BY, []).append(name+cls.sort.value)
 
+    @classmethod
+    def cls_to_str(cls) -> str:
+        return ORDER_BY
+
+PARTITION_BY = 'PARTITION BY'
+class Partition:
+    @classmethod
+    def cls_to_str(cls) -> str:
+        return PARTITION_BY
+
 
 class GroupBy(Clause):
     @classmethod
@@ -489,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
@@ -519,7 +832,7 @@ 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
@@ -542,18 +855,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 = {}
@@ -857,10 +1173,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() )
@@ -920,16 +1239,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])
 
@@ -944,10 +1273,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()
@@ -962,12 +1294,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)
 
@@ -1135,7 +1466,6 @@ class MongoParser(Parser):
 
 class Select(SQLObject):
     join_type: JoinType = JoinType.INNER
-    REGEX = {}
     EQUIVALENT_NAMES = {}
 
     def __init__(self, table_name: str='', **values):
@@ -1153,21 +1483,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, []))
@@ -1180,7 +1519,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)
@@ -1200,16 +1539,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]:
@@ -1221,12 +1592,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:
@@ -1246,6 +1615,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):
@@ -1309,6 +1767,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()
             ]
@@ -1320,6 +1780,32 @@ class RuleDateFuncReplace(Rule):
             target.values[WHERE][i] = ' AND '.join(temp.values[WHERE])
 
 
+class RuleReplaceJoinBySubselect(Rule):
+    @classmethod
+    def apply(cls, target: Select):
+        main, *others = Select.parse( str(target) )
+        modified = False
+        for query in others:
+            fk_field, primary_k = ForeignKey.find(main, query)
+            more_relations = any([
+                ref[0] == query.table_name for ref in ForeignKey.references
+            ])
+            keep_join = any([
+                len( query.values.get(SELECT, []) ) > 0,
+                len( query.values.get(WHERE, []) ) == 0,
+                not fk_field, more_relations
+            ])
+            if keep_join:
+                query.add(fk_field, main)
+                continue
+            query.__class__ = SubSelect
+            Field.add(primary_k, query)
+            query.add(fk_field, main)
+            modified = True
+        if modified:
+            target.values = main.values.copy()
+
+
 def parser_class(text: str) -> Parser:
     PARSER_REGEX = [
         (r'select.*from', SQLParser),
@@ -1334,7 +1820,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:
@@ -1345,21 +1831,18 @@ 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__":
-    OrderBy.sort = SortType.DESC
-    query = Select(
-        'order_Detail d',
-        customer_id=GroupBy,
-        _=Sum('d.unitPrice * d.quantity').As('total', OrderBy)
-    )
-    print(query)
+# ===========================================================================================//