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

velocity/db/servers/sqlserver.py

@@ -8,92 +8,97 @@ from velocity.db import exceptions
 def initialize(config):
     import pytds
     from velocity.db.core.engine import Engine
+
     return Engine(pytds, 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"
     # for index, value in enumerate(vals):
     #     print "In loop..."
     #     if isinstance(value, (bytearray,buffer)):
@@ -101,6 +106,7 @@ def make_where(where, sql, vals, is_join=False):
     #         print value
     #         vals[index] = pytds.Binary(str(value))
 
+
 def quote(data):
     if isinstance(data, list):
         new = []
@@ -108,35 +114,40 @@ 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 = "SQL Server"
-    type_column_identifier = 'data_type'
-    default_schema = 'dbo'
+    type_column_identifier = "data_type"
+    default_schema = "dbo"
 
     ApplicationErrorCodes = []
 
     DatabaseMissingErrorCodes = []
-    TableMissingErrorCodes = [208,]
-    ColumnMissingErrorCodes = [207,1911]
-    ForeignKeyMissingErrorCodes =[]
+    TableMissingErrorCodes = [
+        208,
+    ]
+    ColumnMissingErrorCodes = [207, 1911]
+    ForeignKeyMissingErrorCodes = []
 
     ConnectionErrorCodes = []
     DuplicateKeyErrorCodes = []
     RetryTransactionCodes = []
-    TruncationErrorCodes = [8152,]
+    TruncationErrorCodes = [
+        8152,
+    ]
     LockTimeoutErrorCodes = []
     DatabaseObjectExistsErrorCodes = []
 
@@ -158,157 +169,190 @@ class SQL:
 
     @classmethod
     def schemas(cls):
-        return 'select schema_name from information_schema.schemata', tuple()
+        return "select schema_name from information_schema.schemata", tuple()
 
     @classmethod
     def current_schema(cls):
-        return 'select schema_name()', tuple()
+        return "select schema_name()", tuple()
 
     @classmethod
     def current_database(cls):
-        return 'select db_name() as current_database', tuple()
+        return "select db_name() as current_database", tuple()
 
     @classmethod
     def tables(cls, system=False):
-        return """
+        return (
+            """
         select table_schema, table_name
         from information_schema.tables
         where table_type = 'BASE TABLE'
         order by table_schema,table_name
-        """, tuple()
+        """,
+            tuple(),
+        )
 
     @classmethod
     def views(cls, system=False):
-        return "SELECT s.name , v.name FROM sys.views v inner join sys.schemas s on s.schema_id = v.schema_id", tuple()
+        return (
+            "SELECT s.name , v.name FROM sys.views v inner join sys.schemas s on s.schema_id = v.schema_id",
+            tuple(),
+        )
 
     @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 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 create_database(cls, name):
-        return 'create database ' + name, tuple()
+        return "create database " + name, tuple()
 
     @classmethod
     def last_id(cls, table):
-        return  "SELECT @@IDENTITY", tuple()
+        return "SELECT @@IDENTITY", tuple()
 
     @classmethod
     def drop_database(cls, name):
-        return 'drop database ' + name, tuple()
+        return "drop database " + 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
              KCU1.CONSTRAINT_NAME AS FK_CONSTRAINT_NAME
             ,KCU1.TABLE_NAME AS FK_TABLE_NAME
@@ -331,24 +375,27 @@ class SQL:
             AND KCU2.CONSTRAINT_SCHEMA = RC.UNIQUE_CONSTRAINT_SCHEMA
             AND KCU2.CONSTRAINT_NAME = RC.UNIQUE_CONSTRAINT_NAME
             AND KCU2.ORDINAL_POSITION = KCU1.ORDINAL_POSITION
-        """]
+        """
+        ]
         vals = []
         where = {}
         if schema:
-            where['LOWER(KCU1.CONSTRAINT_SCHEMA)'] = schema.lower()
+            where["LOWER(KCU1.CONSTRAINT_SCHEMA)"] = schema.lower()
         if table:
-            where['LOWER(KCU1.TABLE_NAME)'] = table.lower()
+            where["LOWER(KCU1.TABLE_NAME)"] = table.lower()
         if column:
-            where['LOWER(KCU1.COLUMN_NAME)'] = column.lower()
+            where["LOWER(KCU1.COLUMN_NAME)"] = column.lower()
         make_where(where, sql, vals)
-        return ' '.join(sql), tuple(vals)
+        return " ".join(sql), tuple(vals)
 
     @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):
