velocity-python 0.0.30__py3-none-any.whl → 0.0.32__py3-none-any.whl

velocity/db/servers/mysql.py

@@ -4,95 +4,102 @@ import decimal
 import datetime
 from velocity.db import exceptions
 
+
 def initialize(config):
     from velocity.db.core.engine import Engine
     import mysql.connector
+
     return Engine(mysql.connector, config, SQL)
 
+
 def make_where(where, sql, vals, is_join=False):
     if not where:
         return
-    sql.append('WHERE')
+    sql.append("WHERE")
     if isinstance(where, str):
         sql.append(where)
         return
-    if isinstance(where,dict):
+    if isinstance(where, dict):
         where = where.items()
-    if isinstance(where,list):
-        join = ''
-        for key,val in where:
-            if join: sql.append(join)
+    if isinstance(where, list):
+        join = ""
+        for key, val in where:
+            if join:
+                sql.append(join)
             if is_join:
-                if '.' not in key:
-                    key = 'A.' + key
+                if "." not in key:
+                    key = "A." + key
             if val == None:
-                if '!' in key:
-                    key = key.replace('!','')
-                    sql.append('{} is not NULL'.format(quote(key.lower())))
+                if "!" in key:
+                    key = key.replace("!", "")
+                    sql.append("{} is not NULL".format(quote(key.lower())))
                 else:
-                    sql.append('{} is NULL'.format(quote(key.lower())))
-            elif isinstance(val,(list,tuple)):
-                if '!' in key:
-                    key = key.replace('!','')
-                    sql.append('{} not in %s'.format(quote(key.lower())))
+                    sql.append("{} is NULL".format(quote(key.lower())))
+            elif isinstance(val, (list, tuple)):
+                if "!" in key:
+                    key = key.replace("!", "")
+                    sql.append("{} not in %s".format(quote(key.lower())))
                     vals.append(tuple(val))
                 else:
-                    sql.append('{} in %s'.format(quote(key.lower())))
+                    sql.append("{} in %s".format(quote(key.lower())))
                     vals.append(tuple(val))
             else:
-                if '<>' in key:
-                    key = key.replace('<>','')
-                    op = '<>'
-                elif '!=' in key:
-                    key = key.replace('!=','')
-                    op = '<>'
-                elif '!%' in key:
-                    key = key.replace('!%','')
-                    op = 'not like'
-                elif '%%' in key:
-                    key = key.replace('%%','')
-                    op = '%'
-                elif '%>' in key:
-                    key = key.replace('%>','')
-                    op = '%>'
-                elif '<%' in key:
-                    key = key.replace('<%','')
-                    op = '<%'
-                elif '==' in key:
-                    key = key.replace('==','')
-                    op = '='
-                elif '<=' in key:
-                    key = key.replace('<=','')
-                    op = '<='
-                elif '>=' in key:
-                    key = key.replace('>=','')
-                    op = '>='
-                elif '<' in key:
-                    key = key.replace('<','')
-                    op = '<'
-                elif '>' in key:
-                    key = key.replace('>','')
-                    op = '>'
-                elif '%' in key:
-                    key = key.replace('%','')
-                    op = 'like'
-                elif '!' in key:
-                    key = key.replace('!','')
-                    op = '<>'
-                elif '=' in key:
-                    key = key.replace('=','')
-                    op = '='
+                if "<>" in key:
+                    key = key.replace("<>", "")
+                    op = "<>"
+                elif "!=" in key:
+                    key = key.replace("!=", "")
+                    op = "<>"
+                elif "!%" in key:
+                    key = key.replace("!%", "")
+                    op = "not like"
+                elif "%%" in key:
+                    key = key.replace("%%", "")
+                    op = "%"
+                elif "%>" in key:
+                    key = key.replace("%>", "")
+                    op = "%>"
+                elif "<%" in key:
+                    key = key.replace("<%", "")
+                    op = "<%"
+                elif "==" in key:
+                    key = key.replace("==", "")
+                    op = "="
+                elif "<=" in key:
+                    key = key.replace("<=", "")
+                    op = "<="
+                elif ">=" in key:
+                    key = key.replace(">=", "")
+                    op = ">="
+                elif "<" in key:
+                    key = key.replace("<", "")
+                    op = "<"
+                elif ">" in key:
+                    key = key.replace(">", "")
+                    op = ">"
+                elif "%" in key:
+                    key = key.replace("%", "")
+                    op = "like"
+                elif "!" in key:
+                    key = key.replace("!", "")
+                    op = "<>"
+                elif "=" in key:
+                    key = key.replace("=", "")
+                    op = "="
                 else:
-                    op = '='
-                if isinstance(val,str) and val[:2] == '@@':
-                    sql.append('{} {} {}'.format(quote(key.lower()), op, val[2:]))
+                    op = "="
+                if isinstance(val, str) and val[:2] == "@@":
+                    sql.append("{} {} {}".format(quote(key.lower()), op, val[2:]))
                 else:
-                    if 'like' in op:
-                        sql.append('lower({}) {} lower(%s)'.format(quote(key.lower()), op))
+                    if "like" in op:
+                        sql.append(
+                            "lower({}) {} lower(%s)".format(quote(key.lower()), op)
+                        )
                     else:
