cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Ed Anuff (Commented) (JIRA)" <>
Subject [jira] [Commented] (CASSANDRA-3625) Do something about DynamicCompositeType
Date Wed, 14 Dec 2011 03:48:30 GMT


Ed Anuff commented on CASSANDRA-3625:

Each component in a composite consists of a type (either an alias byte or a Cassandra comparator
type name) and the value.  I'm suggesting doing a compare on the type in the case of types
not being equivalent.  The comparison could be a lexical compare or a hash comparison.  I
think doing the compare on the component type is better since the purpose of the composite
is for slices and if we do a lexical compare of the component values then the slices are going
to have weird results in the middle of them.  For example, a row that had dynamic composite
columns ("ed",5), ("jonathan",6), and (103, 32), that was sliced from ("ed") to ("jonathan")
could have the (103, 32) in the middle.  If we compare on the type, then that never happens.
> Do something about DynamicCompositeType
> ---------------------------------------
>                 Key: CASSANDRA-3625
>                 URL:
>             Project: Cassandra
>          Issue Type: Improvement
>          Components: Core
>            Reporter: Sylvain Lebresne
> Currently, DynamicCompositeType is a super dangerous type. We cannot leave it that way
or people will get hurt.
> Let's recall that DynamicCompositeType allows composite column names without any limitation
on what each component type can be. It was added to basically allow to use different rows
of the same column family to each store a different index. So for instance you would have:
> {noformat}
> index1: {
>   "bar":24 -> someval
>   "bar":42 -> someval
>   "foo":12 -> someval
>   ...
> }
> index2: {
>   0:uuid1:3.2 -> someval
>   1:uuid2:2.2 -> someval
>   ...
> }
> ....
> {noformat}
> where index1, index2, ... are rows.
> So each row have columns whose names have similar structure (so they can be compared),
but between rows the structure can be different (we neve compare two columns from two different
> But the problem is the following: what happens if in the index1 row above, you insert
a column whose name is 0:uuid1 ? There is no really meaningful way to compare "bar":24 and
0:uuid1. The current implementation of DynamicCompositeType, when confronted with this, says
that it is a user error and throw a MarshalException.
> The problem with that is that the exception is not throw at insert time, and it *cannot*
be because of the dynamic nature of the comparator. But that means that if you do insert the
wrong column in the wrong row, you end up *corrupting* a sstable.
> It is too dangerous a behavior. And it's probably made worst by the fact that some people
probably think that DynamicCompositeType should be superior to CompositeType since you know,
it's dynamic.
> One solution to that problem could be to decide of some random (but predictable) order
between two incomparable component. For example we could design that IntType < LongType
< StringType ...
> Note that even if we do that, I would suggest renaming the DynamicCompositeType to something
that suggest that CompositeType is always preferable to DynamicCompositeType unless you're
really doing very advanced stuffs.
> Opinions?

This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:!default.jspa
For more information on JIRA, see:


View raw message