Composite Types

pycassa currently supports static CompositeTypes. DynamicCompositeType support is planned.

Creating a CompositeType Column Family

When creating a column family, you can specify a CompositeType comparator or validator using CompositeType in conjunction with the other types in pycassa.types.

>>> from pycassa.types import *
>>> from pycassa.system_manager import *
>>> sys = SystemManager()
>>> comparator = CompositeType(LongType(reversed=True), AsciiType())
>>> sys.create_column_family("Keyspace1", "CF1", comparator_type=comparator)

This example creates a column family with column names that have two components. The first component is a LongType, sorted in reverse order; the second is a normally sorted AsciiType.

You may put an arbitrary number of components in a CompositeType, and each component may be reversed or not.

Insert CompositeType Data

When inserting data, where a CompositeType is expected, you should supply a tuple which includes all of the components.

Continuing the example from above:

>>> cf = ColumnFamily(pool, "CF1")
>>> cf.insert("key", {(1234, "abc"): "colval"})

When dealing with composite keys or column values, supply tuples in exactly the same manner.

Fetching CompositeType Data

CompositeType data is also returned in a tuple format.

>>> cf.get("key")
{(1234, "abc"): "colval"}

When fetching a slice of columns, slice ends are specified using tuples as well. However, you are only required to supply at least the first component of the CompositeType; elements may be left off of the end of the tuple in order to slice columns based on only the first or first few components.

For example, suppose our comparator_type is CompositeType(LongType, AsciiType, LongType). Valid slice ends would include (1, ), (1, "a"), and (1, "a", 2011).

If you supply a slice start and a slice end that only specify the first component, you will get back all columns where the first component falls in that range, regardless of what the value of the other components is.

When slicing columns, the second component is only compared to the second component of the slice start if the first component of the column name matches the first component of the slice start. Likewise with the slice end, the second component will only be checked if the first components match. In essence, components after the first only serve as “tie-breakers” at the slice ends, and have no effect in the “middle” of the slice. Keep in mind the sorted order of the columns within Cassandra, and that when you get a slice of columns, you can only get a contiguous slice, not separate chunks out of the row.

Inclusive or Exclusive Slice Ends

By default, slice ends are inclusive on the final component you supply for that slice end. This means that if you give a column_finish of (123, "b"), then columns named (123, "a", 2011), (123, "b", 0), and (123, "b" 123098123012) would all be returned.

With composite types, you have the option to make the slice start and finish exclusive. To do so, replace the final component in your slice end with a tuple like (value, False). (Think of the False as being short for inclusive=False. You can also explicitly specify True, but this is redundant.) Now, if you gave a column_finish of (123, ("b", False)), you would only get back (123, "a", 2011). The same principle applies for column_start.