foreign
[Music]
runs a team of solution Architects at
Ivan who focus on a whole collection of
Open Source tools running in public
clouds today's our speaker will cover
the difference between regular databases
and columnar databases and how to get
the best performance out of clickhouse
government database please welcome our
speaker thank you very much
[Applause]
um just like every good cooking show
folks I like to start with something
that is something we prepared earlier
when we get to the demo this is what
you'll be seeing uh there's just a
little clickhouse service that I've
created here if anyone really cares it's
running in Google in southeast one but
that sort of doesn't make too much of us
and you'll see that I've also created
this data file ah that does some things
like create some tables and load some
test data for us more from our demo
service later in the presentation
so welcome everyone thank you very much
I want to start by saying thank you for
joining us here today my name's Troy
sellers I'm a Staff solution architect
for a company called Ivan
um we do many things that Ivan one of
the things that I think I'm most proud
of is the company's contribution to the
open source Community we were founded in
2016 uh by four pretty passionate uh
software Engineers that were committing
to the postgres project at the time and
one of the things they wanted to do was
give back to the open source community
and so they had this idea they could
create a company that runs purely open
source data technology and today we've
got 10 I think I think it's around 10
Engineers that work for our open source
project office whose entire job is to
commit back Upstream into projects like
Kafka projects like postgres and
projects like open search
and so I'm really proud to be able to
come down and talk to everyone about
open source technology and what we do a
staff solution architect at Ivan we are
the technical support for our customer
base in a lot of in a lot of scenarios
when you run 12 different open source
open source data projects what that
means is I am a jack of all trades and a
master of none so I want to get started
today who here is an expert in Click
house
perfect
my just in time learning will suffice
excellent so that doesn't surprise me
right like I um heard it first heard
about clickhouse about mid last year
when it came internally into a company
that we're going to start running this
service for our customers and so I
jumped in and this is a good example of
what this presentation might be is the
things I had to learn about to
understand what clickhouse was in order
to talk to people like yourselves about
it
so thank you for joining me today's
journey is going to be pretty simple
we're going to sort of start off and
we're going to cover like what is just
the main difference like we want to talk
about what the problem is that
clickhouse is trying to solve and I
think it's an important spot to start
there
um because that'll lead us to what click
house is and what are the business cases
that we should be thinking about using
it and how you know why does it work the
way it does and all those kind of things
we'll show you a little demo because
what's this technology presentation
without a demo
and then we'll talk a little bit about
some of the things that you should not
do with clickhouse okay this is not the
kind of thing that you like throw all
our databases out we have a new database
now I'd encourage you not to think about
it like that
uh and finally uh there'll be some QR
codes and stuff like that so you can
scan for further resources
um which is mainly just links to
documentation
uh sound good
so thank you everyone in the room thank
you everyone online for joining us I
know we're going out live today as well
so that's pretty exciting for me it's my
first live stream presentation ever I
think so let's talk a little bit about
data and the purpose of data
and what that means to people let's
imagine a couple of things that we're
all pretty familiar with okay uh online
shopping right
um some iot devices there's that concept
of this you know this stream of events
any kind of application that you have on
your phone
right the amount of data that's coming
out of today's modern world uh to to
roll out and often overuse Trope uh is
growing exponentially and there's no
sign of stopping that and this is the
kind of thing that really helps us as
technologists clickhouse is the kind of
database that helps us as technologists
make sense of all that data okay as as
the size of data increases and the
volume and frequency of data increases
historically we had to make decisions
about which data we thought was going to
be useful to support the business cases
we're trying to support and quite often
we had to make decisions about which
data should we throw away
which data should we not collect at all
okay and then we had to sort of look
forward into the future and try and
imagine what questions people were going
to ask us
so we could keep that data
um there is to keep keep that data
that's ready for queried
um this was kind of a function of
storage being a little bit expensive it
was kind of a function of like how hard
it is to process data sets uh in certain
scenarios with some sort of more
traditional Technologies but today
you'll see this is pretty relevant when
we talk about analytics and the analytic
power of clickhouse this is a really
good example of where this starts to
come in has anyone heard of Apache Kafka
everyone and everyone that's definitely
the type of question that everyone's
supposed to raise their hand to it's
just to see if everyone's awake but that
concept of like you now have an
unbounded continuous stream of data okay
so how do you start to choose which
event in this stream is going to be
relevant okay and these kind of
real-time streaming event-driven
architectures as they're called really
highlight that problem how do you make
the decisions about which data you want
to keep
and it's an interesting thing to think
about we've all sort of heard these
terms does it go into a data warehouse a
data Lake do you put it in a database
these things mean different things to
different people
my favorite follow-up question when
anyone tells me they have a data
warehouse is what do you think that
means
and I've heard answers from actual data
what I think an actual data warehouse is
to I've run it in postgres to we have S3
like it's there's all sorts of things
it's a really big umbrella term
and so we want to talk a little bit
about where does click house fit into
this uh at Ivan we are fair to say
pretty popular with postgres which we we
do love postgres we run a lot of it like
I said our first service we ever ran uh
was postgres but it's fair to say that
postgres is not the solution here okay
you're going to run into problems just
with size and storage on disk and stuff
and that is because of a fundamental
nature in the way that these things work
um if you're not familiar with this like
you've probably already all heard about
this this difference between transaction
processing and analytic processing so
let's imagine that online store scenario
okay you've got a shopping cart you've
got someone that comes in let's say that
Catherine here she wants to come in and
go shopping and there's an awful lot of
data that Catherine might interact with
but there's some interesting things
right she might update her delivery
preferences she might update her phone
number her email address there is a row
in a transactional database that she is
going to be interacting with
okay and the the way that that database
works is built to make sure that you can
find that row update that row very
efficiently very quickly okay indexing
and all this kind of stuff we'll talk a
little bit about it but it really solves
that problem Catherine wants to come on
in and update a record that's particular
to her
she wants that to be in a transaction
okay it needs to be
um consistent
then there's this different type of
interaction that happens on this online
store
while Catherine is navigating that she's
looking at products she's clicking on
links okay she's coming in and out
having different sessions there's all
sorts of things she's adding things to
carts she's removing things from cart
she's might be clicking the buy button
there's all these different events on
this kind of online store that are
different to that
concept of like her single record and
these events we typically want to start
to do some kind of analytical processing
on
what is the most popular product people
are looking at what is the most popular
you know product that's been added to
cart in the last 12 hours right these
kind of things typically are different
queries from a transactional database
typically they aggregate large volumes
of data
okay typically the data is immutable
this event stream data is pretty
interesting about that typically
and they don't retrieve an entire row of
data okay they're going to aggregate
across just a few Columns of that data
set
this is like sort of the main takeaway
for you take away from what's the
difference here between click house and
a transactional database it's this slide
okay if you're online you can flip to
YouTube now uh that's that's it okay
this is the thing is that when you're in
an analytical processing database you
usually only want to retrieve some of
the data to do some aggregations across
it and that leads us quite nicely into
how clickhouse does this and what click
house is for
so a brief history again for those like
no one's really familiar with it click
house
that use case we just described that
capturing web analytics was exactly what
this database was described and built
for it's built by a company called
Yandex in 2016 an open sourced out of
the generosity of their heart for all of
us to enjoy and love
Yandex are the second largest web
analytics platform in the world
according to Wikipedia based out of
Russia
but that concept of like ingesting
hundreds of millions and billions of
rows of data really really quickly and
then running aggregation queries on it
is exactly what this technology was
built for
since then I thought it's really good to
talk about like just the open source
Community behind this project like the
community's really taken this project
and and run with it there's a lot of
total contributors there's a really a
real strong collection of active
contributors to this project and it's
really becoming popular out there in the
world
it's one of those things that we don't
take on lightly as well like as we
there's a fairly strong consist criteria
about us adopting a project to operate
for our customers
um
and that's definitely one of them
so we talked about this idea of what
Rowan orientated data looks like in
postgres now when you sort of scratch
underneath the surface what that means
is that the rows themselves are
typically stored in contiguous files on
disks okay and so it means that if you
want a row you can go and find that row
and you're not scanning across different
parts on disk you're actually getting to
it really quickly and you can go right
this row is this big I can just scan
this many bytes and I have that row of
data okay this works really good but if
you can see if you want just to
aggregate one column there's an awful
lot of data you have to read off disk
hold in memory and throw away okay it's
wasteful in that kind of sense and so
you're kind of reading the whole
database to do an aggregation query
where if you think about a columnar or
orientated database rather than storing
rows you store columns as files and if
you get into the uh you know workings of
the clickhouse database when you open up
and see the file system this is exactly
what you'll see you'll see an index
you'll see a few other indexes in there
in each for each table and then you'll
see a file per column
okay and that makes it really simple to
say aggregate all the data in one column
because now I only have to go and read a
single file okay I don't have to pull
that record out of individual files or
places on disk
and this is why this sort of really
helps one of the sort of first kind of
things that makes click house incredibly
performant for this is just the very
simple fact that the way data is stored
on disk is different and this column of
database is not brand new to click
houses there's heaps other services that
do this column of stuff
um
what's interesting about that also is
that this is one of the things that
clickhouse does really well is that now
that you have Columns of data you also
have Columns of the exact same data type
and it's not immediately obvious but
what clickhouse allows you to do here is
now you can specify individual
compression algorithms that are suited
for the particular data type that you're
storing on disk so not only is
clickhouse incredibly fast at retrieving
data it's incredibly efficient at
storing it on disk like it's incredibly
efficient where there's a benchmark post
somewhere on our blog that just talks
about the size we benchmarked click outs
against a postgres service on a data set
of about four and a half billion rows of
data
and the size on disk was about half
like and it's just because of this
efficiency that you get if you've got
all integers or if you've got all time
stamps or if you've got all floats you
can start to specify individual
compression algorithms on those as you
write that to disk it's kind of useful
here's an example of how you'd create
that and sort of if we wanted to get
down and dirty with it yourself when you
create those tables you can specify
individually how that data is going to
be stored on disk
the second thing to talk about is in
this column orientated fashion and by
the way this is a broad brush on just
some of the things that clickhouse does
to make things incredibly efficient It
Is by no means an exhaustive list so if
you're interested in some of this stuff
then I definitely recommend hit the
documentation for click house
but clickhouse has a primary index who
knows what a primary index is
yep again another one just to check
everyone's awake
um
so there is a primary index in Click
house one of the first surprising things
about a primary index that I found is
that it's not unique
there is no requirement for uniqueness
in your primary index
uh the second thing
is it's what's called a sparse index and
so what that means is for every 8 192
rows of data you have an entry in your
primary index
the thing again that's not immediately
obvious this means that this has got
some kind of sort order in it
okay now this sounds really odd about
but then you think about what analytic
queries do
okay so analytic queries probably don't
go and fetch a single line of data from
the database
okay analytic queries probably aggregate
over millions or hundreds of millions or
billions of rows of data
and if you think let's let's call that
ten thousand because the maths is easier
there's now a thousand or a hundred rows
in the index for every million records
okay and so that when I want to go and
scan a subset of data I can go and pick
out blocks
um what they're called granules of data
and and sort of read that in into memory
and process it really quickly one of the
things you'll find when you start to
work with clickhouse it's very very good
at figuring out exactly what data to
read into memory
okay and it's very good at leaving
memory on disk if it doesn't need it
this sparse index is one of those things
now you can specify different primary
keys and sort orders on tables typically
they're the same value
8192 apparently makes more sense for
those that think in binary
I'm one of the 10 people I think in
normal numbers
um and it just sort of makes that a bit
easier to to look at the the second
thing that you can Define one of the
other things I should say that you can
Define in Click house is a skip index
um now it's kind of analogous if you if
you're familiar with sort of more
relational data structures of defining
secondary indexes on your database so if
you're familiar with like a primary
index and then you can define a
secondary index to say help search
performance or something like that in a
postgres service it's kind of analogous
to that
um
but remember we don't store data in rows
so having a secondary index on that row
of data sort of doesn't really make
sense so what you can Define is a thing
called a skip index
and Skip index pardon me skip indexes
allows you to sort of tell the the
clickhouse query engine is that look you
can go to this index and skip over a
certain amount of data
all right inside that it defines what
you can skip when you're processing it
and a good example of something like
this might be um
sorry
you think about like you've got a Time
series data right that let's go back to
that online web store it's a great
example you are going to have time
series data excellent use case for your
primary key it's going to be ordered
it's going to be blocked it's going to
be searchable right all that kind of
stuff but then you might say well you
know what we've got a pretty well-known
requirement that we want to aggregate
every 403 error
okay we want to know when people are
trying to log in and it's failing and we
want to we want to be able to aggregate
that so that kind of HTTP error might be
make a really good skip index you want
to say we're going to query this table a
lot for all the 403 errors and it will
keep a secondary index on disk about
wherein each block the 403 errors live
and so you can go and query the primary
index it'll query the secondary index
and it'll only pull that data together
for that query
there's a lot more to talk about with
skip indexes this is sort of one of the
the interesting pieces of clickhouse
that when you get right into the details
you'll start to talk more about it
there's a number of sort of other
mechanisms around indexing that's
worthwhile to understand about
clickhouse but like where I find that's
really interesting is that all these
things are kind of focused on
how to take a query and not retrieve
data from disk and it's very efficient
at that
and so to answer finally answer the sort
of the fourth part of this what I
thought was important to talk about in
the time we had today when we talk about
the speed is like we've covered it's a
column in a database and and the
advantages of that for querying we've
talked about you know the data
compression by type which is kind of
used we've talked about this physical
sparse index the primary keys and then
the last thing is this vectorized query
execution which is a very long-winded
say work long-winded way of saying that
it uses multiple processes
okay so because it was written in the
world of
um multi-processor computers they've
understood that they can take a column
of data and separate it
and run it on the processes that are
available and aggregate the result uh
in the end there and there's a lot of
stuff that happens underneath the covers
this is one of those nice things about
clickhouse that you never have to worry
about it just does it and so it really
takes a lot it really takes advantage of
the hardware that's available uh to the
servers
so it's really nice and again I sort of
mentioned the Benchmark that we did it's
worthwhile if you're really interested
to jump out and have a look at it while
you're looking at benchmarks I would
encourage you to all to take that with
the largest grain of salt that you can
find
benchmarks make an awful lot of
assumptions about data
and so the data set that we've
benchmarked our stuff on might not be
the data set that you want to run on
um but it's it's an interesting sort of
heuristic to think about
so let's talk a little bit about uh
let's see click house in action
um and and we'll we'll see how we can
run some queries and stuff here oh yeah
so I was going to tell you what what
we're going to show let's do that
oh yeah there's a data set that is all
the menus
uh for restaurants in New York from like
1850 uh onwards it's on the clickhouse
documentation there's a whole bunch of
test data sets uh this data set I think
it's about 1.3 million rows so it's not
massively huge but it's kind of fun to
play with it'll work today
um
I am going to use
my clickhouse client today
excellent okay so let's start with just
sort of have a look at what we've done
here so the first thing to note is that
the clickhouse data set comes with four
tables
and we've created this denormalized
table here as well
okay
remember what we spoke about
the difference between analytical
processing and transaction processing
how one's row based and one's column
based the fact that if you've got column
based data sets and column based
processing means that really wide data
tables with plenty like hundreds and
hundreds and thousands of columns
work really well in Click house
it works really really well allows you
index it allows you to query it back
remember we're only ever going to pull
columns so you get no penalty at all for
having denormalized data so it's a
really good thing to do so what's
happened here as part of the script is
we've taken that and we've denormalized
that data set
um so let's have a look at some queries
and because no one wants to watch me fat
finger a keyboard
I'm going to copy and paste that so
let's take a quick query and run that
here so what have we got we've taken per
per decade account an average price of
the menu and you'll see
that things were pretty stable for a
while and then things got expensive if
anyone's been to Manhattan lately you
probably understand this to be true what
is really interesting about clickhouse
It's probably hard to see from up the
back especially this is what I kind of
like down the bottom that took point so
two tenths of a second to process 1.3
million rows of data and it actually
scanned in 54 Meg of data which is by no
means the entire data set
okay and when you start to play with
click house this kind of response works
really well
think about the use case where this is
really well deployed into your business
okay what's really fantastic about
clickhouse is real-time analytics
especially if you want to expose this
out to say your customers or to people
on a mobile phone or you want to have
that analytics engine out in your
customers world where they can sort of
query it themselves or you know use a UI
to pull data back that's relevant to
them and they get a really performant
experience
um let's have a little look at dishes
what could you buy that had potatoes in
it in 1850
in 1850 in New York you could have
mashed baked plain or boiled
so culinary Extravaganza in 1850s with
potatoes let's have a look let's see
what's happened in 2010 did chefs get
any more imaginative
um let's look at that
they got more imaginative and uh a
little bit wordier
and it's probably about here they
realize that menus are printed on A4
pieces of paper
so but is that yeah is that just
something that's relevant to potatoes or
did we spot maybe is there a trend there
so let's go and have a look
um can we pull out like what's the
length the average length of menu titles
across the years
and as we support yes in the 2000s
people realize that perhaps we're
getting out of mind uh and we've started
to drop back so some fun things uh to
play around with clickhouse again
we're looking at that two hundredths of
a second row these and these are great
like if you look at some of the queries
of what you're doing here you don't
count roundings
extracting things you're running
functions like they are they're queries
that are scanning the entire data set
and this is sort of a really good
example of a queries that work better in
an analytical processing scenario and B
things that pardon me
uh you know that how clickhouse works
and and how it can make some fun stuff
there as well
my favorite let's see if we can figure
out
what the average price of a beer in
uh was and it looks like things got
really expensive there again at
1980s for a buck for a beer
um I don't know I don't trust the data
on that one for some reason I'm not sure
what happened to 28 dollars for beers
but anyway
uh again just some fun things to have
but I definitely encourage you to go and
have a look at the clickhouse data set
there's a lot of different ones in there
there's uh all the rides on taxis and
and stuff there and and you can really
sort of get a feel for how to set this
up and load data ingesting data actually
is one of those things that's really
really useful
um
The Click house is very good at the the
the interesting thing about having a
data set
um
like in column to format and clickhouse
does this very well is that it's really
easy to write data to disk and so if
you're going to load data in and you're
going to set this up in production like
inserting a single row at a time is a
bad idea when you insert data into
clickhouse it takes it and writes it to
disk and then comes back in time and
merges it in and
fills it out and does the things behind
the scenes but its first job is to get
the data and write it to disk
okay so if you're going to write one row
at a time you're gonna get a lot of
these really really small part files
inside your clickhouse data they
recommend like a million records at a
time
to ingest data and so it's a really
really neat kind of scenario
one of the things that we didn't see
pardon me I'll go through this again
this concept these are the data tables
that we're just looking at there's an
interesting thing that you've that might
be new it was new to me this concept of
a table engine and so when you define a
table in Click house you can actually
Define per table how data is stored on
disk like how are you going to treat
that data and there's a number of
different
table engines the merge tree family of
table engines is by far and away the
most common and popular one it's the one
that's for the scenarios we've discussed
is uh is exactly what that's built for
for ingest and analytic queries there's
a few others we'll talk about a couple
others in a second the this replication
merge tree is just a merge tree but also
that is replicated across multiple nodes
quick house supports replication across
multiple nodes for high availability and
all that kind of stuff
I did speak a bunch about primary Keys
remember and you'll notice there's no
Declaration of a primary key there but
there's an order ID
okay so whenever you specify that sort
order order by this ID you're telling it
that I want it to be a primary key as
well so we're going to do the index on
that sort order
um
just for those that are playing at home
some other things that you clickhouse
does is allow some really interesting
type of data formats to pull data into
the database as well there's a lot of
different functions there's a lot of
ways to pull data from other data
sources in two click house
Park a Avro
CSV tsv
protobuf all these kind of things are
available for you to pull in there's an
awful lot of formats to pull into the
database include the clickhouse
engineers have made that very easy to do
you can pull data from S3 you can pull
data from all different sources
we spoke about that this is a good
example this is what we did run okay so
this is how we just pull and denormalize
that data once we got it in there we
just selected
um create the table and you can sort of
create
as a select it's kind of a neat little
way of of building data inside
clickhouse as well there's an awful lot
of different ways to do this functions
or table engines and stuff we won't sort
of talk about that
but what about that scenario we touched
on as like well you've got this stream
of data in Apache Kafka it's unbounded
it's never going to stop how do you get
that across into this world of I want to
be able to run a table
um and and do some real-time stuff well
there's this thing in clickhouse called
the Kafka table engine which connects to
a topic inside Apache Kafka and
represents itself as a consumer group on
that topic
um
what's that what means what's
interesting about that is that you sort
of have to build inside your world a
materialize view welcome to another
table engine uh inside
click house because and for those of us
that have played with Kafka a little bit
you sort of get to read data from a
topic once
and then you advance the offset and so
the idea behind the way clickhouse works
is the the Kafka engine reads data once
the materialized view takes that data
and puts it in a table that you're going
to query multiple times and then your
Kafka engine is ready to read data
at the latest offset in Kafka because
Kafka you don't want to be reading off
disk
uh it's an interesting sort of pattern
uh here at Ivan it's one of those things
we like to make easier those
Integrations so you can kick click a
couple of buttons and get that done
this is just an example of running those
kind of things I mean
this is just a recording of it working
so if it's just a recording is it really
working uh no that's that's just kind of
how this works this is this good example
of running real-time analytics off a
real-time data stream that you want to
do things like expose back to customers
or to different internal business
stakeholders these kind of things really
work really well
um and it's a nice it's a nice pattern
to get used to
the other sort of postgres or the other
table engine we support at Ivan is this
concept of reading data from postgres so
I'll go back to our online store analogy
again
Catherine was looking at product ID 138
right but maybe in this table you want
to know what the name of that product is
what its price perhaps right and so you
can query postgres inside clickhouse
and you can pull up and query that data
either as a reference table and what the
postgres engine will keep that data
table in postgres available to the
service periodically inside clickhouse
and you can then start to use that to
build your queries in Click house and
get some more end use a meaningful type
of reference data if that's kind of one
of your things you can do there is an
interesting pattern we're working on at
the moment in the in the sa group is to
use this concept with the ability to
select from into as a way to Archive
data out of postgres
is kind of a fun kind of world we've got
a bunch of customers that use postgres
for time series database because like I
said we love postgres and so they're
like hey I've got terabytes of this time
series data and postgres how do I get it
to clickhouse all right well maybe we
can run that select into and then you
can clean out that postgres table
uh interesting world we live in now
okay
I hope that some of these things that we
spoke about
sort of fired that use case of uh maybe
I shouldn't use this for transactions
it's not a transactional database
right it's not a transactional database
you can do deletes because we all have
to be gdpr compliant okay but you don't
want to be sort of updating and deleting
individual records in clickhouse you're
not it's not going to like it
it is not a key Value Store
okay
if you want to run redis run redis
um it is not a file store
if you want to S3 run S3 or S3 things
right it's not a file store and it is
not a document store
okay while I say that it does support
Json there's like Json engines and stuff
in there to support Jason so if you want
to drop documents in there but again the
use cases that you typically use
something like a mongodb for back to
that point as they tend to be they can
be update heavy as well right you don't
want to be updating database records
very often inside clickhouse
so I'm going to stop um I think I'm
close to running out of time I wanted to
make sure we left some time for any
questions uh for either in the room or
if we've got the capability to take them
online I'm not entirely sure
um but we'll have a microphone if anyone
wants some questions while someone
thinks about the most hardest question
that you can stump me with that's not
that hard by the way what we've got here
is our over on your left my right is
just a link to a whole bunch of
resources that Elena put together that I
found really helpful to get started for
this on the left
my left your right is a link to a GitHub
repository that is that terraform script
that I built and loaded all that data if
you want and if you want to run that one
there is a free trial for Ivan so you
can go and sort of run quick house
and do that as well I will thoroughly
recommend
um if you're interested getting onto
click house and starting with the
documentation there it's very very well
documented it's very well explained
um but yeah I'll take questions we've
got one at the back I'll just wait for
you to get the mic if we can just so
those online can um
can hold you accountable in the future
years you mentioned like uh pulling in
data so if you have like say a large
number of clients where they be say
mobile app clients or iot devices you
said it's not good to write one at a
time like uh data one at a time what
would be the recommended way to stream
data in is it via directly into click
house or should you be putting that
something in front of it and then
whatever that Services then streams the
data into clickhouse yeah it's a good
question typically I'd probably have
something like Kafka in front of that
Kafka is definitely
um going to handle sort of the ingest on
that does some nice things like order
things in time as well gives you the
ability to process it in other scenarios
there's also a fun conversation to have
around iot devices around network
security and network boundaries because
now you've got to expose endpoints
somewhere to the internet potentially
um
and so again like having either you know
an API and Kafka in front of that I
would prefer to do that rather than
expose my clickhouse service and then
the last which you absolutely hit on
you're still just going to try and
insert one record at a time just at
massive volume I would imagine you would
break click house pretty quickly what
the Kafka engine does which is not
immediately obvious is it actually reads
in batches it'll take that and and take
those batches off that topic and insert
them for you so it handles that for you
as well
good question thank you very much
I wanted to ask is there any integration
with redis
uh is there any integration with redis
that's an excellent question is not at
the moment on the Ivan service I don't
know if there's a redis
function I didn't see one but the amount
of things that I don't know could fill
this room
um so I don't know to be honest I don't
I don't think so but
I'd love to be proven wrong
is there
yeah I don't know
I was about to have a conversation but
the answers I don't know sorry
anything else it was either a
wonderfully concise and easy to digest
talk or not
um
all right hey folks thanks very much for
joining us today I hope you have a
wonderful conference as the first of
three days so I'd like to thank the
organizers for having us here
um it's and I'd like to thank everyone
for turning up as well it's it's always
a wonderful show of support for open
source communities that you folks take
time out of your busy day and I hope you
have a wonderful day and and learn some
interesting things
thank you very much
[Applause]