relq 1.0.0

package/dist/cjs/table/alter-table-builder.cjs

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropTableBuilder = exports.AlterTableBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const relq_errors_1 = require("../errors/relq-errors.cjs");
+class AlterTableBuilder {
+    tableName;
+    actions = [];
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    addColumn(name, definition, ifNotExists = false) {
+        const ifNotExistsClause = ifNotExists ? 'IF NOT EXISTS ' : '';
+        if (typeof definition === 'string') {
+            this.actions.push(`ADD COLUMN ${ifNotExistsClause}${pg_format_1.default.ident(name)} ${definition}`);
+        }
+        else {
+            let colDef = pg_format_1.default.ident(name) + ' ' + definition.type;
+            if (definition.generated) {
+                const generatedType = definition.generated.always !== false ? 'ALWAYS' : 'BY DEFAULT';
+                colDef += ` GENERATED ${generatedType} AS (${definition.generated.expression}) STORED`;
+            }
+            else {
+                if (definition.nullable === false)
+                    colDef += ' NOT NULL';
+                if (definition.default !== undefined)
+                    colDef += ` DEFAULT ${(0, pg_format_1.default)('%L', definition.default)}`;
+            }
+            this.actions.push(`ADD COLUMN ${ifNotExistsClause}${colDef}`);
+        }
+        return this;
+    }
+    dropColumn(name, ifExists = false, cascade = false) {
+        const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+        const cascadeClause = cascade ? ' CASCADE' : '';
+        this.actions.push(`DROP COLUMN ${ifExistsClause}${pg_format_1.default.ident(name)}${cascadeClause}`);
+        return this;
+    }
+    renameColumn(oldName, newName) {
+        this.actions.push(`RENAME COLUMN ${pg_format_1.default.ident(oldName)} TO ${pg_format_1.default.ident(newName)}`);
+        return this;
+    }
+    alterColumnType(name, newType, using) {
+        let action = `ALTER COLUMN ${pg_format_1.default.ident(name)} TYPE ${newType}`;
+        if (using)
+            action += ` USING ${using}`;
+        this.actions.push(action);
+        return this;
+    }
+    setColumnDefault(name, defaultValue) {
+        this.actions.push(`ALTER COLUMN ${pg_format_1.default.ident(name)} SET DEFAULT ${(0, pg_format_1.default)('%L', defaultValue)}`);
+        return this;
+    }
+    dropColumnDefault(name) {
+        this.actions.push(`ALTER COLUMN ${pg_format_1.default.ident(name)} DROP DEFAULT`);
+        return this;
+    }
+    setColumnNotNull(name) {
+        this.actions.push(`ALTER COLUMN ${pg_format_1.default.ident(name)} SET NOT NULL`);
+        return this;
+    }
+    dropColumnNotNull(name) {
+        this.actions.push(`ALTER COLUMN ${pg_format_1.default.ident(name)} DROP NOT NULL`);
+        return this;
+    }
+    addConstraint(name, constraint) {
+        this.actions.push(`ADD CONSTRAINT ${pg_format_1.default.ident(name)} ${constraint}`);
+        return this;
+    }
+    dropConstraint(name, ifExists = false, cascade = false) {
+        const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+        const cascadeClause = cascade ? ' CASCADE' : '';
+        this.actions.push(`DROP CONSTRAINT ${ifExistsClause}${pg_format_1.default.ident(name)}${cascadeClause}`);
+        return this;
+    }
+    renameTo(newName) {
+        this.actions.push(`RENAME TO ${pg_format_1.default.ident(newName)}`);
+        return this;
+    }
+    setSchema(schemaName) {
+        this.actions.push(`SET SCHEMA ${pg_format_1.default.ident(schemaName)}`);
+        return this;
+    }
+    setTablespace(tablespaceName) {
+        this.actions.push(`SET TABLESPACE ${pg_format_1.default.ident(tablespaceName)}`);
+        return this;
+    }
+    enableTrigger(triggerName) {
+        this.actions.push(`ENABLE TRIGGER ${pg_format_1.default.ident(triggerName)}`);
+        return this;
+    }
+    disableTrigger(triggerName) {
+        this.actions.push(`DISABLE TRIGGER ${pg_format_1.default.ident(triggerName)}`);
+        return this;
+    }
+    enableAllTriggers() {
+        this.actions.push('ENABLE TRIGGER ALL');
+        return this;
+    }
+    disableAllTriggers() {
+        this.actions.push('DISABLE TRIGGER ALL');
+        return this;
+    }
+    toString() {
+        if (this.actions.length === 0) {
+            throw new relq_errors_1.RelqBuilderError('No ALTER TABLE actions specified', { builder: 'AlterTableBuilder', missing: 'actions', hint: 'Use addColumn(), dropColumn(), or other methods' });
+        }
+        return `ALTER TABLE ${pg_format_1.default.ident(this.tableName)} ${this.actions.join(', ')}`;
+    }
+}
+exports.AlterTableBuilder = AlterTableBuilder;
+class DropTableBuilder {
+    tableName;
+    ifExistsFlag = false;
+    cascadeFlag = false;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    ifExists() {
+        this.ifExistsFlag = true;
+        return this;
+    }
+    cascade() {
+        this.cascadeFlag = true;
+        return this;
+    }
+    restrict() {
+        this.cascadeFlag = false;
+        return this;
+    }
+    toString() {
+        let sql = 'DROP TABLE';
+        if (this.ifExistsFlag) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${pg_format_1.default.ident(this.tableName)}`;
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+}
+exports.DropTableBuilder = DropTableBuilder;

package/dist/cjs/table/constraint-builder.cjs

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstraintBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+class ConstraintBuilder {
+    constraints = [];
+    addPrimaryKey(columns, name) {
+        this.constraints.push({
+            type: 'PRIMARY KEY',
+            name,
+            columns
+        });
+        return this;
+    }
+    addForeignKey(config) {
+        this.constraints.push({
+            type: 'FOREIGN KEY',
+            name: config.name,
+            columns: config.columns,
+            references: config.references,
+            onDelete: config.onDelete,
+            onUpdate: config.onUpdate,
+            deferrable: config.deferrable,
+            initially: config.initially
+        });
+        return this;
+    }
+    addUnique(columns, name) {
+        this.constraints.push({
+            type: 'UNIQUE',
+            name,
+            columns
+        });
+        return this;
+    }
+    addCheck(condition, name) {
+        this.constraints.push({
+            type: 'CHECK',
+            name,
+            definition: condition
+        });
+        return this;
+    }
+    addExclusion(constraint, using = 'GIST', name) {
+        this.constraints.push({
+            type: 'EXCLUSION',
+            name,
+            definition: constraint,
+            using
+        });
+        return this;
+    }
+    getConstraints() {
+        return this.constraints;
+    }
+    static buildConstraintSQL(constraint) {
+        let sql = '';
+        if (constraint.name) {
+            sql += `CONSTRAINT ${pg_format_1.default.ident(constraint.name)} `;
+        }
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                sql += `PRIMARY KEY (${constraint.columns.map(c => pg_format_1.default.ident(c)).join(', ')})`;
+                break;
+            case 'FOREIGN KEY': {
+                const cols = constraint.columns.map(c => pg_format_1.default.ident(c)).join(', ');
+                const refCols = constraint.references.columns.map(c => pg_format_1.default.ident(c)).join(', ');
+                sql += `FOREIGN KEY (${cols}) REFERENCES ${pg_format_1.default.ident(constraint.references.table)} (${refCols})`;
+                if (constraint.onDelete) {
+                    sql += ` ON DELETE ${constraint.onDelete}`;
+                }
+                if (constraint.onUpdate) {
+                    sql += ` ON UPDATE ${constraint.onUpdate}`;
+                }
+                if (constraint.deferrable) {
+                    sql += ' DEFERRABLE';
+                    if (constraint.initially) {
+                        sql += ` INITIALLY ${constraint.initially}`;
+                    }
+                }
+                break;
+            }
+            case 'UNIQUE':
+                sql += `UNIQUE (${constraint.columns.map(c => pg_format_1.default.ident(c)).join(', ')})`;
+                break;
+            case 'CHECK':
+                sql += `CHECK (${constraint.definition})`;
+                break;
+            case 'EXCLUSION':
+                sql += `EXCLUDE USING ${constraint.using} (${constraint.definition})`;
+                break;
+        }
+        return sql;
+    }
+    buildAllConstraintsSQL() {
+        return this.constraints.map(c => ConstraintBuilder.buildConstraintSQL(c));
+    }
+}
+exports.ConstraintBuilder = ConstraintBuilder;

package/dist/cjs/table/create-table-builder.cjs

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTableBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const constraint_builder_1 = require("./constraint-builder.cjs");
+const partition_builder_1 = require("./partition-builder.cjs");
+const create_index_builder_1 = require("../indexing/create-index-builder.cjs");
+const relq_errors_1 = require("../errors/relq-errors.cjs");
+class CreateTableBuilder {
+    tableName;
+    columns = new Map();
+    constraintBuilder = new constraint_builder_1.ConstraintBuilder();
+    partitionBuilder;
+    indexes = [];
+    inheritsFrom = [];
+    withOptions = {};
+    tablespaceValue;
+    ifNotExistsFlag = false;
+    temporaryFlag = false;
+    unloggedFlag = false;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    setColumns(columns) {
+        Object.entries(columns).forEach(([name, def]) => {
+            this.columns.set(name, def);
+        });
+        return this;
+    }
+    addColumn(name, definition) {
+        this.columns.set(name, definition);
+        return this;
+    }
+    addPrimaryKey(columns, name) {
+        this.constraintBuilder.addPrimaryKey(columns, name);
+        return this;
+    }
+    addForeignKey(config) {
+        this.constraintBuilder.addForeignKey(config);
+        return this;
+    }
+    addUnique(columns, name) {
+        this.constraintBuilder.addUnique(columns, name);
+        return this;
+    }
+    addCheck(condition, name) {
+        this.constraintBuilder.addCheck(condition, name);
+        return this;
+    }
+    addExclusion(constraint, using, name) {
+        this.constraintBuilder.addExclusion(constraint, using, name);
+        return this;
+    }
+    addIndex(name, callback) {
+        const indexBuilder = new create_index_builder_1.CreateIndexBuilder(this.tableName, name);
+        callback(indexBuilder);
+        this.indexes.push({ name, builder: indexBuilder });
+        return this;
+    }
+    partitionBy(strategy, columns) {
+        this.partitionBuilder = new partition_builder_1.PartitionBuilder();
+        const cols = Array.isArray(columns) ? columns : [columns];
+        if (strategy === 'RANGE') {
+            this.partitionBuilder.range(...cols);
+        }
+        else if (strategy === 'LIST') {
+            this.partitionBuilder.list(cols[0]);
+        }
+        else {
+            this.partitionBuilder.hash(cols[0]);
+        }
+        return this;
+    }
+    inherits(...parentTables) {
+        this.inheritsFrom.push(...parentTables);
+        return this;
+    }
+    with(options) {
+        this.withOptions = { ...this.withOptions, ...options };
+        return this;
+    }
+    tablespace(name) {
+        this.tablespaceValue = name;
+        return this;
+    }
+    ifNotExists() {
+        this.ifNotExistsFlag = true;
+        return this;
+    }
+    temporary() {
+        this.temporaryFlag = true;
+        return this;
+    }
+    unlogged() {
+        this.unloggedFlag = true;
+        return this;
+    }
+    fillfactor(percent) {
+        this.withOptions.fillfactor = percent;
+        return this;
+    }
+    parallelWorkers(count) {
+        this.withOptions.parallel_workers = count;
+        return this;
+    }
+    autovacuum(enabled, options) {
+        this.withOptions.autovacuum_enabled = enabled;
+        if (options) {
+            if (options.vacuumThreshold !== undefined) {
+                this.withOptions.autovacuum_vacuum_threshold = options.vacuumThreshold;
+            }
+            if (options.analyzeThreshold !== undefined) {
+                this.withOptions.autovacuum_analyze_threshold = options.analyzeThreshold;
+            }
+            if (options.vacuumScaleFactor !== undefined) {
+                this.withOptions.autovacuum_vacuum_scale_factor = options.vacuumScaleFactor;
+            }
+            if (options.analyzeScaleFactor !== undefined) {
+                this.withOptions.autovacuum_analyze_scale_factor = options.analyzeScaleFactor;
+            }
+        }
+        return this;
+    }
+    buildColumnSQL(name, def) {
+        if (typeof def === 'string') {
+            return `${pg_format_1.default.ident(name)} ${def}`;
+        }
+        let sql = pg_format_1.default.ident(name);
+        sql += ` ${def.type}`;
+        if (def.collation) {
+            sql += ` COLLATE ${pg_format_1.default.ident(def.collation)}`;
+        }
+        if (def.nullable === false) {
+            sql += ' NOT NULL';
+        }
+        else if (def.nullable === true) {
+            sql += ' NULL';
+        }
+        if (def.default !== undefined) {
+            if (typeof def.default === 'string' &&
+                (def.default.toUpperCase().includes('NOW()') ||
+                    def.default.toUpperCase().includes('CURRENT_'))) {
+                sql += ` DEFAULT ${def.default}`;
+            }
+            else {
+                sql += ` DEFAULT ${(0, pg_format_1.default)('%L', def.default)}`;
+            }
+        }
+        if (def.generated) {
+            sql += def.generated.always ? ' GENERATED ALWAYS' : ' GENERATED BY DEFAULT';
+            sql += ` AS (${def.generated.expression}) STORED`;
+        }
+        if (def.identity) {
+            sql += def.identity.always ? ' GENERATED ALWAYS AS IDENTITY' : ' GENERATED BY DEFAULT AS IDENTITY';
+            const identityOpts = [];
+            if (def.identity.start !== undefined)
+                identityOpts.push(`START WITH ${def.identity.start}`);
+            if (def.identity.increment !== undefined)
+                identityOpts.push(`INCREMENT BY ${def.identity.increment}`);
+            if (def.identity.minValue !== undefined)
+                identityOpts.push(`MINVALUE ${def.identity.minValue}`);
+            if (def.identity.maxValue !== undefined)
+                identityOpts.push(`MAXVALUE ${def.identity.maxValue}`);
+            if (def.identity.cycle)
+                identityOpts.push('CYCLE');
+            if (identityOpts.length > 0) {
+                sql += ` (${identityOpts.join(' ')})`;
+            }
+        }
+        if (def.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        if (def.unique) {
+            sql += ' UNIQUE';
+        }
+        if (def.check) {
+            sql += ` CHECK (${def.check})`;
+        }
+        if (def.references) {
+            sql += ` REFERENCES ${pg_format_1.default.ident(def.references.table)}(${pg_format_1.default.ident(def.references.column)})`;
+            if (def.references.onDelete) {
+                sql += ` ON DELETE ${def.references.onDelete}`;
+            }
+            if (def.references.onUpdate) {
+                sql += ` ON UPDATE ${def.references.onUpdate}`;
+            }
+        }
+        if (def.storage) {
+            sql += ` STORAGE ${def.storage}`;
+        }
+        if (def.compression) {
+            sql += ` COMPRESSION ${def.compression}`;
+        }
+        return sql;
+    }
+    toString() {
+        if (this.columns.size === 0) {
+            throw new relq_errors_1.RelqBuilderError('Table must have at least one column', { builder: 'CreateTableBuilder', missing: 'columns', hint: 'Use .setColumns() or .addColumn()' });
+        }
+        let sql = 'CREATE';
+        if (this.temporaryFlag) {
+            sql += ' TEMPORARY';
+        }
+        if (this.unloggedFlag) {
+            sql += ' UNLOGGED';
+        }
+        sql += ' TABLE';
+        if (this.ifNotExistsFlag) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${pg_format_1.default.ident(this.tableName)}`;
+        const columnDefs = [];
+        this.columns.forEach((def, name) => {
+            columnDefs.push(this.buildColumnSQL(name, def));
+        });
+        const constraints = this.constraintBuilder.buildAllConstraintsSQL();
+        sql += ` (${[...columnDefs, ...constraints].join(', ')})`;
+        if (this.inheritsFrom.length > 0) {
+            sql += ` INHERITS (${this.inheritsFrom.map(t => pg_format_1.default.ident(t)).join(', ')})`;
+        }
+        if (this.partitionBuilder) {
+            sql += this.partitionBuilder.buildPartitionBySQL();
+        }
+        if (Object.keys(this.withOptions).length > 0) {
+            const options = Object.entries(this.withOptions)
+                .map(([key, value]) => `${key} = ${typeof value === 'boolean' ? (value ? 'on' : 'off') : value}`)
+                .join(', ');
+            sql += ` WITH (${options})`;
+        }
+        if (this.tablespaceValue) {
+            sql += ` TABLESPACE ${pg_format_1.default.ident(this.tablespaceValue)}`;
+        }
+        return sql;
+    }
+    getIndexSQL() {
+        return this.indexes.map(({ builder }) => builder.toString());
+    }
+    toFullSQL() {
+        return {
+            table: this.toString(),
+            indexes: this.getIndexSQL()
+        };
+    }
+}
+exports.CreateTableBuilder = CreateTableBuilder;

