►
From YouTube: C* Summit 2013: The State of CQL
Description
Speaker: Sylvain Lebresne, Apache Cassandra Committer and Engineer at DataStax
Slides: http://www.slideshare.net/planetcassandra/cassandra13-state-of-cql
Since its inception, the Cassandra Query Language (CQL) has grown and matured, resulting in the 3rd version of the language (CQL3) being finalized in Cassandra 1.2. Compared to the legacy Thrift API, CQL3 aims at providing an API that is higher level and more user friendly but still fully assumes the distributed nature of Cassandra and it's storage engine. This presentation will present CQL3, describing the reasoning and goals behind the language as well as the language itself. CQL's relationship with Thrift will be touched on, along with the CQL binary protocol that has been introduced in Cassandra 1.2. This presentation will wrap up by discussing the future of CQL.
A
I
work
at
the
stacks
and
I
work
in
the
casino
team,
so
my
job
is
to
work
in
the
open
source,
cassandra
project,
and
so
I'm
a
committer,
and
I
I
suppose
I
can
say
I'm
one
of
the
core
developers
and
one
of
the
things
I've
worked
on
recently
is
cql.
So
that's
what
I
want
to
talk
about
today.
I
should
stay
on
the
light
right,
so
that
doesn't
work
there
you
go
so
what
I
like
to.
What
I
want
to
talk
about
today
is
first,
I
want
to
explain
you.
A
Then
I
want
to
show
you
how
it
works
and
explain
the
principle
and
how
you
actually
do
that
ammo
link
with
it
and
in
that
second
part
I
won't
talk
about
drift
at
all.
So
I
want
to
show
you
that
you
can
explain
cqr
without
stress,
then
I
will
mention
very
quickly
the
native
protocol
and
then
I
want
to
quickly
discuss
you
know.
What's
coming
on
the
sql
front
for
2-0,
and
what's
coming
after
that,
so
before
before
going
into
it,
I
want
to
do
two
quick
general
remarks.
A
To
be
sure
we
understand
what
I'm
talking
about
that.
You
don't
think
I'm
talking
on
something
I'm
not
the
first
one
is
that
that
presentation
is
only
on
cql3,
so
sql
version
three.
We
had
a
secular
two
before
and
before
that
the
ceo
one.
There
is
important
difference
between
cql2
and
secure
three,
and
I
won't
address
it
here.
So
that's
ql3,
that's
the
version
we
are
moving
forward
with
and
I'm
sure
if
some
of
it
doesn't
apply
to
the
previous
version,
but
I
won't
state
it.
A
The
good
news
is
that's
the
same
thing
any
done
in
sql,
so
I
will
mean
kind
of
a
kind
of
an
xqr
com
and
kind
of
an
sql
row,
even
though
I
mean
cqr,
but
that
this
different
from
the
thrift
notion
of
rows
and
columns
right,
so
the
confusion
that
three
shouldn't
have
used,
those
name
for
things
that
are
different
from
sql
because
it
confused
every
new
guy
any
cqr.
Well,
we
couldn't
use
something
different
because
they
are
really
kind
of
rows
in
column
temperature,
so
we
couldn't
call
them
differently,
but
now
it's
confusing.
A
So
I'm
sorry
about
it.
But
in
that
talk
I'm
talking
of
rose
and
comes
secretly
way,
and
hopefully
it
will
be
clear
of
that-
relate
to
the
thrift
part,
and
I
briefly
talk
about
it,
but
so,
let's
get
into
why
we
do
cqr
well,
the
gist
of
it
is
that
the
street
type
is
on
really
a
very
good
api.
It's
not
it's
not
very!
It's
not
very
easy
to
use
it's,
not
very
user
friendly,
and
there
there's
a
number
of
reasons
for
that.
A
But
I
think
that
the
main
one
is
that
it's
very
low
level.
It's
very
very
little
abstraction.
So
what
that
means
is
that
in
thrift,
it's
flexible,
there's
no
question
about
it,
but
everything
is
hard,
so
a
good
api
should
be.
It
should
be
easy
to
do
the
right
thing
and
it
should
be
flexible
enough
so
that
you
can
do
whatever
you
want
is
flexible
but
flicks
in
this
rift.
Everything
is
hard
right,
so
you
have
to
piece
it
together.
A
It's
kind
of
a
it's
kind
of
an
assembler
in
a
way,
and
so
so
yeah.
That's
that's
very
another
reason.
Another
thing
that
that
we
didn't
like
with
thrift-
or
one
thing
that
was
a
problem
for
us-
is
that
it's
pretty
hard
to
evolve
at
least
in
a
way
that
don't
break
clients.
So
it's
hard
to
make
a
change
to
the
api.
I
add
a
new
concept
or
an
extension
to
the
api
without
breaking
people.
A
Part
of
it
is
probably
that
the
freifa
pr
wasn't
designed
very
well
for
that
part
of
is
that
shrift.
The
software
itself
is
trying
to
target
that
many
languages,
so
it
has
to
the
feature
it
has
to
evolve
is
like
a
mini,
a
common
denominator
on
all
those
languages.
So
you
don't
really
have
optional,
like
parameters
to
function
and
stuff
like
that,
so
at
least
it's
not
supported
in
all
languages,
so
you
cannot
really
use
it
without
breaking
people.
A
So
really
cassandra
has
a
reputation
of
being
hard
to
develop
against
and
and
work
with
it,
and
we
believe
that
it
doesn't
have
to
be
that
way.
Don't
get
me
wrong.
That
doesn't
mean
that
you
will
come
from
the
the
rational
model
and
be
able
to
use
cassandra
without
having
to
learn
anything
new.
However,
we
don't
want
people
to
have
to
learn
more,
that
what
they
strictly
need
to
understand:
cassandra.
Okay.
A
Now.
The
second
question
that
comes
is
that
okay,
fair
enough,
we
want
something
else.
That's
strict
and
just
adding
a
few
new
methods
to
switch,
won't
just
cut
it,
but
then
you
know
why
they
are
an
sql
look-alike
language.
It's
called
sql
after
all
right
and
the
reason
is
that
if
you
actually
look
at
the
pros
and
cons
the
query
language
is
is:
is
pretty
nice,
so
those
are
fairly
basic.
But
you
know
sql
is
very
easy
to
read
it
really
like
english
right.
A
So
you
could
do
a
programmatic
api
that
read
like
english,
but
that's
a
little
bit
more
work,
it's
harder
to
make
evolve
and
stuff
like
that,
but
it's
a
given
with
sql
the
reason
one
is
like
it's
programming
language.
What
I
call
programming
language,
independent
and
what
I
mean
here
is
that
when
you
want
to
have
help
on
the
mailing
list,
you
can
send
a
an
email
and
you
can
say
here's
my
schema.
Here's
the
query
that
I
that
I
do
and
I
don't
get
what
I
expect.
A
So
what
gives
right
with
thrift
you
if
you
send
an
email
with
thrift
code,
nobody
will
answer
because
nobody
will
get
after
the
10
first
line
and
you
will
have
probably
100
lines,
because
thrifty
is
that
way,
so
people
will
send
code
for
our
ector
or
for
picasa,
and
I
have
nothing
against
pakasa.
But
maybe
I
don't
speak
python
right,
so
you
know
after
to
add
to
all
those
those
clients
different
everything.
So
I
think
the
language
is
that
kind
of
is
programming.
A
Language
independent
and
allowed
to
communicate
is,
in
my
opinion,
very,
very
useful.
The
other
one.
Well,
everybody
knows
sql,
so
the
syntax
is
familiar
to
anyone.
That's
a
good
thing.
It's
copy
past
friendly,
so
yeah
that,
but
it's
kind
of
useful
and
one
that
that
I
actually
quite
like
a
lot
is
that
it's
very
easy
to
evolve.
So
we've
so
cql3
in
like
one
two
five,
which
is
the
current
casino
version.
There's
been
some
evolution
compared
to
the
one
two
zero,
but
those
has
been
very
easy.
A
That
is,
it's
very
easy
to
add
new
stuff
without
breaking
it
because
you
just
add
new
syntax
construction
that
that
you
support
and
not
only
don't
you
break
stuff,
but
it
looks
very
natural.
It
doesn't
look
like
you've
added
stuff
after
the
fact,
so
that's
really
good
to
make
stuff
evolve
and
well
I'm
not
done
so.
So
the
two
other
points
that
so
people
tell
you:
okay,
but
your
money,
police,
manipulating
strings
right.
A
So
it's
going
to
be
slow
and
we
don't
want
slow
but
well
secure
solved
that
a
long
time
ago
you
just
have
prepared
statement,
so
you
have
preferred
statement
and
you
pass
your
value
as
bytes.
So
it's
not
because
you're
using
a
secure,
sql
like
language,
is
that
you
have
to
actually
use
strings
and
you
don't
even
have
to
work
with
strings.
You
don't
have
to.
I
mean
people
that
do
sql
every
day.
They
don't
do
string
containation
all
the
time
they
just
don't.
A
So
those
are
kind
of
not
argument
in
my
opinion,
so
really
at
the
end
of
the
day.
Why
not?
Why
not
sql,
query
language
just
read
very
well
and
hopefully
will
agree
that
it's
not
too
bad
so
so
and
secure
right.
So
if
you,
if
I
want
to
describe
describe
cql,
is
like
two
words,
I
would
say
that
it's
to
denormalize
sql,
so
it
looks
like
sql,
but
you
really
want
to
modalize
things
with
the
normalization
I'll
come
back
to
that.
A
A
A
A
We
cannot
make
it
impossible
to
do
the
wrong
one,
but
at
least
we
want
to
make
it
easy
to
do
the
right
thing
and
that
that
implies
giving
you
higher
level
constrict
work
with
that.
Just
here
you
can
store
bytes
and
do
whatever
you
want
with
that.
Okay,
so
in
cqr
that
means
that
mean
collection
I
will
see,
but
that's
also
the
weight
and
all
composite
stuff,
and
things
like
that-
and
the
last
point
is
that
it
is
a
goal
of
cqr
to
be
a
complete
alternative
of
thrifts
right.
A
We
don't
mean
cqr
to
be
used
alongside
thrift,
we
made
it
a
complete
alternative
right.
You
can
still
use
trips,
we
want,
but
we
want
everything
that
can
be
done
with
trif
to
be
done
with
cqr.
So
I
know
some
people
will
tell
me
what
about
dynamic
composite
type?
Well,
you
can
do
dynamic
composite
type
with
cqr.
We
don't
have
any
syntax
to
do
specific,
syntax
through
dynamic,
composite
type
with
cqr,
but
you
can
do
it.
That
is,
it
will
look.
A
It
will
look
as
bad
as
rift,
but
it
won't
be
worse
and
you
can
do
it
and
the
reason
for
that
is
that
the
right,
dynamic
composite
app
are
not
that
useful,
they're,
a
corner
case
thing
most
of
the
time
when
people
use
dynamic
type,
they
could
do
it
much
in
a
much
simpler
way,
with
a
simple
composite
type,
which
is
what
cql3
gives
you.
Basically.
A
A
So
we
want
to
do
what
makes
sense.
We
certainly
want
to
extend
the
capability
of
cassandra.
We
support,
comparing
swap
into
and
and
social
things
like
that,
but
it's
not
a
goal
to
be
sql.
Okay.
So
sorry,
if
that's
what
you
want,
that's
not
a
goal
we'll
then
we
will
still
ask
you
to
normalize,
so
there
will
still
be
a
switch
to
do
from
sql
to
cqr,
but
at
least
we
want
to
make
that
as
easy
as
possible.
A
The
other
thing
that
we
don't
want
to
do
is
to
hide
the
specificity
of
cassandra,
because
then
again
the
c
in
cql
stands
for
cassandra,
so
we
really
want
to
have
an
api
that
allows
you
to
make
the
the
most
out
of
you
know
the
distribution
that
cassandra
offers
you.
So
you
need
to
be
able
to
work
with
distribution
and
you
need.
We
want
you
to
be
able
to
make
full
use
of
the
storage
engine
that
casino
offers
right,
which
is
slightly
different
from
it's,
not
a
b3.
A
A
A
A
So
if
you
want
to
be
fast,
you
want
it
to
be
to
go
to
only
one
node
or
really
one
replica
asset,
but
we,
if
a
query,
need
to
fetch
data
on
all
nodes
of
the
cluster
and
join
it
and
whatever
and
transfer
data
between
nodes.
It
won't
be
fast.
So
we
want
you
to
be
able
to
use
that,
so
you
should
use
data
locality
at
the
cluster
level
if
you
want
it
to
be
fast
and
the
second
one
is
that
I'll
cut
you
at
what
I
call
the
node
level
right.
A
So
you
want
to
the
customer.
Storage
engine
allows
you
to
do
data
collocation
on
disk.
It
allows
you
to
store
data
on
these
together
in
a
sorted
order
that
you
can
make
using
your
application,
and
you
only.
You
will
only
get
efficient
queries
if
you
actually
do
that
right
and
what
we
call
we.
We
use
the
normalization
relating
cassandra.
A
The
organization
is
really
kind
of
the
technique
that
allows
you
to
have
both
of
those
things,
because
the
reality
is
that
in
any
generic
and
useful
data
model
a
given
piece
of
data,
it
will
appear
in
different
queries
alongside
different
different
set
of
data.
So
if
you
don't
copy
data
in
multiple
places,
you
cannot
achieve
the
data
locality
and
on
on
the
cluster
and
the
net
level.
You
know
for
all
your
queries
that
that's
not
possible.
A
That
doesn't
mean
that
the
normalization
is
easy.
Don't
get
me
wrong,
there's
there's
an
art
in
their
normalization,
because
denomination
is
not
a
free
lunch.
If
you
denormalize,
then
updates
can
become
a
problem.
So
it's
easy
to
normalize
immutable
data.
Normalizes
mutable
data,
that's
more
of
a
challenge,
so
you
still,
you
will
still
have
to
you
know
know
when
you
need
to
denormalize
when
it's
probably
not
worth
it
and
stuff
like
that.
So
there's
something
to
learn,
but
really
what
you
want
to
achieve
is
that,
so
what
what
we
want
for?
A
The
api,
what
seek
all
that
cql
needs
to
be
able
to
expose
you
for
cassandra
is
oh
to
you,
ok,
to
copy
that
on
the
same
replica
set
really
on
the
same
node,
and
how
do
you
call
it
data
on
disk,
for
you
know
a
given
replica
set
and
in
a
sorted
order
so
that
you
can
query
it,
and
you
need
to
be
able
to
query
that
data
that
is
collocated
in
in
a
meaningful
way.
Okay
and
the
rest
of
what
the
api
should
do.
A
Is
you
know
let
you
model
your
application,
the
the
in
in
an
easy
way.
You
know
it
should
be
easy
for
you
to
do
it
and
it
should
be
easy
to
do
to
do
that
efficiently
and
while
the
street
apis
allows
you
to
do
those
things
right.
The
first
one
here
the
on
on
cluster
localization
is
like
we
call
it.
The
the
rookie
and
this
time
is
a
three
fro
key
right.
We
call
the
three
fro
key
and
we
say
all
data
that
is
within
the
same.
A
A
Okay,
I
mean
names
are
important
to
communicate,
but
I
mean
what's
important:
is
the
concept
behind
them
so
sql,
as
we'll
see,
doesn't
give
the
same
name
to
this
concept,
but
those
concepts
are
absolutely
extremely
important
for
sequel
and
they're,
very
central
to
cpr
now
to
to
explain
this
concept
with
secure
will
use
a
like
a
running
email,
a
small
email
application.
So
I
will
use
an
example.
That's
naive
because
that's
just
slides-
and
I
don't
have
time
to
go
into
all
the
details,
but
it's
a
naive
email
application.
A
So
what
I
want
to
store
is
user.
First,
I
want
to
store
emails
and
then
I
want
to
have
an
inbox
for
my
users.
So
an
inbox
is
just
you
know:
emails
received
by
the
user
in
current
recorder.
That's
what
I
wanted.
Okay,
how
do
I
store
the
user
profile
in
sql?
Well,
it
looks
that
way.
You
create
a
table
user
and
each
user
is
identified
by
an
id.
A
I
use
a
uid
here
because
customize
the
normal,
I
is
sorry
customer
is
decentralized
and
so
uiv
are
an
easy
way
to
create
a
unique
id
in
a
decentralized
way.
So
it's
a
good
match,
so
we
use
uid
a
lot
in
in
cassandra
and
then
I
have
a
number
of
priority.
I
have
my
name,
my
password,
my
email
and
maybe
my
picture
profile.
That's
a
blog
okay
and
maybe
some
of
the
user
won't
have
a
profile.
So
you
know
that
that
can
be
no.
Why
not?
But
at
least
most
users
will
have
that
and
well.
A
My
primary
key
is
my
user
id
because
yeah,
that's
what
identifying
my
user
uniquely
so
my
primary
key,
these
are
primarily
in
the
sql
standard
of
the
term,
is
to
identify
a
role
uniquely
then
I
can
do
insert
of
my
user
okay.
So
that's!
Okay,
that's
a
short
view
id,
but
that's
for
the
slide
right.
A
real
uad
is
longer
than
that,
but
my
slide,
I'm
not
that
big,
and
there
is
no
three
dots
here
just
to
say
that
a
blob
is
likely
to
be
bigger
than
that.
A
A
So
I
would
I
would
advise
to
use
insert
when
you
actually
mean
insert
and
update
when
you
actually
mean
update,
but
the
database
doesn't
enforce
that
they
are
insert
an
update
in
an
sql
sense
of
the
way.
Okay,
and
the
reason
is
that
we
don't
know
to
do
that,
because
cassandra
doesn't
do
a
read
when
you
do
write
so
technically,
we
can't
do
that
and
distribution
make
that
even
harder.
A
In
fact
to,
I
think,
if
I
don't
forget
anything,
I
see
that
the
only
cases
where
we
support
something
that
is
that
look
like
sql,
but
the
semantic
is
different,
so
cql's
additional
thing
that
sql
doesn't
have.
It
also
add
additional
meanings
to
some
of
the
stuff
and
secure
sql
as
we'll
see,
but
I
think
that
it's
the
only
cases
where
the
the
semantic
is
slightly
different,
so
you
have
to
know
it,
but
the
rest
of
the
time.
A
What
if
you
know
sql
and
you
read
something
that
is
secure,
it
should
make
sense
right
doesn't
mean
you
can
use
sql.
You
have
to
learn
the
normalization,
but
at
least
it
will
make
sense
to
you
now.
I've
said
there
is
additional
meanings
to
cqr
and
the
first,
the
the
the
the
that
additional
meaning
cigar
is
in
around
the
primary
key.
So
more
precisely
the
first
element
of
the
primary
key
is
what
we
call
the
partition
king
customer.
A
A
Okay,
let's
say
I
want
an
example,
a
little
bit
more
complicated
and
let's
say
that
I
want
my
user
to
be
able
to
create
custom
properties
right.
I
want
them
to
be
able
to
go
on
their
profile
and
say
I
want
to
show
my
hobbies
to
my
friends
right,
but
every
user
could
do
whatever
he
wants
in
his
profile.
I
want
to
be
able
to
store
custom
properties.
How
do
I
do
that
in
cenra
with
cqr?
A
Well,
I
could
use
a
map,
so
we
support
collections.
So
in
that
case
I
could
just
add
a
column.
That's
a
map
of
string.
So
whenever
my
user
wants
to
add
a
new
property,
I
will
insert
you
know
my
properties
with
whatever
I
want
in
there
for
my
user
and
well.
If
I
query,
I
will
get
that
back
from
the
the
storage.
I
will
have
my
user
that
insert
in
the
preview
slide
and
I
will
have
a
map
here
and
I
can
have
multiple
property
for
each
user
or
whatever.
A
Okay,
now,
let's
store
emails.
Well,
email
looks
a
lot
like
users,
I
have
a
table.
Email
and
the
emails
are
are
identified
by
the
email
id.
That
time
is
the
time
uid.
So
it's
like
a
uid.
It's
unique
for
every
I'm
guaranteed
that
it
will
be
generated
unique
for
each
email,
but
there
is
a
time
component
here,
so
that
value
actually
holds
the
creation
time
of
my
email.
That's
why
I,
I
will
use
the
creation
time
of
my
email
in
that
model,
but
I
don't
have
a
column.
A
That's
that's
called
created
at,
for
example,
I
could
have
it.
I
could
absolutely
have
it,
but
in
that
case
I
don't
need
it,
because
I
have
that
timely
id
and
that's
something
we
do
in
in
cassandra
often,
but
then
my
email
will
have
a
subject,
probably
a
sender
and
a
bunch
of
recipients.
I
can
have
more
and
recipients
to
an
email,
so
that's
a
set
and
a
body.
I
will
note
here
that
my
sender
is
a
uid,
so
in
that
case
I
don't
denormalize
right.
A
But
then
experience
is
helps
you
you
can
insert
email
and
then
you
can
query
them.
So
a
remark
here
is
that
well
first
thing
we
don't
do
join,
we
don't
do
sub
queries,
so
the
syntax
is
just
not
supported.
The
other
point
is
that
the
only
queries
that
sql
allows
you
to
do
is
the
one
for
which
it
has
an
index
to
work
with
that
that's
been
explicitly
defined.
So
my
email
here,
my
primary
key
here.
A
It
defines
a
primary
index
right,
so
my
emails
are
by,
but
I
indexed
by
email
id,
but
that's
the
only
index
I
have.
So.
If
I
try
to
do
that,
query
that
try
to
fetch
the
emails
based
on
the
sender,
then
that
won't
work.
It
will
tell
you
no
sorry.
I
cannot
do
that,
because
sender
is
not
indexed
magically,
so
you
can
create
an
index.
A
You
can
create
an
index
on
the
center
of
emails
that
we
create
a
secondary
index
when
you've
done
that,
then
you
can
do
that
query
but
then,
secondly,
secondary
indexes
in
customer
have
their
own
performance
characteristics.
So
you
know
sometimes
it
doesn't
make
sense,
and
sometimes
you
have
to
do
yourself
an
inverted
index.
Then
again,
you
have
to
learn
when
you
have
to
do
that,
but
you
can
at
least
create
the
secondary
next
now,
let's
get
to
inboxes,
which
which
are
the
I
don't
even
know
when
I'm
supposed
to
stop
so
anyway.
A
So
inboxes
are
the
more
interesting
part,
and
what
we
want
here
is
that
for
each
user
we
want
to
store
the
email
you
receive
in
chronological
order,
because
that's
what
you
want
to
show
your
user
is
inboxes
now
for
this
application,
and
that's
where
you
need
to
know
what
you're
doing
for
this
application.
I
I
will
say
that
I'll
need
to
for
to
display
the
inbox.
What
I
need
for
each
of
those
email
is
the
subject
and
the
sender
and
recipients
names
and
email,
okay.
A
So,
for
example,
what
I
mean
here
is
that
I
don't
need
when
I
request
the
inbox
of
a
user.
I
don't
need
the
profile
picture
of
my
sender,
for
example.
Some
application
may
need
to
and
they
may
need
to
denormalize
that
part,
but
in
that
case
I
will
denormalize
on
the
those
parts.
I
choose
that
it's
enough
right.
So
if
you
want
to
do
that,
a
remark
is
that
in
a
traditional
rdbms
you
know
sql
data
store,
you
don't
need
anything,
you
have
your
store,
you
have
your
emails,
you
have
your
users.
A
Well,
you
can
join
them
and
with
the
right
condition,
you
can
get
your
inbox
now.
I
don't
want
to
it
won't
scale.
Of
course,
if
you
have
millions
of
users
and
billions
of
emails,
no,
I
don't
want
to
pretend
that
you
would
necessarily
do
that
and
there's
no
other
techniques
in
rdbms.
You
can
denormalize
in
a
dbms.
A
But
my
point
is
that
in
cassandra
you
don't
really
have
a
choice
here.
The
only
reasonable
way
to
to
make
it
work
is
to
denormalize,
and
what
we
mean
by
the
numerators
is.
The
normalizing
here
is
just
to
basically
make
sure
we
pre-compute
the
result
of
the
query.
Give
me
an
inbox
and
and
and
we
want
that,
the
normalization
to
have
the
two
property
we
talked
about,
which
is
we
need
to
be
able
to
calculate
all
the
inbox
for
one
inbox.
A
We
need
all
the
emails
to
be
on
one
node,
because
that's
the
only
way
it
will
be
efficient
to
query
an
inbox
and
the
other
one
is
that
for
an
inbox.
I
want
all
the
emails
to
be
on
this
in
sorted
order.
That
way,
I
can
query
them
exactly.
Oh,
I
want
to
display
them
and
again
that's
what
you
want
when
you
model
with
cassandra
and
that's
really
typically,
the
time
series
kind
of
stuff
that
you
know,
casana
is
well
known
to
do.
A
Well,
it
maps
very
well
to
cassandra,
because
customer
always
to
do
that
and
to
do
query
efficiently.
How
does
it
work
in
cqr?
You
will
create
a
table,
that's
called
inboxes
or
whatever,
and
it
will
store
the
email
of
the
inbox.
So
the
first
thing
is
that
an
email
in
an
inbox
will
be
identified
by
the
user
id
basically
which
inbox
it
is.
Each
each
user
has
an
inbox
if
I,
even
if
a
user
could
have
different
inboxes,
I
probably
would
need
something
else
here.
A
But
then
I
want
to
denormalize
some
parts.
So
that's
the
demise
part
and
with
every
input
you
with
every
email
in
an
inbox,
I
will
store
well
the
sender,
email
and
in
that
case
that's
a
text,
because
I
will
actually
write
the
name
of
the
guy
and
his
email.
I
could
store
both
of
them
in
two
column,
but
I
I'll
use
one
here
and
I
will
have
the
email
also
names
and
emails
of
the
recipients
that
will
be
a
set
of
text.
Then
I
will
have
the
subject
and
well.
A
The
one
thing
I
probably
need
is
that
in
an
inbox
you
want
to
display
messages
that
have
been
read
differently
from
the
one
that
hasn't
been.
So
I
will
have
an
israel
boolean
here
and
when,
when
I
insert
a
new
email
in
an
inbox,
this
will
be
false
and
whenever
the
user
click
on
the
email
to
say
to
read
it,
we'll
just
change
that
will
update
that
value
here
right
now.
A
The
thing
that
make
it
work
secure
is
that
again
that
primary
key
here
as
additional
meaning
is
cql
compared
to
sql.
It
is
a
primary
key
right.
It
identifies
myro
uniquely,
but
on
top
of
that,
the
first
element
of
my
primary
key
is
my
partition.
Key,
we'll
already
set
that
we've
said
that
the
partition
key
is
what
pretty
much
decide
on
which
node
the
row
will
end
up.
So
because
my
partition
key
is
my
user
id.
A
In
that
case,
all
the
email
for
a
given
inbox
will
be
on
the
same
note
for
a
given
user
right.
That's
what
I
wanted!
That's
what
will
make
fetching
an
inbox
efficient,
and
the
second
part
of
my
primary
key
here
is
what
we
call
the
clustering
column,
actually
three
columns,
because
you
can
have
more
than
that.
So
if
you
have,
if
you
have
three
elements,
the
first
one
is
the
partition
key
and
the
the
rest
is
what
we
call
the
partition
columns.
A
In
that
case,
I
only
have
one
so
the
partition
columns
tell
me
that,
within
the
same
partition
so
for
the
same
value
of
the
partition
keys,
the
cql3
rows
will
be
physically
physically
ordered
following
those
those
clustering
columns.
Okay,
in
that
case,
that's
the
email
id
the
email
id
is
the
time
uid
and
the
time
uid
in
customer,
the
sort
by
the
timestamp
that
the
times
the
time
uid
actually
contain.
What
that
means
is
that
for
a
given
user,
all
my
email
will
be
sorted
by
their
creation
time,
which
is
exactly
what
I
want.
A
The
last
small
detail
is
that
in
real
life
you
you
want
to
display
emails
in
reverse,
chronological
order,
so
those
that
were
in
patrick's
presentation.
I
see
a
secret
source
or
whatever.
So
anyway,
you
will
generally
query
emails
in
reverse
order.
We
want
the
more
recent
first
and
then
reverse
order.
So
to
do
that
so
well,
we
don't
need
anything
to
make
that
happen,
but
because
we
will
we
will
query
them
in
reverse
order.
We
can
we
want
to
add
that
option
here
and
that
option
here
says
to
cassandra.
A
I
will
query
my
email
in
descending
order,
most
of
the
time
so
optimize
for
that
I
can
still
query
my
email
in
ascending
order.
I
can
do
it,
but
it
will
slightly
be
slightly
less
efficient
that
in
descending
order,
because,
basically
I
will
do
backwards
backward
six
on
the
desk
because
it
will
on
this
will
store
it
in
descending
order.
Okay,
so
with
that
model,
I
can
do
queries
like
get
me
all
the
emails
for
a
given
user
that
are
older
than
january
1st
of
this
year,
and
I
want
them
in
reverse.
A
Chronological
order,
the
more
recent
first
and
oh,
I
do
that.
Well,
I
query
I
do
a
select,
I
will.
You
know,
grab
my
email
id
here.
I
have
a
an
nd
sql3
method
that
extracts
the
timestamp
from
the
email
id.
So
that's
mostly
for
displaying
the
actual
date
in
a
human
readable
way
here
and
then
I
will
have
the
sender,
email,
recipient,
email.
A
Subject
is
read
and
I
will
grab
it
in
my
inbox
for
my
user
and
I
want
all
those
from
for
which
the
email
id
is
greater
than
first
of
january,
but
email,
your
email
ids
are
time
uid.
So
I
need
to
compare
it
to
time
uid.
So
that's
why
I
have
this
function
here
that
computing,
the
smallest
time
uid
that
have
this
time
stamp
component
right.
A
So
it's
called
mean
time
uid,
because
for
a
given
timestamp
there
there
is
multiple
time
uid
that
can
have
the
same
timestamp,
so
you
can
generate
the
minimum
and
of
course,
the
maximum,
depending
on
what
you
want
to
do.
In
that
case,
what
that
means
is
that
I
will,
I
will
include
those
that
are
that
have
been
done
on
january.
First,
basically,
okay,
and
I
will
have
something
like
that.
A
Right
and
that's
well,
that's
pretty
much
secure
three!
Now
in
that
inbox
cases
in
practice,
you
will
have
an
additional
problem
that
is
generally
when
known
to
people
that
have
done
time
series
in
cassandra,
which
is
what,
if
that
inbox
become
too
big
right.
We
are
storing
of
the
email
for
a
given
user
in
the
same
box,
but
what?
A
If
a
user,
do
a
lot
of
emails
that
that
partition
can
become
very
big
and
that's
not
good
for
distribution
purposes,
and
there
is
some
some
performance
character
performance
is
concerned
too,
so
in
general,
when
when
a
partition
can
become
really
really
big,
you
want
to.
You
want
to
short
it
by
some
adapted
time,
shard
right.
A
In
that
case,
I
will
say
that
I
will
just
want
to
chart
it
in
a
year,
so
I
will
only
store
the
email
for
a
given
year
for
a
given
user
in
the
box,
but
I
will
let
different
years
be
stored
in
different
nodes,
so
that
I
can
spread
out
things
more
evenly.
I
I
could
use
a
month
or
whatever.
Now
that's
my
inbox
schema
here.
How
do
I
do
that
in
sql?
A
A
Now
I
want
to
to
say
a
quick
word
about
strife
here,
so
so
cql
uses
the
same
internal
storage
and
thrift
right.
It's
not
build
under
the
strife,
but
it's
built
over
the
storage
engine,
but
swiftly
exposes,
like
the
storage
engine
api
pretty
directly
right,
but
at
the
end
of
the
day
the
data
is
stored.
A
The
same
way,
it's
just
too
way
to
access
kind
of
the
same
data,
except
that
cqr
does
some
layout
thing
in
a
way
that
that
that
makes
sense
and
and
allows
to
do
more
things
more
efficiently
and
more
easily
right.
So
in
practice,
cql
can
read
your
existing
thrift
clone
families,
you
don't
need
to
migrate
or
anything,
it's
different
view,
but
I
I
don't
have
time
in
that
presentation
too
in
the
details.
So
really
what
I
would
suggest,
if
you
have
existing
street
clown
family,
is
that
fire
up
sql
sh.
A
It's
our
share
for
secure
just
log
into
your
key
space
and
do
a
describe
of
your
clone
family
right.
It
will
show
you
the
cqr
definition
for
your
existing
strifeclon
family
and
then
do
a
select
star
and
put
a
limit
because
you
probably
have
an
existing
strifecon
family
that
has
a
lot
of
data
in
it,
so
just
limit
for
what
something
reasonable
and
they
look
at
it.
And
my
guess
is
that,
most
of
the
time
it
will
make
sense.
A
Oh
cqr
actually
show
your
existing
strip
conformity
if
you
do
like
really
weird
stuff
with
thrift
or
if
you
store
in
thrift
that
are
like
only
like
binary
data.
Well,
that
may
be
harder
to
read,
obviously,
but
in
general
that
should
make
sense.
I
will
mention
here
that
you
want
the
double
quotes
and
the
reason
is
that
in
three
the
key
space
names
and
column
names,
they
are
case
sensitive
in
cql3
by
default.
They
aren't
so
you
need
to
add
the
double
quotes
to
make
them
case
sensitive
right.
A
We
don't
expose
the
secure
three
table
when
you
do
a
describing
shift
right,
because
we
would
have
to
add
stuff
that
that
are
not
there
for
the
other
tables.
So
in
practice
you
have
to
know
how
things
are
layout
to
pair
them.
So
you
can
actually
do
the
query.
You
can
fetch
the
data
from
thrift
and
insert
data
and
secure
out
the
table,
but
it's
a
little
bit
more
advanced.
A
You
can
query
like
you
can
query
the
data,
those
secure
authenticate
data
in
the
system
table
so
those
those
metadata
you
can
actually
fetch
them
from
the
qr
by
querying
the
system
tables.
But
then
you
have
to
kind
of
manually.
You
know
know
what
you
do
in
thrift.
Okay,
so
that's
unfortunate,
but
the
point
is
that
cql
is
really
meant
to
be
an
alternative
to
thrift.
It's
not
meant
to
complement
it,
so
we
we
don't.
We
don't
meant
it
to
be.
A
We
don't
mean
to
you
to
mean
for
you
to
actually
use
both
thrift
and
secular
at
the
same
time
right.
So
that's
why
we
agree
that
that
part
is,
is
kind
of
not
ideal
and
we're
sorry,
we
can
make
it
much
better,
but
we
have
prone
eye
compatibility,
but
really,
at
the
end
of
the
day,
you're
not
supposed
to
do
both
at
the
same
time
right.
So,
if
you
want
to
you
think
you
are
well
make
sure
you
can
access
your
click
on
family.
As
you
want
migrate,
you
don't
have
to
do
it
right.
A
If
it's
working,
you
don't
have
to
do
it.
If
you're
happy
with
strife,
then
why
not?
I
don't
know
why
you
would
be,
but
if
you
migrate
to
cqr
migrate
to
secure
and
then
you
know
use
that,
but
don't
try
to
use
both
at
the
time.
It
won't
be
very,
very
easy.
Now
I
don't
have
time
to
use
into
a
lot
of
detail
on
how
this
dcq
of
our
layout
on
top
of
the
storage
engine,
but
there
is,
we
we've
done
a
bunch
of
blogs
on
how
that
works.
So
I
did.
A
I
did
a
blog
explicitly
on.
You
know
how?
Oh,
how
does
your
strife
basically
what's
the
result
of
that
for
typical
thrift
call
families
right.
So
I
have
a
blog
that
explained
that,
and
you
know
jonathan
did
a
blog
post
also,
you
know
to
show
how
the
wide
rows
actually
translate
to
cqr,
but
also
obvious.
Hopefully
it's
obvious
that
you
know
the
cqr.
A
It
does
expose
you
all
you
want
to
do
with
white
rows.
You
can
do
all
the
sorting,
the
the
same
node,
sorting
that
you
do
in
thrift.
It's
just
not
called
it's
not
called
wide
rows.
It's
called
have
a
clustering
column,
basically
for
your
table
and
you
have
a
white
row
in
the
three
sensing
term,
all
right
very
quickly.
I
don't
know
if
I'm
late
until
when
is
my
presentation
for
then
okay
fair
enough,
so
I
want
to
very
quickly.
A
You
know
mention
the
nash
protocol
because
it
complements
cql3,
in
my
opinion,
so
initially
when
we
introduced
the
first
edition
of
cql3
and
that's
actually
still
true
in
one
two:
we
needed
a
transport
because
sql3
is
a
query
languages,
so
you
need
to
ship
that
sequel
that
query
string
to
the
server
and
then
you
need
to
ship
back
the
result
set
to
the
user.
So
what
do
you
use
for
that?
Initially
we
reduce
thrift
and
what
I
I
don't
I
don't
mean
by
that
cqr
was
implemented
after
the
thrift.
A
A
Basically,
and
that's
what
we've
done
in
one
two
and
in
one
two,
we
have
what
we
call
the
native
protocol,
so
the
native
polka
is
really
just
a
binary
transporter
for
cql3.
So
there
is
a
spec
in
the
customer
source
somewhere
that
you
can
implement
and
you
can
build
your
own
driver
for
the
native
protocol
that
you
stick
out
through
and
that
protocol
has
the
following
properties.
The
first
one
is
it's
fully
asynchronous,
so
you
can
have
multiple
queries
and
the
same
connection.
The
goal
here
is
you
have
a
large
cluster.
A
You
don't
want
to
create
a
lot
of
connection
from
every
client
to
every
node
in
the
cluster,
so
you
want
to
use
less
connection,
but
multi
still
want
to
do
multiple
queries
in
the
same
connection
and
the
other
one.
The
things
that
we
couldn't
do
with
respiratory,
because
risk
is
really
air
pc
based
is
that
we
have
several
notification.
A
I
need
to
say
that
so
far,
the
only
things
that
we
support
is
what
I
call
generic
cluster
notification.
So
the
notification
with
that
we
have
is
like
a
new
node
join
the
cluster
and
we
send
a
notification
or
that
node
is
dead
and
we
send
you
a
notification,
because
cassandra
knows
that
when
you
not
die,
ozer
knows
learn
about
it,
so
they
can
actually
inform
the
the
client.
A
So,
as
a
end
user,
you
probably
don't
care,
but
for
the
the
driver
that
that's
actually
that
you
will
be
using
that's
very
useful,
because
it's
loaded
to
that
you
know
your
cluster
grows.
You
don't
have
to
go
and
change
your
client
driver
and
add
a
new
ip
address
and
the
new
customers
to
use
and
before
to
do
that
before
you
had
to
do
polling
basically,
and
now
we
have
something
kind
of
more
modern
and
we
don't
yet
we
don't
do
things
like
as
a
user.
A
I
can
ask
for
a
certain
notification
when
some
data
changes,
but
at
least
I
mean
I
don't
know,
if
we'll
do
it,
but
we
can,
we
can
do
it
if
we
want,
we
haven't
yet
decided.
If
we
want
to
do
it,
but
at
least
we
have
the
tools
to
make
it,
and
the
last
point
is
that
it's
really
kind
of
made
for
ctl3,
so
it's
kind
of
optimized
for
sql
three
number
of
ways
so
moving
forward.
It's
it's
it's
it.
A
Now,
if
you
want
to
know
more
about
what
a
driver
that
uses
dynamic
protocol,
look
like
you
want
to
stay
in
that
room
after
my
talk
and
there's
a
talkback,
mikhail
figure
and
patrick
mcfadden
on
the
datastax
drivers
and
you'll
show
that
looks
now
what
next
for
cqr
well.
The
first
thing
is
that
what
next
forecaster
to
zero
the
customer
to
zero
is
coming
next
month
at
the
end
of
next
month.
The
first
thing
we
have
is
that
we
have
syntax
for
the
new
stuff,
so
we
do
cass
in
in
cql3.
A
A
A
Well
again,
the
the
you
have
to
write
java
code
to
the
trigger
so
far
will
change
that
eventually,
artists
make
the
interface
better
but
from
the
secure
point
of
view
just
create
trigger
whatever
on
some
table,
then
we
have
a
few
things
that
that
we
couldn't
put-
or
we
decided
not
to
put
in
a
minor
releases.
You
don't
want
to
that.
Kasana
2
0
will
have
so
the
one
is.
A
There
was
a
few
stuff
that
in
one
two
you
cannot
prepare.
You
cannot
put
a
bind
marker
for
some
of
the
things
and
those
things
are
the
timestamp,
even
though
in
sequel,
3
should
probably
just
let
cqs
repeat
the
timestamp
for
you,
but
the
ttl
and
the
select
limits
you
couldn't
put
a
bind
marker
and
just
execute
it.
A
Well,
whatever
value
you
can
you
want
it
so
that
that
works
into
zero,
that
that
one
is
primary
key
column
second
indexes
in
customer
1.2,
you
can
create
a
segment
index
on
a
column
that
is
not
part
of
your
primarity,
but
you
cannot
create
a
second
index
on
a
column
that
is
part
of
the
primary
key
in
2
0.
You
will
be
able
to
do
it
so
that
sometimes
that
can
be
useful.
A
You
want
to
create
a
an
index
on
a
clustering
column
typically
and
the
last
one
is
we
support,
altair
drop
that
allows
to
drop
sql
three
columns.
You
know
yeah,
I
wouldn't
get
there,
but
we
couldn't
do
that
in
one
two.
We
also
have
a
few
changes
that
are
kind
of
nice
for
the
niger
protocol,
so
we
actually
have
a
version.
Two
of
the
natural
protocol
in
castron20,
so
casanova
200,
will
support
the
version
one
of
the
protocol,
but
it
will
also
support
that
version
too
that
those
new
feature
the
first
one.
A
Is
it's
a
prepare
and
execute
messages?
So
sometimes
you
don't
want
to
prepare
a
query
because
you
will
execute
it
only
once,
but
you
still.
Maybe
you
have
blob
data
to
insert
and
you
don't
want
to
sterilize
it
to
strength.
So
you
want
to
some
send
a
pre,
a
query
with
bind
markers
and
the
values
and
just
have
it
executed
without
doing
a
round
trip
of
preparing
it.
So
we
have
that
in
version
two.
A
A
We
also
switched
to
ssl
certification
because,
honestly,
the
identification
of
version-
one
is
kind
of
crappy,
so
we
have
something
that's
more
standard
and
the
last
one
automatic
automatic
query
paging
in
swift
and
so
far
in
cqr.
If
you
have
a
query
that
can
give
you
a
lot
of
results,
you
want
to
page
it
just
because
otherwise
you'll
own
either
a
client
side
or
server
side
or
whatever
right
so
with
that
version
of
the
protocol
we'll
do
that
pretty
much
automatically
server
side
right.
A
So
the
result
is
that
with
your
client,
you'll
be
able
to
do
a
select
store
on
everything
and
you'll
be
able
to
read
all
your
database.
If
you
want,
it
will
take
a
lot
of
time
and
that's
probably
done,
but
you
will
do
it
without
ooming,
at
least
so
that's
cool
and
that's
what
after
customer
2
0
well
really.
But
what
we're
going
to
do
is
to
continue
to
improve
that
user
experience
to
make
it
easy
to
do
good
data
modeling
to
promote
the
good
things.
A
A
We
know
everyone
knows
sql
want
to
make
it
easy
to
be
productive,
but
what
we
care
about
is
cassandra,
but
more
specifically,
there's
a
few
stuff
that
I
personally
want
to
work
with,
like
storage
engine
optimization,
so
because
secure
three
layouts
thing
in
a
way
that
we
we
know
that
we
control
we
can
do
actual
optimization
based
on
that
and
then
the
one
thing
you
cannot
secondary
index.
Even
in
two
zero
is
the
collection
we
don't
have
so
many
index.
A
Similarly
index
and
collections,
we
will
add
it,
but
it
will
come
after
to
zero.
Unfortunately,
and
we
we've
discussed
doing
aggregation
within
a
partition
because
we
could
do
that
fairly
efficiently
at
the
end
of
the
day.
So
we'll
probably
do
that
at
some
point
and
then
there's
one
I
want
to
do.
Is
that
make
it
easier
to
create
like
user-defined
type,
that
are
kind
of
tuples
in
psychology?
I
think
it
would
be
useful,
especially
with
collection,
but
more
more
on
that
another
time.
A
B
A
A
That's
what's
a
good
way
to
do
right,
it's
the
timestamp
or
whatever,
and
in
sql3
we
just
show
you
that
value
as
a
value,
because
that's
the
value.
So
that's
email.
Here
I
don't
have
my
row.
So
it's
one
partition
here
and
my
email
id
will
be
internally,
my
my
my
column
name.
So
now
the
thing
is
for
a
given
forgiven
call
for
given
clustering
column.
A
I
can
have
multiple
values
here
right
for
for
an
email
I
can
store
multiple
stuff
and
the
way
it
works
is
that
the
actual
column
name
with
a
composite
where
the
kind
of
first
element
will
be
this
and
the
other
one
will
identify
what
the
actual
you
know,
things
that
so
a
secular
three
row
is
a
slice
of
internal
column
internally
right
and
that's
kind
of
what
you
would
have
done
with
thrift.
If
you
do
it
right,
because
here
right,
you
need
to
be
able
to
update
that
independently
of
the
rest.
A
A
A
The
native
protocol
specifications
tells
you
execute,
is
a
strain,
a
consistency,
consensus,
consistency,
level
right,
because
it's
kind
of
the
consistency
level
is
kind
of
what
it
it
influenced
the
operation
right,
not
really
what
you
store
in
disk,
because
you
start
the
same
thing:
it's
when
you
actually
get
back
the
answer
to
the
clients,
so
we
figure
it's
more
related
to
kind
of
the
it's
external
to
the
actual
operation.
Anyway,
we
made
that
choice.
A
A
That's
why
I
mean
that's
why
in
the
like
java
driver,
if
you
look
at
the
java
drive
sql
3
the
api
kind
of
look
like
gdbc
in
a
way
I
mean
it's
not
super
different,
but
customer
is
different,
so
we
wanted
something
that's
different
and
we
will
probably
do
a
gdbc
layer
for
compatibility's
sake,
but
if
you
really
do
again,
if
you're
the
customer
you're
not
doing
sql,
so
you
should
probably
use
something
that's
adapted
to
them.
Oh,
it's
asking
what
questions.
A
So
we
probably
won't
do
it
that
way.
What
I
want
to
do
is
that
the
storage-
oh
yeah,
sorry,
so
the
question
was
because
here,
like
email
id
is
really
kind
of
the
metadata
actual
name.
Why
not
do
that
for
the
other
columns
so
that
we
we
can
have
meaningful
names
here,
but
internally
short
names
for
storage
reasons
right
and
the
way
we
want
to
do
it
is
that
that's
the
storage
engine
optimization
I
was
talking
about.
A
We
don't
want
you
to
actually
what's
the
point
of
having
you
declaring
the
the
aliases
you've
you've,
given
us
your
columns,
so
we
can
you
we
can
create
that
aliases
internally,
and
we
will
do
that.
Basically,
yes,
we
will
do
that,
but
behind
the
scene
will
optimize
internally,
but
we
do
have
aliases
support
for
select.
A
So
that
here
that's
not
really
a
column
internally,
that's,
okay,
that's
email!
Id
is
not
storage,
just
metadata,
and
that
will
end
up
being
the
column
names,
but
that
will
be
store
as
part
of
the
composite
name
of
the
column
internally,
and
that
will
be
the
value
of
the
internal
column
right.
So
it's
allowed
that
use
the
composite
type,
which
is
what
we
tell
you
to
do
in
swift
anyway
right-
and
I
think
I
have
to
stop
here
but
I'll
be
outside.
Thank
you.