Live CEOing Ep 819: Language Design in Wolfram Language [Tabular]

To start from Carlos material out of Portugal.

Thanks. All right, well, for people joining us, we are continuing our design review of Tabular. And where are we starting out of.

Core Tabular with Cardio's material.

Okay.

Okay, just before you start, some of the things I wrote are not correct because we haven't had build since Monday.

But everything, all the examples work.

But I'll tell you what is a false claim on your build.

Okay.

Yeah.

Okay, so normally this relational database would be referring to a URL, is that correct? Or URI of some kind. This is just happens, which is local. Yeah.

Does literally any relational database object work now?

Yeah.

Or are there some nice.

I mean, I haven't tested everything, but.

Yeah, but in principle, yeah, it is.

The same stuff as.

Yeah.

So we could connect to some corporate transactional database and we could do this. Is that correct?

Yeah.

Does anybody talk to the corporate analytics team about this?

Not since the days of entities. I remember connecting to the bugs database, which is fairly transactional.

Okay, well, I mean, can we, can we know Arnode would be a good person to ask about that now? It'd be good to test this out. Okay. Can I actually run this? Yep. Do I run the initialization?

I, I, I haven't put anything I'd.

Say no, no, it, it belongs to the previous section.

Okay.

What, what's the delay here?

I think it's just your kernel was fresh. It's loading the packlet. You know, if you do it again, it should take like half a second.

Let me just check one thing. I'm just worried about.

Why is tabular blue?

Yeah, I'm, I'm. The problem is that I have my thing set to use.

E. Wait, so that's a new. Okay, that's very concerning.

Right. If somebody can remind me at the end to change it back again because I'm doing a bunch of stuff with GPUs and things for which I need to be doing that. Okay, let's try it again.

Try again.

Okay, but there's initialization, but other than that, there's, it's not like we need to have a progress monitor.

No, I mean, if you are connecting to a database that has 100 columns, then maybe. Yes, but it would be a little.

Bit complicated to get that second argument. Why is that a symbol?

Okay, so that's the thing I wrote up there. Basically, this is how experimentally Rob has set the API up so I can put everything in the databases packlet. It's set up as an app value. I cannot do anything about it. Right. Now the last argument has to be something like relational database or dataset for data set pact. So I mean it's going to change. It's not, it's just going to be removed.

Yeah, okay, fine.

Right now it's convenient.

That's because you can't drill for up up values there. Yeah. Okay, so now this, this thing that says what is the offices thing? Is that a, is that a, is that a table?

It's one of the tables. It's one of the tables.

Is this the way that we want to specify a subtable? I thought that we had a way of specifying that using relational database. No, we.

I mean in relational database if you do stuff with sub values you get properties out. It does evaluate properties of those.

But yeah, I mean it doesn't.

The data connector, whatever it's called. That one is specify the table but that's a different thing I think.

How should you specify this?

Looks like a hokey way to specify a table.

I mean, what else do you propose? I mean it could be a rule, but it feels like rule abuse.

Yeah, I do think that like this is where tabular of data connection object can kind of bridge that gap between where is the stuff and out of core. But I haven't worked that out with Carlo yet.

What's the difference between the schema offices and offices schema?

No, I mean the real full form is basically the third one. This is what it normalizes to. But I got tired of writing of typing relational databases in full every time and so I made those shortcuts. But you know, I'm not married to any of these. It's just that it was the fastest thing to type given the constraint of.

What I think that an arrow will be better. I think this list is super confusing and the fact that you can do it in both orders is just like even more confusing.

Yeah, I get, I can do that.

I mean it looks, it is slight rule abuse, but it is, you know, at least it looks vaguely like the association.

Okay. I mean once, once Rob comes back and we are freed from the constraints of what we have right now, we can think of something, you know.

Well, let's just decide what we want to do and we'll do it when we can.

Yeah, Two arguments for all I care.

Well, I don't think that's a good idea. What, what else is the second argument of tabular used for?

So far? Nothing.

Well, tabular usually use two tabular. Right?

Yeah.

I mean, what, what actually, what are the constructors for tabular that you know the that use tabular instead of two tabular.

If you just do tabular of a matrix, does it work?

I. I think you. It will pick something up for you. Like in terms of what is. I mean, for identity matrix, it's.

What the heck is that? That's a bug. Okay. This has many bugs. Okay, what's this ridiculous thing? Okay, See that?

Yep.

With somebody's. We can always use scientific notation. No, we can't. Okay, and. And that's obviously a bug there. But so to me, I think, you know, tabular of relational database arrows, you know, maybe. Okay, but what's this and what's the generalization of that?

I mean, so in general, what Rob has set up is that there is an API function that is called. Sorry, it's not an API function in the sense of API function the symbol, but it's a function I attach up values to that validates the tabular stuff and returns an association that gets stuffed into the first argument of tabular. So if you look at like the.

Input form, that's the implementation. I want to know what the functional design is. Okay. What is this supposed to be? If this was a regular. If this was like an identity matrix, is there a. An association version of this that can have that identity matrix in it?

I think so.

I think this works very much like structure arrays. So there is a symbol there which effectively changes the meaning of the whole thing. So this tabular with second argument, relational databases is saying the first argument is only about relational databases. It's not the general syntax.

I thought that the second argument is just temporary implementation.

Yeah, that wasn't supposed to be there.

Stephen, look at the input form of the identity matrix. It gets turned into a big association where it says the backend is the Wolfram kernel and the backend data is association that contains a number of things. So it gets like, you see, you see the column tables and the, sorry, tabular column and so on and so forth.

Okay, so this is not end user accessible, this stuff here.

Right.

This is like. Yeah.

One question is, is there logic for why this would be in tabular and not too tabular?

Well, the construction could be into tabular, then the output will be tabular.

Right, right. Which is how all the other constructors of tabular, as far as I know, like all the other ones that users are supposed to use, they use two tabular. I thought.

Well, I think that the point is that two tabular gives you lots of control. Tabular on its own is just. Here's a thing, you know, it's supposed to be interpreted as tabular, correct?

Yeah, well, I don't know.

The input form of one of, you know, of percent two.

It's fairly similar. You know, it says database and then it has.

The fact that it evaluates is maybe another hint that maybe it should be in two tabular. I would argue it is.

It will be also in two tabular. But in general we have. We have something that says that basically if there is an obvious conversion, you can also do it in tabular. To tabular is to specify options and stuff like that.

Oh.

I think I agree.

