Mailing-List: contact user-help@cassandra.apache.org; run by ezmlm
Precedence: bulk
Reply-To: user@cassandra.apache.org
Received-SPF: pass (nike.apache.org: domain of sylvain@datastax.com designates
 209.85.192.175 as permitted sender)
MIME-Version: 1.0
In-Reply-To: <alpine.DEB.2.00.1306052210490.10290@computableinsights.com>
References: <alpine.DEB.2.00.1306052210490.10290@computableinsights.com>
Date: Thu, 6 Jun 2013 12:08:41 +0200
Message-ID: 
 <CAKkz8Q0BNkLA2XBek4eCHWJPL_+TeGoqWx0SqMJ+v7PP6xrYfw@mail.gmail.com>
Subject: Re: smallest/largest UUIDs for LexicalUUIDType
From: Sylvain Lebresne <sylvain@datastax.com>
To: "user@cassandra.apache.org" <user@cassandra.apache.org>
Content-Type: multipart/alternative; boundary=047d7b678754ae4a2804de797f0d

--047d7b678754ae4a2804de797f0d
Content-Type: text/plain; charset=ISO-8859-1

> I'm trying to use composite column names to organize 10**8 records.  Each
> record has a unique pair of UUIDs.  The first UUID is often repeated, so I
> want to use column_start and column_finish to find all the records that
> have a given UUID as the first UUID in the pair.
>
> I thought a simple way to get *all* of the columns would be to use
>
>  start  = uuid.UUID(int=0)        -> 00000000-0000-0000-0000-**
> 000000000000
>  finish = uuid.UUID(int=2**128-1) -> ffffffff-ffff-ffff-ffff-**
> ffffffffffff
>
> But strangely, this fails to find *any* of the columns, and it requires
> that column_reversed=True -- otherwise it raises an error about range
> finish not coming after start.  If I use ints that are much larger/smaller
> than these extremes, then reversed is not required!
>
> Can anyone explain why LexicalUUIDType() does not treat these extremal
> UUIDs like other UUIDs?
>

LexicalUUIDType compares the uuid using Java UUID compare method (
http://docs.oracle.com/javase/6/docs/api/java/util/UUID.html#compareTo(java.util.UUID)
).

As it happens this method consider a UUID as 2 longs and when comparing 2
uuids, it compares those longs lexicographically.
But java longs are signed. So for that
method, 00000000-0000-0000-0000-000000000000
> ffffffff-ffff-ffff-ffff-ffffffffffff (but for
instance, 00000000-0000-0000-0000-000000000000 <
7fffffff-ffff-ffff-ffff-ffffffffffff (because the first "long" of that 2nd
uuid is now positive)).

That's an historical accident, LexicalUUIDType should probably not have use
that comparison as it's arguably not very intuitive. However it's too late
to change it (as changing it now would basically corrupt all data for
people using LexicalUUIDType today).

I'll note that if you have the choice, you can use UUIDType rather than
LexicalUUIDType. UUIDType fixes that behavior and use a proper lexical
comparison for non-type-1 uuids (the other behavior of UUIDType is that for
type 1 uuid, it compares them by time first, i.e. it is equivalent to
TimeUUIDType for type 1 uuid).

--
Sylvain

--047d7b678754ae4a2804de797f0d
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><br><div class=3D"gmail_extra"><div class=3D"gmail_quote">=
<blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-=
left-width:1px;border-left-color:rgb(204,204,204);border-left-style:solid;p=
adding-left:1ex">

I&#39;m trying to use composite column names to organize 10**8 records. =A0=
Each record has a unique pair of UUIDs. =A0The first UUID is often repeated=
, so I want to use column_start and column_finish to find all the records t=
hat have a given UUID as the first UUID in the pair.<br>

<br>
I thought a simple way to get *all* of the columns would be to use<br>
<br>
=A0start =A0=3D uuid.UUID(int=3D0) =A0 =A0 =A0 =A0-&gt; 00000000-0000-0000-=
0000-<u></u>000000000000<br>
=A0finish =3D uuid.UUID(int=3D2**128-1) -&gt; ffffffff-ffff-ffff-ffff-<u></=
u>ffffffffffff<br>
<br>
But strangely, this fails to find *any* of the columns, and it requires tha=
t column_reversed=3DTrue -- otherwise it raises an error about range finish=
 not coming after start. =A0If I use ints that are much larger/smaller than=
 these extremes, then reversed is not required!<br>

<br>
Can anyone explain why LexicalUUIDType() does not treat these extremal UUID=
s like other UUIDs?<br></blockquote><div><br></div><div style>LexicalUUIDTy=
pe compares the uuid using Java UUID compare method (<a href=3D"http://docs=
.oracle.com/javase/6/docs/api/java/util/UUID.html#compareTo(java.util.UUID)=
">http://docs.oracle.com/javase/6/docs/api/java/util/UUID.html#compareTo(ja=
va.util.UUID)</a>).</div>
<div style><br></div><div style>As it happens this method consider a UUID a=
s 2 longs and when comparing 2 uuids, it compares those longs lexicographic=
ally.</div><div style>But java longs are signed. So for that method,=A00000=
0000-0000-0000-0000-000000000000 &gt;=A0ffffffff-ffff-ffff-ffff-fffffffffff=
f (but for instance,=A000000000-0000-0000-0000-000000000000 &lt; 7fffffff-f=
fff-ffff-ffff-ffffffffffff (because the first &quot;long&quot; of that 2nd =
uuid is now positive)).</div>
<div style><br></div><div style>That&#39;s an historical accident, LexicalU=
UIDType should probably not have use that comparison as it&#39;s arguably n=
ot very intuitive. However it&#39;s too late to change it (as changing it n=
ow would basically corrupt all data for people using LexicalUUIDType today)=
.</div>
<div style><br></div><div style>I&#39;ll note that if you have the choice, =
you can use UUIDType rather than LexicalUUIDType. UUIDType fixes that behav=
ior and use a proper lexical comparison for non-type-1 uuids (the other beh=
avior of UUIDType is that for type 1 uuid, it compares them by time first, =
i.e. it is equivalent to TimeUUIDType for type 1 uuid).</div>
<div style><br></div><div style>--</div><div style>Sylvain</div></div></div=
></div>

--047d7b678754ae4a2804de797f0d--