@@ -356,37 +403,44 @@ 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_table(cls, name, columns={}, drop=False):
-        if '.' in name:
+        if "." in name:
             fqtn = name
         else:
-            fqtn = cls.default_schema + '.' + name
-        schema,table = fqtn.split('.')
-        name = fqtn.replace('.','_')
-        trigger = 'on_update_row_{0}'.format(name)
+            fqtn = cls.default_schema + "." + name
+        schema, table = fqtn.split(".")
+        name = fqtn.replace(".", "_")
+        trigger = "on_update_row_{0}".format(name)
         sql = []
-        sql.append('DECLARE @script1 nVarChar(MAX);')
-        sql.append('DECLARE @script2 nVarChar(MAX);')
+        sql.append("DECLARE @script1 nVarChar(MAX);")
+        sql.append("DECLARE @script2 nVarChar(MAX);")
         if drop:
             sql.append(cls.drop_table(fqtn))
-        sql.append("""
+        sql.append(
+            """
             SET @script1 = '
             CREATE TABLE {0} (
               sys_id int identity(1000,1) primary key,
               sys_modified datetime not null default(getdate()),
               sys_created datetime not null default(getdate())
             )'
-        """.format(fqtn, table, trigger))
-        sql.append("""
+        """.format(
+                fqtn, table, trigger
+            )
+        )
+        sql.append(
+            """
             SET @script2 = '
             CREATE TRIGGER {2}
             ON {0}
@@ -399,238 +453,263 @@ class SQL:
                 FROM {0} AS t
                 INNER JOIN deleted AS d on t.sys_id=i.sys_id
             END'
-        """.format(fqtn,  table, trigger))
-        sql.append('EXEC (@script1);')
-        sql.append('EXEC (@script2);')
-        for key,val in columns.items():
-            sql.append("ALTER TABLE {} ADD {} {};".format(fqtn,key,cls.get_type(val)))
-        return '\n\t'.join(sql), tuple()
+        """.format(
+                fqtn, table, trigger
+            )
+        )
+        sql.append("EXEC (@script1);")
+        sql.append("EXEC (@script2);")
+        for key, val in columns.items():
+            sql.append("ALTER TABLE {} ADD {} {};".format(fqtn, key, cls.get_type(val)))
+        return "\n\t".join(sql), tuple()
 
     @classmethod
     def drop_table(cls, name):
-        return "IF OBJECT_ID('%s', 'U') IS NOT NULL DROP TABLE %s;" % (quote(cls.default_schema+'.'+name),quote(cls.default_schema+'.'+name)), tuple()
+        return (
+            "IF OBJECT_ID('%s', 'U') IS NOT NULL DROP TABLE %s;"
+            % (
+                quote(cls.default_schema + "." + name),
+                quote(cls.default_schema + "." + name),
+            ),
+            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_name = %s
-            """, tuple([name])
+            """, tuple(
+                [name]
+            )
 
     @classmethod
     def column_info(cls, table, name):
-        params = table.split('.')
+        params = table.split(".")
         params.append(name)
-        if '.' in table:
+        if "." in table:
             return """
             select *
             from information_schema.columns
             where table_schema = %s
             and table_name = %s
             and column_name = %s
-            """, tuple(params)
+            """, tuple(
+                params
+            )
         else:
             return """
             select *
             from information_schema.columns
             where table_name = %s
             and column_name = %s
-            """, tuple(params)
-
+            """, tuple(
+                params
+            )
 
     @classmethod
     def primary_keys(cls, table):
-        params = table.split('.')
-        if '.' in table:
+        params = table.split(".")
+        if "." in table:
             return """
             SELECT COLUMN_NAME
             FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
             WHERE OBJECTPROPERTY(OBJECT_ID(CONSTRAINT_SCHEMA + '.' + QUOTENAME(CONSTRAINT_NAME)), 'IsPrimaryKey') = 1
             AND TABLE_SCHEMA = %s AND TABLE_NAME = %s
-            """, tuple(params)
+            """, tuple(
+                params
+            )
         else:
             return """
             SELECT COLUMN_NAME
             FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
             WHERE OBJECTPROPERTY(OBJECT_ID(CONSTRAINT_SCHEMA + '.' + QUOTENAME(CONSTRAINT_NAME)), 'IsPrimaryKey') = 1
             AND TABLE_NAME = %s
-            """, tuple(params)
+            """, tuple(
+                params
+            )
 
     @classmethod
     def xforeign_keys(cls, table):
-        params = table.split('.')
-        if '.' in table:
+        params = table.split(".")
+        if "." in table:
             return """
             SELECT COLUMN_NAME
             FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
             WHERE OBJECTPROPERTY(OBJECT_ID(CONSTRAINT_SCHEMA + '.' + QUOTENAME(CONSTRAINT_NAME)), 'IsPrimaryKey') = 1
             AND TABLE_SCHEMA = %s AND TABLE_NAME = %s
-            """, tuple(params)
+            """, tuple(
+                params
+            )
         else:
             return """
             SELECT COLUMN_NAME
             FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
             WHERE OBJECTPROPERTY(OBJECT_ID(CONSTRAINT_SCHEMA + '.' + QUOTENAME(CONSTRAINT_NAME)), 'IsPrimaryKey') = 1
             AND TABLE_NAME = %s
-            """, tuple(params)
+            """, tuple(
+                params
+            )
 
     @classmethod
     def insert(cls, table, data):
         import pytds
+
         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:])