This feels better into tabular because tutabular requires the second.

Yeah, there is no second argument in tabular.

Right, but this second argument's fake.

Right?

Like this is just.

No, but that second argument is going to go away anyway.

Yeah, I know. We're all saying the same thing. It's a fake second argument. So the question is things that are very direct, like tabular of identity matrix, they can just work. Tabular of relational database. If it is obvious, what that should mean is okay too. But if it has multiple tables, then we can't do it that way.

It will always have multiple tables, basically.

Well, okay, in that case, we could have maybe one syntax which is, you know, relational database. Arrow, table name. And that would be a thing that can be put directly into tabular. And anything more elaborate than that has to go into two tabular.

Sounds good.

Okay, let's move on. Current box. Look, I don't want to hear about all this detail until Rob comes back from vacation.

Yeah, sure, okay. But the thing is, if I was able to design this from scratch, this would say something like, it has 10 columns and maybe under a flipper. These are the names of the columns I never care about.

Okay, fine. That's what should happen. Okay, let's move on.

Is there a reason you can't show like the first couple of rows or something like that?

Okay, so there are a few reasons. If it's transactional and it's fast changing.

It might be a lie.

Secondly, it's a remote database. It might take a couple of seconds. And, and I think we've. We've been bitten before by, you know, putting too much evaluation into the boxes. Think single entities.

Fine. So, but why don't you leave the line out? Don't say missing, not available.

Well, I can't right now. That's the only.

Okay, okay, okay. That's a detail that, that's. Okay, fine. So I. We're just defining what it should be like. We're not defining what you can do today. Okay, so we're going to leave it out or we're going to put a dash here.

I know it's not obvious to me. The. I mean, that's useful information.

How many rows? That's count of the number of rows. Right?

Right.

Yeah, but that, that always requires a query.

But that's a fast query.

Not necessarily, not always.

I've had databases where it's actually shockingly slow.

Really depends on how the database is set up, how far it is. And the other thing is that. That thing right now is a simple table, but if there's a complex filter, you might have to scan the whole table before you can see how many there are.

I'm sorry, I don't understand.

If you, for example, evaluate the. Select example just below that thing also returns the same boxes. Now, to know how many offices that have country equals to usa, depending on how the database is set up, you might have to scan a terabyte of.

Look. Okay, hold on. It's clearly useful to know the number of rows. If it turns out that it's difficult to know the number of rows, we should punt on it. But is it possible to do a query with a timeout?

So there are.

There is a.

There is a philosophical problem in doing a query with a timeout. That is, first of all, so what, what would be. What would the timeout be like? How. How long is it acceptable to wait and make boxes before we can get a result?

Half a second.

Okay. Then likely nothing will ever come out.

Of that because it takes a while.

To compile the query before you launch it. And secondly.

Well, tell me how long you need. One second. What do you need?

I think one second is if the database is local, we'll get a result most of the times, but it really depends on what's underneath because there's a.

Okay, I got it. So if we could do that and then if we can't get it, we just put a dash there, that seems fine to me.

But what.

What about the fact, like, what if.

You'Re pointing to a database where the number of rows is changing every millisecond? Like, do we want to have a lie?

I think that's fine. If you say now, it also changes every millisecond, right? Or if you say astroposition of something changes every millisecond, but it's fine. But I do think that there's some. I do think. I. I don't know. Running it with a timeout does seem kind of bad, though, because it's going to mean you run it five times and sometimes it says the number and sometimes it gives a dash and it's like that would be super weird. Yeah, honestly, I think it's better for just to not say. Well especially in this case where it's lazy.

Yeah. Could it be dynamic and come in when it knows it?

What if you're rate limited like and you like for some reason you don't want to.

You know, what if it ends up that it can't get it and it puts a dash there? It's not the worst thing in the world.

What I'm asking you is like, is.

Like imagine you are connecting to something that you're paying for some credits and like every time you perform a query there is a counter that goes down. You don't want your make boxes code to perform a query without you knowing.

Don't worry about it. If you're using the data, the query that asks you how many elements there are is not an important query.

Well actually it can be like I've seen things with like some of the these, what is it? You know, data lake things or like I think even Google BigQuery does this. But you can set it up so that you're, you're querying, you're writing SQL looking queries, but it's actually backed by, it's scanning huge amounts of just like JSON files like that.

It's actually running grep.

Yeah, it's actually running grep. So I did, I did an example on, I think it was like AWS Athena or something like that where I was just running length and it cost me like three bucks because it went through, you know, a terabyte of compressed JSON files. It took it a minute, you know, so there can be weird situations like this.

Okay, well look, if we can find it easily, we should find it. I, the only question is do we say rows and then put a dash or say undetermined or something or, or do we simply leave out that line?

I would leave it out. I mean I, I don't think, I don't think it's like we.

Okay, but if we can get it, we get it. We get it easily. We get it.

But I don't think we should give users the impression that we, we can get it because in full generality it's.

It'S the right, I mean if we can get it and It's a small SQLite database, we should put it in there because it's useful. Right? If it's some giant terabyte petabyte database stored in, you know, in grep format or something, then we don't put it in there. But if we can easily get it, if we know it's a database of a type where we can easily get it, we should get it. What?

What if we leave it out? If the database is a server, like it's remote, there's no hope anyway.

Yeah, that's fine. I think it's fine. That's fine. Okay, but I think having column names and things will be very nice. All right, let's move on. Okay, I don't need to see this detail about Rob not having this stuff yet. I mean, what is this? I don't understand. What, what are you showing me here?

So the, the thing is, you can't use normal to get the data in memory, so I'm using two cellular.

Why?

Because. Because it's not set up to have to. I can't plug into it.

Okay, but we obviously need to be able to do that.

Of course, of course.

But wait, sorry, but is normal. No, no, but hold on. But normal also should do something different, right? Because normal takes a tabular and turns it into. I forget what, you know, a list of associations.

Yep.

This is taking a tabular and returning a new tabular where the data has been imported, right?

Yes.

So I don't think normal of a tabular should ever return another tabular. It should always return a list of associations.

I agree.

Yeah, but then, then, then we need, I think we need something that has an operator form because all of this stuff really begs for slash, slash, postfix stuff like you.

Okay, hold on, hold on, hold on, hold on, hold on, hold on. Okay, Several points. First of all, you know, the, I mean, normal returns the list of associations, something which is not a tabular. Period. End of story. The issue is you need an operation that takes an out of core tabular and brings it in core. Right?

Yeah.

