cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ble...@apache.org
Subject [6/8] cassandra git commit: Merge branch cassandra-3.0 into cassandra-3.11
Date Thu, 24 Aug 2017 16:24:36 GMT
Merge branch cassandra-3.0 into cassandra-3.11


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

Branch: refs/heads/trunk
Commit: 8d98a99231f38102d0ef572ffe948d705169aae4
Parents: 000007f cf0b6d1
Author: Benjamin Lerer <b.lerer@gmail.com>
Authored: Thu Aug 24 18:21:08 2017 +0200
Committer: Benjamin Lerer <b.lerer@gmail.com>
Committed: Thu Aug 24 18:22:13 2017 +0200

----------------------------------------------------------------------
 CHANGES.txt                                     |   1 +
 .../cassandra/db/SerializationHeader.java       |  13 +-
 .../db/rows/AbstractTypeVersionComparator.java  | 121 ++++++++++++
 src/java/org/apache/cassandra/db/rows/Row.java  |  18 +-
 src/java/org/apache/cassandra/db/rows/Rows.java |  22 ++-
 .../io/sstable/format/SSTableReader.java        |  20 +-
 .../org/apache/cassandra/cql3/CQLTester.java    |  20 +-
 .../cql3/validation/entities/UserTypesTest.java | 151 +++++++++++++++
 .../rows/AbstractTypeVersionComparatorTest.java | 188 +++++++++++++++++++
 9 files changed, 533 insertions(+), 21 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cassandra/blob/8d98a992/CHANGES.txt
----------------------------------------------------------------------
diff --cc CHANGES.txt
index d39f78c,ba35152..8fb8e2f
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@@ -1,11 -1,5 +1,12 @@@
 -3.0.15
 +3.11.1
 + * Fix cassandra-stress hang issues when an error during cluster connection happens (CASSANDRA-12938)
 + * Better bootstrap failure message when blocked by (potential) range movement (CASSANDRA-13744)
 + * "ignore" option is ignored in sstableloader (CASSANDRA-13721)
 + * Deadlock in AbstractCommitLogSegmentManager (CASSANDRA-13652)
 + * Duplicate the buffer before passing it to analyser in SASI operation (CASSANDRA-13512)
 + * Properly evict pstmts from prepared statements cache (CASSANDRA-13641)
 +Merged from 3.0:
+  * Fix the merging of cells with different user type versions (CASSANDRA-13776)
   * Copy session properties on cqlsh.py do_login (CASSANDRA-13640)
   * Potential AssertionError during ReadRepair of range tombstone and partition deletions
(CASSANDRA-13719)
   * Don't let stress write warmup data if n=0 (CASSANDRA-13773)

http://git-wip-us.apache.org/repos/asf/cassandra/blob/8d98a992/src/java/org/apache/cassandra/db/SerializationHeader.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/cassandra/blob/8d98a992/src/java/org/apache/cassandra/db/rows/Row.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/cassandra/blob/8d98a992/src/java/org/apache/cassandra/db/rows/Rows.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/db/rows/Rows.java
index a92bdac,09213a4..3331506
--- a/src/java/org/apache/cassandra/db/rows/Rows.java
+++ b/src/java/org/apache/cassandra/db/rows/Rows.java
@@@ -26,9 -25,7 +26,8 @@@ import org.apache.cassandra.config.CFMe
  import org.apache.cassandra.config.ColumnDefinition;
  import org.apache.cassandra.db.*;
  import org.apache.cassandra.db.partitions.PartitionStatisticsCollector;
