pgsql-deparser 17.4.2 → 17.5.0

package/deparser.js

@@ -5057,6 +5057,18 @@ class Deparser {
                     : argValue;
                 return `${node.defname} = ${quotedValue}`;
             }
+            // Handle CopyStmt WITH clause options - uppercase format without quotes
+            if (context.parentNodeTypes.includes('CopyStmt')) {
+                if (node.defname === 'format' && node.arg && this.getNodeType(node.arg) === 'String') {
+                    const stringData = this.getNodeData(node.arg);
+                    return `FORMAT ${stringData.sval.toUpperCase()}`;
+                }
+                // Handle other COPY options with uppercase defname
+                if (node.arg) {
+                    return `${node.defname.toUpperCase()} ${argValue}`;
+                }
+                return node.defname.toUpperCase();
+            }
             // Handle CREATE OPERATOR and CREATE TYPE context
             if (context.parentNodeTypes.includes('DefineStmt')) {
                 const preservedName = this.preserveOperatorDefElemCase(node.defname);

package/esm/deparser.js

@@ -5054,6 +5054,18 @@ export class Deparser {
                     : argValue;
                 return `${node.defname} = ${quotedValue}`;
             }
+            // Handle CopyStmt WITH clause options - uppercase format without quotes
+            if (context.parentNodeTypes.includes('CopyStmt')) {
+                if (node.defname === 'format' && node.arg && this.getNodeType(node.arg) === 'String') {
+                    const stringData = this.getNodeData(node.arg);
+                    return `FORMAT ${stringData.sval.toUpperCase()}`;
+                }
+                // Handle other COPY options with uppercase defname
+                if (node.arg) {
+                    return `${node.defname.toUpperCase()} ${argValue}`;
+                }
+                return node.defname.toUpperCase();
+            }
             // Handle CREATE OPERATOR and CREATE TYPE context
             if (context.parentNodeTypes.includes('DefineStmt')) {
                 const preservedName = this.preserveOperatorDefElemCase(node.defname);

package/esm/utils/statement-splitter.js

@@ -0,0 +1,125 @@
+import { parse } from 'libpg-query';
+/**
+ * Extracts a single statement from SQL using PostgreSQL's location information.
+ * Handles Unicode properly by using byte positions instead of character positions.
+ */
+export function extractStatement(originalSQL, rawStmt, isFirst = false, options = {}) {
+    let extracted = null;
+    // Convert string to buffer to handle byte positions correctly (for Unicode)
+    const sqlBuffer = Buffer.from(originalSQL, 'utf8');
+    if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len !== undefined) {
+        // Use byte positions as provided by PostgreSQL
+        const startByte = rawStmt.stmt_location;
+        const endByte = rawStmt.stmt_location + rawStmt.stmt_len;
+        // Extract using byte positions and convert back to string
+        const extractedBuffer = sqlBuffer.slice(startByte, endByte);
+        extracted = extractedBuffer.toString('utf8');
+    }
+    else if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len === undefined) {
+        // We have location but no length - extract from location to end of file
+        const extractedBuffer = sqlBuffer.slice(rawStmt.stmt_location);
+        extracted = extractedBuffer.toString('utf8');
+    }
+    else if (isFirst && rawStmt.stmt_len !== undefined) {
+        // For first statement when location is missing but we have length
+        const extractedBuffer = sqlBuffer.slice(0, rawStmt.stmt_len);
+        extracted = extractedBuffer.toString('utf8');
+    }
+    else if (isFirst && rawStmt.stmt_location === undefined && rawStmt.stmt_len === undefined) {
+        // For first statement when both location and length are missing, use entire SQL
+        extracted = originalSQL;
+    }
+    if (extracted && options.stripComments !== false) {
+        // Split into lines to handle leading whitespace and comments properly
+        const lines = extracted.split('\n');
+        let startLineIndex = 0;
+        // Find the first line that contains actual SQL content
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            // Skip empty lines and comment-only lines
+            if (line === '' || line.startsWith('--')) {
+                continue;
+            }
+            startLineIndex = i;
+            break;
+        }
+        // Reconstruct from the first SQL line, preserving the original indentation of that line
+        if (startLineIndex < lines.length) {
+            const resultLines = lines.slice(startLineIndex);
+            extracted = resultLines.join('\n').trim();
+        }
+    }
+    // Final validation unless skipped
+    if (extracted && !options.skipValidation) {
+        const firstLine = extracted.split('\n')[0].trim();
+        const firstWord = firstLine.split(/\s+/)[0].toUpperCase();
+        // Only check for most obvious malformed patterns at the BEGINNING
+        if (
+        // Check if it starts with truncated patterns (not just contains anywhere)
+        extracted.trim().startsWith('ELECT ') || // Missing S from SELECT
+            extracted.trim().startsWith('REATE ') || // Missing C from CREATE  
+            extracted.trim().startsWith('NSERT ') || // Missing I from INSERT
+            // Completely empty or whitespace only
+            extracted.trim().length === 0) {
+            return null; // Invalid extraction, skip this statement
+        }
+    }
+    return extracted;
+}
+/**
+ * Splits SQL text into individual statements using PostgreSQL's parser.
+ * Handles Unicode characters properly and provides detailed location information.
+ */
+export async function splitStatements(sql, options = {}) {
+    const parseResult = await parse(sql);
+    const statements = [];
+    if (!parseResult.stmts) {
+        return statements;
+    }
+    for (let idx = 0; idx < parseResult.stmts.length; idx++) {
+        const stmt = parseResult.stmts[idx];
+        const extracted = extractStatement(sql, stmt, idx === 0, options);
+        if (extracted) {
+            statements.push({
+                statement: extracted,
+                index: idx,
+                location: stmt.stmt_location,
+                length: stmt.stmt_len
+            });
+        }
+    }
+    return statements;
+}
+/**
+ * Utility to generate statement keys for fixtures
+ */
+export function generateStatementKey(relativePath, statementIndex, extension = 'sql') {
+    return `${relativePath.replace(/\.sql$/, '')}-${statementIndex + 1}.${extension}`;
+}
+/**
+ * Test utility to compare byte vs character extraction for debugging Unicode issues
+ */
+export function debugUnicodeExtraction(sql, rawStmt) {
+    const charLength = sql.length;
+    const byteLength = Buffer.from(sql, 'utf8').length;
+    // Character-based extraction (old way)
+    let characterBased = '';
+    if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len !== undefined) {
+        characterBased = sql.substring(rawStmt.stmt_location, rawStmt.stmt_location + rawStmt.stmt_len);
+    }
+    // Byte-based extraction (new way)
+    let byteBased = '';
+    if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len !== undefined) {
+        const sqlBuffer = Buffer.from(sql, 'utf8');
+        const extractedBuffer = sqlBuffer.slice(rawStmt.stmt_location, rawStmt.stmt_location + rawStmt.stmt_len);
+        byteBased = extractedBuffer.toString('utf8');
+    }
+    return {
+        characterBased,
+        byteBased,
+        matches: characterBased === byteBased,
+        unicodeChars: byteLength - charLength,
+        byteLength,
+        charLength
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-deparser",
-  "version": "17.4.2",
+  "version": "17.5.0",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "PostgreSQL AST Deparser",
   "main": "index.js",
@@ -30,6 +30,7 @@
     "fixtures:ast": "ts-node scripts/make-fixtures-ast.ts",
     "fixtures:sql": "ts-node scripts/make-fixtures-sql.ts",
     "fixtures": "ts-node scripts/make-fixtures.ts",
+    "fixtures:upstream-diff": "ts-node scripts/make-upstream-diff.ts",
     "lint": "eslint . --fix",
     "test": "jest",
     "test:watch": "jest --watch"
@@ -50,5 +51,5 @@
   "dependencies": {
     "@pgsql/types": "^17.4.2"
   },
-  "gitHead": "f305d4e2e2c776ab97e6f28e9c78852492b96d24"
+  "gitHead": "a066ec74d2840bcf75bc0f975475508180a621fc"
 }

