You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by sl...@apache.org on 2014/10/02 10:11:38 UTC
[1/2] git commit: Better validation of collection values
Repository: cassandra
Updated Branches:
refs/heads/cassandra-2.1 b9826f5f0 -> 814e55af4
Better validation of collection values
patch by slebresne; reviewed by thobbs for CASSANDRA-7833
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/1a096efe
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/1a096efe
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/1a096efe
Branch: refs/heads/cassandra-2.1
Commit: 1a096efebb51a782bc31e4dfd35e4b7fb8dba56f
Parents: cf60d1e
Author: Sylvain Lebresne <sy...@datastax.com>
Authored: Thu Oct 2 09:47:44 2014 +0200
Committer: Sylvain Lebresne <sy...@datastax.com>
Committed: Thu Oct 2 09:47:44 2014 +0200
----------------------------------------------------------------------
CHANGES.txt | 1 +
src/java/org/apache/cassandra/serializers/ListSerializer.java | 2 ++
src/java/org/apache/cassandra/serializers/MapSerializer.java | 2 ++
src/java/org/apache/cassandra/serializers/SetSerializer.java | 2 ++
4 files changed, 7 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/1a096efe/CHANGES.txt
----------------------------------------------------------------------
diff --git a/CHANGES.txt b/CHANGES.txt
index 0e5a0d0..3454928 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,4 +1,5 @@
2.0.11:
+ * Better validation of collection values (CASSANDRA-7833)
* Fix possible overflow while sorting CL segments for replay (CASSANDRA-7992)
* Increase nodetool Xmx (CASSANDRA-7956)
* Archive any commitlog segments present at startup (CASSANDRA-6904)
http://git-wip-us.apache.org/repos/asf/cassandra/blob/1a096efe/src/java/org/apache/cassandra/serializers/ListSerializer.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/serializers/ListSerializer.java b/src/java/org/apache/cassandra/serializers/ListSerializer.java
index 59f25d2..74cab7e 100644
--- a/src/java/org/apache/cassandra/serializers/ListSerializer.java
+++ b/src/java/org/apache/cassandra/serializers/ListSerializer.java
@@ -60,6 +60,8 @@ public class ListSerializer<T> extends CollectionSerializer<List<T>>
elements.validate(databb);
l.add(elements.deserialize(databb));
}
+ if (input.hasRemaining())
+ throw new MarshalException("Unexpected extraneous bytes after list value");
return l;
}
catch (BufferUnderflowException e)
http://git-wip-us.apache.org/repos/asf/cassandra/blob/1a096efe/src/java/org/apache/cassandra/serializers/MapSerializer.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/serializers/MapSerializer.java b/src/java/org/apache/cassandra/serializers/MapSerializer.java
index f79d07f..47515a1 100644
--- a/src/java/org/apache/cassandra/serializers/MapSerializer.java
+++ b/src/java/org/apache/cassandra/serializers/MapSerializer.java
@@ -68,6 +68,8 @@ public class MapSerializer<K, V> extends CollectionSerializer<Map<K, V>>
m.put(keys.deserialize(kbb), values.deserialize(vbb));
}
+ if (input.hasRemaining())
+ throw new MarshalException("Unexpected extraneous bytes after map value");
return m;
}
catch (BufferUnderflowException e)
http://git-wip-us.apache.org/repos/asf/cassandra/blob/1a096efe/src/java/org/apache/cassandra/serializers/SetSerializer.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/serializers/SetSerializer.java b/src/java/org/apache/cassandra/serializers/SetSerializer.java
index d6d7062..a6df281 100644
--- a/src/java/org/apache/cassandra/serializers/SetSerializer.java
+++ b/src/java/org/apache/cassandra/serializers/SetSerializer.java
@@ -60,6 +60,8 @@ public class SetSerializer<T> extends CollectionSerializer<Set<T>>
elements.validate(databb);
l.add(elements.deserialize(databb));
}
+ if (input.hasRemaining())
+ throw new MarshalException("Unexpected extraneous bytes after set value");
return l;
}
catch (BufferUnderflowException e)
[2/2] git commit: Merge branch 'cassandra-2.0' into cassandra-2.1
Posted by sl...@apache.org.
Merge branch 'cassandra-2.0' into cassandra-2.1
Conflicts:
CHANGES.txt
src/java/org/apache/cassandra/serializers/ListSerializer.java
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/814e55af
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/814e55af
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/814e55af
Branch: refs/heads/cassandra-2.1
Commit: 814e55af4515ea1f9c9c6da8fa8aaa4209930a1d
Parents: b9826f5 1a096ef
Author: Sylvain Lebresne <sy...@datastax.com>
Authored: Thu Oct 2 10:11:23 2014 +0200
Committer: Sylvain Lebresne <sy...@datastax.com>
Committed: Thu Oct 2 10:11:23 2014 +0200
----------------------------------------------------------------------
CHANGES.txt | 1 +
src/java/org/apache/cassandra/cql3/Lists.java | 4 +-
.../cassandra/serializers/ListSerializer.java | 7 +
.../cassandra/serializers/MapSerializer.java | 4 +
.../cassandra/serializers/SetSerializer.java | 4 +
.../org/apache/cassandra/cql3/CQLTester.java | 2 +-
.../apache/cassandra/cql3/CollectionsTest.java | 255 +++++++++----------
7 files changed, 142 insertions(+), 135 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/814e55af/CHANGES.txt
----------------------------------------------------------------------
diff --cc CHANGES.txt
index 5d628d1,3454928..9fb1274
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@@ -1,56 -1,5 +1,57 @@@
-2.0.11:
+2.1.1
+ * (cqlsh) Fix IPv6 support (CASSANDRA-7988)
+ * Ignore fat clients when checking for endpoint collision (CASSANDRA-7939)
+ * Make sstablerepairedset take a list of files (CASSANDRA-7995)
+ * (cqlsh) Tab completeion for indexes on map keys (CASSANDRA-7972)
+ * (cqlsh) Fix UDT field selection in select clause (CASSANDRA-7891)
+ * Fix resource leak in event of corrupt sstable
+ * (cqlsh) Add command line option for cqlshrc file path (CASSANDRA-7131)
+ * Provide visibility into prepared statements churn (CASSANDRA-7921, CASSANDRA-7930)
+ * Invalidate prepared statements when their keyspace or table is
+ dropped (CASSANDRA-7566)
+ * cassandra-stress: fix support for NetworkTopologyStrategy (CASSANDRA-7945)
+ * Fix saving caches when a table is dropped (CASSANDRA-7784)
+ * Add better error checking of new stress profile (CASSANDRA-7716)
+ * Use ThreadLocalRandom and remove FBUtilities.threadLocalRandom (CASSANDRA-7934)
+ * Prevent operator mistakes due to simultaneous bootstrap (CASSANDRA-7069)
+ * cassandra-stress supports whitelist mode for node config (CASSANDRA-7658)
+ * GCInspector more closely tracks GC; cassandra-stress and nodetool report it (CASSANDRA-7916)
+ * nodetool won't output bogus ownership info without a keyspace (CASSANDRA-7173)
+ * Add human readable option to nodetool commands (CASSANDRA-5433)
+ * Don't try to set repairedAt on old sstables (CASSANDRA-7913)
+ * Add metrics for tracking PreparedStatement use (CASSANDRA-7719)
+ * (cqlsh) tab-completion for triggers (CASSANDRA-7824)
+ * (cqlsh) Support for query paging (CASSANDRA-7514)
+ * (cqlsh) Show progress of COPY operations (CASSANDRA-7789)
+ * Add syntax to remove multiple elements from a map (CASSANDRA-6599)
+ * Support non-equals conditions in lightweight transactions (CASSANDRA-6839)
+ * Add IF [NOT] EXISTS to create/drop triggers (CASSANDRA-7606)
+ * (cqlsh) Display the current logged-in user (CASSANDRA-7785)
+ * (cqlsh) Don't ignore CTRL-C during COPY FROM execution (CASSANDRA-7815)
+ * (cqlsh) Order UDTs according to cross-type dependencies in DESCRIBE
+ output (CASSANDRA-7659)
+ * (cqlsh) Fix handling of CAS statement results (CASSANDRA-7671)
+ * (cqlsh) COPY TO/FROM improvements (CASSANDRA-7405)
+ * Support list index operations with conditions (CASSANDRA-7499)
+ * Add max live/tombstoned cells to nodetool cfstats output (CASSANDRA-7731)
+ * Validate IPv6 wildcard addresses properly (CASSANDRA-7680)
+ * (cqlsh) Error when tracing query (CASSANDRA-7613)
+ * Avoid IOOBE when building SyntaxError message snippet (CASSANDRA-7569)
+ * SSTableExport uses correct validator to create string representation of partition
+ keys (CASSANDRA-7498)
+ * Avoid NPEs when receiving type changes for an unknown keyspace (CASSANDRA-7689)
+ * Add support for custom 2i validation (CASSANDRA-7575)
+ * Pig support for hadoop CqlInputFormat (CASSANDRA-6454)
+ * Add listen_interface and rpc_interface options (CASSANDRA-7417)
+ * Improve schema merge performance (CASSANDRA-7444)
+ * Adjust MT depth based on # of partition validating (CASSANDRA-5263)
+ * Optimise NativeCell comparisons (CASSANDRA-6755)
+ * Configurable client timeout for cqlsh (CASSANDRA-7516)
+ * Include snippet of CQL query near syntax error in messages (CASSANDRA-7111)
+ * Make repair -pr work with -local (CASSANDRA-7450)
+ * Fix error in sstableloader with -cph > 1 (CASSANDRA-8007)
+Merged from 2.0:
+ * Better validation of collection values (CASSANDRA-7833)
* Fix possible overflow while sorting CL segments for replay (CASSANDRA-7992)
* Increase nodetool Xmx (CASSANDRA-7956)
* Archive any commitlog segments present at startup (CASSANDRA-6904)
http://git-wip-us.apache.org/repos/asf/cassandra/blob/814e55af/src/java/org/apache/cassandra/cql3/Lists.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/cql3/Lists.java
index ea10b48,d483dd5..9d22364
--- a/src/java/org/apache/cassandra/cql3/Lists.java
+++ b/src/java/org/apache/cassandra/cql3/Lists.java
@@@ -422,13 -409,13 +422,15 @@@ public abstract class List
return true;
}
- public void execute(ByteBuffer rowKey, ColumnFamily cf, ColumnNameBuilder prefix, UpdateParameters params) throws InvalidRequestException
+ public void execute(ByteBuffer rowKey, ColumnFamily cf, Composite prefix, UpdateParameters params) throws InvalidRequestException
{
- List<Pair<ByteBuffer, Column>> existingList = params.getPrefetchedList(rowKey, columnName.key);
+ List<Cell> existingList = params.getPrefetchedList(rowKey, column.name);
++ // We want to call bind before possibly returning to reject queries where the value provided is not a list.
++ Term.Terminal value = t.bind(params.options);
++
if (existingList.isEmpty())
return;
- Term.Terminal value = t.bind(params.options);
- Term.Terminal value = t.bind(params.variables);
if (value == null)
return;
http://git-wip-us.apache.org/repos/asf/cassandra/blob/814e55af/src/java/org/apache/cassandra/serializers/ListSerializer.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/serializers/ListSerializer.java
index 9c642bc,74cab7e..7387e1b
--- a/src/java/org/apache/cassandra/serializers/ListSerializer.java
+++ b/src/java/org/apache/cassandra/serializers/ListSerializer.java
@@@ -65,9 -52,17 +65,12 @@@ public class ListSerializer<T> extends
try
{
ByteBuffer input = bytes.duplicate();
- int n = ByteBufferUtil.readShortLength(input);
- List<T> l = new ArrayList<T>(n);
+ int n = readCollectionSize(input, version);
for (int i = 0; i < n; i++)
- {
- ByteBuffer databb = ByteBufferUtil.readBytesWithShortLength(input);
- elements.validate(databb);
- l.add(elements.deserialize(databb));
- }
+ elements.validate(readValue(input, version));
++
+ if (input.hasRemaining())
+ throw new MarshalException("Unexpected extraneous bytes after list value");
- return l;
}
catch (BufferUnderflowException e)
{
@@@ -75,33 -70,24 +78,37 @@@
}
}
- /**
- * Layout is: {@code <n><s_1><b_1>...<s_n><b_n> }
- * where:
- * n is the number of elements
- * s_i is the number of bytes composing the ith element
- * b_i is the s_i bytes composing the ith element
- */
- public ByteBuffer serialize(List<T> value)
+ public List<T> deserializeForNativeProtocol(ByteBuffer bytes, int version)
{
- List<ByteBuffer> bbs = new ArrayList<ByteBuffer>(value.size());
- int size = 0;
- for (T elt : value)
+ try
+ {
+ ByteBuffer input = bytes.duplicate();
+ int n = readCollectionSize(input, version);
+ List<T> l = new ArrayList<T>(n);
+ for (int i = 0; i < n; i++)
+ {
+ // We can have nulls in lists that are used for IN values
+ ByteBuffer databb = readValue(input, version);
+ if (databb != null)
+ {
+ elements.validate(databb);
+ l.add(elements.deserialize(databb));
+ }
+ else
+ {
+ l.add(null);
+ }
+ }
++
++ if (input.hasRemaining())
++ throw new MarshalException("Unexpected extraneous bytes after list value");
++
+ return l;
+ }
+ catch (BufferUnderflowException e)
{
- ByteBuffer bb = elements.serialize(elt);
- bbs.add(bb);
- size += 2 + bb.remaining();
+ throw new MarshalException("Not enough bytes to read a list");
}
- return pack(bbs, value.size(), size);
}
public String toString(List<T> value)
http://git-wip-us.apache.org/repos/asf/cassandra/blob/814e55af/src/java/org/apache/cassandra/serializers/MapSerializer.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/serializers/MapSerializer.java
index 34e7c05,47515a1..dadadd0
--- a/src/java/org/apache/cassandra/serializers/MapSerializer.java
+++ b/src/java/org/apache/cassandra/serializers/MapSerializer.java
@@@ -51,41 -51,7 +51,43 @@@ public class MapSerializer<K, V> extend
this.values = values;
}
- public Map<K, V> deserialize(ByteBuffer bytes)
+ public List<ByteBuffer> serializeValues(Map<K, V> map)
+ {
+ List<ByteBuffer> buffers = new ArrayList<>(map.size() * 2);
+ for (Map.Entry<K, V> entry : map.entrySet())
+ {
+ buffers.add(keys.serialize(entry.getKey()));
+ buffers.add(values.serialize(entry.getValue()));
+ }
+ return buffers;
+ }
+
+ public int getElementCount(Map<K, V> value)
+ {
+ return value.size();
+ }
+
+ public void validateForNativeProtocol(ByteBuffer bytes, int version)
+ {
+ try
+ {
+ ByteBuffer input = bytes.duplicate();
+ int n = readCollectionSize(input, version);
+ for (int i = 0; i < n; i++)
+ {
+ keys.validate(readValue(input, version));
+ values.validate(readValue(input, version));
+ }
++ if (input.hasRemaining())
++ throw new MarshalException("Unexpected extraneous bytes after map value");
+ }
+ catch (BufferUnderflowException e)
+ {
+ throw new MarshalException("Not enough bytes to read a set");
+ }
+ }
+
+ public Map<K, V> deserializeForNativeProtocol(ByteBuffer bytes, int version)
{
try
{
http://git-wip-us.apache.org/repos/asf/cassandra/blob/814e55af/src/java/org/apache/cassandra/serializers/SetSerializer.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/serializers/SetSerializer.java
index 136b4e0,a6df281..de05a66
--- a/src/java/org/apache/cassandra/serializers/SetSerializer.java
+++ b/src/java/org/apache/cassandra/serializers/SetSerializer.java
@@@ -47,35 -47,7 +47,37 @@@ public class SetSerializer<T> extends C
this.elements = elements;
}
- public Set<T> deserialize(ByteBuffer bytes)
+ public List<ByteBuffer> serializeValues(Set<T> values)
+ {
+ List<ByteBuffer> buffers = new ArrayList<>(values.size());
+ for (T value : values)
+ buffers.add(elements.serialize(value));
+ return buffers;
+ }
+
+ public int getElementCount(Set<T> value)
+ {
+ return value.size();
+ }
+
+ public void validateForNativeProtocol(ByteBuffer bytes, int version)
+ {
+ try
+ {
+ ByteBuffer input = bytes.duplicate();
+ int n = readCollectionSize(input, version);
+ for (int i = 0; i < n; i++)
+ elements.validate(readValue(input, version));
++ if (input.hasRemaining())
++ throw new MarshalException("Unexpected extraneous bytes after set value");
+ }
+ catch (BufferUnderflowException e)
+ {
+ throw new MarshalException("Not enough bytes to read a set");
+ }
+ }
+
+ public Set<T> deserializeForNativeProtocol(ByteBuffer bytes, int version)
{
try
{
http://git-wip-us.apache.org/repos/asf/cassandra/blob/814e55af/test/unit/org/apache/cassandra/cql3/CQLTester.java
----------------------------------------------------------------------
diff --cc test/unit/org/apache/cassandra/cql3/CQLTester.java
index 236a9ff,0000000..6e4a5a9
mode 100644,000000..100644
--- a/test/unit/org/apache/cassandra/cql3/CQLTester.java
+++ b/test/unit/org/apache/cassandra/cql3/CQLTester.java
@@@ -1,678 -1,0 +1,678 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.cassandra.cql3;
+
+import java.io.File;
+import java.nio.ByteBuffer;
+import java.util.*;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableSet;
+import org.junit.AfterClass;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.cassandra.SchemaLoader;
+import org.apache.cassandra.config.CFMetaData;
+import org.apache.cassandra.config.Schema;
+import org.apache.cassandra.db.ConsistencyLevel;
+import org.apache.cassandra.db.Directories;
+import org.apache.cassandra.db.Keyspace;
+import org.apache.cassandra.db.marshal.*;
+import org.apache.cassandra.exceptions.*;
+import org.apache.cassandra.io.util.FileUtils;
+import org.apache.cassandra.serializers.TypeSerializer;
+import org.apache.cassandra.service.StorageService;
+import org.apache.cassandra.utils.ByteBufferUtil;
+
+/**
+ * Base class for CQL tests.
+ */
+public abstract class CQLTester
+{
+ protected static final Logger logger = LoggerFactory.getLogger(CQLTester.class);
+
+ public static final String KEYSPACE = "cql_test_keyspace";
+ private static final boolean USE_PREPARED_VALUES = Boolean.valueOf(System.getProperty("cassandra.test.use_prepared", "true"));
+ private static final AtomicInteger seqNumber = new AtomicInteger();
+
+ static
+ {
+ // Once per-JVM is enough
+ SchemaLoader.prepareServer();
+ }
+
+ private String currentTable;
+ private final Set<String> currentTypes = new HashSet<>();
+
+ @BeforeClass
+ public static void setUpClass() throws Throwable
+ {
+ schemaChange(String.format("CREATE KEYSPACE IF NOT EXISTS %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}", KEYSPACE));
+ }
+
+ @AfterClass
+ public static void tearDownClass()
+ {
+ }
+
+ @After
+ public void afterTest() throws Throwable
+ {
+ if (currentTable == null)
+ return;
+
+ final String tableToDrop = currentTable;
+ final Set<String> typesToDrop = currentTypes.isEmpty() ? Collections.emptySet() : new HashSet(currentTypes);
+ currentTable = null;
+ currentTypes.clear();
+
+ // We want to clean up after the test, but dropping a table is rather long so just do that asynchronously
+ StorageService.optionalTasks.execute(new Runnable()
+ {
+ public void run()
+ {
+ try
+ {
+ schemaChange(String.format("DROP TABLE %s.%s", KEYSPACE, tableToDrop));
+
+ for (String typeName : typesToDrop)
+ schemaChange(String.format("DROP TYPE %s.%s", KEYSPACE, typeName));
+
+ // Dropping doesn't delete the sstables. It's not a huge deal but it's cleaner to cleanup after us
+ // Thas said, we shouldn't delete blindly before the SSTableDeletingTask for the table we drop
+ // have run or they will be unhappy. Since those taks are scheduled on StorageService.tasks and that's
+ // mono-threaded, just push a task on the queue to find when it's empty. No perfect but good enough.
+
+ final CountDownLatch latch = new CountDownLatch(1);
+ StorageService.tasks.execute(new Runnable()
+ {
+ public void run()
+ {
+ latch.countDown();
+ }
+ });
+ latch.await(2, TimeUnit.SECONDS);
+
+ removeAllSSTables(KEYSPACE, tableToDrop);
+ }
+ catch (Exception e)
+ {
+ throw new RuntimeException(e);
+ }
+ }
+ });
+ }
+
+ public void flush()
+ {
+ try
+ {
+ if (currentTable != null)
+ Keyspace.open(KEYSPACE).getColumnFamilyStore(currentTable).forceFlush().get();
+ }
+ catch (InterruptedException e)
+ {
+ throw new RuntimeException(e);
+ }
+ catch (ExecutionException e)
+ {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public boolean usePrepared()
+ {
+ return USE_PREPARED_VALUES;
+ }
+
+ private static void removeAllSSTables(String ks, String table)
+ {
+ // clean up data directory which are stored as data directory/keyspace/data files
+ for (File d : Directories.getKSChildDirectories(ks))
+ {
+ if (d.exists() && d.getName().contains(table))
+ FileUtils.deleteRecursive(d);
+ }
+ }
+
+ protected String keyspace()
+ {
+ return KEYSPACE;
+ }
+
+ protected String currentTable()
+ {
+ return currentTable;
+ }
+
+ protected String createType(String query)
+ {
+ String typeName = "type_" + seqNumber.getAndIncrement();
+ String fullQuery = String.format(query, KEYSPACE + "." + typeName);
+ currentTypes.add(typeName);
+ logger.info(fullQuery);
+ schemaChange(fullQuery);
+ return typeName;
+ }
+
+ protected void createTable(String query)
+ {
+ currentTable = "table_" + seqNumber.getAndIncrement();
+ String fullQuery = String.format(query, KEYSPACE + "." + currentTable);
+ logger.info(fullQuery);
+ schemaChange(fullQuery);
+ }
+
+ protected void alterTable(String query)
+ {
+ String fullQuery = String.format(query, KEYSPACE + "." + currentTable);
+ logger.info(fullQuery);
+ schemaChange(fullQuery);
+ }
+
+ protected void createIndex(String query)
+ {
+ String fullQuery = String.format(query, KEYSPACE + "." + currentTable);
+ logger.info(fullQuery);
+ schemaChange(fullQuery);
+ }
+
+ private static void schemaChange(String query)
+ {
+ try
+ {
+ // executeOnceInternal don't work for schema changes
+ QueryProcessor.executeOnceInternal(query);
+ }
+ catch (Exception e)
+ {
+ throw new RuntimeException("Error setting schema for test (query was: " + query + ")", e);
+ }
+ }
+
+ protected CFMetaData currentTableMetadata()
+ {
+ return Schema.instance.getCFMetaData(KEYSPACE, currentTable);
+ }
+
+ protected UntypedResultSet execute(String query, Object... values) throws Throwable
+ {
+ try
+ {
+ query = currentTable == null ? query : String.format(query, KEYSPACE + "." + currentTable);
+
+ UntypedResultSet rs;
+ if (USE_PREPARED_VALUES)
+ {
+ logger.info("Executing: {} with values {}", query, formatAllValues(values));
+ rs = QueryProcessor.executeOnceInternal(query, transformValues(values));
+ }
+ else
+ {
+ query = replaceValues(query, values);
+ logger.info("Executing: {}", query);
+ rs = QueryProcessor.executeOnceInternal(query);
+ }
+ if (rs != null)
+ logger.info("Got {} rows", rs.size());
+ return rs;
+ }
+ catch (RuntimeException e)
+ {
+ Throwable cause = e.getCause() != null ? e.getCause() : e;
+ logger.info("Got error: {}", cause.getMessage() == null ? cause.toString() : cause.getMessage());
+ throw cause;
+ }
+ }
+
+ protected void assertRows(UntypedResultSet result, Object[]... rows)
+ {
+ if (result == null)
+ {
+ if (rows.length > 0)
+ Assert.fail(String.format("No rows returned by query but %d expected", rows.length));
+ return;
+ }
+
+ List<ColumnSpecification> meta = result.metadata();
+ Iterator<UntypedResultSet.Row> iter = result.iterator();
+ int i = 0;
+ while (iter.hasNext() && i < rows.length)
+ {
+ Object[] expected = rows[i++];
+ UntypedResultSet.Row actual = iter.next();
+
+ Assert.assertEquals(String.format("Invalid number of (expected) values provided for row %d", i), meta.size(), expected.length);
+
+ for (int j = 0; j < meta.size(); j++)
+ {
+ ColumnSpecification column = meta.get(j);
+ Object expectedValue = expected[j];
+ ByteBuffer expectedByteValue = makeByteBuffer(expected[j], (AbstractType)column.type);
+ ByteBuffer actualValue = actual.getBytes(column.name.toString());
+
+ if (!Objects.equal(expectedByteValue, actualValue))
+ Assert.fail(String.format("Invalid value for row %d column %d (%s of type %s), expected <%s> but got <%s>",
+ i, j, column.name, column.type.asCQL3Type(), formatValue(expectedByteValue, column.type), formatValue(actualValue, column.type)));
+ }
+ }
+
+ if (iter.hasNext())
+ {
+ while (iter.hasNext())
+ {
+ iter.next();
+ i++;
+ }
+ Assert.fail(String.format("Got less rows than expected. Expected %d but got %d.", rows.length, i));
+ }
+
+ Assert.assertTrue(String.format("Got more rows than expected. Expected %d but got %d", rows.length, i), i == rows.length);
+ }
+
+ protected void assertAllRows(Object[]... rows) throws Throwable
+ {
+ assertRows(execute("SELECT * FROM %s"), rows);
+ }
+
+ protected Object[] row(Object... expected)
+ {
+ return expected;
+ }
+
+ protected void assertEmpty(UntypedResultSet result) throws Throwable
+ {
+ if (result != null && result.size() != 0)
+ throw new InvalidRequestException(String.format("Expected empty result but got %d rows", result.size()));
+ }
+
+ protected void assertInvalid(String query, Object... values) throws Throwable
+ {
+ try
+ {
+ execute(query, values);
+ String q = USE_PREPARED_VALUES
+ ? query + " (values: " + formatAllValues(values) + ")"
+ : replaceValues(query, values);
+ Assert.fail("Query should be invalid but no error was thrown. Query is: " + q);
+ }
+ catch (InvalidRequestException e)
+ {
+ // This is what we expect
+ }
+ }
+
+ protected void assertInvalidSyntax(String query, Object... values) throws Throwable
+ {
+ try
+ {
+ execute(query, values);
+ String q = USE_PREPARED_VALUES
+ ? query + " (values: " + formatAllValues(values) + ")"
+ : replaceValues(query, values);
+ Assert.fail("Query should have invalid syntax but no error was thrown. Query is: " + q);
+ }
+ catch (SyntaxException e)
+ {
+ // This is what we expect
+ }
+ }
+
+ private static String replaceValues(String query, Object[] values)
+ {
+ StringBuilder sb = new StringBuilder();
+ int last = 0;
+ int i = 0;
+ int idx;
+ while ((idx = query.indexOf('?', last)) > 0)
+ {
+ if (i >= values.length)
+ throw new IllegalArgumentException(String.format("Not enough values provided. The query has at least %d variables but only %d values provided", i, values.length));
+
+ sb.append(query.substring(last, idx));
+
+ Object value = values[i++];
+
+ // When we have a .. IN ? .., we use a list for the value because that's what's expected when the value is serialized.
+ // When we format as string however, we need to special case to use parenthesis. Hackish but convenient.
+ if (idx >= 3 && value instanceof List && query.substring(idx - 3, idx).equalsIgnoreCase("IN "))
+ {
+ List l = (List)value;
+ sb.append("(");
+ for (int j = 0; j < l.size(); j++)
+ {
+ if (j > 0)
+ sb.append(", ");
+ sb.append(formatForCQL(l.get(j)));
+ }
+ sb.append(")");
+ }
+ else
+ {
+ sb.append(formatForCQL(value));
+ }
+ last = idx + 1;
+ }
+ sb.append(query.substring(last));
+ return sb.toString();
+ }
+
+ // We're rellly only returning ByteBuffers but this make the type system happy
+ private static Object[] transformValues(Object[] values)
+ {
+ // We could partly rely on QueryProcessor.executeOnceInternal doing type conversion for us, but
+ // it would complain with ClassCastException if we pass say a string where an int is excepted (since
+ // it bases conversion on what the value should be, not what it is). For testing, we sometimes
+ // want to pass value of the wrong type and assert that this properly raise an InvalidRequestException
- // and executeOnceInternal goes into way. So instead, we pre-convert everything to bytes here base
++ // and executeOnceInternal goes into way. So instead, we pre-convert everything to bytes here based
+ // on the value.
+ // Besides, we need to handle things like TupleValue that executeOnceInternal don't know about.
+
+ Object[] buffers = new ByteBuffer[values.length];
+ for (int i = 0; i < values.length; i++)
+ {
+ Object value = values[i];
+ if (value == null)
+ {
+ buffers[i] = null;
+ continue;
+ }
+
+ buffers[i] = typeFor(value).decompose(serializeTuples(value));
+ }
+ return buffers;
+ }
+
+ private static Object serializeTuples(Object value)
+ {
+ if (value instanceof TupleValue)
+ {
+ return ((TupleValue)value).toByteBuffer();
+ }
+
+ // We need to reach inside collections for TupleValue and transform them to ByteBuffer
+ // since otherwise the decompose method of the collection AbstractType won't know what
+ // to do with them
+ if (value instanceof List)
+ {
+ List l = (List)value;
+ List n = new ArrayList(l.size());
+ for (Object o : l)
+ n.add(serializeTuples(o));
+ return n;
+ }
+
+ if (value instanceof Set)
+ {
+ Set s = (Set)value;
+ Set n = new LinkedHashSet(s.size());
+ for (Object o : s)
+ n.add(serializeTuples(o));
+ return n;
+ }
+
+ if (value instanceof Map)
+ {
+ Map m = (Map)value;
+ Map n = new LinkedHashMap(m.size());
+ for (Object entry : m.entrySet())
+ n.put(serializeTuples(((Map.Entry)entry).getKey()), serializeTuples(((Map.Entry)entry).getValue()));
+ return n;
+ }
+ return value;
+ }
+
+ private static String formatAllValues(Object[] values)
+ {
+ StringBuilder sb = new StringBuilder();
+ sb.append("[");
+ for (int i = 0; i < values.length; i++)
+ {
+ if (i > 0)
+ sb.append(", ");
+ sb.append(formatForCQL(values[i]));
+ }
+ sb.append("]");
+ return sb.toString();
+ }
+
+ private static String formatForCQL(Object value)
+ {
+ if (value == null)
+ return "null";
+
+ if (value instanceof TupleValue)
+ return ((TupleValue)value).toCQLString();
+
+ // We need to reach inside collections for TupleValue. Besides, for some reason the format
+ // of collection that CollectionType.getString gives us is not at all 'CQL compatible'
+ if (value instanceof Collection || value instanceof Map)
+ {
+ StringBuilder sb = new StringBuilder();
+ if (value instanceof List)
+ {
+ List l = (List)value;
+ sb.append("[");
+ for (int i = 0; i < l.size(); i++)
+ {
+ if (i > 0)
+ sb.append(", ");
+ sb.append(formatForCQL(l.get(i)));
+ }
+ sb.append("]");
+ }
+ else if (value instanceof Set)
+ {
+ Set s = (Set)value;
+ sb.append("{");
+ Iterator iter = s.iterator();
+ while (iter.hasNext())
+ {
+ sb.append(formatForCQL(iter.next()));
+ if (iter.hasNext())
+ sb.append(", ");
+ }
+ sb.append("}");
+ }
+ else
+ {
+ Map m = (Map)value;
+ sb.append("{");
+ Iterator iter = m.entrySet().iterator();
+ while (iter.hasNext())
+ {
+ Map.Entry entry = (Map.Entry)iter.next();
+ sb.append(formatForCQL(entry.getKey())).append(": ").append(formatForCQL(entry.getValue()));
+ if (iter.hasNext())
+ sb.append(", ");
+ }
+ sb.append("}");
+ }
+ return sb.toString();
+ }
+
+ AbstractType type = typeFor(value);
+ String s = type.getString(type.decompose(value));
+
+ if (type instanceof UTF8Type)
+ return String.format("'%s'", s.replaceAll("'", "''"));
+
+ if (type instanceof BytesType)
+ return "0x" + s;
+
+ return s;
+ }
+
+ private static ByteBuffer makeByteBuffer(Object value, AbstractType type)
+ {
+ if (value == null)
+ return null;
+
+ if (value instanceof TupleValue)
+ return ((TupleValue)value).toByteBuffer();
+
+ if (value instanceof ByteBuffer)
+ return (ByteBuffer)value;
+
+ return type.decompose(value);
+ }
+
+ private static String formatValue(ByteBuffer bb, AbstractType<?> type)
+ {
+ if (bb == null)
+ return "null";
+
+ if (type instanceof CollectionType)
+ {
+ // CollectionType override getString() to use hexToBytes. We can't change that
+ // without breaking SSTable2json, but the serializer for collection have the
+ // right getString so using it directly instead.
+ TypeSerializer ser = type.getSerializer();
+ return ser.toString(ser.deserialize(bb));
+ }
+
+ return type.getString(bb);
+ }
+
+ protected Object tuple(Object...values)
+ {
+ return new TupleValue(values);
+ }
+
+ protected Object list(Object...values)
+ {
+ return Arrays.asList(values);
+ }
+
+ protected Object set(Object...values)
+ {
+ return ImmutableSet.copyOf(values);
+ }
+
+ protected Object map(Object...values)
+ {
+ if (values.length % 2 != 0)
+ throw new IllegalArgumentException();
+
+ int size = values.length / 2;
+ Map m = new LinkedHashMap(size);
+ for (int i = 0; i < size; i++)
+ m.put(values[2 * i], values[(2 * i) + 1]);
+ return m;
+ }
+
+ // Attempt to find an AbstracType from a value (for serialization/printing sake).
+ // Will work as long as we use types we know of, which is good enough for testing
+ private static AbstractType typeFor(Object value)
+ {
+ if (value instanceof ByteBuffer || value instanceof TupleValue || value == null)
+ return BytesType.instance;
+
+ if (value instanceof Integer)
+ return Int32Type.instance;
+
+ if (value instanceof Long)
+ return LongType.instance;
+
+ if (value instanceof Float)
+ return FloatType.instance;
+
+ if (value instanceof Double)
+ return DoubleType.instance;
+
+ if (value instanceof String)
+ return UTF8Type.instance;
+
+ if (value instanceof Boolean)
+ return BooleanType.instance;
+
+ if (value instanceof List)
+ {
+ List l = (List)value;
+ AbstractType elt = l.isEmpty() ? BytesType.instance : typeFor(l.get(0));
+ return ListType.getInstance(elt);
+ }
+
+ if (value instanceof Set)
+ {
+ Set s = (Set)value;
+ AbstractType elt = s.isEmpty() ? BytesType.instance : typeFor(s.iterator().next());
+ return SetType.getInstance(elt);
+ }
+
+ if (value instanceof Map)
+ {
+ Map m = (Map)value;
+ AbstractType keys, values;
+ if (m.isEmpty())
+ {
+ keys = BytesType.instance;
+ values = BytesType.instance;
+ }
+ else
+ {
+ Map.Entry entry = (Map.Entry)m.entrySet().iterator().next();
+ keys = typeFor(entry.getKey());
+ values = typeFor(entry.getValue());
+ }
+ return MapType.getInstance(keys, values);
+ }
+
+ throw new IllegalArgumentException("Unsupported value type (value is " + value + ")");
+ }
+
+ private static class TupleValue
+ {
+ private final Object[] values;
+
+ TupleValue(Object[] values)
+ {
+ this.values = values;
+ }
+
+ public ByteBuffer toByteBuffer()
+ {
+ ByteBuffer[] bbs = new ByteBuffer[values.length];
+ for (int i = 0; i < values.length; i++)
+ bbs[i] = makeByteBuffer(values[i], typeFor(values[i]));
+ return TupleType.buildValue(bbs);
+ }
+
+ public String toCQLString()
+ {
+ StringBuilder sb = new StringBuilder();
+ sb.append("(");
+ for (int i = 0; i < values.length; i++)
+ {
+ if (i > 0)
+ sb.append(", ");
+ sb.append(formatForCQL(values[i]));
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/cassandra/blob/814e55af/test/unit/org/apache/cassandra/cql3/CollectionsTest.java
----------------------------------------------------------------------
diff --cc test/unit/org/apache/cassandra/cql3/CollectionsTest.java
index 01e05f2,0000000..2380c38
mode 100644,000000..100644
--- a/test/unit/org/apache/cassandra/cql3/CollectionsTest.java
+++ b/test/unit/org/apache/cassandra/cql3/CollectionsTest.java
@@@ -1,227 -1,0 +1,216 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.cassandra.cql3;
+
+import org.junit.Test;
+
+public class CollectionsTest extends CQLTester
+{
- @Test
- public void testMapBulkRemoval() throws Throwable
- {
- createTable("CREATE TABLE %s (k int PRIMARY KEY, m map<text, text>)");
++ //@Test
++ //public void testMapBulkRemoval() throws Throwable
++ //{
++ // createTable("CREATE TABLE %s (k int PRIMARY KEY, m map<text, text>)");
+
- execute("INSERT INTO %s(k, m) VALUES (?, ?)", 0, map("k1", "v1", "k2", "v2", "k3", "v3"));
++ // execute("INSERT INTO %s(k, m) VALUES (?, ?)", 0, map("k1", "v1", "k2", "v2", "k3", "v3"));
+
- assertRows(execute("SELECT * FROM %s"),
- row(0, map("k1", "v1", "k2", "v2", "k3", "v3"))
- );
++ // assertRows(execute("SELECT * FROM %s"),
++ // row(0, map("k1", "v1", "k2", "v2", "k3", "v3"))
++ // );
+
- execute("UPDATE %s SET m = m - ? WHERE k = ?", set("k2"), 0);
++ // execute("UPDATE %s SET m = m - ? WHERE k = ?", set("k2"), 0);
+
- assertRows(execute("SELECT * FROM %s"),
- row(0, map("k1", "v1", "k3", "v3"))
- );
++ // assertRows(execute("SELECT * FROM %s"),
++ // row(0, map("k1", "v1", "k3", "v3"))
++ // );
+
- execute("UPDATE %s SET m = m + ?, m = m - ? WHERE k = ?", map("k4", "v4"), set("k3"), 0);
++ // execute("UPDATE %s SET m = m + ?, m = m - ? WHERE k = ?", map("k4", "v4"), set("k3"), 0);
+
- assertRows(execute("SELECT * FROM %s"),
- row(0, map("k1", "v1", "k4", "v4"))
- );
- }
++ // assertRows(execute("SELECT * FROM %s"),
++ // row(0, map("k1", "v1", "k4", "v4"))
++ // );
++ //}
+
+ @Test
+ public void testInvalidCollectionsMix() throws Throwable
+ {
+ createTable("CREATE TABLE %s (k int PRIMARY KEY, l list<text>, s set<text>, m map<text, text>)");
+
+ // Note: we force the non-prepared form for some of those tests because a list and a set
+ // have the same serialized format in practice and CQLTester don't validate that the type
+ // of what's passed as a value in the prepared case, so the queries would work (which is ok,
+ // CQLTester is just a "dumb" client).
+
+ assertInvalid("UPDATE %s SET l = l + { 'a', 'b' } WHERE k = 0");
+ assertInvalid("UPDATE %s SET l = l - { 'a', 'b' } WHERE k = 0");
- // TODO: We should remove this 'if' once #7833 is resolved
- if (!usePrepared())
- {
- assertInvalid("UPDATE %s SET l = l + ? WHERE k = 0", map("a", "b", "c", "d"));
- assertInvalid("UPDATE %s SET l = l - ? WHERE k = 0", map("a", "b", "c", "d"));
- }
++ assertInvalid("UPDATE %s SET l = l + ? WHERE k = 0", map("a", "b", "c", "d"));
++ assertInvalid("UPDATE %s SET l = l - ? WHERE k = 0", map("a", "b", "c", "d"));
+
+ assertInvalid("UPDATE %s SET s = s + [ 'a', 'b' ] WHERE k = 0");
+ assertInvalid("UPDATE %s SET s = s - [ 'a', 'b' ] WHERE k = 0");
- // TODO: We should remove this 'if' once #7833 is resolved
- if (!usePrepared())
- {
- assertInvalid("UPDATE %s SET s = s + ? WHERE k = 0", map("a", "b", "c", "d"));
- assertInvalid("UPDATE %s SET s = s - ? WHERE k = 0", map("a", "b", "c", "d"));
- }
++ assertInvalid("UPDATE %s SET s = s + ? WHERE k = 0", map("a", "b", "c", "d"));
++ assertInvalid("UPDATE %s SET s = s - ? WHERE k = 0", map("a", "b", "c", "d"));
+
+ assertInvalid("UPDATE %s SET m = m + ? WHERE k = 0", list("a", "b"));
+ assertInvalid("UPDATE %s SET m = m - [ 'a', 'b' ] WHERE k = 0");
+ assertInvalid("UPDATE %s SET m = m + ? WHERE k = 0", set("a", "b"));
- // Note that we do allow subtracting a set from a map, but not a map from a map
- // TODO: We should remove this 'if' once #7833 is resolved
- if (!usePrepared())
- assertInvalid("UPDATE %s SET m = m - ? WHERE k = 0", map("a", "b", "c", "d"));
++ assertInvalid("UPDATE %s SET m = m - ? WHERE k = 0", map("a", "b", "c", "d"));
+ }
+
- @Test
- public void testSets() throws Throwable
- {
- createTable("CREATE TABLE %s (k int PRIMARY KEY, s set<text>)");
++ //@Test
++ //public void testSets() throws Throwable
++ //{
++ // createTable("CREATE TABLE %s (k int PRIMARY KEY, s set<text>)");
+
- execute("INSERT INTO %s(k, s) VALUES (0, ?)", set("v1", "v2", "v3", "v4"));
++ // execute("INSERT INTO %s(k, s) VALUES (0, ?)", set("v1", "v2", "v3", "v4"));
+
- assertRows(execute("SELECT s FROM %s WHERE k = 0"),
- row(set("v1", "v2", "v3", "v4"))
- );
++ // assertRows(execute("SELECT s FROM %s WHERE k = 0"),
++ // row(set("v1", "v2", "v3", "v4"))
++ // );
+
- execute("DELETE s[?] FROM %s WHERE k = 0", "v1");
++ // execute("DELETE s[?] FROM %s WHERE k = 0", "v1");
+
- assertRows(execute("SELECT s FROM %s WHERE k = 0"),
- row(set("v2", "v3", "v4"))
- );
++ // assertRows(execute("SELECT s FROM %s WHERE k = 0"),
++ // row(set("v2", "v3", "v4"))
++ // );
+
- // Full overwrite
- execute("UPDATE %s SET s = ? WHERE k = 0", set("v6", "v5"));
++ // // Full overwrite
++ // execute("UPDATE %s SET s = ? WHERE k = 0", set("v6", "v5"));
+
- assertRows(execute("SELECT s FROM %s WHERE k = 0"),
- row(set("v5", "v6"))
- );
++ // assertRows(execute("SELECT s FROM %s WHERE k = 0"),
++ // row(set("v5", "v6"))
++ // );
+
- execute("UPDATE %s SET s = s + ? WHERE k = 0", set("v7"));
++ // execute("UPDATE %s SET s = s + ? WHERE k = 0", set("v7"));
+
- assertRows(execute("SELECT s FROM %s WHERE k = 0"),
- row(set("v5", "v6", "v7"))
- );
++ // assertRows(execute("SELECT s FROM %s WHERE k = 0"),
++ // row(set("v5", "v6", "v7"))
++ // );
+
- execute("UPDATE %s SET s = s - ? WHERE k = 0", set("v6", "v5"));
++ // execute("UPDATE %s SET s = s - ? WHERE k = 0", set("v6", "v5"));
+
- assertRows(execute("SELECT s FROM %s WHERE k = 0"),
- row(set("v7"))
- );
++ // assertRows(execute("SELECT s FROM %s WHERE k = 0"),
++ // row(set("v7"))
++ // );
+
- execute("DELETE s FROM %s WHERE k = 0");
++ // execute("DELETE s FROM %s WHERE k = 0");
+
- assertRows(execute("SELECT s FROM %s WHERE k = 0"),
- row((Object)null)
- );
- }
++ // assertRows(execute("SELECT s FROM %s WHERE k = 0"),
++ // row((Object)null)
++ // );
++ //}
+
- @Test
- public void testMaps() throws Throwable
- {
- createTable("CREATE TABLE %s (k int PRIMARY KEY, m map<text, int>)");
++ //@Test
++ //public void testMaps() throws Throwable
++ //{
++ // createTable("CREATE TABLE %s (k int PRIMARY KEY, m map<text, int>)");
+
- execute("INSERT INTO %s(k, m) VALUES (0, ?)", map("v1", 1, "v2", 2));
++ // execute("INSERT INTO %s(k, m) VALUES (0, ?)", map("v1", 1, "v2", 2));
+
- assertRows(execute("SELECT m FROM %s WHERE k = 0"),
- row(map("v1", 1, "v2", 2))
- );
++ // assertRows(execute("SELECT m FROM %s WHERE k = 0"),
++ // row(map("v1", 1, "v2", 2))
++ // );
+
- execute("UPDATE %s SET m[?] = ?, m[?] = ? WHERE k = 0", "v3", 3, "v4", 4);
++ // execute("UPDATE %s SET m[?] = ?, m[?] = ? WHERE k = 0", "v3", 3, "v4", 4);
+
- assertRows(execute("SELECT m FROM %s WHERE k = 0"),
- row(map("v1", 1, "v2", 2, "v3", 3, "v4", 4))
- );
++ // assertRows(execute("SELECT m FROM %s WHERE k = 0"),
++ // row(map("v1", 1, "v2", 2, "v3", 3, "v4", 4))
++ // );
+
- execute("DELETE m[?] FROM %s WHERE k = 0", "v1");
++ // execute("DELETE m[?] FROM %s WHERE k = 0", "v1");
+
- assertRows(execute("SELECT m FROM %s WHERE k = 0"),
- row(map("v2", 2, "v3", 3, "v4", 4))
- );
++ // assertRows(execute("SELECT m FROM %s WHERE k = 0"),
++ // row(map("v2", 2, "v3", 3, "v4", 4))
++ // );
+
- // Full overwrite
- execute("UPDATE %s SET m = ? WHERE k = 0", map("v6", 6, "v5", 5));
++ // // Full overwrite
++ // execute("UPDATE %s SET m = ? WHERE k = 0", map("v6", 6, "v5", 5));
+
- assertRows(execute("SELECT m FROM %s WHERE k = 0"),
- row(map("v5", 5, "v6", 6))
- );
++ // assertRows(execute("SELECT m FROM %s WHERE k = 0"),
++ // row(map("v5", 5, "v6", 6))
++ // );
+
- execute("UPDATE %s SET m = m + ? WHERE k = 0", map("v7", 7));
++ // execute("UPDATE %s SET m = m + ? WHERE k = 0", map("v7", 7));
+
- assertRows(execute("SELECT m FROM %s WHERE k = 0"),
- row(map("v5", 5, "v6", 6, "v7", 7))
- );
++ // assertRows(execute("SELECT m FROM %s WHERE k = 0"),
++ // row(map("v5", 5, "v6", 6, "v7", 7))
++ // );
+
- // The empty map is parsed as an empty set (because we don't have enough info at parsing
- // time when we see a {}) and special cased later. This test checks this work properly
- execute("UPDATE %s SET m = {} WHERE k = 0");
++ // // The empty map is parsed as an empty set (because we don't have enough info at parsing
++ // // time when we see a {}) and special cased later. This test checks this work properly
++ // execute("UPDATE %s SET m = {} WHERE k = 0");
+
- assertRows(execute("SELECT m FROM %s WHERE k = 0"),
- row((Object)null)
- );
- }
++ // assertRows(execute("SELECT m FROM %s WHERE k = 0"),
++ // row((Object)null)
++ // );
++ //}
+
- @Test
- public void testLists() throws Throwable
- {
- createTable("CREATE TABLE %s (k int PRIMARY KEY, l list<text>)");
++ //@Test
++ //public void testLists() throws Throwable
++ //{
++ // createTable("CREATE TABLE %s (k int PRIMARY KEY, l list<text>)");
+
- execute("INSERT INTO %s(k, l) VALUES (0, ?)", list("v1", "v2", "v3"));
++ // execute("INSERT INTO %s(k, l) VALUES (0, ?)", list("v1", "v2", "v3"));
+
- assertRows(execute("SELECT l FROM %s WHERE k = 0"),
- row(list("v1", "v2", "v3"))
- );
++ // assertRows(execute("SELECT l FROM %s WHERE k = 0"),
++ // row(list("v1", "v2", "v3"))
++ // );
+
- execute("DELETE l[?] FROM %s WHERE k = 0", 1);
++ // execute("DELETE l[?] FROM %s WHERE k = 0", 1);
+
- assertRows(execute("SELECT l FROM %s WHERE k = 0"),
- row(list("v1", "v3"))
- );
++ // assertRows(execute("SELECT l FROM %s WHERE k = 0"),
++ // row(list("v1", "v3"))
++ // );
+
- execute("UPDATE %s SET l[?] = ? WHERE k = 0", 1, "v4");
++ // execute("UPDATE %s SET l[?] = ? WHERE k = 0", 1, "v4");
+
- assertRows(execute("SELECT l FROM %s WHERE k = 0"),
- row(list("v1", "v4"))
- );
++ // assertRows(execute("SELECT l FROM %s WHERE k = 0"),
++ // row(list("v1", "v4"))
++ // );
+
- // Full overwrite
- execute("UPDATE %s SET l = ? WHERE k = 0", list("v6", "v5"));
++ // // Full overwrite
++ // execute("UPDATE %s SET l = ? WHERE k = 0", list("v6", "v5"));
+
- assertRows(execute("SELECT l FROM %s WHERE k = 0"),
- row(list("v6", "v5"))
- );
++ // assertRows(execute("SELECT l FROM %s WHERE k = 0"),
++ // row(list("v6", "v5"))
++ // );
+
- execute("UPDATE %s SET l = l + ? WHERE k = 0", list("v7", "v8"));
++ // execute("UPDATE %s SET l = l + ? WHERE k = 0", list("v7", "v8"));
+
- assertRows(execute("SELECT l FROM %s WHERE k = 0"),
- row(list("v6", "v5", "v7", "v8"))
- );
++ // assertRows(execute("SELECT l FROM %s WHERE k = 0"),
++ // row(list("v6", "v5", "v7", "v8"))
++ // );
+
- execute("UPDATE %s SET l = ? + l WHERE k = 0", list("v9"));
++ // execute("UPDATE %s SET l = ? + l WHERE k = 0", list("v9"));
+
- assertRows(execute("SELECT l FROM %s WHERE k = 0"),
- row(list("v9", "v6", "v5", "v7", "v8"))
- );
++ // assertRows(execute("SELECT l FROM %s WHERE k = 0"),
++ // row(list("v9", "v6", "v5", "v7", "v8"))
++ // );
+
- execute("UPDATE %s SET l = l - ? WHERE k = 0", list("v5", "v8"));
++ // execute("UPDATE %s SET l = l - ? WHERE k = 0", list("v5", "v8"));
+
- assertRows(execute("SELECT l FROM %s WHERE k = 0"),
- row(list("v9", "v6", "v7"))
- );
++ // assertRows(execute("SELECT l FROM %s WHERE k = 0"),
++ // row(list("v9", "v6", "v7"))
++ // );
+
- execute("DELETE l FROM %s WHERE k = 0");
++ // execute("DELETE l FROM %s WHERE k = 0");
+
- assertRows(execute("SELECT l FROM %s WHERE k = 0"),
- row((Object)null)
- );
- }
++ // assertRows(execute("SELECT l FROM %s WHERE k = 0"),
++ // row((Object)null)
++ // );
++ //}
+}