-                        sql.append('{} {} %s'.format(quote(key.lower()), op))
+                        sql.append("{} {} %s".format(quote(key.lower()), op))
                     vals.append(val)
-            join = 'AND'
+            join = "AND"
+
 
 def quote(data):
     if isinstance(data, list):
@@ -101,81 +108,94 @@ def quote(data):
             new.append(quote(item))
         return new
     else:
-        parts = data.split('.')
+        parts = data.split(".")
         new = []
         for part in parts:
-            if '`' in part:
+            if "`" in part:
                 new.append(part)
             elif part.upper() in reserved_words:
-                new.append('`'+part+'`')
-            elif re.findall('[/]',part):
-                new.append('`'+part+'`')
+                new.append("`" + part + "`")
+            elif re.findall("[/]", part):
+                new.append("`" + part + "`")
             else:
                 new.append(part)
-        return '.'.join(new)
+        return ".".join(new)
+
 
 class SQL:
     server = "MySQL"
-    type_column_identifier = 'DATA_TYPE'
-    is_nullable = 'IS_NULLABLE'
+    type_column_identifier = "DATA_TYPE"
+    is_nullable = "IS_NULLABLE"
 
-    default_schema = 'mydb'
+    default_schema = "mydb"
 
     ApplicationErrorCodes = []
 
     DatabaseMissingErrorCodes = []
     TableMissingErrorCodes = [1146]
     ColumnMissingErrorCodes = [1054]
-    ForeignKeyMissingErrorCodes =[]
+    ForeignKeyMissingErrorCodes = []
 
     ConnectionErrorCodes = []
-    DuplicateKeyErrorCodes = [] # Handled in regex check.
+    DuplicateKeyErrorCodes = []  # Handled in regex check.
     RetryTransactionCodes = []
     TruncationErrorCodes = []
     LockTimeoutErrorCodes = []
     DatabaseObjectExistsErrorCodes = []
 
     @classmethod
-    def __has_pointer(cls,columns):
+    def __has_pointer(cls, columns):
         if columns:
-            if isinstance(columns,list):
-                columns = ','.join(columns)
-            if '>' in columns:
+            if isinstance(columns, list):
+                columns = ",".join(columns)
+            if ">" in columns:
                 return True
         return False
 
     @classmethod
     def alter_add(cls, table, columns, null_allowed=True):
         sql = []
-        null = 'NOT NULL' if not null_allowed else ''
-        if isinstance(columns,dict):
-            for key,val in columns.items():
-                key = re.sub('<>!=%', '', key.lower())
-                sql.append("ALTER TABLE {} ADD {} {} {};".format(quote(table), quote(key), cls.get_type(val), null))
-        return '\n\t'.join(sql), tuple()
+        null = "NOT NULL" if not null_allowed else ""
+        if isinstance(columns, dict):
+            for key, val in columns.items():
+                key = re.sub("<>!=%", "", key.lower())
+                sql.append(
+                    "ALTER TABLE {} ADD {} {} {};".format(
+                        quote(table), quote(key), cls.get_type(val), null
+                    )
+                )
+        return "\n\t".join(sql), tuple()
 
     @classmethod
     def columns(cls, name):
-        if '.' in name:
+        if "." in name:
             return """
             SELECT COLUMN_NAME
             FROM INFORMATION_SCHEMA.columns
             WHERE TABLE_SCHEMA = %s
                 AND TABLE_NAME = %s
-            """, tuple(name.split('.'))
+            """, tuple(
+                name.split(".")
+            )
         else:
             return """
             SELECT COLUMN_NAME
             FROM INFORMATION_SCHEMA.columns
             WHERE TABLE_SCHEMA = %s
-            """, tuple([name,])
+            """, tuple(
+                [
+                    name,
+                ]
+            )
 
     @classmethod
-    def create_foreign_key(cls, table, columns, key_to_table, key_to_columns, name=None, schema=None):
-        if '.' not in table and schema:
+    def create_foreign_key(
+        cls, table, columns, key_to_table, key_to_columns, name=None, schema=None
+    ):
+        if "." not in table and schema:
             if schema == None:
                 schema = cls.default_schema
-            table = "{}.{}".format(schema,table)
+            table = "{}.{}".format(schema, table)
         if isinstance(key_to_columns, str):
             key_to_columns = [key_to_columns]
         if isinstance(columns, str):
@@ -183,75 +203,97 @@ class SQL:
         if not name:
             m = hashlib.md5()
             m.update(table)
-            m.update(' '.join(columns))
+            m.update(" ".join(columns))
             m.update(key_to_table)
-            m.update(' ' .join(key_to_columns))
-            name = 'FK_' + m.hexdigest()
-        sql = "ALTER TABLE {} ADD CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {} ({}) ON DELETE CASCADE ON UPDATE CASCADE;".format(table, name, ','.join(columns), key_to_table, ','.join(key_to_columns))
+            m.update(" ".join(key_to_columns))
+            name = "FK_" + m.hexdigest()
+        sql = "ALTER TABLE {} ADD CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {} ({}) ON DELETE CASCADE ON UPDATE CASCADE;".format(
+            table, name, ",".join(columns), key_to_table, ",".join(key_to_columns)
+        )
 
         return sql, tuple()
 
     @classmethod
