Initial commit - Event Planner application
This commit is contained in:
mberlin
776
node_modules/@mikro-orm/sql/dialects/postgresql/PostgreSqlSchemaHelper.js
generated
vendored
Normal file
776
node_modules/@mikro-orm/sql/dialects/postgresql/PostgreSqlSchemaHelper.js
generated
vendored
Normal file
@@ -0,0 +1,776 @@
|
||||
import { DeferMode, EnumType, Type, Utils } from '@mikro-orm/core';
|
||||
import { SchemaHelper } from '../../schema/SchemaHelper.js';
|
||||
/** PostGIS system views that should be automatically ignored */
|
||||
const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
|
||||
export class PostgreSqlSchemaHelper extends SchemaHelper {
|
||||
static DEFAULT_VALUES = {
|
||||
'now()': ['now()', 'current_timestamp'],
|
||||
'current_timestamp(?)': ['current_timestamp(?)'],
|
||||
"('now'::text)::timestamp(?) with time zone": ['current_timestamp(?)'],
|
||||
"('now'::text)::timestamp(?) without time zone": ['current_timestamp(?)'],
|
||||
'null::character varying': ['null'],
|
||||
'null::timestamp with time zone': ['null'],
|
||||
'null::timestamp without time zone': ['null'],
|
||||
};
|
||||
getSchemaBeginning(charset, disableForeignKeys) {
|
||||
if (disableForeignKeys) {
|
||||
return `set names '${charset}';\n${this.disableForeignKeysSQL()}\n\n`;
|
||||
}
|
||||
return `set names '${charset}';\n\n`;
|
||||
}
|
||||
getCreateDatabaseSQL(name) {
|
||||
return `create database ${this.quote(name)}`;
|
||||
}
|
||||
getListTablesSQL() {
|
||||
return (
|
||||
`select table_name, table_schema as schema_name, ` +
|
||||
`(select pg_catalog.obj_description(c.oid) from pg_catalog.pg_class c
|
||||
where c.oid = (select ('"' || table_schema || '"."' || table_name || '"')::regclass::oid) and c.relname = table_name) as table_comment ` +
|
||||
`from information_schema.tables ` +
|
||||
`where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
|
||||
`and table_name != 'geometry_columns' and table_name != 'spatial_ref_sys' and table_type != 'VIEW' ` +
|
||||
`and table_name not in (select inhrelid::regclass::text from pg_inherits) ` +
|
||||
`order by table_name`
|
||||
);
|
||||
}
|
||||
getIgnoredViewsCondition() {
|
||||
return POSTGIS_VIEWS.map(v => `table_name != '${v}'`).join(' and ');
|
||||
}
|
||||
getListViewsSQL() {
|
||||
return (
|
||||
`select table_name as view_name, table_schema as schema_name, view_definition ` +
|
||||
`from information_schema.views ` +
|
||||
`where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
|
||||
`and ${this.getIgnoredViewsCondition()} ` +
|
||||
`order by table_name`
|
||||
);
|
||||
}
|
||||
async loadViews(schema, connection) {
|
||||
const views = await connection.execute(this.getListViewsSQL());
|
||||
for (const view of views) {
|
||||
const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
|
||||
if (definition) {
|
||||
schema.addView(view.view_name, view.schema_name, definition);
|
||||
}
|
||||
}
|
||||
}
|
||||
getListMaterializedViewsSQL() {
|
||||
return (
|
||||
`select matviewname as view_name, schemaname as schema_name, definition as view_definition ` +
|
||||
`from pg_matviews ` +
|
||||
`where ${this.getIgnoredNamespacesConditionSQL('schemaname')} ` +
|
||||
`order by matviewname`
|
||||
);
|
||||
}
|
||||
async loadMaterializedViews(schema, connection, schemaName) {
|
||||
const views = await connection.execute(this.getListMaterializedViewsSQL());
|
||||
for (const view of views) {
|
||||
const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
|
||||
if (definition) {
|
||||
schema.addView(view.view_name, view.schema_name, definition, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
createMaterializedView(name, schema, definition, withData = true) {
|
||||
const viewName = this.quote(this.getTableName(name, schema));
|
||||
const dataClause = withData ? ' with data' : ' with no data';
|
||||
return `create materialized view ${viewName} as ${definition}${dataClause}`;
|
||||
}
|
||||
dropMaterializedViewIfExists(name, schema) {
|
||||
return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
|
||||
}
|
||||
refreshMaterializedView(name, schema, concurrently = false) {
|
||||
const concurrent = concurrently ? ' concurrently' : '';
|
||||
return `refresh materialized view${concurrent} ${this.quote(this.getTableName(name, schema))}`;
|
||||
}
|
||||
async getNamespaces(connection) {
|
||||
const sql =
|
||||
`select schema_name from information_schema.schemata ` +
|
||||
`where ${this.getIgnoredNamespacesConditionSQL()} ` +
|
||||
`order by schema_name`;
|
||||
const res = await connection.execute(sql);
|
||||
return res.map(row => row.schema_name);
|
||||
}
|
||||
getIgnoredNamespacesConditionSQL(column = 'schema_name') {
|
||||
const ignored = [
|
||||
'information_schema',
|
||||
'tiger',
|
||||
'topology',
|
||||
/* v8 ignore next */
|
||||
...(this.platform.getConfig().get('schemaGenerator').ignoreSchema ?? []),
|
||||
]
|
||||
.map(s => this.platform.quoteValue(s))
|
||||
.join(', ');
|
||||
const ignoredPrefixes = ['pg_', 'crdb_', '_timescaledb_'].map(p => `"${column}" not like '${p}%'`).join(' and ');
|
||||
return `${ignoredPrefixes} and "${column}" not in (${ignored})`;
|
||||
}
|
||||
async loadInformationSchema(schema, connection, tables, schemas) {
|
||||
schemas ??= tables.length === 0 ? [schema.name] : tables.map(t => t.schema_name);
|
||||
const nativeEnums = await this.getNativeEnumDefinitions(connection, schemas);
|
||||
schema.setNativeEnums(nativeEnums);
|
||||
if (tables.length === 0) {
|
||||
return;
|
||||
}
|
||||
const tablesBySchema = this.getTablesGroupedBySchemas(tables);
|
||||
const columns = await this.getAllColumns(connection, tablesBySchema, nativeEnums);
|
||||
const indexes = await this.getAllIndexes(connection, tables);
|
||||
const checks = await this.getAllChecks(connection, tablesBySchema);
|
||||
const fks = await this.getAllForeignKeys(connection, tablesBySchema);
|
||||
for (const t of tables) {
|
||||
const key = this.getTableKey(t);
|
||||
const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
|
||||
const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
|
||||
const enums = this.getEnumDefinitions(checks[key] ?? []);
|
||||
if (columns[key]) {
|
||||
table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
|
||||
}
|
||||
}
|
||||
}
|
||||
async getAllIndexes(connection, tables) {
|
||||
const sql = this.getIndexesSQL(tables);
|
||||
const unquote = str => str.replace(/['"`]/g, '');
|
||||
const allIndexes = await connection.execute(sql);
|
||||
const ret = {};
|
||||
for (const index of allIndexes) {
|
||||
const key = this.getTableKey(index);
|
||||
// Extract INCLUDE columns from expression first, to filter them from key columns
|
||||
const includeMatch = index.expression?.match(/include\s*\(([^)]+)\)/i);
|
||||
const includeColumns = includeMatch ? includeMatch[1].split(',').map(col => unquote(col.trim())) : [];
|
||||
// Filter out INCLUDE columns from the column definitions to get only key columns
|
||||
const keyColumnDefs = index.index_def.filter(col => !includeColumns.includes(unquote(col)));
|
||||
// Parse sort order and NULLS ordering from the full expression
|
||||
// pg_get_indexdef individual columns don't include sort modifiers, so we parse from full expression
|
||||
const columns = this.parseIndexColumnsFromExpression(index.expression, keyColumnDefs, unquote);
|
||||
const columnNames = columns.map(col => col.name);
|
||||
const hasAdvancedColumnOptions = columns.some(col => col.sort || col.nulls || col.collation);
|
||||
const indexDef = {
|
||||
columnNames,
|
||||
composite: columnNames.length > 1,
|
||||
// JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
|
||||
constraint: index.contype === 'u',
|
||||
keyName: index.constraint_name,
|
||||
unique: index.unique,
|
||||
primary: index.primary,
|
||||
};
|
||||
// Add columns array if there are advanced options
|
||||
if (hasAdvancedColumnOptions) {
|
||||
indexDef.columns = columns;
|
||||
}
|
||||
if (index.condeferrable) {
|
||||
indexDef.deferMode = index.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
|
||||
}
|
||||
if (index.index_def.some(col => /[(): ,"'`]/.exec(col)) || index.expression?.match(/ where /i)) {
|
||||
indexDef.expression = index.expression;
|
||||
}
|
||||
if (index.deferrable) {
|
||||
indexDef.deferMode = index.initially_deferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
|
||||
}
|
||||
// Extract fillFactor from reloptions
|
||||
if (index.reloptions) {
|
||||
const fillFactorMatch = index.reloptions.find(opt => opt.startsWith('fillfactor='));
|
||||
if (fillFactorMatch) {
|
||||
indexDef.fillFactor = parseInt(fillFactorMatch.split('=')[1], 10);
|
||||
}
|
||||
}
|
||||
// Add INCLUDE columns (already extracted above)
|
||||
if (includeColumns.length > 0) {
|
||||
indexDef.include = includeColumns;
|
||||
}
|
||||
// Add index type if not btree (the default)
|
||||
if (index.index_type && index.index_type !== 'btree') {
|
||||
indexDef.type = index.index_type;
|
||||
}
|
||||
ret[key] ??= [];
|
||||
ret[key].push(indexDef);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
/**
|
||||
* Parses column definitions from the full CREATE INDEX expression.
|
||||
* Since pg_get_indexdef(oid, col_num, true) doesn't include sort modifiers,
|
||||
* we extract them from the full expression instead.
|
||||
*
|
||||
* We use columnDefs (from individual pg_get_indexdef calls) as the source
|
||||
* of column names, and find their modifiers in the expression.
|
||||
*/
|
||||
parseIndexColumnsFromExpression(expression, columnDefs, unquote) {
|
||||
// Extract just the column list from the expression (between first parens after USING)
|
||||
// Pattern: ... USING method (...columns...) [INCLUDE (...)] [WHERE ...]
|
||||
// Note: pg_get_indexdef always returns a valid expression with USING clause
|
||||
const usingMatch = /using\s+\w+\s*\(/i.exec(expression);
|
||||
const startIdx = usingMatch.index + usingMatch[0].length - 1; // Position of opening (
|
||||
const columnsStr = this.extractParenthesizedContent(expression, startIdx);
|
||||
// Use the column names from columnDefs and find their modifiers in the expression
|
||||
return columnDefs.map(colDef => {
|
||||
const name = unquote(colDef);
|
||||
const result = { name };
|
||||
// Find this column in the expression and extract modifiers
|
||||
// Create a pattern that matches the column name (quoted or unquoted) followed by modifiers
|
||||
const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||||
const colPattern = new RegExp(`"?${escapedName}"?\\s*([^,)]*?)(?:,|$)`, 'i');
|
||||
const colMatch = columnsStr.match(colPattern);
|
||||
if (colMatch) {
|
||||
const modifiers = colMatch[1];
|
||||
// Extract sort order (PostgreSQL omits ASC in output as it's the default)
|
||||
if (/\bdesc\b/i.test(modifiers)) {
|
||||
result.sort = 'DESC';
|
||||
}
|
||||
// Extract NULLS ordering
|
||||
const nullsMatch = /nulls\s+(first|last)/i.exec(modifiers);
|
||||
if (nullsMatch) {
|
||||
result.nulls = nullsMatch[1].toUpperCase();
|
||||
}
|
||||
// Extract collation
|
||||
const collateMatch = /collate\s+"?([^"\s,)]+)"?/i.exec(modifiers);
|
||||
if (collateMatch) {
|
||||
result.collation = collateMatch[1];
|
||||
}
|
||||
}
|
||||
return result;
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Extracts the content inside parentheses starting at the given position.
|
||||
* Handles nested parentheses correctly.
|
||||
*/
|
||||
extractParenthesizedContent(str, startIdx) {
|
||||
let depth = 0;
|
||||
const start = startIdx + 1;
|
||||
for (let i = startIdx; i < str.length; i++) {
|
||||
if (str[i] === '(') {
|
||||
depth++;
|
||||
} else if (str[i] === ')') {
|
||||
depth--;
|
||||
if (depth === 0) {
|
||||
return str.slice(start, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* v8 ignore next - pg_get_indexdef always returns balanced parentheses */
|
||||
return '';
|
||||
}
|
||||
async getAllColumns(connection, tablesBySchemas, nativeEnums) {
|
||||
const sql = `select table_schema as schema_name, table_name, column_name,
|
||||
column_default,
|
||||
is_nullable,
|
||||
udt_name,
|
||||
udt_schema,
|
||||
coalesce(datetime_precision, character_maximum_length) length,
|
||||
atttypmod custom_length,
|
||||
numeric_precision,
|
||||
numeric_scale,
|
||||
data_type,
|
||||
is_identity,
|
||||
identity_generation,
|
||||
generation_expression,
|
||||
pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment
|
||||
from information_schema.columns cols
|
||||
join pg_class pgc on cols.table_name = pgc.relname
|
||||
join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
|
||||
where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
|
||||
order by ordinal_position`;
|
||||
const allColumns = await connection.execute(sql);
|
||||
const str = val => (val != null ? '' + val : val);
|
||||
const ret = {};
|
||||
for (const col of allColumns) {
|
||||
const mappedType = connection.getPlatform().getMappedType(col.data_type);
|
||||
const increments =
|
||||
(col.column_default?.includes('nextval') || col.is_identity === 'YES') &&
|
||||
connection.getPlatform().isNumericColumn(mappedType);
|
||||
const key = this.getTableKey(col);
|
||||
ret[key] ??= [];
|
||||
let type = col.data_type.toLowerCase() === 'array' ? col.udt_name.replace(/^_(.*)$/, '$1[]') : col.udt_name;
|
||||
if (
|
||||
col.data_type === 'USER-DEFINED' &&
|
||||
col.udt_schema &&
|
||||
col.udt_schema !== this.platform.getDefaultSchemaName()
|
||||
) {
|
||||
type = `${col.udt_schema}.${type}`;
|
||||
}
|
||||
if (type === 'bpchar') {
|
||||
type = 'char';
|
||||
}
|
||||
if (type === 'vector' && col.length == null && col.custom_length != null && col.custom_length !== -1) {
|
||||
col.length = col.custom_length;
|
||||
}
|
||||
if (col.length != null && !type.endsWith(`(${col.length})`) && !['text', 'date'].includes(type)) {
|
||||
type += `(${col.length})`;
|
||||
}
|
||||
if (type === 'numeric' && col.numeric_precision != null && col.numeric_scale != null) {
|
||||
type += `(${col.numeric_precision},${col.numeric_scale})`;
|
||||
}
|
||||
const length = this.inferLengthFromColumnType(type) === -1 ? -1 : col.length;
|
||||
const column = {
|
||||
name: col.column_name,
|
||||
type,
|
||||
mappedType,
|
||||
length,
|
||||
precision: col.numeric_precision,
|
||||
scale: col.numeric_scale,
|
||||
nullable: col.is_nullable === 'YES',
|
||||
default: str(this.normalizeDefaultValue(col.column_default, col.length)),
|
||||
unsigned: increments,
|
||||
autoincrement: increments,
|
||||
generated:
|
||||
col.is_identity === 'YES'
|
||||
? col.identity_generation === 'BY DEFAULT'
|
||||
? 'by default as identity'
|
||||
: 'identity'
|
||||
: col.generation_expression
|
||||
? col.generation_expression + ' stored'
|
||||
: undefined,
|
||||
comment: col.column_comment,
|
||||
};
|
||||
if (nativeEnums?.[column.type]) {
|
||||
column.mappedType = Type.getType(EnumType);
|
||||
column.nativeEnumName = column.type;
|
||||
column.enumItems = nativeEnums[column.type]?.items;
|
||||
}
|
||||
ret[key].push(column);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
async getAllChecks(connection, tablesBySchemas) {
|
||||
const sql = this.getChecksSQL(tablesBySchemas);
|
||||
const allChecks = await connection.execute(sql);
|
||||
const ret = {};
|
||||
const seen = new Set();
|
||||
for (const check of allChecks) {
|
||||
const key = this.getTableKey(check);
|
||||
const dedupeKey = `${key}:${check.name}`;
|
||||
if (seen.has(dedupeKey)) {
|
||||
continue;
|
||||
}
|
||||
seen.add(dedupeKey);
|
||||
ret[key] ??= [];
|
||||
const m = /^check \(\((.*)\)\)$/is.exec(check.expression);
|
||||
const def = m?.[1].replace(/\((.*?)\)::\w+/g, '$1');
|
||||
ret[key].push({
|
||||
name: check.name,
|
||||
columnName: check.column_name,
|
||||
definition: check.expression,
|
||||
expression: def,
|
||||
});
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
async getAllForeignKeys(connection, tablesBySchemas) {
|
||||
const sql = `select nsp1.nspname schema_name, cls1.relname table_name, nsp2.nspname referenced_schema_name,
|
||||
cls2.relname referenced_table_name, a.attname column_name, af.attname referenced_column_name, conname constraint_name,
|
||||
confupdtype update_rule, confdeltype delete_rule, array_position(con.conkey,a.attnum) as ord, condeferrable, condeferred,
|
||||
pg_get_constraintdef(con.oid) as constraint_def
|
||||
from pg_attribute a
|
||||
join pg_constraint con on con.conrelid = a.attrelid AND a.attnum = ANY (con.conkey)
|
||||
join pg_attribute af on af.attnum = con.confkey[array_position(con.conkey,a.attnum)] AND af.attrelid = con.confrelid
|
||||
join pg_namespace nsp1 on nsp1.oid = con.connamespace
|
||||
join pg_class cls1 on cls1.oid = con.conrelid
|
||||
join pg_class cls2 on cls2.oid = confrelid
|
||||
join pg_namespace nsp2 on nsp2.oid = cls2.relnamespace
|
||||
where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(cls1.relname in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and nsp1.nspname = ${this.platform.quoteValue(schema)})`).join(' or ')})
|
||||
and confrelid > 0
|
||||
order by nsp1.nspname, cls1.relname, constraint_name, ord`;
|
||||
const allFks = await connection.execute(sql);
|
||||
const ret = {};
|
||||
function mapReferentialIntegrity(value, def) {
|
||||
const match = ['n', 'd'].includes(value) && /ON DELETE (SET (NULL|DEFAULT) \(.*?\))/.exec(def);
|
||||
if (match) {
|
||||
return match[1];
|
||||
}
|
||||
/* v8 ignore next */
|
||||
switch (value) {
|
||||
case 'r':
|
||||
return 'RESTRICT';
|
||||
case 'c':
|
||||
return 'CASCADE';
|
||||
case 'n':
|
||||
return 'SET NULL';
|
||||
case 'd':
|
||||
return 'SET DEFAULT';
|
||||
case 'a':
|
||||
default:
|
||||
return 'NO ACTION';
|
||||
}
|
||||
}
|
||||
for (const fk of allFks) {
|
||||
fk.update_rule = mapReferentialIntegrity(fk.update_rule, fk.constraint_def);
|
||||
fk.delete_rule = mapReferentialIntegrity(fk.delete_rule, fk.constraint_def);
|
||||
if (fk.condeferrable) {
|
||||
fk.defer_mode = fk.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
|
||||
}
|
||||
const key = this.getTableKey(fk);
|
||||
ret[key] ??= [];
|
||||
ret[key].push(fk);
|
||||
}
|
||||
Object.keys(ret).forEach(key => {
|
||||
const [schemaName, tableName] = key.split('.');
|
||||
ret[key] = this.mapForeignKeys(ret[key], tableName, schemaName);
|
||||
});
|
||||
return ret;
|
||||
}
|
||||
async getNativeEnumDefinitions(connection, schemas) {
|
||||
const uniqueSchemas = Utils.unique(schemas);
|
||||
const res = await connection.execute(
|
||||
`select t.typname as enum_name, n.nspname as schema_name, array_agg(e.enumlabel order by e.enumsortorder) as enum_value
|
||||
from pg_type t
|
||||
join pg_enum e on t.oid = e.enumtypid
|
||||
join pg_catalog.pg_namespace n on n.oid = t.typnamespace
|
||||
where n.nspname in (${Array(uniqueSchemas.length).fill('?').join(', ')})
|
||||
group by t.typname, n.nspname`,
|
||||
uniqueSchemas,
|
||||
);
|
||||
return res.reduce((o, row) => {
|
||||
let name = row.enum_name;
|
||||
if (row.schema_name && row.schema_name !== this.platform.getDefaultSchemaName()) {
|
||||
name = row.schema_name + '.' + name;
|
||||
}
|
||||
let items = row.enum_value;
|
||||
if (!Array.isArray(items)) {
|
||||
items = this.platform.unmarshallArray(row.enum_value);
|
||||
}
|
||||
o[name] = {
|
||||
name: row.enum_name,
|
||||
schema: row.schema_name,
|
||||
items,
|
||||
};
|
||||
return o;
|
||||
}, {});
|
||||
}
|
||||
getCreateNativeEnumSQL(name, values, schema) {
|
||||
if (schema && schema !== this.platform.getDefaultSchemaName()) {
|
||||
name = schema + '.' + name;
|
||||
}
|
||||
return `create type ${this.quote(name)} as enum (${values.map(value => this.platform.quoteValue(value)).join(', ')})`;
|
||||
}
|
||||
getDropNativeEnumSQL(name, schema) {
|
||||
if (schema && schema !== this.platform.getDefaultSchemaName()) {
|
||||
name = schema + '.' + name;
|
||||
}
|
||||
return `drop type ${this.quote(name)}`;
|
||||
}
|
||||
getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
|
||||
if (schema && schema !== this.platform.getDefaultSchemaName()) {
|
||||
name = schema + '.' + name;
|
||||
}
|
||||
let suffix = '';
|
||||
if (items && value && oldItems) {
|
||||
const position = items.indexOf(value);
|
||||
if (position > 0) {
|
||||
suffix = ` after ${this.platform.quoteValue(items[position - 1])}`;
|
||||
} else if (items.length > 1 && oldItems.length > 0) {
|
||||
suffix = ` before ${this.platform.quoteValue(oldItems[0])}`;
|
||||
}
|
||||
}
|
||||
return `alter type ${this.quote(name)} add value if not exists ${this.platform.quoteValue(value)}${suffix}`;
|
||||
}
|
||||
getEnumDefinitions(checks) {
|
||||
return checks.reduce((o, item) => {
|
||||
// check constraints are defined as one of:
|
||||
// `CHECK ((type = ANY (ARRAY['local'::text, 'global'::text])))`
|
||||
// `CHECK (("columnName" = ANY (ARRAY['local'::text, 'global'::text])))`
|
||||
// `CHECK (((enum_test)::text = ANY ((ARRAY['a'::character varying, 'b'::character varying, 'c'::character varying])::text[])))`
|
||||
// `CHECK ((("enumTest")::text = ANY ((ARRAY['a'::character varying, 'b'::character varying, 'c'::character varying])::text[])))`
|
||||
// `CHECK ((type = 'a'::text))`
|
||||
const m1 =
|
||||
item.definition?.match(/check \(\(\("?(\w+)"?\)::/i) || item.definition?.match(/check \(\("?(\w+)"? = /i);
|
||||
const m2 = item.definition?.match(/\(array\[(.*)]\)/i) || item.definition?.match(/ = (.*)\)/i);
|
||||
if (item.columnName && m1 && m2) {
|
||||
const m3 = m2[1].match(/('[^']*'::text)/g);
|
||||
let items;
|
||||
/* v8 ignore next */
|
||||
if (m3) {
|
||||
items = m3.map(item => /^\(?'(.*)'/.exec(item.trim())?.[1]);
|
||||
} else {
|
||||
items = m2[1].split(',').map(item => /^\(?'(.*)'/.exec(item.trim())?.[1]);
|
||||
}
|
||||
items = items.filter(item => item !== undefined);
|
||||
if (items.length > 0) {
|
||||
o[item.columnName] = items;
|
||||
item.expression = `${this.quote(item.columnName)} in ('${items.join("', '")}')`;
|
||||
item.definition = `check (${item.expression})`;
|
||||
}
|
||||
}
|
||||
return o;
|
||||
}, {});
|
||||
}
|
||||
createTableColumn(column, table) {
|
||||
const pk = table.getPrimaryKey();
|
||||
const compositePK = pk?.composite;
|
||||
const primaryKey = !this.hasNonDefaultPrimaryKeyName(table);
|
||||
const col = [this.quote(column.name)];
|
||||
if (column.autoincrement && !column.generated && !compositePK) {
|
||||
col.push(column.mappedType.getColumnType({ autoincrement: true }, this.platform));
|
||||
} else {
|
||||
let columnType = column.type;
|
||||
if (column.nativeEnumName) {
|
||||
const parts = column.type.split('.');
|
||||
if (parts.length === 2 && parts[0] === '*') {
|
||||
columnType = `${table.schema}.${parts[1]}`;
|
||||
}
|
||||
if (columnType.endsWith('[]')) {
|
||||
columnType = this.quote(columnType.substring(0, columnType.length - 2)) + '[]';
|
||||
} else {
|
||||
columnType = this.quote(columnType);
|
||||
}
|
||||
}
|
||||
if (column.generated === 'by default as identity') {
|
||||
columnType += ` generated ${column.generated}`;
|
||||
} else if (column.generated) {
|
||||
columnType += ` generated always as ${column.generated}`;
|
||||
}
|
||||
col.push(columnType);
|
||||
Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
|
||||
Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable);
|
||||
}
|
||||
if (column.autoincrement && !compositePK) {
|
||||
Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
|
||||
}
|
||||
const useDefault = column.default != null && column.default !== 'null' && !column.autoincrement;
|
||||
Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
|
||||
return col.join(' ');
|
||||
}
|
||||
getPreAlterTable(tableDiff, safe) {
|
||||
const ret = [];
|
||||
const parts = tableDiff.name.split('.');
|
||||
const tableName = parts.pop();
|
||||
const schemaName = parts.pop();
|
||||
/* v8 ignore next */
|
||||
const name =
|
||||
(schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
|
||||
const quotedName = this.quote(name);
|
||||
// detect that the column was an enum before and remove the check constraint in such case here
|
||||
const changedEnums = Object.values(tableDiff.changedColumns).filter(
|
||||
col => col.fromColumn.mappedType instanceof EnumType,
|
||||
);
|
||||
for (const col of changedEnums) {
|
||||
if (!col.fromColumn.nativeEnumName && col.column.nativeEnumName && col.fromColumn.default) {
|
||||
ret.push(`alter table ${quotedName} alter column "${col.column.name}" drop default`);
|
||||
}
|
||||
if (col.fromColumn.nativeEnumName && !col.column.nativeEnumName && col.fromColumn.default) {
|
||||
ret.push(`alter table ${quotedName} alter column "${col.column.name}" drop default`);
|
||||
}
|
||||
}
|
||||
// changing uuid column type requires to cast it to text first
|
||||
const uuids = Object.values(tableDiff.changedColumns).filter(
|
||||
col => col.changedProperties.has('type') && col.fromColumn.type === 'uuid',
|
||||
);
|
||||
for (const col of uuids) {
|
||||
ret.push(
|
||||
`alter table ${quotedName} alter column "${col.column.name}" type text using ("${col.column.name}"::text)`,
|
||||
);
|
||||
}
|
||||
for (const { column } of Object.values(tableDiff.changedColumns).filter(diff =>
|
||||
diff.changedProperties.has('autoincrement'),
|
||||
)) {
|
||||
if (!column.autoincrement && column.default == null) {
|
||||
ret.push(`alter table ${quotedName} alter column ${this.quote(column.name)} drop default`);
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
castColumn(name, type) {
|
||||
if (type === 'uuid') {
|
||||
type = 'text::uuid';
|
||||
}
|
||||
return ` using (${this.quote(name)}::${type})`;
|
||||
}
|
||||
dropForeignKey(tableName, constraintName) {
|
||||
return `alter table ${this.quote(tableName)} drop constraint ${this.quote(constraintName)}`;
|
||||
}
|
||||
getPostAlterTable(tableDiff, safe) {
|
||||
const ret = [];
|
||||
const parts = tableDiff.name.split('.');
|
||||
const tableName = parts.pop();
|
||||
const schemaName = parts.pop();
|
||||
/* v8 ignore next */
|
||||
const name =
|
||||
(schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
|
||||
const quotedName = this.quote(name);
|
||||
// detect that the column was an enum before and remove the check constraint in such a case here
|
||||
const changedEnums = Object.values(tableDiff.changedColumns).filter(
|
||||
col => col.fromColumn.mappedType instanceof EnumType,
|
||||
);
|
||||
for (const col of changedEnums) {
|
||||
if (!col.fromColumn.nativeEnumName && col.column.nativeEnumName && col.column.default) {
|
||||
ret.push(`alter table ${quotedName} alter column "${col.column.name}" set default ${col.column.default}`);
|
||||
}
|
||||
if (col.fromColumn.nativeEnumName && !col.column.nativeEnumName && col.column.default) {
|
||||
ret.push(`alter table ${quotedName} alter column "${col.column.name}" set default ${col.column.default}`);
|
||||
}
|
||||
}
|
||||
for (const { column } of Object.values(tableDiff.changedColumns).filter(diff =>
|
||||
diff.changedProperties.has('autoincrement'),
|
||||
)) {
|
||||
ret.push(...this.getAlterColumnAutoincrement(tableName, column, schemaName));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
getAlterColumnAutoincrement(tableName, column, schemaName) {
|
||||
const ret = [];
|
||||
/* v8 ignore next */
|
||||
const name =
|
||||
(schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
|
||||
if (column.autoincrement) {
|
||||
const seqName = this.platform.getIndexName(tableName, [column.name], 'sequence');
|
||||
ret.push(`create sequence if not exists ${this.quote(seqName)}`);
|
||||
ret.push(`select setval('${seqName}', (select max(${this.quote(column.name)}) from ${this.quote(name)}))`);
|
||||
ret.push(
|
||||
`alter table ${this.quote(name)} alter column ${this.quote(column.name)} set default nextval('${seqName}')`,
|
||||
);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
getChangeColumnCommentSQL(tableName, to, schemaName) {
|
||||
const name = this.quote(
|
||||
(schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName,
|
||||
);
|
||||
const value = to.comment ? this.platform.quoteValue(to.comment) : 'null';
|
||||
return `comment on column ${name}.${this.quote(to.name)} is ${value}`;
|
||||
}
|
||||
alterTableComment(table, comment) {
|
||||
return `comment on table ${table.getQuotedName()} is ${this.platform.quoteValue(comment ?? '')}`;
|
||||
}
|
||||
normalizeDefaultValue(defaultValue, length) {
|
||||
if (!defaultValue || typeof defaultValue !== 'string') {
|
||||
return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
|
||||
}
|
||||
const match = /^'(.*)'::(.*)$/.exec(defaultValue);
|
||||
if (match) {
|
||||
if (match[2] === 'integer') {
|
||||
return +match[1];
|
||||
}
|
||||
return `'${match[1]}'`;
|
||||
}
|
||||
return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
|
||||
}
|
||||
appendComments(table) {
|
||||
const sql = [];
|
||||
if (table.comment) {
|
||||
const comment = this.platform.quoteValue(this.processComment(table.comment));
|
||||
sql.push(`comment on table ${table.getQuotedName()} is ${comment}`);
|
||||
}
|
||||
for (const column of table.getColumns()) {
|
||||
if (column.comment) {
|
||||
const comment = this.platform.quoteValue(this.processComment(column.comment));
|
||||
sql.push(`comment on column ${table.getQuotedName()}.${this.quote(column.name)} is ${comment}`);
|
||||
}
|
||||
}
|
||||
return sql;
|
||||
}
|
||||
getDatabaseExistsSQL(name) {
|
||||
return `select 1 from pg_database where datname = '${name}'`;
|
||||
}
|
||||
getDatabaseNotExistsError(dbName) {
|
||||
return `database ${this.quote(dbName)} does not exist`;
|
||||
}
|
||||
getManagementDbName() {
|
||||
return this.platform.getConfig().get('schemaGenerator', {}).managementDbName ?? 'postgres';
|
||||
}
|
||||
disableForeignKeysSQL() {
|
||||
return `set session_replication_role = 'replica';`;
|
||||
}
|
||||
enableForeignKeysSQL() {
|
||||
return `set session_replication_role = 'origin';`;
|
||||
}
|
||||
getRenameIndexSQL(tableName, index, oldIndexName) {
|
||||
oldIndexName = this.quote(oldIndexName);
|
||||
const keyName = this.quote(index.keyName);
|
||||
return [`alter index ${oldIndexName} rename to ${keyName}`];
|
||||
}
|
||||
dropIndex(table, index, oldIndexName = index.keyName) {
|
||||
if (index.primary || (index.unique && index.constraint)) {
|
||||
return `alter table ${this.quote(table)} drop constraint ${this.quote(oldIndexName)}`;
|
||||
}
|
||||
return `drop index ${this.quote(oldIndexName)}`;
|
||||
}
|
||||
/**
|
||||
* Build the column list for a PostgreSQL index.
|
||||
*/
|
||||
getIndexColumns(index) {
|
||||
if (index.columns?.length) {
|
||||
return index.columns
|
||||
.map(col => {
|
||||
let colDef = this.quote(col.name);
|
||||
// PostgreSQL supports collation with double quotes
|
||||
if (col.collation) {
|
||||
colDef += ` collate ${this.quote(col.collation)}`;
|
||||
}
|
||||
// PostgreSQL supports sort order
|
||||
if (col.sort) {
|
||||
colDef += ` ${col.sort}`;
|
||||
}
|
||||
// PostgreSQL supports NULLS FIRST/LAST
|
||||
if (col.nulls) {
|
||||
colDef += ` nulls ${col.nulls}`;
|
||||
}
|
||||
return colDef;
|
||||
})
|
||||
.join(', ');
|
||||
}
|
||||
return index.columnNames.map(c => this.quote(c)).join(', ');
|
||||
}
|
||||
/**
|
||||
* PostgreSQL-specific index options like fill factor.
|
||||
*/
|
||||
getCreateIndexSuffix(index) {
|
||||
const withOptions = [];
|
||||
if (index.fillFactor != null) {
|
||||
withOptions.push(`fillfactor = ${index.fillFactor}`);
|
||||
}
|
||||
if (withOptions.length > 0) {
|
||||
return ` with (${withOptions.join(', ')})`;
|
||||
}
|
||||
return super.getCreateIndexSuffix(index);
|
||||
}
|
||||
getIndexesSQL(tables) {
|
||||
return `select indrelid::regclass as table_name, ns.nspname as schema_name, relname as constraint_name, idx.indisunique as unique, idx.indisprimary as primary, contype, condeferrable, condeferred,
|
||||
array(
|
||||
select pg_get_indexdef(idx.indexrelid, k + 1, true)
|
||||
from generate_subscripts(idx.indkey, 1) as k
|
||||
order by k
|
||||
) as index_def,
|
||||
pg_get_indexdef(idx.indexrelid) as expression,
|
||||
c.condeferrable as deferrable,
|
||||
c.condeferred as initially_deferred,
|
||||
i.reloptions,
|
||||
am.amname as index_type
|
||||
from pg_index idx
|
||||
join pg_class as i on i.oid = idx.indexrelid
|
||||
join pg_namespace as ns on i.relnamespace = ns.oid
|
||||
join pg_am as am on am.oid = i.relam
|
||||
left join pg_constraint as c on c.conname = i.relname
|
||||
where indrelid in (${tables.map(t => `${this.platform.quoteValue(`${this.quote(t.schema_name)}.${this.quote(t.table_name)}`)}::regclass`).join(', ')})
|
||||
order by relname`;
|
||||
}
|
||||
getChecksSQL(tablesBySchemas) {
|
||||
return `select ccu.table_name as table_name, ccu.table_schema as schema_name, pgc.conname as name, conrelid::regclass as table_from, ccu.column_name as column_name, pg_get_constraintdef(pgc.oid) as expression
|
||||
from pg_constraint pgc
|
||||
join pg_namespace nsp on nsp.oid = pgc.connamespace
|
||||
join pg_class cls on pgc.conrelid = cls.oid
|
||||
join information_schema.constraint_column_usage ccu on pgc.conname = ccu.constraint_name and nsp.nspname = ccu.constraint_schema and cls.relname = ccu.table_name
|
||||
where contype = 'c' and (${[...tablesBySchemas.entries()].map(([schema, tables]) => `ccu.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and ccu.table_schema = ${this.platform.quoteValue(schema)}`).join(' or ')})
|
||||
order by pgc.conname`;
|
||||
}
|
||||
inferLengthFromColumnType(type) {
|
||||
const match = /^(\w+(?:\s+\w+)*)\s*(?:\(\s*(\d+)\s*\)|$)/.exec(type);
|
||||
if (!match) {
|
||||
return;
|
||||
}
|
||||
if (!match[2]) {
|
||||
switch (match[1]) {
|
||||
case 'character varying':
|
||||
case 'varchar':
|
||||
case 'bpchar':
|
||||
case 'char':
|
||||
case 'character':
|
||||
return -1;
|
||||
case 'interval':
|
||||
case 'time':
|
||||
case 'timestamp':
|
||||
case 'timestamptz':
|
||||
return this.platform.getDefaultDateTimeLength();
|
||||
}
|
||||
return;
|
||||
}
|
||||
return +match[2];
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user