[00:00:01]
Welcome in on the BuiltOnAir podcast.
[00:00:04]
Welcome back.
[00:00:05]
We are in season twenty three,
[00:00:07]
episode six.
[00:00:09]
Good to be with you all.
[00:00:11]
Hope you had a great week.
[00:00:12]
We’ve got the regular crew, Ali,
[00:00:15]
Kamille and myself.
[00:00:16]
Good to see you guys again.
[00:00:18]
so for today’s show we’re gonna just jump
[00:00:20]
right into it we’re gonna do a deep
[00:00:22]
dive ali’s gonna walk us through some tips
[00:00:24]
and tricks on how to maintain your base
[00:00:27]
keep it clean find anything uh that might
[00:00:32]
need updates and just general meta schema
[00:00:36]
maintenance and whatnot so i don’t think
[00:00:39]
there’s any big actually we should
[00:00:40]
announce uh that big
[00:00:45]
Hackathon,
[00:00:46]
both the one that the community is running
[00:00:49]
and then also Airtable is doing a live
[00:00:51]
one in New York.
[00:00:53]
What was the date on that?
[00:00:54]
Do you remember the date?
[00:00:56]
I will look it up.
[00:00:58]
I think March.
[00:01:03]
March.
[00:01:03]
March.
[00:01:03]
March.
[00:01:03]
March.
[00:01:04]
March.
[00:01:04]
March.
[00:01:04]
March.
[00:01:06]
March.
[00:01:09]
that one’s live in new york that one’s
[00:01:10]
got real cash money fifty thousand for the
[00:01:13]
top uh winner or maybe divide it up
[00:01:17]
it’s fifty thousand dollars for the top
[00:01:18]
winner and then another fifty thousand
[00:01:20]
dollars distributed in two thousand
[00:01:22]
increments for other like winners of they
[00:01:25]
call them bounties so um i think at
[00:01:29]
the beginning of the day um for those
[00:01:32]
who attend and want to participate they
[00:01:34]
give a prompt
[00:01:36]
And you have basically the whole day to
[00:01:39]
develop a Airtable based AI incorporated
[00:01:43]
solution.
[00:01:44]
And there might be specific prompts that
[00:01:48]
each bounty is dedicated to,
[00:01:49]
or it might just be the top so-and-so
[00:01:53]
number of contestants.
[00:01:54]
And then the very top gets fifty thousand.
[00:01:59]
Yeah.
[00:02:01]
So yeah, so that will keep you busy.
[00:02:04]
So we’ll definitely keep an eye on that,
[00:02:06]
see how that goes.
[00:02:10]
And we’ll cheer anybody on that’s gonna be
[00:02:12]
there.
[00:02:12]
I don’t plan to go to New York
[00:02:15]
for that one,
[00:02:16]
but if you’re in the area already,
[00:02:18]
that might make sense.
[00:02:20]
So try it out.
[00:02:23]
Awesome.
[00:02:24]
Ali, let me get your screen on.
[00:02:28]
There you go.
[00:02:29]
Let’s see what you’ve got.
[00:02:31]
All right,
[00:02:32]
so this is just a fun thing that
[00:02:35]
I’ve found increasingly more useful over
[00:02:38]
the years that
[00:02:41]
I keep finding more uses for.
[00:02:45]
And I’m sure people have probably heard me
[00:02:47]
talk about this and also there’s other
[00:02:50]
products out there in the marketplace such
[00:02:52]
as Kavan’s field list that basically does
[00:02:55]
exactly what this does.
[00:02:57]
This is just a script that I wrote
[00:02:59]
years and years ago that I’ve improved
[00:03:01]
upon as time has gone on.
[00:03:05]
Once you’ve got all of this set up,
[00:03:07]
no matter how you get to it,
[00:03:09]
I’m going to show you some ways that
[00:03:11]
I use this and how I help it
[00:03:14]
clean up my data,
[00:03:16]
how I use it to help clean up
[00:03:17]
my data.
[00:03:19]
So basically what I’m looking at right now
[00:03:20]
is a table of fields,
[00:03:24]
and I have a table of tables.
[00:03:28]
and i’ve got them linked together so on
[00:03:30]
my tables table i’ve got very few fields
[00:03:34]
but um and it’s such a funny way
[00:03:37]
to talk about this data just table of
[00:03:39]
tables and table of fields so things might
[00:03:42]
get a little confusing i’m going to try
[00:03:43]
and keep it all straight um but we’ve
[00:03:47]
got our table name and table id
[00:03:50]
I have a field to mark whether or
[00:03:52]
not the table has been deleted.
[00:03:55]
I have the description of the table,
[00:03:58]
which I just remembered.
[00:03:59]
I think I didn’t actually update my script
[00:04:01]
to include that, but I will.
[00:04:05]
And then I’m counting how many fields
[00:04:07]
there are,
[00:04:08]
and I also have a place to fill
[00:04:10]
in how many records are currently on that
[00:04:13]
table,
[00:04:13]
and we’ll talk more about that later.
[00:04:16]
Um,
[00:04:17]
then I’ve got just my linked fields and
[00:04:21]
I have a field that is looking at
[00:04:23]
the deleted column and saying, okay,
[00:04:26]
if that’s filled in,
[00:04:27]
what is the last modified time of that
[00:04:31]
field?
[00:04:32]
Um,
[00:04:33]
because unfortunately you can’t actually
[00:04:35]
access the create time or delete time,
[00:04:39]
obviously,
[00:04:39]
because the field would be gone.
[00:04:41]
the table would be gone of that data.
[00:04:44]
If you’re using something like Martin’s
[00:04:46]
product that he showed two weeks ago,
[00:04:49]
I believe now,
[00:04:50]
you will capture all that data because
[00:04:52]
it’s happening instantaneously.
[00:04:54]
This is like a dumbed down version of
[00:04:56]
his tool, which is amazing.
[00:05:01]
Um, then I have, whether it’s like the,
[00:05:04]
the create date and I’m labeling this
[00:05:07]
created honor before,
[00:05:08]
cuz I know when I’m running this manually,
[00:05:11]
this,
[00:05:11]
the table may have been created a week
[00:05:13]
ago, but I’m only capturing it today.
[00:05:16]
Um,
[00:05:16]
but then the magic really happens on my
[00:05:19]
fields table and here I’m getting all of
[00:05:24]
my metadata possible.
[00:05:27]
from each field and that is the field
[00:05:31]
name the type whether or not it’s valid
[00:05:35]
which that’s a hugely beneficial piece of
[00:05:37]
information we’ll talk about more the
[00:05:39]
field description more around the metadata
[00:05:44]
we have the field id whether it’s computed
[00:05:49]
the options which are going to be
[00:05:50]
different for each field type
[00:05:54]
um and then references as well so i’m
[00:05:59]
going to get more into how all of
[00:06:01]
that works in a moment but so essentially
[00:06:04]
i’m able to look at a given field
[00:06:07]
and see what other fields that field
[00:06:10]
references and then what fields are
[00:06:12]
referenced by that field um so that helps
[00:06:16]
me
[00:06:18]
look at this list and really determine the
[00:06:21]
structure of my data.
[00:06:23]
And I actually have experimented a lot
[00:06:25]
with visualizing this data and using it to
[00:06:28]
build org charts and stuff like that,
[00:06:30]
which has become really helpful when I’m
[00:06:32]
trying to document a process,
[00:06:37]
so on and so forth.
[00:06:41]
get into a little bit more of like
[00:06:43]
how I access this data and then I’ll
[00:06:46]
talk about the script and then show an
[00:06:48]
interface with some cool tools that are
[00:06:53]
based on this data.
[00:06:54]
And Dan and Kamille,
[00:06:55]
feel free to interrupt me at any time
[00:06:57]
if you have any questions or anything.
[00:07:00]
I’m gonna add a new script.
[00:07:10]
and just talk a little bit about how
[00:07:13]
to access this data um in the api
[00:07:17]
here it’s going to show you all the
[00:07:19]
different things that you can access via
[00:07:23]
one of these um so if you’re ever
[00:07:28]
curious it should be in here they don’t
[00:07:30]
they’re kind of slow to update this
[00:07:32]
reference though sometimes i don’t know if
[00:07:35]
you guys have noticed that um but
[00:07:39]
Let’s say we want to just look at,
[00:07:42]
let’s be super, super meta.
[00:07:43]
And we’re going to look at this fields
[00:07:45]
table here.
[00:07:47]
And I can zoom in a little and
[00:07:48]
make this bigger if that’s helpful.
[00:07:52]
And we’ll just say let table equal base
[00:07:55]
dot get table fields.
[00:08:00]
And then if I console log that.
[00:08:06]
These are all of the things that I
[00:08:07]
get about the table.
[00:08:09]
I get the ID, the name, the description,
[00:08:12]
the URL,
[00:08:14]
and then fields and views that are on
[00:08:17]
that table.
[00:08:19]
Once upon a time,
[00:08:20]
when I first wrote this big schema builder
[00:08:21]
script,
[00:08:22]
I included the views as an option and
[00:08:24]
had a table of views,
[00:08:25]
but I’ve since kind of ditched that ever
[00:08:27]
since interfaces are a thing.
[00:08:29]
Cause I find myself using views a lot
[00:08:31]
less, um,
[00:08:34]
I’m far less dependent on views than I
[00:08:37]
was before.
[00:08:37]
Um, people are like, uh,
[00:08:41]
if I remember correctly through the API is
[00:08:46]
only available on the enterprise.
[00:08:49]
API to get the views,
[00:08:52]
if I remember correctly.
[00:08:53]
From the web API, yeah.
[00:08:56]
And it’s still not as detailed as some
[00:08:58]
of the other things.
[00:08:59]
I’m sure Allie’s about to go through what
[00:09:01]
kind of info you get about each field.
[00:09:04]
For views,
[00:09:04]
it doesn’t tell you what the filters are
[00:09:07]
or its dependencies,
[00:09:09]
if it’s used in automations or anything
[00:09:11]
like that.
[00:09:13]
Ali showed the dependencies for fields,
[00:09:16]
like a formula can reference multiple
[00:09:18]
fields.
[00:09:19]
Views, I mean, you’re on your own.
[00:09:21]
It really is,
[00:09:22]
you got to do some hunting if you
[00:09:24]
want to figure out if a view is
[00:09:25]
important.
[00:09:27]
Exactly.
[00:09:28]
And that is something to note.
[00:09:30]
Like another thing I really,
[00:09:31]
I wish you could get the fields that
[00:09:33]
are visible on a view.
[00:09:36]
That to me is like the number one
[00:09:38]
thing that I’m interested in when I’m
[00:09:40]
looking at metadata and I can never,
[00:09:42]
you just can’t.
[00:09:44]
You can do that with the web API,
[00:09:45]
but again, that’s locked to enterprise.
[00:09:49]
I’ve used that before.
[00:09:50]
If I have to make my own query,
[00:09:52]
I’m like, just copy this view.
[00:09:55]
It doesn’t,
[00:09:57]
you can’t get the filter anywhere as far
[00:10:00]
as I’m aware.
[00:10:00]
No.
[00:10:01]
No.
[00:10:02]
Yeah.
[00:10:03]
Which is again,
[00:10:04]
kind of critical to a view.
[00:10:06]
Yeah.
[00:10:10]
Excellent.
[00:10:11]
Yeah, the fields are far more detailed,
[00:10:14]
but the views,
[00:10:16]
you really just get the ID, the name,
[00:10:18]
the type,
[00:10:19]
like whether it’s a grid or a gallery
[00:10:21]
or a calendar, and then the URL,
[00:10:23]
which again is formulaic and you really
[00:10:26]
don’t necessarily need the URL here,
[00:10:28]
but that’s fine.
[00:10:32]
Then the fields are really where things
[00:10:35]
get interesting.
[00:10:37]
So within each field,
[00:10:40]
we get the ID and the name and
[00:10:41]
description, just like every other object,
[00:10:44]
essentially.
[00:10:46]
But where things are great is within the
[00:10:49]
options,
[00:10:50]
and the options are different depending on
[00:10:52]
your field type.
[00:10:55]
But if it is a formula,
[00:10:57]
it’ll actually give you the formula,
[00:10:59]
which is awesome.
[00:11:00]
Martin showed this in his demo last week
[00:11:03]
or two weeks ago.
[00:11:06]
It shows you what the referenced field IDs
[00:11:08]
are.
[00:11:09]
So this is how I’m getting how I’m
[00:11:11]
populating that field that says what
[00:11:13]
fields are referenced.
[00:11:16]
And long ago,
[00:11:16]
before they made the change of
[00:11:21]
adding the back link for the same table
[00:11:24]
linked records.
[00:11:25]
I had the script also,
[00:11:27]
it would like fill in the reference field
[00:11:28]
and then it would have to loop back
[00:11:29]
over everything to fill in the reference.
[00:11:33]
I was really excited when the back link
[00:11:35]
became a thing because now I don’t have
[00:11:37]
to do that.
[00:11:37]
I could cut out like a whole half
[00:11:39]
of my script.
[00:11:43]
But super cool,
[00:11:44]
it shows you where your references are and
[00:11:46]
you can see here like it’s because these
[00:11:48]
are in the formula,
[00:11:49]
those two fields are in the formula.
[00:11:53]
Then it tells you the result.
[00:11:56]
In this case,
[00:11:57]
that is a single line text.
[00:12:00]
It might be a date,
[00:12:01]
it might be a number.
[00:12:05]
So that will be reflected in this result
[00:12:07]
for the formula fields.
[00:12:10]
There’s a ton of information in here and
[00:12:13]
you kind of have to like get to
[00:12:15]
know each one of these things.
[00:12:17]
But if it’s a single select,
[00:12:18]
it’ll give you their choices,
[00:12:19]
which is awesome.
[00:12:22]
So you can really,
[00:12:23]
once you’ve got all of this stuff in
[00:12:24]
here,
[00:12:27]
use this table as like a metadata search
[00:12:30]
across your base.
[00:12:32]
For example, I was helping a client to,
[00:12:35]
we’re trying to deprecate many extensions
[00:12:37]
and move it on to
[00:12:39]
fill out and we did a big search
[00:12:43]
across all the fields in their base to
[00:12:45]
see if any formulas were referencing many
[00:12:47]
extensions and found a bunch that we like
[00:12:51]
wouldn’t have been able to find with the
[00:12:53]
normal search functions because it’s
[00:12:55]
within the formula itself if that makes
[00:12:59]
sense yeah
[00:13:02]
Almost like in Excel, where you can, say,
[00:13:04]
show formula values,
[00:13:07]
and then it shows all the formula.
[00:13:09]
You could almost recreate that with this.
[00:13:12]
Exactly.
[00:13:14]
So super, super helpful.
[00:13:18]
But I’ll get into, I want to show,
[00:13:23]
actually, the interface.
[00:13:28]
So this base is
[00:13:31]
like I’ve pulled it up many times on
[00:13:34]
the podcast before but I have kind of
[00:13:36]
like my testing grounds and I have a
[00:13:38]
bunch of scripts and formulas saved in
[00:13:40]
here.
[00:13:40]
This was just one I felt comfortable being
[00:13:42]
able to share on the fly.
[00:13:44]
But you could apply this concept to any
[00:13:46]
base and I have this set up in
[00:13:48]
so many different bases across my own
[00:13:51]
workspace as well as clients.
[00:13:54]
And we have different things we’re doing
[00:13:55]
with different reason but
[00:13:58]
Essentially,
[00:14:00]
I can now use this as a search
[00:14:03]
place.
[00:14:03]
I can try and look at my tables
[00:14:05]
and decide if I need to delete fields,
[00:14:07]
if I have processes that I want to
[00:14:12]
assign fields to,
[00:14:14]
which I was actually going to show just
[00:14:16]
live how I would do that.
[00:14:19]
I could say, oh,
[00:14:20]
I want to plan on deleting this field
[00:14:24]
or mark something to research if I want.
[00:14:28]
to see if I actually need it.
[00:14:31]
So as I’m going through this,
[00:14:33]
I could be like, oh, color rollup,
[00:14:35]
that’s a weird named field.
[00:14:36]
I probably don’t need that.
[00:14:38]
And if I add needed,
[00:14:41]
I have a formula that is looking at
[00:14:43]
this field and essentially adding up a
[00:14:47]
bunch of things saying like,
[00:14:50]
are there
[00:14:52]
any references in this field does the
[00:14:55]
field have the word test in the name
[00:14:58]
etc in order to come up with a
[00:15:00]
cleanup level and i’ll actually show you
[00:15:02]
what that formula looks like after we are
[00:15:04]
done looking at this um and then i
[00:15:08]
can if i wanted to sort this by
[00:15:11]
the cleanup level and be like okay here’s
[00:15:13]
a list of all the fields that i
[00:15:14]
can now delete um or look at deleting
[00:15:21]
So how do you get it from the
[00:15:23]
table or from the base into the central
[00:15:28]
base?
[00:15:30]
Yes.
[00:15:30]
So I’m going to show that script in
[00:15:32]
a moment.
[00:15:33]
I call it my schema builder.
[00:15:37]
But the end result is kind of just
[00:15:39]
a GUI interface of your data and being
[00:15:43]
able to take notes, audit the fields,
[00:15:47]
look into things that have
[00:15:49]
references like this one will have
[00:15:52]
references because it’s a linked record
[00:15:53]
field.
[00:15:57]
And then I can click across and kind
[00:15:59]
of dive into each field and just deal
[00:16:04]
with it in that kind of way,
[00:16:05]
which I’ve found really helpful.
[00:16:08]
But in the base,
[00:16:12]
I have this huge behemoth script that I
[00:16:17]
admittedly have not optimized over the
[00:16:19]
years.
[00:16:19]
I barely have.
[00:16:21]
I’ve written it.
[00:16:22]
I wrote it years and years ago.
[00:16:24]
I’m happy to share it with everyone.
[00:16:25]
I have it on a shared interface page
[00:16:28]
that I’m happy to put in Slack.
[00:16:32]
Or we can put it in the show
[00:16:33]
notes if you want, Dan.
[00:16:35]
So I don’t take…
[00:16:37]
I’m not updating this regularly and…
[00:16:41]
It may or may not work for you,
[00:16:42]
but I use it all the time and
[00:16:44]
I find it really useful.
[00:16:47]
So some things that this does,
[00:16:49]
let me just run it to show you.
[00:16:51]
The first thing it’s asking me is what
[00:16:54]
I want to do.
[00:16:55]
So do I wanna run this to update
[00:16:57]
tables and fields, just fields,
[00:17:00]
just tables,
[00:17:01]
or do I wanna do a calculation of
[00:17:04]
my file size or my record and field
[00:17:08]
value counts?
[00:17:10]
I’m eventually going to have one that’s
[00:17:11]
like just do everything,
[00:17:13]
but I haven’t worked that in yet.
[00:17:16]
I separated out tables and fields versus
[00:17:18]
just fields or just tables in case you
[00:17:21]
have a huge base with a lot of
[00:17:22]
data.
[00:17:23]
This might take a while to run and
[00:17:26]
a while is maybe, you know,
[00:17:27]
probably five minutes,
[00:17:29]
but say in that five minutes you leave
[00:17:32]
the window and come back and it finished
[00:17:34]
updating the tables,
[00:17:36]
but you now want to rerun it and
[00:17:37]
just do the fields to save time.
[00:17:39]
You could do that.
[00:17:40]
Um, but if I say tables and fields,
[00:17:44]
it’s going to go through and it goes
[00:17:46]
through every table in the base.
[00:17:50]
And then it’s showing me what has happened
[00:17:53]
on it.
[00:17:53]
So how many fields have been created?
[00:17:56]
How many have been updated?
[00:17:58]
Um, if any have been deleted,
[00:18:01]
if I go and just like add a
[00:18:06]
test field here and run this again.
[00:18:12]
Now on my fields table,
[00:18:15]
I have one field that’s been added.
[00:18:18]
But if I delete it and run it
[00:18:21]
again, now one field’s been deleted.
[00:18:27]
And I can go be super,
[00:18:29]
super meta and go find that.
[00:18:33]
And it’s here marked as deleted,
[00:18:38]
which I found super useful.
[00:18:41]
I, from here,
[00:18:43]
have a couple clients that are,
[00:18:46]
that have like a report that gets sent
[00:18:47]
out every week that’s like,
[00:18:48]
here’s all the fields that were deleted,
[00:18:50]
here’s all the ones that were added,
[00:18:53]
that kind of thing.
[00:18:56]
The
[00:18:59]
Should I dive into the script now?
[00:19:03]
Sure.
[00:19:05]
Let’s see.
[00:19:07]
So I have started adding into this a
[00:19:11]
way to create the table and the fields
[00:19:13]
as well,
[00:19:14]
which I actually used for this base,
[00:19:16]
but it’s not in my main script yet.
[00:19:19]
found it really frustrating that you can’t
[00:19:22]
create formula fields which i guess i
[00:19:25]
understand why but um made it a little
[00:19:29]
bit difficult to finish that part up um
[00:19:33]
but essentially what we’re doing here is
[00:19:36]
it’s like the run options are what i
[00:19:39]
have picked here
[00:19:41]
So it says, all right,
[00:19:42]
I’m gonna determine what my options are,
[00:19:44]
what the user has chosen to do.
[00:19:47]
And then it goes through and it does,
[00:19:49]
depending on their choices,
[00:19:51]
one or many things.
[00:19:55]
Within each one of those things,
[00:19:57]
I have tons of different things broken
[00:20:00]
out, but it’s basically,
[00:20:06]
these are the two new things to update
[00:20:07]
file sizes.
[00:20:09]
First it goes through and loops over all
[00:20:13]
of my tables and it finds the ones
[00:20:16]
that have been deleted.
[00:20:17]
And that works by just saying, okay,
[00:20:19]
what’s my current list of table IDs and
[00:20:22]
what’s the table IDs that are on the
[00:20:24]
table.
[00:20:25]
And if any of them don’t exist in
[00:20:27]
my bases list, the current metadata,
[00:20:30]
it marks it as deleted.
[00:20:33]
And that flows through to the fields as
[00:20:34]
well.
[00:20:35]
So that all of those fields get marked
[00:20:37]
as deleted.
[00:20:40]
And then it does actually go through and
[00:20:42]
compare the objects so that it doesn’t
[00:20:48]
actually update anything if there’s no
[00:20:51]
changes.
[00:20:52]
It compares the JSON of the table object
[00:20:56]
to table object, same with fields,
[00:21:00]
to see if it needs to be updated
[00:21:02]
or not.
[00:21:06]
We can get more into specifics here,
[00:21:08]
but this is just a behemoth of a
[00:21:10]
script.
[00:21:12]
But it’s basically just doing all this
[00:21:14]
stuff.
[00:21:15]
It’s very well organized.
[00:21:18]
Thank you.
[00:21:19]
I thank Kavon for that.
[00:21:20]
She taught me how to write scripts in
[00:21:24]
a far better way than I was doing.
[00:21:27]
And it changed my script writing world.
[00:21:30]
So thank you, Kavon.
[00:21:31]
This is pre-AI.
[00:21:33]
Yes.
[00:21:39]
Absolutely.
[00:21:39]
How are you determining the file size?
[00:21:46]
Yes, that one’s a fun one.
[00:21:49]
That’s for attachments?
[00:21:51]
Yes, that’s for attachments.
[00:21:52]
So that was inspired by a client I’ve
[00:21:55]
been working on with.
[00:21:56]
They’ve got a big attachments table and
[00:21:58]
we’ve got it.
[00:21:59]
We took theirs a step further where they
[00:22:02]
have a table that’s literally every record
[00:22:05]
basically is one or more attachments.
[00:22:06]
So we are updating each of those records
[00:22:09]
to be like, this is twenty five megabytes.
[00:22:12]
This is a gigabyte like et cetera.
[00:22:15]
But in this case,
[00:22:16]
this is just doing the whole field as
[00:22:18]
a whole on a given table.
[00:22:22]
If I make this smaller,
[00:22:24]
I have this view isolating only my
[00:22:30]
attachment fields.
[00:22:33]
So only the ones that are still existing,
[00:22:35]
so they haven’t yet been deleted and they
[00:22:38]
have a type of multiple attachments.
[00:22:41]
And then this
[00:22:44]
Oh, that’s the wrong one.
[00:22:46]
Update file sizes.
[00:22:50]
Just goes through and it’s already
[00:22:52]
updated.
[00:22:53]
If I were to clear that.
[00:22:58]
It finds all of my attachment fields.
[00:23:03]
selects all of the records on that table
[00:23:05]
that have that field filled in and then
[00:23:07]
adds up the file size and fills in
[00:23:09]
the final value here.
[00:23:11]
So if you’re really curious,
[00:23:12]
you can always see in your usage,
[00:23:14]
if you go into your account page and
[00:23:16]
your usage for the workspace,
[00:23:18]
you could see for each base,
[00:23:21]
the total number of gigs that you have
[00:23:24]
in that base.
[00:23:25]
But if you want to know like what
[00:23:27]
fields are really weighing that number
[00:23:29]
down, this becomes really helpful.
[00:23:33]
And that works over here.
[00:23:39]
It’s just looping over each attachment and
[00:23:45]
saying, all right,
[00:23:45]
if it has a size property at it,
[00:23:49]
just keep adding it to the size.
[00:23:52]
Um,
[00:23:53]
and then it updates that one field record.
[00:23:58]
with the total.
[00:24:00]
So that’s been super helpful as well.
[00:24:07]
Then the next thing I found really helpful
[00:24:09]
is that record and field value counts
[00:24:12]
option.
[00:24:14]
I’m like,
[00:24:15]
if I have a huge table and I’m
[00:24:17]
really looking for things that I can
[00:24:18]
delete,
[00:24:19]
like
[00:24:21]
I want to know what’s empty,
[00:24:24]
like how many truly just empty fields do
[00:24:27]
I have that this has become really helpful
[00:24:30]
for that and what happens with it.
[00:24:34]
Actually,
[00:24:35]
I think I can run this again to
[00:24:38]
fill out the rest of this here.
[00:24:43]
We’ll just do all tables.
[00:24:45]
And I have this broken out into just
[00:24:46]
one table or all because, again,
[00:24:49]
if you have a huge base,
[00:24:50]
this part can just grind to a halt
[00:24:54]
because you have to select every record
[00:24:55]
and every field to be able to do
[00:24:58]
this.
[00:25:01]
So this is a small base.
[00:25:03]
It’ll work well.
[00:25:04]
I’m sure I could find a way to
[00:25:05]
optimize it later for bigger bases,
[00:25:09]
but I haven’t gotten that far yet.
[00:25:12]
And
[00:25:14]
Once it’s done, done, there we go.
[00:25:16]
So this all just populated with data.
[00:25:20]
And what’s happening here is on the tables
[00:25:23]
table,
[00:25:24]
I have a field for how many records
[00:25:26]
there are.
[00:25:26]
So when I run this part,
[00:25:28]
it updates this column here.
[00:25:32]
And then it goes through each field and
[00:25:34]
just puts in how many records have a
[00:25:36]
value for that field into this column.
[00:25:39]
And then I’m,
[00:25:42]
calculating the percent filled.
[00:25:44]
So based off of that number of records,
[00:25:48]
if that’s filled in,
[00:25:50]
how many records with values out of that
[00:25:52]
total are filled in.
[00:25:56]
Then all of that kind of amalgamates into
[00:26:01]
one big formula that I have here called
[00:26:07]
cleanup level.
[00:26:10]
And I wish I had a messier base
[00:26:12]
to demo this with.
[00:26:13]
I was really looking for a good one
[00:26:15]
that would be client-facing.
[00:26:18]
But let’s look at this formula.
[00:26:21]
And you could really customize this to
[00:26:23]
whatever you want, of course.
[00:26:24]
This is really just things that,
[00:26:27]
based on my own habits in a base,
[00:26:29]
but there are some things that are
[00:26:30]
universal, of course.
[00:26:33]
For example, I use…
[00:26:36]
this emoji a lot,
[00:26:37]
if I know I want to delete a
[00:26:39]
field, I might put that in the name.
[00:26:42]
That’s actually what this line is
[00:26:44]
referencing.
[00:26:45]
Or I might in that development plan column
[00:26:47]
I was talking about say,
[00:26:49]
I’m definitely gonna delete this and that
[00:26:52]
will affect my cleanup level as well.
[00:26:56]
Higher on the list.
[00:26:59]
Again, it might say,
[00:27:00]
do I need this or not?
[00:27:01]
I want that to affect my cleanup level.
[00:27:05]
This one is more universal.
[00:27:07]
If it ends in a number,
[00:27:09]
if the field ends in a number,
[00:27:11]
then it likely might be added by mistake
[00:27:15]
or you should be renaming it.
[00:27:17]
Except for in my case,
[00:27:19]
I have a lot of fields that end
[00:27:20]
in last four and I don’t want that
[00:27:23]
to affect my cleanup level because I want
[00:27:26]
that to be allowed.
[00:27:28]
So I’ve added that into the formula just
[00:27:30]
so it doesn’t trigger off that.
[00:27:33]
But for example, if I,
[00:27:35]
let’s filter this by ends in a number.
[00:27:44]
So field name, table, et cetera,
[00:27:49]
or like V one.
[00:27:51]
You might have, like,
[00:27:53]
if you have a table with multiple links
[00:27:56]
to a different table on that other table,
[00:27:58]
you might have, like, colors, colors two,
[00:28:01]
colors three, et cetera.
[00:28:04]
So this would capture all of those.
[00:28:06]
Yep.
[00:28:08]
Which I find really useful.
[00:28:11]
There’s also, in that same vein,
[00:28:16]
down here,
[00:28:20]
if i find that the field name the
[00:28:22]
field type is single line text and it
[00:28:24]
includes from like this in the field name
[00:28:29]
like it’s likely been a lookup field or
[00:28:37]
i guess it should be lowercase in that
[00:28:40]
function but yeah like this but
[00:28:51]
That would,
[00:28:52]
if I had deleted this linked field,
[00:28:54]
this would turn into a single line text
[00:28:56]
field.
[00:28:57]
No longer relevant.
[00:29:00]
So that’s what that’s trying to capture as
[00:29:02]
well.
[00:29:02]
Yeah.
[00:29:08]
Absolutely.
[00:29:09]
I’ve found it.
[00:29:10]
Is there a way to detect if the
[00:29:13]
linking went away?
[00:29:15]
You know,
[00:29:15]
if you unlink it and you got the
[00:29:17]
dingling?
[00:29:19]
Yes, I have, that is, this is valid,
[00:29:23]
is false.
[00:29:25]
That, let me show you,
[00:29:28]
let’s add a linked field to wherever and
[00:29:34]
look up from here.
[00:29:43]
You know what, I’m wondering
[00:29:46]
That formula, I think,
[00:29:47]
is set up incorrectly because this would
[00:29:50]
not be a type of single line text
[00:29:52]
after.
[00:29:53]
But regardless, let’s come.
[00:29:55]
We’ll figure this out together.
[00:29:56]
So if I delete that field for tasks
[00:30:00]
after I have a lookup from it,
[00:30:03]
that should break this field.
[00:30:05]
But it still is a type of lookup.
[00:30:09]
But that would now become no longer valid.
[00:30:16]
So if I update all of my fields
[00:30:21]
and say or is valid is false,
[00:30:28]
I have that field on this list now
[00:30:30]
as invalid.
[00:30:35]
I have another script that I sometimes run
[00:30:37]
that’s just called my broken field report
[00:30:40]
that, do I have it over here?
[00:30:43]
Let’s see.
[00:30:48]
Too many testing things in this script,
[00:30:51]
in this space.
[00:30:53]
Yeah, here.
[00:30:56]
So this just shows me very much just
[00:30:58]
plug and play.
[00:30:59]
It doesn’t update anything.
[00:31:00]
It just looks to see what’s valid and
[00:31:02]
what’s not.
[00:31:05]
So that becomes really useful to find
[00:31:07]
anything that’s broken.
[00:31:11]
What I was actually considering doing is
[00:31:16]
trying to do some creative linking to say
[00:31:20]
I could figure out what my table names
[00:31:22]
are and if I have any fields that
[00:31:24]
are named the same as a table that
[00:31:27]
are not multiple record links that should
[00:31:29]
trigger something off as well.
[00:31:33]
So you can imagine getting really creative
[00:31:36]
with all of those things trying to like
[00:31:37]
really manage your data.
[00:31:42]
I one last thing while we’re here that
[00:31:44]
I’ll touch on is this description thing.
[00:31:48]
And I really know that interfaces exist.
[00:31:50]
I wish you could update descriptions with
[00:31:53]
the automation step, but you can’t,
[00:31:55]
you can only do it in the extension.
[00:31:59]
But say you want to add field descriptions
[00:32:02]
and now you could even use AI to
[00:32:04]
do this as well and make this even
[00:32:06]
faster.
[00:32:08]
But if I’m like,
[00:32:10]
I want to just look at my list
[00:32:12]
of fields and add descriptions here and
[00:32:15]
not actually go to all the tables and
[00:32:16]
find them and right click and say edit
[00:32:18]
description and blah blah blah.
[00:32:20]
I want to just say, you know,
[00:32:22]
a new description can go here.
[00:32:25]
And I’m going to click this button.
[00:32:28]
And it opens up this script.
[00:32:32]
And it’s like,
[00:32:32]
do you want to set this to the
[00:32:34]
field description?
[00:32:35]
I say yes.
[00:32:38]
And maybe because this is broken,
[00:32:41]
it doesn’t show it.
[00:32:41]
No, there we go.
[00:32:43]
It worked.
[00:32:43]
It did update,
[00:32:44]
but it’s overwritten by the broken button.
[00:32:50]
Cool.
[00:32:50]
So that’s been really helpful too.
[00:32:53]
So that one, is that the only…
[00:32:56]
How much of this could be run through
[00:32:58]
an automation script?
[00:33:00]
Is that the only one that couldn’t?
[00:33:02]
This is the only one that could not.
[00:33:07]
Except for the building of the tables as
[00:33:08]
well.
[00:33:09]
That one couldn’t.
[00:33:10]
Yeah.
[00:33:11]
Automation scripts can’t modify schema at
[00:33:13]
all.
[00:33:14]
Mm-hmm.
[00:33:16]
But the only other thing I’ve noticed in
[00:33:18]
my,
[00:33:19]
because I have started working on
[00:33:22]
translating this extension script into an
[00:33:24]
automation.
[00:33:27]
When I first started working on it,
[00:33:28]
it was at the thirty second script limit.
[00:33:32]
So now that we’re at one hundred and
[00:33:34]
eighty, I’m like, it’ll probably work now.
[00:33:36]
That’ll be great.
[00:33:37]
But I have it broken up into multiple
[00:33:40]
steps.
[00:33:40]
But either way.
[00:33:42]
The thing I found interesting is that the
[00:33:45]
options field,
[00:33:47]
like the options data point or parameter
[00:33:51]
is different in the automation script
[00:33:54]
versus the field script or the extension.
[00:34:00]
It’s a little frustrating.
[00:34:02]
Um, like I think it’s for single selects.
[00:34:10]
If I go,
[00:34:13]
let’s just try and look at it under
[00:34:15]
here.
[00:34:18]
I don’t care what the trigger is.
[00:34:20]
I just want to run a script,
[00:34:22]
but it probably won’t.
[00:34:24]
Maybe it’ll let me.
[00:34:26]
We’ll say field equal table dot get field
[00:34:36]
deleted.
[00:34:41]
We’ll see what these options are here.
[00:34:55]
Let’s see, maybe it wasn’t,
[00:34:59]
because that looks the same to me.
[00:35:01]
Yeah, those should be the same parameters.
[00:35:04]
Mm-hmm.
[00:35:06]
I can’t remember what the field type was,
[00:35:09]
but I have run into some weird issues
[00:35:11]
around that as well as I noticed the
[00:35:14]
other day, buttons, the button field type,
[00:35:19]
such as that set description button that I
[00:35:22]
was showing earlier, this one,
[00:35:25]
the options are wacky.
[00:35:27]
It just like says no and doesn’t actually
[00:35:31]
give you the formula.
[00:35:34]
I was having a lot of trouble with
[00:35:35]
that.
[00:35:35]
So it doesn’t,
[00:35:37]
If this were referencing a formula and
[00:35:39]
like to open a URL,
[00:35:42]
I’m not able to get that with the
[00:35:43]
metadata.
[00:35:47]
Hmm.
[00:35:47]
Was really weird.
[00:35:49]
It is weird because in interfaces you
[00:35:51]
could use a button as a link.
[00:35:53]
Like it knows if that’s what the button
[00:35:56]
is supposed to do.
[00:35:57]
It knows to just pull the URL out
[00:35:59]
of it.
[00:35:59]
So the return type not being accessible is
[00:36:07]
pretty strange.
[00:36:09]
Yeah, it was very strange.
[00:36:12]
Like if I do a test button and
[00:36:16]
then let’s just say type.
[00:36:20]
This button.
[00:36:25]
And let’s run this for everything.
[00:36:29]
Seeing options now.
[00:36:32]
It just has nothing.
[00:36:36]
They didn’t hide its configuration under
[00:36:38]
some bespoke parameter, did they?
[00:36:42]
There’s a yeah, there is a URL.
[00:36:45]
Parameter, but I believe even that.
[00:36:49]
I didn’t get, let’s see.
[00:36:54]
I literally just started looking at this a
[00:36:56]
couple of days ago because it was
[00:37:01]
interesting here.
[00:37:05]
No, that’s just, it’s not the actual data.
[00:37:07]
That’s the map of what I created.
[00:37:09]
Yeah, it’s really odd.
[00:37:13]
In the API it says,
[00:37:18]
That would be button field, I guess.
[00:37:27]
Let me make this full screen.
[00:37:32]
Where’s the cell rate?
[00:37:42]
That’s not what I want here.
[00:37:45]
No, this is running from a button field.
[00:37:47]
I think I went to the right place
[00:37:51]
to begin with, I think.
[00:37:53]
Celery.
[00:37:54]
So there it says URL.
[00:38:01]
The actions a button can do include open
[00:38:04]
page designer and run a script and open
[00:38:07]
a different extension.
[00:38:09]
So it looks like if it’s a URL,
[00:38:12]
great.
[00:38:13]
If it’s not,
[00:38:16]
Well, no.
[00:38:16]
I guess it says the URL of the
[00:38:18]
extension that the button opens.
[00:38:20]
So I guess technically they’re all URLs.
[00:38:25]
And then Page Designer and certain other
[00:38:28]
ones have a specific under-the-hood coding
[00:38:32]
that knows what to do if you’ve clicked
[00:38:34]
on a button to open it up.
[00:38:38]
Exactly.
[00:38:40]
But I don’t think that even shows up
[00:38:44]
here.
[00:38:48]
See, options, no.
[00:38:49]
Like that’s not even,
[00:38:50]
like the documentation doesn’t even have
[00:38:52]
it right.
[00:38:56]
Yeah, I don’t have label or URL.
[00:38:57]
Yeah.
[00:38:57]
Airtable.
[00:38:57]
Come on now.
[00:39:04]
What are you doing?
[00:39:04]
I got really frustrated because I was
[00:39:06]
like, wait, I know this button.
[00:39:07]
It was that mini extensions example.
[00:39:09]
Like I knew the button opened a mini
[00:39:11]
extensions URL,
[00:39:12]
but it wasn’t showing up when I searched
[00:39:14]
for it in my table.
[00:39:16]
And then I was like, oh,
[00:39:17]
it’s not even in the metadata either.
[00:39:21]
So that’s definitely a potential gotcha.
[00:39:25]
Everything I should say with this comes
[00:39:27]
with a grain of salt because, A,
[00:39:29]
I’m not updating this automatically.
[00:39:30]
So the data on my interface I’m showing
[00:39:34]
the last time I updated it, right?
[00:39:36]
But it’s going to be out of date
[00:39:39]
unless you’re running it immediately
[00:39:40]
before you look at it.
[00:39:44]
This doesn’t pick up on all dependencies.
[00:39:47]
Just because I see that this has a
[00:39:50]
few references,
[00:39:51]
I can only get what I get from
[00:39:53]
the metadata in the script,
[00:39:55]
which as we just saw is not always
[00:39:57]
even accurate in itself.
[00:40:00]
So you should always look at the native
[00:40:02]
dependency checker before you delete
[00:40:04]
something,
[00:40:04]
which of course will come up if you
[00:40:06]
try to delete something that isn’t
[00:40:09]
deletable.
[00:40:11]
Unless you accidentally check the box to
[00:40:14]
mute that alert,
[00:40:15]
which I don’t recommend doing.
[00:40:18]
I only do it in the shortest interval,
[00:40:21]
I think, is an hour.
[00:40:23]
If I know I’m doing a lot of
[00:40:24]
base cleanup and I’ve already done my due
[00:40:26]
diligence, I’ll turn it off for the hour.
[00:40:29]
But I don’t foresee me ever doing it
[00:40:31]
longer than that, just in case.
[00:40:33]
Yeah, for sure.
[00:40:36]
So now I might have misfollowed the
[00:40:40]
metadata dashboard.
[00:40:42]
Is that just for a single base,
[00:40:44]
or are you collecting all of your bases
[00:40:46]
into there?
[00:40:48]
It’s just for a single base.
[00:40:49]
OK.
[00:40:49]
So it would be cool if you pushed
[00:40:54]
all the data from all your bases into
[00:40:57]
a centralized dashboard.
[00:40:59]
You could make a component that has the
[00:41:03]
table of table and table of fields and
[00:41:06]
maybe even the extension too.
[00:41:07]
I don’t know.
[00:41:10]
So that everything is nice and uniform and
[00:41:12]
then sync all of those down into one
[00:41:14]
source, assuming it’s fewer than twenty.
[00:41:17]
I don’t think extensions go into a managed
[00:41:20]
component.
[00:41:21]
Well,
[00:41:22]
here’s to hoping that you can convert it
[00:41:23]
into an automation script then.
[00:41:25]
Yeah.
[00:41:27]
Yeah, if you did the pushing,
[00:41:29]
you could do all through automations.
[00:41:31]
That is a good idea.
[00:41:34]
Absolutely.
[00:41:36]
Yeah, that would be really interesting.
[00:41:40]
One thing I’ve found frustrating that that
[00:41:44]
makes me think of is that there’s nothing
[00:41:46]
in the field metadata or the table
[00:41:48]
metadata to indicate whether it’s synced
[00:41:51]
or not, which is frustrating.
[00:41:56]
That’s a pretty big weakness.
[00:41:58]
I think in all of their APIs is
[00:42:00]
it is very important to know if a
[00:42:04]
table is synced from somewhere or is
[00:42:07]
syncing to somewhere.
[00:42:09]
And you, again,
[00:42:10]
you gotta go hunting if you want that
[00:42:12]
information.
[00:42:13]
And that’s a pretty big dependency.
[00:42:15]
That’s just very difficult to understand
[00:42:19]
without really looking through it.
[00:42:22]
Yeah.
[00:42:24]
yeah the way i think i mentioned this
[00:42:26]
on the other one is except you couldn’t
[00:42:30]
create a field automatically but if you
[00:42:34]
create a source field then it would tell
[00:42:38]
you where the source came from yeah so
[00:42:41]
if you try you could like do try
[00:42:43]
to create a source field on every table
[00:42:46]
and only the ones that are synced would
[00:42:48]
allow it i would guess um and then
[00:42:51]
But I don’t think you can create it
[00:42:53]
automatically because it’s a computed
[00:42:56]
field.
[00:42:57]
I think if you add a second source
[00:43:02]
to a synced table and then get rid
[00:43:04]
of it,
[00:43:04]
you’ll have the synced source field will
[00:43:09]
appear on its own.
[00:43:10]
Or you could do add a button field
[00:43:13]
where the action is open original record.
[00:43:17]
Yeah.
[00:43:19]
is, again,
[00:43:20]
I don’t think you could do it
[00:43:21]
automatically,
[00:43:21]
but that’s the more straightforward thing.
[00:43:24]
And it’s nice that the button is grayed
[00:43:28]
out if the sync source was disappeared or
[00:43:33]
if just that record was deleted or
[00:43:35]
filtered out so you know it doesn’t exist
[00:43:36]
anymore.
[00:43:38]
But yeah, otherwise,
[00:43:40]
it’s kind of rough going to really get
[00:43:44]
that difference.
[00:43:46]
Yep, for sure.
[00:43:51]
Yeah.
[00:43:51]
Yeah.
[00:43:51]
Very cool.
[00:43:52]
No, this is super powerful.
[00:43:55]
It’s actually, uh,
[00:43:59]
I might share something with you guys
[00:44:01]
offline on stuff I’m working on, but, uh,
[00:44:05]
Yeah, so this is cool.
[00:44:07]
This is definitely useful if you’ve got a
[00:44:09]
base of any size and trying to stay
[00:44:14]
on top of it,
[00:44:14]
especially if you’ve got multiple cooks in
[00:44:16]
the kitchen dealing with it.
[00:44:21]
It would be nice to know who last
[00:44:23]
modified the field schema.
[00:44:25]
Once again,
[00:44:26]
not available in the API for reasons
[00:44:28]
unknown.
[00:44:29]
But that was the one feature that is
[00:44:31]
available in the webhook API.
[00:44:34]
And that’s the one thing about the webhook
[00:44:37]
API, yeah.
[00:44:39]
One of these days,
[00:44:39]
we’ll have a consistent sort of,
[00:44:44]
if it’s available and there is an API
[00:44:47]
for it, it’s available in all those APIs.
[00:44:50]
That’s where I would love to see us
[00:44:52]
going.
[00:44:54]
But, yeah, Ali,
[00:44:56]
earlier you touched on a pain point of,
[00:44:59]
like,
[00:45:00]
if you have two tables that link back
[00:45:03]
and forth between each other several
[00:45:04]
times, colors one, two, three, four, five,
[00:45:09]
like, undescriptive names.
[00:45:11]
Or…
[00:45:12]
For me,
[00:45:13]
I had an instance where I just had
[00:45:14]
one link field between two tables and
[00:45:18]
several lookups from that linked
[00:45:20]
relationship.
[00:45:21]
And they all come in with from whatever
[00:45:24]
the table name is by default is the
[00:45:26]
naming convention.
[00:45:27]
Going back and renaming them, not easy.
[00:45:31]
Sneak peek into my thing next week.
[00:45:34]
i built a script that helps you um
[00:45:37]
quickly rename those but starting with
[00:45:39]
this you’d be able to see that pattern
[00:45:41]
of like oh i have all of these
[00:45:43]
fields that probably could use some
[00:45:45]
cleanup absolutely that’s exactly right
[00:45:49]
and the i actually ran into some issues
[00:45:52]
around that with the i was updating my
[00:45:55]
schema thing
[00:45:58]
last night to try and update create that
[00:46:00]
backlink on the table and then go and
[00:46:02]
change the name from the from field colon
[00:46:06]
etc and it was weird it wouldn’t access
[00:46:09]
it like it wouldn’t it just kept saying
[00:46:12]
that field doesn’t exist even though it
[00:46:13]
was just created and i was using the
[00:46:15]
same id it was really weird but uh
[00:46:19]
yeah i would love to
[00:46:22]
look at that more later, but the.
[00:46:23]
One question I had going back to our
[00:46:26]
sync,
[00:46:27]
if you have a synced table coming in
[00:46:31]
and like a text field is not editable
[00:46:34]
because it’s synced and it’s not
[00:46:35]
configured for editable,
[00:46:37]
would the is computed be true or false?
[00:46:42]
false it’ll still be false because it’s a
[00:46:45]
single text i think it’s a field
[00:46:49]
permission under the hood that’s
[00:46:51]
preventing you from editing and the only
[00:46:54]
person who’s allowed to edit is table sync
[00:46:57]
versus literally nothing can change it
[00:47:01]
which is where calculated is and the field
[00:47:04]
permissions don’t come through in the no
[00:47:07]
options or anything
[00:47:09]
Right.
[00:47:10]
Now, once again,
[00:47:11]
I would love to be able to see
[00:47:13]
the user IDs or group IDs that have
[00:47:16]
the ability to edit a field or to
[00:47:21]
add or delete records in a table,
[00:47:23]
table permissions, inaccessible.
[00:47:25]
Yeah, it’s so frustrating.
[00:47:31]
this last thing i was just showing is
[00:47:34]
something i have set up in other bases
[00:47:36]
as well where if i have like groups
[00:47:38]
of fields i want to you know assign
[00:47:41]
to a process and i would probably do
[00:47:43]
this as a table of processes but just
[00:47:46]
for you know sake of time um it’s
[00:47:49]
really cool if you set it up to
[00:47:51]
be like all right anything i mark as
[00:47:53]
as this process or anything that is
[00:47:56]
referencing it that
[00:47:59]
like I look up this field based on
[00:48:01]
the referenced fields,
[00:48:03]
or reference by fields, excuse me.
[00:48:05]
Things get so confusing.
[00:48:06]
But what’s cool is like if I start
[00:48:08]
adding more to that,
[00:48:10]
more things should show up.
[00:48:14]
Of course,
[00:48:15]
this is not the right choice because
[00:48:18]
that’s where this tree ends.
[00:48:21]
But basically, if I clear them all out,
[00:48:29]
Where do I know has a ton of
[00:48:32]
stuff be like the table ID.
[00:48:42]
Like if I just mark that one field,
[00:48:47]
OK, bad example.
[00:48:48]
But basically, yeah, it’s really helpful.
[00:48:51]
It’ll be like, oh,
[00:48:53]
that I sometimes I have it look up
[00:48:55]
like over and over and over again so
[00:48:57]
I can get the entire tree of like
[00:49:00]
just this one field and where it’s
[00:49:01]
referenced.
[00:49:04]
It can be really interesting to like see
[00:49:06]
your data in that way.
[00:49:10]
Cool.
[00:49:11]
Awesome.
[00:49:13]
Thank you for sharing, Allie.
[00:49:14]
Very good stuff.
[00:49:16]
And thank you all for joining in.
[00:49:18]
And we will see you next week.
[00:49:20]
Have a good week.