►
Description
About Web Python User Group
This time around, we will have the pleasure of hearing from Tyler Hobbs: Python developer at DataStax, Cassandra wizard, and all 'round good fellow.
He will be showing us how to use Cassandra in the context of Python and Django. We'll start off with an introduction to the Python driver (which he wrote, and which recently received its 1.0 update!), and then we will move on to Twissandra, which is an example Django app showing how this all gets implemented.
As always we will meet in the Capital Factory in Downtown Austin at 7 PM. Refreshments and Tacos will be generously provided by Indeed.com: "One search. All jobs."
Afterwards we will continue to talk about Python on the web at a nearby watering hole
About Capital Factory
Capital Factory is the entrepreneurial center of gravity in Austin, Texas. Located in the middle of downtown, Capital Factory has 50,000 square feet full of startups and entrepreneurs. Take classes to learn the skills that startups need, attend meet ups to find a co-founder, rent a desk for your startup or apply for funding and mentorship in the Incubator.
A
You
guys
doing
that.
Yet
no
okay,
I
didn't
expect
so
how
many
y'all
know
like
a
fair
amount
about
Cassandra
one
person,
perfect,
okay,
so
I
kind
of
assumed.
That
would
be
the
case.
So
I
started
out
at
a
pretty
low
level
here
with
Cassandra.
So
folk
overleveled
introductory
details,
so
Cassandra
was
first
started
at
Facebook.
They
open
sourced
it
about
five
years
ago
and
most
of
the
early
users
were
kind
of
hip
web
companies.
Dag
was
a
big
early
user.
A
Instead,
we've
been
doing
most
of
the
development
on
Cassandra,
but
all
the
contributions
still
come
from
from
the
community,
especially
from
companies
like
Netflix,
who
are
new
juicers
at
Cassandra
they've
migrated
their
entire
infrastructure
away
from
Oracle
tickets
and
wrote
at
the
same
time
that
they
they
moved
from
a
physical
data
center
into
the
Amazon
AWS
and
since
then,
they've
been
a
lot
of
a
lot
of
news
and
read.
It's
really
expanded
into
many.
Many
different
of
segments
got
a
lot
of
telecom
companies,
financial
companies,
government
agencies.
A
A
So
control
is
like
all
tools,
it's
really
good
at
some
things,
and
it
also
has
its
weaknesses,
I'm,
going
to
say
that
it's
a
perfectly
perfect
database
for
every
use
case.
At
this
point,
we're
certainly
working
to
expand
the
points
where
it's
weak
right
now,
but
it
definitely
has
its
drinks.
So
I'm
gonna
talk
a
little
bit
about
so
kind
of
scenarios
where
you
wouldn't
use
Cassandra
I'm,
going
to
use
a
few
tweak
users
of
Cassandra
as
examples
of
that's
kind
of
those
nice
features.
A
So
one
of
one
big
news:
our
presenter
now
is
an
eBay
and
they
use
it
for
a
few
different
patterns,
but
one
of
the
main
use
cases
they
have
is
this
time
series
data
you'll
see
this
again
then
again
and
Cassandra
usage
time
series
data
is
basically
anything
where
you
want
to
end
up
doing
something
like
select
star
where
dates
falls
in
this
range
or
give
me
the
latest
100
events
that
happened,
anything
where
you're
working
with
dates,
you're
interested
in
sorting
things
by
the
time.
Something
like
that.
So
even
you
also
uses
Cassandra.
A
The
big
part
of
the
reason
is
its
multi
data
center
support.
It's
very
much
I
think
best-in-class.
It
turns
it
the
way
that
it
behaves
in
a
multi
data
center
environments.
You
get
a
lot
of
flexibility
and
how
you
handle
say
failures
of
an
entire
data
center.
Or
how
do
you
wonder
if
you
want
to
wait
for
synchronous,
replication
across
data
centers
or
do
something
more
asynchronous
a
lot
of
good
options
there?
A
That's
definitely
a
big
reason,
where
our
reason
why
eBay
is
using
Cassandra
and
of
course
it
doesn't
have
to
be
the
cloud
hours
just
finding
on
physical
hardware,
but
it's
certainly
a
lot
because
in
your
users
do
use
it
in
Amazon
ec2
in
particular.
So
it's
pretty
well
tuned
for
running
in
that
environment.
A
Another
reason
that
eBay
uses
cassandra
is
it
has
support
for
distributed
counters,
so
distributed
counters
are
actually
something.
That's
it's
very
difficult.
There
are
a
lot
of
different
implementations
of
the
true
beauty
counters
and
they
all
sort
of
have
their
sense
of
trade-offs.
Cassandra's
original
implementation
does
have
some
flaws.
We
just
improved
it
for
Cassandra
2.1,
which
is
currently
in
beta,
but
if
you're
looking
to
count
things
that
are
very,
very
high
throughput
over,
say
millions
of
different
counters,
this
is
I,
think
Cassandra
kind
of
does
it
that
it's
hard
to
find
anywhere
else
Twitter.
A
Also
it's
a
heavy
user
of
the
distributed
counters
and
then
a
new
support.
So
if
you
want
to
run
MapReduce
jobs
to
do
some
sort
of
large
analytics
on
your
data,
it's
important
that
that
be
fairly
painless
and
that
you
also
don't
impact
your
production
cluster
right.
So
so
Cassandra
is
kind
of
built
in
replication.
That
makes
it
very
easy
to
run
a
MapReduce
job
against
some
of
the
data,
your
Cassandra
poster,
without
having
any
extra
ETL
steps
and
also
with
not
impacting
the
clusters
that
are
serving
your
production
application.
A
Adobe
is
also
another
big,
easier
to
see.
Indra
you'll
see
a
few
and
the
reasons
repeated
here,
but
a
little
agency.
This
is
something
Kazaam.
Just
definitely
known
for
this
is
it's
much
better
at
doing
lots
of
small
low
latency
queries
is
a
huge,
complex
queries.
It
basically
doesn't
do
big
complex
queries
at
all,
so
you
can
get
things
like
a
90%.
I
really
get
CDF
of
half
a
millisecond,
and
this
is
at
the
scale
of
somebody
like
Adobe.
A
Scalability
is
another
standards,
excellent
nap.
So,
basically,
when
you
want
to
grow
your
cluster,
you
basically
just
start
up
a
new
piece
and
your
node
and
all
the
other
nodes
automatically
know
what
data
it's
supposed
to
own.
So
they'll
do
that
for
calculation
and
then
just
stream
that
it's
the
new
node
it's
kind
of
magically
in
the
cluster.
It's
not
a
difficult
operation
at
all,
and
the
nice
thing
about
the
way
the
Cassandra
scales
is
that
is
it
scales
linearly,
both
in
reads
performance
and
in
write
performance,
so
with
most
master
slave
systems.
A
It's
very
easy
to
scale
reads
because
you
can
just
have
slaves.
Write,
writes
tend
to
be
more
difficult
to
scale
in
those
cases,
because
the
master
is
a
bottleneck
in
that
case,
but
with
Cassandra.
If
you
double
the
number
of
nodes,
you
get
basically
exactly
twice
the
throughput
in
terms
of
reads:
rights
and
storage
capacity,
so
it's
extremely
linearly
scalable
up
to
at
least
a
thousand
nodes,
that's
about
as
large
as
we
tested
and
tunable
consistency,
which
I'll
cover
a
little
bit
later.
Instagram
has
also
been
really
big
users
either.
Lately.
A
Mostly
and
then
just
for
the
efficiency
and
high
availability
are
the
key
points,
so
one
of
the
reasons
why
it's
extremely
good
either
has
extremely
efficient,
writes
and
get
very
good
group
without
writes
its
that
when
you
do
it
right.
Basically,
it
just
has
to
do
two
things.
One
is
to
the
right
to
commit
log
so
come
in
Kamiya
log
is
just
it's
like
a
transaction
blog
or
right
ahead
log.
In
other
databases,
it's
just
appending
to
a
file,
so
the
distance,
imaginary
syncs,
even
on
SSDs,
don't
have
to
worry
about
so
writing
notification.
A
A
So
some
of
the
things
that
we
really
focus
on
when
we're
working
on
Cassandra
scalability,
as
I
mentioned,
we
want
all
the
operations
to
scale
linearly
so
that
you
can
just
sort
of.
If
you
have
a
performance
problem,
you
can
always
add
notes
and
that
kind
of
always
works.
It's
nice
to
have
that
as
an
option
high
performance.
Obviously
ease
of
uses
is
something
that
the
designer
is
kind
of
had
a
weakness,
and
but
it's
something
that
we're
focusing
on
a
lot.
So
it
can.
A
A
A
A
It's
kind
of
been
a
work
in
progress
for
a
couple
of
years
now
for
Cassandra
is
using
a
query
language
instead
of
he
originally
guided
Cassandra
head
and
the
query.
Language
does
resemble
SQL
quite
a
bit.
It's
it's
almost
a
subset
of
SQL,
so
I'll
show
you
a
little
bit
more
about
how
it
works
in
bid,
and
these
are
just
a
nice
quotes
reporter
about
Cassandra's
resilience.
A
Things
like
tolerating
the
failure
for
an
entire
data
center
with
no
downtown,
so
here's
a
scenario
that
it's
in
your
classical
master/slave
architecture
tends
to
cause
problems
right.
So
so
the
normal
way
this
year,
you're
sort
of
scaling
your
data
down
scaling.
Your
database
would
be
to
have
some
kind
of
partitioning
scheme.
You're
writing
all
routing
all
of
your
operations
through
that
it's
selecting
which
shard
or
partition
of
your
data
you
need
to
operate
on,
and
then
you
have
a
kind
of
a
master/slave
setup
within
there
right.
A
A
This
is
just
a
bit
from
a
slide
by
army
bunker.
The
author
flask,
so
I
I,
don't
know
exactly
what
happened
to
him
here,
but
just
kind
of
a
typical
example
of
what
can
happen
and-
and
there
are
many,
this
is
actually
a
much
more
common
problem
than
people
tend
to
think
that
the
bottom
link
there
just
shows
some
recent
research
on
sort
of
how
frequent
now
network
art
engines
are
and
what
the
familiar
scenarios
were
like.
A
So
because
Sandra
has
a
different
architecture:
it's
not
master/slave,
it's
more
of
a
peer-to-peer
system,
so
there
are.
There
are
no
special
nodes
in
the
cluster
and
that's
one
of
the
ways
that
it
gets
such
great
availability.
So,
basically,
instead
of
having
sort
of
that
routing
layer
on
the
previous
slide,
any
node
in
the
Cassandra
coaster
can
figure
out
where
the
data
is
supposed
to
live.
A
So
your
client
can
contact
any
notice
and
our
cluster
to
form
our
query
and
that
node
will
do
the
calculation
and
route
it
to
be
correct,
credited
us,
so
you
can
sort
of
tolerate
in
the
sense
the
failure
of
any
arbitrary
node
with
without
any
problems,
so
the
way
that
it
splits
up
the
data
and
does
this
calculation
it
it.
Basically,
it
depends
on
the
primary
key
for
the
data
or
more
technically,
be
the
partition
key.
A
A
Basically,
each
node
in
the
cluster
owns
some
portion
of
that
range
of
that
space
for
all
the
possible
64-bit
numbers
so
gather
the
example
here
so
say:
you're
inserting
room
we're
the
primary
keys
Jim,
just
a
string
Jim
it
hashes
to
something
I,
don't
remember:
Oh
hatchets,
that's
a
5,
ee,
so
on
and
so
forth,
but
no
see
Owens
the
range
from
or
whatever
8
whatever
so
5b
falls
in
between
that
and
basically
notice.
Ee
is
the
replica
for
that
piece
of
data.
A
A
If
we
want
the
replication
factor
of
3,
so
with
a
setup
like
this,
any
of
those
three
nodes
can
go
down
and
you'll
still
be
able
to
read
your
rights,
and
they
have
that
data
depending
on
a
perimeter
that
you
specify
with
your
query.
If
you
want
to
be
able
to
tolerate
that
and
to
make
the
picture
a
little
more
confusing,
it's
not
actually
split
up
into
these
huge
ranges
in
your
horn.
They
use
much
smaller
slices,
which
are
called
virtual
movies.
A
It
just
makes
it
a
little
bit
easier
for
maintenance
operations,
so
I'll
walk
through
an
example
of
what
happens
with
it,
with
a
read
request
and
specifically
what
happens
in
the
failure
case.
So
on
a
normal
read,
the
client,
which
is
just
your
application,
sends
in
a
read
request
right,
say
he's
asking
for
a
row
where
the
primary
key
is
is
Joe.
The
coordinator
node
here
could
be
any
member
of
the
cassandra
cluster
and
it
will
run
that
hash
on
on
joe
from
the
hash.
A
D
A
There's
a
parameter
that
you
can
specify
with
queries,
call
that
consistency
level
and
and
what
the
consistency
level
says
is
basically
how
many
of
the
replicas
have
to
respond
to
consider
the
operation
and
success.
So
this
really
controls
kind
of
your
trade-off
between
availability
and
consistency
right.
So
if
you
know
that
you
have
three
replicas,
you
could
say
anywhere
from
from
one
of
them
needs
to
respond
to
all
three.
A
If
you,
if
you
say
that
you
want
I'll
free
to
respond,
obviously
they're
all
going
to
have
consistent
data
stored,
but
you
can't
tolerate
the
failure
of
any
three
of
those
nodes
right
and
likewise,
if
you
say
that
you
only
need
a
response
from
one,
you
can
tolerate
the
failure
of
two
of
the
three
nodes,
but
you
don't
have
a
strong
of
a
consistency.
Guarantee
want
to
do.
Replicas
I
may
have
newer
data
than
the
others.
So
if
you
do
another
read
at
the
consistency
level
one,
they
may
only
need
two
response
from
one
replicas.
A
A
It
will
get
back
to
results
on
both
of
those
and
then
I
will
look
to
see
which
of
the
data
is
newer
and
it
will
return
that
to
the
client
and,
if
necessary,
it
will
repair
the
replica
that
was
sort
of
a
sink
or
head
snail
data.
So
the
nice
thing
about
quorum
and
the
reason
why
it's
pretty
common
is
obviously
you
can.
A
You
can
tolerate
the
failure
of
one
of
these
three
nodes
with
no
downtime,
but
since
you're
writing
to
to
the
guarantee
two
of
the
three
and
a
reading
from
two
of
the
three
they've
guaranteed
to
be
overlap
of
one
replicas.
So
you
get
a
guarantee
that
you're
always
going
to
read
the
most
recently
written
data.
So
you
still
have
pretty
good
consistency,
guarantees
they're,
strong
consistency,
but
you
also
have
some
amount
of
flexibility
in
how
you
can
handle
the
failures
of
notices.
A
So
there's
a
variety
of
consistency
levels,
the
ones
I
just
talked
about
one
corner
and
all
are
typical
and
multi
data
center
environments,
written
special
ones,
a
local
form,
just
waits
for
a
quorum
of
the
replicas
in
your
local
data
center
and
each
corner
waits
for
a
quorum
of
basically
each
of
the
data
centers.
So
in
a
multi
data
center
environment
you
can
say
you
know:
I
want
to
wait
for
a
quorum
of
the
replicas
that
are
in
my
local
data
center
to
respond.
A
But
I
don't
want
to
wait
for
the
remote
data
center
to
respond.
It's
obviously
latency
Steffie,
extremely
high
tech,
so
you
can
sort
of
get
locally
strong
consistency
and
you're
still
replicating
to
the
remote
data
center,
but
you're
not
paying
that
the
latency
penalty.
It's
a
wait
for
replication.
Today,
remote
data
center.
A
So
Cassandra
as
extremely
won't,
let
me
just
talk
about
the
seats
case.
First,
so
common
pattern,
you're
creating
users
right.
Can
you
guys
don't
see
that
hopefully
soon
so
same,
we
had
one
client.
It
wants
to
create
the
new
user
P
McFadden.
So
it's
a
run
to
select
sees
that
that
user
doesn't
exist
and
the
decides
it's
going
to
go,
go
ahead
and
create
the
user.
A
At
the
same
time,
a
second
client
starts
doing
the
same
thing
also
sees
the
user
doesn't
exist,
and
so
you
wind
up
with
both
of
them,
inserting
the
user,
the
last
right
wins
it
gets
overwritten
Cassandra
can't
distinguish
between
basically
insert
and
update,
are
the
same
thing
in
Cassandra.
It
doesn't
do
reads
before
right,
so
there's
no
sort
of
inserts
well
normally
doesn't
do
recent
for
writes.
A
So
it's
not
verifying
that
the
data
doesn't
exist
whenever
you're,
inserting
here
so
recently
in
Sandra,
had
something
called
that
we're
calling
lightweight
transactions
and
what
this
adds
is
elaborate
syntax
to
do
something
like
it
not
exists
and
remember.
This
is
in
a
distributed
database
with
with
multiple
replicas.
So
it's
not
just
a
simple
kind
of
local
transaction
and
it
actually
is
a
little
bit
more
complex
than
that,
but
it's
a
basically
just
allows
you
to
do
if
not
exists
and
if
it
does
happen
to
exist,
it'll
be
nice
and
return.
A
The
row
that
you
expect
it
to
not
exist.
Just
because
that's
a
that's
a
frequent
behavior
anyways.
So
the
way
that
it
does
these
lightweight
transactions
is
through
and
algorithm
coal
taxes,
which
is
a
distributed.
Consensus
algorithm
it's
quorum
based,
so
you
still
have
some
some
tolerance
of
failure.
A
Replicas
all
you
have
to
have
is
a
quorum
of
the
replicas
for
the
data
you're
performing
a
transaction
on
for
the
transaction
to
work
and
if
you're
interested
in
taxes-
or
you
don't
know
about
it,
it's
a
pretty
cool
stuff,
just
check
out
a
paper
pulp
access
made
simple
the
downside
of
this.
Since
it's
running
this
whole
consensus
business
before
it's
actually
mutating
the
data,
it's
a
lot
more
expensive.
So
you
really
want
to
only
use
this
for
a
very
small
portion
of
your
operations
right.
You
shouldn't
be
doing
this
for
every
operation.
A
It's
only
for
cases
like
that
that
user
creation,
where
you
really
need
some
level
of
transactions
and
there's
not
a
good
way
to
do
it
with
just
normal
eventual
consistency
by
and
large,
you
should
expect
to
work
with
eventual
consistency
when
you're
using
to
Sandra
and
it's
not
as
scary
of
a
king
is
a
lot
of
people.
Think
at
first
there's
a
really
good
most
by
christos.
A
B
A
So
when
you
add
a
note,
there's
there's
a
few
ways
that
it
propagates
one
is
says:
the
driver
will
basically
register
for
notifications
from
the
cluster
about
changes
to
it.
So
if
a
node
leaves
or
new
no
is
added
that
information
won't
get
pushed
to
the
driver,
so
it
can
update
its
sub
connections
or
open
new
ones
in
here
then
the
other
is
this:
there's
a
system
table,
they
just
list
all
the
nodes
in
the
cluster
and
so
periodically.
E
A
They
can
all
the
notes
and
looked
at
their
data,
see
one
of
their
data
falls
within
that
token
range
or
that
hash
range
and
then
they'll
just
stream
those
those
chunks
of
data.
Let's
do
that
note
and
once
that
streaming
process
is
complete,
that
that
new
node
becomes
an
actual
owner
for
that
range,
that
hash
range
and
whatever
nodes
used
to
own,
that
portion
flips
worth
got
pushed
out
by
the
new
node.
A
F
A
I,
don't
want
to
go
through
like
a
thousand
slides
again
to
find
it
quits.
So
remember
that
I
mentioned
that
you
typically
have
a
replication
factor:
three,
that's
pretty
common.
So
so
every
piece
of
data
is
stored
across
three
nodes.
So
say
you
have
a
hardware
failure
I'm
one
of
those
three
replicas.
A
What
you'll
do
is
you
basically
run
an
operation
that
lets
the
cluster,
know
that
the
snows
down
and
it's
not
coming
back
and
then
basically
to
repair
the
data?
So
you
only
have
to
two
or
three
replicas
at
this
point,
so
those
those
two
replicas
will
stream
that
up
to
a
third
node
in
order
to
have
a
third
replicas
there,
so
basically
you're
taking
you're,
taking
the
dead
node
out
of
that
kind
of
hash
ring
and
and
whatever
other
nodes
happen
to
be
its
neighbors
they're.
They
be
company
owner
sports.
A
A
Sort
of
so
so
when
I
say
replication
factor
all
that
I
mean
is
that
there's
that
many
copies
of
every
row
in
the
cluster
on
different
nodes,
so
replication
factor
3,
means
that
there
are
three
distinct
copies
on
on
different
notes.
So
yeah
the
durability
is
a
concern
there.
That's
part
of
the
reason
why
you
don't
want
to
use
a
replication
factor
of
one
right
and
people
only
got
one
copy
of
your
piece
of
data.
F
A
It
depends
a
lot
on
the
size
of
your
nodes,
so
some
people
run
those
with
run
them
quite
small
I'd
say
like
50
gigabyte
each
other
people
really
push
it
into
multiple
terabytes
per
node,
so
some
standard
can
handle
multiple
terabytes
per
node.
But
it's
operations
like
this,
where
it
kind
of
bites
you
a
little
bit.
It
takes
a
while
to
stream
a
terabyte
of
data,
so
by
default
Cassandra
throttles
the
streaming,
because
you
don't,
whenever
you're,
adding
a
node
to
the
cluster,
you
don't
want
to
put
too
much
strain
on
the
existing.
A
A
The
number
of
nodes
you'll
have
in
your
cluster,
usually
the
minimum
is
3,
and
the
reason
is
that
that
allows
you
to
use
a
replication
factor
of
3
and
do
quorum.
Consistency
level
reads
and
writes
that's
a
very
common
thing.
Usually
you
don't
see
anybody
running
production
foster
with
less
than
three
notes.
A
A
That's
sort
of
what
suits
most
businesses
for
the
large
part.
How
many
nodes
you
need
depends
on
what
kind
of
read
through
what
do
you
need
as
I
talked
about
briefly
right,
sir
extreme
achievement
Cassandra
reads
a
little
bit
more
expensive
because
they
can
involve
some
random
I/o
on
the
disk,
so
you
do
tend
to
optimize
for
reads,
but
the
reads
are:
are
kind
of
near
your
limiting
factor
Cassandra
and
those
tend
to
dictate
how
many.
F
A
So
you're
talking
about
sort
of
like
an
elastic
scaling
situation,
I
think
they've
been
a
few
people
that
have
kind
of
tried
that
it
is
a
little
bit
easier.
Now
I've
talked
about
virtual
notes
for
just
a
second
there,
where,
instead
of
being
a
huge
big
container
contiguous
range
for
each
note,
I
just
lit
up
into
little
chunks
that
doesn't
make
it
easier
to
pull
out
nodes
and
add
nodes
to
the
cluster.
A
So
it's
a
little
more
feasible
today,
but
the
cost
of
the
streaming
usually
makes
that
not
worthwhile
to
do
you
know
I'm
like
a
day-to-day
basis.
It
does
make
sense
to
do
something
like
that
perhaps
say
when
it's
gonna
be
Black
Friday
soon
we
had
a
lot
of
our
customers.
Do
that?
That's
certainly
nice,
a
lot
of
them
in
particular,
they'll
run
on
physical
hardware
for
the
most
part,
and
when
something
comes
around
like
Black
Friday
values
et
to
to
grow.
E
A
F
A
There's
actually
ways
that
you
can
get
around
storing
things
on
the
heat
so
that
that
avoids
the
garbage
collector,
and
so
so
that's
becoming
less
of
a
limitation,
as
I
mentioned
the
size
of
how
big
they
can
push
a
single
node,
how
it
has
to
do
more
with
how
many
reads
per
second,
you
want
to
support
it
and
how
efficient
those
reads
are,
and
also,
if
you
can
tolerate
the
pain
of
a
very
large
maintenance
operations.
Like
replacing
a
note
that
has
5
terabytes.
A
There's
no
limit
on
the
number
of
notes.
It's
you
know.
Some
of
the
tools
start
to
become
less
useful
and
the
high
hundreds
here
certainly
a
little
bit
adventurous.
Once
you
get
to
that
point.
But
everything's,
then
you
know
they've
been
a
debug,
so
we've
had
to
fix
for
things
to
work
at
that
scale
puts
with
those
resolved.
It
really
does
scale
linearly
at
least
up
to
about
a
thousand
words,
presumably
more,
but
but
yeah.
Nobody
nobody's
really
tested
that.
A
Yet
so
yes,
sucker
that'll
do
that
or
it
sounded
not
good
at
so
primarily
so
so
I
mentioned
it
doesn't
have
capabilities
for
very
complex
queries.
So
you
can't
just
sort
of
run
any
arbitrary,
a
sequel,
query
and
expected
to
eventually
return
a
result.
The
API
is
much
more
limited
than
that.
You
basically
have
to
make
queries
that
ask
for
a
very
specific
piece
of
data
and
I'll
show
you
a
little
bit
about
that
in
a
bit.
A
A
Better
at
if
you
know
exactly
what
kind
of
problem
you're
trying
to
solve
and
you
want
to
solve
it
very
efficiently-
that's
what
you're
saying
this
is
a
good
fit.
If
you
don't
know
that
yet
and
you're
just
trying
to
play
around
with
the
data,
that's
or
you
want
to
have
a
lot
of
flexibility
in
terms
of
how
you
query
the
data,
that's
what
you're
saying
it's
not
gonna
be
great
transactions.
A
The
lightweight
transactions
that
I
mentioned
are
sort
of
the
limit
of
presenters
transactional
capabilities.
If,
for
whatever
reason
you
need
more,
sophisticated
transactions
are
met.
Usually,
usually
you
don't
need
them
as
much
as
you
would
think.
People
are
just
so
used
to
using
transactions
that
they
not
aware
about
their
patterns
that
you
can
use,
but
that,
then,
is
something
where
they
have
highly
sort
of
a
transactional
operations.
Something
you're
gonna
have
have
to
do
a
lot
more
work
for
with
me,
Sandra.
B
A
So
not
exactly
sure
Evan
to
that
I
mean
that
the
project
itself
only
includes
the
database,
it
kind
of
ends
at
the
query.
Language,
that's
kind
of
the
most
high
level
API
to
the
project
itself,
presents
his
ideas,
usually
kind
of
extend
that
a
little
bit
more
people
like
to
try
and
integrate
it
with
things
like
for
getting
out
my
job
recurring,
work
names
now,
but
yeah,
JBoss
or
JDBC
me
JPA.
All
of
that
kind
of
stuff.
A
The
thing
is:
that's
a
lot
of
frameworks
and
tools
are
designed
with
relational
databases
in
minds,
and
they
just
it's
just
just
barely
enough
different
in
a
standard
that
they
really
can't
handle
that
difference.
So
you
won't
be
able
to
just
plug
it
into
a
lot
of
frameworks
and
go
I'll,
be
showing
a
little
bit
about
how
you
can
use
Cassandra
from
within
Django,
but
it's
not
using
the
built-in
ORM
it's
encoded
and
into
an
extent.
A
The
reason
why
our
aims
don't
work
with
Sandra
is
that
kind
of,
instead
of
it,
modeling
your
data
or
your
objects
you're
instead
modeling
your
queries,
you're
kind
of
in
a
sense
of
pre
building
the
answers
for
the
queries
that
you
care
about.
So
that's
that's
what
I
kind
of
meant
what
I
was
saying?
If
you
know
exactly
what
you
need
to
do,
it
can
do
that
very
efficiently.
It
allows
you
to
build
those
answers
in
a
very
efficient
way,
but
you
still
kind
of
have
to
know
what
the
queries
are.
A
A
B
B
A
A
D
A
So
this
is
probably
a
good
time
for
a
quick
break.
After
this
I'm
gonna
talk
a
little
bit
about
the
Python
driver
for
Cassandra
as
well,
and
then
I've
got
a
quick
example
of
projects
called
twist
Sandra.
That's
a
Twitter
clone
that
uses
Cassandra's.
It
back
ends
this
we're
going
to
show
you
a
little
bit
about
kind
of
how
you
model
your
data
for
queries
and
then
walking's
gonna,
be
talking
about.
I
can
go
to
a
session
storage,
so
everyone
like
probably
10
min
of
radio
and
that
will
get
started.
A
G
A
That's
nice
Python
driver,
that's
Apache,
License
Center
driver
I've
been
working
on
it
for
about
seven
or
eight
months
half
time.
Basically,
so
this
it's
a
pretty
complex
piece
of
machinery
just
because
it
does
have
to
distribute
the
distributed
cluster
but
like
I
mentioned.
Hopefully,
the
API
is
pretty
nice
and
should
look
for
the
most
part
pretty
familiar
so
just
opening
a
connection
to
Cassandra.
Basically,
you
can.
D
A
A
list
contact
points
just
a
few
nodes
in
the
cluster
in
a
little
bit.
Some
connections
to
those
figure
out
what
the
rest
of
the
nodes
in
the
cluster
are
and
then
it'll
automatically
connect
to
those
as
well,
and
then
you
create
a
session
which
operates
on
a
key
space,
usually
a
key
space.
It's
like
a
database,
it's
just
a
group
of
tables
and
that's
sort
of
where
you
define
your
replication
settings
for
your
data.
A
So
the
query
interface,
it
should
look
really
familiar
as
I
kind
of
I
used.
A
psycho
PG
to
is
is
one
of
my
main
references
when
working
on
this.
So
there's
a
lot
of
similarities
there,
but
yeah
you
just
wanna,
execute
you
get
back
rows
by
default.
The
rules
come
back
and
a
named
tuple.
So
if
you're
not
familiar
with
a
data
structure,
it's
pretty
handy.
It's
like
a
tuple
of
users
about
the
same
amount
of
space,
but
you
can
access
things
by
the
field
name
here
like
a
user
name
and
I
need.
A
So
this
is
just
treating
it
like
a
tuple.
Instead,
you
can
also
just
have
a
return,
a
dictionary
or
an
order
dictionary
or
some
other
structure.
If
you'd,
like
just
in
terms
of
providing
a
parameters,
should
look
very
familiar
again.
All
you
do
is
is
use
placeholders
for
sentence
or
you
can
do
the
names
style
placeholders.
This
is
exactly
the
same
as
this
psycho
PG
two
here
as
well,
and
it
automatically
does
all
the
escaping
you
don't
get.
Sequel,
injection
and
injection
is
still
a
problem
here
as
well.
A
A
Prepared
statements
are
just
a
way
to
send
a
query
to
Cassandra
it
parses
it
once
it
gives
you
back
an
ID
and
then
you
can,
whenever
you're
executing
that
query,
you
just
test
that
ID
and
the
parameters
that
you
want
to
find
for
that
query.
So
here
we're
selecting
an
account.
Our
ID
equals
some
parameter.
So
after
we've
prepared
we'll
just
reuse
it
over
and
over
again,
and
we
just
provide
the
I
T.
So
it
saves
a
lot
of
network.
A
Bandwidth,
I,
guess
and
Cassandra
doesn't
have
to
reverse
the
query
every
time.
So
any
time,
you're
executing
queries
not
multiple
times,
really
have
to
pray
the
same
as
to
the
way
to
go
so
the
driver.
This
is
something
where
it's
a
little
bit
different
for
most
database
drivers
and
including
the
older
drivers
representative,
which
none
of
you
guys
have
used
this
Cassandra,
but
it
has
really
good
support
for
asynchronous
queries.
The
reasons
for
this
kind
of
has
to
do
with
how
the
driver
uses
connections.
A
It
actually
can
multiplex
multiple
operations
over
a
single
connection,
so
you
can
have
multiple
connection.
Sorry,
multiple
operations
in
flight,
at
the
same
time
of
one
connection,
Cassandra,
can
respond
out
of
order.
It
basically
allows
the
driver
to
more
fully
utilize.
A
single
connection
get
a
lot
better
throughput
with
the
single
connection,
but
it
kind
of
requires
that
the
implementation
someone
have
been
driven
so
really
the
driver
performs
best
when
you
can
use
it
in
an
asynchronous
style,
and
it's
got
a
couple
of
ways
to
do
that.
A
The
probably
the
most
simple
way
to
do
that
has
kind
of
a
future
interface.
These
features
in
Java.
This
is
like
that
you
run
execute
async,
you
get
back
a
feature
and
then
explain
that
you
want
the
results.
Just
called
future,
not
results.
If
it
was
successful,
the
returns,
the
rows
have
failed.
The
raises
an
exception
at
that
point.
So
this
is
nice,
especially
and
I'll
show
some
examples
of
this
I
think
yeah
I
do
obviously
I'll
show
you
those
here.
C
A
So
if
you
want
to
run
some
queries
concurrently,
so
so
you
do
have
a
couple
options
say
we
need
to
select
or
get
the
info
for
a
bunch
of
users.
We
have
a
list
of
ID's,
so
one
option
is
to
run
and
select
start
some
accounts
where
ID
in
a
list
of
ID's
and
that'll
work,
just
fine,
but
it's
slightly
they've.
A
Trade-Offs
in
Cassandra
compared
to
the
style
that
I'm
using
here.
So
when
you
do
this
join
in
list,
what
basically
happens
is
the
coordinator
uses
query
and
it
breaks
down
that
query.
It's
a
sort
of
warn
query
for
each
item
and
that
in
list,
and
then
it
fans
out
the
query
to
the
actual
run
with
those
for
each
of
those
rows
and
ways
for
all
of
them
to
respond
and
then
a
response
to
the
client.
So
that
puts
a
little
bit
of
extra
load
on
the
coordinator.
It
has
to
wait
for
a
lot
more
things.
A
It's
holding
more
things
in
memory
and,
if
that's,
if
any
of
those
operations
fail,
like
save
the
replicas
for
just
one
of
those
items,
and
that
big
in
list
goes
down,
you
have
to
retry
the
entire
operation.
The
entire
operation
fails.
You
retry
the
entire
thing,
so
it
says
to
perform
force
under
failure,
so
an
alternative
that
tends
to
run
a
little
more
smoothly
with
Cassandra,
and
that
happens
to
work
really
well
with
this
asynchronous
query.
Execution
is
to
run
a
separate
query
for
each
item
in
that
list.
A
How
you
get
your
future
and
you
just
queue
up
the
futures,
so
you're
letting
these
queries
run
concurrently
and
then,
once
you
guys
secure
so
I
submitted
all
the
queries,
then
you
go
through
and
wait
for
all
of
them
to
please.
That's
basically
what's
happening
here,
we're
just
building
it
ballistic
futures
I'm,
calling
that
results
on
all
of
them
at
the
end.
So
you
do
get
about
quite
good
throughput.
A
A
So
you
can.
You
can
just
register
a
callback
function,
an
airbag
function.
You
can
also
pass
extra
arguments
to
that.
So
essentially,
whatever
the
query
completes,
it'll
automatically
call
your
your
register,
a
callback
function
with
the
results,
so
that
can
be
useful
for
a
few
things.
There
are
some
limitations
in
the
driver
around
Nance
you.
A
You
have
to
be
a
little
bit
careful
about
throttling
at
your
request,
because
you
can
kind
of
overload
that
the
driver-
it's
not
too
good,
it's
a
throttling
it
as
huge
number
of
these
requests,
if
you,
if
you
use
some
crazy
patterns,
but
it
works
pretty
well
for
lightweight
usage
and
actually
it
gets
the
best
performance
of
any
pattern
with
the
driver
I
just
because
it
keeps
everything
running
on
the
thread.
That's
running
the
event
loop.
A
So
if
you
guys
are
working
with
many
different
systems,
you
know
that
there
are
at
least
some
Python
they're,
all
single
threaded,
this
kind
of
emulates
that
same
pattern
in
terms
of
legitimate
support
for
event,
driven
systems
twisted
G
events,
those
are
in
the
works.
They
should
fit
quite
naturally
G
event
to
probably
be
the
first
one
there.
Nothing
yet,
but
shortly
we'll
have
some
some
good
support
for
this
query.
Tracing
is
something
that
this
Indra
is
awesome
at
now.
A
So,
if
you're
having
performance
problems
with
the
query,
there's
an
it's
a
distributed
database
right,
there's
a
lot
of
things
that
can
be
going
go
wrong
or
they
could
be
slowing
down
their
quarterly.
So
tracing
is
a
great
tool
for
figuring
out
exactly
where
the
slowdown
is
happening.
Basically,
you
just
send
a
flag
to
say
that
trace
the
query.
A
Cassandra
internally
does
all
this
tracing,
it
stores
the
trace
in
a
system
table
and
then
the
driver
basically
automatically
pulls
that
data
out
when
the
query
is
complete
and
you
get
a
sort
of
an
ordered
list
of
here's.
What
happened
with
the
query
with
the
timestamps
with
millisecond
resolution,
it
covers
the
coordinator,
node
and
the
replica
nodes.
So
it's
pretty
detailed.
It's
definitely
a
nice
feature.
I
can
help
blog
with
with
optimizing
queries,
I,
don't
think
I
yeah.
A
So
that's.
Basically
all
you
have
to
do
is
just
said:
trace
equals
true
and
it
should
print
out
pretty
nicely
so
I
didn't
make
too
many
more
slides
on
the
driver,
but
just
just
a
few
things,
I
will
just
mention
real
quick,
like
I
said
it
does,
handle
failure,
queries
transparently,
so
say.
If
the
coordinator
node
goes
down,
it
can
transparently
retry
the
operation
against
the
different
cord
internode
and
there's
quite
a
few
options
for
tuning
exactly
how
it
will
handle
those
types
of
failures.
A
How
we
respond
to
them
failure
scenarios,
but
the
defaults
are
pretty
nice.
It's
also
designed
to
work
with
a
little
T
data
center
environments.
So
you
can
tell
what
data
center
is
local
and
it
will
only
query
notice
the
local
data
center
unless
I
would
say
it
thinks
that
they're
all
down-
and
in
that
case
it
can
resort
to
the
multiple
Sydney
remote
data
centers.
A
I'm
just
about
to
say
something
and
then
I
forget,
but
it
can
also
do
it's
got
a
few.
Other
nice
features
that
probably
you
have
to
know
a
little
bit
more
about
the
standard
they're
important,
but
it's
so
far,
I'm
pretty
happy
with
how
it's
coming
out
so
need
questions
on
the
the
driver
and
how
it
works.
F
B
A
A
So
so,
basically,
adding
jeep
and
support
I
will
do
something
similar
that'll,
probably
be
a
little
more
invasive,
so
that'll
kind
of
break
the
API
apart
a
little
bit
more
once
we
get
the
first
major
change
in
like
that,
then
it
should
should
be
a
little
more
clear
how
to
add
support
with
something
like
a
tornado
but
yeah.
It's
definitely
kind
of
designed
to
be
a
pluggable
system
there.
That
did
remind
me
of
a
couple
things
I
wanted
to
mention.
I
want
us!
A
It's
a
doesn't
support
my
laundry
yet
actually
just
started
working
with
the
guy
yesterday
on
getting
support
for
that.
So
you
guys
need
quite
that
three
should
be
supported
soon,
yeah,
there's
that
it
does
run
pure
Python,
our
camera
I'm,
pure
Python,
which
means
the
worst
pipeline
and
iPhone.
The
nice
thing
about
PI
bi
is
that
it
has
crazy
good
performance
with
the
driver.
A
I
did
some
benchmarks
and
it
gets
two
or
three
times
the
through
quoted
of
C
Python,
which
I
was
pretty
impressed
with
I've
done
some
benchmarks
way
back
in
the
day
and
they
weren't
quite
that
good.
But
it's
getting
pretty
fast
laughs.
So
if
you
really
care
about
throughputs,
that's
pretty
pretty
sweet
combination
with
the
driver,
any
other
questions,
no.
A
It
just
started
a
branch
today,
so
this
was
using
the
kind
of
old-school
Python
driver
that
I
did
I
used
to
maintain
I
just
started,
switching
it
over
to
the
new
one
and
that's
on
the
sequel.
Three
branch:
cql
is
the
name
of
the
query
language
I,
don't
think.
I
mentioned
this.
Just
Cassandra
Corgi
language,
so
I
can
mention.
The
death
model
is
usually
the
trickiest
part
to
get
to
get
right.
So.
A
Of
what
you
would
do
can
be
helpful,
so
say
we
want
to
just
model
the
followers
of
users
and
our
only
real
query
is
going
to
be
giving
me
the
followers
of
a
user.
We've
got
something
that
should
look
pretty
familiar,
create
table
statement,
it's
key
by
the
user.
Word
user
got
a
column
for
the
followers,
and
just
the
timestamp,
and
the
most
important
thing
here
is
the
primary
key
definition.
So
the
first
part
of
the
primary
key
is
the
user
name
and
that's
what
the
center
is
going
to
partition
body.
A
So,
if
you
remember
back
to
where
I
was
talking
about
all
that
matching
business
I
said
that
it
worked
on
the
primary
key
I
said:
technically
partition
key.
This
is
what
I
meant.
The
first
part
of
the
primary
key
is
the
partition
key,
that's
sort
of
how
it
decides
to
split
up
the
data
around
the
cluster,
so
so
one
one
group
of
replicas
is
going
to
have
all
the
data
for
a
particular
username,
but
each
user
name
might
have
a
different
set
of
replicas.
A
The
second
item
near
the
follower
is
what
we
call
a
clustering
key,
so
Sandra.
This
is,
this
is
a
really
important
part
of
Cassandra
monitor
data.
It
stores
the
data
in
a
particular
order,
and
you
really
wanted
to
be
advantage
of
that
that
ordering
so
in
this
case
we
don't
care
about
the
order
of
the
followers
too
much.
The
next
example
will
show
that,
but
in
this
cases
it's
all
of
the
followers,
it's
all
that
now
that's
going
to
be
stored,
contiguously
on
disk,
for
a
single
username.
A
A
So,
let's
say
we
want
to
track
all
the
tweets
by
a
user
astable.
It's
similar
to
the
previous
one.
Just
got
the
username
a
tweet
ID,
which
is
a
time
v2
ID,
so
the
Python
class
UID
I,
don't
know
if
y'all
played
with
it
gets
used
to
log
and
Cassandra
the
one
that's
most
useful
is
a
version
one
you
knew
I
came
I,
which
we
just
call
it
time
you
go,
I
need,
basically
it's
a
timestamp
with
a
bunch
of
random
components.
So
it's
a
way
to
kind
of
have
a
timestamp
and
guarantee
uniqueness.
A
So
you
don't
have
to
worry
about
conflicts,
so
so
we
can
safely
use
username
and
tweet
ID
for
our
primary
key
and
not
worry
about
having
two
identical
tweet
IDs
and
those
overlapping.
But
the
nice
thing
is
that
the
suite
IDs
in
that
that
clustering
key
position
it's
going
to
be
sorted
by
time
so
on
disk
of
the
tweets
by
a
user,
will
be
sorted
by
time
and
stored
in
that
order,
particularly
on
on
disk
and
this
last
bit
at
the
end
of
with
clustering
order.
A
A
Recent
one
hundred
tweets
per
user
need
that
again
this
one
sequential
read
on
this.
Excuse
me
Sandra,
it's
extremely
fast,
a
couple
of
milliseconds,
even
on
a
cold
read
and
you're
done
so
three
wide
followed.
It
gets
a
little
more
interesting
say
you
wanted.
This
is
for
supporting
the
query
basically
show
me
the
last
100
tweets
by
anybody.
I'm
following
this
is
similar
to
the
table.
We
just
looked
at
before
almost
identical.
A
In
fact,
again,
it's
keyed
by
the
username
we've
got
the
tweet
ID,
which
is
a
tiny
UID,
so
it's
ordered
by
time
again
then,
we've
got
the
author
of
the
actual
text
or
the
tweet,
the
body
in
between,
and
it's
stored
in
time,
sorted
order
descending
again,
so
this
this
shows
a
pattern
that
tends
to
be
different
in
Cassandra
and
relational
databases.
So
normally
what
you
want
to
do
in
a
case
like
this
Sandra
is
actually
deep.
Normalized.
A
You
want
to
write
this
tweet
out
to
whenever
you
make
a
tweet,
you
want
to
append
it
to
every
followers
timeline,
so
that
tends
to
scare
people
who
come
from
a
relational
background,
because
you
want
to
normalize.
You
want
to
only
write
once
and
they
want
to
keep
writing
this
duplicate
data
everywhere,
but
Cassandra
writes,
are
extremely
cheap
and
consumers
really
based
around
the
idea
that
disk
space
is
cheap
and
if
you
can
use
extra
disk
space
to
save
almost
any
other
resource,
it's
a
good
trade-off.
A
A
Now
it's
this
pattern
might
fall
down.
In
some
cases,
you've
got
Justin
Bieber
with
like
10
million
followers.
This
is
not
good.
You
might
want
to
that.
This
pattern
might
not
be
the
best
case
for
those
high
end
users
right,
you
don't
want
to
every
time
you
tweets,
you
have
to
write
out
10
million
rows.
That
might
take
it
a
little
too
far,
so
you
do
have
to
be
conscious
of
what
the
pen
that
looks
like,
but
for
most
cases
denormalizing
it's
the
better
option.
Now
you
always
want
to
try
and
optimize
your
reads.
D
A
A
A
You
copy
all
your
data,
it's
a
very
second
table
yeah
the
standard
that
you
can
I'm
gonna.
Do
it
your
schema
in
some
ways
it's
really
easy
and
in
other
ways
it's
difficult,
so
you
can
add
columns
for
free.
It's
not
like
my
sequel.
Do
you
have
a
call?
Basically,
it's
kind
of,
like
all
columns
are
optional,
there's
no
way
to
enforce
not
an
old
or
anything
like
that.
A
So
when
you
add
a
new
column,
it
doesn't
try
and
backfill
the
old
data
it
just
whenever
reads
that
bro
it
seizes
the
columns
not
there
and
just
sort
of
the
signs
that
column
unball
value.
So
it's
easy
to
add
columns
deleting
columns
is.
It
is
also
cheap,
but
it
doesn't
clean
up
all
the
data
immediately.
It
kind
of
slowly
works
at
over
the
system
over
time,
but
yeah.
You
can't
change
the
the
clustering
order.
You
can't
change
the
partition
key
right,
because
that
would
require
a
shuffling
all
the
data
around
the
cluster
again.
A
So
so
in
some
ways
it's
flexible
in
some
ways.
It's
not.
There
are
a
couple
of
cool
kind
of
flexible
things
that
are
flexible
in
the
schema
that
I
didn't
mention.
One
is
collections,
you
can
define
a
column
to
be
a
collection,
either
a
list,
a
set
or
a
map.
So
if
you
have
something
we're
saying
we're
doing
like
a
playlist
of
songs,
you
have
tags
for
the
songs.
You
might
use
a
set
problem
there.
You
definitely
don't
want
to
do
columns
like
type
1
type,
2
type-
3.
That's
not
a
good
idea.
A
Just
use
a
set
there,
so
that
can
give
you
some
some
a
little
bit
of
flexibility
and
you're
still
working
with
types
type
data.
So
there
are.
There
are
a
few
options
there.
We
also
have.
These
are
defined
types
coming
out,
which
are
kind
of
like
sea.
Stress,
I,
think
you
can
just
kind
of
mash
several
fields
into
one
type
and
that's
use
your
find
type.
So
you
can
support
a
kind
of
a
document
style
or
can
support
documents.
Out
of
that,
oh.
G
A
Sure
so
this
Android
can
store
like
blobs.
It
can
store
large
blobs,
but
it's
not
necessarily
the
best
choice
for
that.
What
we
usually
see
users
do
is
they'll
store
the
metadata
in
Cassandra
and
they'll
store.
The
actual
image
was
something
else:
that's
more
designed,
Quebec
that
kind
of
storage.
So
if
this
is.
A
Really
small,
like
a
few
K,
I
think
or
even
up
to
single-digit
bags,
because
they
don't
leave
reasonably
well,
then
the
problem
is
kind
of
with
these
really
large
column
values
whenever
you
same
to
pulls
that
into
memory.
That
kind
of
creates
some
problems
for
garbage
collection,
I'd,
also
kind
of
slows
it
down
with
a
few
other
maintenance
operations.
So
so,
like
I
said
you
can
do
it
pretty.
Well,
if
you
want
to
store
bigger
objects,
you
can
break
them
up,
but
it's
that's
not
what
it
was
optimized
for.
So
there
are
other
sources.
B
C
C
D
C
Sessions
I
wanted
to
go
ahead
and
have
users
and
messages
done
by
today,
but
everything
that
never
happens
right,
hopefully
soon
I'll
be
able
to
take
a
look
at
the
authentication
piece
and
check
to
see
if
that
would
also
work
well
for
translating
that
into
or
being
able
to
use
out
with
Cassandra
so
yeah
on
the
bottom
is
it
is
the
link
to
the
github
repo.
It
is
in
the
update
to
seek
you
all
treat
because
I
want
to
win
and
send
that
back
to
a
repo.
C
That's
been
dead
for
about
three
years,
so
hopefully
accept
it
in
and
update
it
yeah.
So
going
over
a
little
a
little
bit
of
hi
pieces,
I
went
through
I
created
a
key
space
called
Django
Cassandra
for
this
case.
I
would
instead
to
back
up
one,
but
that's
because
most
times
we
probably
just
letting
it
out,
and
you
enjoy
polynomial
one
note
and
then
for
the
primary
key
I
just
went
ahead
and
set
the
assessment,
the
session
key
up
of
that
and
then
session
data.
It's
a
map
of
bombs,
so
yeah.
C
C
Jack
will
be
two
note,
so
we
get
he
get
strong
consistency
and
we're
able
to
lose
a
note
anything
going
yeah
and
then
at
the
end,
I
catch.
It
I'm
going
to
make
sure
that,
if,
for
whatever
reason
that
that
that
that
scheme
isn't
there
given
those
who
don't
don't,
create
it
dynamically,
even
though
it's
just
better
to
go
through
yourself,
so
yeah
my
helper
method,
it
takes
a
prepared
statement
and
buying
tuples
for
for
the
inserts,
because
we
are
using
TTL
is
I'm
going
to
go
ahead
and
repaired.
C
We
prepare
that
if
it
comes
out
that
the
last
time
I
changed
what's
up,
he
wants
plenty
tails.
Okay,
sorry,
Isuzu
kikyo's
are
kinds
or
it
is
a
short
time
to
live.
So,
if
you're
pretty
much
going
through
and
inserting
a
session
did
take
out
there
and
you
wanted
to
live
for
for
the
next
hour,
those
details
will
be
set
and
Cassandra
will
honor
that.
C
So,
let's
see
yeah,
so
the
next
part
is,
is
the
safe
part.
I
did
go
ahead
and
implement
this
if,
if
it
was,
if
my
screen
is
true,
may
checks
to
see
if
it
does
exist,
you're
not
actually
supposed
to
do
that
with
the
center.
If
you
just
because
reef
reached
before
rights
are
costly
and
generally
what
you're
trying
to
do
is
structure
everything
for
you.
You
writing
once
and
you've
read
fully
separate
operation,
but
in
this
case
we
did
it
because
so
yeah
and
then
for
exists.
We
go
through
again.
C
C
Yeah
and
then
just
kind
of
highlighting
that
that,
with
the
details,
we
will
be
able
to
go
through
and
turn
those
out
without
having
to
do
any
sort
of
manual
operation
on
system
yeah.
So
so
a
little
bittle
bit
of
what
I
learned
through.
That
was
just
kind
of
to
be
able
to
keep
my
my
views.
My
library
database
and
the
center
its
own
separate
I
went
ahead
and
redid
everything
as
soon
as
I
got
the
really
good
point
which
I
was
totally
happy
with
and
I
know.
You're
not
supposed
to
do.
C
Aversion
to
a
CD
version
want
to
rewrite
everything
that
I
did,
and
it
worked
incredibly
well
with
that
pathetic
abase
by
layer,
I
pretty
much
had
my
my
sessions
and,
at
all
of
my
mind,
prepared
statements.
So
when
I
changed,
my
entire
team
up
I
was
able
to
see
exactly
what
needed
to
be
changed
and
I
didn't
have
to
mess
with
any
library,
portions
or
services.
C
C
Ya
so
yeah
right
right
now,
I
do
have
a
pull
request
out
drivers
so
that
way,
you'd
be
able
to
do
things
like
like
sending
your
bound
statement
and
send
in
a
dictionary
of
rebound
or
your
binding
values.
It
does
need
a
test
case
and
to
be
cleaned
up
just
a
little
bit
I'm
working
with
her
right
now
and
this
Newsday
I
can
see
where
now
that
will
be,
will
actually
sorry
in
the
next
icon
driver.
It's
me,
mortgage
rate,
is
that
yeah.
C
Yeah
and
then
here's
here's
a
little
bit
of
my
side
project
and
and
me
actually
going
through
and
financial
typically
I.
Naturally,
the
wants
to
be
on
relational
databases
just
because
that's
the
way
they've
been
for
a
very
long
time,
but
here
I
went
in
and
showed
that
with
a
primary
key,
the
date
and
transaction
ID
I
go
ahead
and
hold
onto
that.
So
that
way,
I'm
able
to
ensure
that
every
time
something
that's
rated,
it's
not
going
to
be
a
due
date.
C
And
again,
I
go
through
I,
prepare
it.
I
could
go
ahead
and
set
certain
things
like
sliced
open.
So
that
way,
all
future
executions
of
this
query
will
have
that
and
in
the
safe
history,
I
go
ahead
and
pull
out
the
prepared
statement
and
send
it
back
in
I
will
probably
go
ahead
and
change
that
to
match
closer
with
whatever
sessions
I
just
haven't
had.
C
Yeah
and
and
you
can,
when
it
gets
started,
we
would
send
them
today.
You
have
the
the
Cassandra
launcher
project
you
pretty
much
go
through.
You
install.
You
run
it
once
and
continue
it's
going
to
move
the
cluster
launcher
of
a
kind
of
user,
Etsy,
local
or,
and
some
pasta
on
a
two-year.
Your
home
directory
go
through,
give
it
to
your
AWS
keys
and
it
will
go
through
much
faster
for
you.
So
if
you
want
that's
a
simple
one
note
you
can
see
to
it.
Oh
yeah
I
mean
show
you
that
it
does
go
through.
C
It
brings
all
your
thermal
discs
on
it.
Make
sure
that
that
old
system
settings
are
correct
and
installs
it
dynamically.
So
you
get
the
very
newest
version,
it's
option
for
you
and
that's
all
a
separate
project,
also
very
Python
yeah,
and
if
you
end
up
deciding
that
you
want
to
go
into
production
today,
I
know
you've
run
the
same
script,
because
you
can
know
they're
all
run
together
and
the
ground
running
yeah.