csv-sql-engine 0.3.1 → 0.3.2

package/dist/engine/engine.js

@@ -1,5 +1,5 @@
 import { check } from '@augment-vir/assert';
-import { awaitedBlockingMap, ensureErrorAndPrependMessage, wrapInTry, } from '@augment-vir/common';
+import { awaitedBlockingMap, ensureErrorAndPrependMessage, indent, wrapInTry, } from '@augment-vir/common';
 import { mkdir } from 'node:fs/promises';
 import { parseSqlite, rawSql } from 'sqlite-ast';
 import { SqlParseError, SqlUnsupportedOperationError } from '../errors/sql.error.js';
@@ -65,6 +65,6 @@ async function executeIndividualCommand(params) {
     }
     catch (error) {
         const errorAst = params.ast;
-        throw ensureErrorAndPrependMessage(error, `Failed to execute '${errorAst.variant || errorAst.type}' command.`);
+        throw ensureErrorAndPrependMessage(error, `Failed to execute '${errorAst.variant || errorAst.type}' command:\n\n${indent(JSON.stringify(params.ast, null, 4))}\n\n`);
     }
 }

package/dist/engine/handlers/row-delete.handler.js

@@ -1,7 +1,7 @@
 import { nameCsvTableFile, readCsvFile, readCsvHeaders, writeCsvFile } from '../../csv/csv-file.js';
-import { getAstType } from '../../util/ast-node.js';
+import { getAst } from '../../util/ast-node.js';
 import { sortValues } from '../../util/sort-values.js';
-import { findWhereMatches } from '../../util/where-matcher.js';
+import { findWhereMatches, MatchSort } from '../../util/where-matcher.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 /**
  * Handles deleting rows.
