diff --git a/interface/cassandra.thrift b/interface/cassandra.thrift index f5041c897f..2970cfff1e 100644 --- a/interface/cassandra.thrift +++ b/interface/cassandra.thrift @@ -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 keys. The return value maps keys to the count found. + Perform a get_count in parallel on the given {@code List} keys. The return value maps keys to the count found. */ map multiget_count(1:required list keys, 2:required ColumnParent column_parent, diff --git a/src/java/org/apache/cassandra/cql3/selection/Selection.java b/src/java/org/apache/cassandra/cql3/selection/Selection.java index 20fad4dd26..2081f8ac55 100644 --- a/src/java/org/apache/cassandra/cql3/selection/Selection.java +++ b/src/java/org/apache/cassandra/cql3/selection/Selection.java @@ -407,8 +407,6 @@ public abstract class Selection /** * Builds the ResultSet - * - * @param protocolVersion the protocol version */ public ResultSet build() { diff --git a/src/java/org/apache/cassandra/db/aggregation/GroupingState.java b/src/java/org/apache/cassandra/db/aggregation/GroupingState.java index ff529a68a3..ba5ae28876 100644 --- a/src/java/org/apache/cassandra/db/aggregation/GroupingState.java +++ b/src/java/org/apache/cassandra/db/aggregation/GroupingState.java @@ -35,7 +35,8 @@ import org.apache.cassandra.utils.ByteBufferUtil; *

*

* {@code GroupingState} is only used for internal paging. When a new page is requested by a client the initial state - * will always be empty.
+ * will always be empty.

+ *

* 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. *

diff --git a/src/java/org/apache/cassandra/db/commitlog/IntervalSet.java b/src/java/org/apache/cassandra/db/commitlog/IntervalSet.java index bd0ea2204a..8d3ec82648 100644 --- a/src/java/org/apache/cassandra/db/commitlog/IntervalSet.java +++ b/src/java/org/apache/cassandra/db/commitlog/IntervalSet.java @@ -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> { @@ -132,7 +132,7 @@ public class IntervalSet> * 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> { diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionController.java b/src/java/org/apache/cassandra/db/compaction/CompactionController.java index 7d4b8aab6d..d922d284cc 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionController.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionController.java @@ -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. * diff --git a/src/java/org/apache/cassandra/db/filter/ClusteringIndexFilter.java b/src/java/org/apache/cassandra/db/filter/ClusteringIndexFilter.java index d1907b101f..f184035816 100644 --- a/src/java/org/apache/cassandra/db/filter/ClusteringIndexFilter.java +++ b/src/java/org/apache/cassandra/db/filter/ClusteringIndexFilter.java @@ -114,11 +114,10 @@ public interface ClusteringIndexFilter /** * Returns an iterator that only returns the rows of the provided iterator that this filter selects. *

- * 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); /** diff --git a/src/java/org/apache/cassandra/db/filter/ColumnFilter.java b/src/java/org/apache/cassandra/db/filter/ColumnFilter.java index 9ce7ef7048..20f35df489 100644 --- a/src/java/org/apache/cassandra/db/filter/ColumnFilter.java +++ b/src/java/org/apache/cassandra/db/filter/ColumnFilter.java @@ -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 diff --git a/src/java/org/apache/cassandra/db/partitions/PartitionUpdate.java b/src/java/org/apache/cassandra/db/partitions/PartitionUpdate.java index b7c167aca0..b95a31016e 100644 --- a/src/java/org/apache/cassandra/db/partitions/PartitionUpdate.java +++ b/src/java/org/apache/cassandra/db/partitions/PartitionUpdate.java @@ -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. */ diff --git a/src/java/org/apache/cassandra/db/rows/LazilyInitializedUnfilteredRowIterator.java b/src/java/org/apache/cassandra/db/rows/LazilyInitializedUnfilteredRowIterator.java index fc5bdbe6e4..504d60ed50 100644 --- a/src/java/org/apache/cassandra/db/rows/LazilyInitializedUnfilteredRowIterator.java +++ b/src/java/org/apache/cassandra/db/rows/LazilyInitializedUnfilteredRowIterator.java @@ -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 implements UnfilteredRowIterator { diff --git a/src/java/org/apache/cassandra/db/rows/Row.java b/src/java/org/apache/cassandra/db/rows/Row.java index 20f9e3add6..c19d55e4fa 100644 --- a/src/java/org/apache/cassandra/db/rows/Row.java +++ b/src/java/org/apache/cassandra/db/rows/Row.java @@ -228,8 +228,6 @@ public interface Row extends Unfiltered, Collection * 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 * and regular row deletion. *

* 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). *

- * 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. *

* Currently, the only use of shadowable row deletions is Materialized Views, see CASSANDRA-10261. diff --git a/src/java/org/apache/cassandra/db/rows/WrappingUnfilteredRowIterator.java b/src/java/org/apache/cassandra/db/rows/WrappingUnfilteredRowIterator.java index 8b1855424f..411950eafa 100644 --- a/src/java/org/apache/cassandra/db/rows/WrappingUnfilteredRowIterator.java +++ b/src/java/org/apache/cassandra/db/rows/WrappingUnfilteredRowIterator.java @@ -29,7 +29,7 @@ import org.apache.cassandra.db.*; * some of the methods. *

* 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 implements UnfilteredRowIterator { diff --git a/src/java/org/apache/cassandra/db/view/ViewUpdateGenerator.java b/src/java/org/apache/cassandra/db/view/ViewUpdateGenerator.java index 21613635ac..8286ae3d4d 100644 --- a/src/java/org/apache/cassandra/db/view/ViewUpdateGenerator.java +++ b/src/java/org/apache/cassandra/db/view/ViewUpdateGenerator.java @@ -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. */ diff --git a/src/java/org/apache/cassandra/index/Index.java b/src/java/org/apache/cassandra/index/Index.java index 251d33141e..4ffef1e787 100644 --- a/src/java/org/apache/cassandra/index/Index.java +++ b/src/java/org/apache/cassandra/index/Index.java @@ -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, that is a function which takes as + * {@code java.util.functions.BiFunction}, 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): * - * 

{@code public static Map validateOptions(Map options);
+ * 
{@code public static Map validateOptions(Map options);}
* * 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. diff --git a/src/java/org/apache/cassandra/index/SecondaryIndexManager.java b/src/java/org/apache/cassandra/index/SecondaryIndexManager.java index 8de846fa79..e06cab0c69 100644 --- a/src/java/org/apache/cassandra/index/SecondaryIndexManager.java +++ b/src/java/org/apache/cassandra/index/SecondaryIndexManager.java @@ -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. diff --git a/src/java/org/apache/cassandra/service/pager/AggregationQueryPager.java b/src/java/org/apache/cassandra/service/pager/AggregationQueryPager.java index 1bdaac6210..5483d15719 100644 --- a/src/java/org/apache/cassandra/service/pager/AggregationQueryPager.java +++ b/src/java/org/apache/cassandra/service/pager/AggregationQueryPager.java @@ -386,8 +386,8 @@ public final class AggregationQueryPager implements QueryPager /** * PartitionIterator for queries without Group By but with aggregates. - *

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.

+ *

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.

*/ public final class AggregationPartitionIterator extends GroupByPartitionIterator { diff --git a/src/java/org/apache/cassandra/utils/concurrent/OpOrder.java b/src/java/org/apache/cassandra/utils/concurrent/OpOrder.java index b80fe99e50..fd7e9ff937 100644 --- a/src/java/org/apache/cassandra/utils/concurrent/OpOrder.java +++ b/src/java/org/apache/cassandra/utils/concurrent/OpOrder.java @@ -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()