Implement Not and fix boolean logic

Author: carlosdelest

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/evaluator/EvalMapper.java

@@ -14,6 +14,7 @@
 import org.elasticsearch.compute.data.BooleanBlock;
 import org.elasticsearch.compute.data.BooleanVector;
 import org.elasticsearch.compute.data.DoubleBlock;
+import org.elasticsearch.compute.data.DoubleVector;
 import org.elasticsearch.compute.data.ElementType;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.data.Vector;
@@ -26,8 +27,10 @@
 import org.elasticsearch.xpack.esql.core.expression.Expression;
 import org.elasticsearch.xpack.esql.core.expression.FoldContext;
 import org.elasticsearch.xpack.esql.core.expression.Literal;
+import org.elasticsearch.xpack.esql.core.tree.Source;
 import org.elasticsearch.xpack.esql.evaluator.mapper.EvaluatorMapper;
 import org.elasticsearch.xpack.esql.evaluator.mapper.ExpressionMapper;
+import org.elasticsearch.xpack.esql.evaluator.predicate.operator.logical.NotEvaluator;
 import org.elasticsearch.xpack.esql.expression.predicate.logical.BinaryLogic;
 import org.elasticsearch.xpack.esql.expression.predicate.logical.Not;
 import org.elasticsearch.xpack.esql.expression.predicate.nulls.IsNotNull;
@@ -38,6 +41,8 @@
 
 import java.util.List;
 
+import static org.elasticsearch.compute.lucene.LuceneQueryExpressionEvaluator.NO_MATCH_SCORE;
+
 public final class EvalMapper {
 
     private static final List<ExpressionMapper<?>> MAPPERS = List.of(
@@ -185,7 +190,15 @@ public DoubleBlock score(Page page, BlockFactory blockFactory) {
                         // TODO We could optimize for constant vectors
                         try (var result = lhs.blockFactory().newDoubleVectorFixedBuilder(positionCount)) {
                             for (int p = 0; p < positionCount; p++) {
-                                result.appendDouble(p, lhs.getDouble(p) + rhs.getDouble(p));
+                                double l = lhs.getDouble(p);
+                                double r = rhs.getDouble(p);
+                                if (l == NO_MATCH_SCORE) {
+                                    result.appendDouble(p, r);
+                                } else if (r == NO_MATCH_SCORE) {
+                                    result.appendDouble(p, l);
+                                } else {
+                                    result.appendDouble(p, l + r);
+                                }
                             }
                             return result.build().asBlock();
                         }
@@ -210,12 +223,43 @@ public ExpressionEvaluator.Factory map(
             List<ShardContext> shardContexts,
             boolean usesScoring
         ) {
-            var expEval = toEvaluator(foldCtx, not.field(), layout, shardContexts, usesScoring);
-            return dvrCtx -> new org.elasticsearch.xpack.esql.evaluator.predicate.operator.logical.NotEvaluator(
-                not.source(),
-                expEval.get(dvrCtx),
-                dvrCtx
-            );
+            record NotScoreEvaluator(Source source, NotEvaluator notEval, ExpressionEvaluator innerEval, DriverContext driverContext)
+                implements
+                    ExpressionEvaluator {
+                @Override
+                public Block eval(Page page) {
+                    return notEval.eval(page);
+                }
+
+                @Override
+                // NotEvaluator is a final, generated class - create this record to override score method
+                public DoubleBlock score(Page page, BlockFactory blockFactory) {
+                    try (DoubleBlock scoreBlock = innerEval.score(page, blockFactory)) {
+                        DoubleVector scoreVector = scoreBlock.asVector();
+                        DoubleVector.Builder result = blockFactory.newDoubleVectorFixedBuilder(page.getPositionCount());
+                        // TODO We could optimize for constant vectors
+                        for (int i = 0; i < scoreVector.getPositionCount(); i++) {
+                            result.appendDouble(scoreVector.getDouble(i) == NO_MATCH_SCORE ? 0.0 : NO_MATCH_SCORE);
+                        }
+                        return result.build().asBlock();
+                    }
+                }
+
+                @Override
+                public void close() {
+                    Releasables.closeExpectNoException(notEval, innerEval);
+                }
+            }
+
+            return driverContext -> {
+                var expEval = toEvaluator(foldCtx, not.field(), layout, shardContexts, usesScoring);
+                ExpressionEvaluator innerEval = expEval.get(driverContext);
+                NotEvaluator notEvaluator = new NotEvaluator(not.source(), innerEval, driverContext);
+                if (usesScoring) {
+                    return new NotScoreEvaluator(not.source(), notEvaluator, innerEval, driverContext);
+                }
+                return notEvaluator;
+            };
         }
     }