-    def create_index(cls, table=None, columns=None, unique=False, direction=None, where=None, name=None, schema=None, trigram=None, tbl=None):
-        if '.' not in table and schema:
-            table = "{}.{}".format(schema,table)
-        if isinstance(columns,(list,set)):
-            columns = ','.join([quote(c.lower()) for c in sorted(columns)])
+    def create_index(
+        cls,
+        table=None,
+        columns=None,
+        unique=False,
+        direction=None,
+        where=None,
+        name=None,
+        schema=None,
+        trigram=None,
+        tbl=None,
+    ):
+        if "." not in table and schema:
+            table = "{}.{}".format(schema, table)
+        if isinstance(columns, (list, set)):
+            columns = ",".join([quote(c.lower()) for c in sorted(columns)])
         else:
             columns = quote(columns)
-        sql = ['CREATE']
+        sql = ["CREATE"]
         if unique:
-            sql.append('UNIQUE')
-        sql.append('INDEX')
+            sql.append("UNIQUE")
+        sql.append("INDEX")
         tablename = quote(table)
         if not name:
-            name = re.sub(r'\([^)]*\)', '', columns.replace(',','_'))
-        sql.append('IDX__{}__{}'.format(table.replace('.','_'),name))
-        sql.append('ON')
+            name = re.sub(r"\([^)]*\)", "", columns.replace(",", "_"))
+        sql.append("IDX__{}__{}".format(table.replace(".", "_"), name))
+        sql.append("ON")
         sql.append(tablename)
-        sql.append('(')
+        sql.append("(")
         sql.append(columns)
-        sql.append(')')
-        return ' '.join(sql), tuple()
+        sql.append(")")
+        return " ".join(sql), tuple()
 
     @classmethod
     def create_table(cls, name, columns={}, drop=False):
-        trigger = ''.format(name)
+        trigger = "".format(name)
         sql = []
         if drop:
             sql.append(cls.drop_table(name))
-        sql.append("""
+        sql.append(
+            """
             CREATE TABLE {0} (
               sys_id SERIAL PRIMARY KEY AUTO_INCREMENT,
               sys_modified TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
               sys_created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
             )ENGINE=InnoDB AUTO_INCREMENT=1000;
-        """.format(quote(name)))
-
-        for key,val in columns.items():
-            key = re.sub('<>!=%', '', key.lower())
-            if key in ['sys_id','sys_created','sys_modified']:
+        """.format(
+                quote(name)
+            )
+        )
+
+        for key, val in columns.items():
+            key = re.sub("<>!=%", "", key.lower())
+            if key in ["sys_id", "sys_created", "sys_modified"]:
                 continue
-            sql.append("ALTER TABLE {} ADD COLUMN {} {};".format(quote(name),quote(key),cls.get_type(val)))
-        return '\n\t'.join(sql), tuple()
+            sql.append(
+                "ALTER TABLE {} ADD COLUMN {} {};".format(
+                    quote(name), quote(key), cls.get_type(val)
+                )
+            )
+        return "\n\t".join(sql), tuple()
 
     @classmethod
     def delete(cls, table, where):
-        sql = ['DELETE FROM {}'.format(table)]
+        sql = ["DELETE FROM {}".format(table)]
         vals = []
         make_where(where, sql, vals)
-        return ' '.join(sql), tuple(vals)
+        return " ".join(sql), tuple(vals)
 
     @classmethod
     def drop_table(cls, name):
         return "DROP TABLE IF EXISTS %s CASCADE;" % quote(name), tuple()
 
     @classmethod
-    def foreign_key_info(cls,table=None,column=None,schema=None):
-        if '.' in table:
-            schema, table = table.split('.')
+    def foreign_key_info(cls, table=None, column=None, schema=None):
+        if "." in table:
+            schema, table = table.split(".")
 
-        sql = ["""
+        sql = [
+            """
         SELECT
           TABLE_NAME AS FK_TABLE_NAME
           ,COLUMN_NAME AS FK_COLUMN_NAME
@@ -260,58 +302,48 @@ class SQL:
           ,REFERENCED_COLUMN_NAME
         FROM
           INFORMATION_SCHEMA.KEY_COLUMN_USAGE
-        """]
+        """
+        ]
         vals = []
         where = {}
         if schema:
-            where['LOWER(REFERENCED_TABLE_SCHEMA)'] = schema.lower()
+            where["LOWER(REFERENCED_TABLE_SCHEMA)"] = schema.lower()
         if table:
-            where['LOWER(REFERENCED_TABLE_NAME)'] = table.lower()
+            where["LOWER(REFERENCED_TABLE_NAME)"] = table.lower()
         if column:
-            where['LOWER(REFERENCED_COLUMN_NAME)'] = column.lower()
+            where["LOWER(REFERENCED_COLUMN_NAME)"] = column.lower()
         make_where(where, sql, vals)
-        return ' '.join(sql), tuple(vals)
+        return " ".join(sql), tuple(vals)
 
     @classmethod
     def get_type(cls, v):
         if isinstance(v, str):
-            if v[:2] == '@@':
+            if v[:2] == "@@":
                 return v[2:] or cls.TYPES.TEXT
-        elif isinstance(v, (str, bytes)) \
-        or v is str \
-        or v is bytes:
-            return  cls.TYPES.TEXT
-        elif isinstance(v, bool) \
-        or v is bool:
+        elif isinstance(v, (str, bytes)) or v is str or v is bytes:
+            return cls.TYPES.TEXT
+        elif isinstance(v, bool) or v is bool:
             return cls.TYPES.BOOLEAN
