How to use

skipForCache

method

in

org.apache.cassandra.db.RowIndexEntry$Serializer

public Future<Pair<KeyCacheKey, RowIndexEntry>> deserialize(DataInputPlus input, ColumnFamilyStore cfs) throws IOException
{
  //Keyspace and CF name are deserialized by AutoSaving cache and used to fetch the CFS provided as a
  //parameter so they aren't deserialized here, even though they are serialized by this serializer
  int keyLength = input.readInt();
  if (keyLength > FBUtilities.MAX_UNSIGNED_SHORT)
  {
    throw new IOException(String.format("Corrupted key cache. Key length of %d is longer than maximum of %d",
                      keyLength, FBUtilities.MAX_UNSIGNED_SHORT));
  }
  ByteBuffer key = ByteBufferUtil.read(input, keyLength);
  int generation = input.readInt();
  input.readBoolean(); // backwards compatibility for "promoted indexes" boolean
  SSTableReader reader;
  if (cfs == null || !cfs.isKeyCacheEnabled() || (reader = findDesc(generation, cfs.getSSTables(SSTableSet.CANONICAL))) == null)
  {
    // The sstable doesn't exist anymore, so we can't be sure of the exact version and assume its the current version. The only case where we'll be
    // wrong is during upgrade, in which case we fail at deserialization. This is not a huge deal however since 1) this is unlikely enough that
    // this won't affect many users (if any) and only once, 2) this doesn't prevent the node from starting and 3) CASSANDRA-10219 shows that this
    // part of the code has been broken for a while without anyone noticing (it is, btw, still broken until CASSANDRA-10219 is fixed).
    RowIndexEntry.Serializer.skipForCache(input, BigFormat.instance.getLatestVersion());
    return null;
  }
  RowIndexEntry.IndexSerializer<?> indexSerializer = reader.descriptor.getFormat().getIndexSerializer(reader.metadata,
                                                    reader.descriptor.version,
                                                    reader.header);
  RowIndexEntry<?> entry = indexSerializer.deserializeForCache(input);
  return Futures.immediateFuture(Pair.create(new KeyCacheKey(cfs.metadata.ksAndCFName, reader.descriptor, key), entry));
}

public Future<Pair<KeyCacheKey, RowIndexEntry>> deserialize(DataInputPlus input, ColumnFamilyStore cfs) throws IOException
{
  //Keyspace and CF name are deserialized by AutoSaving cache and used to fetch the CFS provided as a
  //parameter so they aren't deserialized here, even though they are serialized by this serializer
  int keyLength = input.readInt();
  if (keyLength > FBUtilities.MAX_UNSIGNED_SHORT)
  {
    throw new IOException(String.format("Corrupted key cache. Key length of %d is longer than maximum of %d",
                      keyLength, FBUtilities.MAX_UNSIGNED_SHORT));
  }
  ByteBuffer key = ByteBufferUtil.read(input, keyLength);
  int generation = input.readInt();
  input.readBoolean(); // backwards compatibility for "promoted indexes" boolean
  SSTableReader reader;
  if (cfs == null || !cfs.isKeyCacheEnabled() || (reader = findDesc(generation, cfs.getSSTables(SSTableSet.CANONICAL))) == null)
  {
    // The sstable doesn't exist anymore, so we can't be sure of the exact version and assume its the current version. The only case where we'll be
    // wrong is during upgrade, in which case we fail at deserialization. This is not a huge deal however since 1) this is unlikely enough that
    // this won't affect many users (if any) and only once, 2) this doesn't prevent the node from starting and 3) CASSANDRA-10219 shows that this
    // part of the code has been broken for a while without anyone noticing (it is, btw, still broken until CASSANDRA-10219 is fixed).
    RowIndexEntry.Serializer.skipForCache(input, BigFormat.instance.getLatestVersion());
    return null;
  }
  RowIndexEntry.IndexSerializer<?> indexSerializer = reader.descriptor.getFormat().getIndexSerializer(reader.metadata,
                                                    reader.descriptor.version,
                                                    reader.header);
  RowIndexEntry<?> entry = indexSerializer.deserializeForCache(input);
  return Futures.immediateFuture(Pair.create(new KeyCacheKey(cfs.metadata.ksAndCFName, reader.descriptor, key), entry));
}

public Future<Pair<KeyCacheKey, RowIndexEntry>> deserialize(DataInputPlus input, ColumnFamilyStore cfs) throws IOException
{
  //Keyspace and CF name are deserialized by AutoSaving cache and used to fetch the CFS provided as a
  //parameter so they aren't deserialized here, even though they are serialized by this serializer
  int keyLength = input.readInt();
  if (keyLength > FBUtilities.MAX_UNSIGNED_SHORT)
  {
    throw new IOException(String.format("Corrupted key cache. Key length of %d is longer than maximum of %d",
                      keyLength, FBUtilities.MAX_UNSIGNED_SHORT));
  }
  ByteBuffer key = ByteBufferUtil.read(input, keyLength);
  int generation = input.readInt();
  input.readBoolean(); // backwards compatibility for "promoted indexes" boolean
  SSTableReader reader;
  if (cfs == null || !cfs.isKeyCacheEnabled() || (reader = findDesc(generation, cfs.getSSTables(SSTableSet.CANONICAL))) == null)
  {
    // The sstable doesn't exist anymore, so we can't be sure of the exact version and assume its the current version. The only case where we'll be
    // wrong is during upgrade, in which case we fail at deserialization. This is not a huge deal however since 1) this is unlikely enough that
    // this won't affect many users (if any) and only once, 2) this doesn't prevent the node from starting and 3) CASSANDRA-10219 shows that this
    // part of the code has been broken for a while without anyone noticing (it is, btw, still broken until CASSANDRA-10219 is fixed).
    RowIndexEntry.Serializer.skipForCache(input, BigFormat.instance.getLatestVersion());
    return null;
  }
  RowIndexEntry.IndexSerializer<?> indexSerializer = reader.descriptor.getFormat().getIndexSerializer(reader.metadata,
                                                    reader.descriptor.version,
                                                    reader.header);
  RowIndexEntry<?> entry = indexSerializer.deserializeForCache(input);
  return Futures.immediateFuture(Pair.create(new KeyCacheKey(cfs.metadata.ksAndCFName, reader.descriptor, key), entry));
}