-            elif isinstance(val,(bytearray,bytes)):
-                vals.append('%s')
+            elif isinstance(val, (bytearray, bytes)):
+                vals.append("%s")
                 args.append(pytds.Binary(str(val)))
             else:
-                vals.append('%s')
+                vals.append("%s")
                 args.append(val)
 
         sql = []
         if "sys_id" in data:
-            sql.append('SET IDENTITY_INSERT {} ON;'.format(table))
-        sql.append('INSERT INTO')
+            sql.append("SET IDENTITY_INSERT {} ON;".format(table))
+        sql.append("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("(")
+        sql.append(",".join(keys))
+        sql.append(")")
+        sql.append("VALUES")
+        sql.append("(")
+        sql.append(",".join(vals))
+        sql.append(");")
         if "sys_id" in data:
-            sql.append('SET IDENTITY_INSERT {} OFF;'.format(table))
-        sql = ' '.join(sql)
+            sql.append("SET IDENTITY_INSERT {} OFF;".format(table))
+        sql = " ".join(sql)
         return sql, tuple(args)
 
     @classmethod
     def update(cls, table, data, pk):
         import pytds
-        sql = ['UPDATE']
+
+        sql = ["UPDATE"]
         sql.append(quote(table))
-        sql.append('SET')
+        sql.append("SET")
         vals = []
-        join = ''
+        join = ""
         for key in sorted(data.keys()):
             val = data[key]
             if join:
                 sql.append(join)
-            sql.append('{} = %s'.format(quote(key.lower())))
-            if isinstance(val, (bytearray,bytes)):
+            sql.append("{} = %s".format(quote(key.lower())))
+            if isinstance(val, (bytearray, bytes)):
                 vals.append(pytds.Binary(str(val)))
             else:
                 vals.append(val)
-            join = ','
+            join = ","
         if pk:
-            sql.append('\nWHERE')
-            join = ''
+            sql.append("\nWHERE")
+            join = ""
             for key in sorted(pk.keys()):
                 val = pk[key]
                 if join:
                     sql.append(join)
                 if val is None:
-                    sql.append('{} is null'.format(quote(key.lower())))
+                    sql.append("{} is null".format(quote(key.lower())))
                 else:
-                    sql.append('{} = %s'.format(quote(key.lower())))
+                    sql.append("{} = %s".format(quote(key.lower())))
                     vals.append(val)
-                join = 'AND'
-        sql = ' '.join(sql)
+                join = "AND"
+        sql = " ".join(sql)
         return sql, tuple(vals)
 
     @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 drop_index(cls, table=None, columns=None, name=None, schema=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)])
+        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 = ['DROP']
-        sql.append('INDEX IF EXISTS')
+        sql = ["DROP"]
+        sql.append("INDEX IF EXISTS")
         tablename = quote(table)
         if not name:
-            name = re.sub(r'\([^)]*\)', '', columns.replace(',','_'))
-        sql.append('IDX__{}__{}'.format(table.replace('.','_'),name))
-        print(' '.join(sql))
-        return ' '.join(sql), tuple()
+            name = re.sub(r"\([^)]*\)", "", columns.replace(",", "_"))
+        sql.append("IDX__{}__{}".format(table.replace(".", "_"), name))
+        print(" ".join(sql))
+        return " ".join(sql), tuple()
 
     @classmethod
     def get_type(cls, v):
         if isinstance(v, str):
-            if v[:2] == '@@':
+            if v[:2] == "@@":
                 return v[2:]
