Address last code review comments

julian-elastic · julian-elastic · commit b10c36000d32 · 2025-09-16T16:31:40.000-04:00
diff --git a/test/external-modules/esql-heap-attack/src/javaRestTest/java/org/elasticsearch/xpack/esql/heap_attack/HeapAttackIT.java b/test/external-modules/esql-heap-attack/src/javaRestTest/java/org/elasticsearch/xpack/esql/heap_attack/HeapAttackIT.java
@@ -776,7 +776,6 @@ public void testLookupExplosionManyMatches() throws IOException {
     }
 
     public void testLookupExplosionManyMatchesExpression() throws IOException {
-        // 1500, 10000 is enough locally, but some CI machines need more.
         int lookupEntries = 10000;
         assertCircuitBreaks(attempt -> lookupExplosion(attempt * 1500, lookupEntries, 1, lookupEntries, true));
     }
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/AnalyzerRules.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/AnalyzerRules.java
@@ -7,6 +7,7 @@
 
 package org.elasticsearch.xpack.esql.analysis;
 
+import org.elasticsearch.xpack.esql.VerificationException;
 import org.elasticsearch.xpack.esql.core.expression.Attribute;
 import org.elasticsearch.xpack.esql.core.expression.UnresolvedAttribute;
 import org.elasticsearch.xpack.esql.plan.logical.LogicalPlan;
@@ -116,7 +117,6 @@ public static List<Attribute> maybeResolveAgainstList(
             int colDiff = a.sourceLocation().getColumnNumber() - b.sourceLocation().getColumnNumber();
             return lineDiff != 0 ? lineDiff : (colDiff != 0 ? colDiff : a.name().compareTo(b.name()));
         }).map(a -> "line " + a.sourceLocation().toString().substring(1) + " [" + a.name() + "]").toList();
-
-        throw new IllegalStateException("Reference [" + ua.name() + "] is ambiguous; " + "matches any of " + refs);
+        throw new VerificationException("Found ambiguous reference to [" + ua.name() + "]; " + "matches any of " + refs);
     }
 }
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/BinaryComparisonQueryList.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/BinaryComparisonQueryList.java
@@ -33,8 +33,8 @@
  * This class is used in the context of an expression based lookup join,
  * where we need to generate a query for each row of the left dataset.
  * The query is then used to fetch the matching rows from the right dataset.
- * The query is a binary comparison between a field from the right dataset and a value from the left dataset.
- * The field is on the left side of the comparison and the value is on the right side.
+ * The query is a binary comparison between a field from the right dataset
+ * and a single value from the left dataset. e.g right_id > 5
  * The value is extracted from a block at a given position.
  * The comparison is then translated to a Lucene query.
  * If the comparison cannot be translated, an exception is thrown.
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/ExpressionQueryList.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/ExpressionQueryList.java
@@ -49,6 +49,7 @@
  * The query is then used to fetch the matching rows from the right dataset.
  * The class supports two types of joins:
  * 1. Field-based join: The join conditions are based on the equality of fields from the left and right datasets.
