@rex0220/kintone-sql-tools 3.67.0 → 3.69.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) {
@@ -677,6 +677,75 @@ function resolveGroupingSpec(stmt, resolve2) {
   };
 }
 
+// src/core/asOfClock.ts
+var AS_OF_FUNCTION_NAMES = [
+  "NOW",
+  "TODAY",
+  "MONTH_START",
+  "NEXT_MONTH_START"
+];
+var AS_OF_VARIABLE_PREFIX = "\0as-of:";
+function asOfVariableName(name) {
+  return `${AS_OF_VARIABLE_PREFIX}${name}`;
+}
+function asOfFunctionNameFromVariable(name) {
+  if (!name.startsWith(AS_OF_VARIABLE_PREFIX)) return null;
+  const candidate = name.slice(AS_OF_VARIABLE_PREFIX.length);
+  return isAsOfFunctionName(candidate) ? candidate : null;
+}
+function isAsOfFunctionName(name) {
+  return AS_OF_FUNCTION_NAMES.includes(name);
+}
+function createAsOfClock(asOf = /* @__PURE__ */ new Date(), timezone) {
+  if (!(asOf instanceof Date) || !Number.isFinite(asOf.getTime())) {
+    throw new Error("ArgumentError: asOf must be a valid Date.");
+  }
+  let formatter;
+  try {
+    formatter = new Intl.DateTimeFormat("en-CA", {
+      ...timezone === void 0 ? {} : { timeZone: timezone },
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+    formatter.format(asOf);
+  } catch {
+    throw new Error(`ArgumentError: invalid IANA timezone: ${timezone ?? ""}.`);
+  }
+  const parts = formatter.formatToParts(asOf);
+  const year = partNumber(parts, "year");
+  const month = partNumber(parts, "month");
+  const day = partNumber(parts, "day");
+  const today = `${pad4(year)}-${pad2(month)}-${pad2(day)}`;
+  const monthStart = `${pad4(year)}-${pad2(month)}-01`;
+  const nextYear = month === 12 ? year + 1 : year;
+  const nextMonth = month === 12 ? 1 : month + 1;
+  return {
+    asOf: new Date(asOf.getTime()),
+    ...timezone === void 0 ? {} : { timezone },
+    values: {
+      NOW: asOf.toISOString(),
+      TODAY: today,
+      MONTH_START: monthStart,
+      NEXT_MONTH_START: `${pad4(nextYear)}-${pad2(nextMonth)}-01`
+    }
+  };
+}
+function partNumber(parts, type) {
+  const value = parts.find((part) => part.type === type)?.value;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new Error(`InternalError: Intl.DateTimeFormat did not return ${type}.`);
+  }
+  return parsed;
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function pad4(value) {
+  return String(value).padStart(4, "0");
+}
+
 // src/core/aggregateExpression.ts
 function quote(value) {
   return `'${value.replace(/'/g, "''")}'`;
@@ -1082,6 +1151,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 公開型へ位置情報を足さない。 */
@@ -1093,6 +1164,19 @@ var Parser = class {
     this.activeCteDefinition = null;
     this.provisionalRecursiveCte = null;
     this.allowSelectArithVariable = false;
+    if (capabilities.dialect1) {
+      for (let index = 0; index + 1 < tokens.length; index++) {
+        const token = tokens[index];
+        if (token.kind !== "VARIABLE" /* VARIABLE */ || tokens[index + 1].kind !== "(" /* LPAREN */) continue;
+        const name = token.value.slice(1).toUpperCase();
+        if (!isAsOfFunctionName(name)) {
+          throw new ParseError(
+            `\u4F7F\u7528\u53EF\u80FD\u306A as-of \u95A2\u6570\u306F ${AS_OF_FUNCTION_NAMES.map((item) => `@${item}`).join("/")} \u3067\u3059`,
+            token
+          );
+        }
+      }
+    }
   }
   // ----------------------------------------------------------
   // 公開 API
@@ -1120,7 +1204,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 +1225,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 +1268,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 +1293,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
     );
   }
@@ -1248,6 +1346,10 @@ var Parser = class {
   parseScalarExpr(context, allowScalarSubquery) {
     const tok = this.peek();
     if (tok.kind === "VARIABLE" /* VARIABLE */) {
+      if (this.peekAt(1).kind === "(" /* LPAREN */ && this.capabilities.dialect1) {
+        this.advance();
+        return this.finishVariableReference(tok);
+      }
       throw new ParseError(`${context} \u306E\u53F3\u8FBA\u3067\u306F\u4ED6\u306E\u5909\u6570\u3092\u53C2\u7167\u3067\u304D\u307E\u305B\u3093`, tok);
     }
     if (tok.kind === "NULL" /* NULL */) {
@@ -1323,6 +1425,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 +1437,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 +1468,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 +1805,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 +1852,6 @@ var Parser = class {
       const high = this.parseAssertOperand();
       this.rejectAssertCompound();
       return {
-        type: "ASSERT",
         left,
         op: "BETWEEN",
         right: null,
@@ -1722,7 +1870,6 @@ var Parser = class {
     const right = this.parseAssertOperand();
     this.rejectAssertCompound();
     return {
-      type: "ASSERT",
       left,
       op,
       right,
@@ -1731,12 +1878,39 @@ 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);
+    }
+  }
+  /** VARIABLE + `()` is the dialect-1 as-of call syntax; a bare VARIABLE stays unchanged. */
+  finishVariableReference(tok) {
+    const ordinary = { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+    if (this.peek().kind !== "(" /* LPAREN */) return ordinary;
+    if (!this.capabilities.dialect1) return ordinary;
+    const name = tok.value.slice(1).toUpperCase();
+    if (!isAsOfFunctionName(name)) {
+      throw new ParseError(
+        `\u4F7F\u7528\u53EF\u80FD\u306A as-of \u95A2\u6570\u306F ${AS_OF_FUNCTION_NAMES.map((item) => `@${item}`).join("/")} \u3067\u3059`,
+        tok
+      );
+    }
+    this.advance();
+    this.expect(")" /* RPAREN */, `@${name} \u306F\u5F15\u6570\u306A\u3057\u306E () \u3067\u547C\u3073\u51FA\u3057\u3066\u304F\u3060\u3055\u3044`);
+    return { type: "VARIABLE", name: asOfVariableName(name) };
+  }
   /** ASSERT のオペランド: 文字列 / スカラーサブクエリ / 数値算術式 */
   parseAssertOperand() {
     const tok = this.peek();
     if (tok.kind === "VARIABLE" /* VARIABLE */) {
       this.advance();
-      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+      return this.finishVariableReference(tok);
     }
     if (tok.kind === "STRING" /* STRING */) {
       this.advance();
@@ -2110,7 +2284,7 @@ var Parser = class {
         }
         if (tok.kind === "VARIABLE" /* VARIABLE */) {
           this.advance();
-          args.push({ type: "VARIABLE", name: tok.value.slice(1).toLowerCase() });
+          args.push(this.finishVariableReference(tok));
           continue;
         }
         let sign = "";
@@ -2195,15 +2369,21 @@ var Parser = class {
       return this.withAliasDisplay({ type: "SCALAR_VALUE_COL", expr, alias: parsedAlias2?.alias ?? null }, parsedAlias2);
     }
     if (this.peek().kind === "VARIABLE" /* VARIABLE */) {
-      const variable = this.advance();
-      if (!this.consume("AS" /* AS */)) {
-        throw new ParseError("SELECT \u5217\u306E\u30D0\u30C3\u30C1\u5909\u6570\u306B\u306F AS alias \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+      const variable = this.finishVariableReference(this.advance());
+      const asOfFunction = asOfFunctionNameFromVariable(variable.name);
+      let parsedAlias2 = null;
+      if (asOfFunction === null) {
+        if (!this.consume("AS" /* AS */)) {
+          throw new ParseError("SELECT \u5217\u306E\u30D0\u30C3\u30C1\u5909\u6570\u306B\u306F AS alias \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+        }
+        parsedAlias2 = this.parseAliasName();
+      } else if (this.consume("AS" /* AS */)) {
+        parsedAlias2 = this.parseAliasName();
       }
-      const parsedAlias2 = this.parseAliasName();
       return this.withAliasDisplay({
         type: "VARIABLE_COL",
-        name: variable.value.slice(1).toLowerCase(),
-        alias: parsedAlias2.alias
+        name: variable.name,
+        alias: parsedAlias2?.alias ?? null
       }, parsedAlias2);
     }
     const windowFunc = this.tryWindowFunc();
@@ -2539,7 +2719,7 @@ var Parser = class {
     }
     if (this.peek().kind === "VARIABLE" /* VARIABLE */) {
       const tok = this.advance();
-      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+      return this.finishVariableReference(tok);
     }
     const aggFunc = this.tryAggregateFunc();
     if (aggFunc !== null) {
@@ -2699,7 +2879,7 @@ var Parser = class {
     }
     if (tok.kind === "VARIABLE" /* VARIABLE */) {
       this.advance();
-      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+      return this.finishVariableReference(tok);
     }
     if (tok.kind === "CASE" /* CASE */) {
       if (!allowCase) throw new ParseError("\u3053\u306E\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u3067\u306F CASE \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
@@ -2799,7 +2979,7 @@ var Parser = class {
     }
     if (this.allowSelectArithVariable && tok.kind === "VARIABLE" /* VARIABLE */) {
       this.advance();
-      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+      return this.finishVariableReference(tok);
     }
     if (tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */) {
       this.advance();
@@ -3121,6 +3301,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 +3347,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;
@@ -3400,7 +3587,7 @@ var Parser = class {
     }
     if (tok.kind === "VARIABLE" /* VARIABLE */) {
       this.advance();
-      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+      return this.finishVariableReference(tok);
     }
     throw new ParseError(
       "KLIKE / NOT KLIKE \u306E\u53F3\u8FBA\u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u307E\u305F\u306F\u30D0\u30C3\u30C1\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059",
@@ -3593,7 +3780,7 @@ var Parser = class {
     const tok = this.peek();
     if (tok.kind === "VARIABLE" /* VARIABLE */) {
       this.advance();
-      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+      return this.finishVariableReference(tok);
     }
     if (tok.kind === "STRING" /* STRING */) {
       this.advance();
@@ -3649,6 +3836,9 @@ var Parser = class {
       "VARIABLE" /* VARIABLE */,
       "IN / NOT IN \u306E\u5F8C\u306B\u306F (\u5024\u30EA\u30B9\u30C8\u307E\u305F\u306F SELECT) \u304B\u914D\u5217\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059"
     );
+    if (this.peek().kind === "(" /* LPAREN */ && this.capabilities.dialect1) {
+      return { type: "IN_LIST", values: [this.finishVariableReference(variable)] };
+    }
     return { type: "VARIABLE_IN_LIST", name: variable.value.slice(1).toLowerCase() };
   }
   parseInListOrSubquery() {
@@ -3680,7 +3870,7 @@ var Parser = class {
         const sign = tok.kind === "-" /* MINUS */ ? "-" : "+";
         values.push(makeNumberLiteral(`${sign}${number.value}`));
       } else if (tok.kind === "VARIABLE" /* VARIABLE */) {
-        values.push({ type: "VARIABLE", name: tok.value.slice(1).toLowerCase() });
+        values.push(this.finishVariableReference(tok));
       } else if (tok.kind === "LOGINUSER" /* LOGINUSER */) {
         if (values.length > 0) {
           throw new ParseError(mixedLoginUserMessage, tok);
@@ -4061,6 +4251,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 +4272,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 +5320,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 +8690,7 @@ function validateStatement(stmt) {
     case "SET_VARIABLE":
     case "DECLARE_VARIABLE":
     case "ASSERT":
+    case "EXIT":
       validateNestedSelects(stmt);
       return;
     case "UPDATE":
@@ -8961,6 +9393,7 @@ function collectVariableRefs(node, refs, inWhere = false) {
     const obj = node;
     const type = obj["type"];
     if ((type === "VARIABLE" || type === "VARIABLE_COL" || type === "VARIABLE_IN_LIST") && typeof obj["name"] === "string") {
+      if (asOfFunctionNameFromVariable(obj["name"]) !== null) return;
       refs.push({
         name: obj["name"],
         kind: type === "VARIABLE" ? "scalar" : type === "VARIABLE_COL" ? "select-column" : "array-in-list",
@@ -16134,6 +16567,234 @@ 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",
+  DIALECT1_REQUIRED: "KSQL1203",
+  UPDATE_KEY_COMPOSITE: "KSQL1301",
+  UPDATE_KEY_FIELD_TYPE: "KSQL1302",
+  UPDATE_KEY_NOT_UNIQUE: "KSQL1303",
+  SUBTABLE_DML_FORBIDDEN: "KSQL1304",
+  BARE_INSERT_NOT_IDEMPOTENT: "KSQL1305",
+  SERVER_TIME_FUNCTION_NOT_AS_OF: "KSQL1306"
+};
+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/sql.ts
+function parseSqlStatements(sql, capabilities = {}) {
+  const tokens = new Lexer(sql).tokenize();
+  const statements = new Parser(tokens, capabilities).parseStatements();
+  statements.forEach(validateStatementStatic);
+  return statements;
+}
+function parseSqlStatementsForScript(sql, capabilities = {}) {
+  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 scriptSql = header.hasDirectives ? sql.slice(header.headerEnd) : sql;
+  const scriptCapabilities = header.hasDirectives ? { ...capabilities, dialect1: header.meta.dialect === 1 } : capabilities;
+  return {
+    statements: parseSqlStatements(scriptSql, scriptCapabilities),
+    meta: header.meta
+  };
+}
+
+// src/core/dialect1Validation.ts
+var DIALECT1_SERVER_TIME_FUNCTION_WARNING = "bare \u306E\u6642\u523B\u4F9D\u5B58\u95A2\u6570\u306F kintone \u30B5\u30FC\u30D0\u30FC\u8A55\u4FA1\u306E\u305F\u3081 as-of \u306E\u5BFE\u8C61\u5916\u3067\u3059\u3002\u518D\u73FE\u6027\u304C\u5FC5\u8981\u306A\u3089 @ \u4ED8\u304D\u95A2\u6570\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
+function validateDialect1UpdateKey(statement, fieldInfos) {
+  if (fieldInfos === void 0) {
+    return statement.keyFields.length === 1 ? [] : [{
+      code: DiagnosticCodes.UPDATE_KEY_COMPOSITE,
+      severity: "error",
+      message: "dialect 1 \u306E UPSERT / MERGE \u306E\u30AD\u30FC\u306F\u5358\u4E00\u30D5\u30A3\u30FC\u30EB\u30C9\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u8907\u5408\u30AD\u30FC\u306E\u4EE3\u308F\u308A\u306B\u3001\u9023\u7D50\u30AD\u30FC\u30D5\u30A3\u30FC\u30EB\u30C9\uFF08\u4F8B: \u9867\u5BA2\u30B3\u30FC\u30C9_\u5E74\u6708\uFF09\u3092\u30A2\u30D7\u30EA\u5074\u306B\u7528\u610F\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    }];
+  }
+  if (statement.keyFields.length !== 1) return [];
+  const key = statement.keyFields[0];
+  const field = fieldInfos.find((candidate) => candidate.code === key);
+  const issues = [];
+  if (field === void 0 || field.fieldType !== "SINGLE_LINE_TEXT" && field.fieldType !== "NUMBER") {
+    issues.push({
+      code: DiagnosticCodes.UPDATE_KEY_FIELD_TYPE,
+      severity: "error",
+      message: field === void 0 ? `UPSERT / MERGE \u306E\u30AD\u30FC\u300C${key}\u300D\u304C APP${statement.appId} \u306E\u30D5\u30A9\u30FC\u30E0\u306B\u5B58\u5728\u3057\u307E\u305B\u3093\u3002\u91CD\u8907\u7981\u6B62\u3092\u8A2D\u5B9A\u3057\u305F\u6587\u5B57\u5217\uFF081\u884C\uFF09\u307E\u305F\u306F\u6570\u5024\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u30AD\u30FC\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002` : `UPSERT / MERGE \u306E\u30AD\u30FC\u300C${key}\u300D\u306E\u578B ${field.fieldType} \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u91CD\u8907\u7981\u6B62\u3092\u8A2D\u5B9A\u3057\u305F\u6587\u5B57\u5217\uFF081\u884C\uFF09\u307E\u305F\u306F\u6570\u5024\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u30AD\u30FC\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    });
+  }
+  if (field?.isUnique === false) {
+    issues.push({
+      code: DiagnosticCodes.UPDATE_KEY_NOT_UNIQUE,
+      severity: "error",
+      message: `UPSERT / MERGE \u306E\u30AD\u30FC\u300C${key}\u300D\u306F\u91CD\u8907\u7981\u6B62\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u30A2\u30D7\u30EA\u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u8A2D\u5B9A\u3067\u300C\u5024\u306E\u91CD\u8907\u3092\u7981\u6B62\u3059\u308B\u300D\u3092\u6709\u52B9\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    });
+  } else if (field !== void 0 && field.isUnique === void 0) {
+    issues.push({
+      code: DiagnosticCodes.UPDATE_KEY_NOT_UNIQUE,
+      severity: "warning",
+      message: `UPSERT / MERGE \u306E\u30AD\u30FC\u300C${key}\u300D\u306E\u91CD\u8907\u7981\u6B62\u8A2D\u5B9A\u3092 schema resolver \u304B\u3089\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\u3002isUnique \u3092\u8FD4\u3059 resolver \u3092\u4F7F\u7528\u3057\u3001\u30A2\u30D7\u30EA\u5074\u3067\u300C\u5024\u306E\u91CD\u8907\u3092\u7981\u6B62\u3059\u308B\u300D\u304C\u6709\u52B9\u304B\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    });
+  }
+  return issues;
+}
+function statementHasBareServerTimeFunctionInWhere(statement) {
+  let found = false;
+  const visit = (node) => {
+    if (found || node === null || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    const value = node;
+    const where = value["where"];
+    if (where !== null && typeof where === "object") {
+      const names = serverOnlyFunctionOccurrencesInWhere(where);
+      if (names.some((name) => name === "TODAY" || name === "NOW" || isRelativeDateFunctionName(name))) {
+        found = true;
+        return;
+      }
+    }
+    Object.values(value).forEach(visit);
+  };
+  visit(statement);
+  return found;
+}
+
 // src/core/dmlPrevalidation.ts
 function collectDmlPrevalidationSnapshotFields(fieldIndex) {
   return [
@@ -18155,6 +18816,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 = [
@@ -18421,8 +19084,10 @@ var BatchTimeoutError = class extends Error {
   }
 };
 async function executeBatch(sql, client, options = {}) {
+  const asOfClock = createAsOfClock(options.asOf ?? /* @__PURE__ */ new Date(), options.timezone);
   resolveRecursiveCteLimits(options);
-  const statements = parseSqlBatch(sql, options.enableImport === true);
+  const { statements, meta } = parseSqlStatementsForScript(sql, { import: options.enableImport === true });
+  const dialect1Warnings = meta.dialect === 1 && statements.some(statementHasBareServerTimeFunctionInWhere) ? [DIALECT1_SERVER_TIME_FUNCTION_WARNING] : [];
   const analysis = analyzeBatch(statements);
   statements.forEach((statement) => assertApplyExecutionScope("phase15b", statement));
   if (options.allowApplyMutation !== true && statements.some(
@@ -18456,6 +19121,9 @@ async function executeBatch(sql, client, options = {}) {
   try {
     const tempTables = /* @__PURE__ */ new Map();
     const variables = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(asOfClock.values)) {
+      variables.set(asOfVariableName(name), { type: "string", value });
+    }
     const results = [];
     const failed = /* @__PURE__ */ new Set();
     let aborted = null;
@@ -18464,7 +19132,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));
@@ -18502,24 +19170,33 @@ 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),
+          dialect: meta.dialect
+        };
         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);
+          if (dialect1Warnings.length > 0 && statementHasBareServerTimeFunctionInWhere(statements[i]) && outcome.result.type === "SELECT") {
+            outcome.result = mergeSelectWarnings(outcome.result, dialect1Warnings);
+          }
         }
-        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,
@@ -18541,11 +19218,12 @@ 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,
-      metrics
+      metrics,
+      ...dialect1Warnings.length > 0 ? { warnings: dialect1Warnings } : {}
     };
   } finally {
     releaseMetadataCacheScope(cacheContext);
@@ -18557,8 +19235,19 @@ 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) {
-  options = bindStatementEvaluationContext(options);
+async function executeBatchStatement(context) {
+  const {
+    stmt,
+    info,
+    client,
+    options,
+    cacheContext,
+    tempTables,
+    variables,
+    relativeDateVariables,
+    clock,
+    dialect
+  } = context;
   if (stmt.type === "SET_VARIABLE") {
     const resolvedStmt2 = resolveBatchVariableReferences(stmt, variables);
     validateStatementStatic(resolvedStmt2);
@@ -18598,7 +19287,7 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
         throw e;
       }
     } else {
-      variables.set(stmt.name, evaluateScalarExpr(resolvedStmt2.expr, statementEvaluationContext(options)));
+      variables.set(stmt.name, evaluateScalarExpr(resolvedStmt2.expr, clock));
     }
     return {};
   }
@@ -18616,7 +19305,7 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     } else {
       const value = evaluateScalarExpr(
         stmt.default,
-        statementEvaluationContext(options)
+        clock
       );
       variables.set(stmt.name, {
         type: "string",
@@ -18629,6 +19318,18 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
   assertApplyScope("phase15b", resolvedStmt);
   assertApplyExecutionScope("phase15b", resolvedStmt);
   validateStatementStatic(resolvedStmt);
+  if (dialect === 1 && (resolvedStmt.type === "INSERT" || resolvedStmt.type === "UPDATE" || resolvedStmt.type === "DELETE") && resolvedStmt.subtableCode) {
+    throw new Error(
+      "ArgumentError: dialect 1 \u3067\u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u4EEE\u60F3\u30C6\u30FC\u30D6\u30EB\u3078\u306E DML \u306F\u3067\u304D\u307E\u305B\u3093\u3002SELECT \u306F\u53EF\u80FD\u3067\u3059\u3002\u89AA\u30A2\u30D7\u30EA\u3092\u5BFE\u8C61\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+  }
+  if (dialect === 1 && (resolvedStmt.type === "UPSERT" || resolvedStmt.type === "UPSERT_SELECT")) {
+    const staticIssue = validateDialect1UpdateKey(resolvedStmt)[0];
+    if (staticIssue) throw new Error(`ArgumentError: ${staticIssue.message}`);
+    const fieldInfos = await getFieldsCached(resolvedStmt.appId, client, cacheContext);
+    const schemaIssue = validateDialect1UpdateKey(resolvedStmt, fieldInfos)[0];
+    if (schemaIssue) throw new Error(`ArgumentError: ${schemaIssue.message}`);
+  }
   await assertRelativeDateExecutionPlan(resolvedStmt, client, cacheContext);
   if (resolvedStmt.type === "VALIDATE") {
     const result = await executeExistingRecordValidationCore(
@@ -18713,8 +19414,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") {
@@ -18838,9 +19543,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 {
@@ -18885,6 +19590,8 @@ function evaluateScalarExpr(expr, evaluationContext = {}) {
       }
       return { type: "number", value, raw: String(value) };
     }
+    case "VARIABLE":
+      throw new Error(`InternalError: unresolved variable @${expr.name} reached scalar evaluation.`);
   }
 }
 function resolveBatchVariableReferences(node, variables) {
@@ -18920,7 +19627,7 @@ function resolveBatchVariableReferencesInternal(node, variables, numericArithmet
         raw: numericArithmeticOperand === "AGG_ARITH" ? `@${obj["name"]}` : value.raw ?? String(value.value)
       } : { type: "STRING", value: value.value, fromVariable: true };
     }
-    if (obj["type"] === "VARIABLE_COL" && typeof obj["name"] === "string" && typeof obj["alias"] === "string") {
+    if (obj["type"] === "VARIABLE_COL" && typeof obj["name"] === "string" && (typeof obj["alias"] === "string" || obj["alias"] === null)) {
       const value = variables.get(obj["name"]);
       if (value === void 0) throw new Error(`ParseError: variable @${obj["name"]} is not defined in this batch.`);
       if (value.type === "array") throw new Error(`ParseError: array variable @${obj["name"]} cannot be used as a SELECT column.`);
@@ -19026,6 +19733,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") {
@@ -19034,19 +19766,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) {
@@ -26380,7 +27109,7 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
   });
   const invocationCacheContext = createInvocationCacheContext(cacheContext);
   try {
-    const statements = parseSqlBatch(sql, enableImport);
+    const { statements, meta } = parseSqlStatementsForScript(sql, { import: enableImport });
     const analysis = analyzeBatch(statements);
     const normalizedInjectedVariables = validateDeclaredBatchVariables(statements, injectedVariables);
     const relativeDateVariables = prepareRelativeDateVariables(statements, normalizedInjectedVariables);
@@ -26461,10 +27190,16 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
         ), cursorMaxActive)
       ];
       const metadataPlan = explainMetadataLines(whereAnalysis);
+      const dialect1Estimate = meta.dialect === 1 ? buildDialect1ApiEstimateLines(
+        planStmt,
+        analysis.statements[i],
+        maxRecords,
+        dmlMaxRows
+      ) : [];
       plans.push({
         index: i,
         type: analysis.statements[i].statementType,
-        plan: statementPlan.length === 0 ? metadataPlan : [statementPlan[0], ...metadataPlan, ...statementPlan.slice(1)]
+        plan: statementPlan.length === 0 ? [...metadataPlan, ...dialect1Estimate] : [statementPlan[0], ...metadataPlan, ...statementPlan.slice(1), ...dialect1Estimate]
       });
       fetchStatements.push({
         index: i,
@@ -26489,6 +27224,63 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
     releaseMetadataCacheScope(invocationCacheContext);
   }
 }
+function buildDialect1ApiEstimateLines(statement, analysis, maxRecords, dmlMaxRows) {
+  const lines = ["  estimated API consumption (dialect 1):"];
+  const sources = collectPhysicalExplainSources(statement);
+  if ((statement.type === "UPDATE" || statement.type === "DELETE") && !sources.includes(`APP${statement.appId}`)) {
+    sources.unshift(`APP${statement.appId}`);
+  }
+  const maxReadRequests = Math.ceil(maxRecords / 500);
+  for (const source of sources) {
+    lines.push(
+      `    read ${source}: \u4E0D\u660E\uFF08\u4E0A\u9650 maxRecords=${maxRecords} \u3068\u4EEE\u5B9A: \u6700\u5927 ${maxReadRequests} \u56DE\u3001500 \u4EF6/\u56DE\uFF09`
+    );
+  }
+  const metadataApps = [.../* @__PURE__ */ new Set([
+    ...analysis.appIds,
+    ...analysis.targetAppId === null ? [] : [analysis.targetAppId]
+  ])];
+  lines.push(
+    `    metadata: GET form fields \xD7 ${metadataApps.length} \u30A2\u30D7\u30EA\uFF08\u30AD\u30E3\u30C3\u30B7\u30E5\u6E08\u307F\u306F\u8FFD\u52A0 0 \u56DE\uFF09`
+  );
+  if (statement.type === "UPSERT" || statement.type === "UPSERT_SELECT") {
+    if (statement.type === "UPSERT") {
+      lines.push(
+        `    UPSERT pre-read: ${Math.ceil(statement.values.length / UPSERT_IN_CHUNK_SIZE)} \u56DE\uFF08${statement.values.length} \u884C\u3001${UPSERT_IN_CHUNK_SIZE} \u30AD\u30FC/\u56DE\uFF09`
+      );
+    } else {
+      lines.push(
+        `    UPSERT pre-read: \u4E0D\u660E\uFF08\u4E0A\u9650 dmlMaxRows=${dmlMaxRows} \u3068\u4EEE\u5B9A: \u6700\u5927 ${Math.ceil(dmlMaxRows / UPSERT_IN_CHUNK_SIZE)} \u56DE\u3001${UPSERT_IN_CHUNK_SIZE} \u30AD\u30FC/\u56DE\uFF09`
+      );
+    }
+  }
+  const knownRows = statement.type === "INSERT" || statement.type === "UPSERT" ? statement.values.length : null;
+  if (statement.type === "INSERT" || statement.type === "INSERT_SELECT" || statement.type === "UPSERT" || statement.type === "UPSERT_SELECT" || statement.type === "UPDATE" || statement.type === "DELETE") {
+    lines.push(knownRows === null ? `    write: \u4E0D\u660E\uFF08\u4E0A\u9650 dmlMaxRows=${dmlMaxRows} \u3068\u4EEE\u5B9A: \u6700\u5927 ${Math.ceil(dmlMaxRows / 100)} \u56DE\u3001100 \u4EF6/HTTP \u30EA\u30AF\u30A8\u30B9\u30C8\uFF09` : `    write: ${Math.ceil(knownRows / 100)} \u56DE\uFF08${knownRows} \u884C\u3001100 \u4EF6/HTTP \u30EA\u30AF\u30A8\u30B9\u30C8\uFF09`);
+    lines.push("    reference: bulkRequest \u306F\u672A\u5B9F\u88C5\u3002\u66F8\u8FBC\u30B5\u30D6\u30EA\u30AF\u30A8\u30B9\u30C8\u6570\u306F HTTP \u66F8\u8FBC\u56DE\u6570\u3068\u540C\u3058");
+  }
+  return lines;
+}
+function collectPhysicalExplainSources(statement) {
+  const sources = [];
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const value = node;
+    if (typeof value["appId"] === "number" && Object.prototype.hasOwnProperty.call(value, "alias") && Object.prototype.hasOwnProperty.call(value, "cteName") && value["cteName"] === null && value["appId"] > 0) {
+      const app = `APP${value["appId"]}`;
+      const subtable = typeof value["subtableCode"] === "string" ? `$${value["subtableCode"]}` : "";
+      const alias = typeof value["alias"] === "string" && value["alias"] !== app ? ` AS ${value["alias"]}` : "";
+      sources.push(`${app}${subtable}${alias}`);
+    }
+    Object.values(value).forEach(visit);
+  };
+  visit(statement);
+  return sources;
+}
 function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGroupByPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, collector = { sources: [] }, tempSchemaLedger = /* @__PURE__ */ new Map(), createdSchema, explainContext = defaultRecursiveExplainContext()) {
   if (stmt.type === "CREATE_TEMP_TABLE") {
     return [
@@ -26575,8 +27367,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"
@@ -26598,6 +27390,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,
@@ -27943,20 +28760,6 @@ var OperationCancelledError = class extends Error {
   }
 };
 
-// src/core/sql.ts
-function parseSqlStatement(sql, capabilities = {}) {
-  const tokens = new Lexer(sql).tokenize();
-  const stmt = new Parser(tokens, capabilities).parse();
-  validateStatementStatic(stmt);
-  return stmt;
-}
-function parseSqlStatements(sql, capabilities = {}) {
-  const tokens = new Lexer(sql).tokenize();
-  const statements = new Parser(tokens, capabilities).parseStatements();
-  statements.forEach(validateStatementStatic);
-  return statements;
-}
-
 // src/core/displayFormat.ts
 var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var DATETIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
@@ -28085,6 +28888,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 = {}) {
@@ -28142,6 +28948,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));
     }
@@ -29662,7 +30472,7 @@ function toParseInput(sql) {
 }
 function tryParseStatements(sql) {
   try {
-    const stmts = new Parser(new Lexer(toParseInput(sql)).tokenize()).parseStatements();
+    const { statements: stmts } = parseSqlStatementsForScript(toParseInput(sql));
     return {
       kind: "ok",
       count: stmts.length,
@@ -29677,7 +30487,11 @@ function tryParseStatements(sql) {
     if (e instanceof ParseError) {
       return { kind: "fail", continuable: e.token.kind === "EOF" /* EOF */, message: e.message };
     }
-    throw e;
+    return {
+      kind: "fail",
+      continuable: false,
+      message: e instanceof Error ? e.message : String(e)
+    };
   }
 }
 
@@ -30866,7 +31680,7 @@ async function confirmDmlInConsole(sql, opts, queue, defaultProfile = "dev", res
   if (!opts.allowDml || opts.yes || opts.dryRun) return true;
   try {
     const normalized = normalizeSqlAppProfiles(sql, defaultProfile, resolutionContext);
-    const statements = parseSqlStatements(normalized.normalizedSql);
+    const { statements } = parseSqlStatementsForScript(normalized.normalizedSql);
     if (statements.length > 1) {
       const analysis = analyzeBatch(statements);
       if (!analysis.containsDml) return true;
@@ -31316,7 +32130,7 @@ async function run() {
     }
     const importEnabled = Object.keys(args.importCsv).length > 0 || Object.keys(args.importJson).length > 0;
     try {
-      const statements = parseSqlStatements(sql, { import: importEnabled });
+      const { statements } = parseSqlStatementsForScript(sql, { import: importEnabled });
       parsedStatements = statements;
       const hasApply = (statement) => statement.type === "UPDATE" || statement.type === "INSERT" ? (statement.applyBlocks?.length ?? 0) > 0 : statement.type === "UPSERT" ? (statement.onInsertApplyBlocks?.length ?? 0) > 0 || (statement.onUpdateApplyBlocks?.length ?? 0) > 0 : false;
       containsApplyStatement = statements.some(hasApply);
@@ -31337,7 +32151,7 @@ async function run() {
         isBatchSql = true;
         batchContainsDml = batchAnalysis.containsDml;
       } else {
-        const stmt = parseSqlStatement(sql, { import: importEnabled });
+        const stmt = statements[0];
         parsedStmt = stmt;
         stmtType = getStatementType(stmt);
         isDmlStatement = writesKintone(stmt);