mirror of https://github.com/apache/cassandra
minor javadoc fixes
This commit is contained in:
Dave Brosius
parent
f01aedcfb6
commit
143a7d9590
|
|
@ -648,7 +648,7 @@ service Cassandra {
|
|||
throws (1:InvalidRequestException ire, 2:UnavailableException ue, 3:TimedOutException te),
|
||||
|
||||
/**
|
||||
Perform a get_count in parallel on the given list<binary> keys. The return value maps keys to the count found.
|
||||
Perform a get_count in parallel on the given {@code List<binary>} keys. The return value maps keys to the count found.
|
||||
*/
|
||||
map<binary, i32> multiget_count(1:required list<binary> keys,
|
||||
2:required ColumnParent column_parent,
|
||||
|
|
|
|||
|
|
@ -407,8 +407,6 @@ public abstract class Selection
|
|||
|
||||
/**
|
||||
* Builds the <code>ResultSet</code>
|
||||
*
|
||||
* @param protocolVersion the protocol version
|
||||
*/
|
||||
public ResultSet build()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -35,7 +35,8 @@ import org.apache.cassandra.utils.ByteBufferUtil;
|
|||
* </p>
|
||||
* <p>
|
||||
* {@code GroupingState} is only used for internal paging. When a new page is requested by a client the initial state
|
||||
* will always be empty.<br/>
|
||||
* will always be empty.</p>
|
||||
* <p>
|
||||
* If the state has a partition key but no clustering, it means that the previous group ended at the end of the
|
||||
* previous partition. If the clustering is not null it means that we are in the middle of a group.
|
||||
* </p>
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ import org.apache.cassandra.io.util.DataOutputPlus;
|
|||
* to a single interval covering both).
|
||||
*
|
||||
* The set is stored as a sorted map from interval starts to the corresponding end. The map satisfies
|
||||
* curr().getKey() <= curr().getValue() < next().getKey()
|
||||
* {@code curr().getKey() <= curr().getValue() < next().getKey()}
|
||||
*/
|
||||
public class IntervalSet<T extends Comparable<T>>
|
||||
{
|
||||
|
|
@ -132,7 +132,7 @@ public class IntervalSet<T extends Comparable<T>>
|
|||
* Builder of interval sets, applying the necessary normalization while adding ranges.
|
||||
*
|
||||
* Data is stored as above, as a sorted map from interval starts to the corresponding end, which satisfies
|
||||
* curr().getKey() <= curr().getValue() < next().getKey()
|
||||
* {@code curr().getKey() <= curr().getValue() < next().getKey()}
|
||||
*/
|
||||
static public class Builder<T extends Comparable<T>>
|
||||
{
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ public class CompactionController implements AutoCloseable
|
|||
* 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 (maxTimestamp < global minTimestamp)
|
||||
* 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.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -114,11 +114,10 @@ public interface ClusteringIndexFilter
|
|||
/**
|
||||
* Returns an iterator that only returns the rows of the provided iterator that this filter selects.
|
||||
* <p>
|
||||
* This method is the "dumb" counterpart to {@link #filter(SliceableUnfilteredRowIterator)} in that it has no way to quickly get
|
||||
* This method is the "dumb" counterpart to {@link #getSlices(CFMetaData)} in that it has no way to quickly get
|
||||
* to what is actually selected, so it simply iterate over it all and filters out what shouldn't be returned. This should
|
||||
* be avoided in general, we should make sure to have {@code SliceableUnfilteredRowIterator} when we have filtering to do, but this
|
||||
* currently only used in {@link SinglePartitionReadCommand#getThroughCache} when we know this won't be a performance problem.
|
||||
* Another difference with {@link #filter(SliceableUnfilteredRowIterator)} is that this method also filter the queried
|
||||
* be avoided in general.
|
||||
* Another difference with {@link #getSlices(CFMetaData)} is that this method also filter the queried
|
||||
* columns in the returned result, while the former assumes that the provided iterator has already done it.
|
||||
*
|
||||
* @param columnFilter the columns to include in the rows of the result iterator.
|
||||
|
|
@ -138,8 +137,6 @@ public interface ClusteringIndexFilter
|
|||
*
|
||||
* @return a unfiltered row iterator returning those rows (or rather Unfiltered) from {@code partition} that are selected by this filter.
|
||||
*/
|
||||
// TODO: we could get rid of that if Partition was exposing a SliceableUnfilteredRowIterator (instead of the two searchIterator() and
|
||||
// unfilteredIterator() methods). However, for AtomicBtreePartition this would require changes to Btree so we'll leave that for later.
|
||||
public UnfilteredRowIterator getUnfilteredRowIterator(ColumnFilter columnFilter, Partition partition);
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -271,12 +271,12 @@ public class ColumnFilter
|
|||
* A builder for a {@code ColumnFilter} object.
|
||||
*
|
||||
* Note that the columns added to this build are the _queried_ column. Whether or not all columns
|
||||
* are _fetched_ depends on which ctor you've used to obtained this builder, allColumnsBuilder (all
|
||||
* are _fetched_ depends on which constructor you've used to obtained this builder, allColumnsBuilder (all
|
||||
* columns are fetched) or selectionBuilder (only the queried columns are fetched).
|
||||
*
|
||||
* Note that for a allColumnsBuilder, if no queried columns are added, this is interpreted as querying
|
||||
* all columns, not querying none (but if you know you want to query all columns, prefer
|
||||
* {@link ColumnFilter#all)}. For selectionBuilder, adding no queried columns means no column will be
|
||||
* {@link ColumnFilter#all(CFMetaData)}. For selectionBuilder, adding no queried columns means no column will be
|
||||
* fetched (so the builder will return {@code PartitionColumns.NONE}).
|
||||
*/
|
||||
public static class Builder
|
||||
|
|
|
|||
|
|
@ -722,7 +722,7 @@ public class PartitionUpdate extends AbstractBTreePartition
|
|||
* Sets the start for the built range using the provided values.
|
||||
*
|
||||
* @param values the value for the start of the range. They act like the {@code clusteringValues} argument
|
||||
* of the {@link PartitionUpdate.SimpleBuilder#row()} method, except that it doesn't have to be a full
|
||||
* of the {@link SimpleBuilder#row(Object...)} method, except that it doesn't have to be a full
|
||||
* clustering, it can only be a prefix.
|
||||
* @return this builder.
|
||||
*/
|
||||
|
|
@ -732,7 +732,7 @@ public class PartitionUpdate extends AbstractBTreePartition
|
|||
* Sets the end for the built range using the provided values.
|
||||
*
|
||||
* @param values the value for the end of the range. They act like the {@code clusteringValues} argument
|
||||
* of the {@link PartitionUpdate.SimpleBuilder#row()} method, except that it doesn't have to be a full
|
||||
* of the {@link SimpleBuilder#row(Object...)} method, except that it doesn't have to be a full
|
||||
* clustering, it can only be a prefix.
|
||||
* @return this builder.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ import org.apache.cassandra.db.*;
|
|||
*
|
||||
* This is used during partition range queries when we know the partition key but want
|
||||
* to defer the initialization of the rest of the UnfilteredRowIterator until we need those informations.
|
||||
* See {@link org.apache.cassandra.io.sstable.format.big.BigTableScanner#KeyScanningIterator} for instance.
|
||||
* See {@link org.apache.cassandra.io.sstable.format.big.BigTableScanner.KeyScanningIterator} for instance.
|
||||
*/
|
||||
public abstract class LazilyInitializedUnfilteredRowIterator extends AbstractIterator<Unfiltered> implements UnfilteredRowIterator
|
||||
{
|
||||
|
|
|
|||
|
|
@ -228,8 +228,6 @@ public interface Row extends Unfiltered, Collection<ColumnData>
|
|||
* timestamp by {@code newTimestamp - 1}.
|
||||
*
|
||||
* @param newTimestamp the timestamp to use for all live data in the returned row.
|
||||
* @param a copy of this row with timestamp updated using {@code newTimestamp}. This can return {@code null} in the
|
||||
* rare where the row only as a shadowable row deletion and the new timestamp supersedes it.
|
||||
*
|
||||
* @see Commit for why we need this.
|
||||
*/
|
||||
|
|
@ -270,13 +268,13 @@ public interface Row extends Unfiltered, Collection<ColumnData>
|
|||
* and regular row deletion.
|
||||
* <p>
|
||||
* A shadowable row deletion only exists if the row has no timestamp. In other words, the deletion is only
|
||||
* valid as long as no newer insert is done (thus setting a row timestap; note that if the row timestamp set
|
||||
* valid as long as no newer insert is done (thus setting a row timestamp; note that if the row timestamp set
|
||||
* is lower than the deletion, it is shadowed (and thus ignored) as usual).
|
||||
* <p>
|
||||
* That is, if a row has a shadowable deletion with timestamp A and an update is madeto that row with a
|
||||
* timestamp B such that B > A (and that update sets the row timestamp), then the shadowable deletion is 'shadowed'
|
||||
* That is, if a row has a shadowable deletion with timestamp A and an update is made to that row with a
|
||||
* timestamp B such that {@code B > A} (and that update sets the row timestamp), then the shadowable deletion is 'shadowed'
|
||||
* by that update. A concrete consequence is that if said update has cells with timestamp lower than A, then those
|
||||
* cells are preserved(since the deletion is removed), and this contrarily to a normal (regular) deletion where the
|
||||
* cells are preserved(since the deletion is removed), and this is contrary to a normal (regular) deletion where the
|
||||
* deletion is preserved and such cells are removed.
|
||||
* <p>
|
||||
* Currently, the only use of shadowable row deletions is Materialized Views, see CASSANDRA-10261.
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ import org.apache.cassandra.db.*;
|
|||
* some of the methods.
|
||||
* <p>
|
||||
* Note that if most of what you want to do is modifying/filtering the returned
|
||||
* {@code Unfiltered}, {@link org.apache.cassandra.db.transform.Transformation.apply} can be a simpler option.
|
||||
* {@code Unfiltered}, {@link org.apache.cassandra.db.transform.Transformation#apply(UnfilteredRowIterator,Transformation)} can be a simpler option.
|
||||
*/
|
||||
public abstract class WrappingUnfilteredRowIterator extends UnmodifiableIterator<Unfiltered> implements UnfilteredRowIterator
|
||||
{
|
||||
|
|
|
|||
|
|
@ -134,7 +134,7 @@ public class ViewUpdateGenerator
|
|||
|
||||
/**
|
||||
* Returns the updates that needs to be done to the view given the base table updates
|
||||
* passed to {@link #generateViewMutations}.
|
||||
* passed to {@link #addBaseTableUpdate}.
|
||||
*
|
||||
* @return the updates to do to the view.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ import org.apache.cassandra.utils.concurrent.OpOrder;
|
|||
* SecondaryIndexManager. It includes methods for registering and un-registering an index, performing maintenance
|
||||
* tasks such as (re)building an index from SSTable data, flushing, invalidating and so forth, as well as some to
|
||||
* retrieve general metadata about the index (index name, any internal tables used for persistence etc).
|
||||
* Several of these maintenance functions have a return type of Callable<?>; the expectation for these methods is
|
||||
* Several of these maintenance functions have a return type of {@code Callable<?>}; the expectation for these methods is
|
||||
* that any work required to be performed by the method be done inside the Callable so that the responsibility for
|
||||
* scheduling its execution can rest with SecondaryIndexManager. For instance, a task like reloading index metadata
|
||||
* following potential updates caused by modifications to the base table may be performed in a blocking way. In
|
||||
|
|
@ -111,7 +111,7 @@ import org.apache.cassandra.utils.concurrent.OpOrder;
|
|||
* chosen. A Searcher instance is then obtained from the searcherFor method and used to perform the actual Index lookup.
|
||||
* Finally, Indexes can define a post processing step to be performed on the coordinator, after results (partitions from
|
||||
* the primary table) have been received from replicas and reconciled. This post processing is defined as a
|
||||
* java.util.functions.BiFunction<PartitionIterator, RowFilter, PartitionIterator>, that is a function which takes as
|
||||
* {@code java.util.functions.BiFunction<PartitionIterator, RowFilter, PartitionIterator>}, that is a function which takes as
|
||||
* arguments a PartitionIterator (containing the reconciled result rows) and a RowFilter (from the ReadCommand being
|
||||
* executed) and returns another iterator of partitions, possibly having transformed the initial results in some way.
|
||||
* The post processing function is obtained from the Index's postProcessorFor method; the built-in indexes which ship
|
||||
|
|
@ -119,7 +119,7 @@ import org.apache.cassandra.utils.concurrent.OpOrder;
|
|||
*
|
||||
* An optional static method may be provided to validate custom index options (two variants are supported):
|
||||
*
|
||||
* <pre>{@code public static Map<String, String> validateOptions(Map<String, String> options);</pre>
|
||||
* <pre>{@code public static Map<String, String> validateOptions(Map<String, String> options);}</pre>
|
||||
*
|
||||
* The input is the map of index options supplied in the WITH clause of a CREATE INDEX statement.
|
||||
*
|
||||
|
|
@ -434,7 +434,7 @@ public interface Index
|
|||
* Notification of a modification to a row in the base table's Memtable.
|
||||
* This is allow an Index implementation to clean up entries for base data which is
|
||||
* never flushed to disk (and so will not be purged during compaction).
|
||||
* It's important to note that the old & new rows supplied here may not represent
|
||||
* It's important to note that the old and new rows supplied here may not represent
|
||||
* the totality of the data for the Row with this particular Clustering. There may be
|
||||
* additional column data in SSTables which is not present in either the old or new row,
|
||||
* so implementations should be aware of that.
|
||||
|
|
|
|||
|
|
@ -65,11 +65,11 @@ import org.apache.cassandra.utils.concurrent.Refs;
|
|||
* a table, (re)building during bootstrap or other streaming operations, flushing, reloading metadata
|
||||
* and so on.
|
||||
*
|
||||
* The Index interface defines a number of methods which return Callable<?>. These are primarily the
|
||||
* The Index interface defines a number of methods which return {@code Callable<?>}. These are primarily the
|
||||
* management tasks for an index implementation. Most of them are currently executed in a blocking
|
||||
* fashion via submission to SIM's blockingExecutor. This provides the desired behaviour in pretty
|
||||
* much all cases, as tasks like flushing an index needs to be executed synchronously to avoid potentially
|
||||
* deadlocking on the FlushWriter or PostFlusher. Several of these Callable<?> returning methods on Index could
|
||||
* deadlocking on the FlushWriter or PostFlusher. Several of these {@code Callable<?>} returning methods on Index could
|
||||
* then be defined with as void and called directly from SIM (rather than being run via the executor service).
|
||||
* Separating the task defintion from execution gives us greater flexibility though, so that in future, for example,
|
||||
* if the flush process allows it we leave open the possibility of executing more of these tasks asynchronously.
|
||||
|
|
|
|||
|
|
@ -386,8 +386,8 @@ public final class AggregationQueryPager implements QueryPager
|
|||
|
||||
/**
|
||||
* <code>PartitionIterator</code> for queries without Group By but with aggregates.
|
||||
* <p>For maintaining backward compatibility we are forced to use the {@link DataLimits.CQLLimits} instead of the
|
||||
* {@link DataLimits.CQLGroupByLimits}. Due to that pages need to be fetched in a different way.</p>
|
||||
* <p>For maintaining backward compatibility we are forced to use the {@link org.apache.cassandra.db.filter.DataLimits.CQLLimits} instead of the
|
||||
* {@link org.apache.cassandra.db.filter.DataLimits.CQLGroupByLimits}. Due to that pages need to be fetched in a different way.</p>
|
||||
*/
|
||||
public final class AggregationPartitionIterator extends GroupByPartitionIterator
|
||||
{
|
||||
|
|
|
|||
|
|
@ -422,7 +422,7 @@ public class OpOrder
|
|||
}
|
||||
|
||||
/**
|
||||
* returns the Group we are waiting on - any Group with .compareTo(getSyncPoint()) <= 0
|
||||
* returns the Group we are waiting on - any Group with {@code .compareTo(getSyncPoint()) <= 0}
|
||||
* must complete before await() returns
|
||||
*/
|
||||
public Group getSyncPoint()
|
||||
|
|
|
|||
Loading…
Reference in New Issue