WEBVTT

00:00:00.020 --> 00:00:03.060
<v Michael Kennedy>How many files does your query read before it reads any data?

00:00:03.500 --> 00:00:07.360
<v Michael Kennedy>On some data lakes, you go through JSON and metadata files first,

00:00:07.720 --> 00:00:10.000
<v Michael Kennedy>just to learn which Parquet files actually matter.

00:00:10.700 --> 00:00:13.180
<v Michael Kennedy>Duck Lake asks one SQL question instead.

00:00:13.860 --> 00:00:15.300
<v Michael Kennedy>The metadata lives in a real database.

00:00:15.700 --> 00:00:17.460
<v Michael Kennedy>The data stays in plain Parquet.

00:00:17.980 --> 00:00:19.060
<v Michael Kennedy>That's the entire format.

00:00:19.660 --> 00:00:22.680
<v Michael Kennedy>Pedro Holanda joined DuckDB in 2018,

00:00:23.320 --> 00:00:25.700
<v Michael Kennedy>and it was still a research prototype at CWI.

00:00:26.080 --> 00:00:27.820
<v Michael Kennedy>He's the lead Duck Lake developer.

00:00:28.320 --> 00:00:32.900
<v Michael Kennedy>And Guillermo Sanchez-Doinas works on DuckLake and the new Quack protocol.

00:00:33.580 --> 00:00:38.900
<v Michael Kennedy>With Quack as the catalog, DuckLake handles 200 transactions per second under heavy contention.

00:00:39.320 --> 00:00:41.600
<v Michael Kennedy>No other open table format even comes close.

00:00:42.320 --> 00:00:48.580
<v Michael Kennedy>This is Talk Python To Me, episode 562, recorded August 31st, 2026.

00:01:06.560 --> 00:01:10.880
<v Michael Kennedy>Welcome to Talk Python To Me, the number one Python podcast for developers and data scientists.

00:01:11.400 --> 00:01:16.720
<v Michael Kennedy>This is your host, Michael Kennedy. I'm a PSF fellow who's been coding for over 25 years.

00:01:17.440 --> 00:01:18.460
<v Michael Kennedy>Let's connect on social media.

00:01:18.540 --> 00:01:21.940
<v Michael Kennedy>You'll find me and Talk Python on Mastodon, Bluesky, and X.

00:01:22.240 --> 00:01:24.060
<v Michael Kennedy>The social links are all in your show notes.

00:01:24.820 --> 00:01:28.340
<v Michael Kennedy>You can find over 10 years of past episodes at talkpython.fm.

00:01:28.520 --> 00:01:31.720
<v Michael Kennedy>And if you want to be part of the show, you can join our recording live streams.

00:01:32.040 --> 00:01:32.540
<v Michael Kennedy>That's right.

00:01:32.730 --> 00:01:36.000
<v Michael Kennedy>We live stream the raw uncut version of each episode on YouTube.

00:01:36.600 --> 00:01:41.020
<v Michael Kennedy>Just visit talkpython.fm/youtube to see the schedule of upcoming events.

00:01:41.210 --> 00:01:44.880
<v Michael Kennedy>Be sure to subscribe there and press the bell so you'll get notified anytime we're recording.

00:01:45.880 --> 00:01:50.900
<v Michael Kennedy>This episode is brought to you by Six Feet Up, the Python and AI experts who solve hard

00:01:51.240 --> 00:01:51.660
<v Michael Kennedy>software problems.

00:01:52.420 --> 00:01:57.380
<v Michael Kennedy>Whether it's scaling an application, deriving insights from data, or getting results from

00:01:57.520 --> 00:02:00.740
<v Michael Kennedy>AI, Six Feet Up helps you move forward faster.

00:02:01.440 --> 00:02:02.880
<v Michael Kennedy>See what's possible with Six Feet Up.

00:02:03.180 --> 00:02:06.000
<v Michael Kennedy>Visit talkpython.fm/sixfeetup.

00:02:06.600 --> 00:02:08.179
<v Michael Kennedy>And it's brought to you by us.

00:02:08.720 --> 00:02:11.900
<v Michael Kennedy>Talk Python and Python Bytes both now have MCP servers.

00:02:12.480 --> 00:02:16.880
<v Michael Kennedy>Point your AI at 10 plus years of Python episodes, transcripts, and show notes.

00:02:17.300 --> 00:02:17.440
<v Michael Kennedy>Free.

00:02:17.840 --> 00:02:21.620
<v Michael Kennedy>Click MCP in the nav at talkpython.fm and at Python Bytes.

00:02:22.500 --> 00:02:23.780
<v Michael Kennedy>Guys, welcome to the show.

00:02:24.260 --> 00:02:25.260
<v Michael Kennedy>Awesome to have you here.

00:02:25.700 --> 00:02:26.660
<v Pedro Holanda>Yeah, awesome to be here.

00:02:27.040 --> 00:02:27.900
<v Pedro Holanda>Absolutely a pleasure.

00:02:28.760 --> 00:02:29.500
<v Michael Kennedy>It is a pleasure.

00:02:30.340 --> 00:02:31.480
<v Michael Kennedy>I'm a big fan of databases.

00:02:31.880 --> 00:02:38.880
<v Michael Kennedy>I think databases unlock so much potential for software and also data science, especially,

00:02:39.060 --> 00:02:41.000
<v Michael Kennedy>you know, talking DuckDB side of things.

00:02:41.240 --> 00:02:46.920
<v Michael Kennedy>But once you really get good with databases, you can just answer questions so well, so quickly.

00:02:47.220 --> 00:02:50.880
<v Michael Kennedy>And honestly, it kind of makes the other side of programming easy.

00:02:51.140 --> 00:02:58.740
<v Michael Kennedy>So I'm interested to see what you all are doing with Duck Lake, do some refreshers on DuckDB and all of these things.

00:02:59.200 --> 00:02:59.720
<v Michael Kennedy>Let's roll.

00:03:00.240 --> 00:03:00.880
<v Michael Kennedy>Let's do it.

00:03:01.400 --> 00:03:01.920
<v Michael Kennedy>Let's roll.

00:03:02.100 --> 00:03:02.320
<v Michael Kennedy>All right.

00:03:02.720 --> 00:03:05.020
<v Michael Kennedy>Well, Pedro, let's have you kick us off.

00:03:05.160 --> 00:03:09.500
<v Michael Kennedy>Before we get into that, just to give everyone a bit about your background, introduce yourself.

00:03:09.920 --> 00:03:10.320
<v Pedro Holanda>All right.

00:03:10.720 --> 00:03:12.800
<v Pedro Holanda>So, well, my name is Pedro.

00:03:13.940 --> 00:03:17.060
<v Pedro Holanda>I came to the Netherlands, I think, about nine years ago

00:03:17.190 --> 00:03:21.400
<v Pedro Holanda>to do my PhD in the Database Architectures Group at CWI.

00:03:22.100 --> 00:03:24.600
<v Pedro Holanda>This is also where I met both Hannes and Mark,

00:03:24.930 --> 00:03:27.540
<v Pedro Holanda>who are the co-creators of DuckDB.

00:03:27.920 --> 00:03:30.580
<v Pedro Holanda>I actually used to live together with Mark,

00:03:30.850 --> 00:03:33.840
<v Pedro Holanda>and Hannes was also my co-supervisor,

00:03:34.120 --> 00:03:36.780
<v Pedro Holanda>so the connection has been there pre-DuckDB, in a way.

00:03:38.260 --> 00:03:45.920
<v Pedro Holanda>And yeah, I did my PhD at CWI and towards the end of my PhD, I had already finished it.

00:03:45.980 --> 00:03:47.260
<v Pedro Holanda>The book was already being printed.

00:03:47.400 --> 00:03:49.800
<v Pedro Holanda>I still have six or nine months to go.

00:03:49.900 --> 00:03:54.000
<v Pedro Holanda>So I just came to market and was like, hey, you guys have this cool research prototype.

00:03:54.600 --> 00:03:55.740
<v Pedro Holanda>Can I do something in it?

00:03:56.140 --> 00:04:01.660
<v Pedro Holanda>And basically start nerding out about it and be having tons of fun since then.

00:04:03.120 --> 00:04:12.280
<v Pedro Holanda>Funny enough, one of the first things I did in DuckDB, I think this is 2018, maybe, like literally the first month that I was in was the CSV reader.

00:04:12.620 --> 00:04:15.080
<v Pedro Holanda>And I came back to it a few years later.

00:04:15.360 --> 00:04:18.560
<v Pedro Holanda>And I'm actually currently working on something that's CSV reader as well.

00:04:18.579 --> 00:04:20.480
<v Pedro Holanda>So it's my true passion, I guess.

00:04:21.260 --> 00:04:23.480
<v Michael Kennedy>You were born to work on CSV.

00:04:24.860 --> 00:04:25.320
<v Pedro Holanda>It seems.

00:04:26.080 --> 00:04:28.920
<v Pedro Holanda>It's also known as the unsexiest database problem.

00:04:29.020 --> 00:04:30.260
<v Pedro Holanda>But what can I say?

00:04:31.300 --> 00:04:40.900
<v Michael Kennedy>Well, I think it's a subset of the unsexiest data science problem, but also the biggest is the data wrangling, plant cleaning, all that kind of stuff.

00:04:41.020 --> 00:04:49.120
<v Michael Kennedy>And CSV is a fairly raw format that doesn't actually communicate a lot of stuff about what types it actually intends that column to be and so on.

00:04:49.420 --> 00:04:55.680
<v Pedro Holanda>The challenge, of course, not only being efficient about it, but also it's a pretty crazy lens.

00:04:55.980 --> 00:04:58.180
<v Pedro Holanda>I call it like the Wild West of data formats.

00:04:58.780 --> 00:05:01.940
<v Pedro Holanda>So being able to actually read these things, it's challenging.

00:05:02.380 --> 00:05:07.300
<v Pedro Holanda>And I guess, well, also the main reason I've been invited to here

00:05:07.400 --> 00:05:10.840
<v Pedro Holanda>is because I've also been working in Duck Lake for the past year.

00:05:11.710 --> 00:05:12.380
<v Pedro Holanda>Oh, yeah, that.

00:05:13.480 --> 00:05:16.740
<v Pedro Holanda>I'll dare to say that I'm currently the main Duck Lake developer

00:05:17.440 --> 00:05:19.520
<v Pedro Holanda>from our team as well for the past year.

00:05:19.740 --> 00:05:21.680
<v Pedro Holanda>So I might know a little bit about it.

00:05:22.280 --> 00:05:24.080
<v Michael Kennedy>Yeah, that is actually why I invited you.

00:05:24.080 --> 00:05:26.120
<v Michael Kennedy>I mean, CSPs are interesting, don't get me wrong.

00:05:27.740 --> 00:05:33.240
<v Pedro Holanda>I have a plan of having CSV files replacing parquet in Duck Lake, and then that's a big comeback, you know?

00:05:33.960 --> 00:05:34.380
<v Michael Kennedy>Oh, yeah.

00:05:34.600 --> 00:05:38.640
<v Michael Kennedy>Just zipped up compressed CSV.

00:05:39.760 --> 00:05:40.720
<v Michael Kennedy>Just give it a new extension.

00:05:40.980 --> 00:05:41.580
<v Michael Kennedy>Nobody will know.

00:05:41.920 --> 00:05:42.440
<v Pedro Holanda>Yeah, exactly.

00:05:42.740 --> 00:05:42.920
<v Pedro Holanda>Exactly.

00:05:43.940 --> 00:05:48.480
<v Michael Kennedy>So it sounds like you were there from early, early days with DuckDB.

00:05:48.910 --> 00:05:52.100
<v Michael Kennedy>Did it come out of the university there, or was it a project after?

00:05:54.160 --> 00:05:56.540
<v Pedro Holanda>So it came out from CWI.

00:05:56.680 --> 00:05:57.960
<v Pedro Holanda>CWA is not actually a university.

00:05:58.260 --> 00:06:00.780
<v Pedro Holanda>It's, in fact, a research center.

00:06:01.200 --> 00:06:02.600
<v Pedro Holanda>So this is also kind of a fun thing.

00:06:02.720 --> 00:06:03.820
<v Pedro Holanda>If you're doing a PhD there,

00:06:04.140 --> 00:06:06.740
<v Pedro Holanda>you need to also be affiliated to a university to get a diploma.

00:06:07.380 --> 00:06:08.760
<v Pedro Holanda>But you don't really step on the university.

00:06:08.860 --> 00:06:10.340
<v Pedro Holanda>You just stay at the research center.

00:06:10.740 --> 00:06:15.200
<v Pedro Holanda>But the story goes that we had a bunch of projects

00:06:15.460 --> 00:06:17.080
<v Pedro Holanda>with different companies as well during our PhD.

00:06:17.260 --> 00:06:18.640
<v Pedro Holanda>So I was working with Honda.

00:06:19.200 --> 00:06:20.720
<v Pedro Holanda>Mark was working with Dottis too.

00:06:20.940 --> 00:06:22.660
<v Pedro Holanda>And these were more like data science-y projects.

00:06:23.220 --> 00:06:25.440
<v Pedro Holanda>And one thing that was very clear to us,

00:06:25.740 --> 00:06:28.740
<v Pedro Holanda>And Hundes also had a lot of influence in the R community.

00:06:29.060 --> 00:06:31.060
<v Pedro Holanda>And I think that one thing that was clear to everyone

00:06:31.240 --> 00:06:33.800
<v Pedro Holanda>was that everyone was trying to run away

00:06:34.080 --> 00:06:35.200
<v Pedro Holanda>from database systems, right?

00:06:35.340 --> 00:06:38.060
<v Pedro Holanda>Like you would see people using data wrangling tools,

00:06:38.340 --> 00:06:40.020
<v Pedro Holanda>data frame tools, things like that,

00:06:40.240 --> 00:06:42.040
<v Pedro Holanda>but no one wanted to use a Postgres

00:06:42.140 --> 00:06:44.540
<v Pedro Holanda>or things like similar to that.

00:06:44.860 --> 00:06:47.040
<v Pedro Holanda>So I think like Mark and Hundes noticed that gap,

00:06:47.300 --> 00:06:47.720
<v Pedro Holanda>noticed that like,

00:06:47.840 --> 00:06:49.780
<v Pedro Holanda>why are people not using database systems

00:06:50.040 --> 00:06:51.720
<v Pedro Holanda>and started talking to these data scientists

00:06:52.000 --> 00:06:54.279
<v Pedro Holanda>and quickly realized there was a lot of frustration

00:06:54.700 --> 00:06:56.320
<v Pedro Holanda>in setting things up, running queries.

00:06:56.650 --> 00:06:59.700
<v Pedro Holanda>Like I remember that during my PhD,

00:07:00.000 --> 00:07:01.620
<v Pedro Holanda>anything that I wanted to do with like MonitDB

00:07:01.800 --> 00:07:03.660
<v Pedro Holanda>or Postgres would take me just like a day

00:07:03.900 --> 00:07:05.820
<v Pedro Holanda>to build things from the sources

00:07:06.100 --> 00:07:07.320
<v Pedro Holanda>and set up a database system.

00:07:07.660 --> 00:07:09.400
<v Pedro Holanda>And we might take it for granted nowadays

00:07:09.740 --> 00:07:12.900
<v Pedro Holanda>that you can just like bootstuckDB up in half a second

00:07:13.160 --> 00:07:15.560
<v Pedro Holanda>and in one line you are querying something.

00:07:15.840 --> 00:07:19.140
<v Pedro Holanda>But yeah, like 10 years ago or nine years ago,

00:07:19.300 --> 00:07:20.680
<v Pedro Holanda>this was very much not the reality.

00:07:21.020 --> 00:07:22.159
<v Pedro Holanda>So they realized the gap

00:07:22.320 --> 00:07:25.820
<v Pedro Holanda>and started doing this research database system,

00:07:25.960 --> 00:07:28.840
<v Pedro Holanda>let's say, more of like, yeah, towards academia.

00:07:29.880 --> 00:07:31.500
<v Pedro Holanda>And I think at some point they had the realization

00:07:31.840 --> 00:07:33.520
<v Pedro Holanda>that a lot of people were taking it quite seriously.

00:07:34.100 --> 00:07:36.980
<v Pedro Holanda>And a lot of people were already trying it.

00:07:38.380 --> 00:07:39.860
<v Pedro Holanda>This is also the funny thing.

00:07:40.040 --> 00:07:41.200
<v Pedro Holanda>People try things in production,

00:07:41.370 --> 00:07:43.160
<v Pedro Holanda>even though it's not yet to release.

00:07:44.140 --> 00:07:45.120
<v Pedro Holanda>Same thing with DuckLake.

00:07:45.600 --> 00:07:47.240
<v Pedro Holanda>We had people use it in production

00:07:47.460 --> 00:07:48.560
<v Pedro Holanda>before DuckLake 1.0.

00:07:48.720 --> 00:07:50.720
<v Pedro Holanda>And I was always like, cool, cool, cool.

00:07:51.700 --> 00:07:52.460
<v Pedro Holanda>What could go wrong?

00:07:53.900 --> 00:07:54.960
<v Pedro Holanda>So they basically realized...

00:07:54.960 --> 00:07:56.500
<v Michael Kennedy>Yeah, but when you see things that are exciting,

00:07:56.720 --> 00:07:58.780
<v Michael Kennedy>you're like, this is going to solve our problem, right?

00:07:59.080 --> 00:08:00.400
<v Michael Kennedy>It's a good sign you're onto something.

00:08:01.020 --> 00:08:01.700
<v Pedro Holanda>No, no, absolutely.

00:08:02.040 --> 00:08:05.700
<v Pedro Holanda>I think they were super excited about it

00:08:06.540 --> 00:08:07.540
<v Pedro Holanda>when having this realization.

00:08:08.820 --> 00:08:10.120
<v Pedro Holanda>And same thing for us with Duck Lake.

00:08:10.180 --> 00:08:13.660
<v Pedro Holanda>It was like, okay, people are taking this seriously enough

00:08:13.780 --> 00:08:15.840
<v Pedro Holanda>that they're starting to bet their company on it.

00:08:15.980 --> 00:08:17.580
<v Pedro Holanda>So that's cool, definitely.

00:08:18.180 --> 00:08:19.620
<v Pedro Holanda>Always a little bit scary, but cool.

00:08:20.880 --> 00:08:23.140
<v Pedro Holanda>And yeah, from that on, I think it just took off.

00:08:23.880 --> 00:08:27.860
<v Pedro Holanda>Initially, I think it was just the three of us, like Mark and Hannes as the creators.

00:08:28.060 --> 00:08:30.040
<v Pedro Holanda>And I was kind of like the first person to be hired.

00:08:30.580 --> 00:08:32.599
<v Pedro Holanda>But then it quickly expanded.

00:08:32.960 --> 00:08:35.479
<v Pedro Holanda>I think in the first year, we're like six people.

00:08:35.659 --> 00:08:37.700
<v Pedro Holanda>We're now, I think, 35 maybe.

00:08:39.060 --> 00:08:40.940
<v Pedro Holanda>So yeah, it has been quite a journey.

00:08:41.919 --> 00:08:42.460
<v Michael Kennedy>Very exciting.

00:08:42.520 --> 00:08:44.180
<v Michael Kennedy>It's cool to see it gaining traction.

00:08:44.560 --> 00:08:49.840
<v Michael Kennedy>Now, quickly here, you also worked on progressive indexes.

