csv-sql-engine 0.2.0 → 0.3.1

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

@@ -1,9 +1,11 @@
-import { assert } from '@augment-vir/assert';
-import { awaitedForEach, stringify } from '@augment-vir/common';
+import { assert, assertWrap } from '@augment-vir/assert';
+import { stringify } from '@augment-vir/common';
 import { existsSync } from 'node:fs';
+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 { AlterExpressionAction } from '../../sql/ast.js';
+import { SqlUnsupportedOperationError } from '../../errors/sql.error.js';
+import { getAstType } from '../../util/ast-node.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 /**
  * Handles altering tables.
@@ -12,74 +14,91 @@ import { defineAstHandler } from '../define-ast-handler.js';
  */
 export const tableAlterHandler = defineAstHandler({
     name: 'table-alter',
-    async handler({ ast, csvDirPath }) {
-        if (ast.type === 'alter') {
-            const tableNames = ast.table.map((table) => table.table);
-            await awaitedForEach(tableNames, async (tableName) => {
-                await awaitedForEach(ast.expr, async (expression) => {
-                    const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
-                        csvDirPath,
-                        tableName,
-                    });
-                    if (!existsSync(tableFilePath)) {
-                        throw new CsvTableDoesNotExistError(sanitizedTableName);
-                    }
-                    /** Mutate this to apply the table alterations. */
-                    const csvContents = await readCsvFile(tableFilePath);
-                    const csvHeaders = await readCsvHeaders({
-                        csvContents,
-                        sanitizedTableName,
-                    });
-                    if (expression.action === AlterExpressionAction.Add) {
-                        const defaultValue = expression.default_val?.value.value || '';
-                        const newHeaderName = expression.column.column;
-                        csvContents.forEach((row, index) => {
-                            if (index) {
-                                row.push(defaultValue);
-                            }
-                            else {
-                                row.push(newHeaderName);
-                            }
-                        });
-                    }
-                    else if (expression.action === AlterExpressionAction.Rename) {
-                        const oldHeaderName = expression.old_column.column;
-                        const newHeaderName = expression.column.column;
-                        let oldHeaderFound = false;
-                        const newHeaders = csvHeaders.map((header) => {
-                            if (header === oldHeaderName) {
-                                oldHeaderFound = true;
-                                return newHeaderName;
-                            }
-                            else {
-                                return header;
-                            }
-                        });
-                        if (!oldHeaderFound) {
-                            throw new CsvColumnDoesNotExistError(sanitizedTableName, oldHeaderName);
-                        }
-                        csvContents[0] = newHeaders;
-                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                    }
-                    else if (expression.action === AlterExpressionAction.Drop) {
-                        const columnName = expression.column.column;
-                        const columnIndex = csvHeaders.indexOf(columnName);
-                        if (columnIndex < 0) {
-                            throw new CsvColumnDoesNotExistError(sanitizedTableName, columnName);
-                        }
-                        csvContents.forEach((row) => {
-                            row.splice(columnIndex, 1);
-                        });
-                    }
-                    else {
-                        assert.tsType(expression).equals();
-                        assert.never(`Forgot to handle expression action ${stringify(expression)}`);
-                    }
-                    await writeCsvFile(tableFilePath, csvContents);
-                });
+    async handler({ ast, csvDirPath, sql }) {
+        if (ast.variant !== 'alter table' || ast.target.type !== 'identifier') {
+            return;
+        }
+        const tableName = ast.target.name;
+        const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
+            csvDirPath,
+            tableName,
+        });
+        if (!existsSync(tableFilePath)) {
+            throw new CsvTableDoesNotExistError(sanitizedTableName);
+        }
+        /** Mutate this to apply the table alterations. */
+        const csvContents = await readCsvFile(tableFilePath);
+        const csvHeaders = await readCsvHeaders({
+            csvContents,
+            sanitizedTableName,
+        });
+        if (ast.action === 'rename') {
+            const newTableName = assertWrap.isTruthy(getAstType(ast.name, 'identifier')?.name, 'Missing new table name.');
+            await rename(tableFilePath, nameCsvTableFile({ csvDirPath, tableName: newTableName }).tableFilePath);
+            return {
+                columnNames: [],
+                numberOfRowsAffected: 0,
+                values: [],
+            };
+        }
+        else if (ast.action === 'add') {
+            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 newHeaderName = assertWrap.isTruthy(ast.definition.name, 'Missing new column name.');
+            csvContents.forEach((row, index) => {
+                if (index) {
+                    row.push(defaultValue);
+                }
+                else {
+                    row.push(newHeaderName);
+                }
+            });
+        }
+        else if (ast.action === 'rename, column') {
+            const oldHeaderName = ast.oldName;
+            const newHeaderName = ast.newName;
+            if (!oldHeaderName) {
+                throw new Error('No old column name.');
+            }
+            else if (!newHeaderName) {
+                throw new Error('No new column name.');
+            }
+            let oldHeaderFound = false;
+            const newHeaders = csvHeaders.map((header) => {
+                if (header === oldHeaderName) {
+                    oldHeaderFound = true;
+                    return newHeaderName;
+                }
+                else {
+                    return header;
+                }
+            });
+            if (!oldHeaderFound) {
+                throw new CsvColumnDoesNotExistError(sanitizedTableName, oldHeaderName);
+            }
+            csvContents[0] = newHeaders;
+        }
+        else if (ast.action === 'drop') {
+            const columnName = ast.column;
+            assert.isTruthy(columnName, 'No column name found to drop.');
+            const columnIndex = csvHeaders.indexOf(columnName);
+            if (columnIndex < 0) {
+                throw new CsvColumnDoesNotExistError(sanitizedTableName, columnName);
+            }
+            csvContents.forEach((row) => {
+                row.splice(columnIndex, 1);
             });
-            return [];
         }
-        return undefined;
+        else {
+            throw new SqlUnsupportedOperationError(sql, `Forgot to handle alter table action: '${stringify(ast.action)}'`, ast);
+        }
+        await writeCsvFile(tableFilePath, csvContents);
+        return {
+            columnNames: [],
+            numberOfRowsAffected: 0,
+            values: [],
+        };
     },
 });

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