package/dist/cjs/table/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TruncateBuilder = exports.DetachPartitionBuilder = exports.AttachPartitionBuilder = exports.CreatePartitionBuilder = exports.PartitionBuilder = exports.ConstraintBuilder = exports.DropTableBuilder = exports.AlterTableBuilder = exports.CreateTableBuilder = void 0;
+var create_table_builder_1 = require("./create-table-builder.cjs");
+Object.defineProperty(exports, "CreateTableBuilder", { enumerable: true, get: function () { return create_table_builder_1.CreateTableBuilder; } });
+var alter_table_builder_1 = require("./alter-table-builder.cjs");
+Object.defineProperty(exports, "AlterTableBuilder", { enumerable: true, get: function () { return alter_table_builder_1.AlterTableBuilder; } });
+Object.defineProperty(exports, "DropTableBuilder", { enumerable: true, get: function () { return alter_table_builder_1.DropTableBuilder; } });
+var constraint_builder_1 = require("./constraint-builder.cjs");
+Object.defineProperty(exports, "ConstraintBuilder", { enumerable: true, get: function () { return constraint_builder_1.ConstraintBuilder; } });
+var partition_builder_1 = require("./partition-builder.cjs");
+Object.defineProperty(exports, "PartitionBuilder", { enumerable: true, get: function () { return partition_builder_1.PartitionBuilder; } });
+Object.defineProperty(exports, "CreatePartitionBuilder", { enumerable: true, get: function () { return partition_builder_1.CreatePartitionBuilder; } });
+Object.defineProperty(exports, "AttachPartitionBuilder", { enumerable: true, get: function () { return partition_builder_1.AttachPartitionBuilder; } });
+Object.defineProperty(exports, "DetachPartitionBuilder", { enumerable: true, get: function () { return partition_builder_1.DetachPartitionBuilder; } });
+var truncate_builder_1 = require("./truncate-builder.cjs");
+Object.defineProperty(exports, "TruncateBuilder", { enumerable: true, get: function () { return truncate_builder_1.TruncateBuilder; } });