Okay, what about importance import takes a.

Path, not a tabular.

I'm sorry, why not to tabular?

Oh, fair enough.

Well, you mean two single argument to tabular, Jose?

Yeah, exactly. There's some sort of normalizer of 2 of tabulas.

I mean, does that normal thing there actually work right now?

Yes, it does, but I think it.

Says two in memory.

Can we apply that? Or unless it's bigger than I think it is, can we apply that to our, to our example database just to see it work?

But actually, then that makes a lot of sense with what you were saying, Jose, because. Right. It sounds like true tabular already has Stuff where based on the first argument it'll automatically pick, you know, the second argument. So it could just be if you give it a.

What is some kind of garbage here? Multiplied phone numbers. Come on guys, who's dealing with the formatting of this?

How old is your build? Because the, the multiplied phone numbers, I've seen them work properly.

Weird.

I use the same and I never saw those.

Meet multiplied phone numbers.

I mean also the fact that it can't find the template box style. There's something funky going on.

Okay, no matter.

It's the prototype build. We'll figure it out at some point.

Yep. Okay. Okay, so we just need something that brings this in memory. Do we ever need the inverse operation of pushing it out, exporting it to something? I mean we want a cloud deploy clearly for these things.

Well, I was actually going to say, I mean having export for SQLite at least seems like it would be worth having, but I think anything else becomes much more complicated because now it's like I'm launching a server that I now have to manage and all that.

OK, but export to SQLite should just work with export.

Well, you need to give the table a name at very least.

Okay, can't it infer that from the tabular?

No, because the tabular one table.

But it could be an option. It could be like an option to export. You know, it has a default table name, it's just called tabular and otherwise you get an option that says table name, arrow, boo or something.

I don't know.

Yeah.

And I'm also wondering in the case of tabular of a relational database, if there is only one table in the relational database, why not just use it? Because then that would be a round trip mechanism for that.

Oh, well, actually arguably you could also do export of an association of tabulars if you want to, you know, give many tables.

Good point. Yeah.

The only thing that's Worrying me about SQLite is that it doesn't have very.

Good.

Like it doesn't support dates, for example.

So who cares if you're exporting to that, you're exporting to that, you get what you get.

Right. That doesn't preclude. I mean, is there a better, you know, not. Right. Is there a better file based database we could format, we could use? I mean, I'm not an expert in this field, but.

Right.

If there's more richer.

No, no there isn't.

Okay. All right, so let's, let's discuss what is the mechanism to get a tabular into memory? Okay. I'm not that keen on two tabular with one argument doing it seems kind of arbitrary.

Well, two tabular one argument already takes all kinds of things and turns them into tabulars.

Right.

But it takes one argument. It does. It doesn't turn it into an operator.

Form because it's not an operator form.

It's not just be two tabular.

Oh, you're saying two tabular of a out of core.

Right.

Would turn it into an incore tabular.

I think the only thing is that breaks is it sounds like none of the other two tabular usages take a tabular in the first argument. They all take something else. And even if any did take a tabular in the first argument, it's maybe a little weird that it's looking not just at the head, but it's looking to see that it's an out of core tabular.

Well, look, here's the thing. We could just define, I think that.

We'Re going to have tabular and perhaps to tabular to set options. Let's say you want to change an option for an object, then tabular setting that option or two tabular setting that option, I think should both work.

All right, I agree. So, but, but look, two tabular with a tabular as its first argument. The canonical form of tabular could be an incor tabular. And if that first argument is an incor tabular, then it's a no op if there are no options given. Does that make sense?

Well, no.

It sounds like the problem is that if I just want to set my, you know, column names or something by. By changing some options and I use two tabular and I give it an out of core one, then. Then we're in trouble. Although maybe I can't do that.

You can't change those options for out.

Of core, but there might be other options that you can change. I don't know.

Well, are there. Can somebody answer that?

I mean, you could change the names of the columns. Like we put a shim around them. It's. It's fine. It's.

Here's the thing. Sorry, formatting. There might be formatting options.

Yeah, that won't work.

That's the reason why we tabular is.

Like, what if you want to set something to be column keys? I don't know. Some of those options might work. I think you have a good point, Christopher.

Okay. But the main point is if that's the case, if any of those options work, then we can't use the hack of saying that to tabula with the first argument. Of out of core. We'll make it in core.

No.

Yeah, unless we require that. That option thing. You can only do it with tabular and not too tabular. But it sounds like that's maybe.

I'm kind of beginning to think we might just need a function that does this. I mean, what is this? This is making it too local Tabular. Basically.

Another possibility is the second argument of normal. So normal allows you what, to normalize.

With the second argument?

Well, we haven't really properly documented it and it's.

It's kind of a hack.

It is documented. There are like 15, 20 different things.

What?

Yeah, it also doesn't have an operator form, so.

Yes, that's true.

I mean, is there a reason that two tabular with a second argument shouldn't work? I mean, may. Maybe we have an. Maybe we have some other function that does it too, but I don't see.

Why that shouldn't work. But what does the normal second argument do? Isn't that. I mean, shouldn't it be like a persistence location where you can say in memory or in the cloud or wherever else.

But can I ask you like. Oh, wait, normal of over an association which has nested associations in.

In it.

You might have to do normal more than once in order to get it to become.

Yes, but that's not our finest hour.

No, but also normal of a tabular. The thing with head tabular, like normal of an association always returns a list of rules. There might be more associations inside, but it always returns a list of rules.

My point was that normally it's not always idempotent, like you might have to run more than once.

In general, I think the problem is not idempotence. The problem is just that it's inconsistent. Like I have a tabular. One of them turns into a list of associations, the other turns into another tabular.

Yeah, I don't think normal is a good idea. I. I think let. Let's think about similar cases. I mean, local cache is the other function that tries to do. Well, it's not quite like this import is. Is a function that does this. Go ahead.

Well, I was just going to ask because you were talking about the second argument of two tabular local caches. The second argument of two tabular is a string that tells what the format of the first argument is. Is that right?

It's.

It's a control.

It.

It can give. You can give detailed commands of how, how things are done.

But what does it refer to? Does it refer to what you're getting in or what you're getting out, so to speak.

I mean, what you're getting in is what you're getting in. And then how do you want it to construct the finger generation?

Is it primarily presented as a description of what you're getting in or is it primarily a.

It's relative to what you get in, but it describes what you get out.

Okay, so then having something like two in memory or something like it, you know, would make sense.

Yes.