-        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, (bytearray, bytes)) \
-        or v is bytearray \
-        or v is bytes:
+        elif isinstance(v, (bytearray, bytes)) or v is bytearray or v is bytes:
             return cls.TYPES.BINARY
         # Everything else defaults to TEXT, incl. None
         return cls.TYPES.TEXT
@@ -654,7 +733,7 @@ class SQL:
             raise Exception("unmapped type %s" % v)
 
     @classmethod
-    def massage_data(cls,data):
+    def massage_data(cls, data):
         """
 
         :param :
@@ -662,68 +741,79 @@ class SQL:
         :param :
         :returns:
         """
-        data = {key.lower():val for key,val in data.items()}
+        data = {key.lower(): val for key, val in data.items()}
         primaryKey = set(cls.GetPrimaryKeyColumnNames())
         if not primaryKey:
             if not cls.Exists():
                 raise exceptions.DbTableMissingError
-        dataKeys = set(data.keys()).intersection( primaryKey )
-        dataColumns = set(data.keys()).difference( primaryKey )
+        dataKeys = set(data.keys()).intersection(primaryKey)
+        dataColumns = set(data.keys()).difference(primaryKey)
         pk = {}
-        pk.update([(k,data[k]) for k in dataKeys])
+        pk.update([(k, data[k]) for k in dataKeys])
         d = {}
-        d.update([(k,data[k]) for k in dataColumns])
+        d.update([(k, data[k]) for k in dataColumns])
         return d, pk
 
     @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():
-                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():
+                sql.append(
+                    "ALTER TABLE {} ADD {} {} {};".format(
+                        quote(table), quote(key), cls.get_type(val), null
+                    )
+                )
+        return "\n\t".join(sql), tuple()
 
     @classmethod
     def alter_drop(cls, table, columns):
         sql = ["ALTER TABLE {} DROP COLUMN".format(quote(table))]
-        if isinstance(columns,dict):
-            for key,val in columns.items():
+        if isinstance(columns, dict):
+            for key, val in columns.items():
                 sql.append("{},".format(key))
-        if sql[-1][-1] == ',':
+        if sql[-1][-1] == ",":
             sql[-1] = sql[-1][:-1]
-        return '\n\t'.join(sql), tuple()
+        return "\n\t".join(sql), tuple()
 
     @classmethod
     def alter_column_by_type(cls, table, column, value, null_allowed=True):
         sql = ["ALTER TABLE {} ALTER COLUMN".format(quote(table))]
         sql.append("{} {}".format(quote(column), cls.get_type(value)))
         if not null_allowed:
-            sql.append('NOT NULL')
-        return '\n\t'.join(sql), tuple()
+            sql.append("NOT NULL")
+        return "\n\t".join(sql), tuple()
 
     @classmethod
     def alter_column_by_sql(cls, table, column, value):
         sql = ["ALTER TABLE {} ALTER COLUMN".format(quote(table))]
         sql.append("{} {}".format(quote(column), value))
-        return ' '.join(sql), tuple()
-
+        return " ".join(sql), tuple()
 
     @classmethod
     def rename_column(cls, table, orig, new):
-        if '.' in table:
-            schema, table = table.split('.')
+        if "." in table:
+            schema, table = table.split(".")
         else:
             schema = cls.default_schema
-        return "sp_rename '{}.{}.{}', '{}', 'COLUMN';".format(quote(schema), quote(table), quote(orig), new), tuple()
+        return (
+            "sp_rename '{}.{}.{}', '{}', 'COLUMN';".format(
+                quote(schema), quote(table), quote(orig), new
+            ),
+            tuple(),
+        )
 
     @classmethod
     def rename_table(cls, table, name, new):
-        if '.' in table:
-            schema, table = table.split('.')
+        if "." in table:
+            schema, table = table.split(".")
         else:
             schema = cls.default_schema
-        return "sp_rename '{}.{}', '{}';".format(quote(schema), quote(name), new), tuple()
+        return (
+            "sp_rename '{}.{}', '{}';".format(quote(schema), quote(name), new),
+            tuple(),
+        )
 
     @classmethod
     def create_savepoint(cls, sp):
@@ -741,45 +831,56 @@ class SQL:
     def find_duplicates(cls, table, columns, key):
         if isinstance(columns, str):
             columns = [columns]
-        return """
+        return (
+            """
         SELECT {2}
         FROM (SELECT {2},
               ROW_NUMBER() OVER (partition BY {1} ORDER BY {2}) AS rnum
             FROM {0}) t
         WHERE t.rnum > 1;