00:08:49.980 --> 00:08:51.340
<v Michael Kennedy>Is this for your dissertation?

00:08:51.880 --> 00:08:55.780
<v Pedro Holanda>If I'm being honest, my plan was to actually work on CSV files during my P2D,

00:08:56.020 --> 00:08:58.320
<v Pedro Holanda>but I was told that was a solved problem.

00:08:59.939 --> 00:09:03.040
<v Pedro Holanda>So I went something else, which was progressive indexes.

00:09:04.280 --> 00:09:08.320
<v Pedro Holanda>The basic gist of progressive indexes is that you can create an index while

00:09:08.600 --> 00:09:13.020
<v Pedro Holanda>curing the data instead of creating up front and having the downtime and whatnot.

00:09:14.260 --> 00:09:19.140
<v Pedro Holanda>But it's actually quite difficult to implement it in practice in the database system.

00:09:19.500 --> 00:09:23.380
<v Pedro Holanda>So in my thesis, I even have a chapter called The Elephants in the Room, where I basically

00:09:23.640 --> 00:09:24.940
<v Pedro Holanda>diss all my work.

00:09:25.320 --> 00:09:30.520
<v Pedro Holanda>Now, I point out why it's complicated to implement in production and things that I would personally

00:09:30.760 --> 00:09:33.500
<v Pedro Holanda>look into if I wanted to still continue in that direction.

00:09:34.720 --> 00:09:36.040
<v Pedro Holanda>But it was also quite a fun journey.

00:09:36.320 --> 00:09:41.420
<v Pedro Holanda>And then you have the image of the website, and there's my little cover.

00:09:41.790 --> 00:09:45.620
<v Pedro Holanda>And my little cover is like a tree eating all these database systems and growing from

00:09:45.820 --> 00:09:47.120
<v Pedro Holanda>a little tree to a bigger tree.

00:09:48.620 --> 00:09:49.520
<v Michael Kennedy>It is, isn't it?

00:09:49.760 --> 00:09:50.180
<v Michael Kennedy>Very cool.

00:09:51.240 --> 00:09:52.360
<v Michael Kennedy>Guillermo, how about you?

00:09:52.820 --> 00:09:53.360
<v Michael Kennedy>Welcome to the show.

00:09:53.720 --> 00:09:53.960
<v Guillermo Sanchez Dionis>Yes.

00:09:54.220 --> 00:09:54.680
<v Guillermo Sanchez Dionis>Thanks, Michael.

00:09:55.140 --> 00:09:56.860
<v Guillermo Sanchez Dionis>My background is a little bit different from Pedro.

00:09:57.060 --> 00:10:02.140
<v Guillermo Sanchez Dionis>I actually was working as a software and data engineer for quite a while before I joined

00:10:02.300 --> 00:10:02.560
<v Guillermo Sanchez Dionis>Activity.

00:10:03.780 --> 00:10:09.120
<v Guillermo Sanchez Dionis>And actually, I come from the experience of running some of these beefy systems.

00:10:09.620 --> 00:10:15.460
<v Guillermo Sanchez Dionis>I think Pedro mentioned the Monet TV or Postgres, but also the BigQuery, Statorix, Snowflakes,

00:10:15.620 --> 00:10:18.840
<v Guillermo Sanchez Dionis>which is like, let's say, a second generation kind of system

00:10:18.970 --> 00:10:22.600
<v Guillermo Sanchez Dionis>where the experience is quite good, but the cost is quite expensive.

00:10:23.320 --> 00:10:29.240
<v Guillermo Sanchez Dionis>And, I mean, one of the things actually that prompted me to join MDD

00:10:29.320 --> 00:10:31.200
<v Guillermo Sanchez Dionis>was that Tag Lake was released, actually.

00:10:31.680 --> 00:10:38.760
<v Guillermo Sanchez Dionis>And I listened to this podcast that announced Tag Lake with Hannes and Mark.

00:10:39.220 --> 00:10:45.580
<v Guillermo Sanchez Dionis>And, yeah, just a lot of it really resonated with what I thought was maybe

00:10:45.600 --> 00:10:49.000
<v Guillermo Sanchez Dionis>slightly wrong from other OpenTable formats.

00:10:50.200 --> 00:10:51.760
<v Guillermo Sanchez Dionis>I just really like the simplicity of it.

00:10:51.800 --> 00:10:53.920
<v Guillermo Sanchez Dionis>I was a fan of DuckDB for quite a while now

00:10:54.060 --> 00:10:57.620
<v Guillermo Sanchez Dionis>because if you're interested in reducing the cost of your stack,

00:10:57.780 --> 00:10:59.880
<v Guillermo Sanchez Dionis>it was probably the best tool out there by far.

00:11:00.800 --> 00:11:03.980
<v Guillermo Sanchez Dionis>So then I actually wrote an email to Hannes and Mark directly,

00:11:04.460 --> 00:11:06.260
<v Guillermo Sanchez Dionis>saying like, hey, I want to work with you guys.

00:11:07.960 --> 00:11:10.540
<v Guillermo Sanchez Dionis>Yeah, I initially joined as a DevRel, actually,

00:11:10.840 --> 00:11:14.480
<v Guillermo Sanchez Dionis>and then got ready to work in DuckLake together with Pedro.

00:11:14.840 --> 00:11:20.940
<v Guillermo Sanchez Dionis>But then as time evolved, I became like this kind of like hybrid role where I was a bit of like doing product management things.

00:11:21.090 --> 00:11:26.320
<v Guillermo Sanchez Dionis>And also I contribute to Daclex sometimes and also to Quack, which is our new client server protocol.

00:11:26.800 --> 00:11:28.300
<v Guillermo Sanchez Dionis>So we're not only embedded anymore.

00:11:29.920 --> 00:11:33.680
<v Guillermo Sanchez Dionis>But yeah, so that's kind of the history of how I got to Daclabs.

00:11:34.020 --> 00:11:38.600
<v Michael Kennedy>Yeah. If someone reaches out to you and says, I heard you talk about this and I believe in your mission.

00:11:38.840 --> 00:11:40.440
<v Michael Kennedy>Yeah, that's a pretty big endorsement.

00:11:40.580 --> 00:11:42.460
<v Michael Kennedy>So I can see why they're like, yeah, you have to come work for us.

00:11:42.780 --> 00:11:43.500
<v Guillermo Sanchez Dionis>Yeah, for sure.

00:11:43.660 --> 00:11:46.560
<v Guillermo Sanchez Dionis>I mean, I literally told them, like, I'm quitting my job.

00:11:47.010 --> 00:11:48.480
<v Guillermo Sanchez Dionis>I want to work with you, you know?

00:11:48.520 --> 00:11:50.160
<v Guillermo Sanchez Dionis>I think it's actually pretty cool what you're doing.

00:11:51.160 --> 00:11:52.360
<v Michael Kennedy>Hadoop, it's done to me.

00:11:52.620 --> 00:11:53.200
<v Michael Kennedy>Spark, never.

00:11:54.360 --> 00:11:58.200
<v Guillermo Sanchez Dionis>No, I was already kind of, I think, done with those technologies.

00:11:58.490 --> 00:12:04.000
<v Guillermo Sanchez Dionis>Because the things that, for example, if you have Databricks as a platform, right?

00:12:04.180 --> 00:12:09.560
<v Guillermo Sanchez Dionis>Like, it's such a large thing that, for sure, they give you, like, a lot of, like, nice services.

00:12:09.830 --> 00:12:11.080
<v Guillermo Sanchez Dionis>Like, you don't have to worry about things.

00:12:11.170 --> 00:12:11.980
<v Guillermo Sanchez Dionis>And it's serverless.

00:12:12.260 --> 00:12:13.580
<v Guillermo Sanchez Dionis>but it's also so expensive.

00:12:13.880 --> 00:12:14.800
<v Guillermo Sanchez Dionis>And I was thinking like,

00:12:14.960 --> 00:12:17.740
<v Guillermo Sanchez Dionis>there's so much better things out there

00:12:17.800 --> 00:12:18.480
<v Guillermo Sanchez Dionis>that you can do,

00:12:18.740 --> 00:12:19.960
<v Guillermo Sanchez Dionis>that you can run yourself, right?

00:12:20.120 --> 00:12:21.240
<v Guillermo Sanchez Dionis>Like if you're interested in this,

00:12:21.260 --> 00:12:23.580
<v Guillermo Sanchez Dionis>this is like DacLig and DacDB feel like

00:12:23.760 --> 00:12:27.120
<v Guillermo Sanchez Dionis>foundational things that you can run any software on.

00:12:27.340 --> 00:12:29.120
<v Guillermo Sanchez Dionis>And I think this got me really excited.

00:12:29.320 --> 00:12:32.140
<v Michael Kennedy>You know, in software and deploying systems

00:12:32.640 --> 00:12:32.980
<v Michael Kennedy>and database,

00:12:33.620 --> 00:12:35.840
<v Michael Kennedy>there's these things that just layer and layer

00:12:35.940 --> 00:12:37.540
<v Michael Kennedy>until they just get so complicated.

00:12:38.040 --> 00:12:39.800
<v Michael Kennedy>And then there's always this alternative,

00:12:39.960 --> 00:12:41.500
<v Michael Kennedy>like, well, what if we just did a simple thing?

00:12:41.840 --> 00:12:45.200
<v Michael Kennedy>You know, if we could just make it not so complicated, would it still be working?

00:12:45.250 --> 00:12:47.180
<v Michael Kennedy>If it did, how amazing would that be?

00:12:47.540 --> 00:12:52.600
<v Michael Kennedy>So when you say cost, are we talking like operational costs, licensing costs?

00:12:52.720 --> 00:13:00.240
<v Michael Kennedy>You know, do I need a large cluster of machines so there's always a quorum to vote on different things for durability?

00:13:00.550 --> 00:13:01.720
<v Michael Kennedy>Or what do you mean by cost?

00:13:02.380 --> 00:13:14.100
<v Guillermo Sanchez Dionis>I mean, cost is actually, let's say, the service cost that, for example, platforms like Databricks or Snowflake, you know, charge you to use infrastructure that they run, right?

00:13:14.270 --> 00:13:18.420
<v Guillermo Sanchez Dionis>Because obviously Snowflake and Databricks, they run on AWS or Google Cloud, depending.

00:13:18.510 --> 00:13:20.320
<v Guillermo Sanchez Dionis>You can even choose your deployment type.

00:13:20.620 --> 00:13:24.480
<v Guillermo Sanchez Dionis>But obviously, because they provide the service, but they still have to pay for the infrastructure.

00:13:24.650 --> 00:13:27.080
<v Guillermo Sanchez Dionis>The service is basically something on top of that infrastructure.

00:13:27.580 --> 00:13:29.680
<v Guillermo Sanchez Dionis>And they decide how much it is, basically.

00:13:30.160 --> 00:13:40.500
<v Guillermo Sanchez Dionis>And because they're pretty much the bigger players in the market together with existing cloud vendors like GCP, AWS and Azure, they charge quite steep.

00:13:41.040 --> 00:13:44.080
<v Guillermo Sanchez Dionis>And I mean, of course, like the service is nice.

00:13:44.270 --> 00:13:45.980
<v Guillermo Sanchez Dionis>Like you don't have to worry about things, right?

00:13:46.070 --> 00:13:48.020
<v Guillermo Sanchez Dionis>You don't have to worry about downtime and all these things.

00:13:48.300 --> 00:13:51.880
<v Guillermo Sanchez Dionis>And for sure, they handle the replication and everything that you need.

00:13:52.100 --> 00:14:00.620
<v Guillermo Sanchez Dionis>But still, though, yeah, if you want control over your stack, this is like a very high level of abstraction that they are offering.

00:14:01.760 --> 00:14:02.060
<v Michael Kennedy>Yeah.

00:14:02.160 --> 00:14:08.680
<v Michael Kennedy>You also mentioned open table formats, and that's going to become relevant to our Duck Lake side of things.

00:14:09.310 --> 00:14:11.460
<v Michael Kennedy>More generally, what are open table formats?

00:14:11.860 --> 00:14:12.020
<v Guillermo Sanchez Dionis>Yeah.

00:14:12.140 --> 00:14:15.220
<v Guillermo Sanchez Dionis>So, I mean, they used to be called open table formats.

00:14:15.380 --> 00:14:23.760
<v Guillermo Sanchez Dionis>And then I think people are leaning more towards this lake house format name, which I'm not sure why.

00:14:23.960 --> 00:14:28.300
<v Guillermo Sanchez Dionis>I think it's actually maybe because of data rigs, because I think they started calling it the lake house.

00:14:28.340 --> 00:14:30.520
<v Guillermo Sanchez Dionis>And then everybody's like, yeah, the lake house.

00:14:31.280 --> 00:14:36.820
<v Guillermo Sanchez Dionis>But yeah, OpenTable formats are basically, I think Pedro correct me if I'm wrong,

00:14:36.880 --> 00:14:44.880
<v Guillermo Sanchez Dionis>but it's basically just some metadata on some parquet files that you can query in a transactional manner.

00:14:45.320 --> 00:14:50.220
<v Guillermo Sanchez Dionis>And you can do operations also, atomic operations on this data as well.

00:14:50.510 --> 00:14:54.360
<v Guillermo Sanchez Dionis>In the most basic case, it's just basically a pointer,

00:14:55.390 --> 00:14:58.620
<v Guillermo Sanchez Dionis>sorry, a metadata file with a pointer to a list of files

00:14:59.140 --> 00:15:03.200
<v Guillermo Sanchez Dionis>that all of those files form part of a table.

00:15:03.880 --> 00:15:06.040
<v Guillermo Sanchez Dionis>And you can also have things like a schema to it,

00:15:06.190 --> 00:15:09.060
<v Guillermo Sanchez Dionis>like what data types do you expect from this table?

00:15:09.380 --> 00:15:11.860
<v Guillermo Sanchez Dionis>And you can add more complex things like statistics,

00:15:11.980 --> 00:15:15.760
<v Guillermo Sanchez Dionis>like, you know, which files contain which data.

00:15:16.280 --> 00:15:18.480
<v Guillermo Sanchez Dionis>And it can get obviously a lot more complex than that,

00:15:18.640 --> 00:15:20.260
<v Guillermo Sanchez Dionis>but that's sort of the basics, I think.

00:15:20.460 --> 00:15:23.280
<v Pedro Holanda>Yeah, and I think like the interesting thing

00:15:23.460 --> 00:15:25.360
<v Pedro Holanda>of the OpenTable formats is, of course,

00:15:26.280 --> 00:15:27.480
<v Pedro Holanda>the openness part of it, right?

00:15:27.660 --> 00:15:28.920
<v Pedro Holanda>So they have a specification,

00:15:29.640 --> 00:15:31.540
<v Pedro Holanda>the file formats where your data is stored,

00:15:31.740 --> 00:15:32.740
<v Pedro Holanda>they also have a specification.

00:15:33.280 --> 00:15:35.040
<v Pedro Holanda>So by just reading the specification,

00:15:35.460 --> 00:15:37.900
<v Pedro Holanda>anyone should be able to implement a reader

00:15:38.100 --> 00:15:39.680
<v Pedro Holanda>and writer to that format, right?

00:15:39.780 --> 00:15:43.620
<v Pedro Holanda>So the whole idea of this, or maybe the beauty of this,

00:15:43.740 --> 00:15:46.160
<v Pedro Holanda>is that it should be able to solve the problem

00:15:46.360 --> 00:15:49.760
<v Pedro Holanda>where you're locked in into a certain system, right?

00:15:49.920 --> 00:15:51.380
<v Pedro Holanda>So you suddenly don't need,

00:15:51.700 --> 00:15:54.560
<v Pedro Holanda>like if you start off your database from Oracle, for example,

00:15:54.960 --> 00:15:55.840
<v Pedro Holanda>you're kind of locked in.

00:15:56.120 --> 00:15:58.860
<v Pedro Holanda>Like doing an Oracle migration is known to be painful,

00:15:59.090 --> 00:16:01.040
<v Pedro Holanda>to be costly, so you're going to be using,

00:16:01.420 --> 00:16:04.220
<v Pedro Holanda>you're going to be giving Larry Edson a second island in Hawaii

00:16:04.930 --> 00:16:07.140
<v Pedro Holanda>in the next few years, that's fine.

00:16:07.620 --> 00:16:11.720
<v Pedro Holanda>But then if you actually use an open table formats, you kind of solve that problem, right?

00:16:11.740 --> 00:16:15.420
<v Pedro Holanda>It's like you can literally switch from different engines and different providers.

00:16:15.640 --> 00:16:24.780
<v Pedro Holanda>And if you're tired of Databricks and now you want to use NoFlake or now you want to use your own solution based on DuckDB, you can theoretically quickly jump from these, right?

00:16:25.140 --> 00:16:37.260
<v Pedro Holanda>And it's also super scalable because if you're just dealing with file formats or like a catalog as well, but your data is in parquet files, you can easily distribute your reads on it.

00:16:38.040 --> 00:16:41.560
<v Pedro Holanda>So there's quite some cleverness behind it.

00:16:43.340 --> 00:16:46.120
<v Michael Kennedy>This portion of Talk Python To Me is brought to you by Six Feet Up.

00:16:46.500 --> 00:16:47.600
<v Michael Kennedy>Let me ask you a question.

00:16:48.040 --> 00:16:48.860
<v Michael Kennedy>What's stopping you?

00:16:49.480 --> 00:16:53.860
<v Michael Kennedy>Maybe it's an application that won't scale or an AI initiative that just isn't delivering.

00:16:54.320 --> 00:16:56.080
<v Michael Kennedy>That's where Six Feet Up comes in.

00:16:56.660 --> 00:17:01.360
<v Michael Kennedy>With deep expertise in Python and AI, they solve hard software problems,

00:17:02.080 --> 00:17:04.780
<v Michael Kennedy>modernize platforms, and get teams to market faster.

00:17:05.220 --> 00:17:07.480
<v Michael Kennedy>These folks have been doing Python since version one.

00:17:07.870 --> 00:17:10.740
<v Michael Kennedy>They know the frameworks and ecosystems like the back of their hands.

00:17:11.300 --> 00:17:13.819
<v Michael Kennedy>Six Feet Up's impact speaks for itself.

00:17:14.439 --> 00:17:18.240
<v Michael Kennedy>Automated healthcare pipelines for hospitals, helping NASA explore Pluto,

00:17:18.920 --> 00:17:20.560
<v Michael Kennedy>building severe weather prediction tools,

00:17:20.819 --> 00:17:24.260
<v Michael Kennedy>and applying AI to connect farmers with vital crop data.

00:17:24.760 --> 00:17:26.600
<v Michael Kennedy>When the stakes are high and the problems are hard,

00:17:26.920 --> 00:17:28.700
<v Michael Kennedy>Six Feet Up is the partner that delivers.

00:17:29.320 --> 00:17:30.820
<v Michael Kennedy>See what's possible with Six Feet Up.

00:17:31.020 --> 00:17:33.580
<v Michael Kennedy>Visit talkpython.fm/sixfeetup.

00:17:34.020 --> 00:17:36.920
<v Michael Kennedy>The link is on the episode page and in your podcast player's show notes.

00:17:37.300 --> 00:17:39.060
<v Michael Kennedy>Thanks to Six Feet Up for sponsoring the show.

00:17:40.220 --> 00:17:43.340
<v Michael Kennedy>The examples I've seen are like a whole bunch of Parquet files

