sql-blocks 0.0.2__py3-none-any.whl

sql_blocks/__init__.py

@@ -0,0 +1 @@
+from sql_blocks import *

sql_blocks/sql_blocks.py

@@ -0,0 +1,434 @@
+from enum import Enum
+
+KEYWORD = {
+    'SELECT': (',{}', 'SELECT *'),
+    'FROM': ('{}', ''),
+    'WHERE': ('{}AND ', ''),
+    'GROUP BY': (',{}', ''),
+    'ORDER BY': (',{}', ''),
+    'LIMIT': (' ', ''),
+}
+SELECT, FROM, WHERE, GROUP_BY, ORDER_BY, LIMIT = KEYWORD.keys()
+USUAL_KEYS = [SELECT, WHERE, GROUP_BY, ORDER_BY]
+
+
+class SQLObject:
+    def __init__(self, table_name: str=''):
+        self.alias = ''
+        self.values = {}
+        self.key_field = ''
+        self.set_table(table_name)
+
+    def set_table(self, table_name: str):
+        if not table_name:
+            return
+        if ' ' in table_name:
+            table_name, self.alias = table_name.split()
+        elif '_' in table_name:
+            self.alias = ''.join(
+                word[0].lower()
+                for word in table_name.split('_')
+            )
+        else:
+            self.alias = table_name.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 delete(self, search: str, keys: list=USUAL_KEYS):
+        for key in keys:
+            result = []
+            for item in self.values.get(key, []):
+                if search not in item:
+                    result.append(item)
+            self.values[key] = result
+
+
+class Function:
+    ...
+
+class Field:
+    prefix = ''
+
+    @classmethod
+    def format(cls, name: str, main: SQLObject) -> str:
+        if name == '_':
+            name = '*'
+        else:
+            name = f'{main.alias}.{name}'
+        if Function in cls.__bases__:
+            name = f'{cls.__name__}({name})'
+        return f'{cls.prefix}{name}'
+
+    @classmethod
+    def add(cls, name: str, main: SQLObject):
+        main.values.setdefault(SELECT, []).append(
+            cls.format(name, main)
+        )
+
+
+class Avg(Function, Field):
+    ...
+class Min(Function, Field):
+    ...
+class Max(Function, Field):
+    ...
+class Sum(Function, Field):
+    ...
+class Count(Function, Field):
+    ...
+
+class Distinct(Field):
+    prefix = 'DISTINCT '
+
+
+class NamedField:
+    def __init__(self, alias: str, class_type = Field):
+        self.alias = alias
+        if class_type not in [Field] + Field.__subclasses__():
+            raise TypeError('class_type must be a Field (sub)class.')
+        self.class_type = class_type
+
+    def add(self, name: str, main: SQLObject):
+        main.values.setdefault(SELECT, []).append(
+            '{} as {}'.format(
+                self.class_type.format(name, main),
+                self.alias
+            )
+        )
+
+
+class Table:
+    def __init__(self, fields: list | str=[]):
+        if isinstance(fields, str):
+            fields = [f.strip() for f in fields.split(',')]
+        self.fields = fields
+
+    def add(self, name: str, main: SQLObject):
+        main.set_table(name)
+        for field in self.fields:
+            Field.add(field, main)
+
+
+class PrimaryKey:
+    @staticmethod
+    def add(name: str, main: SQLObject):
+        main.key_field = name
+
+
+class ForeignKey:
+    references = {}
+
+    def __init__(self, table_name: str):
+        self.table_name = table_name
+
+    def add(self, name: str, main: SQLObject):
+        key = f'{main.table_name}_{self.table_name}'
+        ForeignKey.references[key] = name
+
+    @classmethod
+    def find(cls, obj1: SQLObject, obj2: SQLObject) -> list:
+        key = f'{obj1.table_name}_{obj2.table_name}'
+        return cls.references.get(key, '').split('_')
+
+
+def quoted(value) -> str:
+    if isinstance(value, str):
+        value = f"'{value}'"
+    return str(value)
+
+
+class Where:
+    prefix = ''
+
+    def __init__(self, expr: str):
+        self.expr = f'{self.prefix}{expr}'
+
+    @classmethod
+    def __constructor(cls, operator: str, value):
+        return cls(expr=f'{operator} {quoted(value)}')
+
+    @classmethod
+    def eq(cls, value):
+        return cls.__constructor('=', value)
+
+    @classmethod
+    def like(cls, value: str):
+        return cls(f"LIKE '%{value}%'")
+   
+    @classmethod
+    def gt(cls, value):
+        return cls.__constructor('>', value)
+
+    @classmethod
+    def gte(cls, value):
+        return cls.__constructor('>=', value)
+
+    @classmethod
+    def lt(cls, value):
+        return cls.__constructor('<', value)
+
+    @classmethod
+    def lte(cls, value):
+        return cls.__constructor('<=', value)
+    
+    @classmethod
+    def is_null(cls):
+        return cls('IS NULL')
+    
+    @classmethod
+    def list(cls, values):
+        if isinstance(values, list):
+            values = ','.join(quoted(v) for v in values)
+        return cls(f'IN ({values})')
+
+    def add(self, name: str, main: SQLObject):
+        main.values.setdefault(WHERE, []).append('{} {}'.format(
+            Field.format(name, main), self.expr
+        ))
+
+
+class Not(Where):
+    prefix = 'NOT '
+
+    @classmethod
+    def eq(cls, value):
+        return Where.__constructor('<>', value)
+
+
+class Case:
+    def __init__(self, field: str):
+        self.__conditions = {}
+        self.default = None
+        self.field = field
+
+    def when(self, condition: Where, result: str):
+        self.__conditions[result] = condition
+        return self
+    
+    def else_value(self, default: str):
+        self.default = default
+        return self
+    
+    def add(self, name: str, main: SQLObject):
+        field = Field.format(self.field, main)
+        default = quoted(self.default)
+        name = 'CASE \n{}\n\tEND AS {}'.format(
+            '\n'.join(
+                f'\t\tWHEN {field} {cond.expr} THEN {quoted(res)}'
+                for res, cond in self.__conditions.items()
+            ) + f'\n\t\tELSE {default}' if default else '',
+            name
+        )
+        main.values.setdefault(SELECT, []).append(name)
+
+
+class Options:
+    def __init__(self, **values):
+        self.__children: dict = values
+
+    def add(self, logical_separator: str, main: SQLObject):
+        """
+        `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
+            ))
+        main.values.setdefault(WHERE, []).append(
+            '(' + logical_separator.join(conditions) + ')'
+        )
+
+
+class Between:
+    def __init__(self, start, end):
+        if start > end:
+            start, end = end, start
+        self.start = start
+        self.end = end
+
+    def add(self, name: str, main:SQLObject):
+        Where.gte(self.start).add(name, main),
+        Where.lte(self.end).add(name, main)
+
+
+class SortType(Enum):
+    ASC = ''
+    DESC = ' DESC'
+
+class OrderBy:
+    sort: SortType = SortType.ASC
+    @classmethod
+    def add(cls, name: str, main: SQLObject):
+        if main.alias:
+            name = f'{main.alias}.{name}'
+        main.values.setdefault(ORDER_BY, []).append(name + cls.sort.value)
+
+
+class GroupBy:
+    @staticmethod
+    def add(name: str, main: SQLObject):
+        main.values.setdefault(GROUP_BY, []).append(f'{main.alias}.{name}')
+
+
+class Having:
+    def __init__(self, function: Function, condition: Where):
+        self.function = function
+        self.condition = condition
+
+    def add(self, name: str, main:SQLObject):
+        main.values[GROUP_BY][-1] += ' HAVING {} {}'.format(
+            self.function.format(name, main), self.condition.expr
+        )
+    
+    @classmethod
+    def avg(cls, condition: Where):
+        return cls(Avg, condition)
+    
+    @classmethod
+    def min(cls, condition: Where):
+        return cls(Min, condition)
+    
+    @classmethod
+    def max(cls, condition: Where):
+        return cls(Max, condition)
+    
+    @classmethod
+    def sum(cls, condition: Where):
+        return cls(Sum, condition)
+    
+    @classmethod
+    def count(cls, condition: Where):
+        return cls(Count, condition)
+
+
+class JoinType(Enum):
+    INNER = ''
+    LEFT = 'LEFT '
+    RIGHT = 'RIGHT '
+    FULL = 'FULL '
+
+class Select(SQLObject):
+    join_type: JoinType = JoinType.INNER
+    REGEX = None
+
+    def __init__(self, table_name: str='', **values):
+        super().__init__(table_name)
+        self.__call__(**values)
+        self.break_lines = True
+
+    def add(self, name: str, main: SQLObject):
+        def update_values(key: str, new_values: list):
+            for value in new_values:
+                old_values = main.values.get(key, [])
+                if value not in old_values:
+                    main.values[key] = old_values + [value]
+        update_values(
+            FROM, [
+                '{jt}JOIN {tb} {a2} ON ({a1}.{f1} = {a2}.{f2})'.format(
+                    jt=self.join_type.value,
+                    tb=self.table_name,
+                    a1=main.alias, f1=name,
+                    a2=self.alias, f2=self.key_field
+                )
+            ] + self.values[FROM][1:]
+        )
+        for key in USUAL_KEYS:
+            update_values(key, self.values.get(key, []))
+
+    def __add__(self, other: SQLObject):
+        foreign_field, *primary_key = ForeignKey.find(self, other)
+        if not foreign_field:
+            foreign_field, *primary_key = ForeignKey.find(other, self)
+            if foreign_field:
+                if primary_key:
+                    PrimaryKey.add(primary_key[0], self)
+                self.add(foreign_field, other)
+                return other
+            raise ValueError(f'No relationship found between {self.table_name} and {other.table_name}.')
+        elif primary_key:
+            PrimaryKey.add(primary_key[0], other)
+        other.add(foreign_field, self)
+        return self
+
+    def __str__(self) -> str:
+        TABULATION = '\n\t' if self.break_lines else ' '
+        LINE_BREAK = '\n' if self.break_lines else ' '
+        DEFAULT = lambda key: KEYWORD[key][1]
+        FMT_SEP = lambda key: KEYWORD[key][0].format(TABULATION)
+        select, _from, where, groupBy, orderBy, limit = [
+            DEFAULT(key) if not self.values.get(key) else "{}{}{}{}".format(
+                LINE_BREAK, key, TABULATION, FMT_SEP(key).join(self.values[key])
+            ) for key in KEYWORD
+        ]
+        return f'{select}{_from}{where}{groupBy}{orderBy}{limit}'.strip()
+   
+    def __call__(self, **values):
+        to_list = lambda x: x if isinstance(x, list) else [x]
+        for name, params in values.items():
+            for obj in to_list(params):
+                obj.add(name, self)
+        return self
+
+    def __eq__(self, other: SQLObject) -> bool:
+        def sorted_values(obj: SQLObject, key: str) -> list:
+            return sorted(obj.values.get(key, []))
+        for key in KEYWORD:
+            if sorted_values(self, key) != sorted_values(other, key):
+                return False
+        return True
+
+    def limit(self, row_count: int, offset: int=0):
+        result = [str(row_count)]
+        if offset > 0:
+            result.append(f'OFFSET {offset}')
+        self.values.setdefault(LIMIT, result)
+        return self
+
+    @classmethod
+    def parse(cls, txt: str) -> list[SQLObject]:
+        import re
+        txt = re.sub(' +', ' ', re.sub('\n|\t', ' ', txt))
+        if not cls.REGEX:
+            keywords = '|'.join(KEYWORD)
+            cls.REGEX = re.compile(f'({keywords})', re.IGNORECASE)
+        tokens = [t.strip() for t in cls.REGEX.split(txt) if t.strip()]
+        values = {k: v for k, v in zip(tokens[::2], tokens[1::2])}
+        tables = [t.strip() for t in re.split('JOIN|LEFT|RIGHT|ON', values[FROM]) if t.strip()]
+        result = {}
+        for item in tables:
+            if '=' in item:
+                a1, f1, a2, f2 = [r.strip() for r in re.split('[().=]', item) if r]
+                obj1: SQLObject = result[a1]
+                obj2:SQLObject = result[a2]
+                PrimaryKey.add(f2, obj2)
+                ForeignKey(obj2.table_name).add(f1, obj1)
+            else:
+                obj = cls(item)
+                for key in USUAL_KEYS:
+                    if not key in values:
+                        continue
+                    separator = KEYWORD[key][0].format(
+                        ' ' if key == WHERE else ''
+                    )
+                    fields = [
+                        fld.strip() for fld in re.split(
+                            separator, values[key]
+                        ) if len(tables) == 1
+                        or re.findall(f'^[( ]*{obj.alias}\.', fld)
+                    ]
+                    obj.values[key] = [
+                        f'{obj.alias}.{f}' if not '.' in f else f for f in fields
+                    ]
+                result[obj.alias] = obj
+        return list( result.values() )
+
+
+class SubSelect(Select):
+    def add(self, name: str, main: SQLObject):
+        self.break_lines = False
+        Where.list(self).add(name, main)

sql_blocks-0.0.2.dist-info/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sql_blocks-0.0.2.dist-info/METADATA

@@ -0,0 +1,296 @@
+Metadata-Version: 2.1
+Name: sql_blocks
+Version: 0.0.2
+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
+Author-email: Julio Cascalles <julio.cascalles@outlook.com>
+Project-URL: Homepage, https://github.com/julio-cascalles/sql_blocks
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# SQL_Blocks
+
+### 1 - You can assemble a simple object that will then be converted into an SQL command:
+
+> a = Select('Actor') # --> SELECT * FROM Actor act
+
+_Note that an alias "act" has been added._
+
+You can specify your own alias:  `a = Select('Actor a')`
+
+---
+### 2 - You can also add a field, like this...
+
+* a = Select('Actor a', **name=Field**)
+
+* Here are another ways to add a field:
+    - Select('Actor a', name=Distinct )
+
+    - Select('Actor a', name=NamedField('actors_name'))
+
+    - Select(
+        'Actor a', 
+        name=NamedField('actors_name', Distinct)
+    )
+
+---
+
+### 3 - To set conditions, use **Where**:
+* For example, `a = Select(... age=Where.gt(45) )`
+
+    Some possible conditions:
+    * field=Where.eq(value) - ...the field is EQUAL to the value;
+    * field=Where.gt(value) - ...the field is GREATER than the value;
+    * field=Where.lt(value) - ...the field is LESS than the value;
+
+    3.1 -- If you want to filter the field on a range of values:
+    
+    `a = Select( 'Actor a', age=Between(45, 69) )`
+
+    3.2 -- Sub-queries:
+
+```
+query = Select('Movie m', title=Field,
+    id=SubSelect(
+        'Review r',
+        rate=Where.gt(4.5),
+        movie_id=Distinct
+    )
+)
+```
+
+**>> print(query)** 
+
+        SELECT
+            m.title
+        FROM
+            Movie m
+        WHERE
+            m.id IN (
+                SELECT DISTINCT r.movie
+                FROM Review r WHERE r.rate > 4.5
+            )
+    
+3.3 -- Optional conditions:
+```
+    OR=Options(
+        genre=Where.eq("Sci-Fi"),
+        awards=Where.like("Oscar")
+    )
+```
+> Could be AND=Options(...)
+
+---
+### 4 - A field can be two things at the same time:
+
+* m = Select('Movie m' release_date=[Field, OrderBy])
+    - This means that the field will appear in the results and also that the query will be ordered by that field.
+* Applying **GROUP BY** to item 3.2, it would look like this:
+    ```    
+    SubSelect(
+        'Review r', movie=[GroupBy, Distinct],
+        rate=Having.avg(Where.gt(4.5))
+    )
+    ```
+---
+### 5 - Relationships:
+```
+    query = Select('Actor a', name=Field,
+        cast=Select('Cast c', id=PrimaryKey)
+    )
+```
+**>> print(query)**    
+```
+SELECT
+    a.name
+FROM
+    Actor a
+    JOIN Cast c ON (a.cast = c.id)    
+```
+
+---
+### 6 - The reverse process (parse):
+```
+text = """
+        SELECT
+                cas.role,
+                m.title,
+                m.release_date,
+                a.name as actors_name
+        FROM
+                Actor a
+                LEFT JOIN Cast cas ON (a.cast = cas.id)
+                LEFT JOIN Movie m ON (cas.movie = m.id)
+        WHERE
+                (
+                    m.genre = 'Sci-Fi'
+                    OR
+                    m.awards LIKE '%Oscar%'
+                )
+                AND a.age <= 69 AND a.age >= 45
+        ORDER BY
+                m.release_date DESC
+"""
+```
+
+`a, c, m = Select.parse(text)`
+
+**6.1  --- print(a)**
+```
+    SELECT
+            a.name as actors_name
+    FROM
+            Actor a
+    WHERE
+            a.age <= 69
+            AND a.age >= 45
+```
+
+**6.2 --- print(c)**
+
+    SELECT
+            c.role
+    FROM
+            Cast c
+
+**6.3 --- print(m)**
+
+    SELECT
+            m.title,
+            m.release_date
+    FROM
+            Movie m
+    WHERE
+            ( m.genre = 'Sci-Fi' OR m.awards LIKE '%Oscar%' )
+    ORDER BY
+            m.release_date DESC
+
+
+
+**6.4 --- print(a+c)**
+
+    SELECT
+            a.name as actors_name,
+            cas.role
+    FROM
+            Actor a
+            JOIN Cast cas ON (a.cast = cas.id)
+    WHERE
+            a.age >= 45
+            AND a.age <= 69
+
+**6.5 --- print(c+m)** 
+> `... or  print(m+c)`
+
+    SELECT
+            cas.role,
+            m.title,
+            m.release_date,
+            m.director
+    FROM
+            Cast cas
+            JOIN Movie m ON (cas.movie = m.id)
+    WHERE
+            ( m.genre = 'Sci-Fi' OR m.awards LIKE '%Oscar%' )
+            AND m.director LIKE '%Coppola%'
+    ORDER BY
+            m.release_date,
+            m.director
+---
+
+### 7 - You can add or delete attributes directly in objects:
+* a(gender=Field)
+* m.delete('director')
+
+---
+
+### 8 - Defining relationship on separate objects:
+```
+a = Select...
+c = Select...
+m = Select...
+```
+`a + c => ERROR: "No relationship found between Actor and Cast"`
+
+8.1 - But...
+
+    a( cast=ForeignKey('Cast') )
+    c(id=PrimaryKey)
+
+**a + c => Ok!**
+
+8.2
+
+    c( movie=ForeignKey('Movie') )
+    m(id=PrimaryKey)
+
+> **c + m => Ok!**
+>> **m + c => Ok!**
+
+
+---
+
+### 9 - Comparing objects
+
+9.1
+```
+        a1 = Select.parse('''
+                SELECT gender, max(age) FROM Actor act
+                WHERE act.age <= 69 AND act.age >= 45
+                GROUP BY gender
+            ''')[0]
+
+        a2 = Select('Actor',
+            age=Between(45, 69), gender=GroupBy,
+            gender=[GroupBy, Field]
+        )       
+```
+> **a1 == a2 # --- True!**
+
+
+
+9.2
+```
+    m1 = Select.parse("""
+        SELECT title, release_date FROM Movie m ORDER BY release_date 
+        WHERE m.genre = 'Sci-Fi' AND m.awards LIKE '%Oscar%'
+    """)[0]
+
+    m2 = Select.parse("""
+        SELECT release_date, title
+        FROM Movie m
+        WHERE m.awards LIKE '%Oscar%' AND m.genre = 'Sci-Fi'
+        ORDER BY release_date 
+    """)[0]
+```
+
+**m1 == m2  #  --- True!**
+
+
+9.3
+```
+best_movies = SubSelect(
+    Review=Table('role'),
+    rate=[GroupBy, Having.avg(Where.gt(4.5))]
+)
+m1 = Select(
+    Movie=Table('title,release_date),
+    id=best_movies
+)
+
+sql = "SELECT rev.role FROM Review rev GROUP BY rev.rate HAVING Avg(rev.rate) > 4.5"
+m2 = Select(
+    'Movie', release_date=Field, title=Field,
+    id=Where(f"IN ({sql})")
+)
+```
+**m1 == m2 # --- True!**
+
+---
+---
+

sql_blocks-0.0.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+sql_blocks/__init__.py,sha256=TodC5q-UEdYEz9v1RRoogVqqRcsKnZRY1WDGinrI2zo,26
+sql_blocks/sql_blocks.py,sha256=V5WKBZg90emr0-jPpFEyX9rtU4VR3JlQKKu1qhlaiH0,13193
+sql_blocks-0.0.2.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+sql_blocks-0.0.2.dist-info/METADATA,sha256=stJ7wQ6iRmHNvf4nJBVr_r5W13Z-ey1ZAllXd8kV9bw,6604
+sql_blocks-0.0.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sql_blocks-0.0.2.dist-info/top_level.txt,sha256=57AbUvUjYNy4m1EqDaU3WHeP-uyIAfV0n8GAUp1a1YQ,11
+sql_blocks-0.0.2.dist-info/RECORD,,

sql_blocks-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sql_blocks-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+sql_blocks