-        elif isinstance(v, int) \
-        or v is int:
+        elif isinstance(v, int) or v is int:
             if v is int:
                 return cls.TYPES.INTEGER
             if v > 2147483647 or v < -2147483648:
                 return cls.TYPES.BIGINT
             else:
-                return  cls.TYPES.INTEGER
-        elif isinstance(v, float) \
-        or v is float:
-            return cls.TYPES.NUMERIC + '(19, 6)'
-        elif isinstance(v, decimal.Decimal) \
-        or v is decimal.Decimal:
-            return cls.TYPES.NUMERIC + '(19, 6)'
-        elif isinstance (v, datetime.datetime) \
-        or v is datetime.datetime:
+                return cls.TYPES.INTEGER
+        elif isinstance(v, float) or v is float:
+            return cls.TYPES.NUMERIC + "(19, 6)"
+        elif isinstance(v, decimal.Decimal) or v is decimal.Decimal:
+            return cls.TYPES.NUMERIC + "(19, 6)"
+        elif isinstance(v, datetime.datetime) or v is datetime.datetime:
             return cls.TYPES.DATETIME
-        elif isinstance (v, datetime.date) \
-        or v is datetime.date:
+        elif isinstance(v, datetime.date) or v is datetime.date:
             return cls.TYPES.DATE
-        elif isinstance(v, datetime.time) \
-        or v is datetime.time:
+        elif isinstance(v, datetime.time) or v is datetime.time:
             return cls.TYPES.TIME
-        elif isinstance(v, datetime.timedelta) \
-        or v is datetime.timedelta:
+        elif isinstance(v, datetime.timedelta) or v is datetime.timedelta:
             return cls.TYPES.INTERVAL
-        elif isinstance (v, bytearray) \
-        or v is bytearray:
+        elif isinstance(v, bytearray) or v is bytearray:
             return cls.TYPES.BINARY
         # Everything else defaults to TEXT, incl. None
         return cls.TYPES.TEXT
@@ -321,31 +353,29 @@ class SQL:
         keys = []
         vals = []
         args = []
-        for key,val in data.items():
+        for key, val in data.items():
             keys.append(quote(key.lower()))
-            if isinstance(val,str) \
-            and len(val) > 2 \
-            and val[:2] == '@@':
+            if isinstance(val, str) and len(val) > 2 and val[:2] == "@@":
                 vals.append(val[2:])
             else:
-                vals.append('%s')
+                vals.append("%s")
                 args.append(val)
 
-        sql = ['INSERT INTO']
+        sql = ["INSERT INTO"]
         sql.append(quote(table))
-        sql.append('(')
-        sql.append(','.join(keys))
-        sql.append(')')
-        sql.append('VALUES')
-        sql.append('(')
-        sql.append(','.join(vals))
-        sql.append(')')
-        sql = ' '.join(sql)
+        sql.append("(")
+        sql.append(",".join(keys))
+        sql.append(")")
+        sql.append("VALUES")
+        sql.append("(")
+        sql.append(",".join(vals))
+        sql.append(")")
+        sql = " ".join(sql)
         return sql, tuple(args)
 
     @classmethod
     def last_id(cls, table):
-        return  "SELECT LAST_INSERT_ID();",tuple()
+        return "SELECT LAST_INSERT_ID();", tuple()
 
     @classmethod
     def create_savepoint(cls, sp):
@@ -361,215 +391,483 @@ class SQL:
 
     @classmethod
     def create_view(cls, name, query, temp=False, silent=True):
-        sql = ['CREATE']
+        sql = ["CREATE"]
         if silent:
-            sql.append('OR REPLACE')
+            sql.append("OR REPLACE")
         if temp:
-            sql.append('TEMPORARY')
-        sql.append('VIEW')
+            sql.append("TEMPORARY")
+        sql.append("VIEW")
         sql.append(name)
-        sql.append('AS')
+        sql.append("AS")
         sql.append(query)
-        return ' '.join(sql),tuple()
+        return " ".join(sql), tuple()
 
     @classmethod
     def drop_view(cls, name, silent=True):
-        sql = ['DROP VIEW']
+        sql = ["DROP VIEW"]
         if silent:
-            sql.append('IF EXISTS')
+            sql.append("IF EXISTS")
         sql.append(name)
-        return ' '.join(sql),tuple()
+        return " ".join(sql), tuple()
 
     @classmethod
     def rename_column(cls, table, orig, new):
-        return "ALTER TABLE {} RENAME COLUMN {} TO {};".format(quote(table), quote(orig), quote(new)), tuple()
+        return (
+            "ALTER TABLE {} RENAME COLUMN {} TO {};".format(
+                quote(table), quote(orig), quote(new)
+            ),
+            tuple(),
+        )
 
     @classmethod
-    def select(cls,columns=None,table=None,where=None,orderby=None,groupby=None,having=None,start=None,qty=None,tbl=None):
+    def select(
+        cls,
+        columns=None,
+        table=None,
+        where=None,
+        orderby=None,
+        groupby=None,
+        having=None,
+        start=None,
+        qty=None,
+        tbl=None,
+    ):
         is_join = False
 