00:17:44.120 --> 00:17:46.940
<v Michael Kennedy>on S3 or Azure Blob Storage or something like that.

00:17:47.170 --> 00:17:50.540
<v Michael Kennedy>And then some other file may be also stored there.

00:17:50.840 --> 00:17:53.540
<v Michael Kennedy>that you can say, well, let's read the metadata file

00:17:53.560 --> 00:17:54.860
<v Michael Kennedy>that describes what files are here.

00:17:55.220 --> 00:17:57.080
<v Michael Kennedy>But I mean, your dream could be back.

00:17:57.100 --> 00:17:59.960
<v Michael Kennedy>It could be zipped up CSV files stored up there

00:18:00.060 --> 00:18:01.000
<v Michael Kennedy>with some metadata, right?

00:18:02.419 --> 00:18:03.940
<v Pedro Holanda>So of course in Duck Lake,

00:18:04.460 --> 00:18:07.600
<v Pedro Holanda>so maybe one quick thing is that Iceberg,

00:18:07.840 --> 00:18:10.800
<v Pedro Holanda>which is, I guess, the other main open table formats,

00:18:10.980 --> 00:18:12.540
<v Pedro Holanda>it uses files all over, right?

00:18:12.680 --> 00:18:15.040
<v Pedro Holanda>So you have your files in the metadata

00:18:15.060 --> 00:18:17.880
<v Pedro Holanda>and then your files that actually store the data.

00:18:18.440 --> 00:18:20.500
<v Pedro Holanda>In Duck Lake, we'll talk a bit more about this.

00:18:20.580 --> 00:18:23.560
<v Pedro Holanda>but the metadata is actually a database system

00:18:23.840 --> 00:18:25.260
<v Pedro Holanda>and your files are still parquet files.

00:18:25.640 --> 00:18:28.600
<v Pedro Holanda>So there's nothing stopping us from a technical point of view

00:18:28.820 --> 00:18:30.840
<v Pedro Holanda>to actually replacing these files with CSV files.

00:18:31.920 --> 00:18:34.520
<v Pedro Holanda>From the Duck Lake spec, that's actually already allowed

00:18:34.720 --> 00:18:37.500
<v Pedro Holanda>because we can store in the catalog that these are CSV files

00:18:38.000 --> 00:18:41.060
<v Pedro Holanda>and we could theoretically bring the stats necessary.

00:18:41.460 --> 00:18:43.500
<v Pedro Holanda>So it is an achievable dream.

00:18:44.460 --> 00:18:47.740
<v Michael Kennedy>Exactly. The dream of the CSVs are still alive.

00:18:48.120 --> 00:18:48.760
<v Michael Kennedy>All right, really quickly.

00:18:49.040 --> 00:18:53.940
<v Michael Kennedy>I don't know I'm on the CSV kick, but what's the largest CSV you've ever parsed?

00:18:54.260 --> 00:18:54.600
<v Pedro Holanda>Oof.

00:18:55.300 --> 00:19:00.740
<v Pedro Holanda>Personally, I think I've reached close to a terabytes on benchmarks.

00:19:02.200 --> 00:19:07.520
<v Pedro Holanda>But I've seen people, like, you know, people, they, there were many times in CSV land there

00:19:07.640 --> 00:19:10.700
<v Pedro Holanda>was like, yeah, this sounds like a rather reasonable limitation.

00:19:11.460 --> 00:19:12.720
<v Pedro Holanda>No one's ever going to do something.

00:19:13.620 --> 00:19:17.879
<v Pedro Holanda>I think I had a limitation, for example, that no one would ever have a line in a CSV file

00:19:17.900 --> 00:19:19.500
<v Pedro Holanda>that was over 32 megabytes.

00:19:19.870 --> 00:19:22.480
<v Pedro Holanda>And that was kind of nice for me to be able to do parallelism.

00:19:22.710 --> 00:19:24.260
<v Pedro Holanda>And then, of course, some guy,

00:19:24.900 --> 00:19:28.280
<v Pedro Holanda>hey, this CSV is throwing an error for me now,

00:19:28.480 --> 00:19:30.100
<v Pedro Holanda>saying that my line is over 32 megabytes.

00:19:30.150 --> 00:19:31.460
<v Pedro Holanda>I'm like, Jesus Christ, man.

00:19:32.240 --> 00:19:33.320
<v Michael Kennedy>What are they storing in there?

00:19:33.320 --> 00:19:35.880
<v Michael Kennedy>Like a book per line?

00:19:36.720 --> 00:19:36.960
<v Pedro Holanda>Yeah.

00:19:37.580 --> 00:19:39.780
<v Pedro Holanda>So if I've done a terabyte,

00:19:40.000 --> 00:19:42.600
<v Pedro Holanda>I think some people have gone a bit crazier.

00:19:43.380 --> 00:19:45.080
<v Michael Kennedy>Let's jump into our topic here a bit.

00:19:45.360 --> 00:19:50.160
<v Michael Kennedy>And I want to work our way, sort of do a little bit of talking about DuckDB.

00:19:50.440 --> 00:19:54.240
<v Michael Kennedy>And you talked about Quack.

00:19:54.640 --> 00:19:57.880
<v Michael Kennedy>In the early days, DuckDB was an embedded database.

00:19:58.540 --> 00:20:01.020
<v Michael Kennedy>You know, the most common one of these is SQLite.

00:20:01.240 --> 00:20:03.400
<v Michael Kennedy>And Postgres is all the rage, obviously.

00:20:04.180 --> 00:20:04.700
<v Michael Kennedy>Others as well.

00:20:04.700 --> 00:20:08.920
<v Michael Kennedy>But Postgres certainly seems to be taking over a lot of the database side of things.

00:20:09.540 --> 00:20:13.320
<v Michael Kennedy>But I think there's still a bit of a resurgence of embedded databases.

00:20:13.700 --> 00:20:17.100
<v Michael Kennedy>And I think DuckDB is an example of that interest, right?

00:20:17.400 --> 00:20:21.040
<v Michael Kennedy>So maybe just you guys give me your thoughts on SQLite

00:20:21.250 --> 00:20:23.220
<v Michael Kennedy>and some of these other embedded database ideas.

00:20:23.820 --> 00:20:30.020
<v Guillermo Sanchez Dionis>I just wanted to mention that I think Pedro can give more research background on this,

00:20:30.140 --> 00:20:31.340
<v Guillermo Sanchez Dionis>but I think from a user perspective,

00:20:31.870 --> 00:20:35.620
<v Guillermo Sanchez Dionis>I think the idea of having your database within your application system

00:20:35.860 --> 00:20:37.260
<v Guillermo Sanchez Dionis>was always very attractive to me, right?

00:20:37.520 --> 00:20:38.900
<v Guillermo Sanchez Dionis>I think Pedro mentioned this at the beginning.

00:20:39.340 --> 00:20:43.260
<v Guillermo Sanchez Dionis>It's very nice to not have to provision a Postgres database.

00:20:43.880 --> 00:20:47.840
<v Guillermo Sanchez Dionis>or any other type of database on a separate server to run your application.

00:20:48.420 --> 00:20:50.360
<v Guillermo Sanchez Dionis>And I think SQL lights off this wonderfully.

00:20:50.940 --> 00:20:53.020
<v Guillermo Sanchez Dionis>And of course, when DuckDB came by,

00:20:53.100 --> 00:20:57.180
<v Guillermo Sanchez Dionis>it was also with the idea to solve this from an analytical database perspective.

00:20:57.460 --> 00:20:59.460
<v Guillermo Sanchez Dionis>But of course, DuckDB can also do transactions, right?

00:20:59.780 --> 00:21:01.760
<v Guillermo Sanchez Dionis>Pedro can talk about it if he wants.

00:21:01.960 --> 00:21:03.520
<v Guillermo Sanchez Dionis>But this is also very nice, right?

00:21:03.600 --> 00:21:05.300
<v Guillermo Sanchez Dionis>But you can still run transactions in DuckDB.

00:21:05.640 --> 00:21:08.760
<v Guillermo Sanchez Dionis>But overall, I would just be very happy with the idea

00:21:09.140 --> 00:21:12.620
<v Guillermo Sanchez Dionis>of being able to embed your database system wherever your application is.

00:21:12.740 --> 00:21:15.420
<v Guillermo Sanchez Dionis>because I think there's a lot of use cases where this is just good enough.

00:21:15.860 --> 00:21:20.220
<v Guillermo Sanchez Dionis>And actually, one of the coolest use cases I think that DuckDB brings to the table

00:21:20.560 --> 00:21:22.960
<v Guillermo Sanchez Dionis>is the fact that you can use a Wasm client in the browser

00:21:23.460 --> 00:21:26.660
<v Guillermo Sanchez Dionis>and serve your database over S3,

00:21:27.100 --> 00:21:28.180
<v Guillermo Sanchez Dionis>and literally there's no server,

00:21:28.580 --> 00:21:32.040
<v Guillermo Sanchez Dionis>and you have an application that can query data from your browser.

00:21:32.420 --> 00:21:33.780
<v Guillermo Sanchez Dionis>And I think that's amazing, right?

00:21:33.940 --> 00:21:35.780
<v Guillermo Sanchez Dionis>It reduces the costs completely,

00:21:36.280 --> 00:21:38.120
<v Guillermo Sanchez Dionis>because S3 storage is very, very cheap.

00:21:38.600 --> 00:21:39.440
<v Michael Kennedy>That's really incredible.

00:21:40.500 --> 00:21:45.200
<v Michael Kennedy>There's just so much operational simplicity if you can make these things work, right?

00:21:45.500 --> 00:21:47.300
<v Michael Kennedy>If you make these embedded databases work, right?

00:21:47.340 --> 00:21:49.800
<v Michael Kennedy>It's just like, wow, there's nothing to go down.

00:21:50.440 --> 00:21:55.040
<v Michael Kennedy>There's no like, oh, this server needs that security.

00:21:55.320 --> 00:21:58.380
<v Michael Kennedy>But then, you know, it's all those things to juggle, right?

00:21:58.700 --> 00:21:59.780
<v Michael Kennedy>Just it's a file.

00:22:00.180 --> 00:22:01.240
<v Pedro Holanda>It's in process.

00:22:01.780 --> 00:22:05.920
<v Pedro Holanda>You end up eliminating like a lot of this complexity of keeping a server for sure.

00:22:06.340 --> 00:22:09.080
<v Pedro Holanda>And there are other beauties to it as well, right?

00:22:09.140 --> 00:22:13.740
<v Pedro Holanda>because you suddenly have your database running within your application.

00:22:14.720 --> 00:22:18.000
<v Pedro Holanda>So it also can share the same memory space of your application.

00:22:18.160 --> 00:22:22.700
<v Pedro Holanda>So you can do a bunch of tricks to avoid copying memory all over.

00:22:23.160 --> 00:22:26.360
<v Pedro Holanda>So this is especially interesting for data science projects

00:22:26.520 --> 00:22:29.560
<v Pedro Holanda>because if you're using something like Pandas or NumPy,

00:22:30.140 --> 00:22:31.260
<v Pedro Holanda>what is a NumPy array?

00:22:31.740 --> 00:22:34.340
<v Pedro Holanda>It's literally a C array with some makeup on top.

00:22:34.600 --> 00:22:38.900
<v Pedro Holanda>What is a DuckDB vector is literally an array with some makeup on top.

00:22:39.020 --> 00:22:44.980
<v Pedro Holanda>So you can just change the makeup and then you can suddenly access the same data with constant cost, right?

00:22:45.050 --> 00:22:46.540
<v Pedro Holanda>You don't have to transform actual data.

00:22:46.980 --> 00:22:47.760
<v Michael Kennedy>Oh, that's interesting.

00:22:47.890 --> 00:22:55.540
<v Michael Kennedy>So when you do a query, you may be able to just return a piece of the in-memory WDB chunk instead of going,

00:22:55.690 --> 00:23:01.360
<v Michael Kennedy>okay, ours looks like this, but then we're going to copy a million floats over to this thing in this column and then send it back, right?

00:23:01.680 --> 00:23:08.240
<v Pedro Holanda>So this is what was also like one of the things that was one of the realizations that database protocols, right?

00:23:08.380 --> 00:23:12.780
<v Pedro Holanda>So the way you transfer data from the server to the clients, they're actually quite slow.

00:23:13.800 --> 00:23:17.740
<v Pedro Holanda>So this is one of the main frustrations we had seen with the data scientists.

00:23:17.950 --> 00:23:23.200
<v Pedro Holanda>It's not only like, oh, it's clumsy to set it up and you'd like to start a server and create schemas and whatnot,

00:23:23.700 --> 00:23:33.140
<v Pedro Holanda>but it's also just to get your data from your NumPy or TensorFlow or Pandas or whatever you're running into the database system and back and forth was super slow.

00:23:33.600 --> 00:23:37.380
<v Pedro Holanda>So you completely remove that boundary.

00:23:38.020 --> 00:23:42.720
<v Pedro Holanda>And yeah, like you gain all these benefits, which is inspired and very similar to what

00:23:42.820 --> 00:23:43.700
<v Pedro Holanda>SQLite already had.

00:23:44.020 --> 00:23:47.960
<v Pedro Holanda>But of course, with the difference that there's a huge focus on analytics.

00:23:48.200 --> 00:23:51.200
<v Pedro Holanda>So it's a color format instead of a row format.

00:23:51.520 --> 00:23:55.280
<v Pedro Holanda>There's a lot of emphasis in compression and vectorized execution and so on.

00:23:55.560 --> 00:23:59.240
<v Michael Kennedy>I think probably people out there listening, they're like, wait a minute, columnar, row

00:23:59.630 --> 00:24:01.100
<v Michael Kennedy>format, what does this mean?

00:24:01.920 --> 00:24:02.260
<v Michael Kennedy>Yeah.

00:24:02.360 --> 00:24:03.640
<v Michael Kennedy>Give us a bit more detail there.

00:24:03.940 --> 00:24:04.280
<v Pedro Holanda>Absolutely.

00:24:04.640 --> 00:24:08.840
<v Pedro Holanda>So, well, there's basically two ways that you can store there, right?

00:24:08.940 --> 00:24:09.940
<v Pedro Holanda>So your data is a table.

00:24:10.400 --> 00:24:13.340
<v Pedro Holanda>Say that is a, I don't know, a table that sells products, right?

00:24:13.500 --> 00:24:16.780
<v Pedro Holanda>So you have products, quantity in your shop and price.

00:24:17.300 --> 00:24:22.000
<v Pedro Holanda>One of the ways you can store exactly in your memory is contiguous row by row, right?

00:24:22.050 --> 00:24:26.020
<v Pedro Holanda>So you store first the first row, then the second row, so on and so forth.

00:24:26.340 --> 00:24:32.920
<v Pedro Holanda>However, analytical queries, they're usually of the type of, give me the average price of all your products.

00:24:33.580 --> 00:24:38.100
<v Pedro Holanda>So in practice, even though you have three columns, you only really want to access one column, right?

00:24:38.540 --> 00:24:46.000
<v Pedro Holanda>So on the color formats, you actually store both in memory and on your storage, the columns first contiguously.

00:24:46.040 --> 00:24:50.000
<v Pedro Holanda>So if you want to access one column, you don't have to read basically all your table,

00:24:50.440 --> 00:24:53.120
<v Pedro Holanda>but you know exactly from your memory or your disk

00:24:53.840 --> 00:24:56.920
<v Pedro Holanda>where you have to read just to access that column.

00:24:57.320 --> 00:24:59.040
<v Pedro Holanda>And the other nice benefits from that

00:24:59.340 --> 00:25:02.340
<v Pedro Holanda>is that lightweight compression is heavily dependent

00:25:02.800 --> 00:25:05.200
<v Pedro Holanda>on the proximity of your data, right?

00:25:05.260 --> 00:25:06.480
<v Pedro Holanda>So it's much easier, for example,

00:25:06.580 --> 00:25:08.860
<v Pedro Holanda>to compress one column of dates.

00:25:09.260 --> 00:25:11.320
<v Pedro Holanda>You can maybe do like delta compression quite easily

00:25:11.480 --> 00:25:13.680
<v Pedro Holanda>because dates tend to be the same for a long time

00:25:13.720 --> 00:25:15.060
<v Pedro Holanda>and then they just change one by one.

00:25:15.660 --> 00:25:17.680
<v Pedro Holanda>They have to do that if it's in a row, right?

00:25:17.780 --> 00:25:20.060
<v Pedro Holanda>Because the next value of a row is not going to be a date.

00:25:20.180 --> 00:25:24.000
<v Pedro Holanda>it's going to be a double or it's going to be a string or whatever it is.

00:25:24.290 --> 00:25:28.520
<v Pedro Holanda>So this change in formats allows you to access your data much faster

00:25:29.100 --> 00:25:34.360
<v Pedro Holanda>with the disadvantage that if you want to update one of your rows,

00:25:34.720 --> 00:25:35.840
<v Pedro Holanda>it's a bit more expensive, right?

00:25:36.020 --> 00:25:37.820
<v Pedro Holanda>Because again, if you have the row formats

00:25:37.980 --> 00:25:42.960
<v Pedro Holanda>and you want to now update the price of your Volkswagen cars or whatever,

00:25:43.340 --> 00:25:47.040
<v Pedro Holanda>you just need to fetch that one tuple and you immediately can update that.

00:25:47.240 --> 00:25:50.020
<v Pedro Holanda>So it's one random accessing kind of done.

00:25:50.060 --> 00:26:02.560
<v Pedro Holanda>If you are on a color format, you're first going to have to check that one whole column to figure out where are your Volkswagen cars and then go to another part of your data to figure out where the price is and update that value.

00:26:02.650 --> 00:26:03.700
<v Pedro Holanda>So it's a bit more costly.

00:26:04.160 --> 00:26:10.340
<v Pedro Holanda>And that's why people say that SQLite is good for transactions and transactions in the sense that it updates one row every now and then.

00:26:10.680 --> 00:26:20.940
<v Pedro Holanda>And DuckDB is great for analytics, which is, again, this type of query that reads huge checks of your data, but like fewer columns instead of lots of columns.

00:26:21.280 --> 00:26:22.580
<v Michael Kennedy>That's a really good explanation.

00:26:22.830 --> 00:26:28.640
<v Michael Kennedy>Yeah, I can just see if you want to query, you know, take the average of all of the prices.

00:26:29.090 --> 00:26:29.900
<v Michael Kennedy>You've got these rows.

00:26:29.910 --> 00:26:34.880
<v Michael Kennedy>You basically got to seek over every row through the entire database to get those things.

00:26:35.260 --> 00:26:41.740
<v Michael Kennedy>And if you have a varchar sort of thing, then it's even harder because you're not even skipping known links.

00:26:41.900 --> 00:26:45.780
<v Michael Kennedy>You've got to compute, well, okay, where is the price in this particular row?

00:26:46.000 --> 00:26:47.200
<v Michael Kennedy>And it's just very different.

00:26:47.480 --> 00:26:53.480
<v Pedro Holanda>And maybe just to add, the color format also allows you to do vectorized query execution.

00:26:54.380 --> 00:27:04.340
<v Pedro Holanda>The basic idea of vectorized query execution is that you can actually have batches of your data going through your query plan in one go, right?

00:27:04.500 --> 00:27:06.060
<v Pedro Holanda>unless you have a pipeline breaker,

00:27:06.440 --> 00:27:07.520
<v Pedro Holanda>like a join or something like this.

