cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From slebre...@apache.org
Subject [2/3] git commit: Merge branch 'cassandra-2.0' into cassandra-2.1
Date Wed, 02 Apr 2014 19:38:36 GMT
Merge branch 'cassandra-2.0' into cassandra-2.1

Conflicts:
	src/java/org/apache/cassandra/cql3/ColumnCondition.java


Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/13510d41
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/13510d41
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/13510d41

Branch: refs/heads/trunk
Commit: 13510d414fbb0da489ecd062054aa49d059ba79d
Parents: 8234bc1 5aafa98
Author: Sylvain Lebresne <sylvain@datastax.com>
Authored: Wed Apr 2 21:38:03 2014 +0200
Committer: Sylvain Lebresne <sylvain@datastax.com>
Committed: Wed Apr 2 21:38:03 2014 +0200

----------------------------------------------------------------------
 CHANGES.txt                                     |   1 +
 .../apache/cassandra/cql3/ColumnCondition.java  | 126 +++++++++++++++++--
 src/java/org/apache/cassandra/cql3/Cql.g        |   4 +-
 .../cql3/statements/CQL3CasConditions.java      |   5 +-
 4 files changed, 123 insertions(+), 13 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cassandra/blob/13510d41/CHANGES.txt
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/cassandra/blob/13510d41/src/java/org/apache/cassandra/cql3/ColumnCondition.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/cql3/ColumnCondition.java
index 64c2032,9fb3390..67e7174
--- a/src/java/org/apache/cassandra/cql3/ColumnCondition.java
+++ b/src/java/org/apache/cassandra/cql3/ColumnCondition.java
@@@ -36,19 -35,28 +37,28 @@@ import org.apache.cassandra.utils.ByteB
   */
  public class ColumnCondition
  {
 -    public final CFDefinition.Name column;
 +    public final ColumnDefinition column;
+ 
+     // For collection, when testing the equality of a specific element, null otherwise.
+     private final Term collectionElement;
+ 
      private final Term value;
  
-     private ColumnCondition(ColumnDefinition column, Term value)
 -    private ColumnCondition(CFDefinition.Name column, Term collectionElement, Term value)
++    private ColumnCondition(ColumnDefinition column, Term collectionElement, Term value)
      {
          this.column = column;
+         this.collectionElement = collectionElement;
          this.value = value;
      }
  
-     // The only ones we support so far
 -    public static ColumnCondition equal(CFDefinition.Name column, Term value)
 +    public static ColumnCondition equal(ColumnDefinition column, Term value)
      {
-         return new ColumnCondition(column, value);
+         return new ColumnCondition(column, null, value);
+     }
+ 
 -    public static ColumnCondition equal(CFDefinition.Name column, Term collectionElement,
Term value)
++    public static ColumnCondition equal(ColumnDefinition column, Term collectionElement,
Term value)
+     {
+         return new ColumnCondition(column, collectionElement, value);
      }
  
      /**
@@@ -76,15 -86,29 +88,29 @@@
              this.variables = variables;
          }
  
-         // Not overriding equals() because we need the variables to have been attached when
this is
-         // called and so having a non standard method name might help avoid mistakes
          public boolean equalsTo(WithVariables other) throws InvalidRequestException
          {
-             return column.equals(other.column())
-                 && value.bindAndGet(variables).equals(other.value().bindAndGet(other.variables));
+             if (!column().equals(other.column()))
+                 return false;
+ 
+             if ((collectionElement() == null) != (other.collectionElement() == null))
+                 return false;
+ 
+             if (collectionElement() != null)
+             {
+                 assert column.type instanceof ListType || column.type instanceof MapType;
+                 AbstractType<?> comparator = column.type instanceof ListType
+                                            ? Int32Type.instance
+                                            : ((MapType)column.type).keys;
+ 
+                 if (comparator.compare(collectionElement().bindAndGet(variables), other.collectionElement().bindAndGet(variables))
!= 0)
+                     return false;
+             }
+ 
+             return value().bindAndGet(variables).equals(other.value().bindAndGet(other.variables));
          }
  
 -        private CFDefinition.Name column()
 +        private ColumnDefinition column()
          {
              return column;
          }
@@@ -94,6 -123,16 +125,11 @@@
              return value;
          }
  
+         public ByteBuffer getCollectionElementValue() throws InvalidRequestException
+         {
+             return collectionElement == null ? null : collectionElement.bindAndGet(variables);
+         }
+ 
 -        private ColumnNameBuilder copyOrUpdatePrefix(CFMetaData cfm, ColumnNameBuilder rowPrefix)
 -        {
 -            return column.kind == CFDefinition.Name.Kind.STATIC ? cfm.getStaticColumnNameBuilder()
: rowPrefix.copy();
 -        }
 -
          /**
           * Validates whether this condition applies to {@code current}.
           */
@@@ -102,22 -141,39 +138,34 @@@
              if (column.type instanceof CollectionType)
                  return collectionAppliesTo((CollectionType)column.type, rowPrefix, current,
now);
  
+             assert collectionElement == null;
 -            ColumnNameBuilder prefix = copyOrUpdatePrefix(current.metadata(), rowPrefix);
 -            ByteBuffer columnName = column.kind == CFDefinition.Name.Kind.VALUE_ALIAS
 -                                  ? prefix.build()
 -                                  : prefix.add(column.name.key).build();
 -
 -            Column c = current.getColumn(columnName);
 +            Cell c = current.getColumn(current.metadata().comparator.create(rowPrefix, column));
              ByteBuffer v = value.bindAndGet(variables);
              return v == null
                   ? c == null || !c.isLive(now)
 -                 : c != null && c.isLive(now) && column.type.compare(c.value(),
v) == 0;
 +                 : c != null && c.isLive(now) && c.value().equals(v);
          }
  
 -        private boolean collectionAppliesTo(CollectionType type, ColumnNameBuilder rowPrefix,
ColumnFamily current, final long now) throws InvalidRequestException
 +        private boolean collectionAppliesTo(CollectionType type, Composite rowPrefix, ColumnFamily
current, final long now) throws InvalidRequestException
          {
 -            ColumnNameBuilder collectionPrefix = copyOrUpdatePrefix(current.metadata(),
rowPrefix).add(column.name.key);
+             Term.Terminal v = value.bind(variables);
+ 
+             // For map element access, we won't iterate over the collection, so deal with
that first. In other case, we do.
+             if (collectionElement != null && type instanceof MapType)
+             {
+                 ByteBuffer e = collectionElement.bindAndGet(variables);
+                 if (e == null)
+                     throw new InvalidRequestException("Invalid null value for map access");
 -                return mapElementAppliesTo((MapType)type, current, collectionPrefix, e,
v.get(), now);
++                return mapElementAppliesTo((MapType)type, current, rowPrefix, e, v.get(),
now);
+             }
+ 
 +            CellName name = current.metadata().comparator.create(rowPrefix, column);
              // We are testing for collection equality, so we need to have the expected values
*and* only those.
 -            ColumnSlice[] collectionSlice = new ColumnSlice[]{ new ColumnSlice(collectionPrefix.build(),
collectionPrefix.buildAsEndOfRange()) };
 +            ColumnSlice[] collectionSlice = new ColumnSlice[]{ name.slice() };
              // Filter live columns, this makes things simpler afterwards
 -            Iterator<Column> iter = Iterators.filter(current.iterator(collectionSlice),
new Predicate<Column>()
 +            Iterator<Cell> iter = Iterators.filter(current.iterator(collectionSlice),
new Predicate<Cell>()
              {
 -                public boolean apply(Column c)
 +                public boolean apply(Cell c)
                  {
                      // we only care about live columns
                      return c.isLive(now);
@@@ -127,12 -183,21 +175,21 @@@
              if (v == null)
                  return !iter.hasNext();
  
+             if (collectionElement != null)
+             {
+                 assert type instanceof ListType;
+                 ByteBuffer e = collectionElement.bindAndGet(variables);
+                 if (e == null)
+                     throw new InvalidRequestException("Invalid null value for list access");
+ 
+                 return listElementAppliesTo((ListType)type, iter, e, v.get());
+             }
+ 
              switch (type.kind)
              {
 -                case LIST: return listAppliesTo((ListType)type, current.metadata(), iter,
((Lists.Value)v).elements);
 -                case SET: return setAppliesTo((SetType)type, current.metadata(), iter, ((Sets.Value)v).elements);
 -                case MAP: return mapAppliesTo((MapType)type, current.metadata(), iter, ((Maps.Value)v).map);
 +                case LIST: return listAppliesTo((ListType)type, iter, ((Lists.Value)v).elements);
 +                case SET: return setAppliesTo((SetType)type, iter, ((Sets.Value)v).elements);
 +                case MAP: return mapAppliesTo((MapType)type, iter, ((Maps.Value)v).map);
              }
              throw new AssertionError();
          }
@@@ -146,7 -217,20 +203,20 @@@
              return !iter.hasNext();
          }
  
 -        private boolean listElementAppliesTo(ListType type, Iterator<Column> iter,
ByteBuffer element, ByteBuffer value) throws InvalidRequestException
++        private boolean listElementAppliesTo(ListType type, Iterator<Cell> iter, ByteBuffer
element, ByteBuffer value) throws InvalidRequestException
+         {
+             int idx = ByteBufferUtil.toInt(element);
+             if (idx < 0)
+                 throw new InvalidRequestException(String.format("Invalid negative list index
%d", idx));
+ 
+             int adv = Iterators.advance(iter, idx);
+             if (adv != idx || !iter.hasNext())
+                 throw new InvalidRequestException(String.format("List index %d out of bound,
list has size %d", idx, adv));
+ 
+             return type.elements.compare(iter.next().value(), value) == 0;
+         }
+ 
 -        private boolean setAppliesTo(SetType type, CFMetaData cfm, Iterator<Column>
iter, Set<ByteBuffer> elements)
 +        private boolean setAppliesTo(SetType type, Iterator<Cell> iter, Set<ByteBuffer>
elements)
          {
              Set<ByteBuffer> remaining = new TreeSet<>(type.elements);
              remaining.addAll(elements);
@@@ -177,23 -261,59 +247,59 @@@
              }
              return remaining.isEmpty();
          }
+ 
 -        private boolean mapElementAppliesTo(MapType type, ColumnFamily current, ColumnNameBuilder
collectionPrefix, ByteBuffer element, ByteBuffer value, long now)
++        private boolean mapElementAppliesTo(MapType type, ColumnFamily current, Composite
rowPrefix, ByteBuffer element, ByteBuffer value, long now)
+         {
 -            ByteBuffer name = collectionPrefix.add(element).build();
 -            Column c = current.getColumn(name);
++            CellName name = current.getComparator().create(rowPrefix, column, element);
++            Cell c = current.getColumn(name);
+             return c != null && c.isLive(now) && type.values.compare(c.value(),
value) == 0;
+         }
      }
  
      public static class Raw
      {
          private final Term.Raw value;
  
-         public Raw(Term.Raw value)
+         // Can be null, only used with the syntax "IF m[e] = ..." (in which case it's 'e')
+         private final Term.Raw collectionElement;
+ 
+         private Raw(Term.Raw value, Term.Raw collectionElement)
          {
              this.value = value;
+             this.collectionElement = collectionElement;
+         }
+ 
+         public static Raw simpleEqual(Term.Raw value)
+         {
+             return new Raw(value, null);
+         }
+ 
+         public static Raw collectionEqual(Term.Raw value, Term.Raw collectionElement)
+         {
+             return new Raw(value, collectionElement);
          }
  
 -        public ColumnCondition prepare(CFDefinition.Name receiver) throws InvalidRequestException
 +        public ColumnCondition prepare(String keyspace, ColumnDefinition receiver) throws
InvalidRequestException
          {
              if (receiver.type instanceof CounterColumnType)
                  throw new InvalidRequestException("Condtions on counters are not supported");
  
-             return ColumnCondition.equal(receiver, value.prepare(keyspace, receiver));
+             if (collectionElement == null)
 -                return ColumnCondition.equal(receiver, value.prepare(receiver));
++                return ColumnCondition.equal(receiver, value.prepare(keyspace, receiver));
+ 
+             if (!(receiver.type.isCollection()))
+                 throw new InvalidRequestException(String.format("Invalid element access
syntax for non-collection column %s", receiver.name));
+ 
+             switch (((CollectionType)receiver.type).kind)
+             {
+                 case LIST:
 -                    return ColumnCondition.equal(receiver, collectionElement.prepare(Lists.indexSpecOf(receiver)),
value.prepare(Lists.valueSpecOf(receiver)));
++                    return ColumnCondition.equal(receiver, collectionElement.prepare(keyspace,
Lists.indexSpecOf(receiver)), value.prepare(keyspace, Lists.valueSpecOf(receiver)));
+                 case SET:
+                     throw new InvalidRequestException(String.format("Invalid element access
syntax for set column %s", receiver.name));
+                 case MAP:
 -                    return ColumnCondition.equal(receiver, collectionElement.prepare(Maps.keySpecOf(receiver)),
value.prepare(Maps.valueSpecOf(receiver)));
++                    return ColumnCondition.equal(receiver, collectionElement.prepare(keyspace,
Maps.keySpecOf(receiver)), value.prepare(keyspace, Maps.valueSpecOf(receiver)));
+             }
+             throw new AssertionError();
          }
      }
  }

http://git-wip-us.apache.org/repos/asf/cassandra/blob/13510d41/src/java/org/apache/cassandra/cql3/Cql.g
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/cassandra/blob/13510d41/src/java/org/apache/cassandra/cql3/statements/CQL3CasConditions.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/cql3/statements/CQL3CasConditions.java
index fb842a2,9f67bc0..4003edc
--- a/src/java/org/apache/cassandra/cql3/statements/CQL3CasConditions.java
+++ b/src/java/org/apache/cassandra/cql3/statements/CQL3CasConditions.java
@@@ -166,9 -167,9 +167,9 @@@ public class CQL3CasConditions implemen
  
      private static class ColumnsConditions extends RowCondition
      {
-         private final Map<ColumnIdentifier, ColumnCondition.WithVariables> conditions
= new HashMap<>();
+         private final Map<Pair<ColumnIdentifier, ByteBuffer>, ColumnCondition.WithVariables>
conditions = new HashMap<>();
  
 -        private ColumnsConditions(ColumnNameBuilder rowPrefix, long now)
 +        private ColumnsConditions(Composite rowPrefix, long now)
          {
              super(rowPrefix, now);
          }


Mime
View raw message