sql-blocks 1.25.13__py3-none-any.whl → 1.25.111__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,7 +41,10 @@ class SQLObject:
     def set_table(self, table_name: str):
         if not table_name:
             return
-        if ' ' in table_name.strip():
+        cls = SQLObject
+        if cls.ALIAS_FUNC:
+            self.__alias = cls.ALIAS_FUNC(table_name)
+        elif ' ' in table_name.strip():
             table_name, self.__alias = table_name.split()
         elif '_' in table_name:
             self.__alias = ''.join(
@@ -49,7 +52,7 @@ class SQLObject:
                 for word in table_name.split('_')
             )
         else:
-            self.__alias = SQLObject.ALIAS_FUNC(table_name)
+            self.__alias = table_name.lower()[:3]
         self.values.setdefault(FROM, []).append(f'{table_name} {self.alias}')
 
     @property
@@ -111,15 +114,26 @@ class SQLObject:
             self.values[key] = result
 
 
+SQL_CONST_SYSDATE = 'SYSDATE'
+SQL_CONST_CURR_DATE = 'Current_date'
+SQL_CONSTS = [SQL_CONST_SYSDATE, SQL_CONST_CURR_DATE]
+
+
 class Field:
     prefix = ''
 
     @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():
             name = f'{main.alias}.{name}'
         if Function in cls.__bases__:
             name = f'{cls.__name__}({name})'
@@ -150,7 +164,16 @@ class NamedField:
         )
 
 
+class Dialect(Enum):
+    ANSI = 0
+    SQL_SERVER = 1
+    ORACLE = 2
+    POSTGRESQL = 3
+    MYSQL = 4
+
 class Function:
+    dialect = Dialect.ANSI
+
     def __init__(self, *params: list):
         # --- Replace class methods by instance methods: ------
         self.add = self.__add
@@ -158,26 +181,30 @@ class Function:
         # -----------------------------------------------------
         self.params = [str(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 __str__(self) -> str:
+        return self.pattern.format(
+            func_name=self.__class__.__name__,
+            params=', '.join(self.params)
+        )
+
     def __format(self, name: str, main: SQLObject) -> str:
-        if name in '*_' and self.params:
-            params = self.params
-        else:
-            params = [
+        if name not in '*_':
+            self.params = [
                 Field.format(name, main)
             ] + self.params
-        return self.pattern.format(
-            self.__class__.__name__,
-            ', '.join(params)
-        )
+        return str(self)
 
     @classmethod
     def format(cls, name: str, main: SQLObject):
@@ -196,7 +223,10 @@ class Function:
 
 # ---- String Functions: ---------------------------------
 class SubString(Function):
-    ...
+    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):
@@ -204,13 +234,37 @@ class Round(Function):
 
 # --- Date Functions: ------------------------------------
 class DateDiff(Function):
-    ...
-class Extract(Function):
-    ...
-class DatePart(Function):
-    ...
+    def get_pattern(self) -> str:
+        def is_field_or_func(name: str) -> bool:
+            return re.sub('[()]', '', name).isidentifier()
+        if self.dialect != Dialect.SQL_SERVER:
+            return ' - '.join(
+                p if is_field_or_func(p) else f"'{p}'"
+                for p in self.params
+            )  # <====  Date subtract
+        return super().get_pattern()
+
+class Year(Function):
+    def get_pattern(self) -> str:
+        database_type = {
+            Dialect.ORACLE: 'Extract(YEAR FROM {params})',
+            Dialect.POSTGRESQL: "Date_Part('year', {params})",
+        }
+        if self.dialect in database_type:
+            return database_type[self.dialect]
+        return super().get_pattern()
+
 class Current_Date(Function):
-    ...
+    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:
     break_lines: bool = True
@@ -225,7 +279,7 @@ class Aggregate:
         )
         if keywords and self.break_lines:
             keywords += '\n\t'
-        self.pattern = '{}({})' + f' OVER({keywords})'
+        self.pattern = self.get_pattern() + f' OVER({keywords})'
         return self
 
 
@@ -324,6 +378,12 @@ def quoted(value) -> str:
     return str(value)
 
 
+class Position(Enum):
+    Middle = 0
+    StartsWith = 1
+    EndsWith = 2
+
+
 class Where:
     prefix = ''
 
@@ -339,8 +399,14 @@ class Where:
         return cls.__constructor('=', value)
 
     @classmethod
-    def contains(cls, value: str):
-        return cls(f"LIKE '%{value}%'")
+    def contains(cls, content: str, pos: Position = Position.Middle):
+        return cls(
+            "LIKE '{}{}{}'".format(
+                '%' if pos != Position.StartsWith else '',
+                content,
+                '%' if pos != Position.EndsWith else ''
+            )
+        )
    
     @classmethod
     def gt(cls, value):
@@ -420,9 +486,8 @@ 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():
@@ -1320,6 +1385,31 @@ 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
+            ])
+            invalid = any([
+                len( query.values.get(SELECT, []) ) > 0,
+                len( query.values.get(WHERE, []) ) == 0,
+                not fk_field, more_relations
+            ])
+            if invalid:
+                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),
@@ -1355,11 +1445,15 @@ def detect(text: str) -> Select:
         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)