+ * It is used for field-based join when the join is on more than one field or there is a preJoinFilter
  * 2. Expression-based join: The join conditions are based on a complex expression that can involve multiple fields and operators.
  */
 public class ExpressionQueryList implements LookupEnrichQueryGenerator {
@@ -76,13 +77,6 @@ private ExpressionQueryList(
      * For example | LOOKUP JOIN on field1, field2, field3
      * The query lists are generated from the join conditions.
      * The pre-join filter is an optional filter that is applied to the right dataset before the join.
-     * @param queryLists The list of query lists that will be combined.
-     * @param context The search execution context.
-     * @param rightPreJoinPlan The physical plan for the right side of the join.
-     * @param clusterService The cluster service.
-     * @param aliasFilter The alias filter.
-     * @return A new {@link ExpressionQueryList} for a field-based join.
-     * @throws IllegalArgumentException if the number of query lists is less than 2 and there is no pre-join filter.
      */
     public static ExpressionQueryList fieldBasedJoin(
         List<QueryList> queryLists,
@@ -104,14 +98,6 @@ public static ExpressionQueryList fieldBasedJoin(
      * Example | LOOKUP JOIN on left_field > right_field AND left_field2 == right_field2
      * The query lists are generated from the join conditions.
      * The pre-join filter is an optional filter that is applied to the right dataset before the join.
-     * @param context The search execution context.
-     * @param rightPreJoinPlan The physical plan for the right side of the join.
-     * @param clusterService The cluster service.
-     * @param request The transport request.
-     * @param aliasFilter The alias filter.
-     * @param warnings The warnings.
-     * @return A new {@link ExpressionQueryList} for an expression-based join.
-     * @throws IllegalStateException if the join conditions are null.
      */
     public static ExpressionQueryList expressionBasedJoin(
         SearchExecutionContext context,
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/LookupFromIndexService.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/enrich/LookupFromIndexService.java
@@ -337,7 +337,7 @@ public void writeTo(StreamOutput out) throws IOException {
                 planOut.writeOptionalNamedWriteable(joinOnConditions);
             } else {
                 if (joinOnConditions != null) {
-                    throw new EsqlIllegalArgumentException("LOOKUP JOIN with ON conditions is not supported on remote node");
+                    throw new IllegalArgumentException("LOOKUP JOIN with ON conditions is not supported on remote node");
                 }
             }
         }
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/parser/LogicalPlanBuilder.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/parser/LogicalPlanBuilder.java
@@ -733,7 +733,7 @@ private JoinInfo processFieldBasedJoin(List<Expression> expressions) {
             } else {
                 throw new ParsingException(
                     f.source(),
-                    "JOIN ON clause must be a comma separated list of fields or a single expression found [{}]",
+                    "JOIN ON clause must be a comma separated list of fields or a single expression, found [{}]",
                     f.sourceText()
                 );
             }
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/plan/logical/join/JoinConfig.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/plan/logical/join/JoinConfig.java
@@ -12,7 +12,6 @@
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.core.Nullable;
-import org.elasticsearch.xpack.esql.EsqlIllegalArgumentException;
 import org.elasticsearch.xpack.esql.core.capabilities.Resolvables;
 import org.elasticsearch.xpack.esql.core.expression.Attribute;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
@@ -61,7 +60,7 @@ public void writeTo(StreamOutput out) throws IOException {
         if (out.getTransportVersion().onOrAfter(TransportVersions.ESQL_LOOKUP_JOIN_ON_EXPRESSION)) {
             out.writeOptionalNamedWriteable(joinOnConditions);
         } else if (joinOnConditions != null) {
-            throw new EsqlIllegalArgumentException("LOOKUP JOIN with ON conditions is not supported on remote node");
+            throw new IllegalArgumentException("LOOKUP JOIN with ON conditions is not supported on remote node");
         }
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/plan/physical/LookupJoinExec.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/plan/physical/LookupJoinExec.java
@@ -11,7 +11,6 @@
 import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
-import org.elasticsearch.xpack.esql.EsqlIllegalArgumentException;
 import org.elasticsearch.xpack.esql.core.expression.Attribute;
 import org.elasticsearch.xpack.esql.core.expression.AttributeSet;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
@@ -80,7 +79,7 @@ public void writeTo(StreamOutput out) throws IOException {
         if (out.getTransportVersion().onOrAfter(TransportVersions.ESQL_LOOKUP_JOIN_ON_EXPRESSION)) {
             out.writeOptionalNamedWriteable(joinOnConditions);
         } else if (joinOnConditions != null) {
-            throw new EsqlIllegalArgumentException("LOOKUP JOIN with ON conditions is not supported on remote node");
+            throw new IllegalArgumentException("LOOKUP JOIN with ON conditions is not supported on remote node");
         }
     }
 
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/analysis/VerifierTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/analysis/VerifierTests.java
@@ -2218,6 +2218,48 @@ public void testLookupJoinDataTypeMismatch() {
         );
     }
 
+    public void testLookupJoinExpressionAmbiguousRight() {
+        assumeTrue("requires LOOKUP JOIN capability", EsqlCapabilities.Cap.JOIN_LOOKUP_V12.isEnabled());
+        String queryString = """
+            from test
+            | rename languages as language_code
+            | lookup join languages_lookup ON salary == language_code
+            """;
+
+        assertEquals(
+            " ambiguous reference to [language_code]; matches any of [line 2:10 [language_code], line 3:15 [language_code]]",
+            error(queryString)
+        );
+    }
+
+    public void testLookupJoinExpressionAmbiguousLeft() {
+        assumeTrue("requires LOOKUP JOIN capability", EsqlCapabilities.Cap.JOIN_LOOKUP_V12.isEnabled());
+        String queryString = """
+             from test
+            | rename languages as language_name
+            | lookup join languages_lookup ON language_name == language_code
+            """;
+
+        assertEquals(
+            " ambiguous reference to [language_name]; matches any of [line 2:10 [language_name], line 3:15 [language_name]]",
+            error(queryString)
+        );
+    }
+
+    public void testLookupJoinExpressionAmbiguousBoth() {
+        assumeTrue("requires LOOKUP JOIN capability", EsqlCapabilities.Cap.JOIN_LOOKUP_V12.isEnabled());
+        String queryString = """
+            from test
+            | rename languages as language_code
+            | lookup join languages_lookup ON language_code != language_code
+            """;
+
+        assertEquals(
+            " ambiguous reference to [language_code]; matches any of [line 2:10 [language_code], line 3:15 [language_code]]",
+            error(queryString)
+        );
+    }
+
     public void testFullTextFunctionOptions() {
         checkOptionDataTypes(Match.ALLOWED_OPTIONS, "FROM test | WHERE match(title, \"Jean\", {\"%s\": %s})");
         checkOptionDataTypes(QueryString.ALLOWED_OPTIONS, "FROM test | WHERE QSTR(\"title: Jean\", {\"%s\": %s})");
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/enrich/LookupFromIndexOperatorTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/enrich/LookupFromIndexOperatorTests.java
@@ -455,6 +455,7 @@ protected MapMatcher extendStatusMatcher(MapMatcher mapMatcher, List<Page> input
 
     @Override
     public void testSimpleCircuitBreaking() {
+        // only test field based join and EQ to prevents timeouts in Ci
         if (operation == null || operation.equals(EsqlBinaryComparison.BinaryComparisonOperation.EQ)) {
             super.testSimpleCircuitBreaking();
         }
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LogicalPlanOptimizerTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LogicalPlanOptimizerTests.java
@@ -89,6 +89,7 @@
 import org.elasticsearch.xpack.esql.expression.predicate.operator.comparison.In;
 import org.elasticsearch.xpack.esql.expression.predicate.operator.comparison.InsensitiveEquals;
 import org.elasticsearch.xpack.esql.expression.predicate.operator.comparison.LessThan;
+import org.elasticsearch.xpack.esql.expression.predicate.operator.comparison.NotEquals;
 import org.elasticsearch.xpack.esql.index.EsIndex;
 import org.elasticsearch.xpack.esql.index.IndexResolution;
 import org.elasticsearch.xpack.esql.optimizer.rules.logical.LiteralsOnTheRight;
@@ -9169,37 +9170,19 @@ public void testLookupJoinExpressionSwapped() {
         as(join.right(), EsRelation.class);
     }
 
-    public void testLookupJoinExpressionAmbigiousRight() {
-        String query = """
-            from test
-            | rename languages as language_code
-            | lookup join languages_lookup ON salary == language_code
-            """;
-        IllegalStateException e = expectThrows(IllegalStateException.class, () -> plan(query));
-        assertThat(e.getMessage(), containsString("Reference [language_code] is ambiguous; matches any of "));
-    }
-
-    public void testLookupJoinExpressionAmbigiousLeft() {
-        String query = """
-            from test
-            | rename languages as language_name
-            | lookup join languages_lookup ON language_name == language_code
-            """;
-        IllegalStateException e = expectThrows(IllegalStateException.class, () -> plan(query));
-        assertThat(e.getMessage(), containsString("Reference [language_name] is ambiguous; matches any of "));
-    }
-
-    public void testLookupJoinExpressionAmbigiousBoth() {
-        String query = """
-            from test
-            | rename languages as language_code
-            | lookup join languages_lookup ON language_code != language_code
-            """;
-        IllegalStateException e = expectThrows(IllegalStateException.class, () -> plan(query));
-        assertThat(e.getMessage(), containsString("Reference [language_code] is ambiguous; matches any of "));
-    }
-
-    public void testLookupJoinExpressionAnd() {
+    /**
+     *
+     * Project[[_meta_field{f}#15, emp_no{f}#9, first_name{f}#10, gender{f}#11, hire_date{f}#16, job{f}#17, job.raw{f}#18, la
+     * nguages{f}#12 AS language_code_left#4, last_name{f}#13, long_noidx{f}#19, salary{f}#14, language_code{f}#20, language_name{f}#21]]
+     * \_Limit[1000[INTEGER],true]
+     *   \_Join[LEFT,[languages{f}#12, languages{f}#12],[language_code{f}#20, language_code{f}#20],languages{f}#12 != language_co
+     * de{f}#20 AND languages{f}#12 > language_code{f}#20]
+     *     |_Limit[1000[INTEGER],false]
+     *     | \_EsRelation[test][_meta_field{f}#15, emp_no{f}#9, first_name{f}#10, g..]
+     *     \_EsRelation[languages_lookup][LOOKUP][language_code{f}#20, language_name{f}#21]
+     *
+     */
+    public void testLookupJoinExpressionSameAttrsDifferentConditions() {
         String query = """
             from test
             | rename languages as language_code_left
@@ -9208,5 +9191,33 @@ public void testLookupJoinExpressionAnd() {
 
         LogicalPlan plan = optimizedPlan(query);
         var project = as(plan, Project.class);
+        var limit = asLimit(project.child(), 1000, true);
+        var join = as(limit.child(), Join.class);
+
+        // Verify the join conditions contain both != and > operators
+        var joinConditions = join.config().joinOnConditions();
+        assertThat(joinConditions, instanceOf(And.class));
+        var and = as(joinConditions, And.class);
+
+        // Check the left condition (should be !=)
+        var notEquals = as(and.left(), NotEquals.class);
+        var leftAttr = as(notEquals.left(), Attribute.class);
+        var rightAttr = as(notEquals.right(), Attribute.class);
+        assertEquals("languages", leftAttr.name());
+        assertEquals("language_code", rightAttr.name());
+
+        // Check the right condition (should be >)
+        var greaterThan = as(and.right(), GreaterThan.class);
+        var leftAttrGT = as(greaterThan.left(), Attribute.class);
+        var rightAttrGT = as(greaterThan.right(), Attribute.class);
+        assertEquals("languages", leftAttrGT.name());
+        assertEquals("language_code", rightAttrGT.name());
+
+        // Verify the left side of join has Limit then EsRelation
+        var limitPastJoin = asLimit(join.left(), 1000, false);
+        as(limitPastJoin.child(), EsRelation.class);
+
+        // Verify the right side of join is EsRelation with LOOKUP
+        as(join.right(), EsRelation.class);
     }
 }
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/PushDownAndCombineFiltersTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/PushDownAndCombineFiltersTests.java
@@ -850,7 +850,7 @@ private Join createLeftJoinOnExpression() {
         EsRelation left = relation(List.of(a, b1));
         EsRelation right = relation(List.of(c, b2));
         Expression joinOnCondition = new GreaterThanOrEqual(Source.EMPTY, b1, b2);
-        JoinConfig joinConfig = new JoinConfig(JoinTypes.LEFT, List.of(a, b1, b2), List.of(b2, c), joinOnCondition);
+        JoinConfig joinConfig = new JoinConfig(JoinTypes.LEFT, List.of(b1), List.of(b2), joinOnCondition);
         return new Join(EMPTY, left, right, joinConfig);
     }
 
@@ -872,6 +872,33 @@ public void testLeftJoinOnExpressionPushable() {
         assertEquals(pushableCondition, rightFilter.condition());
     }
 
+    public void testLeftJoinOnExpressionPushableLeftAndRight() {
+        Join join = createLeftJoinOnExpression();
+        FieldAttribute a = (FieldAttribute) join.left().output().get(0);
+        FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+        // Pushable filters on both left and right
+        Expression leftPushableCondition = greaterThanOf(a, ONE);
+        Expression rightPushableCondition = greaterThanOf(c, TWO);
+        Expression combinedCondition = Predicates.combineAnd(List.of(leftPushableCondition, rightPushableCondition));
+        Filter filter = new Filter(EMPTY, join, combinedCondition);
+        LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+
+        // The top filter should only contain the right pushable condition
+        // because left pushable conditions are completely pushed down and removed from the top
+        Filter topFilter = as(optimized, Filter.class);
+        assertEquals(rightPushableCondition, topFilter.condition());
+        Join optimizedJoin = as(topFilter.child(), Join.class);
+
+        // Check that the left side has the left pushable filter
+        Filter leftFilter = as(optimizedJoin.left(), Filter.class);
+        assertEquals(leftPushableCondition, leftFilter.condition());
+
+        // Check that the right side has the right pushable filter
+        Filter rightFilter = as(optimizedJoin.right(), Filter.class);
+        assertEquals(rightPushableCondition, rightFilter.condition());
+    }
+
     public void testPushDownFilterPastLeftJoinExpressionWithPartiallyPushableAnd() {
         Join join = createLeftJoinOnExpression();
         EsRelation left = (EsRelation) join.left();
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/PushDownJoinPastProjectTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/PushDownJoinPastProjectTests.java
@@ -284,6 +284,56 @@ public void testShadowingAfterPushdownExpressionJoin() {
         assertTrue(lookupRel.outputSet().contains(salary));
     }
 
+    /**
+     * Project[[languages{f}#31, emp_no{f}#28, salary{f}#33, $$languages$temp_name$39{r$}#40 AS lang2#4]]
+     * \_Limit[1000[INTEGER],true]
+     *   \_Join[LEFT,[emp_no{f}#17],[languages{f}#31],emp_no{f}#17 == languages{f}#31]
+     *     |_Eval[[languages{f}#20 AS $$languages$temp_name$39#40]]
+     *     | \_Limit[1000[INTEGER],false]
+     *     |   \_EsRelation[test][_meta_field{f}#23, emp_no{f}#17, first_name{f}#18, ..]
+     *     \_EsRelation[test_lookup][LOOKUP][emp_no{f}#28, languages{f}#31, salary{f}#33]
+     */
+    public void testShadowingAfterPushdownExpressionJoinKeepOrig() {
+        assumeTrue("Requires LOOKUP JOIN", EsqlCapabilities.Cap.JOIN_LOOKUP_V12.isEnabled());
+
+        String query = """
+            FROM test_lookup
+            | RENAME languages as lang2
+            | EVAL y = emp_no
+            | RENAME y AS lang
+            | LOOKUP JOIN test_lookup ON lang == languages
+            | KEEP languages, emp_no, salary, lang2
+            """;
+
+        var plan = optimizedPlan(query);
+        var project = as(plan, Project.class);
+        var limit1 = asLimit(project.child(), 1000, true);
+        var join = as(limit1.child(), Join.class);
+        var lookupRel = as(join.right(), EsRelation.class);
+        var eval = as(join.left(), Eval.class);
+        var limit2 = asLimit(eval.child(), 1000, false);
+        var mainRel = as(limit2.child(), EsRelation.class);
+
+        var projections = project.projections();
+        assertThat(Expressions.names(projections), contains("languages", "emp_no", "salary", "lang2"));
+
+        var languages = as(projections.get(0), FieldAttribute.class);
+        assertEquals("languages", languages.fieldName().string());
+        assertTrue(lookupRel.outputSet().contains(languages));
+
+        var empNo = as(projections.get(1), FieldAttribute.class);
+        assertEquals("emp_no", empNo.fieldName().string());
+        assertTrue(lookupRel.outputSet().contains(empNo));
+
+        var salary = as(projections.get(2), FieldAttribute.class);
+        assertEquals("salary", salary.fieldName().string());
+        assertTrue(lookupRel.outputSet().contains(salary));
+
+        var lang2TempName = unwrapAlias(projections.get(3), ReferenceAttribute.class);
+        assertThat(lang2TempName.name(), startsWith("$$languages$temp_name$"));
+        assertTrue(eval.outputSet().contains(lang2TempName));
+    }
+
     /**
      * Project[[languages{f}#24, emp_no{f}#21, salary{f}#26]]
      * \_Limit[1000[INTEGER],true]
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/parser/StatementParserTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/parser/StatementParserTests.java
@@ -3396,7 +3396,7 @@ public void testInvalidJoinPatternsExpressionJoinMixTwo() {
     public void testInvalidLookupJoinOnClause() {
         expectError(
             "FROM test  | LOOKUP JOIN test2 ON " + randomIdentifier() + " , " + singleExpressionJoinClause(),
-            "JOIN ON clause must be a comma separated list of fields or a single expression found"
+            "JOIN ON clause must be a comma separated list of fields or a single expression, found"
         );
 
         expectError(

Original file line number	Diff line number	Diff line change
`@@ -776,7 +776,6 @@ public void testLookupExplosionManyMatches() throws IOException {`
`776`	`776`	`}`
`777`	`777`
`778`	`778`	`public void testLookupExplosionManyMatchesExpression() throws IOException {`
`779`		`- // 1500, 10000 is enough locally, but some CI machines need more.`
`780`	`779`	`int lookupEntries = 10000;`
`781`	`780`	`assertCircuitBreaks(attempt -> lookupExplosion(attempt * 1500, lookupEntries, 1, lookupEntries, true));`
`782`	`781`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`
`8`	`8`	`package org.elasticsearch.xpack.esql.analysis;`
`9`	`9`
	`10`	`+import org.elasticsearch.xpack.esql.VerificationException;`
`10`	`11`	`import org.elasticsearch.xpack.esql.core.expression.Attribute;`
`11`	`12`	`import org.elasticsearch.xpack.esql.core.expression.UnresolvedAttribute;`
`12`	`13`	`import org.elasticsearch.xpack.esql.plan.logical.LogicalPlan;`
`@@ -116,7 +117,6 @@ public static List<Attribute> maybeResolveAgainstList(`
`116`	`117`	`int colDiff = a.sourceLocation().getColumnNumber() - b.sourceLocation().getColumnNumber();`
`117`	`118`	`return lineDiff != 0 ? lineDiff : (colDiff != 0 ? colDiff : a.name().compareTo(b.name()));`
`118`	`119`	`}).map(a -> "line " + a.sourceLocation().toString().substring(1) + " [" + a.name() + "]").toList();`
`119`		`-`
`120`		`- throw new IllegalStateException("Reference [" + ua.name() + "] is ambiguous; " + "matches any of " + refs);`
	`120`	`+ throw new VerificationException("Found ambiguous reference to [" + ua.name() + "]; " + "matches any of " + refs);`
`121`	`121`	`}`
`122`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -337,7 +337,7 @@ public void writeTo(StreamOutput out) throws IOException {`
`337`	`337`	`planOut.writeOptionalNamedWriteable(joinOnConditions);`
`338`	`338`	`} else {`
`339`	`339`	`if (joinOnConditions != null) {`
`340`		`- throw new EsqlIllegalArgumentException("LOOKUP JOIN with ON conditions is not supported on remote node");`
	`340`	`+ throw new IllegalArgumentException("LOOKUP JOIN with ON conditions is not supported on remote node");`
`341`	`341`	`}`
`342`	`342`	`}`
`343`	`343`	`}`
Original file line number	Diff line number	Diff line change
`@@ -733,7 +733,7 @@ private JoinInfo processFieldBasedJoin(List<Expression> expressions) {`
`733`	`733`	`} else {`
`734`	`734`	`throw new ParsingException(`
`735`	`735`	`f.source(),`
`736`		`- "JOIN ON clause must be a comma separated list of fields or a single expression found [{}]",`
	`736`	`+ "JOIN ON clause must be a comma separated list of fields or a single expression, found [{}]",`
`737`	`737`	`f.sourceText()`
`738`	`738`	`);`
`739`	`739`	`}`
Original file line number	Diff line number	Diff line change
`@@ -455,6 +455,7 @@ protected MapMatcher extendStatusMatcher(MapMatcher mapMatcher, List<Page> input`
`455`	`455`
`456`	`456`	`@Override`
`457`	`457`	`public void testSimpleCircuitBreaking() {`
	`458`	`+ // only test field based join and EQ to prevents timeouts in Ci`
`458`	`459`	`if (operation == null \|\| operation.equals(EsqlBinaryComparison.BinaryComparisonOperation.EQ)) {`
`459`	`460`	`super.testSimpleCircuitBreaking();`
`460`	`461`	`}`