package/utils/statement-splitter.d.ts

@@ -0,0 +1,38 @@
+import { RawStmt } from '@pgsql/types';
+export interface ExtractedStatement {
+    statement: string;
+    index: number;
+    location?: number;
+    length?: number;
+}
+export interface StatementSplitterOptions {
+    /** Skip validation for malformed statements */
+    skipValidation?: boolean;
+    /** Strip leading comments from extracted statements */
+    stripComments?: boolean;
+}
+/**
+ * Extracts a single statement from SQL using PostgreSQL's location information.
+ * Handles Unicode properly by using byte positions instead of character positions.
+ */
+export declare function extractStatement(originalSQL: string, rawStmt: RawStmt, isFirst?: boolean, options?: StatementSplitterOptions): string | null;
+/**
+ * Splits SQL text into individual statements using PostgreSQL's parser.
+ * Handles Unicode characters properly and provides detailed location information.
+ */
+export declare function splitStatements(sql: string, options?: StatementSplitterOptions): Promise<ExtractedStatement[]>;
+/**
+ * Utility to generate statement keys for fixtures
+ */
+export declare function generateStatementKey(relativePath: string, statementIndex: number, extension?: string): string;
+/**
+ * Test utility to compare byte vs character extraction for debugging Unicode issues
+ */
+export declare function debugUnicodeExtraction(sql: string, rawStmt: RawStmt): {
+    characterBased: string;
+    byteBased: string;
+    matches: boolean;
+    unicodeChars: number;
+    byteLength: number;
+    charLength: number;
+};

