Refactoring, added docs

elasticsearchmachine · elasticsearchmachine · commit 2b8c412728e2 · 2025-10-09T15:02:57.000+02:00
diff --git a/server/src/main/java/org/elasticsearch/search/sort/ScriptSortBuilder.java b/server/src/main/java/org/elasticsearch/search/sort/ScriptSortBuilder.java
@@ -328,6 +328,7 @@ public BucketedSort newBucketedSort(
                 };
             }
             case NUMBER -> {
+                // TODO Temporary hack to allow vector similarity functions access from sorting scripts. Needs to be done properly.
                 final ScoreScript.Factory numberSortFactory = context.compile(script, ScoreScript.CONTEXT);
                 // searchLookup is unnecessary here, as it's just used for expressions
                 final ScoreScript.LeafFactory numberSortScriptFactory = numberSortFactory.newFactory(script.getParams(), searchLookup);
diff --git a/x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/expression/Expression.java b/x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/expression/Expression.java
@@ -212,14 +212,33 @@ public String propertiesToString(boolean skipIfChild) {
         return super.propertiesToString(false);
     }
 
+    /**
+     * Returns whether the expression is pushable to Lucene:
+     * <ul>
+     *  <li>PREFERRED: We should push whenever possible. An expression that has a PREFERRED expression and does not have a NOT_SUPPORTED one can be pushed down to Lucene.</li>
+     * <li>SUPPORTED: Expression can be pushed down but does not offer a significant advantage in terms of performance, or depends on other expressions that are part of it.</li>
+     * <li>NOT_SUPPORTED: Expression can't be pushed down.</li>
+     * </ul>
+     *
+     * @return the pushable options for this expression
+     */
     public PushableOptions pushableOptions() {
         return PushableOptions.NOT_SUPPORTED;
     }
 
-    public String asScript() {
-        throw new UnsupportedOperationException("asScript not implemented for " + getWriteableName());
+    /**
+     * Returns the expression as a painless script to be pushed down to Lucene
+     *
+     * @return the painless script representation of this expression
+     * @throws UnsupportedOperationException if the expression does not support being represented as a script
+     */
+    public String asPushableScript() {
+        throw new UnsupportedOperationException("asPushableScript not implemented for " + getWriteableName());
     }
 
+    /**
+     * See {@link #pushableOptions()}}
+     */
     public enum PushableOptions {
         SUPPORTED,
         NOT_SUPPORTED,
diff --git a/x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/expression/FieldAttribute.java b/x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/expression/FieldAttribute.java
@@ -266,7 +266,7 @@ public PushableOptions pushableOptions() {
     }
 
     @Override
-    public String asScript() {
+    public String asPushableScript() {
         return "doc['" + fieldName().string() + "'].value";
     }
 }
diff --git a/x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/expression/Literal.java b/x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/expression/Literal.java
@@ -244,7 +244,7 @@ public PushableOptions pushableOptions() {
     }
 
     @Override
-    public String asScript() {
+    public String asPushableScript() {
         return Objects.toString(value());
     }
 }
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/LuceneTopNSourceOperator.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/LuceneTopNSourceOperator.java
@@ -288,6 +288,7 @@ private Page emit() {
         DoubleBlock scores = null;
         Page page = null;
 
+        // Prepares builders for sort values extraction
         int extractSortCount = (int) sorts.stream().filter(s -> s instanceof ScriptSortBuilder).count();
         DoubleBlock.Builder[] sortValuesBlockBuilders = new DoubleBlock.Builder[extractSortCount];
         for (int i = 0; i < sortValuesBlockBuilders.length; i++) {
@@ -310,6 +311,7 @@ private Page emit() {
                     float score = getScore(topDocs[i]);
                     currentScoresBuilder.appendDouble(score);
                 }
+                // Extracts sort values for script sorts, so they can be retrieved as values in the compute engine
                 if ((extractSortCount > 0) && topDocs[i] instanceof FieldDoc fieldDoc) {
                     int sortIndex = 0;
                     int extractedSortIndex = 0;
diff --git a/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/DenseVectorFieldTypeIT.java b/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/DenseVectorFieldTypeIT.java
@@ -34,7 +34,7 @@
 import static org.elasticsearch.index.IndexSettings.INDEX_MAPPER_SOURCE_MODE_SETTING;
 import static org.elasticsearch.index.mapper.SourceFieldMapper.Mode.SYNTHETIC;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
-import static org.elasticsearch.xpack.esql.action.EsqlCapabilities.Cap.L2_NORM_VECTOR_SIMILARITY_FUNCTION;
+import static org.elasticsearch.xpack.esql.action.EsqlCapabilities.Cap.L2_NORM_VECTOR_SIMILARITY_FUNCTION_PUSHABLE;
 
 public class DenseVectorFieldTypeIT extends AbstractEsqlIntegTestCase {
 
@@ -91,7 +91,7 @@ public DenseVectorFieldTypeIT(
     private final Map<Integer, List<Number>> indexedVectors = new HashMap<>();
 
     public void testRetrieveFieldType() {
-        assumeTrue("Need L2_NORM available for dense_vector retrieval", L2_NORM_VECTOR_SIMILARITY_FUNCTION.isEnabled());
+        assumeTrue("Need L2_NORM available for dense_vector retrieval", L2_NORM_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled());
 
         var query = """
             FROM test
@@ -107,7 +107,7 @@ public void testRetrieveFieldType() {
 
     @SuppressWarnings("unchecked")
     public void testRetrieveTopNDenseVectorFieldData() {
-        assumeTrue("Need L2_NORM available for dense_vector retrieval", L2_NORM_VECTOR_SIMILARITY_FUNCTION.isEnabled());
+        assumeTrue("Need L2_NORM available for dense_vector retrieval", L2_NORM_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled());
 
         var query = """
                 FROM test
@@ -137,7 +137,7 @@ public void testRetrieveTopNDenseVectorFieldData() {
 
     @SuppressWarnings("unchecked")
     public void testRetrieveDenseVectorFieldData() {
-        assumeTrue("Need L2_NORM available for dense_vector retrieval", L2_NORM_VECTOR_SIMILARITY_FUNCTION.isEnabled());
+        assumeTrue("Need L2_NORM available for dense_vector retrieval", L2_NORM_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled());
 
         var query = """
             FROM test
diff --git a/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/vector/VectorSimilarityFunctionsIT.java b/x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/vector/VectorSimilarityFunctionsIT.java
@@ -50,19 +50,19 @@ public class VectorSimilarityFunctionsIT extends AbstractEsqlIntegTestCase {
     public static Iterable<Object[]> parameters() throws Exception {
         List<Object[]> params = new ArrayList<>();
 
-        if (EsqlCapabilities.Cap.COSINE_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {
+        if (EsqlCapabilities.Cap.COSINE_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {
             params.add(new Object[] { "v_cosine", (SimilarityEvaluatorFunction) CosineSimilarity::calculateSimilarity });
         }
-        if (EsqlCapabilities.Cap.DOT_PRODUCT_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {
+        if (EsqlCapabilities.Cap.DOT_PRODUCT_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {
             params.add(new Object[] { "v_dot_product", (SimilarityEvaluatorFunction) DotProduct::calculateSimilarity });
         }
-        if (EsqlCapabilities.Cap.L1_NORM_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {
+        if (EsqlCapabilities.Cap.L1_NORM_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {
             params.add(new Object[] { "v_l1_norm", (SimilarityEvaluatorFunction) L1Norm::calculateSimilarity });
         }
-        if (EsqlCapabilities.Cap.L2_NORM_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {
+        if (EsqlCapabilities.Cap.L2_NORM_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {
             params.add(new Object[] { "v_l2_norm", (SimilarityEvaluatorFunction) L2Norm::calculateSimilarity });
         }
-        if (EsqlCapabilities.Cap.HAMMING_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {
+        if (EsqlCapabilities.Cap.HAMMING_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {
             params.add(new Object[] { "v_hamming", (SimilarityEvaluatorFunction) Hamming::calculateSimilarity });
         }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/vector/Magnitude.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/vector/Magnitude.java
@@ -139,7 +139,7 @@ public PushableOptions pushableOptions() {
     }
 
     @Override
-    public String asScript() {
+    public String asPushableScript() {
         return "doc['" + ((FieldAttribute) field()).name() + "'].magnitude";
     }
 
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/vector/VectorSimilarityFunction.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/vector/VectorSimilarityFunction.java
@@ -94,14 +94,14 @@ public PushableOptions pushableOptions() {
     }
 
     @Override
-    public final String asScript() {
+    public final String asPushableScript() {
         String queryVector = left().foldable() ? queryVectorAsScript(left()) : queryVectorAsScript(right());
         String fieldName = ((FieldAttribute) (left().foldable() ? right() : left())).name();
         return "doc['" + fieldName + "'].size() == 0 ? 0 : " + scriptFunctionName() + "(" + queryVector + ", '" + fieldName + "')";
     }
 
     protected String queryVectorAsScript(Expression queryVector) {
-        return queryVector.asScript();
+        return queryVector.asPushableScript();
     }
 
     protected abstract String scriptFunctionName();
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/predicate/operator/arithmetic/EsqlArithmeticOperation.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/predicate/operator/arithmetic/EsqlArithmeticOperation.java
@@ -170,8 +170,8 @@ public PushableOptions pushableOptions() {
     }
 
     @Override
-    public String asScript() {
-        return left().asScript() + function().symbol() + right().asScript();
+    public String asPushableScript() {
+        return left().asPushableScript() + function().symbol() + right().asPushableScript();
     }
 
     @Override
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/physical/local/PushTopNToSource.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/physical/local/PushTopNToSource.java
@@ -9,7 +9,6 @@
 
 import org.elasticsearch.geometry.Geometry;
 import org.elasticsearch.geometry.Point;
-import org.elasticsearch.script.Script;
 import org.elasticsearch.xpack.esql.core.expression.Alias;
 import org.elasticsearch.xpack.esql.core.expression.Attribute;
 import org.elasticsearch.xpack.esql.core.expression.AttributeMap;
@@ -130,13 +129,15 @@ private static PushableGeoDistance from(FoldContext ctx, Attribute attr, Express
     record PushableCompoundExec(EvalExec evalExec, EsQueryExec queryExec, List<EsQueryExec.Sort> pushableSorts) implements Pushable {
         public PhysicalPlan rewrite(TopNExec topNExec) {
             List<Alias> evalExecAlias = evalExec.fields();
+            // If we have pushable sorts, we update the EVAL aliases to refer to the pushed down sort fields.
+            // It changes EVAL alias = pushable_expression to EVAL alias = alias_script
             for (EsQueryExec.Sort pushableSort : pushableSorts) {
-                if (pushableSort instanceof EsQueryExec.ScriptSort scriptSort) {
+                if (pushableSort instanceof EsQueryExec.PushableExpressionSort pushableExpressionSort) {
                     // Change eval alias to the script sort field
                     for (int i = 0; i < evalExecAlias.size(); i++) {
                         Alias alias = evalExecAlias.get(i);
-                        if (alias.id().equals(scriptSort.alias().id())) {
-                            evalExecAlias.set(i, alias.replaceChild(scriptSort.field()));
+                        if (alias.id().equals(pushableExpressionSort.alias().id())) {
+                            evalExecAlias.set(i, alias.replaceChild(pushableExpressionSort.field()));
                             break;
                         }
                     }
@@ -219,13 +220,12 @@ && canPushLimit(topNExec, plannerSettings)) {
                         } else if (pushableExpressions.containsKey(resolvedAttribute.id())) {
                             Alias expressionAlias = (Alias) pushableExpressions.get(resolvedAttribute.id());
 
-                            // Create a script from the expression
-                            String scriptText = "return " + expressionAlias.child().asScript();
-                            Script script = new Script(scriptText);
-
                             // Create a script sort that computes the value
-                            EsQueryExec.ScriptSort scriptSort = new EsQueryExec.ScriptSort(expressionAlias, script, order.direction());
-                            pushableSorts.add(scriptSort);
+                            EsQueryExec.PushableExpressionSort pushableExpressionSort = new EsQueryExec.PushableExpressionSort(
+                                expressionAlias,
+                                order.direction()
+                            );
+                            pushableSorts.add(pushableExpressionSort);
                         } else {
                             // If the SORT refers to a non-pushable reference function, the EVAL must remain before the SORT,
                             // and we can no longer push down anything
diff --git a/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/plan/physical/EsQueryExec.java b/x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/plan/physical/EsQueryExec.java
@@ -134,15 +134,21 @@ public DataType resulType() {
         }
     }
 
-    public static final class ScriptSort implements Sort {
+    /**
+     * A sort implemented as a painless script based on an alias with a pushable expression
+     */
+    public static final class PushableExpressionSort implements Sort {
         private final Alias alias;
         private final FieldAttribute field;
         private final Script script;
         private final Order.OrderDirection direction;
 
-        public ScriptSort(Alias alias, Script script, Order.OrderDirection direction) {
+        public PushableExpressionSort(Alias alias, Order.OrderDirection direction) {
             this.alias = alias;
-            this.script = script;
+
+            // Create a script from the expression
+            String scriptText = "return " + alias.child().asPushableScript();
+            this.script = new Script(scriptText);
             this.direction = direction;
             EsField esField = new EsField(alias.name(), alias.dataType(), Map.of(), false, EsField.TimeSeriesFieldType.NONE);
             this.field = new FieldAttribute(alias.source(), null, null, alias.name() + "_script", esField);
@@ -185,7 +191,7 @@ public Order.OrderDirection direction() {
         public boolean equals(Object obj) {
             if (obj == this) return true;
             if (obj == null || obj.getClass() != this.getClass()) return false;
-            var that = (ScriptSort) obj;
+            var that = (PushableExpressionSort) obj;
             return Objects.equals(this.alias, that.alias)
                 && Objects.equals(this.field, that.field)
                 && Objects.equals(this.script, that.script)
@@ -311,8 +317,8 @@ public List<Attribute> output() {
         if (sorts == null || sorts.isEmpty()) {
             return attrs;
         }
-        // Concat attributes with the fields used in script sorts, as they need to be extracted too
-        return Stream.concat(attrs.stream(), sorts.stream().filter(s -> s instanceof ScriptSort).map(Sort::field)).toList();
+        // Concat attributes with the fields used in pushable sorts, as they will be extracted as well to allow usage of the sort value
+        return Stream.concat(attrs.stream(), sorts.stream().filter(s -> s instanceof PushableExpressionSort).map(Sort::field)).toList();
     }
 
     public Expression limit() {
diff --git a/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/PhysicalPlanOptimizerTests.java b/x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/PhysicalPlanOptimizerTests.java
@@ -8314,47 +8314,6 @@ protected List<Batch<PhysicalPlan>> batches() {
         return PhysicalPlanOptimizer;
     }
 
-    public void testTest() throws Exception {
-
-        PhysicalPlan plan = physicalPlan("""
-            from test
-            | stats a = min(salary) by emp_no
-            """);
-
-        var limit = as(plan, LimitExec.class);
-        var aggregate = as(limit.child(), AggregateExec.class);
-        var min = as(Alias.unwrap(aggregate.aggregates().get(0)), Min.class);
-        var salary = as(min.field(), NamedExpression.class);
-        assertThat(salary.name(), is("salary"));
-        Holder<Integer> appliedCount = new Holder<>(0);
-        // use a custom rule that adds another output attribute
-        var customRuleBatch = new RuleExecutor.Batch<>(
-            "CustomRuleBatch",
-            RuleExecutor.Limiter.ONCE,
-            new PhysicalOptimizerRules.ParameterizedOptimizerRule<PhysicalPlan, PhysicalOptimizerContext>() {
-                @Override
-                public PhysicalPlan rule(PhysicalPlan plan, PhysicalOptimizerContext context) {
-                    // This rule adds a missing attribute to the plan output
-                    // We only want to apply it once, so we use a static counter
-                    if (appliedCount.get() == 0) {
-                        appliedCount.set(appliedCount.get() + 1);
-                        Literal additionalLiteral = new Literal(Source.EMPTY, "additional literal", INTEGER);
-                        return new EvalExec(
-                            plan.source(),
-                            plan,
-                            List.of(new Alias(Source.EMPTY, "additionalAttribute", additionalLiteral))
-                        );
-                    }
-                    return plan;
-                }
-            }
-        );
-        PhysicalPlanOptimizer customRulesPhysicalPlanOptimizer = getCustomRulesPhysicalPlanOptimizer(List.of(customRuleBatch));
-        Exception e = expectThrows(VerificationException.class, () -> customRulesPhysicalPlanOptimizer.optimize(plan));
-        assertThat(e.getMessage(), containsString("Output has changed from"));
-        assertThat(e.getMessage(), containsString("additionalAttribute"));
-    }
-
     public void testVerifierOnAdditionalAttributeAdded() throws Exception {
 
         PhysicalPlan plan = physicalPlan("""

Original file line number	Diff line number	Diff line change
`@@ -328,6 +328,7 @@ public BucketedSort newBucketedSort(`
`328`	`328`	`};`
`329`	`329`	`}`
`330`	`330`	`case NUMBER -> {`
	`331`	`+ // TODO Temporary hack to allow vector similarity functions access from sorting scripts. Needs to be done properly.`
`331`	`332`	`final ScoreScript.Factory numberSortFactory = context.compile(script, ScoreScript.CONTEXT);`
`332`	`333`	`// searchLookup is unnecessary here, as it's just used for expressions`
`333`	`334`	`final ScoreScript.LeafFactory numberSortScriptFactory = numberSortFactory.newFactory(script.getParams(), searchLookup);`
Original file line number	Diff line number	Diff line change
`@@ -266,7 +266,7 @@ public PushableOptions pushableOptions() {`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`@Override`
`269`		`- public String asScript() {`
	`269`	`+ public String asPushableScript() {`
`270`	`270`	`return "doc['" + fieldName().string() + "'].value";`
`271`	`271`	`}`
`272`	`272`	`}`
Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ public PushableOptions pushableOptions() {`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`@Override`
`247`		`- public String asScript() {`
	`247`	`+ public String asPushableScript() {`
`248`	`248`	`return Objects.toString(value());`
`249`	`249`	`}`
`250`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,19 +50,19 @@ public class VectorSimilarityFunctionsIT extends AbstractEsqlIntegTestCase {`
`50`	`50`	`public static Iterable<Object[]> parameters() throws Exception {`
`51`	`51`	`List<Object[]> params = new ArrayList<>();`
`52`	`52`
`53`		`- if (EsqlCapabilities.Cap.COSINE_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {`
	`53`	`+ if (EsqlCapabilities.Cap.COSINE_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {`
`54`	`54`	`params.add(new Object[] { "v_cosine", (SimilarityEvaluatorFunction) CosineSimilarity::calculateSimilarity });`
`55`	`55`	`}`
`56`		`- if (EsqlCapabilities.Cap.DOT_PRODUCT_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {`
	`56`	`+ if (EsqlCapabilities.Cap.DOT_PRODUCT_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {`
`57`	`57`	`params.add(new Object[] { "v_dot_product", (SimilarityEvaluatorFunction) DotProduct::calculateSimilarity });`
`58`	`58`	`}`
`59`		`- if (EsqlCapabilities.Cap.L1_NORM_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {`
	`59`	`+ if (EsqlCapabilities.Cap.L1_NORM_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {`
`60`	`60`	`params.add(new Object[] { "v_l1_norm", (SimilarityEvaluatorFunction) L1Norm::calculateSimilarity });`
`61`	`61`	`}`
`62`		`- if (EsqlCapabilities.Cap.L2_NORM_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {`
	`62`	`+ if (EsqlCapabilities.Cap.L2_NORM_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {`
`63`	`63`	`params.add(new Object[] { "v_l2_norm", (SimilarityEvaluatorFunction) L2Norm::calculateSimilarity });`
`64`	`64`	`}`
`65`		`- if (EsqlCapabilities.Cap.HAMMING_VECTOR_SIMILARITY_FUNCTION.isEnabled()) {`
	`65`	`+ if (EsqlCapabilities.Cap.HAMMING_VECTOR_SIMILARITY_FUNCTION_PUSHABLE.isEnabled()) {`
`66`	`66`	`params.add(new Object[] { "v_hamming", (SimilarityEvaluatorFunction) Hamming::calculateSimilarity });`
`67`	`67`	`}`
`68`	`68`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ public PushableOptions pushableOptions() {`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`@Override`
`142`		`- public String asScript() {`
	`142`	`+ public String asPushableScript() {`
`143`	`143`	`return "doc['" + ((FieldAttribute) field()).name() + "'].magnitude";`
`144`	`144`	`}`
`145`	`145`
Original file line number	Diff line number	Diff line change
`@@ -94,14 +94,14 @@ public PushableOptions pushableOptions() {`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`@Override`
`97`		`- public final String asScript() {`
	`97`	`+ public final String asPushableScript() {`
`98`	`98`	`String queryVector = left().foldable() ? queryVectorAsScript(left()) : queryVectorAsScript(right());`
`99`	`99`	`String fieldName = ((FieldAttribute) (left().foldable() ? right() : left())).name();`
`100`	`100`	`return "doc['" + fieldName + "'].size() == 0 ? 0 : " + scriptFunctionName() + "(" + queryVector + ", '" + fieldName + "')";`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`protected String queryVectorAsScript(Expression queryVector) {`
`104`		`- return queryVector.asScript();`
	`104`	`+ return queryVector.asPushableScript();`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`protected abstract String scriptFunctionName();`
Original file line number	Diff line number	Diff line change
`@@ -170,8 +170,8 @@ public PushableOptions pushableOptions() {`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`@Override`
`173`		`- public String asScript() {`
`174`		`- return left().asScript() + function().symbol() + right().asScript();`
	`173`	`+ public String asPushableScript() {`
	`174`	`+ return left().asPushableScript() + function().symbol() + right().asPushableScript();`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`@Override`