00:27:07.540 --> 00:27:09.880
<v Pedro Holanda>But usually you can go through the whole query in one go.

00:27:10.040 --> 00:27:13.040
<v Pedro Holanda>And because you have these batches are sufficiently small,

00:27:13.480 --> 00:27:14.960
<v Pedro Holanda>they just get cached on your CPU

00:27:15.540 --> 00:27:17.820
<v Pedro Holanda>and then you don't have to constantly go through memory

00:27:18.020 --> 00:27:18.920
<v Pedro Holanda>to fetch the data anymore.

00:27:19.440 --> 00:27:22.140
<v Pedro Holanda>While in a tuple-wise execution,

00:27:22.460 --> 00:27:23.680
<v Pedro Holanda>which is like what SQLite does,

00:27:24.000 --> 00:27:26.440
<v Pedro Holanda>and it was created more like when memory was small,

00:27:26.680 --> 00:27:29.460
<v Pedro Holanda>so you wanted to just have a little bit of your data in memory,

00:27:29.600 --> 00:27:30.460
<v Pedro Holanda>like from the 90s.

00:27:31.700 --> 00:27:34.040
<v Pedro Holanda>You just go and execute through the query plan,

00:27:34.180 --> 00:27:35.000
<v Pedro Holanda>tuple by tuple, right?

00:27:35.000 --> 00:27:36.640
<v Pedro Holanda>So this caused a bunch of cache misses.

00:27:37.180 --> 00:27:38.500
<v Pedro Holanda>You frequently have to go to memory

00:27:38.650 --> 00:27:40.580
<v Pedro Holanda>to fetch the next tuple and so on.

00:27:40.790 --> 00:27:42.840
<v Pedro Holanda>So that also allows that extra step

00:27:42.910 --> 00:27:44.180
<v Pedro Holanda>that makes a huge difference

00:27:44.860 --> 00:27:46.080
<v Pedro Holanda>in analytical performance.

00:27:46.460 --> 00:27:47.020
<v Michael Kennedy>It's funny.

00:27:47.400 --> 00:27:49.140
<v Michael Kennedy>It used to be things were optimized

00:27:49.460 --> 00:27:50.760
<v Michael Kennedy>because memory was expensive

00:27:51.110 --> 00:27:53.500
<v Michael Kennedy>in terms of it was scarce, right?

00:27:53.660 --> 00:27:55.340
<v Michael Kennedy>It was hard to get enough memory

00:27:55.540 --> 00:27:56.900
<v Michael Kennedy>to handle all the data

00:27:56.930 --> 00:27:58.320
<v Michael Kennedy>that you're working with in the 90s.

00:27:58.460 --> 00:28:00.840
<v Michael Kennedy>And people have heard of like third normal form

00:28:01.080 --> 00:28:01.740
<v Michael Kennedy>and normalization.

00:28:01.980 --> 00:28:06.260
<v Michael Kennedy>all of this is we must not waste the memory, right?

00:28:06.340 --> 00:28:07.540
<v Michael Kennedy>I mean, other reasons as well,

00:28:07.560 --> 00:28:09.320
<v Michael Kennedy>but still we must not waste the memory.

00:28:09.440 --> 00:28:10.480
<v Michael Kennedy>And then it got kind of cheap.

00:28:10.680 --> 00:28:11.460
<v Michael Kennedy>We were able to use it.

00:28:11.660 --> 00:28:14.340
<v Michael Kennedy>And now with AI, we're back to memory is scarce again.

00:28:14.660 --> 00:28:15.140
<v Michael Kennedy>How about that?

00:28:16.400 --> 00:28:17.400
<v Pedro Holanda>It's actually for databases,

00:28:17.800 --> 00:28:20.200
<v Pedro Holanda>the cycle has started a bit earlier

00:28:20.360 --> 00:28:22.840
<v Pedro Holanda>because I think like in the mid 2000s,

00:28:22.960 --> 00:28:24.440
<v Pedro Holanda>there was like, oh, we don't need disk.

00:28:24.780 --> 00:28:25.740
<v Pedro Holanda>We can have our database.

00:28:26.160 --> 00:28:27.820
<v Pedro Holanda>It was the in-memory database systems, right?

00:28:27.940 --> 00:28:30.180
<v Pedro Holanda>Just everything in memory and it's all good.

00:28:30.360 --> 00:28:31.240
<v Pedro Holanda>And then you can map,

00:28:31.560 --> 00:28:34.640
<v Pedro Holanda>Like just let the OS handle whatever needs to go to disk every now and then.

00:28:34.960 --> 00:28:35.660
<v Pedro Holanda>But it's going to be good.

00:28:36.000 --> 00:28:39.580
<v Pedro Holanda>And the reality is that in this, memory has increased drastically.

00:28:40.240 --> 00:28:41.960
<v Pedro Holanda>But there's still lots of limitations.

00:28:42.840 --> 00:28:46.800
<v Pedro Holanda>Maybe you want to run things on your phone or like in an Arduino or something like this.

00:28:47.120 --> 00:28:48.500
<v Pedro Holanda>And that's also inductive view.

00:28:48.500 --> 00:28:51.120
<v Pedro Holanda>We put a lot of emphasis in having proper buffer managers.

00:28:51.520 --> 00:28:54.480
<v Pedro Holanda>And like all our operators built to disk as well.

00:28:54.860 --> 00:28:59.080
<v Pedro Holanda>So even in scenarios that you still have memory constraints, the tool will just work.

00:28:59.300 --> 00:29:00.260
<v Pedro Holanda>Like it's not going to crash.

00:29:00.720 --> 00:29:02.080
<v Pedro Holanda>They'd be like, oh yeah, there's no memory buy.

00:29:02.970 --> 00:29:04.280
<v Pedro Holanda>Because that's also a little bit frustrating.

00:29:04.720 --> 00:29:05.540
<v Michael Kennedy>It definitely is.

00:29:05.790 --> 00:29:07.600
<v Michael Kennedy>And just the problems people are trying to solve.

00:29:07.800 --> 00:29:09.640
<v Michael Kennedy>It's like, yeah, we have 10 terabytes of data.

00:29:10.120 --> 00:29:13.280
<v Michael Kennedy>Oh, we didn't used to have that much data typically.

00:29:13.780 --> 00:29:18.260
<v Guillermo Sanchez Dionis>That actually one of the parts that I love the most about our website is we have like

00:29:18.350 --> 00:29:21.520
<v Guillermo Sanchez Dionis>this series of blog posts that run on exotic hardware.

00:29:22.020 --> 00:29:26.620
<v Guillermo Sanchez Dionis>And basically, you know, this can be a Raspberry Pi, but it can also be an iPhone, right?

00:29:26.920 --> 00:29:29.040
<v Guillermo Sanchez Dionis>And we try to push it to see where's the limit.

00:29:29.320 --> 00:29:33.580
<v Guillermo Sanchez Dionis>there's this very nice image of an iPhone cooling down in a block of ice

00:29:34.110 --> 00:29:35.520
<v Guillermo Sanchez Dionis>because we're running the scale factor.

00:29:36.120 --> 00:29:39.220
<v Guillermo Sanchez Dionis>I don't know if it's 100 or even one terabyte on an iPhone 15.

00:29:40.360 --> 00:29:43.080
<v Guillermo Sanchez Dionis>Yeah, so I think that's also a very cool thing about DacTV,

00:29:43.240 --> 00:29:44.740
<v Guillermo Sanchez Dionis>that it truly can run anywhere

00:29:45.280 --> 00:29:47.440
<v Guillermo Sanchez Dionis>and that it doesn't matter what constraints it has,

00:29:47.640 --> 00:29:51.140
<v Guillermo Sanchez Dionis>it can still run queries with this out-of-core processing

00:29:51.380 --> 00:29:52.920
<v Guillermo Sanchez Dionis>that it has and the ability to spill to these.

00:29:54.020 --> 00:29:56.820
<v Michael Kennedy>This portion of Talk Python To Me is brought to you by our AI tools.

00:29:57.560 --> 00:30:01.780
<v Michael Kennedy>You know that thing where you ask an AI something about Python and it confidently tells you

00:30:02.320 --> 00:30:04.500
<v Michael Kennedy>about a library version from 18 months ago?

00:30:05.080 --> 00:30:06.780
<v Michael Kennedy>Well, we fixed that, at least for our shows.

00:30:07.480 --> 00:30:10.980
<v Michael Kennedy>Talk Python and Python Bytes both have MCP servers now.

00:30:11.580 --> 00:30:17.080
<v Michael Kennedy>Connect Talk Python and your AI can search over 550 episodes, full transcripts,

00:30:17.190 --> 00:30:19.120
<v Michael Kennedy>every guest in the entire course catalog.

00:30:19.740 --> 00:30:24.740
<v Michael Kennedy>Connect Python Bytes and you get almost 500 episodes of Python news going back to 2026,

00:30:25.440 --> 00:30:27.920
<v Michael Kennedy>including every link we've ever put in the show notes.

00:30:28.540 --> 00:30:29.860
<v Michael Kennedy>That means you can say things like,

00:30:30.300 --> 00:30:34.280
<v Michael Kennedy>ask Talk Python what astral joining OpenAI means for uv,

00:30:34.640 --> 00:30:37.380
<v Michael Kennedy>or what has Python Bytes said about uv?

00:30:37.700 --> 00:30:40.420
<v Michael Kennedy>And get real answers with real links, not hallucination.

00:30:40.860 --> 00:30:41.680
<v Michael Kennedy>Name the show in your prompt,

00:30:41.860 --> 00:30:44.000
<v Michael Kennedy>and your AI knows exactly where to look.

00:30:44.640 --> 00:30:45.680
<v Michael Kennedy>And if you live in the terminal,

00:30:46.060 --> 00:30:48.100
<v Michael Kennedy>Talk Python also has a CLI too.

00:30:48.600 --> 00:30:52.660
<v Michael Kennedy>One line, uvtoolinstalltalk-python-cli,

00:30:53.200 --> 00:30:58.280
<v Michael Kennedy>and then search episodes, transcripts, guests, and courses without ever opening a browser.

00:30:58.780 --> 00:31:01.800
<v Michael Kennedy>It's open source, and it outputs text, JSON, and Markdown,

00:31:01.890 --> 00:31:05.080
<v Michael Kennedy>so it feeds the AI tools that don't speak MCP yet.

00:31:05.560 --> 00:31:06.920
<v Michael Kennedy>And here's the real reason I built it.

00:31:07.480 --> 00:31:10.300
<v Michael Kennedy>Both shows cover around 10 years of Python history.

00:31:10.820 --> 00:31:15.520
<v Michael Kennedy>The people, the decisions, the packages that took over, and the ones that quietly didn't.

00:31:16.240 --> 00:31:18.180
<v Michael Kennedy>This enhanced access is free.

00:31:18.490 --> 00:31:21.160
<v Michael Kennedy>No account, no API key, nothing to buy.

00:31:21.780 --> 00:31:23.680
<v Michael Kennedy>This history should belong to all of us.

00:31:24.920 --> 00:31:26.880
<v Michael Kennedy>Visit talkpython.fm and Python Bytes

00:31:27.000 --> 00:31:28.660
<v Michael Kennedy>and click the MCP link in the nav bar.

00:31:29.160 --> 00:31:31.000
<v Michael Kennedy>Connect them right now to your agents

00:31:31.180 --> 00:31:33.940
<v Michael Kennedy>so that they'll be accessible anytime you need them in the future.

00:31:35.220 --> 00:31:37.660
<v Michael Kennedy>There's also some stuff that's been happening

00:31:37.740 --> 00:31:42.260
<v Michael Kennedy>to make running these as real backends for apps better.

00:31:42.500 --> 00:31:45.820
<v Michael Kennedy>On the SQLite side, we've got the wall or the write-ahead log

00:31:46.280 --> 00:31:48.700
<v Michael Kennedy>that allows you to have a lot less locking.

00:31:49.400 --> 00:31:56.800
<v Michael Kennedy>We've got Lightstream, which will basically build on top of that and stream constant replication to an S3 bucket.

00:31:57.560 --> 00:31:59.640
<v Michael Kennedy>What's the story with DuckDB on that kind of stuff?

00:31:59.940 --> 00:32:01.100
<v Michael Kennedy>I mean, you talked about Quack.

00:32:01.280 --> 00:32:05.240
<v Michael Kennedy>That sort of DuckDB gets to be a little bit more grown up and distributed, right?

00:32:05.500 --> 00:32:06.820
<v Guillermo Sanchez Dionis>Yeah, I mean, for sure.

00:32:08.560 --> 00:32:13.740
<v Guillermo Sanchez Dionis>I think the DuckDB experience was always very nice to run on a laptop, right?

00:32:13.900 --> 00:32:17.660
<v Guillermo Sanchez Dionis>or to basically if you wanted to run an ETL pipeline,

00:32:17.920 --> 00:32:19.660
<v Guillermo Sanchez Dionis>let's say, on an EC2 machine,

00:32:20.340 --> 00:32:21.320
<v Guillermo Sanchez Dionis>DacDB was a great tool.

00:32:22.160 --> 00:32:26.860
<v Guillermo Sanchez Dionis>But I think at least with the original DacDB file formats,

00:32:27.140 --> 00:32:31.160
<v Guillermo Sanchez Dionis>there was this sort of limitation around, you know,

00:32:31.440 --> 00:32:33.600
<v Guillermo Sanchez Dionis>one writer grabbing the log over the file

00:32:33.840 --> 00:32:35.780
<v Guillermo Sanchez Dionis>and then no readers can connect to it.

00:32:36.540 --> 00:32:39.920
<v Guillermo Sanchez Dionis>And I think that is not a limitation, of course,

00:32:39.980 --> 00:32:41.480
<v Guillermo Sanchez Dionis>if you're running DacDB in your laptop,

00:32:41.680 --> 00:32:47.680
<v Guillermo Sanchez Dionis>But it is a limitation if you want to share a DAGDB storage with a broader audience.

00:32:48.720 --> 00:32:52.300
<v Guillermo Sanchez Dionis>Quack, indeed, is something that solves this problem, right?

00:32:53.200 --> 00:32:56.800
<v Guillermo Sanchez Dionis>But then that means, of course, that you go into the client server kind of architecture.

00:32:57.700 --> 00:33:04.400
<v Guillermo Sanchez Dionis>I think SQLite does this a little bit different, where even on a single machine with a single file,

00:33:04.520 --> 00:33:08.560
<v Guillermo Sanchez Dionis>you can still have writers and readers at the same time.

00:33:08.940 --> 00:33:10.980
<v Guillermo Sanchez Dionis>But correct me if I'm wrong, I'm not sure about this.

00:33:11.960 --> 00:33:13.000
<v Guillermo Sanchez Dionis>putting you on the spot.

00:33:13.560 --> 00:33:14.680
<v Guillermo Sanchez Dionis>You're not a SQLite expert.

00:33:16.220 --> 00:33:17.180
<v Michael Kennedy>I think so with the

00:33:17.460 --> 00:33:19.300
<v Michael Kennedy>I think with the writer headlock, it does

00:33:19.880 --> 00:33:21.560
<v Michael Kennedy>log rather. I think it does

00:33:21.880 --> 00:33:23.420
<v Michael Kennedy>allow multiple writers

00:33:23.620 --> 00:33:25.100
<v Michael Kennedy>to different parts of the database,

00:33:25.660 --> 00:33:26.820
<v Michael Kennedy>but there's still some locking.

00:33:27.400 --> 00:33:29.540
<v Guillermo Sanchez Dionis>We have the same. We also have a writer headlock,

00:33:29.640 --> 00:33:31.240
<v Guillermo Sanchez Dionis>but probably they have a different mechanism

00:33:31.700 --> 00:33:33.720
<v Guillermo Sanchez Dionis>that allows for multiple writers at the same time.

00:33:34.040 --> 00:33:35.660
<v Guillermo Sanchez Dionis>I mean, DictDB does have like these

00:33:36.380 --> 00:33:37.500
<v Guillermo Sanchez Dionis>you know, within one

00:33:37.840 --> 00:33:39.439
<v Guillermo Sanchez Dionis>single process

00:33:39.440 --> 00:33:42.900
<v Guillermo Sanchez Dionis>you can still have multiple child connections

00:33:43.240 --> 00:33:44.480
<v Guillermo Sanchez Dionis>right into the same database as well.

00:33:44.710 --> 00:33:47.760
<v Guillermo Sanchez Dionis>I think the problem is if you try to access that G from a different process,

00:33:48.080 --> 00:33:51.020
<v Guillermo Sanchez Dionis>then that's where the lock-in mechanism triggers.

00:33:51.580 --> 00:33:55.020
<v Guillermo Sanchez Dionis>But yeah, indeed, Quack is a good solution for this,

00:33:55.280 --> 00:33:59.260
<v Guillermo Sanchez Dionis>but it goes more into this client-server recipe again.

00:33:59.540 --> 00:34:04.460
<v Michael Kennedy>So if I'm using Quack, do I host my backend with you all at Mother Duck

00:34:04.890 --> 00:34:06.300
<v Michael Kennedy>in some sort of cloud situation?

00:34:06.700 --> 00:34:10.060
<v Michael Kennedy>Do I self-host some backend piece to make this possible?

00:34:10.240 --> 00:34:10.740
<v Michael Kennedy>What's the story?

00:34:10.940 --> 00:34:12.960
<v Guillermo Sanchez Dionis>You can host it anywhere you like, actually.

00:34:13.220 --> 00:34:17.840
<v Guillermo Sanchez Dionis>I mean, also the nice thing about it being DuckDV is it's extremely simple to use, right?

00:34:17.960 --> 00:34:25.620
<v Guillermo Sanchez Dionis>So if you want to try it out, you'd go to a terminal, you basically type install quack, load quack.

00:34:25.720 --> 00:34:29.040
<v Guillermo Sanchez Dionis>And then the next thing that you do is you call a function called quack serve.

00:34:29.340 --> 00:34:31.580
<v Guillermo Sanchez Dionis>And that will already spin up a server for you, right?

00:34:31.919 --> 00:34:40.679
<v Guillermo Sanchez Dionis>And then from another terminal client, you could just go in, connect to this specific address in your local host, and then you already have a client-server protocol working.

00:34:41.060 --> 00:34:45.960
<v Guillermo Sanchez Dionis>Which, if you compare it to, again, traditional systems like Postgres, it's extremely simple.

00:34:47.220 --> 00:34:55.840
<v Guillermo Sanchez Dionis>And obviously, in a more production-grade scenario, you host this on EC2, and then maybe you need something like a load balancer on top of that.

00:34:55.919 --> 00:35:00.900
<v Guillermo Sanchez Dionis>Because also the nice thing about Quack is it runs on modern HTTPS.

00:35:01.140 --> 00:35:02.540
<v Guillermo Sanchez Dionis>So it's also very nice.

00:35:02.800 --> 00:35:05.840
<v Guillermo Sanchez Dionis>You don't need to reinvent a protocol yourself on top of TCP.

00:35:06.140 --> 00:35:07.340
<v Guillermo Sanchez Dionis>It's just plain old HTTP.

00:35:08.820 --> 00:35:15.820
<v Guillermo Sanchez Dionis>So yeah, I think it's relatively simple to still get something up and running on the cloud and get it to work.

00:35:16.780 --> 00:35:19.820
<v Guillermo Sanchez Dionis>Yeah, it's a very nice foundation, I think, for a client-server architecture.