- import org.apache.cassandra.db.rows.Row.Deletion;
  import org.apache.cassandra.utils.MergeIterator;
 +import org.apache.cassandra.utils.WrappedInt;
  
  /**
   * Static utilities to work on Row objects.
@@@ -330,78 -312,20 +330,96 @@@ public abstract class Row
      }
  
      /**
 +     * Returns a row that is obtained from the given existing row by removing everything
that is shadowed by data in
 +     * the update row. In other words, produces the smallest result row such that
 +     * {@code merge(result, update, nowInSec) == merge(existing, update, nowInSec)} after
filtering by rangeDeletion.
 +     *
 +     * @param existing source row
 +     * @param update shadowing row
 +     * @param rangeDeletion extra {@code DeletionTime} from covering tombstone
 +     * @param nowInSec the current time in seconds (which plays a role during reconciliation
 +     * because deleted cells always have precedence on timestamp equality and deciding if
a
 +     * cell is a live or not depends on the current time due to expiring cells).
 +     */
 +    public static Row removeShadowedCells(Row existing, Row update, DeletionTime rangeDeletion,
int nowInSec)
 +    {
 +        Row.Builder builder = BTreeRow.sortedBuilder();
 +        Clustering clustering = existing.clustering();
 +        builder.newRow(clustering);
 +
 +        DeletionTime deletion = update.deletion().time();
 +        if (rangeDeletion.supersedes(deletion))
 +            deletion = rangeDeletion;
 +
 +        LivenessInfo existingInfo = existing.primaryKeyLivenessInfo();
 +        if (!deletion.deletes(existingInfo))
 +            builder.addPrimaryKeyLivenessInfo(existingInfo);
 +        Row.Deletion rowDeletion = existing.deletion();
 +        if (!deletion.supersedes(rowDeletion.time()))
 +            builder.addRowDeletion(rowDeletion);
 +
 +        Iterator<ColumnData> a = existing.iterator();
 +        Iterator<ColumnData> b = update.iterator();
 +        ColumnData nexta = a.hasNext() ? a.next() : null, nextb = b.hasNext() ? b.next()
: null;
 +        while (nexta != null)
 +        {
 +            int comparison = nextb == null ? -1 : nexta.column.compareTo(nextb.column);
 +            if (comparison <= 0)
 +            {
 +                ColumnData cura = nexta;
 +                ColumnDefinition column = cura.column;
 +                ColumnData curb = comparison == 0 ? nextb : null;
 +                if (column.isSimple())
 +                {
 +                    Cells.addNonShadowed((Cell) cura, (Cell) curb, deletion, builder, nowInSec);
 +                }
 +                else
 +                {
 +                    ComplexColumnData existingData = (ComplexColumnData) cura;
 +                    ComplexColumnData updateData = (ComplexColumnData) curb;
 +
 +                    DeletionTime existingDt = existingData.complexDeletion();
 +                    DeletionTime updateDt = updateData == null ? DeletionTime.LIVE : updateData.complexDeletion();
 +
 +                    DeletionTime maxDt = updateDt.supersedes(deletion) ? updateDt : deletion;
 +                    if (existingDt.supersedes(maxDt))
 +                    {
 +                        builder.addComplexDeletion(column, existingDt);
 +                        maxDt = existingDt;
 +                    }
 +
 +                    Iterator<Cell> existingCells = existingData.iterator();
 +                    Iterator<Cell> updateCells = updateData == null ? null : updateData.iterator();
 +                    Cells.addNonShadowedComplex(column, existingCells, updateCells, maxDt,
builder, nowInSec);
 +                }
 +                nexta = a.hasNext() ? a.next() : null;
 +                if (curb != null)
 +                    nextb = b.hasNext() ? b.next() : null;
 +            }
 +            else
 +            {
 +                nextb = b.hasNext() ? b.next() : null;
 +            }
 +        }
 +        Row row = builder.build();
 +        return row != null && !row.isEmpty() ? row : null;
 +    }
++
++    /**
+      * Returns the {@code ColumnDefinition} to use for merging the columns.
+      * If the 2 column definitions are different the latest one will be returned.
+      */
+     private static ColumnDefinition getColumnDefinition(ColumnData cura, ColumnData curb)
+     {
+         if (cura == null)
+             return curb.column;
+ 
+         if (curb == null)
+             return cura.column;
+ 
+         if (AbstractTypeVersionComparator.INSTANCE.compare(cura.column.type, curb.column.type)
>= 0)
+             return cura.column;
+ 
+         return curb.column;
+     }
  }