-        if isinstance(columns,str)\
-        and 'distinct' in columns.lower():
+        if isinstance(columns, str) and "distinct" in columns.lower():
             sql = [
-                'SELECT',
+                "SELECT",
                 columns,
-                'FROM',
+                "FROM",
                 quote(table),
-                ]
+            ]
         elif cls.__has_pointer(columns):
             is_join = True
-            if isinstance(columns,str):
-                columns = columns.split(',')
+            if isinstance(columns, str):
+                columns = columns.split(",")
             letter = 65
             tables = {table: chr(letter)}
             letter += 1
             __select = []
-            __from = ['{} AS {}'.format(quote(table),tables.get(table))]
+            __from = ["{} AS {}".format(quote(table), tables.get(table))]
             __left_join = []
 
             for column in columns:
-                if '>' in column:
+                if ">" in column:
                     is_join = True
-                    parts = column.split('>')
+                    parts = column.split(">")
                     foreign = tbl.foreign_key_info(parts[0])
                     if not foreign:
                         raise exceptions.DbApplicationError("Foreign key not defined")
-                    ref_table = foreign['referenced_table_name']
-                    ref_schema = foreign['referenced_table_schema']
-                    ref_column = foreign['referenced_column_name']
-                    lookup = "{}:{}".format(ref_table,parts[0])
+                    ref_table = foreign["referenced_table_name"]
+                    ref_schema = foreign["referenced_table_schema"]
+                    ref_column = foreign["referenced_column_name"]
+                    lookup = "{}:{}".format(ref_table, parts[0])
                     if tables.has_key(lookup):
-                        __select.append('{}."{}" as "{}"'.format(tables.get(lookup),parts[1],'_'.join(parts)))
+                        __select.append(
+                            '{}."{}" as "{}"'.format(
+                                tables.get(lookup), parts[1], "_".join(parts)
+                            )
+                        )
                     else:
                         tables[lookup] = chr(letter)
                         letter += 1
-                        __select.append('{}."{}" as "{}"'.format(tables.get(lookup),parts[1],'_'.join(parts)))
-                        __left_join.append('LEFT OUTER JOIN "{}"."{}" AS {}'.format(ref_schema,ref_table,tables.get(lookup)))
-                        __left_join.append('ON {}."{}" = {}."{}"'.format(
-                            tables.get(table),
-                            parts[0],
-                            tables.get(lookup),
-                            ref_column
-                        ))
+                        __select.append(
+                            '{}."{}" as "{}"'.format(
+                                tables.get(lookup), parts[1], "_".join(parts)
+                            )
+                        )
+                        __left_join.append(
+                            'LEFT OUTER JOIN "{}"."{}" AS {}'.format(
+                                ref_schema, ref_table, tables.get(lookup)
+                            )
+                        )
+                        __left_join.append(
+                            'ON {}."{}" = {}."{}"'.format(
+                                tables.get(table),
+                                parts[0],
+                                tables.get(lookup),
+                                ref_column,
+                            )
+                        )
                     if orderby and column in orderby:
-                        orderby = orderby.replace(column,"{}.{}".format(tables.get(lookup),parts[1]))
+                        orderby = orderby.replace(
+                            column, "{}.{}".format(tables.get(lookup), parts[1])
+                        )
 
                 else:
-                    if '(' in column:
+                    if "(" in column:
                         __select.append(column)
                     else:
-                        __select.append("{}.{}".format(tables.get(table),column))
-            sql = ['SELECT']
-            sql.append(','.join(__select))
-            sql.append('FROM')
+                        __select.append("{}.{}".format(tables.get(table), column))
+            sql = ["SELECT"]
+            sql.append(",".join(__select))
+            sql.append("FROM")
             sql.extend(__from)
             sql.extend(__left_join)
         else:
             if columns:
-                if isinstance(columns,str):
-                    columns = columns.split(',')
-                if isinstance(columns,list):
+                if isinstance(columns, str):
+                    columns = columns.split(",")
+                if isinstance(columns, list):
                     columns = quote(columns)
-                    columns = ','.join(columns)
+                    columns = ",".join(columns)
             else:
-                columns = '*'
+                columns = "*"
             sql = [
-                'SELECT',
+                "SELECT",
                 columns,
-                'FROM',
+                "FROM",
                 quote(table),
-                ]
+            ]
         vals = []
         make_where(where, sql, vals, is_join)
         if groupby:
-            sql.append('GROUP BY')
-            if isinstance(groupby,(list,tuple)):
-                groupby = ','.join(groupby)
+            sql.append("GROUP BY")
+            if isinstance(groupby, (list, tuple)):
+                groupby = ",".join(groupby)
             sql.append(groupby)
         if having:
-            sql.append('HAVING')
-            if isinstance(having,(list,tuple)):
-                having = ','.join(having)
+            sql.append("HAVING")
+            if isinstance(having, (list, tuple)):
+                having = ",".join(having)
             sql.append(having)
         if orderby:
-            sql.append('ORDER BY')
-            if isinstance(orderby,(list,tuple)):
-                orderby = ','.join(orderby)
+            sql.append("ORDER BY")
+            if isinstance(orderby, (list, tuple)):
+                orderby = ",".join(orderby)
             sql.append(orderby)
         if start and qty:
-            sql.append('OFFSET {} ROWS FETCH NEXT {} ROWS ONLY'.format(start,qty))
+            sql.append("OFFSET {} ROWS FETCH NEXT {} ROWS ONLY".format(start, qty))
         elif start:
-            sql.append('OFFSET {} ROWS'.format(start))
+            sql.append("OFFSET {} ROWS".format(start))
         elif qty:
-            sql.append('FETCH NEXT {} ROWS ONLY'.format(qty))
-        sql = ' '.join(sql)
+            sql.append("FETCH NEXT {} ROWS ONLY".format(qty))
+        sql = " ".join(sql)
         return sql, tuple(vals)
 
     @classmethod
     def update(cls, table, data, pk):
-        sql = ['UPDATE']
+        sql = ["UPDATE"]
         sql.append(quote(table))
-        sql.append('SET')
+        sql.append("SET")
         vals = []
-        join = ''
+        join = ""
         for key in data.keys():
             val = data[key]
             if join:
                 sql.append(join)
-            if isinstance(val,str) and val[:2] == '@@':
-                sql.append("{} = {}".format(quote(key.lower()),val[2:]))
+            if isinstance(val, str) and val[:2] == "@@":
+                sql.append("{} = {}".format(quote(key.lower()), val[2:]))
             else:
-                sql.append('{} = %s'.format(quote(key.lower())))
+                sql.append("{} = %s".format(quote(key.lower())))
                 vals.append(val)
-            join = ','
+            join = ","
         make_where(pk, sql, vals)
-        return ' '.join(sql), tuple(vals)
+        return " ".join(sql), tuple(vals)
 
     @classmethod
     def upsert(cls, table, data, pk):
         keys = []
         vals = []
         args = []
-        for key,val in data.items():
+        for key, val in data.items():
             keys.append(quote(key.lower()))
-            if isinstance(val,str) \
-            and len(val) > 2 \
-            and val[:2] == '@@':
+            if isinstance(val, str) and len(val) > 2 and val[:2] == "@@":
                 vals.append(val[2:])
             else:
-                vals.append('%s')
+                vals.append("%s")
                 args.append(val)
-        for key,val in pk.items():
+        for key, val in pk.items():
             keys.append(quote(key.lower()))
-            if isinstance(val,str) \
-            and len(val) > 2 \
-            and val[:2] == '@@':
+            if isinstance(val, str) and len(val) > 2 and val[:2] == "@@":
                 vals.append(val[2:])
             else:
-                vals.append('%s')
+                vals.append("%s")
                 args.append(val)
-        sql = ['INSERT INTO']
+        sql = ["INSERT INTO"]
         sql.append(quote(table))
-        sql.append('(')
-        sql.append(','.join(keys))
-        sql.append(')')
-        sql.append('VALUES')
-        sql.append('(')
-        sql.append(','.join(vals))
-        sql.append(')')
-        sql.append('ON DUPLICATE KEY UPDATE')
-        join = ''
+        sql.append("(")
+        sql.append(",".join(keys))
+        sql.append(")")
+        sql.append("VALUES")
+        sql.append("(")
+        sql.append(",".join(vals))
+        sql.append(")")
+        sql.append("ON DUPLICATE KEY UPDATE")
+        join = ""
         for key in data.keys():
             val = data[key]
             if join:
                 sql.append(join)
-            if isinstance(val,str) and val[:2] == '@@':
-                sql.append("{} = {}".format(quote(key.lower()),val[2:]))
+            if isinstance(val, str) and val[:2] == "@@":
+                sql.append("{} = {}".format(quote(key.lower()), val[2:]))
             else:
-                sql.append('{} = %s'.format(quote(key.lower())))
+                sql.append("{} = %s".format(quote(key.lower())))
                 args.append(val)
-            join = ','
-        return ' '.join(sql), tuple(args)
+            join = ","
+        return " ".join(sql), tuple(args)
 
     @classmethod
     def views(cls, system=False):
         if system:
-            return "SELECT TABLE_SCHEMA, TABLE_NAME FROM information_schema.tables WHERE TABLE_TYPE LIKE 'VIEW';", tuple()
+            return (
+                "SELECT TABLE_SCHEMA, TABLE_NAME FROM information_schema.tables WHERE TABLE_TYPE LIKE 'VIEW';",
+                tuple(),
+            )
         else:
-            return "SELECT TABLE_SCHEMA, TABLE_NAME FROM information_schema.tables WHERE TABLE_TYPE LIKE 'VIEW';", tuple()
+            return (
+                "SELECT TABLE_SCHEMA, TABLE_NAME FROM information_schema.tables WHERE TABLE_TYPE LIKE 'VIEW';",
+                tuple(),
+            )
 
     class TYPES(object):