Why don't I have Docu tools? Is there something broken with. With this build? Should I run the Docu tools installer? Hello?

Why not?

I think there is something wrong with your version of this because I didn't see those pink boxes on the same build.

Okay.

It's examples of former. Yeah.

No, but this is completely the wrong thing. These are describing what is coming in, Roger.

Yeah, but they need to be detailed controls. It's just not done.

You need.

I understand that, but Roger, this is the wrong way around. Okay. This is. This would be, you know, something like external database or something. But the, the detail.

I mean, look, this is not in the. Nothing. None of the documentation is in particular good form right now. Can you scroll down please?

Yeah.

See, here's like details of how to do things.

I understand what's being presented here, but it's very incomplete.

Okay, but what, what's needed? Like for instance, how do you embed a time series in. In tabular? There are multiple ways of doing it. If you have a vector value time series.

Okay, so look, look, if I look at this clearly here, somebody is imagining, you know, you're trying to save a transpose basically. Right?

Yes. Yeah, you're right in that case, yes.

But the other ones here look pretty silly because the other ones have a lot of metadata already in this symbolic.

I think the point, correct me if I'm wrong, Roger, is just that right now there's only one way of doing time series. But there might be three ways of doing time series.

Yeah.

In particular, when the same time series can be interpreted in three different ways.

Yeah. Particularly when you have multi paths like temporal data and stuff. So this is, this is just poorly done right now. It's not done.

Right. I get it, I get it. But. So the only question that we have to answer here is, is the type of thing that we're doing here saying how to take. You know, it sounds to me like it is consistent with. I mean, clearly it's a separate design review to look at two tabular in the things it really has to do. But it's Somewhat consistent with that. To be taking an out of core thing and putting it in core. That's consistent with the kind of operations that that second argument is describing. Is that correct, Roger?

I think so.

Okay, so let's assume that's what's going to happen. The design isn't right yet. Recognizing that it's unfortunate. There's an operator form and we have to think about that. Okay. But let's wait until two tabular is better designed to finish that job. Makes sense to everybody.

You know, as a. To add more confusion, it might also.

Fit in from tabular, not just in two tabular.

That's almost, you know, a joke. But. Yes, I understand it is. Yeah. Okay. All right. Which kind of suggests that neither of them is the right thing. And.

Yeah.

You know, that really what, what it is, is.

Well, I was thinking. I mean, I don't know if it's going to be a more general thing. So there is, you know, the, the way Carlo's thinking out of core, it's like a fixed database that someone else provides. I was thinking about a core is. I mean, so the way we do video is like you processing. So you're generating out a core. You're, you know.

Exactly. But that, that's like. That was what I was saying about clouds and persistence locations.

Right, right. And so I think that they're a little bit.

Not all complicated because a pretty common thing might be. I've got this tabular thing. It's pretty big. I want to make it available to a group of people. I'm going to put it in the cloud. I'm going to do this or that to it. I think we don't know yet. And we should look at all the persistence locations that we're defining for anything and ask whether they make sense for tabular. Like you could.

Some kind of stratification here. It's like it's small enough. I can go in core. It's. Or even in Notebook. Like I could send it along with a notebook or maybe it fits in our cloud, but there's going to be a lot of data stores that don't even fit in our cloud.

Yeah, yeah.

Right, right.

So. So there's some levels.

Let's move on. Let's move on. I mean, we've clearly. This is a thing we have to resolve. But that's for a separate meeting. Let's keep going here. Okay, so now you're describing. This is the same syntax as standard transform columns and so on. Right?

Yeah.

And you're just saying these are things that can be supported for an out of core database?

No, they work right now. I mean, I, I, I, I don't have hooks for all of them yet. Like I can't sort by isn't quite working yet and okay, stuff like that.

That's great.

Those were, those work out of.

Okay, so what's some examples of things that don't work?

Well joins don't work. Sort doesn't work.

Okay, and what do you do when it doesn't work? What do you say when it doesn't work?

Right now there isn't even a way to do the error handling. But you know, for example, one thing you can, I mean I've inherited all the rich error handling of databases in entities and so I can even tell you things like you're trying to compare a string to an integer.

Right. Let's just keep, let's just cut through and you know, the basic point is what roughly should the message say? The message should basically say, you can't do this with an external database. You know, use whatever the thing is that localizes tabular to in core to do this, you know, to move the tabular in core if you want to do this. Makes sense.

I mean it depends because some things will not work even in core.

Why?

Because also the in core tabular is kind of strongly typed, right?

So fine. But.

Is the point that the tabular framework doesn't handle those errors itself? Like if you make a type error, it still goes. I mean this is just sort of an implementation detail, I guess.

No, yeah, but there's different types of things. There are situations where you're trying to compute a bessel K and I don't know how to do Bessel k in SQL, but you might as well do that in memory. And there are cases where that operation is always going to return something nonsensical because you're right.

Okay, so Carlo, let's just keep it. Okay. Clearly what we have to do is we would like to segregate the messages so that they are different depending on whether you would succeed if you brought it in core and you wouldn't succeed if you can do that. Great.

Yeah, I can.

Okay, then that's the answer. Okay, let's, that's great. Okay, let's go through these questions. What do you mean fully lazy?

So select yes, select that and it's the select that you can't do. Do you want the error right away when you evaluate the select Only when you don't to tabular.

Or when you index into it? Like if you say select and you reference. A column that doesn't exist would be like the easiest case.

Okay, but what does. What does the select return?

Another tabular. But it's a symbolic out of core tabular.

Right. Because the point is, if you're querying SQL, like you're not actually going to run the whole query when you return that new tabular.

Right.

It's just.

I think this should indicate that, because most tabulars that you run in core run, you know, they run immediately. They're not lazy.

So what?

I think this summary box should indicate that it hasn't yet been run.

Yeah.

Okay, so how do we do that? And that also gives us an excuse to not know how many rows it has. Because it's very weird to not know how many rows it has. If you, if we ran it.

Well, maybe. I mean, the first thing would be maybe they should have like a location field which just kind of basically tells you it's not local.

Yes.

And then. And then it could have. In addition to the location. It could have. Is the right term, like if it's a virtual table or something like that?

Yes. What is the right terminology here?

I mean, if it's. It's kind of blurred, but it can be a table that does exist on the database, or it can be a query that is made of one or more tables.

And that's not what we're asking. What we're asking is simply if somebody sees this, right? And it says, you know, look, it can say location, remote or something. But the issue is what do we say? What are the words we use to describe the fact that the query has not yet been done? Do you see what I'm saying?