-        """.format(table, ','.join(quote(columns)), key), tuple()
+        """.format(
+                table, ",".join(quote(columns)), key
+            ),
+            tuple(),
+        )
 
     @classmethod
     def delete_duplicates(cls, table, columns, key):
         if isinstance(columns, str):
             columns = [columns]
-        return """
+        return (
+            """
         DELETE FROM {0}
         WHERE {2} IN (SELECT {2}
               FROM (SELECT {2},
                          ROW_NUMBER() OVER (partition BY {1} ORDER BY {2}) AS rnum
                      FROM {0}) t
               WHERE t.rnum > 1);
-        """.format(table, ','.join(quote(columns)), key), tuple()
+        """.format(
+                table, ",".join(quote(columns)), key
+            ),
+            tuple(),
+        )
 
     @classmethod
     def delete(cls, table, where):
-        sql = ['DELETE FROM {}'.format(table)]
-        sql.append('WHERE')
+        sql = ["DELETE FROM {}".format(table)]
+        sql.append("WHERE")
         vals = []
-        if isinstance(where,dict):
-            join = ''
+        if isinstance(where, dict):
+            join = ""
             for key in sorted(where.keys()):
-                if join: sql.append(join)
+                if join:
+                    sql.append(join)
                 if where[key] == None:
-                    sql.append('{} is NULL'.format(quote(key.lower())))
+                    sql.append("{} is NULL".format(quote(key.lower())))
                 else:
-                    sql.append('{} = %s'.format(quote(key.lower())))
+                    sql.append("{} = %s".format(quote(key.lower())))
                     vals.append(where[key])
-                join = 'AND'
+                join = "AND"
         else:
             sql.append(where)
-        return ' '.join(sql), tuple(vals)
+        return " ".join(sql), tuple(vals)
 
     @classmethod
     def truncate(cls, table):
@@ -787,35 +888,349 @@ 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(cls.default_schema+'.'+name)
-        sql.append('AS')
+            sql.append("TEMPORARY")
+        sql.append("VIEW")
+        sql.append(cls.default_schema + "." + name)
+        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(cls.default_schema+'.'+name)
-        return ' '.join(sql),tuple()
+            sql.append("IF EXISTS")
+        sql.append(cls.default_schema + "." + name)
+        return " ".join(sql), tuple()
 
     class TYPES(object):