-        TEXT = 'TEXT'
-        INTEGER = 'INTEGER'
-        NUMERIC = 'NUMERIC'
-        DATETIME = 'DATETIME'
-        TIMESTAMP = 'TIMESTAMP'
-        DATE = 'DATE'
-        TIME = 'TIME'
-        BIGINT = 'BIGINT'
-        SMALLINT = 'SMALLINT'
-        BOOLEAN = 'BIT'
-        BINARY = 'BLOB'
-        INTERVAL = 'INTERVAL'
-
-reserved_words = ['ACCESSIBLE','ADD','ALL','ALTER','ANALYZE','AND','AS','ASC','ASENSITIVE','BEFORE','BETWEEN','BIGINT','BINARY','BLOB','BOTH','BY','CALL','CASCADE','CASE','CHANGE','CHAR','CHARACTER','CHECK','COLLATE','COLUMN','CONDITION','CONSTRAINT','CONTINUE','CONVERT','CREATE','CROSS','CURRENT_DATE','CURRENT_TIME','CURRENT_TIMESTAMP','CURRENT_USER','CURSOR','DATABASE','DATABASES','DAY_HOUR','DAY_MICROSECOND','DAY_MINUTE','DAY_SECOND','DEC','DECIMAL','DECLARE','DEFAULT','DELAYED','DELETE','DESC','DESCRIBE','DETERMINISTIC','DISTINCT','DISTINCTROW','DIV','DOUBLE','DROP','DUAL','EACH','ELSE','ELSEIF','ENCLOSED','ESCAPED','EXISTS','EXIT','EXPLAIN','FALSE','FETCH','FLOAT','FLOAT4','FLOAT8','FOR','FORCE','FOREIGN','FROM','FULLTEXT','GENERAL','GRANT','GROUP','HAVING','HIGH_PRIORITY','HOUR_MICROSECOND','HOUR_MINUTE','HOUR_SECOND','IF','IGNORE','IGNORE_SERVER_IDS','IN','INDEX','INFILE','INNER','INOUT','INSENSITIVE','INSERT','INT','INT1','INT2','INT3','INT4','INT8','INTEGER','INTERVAL','INTO','IS','ITERATE','JOIN','KEY','KEYS','KILL','LEADING','LEAVE','LEFT','LIKE','LIMIT','LINEAR','LINES','LOAD','LOCALTIME','LOCALTIMESTAMP','LOCK','LONG','LONGBLOB','LONGTEXT','LOOP','LOW_PRIORITY','MASTER_HEARTBEAT_PERIOD','MASTER_SSL_VERIFY_SERVER_CERT','MATCH','MAXVALUE','MEDIUMBLOB','MEDIUMINT','MEDIUMTEXT','MIDDLEINT','MINUTE_MICROSECOND','MINUTE_SECOND','MOD','MODIFIES','NATURAL','NOT','NO_WRITE_TO_BINLOG','NULL','NUMERIC','ON','OPTIMIZE','OPTION','OPTIONALLY','OR','ORDER','OUT','OUTER','OUTFILE','PRECISION','PRIMARY','PROCEDURE','PROXY','PURGE','RANGE','READ','READS','READ_WRITE','REAL','REFERENCES','REGEXP','RELAY','RELEASE','RENAME','REPEAT','REPLACE','REQUIRE','RESIGNAL','RESTRICT','RETURN','REVOKE','RIGHT','RLIKE','SCHEMA','SCHEMAS','SECOND_MICROSECOND','SELECT','SENSITIVE','SEPARATOR','SET','SHOW','SIGNAL','SLOW','SMALLINT','SPATIAL','SPECIFIC','SQL','SQLEXCEPTION','SQLSTATE','SQLWARNING','SQL_BIG_RESULT','SQL_CALC_FOUND_ROWS','SQL_SMALL_RESULT','SSL','STARTING','STRAIGHT_JOIN','TABLE','TERMINATED','THEN','TIMESTAMP','TINYBLOB','TINYINT','TINYTEXT','TO','TRAILING','TRIGGER','TRUE','UNDO','UNION','UNIQUE','UNLOCK','UNSIGNED','UPDATE','USAGE','USE','USING','UTC_DATE','UTC_TIME','UTC_TIMESTAMP','VALUES','VARBINARY','VARCHAR','VARCHARACTER','VARYING','WHEN','WHERE','WHILE','WITH','WRITE','XOR','YEAR_MONTH','ZEROFILL']
+        TEXT = "TEXT"
+        INTEGER = "INTEGER"
+        NUMERIC = "NUMERIC"
+        DATETIME = "DATETIME"
+        TIMESTAMP = "TIMESTAMP"
+        DATE = "DATE"
+        TIME = "TIME"
+        BIGINT = "BIGINT"
+        SMALLINT = "SMALLINT"
+        BOOLEAN = "BIT"
+        BINARY = "BLOB"
+        INTERVAL = "INTERVAL"
+
+
+reserved_words = [
+    "ACCESSIBLE",
+    "ADD",
+    "ALL",
+    "ALTER",
+    "ANALYZE",
+    "AND",
+    "AS",
+    "ASC",
+    "ASENSITIVE",
+    "BEFORE",
+    "BETWEEN",
+    "BIGINT",
+    "BINARY",
+    "BLOB",
+    "BOTH",
+    "BY",
+    "CALL",
+    "CASCADE",
+    "CASE",
+    "CHANGE",
+    "CHAR",
+    "CHARACTER",
+    "CHECK",
+    "COLLATE",
+    "COLUMN",
+    "CONDITION",
+    "CONSTRAINT",
+    "CONTINUE",
+    "CONVERT",
+    "CREATE",
+    "CROSS",
+    "CURRENT_DATE",
+    "CURRENT_TIME",
+    "CURRENT_TIMESTAMP",
+    "CURRENT_USER",
+    "CURSOR",
+    "DATABASE",
+    "DATABASES",
+    "DAY_HOUR",
+    "DAY_MICROSECOND",
+    "DAY_MINUTE",
+    "DAY_SECOND",
+    "DEC",
+    "DECIMAL",
+    "DECLARE",
+    "DEFAULT",
+    "DELAYED",
+    "DELETE",
+    "DESC",
+    "DESCRIBE",
+    "DETERMINISTIC",
+    "DISTINCT",
+    "DISTINCTROW",
+    "DIV",
+    "DOUBLE",
+    "DROP",
+    "DUAL",
+    "EACH",
+    "ELSE",
+    "ELSEIF",
+    "ENCLOSED",
+    "ESCAPED",
+    "EXISTS",
+    "EXIT",
+    "EXPLAIN",
+    "FALSE",
+    "FETCH",
+    "FLOAT",
+    "FLOAT4",
+    "FLOAT8",
+    "FOR",
+    "FORCE",
+    "FOREIGN",
+    "FROM",
+    "FULLTEXT",
+    "GENERAL",
+    "GRANT",
+    "GROUP",
+    "HAVING",
+    "HIGH_PRIORITY",
+    "HOUR_MICROSECOND",
+    "HOUR_MINUTE",
+    "HOUR_SECOND",
+    "IF",
+    "IGNORE",
+    "IGNORE_SERVER_IDS",
+    "IN",
+    "INDEX",
+    "INFILE",
+    "INNER",
+    "INOUT",
+    "INSENSITIVE",
+    "INSERT",
+    "INT",
+    "INT1",
+    "INT2",
+    "INT3",
+    "INT4",
+    "INT8",
+    "INTEGER",
+    "INTERVAL",
+    "INTO",
+    "IS",
+    "ITERATE",
+    "JOIN",
+    "KEY",
+    "KEYS",
+    "KILL",
+    "LEADING",
+    "LEAVE",
+    "LEFT",
+    "LIKE",
+    "LIMIT",
+    "LINEAR",
+    "LINES",
+    "LOAD",
+    "LOCALTIME",
+    "LOCALTIMESTAMP",
+    "LOCK",
+    "LONG",
+    "LONGBLOB",
+    "LONGTEXT",
+    "LOOP",
+    "LOW_PRIORITY",
+    "MASTER_HEARTBEAT_PERIOD",
+    "MASTER_SSL_VERIFY_SERVER_CERT",
+    "MATCH",
+    "MAXVALUE",
+    "MEDIUMBLOB",
+    "MEDIUMINT",
+    "MEDIUMTEXT",
+    "MIDDLEINT",
+    "MINUTE_MICROSECOND",
+    "MINUTE_SECOND",
+    "MOD",
+    "MODIFIES",
+    "NATURAL",
+    "NOT",
+    "NO_WRITE_TO_BINLOG",
+    "NULL",
+    "NUMERIC",
+    "ON",
+    "OPTIMIZE",
+    "OPTION",
+    "OPTIONALLY",
+    "OR",
+    "ORDER",
+    "OUT",
+    "OUTER",
+    "OUTFILE",
+    "PRECISION",
+    "PRIMARY",
+    "PROCEDURE",
+    "PROXY",
+    "PURGE",
+    "RANGE",
+    "READ",
+    "READS",
+    "READ_WRITE",
+    "REAL",
+    "REFERENCES",
+    "REGEXP",
+    "RELAY",
+    "RELEASE",
+    "RENAME",
+    "REPEAT",
+    "REPLACE",
+    "REQUIRE",
+    "RESIGNAL",
+    "RESTRICT",
+    "RETURN",
+    "REVOKE",
+    "RIGHT",
+    "RLIKE",
+    "SCHEMA",
+    "SCHEMAS",
+    "SECOND_MICROSECOND",
+    "SELECT",
+    "SENSITIVE",
+    "SEPARATOR",
+    "SET",
+    "SHOW",
+    "SIGNAL",
+    "SLOW",
+    "SMALLINT",
+    "SPATIAL",
+    "SPECIFIC",
+    "SQL",
+    "SQLEXCEPTION",
+    "SQLSTATE",
+    "SQLWARNING",
+    "SQL_BIG_RESULT",
+    "SQL_CALC_FOUND_ROWS",
+    "SQL_SMALL_RESULT",
+    "SSL",
+    "STARTING",
+    "STRAIGHT_JOIN",
+    "TABLE",
+    "TERMINATED",
+    "THEN",
+    "TIMESTAMP",
+    "TINYBLOB",
+    "TINYINT",
+    "TINYTEXT",
+    "TO",
+    "TRAILING",
+    "TRIGGER",
+    "TRUE",
+    "UNDO",
+    "UNION",
+    "UNIQUE",
+    "UNLOCK",
+    "UNSIGNED",
+    "UPDATE",
+    "USAGE",
+    "USE",
+    "USING",
+    "UTC_DATE",
+    "UTC_TIME",
+    "UTC_TIMESTAMP",
+    "VALUES",
+    "VARBINARY",
+    "VARCHAR",
+    "VARCHARACTER",
+    "VARYING",
+    "WHEN",
+    "WHERE",
+    "WHILE",
+    "WITH",
+    "WRITE",
+    "XOR",
+    "YEAR_MONTH",
+    "ZEROFILL",
+]