@@ -1,10 +1,9 @@
 import { check } from '@augment-vir/assert';
-import { awaitedForEach, filterMap } from '@augment-vir/common';
+import { filterMap } from '@augment-vir/common';
 import { existsSync } from 'node:fs';
 import { appendCsvRow, nameCsvTableFile } from '../../csv/csv-file.js';
 import { CsvTableExistsError } from '../../errors/csv.error.js';
-import { SqlMissingColumnsError } from '../../errors/sql.error.js';
-import { AstType, CreateKeyword } from '../../sql/ast.js';
+import { SqlMissingColumnsError, SqlUnsupportedOperationError } from '../../errors/sql.error.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 /**
  * Handles creating tables.
@@ -13,26 +12,41 @@ import { defineAstHandler } from '../define-ast-handler.js';
  */
 export const tableCreateHandler = defineAstHandler({
     name: 'table-create',
-    async handler({ ast, csvDirPath, sql }) {
-        if (ast.type === AstType.Create && ast.keyword === CreateKeyword.Table) {
-            await awaitedForEach(ast.table, async (table) => {
-                const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
-                    csvDirPath,
-                    tableName: table.table,
-                });
-                if (existsSync(tableFilePath)) {
-                    throw new CsvTableExistsError(sanitizedTableName);
-                }
-                const headers = filterMap(ast.create_definitions, (definition) => {
-                    return definition.column.column;
-                }, check.isTruthy);
-                if (!headers.length) {
-                    throw new SqlMissingColumnsError(sql, sanitizedTableName);
-                }
-                await appendCsvRow(headers, tableFilePath);
-            });
-            return [];
+    async handler({ ast, csvDirPath, sql, rejectUnsupportedOperations }) {
+        if (ast.variant !== 'create' ||
+            ast.format !== 'table' ||
+            !ast.name ||
+            ast.name.type !== 'identifier') {
+            return undefined;
         }
-        return undefined;
+        const tableName = ast.name.name;
+        if (!tableName) {
+            if (rejectUnsupportedOperations) {
+                throw new SqlUnsupportedOperationError(sql, 'No table name found when creating a table.', ast);
+            }
+            return undefined;
+        }
+        const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
+            csvDirPath,
+            tableName,
+        });
+        if (existsSync(tableFilePath)) {
+            throw new CsvTableExistsError(sanitizedTableName);
+        }
+        const headers = filterMap(ast.definition || [], (definition) => {
+            if (definition.type !== 'definition' || !definition.name) {
+                return undefined;
+            }
+            return definition.name;
+        }, check.isTruthy);
+        if (!headers.length) {
+            throw new SqlMissingColumnsError(sql, sanitizedTableName);
+        }
+        await appendCsvRow(headers, tableFilePath);
+        return {
+            columnNames: [],
+            numberOfRowsAffected: 0,
+            values: [],
+        };
     },
 });

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