package/utils/statement-splitter.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractStatement = extractStatement;
+exports.splitStatements = splitStatements;
+exports.generateStatementKey = generateStatementKey;
+exports.debugUnicodeExtraction = debugUnicodeExtraction;
+const libpg_query_1 = require("libpg-query");
+/**
+ * Extracts a single statement from SQL using PostgreSQL's location information.
+ * Handles Unicode properly by using byte positions instead of character positions.
+ */
+function extractStatement(originalSQL, rawStmt, isFirst = false, options = {}) {
+    let extracted = null;
+    // Convert string to buffer to handle byte positions correctly (for Unicode)
+    const sqlBuffer = Buffer.from(originalSQL, 'utf8');
+    if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len !== undefined) {
+        // Use byte positions as provided by PostgreSQL
+        const startByte = rawStmt.stmt_location;
+        const endByte = rawStmt.stmt_location + rawStmt.stmt_len;
+        // Extract using byte positions and convert back to string
+        const extractedBuffer = sqlBuffer.slice(startByte, endByte);
+        extracted = extractedBuffer.toString('utf8');
+    }
+    else if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len === undefined) {
+        // We have location but no length - extract from location to end of file
+        const extractedBuffer = sqlBuffer.slice(rawStmt.stmt_location);
+        extracted = extractedBuffer.toString('utf8');
+    }
+    else if (isFirst && rawStmt.stmt_len !== undefined) {
+        // For first statement when location is missing but we have length
+        const extractedBuffer = sqlBuffer.slice(0, rawStmt.stmt_len);
+        extracted = extractedBuffer.toString('utf8');
+    }
+    else if (isFirst && rawStmt.stmt_location === undefined && rawStmt.stmt_len === undefined) {
+        // For first statement when both location and length are missing, use entire SQL
+        extracted = originalSQL;
+    }
+    if (extracted && options.stripComments !== false) {
+        // Split into lines to handle leading whitespace and comments properly
+        const lines = extracted.split('\n');
+        let startLineIndex = 0;
+        // Find the first line that contains actual SQL content
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            // Skip empty lines and comment-only lines
+            if (line === '' || line.startsWith('--')) {
+                continue;
+            }
+            startLineIndex = i;
+            break;
+        }
+        // Reconstruct from the first SQL line, preserving the original indentation of that line
+        if (startLineIndex < lines.length) {
+            const resultLines = lines.slice(startLineIndex);
+            extracted = resultLines.join('\n').trim();
+        }
+    }
+    // Final validation unless skipped
+    if (extracted && !options.skipValidation) {
+        const firstLine = extracted.split('\n')[0].trim();
+        const firstWord = firstLine.split(/\s+/)[0].toUpperCase();
+        // Only check for most obvious malformed patterns at the BEGINNING
+        if (
+        // Check if it starts with truncated patterns (not just contains anywhere)
+        extracted.trim().startsWith('ELECT ') || // Missing S from SELECT
+            extracted.trim().startsWith('REATE ') || // Missing C from CREATE  
+            extracted.trim().startsWith('NSERT ') || // Missing I from INSERT
+            // Completely empty or whitespace only
+            extracted.trim().length === 0) {
+            return null; // Invalid extraction, skip this statement
+        }
+    }
+    return extracted;
+}
+/**
+ * Splits SQL text into individual statements using PostgreSQL's parser.
+ * Handles Unicode characters properly and provides detailed location information.
+ */
+async function splitStatements(sql, options = {}) {
+    const parseResult = await (0, libpg_query_1.parse)(sql);
+    const statements = [];
+    if (!parseResult.stmts) {
+        return statements;
+    }
+    for (let idx = 0; idx < parseResult.stmts.length; idx++) {
+        const stmt = parseResult.stmts[idx];
+        const extracted = extractStatement(sql, stmt, idx === 0, options);
+        if (extracted) {
+            statements.push({
+                statement: extracted,
+                index: idx,
+                location: stmt.stmt_location,
+                length: stmt.stmt_len
+            });
+        }
+    }
+    return statements;
+}
+/**
+ * Utility to generate statement keys for fixtures
+ */
+function generateStatementKey(relativePath, statementIndex, extension = 'sql') {
+    return `${relativePath.replace(/\.sql$/, '')}-${statementIndex + 1}.${extension}`;
+}
+/**
+ * Test utility to compare byte vs character extraction for debugging Unicode issues
+ */
+function debugUnicodeExtraction(sql, rawStmt) {
+    const charLength = sql.length;
+    const byteLength = Buffer.from(sql, 'utf8').length;
+    // Character-based extraction (old way)
+    let characterBased = '';
+    if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len !== undefined) {
+        characterBased = sql.substring(rawStmt.stmt_location, rawStmt.stmt_location + rawStmt.stmt_len);
+    }
+    // Byte-based extraction (new way)
+    let byteBased = '';
+    if (rawStmt.stmt_location !== undefined && rawStmt.stmt_len !== undefined) {
+        const sqlBuffer = Buffer.from(sql, 'utf8');
+        const extractedBuffer = sqlBuffer.slice(rawStmt.stmt_location, rawStmt.stmt_location + rawStmt.stmt_len);
+        byteBased = extractedBuffer.toString('utf8');
+    }
+    return {
+        characterBased,
+        byteBased,
+        matches: characterBased === byteBased,
+        unicodeChars: byteLength - charLength,
+        byteLength,
+        charLength
+    };
+}