+        'Installments i', due_date=Field,  customer=Select(
+            'Customer c', id=PrimaryKey,
+            name=contains('Smith', Position.EndsWith)
+        )
     )
     print(query)
+    print('-----')
+    query.optimize([RuleReplaceJoinBySubselect])
+    print(query)

{sql_blocks-1.25.13.dist-info → sql_blocks-1.25.111.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql_blocks
-Version: 1.25.13
+Version: 1.25.111
 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
@@ -97,8 +97,13 @@ query = Select('Movie m', title=Field,
         genre=eq("Sci-Fi"),
         awards=contains("Oscar")
     )
+    AND=Options(
+        ..., name=contains(
+            'Chris',
+            Position.StartsWith
+        )
+    )
 ```
-> Could be AND=Options(...)
 
 3.4 -- Negative conditions use the _Not_ class instead of _Where_
 ```
@@ -363,6 +368,35 @@ m2 = Select(
 
 > The method allows you to select which rules you want to apply in the optimization...Or define your own rules!
 
+>> NOTE: When a joined table is used only as a filter, it is possible that it can be changed to a sub-query:
+
+    query = Select(
+        'Installments i', due_date=Field,  customer=Select(
+            'Customer c', id=PrimaryKey,
+            name=contains('Smith', Position.EndsWith)
+        )
+    )
+    print(query)
+    print('-----')
+    query.optimize([RuleReplaceJoinBySubselect])
+    print(query)
+```
+SELECT
+        i.due_date
+FROM
+        Installments i
+        JOIN Customer c ON (i.customer = c.id)
+WHERE
+        c.name LIKE '%Smith'
+-----
+SELECT
+        i.due_date
+FROM
+        Installments i
+WHERE
+        i.customer IN (SELECT c.id FROM Customer c WHERE c.name LIKE '%Smith')
+```
+
 ---
 
 ### 12 - Adding multiple fields at once
@@ -567,3 +601,21 @@ GROUP BY
 ORDER BY
         customer_count
 ```
+---
+### 16 - Function classes
+You may use this functions:
+* SubString
+* Round
+* DateDiff
+* Year
+* Current_Date
+* Avg
+* Min
+* Max
+* Sum
+* Count
+> Some of these functions may vary in syntax depending on the database.
+For example, if your query is going to run on Oracle, do the following:
+
+`Function.dialect = Dialect.ORACLE`
+

sql_blocks-1.25.111.dist-info/RECORD

@@ -0,0 +1,7 @@
+sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
+sql_blocks/sql_blocks.py,sha256=rARGbJxL3Di9mOXRBS4aEFvclO922-dzDOXPy1vSTGg,49018
+sql_blocks-1.25.111.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+sql_blocks-1.25.111.dist-info/METADATA,sha256=Lm7JKPIdZSJT5dkWUc2K7fpY4r0MQ-TeTyv0pbiMy24,14581
+sql_blocks-1.25.111.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sql_blocks-1.25.111.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
+sql_blocks-1.25.111.dist-info/RECORD,,

sql_blocks-1.25.13.dist-info/RECORD

@@ -1,7 +0,0 @@
-sql_blocks/__init__.py,sha256=5ItzGCyqqa6kwY8wvF9kapyHsAiWJ7KEXCcC-OtdXKg,37
-sql_blocks/sql_blocks.py,sha256=P5yp0Ug4PD56xklmQOtpNLKm9hfhHBNb8TDkOneNAHw,45783
-sql_blocks-1.25.13.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-sql_blocks-1.25.13.dist-info/METADATA,sha256=tahTyaVcsa4ROoxQSMK41W6m20bVlDs6_kh9b9mkgoc,13424
-sql_blocks-1.25.13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sql_blocks-1.25.13.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
-sql_blocks-1.25.13.dist-info/RECORD,,