@rex0220/kintone-sql-tools 2.7.0 → 2.9.0

package/dist-cli/ksql.js

@@ -94,6 +94,7 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["IS", "IS" /* IS */],
   ["NULL", "NULL" /* NULL */],
   ["LIKE", "LIKE" /* LIKE */],
+  ["KLIKE", "KLIKE" /* KLIKE */],
   ["IN", "IN" /* IN */],
   ["BETWEEN", "BETWEEN" /* BETWEEN */],
   ["TODAY", "TODAY" /* TODAY */],
@@ -1619,7 +1620,7 @@ var Parser = class {
     }
     return false;
   }
-  // 比較演算子: =, !=, <>, >, <, >=, <=, LIKE, IN, IS NULL
+  // 比較演算子: =, !=, <>, >, <, >=, <=, LIKE, KLIKE, IN, IS NULL
   parseCompareExpr() {
     if (this.peek().kind === "(" /* LPAREN */ && !this.isArithParen()) {
       this.advance();
@@ -1655,8 +1656,12 @@ var Parser = class {
         const pattern = this.parseSqlValue();
         return { type: "BINARY", op: "NOT_LIKE", left: field, right: pattern };
       }
+      if (this.consume("KLIKE" /* KLIKE */)) {
+        const pattern = this.parseKlikePattern();
+        return { type: "BINARY", op: "NOT_KLIKE", left: field, right: pattern };
+      }
       throw new ParseError(
-        "NOT \u306E\u5F8C\u306B\u306F IN \u307E\u305F\u306F LIKE \u304C\u5FC5\u8981\u3067\u3059",
+        "NOT \u306E\u5F8C\u306B\u306F IN\u3001LIKE\u3001KLIKE \u306E\u3044\u305A\u308C\u304B\u304C\u5FC5\u8981\u3067\u3059",
         this.peek()
       );
     }
@@ -1666,6 +1671,10 @@ var Parser = class {
       this.expect(")" /* RPAREN */);
       return { type: "BINARY", op: "IN", left: field, right: right2 };
     }
+    if (this.consume("KLIKE" /* KLIKE */)) {
+      const pattern = this.parseKlikePattern();
+      return { type: "BINARY", op: "KLIKE", left: field, right: pattern };
+    }
     const op = this.parseCompareOp();
     const right = this.parseSqlValue();
     return { type: "BINARY", op, left: field, right };
@@ -1691,11 +1700,27 @@ var Parser = class {
         return "LIKE";
       default:
         throw new ParseError(
-          "\u6BD4\u8F03\u6F14\u7B97\u5B50\uFF08=, !=, >, <, >=, <=, LIKE, IN, IS\uFF09\u304C\u5FC5\u8981\u3067\u3059",
+          "\u6BD4\u8F03\u6F14\u7B97\u5B50\uFF08=, !=, >, <, >=, <=, LIKE, KLIKE, IN, IS\uFF09\u304C\u5FC5\u8981\u3067\u3059",
           tok
         );
     }
   }
+  /** KLIKE / NOT KLIKE の右辺。kintone キーワードは文字列値だけを受け付ける。 */
+  parseKlikePattern() {
+    const tok = this.peek();
+    if (tok.kind === "STRING" /* STRING */) {
+      this.advance();
+      return { type: "STRING", value: tok.value };
+    }
+    if (tok.kind === "VARIABLE" /* VARIABLE */) {
+      this.advance();
+      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+    }
+    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",
+      tok
+    );
+  }
   // WHERE / HAVING の左辺
   // - 文字列・数値関数: UPPER(f) / LENGTH(f) / ROUND(f, 2) ...
   // - 集計関数（HAVING のみ）: COUNT(*) / SUM(f) ...
@@ -2346,238 +2371,6 @@ function collectDmlTargetFields(stmt) {
   return [];
 }
 
