relq 1.0.5 → 1.0.6

package/dist/cjs/cli/utils/sql-generator.cjs

@@ -15,11 +15,11 @@ exports.generateTriggerSQL = generateTriggerSQL;
 exports.generateCommentSQL = generateCommentSQL;
 exports.generateFullSchemaSQL = generateFullSchemaSQL;
 const RESERVED_WORDS = new Set([
-    'user', 'order', 'check', 'table', 'index', 'column', 'constraint',
+    'order', 'check', 'table', 'index', 'column', 'constraint',
     'primary', 'foreign', 'key', 'references', 'unique', 'default',
     'null', 'not', 'and', 'or', 'in', 'like', 'between', 'case',
     'when', 'then', 'else', 'end', 'select', 'from', 'where', 'group',
-    'having', 'order', 'by', 'limit', 'offset', 'join', 'left', 'right',
+    'having', 'by', 'limit', 'offset', 'join', 'left', 'right',
     'inner', 'outer', 'cross', 'on', 'as', 'into', 'values', 'insert',
     'update', 'delete', 'create', 'alter', 'drop', 'grant', 'revoke',
     'all', 'any', 'some', 'exists', 'true', 'false', 'boolean', 'int',
@@ -61,7 +61,7 @@ const RESERVED_WORDS = new Set([
     'off', 'oids', 'old', 'only', 'operator', 'option', 'options',
     'ordinality', 'others', 'out', 'over', 'overlaps', 'overlay',
     'overriding', 'owned', 'owner', 'parallel', 'parser', 'partial',
-    'partition', 'passing', 'password', 'placing', 'plans', 'policy',
+    'partition', 'passing', 'placing', 'plans', 'policy',
     'position', 'preceding', 'prepare', 'prepared', 'preserve', 'prior',
     'privileges', 'procedural', 'program', 'publication', 'quote',
     'range', 'read', 'reassign', 'recheck', 'refresh', 'reindex',
@@ -97,6 +97,34 @@ function quoteIdentifier(name) {
     }
     return name;
 }
+function parseFKDefinition(definition) {
+    if (!definition)
+        return null;
+    const constraintNameMatch = definition.match(/^CONSTRAINT\s+"?([^"]+)"?\s+/i);
+    const constraintName = constraintNameMatch?.[1];
+    const fkPart = constraintName
+        ? definition.substring(constraintNameMatch[0].length)
+        : definition;
+    const fkMatch = fkPart.match(/FOREIGN\s+KEY\s*\(\s*([^)]+)\s*\)\s*REFERENCES\s+"?([^"\s(]+)"?\s*(?:\(\s*([^)]+)\s*\))?/i);
+    if (!fkMatch)
+        return null;
+    const parseColumnList = (str) => {
+        return str.split(',').map(c => c.trim().replace(/^"|"$/g, ''));
+    };
+    const columns = parseColumnList(fkMatch[1]);
+    const referencedTable = fkMatch[2].replace(/^"|"$/g, '');
+    const referencedColumns = fkMatch[3] ? parseColumnList(fkMatch[3]) : ['id'];
+    const onDeleteMatch = definition.match(/ON\s+DELETE\s+(CASCADE|SET\s+NULL|SET\s+DEFAULT|RESTRICT|NO\s+ACTION)/i);
+    const onUpdateMatch = definition.match(/ON\s+UPDATE\s+(CASCADE|SET\s+NULL|SET\s+DEFAULT|RESTRICT|NO\s+ACTION)/i);
+    return {
+        constraintName,
+        columns,
+        referencedTable,
+        referencedColumns,
+        onDelete: onDeleteMatch?.[1]?.toUpperCase().replace(/\s+/g, ' '),
+        onUpdate: onUpdateMatch?.[1]?.toUpperCase().replace(/\s+/g, ' '),
+    };
+}
 function quoteColumnRef(name) {
     const lowerName = name.toLowerCase();
     if (RESERVED_WORDS.has(lowerName)) {
@@ -107,12 +135,25 @@ function quoteColumnRef(name) {
     }
     return name;
 }
+const PG_TYPE_MAP = {
+    'int2': 'smallint',
+    'int4': 'integer',
+    'int8': 'bigint',
+    'float4': 'real',
+    'float8': 'double precision',
+    'bool': 'boolean',
+    'timestamptz': 'timestamp with time zone',
+    'timetz': 'time with time zone',
+    'bpchar': 'character',
+    'varbit': 'bit varying',
+};
 function normalizePgType(pgType) {
     if (pgType.startsWith('_')) {
         const baseType = pgType.slice(1);
-        return `${baseType}[]`;
+        const friendlyBase = PG_TYPE_MAP[baseType] || baseType;
+        return `${friendlyBase}[]`;
     }
-    return pgType;
+    return PG_TYPE_MAP[pgType] || pgType;
 }
 function generateExtensionSQL(extensionName) {
     const quotedName = extensionName.includes('-') ? `"${extensionName}"` : extensionName;
@@ -190,15 +231,116 @@ function generateSequenceSQL(seq) {
     return parts.join(' ') + ';';
 }
 function generateTableSQL(table, options = {}) {
-    const { includeConstraints = true } = options;
+    const { includeConstraints = true, ifNotExists = false } = options;
     const lines = [];
-    lines.push(`CREATE TABLE ${quoteIdentifier(table.name)} (`);
+    const ifNotExistsClause = ifNotExists ? 'IF NOT EXISTS ' : '';
+    lines.push(`-- DEBUG: generateTableSQL running for ${table.name}`);
+    lines.push(`CREATE TABLE ${ifNotExistsClause}${quoteIdentifier(table.name)} (`);
+    let singleColumnPkName = null;
+    let pkConstraintIndex = -1;
+    const compositeUniqueColumns = new Set();
+    const inlineFKs = new Map();
+    const skipFKIndices = new Set();
+    if (table.constraints) {
+        const pkIndex = table.constraints.findIndex(c => c.type === 'PRIMARY KEY');
+        if (pkIndex !== -1) {
+            const pkConstraint = table.constraints[pkIndex];
+            pkConstraintIndex = pkIndex;
+            if (pkConstraint.columns && pkConstraint.columns.length === 1) {
+                singleColumnPkName = pkConstraint.columns[0];
+            }
+            else if (pkConstraint.definition) {
+                const match = pkConstraint.definition.match(/PRIMARY\s+KEY\s*\(\s*"?([^",\s)]+)"?\s*\)/i);
+                if (match && !pkConstraint.definition.includes(',')) {
+                    singleColumnPkName = match[1];
+                }
+            }
+        }
+        for (const constraint of table.constraints) {
+            if (constraint.type === 'UNIQUE') {
+                let cols = [];
+                if (constraint.columns && constraint.columns.length > 0) {
+                    if (Array.isArray(constraint.columns)) {
+                        cols = constraint.columns;
+                    }
+                    else if (typeof constraint.columns === 'string') {
+                        const str = constraint.columns;
+                        if (str.startsWith('{') && str.endsWith('}')) {
+                            cols = str.slice(1, -1).split(',').map(c => c.trim().replace(/^"|"$/g, ''));
+                        }
+                    }
+                }
+                else if (constraint.definition) {
+                    const match = constraint.definition.match(/UNIQUE\s*\(([^)]+)\)/i);
+                    if (match) {
+                        cols = match[1].split(',').map(c => c.trim().replace(/^"|"$/g, ''));
+                    }
+                }
+                if (cols.length > 1) {
+                    for (const col of cols) {
+                        compositeUniqueColumns.add(col);
+                    }
+                }
+            }
+        }
+        table.constraints.forEach((constraint, index) => {
+            if (constraint.type === 'FOREIGN KEY') {
+                let fkColumns = constraint.columns;
+                let refTable = constraint.referencedTable || constraint.references?.table;
+                let refColumns = constraint.referencedColumns || constraint.references?.columns;
+                let onDelete = constraint.onDelete || constraint.references?.onDelete;
+                let onUpdate = constraint.onUpdate || constraint.references?.onUpdate;
+                let constraintName = constraint.name;
+                if (!refTable && constraint.definition) {
+                    const parsed = parseFKDefinition(constraint.definition);
+                    if (parsed) {
+                        fkColumns = parsed.columns;
+                        refTable = parsed.referencedTable;
+                        refColumns = parsed.referencedColumns;
+                        onDelete = parsed.onDelete;
+                        onUpdate = parsed.onUpdate;
+                        if (!constraintName) {
+                            constraintName = parsed.constraintName;
+                        }
+                    }
+                }
+                const isSingleColumn = fkColumns && fkColumns.length === 1;
+                let hasExplicitName = false;
+                if (constraintName && fkColumns && fkColumns.length > 0) {
+                    const colName = fkColumns[0];
+                    const expectedAutoName = `${table.name}_${colName}_fkey`;
+                    hasExplicitName = constraintName.toLowerCase() !== expectedAutoName.toLowerCase();
+                }
+                if (isSingleColumn && refTable) {
+                    const colName = fkColumns[0];
+                    inlineFKs.set(colName, {
+                        table: refTable,
+                        column: refColumns?.[0],
+                        onDelete: onDelete,
+                        onUpdate: onUpdate,
+                        constraintName: hasExplicitName ? constraintName : undefined,
+                    });
+                    skipFKIndices.add(index);
+                }
+            }
+        });
+    }
     const columnLines = [];
     for (const col of table.columns) {
-        columnLines.push(generateColumnSQL(col));
+        const isInlinePk = singleColumnPkName === col.name;
+        const skipInlineUnique = compositeUniqueColumns.has(col.name);
+        const inlineFKInfo = inlineFKs.get(col.name);
+        columnLines.push(generateColumnSQL(col, { inlinePrimaryKey: isInlinePk, skipInlineUnique, inlineForeignKey: inlineFKInfo }));
     }
     if (includeConstraints && table.constraints) {
-        for (const constraint of table.constraints) {
+        for (let i = 0; i < table.constraints.length; i++) {
+            const constraint = table.constraints[i];
+            if (constraint.type === 'PRIMARY KEY' && singleColumnPkName) {
+                continue;
+            }
+            if (constraint.type === 'FOREIGN KEY' && skipFKIndices.has(i)) {
+                continue;
+            }
             const constraintSQL = generateInlineConstraintSQL(constraint);
             if (constraintSQL) {
                 columnLines.push(constraintSQL);
@@ -217,9 +359,21 @@ function generateTableSQL(table, options = {}) {
     }
     return lines.join('\n');
 }
-function generateColumnSQL(col) {
+function generateColumnSQL(col, options = {}) {
+    const { inlinePrimaryKey = false, skipInlineUnique = false, inlineForeignKey } = options;
     const parts = [];
-    const normalizedType = normalizePgType(col.dataType);
+    let normalizedType = normalizePgType(col.dataType);
+    const baseType = normalizedType.replace('[]', '').toLowerCase();
+    if ((baseType === 'varchar' || baseType === 'character varying') && col.maxLength) {
+        normalizedType = `varchar(${col.maxLength})${normalizedType.endsWith('[]') ? '[]' : ''}`;
+    }
+    else if ((baseType === 'char' || baseType === 'character' || baseType === 'bpchar') && col.maxLength) {
+        normalizedType = `char(${col.maxLength})${normalizedType.endsWith('[]') ? '[]' : ''}`;
+    }
+    else if (baseType === 'numeric' && col.precision) {
+        const precisionStr = col.scale ? `${col.precision},${col.scale}` : `${col.precision}`;
+        normalizedType = `numeric(${precisionStr})${normalizedType.endsWith('[]') ? '[]' : ''}`;
+    }
     parts.push(`${quoteIdentifier(col.name).padEnd(28)}${normalizedType}`);
     if (col.dataType.endsWith('[]')) {
     }
@@ -230,44 +384,68 @@ function generateColumnSQL(col) {
     if (col.identityGeneration) {
         parts.push(`GENERATED ${col.identityGeneration} AS IDENTITY`);
     }
-    if (!col.isNullable && !col.isPrimaryKey && !col.identityGeneration) {
+    if (!col.isNullable && !col.identityGeneration && !inlinePrimaryKey) {
         parts.push('NOT NULL');
     }
     if (col.defaultValue !== null && col.defaultValue !== undefined && !col.isGenerated) {
         parts.push(`DEFAULT ${col.defaultValue}`);
     }
-    if (col.isUnique && !col.isPrimaryKey) {
+    if (inlinePrimaryKey) {
+        parts.push('PRIMARY KEY');
+    }
+    if (col.isUnique && !col.isPrimaryKey && !inlinePrimaryKey && !skipInlineUnique) {
         parts.push('UNIQUE');
     }
-    if (col.references) {
-        const ref = col.references;
-        let refStr = `REFERENCES ${quoteIdentifier(ref.table)}(${quoteIdentifier(ref.column)})`;
-        if (ref.onDelete && ref.onDelete !== 'NO ACTION') {
-            refStr += ` ON DELETE ${ref.onDelete}`;
+    if (inlineForeignKey) {
+        let refPart = '';
+        if (inlineForeignKey.constraintName) {
+            refPart += `CONSTRAINT ${quoteIdentifier(inlineForeignKey.constraintName)} `;
+        }
+        refPart += `REFERENCES ${quoteIdentifier(inlineForeignKey.table)}`;
+        if (inlineForeignKey.column && inlineForeignKey.column.toLowerCase() !== 'id') {
+            refPart += `(${quoteIdentifier(inlineForeignKey.column)})`;
         }
-        if (ref.onUpdate && ref.onUpdate !== 'NO ACTION') {
-            refStr += ` ON UPDATE ${ref.onUpdate}`;
+        if (inlineForeignKey.onDelete && inlineForeignKey.onDelete !== 'NO ACTION') {
+            refPart += ` ON DELETE ${inlineForeignKey.onDelete}`;
         }
-        parts.push(refStr);
+        if (inlineForeignKey.onUpdate && inlineForeignKey.onUpdate !== 'NO ACTION') {
+            refPart += ` ON UPDATE ${inlineForeignKey.onUpdate}`;
+        }
+        parts.push(refPart);
     }
     if (col.check) {
         parts.push(`CHECK (${col.check})`);
     }
     return parts.join(' ');
 }
+function unquoteIdentifiers(sql) {
+    return sql.replace(/"([a-z_][a-z0-9_]*)"/g, (match, identifier) => {
+        if (RESERVED_WORDS.has(identifier.toLowerCase())) {
+            return match;
+        }
+        return identifier;
+    });
+}
 function generateInlineConstraintSQL(constraint) {
     if (constraint.definition) {
-        const def = constraint.definition.trim();
+        let def = constraint.definition.trim();
+        def = unquoteIdentifiers(def);
+        if (constraint.type === 'PRIMARY KEY') {
+            const pkMatch = def.match(/PRIMARY\s+KEY\s*\([^)]+\)/i);
+            if (pkMatch) {
+                return pkMatch[0];
+            }
+        }
         if (def.toUpperCase().startsWith('CONSTRAINT')) {
             return def;
         }
-        if (constraint.name) {
+        if (constraint.name && constraint.type !== 'PRIMARY KEY') {
             return `CONSTRAINT ${quoteIdentifier(constraint.name)} ${def}`;
         }
         return def;
     }
     const parts = [];
-    if (constraint.name) {
+    if (constraint.name && constraint.type !== 'PRIMARY KEY') {
         parts.push(`CONSTRAINT ${quoteIdentifier(constraint.name)}`);
     }
     switch (constraint.type) {
@@ -288,9 +466,20 @@ function generateInlineConstraintSQL(constraint) {
             }
             break;
         case 'FOREIGN KEY':
-            if (constraint.columns && constraint.referencedTable && constraint.referencedColumns) {
+            const refTable = constraint.referencedTable || constraint.references?.table;
+            const refColumns = constraint.referencedColumns || constraint.references?.columns;
+            const onDelete = constraint.onDelete || constraint.references?.onDelete;
+            const onUpdate = constraint.onUpdate || constraint.references?.onUpdate;
+            if (constraint.columns && refTable && refColumns) {
                 parts.push(`FOREIGN KEY (${constraint.columns.map(c => quoteIdentifier(c)).join(', ')})`);
-                parts.push(`REFERENCES ${quoteIdentifier(constraint.referencedTable)}(${constraint.referencedColumns.map(c => quoteIdentifier(c)).join(', ')})`);
+                let refPart = `REFERENCES ${quoteIdentifier(refTable)}(${refColumns.map((c) => quoteIdentifier(c)).join(', ')})`;
+                if (onDelete && onDelete !== 'NO ACTION') {
+                    refPart += ` ON DELETE ${onDelete}`;
+                }
+                if (onUpdate && onUpdate !== 'NO ACTION') {
+                    refPart += ` ON UPDATE ${onUpdate}`;
+                }
+                parts.push(refPart);
             }
             else {
                 return null;
@@ -325,32 +514,64 @@ function generatePartitionSQL(partition) {
     }
     return parts.join(' ') + ';';
 }
-function generateIndexSQL(index, tableName) {
-    if (index.definition) {
-        let def = index.definition.trim();
-        if (!def.endsWith(';')) {
-            def += ';';
-        }
-        return def;
-    }
+function generateIndexSQL(index, tableName, options = {}) {
     const parts = [];
     parts.push('CREATE');
     if (index.isUnique) {
         parts.push('UNIQUE');
     }
     parts.push('INDEX');
+    if (options.ifNotExists) {
+        parts.push('IF NOT EXISTS');
+    }
     parts.push(quoteIdentifier(index.name));
     parts.push('ON');
-    parts.push(quoteIdentifier(tableName));
+    if (options.tableOnly) {
+        parts.push('ONLY');
+    }
+    if (options.includeSchema && options.schema) {
+        parts.push(`${quoteIdentifier(options.schema)}.${quoteIdentifier(tableName)}`);
+    }
+    else {
+        parts.push(quoteIdentifier(tableName));
+    }
     if (index.type && index.type.toLowerCase() !== 'btree') {
-        parts.push(`USING ${index.type.toUpperCase()}`);
+        parts.push(`USING ${index.type.toLowerCase()}`);
+    }
+    let columnSpec = null;
+    if (index.definition) {
+        const defMatch = index.definition.match(/\bON\s+(?:ONLY\s+)?[^\s(]+\s+(?:USING\s+\w+\s+)?\(([^)]+)\)/i);
+        if (defMatch) {
+            columnSpec = defMatch[1].trim();
+        }
+    }
+    if (columnSpec) {
+        parts.push(`(${columnSpec})`);
     }
-    if (index.expression) {
+    else if (index.expression) {
         parts.push(`(${index.expression})`);
     }
-    else if (index.columns && Array.isArray(index.columns) && index.columns.length > 0) {
-        const cols = index.columns.map(c => quoteColumnRef(c)).join(', ');
-        parts.push(`(${cols})`);
+    else if (index.columns) {
+        let columnsArray;
+        if (Array.isArray(index.columns)) {
+            columnsArray = index.columns;
+        }
+        else if (typeof index.columns === 'string') {
+            const str = index.columns;
+            if (str.startsWith('{') && str.endsWith('}')) {
+                columnsArray = str.slice(1, -1).split(',').map(c => c.trim().replace(/^"|"$/g, ''));
+            }
+            else {
+                columnsArray = [str];
+            }
+        }
+        else {
+            columnsArray = [];
+        }
+        if (columnsArray.length > 0) {
+            const cols = columnsArray.map(c => quoteColumnRef(c)).join(', ');
+            parts.push(`(${cols})`);
+        }
     }
     if (index.whereClause) {
         parts.push(`WHERE ${index.whereClause}`);
@@ -439,7 +660,7 @@ function generateCommentSQL(comment) {
     }
 }
 function generateFullSchemaSQL(schema, options = {}) {
-    const { includeExtensions = true, includeEnums = true, includeDomains = true, includeCompositeTypes = true, includeSequences = true, includeTables = true, includePartitions = true, includeIndexes = true, includeConstraints = true, includeFunctions = true, includeTriggers = true, headerComment, } = options;
+    const { includeExtensions = true, includeEnums = true, includeDomains = true, includeCompositeTypes = true, includeSequences = true, includeTables = true, includePartitions = true, includeIndexes = true, includeConstraints = true, includeFunctions = true, includeTriggers = true, includeComments = true, headerComment, ifNotExists = false, } = options;
     const sections = [];
     if (headerComment) {
         sections.push(`-- ${headerComment}\n`);
@@ -480,45 +701,113 @@ function generateFullSchemaSQL(schema, options = {}) {
         sections.push('');
     }
     if (includeTables && schema.tables && schema.tables.length > 0) {
-        sections.push('-- Tables');
-        for (const table of schema.tables) {
-            sections.push(generateTableSQL(table, { includeConstraints }));
-            sections.push('');
-        }
-    }
-    if (includePartitions && schema.partitions && schema.partitions.length > 0) {
-        sections.push('-- Partitions');
-        for (const partition of schema.partitions) {
-            sections.push(generatePartitionSQL(partition));
+        const partitionsByParent = new Map();
+        if (includePartitions && schema.partitions) {
+            for (const partition of schema.partitions) {
+                const parent = partition.parentTable;
+                if (!partitionsByParent.has(parent)) {
+                    partitionsByParent.set(parent, []);
+                }
+                partitionsByParent.get(parent).push(partition);
+            }
         }
-        sections.push('');
-    }
-    if (includeIndexes && schema.tables) {
-        const indexLines = [];
         for (const table of schema.tables) {
-            if (table.indexes && table.indexes.length > 0) {
+            const tableSection = [];
+            tableSection.push('-- ==================================================================');
+            tableSection.push(`--  TABLE: ${table.name}`);
+            tableSection.push('-- ==================================================================');
+            tableSection.push('');
+            tableSection.push('-- Table');
+            tableSection.push(generateTableSQL(table, { includeConstraints, ifNotExists }));
+            const tablePartitions = partitionsByParent.get(table.name);
+            if (tablePartitions && tablePartitions.length > 0) {
+                tableSection.push('');
+                tableSection.push(`-- Partitions for ${table.name}`);
+                for (const partition of tablePartitions) {
+                    tableSection.push(generatePartitionSQL(partition));
+                }
+            }
+            if (includeIndexes && table.indexes && table.indexes.length > 0) {
+                const uniqueConstraintNames = new Set((table.constraints || [])
+                    .filter(c => c.type === 'UNIQUE')
+                    .map(c => c.name));
+                const indexLines = [];
                 for (const index of table.indexes) {
-                    if (!index.isPrimary) {
-                        indexLines.push(generateIndexSQL(index, table.name));
+                    if (index.isPrimary)
+                        continue;
+                    if (index.isUnique && uniqueConstraintNames.has(index.name))
+                        continue;
+                    if (index.isUnique && (index.name.endsWith('_key') ||
+                        index.name.startsWith('unique_') ||
+                        uniqueConstraintNames.has(index.name.replace(/_key$/, ''))))
+                        continue;
+                    indexLines.push(generateIndexSQL(index, table.name, { ifNotExists }));
+                }
+                if (indexLines.length > 0) {
+                    tableSection.push('');
+                    tableSection.push(`-- Indexes for ${table.name}`);
+                    tableSection.push(indexLines.join('\n'));
+                }
+            }
+            if (includeComments) {
+                const commentLines = [];
+                if (table.comment) {
+                    commentLines.push(generateCommentSQL({
+                        objectType: 'table',
+                        objectName: table.name,
+                        comment: table.comment,
+                    }));
+                }
+                if (table.columns) {
+                    for (const col of table.columns) {
+                        if (col.comment) {
+                            commentLines.push(generateCommentSQL({
+                                objectType: 'column',
+                                objectName: table.name,
+                                subObjectName: col.name,
+                                comment: col.comment,
+                            }));
+                        }
                     }
                 }
+                if (table.indexes) {
+                    for (const idx of table.indexes) {
+                        if (idx.comment) {
+                            commentLines.push(generateCommentSQL({
+                                objectType: 'index',
+                                objectName: idx.name,
+                                comment: idx.comment,
+                            }));
+                        }
+                    }
+                }
+                if (commentLines.length > 0) {
+                    tableSection.push('');
+                    tableSection.push(`-- Comments for ${table.name}`);
+                    tableSection.push(commentLines.join('\n'));
+                }
             }
-        }
-        if (indexLines.length > 0) {
-            sections.push('-- Indexes');
-            sections.push(indexLines.join('\n'));
+            sections.push(tableSection.join('\n'));
+            sections.push('');
+            sections.push('');
             sections.push('');
         }
     }
     if (includeFunctions && schema.functions && schema.functions.length > 0) {
-        sections.push('-- Functions');
+        sections.push('-- ==================================================================');
+        sections.push('--  FUNCTIONS');
+        sections.push('-- ==================================================================');
+        sections.push('');
         for (const func of schema.functions) {
             sections.push(generateFunctionSQL(func));
             sections.push('');
         }
     }
     if (includeTriggers && schema.triggers && schema.triggers.length > 0) {
-        sections.push('-- Triggers');
+        sections.push('-- ==================================================================');
+        sections.push('--  TRIGGERS');
+        sections.push('-- ==================================================================');
+        sections.push('');
         for (const trigger of schema.triggers) {
             sections.push(generateTriggerSQL(trigger));
         }