►
From YouTube: Trie Memtable Implementation (CEP-19) | Apache Cassandra® Contributor Meeting August 29, 2023
Description
Presentation about CEP-19: Trie Memtable Implementation by Branimir Lambov: https://cwiki.apache.org/confluence/display/CASSANDRA/CEP-19%3A+Trie+memtable+implementation
CEP = Cassandra Enhancement Proposal.
What is Apache Cassandra?
Apache Cassandra is an open source NoSQL distributed database trusted by thousands of companies for scalability and high availability without compromising performance. Linear scalability and proven fault-tolerance on commodity hardware or cloud infrastructure make it the perfect platform for mission-critical data. https://cassandra.apache.org
What is the Contributor Meeting?
The Apache Cassandra community hosts informal monthly meetings to enable real-time collaboration for contributors to discuss CEPs and other issues, and ask questions. Meetings take place the last Tuesday of each month at 10:00 PT / 13:00 ET / 17:00 UTC / 22:30 IST. Learn more and join: https://cwiki.apache.org/confluence/display/CASSANDRA/Cassandra+Contributor+Meeting
Learn and Participate
Meetups: https://www.meetup.com/cassandra-global/
Apache Cassandra Website: https://cassandra.apache.org
ASF Slack #cassandra: https://join.slack.com/t/the-asf/shared_invite/zt-vlfbf7ch-HkbNHiU_uDlcH_RvaHv9gQ
Twitter: https://twitter.com/cassandra
LinkedIn: https://www.linkedin.com/company/apache-cassandra/posts/
Planet Cassandra Website: https://planetcassandra.org/
Planet Cassandra YouTube: https://www.youtube.com/@PlanetCassandra
Planet Cassandra Discord: https://discord.com/invite/Ut8YctQWac
A
Awesome
welcome
to
the
August
Apache
Cassandra
contributor
meeting,
it's
great
to
have
you
all
here
today.
So
in
these
meetings
we
we
hear
from
people
who
are
you
know
developing
Cassandra
and
working
on
on
core
features,
and
we
yeah
today
we're
going
to
be
hearing
from
Brandon
Lambo
who's
talking
about
trying
mem
table
implementation
and
cp19.
A
The
cep
is
a
Cassandra
enhancement
proposal,
which
is
where
all
the
core
work
gets
done
on
Cassandra,
so
some
great
stuff
going
on
there
brand
new's
got
some
exciting
stuff
to
share
I'll.
Let
him
introduce
himself
a
bit
more
and
then
we
can
we
can.
We
can
jump
right
in
if
you
have
questions
as
we
go,
just
drop
them
in
the
chat.
A
I'll
keep
an
eye
on
that
as
well.
Brandemiah.
If
you
can
too,
but
I'll,
be
keep
an
eye
on
it
and
make
sure
we
can
get
those
questions
answered,
there'll
be
we
can
weave
them
in
as
we
go
or
have
some
question
q
a
time
at
the
end
as
well,
and
then
we'll
wrap
up
when
we're
done
so
yeah
I
will
hand
over
to
to
brandemia
thanks
for
joining
us
and
then
I'd
like
to
introduce
yourself
a
bit
more
energy
topic.
A
B
Believe
my
name
is
pranimir
I
work
for
data
Stacks
I
have
been
for
nine
years
now
on
the
core
database
on
Cassandra.
Usually
the
stuff
I
do
is
on
the
local
note,
processing
the
storage
and
bits
around
that,
and
this
example
that
this
CP
that
I'm
going
to
talk
about
today
is
again
one
of
those
pieces
in
the
local
node
infrastructure
in
Cassandra.
B
B
What
are
the
main
tables
so
generally
Cassandra
is
an
LSM
work,
structured,
merge,
3
database,
which
means
that
it's
built
of
data
stored
in
multiple
components.
When
we
read
read
it,
we
need
to
consult
multiple
components
and
then
we'll
write.
The
database
we
first
try
to
buffer,
which
is
dismantable,
which
takes
a
few
writes
until
it
fills
up
and
that
mem
table
is
converted
into
a
long
discusses
table.
B
B
The
interesting
thing
about
men
tables
is
that
they're
actually
considered
fast
enough,
because
there
are
so
many
other
overheads
in
the
system
that
usually
the
work
we
do
for
the
land
table
is
just
a
very
small
part
in
part
of
it,
especially
if
you're
doing
reads
in
your
Consulting
disk.
The
main
table
is
going
to
be
nothing
compared
to
to
reading
from
disk,
and
yet
there
are
a
lot
of
things
that
can
be
achieved
by
optimizing
many
tables.
B
Maybe
the
focus
of
doing
this
has
to
change
a
little
bit
to
do
this
because
to
to
make
things
better.
Generally,
you
don't
just
want
to
improve
the
performance
or
the
the
speed
with
which
you
can
write
or
break
through
the
main
table,
but
you're
more
interested
in
how
much
space
a
mem
table
takes
for
the
same
amount
of
data
and
whether
or
not
it
has
a
complex
structure
that
a
garbage
collector
needs
to
look
at
and
how
much
time
it
needs
to
spend,
processing
and
dealing
with
this
amount
table
structure.
B
Now
to
continue
the
the
discussion
about
why
we
wanted
to
optimize
the
the
mem
tables.
Let's,
let's
look
at
what
the
the
existing
or
the
Legacy
mainta
was
in
Cassandra
actually
are
Terra
hierarchy
of
maps
and
their
comparison-based
Maps,
which
means
that
the
only
the
only
thing
we
we
know
about
the
keys
are
that
we
can
compare
to
different
keys
and
based
on
the
the
result
of
the
comparison
we
can
choose
whether
to
go
in
a
structure.
B
B
So
we
have
some
management
mechanism
that
allows
us
to
put
the
data
for
cells
in
of
heat
memory,
but
all
of
the
maps,
all
these
structures
for
all
levels
of
the
the
hierarchy
are
on
Heap
and
they're.
Actually,
a
pretty
complex
structure
because
you
have
an
index
for
applications,
then
many
many
indexes
for
each
partition
to
individual
B3,
to
individual
roles
and
for
every
row.
You
also
have
another
level
of
a
b
tree
which
gives
you
all
the
The
Columns
in
the
row,
and
this
quickly
becomes
huge
and
because
this
data.
A
B
Heap,
this
has
two
very
big
disadvantages.
The
only
hip
size
of
This
Ss
table
is
sorry.
You
know
this
mem
table
is
bigger
than
the
data
size
most
of
the
time
and
by
not
a
small
number,
it's
several
times
bigger
than
the
than
the
size
of
the
data
which
we
put
off
Heap.
Also,
this
structure
is
very
complex,
so
when
the
garbage
collector
decides
to
walk
the
structure,
it
has
to
spend
a
lot
of
time
following
pointers.
B
It
also
is
not
short-lived,
which
would
be
ideal
for
for
garbage
collector,
neither
very
long
left,
which
would
also
be
good,
because
it
can
be
left
alone
in
some
in
some
older
generation
it
has
a
medium
term
life
cycle,
which
means
that
it
has
to
be
promoted,
but
after
it's
promoted
very
soon
afterwards,
it
has
to
be
removed
again.
So
that's
the
worst
case
scenario
for
for
garbage
collector
and
this
structure
changes
all
the
time
when
resetting
data.
So
these
objects
which
are
not
short-lived,
they
they
change
a
lot.
B
New
ones
come
in
other
ones
disappear,
and
this
is
just
a
lot
of
work
which
is
not
simple
for
garbage
collector.
It's
also
that
this
structure
is
very
it's
generally.
We
want
it
to
be
as
big
as
possible
because
the
size
of
the
structure
determines
the
size
of
the
lowest
levels
of
the
of
the
assist
tables
l0
in
the
combustion
hierarchy
and
that
size
of
the
Avail
zero
determines
how
many
levels
of
compaction
you
need
for
the
same
amount
of
total
data.
B
So
we
want
them
to
be
big,
but
big
mean
more
compaction.
Sorry,
more
garbage
collection,
less
compaction,
but
more
garbage
collection,
more
garbage
collection,
especially
garbage
collection
that
needs
to
deal
with
higher
with
older
Generations
means
longer.
Garbage
collection
poses,
and
these
are
one
of
the
things
that
we
really
want
to
get
rid
of
in
because
I'm
running.
B
So
how
can
we
improve
this?
Let's
start
with
the
idea
of
these
comparison-based
structures
that,
when
tables
use
now
we
have
Keys
which
are
composed
with
multiple
components,
so
you
may
have
two
columns
forming
a
partition
key
another
three
columns
forming
a
clustering
key
and
every
time
we
want
to
find
where
something
is
in
a
map
like
this,
or
we
want
to
insert
a
new
a
new
piece
of
data.
B
In
a
map
like
this,
we
have
to
compare
the
existing
Keys,
some
of
the
existing
keys
to
the
new
key
with
all
these
components,
because
we
often
have
repetition
of
the
leading
components
with
just
different
value
of
the
end
component.
Often,
when
you're
doing
these
comparisons,
we
have
to
compare
again
and
again
the
same
the
same
prefixes,
which
is
one
of
the
one
of
the
reasons
why
we
actually
have
to
introduce
combustion.
B
These
repeated
prefixes
can
be
causing
problems
and
we
also
have
a
complexity,
which
is
the
length
of
the
keys
multiplied
by
algorithm
of
the
number
of
of
keys
we
haven't
in
in
the
map,
which
is
good,
but
there
are
structures
which
can
do
a
little
bit
better
and
these
structures
rely
on
the
so-called
byte
order.
If
you
imagine
strings
for
them,
you
can
compare
two
strings
and
the
first
time
you
see
a
difference
in
in
a
character
at
the
first
different
position
in
the
string.
B
You
know
which
one
which
which
of
the
two
strings
is
smaller
than
the
other
one,
because
they're
electric
graphically
ordered,
which
means
that
yeah,
which
means
exactly
this
the
first
time
there's
a
difference.
Order
is
determined.
We
don't
have
this
in
the
normal
types
for
Cassandra.
We
have
to
fully
look
at
look
at
the
full
value
before
you
can
compare.
B
So
the
thing
about
pytorders
is
that,
if
you
have
them,
you
can
decide
comparisons
early,
but
also
you
can
use
structures
that
make
usage
of
this
internal,
this
structure
of
the
values
and
these
structures
are
called
tries
and
they
have
a
few
advantages.
One
of
them
is
that
when
you,
when
you
store
a
lot
of
information
in
a
try-
and
you
have
repeated
prefixes-
any
prefix
is
stored
only
once
in
this
example.
B
This
prefix
is
going
to
be
stored
in
a
try
only
once
another
thing
about
this
is
that
we
we
know
that
every
node
has
only
up
to
256
children,
because
these
are
all
the
bytes
of
possible
values
of
a
byte.
So
we
can
I
mean
we
can
use
some
some
data
structure
that
uses
only
up
to
this
number
of
of
children.
B
Also
to
look
for
something
in
in
a
try.
You
follow
the
Transitions
and,
if
you're
looking
for,
for
example,
the
the
thing
that
the
first
thing
in
the
try,
which
is
greater
than
let's
say
together,
that
would
be
following
the
the
first
character
of
the
word
you're
looking
for,
which
is
okay,
then,
following
the
second
character
of
the
letter
of
the
work
we're
looking
for,
which
is
oh,
this
brings
us
here.
We
have
more
characters,
which
means
that
this
is
not.
B
B
A
word
in
our
use
case
is
just
the
sequence
of
bytes,
which
is
which
determines
some
key
yeah.
So
look
up
in
a
try
because
we're
following
always
one
transition
in
the
key
of
the
key
one.
Byte
of
the
key
is
just
an
O
of
K
operations,
because
the
length
of
the
key
is
K,
we're
just
taking
one
transition
for
every
character
of
the
key
or
any
any
character
of
the
first
value
after
we
found
the
point
where
we
we
can
just
find
the
next
value
in
general.
B
B
The
problem
for
Cassandra
is
that
most
of
the
types
in
the
database
are
not
things
that
are
naturally
I
mean
naturally
right
ordered.
We
have
to
convert
them.
This
is
something
that
we
can
actually
do.
It's
not
too
hard,
and
for
for
most
of
the
types
is
actually
very
simple.
For
example,
if
you
take
integers,
if
you
just
take
their
byte
values,
you
have
a
little
bit
of
a
problem,
because
positive
integers
are
start
from
zero
and
then
that's
sevenf
and
negative
integer
started
80.
B
and
zeros,
which
means
that
if
you
directly
compare
them
as
unsigned
bytes,
the
negative
integers
will
be
greater,
will
come
out
as
greater
than
the
positive
ones.
But
you
can
fix
this
by
just
flipping
the
the
top
bit
of
the
encoding
and
then
all
the
integers
start
at
80
000
and
all
the
negative
numbers
end
at
7ff
and
they're
smaller
than
the
positive
ones.
B
You
can
do
a
very
similar
trick
for
floating
Point
numbers,
and
actually
you
can
do
something
like
that
for
all
of
the
types
in
in
the
in
that
example,
can
use
this
case.
One
other
thing
that's
important
is
that
you
can
also
take
multiple
keys
and
form
one
single
sequence
of
bytes,
which,
which
is
an
encoding
of
all
the
sequence
of
keys,
and
it's
also
something
that
can
be
compared
directly
as
a
byte
sequence
and
can
give
you
something
which
is
equivalent
to
to
the
multi-component
key.
B
For
example,
for
the
multiple
components
of
the
partition
key
and
also
the
token,
which
is
usually
sets
at
the
front
of
the
sequence
of
case
in
the
partition
key,
you
can
combine
all
these
components
into
a
single
byte,
comparable
sequence,
and
you
can
use
that
and
put
it
in
a
prime
and
that's
the
the
main
idea
of
the
the
new
memory
table
solution.
We
have
a
translation
of
this
key
of
this
multi-component
key
into
one
single
byte
ordered
sequence.
B
This
try
is
a
single
writer,
multiple
reader
thing.
So
if
you
want
to
have
good
performance
in
multi-threaded
machines
in
multi-core
machines,
you
actually
need
to
shark.
The
mem
table
that
is
separated
into
several
components,
split
by
by
token
ranges
so
that
you
can
do
multiple,
writes
in
parallel
and
then
the
implementation
of
the
mem
table
itself
is
using
some
some
interesting
features
to
make
it
as
efficient
as
possible.
B
B
That
is
notes
that
have
many
many
children
very
close
to
the
roots
after
that
comes
a
space
with
lots
of
notes
with
very
few
children
up
to
two
three
five,
ten,
usually
not
more
than
that
and
below
this
in
the
tree,
you
see
a
lot
of
change
of
single
child
nodes
and
at
the
end
you
have
leaves-
and
if
you're,
if
you
count
the
notes
that
are
there
most
of
the
notes
are
leaves,
then
you
have
a
lot
of
chain
nodes.
Then
you
have
quite
a
few
sparse.
A
A
B
Disk,
because
you
can,
you
can
use
the
pointer
to
give
you
an
index
in
an
array
and
completely
safe,
storing
this
in
the
try
structure.
One
of
the
other
important
bits
about
about
the
mem
table.
Try
is
that
you,
we
use
a
fixed
block
size
which
makes
it
much
easier
to
to
do
memory
management
in
in
the
dry
structure.
So
the
idea
here
is
that
we
want
to
do
our
own
memory
management.
B
We
want
to
use
an
off
Heap
block
of
memory
or
a
non-key
block
of
memory,
but
the
thing
is
we
don't
want
to
give
the
garbage
collector
access
to
the
individual
pointers
individual
blocks
in
this.
We
want
to
manage
them
ourselves
so
that
the
garbage
collectors
is
just
the
one
big
block
never
looks
into
it,
and
so
coverage
collection,
Cycles
are
faster
and
there
are
no
garbage
collection
poses
or
shorter
garage
connection
causes.
The
way
we
do
this
is
by
managing
ourselves
ourselves.
What
what
blocks
we
take?
B
What
blocks
are
no
longer
needed
and
can
be
reused,
and
to
do
this
most
efficiently,
we
use
the
fixed
block
size.
This
is
usually.
This
is
32
bits
in
the
32
bytes
in
the
current
implementation
and
because
32
bytes
are
not
enough
to
fit
all
the
256
transitions
that
at
most,
you
can
have
for
a
single
note.
We
do
a
different
trick.
We
instead
do
SUB
transitions,
so
we
kind
of
changed
the
width
of
the
transition
that
we
that
we
need
to
take
when
we're.
B
A
B
B
B
We
can
fit
the
dense
node
into
multiple
of
these
fixed
block,
size
blocks
and
yeah.
You
can.
What
was
the
number
we
can
have
up
to
several
sorry
eight
times,
eight
plus
one,
so
we
can
have
up
to
65,
I.
Think
notes
that
form
one
dense
node
if
it's
fully
fully
dense,
if
it
has
mapping
for
every
for
every
job
for
every
possible
transition,
but
it
also
allows
us
to
get
rid
of
some
of
these
children
and
make
it
take
less
space.
B
The
other
side
of
this
taking
advantage
of
this
fixed
block
size,
is
when
you're
closer
to
the
leaves
when
we're
in
the
spaces
of
them,
then
they
will
try,
which
have
only
a
single
child.
We
can
combine
multiple
such
transitions
into
one
single
block.
So
in
the
example
here,
the
chain
that
starts
at
ox18
has
several
Transitions
and
all
of
them
are
in
the
same
block
the
whole.
B
Actually,
the
zero
zero
book,
which
extends
from
from
the
address
0
0
to
the
address,
0,
1,
f,
inclusive,
and
in
this
one.
In
this
example,
here
we
have
four
characters:
being
four
Transitions
and
four
notes
being
placed
into
the
same
block
and
the
pointer
after
it
takes
us
to
a
entry
in
the
content
array.
So
the
value
that's
associated
with
the
words
e
r,
a
c
k,
o
r
or
tractor
using
fixed
block
sizes,
has
two
objectives.
B
But
the
thing
is
that,
when
we're
accessing
even
one
byte
we're
taking
the
whole
cache
line
with
us,
it
makes
a
lot
of
sense
to
be
to
to
take
the
most
Advantage
you
can
out
of
out
of
this
whole
cache
line
that
you've
brought
in
the
other
thing
I
mentioned,
is
that
we
use
pointer
tagging,
which
means
that
we
store
integers
integer
pointers
in
in
our
data
structure,
which
have
some
bits
that
determine
on
one
side.
What
kind
of
what
kind
of
node
is
this
node
we're?
B
Looking
at
so,
for
example,
Sparks,
No,
sparse
nodes
started,
it's
ended
e
and
one
so
the
last
five
bits
of
a
pointer
are
actually
these
tag
bits.
That's
because
we
have
32
32
bytes
per
block,
so
all
the
last
five
bits
give
us
the
block
ID
and
the
last
five
bits
are
information
about
what
is
the
type
of
node,
and
if
the
node
is
a
chain
node,
we
actually
actually
know
which
one
node
we're
actually
looking
at
inside
the
chain.
B
So,
for
example,
these
ox19
here
points
to
the
nodes
with
pointer
T
and
the
the
target
of
this
transition
with
the
with
the
character.
T
is
just
the
next
address,
which
is
ox1a.
It
doesn't
need
to
be
written
anywhere
because
it's
because
that's
the
way
that
the
chains
are
stored,
the
other
usage
of
these
terminals
is
for
for
leaves
in
the
try.
We
store
a
negative
number
and
this
negative
number
Maps
into
an
entry
in
the
content
array,
so
in
in
the
array
of
values
that
we
have
from.
B
Now
one
thing
that's
important
about
another
thing:
that's
important
about
this
price
is
that
we
have
a
very
efficient
way
of
working
them
which
basically
using
the
so-called
cursor
we
can,
when
we're
trying
to
list
how
the
the
keys
and
values
present
in
the
try.
We
can
do
this
with
a
very
efficient
mechanism
where
we
use
a
cursor,
which
is
something
that
walks
to
try
and
lexicographic
order.
So
it
works
out
all
the
notes
in
the
Try
Not
Just
ones
that
have
content,
but
just
everything.
B
So
in
this
example,
the
first
note
we
want
to
visit
is
T
because
out
of
the
all
of
the
nodes
here,
this
is
first
inexiographic
order.
Then
the
next
one
is
something
that
extends
this.
What
we've
collected
so
far
with
another
character
and
that's
R,
the
third
one
extends
it
with
yet
another
character,
a
and
so
on.
Until
we
reach
the
tractor
point
and
then
the
next
one
in
the
lexicographic
order,
is
moving
back
up
the
chain
and
using
the
the
next
transition
of
the
first
closest
node.
B
A
B
B
B
Way
of
working,
the
data
is
to
have
a
linked
list
at
the
bottom
and
to
just
follow
this
linked
list.
But
the
problem
with
with
having
the
linked
list
at
the
bottom
is
that
in
that
case,
you
need
to
store
the
the
keys
of
each
partition
or
which
element,
and
this
linked
list
and
this
defeats
the
purpose
of
the
try,
which
is
to
Only
Store
the
paths.
A
B
B
The
new
mem
table
for
a
longer
period
or
in
a
bigger
test.
We
can
see
that
this
throughput
Advantage
I
mean
this
disadvantage
in
in
the
time
it
takes
to
write,
translates
into
a
much
better
burst
throughput
than
using
the
Legacy
mem
tables,
and
if
you
optimize
things
a
little
further
and
use
better
compaction,
you
can
also
maintain
this
higher
sustainable,
but
when
you're
doing
a
much
longer
process,
in
this
case,
it's
more
than
20
hours.
Sorry
for
the
blue
graph,
it's
more
than
10
hours.
B
The
the
efficiency
or
the
the
processing
time
of
the
mem
table
stops
to
matter
that
much
and
the
thing
that
becomes
more
important
is
the
size
of
the
gas
is
stable,
so
level
zero,
which
we
already
said
to
be
improved
and
also
how
how
much
work
coverage
collection
has
to
do,
and
we
improve
all
these
things
so
that
so
we
managed
to
get
much
better
longer
term
performance
as
well
latency
reduction
with
fixed
rates
and
what
we
wanted
to
achieve.
Much
better
total
garbage
collection
time
than
the
previous.
B
A
B
Legacy
member
implementation,
one
of
the
things
that
you
may
worry
some
people
is
the
fact
that
we
do
sharding,
which
means
that
we
split
the
mem
tables
into
several
independent
components
so
that
you
can
write
in
parallel
to
each
of
these
components,
because
the
keys
are
harsh
for
I
mean
because
every
partition
starts
with
the
token
which
is
Hash.
This
usually
gives
us
better,
pretty
good
distribution
of
work,
and
you
can
achieve
a
better
performance
that
you
can
achieve.
B
Even
with
a
parallel
with
a
limited
structure.
That's
meant
to
be
concurrently
modified
in
this
example.
Here.
The
first
graph
is,
without
any
I
mean
with
randomly
distributed
load,
and
in
this
case
you
can
see
that
the
the
parallel
structure,
the
skip
list,
is
actually
slower
than
a
different
version
of
the
same
structure
which
which
is
sharded,
and
that
is
slower
than
much
lower
than
the
try
implementation,
which
is
again
Charlotte,
but
faster
individual
operations
and.
B
You
can
switch
between
the
the
threats
processing,
individual
Assurance,
it's
actually
more
efficient
to
do
blocking
than
to
do
parallel
processing.
Here
the
thing
change
changes
when
you
do
more
access
to
the
same
key.
In
this
case
you
have
to
you're
actually
hitting
the
same
chart
many
many
more
times
and
if
you're
half
of
the
time
you're
hitting
the
same
exactly
same
value,
you
can
see
that
the
skip
list,
the
parallel
structure,
becomes
faster
than
the
blocking
structure
and
the
try
becomes
even
slower,
but
50
skew.
B
B
B
You
do
this
by
setting
mem
table
configuration
specifying
a
specific
configuration
giving
it
your
name
in
this
case.
Try
which
refers
to
the
class
name:
crime,
M,
cable,
the
next
two
lines
change
the
default
for
for
the
node,
so
every
time
you're
creating
any
table
it.
If
you're,
using
if
you're,
adding.
If
you've
added
these
two
lines
to
the
Cassandra
ammo,
it
will
always
use
the
dry
man
table.
B
This
here
try
refers
to
the
definition
of
try
given
under
configurations
so
yeah.
So
if
you
want
to
use
it
individually
per
table,
specify
for
for
only
some
tables
and
use
the
default
for
address,
you
would
use
the
same.
The
first
four
lines
so
that
this
configuration
without
the
default
part-
and
you
will
specify
it
in
in
an
alter
table
statement
to
a
table.
You
want
to
use
it
on
now.
B
One
of
the
important
things
about
this
work
is
that
it's
not
finished
at
all
and
it
enables
a
lot
of
things.
One
of
the
things.
The
first
thing
that
enables
is
in
mem
tables
to
completely
eliminate
the
map
hierarchy.
So
instead
of
this
skip
list,
map
that
takes
us
to
to
a
partition
and
each
partition
has
another
big
tree
map
which
takes
us
to
the
row,
and
each
row
has
another
big
tree
map
which
takes
us
to
columns
and
cells.
Instead
of
this,
we
can
have
one
big
try,
which
has
some.
B
Which
has
some
just
some
pointers
that
at
some
points
tell
you
well,
this
is
the
partition,
boundary
and
then
continues
onwards,
and
then
at
some
point
it
can
specify.
You
can
say
that
this
is
a
row
boundary
and
it
can
continue
onwards
to
individual
cells.
So
everything
can
be
stored
in
one
single.
Try
in
one
single
object
in
memory,
which
can
be
completely
something
that
the
garbage
collector
doesn't.
A
A
A
B
B
B
Actually,
we
have
an
opportunity
to
also
change
how
we
store
some
values
and
how
we
store
metadata
in
a
way
that
lets
us
do
much
more
efficient,
compassion,
mostly
being
able
to
see
at
some
point
that
all
of
this
that's
below
this
point
in
the
try
comes
from
only
one
source.
Only
one
ss
table-
let's
not
look
inside
it
at
all,
just
take
it
as
it
is
it's
by
it's
on
disk
and
move
these
bits.
This
bytes
to
another
file
having
this
can
improve
performance
of
of
compaction
tremendously.
B
Generally,
we
know
that
tombstones
are
a
problem
for
Cassandra,
and
this
is
an
opportunity
to
completely
solve
it,
rather
than
trying
to
reduce
the
number
of
tombstones
just
not
care
how
many
there
are
and
towards
the
end.
If
we
have
a
representation
of
of
data
and
one
this
big
try
with
these
simple
flat,
Keys
byte
sequences,
we
can
also
change
the
way
partitioning
is
done,
meaning
that
we
can
start
using
some
prefix
of
this
long
byte.
B
As
the
the
boundary
between
nodes,
so
right
now
we
have.
We
can
only
use
tokens
as
the
boundary
between
nodes,
which
gives
us
problems
if
we
want
to
have,
for
example,
tables
which
are
completely
ordered,
which
you
may
want,
in
case
of
in
case
you're,
trying
to
do,
for
example,
a
global
secondary
index
or
materialized
view,
or
something
like
that,
and
if
we're,
if
we're
able
to
to
use
well
to
use
I,
mean
to
decide
to
split
data
anywhere
in
that
key
or
any
prefix.
B
A
A
A
I
can
drop
a
link
in
the
chat.
Actually
you
can.
We
can
have
a
look
at
have
a
look
at
some
recordings
on
there
always
great
to
catch
up
on
those
yeah.
So
thank
you,
brandemia.
That
was
great
I
appreciate
you
taking
the
time
to
share
with
us
and
yeah
excited
about
this
work
going
into
going
into
Cassandra
before
we
before
we
close
off
just
a
couple
of
announcements.
One
is
a
reminder.
A
So
on
December,
12th
and
13th
we've
got
Cassandra
Summit
coming
up
in
San
Jose,
which
is
very
exciting
you
can
you
can
get
your
tickets
now.
You
can
register
for
right
now
the
I'd
stop
the
link
to
it
in
the
chat,
so
you
can
get
your
tickets
for
that,
and
also
we
have.
Our
next
contributor
meeting
will
be
on
the
26th
of
September
10
a.m.
Pacific
we
don't
have.
A
We
will
we'll
announce
the
once
the
once
we
were
confirmed,
we're
not
to
speak
in
the
topic
for
that
and
we'll
be
on
the
Wiki
page,
which
is
should
I
just
drop
a
link
to
as
well.
So
you
can.
You
can
check
that
out
and
be
the
same.
Zoom
link
and
yeah
that's
going
to
be
great,
and
then
we've
got
a
end
of
September
28th
of
September
8
A.M
Pacific
as
our
next
town
hall,
which
we
will
announce
the
speaker
for
that
soon.
A
But
that's
it.
Thank
you
so
much
again,
the
recording
will
be
up
online
later,
so
you
can
check
it
out
and
share
and
we'll
be
linked
on
the
the
Wiki
page
on
conference
as
well.
So
thank
you
for
joining
everyone
and
thank
you
for
sharing
brenamia,
that's
been
great
to
hear
from
you.
Thank
you,
cheers
everyone.