@rex0220/kintone-sql-tools 3.10.0 → 3.12.0

package/README.md

@@ -71,6 +71,8 @@ npm run build:plugin
   - 一時テーブルで中間結果をサーバー内に保持し、AI のコンテキスト消費を抑えたい場合
   - validation / EXPLAIN で論理名から最終的な物理アプリ ID への解決を確認したい場合
 
+言語リファレンス・レシピは MCP resources（`ksql://language-reference` / `ksql://recipes`）に加えて、read-only ツール **`ksql_docs`** でも読めます。中継環境（リモート接続のプロキシ等）が resources を通さないクライアントでは、`ksql_docs` を引数なしで呼ぶと全章キーの索引が返るので、必要な章だけ `{"section":"language-reference/05-string-number-functions"}` の形で取得してください。
+
 注意:
 
 - `APP@profile` と `LAPP_<NAME>[@profile]` は Node.js runtime（CLI / MCP）の拡張です。plugin 側では非対応です。

package/dist-cli/ksql.js

@@ -577,6 +577,87 @@ function numberLiteralText(node) {
 
 // src/parser/parser.ts
 var MAX_BATCH_STATEMENTS = 20;
+var PARSER_SCALAR_FUNCTION_TOKEN_MAP = Object.freeze({
+  ["UPPER" /* UPPER */]: "UPPER",
+  ["LOWER" /* LOWER */]: "LOWER",
+  ["TRIM" /* TRIM */]: "TRIM",
+  ["LTRIM" /* LTRIM */]: "LTRIM",
+  ["RTRIM" /* RTRIM */]: "RTRIM",
+  ["LENGTH" /* LENGTH */]: "LENGTH",
+  ["LENGTH_CHAR" /* LENGTH_CHAR */]: "LENGTH_CHAR",
+  ["SUBSTRING" /* SUBSTRING */]: "SUBSTRING",
+  ["SUBSTR" /* SUBSTR */]: "SUBSTRING",
+  ["LEFT" /* LEFT */]: "LEFT",
+  ["RIGHT" /* RIGHT */]: "RIGHT",
+  ["INSTR" /* INSTR */]: "INSTR",
+  ["CONCAT" /* CONCAT */]: "CONCAT",
+  ["REPLACE" /* REPLACE */]: "REPLACE",
+  ["REGEXP_LIKE" /* REGEXP_LIKE */]: "REGEXP_LIKE",
+  ["REGEXP_REPLACE" /* REGEXP_REPLACE */]: "REGEXP_REPLACE",
+  ["REGEXP_SUBSTR" /* REGEXP_SUBSTR */]: "REGEXP_SUBSTR",
+  ["TRANSLATE" /* TRANSLATE */]: "TRANSLATE",
+  ["COALESCE" /* COALESCE */]: "COALESCE",
+  ["ISNULL" /* ISNULL */]: "ISNULL",
+  ["NULLIF" /* NULLIF */]: "NULLIF",
+  ["GREATEST" /* GREATEST */]: "GREATEST",
+  ["LEAST" /* LEAST */]: "LEAST",
+  ["LPAD" /* LPAD */]: "LPAD",
+  ["RPAD" /* RPAD */]: "RPAD",
+  ["ROUND" /* ROUND */]: "ROUND",
+  ["FLOOR" /* FLOOR */]: "FLOOR",
+  ["CEIL" /* CEIL */]: "CEIL",
+  ["CEILING" /* CEILING */]: "CEIL",
+  ["TRUNCATE" /* TRUNCATE */]: "TRUNCATE",
+  ["TRUNC" /* TRUNC */]: "TRUNCATE",
+  ["ABS" /* ABS */]: "ABS",
+  ["MOD" /* MOD */]: "MOD",
+  ["POWER" /* POWER */]: "POWER",
+  ["POW" /* POW */]: "POWER",
+  ["SQRT" /* SQRT */]: "SQRT",
+  ["FORMAT" /* FORMAT */]: "FORMAT",
+  ["CAST" /* CAST */]: "CAST",
+  ["CONVERT" /* CONVERT */]: "CAST",
+  ["YEAR" /* YEAR */]: "YEAR",
+  ["MONTH" /* MONTH */]: "MONTH",
+  ["DAY" /* DAY */]: "DAY",
+  ["DATE_FORMAT" /* DATE_FORMAT */]: "DATE_FORMAT",
+  ["DATEDIFF" /* DATEDIFF */]: "DATEDIFF",
+  ["DATE_ADD" /* DATE_ADD */]: "DATE_ADD",
+  ["LAST_DAY" /* LAST_DAY */]: "LAST_DAY"
+});
+var PARSER_IDENT_SCALAR_FUNCTIONS = Object.freeze([
+  "CURRENT_DATE",
+  "CURRENT_TIMESTAMP"
+]);
+var PARSER_AGGREGATE_FUNCTION_TOKEN_MAP = Object.freeze({
+  ["COUNT" /* COUNT */]: "COUNT",
+  ["SUM" /* SUM */]: "SUM",
+  ["AVG" /* AVG */]: "AVG",
+  ["MAX" /* MAX */]: "MAX",
+  ["MIN" /* MIN */]: "MIN",
+  ["GROUP_CONCAT" /* GROUP_CONCAT */]: "GROUP_CONCAT"
+});
+var PARSER_WINDOW_FUNCTION_TOKEN_MAP = Object.freeze({
+  ["ROW_NUMBER" /* ROW_NUMBER */]: "ROW_NUMBER",
+  ["RANK" /* RANK */]: "RANK",
+  ["DENSE_RANK" /* DENSE_RANK */]: "DENSE_RANK"
+});
+var PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP = Object.freeze({
+  ["TODAY" /* TODAY */]: "TODAY",
+  ["NOW" /* NOW */]: "NOW",
+  ["LOGINUSER" /* LOGINUSER */]: "LOGINUSER"
+});
+function isContextualFunctionToken(kind) {
+  return PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP[kind] !== void 0;
+}
+var PARSER_FUNCTION_SPELLINGS = Object.freeze(Array.from(/* @__PURE__ */ new Set([
+  ...Object.keys(PARSER_SCALAR_FUNCTION_TOKEN_MAP),
+  ...PARSER_IDENT_SCALAR_FUNCTIONS,
+  ...Object.keys(PARSER_AGGREGATE_FUNCTION_TOKEN_MAP),
+  ...Object.keys(PARSER_WINDOW_FUNCTION_TOKEN_MAP),
+  ...Object.keys(PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP),
+  "IF"
+])));
 var FUNC_CALL_PREFIX_KINDS = /* @__PURE__ */ new Set([
   "IDENT" /* IDENT */,
   "BIDENT" /* BIDENT */,
@@ -820,13 +901,14 @@ var Parser = class {
       this.advance();
       return { type: "STRING", value: tok.value };
     }
-    if (tok.kind === "LOGINUSER" /* LOGINUSER */) {
+    const contextualFunction = PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP[tok.kind];
+    if (contextualFunction === "LOGINUSER") {
       throw new ParseError(
         `${context} \u306E\u53F3\u8FBA\u3067 LOGINUSER() \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\uFF08\u5B9F\u884C\u74B0\u5883\u5171\u901A\u306E\u30ED\u30B0\u30A4\u30F3\u30E6\u30FC\u30B6\u30FC\u89E3\u6C7A\u306F\u672A\u5BFE\u5FDC\u3067\u3059\uFF09`,
         tok
       );
     }
-    if (tok.kind === "TODAY" /* TODAY */ || tok.kind === "NOW" /* NOW */) {
+    if (contextualFunction !== void 0) {
       return this.parseSqlValue();
     }
     const expr = this.parseArithAddSub();
@@ -1581,16 +1663,7 @@ var Parser = class {
     return { type: "FIELD", field, alias };
   }
   tryWindowFunc() {
-    switch (this.peek().kind) {
-      case "ROW_NUMBER" /* ROW_NUMBER */:
-        return "ROW_NUMBER";
-      case "RANK" /* RANK */:
-        return "RANK";
-      case "DENSE_RANK" /* DENSE_RANK */:
-        return "DENSE_RANK";
-      default:
-        return null;
-    }
+    return PARSER_WINDOW_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
   }
   parseWindowColumn(func) {
     this.advance();
@@ -1947,64 +2020,14 @@ var Parser = class {
   // ──────────────────────────────────────────────────
   tryStringFuncName() {
     if (this.peekAt(1).kind === "(" /* LPAREN */) {
-      if (this.peek().kind === "LEFT" /* LEFT */) return "LEFT";
-      if (this.peek().kind === "RIGHT" /* RIGHT */) return "RIGHT";
-    }
-    const map = {
-      ["UPPER" /* UPPER */]: "UPPER",
-      ["LOWER" /* LOWER */]: "LOWER",
-      ["TRIM" /* TRIM */]: "TRIM",
-      ["LTRIM" /* LTRIM */]: "LTRIM",
-      ["RTRIM" /* RTRIM */]: "RTRIM",
-      ["LENGTH" /* LENGTH */]: "LENGTH",
-      ["LENGTH_CHAR" /* LENGTH_CHAR */]: "LENGTH_CHAR",
-      ["SUBSTRING" /* SUBSTRING */]: "SUBSTRING",
-      ["SUBSTR" /* SUBSTR */]: "SUBSTRING",
-      ["CONCAT" /* CONCAT */]: "CONCAT",
-      ["REPLACE" /* REPLACE */]: "REPLACE",
-      ["REGEXP_LIKE" /* REGEXP_LIKE */]: "REGEXP_LIKE",
-      ["REGEXP_REPLACE" /* REGEXP_REPLACE */]: "REGEXP_REPLACE",
-      ["REGEXP_SUBSTR" /* REGEXP_SUBSTR */]: "REGEXP_SUBSTR",
-      ["TRANSLATE" /* TRANSLATE */]: "TRANSLATE",
-      ["COALESCE" /* COALESCE */]: "COALESCE",
-      ["NULLIF" /* NULLIF */]: "NULLIF",
-      ["ISNULL" /* ISNULL */]: "ISNULL",
-      ["INSTR" /* INSTR */]: "INSTR",
-      ["GREATEST" /* GREATEST */]: "GREATEST",
-      ["LEAST" /* LEAST */]: "LEAST",
-      ["LPAD" /* LPAD */]: "LPAD",
-      ["RPAD" /* RPAD */]: "RPAD",
-      ["CAST" /* CAST */]: "CAST",
-      ["CONVERT" /* CONVERT */]: "CAST",
-      // CONVERT → CAST に正規化
-      ["FORMAT" /* FORMAT */]: "FORMAT",
-      ["ROUND" /* ROUND */]: "ROUND",
-      ["FLOOR" /* FLOOR */]: "FLOOR",
-      ["CEIL" /* CEIL */]: "CEIL",
-      ["CEILING" /* CEILING */]: "CEIL",
-      // CEILING → CEIL に正規化
-      ["TRUNCATE" /* TRUNCATE */]: "TRUNCATE",
-      ["TRUNC" /* TRUNC */]: "TRUNCATE",
-      // TRUNC → TRUNCATE に正規化
-      ["YEAR" /* YEAR */]: "YEAR",
-      ["MONTH" /* MONTH */]: "MONTH",
-      ["DAY" /* DAY */]: "DAY",
-      ["DATE_FORMAT" /* DATE_FORMAT */]: "DATE_FORMAT",
-      ["DATEDIFF" /* DATEDIFF */]: "DATEDIFF",
-      ["DATE_ADD" /* DATE_ADD */]: "DATE_ADD",
-      ["LAST_DAY" /* LAST_DAY */]: "LAST_DAY",
-      ["ABS" /* ABS */]: "ABS",
-      ["MOD" /* MOD */]: "MOD",
-      ["POWER" /* POWER */]: "POWER",
-      ["POW" /* POW */]: "POWER",
-      // POW → POWER に正規化
-      ["SQRT" /* SQRT */]: "SQRT"
-    };
-    const byKind = map[this.peek().kind] ?? null;
-    if (byKind !== null) return byKind;
+      const conditional = PARSER_SCALAR_FUNCTION_TOKEN_MAP[this.peek().kind];
+      if (conditional === "LEFT" || conditional === "RIGHT") return conditional;
+    }
+    const byKind = PARSER_SCALAR_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
+    if (byKind !== null && byKind !== "LEFT" && byKind !== "RIGHT") return byKind;
     if (this.peek().kind === "IDENT" /* IDENT */) {
       const name = this.peek().value.toUpperCase();
-      if (name === "CURRENT_DATE" || name === "CURRENT_TIMESTAMP") {
+      if (PARSER_IDENT_SCALAR_FUNCTIONS.includes(name)) {
         if (this.peekAt(1).kind === "(" /* LPAREN */) {
           return name;
         }
@@ -2094,16 +2117,7 @@ var Parser = class {
     return false;
   }
   tryAggregateFunc() {
-    const map = {
-      ["COUNT" /* COUNT */]: "COUNT",
-      ["SUM" /* SUM */]: "SUM",
-      ["AVG" /* AVG */]: "AVG",
-      ["MAX" /* MAX */]: "MAX",
-      ["MIN" /* MIN */]: "MIN",
-      ["GROUP_CONCAT" /* GROUP_CONCAT */]: "GROUP_CONCAT"
-    };
-    const kind = this.peek().kind;
-    return map[kind] ?? null;
+    return PARSER_AGGREGATE_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
   }
   /** 集計関数参照を読む。SELECT 列の alias は呼び出し側で式全体の後に処理する。 */
   parseAggregateRef(func) {
@@ -2464,13 +2478,13 @@ var Parser = class {
       this.advance();
       return { type: "STRING", value: tok.value };
     }
-    if (tok.kind === "TODAY" /* TODAY */ || tok.kind === "NOW" /* NOW */ || tok.kind === "LOGINUSER" /* LOGINUSER */) {
+    if (isContextualFunctionToken(tok.kind)) {
       this.advance();
       this.expect("(" /* LPAREN */);
       this.expect(")" /* RPAREN */);
       return {
         type: "KINTONE_FUNC",
-        name: tok.value
+        name: PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP[tok.kind]
       };
     }
     if (tok.kind === "CASE" /* CASE */) {
@@ -3267,7 +3281,7 @@ var Parser = class {
     }
     if (tok.kind === "VARIABLE" /* VARIABLE */) return this.parseSqlValue();
     if (tok.kind === "STRING" /* STRING */) return this.parseSqlValue();
-    if (tok.kind === "TODAY" /* TODAY */ || tok.kind === "NOW" /* NOW */ || tok.kind === "LOGINUSER" /* LOGINUSER */) return this.parseSqlValue();
+    if (isContextualFunctionToken(tok.kind)) return this.parseSqlValue();
     if (tok.kind === "IN" /* IN */) return this.parseSqlValue();
     if (tok.kind === "CASE" /* CASE */ || tok.kind === "IF" /* IF */) {
       return this.parseSqlValue();
@@ -4930,6 +4944,9 @@ 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;
+  if (!cteDef.query.columns.every(
+    (column) => column.type === "WILDCARD" || column.type === "FIELD" && (column.alias === null || column.alias === column.field)
+  )) return false;
   const finalQuery = stmt.query;
   if (finalQuery.type !== "SELECT") return false;
   if (finalQuery.from.cteName !== cteDef.name || finalQuery.joins.length > 0) return false;
@@ -9700,10 +9717,12 @@ function flatten(record, alias) {
   }
   return row;
 }
-function applyJoin(leftRows, rightRows, join2) {
+function applyJoin(leftRows, rightRows, join2, columns = {}) {
   const { on, type: joinType } = join2;
   const leftKey = on.left.tableAlias ? `${on.left.tableAlias}.${on.left.field}` : on.left.field;
   const rightKey = on.right.tableAlias ? `${on.right.tableAlias}.${on.right.field}` : on.right.field;
+  assertJoinKeyAvailable(leftRows, leftKey, columns.leftColumns);
+  assertJoinKeyAvailable(rightRows, rightKey, columns.rightColumns);
   if (joinType === "RIGHT") {
     const leftIndex = /* @__PURE__ */ new Map();
     for (const lRow of leftRows) {
@@ -9713,7 +9732,7 @@ function applyJoin(leftRows, rightRows, join2) {
       else leftIndex.set(k, [lRow]);
     }
     const emptyLeft = {};
-    for (const key of Object.keys(leftRows[0] ?? {})) emptyLeft[key] = "";
+    for (const key of columns.leftColumns ?? Object.keys(leftRows[0] ?? {})) emptyLeft[key] = "";
     const result2 = [];
     for (const rRow of rightRows) {
       const k = rRow[rightKey] ?? "";
@@ -9735,7 +9754,7 @@ function applyJoin(leftRows, rightRows, join2) {
   }
   const result = [];
   const emptyRight = {};
-  for (const key of Object.keys(rightRows[0] ?? {})) emptyRight[key] = "";
+  for (const key of columns.rightColumns ?? Object.keys(rightRows[0] ?? {})) emptyRight[key] = "";
   for (const lRow of leftRows) {
     const k = lRow[leftKey] ?? "";
     const matched = rightIndex.get(k) ?? [];
@@ -9749,6 +9768,12 @@ function applyJoin(leftRows, rightRows, join2) {
   }
   return result;
 }
+function assertJoinKeyAvailable(rows, key, savedColumns) {
+  const missing = rows.length > 0 ? rows.some((row) => !Object.prototype.hasOwnProperty.call(row, key)) : savedColumns !== void 0 && !savedColumns.includes(key);
+  if (missing) {
+    throw new Error(`ArgumentError: JOIN key ${key} is not available in the materialized table.`);
+  }
+}
 function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
   if (where === null) return rows;
   return rows.filter((row) => evalWhere(where, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2));
@@ -10047,9 +10072,12 @@ function applyLimit(rows, limit, offset) {
   if (limit === null) return rows.slice(start);
   return rows.slice(start, start + limit);
 }
-function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, resolveFieldSemantics2) {
+function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, resolveFieldSemantics2, hiddenQualifiedAliases) {
   if (columns.length === 1 && columns[0].type === "WILDCARD") {
-    const projected2 = rows.map((row) => stripParentShortcutColumns(row));
+    const projected2 = rows.map((row) => stripHiddenQualifiedColumns(
+      stripParentShortcutColumns(row),
+      hiddenQualifiedAliases
+    ));
     const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [...sourceColumns ?? []];
     return { rows: projected2, columns: cols };
   }
@@ -10069,7 +10097,10 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
         case "VARIABLE_COL":
           throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
         case "WILDCARD":
-          Object.assign(out, stripParentShortcutColumns(row));
+          Object.assign(out, stripHiddenQualifiedColumns(
+            stripParentShortcutColumns(row),
+            hiddenQualifiedAliases
+          ));
           break;
         case "PARENT_WILDCARD": {
           const parentKeys = Object.keys(row).filter((k) => k.startsWith("_p.")).sort();
@@ -10322,6 +10353,27 @@ function resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind) {
     args: expr.args.map((arg) => resolveAggInStringFuncArg(arg, rows, resolveAggSortKind))
   };
 }
+function stripHiddenQualifiedColumns(row, hiddenQualifiedAliases) {
+  if (!hiddenQualifiedAliases || hiddenQualifiedAliases.size === 0) return row;
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if ([...hiddenQualifiedAliases].some((alias) => key.startsWith(`${alias}.`))) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function flattenedColumns(columns, alias) {
+  if (columns === void 0) return void 0;
+  return alias ? columns.flatMap((column) => [`${alias}.${column}`, column]) : [...columns];
+}
+function mergeKnownColumns(left, right, rows) {
+  if (left === void 0 && right === void 0 && rows.length === 0) return void 0;
+  return [.../* @__PURE__ */ new Set([
+    ...left ?? [],
+    ...right ?? [],
+    ...Object.keys(rows[0] ?? {})
+  ])];
+}
 function deriveOutputOrderSemantics(columns) {
   const result = /* @__PURE__ */ new Map();
   for (const column of columns) {
@@ -10356,7 +10408,9 @@ function runFullScan(input) {
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes,
-    sourceColumns
+    sourceColumns,
+    tableColumns,
+    hiddenQualifiedAliases
   } = input;
   const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns);
   for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
@@ -10364,11 +10418,25 @@ function runFullScan(input) {
   const mainAlias = stmt.from.alias;
   const mainRecords = tables.get(mainAlias) ?? tables.get(null) ?? [];
   rows = mainRecords.map((r) => flatten(r, mainAlias));
+  let knownColumns = mergeKnownColumns(
+    flattenedColumns(tableColumns?.get(mainAlias), mainAlias),
+    void 0,
+    rows
+  );
   for (const join2 of stmt.joins) {
     const rightAlias = join2.table.alias;
     const rightRecords = tables.get(rightAlias) ?? [];
     const rightRows = rightRecords.map((r) => flatten(r, rightAlias));
-    rows = applyJoin(rows, rightRows, join2);
+    const rightColumns = mergeKnownColumns(
+      flattenedColumns(tableColumns?.get(rightAlias), rightAlias),
+      void 0,
+      rightRows
+    );
+    rows = applyJoin(rows, rightRows, join2, {
+      leftColumns: knownColumns,
+      rightColumns
+    });
+    knownColumns = mergeKnownColumns(knownColumns, rightColumns, rows);
   }
   rows = applyFilter(rows, stmt.where, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
   if (stmt.groupBy.length > 0 || hasAggregateColumns(stmt.columns)) {
@@ -10381,7 +10449,15 @@ function runFullScan(input) {
   }
   rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds, effectiveOrderSemantics);
   rows = applyLimit(rows, stmt.limit, stmt.offset);
-  return project(rows, stmt.columns, scalarCache, fieldTypeResolver, sourceColumns, fieldSemanticsResolver);
+  return project(
+    rows,
+    stmt.columns,
+    scalarCache,
+    fieldTypeResolver,
+    sourceColumns,
+    fieldSemanticsResolver,
+    hiddenQualifiedAliases
+  );
 }
 
 // src/converter/subtableAdapter.ts
@@ -12693,7 +12769,7 @@ async function buildWhereFieldSemanticsResolver(stmt, client, cacheContext, mate
       if (field.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
         return fromPhysical(stmt.from, field.field, false);
       }
-      const table = tables.find((candidate) => candidate.alias === field.tableAlias);
+      const table = tables.find((candidate) => effectiveTableAlias(candidate) === field.tableAlias);
       if (!table) return void 0;
       if (table.cteName !== null) {
         return materializedTables?.get(table.cteName)?.columnMeta?.get(field.field)?.semantics ?? syntheticSemantics("string");
@@ -13127,8 +13203,11 @@ function collectSelectTypedInFieldRefs(stmt) {
   }
   return refs;
 }
+function effectiveTableAlias(table) {
+  return table.alias ?? table.cteName;
+}
 function findTableForAlias(stmt, alias) {
-  return [stmt.from, ...stmt.joins.map((join2) => join2.table)].find((table) => table.alias === alias);
+  return [stmt.from, ...stmt.joins.map((join2) => join2.table)].find((table) => effectiveTableAlias(table) === alias);
 }
 function physicalSelectTables(stmt) {
   return [stmt.from, ...stmt.joins.map((join2) => join2.table)].filter((table) => table.cteName === null);
@@ -13280,7 +13359,7 @@ async function loadAggregateSortKindResolver(stmt, client, cacheContext, materia
       if (ref.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
         info = fieldInfosByApp.get(stmt.from.appId)?.get(ref.field);
       } else {
-        const table = tables.find((candidate) => candidate.alias === ref.tableAlias);
+        const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
         if (!table) return void 0;
         if (table.cteName !== null) {
           return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field)?.semantics ?? syntheticSemantics("string");
@@ -13305,7 +13384,7 @@ async function loadAggregateSortKindResolver(stmt, client, cacheContext, materia
       return matches[0];
     }
     if (!info) return void 0;
-    const sourceTable = ref.tableAlias !== null ? tables.find((table) => table.alias === ref.tableAlias) : stmt.joins.length === 0 ? stmt.from : void 0;
+    const sourceTable = ref.tableAlias !== null ? tables.find((table) => effectiveTableAlias(table) === ref.tableAlias) : stmt.joins.length === 0 ? stmt.from : void 0;
     return semanticsForInfo(info, sourceTable?.appId ?? stmt.from.appId);
   };
 }
@@ -13435,7 +13514,7 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
         const info2 = physicalInfos.get(stmt.from.appId)?.get(ref.field);
         return info2 ? materializedMetaFromFieldInfo(info2, stmt.from.appId) : void 0;
       }
-      const table = tables.find((candidate) => candidate.alias === ref.tableAlias);
+      const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
       if (!table) return void 0;
       if (table.cteName !== null) return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field);
       const info = physicalInfos.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
@@ -13540,7 +13619,7 @@ function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
       if (field.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
         return fieldTypesByApp.get(stmt.from.appId)?.get(field.field);
       }
-      const table = tables.find((candidate) => candidate.alias === field.tableAlias);
+      const table = tables.find((candidate) => effectiveTableAlias(candidate) === field.tableAlias);
       if (!table || table.cteName !== null) return void 0;
       return subtableSystemFieldType(table, field.field) ?? fieldTypesByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, field.field));
     }
@@ -13765,6 +13844,37 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
   return result;
 }
 async function executeFullScanWithCte(stmt, client, options, cteCache, cacheContext) {
+  const hiddenQualifiedAliases = /* @__PURE__ */ new Set();
+  const withEffectiveAlias = (table) => {
+    if (table.alias !== null || table.cteName === null) return table;
+    const alias = effectiveTableAlias(table);
+    hiddenQualifiedAliases.add(alias);
+    return { ...table, alias };
+  };
+  stmt = {
+    ...stmt,
+    from: withEffectiveAlias(stmt.from),
+    joins: stmt.joins.map((join2) => ({ ...join2, table: withEffectiveAlias(join2.table) }))
+  };
+  const aliases = /* @__PURE__ */ new Set();
+  for (const table of [stmt.from, ...stmt.joins.map((join2) => join2.table)]) {
+    const alias = effectiveTableAlias(table);
+    if (alias === null) continue;
+    if (aliases.has(alias)) {
+      throw new Error(`ArgumentError: effective alias ${alias} is used by multiple tables.`);
+    }
+    aliases.add(alias);
+  }
+  const requireMaterializedTable = (name) => {
+    const table = cteCache.get(name);
+    if (!table) {
+      throw new Error(`ArgumentError: materialized source ${name} is not available.`);
+    }
+    return table;
+  };
+  for (const table of [stmt.from, ...stmt.joins.map((join2) => join2.table)]) {
+    if (table.cteName !== null) requireMaterializedTable(table.cteName);
+  }
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
@@ -13811,9 +13921,11 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   orderByMetaPromise.catch(() => {
   });
   const tables = /* @__PURE__ */ new Map();
+  const tableColumns = /* @__PURE__ */ new Map();
   if (stmt.from.cteName != null) {
-    const table = cteCache.get(stmt.from.cteName);
-    tables.set(stmt.from.alias, (table?.rows ?? []).map(processRowToKintoneRecord));
+    const table = requireMaterializedTable(stmt.from.cteName);
+    tables.set(stmt.from.alias, table.rows.map(processRowToKintoneRecord));
+    tableColumns.set(stmt.from.alias, table.columns);
   } else {
     const mainRecords = await fetchTableRecordsForFullScan(
       stmt,
@@ -13831,8 +13943,9 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   }
   const joinFetches = stmt.joins.map(async (join2) => {
     if (join2.table.cteName != null) {
-      const table = cteCache.get(join2.table.cteName);
-      tables.set(join2.table.alias, (table?.rows ?? []).map(processRowToKintoneRecord));
+      const table = requireMaterializedTable(join2.table.cteName);
+      tables.set(join2.table.alias, table.rows.map(processRowToKintoneRecord));
+      tableColumns.set(join2.table.alias, table.columns);
     } else {
       const pushDownCond = join2.table.alias ? pushdownPlan.joinConditions.get(join2.table.alias) ?? null : null;
       const optimized = await tryFetchJoinRecordsBySourceKeys(
@@ -13863,7 +13976,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   await Promise.all(joinFetches);
   const scalarCache = await scalarCachePromise;
   const { optionOrders, sortKinds, semantics } = await orderByMetaPromise;
-  const sourceColumns = stmt.joins.length === 0 && stmt.from.cteName != null ? cteCache.get(stmt.from.cteName)?.columns : void 0;
+  const sourceColumns = stmt.joins.length === 0 && stmt.from.cteName != null ? requireMaterializedTable(stmt.from.cteName).columns : void 0;
   const { rows, columns } = runFullScan({
     tables,
     stmt,
@@ -13877,7 +13990,9 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes: pushdownPlan.appliedKlikes,
-    sourceColumns
+    sourceColumns,
+    tableColumns,
+    hiddenQualifiedAliases
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -14179,7 +14294,7 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
         const info2 = infosByApp.get(stmt.from.appId)?.get(ref.field);
         return info2 ? materializedMetaFromFieldInfo(info2, stmt.from.appId) : void 0;
       }
-      const table = tables.find((candidate) => candidate.alias === ref.tableAlias);
+      const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
       if (!table) return void 0;
       if (table.cteName !== null) return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field);
       const info = infosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));