@kensio/yulin 1.21.2 → 1.21.4

package/dist/service/athena/engine/sim-athena-column-types.d.ts

@@ -10,6 +10,8 @@ export declare const defaultAthenaResultType = "varchar";
  * read back out as `true` or `false` by the type the Glue column declared.
  */
 export declare function simAthenaSqliteAffinity(glueType: string | undefined): string;
+/** Whether a Glue column type holds a day with no time on it. */
+export declare function simAthenaIsDateType(glueType: string | undefined): boolean;
 /** Whether a Glue column type holds a boolean. */
 export declare function simAthenaIsBooleanType(glueType: string | undefined): boolean;
 /** The type name Athena reports for a Glue column type. */

package/dist/service/athena/engine/sim-athena-column-types.js

@@ -65,6 +65,10 @@ export function simAthenaSqliteAffinity(glueType) {
     }
     return realTypes.has(type) ? "REAL" : "TEXT";
 }
+/** Whether a Glue column type holds a day with no time on it. */
+export function simAthenaIsDateType(glueType) {
+    return baseType(glueType) === "date";
+}
 /** Whether a Glue column type holds a boolean. */
 export function simAthenaIsBooleanType(glueType) {
     return baseType(glueType) === "boolean";

package/dist/service/athena/engine/sim-athena-delimited-format.d.ts

@@ -0,0 +1,7 @@
+import type { SimAthenaCatalogTable } from "../table/sim-athena-catalog-table.js";
+import type { SimAthenaDelimitedFormat } from "./sim-athena-delimited-records.js";
+/**
+ * How one table's delimited objects are read, or nothing where its SerDe names
+ * no delimited format.
+ */
+export declare function simAthenaDelimitedFormat(table: SimAthenaCatalogTable, library: string): SimAthenaDelimitedFormat | undefined;

package/dist/service/athena/engine/sim-athena-delimited-format.js

@@ -0,0 +1,51 @@
+/**
+ * The SerDe class names that mean delimited text, and what each one reads
+ * before the table's own parameters are applied.
+ *
+ * `OpenCSVSerde` is comma separated and quoted. `LazySimpleSerDe` is what
+ * `ROW FORMAT DELIMITED` gives: it quotes nothing, and its own default
+ * delimiter is the control character Hive has always used rather than a comma.
+ */
+const delimitedSerDes = new Map([
+    [
+        "org.apache.hadoop.hive.serde2.opencsvserde",
+        { delimiter: ",", quoted: true },
+    ],
+    [
+        "org.apache.hadoop.hive.serde2.lazy.lazysimpleserde",
+        { delimiter: "\u{1}", quoted: false },
+    ],
+]);
+/**
+ * How one table's delimited objects are read, or nothing where its SerDe names
+ * no delimited format.
+ */
+export function simAthenaDelimitedFormat(table, library) {
+    const defaults = delimitedSerDes.get(library);
+    if (defaults === undefined) {
+        return undefined;
+    }
+    const parameters = table.storageDescriptor?.SerdeInfo?.Parameters ?? {};
+    const quoted = defaults.quoted || parameters["quoteChar"] !== undefined;
+    return {
+        delimiter: parameters["separatorChar"] ??
+            parameters["field.delim"] ??
+            defaults.delimiter,
+        quote: quoted ? (parameters["quoteChar"] ?? '"') : undefined,
+        escape: quoted ? (parameters["escapeChar"] ?? "\\") : undefined,
+        skipHeaderLines: skippedHeaderLines(table),
+    };
+}
+/**
+ * How many lines of every object are a header rather than a row.
+ *
+ * `skip.header.line.count` is a table property on real Athena, and the storage
+ * descriptor's own parameters are read as well because a template can put it
+ * in either place.
+ */
+function skippedHeaderLines(table) {
+    const declared = table.parameters["skip.header.line.count"] ??
+        table.storageDescriptor?.Parameters?.["skip.header.line.count"];
+    const count = Math.trunc(Number(declared ?? ""));
+    return Number.isFinite(count) && count > 0 ? count : 0;
+}

package/dist/service/athena/engine/sim-athena-engine-result.js

@@ -10,6 +10,11 @@ import { simAthenaResultColumns } from "./sim-athena-result-columns.js";
 export function simAthenaEngineResult(database, sql, loaded) {
     const statement = database.prepare(sql);
     statement.setReturnArrays(true);
+    // A whole number comes back as a BigInt, because SQLite holds a 64 bit
+    // integer and reading one past what a double represents exactly raises
+    // otherwise. A Parquet `bigint` column is what carries values that large.
+    // Every one of them renders the same either way.
+    statement.setReadBigInts(true);
     const rows = statement.all();
     const columns = simAthenaResultColumns(statement.columns(), rows, loaded);
     return new SimAthenaResolvedResult({

package/dist/service/athena/engine/sim-athena-engine-run.d.ts

@@ -4,6 +4,22 @@ import type { SimAthenaResolvedResult } from "../result/sim-athena-resolved-resu
 import type { SimAthenaSqlParser } from "./sim-athena-parser-module.js";
 import type { SimAthenaSqliteModule } from "./sim-athena-sqlite-module.js";
 import type { SimAthenaTableObjects } from "./sim-athena-table-objects.js";
+/**
+ * What the engine came to for one query.
+ *
+ * A turn-down carries why, because a strict engine fails the query with it and
+ * a reader of that failing test has to learn which of them it hit.
+ */
+export interface SimAthenaEngineAnswer {
+    /** The rows, where the engine ran the statement. */
+    readonly result: SimAthenaResolvedResult | undefined;
+    /** What the engine could not do, where it turned the query down. */
+    readonly turnedDown: string | undefined;
+}
+/** One answer the engine ran for real. */
+export declare function simAthenaEngineAnswered(result: SimAthenaResolvedResult): SimAthenaEngineAnswer;
+/** One query the engine turned down, and why. */
+export declare function simAthenaEngineTurnedDown(turnedDown: string): SimAthenaEngineAnswer;
 /** What one query is run with, once the engine is on and has somewhere to read. */
 export interface SimAthenaEngineRun {
     readonly parser: SimAthenaSqlParser;
@@ -22,6 +38,10 @@ export interface SimAthenaEngineRun {
  * can fail on an object the caller cannot open, building the database can fail
  * on a schema SQLite refuses, and running the statement can fail on anything
  * the parser wrote that SQLite does not have. All three leave the declared
- * result to answer.
+ * result to answer. So does a Parquet table in a project that has not installed
+ * the reader, and `hyparquet` is named in the docs for that reason.
+ *
+ * Each of them carries a reason out, which a strict engine fails the query
+ * with.
  */
-export declare function simAthenaEngineRun(run: SimAthenaEngineRun): Promise<SimAthenaResolvedResult | undefined>;
+export declare function simAthenaEngineRun(run: SimAthenaEngineRun): Promise<SimAthenaEngineAnswer>;

package/dist/service/athena/engine/sim-athena-engine-run.js

@@ -1,6 +1,15 @@
+import { simAthenaRunFailure } from "./sim-athena-turn-down.js";
 import { simAthenaEngineResult } from "./sim-athena-engine-result.js";
 import { simAthenaSqliteDatabase } from "./sim-athena-sqlite-database.js";
-import { simAthenaTableRows, } from "./sim-athena-table-rows.js";
+import { simAthenaLoadedTables } from "./sim-athena-loaded-tables.js";
+/** One answer the engine ran for real. */
+export function simAthenaEngineAnswered(result) {
+    return { result, turnedDown: undefined };
+}
+/** One query the engine turned down, and why. */
+export function simAthenaEngineTurnedDown(turnedDown) {
+    return { result: undefined, turnedDown };
+}
 /**
  * Load the tables, build the database and run the statement.
  *
@@ -8,13 +17,17 @@ import { simAthenaTableRows, } from "./sim-athena-table-rows.js";
  * can fail on an object the caller cannot open, building the database can fail
  * on a schema SQLite refuses, and running the statement can fail on anything
  * the parser wrote that SQLite does not have. All three leave the declared
- * result to answer.
+ * result to answer. So does a Parquet table in a project that has not installed
+ * the reader, and `hyparquet` is named in the docs for that reason.
+ *
+ * Each of them carries a reason out, which a strict engine fails the query
+ * with.
  */
 export async function simAthenaEngineRun(run) {
     try {
-        const loaded = await loadedTables(run);
-        if (loaded === undefined) {
-            return undefined;
+        const loaded = await simAthenaLoadedTables(run);
+        if (typeof loaded === "string") {
+            return simAthenaEngineTurnedDown(loaded);
         }
         const database = simAthenaSqliteDatabase({
             sqlite: run.sqlite,
@@ -23,36 +36,13 @@ export async function simAthenaEngineRun(run) {
             startedAt: run.startedAt,
         });
         try {
-            return simAthenaEngineResult(database, run.sql, loaded);
+            return simAthenaEngineAnswered(simAthenaEngineResult(database, run.sql, loaded));
         }
         finally {
             database.close();
         }
     }
-    catch {
-        return undefined;
+    catch (error) {
+        return simAthenaEngineTurnedDown(simAthenaRunFailure(error));
     }
 }
-/**
- * Every table the query reads, loaded once each.
- *
- * A statement naming one table twice resolves to two entries, and loading each
- * of them would read the objects twice and then fail to create the table.
- */
-async function loadedTables(run) {
-    const loaded = await Promise.all(distinctTables(run.tables).map(async (planned) => simAthenaTableRows({ planned, objects: run.objects, caller: run.caller })));
-    return loaded.includes(undefined)
-        ? undefined
-        : loaded;
-}
-function distinctTables(tables) {
-    const seen = new Set();
-    return tables.filter((planned) => {
-        const identity = `${planned.table.databaseName}.${planned.table.name}`.toLowerCase();
-        if (seen.has(identity)) {
-            return false;
-        }
-        seen.add(identity);
-        return true;
-    });
-}

package/dist/service/athena/engine/sim-athena-loaded-tables.d.ts

@@ -0,0 +1,10 @@
+import type { SimAthenaEngineRun } from "./sim-athena-engine-run.js";
+import { type SimAthenaLoadedTable } from "./sim-athena-table-rows.js";
+/**
+ * Every table the query reads, loaded once each, or the reason one of them
+ * could not be.
+ *
+ * A statement naming one table twice resolves to two entries, and loading each
+ * of them would read the objects twice and then fail to create the table.
+ */
+export declare function simAthenaLoadedTables(run: SimAthenaEngineRun): Promise<readonly SimAthenaLoadedTable[] | string>;

package/dist/service/athena/engine/sim-athena-loaded-tables.js

@@ -0,0 +1,35 @@
+import { simAthenaTableRows, } from "./sim-athena-table-rows.js";
+import { simAthenaUnreadableFormat } from "./sim-athena-turn-down.js";
+/**
+ * Every table the query reads, loaded once each, or the reason one of them
+ * could not be.
+ *
+ * A statement naming one table twice resolves to two entries, and loading each
+ * of them would read the objects twice and then fail to create the table.
+ */
+export async function simAthenaLoadedTables(run) {
+    const loaded = await Promise.all(distinctTables(run.tables).map(async (planned) => ({
+        planned,
+        rows: await simAthenaTableRows({
+            planned,
+            objects: run.objects,
+            caller: run.caller,
+        }),
+    })));
+    const unread = loaded.find((one) => one.rows === undefined);
+    if (unread !== undefined) {
+        return simAthenaUnreadableFormat(unread.planned.table);
+    }
+    return loaded.flatMap((one) => one.rows ?? []);
+}
+function distinctTables(tables) {
+    const seen = new Set();
+    return tables.filter((planned) => {
+        const identity = `${planned.table.databaseName}.${planned.table.name}`.toLowerCase();
+        if (seen.has(identity)) {
+            return false;
+        }
+        seen.add(identity);
+        return true;
+    });
+}

package/dist/service/athena/engine/sim-athena-parquet-module.d.ts

@@ -0,0 +1,25 @@
+/** One Parquet file's rows, keyed by the names the file's own schema holds. */
+export type SimAthenaParquetRow = Record<string, unknown>;
+/** What one Parquet file is read with. */
+export interface SimAthenaParquetOptions {
+    readonly file: ArrayBuffer;
+    readonly compressors: Readonly<Record<string, (bytes: Uint8Array, size: number) => Uint8Array>>;
+    /** Whether a `BYTE_ARRAY` column reads as text, which a Hive string is. */
+    readonly utf8: boolean;
+}
+/** The one thing the engine needs out of `hyparquet`. */
+export interface SimAthenaParquetReader {
+    parquetReadObjects(options: SimAthenaParquetOptions): Promise<SimAthenaParquetRow[]>;
+}
+/**
+ * The Parquet reader, loaded the first time a query reaches a Parquet table.
+ *
+ * `hyparquet` is an optional peer dependency, so a project querying only JSON
+ * and CSV tables never installs it. Loading here rather than in `enable()` is
+ * what keeps that true, since the engine has no idea what a test will query
+ * until it does.
+ *
+ * The package name is a parameter so that a test can ask for one that is not
+ * installed and read what a project without the package is told.
+ */
+export declare function simAthenaParquetReader(packageName?: string): Promise<SimAthenaParquetReader>;

package/dist/service/athena/engine/sim-athena-parquet-module.js

@@ -0,0 +1,39 @@
+import { SimAthenaSetUpError } from "../error/sim-athena.error.js";
+/**
+ * The package name, held as a variable rather than written into the `import()`
+ * so that building this repository never turns an optional dependency into a
+ * required one.
+ */
+const parquetPackage = "hyparquet";
+const missingPackage = `Simulated Athena needs hyparquet to read a Parquet table. Add it to your ` +
+    `project as a dev dependency, or declare what each query over that table ` +
+    `answers with through results().`;
+/**
+ * The Parquet reader, loaded the first time a query reaches a Parquet table.
+ *
+ * `hyparquet` is an optional peer dependency, so a project querying only JSON
+ * and CSV tables never installs it. Loading here rather than in `enable()` is
+ * what keeps that true, since the engine has no idea what a test will query
+ * until it does.
+ *
+ * The package name is a parameter so that a test can ask for one that is not
+ * installed and read what a project without the package is told.
+ */
+export async function simAthenaParquetReader(packageName = parquetPackage) {
+    const module = await importedReader(packageName);
+    const { parquetReadObjects } = module;
+    if (typeof parquetReadObjects !== "function") {
+        throw new SimAthenaSetUpError(`${packageName} carries no parquetReadObjects. ${missingPackage}`);
+    }
+    return { parquetReadObjects };
+}
+async function importedReader(packageName) {
+    try {
+        return (await import(packageName));
+    }
+    catch (error) {
+        const missing = new SimAthenaSetUpError(missingPackage);
+        missing.cause = error;
+        throw missing;
+    }
+}

package/dist/service/athena/engine/sim-athena-parquet-records.d.ts

@@ -0,0 +1,13 @@
+import type { SimAthenaEngineRow } from "./sim-athena-engine-row.js";
+/**
+ * One Parquet object's rows.
+ *
+ * A Parquet file carries its own schema, so nothing here reads the table's Glue
+ * columns. A column the table declares and the file has not got reads null, the
+ * way a JSON record missing a key already does.
+ *
+ * `utf8` reads a `BYTE_ARRAY` column as text. Hive's `string` is what nearly
+ * every one of them holds, and a Glue `binary` column already arrives as text
+ * everywhere else in this engine.
+ */
+export declare function simAthenaParquetRows(bytes: Uint8Array): Promise<readonly SimAthenaEngineRow[]>;

package/dist/service/athena/engine/sim-athena-parquet-records.js

@@ -0,0 +1,57 @@
+import { brotliDecompressSync, gunzipSync, inflateSync, zstdDecompressSync, } from "node:zlib";
+import { simAthenaParquetReader } from "./sim-athena-parquet-module.js";
+/**
+ * The Parquet codecs Node's own zlib covers.
+ *
+ * `hyparquet` decompresses `UNCOMPRESSED` and `SNAPPY` itself, and snappy is
+ * what Athena and Glue write by default. The three here are what `node:zlib`
+ * adds for nothing. `LZO`, `LZ4` and `LZ4_RAW` are what is left, and a file in
+ * one of those turns the query down.
+ *
+ * A Parquet file compresses per column chunk inside itself, so none of this
+ * has anything to do with the codec an object's key names.
+ */
+const compressors = {
+    GZIP: (bytes, size) => sized(gunzipSync(bytes), size),
+    ZSTD: (bytes, size) => sized(zstdDecompressSync(bytes), size),
+    BROTLI: (bytes, size) => sized(brotliDecompressSync(bytes), size),
+    DEFLATE: (bytes, size) => sized(inflateSync(bytes), size),
+};
+/**
+ * One decompressed page, cut to the length the page header declares.
+ *
+ * `hyparquet` checks the length itself and refuses a page that comes back
+ * longer, which a codec padding its output would produce.
+ */
+function sized(buffer, size) {
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, size);
+}
+/**
+ * One Parquet object's rows.
+ *
+ * A Parquet file carries its own schema, so nothing here reads the table's Glue
+ * columns. A column the table declares and the file has not got reads null, the
+ * way a JSON record missing a key already does.
+ *
+ * `utf8` reads a `BYTE_ARRAY` column as text. Hive's `string` is what nearly
+ * every one of them holds, and a Glue `binary` column already arrives as text
+ * everywhere else in this engine.
+ */
+export async function simAthenaParquetRows(bytes) {
+    const reader = await simAthenaParquetReader();
+    return reader.parquetReadObjects({
+        file: arrayBuffer(bytes),
+        compressors,
+        utf8: true,
+    });
+}
+/**
+ * One object's bytes as the `ArrayBuffer` the reader takes.
+ *
+ * A `Buffer` read out of simulated S3 is a view onto a larger pool, so the
+ * whole of its own buffer is more than the object and the offsets have to be
+ * carried through.
+ */
+function arrayBuffer(bytes) {
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}

package/dist/service/athena/engine/sim-athena-query-engine.d.ts

@@ -1,7 +1,19 @@
 import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
 import type { SimAthenaPlannedTable } from "../execution/sim-athena-query-refusal.js";
-import type { SimAthenaResolvedResult } from "../result/sim-athena-resolved-result.js";
+import { type SimAthenaEngineAnswer } from "./sim-athena-engine-run.js";
 import type { SimAthenaTableObjects } from "./sim-athena-table-objects.js";
+/** How one scope's engine is turned on. */
+export interface SimAthenaEngineOptions {
+    /**
+     * Whether a query the engine turns down fails rather than falling back.
+     *
+     * Off by default, which leaves every turn-down answering from a declaration
+     * the way it always has. A test suite meaning to exercise the engine turns
+     * this on, and then a query the engine quietly stopped running shows up as a
+     * failing test rather than as one passing on rows nobody meant to use.
+     */
+    readonly strict?: boolean;
+}
 /** What one query is run against. */
 export interface SimAthenaEngineRequest {
     readonly queryString: string;
@@ -28,12 +40,15 @@ export interface SimAthenaEngineRequest {
  * Everything the engine cannot do, it turns down. A statement Athena's grammar
  * refuses, a table in a format it has no reader for, an object it cannot open
  * and a statement SQLite will not run all end the same way: no result, and the
- * declaration a test wrote answers the query instead.
+ * declaration a test wrote answers the query instead. A strict engine fails the
+ * query instead of falling back, and the reason says which of them it hit.
  */
 export declare class SimAthenaQueryEngine {
     #private;
     /** Whether this scope runs queries rather than answering from declarations. */
     get isEnabled(): boolean;
+    /** Whether a query this engine turns down fails rather than falling back. */
+    get isStrict(): boolean;
     /**
      * Run queries in this scope for real, loading the SQL parser.
      *
@@ -41,11 +56,14 @@ export declare class SimAthenaQueryEngine {
      * optional peer dependency, so a project that never runs a query never
      * installs it.
      */
-    enable(): Promise<void>;
+    enable(options?: SimAthenaEngineOptions): Promise<void>;
     /** Answer queries from declarations again. */
     disable(): void;
     /**
-     * What one query answers with, or nothing where the engine turned it down.
+     * What one query answers with, or why the engine turned it down.
+     *
+     * An engine nobody turned on turns nothing down. It has no opinion about the
+     * query, and a scope left alone answers from declarations as it always did.
      */
-    run(request: SimAthenaEngineRequest): Promise<SimAthenaResolvedResult | undefined>;
+    run(request: SimAthenaEngineRequest): Promise<SimAthenaEngineAnswer>;
 }

package/dist/service/athena/engine/sim-athena-query-engine.js

@@ -1,7 +1,8 @@
-import { simAthenaEngineRun } from "./sim-athena-engine-run.js";
+import { simAthenaEngineRun, simAthenaEngineTurnedDown, } from "./sim-athena-engine-run.js";
 import { simAthenaSqlParser, } from "./sim-athena-parser-module.js";
 import { simAthenaSqliteModule, } from "./sim-athena-sqlite-module.js";
 import { simAthenaSqliteSql } from "./sim-athena-sql-translation.js";
+import { simAthenaNoObjects } from "./sim-athena-turn-down.js";
 /**
  * The query engine one simulated Athena scope answers with, when a test turns
  * it on.
@@ -18,15 +19,21 @@ import { simAthenaSqliteSql } from "./sim-athena-sql-translation.js";
  * Everything the engine cannot do, it turns down. A statement Athena's grammar
  * refuses, a table in a format it has no reader for, an object it cannot open
  * and a statement SQLite will not run all end the same way: no result, and the
- * declaration a test wrote answers the query instead.
+ * declaration a test wrote answers the query instead. A strict engine fails the
+ * query instead of falling back, and the reason says which of them it hit.
  */
 export class SimAthenaQueryEngine {
     #parser;
     #sqlite;
+    #strict = false;
     /** Whether this scope runs queries rather than answering from declarations. */
     get isEnabled() {
         return this.#parser !== undefined;
     }
+    /** Whether a query this engine turns down fails rather than falling back. */
+    get isStrict() {
+        return this.#strict;
+    }
     /**
      * Run queries in this scope for real, loading the SQL parser.
      *
@@ -34,32 +41,46 @@ export class SimAthenaQueryEngine {
      * optional peer dependency, so a project that never runs a query never
      * installs it.
      */
-    async enable() {
+    async enable(options = {}) {
         const parser = await simAthenaSqlParser();
         this.#sqlite = await simAthenaSqliteModule();
         this.#parser = parser;
+        this.#strict = options.strict ?? false;
     }
     /** Answer queries from declarations again. */
     disable() {
         this.#parser = undefined;
+        this.#strict = false;
     }
     /**
-     * What one query answers with, or nothing where the engine turned it down.
+     * What one query answers with, or why the engine turned it down.
+     *
+     * An engine nobody turned on turns nothing down. It has no opinion about the
+     * query, and a scope left alone answers from declarations as it always did.
      */
     async run(request) {
         const parser = this.#parser;
         const sqlite = this.#sqlite;
         const { objects } = request;
-        if (parser === undefined || sqlite === undefined || objects === undefined) {
-            return undefined;
+        if (parser === undefined || sqlite === undefined) {
+            return { result: undefined, turnedDown: undefined };
+        }
+        if (objects === undefined) {
+            return simAthenaEngineTurnedDown(simAthenaNoObjects);
         }
-        const sql = simAthenaSqliteSql({
+        const translated = simAthenaSqliteSql({
             parser,
             athenaSql: request.queryString,
             tables: request.tables.map((planned) => planned.table),
         });
-        return sql === undefined
-            ? undefined
-            : simAthenaEngineRun({ ...request, parser, sqlite, objects, sql });
+        return translated.sql === undefined
+            ? simAthenaEngineTurnedDown(translated.turnedDown)
+            : simAthenaEngineRun({
+                ...request,
+                parser,
+                sqlite,
+                objects,
+                sql: translated.sql,
+            });
     }
 }

package/dist/service/athena/engine/sim-athena-record-reader.d.ts

@@ -1,15 +1,21 @@
 import type { SimAthenaCatalogTable } from "../table/sim-athena-catalog-table.js";
 import type { SimAthenaEngineRow } from "./sim-athena-engine-row.js";
-/** One object's bytes, read into the rows it holds. */
-export type SimAthenaRecordReader = (text: string) => readonly SimAthenaEngineRow[];
+/**
+ * One object's bytes, read into the rows it holds.
+ *
+ * The bytes rather than the text, because Parquet is binary and carries its own
+ * schema. A reader may answer with a promise for the same reason, since reading
+ * one is asynchronous.
+ */
+export type SimAthenaRecordReader = (bytes: Uint8Array) => readonly SimAthenaEngineRow[] | Promise<readonly SimAthenaEngineRow[]>;
 /**
  * How one table's objects are decoded, or nothing where this simulation has no
  * reader for what the table declares.
  *
  * The SerDe is what says so, the way it says so on real Athena. A table
- * holding Parquet or ORC lands here, and the query falls back to whatever a
- * test declared. A table declaring no SerDe at all lands here too: nothing
- * else in the catalog says what the bytes are, and guessing would answer a
- * Parquet query with nonsense rather than turning it down.
+ * holding ORC lands here, and the query falls back to whatever a test declared.
+ * A table declaring no SerDe at all lands here too. Nothing else in the catalog
+ * says what the bytes are, and guessing would answer with nonsense where
+ * turning the query down is the honest reply.
  */
 export declare function simAthenaRecordReader(table: SimAthenaCatalogTable): SimAthenaRecordReader | undefined;