import org.apache.cassandra.cache.IRowCacheEntry; //导入依赖的package包/类
/**
 * @return the cached row for @param key if it is already present in the cache.
 * That is, unlike getThroughCache, it will not readAndCache the row if it is not present, nor
 * are these calls counted in cache statistics.
 *
 * Note that this WILL cause deserialization of a SerializingCache row, so if all you
 * need to know is whether a row is present or not, use containsCachedRow instead.
 */
public ColumnFamily getRawCachedRow(DecoratedKey key)
{
    if (!isRowCacheEnabled())
        return null;

    IRowCacheEntry cached = CacheService.instance.rowCache.getInternal(new RowCacheKey(metadata.cfId, key));
    return cached == null || cached instanceof RowCacheSentinel ? null : (ColumnFamily) cached;
}
 

import org.apache.cassandra.cache.IRowCacheEntry; //导入依赖的package包/类
public void maybeUpdateRowCache(DecoratedKey key, ColumnFamily columnFamily)
{
    if (!isRowCacheEnabled())
        return;

    RowCacheKey cacheKey = new RowCacheKey(metadata.cfId, key);

    // always invalidate a copying cache value
    if (CacheService.instance.rowCache.isPutCopying())
    {
        invalidateCachedRow(cacheKey);
        return;
    }

    // invalidate a normal cache value if it's a sentinel, so the read will retry (and include the new update)
    IRowCacheEntry cachedRow = CacheService.instance.rowCache.getInternal(cacheKey);
    if (cachedRow != null)
    {
        if (cachedRow instanceof RowCacheSentinel)
            invalidateCachedRow(cacheKey);
        else
            // columnFamily is what is written in the commit log. Because of the PeriodicCommitLog, this can be done in concurrency
            // with this. So columnFamily shouldn't be modified and if it contains super columns, neither should they. So for super
            // columns, we must make sure to clone them when adding to the cache. That's what addAllWithSCCopy does (see #3957)
            ((ColumnFamily) cachedRow).addAllWithSCCopy(columnFamily, HeapAllocator.instance);
    }
}
 

import org.apache.cassandra.cache.IRowCacheEntry; //导入依赖的package包/类
/**
 * @return the cached row for @param key if it is already present in the cache.
 * That is, unlike getThroughCache, it will not readAndCache the row if it is not present, nor
 * are these calls counted in cache statistics.
 *
 * Note that this WILL cause deserialization of a SerializingCache row, so if all you
 * need to know is whether a row is present or not, use containsCachedRow instead.
 */
public ColumnFamily getRawCachedRow(DecoratedKey key)
{
    if (!isRowCacheEnabled() || metadata.cfId == null)
        return null; // secondary index

    IRowCacheEntry cached = CacheService.instance.rowCache.getInternal(new RowCacheKey(metadata.cfId, key));
    return cached == null || cached instanceof RowCacheSentinel ? null : (ColumnFamily) cached;
}