Skip to content

Simplify pattern matching #120875

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 4 commits into
base: main
Choose a base branch
from
+67 −148
Open

Simplify pattern matching #120875

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
a77d9e5
Simplify pattern matching
idegtiarenko Jan 27, 2025
31ce634
update DataType
idegtiarenko Jan 31, 2025
6b357cd
Merge branch 'main' into simplify_pattern_matching
idegtiarenko Jan 31, 2025
c85ac70
Merge branch 'main' into simplify_pattern_matching
idegtiarenko Apr 7, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
51 changes: 16 additions & 35 deletions x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/type/DataType.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -433,41 +433,22 @@ public static DataType fromEs(String name) {
}

public static DataType fromJava(Object value) {
if (value == null) {
return NULL;
}
if (value instanceof Integer) {
return INTEGER;
}
if (value instanceof Long) {
return LONG;
}
if (value instanceof BigInteger) {
return UNSIGNED_LONG;
}
if (value instanceof Boolean) {
return BOOLEAN;
}
if (value instanceof Double) {
return DOUBLE;
}
if (value instanceof Float) {
return FLOAT;
}
if (value instanceof Byte) {
return BYTE;
}
if (value instanceof Short) {
return SHORT;
}
if (value instanceof ZonedDateTime) {
return DATETIME;
}
if (value instanceof String || value instanceof Character || value instanceof BytesRef) {
return KEYWORD;
}

return null;
return switch (value) {
case null -> NULL;
case Integer i -> INTEGER;
case Long l -> LONG;
case BigInteger bigInteger -> UNSIGNED_LONG;
case Boolean b -> BOOLEAN;
case Double v -> DOUBLE;
case Float v -> FLOAT;
case Byte b -> BYTE;
case Short i -> SHORT;
case ZonedDateTime zonedDateTime -> DATETIME;
case String s -> KEYWORD;
case Character c -> KEYWORD;
case BytesRef bytesRef -> KEYWORD;
default -> null;
};
}

public static boolean isUnsupported(DataType from) {
Expand Down
71 changes: 17 additions & 54 deletions x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/Analyzer.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -483,59 +483,22 @@ protected LogicalPlan rule(LogicalPlan plan, AnalyzerContext context) {
childrenOutput.addAll(output);
}

if (plan instanceof Aggregate aggregate) {
return resolveAggregate(aggregate, childrenOutput);
}

if (plan instanceof Drop d) {
return resolveDrop(d, childrenOutput);
}

if (plan instanceof Rename r) {
return resolveRename(r, childrenOutput);
}

if (plan instanceof Keep p) {
return resolveKeep(p, childrenOutput);
}

if (plan instanceof Eval p) {
return resolveEval(p, childrenOutput);
}

if (plan instanceof Enrich p) {
return resolveEnrich(p, childrenOutput);
}

if (plan instanceof MvExpand p) {
return resolveMvExpand(p, childrenOutput);
}

if (plan instanceof Lookup l) {
return resolveLookup(l, childrenOutput);
}

if (plan instanceof LookupJoin j) {
return resolveLookupJoin(j);
}

if (plan instanceof Insist i) {
return resolveInsist(i, childrenOutput, context.indexResolution());
}

if (plan instanceof Dedup dedup) {
return resolveDedup(dedup, childrenOutput);
}

if (plan instanceof RrfScoreEval rrf) {
return resolveRrfScoreEval(rrf, childrenOutput);
}

if (plan instanceof Rerank r) {
return resolveRerank(r, childrenOutput);
}

return plan.transformExpressionsOnly(UnresolvedAttribute.class, ua -> maybeResolveAttribute(ua, childrenOutput));
return switch (plan) {
case Aggregate aggregate -> resolveAggregate(aggregate, childrenOutput);
case Drop d -> resolveDrop(d, childrenOutput);
case Rename r -> resolveRename(r, childrenOutput);
case Keep p -> resolveKeep(p, childrenOutput);
case Eval p -> resolveEval(p, childrenOutput);
case Enrich p -> resolveEnrich(p, childrenOutput);
case MvExpand p -> resolveMvExpand(p, childrenOutput);
case Lookup l -> resolveLookup(l, childrenOutput);
case LookupJoin j -> resolveLookupJoin(j);
case Insist i -> resolveInsist(i, childrenOutput, context.indexResolution());
case Dedup dedup -> resolveDedup(dedup, childrenOutput);
case RrfScoreEval rrf -> resolveRrfScoreEval(rrf, childrenOutput);
case Rerank r -> resolveRerank(r, childrenOutput);
default -> plan.transformExpressionsOnly(UnresolvedAttribute.class, ua -> maybeResolveAttribute(ua, childrenOutput));
};
}