@@ -1,9 +1,7 @@
-import { awaitedForEach } from '@augment-vir/common';
 import { existsSync } from 'node:fs';
 import { rm } from 'node:fs/promises';
-import { nameCsvTableFile } from '../../csv/csv-file.js';
+import { nameCsvTableFile, readCsvFile } from '../../csv/csv-file.js';
 import { CsvTableDoesNotExistError } from '../../errors/csv.error.js';
-import { AstType } from '../../sql/ast.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 /**
  * Handles dropping tables.
@@ -13,24 +11,34 @@ import { defineAstHandler } from '../define-ast-handler.js';
 export const tableDropHandler = defineAstHandler({
     name: 'table-drop',
     async handler({ ast, csvDirPath }) {
-        if (ast.type === AstType.Drop) {
-            await awaitedForEach(ast.name, async (table) => {
-                const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
-                    csvDirPath,
-                    tableName: table.table,
-                });
-                if (existsSync(tableFilePath)) {
-                    await rm(tableFilePath);
-                }
-                else if (ast.prefix === 'if exists') {
-                    return;
-                }
-                else {
-                    throw new CsvTableDoesNotExistError(sanitizedTableName);
-                }
-            });
-            return [];
+        if (ast.variant !== 'drop') {
+            return undefined;
+        }
+        const tableName = ast.target.name;
+        const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
+            csvDirPath,
+            tableName,
+        });
+        if (existsSync(tableFilePath)) {
+            const csvContents = await readCsvFile(tableFilePath);
+            await rm(tableFilePath);
+            return {
+                columnNames: csvContents[0] || [],
+                numberOfRowsAffected: csvContents.length - 1,
+                values: csvContents.slice(1),
+            };
+        }
+        else if (ast.condition[0]?.variant === 'if' &&
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            ast.condition[0]?.condition.variant === 'exists') {
+            return {
+                columnNames: [],
+                numberOfRowsAffected: 0,
+                values: [],
+            };
+        }
+        else {
+            throw new CsvTableDoesNotExistError(sanitizedTableName);
         }
-        return undefined;
     },
 });

package/dist/engine/params.d.ts

@@ -1,7 +1,5 @@
 import { type PartialWithUndefined } from '@augment-vir/common';
-import { type Parser } from 'node-sql-parser';
-import { type SqlAst } from '../sql/ast.js';
-import { type Sql } from '../sql/sql.js';
+import { type Sql, type SqliteAst } from 'sqlite-ast';
 /**
  * Options for rejecting unsupported operations (rather than ignoring them).
  *
@@ -16,26 +14,15 @@ export type RejectUnsupportedOptions = PartialWithUndefined<{
      */
     rejectUnsupportedOperations: boolean;
 }>;
