DAVID EAST: This is a delicate sentence right here.
Querying function-- eh.
Oh, my god.
(LAUGHING)
Hey, everyone.
Welcome to the third lesson in the Firebase Database
for SQL Developers series.
And in this lesson, I'm going to teach you
all about the basics of querying in the real-time database.
But before I begin, I'm going to be upfront with you.
If you're coming from a SQL database,
you're going to notice a drop off
in querying functionality in NoSQL databases,
like the Firebase database.
So when you're building an application that's
backed by a SQL database, to get data
from the database to the view, you're
going to write a query that joins data
from all these different tables, puts it into a subset of data,
and then puts that right back to the view.
Now, when you're building an application that's
backed by a NoSQL database, you tend
to structure your data after your views.
So all you have to do is simply go read the data,
and it has all of the needed parts already available,
organized in the database.
You take that, and you put it right back into the view.
So even if there isn't as much powerful
as querying in NoSQL databases, you
tend to not need it because you can just
structure your data properly.
But still, it's really important to know how to query.
So let's dive into the laptop and learn
the basics of querying in the real-time database.
So in SQL, the basics of querying involves two steps.
First you select columns from your table,
and then second, you restrict using the WHERE clause.
In the Firebase database, the basics of querying also
follows two steps.
First you create a reference to the parent key,
and then second, you use an ordering function.
And then optionally, you can also
use a query function for more advanced restricting.
This example query retrieves the first 10 events.
The ordering function is order by key.
And the querying function is when limitToFirst.
And there are actually four different ordering functions
that you can use.
The first is orderByKey.
Using orderByKey allows you to query based upon the child
keys which are always string based.
And you've seen in the previous videos
that these child keys are similar to primary keys in SQL
databases.
And you would use orderByKey if you're doing any limiting
or if you're doing some basic paging.
The second is orderByChild.
And this is usually what you want.
This is very similar to using a WHERE clause.
By saying orderByChild, you can specify a child property,
like name or age, and then you can
query based upon those values.
So you can actually say something
like, orderByChild name and then dot equal to whatever name
you're looking for.
Then there's orderByValue, where all the children
are ordered by their values.
And this works really well if you're
dealing with numeric values and you
need them to be ordered by their numeric value.
And lastly, there is orderByPriority.
And I'm not going to get into this because this is sort
of the old way of doing things.
So anything that you can achieve with orderByPriority,
you should really be doing with orderByChild.
Now, once you've picked your ordering function,
you're able to use one of the more advanced querying
functions to further restrict your data.
And the querying functions you can use
are startAt, endAt, equalTo, limitToFirst, and limitToLast.
StartAt and endAt is how you create a range query.
You can start at a value or a key
and then move until you hit this ending value.
EqualTo is like your WHERE clause.
You can order by a child of name then say dot equal to,
and it's the name you're looking for.
LimitToFirst and limitToLast is how you limiting.
So limitToFirst would be like saying
select these top 10 rows.
And limitToLast would be like saying select these bottom 10
or whatever number you need rows.
And the great thing about these querying functions
is that you can use them all in combination with one another.
This SQL query right here will return the first event
whose name is Firebase Meetup.
So let's take a look at how you would do this with the Firebase
database.
First we get the database object.
And then we're going to create a reference to the parent
key which is events.
And it's at this point that we can begin our query.
So to begin our query, we're going
to orderByChild and specify the name property, then make sure
that we're using the equalTo querying function,
and say the name is equal to Firebase Meetup.
And then lastly, we will say limitToFirst and specify one
so we get the first event that comes back.
So basically, getting the events reference
is like your select statement.
And then ordering by child and saying equal to
is like your WHERE statement.
And then the limit is like your limitToFirst method.
So that's the basics of querying in the Firebase database.
If you like this video, make sure to like and subscribe
so you can stay up to date with all of our content
and make sure you stay tuned to the next lesson,
where we're going to take a look at eight different SQL queries
and then convert them one by one to Firebase queries.
So that's all.
And I will see you in the next lesson.
Oh, hey there.
Just fixing up new content over on the Firebase channel.
Thanks for watching our video.
You also might like this one or even this one.
And it's always good to subscribe.
This thing is awesome.