/* * 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; } }