00:35:20.120 --> 00:35:23.800
<v Michael Kennedy>I like how you all keep it playful as well, you know, with quack and ducks.

00:35:23.980 --> 00:35:28.900
<v Michael Kennedy>And, you know, it could be now you're going to create a database provider factory,

00:35:29.220 --> 00:35:30.860
<v Michael Kennedy>and the factory is going to get the provider.

00:35:31.060 --> 00:35:33.560
<v Michael Kennedy>then the provider is going to, you know, just like, you know, I don't know.

00:35:34.000 --> 00:35:37.420
<v Guillermo Sanchez Dionis>Yeah, actually, very funny story about this, now that you bring this up,

00:35:37.640 --> 00:35:39.860
<v Guillermo Sanchez Dionis>is that it was called Quack at the beginning, right?

00:35:39.960 --> 00:35:40.760
<v Guillermo Sanchez Dionis>This was Hannes' idea.

00:35:41.300 --> 00:35:44.360
<v Guillermo Sanchez Dionis>And then someone within the company mentioned like,

00:35:44.390 --> 00:35:47.920
<v Guillermo Sanchez Dionis>oh, shouldn't we call this a little bit more of a straightforward name,

00:35:48.220 --> 00:35:52.760
<v Guillermo Sanchez Dionis>like, you know, RPC protocol or something like that?

00:35:53.000 --> 00:35:57.940
<v Guillermo Sanchez Dionis>And then both me and Gabor, which is the main dev world in the team,

00:35:58.170 --> 00:35:59.560
<v Guillermo Sanchez Dionis>we said like, no, no, no way.

00:35:59.820 --> 00:36:00.700
<v Guillermo Sanchez Dionis>It has to be called Quack.

00:36:01.000 --> 00:36:02.620
<v Guillermo Sanchez Dionis>Quack is too good to pass on.

00:36:02.760 --> 00:36:04.580
<v Guillermo Sanchez Dionis>We cannot pass on these names so good.

00:36:04.740 --> 00:36:05.800
<v Michael Kennedy>I mean, the branding is great.

00:36:05.940 --> 00:36:08.180
<v Michael Kennedy>You hear Quack, you're like, oh, that's got to be DuckDB, right?

00:36:08.320 --> 00:36:13.160
<v Michael Kennedy>Like no one else is going to take the Quack protocol and get away with it.

00:36:13.780 --> 00:36:14.040
<v Michael Kennedy>All right.

00:36:14.880 --> 00:36:17.840
<v Michael Kennedy>Let's talk about Duck Lake.

00:36:20.200 --> 00:36:21.540
<v Michael Kennedy>So, yeah, let's talk Duck Lake.

00:36:21.600 --> 00:36:23.580
<v Michael Kennedy>I think it's a really interesting project.

00:36:25.280 --> 00:36:27.240
<v Michael Kennedy>It's not a direct follow-on.

00:36:27.440 --> 00:36:30.400
<v Michael Kennedy>It's not just a more distributed DuckDB, right?

00:36:30.460 --> 00:36:32.000
<v Michael Kennedy>This is a bigger idea.

00:36:32.440 --> 00:36:32.660
<v Pedro Holanda>Yeah.

00:36:33.280 --> 00:36:46.240
<v Pedro Holanda>So the basic gist of Duck Lake is that I think Mark and Hannah were already looking at data lakes for a while because we had been getting lots of requests for support for Iceberg.

00:36:46.680 --> 00:36:55.180
<v Pedro Holanda>And I think they were already seeing that having the metadata in files was just not as efficient, right?

00:36:55.300 --> 00:36:59.220
<v Pedro Holanda>Like you suddenly have to do so many hoops on these files to get to your data.

00:36:59.660 --> 00:37:01.300
<v Pedro Holanda>the more snapshots you have,

00:37:01.860 --> 00:37:04.340
<v Pedro Holanda>because maybe researching tons of small files,

00:37:04.540 --> 00:37:05.360
<v Pedro Holanda>there's a small file problem, right?

00:37:05.460 --> 00:37:06.780
<v Pedro Holanda>Like we all have heard about this.

00:37:07.880 --> 00:37:09.320
<v Pedro Holanda>If you've been around data lakes,

00:37:09.400 --> 00:37:12.200
<v Pedro Holanda>it's that basically if you have lots of small insertions,

00:37:12.340 --> 00:37:13.860
<v Pedro Holanda>like in a streaming fashion, for example,

00:37:14.200 --> 00:37:16.240
<v Pedro Holanda>you create so much of these metadata files

00:37:16.420 --> 00:37:19.300
<v Pedro Holanda>that it's hard to get to your actual data.

00:37:19.760 --> 00:37:25.100
<v Pedro Holanda>So I don't know, I guess as database researchers and engineers,

00:37:25.260 --> 00:37:27.460
<v Pedro Holanda>they were like, well, why is this not just a database?

00:37:28.000 --> 00:37:30.520
<v Pedro Holanda>So I actually have it somewhere here.

00:37:30.920 --> 00:37:32.140
<v Pedro Holanda>Oh, easy to pick this time.

00:37:32.460 --> 00:37:34.720
<v Pedro Holanda>This was the initial idea they had.

00:37:34.980 --> 00:37:37.100
<v Pedro Holanda>So here you can see like all the files, right?

00:37:37.260 --> 00:37:39.340
<v Pedro Holanda>So they're like, why can't it just be like a database?

00:37:39.880 --> 00:37:41.880
<v Pedro Holanda>And there's already like a database here on the top

00:37:42.000 --> 00:37:43.480
<v Pedro Holanda>because in the end, they needed like a database

00:37:43.700 --> 00:37:46.680
<v Pedro Holanda>to get a pointer for the latest metadata file.

00:37:46.860 --> 00:37:48.960
<v Pedro Holanda>So what if we just put this all in the database

00:37:49.280 --> 00:37:51.120
<v Pedro Holanda>and then I made them sign for me

00:37:51.220 --> 00:37:53.040
<v Pedro Holanda>in case this was a very successful idea.

00:37:53.240 --> 00:37:55.920
<v Pedro Holanda>So if anyone wants to buy this, it's for sale

00:37:56.680 --> 00:37:57.640
<v Pedro Holanda>or for the rights price.

00:37:58.820 --> 00:38:03.500
<v Pedro Holanda>so that was the basic gist right because having this whole metadata in the database you can just

00:38:03.610 --> 00:38:12.040
<v Pedro Holanda>query with sql anyone can easily see a schema and write sql over it so just specify the schema of

00:38:12.040 --> 00:38:16.060
<v Pedro Holanda>these tables that hold all this information the metadata and you could you could then have

00:38:16.330 --> 00:38:23.719
<v Pedro Holanda>something that's more efficient and simpler right because i think for iceberg you have json you have

00:38:23.780 --> 00:38:25.920
<v Pedro Holanda>Avro, you might have

00:38:25.970 --> 00:38:27.460
<v Pedro Holanda>some other file formats

00:38:28.480 --> 00:38:29.820
<v Pedro Holanda>that I'm not, just to store

00:38:29.890 --> 00:38:31.820
<v Pedro Holanda>like the metadata, so just to

00:38:31.820 --> 00:38:33.700
<v Pedro Holanda>be able to read this format, you need

00:38:33.750 --> 00:38:35.760
<v Pedro Holanda>like three or four different file

00:38:36.020 --> 00:38:37.740
<v Pedro Holanda>format readers, and then you need to hoop

00:38:37.900 --> 00:38:39.600
<v Pedro Holanda>through all of these, and with Duck Lake

00:38:39.780 --> 00:38:41.780
<v Pedro Holanda>it's simply like, okay, go to

00:38:41.810 --> 00:38:43.680
<v Pedro Holanda>the catalog, ask the catalog, which files

00:38:43.780 --> 00:38:45.660
<v Pedro Holanda>do I have to read to read my table at a certain

00:38:45.860 --> 00:38:47.740
<v Pedro Holanda>snapshots, you have the list of files and

00:38:47.740 --> 00:38:49.800
<v Pedro Holanda>you read them, so there's

00:38:49.840 --> 00:38:51.959
<v Pedro Holanda>the simplicity factor. Nice, I think

00:38:51.980 --> 00:38:58.560
<v Michael Kennedy>maybe the place, the way to make this clear to folks is let's maybe talk through the architecture

00:38:59.100 --> 00:39:05.620
<v Michael Kennedy>of these data lakes in general, but also the duck lake specific version, you know, and I know a lot

00:39:05.620 --> 00:39:09.280
<v Michael Kennedy>of people haven't worked with these necessarily worked with databases, they've worked with APIs,

00:39:09.640 --> 00:39:15.179
<v Michael Kennedy>and they've worked with storage like S3. But the general idea, I guess maybe the iceberg

00:39:16.259 --> 00:39:22.280
<v Michael Kennedy>original idea was, well, what if we could just use all of S3 for scaling? Like think how scalable

00:39:22.440 --> 00:39:26.020
<v Michael Kennedy>that is. And we just put a bunch of files all over the place, like a bunch of parquet files.

00:39:26.420 --> 00:39:30.380
<v Michael Kennedy>Well, you need something to gather them together if you can do a query across them. So we'll put a

00:39:30.560 --> 00:39:34.940
<v Michael Kennedy>metadata file up there as well. But then the problem is, well, I'm going to do a query. So it's a

00:39:35.320 --> 00:39:39.780
<v Michael Kennedy>S3 request to the metadata. And then you parse that. Maybe you got to get some more metadata.

00:39:40.060 --> 00:39:43.959
<v Michael Kennedy>Then you go to the file. It's just a lot of back and forth. And Pedro, that's what you're talking

00:39:43.980 --> 00:39:47.820
<v Michael Kennedy>about where you're like, well, what if a lot of that back and forth could just be in a database?

00:39:48.410 --> 00:39:53.160
<v Pedro Holanda>And then you finally get to the data, right? Exactly. And I think, sure, there's something

00:39:53.340 --> 00:39:58.320
<v Pedro Holanda>to be said that if you just have your files on S3, you can theoretically scale this indefinitely,

00:39:58.620 --> 00:40:04.340
<v Pedro Holanda>right? Because you could have bazillion readers reading at the same time, that's fine. But with

00:40:04.500 --> 00:40:11.099
<v Pedro Holanda>database systems, well, I would say that the point you have to scale is much lower. A database like

00:40:11.120 --> 00:40:16.640
<v Pedro Holanda>DuckDB can make use of a small piece of hardware quite drastically,

00:40:16.790 --> 00:40:19.460
<v Pedro Holanda>but it's also you have distributed database systems, right?

00:40:19.550 --> 00:40:24.620
<v Pedro Holanda>So the only restrictions for the catalog is that I think it needs to have

00:40:26.179 --> 00:40:29.660
<v Pedro Holanda>timestamp, varchar, and integer types and use primary keys.

00:40:30.030 --> 00:40:35.480
<v Pedro Holanda>So any system that has this for can theoretically be a catalog for DuckLake.

00:40:35.740 --> 00:40:39.979
<v Pedro Holanda>So I do believe that there's also potential for hyperscading there

00:40:40.600 --> 00:40:43.300
<v Pedro Holanda>or the case where your metadata is really that big.

00:40:43.340 --> 00:40:45.400
<v Pedro Holanda>And again, this is not about the size of your data, right?

00:40:45.600 --> 00:40:46.940
<v Pedro Holanda>It's the size of your metadata.

00:40:47.620 --> 00:40:49.660
<v Michael Kennedy>Right, just here are the tables,

00:40:50.100 --> 00:40:51.280
<v Michael Kennedy>here's the elements, here are the stored.

00:40:51.520 --> 00:40:54.120
<v Michael Kennedy>You know, it's worth maybe emphasizing

00:40:54.640 --> 00:40:57.420
<v Michael Kennedy>that scalability, something that's highly scalable,

00:40:57.680 --> 00:40:58.780
<v Michael Kennedy>doesn't mean it's fast.

00:40:59.200 --> 00:41:01.720
<v Michael Kennedy>It just means as you add many, many more users

00:41:02.100 --> 00:41:04.800
<v Michael Kennedy>or amounts of data to it, it doesn't get slower.

00:41:05.020 --> 00:41:07.200
<v Michael Kennedy>But it could have been kind of slow from the start.

00:41:07.680 --> 00:41:08.040
<v Michael Kennedy>You know what I mean?

00:41:08.240 --> 00:41:11.520
<v Michael Kennedy>Like 12 back and forths across S3s,

00:41:11.900 --> 00:41:12.660
<v Michael Kennedy>even for one query,

00:41:12.840 --> 00:41:14.780
<v Michael Kennedy>is still slow if you don't have a ton of data,

00:41:14.980 --> 00:41:16.520
<v Michael Kennedy>but maybe it's consistent

00:41:16.720 --> 00:41:18.520
<v Michael Kennedy>as you add a million more, right?

00:41:19.200 --> 00:41:20.500
<v Michael Kennedy>So there's that worth considering.

00:41:20.580 --> 00:41:23.400
<v Michael Kennedy>It's like performance for one thing versus scale.

00:41:24.500 --> 00:41:24.900
<v Pedro Holanda>Absolutely.

00:41:25.500 --> 00:41:27.000
<v Pedro Holanda>But as you think, again,

00:41:27.280 --> 00:41:28.580
<v Pedro Holanda>that from the catalog side,

00:41:28.640 --> 00:41:30.600
<v Pedro Holanda>the scalability of Duck Lake

00:41:31.360 --> 00:41:32.680
<v Pedro Holanda>doesn't necessarily have to suffer.

00:41:33.020 --> 00:41:33.360
<v Pedro Holanda>Like you have options.

00:41:33.360 --> 00:41:33.860
<v Pedro Holanda>No, no, no, no.

00:41:34.300 --> 00:41:35.040
<v Pedro Holanda>Yeah, absolutely.

00:41:35.180 --> 00:41:36.940
<v Michael Kennedy>I'm not suggesting it does.

00:41:37.140 --> 00:41:37.760
<v Michael Kennedy>I'm just saying like,

00:41:37.940 --> 00:41:40.940
<v Michael Kennedy>Okay, I built a scalable system, like, great, but it was slow from the start.

00:41:41.070 --> 00:41:41.700
<v Michael Kennedy>So, like, it doesn't...

00:41:41.780 --> 00:41:42.300
<v Michael Kennedy>Yeah, yeah, absolutely.

00:41:42.660 --> 00:41:43.240
<v Michael Kennedy>You know what I mean?

00:41:43.720 --> 00:41:45.740
<v Michael Kennedy>All right, so basically the architecture looks like this.

00:41:45.920 --> 00:41:47.340
<v Michael Kennedy>There's three core elements.

00:41:47.740 --> 00:41:51.720
<v Michael Kennedy>There's storage, there's catalog services, and there's compute.

00:41:52.020 --> 00:41:53.720
<v Michael Kennedy>Who wants to break that down for people?

00:41:54.140 --> 00:42:03.600
<v Guillermo Sanchez Dionis>Yeah, so, I mean, basically the storage can be, as you mentioned before, anything that is object storage, like S3 or Blob of Storage.

00:42:04.820 --> 00:42:12.160
<v Guillermo Sanchez Dionis>Usually, you know, people go for options that are cloud hosted, of course, like S3, GCS, or Azure Blob Storage.

00:42:13.540 --> 00:42:20.860
<v Guillermo Sanchez Dionis>And that's where the parquet files lead in the case of DuckLake and nothing else because we don't have any metadata files.

00:42:22.120 --> 00:42:27.320
<v Guillermo Sanchez Dionis>Then you have the catalog service, which you can theoretically run in anything that is BigSQL.

00:42:27.460 --> 00:42:42.980
<v Guillermo Sanchez Dionis>Well, the DuckDB extension of DuckLake, right, which is basically our implementation of a reader and a writer for DuckLake, can speak to MySQL, Postgres, SQLite, and of course, DuckDB and Quack.

00:42:43.740 --> 00:42:45.760
<v Guillermo Sanchez Dionis>Because they're not exactly the same, right?

00:42:45.810 --> 00:42:50.460
<v Guillermo Sanchez Dionis>One lives next to you, the other one lives in any remote server that you want it to be.

00:42:50.760 --> 00:42:57.120
<v Guillermo Sanchez Dionis>And this catalog service is what contains all of the metadata regarding these parquet files that leave in object storage.

00:42:57.620 --> 00:43:02.540
<v Guillermo Sanchez Dionis>so basically then the third component which in this case is the compute right and indeed it can

00:43:02.540 --> 00:43:08.900
<v Guillermo Sanchez Dionis>be anything it can be spark or it can be dactdb and of course any anything that supports this

00:43:09.060 --> 00:43:14.620
<v Guillermo Sanchez Dionis>format and then the only thing that they need to do in order to query for example some tables right

00:43:14.800 --> 00:43:19.960
<v Guillermo Sanchez Dionis>is they they make some sql queries against the catalog service right and the catalog service

00:43:20.420 --> 00:43:26.600
<v Guillermo Sanchez Dionis>returns something like a list of files for example and some statistics regarding those files so that

00:43:26.540 --> 00:43:29.940
<v Guillermo Sanchez Dionis>the reader knows what it needs to read, basically.

00:43:30.380 --> 00:43:36.040
<v Guillermo Sanchez Dionis>And I think this is very nice, actually, because you just need one query, actually, in order

00:43:36.090 --> 00:43:39.280
<v Guillermo Sanchez Dionis>to retrieve all of the information that you need to query these parquet files.

00:43:40.140 --> 00:43:45.460
<v Guillermo Sanchez Dionis>And I think this is the big, powerful thing about Tag Lake is that we designed it with

00:43:46.070 --> 00:43:48.300
<v Guillermo Sanchez Dionis>pretty much Iceberg and Delta in our heads, right?

00:43:48.560 --> 00:43:53.280
<v Guillermo Sanchez Dionis>Where usually there's more than one roundtrip, taking more than one file just to figure out

00:43:53.480 --> 00:43:54.700
<v Guillermo Sanchez Dionis>which parquet files you need to read.

00:43:54.890 --> 00:43:56.360
<v Guillermo Sanchez Dionis>In our case, it's just one SQL query.

00:43:56.480 --> 00:44:04.940
<v Guillermo Sanchez Dionis>I think that that is basically what collapses the complexity quite a bit for engines that are trying to read this format or write to this format.

00:44:05.200 --> 00:44:08.760
<v Michael Kennedy>Yeah, you can do database things like join or something if you need to, right?

00:44:09.040 --> 00:44:20.380
<v Guillermo Sanchez Dionis>Yeah, I mean, indeed, actually, like one of the things that is very interesting about Iceberg and Delta is that because they grew backwards, they started to think about operations in a different way, right?

00:44:20.500 --> 00:44:26.680
<v Guillermo Sanchez Dionis>Like you were mentioning, for example, you know, at the beginning, it was just writing some parquet files and some metadata that points to them.

00:44:26.830 --> 00:44:32.040
<v Guillermo Sanchez Dionis>But then at some point, they wanted to do acid operations on this data, right?

00:44:32.420 --> 00:44:34.360
<v Guillermo Sanchez Dionis>And then you need to give some sort of guarantees.

00:44:34.840 --> 00:44:41.740
<v Guillermo Sanchez Dionis>And to give those guarantees, they built this very complex structure of metadata files and manifest lists and manifest files.

00:44:42.820 --> 00:44:47.540
<v Guillermo Sanchez Dionis>When for us at Obesity is just basically, you know, if you're writing to a table, right?