http://git-wip-us.apache.org/repos/asf/cassandra/blob/8d98a992/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/cassandra/blob/8d98a992/test/unit/org/apache/cassandra/cql3/CQLTester.java
----------------------------------------------------------------------
diff --cc test/unit/org/apache/cassandra/cql3/CQLTester.java
index 2542db0,40aec88..c0513ce
--- a/test/unit/org/apache/cassandra/cql3/CQLTester.java
+++ b/test/unit/org/apache/cassandra/cql3/CQLTester.java
@@@ -425,9 -396,34 +425,10 @@@ public abstract class CQLTeste
      public void disableCompaction(String keyspace)
      {
          ColumnFamilyStore store = getCurrentColumnFamilyStore(keyspace);
-         store.disableAutoCompaction();
+         if (store != null)
+             store.disableAutoCompaction();
      }
  
 -    public void flush(boolean forceFlush)
 -    {
 -        if (forceFlush)
 -            flush();
 -    }
 -
 -    @FunctionalInterface
 -    public interface CheckedFunction {
 -        void apply() throws Throwable;
 -    }
 -
 -    /**
 -     * Runs the given function before and after a flush of sstables.  This is useful for
checking that behavior is
 -     * the same whether data is in memtables or sstables.
 -     * @param runnable
 -     * @throws Throwable
 -     */
 -    public void beforeAndAfterFlush(CheckedFunction runnable) throws Throwable
 -    {
 -        runnable.apply();
 -        flush();
 -        runnable.apply();
 -    }
 -
      public void compact()
      {
          try

http://git-wip-us.apache.org/repos/asf/cassandra/blob/8d98a992/test/unit/org/apache/cassandra/cql3/validation/entities/UserTypesTest.java
----------------------------------------------------------------------
diff --cc test/unit/org/apache/cassandra/cql3/validation/entities/UserTypesTest.java
index b78eb3e,dfc2e5e..9ea5572
--- a/test/unit/org/apache/cassandra/cql3/validation/entities/UserTypesTest.java
+++ b/test/unit/org/apache/cassandra/cql3/validation/entities/UserTypesTest.java
@@@ -624,109 -563,156 +624,260 @@@ public class UserTypesTest extends CQLT
      }
  
      @Test
 +    public void testInsertNonFrozenUDT() throws Throwable
 +    {
 +        String typeName = createType("CREATE TYPE %s (a int, b text)");
 +        createTable("CREATE TABLE %s (k int PRIMARY KEY, v " + typeName + ")");
 +
 +        execute("INSERT INTO %s (k, v) VALUES (?, {a: ?, b: ?})", 0, 0, "abc");
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
"abc")));
 +
 +        execute("INSERT INTO %s (k, v) VALUES (?, ?)", 0, userType("a", 0, "b", "abc"));
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
"abc")));
 +
 +        execute("INSERT INTO %s (k, v) VALUES (?, {a: ?, b: ?})", 0, 0, null);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
