@kensio/yulin 1.21.29 → 1.21.30

package/dist/service/athena/engine/sim-athena-array-shims.js

@@ -57,7 +57,7 @@ function joined(array, delimiter, absent) {
  * One element written out.
  *
  * Trino refuses to join an array whose elements are not text, and raising here
- * turns the query down to its declared result instead.
+ * fails the query the same way.
  */
 function scalarText(value) {
     if (typeof value === "string") {

package/dist/service/athena/engine/sim-athena-binary-text.d.ts

@@ -3,8 +3,8 @@ import type { SQLOutputValue } from "node:sqlite";
  * One encoded string read back to bytes, or null where it is null.
  *
  * Trino fails the query over text the encoding cannot carry, and `Buffer` reads
- * as much of it as it can and drops the rest. Raising here turns the query down
- * instead, which is nearer to Trino's answer than bytes nobody wrote.
+ * as much of it as it can and drops the rest. Raising here fails the query the
+ * way Trino does.
  */
 export declare function simAthenaDecodedText(text: string | undefined, encoding: "base64" | "hex"): Uint8Array | null;
 /**

package/dist/service/athena/engine/sim-athena-binary-text.js

@@ -20,8 +20,8 @@ const encodedReplacement = Buffer.from([0xef, 0xbf, 0xbd]);
  * One encoded string read back to bytes, or null where it is null.
  *
  * Trino fails the query over text the encoding cannot carry, and `Buffer` reads
- * as much of it as it can and drops the rest. Raising here turns the query down
- * instead, which is nearer to Trino's answer than bytes nobody wrote.
+ * as much of it as it can and drops the rest. Raising here fails the query the
+ * way Trino does.
  */
 export function simAthenaDecodedText(text, encoding) {
     if (text === undefined) {

package/dist/service/athena/engine/sim-athena-cast-rewrite.d.ts

@@ -0,0 +1,30 @@
+import type { SimAthenaCatalogTable } from "../table/sim-athena-catalog-table.js";
+/**
+ * The shims a cast to `DATE` and to `TIMESTAMP` are handed to.
+ *
+ * The names have the simulator's prefix so that neither can collide with a
+ * Trino function a statement calls itself.
+ */
+export declare const simAthenaDateCast = "sim_athena_cast_date";
+export declare const simAthenaTimestampCast = "sim_athena_cast_timestamp";
+/** The second argument a shim is handed where the value it casts is text. */
+export declare const simAthenaCastSource = "varchar";
+/**
+ * Hand every cast to `DATE` or `TIMESTAMP` in the tree to the engine's shims.
+ *
+ * SQLite gives a column declared `DATE` or `TIMESTAMP` numeric affinity, so a
+ * plain `CAST('2026-08-15' AS DATE)` keeps the leading number and answers
+ * `2026`. Every date function downstream of that cast then reads a year where
+ * it expected a date.
+ *
+ * Trino's one-argument `date(x)` is the cast to `DATE` under another name,
+ * and it goes to the same shim. SQLite's own `date()` answers null over text
+ * that is no date, where Trino fails the cast.
+ *
+ * Trino reads text more strictly than a value already typed as a timestamp,
+ * and the shim is told which it has. A string literal and a column the catalog
+ * declares as text are text. Anything else is taken to be a date or a
+ * timestamp already, since the engine cannot tell the type a function answers
+ * with.
+ */
+export declare function simAthenaRewriteCasts(ast: unknown, tables: readonly SimAthenaCatalogTable[]): void;

package/dist/service/athena/engine/sim-athena-cast-rewrite.js

@@ -0,0 +1,107 @@
+import { asAstNode, isColumnRef, replaceNode, simAthenaAstNodes, simAthenaCalledName, } from "./sim-athena-ast-nodes.js";
+/**
+ * The shims a cast to `DATE` and to `TIMESTAMP` are handed to.
+ *
+ * The names have the simulator's prefix so that neither can collide with a
+ * Trino function a statement calls itself.
+ */
+export const simAthenaDateCast = "sim_athena_cast_date";
+export const simAthenaTimestampCast = "sim_athena_cast_timestamp";
+/** The second argument a shim is handed where the value it casts is text. */
+export const simAthenaCastSource = "varchar";
+/** The shim each cast target goes to. */
+const castShims = new Map([
+    ["DATE", simAthenaDateCast],
+    ["TIMESTAMP", simAthenaTimestampCast],
+]);
+/** The Glue types a column of text is declared with. */
+const textTypes = /^(?:string|varchar|char)\b/iu;
+/**
+ * Hand every cast to `DATE` or `TIMESTAMP` in the tree to the engine's shims.
+ *
+ * SQLite gives a column declared `DATE` or `TIMESTAMP` numeric affinity, so a
+ * plain `CAST('2026-08-15' AS DATE)` keeps the leading number and answers
+ * `2026`. Every date function downstream of that cast then reads a year where
+ * it expected a date.
+ *
+ * Trino's one-argument `date(x)` is the cast to `DATE` under another name,
+ * and it goes to the same shim. SQLite's own `date()` answers null over text
+ * that is no date, where Trino fails the cast.
+ *
+ * Trino reads text more strictly than a value already typed as a timestamp,
+ * and the shim is told which it has. A string literal and a column the catalog
+ * declares as text are text. Anything else is taken to be a date or a
+ * timestamp already, since the engine cannot tell the type a function answers
+ * with.
+ */
+export function simAthenaRewriteCasts(ast, tables) {
+    const textColumns = textColumnsOf(tables);
+    for (const node of simAthenaAstNodes(ast)) {
+        const cast = castOf(node);
+        if (cast !== undefined) {
+            replaceNode(node, {
+                type: "function",
+                name: { name: [{ type: "default", value: cast.shim }] },
+                args: {
+                    type: "expr_list",
+                    value: [cast.value, sourceOf(cast.value, textColumns)],
+                },
+                over: null,
+            });
+        }
+    }
+}
+function castOf(node) {
+    if (node["type"] === "cast") {
+        const shim = castShims.get(targetOf(node["target"]));
+        return shim === undefined ? undefined : { shim, value: node["expr"] };
+    }
+    const values = asAstNode(node["args"])?.["value"];
+    if (node["type"] !== "function" ||
+        simAthenaCalledName(node)?.toLowerCase() !== "date" ||
+        !Array.isArray(values) ||
+        values.length !== 1) {
+        return undefined;
+    }
+    return { shim: simAthenaDateCast, value: values[0] };
+}
+/** The one type a cast names, upper cased, or nothing for anything else. */
+function targetOf(target) {
+    const only = Array.isArray(target) && target.length === 1 ? target[0] : null;
+    const dataType = asAstNode(only)?.["dataType"];
+    return typeof dataType === "string" ? dataType.toUpperCase() : "";
+}
+/** The second argument that tells the shim whether its value is text. */
+function sourceOf(value, textColumns) {
+    const node = asAstNode(value);
+    const isText = node?.["type"] === "single_quote_string" ||
+        (node !== undefined &&
+            isColumnRef(node) &&
+            textColumns.has(node.column.toLowerCase()));
+    return {
+        type: "single_quote_string",
+        value: isText ? simAthenaCastSource : "",
+    };
+}
+/**
+ * Every column name the tables declare as text and as nothing else.
+ *
+ * A name two tables declare with different types is left out, since the
+ * statement could mean either and only text is held to the stricter read.
+ */
+function textColumnsOf(tables) {
+    const text = new Set();
+    const other = new Set();
+    for (const table of tables) {
+        for (const column of [...table.columns, ...table.partitionKeys]) {
+            const name = column.Name.toLowerCase();
+            if (textTypes.test(column.Type ?? "")) {
+                text.add(name);
+            }
+            else {
+                other.add(name);
+            }
+        }
+    }
+    return text.difference(other);
+}

package/dist/service/athena/engine/sim-athena-cast-shims.d.ts

@@ -0,0 +1,12 @@
+import type { DatabaseSync } from "node:sqlite";
+/**
+ * Trino's casts to `DATE` and `TIMESTAMP`, which SQLite cannot do itself.
+ *
+ * SQLite gives both types numeric affinity, so its own cast of
+ * `'2026-08-15'` answers `2026`. The statement's casts are rewritten onto
+ * these shims before it runs, and the rewrite says whether the value is text.
+ *
+ * A value the cast cannot read fails the query with Trino's own message, the
+ * way Athena fails it.
+ */
+export declare function simAthenaInstallCastShims(database: DatabaseSync): void;

package/dist/service/athena/engine/sim-athena-cast-shims.js

@@ -0,0 +1,29 @@
+import { SimAthenaSetUpError } from "../error/sim-athena.error.js";
+import { simAthenaCastSource, simAthenaDateCast, simAthenaTimestampCast, } from "./sim-athena-cast-rewrite.js";
+import { simAthenaCastInstant, simAthenaCastRendered, } from "./sim-athena-cast-text.js";
+import { shimText, simAthenaScalarShim } from "./sim-athena-shim-registry.js";
+/**
+ * Trino's casts to `DATE` and `TIMESTAMP`, which SQLite cannot do itself.
+ *
+ * SQLite gives both types numeric affinity, so its own cast of
+ * `'2026-08-15'` answers `2026`. The statement's casts are rewritten onto
+ * these shims before it runs, and the rewrite says whether the value is text.
+ *
+ * A value the cast cannot read fails the query with Trino's own message, the
+ * way Athena fails it.
+ */
+export function simAthenaInstallCastShims(database) {
+    simAthenaScalarShim(database, simAthenaDateCast, (value, source) => cast(value, source, "date"), "CAST(... AS DATE)");
+    simAthenaScalarShim(database, simAthenaTimestampCast, (value, source) => cast(value, source, "timestamp"), "CAST(... AS TIMESTAMP)");
+}
+function cast(value, source, type) {
+    const text = shimText(value);
+    if (text === undefined) {
+        return null;
+    }
+    const instant = simAthenaCastInstant(text, type, source === simAthenaCastSource);
+    if (instant === undefined) {
+        throw new SimAthenaSetUpError(`Value cannot be cast to ${type}: ${text}`);
+    }
+    return simAthenaCastRendered(instant, type);
+}

package/dist/service/athena/engine/sim-athena-cast-text.d.ts

@@ -0,0 +1,13 @@
+/** The two types a cast in the engine reads a value as. */
+export type SimAthenaCastType = "date" | "timestamp";
+/**
+ * The instant one value names as the cast reads it, or nothing where the cast
+ * fails.
+ *
+ * Text is held to the formats Trino's cast from `varchar` takes. Any other
+ * source is a value some column or function already typed as a date or a
+ * timestamp, written as the ISO-8601 text the engine holds one as.
+ */
+export declare function simAthenaCastInstant(text: string, type: SimAthenaCastType, fromText: boolean): number | undefined;
+/** One instant rendered as Athena renders a value of the type. */
+export declare function simAthenaCastRendered(instant: number, type: SimAthenaCastType): string;

package/dist/service/athena/engine/sim-athena-cast-text.js

@@ -0,0 +1,66 @@
+// Both patterns below are anchored at each end with every quantifier bounded,
+// so there is nothing in either to backtrack over.
+// oxlint-disable security/detect-unsafe-regex
+import { simAthenaInstant } from "./sim-athena-timestamp-text.js";
+/**
+ * What Trino's cast from `varchar` to `DATE` reads, once the text is trimmed.
+ *
+ * A time of day is refused. `CAST('2026-08-15 10:00:00' AS DATE)` fails on
+ * Athena, and only a timestamp value loses its time to a cast.
+ */
+const varcharDate = /^(\d{4})-(\d{1,2})-(\d{1,2})$/u;
+/**
+ * What Trino's cast from `varchar` to `TIMESTAMP` reads.
+ *
+ * The time follows a space. A `T` between the date and the time fails the
+ * cast on Athena, and so does a zone, which belongs to `TIMESTAMP WITH TIME
+ * ZONE`.
+ */
+const varcharTimestamp = /^(\d{4})-(\d{1,2})-(\d{1,2})(?: (\d{1,2}):(\d{1,2})(?::(\d{1,2})(?:\.(\d{1,12}))?)?)?$/u;
+/**
+ * The instant one value names as the cast reads it, or nothing where the cast
+ * fails.
+ *
+ * Text is held to the formats Trino's cast from `varchar` takes. Any other
+ * source is a value some column or function already typed as a date or a
+ * timestamp, written as the ISO-8601 text the engine holds one as.
+ */
+export function simAthenaCastInstant(text, type, fromText) {
+    if (!fromText) {
+        return simAthenaInstant(text);
+    }
+    const fields = type === "date"
+        ? varcharDate.exec(text.trim())
+        : varcharTimestamp.exec(text);
+    return fields === null ? undefined : instantOf(fields);
+}
+/** One instant rendered as Athena renders a value of the type. */
+export function simAthenaCastRendered(instant, type) {
+    const iso = new Date(instant).toISOString();
+    return type === "date"
+        ? iso.slice(0, 10)
+        : iso.slice(0, 23).replace("T", " ");
+}
+/**
+ * The instant a matched value names, where every field is in range.
+ *
+ * `Date.UTC` rolls the 30th of February over into March, and Trino refuses
+ * it. Each field is checked against its calendar before anything is built.
+ * A fraction rounds to the millisecond, which is the precision Athena gives a
+ * `TIMESTAMP` with none written.
+ */
+function instantOf(fields) {
+    const [year, month, day, hour, minute, second] = Array.from({ length: 6 }, (_, index) => Number(fields[index + 1] ?? 0));
+    const lastDay = new Date(Date.UTC(year, month, 0)).getUTCDate();
+    if (month < 1 ||
+        month > 12 ||
+        day < 1 ||
+        day > lastDay ||
+        hour > 23 ||
+        minute > 59 ||
+        second > 59) {
+        return undefined;
+    }
+    const milliseconds = Math.round(Number(`0.${fields[7] ?? "0"}`) * 1000);
+    return Date.UTC(year, month - 1, day, hour, minute, second, milliseconds);
+}

package/dist/service/athena/engine/sim-athena-comparison-shims.js

@@ -57,8 +57,7 @@ function isNumeric(value) {
  * One argument as the text it orders by.
  *
  * A `varbinary` orders by its bytes in Trino, and nothing written out here
- * orders the same way. A call over one raises and the query falls back to its
- * declared result.
+ * orders the same way. A call over one raises and the query fails.
  */
 function comparableText(value) {
     if (value instanceof Uint8Array) {

package/dist/service/athena/engine/sim-athena-date-arithmetic-shims.d.ts

@@ -2,10 +2,9 @@ import type { DatabaseSync } from "node:sqlite";
 /**
  * Trino's date arithmetic, over ISO-8601 text.
  *
- * Each of these raises rather than guessing where it cannot answer faithfully.
- * A unit outside the ones Trino names and a value that is no ISO-8601 timestamp
- * both land there, and the engine turns the query down and lets the declared
- * result answer. A shim answering a null instead would be a wrong answer
- * wearing the shape of a right one.
+ * Each of these raises where it cannot answer faithfully. A unit outside the
+ * ones Trino names and a value that is no ISO-8601 timestamp both land there,
+ * and the engine fails the query with the reason. A shim answering a null
+ * would be a wrong answer wearing the shape of a right one.
  */
 export declare function simAthenaInstallDateArithmeticShims(database: DatabaseSync): void;

package/dist/service/athena/engine/sim-athena-date-arithmetic-shims.js

@@ -6,11 +6,10 @@ import { simAthenaInstant, simAthenaRenderLike, } from "./sim-athena-timestamp-t
 /**
  * Trino's date arithmetic, over ISO-8601 text.
  *
- * Each of these raises rather than guessing where it cannot answer faithfully.
- * A unit outside the ones Trino names and a value that is no ISO-8601 timestamp
- * both land there, and the engine turns the query down and lets the declared
- * result answer. A shim answering a null instead would be a wrong answer
- * wearing the shape of a right one.
+ * Each of these raises where it cannot answer faithfully. A unit outside the
+ * ones Trino names and a value that is no ISO-8601 timestamp both land there,
+ * and the engine fails the query with the reason. A shim answering a null
+ * would be a wrong answer wearing the shape of a right one.
  */
 export function simAthenaInstallDateArithmeticShims(database) {
     simAthenaScalarShim(database, "date_add", (unit, value, timestamp) => {
@@ -47,13 +46,7 @@ function unitOf(value) {
         ? unit
         : raise(`${unit} is no date unit the engine reads`);
 }
-/**
- * Turn the query down.
- *
- * A shim that cannot answer faithfully raises, and the engine catches it and
- * lets the declared result answer. Answering a null instead would be a wrong
- * answer wearing the shape of a right one.
- */
+/** Fail the query, saying why the shim could not answer. */
 function raise(reason) {
     throw new SimAthenaSetUpError(reason);
 }
@@ -63,8 +56,7 @@ function raise(reason) {
  * Trino answers with a timestamp carrying the zone. There is nowhere to put one
  * here, so the answer is the wall clock alone, with any `Z` the value arrived
  * with taken off. A `Z` left on would say UTC over a time that is no longer in
- * it. A zone nobody has heard of raises out of `Intl`, and the query falls
- * back.
+ * it. A zone nobody has heard of raises out of `Intl`, and the query fails.
  */
 function inZone(at, zone) {
     if (at === undefined || zone === undefined) {

package/dist/service/athena/engine/sim-athena-date-units.d.ts

@@ -3,7 +3,7 @@
  *
  * A shim answering a unit it does not know would be answering wrongly, so the
  * ones here are the whole of what `date_add` and `date_diff` take. Anything
- * else raises, and the engine turns the query down.
+ * else raises, and the query fails.
  */
 export declare function isDateUnit(unit: string): boolean;
 /**

package/dist/service/athena/engine/sim-athena-date-units.js

@@ -19,7 +19,7 @@ const calendarUnits = new Map([
  *
  * A shim answering a unit it does not know would be answering wrongly, so the
  * ones here are the whole of what `date_add` and `date_diff` take. Anything
- * else raises, and the engine turns the query down.
+ * else raises, and the query fails.
  */
 export function isDateUnit(unit) {
     return clockUnits.has(unit) || calendarUnits.has(unit);

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

@@ -10,7 +10,12 @@ export interface SimAthenaEngineAnswer {
     readonly result: SimAthenaResolvedResult | undefined;
     /** What the engine could not do, where it turned the query down. */
     readonly turnedDown: string | undefined;
-    /** Why Athena refuses the statement, where the engine found it invalid. */
+    /**
+     * Why the query fails whether or not the engine is strict.
+     *
+     * That is a statement Athena refuses, or one the engine ran and could not
+     * evaluate.
+     */
     readonly rejected: string | undefined;
 }
 /** One answer the engine ran for real. */
@@ -18,11 +23,11 @@ export declare function simAthenaEngineAnswered(result: SimAthenaResolvedResult)
 /** One query the engine turned down, and why. */
 export declare function simAthenaEngineTurnedDown(turnedDown: string): SimAthenaEngineAnswer;
 /**
- * One statement Athena refuses, and why.
+ * One statement that fails whatever mode the engine is in, and why.
  *
- * The engine ran nothing. A query that reaches this fails whether or not the
- * engine is strict, since the alternative is a green test on SQL the service
- * rejects.
+ * Athena refusing the statement is one reason, and the alternative there is a
+ * green test on SQL the service rejects. A function shim refusing a value is
+ * the other, and the alternative there is a query losing every row in silence.
  */
 export declare function simAthenaEngineRejected(rejected: string): SimAthenaEngineAnswer;
 /** An engine nobody turned on, which has no opinion about the query. */

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

@@ -7,11 +7,11 @@ export function simAthenaEngineTurnedDown(turnedDown) {
     return { result: undefined, turnedDown, rejected: undefined };
 }
 /**
- * One statement Athena refuses, and why.
+ * One statement that fails whatever mode the engine is in, and why.
  *
- * The engine ran nothing. A query that reaches this fails whether or not the
- * engine is strict, since the alternative is a green test on SQL the service
- * rejects.
+ * Athena refusing the statement is one reason, and the alternative there is a
+ * green test on SQL the service rejects. A function shim refusing a value is
+ * the other, and the alternative there is a query losing every row in silence.
  */
 export function simAthenaEngineRejected(rejected) {
     return { result: undefined, turnedDown: undefined, rejected };

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

@@ -29,5 +29,9 @@ export interface SimAthenaEngineRun {
  *
  * Each of them carries a reason out, which a strict engine fails the query
  * with.
+ *
+ * A function shim refusing one of the statement's values is the exception. The
+ * engine ran the statement and could not evaluate it, and the query fails
+ * whether or not the engine is strict.
  */
 export declare function simAthenaEngineRun(run: SimAthenaEngineRun): Promise<SimAthenaEngineAnswer>;

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

@@ -1,6 +1,7 @@
-import { simAthenaEngineAnswered, simAthenaEngineTurnedDown, } from "./sim-athena-engine-answer.js";
-import { simAthenaRunFailure } from "./sim-athena-turn-down.js";
+import { simAthenaEngineAnswered, simAthenaEngineRejected, simAthenaEngineTurnedDown, } from "./sim-athena-engine-answer.js";
+import { simAthenaRunFailure, simAthenaUnevaluable, } from "./sim-athena-turn-down.js";
 import { simAthenaEngineResult } from "./sim-athena-engine-result.js";
+import { SimAthenaShimRefusal } from "./sim-athena-shim-refusal.js";
 import { simAthenaSqliteDatabase } from "./sim-athena-sqlite-database.js";
 import { simAthenaLoadedTables } from "./sim-athena-loaded-tables.js";
 /**
@@ -15,6 +16,10 @@ import { simAthenaLoadedTables } from "./sim-athena-loaded-tables.js";
  *
  * Each of them carries a reason out, which a strict engine fails the query
  * with.
+ *
+ * A function shim refusing one of the statement's values is the exception. The
+ * engine ran the statement and could not evaluate it, and the query fails
+ * whether or not the engine is strict.
  */
 export async function simAthenaEngineRun(run) {
     try {
@@ -41,6 +46,9 @@ export async function simAthenaEngineRun(run) {
         }
     }
     catch (error) {
+        if (error instanceof SimAthenaShimRefusal) {
+            return simAthenaEngineRejected(simAthenaUnevaluable(error));
+        }
         return simAthenaEngineTurnedDown(simAthenaRunFailure(error));
     }
 }

package/dist/service/athena/engine/sim-athena-regexp-shims.js

@@ -28,8 +28,8 @@ function matches(value, pattern) {
  *
  * Trino counts the groups from one and calls the whole match zero, which is
  * what a regular expression counts them as anywhere. Trino also refuses a group
- * the pattern has not got, and raising here turns the query down rather than
- * letting a negative index quietly count back from the end.
+ * the pattern has not got, and raising here fails the query where a negative
+ * index would quietly count back from the end.
  */
 function extracted(value, pattern, group) {
     if (!Number.isSafeInteger(group) || group < 0) {

package/dist/service/athena/engine/sim-athena-shim-refusal.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A Trino function shim that could not answer for one value.
+ *
+ * Each shim raises where it cannot answer faithfully, such as a date function
+ * handed text that is no timestamp. SQLite hands the error back out of the
+ * statement unchanged, and this class is how the engine tells it apart from
+ * SQLite refusing the statement itself.
+ *
+ * The engine fails the query on one of these whether or not it is strict. The
+ * statement parsed and SQLite ran it, so falling back would answer a query the
+ * engine had taken on with rows a declaration wrote for some other purpose,
+ * often no rows at all.
+ */
+export declare class SimAthenaShimRefusal extends Error {
+    readonly name = "SimAthenaShimRefusal";
+    constructor(described: string, cause: unknown);
+}

package/dist/service/athena/engine/sim-athena-shim-refusal.js

@@ -0,0 +1,22 @@
+/**
+ * A Trino function shim that could not answer for one value.
+ *
+ * Each shim raises where it cannot answer faithfully, such as a date function
+ * handed text that is no timestamp. SQLite hands the error back out of the
+ * statement unchanged, and this class is how the engine tells it apart from
+ * SQLite refusing the statement itself.
+ *
+ * The engine fails the query on one of these whether or not it is strict. The
+ * statement parsed and SQLite ran it, so falling back would answer a query the
+ * engine had taken on with rows a declaration wrote for some other purpose,
+ * often no rows at all.
+ */
+export class SimAthenaShimRefusal extends Error {
+    name = "SimAthenaShimRefusal";
+    constructor(described, cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        super(`${described} could not answer for this statement's values. ${reason}`, {
+            cause,
+        });
+    }
+}

package/dist/service/athena/engine/sim-athena-shim-registry.d.ts

@@ -7,8 +7,12 @@ export type SimAthenaScalarShim = (...values: SQLOutputValue[]) => SQLInputValue
  * Every shim takes any number of arguments, because SQLite checks the count
  * against the JavaScript function's own arity otherwise and a Trino function
  * with an optional argument would stop resolving.
+ *
+ * Anything the shim raises comes back out as a `SimAthenaShimRefusal` naming
+ * the function as a statement wrote it, which fails the query. `described`
+ * is that name where it differs from the one registered.
  */
-export declare function simAthenaScalarShim(database: DatabaseSync, name: string, implementation: SimAthenaScalarShim): void;
+export declare function simAthenaScalarShim(database: DatabaseSync, name: string, implementation: SimAthenaScalarShim, described?: string): void;
 /**
  * Whether an optional argument was written as an explicit `NULL`.
  *

package/dist/service/athena/engine/sim-athena-shim-registry.js

@@ -1,12 +1,24 @@
+import { SimAthenaShimRefusal } from "./sim-athena-shim-refusal.js";
 /**
  * Register one Trino scalar function on this database.
  *
  * Every shim takes any number of arguments, because SQLite checks the count
  * against the JavaScript function's own arity otherwise and a Trino function
  * with an optional argument would stop resolving.
+ *
+ * Anything the shim raises comes back out as a `SimAthenaShimRefusal` naming
+ * the function as a statement wrote it, which fails the query. `described`
+ * is that name where it differs from the one registered.
  */
-export function simAthenaScalarShim(database, name, implementation) {
-    database.function(name, { varargs: true, deterministic: true }, (...values) => withEmptyBytes(implementation(...values)));
+export function simAthenaScalarShim(database, name, implementation, described = name) {
+    database.function(name, { varargs: true, deterministic: true }, (...values) => {
+        try {
+            return withEmptyBytes(implementation(...values));
+        }
+        catch (error) {
+            throw new SimAthenaShimRefusal(described, error);
+        }
+    });
 }
 /**
  * One answer, with an empty `varbinary` written so that SQLite keeps it.

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

@@ -1,6 +1,7 @@
 import { simAthenaInstallAggregateShims } from "./sim-athena-aggregate-shims.js";
 import { simAthenaInstallArrayShims } from "./sim-athena-array-shims.js";
 import { simAthenaInstallBinaryShims } from "./sim-athena-binary-shims.js";
+import { simAthenaInstallCastShims } from "./sim-athena-cast-shims.js";
 import { simAthenaInstallClockShims } from "./sim-athena-clock-shims.js";
 import { simAthenaInstallComparisonShims } from "./sim-athena-comparison-shims.js";
 import { simAthenaInstallDateArithmeticShims } from "./sim-athena-date-arithmetic-shims.js";
@@ -22,6 +23,7 @@ export function simAthenaInstallShims(database, startedAt) {
     simAthenaInstallClockShims(database, startedAt);
     simAthenaInstallDateShims(database);
     simAthenaInstallDateArithmeticShims(database);
+    simAthenaInstallCastShims(database);
     simAthenaInstallJsonShims(database);
     simAthenaInstallJsonDocumentShims(database);
     simAthenaInstallArrayShims(database);

package/dist/service/athena/engine/sim-athena-sql-translation.d.ts

@@ -1,28 +1,6 @@
 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 was not. */
-export type SimAthenaTranslatedSql = {
-    readonly sql: string;
-    /**
-     * The decimal places each result column was rounded to, by position.
-     *
-     * Read here because the syntax tree is the only place that knows, and
-     * the tree is gone by the time the answer is rendered.
-     */
-    readonly scales: ReadonlyMap<number, number>;
-    readonly turnedDown: undefined;
-    readonly rejected: undefined;
-} | {
-    readonly sql: undefined;
-    readonly scales: undefined;
-    readonly turnedDown: string;
-    readonly rejected: undefined;
-} | {
-    readonly sql: undefined;
-    readonly scales: undefined;
-    readonly turnedDown: undefined;
-    readonly rejected: string;
-};
+import { type SimAthenaTranslatedSql } from "./sim-athena-translated-sql.js";
 interface SimAthenaSqlTranslationRequest {
     readonly parser: SimAthenaSqlParser;
     readonly athenaSql: string;

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

@@ -1,7 +1,9 @@
 import { simAthenaSqlForParser, simAthenaSqlForSqlite, } from "./sim-athena-sql-rewrites.js";
 import { simAthenaUnparsedStatement, simAthenaUnrewrittenUnnest, simAthenaUnwrittenStatement, } from "./sim-athena-turn-down.js";
 import { simAthenaRejectedStatement } from "./sim-athena-rejected-statement.js";
+import { simAthenaRewriteCasts } from "./sim-athena-cast-rewrite.js";
 import { simAthenaRoundScales } from "./sim-athena-round-scales.js";
+import { simAthenaRejectedSql, simAthenaTranslated, simAthenaTurnedDownSql, } from "./sim-athena-translated-sql.js";
 import { simAthenaRewriteUnnest } from "./sim-athena-unnest-rewrite.js";
 /**
  * One Athena statement written back out for SQLite, or why it is not.
@@ -26,16 +28,11 @@ export function simAthenaSqliteSql(request) {
         ast = parser.astify(read.sql, { database: "athena" });
     }
     catch {
-        return turnedDown(simAthenaUnparsedStatement);
+        return simAthenaTurnedDownSql(simAthenaUnparsedStatement);
     }
     const rejected = simAthenaRejectedStatement(ast);
     if (rejected !== undefined) {
-        return {
-            sql: undefined,
-            scales: undefined,
-            turnedDown: undefined,
-            rejected,
-        };
+        return simAthenaRejectedSql(rejected);
     }
     try {
         if (!simAthenaRewriteUnnest({
@@ -43,27 +40,15 @@ export function simAthenaSqliteSql(request) {
             ordinality: read.ordinality,
             tables: request.tables,
         })) {
-            return turnedDown(simAthenaUnrewrittenUnnest);
+            return simAthenaTurnedDownSql(simAthenaUnrewrittenUnnest);
         }
+        simAthenaRewriteCasts(ast, request.tables);
         // Read before the tree is written back out, since the rewrites above can
         // move a select item and the scale travels by position.
         const scales = simAthenaRoundScales(ast);
-        return {
-            sql: simAthenaSqlForSqlite(parser.sqlify(ast, { database: "sqlite" })),
-            scales,
-            turnedDown: undefined,
-            rejected: undefined,
-        };
+        return simAthenaTranslated(simAthenaSqlForSqlite(parser.sqlify(ast, { database: "sqlite" })), scales);
     }
     catch {
-        return turnedDown(simAthenaUnwrittenStatement);
+        return simAthenaTurnedDownSql(simAthenaUnwrittenStatement);
     }
 }
-function turnedDown(reason) {
-    return {
-        sql: undefined,
-        scales: undefined,
-        turnedDown: reason,
-        rejected: undefined,
-    };
-}

package/dist/service/athena/engine/sim-athena-translated-sql.d.ts

@@ -0,0 +1,29 @@
+/** One statement translated for SQLite, or why it was not. */
+export type SimAthenaTranslatedSql = {
+    readonly sql: string;
+    /**
+     * The decimal places each result column was rounded to, by position.
+     *
+     * Read here because the syntax tree is the only place that knows, and
+     * the tree is gone by the time the answer is rendered.
+     */
+    readonly scales: ReadonlyMap<number, number>;
+    readonly turnedDown: undefined;
+    readonly rejected: undefined;
+} | {
+    readonly sql: undefined;
+    readonly scales: undefined;
+    readonly turnedDown: string;
+    readonly rejected: undefined;
+} | {
+    readonly sql: undefined;
+    readonly scales: undefined;
+    readonly turnedDown: undefined;
+    readonly rejected: string;
+};
+/** One statement written out for SQLite, with the scales read off its tree. */
+export declare function simAthenaTranslated(sql: string, scales: ReadonlyMap<number, number>): SimAthenaTranslatedSql;
+/** One statement the engine turned down, and why. */
+export declare function simAthenaTurnedDownSql(turnedDown: string): SimAthenaTranslatedSql;
+/** One statement Athena refuses, and why. */
+export declare function simAthenaRejectedSql(rejected: string): SimAthenaTranslatedSql;

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

@@ -0,0 +1,12 @@
+/** One statement written out for SQLite, with the scales read off its tree. */
+export function simAthenaTranslated(sql, scales) {
+    return { sql, scales, turnedDown: undefined, rejected: undefined };
+}
+/** One statement the engine turned down, and why. */
+export function simAthenaTurnedDownSql(turnedDown) {
+    return { sql: undefined, scales: undefined, turnedDown, rejected: undefined };
+}
+/** One statement Athena refuses, and why. */
+export function simAthenaRejectedSql(rejected) {
+    return { sql: undefined, scales: undefined, turnedDown: undefined, rejected };
+}

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

@@ -14,6 +14,13 @@ export declare const simAthenaUnrewrittenUnnest = "The simulated Athena query en
 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;
+/**
+ * A function shim that could not answer for one of the statement's values.
+ *
+ * This fails the query whether or not the engine is strict, so the reason
+ * points at the one declaration that still answers it.
+ */
+export declare function simAthenaUnevaluable(refusal: Error): string;
 /**
  * One table the engine has no reader for.
  *

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

@@ -21,6 +21,17 @@ export function simAthenaRunFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return `${engine} could not answer this statement. ${message}`;
 }
+/**
+ * A function shim that could not answer for one of the statement's values.
+ *
+ * This fails the query whether or not the engine is strict, so the reason
+ * points at the one declaration that still answers it.
+ */
+export function simAthenaUnevaluable(refusal) {
+    return (`${engine} cannot evaluate this statement. ${refusal.message} ` +
+        `Declare what this exact query answers with through results() to answer ` +
+        `it without the engine.`);
+}
 /**
  * One table the engine has no reader for.
  *

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

@@ -51,7 +51,8 @@ interface SimAthenaQueryAnswerRequest {
  *
  * A statement Athena refuses fails whichever mode the engine is in. That is
  * SQL the service would never have run, and falling back would leave the query
- * green on it.
+ * green on it. So does a statement the engine ran and could not evaluate,
+ * where falling back to the default would answer with no rows at all.
  */
 export declare function simAthenaQueryAnswer(request: SimAthenaQueryAnswerRequest): Promise<SimAthenaQueryAnswer>;
 export {};

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

@@ -18,7 +18,8 @@ import { simAthenaStrictRefusal } from "../engine/sim-athena-turn-down.js";
  *
  * A statement Athena refuses fails whichever mode the engine is in. That is
  * SQL the service would never have run, and falling back would leave the query
- * green on it.
+ * green on it. So does a statement the engine ran and could not evaluate,
+ * where falling back to the default would answer with no rows at all.
  */
 export async function simAthenaQueryAnswer(request) {
     const forQuery = request.results.declaredForQuery(request.queryString);

package/dist/service/athena/sim-athena-snapshot-table.fixture.d.ts

@@ -0,0 +1,10 @@
+import { type SimAthenaEngineSimulation } from "./sim-athena-engine.fixture.js";
+/**
+ * A table of snapshots partitioned by a string `day`, with the engine on and
+ * a default declaration that a fallback would answer with.
+ *
+ * `taken_at` is a Glue `timestamp` written as ISO-8601 with a `T` and a `Z`.
+ * `noted_at` is a `string` holding a timestamp the way Trino's cast from text
+ * reads one.
+ */
+export declare function aSnapshotSimulation(): Promise<SimAthenaEngineSimulation>;

package/dist/service/athena/sim-athena-snapshot-table.fixture.js

@@ -0,0 +1,39 @@
+import { aCatalogTable, anEngineSimulation, aSeededJson, } from "./sim-athena-engine.fixture.js";
+/**
+ * A table of snapshots partitioned by a string `day`, with the engine on and
+ * a default declaration that a fallback would answer with.
+ *
+ * `taken_at` is a Glue `timestamp` written as ISO-8601 with a `T` and a `Z`.
+ * `noted_at` is a `string` holding a timestamp the way Trino's cast from text
+ * reads one.
+ */
+export async function aSnapshotSimulation() {
+    const simulation = await anEngineSimulation();
+    aCatalogTable(simulation.simAws, {
+        name: "snapshots",
+        columns: [
+            { Name: "sku", Type: "string" },
+            { Name: "taken_at", Type: "timestamp" },
+            { Name: "noted_at", Type: "string" },
+        ],
+        partitionKeys: [{ Name: "day", Type: "string" }],
+    });
+    await aSeededJson(simulation.simAws, "snapshots/day=2026-08-15/part-0.json", [
+        {
+            sku: "bolt",
+            taken_at: "2026-08-15T23:30:00Z",
+            noted_at: "2026-08-15 10:00:00",
+        },
+        {
+            sku: "nut",
+            taken_at: "2026-08-14T08:00:00Z",
+            noted_at: "2026-08-14 09:15:00.5",
+        },
+    ]);
+    await simulation.simAws.athena().engine().enable();
+    simulation.simAws
+        .athena()
+        .results()
+        .byDefault({ columns: ["fallback"], rows: [["declared"]] });
+    return simulation;
+}

package/docs/services/athena/README.md

@@ -383,8 +383,8 @@ test's own statement about a query the engine gets wrong.
 
 ### Failing a statement Athena refuses
 
-One failure ignores strict mode. Where the engine can see that Athena would refuse a statement
-outright, the query fails whether strict mode is on or off. A turn-down means the engine reached its
+Two failures ignore strict mode. This section covers the first. Where the engine can see that
+Athena would refuse a statement outright, the query fails whether strict mode is on or off. A turn-down means the engine reached its
 limits, and a declaration is a fair answer to that. A rejection means the SQL is invalid, and
 answering from a declaration would leave a test green on a query that fails against AWS.
 
@@ -411,6 +411,18 @@ well, since the two names differ and nothing shadows.
 Trino and SQLite resolve names by different rules in other places too, and the engine catches this
 one. A statement that behaves differently under the two is worth reporting.
 
+### Failing a value a function cannot read
+
+The second failure that ignores strict mode comes from a Trino function the engine runs. Where one
+cannot answer faithfully for a value the statement hands it, the query fails with a
+`StateChangeReason` naming the function and the value. `date_add('fortnight', ...)` fails this way,
+and so does `CAST(sku AS DATE)` over a column holding no date.
+
+The engine took the statement on and ran it, so falling back would answer from rows a declaration
+wrote for some other purpose. A query with no declaration of its own would answer from the
+default, which is often no rows at all, and a test reading it would see an empty result with no
+error. A declaration written against the exact query text still answers it.
+
 ### The objects it reads
 
 The SerDe class name in the table's storage descriptor says how its objects are decoded.
@@ -560,7 +572,7 @@ call written inside a string literal is left alone as well.
 instant it froze, and the same test answers the same way on every machine. Athena reads both at the
 instant the query started, which is what the execution records.
 
-A function that cannot answer faithfully raises rather than guessing, and the query falls back.
+A function that cannot answer faithfully raises rather than guessing, and the query fails.
 `date_add` with a unit Trino does not name, `slice` starting at zero, `array_join` over an array of
 objects, `least` over a `varbinary`, and `regexp_extract` naming a capture group the pattern has not
 got all land there. A null
@@ -1064,7 +1076,7 @@ Current documented limitations:
   statement comparing the answer against a bare string matches on one and not the other.
 - A timestamp carrying a numeric UTC offset falls outside the date functions, and so does one
   written finer than the millisecond. A value written with a `Z` or with no zone at all reads as
-  UTC, and a value the date functions cannot read turns the query down.
+  UTC, and a value the date functions cannot read fails the query.
 - A JSON number beyond about fifteen significant digits loses the digits past that, wherever the
   engine reads JSON. An identifier of that size in a JSON lines object comes back rounded, and a
   filter on it can then match the wrong row.
@@ -1088,9 +1100,9 @@ Current documented limitations:
   written any other way gets whatever slicing that text comes to.
 - A `varbinary` in a result row reads as its bytes decoded as UTF-8. A digest read that way loses
   whatever in it was no UTF-8. A query answering with one wants `to_hex` or `to_base64` around it.
-- `from_hex` and `from_base64` turn the query down over text the encoding cannot carry. Trino fails
-  the query, and reading as much of the text as parses would answer with bytes nobody wrote.
-- `from_utf8` with a replacement named turns the query down where the bytes already carry the
+- `from_hex` and `from_base64` fail the query over text the encoding cannot carry, as Trino does.
+  The alternative, reading as much of the text as parses, would answer with bytes nobody wrote.
+- `from_utf8` with a replacement named fails the query where the bytes already carry the
   replacement character. Trino writes the replacement only where a sequence was broken, and nothing
   survives decoding to tell one of those apart from a character the bytes held.
 - `spooky_hash_v2_32` and `spooky_hash_v2_64` are absent, and so are the other Trino hashes with no
@@ -1107,7 +1119,16 @@ Current documented limitations:
   runs.
 - `try_cast` runs as a plain cast. `try_cast('abc' AS integer)` therefore answers 0 where real
   Athena answers null, which is the same forgiving direction as the cast above. Reading the
-  statement without the rewrite would turn the whole query down.
+  statement without the rewrite would turn the whole query down. A `try_cast` to `DATE` or
+  `TIMESTAMP` over text the cast cannot read fails the query, where Athena answers null.
+- `CAST(x AS DATE)`, `date(x)` and `CAST(x AS TIMESTAMP)` read text the way Trino's cast from
+  `varchar` does. A date is `yyyy-MM-dd` and nothing else. A timestamp is a date, optionally
+  followed by a space and a time, with no `T` and no zone. A timestamp renders as
+  `2026-08-15 10:00:00.000`, and a fraction finer than the millisecond is rounded.
+- A cast reads its value as text only where it is a string literal or a column the catalog declares
+  as `string`, `varchar` or `char`. Anything else, such as a `timestamp` column or the answer of a
+  function, is taken to be a date or a timestamp already, and any ISO-8601 form of it is accepted.
+  The answer is text in a `varchar` column, where Athena reports a `date` or a `timestamp`.
 - A `decimal` column is held as a double. A value carrying more than about fifteen significant
   digits loses the ones past that, and a filter, a sum or a group on it can then answer
   differently from Athena's exact arithmetic.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/yulin",
-  "version": "1.21.29",
+  "version": "1.21.30",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": "https://github.com/KensioSoftware/yulin",
   "homepage": "https://yulinsim.dev/",