velocity-python 0.0.34__py3-none-any.whl → 0.0.35__py3-none-any.whl

velocity/db/servers/postgres.py

@@ -7,6 +7,7 @@ import datetime
 from ..core import exceptions
 from ..core import engine
 from ..core.table import Query
+from .postgres_reserved import reserved_words
 
 system_fields = [
     "sys_id",
@@ -26,14 +27,12 @@ default_config = {
     "password": os.environ["DBPassword"],
 }
 
-
 def initialize(config=None, **kwargs):
     if not config:
         config = default_config.copy()
     config.update(kwargs)
     return engine.Engine(psycopg2, config, SQL)
 
-
 def make_where(where, sql, vals, is_join=False):
     if not where:
         return
@@ -54,23 +53,23 @@ def make_where(where, sql, vals, is_join=False):
             sql.append(connect)
         if is_join:
             if "." not in key:
-                key = alias + "." + quote(key.lower())
-        if val == None:
+                key = f"{alias}.{quote(key.lower())}"
+        if val is None:
             if "!" in key:
                 key = key.replace("!", "")
-                sql.append("{} is not NULL".format(key))
+                sql.append(f"{key} is not NULL")
             else:
-                sql.append("{} is NULL".format(key))
+                sql.append(f"{key} is NULL")
         elif isinstance(val, (list, tuple)) and "><" not in key:
             if "!" in key:
                 key = key.replace("!", "")
-                sql.append("{} not in %s".format(key))
+                sql.append(f"{key} not in %s")
                 vals.append(tuple(val))
             else:
-                sql.append("{} in %s".format(key))
+                sql.append(f"{key} in %s")
                 vals.append(tuple(val))
         elif isinstance(val, Query):
-            sql.append("{} in ({})".format(key, val))
+            sql.append(f"{key} in ({val})")
         else:
             case = None
             if "<>" in key:
@@ -116,23 +115,15 @@ def make_where(where, sql, vals, is_join=False):
                 key = key.replace("%", "")
                 op = "ilike"
             elif "!~*" in key:
-                # String does not match regular expression, case insensitively
-                # 'thomas' !~* 'T.*ma' → False
                 key = key.replace("!~*", "")
                 op = "!~*"
             elif "~*" in key:
-                # String matches regular expression, case insensitively
-                # 'thomas' ~* 'T.*ma' → True
                 key = key.replace("~*", "")
                 op = "~*"
             elif "!~" in key:
-                # String does not match regular expression, case sensitively
-                # 'thomas' !~ 't.*max' → True
                 key = key.replace("!~", "")
                 op = "!~"
             elif "~" in key:
-                # String matches regular expression, case sensitively
-                # 'thomas' ~ 't.*ma' → True
                 key = key.replace("~", "")
                 op = "~"
             elif "!" in key:
@@ -148,19 +139,18 @@ def make_where(where, sql, vals, is_join=False):
                 op = "="
                 case = "lower"
             if isinstance(val, str) and val[:2] == "@@" and val[2:]:
-                sql.append("{} {} {}".format(key, op, val[2:]))
+                sql.append(f"{key} {op} {val[2:]}")
             elif op in ["between", "not between"]:
-                sql.append("{} {} %s and %s".format(key, op))
+                sql.append(f"{key} {op} %s and %s")
                 vals.extend(val)
             else:
                 if case:
-                    sql.append("{2}({0}) {1} {2}(%s)".format(key, op, case))
+                    sql.append(f"{case}({key}) {op} {case}(%s)")
                 else:
-                    sql.append("{0} {1} %s".format(key, op))
+                    sql.append(f"{key} {op} %s")
                 vals.append(val)
         connect = "AND"
 
-
 def quote(data):
     if isinstance(data, list):
         new = []
@@ -177,14 +167,13 @@ def quote(data):
             if '"' in part:
                 new.append(part)
             elif part.upper() in reserved_words:
-                new.append('"' + part + '"')
+                new.append(f'"{part}"')
             elif re.findall("[/]", part):
-                new.append('"' + part + '"')
+                new.append(f'"{part}"')
             else:
                 new.append(part)
         return ".".join(new)
 
-
 class SQL(object):
     server = "PostGreSQL"
     type_column_identifier = "data_type"
@@ -199,10 +188,10 @@ class SQL(object):
     ColumnMissingErrorCodes = ["42703"]
     ForeignKeyMissingErrorCodes = ["42704"]
 
-    ConnectionErrorCodes = ["08001", "08S01"]
+    ConnectionErrorCodes = ["08001", "08S01","57P03", "08006", "53300"]
     DuplicateKeyErrorCodes = []  # Handled in regex check.
     RetryTransactionCodes = []
-    TruncationErrorCodes = []
+    TruncationErrorCodes = ["22001"]
     LockTimeoutErrorCodes = ["55P03"]
     DatabaseObjectExistsErrorCodes = ["42710", "42P07", "42P04"]
     DataIntegrityErrorCodes = ["23503"]
@@ -307,7 +296,7 @@ class SQL(object):
             tables = {table: chr(letter)}
             letter += 1
             __select = []
-            __from = ["{} AS {}".format(quote(table), tables.get(table))]
+            __from = [f"{quote(table)} AS {tables.get(table)}"]
             __left_join = []
 
             for column in columns:
@@ -321,44 +310,33 @@ class SQL(object):
                     ref_table = foreign["referenced_table_name"]
                     ref_schema = foreign["referenced_table_schema"]
                     ref_column = foreign["referenced_column_name"]
-                    lookup = "{}:{}".format(ref_table, parts[0])
+                    lookup = f"{ref_table}:{parts[0]}"
                     if lookup in tables:
                         __select.append(
-                            '{}."{}" as "{}"'.format(
-                                tables.get(lookup), parts[1], "_".join(parts)
-                            )
+                            f'{tables.get(lookup)}."{parts[1]}" as "{'_'.join(parts)}"'
                         )
                     else:
                         tables[lookup] = chr(letter)
                         letter += 1
                         __select.append(
-                            '{}."{}" as "{}"'.format(
-                                tables.get(lookup), parts[1], "_".join(parts)
-                            )
+                            f'{tables.get(lookup)}."{parts[1]}" as "{'_'.join(parts)}"'
                         )
                         __left_join.append(
-                            'LEFT OUTER JOIN "{}"."{}" AS {}'.format(
-                                ref_schema, ref_table, tables.get(lookup)
-                            )
+                            f'LEFT OUTER JOIN "{ref_schema}"."{ref_table}" AS {tables.get(lookup)}'
                         )
                         __left_join.append(
-                            'ON {}."{}" = {}."{}"'.format(
-                                tables.get(table),
-                                parts[0],
-                                tables.get(lookup),
-                                ref_column,
-                            )
+                            f'ON {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])
+                            column, f"{tables.get(lookup)}.{parts[1]}"
                         )
 
                 else:
                     if "(" in column:
                         __select.append(column)
                     else:
-                        __select.append("{}.{}".format(tables.get(table), column))
+                        __select.append(f"{tables.get(table)}.{column}")
             sql = ["SELECT"]
             sql.append(",".join(__select))
             sql.append("FROM")
@@ -397,11 +375,11 @@ class SQL(object):
                 orderby = ",".join(orderby)
             sql.append(orderby)
         if start and qty:
-            sql.append("OFFSET {} ROWS FETCH NEXT {} ROWS ONLY".format(start, qty))
+            sql.append(f"OFFSET {start} ROWS FETCH NEXT {qty} ROWS ONLY")
         elif start:
-            sql.append("OFFSET {} ROWS".format(start))
+            sql.append(f"OFFSET {start} ROWS")
         elif qty:
-            sql.append("FETCH NEXT {} ROWS ONLY".format(qty))
+            sql.append(f"FETCH NEXT {qty} ROWS ONLY")
         if lock or skip_locked:
             sql.append("FOR UPDATE")
         if skip_locked:
@@ -411,7 +389,7 @@ class SQL(object):
 
     @classmethod
     def create_database(cls, name):
-        return "create database " + name, tuple()
+        return f"create database {name}", tuple()
 
     @classmethod
     def last_id(cls, table):
@@ -432,23 +410,22 @@ class SQL(object):
 
     @classmethod
     def drop_database(cls, name):
-        return "drop database if exists " + name, tuple()
+        return f"drop database if exists {name}", tuple()
 
     @classmethod
     def create_table(cls, name, columns={}, drop=False):
         if "." in name:
             fqtn = name
         else:
-            fqtn = "public." + name
+            fqtn = f"public.{name}"
         schema, table = fqtn.split(".")
         name = fqtn.replace(".", "_")
-        trigger = "".format(name)
         sql = []
         if drop:
             sql.append(cls.drop_table(fqtn)[0])
         sql.append(
-            """
-            CREATE TABLE {0} (
+            f"""
+            CREATE TABLE {fqtn} (
               sys_id BIGSERIAL PRIMARY KEY,
               sys_modified TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
               sys_created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
@@ -458,9 +435,9 @@ class SQL(object):
               description TEXT
             );
 
-            SELECT SETVAL(PG_GET_SERIAL_SEQUENCE('{0}', 'sys_id'),1000,TRUE);
+            SELECT SETVAL(PG_GET_SERIAL_SEQUENCE('{fqtn}', 'sys_id'),1000,TRUE);
 
-            CREATE OR REPLACE FUNCTION {1}.on_sys_modified()
+            CREATE OR REPLACE FUNCTION {schema}.on_sys_modified()
               RETURNS TRIGGER AS
             $BODY$
                         BEGIN
@@ -480,13 +457,11 @@ class SQL(object):
               LANGUAGE plpgsql VOLATILE
               COST 100;
 
-            CREATE TRIGGER on_update_row_{3}
-            BEFORE INSERT OR UPDATE ON {0}
-            FOR EACH ROW EXECUTE PROCEDURE {1}.on_sys_modified();
+            CREATE TRIGGER on_update_row_{fqtn.replace('.', '_')}
+            BEFORE INSERT OR UPDATE ON {fqtn}
+            FOR EACH ROW EXECUTE PROCEDURE {schema}.on_sys_modified();
 
-        """.format(
-                fqtn, schema, table, fqtn.replace(".", "_")
-            )
+        """
         )
 
         for key, val in columns.items():
@@ -494,26 +469,24 @@ class SQL(object):
             if key in system_fields:
                 continue
             sql.append(
-                "ALTER TABLE {} ADD COLUMN {} {};".format(
-                    quote(fqtn), quote(key), cls.get_type(val)
-                )
+                f"ALTER TABLE {quote(fqtn)} ADD COLUMN {quote(key)} {cls.get_type(val)};"
             )
         return "\n\t".join(sql), tuple()
 
     @classmethod
     def drop_table(cls, name):
-        return "drop table if exists %s cascade;" % quote(name), tuple()
+        return f"drop table if exists {quote(name)} cascade;", tuple()
 
     @classmethod
     def drop_column(cls, table, name, cascade=True):
         if cascade:
             return (
-                "ALTER TABLE %s DROP COLUMN %s CASCADE" % (quote(table), quote(name)),
+                f"ALTER TABLE {quote(table)} DROP COLUMN {quote(name)} CASCADE",
                 tuple(),
             )
         else:
             return (
-                "ALTER TABLE %s DROP COLUMN %s " % (quote(table), quote(name)),
+                f"ALTER TABLE {quote(table)} DROP COLUMN {quote(name)}",
                 tuple(),
             )
 
@@ -651,7 +624,7 @@ class SQL(object):
         cls, table, columns, key_to_table, key_to_columns, name=None, schema=None
     ):
         if "." not in table and schema:
-            table = "{}.{}".format(schema, table)
+            table = f"{schema}.{table}"
         if isinstance(key_to_columns, str):
             key_to_columns = [key_to_columns]
         if isinstance(columns, str):
@@ -662,10 +635,8 @@ class SQL(object):
             m.update(" ".join(columns).encode("utf-8"))
             m.update(key_to_table.encode("utf-8"))
             m.update(" ".join(key_to_columns).encode("utf-8"))
-            name = "FK_" + m.hexdigest()
-        sql = "ALTER TABLE {} ADD CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {} ({});".format(
-            table, name, ",".join(columns), key_to_table, ",".join(key_to_columns)
-        )
+            name = f"FK_{m.hexdigest()}"
+        sql = f"ALTER TABLE {table} ADD CONSTRAINT {name} FOREIGN KEY ({','.join(columns)}) REFERENCES {key_to_table} ({','.join(key_to_columns)});"
 
         return sql, tuple()
 
@@ -680,7 +651,7 @@ class SQL(object):
         schema=None,
     ):
         if "." not in table and schema:
-            table = "{}.{}".format(schema, table)
+            table = f"{schema}.{table}"
         if isinstance(key_to_columns, str):
             key_to_columns = [key_to_columns]
         if isinstance(columns, str):
@@ -691,8 +662,8 @@ class SQL(object):
             m.update(" ".join(columns).encode("utf-8"))
             m.update(key_to_table.encode("utf-8"))
             m.update(" ".join(key_to_columns).encode("utf-8"))
