fix(vnext): authenticate join continuations

Author: Light2Dark

docs/adr/0005-parser-independent-relation-completion.md

@@ -97,12 +97,20 @@ embedded region are unavailable or inactive according to the closed result.
 CTE visibility is the one narrow scope-semantics exception; general
 parser-derived scope semantics remain deferred.
 
+The recognizer may cross a `USING` join constraint only after authenticating
+the complete bounded grammar `USING(identifier [, identifier ...])` with
+dialect-owned identifier validation. It does not interpret `ON` expressions:
+encountering `ON` makes the query site unavailable until a future
+parser-backed or separately specified expression recognizer can prove the
+boundary.
+
 The conformance corpus includes positive base `FROM`, qualified prefix,
-aliased `JOIN`, same-depth comma, and nested supported-query cases. It includes
+aliased `JOIN`, authenticated `USING`, same-depth comma, and nested
+supported-query cases. It includes
 negative `IS DISTINCT FROM`, `substring(... FROM ...)`, `extract(... FROM
-...)`, `DELETE FROM`, `COPY ... FROM`, set-operation, `QUALIFY`, `WINDOW`, join
-constraint, DML, and expression cases. A keyword match alone never creates a
-site.
+...)`, `DELETE FROM`, `COPY ... FROM`, set-operation, `QUALIFY`, `WINDOW`,
+`ON`, malformed `USING`, DML, and expression cases. A keyword match alone
+never creates a site.
 
 The result distinguishes:
 

src/vnext/__tests__/query-site.bench.ts

@@ -11,9 +11,9 @@ import {
 } from "../statement-index.js";
 
 const dialect: SqlQuerySiteDialect = {
-  classifyRelationAlias: (rawAlias) => ({
+  classifyIdentifierToken: (rawIdentifier) => ({
     status: "identifier",
-    value: rawAlias,
+    value: rawIdentifier,
   }),
   decodeRelationPath: (rawPath, cursorOffset) => ({
     finalSegment: { from: 0, to: rawPath.length },
@@ -29,10 +29,20 @@ const dialect: SqlQuerySiteDialect = {
   maximumPathDepth: 16,
   supportsNaturalJoin: true,
 };
-const tenKilobyteQuery = `SELECT ${Array.from(
-  { length: 1_100 },
-  (_, index) => `value_${index}`,
-).join(", ")} FROM schema_prefix`;
+const TEN_KIBIBYTES = 10 * 1_024;
+const queryPrefix = "SELECT ";
+const querySuffix = " FROM schema_prefix";
+const projectedListLength =
+  TEN_KIBIBYTES - queryPrefix.length - querySuffix.length;
+const projectedList = `${"x,".repeat(
+  Math.floor((projectedListLength - 1) / 2),
+)}x`;
+const tenKilobyteQuery = `${queryPrefix}${projectedList}${" ".repeat(
+  projectedListLength - projectedList.length,
+)}${querySuffix}`;
+if (tenKilobyteQuery.length !== TEN_KIBIBYTES) {
+  throw new Error("Query benchmark fixture must be exactly 10 KiB");
+}
 const source = createIdentitySqlSource(tenKilobyteQuery);
 const index = buildSqlStatementIndex(
   source.analysisText,
@@ -55,6 +65,21 @@ const aliasHeavySlot = findSqlStatementSlot(
   aliasHeavyPosition,
   "left",
 );
+const usingHeavyQuery = `SELECT * FROM first_table JOIN second_table USING(${Array.from(
+  { length: 1_000 },
+  (_, columnIndex) => `column_${columnIndex}`,
+).join(", ")}) JOIN target`;
+const usingHeavySource = createIdentitySqlSource(usingHeavyQuery);
+const usingHeavyIndex = buildSqlStatementIndex(
+  usingHeavySource.analysisText,
+  dialect.lexicalProfile,
+);
+const usingHeavyPosition = usingHeavyQuery.length;
+const usingHeavySlot = findSqlStatementSlot(
+  usingHeavyIndex,
+  usingHeavyPosition,
+  "left",
+);
 
 describe("query-site recognizer", () => {
   bench("10 KiB active statement", () => {
@@ -69,4 +94,13 @@ describe("query-site recognizer", () => {
       dialect,
     );
   });
+
+  bench("1,000 authenticated USING columns", () => {
+    recognizeSqlRelationQuerySite(
+      usingHeavySource,
+      usingHeavySlot,
+      usingHeavyPosition,
+      dialect,
+    );
+  });
 });