CNDB-12154

.build/parent-pom-template.xml

@@ -1235,7 +1235,7 @@
       <dependency>
         <groupId>io.github.jbellis</groupId>
         <artifactId>jvector</artifactId>
-        <version>3.0.0</version>
+        <version>3.0.1</version>
       </dependency>
       <dependency>
         <groupId>com.carrotsearch.randomizedtesting</groupId>

src/java/org/apache/cassandra/config/CassandraRelevantProperties.java

@@ -795,19 +795,27 @@ public enum CassandraRelevantProperties
      */
     UCS_COMPACTION_AGGREGATE_PRIORITIZER("unified_compaction.custom_compaction_aggregate_prioritizer"),
     UCS_DATASET_SIZE("unified_compaction.dataset_size"),
+    UCS_IS_REPLICA_AWARE("unified_compaction.is_replica_aware"),
     UCS_L0_SHARDS_ENABLED("unified_compaction.l0_shards_enabled", "true"),
     UCS_MAX_ADAPTIVE_COMPACTIONS("unified_compaction.max_adaptive_compactions", "5"),
     UCS_MAX_SPACE_OVERHEAD("unified_compaction.max_space_overhead", "0.2"),
     UCS_MIN_SSTABLE_SIZE("unified_compaction.min_sstable_size", "100MiB"),
     UCS_NUM_SHARDS("unified_compaction.num_shards"),
     UCS_OVERLAP_INCLUSION_METHOD("unified_compaction.overlap_inclusion_method"),
+    UCS_OVERRIDE_UCS_CONFIG_FOR_VECTOR_TABLES("unified_compaction.override_ucs_config_for_vector_tables", "false"),
     UCS_RESERVATIONS_TYPE_OPTION("unified_compaction.reservations_type_option", Reservations.Type.LEVEL_OR_BELOW.name()),
     UCS_RESERVED_THREADS("reserved_threads", "max"),
     UCS_SHARED_STORAGE("unified_compaction.shared_storage", "false"),
-    UCS_SSTABLE_GROWTH("unified_compaction.sstable_growth", "0.5"),
+    UCS_SSTABLE_GROWTH("unified_compaction.sstable_growth", "0.333"),
     UCS_STATIC_SCALING_PARAMETERS("unified_compaction.scaling_parameters", "T4"),
     UCS_SURVIVAL_FACTOR("unified_compaction.survival_factor", "1"),
-    UCS_TARGET_SSTABLE_SIZE("unified_compaction.target_sstable_size", "5GiB"),
+    UCS_TARGET_SSTABLE_SIZE("unified_compaction.target_sstable_size", "1GiB"),
+    UCS_VECTOR_BASE_SHARD_COUNT("unified_compaction.vector_base_shard_count", "1"),
+    UCS_VECTOR_MIN_SSTABLE_SIZE("unified_compaction.vector_min_sstable_size", "1024MiB"),
+    UCS_VECTOR_RESERVED_THREADS("unified_compaction.vector_reserved_threads", "max"),
+    UCS_VECTOR_SCALING_PARAMETERS("unified_compaction.vector_scaling_parameters", "-8"),
+    UCS_VECTOR_SSTABLE_GROWTH("unified_compaction.vector_sstable_growth", "1.0"),
+    UCS_VECTOR_TARGET_SSTABLE_SIZE("unified_compaction.vector_target_sstable_size", "5GiB"),
     UDF_EXECUTOR_THREAD_KEEPALIVE_MS("cassandra.udf_executor_thread_keepalive_ms", "30000"),
     UNSAFE_SYSTEM("cassandra.unsafesystem"),
     /** User's home directory. */

src/java/org/apache/cassandra/cql3/restrictions/RestrictionSet.java

@@ -242,7 +242,7 @@ public void addToRowFilter(RowFilter.Builder rowFilter,
                                    QueryOptions options) throws InvalidRequestException
         {
             for (SingleRestriction restriction : restrictionsMap.values())
-                restriction.addToRowFilter(rowFilter, indexRegistry, options);
+                rowFilter.addAllAsConjunction(b -> restriction.addToRowFilter(b, indexRegistry, options));
         }
 
         @Override

src/java/org/apache/cassandra/cql3/selection/Selectable.java