@@ -14,7 +14,11 @@ export const rowDeleteHandler = defineAstHandler({
         if (ast.variant !== 'delete') {
             return undefined;
         }
-        const tableName = getAstType(ast.from, 'identifier')?.name;
+        const tableName = getAst({
+            ast: ast.from,
+            property: 'type',
+            value: 'identifier',
+        })?.name;
         if (!tableName) {
             throw new Error('Missing table name.');
         }
@@ -27,10 +31,14 @@ export const rowDeleteHandler = defineAstHandler({
             csvContents,
             sanitizedTableName,
         });
-        const rowIndexesToDelete = findWhereMatches(ast.where, csvContents, tableFilePath);
+        const rowIndexesToDelete = findWhereMatches(ast.where, csvContents, tableFilePath, MatchSort.Descending);
         const returningRequirement = ast.returning;
         const sqlHeaders = returningRequirement?.map((column) => {
-            const columnNode = getAstType(column, 'identifier');
+            const columnNode = getAst({
+                ast: column,
+                property: 'type',
+                value: 'identifier',
+            });
             if (columnNode) {
                 return columnNode.name;
             }

package/dist/engine/handlers/row-select.handler.js

@@ -1,10 +1,11 @@
-import { check } from '@augment-vir/assert';
+import { check, checkWrap } from '@augment-vir/assert';
 import { filterMap } from '@augment-vir/common';
 import { nameCsvTableFile, readCsvFile, readCsvHeaders } from '../../csv/csv-file.js';
 import { SqlUnsupportedOperationError } from '../../errors/sql.error.js';
-import { getAstType } from '../../util/ast-node.js';
+import { getAst } from '../../util/ast-node.js';
+import { readAstText } from '../../util/ast-text.js';
 import { sortValues } from '../../util/sort-values.js';
-import { findWhereMatches } from '../../util/where-matcher.js';
+import { findWhereMatches, MatchSort } from '../../util/where-matcher.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 /**
  * Handles SQL selection.
@@ -17,7 +18,7 @@ export const rowSelectHandler = defineAstHandler({
         if (ast.variant !== 'select') {
             return undefined;
         }
-        const tableName = getAstType(ast.from, 'identifier')?.name;
+        const tableName = getAst({ ast: ast.from, property: 'type', value: 'identifier' })?.name;
         if (!tableName) {
             throw new Error('No table name.');
         }
@@ -30,9 +31,20 @@ export const rowSelectHandler = defineAstHandler({
             csvContents,
             sanitizedTableName,
         });
-        const rowIndexesToSelect = findWhereMatches(ast.where, csvContents, tableFilePath);
+        const limit = ast.limit ? checkWrap.isNumber(Number(readAstText(ast.limit.start))) : -1;
+        if (limit == undefined) {
+            throw new Error(`Unexpected limit: ${JSON.stringify(ast.limit)}`);
+        }
+        const offset = ast.limit?.offset
+            ? checkWrap.isNumber(Number(readAstText(ast.limit.offset)))
+            : 0;
+        if (offset == undefined) {
+            throw new Error(`Unexpected offset: ${JSON.stringify(ast.limit?.offset)}`);
+        }
+        const rawIndexes = findWhereMatches(ast.where, csvContents, tableFilePath, MatchSort.Ascending);
+        const rowIndexesToSelect = limit < 0 ? rawIndexes.slice(offset) : rawIndexes.slice(offset, offset + limit);
         const columnNames = filterMap(ast.result, (result) => {
-            return getAstType(result, 'identifier')?.name;
+            return getAst({ ast: result, property: 'type', value: 'identifier' })?.name;
         }, (value) => {
             if (check.isString(value)) {
                 return true;

package/dist/engine/handlers/row-update.handler.js

@@ -1,9 +1,9 @@
 import { assertWrap } from '@augment-vir/assert';
 import { createCsvHeaderMaps, nameCsvTableFile, readCsvFile, readCsvHeaders, writeCsvFile, } from '../../csv/csv-file.js';
 import { CsvColumnDoesNotExistError } from '../../errors/csv.error.js';
-import { getAstType } from '../../util/ast-node.js';
+import { getAst } from '../../util/ast-node.js';
 import { sortValues } from '../../util/sort-values.js';
-import { findWhereMatches } from '../../util/where-matcher.js';
+import { findWhereMatches, MatchSort } from '../../util/where-matcher.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 /**
  * Handles updating rows.
@@ -16,7 +16,7 @@ export const rowUpdateHandler = defineAstHandler({
         if (ast.variant !== 'update') {
             return undefined;
         }
-        const tableName = getAstType(ast.into, 'identifier')?.name;
+        const tableName = getAst({ ast: ast.into, property: 'type', value: 'identifier' })?.name;
         if (!tableName) {
             throw new Error('No table name');
         }
@@ -30,7 +30,7 @@ export const rowUpdateHandler = defineAstHandler({
             sanitizedTableName,
         });
         const csvHeaderIndexes = createCsvHeaderMaps(csvHeaders);
-        const rowIndexesToUpdate = findWhereMatches(ast.where, csvContents, tableFilePath);
+        const rowIndexesToUpdate = findWhereMatches(ast.where, csvContents, tableFilePath, MatchSort.Ascending);
         const returningRequirement = ast.returning;
         rowIndexesToUpdate.forEach((rowIndexToUpdate) => {
             const row = assertWrap.isTruthy(csvContents[rowIndexToUpdate], `Invalid row index '${rowIndexToUpdate}'.`);
@@ -40,7 +40,7 @@ export const rowUpdateHandler = defineAstHandler({
                 if (!headerIndex) {
                     throw new CsvColumnDoesNotExistError(sanitizedTableName, columnName);
                 }
-                const valueNode = getAstType(set.value, 'literal');
+                const valueNode = getAst({ ast: set.value, property: 'type', value: 'literal' });
                 if (!valueNode) {
                     throw new Error(`Unexpected set type: ${set.value.type}`);
                 }
@@ -48,7 +48,7 @@ export const rowUpdateHandler = defineAstHandler({
             });
         });
         const sqlHeaders = returningRequirement?.map((column) => {
-            const columnNode = getAstType(column, 'identifier');
+            const columnNode = getAst({ ast: column, property: 'type', value: 'identifier' });
             if (columnNode) {
                 return columnNode.name;
             }

package/dist/engine/handlers/table-alter.handler.js

@@ -5,7 +5,7 @@ import { rename } from 'node:fs/promises';
 import { nameCsvTableFile, readCsvFile, readCsvHeaders, writeCsvFile } from '../../csv/csv-file.js';
 import { CsvColumnDoesNotExistError, CsvTableDoesNotExistError } from '../../errors/csv.error.js';
 import { SqlUnsupportedOperationError } from '../../errors/sql.error.js';
-import { getAstType } from '../../util/ast-node.js';
+import { getAst } from '../../util/ast-node.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 /**
  * Handles altering tables.
@@ -33,7 +33,7 @@ export const tableAlterHandler = defineAstHandler({
             sanitizedTableName,
         });
         if (ast.action === 'rename') {
-            const newTableName = assertWrap.isTruthy(getAstType(ast.name, 'identifier')?.name, 'Missing new table name.');
+            const newTableName = assertWrap.isTruthy(getAst({ ast: ast.name, property: 'type', value: 'identifier' })?.name, 'Missing new table name.');
             await rename(tableFilePath, nameCsvTableFile({ csvDirPath, tableName: newTableName }).tableFilePath);
             return {
                 columnNames: [],
@@ -45,7 +45,11 @@ export const tableAlterHandler = defineAstHandler({
             if (!ast.definition || ast.definition.type !== 'definition') {
                 return;
             }
-            const defaultValue = getAstType(ast.definition.definition.find((entry) => entry.type === 'constraint' && entry.variant === 'default')?.value, 'literal')?.value || '';
+            const defaultValue = getAst({
+                ast: ast.definition.definition.find((entry) => entry.type === 'constraint' && entry.variant === 'default')?.value,
+                property: 'type',
+                value: 'literal',
+            })?.value || '';
             const newHeaderName = assertWrap.isTruthy(ast.definition.name, 'Missing new column name.');
             csvContents.forEach((row, index) => {
                 if (index) {

package/dist/util/ast-node.d.ts

@@ -1,10 +1,6 @@
 import { type SqliteAstNode } from 'sqlite-ast';
-/** @throws If the request type is not there. */
-export declare function getAstType<const Ast extends SqliteAstNode | undefined, const TypeName extends NonNullable<Ast>['type']>(node: Ast, typeName: TypeName): Extract<Ast, {
-    type: TypeName;
-}> | undefined;
-export declare function getAstVariant<const Ast extends Extract<SqliteAstNode, {
-    variant: string;
-}> | undefined, const VariantName extends NonNullable<Ast>['variant']>(node: Ast, variant: VariantName): Extract<Ast, {
-    variant: VariantName;
-}> | undefined;
+export declare function getAst<const Ast extends (SqliteAstNode & Record<PropertyToCheck, any>) | undefined, const PropertyToCheck extends string, const ValueToCheck>({ ast, property, value, }: {
+    ast: Ast;
+    property: PropertyToCheck;
+    value: ValueToCheck;
+}): Extract<Ast, Record<PropertyToCheck, ValueToCheck>> | undefined;

package/dist/util/ast-node.js

@@ -1,21 +1,9 @@
-/** @throws If the request type is not there. */
-export function getAstType(node, typeName) {
-    if (!node) {
+export function getAst({ ast, property, value, }) {
+    if (!ast) {
         return undefined;
     }
-    else if (node.type === typeName) {
-        return node;
-    }
-    else {
-        return undefined;
-    }
-}
-export function getAstVariant(node, variant) {
-    if (!node) {
-        return undefined;
-    }
-    else if (node.variant === variant) {
-        return node;
+    else if (ast[property] === value) {
+        return ast;
     }
     else {
         return undefined;

package/dist/util/ast-text.d.ts

@@ -0,0 +1,7 @@
+import { type SqliteAstNode } from 'sqlite-ast';
+/**
+ * Recursively converts an AST node back to its SQL text representation.
+ *
+ * @category Internal
+ */
+export declare function readAstText(node: SqliteAstNode | null | undefined): string;

package/dist/util/ast-text.js

@@ -0,0 +1,649 @@
+/**
+ * Recursively converts an AST node back to its SQL text representation.
+ *
+ * @category Internal
+ */
+export function readAstText(node) {
+    if (!node) {
+        return '';
+    }
+    switch (node.type) {
+        case 'literal':
+            return readLiteralText(node);
+        case 'identifier':
+            return readIdentifierText(node);
+        case 'expression':
+            return readExpressionText(node);
+        case 'function':
+            return readFunctionText(node);
+        case 'statement':
+            return readStatementText(node);
+        case 'constraint':
+            return readConstraintText(node);
+        case 'definition':
+            return readDefinitionText(node);
+        case 'condition':
+            return readConditionText(node);
+        case 'join':
+            return readJoinText(node);
+        case 'map':
+            return readMapText(node);
+        case 'assignment':
+            return readAssignmentText(node);
+        case 'compound':
+            return readCompoundText(node);
+        case 'datatype':
+            return readDatatypeText(node);
+        case 'variable':
+            return readVariableText(node);
+        case 'values':
+            return 'DEFAULT VALUES';
+        case 'error':
+            return readErrorText(node);
+        case 'event':
+            return readEventText(node);
+        case 'module':
+            return readModuleText(node);
+        default:
+            // Fallback for any unhandled type
+            return '';
+    }
+}
+function readLiteralText(node) {
+    if (node.variant === 'text') {
+        return `'${node.value}'`;
+    }
+    else if (node.variant === 'null') {
+        return 'NULL';
+    }
+    else if (node.variant === 'blob') {
+        return node.value;
+    }
+    return node.value;
+}
+function readIdentifierText(node) {
+    let text = node.name;
+    if (node.columns) {
+        text += `(${readNodeArray(node.columns)})`;
+    }
+    if (node.alias) {
+        text += ` AS ${node.alias}`;
+    }
+    return text;
+}
+function readExpressionText(node) {
+    if ('format' in node) {
+        if (node.format === 'binary') {
+            const left = readAstText(node.left);
+            const right = readAstText(node.right);
+            let text = `${left} ${node.operation.toUpperCase()} ${right}`;
+            if (node.escape) {
+                text += ` ESCAPE ${readAstText(node.escape)}`;
+            }
+            return withAlias(text, node);
+        }
+        else if (node.format === 'unary') {
+            if (node.variant === 'operation') {
+                if ('collate' in node) {
+                    const expr = readAstText(node.expression);
+                    const collation = node.collate.map((c) => c.name).join(' ');
+                    return `${expr} COLLATE ${collation}`;
+                }
+                const expr = readAstText(node.expression);
+                const op = node.operator.toUpperCase();
+                // Prefix operators like NOT, -, +, ~
+                if (op === '-' || op === '+' || op === '~') {
+                    return withAlias(`${op}${expr}`, node);
+                }
+                if (op === 'NOT') {
+                    return withAlias(`${op} ${expr}`, node);
+                }
+                return withAlias(`${expr} ${op}`, node);
+            }
+            else if (node.variant === 'cast') {
+                const expr = readAstText(node.expression);
+                const datatype = readDatatypeText(node.as);
+                return withAlias(`CAST(${expr} AS ${datatype})`, node);
+            }
+            // exists variant
+            const expr = readAstText(node.expression);
+            return `${node.operator.toUpperCase()} ${expr}`;
+        }
+        // table format
+        const target = readAstText(node.target);
+        const expr = readAstText(node.expression);
+        const variant = node.variant === 'recursive' ? 'RECURSIVE' : '';
+        return `${target} AS ${variant}(${expr})`.trim();
+    }
+    switch (node.variant) {
+        case 'list':
+            return readExpressionList(node.expression);
+        case 'order': {
+            const expr = readAstText(node.expression);
+            const dir = node.direction ? ` ${node.direction.toUpperCase()}` : '';
+            return `${expr}${dir}`;
+        }
+        case 'limit': {
+            const start = readAstText(node.start);
+            const offset = node.offset ? ` OFFSET ${readAstText(node.offset)}` : '';
+            return `${start}${offset}`;
+        }
+        case 'exists':
+            return node.operator.toUpperCase();
+        case 'case':
+            return withAlias(readCaseText(node.expression), node);
+        default:
+            return '';
+    }
+}
+function readExpressionList(expression) {
+    if (expression == null) {
+        return '';
+    }
+    if (Array.isArray(expression)) {
+        return expression.map(readAstText).join(', ');
+    }
+    return readAstText(expression);
+}
+function readCaseText(conditions) {
+    const parts = conditions.map((cond) => {
+        if (cond.type === 'condition') {
+            if (cond.variant === 'when') {
+                return `WHEN ${readAstText(cond.condition)} THEN ${readAstText(cond.consequent)}`;
+            }
+            else if (cond.variant === 'else') {
+                return `ELSE ${readAstText(cond.consequent)}`;
+            }
+        }
+        return '';
+    });
+    return `CASE ${parts.join(' ')} END`;
+}
+function readFunctionText(node) {
+    const name = node.name.name.toUpperCase();
+    let args;
+    if (node.args.type === 'identifier') {
+        args = '*';
+    }
+    else {
+        args = readExpressionList(node.args.expression);
+    }
+    const text = `${name}(${args})`;
+    return withAlias(text, node);
+}
+function readStatementText(node) {
+    switch (node.variant) {
+        case 'select':
+            return readSelectText(node);
+        case 'insert':
+            return readInsertText(node);
+        case 'update':
+            return readUpdateText(node);
+        case 'delete':
+            return readDeleteText(node);
+        case 'create':
+            return readCreateText(node);
+        case 'drop':
+            return readDropText(node);
+        case 'compound':
+            return readCompoundStatementText(node);
+        case 'transaction':
+            return readTransactionText(node);
+        case 'alter table':
+            return readAlterTableText(node);
+        case 'pragma':
+            return readPragmaText(node);
+        case 'attach':
+            return readAttachText(node);
+        case 'detach':
+            return readDetachText(node);
+        case 'vacuum':
+            return readVacuumText(node);
+        case 'reindex':
+            return readReindexText(node);
+        case 'analyze':
+            return readAnalyzeText(node);
+        case 'release':
+        case 'savepoint':
+            return readSavepointText(node);
+        default:
+            return '';
+    }
+}
+function readSelectText(node) {
+    const parts = [];
+    if (node.with) {
+        parts.push(`WITH ${readNodeArray(node.with)}`);
+    }
+    parts.push('SELECT');
+    if (node.distinct) {
+        parts.push('DISTINCT');
+    }
+    parts.push(readNodeArray(node.result));
+    if (node.from) {
+        parts.push(`FROM ${readAstText(node.from)}`);
+    }
+    if (node.where) {
+        parts.push(`WHERE ${readNodeArray(node.where, ' AND ')}`);
+    }
+    if (node.group) {
+        parts.push(`GROUP BY ${readExpressionList(node.group.expression)}`);
+    }
+    if (node.having) {
+        parts.push(`HAVING ${readAstText(node.having)}`);
+    }
+    if (node.order) {
+        parts.push(`ORDER BY ${readNodeArray(node.order)}`);
+    }
+    if (node.limit) {
+        parts.push(`LIMIT ${readAstText(node.limit)}`);
+    }
+    return withAlias(parts.join(' '), node);
+}
+function readInsertText(node) {
+    const parts = [];
+    if (node.or) {
+        parts.push(`INSERT OR ${node.or.toUpperCase()}`);
+    }
+    else {
+        parts.push('INSERT');
+    }
+    parts.push(`INTO ${readAstText(node.into)}`);
+    if (Array.isArray(node.result)) {
+        const values = node.result
+            .map((r) => {
+            const expr = r.expression;
+            return `(${readExpressionList(expr)})`;
+        })
+            .join(', ');
+        parts.push(`VALUES ${values}`);
+    }
+    else if ('type' in node.result && node.result.type === 'values') {
+        parts.push('DEFAULT VALUES');
+    }
+    else {
+        parts.push(readAstText(node.result));
+    }
+    if (node.returning) {
+        parts.push(`RETURNING ${readNodeArray(node.returning)}`);
+    }
+    return parts.join(' ');
+}
+function readUpdateText(node) {
+    const parts = [];
+    if (node.or) {
+        parts.push(`UPDATE OR ${node.or.toUpperCase()}`);
+    }
+    else {
+        parts.push('UPDATE');
+    }
+    parts.push(readAstText(node.into));
+    const setClause = node.set.map((s) => readAssignmentText(s)).join(', ');
+    parts.push(`SET ${setClause}`);
+    if (node.where) {
+        parts.push(`WHERE ${readNodeArray(node.where, ' AND ')}`);
+    }
+    if (node.limit) {
+        parts.push(`LIMIT ${readAstText(node.limit)}`);
+    }
+    if (node.returning) {
+        parts.push(`RETURNING ${readNodeArray(node.returning)}`);
+    }
+    return parts.join(' ');
+}
+function readDeleteText(node) {
+    const parts = [
+        'DELETE FROM',
+        readAstText(node.from),
+    ];
+    if (node.where) {
+        parts.push(`WHERE ${readNodeArray(node.where, ' AND ')}`);
+    }
+    if (node.limit) {
+        parts.push(`LIMIT ${readAstText(node.limit)}`);
+    }
+    if (node.returning) {
+        parts.push(`RETURNING ${readNodeArray(node.returning)}`);
+    }
+    return parts.join(' ');
+}
+function readCreateText(node) {
+    const parts = ['CREATE'];
+    if (node.temporary) {
+        parts.push('TEMPORARY');
+    }
+    if (node.unique) {
+        parts.push('UNIQUE');
+    }
+    parts.push(node.format.toUpperCase());
+    if (node.condition) {
+        parts.push('IF NOT EXISTS');
+    }
+    if (node.name) {
+        parts.push(readAstText(node.name));
+    }
+    if (node.format === 'table' && node.definition) {
+        parts.push(`(${readNodeArray(node.definition)})`);
+    }
+    if (node.format === 'index' && node.on) {
+        parts.push(`ON ${readAstText(node.on)}`);
+    }
+    if (node.format === 'view' && node.result) {
+        parts.push(`AS ${readAstText(node.result)}`);
+    }
+    if (node.format === 'trigger') {
+        if (node.event) {
+            parts.push(readEventText(node.event));
+        }
+        if (node.on) {
+            parts.push(`ON ${readAstText(node.on)}`);
+        }
+        if (node.by) {
+            parts.push(`FOR EACH ${node.by.toUpperCase()}`);
+        }
+        if (node.when) {
+            parts.push(`WHEN ${readAstText(node.when)}`);
+        }
+        if (node.action) {
+            parts.push(`BEGIN ${readNodeArray(node.action, '; ')}; END`);
+        }
+    }
+    return parts.join(' ');
+}
+function readDropText(node) {
+    const parts = [
+        'DROP',
+        node.format.toUpperCase(),
+    ];
+    if (node.condition.length > 0) {
+        parts.push('IF EXISTS');
+    }
+    parts.push(readAstText(node.target));
+    return parts.join(' ');
+}
+function readCompoundStatementText(node) {
+    const first = readAstText(node.statement);
+    const rest = node.compound.map((c) => `${c.variant.toUpperCase()} ${readAstText(c.statement)}`);
+    return [
+        first,
+        ...rest,
+    ].join(' ');
+}
+function readTransactionText(node) {
+    const parts = [node.action.toUpperCase()];
+    if (node.defer) {
+        parts.push(node.defer.toUpperCase());
+    }
+    parts.push('TRANSACTION');
+    if (node.savepoint) {
+        parts.push(node.savepoint.name);
+    }
+    return parts.join(' ');
+}
+function readAlterTableText(node) {
+    const parts = [
+        'ALTER TABLE',
+        readAstText(node.target),
+    ];
+    if (node.action === 'rename') {
+        if (node.column && node.newName) {
+            parts.push(`RENAME COLUMN ${node.column} TO ${node.newName}`);
+        }
+        else if (node.newName) {
+            parts.push(`RENAME TO ${node.newName}`);
+        }
+    }
+    else if (node.action === 'add') {
+        if (node.definition) {
+            parts.push(`ADD COLUMN ${readAstText(node.definition)}`);
+        }
+        else if (node.name) {
+            parts.push(`ADD COLUMN ${readAstText(node.name)}`);
+        }
+    }
+    else if (node.action === 'drop' && node.column) {
+        parts.push(`DROP COLUMN ${node.column}`);
+    }
+    return parts.join(' ');
+}
+function readPragmaText(node) {
+    const name = node.target.name;
+    if (node.args.expression) {
+        return `PRAGMA ${name} = ${readAstText(node.args.expression)}`;
+    }
+    return `PRAGMA ${name}`;
+}
+function readAttachText(node) {
+    return `ATTACH ${readAstText(node.target)} AS ${readAstText(node.attach)}`;
+}
+function readDetachText(node) {
+    return `DETACH ${node.target.name}`;
+}
+function readVacuumText(node) {
+    if (node.target) {
+        return `VACUUM ${node.target.name}`;
+    }
+    return 'VACUUM';
+}
+function readReindexText(node) {
+    if (node.target) {
+        return `REINDEX ${node.target}`;
+    }
+    return 'REINDEX';
+}
+function readAnalyzeText(node) {
+    if (node.target) {
+        return `ANALYZE ${node.target}`;
+    }
+    return 'ANALYZE';
+}
+function readSavepointText(node) {
+    const action = node.variant === 'release' ? 'RELEASE' : 'SAVEPOINT';
+    return `${action} ${node.target.savepoint.name}`;
+}
+function readConstraintText(node) {
+    const parts = [];
+    switch (node.variant) {
+        case 'primary key':
+            if (node.name) {
+                parts.push(`CONSTRAINT ${node.name}`);
+            }
+            parts.push('PRIMARY KEY');
+            if (node.direction) {
+                parts.push(node.direction.toUpperCase());
+            }
+            if (node.conflict) {
+                parts.push(`ON CONFLICT ${node.conflict.toUpperCase()}`);
+            }
+            if (node.autoIncrement) {
+                parts.push('AUTOINCREMENT');
+            }
+            break;
+        case 'not null':
+            if (node.name) {
+                parts.push(`CONSTRAINT ${node.name}`);
+            }
+            parts.push('NOT NULL');
+            if (node.conflict) {
+                parts.push(`ON CONFLICT ${node.conflict.toUpperCase()}`);
+            }
+            break;
+        case 'null':
+            if (node.name) {
+                parts.push(`CONSTRAINT ${node.name}`);
+            }
+            parts.push('NULL');
+            break;
+        case 'unique':
+            if (node.name) {
+                parts.push(`CONSTRAINT ${node.name}`);
+            }
+            parts.push('UNIQUE');
+            if (node.conflict) {
+                parts.push(`ON CONFLICT ${node.conflict.toUpperCase()}`);
+            }
+            break;
+        case 'check':
+            if (node.name) {
+                parts.push(`CONSTRAINT ${node.name}`);
+            }
+            parts.push(`CHECK (${readAstText(node.expression)})`);
+            break;
+        case 'default':
+            if (node.name) {
+                parts.push(`CONSTRAINT ${node.name}`);
+            }
+            parts.push(`DEFAULT ${readAstText(node.value)}`);
+            break;
+        case 'foreign key':
+            if (node.name) {
+                parts.push(`CONSTRAINT ${node.name}`);
+            }
+            parts.push(`REFERENCES ${readAstText(node.references)}`);
+            if (node.action) {
+                for (const act of node.action) {
+                    parts.push(`ON ${act.variant.toUpperCase()} ${act.action.toUpperCase()}`);
+                }
+            }
+            if (node.defer) {
+                parts.push(node.defer.toUpperCase());
+            }
+            break;
+        case 'collate':
+            if (node.name) {
+                parts.push(`CONSTRAINT ${node.name}`);
+            }
+            parts.push(`COLLATE ${node.collate.collate.map((c) => c.name).join(' ')}`);
+            break;
+        case 'join':
+            parts.push(node.format.toUpperCase());
+            if (node.on) {
+                parts.push(`ON ${readAstText(node.on)}`);
+            }
+            if (node.using) {
+                const cols = node.using.columns.map((c) => c.name).join(', ');
+                parts.push(`USING (${cols})`);
+            }
+            break;
+    }
+    return parts.join(' ');
+}
+function readDefinitionText(node) {
+    if (node.variant === 'column') {
+        const parts = [node.name];
+        parts.push(readDatatypeText(node.datatype));
+        if (node.definition.length > 0) {
+            parts.push(readNodeArray(node.definition, ' '));
+        }
+        return parts.join(' ');
+    }
+    // constraint variant
+    const parts = [];
+    if (node.name) {
+        parts.push(`CONSTRAINT ${node.name}`);
+    }
+    if (node.columns) {
+        parts.push(`(${readNodeArray(node.columns)})`);
+    }
+    if (node.definition.length > 0) {
+        parts.push(readNodeArray(node.definition, ' '));
+    }
+    return parts.join(' ');
+}
+function readConditionText(node) {
+    switch (node.variant) {
+        case 'when':
+            return `WHEN ${readAstText(node.condition)} THEN ${readAstText(node.consequent)}`;
+        case 'else':
+            return `ELSE ${readAstText(node.consequent)}`;
+        case 'if':
+            return `IF ${readAstText(node.condition)}`;
+        default:
+            return '';
+    }
+}
+function readJoinText(node) {
+    const parts = [];
+    parts.push(node.variant.toUpperCase());
+    parts.push(readAstText(node.source));
+    if (node.constraint) {
+        parts.push(readAstText(node.constraint));
+    }
+    return parts.join(' ');
+}
+function readMapText(node) {
+    const source = readAstText(node.source);
+    const joins = node.map.map(readAstText).join(' ');
+    return `${source} ${joins}`;
+}
+function readAssignmentText(node) {
+    return `${node.target.name} = ${readAstText(node.value)}`;
+}
+function readCompoundText(node) {
+    return `${node.variant.toUpperCase()} ${readAstText(node.statement)}`;
+}
+function readDatatypeText(node) {
+    let text = node.variant.toUpperCase();
+    if (node.args) {
+        text += `(${readExpressionList(node.args.expression)})`;
+    }
+    return text;
+}
+function readVariableText(node) {
+    let text;
+    switch (node.format) {
+        case 'named':
+            text = `:${node.name}`;
+            break;
+        case 'numbered':
+            text = `?${node.name}`;
+            break;
+        case 'tcl':
+            text = `$${node.name}`;
+            break;
+        default:
+            text = `?`;
+    }
+    if (node.suffix) {
+        text += node.suffix;
+    }
+    return text;
+}
+function readErrorText(node) {
+    const parts = ['RAISE'];
+    if (node.action) {
+        parts.push(`(${node.action.toUpperCase()}`);
+        if (node.message) {
+            parts.push(`, ${readAstText(node.message)}`);
+        }
+        parts.push(')');
+    }
+    return parts.join('');
+}
+function readEventText(node) {
+    const parts = [];
+    if (node.occurs) {
+        parts.push(node.occurs.toUpperCase());
+    }
+    parts.push(node.event.toUpperCase());
+    if (node.of) {
+        parts.push(`OF ${readNodeArray(node.of)}`);
+    }
+    return parts.join(' ');
+}
+function readModuleText(node) {
+    const args = readExpressionList(node.args.expression);
+    return `USING ${node.name}(${args})`;
+}
+function readNodeArray(nodes, separator = ', ') {
+    if (!nodes) {
+        return '';
+    }
+    return nodes.map(readAstText).join(separator);
+}
+function withAlias(text, node) {
+    if (node.alias) {
+        return `${text} AS ${node.alias}`;
+    }
+    return text;
+}

package/dist/util/sort-values.js

@@ -1,18 +1,28 @@
+/**
+ * Extracts the column name from a potentially fully qualified identifier. E.g., `main.users.email`
+ * -> `email`, `users.email` -> `email`, `email` -> `email`
+ */
+function extractColumnName(header) {
+    const parts = header.split('.');
+    return parts[parts.length - 1] || header;
+}
 /**
  * Sorts values for CSV insertion or reading and handle interpolated values.
  *
  * @category Internal
  */
 export function sortValues({ csvFileHeaderOrder, sqlQueryHeaderOrder, from, unconsumedInterpolationValues, }) {
-    const fromOrder = from.sqlQuery ? sqlQueryHeaderOrder : csvFileHeaderOrder;
-    const toOrder = (from.sqlQuery ? csvFileHeaderOrder : sqlQueryHeaderOrder).flatMap((header) => {
+    const fromOrder = (from.sqlQuery ? sqlQueryHeaderOrder : csvFileHeaderOrder).map(extractColumnName);
+    const toOrder = (from.sqlQuery ? csvFileHeaderOrder : sqlQueryHeaderOrder)
+        .flatMap((header) => {
         if (header === '*') {
             return csvFileHeaderOrder;
         }
         else {
             return header;
         }
-    });
+    })
+        .map(extractColumnName);
     const values = (from.csvFile || from.sqlQuery).map((valueRow) => {
         const mappedValueRow = valueRow.map((value) => {
             if (value === '?') {

package/dist/util/where-matcher.d.ts

@@ -1,10 +1,21 @@
 import { type MaybeArray } from '@augment-vir/common';
 import { type SqliteAstNode } from 'sqlite-ast';
 import { type CsvFile } from '../csv/csv-file.js';
+/**
+ * Used to determine how matches returned from {@link findWhereMatches} should be sorted.
+ *
+ * @category Internal
+ */
+export declare enum MatchSort {
+    /** 0 index first */
+    Ascending = "ascending",
+    /** 0 index last */
+    Descending = "descending"
+}
 /**
  * Finds all row indexes that match the given SQL where conditions.
  *
  * @category Internal
  * @returns An array of row indexes that match the given where condition.
  */
-export declare function findWhereMatches(expressions: Readonly<MaybeArray<Readonly<SqliteAstNode>>> | undefined, csvContents: Readonly<CsvFile>, csvFilePath: string): number[];
+export declare function findWhereMatches(expressions: Readonly<MaybeArray<Readonly<SqliteAstNode>>> | undefined, csvContents: Readonly<CsvFile>, csvFilePath: string, sort: MatchSort): number[];

package/dist/util/where-matcher.js

@@ -1,23 +1,46 @@
+import { check } from '@augment-vir/assert';
 import { ensureArray, extractDuplicates, filterMap, removeDuplicates, removeSuffix, } from '@augment-vir/common';
 import { csvExtension } from '../csv/csv-file.js';
 import { CsvColumnDoesNotExistError, CsvFileMissingHeadersError } from '../errors/csv.error.js';
+/**
+ * Used to determine how matches returned from {@link findWhereMatches} should be sorted.
+ *
+ * @category Internal
+ */
+export var MatchSort;
+(function (MatchSort) {
+    /** 0 index first */
+    MatchSort["Ascending"] = "ascending";
+    /** 0 index last */
+    MatchSort["Descending"] = "descending";
+})(MatchSort || (MatchSort = {}));
 /**
  * Finds all row indexes that match the given SQL where conditions.
  *
  * @category Internal
  * @returns An array of row indexes that match the given where condition.
  */
-export function findWhereMatches(expressions, csvContents, csvFilePath) {
-    /**
-     * These must be sorted from greatest to least so that deleting rows does not mess up the
-     * indexes.
-     */
-    const allIndexes = removeDuplicates((expressions ? ensureArray(expressions) : [undefined]).flatMap((expression) => innerFindWhereMatches(expression, csvContents, csvFilePath))).sort((a, b) => b - a);
+export function findWhereMatches(expressions, csvContents, csvFilePath, sort) {
+    const allIndexes = removeDuplicates((expressions ? ensureArray(expressions) : [undefined]).flatMap((expression) => innerFindWhereMatches(expression, csvContents, csvFilePath))).sort((a, b) => {
+        if (sort === MatchSort.Descending) {
+            return b - a;
+        }
+        else {
+            return a - b;
+        }
+    });
     return allIndexes;
 }
+function getAllIndexes(csvContents) {
+    return csvContents
+        .map((value, index) => index)
+        .filter(
+    /** Exclude the first index, which is headers. */
+    check.isTruthy);
+}
 function innerFindWhereMatches(where, csvContents, csvFilePath) {
     if (!where) {
-        return csvContents.map((value, index) => index);
+        return getAllIndexes(csvContents);
     }
     else if (where.type === 'expression' &&
         where.variant === 'operation' &&
@@ -39,6 +62,17 @@ function innerFindWhereMatches(where, csvContents, csvFilePath) {
             if (!headers) {
                 throw new CsvFileMissingHeadersError(csvFilePath);
             }
+            /** Handle no-op WHERE clauses like `1=1` that always evaluate to true. */
+            if (where.left.type === 'literal' && where.right.type === 'literal') {
+                if (where.left.value === where.right.value) {
+                    /** Always true - return all rows (excluding headers). */
+                    return getAllIndexes(csvContents);
+                }
+                else {
+                    /** Always false - return no rows. */
+                    return [];
+                }
+            }
             if (where.left.type !== 'identifier' || where.left.variant !== 'column') {
                 throw new Error(`Expected column identifier on left side of '=' operation`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "csv-sql-engine",
-    "version": "0.3.1",
+    "version": "0.3.2",
     "description": "API for executing SQL statements on CSV files.",
     "keywords": [
         "CSV",