-/**
- * Options for parsing SQL.
- *
- * @category Internal
- */
-export type ParseSqlOptions = PartialWithUndefined<{
-    /**
-     * A custom implementation of the Parser from
-     * [node-sql-parser](https://npmjs.com/package/node-sql-parser). If not provided, one will be
-     * constructed.
-     */
-    parser: Parser;
-}> & RejectUnsupportedOptions;
 /**
  * Parameters for AST handlers.
  *
  * @category Internal
  */
 export type AstHandlerParams = {
-    ast: SqlAst;
+    ast: Extract<SqliteAst, {
+        type: 'statement';
+    }>;
     sql: Sql;
     /**
      * Path to the folder or directory containing all the CSV files. (Each CSV file is treated as an
@@ -48,4 +35,4 @@ export type AstHandlerParams = {
  *
  * @category Internal
  */
-export type ExecuteSqlParams = ParseSqlOptions & Omit<AstHandlerParams, 'ast' | 'sql'>;
+export type ExecuteSqlParams = Omit<AstHandlerParams, 'ast' | 'sql'>;

package/dist/errors/sql.error.d.ts

@@ -1,4 +1,4 @@
-import { type Sql } from '../sql/sql.js';
+import { type Sql, type SqliteAst } from 'sqlite-ast';
 import { CsvSqlEngineError } from './csv-sql-engine.error.js';
 /**
  * Generic SQL related error thrown by the csv-sql-engine package. All SQL related errors from this
@@ -18,8 +18,9 @@ export declare class SqlError extends CsvSqlEngineError {
 export declare class SqlUnsupportedOperationError extends SqlError {
     readonly sql: Sql;
     readonly exactFailure: string | undefined;
+    readonly ast: SqliteAst;
     readonly name: string;
-    constructor(sql: Sql, exactFailure: string | undefined);
+    constructor(sql: Sql, exactFailure: string | undefined, ast: SqliteAst);
 }
 /**
  * Indicates that the original SQL command was not syntactically correct: it cannot be parsed.
@@ -32,6 +33,12 @@ export declare class SqlParseError extends SqlError {
     readonly name: string;
     constructor(sql: Sql, originalError: unknown);
 }
+export declare class SqlAstError extends SqlError {
+    readonly ast: SqliteAst;
+    readonly failure: string;
+    readonly name: string;
+    constructor(ast: SqliteAst, failure: string);
+}
 /**
  * Indicates that a SQL command is missing expected column definitions.
  *

package/dist/errors/sql.error.js

@@ -18,17 +18,21 @@ export class SqlError extends CsvSqlEngineError {
 export class SqlUnsupportedOperationError extends SqlError {
     sql;
     exactFailure;
+    ast;
     name = 'SqlUnsupportedOperationError';
-    constructor(sql, exactFailure) {
+    constructor(sql, exactFailure, ast) {
         super([
             'Unsupported SQL:',
             exactFailure ? ' ' : '',
             exactFailure ? addSuffix({ value: exactFailure, suffix: '.' }) : '',
             '\n',
             indent(trimLines(sql.sql)),
+            '\n',
+            indent(JSON.stringify(ast, null, 4)),
         ].join(''));
         this.sql = sql;
         this.exactFailure = exactFailure;
+        this.ast = ast;
     }
 }
 /**
@@ -46,6 +50,16 @@ export class SqlParseError extends SqlError {
         this.originalError = originalError;
     }
 }
+export class SqlAstError extends SqlError {
+    ast;
+    failure;
+    name = 'SqlAstError';
+    constructor(ast, failure) {
+        super(`SQLite AST parsing failed: ${failure}:\n${indent(JSON.stringify(ast, null, 4))}`);
+        this.ast = ast;
+        this.failure = failure;
+    }
+}
 /**
  * Indicates that a SQL command is missing expected column definitions.
  *

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from 'sqlite-ast';
 export * from './csv/csv-file.js';
 export * from './csv/csv-text.js';
 export * from './engine/define-ast-handler.js';
@@ -10,11 +11,8 @@ export * from './engine/handlers/table-alter.handler.js';
 export * from './engine/handlers/table-create.handler.js';
 export * from './engine/handlers/table-drop.handler.js';
 export * from './engine/params.js';
-export * from './engine/sort-values.js';
-export * from './engine/where-matcher.js';
 export * from './errors/csv-sql-engine.error.js';
 export * from './errors/csv.error.js';
 export * from './errors/sql.error.js';
-export * from './sql/ast.js';
-export * from './sql/parse-sql.js';
-export * from './sql/sql.js';
+export * from './util/sort-values.js';
+export * from './util/where-matcher.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from 'sqlite-ast';
 export * from './csv/csv-file.js';
 export * from './csv/csv-text.js';
 export * from './engine/define-ast-handler.js';
@@ -10,11 +11,8 @@ export * from './engine/handlers/table-alter.handler.js';
 export * from './engine/handlers/table-create.handler.js';
 export * from './engine/handlers/table-drop.handler.js';
 export * from './engine/params.js';
-export * from './engine/sort-values.js';
-export * from './engine/where-matcher.js';
 export * from './errors/csv-sql-engine.error.js';
 export * from './errors/csv.error.js';
 export * from './errors/sql.error.js';
-export * from './sql/ast.js';
-export * from './sql/parse-sql.js';
-export * from './sql/sql.js';
+export * from './util/sort-values.js';
+export * from './util/where-matcher.js';

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

@@ -0,0 +1,10 @@
+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;

package/dist/util/ast-node.js

@@ -0,0 +1,23 @@
+/** @throws If the request type is not there. */
+export function getAstType(node, typeName) {
+    if (!node) {
+        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 {
+        return undefined;
+    }
+}

package/dist/{engine → util}/sort-values.d.ts

@@ -1,5 +1,5 @@
+import { type ConsumableValue } from 'sqlite-ast';
 import { type RequireExactlyOne } from 'type-fest';
-import { type ConsumableValue } from '../sql/sql.js';
 /**
  * Output from {@link sortValues}.
  *

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

@@ -0,0 +1,10 @@
+import { type MaybeArray } from '@augment-vir/common';
+import { type SqliteAstNode } from 'sqlite-ast';
+import { type CsvFile } from '../csv/csv-file.js';
+/**
+ * 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[];

package/dist/util/where-matcher.js

@@ -0,0 +1,66 @@
+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';
+/**
+ * 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);
+    return allIndexes;
+}
+function innerFindWhereMatches(where, csvContents, csvFilePath) {
+    if (!where) {
+        return csvContents.map((value, index) => index);
+    }
+    else if (where.type === 'expression' &&
+        where.variant === 'operation' &&
+        where.format === 'binary') {
+        if (where.operation === 'or') {
+            return removeDuplicates([
+                ...innerFindWhereMatches(where.left, csvContents, csvFilePath),
+                ...innerFindWhereMatches(where.right, csvContents, csvFilePath),
+            ]);
+        }
+        else if (where.operation === 'and') {
+            return extractDuplicates([
+                ...innerFindWhereMatches(where.left, csvContents, csvFilePath),
+                ...innerFindWhereMatches(where.right, csvContents, csvFilePath),
+            ]).duplicates;
+        }
+        else if (where.operation === '=') {
+            const headers = csvContents[0];
+            if (!headers) {
+                throw new CsvFileMissingHeadersError(csvFilePath);
+            }
+            if (where.left.type !== 'identifier' || where.left.variant !== 'column') {
+                throw new Error(`Expected column identifier on left side of '=' operation`);
+            }
+            if (where.right.type !== 'literal') {
+                throw new Error(`Expected literal value on right side of '=' operation`);
+            }
+            const columnIndex = headers.indexOf(where.left.name);
+            if (columnIndex < 0) {
+                throw new CsvColumnDoesNotExistError(removeSuffix({ value: csvFilePath, suffix: csvExtension }), where.left.name);
+            }
+            const rightValue = where.right.value;
+            return filterMap(csvContents, (row, index) => index, (index, row) => {
+                /** Don't select from the header row. */
+                const isHeaderRow = !index;
+                return !isHeaderRow && String(row[columnIndex]) === rightValue;
+            });
+        }
+        else {
+            throw new Error(`Unsupported WHERE operation: '${where.operation}'`);
+        }
+    }
+    else {
+        throw new Error(`Unsupported WHERE expression type: '${where.type}'`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "csv-sql-engine",
-    "version": "0.2.0",
+    "version": "0.3.1",
     "description": "API for executing SQL statements on CSV files.",
     "keywords": [
         "CSV",
@@ -43,17 +43,17 @@
         "test:update": "npm run test update"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.56.0",
-        "@augment-vir/common": "^31.56.0",
-        "@augment-vir/node": "^31.56.0",
+        "@augment-vir/assert": "^31.57.0",
+        "@augment-vir/common": "^31.57.0",
+        "@augment-vir/node": "^31.57.0",
         "@sinclair/typebox": "^0.34.45",
         "d3-dsv": "^3.0.1",
-        "node-sql-parser": "^5.3.13",
         "object-shape-tester": "^6.11.0",
-        "sql-template-tag": "^5.2.1"
+        "sqlite-ast": "^0.0.7",
+        "sqlite-parser": "^1.0.1"
     },
     "devDependencies": {
-        "@augment-vir/test": "^31.56.0",
+        "@augment-vir/test": "^31.57.0",
         "@eslint/eslintrc": "^3.3.3",
         "@eslint/js": "^9.39.2",
         "@stylistic/eslint-plugin": "^5.6.1",

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

@@ -1,9 +0,0 @@
-import { type CsvFile } from '../csv/csv-file.js';
-import { type Where } from '../sql/ast.js';
-/**
- * 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(where: Readonly<Where>, csvContents: Readonly<CsvFile>, csvFilePath: string): number[];