@kensio/yulin 1.21.2 → 1.21.4

package/dist/service/athena/engine/sim-athena-record-reader.js

@@ -1,7 +1,19 @@
-import { simAthenaDelimitedRows, } from "./sim-athena-delimited-records.js";
+import { simAthenaDelimitedFormat } from "./sim-athena-delimited-format.js";
+import { simAthenaDelimitedRows } from "./sim-athena-delimited-records.js";
 import { simAthenaJsonRows, } from "./sim-athena-json-records.js";
+import { simAthenaParquetRows } from "./sim-athena-parquet-records.js";
 /** The SerDe class name that takes `mapping.<column>` parameters. */
 const openXSerDe = "org.openx.data.jsonserde.jsonserde";
+/**
+ * The SerDe class names that mean Parquet.
+ *
+ * Glue and the Athena `CREATE TABLE` documentation both name the first. The
+ * second is what an older Hive table carries, and Athena still reads one.
+ */
+const parquetSerDes = new Set([
+    "org.apache.hadoop.hive.ql.io.parquet.serde.parquethiveserde",
+    "parquet.hive.serde.parquethiveserde",
+]);
 /** The SerDe class names that mean JSON lines. */
 const jsonSerDes = new Set([
     openXSerDe,
@@ -10,50 +22,38 @@ const jsonSerDes = new Set([
 ]);
 /** What a `mapping.<column>` parameter is named with. */
 const mappingPrefix = "mapping.";
-/**
- * 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 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 function simAthenaRecordReader(table) {
     const library = table.storageDescriptor?.SerdeInfo?.SerializationLibrary?.toLowerCase();
     if (library === undefined) {
         return undefined;
     }
+    if (parquetSerDes.has(library)) {
+        return simAthenaParquetRows;
+    }
     if (jsonSerDes.has(library)) {
         const format = jsonFormat(table, library);
-        return (text) => simAthenaJsonRows(text, format);
+        return (bytes) => simAthenaJsonRows(decodedText(bytes), format);
     }
-    const defaults = delimitedSerDes.get(library);
-    if (defaults === undefined) {
+    const format = simAthenaDelimitedFormat(table, library);
+    if (format === undefined) {
         return undefined;
     }
-    const format = delimitedFormat(table, defaults);
     const columns = table.columns.map((column) => column.Name);
-    return (text) => simAthenaDelimitedRows(text, format, columns);
+    return (bytes) => simAthenaDelimitedRows(decodedText(bytes), format, columns);
+}
+/** One object's bytes as the text a JSON or delimited reader wants. */
+function decodedText(bytes) {
+    return new TextDecoder().decode(bytes);
 }
 /**
  * How one table's JSON records reach its columns.
@@ -77,28 +77,3 @@ function jsonFormat(table, library) {
         caseInsensitive: parameters["case.insensitive"]?.toLowerCase() !== "false",
     };
 }
-function delimitedFormat(table, defaults) {
-    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-sql-translation.d.ts

@@ -1,5 +1,13 @@
 import type { SimAthenaCatalogTable } from "../table/sim-athena-catalog-table.js";
 import type { SimAthenaSqlParser } from "./sim-athena-parser-module.js";
+/** One statement translated for SQLite, or why it could not be. */
+export type SimAthenaTranslatedSql = {
+    readonly sql: string;
+    readonly turnedDown: undefined;
+} | {
+    readonly sql: undefined;
+    readonly turnedDown: string;
+};
 interface SimAthenaSqlTranslationRequest {
     readonly parser: SimAthenaSqlParser;
     readonly athenaSql: string;
@@ -7,15 +15,13 @@ interface SimAthenaSqlTranslationRequest {
     readonly tables: readonly SimAthenaCatalogTable[];
 }
 /**
- * One Athena statement written back out for SQLite, or nothing where it cannot
- * be.
+ * One Athena statement written back out for SQLite, or why it cannot be.
  *
- * A statement the Athena grammar refuses, one carrying an `UNNEST` that cannot
- * become a `json_each`, and one the parser cannot write back out all land the
- * same way. The engine has one answer to any of them, which is to turn the
- * query down and let the declared result take it. Nothing is reported from
- * here, since a query the engine cannot run is an ordinary thing for a test to
- * write.
+ * Three things stop it, and each is told apart because a strict engine fails
+ * the query with the reason. The Athena grammar can refuse the statement, an
+ * `UNNEST` in it can have no `json_each` to become, and the parser can decline
+ * to write the statement back out. A lenient engine answers all three the same
+ * way, by turning the query down and letting the declared result take it.
  */
-export declare function simAthenaSqliteSql(request: SimAthenaSqlTranslationRequest): string | undefined;
+export declare function simAthenaSqliteSql(request: SimAthenaSqlTranslationRequest): SimAthenaTranslatedSql;
 export {};

package/dist/service/athena/engine/sim-athena-sql-translation.js

@@ -1,31 +1,43 @@
 import { simAthenaSqlForParser, simAthenaSqlForSqlite, } from "./sim-athena-sql-rewrites.js";
+import { simAthenaUnparsedStatement, simAthenaUnrewrittenUnnest, simAthenaUnwrittenStatement, } from "./sim-athena-turn-down.js";
 import { simAthenaRewriteUnnest } from "./sim-athena-unnest-rewrite.js";
 /**
- * One Athena statement written back out for SQLite, or nothing where it cannot
- * be.
+ * One Athena statement written back out for SQLite, or why it cannot be.
  *
- * A statement the Athena grammar refuses, one carrying an `UNNEST` that cannot
- * become a `json_each`, and one the parser cannot write back out all land the
- * same way. The engine has one answer to any of them, which is to turn the
- * query down and let the declared result take it. Nothing is reported from
- * here, since a query the engine cannot run is an ordinary thing for a test to
- * write.
+ * Three things stop it, and each is told apart because a strict engine fails
+ * the query with the reason. The Athena grammar can refuse the statement, an
+ * `UNNEST` in it can have no `json_each` to become, and the parser can decline
+ * to write the statement back out. A lenient engine answers all three the same
+ * way, by turning the query down and letting the declared result take it.
  */
 export function simAthenaSqliteSql(request) {
     const { parser } = request;
+    let read;
+    let ast;
+    try {
+        read = simAthenaSqlForParser(request.athenaSql);
+        ast = parser.astify(read.sql, { database: "athena" });
+    }
+    catch {
+        return turnedDown(simAthenaUnparsedStatement);
+    }
     try {
-        const read = simAthenaSqlForParser(request.athenaSql);
-        const ast = parser.astify(read.sql, { database: "athena" });
         if (!simAthenaRewriteUnnest({
             ast,
             ordinality: read.ordinality,
             tables: request.tables,
         })) {
-            return undefined;
+            return turnedDown(simAthenaUnrewrittenUnnest);
         }
-        return simAthenaSqlForSqlite(parser.sqlify(ast, { database: "sqlite" }));
+        return {
+            sql: simAthenaSqlForSqlite(parser.sqlify(ast, { database: "sqlite" })),
+            turnedDown: undefined,
+        };
     }
     catch {
-        return undefined;
+        return turnedDown(simAthenaUnwrittenStatement);
     }
 }
+function turnedDown(reason) {
+    return { sql: undefined, turnedDown: reason };
+}

package/dist/service/athena/engine/sim-athena-sqlite-values.d.ts

@@ -12,5 +12,10 @@ export type SimAthenaSqliteValue = string | number | bigint | null;
  * delimited text carries it as the word `true`, and a column holding the word
  * would otherwise compare against nothing and read back as `true` whichever
  * value it held.
+ *
+ * A `Date` is what a Parquet `TIMESTAMP`, `DATE` or `INT96` column arrives as.
+ * Text formats carry a timestamp as the text the object held, and this writes
+ * one the same way. Left as an object it would reach SQLite as quoted JSON, and
+ * every comparison against it would answer false while the query succeeded.
  */
 export declare function simAthenaSqliteValue(value: unknown, glueType: string | undefined): SimAthenaSqliteValue;

package/dist/service/athena/engine/sim-athena-sqlite-values.js

@@ -1,4 +1,19 @@
-import { simAthenaIsBooleanType } from "./sim-athena-column-types.js";
+import { simAthenaIsBooleanType, simAthenaIsDateType, } from "./sim-athena-column-types.js";
+/**
+ * One instant, as the text a column of its Glue type reads.
+ *
+ * Athena renders a `date` column as a day and a `timestamp` column as a day and
+ * a time, and the Glue column type is the only thing that says which this is.
+ */
+function simAthenaTimestampText(value, glueType) {
+    const iso = value.toISOString();
+    return simAthenaIsDateType(glueType)
+        ? iso.slice(0, 10)
+        : iso
+            .slice(0, 23)
+            .replace("T", " ")
+            .replace(/\.000$/u, "");
+}
 /** How delimited text writes a boolean, which JSON writes as a keyword. */
 const booleanText = new Map([
     ["true", 1],
@@ -18,6 +33,11 @@ const booleanText = new Map([
  * delimited text carries it as the word `true`, and a column holding the word
  * would otherwise compare against nothing and read back as `true` whichever
  * value it held.
+ *
+ * A `Date` is what a Parquet `TIMESTAMP`, `DATE` or `INT96` column arrives as.
+ * Text formats carry a timestamp as the text the object held, and this writes
+ * one the same way. Left as an object it would reach SQLite as quoted JSON, and
+ * every comparison against it would answer false while the query succeeded.
  */
 export function simAthenaSqliteValue(value, glueType) {
     if (value === undefined || value === null) {
@@ -34,5 +54,8 @@ export function simAthenaSqliteValue(value, glueType) {
     if (typeof value === "number") {
         return Number.isFinite(value) ? value : null;
     }
+    if (value instanceof Date) {
+        return simAthenaTimestampText(value, glueType);
+    }
     return typeof value === "bigint" ? value : JSON.stringify(value);
 }

package/dist/service/athena/engine/sim-athena-table-objects.d.ts

@@ -26,5 +26,10 @@ export interface SimAthenaTableObjects extends SimAthenaScannedObjects {
  * there because nothing holds the data it would answer from.
  */
 export declare function simAthenaTableObjects(s3: Partial<SimAthenaTableObjects> | undefined): SimAthenaTableObjects | undefined;
-/** One object's bytes, decompressed by its key and read as UTF-8 text. */
-export declare function simAthenaObjectText(objects: SimAthenaTableObjects, bucket: string, key: string, caller: SimAwsCaller | undefined): Promise<string>;
+/**
+ * One object's bytes, decompressed by the codec its key names.
+ *
+ * Decoding is left to the reader the table's SerDe picks, because a Parquet
+ * object holds no text to decode.
+ */
+export declare function simAthenaObjectBytes(objects: SimAthenaTableObjects, bucket: string, key: string, caller: SimAwsCaller | undefined): Promise<Uint8Array>;

package/dist/service/athena/engine/sim-athena-table-objects.js

@@ -10,10 +10,14 @@ export function simAthenaTableObjects(s3) {
         ? undefined
         : s3;
 }
-/** One object's bytes, decompressed by its key and read as UTF-8 text. */
-export async function simAthenaObjectText(objects, bucket, key, caller) {
+/**
+ * One object's bytes, decompressed by the codec its key names.
+ *
+ * Decoding is left to the reader the table's SerDe picks, because a Parquet
+ * object holds no text to decode.
+ */
+export async function simAthenaObjectBytes(objects, bucket, key, caller) {
     const got = await objects.getObject({ input: { Bucket: bucket, Key: key } }, caller === undefined ? undefined : { caller });
     const chunks = await Array.fromAsync(got.Body ?? []);
-    const bytes = simAthenaDecompressedBytes(key, Buffer.concat(chunks));
-    return new TextDecoder().decode(bytes);
+    return simAthenaDecompressedBytes(key, Buffer.concat(chunks));
 }

package/dist/service/athena/engine/sim-athena-table-rows.js

@@ -1,7 +1,7 @@
 import { simAthenaHivePartitionValues } from "./sim-athena-hive-partitions.js";
 import { simAthenaPartitionedObjects, } from "./sim-athena-partitioned-objects.js";
 import { simAthenaRecordReader, } from "./sim-athena-record-reader.js";
-import { simAthenaObjectText, } from "./sim-athena-table-objects.js";
+import { simAthenaObjectBytes, } from "./sim-athena-table-objects.js";
 /**
  * Every row one table holds for this query, or nothing where the engine has no
  * reader for what the table declares.
@@ -29,10 +29,11 @@ export async function simAthenaTableRows(request) {
  * A field the record itself carries wins over both.
  */
 async function objectRows(request, reader, one) {
-    const text = await simAthenaObjectText(request.objects, one.object.bucket, one.object.key, request.caller);
+    const bytes = await simAthenaObjectBytes(request.objects, one.object.bucket, one.object.key, request.caller);
     const partition = {
         ...simAthenaHivePartitionValues(one.object.key),
         ...Object.fromEntries(one.values),
     };
-    return reader(text).map((row) => ({ ...partition, ...row }));
+    const rows = await reader(bytes);
+    return rows.map((row) => ({ ...partition, ...row }));
 }

package/dist/service/athena/engine/sim-athena-turn-down.d.ts

@@ -0,0 +1,26 @@
+import type { SimAthenaCatalogTable } from "../table/sim-athena-catalog-table.js";
+/** Nothing in scope holds the objects a query would read. */
+export declare const simAthenaNoObjects = "The simulated Athena query engine has no simulated S3 to read this query's objects from.";
+/**
+ * The Athena grammar would not parse the statement.
+ *
+ * Nothing has reached SQLite at this point. A statement SQLite refuses to run
+ * is its own case, and it carries SQLite's own message out.
+ */
+export declare const simAthenaUnparsedStatement = "The simulated Athena query engine cannot read this statement. The Athena grammar refused it.";
+/** The statement's `UNNEST` has no `json_each` to become. */
+export declare const simAthenaUnrewrittenUnnest = "The simulated Athena query engine cannot rewrite this statement's UNNEST onto SQLite's json_each.";
+/** The parsed statement would not come back out as SQLite's dialect. */
+export declare const simAthenaUnwrittenStatement = "The simulated Athena query engine cannot write this statement back out for SQLite.";
+/** Whatever went wrong while the tables were loaded or the statement ran. */
+export declare function simAthenaRunFailure(error: unknown): string;
+/**
+ * One table the engine has no reader for.
+ *
+ * The SerDe is what decides, so the SerDe is what the reason names. A table
+ * carrying none is its own case, because there is nothing to name and nothing
+ * else in the catalog says what its objects hold.
+ */
+export declare function simAthenaUnreadableFormat(table: SimAthenaCatalogTable): string;
+/** One turn-down, as the reason a strict engine fails the query with. */
+export declare function simAthenaStrictRefusal(turnedDown: string): string;

package/dist/service/athena/engine/sim-athena-turn-down.js

@@ -0,0 +1,43 @@
+/** How every reason opens, so a test can match one without matching all of it. */
+const engine = "The simulated Athena query engine";
+/** What a strict engine tells a test to do about the query it failed. */
+const alternatives = `Declare what this query answers with through results(), or leave strict ` +
+    `mode off to fall back to a declaration.`;
+/** Nothing in scope holds the objects a query would read. */
+export const simAthenaNoObjects = `${engine} has no simulated S3 to read this query's objects from.`;
+/**
+ * The Athena grammar would not parse the statement.
+ *
+ * Nothing has reached SQLite at this point. A statement SQLite refuses to run
+ * is its own case, and it carries SQLite's own message out.
+ */
+export const simAthenaUnparsedStatement = `${engine} cannot read this statement. The Athena grammar refused it.`;
+/** The statement's `UNNEST` has no `json_each` to become. */
+export const simAthenaUnrewrittenUnnest = `${engine} cannot rewrite this statement's UNNEST onto SQLite's json_each.`;
+/** The parsed statement would not come back out as SQLite's dialect. */
+export const simAthenaUnwrittenStatement = `${engine} cannot write this statement back out for SQLite.`;
+/** Whatever went wrong while the tables were loaded or the statement ran. */
+export function simAthenaRunFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `${engine} could not answer this statement. ${message}`;
+}
+/**
+ * One table the engine has no reader for.
+ *
+ * The SerDe is what decides, so the SerDe is what the reason names. A table
+ * carrying none is its own case, because there is nothing to name and nothing
+ * else in the catalog says what its objects hold.
+ */
+export function simAthenaUnreadableFormat(table) {
+    const name = `${table.databaseName}.${table.name}`;
+    const serDe = table.storageDescriptor?.SerdeInfo?.SerializationLibrary;
+    if (serDe === undefined) {
+        return (`Table ${name} declares no SerDe, and ${engine.toLowerCase()} has ` +
+            `nothing to say what its objects hold.`);
+    }
+    return `${engine} has no reader for ${serDe}, which table ${name} declares.`;
+}
+/** One turn-down, as the reason a strict engine fails the query with. */
+export function simAthenaStrictRefusal(turnedDown) {
+    return `${turnedDown} ${alternatives}`;
+}

package/dist/service/athena/execution/sim-athena-query-completion.d.ts

@@ -14,7 +14,9 @@ interface SimAthenaQueryCompletionRequest {
  * only a query that got past all three goes on to be answered and written.
  *
  * A write that fails leaves the execution `FAILED` rather than raising at a
- * caller who was answered long ago and has gone away to poll.
+ * caller who was answered long ago and has gone away to poll. A strict engine
+ * turning the query down fails it the same way, and the reason names what the
+ * engine could not do.
  */
 export declare function simAthenaCompleteQuery(request: SimAthenaQueryCompletionRequest): Promise<void>;
 export {};

package/dist/service/athena/execution/sim-athena-query-completion.js

@@ -9,7 +9,9 @@ import { simAthenaWriteFailureReason } from "./sim-athena-write-failure.js";
  * only a query that got past all three goes on to be answered and written.
  *
  * A write that fails leaves the execution `FAILED` rather than raising at a
- * caller who was answered long ago and has gone away to poll.
+ * caller who was answered long ago and has gone away to poll. A strict engine
+ * turning the query down fails it the same way, and the reason names what the
+ * engine could not do.
  */
 export async function simAthenaCompleteQuery(request) {
     const { execution, caller, runner } = request;
@@ -42,6 +44,10 @@ export async function simAthenaCompleteQuery(request) {
         caller,
         startedAt: execution.submittedAt,
     });
+    if (answer.refusal !== undefined) {
+        execution.fail(answer.refusal, runner.background.now());
+        return;
+    }
     try {
         await runner.writer.write(execution, answer.result, caller);
     }

package/dist/service/athena/index.d.ts

@@ -9,7 +9,7 @@ export { SimAthenaResultConfiguration, type SimAthenaResultAcl, type SimAthenaRe
 export { SimAthenaWorkGroupStore } from "./workgroup/sim-athena-work-group-store.js";
 export { SimAthenaNamedQuery } from "./named-query/sim-athena-named-query.js";
 export { SimAthenaQueryExecution } from "./execution/sim-athena-query-execution.js";
-export { SimAthenaQueryEngine } from "./engine/sim-athena-query-engine.js";
+export { SimAthenaQueryEngine, type SimAthenaEngineOptions, } from "./engine/sim-athena-query-engine.js";
 export type { SimAthenaAnswerSource, SimAthenaQueryAnswer, } from "./result/sim-athena-query-answer.js";
 export type { SimAthenaCatalogColumn, SimAthenaCatalogSerDe, SimAthenaCatalogStorage, SimAthenaCatalogTable, } from "./table/sim-athena-catalog-table.js";
 export { SimAthenaQueryExecutionStore } from "./execution/sim-athena-query-execution-store.js";

package/dist/service/athena/index.js

@@ -7,7 +7,7 @@ export { SimAthenaResultConfiguration, } from "./workgroup/sim-athena-result-con
 export { SimAthenaWorkGroupStore } from "./workgroup/sim-athena-work-group-store.js";
 export { SimAthenaNamedQuery } from "./named-query/sim-athena-named-query.js";
 export { SimAthenaQueryExecution } from "./execution/sim-athena-query-execution.js";
-export { SimAthenaQueryEngine } from "./engine/sim-athena-query-engine.js";
+export { SimAthenaQueryEngine, } from "./engine/sim-athena-query-engine.js";
 export { SimAthenaQueryExecutionStore } from "./execution/sim-athena-query-execution-store.js";
 export { isSettledQueryState, } from "./execution/sim-athena-query-state.js";
 export { SimAthenaOutputLocation } from "./execution/sim-athena-output-location.js";

package/dist/service/athena/result/sim-athena-query-answer.d.ts

@@ -10,6 +10,14 @@ export type SimAthenaAnswerSource = "engine" | "declaration";
 export interface SimAthenaQueryAnswer {
     readonly result: SimAthenaResolvedResult;
     readonly source: SimAthenaAnswerSource;
+    /**
+     * Why the query fails rather than answering, where a strict engine turned it
+     * down.
+     *
+     * The declared result is still carried alongside, because it is what the
+     * query would have answered with had the engine not been strict.
+     */
+    readonly refusal: string | undefined;
 }
 interface SimAthenaQueryAnswerRequest {
     readonly queryString: string;
@@ -36,6 +44,10 @@ interface SimAthenaQueryAnswerRequest {
  * declarations again, where a workgroup rule or the default answers it. Every
  * test written before the engine existed therefore keeps working, whether or
  * not the engine is on.
+ *
+ * A strict engine is the exception, and it fails the query it turned down.
+ * The declaration keeps its place ahead of that, since a test writing one
+ * against this exact statement has already said what the engine gets wrong.
  */
 export declare function simAthenaQueryAnswer(request: SimAthenaQueryAnswerRequest): Promise<SimAthenaQueryAnswer>;
 export {};

package/dist/service/athena/result/sim-athena-query-answer.js

@@ -1,3 +1,4 @@
+import { simAthenaStrictRefusal } from "../engine/sim-athena-turn-down.js";
 /**
  * What one query answers with, from the engine or from a declaration.
  *
@@ -10,11 +11,15 @@
  * declarations again, where a workgroup rule or the default answers it. Every
  * test written before the engine existed therefore keeps working, whether or
  * not the engine is on.
+ *
+ * A strict engine is the exception, and it fails the query it turned down.
+ * The declaration keeps its place ahead of that, since a test writing one
+ * against this exact statement has already said what the engine gets wrong.
  */
 export async function simAthenaQueryAnswer(request) {
     const forQuery = request.results.declaredForQuery(request.queryString);
     if (forQuery !== undefined) {
-        return { result: forQuery, source: "declaration" };
+        return { result: forQuery, source: "declaration", refusal: undefined };
     }
     const computed = await request.engine.run({
         queryString: request.queryString,
@@ -24,7 +29,24 @@ export async function simAthenaQueryAnswer(request) {
         caller: request.caller,
         startedAt: request.startedAt,
     });
-    return computed === undefined
-        ? { result: request.declared, source: "declaration" }
-        : { result: computed, source: "engine" };
+    if (computed.result !== undefined) {
+        return { result: computed.result, source: "engine", refusal: undefined };
+    }
+    return {
+        result: request.declared,
+        source: "declaration",
+        refusal: strictRefusal(request.engine, computed.turnedDown),
+    };
+}
+/**
+ * Why a query fails, where a strict engine is what turned it down.
+ *
+ * An engine nobody turned on turns nothing down, and a lenient one turns a
+ * query down without failing it. Both answer from the declaration.
+ */
+function strictRefusal(engine, turnedDown) {
+    if (turnedDown === undefined || !engine.isStrict) {
+        return undefined;
+    }
+    return simAthenaStrictRefusal(turnedDown);
 }

package/dist/service/athena/sim-athena-answered-query.fixture.d.ts

@@ -4,6 +4,8 @@ import type { SimAthenaEngineSimulation } from "./sim-athena-engine.fixture.js";
 export interface SimAthenaEngineQuery {
     readonly state: string | undefined;
     readonly answeredBy: SimAthenaAnswerSource | undefined;
+    /** Why a failed query failed, which a refusal is what a test reads. */
+    readonly reason: string | undefined;
     readonly columns: readonly (string | undefined)[];
     readonly rows: readonly (readonly (string | undefined)[])[];
 }

package/dist/service/athena/sim-athena-answered-query.fixture.js

@@ -18,6 +18,7 @@ export async function anAnsweredQuery(simulation, queryString, database) {
     const answered = {
         state: execution?.state,
         answeredBy: execution?.answeredBy,
+        reason: execution?.stateChangeReason,
     };
     if (execution?.state !== "SUCCEEDED") {
         return { ...answered, columns: [], rows: [] };

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

@@ -1,3 +1,5 @@
+import { type BasicType } from "hyparquet-writer";
+import type { CompressionCodec } from "hyparquet";
 import type { SimClock } from "../../util/clock/sim-clock.js";
 import type { SimGlueColumn } from "../glue/table/sim-glue-table-schema.js";
 import { SimAws } from "../aws/sim-aws.js";
@@ -5,6 +7,10 @@ import { SimAws } from "../aws/sim-aws.js";
 export declare const jsonSerDe = "org.openx.data.jsonserde.JsonSerDe";
 /** The SerDe class name a quoted CSV table declares. */
 export declare const csvSerDe = "org.apache.hadoop.hive.serde2.OpenCSVSerde";
+/** The SerDe class name a Parquet table declares. */
+export declare const parquetSerDe = "org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe";
+/** The SerDe class name an ORC table declares, which nothing here reads. */
+export declare const orcSerDe = "org.apache.hadoop.hive.ql.io.orc.OrcSerde";
 /** Where every table in these fixtures keeps its data. */
 export declare const logsBucket = "rainlytics-logs";
 /** A simulation holding both Buckets, a workgroup and a catalog database. */
@@ -38,3 +44,17 @@ export declare function aSeededObject(simAws: SimAws, key: string, body: string)
 export declare function aSeededBytes(simAws: SimAws, key: string, body: Uint8Array): Promise<void>;
 /** Put one object of JSON lines under the logs Bucket. */
 export declare function aSeededJson(simAws: SimAws, key: string, records: readonly Record<string, unknown>[]): Promise<void>;
+/** One column of a Parquet fixture, with the values it holds. */
+export interface SimAthenaParquetColumn {
+    readonly name: string;
+    readonly data: readonly unknown[];
+    readonly type?: BasicType;
+}
+/**
+ * Put one Parquet object under the logs Bucket.
+ *
+ * `hyparquet-writer` is a development dependency of this repository alone. A
+ * project testing against a Parquet table brings its own file, or writes one
+ * however its production pipeline does.
+ */
+export declare function aSeededParquet(simAws: SimAws, key: string, columns: readonly SimAthenaParquetColumn[], codec?: CompressionCodec): Promise<void>;

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

@@ -1,9 +1,15 @@
 import { faker } from "@faker-js/faker";
+import { brotliCompressSync, deflateSync, gzipSync, zstdCompressSync, } from "node:zlib";
+import { parquetWriteBuffer, } from "hyparquet-writer";
 import { SimAws } from "../aws/sim-aws.js";
 /** The SerDe class name a JSON lines table declares. */
 export const jsonSerDe = "org.openx.data.jsonserde.JsonSerDe";
 /** The SerDe class name a quoted CSV table declares. */
 export const csvSerDe = "org.apache.hadoop.hive.serde2.OpenCSVSerde";
+/** The SerDe class name a Parquet table declares. */
+export const parquetSerDe = "org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe";
+/** The SerDe class name an ORC table declares, which nothing here reads. */
+export const orcSerDe = "org.apache.hadoop.hive.ql.io.orc.OrcSerde";
 /** Where every table in these fixtures keeps its data. */
 export const logsBucket = "rainlytics-logs";
 /**
@@ -69,3 +75,31 @@ export async function aSeededJson(simAws, key, records) {
     const lines = records.map((record) => JSON.stringify(record));
     await aSeededObject(simAws, key, `${lines.join("\n")}\n`);
 }
+/**
+ * What the writer compresses a page with, for the codecs it has not got.
+ *
+ * `hyparquet-writer` compresses snappy alone. These are what let a fixture
+ * produce a file in the codecs the reader takes from `node:zlib`, so those
+ * paths are exercised by a real file rather than by a label.
+ */
+const writeCompressors = {
+    GZIP: (bytes) => new Uint8Array(gzipSync(bytes)),
+    ZSTD: (bytes) => new Uint8Array(zstdCompressSync(bytes)),
+    BROTLI: (bytes) => new Uint8Array(brotliCompressSync(bytes)),
+    DEFLATE: (bytes) => new Uint8Array(deflateSync(bytes)),
+};
+/**
+ * Put one Parquet object under the logs Bucket.
+ *
+ * `hyparquet-writer` is a development dependency of this repository alone. A
+ * project testing against a Parquet table brings its own file, or writes one
+ * however its production pipeline does.
+ */
+export async function aSeededParquet(simAws, key, columns, codec = "SNAPPY") {
+    const buffer = parquetWriteBuffer({
+        codec,
+        compressors: writeCompressors,
+        columnData: columns,
+    });
+    await aSeededBytes(simAws, key, new Uint8Array(buffer));
+}