Removed lastValue field

Author: ivancea

x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/aggregation/blockhash/LongTopNBlockHash.java

@@ -38,12 +38,7 @@ public final class LongTopNBlockHash extends BlockHash {
     private final boolean nullsFirst;
     private final int limit;
     private final LongHash hash;
-    private LongTopNUniqueSort topValues;
-    private final LongHash seenUniqueValues;
-    /**
-     * Helper field to keep track of the last top value, and avoid expensive accesses.
-     */
-    private long lastTopValue;
+    private final LongTopNUniqueSort topValues;
 
     /**
      * Have we seen any {@code null} values?
@@ -63,8 +58,6 @@ public LongTopNBlockHash(int channel, boolean asc, boolean nullsFirst, int limit
         this.limit = limit;
         this.hash = new LongHash(1, blockFactory.bigArrays());
         this.topValues = new LongTopNUniqueSort(blockFactory.bigArrays(), asc ? SortOrder.ASC : SortOrder.DESC, limit);
-        this.seenUniqueValues = new LongHash(1, blockFactory.bigArrays());
-        this.lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE;
 
         assert limit > 0 : "LongTopNBlockHash requires a limit greater than 0";
     }
@@ -105,13 +98,6 @@ private boolean acceptNull() {
         if (nullsFirst) {
             hasNull = true;
             migrateToSmallTop();
-            if (topValues.getCount() == limit - 1) {
-                if (topValues.getCount() == 0) {
-                    lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE;
-                } else {
-                    lastTopValue = topValues.getWorstValue();
-                }
-            }
             return true;
         }
 
@@ -127,35 +113,13 @@ private boolean acceptNull() {
      * Tries to add the value to the top values, and returns true if it was successful.
      */
     private boolean acceptValue(long value) {
-        // Ignore values that are worse than the current worst value
-        if (isAcceptable(value) == false) {
+        if (topValues.collect(value) == false) {
             return false;
         }
 
-        // O(1) operation to check if the value is already in the hash, and avoid adding it again
-        if (seenUniqueValues.add(value) < 0) {
-            return true;
-        }
-
-        topValues.collect(value);
-
-        if (topValues.getCount() == limit) {
-            lastTopValue = topValues.getWorstValue();
-        } else if (topValues.getCount() == 1 || isBetterThan(lastTopValue, value)) {
-            lastTopValue = value;
-        }
-
         // Full top and null, there's an extra value/null we must remove
-        if (topValues.getCount() == limit && hasNull) {
-            if (nullsFirst) {
-                if (topValues.getCount() == 1) {
-                    lastTopValue = asc ? Long.MAX_VALUE : Long.MIN_VALUE;
-                } else {
-                    lastTopValue = topValues.getWorstValue();
-                }
-            } else {
-                hasNull = false;
-            }
+        if (topValues.getCount() == limit && hasNull && nullsFirst == false) {
+            hasNull = false;
         }
 
         return true;
@@ -171,10 +135,6 @@ private void migrateToSmallTop() {
         topValues.reduceLimitByOne();
     }
 
-    private boolean isBetterThan(long value, long other) {
-        return asc ? value < other : value > other;
-    }
-
     /**
      * Returns true if the value is in, or can be added to the top; false otherwise.
      */
@@ -189,7 +149,7 @@ private boolean isAcceptable(long value) {
      * </p>
      */
     private boolean isInTop(long value) {
-        return asc ? value <= lastTopValue : value >= lastTopValue;
+        return asc ? value <= topValues.getWorstValue() : value >= topValues.getWorstValue();
     }
 
     /**
@@ -349,7 +309,7 @@ public BitArray seenGroupIds(BigArrays bigArrays) {
 
     @Override
     public void close() {
-        Releasables.close(hash, topValues, seenUniqueValues);
+        Releasables.close(hash, topValues);
     }
 
     @Override

x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/sort/LongTopNUniqueSort.java

@@ -22,7 +22,6 @@
  */
 public class LongTopNUniqueSort implements Releasable {
 
-    private final BigArrays bigArrays;
     private final SortOrder order;
     private int limit;
 
@@ -32,44 +31,43 @@ public class LongTopNUniqueSort implements Releasable {
     private int count;
 
     public LongTopNUniqueSort(BigArrays bigArrays, SortOrder order, int limit) {
-        this.bigArrays = bigArrays;
         this.order = order;
         this.limit = limit;
+        this.count = 0;
         this.values = bigArrays.newLongArray(limit, false);
         this.searcher = new LongBinarySearcher(values, order);
-        this.count = 0;
     }
 
-    public void collect(long value) {
+    public boolean collect(long value) {
         if (limit == 0) {
-            return;
+            return false;
         }
 
         // Short-circuit if the value is worse than the worst value on the top.
         // This avoids a O(log(n)) check in the binary search
-        if (count == limit && betterThan(values.get(count - 1), value)) {
-            return;
+        if (count == limit && betterThan(getWorstValue(), value)) {
+            return false;
         }
 
         if (count == 0) {
             values.set(0, value);
             count++;
-            return;
+            return true;
         }
 
         int insertionIndex = this.searcher.search(0, count - 1, value);
 
         if (insertionIndex == count - 1) {
-            if (betterThan(values.get(count - 1), value)) {
+            if (betterThan(getWorstValue(), value)) {
                 values.set(count, value);
                 count++;
-                return;
+                return true;
             }
         }
 
         if (values.get(insertionIndex) == value) {
             // Only unique values are stored here
-            return;
+            return true;
         }
 
         // The searcher returns the upper bound, so we move right the elements from there
@@ -79,6 +77,8 @@ public void collect(long value) {
 
         values.set(insertionIndex, value);
         count = Math.min(count + 1, limit);
+
+        return true;
     }
 
     /**