-// src/core/batch.ts
-var MAX_TEMP_TABLES = 16;
-var MAX_BATCH_VARIABLES = 64;
-var BatchAnalysisError = class extends Error {
-  constructor(message, statementIndex) {
-    super(message);
-    this.statementIndex = statementIndex;
-  }
-};
-function collectRefs(node, tempRefs, appIds) {
-  if (Array.isArray(node)) {
-    for (const v of node) collectRefs(v, tempRefs, appIds);
-    return;
-  }
-  if (node !== null && typeof node === "object") {
-    const obj = node;
-    const cte = obj["cteName"];
-    if (typeof cte === "string" && cte.startsWith("#")) tempRefs.add(cte);
-    const appId = obj["appId"];
-    if (typeof appId === "number" && appId > 0) appIds.add(appId);
-    for (const v of Object.values(obj)) collectRefs(v, tempRefs, appIds);
-  }
-}
-function collectVariableRefs(node, refs) {
-  if (Array.isArray(node)) {
-    for (const v of node) collectVariableRefs(v, refs);
-    return;
-  }
-  if (node !== null && typeof node === "object") {
-    const obj = node;
-    if (obj["type"] === "VARIABLE" && typeof obj["name"] === "string") {
-      refs.add(obj["name"]);
-      return;
-    }
-    for (const v of Object.values(obj)) collectVariableRefs(v, refs);
-  }
-}
-function analyzeBatch(statements) {
-  if (statements.length === 0) {
-    throw new BatchAnalysisError("ArgumentError: SQL is empty.", 0);
-  }
-  if (statements.length === 1) {
-    const t = statements[0].type;
-    if (t === "SET_VARIABLE" || t === "DECLARE_VARIABLE") {
-      const verb = t === "SET_VARIABLE" ? "SET" : "DECLARE";
-      throw new BatchAnalysisError(`ArgumentError: ${verb} variable requires a batch.`, 0);
-    }
-    if (t === "CREATE_TEMP_TABLE" || t === "DROP_TEMP_TABLE") {
-      const verb = t === "CREATE_TEMP_TABLE" ? "CREATE TEMP TABLE" : "DROP TEMP TABLE";
-      throw new BatchAnalysisError(
-        `ArgumentError: ${verb} requires a batch (temp tables are batch-scoped).`,
-        0
-      );
-    }
-  }
-  const defined = /* @__PURE__ */ new Map();
-  const createdOrder = [];
-  const results = [];
-  const variableDefs = /* @__PURE__ */ new Map();
-  const variableOrder = [];
-  statements.forEach((stmt, index) => {
-    const statementType = getStatementType(stmt);
-    const created = [];
-    const dropped = [];
-    const refs = /* @__PURE__ */ new Set();
-    const stmtAppIds = /* @__PURE__ */ new Set();
-    const dependsOn = /* @__PURE__ */ new Set();
-    const variableRefs = /* @__PURE__ */ new Set();
-    collectVariableRefs(stmt, variableRefs);
-    for (const name of variableRefs) {
-      const def = variableDefs.get(name);
-      if (def === void 0) {
-        throw new BatchAnalysisError(
-          `ParseError: variable @${name} is not defined before statement ${index + 1}.`,
-          index
-        );
-      }
-      def.referencedBy.push(index);
-    }
-    if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
-      if (variableDefs.has(stmt.name)) {
-        throw new BatchAnalysisError(`ParseError: variable @${stmt.name} is already defined.`, index);
-      }
-      variableDefs.set(stmt.name, { index, referencedBy: [] });
-      variableOrder.push(stmt.name);
-      if (variableOrder.length > MAX_BATCH_VARIABLES) {
-        throw new BatchAnalysisError(
-          `ParseError: batch exceeds ${MAX_BATCH_VARIABLES} variables.`,
-          index
-        );
-      }
-    }
-    if (stmt.type === "CREATE_TEMP_TABLE") {
-      collectRefs(stmt.query, refs, stmtAppIds);
-    } else if (stmt.type === "DROP_TEMP_TABLE") {
-    } else {
-      collectRefs(stmt, refs, stmtAppIds);
-    }
-    let tempOnlySource = false;
-    if (stmt.type === "INSERT_SELECT" || stmt.type === "UPSERT_SELECT") {
-      const srcTemp = /* @__PURE__ */ new Set();
-      const srcApps = /* @__PURE__ */ new Set();
-      collectRefs(stmt.select, srcTemp, srcApps);
-      tempOnlySource = srcTemp.size > 0 && srcApps.size === 0;
-    }
-    for (const name of refs) {
-      const at = defined.get(name);
-      if (at === void 0) {
-        throw new BatchAnalysisError(
-          `ParseError: temp table ${name} is not defined in this batch.`,
-          index
-        );
-      }
-      dependsOn.add(at);
-    }
-    if (stmt.type === "CREATE_TEMP_TABLE") {
-      if (defined.has(stmt.name)) {
-        throw new BatchAnalysisError(
-          `ParseError: temp table ${stmt.name} is already defined.`,
-          index
-        );
-      }
-      defined.set(stmt.name, index);
-      createdOrder.push(stmt.name);
-      created.push(stmt.name);
-      if (defined.size > MAX_TEMP_TABLES) {
-        throw new BatchAnalysisError(
-          `ParseError: batch exceeds ${MAX_TEMP_TABLES} temp tables.`,
-          index
-        );
-      }
-    }
-    if (stmt.type === "DROP_TEMP_TABLE") {
-      const at = defined.get(stmt.name);
-      if (at === void 0) {
-        throw new BatchAnalysisError(
-          `ParseError: temp table ${stmt.name} is not defined in this batch.`,
-          index
-        );
-      }
-      dependsOn.add(at);
-      dropped.push(stmt.name);
-      defined.delete(stmt.name);
-    }
-    results.push({
-      index,
-      statementType,
-      isDml: isDmlType(statementType),
-      isReadOnly: isReadOnlyType(statementType),
-      hasWhere: hasWhereClause(stmt),
-      insertValuesCount: getInsertValuesCount(stmt),
-      appIds: [...stmtAppIds].sort((a, b) => a - b),
-      tempTablesCreated: created,
-      tempTablesReferenced: [...refs],
-      tempTablesDropped: dropped,
-      dependsOn: [...dependsOn].sort((a, b) => a - b),
-      tempOnlySource,
-      targetAppId: isDmlType(statementType) && typeof stmt.appId === "number" ? stmt.appId : null
-    });
-  });
-  const containsDml = results.some((r) => r.isDml);
-  const variables = variableOrder.map((name) => ({
-    name,
-    referencedBy: [...variableDefs.get(name).referencedBy]
-  }));
-  return {
-    statementCount: statements.length,
-    isReadOnlyBatch: !containsDml && results.every((r) => r.isReadOnly),
-    containsDml,
-    tempTables: createdOrder,
-    variables,
-    warnings: variables.filter((v) => v.referencedBy.length === 0).map((v) => `variable @${v.name} is never used.`),
-    statements: results
-  };
-}
-
-// src/core/batchVariables.ts
-var VARIABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
-function normalizeBatchVariableName(name) {
-  if (!VARIABLE_NAME_RE.test(name)) {
-    throw new Error(
-      `ArgumentError: invalid variable name "${name}". Use a name without @ matching [A-Za-z_][A-Za-z0-9_]{0,63}.`
-    );
-  }
-  return name.toLowerCase();
-}
-function normalizeBatchVariables(input) {
-  const normalized = /* @__PURE__ */ Object.create(null);
-  for (const [rawName, value] of Object.entries(input ?? {})) {
-    const name = normalizeBatchVariableName(rawName);
-    if (Object.prototype.hasOwnProperty.call(normalized, name)) {
-      throw new Error(`ArgumentError: variable "${rawName}" is specified more than once.`);
-    }
-    normalized[name] = value;
-  }
-  return normalized;
-}
-function validateDeclaredBatchVariables(statements, input) {
-  const normalized = normalizeBatchVariables(input);
-  const declared = new Set(
-    statements.filter((stmt) => stmt.type === "DECLARE_VARIABLE").map((stmt) => stmt.name)
-  );
-  for (const name of Object.keys(normalized)) {
-    if (!declared.has(name)) {
-      throw new Error(`ArgumentError: injected variable @${name} is not declared.`);
-    }
-  }
-  return normalized;
-}
-
-// src/core/scalarCompare.ts
-function compareScalarValues(op, leftStr, rightStr) {
-  if (op === "=") return leftStr === rightStr;
-  if (op === "!=" || op === "<>") return leftStr !== rightStr;
-  const rightNum = Number(rightStr);
-  if (leftStr === "" && rightStr !== "" && Number.isFinite(rightNum)) {
-    return op === "<" || op === "<=";
-  }
-  const leftNum = Number(leftStr);
-  const numeric = !Number.isNaN(leftNum) && !Number.isNaN(rightNum);
-  switch (op) {
-    case ">":
-      return numeric ? leftNum > rightNum : leftStr > rightStr;
-    case "<":
-      return numeric ? leftNum < rightNum : leftStr < rightStr;
-    case ">=":
-      return numeric ? leftNum >= rightNum : leftStr >= rightStr;
-    case "<=":
-      return numeric ? leftNum <= rightNum : leftStr <= rightStr;
-  }
-}
-
 // src/engine/pushDownNot.ts
 function pushDownNot(expr) {
   switch (expr.type) {
@@ -2627,6 +2420,10 @@ function negateOp(op) {
       return "NOT_LIKE";
     case "NOT_LIKE":
       return "LIKE";
+    case "KLIKE":
+      return "NOT_KLIKE";
+    case "NOT_KLIKE":
+      return "KLIKE";
     case "IN":
       return "NOT_IN";
     case "NOT_IN":
@@ -2641,6 +2438,9 @@ function likePatternHasWildcard(pattern) {
 function isLike(where) {
   return where.type === "BINARY" && (where.op === "LIKE" || where.op === "NOT_LIKE");
 }
+function isKlike(where) {
+  return where.type === "BINARY" && (where.op === "KLIKE" || where.op === "NOT_KLIKE");
+}
 function whereHasLike(where) {
   if (where === null) return false;
   if (isLike(where)) return true;
@@ -2656,14 +2456,29 @@ function whereHasLike(where) {
       return false;
   }
 }
-
-// src/converter/whereToKintone.ts
-function whereToKintone(expr) {
-  switch (expr.type) {
-    case "BINARY":
-      return convertBinary(expr);
-    case "NULL_CHECK":
-      return convertNullCheck(expr);
+function whereHasKlike(where) {
+  if (where === null) return false;
+  if (isKlike(where)) return true;
+  switch (where.type) {
+    case "LOGICAL":
+      return whereHasKlike(where.left) || whereHasKlike(where.right);
+    case "NOT":
+    case "GROUP":
+      return whereHasKlike(where.expr);
+    case "BINARY":
+    case "NULL_CHECK":
+    case "EXISTS":
+      return false;
+  }
+}
+
+// src/converter/whereToKintone.ts
+function whereToKintone(expr) {
+  switch (expr.type) {
+    case "BINARY":
+      return convertBinary(expr);
+    case "NULL_CHECK":
+      return convertNullCheck(expr);
     case "LOGICAL":
       return convertLogical(expr);
     case "NOT":
@@ -2704,6 +2519,10 @@ function convertOp(op) {
       return "like";
     case "NOT_LIKE":
       return "not like";
+    case "KLIKE":
+      return "like";
+    case "NOT_KLIKE":
+      return "not like";
     case "IN":
       return "in";
     case "NOT_IN":
@@ -3229,72 +3048,713 @@ function collectRequiredFieldsByTable(stmt) {
     addFieldRef(join2.on.left.field, join2.on.left.tableAlias, "where");
     addFieldRef(join2.on.right.field, join2.on.right.tableAlias, "where");
   }
-  walkWhere(stmt.where, "where");
-  for (const gk of stmt.groupBy) walkGroupByKey(gk);
-  walkWhere(stmt.having, "having");
-  for (const ob of stmt.orderBy) walkOrderByKey(ob.key);
-  return states;
+  walkWhere(stmt.where, "where");
+  for (const gk of stmt.groupBy) walkGroupByKey(gk);
+  walkWhere(stmt.having, "having");
+  for (const ob of stmt.orderBy) walkOrderByKey(ob.key);
+  return states;
+}
+function collectSelectOutputNames(columns) {
+  const names = /* @__PURE__ */ new Set();
+  for (const col of columns) {
+    if (col.type === "FIELD" && col.alias) {
+      names.add(col.alias);
+      continue;
+    }
+    if (col.type === "LITERAL_COL") {
+      names.add(col.alias ?? `'${col.value}'`);
+      continue;
+    }
+    if (col.type === "AGGREGATE") {
+      if (col.alias) names.add(col.alias);
+      else names.add(aggregateSyntheticName(col.func, col.distinct, col.arg));
+      continue;
+    }
+    if (col.type === "ARITH_AGG_COL") {
+      if (col.alias) names.add(col.alias);
+      continue;
+    }
+    if (col.type === "ARITH_COL") {
+      if (col.alias) names.add(col.alias);
+      continue;
+    }
+    if (col.type === "CASE_COL") {
+      names.add(col.alias ?? "case");
+      continue;
+    }
+    if (col.type === "STRFUNC_COL") {
+      if (col.alias) names.add(col.alias);
+      continue;
+    }
+    if (col.type === "SCALAR_SUBQUERY_COL") {
+      names.add(col.alias ?? "(subquery)");
+    }
+  }
+  return names;
+}
+function aggregateSyntheticName(func, distinct, arg) {
+  const argStr = arg.type === "WILDCARD" ? "*" : arithNodeLabel(arg);
+  return distinct ? `${func}(DISTINCT ${argStr})` : `${func}(${argStr})`;
+}
+function arithNodeLabel(node) {
+  if (node.type === "FIELD_REF") return node.field;
+  if (node.type === "NUMBER") return String(node.value);
+  if (node.type === "STRING_FUNC") return stringFuncLabel(node);
+  return `(${arithNodeLabel(node.left)}${node.op}${arithNodeLabel(node.right)})`;
+}
+function stringFuncLabel(expr) {
+  const args = expr.args.map((a) => {
+    if (a.type === "STRING") return `'${a.value}'`;
+    if (a.type === "STRING_FUNC") return stringFuncLabel(a);
+    if (a.type === "AGG_REF") return aggregateSyntheticName(a.func, a.distinct, a.arg);
+    if (a.type === "AGG_ARITH") return "agg_arith";
+    return arithNodeLabel(a);
+  });
+  return `${expr.func}(${args.join(",")})`;
+}
+function isAggregateSyntheticName(name) {
+  return /^(COUNT|SUM|AVG|MAX|MIN)\(/i.test(name);
+}
+
+// src/core/cteInlining.ts
+function canInlineSingleCte(stmt) {
+  if (stmt.ctes.length !== 1) return false;
+  const cteDef = stmt.ctes[0];
+  if (cteDef.query.type !== "SELECT" || resolveSelectMode(cteDef.query) !== "SIMPLE") return false;
+  const finalQuery = stmt.query;
+  if (finalQuery.type !== "SELECT") return false;
+  if (finalQuery.from.cteName !== cteDef.name || finalQuery.joins.length > 0) return false;
+  if (finalQuery.groupBy.length > 0 || finalQuery.distinct) return false;
+  return !finalQuery.columns.some(
+    (column) => column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL"
+  );
+}
+function buildInlinedQuery(stmt) {
+  const cteBody = stmt.ctes[0].query;
+  const final = stmt.query;
+  const finalWhere = stripCteAlias(final.where, final.from.alias);
+  const where = cteBody.where === null ? finalWhere : finalWhere === null ? cteBody.where : { type: "LOGICAL", op: "AND", left: cteBody.where, right: finalWhere };
+  const columns = final.columns.every((column) => column.type === "WILDCARD") ? cteBody.columns : final.columns;
+  return {
+    type: "SELECT",
+    from: cteBody.from,
+    joins: [],
+    columns,
+    where,
+    groupBy: [],
+    having: null,
+    orderBy: final.orderBy.length > 0 ? final.orderBy : cteBody.orderBy,
+    limit: final.limit ?? cteBody.limit,
+    offset: final.offset ?? cteBody.offset,
+    distinct: false
+  };
+}
+function stripCteAlias(where, alias) {
+  if (where === null || alias === null) return where;
+  switch (where.type) {
+    case "BINARY":
+      return { ...where, left: stripCteAliasFromFieldValue(where.left, alias) };
+    case "NULL_CHECK":
+      return { ...where, field: stripCteAliasFromFieldValue(where.field, alias) };
+    case "LOGICAL":
+      return {
+        ...where,
+        left: stripCteAlias(where.left, alias),
+        right: stripCteAlias(where.right, alias)
+      };
+    case "NOT":
+    case "GROUP":
+      return { ...where, expr: stripCteAlias(where.expr, alias) };
+    case "EXISTS":
+      return where;
+  }
+}
+function stripCteAliasFromFieldValue(value, alias) {
+  if (value.type === "FIELD" && value.tableAlias === alias) {
+    return { ...value, tableAlias: null };
+  }
+  return value;
+}
+
+// src/core/optimization/wherePredicatePushdown.ts
+function extractSafePushdownLeaves(where, options = {}) {
+  return extractAndLeaves(where, (expr) => isSafeComparison(expr, options));
+}
+function extractTypedPushdownCandidates(where, options = {}) {
+  return extractAndLeaves(
+    where,
+    (expr) => isNumericCandidate(expr, options) || isSelectionInCandidate(expr, options)
+  );
+}
+function extractAndLeaves(where, accept) {
+  switch (where.type) {
+    case "BINARY":
+      return accept(where) ? where : null;
+    case "LOGICAL":
+      if (where.op !== "AND") return null;
+      {
+        const left = extractAndLeaves(where.left, accept);
+        const right = extractAndLeaves(where.right, accept);
+        if (left && right) return { ...where, left, right };
+        return left ?? right ?? null;
+      }
+    case "GROUP":
+      return extractAndLeaves(where.expr, accept);
+    case "NULL_CHECK":
+    case "NOT":
+    case "EXISTS":
+      return null;
+  }
+}
+function isSafeComparison(expr, options) {
+  if (isKlikeComparison(expr, options)) return true;
+  if (isSafeIdComparison(expr, options)) return true;
+  if (isNumericCandidate(expr, options)) {
+    return options.fieldTypes?.get(expr.left.field) === "NUMBER";
+  }
+  return isSelectionInComparison(expr, options);
+}
+function isKlikeComparison(expr, options) {
+  if (options.allowKlike === false) return false;
+  if (expr.op !== "KLIKE" && expr.op !== "NOT_KLIKE") return false;
+  if (expr.left.type !== "FIELD" || !isTargetField(expr.left, options)) return false;
+  return expr.right.type === "STRING" || options.allowUnresolvedKlikeVariables === true && expr.right.type === "VARIABLE";
+}
+var SELECTION_IN_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "DROP_DOWN",
+  "RADIO_BUTTON",
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "STATUS"
+]);
+function isSelectionInComparison(expr, options) {
+  if (!isSelectionInCandidate(expr, options)) return false;
+  if (expr.left.type !== "FIELD" || expr.right.type !== "IN_LIST") return false;
+  const fieldType = options.fieldTypes?.get(expr.left.field);
+  if (fieldType === void 0 || !SELECTION_IN_FIELD_TYPES.has(fieldType)) return false;
+  const validOptions = options.fieldOptions?.get(expr.left.field);
+  if (validOptions === void 0) return false;
+  return expr.right.values.every(
+    (value) => value.type === "STRING" && value.value !== "" && validOptions.has(value.value)
+  );
+}
+function isSafeIdComparison(expr, options) {
+  if (!isTargetIdField(expr.left, options)) return false;
+  if (expr.right.type !== "NUMBER") return false;
+  return expr.op === "=" || expr.op === ">" || expr.op === "<" || expr.op === ">=" || expr.op === "<=";
+}
+function isTargetIdField(field, options) {
+  if (field.type !== "FIELD" || field.field !== "$id") return false;
+  const targetAlias = options.tableAlias ?? null;
+  if (field.tableAlias === targetAlias) return true;
+  return options.allowUnqualifiedFields === true && field.tableAlias === null;
+}
+function isNumericCandidate(expr, options) {
+  if (expr.left.type !== "FIELD" || expr.left.field === "$id") return false;
+  if (!isTargetField(expr.left, options)) return false;
+  if (expr.right.type !== "NUMBER") return false;
+  if (expr.op === "=") return true;
+  return (expr.op === "<" || expr.op === ">") && Number.isSafeInteger(expr.right.value);
+}
+function isSelectionInCandidate(expr, options) {
+  if (expr.left.type !== "FIELD" || expr.left.field === "$id") return false;
+  if (!isTargetField(expr.left, options)) return false;
+  if (expr.op !== "IN" && expr.op !== "NOT_IN") return false;
+  if (expr.right.type !== "IN_LIST" || expr.right.values.length === 0) return false;
+  return expr.right.values.every((value) => value.type === "STRING" && value.value !== "");
+}
+function isTargetField(field, options) {
+  const targetAlias = options.tableAlias ?? null;
+  if (field.tableAlias === targetAlias) return true;
+  return options.allowUnqualifiedFields === true && field.tableAlias === null;
+}
+
+// src/core/optimization/klikePushdownPlan.ts
+function buildKlikePushdownPlan(stmt, options = {}) {
+  const joinsAreSafeForKlike = stmt.joins.every((join2) => join2.type === "INNER");
+  const common = {
+    allowKlike: joinsAreSafeForKlike,
+    allowUnresolvedKlikeVariables: options.allowUnresolvedVariables
+  };
+  let mainCondition = null;
+  if (stmt.where !== null && !stmt.from.subtableCode && stmt.from.cteName === null) {
+    if (stmt.joins.length === 0) {
+      mainCondition = extractSafePushdownLeaves(stmt.where, {
+        ...common,
+        tableAlias: stmt.from.alias ?? void 0,
+        allowUnqualifiedFields: true,
+        fieldTypes: options.fieldTypesByApp?.get(stmt.from.appId),
+        fieldOptions: options.fieldOptionsByApp?.get(stmt.from.appId)
+      });
+    } else if (stmt.from.alias) {
+      mainCondition = extractSafePushdownLeaves(stmt.where, {
+        ...common,
+        tableAlias: stmt.from.alias,
+        fieldTypes: options.fieldTypesByApp?.get(stmt.from.appId),
+        fieldOptions: options.fieldOptionsByApp?.get(stmt.from.appId)
+      });
+    }
+  }
+  const joinConditions = /* @__PURE__ */ new Map();
+  if (stmt.where !== null) {
+    for (const join2 of stmt.joins) {
+      if (!join2.table.alias || join2.table.subtableCode || join2.table.cteName !== null) continue;
+      const condition = extractSafePushdownLeaves(stmt.where, {
+        ...common,
+        tableAlias: join2.table.alias,
+        fieldTypes: options.fieldTypesByApp?.get(join2.table.appId),
+        fieldOptions: options.fieldOptionsByApp?.get(join2.table.appId)
+      });
+      if (condition !== null) joinConditions.set(join2.table.alias, condition);
+    }
+  }
+  const appliedKlikes = /* @__PURE__ */ new Set();
+  collectKlikes(mainCondition, appliedKlikes);
+  for (const condition of joinConditions.values()) collectKlikes(condition, appliedKlikes);
+  const allKlikes = /* @__PURE__ */ new Set();
+  collectKlikes(stmt.where, allKlikes);
+  return {
+    mainCondition,
+    joinConditions,
+    appliedKlikes,
+    allKlikes: [...allKlikes]
+  };
+}
+function unappliedKlikes(plan) {
+  return plan.allKlikes.filter((expr) => !plan.appliedKlikes.has(expr));
+}
+function collectKlikes(where, out) {
+  if (where === null) return;
+  if (isKlike(where)) {
+    out.add(where);
+    return;
+  }
+  switch (where.type) {
+    case "LOGICAL":
+      collectKlikes(where.left, out);
+      collectKlikes(where.right, out);
+      return;
+    case "NOT":
+    case "GROUP":
+      collectKlikes(where.expr, out);
+      return;
+    case "BINARY":
+    case "NULL_CHECK":
+    case "EXISTS":
+      return;
+  }
+}
+
+// src/core/klikeValidation.ts
+var KlikeValidationError = class extends Error {
+  constructor(message) {
+    super(`ArgumentError: ${message}`);
+    this.name = "ArgumentError";
+  }
+};
+function validateKlikeStatement(stmt) {
+  validateStatement(stmt);
+}
+function validateKlikePushdownPlan(plan) {
+  if (unappliedKlikes(plan).length > 0) {
+    throw new KlikeValidationError(
+      "FULL_SCAN \u306E KLIKE / NOT KLIKE \u3092\u5B89\u5168\u306B\u62BC\u3057\u4E0B\u3052\u3089\u308C\u307E\u305B\u3093\u3002OR / NOT \u914D\u4E0B\u3001CTE\u30FB\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u3001LEFT / RIGHT JOIN \u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044"
+    );
+  }
+}
+function validateStatement(stmt) {
+  switch (stmt.type) {
+    case "SELECT":
+      validateSelect(stmt);
+      return;
+    case "UNION":
+      validateUnion(stmt);
+      return;
+    case "WITH":
+      validateWith(stmt);
+      return;
+    case "EXPLAIN":
+      validateStatement(stmt.query);
+      return;
+    case "CREATE_TEMP_TABLE":
+      validateSelectLike(stmt.query);
+      return;
+    case "SET_VARIABLE":
+    case "DECLARE_VARIABLE":
+    case "ASSERT":
+      validateNestedSelects(stmt);
+      return;
+    case "INSERT":
+    case "INSERT_SELECT":
+    case "UPSERT":
+    case "UPSERT_SELECT":
+    case "UPDATE":
+    case "DELETE":
+    case "REORDER":
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError(
+          "KLIKE / NOT KLIKE \u306F\u5168 DML\uFF08UPDATE / DELETE / INSERT / UPSERT / REORDER\uFF09\u3067\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+        );
+      }
+      return;
+    case "SHOW_APPS":
+    case "DESCRIBE":
+    case "DROP_TEMP_TABLE":
+      return;
+  }
+}
+function validateSelectLike(query) {
+  if (query.type === "SELECT") validateSelect(query);
+  else if (query.type === "UNION") validateUnion(query);
+  else validateWith(query);
+}
+function validateUnion(stmt) {
+  validateSelectLike(stmt.left);
+  validateSelect(stmt.right);
+}
+function validateWith(stmt) {
+  if (canInlineSingleCte(stmt)) {
+    validateSelect(buildInlinedQuery(stmt));
+    return;
+  }
+  for (const cte of stmt.ctes) {
+    if (cte.query.type === "SELECT") validateSelect(cte.query);
+    else if (cte.query.type === "UNION") validateUnion(cte.query);
+  }
+  validateSelectLike(stmt.query);
+}
+function validateSelect(stmt) {
+  validateOwnKlikeExpressions(stmt);
+  if (whereHasKlike(stmt.where)) {
+    const directKintoneSimple = resolveSelectMode(stmt) === "SIMPLE" && stmt.from.cteName === null && stmt.joins.every((join2) => join2.table.cteName === null);
+    if (!directKintoneSimple) {
+      const plan = buildKlikePushdownPlan(stmt, { allowUnresolvedVariables: true });
+      if (unappliedKlikes(plan).length === 0) {
+        validateNestedSelects(stmt);
+        return;
+      }
+      throw new KlikeValidationError(
+        "FULL_SCAN \u306E KLIKE / NOT KLIKE \u306F\u3001\u7269\u7406\u30C6\u30FC\u30D6\u30EB\u306B\u5BFE\u3059\u308B AND \u30EA\u30FC\u30D5\u3068\u3057\u3066\u5FC5\u305A\u62BC\u3057\u4E0B\u3052\u3089\u308C\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002OR / NOT \u914D\u4E0B\u3001CTE\u30FB\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u3001LEFT / RIGHT JOIN \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
+      );
+    }
+  }
+  validateNestedSelects(stmt);
+}
+function validateOwnKlikeExpressions(stmt) {
+  walkWithoutNestedSelects(stmt, (where) => {
+    if (!isKlike(where)) return;
+    if (!isDescendantOf(stmt.where, where)) {
+      throw new KlikeValidationError("KLIKE / NOT KLIKE \u306F SELECT \u306E WHERE \u53E5\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059");
+    }
+    const right = where.right;
+    if (right.type !== "STRING" && right.type !== "VARIABLE") {
+      throw new KlikeValidationError(
+        "KLIKE / NOT KLIKE \u306E\u53F3\u8FBA\u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u307E\u305F\u306F\u6587\u5B57\u5217\u30D0\u30C3\u30C1\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059"
+      );
+    }
+    if (right.type === "STRING" && right.value.includes("%")) {
+      throw new KlikeValidationError(
+        "KLIKE / NOT KLIKE \u306E\u691C\u7D22\u8A9E\u306B % \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002SQL \u30EF\u30A4\u30EB\u30C9\u30AB\u30FC\u30C9\u691C\u7D22\u306B\u306F LIKE \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044"
+      );
+    }
+  });
+}
+function validateNestedSelects(node) {
+  walkObjects(node, (obj) => {
+    if (obj.type === "SELECT") validateSelect(obj);
+  }, true);
+}
+function containsKlike(node) {
+  let found = false;
+  walkObjects(node, (obj) => {
+    if (obj.type === "BINARY" && (obj.op === "KLIKE" || obj.op === "NOT_KLIKE")) found = true;
+  });
+  return found;
+}
+function isDescendantOf(root, target) {
+  if (root === null) return false;
+  if (root === target) return true;
+  switch (root.type) {
+    case "LOGICAL":
+      return isDescendantOf(root.left, target) || isDescendantOf(root.right, target);
+    case "NOT":
+    case "GROUP":
+      return isDescendantOf(root.expr, target);
+    case "BINARY":
+    case "NULL_CHECK":
+    case "EXISTS":
+      return false;
+  }
+}
+function walkWithoutNestedSelects(node, visitWhere) {
+  if (Array.isArray(node)) {
+    for (const value of node) walkWithoutNestedSelects(value, visitWhere);
+    return;
+  }
+  if (node === null || typeof node !== "object") return;
+  const obj = node;
+  if (obj.type === "BINARY" || obj.type === "NULL_CHECK" || obj.type === "LOGICAL" || obj.type === "NOT" || obj.type === "GROUP" || obj.type === "EXISTS") {
+    visitWhere(obj);
+  }
+  for (const value of Object.values(obj)) {
+    if (value !== node && isSelectObject(value)) continue;
+    walkWithoutNestedSelects(value, visitWhere);
+  }
+}
+function walkObjects(node, visit, skipRoot = false) {
+  if (Array.isArray(node)) {
+    for (const value of node) walkObjects(value, visit);
+    return;
+  }
+  if (node === null || typeof node !== "object") return;
+  const obj = node;
+  if (!skipRoot) visit(obj);
+  for (const value of Object.values(obj)) walkObjects(value, visit);
+}
+function isSelectObject(value) {
+  return value !== null && typeof value === "object" && value.type === "SELECT";
+}
+
+// src/core/batch.ts
+var MAX_TEMP_TABLES = 16;
+var MAX_BATCH_VARIABLES = 64;
+var BatchAnalysisError = class extends Error {
+  constructor(message, statementIndex) {
+    super(message);
+    this.statementIndex = statementIndex;
+  }
+};
+function collectRefs(node, tempRefs, appIds) {
+  if (Array.isArray(node)) {
+    for (const v of node) collectRefs(v, tempRefs, appIds);
+    return;
+  }
+  if (node !== null && typeof node === "object") {
+    const obj = node;
+    const cte = obj["cteName"];
+    if (typeof cte === "string" && cte.startsWith("#")) tempRefs.add(cte);
+    const appId = obj["appId"];
+    if (typeof appId === "number" && appId > 0) appIds.add(appId);
+    for (const v of Object.values(obj)) collectRefs(v, tempRefs, appIds);
+  }
+}
+function collectVariableRefs(node, refs) {
+  if (Array.isArray(node)) {
+    for (const v of node) collectVariableRefs(v, refs);
+    return;
+  }
+  if (node !== null && typeof node === "object") {
+    const obj = node;
+    if (obj["type"] === "VARIABLE" && typeof obj["name"] === "string") {
+      refs.add(obj["name"]);
+      return;
+    }
+    for (const v of Object.values(obj)) collectVariableRefs(v, refs);
+  }
+}
+function analyzeBatch(statements) {
+  if (statements.length === 0) {
+    throw new BatchAnalysisError("ArgumentError: SQL is empty.", 0);
+  }
+  statements.forEach((stmt, index) => {
+    try {
+      validateKlikeStatement(stmt);
+    } catch (error) {
+      if (error instanceof KlikeValidationError) {
+        throw new BatchAnalysisError(error.message, index);
+      }
+      throw error;
+    }
+  });
+  if (statements.length === 1) {
+    const t = statements[0].type;
+    if (t === "SET_VARIABLE" || t === "DECLARE_VARIABLE") {
+      const verb = t === "SET_VARIABLE" ? "SET" : "DECLARE";
+      throw new BatchAnalysisError(`ArgumentError: ${verb} variable requires a batch.`, 0);
+    }
+    if (t === "CREATE_TEMP_TABLE" || t === "DROP_TEMP_TABLE") {
+      const verb = t === "CREATE_TEMP_TABLE" ? "CREATE TEMP TABLE" : "DROP TEMP TABLE";
+      throw new BatchAnalysisError(
+        `ArgumentError: ${verb} requires a batch (temp tables are batch-scoped).`,
+        0
+      );
+    }
+  }
+  const defined = /* @__PURE__ */ new Map();
+  const createdOrder = [];
+  const results = [];
+  const variableDefs = /* @__PURE__ */ new Map();
+  const variableOrder = [];
+  statements.forEach((stmt, index) => {
+    const statementType = getStatementType(stmt);
+    const created = [];
+    const dropped = [];
+    const refs = /* @__PURE__ */ new Set();
+    const stmtAppIds = /* @__PURE__ */ new Set();
+    const dependsOn = /* @__PURE__ */ new Set();
+    const variableRefs = /* @__PURE__ */ new Set();
+    collectVariableRefs(stmt, variableRefs);
+    for (const name of variableRefs) {
+      const def = variableDefs.get(name);
+      if (def === void 0) {
+        throw new BatchAnalysisError(
+          `ParseError: variable @${name} is not defined before statement ${index + 1}.`,
+          index
+        );
+      }
+      def.referencedBy.push(index);
+    }
+    if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
+      if (variableDefs.has(stmt.name)) {
+        throw new BatchAnalysisError(`ParseError: variable @${stmt.name} is already defined.`, index);
+      }
+      variableDefs.set(stmt.name, { index, referencedBy: [] });
+      variableOrder.push(stmt.name);
+      if (variableOrder.length > MAX_BATCH_VARIABLES) {
+        throw new BatchAnalysisError(
+          `ParseError: batch exceeds ${MAX_BATCH_VARIABLES} variables.`,
+          index
+        );
+      }
+    }
+    if (stmt.type === "CREATE_TEMP_TABLE") {
+      collectRefs(stmt.query, refs, stmtAppIds);
+    } else if (stmt.type === "DROP_TEMP_TABLE") {
+    } else {
+      collectRefs(stmt, refs, stmtAppIds);
+    }
+    let tempOnlySource = false;
+    if (stmt.type === "INSERT_SELECT" || stmt.type === "UPSERT_SELECT") {
+      const srcTemp = /* @__PURE__ */ new Set();
+      const srcApps = /* @__PURE__ */ new Set();
+      collectRefs(stmt.select, srcTemp, srcApps);
+      tempOnlySource = srcTemp.size > 0 && srcApps.size === 0;
+    }
+    for (const name of refs) {
+      const at = defined.get(name);
+      if (at === void 0) {
+        throw new BatchAnalysisError(
+          `ParseError: temp table ${name} is not defined in this batch.`,
+          index
+        );
+      }
+      dependsOn.add(at);
+    }
+    if (stmt.type === "CREATE_TEMP_TABLE") {
+      if (defined.has(stmt.name)) {
+        throw new BatchAnalysisError(
+          `ParseError: temp table ${stmt.name} is already defined.`,
+          index
+        );
+      }
+      defined.set(stmt.name, index);
+      createdOrder.push(stmt.name);
+      created.push(stmt.name);
+      if (defined.size > MAX_TEMP_TABLES) {
+        throw new BatchAnalysisError(
+          `ParseError: batch exceeds ${MAX_TEMP_TABLES} temp tables.`,
+          index
+        );
+      }
+    }
+    if (stmt.type === "DROP_TEMP_TABLE") {
+      const at = defined.get(stmt.name);
+      if (at === void 0) {
+        throw new BatchAnalysisError(
+          `ParseError: temp table ${stmt.name} is not defined in this batch.`,
+          index
+        );
+      }
+      dependsOn.add(at);
+      dropped.push(stmt.name);
+      defined.delete(stmt.name);
+    }
+    results.push({
+      index,
+      statementType,
+      isDml: isDmlType(statementType),
+      isReadOnly: isReadOnlyType(statementType),
+      hasWhere: hasWhereClause(stmt),
+      insertValuesCount: getInsertValuesCount(stmt),
+      appIds: [...stmtAppIds].sort((a, b) => a - b),
+      tempTablesCreated: created,
+      tempTablesReferenced: [...refs],
+      tempTablesDropped: dropped,
+      dependsOn: [...dependsOn].sort((a, b) => a - b),
+      tempOnlySource,
+      targetAppId: isDmlType(statementType) && typeof stmt.appId === "number" ? stmt.appId : null
+    });
+  });
+  const containsDml = results.some((r) => r.isDml);
+  const variables = variableOrder.map((name) => ({
+    name,
+    referencedBy: [...variableDefs.get(name).referencedBy]
+  }));
+  return {
+    statementCount: statements.length,
+    isReadOnlyBatch: !containsDml && results.every((r) => r.isReadOnly),
+    containsDml,
+    tempTables: createdOrder,
+    variables,
+    warnings: variables.filter((v) => v.referencedBy.length === 0).map((v) => `variable @${v.name} is never used.`),
+    statements: results
+  };
+}
+
+// src/core/batchVariables.ts
+var VARIABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+function normalizeBatchVariableName(name) {
+  if (!VARIABLE_NAME_RE.test(name)) {
+    throw new Error(
+      `ArgumentError: invalid variable name "${name}". Use a name without @ matching [A-Za-z_][A-Za-z0-9_]{0,63}.`
+    );
+  }
+  return name.toLowerCase();
+}
+function normalizeBatchVariables(input) {
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [rawName, value] of Object.entries(input ?? {})) {
+    const name = normalizeBatchVariableName(rawName);
+    if (Object.prototype.hasOwnProperty.call(normalized, name)) {
+      throw new Error(`ArgumentError: variable "${rawName}" is specified more than once.`);
+    }
+    normalized[name] = value;
+  }
+  return normalized;
 }
-function collectSelectOutputNames(columns) {
-  const names = /* @__PURE__ */ new Set();
-  for (const col of columns) {
-    if (col.type === "FIELD" && col.alias) {
-      names.add(col.alias);
-      continue;
-    }
-    if (col.type === "LITERAL_COL") {
-      names.add(col.alias ?? `'${col.value}'`);
-      continue;
-    }
-    if (col.type === "AGGREGATE") {
-      if (col.alias) names.add(col.alias);
-      else names.add(aggregateSyntheticName(col.func, col.distinct, col.arg));
-      continue;
-    }
-    if (col.type === "ARITH_AGG_COL") {
-      if (col.alias) names.add(col.alias);
-      continue;
-    }
-    if (col.type === "ARITH_COL") {
-      if (col.alias) names.add(col.alias);
-      continue;
-    }
-    if (col.type === "CASE_COL") {
-      names.add(col.alias ?? "case");
-      continue;
-    }
-    if (col.type === "STRFUNC_COL") {
-      if (col.alias) names.add(col.alias);
-      continue;
-    }
-    if (col.type === "SCALAR_SUBQUERY_COL") {
-      names.add(col.alias ?? "(subquery)");
+function validateDeclaredBatchVariables(statements, input) {
+  const normalized = normalizeBatchVariables(input);
+  const declared = new Set(
+    statements.filter((stmt) => stmt.type === "DECLARE_VARIABLE").map((stmt) => stmt.name)
+  );
+  for (const name of Object.keys(normalized)) {
+    if (!declared.has(name)) {
+      throw new Error(`ArgumentError: injected variable @${name} is not declared.`);
     }
   }
-  return names;
-}
-function aggregateSyntheticName(func, distinct, arg) {
-  const argStr = arg.type === "WILDCARD" ? "*" : arithNodeLabel(arg);
-  return distinct ? `${func}(DISTINCT ${argStr})` : `${func}(${argStr})`;
-}
-function arithNodeLabel(node) {
-  if (node.type === "FIELD_REF") return node.field;
-  if (node.type === "NUMBER") return String(node.value);
-  if (node.type === "STRING_FUNC") return stringFuncLabel(node);
-  return `(${arithNodeLabel(node.left)}${node.op}${arithNodeLabel(node.right)})`;
-}
-function stringFuncLabel(expr) {
-  const args = expr.args.map((a) => {
-    if (a.type === "STRING") return `'${a.value}'`;
-    if (a.type === "STRING_FUNC") return stringFuncLabel(a);
-    if (a.type === "AGG_REF") return aggregateSyntheticName(a.func, a.distinct, a.arg);
-    if (a.type === "AGG_ARITH") return "agg_arith";
-    return arithNodeLabel(a);
-  });
-  return `${expr.func}(${args.join(",")})`;
+  return normalized;
 }
-function isAggregateSyntheticName(name) {
-  return /^(COUNT|SUM|AVG|MAX|MIN)\(/i.test(name);
+
+// src/core/scalarCompare.ts
+function compareScalarValues(op, leftStr, rightStr) {
+  if (op === "=") return leftStr === rightStr;
+  if (op === "!=" || op === "<>") return leftStr !== rightStr;
+  const rightNum = Number(rightStr);
+  if (leftStr === "" && rightStr !== "" && Number.isFinite(rightNum)) {
+    return op === "<" || op === "<=";
+  }
+  const leftNum = Number(leftStr);
+  const numeric = !Number.isNaN(leftNum) && !Number.isNaN(rightNum);
+  switch (op) {
+    case ">":
+      return numeric ? leftNum > rightNum : leftStr > rightStr;
+    case "<":
+      return numeric ? leftNum < rightNum : leftStr < rightStr;
+    case ">=":
+      return numeric ? leftNum >= rightNum : leftStr >= rightStr;
+    case "<=":
+      return numeric ? leftNum <= rightNum : leftStr <= rightStr;
+  }
 }
 
 // src/engine/evalFunc.ts
@@ -3508,25 +3968,29 @@ function resolveFieldRef(row, field) {
 }
 
 // src/engine/evalWhere.ts
-function evalWhere(expr, row, resolveFieldType) {
+function evalWhere(expr, row, resolveFieldType, appliedKlikes) {
   switch (expr.type) {
     case "BINARY":
-      return evalBinary(expr, row, resolveFieldType);
+      return evalBinary(expr, row, resolveFieldType, appliedKlikes);
     case "NULL_CHECK":
       return evalNullCheck(expr, row);
     case "LOGICAL":
-      return evalLogical(expr, row, resolveFieldType);
+      return evalLogical(expr, row, resolveFieldType, appliedKlikes);
     case "NOT":
-      return !evalWhere(expr.expr, row, resolveFieldType);
+      return !evalWhere(expr.expr, row, resolveFieldType, appliedKlikes);
     case "GROUP":
-      return evalWhere(expr.expr, row, resolveFieldType);
+      return evalWhere(expr.expr, row, resolveFieldType, appliedKlikes);
     case "EXISTS": {
       const exists = expr.resolved;
       return expr.not ? !exists : exists;
     }
   }
 }
-function evalBinary(expr, row, resolveFieldType) {
+function evalBinary(expr, row, resolveFieldType, appliedKlikes) {
+  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);
   const fieldType = expr.left.type === "FIELD" ? resolveFieldType?.(expr.left) : void 0;
   return evalOp(expr.op, left, expr.right, row, fieldType, resolveFieldType);
@@ -3553,6 +4017,9 @@ function evalOp(op, leftStr, right, row, fieldType, resolveFieldType) {
     const pattern = resolveValue(right, row, resolveFieldType);
     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);
   return compareScalarValues(op, leftStr, rightStr);
 }
@@ -3605,11 +4072,11 @@ function evalNullCheck(expr, row) {
   const val = resolveField(expr.field, row);
   return expr.not ? val !== "" : val === "";
 }
-function evalLogical(expr, row, resolveFieldType) {
+function evalLogical(expr, row, resolveFieldType, appliedKlikes) {
   if (expr.op === "AND") {
-    return evalWhere(expr.left, row, resolveFieldType) && evalWhere(expr.right, row, resolveFieldType);
+    return evalWhere(expr.left, row, resolveFieldType, appliedKlikes) && evalWhere(expr.right, row, resolveFieldType, appliedKlikes);
   }
-  return evalWhere(expr.left, row, resolveFieldType) || evalWhere(expr.right, row, resolveFieldType);
+  return evalWhere(expr.left, row, resolveFieldType, appliedKlikes) || evalWhere(expr.right, row, resolveFieldType, appliedKlikes);
 }
 function resolveField(field, row, resolveFieldType) {
   if (field.type === "FUNC_FIELD") return evalStringFunc(field.expr, row);
@@ -3708,6 +4175,11 @@ function matchLike(value, pattern) {
 
 // src/converter/dmlToKintone.ts
 function assertDmlWhereIsSafe(where) {
+  if (whereHasKlike(where)) {
+    throw new DmlConvertError(
+      "UPDATE / DELETE \u306E WHERE \u306B KLIKE / NOT KLIKE \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002kintone \u30AD\u30FC\u30EF\u30FC\u30C9\u691C\u7D22\u306E\u6253\u3061\u5207\u308A\u3092\u691C\u51FA\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u5168 DML \u3067\u5B89\u5168\u4E0A\u62D2\u5426\u3057\u3066\u3044\u307E\u3059\u3002"
+    );
+  }
   if (!whereHasLike(where)) return;
   throw new DmlConvertError(
     "UPDATE / DELETE \u306E WHERE \u306B LIKE / NOT LIKE \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002LIKE \u306F kSQL \u306E\u610F\u5473\u8AD6\u306B\u5F93\u3063\u3066 JS \u3067\u8A55\u4FA1\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u304C\u3001\u89AA\u30EC\u30B3\u30FC\u30C9 DML \u306B\u306F JS \u8A55\u4FA1\u7D4C\u8DEF\u304C\u306A\u3044\u305F\u3081\u3001\u5B89\u5168\u4E0A\u62D2\u5426\u3057\u307E\u3057\u305F\u3002SELECT \u3067\u5BFE\u8C61\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u3092\u78BA\u8A8D\u3057\u3001IN \u307E\u305F\u306F\u5B8C\u5168\u4E00\u81F4\u3067\u5BFE\u8C61\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
@@ -4195,92 +4667,6 @@ async function resolveDmlTargetIds(getRecords, app, query, options) {
   };
 }
 
-// src/core/optimization/wherePredicatePushdown.ts
-function extractSafePushdownLeaves(where, options = {}) {
-  return extractAndLeaves(where, (expr) => isSafeComparison(expr, options));
-}
-function extractTypedPushdownCandidates(where, options = {}) {
-  return extractAndLeaves(
-    where,
-    (expr) => isNumericCandidate(expr, options) || isSelectionInCandidate(expr, options)
-  );
-}
-function extractAndLeaves(where, accept) {
-  switch (where.type) {
-    case "BINARY":
-      return accept(where) ? where : null;
-    case "LOGICAL":
-      if (where.op !== "AND") return null;
-      {
-        const left = extractAndLeaves(where.left, accept);
-        const right = extractAndLeaves(where.right, accept);
-        if (left && right) return { ...where, left, right };
-        return left ?? right ?? null;
-      }
-    case "GROUP":
-      return extractAndLeaves(where.expr, accept);
-    case "NULL_CHECK":
-    case "NOT":
-    case "EXISTS":
-      return null;
-  }
-}
-function isSafeComparison(expr, options) {
-  if (isSafeIdComparison(expr, options)) return true;
-  if (isNumericCandidate(expr, options)) {
-    return options.fieldTypes?.get(expr.left.field) === "NUMBER";
-  }
-  return isSelectionInComparison(expr, options);
-}
-var SELECTION_IN_FIELD_TYPES = /* @__PURE__ */ new Set([
-  "DROP_DOWN",
-  "RADIO_BUTTON",
-  "CHECK_BOX",
-  "MULTI_SELECT",
-  "STATUS"
-]);
-function isSelectionInComparison(expr, options) {
-  if (!isSelectionInCandidate(expr, options)) return false;
-  if (expr.left.type !== "FIELD" || expr.right.type !== "IN_LIST") return false;
-  const fieldType = options.fieldTypes?.get(expr.left.field);
-  if (fieldType === void 0 || !SELECTION_IN_FIELD_TYPES.has(fieldType)) return false;
-  const validOptions = options.fieldOptions?.get(expr.left.field);
-  if (validOptions === void 0) return false;
-  return expr.right.values.every(
-    (value) => value.type === "STRING" && value.value !== "" && validOptions.has(value.value)
-  );
-}
-function isSafeIdComparison(expr, options) {
-  if (!isTargetIdField(expr.left, options)) return false;
-  if (expr.right.type !== "NUMBER") return false;
-  return expr.op === "=" || expr.op === ">" || expr.op === "<" || expr.op === ">=" || expr.op === "<=";
-}
-function isTargetIdField(field, options) {
-  if (field.type !== "FIELD" || field.field !== "$id") return false;
-  const targetAlias = options.tableAlias ?? null;
-  if (field.tableAlias === targetAlias) return true;
-  return options.allowUnqualifiedFields === true && field.tableAlias === null;
-}
-function isNumericCandidate(expr, options) {
-  if (expr.left.type !== "FIELD" || expr.left.field === "$id") return false;
-  if (!isTargetField(expr.left, options)) return false;
-  if (expr.right.type !== "NUMBER") return false;
-  if (expr.op === "=") return true;
-  return (expr.op === "<" || expr.op === ">") && Number.isSafeInteger(expr.right.value);
-}
-function isSelectionInCandidate(expr, options) {
-  if (expr.left.type !== "FIELD" || expr.left.field === "$id") return false;
-  if (!isTargetField(expr.left, options)) return false;
-  if (expr.op !== "IN" && expr.op !== "NOT_IN") return false;
-  if (expr.right.type !== "IN_LIST" || expr.right.values.length === 0) return false;
-  return expr.right.values.every((value) => value.type === "STRING" && value.value !== "");
-}
-function isTargetField(field, options) {
-  const targetAlias = options.tableAlias ?? null;
-  if (field.tableAlias === targetAlias) return true;
-  return options.allowUnqualifiedFields === true && field.tableAlias === null;
-}
-
 // src/engine/process.ts
 function flatten(record, alias) {
   const row = {};
@@ -4345,9 +4731,9 @@ function applyJoin(leftRows, rightRows, join2) {
   }
   return result;
 }
-function applyFilter(rows, where, resolveFieldType) {
+function applyFilter(rows, where, resolveFieldType, appliedKlikes) {
   if (where === null) return rows;
-  return rows.filter((row) => evalWhere(where, row, resolveFieldType));
+  return rows.filter((row) => evalWhere(where, row, resolveFieldType, appliedKlikes));
 }
 function hasAggregateColumns(columns) {
   return columns.some(
@@ -4804,7 +5190,8 @@ function runFullScan(input) {
     optionOrders,
     sortKinds,
     fieldTypeResolver,
-    havingFieldTypeResolver
+    havingFieldTypeResolver,
+    appliedKlikes
   } = input;
   let rows = [];
   const mainAlias = stmt.from.alias;
@@ -4816,7 +5203,7 @@ function runFullScan(input) {
     const rightRows = rightRecords.map((r) => flatten(r, rightAlias));
     rows = applyJoin(rows, rightRows, join2);
   }
-  rows = applyFilter(rows, stmt.where, fieldTypeResolver);
+  rows = applyFilter(rows, stmt.where, fieldTypeResolver, appliedKlikes);
   if (stmt.groupBy.length > 0 || hasAggregateColumns(stmt.columns)) {
     rows = applyGroupBy(rows, stmt.groupBy, stmt.columns);
   }
@@ -4937,6 +5324,7 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
   if (unresolved !== null) {
     throw new Error(`ParseError: variable @${unresolved} is not defined in a batch.`);
   }
+  validateKlikeStatement(stmt);
   switch (stmt.type) {
     case "SELECT":
       return executeSelect(stmt, client, options, cacheContext);
@@ -5073,6 +5461,7 @@ async function executeBatch(sql, client, options = {}) {
 async function executeBatchStatement(stmt, info, client, options, cacheContext, tempTables, variables) {
   if (stmt.type === "SET_VARIABLE") {
     const resolvedStmt2 = resolveVariableRefs(stmt, variables);
+    validateKlikeStatement(resolvedStmt2);
     if (resolvedStmt2.expr.type === "SCALAR_SUBQUERY") {
       try {
         const value = await evaluateScalarSubquery(
@@ -5105,6 +5494,7 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     return {};
   }
   const resolvedStmt = resolveVariableRefs(stmt, variables);
+  validateKlikeStatement(resolvedStmt);
   if (resolvedStmt.type === "CREATE_TEMP_TABLE") {
     const materializeOptions = {
       ...options,
@@ -5501,23 +5891,6 @@ async function validateSelectFieldCodes(stmt, mode, client, cacheContext) {
     }
   }
 }
-function extractMainSafePushdown(stmt, fieldTypes, fieldOptions) {
-  if (stmt.where === null || stmt.from.subtableCode || stmt.from.cteName !== null) return null;
-  if (stmt.joins.length === 0) {
-    return extractSafePushdownLeaves(stmt.where, {
-      tableAlias: stmt.from.alias ?? void 0,
-      allowUnqualifiedFields: true,
-      fieldTypes,
-      fieldOptions
-    });
-  }
-  if (!stmt.from.alias) return null;
-  return extractSafePushdownLeaves(stmt.where, {
-    tableAlias: stmt.from.alias,
-    fieldTypes,
-    fieldOptions
-  });
-}
 function extractMainTypedPushdownCandidate(stmt) {
   if (stmt.where === null || stmt.from.subtableCode || stmt.from.cteName !== null) return null;
   if (stmt.joins.length === 0) {
@@ -5699,23 +6072,10 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     loadTypedInFieldTypes(stmt, client, cacheContext)
   ]);
   const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
-  const mainPushDown = extractMainSafePushdown(
-    stmt,
-    pushdownMeta.fieldTypesByApp.get(stmt.from.appId),
-    pushdownMeta.fieldOptionsByApp.get(stmt.from.appId)
-  );
-  const tableConditions = /* @__PURE__ */ new Map();
-  if (stmt.where !== null) {
-    for (const join2 of stmt.joins) {
-      if (!join2.table.alias || join2.table.subtableCode || join2.table.cteName !== null) continue;
-      const cond = extractSafePushdownLeaves(stmt.where, {
-        tableAlias: join2.table.alias,
-        fieldTypes: pushdownMeta.fieldTypesByApp.get(join2.table.appId),
-        fieldOptions: pushdownMeta.fieldOptionsByApp.get(join2.table.appId)
-      });
-      if (cond) tableConditions.set(join2.table.alias, cond);
-    }
-  }
+  const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
+  validateKlikePushdownPlan(pushdownPlan);
+  const mainPushDown = pushdownPlan.mainCondition;
+  const tableConditions = pushdownPlan.joinConditions;
   const mainFetch = fetchTableRecordsForFullScan(
     stmt,
     stmt.from,
@@ -5796,7 +6156,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     optionOrders,
     sortKinds,
     fieldTypeResolver: fieldTypeResolvers.row,
-    havingFieldTypeResolver: fieldTypeResolvers.having
+    havingFieldTypeResolver: fieldTypeResolvers.having,
+    appliedKlikes: pushdownPlan.appliedKlikes
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -5845,83 +6206,6 @@ async function executeWith(stmt, client, options, cacheContext, seed) {
   }
   return executeQueryWithCte(stmt.query, client, options, cteCache, cacheContext);
 }
-function canInlineSingleCte(stmt) {
-  if (stmt.ctes.length !== 1) return false;
-  const cteDef = stmt.ctes[0];
-  if (cteDef.query.type !== "SELECT") return false;
-  if (resolveSelectMode(cteDef.query) !== "SIMPLE") return false;
-  const finalQuery = stmt.query;
-  if (finalQuery.type !== "SELECT") return false;
-  if (finalQuery.from.cteName !== cteDef.name) return false;
-  if (finalQuery.joins.length > 0) return false;
-  if (finalQuery.groupBy.length > 0) return false;
-  if (finalQuery.distinct) return false;
-  if (finalQuery.columns.some(
-    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL"
-  )) return false;
-  return true;
-}
-function buildInlinedQuery(stmt) {
-  const cteBody = stmt.ctes[0].query;
-  const final = stmt.query;
-  const cteAlias = final.from.alias;
-  const finalWhere = stripCteAlias(final.where, cteAlias);
-  let mergedWhere;
-  if (cteBody.where === null) mergedWhere = finalWhere;
-  else if (finalWhere === null) mergedWhere = cteBody.where;
-  else mergedWhere = { type: "LOGICAL", op: "AND", left: cteBody.where, right: finalWhere };
-  const columns = final.columns.every((c) => c.type === "WILDCARD") ? cteBody.columns : final.columns;
-  return {
-    type: "SELECT",
-    from: cteBody.from,
-    joins: [],
-    columns,
-    where: mergedWhere,
-    groupBy: [],
-    having: null,
-    orderBy: final.orderBy.length > 0 ? final.orderBy : cteBody.orderBy,
-    limit: final.limit ?? cteBody.limit,
-    offset: final.offset ?? cteBody.offset,
-    distinct: false
-  };
-}
-function stripCteAlias(where, alias) {
-  if (where === null || alias === null) return where;
-  switch (where.type) {
-    case "BINARY":
-      return {
-        type: "BINARY",
-        op: where.op,
-        left: stripCteAliasFromFieldValue(where.left, alias),
-        right: where.right
-      };
-    case "NULL_CHECK":
-      return {
-        type: "NULL_CHECK",
-        not: where.not,
-        field: stripCteAliasFromFieldValue(where.field, alias)
-      };
-    case "LOGICAL":
-      return {
-        type: "LOGICAL",
-        op: where.op,
-        left: stripCteAlias(where.left, alias),
-        right: stripCteAlias(where.right, alias)
-      };
-    case "NOT":
-      return { type: "NOT", expr: stripCteAlias(where.expr, alias) };
-    case "GROUP":
-      return { type: "GROUP", expr: stripCteAlias(where.expr, alias) };
-    case "EXISTS":
-      return where;
-  }
-}
-function stripCteAliasFromFieldValue(fv, alias) {
-  if (fv.type === "FIELD" && fv.tableAlias === alias) {
-    return { type: "FIELD", field: fv.field, tableAlias: null };
-  }
-  return fv;
-}
 async function executeQueryWithCte(query, client, options, cteCache, cacheContext) {
   if (query.type === "UNION") {
     const [leftResult, rightResult] = await Promise.all([
@@ -5956,8 +6240,13 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     resolveSubqueries(stmt.having, client, options, cacheContext, cteCache),
     resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache)
   ]);
-  const typedInFieldTypes = await loadTypedInFieldTypes(stmt, client, cacheContext);
+  const [pushdownMeta, typedInFieldTypes] = await Promise.all([
+    loadTypedPushdownMeta(stmt, client, cacheContext),
+    loadTypedInFieldTypes(stmt, client, cacheContext)
+  ]);
   const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
+  const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
+  validateKlikePushdownPlan(pushdownPlan);
   const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
   const orderByMetaPromise = buildOrderByMetaForSelect(stmt, client, cacheContext);
   scalarCachePromise.catch(() => {
@@ -5977,7 +6266,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
       parallel,
       true,
       options.onLimitReached ?? "error",
-      warnings
+      warnings,
+      pushdownPlan.mainCondition
     );
     tables.set(stmt.from.alias, mainRecords);
   }
@@ -5986,6 +6276,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
       const rows2 = cteCache.get(join2.table.cteName) ?? [];
       tables.set(join2.table.alias, rows2.map(processRowToKintoneRecord));
     } else {
+      const pushDownCond = join2.table.alias ? pushdownPlan.joinConditions.get(join2.table.alias) ?? null : null;
       const optimized = await tryFetchJoinRecordsBySourceKeys(
         stmt,
         join2,
@@ -5994,7 +6285,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
         maxRecords,
         parallel,
         options.onLimitReached ?? "error",
-        warnings
+        warnings,
+        pushDownCond
       );
       const joinRecords = optimized ?? await fetchTableRecordsForFullScan(
         stmt,
@@ -6004,7 +6296,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
         parallel,
         false,
         options.onLimitReached ?? "error",
-        warnings
+        warnings,
+        pushDownCond
       );
       tables.set(join2.table.alias, joinRecords);
     }
@@ -6019,7 +6312,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     optionOrders,
     sortKinds,
     fieldTypeResolver: fieldTypeResolvers.row,
-    havingFieldTypeResolver: fieldTypeResolvers.having
+    havingFieldTypeResolver: fieldTypeResolvers.having,
+    appliedKlikes: pushdownPlan.appliedKlikes
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -6973,7 +7267,9 @@ async function executeDescribe(stmt, client, cacheContext) {
 function parseSql(sql) {
   try {
     const tokens = new Lexer(sql).tokenize();
-    return new Parser(tokens).parse();
+    const stmt = new Parser(tokens).parse();
+    validateKlikeStatement(stmt);
+    return stmt;
   } catch (e) {
     if (e instanceof LexError || e instanceof ParseError) {
       throw e;
@@ -7084,6 +7380,7 @@ function buildBatchExplainPlans(sql, injectedVariables) {
     statementCount: statements.length,
     statements: statements.map((stmt, i) => {
       const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveVariableRefs(stmt.expr, variables) } : stmt : resolveVariableRefs(stmt, variables);
+      validateKlikeStatement(planStmt);
       const result = {
         index: i,
         type: analysis.statements[i].statementType,
@@ -7225,9 +7522,10 @@ function buildSelectPlan(stmt, label) {
     lines.push(`  kintone query: ${params.query || "(\u306A\u3057)"}`);
     lines.push(`  fields:        ${params.fields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : params.fields.join(", ")}`);
   } else {
+    const pushdownPlan = buildKlikePushdownPlan(stmt);
     const mainFields = selectToFetchAllFields(stmt, stmt.from);
     const mainAliasStr = stmt.from.alias ? ` AS ${stmt.from.alias}` : "";
-    const mainPushDown = extractMainSafePushdown(stmt);
+    const mainPushDown = pushdownPlan.mainCondition;
     const mainCandidate = extractMainTypedPushdownCandidate(stmt);
     const mainQ = mainPushDown !== null ? whereToKintone(mainPushDown) : "(\u5168\u4EF6\u53D6\u5F97)";
     lines.push(`  app:           APP${stmt.from.appId}${mainAliasStr} (${stmt.from.appId})`);
@@ -7240,7 +7538,7 @@ function buildSelectPlan(stmt, label) {
       const joinFields = selectToFetchAllFields(stmt, join2.table);
       const joinAliasStr = join2.table.alias ? ` AS ${join2.table.alias}` : "";
       const joinType = join2.type === "INNER" ? "JOIN" : `${join2.type} JOIN`;
-      const joinPushDown = join2.table.alias && !join2.table.subtableCode && join2.table.cteName === null && stmt.where ? extractSafePushdownLeaves(stmt.where, { tableAlias: join2.table.alias }) : null;
+      const joinPushDown = join2.table.alias ? pushdownPlan.joinConditions.get(join2.table.alias) ?? null : null;
       const joinCandidate = join2.table.alias && !join2.table.subtableCode && join2.table.cteName === null && stmt.where ? extractTypedPushdownCandidates(stmt.where, { tableAlias: join2.table.alias }) : null;
       const joinQ = joinPushDown !== null ? whereToKintone(joinPushDown) : "(\u5168\u4EF6\u53D6\u5F97)";
       lines.push(`  ${joinType}:        APP${join2.table.appId}${joinAliasStr} (${join2.table.appId})`);
@@ -7283,6 +7581,10 @@ function buildWithPlan(stmt) {
   if (stmt.query.type === "SELECT" || stmt.query.type === "UNION") {
     lines.push(...buildExplainPlan(stmt.query, "[main]"));
   }
+  if (canInlineSingleCte(stmt)) {
+    lines.push("");
+    lines.push(...buildSelectPlan(buildInlinedQuery(stmt), "[effective: inlined CTE]"));
+  }
   return lines;
 }
 function collectFullScanReasons(stmt) {
@@ -7517,11 +7819,15 @@ var OperationCancelledError = class extends Error {
 // src/core/sql.ts
 function parseSqlStatement(sql) {
   const tokens = new Lexer(sql).tokenize();
-  return new Parser(tokens).parse();
+  const stmt = new Parser(tokens).parse();
+  validateKlikeStatement(stmt);
+  return stmt;
 }
 function parseSqlStatements(sql) {
   const tokens = new Lexer(sql).tokenize();
-  return new Parser(tokens).parseStatements();
+  const statements = new Parser(tokens).parseStatements();
+  statements.forEach(validateKlikeStatement);
+  return statements;
 }
 
 // src/core/displayFormat.ts