null)));
 +
 +        execute("INSERT INTO %s (k, v) VALUES (?, ?)", 0, userType("a", null, "b", "abc"));
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", null,
"b", "abc")));
 +    }
 +
 +    @Test
 +    public void testUpdateNonFrozenUDT() throws Throwable
 +    {
 +        String typeName = createType("CREATE TYPE %s (a int, b text)");
 +        createTable("CREATE TABLE %s (k int PRIMARY KEY, v " + typeName + ")");
 +
 +        execute("INSERT INTO %s (k, v) VALUES (?, ?)", 0, userType("a", 0, "b", "abc"));
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
"abc")));
 +
 +        // overwrite the whole UDT
 +        execute("UPDATE %s SET v = ? WHERE k = ?", userType("a", 1, "b", "def"), 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 1, "b",
"def")));
 +
 +        execute("UPDATE %s SET v = ? WHERE k = ?", userType("a", 0, "b", null), 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
null)));
 +
 +        execute("UPDATE %s SET v = ? WHERE k = ?", userType("a", null, "b", "abc"), 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", null,
"b", "abc")));
 +
 +        // individually set fields to non-null values
 +        execute("UPDATE %s SET v.a = ? WHERE k = ?", 1, 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 1, "b",
"abc")));
 +
 +        execute("UPDATE %s SET v.b = ? WHERE k = ?", "def", 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 1, "b",
"def")));
 +
 +        execute("UPDATE %s SET v.a = ?, v.b = ? WHERE k = ?", 0, "abc", 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
"abc")));
 +
 +        execute("UPDATE %s SET v.b = ?, v.a = ? WHERE k = ?", "abc", 0, 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
"abc")));
 +
 +        // individually set fields to null values
 +        execute("UPDATE %s SET v.a = ? WHERE k = ?", null, 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", null,
"b", "abc")));
 +
 +        execute("UPDATE %s SET v.a = ? WHERE k = ?", 0, 0);
 +        execute("UPDATE %s SET v.b = ? WHERE k = ?", null, 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
null)));
 +
 +        execute("UPDATE %s SET v.a = ? WHERE k = ?", null, 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, null));
 +
 +        assertInvalid("UPDATE %s SET v.bad = ? FROM %s WHERE k = ?", 0, 0);
 +        assertInvalid("UPDATE %s SET v = ? FROM %s WHERE k = ?", 0, 0);
 +        assertInvalid("UPDATE %s SET v = ? FROM %s WHERE k = ?", userType("a", 1, "b", "abc",
"bad", 123), 0);
 +    }
 +
 +    @Test
 +    public void testDeleteNonFrozenUDT() throws Throwable
 +    {
 +        String typeName = createType("CREATE TYPE %s (a int, b text)");
 +        createTable("CREATE TABLE %s (k int PRIMARY KEY, v " + typeName + ")");
 +
 +        execute("INSERT INTO %s (k, v) VALUES (?, ?)", 0, userType("a", 0, "b", "abc"));
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
"abc")));
 +
 +        execute("DELETE v.b FROM %s WHERE k = ?", 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", 0, "b",
null)));
 +
 +        execute("INSERT INTO %s (k, v) VALUES (?, ?)", 0, userType("a", 0, "b", "abc"));
 +        execute("DELETE v.a FROM %s WHERE k = ?", 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, userType("a", null,
"b", "abc")));
 +
 +        execute("DELETE v.b FROM %s WHERE k = ?", 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, null));
 +
 +        // delete both fields at once
 +        execute("INSERT INTO %s (k, v) VALUES (?, ?)", 0, userType("a", 0, "b", "abc"));
 +        execute("DELETE v.a, v.b FROM %s WHERE k = ?", 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, null));
 +
 +        // same, but reverse field order
 +        execute("INSERT INTO %s (k, v) VALUES (?, ?)", 0, userType("a", 0, "b", "abc"));
 +        execute("DELETE v.b, v.a FROM %s WHERE k = ?", 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, null));
 +
 +        // delete the whole thing at once
 +        execute("INSERT INTO %s (k, v) VALUES (?, ?)", 0, userType("a", 0, "b", "abc"));
 +        execute("DELETE v FROM %s WHERE k = ?", 0);
 +        assertRows(execute("SELECT * FROM %s WHERE k = ?", 0), row(0, null));
 +
 +        assertInvalid("DELETE v.bad FROM %s WHERE k = ?", 0);
 +    }
 +
++    @Test
+     public void testReadAfterAlteringUserTypeNestedWithinSet() throws Throwable
+     {
+         String columnType = typeWithKs(createType("CREATE TYPE %s (a int)"));
+ 
+         try
+         {
+             createTable("CREATE TABLE %s (x int PRIMARY KEY, y set<frozen<" + columnType
+ ">>)");
+             disableCompaction();
+ 
 -            execute("INSERT INTO %s (x, y) VALUES(1, ?)", set(userType(1), userType(2)));
 -            assertRows(execute("SELECT * FROM %s"), row(1, set(userType(1), userType(2))));
++            execute("INSERT INTO %s (x, y) VALUES(1, ?)", set(userType("a", 1), userType("a",
2)));
++            assertRows(execute("SELECT * FROM %s"), row(1, set(userType("a", 1), userType("a",
2))));
+             flush();
+ 
+             assertRows(execute("SELECT * FROM %s WHERE x = 1"),
 -                       row(1, set(userType(1), userType(2))));
++                       row(1, set(userType("a", 1), userType("a", 2))));
+ 
+             execute("ALTER TYPE " + columnType + " ADD b int");
+             execute("UPDATE %s SET y = y + ? WHERE x = 1",
 -                    set(userType(1, 1), userType(1, 2), userType(2, 1)));
++                    set(userType("a", 1, "b", 1), userType("a", 1, "b", 2), userType("a",
2, "b", 1)));
+ 
+             flush();
+             assertRows(execute("SELECT * FROM %s WHERE x = 1"),
 -                           row(1, set(userType(1),
 -                                      userType(1, 1),
 -                                      userType(1, 2),
 -                                      userType(2),
 -                                      userType(2, 1))));
++                           row(1, set(userType("a", 1),
++                                      userType("a", 1, "b", 1),
++                                      userType("a", 1, "b", 2),
++                                      userType("a", 2),
++                                      userType("a", 2, "b", 1))));
+ 
+             compact();
+ 
+             assertRows(execute("SELECT * FROM %s WHERE x = 1"),
 -                       row(1, set(userType(1),
 -                                  userType(1, 1),
 -                                  userType(1, 2),
 -                                  userType(2),
 -                                  userType(2, 1))));