Yeah, I use lazy, but I don't know.

I don't think it's like, I think.

In SQL, I think they use maybe Carl, you know, if these terms are right, but the terms that I thought were used were view and virtual table.

Yeah, but view is actually saved on the database, so this is not a view.

Oh, a view is when views were.

Okay.

I didn't realize. I thought views were usually lazy, but I don't know what I'm talking about.

They are, they are.

But you store it.

Okay.

We need to name it and save it. You don't run it, but you save it.

Right, but it doesn't.

But isn't it untickled transactions? I mean, isn't like query optimization or transaction optimization?

A transaction is a group of one or more queries that you run together.

Have we had this issue for entities?

No, because Entities are symbolic in general. So an entity class is always like lazy.

Well, maybe we use the term symbolic to represent this.

Yeah, I mean we can see it's a symbolic.

Really.

Symbolic or literal.

Or.

We, we need a term here. I mean, first of all, the first line should be instead of the message we replace implicit. Say it again.

Implicit. A symbolic is better.

And you can actually says type and it either says table or query.

I mean, we could use the nomenclature explicit. That's concrete. Data. Implicit. It's referred to data.

Yes.

Can we say something like unexecuted?

That sounds clear what that means.

Uncommitted.

Look, okay, first point is there are going to be cases where we know the number of rows, but we haven't actually done the query true or not true. Or if we know the number of rows, then knowing the number of rows.

Is actually a separate query, which is.

I understand, but I'm asking as a practical matter, if we know the number of rows, can we assume that we've done the main query or not?

No, those are two separate queries.

Well, but you might, you might have had to do most of the work of the query.

Yeah, like the select is not going to know the number of rows unless you do the select. Right.

But I think in general there can be queries that do more work. But if you only ask for the length, it'll optimize it and it won't do as much work.

Correct.

Okay, Well, okay, so hold on.

Can we call it abstract?

How about unresolved?

Not a huge fan of unresolved.

I'm thinking of some parenthetical at the top that says.

Well, what about something where you can have two. I mean like you could have it. So it's type. It's either a table or it's a query.

I think that's obscure. I think we should simply say in words because this is a sufficiently complicated concept and we're all confused about it. We should just say is a gray thing of words, you know, not yet resolved or something.

I don't think resol. Resolved, I think is really not the. But also not yet makes it sound like if I apply some function to it, I can get a resolved version.

Well, you can. If you apply normal to it, it'll resolve.

Wait, not normal. I mean, well, normal, I guess will really. It'll resolve to a list of associations.

But yeah, right. But I mean, whatever.

I can never get this object. I mean, I guess other than by calling to tabular of in memory, I, I, I will never get an object that looks like this. That's quote unquote resolved.

Right. But I'm saying that whatever that two tabular in memory thing is, which is looking more and more like it should actually be a function that resolves things like this to make an explicit tabular.

Again, I don't think resolve is really not right.

Implicit.

What about pending?

Well, except that. Yeah. Okay.

What do we call like, like parallel. What are they called? Like parallel tasks. The whole task framework, asynchronous task stuff. What do we call task? That's, that's. You haven't run parallel submit on. So it's just kind of floating.

Yeah, I think pending is used somewhat there, but I don't know, we have to look it up.

It says. Oh, no, it says ready for processing. It's what it says on it. It looks like.

Okay, Not explicitly. Something or other. Look, we need a phrase at the top that says. I'm not sure. All right, let's move on. But I think. Why don't we say. What the heck can we call this? Implicit. Delayed deferred. Yeah, it's not bad.

We could have something that says data pending evaluation or something like that. So we specify that the data is not present. Instead of saying that the query is.

Abstract.

We say data external.

Internal. Sorry.

Well, it's always external. Right? I mean, if it's on some database.

Yeah, but we could, you know, if we say data not yet evaluated and then you evaluate it, then it.

But how do you evaluate it? Somebody. The immediate question is, well, what function do I call to evaluate it? Right.

That's the thing is a lot of these sound like, oh, it's a problem. Like, before I continue, I have to fix this. And there's no function you can call that will give you a version that looks the same, except that it doesn't.

Because the thing is that those boxes that you see there, they're the same boxes you would get for an incor tabular when dynamic evaluation is off. So there is also a version of this that would show up for an incor tabular.

Well, it happens to look more or less the same. But.

But, yeah, but you could have something that says data present in memory, in notebook. In memory or not present.

Okay, so one possibility is something like data not see data not present. Sounds like an error.

Yeah, right, right.

I mean, you could say data external.

No, but again, it's, it's. It's always external, right?

It's not always external.

Well, no, like if it's coming from.

A data to the kernel.

No, but it's It's. It's. Either way, it's external to the kernel, right? I mean, if you. If it's a table on some database, you know, some postgres database that someone else is hosting, it's external to the kernel. Even if it's a kernel table, it's not a query.

Once you import it and bring it in memory, then it's internal, right?

Yeah.

I mean, the distinction here is not in. The distinction here is not whether it's in memory or out of memory, it's whether it's a table on the database or if it's a query.

No, I don't think that distinction is very meaningful here.

How about something like data not yet computed?

I like that. Or not fetched.

Actually, I think not computed is nice because it suggests that if you're going to get an error, you wouldn't have gotten it yet because it hasn't even run it.

So are we more for fully lazy or partly lazy? When do you want to see the errors.

Dan is on? Our livestream is suggesting data not available in memory, but I don't think that's what this is. Right. The query has not yet been run. It's not just that it isn't available in memory, it's that the query hasn't even been run.

Right. If I just reference some table on this database, it's also not in memory or not memory on my machine.

Do we want to say data not yet completed or query not yet computed?

I would say query because the data might be computed.

You just have to fetch it like.

Or maybe executed.

Yeah, it's better.

Yeah, it's better.

I think that's reasonable. Let's go with that for the time being. Query not yet executed.

Okay.

And. And so for partial versus fully lazy, I mean, is there a. Is there a downside to being partially lazy? Like that it'll be slower or something.

Yeah.

Or is it free?

It's fully lazy. Is like completely instantaneous partially lazy. You have to do some legwork that you can reuse later. I mean, it has some advantages in that, for example, you can show the types. If you perform a partial compilation, you can say what the types of the columns coming out are without.

Oh, right, yeah. Like if I query because tabular has a. You can ask it for the column types, right?

Yeah.

