@kensio/yulin 1.21.18 → 1.21.19

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

@@ -0,0 +1,29 @@
+import type { SimAthenaResolvedResult } from "../result/sim-athena-resolved-result.js";
+/**
+ * What the engine came to for one query.
+ *
+ * A turn-down carries why, because a strict engine fails the query with it and
+ * a reader of that failing test has to learn which of them it hit.
+ */
+export interface SimAthenaEngineAnswer {
+    /** The rows, where the engine ran the statement. */
+    readonly result: SimAthenaResolvedResult | undefined;
+    /** What the engine could not do, where it turned the query down. */
+    readonly turnedDown: string | undefined;
+    /** Why Athena refuses the statement, where the engine found it invalid. */
+    readonly rejected: string | undefined;
+}
+/** One answer the engine ran for real. */
+export declare function simAthenaEngineAnswered(result: SimAthenaResolvedResult): SimAthenaEngineAnswer;
+/** One query the engine turned down, and why. */
+export declare function simAthenaEngineTurnedDown(turnedDown: string): SimAthenaEngineAnswer;
+/**
+ * One statement Athena refuses, 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.
+ */
+export declare function simAthenaEngineRejected(rejected: string): SimAthenaEngineAnswer;
+/** An engine nobody turned on, which has no opinion about the query. */
+export declare function simAthenaEngineSilent(): SimAthenaEngineAnswer;

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

@@ -0,0 +1,22 @@
+/** One answer the engine ran for real. */
+export function simAthenaEngineAnswered(result) {
+    return { result, turnedDown: undefined, rejected: undefined };
+}
+/** One query the engine turned down, and why. */
+export function simAthenaEngineTurnedDown(turnedDown) {
+    return { result: undefined, turnedDown, rejected: undefined };
+}
+/**
+ * One statement Athena refuses, 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.
+ */
+export function simAthenaEngineRejected(rejected) {
+    return { result: undefined, turnedDown: undefined, rejected };
+}
+/** An engine nobody turned on, which has no opinion about the query. */
+export function simAthenaEngineSilent() {
+    return { result: undefined, turnedDown: undefined, rejected: undefined };
+}

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

@@ -1,25 +1,9 @@
 import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
 import type { SimAthenaPlannedTable } from "../execution/sim-athena-query-refusal.js";
-import type { SimAthenaResolvedResult } from "../result/sim-athena-resolved-result.js";
+import { type SimAthenaEngineAnswer } from "./sim-athena-engine-answer.js";
 import type { SimAthenaSqlParser } from "./sim-athena-parser-module.js";
 import type { SimAthenaSqliteModule } from "./sim-athena-sqlite-module.js";
 import type { SimAthenaTableObjects } from "./sim-athena-table-objects.js";