++                       row(1, set(userType("a", 1),
++                                  userType("a", 1, "b", 1),
++                                  userType("a", 1, "b", 2),
++                                  userType("a", 2),
++                                  userType("a", 2, "b", 1))));
+         }
+         finally
+         {
+             enableCompaction();
+         }
+     }
+ 
+     @Test
+     public void testReadAfterAlteringUserTypeNestedWithinMap() throws Throwable
+     {
+         String columnType = typeWithKs(createType("CREATE TYPE %s (a int)"));
+ 
+         try
+         {
+             createTable("CREATE TABLE %s (x int PRIMARY KEY, y map<frozen<" + columnType
+ ">, int>)");
+             disableCompaction();
+ 
 -            execute("INSERT INTO %s (x, y) VALUES(1, ?)", map(userType(1), 1, userType(2),
2));
 -            assertRows(execute("SELECT * FROM %s"), row(1, map(userType(1), 1, userType(2),
2)));
++            execute("INSERT INTO %s (x, y) VALUES(1, ?)", map(userType("a", 1), 1, userType("a",
2), 2));
++            assertRows(execute("SELECT * FROM %s"), row(1, map(userType("a", 1), 1, userType("a",
2), 2)));
+             flush();
+ 
+             assertRows(execute("SELECT * FROM %s WHERE x = 1"),
 -                       row(1, map(userType(1), 1, userType(2), 2)));
++                       row(1, map(userType("a", 1), 1, userType("a", 2), 2)));
+ 
+             execute("ALTER TYPE " + columnType + " ADD b int");
+             execute("UPDATE %s SET y = y + ? WHERE x = 1",
 -                    map(userType(1, 1), 1, userType(1, 2), 1, userType(2, 1), 2));
++                    map(userType("a", 1, "b", 1), 1, userType("a", 1, "b", 2), 1, userType("a",
2, "b", 1), 2));
+ 
+             flush();
+             assertRows(execute("SELECT * FROM %s WHERE x = 1"),
 -                           row(1, map(userType(1), 1,
 -                                      userType(1, 1), 1,
 -                                      userType(1, 2), 1,
 -                                      userType(2), 2,
 -                                      userType(2, 1), 2)));
++                           row(1, map(userType("a", 1), 1,
++                                      userType("a", 1, "b", 1), 1,
++                                      userType("a", 1, "b", 2), 1,
++                                      userType("a", 2), 2,
++                                      userType("a", 2, "b", 1), 2)));
+ 
+             compact();
+ 
+             assertRows(execute("SELECT * FROM %s WHERE x = 1"),
 -                       row(1, map(userType(1), 1,
 -                                  userType(1, 1), 1,
 -                                  userType(1, 2), 1,
 -                                  userType(2), 2,
 -                                  userType(2, 1), 2)));
++                       row(1, map(userType("a", 1), 1,
++                                  userType("a", 1, "b", 1), 1,
++                                  userType("a", 1, "b", 2), 1,
++                                  userType("a", 2), 2,
++                                  userType("a", 2, "b", 1), 2)));
+         }
+         finally
+         {
+             enableCompaction();
+         }
+     }
+ 
+     @Test
+     public void testReadAfterAlteringUserTypeNestedWithinList() throws Throwable
+     {
+         String columnType = typeWithKs(createType("CREATE TYPE %s (a int)"));
+ 
+         try
+         {
+             createTable("CREATE TABLE %s (x int PRIMARY KEY, y list<frozen<" + columnType
+ ">>)");
+             disableCompaction();
+ 
 -            execute("INSERT INTO %s (x, y) VALUES(1, ?)", list(userType(1), userType(2)));
 -            assertRows(execute("SELECT * FROM %s"), row(1, list(userType(1), userType(2))));
++            execute("INSERT INTO %s (x, y) VALUES(1, ?)", list(userType("a", 1), userType("a",
2)));
++            assertRows(execute("SELECT * FROM %s"), row(1, list(userType("a", 1), userType("a",
2))));
+             flush();
+ 
+             assertRows(execute("SELECT * FROM %s WHERE x = 1"),
 -                       row(1, list(userType(1), userType(2))));
++                       row(1, list(userType("a", 1), userType("a", 2))));
+ 
+             execute("ALTER TYPE " + columnType + " ADD b int");
+             execute("UPDATE %s SET y = y + ? WHERE x = 1",
 -                    list(userType(1, 1), userType(1, 2), userType(2, 1)));
++                    list(userType("a", 1, "b", 1), userType("a", 1, "b", 2), userType("a",
2, "b", 1)));
+ 
+             flush();
+             assertRows(execute("SELECT * FROM %s WHERE x = 1"),
 -                           row(1, list(userType(1),
 -                                       userType(2),
 -                                       userType(1, 1),
 -                                       userType(1, 2),
 -                                       userType(2, 1))));