00:44:47.820 --> 00:44:51.520
<v Guillermo Sanchez Dionis>And then, yeah, you're basically raising another transaction.

00:44:51.660 --> 00:44:54.680
<v Guillermo Sanchez Dionis>You can just see whether the other transaction succeeded or not, right?

00:44:54.760 --> 00:44:57.920
<v Guillermo Sanchez Dionis>It's just something that is built into your catalog service.

00:44:58.320 --> 00:45:01.680
<v Guillermo Sanchez Dionis>So for us, we didn't have to build any ACID.

00:45:01.700 --> 00:45:07.360
<v Guillermo Sanchez Dionis>It was built into the design, basically, because the catalog service is a SQL database that already supports ACID transactions.

00:45:07.920 --> 00:45:12.660
<v Guillermo Sanchez Dionis>So, yeah, I think that was also an extremely nice thing about DuckLake from the get-go.

00:45:12.960 --> 00:45:13.480
<v Michael Kennedy>Yeah, absolutely.

00:45:13.820 --> 00:45:18.960
<v Michael Kennedy>Now, whoever wants to take this, give us a sense of the size of these parquet files.

00:45:19.160 --> 00:45:23.120
<v Michael Kennedy>I know when I created Datalake, I've got a bunch of different parquet files.

00:45:23.280 --> 00:45:27.680
<v Michael Kennedy>I've got a database catalog that will tell me, okay, if I have this type of query, go look at these three.

00:45:27.920 --> 00:45:31.420
<v Michael Kennedy>But are these five kilobytes, five megabytes, five gigabytes?

00:45:31.660 --> 00:45:32.300
<v Michael Kennedy>What are we talking?

00:45:32.580 --> 00:45:35.820
<v Guillermo Sanchez Dionis>Well, you decide the size, basically, right?

00:45:35.940 --> 00:45:40.400
<v Guillermo Sanchez Dionis>You can say that the target file size is something like 512 megabytes.

00:45:40.620 --> 00:45:51.700
<v Guillermo Sanchez Dionis>And if you're doing batch operations on your data, so batch writing, like Taglic will respect that you write 512 megabytes files with certain row group sites.

00:45:52.720 --> 00:46:04.420
<v Guillermo Sanchez Dionis>Of course, if you do very small operations on your data where you do very small writes, then you may have, if you don't have data inlining on, which is a feature that maybe we will discuss later, you will have very small files.

00:46:04.920 --> 00:46:21.520
<v Guillermo Sanchez Dionis>And then what happens usually in Lakehouse or OpenTable formats is that you have some sort of compaction functions that the engine offers that allow you to compact these very small files into bigger files so that, you know, engines can scale reading better, right?

00:46:21.670 --> 00:46:25.120
<v Guillermo Sanchez Dionis>Because engines don't like to read 1,000 5-kilobyte files.

00:46:25.430 --> 00:46:29.720
<v Guillermo Sanchez Dionis>They prefer to read, you know, half a gigabyte file that you can still parallelize, by the way.

00:46:30.000 --> 00:46:30.360
<v Michael Kennedy>Yeah, okay.

00:46:30.570 --> 00:46:32.080
<v Michael Kennedy>That makes a lot of sense, I guess.

00:46:32.120 --> 00:46:39.020
<v Michael Kennedy>The smaller they get, the more you're paying the cost of the latency round trip than the actual reading.

00:46:39.180 --> 00:46:47.480
<v Michael Kennedy>Now, operationally, transferring data is fast on S3 and friends, but it can start to get expensive if you have too much traffic there.

00:46:47.740 --> 00:46:56.740
<v Michael Kennedy>Do you recommend running this maybe inside of a data center where you have within the data center traffic to your data storage?

00:46:57.140 --> 00:46:58.320
<v Michael Kennedy>Or what does that look like?

00:46:58.380 --> 00:47:01.720
<v Guillermo Sanchez Dionis>I think Pedro is the expert on reading from object storage.

00:47:02.100 --> 00:47:05.040
<v Guillermo Sanchez Dionis>He has a ton of that in the last one.

00:47:05.340 --> 00:47:11.540
<v Pedro Holanda>I think the typical setup is that people use like an S3 EC2 kind of instance, right?

00:47:11.760 --> 00:47:13.960
<v Pedro Holanda>So you have an RBS.

00:47:14.360 --> 00:47:18.700
<v Pedro Holanda>So in the end, you can definitely have this separate.

00:47:20.000 --> 00:47:23.500
<v Pedro Holanda>I think that's the usual way that people run.

00:47:23.840 --> 00:47:24.720
<v Michael Kennedy>Yeah, that's what I would imagine.

00:47:24.800 --> 00:47:29.440
<v Michael Kennedy>or DigitalOcean servers with spaces or anything.

00:47:29.720 --> 00:47:31.560
<v Michael Kennedy>It could probably talk to anything that talks S3,

00:47:31.620 --> 00:47:32.420
<v Michael Kennedy>I would imagine, right?

00:47:32.680 --> 00:47:33.680
<v Michael Kennedy>Yes, absolutely.

00:47:34.080 --> 00:47:34.260
<v Michael Kennedy>Yeah.

00:47:34.580 --> 00:47:34.680
<v Michael Kennedy>Okay.

00:47:35.200 --> 00:47:36.500
<v Michael Kennedy>Now, I'm back.

00:47:36.920 --> 00:47:39.580
<v Michael Kennedy>We've got different ways to set this up.

00:47:40.280 --> 00:47:40.880
<v Michael Kennedy>Oh, sorry.

00:47:40.940 --> 00:47:43.020
<v Michael Kennedy>Before we move on, there was a third piece.

00:47:43.420 --> 00:47:45.240
<v Michael Kennedy>There's storage, there's the catalog,

00:47:45.460 --> 00:47:46.420
<v Michael Kennedy>and then there's compute.

00:47:46.720 --> 00:47:47.980
<v Michael Kennedy>What's the story with compute?

00:47:48.340 --> 00:47:50.320
<v Michael Kennedy>Like, what kind of stuff am I computing, right?

00:47:50.620 --> 00:47:51.300
<v Pedro Holanda>Yeah, absolutely.

00:47:52.480 --> 00:47:57.740
<v Pedro Holanda>theoretically, you can use anything that reads Parquet files to perform the computation, right?

00:47:59.040 --> 00:48:03.240
<v Pedro Holanda>As Guillermo says, in the end, if you have your catalog running, you just have to issue the

00:48:03.270 --> 00:48:08.340
<v Pedro Holanda>correct queries. The queries will basically tell you, read these files to answer the query you want

00:48:08.950 --> 00:48:15.400
<v Pedro Holanda>to answer. And you can use any kind of tool that is capable of reading these files. I think that

00:48:15.760 --> 00:48:22.440
<v Pedro Holanda>most people just use DeckDB. And there's also like a Data Fusion extension that's quite

00:48:22.460 --> 00:48:24.060
<v Pedro Holanda>evolves already.

00:48:24.900 --> 00:48:26.580
<v Pedro Holanda>But I'm not sure if there's like a Spark

00:48:26.820 --> 00:48:28.720
<v Pedro Holanda>proper implementation of

00:48:29.120 --> 00:48:30.540
<v Pedro Holanda>the Spark. Maybe Guillermo knows.

00:48:31.400 --> 00:48:32.840
<v Guillermo Sanchez Dionis>There is a

00:48:33.080 --> 00:48:34.740
<v Guillermo Sanchez Dionis>Spark writer, I think

00:48:34.920 --> 00:48:35.860
<v Guillermo Sanchez Dionis>specifically, that was

00:48:36.820 --> 00:48:38.000
<v Guillermo Sanchez Dionis>developed by MotherDuck because

00:48:38.760 --> 00:48:40.900
<v Guillermo Sanchez Dionis>some of their customers were using Spark for ETL

00:48:41.240 --> 00:48:42.900
<v Guillermo Sanchez Dionis>so they thought that it would make sense

00:48:42.940 --> 00:48:44.480
<v Guillermo Sanchez Dionis>to have a Spark writer

00:48:44.980 --> 00:48:46.300
<v Guillermo Sanchez Dionis>into Duck Lake. I see.

00:48:46.560 --> 00:48:48.660
<v Pedro Holanda>So the basic gist is that you can

00:48:49.080 --> 00:48:50.920
<v Pedro Holanda>actually use any engine

00:48:50.940 --> 00:48:55.180
<v Pedro Holanda>you want as long as you have like these pieces properly built.

00:48:55.480 --> 00:48:55.660
<v Michael Kennedy>Nice.

00:48:55.740 --> 00:48:59.740
<v Michael Kennedy>And then you've got some Python code or whatever code that talks to that.

00:49:00.220 --> 00:49:00.920
<v Michael Kennedy>I have this question.

00:49:01.220 --> 00:49:01.880
<v Michael Kennedy>Go figure it out.

00:49:02.180 --> 00:49:02.520
<v Michael Kennedy>Yeah, exactly.

00:49:03.060 --> 00:49:03.180
<v Michael Kennedy>Okay.

00:49:03.600 --> 00:49:05.240
<v Michael Kennedy>Now, there's different setups here.

00:49:05.640 --> 00:49:12.200
<v Michael Kennedy>I would imagine the most common setup is probably Postgres as your catalog and storage as Parquet

00:49:12.360 --> 00:49:12.900
<v Michael Kennedy>files, though.

00:49:13.300 --> 00:49:14.940
<v Michael Kennedy>Hat tip to compress CSVs.

00:49:16.780 --> 00:49:18.880
<v Michael Kennedy>Postgres and Parquet somewhere.

00:49:19.240 --> 00:49:24.180
<v Michael Kennedy>But you can also do, it's partly why I jumped on this, you can do SQLite as your catalog,

00:49:24.550 --> 00:49:28.420
<v Michael Kennedy>or you could, which is in-process, and same with the in-process DuckDB,

00:49:28.640 --> 00:49:32.580
<v Michael Kennedy>or even Wermos quack backend that's distributed, right?

00:49:32.720 --> 00:49:34.420
<v Michael Kennedy>Like maybe talk about these different options.

00:49:35.140 --> 00:49:35.780
<v Michael Kennedy>When do you recommend which?

00:49:36.940 --> 00:49:41.460
<v Pedro Holanda>So I would say that a lot of people also use DuckDB as an in-process solution

00:49:41.780 --> 00:49:44.940
<v Pedro Holanda>to either develop their own data lake on their own machine,

00:49:45.090 --> 00:49:47.920
<v Pedro Holanda>but I think also a lot of people have been using with their favorites,

00:49:48.120 --> 00:49:52.940
<v Pedro Holanda>clanker just to store the data also in the local lake house formats.

00:49:53.010 --> 00:49:59.580
<v Pedro Holanda>But if you're using DuckDB specifically, it also means that as DuckDB works, like Guillermo

00:49:59.590 --> 00:50:03.960
<v Pedro Holanda>said before, is that you can only have one writer connected at a time, right?

00:50:03.960 --> 00:50:08.920
<v Pedro Holanda>So you cannot have multiple people connected to the data lake and writing if the DuckDB

00:50:08.920 --> 00:50:09.460
<v Pedro Holanda>is your catalog.

00:50:09.810 --> 00:50:15.540
<v Pedro Holanda>So I would say in production, what I've seen is that indeed most people use Postgres because

00:50:15.560 --> 00:50:18.140
<v Pedro Holanda>it takes that limitation away.

00:50:18.590 --> 00:50:20.380
<v Pedro Holanda>So you suddenly can operate with it

00:50:20.880 --> 00:50:24.060
<v Pedro Holanda>in a way that people are more accustomed to using.

00:50:25.540 --> 00:50:28.140
<v Pedro Holanda>And of course, Quack is still experimental.

00:50:28.440 --> 00:50:31.560
<v Pedro Holanda>I think we're going to have the first stable release

00:50:31.800 --> 00:50:34.160
<v Pedro Holanda>with DuckDB 2.0, like in a month and a half.

00:50:34.480 --> 00:50:37.440
<v Pedro Holanda>But Quack already works with DuckLake as well,

00:50:37.560 --> 00:50:40.060
<v Pedro Holanda>but don't run that in production right now, people.

00:50:40.260 --> 00:50:41.460
<v Pedro Holanda>Wait a little bit longer.

00:50:42.360 --> 00:50:43.840
<v Pedro Holanda>But it's also quite cool

00:50:43.860 --> 00:50:46.940
<v Pedro Holanda>because, for example, when using Postgres,

00:50:47.440 --> 00:50:48.700
<v Pedro Holanda>one of the problems that we face

00:50:48.800 --> 00:50:50.980
<v Pedro Holanda>is that if there is a conflict on your snapshot ID,

00:50:51.120 --> 00:50:53.280
<v Pedro Holanda>like you're doing multiple transactions on the same table,

00:50:53.660 --> 00:50:54.720
<v Pedro Holanda>every time you have the conflicts,

00:50:54.780 --> 00:50:57.560
<v Pedro Holanda>you have to return to the application from the database

00:50:57.800 --> 00:50:58.920
<v Pedro Holanda>and say, hey, there's a conflict,

00:50:59.540 --> 00:51:01.320
<v Pedro Holanda>recalculate your snapshot ID, some other things,

00:51:01.480 --> 00:51:03.080
<v Pedro Holanda>and send the queries to me again.

00:51:03.360 --> 00:51:05.300
<v Pedro Holanda>So you have this round tripping

00:51:05.540 --> 00:51:09.460
<v Pedro Holanda>and that actually creates quite a big cost on retrials.

00:51:09.820 --> 00:51:12.040
<v Pedro Holanda>But with Quack, because it's just DuckDB,

00:51:12.240 --> 00:51:15.560
<v Pedro Holanda>what we can do is that we load DuckLake on the Quark server,

00:51:16.040 --> 00:51:18.820
<v Pedro Holanda>and then we can immediately do the retrials in the server,

00:51:19.620 --> 00:51:21.520
<v Pedro Holanda>avoiding this process, right?

00:51:21.740 --> 00:51:25.260
<v Pedro Holanda>So to give you an idea, if you have Postgres as your catalog,

00:51:25.760 --> 00:51:29.720
<v Pedro Holanda>I think in a very contentious environment with, I don't know,

00:51:29.720 --> 00:51:33.440
<v Pedro Holanda>like 20 writers, you have something like five transactions a second

00:51:33.640 --> 00:51:35.040
<v Pedro Holanda>because of this retrial cost.

00:51:35.280 --> 00:51:38.880
<v Pedro Holanda>But if you're using DuckDB and Quark, it's like 200 transactions a second

00:51:39.100 --> 00:51:41.680
<v Pedro Holanda>because the retrials are now running on the server.

00:51:42.060 --> 00:51:50.580
<v Pedro Holanda>So, yeah, my expectation is that as time goes on, Quark will be the de facto catalog for Dark Lake.

00:51:50.920 --> 00:51:59.400
<v Guillermo Sanchez Dionis>Maybe something to add to that is that, you know, I think Lakehouse formats, they were never designed for transactional workloads in the first place, right?

00:51:59.760 --> 00:52:12.000
<v Guillermo Sanchez Dionis>But something that we realized quite early together with Pedro is that, you know, actually we should flag that Tag Lake is actually better at doing these transactional workloads because it's one of the selling points, right?

00:52:12.440 --> 00:52:24.220
<v Guillermo Sanchez Dionis>And already with the Postgres setup, we were doing quite okay in transactional workloads versus, you know, TagDB also doing transactional workloads against Iceberg.

00:52:25.460 --> 00:52:32.720
<v Guillermo Sanchez Dionis>And with what Pedro implemented, server-side retrials in Quack, which could theoretically also be done in a way in Postgres.

00:52:32.920 --> 00:52:34.920
<v Guillermo Sanchez Dionis>We will see if that happens or not.

00:52:35.700 --> 00:52:46.500
<v Guillermo Sanchez Dionis>It's actually very, very powerful to the point where 200 transactions per second in a high-contention environment is almost unheard of for any other open table format.

00:52:46.770 --> 00:52:49.120
<v Guillermo Sanchez Dionis>Because these open table formats are designed for batch processing.

00:52:49.340 --> 00:52:55.240
<v Guillermo Sanchez Dionis>right? It's just you write once to a table, very large chunk of data, but they're not really

00:52:55.420 --> 00:53:01.380
<v Pedro Holanda>thought for like transactional loads or streaming data, things like that. I think the joke was that

00:53:01.630 --> 00:53:05.700
<v Pedro Holanda>if you wanted to buy something, use your Bitcoin, right? It took like 30 seconds because it could

00:53:05.750 --> 00:53:12.900
<v Pedro Holanda>only do two transactions and then iceberg was even slower than that, right? So yeah, it is a bit

00:53:12.920 --> 00:53:19.560
<v Pedro Holanda>heard of and uh just maybe to compliment uh what guillermo said it's indeed uh possible to have

00:53:19.720 --> 00:53:23.660
<v Pedro Holanda>something similar to postgres the main reason i haven't done it yet is because of course we cannot

00:53:23.730 --> 00:53:29.780
<v Pedro Holanda>do this trick of loading duck lake uh in a postgres server however we could theoretically do stored

00:53:29.920 --> 00:53:35.700
<v Pedro Holanda>procedures but i haven't done a stored procedure since college so that's why i've been uh going

00:53:35.720 --> 00:53:38.920
<v Michael Kennedy>It's really hard to do a stored procedure in a CSV.

00:53:40.920 --> 00:53:52.200
<v Michael Kennedy>No, I honestly, for all the benefits that stored procedures have, it's just, you know, in general, you have so much more flexibility if you just do SQL and all that on your own.

00:53:52.400 --> 00:53:53.500
<v Michael Kennedy>But yeah, that makes a lot of sense.

00:53:53.540 --> 00:53:57.440
<v Michael Kennedy>If you could just package it up and go, you just call this and the database handles it and process.

00:53:58.320 --> 00:53:58.500
<v Michael Kennedy>Yeah.

00:53:58.920 --> 00:54:01.820
<v Michael Kennedy>So multiple clients works locally or in the cloud.

00:54:01.900 --> 00:54:05.800
<v Michael Kennedy>I guess for the non-hosted ones,

00:54:06.280 --> 00:54:07.680
<v Michael Kennedy>what's the scenario here?

00:54:07.920 --> 00:54:10.300
<v Michael Kennedy>Like either DuckDB in process or SQLite.

00:54:10.560 --> 00:54:12.380
<v Michael Kennedy>Is this, I'm working on my machine

00:54:12.920 --> 00:54:15.480
<v Michael Kennedy>and I know that the data is out there

00:54:15.620 --> 00:54:16.860
<v Michael Kennedy>or how do I share this?

00:54:16.860 --> 00:54:17.800
<v Michael Kennedy>How do I like replicate?

00:54:17.960 --> 00:54:19.280
<v Michael Kennedy>Because you've got the S3 storage

00:54:19.440 --> 00:54:20.920
<v Michael Kennedy>with all the stuff that could be shared,

00:54:20.970 --> 00:54:24.000
<v Michael Kennedy>but then you've got the local SQL or DuckDB file.

00:54:24.380 --> 00:54:26.740
<v Guillermo Sanchez Dionis>Yeah, there's a very cool use case for this,

00:54:26.850 --> 00:54:28.260
<v Guillermo Sanchez Dionis>particularly with DuckDB in process,

00:54:29.340 --> 00:54:31.820
<v Guillermo Sanchez Dionis>which people started calling the frozen DuckLite.

