@kensio/yulin 1.21.21 → 1.21.23

package/dist/service/athena/engine/sim-athena-ast-nodes.d.ts

@@ -18,6 +18,17 @@ export interface SimAthenaFromItem extends SimAthenaAstNode {
     table: string;
     as?: string | null;
 }
+/** One value as a node, or nothing where it is not an object. */
+export declare function asAstNode(value: unknown): SimAthenaAstNode | undefined;
+/**
+ * The name a call carries, where the statement wrote it as one part.
+ *
+ * The parser holds a name as a list, one entry per piece of a qualified name,
+ * and it holds an `UNNEST` alias as a call of its own. A name written in more
+ * than one part answers with nothing, since neither the engine's functions nor
+ * an alias is reached that way.
+ */
+export declare function simAthenaCalledName(node: SimAthenaAstNode | undefined): string | undefined;
 /** Every node in the tree, the outermost first. */
 export declare function simAthenaAstNodes(root: unknown): Generator<SimAthenaAstNode>;
 /** Whether this node references a column. */

package/dist/service/athena/engine/sim-athena-ast-nodes.js

@@ -1,3 +1,25 @@
+/** One value as a node, or nothing where it is not an object. */
+export function asAstNode(value) {
+    return typeof value === "object" && value !== null
+        ? value
+        : undefined;
+}
+/**
+ * The name a call carries, where the statement wrote it as one part.
+ *
+ * The parser holds a name as a list, one entry per piece of a qualified name,
+ * and it holds an `UNNEST` alias as a call of its own. A name written in more
+ * than one part answers with nothing, since neither the engine's functions nor
+ * an alias is reached that way.
+ */
+export function simAthenaCalledName(node) {
+    const parts = asAstNode(node?.["name"])?.["name"];
+    const first = Array.isArray(parts) && parts.length === 1
+        ? asAstNode(parts[0])
+        : undefined;
+    const name = first?.["value"];
+    return typeof name === "string" ? name : undefined;
+}
 /** Every node in the tree, the outermost first. */
 export function* simAthenaAstNodes(root) {
     if (Array.isArray(root)) {

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

@@ -1,6 +1,14 @@
 import type { DatabaseSync } from "node:sqlite";
 import { SimAthenaResolvedResult } from "../result/sim-athena-resolved-result.js";
 import type { SimAthenaLoadedTable } from "./sim-athena-table-rows.js";
+/** What one statement is run and read back with. */
+export interface SimAthenaEngineResultRun {
+    readonly database: DatabaseSync;
+    readonly sql: string;
+    readonly loaded: readonly SimAthenaLoadedTable[];
+    /** The decimal places each result column was rounded to, by position. */
+    readonly scales: ReadonlyMap<number, number>;
+}
 /**
  * Run one translated statement and read its answer back as a result set.
  *
@@ -8,4 +16,4 @@ import type { SimAthenaLoadedTable } from "./sim-athena-table-rows.js";
  * free to answer with two columns of one name and an object would keep one of
  * them.
  */
-export declare function simAthenaEngineResult(database: DatabaseSync, sql: string, loaded: readonly SimAthenaLoadedTable[]): SimAthenaResolvedResult;
+export declare function simAthenaEngineResult(run: SimAthenaEngineResultRun): SimAthenaResolvedResult;

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

@@ -1,5 +1,6 @@
 import { SimAthenaResolvedResult } from "../result/sim-athena-resolved-result.js";
 import { simAthenaResultColumns } from "./sim-athena-result-columns.js";
+import { simAthenaRoundedText } from "./sim-athena-round-scales.js";
 /**
  * Run one translated statement and read its answer back as a result set.
  *
@@ -7,8 +8,8 @@ import { simAthenaResultColumns } from "./sim-athena-result-columns.js";
  * free to answer with two columns of one name and an object would keep one of
  * them.
  */
-export function simAthenaEngineResult(database, sql, loaded) {
-    const statement = database.prepare(sql);
+export function simAthenaEngineResult(run) {
+    const statement = run.database.prepare(run.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
@@ -16,12 +17,22 @@ export function simAthenaEngineResult(database, sql, loaded) {
     // Every one of them renders the same either way.
     statement.setReadBigInts(true);
     const rows = statement.all();
-    const columns = simAthenaResultColumns(statement.columns(), rows, loaded);
+    const columns = simAthenaResultColumns(statement.columns(), rows, run.loaded, run.scales);
     return new SimAthenaResolvedResult({
         columns,
-        rows: rows.map((row) => columns.map((column, index) => rendered(row[index], column))),
+        rows: rows.map((row) => columns.map((column, index) => renderedCell(row[index], column, run.scales.get(index)))),
     });
 }
+/**
+ * One value as `GetQueryResults` carries it, with the scale its column was
+ * rounded to where the statement asked for one.
+ */
+function renderedCell(value, column, scale) {
+    const text = rendered(value, column);
+    return scale === undefined || text === ""
+        ? text
+        : simAthenaRoundedText(value, scale);
+}
 /**
  * One value as `GetQueryResults` carries it.
  *

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

@@ -14,6 +14,8 @@ export interface SimAthenaEngineRun {
     readonly caller: SimAwsCaller | undefined;
     readonly startedAt: Date;
     readonly sql: string;
+    /** The decimal places each result column was rounded to, by position. */
+    readonly scales: ReadonlyMap<number, number>;
 }
 /**
  * Load the tables, build the database and run the statement.

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

@@ -29,7 +29,12 @@ export async function simAthenaEngineRun(run) {
             startedAt: run.startedAt,
         });
         try {
-            return simAthenaEngineAnswered(simAthenaEngineResult(database, run.sql, loaded));
+            return simAthenaEngineAnswered(simAthenaEngineResult({
+                database,
+                sql: run.sql,
+                loaded,
+                scales: run.scales,
+            }));
         }
         finally {
             database.close();

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

@@ -85,6 +85,7 @@ export class SimAthenaQueryEngine {
                 sqlite,
                 objects,
                 sql: translated.sql,
+                scales: translated.scales,
             });
     }
 }

package/dist/service/athena/engine/sim-athena-result-columns.d.ts

@@ -15,4 +15,4 @@ import type { SimAthenaLoadedTable } from "./sim-athena-table-rows.js";
  * could not have been written as an identifier is how that is told apart from
  * an alias a statement chose.
  */
-export declare function simAthenaResultColumns(metadata: readonly StatementColumnMetadata[], rows: readonly (readonly SQLOutputValue[])[], loaded: readonly SimAthenaLoadedTable[]): readonly SimAthenaDeclaredColumn[];
+export declare function simAthenaResultColumns(metadata: readonly StatementColumnMetadata[], rows: readonly (readonly SQLOutputValue[])[], loaded: readonly SimAthenaLoadedTable[], scales?: ReadonlyMap<number, number>): readonly SimAthenaDeclaredColumn[];

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

@@ -15,15 +15,22 @@ const identifier = /^[A-Za-z_][\dA-Za-z_]*$/u;
  * could not have been written as an identifier is how that is told apart from
  * an alias a statement chose.
  */
-export function simAthenaResultColumns(metadata, rows, loaded) {
+export function simAthenaResultColumns(metadata, rows, loaded, scales = new Map()) {
     const types = glueColumnTypes(loaded);
     return metadata.map((column, index) => ({
         name: nameOf(column, index),
-        type: column.column === null
-            ? inferredType(rows, index)
-            : simAthenaResultType(types.get(originOf(column))),
+        // A column the statement rounded to a scale is a double whatever value it
+        // happens to hold, since a whole number rounded to one place is still one.
+        type: scales.has(index)
+            ? "double"
+            : columnType({ column, rows, index, types }),
     }));
 }
+function columnType(read) {
+    return read.column.column === null
+        ? inferredType(read.rows, read.index)
+        : simAthenaResultType(read.types.get(originOf(read.column)));
+}
 function nameOf(column, index) {
     const { name } = column;
     if (column.column !== null || identifier.test(name)) {

package/dist/service/athena/engine/sim-athena-round-scales.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The decimal places each result column was rounded to, by position.
+ *
+ * `round(x, 1)` answers `25.0` on Trino and `25` here, because SQLite hands
+ * back a double and nothing downstream knows how many places the statement
+ * asked to keep. The statement is the only thing that knows, so the scale is
+ * read off the syntax tree while it is still there and travels with the query.
+ *
+ * Only a literal scale is read. `round(x, n)` over a column is a scale that
+ * differs per row, and a result column has one rendering for every row in it.
+ */
+export declare function simAthenaRoundScales(ast: unknown): ReadonlyMap<number, number>;
+/**
+ * One rounded value as its column renders it.
+ *
+ * A whole number keeps the trailing zeros the scale asked for, which is the
+ * whole point of carrying the scale this far.
+ */
+export declare function simAthenaRoundedText(value: unknown, scale: number): string;

package/dist/service/athena/engine/sim-athena-round-scales.js

@@ -0,0 +1,80 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+/**
+ * The decimal places each result column was rounded to, by position.
+ *
+ * `round(x, 1)` answers `25.0` on Trino and `25` here, because SQLite hands
+ * back a double and nothing downstream knows how many places the statement
+ * asked to keep. The statement is the only thing that knows, so the scale is
+ * read off the syntax tree while it is still there and travels with the query.
+ *
+ * Only a literal scale is read. `round(x, n)` over a column is a scale that
+ * differs per row, and a result column has one rendering for every row in it.
+ */
+export function simAthenaRoundScales(ast) {
+    const scales = new Map();
+    for (const [index, item] of selectItems(ast).entries()) {
+        const scale = roundScaleOf(item);
+        if (scale !== undefined) {
+            scales.set(index, scale);
+        }
+    }
+    return scales;
+}
+/**
+ * One rounded value as its column renders it.
+ *
+ * A whole number keeps the trailing zeros the scale asked for, which is the
+ * whole point of carrying the scale this far.
+ */
+export function simAthenaRoundedText(value, scale) {
+    return typeof value === "number" ? value.toFixed(scale) : String(value);
+}
+/**
+ * The select list of the statement, which is the first one where a query
+ * carries several.
+ */
+function selectItems(ast) {
+    const statement = Array.isArray(ast) ? ast[0] : ast;
+    const columns = isRecord(statement) ? statement["columns"] : undefined;
+    return Array.isArray(columns) ? columns : [];
+}
+/**
+ * The scale one select item was rounded to, for an item that is a `round` call
+ * over a literal scale.
+ */
+function roundScaleOf(item) {
+    const expression = isRecord(item) ? item["expr"] : undefined;
+    if (!isRecord(expression) || functionNameOf(expression) !== "round") {
+        return undefined;
+    }
+    const arguments_ = callArguments(expression);
+    return arguments_.length === 2 ? literalScale(arguments_[1]) : undefined;
+}
+/**
+ * The name a function call node carries, which the parser holds as a list of
+ * the parts a qualified name would have.
+ */
+function functionNameOf(expression) {
+    const name = isRecord(expression["name"])
+        ? expression["name"]["name"]
+        : undefined;
+    const first = Array.isArray(name) ? name[0] : undefined;
+    const value = isRecord(first) ? first["value"] : undefined;
+    return typeof value === "string" ? value.toLowerCase() : "";
+}
+/**
+ * The arguments a function call node carries.
+ */
+function callArguments(expression) {
+    const arguments_ = expression["args"];
+    const value = isRecord(arguments_) ? arguments_["value"] : undefined;
+    return Array.isArray(value) ? value : [];
+}
+/**
+ * A whole number written into the statement, or nothing for anything else.
+ */
+function literalScale(node) {
+    const value = isRecord(node) && node["type"] === "number" ? node["value"] : undefined;
+    const scale = Number(value);
+    return Number.isSafeInteger(scale) && scale >= 0 ? scale : undefined;
+}

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

@@ -3,14 +3,23 @@ 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;
 };

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

@@ -1,6 +1,7 @@
 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 { simAthenaRoundScales } from "./sim-athena-round-scales.js";
 import { simAthenaRewriteUnnest } from "./sim-athena-unnest-rewrite.js";
 /**
  * One Athena statement written back out for SQLite, or why it is not.
@@ -29,7 +30,12 @@ export function simAthenaSqliteSql(request) {
     }
     const rejected = simAthenaRejectedStatement(ast);
     if (rejected !== undefined) {
-        return { sql: undefined, turnedDown: undefined, rejected };
+        return {
+            sql: undefined,
+            scales: undefined,
+            turnedDown: undefined,
+            rejected,
+        };
     }
     try {
         if (!simAthenaRewriteUnnest({
@@ -39,8 +45,12 @@ export function simAthenaSqliteSql(request) {
         })) {
             return turnedDown(simAthenaUnrewrittenUnnest);
         }
+        // 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,
         };
@@ -50,5 +60,10 @@ export function simAthenaSqliteSql(request) {
     }
 }
 function turnedDown(reason) {
-    return { sql: undefined, turnedDown: reason, rejected: undefined };
+    return {
+        sql: undefined,
+        scales: undefined,
+        turnedDown: reason,
+        rejected: undefined,
+    };
 }

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

@@ -1,4 +1,5 @@
-import { shimNumber, shimText, simAthenaScalarShim, } from "./sim-athena-shim-registry.js";
+import { SimAthenaSetUpError } from "../error/sim-athena.error.js";
+import { isExplicitNull, shimNumber, shimText, simAthenaScalarShim, } from "./sim-athena-shim-registry.js";
 /**
  * Trino's string functions.
  *
@@ -8,9 +9,36 @@ import { shimNumber, shimText, simAthenaScalarShim, } from "./sim-athena-shim-re
  * with something that works less well.
  */
 export function simAthenaInstallStringShims(database) {
+    simAthenaScalarShim(database, "split", (...values) => isExplicitNull(values, 2)
+        ? null
+        : split(shimText(values.at(0)), shimText(values.at(1)), shimNumber(values.at(2))));
     simAthenaScalarShim(database, "split_part", (value, delimiter, index) => splitPart(shimText(value), shimText(delimiter), shimNumber(index)));
     simAthenaScalarShim(database, "strpos", (value, search) => position(shimText(value), shimText(search)));
 }
+/**
+ * One value cut into an array, written as the JSON text an array is held as.
+ *
+ * Trino answers with one empty element over an empty value, and refuses an
+ * empty delimiter rather than answering a character at a time. A limit caps
+ * how many elements come back and leaves the rest of the value in the last of
+ * them.
+ */
+function split(value, delimiter, limit) {
+    if (value === undefined || delimiter === undefined) {
+        return null;
+    }
+    if (delimiter === "" || (limit !== undefined && limit < 1)) {
+        throw new SimAthenaSetUpError("split takes a delimiter of at least one character and a limit from one");
+    }
+    const parts = value.split(delimiter);
+    if (limit === undefined || parts.length <= limit) {
+        return JSON.stringify(parts);
+    }
+    return JSON.stringify([
+        ...parts.slice(0, limit - 1),
+        parts.slice(limit - 1).join(delimiter),
+    ]);
+}
 /** Trino counts the fields from one, and has no field below that. */
 function splitPart(value, delimiter, index) {
     if (value === undefined || delimiter === undefined || index === undefined) {

package/dist/service/athena/engine/sim-athena-unnest-item.js

@@ -1,4 +1,4 @@
-import { simAthenaAstNodes, } from "./sim-athena-ast-nodes.js";
+import { asAstNode, simAthenaAstNodes, simAthenaCalledName, } from "./sim-athena-ast-nodes.js";
 /**
  * The `UNNEST` a statement flattens an array or a map with.
  *
@@ -19,8 +19,8 @@ export function simAthenaUnnestItem(ast) {
     }
     const alias = aliasOf(item);
     const columns = aliasColumns(item);
-    const source = item["expr"];
-    if (alias === undefined || columns === undefined || !isNode(source)) {
+    const source = asAstNode(item["expr"]);
+    if (alias === undefined || columns === undefined || source === undefined) {
         return { kind: "unreadable" };
     }
     return { kind: "found", item, alias, columns, source };
@@ -38,25 +38,16 @@ function isCrossJoined(item) {
 }
 /** The alias name, which the parser holds as a function's name. */
 function aliasOf(item) {
-    const parts = asNode(asNode(item["as"])?.["name"])?.["name"];
-    const first = Array.isArray(parts) ? asNode(parts[0]) : undefined;
-    const value = first?.["value"];
-    return typeof value === "string" ? value : undefined;
+    return simAthenaCalledName(asAstNode(item["as"]));
 }
 /** The names inside the alias, which the parser holds as a function's arguments. */
 function aliasColumns(item) {
-    const values = asNode(asNode(item["as"])?.["args"])?.["value"];
+    const values = asAstNode(asAstNode(item["as"])?.["args"])?.["value"];
     if (!Array.isArray(values) || values.length === 0) {
         return undefined;
     }
-    const columns = values.map((value) => asNode(value)?.["column"]);
+    const columns = values.map((value) => asAstNode(value)?.["column"]);
     return columns.every((column) => typeof column === "string")
         ? columns
         : undefined;
 }
-function isNode(value) {
-    return typeof value === "object" && value !== null;
-}
-function asNode(value) {
-    return isNode(value) ? value : undefined;
-}

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

@@ -7,10 +7,10 @@ interface SimAthenaUnnestRewriteRequest {
 /**
  * Turn an `UNNEST` into the `json_each` SQLite flattens JSON with.
  *
- * An array or a map column is held as its JSON text, and `json_each` reads that
- * as one row per element with a `key` and a `value`. The `FROM` entry becomes a
- * call to it and every reference to the alias is pointed at the column it
- * answers with.
+ * An array or a map column is held as its JSON text, as is what a function like
+ * `split` answers, and `json_each` reads that as one row per element with a
+ * `key` and a `value`. The `FROM` entry becomes a call to it and every
+ * reference to the alias is pointed at the column it answers with.
  *
  * Answers with whether the statement can run. A statement carrying no `UNNEST`
  * runs untouched, and one carrying an `UNNEST` this cannot turn into

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

@@ -6,10 +6,10 @@ import { simAthenaUnnestTargets } from "./sim-athena-unnest-targets.js";
 /**
  * Turn an `UNNEST` into the `json_each` SQLite flattens JSON with.
  *
- * An array or a map column is held as its JSON text, and `json_each` reads that
- * as one row per element with a `key` and a `value`. The `FROM` entry becomes a
- * call to it and every reference to the alias is pointed at the column it
- * answers with.
+ * An array or a map column is held as its JSON text, as is what a function like
+ * `split` answers, and `json_each` reads that as one row per element with a
+ * `key` and a `value`. The `FROM` entry becomes a call to it and every
+ * reference to the alias is pointed at the column it answers with.
  *
  * Answers with whether the statement can run. A statement carrying no `UNNEST`
  * runs untouched, and one carrying an `UNNEST` this cannot turn into

package/dist/service/athena/engine/sim-athena-unnest-source.d.ts

@@ -3,17 +3,18 @@ import { type SimAthenaAstNode } from "./sim-athena-ast-nodes.js";
 /** The two things Athena flattens with `UNNEST`. */
 export type SimAthenaUnnestKind = "array" | "map";
 /**
- * What the statement is flattening, read off the Glue schema.
+ * What the statement is flattening.
  *
- * The catalog is the only thing that says whether a column holds an array, a
- * map or a scalar, and `json_each` answers with different columns for the first
- * two. A column the schema calls anything else answers with nothing here, and
- * the query falls back rather than reading a value as a collection it never
- * was.
+ * A column is read off the Glue schema. The catalog is the only thing that says
+ * whether a column holds an array, a map or a scalar, and `json_each` answers
+ * with different columns for the first two. A column the schema calls anything
+ * else answers with nothing here, and the query falls back rather than reading
+ * a value as a collection it never was.
  *
- * An expression that is not a plain column reference answers with nothing too.
- * `UNNEST(split(x, ','))` is a real Athena query and the schema says nothing
- * about what it comes to.
+ * An expression is read off the function it calls. `UNNEST(split(x, ','))` is
+ * how a statement flattens a delimited string, and nothing but the call says
+ * what it comes to. A call to anything else answers with nothing, since the
+ * flattening would otherwise run over whatever SQLite made of a scalar.
  */
 export declare function simAthenaUnnestKind(source: SimAthenaAstNode, ast: unknown, tables: readonly SimAthenaCatalogTable[]): SimAthenaUnnestKind | undefined;
 /** Every catalog table the statement reads, by the name it reaches each one by. */

package/dist/service/athena/engine/sim-athena-unnest-source.js

@@ -1,20 +1,29 @@
-import { isColumnRef, isFromItem, simAthenaAstNodes, } from "./sim-athena-ast-nodes.js";
+import { isColumnRef, isFromItem, simAthenaAstNodes, simAthenaCalledName, } from "./sim-athena-ast-nodes.js";
 /**
- * What the statement is flattening, read off the Glue schema.
+ * The engine's own functions that answer an array.
  *
- * The catalog is the only thing that says whether a column holds an array, a
- * map or a scalar, and `json_each` answers with different columns for the first
- * two. A column the schema calls anything else answers with nothing here, and
- * the query falls back rather than reading a value as a collection it never
- * was.
+ * An expression has no catalog entry to read, so the call itself is what says
+ * the value is a collection. Each of these answers with the JSON text an array
+ * column is held as, which is what `json_each` reads.
+ */
+const arrayFunctions = new Set(["split", "slice"]);
+/**
+ * What the statement is flattening.
+ *
+ * A column is read off the Glue schema. The catalog is the only thing that says
+ * whether a column holds an array, a map or a scalar, and `json_each` answers
+ * with different columns for the first two. A column the schema calls anything
+ * else answers with nothing here, and the query falls back rather than reading
+ * a value as a collection it never was.
  *
- * An expression that is not a plain column reference answers with nothing too.
- * `UNNEST(split(x, ','))` is a real Athena query and the schema says nothing
- * about what it comes to.
+ * An expression is read off the function it calls. `UNNEST(split(x, ','))` is
+ * how a statement flattens a delimited string, and nothing but the call says
+ * what it comes to. A call to anything else answers with nothing, since the
+ * flattening would otherwise run over whatever SQLite made of a scalar.
  */
 export function simAthenaUnnestKind(source, ast, tables) {
     if (!isColumnRef(source)) {
-        return undefined;
+        return answersArray(source) ? "array" : undefined;
     }
     const declared = declaredType(source, ast, tables);
     if (declared === undefined) {
@@ -26,6 +35,11 @@ export function simAthenaUnnestKind(source, ast, tables) {
     }
     return type.startsWith("map") ? "map" : undefined;
 }
+/** Whether this expression is a call to a function answering an array. */
+function answersArray(source) {
+    const name = source["type"] === "function" ? simAthenaCalledName(source) : undefined;
+    return name !== undefined && arrayFunctions.has(name.toLowerCase());
+}
 /** Every catalog table the statement reads, by the name it reaches each one by. */
 export function simAthenaQueryTables(ast, tables) {
     const byName = new Map();

package/dist/service/athena/sim-athena-flattened-events.fixture.d.ts

@@ -0,0 +1,3 @@
+import { type SimAthenaEngineSimulation } from "./sim-athena-engine.fixture.js";
+/** A simulation holding the events, with the engine on. */
+export declare function anEventSimulation(): Promise<SimAthenaEngineSimulation>;

package/dist/service/athena/sim-athena-flattened-events.fixture.js

@@ -0,0 +1,46 @@
+import { aCatalogTable, anEngineSimulation, aSeededJson, } from "./sim-athena-engine.fixture.js";
+/**
+ * The events a flattening query reads.
+ *
+ * Each holds a collection of every shape an `UNNEST` reaches. An array and a
+ * map that are empty, a delimited string that is empty, and a row carrying no
+ * delimited string at all, which is what a flattening answering no rows runs
+ * over.
+ */
+const events = [
+    {
+        id: 1,
+        tags: ["red", "blue"],
+        attrs: { size: "large" },
+        name: "one",
+        packed: "red;blue",
+    },
+    { id: 2, tags: [], attrs: {}, name: "two", packed: "" },
+    {
+        id: 3,
+        tags: ["green"],
+        attrs: { size: "small", colour: "green" },
+        name: "three",
+    },
+];
+/** A simulation holding the events, with the engine on. */
+export async function anEventSimulation() {
+    const simulation = await anEngineSimulation();
+    aCatalogTable(simulation.simAws, {
+        name: "events",
+        columns: [
+            { Name: "id", Type: "int" },
+            { Name: "tags", Type: "array<string>" },
+            { Name: "attrs", Type: "map<string,string>" },
+            { Name: "name", Type: "string" },
+            { Name: "packed", Type: "string" },
+        ],
+    });
+    await aSeededJson(simulation.simAws, "events/part-0.json", events);
+    await simulation.simAws.athena().engine().enable();
+    simulation.simAws
+        .athena()
+        .results()
+        .byDefault({ columns: ["fallback"], rows: [["declared"]] });
+    return simulation;
+}

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-properties.js

@@ -1,3 +1,4 @@
+import { simLambdaFilterCriteriaInput } from "../../event-source/filter/sim-lambda-filter-criteria.js";
 import { simLambdaStreamDestinationConfig } from "../../event-source/sim-lambda-stream-destination-config.js";
 import { SimCfnLambdaPropertyParser } from "../function/sim-cfn-lambda-property-parser.js";
 import { recordUnsimulatedEventSourceMappingProperties } from "./sim-cfn-lambda-event-source-mapping-property-rules.js";
@@ -46,6 +47,7 @@ export class SimCfnLambdaEventSourceMappingProperties {
             StartingPosition: this.parser.optionalString(this.resource, this.properties["StartingPosition"], "StartingPosition"),
             StartingPositionTimestamp: this.startingPositionTimestamp(),
             FunctionResponseTypes: this.functionResponseTypes(),
+            FilterCriteria: simLambdaFilterCriteriaInput(this.properties["FilterCriteria"]),
         };
     }
     /**

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-property-names.js

@@ -44,13 +44,9 @@ const absentEventSource = "the mapping polls the source its EventSourceArn names
 export const unsimulatedPropertyReasons = new Map([
     ["AmazonManagedKafkaEventSourceConfig", absentEventSource],
     ["DocumentDBEventSourceConfig", absentEventSource],
-    [
-        "FilterCriteria",
-        "every record on the event source is delivered to the function, unfiltered",
-    ],
     [
         "KmsKeyArn",
-        "the key encrypts filter criteria, and filter criteria are not simulated",
+        "filter criteria are simulated in plaintext, and encrypting them is not",
     ],
     ["MetricsConfig", "the mapping publishes no CloudWatch metrics"],
     [