tspace-mysql 1.9.0 → 1.9.1-beta.2

package/dist/lib/core/Driver/postgres/PostgresQueryBuilder.d.ts

@@ -2,8 +2,9 @@ import { QueryBuilder } from "..";
 import { Blueprint } from "../../Blueprint";
 import { StateManager } from "../../StateManager";
 export declare class PostgresQueryBuilder extends QueryBuilder {
+    private _returnStart;
     constructor(state: StateManager);
-    select: () => string;
+    select: (selectColumns?: string[]) => string;
     insert(): string;
     update(): string;
     remove(): string;
@@ -21,6 +22,11 @@ export declare class PostgresQueryBuilder extends QueryBuilder {
         database: string;
         table: string;
     }): string;
+    hasTable({ database, table }: {
+        database: string;
+        table: string;
+    }): string;
+    createDatabase(database: string): string;
     createTable({ database, table, schema, }: {
         database: string;
         table: string;
@@ -52,7 +58,7 @@ export declare class PostgresQueryBuilder extends QueryBuilder {
         table: string;
         constraint: string;
     }): string;
-    createFK({ table, tableRef, key, constraint, foreign, }: {
+    addFK({ table, tableRef, key, constraint, foreign, }: {
         table: string;
         tableRef: string;
         key: string;
@@ -71,15 +77,44 @@ export declare class PostgresQueryBuilder extends QueryBuilder {
         database: string;
         table: string;
     }): string;
-    hasIndex({ database, table, index, }: {
+    hasIndex({ database, table, name, }: {
         database: string;
         table: string;
-        index: string;
+        name: string;
     }): string;
-    createIndex({ table, index, key, }: {
+    addIndex({ table, name, columns, }: {
+        table: string;
+        name: string;
+        columns: string[];
+    }): string;
+    dropIndex({ table, name, }: {
+        table: string;
+        name: string;
+    }): string;
+    hasUnique({ database, table, name, }: {
+        database: string;
+        table: string;
+        name: string;
+    }): string;
+    addUnique({ table, name, columns }: {
+        table: string;
+        name: string;
+        columns: string[];
+    }): string;
+    dropUnique({ table, name, }: {
+        table: string;
+        name: string;
+    }): string;
+    hasPrimaryKey({ database, table, }: {
+        database: string;
+        table: string;
+    }): string;
+    addPrimaryKey({ table, columns, }: {
+        table: string;
+        columns: string[];
+    }): string;
+    dropPrimaryKey({ table }: {
         table: string;
-        index: string;
-        key: string;
     }): string;
     getDatabase(database: string): string;
     dropDatabase(database: string): string;
@@ -88,13 +123,15 @@ export declare class PostgresQueryBuilder extends QueryBuilder {
     truncate(table: string): string;
     sleep(second: number): string;
     format(sql: (string | null)[] | string): string;
+    getActiveConnections(): string;
+    getMaxConnections(): string;
+    lockTable(mode: 'WRITE' | 'READ'): string;
+    unlockTable(): null;
     protected bindJoin(values: string[]): string | null;
-    protected bindWhere(values: string[]): string | null;
+    protected bindWhere(values: any[]): string | null;
     protected bindOrderBy(values: string[]): string | null;
     protected bindGroupBy(values: string[]): string | null;
-    protected bindSelect(values: string[], { distinct }?: {
-        distinct?: string;
-    }): string;
+    protected bindSelect(values: string[]): string;
     protected bindFrom({ from, alias, rawAlias, }: {
         from: string[];
         alias: string | null;
@@ -103,6 +140,10 @@ export declare class PostgresQueryBuilder extends QueryBuilder {
     protected bindLimit(limit: string | number | null): string;
     protected bindOffset(offset: string | number | null): string;
     protected bindHaving(having: string | null): string;
-    protected bindRowLevelLock(mode: "FOR_UPDATE" | "FOR_SHARE" | null): any;
+    protected bindRowLevelLock(rowLevelLock: {
+        mode: "FOR_UPDATE" | "FOR_SHARE" | null;
+        skipLocked: boolean | null;
+        nowait: boolean | null;
+    }): any;
     private _formatedTypeAndAttributes;
 }

package/dist/lib/core/Driver/postgres/PostgresQueryBuilder.js

@@ -1,18 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresQueryBuilder = void 0;
+const pluralize_1 = require("pluralize");
 const __1 = require("..");
 class PostgresQueryBuilder extends __1.QueryBuilder {
+    _returnStart = 'RETURNING *';
     constructor(state) {
         super(state);
     }
-    select = () => {
+    select = (selectColumns) => {
         const combindSQL = [
-            this.bindSelect(this.$state.get("SELECT")),
+            this.bindSelect(selectColumns ?? this.$state.get("SELECT")),
             this.bindFrom({
                 from: !this.$state.get("FROM").length
-                    ? [this.$state.get("TABLE_NAME")].map(String)
-                    : [this.$state.get("TABLE_NAME"), ...this.$state.get("FROM")].map(String),
+                    ? [this.$state.get("TABLE_NAME")].filter(Boolean).map(String)
+                    : [this.$state.get("TABLE_NAME"), ...this.$state.get("FROM")].filter(Boolean).map(String),
                 alias: this.$state.get("ALIAS"),
                 rawAlias: this.$state.get("RAW_ALIAS"),
             }),
@@ -58,24 +60,28 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
             columns,
             this.$constants("VALUES"),
             values,
-            "RETURNING *"
+            this._returnStart
         ]);
         return sql;
     }
     update() {
-        const query = this.$state.get("UPDATE");
-        if (query == null) {
+        if (this.$state.get("UPDATE") == null) {
             return '';
         }
+        const primaryKey = `${this.$state.get("TABLE_NAME")}.\`${this.$state.get("PRIMARY_KEY")}\``;
         const sql = this.format([
-            `${this.$constants("UPDATE")}`,
-            `${this.$state.get("TABLE_NAME")}`,
-            `${this.$constants("SET")}`,
-            `${query}`,
-            this.bindWhere(this.$state.get("WHERE")),
-            this.bindOrderBy(this.$state.get("ORDER_BY")),
-            /* this.bindLimit(this.$state.get("LIMIT")) postgres does't support limit when update */
-            "RETURNING *",
+            this.$constants("UPDATE"),
+            this.$state.get("TABLE_NAME"),
+            this.$constants("SET"),
+            this.$state.get("UPDATE"),
+            this.bindWhere([
+                {
+                    column: `${primaryKey}`,
+                    operator: `${this.$constants('IN')}`,
+                    value: `(${this.select([primaryKey])})`
+                }
+            ]),
+            this._returnStart
         ]);
         return sql;
     }
@@ -84,13 +90,19 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
         if (!query) {
             throw new Error("Bad query builder: DELETE state not found. Please check your query configuration.");
         }
+        const primaryKey = `${this.$state.get("TABLE_NAME")}.\`${this.$state.get("PRIMARY_KEY")}\``;
         let sql = this.format([
             this.$constants("DELETE"),
             this.$constants("FROM"),
             this.$state.get("TABLE_NAME"),
-            this.bindWhere(this.$state.get("WHERE")),
-            this.bindOrderBy(this.$state.get("ORDER_BY")),
-            "RETURNING *",
+            this.bindWhere([
+                {
+                    column: `${primaryKey}`,
+                    operator: `${this.$constants('IN')}`,
+                    value: `(${this.select([primaryKey])})`
+                }
+            ]),
+            this._returnStart
         ]);
         if (this.$state.get("CTE").length) {
             sql = `${this.$constants("WITH")} ${this.$state
@@ -139,12 +151,24 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
             WHEN column_default LIKE 'nextval(%' THEN 'PRI'
             ELSE NULL
         END AS "Key",
+
         CASE
+          WHEN DATA_TYPE = 'USER-DEFINED' THEN
+          'enum(' ||
+          (
+            SELECT string_agg(quote_literal(e.enumlabel), ',')
+            FROM PG_TYPE t
+            JOIN PG_ENUM e ON t.oid = e.enumtypid
+            WHERE t.typname = udt_name
+          )
+          || ')'
+
           WHEN 
             DATA_TYPE = 'character varying' AND CHARACTER_MAXIMUM_LENGTH IS NOT NULL
             THEN DATA_TYPE || '(' || CHARACTER_MAXIMUM_LENGTH || ')'
           ELSE DATA_TYPE
         END AS "Type",
+
         IS_NULLABLE as "Nullable",
 
         CASE
@@ -203,6 +227,28 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
         ];
         return this.format(sql);
     }
+    hasTable({ database, table }) {
+        const sql = [
+            `SELECT EXISTS( 
+        SELECT 1
+        FROM INFORMATION_SCHEMA.TABLES
+        WHERE 
+          TABLE_TYPE = 'BASE TABLE'
+          AND TABLE_CATALOG = '${database.replace(/\`/g, "")}'
+          AND TABLE_NAME LIKE '${table.replace(/\`/g, "")}'
+          AND UPPER(TABLE_SCHEMA) NOT IN (
+            'PG_CATALOG', 
+            'INFORMATION_SCHEMA', 
+            'PG_TOAST'
+          )
+       ) AS "IS_EXISTS"`,
+        ];
+        return this.format(sql);
+    }
+    createDatabase(database) {
+        const sql = `CREATE DATABASE \`${database}\``;
+        return this.format(sql);
+    }
     createTable({ database, table, schema, }) {
         let columns = [];
         if (Array.isArray(schema)) {
@@ -258,7 +304,7 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
             this.$constants("ALTER_TABLE"),
             `\`${table}\``,
             this.$constants("ADD"),
-            "COLUMN",
+            this.$constants("COLUMN"),
             `\`${column}\` ${formatedType} ${formatedAttributes != null && formatedAttributes.length
                 ? `${formatedAttributes.join(" ")}`
                 : ""}`,
@@ -267,17 +313,22 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
         return this.format(sql);
     }
     changeColumn({ table, column, type, attributes, }) {
-        const { formatedAttributes, formatedType } = this._formatedTypeAndAttributes({
+        const { formatedAttributes, formatedType, raws } = this._formatedTypeAndAttributes({
+            table,
             type,
             attributes,
             key: column,
+            changed: true
         });
+        if (raws) {
+            return this.format(raws);
+        }
         const sql = [
             this.$constants("ALTER_TABLE"),
             `\`${table}\``,
             this.$constants("ALTER_COLUMN"),
             `\`${column}\``,
-            `TYPE ${formatedType}`,
+            `${this.$constants("TYPE")} ${formatedType}`,
         ];
         const sqlAttr = [];
         for (const formatedAttribute of formatedAttributes) {
@@ -290,7 +341,7 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
                 `\`${table}\``,
                 this.$constants("ALTER_COLUMN"),
                 `\`${column}\``,
-                `SET ${formatedAttribute}`,
+                `${this.$constants("SET")} ${formatedAttribute}`,
             ].join(" "));
         }
         if (!sqlAttr.length) {
@@ -329,7 +380,6 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
           BY con.CONNAME, conrel.RELNAME, confrel.RELNAME
         ORDER 
           BY conrel.RELNAME, con.CONNAME
-
       `,
         ];
         return this.format(sql);
@@ -378,7 +428,7 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
         ];
         return this.format(sql);
     }
-    createFK({ table, tableRef, key, constraint, foreign, }) {
+    addFK({ table, tableRef, key, constraint, foreign, }) {
         const sql = [
             `${this.$constants("ALTER_TABLE")}`,
             `\`${table}\``,
@@ -438,7 +488,7 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
         ];
         return this.format(sql);
     }
-    hasIndex({ database, table, index, }) {
+    hasIndex({ database, table, name, }) {
         const sql = [
             `
         SELECT EXISTS( 
@@ -457,18 +507,103 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
             t.RELKIND             = 'r'
             AND kcu.TABLE_CATALOG = '${database.replace(/\`/g, "")}'
             AND t.RELNAME         = '${table.replace(/\`/g, "")}'
-            AND i.RELNAME         = '${index}'
+            AND i.RELNAME         = '${name}'
         ) AS "IS_EXISTS"  
       `,
         ];
         return this.format(sql);
     }
-    createIndex({ table, index, key, }) {
+    addIndex({ table, name, columns, }) {
+        const cols = columns
+            .map(col => `\`${col}\``)
+            .join(", ");
+        const sql = [
+            this.$constants("CREATE_INDEX"),
+            `\`${name}\``,
+            this.$constants("ON"),
+            `\`${table}\``,
+            `(${cols})`
+        ];
+        return this.format(sql);
+    }
+    dropIndex({ table, name, }) {
+        const sql = [
+            this.$constants("DROP"),
+            this.$constants("INDEX"),
+            `\`${name}\``
+        ];
+        return this.format(sql);
+    }
+    hasUnique({ database, table, name, }) {
+        const sql = [
+            `
+      SELECT EXISTS(
+        SELECT 1
+        FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS
+        WHERE 
+          TABLE_SCHEMA        = '${database.replace(/['"`]/g, "")}'
+          AND TABLE_NAME      = '${table.replace(/['"`]/g, "")}'
+          AND CONSTRAINT_NAME = '${name.replace(/['"`]/g, "")}'
+          AND CONSTRAINT_TYPE = '${this.$constants("UNIQUE")}'
+      ) AS "IS_EXISTS"
+      `
+        ];
+        return this.format(sql);
+    }
+    addUnique({ table, name, columns }) {
+        const cols = columns
+            .map(col => `\`${col}\``)
+            .join(", ");
         const sql = [
-            `${this.$constants("CREATE_INDEX")}`,
-            `\`${index.replace(/`/g, "")}\``,
-            `${this.$constants("ON")}`,
-            `${table}(\`${key.replace(/`/g, "")}\`)`,
+            this.$constants("ALTER_TABLE"),
+            `\`${table}\``,
+            this.$constants("ADD_CONSTRAINT"),
+            `\`${name}\``,
+            this.$constants("UNIQUE"),
+            `(${cols})`
+        ];
+        return this.format(sql);
+    }
+    dropUnique({ table, name, }) {
+        const sql = [
+            this.$constants("ALTER_TABLE"),
+            `\`${table}\``,
+            this.$constants("DROP"),
+            this.$constants("CONSTRAINT"),
+            `\`${name}\``
+        ];
+        return this.format(sql);
+    }
+    hasPrimaryKey({ database, table, }) {
+        const sql = `
+      SELECT EXISTS (
+        SELECT 1
+        FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS
+        WHERE 
+          TABLE_SCHEMA        = '${database.replace(/['"`]/g, "")}'
+          AND TABLE_NAME      = '${table.replace(/['"`]/g, "")}'
+          AND CONSTRAINT_TYPE = '${this.$constants('PRIMARY_KEY')}'
+      ) AS "IS_EXISTS"
+    `;
+        return this.format(sql);
+    }
+    addPrimaryKey({ table, columns, }) {
+        const cols = columns
+            .map(col => `\`${col}\``)
+            .join(", ");
+        const sql = `
+      ${this.$constants('ALTER_TABLE')} \`${table}\`
+      ${this.$constants('ADD')} ${this.$constants('PRIMARY_KEY')} (${cols})
+    `;
+        return this.format(sql);
+    }
+    dropPrimaryKey({ table }) {
+        const sql = [
+            this.$constants("ALTER_TABLE"),
+            `\`${table}\``,
+            this.$constants("DROP"),
+            this.$constants("CONSTRAINT"),
+            `\`${table}_pkey\``
         ];
         return this.format(sql);
     }
@@ -524,18 +659,55 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
             const insertRegex = /^INSERT\b/i;
             const deleteRegex = /^DELETE\b/i;
             const truncateRegex = /^TRUNCATE\b/i;
+            if (updateRegex.test(sqlString)) {
+                sqlString = sqlString.replace(/(SET\s+)(.*?)(\s+WHERE)/is, (_, start, setPart, end) => {
+                    const cleaned = setPart.replace(/`[\w$_]+`\./g, '');
+                    return start + cleaned + end;
+                });
+            }
             if (insertRegex.test(sqlString) ||
-                updateRegex.test(sqlString) ||
                 deleteRegex.test(sqlString) ||
                 truncateRegex.test(sqlString)) {
                 return sqlString
-                    .replace(/`[\w_]+`\.`([\w_]+)`/g, "`$1`")
+                    .replace(/`[\w$_]+`\.`([\w$_]+)`/g, "`$1`")
                     .replace(/`([^`]+)`/g, '"$1"');
             }
             return sqlString.replace(/`([^`]+)`/g, '"$1"');
         };
         return replaceBackticksWithDoubleQuotes(formated);
     }
+    getActiveConnections() {
+        const sql = `
+      SELECT 
+        COUNT(*) AS "Connections"
+      FROM 
+       PG_STAT_ACTIVITY
+    `;
+        return this.format(sql);
+    }
+    getMaxConnections() {
+        const sql = `
+    SELECT 
+      setting::int AS "MaxConnections"
+    FROM 
+      PG_SETTINGS
+    WHERE 
+      name = 'max_connections'
+  `;
+        return this.format(sql);
+    }
+    lockTable(mode) {
+        const sql = [
+            "LOCK TABLE",
+            this.$state.get('TABLE_NAME'),
+            mode === 'READ' ? 'IN SHARE MODE' : 'IN ACCESS EXCLUSIVE MODE'
+        ];
+        return this.format(sql);
+    }
+    unlockTable() {
+        // in postgress not have unlock table, unlock when trx COMMIT / ROLLBACK
+        return null;
+    }
     bindJoin(values) {
         if (!Array.isArray(values) || !values.length)
             return null;
@@ -544,9 +716,42 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
     bindWhere(values) {
         if (!Array.isArray(values) || !values.length)
             return null;
-        return `${this.$constants("WHERE")} ${values
-            .map((v) => v.replace(/^\s/, "").replace(/\s+/g, " "))
-            .join(" ")}`;
+        const serializeWhere = (wheres) => {
+            const resolveValue = ({ operator, value }) => {
+                let valueStr = '';
+                if (operator?.toUpperCase() === this.$constants('IN') && Array.isArray(value)) {
+                    valueStr = `(${value.map((v) => v).join(',')})`;
+                }
+                else if (operator?.toUpperCase() === this.$constants('IS_NULL') ||
+                    operator?.toUpperCase() === this.$constants('IS_NOT_NULL')) {
+                    valueStr = '';
+                }
+                else {
+                    valueStr = `${value}`;
+                }
+                return valueStr;
+            };
+            const conditionToSQL = (cond, isFirst = false) => {
+                const { column = '', operator = '', condition, value, nested } = cond;
+                if (nested && nested.length) {
+                    const nestedSQL = nested
+                        .map((c) => conditionToSQL(c))
+                        .join(' ');
+                    const valueStr = resolveValue({ operator, value });
+                    if (!isFirst) {
+                        return `${condition ?? this.$constants('AND')} (${column} ${operator} ${valueStr} ${nestedSQL})`;
+                    }
+                    return `(${column} ${operator} ${valueStr} ${nestedSQL})`;
+                }
+                const valueStr = resolveValue({ operator, value });
+                if (!isFirst) {
+                    return `${condition ?? this.$constants('AND')} ${column} ${operator} ${valueStr}`.trim();
+                }
+                return `${column} ${operator} ${valueStr}`.trim();
+            };
+            return wheres.map((cond, i) => conditionToSQL(cond, !i)).join(' ');
+        };
+        return `${this.$constants("WHERE")} ${serializeWhere(values)}`;
     }
     bindOrderBy(values) {
         if (!Array.isArray(values) || !values.length)
@@ -562,17 +767,20 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
             .map((v) => v.replace(/^\s/, "").replace(/\s+/g, " "))
             .join(", ")}`;
     }
-    bindSelect(values, { distinct } = {}) {
+    bindSelect(values) {
         if (!values.length) {
-            if (!distinct)
-                return `${this.$constants("SELECT")} *`;
-            return `${this.$constants("SELECT")} ${this.$constants("DISTINCT")} *`;
+            return `${this.$constants("SELECT")} *`;
         }
-        const findIndex = values.indexOf("*");
-        if (findIndex > -1) {
-            const removed = values.splice(findIndex, 1);
+        const findIndexStar = values.indexOf("*");
+        if (findIndexStar > -1) {
+            const removed = values.splice(findIndexStar, 1);
             values.unshift(removed[0]);
         }
+        const findIndexDistinct = values.findIndex(v => new RegExp(`^${this.$constants("DISTINCT")}\\s*\\(`, 'i').test(v));
+        if (findIndexDistinct > -1) {
+            const [distinct] = values.splice(findIndexDistinct, 1);
+            values.unshift(distinct);
+        }
         return `${this.$constants("SELECT")} ${values.join(", ")}`;
     }
     bindFrom({ from, alias, rawAlias, }) {
@@ -607,19 +815,29 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
             return "";
         return `${this.$constants("HAVING")} ${having}`;
     }
-    bindRowLevelLock(mode) {
-        if (mode == null)
+    bindRowLevelLock(rowLevelLock) {
+        if (rowLevelLock.mode == null)
             return '';
-        const modeLock = mode === "FOR_UPDATE"
+        let modeLock = rowLevelLock.mode === "FOR_UPDATE"
             ? this.$constants("ROW_LEVEL_LOCK").update
             : this.$constants("ROW_LEVEL_LOCK").share;
+        if (rowLevelLock.skipLocked) {
+            modeLock += ` ${this.$constants("ROW_LEVEL_LOCK").skipLocked}`;
+        }
+        if (rowLevelLock.nowait) {
+            modeLock += ` ${this.$constants("ROW_LEVEL_LOCK").nowait}`;
+        }
         return modeLock;
     }
-    _formatedTypeAndAttributes({ type, attributes, key, }) {
+    _formatedTypeAndAttributes({ table, type, attributes, key, changed }) {
         let formatedType = type;
         let formatedAttributes = attributes;
+        let raws = null;
         if (type.startsWith("INT") && attributes.some((v) => v === "PRIMARY KEY")) {
             formatedType = "SERIAL";
+            if (changed) {
+                formatedType = `INT USING "${key}"::INTEGER`;
+            }
             formatedAttributes = attributes.filter((attr) => {
                 return !attr.startsWith("AUTO_INCREMENT");
             });
@@ -627,7 +845,7 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
         if (type.startsWith("TINYINT")) {
             formatedType = "SMALLINT";
         }
-        if (type.startsWith("LONGTEXT")) {
+        if (type.startsWith("LONGTEXT") || type.startsWith("MEDIUMTEXT")) {
             formatedType = "TEXT";
         }
         if (type.startsWith("ENUM")) {
@@ -639,6 +857,57 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
                 .reduce((sum, item) => sum + item.length, 0);
             formatedType = `VARCHAR(${totalLength}) CHECK (${key} IN ${enums})`;
         }
+        if (changed && type.startsWith("ENUM")) {
+            const enums = type.replace("ENUM", "");
+            const totalLength = enums
+                .slice(1, -1)
+                .split(",")
+                .map((s) => s.replace(/'/g, ""))
+                .reduce((sum, item) => sum + item.length, 0);
+            const enumType = `${[(0, pluralize_1.singular)(String(table ?? '')), key].join('_')}`;
+            raws = `
+          DO $$
+            DECLARE tname text;
+            BEGIN
+
+              SELECT t.TYPNAME
+              INTO tname
+              FROM PG_ATTRIBUTE a
+              JOIN PG_CLASS c ON c.OID = a.ATTRELID
+              JOIN PG_TYPE t ON t.OID = a.ATTTYPID
+              WHERE c.RELNAME = '${table}'
+                AND a.ATTNAME = '${key}'
+                AND a.ATTNUM > 0
+                AND t.TYPTYPE = 'e'
+              LIMIT 1;
+
+              IF tname IS NOT NULL THEN
+
+                ALTER TABLE ${table} 
+                ALTER COLUMN ${key} DROP DEFAULT;
+
+                ALTER TABLE ${table} 
+                ALTER COLUMN ${key} TYPE varchar(${totalLength});
+
+                EXECUTE 'DROP TYPE IF EXISTS ' || quote_ident(tname);
+
+              END IF;
+
+              DROP TYPE IF EXISTS ${enumType};
+              
+              CREATE TYPE ${enumType} AS ENUM ${enums};
+
+              ALTER TABLE ${table}
+              ALTER COLUMN ${key} DROP DEFAULT;
+
+              ALTER TABLE ${table}
+              ALTER COLUMN ${key} TYPE ${enumType}
+              USING ${key}::${enumType};
+
+            END
+          $$
+        `;
+        }
         if (type.startsWith("BOOLEAN")) {
             formatedAttributes = attributes.map((attr) => {
                 if (attr.startsWith("DEFAULT")) {
@@ -650,6 +919,7 @@ class PostgresQueryBuilder extends __1.QueryBuilder {
         return {
             formatedType,
             formatedAttributes,
+            raws
         };
     }
 }