@rex0220/kintone-sql-tools 3.66.1 → 3.68.0

package/dist-cli/ksql.js

@@ -475,7 +475,7 @@ var Lexer = class {
   // ヘルパー
   // ----------------------------------------------------------
   makeToken(kind, value, pos) {
-    return { kind, value, pos };
+    return { kind, value, pos, end: this.pos };
   }
 };
 function isIdentStart(ch) {
@@ -1082,6 +1082,8 @@ var Parser = class {
     this.allowRelativeDateFunctions = false;
     /** WITH 句で定義された CTE 名のセット（parseTableRef で参照） */
     this.cteNames = /* @__PURE__ */ new Set();
+    /** dialect 1 の裸名で宣言された一時テーブル名（参照時に # 付きへ正規化） */
+    this.bareTempTableNames = /* @__PURE__ */ new Set();
     /** パース中に出現した一時テーブル参照（#name）のトークン。単文 API での拒否に使う */
     this.tempTableRefs = [];
     /** GROUP BY を読む前に作る B124 候補 leaf の診断位置。AST 公開型へ位置情報を足さない。 */
@@ -1120,7 +1122,12 @@ var Parser = class {
   }
   /** 複文（`;` 区切り）をパースする。空文はスキップする */
   parseStatements() {
+    return this.parseStatementsWithRanges().statements;
+  }
+  /** 複文と、原文上の文ごとの文字範囲を同時に返す。 */
+  parseStatementsWithRanges() {
     const stmts = [];
+    const statementRanges = [];
     while (true) {
       while (this.peek().kind === ";" /* SEMICOLON */) this.advance();
       if (this.peek().kind === "EOF" /* EOF */) break;
@@ -1136,9 +1143,11 @@ var Parser = class {
       if (after.kind !== ";" /* SEMICOLON */ && after.kind !== "EOF" /* EOF */) {
         throw new ParseError("\u6587\u306E\u533A\u5207\u308A\u306B\u306F ; \u304C\u5FC5\u8981\u3067\u3059", after);
       }
+      const lastTok = this.prev();
+      statementRanges.push({ start: startTok.pos, end: lastTok.end ?? after.pos });
     }
     this.expect("EOF" /* EOF */);
-    return stmts;
+    return { statements: stmts, statementRanges };
   }
   // ----------------------------------------------------------
   // Statement ディスパッチ
@@ -1177,6 +1186,13 @@ var Parser = class {
         if (upper === "DROP") return this.parseDropTempTable();
         if (upper === "DECLARE") return this.parseDeclareVariable();
         if (upper === "VALIDATE") return this.parseValidate();
+        if (upper === "EXIT") return this.parseExit();
+        if (upper === "MERGE") {
+          if (!this.capabilities.dialect1) {
+            throw new ParseError("MERGE \u306B\u306F -- @ksql dialect: 1 \u306E\u5BA3\u8A00\u304C\u5FC5\u8981\u3067\u3059", tok);
+          }
+          return this.parseMergeAsUpsert();
+        }
         if (upper === "GENERATE_SERIES") {
           throw new ParseError(
             "GENERATE_SERIES \u306F WITH \u306E CTE \u672C\u4F53\u306B\u66F8\u3044\u3066\u304F\u3060\u3055\u3044\u3002\u4F8B: WITH s AS (GENERATE_SERIES(1, 5)) SELECT generate_series FROM s",
@@ -1195,7 +1211,7 @@ var Parser = class {
         break;
     }
     throw new ParseError(
-      "SELECT / INSERT / UPDATE / DELETE / REORDER / VALIDATE / WITH / SHOW / DESCRIBE / EXPLAIN / CREATE TEMP TABLE / DROP TEMP TABLE / SET / DECLARE / ASSERT \u306E\u3044\u305A\u308C\u304B\u3067\u59CB\u307E\u308B SQL \u6587\u304C\u5FC5\u8981\u3067\u3059",
+      "SELECT / INSERT / UPDATE / DELETE / REORDER / VALIDATE / WITH / SHOW / DESCRIBE / EXPLAIN / CREATE TEMP TABLE / DROP TEMP TABLE / SET / DECLARE / ASSERT / EXIT \u306E\u3044\u305A\u308C\u304B\u3067\u59CB\u307E\u308B SQL \u6587\u304C\u5FC5\u8981\u3067\u3059",
       tok
     );
   }
@@ -1323,6 +1339,7 @@ var Parser = class {
     this.advance();
     this.expectSoftKeyword("TEMP", "CREATE \u306E\u5F8C\u306B\u306F TEMP TABLE \u304C\u5FC5\u8981\u3067\u3059\uFF08\u4F8B: CREATE TEMP TABLE #temp AS SELECT ...\uFF09");
     this.expectSoftKeyword("TABLE", "CREATE TEMP \u306E\u5F8C\u306B\u306F TABLE \u304C\u5FC5\u8981\u3067\u3059");
+    const bareName = this.isDialect1BareTempTableName();
     const name = this.parseTempTableName();
     this.expect("AS" /* AS */, "CREATE TEMP TABLE \u306B\u306F AS SELECT \u304C\u5FC5\u8981\u3067\u3059");
     const tok = this.peek();
@@ -1334,13 +1351,16 @@ var Parser = class {
     } else {
       throw new ParseError("CREATE TEMP TABLE ... AS \u306E\u5F8C\u306B\u306F SELECT / WITH \u304C\u5FC5\u8981\u3067\u3059", tok);
     }
+    if (bareName !== null) this.bareTempTableNames.add(bareName);
     return { type: "CREATE_TEMP_TABLE", name, query };
   }
   parseDropTempTable() {
     this.advance();
     this.expectSoftKeyword("TEMP", "DROP \u306E\u5F8C\u306B\u306F TEMP TABLE \u304C\u5FC5\u8981\u3067\u3059\uFF08\u4F8B: DROP TEMP TABLE #temp\uFF09");
     this.expectSoftKeyword("TABLE", "DROP TEMP \u306E\u5F8C\u306B\u306F TABLE \u304C\u5FC5\u8981\u3067\u3059");
+    const bareName = this.isDialect1BareTempTableName();
     const name = this.parseTempTableName();
+    if (bareName !== null) this.bareTempTableNames.delete(bareName);
     return { type: "DROP_TEMP_TABLE", name };
   }
   expectSoftKeyword(word, msg) {
@@ -1362,8 +1382,16 @@ var Parser = class {
       this.advance();
       return tok.value;
     }
+    if (this.capabilities.dialect1 && (tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */)) {
+      this.advance();
+      return `#${tok.value}`;
+    }
     throw new ParseError("\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u540D\u306F # \u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08\u4F8B: #temp\uFF09", tok);
   }
+  isDialect1BareTempTableName() {
+    const tok = this.peek();
+    return this.capabilities.dialect1 && (tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */) && !tok.value.startsWith("#") ? tok.value : null;
+  }
   parseShow() {
     this.advance();
     if (!this.consume("APPS" /* APPS */)) {
@@ -1691,6 +1719,41 @@ var Parser = class {
   // ----------------------------------------------------------
   parseAssert() {
     this.expect("ASSERT" /* ASSERT */);
+    const warnTok = this.peek();
+    const warn = this.isSoftKeyword("WARN");
+    if (warn) {
+      this.requireDialect1(warnTok);
+      this.advance();
+    }
+    const condition = this.parseAssertCondition();
+    const message = this.parseFlowMessage();
+    return {
+      type: "ASSERT",
+      ...condition,
+      ...warn ? { warn: true } : {},
+      ...message !== void 0 ? { message } : {}
+    };
+  }
+  /** EXIT SUCCESS IF <ASSERT と同じ条件>, '<message>' */
+  parseExit() {
+    const exitTok = this.advance();
+    this.requireDialect1(exitTok);
+    if (!this.isSoftKeyword("SUCCESS")) {
+      throw new ParseError("EXIT \u306E\u5F8C\u306B\u306F SUCCESS \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+    }
+    this.advance();
+    if (this.peek().kind !== "IF" /* IF */ && !this.isSoftKeyword("IF")) {
+      throw new ParseError("EXIT SUCCESS \u306E\u5F8C\u306B\u306F IF \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+    }
+    this.advance();
+    const condition = this.parseAssertCondition();
+    if (!this.consume("," /* COMMA */)) {
+      throw new ParseError("EXIT SUCCESS IF \u306B\u306F\u672B\u5C3E\u306E\u30E1\u30C3\u30BB\u30FC\u30B8\u6587\u5B57\u5217\u304C\u5FC5\u8981\u3067\u3059", this.peek());
+    }
+    const message = this.expect("STRING" /* STRING */, "EXIT SUCCESS IF \u306E\u30E1\u30C3\u30BB\u30FC\u30B8\u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059");
+    return { type: "EXIT", ...condition, message: message.value };
+  }
+  parseAssertCondition() {
     const condStart = this.pos;
     const left = this.parseAssertOperand();
     const opTok = this.peek();
@@ -1703,7 +1766,6 @@ var Parser = class {
       const high = this.parseAssertOperand();
       this.rejectAssertCompound();
       return {
-        type: "ASSERT",
         left,
         op: "BETWEEN",
         right: null,
@@ -1722,7 +1784,6 @@ var Parser = class {
     const right = this.parseAssertOperand();
     this.rejectAssertCompound();
     return {
-      type: "ASSERT",
       left,
       op,
       right,
@@ -1731,6 +1792,17 @@ var Parser = class {
       text: this.renderTokenRange(condStart, this.pos)
     };
   }
+  /** ASSERT の dialect 1 メッセージ。カンマが無ければ既存形式。 */
+  parseFlowMessage() {
+    if (!this.consume("," /* COMMA */)) return void 0;
+    this.requireDialect1(this.prev());
+    return this.expect("STRING" /* STRING */, "ASSERT \u306E\u30E1\u30C3\u30BB\u30FC\u30B8\u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059").value;
+  }
+  requireDialect1(tok) {
+    if (!this.capabilities.dialect1) {
+      throw new ParseError("\u3053\u306E\u69CB\u6587\u306B\u306F -- @ksql dialect: 1 \u306E\u5BA3\u8A00\u304C\u5FC5\u8981\u3067\u3059", tok);
+    }
+  }
   /** ASSERT のオペランド: 文字列 / スカラーサブクエリ / 数値算術式 */
   parseAssertOperand() {
     const tok = this.peek();
@@ -3121,6 +3193,12 @@ var Parser = class {
       );
     }
     const name = this.parseTableName();
+    if (this.capabilities.dialect1 && this.bareTempTableNames.has(name)) {
+      const normalizedName = `#${name}`;
+      this.tempTableRefs.push({ ...this.prev(), value: normalizedName });
+      const alias2 = this.consume("AS" /* AS */) ? this.parseTableAliasName() : this.tryParseImplicitAlias();
+      return { appId: 0, alias: alias2, cteName: normalizedName };
+    }
     if (nameTok.kind === "IDENT" /* IDENT */ && name.startsWith("#")) {
       this.tempTableRefs.push(this.prev());
       const alias2 = this.consume("AS" /* AS */) ? this.parseTableAliasName() : this.tryParseImplicitAlias();
@@ -3161,6 +3239,7 @@ var Parser = class {
     if (k === "IDENT" /* IDENT */ || k === "BIDENT" /* BIDENT */) {
       if (k === "IDENT" /* IDENT */ && this.peek().value.toUpperCase() === "VALIDATE" && this.peekAt(1).kind === "IDENT" /* IDENT */ && this.peekAt(1).value.toUpperCase() === "ONLY") return null;
       if (k === "IDENT" /* IDENT */ && this.peek().value.toUpperCase() === "CHECK" && this.peekAt(1).kind === "WHEN" /* WHEN */) return null;
+      if (k === "IDENT" /* IDENT */ && this.peek().value.toUpperCase() === "KEY" && this.peekAt(1).kind === "(" /* LPAREN */) return null;
       return this.parseTableAliasName();
     }
     return null;
@@ -4061,6 +4140,15 @@ var Parser = class {
     };
   }
   parseOnDuplicate() {
+    if (this.capabilities.dialect1 && this.consumeSoftKeyword("KEY")) {
+      this.expect("(" /* LPAREN */, "KEY \u306E\u5F8C\u306B\u306F (\u30AD\u30FC\u30D5\u30A3\u30FC\u30EB\u30C9) \u304C\u5FC5\u8981\u3067\u3059");
+      const keyFields2 = this.parseIdentList();
+      this.expect(")" /* RPAREN */);
+      if (keyFields2.length === 0) {
+        throw new ParseError("KEY \u306B\u306F\u30AD\u30FC\u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u6700\u4F4E 1 \u3064\u5FC5\u8981\u3067\u3059", this.prev());
+      }
+      return keyFields2;
+    }
     this.expectKeyword("ON" /* ON */, "UPSERT \u306B\u306F ON DUPLICATE (\u30AD\u30FC\u30D5\u30A3\u30FC\u30EB\u30C9) \u304C\u5FC5\u8981\u3067\u3059");
     if (!this.consume("DUPLICATE" /* DUPLICATE */)) {
       throw new ParseError("ON \u306E\u5F8C\u306B\u306F DUPLICATE \u304C\u5FC5\u8981\u3067\u3059", this.peek());
@@ -4073,6 +4161,238 @@ var Parser = class {
     }
     return keyFields;
   }
+  parseMergeAsUpsert() {
+    const mergeToken = this.advance();
+    this.expect("INTO" /* INTO */, "MERGE \u306E\u5F8C\u306B\u306F INTO \u304C\u5FC5\u8981\u3067\u3059");
+    this.rejectTempTableDml();
+    const targetName = this.parseIdentifier();
+    const { appId, subtableCode } = extractTableRef(targetName, this.prev());
+    if (subtableCode) {
+      throw new ParseError("MERGE \u306F\u307E\u3060\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u4EEE\u60F3\u30C6\u30FC\u30D6\u30EB\u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093", this.prev());
+    }
+    this.expect("AS" /* AS */, "MERGE \u306E\u30BF\u30FC\u30B2\u30C3\u30C8\u306B\u306F AS alias \u304C\u5FC5\u8981\u3067\u3059");
+    const targetAlias = this.parseTableAliasName();
+    this.expectSoftKeyword("USING", "MERGE \u306B\u306F USING <source> AS alias \u304C\u5FC5\u8981\u3067\u3059");
+    const sourceStart = this.pos;
+    const source = this.parseTableRef();
+    const explicitSourceAlias = this.tokens.slice(sourceStart, this.pos).some((token) => token.kind === "AS" /* AS */);
+    if (!explicitSourceAlias || source.alias === null) {
+      throw new ParseError("MERGE \u306E USING \u30BD\u30FC\u30B9\u306B\u306F AS alias \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+    }
+    const sourceAlias = source.alias;
+    this.expect("ON" /* ON */, "MERGE \u306B\u306F ON t.key = s.key \u306E\u5358\u4E00\u30AD\u30FC\u7B49\u5024\u304C\u5FC5\u8981\u3067\u3059");
+    const left = this.parseMergeQualifiedField("MERGE \u306E ON \u5DE6\u8FBA\u306F targetAlias.key \u306E\u5F62\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044");
+    if (!this.consume("=" /* EQ */)) {
+      throw new ParseError(
+        "MERGE \u306E ON \u306F\u5358\u4E00\u30AD\u30FC\u306E\u7B49\u5024\uFF08t.key = s.key\uFF09\u306E\u307F\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u3059\u3002\u8907\u6570\u6761\u4EF6\u3084\u975E\u7B49\u5024\u306F\u9023\u7D50\u30AD\u30FC\u30D5\u30A3\u30FC\u30EB\u30C9\u3067\u7F6E\u304D\u63DB\u3048\u3066\u304F\u3060\u3055\u3044",
+        this.peek()
+      );
+    }
+    const right = this.parseMergeQualifiedField("MERGE \u306E ON \u53F3\u8FBA\u306F sourceAlias.key \u306E\u5F62\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044");
+    if (left.alias.toLowerCase() !== targetAlias.toLowerCase() || right.alias.toLowerCase() !== sourceAlias.toLowerCase()) {
+      throw new ParseError(
+        `MERGE \u306E ON \u306F ${targetAlias}.key = ${sourceAlias}.key \u306E\u5225\u540D\u4FEE\u98FE\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044`,
+        mergeToken
+      );
+    }
+    if (this.peek().kind === "AND" /* AND */ || this.peek().kind === "OR" /* OR */) {
+      throw new ParseError(
+        "MERGE \u306E ON \u306F\u5358\u4E00\u30AD\u30FC\u306E\u7B49\u5024\u306E\u307F\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u3059\u3002\u8907\u6570\u6761\u4EF6\u306F\u9023\u7D50\u30AD\u30FC\u30D5\u30A3\u30FC\u30EB\u30C9\u3067\u7F6E\u304D\u63DB\u3048\u3066\u304F\u3060\u3055\u3044",
+        this.peek()
+      );
+    }
+    let matched = null;
+    let insertFields = null;
+    let insertValues = null;
+    while (this.peek().kind === "WHEN" /* WHEN */) {
+      const whenToken = this.advance();
+      if (this.consume("NOT" /* NOT */)) {
+        this.expectSoftKeyword("MATCHED", "WHEN NOT \u306E\u5F8C\u306B\u306F MATCHED \u304C\u5FC5\u8981\u3067\u3059");
+        if (insertFields !== null) throw new ParseError("WHEN NOT MATCHED \u53E5\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059", whenToken);
+        this.expect("THEN" /* THEN */, "WHEN NOT MATCHED \u306E\u5F8C\u306B\u306F THEN \u304C\u5FC5\u8981\u3067\u3059");
+        this.expect("INSERT" /* INSERT */, "WHEN NOT MATCHED THEN \u306E\u5F8C\u306B\u306F INSERT \u304C\u5FC5\u8981\u3067\u3059");
+        this.expect("(" /* LPAREN */, "MERGE INSERT \u306B\u306F\u5217\u30EA\u30B9\u30C8\u304C\u5FC5\u8981\u3067\u3059");
+        insertFields = this.parseIdentList();
+        this.expect(")" /* RPAREN */);
+        this.expect("VALUES" /* VALUES */, "MERGE INSERT \u306E\u5217\u30EA\u30B9\u30C8\u306E\u5F8C\u306B\u306F VALUES \u304C\u5FC5\u8981\u3067\u3059");
+        this.expect("(" /* LPAREN */, "MERGE INSERT VALUES \u306F ( \u3067\u59CB\u3081\u3066\u304F\u3060\u3055\u3044");
+        insertValues = this.parseMergeValueList();
+        this.expect(")" /* RPAREN */);
+        if (insertFields.length !== insertValues.length) {
+          throw new ParseError("MERGE INSERT \u306E\u5217\u6570\u3068 VALUES \u306E\u5024\u6570\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093", whenToken);
+        }
+      } else {
+        this.expectSoftKeyword("MATCHED", "WHEN \u306E\u5F8C\u306B\u306F MATCHED \u307E\u305F\u306F NOT MATCHED \u304C\u5FC5\u8981\u3067\u3059");
+        if (matched !== null) throw new ParseError("WHEN MATCHED \u53E5\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059", whenToken);
+        this.expect("THEN" /* THEN */, "WHEN MATCHED \u306E\u5F8C\u306B\u306F THEN \u304C\u5FC5\u8981\u3067\u3059");
+        this.expect("UPDATE" /* UPDATE */, "WHEN MATCHED THEN \u306E\u5F8C\u306B\u306F UPDATE \u304C\u5FC5\u8981\u3067\u3059");
+        this.expect("SET" /* SET */, "WHEN MATCHED THEN UPDATE \u306E\u5F8C\u306B\u306F SET \u304C\u5FC5\u8981\u3067\u3059");
+        matched = this.parseMergeAssignments(targetAlias);
+      }
+    }
+    if (matched === null || insertFields === null || insertValues === null) {
+      throw new ParseError(
+        "WHEN MATCHED / WHEN NOT MATCHED \u306E\u4E21\u53E5\u304C\u5FC5\u8981\u3067\u3059\uFF08\u66F4\u65B0\u306E\u307F\u306F UPDATE ... FROM\u3001\u633F\u5165\u306E\u307F\u306F INSERT ... SELECT \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\uFF09",
+        this.peek()
+      );
+    }
+    if (!insertFields.some((field) => field.toLowerCase() === left.field.toLowerCase())) {
+      throw new ParseError(
+        `MERGE \u306E ON \u30AD\u30FC ${left.field} \u306F INSERT \u5217\u30EA\u30B9\u30C8\u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044`,
+        mergeToken
+      );
+    }
+    const expressions = /* @__PURE__ */ new Map();
+    insertFields.forEach((field, index) => expressions.set(field.toLowerCase(), insertValues[index]));
+    for (const assignment of matched) {
+      const key = assignment.field.toLowerCase();
+      const existing = expressions.get(key);
+      if (existing !== void 0 && !this.mergeExpressionsEqual(existing, assignment.value, sourceAlias)) {
+        throw new ParseError(
+          `MERGE \u306E\u5217 ${assignment.field} \u306F\u4E21\u53E5\u306E\u5F0F\u304C\u4E00\u81F4\u3059\u308B\u5834\u5408\u306E\u307F MERGE \u3092 UPSERT \u3078\u6B63\u898F\u5316\u3067\u304D\u307E\u3059`,
+          mergeToken
+        );
+      }
+      if (existing === void 0) {
+        insertFields.push(assignment.field);
+        insertValues.push(assignment.value);
+        expressions.set(key, assignment.value);
+      }
+    }
+    const columns = insertValues.map((value) => this.mergeValueToSelectColumn(value, sourceAlias, mergeToken));
+    const normalizedSource = source.cteName !== null ? { ...source, alias: null } : { ...source, alias: `APP${source.appId}${source.subtableCode ? `$${source.subtableCode}` : ""}` };
+    const select = {
+      type: "SELECT",
+      distinct: false,
+      columns,
+      from: normalizedSource,
+      joins: [],
+      where: null,
+      groupBy: [],
+      having: null,
+      orderMode: "CANONICAL",
+      orderBy: [],
+      limit: null,
+      offset: null
+    };
+    const checkGroups = this.parseCheckGroups();
+    const validation = this.parseDmlControlSuffix();
+    return {
+      type: "UPSERT_SELECT",
+      appId,
+      fields: insertFields,
+      select,
+      keyFields: [left.field],
+      ...checkGroups,
+      ...validation
+    };
+  }
+  parseMergeQualifiedField(message) {
+    const token = this.peek();
+    const path = this.parseFieldPath();
+    const ref = this.splitQualifiedField(path);
+    if (ref.alias === null) throw new ParseError(message, token);
+    return { alias: ref.alias, field: ref.field };
+  }
+  parseMergeAssignments(targetAlias) {
+    const assignments = [];
+    do {
+      const token = this.peek();
+      const path = this.parseFieldPath();
+      const ref = this.splitQualifiedField(path);
+      if (ref.alias !== null && ref.alias.toLowerCase() !== targetAlias.toLowerCase()) {
+        throw new ParseError(`MERGE UPDATE SET \u306E\u5DE6\u8FBA\u306F target alias ${targetAlias} \u3067\u4FEE\u98FE\u3057\u3066\u304F\u3060\u3055\u3044`, token);
+      }
+      this.expect("=" /* EQ */);
+      assignments.push({ field: ref.field, value: this.parseAssignmentValue() });
+    } while (this.consume("," /* COMMA */));
+    return assignments;
+  }
+  parseMergeValueList() {
+    const values = [];
+    if (this.peek().kind === ")" /* RPAREN */) return values;
+    do
+      values.push(this.parseAssignmentValue());
+    while (this.consume("," /* COMMA */));
+    return values;
+  }
+  mergeExpressionsEqual(left, right, sourceAlias) {
+    return this.mergeNormalizedValueEqual(
+      this.normalizeMergeValue(left, sourceAlias, true),
+      this.normalizeMergeValue(right, sourceAlias, true)
+    );
+  }
+  normalizeMergeValue(value, sourceAlias, compareLiteralValues = false) {
+    if (Array.isArray(value)) {
+      return value.map((item) => this.normalizeMergeValue(item, sourceAlias, compareLiteralValues));
+    }
+    if (value === null || typeof value !== "object") return value;
+    const obj = value;
+    if (compareLiteralValues && obj["type"] === "NUMBER") {
+      return { type: "NUMBER", value: obj["value"] };
+    }
+    if (obj["type"] === "SOURCE_FIELD") {
+      if (String(obj["alias"]).toLowerCase() !== sourceAlias.toLowerCase()) return { type: "INVALID_SOURCE" };
+      return { type: "FIELD_REF", field: obj["field"] };
+    }
+    if (obj["type"] === "FIELD_REF" && typeof obj["field"] === "string") {
+      const ref = this.splitQualifiedField(obj["field"]);
+      if (ref.alias !== null && ref.alias.toLowerCase() !== sourceAlias.toLowerCase()) return { type: "INVALID_SOURCE" };
+      return { ...obj, field: ref.field };
+    }
+    if (obj["type"] === "FIELD" && typeof obj["tableAlias"] === "string") {
+      if (obj["tableAlias"].toLowerCase() !== sourceAlias.toLowerCase()) return { type: "INVALID_SOURCE" };
+      return { ...obj, tableAlias: null };
+    }
+    return Object.fromEntries(Object.entries(obj).map(([key, child]) => [
+      key,
+      this.normalizeMergeValue(child, sourceAlias, compareLiteralValues)
+    ]));
+  }
+  mergeNormalizedValueEqual(left, right) {
+    if (left === right) return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+      return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => this.mergeNormalizedValueEqual(item, right[index]));
+    }
+    if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return false;
+    const leftObj = left;
+    const rightObj = right;
+    const leftKeys = Object.keys(leftObj);
+    const rightKeys = Object.keys(rightObj);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.prototype.hasOwnProperty.call(rightObj, key) && this.mergeNormalizedValueEqual(leftObj[key], rightObj[key]));
+  }
+  mergeValueToSelectColumn(value, sourceAlias, token) {
+    const normalized = this.normalizeMergeValue(value, sourceAlias);
+    if (this.mergeValueContainsInvalidSource(normalized)) {
+      throw new ParseError(`MERGE \u306E\u5F0F\u306F source alias ${sourceAlias} \u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u3060\u3051\u3092\u53C2\u7167\u3057\u3066\u304F\u3060\u3055\u3044`, token);
+    }
+    const expr = normalized;
+    switch (expr["type"]) {
+      case "FIELD_REF":
+        return { type: "FIELD", field: String(expr["field"]), alias: null };
+      case "STRING":
+        return { type: "LITERAL_COL", value: String(expr["value"]), alias: null };
+      case "NUMBER":
+        return { type: "ARITH_COL", expr, alias: null };
+      case "ARITH":
+        return { type: "ARITH_COL", expr, alias: null };
+      case "STRING_FUNC":
+        return { type: "STRFUNC_COL", expr, alias: null };
+      case "CASE_VALUE":
+        return { type: "CASE_COL", expr: expr["expr"], alias: null };
+      default:
+        throw new ParseError(
+          "MERGE \u306E\u4EE3\u5165\u5F0F\u306F\u30BD\u30FC\u30B9\u30D5\u30A3\u30FC\u30EB\u30C9\u30FB\u30EA\u30C6\u30E9\u30EB\u30FB\u7B97\u8853\u5F0F\u30FB\u6587\u5B57\u5217\u95A2\u6570\u30FBCASE \u306E\u3044\u305A\u308C\u304B\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044",
+          token
+        );
+    }
+  }
+  mergeValueContainsInvalidSource(value) {
+    if (Array.isArray(value)) return value.some((item) => this.mergeValueContainsInvalidSource(item));
+    if (value === null || typeof value !== "object") return false;
+    const obj = value;
+    return obj["type"] === "INVALID_SOURCE" || Object.values(obj).some((item) => this.mergeValueContainsInvalidSource(item));
+  }
   isUpsertApplyBranchStart() {
     return this.peek().kind === "ON" /* ON */ && (this.peekAt(1).kind === "INSERT" /* INSERT */ || this.peekAt(1).kind === "UPDATE" /* UPDATE */);
   }
@@ -4889,7 +5209,7 @@ function isDmlType(type) {
   return type === "INSERT" || type === "INSERT_SELECT" || type === "UPDATE" || type === "DELETE" || type === "UPSERT" || type === "UPSERT_SELECT" || type === "REORDER" || type === "IMPORT";
 }
 function isReadOnlyType(type) {
-  return type === "SELECT" || type === "VALIDATE" || type === "UNION" || type === "WITH" || type === "EXPLAIN" || type === "SHOW_APPS" || type === "DESCRIBE" || type === "CREATE_TEMP_TABLE" || type === "DROP_TEMP_TABLE" || type === "SET_VARIABLE" || type === "DECLARE_VARIABLE" || type === "ASSERT";
+  return type === "SELECT" || type === "VALIDATE" || type === "UNION" || type === "WITH" || type === "EXPLAIN" || type === "SHOW_APPS" || type === "DESCRIBE" || type === "CREATE_TEMP_TABLE" || type === "DROP_TEMP_TABLE" || type === "SET_VARIABLE" || type === "DECLARE_VARIABLE" || type === "ASSERT" || type === "EXIT";
 }
 function writesKintone(stmt) {
   return isDmlType(stmt.type) && !("validateOnly" in stmt && stmt.validateOnly === true);
@@ -8259,6 +8579,7 @@ function validateStatement(stmt) {
     case "SET_VARIABLE":
     case "DECLARE_VARIABLE":
     case "ASSERT":
+    case "EXIT":
       validateNestedSelects(stmt);
       return;
     case "UPDATE":
@@ -9376,15 +9697,15 @@ function selectScalarExtreme(values, extreme) {
 }
 
 // src/engine/evalFunc.ts
-function evalArithExpr(expr, row) {
+function evalArithExpr(expr, row, context = {}) {
   if (expr.type === "VARIABLE") throw new Error(
     `InternalError: unresolved arithmetic variable @${expr.name} reached arithmetic evaluation.`
   );
   if (expr.type === "NUMBER") return expr.value;
   if (expr.type === "FIELD_REF") return Number(resolveFieldRef(row, expr.field));
-  if (expr.type === "STRING_FUNC") return Number(evalStringFunc(expr, row));
-  const l = evalArithExpr(expr.left, row);
-  const r = evalArithExpr(expr.right, row);
+  if (expr.type === "STRING_FUNC") return Number(evalStringFunc(expr, row, void 0, void 0, context));
+  const l = evalArithExpr(expr.left, row, context);
+  const r = evalArithExpr(expr.right, row, context);
   switch (expr.op) {
     case "+":
       return l + r;
@@ -9398,7 +9719,7 @@ function evalArithExpr(expr, row) {
       return r !== 0 ? l % r : NaN;
   }
 }
-function evalScalarValueExpr(expr, row, resolveFieldType, resolveFieldSemantics2) {
+function evalScalarValueExpr(expr, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
   switch (expr.type) {
     case "STRING":
       return expr.value;
@@ -9409,19 +9730,19 @@ function evalScalarValueExpr(expr, row, resolveFieldType, resolveFieldSemantics2
     case "VARIABLE":
       throw new Error(`ArgumentError: unresolved variable @${expr.name} reached scalar evaluator.`);
     case "STRING_FUNC":
-      return evalStringFunc(expr, row, resolveFieldType, resolveFieldSemantics2);
+      return evalStringFunc(expr, row, resolveFieldType, resolveFieldSemantics2, context);
     case "CASE_WHEN":
-      return evalCaseWhen(expr, row, resolveFieldType, resolveFieldSemantics2);
+      return evalCaseWhen(expr, row, resolveFieldType, resolveFieldSemantics2, context);
     case "CONCAT_OP": {
       return evalStringFunc({
         type: "STRING_FUNC",
         func: "CONCAT",
         args: [expr.left, expr.right]
-      }, row, resolveFieldType, resolveFieldSemantics2);
+      }, row, resolveFieldType, resolveFieldSemantics2, context);
     }
     case "SCALAR_ARITH": {
-      const left = Number(evalScalarValueExpr(expr.left, row, resolveFieldType, resolveFieldSemantics2));
-      const right = Number(evalScalarValueExpr(expr.right, row, resolveFieldType, resolveFieldSemantics2));
+      const left = Number(evalScalarValueExpr(expr.left, row, resolveFieldType, resolveFieldSemantics2, context));
+      const right = Number(evalScalarValueExpr(expr.right, row, resolveFieldType, resolveFieldSemantics2, context));
       switch (expr.op) {
         case "+":
           return left + right;
@@ -9437,13 +9758,13 @@ function evalScalarValueExpr(expr, row, resolveFieldType, resolveFieldSemantics2
     }
   }
 }
-function evalScalarValueExprNullable(expr, row, resolveFieldType, resolveFieldSemantics2) {
+function evalScalarValueExprNullable(expr, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
   switch (expr.type) {
     case "CASE_WHEN":
-      return evalCaseWhenNullable(expr, row, resolveFieldType, resolveFieldSemantics2);
+      return evalCaseWhenNullable(expr, row, resolveFieldType, resolveFieldSemantics2, context);
     case "SCALAR_ARITH": {
-      const left = evalScalarValueExprNullable(expr.left, row, resolveFieldType, resolveFieldSemantics2);
-      const right = evalScalarValueExprNullable(expr.right, row, resolveFieldType, resolveFieldSemantics2);
+      const left = evalScalarValueExprNullable(expr.left, row, resolveFieldType, resolveFieldSemantics2, context);
+      const right = evalScalarValueExprNullable(expr.right, row, resolveFieldType, resolveFieldSemantics2, context);
       if (left === null || right === null) return null;
       const l = Number(left);
       const r = Number(right);
@@ -9461,12 +9782,12 @@ function evalScalarValueExprNullable(expr, row, resolveFieldType, resolveFieldSe
       }
     }
     case "CONCAT_OP": {
-      const left = evalScalarValueExprNullable(expr.left, row, resolveFieldType, resolveFieldSemantics2);
-      const right = evalScalarValueExprNullable(expr.right, row, resolveFieldType, resolveFieldSemantics2);
+      const left = evalScalarValueExprNullable(expr.left, row, resolveFieldType, resolveFieldSemantics2, context);
+      const right = evalScalarValueExprNullable(expr.right, row, resolveFieldType, resolveFieldSemantics2, context);
       return `${left ?? ""}${right ?? ""}`;
     }
     default:
-      return evalScalarValueExpr(expr, row, resolveFieldType, resolveFieldSemantics2);
+      return evalScalarValueExpr(expr, row, resolveFieldType, resolveFieldSemantics2, context);
   }
 }
 function applyRoundOp(op, num, digits) {
@@ -9618,9 +9939,9 @@ function replaceNthMatch(input, globalRe, replacement, n) {
     return expandRegexpReplacement(replacement, match, captures, namedGroups);
   });
 }
-function evalStringFunc(expr, row, resolveFieldType, resolveFieldSemantics2) {
+function evalStringFunc(expr, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
   assertStringFunctionArity(expr.func, expr.args);
-  const args = expr.args.map((a) => evalStringFuncArg(a, row, resolveFieldType, resolveFieldSemantics2));
+  const args = expr.args.map((a) => evalStringFuncArg(a, row, resolveFieldType, resolveFieldSemantics2, context));
   switch (expr.func) {
     case "UPPER":
       return (args[0] ?? "").toUpperCase();
@@ -9768,14 +10089,14 @@ function evalStringFunc(expr, row, resolveFieldType, resolveFieldSemantics2) {
     case "SQRT":
       return String(Math.sqrt(Number(args[0] ?? "0")));
     case "CURRENT_DATE": {
-      const now = /* @__PURE__ */ new Date();
+      const now = context.statementInstant ?? /* @__PURE__ */ new Date();
       const y = now.getFullYear();
       const m = String(now.getMonth() + 1).padStart(2, "0");
       const d = String(now.getDate()).padStart(2, "0");
       return `${y}-${m}-${d}`;
     }
     case "CURRENT_TIMESTAMP":
-      return (/* @__PURE__ */ new Date()).toISOString();
+      return (context.statementInstant ?? /* @__PURE__ */ new Date()).toISOString();
   }
 }
 function parseDateParts(s) {
@@ -9937,12 +10258,12 @@ function formatWithComma(num, digits) {
   const intFmt = intStr.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
   return decStr ? `${intFmt}.${decStr}` : intFmt;
 }
-function evalStringFuncArg(arg, row, resolveFieldType, resolveFieldSemantics2) {
+function evalStringFuncArg(arg, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY") {
     return String(evalMaterializedAggregateOperand(arg, row));
   }
   if (arg.type === "NUMBER") return numberLiteralText(arg);
-  return String(evalScalarValueExpr(arg, row, resolveFieldType, resolveFieldSemantics2));
+  return String(evalScalarValueExpr(arg, row, resolveFieldType, resolveFieldSemantics2, context));
 }
 function evalMaterializedAggregateOperand(node, row) {
   if (node.type === "NUMBER") return node.value;
@@ -9983,37 +10304,37 @@ function resolveFieldRef(row, field) {
 }
 
 // src/engine/evalWhere.ts
-function evalWhere(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
+function evalWhere(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context = {}) {
   switch (expr.type) {
     case "BOOLEAN":
       return expr.value;
     case "BINARY":
-      return evalBinary(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
+      return evalBinary(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context);
     case "NULL_CHECK":
       return evalNullCheck(expr, row);
     case "LOGICAL":
-      return evalLogical(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
+      return evalLogical(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context);
     case "NOT":
-      return !evalWhere(expr.expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
+      return !evalWhere(expr.expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context);
     case "GROUP":
-      return evalWhere(expr.expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
+      return evalWhere(expr.expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context);
     case "EXISTS": {
       const exists = expr.resolved;
       return expr.not ? !exists : exists;
     }
   }
 }
-function evalBinary(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
+function evalBinary(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context = {}) {
   if (expr.op === "KLIKE" || expr.op === "NOT_KLIKE") {
     if (appliedKlikes?.has(expr)) return true;
     throw new Error("KLIKE / NOT KLIKE \u306F\u62BC\u3057\u4E0B\u3052\u6E08\u307F\u96C6\u5408\u306B\u542B\u307E\u308C\u306A\u3044\u305F\u3081 JavaScript \u5074\u3067\u306F\u8A55\u4FA1\u3067\u304D\u307E\u305B\u3093");
   }
-  const left = resolveField(expr.left, row, resolveFieldType, resolveFieldSemantics2);
+  const left = resolveField(expr.left, row, resolveFieldType, resolveFieldSemantics2, context);
   const fieldType = expr.left.type === "FIELD" ? resolveFieldType?.(expr.left) : void 0;
   const semantics = semanticsForLeft(expr.left, fieldType, resolveFieldSemantics2);
-  return evalOp(expr.op, left, expr.right, row, fieldType, resolveFieldType, semantics, resolveFieldSemantics2);
+  return evalOp(expr.op, left, expr.right, row, fieldType, resolveFieldType, semantics, resolveFieldSemantics2, context);
 }
-function evalOp(op, leftStr, right, row, fieldType, resolveFieldType, semantics = syntheticSemantics("string"), resolveFieldSemantics2) {
+function evalOp(op, leftStr, right, row, fieldType, resolveFieldType, semantics = syntheticSemantics("string"), resolveFieldSemantics2, context = {}) {
   if (op === "IN" || op === "NOT_IN") {
     let values = null;
     if (right.type === "IN_LIST") {
@@ -10028,17 +10349,17 @@ function evalOp(op, leftStr, right, row, fieldType, resolveFieldType, semantics
     return op === "IN" ? contains : !contains;
   }
   if (op === "LIKE") {
-    const pattern = resolveValue(right, row, resolveFieldType);
+    const pattern = resolveValue(right, row, resolveFieldType, void 0, context);
     return matchLike(leftStr, pattern);
   }
   if (op === "NOT_LIKE") {
-    const pattern = resolveValue(right, row, resolveFieldType);
+    const pattern = resolveValue(right, row, resolveFieldType, void 0, context);
     return !matchLike(leftStr, pattern);
   }
   if (op === "KLIKE" || op === "NOT_KLIKE") {
     throw new Error("KLIKE / NOT KLIKE \u306F JavaScript \u5074\u3067\u306F\u8A55\u4FA1\u3067\u304D\u307E\u305B\u3093\uFF08SIMPLE SELECT \u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059\uFF09");
   }
-  const rightStr = resolveValue(right, row, resolveFieldType, resolveFieldSemantics2);
+  const rightStr = resolveValue(right, row, resolveFieldType, resolveFieldSemantics2, context);
   return compareScalarValues(op, leftStr, rightStr, semantics);
 }
 var NUMERIC_STRING_FUNCTIONS = /* @__PURE__ */ new Set([
@@ -10150,17 +10471,17 @@ function evalNullCheck(expr, row) {
   const val = resolveField(expr.field, row);
   return expr.not ? val !== "" : val === "";
 }
-function evalLogical(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
+function evalLogical(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context = {}) {
   if (expr.op === "AND") {
-    return evalWhere(expr.left, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) && evalWhere(expr.right, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
+    return evalWhere(expr.left, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context) && evalWhere(expr.right, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context);
   }
-  return evalWhere(expr.left, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) || evalWhere(expr.right, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
+  return evalWhere(expr.left, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context) || evalWhere(expr.right, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context);
 }
-function resolveField(field, row, resolveFieldType, resolveFieldSemantics2) {
-  if (field.type === "FUNC_FIELD") return evalStringFunc(field.expr, row);
+function resolveField(field, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
+  if (field.type === "FUNC_FIELD") return evalStringFunc(field.expr, row, void 0, void 0, context);
   if (field.type === "AGG_FIELD") return String(evalMaterializedAggregateOperand(field.expr, row));
-  if (field.type === "ARITH_FIELD") return String(evalArithExpr(field.expr, row));
-  if (field.type === "CASE_FIELD") return evalCaseWhen(field.expr, row, resolveFieldType, resolveFieldSemantics2);
+  if (field.type === "ARITH_FIELD") return String(evalArithExpr(field.expr, row, context));
+  if (field.type === "CASE_FIELD") return evalCaseWhen(field.expr, row, resolveFieldType, resolveFieldSemantics2, context);
   if (field.type === "GROUPING_FIELD") return evalGroupingRef(field.ref, row);
   if (field.aggregateRef) {
     const ref = field.aggregateRef;
@@ -10169,7 +10490,7 @@ function resolveField(field, row, resolveFieldType, resolveFieldSemantics2) {
   const key = field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
   return resolveFieldRef(row, key);
 }
-function resolveValue(value, row, resolveFieldType, resolveFieldSemantics2) {
+function resolveValue(value, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
   switch (value.type) {
     case "VARIABLE":
       throw new Error(`ParseError: unresolved batch variable @${value.name}.`);
@@ -10191,44 +10512,44 @@ function resolveValue(value, row, resolveFieldType, resolveFieldSemantics2) {
       return value.resolved;
     case "ARITH_VALUE":
       if (value.expr.type === "FIELD_REF") return resolveFieldRef(row, value.expr.field);
-      if (value.expr.type === "STRING_FUNC") return evalStringFunc(value.expr, row);
-      return String(evalArithExpr(value.expr, row));
+      if (value.expr.type === "STRING_FUNC") return evalStringFunc(value.expr, row, void 0, void 0, context);
+      return String(evalArithExpr(value.expr, row, context));
     case "CASE_VALUE":
-      return evalCaseWhen(value.expr, row, resolveFieldType, resolveFieldSemantics2);
+      return evalCaseWhen(value.expr, row, resolveFieldType, resolveFieldSemantics2, context);
     case "ARRAY":
       return value.elements.map((e) => e.value).join(",");
   }
 }
-function evalCaseWhen(expr, row, resolveFieldType, resolveFieldSemantics2) {
+function evalCaseWhen(expr, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
   for (const branch of expr.branches) {
-    if (evalWhere(branch.condition, row, resolveFieldType, void 0, resolveFieldSemantics2)) {
-      return evalCaseResult(branch.result, row, resolveFieldType, resolveFieldSemantics2);
+    if (evalWhere(branch.condition, row, resolveFieldType, void 0, resolveFieldSemantics2, context)) {
+      return evalCaseResult(branch.result, row, resolveFieldType, resolveFieldSemantics2, context);
     }
   }
   if (expr.elseResult !== null) {
-    return evalCaseResult(expr.elseResult, row, resolveFieldType, resolveFieldSemantics2);
+    return evalCaseResult(expr.elseResult, row, resolveFieldType, resolveFieldSemantics2, context);
   }
   return "";
 }
-function evalCaseWhenNullable(expr, row, resolveFieldType, resolveFieldSemantics2) {
+function evalCaseWhenNullable(expr, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
   for (const branch of expr.branches) {
-    if (evalWhere(branch.condition, row, resolveFieldType, void 0, resolveFieldSemantics2)) {
-      return evalCaseResultNullable(branch.result, row, resolveFieldType, resolveFieldSemantics2);
+    if (evalWhere(branch.condition, row, resolveFieldType, void 0, resolveFieldSemantics2, context)) {
+      return evalCaseResultNullable(branch.result, row, resolveFieldType, resolveFieldSemantics2, context);
     }
   }
-  return expr.elseResult === null ? null : evalCaseResultNullable(expr.elseResult, row, resolveFieldType, resolveFieldSemantics2);
+  return expr.elseResult === null ? null : evalCaseResultNullable(expr.elseResult, row, resolveFieldType, resolveFieldSemantics2, context);
 }
-function evalCaseResultNullable(result, row, resolveFieldType, resolveFieldSemantics2) {
+function evalCaseResultNullable(result, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
   if (result.type === "ARRAY") return result.elements.map((entry) => entry.value).join(",");
   if (result.type === "AGG_REF") {
     return row[aggregateSyntheticName(result.func, result.distinct, result.arg)] ?? "";
   }
   if (result.type === "AGG_ARITH") return row[aggregateOperandLabel(result)] ?? "";
   if (result.type === "FIELD_REF") return row[result.field] ?? "";
-  if (result.type === "ARITH") return evalArithExpr(result, row);
-  return evalScalarValueExprNullable(result, row, resolveFieldType, resolveFieldSemantics2);
+  if (result.type === "ARITH") return evalArithExpr(result, row, context);
+  return evalScalarValueExprNullable(result, row, resolveFieldType, resolveFieldSemantics2, context);
 }
-function evalCaseResult(result, row, resolveFieldType, resolveFieldSemantics2) {
+function evalCaseResult(result, row, resolveFieldType, resolveFieldSemantics2, context = {}) {
   if (result.type === "ARRAY") return result.elements.map((e) => e.value).join(",");
   if (result.type === "AGG_REF") {
     return row[aggregateSyntheticName(result.func, result.distinct, result.arg)] ?? "";
@@ -10238,12 +10559,12 @@ function evalCaseResult(result, row, resolveFieldType, resolveFieldSemantics2) {
     return row[result.field] ?? "";
   }
   if (result.type === "ARITH") {
-    return String(evalArithExpr(result, row));
+    return String(evalArithExpr(result, row, context));
   }
-  return String(evalScalarValueExpr(result, row, resolveFieldType, resolveFieldSemantics2));
+  return String(evalScalarValueExpr(result, row, resolveFieldType, resolveFieldSemantics2, context));
 }
-function resolveKintoneFunc(name) {
-  const now = /* @__PURE__ */ new Date();
+function resolveKintoneFunc(name, context = {}) {
+  const now = context.statementInstant ?? /* @__PURE__ */ new Date();
   switch (name) {
     case "TODAY": {
       const y = now.getFullYear();
@@ -10367,21 +10688,21 @@ function assertDmlWhereIsSafe(where) {
 }
 var USER_TYPES = /* @__PURE__ */ new Set(["USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"]);
 var ARRAY_TYPES = /* @__PURE__ */ new Set(["CHECK_BOX", "MULTI_SELECT"]);
-function insertToPostBatches(stmt, fieldTypes = /* @__PURE__ */ new Map()) {
+function insertToPostBatches(stmt, fieldTypes = /* @__PURE__ */ new Map(), evaluationContext = {}) {
   const allRecords = stmt.values.map(
-    (row) => buildInsertRecord(stmt.fields, row, fieldTypes)
+    (row) => buildInsertRecord(stmt.fields, row, fieldTypes, evaluationContext)
   );
   return chunk(allRecords, 100).map((records) => ({
     app: stmt.appId,
     records
   }));
 }
-function buildInsertRecord(fields, row, fieldTypes) {
+function buildInsertRecord(fields, row, fieldTypes, evaluationContext) {
   const record = {};
   fields.forEach((field, i) => {
     const val = row[i];
     if (val.type === "CASE_VALUE") {
-      record[field] = { value: evalCaseWhenValue(val.expr, {}, fieldTypes.get(field)) };
+      record[field] = { value: evalCaseWhenValue(val.expr, {}, fieldTypes.get(field), evaluationContext) };
     } else {
       record[field] = { value: toKintoneValue(val, fieldTypes.get(field)) };
     }
@@ -10541,14 +10862,14 @@ function collectConditionFields(expr, out) {
       break;
   }
 }
-function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new Map()) {
+function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new Map(), evaluationContext = {}) {
   const updateRecords = records.map((raw) => {
     const id = Number(raw["$id"].value);
     const row = kintoneRecordToProcessRow(raw);
     const record = {};
     for (const { field, value } of stmt.assignments) {
       record[field] = {
-        value: evaluateUpdateAssignmentValue(value, row, fieldTypes.get(field), raw)
+        value: evaluateUpdateAssignmentValue(value, row, fieldTypes.get(field), raw, evaluationContext)
       };
     }
     return { id, record };
@@ -10558,25 +10879,31 @@ function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new
     records: batch
   }));
 }
-function evaluateUpdateAssignmentValue(value, row, fieldType, raw) {
+function evaluateUpdateAssignmentValue(value, row, fieldType, raw, evaluationContext = {}) {
   if (value.type === "ARITH") {
-    return String(raw ? evalArith(value, raw) : evalArithExpr(value, row));
+    return String(raw ? evalArith(value, raw) : evalArithExpr(value, row, evaluationContext));
   }
   if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") {
-    return String(evalScalarValueExpr(value, row));
+    return String(evalScalarValueExpr(value, row, void 0, void 0, evaluationContext));
   }
-  if (value.type === "STRING_FUNC") return evalStringFunc(value, row);
-  if (value.type === "CASE_VALUE") return evalCaseWhenValue(value.expr, row, fieldType);
+  if (value.type === "STRING_FUNC") return evalStringFunc(value, row, void 0, void 0, evaluationContext);
+  if (value.type === "CASE_VALUE") return evalCaseWhenValue(value.expr, row, fieldType, evaluationContext);
   if (value.type === "SOURCE_FIELD") {
     throw new DmlConvertError("SOURCE_FIELD \u306F UPDATE ... FROM \u5C02\u7528\u3067\u3059");
   }
   return toKintoneValue(value, fieldType);
 }
-function evaluateSubtableAssignmentValue(value, row, resolveFieldType) {
+function evaluateSubtableAssignmentValue(value, row, resolveFieldType, evaluationContext = {}) {
   if (value.type === "STRING") return value.value;
   if (value.type === "NUMBER") return numberLiteralText(value);
-  if (value.type === "ARITH") return String(evalArithExpr(value, row));
-  if (value.type === "CASE_VALUE") return evalCaseWhen(value.expr, row, resolveFieldType);
+  if (value.type === "ARITH") return String(evalArithExpr(value, row, evaluationContext));
+  if (value.type === "CASE_VALUE") return evalCaseWhen(
+    value.expr,
+    row,
+    resolveFieldType,
+    void 0,
+    evaluationContext
+  );
   throw new Error(`${value.type} \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306E\u5024\u3068\u3057\u3066\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`);
 }
 var UPDATE_FROM_UNSUPPORTED_TYPES = /* @__PURE__ */ new Set([
@@ -10587,7 +10914,7 @@ var UPDATE_FROM_UNSUPPORTED_TYPES = /* @__PURE__ */ new Set([
   "GROUP_SELECT",
   "FILE"
 ]);
-function updateFromToPutBatches(stmt, matched, fieldTypes = /* @__PURE__ */ new Map()) {
+function updateFromToPutBatches(stmt, matched, fieldTypes = /* @__PURE__ */ new Map(), evaluationContext = {}) {
   const updateRecords = matched.map(({ target, source }) => {
     const id = Number(target["$id"]?.value);
     if (!Number.isSafeInteger(id) || id <= 0) {
@@ -10617,9 +10944,20 @@ function updateFromToPutBatches(stmt, matched, fieldTypes = /* @__PURE__ */ new
       } else if (value.type === "ARITH") {
         record[field] = { value: String(evalArith(value, target)) };
       } else if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") {
-        record[field] = { value: String(evalScalarValueExpr(value, targetRow)) };
+        record[field] = { value: String(evalScalarValueExpr(
+          value,
+          targetRow,
+          void 0,
+          void 0,
+          evaluationContext
+        )) };
       } else if (value.type === "CASE_VALUE") {
-        record[field] = { value: evalCaseWhenValue(value.expr, targetRow, fieldType) };
+        record[field] = { value: evalCaseWhenValue(
+          value.expr,
+          targetRow,
+          fieldType,
+          evaluationContext
+        ) };
       } else {
         record[field] = { value: toKintoneValue(value, fieldType) };
       }
@@ -10721,7 +11059,7 @@ function convertArray(elements, fieldType) {
   if (isUserType(fieldType)) return elements.map((c) => ({ code: c }));
   return elements;
 }
-function evalCaseResultValue(result, row, fieldType) {
+function evalCaseResultValue(result, row, fieldType, evaluationContext) {
   if (result.type === "ARRAY") {
     return convertArray(result.elements.map((e) => e.value), fieldType);
   }
@@ -10732,26 +11070,26 @@ function evalCaseResultValue(result, row, fieldType) {
     return convertString2(result.value, fieldType);
   }
   if (result.type === "STRING_FUNC") {
-    return evalStringFunc(result, row);
+    return evalStringFunc(result, row, void 0, void 0, evaluationContext);
   }
   if (result.type === "FIELD_REF" || result.type === "ARITH") {
-    return String(evalArithExpr(result, row));
+    return String(evalArithExpr(result, row, evaluationContext));
   }
-  return String(evalScalarValueExpr(result, row));
+  return String(evalScalarValueExpr(result, row, void 0, void 0, evaluationContext));
 }
 function collectUpdateCheckTargetFields(stmt) {
   if (!stmt.checkGroups) return [];
   const targetAlias = `app${stmt.appId}`.toLowerCase();
   return [...new Set(collectCheckFieldRefs(stmt.checkGroups).filter((ref) => ref.tableAlias === null || ref.tableAlias.toLowerCase() === targetAlias).map((ref) => ref.field).filter((field) => field !== "$id"))];
 }
-function evalCaseWhenValue(expr, row, fieldType) {
+function evalCaseWhenValue(expr, row, fieldType, evaluationContext = {}) {
   for (const branch of expr.branches) {
-    if (evalWhere(branch.condition, row)) {
-      return evalCaseResultValue(branch.result, row, fieldType);
+    if (evalWhere(branch.condition, row, void 0, void 0, void 0, evaluationContext)) {
+      return evalCaseResultValue(branch.result, row, fieldType, evaluationContext);
     }
   }
   if (expr.elseResult !== null) {
-    return evalCaseResultValue(expr.elseResult, row, fieldType);
+    return evalCaseResultValue(expr.elseResult, row, fieldType, evaluationContext);
   }
   return "";
 }
@@ -11029,18 +11367,30 @@ function buildApplyPatchPlan(input) {
   const parentId = requirePositiveInteger(snapshot["$id"]?.value, "APPLY snapshot $id");
   const expectedParentId = getApplyParentId(statement);
   if (parentId !== expectedParentId) argument2(`APPLY snapshot $id ${parentId} does not match requested $id ${expectedParentId}.`);
-  return buildApplyPatchPlanForSnapshot(statement, snapshot, metadata, parentId);
+  return buildApplyPatchPlanForSnapshot(
+    statement,
+    snapshot,
+    metadata,
+    parentId,
+    input.evaluationContext
+  );
 }
-function buildApplyPatchPlans(statement, snapshots, fieldInfos, metadata = resolveApplyPatchMetadata(statement, fieldInfos)) {
+function buildApplyPatchPlans(statement, snapshots, fieldInfos, metadata = resolveApplyPatchMetadata(statement, fieldInfos), evaluationContext = {}) {
   const parentIds = /* @__PURE__ */ new Set();
   return snapshots.map((snapshot) => {
     const parentId = requirePositiveInteger(snapshot["$id"]?.value, "APPLY snapshot $id");
     if (parentIds.has(parentId)) argument2(`APPLY snapshots contain duplicate parentId ${parentId}.`);
     parentIds.add(parentId);
-    return buildApplyPatchPlanForSnapshot(statement, snapshot, metadata, parentId);
+    return buildApplyPatchPlanForSnapshot(
+      statement,
+      snapshot,
+      metadata,
+      parentId,
+      evaluationContext
+    );
   });
 }
-function buildApplyPatchPlanForSnapshot(statement, snapshot, metadata, parentId) {
+function buildApplyPatchPlanForSnapshot(statement, snapshot, metadata, parentId, evaluationContext = {}) {
   const revision = requirePositiveInteger(snapshot["$revision"]?.value, "APPLY snapshot $revision");
   const tablePlans = [];
   const multiValuePlans = [];
@@ -11069,13 +11419,24 @@ function buildApplyPatchPlanForSnapshot(statement, snapshot, metadata, parentId)
     const hasRemove = block.operations.some((operation) => operation.kind === "REMOVE");
     for (const [operationIndex, operation] of block.operations.entries()) {
       if (operation.kind === "APPEND") {
-        const rows = buildApplyAppendRows(operation, targetChildren, block.field);
+        const rows = buildApplyAppendRows(
+          operation,
+          targetChildren,
+          block.field,
+          evaluationContext
+        );
         operationPlans.push({ kind: "APPEND", addedRows: rows.length });
         appended.push(...rows);
         continue;
       }
       if (operation.kind === "REMOVE") {
-        const indices2 = resolveRemoveTargets(operation, snapshotRows, childTypeResolver, block.field);
+        const indices2 = resolveRemoveTargets(
+          operation,
+          snapshotRows,
+          childTypeResolver,
+          block.field,
+          evaluationContext
+        );
         if (operation.expectRows) {
           assertExpectRows(operation.expectRows, indices2.length, parentId, block.field, operationIndex, operation.kind);
         }
@@ -11093,7 +11454,13 @@ function buildApplyPatchPlanForSnapshot(statement, snapshot, metadata, parentId)
         continue;
       }
       if (operation.kind !== "PATCH") continue;
-      const indices = resolvePatchTargets(operation, snapshotRows, childTypeResolver, block.field);
+      const indices = resolvePatchTargets(
+        operation,
+        snapshotRows,
+        childTypeResolver,
+        block.field,
+        evaluationContext
+      );
       if (operation.expectRows) {
         assertExpectRows(operation.expectRows, indices.length, parentId, block.field, operationIndex, operation.kind);
       }
@@ -11112,7 +11479,12 @@ function buildApplyPatchPlanForSnapshot(statement, snapshot, metadata, parentId)
           resolved.push({
             rowIndex,
             field: assignment.field,
-            value: evaluateSubtableAssignmentValue(assignment.value, flat, childTypeResolver)
+            value: evaluateSubtableAssignmentValue(
+              assignment.value,
+              flat,
+              childTypeResolver,
+              evaluationContext
+            )
           });
         }
       }
@@ -11164,7 +11536,13 @@ function buildApplyPatchPlanForSnapshot(statement, snapshot, metadata, parentId)
   for (const assignment of statement.assignments) {
     const fieldType = metadata.fieldsByCode.get(assignment.field)?.fieldType;
     parentValues[assignment.field] = {
-      value: evaluateUpdateAssignmentValue(assignment.value, parentRow, fieldType, snapshot)
+      value: evaluateUpdateAssignmentValue(
+        assignment.value,
+        parentRow,
+        fieldType,
+        snapshot,
+        evaluationContext
+      )
     };
   }
   const postImage = { ...snapshot };
@@ -11234,12 +11612,12 @@ function normalizeApplyPatchPlan(plan, normalizedRecord) {
     postImage: normalizedRecord
   };
 }
-function buildApplyAppendRows(operation, children, table) {
+function buildApplyAppendRows(operation, children, table, evaluationContext = {}) {
   return operation.values.map((row) => ({
-    value: buildAppendValue(operation, row, children, table)
+    value: buildAppendValue(operation, row, children, table, evaluationContext)
   }));
 }
-function buildAppendValue(operation, row, children, table) {
+function buildAppendValue(operation, row, children, table, evaluationContext) {
   if (row.length !== operation.fields.length) {
     return argument2(`APPLY APPEND for ${table} has ${row.length} values for ${operation.fields.length} fields.`);
   }
@@ -11248,7 +11626,7 @@ function buildAppendValue(operation, row, children, table) {
   for (const field of children.values()) {
     if (field.fieldType === "FILE" || field.writable === false) continue;
     const sqlValue = specified.get(field.code);
-    value[field.code] = { value: sqlValue === void 0 ? appendDefaultValue(field) : sqlValue.type === "CASE_VALUE" ? evalCaseWhenValue(sqlValue.expr, {}, field.fieldType) : toKintoneValue(sqlValue, field.fieldType) };
+    value[field.code] = { value: sqlValue === void 0 ? appendDefaultValue(field) : sqlValue.type === "CASE_VALUE" ? evalCaseWhenValue(sqlValue.expr, {}, field.fieldType, evaluationContext) : toKintoneValue(sqlValue, field.fieldType) };
   }
   return value;
 }
@@ -11256,17 +11634,36 @@ function appendDefaultValue(field) {
   if (field.defaultValue !== void 0 && field.defaultValue !== null) return field.defaultValue;
   return ["CHECK_BOX", "MULTI_SELECT", "USER_SELECT", "ORGANIZATION_SELECT", "GROUP_SELECT"].includes(field.fieldType) ? [] : "";
 }
-function resolvePatchTargets(operation, rows, resolveFieldType, table) {
-  return resolveSelectorTargets(operation.selector, rows, resolveFieldType, table);
+function resolvePatchTargets(operation, rows, resolveFieldType, table, evaluationContext = {}) {
+  return resolveSelectorTargets(
+    operation.selector,
+    rows,
+    resolveFieldType,
+    table,
+    evaluationContext
+  );
 }
-function resolveRemoveTargets(operation, rows, resolveFieldType, table) {
-  return resolveSelectorTargets(operation.selector, rows, resolveFieldType, table);
+function resolveRemoveTargets(operation, rows, resolveFieldType, table, evaluationContext = {}) {
+  return resolveSelectorTargets(
+    operation.selector,
+    rows,
+    resolveFieldType,
+    table,
+    evaluationContext
+  );
 }
-function resolveSelectorTargets(selector, rows, resolveFieldType, table) {
+function resolveSelectorTargets(selector, rows, resolveFieldType, table, evaluationContext = {}) {
   if (selector.kind === "ALL_ROWS") return rows.map((_, index) => index);
   const where = selector.where;
   const indices = rows.flatMap(
-    (row, index) => evalWhere(where, flattenSubtableSnapshotRow(row, index), resolveFieldType) ? [index] : []
+    (row, index) => evalWhere(
+      where,
+      flattenSubtableSnapshotRow(row, index),
+      resolveFieldType,
+      void 0,
+      void 0,
+      evaluationContext
+    ) ? [index] : []
   );
   const requestedRid = exactRidSelectorValue(where);
   if (requestedRid !== null && indices.length === 0) {
@@ -14557,9 +14954,16 @@ function assertJoinKeyAvailable(rows, key, savedColumns) {
     throw new Error(`ArgumentError: JOIN key ${key} is not available in the materialized table.`);
   }
 }
-function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
+function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldSemantics2, evaluationContext = {}) {
   if (where === null) return rows;
-  return rows.filter((row) => evalWhere(where, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2));
+  return rows.filter((row) => evalWhere(
+    where,
+    row,
+    resolveFieldType,
+    appliedKlikes,
+    resolveFieldSemantics2,
+    evaluationContext
+  ));
 }
 function hasAggregateColumns(columns) {
   return columns.some(
@@ -14593,12 +14997,28 @@ function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolution
     const outRow = asProcessingRow({ ...groupRows[0] });
     for (const k of groupByKeys) {
       if (k.type === "ARITH_KEY") {
-        outRow[arithColDefaultKey(k.expr)] = String(evalArithExpr(k.expr, groupRows[0]));
+        outRow[arithColDefaultKey(k.expr)] = String(evalArithExpr(
+          k.expr,
+          groupRows[0],
+          aliasEvaluationContext.evaluationContext
+        ));
       } else if (k.type === "FUNC_KEY") {
-        outRow[stringFuncDefaultKey(k.expr)] = evalStringFunc(k.expr, groupRows[0]);
+        outRow[stringFuncDefaultKey(k.expr)] = evalStringFunc(
+          k.expr,
+          groupRows[0],
+          void 0,
+          void 0,
+          aliasEvaluationContext.evaluationContext
+        );
       }
     }
-    materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind);
+    materializeAggregateColumns(
+      outRow,
+      groupRows,
+      columns,
+      resolveAggSortKind,
+      aliasEvaluationContext.evaluationContext
+    );
     result.push(outRow);
   }
   return result;
@@ -14656,7 +15076,13 @@ function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {})
           outRow[item.unqualifiedBridgeKey] = value;
         }
       }
-      materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind);
+      materializeAggregateColumns(
+        outRow,
+        groupRows,
+        columns,
+        resolveAggSortKind,
+        limits.evaluationContext
+      );
       attachGroupingRowMeta(outRow, includedCanonicalIds);
       result.push(outRow);
     }
@@ -14667,11 +15093,19 @@ function groupingItemValue(item, row) {
   if (!row) return "";
   return row[item.directKey] ?? (item.unqualifiedBridgeKey === null ? void 0 : row[item.unqualifiedBridgeKey]) ?? "";
 }
-function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind) {
+function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind, evaluationContext = {}) {
   for (const [columnIndex, col] of columns.entries()) {
     if (col.type === "AGGREGATE") {
       const syntheticKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
-      const value = String(evalAggregate(col.func, col.distinct, col.arg, col.separator, groupRows, resolveAggSortKind));
+      const value = String(evalAggregate(
+        col.func,
+        col.distinct,
+        col.arg,
+        col.separator,
+        groupRows,
+        resolveAggSortKind,
+        evaluationContext
+      ));
       setMaterializedSelectValue(
         outRow,
         columnIndex,
@@ -14679,38 +15113,44 @@ function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortK
         col.alias ? [col.alias, syntheticKey] : [syntheticKey]
       );
     } else if (col.type === "ARITH_AGG_COL") {
-      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
+      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind, evaluationContext);
       const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
       setMaterializedSelectValue(
         outRow,
         columnIndex,
-        String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind)),
+        String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind, evaluationContext)),
         [outputKey]
       );
     } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
-      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
+      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind, evaluationContext);
       const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
       const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
-      setMaterializedSelectValue(outRow, columnIndex, evalStringFunc(resolvedExpr, outRow), [outputKey]);
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        evalStringFunc(resolvedExpr, outRow, void 0, void 0, evaluationContext),
+        [outputKey]
+      );
     } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
-      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
+      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind, evaluationContext);
       const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
       const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
       setMaterializedSelectValue(
         outRow,
         columnIndex,
-        String(evalScalarValueExpr(resolvedExpr, outRow)),
+        String(evalScalarValueExpr(resolvedExpr, outRow, void 0, void 0, evaluationContext)),
         [outputKey]
       );
     } else if (col.type === "CASE_COL" && containsAggregate2(col.expr)) {
-      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
+      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind, evaluationContext);
       const resolvedExpr = resolveAggInCaseExpr(col.expr, groupRows, resolveAggSortKind);
       const resolveAggregateSemantics = (field) => field.aggregateRef ? aggregateResultSemantics(field.aggregateRef, resolveAggSortKind) : void 0;
       const value = evalCaseWhen(
         resolvedExpr,
         outRow,
         void 0,
-        resolveAggregateSemantics
+        resolveAggregateSemantics,
+        evaluationContext
       );
       setMaterializedSelectValue(
         outRow,
@@ -14738,7 +15178,7 @@ function collectAggregateRefs(node, out) {
   if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
   Object.values(value).forEach((child) => collectAggregateRefs(child, out));
 }
-function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind) {
+function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind, evaluationContext = {}) {
   const refs = [];
   collectAggregateRefs(node, refs);
   for (const ref of refs) {
@@ -14750,7 +15190,8 @@ function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind
       ref.arg,
       ref.separator,
       rows,
-      resolveAggSortKind
+      resolveAggSortKind,
+      evaluationContext
     ));
     materializedValuesFor(outRow).byLookupKey.set(key, value);
   }
@@ -14781,14 +15222,20 @@ function evalGroupByKey(key, row, resolution, columns, aliasEvaluationContext) {
       `InternalError: unresolved plain GROUP BY item ${resolution.kind} reached evaluation.`
     );
   }
-  if (key.type === "FUNC_KEY") return evalStringFunc(key.expr, row);
-  return String(evalArithExpr(key.expr, row));
+  if (key.type === "FUNC_KEY") return evalStringFunc(
+    key.expr,
+    row,
+    void 0,
+    void 0,
+    aliasEvaluationContext.evaluationContext
+  );
+  return String(evalArithExpr(key.expr, row, aliasEvaluationContext.evaluationContext));
 }
-function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind) {
+function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind, evaluationContext = {}) {
   if (arg.type === "WILDCARD") {
     return func === "COUNT" ? rows.length : 0;
   }
-  const strValues = aggregateRowValues(func, arg, rows).filter((value) => value !== null);
+  const strValues = aggregateRowValues(func, arg, rows, evaluationContext).filter((value) => value !== null);
   const statistical = func === "STDDEV_POP" || func === "STDDEV_SAMP" || func === "VAR_POP" || func === "VAR_SAMP" || func === "MEDIAN";
   const numericValues = statistical ? strValues.map((value) => {
     const numeric = Number(value);
@@ -14866,7 +15313,7 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
     }
   }
 }
-function aggregateRowValues(func, arg, rows) {
+function aggregateRowValues(func, arg, rows, evaluationContext = {}) {
   return rows.map((processingRow) => {
     const row = sourceRowForEvaluation(processingRow);
     let strVal;
@@ -14875,11 +15322,11 @@ function aggregateRowValues(func, arg, rows) {
       if (raw === void 0 || raw === "" && func !== "MIN" && func !== "MAX") return null;
       strVal = raw;
     } else if (arg.type === "ARITH" || arg.type === "NUMBER") {
-      const n = evalArithExpr(arg, row);
+      const n = evalArithExpr(arg, row, evaluationContext);
       if (isNaN(n)) return null;
       strVal = String(n);
     } else {
-      const value = evalScalarValueExprNullable(arg, row);
+      const value = evalScalarValueExprNullable(arg, row, void 0, void 0, evaluationContext);
       if (value === null) return null;
       if (value === "" && func !== "MIN" && func !== "MAX") return null;
       if (typeof value === "number" && Number.isNaN(value)) return null;
@@ -14892,9 +15339,17 @@ function toAggregateFieldRef(field) {
   const dot = field.indexOf(".");
   return dot > 0 ? { type: "FIELD", tableAlias: field.slice(0, dot), field: field.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field };
 }
-function evalAggArithExpr(node, rows, resolveAggSortKind) {
+function evalAggArithExpr(node, rows, resolveAggSortKind, evaluationContext = {}) {
   if (node.type === "NUMBER") return node.value;
-  if (node.type === "AGG_REF") return Number(evalAggregate(node.func, node.distinct, node.arg, node.separator, rows, resolveAggSortKind));
+  if (node.type === "AGG_REF") return Number(evalAggregate(
+    node.func,
+    node.distinct,
+    node.arg,
+    node.separator,
+    rows,
+    resolveAggSortKind,
+    evaluationContext
+  ));
   if (node.type === "AGG_GROUP_KEY") {
     const field = node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field;
     return Number(resolveFieldRef(rows[0] ?? {}, field));
@@ -14902,8 +15357,8 @@ function evalAggArithExpr(node, rows, resolveAggSortKind) {
   if (node.type === "VARIABLE") {
     throw new Error(`InternalError: unresolved aggregate arithmetic variable @${node.name}.`);
   }
-  const l = evalAggArithExpr(node.left, rows, resolveAggSortKind);
-  const r = evalAggArithExpr(node.right, rows, resolveAggSortKind);
+  const l = evalAggArithExpr(node.left, rows, resolveAggSortKind, evaluationContext);
+  const r = evalAggArithExpr(node.right, rows, resolveAggSortKind, evaluationContext);
   switch (node.op) {
     case "+":
       return l + r;
@@ -14947,22 +15402,24 @@ function aggregateResultSemantics(ref, resolver) {
   const semantics = ref.arg.type === "WILDCARD" ? "string" : resolveAggregateArgSemantics(ref.arg, resolver) ?? "string";
   return typeof semantics === "string" ? syntheticSemantics(semantics) : semantics;
 }
-function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2) {
+function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2, evaluationContext = {}) {
   if (having === null) return rows;
   return rows.filter((row) => evalWhere(
     having,
     havingEvaluationRow(row),
     resolveFieldType,
     void 0,
-    resolveFieldSemantics2
+    resolveFieldSemantics2,
+    evaluationContext
   ));
 }
-function applyDistinct(rows, columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
+function applyDistinct(rows, columns, scalarCache, resolveFieldType, resolveFieldSemantics2, evaluationContext = {}) {
   if (rows.length === 0) return rows;
   const keyFor = buildDistinctKeyBuilder(rows, columns, {
     scalarCache,
     resolveFieldType,
-    resolveFieldSemantics: resolveFieldSemantics2
+    resolveFieldSemantics: resolveFieldSemantics2,
+    evaluationContext
   });
   const seen = /* @__PURE__ */ new Set();
   return rows.filter((row) => {
@@ -14998,11 +15455,19 @@ function buildDistinctKeyBuilder(rows, columns, context) {
   };
   return (row) => JSON.stringify(buildDistinctTuple(columns, row, distinctContext));
 }
-function applyOrderBy(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator) {
+function applyOrderBy(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator, evaluationContext = {}) {
   if (orderBy.length === 0) return rows;
-  return sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator).rows.map((item) => item.row);
+  return sortDecoratedRows(
+    rows,
+    orderBy,
+    optionOrders,
+    sortKinds,
+    fieldSemantics2,
+    aliasEvaluator,
+    evaluationContext
+  ).rows.map((item) => item.row);
 }
-function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator) {
+function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator, evaluationContext = {}) {
   const keyMeta = orderBy.map(({ key }) => {
     if (key.type === "ARITH_KEY") return { semantics: syntheticSemantics("number") };
     if (key.type === "FUNC_KEY") {
@@ -15028,7 +15493,7 @@ function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantic
   const decorated = rows.map((row) => ({
     row,
     keys: orderBy.map(({ key }, i) => {
-      const s = evalOrderKey(key, row, aliasEvaluator);
+      const s = evalOrderKey(key, row, aliasEvaluator, evaluationContext);
       return { s };
     })
   }));
@@ -15066,20 +15531,20 @@ var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
   "QUARTER",
   "WEEK"
 ]);
-function evalOrderKey(key, row, aliasEvaluator) {
+function evalOrderKey(key, row, aliasEvaluator, evaluationContext = {}) {
   const sourceRow = sourceRowForEvaluation(row);
   switch (key.type) {
     case "FIELD_NAME":
       return aliasEvaluator?.(key.name, row) ?? getMaterializedLookupValue(row, key.name) ?? sourceRow[key.name] ?? "";
     case "ARITH_KEY":
-      return String(evalArithExpr(key.expr, sourceRow));
+      return String(evalArithExpr(key.expr, sourceRow, evaluationContext));
     case "FUNC_KEY":
-      return evalStringFunc(key.expr, sourceRow);
+      return evalStringFunc(key.expr, sourceRow, void 0, void 0, evaluationContext);
     case "GROUPING_KEY":
       return evalGroupingRef(key.ref, row);
   }
 }
-function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
+function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, resolveFieldSemantics2, evaluationContext = {}) {
   const evaluators = /* @__PURE__ */ new Map();
   for (const [columnIndex, column] of columns.entries()) {
     if (!("alias" in column) || column.alias === null) continue;
@@ -15103,15 +15568,37 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
         evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "");
         break;
       case "ARITH_COL":
-        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, sourceRowForEvaluation(row))));
+        evaluators.set(alias, (row) => String(evalArithExpr(
+          column.expr,
+          sourceRowForEvaluation(row),
+          evaluationContext
+        )));
         break;
       case "STRFUNC_COL": {
         const source = stringFuncDefaultKey(column.expr);
-        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? evalStringFunc(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2));
+        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? evalStringFunc(
+          column.expr,
+          sourceRowForEvaluation(row),
+          resolveFieldType,
+          resolveFieldSemantics2,
+          evaluationContext
+        ) : evalStringFunc(
+          column.expr,
+          sourceRowForEvaluation(row),
+          resolveFieldType,
+          resolveFieldSemantics2,
+          evaluationContext
+        ));
         break;
       }
       case "CASE_COL":
-        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? "" : evalCaseWhen(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2));
+        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? "" : evalCaseWhen(
+          column.expr,
+          sourceRowForEvaluation(row),
+          resolveFieldType,
+          resolveFieldSemantics2,
+          evaluationContext
+        ));
         break;
       case "SCALAR_VALUE_COL": {
         const source = scalarValueDefaultKey(column.expr);
@@ -15119,7 +15606,8 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
           column.expr,
           sourceRowForEvaluation(row),
           resolveFieldType,
-          resolveFieldSemantics2
+          resolveFieldSemantics2,
+          evaluationContext
         )));
         break;
       }
@@ -15135,7 +15623,7 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
   }
   return (name, row) => evaluators.get(name)?.(row);
 }
-function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind) {
+function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind, evaluationContext = {}) {
   const windows = columns.map((column, columnIndex) => ({ column, columnIndex })).filter((item) => item.column.type === "WINDOW_COL");
   if (rows.length === 0 || windows.length === 0) return rows;
   for (let index = 0; index < rows.length; index++) rows[index] = asProcessingRow(rows[index]);
@@ -15148,14 +15636,28 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
       else partitions.set(key, [row]);
     }
     for (const partition of partitions.values()) {
-      const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
+      const sortedResult = sortDecoratedRows(
+        partition,
+        window.orderBy,
+        optionOrders,
+        sortKinds,
+        fieldSemantics2,
+        void 0,
+        evaluationContext
+      );
       const sorted = sortedResult.rows;
       if (isAggregateWindow(window)) {
-        applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortKind);
+        applyAggregateWindow(
+          window,
+          columnIndex,
+          sortedResult,
+          resolveAggSortKind,
+          evaluationContext
+        );
         continue;
       }
       if (isValueWindow(window)) {
-        applyValueWindow(window, columnIndex, sorted);
+        applyValueWindow(window, columnIndex, sorted, evaluationContext);
         continue;
       }
       if (!isRankingWindow(window)) {
@@ -15175,14 +15677,24 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
   }
   return rows;
 }
-function evaluateValueWindowArg(arg, row) {
-  const value = evalScalarValueExprNullable(arg, sourceRowForEvaluation(row));
+function evaluateValueWindowArg(arg, row, evaluationContext = {}) {
+  const value = evalScalarValueExprNullable(
+    arg,
+    sourceRowForEvaluation(row),
+    void 0,
+    void 0,
+    evaluationContext
+  );
   if (value === null || value === void 0) return "";
   if (typeof value === "number" && !Number.isFinite(value)) return "";
   return String(value);
 }
-function applyValueWindow(window, columnIndex, sorted) {
-  const values = sorted.map((item) => evaluateValueWindowArg(window.arg, item.row));
+function applyValueWindow(window, columnIndex, sorted, evaluationContext = {}) {
+  const values = sorted.map((item) => evaluateValueWindowArg(
+    window.arg,
+    item.row,
+    evaluationContext
+  ));
   const direction = window.valueFunc === "LAG" ? -1 : 1;
   for (let index = 0; index < sorted.length; index++) {
     const target = index + direction * window.offset;
@@ -15194,9 +15706,14 @@ function applyValueWindow(window, columnIndex, sorted) {
     );
   }
 }
-function applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortKind) {
+function applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortKind, evaluationContext = {}) {
   const sorted = sortedResult.rows;
-  const values = window.arg.type === "WILDCARD" ? null : aggregateRowValues(window.aggFunc, window.arg, sorted.map((item) => item.row));
+  const values = window.arg.type === "WILDCARD" ? null : aggregateRowValues(
+    window.aggFunc,
+    window.arg,
+    sorted.map((item) => item.row),
+    evaluationContext
+  );
   const comparison = window.arg.type === "WILDCARD" ? void 0 : resolveAggregateArgSemantics(window.arg, resolveAggSortKind);
   const semantics = typeof comparison === "string" ? syntheticSemantics(comparison) : comparison ?? syntheticSemantics("string");
   const output = [];
@@ -15288,13 +15805,14 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
       return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, source) ?? "0";
     }
     case "ARITH_COL":
-      return String(evalArithExpr(column.expr, sourceRow));
+      return String(evalArithExpr(column.expr, sourceRow, context.evaluationContext));
     case "CASE_COL":
       return containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? getLegacyMaterializedValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? "" : evalCaseWhen(
         column.expr,
         sourceRow,
         context.resolveFieldType,
-        context.resolveFieldSemantics
+        context.resolveFieldSemantics,
+        context.evaluationContext
       );
     case "GROUPING_COL":
       return evalGroupingRef(column.ref, row);
@@ -15304,12 +15822,14 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
         column.expr,
         sourceRow,
         context.resolveFieldType,
-        context.resolveFieldSemantics
+        context.resolveFieldSemantics,
+        context.evaluationContext
       ) : evalStringFunc(
         column.expr,
         sourceRow,
         context.resolveFieldType,
-        context.resolveFieldSemantics
+        context.resolveFieldSemantics,
+        context.evaluationContext
       );
     }
     case "SCALAR_VALUE_COL": {
@@ -15318,7 +15838,8 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
         column.expr,
         sourceRow,
         context.resolveFieldType,
-        context.resolveFieldSemantics
+        context.resolveFieldSemantics,
+        context.evaluationContext
       ));
     }
     case "SCALAR_SUBQUERY_COL":
@@ -15333,7 +15854,7 @@ function buildDistinctTuple(columns, row, context = {}) {
     return typeof value === "string" ? value : value.entries.map(([, entryValue]) => entryValue);
   });
 }
-function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, resolveFieldSemantics2, hiddenQualifiedAliases) {
+function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, resolveFieldSemantics2, hiddenQualifiedAliases, evaluationContext = {}) {
   if (columns.length === 1 && columns[0].type === "WILDCARD") {
     const projected2 = rows.map((row) => {
       const visible = stripHiddenQualifiedColumns(
@@ -15366,10 +15887,11 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, r
   }
   const projected = rows.map((row, rowIdx) => {
     const out = {};
-    const evaluationContext = {
+    const columnEvaluationContext = {
       scalarCache,
       resolveFieldType,
       resolveFieldSemantics: resolveFieldSemantics2,
+      evaluationContext,
       wildcardKeys: Object.keys(stripHiddenQualifiedColumns(
         stripParentShortcutColumns(row),
         hiddenQualifiedAliases
@@ -15377,7 +15899,7 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, r
       parentWildcardKeys: Object.keys(row).filter((key) => key.startsWith("_p.")).sort()
     };
     for (const [colIdx, col] of columns.entries()) {
-      const value = evaluateSelectColumnValue(col, row, colIdx, evaluationContext);
+      const value = evaluateSelectColumnValue(col, row, colIdx, columnEvaluationContext);
       switch (col.type) {
         case "VARIABLE_COL":
           break;
@@ -15769,7 +16291,8 @@ function runFullScan(input) {
     hiddenQualifiedAliases,
     resolvedGroupingSpec,
     plainGroupByPlan,
-    warnings
+    warnings,
+    evaluationContext
   } = input;
   const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns, aggregateSortKindResolver);
   for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
@@ -15798,7 +16321,14 @@ function runFullScan(input) {
     knownColumns = mergeKnownColumns(knownColumns, rightColumns, rows);
   }
   const filterWhere = input.residualWhere !== void 0 ? input.residualWhere : stmt.where;
-  rows = applyFilter(rows, filterWhere, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
+  rows = applyFilter(
+    rows,
+    filterWhere,
+    fieldTypeResolver,
+    appliedKlikes,
+    fieldSemanticsResolver,
+    evaluationContext
+  );
   const grouping = normalizeGroupingSpec(stmt);
   if (grouping.type === "GROUPING_SETS") {
     if (!resolvedGroupingSpec) {
@@ -15809,7 +16339,7 @@ function runFullScan(input) {
       resolvedGroupingSpec,
       stmt.columns,
       aggregateSortKindResolver,
-      { maxGeneratedRows: B65_MAX_GENERATED_ROWS }
+      { maxGeneratedRows: B65_MAX_GENERATED_ROWS, evaluationContext }
     );
   } else if (grouping.type === "PLAIN" || hasAggregateColumns(stmt.columns)) {
     rows = applyGroupBy(
@@ -15821,21 +16351,29 @@ function runFullScan(input) {
       {
         scalarCache,
         resolveFieldType: fieldTypeResolver,
-        resolveFieldSemantics: fieldSemanticsResolver
+        resolveFieldSemantics: fieldSemanticsResolver,
+        evaluationContext
       }
     );
   }
   warnOnUnresolvedAggregateComparisons(stmt.columns, rows, warnings);
   const resolveHavingSemantics = (field) => field.aggregateRef ? aggregateResultSemantics(field.aggregateRef, aggregateSortKindResolver) : havingFieldSemanticsResolver?.(field);
   warnOnUnresolvedAggregateComparisons(stmt.having, rows, warnings);
-  rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, resolveHavingSemantics);
+  rows = applyHaving(
+    rows,
+    stmt.having,
+    havingFieldTypeResolver,
+    resolveHavingSemantics,
+    evaluationContext
+  );
   rows = applyWindow(
     rows,
     stmt.columns,
     optionOrders,
     sortKinds,
     effectiveOrderSemantics,
-    aggregateSortKindResolver
+    aggregateSortKindResolver,
+    evaluationContext
   );
   if (stmt.distinct) {
     rows = applyDistinct(
@@ -15843,7 +16381,8 @@ function runFullScan(input) {
       stmt.columns,
       scalarCache,
       fieldTypeResolver,
-      fieldSemanticsResolver
+      fieldSemanticsResolver,
+      evaluationContext
     );
   }
   rows = applyOrderBy(
@@ -15852,7 +16391,14 @@ function runFullScan(input) {
     optionOrders,
     sortKinds,
     effectiveOrderSemantics,
-    buildOrderByAliasEvaluator(stmt.columns, scalarCache, fieldTypeResolver, fieldSemanticsResolver)
+    buildOrderByAliasEvaluator(
+      stmt.columns,
+      scalarCache,
+      fieldTypeResolver,
+      fieldSemanticsResolver,
+      evaluationContext
+    ),
+    evaluationContext
   );
   rows = applyLimit(rows, stmt.limit, stmt.offset);
   return project(
@@ -15862,7 +16408,8 @@ function runFullScan(input) {
     fieldTypeResolver,
     sourceColumns2,
     fieldSemanticsResolver,
-    hiddenQualifiedAliases
+    hiddenQualifiedAliases,
+    evaluationContext
   );
 }
 
@@ -15908,6 +16455,147 @@ function toFlatString(value) {
   }
 }
 
+// src/core/diagnostics.ts
+var DiagnosticCodes = {
+  HEADER_UNKNOWN_KEY: "KSQL1001",
+  HEADER_DUPLICATE_KEY: "KSQL1002",
+  HEADER_INVALID_NAME: "KSQL1003",
+  HEADER_INVALID_DEPENDS_ON: "KSQL1004",
+  HEADER_INVALID_TIMEOUT: "KSQL1005",
+  HEADER_INVALID_DIALECT: "KSQL1006",
+  LOGICAL_APP_UNRESOLVED: "KSQL1101",
+  LEX_ERROR: "KSQL1201",
+  PARSE_ERROR: "KSQL1202"
+};
+function sourceLocationAt(source, offset) {
+  const target = Math.max(0, Math.min(offset, source.length));
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < target; i++) {
+    const ch = source[i];
+    if (ch === "\r") {
+      if (source[i + 1] === "\n" && i + 1 < target) i++;
+      line++;
+      column = 1;
+    } else if (ch === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { line, column };
+}
+function diagnosticAt(source, offset, diagnostic2) {
+  return { ...diagnostic2, ...sourceLocationAt(source, offset) };
+}
+
+// src/core/scriptHeader.ts
+var HEADER_LINE_RE = /^(\s*)--\s*@ksql\s+([^:\s]+)\s*:\s*(.*)$/i;
+function parseScriptHeader(source) {
+  const meta = { name: null, dependsOn: [], timeout: null, dialect: 0 };
+  const diagnostics = [];
+  const seen = /* @__PURE__ */ new Set();
+  let hasDirectives = false;
+  let offset = source.charCodeAt(0) === 65279 ? 1 : 0;
+  let headerEnd = offset;
+  while (offset < source.length) {
+    const lineEnd = findLineEnd(source, offset);
+    const line = source.slice(offset, lineEnd.contentEnd);
+    if (!/^\s*--/.test(line)) break;
+    headerEnd = lineEnd.next;
+    const match = HEADER_LINE_RE.exec(line);
+    if (match) {
+      hasDirectives = true;
+      const rawKey = match[2];
+      const key = rawKey.toLowerCase();
+      const rawValue = match[3];
+      const commentAt = rawValue.indexOf("#");
+      const valuePart = commentAt < 0 ? rawValue : rawValue.slice(0, commentAt);
+      const leading = valuePart.match(/^\s*/)?.[0].length ?? 0;
+      const value = valuePart.trim();
+      const valueOffset = offset + match.index + match[0].length - rawValue.length + leading;
+      if (!isHeaderKey(key)) {
+        diagnostics.push(diagnosticAt(source, valueOffset, {
+          severity: "warning",
+          code: DiagnosticCodes.HEADER_UNKNOWN_KEY,
+          message: `Unknown @ksql header key "${rawKey}" was ignored.`
+        }));
+      } else if (seen.has(key)) {
+        diagnostics.push(diagnosticAt(source, valueOffset, {
+          severity: "warning",
+          code: DiagnosticCodes.HEADER_DUPLICATE_KEY,
+          message: `Duplicate @ksql header key "${key}" was ignored; the first value is retained.`
+        }));
+      } else {
+        seen.add(key);
+        applyHeaderValue(meta, key, value, source, valueOffset, diagnostics);
+      }
+    }
+    offset = lineEnd.next;
+  }
+  return { meta, diagnostics, hasDirectives, headerEnd };
+}
+function isHeaderKey(value) {
+  return value === "name" || value === "depends_on" || value === "timeout" || value === "dialect";
+}
+function applyHeaderValue(meta, key, value, source, valueOffset, diagnostics) {
+  if (key === "name") {
+    if (!value) {
+      diagnostics.push(diagnosticAt(source, valueOffset, {
+        severity: "error",
+        code: DiagnosticCodes.HEADER_INVALID_NAME,
+        message: "@ksql name must not be empty."
+      }));
+    } else {
+      meta.name = value;
+    }
+    return;
+  }
+  if (key === "depends_on") {
+    const dependencies = value.split(",").map((item) => item.trim());
+    if (!value || dependencies.some((item) => !item)) {
+      diagnostics.push(diagnosticAt(source, valueOffset, {
+        severity: "error",
+        code: DiagnosticCodes.HEADER_INVALID_DEPENDS_ON,
+        message: "@ksql depends_on must be a comma-separated list without empty items."
+      }));
+    } else {
+      meta.dependsOn = dependencies;
+    }
+    return;
+  }
+  if (key === "timeout") {
+    if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value))) {
+      diagnostics.push(diagnosticAt(source, valueOffset, {
+        severity: "error",
+        code: DiagnosticCodes.HEADER_INVALID_TIMEOUT,
+        message: "@ksql timeout must be a positive integer."
+      }));
+    } else {
+      meta.timeout = Number(value);
+    }
+    return;
+  }
+  if (value !== "0" && value !== "1") {
+    diagnostics.push(diagnosticAt(source, valueOffset, {
+      severity: "error",
+      code: DiagnosticCodes.HEADER_INVALID_DIALECT,
+      message: "@ksql dialect must be 0 or 1."
+    }));
+  } else {
+    meta.dialect = Number(value);
+  }
+}
+function findLineEnd(source, start) {
+  let i = start;
+  while (i < source.length && source[i] !== "\r" && source[i] !== "\n") i++;
+  const contentEnd = i;
+  if (source[i] === "\r" && source[i + 1] === "\n") i += 2;
+  else if (i < source.length) i++;
+  return { contentEnd, next: i };
+}
+
 // src/core/dmlPrevalidation.ts
 function collectDmlPrevalidationSnapshotFields(fieldIndex) {
   return [
@@ -17572,6 +18260,18 @@ var SearchAbortedError = class extends Error {
 var materializedMetaBySelectResult = /* @__PURE__ */ new WeakMap();
 var materializedMetaByValidationResult = /* @__PURE__ */ new WeakMap();
 var importSourceByDmlStatement = /* @__PURE__ */ new WeakMap();
+var statementEvaluationContextKey = /* @__PURE__ */ Symbol("statementEvaluationContext");
+function bindStatementEvaluationContext(options) {
+  const internal = options;
+  if (internal[statementEvaluationContextKey]) return options;
+  return {
+    ...options,
+    [statementEvaluationContextKey]: { statementInstant: /* @__PURE__ */ new Date() }
+  };
+}
+function statementEvaluationContext(options) {
+  return options[statementEvaluationContextKey] ?? {};
+}
 var defaultCacheContextByClient = /* @__PURE__ */ new WeakMap();
 var nextDefaultCacheContextId = 1;
 var nextCacheInvocationId = 1;
@@ -17821,6 +18521,7 @@ async function resolveRelativeDateExecutionPlan(stmt, client, cacheContext) {
   });
 }
 async function executeParsedStatement(stmt, client, options, cacheContext) {
+  options = bindStatementEvaluationContext(options);
   const relativeDatePlan = await resolveRelativeDateExecutionPlan(stmt, client, cacheContext);
   if (stmt.type !== "EXPLAIN") assertRelativeDatePushdownPlan(relativeDatePlan);
   const unresolved = findVariableRef(stmt);
@@ -17916,6 +18617,8 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
       throw new Error("ArgumentError: DECLARE variable requires a batch.");
     case "ASSERT":
       return executeAssert(stmt, client, options, cacheContext);
+    case "EXIT":
+      throw new Error("ArgumentError: EXIT SUCCESS IF \u306F\u30D0\u30C3\u30C1\u5C02\u7528\u3067\u3059");
   }
 }
 var EXISTING_VALIDATION_COLUMNS = [
@@ -18035,7 +18738,14 @@ async function executeExistingRecordValidationCore(stmt, client, options, cacheC
     id: String(record["$id"]?.value ?? ""),
     record,
     flat: flatten(record, null)
-  })).filter((row) => stmt.where === null || evalWhere(stmt.where, row.flat, (field) => evaluationTypes.get(field.field)));
+  })).filter((row) => stmt.where === null || evalWhere(
+    stmt.where,
+    row.flat,
+    (field) => evaluationTypes.get(field.field),
+    void 0,
+    void 0,
+    statementEvaluationContext(options)
+  ));
   const rows = [];
   const detailRows = /* @__PURE__ */ new Map();
   const summaryRows = /* @__PURE__ */ new Map();
@@ -18176,7 +18886,16 @@ var BatchTimeoutError = class extends Error {
 };
 async function executeBatch(sql, client, options = {}) {
   resolveRecursiveCteLimits(options);
-  const statements = parseSqlBatch(sql, options.enableImport === true);
+  const header = parseScriptHeader(sql);
+  const headerError = header.diagnostics.find((diagnostic2) => diagnostic2.severity === "error");
+  if (header.hasDirectives && headerError) {
+    throw new Error(`${headerError.code}: ${headerError.message} (${headerError.line}:${headerError.column})`);
+  }
+  const statements = parseSqlBatch(
+    header.hasDirectives ? sql.slice(header.headerEnd) : sql,
+    options.enableImport === true,
+    header.hasDirectives && header.meta.dialect === 1
+  );
   const analysis = analyzeBatch(statements);
   statements.forEach((statement) => assertApplyExecutionScope("phase15b", statement));
   if (options.allowApplyMutation !== true && statements.some(
@@ -18218,7 +18937,7 @@ async function executeBatch(sql, client, options = {}) {
       const base = { index: i, type: info.statementType };
       if (aborted) {
         results.push({ ...base, status: "skipped", skippedReason: aborted });
-        failed.add(i);
+        if (aborted !== "exit") failed.add(i);
         continue;
       }
       const brokenDep = info.dependsOn.find((d) => failed.has(d));
@@ -18256,24 +18975,29 @@ async function executeBatch(sql, client, options = {}) {
           info.statementType !== "SELECT" && info.statementType !== "UNION" && info.statementType !== "WITH" || statementContainsOuterJoin(statements[i])
         );
         const cursorScope = wrapClientWithCursorScope(statementClient);
+        const boundOptions = bindStatementEvaluationContext(stmtOptions);
+        const statementContext = {
+          stmt: statements[i],
+          info,
+          client: cursorScope.client,
+          options: boundOptions,
+          cacheContext,
+          tempTables,
+          variables,
+          relativeDateVariables,
+          clock: statementEvaluationContext(boundOptions)
+        };
         const outcome = await runWithDeadline(
-          executeBatchStatement(
-            statements[i],
-            info,
-            cursorScope.client,
-            stmtOptions,
-            cacheContext,
-            tempTables,
-            variables,
-            relativeDateVariables
-          ),
+          executeBatchStatement(statementContext),
           remaining,
           cursorScope.closeActive
         );
         if (outcome.result) {
           outcome.result = attachSearchAbortWarning(outcome.result, searchAbortCollector);
         }
-        results.push({ ...base, status: "success", ...outcome });
+        const { exitTriggered, ...statementOutcome } = outcome;
+        results.push({ ...base, status: "success", ...statementOutcome });
+        if (exitTriggered) aborted = "exit";
       } catch (e) {
         results.push({
           ...base,
@@ -18295,7 +19019,7 @@ async function executeBatch(sql, client, options = {}) {
     }
     metrics.elapsedMs = Date.now() - startedAt;
     return {
-      ok: results.every((r) => r.status === "success"),
+      ok: results.every((r) => r.status === "success" || r.skippedReason === "exit"),
       statementCount: statements.length,
       statements: results,
       analysis,
@@ -18311,7 +19035,18 @@ function statementHasApplyMutation(statement) {
   }
   return statement.type === "UPSERT" && statement.validateOnly !== true && Boolean(statement.onInsertApplyBlocks?.length || statement.onUpdateApplyBlocks?.length);
 }
-async function executeBatchStatement(stmt, info, client, options, cacheContext, tempTables, variables, relativeDateVariables) {
+async function executeBatchStatement(context) {
+  const {
+    stmt,
+    info,
+    client,
+    options,
+    cacheContext,
+    tempTables,
+    variables,
+    relativeDateVariables,
+    clock
+  } = context;
   if (stmt.type === "SET_VARIABLE") {
     const resolvedStmt2 = resolveBatchVariableReferences(stmt, variables);
     validateStatementStatic(resolvedStmt2);
@@ -18351,7 +19086,7 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
         throw e;
       }
     } else {
-      variables.set(stmt.name, evaluateScalarExpr(resolvedStmt2.expr));
+      variables.set(stmt.name, evaluateScalarExpr(resolvedStmt2.expr, clock));
     }
     return {};
   }
@@ -18367,7 +19102,10 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     if (Object.prototype.hasOwnProperty.call(injected, stmt.name)) {
       variables.set(stmt.name, { type: "string", value: injected[stmt.name] });
     } else {
-      const value = evaluateScalarExpr(stmt.default);
+      const value = evaluateScalarExpr(
+        stmt.default,
+        clock
+      );
       variables.set(stmt.name, {
         type: "string",
         value: value.type === "number" ? value.raw ?? String(value.value) : value.value
@@ -18463,8 +19201,12 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     }
   }
   if (resolvedStmt.type === "ASSERT") {
-    await executeAssert(resolvedStmt, client, options, cacheContext, tempTables);
-    return {};
+    const result = await executeAssert(resolvedStmt, client, options, cacheContext, tempTables);
+    return result.warning !== void 0 ? { result } : {};
+  }
+  if (resolvedStmt.type === "EXIT") {
+    const result = await executeExit(resolvedStmt, client, options, cacheContext, tempTables);
+    return { result, ...result.exited ? { exitTriggered: true } : {} };
   }
   if (info.tempTablesReferenced.length > 0) {
     if (resolvedStmt.type === "SELECT" || resolvedStmt.type === "UNION") {
@@ -18588,9 +19330,9 @@ function safeJsonStringify(v) {
     return String(v);
   }
 }
-function parseSqlBatch(sql, enableImport = false) {
+function parseSqlBatch(sql, enableImport = false, dialect1 = false) {
   const tokens = new Lexer(sql).tokenize();
-  return new Parser(tokens, { import: enableImport }).parseStatements();
+  return new Parser(tokens, { import: enableImport, dialect1 }).parseStatements();
 }
 function parseRelativeDateVariableValue(name, value) {
   try {
@@ -18618,18 +19360,18 @@ function prepareRelativeDateVariables(statements, injectedVariables) {
   }
   return prepared;
 }
-function evaluateScalarExpr(expr) {
+function evaluateScalarExpr(expr, evaluationContext = {}) {
   switch (expr.type) {
     case "STRING":
       return { type: "string", value: expr.value };
     case "NUMBER":
       return { type: "number", value: expr.value, raw: numberLiteralText(expr) };
     case "KINTONE_FUNC":
-      return { type: "string", value: resolveKintoneFunc(expr.name) };
+      return { type: "string", value: resolveKintoneFunc(expr.name, evaluationContext) };
     case "STRING_FUNC":
-      return { type: "string", value: evalStringFunc(expr, {}) };
+      return { type: "string", value: evalStringFunc(expr, {}, void 0, void 0, evaluationContext) };
     case "ARITH": {
-      const value = evalArithExpr(expr, {});
+      const value = evalArithExpr(expr, {}, evaluationContext);
       if (!Number.isFinite(value)) {
         throw new Error("ArgumentError: SET scalar arithmetic produced a non-finite number.");
       }
@@ -18776,6 +19518,31 @@ var ScalarSubqueryError = class extends Error {
   }
 };
 async function executeAssert(stmt, client, options, cacheContext, tempTables) {
+  const evaluation = await evaluateAssertCondition(stmt, client, options, cacheContext, tempTables);
+  if (!evaluation.passed) {
+    if (stmt.warn === true) {
+      return {
+        type: "ASSERT",
+        condition: stmt.text,
+        passed: false,
+        warning: stmt.message ?? `assertion failed: ${stmt.text} (actual: ${evaluation.actual}).`
+      };
+    }
+    const suffix = stmt.message !== void 0 ? ` ${stmt.message}` : "";
+    throw new AssertError(`assertion failed: ${stmt.text} (actual: ${evaluation.actual}).${suffix}`);
+  }
+  return { type: "ASSERT", condition: stmt.text };
+}
+async function executeExit(stmt, client, options, cacheContext, tempTables) {
+  const evaluation = await evaluateAssertCondition(stmt, client, options, cacheContext, tempTables);
+  return {
+    type: "EXIT",
+    condition: stmt.text,
+    exited: evaluation.passed,
+    message: stmt.message
+  };
+}
+async function evaluateAssertCondition(stmt, client, options, cacheContext, tempTables) {
   const left = await evalAssertOperand(stmt.left, client, options, cacheContext, tempTables);
   const semantics = stmt.left.type === "NUMBER" || stmt.left.type === "ARITH" ? syntheticSemantics("number") : syntheticSemantics("string");
   if (stmt.op === "BETWEEN") {
@@ -18784,19 +19551,16 @@ async function executeAssert(stmt, client, options, cacheContext, tempTables) {
     }
     const low = await evalAssertOperand(stmt.low, client, options, cacheContext, tempTables);
     const high = await evalAssertOperand(stmt.high, client, options, cacheContext, tempTables);
-    if (!compareScalarValues(">=", left, low, semantics) || !compareScalarValues("<=", left, high, semantics)) {
-      throw new AssertError(`assertion failed: ${stmt.text} (actual: ${left}).`);
-    }
-    return { type: "ASSERT", condition: stmt.text };
+    return {
+      passed: compareScalarValues(">=", left, low, semantics) && compareScalarValues("<=", left, high, semantics),
+      actual: left
+    };
   }
   if (stmt.right === null) {
     throw new Error("ArgumentError: malformed ASSERT statement.");
   }
   const right = await evalAssertOperand(stmt.right, client, options, cacheContext, tempTables);
-  if (!compareScalarValues(stmt.op, left, right, semantics)) {
-    throw new AssertError(`assertion failed: ${stmt.text} (actual: ${left}).`);
-  }
-  return { type: "ASSERT", condition: stmt.text };
+  return { passed: compareScalarValues(stmt.op, left, right, semantics), actual: left };
 }
 async function evalAssertOperand(operand, client, options, cacheContext, tempTables) {
   switch (operand.type) {
@@ -19136,7 +19900,7 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   const subqueryWarnings = /* @__PURE__ */ new Set();
   await validateSelectGroupingPlanning(stmt, client, cacheContext, cteCache);
   if (isNoFromSelect(stmt)) {
-    result = executeNoFromSelect(stmt);
+    result = executeNoFromSelect(stmt, options);
     if (captureColumnMeta) {
       materializedMetaBySelectResult.set(
         result,
@@ -19617,13 +20381,30 @@ function validateNoFromColumns(stmt) {
     }
   }
 }
-function executeNoFromSelect(stmt) {
+function executeNoFromSelect(stmt, options) {
   if (stmt.joins.length > 0 || stmt.where || normalizeGroupingSpec(stmt).type !== "NONE" || stmt.having || stmt.orderBy.length > 0 || stmt.distinct) {
     throw new Error("ArgumentError: JOIN/WHERE/GROUP BY/HAVING/ORDER BY/DISTINCT are not supported without FROM.");
   }
   validateNoFromColumns(stmt);
-  const windowed = applyWindow([{}], stmt.columns);
-  const { rows: projected, columns } = project(windowed, stmt.columns);
+  const windowed = applyWindow(
+    [{}],
+    stmt.columns,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    statementEvaluationContext(options)
+  );
+  const { rows: projected, columns } = project(
+    windowed,
+    stmt.columns,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    statementEvaluationContext(options)
+  );
   const rows = applyLimit(projected, stmt.limit, stmt.offset);
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [] };
 }
@@ -19699,8 +20480,10 @@ async function executeSimpleSelect(stmt, client, options, cacheContext, orderPla
         stmt.columns,
         void 0,
         fieldTypeResolvers.row,
-        projectionSemanticsResolver
-      )
+        projectionSemanticsResolver,
+        statementEvaluationContext(options)
+      ),
+      statementEvaluationContext(options)
     );
     rows = applyLimit(rows, stmt.limit, stmt.offset);
   }
@@ -19710,7 +20493,9 @@ async function executeSimpleSelect(stmt, client, options, cacheContext, orderPla
     void 0,
     fieldTypeResolvers.row,
     void 0,
-    projectionSemanticsResolver
+    projectionSemanticsResolver,
+    void 0,
+    statementEvaluationContext(options)
   );
   const columns = await restoreEmptyWildcardColumns(
     stmt,
@@ -20873,7 +21658,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     ...prefilterPlan ? { residualWhere: prefilterPlan.residualWhere } : boundServerFunctionPlan ? { residualWhere: boundServerFunctionPlan.joinPlan.residualWhere } : {},
     resolvedGroupingSpec: resolvedGroupingSpecs.get(stmt),
     plainGroupByPlan,
-    warnings
+    warnings,
+    evaluationContext: statementEvaluationContext(options)
   });
   const columns = await restoreEmptyWildcardColumns(
     stmt,
@@ -21700,7 +22486,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     tableColumns,
     hiddenQualifiedAliases,
     resolvedGroupingSpec,
-    plainGroupByPlan
+    plainGroupByPlan,
+    evaluationContext: statementEvaluationContext(options)
   });
   const columns = await restoreEmptyWildcardColumns(
     stmt,
@@ -22826,7 +23613,12 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     evaluationTypes = new Map(stmt.fields.map((field) => [field, infoByCode.get(field)?.fieldType ?? ""]));
     assertCheckComparisonTypes(stmt, evaluationTypes);
     rows = stmt.values.map((row) => row.map(
-      (value, i) => value.type === "CASE_VALUE" ? evalCaseWhenValue(value.expr, {}, infoByCode.get(stmt.fields[i])?.fieldType) : value
+      (value, i) => value.type === "CASE_VALUE" ? evalCaseWhenValue(
+        value.expr,
+        {},
+        infoByCode.get(stmt.fields[i])?.fieldType,
+        statementEvaluationContext(options)
+      ) : value
     ));
   } else {
     const selectResult = await dmlSourceMaterializer.materialize(stmt, client, options, cacheContext, tempTables, [...infoByCode.values()]);
@@ -22957,7 +23749,12 @@ async function materializeUpdateValidationCandidates(stmt, client, options, cach
     });
     snapshotsById = indexDmlUpdateSnapshots(resolved.records);
     evaluationById = snapshotsById;
-    records = updateToPutBatchesArith(stmt, resolved.records, fieldTypes).flatMap((batch) => batch.records);
+    records = updateToPutBatchesArith(
+      stmt,
+      resolved.records,
+      fieldTypes,
+      statementEvaluationContext(options)
+    ).flatMap((batch) => batch.records);
   } else {
     const getParams = updateToGetQuery(stmt);
     if (checkTargetFields.length > 0) {
@@ -23125,7 +23922,12 @@ async function materializeUpdateFromValidationCandidates(stmt, from, client, opt
     snapshotFields
   );
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
-  const records = updateFromToPutBatches(stmt, matched, fieldTypes).flatMap((batch) => batch.records);
+  const records = updateFromToPutBatches(
+    stmt,
+    matched,
+    fieldTypes,
+    statementEvaluationContext(options)
+  ).flatMap((batch) => batch.records);
   const matchedById = new Map(matched.map((pair) => [Number(pair.target["$id"]?.value), pair]));
   const snapshotsById = snapshotFields ? indexDmlUpdateSnapshots(matched.map((pair) => pair.target)) : /* @__PURE__ */ new Map();
   return records.sort((a, b) => a.id - b.id).map((entry, index) => ({
@@ -23357,7 +24159,7 @@ async function executeInsert(stmt, client, options, cacheContext) {
   const fieldInfos = await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
   const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, stmt.fields, fieldInfos, client, cacheContext);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
-  const batches = insertToPostBatches(stmt, fieldTypes);
+  const batches = insertToPostBatches(stmt, fieldTypes, statementEvaluationContext(options));
   assertValidDmlRecords(batches.flatMap((batch) => batch.records), stmt.fields, fieldInfos, numberPrecision);
   const createdIds = [];
   for (const batch of batches) {
@@ -23966,7 +24768,12 @@ async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
       { maxRecords, parallel: options.fetchParallel ?? 1 }
     );
     const records = resolved2.records;
-    const batches2 = updateToPutBatchesArith(stmt, records, fieldTypes);
+    const batches2 = updateToPutBatchesArith(
+      stmt,
+      records,
+      fieldTypes,
+      statementEvaluationContext(options)
+    );
     assertValidDmlRecords(batches2.flatMap((batch) => batch.records.map((entry) => entry.record)), targetFields, fieldInfos, numberPrecision);
     if (options.confirm) {
       const ok = await options.confirm(records.length, "UPDATE");
@@ -24023,7 +24830,13 @@ async function executeApplyPatchUpdate(stmt, client, options, cacheContext, stat
     throw new Error(`ArgumentError: APPLY snapshot $id ${actualId} does not match requested $id ${requestedId}.`);
   }
   requireRevision(response.records[0]);
-  const plan = buildApplyPatchPlan({ statement: stmt, snapshot: response.records[0], fieldInfos, metadata });
+  const plan = buildApplyPatchPlan({
+    statement: stmt,
+    snapshot: response.records[0],
+    fieldInfos,
+    metadata,
+    evaluationContext: statementEvaluationContext(options)
+  });
   const fieldIndex = buildPostImageFieldIndex(
     fieldInfos,
     stmt.assignments.map((assignment) => assignment.field)
@@ -24222,7 +25035,8 @@ async function selectApplyParentSnapshots(stmt, client, options, fieldInfos, cac
     row,
     resolvers.fieldTypeResolver,
     selectionPlan.appliedKlikes,
-    resolvers.fieldSemanticsResolver
+    resolvers.fieldSemanticsResolver,
+    statementEvaluationContext(options)
   )).map(({ snapshot }) => snapshot);
 }
 function collectApplyParentWhereFields(where) {
@@ -24463,7 +25277,12 @@ function applyValidationColumnMeta(columns, fieldInfos, appId) {
 async function executeUpdateFrom(stmt, from, client, options, cacheContext, tempTables) {
   const matched = await resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
-  const batches = updateFromToPutBatches(stmt, matched, fieldTypes);
+  const batches = updateFromToPutBatches(
+    stmt,
+    matched,
+    fieldTypes,
+    statementEvaluationContext(options)
+  );
   const targetFields = stmt.assignments.map((assignment) => assignment.field);
   const fieldInfos = await getFieldsCached(stmt.appId, client, cacheContext);
   const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, targetFields, fieldInfos, client, cacheContext);
@@ -24537,7 +25356,12 @@ async function executeUpsert(stmt, client, options, cacheContext) {
     stmt.fields.forEach((field, i) => {
       const val = row[i];
       if (val.type === "CASE_VALUE") {
-        record[field] = { value: evalCaseWhenValue(val.expr, {}, fieldTypes.get(field)) };
+        record[field] = { value: evalCaseWhenValue(
+          val.expr,
+          {},
+          fieldTypes.get(field),
+          statementEvaluationContext(options)
+        ) };
       } else {
         record[field] = { value: toKintoneValue(val, fieldTypes.get(field)) };
       }
@@ -24658,7 +25482,14 @@ async function executeUpdateSubtable(stmt, client, options, cacheContext) {
     { maxRecords: options.maxRecords ?? 1e4, parallel: options.fetchParallel ?? 1 }
   );
   const expanded = expandRowsForSubtableDml(parents, subtableCode);
-  const targets = expanded.filter((r) => evalWhere(stmt.where, r.flat, resolveFieldType));
+  const targets = expanded.filter((r) => evalWhere(
+    stmt.where,
+    r.flat,
+    resolveFieldType,
+    void 0,
+    void 0,
+    statementEvaluationContext(options)
+  ));
   if (options.confirm) {
     const ok = await options.confirm(targets.length, "UPDATE");
     if (!ok) throw new OperationCancelledError("UPDATE", targets.length);
@@ -24678,7 +25509,12 @@ async function executeUpdateSubtable(stmt, client, options, cacheContext) {
       if (a.field.startsWith("_")) {
         throw new Error(`\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u3067\u30B7\u30B9\u30C6\u30E0\u5217\u300C${a.field}\u300D\u306F\u66F4\u65B0\u3067\u304D\u307E\u305B\u3093`);
       }
-      updates[a.field] = { value: evaluateSubtableAssignmentValue(a.value, t.flat, resolveFieldType) };
+      updates[a.field] = { value: evaluateSubtableAssignmentValue(
+        a.value,
+        t.flat,
+        resolveFieldType,
+        statementEvaluationContext(options)
+      ) };
     }
     byRid.set(t.rowId, updates);
   }
@@ -24721,7 +25557,14 @@ async function executeDeleteSubtable(stmt, client, options, cacheContext) {
     { maxRecords: options.maxRecords ?? 1e4, parallel: options.fetchParallel ?? 1 }
   );
   const expanded = expandRowsForSubtableDml(parents, subtableCode);
-  const targets = expanded.filter((r) => evalWhere(stmt.where, r.flat, resolveFieldType));
+  const targets = expanded.filter((r) => evalWhere(
+    stmt.where,
+    r.flat,
+    resolveFieldType,
+    void 0,
+    void 0,
+    statementEvaluationContext(options)
+  ));
   if (options.confirm) {
     const ok = await options.confirm(targets.length, "DELETE");
     if (!ok) throw new OperationCancelledError("DELETE", targets.length);
@@ -24896,7 +25739,8 @@ async function executeReorder(stmt, client, options, cacheContext) {
     r.flat,
     resolveFieldType,
     void 0,
-    resolveReorderSemantics
+    resolveReorderSemantics,
+    statementEvaluationContext(options)
   )).map((r) => r.parentId));
   if (options.confirm) {
     const ok = await options.confirm(targetParentIds.size, "UPDATE");
@@ -24908,7 +25752,13 @@ async function executeReorder(stmt, client, options, cacheContext) {
     if (!parent) continue;
     const rows = getMutableTableRows(parent, stmt.subtableCode);
     const sortable = rows.map((row, i) => ({ row, i, flat: buildFlatRowForSort(parent, stmt.subtableCode, row, i) }));
-    sortable.sort((a, b) => compareByOrder(a.flat, b.flat, stmt.by, resolveReorderSemantics));
+    sortable.sort((a, b) => compareByOrder(
+      a.flat,
+      b.flat,
+      stmt.by,
+      resolveReorderSemantics,
+      statementEvaluationContext(options)
+    ));
     const orderedRowIds = sortable.map((x) => x.row.id ?? "");
     await client.putRecords(buildSubtableReorderPutParams(stmt.appId, pid, getRevision(parent), stmt.subtableCode, orderedRowIds));
   }
@@ -24929,24 +25779,24 @@ function buildFlatRowForSort(parent, subtableCode, row, idx) {
   }
   return flat;
 }
-function compareByOrder(a, b, orderBy, resolveSemantics) {
+function compareByOrder(a, b, orderBy, resolveSemantics, evaluationContext = {}) {
   for (const item of orderBy) {
-    const av = evalOrderKeyForRow(item.key, a);
-    const bv = evalOrderKeyForRow(item.key, b);
+    const av = evalOrderKeyForRow(item.key, a, evaluationContext);
+    const bv = evalOrderKeyForRow(item.key, b, evaluationContext);
     const semantics = item.key.type === "FIELD_NAME" ? resolveSemantics(aggregateFieldRef(item.key.name)) : item.key.type === "ARITH_KEY" ? syntheticSemantics("number") : item.key.type === "FUNC_KEY" ? stringFunctionColumnMeta(item.key.expr).semantics ?? syntheticSemantics("string") : syntheticSemantics("number");
     const cmp = compareCanonicalValues(av, bv, semantics ?? syntheticSemantics("string"));
     if (cmp !== 0) return item.direction === "ASC" ? cmp : -cmp;
   }
   return 0;
 }
-function evalOrderKeyForRow(key, row) {
+function evalOrderKeyForRow(key, row, evaluationContext = {}) {
   switch (key.type) {
     case "FIELD_NAME":
       return row[key.name] ?? "";
     case "ARITH_KEY":
-      return String(evalArithExpr(key.expr, row));
+      return String(evalArithExpr(key.expr, row, evaluationContext));
     case "FUNC_KEY":
-      return evalStringFunc(key.expr, row);
+      return evalStringFunc(key.expr, row, void 0, void 0, evaluationContext);
     case "GROUPING_KEY":
       throw new Error("ArgumentError: GROUPING() is not supported in REORDER BY.");
   }
@@ -26044,7 +26894,16 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
   });
   const invocationCacheContext = createInvocationCacheContext(cacheContext);
   try {
-    const statements = parseSqlBatch(sql, enableImport);
+    const header = parseScriptHeader(sql);
+    const headerError = header.diagnostics.find((diagnostic2) => diagnostic2.severity === "error");
+    if (header.hasDirectives && headerError) {
+      throw new Error(`${headerError.code}: ${headerError.message} (${headerError.line}:${headerError.column})`);
+    }
+    const statements = parseSqlBatch(
+      header.hasDirectives ? sql.slice(header.headerEnd) : sql,
+      enableImport,
+      header.hasDirectives && header.meta.dialect === 1
+    );
     const analysis = analyzeBatch(statements);
     const normalizedInjectedVariables = validateDeclaredBatchVariables(statements, injectedVariables);
     const relativeDateVariables = prepareRelativeDateVariables(statements, normalizedInjectedVariables);
@@ -26239,8 +27098,8 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGrou
   }
   if (stmt.type === "ASSERT") {
     const lines = [
-      `ASSERT ${stmt.text}`,
-      "  check:         \u5B9F\u884C\u6642\u306B\u6761\u4EF6\u8A55\u4FA1\uFF08\u4E0D\u6210\u7ACB\u306F AssertError \u3067\u30D0\u30C3\u30C1\u505C\u6B62\u3001\u4EE5\u964D\u306E\u6587\u306F skipped\uFF09"
+      `ASSERT${stmt.warn === true ? " WARN" : ""} ${stmt.text}${stmt.message !== void 0 ? `, '${stmt.message.replace(/'/g, "''")}'` : ""}`,
+      stmt.warn === true ? "  check:         \u5B9F\u884C\u6642\u306B\u6761\u4EF6\u8A55\u4FA1\uFF08\u4E0D\u6210\u7ACB\u306F\u8B66\u544A\u3068\u3057\u3066\u8A18\u9332\u3057\u3001\u5F8C\u7D9A\u6587\u3092\u7D9A\u884C\uFF09" : "  check:         \u5B9F\u884C\u6642\u306B\u6761\u4EF6\u8A55\u4FA1\uFF08\u4E0D\u6210\u7ACB\u306F AssertError \u3067\u30D0\u30C3\u30C1\u505C\u6B62\u3001\u4EE5\u964D\u306E\u6587\u306F skipped\uFF09"
     ];
     const subqueries = [stmt.left, stmt.right, stmt.low, stmt.high].filter(
       (o) => o !== null && o.type === "SCALAR_SUBQUERY"
@@ -26262,6 +27121,31 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGrou
     });
     return lines;
   }
+  if (stmt.type === "EXIT") {
+    const lines = [
+      `EXIT SUCCESS IF ${stmt.text}, '${stmt.message.replace(/'/g, "''")}'`,
+      "  check:         \u5B9F\u884C\u6642\u306B\u6761\u4EF6\u8A55\u4FA1\uFF08\u6210\u7ACB\u6642\u306F\u6B63\u5E38\u7D42\u4E86\u3057\u3001\u4EE5\u964D\u306E\u6587\u306F skippedReason: exit\uFF09"
+    ];
+    const subqueries = [stmt.left, stmt.right, stmt.low, stmt.high].filter(
+      (o) => o !== null && o.type === "SCALAR_SUBQUERY"
+    );
+    subqueries.forEach((sq, i) => {
+      lines.push(subqueries.length > 1 ? `  subquery[${i + 1}]:` : "  subquery:");
+      const subInfo = hasTempTableRef(sq.query) ? info : { ...info, tempTablesReferenced: [] };
+      lines.push(...buildPlanForBatchQuery(
+        sq.query,
+        subInfo,
+        capabilities,
+        orderPlans,
+        plainGroupByPlans,
+        collector,
+        "main",
+        tempSchemaLedger,
+        explainContext
+      ).map((line) => `  ${line}`));
+    });
+    return lines;
+  }
   if (stmt.type === "UPDATE" && (stmt.applyBlocks?.length ?? 0) > 0) {
     return buildExplainPlan(
       stmt,
@@ -27749,6 +28633,9 @@ function toMutationSummary(result) {
       ...result.errTable !== void 0 ? { errTable: result.errTable } : {}
     };
   }
+  if (result.type === "EXIT") {
+    return { condition: result.condition, exited: result.exited, message: result.message };
+  }
   return { reorderedParentCount: result.reorderedParentCount };
 }
 function buildBatchEnvelope(batch, options = {}) {
@@ -27806,6 +28693,10 @@ function buildBatchEnvelope(batch, options = {}) {
         ...s.result.deletedRows ? { deletedRows: s.result.deletedRows } : {},
         ...s.result.diagnostic ? { diagnostic: s.result.diagnostic } : {}
       });
+    } else if (s.status === "success" && s.result?.type === "ASSERT") {
+      entry.condition = s.result.condition;
+      if (s.result.passed !== void 0) entry.passed = s.result.passed;
+      if (s.result.warning !== void 0) entry.warning = s.result.warning;
     } else if (s.status === "success" && s.result && s.result.type !== "SELECT" && s.result.type !== "ASSERT") {
       Object.assign(entry, toMutationSummary(s.result));
     }