package/dist/cjs/table/partition-builder.cjs

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetachPartitionBuilder = exports.AttachPartitionBuilder = exports.CreatePartitionBuilder = exports.PartitionBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+class PartitionBuilder {
+    strategy;
+    columns = [];
+    range(...columns) {
+        this.strategy = 'RANGE';
+        this.columns = columns;
+        return this;
+    }
+    list(column) {
+        this.strategy = 'LIST';
+        this.columns = [column];
+        return this;
+    }
+    hash(column) {
+        this.strategy = 'HASH';
+        this.columns = [column];
+        return this;
+    }
+    getStrategy() {
+        return this.strategy;
+    }
+    getColumns() {
+        return this.columns;
+    }
+    buildPartitionBySQL() {
+        if (!this.strategy || this.columns.length === 0) {
+            return '';
+        }
+        const cols = this.columns.map(c => pg_format_1.default.ident(c)).join(', ');
+        return ` PARTITION BY ${this.strategy} (${cols})`;
+    }
+}
+exports.PartitionBuilder = PartitionBuilder;
+class CreatePartitionBuilder {
+    partitionName;
+    parentTable;
+    forValuesClause;
+    tablespaceValue;
+    withOptions;
+    constructor(partitionName, parentTable) {
+        this.partitionName = partitionName;
+        this.parentTable = parentTable;
+    }
+    forValues(specification) {
+        this.forValuesClause = specification;
+        return this;
+    }
+    tablespace(name) {
+        this.tablespaceValue = name;
+        return this;
+    }
+    with(options) {
+        this.withOptions = options;
+        return this;
+    }
+    toString() {
+        let sql = (0, pg_format_1.default)('CREATE TABLE %I PARTITION OF %I', this.partitionName, this.parentTable);
+        if (this.forValuesClause) {
+            sql += ` FOR VALUES ${this.forValuesClause}`;
+        }
+        if (this.withOptions && Object.keys(this.withOptions).length > 0) {
+            const options = Object.entries(this.withOptions)
+                .map(([key, value]) => `${key} = ${value}`)
+                .join(', ');
+            sql += ` WITH (${options})`;
+        }
+        if (this.tablespaceValue) {
+            sql += ` TABLESPACE ${pg_format_1.default.ident(this.tablespaceValue)}`;
+        }
+        return sql;
+    }
+}
+exports.CreatePartitionBuilder = CreatePartitionBuilder;
+class AttachPartitionBuilder {
+    parentTable;
+    partitionName;
+    forValuesClause;
+    concurrentFlag = false;
+    constructor(parentTable, partitionName) {
+        this.parentTable = parentTable;
+        this.partitionName = partitionName;
+    }
+    forValues(specification) {
+        this.forValuesClause = specification;
+        return this;
+    }
+    toString() {
+        let sql = (0, pg_format_1.default)('ALTER TABLE %I ATTACH PARTITION %I', this.parentTable, this.partitionName);
+        if (this.forValuesClause) {
+            sql += ` FOR VALUES ${this.forValuesClause}`;
+        }
+        return sql;
+    }
+}
+exports.AttachPartitionBuilder = AttachPartitionBuilder;
+class DetachPartitionBuilder {
+    parentTable;
+    partitionName;
+    concurrentFlag = false;
+    finalizeFlag = false;
+    constructor(parentTable, partitionName) {
+        this.parentTable = parentTable;
+        this.partitionName = partitionName;
+    }
+    concurrently() {
+        this.concurrentFlag = true;
+        return this;
+    }
+    finalize() {
+        this.finalizeFlag = true;
+        return this;
+    }
+    toString() {
+        let sql = (0, pg_format_1.default)('ALTER TABLE %I DETACH PARTITION %I', this.parentTable, this.partitionName);
+        if (this.concurrentFlag) {
+            sql += ' CONCURRENTLY';
+        }
+        if (this.finalizeFlag) {
+            sql += ' FINALIZE';
+        }
+        return sql;
+    }
+}
+exports.DetachPartitionBuilder = DetachPartitionBuilder;