So what. What is it? Even if you. If it was fully lazy, would it. Then when you ask for the column types, would it fail or would it do a bunch of work when you ask for that?

We haven't decided yet.

I Suggest these two possibilities. Query specified but not yet executed. Query specified but not yet fully execut. Is that reasonable?

I don't know what the fooly does there, but.

Oh yeah, fine. Well then that's irrelevant.

I mean the fully might only mean something if we do the partial. Lazy.

Exactly. That's what I was doing.

But yeah, but still like the query.

In that case, it's compiled but not executed at all.

Right, so okay, fine. But then let's say query specified but not yet executed for the time being. If we hate it, then we'll. We'll simplify it. But let's start with that. Make sense?

Yeah.

And in gray and parens underneath here, I think.

Okay.

Or maybe it's at the very top. If we have to have an open down there.

I think we will have to. For the column names.

Yeah, we'll have an opener for the column names. Okay. What do we do with foreign keys?

Well, we didn't.

We didn't answer the thing before really, whether it's fully or partly lazy. Like when do we want the error messages to appear?

If you do a. I think it should appear immediately. I think it's very frustrating when error messages don't appear. I think compilation to SQL is not particularly slow. I think we should do it.

Okay.

I mean, does it. If I have a whole workflow and I run it, will it, you know, will it change the speed that the whole thing runs at to do the partial versus the fully.

No, we're gonna do memoization and so on.

Fine.

Yeah.

Then why not?

If not. Or maybe even store the partially compiled thing within the tabular expression.

Yeah, you're not expected to open the tabular expression yourself. Yeah. Okay. What do we do with foreign keys?

So I like the work we have done with entities like which. Which. Which is basically grandfather from how built in entities work. That some properties are entity valued and that lets you forget about joins for the most part because you just follow those foreign keys.

What would it actually look like? I'm not sure I understand. I mean, so in other words, you've got a database. You've got a relational database which has foreign keys in some table. Yeah. And those foreign keys would show up as entity. What would they show up as?

As tabular row. Entities are tabular row.

So wait a minute. Then in. In the database, in Table 1, what you would actually see is tabular row, blah, blah, blah.

Actually it probably. If you scroll that normal thing that you have up top, you can see some columns that are tabular row switch thing that that one there, the one with headers. Yeah, scroll right. Yep. Well, tabulars, not tabular rows. Yeah, those are probably the employees that work out of that office. So there's more than one per office.

So wait a minute, so what are you seeing here? So in other words, I have a tabular and if I want to drill further down into that, I use standard tabular accessor functions. Looks great.

But also what you can do is like if you scroll down again to that example. So that entity function applies to an entity of type customer. Each customer has a sale representative. That sale representative is employees. And then you can get the first name of the sale representative. And then you can drill even further and get the boss of the sale representative.

I understand, but what is this thing? Why is there an entity function?

Because this was the syntax we had for entities. Like do we want to do that for tabular as well? In that case it would just.

What's the name of the. I mean, in the case of entities, there's always an entity type. What is that here? Is that a table name?

Yeah.

Well, I mean, this is, look, this is diving, you know, deep into the, whatever, you know, into this is, this is submerging into, into details here. I mean this, if we can implement this easily, then we should have this. We may yet want to clean it and change some names and so on later. Yeah, I mean the first cut, if this comes for free, we should absolutely take it.

Yeah, that. That comes pretty much for free. The thing that is, that doesn't exactly come for free is the fact that entity class and tabular are like slightly different in terms of how the sub values work. So you. For, for the entity class, once here you would have to add all comma, the thing. So it's different the way you access the sub values.

I don't think we're going to want to call it entity function.

No, it's not called entity function. It's called function here. It's just a function. It's not an entity function.

Well, I don't understand. Why is it. Why do you say entity? Why does it say entity function?

Because I copied an example from the documentation. That was something that would require two joins to do. It's just. Okay, an example that I had from Marketing Page.

Okay, so I, I don't understand what you're basically saying is. I mean, the issue is you've got a tabular inside here. But is that tabular sort of sub referencing some small piece of the tabular? Or is it the whole tabular? Is it A whole tabular.

No. Okay, so employees here. See, employees is a tabular, a single tabular row. So for each customer, you have one employee who's the sales representative of that customer. So it's a one row.

Can you answer the following question? In this thing up here, are these.

Oh, that thing up there. That's. That's a. That's a. It's a select on that tabular. Because only the employees that work out of the San Francisco office in the first case.

Okay, all right. Okay. That's the answer to the question is it's a select of a tabular.

Yes.

Right. Which is basically one of these things that we've defined here. A query specified but not yet executed.

Yes.

Which would return a tabular. So there could be a. This is in fact correctly represented as a tabular, but it is not the whole tabular that represented that table in the relational database. It's a tabular that has been filtered by a query of some kind.

Yes.

What does normal do?

It has to resolve it.

No, no.

It can't resolve anything more than depth one.

Well, actually, normal of that returns data columns. An association of data columns. I think.

I don't think this is our most important thing to resolve right now. I think you should do the thing.

The point is that you can't res. Recursively resolve all those things because in. In full generality, you'll get an infinite loop.

Okay. I think we need to have examples we can actually run and so on. I think what you're doing right now with putting these tabulars here, which are selected tabulars, seems to make sense to me. I don't really understand this.

Okay. On Thursday, I'll have examples that work with that.

Okay. All right.

Actually, if you want, you can type one yourself out of that example. If you want to try it right away.

Okay, I'll try it right now. This one here.

No, no, type this construct. Construct columns. Okay. Then type tabular.

Tabular or tab.

Oh, no, tabular with a capital T. Open square bracket, List, schema, comma, customers comma, relational database. Exit the square bracket comma, sent, quotes, sentence.

What?

Like phrase. It's a phrase. I don't know. X. Whatever. Just a string. It's just going to be the name of the column. Just X in a string. Yeah, whatever goes to. And then copy that entity function above and replace the head entity function with function. Okay, now do normal. Yeah, with lowercase. No lowercase normal. That doesn't work. Yeah.

Well, I want to cuddle the crap out of this I mean, Construct columns. Okay, can we just cut all this garbage out and just let me see something simple here?

Yeah, sure. Just remove, just keep the first name.

This thing here, right?

Yeah.

By the way, those, this is why.

Variable names are worth using.

But okay, let me understand this. Okay. Okay, so this is getting applied to customers. Wait a minute, wait a minute, wait a minute, wait a minute. This is getting applied to this. So let's get that, that object there. Oh, for God's sake. How do I see this?

