Public

getOperations

<init>

accepts

getAllocator

getLiveDataSize

isClean

isExpired

partitionCount

Should only be called by ColumnFamilyStore.apply via Keyspace.apply, which
supplies the appropriate 

setDiscarded

setDiscarding

toString

abortRunnables

createFlushRunnables

findMinLocalDeletionTime

flushRunnables

getCommitLogLowerBound

getCommitLogUpperBound

getMinTimestamp

getPartition

Memtable

Running tasks concurrently on multiple threads

Thrown when a program encounters the end of a file or stream during an input
operation.

java.io.EOFException

Represents a command that can be executed. Often used to run code in a different
Thread.

java.lang.Runnable

Java representation of an SQL TIME value. Provides utilities to format and parse
the time's represen

java.sql.Time

SortedSet is a Set which iterates over its elements in a sorted order. The order
is determined eithe

java.util.SortedSet

javax.swing.JCheckBox

Used to perform Get operations on a single row. To get everything for a row,
instantiate a Get objec

org.apache.hadoop.hbase.client.Get

addToBackStack

runOnUiThread

setRequestProperty

/**
     * Finds expired sstables
     *
     * works something like this;
     * 1. find "global" minTimestamp of overlapping sstables, compacting sstables and memtables containing any non-expired data
     * 2. build a list of fully expired candidates
     * 3. check if the candidates to be dropped actually can be dropped {@code (maxTimestamp < global minTimestamp)}
     *    - if not droppable, remove from candidates
     * 4. return candidates.
     *
     * @param cfStore
     * @param compacting we take the drop-candidates from this set, it is usually the sstables included in the compaction
     * @param overlapping the sstables that overlap the ones in compacting.
     * @param gcBefore
     * @param ignoreOverlaps don't check if data shadows/overlaps any data in other sstables
     * @return
     */

"Dropping overlap ignored expired SSTable {} (maxLocalDeletionTime={}, gcBefore={})"

// Overlapping might include fully expired sstables. What we care about here is

// the min timestamp of the overlapping sstables that actually contain live data.

// At this point, minTimestamp denotes the lowest timestamp of any relevant

// SSTable or Memtable that contains a constructive value. candidates contains all the

// candidates with no constructive values. The ones out of these that have

// (getMaxTimestamp() < minTimestamp) serve no purpose anymore.

"Dropping expired SSTable {} (maxLocalDeletionTime={}, gcBefore={})"

/*
         * We have 2 main strategies:
         *   1) We query memtables and sstables simulateneously. This is our most generic strategy and the one we use
         *      unless we have a names filter that we know we can optimize futher.
         *   2) If we have a name filter (so we query specific rows), we can make a bet: that all column for all queried row
         *      will have data in the most recent sstable(s), thus saving us from reading older ones. This does imply we
         *      have a way to guarantee we have all the data for what is queried, which is only possible for name queries
         *      and if we have neither non-frozen collections/UDTs nor counters (indeed, for a non-frozen collection or UDT,
         *      we can't guarantee an older sstable won't have some elements that weren't in the most recent sstables,
         *      and counters are intrinsically a collection of shards and so have the same problem).
         */

// 'iter' is added to iterators which is closed on exception, or through the closing of the final merged iterator

/*
             * We can't eliminate full sstables based on the timestamp of what we've already read like
             * in collectTimeOrderedData, but we still want to eliminate sstable whose maxTimestamp < mostRecentTombstone
             * we've read. We still rely on the sstable ordering by maxTimestamp since if
             *   maxTimestamp_s1 > maxTimestamp_s0,
             * we're guaranteed that s1 cannot have a row tombstone such that
             *   timestamp(tombstone) > maxTimestamp_s0
             * since we necessarily have
             *   timestamp(tombstone) <= maxTimestamp_s1
             * In other words, iterating in maxTimestamp order allow to do our mostRecentPartitionTombstone elimination
             * in one pass, and minimize the number of sstables for which we read a partition tombstone.
             */

// if we've already seen a partition tombstone with a timestamp greater

// than the most recent update to this sstable, we can skip it

// if sstable has tombstones we need to check after one pass if it can be safely skipped

// 'iter' is added to iterators which is closed on exception,

// or through the closing of the final merged iterator

// Check for sstables with tombstones that are not expired

// 'iter' is added to iterators which is close on exception,

"Skipped {}/{} non-slice-intersecting sstables, included {} due to tombstones"

How to use getMinTimestampmethodin org.apache.cassandra.db.Memtable

Best Java code snippets using org.apache.cassandra.db.Memtable.getMinTimestamp (Showing top 6 results out of 315)

How to use
getMinTimestamp
method
in
org.apache.cassandra.db.Memtable