You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by bl...@apache.org on 2016/02/11 10:49:57 UTC
[6/6] cassandra git commit: Merge branch cassandra-3.0 into trunk
Merge branch cassandra-3.0 into trunk
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/b0448e66
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/b0448e66
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/b0448e66
Branch: refs/heads/trunk
Commit: b0448e66b567bb8dc80acb1cb9c66bbf8b5f461c
Parents: ebd6c23 1aa97e3
Author: Benjamin Lerer <b....@gmail.com>
Authored: Thu Feb 11 10:44:30 2016 +0100
Committer: Benjamin Lerer <b....@gmail.com>
Committed: Thu Feb 11 10:48:28 2016 +0100
----------------------------------------------------------------------
CHANGES.txt | 1 +
.../cql3/restrictions/AbstractRestriction.java | 14 +
.../ForwardingPrimaryKeyRestrictions.java | 3 +-
.../restrictions/MultiColumnRestriction.java | 76 +-
.../restrictions/PrimaryKeyRestrictionSet.java | 34 +-
.../cql3/restrictions/Restriction.java | 4 +-
.../cql3/restrictions/RestrictionSet.java | 4 +-
.../restrictions/SingleColumnRestriction.java | 9 +-
.../cql3/restrictions/TokenRestriction.java | 2 +-
.../org/apache/cassandra/db/MultiCBuilder.java | 90 +-
.../PrimaryKeyRestrictionSetTest.java | 1174 +++++++++++++++---
.../SelectMultiColumnRelationTest.java | 859 ++++++++++++-
12 files changed, 2059 insertions(+), 211 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/b0448e66/CHANGES.txt
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/b0448e66/src/java/org/apache/cassandra/cql3/restrictions/AbstractRestriction.java
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/b0448e66/src/java/org/apache/cassandra/cql3/restrictions/ForwardingPrimaryKeyRestrictions.java
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/b0448e66/src/java/org/apache/cassandra/cql3/restrictions/PrimaryKeyRestrictionSet.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/cql3/restrictions/PrimaryKeyRestrictionSet.java
index d24799a,8121858..978ebbc
--- a/src/java/org/apache/cassandra/cql3/restrictions/PrimaryKeyRestrictionSet.java
+++ b/src/java/org/apache/cassandra/cql3/restrictions/PrimaryKeyRestrictionSet.java
@@@ -163,20 -175,6 +163,30 @@@ final class PrimaryKeyRestrictionSet ex
return new PrimaryKeyRestrictionSet(this, restriction);
}
+ // Whether any of the underlying restriction is an IN
+ private boolean hasIN()
+ {
+ if (isIN())
+ return true;
+
+ for (Restriction restriction : restrictions)
+ {
+ if (restriction.isIN())
+ return true;
+ }
+ return false;
+ }
+
++ private boolean hasMultiColumnSlice()
++ {
++ for (Restriction restriction : restrictions)
++ {
++ if (restriction.isMultiColumn() && restriction.isSlice())
++ return true;
++ }
++ return false;
++ }
++
@Override
public NavigableSet<Clustering> valuesAsClustering(QueryOptions options) throws InvalidRequestException
{
@@@ -204,7 -202,7 +214,7 @@@
@Override
public NavigableSet<Slice.Bound> boundsAsClustering(Bound bound, QueryOptions options) throws InvalidRequestException
{
- MultiCBuilder builder = MultiCBuilder.create(comparator, hasIN());
- MultiCBuilder builder = MultiCBuilder.create(comparator);
++ MultiCBuilder builder = MultiCBuilder.create(comparator, hasIN() || hasMultiColumnSlice());
int keyPosition = 0;
for (Restriction r : restrictions)
{
http://git-wip-us.apache.org/repos/asf/cassandra/blob/b0448e66/src/java/org/apache/cassandra/cql3/restrictions/Restriction.java
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/b0448e66/src/java/org/apache/cassandra/cql3/restrictions/RestrictionSet.java
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/b0448e66/src/java/org/apache/cassandra/cql3/restrictions/SingleColumnRestriction.java
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/b0448e66/src/java/org/apache/cassandra/db/MultiCBuilder.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/db/MultiCBuilder.java
index 7a4eef0,7c77ab0..f03e674
--- a/src/java/org/apache/cassandra/db/MultiCBuilder.java
+++ b/src/java/org/apache/cassandra/db/MultiCBuilder.java
@@@ -18,8 -18,11 +18,13 @@@
package org.apache.cassandra.db;
import java.nio.ByteBuffer;
- import java.util.*;
+ import java.util.ArrayList;
++import java.util.Arrays;
+ import java.util.List;
+ import java.util.NavigableSet;
+ import org.apache.cassandra.config.ColumnDefinition;
++import org.apache.cassandra.db.Slice.Bound;
import org.apache.cassandra.utils.ByteBufferUtil;
import org.apache.cassandra.utils.btree.BTreeSet;
@@@ -159,260 -257,123 +164,333 @@@ public abstract class MultiCBuilde
*
* @return the clusterings
*/
- public NavigableSet<Clustering> build()
- {
- built = true;
-
- if (hasMissingElements)
- return BTreeSet.empty(comparator);
-
- CBuilder builder = CBuilder.create(comparator);
-
- if (elementsList.isEmpty())
- return BTreeSet.of(builder.comparator(), builder.build());
-
- BTreeSet.Builder<Clustering> set = BTreeSet.builder(builder.comparator());
- for (int i = 0, m = elementsList.size(); i < m; i++)
- {
- List<ByteBuffer> elements = elementsList.get(i);
- set.add(builder.buildWith(elements));
- }
- return set.build();
- }
+ public abstract NavigableSet<Clustering> build();
/**
- * Builds the <code>clusterings</code> with the specified EOC.
+ * Builds the <code>Slice.Bound</code>s for slice restrictions.
*
- * @return the clusterings
+ * @param isStart specify if the bound is a start one
+ * @param isInclusive specify if the bound is inclusive or not
+ * @param isOtherBoundInclusive specify if the other bound is inclusive or not
+ * @param columnDefs the columns of the slice restriction
+ * @return the <code>Slice.Bound</code>s
+ */
- public NavigableSet<Slice.Bound> buildBoundForSlice(boolean isStart,
- boolean isInclusive,
- boolean isOtherBoundInclusive,
- List<ColumnDefinition> columnDefs)
++ public abstract NavigableSet<Slice.Bound> buildBoundForSlice(boolean isStart,
++ boolean isInclusive,
++ boolean isOtherBoundInclusive,
++ List<ColumnDefinition> columnDefs);
++
++ /**
++ * Builds the <code>Slice.Bound</code>s
++ *
++ * @param isStart specify if the bound is a start one
++ * @param isInclusive specify if the bound is inclusive or not
++ * @return the <code>Slice.Bound</code>s
+ */
+ public abstract NavigableSet<Slice.Bound> buildBound(boolean isStart, boolean isInclusive);
+
+ /**
+ * Checks if some elements can still be added to the clusterings.
+ *
+ * @return <code>true</code> if it is possible to add more elements to the clusterings, <code>false</code> otherwise.
+ */
+ public boolean hasRemaining()
{
- built = true;
+ return remainingCount() > 0;
+ }
- if (hasMissingElements)
- return BTreeSet.empty(comparator);
+ /**
+ * Specialization of MultiCBuilder when we know only one clustering/bound is created.
+ */
+ private static class OneClusteringBuilder extends MultiCBuilder
+ {
+ /**
+ * The elements of the clusterings
+ */
+ private final ByteBuffer[] elements;
- CBuilder builder = CBuilder.create(comparator);
+ public OneClusteringBuilder(ClusteringComparator comparator)
+ {
+ super(comparator);
+ this.elements = new ByteBuffer[comparator.size()];
+ }
- if (elementsList.isEmpty())
- return BTreeSet.of(comparator, builder.buildBound(isStart, isInclusive));
+ public MultiCBuilder addElementToAll(ByteBuffer value)
+ {
+ checkUpdateable();
- // Use a TreeSet to sort and eliminate duplicates
- BTreeSet.Builder<Slice.Bound> set = BTreeSet.builder(comparator);
+ if (value == null)
+ containsNull = true;
+ if (value == ByteBufferUtil.UNSET_BYTE_BUFFER)
+ containsUnset = true;
- // The first column of the slice might not be the first clustering column (e.g. clustering_0 = ? AND (clustering_1, clustering_2) >= (?, ?)
- int offset = columnDefs.get(0).position();
+ elements[size++] = value;
+ return this;
+ }
- for (int i = 0, m = elementsList.size(); i < m; i++)
+ public MultiCBuilder addEachElementToAll(List<ByteBuffer> values)
{
- List<ByteBuffer> elements = elementsList.get(i);
-
- // Handle the no bound case
- if (elements.size() == offset)
+ if (values.isEmpty())
{
- set.add(builder.buildBoundWith(elements, isStart, true));
- continue;
+ hasMissingElements = true;
+ return this;
}
- // In the case of mixed order columns, we will have some extra slices where the columns change directions.
- // For example: if we have clustering_0 DESC and clustering_1 ASC a slice like (clustering_0, clustering_1) > (1, 2)
- // will produce 2 slices: [BOTTOM, 1) and (1.2, 1]
- // So, the END bound will return 2 bounds with the same values 1
- ColumnDefinition lastColumn = columnDefs.get(columnDefs.size() - 1);
- if (elements.size() <= lastColumn.position() && i < m - 1 && elements.equals(elementsList.get(i + 1)))
+ assert values.size() == 1;
+
+ return addElementToAll(values.get(0));
+ }
+
+ public MultiCBuilder addAllElementsToAll(List<List<ByteBuffer>> values)
+ {
+ if (values.isEmpty())
{
- set.add(builder.buildBoundWith(elements, isStart, false));
- set.add(builder.buildBoundWith(elementsList.get(i++), isStart, true));
- continue;
+ hasMissingElements = true;
+ return this;
}
- // Handle the normal bounds
- ColumnDefinition column = columnDefs.get(elements.size() - 1 - offset);
- set.add(builder.buildBoundWith(elements, isStart, column.isReversedType() ? isOtherBoundInclusive : isInclusive));
+ assert values.size() == 1;
+ return addEachElementToAll(values.get(0));
}
- return set.build();
- }
- public NavigableSet<Slice.Bound> buildBound(boolean isStart, boolean isInclusive)
- {
- built = true;
-
- if (hasMissingElements)
- return BTreeSet.empty(comparator);
+ public NavigableSet<Clustering> build()
+ {
+ built = true;
- CBuilder builder = CBuilder.create(comparator);
+ if (hasMissingElements)
+ return BTreeSet.empty(comparator);
- if (elementsList.isEmpty())
- return BTreeSet.of(comparator, builder.buildBound(isStart, isInclusive));
+ return BTreeSet.of(comparator, size == 0 ? Clustering.EMPTY : Clustering.make(elements));
+ }
- // Use a TreeSet to sort and eliminate duplicates
- BTreeSet.Builder<Slice.Bound> set = BTreeSet.builder(comparator);
++ @Override
++ public NavigableSet<Bound> buildBoundForSlice(boolean isStart,
++ boolean isInclusive,
++ boolean isOtherBoundInclusive,
++ List<ColumnDefinition> columnDefs)
++ {
++ return buildBound(isStart, columnDefs.get(0).isReversedType() ? isOtherBoundInclusive : isInclusive);
++ }
+
- for (int i = 0, m = elementsList.size(); i < m; i++)
+ public NavigableSet<Slice.Bound> buildBound(boolean isStart, boolean isInclusive)
{
- List<ByteBuffer> elements = elementsList.get(i);
- set.add(builder.buildBoundWith(elements, isStart, isInclusive));
+ built = true;
+
+ if (hasMissingElements)
+ return BTreeSet.empty(comparator);
+
+ if (size == 0)
+ return BTreeSet.of(comparator, isStart ? Slice.Bound.BOTTOM : Slice.Bound.TOP);
+
+ ByteBuffer[] newValues = size == elements.length
+ ? elements
+ : Arrays.copyOf(elements, size);
+
+ return BTreeSet.of(comparator, Slice.Bound.create(Slice.Bound.boundKind(isStart, isInclusive), newValues));
}
- return set.build();
}
/**
- * Checks if some elements can still be added to the clusterings.
- *
- * @return <code>true</code> if it is possible to add more elements to the clusterings, <code>false</code> otherwise.
+ * MultiCBuilder implementation actually supporting the creation of multiple clustering/bound.
*/
- public boolean hasRemaining()
+ private static class MultiClusteringBuilder extends MultiCBuilder
{
- return remainingCount() > 0;
- }
+ /**
+ * The elements of the clusterings
+ */
+ private final List<List<ByteBuffer>> elementsList = new ArrayList<>();
- private void checkUpdateable()
- {
- if (!hasRemaining() || built)
- throw new IllegalStateException("this builder cannot be updated anymore");
+ public MultiClusteringBuilder(ClusteringComparator comparator)
+ {
+ super(comparator);
+ }
+
+ public MultiCBuilder addElementToAll(ByteBuffer value)
+ {
+ checkUpdateable();
+
+ if (elementsList.isEmpty())
+ elementsList.add(new ArrayList<ByteBuffer>());
+
+ if (value == null)
+ containsNull = true;
+ else if (value == ByteBufferUtil.UNSET_BYTE_BUFFER)
+ containsUnset = true;
+
+ for (int i = 0, m = elementsList.size(); i < m; i++)
+ elementsList.get(i).add(value);
+
+ size++;
+ return this;
+ }
+
+ public MultiCBuilder addEachElementToAll(List<ByteBuffer> values)
+ {
+ checkUpdateable();
+
+ if (elementsList.isEmpty())
+ elementsList.add(new ArrayList<ByteBuffer>());
+
+ if (values.isEmpty())
+ {
+ hasMissingElements = true;
+ }
+ else
+ {
+ for (int i = 0, m = elementsList.size(); i < m; i++)
+ {
+ List<ByteBuffer> oldComposite = elementsList.remove(0);
+
+ for (int j = 0, n = values.size(); j < n; j++)
+ {
+ List<ByteBuffer> newComposite = new ArrayList<>(oldComposite);
+ elementsList.add(newComposite);
+
+ ByteBuffer value = values.get(j);
+
+ if (value == null)
+ containsNull = true;
+ if (value == ByteBufferUtil.UNSET_BYTE_BUFFER)
+ containsUnset = true;
+
+ newComposite.add(values.get(j));
+ }
+ }
+ }
+ size++;
+ return this;
+ }
+
+ public MultiCBuilder addAllElementsToAll(List<List<ByteBuffer>> values)
+ {
+ checkUpdateable();
+
+ if (elementsList.isEmpty())
+ elementsList.add(new ArrayList<ByteBuffer>());
+
+ if (values.isEmpty())
+ {
+ hasMissingElements = true;
+ }
+ else
+ {
+ for (int i = 0, m = elementsList.size(); i < m; i++)
+ {
+ List<ByteBuffer> oldComposite = elementsList.remove(0);
+
+ for (int j = 0, n = values.size(); j < n; j++)
+ {
+ List<ByteBuffer> newComposite = new ArrayList<>(oldComposite);
+ elementsList.add(newComposite);
+
+ List<ByteBuffer> value = values.get(j);
+
- if (value.isEmpty())
- hasMissingElements = true;
-
+ if (value.contains(null))
+ containsNull = true;
+ if (value.contains(ByteBufferUtil.UNSET_BYTE_BUFFER))
+ containsUnset = true;
+
+ newComposite.addAll(value);
+ }
+ }
+ size += values.get(0).size();
+ }
+ return this;
+ }
+
+ public NavigableSet<Clustering> build()
+ {
+ built = true;
+
+ if (hasMissingElements)
+ return BTreeSet.empty(comparator);
+
+ CBuilder builder = CBuilder.create(comparator);
+
+ if (elementsList.isEmpty())
+ return BTreeSet.of(builder.comparator(), builder.build());
+
+ BTreeSet.Builder<Clustering> set = BTreeSet.builder(builder.comparator());
+ for (int i = 0, m = elementsList.size(); i < m; i++)
+ {
+ List<ByteBuffer> elements = elementsList.get(i);
+ set.add(builder.buildWith(elements));
+ }
+ return set.build();
+ }
+
++ public NavigableSet<Slice.Bound> buildBoundForSlice(boolean isStart,
++ boolean isInclusive,
++ boolean isOtherBoundInclusive,
++ List<ColumnDefinition> columnDefs)
++ {
++ built = true;
++
++ if (hasMissingElements)
++ return BTreeSet.empty(comparator);
++
++ CBuilder builder = CBuilder.create(comparator);
++
++ if (elementsList.isEmpty())
++ return BTreeSet.of(comparator, builder.buildBound(isStart, isInclusive));
++
++ // Use a TreeSet to sort and eliminate duplicates
++ BTreeSet.Builder<Slice.Bound> set = BTreeSet.builder(comparator);
++
++ // The first column of the slice might not be the first clustering column (e.g. clustering_0 = ? AND (clustering_1, clustering_2) >= (?, ?)
++ int offset = columnDefs.get(0).position();
++
++ for (int i = 0, m = elementsList.size(); i < m; i++)
++ {
++ List<ByteBuffer> elements = elementsList.get(i);
++
++ // Handle the no bound case
++ if (elements.size() == offset)
++ {
++ set.add(builder.buildBoundWith(elements, isStart, true));
++ continue;
++ }
++
++ // In the case of mixed order columns, we will have some extra slices where the columns change directions.
++ // For example: if we have clustering_0 DESC and clustering_1 ASC a slice like (clustering_0, clustering_1) > (1, 2)
++ // will produce 2 slices: [BOTTOM, 1) and (1.2, 1]
++ // So, the END bound will return 2 bounds with the same values 1
++ ColumnDefinition lastColumn = columnDefs.get(columnDefs.size() - 1);
++ if (elements.size() <= lastColumn.position() && i < m - 1 && elements.equals(elementsList.get(i + 1)))
++ {
++ set.add(builder.buildBoundWith(elements, isStart, false));
++ set.add(builder.buildBoundWith(elementsList.get(i++), isStart, true));
++ continue;
++ }
++
++ // Handle the normal bounds
++ ColumnDefinition column = columnDefs.get(elements.size() - 1 - offset);
++ set.add(builder.buildBoundWith(elements, isStart, column.isReversedType() ? isOtherBoundInclusive : isInclusive));
++ }
++ return set.build();
++ }
++
+ public NavigableSet<Slice.Bound> buildBound(boolean isStart, boolean isInclusive)
+ {
+ built = true;
+
+ if (hasMissingElements)
+ return BTreeSet.empty(comparator);
+
+ CBuilder builder = CBuilder.create(comparator);
+
+ if (elementsList.isEmpty())
+ return BTreeSet.of(comparator, builder.buildBound(isStart, isInclusive));
+
+ // Use a TreeSet to sort and eliminate duplicates
+ BTreeSet.Builder<Slice.Bound> set = BTreeSet.builder(comparator);
+
+ for (int i = 0, m = elementsList.size(); i < m; i++)
+ {
+ List<ByteBuffer> elements = elementsList.get(i);
+ set.add(builder.buildBoundWith(elements, isStart, isInclusive));
+ }
+ return set.build();
+ }
}
}