-            name = "FK_" + m.hexdigest()
-        sql = "ALTER TABLE {} DROP CONSTRAINT {};".format(table, name)
+            name = f"FK_{m.hexdigest()}"
+        sql = f"ALTER TABLE {table} DROP CONSTRAINT {name};"
         return sql, tuple()
 
     @classmethod
@@ -715,7 +686,7 @@ class SQL(object):
         CREATE EXTENSION btree_gist; is required to use gist
         """
         if "." not in table and schema:
-            table = "{}.{}".format(schema, table)
+            table = f"{schema}.{table}"
         if isinstance(columns, (list, set)):
             columns = ",".join([quote(c.lower()) for c in columns])
         else:
@@ -733,12 +704,10 @@ class SQL(object):
             )
         if trigram:
             sql.append(
-                "IDX__TRGM_{}_{}__{}".format(
-                    table.replace(".", "_"), trigram.upper(), name
-                )
+                f"IDX__TRGM_{table.replace('.', '_')}_{trigram.upper()}__{name}"
             )
         else:
-            sql.append("IDX__{}__{}".format(table.replace(".", "_"), name))
+            sql.append(f"IDX__{table.replace('.', '_')}__{name}")
         sql.append("ON")
         sql.append(quote(tablename))
 
@@ -755,7 +724,7 @@ class SQL(object):
                 column = tbl.column(column_name)
                 if column.py_type == str:
                     if lower:
-                        sql.append("lower({})".format(quote(column_name)))
+                        sql.append(f"lower({quote(column_name)})")
                     else:
                         sql.append(quote(column_name))
                 else:
@@ -764,7 +733,7 @@ class SQL(object):
         else:
             sql.append(columns)
         if trigram:
-            sql.append("{}_trgm_ops".format(trigram.lower()))
+            sql.append(f"{trigram.lower()}_trgm_ops")
         sql.append(")")
         vals = []
 
@@ -774,7 +743,7 @@ class SQL(object):
     @classmethod
     def drop_index(cls, table=None, columns=None, name=None, schema=None, trigram=None):
         if "." not in table and schema:
-            table = "{}.{}".format(schema, table)
+            table = f"{schema}.{table}"
         if isinstance(columns, (list, set)):
             columns = ",".join([quote(c.lower()) for c in columns])
         else:
@@ -790,12 +759,10 @@ class SQL(object):
             )
         if trigram:
             sql.append(
-                "IDX__TRGM_{}_{}__{}".format(
-                    table.replace(".", "_"), trigram.upper(), name
-                )
+                f"IDX__TRGM_{table.replace('.', '_')}_{trigram.upper()}__{name}"
             )
         else:
-            sql.append("IDX__{}__{}".format(table.replace(".", "_"), name))
+            sql.append(f"IDX__{table.replace('.', '_')}__{name}")
         return " ".join(sql), tuple()
 
     @classmethod
@@ -874,12 +841,12 @@ class SQL(object):
             if connect:
                 sql.append(connect)
             if isinstance(val, str) and val[:2] == "@@" and val[2:]:
-                sql.append("{} = {}".format(key, val[2:]))
+                sql.append(f"{key} = {val[2:]}")
             else:
                 if excluded:
-                    sql.append("{} = EXCLUDED.{}".format(key, key))
+                    sql.append(f"{key} = EXCLUDED.{key}")
                 else:
-                    sql.append("{} = %s".format(key))
+                    sql.append(f"{key} = %s")
                     vals.append(val)
             connect = ","
         if is_join:
@@ -920,18 +887,10 @@ class SQL(object):
             return cls.TYPES.BOOLEAN
         elif isinstance(v, int) or v is int:
             return cls.TYPES.BIGINT
-        # 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)"
+            return f"{cls.TYPES.NUMERIC}(19, 6)"
         elif isinstance(v, decimal.Decimal) or v is decimal.Decimal:
-            return cls.TYPES.NUMERIC + "(19, 6)"
+            return f"{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:
@@ -942,7 +901,6 @@ class SQL(object):
             return cls.TYPES.INTERVAL
         elif isinstance(v, bytes) or v is bytes:
             return cls.TYPES.BINARY
-        # Everything else defaults to TEXT, incl. None
         return cls.TYPES.TEXT
 
     @classmethod
@@ -956,14 +914,6 @@ class SQL(object):
             return cls.TYPES.BOOLEAN
         elif isinstance(v, int) or v is int:
             return cls.TYPES.BIGINT
-        # 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
         elif isinstance(v, decimal.Decimal) or v is decimal.Decimal:
@@ -978,7 +928,6 @@ class SQL(object):
             return cls.TYPES.INTERVAL
         elif isinstance(v, bytes) or v is bytes:
             return cls.TYPES.BINARY
-        # Everything else defaults to TEXT, incl. None
         return cls.TYPES.TEXT
 
     @classmethod
@@ -1011,22 +960,15 @@ class SQL(object):
         elif v == cls.TYPES.INTERVAL_TZ:
             return datetime.timedelta
         else:
-            raise Exception("unmapped type %s" % v)
+            raise Exception(f"unmapped type {v}")
 
     @classmethod
     def massage_data(cls, data):
-        """
-
-        :param :
-        :param :
-        :param :
-        :returns:
-        """
         data = {key.lower(): val for key, val in data.items()}
         primaryKey = set(cls.GetPrimaryKeyColumnNames())
         if not primaryKey:
             if not cls.Exists():
-                raise DbTableMissingError
+                raise exceptions.DbTableMissingError
         dataKeys = set(data.keys()).intersection(primaryKey)
         dataColumns = set(data.keys()).difference(primaryKey)
         pk = {}
@@ -1043,62 +985,58 @@ class SQL(object):
             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
-                    )
+                    f"ALTER TABLE {quote(table)} ADD {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))]
+        sql = [f"ALTER TABLE {quote(table)} DROP COLUMN"]
         if isinstance(columns, dict):
             for key, val in columns.items():
                 key = re.sub("<>!=%", "", key.lower())
-                sql.append("{},".format(key))
+                sql.append(f"{key},")
         if sql[-1][-1] == ",":
             sql[-1] = sql[-1][:-1]
         return "\n\t".join(sql), tuple()
 
     @classmethod
     def alter_column_by_type(cls, table, column, value, nullable=True):
-        sql = ["ALTER TABLE {} ALTER COLUMN".format(quote(table))]
-        sql.append("{} TYPE {}".format(quote(column), cls.get_type(value)))
-        sql.append("USING {}::{}".format(quote(column), cls.get_conv(value)))
+        sql = [f"ALTER TABLE {quote(table)} ALTER COLUMN"]
+        sql.append(f"{quote(column)} TYPE {cls.get_type(value)}")
+        sql.append(f"USING {quote(column)}::{cls.get_conv(value)}")
         if not nullable:
             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))
+        sql = [f"ALTER TABLE {quote(table)} ALTER COLUMN"]
+        sql.append(f"{quote(column)} {value}")
         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)
-            ),
+            f"ALTER TABLE {quote(table)} RENAME COLUMN {quote(orig)} TO {quote(new)};",
             tuple(),
         )
 
     @classmethod
     def rename_table(cls, table, new):
-        return "ALTER TABLE {} RENAME TO {};".format(quote(table), quote(new)), tuple()
+        return f"ALTER TABLE {quote(table)} RENAME TO {quote(new)};", tuple()
 
     @classmethod
     def create_savepoint(cls, sp):
-        return 'SAVEPOINT "{}"'.format(sp), tuple()
+        return f'SAVEPOINT "{sp}"', tuple()
 
     @classmethod
     def release_savepoint(cls, sp):
-        return 'RELEASE SAVEPOINT "{}"'.format(sp), tuple()
+        return f'RELEASE SAVEPOINT "{sp}"', tuple()
 
     @classmethod
     def rollback_savepoint(cls, sp):
-        return 'ROLLBACK TO SAVEPOINT "{}"'.format(sp), tuple()
+        return f'ROLLBACK TO SAVEPOINT "{sp}"', tuple()
 
     @classmethod
     def duplicate_rows(cls, table, columns, where={}):
@@ -1113,14 +1051,14 @@ class SQL(object):
 
     @classmethod
     def delete(cls, table, where):
-        sql = ["DELETE FROM {}".format(table)]
+        sql = [f"DELETE FROM {table}"]
         vals = []
         make_where(where, sql, vals)
         return " ".join(sql), tuple(vals)
 
     @classmethod
     def truncate(cls, table):
-        return "truncate table {}".format(quote(table)), tuple()
+        return f"truncate table {quote(table)}", tuple()
 
     @classmethod
     def create_view(cls, name, query, temp=False, silent=True):
@@ -1145,23 +1083,21 @@ class SQL(object):
 
     @classmethod
     def alter_trigger(cls, table, state="ENABLE", name="USER"):
-        return "ALTER TABLE {} {} TRIGGER {}".format(table, state, name), tuple()
+        return f"ALTER TABLE {table} {state} TRIGGER {name}", tuple()
 
     @classmethod
     def set_sequence(cls, table, next_value):
         return (
-            "SELECT SETVAL(PG_GET_SERIAL_SEQUENCE('{0}', 'sys_id'),{1},FALSE)".format(
-                table, next_value
-            ),
+            f"SELECT SETVAL(PG_GET_SERIAL_SEQUENCE('{table}', 'sys_id'),{next_value},FALSE)",
             tuple(),
         )
 
     @classmethod
     def missing(cls, table, list, column="SYS_ID", where=None):
         sql = [
-            "SELECT * FROM",
+            f"SELECT * FROM",
             f"UNNEST('{{{','.join([str(x) for x in list])}}}'::int[]) id",
-            "EXCEPT ALL",
+            f"EXCEPT ALL",
             f"SELECT {column} FROM {table}",
         ]
         vals = []
@@ -1184,213 +1120,3 @@ class SQL(object):
         BOOLEAN = "BOOLEAN"
         BINARY = "BYTEA"
         INTERVAL = "INTERVAL"
-
-
-reserved_words = [
-    "ADMIN",
-    "ALIAS",
-    "ALL",
-    "ALLOCATE",
-    "ANALYSE",
-    "ANALYZE",
-    "AND",
-    "ANY",
-    "ARE",
-    "ARRAY",
-    "AS",
-    "ASC",
-    "AUTHORIZATION",
-    "BETWEEN",
-    "BINARY",
-    "BLOB",
-    "BOTH",
-    "BREADTH",
-    "CALL",
-    "CASCADED",
-    "CASE",
-    "CAST",
-    "CATALOG",
-    "CHECK",
-    "CLOB",
-    "COLLATE",
-    "COLLATION",
-    "COLUMN",
-    "COMPLETION",
-    "CONNECT",
-    "CONNECTION",
-    "CONSTRAINT",
-    "CONSTRUCTOR",
-    "CONTINUE",
-    "CORRESPONDING",
-    "CREATE",
-    "CROSS",
-    "CUBE",
-    "CURRENT",
-    "CURRENT_DATE",
-    "CURRENT_PATH",
-    "CURRENT_ROLE",
-    "CURRENT_TIME",
-    "CURRENT_TIMESTAMP",
-    "CURRENT_USER",
-    "DATA",
-    "DATE",
-    "DEFAULT",
-    "DEFERRABLE",
-    "DEPTH",
-    "DEREF",
-    "DESC",
-    "DESCRIBE",
-    "DESCRIPTOR",
-    "DESTROY",
-    "DESTRUCTOR",
-    "DETERMINISTIC",
-    "DIAGNOSTICS",
-    "DICTIONARY",
-    "DISCONNECT",
-    "DISTINCT",
-    "DO",
-    "DYNAMIC",
-    "ELSE",
-    "END",
-    "END-EXEC",
-    "EQUALS",
-    "EVERY",
-    "EXCEPT",
-    "EXCEPTION",
-    "EXEC",
-    "FALSE",
-    "FIRST",
-    "FOR",
-    "FOREIGN",
-    "FOUND",
-    "FREE",
-    "FREEZE",
-    "FROM",
-    "FULL",
-    "GENERAL",
-    "GO",
-    "GOTO",
-    "GRANT",
-    "GROUP",
-    "GROUPING",
-    "HAVING",
-    "HOST",
-    "IDENTITY",
-    "IGNORE",
-    "ILIKE",
-    "IN",
-    "INDICATOR",
-    "INITIALIZE",
-    "INITIALLY",
-    "INNER",
-    "INTERSECT",
-    "INTO",
-    "IS",
-    "ISNULL",
-    "ITERATE",
-    "JOIN",
-    "LARGE",
-    "LAST",
-    "LATERAL",
-    "LEADING",
-    "LEFT",
-    "LESS",
-    "LIKE",
-    "LIMIT",
-    "LOCALTIME",
-    "LOCALTIMESTAMP",
-    "LOCATOR",
-    "MAP",
-    "MODIFIES",
-    "MODIFY",
-    "MODULE",
-    "NAME",
-    "NATURAL",
-    "NCLOB",
-    "NEW",
-    "NOT",
-    "NOTNULL",
-    "NULL",
-    "OBJECT",
-    "OFF",
-    "OFFSET",
-    "OLD",
-    "ON",
-    "ONLY",
-    "OPEN",
-    "OPERATION",
-    "OR",
-    "ORDER",
-    "ORDINALITY",
-    "OUTER",
-    "OUTPUT",
-    "OVERLAPS",
-    "PAD",
-    "PARAMETER",
-    "PARAMETERS",
-    "PLACING",
-    "POSTFIX",
-    "PREFIX",
-    "PREORDER",
-    "PRESERVE",
-    "PRIMARY",
-    "PUBLIC",
-    "READS",
-    "RECURSIVE",
-    "REF",
-    "REFERENCES",
-    "REFERENCING",
-    "RESULT",
-    "RETURN",
-    "RIGHT",
-    "ROLE",
-    "ROLLUP",
-    "ROUTINE",
-    "ROWS",
-    "SAVEPOINT",
-    "SCOPE",
-    "SEARCH",
-    "SECTION",
-    "SELECT",
-    "SESSION_USER",
-    "SETS",
-    "SIMILAR",
-    "SIZE",
-    "SOME",
-    "SPACE",
-    "SPECIFIC",
-    "SPECIFICTYPE",
-    "SQL",
-    "SQLCODE",
-    "SQLERROR",
-    "SQLEXCEPTION",
-    "SQLSTATE",
-    "SQLWARNING",
-    "STATE",
-    "STATIC",
-    "STRUCTURE",
-    "SYSTEM_USER",
-    "TABLE",
-    "TERMINATE",
-    "THAN",
-    "THEN",
-    "TIMESTAMP",
-    "TIMEZONE_HOUR",
-    "TIMEZONE_MINUTE",
-    "TO",
-    "TRAILING",
-    "TRANSLATION",
-    "TRUE",
-    "UNDER",
-    "UNION",
-    "UNIQUE",
-    "UNNEST",
-    "USER",
-    "USING",
-    "VALUE",
-    "VARIABLE",
-    "VERBOSE",
-    "WHEN",
-    "WHENEVER",
-    "WHERE",
-]