++                           row(1, list(userType("a", 1),
++                                       userType("a", 2),
++                                       userType("a", 1, "b", 1),
++                                       userType("a", 1, "b", 2),
++                                       userType("a", 2, "b", 1))));
+ 
+             compact();
+ 
+             assertRows(execute("SELECT * FROM %s WHERE x = 1"),
 -                       row(1, list(userType(1),
 -                                   userType(2),
 -                                   userType(1, 1),
 -                                   userType(1, 2),
 -                                   userType(2, 1))));
++                       row(1, list(userType("a", 1),
++                                   userType("a", 2),
++                                   userType("a", 1, "b", 1),
++                                   userType("a", 1, "b", 2),
++                                   userType("a", 2, "b", 1))));
+         }
+         finally
+         {
+             enableCompaction();
+         }
+     }
+ 
+     @Test
+     public void testAlteringUserTypeNestedWithinSetWithView() throws Throwable
+     {
+         String columnType = typeWithKs(createType("CREATE TYPE %s (a int)"));
+ 
+         createTable("CREATE TABLE %s (pk int, c int, v int, s set<frozen<" + columnType
+ ">>, PRIMARY KEY (pk, c))");
+         execute("CREATE MATERIALIZED VIEW " + keyspace() + ".view1 AS SELECT c, pk, v FROM
%s WHERE pk IS NOT NULL AND c IS NOT NULL AND v IS NOT NULL PRIMARY KEY (c, pk)");
+ 
 -        execute("INSERT INTO %s (pk, c, v, s) VALUES(?, ?, ?, ?)", 1, 1, 1, set(userType(1),
userType(2)));
++        execute("INSERT INTO %s (pk, c, v, s) VALUES(?, ?, ?, ?)", 1, 1, 1, set(userType("a",
1), userType("a", 2)));
+         flush();
+ 
+         execute("ALTER TYPE " + columnType + " ADD b int");
+         execute("UPDATE %s SET s = s + ?, v = ? WHERE pk = ? AND c = ?",
 -                set(userType(1, 1), userType(1, 2), userType(2, 1)), 2, 1, 1);
++                set(userType("a", 1, "b", 1), userType("a", 1, "b", 2), userType("a", 2,
"b", 1)), 2, 1, 1);
+ 
+         assertRows(execute("SELECT * FROM %s WHERE pk = ? AND c = ?", 1, 1),
 -                       row(1, 1,set(userType(1), userType(1, 1), userType(1, 2), userType(2),
userType(2, 1)), 2));
++                       row(1, 1,set(userType("a", 1), userType("a", 1, "b", 1), userType("a",
1, "b", 2), userType("a", 2), userType("a", 2, "b", 1)), 2));
+     }
+ 
      private String typeWithKs(String type1)
      {
          return keyspace() + '.' + type1;

http://git-wip-us.apache.org/repos/asf/cassandra/blob/8d98a992/test/unit/org/apache/cassandra/db/rows/AbstractTypeVersionComparatorTest.java
----------------------------------------------------------------------
diff --cc test/unit/org/apache/cassandra/db/rows/AbstractTypeVersionComparatorTest.java
index 0000000,ad0c05c..7170696
mode 000000,100644..100644
--- a/test/unit/org/apache/cassandra/db/rows/AbstractTypeVersionComparatorTest.java
+++ b/test/unit/org/apache/cassandra/db/rows/AbstractTypeVersionComparatorTest.java
@@@ -1,0 -1,184 +1,188 @@@
+ /*
+  * 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.db.rows;
+ 
+ import java.nio.ByteBuffer;
+ import java.util.Set;
+ 
+ import org.junit.After;
+ import org.junit.Before;
+ import org.junit.Test;
+ 
+ import org.apache.cassandra.db.marshal.*;
+ 
+ import static java.util.Arrays.asList;
++import static org.apache.cassandra.cql3.FieldIdentifier.forUnquoted;
+ import static org.apache.cassandra.utils.ByteBufferUtil.bytes;
+ import static org.junit.Assert.assertEquals;
+ import static org.junit.Assert.fail;
+ 
+ public class AbstractTypeVersionComparatorTest
+ {
+     private UserType udtWith2Fields;
+     private UserType udtWith3Fields;
+ 
+     @Before
+     public void setUp()
+     {
+         udtWith2Fields = new UserType("ks",
+                                       bytes("myType"),
 -                                      asList(bytes("a"), bytes("b")),
 -                                      asList(Int32Type.instance, Int32Type.instance));
++                                      asList(forUnquoted("a"), forUnquoted("b")),
++                                      asList(Int32Type.instance, Int32Type.instance),
++                                      false);
+         udtWith3Fields = new UserType("ks",
+                                       bytes("myType"),
 -                                      asList(bytes("a"), bytes("b"), bytes("c")),
 -                                      asList(Int32Type.instance, Int32Type.instance, Int32Type.instance));
++                                      asList(forUnquoted("a"), forUnquoted("b"), forUnquoted("c")),
++                                      asList(Int32Type.instance, Int32Type.instance, Int32Type.instance),
++                                      false);
+     }
+ 
+     @After
+     public void tearDown()
+     {
+         udtWith2Fields = null;
+         udtWith3Fields = null;
+     }
+ 
+     @Test
+     public void testWithTuples()
+     {
+         checkComparisonResults(new TupleType(asList(Int32Type.instance, Int32Type.instance)),
+                                new TupleType(asList(Int32Type.instance, Int32Type.instance,
Int32Type.instance)));
+     }
+ 
+     @Test
+     public void testWithUDTs()
+     {
+         checkComparisonResults(udtWith2Fields, udtWith3Fields);
+     }
+ 
+     @Test
+     public void testWithUDTsNestedWithinSet()
+     {
+         for (boolean isMultiCell : new boolean[]{false, true})
+         {
+             SetType<ByteBuffer> set1 = SetType.getInstance(udtWith2Fields, isMultiCell);
+             SetType<ByteBuffer> set2 = SetType.getInstance(udtWith3Fields, isMultiCell);
+             checkComparisonResults(set1, set2);
+         }
+     }
+ 
+     @Test
+     public void testWithUDTsNestedWithinList()
+     {
+         for (boolean isMultiCell : new boolean[]{false, true})
+         {
+             ListType<ByteBuffer> list1 = ListType.getInstance(udtWith2Fields, isMultiCell);
+             ListType<ByteBuffer> list2 = ListType.getInstance(udtWith3Fields, isMultiCell);
+             checkComparisonResults(list1, list2);
+         }
+     }
+ 
+     @Test
+     public void testWithUDTsNestedWithinMap()
+     {
+         for (boolean isMultiCell : new boolean[]{false, true})
+         {
+             MapType<ByteBuffer, Integer> map1 = MapType.getInstance(udtWith2Fields,
Int32Type.instance, isMultiCell);
+             MapType<ByteBuffer, Integer> map2 = MapType.getInstance(udtWith3Fields,
Int32Type.instance, isMultiCell);
+             checkComparisonResults(map1, map2);
+         }
+ 
+         for (boolean isMultiCell : new boolean[]{false, true})
+         {
+             MapType<Integer, ByteBuffer> map1 = MapType.getInstance(Int32Type.instance,
udtWith2Fields, isMultiCell);
+             MapType<Integer, ByteBuffer> map2 = MapType.getInstance(Int32Type.instance,
udtWith3Fields, isMultiCell);
+             checkComparisonResults(map1, map2);
+         }
+     }
+ 
+     @Test
+     public void testWithUDTsNestedWithinTuple()
+     {
+         TupleType tuple1 = new TupleType(asList(udtWith2Fields, Int32Type.instance));
+         TupleType tuple2 = new TupleType(asList(udtWith3Fields, Int32Type.instance));
+         checkComparisonResults(tuple1, tuple2);
+     }
+ 
+     @Test
+     public void testWithUDTsNestedWithinComposite()
+     {
+         CompositeType composite1 = CompositeType.getInstance(asList(udtWith2Fields, Int32Type.instance));
+         CompositeType composite2 = CompositeType.getInstance(asList(udtWith3Fields, Int32Type.instance));
+         checkComparisonResults(composite1, composite2);
+     }
+ 
+     @Test
+     public void testWithDeeplyNestedUDT()
+     {
+         for (boolean isMultiCell : new boolean[]{false, true})
+         {
+             ListType<Set<ByteBuffer>> list1 = ListType.getInstance(SetType.getInstance(new
TupleType(asList(udtWith2Fields, Int32Type.instance)), isMultiCell), isMultiCell);
+             ListType<Set<ByteBuffer>> list2 = ListType.getInstance(SetType.getInstance(new
TupleType(asList(udtWith3Fields, Int32Type.instance)), isMultiCell), isMultiCell);
+             checkComparisonResults(list1, list2);
+         }
+     }
+ 
+     @Test
+     public void testInvalidComparison()
+     {
 -        assertInvalidComparison("Trying to compare 2 different types: org.apache.cassandra.db.marshal.UserType(ks,6d7954797065,61:org.apache.cassandra.db.marshal.Int32Type,62:org.apache.cassandra.db.marshal.Int32Type)
and org.apache.cassandra.db.marshal.Int32Type",
++        assertInvalidComparison("Trying to compare 2 different types: org.apache.cassandra.db.marshal.FrozenType(org.apache.cassandra.db.marshal.UserType(ks,6d7954797065,61:org.apache.cassandra.db.marshal.Int32Type,62:org.apache.cassandra.db.marshal.Int32Type))
and org.apache.cassandra.db.marshal.Int32Type",
+                                 udtWith2Fields,
+                                 Int32Type.instance);
+         assertInvalidComparison("Trying to compare 2 different types: org.apache.cassandra.db.marshal.UTF8Type
and org.apache.cassandra.db.marshal.InetAddressType",
+                                 SetType.getInstance(UTF8Type.instance, true),
+                                 SetType.getInstance(InetAddressType.instance, true));
+         assertInvalidComparison("Trying to compare 2 different types: org.apache.cassandra.db.marshal.UTF8Type
and org.apache.cassandra.db.marshal.InetAddressType",
+                                 ListType.getInstance(UTF8Type.instance, true),
+                                 ListType.getInstance(InetAddressType.instance, true));
+         assertInvalidComparison("Trying to compare 2 different types: org.apache.cassandra.db.marshal.UTF8Type
and org.apache.cassandra.db.marshal.InetAddressType",
+                                 MapType.getInstance(UTF8Type.instance, IntegerType.instance,
true),
+                                 MapType.getInstance(InetAddressType.instance, IntegerType.instance,
true));
+         assertInvalidComparison("Trying to compare 2 different types: org.apache.cassandra.db.marshal.UTF8Type
and org.apache.cassandra.db.marshal.InetAddressType",
+                                 MapType.getInstance(IntegerType.instance, UTF8Type.instance,
true),
+                                 MapType.getInstance(IntegerType.instance, InetAddressType.instance,
true));
+     }
+ 
+     private void assertInvalidComparison(String expectedMessage, AbstractType<?> oldVersion,
AbstractType<?> newVersion)
+     {
+         try
+         {
+             checkComparisonResults(oldVersion, newVersion);
+             fail("comparison doesn't throw expected IllegalArgumentException: " + expectedMessage);
+         }
+         catch (IllegalArgumentException e)
+         {
++            System.out.println(e.getMessage());
+             assertEquals(e.getMessage(), expectedMessage);
+         }
+     }
+ 
+     private void checkComparisonResults(AbstractType<?> oldVersion, AbstractType<?>
newVersion)
+     {
+         assertEquals(0, compare(oldVersion, oldVersion));
+         assertEquals(0, compare(newVersion, newVersion));
+         assertEquals(-1, compare(oldVersion, newVersion));
+         assertEquals(1, compare(newVersion, oldVersion));
+     }
+ 
 -    private int compare(AbstractType<?> left, AbstractType<?> right)
++    private static int compare(AbstractType<?> left, AbstractType<?> right)
+     {
+         return AbstractTypeVersionComparator.INSTANCE.compare(left, right);
+     }
+ }


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org


Mime
View raw message