Normal.

Normal. Which normal?

Lowercase normal.

We're going to need a function that does this. It's not going to be a two tabular thingy, dingy.

Okay, so if you scroll to the right, there's a, there's going to be a column called employees.

Okay. What's that? What's that thing there? What's that?

Those are.

I think it's an expression.

It's an expression.

So we, we were supposed to have a list of those, of those, all those icons and we were supposed to discuss putting the icons in the top right hand corner.

Yes, but Jason a had a family emergency, so we, we post. Also postponed that.

Also, this build was built before we discussed this. So I mean, even if he didn't have a family emergency, it's physically impossible that he. Are any changes here?

Yeah, okay. All right. Okay, fine. But. So this is now a tabular row. Can I, can I get one of those out?

Does that can run normal, right? Actual normal. You want to see what it is you can do?

You can verify it with a. Wait, Steven, do one open square bracket after the normal one comma employees and you get the first.

Okay, hold on, hold on. After this thing here, percent sub 1 comma employees. Is that correct?

You gotta use some variables. This is very confusing.

Yep. Okay, now I can say ordinary normal, right?

I don't know.

No, no, no, because that's still SQL based. I hope that works. No, that's not set up yet. Sorry.

How do I get that tabular row resolved?

I don't think you can with this.

Okay, it's clear we're going to need a function that does what this normal thing does. We're not going to have it as some side door to two tabular. It's something like tabular resolve or tabular.

I mean, could we have like an incor2core, something like that that accepts more than just tabulars?

Possibly, yeah.

First, what is the operation? Is the operation that it brings it in memory or onto your computer? It brings it in memory, right?

Yes, mem.

Though there might be a version of this that brings it to a parquet cache file. Okay, I don't think it's.

This is the analog of entity value which resolves entities, right?

Yes.

No, it's a bad idea.

No, that, that, that is.

That's also a bad idea.

Memorize would be a funny name.

Refi.

How about tabular evaluate?

It's not. It's not necessarily evaluating anything. It might just be downloading something. Right. And also tabular evaluate sounds like. Yeah, no, I mean it sounds like something like that you do to make something evaluate.

Yeah. Well. Okay, how do I get this?

Okay, well, did you try the copy thing? Right. It offered you a copy. Right.

This here.

Oh, I see we got the tabular.

Yeah, I don't think any copy pasting on tabulars works on this build.

Okay, all right. Tabular row. What do we do with it.

When.

How do I get the first element of that tabular row?

You can't right now. There's no. It's not plugged in.

I'm sorry.

Okay, all right. Okay, fine.

I can't do it.

Okay, fine. So we'll look at this another time. But basically what's happening here is these are references to pieces of a tabular, pieces of another tabular. They're explicit ref. Explicit symbolic references to another tabular.

Yeah.

AKA foreign keys. And the issue is when we are doing something like this, we're taking that tabular that's there. And we're indexing like this. So if I say.

If, if we did capital normal on percent 18, would we then be able to extract the.

No, it's just not plugged in or lazy because there's an important, like, can't work. Can't work.

Sorry. But, but by the way, in this visual form, if it's not in memory, we've got to indicate that somehow.

Yeah, yeah, absolutely.

But again, how are we going to indicate it?

With the same thing as before. Query, not blah. I think it's the same thing.

Possibly. Or we could do something. We're doing this for the. For percent references. Some kind of WI fi looking icon. I could imagine using that square up there to indicate some kind of remote WI fi looking icon.

Well, on the other hand, I think I personally don't love the fact that these columns become of type expression where we know much more about them. That column is of type really dressed up for.

That's not a relevant point to what I'm saying. I'm saying there has to be a visual indication in here that this is Remote data. Can we address that particular point? But this whole thing is remote, correct?

Wait, no, that's not remote.

It is the output of normal, so it's supposed to not be.

Oh, so you're saying that never looks this way? It never shows this explicitness in the case where it's remote? No, it can't because it doesn't know enough.

Yeah, but those. But this is still partially resolved and those columns are remote.

Okay, let's. Okay, okay, we. We've. Okay, all right, we're running out of time here, so can we. Can we take a look at the other items here? Please.

Just play the comments about suggestions for tabular in memory. But yet again, I kind of like both fetch and execute over like resolve and evaluate.

Yeah, I think fetch is okay.

Fetch is okay.

Materialize isn't terrible, but it's a little.

Materialize only for Star Trek.

I like Materialize.

Ray. Ify. Fetch is very weird because I was favoring import tabular.

Just not clear. I mean it's like import string, import byte array, import tabular.

You're right.

Maybe we should look at the next section where I do import a data connection object.

Okay. Okay, let's take a look at this.

It's a bit wordy to say that essentially this should be a high level way to get connected to data that, you know, regardless of its backend implementation. So I picked good examples for a C backend service connect API and started from there.

Let's just take a look at how this works. Do I run this? For God's sake, Have we not finished with general utilities? I thought we were getting rid of everything in there.

I just liked the formatting from a pretty print function which.

Formatting of what?

If you scroll down a little bit, I use it.

We've moved the non controversial bits of it into other.

Can we try an ILD or LCC to look at all the other ones? Because clearly people are still using it. It's got useful things in it.

You know, by the way, that pretty print thing, I think the compiler uses a modified version of that now for its errors. So yes, that formatter is still used.

So let's look at bringing that in more. More at least into a wfr. Okay. In any case, be this as it may, what's happening here.

This is giving the specification for where some remote data is located. So before it was a bit more generalized and you asked for kind of a flat association where we just have some keys to get the specification for those remote objects. That's what this looks like. And Then also, you know, has the caching and authentication implemented? Everything should work here.

Well, I guess this build.

Will it actually work?

Yeah, let's try it.

Is the fact the access secret is on screen? Is that a problem?

Well, probably access secret has an uncompressed.

Yes, that makes it very sensitive.

No, that's.

Okay, well, let's.

This is dummy data. That's hardly. I made sure that this is data that isn't sensitive or. And that account doesn't have access to modify it.

Fine.

Aren't you going to pay a ton.

Of aggress when all our fans try to download it?

Okay. Import.

So that resulting tabular is in memory, right?

Yep.

So this is a new first argument for import. That is a data connection object. Yep. Is that right? So in principle, my data connection object could contain a giant GIF or something.

Yeah, it's just a reference to some data somewhere. It could be remote eventually, it could be local. It's not implemented yet.