-/**
- * What the engine came to for one query.
- *
- * A turn-down carries why, because a strict engine fails the query with it and
- * a reader of that failing test has to learn which of them it hit.
- */
-export interface SimAthenaEngineAnswer {
-    /** The rows, where the engine ran the statement. */
-    readonly result: SimAthenaResolvedResult | undefined;
-    /** What the engine could not do, where it turned the query down. */
-    readonly turnedDown: string | undefined;
-}
-/** One answer the engine ran for real. */
-export declare function simAthenaEngineAnswered(result: SimAthenaResolvedResult): SimAthenaEngineAnswer;
-/** One query the engine turned down, and why. */
-export declare function simAthenaEngineTurnedDown(turnedDown: string): SimAthenaEngineAnswer;
 /** What one query is run with, once the engine is on and has somewhere to read. */
 export interface SimAthenaEngineRun {
     readonly parser: SimAthenaSqlParser;

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

@@ -1,15 +1,8 @@
+import { simAthenaEngineAnswered, simAthenaEngineTurnedDown, } from "./sim-athena-engine-answer.js";
 import { simAthenaRunFailure } from "./sim-athena-turn-down.js";
 import { simAthenaEngineResult } from "./sim-athena-engine-result.js";
 import { simAthenaSqliteDatabase } from "./sim-athena-sqlite-database.js";
 import { simAthenaLoadedTables } from "./sim-athena-loaded-tables.js";
-/** One answer the engine ran for real. */
-export function simAthenaEngineAnswered(result) {
-    return { result, turnedDown: undefined };
-}
-/** One query the engine turned down, and why. */
-export function simAthenaEngineTurnedDown(turnedDown) {
-    return { result: undefined, turnedDown };
-}
 /**
  * Load the tables, build the database and run the statement.
  *

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

@@ -1,6 +1,6 @@
 import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
 import type { SimAthenaPlannedTable } from "../execution/sim-athena-query-refusal.js";
-import { type SimAthenaEngineAnswer } from "./sim-athena-engine-run.js";
+import { type SimAthenaEngineAnswer } from "./sim-athena-engine-answer.js";
 import type { SimAthenaTableObjects } from "./sim-athena-table-objects.js";
 /** How one scope's engine is turned on. */
 export interface SimAthenaEngineOptions {

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

@@ -1,4 +1,5 @@
-import { simAthenaEngineRun, simAthenaEngineTurnedDown, } from "./sim-athena-engine-run.js";
+import { simAthenaEngineRejected, simAthenaEngineSilent, simAthenaEngineTurnedDown, } from "./sim-athena-engine-answer.js";
+import { simAthenaEngineRun } from "./sim-athena-engine-run.js";
 import { simAthenaSqlParser, } from "./sim-athena-parser-module.js";
 import { simAthenaSqliteModule, } from "./sim-athena-sqlite-module.js";
 import { simAthenaSqliteSql } from "./sim-athena-sql-translation.js";
@@ -63,7 +64,7 @@ export class SimAthenaQueryEngine {
         const sqlite = this.#sqlite;
         const { objects } = request;
         if (parser === undefined || sqlite === undefined) {
-            return { result: undefined, turnedDown: undefined };
+            return simAthenaEngineSilent();
         }
         if (objects === undefined) {
             return simAthenaEngineTurnedDown(simAthenaNoObjects);
@@ -73,6 +74,9 @@ export class SimAthenaQueryEngine {
             athenaSql: request.queryString,
             tables: request.tables.map((planned) => planned.table),
         });
+        if (translated.rejected !== undefined) {
+            return simAthenaEngineRejected(translated.rejected);
+        }
         return translated.sql === undefined
             ? simAthenaEngineTurnedDown(translated.turnedDown)
             : simAthenaEngineRun({

package/dist/service/athena/engine/sim-athena-rejected-statement.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Why Athena refuses one parsed statement, where it does.
+ *
+ * Everything here is a statement SQLite runs happily and the real service
+ * rejects. A translation that hands such a statement to SQLite answers a test
+ * with rows, and the command then fails against AWS. Each shape is spotted on
+ * the tree the Athena grammar produced, before anything is written out for
+ * SQLite.
+ *
+ * Trino and SQLite resolve names by different rules in more places than this.
+ * One shape is covered, the one seen reaching production. Add the next when a
+ * query hits it.
+ */
+export declare function simAthenaRejectedStatement(ast: unknown): string | undefined;

package/dist/service/athena/engine/sim-athena-rejected-statement.js

@@ -0,0 +1,103 @@
+import { isColumnRef, simAthenaAstNodes, } from "./sim-athena-ast-nodes.js";
+/**
+ * Why Athena refuses one parsed statement, where it does.
+ *
+ * Everything here is a statement SQLite runs happily and the real service
+ * rejects. A translation that hands such a statement to SQLite answers a test
+ * with rows, and the command then fails against AWS. Each shape is spotted on
+ * the tree the Athena grammar produced, before anything is written out for
+ * SQLite.
+ *
+ * Trino and SQLite resolve names by different rules in more places than this.
+ * One shape is covered, the one seen reaching production. Add the next when a
+ * query hits it.
+ */
+export function simAthenaRejectedStatement(ast) {
+    for (const node of simAthenaAstNodes(ast)) {
+        const sort = node["orderby"];
+        const columns = node["columns"];
+        if (!Array.isArray(sort) || !Array.isArray(columns)) {
+            continue;
+        }
+        const alias = aggregatedAlias(sort, columns);
+        if (alias !== undefined) {
+            return orderByAggregateOverAlias(alias);
+        }
+    }
+    return undefined;
+}
+/** What Athena says about an `ORDER BY` aggregate over an aggregate alias. */
+function orderByAggregateOverAlias(alias) {
+    return (`Athena refuses this statement. Its ORDER BY aggregates over ${alias}, ` +
+        `and the select list names ${alias} as the output alias of an aggregate. ` +
+        `Trino resolves a bare name in ORDER BY against the select list before ` +
+        `the table. That makes the sort an aggregate over an aggregate, and the ` +
+        `service answers "Invalid reference to output projection attribute from ` +
+        `ORDER BY aggregation". Sort by ${alias} on its own, or give the alias a ` +
+        `name the sort leaves alone.`);
+}
+/**
+ * The output alias one `ORDER BY` aggregates over, where the alias aggregates
+ * too.
+ *
+ * A select list of `sum(qty) AS qty` sorted by `ORDER BY sum(qty)` is the
+ * shape. SQLite reads that `qty` as the table's column and sorts correctly.
+ * Trino reads it as the alias and refuses the query.
+ *
+ * `ORDER BY qty` over the same select list is the form Athena takes, with no
+ * aggregate wrapped around the name. An aggregate over a name the select list
+ * leaves alone is legal too, as in `ORDER BY sum(revenue_total)` beside
+ * `coalesce(sum(revenue_total), 0) AS revenue`. The aliases are what tell this
+ * shape from those two.
+ */
+function aggregatedAlias(sort, columns) {
+    const aliases = aggregateAliases(columns);
+    if (aliases.size === 0) {
+        return undefined;
+    }
+    for (const node of simAthenaAstNodes(sort)) {
+        if (!isAggregate(node)) {
+            continue;
+        }
+        const arguments_ = simAthenaAstNodes(node["args"]);
+        for (const inner of arguments_) {
+            const alias = isColumnRef(inner) && inner.table === null
+                ? aliases.get(inner.column.toLowerCase())
+                : undefined;
+            if (alias !== undefined) {
+                return alias;
+            }
+        }
+    }
+    return undefined;
+}
+/** Every output alias of one select list whose own expression aggregates. */
+function aggregateAliases(columns) {
+    const aliases = new Map();
+    for (const column of columns) {
+        const alias = column["as"];
+        if (typeof alias === "string" && holdsAggregate(column["expr"])) {
+            aliases.set(alias.toLowerCase(), alias);
+        }
+    }
+    return aliases;
+}
+/** Whether anything under this expression aggregates. */
+function holdsAggregate(expression) {
+    for (const node of simAthenaAstNodes(expression)) {
+        if (isAggregate(node)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether this node is a grouped aggregate call.
+ *
+ * A window function carries `over` and is computed once the grouped aggregates
+ * have been. It takes an output alias in `ORDER BY` happily, and stays out of
+ * this.
+ */
+function isAggregate(node) {
+    return node["type"] === "aggr_func" && (node["over"] ?? null) === null;
+}

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

@@ -1,12 +1,18 @@
 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. */
+/** One statement translated for SQLite, or why it was not. */
 export type SimAthenaTranslatedSql = {
     readonly sql: string;
     readonly turnedDown: undefined;
+    readonly rejected: undefined;
 } | {
     readonly sql: undefined;
     readonly turnedDown: string;
+    readonly rejected: undefined;
+} | {
+    readonly sql: undefined;
+    readonly turnedDown: undefined;
+    readonly rejected: string;
 };
 interface SimAthenaSqlTranslationRequest {
     readonly parser: SimAthenaSqlParser;
@@ -15,13 +21,18 @@ interface SimAthenaSqlTranslationRequest {
     readonly tables: readonly SimAthenaCatalogTable[];
 }
 /**
- * One Athena statement written back out for SQLite, or why it cannot be.
+ * One Athena statement written back out for SQLite, or why it is not.
+ *
+ * Three things turn the query down, 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 letting the declared result take the query.
  *
- * 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.
+ * A rejection is the fourth outcome and a different thing. The statement
+ * parsed, and Athena would still refuse to run it. That fails the query
+ * whether or not the engine is strict, since falling back would leave a test
+ * green on SQL the service rejects.
  */
 export declare function simAthenaSqliteSql(request: SimAthenaSqlTranslationRequest): SimAthenaTranslatedSql;
 export {};

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

@@ -1,14 +1,20 @@
 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 { simAthenaRewriteUnnest } from "./sim-athena-unnest-rewrite.js";
 /**
- * One Athena statement written back out for SQLite, or why it cannot be.
+ * One Athena statement written back out for SQLite, or why it is not.
  *
- * 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.
+ * Three things turn the query down, 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 letting the declared result take the query.
+ *
+ * A rejection is the fourth outcome and a different thing. The statement
+ * parsed, and Athena would still refuse to run it. That fails the query
+ * whether or not the engine is strict, since falling back would leave a test
+ * green on SQL the service rejects.
  */
 export function simAthenaSqliteSql(request) {
     const { parser } = request;
@@ -21,6 +27,10 @@ export function simAthenaSqliteSql(request) {
     catch {
         return turnedDown(simAthenaUnparsedStatement);
     }
+    const rejected = simAthenaRejectedStatement(ast);
+    if (rejected !== undefined) {
+        return { sql: undefined, turnedDown: undefined, rejected };
+    }
     try {
         if (!simAthenaRewriteUnnest({
             ast,
@@ -32,6 +42,7 @@ export function simAthenaSqliteSql(request) {
         return {
             sql: simAthenaSqlForSqlite(parser.sqlify(ast, { database: "sqlite" })),
             turnedDown: undefined,
+            rejected: undefined,
         };
     }
     catch {
@@ -39,5 +50,5 @@ export function simAthenaSqliteSql(request) {
     }
 }
 function turnedDown(reason) {
-    return { sql: undefined, turnedDown: reason };
+    return { sql: undefined, turnedDown: reason, rejected: undefined };
 }

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

@@ -48,6 +48,10 @@ interface SimAthenaQueryAnswerRequest {
  * 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.
+ *
+ * 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.
  */
 export declare function simAthenaQueryAnswer(request: SimAthenaQueryAnswerRequest): Promise<SimAthenaQueryAnswer>;
 export {};

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

@@ -15,6 +15,10 @@ import { simAthenaStrictRefusal } from "../engine/sim-athena-turn-down.js";
  * 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.
+ *
+ * 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.
  */
 export async function simAthenaQueryAnswer(request) {
     const forQuery = request.results.declaredForQuery(request.queryString);
@@ -35,7 +39,7 @@ export async function simAthenaQueryAnswer(request) {
     return {
         result: request.declared,
         source: "declaration",
-        refusal: strictRefusal(request.engine, computed.turnedDown),
+        refusal: computed.rejected ?? strictRefusal(request.engine, computed.turnedDown),
     };
 }
 /**

package/docs/services/athena/README.md

@@ -381,6 +381,36 @@ Strict mode is off unless a test asks for it, and `disable()` takes it off with
 declaration written against one exact query text still answers, with no failure, because that is a
 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
+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.
+
+The one shape it catches today is an `ORDER BY` that aggregates over an output alias which is itself
+an aggregate.
+
+```sql
+SELECT sku, coalesce(sum(qty), 0) AS qty
+FROM rainlytics.lines
+GROUP BY sku
+ORDER BY sum(qty) DESC
+```
+
+Trino resolves the bare `qty` in `ORDER BY` against the select list before the table. The sort then
+asks for an aggregate over an aggregate, and Athena answers `COLUMN_NOT_FOUND: Invalid reference to
+output projection attribute from ORDER BY aggregation`. SQLite resolves the same name against the
+table's column, runs the statement and orders it correctly. That is how a green test shipped a
+command that failed against the service.
+
+`ORDER BY qty DESC` over the same select list is the form Athena takes, and it is what to write.
+`ORDER BY sum(revenue_total) DESC` beside `coalesce(sum(revenue_total), 0) AS revenue` is fine as
+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.
+
 ### The objects it reads
 
 The SerDe class name in the table's storage descriptor says how its objects are decoded.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/yulin",
-  "version": "1.21.18",
+  "version": "1.21.19",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": "https://github.com/KensioSoftware/yulin",
   "homepage": "https://yulinsim.dev/",
@@ -299,7 +299,7 @@
     "hyparquet": "^1.29.2",
     "hyparquet-writer": "^0.16.9",
     "node-sql-parser": "^5.4.0",
-    "oxfmt": "^0.65.0",
+    "oxfmt": "^0.66.0",
     "oxlint": "^1.77.0",
     "oxlint-tsgolint": "^7.0.2001",
     "semantic-release": "25.0.9",