question

Collections

The difference between the two collection types lies in the fact that the elements in a list collection are stored in a particular order and thus allows for duplicate values. In contrast, a set collection consists of unordered unique values which only get sorted in natural order when queried.

Sets

To illustrate, let me use an example table that contains a set of friends and a set of numbers:

CREATE TABLE myset (
    name text PRIMARY KEY,
    friends set<text>,
    numbers set<int>
)

Inserting unordered groups of friends and numbers:

cqlsh> INSERT INTO myset (name, friends, numbers) \
  VALUES ( 'erick', \
    { 'tom', 'dick', 'harry', 'sally' }, \
    { 3, 1, 2, 4 } \
  );

When queried, we see that the friends' names are returned in alphabetical order and the numbers are returned in order:

cqlsh> SELECT * FROM myset ;

 name  | friends                           | numbers
-------+-----------------------------------+--------------
 erick | {'dick', 'harry', 'sally', 'tom'} | {1, 2, 3, 4}

Lists

Here's a similar table but this time has a list of friends and a list of numbers:

CREATE TABLE mylist (
    name text PRIMARY KEY,
    friends list<text>,
    numbers list<int>
)

Inserting a group of friends and numbers:

cqlsh> INSERT INTO mylist (name, friends, numbers) \
  VALUES ( 'erick', \
    [ 'tom', 'dick', 'harry', 'sally' ], \
    [ 3, 1, 2, 4 ] \
  );

When queried, we see that the order is preserved:

cqlsh> SELECT * FROM mylist ;

 name  | friends                           | numbers
-------+-----------------------------------+--------------
 erick | ['tom', 'dick', 'harry', 'sally'] | [3, 1, 2, 4]

This is an important point to understand because with a set, it doesn't matter whether we add or delete elements from the collection because the order does not matter.

With a list, prepending (adding an element to the start) or appending (adding an element to the end) does NOT involve a read-before-write because Cassandra does not need to know which position to add the new element -- it either goes at the start or the end of the list. But when inserting or deleting an element in a specific position, Cassandra needs to read the elements because it needs to rewrite it in the proper order.

Consider this diagram which shows the elements in order where Tom is in position 0, Dick is in position 1 and so on:

If we insert Alice in position 1, Cassandra needs to "walk" the list to get to position 1 and update its value:

cqlsh> UPDATE mylist SET friends[1] = 'alice' WHERE name = 'erick';

It can only do that by reading all the elements in the list. Similarly, to delete the element at position 2, C* needs to:

1. iterate over the first 2 elements
2. delete the value in position 2
3. shift all the elements to the left

cqlsh> DELETE friends[2] FROM mylist WHERE name = 'erick';

To reiterate:

• Cassandra does a read-before-write when updating or deleting the value of an element at a specific position because the order of elements matters in a list collection.
• The elements are not in any particular order in a set collection so it does not incur this penalty.

Cheers!