Okay, but what I'm not being.

Though it can generally be a file, but.

Yes, it is not specific to tabular at all.

But there's no MIME type here. I mean. Or is there in the data connection object, is it giving the analog of a MIME type that allows import to know what kind of thing it's supposed to import? Sean, do you understand my question?

I need to think for a second. I. Right now it's mainly giving access to the file. I'm not caching any information about its format and whatnot, but those things seem like implementation details that would be promoted to features when it's become useful.

But the location says dot parquet. Right? Country-codes dot parquet.

Right. And data connection object always caches a file.

Okay.

Even if it's from a relational database. Yes, but. So if you have like a relational database example in the next section, it'll still cache the resulting query as a parquet file. Relational database. So the resulting query is cached as a parquet file, but the user is never exposed to that file.

So.

Because my point is that this framework, if I just stored a bunch of GIFs in a S3 bucket or something, right?

Yep. It'll already import those GIFs. It'll already work.

But didn't we. Don't we already have another mechanism for that, this external data?

So there's an external storage download, which is a procedural download the file, import the file kind of thing. This is a symbolic reference to data.

What's the relationship? Are those formats consistent?

Which format? Sorry?

External data. External storage download.

You mean like the syntax for it. Is it consistent?

Yeah.

Yes, for the most part. But this is also supposed to be a more elegant, more, you know, well, refined version.

Well, I don't care. But we've already got that other function, so we need to make sure we maintain consistency.

Rather experimental and messy.

Well, it doesn't say it's experimental.

It doesn't.

Yes, it does. In the top, right.

Oh, yes. Okay, thank you. All right.

This was kind of a hacky thing that was invented for a specific use case.

Okay. But then we've got to clean it up. If what you built here is a nice clean version, let's back port that into external storage download. And presumably external storage download should be able to take a data connection object. What's the relationship? Or. Or are we retiring external storage download because it is the set, but we've also got external storage upload and so on. Right. And I don't think we have export to a data connection object, do we?

No.

Oh, we don't really imagine that, do we?

I don't think so at this point.

Okay.

Having this work with external storage download doesn't seem completely crazy to me, but it's not something that I've looked into as in detail.

But okay. Yeah. So, so, okay, so then data connection object is a symbolic reference that is beyond a file, so to speak, beyond the uri. And it's beyond the URI for what reason? Because it has authentication. It has what? What else does it. And it is an external storage object.

Now, don't we often external storage needs a query language? I mean.

What'S external storage object? We got to look at this. Okay.

I meant to say the, the data. The way you connect to a data store, the way you locate what you want there is often in a query language.

I got it. I got it. Which external storage object doesn't really support. It just says you've got this essentially uri. Now, how do you get to it?

And this was built rather specifically for like IPFs in Amazon S3. When I was going about data connection object, I was trying to make things as general as possible.

Great. But, you know, we don't just leave functions out there to rot. You know, we're either going to update this or we're going to, you know, deprecate it or something. It doesn't just sit out there rotting.

Absolutely. The intention is to get this out, start using it, and when it's an obvious replacement, probably deprecate this. Or if there's still need for these.

Look at it more carefully because We've also got things like external storage upload. We got a whole system here around external storage, and I don't think we should just throw it away now. You know, I'm a little bit confused. Okay, so for another time, let's do an analysis of the relationship between them. Okay. I. I also think, I think that.

Julia being here for that would be a great thing. He's worked on this, actually.

Great. I think. This is not exactly ancient. This is 2020.

Again.

I think it was rapidly developed for some other purpose we used.

I remember what happened with it. It was actually hanging out for quite a few years and it finally made it into the system.

I think this was. We developed in the machine learning team.

For S3 storage, I think, among other things. Yeah. And the blockchain team for IPFs and so on. It had multiple users.

Okay.

I have to admit that I've never used it, which is a bad sign. And I also realized that in the persistence framework, I don't think we properly connected this to the persistence location framework, which is also something to worry about for data connection object. Am I making sense? Sean, you know about that, right?

Yeah, I mean, I've looked at persistent symbol and whatnot. The UX for how this thing is persistent between sessions is something that's been in the back of my mind and I haven't quite proposed anything yet, but I. I could right now, essentially, if you want to use your existing cache, you'd kind of have to like copy the resulting object and then like paste that as an input somewhere. And I can almost imagine a button similar to like store data in this notebook that kind of preserves the object or something like that. Because ideally we want this to the top of a notebook to refresh the.

Data.

At the start.

Also, the data connection could very much be an API. Let's say that you have.

I agree.

Yeah, all kinds of APIs actually, but. But Amazon Store account or something like that.

Right, but okay, look, data connection object is potentially the new URL in some sense. Just like you can import from a URL, so you can import from a data connection object. And it could be dynamic, it could be. It could be a blob of data that's already there. It could be data that has a certain MIME type, all those kinds of things.

As general as possible and intended to grow.

Yes, I do wonder about export to these things, and I think that's worth thinking through whether it's the same data connection object that, you know, let's say you have a connection to some S3 thing, you know, why not just use export to data connection object?

That seems reasonable.

Yeah.

The question is, does external storage object have a life or is it completely subsumed by data connection object? I mean, there's quite a lot there in external storage. Put external storage, get all these kinds of things. We need to understand what all of those are, make sense.

I think that more general functions in the language like just put and get, could just work on data connection object and it.

That would be nice.

Kind of cleans things up.

Yeah, I agree, I agree.

Let's just generalize this thing and make it like it's a symbolic name for something that we didn't have a name for before and ended up having to.

Build it out properly. I mean, the name we had before is external storage object, but we didn't build it out properly. Yeah. All right, well, that's to be looked at. And, and also just look at. What would it take to have a persistence location be a data connection object, I. E. The persistence location is. And I don't know whether this makes sense, a particular S3 bucket. So I'm saying just like a persistence location can be the cloud, in which case it gets a specific cloud object id. Could it be something where you are persisting on, for example, an external cloud? Do you get what I'm saying?

Yeah, I'll look into it.

Okay, so I think that makes.

I think that makes a lot of sense because the advantage of leveraging the built clouds is the scale. And there's like.

I agree.

Infinite scale.

Maybe this is a generalization of, you know, external storage object. And, you know, notice this is storing images there and so on. I mean, there's a bunch of stuff here that we need to look at. Okay, good stuff. Anything else that we need to. We need to cover?

No.

Okay.

No.

All right, talk to you all soon. Thanks a lot.

Okay.