►
From YouTube: NYC* 2013 - "New Cassandra Drivers in Depth"
Description
Speaker: Michael Figuiere
SlideShare: http://www.slideshare.net/planetcassandra/nyc-tech-day-new-cassandra-drivers-in-depth-17867623
Cassandra 1.2 finalizes CQL3 and introduces a new binary protocol for client/server communication. These two components are the foundation of the new line of drivers developed by DataStax. Based on years of experience with Cassandra, these new drivers for Java, .Net and Python come with an asynchronous and lightweight architecture, a clean and simple API, a standardized way to discover nodes and to manage load balancing and fail over. This presentation will give an in depth look at these new drivers which will make your Cassandra-based applications even more robust, efficient and simple to write.
A
A
Most
of
the
time
we
speak
about
some
new
features
and
casting
was
some
new
features
to
improve
some
performance
to
improve
the
developer
experience
on
the
server
side,
but
we
haven't
talked
that
much
over
the
past
years
of
some
real
new
stuff
on
the
driver's
side.
Of
course,
there
has
been
some
improvement
for
some
language
thinking,
for
instance,
about
astronauts.
That
was
a
great
project
for
the
java
space,
but
still,
I
guess
that
most
of
us,
customer
user
can
feel
something
is
missing
and
that's
actually
what
this
talk
will
be
about.
A
A
A
Up
to
now.
I
think
that
I've
heard
a
lot
of
feedbacks
about
casino
from
bunch
of
users
for
a
lot
of
people,
and
very
few
of
them
could,
and
actually
none
of
them
have
never
criticized
customer
architecture
or
said
that
it
wasn't
a
very
robust
and
efficient
piece
of
engineering,
and
indeed
I
really
think
it
is,
but
probably
the
number
one
critic
that
I
can
hear
for
casanova
is
probably
that
it's
a
little
complex
and
slightly
too
complicated
to
learn.
A
That's
nicely
said
right
so
and
that's
true
I
mean
it
has
been
very
innovative.
It
was
a
very
new,
a
very
new
way
of
thinking,
so
everybody
was
learning,
including
us,
including
the
entire
nosql
community.
So
that's
new
stuff
and
things
improve
thoroughly,
but
now
that
the
the
product
actually
become
much
more
mature
and
now
that
it
starts
to
get
used
by
the
much
much
poorer
audience
it's
it's
definitely
time
to
make
it
way
simpler
to
use
and
way
more
productive.
So.
A
So
it's
all
about
manipulating
some
simple
statically
defined
table.
Just
like
you
know,
just
like
those
you
can
use
in
sql,
just
as
johnson
could
present
you
this
morning,
and
it's
really
also
about
introducing
a
new
query
language
in
order
to
have
a
consistent
experience
across
all
language
across
any
programming
language
across
any
administrator
shell.
A
You
know
that
is
you've
got
this
sql
sh,
where
you
can
send
the
exact
same
query
as
the
one
you
can
send
in
your
programming
language
and
that's
obviously
a
great
feature,
because
that's
a
consistent
experience
across
any
environment,
and
that's
probably
where
why
is
sql
language
is
actually
such
popular.
So
popular,
it's
actually
yeah,
because
it's
just
a
consistent
experience
and
you
don't
have
to
figure
out
how
to
express
this.
All
that
concept
in
z
cells
that
programming
language,
so
cqr3
is
statically
defined.
So
it's
not
it's
no
more
schemas!
A
So
that's
a
thing.
Some
people
don't
really
feel
comfortable
about
it,
but
just
think
about
the
fact
that
whenever
you've
got
a
schema,
less
database,
actually
most
of
the
time
you
you've
got
a
schema.
It's
just
that
the
definition
is
stored
in
your
programming
language.
The
schema
is
written
in
java
in
python
in
whatever,
but
your
application
is
somewhat
aware
of
the
schema
of
the
way
you
store
your
data
in
your
database,
even
if
you
believe,
there's
no
schema,
so
we
don't
really
feel
that
it's
a
huge
pain
point.
A
Besides
that
a
huge
impediment
in
the
castle
world
was
swift.
Swift
has
been
a
huge
opportunity
for
casanova
at
first,
because
it
has
offered
us
a
lot
of
drivers
for
a
bunch
of
language
for
free.
You
know
we
have
this
ideal.
This
interface
definition
language
for
for
swift
and
as
soon
as
the
swift
community
could
come
with
some
driver
for
with
some
implementation
for
a
new
programming
language.
A
We
are
the
driver
for
that
point,
language
which
is
great
for
a
new
cover
in
the
database
world,
but
now
that
custom
worlds
move
forward,
it
turns
out
that
swift's
got
some
limitation.
It's
an
fpc!
It's
an
rpg
framework,
so
that
means
any
interaction
we
can
have
with.
The
database
must
be,
must
follow
the
request
response
paradigm,
that's
fairly
limited.
A
We
cannot
send
any
notification,
for
instance
the
new
protocol.
We
we've
introduced
in
custom
1.2
and
that's
the
wall.
Point
of
of
this
slide
is
actually
fully
designed
for
the
knees
of
casanova.
So
it's
no
more
an
air
pc
only
protocol
you've
got
everything
you
need.
It
opens
a
lot
of
doors
for
a
lot
of
different
kind
of
interaction
between
between
the
servers,
the
client.
A
So
let's
dig
a
bit
more
in
cql3
cqr3,
as
I've
mentioned,
is
just
a
set
of
statically
defined
table,
so
just
think
about
the
table.
You've
got
in
square,
that's
exactly
the
same.
Only
difference
is
that
you
don't
have
any
joy.
So
in
practice
you
don't
have
this
coma
in
the
in
the
form
clauses
of
your
query
language
in
its
grammar.
You
know,
so
you
don't
have
any
join.
You
don't
have
any
aggregation.
A
A
So
in
this
example,
we
try
to
store
some
tweets,
so
you
can
recognize
here
what
you
would
actually
store
in
an
sql
database
if
you
were
trying
to
store
something
somewhat
denormalized
or
maybe
that
could
be
something
that
you
could
see
in
a
wizard
set
from
a
query
in
my
sequel.
You
know
that
is:
you've
got
for
a
for
a
given
user.
You've
got
several
tweets
that
are
stored
along
with
all
their
details.
You
know
auto
and
body,
and
so
on.
A
Some
other
column
as
clustering
key
the
clustering
key
in
in
sql
series,
actually,
how
you
tell
customers
or
when
you
tell
the
customer
storage
engine,
how
to
group
how
to
cluster
your
data
together
on
the
disk,
because
that's
the
concept
you're
used
to
in
in
casanova
and
that's
the
way
we
express
it
here.
So
I
will
come
right
after
on
the
link
between
this
data
module
and
the
actual
physical
data
model,
which
is
the
one
you're
familiar
with.
A
Secure
statement
that
you
will
use
to
create
this
schema,
so
you
can
see
that
obviously
it's
fairly
familiar.
An
interesting
point
is
that
here
you
can
see
that
the
first,
the
first
item
in
your
primary
key
statement
is
a
partition
key
and
the
following
is
following
once
with
an
s,
because
you
can
have
several
ones
can
are
your
clustering
keys?
So
this
way
you
can
express
how
you
want
to
partition
your
data
and
then
how
you
want
to
cluster
them
together
on
this
particular
instance.
So
that's
simply
several
level
of
aggregation.
You
know.
A
A
B
A
A
Maybe
some
of
you
just
play
with
the
high
level
client
and
don't
we
and
I
haven't
digged
into
some
details
of
the
underlying
details,
but
basically
the
way
it
work
is
that
you
you've
got
this
swift
layer,
customer
defined
and
idl,
and
then
swift
is
able
to
generate
a
client
for
every
programming
language,
but
then,
as
any
kind
of
generated
code,
you
don't
have
a
great
api
with
it
right.
It's
not
really
awesome.
It's
not
really
pleasant
to
use.
A
So
that's
why
the
community
came
with
some
higher
level
clients
on
top
of
swift
in
order
to
make
it
way
more
productive
and
way
more
pleasant
to
use.
So
they
came
with
some
ir
level
swift
api
with
some
object-oriented
api.
That's,
for
instance,
the
object
mapper
from
actors
that
you
can
find
hashtags
got
to
as
well,
and
you
can
find
some
for
python
and
so
on,
and
they
also
have
some
2
of
603
even
api,
also
because
it's
also
possible
to
perform
to
play
with
sql3
on
top
of
swift.
A
A
There
were
some
experimentations
that
have
been
done
at
the
very
beginning
of
sql
three,
because
we've
got
this
tabular
their
model
that
actually
fits
in
most
standard
db,
api
of
any
programming
language.
So
we
wanted
to
leverage
that
in
order
to
have
a
jdbc
standard
api,
which
was
a
very
nice
way
to
integrate
with
a
bunch
of
things
that
was
a
very
interesting
experimentation
and
this
world
architecture
in
some
way
was.
C
A
So
that's
a
very
important
point:
all
your
investments
are
safe,
but
besides
that
we
continue
to
prepare
and
invest
for
the
future,
and
this
architecture
is
based
on
this.
New
protocol
live
mansion,
which
I
got
a
bunch
of
features
that
I
will
mention
later.
We've
got
this.
What
I
call
db
standard
db
api,
which
is
this
jdbc
thing-
that's,
for
instance,
in
the
javaspace.
That's
a
can
a
kind
of
api
that
we
will
try
to
have
on
top
of
all
this
architecture,
because
that's
still
convenient
to
have
for
some
integration.
A
Obviously,
that's
probably
not
what
you
want
to
use
in
production.
Then
you've
got
this
pure,
dedicated,
sql
api
that
is
fully
designed
for
cql3
and
all
its
features
which
might
not
all
fit
in
this
standard
db
api.
As
you
know,
and
of
course
we
keep
this
object-oriented
thing
because
that's
part
of
the
productivity
thing
for
any
modern
program
language.
A
We
consider
it
as
a
reference
implementation
for
for
this
architecture
and
for
the
new
binary
protocol,
because
it
has
been
developed
very
closely
with
the
apache
team,
so
basically
every
it
implements
absolutely
every
features
of
the
new
protocol
and
the
protocol
has
been
designed
closely
with
the
implementers
of
this
language
of
these
drivers.
So.
B
A
A
A
It
support
also
the
new
trusting
features
that
jonathan
mentioned
this
morning.
You
might
remember
about
it:
it's
pretty
convenient
for
to
debug
your
production
environment
or
your
developing
developer
environment,
and
then
you've
got
a
bunch
of
polities
somewhat
inspired
by
the
work
that
has
been
done
by
astinx
in
netflix
at
netflix,
which
was
very
inspiring
for
for
this
driver.
A
So
let's
talk
about
some
details
about
the
drug
about
the
protocol
itself,
so
one
of
one
very
interesting
features
which-
and
you
will
see
there
are
several
of
them
just
to
me-
justified
the
fact-
the
idea
to
switch
from
swift
to
this
new
protocol.
What
very
very
interesting
features
is,
is
that
it
supports
request.
Pipelining,
request
pipeline
is
actually
the
idea
to
be
able
to
send
a
bunch
of
requests
without
waiting
for
any
answers.
A
So
a
very
interesting
thing
in
this
architecture
is
that
it
allows
you
to
send
a
bunch
of
requests
without
blocking
a
connection
just
just
because
you've
got
a
request
that
is
a
bit
slow
or
not.
That
is
a
bit
slow,
whatever
so
very
interesting
thing,
especially
for
castle,
which
start
to
have
some
very
large
deployments.
You
know
with.
We
already
have
some
clustering,
the
androids,
so
you
can
imagine
that
if
you've
got
some
cluster
in
the
android,
typically
you
might
have
several
androids
application
server
as
well
in
front
of
it.
A
A
For
the
the
actual
answer
you
still
perform
very
well,
because
this
bunch
of
requests
just
looks
a
lot
like
the
actual
queue
is
for
a
batch.
You
know,
so
that's
a
very
convenient
way
to
use
your
connection
at
its
max
all
all
the
boundaries
of
your
connection
without
being
killed
by
any
latency
issues.
A
A
You
know
because
currently
the
typical
strategy
is
that
clients
will
try
to
pull
all
this,
not
all,
but
I
will
try
to
pull
the
servers
occasional
nodes
to
wait
with
periodically
an
updated
list
of
nodes
and
outdated
topology
and
that's
obviously
not
very
satisfying
architecture,
so
with
swift,
it
was
obviously
the
only
way
to
go,
but
here,
as
we
own
our
protocol
as
we,
we
make
our
own
rules
with
this
protocol.
We
can
that's
a
very
simple
thing
for
us
to
implement.
A
That
allows
us
to
have
a
very
nice
way
to
implement
all
that.
Basically,
here
what
will
happen
is
that
a
client
suite
will
send
a
request
to
the
driver.
The
driver
will
dispatch
it
according
to
a
load
balancing
policy.
I
will
mention
it
right
after
we'll
dispatch
it
according
to
the
load,
bouncing
policy
to
any
node
and
then
we'll
pick
up
the
least
used
connection
for
this
node.
A
It
will
send
the
request
to
the
node
the
node
will
enter
while,
while
the
request
is
processed,
the
suede
will
be
typically
blocked,
but
internally
in
the
driver,
there's
no
sweat
that
is
used
or
no
blocking
connection
or
no
blocking
I
o
or
whatever
the
driver
is
still
free.
Maybe,
as
the
client
said,
we're
actually
not
blocked,
maybe
it
will
just
perform
some
other
asynchronous
operation
during
this
weakness
processing,
then
the
answer
will
come
from
the
castle
node.
A
The
driver
will
then
dispatch
it
to
to
the
wide
suede
waiting
for
for
the
answer
and
we're
good
to
go
so
this
architecture-
I'm
definitely
not
here,
trying
to
move
forward
to
to
try
to
restore
the
good
old
debate
blocking
versus
non-blocking
and
asynchronous
versus
synchronous.
But
it's
just
that.
It's
simplify
your
life
here
in
a
very
scalable
environment,
because
you
don't
have
to
maintain
any
sweat
pools.
You
don't
have
to
maintain
any
cues
or
things
like
that.
A
So
I
was
mentioning
this
load
balancing
qualities
in
this
new
driver
and
that's
so
during
this
work
presentation
I
actually
use
java,
but
you
will
find
some
similar
concepts
in
pretty
much
every
language
for
which
we
will
try
to
implement
or
our
collaborate
to
implement
some.
This
kind
of
driver
architecture-
so
don't
worry
if
you
don't
actually
use
java
every
day,
so
the.
B
A
Of
policies
you
will
have
to
implement
if
you
want
to
very
finely
customized
the
way
the
driver
will
behave
with
your
architecture.
Is
this
kind
of
a
load
bouncing
policy?
Everybody
in
this
room
might
have
in
production
some
very
different
kind
of
topology.
You
know
some
of
you,
some
of
you
guys
might
have
tenders
on
tourism.
Also,
you
might
have
just
two
or
three
like
west
coast,
east
coast,
europe,
and
maybe
some
other
might
just
have
one
dozen
two
and
just
a
few
few
nodes.
A
So
obviously
some
very
different
load
balancing
policies
might
fit
your
needs,
and
maybe
you
might
have
some
close
to
locally.
You
might
have
another
one
on
ec2
for
some
cost
strategy.
You
might
want
to
send
as
few
requests
as
possible
on
the
ec2
cluster
and
more
on
the
local
one.
That's
where
you
can
totally
tweak
these
kind
of
things,
so
it's
fairly
flexible.
All
you've
got
to
do
is
to
implement
this
interface,
which
will
be
able
to
say
the
driver.
Okay,
for
this,
this
host
is
actually
at
this
distance.
A
A
That
is
if
the
first
one
is
not
available,
then
the
driver
will
will
twice
the
second
one
and
so
on
so
forth,
so
we
have
made
it
as
simple
as
possible
for
you
guys
to
implement
so
that
don't
hesitate
to
implement
it
to
fit
exactly
your
needs,
but
obviously
because
a
lot
of
deployments
are
still
pretty
similar.
Also,
we
come
with
some
default
with
some
built-in
implementation,
so
obviously
you've
got
a
one
webbing
quality,
that's
pretty
basic,
but
you've
got
also
some
more
interesting
one.
A
A
We
also
support
some
token
aware
policies,
that's
something
that
has
been
introduced
with
aston
x
and
it's
very
interesting,
especially
if
your
cluster
is
very
large.
The
idea
here
is
simply
to
give
some
awareness
of
the
token
topology
of
the
cluster
so
that
the
client
is
able
to
would
to
choose
a
coordinator.
That
is
actually
a
replica
for
the
query
that
is
being
processed.
A
A
Request
not
complete
successfully,
maybe
you
will
have
on
the
coordinator
node.
The
coordinator
node
will
not
receive
response
on
time
to
complete
the
request,
so
it
will
be
some
time
out
either
some
weed
or
while,
depending
on
the
kind
of
the
request,
it
can
also
be
simply
that
the
coordinator
knows
that
not
enough
nodes
are
available,
in
which
case
it
will
be
an
unavailable
exception.
A
Depending
on
this
case,
you
will
implement
some
different
kind
of
behavior
and
we
try
policy.
So
here
you
will
just
have
to
implement
to
provide
a
decision
which
might
be
easier
to
retry,
either
to
withdraw
the
exception
or
just
to
ignore,
silently
or
the
error,
and
that's
really
interesting,
because
you
can
implement
outside
your
business
logic,
these
very
common
technical
things
that
are
we
twice.
You
know.
Maybe
in
most
of
your
application,
you
don't
care
about
three
twice
and
you
will
actually
just
move
on
if
an
app.
A
A
So
a
good
reason
for
the
gasoline
cluster
to
not
feel
very
well
and
for
this
kind
of
error
to
to
rise,
might
be
simply
that
you've
lost
too
much
replicas.
You
know.
Maybe
you
wanted
to
perform
a
query
with
a
calm
consistency
level,
either
at
read
or
write
time,
and
you
couldn't
complete
it,
for
instance,
because
you
were
missing
two
replicas
out
of
three.
A
So
in
such
a
situation,
you
know
that
the
query
will
not
complete
successfully
and
what
what
we
allow
you
to
do
is,
and
we
provide
you
a
built-in
retry
quality,
for
that
is
to
downgrade
the
consistency.
If
you
want
to
do
so.
That
is,
if,
for
some
business
logic,
purpose
for
business
requirement,
purpose
you've
you've
chosen
to
to
perform
your
request
with
a
chrome
consistency
level.
A
To
complete
the
request
with
consistency
level
one
and
be
notified
that
in
the
wesley
set
that
the
query
could
not
complete
at
the
current
consistency
level
and
that's
interesting
in
some
business
situation,
where
you
actually
cannot
afford
to
to
answer
on
your
page,
maybe
to
to
some
customers,
because
that's
a
fairly
critical
service.
So
you
might.
C
A
C
A
Okay,
so
the
question
was
about
the
amount
of
of
connection
per
o's
that
are
maintained,
and
actually
this
concept
is
out
of
these
retry
policies.
It's
in
something
I
haven't
mentioned
it
because
it's
not
it's
not
that
important
at
least
less
than
this
one.
It's
you've
got
also
reconnection
policies.
A
So
here
you
we
don't
expect
you
to
actually
want
to
implement
some
very
exotic
one.
We
just
provide
you
a
constant
reconnection
quality
or
an
logarithmic
reconnection
policy,
which
is
basically
you
know
it's
a
very
classic
thing.
You
want
to
try
to
reconnect
easier
every
end
second
or
you
want
to
reconnect
every
two
seconds
and
it
with
four
seconds
and
every
eight
second,
and
so
on
so
forth.
So.
A
A
So
here
we've
really
really
wanted
to
have
something
very
productive,
very
not
verbal
and
very
efficient.
So
we
provide
you
a
builder
to
build
your
cluster
very
typical.
You
provide
several
contact
points
that
will
that
will
be
used
as
a
seed.
You
know
for
for
the
client
to
discover
some
nodes,
so
the
client
will
try
to
connect
to
either
of
these
nodes.
B
A
You
connect
to
this
cluster
functioning
your
key
space
and
you
obtain
this
session
object
that
is
fully
sweat,
safe.
You
don't
have
to
care
about
anything.
You
can
inject
it
in
every
place
in
your
application
and
you
don't
have
to
care
about
anything.
You
can
simply
execute
some
statement
using
this
execute
method
and
yeah
you're
good
to
go.
If
it's
a
white,
you
don't
even
care
about
the
wisdom
set,
maybe
so
you're
done
so
I
really
think
it's
a
huge
improvement
compared
to
some
past
implementation.
A
C
A
This
wizard
set
actually
implement
it
away
ball
in
java,
but
you
will
be
able
to
to
wait
with
a
list
of
wall
and
then
you
will
just
each
wait
over
this
list
of
wars
so
once
again,
fairly
classical
and
fairly
readable
for
any
java
developer.
I
bet,
but
the
interesting
point
is
that
we've
got
asynchronous
weed,
so
we
are
able
to
perform
these
same
kind
of
requests
with
some
asynchronous
architecture
in
some
asynchronous
way.
So
here
you
will
just
receive
a
future
object.
A
A
B
A
A
I've
mentioned
prepare
statements,
we've
got
prep
statement
already
available
and
that's
where
that's
very
important
feature
for
a
query
language
that
actually
use
some
strings
because
strings
obviously
are
much
less
efficient
than
swift.
I
mean
swift
is,
is
still
binary,
so
we
need
to
send
all
these
queries
as
twin
to
the
server
and
it's
not
very,
very
efficient.
Obviously,
but
thanks
to
prepare
statement,
I
mean
same
same
architecture,
same
solution
to
the
same
problem
as
in
this
sql
world.
So
we
use
prepare
statement,
a
difference.
A
So
you
can
share
it
among
all
your
suede
and
then
you
will
bind
it
with
with
some
parameters
and
you
will
obtain
a
bound
statement,
so
you
can
either
set
all
your
parameters
at
bad
bind
time
or
you
can
set
them
slightly
later
by
setting
every
parameter
one
by
one,
depending
on
some
on
the
kind
of
short
shortcut
you're
willing
to
use
or
not
so
here
you
will
obtain
this
bond
statement
that
will
just
be
valid
for
the
context
of
your
request.
You
will
set
all
your
parameters
and
you
will
then
execute
them.
A
You
might
have
some
secular
injection
right
so
because,
obviously
we
don't
want
this
to
happen
whenever
you
need
to
craft
some
query
at
one
time.
You
should
use
this
query
language
that
actually
does
the
work
properly
for
you.
So
you
can
simply
use
this
very
convinced,
affluent
api
that
will
allow
you
to
dynamically
craft.
Some
queries,
maybe
depending
on
some
wizards
of
of
some
form,
you
know
submitted
by
its
users
or
something
like
that.
A
That's
some
fairly
typical
use
cases
for
some
for
a
query
builder
or
maybe
even
you
don't
like
to
put
some
strings
in
your
program,
language
and
you
prefer
to
have
this
type
safe,
fluent
api,
so
maybe
that
that
might
be
something
that
you
prefer
to
use
in
any
case
here
you
could
use
this
this
query
builder
and
you
can
also
use
it
to
to
craft
some
queries
for
some
prepaid
statement
actually
so
fairly
productive.
I
guess.
A
This
object
mapping
is
not
falling
fully
so
once
again
here
in
in
the
case
of
this
jar
driver
is
not
fully
following
the
standard
jpi
interface,
because
we
don't
want
to
be
trapped
in
a
standard,
relational
oriented
api
which
doesn't
allow
us
to
put
any
kind
of
uncommon
features
that
you
may
may
find
in
the
relational
world.
We
want
to
be
free
to
extend
the
customer
as
much
as
you
want
and
already
now.
A
You've
got
some
features
that
will
not
fit
very
well
in
gpa,
so
we
want
to
follow
as
much
as
possible
jpi,
because
once
again,
there's
no
reason
for
developers
to
we
learn
everything
something
totally
different
for
every
for
every
database
that
get
familiar
with,
but
we
want
to
still
be
free
from
it.
So
here
you
will
define
simply
with
a
table
annotation
the
the
actual
name
of
the
table
in
in
cast
noir.
A
A
Interesting,
interestingly,
here
all
this
object
mapping
all
this
object.
Mapping
is
actually
not
an
equivalent
to
orm.
You
know
it's.
It's
not
meant
to
simulate
an
object
database
on
top
of
casino,
like
most
om,
are
actually
doing,
but
here
we
just
try
to
map
some
object
to
queries
and
some
ways
you'll
set
to
object.
A
You
know,
that's
all
all
we
do
simply
to
allow
you
to
be
productive
and
and
to
provide
you
something
convenient
whenever
you
program
some
real-world
business
application
where
you
might
have
tens
and
hundreds
of
current,
because
some
business
logic
for
some
business
are
fairly
complex.
Sometimes
so
here
you
you
actually
don't
really
have
because
of
that
to
provide
the
partition
key,
it's
optional,
but
you
might
want
to
provide
it
so
that
we
will
be
able
to
craft
some
ddl
for
you,
which
might
be
fairly
convenient.
A
A
Because
we
are
in
java
and
because
we
are
performing,
we
are
trying
to
build
this
mapping
module.
We
can
provide
you
some
innovations,
it's
not
something
new,
some
other
mapping
framework
on
top
of
casama
also
do
it,
but
this
any
written
is
simply
based
on
on
discriminator
column.
So
we
you
will
just
specify
which
column
to
use
for
the
discriminator
and
then
in
each
subclass.
You
will
specify
what
is
the
actual
value,
so
this
any
returns
is
just
a
way
to
map
to
map
type
to
column
and
current
to
type
right.
A
About
this
new
driver,
so
the
good
news
is
that
some
betas
are
already
available
at
github.com
there.
There
are
some
dash
products,
but
they're
all
open
source
and
they
will
remain
open
source.
So
you
can
debug
or
have
the
source
of
extend
or
submit
some
patch
or
whatever
you
want.
It's
apache
2
license,
so
it's
fully
compatible
with
any
upgrade
project
or
most
of
open
source
projects,
and
it's
business
friendly
of
course.
A
So
we've
got
better
a
better
better
java
driver
available
than
the
one
I've
presented
here.
We've
got
c
sharp
driver
available
on
this
icon
as
well,
and
we're
working
currently
on
some
other
language
to
support
some
other
language,
and
we
will
work
together
with
the
community
to
support
an
extended
list
of
language.
A
A
So
I
don't
have
a
plan
for
every
single
language,
but
so
all
I
can
tell
you
right
now
is
that
our
goal
is
clearly
to
push
this
kind
of
architecture
for
every
possible
language
and
especially
for
the
mainstream
world.
So
I
don't
have
an
answer
for
you
right
now,
but
I
can
tell
you
that
we
really
want
basically
to
see
something
up
but
to
see
something
similar
for
the
php
world,
so
either
done
by
their
stacks
or
by
the
community.
We
will
work
together
closely
in
order
to
see
that
happen.
A
Yeah,
that's
that's
clearly
the
long-term
client
architecture
that
we
would
like
to
see
for
almost
a
programming
language,
because
we
believe
we've
suffered
it
with
a
lot
of
care.
That
feedbacks
are
fully
welcome
if
you
believe
something
is
wrong
or
if
you
believe
something
is
missing,
feel
free
to
contact
me,
even
if
you
really
really
think
it's
bad,
I'm
still
interested
in
that.
So
we
just
want
the
idea,
with
with
this
project,
is
just
to
provide
a
consistent
architecture
across
every
language.
A
So
the
very
interesting
part
here
is
that
you've
seen
these
qualities.
What
we
are
doing
is
that
we
standardize
these
policies
across
well,
in
this
case
java
and
c-sharp
for
now,
but
soon
across
some
more
language.
So
from
a
developer's
standpoint,
that
means
that
the
very
custom
load
bouncing
policies
that
you
implement
in
one
language.
You
can
very
simply
port
them
in
some
other
language,
because
the
api
will
be
so
similar.
You
know,
and
from
an
ops
perspective
it's
it
means
that
they
no
longer
have
to
figure
out.
C
A
Strategy
is
this
one,
but
I
think
that
this
driver
is
slightly
more
smart
and
do
some
weight
twice,
but
I'm
not
sure
our
girl
would
yeah
so
you're
good.
So
here
what
we
try
to
do
is
to
include
the
client
in
the
wall,
art
in
the
world,
distributed
architecture
of
casanova
and
make
it
a
wall
consistent
thing
and
no
more
just
a
set
of
you
know:
service
providers,
service
consumers
just
like
it
used
to
be
any
other
question.
A
A
A
So
the
question
was
about
batch,
so
batch
are
supported
directly
in
the
cql
language,
so
you
can
provide
some
batch
statement
directly
in
the
execute
method.
You
know
it
will
work.
We've
got
a
batch
object
also
available
in
our
query
builder,
and
everything
in
this
driver
is
actually
a
queer
object.
So
you
will
quickly
realize
that
a
batch
is
still
a
query
and
you
can
put
some
queries
in
a
badge
and
that's
pretty
convenient
yeah.