@@ -69,7 +69,7 @@
 
 public interface Selectable extends AssignmentTestable
 {
-    public Selector.Factory newSelectorFactory(TableMetadata table, AbstractType<?> expectedType, List<ColumnMetadata> defs, VariableSpecifications boundNames);
+    Selector.Factory newSelectorFactory(TableMetadata table, AbstractType<?> expectedType, List<ColumnMetadata> defs, VariableSpecifications boundNames);
 
     /**
      * The type of the {@code Selectable} if it can be infered.
@@ -81,22 +81,22 @@ public interface Selectable extends AssignmentTestable
      * literals, the exact type is not inferrable since they are valid for many
      * different types and so this will return {@code null} too).
      */
-    public AbstractType<?> getExactTypeIfKnown(String keyspace);
+    AbstractType<?> getExactTypeIfKnown(String keyspace);
 
     /**
      * Checks if this {@code Selectable} select columns matching the specified predicate.
      * @return {@code true} if this {@code Selectable} select columns matching the specified predicate,
      * {@code false} otherwise.
      */
-    public boolean selectColumns(Predicate<ColumnMetadata> predicate);
+    boolean selectColumns(Predicate<ColumnMetadata> predicate);
 
     /**
      * Checks if the specified Selectables select columns matching the specified predicate.
      * @param selectables the selectables to check.
      * @return {@code true} if the specified Selectables select columns matching the specified predicate,
       {@code false} otherwise.
      */
-    public static boolean selectColumns(List<Selectable> selectables, Predicate<ColumnMetadata> predicate)
+    static boolean selectColumns(List<Selectable> selectables, Predicate<ColumnMetadata> predicate)
     {
         for (Selectable selectable : selectables)
         {
@@ -110,21 +110,21 @@ public static boolean selectColumns(List<Selectable> selectables, Predicate<Colu
      * Checks if any processing is performed on the selected columns, {@code false} otherwise.
      * @return {@code true} if any processing is performed on the selected columns, {@code false} otherwise.
      */
-    public default boolean processesSelection()
+    default boolean processesSelection()
     {
         // ColumnMetadata is the only case that returns false (if the column is not masked) and overrides this
         return true;
     }
 
     // Term.Raw overrides this since some literals can be WEAKLY_ASSIGNABLE
-    default public TestResult testAssignment(String keyspace, ColumnSpecification receiver)
+    default TestResult testAssignment(String keyspace, ColumnSpecification receiver)
     {
         AbstractType<?> type = getExactTypeIfKnown(keyspace);
         return type == null ? TestResult.NOT_ASSIGNABLE : type.testAssignment(keyspace, receiver);
     }
 
     @Override
-    public default AbstractType<?> getCompatibleTypeIfKnown(String keyspace)
+    default AbstractType<?> getCompatibleTypeIfKnown(String keyspace)
     {
         return getExactTypeIfKnown(keyspace);
     }
@@ -168,12 +168,12 @@ default void validateType(TableMetadata table, AbstractType<?> type)
             throw invalidRequest("%s is not of the expected type: %s", this, type.asCQL3Type());
     }
 
-    public interface Raw
+    interface Raw
     {
-        public Selectable prepare(TableMetadata table);
+        Selectable prepare(TableMetadata table);
     }
 
-    public static class WithTerm implements Selectable
+    class WithTerm implements Selectable
     {
         /**
          * The names given to unamed bind markers found in selection. In selection clause, we often don't have a good
@@ -282,7 +282,7 @@ public Selectable prepare(TableMetadata table)
         }
     }
 
-    public static class WritetimeOrTTL implements Selectable
+    class WritetimeOrTTL implements Selectable
     {
         // The order of the variants in the Kind enum matters as they are used in ser/deser
         public enum Kind
@@ -379,7 +379,7 @@ public WritetimeOrTTL prepare(TableMetadata table)
         }
     }
 
-    public static class WithFunction implements Selectable
+    class WithFunction implements Selectable
     {
         public final Function function;
         public final List<Selectable> args;
@@ -477,7 +477,7 @@ public Selectable prepare(TableMetadata table)
         }
     }
 
-    public static class WithCast implements Selectable
+    class WithCast implements Selectable
     {
         private final CQL3Type type;
         private final Selectable arg;
@@ -549,7 +549,7 @@ public WithCast prepare(TableMetadata table)
     /**
      * Represents the selection of the field of a UDT (eg. t.f).
      */
-    public static class WithFieldSelection implements Selectable
+    class WithFieldSelection implements Selectable
     {
         public final Selectable selected;
         public final FieldIdentifier field;
@@ -601,7 +601,7 @@ public Selector.Factory newSelectorFactory(TableMetadata table, AbstractType<?>
         public AbstractType<?> getExactTypeIfKnown(String keyspace)
         {
             AbstractType<?> selectedType = selected.getExactTypeIfKnown(keyspace);
-            if (selectedType == null || !(selectedType instanceof UserType))
+            if (!(selectedType instanceof UserType))
                 return null;
 
             UserType ut = (UserType) selectedType;
@@ -641,7 +641,7 @@ public WithFieldSelection prepare(TableMetadata table)
      * <p>The parser cannot differentiate between a single element between parentheses or a single element tuple.
      * By consequence, we are forced to wait until the type is known to be able to differentiate them.</p>
      */
-    public static class BetweenParenthesesOrWithTuple implements Selectable
+    class BetweenParenthesesOrWithTuple implements Selectable
     {
         /**
          * The tuple elements or the element between the parentheses
@@ -915,18 +915,6 @@ public AbstractType<?> getCompatibleTypeIfKnown(String keyspace)
         {
             return Lists.getPreferredCompatibleType(selectables, p -> p.getCompatibleTypeIfKnown(keyspace));
         }
-
-        @Override
-        public boolean selectColumns(Predicate<ColumnMetadata> predicate)
-        {
-            return Selectable.selectColumns(selectables, predicate);
-        }
-
-        @Override
-        public String toString()
-        {
-            return Lists.listToString(selectables);
-        }
     }
 
     public static class WithVector extends WithArrayLiteral
@@ -984,24 +972,12 @@ public AbstractType<?> getCompatibleTypeIfKnown(String keyspace)
         {
             return Vectors.getPreferredCompatibleType(selectables, p -> p.getCompatibleTypeIfKnown(keyspace));
         }
-
-        @Override
-        public boolean selectColumns(Predicate<ColumnMetadata> predicate)
-        {
-            return Selectable.selectColumns(selectables, predicate);
-        }
-
-        @Override
-        public String toString()
-        {
-            return Lists.listToString(selectables);
-        }
     }
 
     /**
      * <code>Selectable</code> for literal Sets.
      */
-    public static class WithSet implements Selectable
+    class WithSet implements Selectable
     {
         /**
          * The set elements
@@ -1104,7 +1080,7 @@ public Selectable prepare(TableMetadata cfm)
      * {@code ColumnIdentifier} is equivalent to a {@code FieldIdentifier} from a syntax point of view.
      * By consequence, we are forced to wait until the type is known to be able to differentiate them.</p>
      */
-    public static class WithMapOrUdt implements Selectable
+    class WithMapOrUdt implements Selectable
     {
         /**
          * The column family metadata. We need to store them to be able to build the proper data once the type has been
@@ -1289,7 +1265,7 @@ public Selectable prepare(TableMetadata cfm)
     /**
      * <code>Selectable</code> for type hints (e.g. (int) ?).
      */
-    public static class WithTypeHint implements Selectable
+    class WithTypeHint implements Selectable
     {
 
         /**
@@ -1401,7 +1377,7 @@ public Selectable prepare(TableMetadata cfm)
      * identifier have the same syntax. By consequence, we need to wait until the type is known to create the proper
      * Object: {@code ColumnMetadata} or {@code FieldIdentifier}.
      */
-    public static final class RawIdentifier implements Selectable.Raw
+    final class RawIdentifier implements Selectable.Raw
     {
         private final String text;
 
@@ -1456,7 +1432,7 @@ public String toString()
     /**
      * Represents the selection of an element of a collection (eg. c[x]).
      */
-    public static class WithElementSelection implements Selectable
+    class WithElementSelection implements Selectable
     {
         public final Selectable selected;
         // Note that we can't yet prepare the Term.Raw yet as we need the ColumnSpecificiation corresponding to Selectable, which
@@ -1487,20 +1463,20 @@ public Selector.Factory newSelectorFactory(TableMetadata cfm, AbstractType<?> ex
             if (!(type instanceof CollectionType))
                 throw new InvalidRequestException(String.format("Invalid element selection: %s is of type %s is not a collection", selected, type.asCQL3Type()));
 
-            ColumnSpecification boundSpec = specForElementOrSlice(selected, receiver, ((CollectionType) type).kind, "Element");
+            ColumnSpecification boundSpec = specForElementOrSlice(selected, receiver, ((CollectionType<?>) type).kind, "Element");
 
             Term elt = element.prepare(cfm.keyspace, boundSpec);
             elt.collectMarkerSpecification(boundNames);
-            return ElementsSelector.newElementFactory(toString(), factory, (CollectionType)type, elt);
+            return ElementsSelector.newElementFactory(toString(), factory, (CollectionType<?>)type, elt);
         }
 
         public AbstractType<?> getExactTypeIfKnown(String keyspace)
         {
             AbstractType<?> selectedType = selected.getExactTypeIfKnown(keyspace);
-            if (selectedType == null || !(selectedType instanceof CollectionType))
+            if (!(selectedType instanceof CollectionType))
                 return null;
 
-            return ElementsSelector.valueType((CollectionType) selectedType);
+            return ElementsSelector.valueType((CollectionType<?>) selectedType);
         }
 
         @Override
@@ -1536,7 +1512,7 @@ public String toString()
     /**
      * Represents the selection of a slice of a collection (eg. c[x..y]).
      */
-    public static class WithSliceSelection implements Selectable
+    class WithSliceSelection implements Selectable
     {
         public final Selectable selected;
         // Note that we can't yet prepare the Term.Raw yet as we need the ColumnSpecificiation corresponding to Selectable, which
@@ -1570,21 +1546,21 @@ public Selector.Factory newSelectorFactory(TableMetadata cfm, AbstractType<?> ex
             if (!(type instanceof CollectionType))
                 throw new InvalidRequestException(String.format("Invalid slice selection: %s of type %s is not a collection", selected, type.asCQL3Type()));
 
-            ColumnSpecification boundSpec = specForElementOrSlice(selected, receiver, ((CollectionType) type).kind, "Slice");
+            ColumnSpecification boundSpec = specForElementOrSlice(selected, receiver, ((CollectionType<?>) type).kind, "Slice");
 
             // If from or to are null, this means the user didn't provide on in the syntax (we had c[x..] or c[..x]).
             // The equivalent of doing this when preparing values would be to use UNSET.
             Term f = from == null ? Constants.UNSET_VALUE : from.prepare(cfm.keyspace, boundSpec);
             Term t = to == null ? Constants.UNSET_VALUE : to.prepare(cfm.keyspace, boundSpec);
             f.collectMarkerSpecification(boundNames);
             t.collectMarkerSpecification(boundNames);
-            return ElementsSelector.newSliceFactory(toString(), factory, (CollectionType)type, f, t);
+            return ElementsSelector.newSliceFactory(toString(), factory, (CollectionType<?>) type, f, t);
         }
 
         public AbstractType<?> getExactTypeIfKnown(String keyspace)
         {
             AbstractType<?> selectedType = selected.getExactTypeIfKnown(keyspace);
-            if (selectedType == null || !(selectedType instanceof CollectionType))
+            if (!(selectedType instanceof CollectionType))
                 return null;
 
             return selectedType;

src/java/org/apache/cassandra/cql3/selection/Selection.java

@@ -344,14 +344,14 @@ private static List<ByteBuffer> rowToJson(List<ByteBuffer> row,
         return Arrays.asList(jsonRow);
     }
 
-    public static interface Selectors
+    public interface Selectors
     {
         /**
          * Returns the {@code ColumnFilter} corresponding to those selectors
          *
          * @return the {@code ColumnFilter} corresponding to those selectors
          */
-        public ColumnFilter getColumnFilter();
+        ColumnFilter getColumnFilter();
 
         /**
          * Checks if this Selectors perform some processing
@@ -363,19 +363,19 @@ public static interface Selectors
          * Checks if one of the selectors perform some aggregations.
          * @return {@code true} if one of the selectors perform some aggregations, {@code false} otherwise.
          */
-        public boolean isAggregate();
+        boolean isAggregate();
 
         /**
          * Returns the number of fetched columns
          * @return the number of fetched columns
          */
-        public int numberOfFetchedColumns();
+        int numberOfFetchedColumns();
 
         /**
          * Checks if one of the selectors collect TTLs.
          * @return {@code true} if one of the selectors collect TTLs, {@code false} otherwise.
          */
-        public boolean collectTTLs();
+        boolean collectTTLs();
 
         /**
          * Checks if one of the selectors collects write timestamps.
@@ -390,9 +390,9 @@ public static interface Selectors
          */
         public void addInputRow(InputRow input);
 
-        public List<ByteBuffer> getOutputRow();
+        List<ByteBuffer> getOutputRow();
 
-        public void reset();
+        void reset();
     }
 
     // Special cased selection for when only columns are selected.

src/java/org/apache/cassandra/cql3/selection/WritetimeOrTTLSelector.java

@@ -117,6 +117,7 @@ public void addFetchedColumns(ColumnFilter.Builder builder)
         };
     }
 
+    @Override
     public void addFetchedColumns(ColumnFilter.Builder builder)
     {
         selected.addFetchedColumns(builder);
@@ -146,18 +147,21 @@ public void addInput(InputRow input)
         }
     }
 
+    @Override
     public ByteBuffer getOutput(ProtocolVersion protocolVersion)
     {
         return current;
     }
 
+    @Override
     public void reset()
     {
         selected.reset();
         isSet = false;
         current = null;
     }
 
+    @Override
     public AbstractType<?> getType()
     {
         AbstractType<?> type = kind.returnType;