-        TEXT = 'VARCHAR(MAX)'
-        INTEGER = 'INT'
-        NUMERIC = 'NUMERIC'
-        DATETIME = 'DATETIME'
-        TIMESTAMP = 'DATETIME'
-        DATE = 'DATE'
-        TIME = 'TIME'
-        BIGINT = 'BIGINT'
-        BOOLEAN = 'BIT'
-        BINARY = 'VARBINARY(MAX)'
-
-reserved_words = ['ABSOLUTE', 'ACTION', 'ADA', 'ADD', 'ALL', 'ALLOCATE', 'ALTER', 'AND', 'ANY', 'ARE', 'AS', 'ASC', 'ASSERTION', 'AT', 'AUTHORIZATION', 'AVG', 'BACKUP', 'BEGIN', 'BETWEEN', 'BIT', 'BIT_LENGTH', 'BOTH', 'BREAK', 'BROWSE', 'BULK', 'BY', 'CASCADE', 'CASCADED', 'CASE', 'CAST', 'CATALOG', 'CHAR', 'CHARACTER', 'CHARACTER_LENGTH', 'CHAR_LENGTH', 'CHECK', 'CHECKPOINT', 'CLOSE', 'CLUSTERED', 'COALESCE', 'COLLATE', 'COLLATION', 'COLUMN', 'COMMIT', 'COMPUTE', 'CONNECT', 'CONNECTION', 'CONSTRAINT', 'CONSTRAINTS', 'CONTAINS', 'CONTAINSTABLE', 'CONTINUE', 'CONVERT', 'CORRESPONDING', 'COUNT', 'CREATE', 'CROSS', 'CURRENT', 'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP', 'CURRENT_USER', 'CURSOR', 'DATABASE', 'DATE', 'DAY', 'DBCC', 'DEALLOCATE', 'DEC', 'DECIMAL', 'DECLARE', 'DEFAULT', 'DEFERRABLE', 'DEFERRED', 'DELETE', 'DENY', 'DESC', 'DESCRIBE', 'DESCRIPTOR', 'DIAGNOSTICS', 'DISCONNECT', 'DISK', 'DISTINCT', 'DISTRIBUTED', 'DOMAIN', 'DOUBLE', 'DROP', 'DUMP', 'ELSE', 'END', 'END-EXEC', 'ERRLVL', 'ESCAPE', 'EXCEPT', 'EXCEPTION', 'EXEC', 'EXECUTE', 'EXISTS', 'EXIT', 'EXTERNAL', 'EXTRACT', 'FALSE', 'FETCH', 'FILE', 'FILLFACTOR', 'FIRST', 'FLOAT', 'FOR', 'FOREIGN', 'FORTRAN', 'FOUND', 'FREETEXT', 'FREETEXTTABLE', 'FROM', 'FULL', 'FUNCTION', 'GET', 'GLOBAL', 'GO', 'GOTO', 'GRANT', 'GROUP', 'HAVING', 'HOLDLOCK', 'HOUR', 'IDENTITY', 'IDENTITYCOL', 'IDENTITY_INSERT', 'IF', 'IMMEDIATE', 'IN', 'INCLUDE', 'INDEX', 'INDICATOR', 'INITIALLY', 'INNER', 'INPUT', 'INSENSITIVE', 'INSERT', 'INT', 'INTEGER', 'INTERSECT', 'INTERVAL', 'INTO', 'IS', 'ISOLATION', 'JOIN', 'KEY', 'KILL', 'LANGUAGE', 'LAST', 'LEADING', 'LEFT', 'LEVEL', 'LIKE', 'LINENO', 'LOAD', 'LOCAL', 'LOWER', 'MATCH', 'MAX', 'MERGE', 'MIN', 'MINUTE', 'MODULE', 'MONTH', 'NAMES', 'NATIONAL', 'NATURAL', 'NCHAR', 'NEXT', 'NO', 'NOCHECK', 'NONCLUSTERED', 'NONE', 'NOT', 'NULL', 'NULLIF', 'NUMERIC', 'OCTET_LENGTH', 'OF', 'OFF', 'OFFSETS', 'ON', 'ONLY', 'OPEN', 'OPENDATASOURCE', 'OPENQUERY', 'OPENROWSET', 'OPENXML', 'OPTION', 'OR', 'ORDER', 'OUTER', 'OUTPUT', 'OVER', 'OVERLAPS', 'PAD', 'PARTIAL', 'PASCAL', 'PERCENT', 'PIVOT', 'PLAN', 'POSITION', 'PRECISION', 'PREPARE', 'PRESERVE', 'PRIMARY', 'PRINT', 'PRIOR', 'PRIVILEGES', 'PROC', 'PROCEDURE', 'PUBLIC', 'RAISERROR', 'READ', 'READTEXT', 'REAL', 'RECONFIGURE', 'REFERENCES', 'RELATIVE', 'REPLICATION', 'RESTORE', 'RESTRICT', 'RETURN', 'REVERT', 'REVOKE', 'RIGHT', 'ROLLBACK', 'ROWCOUNT', 'ROWGUIDCOL', 'ROWS', 'RULE', 'SAVE', 'SCHEMA', 'SCROLL', 'SECOND', 'SECTION', 'SECURITYAUDIT', 'SELECT', 'SEMANTICKEYPHRASETABLE', 'SEMANTICSIMILARITYDETAILSTABLE', 'SEMANTICSIMILARITYTABLE', 'SESSION', 'SESSION_USER', 'SET', 'SETUSER', 'SHUTDOWN', 'SIZE', 'SMALLINT', 'SOME', 'SPACE', 'SQL', 'SQLCA', 'SQLCODE', 'SQLERROR', 'SQLSTATE', 'SQLWARNING', 'STATISTICS', 'SUBSTRING', 'SUM', 'SYSTEM_USER', 'TABLE', 'TABLESAMPLE', 'TEMPORARY', 'TEXTSIZE', 'THEN', 'TIME', 'TIMESTAMP', 'TIMEZONE_HOUR', 'TIMEZONE_MINUTE', 'TO', 'TOP', 'TRAILING', 'TRAN', 'TRANSACTION', 'TRANSLATE', 'TRANSLATION', 'TRIGGER', 'TRIM', 'TRUE', 'TRUNCATE', 'TRY_CONVERT', 'TSEQUAL', 'UNION', 'UNIQUE', 'UNKNOWN', 'UNPIVOT', 'UPDATE', 'UPDATETEXT', 'UPPER', 'USAGE', 'USE', 'USER', 'USING', 'VALUE', 'VALUES', 'VARCHAR', 'VARYING', 'VIEW', 'WAITFOR', 'WHEN', 'WHENEVER', 'WHERE', 'WHILE', 'WITH', 'WITHIN GROUP', 'WORK', 'WRITE', 'WRITETEXT', 'YEAR', 'ZONE',]
+        TEXT = "VARCHAR(MAX)"
+        INTEGER = "INT"
+        NUMERIC = "NUMERIC"
+        DATETIME = "DATETIME"
+        TIMESTAMP = "DATETIME"
+        DATE = "DATE"
+        TIME = "TIME"
+        BIGINT = "BIGINT"
+        BOOLEAN = "BIT"
+        BINARY = "VARBINARY(MAX)"
+
+
+reserved_words = [
+    "ABSOLUTE",
+    "ACTION",
+    "ADA",
+    "ADD",
+    "ALL",
+    "ALLOCATE",
+    "ALTER",
+    "AND",
+    "ANY",
+    "ARE",
+    "AS",
+    "ASC",
+    "ASSERTION",
+    "AT",
+    "AUTHORIZATION",
+    "AVG",
+    "BACKUP",
+    "BEGIN",
+    "BETWEEN",
+    "BIT",
+    "BIT_LENGTH",
+    "BOTH",
+    "BREAK",
+    "BROWSE",
+    "BULK",
+    "BY",
+    "CASCADE",
+    "CASCADED",
+    "CASE",
+    "CAST",
+    "CATALOG",
+    "CHAR",
+    "CHARACTER",
+    "CHARACTER_LENGTH",
+    "CHAR_LENGTH",
+    "CHECK",
+    "CHECKPOINT",
+    "CLOSE",
+    "CLUSTERED",
+    "COALESCE",
+    "COLLATE",
+    "COLLATION",
+    "COLUMN",
+    "COMMIT",
+    "COMPUTE",
+    "CONNECT",
+    "CONNECTION",
+    "CONSTRAINT",
+    "CONSTRAINTS",
+    "CONTAINS",
+    "CONTAINSTABLE",
+    "CONTINUE",
+    "CONVERT",
+    "CORRESPONDING",
+    "COUNT",
+    "CREATE",
+    "CROSS",
+    "CURRENT",
+    "CURRENT_DATE",
+    "CURRENT_TIME",
+    "CURRENT_TIMESTAMP",
+    "CURRENT_USER",
+    "CURSOR",
+    "DATABASE",
+    "DATE",
+    "DAY",
+    "DBCC",
+    "DEALLOCATE",
+    "DEC",
+    "DECIMAL",
+    "DECLARE",
+    "DEFAULT",
+    "DEFERRABLE",
+    "DEFERRED",
+    "DELETE",
+    "DENY",
+    "DESC",
+    "DESCRIBE",
+    "DESCRIPTOR",
+    "DIAGNOSTICS",
+    "DISCONNECT",
+    "DISK",
+    "DISTINCT",
+    "DISTRIBUTED",
+    "DOMAIN",
+    "DOUBLE",
+    "DROP",
+    "DUMP",
+    "ELSE",
+    "END",
+    "END-EXEC",
+    "ERRLVL",
+    "ESCAPE",
+    "EXCEPT",
+    "EXCEPTION",
+    "EXEC",
+    "EXECUTE",
+    "EXISTS",
+    "EXIT",
+    "EXTERNAL",
+    "EXTRACT",
+    "FALSE",
+    "FETCH",
+    "FILE",
+    "FILLFACTOR",
+    "FIRST",
+    "FLOAT",
+    "FOR",
+    "FOREIGN",
+    "FORTRAN",
+    "FOUND",
+    "FREETEXT",
+    "FREETEXTTABLE",
+    "FROM",
+    "FULL",
+    "FUNCTION",
+    "GET",
+    "GLOBAL",
+    "GO",
+    "GOTO",
+    "GRANT",
+    "GROUP",
+    "HAVING",
+    "HOLDLOCK",
+    "HOUR",
+    "IDENTITY",
+    "IDENTITYCOL",
+    "IDENTITY_INSERT",
+    "IF",
+    "IMMEDIATE",
+    "IN",
+    "INCLUDE",
+    "INDEX",
+    "INDICATOR",
+    "INITIALLY",
+    "INNER",
+    "INPUT",
+    "INSENSITIVE",
+    "INSERT",
+    "INT",
+    "INTEGER",
+    "INTERSECT",
+    "INTERVAL",
+    "INTO",
+    "IS",
+    "ISOLATION",
+    "JOIN",
+    "KEY",
+    "KILL",
+    "LANGUAGE",
+    "LAST",
+    "LEADING",
+    "LEFT",
+    "LEVEL",
+    "LIKE",
+    "LINENO",
+    "LOAD",
+    "LOCAL",
+    "LOWER",
+    "MATCH",
+    "MAX",
+    "MERGE",
+    "MIN",
+    "MINUTE",
+    "MODULE",
+    "MONTH",
+    "NAMES",
+    "NATIONAL",
+    "NATURAL",
+    "NCHAR",
+    "NEXT",
+    "NO",
+    "NOCHECK",
+    "NONCLUSTERED",
+    "NONE",
+    "NOT",
+    "NULL",
+    "NULLIF",
+    "NUMERIC",
+    "OCTET_LENGTH",
+    "OF",
+    "OFF",
+    "OFFSETS",
+    "ON",
+    "ONLY",
+    "OPEN",
+    "OPENDATASOURCE",
+    "OPENQUERY",
+    "OPENROWSET",
+    "OPENXML",
+    "OPTION",
+    "OR",
+    "ORDER",
+    "OUTER",
+    "OUTPUT",
+    "OVER",
+    "OVERLAPS",
+    "PAD",
+    "PARTIAL",
+    "PASCAL",
+    "PERCENT",
+    "PIVOT",
+    "PLAN",
+    "POSITION",
+    "PRECISION",
+    "PREPARE",
+    "PRESERVE",
+    "PRIMARY",
+    "PRINT",
+    "PRIOR",
+    "PRIVILEGES",
+    "PROC",
+    "PROCEDURE",
+    "PUBLIC",
+    "RAISERROR",
+    "READ",
+    "READTEXT",
+    "REAL",
+    "RECONFIGURE",
+    "REFERENCES",
+    "RELATIVE",
+    "REPLICATION",
+    "RESTORE",
+    "RESTRICT",
+    "RETURN",
+    "REVERT",
+    "REVOKE",
+    "RIGHT",
+    "ROLLBACK",
+    "ROWCOUNT",
+    "ROWGUIDCOL",
+    "ROWS",
+    "RULE",
+    "SAVE",
+    "SCHEMA",
+    "SCROLL",
+    "SECOND",
+    "SECTION",
+    "SECURITYAUDIT",
+    "SELECT",
+    "SEMANTICKEYPHRASETABLE",
+    "SEMANTICSIMILARITYDETAILSTABLE",
+    "SEMANTICSIMILARITYTABLE",
+    "SESSION",
+    "SESSION_USER",
+    "SET",
+    "SETUSER",
+    "SHUTDOWN",
+    "SIZE",
+    "SMALLINT",
+    "SOME",
+    "SPACE",
+    "SQL",
+    "SQLCA",
+    "SQLCODE",
+    "SQLERROR",
+    "SQLSTATE",
+    "SQLWARNING",
+    "STATISTICS",
+    "SUBSTRING",
+    "SUM",
+    "SYSTEM_USER",
+    "TABLE",
+    "TABLESAMPLE",
+    "TEMPORARY",
+    "TEXTSIZE",
+    "THEN",
+    "TIME",
+    "TIMESTAMP",
+    "TIMEZONE_HOUR",
+    "TIMEZONE_MINUTE",
+    "TO",
+    "TOP",
+    "TRAILING",
+    "TRAN",
+    "TRANSACTION",
+    "TRANSLATE",
+    "TRANSLATION",
+    "TRIGGER",
+    "TRIM",
+    "TRUE",
+    "TRUNCATE",
+    "TRY_CONVERT",
+    "TSEQUAL",
+    "UNION",
+    "UNIQUE",
+    "UNKNOWN",
+    "UNPIVOT",
+    "UPDATE",
+    "UPDATETEXT",
+    "UPPER",
+    "USAGE",
+    "USE",
+    "USER",
+    "USING",
+    "VALUE",
+    "VALUES",
+    "VARCHAR",
+    "VARYING",
+    "VIEW",
+    "WAITFOR",
+    "WHEN",
+    "WHENEVER",
+    "WHERE",
+    "WHILE",
+    "WITH",
+    "WITHIN GROUP",
+    "WORK",
+    "WRITE",
+    "WRITETEXT",
+    "YEAR",
+    "ZONE",
+]