00:54:32.840 --> 00:54:38.140
<v Guillermo Sanchez Dionis>and the thing is that to update a DAG Lake

00:54:38.520 --> 00:54:40.860
<v Guillermo Sanchez Dionis>backed by an in-process DAGDB catalog,

00:54:41.070 --> 00:54:44.160
<v Guillermo Sanchez Dionis>you do need to pull the DAGDB file locally, right?

00:54:44.340 --> 00:54:47.660
<v Guillermo Sanchez Dionis>You can still talk to the catalog file locally

00:54:48.160 --> 00:54:50.220
<v Guillermo Sanchez Dionis>and then do the updates there,

00:54:50.600 --> 00:54:52.660
<v Guillermo Sanchez Dionis>write your data to actually S3 directly

00:54:53.010 --> 00:54:54.760
<v Guillermo Sanchez Dionis>and then once you've done this,

00:54:55.110 --> 00:54:56.660
<v Guillermo Sanchez Dionis>for example, writing process, right?

00:54:56.820 --> 00:54:58.160
<v Guillermo Sanchez Dionis>Which let's say happens once a day,

00:54:58.330 --> 00:54:59.380
<v Guillermo Sanchez Dionis>it's like a batch workload,

00:54:59.800 --> 00:55:04.760
<v Guillermo Sanchez Dionis>Then you upload the DACDB file to S3 storage,

00:55:05.400 --> 00:55:08.640
<v Guillermo Sanchez Dionis>and then you can have any amount of read-only connections

00:55:09.500 --> 00:55:14.400
<v Guillermo Sanchez Dionis>to S3 storage backed by a DACDB file as a catalog,

00:55:14.820 --> 00:55:18.300
<v Guillermo Sanchez Dionis>which means that basically you can have a data lake almost for free, right?

00:55:18.380 --> 00:55:21.060
<v Guillermo Sanchez Dionis>Because your catalog database is just a file in S3,

00:55:21.600 --> 00:55:22.320
<v Guillermo Sanchez Dionis>which is very powerful.

00:55:22.440 --> 00:55:25.740
<v Guillermo Sanchez Dionis>So this works very well if you're doing, let's say, one update per day,

00:55:26.400 --> 00:55:27.960
<v Guillermo Sanchez Dionis>or you just batch load a bunch of data,

00:55:28.380 --> 00:55:33.460
<v Guillermo Sanchez Dionis>And then you can have an arbitrary amount of read-only connections to this frozen duck lake.

00:55:33.780 --> 00:55:34.740
<v Michael Kennedy>Yeah, this frozen duck lake.

00:55:34.840 --> 00:55:35.600
<v Michael Kennedy>That's an interesting idea.

00:55:36.180 --> 00:55:38.400
<v Michael Kennedy>That way, it just operationally is easier, right?

00:55:38.440 --> 00:55:41.140
<v Michael Kennedy>Like, just it runs overnight in the morning.

00:55:41.460 --> 00:55:42.860
<v Michael Kennedy>Download the DuckDB file.

00:55:43.240 --> 00:55:44.300
<v Michael Kennedy>Ask all the questions you want.

00:55:44.540 --> 00:55:46.940
<v Guillermo Sanchez Dionis>Yeah, I mean, it's also like the very nice thing, right?

00:55:47.040 --> 00:55:53.600
<v Guillermo Sanchez Dionis>Like, you can literally have anyone asking questions without a server catalog running, right?

00:55:53.720 --> 00:55:56.980
<v Guillermo Sanchez Dionis>So you don't need to pay for a Postgres to be running or for a Quack to be running.

00:55:57.200 --> 00:56:00.420
<v Guillermo Sanchez Dionis>You could just literally have a DuckDV file in S3 storage

00:56:00.670 --> 00:56:03.320
<v Guillermo Sanchez Dionis>and then read all of the DuckLake from your laptop.

00:56:03.740 --> 00:56:05.720
<v Michael Kennedy>Yeah, and operationally, it's so much easier.

00:56:05.990 --> 00:56:07.100
<v Michael Kennedy>Yeah, so much easier indeed.

00:56:07.440 --> 00:56:13.100
<v Michael Kennedy>So another interesting optimization, Pedro, that you wrote about is data inlining

00:56:13.580 --> 00:56:18.080
<v Michael Kennedy>instead of sending every little request all the way back to the object storage.

00:56:18.540 --> 00:56:25.200
<v Pedro Holanda>Yeah, the basic just here is, again, to try to mitigate the small file problem, right?

00:56:25.380 --> 00:56:30.280
<v Pedro Holanda>So the small file problem, again, is if you have a bunch of little insertions, you generate a bunch of little files.

00:56:30.360 --> 00:56:33.420
<v Pedro Holanda>And in Niceberg, you're also going to generate a bunch of metadata files.

00:56:33.780 --> 00:56:40.240
<v Pedro Holanda>I think it's four files per insertion, if I remember correctly, but I'm far from being a Niceberg specialist.

00:56:41.560 --> 00:56:46.960
<v Pedro Holanda>And that basically means that if you want to get the information of that one snapshot, you have to request all these files.

00:56:47.280 --> 00:56:55.900
<v Pedro Holanda>And although they're small, as you said, there's latency playing around and it just adds up and you end up paying quite a big cost on retrieving your data.

00:56:56.920 --> 00:57:00.340
<v Pedro Holanda>Duck Lake would still have that problem to a smaller scale, right?

00:57:00.870 --> 00:57:01.500
<v Pedro Holanda>Without inline.

00:57:01.500 --> 00:57:07.000
<v Pedro Holanda>So basically, you'd still have a bunch of small data files, but you would solve the catalog part.

00:57:07.360 --> 00:57:12.260
<v Pedro Holanda>So the idea here is like, well, we are using a database management system.

00:57:13.080 --> 00:57:13.920
<v Pedro Holanda>They can store tables.

00:57:14.540 --> 00:57:20.100
<v Pedro Holanda>What if we stored the same table as our data, but in our catalog,

00:57:20.620 --> 00:57:23.820
<v Pedro Holanda>and then stored the inline, and then stored the actual data

00:57:23.960 --> 00:57:26.280
<v Pedro Holanda>that would go to the file in this inline table?

00:57:26.590 --> 00:57:27.700
<v Pedro Holanda>So that's basically what it is.

00:57:27.710 --> 00:57:31.720
<v Pedro Holanda>So imagine we would have a parquet file with, like, dates and value,

00:57:32.070 --> 00:57:32.460
<v Pedro Holanda>two columns.

00:57:33.020 --> 00:57:34.880
<v Pedro Holanda>You're going to, instead of creating that parquet file,

00:57:35.070 --> 00:57:37.740
<v Pedro Holanda>you have, if you're using DuckDB as your catalog,

00:57:37.940 --> 00:57:39.300
<v Pedro Holanda>you're going to have a table in your DuckDB

00:57:39.320 --> 00:57:44.560
<v Pedro Holanda>be called something like underscore duck lake, underscore data table.

00:57:44.980 --> 00:57:48.960
<v Pedro Holanda>And then you're going to have these two columns plus some extra columns we need to actually

00:57:49.060 --> 00:57:49.540
<v Pedro Holanda>run the query.

00:57:49.660 --> 00:57:57.220
<v Pedro Holanda>So like the snapshots ID where that value was asserted, the end snapshots if that value

00:57:57.220 --> 00:58:00.440
<v Pedro Holanda>ended up being deleted while it has not been created to a fire yet.

00:58:01.100 --> 00:58:04.220
<v Pedro Holanda>And I think we have a third column, but I don't remember by heart now.

00:58:05.000 --> 00:58:06.020
<v Pedro Holanda>But that's the basic gist.

00:58:06.400 --> 00:58:09.520
<v Pedro Holanda>And then, of course, at some points, if your data grows enough,

00:58:09.840 --> 00:58:12.540
<v Pedro Holanda>so the idea here is that your insertions are kind of small, right?

00:58:12.640 --> 00:58:15.000
<v Pedro Holanda>Like 100 tuples, 10 tuples, maybe 1,000 tuples,

00:58:15.380 --> 00:58:16.600
<v Pedro Holanda>but it's not really that big.

00:58:17.120 --> 00:58:18.800
<v Pedro Holanda>And if at some point your table is too big,

00:58:18.880 --> 00:58:21.260
<v Pedro Holanda>you can just flush it to disk.

00:58:21.600 --> 00:58:23.620
<v Pedro Holanda>So you remove the data from your inline table

00:58:23.740 --> 00:58:24.840
<v Pedro Holanda>and you create the actual file.

00:58:25.080 --> 00:58:27.500
<v Pedro Holanda>And then it avoids this mid situation

00:58:27.820 --> 00:58:29.460
<v Pedro Holanda>where you have a bunch of small files.

00:58:29.900 --> 00:58:33.360
<v Pedro Holanda>And then Iceberg tries to solve this issue,

00:58:33.380 --> 00:58:35.580
<v Pedro Holanda>I think, with some streaming tools.

00:58:35.940 --> 00:58:39.240
<v Pedro Holanda>Guillermo is probably more aware of these things than me.

00:58:40.210 --> 00:58:43.180
<v Pedro Holanda>But this will again force you to have another tool.

00:58:43.350 --> 00:58:47.460
<v Pedro Holanda>I think it also gets in the way of transactionality

00:58:47.980 --> 00:58:50.200
<v Pedro Holanda>or having your snapshots per data file at least

00:58:50.300 --> 00:58:52.660
<v Pedro Holanda>because you're going to have to start batching your data

00:58:52.660 --> 00:58:53.940
<v Pedro Holanda>and try to do it in one go.

00:58:54.440 --> 00:58:56.840
<v Pedro Holanda>And with Duck Lake, you still preserve all of these.

00:58:57.920 --> 00:59:00.260
<v Pedro Holanda>And yeah, like I have some numbers in this blog post,

00:59:00.340 --> 00:59:04.220
<v Pedro Holanda>but of course we're just comparing raw Iceberg with raw Duck Lake.

00:59:04.640 --> 00:59:07.800
<v Pedro Holanda>Yeah, so the numbers is like we got basically a thousand times faster.

00:59:08.020 --> 00:59:10.020
<v Michael Kennedy>It's a little bit of a performance improvement.

00:59:10.320 --> 00:59:11.020
<v Pedro Holanda>Yes, exactly.

00:59:11.540 --> 00:59:14.020
<v Pedro Holanda>So it is like a really cool feature in my opinion.

00:59:14.360 --> 00:59:14.640
<v Michael Kennedy>It is.

00:59:14.680 --> 00:59:20.140
<v Michael Kennedy>And once you've got this data, this local database in place, you can use it for things like that, right?

00:59:20.360 --> 00:59:23.160
<v Michael Kennedy>You need the database anyway to have a consistent data lake.

00:59:24.140 --> 00:59:24.540
<v Michael Kennedy>Yes, exactly.

00:59:25.260 --> 00:59:26.200
<v Michael Kennedy>Yeah, might as well.

00:59:26.360 --> 00:59:32.660
<v Michael Kennedy>And then, I mean, when you say with open some file in Python, you get buffering.

00:59:32.900 --> 00:59:38.140
<v Michael Kennedy>not every single byte you write instantly goes to the file because that's a lot slower and it just

00:59:38.240 --> 00:59:43.840
<v Michael Kennedy>seems like a much more scaled out way which is even more important right because the latency of

00:59:44.000 --> 00:59:48.360
<v Michael Kennedy>talking to object storage far away absolutely nice all right let's we got a time for a couple more

00:59:48.500 --> 00:59:55.520
<v Michael Kennedy>things let's talk about duck lake data frame what is this i know so uh while doing that project

00:59:56.020 --> 01:00:01.119
<v Pedro Holanda>with the i had to of course set an iceberg instance to compare uh with that could be

01:00:01.220 --> 01:00:03.440
<v Pedro Holanda>I thought it was a bit frustrating, the experience.

01:00:03.520 --> 01:00:04.500
<v Pedro Holanda>It took me like a while.

01:00:05.340 --> 01:00:07.420
<v Pedro Holanda>And then I just had my clanker going over it

01:00:07.520 --> 01:00:08.780
<v Pedro Holanda>and I went to do something else.

01:00:09.160 --> 01:00:10.640
<v Pedro Holanda>And it still took my clanker like a while.

01:00:10.980 --> 01:00:11.960
<v Pedro Holanda>So I started like wondering,

01:00:12.120 --> 01:00:14.780
<v Pedro Holanda>oh, maybe it would be easier to have my clanker implemented

01:00:14.920 --> 01:00:16.320
<v Pedro Holanda>new clank implementation

01:00:16.980 --> 01:00:19.240
<v Pedro Holanda>than to actually get Iceberg to work or find Iceberg

01:00:19.600 --> 01:00:20.980
<v Pedro Holanda>on this machine of like some glue,

01:00:21.380 --> 01:00:24.480
<v Pedro Holanda>not glue, sorry, some, the Iceberg catalog,

01:00:25.280 --> 01:00:26.640
<v Pedro Holanda>I forgot the name now, working.

01:00:26.980 --> 01:00:29.640
<v Pedro Holanda>And then the whole idea of this experiment is just like,

01:00:29.860 --> 01:00:33.620
<v Pedro Holanda>This was a few months ago, so the Clanker was not as smart as it is now.

01:00:33.950 --> 01:00:36.720
<v Pedro Holanda>And I just let it go, and I just allowed it to write it.

01:00:36.920 --> 01:00:40.760
<v Pedro Holanda>And it came up with something that worked quite well.

01:00:41.100 --> 01:00:43.980
<v Pedro Holanda>I didn't really review the code, but it had nice numbers.

01:00:44.600 --> 01:00:47.380
<v Pedro Holanda>And I checked the test over, looks good enough.

01:00:48.400 --> 01:00:50.840
<v Pedro Holanda>But I also made some fun benchmarks that was like,

01:00:50.840 --> 01:00:54.940
<v Pedro Holanda>oh, what if we just change our scheme off the table a million times?

01:00:55.220 --> 01:00:57.380
<v Pedro Holanda>How much faster is this in Epsburg?

01:00:57.780 --> 01:00:58.680
<v Pedro Holanda>And I thought it was just funny.

01:00:59.040 --> 01:01:04.980
<v Guillermo Sanchez Dionis>I mean, actually, it's funny, but it's also like one of the craziest things that the DuckLake improves over Iceberg, right?

01:01:05.090 --> 01:01:09.740
<v Guillermo Sanchez Dionis>Because every time you change schema in Iceberg, you need to write files as well, right?

01:01:09.980 --> 01:01:13.700
<v Guillermo Sanchez Dionis>And I think that's also the crazy thing about DuckLake is that, well, it's not crazy, actually.

01:01:13.850 --> 01:01:14.560
<v Guillermo Sanchez Dionis>It makes a lot of sense.

01:01:14.720 --> 01:01:16.860
<v Guillermo Sanchez Dionis>But we just do basically a SQL operation.

01:01:17.340 --> 01:01:18.300
<v Guillermo Sanchez Dionis>And this is just...

01:01:18.340 --> 01:01:28.740
<v Guillermo Sanchez Dionis>So over time, like, if you have, like, all of these different operations that are, you know, like alter table commands, for example, or stuff like that, which actually are not changing data, but are growing the metadata.

01:01:28.920 --> 01:01:30.700
<v Guillermo Sanchez Dionis>that, then your read performance will

01:01:30.970 --> 01:01:31.820
<v Guillermo Sanchez Dionis>decrease because of that.

01:01:32.700 --> 01:01:34.760
<v Guillermo Sanchez Dionis>And of course, I changed it one million times.

01:01:34.830 --> 01:01:36.820
<v Guillermo Sanchez Dionis>The schema probably is not a real

01:01:37.060 --> 01:01:37.880
<v Guillermo Sanchez Dionis>case scenario, but

01:01:38.940 --> 01:01:40.400
<v Guillermo Sanchez Dionis>anyway, it's quite interesting.

01:01:40.860 --> 01:01:42.780
<v Pedro Holanda>Is this one the schema evolution rename?

01:01:42.950 --> 01:01:44.740
<v Pedro Holanda>I was just like, okay, I have no idea

01:01:44.880 --> 01:01:46.720
<v Pedro Holanda>how CloudFont is an interesting

01:01:46.960 --> 01:01:47.820
<v Pedro Holanda>metric, but okay.

01:01:49.180 --> 01:01:50.280
<v Pedro Holanda>That's a fair point, I think.

01:01:50.700 --> 01:01:52.100
<v Michael Kennedy>Yeah, what are the things we can do with it?

01:01:52.650 --> 01:01:54.780
<v Michael Kennedy>Very cool. But maybe the more interesting

01:01:55.360 --> 01:01:55.940
<v Pedro Holanda>part of this,

01:01:56.920 --> 01:01:58.880
<v Pedro Holanda>what I want to show, or at least

01:01:58.900 --> 01:02:05.320
<v Pedro Holanda>experiment myself is I do believe that compared to the iceberg open table formats, DuckLake

01:02:05.400 --> 01:02:06.380
<v Pedro Holanda>is much easier to implement.

01:02:06.640 --> 01:02:08.160
<v Pedro Holanda>That was the idea behind these experiments.

01:02:08.630 --> 01:02:12.800
<v Pedro Holanda>And since then, we've seen some people doing actual implementations.

01:02:13.180 --> 01:02:16.680
<v Pedro Holanda>There are, I think, closed source implementations from FireBot, I think.

01:02:16.790 --> 01:02:19.860
<v Pedro Holanda>But there's also the people from HotData that have done the one from DataFusion.

01:02:20.260 --> 01:02:25.600
<v Pedro Holanda>There is another implementation that's actually more official than mine from a board chat,

01:02:25.660 --> 01:02:28.400
<v Pedro Holanda>I think, that does the actual DataFrame, DuckLake.

01:02:28.780 --> 01:02:31.740
<v Pedro Holanda>So again, it was also to show that despite the name,

01:02:32.300 --> 01:02:34.540
<v Pedro Holanda>Duck Lake is not only entangled to DuckDB.

01:02:34.780 --> 01:02:35.820
<v Pedro Holanda>It's an open table format.

01:02:36.720 --> 01:02:41.200
<v Pedro Holanda>We want people to also to write their own readers and writers

01:02:41.880 --> 01:02:44.300
<v Pedro Holanda>and to use our own implementation as a reference,

01:02:44.560 --> 01:02:46.840
<v Pedro Holanda>but also our website has like the spec description.

01:02:47.280 --> 01:02:50.400
<v Pedro Holanda>So the idea of that experiment was also in line with that position.

01:02:50.680 --> 01:02:51.640
<v Michael Kennedy>Sure, that makes a lot of sense.

01:02:51.920 --> 01:02:53.500
<v Michael Kennedy>When I first saw Duck Lake,

01:02:53.640 --> 01:02:55.820
<v Michael Kennedy>oh, this is DuckDB, but for data lakes.

01:02:56.000 --> 01:02:56.540
<v Michael Kennedy>How does that work?

01:02:56.540 --> 01:02:58.040
<v Michael Kennedy>And then looking more into it,

01:02:58.120 --> 01:03:04.200
<v Michael Kennedy>realize what it was now said don't use this in production when when can you what's what's the

01:03:04.300 --> 01:03:10.880
<v Michael Kennedy>path to 1.0 ready for production all these things yeah so i'll say the main like we actually took a

