CNDB-12154: Port latest commits from main to main-5.0

src/java/org/apache/cassandra/db/memtable/DefaultMemtableFactory.java

@@ -18,12 +18,59 @@
 
 package org.apache.cassandra.db.memtable;
 
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.apache.cassandra.db.commitlog.CommitLogPosition;
+import org.apache.cassandra.db.partitions.PartitionUpdate;
+import org.apache.cassandra.db.partitions.TriePartitionUpdate;
+import org.apache.cassandra.metrics.TableMetrics;
+import org.apache.cassandra.schema.TableMetadataRef;
+
 /**
  * This class exists solely to avoid initialization of the default memtable class.
  * Some tests want to setup table parameters before initializing DatabaseDescriptor -- this allows them to do so.
  */
-public class DefaultMemtableFactory
+public class DefaultMemtableFactory implements Memtable.Factory
 {
-    // We can't use TrieMemtable.FACTORY as that requires DatabaseDescriptor to have been initialized.
-    public static final Memtable.Factory INSTANCE = (commitLogLowerBound, metadataRef, owner) -> new TrieMemtable(commitLogLowerBound, metadataRef, owner, null);
+    @Override
+    public Memtable create(AtomicReference<CommitLogPosition> commitLogLowerBound, TableMetadataRef metadaRef, Memtable.Owner owner)
+    {
+        return TrieMemtable.FACTORY.create(commitLogLowerBound, metadaRef, owner);
+    }
+
+    @Override
+    public boolean writesShouldSkipCommitLog()
+    {
+        return TrieMemtable.FACTORY.writesShouldSkipCommitLog();
+    }
+
+    @Override
+    public boolean writesAreDurable()
+    {
+        return TrieMemtable.FACTORY.writesAreDurable();
+    }
+
+    @Override
+    public boolean streamToMemtable()
+    {
+        return TrieMemtable.FACTORY.streamToMemtable();
+    }
+
+    @Override
+    public boolean streamFromMemtable()
+    {
+        return TrieMemtable.FACTORY.streamFromMemtable();
+    }
+
+    @Override
+    public TableMetrics.ReleasableMetric createMemtableMetrics(TableMetadataRef metadataRef)
+    {
+        return TrieMemtable.FACTORY.createMemtableMetrics(metadataRef);
+    }
+
+    @Override
+    public PartitionUpdate.Factory partitionUpdateFactory()
+    {
+        return TriePartitionUpdate.FACTORY;
+    }
 }

src/java/org/apache/cassandra/db/memtable/TrieMemtable.java

@@ -93,6 +93,8 @@ public class TrieMemtable extends AbstractShardedMemtable
 {
     private static final Logger logger = LoggerFactory.getLogger(TrieMemtable.class);
 
+    public static final Factory FACTORY = new TrieMemtable.Factory(null);
+
     /** Buffer type to use for memtable tries (on- vs off-heap) */
     public static final BufferType BUFFER_TYPE = DatabaseDescriptor.getMemtableAllocationType().toBufferType();
 
@@ -781,6 +783,13 @@ public UnfilteredRowIterator next()
         }
     }
 
+    public static Factory factory(Map<String, String> optionsCopy)
+    {
+        String shardsString = optionsCopy.remove(SHARDS_OPTION);
+        Integer shardCount = shardsString != null ? Integer.parseInt(shardsString) : null;
+        return new Factory(shardCount);
+    }
+
     static class Factory implements Memtable.Factory
     {
         final Integer shardCount;

src/java/org/apache/cassandra/index/sai/memory/TrieMemoryIndex.java

@@ -454,7 +454,7 @@ private KeyRangeIterator rangeMatch(Expression expression, AbstractBounds<Partit
                 // Before version DB, we encoded composite types using a non order-preserving function. In order to
                 // perform a range query on a map, we use the bounds to get all entries for a given map key and then
                 // only keep the map entries that satisfy the expression.
-                byte[] key = ByteSourceInverse.readBytes(entry.getKey().asComparableBytes(ByteComparable.Version.OSS50));
+                byte[] key = ByteSourceInverse.readBytes(entry.getKey().asComparableBytes(TypeUtil.BYTE_COMPARABLE_VERSION));
                 if (expression.isSatisfiedBy(ByteBuffer.wrap(key)))
                     mergingIteratorBuilder.add(entry.getValue());
             });