expectedToStringOfSimple() {
StringBuilder sb = new StringBuilder();
- sb.append("LookupOperator\\[index=idx load_fields=\\[lkwd\\{r}#\\d+, lint\\{r}#\\d+]");
+ sb.append("LookupOperator\\[index=idx load_fields=\\[lkwd\\{r}#\\d+, lint\\{r}#\\d+] ");
for (int i = 0; i < numberOfJoinColumns; i++) {
- sb.append(" input_type=LONG match_field=match").append(i).append(" inputChannel=").append(i);
+ sb.append("input_type=LONG match_field=match").append(i).append(" inputChannel=").append(i).append(" ");
}
- sb.append("]");
+ // Accept either the legacy physical plan rendering (FilterExec/EsQueryExec) or the new FragmentExec rendering
+ sb.append("right_pre_join_plan=(?:");
+ // Legacy pattern
+ sb.append("FilterExec\\[lint\\{f}#\\d+ < ")
+ .append(LESS_THAN_VALUE)
+ .append(
+ "\\[INTEGER]]\\n\\\\_EsQueryExec\\[test], indexMode\\[lookup],\\s*(?:query\\[\\]|\\[\\])?,?\\s*"
+ + "limit\\[\\],?\\s*sort\\[(?:\\[\\])?\\]\\s*estimatedRowSize\\[null\\]\\s*queryBuilderAndTags \\[(?:\\[\\]\\])\\]"
+ );
+ sb.append("|");
+ // New FragmentExec pattern - match the actual output format
+ sb.append("FragmentExec\\[filter=null, estimatedRowSize=\\d+, reducer=\\[\\], fragment=\\[<>\\n")
+ .append("Filter\\[lint\\{f}#\\d+ < ")
+ .append(LESS_THAN_VALUE)
+ .append("\\[INTEGER]]\\n")
+ .append("\\\\_EsRelation\\[test]\\[LOOKUP]\\[\\]<>\\]\\]");
+ sb.append(")");
+ sb.append(" join_on_expression=null\\]");
return matchesPattern(sb.toString());
}
private LookupFromIndexService lookupService(DriverContext mainContext) {
boolean beCranky = mainContext.bigArrays().breakerService() instanceof CrankyCircuitBreakerService;
DiscoveryNode localNode = DiscoveryNodeUtils.create("node", "node");
+ var builtInClusterSettings = new HashSet<>(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+ builtInClusterSettings.addAll(EsqlFlags.ALL_ESQL_FLAGS_SETTINGS);
ClusterService clusterService = ClusterServiceUtils.createClusterService(
threadPool,
localNode,
@@ -202,7 +268,7 @@ private LookupFromIndexService lookupService(DriverContext mainContext) {
.put(BlockFactory.LOCAL_BREAKER_OVER_RESERVED_SIZE_SETTING, ByteSizeValue.ofKb(0))
.put(BlockFactory.LOCAL_BREAKER_OVER_RESERVED_MAX_SIZE_SETTING, ByteSizeValue.ofKb(0))
.build(),
- ClusterSettings.createBuiltInClusterSettings()
+ new ClusterSettings(Settings.EMPTY, builtInClusterSettings)
);
IndicesService indicesService = mock(IndicesService.class);
IndexNameExpressionResolver indexNameExpressionResolver = TestIndexNameExpressionResolver.newInstance();
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LocalPhysicalPlanOptimizerTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LocalPhysicalPlanOptimizerTests.java
index 9b161388d6cc3..a8f8b1e696ae6 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LocalPhysicalPlanOptimizerTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LocalPhysicalPlanOptimizerTests.java
@@ -74,6 +74,7 @@
import org.elasticsearch.xpack.esql.optimizer.rules.logical.ExtractAggregateCommonFilter;
import org.elasticsearch.xpack.esql.parser.ParsingException;
import org.elasticsearch.xpack.esql.plan.logical.Enrich;
+import org.elasticsearch.xpack.esql.plan.logical.EsRelation;
import org.elasticsearch.xpack.esql.plan.logical.LogicalPlan;
import org.elasticsearch.xpack.esql.plan.physical.AggregateExec;
import org.elasticsearch.xpack.esql.plan.physical.DissectExec;
@@ -85,6 +86,7 @@
import org.elasticsearch.xpack.esql.plan.physical.ExchangeExec;
import org.elasticsearch.xpack.esql.plan.physical.FieldExtractExec;
import org.elasticsearch.xpack.esql.plan.physical.FilterExec;
+import org.elasticsearch.xpack.esql.plan.physical.FragmentExec;
import org.elasticsearch.xpack.esql.plan.physical.GrokExec;
import org.elasticsearch.xpack.esql.plan.physical.LimitExec;
import org.elasticsearch.xpack.esql.plan.physical.LocalSourceExec;
@@ -1030,21 +1032,23 @@ public void testMissingFieldsPurgesTheJoinLocallyThroughCommands() {
}
/*
- * LimitExec[1000[INTEGER]]
+ * LimitExec[1000[INTEGER],12]
* \_AggregateExec[[language_code{r}#12],[COUNT(emp_no{r}#31,true[BOOLEAN]) AS c#17, language_code{r}#12],FINAL,[language_code{r}#12
* , $$c$count{r}#32, $$c$seen{r}#33],12]
* \_ExchangeExec[[language_code{r}#12, $$c$count{r}#32, $$c$seen{r}#33],true]
* \_AggregateExec[[language_code{r}#12],[COUNT(emp_no{r}#31,true[BOOLEAN]) AS c#17, language_code{r}#12],INITIAL,[language_code{r}#
- * 12, $$c$count{r}#34, $$c$seen{r}#35],12]
+ * 12, $$c$count{r}#34, $$c$seen{r}#35],12]
* \_LookupJoinExec[[language_code{r}#12],[language_code{f}#29],[]]
- * |_GrokExec[first_name{f}#19,Parser[pattern=%{NUMBER:language_code:int}, grok=org.elasticsearch.grok.Grok@764e5109],[languag
- * e_code{r}#12]]
+ * |_GrokExec[first_name{f}#19,Parser[pattern=%{NUMBER:language_code:int}, grok=org.elasticsearch.grok.Grok@177d8fd5],[languag
+ * e_code{r}#12]]
* | \_MvExpandExec[emp_no{f}#18,emp_no{r}#31]
* | \_ProjectExec[[emp_no{f}#18, languages{r}#21 AS language_code#7, first_name{f}#19]]
* | \_FieldExtractExec[emp_no{f}#18, first_name{f}#19]<[],[]>
* | \_EvalExec[[null[INTEGER] AS languages#21]]
- * | \_EsQueryExec[test], indexMode[standard], query[][_doc{f}#36], limit[], sort[] estimatedRowSize[66]
- * \_EsQueryExec[languages_lookup], indexMode[lookup], query[][_doc{f}#37], limit[], sort[] estimatedRowSize[4]
+ * | \_EsQueryExec[test], indexMode[standard], [_doc{f}#36], limit[], sort[] estimatedRowSize[66]
+ * queryBuilderAndTags [[QueryBuilderAndTags{queryBuilder=[null], tags=[]}]]
+ * \_FragmentExec[filter=null, estimatedRowSize=0, reducer=[], fragment=[<>
+ * EsRelation[languages_lookup][LOOKUP][language_code{f}#29]<>]]
*/
public void testMissingFieldsNotPurgingTheJoinLocally() {
var stats = EsqlTestUtils.statsForMissingField("languages");
@@ -1072,22 +1076,26 @@ public void testMissingFieldsNotPurgingTheJoinLocally() {
var extract = as(project.child(), FieldExtractExec.class);
var eval = as(extract.child(), EvalExec.class);
var source = as(eval.child(), EsQueryExec.class);
- var right = as(join.right(), EsQueryExec.class);
+ var right = as(join.right(), FragmentExec.class);
+ var relation = as(right.fragment(), EsRelation.class);
}
/*
- * LimitExec[1000[INTEGER]]
+ * LimitExec[1000[INTEGER],62]
* \_LookupJoinExec[[language_code{r}#6],[language_code{f}#23],[language_name{f}#24]]
- * |_LimitExec[1000[INTEGER]]
+ * |_LimitExec[1000[INTEGER],12]
* | \_AggregateExec[[languages{f}#15],[COUNT(emp_no{f}#12,true[BOOLEAN]) AS c#10, languages{f}#15 AS language_code#6],FINAL,[language
- * s{f}#15, $$c$count{r}#25, $$c$seen{r}#26],62]
+ * s{f}#15, $$c$count{r}#25, $$c$seen{r}#26],62]
* | \_ExchangeExec[[languages{f}#15, $$c$count{r}#25, $$c$seen{r}#26],true]
* | \_AggregateExec[[languages{r}#15],[COUNT(emp_no{f}#12,true[BOOLEAN]) AS c#10, languages{r}#15 AS language_code#6],INITIAL,
- * [languages{r}#15, $$c$count{r}#27, $$c$seen{r}#28],12]
+ * [languages{r}#15, $$c$count{r}#27, $$c$seen{r}#28],12]
+ * ges{r}#15, $$c$count{r}#27, $$c$seen{r}#28],12]
* | \_FieldExtractExec[emp_no{f}#12]<[],[]>
* | \_EvalExec[[null[INTEGER] AS languages#15]]
- * | \_EsQueryExec[test], indexMode[standard], query[][_doc{f}#29], limit[], sort[] estimatedRowSize[12]
- * \_EsQueryExec[languages_lookup], indexMode[lookup], query[][_doc{f}#30], limit[], sort[] estimatedRowSize[4]
+ * | \_EsQueryExec[test], indexMode[standard], [_doc{f}#29], limit[], sort[] estimatedRowSize[12]
+ * queryBuilderAndTags [[QueryBuilderAndTags{queryBuilder=[null], tags=[]}]]
+ * \_FragmentExec[filter=null, estimatedRowSize=0, reducer=[], fragment=[<>
+ * EsRelation[languages_lookup][LOOKUP][language_code{f}#23, language_name{f}#24]<>]]
*/
public void testMissingFieldsDoesNotPurgeTheJoinOnCoordinator() {
var stats = EsqlTestUtils.statsForMissingField("languages");
@@ -1118,9 +1126,10 @@ public void testMissingFieldsDoesNotPurgeTheJoinOnCoordinator() {
assertThat(source.indexPattern(), is("test"));
assertThat(source.indexMode(), is(IndexMode.STANDARD));
- source = as(join.right(), EsQueryExec.class);
- assertThat(source.indexPattern(), is("languages_lookup"));
- assertThat(source.indexMode(), is(IndexMode.LOOKUP));
+ var right = as(join.right(), FragmentExec.class);
+ var relation = as(right.fragment(), EsRelation.class);
+ assertThat(relation.indexPattern(), is("languages_lookup"));
+ assertThat(relation.indexMode(), is(IndexMode.LOOKUP));
}
/*
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
index c8a64f779ab4a..790f4b1a9d279 100644
--- 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
@@ -1032,10 +1032,10 @@ public void testPushdownLimitsPastLeftJoin() {
var rightChild = new LocalRelation(Source.EMPTY, List.of(fieldAttribute()), EmptyLocalSupplier.EMPTY);
assertNotEquals(leftChild, rightChild);
- var joinConfig = new JoinConfig(JoinTypes.LEFT, List.of(), List.of(), List.of());
+ var joinConfig = new JoinConfig(JoinTypes.LEFT, List.of(), List.of(), List.of(), null);
var join = switch (randomIntBetween(0, 2)) {
case 0 -> new Join(EMPTY, leftChild, rightChild, joinConfig);
- case 1 -> new LookupJoin(EMPTY, leftChild, rightChild, joinConfig);
+ case 1 -> new LookupJoin(EMPTY, leftChild, rightChild, joinConfig, false);
case 2 -> new InlineJoin(EMPTY, leftChild, rightChild, joinConfig);
default -> throw new IllegalArgumentException();
};
@@ -7003,13 +7003,14 @@ public void testLookupJoinPushDownFilterOnLeftSideField() {
* Expects
*
* {@code
- * Project[[_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, gender{f}#9, hire_date{f}#14, job{f}#15, job.raw{f}#16,
- * languages{f}#10 AS language_code#4, last_name{f}#11, long_noidx{f}#17, salary{f}#12, language_name{f}#19]]
+ * Project[[_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, gender{f}#9, hire_date{f}#14, job{f}#15, job.raw{f}#16, languages
+ * {f}#10 AS language_code#4, last_name{f}#11, long_noidx{f}#17, salary{f}#12, language_name{f}#19]]
* \_Limit[1000[INTEGER],false]
- * \_Filter[language_name{f}#19 == [45 6e 67 6c 69 73 68][KEYWORD]]
- * \_Join[LEFT,[languages{f}#10],[languages{f}#10],[language_code{f}#18]]
+ * \_Filter[language_name{f}#19 == English[KEYWORD]]
+ * \_Join[LEFT,[languages{f}#10],[languages{f}#10],[language_code{f}#18],false]
* |_EsRelation[test][_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, ge..]
- * \_EsRelation[languages_lookup][LOOKUP][language_code{f}#18, language_name{f}#19]
+ * \_Filter[language_name{f}#19 == English[KEYWORD]]
+ * \_EsRelation[languages_lookup][LOOKUP][language_code{f}#18, language_name{f}#19]
* }
*/
public void testLookupJoinPushDownDisabledForLookupField() {
@@ -7038,7 +7039,10 @@ public void testLookupJoinPushDownDisabledForLookupField() {
assertThat(join.config().type(), equalTo(JoinTypes.LEFT));
var leftRel = as(join.left(), EsRelation.class);
- var rightRel = as(join.right(), EsRelation.class);
+ var rightFilter = as(join.right(), Filter.class);
+ assertEquals("language_name == \"English\"", rightFilter.condition().toString());
+ var joinRightEsRelation = as(rightFilter.child(), EsRelation.class);
+
}
/**
@@ -7047,14 +7051,15 @@ public void testLookupJoinPushDownDisabledForLookupField() {
* Expects
*
* {@code
- * Project[[_meta_field{f}#14, emp_no{f}#8, first_name{f}#9, gender{f}#10, hire_date{f}#15, job{f}#16, job.raw{f}#17,
- * languages{f}#11 AS language_code#4, last_name{f}#12, long_noidx{f}#18, salary{f}#13, language_name{f}#20]]
+ * Project[[_meta_field{f}#14, emp_no{f}#8, first_name{f}#9, gender{f}#10, hire_date{f}#15, job{f}#16, job.raw{f}#17, languages
+ * {f}#11 AS language_code#4, last_name{f}#12, long_noidx{f}#18, salary{f}#13, language_name{f}#20]]
* \_Limit[1000[INTEGER],false]
- * \_Filter[language_name{f}#20 == [45 6e 67 6c 69 73 68][KEYWORD]]
- * \_Join[LEFT,[languages{f}#11],[languages{f}#11],[language_code{f}#19]]
+ * \_Filter[language_name{f}#20 == English[KEYWORD]]
+ * \_Join[LEFT,[languages{f}#11],[languages{f}#11],[language_code{f}#19],false]
* |_Filter[emp_no{f}#8 > 1[INTEGER]]
* | \_EsRelation[test][_meta_field{f}#14, emp_no{f}#8, first_name{f}#9, ge..]
- * \_EsRelation[languages_lookup][LOOKUP][language_code{f}#19, language_name{f}#20]
+ * \_Filter[language_name{f}#20 == English[KEYWORD]]
+ * \_EsRelation[languages_lookup][LOOKUP][language_code{f}#19, language_name{f}#20]
* }
*/
public void testLookupJoinPushDownSeparatedForConjunctionBetweenLeftAndRightField() {
@@ -7091,7 +7096,9 @@ public void testLookupJoinPushDownSeparatedForConjunctionBetweenLeftAndRightFiel
assertThat(literal.value(), equalTo(1));
var leftRel = as(filter.child(), EsRelation.class);
- var rightRel = as(join.right(), EsRelation.class);
+ var rightFilter = as(join.right(), Filter.class);
+ assertEquals("language_name == \"English\"", rightFilter.condition().toString());
+ var rightRel = as(rightFilter.child(), 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
index f3d1107983628..250481f06d3f8 100644
--- 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
@@ -9,41 +9,56 @@
import org.elasticsearch.index.IndexMode;
import org.elasticsearch.index.query.QueryBuilder;
-import org.elasticsearch.test.ESTestCase;
import org.elasticsearch.xpack.esql.core.expression.Alias;
import org.elasticsearch.xpack.esql.core.expression.Attribute;
import org.elasticsearch.xpack.esql.core.expression.Expression;
import org.elasticsearch.xpack.esql.core.expression.FieldAttribute;
+import org.elasticsearch.xpack.esql.core.expression.FoldContext;
import org.elasticsearch.xpack.esql.core.expression.MetadataAttribute;
import org.elasticsearch.xpack.esql.core.type.DataType;
import org.elasticsearch.xpack.esql.expression.function.aggregate.Count;
import org.elasticsearch.xpack.esql.expression.function.fulltext.Match;
import org.elasticsearch.xpack.esql.expression.function.scalar.math.Pow;
+import org.elasticsearch.xpack.esql.expression.function.scalar.nulls.Coalesce;
import org.elasticsearch.xpack.esql.expression.function.scalar.string.regex.RLike;
import org.elasticsearch.xpack.esql.expression.function.scalar.string.regex.WildcardLike;
import org.elasticsearch.xpack.esql.expression.predicate.Predicates;
import org.elasticsearch.xpack.esql.expression.predicate.logical.And;
+import org.elasticsearch.xpack.esql.expression.predicate.logical.Not;
+import org.elasticsearch.xpack.esql.expression.predicate.logical.Or;
+import org.elasticsearch.xpack.esql.expression.predicate.nulls.IsNull;
+import org.elasticsearch.xpack.esql.expression.predicate.operator.comparison.Equals;
import org.elasticsearch.xpack.esql.expression.predicate.operator.comparison.GreaterThan;
import org.elasticsearch.xpack.esql.expression.predicate.operator.comparison.GreaterThanOrEqual;
import org.elasticsearch.xpack.esql.expression.predicate.operator.comparison.LessThan;
+import org.elasticsearch.xpack.esql.optimizer.AbstractLogicalPlanOptimizerTests;
+import org.elasticsearch.xpack.esql.optimizer.LogicalOptimizerContext;
import org.elasticsearch.xpack.esql.plan.logical.Aggregate;
import org.elasticsearch.xpack.esql.plan.logical.EsRelation;
import org.elasticsearch.xpack.esql.plan.logical.Eval;
import org.elasticsearch.xpack.esql.plan.logical.Filter;
+import org.elasticsearch.xpack.esql.plan.logical.Limit;
import org.elasticsearch.xpack.esql.plan.logical.LogicalPlan;
import org.elasticsearch.xpack.esql.plan.logical.Project;
import org.elasticsearch.xpack.esql.plan.logical.inference.Completion;
import org.elasticsearch.xpack.esql.plan.logical.inference.Rerank;
+import org.elasticsearch.xpack.esql.plan.logical.join.Join;
+import org.elasticsearch.xpack.esql.plan.logical.join.JoinConfig;
+import org.elasticsearch.xpack.esql.plan.logical.join.JoinTypes;
import org.elasticsearch.xpack.esql.plan.logical.local.EsqlProject;
import java.util.ArrayList;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import static java.util.Collections.emptyList;
import static java.util.Collections.singletonList;
+import static org.elasticsearch.xpack.esql.EsqlTestUtils.FIVE;
import static org.elasticsearch.xpack.esql.EsqlTestUtils.FOUR;
import static org.elasticsearch.xpack.esql.EsqlTestUtils.ONE;
+import static org.elasticsearch.xpack.esql.EsqlTestUtils.SIX;
import static org.elasticsearch.xpack.esql.EsqlTestUtils.THREE;
import static org.elasticsearch.xpack.esql.EsqlTestUtils.TWO;
import static org.elasticsearch.xpack.esql.EsqlTestUtils.as;
@@ -56,9 +71,13 @@
import static org.elasticsearch.xpack.esql.EsqlTestUtils.rlike;
import static org.elasticsearch.xpack.esql.EsqlTestUtils.wildcardLike;
import static org.elasticsearch.xpack.esql.core.tree.Source.EMPTY;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
import static org.mockito.Mockito.mock;
-public class PushDownAndCombineFiltersTests extends ESTestCase {
+public class PushDownAndCombineFiltersTests extends AbstractLogicalPlanOptimizerTests {
+
+ private final LogicalOptimizerContext optimizerContext = new LogicalOptimizerContext(null, FoldContext.small());
public void testCombineFilters() {
EsRelation relation = relation();
@@ -68,7 +87,10 @@ public void testCombineFilters() {
Filter fa = new Filter(EMPTY, relation, conditionA);
Filter fb = new Filter(EMPTY, fa, conditionB);
- assertEquals(new Filter(EMPTY, relation, new And(EMPTY, conditionA, conditionB)), new PushDownAndCombineFilters().apply(fb));
+ assertEquals(
+ new Filter(EMPTY, relation, new And(EMPTY, conditionA, conditionB)),
+ new PushDownAndCombineFilters().apply(fb, optimizerContext)
+ );
}
public void testCombineFiltersLikeRLike() {
@@ -79,7 +101,10 @@ public void testCombineFiltersLikeRLike() {
Filter fa = new Filter(EMPTY, relation, conditionA);
Filter fb = new Filter(EMPTY, fa, conditionB);
- assertEquals(new Filter(EMPTY, relation, new And(EMPTY, conditionA, conditionB)), new PushDownAndCombineFilters().apply(fb));
+ assertEquals(
+ new Filter(EMPTY, relation, new And(EMPTY, conditionA, conditionB)),
+ new PushDownAndCombineFilters().apply(fb, optimizerContext)
+ );
}
public void testPushDownFilter() {
@@ -93,7 +118,7 @@ public void testPushDownFilter() {
Filter fb = new Filter(EMPTY, keep, conditionB);
Filter combinedFilter = new Filter(EMPTY, relation, new And(EMPTY, conditionA, conditionB));
- assertEquals(new EsqlProject(EMPTY, combinedFilter, projections), new PushDownAndCombineFilters().apply(fb));
+ assertEquals(new EsqlProject(EMPTY, combinedFilter, projections), new PushDownAndCombineFilters().apply(fb, optimizerContext));
}
public void testPushDownFilterPastRenamingProject() {
@@ -111,7 +136,7 @@ public void testPushDownFilterPastRenamingProject() {
LessThan bRenamedLessThanTwo = lessThanOf(bRenamed.toAttribute(), TWO);
Filter filter = new Filter(EMPTY, project, Predicates.combineAnd(List.of(aRenamedTwiceGreaterThanOne, bRenamedLessThanTwo)));
- LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
Project optimizedProject = as(optimized, Project.class);
assertEquals(optimizedProject.projections(), project.projections());
@@ -184,7 +209,7 @@ public void testPushDownFilterOnAliasInEval() {
Filter filter = new Filter(EMPTY, eval, Predicates.combineAnd(conditions));
- LogicalPlan plan = new PushDownAndCombineFilters().apply(filter);
+ LogicalPlan plan = new PushDownAndCombineFilters().apply(filter, optimizerContext);
if (numNonPushable > 0) {
Filter optimizedFilter = as(plan, Filter.class);
@@ -216,7 +241,7 @@ public void testPushDownLikeRlikeFilter() {
Filter fb = new Filter(EMPTY, keep, conditionB);
Filter combinedFilter = new Filter(EMPTY, relation, new And(EMPTY, conditionA, conditionB));
- assertEquals(new EsqlProject(EMPTY, combinedFilter, projections), new PushDownAndCombineFilters().apply(fb));
+ assertEquals(new EsqlProject(EMPTY, combinedFilter, projections), new PushDownAndCombineFilters().apply(fb, optimizerContext));
}
// from ... | where a > 1 | stats count(1) by b | where count(1) >= 3 and b < 2
@@ -244,7 +269,7 @@ public void testSelectivelyPushDownFilterPastFunctionAgg() {
),
aggregateCondition
);
- assertEquals(expected, new PushDownAndCombineFilters().apply(fb));
+ assertEquals(expected, new PushDownAndCombineFilters().apply(fb, optimizerContext));
}
// from ... | where a > 1 | COMPLETION completion = "some prompt" WITH { "inferenceId' : "inferenceId" } | where b < 2 and
@@ -284,7 +309,7 @@ public void testPushDownFilterPastCompletion() {
conditionCompletion
);
- assertEquals(expectedOptimizedPlan, new PushDownAndCombineFilters().apply(filterB));
+ assertEquals(expectedOptimizedPlan, new PushDownAndCombineFilters().apply(filterB, optimizerContext));
}
// from ... | where a > 1 | RERANK "query" ON title WITH { "inference_id" : "inferenceId" } | where b < 2 and _score > 1
@@ -317,7 +342,7 @@ public void testPushDownFilterPastRerank() {
scoreCondition
);
- assertEquals(expectedOptimizedPlan, new PushDownAndCombineFilters().apply(filterB));
+ assertEquals(expectedOptimizedPlan, new PushDownAndCombineFilters().apply(filterB, optimizerContext));
}
private static Completion completion(LogicalPlan child) {
@@ -348,4 +373,471 @@ private static EsRelation relation() {
private static EsRelation relation(List fieldAttributes) {
return new EsRelation(EMPTY, randomIdentifier(), randomFrom(IndexMode.values()), Map.of(), fieldAttributes);
}
+
+ public void testPushDownFilterPastLeftJoinWithPushable() {
+ Join join = createLeftJoin();
+ EsRelation left = (EsRelation) join.left();
+ FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+ // Pushable filter
+ Expression pushableCondition = greaterThanOf(c, ONE);
+ Filter filter = new Filter(EMPTY, join, pushableCondition);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+ // The filter should still be on top
+ Filter topFilter = as(optimized, Filter.class);
+ assertEquals(pushableCondition, topFilter.condition());
+ Join optimizedJoin = as(topFilter.child(), Join.class);
+ assertEquals(left, optimizedJoin.left());
+ Filter rightFilter = as(optimizedJoin.right(), Filter.class);
+ assertEquals(pushableCondition, rightFilter.condition());
+ }
+
+ public void testPushDownFilterPastLeftJoinWithExistingFilter() {
+ Join join = createLeftJoin();
+ EsRelation left = (EsRelation) join.left();
+ FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+ // Existing filter on the right side
+ Expression existingCondition = lessThanOf(c, FIVE);
+ Filter existingFilter = new Filter(EMPTY, join.right(), existingCondition);
+ join = (Join) join.replaceRight(existingFilter);
+
+ // Pushable filter
+ Expression pushableCondition = greaterThanOf(c, ONE);
+ Filter filter = new Filter(EMPTY, join, pushableCondition);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+ // The filter should still be on top
+ Filter topFilter = as(optimized, Filter.class);
+ assertEquals(pushableCondition, topFilter.condition());
+ Join optimizedJoin = as(topFilter.child(), Join.class);
+ assertEquals(left, optimizedJoin.left());
+ Filter rightFilter = as(optimizedJoin.right(), Filter.class);
+
+ // The new condition should be merged with the existing one
+ Expression combinedCondition = new And(EMPTY, existingCondition, pushableCondition);
+ assertEquals(combinedCondition, rightFilter.condition());
+
+ // try to apply the filter again, the plan should not change
+ // this verifies that the rule is idempotent
+ // and we will not get in an infinite loop pushing the same filter over and over
+ optimized = new PushDownAndCombineFilters().apply(optimized, optimizerContext);
+
+ topFilter = as(optimized, Filter.class);
+ assertEquals(pushableCondition, topFilter.condition());
+ optimizedJoin = as(topFilter.child(), Join.class);
+ assertEquals(left, optimizedJoin.left());
+ rightFilter = as(optimizedJoin.right(), Filter.class);
+
+ // The new condition should be merged with the existing one
+ assertEquals(combinedCondition, rightFilter.condition());
+
+ }
+
+ public void testDoNotPushDownExistingFilterAgain() {
+ Join join = createLeftJoin();
+ EsRelation left = (EsRelation) join.left();
+ FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+ // Existing filter on the right side
+ Expression existingCondition = greaterThanOf(c, ONE);
+ Filter existingFilter = new Filter(EMPTY, join.right(), existingCondition);
+ join = (Join) join.replaceRight(existingFilter);
+
+ // A filter on top with the same condition
+ Filter filter = new Filter(EMPTY, join, existingCondition);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+
+ // The filter should still be on top
+ Filter topFilter = as(optimized, Filter.class);
+ assertEquals(existingCondition, topFilter.condition());
+
+ Join optimizedJoin = as(topFilter.child(), Join.class);
+ assertEquals(left, optimizedJoin.left());
+
+ // The right side should be the original filter, unchanged.
+ Filter rightFilter = as(optimizedJoin.right(), Filter.class);
+ assertEquals(existingFilter, rightFilter);
+ assertEquals(existingCondition, rightFilter.condition());
+ }
+
+ public void testPushDownFilterPastLeftJoinWithExistingFilterCalledTwice() {
+ Join join = createLeftJoin();
+ EsRelation left = (EsRelation) join.left();
+ FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+ // Pushable filter
+ Expression pushableCondition = greaterThanOf(c, ONE);
+ Filter filter = new Filter(EMPTY, join, pushableCondition);
+
+ // First optimization
+ LogicalPlan optimizedOnce = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+
+ // Second optimization
+ LogicalPlan optimizedTwice = new PushDownAndCombineFilters().apply(optimizedOnce, optimizerContext);
+
+ // The filter should still be on top
+ Filter topFilter = as(optimizedTwice, Filter.class);
+ assertEquals(pushableCondition, topFilter.condition());
+
+ Join optimizedJoin = as(topFilter.child(), Join.class);
+ assertEquals(left, optimizedJoin.left());
+
+ // The right side should have the filter, but not duplicated.
+ Filter rightFilter = as(optimizedJoin.right(), Filter.class);
+ assertEquals(pushableCondition, rightFilter.condition());
+ }
+
+ public void testPushDownFilterPastLeftJoinWithNonPushable() {
+ Join join = createLeftJoin();
+ FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+ // Non-pushable filter
+ Expression nonPushableCondition = new IsNull(EMPTY, c);
+ Filter filter = new Filter(EMPTY, join, nonPushableCondition);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+ // No optimization should be applied, the plan should be the same
+ assertEquals(filter, optimized);
+ // And the join inside should not have candidate filters
+ Join innerJoin = as(as(optimized, Filter.class).child(), Join.class);
+ assertFalse(innerJoin.right() instanceof Filter);
+ }
+
+ public void testPushDownFilterPastLeftJoinWithPartiallyPushableAnd() {
+ Join join = createLeftJoin();
+ EsRelation left = (EsRelation) join.left();
+ FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+ Expression pushableCondition = greaterThanOf(c, ONE);
+ Expression nonPushableCondition = new IsNull(EMPTY, c);
+
+ // Partially pushable filter
+ Expression partialCondition = new And(EMPTY, pushableCondition, nonPushableCondition);
+ Filter filter = new Filter(EMPTY, join, partialCondition);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+ Filter topFilter = as(optimized, Filter.class);
+ // The top filter condition should be the original one
+ assertEquals(partialCondition, topFilter.condition());
+ Join optimizedJoin = as(topFilter.child(), Join.class);
+ assertEquals(left, optimizedJoin.left());
+ Filter rightFilter = as(optimizedJoin.right(), Filter.class);
+ // Only the pushable part should be a candidate
+ assertEquals(pushableCondition, rightFilter.condition());
+ }
+
+ public void testPushDownFilterPastLeftJoinWithOr() {
+ Join join = createLeftJoin();
+ FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+ Expression pushableCondition = greaterThanOf(c, ONE);
+ Expression nonPushableCondition = new IsNull(EMPTY, c);
+
+ // OR of pushable and non-pushable filter
+ Expression orCondition = new Or(EMPTY, pushableCondition, nonPushableCondition);
+ Filter filter = new Filter(EMPTY, join, orCondition);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+ // No optimization should be applied, the plan should be the same
+ assertEquals(filter, optimized);
+ // And the join inside should not have candidate filters
+ Join innerJoin = as(filter.child(), Join.class);
+ assertFalse(innerJoin.right() instanceof Filter);
+ }
+
+ public void testPushDownFilterPastLeftJoinWithNotButStillPushable() {
+ Join join = createLeftJoin();
+ FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+ Expression pushableCondition = greaterThanOf(c, ONE);
+
+ // negation of pushable filter, in this case it remains pushable
+ Expression negationOfPushableCondition = new Not(EMPTY, pushableCondition);
+ Filter filter = new Filter(EMPTY, join, negationOfPushableCondition);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+ Filter topFilter = as(optimized, Filter.class);
+ assertEquals(negationOfPushableCondition, topFilter.condition());
+ Join optimizedJoin = as(topFilter.child(), Join.class);
+ Filter rightFilter = as(optimizedJoin.right(), Filter.class);
+ assertEquals(negationOfPushableCondition, rightFilter.condition());
+ }
+
+ public void testPushDownFilterPastLeftJoinWithNotNonPushable() {
+ Join join = createLeftJoin();
+ FieldAttribute c = (FieldAttribute) join.right().output().get(0);
+
+ Expression nonPushableCondition = new IsNull(EMPTY, c);
+
+ // negation of non-pushable filter makes it pushable
+ Expression negationOfNonPushableCondition = new Not(EMPTY, nonPushableCondition);
+ Filter filter = new Filter(EMPTY, join, negationOfNonPushableCondition);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+ Filter topFilter = as(optimized, Filter.class);
+ assertEquals(negationOfNonPushableCondition, topFilter.condition());
+ Join optimizedJoin = as(topFilter.child(), Join.class);
+ Filter rightFilter = as(optimizedJoin.right(), Filter.class);
+ assertEquals(negationOfNonPushableCondition, rightFilter.condition());
+ }
+
+ public void testPushDownFilterPastLeftJoinWithComplexMix() {
+ // Setup
+ FieldAttribute a = getFieldAttribute("a");
+ FieldAttribute c = getFieldAttribute("c");
+ FieldAttribute d = getFieldAttribute("d");
+ FieldAttribute e = getFieldAttribute("e");
+ FieldAttribute f = getFieldAttribute("f");
+ FieldAttribute g = getFieldAttribute("g");
+ EsRelation left = relation(List.of(a, getFieldAttribute("b")));
+ EsRelation right = relation(List.of(c, d, e, f, g));
+ JoinConfig joinConfig = new JoinConfig(JoinTypes.LEFT, List.of(a), List.of(a), List.of(c), null);
+ Join join = new Join(EMPTY, left, right, joinConfig);
+
+ // Predicates
+ Expression p1 = greaterThanOf(c, ONE); // pushable
+ Expression p2 = new Not(EMPTY, new IsNull(EMPTY, d)); // pushable (d IS NOT NULL)
+ Expression p3 = lessThanOf(e, THREE); // pushable
+ Expression p4 = rlike(f, "pat"); // pushable
+ Expression p5 = new Not(EMPTY, new IsNull(EMPTY, g)); // pushable (g IS NOT NULL)
+ Expression p6 = greaterThanOf(c, TWO); // pushable
+ Expression p7 = lessThanOf(d, FOUR); // pushable
+ Expression p8 = greaterThanOf(e, FIVE); // pushable
+
+ Expression np1 = new IsNull(EMPTY, c); // non-pushable (c IS NULL)
+ Expression np2 = new Equals(EMPTY, new Coalesce(EMPTY, d, List.of(SIX)), SIX); // non-pushable
+
+ // Build a complex condition
+ // np2 AND ((p1 AND p2 AND p3 AND p4 AND p5) AND (np1 OR (p6 AND p7) OR (p8 AND np2))) AND p1 AND p6
+ Expression pushableBranch = Predicates.combineAnd(List.of(p1, p2, p3, p4, p5));
+ Expression nonPushableBranch = new Or(EMPTY, np1, new Or(EMPTY, new And(EMPTY, p6, p7), new And(EMPTY, p8, np2)));
+ Expression complexCondition = new And(EMPTY, pushableBranch, nonPushableBranch);
+ complexCondition = Predicates.combineAnd(List.of(np2, complexCondition, p1, p6));
+
+ Filter filter = new Filter(EMPTY, join, complexCondition);
+ LogicalPlan optimized = new PushDownAndCombineFilters().apply(filter, optimizerContext);
+
+ // The top filter with the original condition should remain, but the structure of the AND tree might have changed.
+ // So, we flatten the conditions and compare them as a set.
+ Filter topFilter = as(optimized, Filter.class);
+ Set actualTopPredicates = new HashSet<>(Predicates.splitAnd(topFilter.condition()));
+ Set expectedTopPredicates = new HashSet<>(List.of(p1, p2, p3, p4, p5, nonPushableBranch, np2, p1, p6));
+ assertEquals(expectedTopPredicates, actualTopPredicates);
+
+ // The pushable part of the filter should be added as a candidate to the join
+ Join optimizedJoin = as(topFilter.child(), Join.class);
+ assertEquals(left, optimizedJoin.left());
+ Filter rightFilter = as(optimizedJoin.right(), Filter.class);
+ Set actualPushable = new HashSet<>(Predicates.splitAnd(rightFilter.condition()));
+ Set expectedPushable = new HashSet<>(List.of(p1, p2, p3, p4, p5, p6));
+ assertEquals(expectedPushable, actualPushable);
+ }
+
+ /**
+ * Project[[_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, gender{f}#9, hire_date{f}#14, job{f}#15, job.raw{f}#16, languages
+ * {f}#10 AS language_code#4, last_name{f}#11, long_noidx{f}#17, salary{f}#12, language_name{f}#19]]
+ * \_Limit[1000[INTEGER],false]
+ * \_Filter[ISNULL(language_name{f}#19)]
+ * \_Join[LEFT,[languages{f}#10],[languages{f}#10],[language_code{f}#18]]
+ * |_EsRelation[test][_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, ge..]
+ * \_EsRelation[languages_lookup][LOOKUP][language_code{f}#18, language_name{f}#19]
+ */
+ public void testDoNotPushDownIsNullFilterPastLookupJoin() {
+ var plan = plan("""
+ FROM test
+ | RENAME languages AS language_code
+ | LOOKUP JOIN languages_lookup ON language_code
+ | WHERE language_name IS NULL
+ """);
+
+ var project = as(plan, Project.class);
+ var limit = as(project.child(), Limit.class);
+ var filter = as(limit.child(), Filter.class);
+ var join = as(filter.child(), Join.class);
+ assertThat(join.right(), instanceOf(EsRelation.class));
+ }
+
+ /**
+ * Project[[_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, gender{f}#9, hire_date{f}#14, job{f}#15, job.raw{f}#16, languages
+ * {f}#10 AS language_code#4, last_name{f}#11, long_noidx{f}#17, salary{f}#12, language_name{f}#19]]
+ * \_Limit[1000[INTEGER],false]
+ * \_Filter[language_name{f}#19 > a[KEYWORD]]
+ * \_Join[LEFT,[languages{f}#10],[languages{f}#10],[language_code{f}#18],false]
+ * |_EsRelation[test][_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, ge..]
+ * \_Filter[language_name{f}#19 > a[KEYWORD]]
+ * \_EsRelation[languages_lookup][LOOKUP][language_code{f}#18, language_name{f}#19]
+ */
+ public void testPushDownGreaterThanFilterPastLookupJoin() {
+ var plan = plan("""
+ FROM test
+ | RENAME languages AS language_code
+ | LOOKUP JOIN languages_lookup ON language_code
+ | WHERE language_name > "a"
+ """);
+
+ var project = as(plan, Project.class);
+ var limit = as(project.child(), Limit.class);
+ var filter = as(limit.child(), Filter.class);
+ var join = as(filter.child(), Join.class);
+ var rightFilter = as(join.right(), Filter.class);
+ assertThat(rightFilter.condition().toString(), is("language_name > \"a\""));
+ }
+
+ /**
+ * Project[[_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, gender{f}#9, hire_date{f}#14, job{f}#15, job.raw{f}#16, languages
+ * {f}#10 AS language_code#4, last_name{f}#11, long_noidx{f}#17, salary{f}#12, language_name{f}#19]]
+ * \_Limit[1000[INTEGER],false]
+ * \_Filter[COALESCE(language_name{f}#19,a[KEYWORD]) == a[KEYWORD]]
+ * \_Join[LEFT,[languages{f}#10],[languages{f}#10],[language_code{f}#18]]
+ * |_EsRelation[test][_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, ge..]
+ * \_EsRelation[languages_lookup][LOOKUP][language_code{f}#18, language_name{f}#19]
+ */
+ public void testDoNotPushDownCoalesceFilterPastLookupJoin() {
+ var plan = plan("""
+ FROM test
+ | RENAME languages AS language_code
+ | LOOKUP JOIN languages_lookup ON language_code
+ | WHERE COALESCE(language_name, "a") == "a"
+ """);
+
+ var project = as(plan, Project.class);
+ var limit = as(project.child(), Limit.class);
+ var filter = as(limit.child(), Filter.class);
+ var join = as(filter.child(), Join.class);
+ assertThat(join.right(), instanceOf(EsRelation.class));
+ }
+
+ /**
+ *
+ * Project[[_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, gender{f}#9, hire_date{f}#14, job{f}#15, job.raw{f}#16, languages
+ * {f}#10 AS language_code#4, last_name{f}#11, long_noidx{f}#17, salary{f}#12, language_name{f}#19]]
+ * \_Limit[1000[INTEGER],false]
+ * \_Filter[ISNOTNULL(language_name{f}#19)]
+ * \_Join[LEFT,[languages{f}#10],[languages{f}#10],[language_code{f}#18],false]
+ * |_EsRelation[test][_meta_field{f}#13, emp_no{f}#7, first_name{f}#8, ge..]
+ * \_Filter[ISNOTNULL(language_name{f}#19)]
+ * \_EsRelation[languages_lookup][LOOKUP][language_code{f}#18, language_name{f}#19]
+ */
+ public void testPushDownIsNotNullFilterPastLookupJoin() {
+ var plan = plan("""
+ FROM test
+ | RENAME languages AS language_code
+ | LOOKUP JOIN languages_lookup ON language_code
+ | WHERE language_name IS NOT NULL
+ """);
+
+ var project = as(plan, Project.class);
+ var limit = as(project.child(), Limit.class);
+ var filter = as(limit.child(), Filter.class);
+ var join = as(filter.child(), Join.class);
+ var rightFilter = as(join.right(), Filter.class);
+ assertThat(rightFilter.condition().toString(), is("language_name IS NOT NULL"));
+ }
+
+ /**
+ * Project[[_meta_field{f}#17, emp_no{f}#11, first_name{f}#12, gender{f}#13, hire_date{f}#18, job{f}#19, job.raw{f}#20, languages
+ * {f}#14 AS language_code#4, last_name{f}#15, long_noidx{f}#21, salary{f}#16, language_name{f}#23]]
+ * \_Limit[1000[INTEGER],false]
+ * \_Filter[ISNOTNULL(language_name{f}#23) AND language_name{f}#23 > a[KEYWORD] AND LIKE(language_name{f}#23, "*b", false)
+ * AND COALESCE(language_name{f}#23,c[KEYWORD]) == c[KEYWORD] AND RLIKE(language_name{f}#23, "f.*", false)]
+ * \_Join[LEFT,[languages{f}#14],[languages{f}#14],[language_code{f}#22]]
+ * |_EsRelation[test][_meta_field{f}#17, emp_no{f}#11, first_name{f}#12, ..]
+ * \_Filter[ISNOTNULL(language_name{f}#23) AND language_name{f}#23 > a[KEYWORD] AND LIKE(language_name{f}#23, "*b", false)
+ * AND RLIKE(language_name{f}#23, "f.*", false)]
+ * \_EsRelation[languages_lookup][LOOKUP][language_code{f}#22, language_name{f}#23]
+ */
+ public void testPushDownMultipleWhere() {
+ var plan = plan("""
+ FROM test
+ | RENAME languages AS language_code
+ | LOOKUP JOIN languages_lookup ON language_code
+ | WHERE language_name IS NOT NULL
+ | WHERE language_name > "a"
+ | WHERE language_name LIKE "*b"
+ | WHERE COALESCE(language_name, "c") == "c"
+ | WHERE language_name RLIKE "f.*"
+ """);
+
+ var project = as(plan, Project.class);
+ var limit = as(project.child(), Limit.class);
+ var topFilter = as(limit.child(), Filter.class);
+
+ // Verify the top-level filter contains all 5 original conditions combined
+ Set expectedAllFilters = Set.of(
+ "language_name IS NOT NULL",
+ "language_name > \"a\"",
+ "language_name LIKE \"*b\"",
+ "COALESCE(language_name, \"c\") == \"c\"",
+ "language_name RLIKE \"f.*\""
+ );
+
+ Set actualAllFilters = new HashSet<>(Predicates.splitAnd(topFilter.condition()).stream().map(Object::toString).toList());
+ assertEquals(expectedAllFilters, actualAllFilters);
+
+ // Verify the join is below the top-level filter
+ var join = as(topFilter.child(), Join.class);
+
+ // Verify a new filter with only the pushable predicates has been pushed to the right side of the join
+ var rightFilter = as(join.right(), Filter.class);
+ Set expectedPushedFilters = Set.of(
+ "language_name IS NOT NULL",
+ "language_name > \"a\"",
+ "language_name LIKE \"*b\"",
+ "language_name RLIKE \"f.*\""
+ );
+ Set actualPushedFilters = new HashSet<>(
+ Predicates.splitAnd(rightFilter.condition()).stream().map(Object::toString).toList()
+ );
+ assertEquals(expectedPushedFilters, actualPushedFilters);
+ }
+
+ /**
+ *
+ * Project[[$$languages$temp_name$32{r$}#33 AS language_code#4, salary{f}#13, language_name{f}#20, _meta_field{f}#27, emp
+ * _no{f}#21, first_name{f}#22, gender{f}#23, hire_date{f}#28, job{f}#29, job.raw{f}#30, languages{f}#24,
+ * last_name{f}#25, long_noidx{f}#31]]
+ * \_Limit[1000[INTEGER],true]
+ * \_Join[LEFT,[salary{f}#13],[salary{f}#13],[salary{f}#26]]
+ * |_Eval[[languages{f}#11 AS $$languages$temp_name$32#33]]
+ * | \_Limit[1000[INTEGER],false]
+ * | \_Filter[language_name{f}#20 > a[KEYWORD]]
+ * | \_Join[LEFT,[languages{f}#11],[languages{f}#11],[language_code{f}#19]]
+ * | |_EsRelation[test][_meta_field{f}#14, emp_no{f}#8, first_name{f}#9, ge..]
+ * | \_Filter[language_name{f}#20 > a[KEYWORD]]
+ * | \_EsRelation[languages_lookup][LOOKUP][language_code{f}#19, language_name{f}#20]
+ * \_EsRelation[test_lookup][LOOKUP][_meta_field{f}#27, emp_no{f}#21, first_name{f}#22, ..]
+ */
+ public void testPushDownFilterPastTwoLookupJoins() {
+ var plan = plan("""
+ FROM test
+ | RENAME languages AS language_code
+ | LOOKUP JOIN languages_lookup ON language_code
+ | LOOKUP JOIN test_lookup ON salary
+ | WHERE language_name > "a"
+ """);
+
+ var project = as(plan, Project.class);
+ var limit = as(project.child(), Limit.class);
+
+ // The filter is pushed down past the top join, so a Join is now at the top of the plan after the limit
+ var topJoin = as(limit.child(), Join.class);
+ assertThat(topJoin.right(), instanceOf(EsRelation.class)); // No filter on the top lookup join's right side
+
+ // Traverse down the left side of the top join to find the filter and the bottom join
+ var eval = as(topJoin.left(), Eval.class);
+ var innerLimit = as(eval.child(), Limit.class);
+ var topFilter = as(innerLimit.child(), Filter.class);
+ assertThat(topFilter.condition().toString(), is("language_name > \"a\""));
+
+ // make sure that the filter was pushed to the right side of the bottom join
+ var bottomJoin = as(topFilter.child(), Join.class);
+ var rightFilter = as(bottomJoin.right(), Filter.class);
+ assertThat(rightFilter.condition().toString(), is("language_name > \"a\""));
+ }
+
+ private Join createLeftJoin() {
+ FieldAttribute a = getFieldAttribute("a");
+ FieldAttribute b = getFieldAttribute("b");
+ FieldAttribute c = getFieldAttribute("c");
+ EsRelation left = relation(List.of(a, b));
+ EsRelation right = relation(List.of(c, b));
+
+ JoinConfig joinConfig = new JoinConfig(JoinTypes.LEFT, List.of(b), List.of(a, b), List.of(b, c), null);
+ return new Join(EMPTY, left, right, joinConfig);
+ }
}
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
index 96f63d0d7eb81..746f74bb307be 100644
--- 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
@@ -240,6 +240,197 @@ public void testShadowingAfterPushdown2() {
assertLeftJoinConfig(join.config(), "emp_no", mainRel.outputSet(), "languages", lookupRel.outputSet());
}
+ /**
+ * EsqlProject[[languages{f}#30, emp_no{f}#27, salary{f}#32]]
+ * \_Limit[1000[INTEGER],true]
+ * \_Join[LEFT,[lang{r}#10, languages{f}#30],[lang{r}#10],[languages{f}#30],lang{r}#10 == languages{f}#30]
+ * |_EsqlProject[[_meta_field{f}#22, emp_no{f}#16, first_name{f}#17, gender{f}#18, hire_date{f}#23, job{f}#24, job.raw{f}#25,
+ * languages{f}#19 AS lang2#4, last_name{f}#20, long_noidx{f}#26, salary{f}#21, emp_no{f}#16 AS lang#10]]
+ * | \_Limit[1000[INTEGER],false]
+ * | \_EsRelation[test][_meta_field{f}#22, emp_no{f}#16, first_name{f}#17, ..]
+ * \_EsRelation[test_lookup][LOOKUP][emp_no{f}#27, languages{f}#30, salary{f}#32]
+ */
+ public void testShadowingAfterPushdownExpressionJoin() {
+ 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
+ """;
+
+ 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 project2 = as(join.left(), Project.class);
+ var limit2 = asLimit(project2.child(), 1000, false);
+ var mainRel = as(limit2.child(), EsRelation.class);
+
+ var projections = project.projections();
+ assertThat(Expressions.names(projections), contains("languages", "emp_no", "salary"));
+
+ 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 project2Projections = project2.projections();
+ var lang = as(project2Projections.stream().filter(p -> "lang".equals(p.name())).findFirst().get(), Alias.class);
+ var langAttr = lang.toAttribute();
+ var originalEmpNo = as(lang.child(), FieldAttribute.class);
+ assertEquals("emp_no", originalEmpNo.fieldName().string());
+ assertTrue(mainRel.outputSet().contains(originalEmpNo));
+
+ var joinConfig = join.config();
+ assertSame(JoinTypes.LEFT, joinConfig.type());
+ var leftKeys = joinConfig.leftFields();
+ assertEquals(1, leftKeys.size());
+ assertTrue(leftKeys.get(0).semanticEquals(langAttr));
+ var rightKeys = joinConfig.rightFields();
+ assertEquals(1, rightKeys.size());
+ assertEquals("languages", rightKeys.get(0).name());
+ assertTrue(lookupRel.outputSet().contains(rightKeys.get(0)));
+ }
+
+ /**
+ * EsqlProject[[languages{f}#24, emp_no{f}#21, salary{f}#26]]
+ * \_Limit[1000[INTEGER],true]
+ * \_Join[LEFT,[lang{r}#4, languages{f}#24],[lang{r}#4],[languages{f}#24],lang{r}#4 == languages{f}#24]
+ * |_EsqlProject[[_meta_field{f}#16, emp_no{f}#10, first_name{f}#11, gender{f}#12, hire_date{f}#17, job{f}#18, job.raw{f}#19,
+ * languages{f}#13 AS lang#4, last_name{f}#14, long_noidx{f}#20, salary{f}#15]]
+ * | \_Limit[1000[INTEGER],false]
+ * | \_EsRelation[test][_meta_field{f}#16, emp_no{f}#10, first_name{f}#11, ..]
+ * \_EsRelation[test_lookup][LOOKUP][emp_no{f}#21, languages{f}#24, salary{f}#26]
+ */
+ public void testShadowingAfterPushdownRenameExpressionJoin() {
+ assumeTrue("Requires LOOKUP JOIN", EsqlCapabilities.Cap.JOIN_LOOKUP_V12.isEnabled());
+
+ String query = """
+ FROM test_lookup
+ | RENAME languages AS lang
+ | LOOKUP JOIN test_lookup ON lang == languages
+ | KEEP languages, emp_no, salary
+ """;
+
+ 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 project2 = as(join.left(), Project.class);
+ var limit2 = asLimit(project2.child(), 1000, false);
+ var mainRel = as(limit2.child(), EsRelation.class);
+
+ var projections = project.projections();
+ assertThat(Expressions.names(projections), contains("languages", "emp_no", "salary"));
+
+ 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 project2Projections = project2.projections();
+ var lang = as(project2Projections.stream().filter(p -> "lang".equals(p.name())).findFirst().get(), Alias.class);
+ var langAttr = lang.toAttribute();
+ var originalLanguages = as(lang.child(), FieldAttribute.class);
+ assertEquals("languages", originalLanguages.fieldName().string());
+ assertTrue(mainRel.outputSet().contains(originalLanguages));
+
+ var joinConfig = join.config();
+ assertSame(JoinTypes.LEFT, joinConfig.type());
+ var leftKeys = joinConfig.leftFields();
+ assertEquals(1, leftKeys.size());
+ assertTrue(leftKeys.get(0).semanticEquals(langAttr));
+ var rightKeys = joinConfig.rightFields();
+ assertEquals(1, rightKeys.size());
+ assertEquals("languages", rightKeys.get(0).name());
+ assertTrue(lookupRel.outputSet().contains(rightKeys.get(0)));
+ }
+
+ /**
+ * EsqlProject[[languages{f}#25, emp_no{f}#22, salary{f}#27]]
+ * \_Limit[1000[INTEGER],true]
+ * \_Join[LEFT,[languages{f}#25, lang{r}#4],[lang{r}#4],[languages{f}#25],lang{r}#4 == languages{f}#25]
+ * |_EsqlProject[[_meta_field{f}#17, emp_no{f}#11, first_name{f}#12, gender{f}#13, hire_date{f}#18, job{f}#19, job.raw{f}#20, l
+ * ast_name{f}#15, long_noidx{f}#21, salary{f}#16, lang{r}#4]]
+ * | \_Eval[[languages{f}#14 + 0[INTEGER] AS lang#4]]
+ * | \_Limit[1000[INTEGER],false]
+ * | \_EsRelation[test][_meta_field{f}#17, emp_no{f}#11, first_name{f}#12, ..]
+ * \_EsRelation[test_lookup][LOOKUP][emp_no{f}#22, languages{f}#25, salary{f}#27]
+ */
+ public void testShadowingAfterPushdownEvalExpressionJoin() {
+ assumeTrue("Requires LOOKUP JOIN", EsqlCapabilities.Cap.JOIN_LOOKUP_V12.isEnabled());
+
+ String query = """
+ FROM test_lookup
+ | EVAL lang = languages + 0
+ | DROP languages
+ | LOOKUP JOIN test_lookup ON lang == languages
+ | KEEP languages, emp_no, salary
+ """;
+
+ 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 project2 = as(join.left(), Project.class);
+ var eval = as(project2.child(), 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"));
+
+ 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 lang = as(eval.fields().get(0), Alias.class);
+ var langAttr = lang.toAttribute();
+ var add = as(lang.child(), org.elasticsearch.xpack.esql.expression.predicate.operator.arithmetic.Add.class);
+ var originalLanguages = as(add.left(), FieldAttribute.class);
+ assertEquals("languages", originalLanguages.fieldName().string());
+ assertTrue(mainRel.outputSet().contains(originalLanguages));
+
+ var joinConfig = join.config();
+ assertSame(JoinTypes.LEFT, joinConfig.type());
+ var leftKeys = joinConfig.leftFields();
+ assertEquals(1, leftKeys.size());
+ assertTrue(leftKeys.get(0).semanticEquals(langAttr));
+ var rightKeys = joinConfig.rightFields();
+ assertEquals(1, rightKeys.size());
+ assertEquals("languages", rightKeys.get(0).name());
+ assertTrue(lookupRel.outputSet().contains(rightKeys.get(0)));
+ }
+
private static void assertLeftJoinConfig(
JoinConfig config,
String expectedLeftFieldName,
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/rules/physical/local/ReplaceRoundToWithQueryAndTagsTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/rules/physical/local/ReplaceRoundToWithQueryAndTagsTests.java
index 79c484c916af5..beef7ee4857a3 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/rules/physical/local/ReplaceRoundToWithQueryAndTagsTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/rules/physical/local/ReplaceRoundToWithQueryAndTagsTests.java
@@ -29,11 +29,13 @@
import org.elasticsearch.xpack.esql.expression.function.scalar.math.RoundTo;
import org.elasticsearch.xpack.esql.optimizer.LocalPhysicalPlanOptimizerTests;
import org.elasticsearch.xpack.esql.optimizer.TestPlannerOptimizer;
+import org.elasticsearch.xpack.esql.plan.logical.EsRelation;
import org.elasticsearch.xpack.esql.plan.physical.AggregateExec;
import org.elasticsearch.xpack.esql.plan.physical.EsQueryExec;
import org.elasticsearch.xpack.esql.plan.physical.EvalExec;
import org.elasticsearch.xpack.esql.plan.physical.ExchangeExec;
import org.elasticsearch.xpack.esql.plan.physical.FieldExtractExec;
+import org.elasticsearch.xpack.esql.plan.physical.FragmentExec;
import org.elasticsearch.xpack.esql.plan.physical.LimitExec;
import org.elasticsearch.xpack.esql.plan.physical.LookupJoinExec;
import org.elasticsearch.xpack.esql.plan.physical.MergeExec;
@@ -295,7 +297,24 @@ public void testDateTruncBucketTransformToQueryAndTagsWithOtherPushdownFunctions
}
}
- // ReplaceRoundToWithQueryAndTags does not support lookup joins yet
+ /**
+ * ReplaceRoundToWithQueryAndTags does not support lookup joins yet
+ * LimitExec[1000[INTEGER],16]
+ * \_AggregateExec[[x{r}#8],[COUNT(*[KEYWORD],true[BOOLEAN]) AS count(*)#9, x{r}#8],FINAL,[x{r}#8, $$count(*)$count{r}#34, $$count(*
+ * )$seen{r}#35],16]
+ * \_ExchangeExec[[x{r}#8, $$count(*)$count{r}#34, $$count(*)$seen{r}#35],true]
+ * \_AggregateExec[[x{r}#8],[COUNT(*[KEYWORD],true[BOOLEAN]) AS count(*)#9, x{r}#8],INITIAL,[x{r}#8, $$count(*)$count{r}#36, $$count
+ * (*)$seen{r}#37],16]
+ * \_EvalExec[[ROUNDTO(date{f}#15,1697760000000[DATETIME],1697846400000[DATETIME],1697932800000[DATETIME],1698019200000[DATE
+ * TIME]) AS x#8]]
+ * \_FieldExtractExec[date{f}#15]
+ * \_LookupJoinExec[[integer{f}#21],[language_code{f}#32],[]]
+ * |_FieldExtractExec[integer{f}#21]
+ * | \_EsQueryExec[test], indexMode[standard], [_doc{f}#38], limit[], sort[] estimatedRowSize[24]
+ * queryBuilderAndTags [[QueryBuilderAndTags{queryBuilder=[null], tags=[]}]]
+ * \_FragmentExec[filter=null, estimatedRowSize=0, reducer=[], fragment=[
+ * EsRelation[languages_lookup][LOOKUP][language_code{f}#32]]]
+ */
public void testDateTruncBucketNotTransformToQueryAndTagsWithLookupJoin() {
for (String dateHistogram : dateHistograms) {
String query = LoggerMessageFormat.format(null, """
@@ -341,14 +360,9 @@ public void testDateTruncBucketNotTransformToQueryAndTagsWithLookupJoin() {
assertTrue(queryBuilder.tags().isEmpty());
assertNull(esQueryExec.query());
// rhs of lookup join
- esQueryExec = as(lookupJoinExec.right(), EsQueryExec.class);
- assertEquals("languages_lookup", esQueryExec.indexPattern());
- queryBuilderAndTags = esQueryExec.queryBuilderAndTags();
- assertEquals(1, queryBuilderAndTags.size());
- queryBuilder = queryBuilderAndTags.get(0);
- assertNull(queryBuilder.query());
- assertTrue(queryBuilder.tags().isEmpty());
- assertNull(esQueryExec.query());
+ FragmentExec fragmentExec = as(lookupJoinExec.right(), FragmentExec.class);
+ EsRelation esRelation = as(fragmentExec.fragment(), EsRelation.class);
+ assertTrue(esRelation.toString().contains("EsRelation[languages_lookup][LOOKUP]"));
}
}
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
index e1c52eb6845d9..bb42c8d4884ec 100644
--- 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
@@ -4638,9 +4638,7 @@ public void testMixedSingleDoubleParams() {
expectError(
LoggerMessageFormat.format(null, "from test | " + command, param1, param2, param3),
List.of(paramAsConstant("f1", "f1"), paramAsConstant("f2", "f2"), paramAsConstant("f3", "f3")),
- command.contains("join")
- ? "JOIN ON clause only supports fields at the moment"
- : "declared as a constant, cannot be used as an identifier"
+ "declared as a constant, cannot be used as an identifier"
);
}
}
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/CommandLicenseTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/CommandLicenseTests.java
index e55a04c03cd1b..204aee977f5c2 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/CommandLicenseTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/CommandLicenseTests.java
@@ -178,7 +178,7 @@ private static LogicalPlan createInstance(Class clazz, Lo
return new Sample(source, null, child);
}
case "LookupJoin" -> {
- return new LookupJoin(source, child, child, List.of());
+ return new LookupJoin(source, child, child, List.of(), false, null);
}
case "Limit" -> {
return new Limit(source, null, child);
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/JoinSerializationTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/JoinSerializationTests.java
index 2b812e4caf260..c88ef47a72989 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/JoinSerializationTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/JoinSerializationTests.java
@@ -32,7 +32,7 @@ private static JoinConfig randomJoinConfig() {
List matchFields = randomFieldAttributes(1, 10, false);
List leftFields = randomFieldAttributes(1, 10, false);
List rightFields = randomFieldAttributes(1, 10, false);
- return new JoinConfig(type, matchFields, leftFields, rightFields);
+ return new JoinConfig(type, matchFields, leftFields, rightFields, null);
}
@Override
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/JoinTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/JoinTests.java
index 62c4812d157e5..21f6f5cd49f43 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/JoinTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/JoinTests.java
@@ -47,7 +47,7 @@ public void testExpressionsAndReferences() {
Row left = new Row(Source.EMPTY, leftFields);
Row right = new Row(Source.EMPTY, rightFields);
- JoinConfig joinConfig = new JoinConfig(JoinTypes.LEFT, matchFields, leftAttributes, rightAttributes);
+ JoinConfig joinConfig = new JoinConfig(JoinTypes.LEFT, matchFields, leftAttributes, rightAttributes, null);
Join join = new Join(Source.EMPTY, left, right, joinConfig);
// matchfields are a subset of the left and right fields, so they don't contribute to the size of the references set.
@@ -87,7 +87,7 @@ public void testTransformExprs() {
Row left = new Row(Source.EMPTY, leftFields);
Row right = new Row(Source.EMPTY, rightFields);
- JoinConfig joinConfig = new JoinConfig(JoinTypes.LEFT, matchFields, leftAttributes, rightAttributes);
+ JoinConfig joinConfig = new JoinConfig(JoinTypes.LEFT, matchFields, leftAttributes, rightAttributes, null);
Join join = new Join(Source.EMPTY, left, right, joinConfig);
assertTrue(join.config().matchFields().stream().allMatch(ref -> ref.dataType().equals(DataType.INTEGER)));
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/LookupSerializationTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/LookupSerializationTests.java
index 53f36e124ebb0..8ce5b8c06f052 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/LookupSerializationTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/logical/LookupSerializationTests.java
@@ -24,7 +24,7 @@ public static Lookup randomLookup(int depth) {
Expression tableName = AbstractExpressionSerializationTests.randomChild();
List matchFields = randomFieldAttributes(1, 10, false);
LocalRelation localRelation = randomBoolean() ? null : LocalRelationSerializationTests.randomLocalRelation();
- return new Lookup(source, child, tableName, matchFields, localRelation);
+ return new Lookup(source, child, tableName, matchFields, localRelation, null);
}
@Override
@@ -48,6 +48,6 @@ protected Lookup mutateInstance(Lookup instance) throws IOException {
() -> randomBoolean() ? null : LocalRelationSerializationTests.randomLocalRelation()
);
}
- return new Lookup(source, child, tableName, matchFields, localRelation);
+ return new Lookup(source, child, tableName, matchFields, localRelation, null);
}
}
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/physical/AbstractPhysicalPlanSerializationTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/physical/AbstractPhysicalPlanSerializationTests.java
index ac831d36f1533..c2a012cd8e853 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/physical/AbstractPhysicalPlanSerializationTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/physical/AbstractPhysicalPlanSerializationTests.java
@@ -53,6 +53,7 @@ protected final NamedWriteableRegistry getNamedWriteableRegistry() {
entries.addAll(new SearchModule(Settings.EMPTY, List.of()).getNamedWriteables()); // Query builders
entries.add(Add.ENTRY); // Used by the eval tests
entries.add(AggregateMetricDoubleBlockBuilder.AggregateMetricDoubleLiteral.ENTRY);
+ entries.add(LookupJoinExec.ENTRY);
return new NamedWriteableRegistry(entries);
}
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/physical/LookupJoinExecSerializationTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/physical/LookupJoinExecSerializationTests.java
new file mode 100644
index 0000000000000..ac94839350e14
--- /dev/null
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plan/physical/LookupJoinExecSerializationTests.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.esql.plan.physical;
+
+import org.elasticsearch.xpack.esql.core.expression.Attribute;
+import org.elasticsearch.xpack.esql.core.tree.Source;
+
+import java.io.IOException;
+import java.util.List;
+
+public class LookupJoinExecSerializationTests extends AbstractPhysicalPlanSerializationTests {
+ public static LookupJoinExec randomLookupJoinExec(int depth) {
+ Source source = randomSource();
+ PhysicalPlan child = randomChild(depth);
+ PhysicalPlan lookup = randomChild(depth);
+ List leftFields = randomFields();
+ List rightFields = randomFields();
+ List addedFields = randomFields();
+ return new LookupJoinExec(source, child, lookup, leftFields, rightFields, addedFields, null);
+ }
+
+ private static List randomFields() {
+ return randomFieldAttributes(1, 5, false);
+ }
+
+ @Override
+ protected LookupJoinExec createTestInstance() {
+ return randomLookupJoinExec(0);
+ }
+
+ @Override
+ protected LookupJoinExec mutateInstance(LookupJoinExec instance) throws IOException {
+ PhysicalPlan child = instance.left();
+ PhysicalPlan lookup = instance.lookup();
+ List leftFields = randomFields();
+ List rightFields = randomFields();
+ List addedFields = randomFields();
+ switch (between(0, 4)) {
+ case 0 -> child = randomValueOtherThan(child, () -> randomChild(0));
+ case 1 -> lookup = randomValueOtherThan(lookup, () -> randomChild(0));
+ case 2 -> leftFields = randomValueOtherThan(leftFields, LookupJoinExecSerializationTests::randomFields);
+ case 3 -> rightFields = randomValueOtherThan(rightFields, LookupJoinExecSerializationTests::randomFields);
+ case 4 -> addedFields = randomValueOtherThan(addedFields, LookupJoinExecSerializationTests::randomFields);
+ default -> throw new UnsupportedOperationException();
+ }
+ return new LookupJoinExec(instance.source(), child, lookup, leftFields, rightFields, addedFields, null);
+ }
+
+ @Override
+ protected boolean alwaysEmptySource() {
+ return true;
+ }
+}
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/tree/EsqlNodeSubclassTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/tree/EsqlNodeSubclassTests.java
index 65f48ad06e299..c21aa9693989c 100644
--- a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/tree/EsqlNodeSubclassTests.java
+++ b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/tree/EsqlNodeSubclassTests.java
@@ -514,7 +514,8 @@ public void accept(Page page) {
JoinTypes.LEFT,
List.of(UnresolvedAttributeTests.randomUnresolvedAttribute()),
List.of(UnresolvedAttributeTests.randomUnresolvedAttribute()),
- List.of(UnresolvedAttributeTests.randomUnresolvedAttribute())
+ List.of(UnresolvedAttributeTests.randomUnresolvedAttribute()),
+ null
);
}