01:03:11.260 --> 01:03:17.820
<v Pedro Holanda>a bunch of time uh to from duck lake 0.4 i think to 1.0 where we decided we're not gonna add any

01:03:17.860 --> 01:03:23.480
<v Pedro Holanda>new features we're just gonna focus on fixing bugs and we're only gonna do schema changes

01:03:23.500 --> 01:03:24.960
<v Pedro Holanda>if they are fixing bugs.

01:03:25.720 --> 01:03:27.920
<v Pedro Holanda>And I believe that since April,

01:03:28.380 --> 01:03:31.300
<v Pedro Holanda>it should be production ready.

01:03:31.720 --> 01:03:33.560
<v Pedro Holanda>Of course, as software is,

01:03:33.580 --> 01:03:34.320
<v Pedro Holanda>there are still issues

01:03:34.720 --> 01:03:35.940
<v Pedro Holanda>and we still have bug reports

01:03:36.140 --> 01:03:37.080
<v Pedro Holanda>and we're still fixing them.

01:03:37.480 --> 01:03:38.580
<v Pedro Holanda>And we're going to be releasing

01:03:39.440 --> 01:03:40.680
<v Pedro Holanda>Duck Lake 1.1 soon,

01:03:41.600 --> 01:03:42.900
<v Pedro Holanda>I believe most likely

01:03:43.020 --> 01:03:43.600
<v Pedro Holanda>in the month and a half

01:03:43.780 --> 01:03:44.680
<v Pedro Holanda>with Duck Lake 2.0.

01:03:44.920 --> 01:03:47.100
<v Pedro Holanda>Again, almost on the same perspective

01:03:47.500 --> 01:03:49.940
<v Pedro Holanda>that it will have some smaller features

01:03:50.280 --> 01:03:51.260
<v Pedro Holanda>or smaller optimizations,

01:03:51.460 --> 01:03:53.460
<v Pedro Holanda>but it's mostly focused also

01:03:53.480 --> 01:03:54.680
<v Pedro Holanda>on bug fixing.

01:03:55.200 --> 01:03:57.980
<v Pedro Holanda>So this is really the direction we're going now.

01:03:58.100 --> 01:04:00.220
<v Pedro Holanda>It's trying to make it more solid

01:04:00.720 --> 01:04:03.100
<v Pedro Holanda>and more compatible with Iceberg.

01:04:03.560 --> 01:04:06.540
<v Pedro Holanda>So we can also read from and export to Iceberg.

01:04:06.720 --> 01:04:09.120
<v Pedro Holanda>So in the sense of being an open table format,

01:04:09.340 --> 01:04:10.860
<v Pedro Holanda>we also don't want people to be locked in

01:04:11.030 --> 01:04:13.600
<v Pedro Holanda>in our own table formats, if that makes sense.

01:04:13.880 --> 01:04:14.020
<v Pedro Holanda>Yeah.

01:04:14.290 --> 01:04:14.440
<v Guillermo Sanchez Dionis>Yeah.

01:04:14.700 --> 01:04:16.920
<v Guillermo Sanchez Dionis>And one thing that is interesting about what Pedro said

01:04:16.990 --> 01:04:19.180
<v Guillermo Sanchez Dionis>is that because we have the specification,

01:04:19.640 --> 01:04:22.500
<v Guillermo Sanchez Dionis>but also the DAC leak implementation of DACDB, right?

01:04:22.960 --> 01:04:27.380
<v Guillermo Sanchez Dionis>I think the specification, we tried to sort of like freeze it as much as possible and

01:04:27.520 --> 01:04:31.580
<v Guillermo Sanchez Dionis>make sure that we only do like new releases of the specification if it's really necessary.

01:04:31.940 --> 01:04:36.760
<v Guillermo Sanchez Dionis>There's like a breaking change in the, yeah, in the catalog schema.

01:04:37.240 --> 01:04:42.600
<v Guillermo Sanchez Dionis>But the extension itself can have like not only back features, but also like performance

01:04:42.880 --> 01:04:43.960
<v Guillermo Sanchez Dionis>improvements, for example, right?

01:04:43.980 --> 01:04:49.040
<v Guillermo Sanchez Dionis>Like I think we've recently seen like some improvements in like the way we calculate

01:04:49.220 --> 01:04:49.640
<v Guillermo Sanchez Dionis>the statistics.

01:04:50.340 --> 01:04:51.980
<v Guillermo Sanchez Dionis>And I think there's a bunch of others.

01:04:52.900 --> 01:04:55.620
<v Guillermo Sanchez Dionis>So basically the extension can still get better, right?

01:04:55.780 --> 01:04:59.220
<v Guillermo Sanchez Dionis>Like the engine can be faster and do things better anyway.

01:04:59.700 --> 01:05:02.000
<v Guillermo Sanchez Dionis>So it doesn't mean that Duck Lake is not evolving.

01:05:02.120 --> 01:05:05.520
<v Guillermo Sanchez Dionis>I think it's like the specification evolves slower, right?

01:05:05.860 --> 01:05:07.100
<v Guillermo Sanchez Dionis>As it should be in our opinion.

01:05:07.620 --> 01:05:10.460
<v Guillermo Sanchez Dionis>And the extension can still get better and better over time.

01:05:10.740 --> 01:05:12.880
<v Michael Kennedy>Now, let me just put this out directly.

01:05:13.320 --> 01:05:15.320
<v Michael Kennedy>It sounds like maybe it is ready for production.

01:05:15.480 --> 01:05:17.700
<v Michael Kennedy>What's the readiness state of Duck Lake?

01:05:17.780 --> 01:05:32.320
<v Pedro Holanda>Yeah, so I think one of the main things we wanted to achieve for 1.0 before, besides all the bug fixing and whatnot, is that one of the main aspects when you run a data lake over a long period of time is that you get more data in it, right?

01:05:32.820 --> 01:05:36.320
<v Pedro Holanda>So we needed all the checkpointing functionality.

01:05:36.540 --> 01:05:50.120
<v Pedro Holanda>And with checkpointing is compaction, is rewriting data files by adding their deletions, is removing orphan files, it's removing old files, all these things completely ready and easy to use.

01:05:50.460 --> 01:06:05.080
<v Pedro Holanda>So I think that's also one of the main things we ended up spending a lot of time in this production readiness state to be sure that people can just run it and not be completely stationary because their data grew too much.

01:06:05.290 --> 01:06:08.000
<v Pedro Holanda>So that was also one of the main concepts behind this.

01:06:08.400 --> 01:06:09.640
<v Pedro Holanda>So it is production ready.

01:06:09.980 --> 01:06:16.860
<v Guillermo Sanchez Dionis>I mean, for sure, there's already a lot of companies that are running this openly and they even base their software on it.

01:06:16.880 --> 01:06:18.820
<v Guillermo Sanchez Dionis>I think BossHawk is a good example.

01:06:19.200 --> 01:06:20.480
<v Guillermo Sanchez Dionis>AlterTable is a good example.

01:06:20.790 --> 01:06:25.340
<v Guillermo Sanchez Dionis>I think Firebolt also reworks their story changing to use DuckLake as well.

01:06:25.500 --> 01:06:35.760
<v Guillermo Sanchez Dionis>So there's a bunch of companies that already trust DuckLake as a thing to trust your software on, which for me is the biggest testament of something working.

01:06:36.060 --> 01:06:38.820
<v Michael Kennedy>Yeah, when people just start diving into it.

01:06:38.900 --> 01:06:39.220
<v Michael Kennedy>That's right.

01:06:39.690 --> 01:06:41.040
<v Michael Kennedy>To keep the lake analogy going.

01:06:41.340 --> 01:06:41.560
<v Michael Kennedy>All right.

01:06:42.720 --> 01:06:45.960
<v Michael Kennedy>Let's wrap it up with Final Call to Action for people.

01:06:46.520 --> 01:06:48.120
<v Michael Kennedy>they want to get started with the lake,

01:06:48.920 --> 01:06:50.700
<v Michael Kennedy>you've convinced them that this is awesome,

01:06:50.830 --> 01:06:51.580
<v Michael Kennedy>they should be doing it.

01:06:51.770 --> 01:06:52.260
<v Michael Kennedy>What do you tell them?

01:06:52.500 --> 01:06:53.620
<v Pedro Holanda>I mean, if you want to get started,

01:06:54.500 --> 01:06:56.660
<v Pedro Holanda>I think the main way of doing it

01:06:57.000 --> 01:06:58.620
<v Pedro Holanda>is going to the Duck Lake website.

01:06:58.940 --> 01:06:59.780
<v Pedro Holanda>There's going to be examples.

01:07:00.070 --> 01:07:01.960
<v Pedro Holanda>I think we have a couple of tutorials as well.

01:07:02.660 --> 01:07:05.600
<v Pedro Holanda>Otherwise, the clankers are also pretty good these days

01:07:05.820 --> 01:07:06.640
<v Pedro Holanda>and it's really easy.

01:07:06.980 --> 01:07:08.320
<v Pedro Holanda>It's literally like one line

01:07:08.680 --> 01:07:10.220
<v Pedro Holanda>and you have a data lake working.

01:07:10.820 --> 01:07:13.140
<v Pedro Holanda>In one line, you can also have a Duck Lake

01:07:13.400 --> 01:07:14.280
<v Pedro Holanda>with Quok working.

01:07:15.060 --> 01:07:17.100
<v Pedro Holanda>To me, it's always a bit mind-blowing.

01:07:18.080 --> 01:07:18.980
<v Pedro Holanda>Just check the website.

01:07:19.220 --> 01:07:19.860
<v Pedro Holanda>That's the best way.

01:07:20.120 --> 01:07:21.720
<v Pedro Holanda>If you find any issues,

01:07:22.780 --> 01:07:24.600
<v Pedro Holanda>it's always super helpful to us

01:07:24.740 --> 01:07:26.440
<v Pedro Holanda>if you open an issue on a GitHub,

01:07:26.880 --> 01:07:29.540
<v Pedro Holanda>especially with very reproducible steps,

01:07:29.740 --> 01:07:32.020
<v Pedro Holanda>like full-on scripts on how to generate the data,

01:07:32.460 --> 01:07:33.740
<v Pedro Holanda>what exactly was the problem.

01:07:34.480 --> 01:07:36.320
<v Pedro Holanda>As easier as it is for us to reproduce,

01:07:36.780 --> 01:07:38.360
<v Pedro Holanda>it's easier for us to fix as well.

01:07:39.440 --> 01:07:41.040
<v Pedro Holanda>And we got people covered.

01:07:41.300 --> 01:07:42.520
<v Pedro Holanda>We go through issues.

01:07:42.660 --> 01:07:45.020
<v Pedro Holanda>We have a way of...

01:07:45.040 --> 01:07:49.340
<v Pedro Holanda>going through all of them and prioritizing them within our team as well.

01:07:49.620 --> 01:07:51.080
<v Guillermo Sanchez Dionis>Yeah, I mean, I agree with Pedro.

01:07:51.100 --> 01:07:54.780
<v Guillermo Sanchez Dionis>I think the most important thing is that you try it out for yourself, right?

01:07:54.880 --> 01:07:56.620
<v Guillermo Sanchez Dionis>And you see whether it works or not for you.

01:07:56.940 --> 01:08:01.260
<v Guillermo Sanchez Dionis>I think TagLik can work in multiple different ways, right?

01:08:01.400 --> 01:08:05.140
<v Guillermo Sanchez Dionis>Like you can see it as like your pet project to store all of your data,

01:08:05.700 --> 01:08:07.740
<v Guillermo Sanchez Dionis>which is a very comfortable way of running it.

01:08:07.780 --> 01:08:10.480
<v Guillermo Sanchez Dionis>Or it can be even the backbone of your software service, right?

01:08:10.600 --> 01:08:13.340
<v Guillermo Sanchez Dionis>Which is also where many companies are betting on.

01:08:14.120 --> 01:08:17.680
<v Guillermo Sanchez Dionis>So yeah, just try it out and let us know what you think, right?

01:08:17.819 --> 01:08:19.859
<v Guillermo Sanchez Dionis>We will be there in the public issue trackers.

01:08:20.660 --> 01:08:25.759
<v Pedro Holanda>And with DuckDB 2.0 coming, things are also going to get much faster.

01:08:26.259 --> 01:08:27.740
<v Guillermo Sanchez Dionis>Much faster, that is true.

01:08:29.299 --> 01:08:32.060
<v Pedro Holanda>We now have an async.io implemented

01:08:32.460 --> 01:08:36.339
<v Pedro Holanda>and that will make a huge difference for reading S3 files

01:08:36.759 --> 01:08:39.299
<v Pedro Holanda>because it will basically unclog your processing.

01:08:40.339 --> 01:08:43.460
<v Pedro Holanda>So yeah, I mean, I think this is one of the most exciting times

01:08:43.500 --> 01:08:45.279
<v Pedro Holanda>to be diving into Duck Lake.

01:08:45.759 --> 01:08:45.839
<v Michael Kennedy>Awesome.

01:08:46.240 --> 01:08:46.640
<v Michael Kennedy>Now, finally,

01:08:47.580 --> 01:08:48.580
<v Michael Kennedy>there's all these different ways

01:08:48.600 --> 01:08:49.480
<v Michael Kennedy>you can run it with Postgres,

01:08:49.740 --> 01:08:50.660
<v Michael Kennedy>with SQLite,

01:08:50.759 --> 01:08:51.660
<v Michael Kennedy>with DuckDB in process,

01:08:52.020 --> 01:08:52.420
<v Michael Kennedy>or Quack.

01:08:52.859 --> 01:08:53.799
<v Michael Kennedy>Do you recommend people

01:08:54.000 --> 01:08:54.720
<v Michael Kennedy>start in one of these?

01:08:55.120 --> 01:08:56.000
<v Michael Kennedy>I'd start with DuckDB.

01:08:56.440 --> 01:08:56.540
<v Michael Kennedy>Yeah.

01:08:57.140 --> 01:08:58.259
<v Guillermo Sanchez Dionis>DuckDB in process, right?

01:08:58.560 --> 01:08:59.480
<v Guillermo Sanchez Dionis>Yeah, DuckDB in process.

01:08:59.740 --> 01:09:00.200
<v Guillermo Sanchez Dionis>That's the easiest.

01:09:00.660 --> 01:09:00.819
<v Guillermo Sanchez Dionis>Okay.

01:09:00.980 --> 01:09:02.080
<v Pedro Holanda>Because with Postgres,

01:09:02.240 --> 01:09:03.560
<v Pedro Holanda>you still have to set up the server

01:09:03.980 --> 01:09:04.500
<v Pedro Holanda>because that's, of course,

01:09:04.500 --> 01:09:05.000
<v Pedro Holanda>a little bit apart.

01:09:05.339 --> 01:09:06.400
<v Pedro Holanda>If DuckDB is literally online

01:09:06.600 --> 01:09:07.279
<v Pedro Holanda>and you're ready to go.

01:09:07.620 --> 01:09:08.520
<v Michael Kennedy>Yeah, it's got all the extensions

01:09:08.880 --> 01:09:09.680
<v Michael Kennedy>and it just knows, right?

01:09:09.980 --> 01:09:10.200
<v Michael Kennedy>Exactly.

01:09:11.140 --> 01:09:11.600
<v Michael Kennedy>All right, you guys.

01:09:11.940 --> 01:09:12.660
<v Michael Kennedy>Thanks for being on the show.

01:09:13.319 --> 01:09:16.000
<v Michael Kennedy>And sharing this cool project you're working on.

01:09:16.430 --> 01:09:17.560
<v Michael Kennedy>Thank you so much for the invites.

01:09:18.319 --> 01:09:19.080
<v Guillermo Sanchez Dionis>Yeah, thanks, Micah.

01:09:19.440 --> 01:09:19.500
<v Guillermo Sanchez Dionis>Bye.

01:09:20.020 --> 01:09:22.480
<v Michael Kennedy>This has been another episode of Talk Python To Me.

01:09:22.859 --> 01:09:23.580
<v Michael Kennedy>Thank you to our sponsors.

01:09:23.810 --> 01:09:25.120
<v Michael Kennedy>Be sure to check out what they're offering.

01:09:25.270 --> 01:09:26.640
<v Michael Kennedy>It really helps support the show.

01:09:27.380 --> 01:09:28.460
<v Michael Kennedy>Thanks again to Six Feet Up,

01:09:28.589 --> 01:09:32.560
<v Michael Kennedy>the Python and AI experts you call for the hardest software problems.

01:09:33.299 --> 01:09:36.120
<v Michael Kennedy>From scaling applications to simplifying data complexity

01:09:36.560 --> 01:09:40.060
<v Michael Kennedy>and unlocking AI outcomes, they help you move forward faster.

01:09:40.640 --> 01:09:42.339
<v Michael Kennedy>See what's possible with Six Feet Up.

01:09:42.819 --> 01:09:45.859
<v Michael Kennedy>Visit talkpython.fm/six feet up.

01:09:46.600 --> 01:09:48.180
<v Michael Kennedy>And it's brought to you by us.

01:09:48.799 --> 01:09:51.900
<v Michael Kennedy>Talk Python and Python Bytes both now have MCP servers.

01:09:52.500 --> 01:09:55.440
<v Michael Kennedy>Point your AI at 10 plus years of Python episodes,

01:09:55.840 --> 01:09:57.440
<v Michael Kennedy>transcripts, and show notes free.

01:09:57.860 --> 01:10:01.640
<v Michael Kennedy>Click MCP in the nav at talkpython.fm and at Python Bytes.

01:10:02.440 --> 01:10:04.340
<v Michael Kennedy>If you or your team needs to learn Python,

01:10:04.490 --> 01:10:07.960
<v Michael Kennedy>we have over 270 hours of beginner and advanced courses

01:10:08.110 --> 01:10:11.680
<v Michael Kennedy>on topics ranging from complete beginners to async code,

01:10:11.860 --> 01:10:14.600
<v Michael Kennedy>Flask, Django, HTMX, and even LLMs.

01:10:14.920 --> 01:10:17.280
<v Michael Kennedy>Best of all, there's no subscription in sight.

01:10:17.760 --> 01:10:19.440
<v Michael Kennedy>Browse the catalog at talkpython.fm.

01:10:20.160 --> 01:10:22.080
<v Michael Kennedy>And if you're not already subscribed to the show

01:10:22.340 --> 01:10:23.500
<v Michael Kennedy>on your favorite podcast player,

01:10:24.140 --> 01:10:24.800
<v Michael Kennedy>what are you waiting for?

01:10:25.480 --> 01:10:27.220
<v Michael Kennedy>Just search for Python in your podcast player.

01:10:27.380 --> 01:10:28.200
<v Michael Kennedy>We should be right at the top.

01:10:28.640 --> 01:10:30.040
<v Michael Kennedy>If you enjoy that geeky rap song,

01:10:30.240 --> 01:10:31.500
<v Michael Kennedy>you can download the full track.

01:10:31.620 --> 01:10:33.520
<v Michael Kennedy>The link is actually in your podcast blur show notes.

01:10:34.300 --> 01:10:35.660
<v Michael Kennedy>This is your host, Michael Kennedy.

01:10:36.080 --> 01:10:37.140
<v Michael Kennedy>Thank you so much for listening.

01:10:37.340 --> 01:10:38.140
<v Michael Kennedy>I really appreciate it.

01:10:38.560 --> 01:10:39.280
<v Michael Kennedy>I'll see you next time.

01:10:50.920 --> 01:10:53.720
I'm out.