/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.cassandra.db;
import java.io.File;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.nio.ByteBuffer;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.regex.Pattern;
import javax.management.*;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.collect.*;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.Uninterruptibles;
import org.cliffc.high_scale_lib.NonBlockingHashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.cassandra.cache.IRowCacheEntry;
import org.apache.cassandra.cache.RowCacheKey;
import org.apache.cassandra.cache.RowCacheSentinel;
import org.apache.cassandra.concurrent.JMXEnabledThreadPoolExecutor;
import org.apache.cassandra.config.CFMetaData;
import org.apache.cassandra.config.CFMetaData.SpeculativeRetry;
import org.apache.cassandra.config.ColumnDefinition;
import org.apache.cassandra.config.DatabaseDescriptor;
import org.apache.cassandra.config.Schema;
import org.apache.cassandra.db.columniterator.OnDiskAtomIterator;
import org.apache.cassandra.db.commitlog.CommitLog;
import org.apache.cassandra.db.commitlog.ReplayPosition;
import org.apache.cassandra.db.compaction.*;
import org.apache.cassandra.db.filter.*;
import org.apache.cassandra.db.index.SecondaryIndex;
import org.apache.cassandra.db.index.SecondaryIndexManager;
import org.apache.cassandra.db.marshal.AbstractType;
import org.apache.cassandra.db.marshal.CompositeType;
import org.apache.cassandra.dht.*;
import org.apache.cassandra.dht.Range;
import org.apache.cassandra.exceptions.ConfigurationException;
import org.apache.cassandra.io.FSReadError;
import org.apache.cassandra.io.compress.CompressionParameters;
import org.apache.cassandra.io.sstable.*;
import org.apache.cassandra.io.sstable.Descriptor;
import org.apache.cassandra.io.util.FileUtils;
import org.apache.cassandra.metrics.ColumnFamilyMetrics;
import org.apache.cassandra.service.CacheService;
import org.apache.cassandra.service.StorageService;
import org.apache.cassandra.tracing.Tracing;
import org.apache.cassandra.utils.*;
import static org.apache.cassandra.config.CFMetaData.Caching;
public class ColumnFamilyStore implements ColumnFamilyStoreMBean
{
private static final Logger logger = LoggerFactory.getLogger(ColumnFamilyStore.class);
public static final ExecutorService postFlushExecutor = new JMXEnabledThreadPoolExecutor("MemtablePostFlusher");
public final Keyspace keyspace;
public final String name;
public final CFMetaData metadata;
public final IPartitioner partitioner;
private final String mbeanName;
private volatile boolean valid = true;
/* Memtables and SSTables on disk for this column family */
private final DataTracker data;
/* This is used to generate the next index for a SSTable */
private final AtomicInteger fileIndexGenerator = new AtomicInteger(0);
public final SecondaryIndexManager indexManager;
private static final int INTERN_CUTOFF = 256;
public final ConcurrentMap<ByteBuffer, ByteBuffer> internedNames = new NonBlockingHashMap<ByteBuffer, ByteBuffer>();
/* These are locally held copies to be changed from the config during runtime */
private volatile DefaultInteger minCompactionThreshold;
private volatile DefaultInteger maxCompactionThreshold;
private volatile AbstractCompactionStrategy compactionStrategy;
public final Directories directories;
/** ratio of in-memory memtable size, to serialized size */
volatile double liveRatio = 10.0; // reasonable default until we compute what it is based on actual data
/** ops count last time we computed liveRatio */
private final AtomicLong liveRatioComputedAt = new AtomicLong(32);
public final ColumnFamilyMetrics metric;
public volatile long sampleLatencyNanos;
public void reload()
{
// metadata object has been mutated directly. make all the members jibe with new settings.
// only update these runtime-modifiable settings if they have not been modified.
if (!minCompactionThreshold.isModified())
for (ColumnFamilyStore cfs : concatWithIndexes())
cfs.minCompactionThreshold = new DefaultInteger(metadata.getMinCompactionThreshold());
if (!maxCompactionThreshold.isModified())
for (ColumnFamilyStore cfs : concatWithIndexes())
cfs.maxCompactionThreshold = new DefaultInteger(metadata.getMaxCompactionThreshold());
maybeReloadCompactionStrategy();
scheduleFlush();
indexManager.reload();
// If the CF comparator has changed, we need to change the memtable,
// because the old one still aliases the previous comparator.
if (getMemtableThreadSafe().initialComparator != metadata.comparator)
switchMemtable(true, true);
}
private void maybeReloadCompactionStrategy()
{
// Check if there is a need for reloading
if (metadata.compactionStrategyClass.equals(compactionStrategy.getClass()) && metadata.compactionStrategyOptions.equals(compactionStrategy.options))
return;
// synchronize vs runWithCompactionsDisabled calling pause/resume. otherwise, letting old compactions
// finish should be harmless and possibly useful.
synchronized (this)
{
compactionStrategy.shutdown();
compactionStrategy = metadata.createCompactionStrategyInstance(this);
}
}
void scheduleFlush()
{
int period = metadata.getMemtableFlushPeriod();
if (period > 0)
{
logger.debug("scheduling flush in {} ms", period);
WrappedRunnable runnable = new WrappedRunnable()
{
protected void runMayThrow() throws Exception
{
if (getMemtableThreadSafe().isExpired())
{
// if memtable is already expired but didn't flush because it's empty,
// then schedule another flush.
if (isClean())
scheduleFlush();
else
forceFlush(); // scheduleFlush() will be called by the constructor of the new memtable.
}
}
};
StorageService.scheduledTasks.schedule(runnable, period, TimeUnit.MILLISECONDS);
}
}
public void setCompactionStrategyClass(String compactionStrategyClass)
{
try
{
metadata.compactionStrategyClass = CFMetaData.createCompactionStrategy(compactionStrategyClass);
maybeReloadCompactionStrategy();
}
catch (ConfigurationException e)
{
throw new IllegalArgumentException(e.getMessage());
}
}
public String getCompactionStrategyClass()
{
return metadata.compactionStrategyClass.getName();
}
public Map<String,String> getCompressionParameters()
{
return metadata.compressionParameters().asThriftOptions();
}
public void setCompressionParameters(Map<String,String> opts)
{
try
{
metadata.compressionParameters = CompressionParameters.create(opts);
}
catch (ConfigurationException e)
{
throw new IllegalArgumentException(e.getMessage());
}
}
public void setCrcCheckChance(double crcCheckChance)
{
try
{
for (SSTableReader sstable : keyspace.getAllSSTables())
if (sstable.compression)
sstable.getCompressionMetadata().parameters.setCrcCheckChance(crcCheckChance);
}
catch (ConfigurationException e)
{
throw new IllegalArgumentException(e.getMessage());
}
}
private ColumnFamilyStore(Keyspace keyspace,
String columnFamilyName,
IPartitioner partitioner,
int generation,
CFMetaData metadata,
Directories directories,
boolean loadSSTables)
{
assert metadata != null : "null metadata for " + keyspace + ":" + columnFamilyName;
this.keyspace = keyspace;
name = columnFamilyName;
this.metadata = metadata;
this.minCompactionThreshold = new DefaultInteger(metadata.getMinCompactionThreshold());
this.maxCompactionThreshold = new DefaultInteger(metadata.getMaxCompactionThreshold());
this.partitioner = partitioner;
this.directories = directories;
this.indexManager = new SecondaryIndexManager(this);
this.metric = new ColumnFamilyMetrics(this);
fileIndexGenerator.set(generation);
sampleLatencyNanos = DatabaseDescriptor.getReadRpcTimeout() / 2;
Caching caching = metadata.getCaching();
logger.info("Initializing {}.{}", keyspace.getName(), name);
// scan for sstables corresponding to this cf and load them
data = new DataTracker(this);
if (loadSSTables)
{
Directories.SSTableLister sstableFiles = directories.sstableLister().skipTemporary(true);
Collection<SSTableReader> sstables = SSTableReader.openAll(sstableFiles.list().entrySet(), metadata, this.partitioner);
data.addInitialSSTables(sstables);
}
if (caching == Caching.ALL || caching == Caching.KEYS_ONLY)
CacheService.instance.keyCache.loadSaved(this);
// compaction strategy should be created after the CFS has been prepared
this.compactionStrategy = metadata.createCompactionStrategyInstance(this);
if (maxCompactionThreshold.value() <= 0 || minCompactionThreshold.value() <=0)
{
logger.warn("Disabling compaction strategy by setting compaction thresholds to 0 is deprecated, set the compaction option 'enabled' to 'false' instead.");
this.compactionStrategy.disable();
}
// create the private ColumnFamilyStores for the secondary column indexes
for (ColumnDefinition info : metadata.allColumns())
{
if (info.getIndexType() != null)
indexManager.addIndexedColumn(info);
}
// register the mbean
String type = this.partitioner instanceof LocalPartitioner ? "IndexColumnFamilies" : "ColumnFamilies";
mbeanName = "org.apache.cassandra.db:type=" + type + ",keyspace=" + this.keyspace.getName() + ",columnfamily=" + name;
try
{
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
ObjectName nameObj = new ObjectName(mbeanName);
mbs.registerMBean(this, nameObj);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
StorageService.optionalTasks.scheduleWithFixedDelay(new Runnable()
{
public void run()
{
SpeculativeRetry retryPolicy = ColumnFamilyStore.this.metadata.getSpeculativeRetry();
logger.debug("retryPolicy for {} is {}", name, retryPolicy.value);
switch (retryPolicy.type)
{
case PERCENTILE:
// get percentile in nanos
assert metric.coordinatorReadLatency.durationUnit() == TimeUnit.MICROSECONDS;
sampleLatencyNanos = (long) (metric.coordinatorReadLatency.getSnapshot().getValue(retryPolicy.value) * 1000d);
break;
case CUSTOM:
// convert to nanos, since configuration is in millisecond
sampleLatencyNanos = (long) (retryPolicy.value * 1000d * 1000d);
break;
default:
sampleLatencyNanos = Long.MAX_VALUE;
break;
}
}
}, DatabaseDescriptor.getReadRpcTimeout(), DatabaseDescriptor.getReadRpcTimeout(), TimeUnit.MILLISECONDS);
}
/** call when dropping or renaming a CF. Performs mbean housekeeping and invalidates CFS to other operations */
public void invalidate()
{
try
{
valid = false;
unregisterMBean();
SystemKeyspace.removeTruncationRecord(metadata.cfId);
data.unreferenceSSTables();
indexManager.invalidate();
}
catch (Exception e)
{
// this shouldn't block anything.
logger.warn("Failed unregistering mbean: {}", mbeanName, e);
}
}
/**
* Removes every SSTable in the directory from the DataTracker's view.
* @param directory the unreadable directory, possibly with SSTables in it, but not necessarily.
*/
void maybeRemoveUnreadableSSTables(File directory)
{
data.removeUnreadableSSTables(directory);
}
void unregisterMBean() throws MalformedObjectNameException, InstanceNotFoundException, MBeanRegistrationException
{
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
ObjectName nameObj = new ObjectName(mbeanName);
if (mbs.isRegistered(nameObj))
mbs.unregisterMBean(nameObj);
// unregister metrics
metric.release();
}
public long getMinRowSize()
{
return metric.minRowSize.value();
}
public long getMaxRowSize()
{
return metric.maxRowSize.value();
}
public long getMeanRowSize()
{
return metric.meanRowSize.value();
}
public int getMeanColumns()
{
return data.getMeanColumns();
}
public static ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace, String columnFamily, boolean loadSSTables)
{
return createColumnFamilyStore(keyspace, columnFamily, StorageService.getPartitioner(), Schema.instance.getCFMetaData(keyspace.getName(), columnFamily), loadSSTables);
}
public static ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace, String columnFamily, IPartitioner partitioner, CFMetaData metadata)
{
return createColumnFamilyStore(keyspace, columnFamily, partitioner, metadata, true);
}
private static synchronized ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace,
String columnFamily,
IPartitioner partitioner,
CFMetaData metadata,
boolean loadSSTables)
{
// get the max generation number, to prevent generation conflicts
Directories directories = Directories.create(keyspace.getName(), columnFamily);
Directories.SSTableLister lister = directories.sstableLister().includeBackups(true);
List<Integer> generations = new ArrayList<Integer>();
for (Map.Entry<Descriptor, Set<Component>> entry : lister.list().entrySet())
{
Descriptor desc = entry.getKey();
generations.add(desc.generation);
if (!desc.isCompatible())
throw new RuntimeException(String.format("Can't open incompatible SSTable! Current version %s, found file: %s", Descriptor.Version.CURRENT, desc));
}
Collections.sort(generations);
int value = (generations.size() > 0) ? (generations.get(generations.size() - 1)) : 0;
return new ColumnFamilyStore(keyspace, columnFamily, partitioner, value, metadata, directories, loadSSTables);
}
/**
* Removes unnecessary files from the cf directory at startup: these include temp files, orphans, zero-length files
* and compacted sstables. Files that cannot be recognized will be ignored.
*/
public static void scrubDataDirectories(String keyspaceName, String columnFamily)
{
logger.debug("Removing compacted SSTable files from {} (see http://wiki.apache.org/cassandra/MemtableSSTable)", columnFamily);
Directories directories = Directories.create(keyspaceName, columnFamily);
for (Map.Entry<Descriptor,Set<Component>> sstableFiles : directories.sstableLister().list().entrySet())
{
Descriptor desc = sstableFiles.getKey();
Set<Component> components = sstableFiles.getValue();
if (components.contains(Component.COMPACTED_MARKER) || desc.temporary)
{
SSTable.delete(desc, components);
continue;
}
File dataFile = new File(desc.filenameFor(Component.DATA));
if (components.contains(Component.DATA) && dataFile.length() > 0)
// everything appears to be in order... moving on.
continue;
// missing the DATA file! all components are orphaned
logger.warn("Removing orphans for {}: {}", desc, components);
for (Component component : components)
{
FileUtils.deleteWithConfirm(desc.filenameFor(component));
}
}
// cleanup incomplete saved caches
Pattern tmpCacheFilePattern = Pattern.compile(keyspaceName + "-" + columnFamily + "-(Key|Row)Cache.*\\.tmp$");
File dir = new File(DatabaseDescriptor.getSavedCachesLocation());
if (dir.exists())
{
assert dir.isDirectory();
for (File file : dir.listFiles())
if (tmpCacheFilePattern.matcher(file.getName()).matches())
if (!file.delete())
logger.warn("could not delete {}", file.getAbsolutePath());
}
// also clean out any index leftovers.
CFMetaData cfm = Schema.instance.getCFMetaData(keyspaceName, columnFamily);
if (cfm != null) // secondary indexes aren't stored in DD.
{
for (ColumnDefinition def : cfm.allColumns())
scrubDataDirectories(keyspaceName, cfm.indexColumnFamilyName(def));
}
}
/**
* Replacing compacted sstables is atomic as far as observers of DataTracker are concerned, but not on the
* filesystem: first the new sstables are renamed to "live" status (i.e., the tmp marker is removed), then
* their ancestors are removed.
*
* If an unclean shutdown happens at the right time, we can thus end up with both the new ones and their
* ancestors "live" in the system. This is harmless for normal data, but for counters it can cause overcounts.
*
* To prevent this, we record sstables being compacted in the system keyspace. If we find unfinished
* compactions, we remove the new ones (since those may be incomplete -- under LCS, we may create multiple
* sstables from any given ancestor).
*/
public static void removeUnfinishedCompactionLeftovers(String keyspace, String columnfamily, Set<Integer> unfinishedGenerations)
{
Directories directories = Directories.create(keyspace, columnfamily);
// sanity-check unfinishedGenerations
Set<Integer> allGenerations = new HashSet<Integer>();
for (Descriptor desc : directories.sstableLister().list().keySet())
allGenerations.add(desc.generation);
if (!allGenerations.containsAll(unfinishedGenerations))
{
throw new IllegalStateException("Unfinished compactions reference missing sstables."
+ " This should never happen since compactions are marked finished before we start removing the old sstables.");
}
// remove new sstables from compactions that didn't complete, and compute
// set of ancestors that shouldn't exist anymore
Set<Integer> completedAncestors = new HashSet<Integer>();
for (Map.Entry<Descriptor, Set<Component>> sstableFiles : directories.sstableLister().list().entrySet())
{
Descriptor desc = sstableFiles.getKey();
Set<Component> components = sstableFiles.getValue();
Set<Integer> ancestors;
try
{
ancestors = SSTableMetadata.serializer.deserialize(desc).right;
}
catch (IOException e)
{
throw new FSReadError(e, desc.filenameFor(Component.STATS));
}
if (!ancestors.isEmpty() && unfinishedGenerations.containsAll(ancestors))
{
SSTable.delete(desc, components);
}
else
{
completedAncestors.addAll(ancestors);
}
}
// remove old sstables from compactions that did complete
for (Map.Entry<Descriptor, Set<Component>> sstableFiles : directories.sstableLister().list().entrySet())
{
Descriptor desc = sstableFiles.getKey();
Set<Component> components = sstableFiles.getValue();
if (completedAncestors.contains(desc.generation))
SSTable.delete(desc, components);
}
}
// must be called after all sstables are loaded since row cache merges all row versions
public void initRowCache()
{
if (!isRowCacheEnabled())
return;
long start = System.nanoTime();
int cachedRowsRead = CacheService.instance.rowCache.loadSaved(this);
if (cachedRowsRead > 0)
logger.info("completed loading ({} ms; {} keys) row cache for {}.{}",
TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start),
cachedRowsRead,
keyspace.getName(),
name);
}
/**
* See #{@code StorageService.loadNewSSTables(String, String)} for more info
*
* @param ksName The keyspace name
* @param cfName The columnFamily name
*/
public static synchronized void loadNewSSTables(String ksName, String cfName)
{
/** ks/cf existence checks will be done by open and getCFS methods for us */
Keyspace keyspace = Keyspace.open(ksName);
keyspace.getColumnFamilyStore(cfName).loadNewSSTables();
}
/**
* #{@inheritDoc}
*/
public synchronized void loadNewSSTables()
{
logger.info("Loading new SSTables for {}/{}...", keyspace.getName(), name);
Set<Descriptor> currentDescriptors = new HashSet<Descriptor>();
for (SSTableReader sstable : data.getView().sstables)
currentDescriptors.add(sstable.descriptor);
Set<SSTableReader> newSSTables = new HashSet<SSTableReader>();
Directories.SSTableLister lister = directories.sstableLister().skipTemporary(true);
for (Map.Entry<Descriptor, Set<Component>> entry : lister.list().entrySet())
{
Descriptor descriptor = entry.getKey();
if (currentDescriptors.contains(descriptor))
continue; // old (initialized) SSTable found, skipping
if (descriptor.temporary) // in the process of being written
continue;
if (!descriptor.isCompatible())
throw new RuntimeException(String.format("Can't open incompatible SSTable! Current version %s, found file: %s",
Descriptor.Version.CURRENT,
descriptor));
// force foreign sstables to level 0
try
{
if (new File(descriptor.filenameFor(Component.STATS)).exists())
{
Pair<SSTableMetadata, Set<Integer>> oldMetadata = SSTableMetadata.serializer.deserialize(descriptor);
LeveledManifest.mutateLevel(oldMetadata, descriptor, descriptor.filenameFor(Component.STATS), 0);
}
}
catch (IOException e)
{
SSTableReader.logOpenException(entry.getKey(), e);
continue;
}
Descriptor newDescriptor = new Descriptor(descriptor.version,
descriptor.directory,
descriptor.ksname,
descriptor.cfname,
fileIndexGenerator.incrementAndGet(),
false);
logger.info("Renaming new SSTable {} to {}", descriptor, newDescriptor);
SSTableWriter.rename(descriptor, newDescriptor, entry.getValue());
SSTableReader reader;
try
{
reader = SSTableReader.open(newDescriptor, entry.getValue(), metadata, partitioner);
}
catch (IOException e)
{
SSTableReader.logOpenException(entry.getKey(), e);
continue;
}
newSSTables.add(reader);
}
if (newSSTables.isEmpty())
{
logger.info("No new SSTables were found for {}/{}", keyspace.getName(), name);
return;
}
logger.info("Loading new SSTables and building secondary indexes for {}/{}: {}", keyspace.getName(), name, newSSTables);
SSTableReader.acquireReferences(newSSTables);
data.addSSTables(newSSTables);
try
{
indexManager.maybeBuildSecondaryIndexes(newSSTables, indexManager.allIndexesNames());
}
finally
{
SSTableReader.releaseReferences(newSSTables);
}
logger.info("Done loading load new SSTables for {}/{}", keyspace.getName(), name);
}
public static void rebuildSecondaryIndex(String ksName, String cfName, String... idxNames)
{
ColumnFamilyStore cfs = Keyspace.open(ksName).getColumnFamilyStore(cfName);
Set<String> indexes = new HashSet<String>(Arrays.asList(idxNames));
Collection<SSTableReader> sstables = cfs.getSSTables();
try
{
cfs.indexManager.setIndexRemoved(indexes);
SSTableReader.acquireReferences(sstables);
logger.info(String.format("User Requested secondary index re-build for %s/%s indexes", ksName, cfName));
cfs.indexManager.maybeBuildSecondaryIndexes(sstables, indexes);
cfs.indexManager.setIndexBuilt(indexes);
}
finally
{
SSTableReader.releaseReferences(sstables);
}
}
public String getColumnFamilyName()
{
return name;
}
public String getTempSSTablePath(File directory)
{
return getTempSSTablePath(directory, Descriptor.Version.CURRENT);
}
private String getTempSSTablePath(File directory, Descriptor.Version version)
{
Descriptor desc = new Descriptor(version,
directory,
keyspace.getName(),
name,
fileIndexGenerator.incrementAndGet(),
true);
return desc.filenameFor(Component.DATA);
}
/**
* Switch and flush the current memtable, if it was dirty. The forceSwitch
* flag allow to force switching the memtable even if it is clean (though
* in that case we don't flush, as there is no point).
*/
public Future<?> switchMemtable(final boolean writeCommitLog, boolean forceSwitch)
{
/*
* If we can get the writelock, that means no new updates can come in and
* all ongoing updates to memtables have completed. We can get the tail
* of the log and use it as the starting position for log replay on recovery.
*
* This is why we Keyspace.switchLock needs to be global instead of per-Keyspace:
* we need to schedule discardCompletedSegments calls in the same order as their
* contexts (commitlog position) were read, even though the flush executor
* is multithreaded.
*/
Keyspace.switchLock.writeLock().lock();
try
{
final Future<ReplayPosition> ctx = writeCommitLog ? CommitLog.instance.getContext() : Futures.immediateFuture(ReplayPosition.NONE);
// submit the memtable for any indexed sub-cfses, and our own.
final List<ColumnFamilyStore> icc = new ArrayList<ColumnFamilyStore>();
// don't assume that this.memtable is dirty; forceFlush can bring us here during index build even if it is not
for (ColumnFamilyStore cfs : concatWithIndexes())
{
if (forceSwitch || !cfs.getMemtableThreadSafe().isClean())
icc.add(cfs);
}
final CountDownLatch latch = new CountDownLatch(icc.size());
for (ColumnFamilyStore cfs : icc)
{
Memtable memtable = cfs.data.switchMemtable();
// With forceSwitch it's possible to get a clean memtable here.
// In that case, since we've switched it already, just remove
// it from the memtable pending flush right away.
if (memtable.isClean())
{
cfs.replaceFlushed(memtable, null);
latch.countDown();
}
else
{
//pgaref was here
logger.info("Enqueuing flush of {}", memtable);
long CurrTime = (System.currentTimeMillis() -org.apache.cassandra.service.CassandraDaemon.compactionTimer)/1000;
org.apache.cassandra.db.compaction.CompactionTask.MyLogWriter("AcaZoo: " + CurrTime +" "+ "Enqueuing flush of memtable: "+ memtable);
memtable.flushAndSignal(latch, ctx);
}
}
if (metric.memtableSwitchCount.count() == Long.MAX_VALUE)
metric.memtableSwitchCount.clear();
metric.memtableSwitchCount.inc();
// when all the memtables have been written, including for indexes, mark the flush in the commitlog header.
// a second executor makes sure the onMemtableFlushes get called in the right order,
// while keeping the wait-for-flush (future.get) out of anything latency-sensitive.
return postFlushExecutor.submit(new WrappedRunnable()
{
public void runMayThrow() throws InterruptedException, ExecutionException
{
latch.await();
if (!icc.isEmpty())
{
//only valid when memtables exist
for (SecondaryIndex index : indexManager.getIndexesNotBackedByCfs())
{
// flush any non-cfs backed indexes
logger.info("Flushing SecondaryIndex {}", index);
index.forceBlockingFlush();
}
}
if (writeCommitLog)
{
// if we're not writing to the commit log, we are replaying the log, so marking
// the log header with "you can discard anything written before the context" is not valid
CommitLog.instance.discardCompletedSegments(metadata.cfId, ctx.get());
}
}
});
}
finally
{
Keyspace.switchLock.writeLock().unlock();
}
}
private boolean isClean()
{
// during index build, 2ary index memtables can be dirty even if parent is not. if so,
// we want flushLargestMemtables to flush the 2ary index ones too.
for (ColumnFamilyStore cfs : concatWithIndexes())
if (!cfs.getMemtableThreadSafe().isClean())
return false;
return true;
}
/**
* @return a future, with a guarantee that any data inserted prior to the forceFlush() call is fully flushed
* by the time future.get() returns. Never returns null.
*/
public Future<?> forceFlush()
{
if (isClean())
{
// We could have a memtable for this column family that is being
// flushed. Make sure the future returned wait for that so callers can
// assume that any data inserted prior to the call are fully flushed
// when the future returns (see #5241).
return postFlushExecutor.submit(new Runnable()
{
public void run()
{
logger.debug("forceFlush requested but everything is clean in {}", name);
}
});
}
return switchMemtable(true, false);
}
public void forceBlockingFlush()
{
FBUtilities.waitOnFuture(forceFlush());
}
public void maybeUpdateRowCache(DecoratedKey key)
{
if (!isRowCacheEnabled())
return;
RowCacheKey cacheKey = new RowCacheKey(metadata.cfId, key);
invalidateCachedRow(cacheKey);
}
/**
* Insert/Update the column family for this key.
* Caller is responsible for acquiring Keyspace.switchLock
* param @ lock - lock that needs to be used.
* param @ key - key for update/insert
* param @ columnFamily - columnFamily changes
*/
public void apply(DecoratedKey key, ColumnFamily columnFamily, SecondaryIndexManager.Updater indexer)
{
long start = System.nanoTime();
Memtable mt = getMemtableThreadSafe();
mt.put(key, columnFamily, indexer);
maybeUpdateRowCache(key);
metric.writeLatency.addNano(System.nanoTime() - start);
// recompute liveRatio, if we have doubled the number of ops since last calculated
while (true)
{
long last = liveRatioComputedAt.get();
long operations = metric.writeLatency.latency.count();
if (operations < 2 * last)
break;
if (liveRatioComputedAt.compareAndSet(last, operations))
{
logger.debug("computing liveRatio of {} at {} ops", this, operations);
mt.updateLiveRatio();
}
}
}
public static ColumnFamily removeDeletedCF(ColumnFamily cf, int gcBefore)
{
cf.maybeResetDeletionTimes(gcBefore);
return cf.getColumnCount() == 0 && !cf.isMarkedForDelete() ? null : cf;
}
public static ColumnFamily removeDeleted(ColumnFamily cf, int gcBefore)
{
return removeDeleted(cf, gcBefore, SecondaryIndexManager.nullUpdater);
}
/*
This is complicated because we need to preserve deleted columns, supercolumns, and columnfamilies
until they have been deleted for at least GC_GRACE_IN_SECONDS. But, we do not need to preserve
their contents; just the object itself as a "tombstone" that can be used to repair other
replicas that do not know about the deletion.
*/
public static ColumnFamily removeDeleted(ColumnFamily cf, int gcBefore, SecondaryIndexManager.Updater indexer)
{
if (cf == null)
{
return null;
}
removeDeletedColumnsOnly(cf, gcBefore, indexer);
return removeDeletedCF(cf, gcBefore);
}
private static void removeDeletedColumnsOnly(ColumnFamily cf, int gcBefore, SecondaryIndexManager.Updater indexer)
{
Iterator<Column> iter = cf.iterator();
DeletionInfo.InOrderTester tester = cf.inOrderDeletionTester();
boolean hasDroppedColumns = !cf.metadata.getDroppedColumns().isEmpty();
while (iter.hasNext())
{
Column c = iter.next();
// remove columns if
// (a) the column itself is gcable or
// (b) the column is shadowed by a CF tombstone
// (c) the column has been dropped from the CF schema (CQL3 tables only)
if (c.getLocalDeletionTime() < gcBefore || tester.isDeleted(c) || (hasDroppedColumns && isDroppedColumn(c, cf.metadata())))
{
iter.remove();
indexer.remove(c);
}
}
}
public static void removeDeletedColumnsOnly(ColumnFamily cf, int gcBefore)
{
removeDeletedColumnsOnly(cf, gcBefore, SecondaryIndexManager.nullUpdater);
}
// returns true if
// 1. this column has been dropped from schema and
// 2. if it has been re-added since then, this particular column was inserted before the last drop
private static boolean isDroppedColumn(Column c, CFMetaData meta)
{
Long droppedAt = meta.getDroppedColumns().get(((CompositeType) meta.comparator).extractLastComponent(c.name()));
return droppedAt != null && c.timestamp() <= droppedAt;
}
private void removeDroppedColumns(ColumnFamily cf)
{
if (cf == null || cf.metadata.getDroppedColumns().isEmpty())
return;
Iterator<Column> iter = cf.iterator();
while (iter.hasNext())
if (isDroppedColumn(iter.next(), metadata))
iter.remove();
}
/**
* @param sstables
* @return sstables whose key range overlaps with that of the given sstables, not including itself.
* (The given sstables may or may not overlap with each other.)
*/
public Set<SSTableReader> getOverlappingSSTables(Collection<SSTableReader> sstables)
{
logger.debug("Checking for sstables overlapping {}", sstables);
// a normal compaction won't ever have an empty sstables list, but we create a skeleton
// compaction controller for streaming, and that passes an empty list.
if (sstables.isEmpty())
return ImmutableSet.of();
DataTracker.SSTableIntervalTree tree = data.getView().intervalTree;
Set<SSTableReader> results = null;
for (SSTableReader sstable : sstables)
{
Set<SSTableReader> overlaps = ImmutableSet.copyOf(tree.search(Interval.<RowPosition, SSTableReader>create(sstable.first, sstable.last)));
results = results == null ? overlaps : Sets.union(results, overlaps).immutableCopy();
}
results = Sets.difference(results, ImmutableSet.copyOf(sstables));
return results;
}
/**
* like getOverlappingSSTables, but acquires references before returning
*/
public Set<SSTableReader> getAndReferenceOverlappingSSTables(Collection<SSTableReader> sstables)
{
while (true)
{
Set<SSTableReader> overlapped = getOverlappingSSTables(sstables);
if (SSTableReader.acquireReferences(overlapped))
return overlapped;
}
}
/*
* Called after a BinaryMemtable flushes its in-memory data, or we add a file
* via bootstrap. This information is cached in the ColumnFamilyStore.
* This is useful for reads because the ColumnFamilyStore first looks in
* the in-memory store and the into the disk to find the key. If invoked
* during recoveryMode the onMemtableFlush() need not be invoked.
*
* param @ filename - filename just flushed to disk
*/
public void addSSTable(SSTableReader sstable)
{
assert sstable.getColumnFamilyName().equals(name);
addSSTables(Arrays.asList(sstable));
}
public void addSSTables(Collection<SSTableReader> sstables)
{
data.addSSTables(sstables);
CompactionManager.instance.submitBackground(this);
}
/**
* Calculate expected file size of SSTable after compaction.
*
* If operation type is {@code CLEANUP} and we're not dealing with an index sstable,
* then we calculate expected file size with checking token range to be eliminated.
*
* Otherwise, we just add up all the files' size, which is the worst case file
* size for compaction of all the list of files given.
*
* @param sstables SSTables to calculate expected compacted file size
* @param operation Operation type
* @return Expected file size of SSTable after compaction
*/
public long getExpectedCompactedFileSize(Iterable<SSTableReader> sstables, OperationType operation)
{
if (operation != OperationType.CLEANUP || isIndex())
{
return SSTable.getTotalBytes(sstables);
}
// cleanup size estimation only counts bytes for keys local to this node
long expectedFileSize = 0;
Collection<Range<Token>> ranges = StorageService.instance.getLocalRanges(keyspace.getName());
for (SSTableReader sstable : sstables)
{
List<Pair<Long, Long>> positions = sstable.getPositionsForRanges(ranges);
for (Pair<Long, Long> position : positions)
expectedFileSize += position.right - position.left;
}
return expectedFileSize;
}
/*
* Find the maximum size file in the list .
*/
public SSTableReader getMaxSizeFile(Iterable<SSTableReader> sstables)
{
long maxSize = 0L;
SSTableReader maxFile = null;
for (SSTableReader sstable : sstables)
{
if (sstable.onDiskLength() > maxSize)
{
maxSize = sstable.onDiskLength();
maxFile = sstable;
}
}
return maxFile;
}
public void forceCleanup(CounterId.OneShotRenewer renewer) throws ExecutionException, InterruptedException
{
CompactionManager.instance.performCleanup(ColumnFamilyStore.this, renewer);
}
public void scrub(boolean disableSnapshot) throws ExecutionException, InterruptedException
{
// skip snapshot creation during scrub, SEE JIRA 5891
if(!disableSnapshot)
snapshotWithoutFlush("pre-scrub-" + System.currentTimeMillis());
CompactionManager.instance.performScrub(ColumnFamilyStore.this);
}
public void sstablesRewrite(boolean excludeCurrentVersion) throws ExecutionException, InterruptedException
{
CompactionManager.instance.performSSTableRewrite(ColumnFamilyStore.this, excludeCurrentVersion);
}
public void markObsolete(Collection<SSTableReader> sstables, OperationType compactionType)
{
assert !sstables.isEmpty();
data.markObsolete(sstables, compactionType);
}
public void replaceCompactedSSTables(Collection<SSTableReader> sstables, Collection<SSTableReader> replacements, OperationType compactionType)
{
data.replaceCompactedSSTables(sstables, replacements, compactionType);
}
void replaceFlushed(Memtable memtable, SSTableReader sstable)
{
compactionStrategy.replaceFlushed(memtable, sstable);
}
public boolean isValid()
{
return valid;
}
public long getMemtableColumnsCount()
{
return metric.memtableColumnsCount.value();
}
public long getMemtableDataSize()
{
return metric.memtableDataSize.value();
}
public long getTotalMemtableLiveSize()
{
return getMemtableDataSize() + indexManager.getTotalLiveSize();
}
public int getMemtableSwitchCount()
{
return (int) metric.memtableSwitchCount.count();
}
Memtable getMemtableThreadSafe()
{
return data.getMemtable();
}
/**
* Package protected for access from the CompactionManager.
*/
public DataTracker getDataTracker()
{
return data;
}
public Collection<SSTableReader> getSSTables()
{
return data.getSSTables();
}
public Set<SSTableReader> getUncompactingSSTables()
{
return data.getUncompactingSSTables();
}
public long[] getRecentSSTablesPerReadHistogram()
{
return metric.recentSSTablesPerRead.getBuckets(true);
}
public long[] getSSTablesPerReadHistogram()
{
return metric.sstablesPerRead.getBuckets(false);
}
public long getReadCount()
{
return metric.readLatency.latency.count();
}
public double getRecentReadLatencyMicros()
{
return metric.readLatency.getRecentLatency();
}
public long[] getLifetimeReadLatencyHistogramMicros()
{
return metric.readLatency.totalLatencyHistogram.getBuckets(false);
}
public long[] getRecentReadLatencyHistogramMicros()
{
return metric.readLatency.recentLatencyHistogram.getBuckets(true);
}
public long getTotalReadLatencyMicros()
{
return metric.readLatency.totalLatency.count();
}
public int getPendingTasks()
{
return metric.pendingTasks.value();
}
public long getWriteCount()
{
return metric.writeLatency.latency.count();
}
public long getTotalWriteLatencyMicros()
{
return metric.writeLatency.totalLatency.count();
}
public double getRecentWriteLatencyMicros()
{
return metric.writeLatency.getRecentLatency();
}
public long[] getLifetimeWriteLatencyHistogramMicros()
{
return metric.writeLatency.totalLatencyHistogram.getBuckets(false);
}
public long[] getRecentWriteLatencyHistogramMicros()
{
return metric.writeLatency.recentLatencyHistogram.getBuckets(true);
}
public ColumnFamily getColumnFamily(DecoratedKey key,
ByteBuffer start,
ByteBuffer finish,
boolean reversed,
int limit,
long timestamp)
{
return getColumnFamily(QueryFilter.getSliceFilter(key, name, start, finish, reversed, limit, timestamp));
}
/**
* fetch the row given by filter.key if it is in the cache; if not, read it from disk and cache it
* @param cfId the column family to read the row from
* @param filter the columns being queried. Note that we still cache entire rows, but if a row is uncached
* and we race to cache it, only the winner will read the entire row
* @return the entire row for filter.key, if present in the cache (or we can cache it), or just the column
* specified by filter otherwise
*/
private ColumnFamily getThroughCache(UUID cfId, QueryFilter filter)
{
assert isRowCacheEnabled()
: String.format("Row cache is not enabled on column family [" + name + "]");
RowCacheKey key = new RowCacheKey(cfId, filter.key);
// attempt a sentinel-read-cache sequence. if a write invalidates our sentinel, we'll return our
// (now potentially obsolete) data, but won't cache it. see CASSANDRA-3862
IRowCacheEntry cached = CacheService.instance.rowCache.get(key);
if (cached != null)
{
if (cached instanceof RowCacheSentinel)
{
// Some other read is trying to cache the value, just do a normal non-caching read
Tracing.trace("Row cache miss (race)");
return getTopLevelColumns(filter, Integer.MIN_VALUE);
}
Tracing.trace("Row cache hit");
return (ColumnFamily) cached;
}
Tracing.trace("Row cache miss");
RowCacheSentinel sentinel = new RowCacheSentinel();
boolean sentinelSuccess = CacheService.instance.rowCache.putIfAbsent(key, sentinel);
try
{
ColumnFamily data = getTopLevelColumns(QueryFilter.getIdentityFilter(filter.key, name, filter.timestamp),
Integer.MIN_VALUE);
if (sentinelSuccess && data != null)
CacheService.instance.rowCache.replace(key, sentinel, data);
return data;
}
finally
{
if (sentinelSuccess && data == null)
CacheService.instance.rowCache.remove(key);
}
}
public int gcBefore(long now)
{
return (int) (now / 1000) - metadata.getGcGraceSeconds();
}
/**
* get a list of columns starting from a given column, in a specified order.
* only the latest version of a column is returned.
* @return null if there is no data and no tombstones; otherwise a ColumnFamily
*/
public ColumnFamily getColumnFamily(QueryFilter filter)
{
assert name.equals(filter.getColumnFamilyName()) : filter.getColumnFamilyName();
ColumnFamily result = null;
long start = System.nanoTime();
try
{
int gcBefore = gcBefore(filter.timestamp);
if (isRowCacheEnabled())
{
UUID cfId = Schema.instance.getId(keyspace.getName(), name);
if (cfId == null)
{
logger.trace("no id found for {}.{}", keyspace.getName(), name);
return null;
}
ColumnFamily cached = getThroughCache(cfId, filter);
if (cached == null)
{
logger.trace("cached row is empty");
return null;
}
result = filterColumnFamily(cached, filter);
}
else
{
ColumnFamily cf = getTopLevelColumns(filter, gcBefore);
if (cf == null)
return null;
result = removeDeletedCF(cf, gcBefore);
}
removeDroppedColumns(result);
if (filter.filter instanceof SliceQueryFilter)
{
// Log the number of tombstones scanned on single key queries
metric.tombstoneScannedHistogram.update(((SliceQueryFilter) filter.filter).lastIgnored());
metric.liveScannedHistogram.update(((SliceQueryFilter) filter.filter).lastLive());
}
}
finally
{
metric.readLatency.addNano(System.nanoTime() - start);
}
return result;
}
/**
* Filter a cached row, which will not be modified by the filter, but may be modified by throwing out
* tombstones that are no longer relevant.
* The returned column family won't be thread safe.
*/
ColumnFamily filterColumnFamily(ColumnFamily cached, QueryFilter filter)
{
ColumnFamily cf = cached.cloneMeShallow(ArrayBackedSortedColumns.factory, filter.filter.isReversed());
OnDiskAtomIterator ci = filter.getColumnFamilyIterator(cached);
int gcBefore = gcBefore(filter.timestamp);
filter.collateOnDiskAtom(cf, ci, gcBefore);
return removeDeletedCF(cf, gcBefore);
}
/**
* Get the current view and acquires references on all its sstables.
* This is a bit tricky because we must ensure that between the time we
* get the current view and the time we acquire the references the set of
* sstables hasn't changed. Otherwise we could get a view for which an
* sstable have been deleted in the meantime.
*
* At the end of this method, a reference on all the sstables of the
* returned view will have been acquired and must thus be released when
* appropriate.
*/
private DataTracker.View markCurrentViewReferenced()
{
while (true)
{
DataTracker.View currentView = data.getView();
if (SSTableReader.acquireReferences(currentView.sstables))
return currentView;
}
}
/**
* Get the current sstables, acquiring references on all of them.
* The caller is in charge of releasing the references on the sstables.
*
* See markCurrentViewReferenced() above.
*/
public Collection<SSTableReader> markCurrentSSTablesReferenced()
{
return markCurrentViewReferenced().sstables;
}
abstract class AbstractViewSSTableFinder
{
abstract List<SSTableReader> findSSTables(DataTracker.View view);
protected List<SSTableReader> sstablesForRowBounds(AbstractBounds<RowPosition> rowBounds, DataTracker.View view)
{
RowPosition stopInTree = rowBounds.right.isMinimum() ? view.intervalTree.max() : rowBounds.right;
return view.intervalTree.search(Interval.<RowPosition, SSTableReader>create(rowBounds.left, stopInTree));
}
}
private ViewFragment markReferenced(AbstractViewSSTableFinder finder)
{
List<SSTableReader> sstables;
DataTracker.View view;
while (true)
{
view = data.getView();
if (view.intervalTree.isEmpty())
{
sstables = Collections.emptyList();
break;
}
sstables = finder.findSSTables(view);
if (SSTableReader.acquireReferences(sstables))
break;
// retry w/ new view
}
return new ViewFragment(sstables, Iterables.concat(Collections.singleton(view.memtable), view.memtablesPendingFlush));
}
/**
* @return a ViewFragment containing the sstables and memtables that may need to be merged
* for the given @param key, according to the interval tree
*/
public ViewFragment markReferenced(final DecoratedKey key)
{
assert !key.isMinimum();
return markReferenced(new AbstractViewSSTableFinder()
{
List<SSTableReader> findSSTables(DataTracker.View view)
{
return compactionStrategy.filterSSTablesForReads(view.intervalTree.search(key));
}
});
}
/**
* @return a ViewFragment containing the sstables and memtables that may need to be merged
* for rows within @param rowBounds, inclusive, according to the interval tree.
*/
public ViewFragment markReferenced(final AbstractBounds<RowPosition> rowBounds)
{
return markReferenced(new AbstractViewSSTableFinder()
{
List<SSTableReader> findSSTables(DataTracker.View view)
{
return compactionStrategy.filterSSTablesForReads(sstablesForRowBounds(rowBounds, view));
}
});
}
/**
* @return a ViewFragment containing the sstables and memtables that may need to be merged
* for rows for all of @param rowBoundsCollection, inclusive, according to the interval tree.
*/
public ViewFragment markReferenced(final Collection<AbstractBounds<RowPosition>> rowBoundsCollection)
{
return markReferenced(new AbstractViewSSTableFinder()
{
List<SSTableReader> findSSTables(DataTracker.View view)
{
Set<SSTableReader> sstables = Sets.newHashSet();
for (AbstractBounds<RowPosition> rowBounds : rowBoundsCollection)
sstables.addAll(sstablesForRowBounds(rowBounds, view));
return ImmutableList.copyOf(sstables);
}
});
}
public List<String> getSSTablesForKey(String key)
{
DecoratedKey dk = new DecoratedKey(partitioner.getToken(ByteBuffer.wrap(key.getBytes())), ByteBuffer.wrap(key.getBytes()));
ViewFragment view = markReferenced(dk);
try
{
List<String> files = new ArrayList<String>();
for (SSTableReader sstr : view.sstables)
{
// check if the key actually exists in this sstable, without updating cache and stats
if (sstr.getPosition(dk, SSTableReader.Operator.EQ, false) != null)
files.add(sstr.getFilename());
}
return files;
}
finally
{
SSTableReader.releaseReferences(view.sstables);
}
}
public ColumnFamily getTopLevelColumns(QueryFilter filter, int gcBefore)
{
Tracing.trace("Executing single-partition query on {}", name);
CollationController controller = new CollationController(this, filter, gcBefore);
ColumnFamily columns = controller.getTopLevelColumns();
metric.updateSSTableIterated(controller.getSstablesIterated());
return columns;
}
public void cleanupCache()
{
Collection<Range<Token>> ranges = StorageService.instance.getLocalRanges(keyspace.getName());
for (RowCacheKey key : CacheService.instance.rowCache.getKeySet())
{
DecoratedKey dk = partitioner.decorateKey(ByteBuffer.wrap(key.key));
if (key.cfId == metadata.cfId && !Range.isInRanges(dk.token, ranges))
invalidateCachedRow(dk);
}
}
public static abstract class AbstractScanIterator extends AbstractIterator<Row> implements CloseableIterator<Row>
{
public boolean needsFiltering()
{
return true;
}
}
/**
* Iterate over a range of rows and columns from memtables/sstables.
*
* @param range The range of keys and columns within those keys to fetch
*/
private AbstractScanIterator getSequentialIterator(final DataRange range, long now)
{
assert !(range.keyRange() instanceof Range) || !((Range)range.keyRange()).isWrapAround() || range.keyRange().right.isMinimum() : range.keyRange();
final ViewFragment view = markReferenced(range.keyRange());
Tracing.trace("Executing seq scan across {} sstables for {}", view.sstables.size(), range.keyRange().getString(metadata.getKeyValidator()));
try
{
final CloseableIterator<Row> iterator = RowIteratorFactory.getIterator(view.memtables, view.sstables, range, this, now);
// todo this could be pushed into SSTableScanner
return new AbstractScanIterator()
{
protected Row computeNext()
{
// pull a row out of the iterator
if (!iterator.hasNext())
return endOfData();
Row current = iterator.next();
DecoratedKey key = current.key;
if (!range.stopKey().isMinimum() && range.stopKey().compareTo(key) < 0)
return endOfData();
// skipping outside of assigned range
if (!range.contains(key))
return computeNext();
if (logger.isTraceEnabled())
logger.trace("scanned {}", metadata.getKeyValidator().getString(key.key));
return current;
}
public void close() throws IOException
{
SSTableReader.releaseReferences(view.sstables);
iterator.close();
}
};
}
catch (RuntimeException e)
{
// In case getIterator() throws, otherwise the iteror close method releases the references.
SSTableReader.releaseReferences(view.sstables);
throw e;
}
}
@VisibleForTesting
public List<Row> getRangeSlice(final AbstractBounds<RowPosition> range,
List<IndexExpression> rowFilter,
IDiskAtomFilter columnFilter,
int maxResults)
{
return getRangeSlice(range, rowFilter, columnFilter, maxResults, System.currentTimeMillis());
}
public List<Row> getRangeSlice(final AbstractBounds<RowPosition> range,
List<IndexExpression> rowFilter,
IDiskAtomFilter columnFilter,
int maxResults,
long now)
{
return getRangeSlice(makeExtendedFilter(range, columnFilter, rowFilter, maxResults, false, false, now));
}
/**
* Allows generic range paging with the slice column filter.
* Typically, suppose we have rows A, B, C ... Z having each some columns in [1, 100].
* And suppose we want to page throught the query that for all rows returns the columns
* within [25, 75]. For that, we need to be able to do a range slice starting at (row r, column c)
* and ending at (row Z, column 75), *but* that only return columns in [25, 75].
* That is what this method allows. The columnRange is the "window" of columns we are interested
* in each row, and columnStart (resp. columnEnd) is the start (resp. end) for the first
* (resp. end) requested row.
*/
public ExtendedFilter makeExtendedFilter(AbstractBounds<RowPosition> keyRange,
SliceQueryFilter columnRange,
ByteBuffer columnStart,
ByteBuffer columnStop,
List<IndexExpression> rowFilter,
int maxResults,
long now)
{
DataRange dataRange = new DataRange.Paging(keyRange, columnRange, columnStart, columnStop, metadata.comparator);
return ExtendedFilter.create(this, dataRange, rowFilter, maxResults, true, now);
}
public List<Row> getRangeSlice(AbstractBounds<RowPosition> range,
List<IndexExpression> rowFilter,
IDiskAtomFilter columnFilter,
int maxResults,
long now,
boolean countCQL3Rows,
boolean isPaging)
{
return getRangeSlice(makeExtendedFilter(range, columnFilter, rowFilter, maxResults, countCQL3Rows, isPaging, now));
}
public ExtendedFilter makeExtendedFilter(AbstractBounds<RowPosition> range,
IDiskAtomFilter columnFilter,
List<IndexExpression> rowFilter,
int maxResults,
boolean countCQL3Rows,
boolean isPaging,
long timestamp)
{
DataRange dataRange;
if (isPaging)
{
assert columnFilter instanceof SliceQueryFilter;
SliceQueryFilter sfilter = (SliceQueryFilter)columnFilter;
assert sfilter.slices.length == 1;
SliceQueryFilter newFilter = new SliceQueryFilter(ColumnSlice.ALL_COLUMNS_ARRAY, sfilter.isReversed(), sfilter.count);
dataRange = new DataRange.Paging(range, newFilter, sfilter.start(), sfilter.finish(), metadata.comparator);
}
else
{
dataRange = new DataRange(range, columnFilter);
}
return ExtendedFilter.create(this, dataRange, rowFilter, maxResults, countCQL3Rows, timestamp);
}
public List<Row> getRangeSlice(ExtendedFilter filter)
{
return filter(getSequentialIterator(filter.dataRange, filter.timestamp), filter);
}
@VisibleForTesting
public List<Row> search(AbstractBounds<RowPosition> range,
List<IndexExpression> clause,
IDiskAtomFilter dataFilter,
int maxResults)
{
return search(range, clause, dataFilter, maxResults, System.currentTimeMillis());
}
public List<Row> search(AbstractBounds<RowPosition> range,
List<IndexExpression> clause,
IDiskAtomFilter dataFilter,
int maxResults,
long now)
{
return search(makeExtendedFilter(range, dataFilter, clause, maxResults, false, false, now));
}
public List<Row> search(ExtendedFilter filter)
{
Tracing.trace("Executing indexed scan for {}", filter.dataRange.keyRange().getString(metadata.getKeyValidator()));
return indexManager.search(filter);
}
public List<Row> filter(AbstractScanIterator rowIterator, ExtendedFilter filter)
{
logger.trace("Filtering {} for rows matching {}", rowIterator, filter);
List<Row> rows = new ArrayList<Row>();
int columnsCount = 0;
int total = 0, matched = 0;
try
{
while (rowIterator.hasNext() && matched < filter.maxRows() && columnsCount < filter.maxColumns())
{
// get the raw columns requested, and additional columns for the expressions if necessary
Row rawRow = rowIterator.next();
total++;
ColumnFamily data = rawRow.cf;
if (rowIterator.needsFiltering())
{
IDiskAtomFilter extraFilter = filter.getExtraFilter(rawRow.key, data);
if (extraFilter != null)
{
ColumnFamily cf = filter.cfs.getColumnFamily(new QueryFilter(rawRow.key, name, extraFilter, filter.timestamp));
if (cf != null)
data.addAll(cf, HeapAllocator.instance);
}
removeDroppedColumns(data);
if (!filter.isSatisfiedBy(rawRow.key, data, null))
continue;
logger.trace("{} satisfies all filter expressions", data);
// cut the resultset back to what was requested, if necessary
data = filter.prune(rawRow.key, data);
}
else
{
removeDroppedColumns(data);
}
rows.add(new Row(rawRow.key, data));
matched++;
if (data != null)
columnsCount += filter.lastCounted(data);
// Update the underlying filter to avoid querying more columns per slice than necessary and to handle paging
filter.updateFilter(columnsCount);
}
return rows;
}
finally
{
try
{
rowIterator.close();
Tracing.trace("Scanned {} rows and matched {}", total, matched);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
}
public AbstractType<?> getComparator()
{
return metadata.comparator;
}
public void snapshotWithoutFlush(String snapshotName)
{
for (ColumnFamilyStore cfs : concatWithIndexes())
{
DataTracker.View currentView = cfs.markCurrentViewReferenced();
try
{
for (SSTableReader ssTable : currentView.sstables)
{
File snapshotDirectory = Directories.getSnapshotDirectory(ssTable.descriptor, snapshotName);
ssTable.createLinks(snapshotDirectory.getPath()); // hard links
if (logger.isDebugEnabled())
logger.debug("Snapshot for {} keyspace data file {} created in {}", keyspace, ssTable.getFilename(), snapshotDirectory);
}
}
finally
{
SSTableReader.releaseReferences(currentView.sstables);
}
}
}
public List<SSTableReader> getSnapshotSSTableReader(String tag) throws IOException
{
Map<Descriptor, Set<Component>> snapshots = directories.sstableLister().snapshots(tag).list();
List<SSTableReader> readers = new ArrayList<SSTableReader>(snapshots.size());
for (Map.Entry<Descriptor, Set<Component>> entries : snapshots.entrySet())
readers.add(SSTableReader.open(entries.getKey(), entries.getValue(), metadata, partitioner));
return readers;
}
/**
* Take a snap shot of this columnfamily store.
*
* @param snapshotName the name of the associated with the snapshot
*/
public void snapshot(String snapshotName)
{
forceBlockingFlush();
snapshotWithoutFlush(snapshotName);
}
public boolean snapshotExists(String snapshotName)
{
return directories.snapshotExists(snapshotName);
}
public long getSnapshotCreationTime(String snapshotName)
{
return directories.snapshotCreationTime(snapshotName);
}
public void clearSnapshot(String snapshotName)
{
directories.clearSnapshot(snapshotName);
}
public boolean hasUnreclaimedSpace()
{
return getLiveDiskSpaceUsed() < getTotalDiskSpaceUsed();
}
public long getTotalDiskSpaceUsed()
{
return metric.totalDiskSpaceUsed.count();
}
public long getLiveDiskSpaceUsed()
{
return metric.liveDiskSpaceUsed.count();
}
public int getLiveSSTableCount()
{
return metric.liveSSTableCount.value();
}
/**
* @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;
}
/**
* @return true if @param key is contained in the row cache
*/
public boolean containsCachedRow(DecoratedKey key)
{
return CacheService.instance.rowCache.getCapacity() != 0 && CacheService.instance.rowCache.containsKey(new RowCacheKey(metadata.cfId, key));
}
public void invalidateCachedRow(RowCacheKey key)
{
CacheService.instance.rowCache.remove(key);
}
public void invalidateCachedRow(DecoratedKey key)
{
UUID cfId = Schema.instance.getId(keyspace.getName(), this.name);
if (cfId == null)
return; // secondary index
invalidateCachedRow(new RowCacheKey(cfId, key));
}
public void forceMajorCompaction() throws InterruptedException, ExecutionException
{
CompactionManager.instance.performMaximal(this);
}
public static Iterable<ColumnFamilyStore> all()
{
List<Iterable<ColumnFamilyStore>> stores = new ArrayList<Iterable<ColumnFamilyStore>>(Schema.instance.getKeyspaces().size());
for (Keyspace keyspace : Keyspace.all())
{
stores.add(keyspace.getColumnFamilyStores());
}
return Iterables.concat(stores);
}
public Iterable<DecoratedKey> keySamples(Range<Token> range)
{
Collection<SSTableReader> sstables = getSSTables();
Iterable<DecoratedKey>[] samples = new Iterable[sstables.size()];
int i = 0;
for (SSTableReader sstable: sstables)
{
samples[i++] = sstable.getKeySamples(range);
}
return Iterables.concat(samples);
}
/**
* For testing. No effort is made to clear historical or even the current memtables, nor for
* thread safety. All we do is wipe the sstable containers clean, while leaving the actual
* data files present on disk. (This allows tests to easily call loadNewSSTables on them.)
*/
public void clearUnsafe()
{
for (final ColumnFamilyStore cfs : concatWithIndexes())
{
cfs.runWithCompactionsDisabled(new Callable<Void>()
{
public Void call()
{
cfs.data.init();
return null;
}
}, true);
}
}
/**
* Truncate deletes the entire column family's data with no expensive tombstone creation
*/
public void truncateBlocking()
{
// We have two goals here:
// - truncate should delete everything written before truncate was invoked
// - but not delete anything that isn't part of the snapshot we create.
// We accomplish this by first flushing manually, then snapshotting, and
// recording the timestamp IN BETWEEN those actions. Any sstables created
// with this timestamp or greater time, will not be marked for delete.
//
// Bonus complication: since we store replay position in sstable metadata,
// truncating those sstables means we will replay any CL segments from the
// beginning if we restart before they [the CL segments] are discarded for
// normal reasons post-truncate. To prevent this, we store truncation
// position in the System keyspace.
logger.debug("truncating {}", name);
if (DatabaseDescriptor.isAutoSnapshot())
{
// flush the CF being truncated before forcing the new segment
forceBlockingFlush();
// sleep a little to make sure that our truncatedAt comes after any sstable
// that was part of the flushed we forced; otherwise on a tie, it won't get deleted.
Uninterruptibles.sleepUninterruptibly(1, TimeUnit.MILLISECONDS);
}
// nuke the memtable data w/o writing to disk first
Keyspace.switchLock.writeLock().lock();
try
{
for (ColumnFamilyStore cfs : concatWithIndexes())
{
Memtable mt = cfs.getMemtableThreadSafe();
if (!mt.isClean())
mt.cfs.data.renewMemtable();
}
}
finally
{
Keyspace.switchLock.writeLock().unlock();
}
Runnable truncateRunnable = new Runnable()
{
public void run()
{
logger.debug("Discarding sstable data for truncated CF + indexes");
final long truncatedAt = System.currentTimeMillis();
if (DatabaseDescriptor.isAutoSnapshot())
snapshot(Keyspace.getTimestampedSnapshotName(name));
ReplayPosition replayAfter = discardSSTables(truncatedAt);
for (SecondaryIndex index : indexManager.getIndexes())
index.truncateBlocking(truncatedAt);
SystemKeyspace.saveTruncationRecord(ColumnFamilyStore.this, truncatedAt, replayAfter);
logger.debug("cleaning out row cache");
for (RowCacheKey key : CacheService.instance.rowCache.getKeySet())
{
if (key.cfId == metadata.cfId)
CacheService.instance.rowCache.remove(key);
}
}
};
runWithCompactionsDisabled(Executors.callable(truncateRunnable), true);
logger.debug("truncate complete");
}
public <V> V runWithCompactionsDisabled(Callable<V> callable, boolean interruptValidation)
{
// synchronize so that concurrent invocations don't re-enable compactions partway through unexpectedly,
// and so we only run one major compaction at a time
synchronized (this)
{
logger.debug("Cancelling in-progress compactions for {}", metadata.cfName);
Iterable<ColumnFamilyStore> selfWithIndexes = concatWithIndexes();
for (ColumnFamilyStore cfs : selfWithIndexes)
cfs.getCompactionStrategy().pause();
try
{
// interrupt in-progress compactions
Function<ColumnFamilyStore, CFMetaData> f = new Function<ColumnFamilyStore, CFMetaData>()
{
public CFMetaData apply(ColumnFamilyStore cfs)
{
return cfs.metadata;
}
};
Iterable<CFMetaData> allMetadata = Iterables.transform(selfWithIndexes, f);
CompactionManager.instance.interruptCompactionFor(allMetadata, interruptValidation);
// wait for the interruption to be recognized
long start = System.nanoTime();
long delay = TimeUnit.MINUTES.toNanos(1);
while (System.nanoTime() - start < delay)
{
if (CompactionManager.instance.isCompacting(selfWithIndexes))
Uninterruptibles.sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
else
break;
}
// doublecheck that we finished, instead of timing out
for (ColumnFamilyStore cfs : selfWithIndexes)
{
if (!cfs.getDataTracker().getCompacting().isEmpty())
{
logger.warn("Unable to cancel in-progress compactions for {}. Probably there is an unusually large row in progress somewhere. It is also possible that buggy code left some sstables compacting after it was done with them", metadata.cfName);
}
}
logger.debug("Compactions successfully cancelled");
// run our task
try
{
return callable.call();
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
finally
{
for (ColumnFamilyStore cfs : selfWithIndexes)
cfs.getCompactionStrategy().resume();
}
}
}
public Iterable<SSTableReader> markAllCompacting()
{
Callable<Iterable<SSTableReader>> callable = new Callable<Iterable<SSTableReader>>()
{
public Iterable<SSTableReader> call() throws Exception
{
assert data.getCompacting().isEmpty() : data.getCompacting();
Iterable<SSTableReader> sstables = Lists.newArrayList(AbstractCompactionStrategy.filterSuspectSSTables(getSSTables()));
if (Iterables.isEmpty(sstables))
return null;
boolean success = data.markCompacting(sstables);
assert success : "something marked things compacting while compactions are disabled";
return sstables;
}
};
return runWithCompactionsDisabled(callable, false);
}
public long getBloomFilterFalsePositives()
{
return metric.bloomFilterFalsePositives.value();
}
public long getRecentBloomFilterFalsePositives()
{
return metric.recentBloomFilterFalsePositives.value();
}
public double getBloomFilterFalseRatio()
{
return metric.bloomFilterFalseRatio.value();
}
public double getRecentBloomFilterFalseRatio()
{
return metric.recentBloomFilterFalseRatio.value();
}
public long getBloomFilterDiskSpaceUsed()
{
return metric.bloomFilterDiskSpaceUsed.value();
}
@Override
public String toString()
{
return "CFS(" +
"Keyspace='" + keyspace.getName() + '\'' +
", ColumnFamily='" + name + '\'' +
')';
}
public void disableAutoCompaction()
{
// we don't use CompactionStrategy.pause since we don't want users flipping that on and off
// during runWithCompactionsDisabled
this.compactionStrategy.disable();
}
public void enableAutoCompaction()
{
enableAutoCompaction(false);
}
/**
* used for tests - to be able to check things after a minor compaction
* @param waitForFutures if we should block until autocompaction is done
*/
@VisibleForTesting
public void enableAutoCompaction(boolean waitForFutures)
{
this.compactionStrategy.enable();
List<Future<?>> futures = CompactionManager.instance.submitBackground(this);
if (waitForFutures)
FBUtilities.waitOnFutures(futures);
}
public boolean isAutoCompactionDisabled()
{
return !this.compactionStrategy.isEnabled();
}
/*
JMX getters and setters for the Default<T>s.
- get/set minCompactionThreshold
- get/set maxCompactionThreshold
- get memsize
- get memops
- get/set memtime
*/
public AbstractCompactionStrategy getCompactionStrategy()
{
assert compactionStrategy != null : "No compaction strategy set yet";
return compactionStrategy;
}
public void setCompactionThresholds(int minThreshold, int maxThreshold)
{
validateCompactionThresholds(minThreshold, maxThreshold);
minCompactionThreshold.set(minThreshold);
maxCompactionThreshold.set(maxThreshold);
// this is called as part of CompactionStrategy constructor; avoid circular dependency by checking for null
if (compactionStrategy != null)
CompactionManager.instance.submitBackground(this);
}
public int getMinimumCompactionThreshold()
{
return minCompactionThreshold.value();
}
public void setMinimumCompactionThreshold(int minCompactionThreshold)
{
validateCompactionThresholds(minCompactionThreshold, maxCompactionThreshold.value());
this.minCompactionThreshold.set(minCompactionThreshold);
}
public int getMaximumCompactionThreshold()
{
return maxCompactionThreshold.value();
}
public void setMaximumCompactionThreshold(int maxCompactionThreshold)
{
validateCompactionThresholds(minCompactionThreshold.value(), maxCompactionThreshold);
this.maxCompactionThreshold.set(maxCompactionThreshold);
}
private void validateCompactionThresholds(int minThreshold, int maxThreshold)
{
if (minThreshold > maxThreshold)
throw new RuntimeException(String.format("The min_compaction_threshold cannot be larger than the max_compaction_threshold. " +
"Min is '%d', Max is '%d'.", minThreshold, maxThreshold));
if (maxThreshold == 0 || minThreshold == 0)
throw new RuntimeException("Disabling compaction by setting min_compaction_threshold or max_compaction_threshold to 0 " +
"is deprecated, set the compaction strategy option 'enabled' to 'false' instead or use the nodetool command 'disableautocompaction'.");
}
public long getTombstonesPerLastRead()
{
return metric.tombstoneScannedHistogram.count();
}
public float getPercentageTombstonesPerLastRead()
{
long total = metric.tombstoneScannedHistogram.count() + metric.liveScannedHistogram.count();
return ((float) metric.tombstoneScannedHistogram.count() / total);
}
public long getLiveCellsPerLastRead()
{
return metric.liveScannedHistogram.count();
}
// End JMX get/set.
public long estimateKeys()
{
return data.estimatedKeys();
}
public long[] getEstimatedRowSizeHistogram()
{
return metric.estimatedRowSizeHistogram.value();
}
public long[] getEstimatedColumnCountHistogram()
{
return metric.estimatedColumnCountHistogram.value();
}
public double getCompressionRatio()
{
return metric.compressionRatio.value();
}
/** true if this CFS contains secondary index data */
public boolean isIndex()
{
return partitioner instanceof LocalPartitioner;
}
private ByteBuffer intern(ByteBuffer name)
{
ByteBuffer internedName = internedNames.get(name);
if (internedName == null)
{
internedName = ByteBufferUtil.clone(name);
ByteBuffer concurrentName = internedNames.putIfAbsent(internedName, internedName);
if (concurrentName != null)
internedName = concurrentName;
}
return internedName;
}
public ByteBuffer internOrCopy(ByteBuffer name, Allocator allocator)
{
if (internedNames.size() >= INTERN_CUTOFF)
return allocator.clone(name);
return intern(name);
}
public ByteBuffer maybeIntern(ByteBuffer name)
{
if (internedNames.size() >= INTERN_CUTOFF)
return null;
return intern(name);
}
public Iterable<ColumnFamilyStore> concatWithIndexes()
{
return Iterables.concat(indexManager.getIndexesBackedByCfs(), Collections.singleton(this));
}
public Set<Memtable> getMemtablesPendingFlush()
{
return data.getMemtablesPendingFlush();
}
public List<String> getBuiltIndexes()
{
return indexManager.getBuiltIndexes();
}
public int getUnleveledSSTables()
{
return this.compactionStrategy instanceof LeveledCompactionStrategy
? ((LeveledCompactionStrategy) this.compactionStrategy).getLevelSize(0)
: 0;
}
public int[] getSSTableCountPerLevel()
{
return compactionStrategy instanceof LeveledCompactionStrategy
? ((LeveledCompactionStrategy) compactionStrategy).getAllLevelSize()
: null;
}
public static class ViewFragment
{
public final List<SSTableReader> sstables;
public final Iterable<Memtable> memtables;
public ViewFragment(List<SSTableReader> sstables, Iterable<Memtable> memtables)
{
this.sstables = sstables;
this.memtables = memtables;
}
}
/**
* Returns the creation time of the oldest memtable not fully flushed yet.
*/
public long oldestUnflushedMemtable()
{
DataTracker.View view = data.getView();
long oldest = view.memtable.creationTime();
for (Memtable memtable : view.memtablesPendingFlush)
oldest = Math.min(oldest, memtable.creationTime());
return oldest;
}
public boolean isEmpty()
{
DataTracker.View view = data.getView();
return view.sstables.isEmpty() && view.memtable.getOperations() == 0 && view.memtablesPendingFlush.isEmpty();
}
private boolean isRowCacheEnabled()
{
return !(metadata.getCaching() == Caching.NONE
|| metadata.getCaching() == Caching.KEYS_ONLY
|| CacheService.instance.rowCache.getCapacity() == 0);
}
/**
* Discard all SSTables that were created before given timestamp.
*
* Caller should first ensure that comapctions have quiesced.
*
* @param truncatedAt The timestamp of the truncation
* (all SSTables before that timestamp are going be marked as compacted)
*
* @return the most recent replay position of the truncated data
*/
public ReplayPosition discardSSTables(long truncatedAt)
{
assert data.getCompacting().isEmpty() : data.getCompacting();
List<SSTableReader> truncatedSSTables = new ArrayList<SSTableReader>();
for (SSTableReader sstable : getSSTables())
{
if (!sstable.newSince(truncatedAt))
truncatedSSTables.add(sstable);
}
if (truncatedSSTables.isEmpty())
return ReplayPosition.NONE;
markObsolete(truncatedSSTables, OperationType.UNKNOWN);
return ReplayPosition.getReplayPosition(truncatedSSTables);
}
public double getDroppableTombstoneRatio()
{
return getDataTracker().getDroppableTombstoneRatio();
}
public long getTruncationTime()
{
Pair<ReplayPosition, Long> truncationRecord = SystemKeyspace.getTruncationRecords().get(metadata.cfId);
return truncationRecord == null ? Long.MIN_VALUE : truncationRecord.right;
}
}