switch ClusterGroupTuples to record class

Author: clintropolis

processing/src/main/java/org/apache/druid/timeline/ClusterGroupTuples.java

@@ -37,54 +37,29 @@
 
 /**
  * Typed clustering tuples carried on {@link DataSegment#getClusterGroups()} for clustered base-table segments. Each
- * entry in {@link #getTuples()} is one cluster group's clustering-column values, in the order declared by
- * {@link #getClusteringColumns()}. Optionally carries the clustering {@link VirtualColumns} when the segment was
+ * entry in {@link #tuples()} is one cluster group's clustering-column values, in the order declared by
+ * {@link #clusteringColumns()}. Optionally carries the clustering {@link VirtualColumns} when the segment was
  * clustered on a virtual-column expression, so that matching for things like partial load rules and query time
  * segment pruning can make use of this information.
+ * <p>
+ * The compact constructor validates {@code clusteringColumns}, interns the virtual columns through
+ * {@link DataSegment#virtualColumnInterner()}, and canonicalizes every tuple value to its declared
+ * {@link ColumnType} via {@link #coerceValue} so {@link Object#equals} works across the JSON/programmatic boundary.
  */
-public class ClusterGroupTuples
+public record ClusterGroupTuples(
+    @JsonProperty("clusteringColumns") RowSignature clusteringColumns,
+    @JsonProperty("virtualColumns") @JsonInclude(JsonInclude.Include.NON_EMPTY) VirtualColumns virtualColumns,
+    @JsonProperty("tuples") List<List<Object>> tuples
+)
 {
-  private final RowSignature clusteringColumns;
-  private final List<List<Object>> tuples;
-  private final VirtualColumns virtualColumns;
-
   @JsonCreator
-  public ClusterGroupTuples(
-      @JsonProperty("clusteringColumns") RowSignature clusteringColumns,
-      @JsonProperty("tuples") @Nullable List<List<Object>> tuples,
-      @JsonProperty("virtualColumns") @Nullable VirtualColumns virtualColumns
-  )
+  public ClusterGroupTuples
   {
     if (clusteringColumns == null || clusteringColumns.size() == 0) {
       throw InvalidInput.exception("clusteringColumns must not be null or empty");
     }
-    this.clusteringColumns = clusteringColumns;
-    this.virtualColumns = internVirtualColumns(virtualColumns);
-
-    final List<List<Object>> source = tuples == null ? Collections.emptyList() : tuples;
-    final int numCols = clusteringColumns.size();
-    final List<List<Object>> coerced = new ArrayList<>(source.size());
-    for (int t = 0; t < source.size(); t++) {
-      final List<Object> tuple = source.get(t);
-      if (tuple == null || tuple.size() != numCols) {
-        throw InvalidInput.exception(
-            "tuple[%s] has size [%s] but clusteringColumns size is [%s]",
-            t,
-            tuple == null ? "null" : tuple.size(),
-            numCols
-        );
-      }
-      final Object[] out = new Object[numCols];
-      for (int i = 0; i < numCols; i++) {
-        final String name = clusteringColumns.getColumnName(i);
-        final ColumnType type = clusteringColumns.getColumnType(i).orElseThrow(
-            () -> InvalidInput.exception("clusteringColumn[%s] has no declared type", name)
-        );
-        out[i] = coerceValue(name, type, tuple.get(i));
-      }
-      coerced.add(Collections.unmodifiableList(Arrays.asList(out)));
-    }
-    this.tuples = Collections.unmodifiableList(coerced);
+    virtualColumns = internVirtualColumns(virtualColumns);
+    tuples = canonicalizeTuples(clusteringColumns, tuples);
   }
 
   /**
@@ -93,56 +68,7 @@ public ClusterGroupTuples(
    */
   public ClusterGroupTuples(RowSignature clusteringColumns, @Nullable List<List<Object>> tuples)
   {
-    this(clusteringColumns, tuples, null);
-  }
-
-  @JsonProperty
-  public RowSignature getClusteringColumns()
-  {
-    return clusteringColumns;
-  }
-
-  @JsonProperty
-  public List<List<Object>> getTuples()
-  {
-    return tuples;
-  }
-
-  @JsonProperty
-  @JsonInclude(JsonInclude.Include.NON_EMPTY)
-  public VirtualColumns getVirtualColumns()
-  {
-    return virtualColumns;
-  }
-
-  @Override
-  public boolean equals(Object o)
-  {
-    if (this == o) {
-      return true;
-    }
-    if (!(o instanceof ClusterGroupTuples)) {
-      return false;
-    }
-    ClusterGroupTuples that = (ClusterGroupTuples) o;
-    return Objects.equals(clusteringColumns, that.clusteringColumns)
-           && Objects.equals(tuples, that.tuples)
-           && Objects.equals(virtualColumns, that.virtualColumns);
-  }
-
-  @Override
-  public int hashCode()
-  {
-    return Objects.hash(clusteringColumns, tuples, virtualColumns);
-  }
-
-  @Override
-  public String toString()
-  {
-    return "ClusterGroupTuples{clusteringColumns=" + clusteringColumns
-           + ", tuples=" + tuples
-           + ", virtualColumns=" + virtualColumns
-           + '}';
+    this(clusteringColumns, null, tuples);
   }
 
   /**
@@ -160,7 +86,7 @@ public String toString()
    * <p>
    * Used by:
    * <ul>
-   *   <li>{@link ClusterGroupTuples}'s constructor to canonicalize segment-side tuples (strict).</li>
+   *   <li>{@link ClusterGroupTuples}'s compact constructor to canonicalize segment-side tuples (strict).</li>
    *   <li>Operator-supplied rule tuples in future cluster-group partial-load matchers, which can catch the
    *       exception and treat it as "no match for this segment" rather than a hard failure.</li>
    * </ul>
@@ -211,6 +137,37 @@ private static VirtualColumns internVirtualColumns(@Nullable VirtualColumns virt
     );
   }
 
+  private static List<List<Object>> canonicalizeTuples(
+      RowSignature clusteringColumns,
+      @Nullable List<List<Object>> tuples
+  )
+  {
+    final List<List<Object>> source = tuples == null ? Collections.emptyList() : tuples;
+    final int numCols = clusteringColumns.size();
+    final List<List<Object>> coerced = new ArrayList<>(source.size());
+    for (int t = 0; t < source.size(); t++) {
+      final List<Object> tuple = source.get(t);
+      if (tuple == null || tuple.size() != numCols) {
+        throw InvalidInput.exception(
+            "tuple[%s] has size [%s] but clusteringColumns size is [%s]",
+            t,
+            tuple == null ? "null" : tuple.size(),
+            numCols
+        );
+      }
+      final Object[] out = new Object[numCols];
+      for (int i = 0; i < numCols; i++) {
+        final String name = clusteringColumns.getColumnName(i);
+        final ColumnType type = clusteringColumns.getColumnType(i).orElseThrow(
+            () -> InvalidInput.exception("clusteringColumn[%s] has no declared type", name)
+        );
+        out[i] = coerceValue(name, type, tuple.get(i));
+      }
+      coerced.add(Collections.unmodifiableList(Arrays.asList(out)));
+    }
+    return Collections.unmodifiableList(coerced);
+  }
+
   private static DruidException cannotCoerce(Object raw, String columnName, String targetType)
   {
     return InvalidInput.exception(

processing/src/test/java/org/apache/druid/timeline/ClusterGroupTuplesTest.java

@@ -93,14 +93,14 @@ void testConstructorRejectsEmptyClusteringColumns()
   void testConstructorAllowsEmptyTuples()
   {
     final ClusterGroupTuples groups = new ClusterGroupTuples(tenantRegion(), List.of());
-    Assertions.assertTrue(groups.getTuples().isEmpty());
+    Assertions.assertTrue(groups.tuples().isEmpty());
   }
 
   @Test
   void testConstructorAllowsNullTuplesList()
   {
     final ClusterGroupTuples groups = new ClusterGroupTuples(tenantRegion(), null);
-    Assertions.assertTrue(groups.getTuples().isEmpty());
+    Assertions.assertTrue(groups.tuples().isEmpty());
   }
 
   @Test
@@ -166,11 +166,11 @@ void testNullsAllowedAtAnyTuplePosition()
             Arrays.asList(null, null)
         )
     );
-    Assertions.assertEquals(3, groups.getTuples().size());
-    Assertions.assertNull(groups.getTuples().get(0).get(0));
-    Assertions.assertNull(groups.getTuples().get(1).get(1));
-    Assertions.assertNull(groups.getTuples().get(2).get(0));
-    Assertions.assertNull(groups.getTuples().get(2).get(1));
+    Assertions.assertEquals(3, groups.tuples().size());
+    Assertions.assertNull(groups.tuples().get(0).get(0));
+    Assertions.assertNull(groups.tuples().get(1).get(1));
+    Assertions.assertNull(groups.tuples().get(2).get(0));
+    Assertions.assertNull(groups.tuples().get(2).get(1));
   }
 
   @Test
@@ -195,8 +195,8 @@ void testCoercionIntegerToLong()
         tenantPriority(),
         List.of(List.of("acme", Integer.valueOf(5)))
     );
-    Assertions.assertEquals(Long.class, groups.getTuples().get(0).get(1).getClass());
-    Assertions.assertEquals(5L, groups.getTuples().get(0).get(1));
+    Assertions.assertEquals(Long.class, groups.tuples().get(0).get(1).getClass());
+    Assertions.assertEquals(5L, groups.tuples().get(0).get(1));
   }
 
   @Test
@@ -219,8 +219,8 @@ void testCoercionDoubleToFloat()
   {
     final RowSignature sig = RowSignature.builder().add("temp", ColumnType.FLOAT).build();
     final ClusterGroupTuples groups = new ClusterGroupTuples(sig, List.of(List.of((Object) Double.valueOf(98.6))));
-    Assertions.assertEquals(Float.class, groups.getTuples().get(0).get(0).getClass());
-    Assertions.assertEquals(98.6f, (Float) groups.getTuples().get(0).get(0), 0.0001f);
+    Assertions.assertEquals(Float.class, groups.tuples().get(0).get(0).getClass());
+    Assertions.assertEquals(98.6f, (Float) groups.tuples().get(0).get(0), 0.0001f);
   }
 
   @Test
@@ -255,7 +255,7 @@ void testCoercionAcceptsAnyTypeForString()
   {
     final RowSignature sig = RowSignature.builder().add("v", ColumnType.STRING).build();
     final ClusterGroupTuples groups = new ClusterGroupTuples(sig, List.of(List.of((Object) Long.valueOf(7))));
-    Assertions.assertEquals("7", groups.getTuples().get(0).get(0));
+    Assertions.assertEquals("7", groups.tuples().get(0).get(0));
   }
 
   @Test
@@ -270,8 +270,8 @@ void testJsonRoundTripPreservesCoercedTypes() throws Exception
     final ClusterGroupTuples back = MAPPER.readValue(json, ClusterGroupTuples.class);
     Assertions.assertEquals(groups, back);
     // Round-tripped tuples must end up with the same canonical types as the in-memory original.
-    Assertions.assertEquals(Long.class, back.getTuples().get(0).get(1).getClass());
-    Assertions.assertEquals(Long.class, back.getTuples().get(1).get(1).getClass());
+    Assertions.assertEquals(Long.class, back.tuples().get(0).get(1).getClass());
+    Assertions.assertEquals(Long.class, back.tuples().get(1).get(1).getClass());
   }
 
   @Test
@@ -283,39 +283,39 @@ void testTuplesAreImmutable()
     );
     Assertions.assertThrows(
         UnsupportedOperationException.class,
-        () -> groups.getTuples().add(List.of("globex", "us-east-1"))
+        () -> groups.tuples().add(List.of("globex", "us-east-1"))
     );
     Assertions.assertThrows(
         UnsupportedOperationException.class,
-        () -> groups.getTuples().get(0).set(0, "hijacked")
+        () -> groups.tuples().get(0).set(0, "hijacked")
     );
   }
 
   @Test
   void testVirtualColumnsDefaultEmpty()
   {
     final ClusterGroupTuples groups = new ClusterGroupTuples(tenantRegion(), List.of());
-    Assertions.assertSame(VirtualColumns.EMPTY, groups.getVirtualColumns());
+    Assertions.assertSame(VirtualColumns.EMPTY, groups.virtualColumns());
   }
 
   @Test
   void testVirtualColumnsAreStored()
   {
     final ClusterGroupTuples groups = new ClusterGroupTuples(
         RowSignature.builder().add("tenant_lower", ColumnType.STRING).build(),
-        List.of(List.of("acme")),
-        VIRTUAL_COLUMNS
+        VIRTUAL_COLUMNS,
+        List.of(List.of("acme"))
     );
-    Assertions.assertNotNull(groups.getVirtualColumns().getVirtualColumn("tenant_lower"));
+    Assertions.assertNotNull(groups.virtualColumns().getVirtualColumn("tenant_lower"));
   }
 
   @Test
   void testVirtualColumnsJsonRoundTrip() throws Exception
   {
     final ClusterGroupTuples original = new ClusterGroupTuples(
         RowSignature.builder().add("tenant_lower", ColumnType.STRING).build(),
-        List.of(List.of("acme")),
-        VIRTUAL_COLUMNS
+        VIRTUAL_COLUMNS,
+        List.of(List.of("acme"))
     );
     // Round-trip needs an injectable ExprMacroTable for ExpressionVirtualColumn deserialization.
     final ObjectMapper mapper = new DefaultObjectMapper();
@@ -344,17 +344,17 @@ void testVirtualColumnInternerSharesAcrossInstances()
     // shared interner on DataSegment, so identical clustering VCs dedupe across segments held in memory.
     final ClusterGroupTuples a = new ClusterGroupTuples(
         RowSignature.builder().add("tenant_lower", ColumnType.STRING).build(),
-        List.of(List.of("acme")),
-        VIRTUAL_COLUMNS
+        VIRTUAL_COLUMNS,
+        List.of(List.of("acme"))
     );
     final ClusterGroupTuples b = new ClusterGroupTuples(
         RowSignature.builder().add("tenant_lower", ColumnType.STRING).build(),
-        List.of(List.of("globex")),
-        VIRTUAL_COLUMNS
+        VIRTUAL_COLUMNS,
+        List.of(List.of("globex"))
     );
     Assertions.assertSame(
-        a.getVirtualColumns().getVirtualColumns()[0],
-        b.getVirtualColumns().getVirtualColumns()[0]
+        a.virtualColumns().getVirtualColumns()[0],
+        b.virtualColumns().getVirtualColumns()[0]
     );
   }
 }

server/src/main/java/org/apache/druid/server/coordinator/rules/WildcardClusterGroupPartialLoadMatcher.java

@@ -50,7 +50,7 @@
  * If the operator supplies {@link #getVirtualColumns()}, a pattern key may also reference one of those virtual
  * columns. At match time, the matcher resolves such a key to a clustering column on the segment via
  * {@link VirtualColumns#findEquivalent(VirtualColumns.Node)} between the matchers VCs and the segment's clustering
- * VCs (carried on {@link ClusterGroupTuples#getVirtualColumns()}). This lets operators author portable rules, they
+ * VCs (carried on {@link ClusterGroupTuples#virtualColumns()}). This lets operators author portable rules, they
  * write their preferred VC name and expression, and the matcher resolves to whatever name the segment happens to use
  * for the equivalent clustering VC.
  * <p>
@@ -132,9 +132,9 @@ protected List<Integer> resolveClusterGroupIndices(DataSegment segment)
     if (clusterGroups == null) {
       return Collections.emptyList();
     }
-    final RowSignature clusteringColumns = clusterGroups.getClusteringColumns();
-    final VirtualColumns segmentVcs = clusterGroups.getVirtualColumns();
-    final List<List<Object>> tuples = clusterGroups.getTuples();
+    final RowSignature clusteringColumns = clusterGroups.clusteringColumns();
+    final VirtualColumns segmentVcs = clusterGroups.virtualColumns();
+    final List<List<Object>> tuples = clusterGroups.tuples();
 
     // Per-pattern resolution: which clustering column does each pattern key map to? Resolution is segment-scoped
     // (depends only on the segment's clustering signature + VCs), so compute it once up front and reuse it across

server/src/test/java/org/apache/druid/server/coordinator/rules/WildcardClusterGroupPartialLoadMatcherTest.java

@@ -444,6 +444,6 @@ private static DataSegment vcClusteredSegment(String... lowerTenants)
     for (String t : lowerTenants) {
       tuples.add(Collections.singletonList(t));
     }
-    return segmentWithGroups(new ClusterGroupTuples(clusteringColumns, tuples, lowerTenantVcs("tenant_lower")));
+    return segmentWithGroups(new ClusterGroupTuples(clusteringColumns, lowerTenantVcs("tenant_lower"), tuples));
   }
 }