fine-grained

Author: dnhatn

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

@@ -180,11 +180,18 @@ static void addOrdinalInputVector(
     ) {
         if (groupIds.isConstant() && hashIds.isConstant()) {
             state.addValueOrdinal(groupIds.getInt(0), hashIds.getInt(0));
-        } else {
-            for (int p = 0; p < groupIds.getPositionCount(); p++) {
-                int groupId = groupIds.getInt(p);
-                int ord = ordinalIds.getInt(p + positionOffset);
-                state.addValueOrdinal(groupId, hashIds.getInt(ord));
+            return;
+        }
+        int lastGroup = groupIds.getInt(0);
+        int lastOrd = ordinalIds.getInt(positionOffset);
+        state.addValueOrdinal(lastGroup, hashIds.getInt(lastOrd));
+        for (int p = 1; p < groupIds.getPositionCount(); p++) {
+            final int nextGroup = groupIds.getInt(p);
+            final int nextOrd = ordinalIds.getInt(p + positionOffset);
+            if (nextGroup != lastGroup || nextOrd != lastOrd) {
+                lastGroup = nextGroup;
+                lastOrd = nextOrd;
+                state.addValueOrdinal(lastGroup, hashIds.getInt(lastOrd));
             }
         }
     }

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

@@ -98,29 +98,42 @@ public void add(IntBlock bytesHashes, LongBlock longsBlock, GroupingAggregatorFu
     }
 
     public IntVector add(IntVector bytesHashes, LongVector longsVector) {
+        int positions = bytesHashes.getPositionCount();
+        final int[] ords = new int[positions];
+        int lastByte = bytesHashes.getInt(0);
+        long lastLong = longsVector.getLong(0);
+        ords[0] = Math.toIntExact(hashOrdToGroup(finalHash.add(lastByte, lastLong)));
+        boolean constant = true;
         if (bytesHashes.isConstant()) {
-            boolean singleValue = true;
-            // TODO: Should we also support num_runs? Should we add a constant flag to Vector and perform this check in EVAL instead?
-            if (longsVector.isConstant() == false) {
-                long firstValue = longsVector.getLong(0);
-                for (int i = 1; i < longsVector.getPositionCount(); i++) {
-                    if (firstValue != longsVector.getLong(i)) {
-                        singleValue = false;
-                        break;
-                    }
+            for (int i = 1; i < positions; i++) {
+                final long nextLong = longsVector.getLong(i);
+                if (nextLong == lastLong) {
+                    ords[i] = ords[i - 1];
+                } else {
+                    ords[i] = Math.toIntExact(hashOrdToGroup(finalHash.add(lastByte, nextLong)));
+                    lastLong = nextLong;
+                    constant = false;
                 }
             }
-            if (singleValue) {
-                int singleOrd = Math.toIntExact(hashOrdToGroup(finalHash.add(bytesHashes.getInt(0), longsVector.getLong(0))));
-                return blockFactory.newConstantIntVector(singleOrd, longsVector.getPositionCount());
+        } else {
+            for (int i = 1; i < positions; i++) {
+                final int nextByte = bytesHashes.getInt(i);
+                final long nextLong = longsVector.getLong(i);
+                if (nextByte == lastByte && nextLong == lastLong) {
+                    ords[i] = ords[i - 1];
+                } else {
+                    ords[i] = Math.toIntExact(hashOrdToGroup(finalHash.add(nextByte, nextLong)));
+                    lastByte = nextByte;
+                    lastLong = nextLong;
+                    constant = false;
+                }
             }
         }
-        int positions = bytesHashes.getPositionCount();
-        final int[] ords = new int[positions];
-        for (int i = 0; i < positions; i++) {
-            ords[i] = Math.toIntExact(hashOrdToGroup(finalHash.add(bytesHashes.getInt(i), longsVector.getLong(i))));
+        if (constant) {
+            return blockFactory.newConstantIntVector(ords[0], positions);
+        } else {
+            return blockFactory.newIntArrayVector(ords, positions);
         }
-        return blockFactory.newIntArrayVector(ords, positions);
     }
 
     @Override

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

@@ -173,15 +173,18 @@ $endif$
 $if(BytesRef)$
     private IntVector addOrdinalsVector(OrdinalBytesRefVector inputBlock) {
         IntVector inputOrds = inputBlock.getOrdinalsVector();
-        try (
-            var builder = blockFactory.newIntVectorBuilder(inputOrds.getPositionCount());
-            var hashOrds = add(inputBlock.getDictionaryVector())
-        ) {
-            for (int p = 0; p < inputOrds.getPositionCount(); p++) {
-                int ord = hashOrds.getInt(inputOrds.getInt(p));
-                builder.appendInt(ord);
+        try (var hashOrds = add(inputBlock.getDictionaryVector())) {
+            if (inputOrds.isConstant()) {
+                int ord = hashOrds.getInt(inputOrds.getInt(0));
+                return blockFactory.newConstantIntVector(ord, inputOrds.getPositionCount());
+            }
+            try (var builder = blockFactory.newIntVectorBuilder(inputOrds.getPositionCount())) {
+                for (int p = 0; p < inputOrds.getPositionCount(); p++) {
+                    int ord = hashOrds.getInt(inputOrds.getInt(p));
+                    builder.appendInt(ord);
+                }
+                return builder.build();
             }
-            return builder.build();
         }
     }