private Aggregate resolveAggregate(Aggregate aggregate, List<Attribute> childrenOutput) {
Expand Down Expand Up @@ -1286,7 +1249,7 @@ private static Expression cast(org.elasticsearch.xpack.esql.core.expression.func
return processScalarOrGroupingFunction(f, registry);
}
if (f instanceof EsqlArithmeticOperation || f instanceof BinaryComparison) {
return processBinaryOperator((BinaryOperator) f);
return processBinaryOperator((BinaryOperator<?, ?, ?, ?>) f);
}
return f;
}
Expand Down
93 changes: 34 additions & 59 deletions ...plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/LocalExecutionPlanner.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -231,65 +231,40 @@ public LocalExecutionPlan plan(String description, FoldContext foldCtx, Physical
}

private PhysicalOperation plan(PhysicalPlan node, LocalExecutionPlannerContext context) {
if (node instanceof AggregateExec aggregate) {
return planAggregation(aggregate, context);
} else if (node instanceof FieldExtractExec fieldExtractExec) {
return planFieldExtractNode(fieldExtractExec, context);
} else if (node instanceof ExchangeExec exchangeExec) {
return planExchange(exchangeExec, context);
} else if (node instanceof TopNExec topNExec) {
return planTopN(topNExec, context);
} else if (node instanceof EvalExec eval) {
return planEval(eval, context);
} else if (node instanceof DissectExec dissect) {
return planDissect(dissect, context);
} else if (node instanceof GrokExec grok) {
return planGrok(grok, context);
} else if (node instanceof ProjectExec project) {
return planProject(project, context);
} else if (node instanceof FilterExec filter) {
return planFilter(filter, context);
} else if (node instanceof LimitExec limit) {
return planLimit(limit, context);
} else if (node instanceof MvExpandExec mvExpand) {
return planMvExpand(mvExpand, context);
} else if (node instanceof RerankExec rerank) {
return planRerank(rerank, context);
} else if (node instanceof ChangePointExec changePoint) {
return planChangePoint(changePoint, context);
}
// source nodes
else if (node instanceof EsQueryExec esQuery) {
return planEsQueryNode(esQuery, context);
} else if (node instanceof EsStatsQueryExec statsQuery) {
return planEsStats(statsQuery, context);
} else if (node instanceof LocalSourceExec localSource) {
return planLocal(localSource, context);
} else if (node instanceof ShowExec show) {
return planShow(show);
} else if (node instanceof ExchangeSourceExec exchangeSource) {
return planExchangeSource(exchangeSource, context);
}
// lookups and joins
else if (node instanceof EnrichExec enrich) {
return planEnrich(enrich, context);
} else if (node instanceof HashJoinExec join) {
return planHashJoin(join, context);
} else if (node instanceof LookupJoinExec join) {
return planLookupJoin(join, context);
}
// output
else if (node instanceof OutputExec outputExec) {
return planOutput(outputExec, context);
} else if (node instanceof ExchangeSinkExec exchangeSink) {
return planExchangeSink(exchangeSink, context);
} else if (node instanceof MergeExec mergeExec) {
return planMerge(mergeExec, context);
} else if (node instanceof RrfScoreEvalExec rrf) {
return planRrfScoreEvalExec(rrf, context);
}

throw new EsqlIllegalArgumentException("unknown physical plan node [" + node.nodeName() + "]");
return switch (node) {
case AggregateExec aggregate -> planAggregation(aggregate, context);
case FieldExtractExec fieldExtractExec -> planFieldExtractNode(fieldExtractExec, context);
case ExchangeExec exchangeExec -> planExchange(exchangeExec, context);
case TopNExec topNExec -> planTopN(topNExec, context);
case EvalExec eval -> planEval(eval, context);
case DissectExec dissect -> planDissect(dissect, context);
case GrokExec grok -> planGrok(grok, context);
case ProjectExec project -> planProject(project, context);
case FilterExec filter -> planFilter(filter, context);
case LimitExec limit -> planLimit(limit, context);
case MvExpandExec mvExpand -> planMvExpand(mvExpand, context);
case RerankExec rerank -> planRerank(rerank, context);
case ChangePointExec changePoint -> planChangePoint(changePoint, context);

// source nodes
case EsQueryExec esQuery -> planEsQueryNode(esQuery, context);
case EsStatsQueryExec statsQuery -> planEsStats(statsQuery, context);
case LocalSourceExec localSource -> planLocal(localSource, context);
case ShowExec show -> planShow(show);
case ExchangeSourceExec exchangeSource -> planExchangeSource(exchangeSource, context);

// lookups and joins
case EnrichExec enrich -> planEnrich(enrich, context);
case HashJoinExec join -> planHashJoin(join, context);
case LookupJoinExec join -> planLookupJoin(join, context);

// output
case OutputExec outputExec -> planOutput(outputExec, context);
case ExchangeSinkExec exchangeSink -> planExchangeSink(exchangeSink, context);
case MergeExec mergeExec -> planMerge(mergeExec, context);
case RrfScoreEvalExec rrf -> planRrfScoreEvalExec(rrf, context);
case null, default -> throw new EsqlIllegalArgumentException("unknown physical plan node [" + node.nodeName() + "]");
};
}

private PhysicalOperation planRrfScoreEvalExec(RrfScoreEvalExec rrf, LocalExecutionPlannerContext context) {
Expand Down