Hi, my name is Mosh Hamedani, and I'm 
super excited to be your instructor. In this three hour course, you're going to learn everything 
you need to get started with SQL or SQUEL. First I'm going to
give you a three minute introduction to SQL, then we're going to install the necessary 
tools and write our first SQL query. This course
is ideal for anyone who wants to learn SQL from scratch, but also 
anyone with some basic knowledge who wants to fill in the missing gaps. By the end 
of this course, you'll be able to retrieve insert, update, and 
delete data in databases. We'll talk about tables, relationships, 
different types of joints, sub-queries regular expressions and 
much, much, more. These are the essential concepts every software developer 
or data scientist must know. This SQL course is packed with tons 
of exercises that help you both learn and remember the SQL syntax.
Also, there is a table of content below this video so you can quickly jump
to specific tutorials, now let's jump in and get started. 
Let's start the course with a quick overview of databases, what they are and 
how we use them. A database is a collection of data stored 
in a format that can be easily accessed. In order to manage our
databases, we use a software application called database management system, 
or, DBMS. We connect to a DBMS and give it 
instructions for querying or modifying data. The DMBS will
execute our instructions and send results back. Now we have 
several database management systems out there, and these are classified into
two categories, relational and non relational, also 
called NoSQL. In relational databases, we store data
in tables that are linked to each other using relationships. That's
why we call these databases relational databases, each table 
stores data about a specific type of object, like customer
product, order and so on. SQL or SQUEL is
the language that we use to work with these relational database
management systems. It looks like this. We use SQL to query
or modify our data. In this course you're going to learn everything there is to know about this powerful 
language. Now, there are many different relational database management systems, 
out there, some of the most popular ones are MySQL,
SQL Server my Microsoft, and Oracle. But of course, there are plenty 
more. Each database management system has a different flavor of SQL. 
But all these implementations are very similar and are based on
the standard SQL specification. So most of the SQL 
code that you will learn in this course will work with any database management system. 
In this course, we'll be using MySQL, which is the most popular 
open source database in the world. Okay, now back to this diagram, 
what about non relational databases? In non relational databases, 
we don't have tables or relationships, these databases are
different from relational databases, but that's a topic for an entirely different course. 
What you need to know is non relational database systems 
don't understand SQL. They have their own query language. 
So, we use SQL to work with relational database management 
systems. Now, before we jump in and install MySql, let me clarify 
something quickly, as you talk to different people, you will hear two different pronunciations 
of SQL. SQUEL, or SQL. 
What is the correct way? Well, it depends on who you ask, and
of course everybody thinks their way of pronouncing this word is the right way. But here's a 
history about this language. SQL was originally developed at IBM
in the 70s and back then it was initially called SQUEL
short for structured English query language. But they changed
the acronym to SQL, because SQUEL was the trademark of an airplane 
company. So to this day, there has been an argument about what is the right
generally speaking, people in non-English speaking 
countries call it SQL. I'm used to calling it SQUEL
because it's shorter and sweeter than SQL. But if you prefer to
call it SQL, that's totally fine with me, I'm not going to get mad at you. So that's
the history behind this language. But what about MySQL as a 
software product? Developers of this product prefer to call it MySQL rather
than mySQL. But they don't mind if they call it MySQL. 
In this course, I'll be teaching you SQL with MySQL. 
Hey guys, Mosh here. I just wanted to let you know that 
you really don't have to memorize anything in this course, because I've created a 
complete cheat sheet with summary notes for you. You can find it below this video 
in the description box. So I have done my best to create
the best possible, most comprehensive SQL course for you, and
I would really appreciate it if you would support my hard work by liking and sharing this 
video. Thank you so much, now, let's continue. 
In this tutorial, 
I'm going to show you how to install MySQL on your computer. Now
I'm using a Mac, so first I will show you how to install MySQL on a Mac 
computer, and then I will show you how to install it on Windows. So if you're a Windows user, 
feel free to skip this tutorial. Now, open up your browser and
head over to MySQL.com. Then, go to the
downloads page, and scroll down to the bottom.
Here you should see MySQL community edition, this is absolutely 
free, and we're going to use that throughout this course. So let's go ahead 
and look at that, now on this page, click on MySQL, 
community server, and then on this page, 
you should see available releases for Mac OS. 
So, in this list, download the first item which is a dmg archive. 
Alright, now, on the next page, click
on no thanks, just start my download. Okay, as you can
see, we are getting a dmg file, which is basically a setup wizard. 
Alright, now the DMG is downloaded, so let's open it, 
and then double click on this package, this
will launch an installation wizard which is pretty easy to use, so simply 
click on continue and again, and again, 
agree with the license agreement, and 
install MySQL, it's going to ask for your password, this is the password 
that you used to log into your computer, so let's put that here, 
alright, now here we need to set a password to the root
for the admin user. So click next, and 
in this box, type a complex password, 
alright, now, let's finish the installation, 
and enter your computer's password one more time, 
and we are done! 
That was super easy and sweet. 
Alright, we installed MySQL community server, now we 
need the graphical tool to connect with this server and manage our databases. 
So, back to the downloads page, one more time, 
scroll to the bottom, and go to MySQL 
community addition, and on this page, somewhere 
you should see MySQL workbench. This is a graphical tool that we use to
connect to our database server. So let's go ahead and 
download this as well. Now once again on this
page, we need to download a dmg archive, so, 
download, and, again we have 
to say no we don't want to login or sign up, so let's go ahead and download 
the dmg, and then 
open it, alright, you're going to see something like this, so 
drag this MySQL workbench and drop it onto the applications folder. 
So, let's go ahead with that, now it's going to copy 
this into the applications folder, beautiful, 
so we're done with the installation, that was super easy, now press
command and space, and search for MySQL, 
work bench, there you go, let's open it, now the 
first time we get this message, because this is an application we downloaded from the internet. 
So, we need to tell Mac that we trust this, let's go ahead with that, 
so this is MySQL workbench, now by default 
you see a connection here, if you don't see that, you need to create it.
Let me show you how to do that. So for this demo I'm going to right click this and
delete this connection, alright, 
now let's create a connection from scratch. So click on this plus icon, 
on this page, give this connection a name, let's 
say local instance, now the connection method 
we're going to use is tcip, which is set by default, the 
host name is 127.0.0.1, which 
is the address of the local machine, and the port is 33
06, this is the default port for MySQL server, that is
the user name of the admin, now we need to enter the password. This is
the password that we set during the installation. So, click on 
store in keychain, and in this box, type the 
password for the MySQL server. Alright 
and finally, let's test the 
connection, okay, we successfully connected to MySQL
server on the local machine, beautiful, let's click okay, 
and here we have a connection on the homepage of MySQL
workbench, every time we open MySQL workbench, we use this
connection to connect to our local server. Alright, we're done
with the installation of MySQL on a Mac, next I will talk about
MySQL on a Windows computer, so feel free to skip that tutorial.
In this tutorial, I'm going to show you how to install
MySQL on Windows. So open up your browser and head over to
MySQL.com, then, go to the downloads page
now here, scroll down to the bottom, 
we're going to use MySQL community edition which is absolutely 
free. So, let's go with this, now, 
select MySQL community server, 
and then scroll down so here you should see
something like this, MySQL installer for Windows. This is the 
recommended method for installing MySQL on Windows. So, 
click on this, alright, on the next page, scroll down, 
and 
download the first installer here. On the next page 
scroll downs nd click on no thanks just start my 
download. Otherwise you have to create an account and log, which is unnecessary for
knowing this course, so, let's go with this, 
and save this file to our computer, and then 
run it. 
Alright, we're going to use this setup wizard to install MySQL, 
on our computer.  This is very easy, all you have to do is click next, 
but there are a couple places where you need to enter a password, let me show you.
So, on the first page, for the setup type we're going to use the 
developer default setup. Go to the next page.
Now here we're getting a little warning, because this installation wizard wants to
install the connector for python 3.7, but I
don't have Python on this machine, so that's why I'm getting this warning, now on your 
machine, you might or you might not get this error, just click 
next, and one more time, so here are
the products that I want to get installed the first one is MySQL server, 
the second one is MySQL workbench, this is the graphical
tool that we use to connect to our database server, and manage our database. 
You're going to see that soon. So click on execute, 
now this is going to take about 5-10 minutes, so, 
I'm going to pause the recording. 
Alright, all the products are installed, beautiful, let's go to the next page, 
and again, here our the group replication 
page, also click on next, and the next page which is 
about networking, leave all the default settings, so, 
let's go to the next page, now we should set a password for the root for 
the admin user. So, click on next, 
and in this box, type a password for the admin user. 
Alright, and then 
let's go to the next page, once again leave all the default settings, 
and click on next, and execute one more time, 
alright, and now 
let's finish our installation, once again we have to click on next, 
and then finish. One more time, 
there are so many steps. Now here's the page where you need to enter the
admin password, so the page is called connect to server, you can
see the username is root, which represents the admin user, 
so in this box enter the password that you said earlier, 
then click on check, okay, connection was successful 
beautiful, let's go to the next page, and 
click on execute, and finally finish. 
There you go, we have one more step, next the 
finally after all these steps the installation is complete.
Now, this is going to start, MySQL workbench, which is the graphical
tool we use to manage our database and run SQL queries. 
So, click on finish, so now we have a command 
prompt window, where we can type instructions to talk to our MySQL server, 
we don't really need this, so close it, 
and here's MySQL workbench, now the first time you open this page, 
by default you should see a connection here, if you don't see it, 
click on this plus icon, 
on this page give this connection a name, let's say local 
instance, now leave all their settings to their default value, 
but here for the password click on store involved. 
And in this box, type the password that you used for the admin user. 
So, I'm going to put that here, okay, 
now click on test connection, 
alright, we successfully connected to the MySQL server on this 
computer, alright, then, click on okay, 
now we click on this connection to connect to our database server. 
Alright, so here's the interface you'll be using throughout this course, 
on the left hand side we have the navigator panel, in the middle we have the
query editor which we can resize 
this is where we're going to write our SQL queries, and on the right side we have 
additions. So we're done with MySQL 
on our computer, next, I'm going to show you how to create our databases for this query. 
In this tutorial, I'm going to show you how to
create the databases for this course. So here I've got MySQL
workbench open, let me quickly give you an overview of this interface because 
the first time you open it it might appear a little bit intimidating. 
But actually it's not that difficult. So here on the top we have this tool
bar with these buttons for creating a new tab for writing SQL code 
as well as opening a SQL file. And next to that 
we've got a bunch of buttons for creating a database, creating new tables and 
so on. On the left side, we've got the navigator panel with two tabs 
administration and schemas. We use the administration tab
to do administrative work, such as starting or stopping our server.
Importing or exporting data and so on. The schemas 
tab shows the databases that we have in the current database server. 
So currently we only have one database, that is sis, and this is
the database that MySQL uses internally to do it's work. 
Now, in the middle we've got this query editor window, this is where we write our
SQL code, so we'll be spending most of our time in this course, in this
window, and on the right side we've got another panel with two tabs, 
contacts held, and snippets, now chances are this interface 
might look slightly different on Windows, but what I'm showing you here is 
almost identical to what we have on Windows. So don't get hung up if it 
looks slightly different on your machine. It doesn't really matter. Now up here, 
we've got these buttons for showing or hiding these panels, so
to clean this interface, I'm going to hide this panel on the right side. 
As well as the panel on the bottom. That is better. Now, 
to create the databases for this course, download the zip file attached, 
below this video. When you extract the (?) you're going to see a bunch of
SQL files like this. So the main one you'll be using in this tutorial
is called create databases.SQL. So this
file contains all the SQL code to create all the databases that we need 
in this course, now we also have individual files for creating 
individual databases, I've just added these files in case you need to recreate 
one of these databases in the future. But for now don't worry about them. Now, 
back to MySQL work bench, let's open 
the main SQL file. That is create databases. 
So this is an example of SQL code. 
Now this may look complex at the beginning, but trust me, as you go through the course 
you're going to understand exactly how everything works here. You're going to be able to
write SQL code like this. So, you want to execute 
this, to create all the databases for this course. To do that, we click 
on this icon, this yellow thunder icon that we have 
on this tool bar here. This will execute either the selection or the 
entire code if there is nothing selected for example, if I select this line here, 
and click on this icon, this will execute only this line. In this case
we want to execute the entire code, so we shouldn't select anything, 
and now let's execute this, beautiful, now here down on the bottom, 
we have this panel called the output window that shows all the 
operations perform in our database server, so we can see 
all the operations completed successfully, or something went wrong. 
As you can see you've got these green ticks next to each operation. 
Beautiful, so I'm going to close this panel, that's better. 
Now on the left side in this schemas tab you don't see this new database 
so we'll have to refresh this view, beautiful. 
So we've got all these databases that are prefixed with SQL
or SQL, I decided to prefix them with SQL so we know that 
these are the databases for this course, they don't accidentally clash with 
a database on the same name of your database server. Now, 
at the time of recording this video, there are only 4 databases here, but as we go through 
the course, I'm going to update the script for creating the databases, so, 
when you watch this course, chances are you're going to see more databases here. Don't worry 
worry about the difference. Now as an example let's explore 
these databases. And by the way we don't need this tab anymore so let's close it. 
That's better. Let's expand the SQL store
database, now in every database we have these objects, we have 
tables, this is where we store our data, we have views, 
which are kind of like virtual cables, so we can combine data from multiple 
tables, and put them in a view. And this is especially powerful 
for creating reports, you're going to learn about them in the future. You also have 
store procedures and functions, and these are little programs that we 
stored inside of our database for querying data. For example, 
you can have a store procedure for getting all the customers in a given city. 
So we call that procedure and we say hey, give me all the customers in San Francisco 
And this will return all the customers in San Francisco. 
Okay, now, let's expand the tables, 
so here are the tables in this database. We have customers, 
we have orders, products, shippers and so on. 
Now, select this customers table whenever you hover your mouse 
over this item and see these three items on the right side. 
Click on the right most icon, that looks like a table with a 
thunder. With this we can see all the data, in this 
table. So this is our customers table. In this
table, we have these columns like customer id which we use to uniquely identify 
customers. We all have first name, last name, birth 
date, phone, address and so on. So these are the columns 
in this table and every row is called a 
record. So every row represents one customer and these are the pieces of 
information we know for each customer. Now let's look at 
another table, let's open the orders table, 
in this table we have these columns like order ID, customer ID, 
order date, status, and so on. What is this customer ID here. 
We use this column to identify who has placed 
each order. Now what is interesting here is you have referred to this customer 
using their customer ID which uniquely identifies that. 
In other words, if Jon Smith has placed an order, we don't 
store John Smith here, we only store John's customer ID. 
Why is that? Here is the reason. It is possible 
John Smith might have placed multiple orders in our system. 
Now every time John places his order, we need to look up his address and 
phone to ship his order. Now it is possible that some of this information 
might change in the future. John might move to a new place or change his 
phone number, he might even change his name, if you repeat all that information
next to each order, then we'll have to come back and make changes
in multiple places. In contrast, with this design we only 
store the ID of john here, so anytime we want to change 
any information about John, instead of changing that here. We go back
to our customers table, so let's look at 
customer with ID 6, that is actually called (?)
So here is all the information about Elka. This is her phone number, this is
her address, and by the way this is all dummy data that I created using a tool. 
So, if any information about elka changes in the future, 
this is the only place that we need to modify. So 
this is how these databases work. We refer to these databases as 
relational databases. That basically means in these kind of databases we have 
multiple tables that are related to each other using 
a relationship. So internally there is a relationship between
the customers table, and the orders table. So the customer 
ID column in the customers table is related 
or linked or associated with the customer ID column. 
In the orders table. Here's the orders table, and here we have 
the customer ID column. So this was a brief introduction to 
relational databases, you learned about databases, tables, 
columns, rows and relationships. In the next section I'm going to show you
how to retrieve data from a single table in this database. 
But, before going any further as an exercise I want you to explore 
the invoicing database. Look at the all the tables, look at all the data to
get an id of the kind of data that we have in this database. You're going to use this database 
a lot in the future, so let's spend a couple minutes to explore this
database. 
In this tutorial I'm going to show you how 
to retrieve data from a single panel. Now look at the navigator panel. 
Currently none of our databases is displayed in bold, and that
means none of these databases are selected for query. So the first step to
rate a query to get data from a database, is to select a database. 
The query that we'll write will be executed against that database. 
In this demo, we're going to use the SEQUEL store database. 
So we type our use SQL_
store. Now use is a keyword in the SQL language, and that's 
displayed in blue. Now SQL is not a case sensitive language, 
and that means we can use upper case or lower case characters, it doesn't really 
matter, but as a best practice, we should capitalize the 
SQL keywords, and use lower case characters for everything else. 
So now, let's go ahead and execute this query. Alright, 
Look, the SQL store database is now displayed in bold. 
Now in MySQL workbench, we can also select a database 
by double clicking that, so now I double click SQL invoice 
and it's the current database. Now if we run this query again, 
the SQL store database becomes selected. 
Alright, now let's write our first query to retrieve all the customers in this
database. So after the you statement we're going to use 
select statement. Here is the basic syntax or basic structure 
of the select statement, we type out select in front 
of that we specify the columns that we want to retrieve, for example we can retrieve 
the customer ID column as well as the first name column or 
we can retrieve all columns using an asterisk. 
Now after that we use the from clause and this is where we specify the 
table that we want to query, in this case the customer's table. 
So this is the simplest query to select all the customers in a given table, 
now whenever you have multiple SQL statements you
need to terminate each statement using a semicolon. So, 
look, we have a red underline here that indicates an error, if you hover your mouse over here, 
you can see this tool tip saying select is not valid at this position. 
Because we didn't terminate the first statement with a semi colon. 
Okay, now let's execute this query one more time, once again, 
we can click on this button here, or we can use a short cut, 
so look at the query menu on the top, the first line is execute.
Now here's the shortcut for this command, on Mac, it's shift 
command and enter. On Windows its going to be different honestly 
I'm not sure. So whatever it is, use that. So I'm going to press 
shift command enter, and here are 
all the customers in this table. So this 
next statement has two clauses, the select clause and the 
from clause. But there are other clauses we can use to filter 
and sort data. For example, you can use the wear clause 
to filter the result and get the customer with ID
one. So we can write an expression like this. Where 
_ID = 1. Now when we execute this 
query, we'll only get the customer with ID 
1. So this is the where clause. We can also sort 
the data so after wear we use the order by 
clause and here we specify the columns that we're going to sort the results from
on. Let's say we want to sort these customers by their first name so we type out 
first_name. That is the name of one of the columns in this 
table, right? Now if you execute this query this order by doesn't really have 
an impact, because we only get one record in the result 
so let me temporarily take out the where clause, 
to do that we can put two hyphens in front of this line, now this line, 
is treated as a comment, which means the SQL engine is not going to
execute this, okay, so let's execute this query one more time, 
now all the customers that we get our sorted 
based on their first name. So that's the basic idea. 
Now over the next few tutorials your'e going to learn more about
these clauses in detail. But what you need to take away in this tutorial is that 
is that these 3 clauses from where an order by are 
optional. As you can see in this example, I'm not using the where clause, 
we can also comment out the order by clause, we can also comment 
out the from clause, so instead of selecting all the columns, 
in a given table, we can select some values like one and two. Now, 
if you execute this query one more time, in the result, we get something like
this. Two columns called one and two, and in these columns 
we have these values. So all these clauses are optional but in the 
real world we quite often use all of them. Now what you need to understand here is that 
the order of these clauses matter, so we always have select first, 
then we have from, then where, and finally order by. 
We cannot change the order of these clauses, otherwise we get a syntax error. 
Which basically means the syntax, or the grammar or the structure 
of our simple statement is incorrect. So it cannot be executed. 
And one last thing before we finish this tutorial, you can
see I've listed all these clauses on a  new line, now technically you don't have to
do this, because line breaks, white spaces and tabs are ignored 
when executing SQL statements. So we could come back here and 
put from in front of select, so select store 
from customers all in one line, and that's perfectly acceptable for simple queries, 
but as your queries get more complex, it's better to put each clause
on a new line. So that's all for this tutorial. In the next 
tutorial, we'll explore the select  clause in detail. 
In this tutorial, we're going to look at the select clause in detail. 
So, since our current database is SQL store, to 
clean things up I'm going to remove the first statement, you don't really need it now, 
also, I'm going to delete these two comments, we just want 
to focus on the select clause. Alright, so what
can we do with this select clause? Well in the last tutorial we learned that if you use 
an asterisk, this will return all the columns. Alternatively we can specify 
the columns that we want and this is helpful in situations where you have a 
big table with so many columns and perhaps millions of record. 
If you want to bring back all that data, that's going to put a lot of pressure 
on the database server, in this case MySQL, as well as the network. 
So, that's when we explicitly specify the columns that we 
want to get. Let's say we want to get the first name 
and last name columns. Execute
the query, as you can see, we only get these two columns. 
And they are in the same order we specified here. So if we 
change the order and put the last name first and execute the 
query again, now we can see the last name column comes first. 
Now let's add a new column, at the end, let's get
the points for each customer as well, run the query, so these are
the points for each customer which are calculated based on their shopping. 
Now let's say we want to get these points and put them in a mathematical formula 
to calculate the discount that we can give to each customer. 
So here we can use an arithmetic expression, that's points plus ten. 
This is an arithmetic expression. So now we can execute this query 
for the first record you can see that their points will end up
being 2283. Let's run the query one more time
there you go. Now we can put the original points column here for clarity. 
So points, points plus 10. Let's run the
query one more time, now you can see the original points, and next 
to that you can see the value that we're going to use to calculate the discount. 
Now here we're using the plus operator which is for addition, we also have 
multiplication, division, subtraction, and 
module which is the remainder of the division. So let's change this to something 
more complex. Let's say we want to get the points, multiply by 10, 
and then add 100 to it. 
Now we can immediately see that this line one is getting too long 
and it doesn't fit on the screen, in situations like this, you can break
up the select clause by placing each column on a new line, so, 
select last name, then first name 
points finally points times 10, 
plus 100. So let's execute this query one more time. 
So this is our new column with the new calculated value. 
Now one thing you need to understand in this arithmetic expression is the order 
of operators, and this is based on the order of operators in math. 
So in math, the multiplication and division 
operators have nighter precedence then addition
and subtraction, so in this expression, points is
multiplied by 10 and then the result is added 
to 100. If this is not what you want you can always change the order
by using parenthesis, as an example, let's change this
multiplication to addition and then put that 
multiplication here. In this expression, first 10 is 
multiplied by 100, and then the result is added to the points. 
Now let's say this is not what we want, so we can change the order by
using parenthesis here. 
With these parenthesis, first we get the points add 10 to them 
and then multiply the result by 100. So this
parenthesis are useful for changing the order of operations as well as 
adding clarity to our code. So someone else reading this code can easily understand. 
the order of these operations. Now let's execute this query one more time, 
alright, now look at the name of this column here, 
its set to the expression that we have on line 5. 
That doesn't quite make sense you want to have a clear descriptive name, 
so we can give this column an alias using the as keyword. 
So, as and then we give it a name like discount 
discount _factor. Let's run the query again. 
now the name of this column has changed, so this is the 
benefit of using an alias, we can give descriptive names to the 
columns and the results sets. Now if you want to have a space in the 
column name, you need to surround it with quotes, either 
single, or double quotes. So we put quotes here and then 
we can add a space in between these two words. Let me 
execute the query one more time. Now we have discount
factor. So let's quickly recap everything you learned about the select 
clause. We cause an asterisk to return the columns, or 
we can explicitly specify the columns that you want to return. 
We can also use, arithmetic expressions here, and optionally, we can even
 gibe an alias to each column in the results set. Now there is one more
thing you need to know about the select clause. So let's delete this query 
and select the state column, 
of the customers table. Take a look. These are the 
states in which our customers our located. Now currently in the sample 
data we don't have any duplicates, in other words we don't have multiple customer
in any of these states. But for this demo I want to change the 
state of the first customer to Virginia, so we end up with duplicates 
in the result set. So let's open up navigator panel
here's our customers table, let's look at all the data, 
and here's our first customer, 
here a you can see, it's located in the state of Massachusetts 
now I want to change this to Virginia. So double click
VA for Virginia, enter, now 
on the bottom right corner of the screen, you should see two buttons, 
apply and revert. Unfortunately I cannot show you this button 
because the recording window is a bit smaller then MySQL 
But look down in the bottom right hand corner, click
and apply. You're going to see a dial up box like this asking you to
review the changes, so go ahead and click that button one more time
alright, now, let's
go back to our first query window, and execute this query one more time. 
As you can see, the first two customers are located
in Virginia. What if you wanted to get a unique list of
states in the results set, that's when we use a distinct 
keyword. So select distinct set. 
With his query, we'll retrieve a unique list of states from the 
customers table. So with the distinct keyword we can remove 
let's execute the query one more time, now you can see
Virginia is not duplicated. 
Alright here's an exercise for you. 
I want you to write a SQL query to return all the products in our database 
in the result set. I want to see three columns, name, 
unit price, and a new column called new
price which is based on this expression, unit price 
times 1.1. So let's say you want to increase the price of each product by
10%. With this query you want to get all the products 
the original price and the new price. So pause the video and spend 
one or two minutes on this exercise, when you are done come back and see my solution. 
Alright this is pretty easy, so we start with select 
now what columns do we want to select? Name, unit
_price and then here we're going to use an arithmetic 
expression to calculate the new price. So we type 
out unit price times 1.1 and then give it a 
alias, o as new_price or we can put this in quotes 
and put a space between new and price. Now where do we want to
select these columns from? From the products table, so from 
products. Note that I've used upper case characters for all
the SQL keywords and lowercase characters for everything else. So, 
let's go ahead and execute tis query, this is what we get 
so these are all the products, you can see their original price 
as well as the new price which is 10 % more expensive. 
In this tutorial, we're going to look at the where clause
in SQL. So earlier I told you that we use the where clause to filter 
data. For example, let's say we only want to get the customers with 
points greater than 3000. So here in the where clause you can type out
the condition like this. Points, greater than 
3000. When we execute this query, the query execution
engine in MySQL is going to iterate over all the customers 
in the customers table. For each customer it's going to evaluate this condition 
if this condition is true, it will return that customer in the 
result set. So let's go ahead and execute this, 
and here's the result, as you can see you only have two customers 
with points greater than 3000. 
So, thesis what we call the greater than operator which is one of the 
comparison operators in SQL. Let me show you the completeness of comparison 
operators, so, we have 
greater than, greater than, or equal to, we have less then, 
less than or equal to, here's the equality 
operator, and for not equality, we can use an exclamation 
followed by an equal sign, or something like this. So both 
of these are not equal operators. Let me show you examples of 
these operators. So I'm going to delete all these and bring back
the previous query, let's say we want to get only the customers in the
state of Virginia. So we can change our condition to something like this. 
Where state equals Virginia. 
Note that I've put Virginia in quotes, because this is what we call a 
string. A string is a sequence of characters. So whenever you're dealing
with a sequence of characters, or basically textural data, we 
need to enclose your values with either single or double quotes. 
But quite often, by convention, we use single quotes 
so let's execute this query and here's
the result, you can see we only have these two customers with ID 1
and 2, who are located in Virginia. And it doesn't matter
if you use upper case or lower case characters, so if you type out
the a in lower case and execute the query you get the
exact same result. Now what if you want to get all the customers 
outside of the state of Virginia, you can use the not equal operator. 
So, we can either prefix this with an exclamation 
or use this other notation. 
Either way we get the same result. So these are 
the customers that are not located in Virginia. Now we can 
use these comparison operators for date values as well. For example, 
let's say you want to get only the customers born after January 
1st, 1990. So we change out condition to
first date, greater then, once again we use quotes, 
for representing date values even though dates are actually not 
strings. But in the sequel language, we should enclose dates with quotes, 
so, here we type out 1990, 
01 for January, -01 for
date. So this is the standard or default format for representing 
dates in MySQL. 4 digits for the year, two digits for the
month, and 2 digits for the day. So let's go ahead and execute
this query. I actually made a mistake here, so we don't see the 
result, instead we see the action output, or the output window.
If you scroll to the bottom, you can see the details of the error. So here I used 
the wrong name for the column, which should separate these two words
with an underscore. That is the name of our column. So, 
let's execute the query one more time, so we only have 3 customers
born after January 1st 1990. So these 
are examples of comparison operators in SQL. In the next tutorial
I'm going to show you how to combine multiple conditions when filtering data. 
Alright, here's your exercise. I want you to write a query to get the 
orders that are placed this year, so look at the orders table, see
what columns to do we have there, and based on that write query with a  where clause. 
So here's the orders table, in this table we have this column, order
date. We can use this problem to see the orders that are placed this year 
so here's our query, select, start from order 
where order_date, is 
greater than or equal to 2019, assuming 
this is the current yer, so 2019, 0101. 
Now since currently we are in the year 2019, this query will
return all the orders placed this year. But next year this query 
is not going to give us the right result. But don't worry about it, later in the course I will show
you how to write a query to get the orders placed in the current year, 
so for the purpose of the new exercise, this is a valid solution. Now let's
execute this query and see what we get. So, we have 
only one order, order ID 1, that is placed in the current 
year. 
In this tutorial I'm going to show you how to
combine multiple search conditions when filtering data. So,
let's say you want to get all the customers that were born after
January 1st, 1990, who also happen to have more then 
1000 points. So this is where we use the and operator. 
So we type out and, and after we type out another condition. 
Like points, greater than 1000. 
Now when we execute this query, we only get customers who have 
both these conditions. Let's take a look, so execute 
we only have 2 customers and if you look both these people
are born after 1990, and they have more then 
1000 points. So this is the and operator. When we use this 
operator, both these conditions should be true. In contrast to the and 
operator, we have the or operator. So with or if
at least one of these conditions is true, that row will be returned in the 
result set. Let's take a look. Now we execute this query again, 
2 records we have quite a few records. So for example, 
we have this person who's not born after 1990 
but if you look at their points they have more then 1000 points. 
So any customer records that satisfies at least one of these conditions
will be returned. Now let's take this to the next level. Let's say we want to get
customers who are either born after 1990, or 
they should have at least 1000 points and live in Virginia 
so this is how we do this, we type out and 
and then we add another condition, state equals 
Virginia. Let's execute this query and see what we get. We only get
4 records, so these are the customers that are either born after
1990 or they have more then 1000 points and live 
in Virginia. If you look at the first customer here this
person is not born after 1990. But you can see that she lives
in Virginia and she has more than 1000 points. So the last two conditions. 
are true for this customer. Now when combining multiple
logical operators. You need to be aware of the order of these operators. 
So earlier I talked about he order of arithmetic operators. I told you that
multiplication have a higher order then addition and 
subtraction. And we can use parenthesis to override 
the default order. We have the same concept in logical operator 
So the and operator is always evaluated first. 
So when this query is executed, the query execution engine 
first evaluates this condition, because here we're using an and
it doesn't matter that we typed out this condition after the first condition. 
Because the and operator has a higher precedence. Now you can always
change the order using parenthesis. And this also makes your code cleaner 
and easier to understand. So here we can put parenthesis, 
around these last two conditions, 
and also we can put these in a  new line for 
clarity. Something like this. So anyone 
who reads this code can easily understand what is the intent of this query. 
Now we also have logical operator called 
not. And we use that to negate a condition. So, 
I'm going to simplify our where clause. Let's say
we're searching for customers who were born after 1990 or 
we have more then 1000 points. If we execute this query 
we get these people. Customers with 
ID 1, 3, 5 and so on. Now we can use the not operator 
to negate this condition. So we apply not here, and 
preferably we also put parenthesis around this condition. 
Now when we execute this query, we see other customers that are not 
in the current results set. Let's take a look. So, 
instead of customers with id's 1356
and so on, we get customers with id's 2 4 and 10. 
Now technically these customers were born before 1990.
And we have less then 1000 points. So if you look here, 
this first customer was born before 1990 and 
he has less then 1000 points. How do they know that? Let me show
you a trick that I learned in math. Whenever you have a not 
operator. You can simplify your expression like this. We apply the not operator 
to the first condition. People who were born after
1990, how can we negate this condition? Well, 
the greater than operator becomes less then or equal to. 
That is the inverse of that condition. Now we 
apply the not to or to negate the or. What do we get?
We get and. Finally apply
the not operator on the last condition. We both have more then 1000 points. 
When we negate this condition we get customers with less then or equal 
to 1000 points. Now, you can remove the not operator 
to simplify this, we don't need parenthesis anymore because we 
only have 2 conditions that are combined with an end. Here is the result. 
As you can see, this is much easier to read and understand 
people who were born before this day and they have less then 1000 points 
Alright, here's your exercise. From the order items 
table, get the items for order number 6, 
where the total price for the total item is greater then 
30. 
Alright, here's the order items table, in
this table we have these columns order id, product id, quality, and unit 
price. If we multiply the quantity by unit price we can 
get the total cost of that item. And then we can compare it with 
30. So, let's go ahead and write this query. 
Select star 
from order items. Where 
here we need two conditions one is for order, so order 
_id should be 6, and the second condition 
we want to calculate the total price. So we get the unit price
multiply it by quantity and this 
value should be greater than 30. So as you can see, 
we can use an arithmetic expression in the where clause. It's not limited 
to the select clause. Okay? Now let's execute this query and see
what we get. We should get only 1 item, 
that is for product 1, here in quantities 4 and unit price 
is just over 8 dollars, so the total price for this item, is greater than 30. 
Hey guys, Mosh here. 
In case you haven't seen my website yet, head over to codewithmosh.com. 
This is my coding school where you can find plenty of courses 
on web and mobile application development. In fact recently I 
published a complete SQL course that is about 10 hours long, 
and it teaches you everything you need to know from the basic to advanced topics 
such as database design, security, writing complex queries, 
transactions, events, and much much more. These are the
topics that every software engineer must master. This YouTube course 
you're watching, is the first 3 hours of my complete SQL
course that is about 10 hours long. So if you want to master SQL
and get job ready, I highly encourage you to enroll in my 
complete SQL course. You can watch it anytime, anywhere, as many times as you
want, you can watch it online or download the videos. The course comes 
with a 30 day money back guarantee, and a certificate of completion 
that you can add to your resume. The price for this course is $149
dollars, but the first 200 students can get it for just over 
10 dollars. So if you're interested the link is below this video. 
In this tutorial I'm going to show you how to use the 
in operator in SQL. So, as an example, let's say
you want to get the customers that are in Virginia or
Florida, or Georgia. One way to write this query is like this.
So, where state equals Virginia, or 
a state equals Georgia, or a state equals
Florida. Now people who are new to the SQL language or 
programming in general find this expression a little bit strange. 
They ask, "Mosh, why can't we write this expression like this?"
where state equals Virginia or Georgia or 
Florida. Here's the reason, we use the or operator 
to combine multiple conditions. So here we have a condition 
or an expression more accurately, but on the right side of this or operator 
we have a string. In SQL we cannot combine a string 
with a boolean expression that expresses a boolean value which can be 
true or false. So that is why we have to write our query 
like this. So we have multiple expressions or multiple conditions 
and we're combining them using the or operator. 
So, now if we execute this query we get these customers here. 
customers here but there is a shorter and cleaner way to get the same result. 
Instead of combining multiple conditions using the or operator we can
use the in operator. So, where state 
is in and then in parenthesis we add all the values, 
like Virginia, comma, Florida, comma
Georgia and the order doesn't matter, this query is exactly equivalent 
to what we had earlier, but a you can see it's shorter and easier to understand. 
So, let's execute it, look, we get the exact same result.
Now here we can also use the not operator. Let's say you want to get the
customer's outside of these states, so we can use 
rare state, not in this list. 
Now if you execute this query, we get customers who are located in Colorado, 
Texas and so on. So use the in operator whenever 
you want to compare an attribute to a list of values. 
Now here is your 
exercise. I want you to write a query to get the products where 
their quantity in stock equals on of these values. 
49, 38, and 72, so pause the video, do this exercise, and 
then come back and continue watching. 
Alright, this is pretty easy, so we do a 
select star to get all the columns from the products table, 
where quantity in stock 
in we use the in operator to compare this attribute with these values. 
49, 38, and 72, let's execute the query, 
we get only 2 records because we 
don't have a product with quantity in stock equal to 72. 
In this tutorial, we're going to look at the between operator 
in SQL, so that means we want to get the customers who have more
then 1000 and less then 3000 points. What made you
write these queries like this? Where, points, greater than
thousand, more accurately greater than or equal to 1000. 
And, points less then or equal to 
3000. When we execute this query we get 
how many, we get 4 people that satisfy my criteria. 
Now whenever you're comparing an attribute with a range of values, 
you can use the between operator, and that makes your code shorter and cleaner. 
So, we can rewrite this expression like this, where points, 
between 1000 and 3000. 
This is exactly equivalent to what we had before, so these
range values are also inclusive, so that means points is going to be 
greater than or equal to 1000 or greater than or equal to 
3000. Let's execute the query, we get the exact same result. 
Alright, now as an exercise, I want you to write a query, to get the customers 
that are born between January 1st 1990 and January 
21st, 2000. 
Alright, so we start the 
select star from customers, 
where birth_date between 
so what matters here is we can use the between operator 
as well. It's not limited to using numbers. So with birth date between
now we need to supply two date values, so as I told you before, 
the format for dates is four digits for the year, so 
1990, two digits for the month, and two digits for the date. 
So, the birthdate should be between this value and 
here's a second value. 2000, 0, 1, and 
01. Let's execute this query, we get 
only 3 people who match this criteria. 
In this tutorial, I'm going to show you how to retrieve 
rows that match a specific string pattern, for example, 
let's say we only want to get to customers who's last name start with 
3. So, here in the where clause we type out
where last name this is where we use the like operator, 
and right after that we have a string pattern, so, 
you want to get the customers who's last name start with b and we have 
any number of characters after b. So use the 
percent sign to indicate any number of characters, you may have 
one character after b or no characters or 10 characters, with this
pattern, you get all the customers who's patterns start with b. 
And also it doesn't matter if it's an upper case or lower case b. 
So, let's execute this query, there you go, so you only have 
3 customers who's last name starts with b. As another 
example, let's say we only want to get the customers who's last name starts with 
brush. So, we change our pattern to brush, 
percent. Now, let's execute the query, we only get 
this one customer here. Now this percent sign doesn't have to be 
at the end of the pattern, it can be anywhere. For example, let's say we want 
to search for customers who have an e in their last name, whether it's at the beginning 
in the middle or at the end, so we change our pattern to 
percent e percent this pattern means we can 
have any number of characters before or after b. Let's
execute the query, these are the customers that have a b 
somewhere in their last name. It doesn't matter if b is in the beginning 
or in the middle or at the end. Let's look at another example, 
I want to get all the customers who's last names end 
with y, so here's the pattern we use, 
let's execute this query, so we have 5 customers 
who's last name ends with a y. So this is how we use the 
percent sign. Now we also have an underscore and 
that matches a single character so with this pattern you get customer 
who's last name is exactly two characters long, 
we don't care what the first character is, but the second character should be y. 
Let's execute his for you. Obviously we don't have any customers who's last 
name matches this pattern. But if you change this pattern to 
5 under score, so 1234
5, followed by a y we should get 
these customers. So their last name is exactly 
6 characters, we don't care about the first 5 characters, but all
of them end with a y. Now, as another example, 
we can replace the first underscore with b, and that means 
we want to get the customers who's last names start with b, and 
after b we have exactly 4 characters followed by a 
y. Let's execute this query. So we only have one customer, 
that matches this pattern. So this is how we use the 
light operator, use the percent sign to represent 
any number of characters and an underscore 
to represent a single character. 
Now this like operator in MySQL is an older operator 
but we also have a newer one that is more powerful and it allows us to search for
any string patterns. And that's what I'm going to show you next. 
Alright. 
Here I'm going to give you two exercises for the like operator. 
First, I want you to get the customers who's addresses contain trade
or avenue, and next I want you to get the customers who's phone 
numbers end with 9. 
Alright, let's get started with the first exercise. So 
start from customers where address
like now here we want to use a search pattern like this. 
You want to have tray (?) but tray can be anywhere in the address. So, 
we put a percent before and after tray. 
Next, we should use the or operator to search for another pattern. 
Or address like, let me 
put this on a new line that is better, address
once again, percent, avenue percent, that's it. 
So, let's execute this query, 
here is the result, you should get the customers with ID's 
2, 9, and 10. If you look at their addresses, all of them
have either tray or avenue in their
address. Now let's work on the second exercise, you want to get 
the customers who's phone numbers end with 9. That is pretty easy, 
so, let me change our where clause. Where 
phone once again we use the like operator and a percent, 
followed by a 9. That's all you have to do. Let's execute the 
query. So, here's the result, customers with 
id's 3 and 7, their phone numbers, and 
9. So this is how we use the like operator. And by the way
you can always use the not operator here let's say you want to get the 
customers who's phone numbers don't end with 9, 
so we simply prefix like with not. Now, 
if we execute this query one more time, we get all the other 
customers in the database. 
In the last tutorial you
learned about the like operator in SQL. So as another example 
let's say you want to search for the customers who have the word 
field in their last name. So we type out the where clause like this, 
where last name, like, percent, 
field, percent, so the word field, 
can be anywhere in the last name. Let's execute this query, we get 
only one customer, beautiful. Now we also have another
operator in MySQL, that is reg x which is 
short for regular expression, and regular expressions are extremely 
powerful when it comes to searching for strings. So they allow us to
search for more complex patterns. Here's an example. If I want to
rewrite this last where clause using a regular 
expression it looks like. Where last name 
ragexp now here in our string pattern 
we don't have to type out the person's size we only type 
out field so what we have on line 4 is exactly 
identical to what we have on line 3, let's execute this query 
we get the same result, beautiful, now here in regular 
expressions, we have additional characters that we don't have when we use the 
like operator. For example, we can use the carrot sign to indicate
the beginning of a string. So if I put a carrot 
just before the word field, that means our 
last name must start with field. Obviously, if you execute
this query, we don't get anyone that matches this criteria, so we use the 
carrot sign to represent the beginning of a string. We 
also have a dollar sign to represent the end of a string. 
So this pattern means the last name must end with field. 
Let's execute this query, you get the same result as before. Now
we can also search for multiple words here, for example let' say we want to find 
the customers who have the word field or mac in their last name
So, we use a pipe, a vertical bar, 
and type out another pattern. Let's execute
this query, so here we have two customers, one of them has the word 
mac, the other has the word field and the last name. 
Now we can take this to the next level. Let's say we want  to find the customers who
have the words field, or Mac, or rows 
in their last name. Let's execute the query we get 3 customers. 
Beautiful. So we use a pipe or a vertical board 
to represent multiple search patterns. Now as another example, 
we can change our first search pattern to something like this.
Now this pattern means this last name should either start 
with the word field, or it should have the word
mac in it or it should have the word rows. Let's execute
the query, now we get only two customers, because our customer
with the last name brush field doesn't match this pattern. 
However, if we change our first pattern to field 
$ and execute the query we get 3 people here, 
3 customers. So this is how we can combine multiple special characters
when building a complex pattern. Now let's look at another 
example, let's say you want to search for customers who have an e in their last name. 
So these are all the people, alright, now let's say 
you want to make sure that before the letter e, we should either have a 
g or an i. So this is where we use square brackets. 
And inside the brackets we add multiple characters like
g, i, m and that matches any customers who have 
ge or ie or me 
in their last name. So any of these characters can come before e. 
Now, let's execute this query, 
there you go, we only get 2 customers, and the first
example before e we have i which is one of the characters 
inside the brackets, in the second example, before e we have 
a g which is also another valid character before 
and once again the square brackets don't have to be before
we could add them after e, any customers who have e 
followed by an f or an m or a q in their last 
name, can be returned with this pattern, 
if we don't have anyone in the database so this is how we use square brackets, 
now we can also supply a range of characters, for example 
we can have e and just before e you can have 
as many characters from a to h, you don't have to
type them out explicitly like abcdefg, that's very 
verbose, so, we can type out a to h. 
And then if we execute this query we get these three people. 
So, let's quickly recap everything you learned about regular expressions
in this tutorial. Use a carrot to represent the beginning of
a string, so beginning, we use a dollar sign to represent 
the end of a string, we use a vertical bar or pipe, 
to represent a logical or so we can supply multiple
search patterns, we use square brackets to 
match any single characters listed in the brackets, and finally 
we use square brackets with a  hyphen to represent a range. 
So any characters from a to f. 
Technically MySQL supports more special characters but quite
honestly, the ones that I've listed in this tutorial are the ones that you'll be using 90% of the
time. So just memorize these and you're good to go.
With honesty a lot of beginners find the syntax for regular
expressions confusing, so in this video I'm going to give you 4 exercises that I have carefully 
designed to help you quickly learn about this syntax. Here's
the first exercise, get the customer's who's first names are Elka 
or Ambur. And note that this is Ambur with a U. 
Now for the second episode return the customer's who's names 
end with ei or on. 
Here's the third exercise get the customer's who's last names start with
my or it contains se, and finally 
as the last exercise return the customer's who's last names
contain e followed by r or a u. 
So, go ahead and spend 2-3 minutes on this exercise, 
when you're done come back and continue watching. 
Alright, let's knock out the first exercise. So we'll get 
allows, there's a c here, so let's start from 
regular expression, and here's our pattern, you're going to search 
for two words either Elka or Ambur. 
As simple as that. Let's execute this query, we should get two
customers, there you go, Ambur and Elka. Alright.
Now, let's knock out the second exercise. So I'm going to delete these 
we don't need them anymore. So we want to get the customers 
select start from customers, where 
last name should end with either ey or 
om. So, in the search pattern we type out 
ey followed by a dollar sign to indicate the end of a string
then we add a vertical bar to supply the second
search pattern. So On and once again dollar sign. 
Let's execute this query, oops I forgot to type out
regular expression, there you go. So, 
Let's execute this query, and you should get 
these four customers with ID's one 
three, five and seven. The first three, five, and seven, the first three, their last names 
end with ey, and the last customer, his or her last 
name ends with on. Alright, Now, let's 
work on the third exercise. So I'm just going to change the regular expression 
here, we want to get the customers whose last names start with
my or contains se. So we use 
a carrot to indicate the beginning of a string so 
it should start with my, or it should contain se, 
again, very easy, let's execute this query 
and we get the customer's with ID's 
4, 8, and 10 and finally 
we want to get the customers who's last names contain e 
so, let's change the search pattern, we should have a b, 
followed by r or u. Now there are two ways to write 
this regular expression, we can use square brackets so 
we have b followed by r or u, that's one way, or
the other way is to use a vertical bar. So b
r or bu. These are both valid solutions.
So, I hope you knocked out these exercises, in the next tutorial I'm going to show you 
how to get the records with missing values. 
In this tutorial, I'm going to show you how to look for records that miss 
an attribute. For example, if you select all the customers in our database, 
you can see that the customer with id 5 doesn't have 
a full number. So if you look closely here, you can see the value of
null. Null means the absence of a value. Now let's say
we want to search for all the customers who don't have a phone. Perhaps you want to send them an email
and say hey, your phone is missing in our system. So how can
we get these customers? That is very easy? We use the is null
operator, so in the where clause, we type out 
where phone is null. Now let's execute 
this query, we only get one customer who doesn't have a phone, 
now here we can also use the not operator to get 
the customers who do have a phone. So we change the conditions to
is not null. Let's execute the query, 
now in the query results, every customer 
does have a phone number. 
For this exercise, I want you to write a query 
to get the orders that are not shipped yet. This is a very useful query 
that is used in a  lot of real applications. For example, let's say you're an admin for
online shop. You want to see the orders that are not shipped yet, so you can see 
them all. So write a query, and get these orders. 
So here we have the orders table, let's have a quick look at the
data in this table. So if you pay close attention 
you see some of these orders don't have a
date. And these orders also don't have a shipper id which 
is a unique number for identifying the shippers. So any order
that misses the value for the ship date or shipper ID, 
is considered an order that is not shipped. So let's go ahead and write 
a query to get these orders. So back to our query editor 
select star from orders where 
ship_date is 
null. You could also write shipper id is null. They're both
equally correct. So let's execute this query, and you should get 
5 orders. Orders 1, 3, 4, 6, 
and 8. 
In this tutorial I'm going to
show you how to sort data in your sequel queries. So here in your
have a query to select all the customers from the customers table, if you look at 
the query result, you can see that our customer's or sorted by id, 
so we have customers 1, 2, 3, 4, and so on. This is the 
default sort column. But we can always change this using the 
order by clause. But first, let me explain 
why the customer id column is the default sort column. So first of all
the first I'm going to open up the navigators panel on the left side here's the customers
table, now let's click on this middle icon here that looks like 
tool. This opens up our customers table in the design mode, 
here we can change our columns we cana dd new column or 
remove existing ones or change that name and order and so on. 
Now if you pay close attention you can see a yellow key just before 
This means that this column is the primary key column. 
For this query. So in relational databases every
table should have a primary key column, and the values in that column 
should uniquely identify the records in that table. So 
back to our query window, you can see that the values in this column
 uniquely identify each customer, so the customer id column 
is the primary key column in this table, and that is why when you write a 
query against this table, our customers will sort it by id by default. 
Now, let me show you how to sort customers by a different column. 
So, here in the order by clause, you type out the name of another
column, like first name. Let's execute the query, now we can 
see our customers are no longer sorted by their id, instead 
they are sorted by their first name in ascending order. Now, 
if you want to reverse the sort order, simply type out de, 
e, sc, which is short for descending. Now, 
you're sorting the customers in this order, okay, 
we can also sort data by multiple columns, for example, 
let's say first we want to sort customers based on their state, 
and then within each state, we want to sort them by their first name. 
So, we type out multiple columns here, state 
and first name. Let's execute the query 
now, you can see that the first state we have here is california, followed 
by Colorado, and new here in Florida, you have two customers 
and these customers are sorted by their first name. Let's have a 
close look here, so first we have Ambur and then we have other
customers here. Now we can also use the descending argument anywhere here. 
For example, we can sort these customers by their state in descending 
order. And then sort them by their first name in ascending order 
or once, again in descending order. So there are various ways we can
sort data. Now one of the differences between MySQL, and 
other database management systems, is that in MySQL you can sort
data by any columns whether that column is in the select clause 
or not. For example, let's say you only want to select 
the first and last name for each customer. Now we can sort
the result by any columns in this table, they don't have to be first name and last names
For example, we can sort them by their birthdate, 
take a look, so this is a valid query in MySQL, but other databases
management sometimes yell at you when you update a query like this. 
Now we can also sort data by an alias for example, here in
out select clause let's add the number ten and give it a 
alias. As let's say points, so points is
not a valid column in this table, it's simply an alias 
or expression, in this case a simple number. And here we could have a complex 
mathematical expression, it doesn't really matter, we can still sort 
data by Alias, so we can order by points 
and then first name. Once again this is a valid, 
query from MySQL's point of view. Now one last thing before we finish 
this tutorial, I've seen some tutorials that teach you how to sort data by
calling positions, for example, here we can order it by 
1, 2, and that basically means sort the data by the first name, 
and then, the last name. So these are the orders of these columns, 
if you execute this query, you can see that our customers are sorted by their first 
name and then last name. Why this approach works, it's something that
you should avoid. Because if in the future you come back here and add 
a new column, in front of the first name column, let's say 
first, date. Now our customers are no longer sorted 
in this order. So sorting data by calling positions 
produces unexpected results and is something you should avoid. 
always sort by column names like first, 
Alright, here's your exercise for this tutorial. In this database, we have this table, 
called order items, where we find the items for each order. Now, 
I've written the query that you cannot see here, because that's the solution to the exercise 
I'm going to give you, that query produces this results. So 
we only have the items for the order with ID 2, and we 
have sorted these items based on the total price 
for each item. So the total price for each item equals quantity times
unit price. In this case the total price of product 1 is just 
over 18 dollars. So go ahead and write a query 
to select all the items for order with ID2. And 
sort them by their total price in descending order. 
Alright, let's select everything from order 
items, where order id equals 2. 
that returns all the items for this order. Now we want to make sure 
to sort them by their total price, so, 
here in order by clause, we write an expression. Quantity times 
unit price, this returns the total price for each item. 
And then we add the descending argument here. So, 
once again the expression that we use in the order by clause doesn't have to be 
column name, it can be an alias or an arithmetic expression like this. 
Let's go ahead and execute this query. This is what we get 
now for clarity, I would like to add another column in the result 
So, let's say quantity times unit
_price. We give it an alias like total 
price. Let's execute the query, you can clearly 
see, that this data ia sorted by the total rice in descending order. 
However, there is a bit of duplication in our query, you have to
repeated this expression in two places. So now we can simplify our 
by clause, by using an alias that is total price. 
And we gwet the exact same result. Net I'm going to show you
how to mimic the number of records returned form your queries. 
In this tutorial, I'm going to show you how to limit the 
records returned from the query. For example, when we return this query 
we get all the customers in the customer, table, so we have to 
ten customers here. Now what if we only want to get, 
the first 3 customers. That's where we use the limit clause. 
Let me show you. So, after from, you type out
limit 3, and this will return only the first 3 
customers. Now if the argument that we pass here is
greater than the number of records that our query produces, we'll get 
the records in the query result. For example, if I pass 300 here, 
obviously we don't have 300 customers in this table, so when
we execute this query. We get all the ten customers in this table. 
So this is how the limit clause works. 
Now here we can optionally supply an offset, and this is very 
useful in situations where you want to paginate the data. For example, 
let's say we have a website, and on this website we have a web page for
the user to see all the customers int he database. Now for simplicity 
let's imagine, we want to show only there customers per page. So, 
what are the customer's you're going to have on page 1? We're going to have 
customers 123. On page
2 we're going to have customers 456 and on
page 3 we're going to have customers 789. 
Now, let's say we want to write a query to retrieve the customers on page 3. 
How can we do that? Well, you want to skip the first 
6 records and then pick 3 records. So, 
we change our limit clause to something like this. 6
and 3. So 6 is what we call an offset. 
And that basically tells MySQL to skip the first records 
and then take 3 records. Let's execute this
query. Alright, now we get 
customers 789. 
Now, for your 
exercise, I want you to get the top 3 loyal customers. These
are the customers that have more points then everyone else. 
Alright, first we select everything from the customers table, 
now we need to order these customers by their points, 
in descending order. So if you look at the query result 
you can see that customers are sorted by their loyalty. So, 
the most loyal customers come first, now we want to pick 
only the first three customers, and that's where 
we sue the limit clause, so limit, 
let's execute this query. And these are the 
most loyal customers, customers with id's 56
and 3. Now, here's one thing I want you to remember and that is 
the order of the limit clause. The limit clause should always 
come at the end. So first we have the select clause and then
we have from optionally you can have where followed by
order by and finally limit. Order of these clauses matter 
If you change the order MySQL is going to yell at you. So
pay attention to the order when writing your queries. 
So far you have only selected columns from a single but in a real 
world, we quite often select columns from multiple tables. And that's what I'm going to show you
over the next few tutorials, so on the left side if you put 
our orders table. Let's select all the data here, 
in this table we're using the customer id column to identify the customer 
that has placed each order. Now as I have told you before 
we don't store customers information here like their phone number, their email their address, 
because this information can change in the future. And if 
even a customer has placed multiple orders then we have to
change multiple records, you don't want to do that. That's why we have separate tables 
for customers and orders. Now in this tutorial I'm going to show you
how to select the orders in the orders table, but instead of showing the customer
id, we showed full name for each customer. So lets go back
to our query window. Okay, so, 
we want to select everything from the orders table. Now we should combine the 
columns in this table with he columns in the customers table. That 
is where we use the join keyword. And here we can optionally 
type inner join, because we in SQL we have two types of join
inner join and over join. You'll look at outer joins later in this section, 
so for now we are only using inner join and these inner keyword, 
is actually optional, so we don't have to type it.
So, you want to join the orders table with the customer
table. Now, on what basis do we want to join these tables? 
Well, here in the customers table, we have this customer id column. 
So if you put these two tables next to each other you want to line up the records 
such that the customer ID's are equal. That is where 
we use the on phrase. So after
we type out a condition, here's a condition we need to type out, 
orders.customer_id. Should be equal to 
customers.customer id. 
Now, this is getting outside of the screen, so let's break up the line, 
that's better, so with this query, we're
telling MySQl that hey, whenever you're going the orders table 
with the customers table, make sure that the customer ID column, 
in the orders table, equals the customer ID 
column, in the customers table. Now let's execute this query, 
look at the result, 
since we are selecting everything here, the first few columns are
from the orders table, because we have listed that first 
now after all the columns in the 
customer table. So customer ID first name, last name and so on. 
Now let's simplify the result set and select only 
border id, first name, and last name, so query 
we select order ID, first 
name, and last name. Now let's execute the query 
that is better. So next to each order ID, you can see the 
name of the customer that placed that order. Now what if you want to display 
the customer ID here as well. Well, let's put that here and 
see what happens. Customer ID, execute the query 
we get an error, so if you look at the output window, down at the bottom, 
we should see an error saying column, customer id, field this is
ambiguous. Now unfortunately I cannot show you this error, because the size of my
recording window is smaller then MySQL workbench. But
that aside, let me explain why we're getting this error. Because we have this customer ID 
column in both the orders and the customers table, 
so MySQL is not sure which table we want to select this
column from. That is why it's saying this column is ambiguous 
so we need to qualify this column by prefixing it with a table name. 
We can either pick it from order table or 
the customers table, it doesn't really matter, because the values are
equal, right? So, in situations where you have 
the same column in multiple tables, you need to qualify them, 
by prefixing them with the name of the table, okay, now, 
we say tot he query one more time, there you go, you have order ID, 
customer ID and the full name. Now one more thing 
before we finish this tutorial, if you pay close attention we have repeated the word 
orders in multipel places, you have it here, as well as 
in the join condition, the same is true about he customers table, you
have repeated that here. We can get rid of this repetition 
and make our code simpler by using an alias. So write 
after each table you can do it in alias, 
as a short for orders, so by convention we abbreviate the table's name. 
Now, wherever we have orders you should replace that with 
o. So here in the join condition, we're going to replace orders 
with o, and also one more time, in the select 
clause. There you go. You can also apply an alias for 
a customer's table, call it c, and then simplify 
our join condition like this. So this is how we can join 
columns for multiple tables. 
Now for your 
exercise, I want you to look at the order items table. 
So, in this table we have these columns, order ID, column ID, 
product id, quantity, and unit price. Now I want you to write a query 
and join this table with the products table so for each order 
return both the product id as well as this name, followed by the 
quantity, and the unit price form the order items table. And by the way 
make sure to use an alias to simplify your code, 
Alright, first let's select everything from the order 
items table, and then join it with the 
products table. How are we going to join this table. On
order_items. Well actually 
let's just keep this on Alias right away, so we use oi, 
as an abbreviation for order items. And p as 
a short for products. So oi.product
id, should be equal to p or products.
product id. And by the way, remember that
alias for table, you have to use that alias everywhere. So here
I cannot type out product, MySQL is going to yell at me. So
let's use the abbreviation. Alright, this is how we join these tables, 
let's execute this query up to this point. Alright, 
so we see all the items form the order items table, followed by 
from the products table. Now, you want 
to explicit select a few column here. So, to 
order items table you want to select order_id. 
We take it then we don't have to prefix it with a table name 
because this calumnies not repeated in multiple places, so it's not ambiguous. 
So, let's make the code shorter, that's better, now 
we want to select the product ID column, but because this column exists
in both tables, you have to both prefix it with a column name.
Either oi or p it doesn't really matter. So, 
next, we want to select quantity, and finally you want 
price. Now actually here, you have this unit price column. 
In both tables, so this is the unit price in order items table 
and this is the unit price in the products table, 
now you might be curious why we have this column in 2 places, 
is that the price of product can change, so for each 
order item, you want to have the price at the time the user 
placed the order. So this is a snapshot of the price 
at a given point in time. The unit price that we have for the products table 
is the current price right now. This is very important for the 
recording, otherwise we cannot calculate the sales properly. So, 
because we have the unit price column in two places, in this case we should pick it
from the quarter items table because this is the price at the time of
now, let's execute query. So here's 
the final result. 
In the real world, when you
work as a developer or a data base administrator quite often you will 
have to work with multiple databases. In this tutorial I'm going to show you how
to combine columns from tables in multiple places. 
That's pretty easy. So, in the SQL store database, you have this tables 
that you're fairly familiar with. Now imagine this products table
was not here. Now, if you look at the 
database, you can see here another products table, this
products table is exactly the same as the products table that we have 
in a SQL store database, so it has the same columns and the same data. 
Now technically this is not a good design, you don't want to have the same table 
repeated in multiple places. But for this demo, let's just imagine 
that we don't have the products table here, so we want to join the 
order items table, with the products table in the SQL
inventory database. Let's get started. So select 
everything from the order items table, 
let's give it an alias straight away, you want to join this with
the products table. This products table is part of the products inventory 
database. So we'll have to prefix this with the name of it's database. 
So, we type out SQL inventory.
Now once again we can give this an alias like p, 
then type out our joint condition, so oi.product 
id should be the same as p.product id. 
Let's run the query there you go, so we successfully joined 
tables across multiple databases. Now note that
we're prefixing the products table with the name of the database because 
the current database that we're writing this query with is the SQL stored 
database. Take a look, in the navigator panel, in the SQL 
store database is displayed in full. Because earlier, the 
root we use statement to select 
a database, that will SQL store. Now what if we select 
the SQL inventory database. So, let's see what happens SQL 
inventory, now because we have multiple statements we have 
to terminate this with a semi colon. Now we want to select everything with a 
order items table. But we don't have this table inside of this 
database. So now we'll have to prefix this table 
with the name of it's database, that is SQL underline 
story. Let's execute the query, okay, 
everything works, beautifully. So here's the lesson. You only have to 
prefix the tables that are not part of the current database. In other words
the query will be different depending on the database. 
In SQL we can also join a table with
itself. Let me show you an example. Take a look at this database. 
SQL hr, in this database we have 
these two tables, employees and offices. Let's take a look at the 
data int he employees table. 
There you go. So here we have these columns, 
employee id, first name, last name, salary 
and reports 2. This is the id of 
the manager for this person or this employee. Now once again, 
you don't want to repeat the managers information here, like the phone number, the address
because this information can change in the future, so we are only using 
your identifier or their id to refer to them in this table, 
now where can we find information about this
This manager is actually an employee of the same organization, so, 
look at this example, the manager ID is 37
370. Now if you look on the website, here is the ID of
that manager which is another employee. That was the manager for this
employee. We don't have any values here so 
the value for the sale is null. So this employee doesn't have a manager 
and that means they are the CEO. So let's go ahead and 
write a query to join this table with itself so we can select the name of
each employee and their manager. Back to our query window, 
first we need to select the SQL hr database. 
Next, we select everything from 
the employees table, we give an alias like
b now we need to join this table with itself. So once again we type 
out the employees, but we need a different alias. What should we 
call this alias. Well you want to join this table with itself so we can 
find the managers right? So we can use m as a shortcut 
for managers. Now, let's type our our joint condition. 
So from the employees table, we need to join 
the reports_2 column. To the manager 
table which is basically an employees table itself, and 
that is employee_
id. Now let's execute this query and see what we get. 
So, we see all the columns from the employees table 
repeated the first set of columns, represent the information about the 
employees, and after that, we have the information about the managers
in this case we have only one manager in this table. 
But with this technique we can easily create an organization trial. We can have 
a hierarchy of managers. Now let's 
only the name of the employee and the manager. So, 
right here, since every column in the employees table is 
repeated twice we need to prefix each column with a table name. 
For example, from the employee's table you want to get
employee ID, as well as the first 
name, and then for the managers table, we want to select 
the first name as well. So every column 
should be prefixed with a table name or more accurately the alias because
all these columns exist in two tables, right? 
Let's go ahead and execute this query, so, 
this is what we get, employee id, and here's the managers 
first name. We can improve this query by giving an alias to this
column. Because it doesn't make sense to have two first name columns. 
So, let's give an alias to the third column, 
manager. Now, let's execute it one more time. 
And, here's the end result. So, we have
the empty ID first name, and object. So, 
joining a table with itself is pretty much the same as joining a table with
another table. The only difference is that we have to use 
different alias's. And we have to prefix each column with an alias. 
This is what we call a self join. Next, I'm going to show you
how to join more then two tables. 
In this tutorial, 
I'm going to show you how to join more then two tables in writing a 
query. For example, back to our SQL database, look at the 
orders table, now you know how to write a query to join this
table with the customers table to return information about the customer
to place each order. But here we also have another column, 
status, which is similar to the customer ID status. So the name of the 
status's are not stored in this table, they are somewhere else in the 
order status's table. Let's have a quick look here. 
Our orders can be either processed, shipped or delivered. And these are
the identifiers for each of these status's. Now back to our
orders table. In the status column you store
status id. So now we should write a query to join the orders
table, be two tables. The customers table and orders 
status's table. The result of this query is going to look like this. 
So for each order we see the order id, the date, 
the first and last name of the customer, and finally the status of the order. 
This is a beautiful report we can create for our users. So let me
show you how to write this query. Back to our query editor, first we need to select 
the SQL store database, now, we need to select 
everything from the orders table, that's going to be the alias, 
next we need to join this with the customers table. 
On, that customer id should 
be equal to see the customer id. Nothing 
new so far. Exactly like before. Now here we can write another
joint keyword. To join the others keyword 
order status's table. So we type out order status's. 
And also give it an alias, OS, 
what is our join condition? Well, back in the 
orders table, here we have the status column. So the 
value in this column should be equal to the order status ID, 
column in order status's table. Right? So back
to the query, so orders table.status
should be equal to order status's.order status
ID. Make sure to get the name right, otherwise you're going to get
an error So this is how we can join three tables. 
Now in the real world as you work on more complex problems, you'll end up joining 
even ten tables. So this is not uncommon in the SQL world. 
Now let's go ahead and execute this query. First we get the column 
from the orders table, followed by the orders from the customers table, 
and so on. This result is so complex and hard to extract information. 
from. So, let's explicitly select 
a few columns here. From the orders table, you want to select 
the order iD column, as well as the order
date. Then, from the customers table, we want to select 
the first name, and last name.
And finally form the order status's, we select the name 
column. So we can give this an alias like status
that's better. Let's execute the query one more time. 
So, here's the end result, we have order ID, 
order date, the name of the customer, followed by the status of the order. 
Alright, for exercise, take a look at the SQL
invoicing database. Here we have this table, payments, 
and these are the payments that each client has made towards either invoice 
Let's take a look at the data, so we have these columns, 
like client id, that identifies the client, so we can join this table 
with the client's table to see the name of the clients. Next we 
have invoice ID, we also have date, 
payment method. So similarly we can join this table with the payment method 
table here, let's have a look at the data in this table, these are the 
payment methods, credit card, cash, PayPal, wire transfer. So, 
back to the payments table, I want you to write a query and join this table 
with the payment methods table as well as the client's table. 
Produce a report that shows the payments, with more details, such as the name of the client, 
and the payment method. 
Alright, first we need to
use, the SQL invoicing database, now we can 
select everything from the payments table which we call
e, next we need to join this with the client's table which we call
c, on p.clientid 
should eb equal to c.client id. Let me double 
check the column name to make sure I got it right, so back to the payments table
the column is called client item. You also have a column called 
payment method, that we should join to the payment 
method ID column of the payment methods table. 
So, back to the query, once again we use a joint 
statement here, join with payment methods, we give it an alias 
pm, on p.
payment _method should be equal to pm. 
payment method id. Make sure to type it out correctly 
otherwise you're going to get an error. So let's go ahead and execute the query 
up to this point, finally let's hand pick 
the columns that make the most sense. So, 
from the payments table, let's select the
date, followed by invoice id, 
what else do we have here. So we have client id, invoice 
id, date, and now the payment method, I'm going to pick the amount 
column from here as well, so back to the query, p 
.amount. Now we need to add information about the client. 
Let's take a look at this table, clients, 
so here we have columns like name, address, 
city and so on. All we need here is the name column. So back to the query, 
of the client's table let's select the name column and 
finally form the payment method table, let's select, what is that column called
it's called name. So back to the query
pm.name. So here's the end result. 
Now we can put this column in any order that we want, it doesn't really matter, 
let's execute the query, and make sure everything works. 
So, on this date, on this invoice, 
we have a payment for this amount by this client using a 
credit card. 
Ina let he examples you have seen so far, 
we use a single column to uniquely identify the rows 
in a given table. For example, for example, in the customers table, 
we have this customer ID column which uniquely identifies 
the rows in this table. But there are times where we cannot use a single 
column to uniquely identify columns in a given table. For example,
look at the order items table. In this
table, we have columns like order id, product id, and so on. Now if you look at 
the data, you can see that the values in the order id column are repeated. 
They are duplicated. You have 2226 and so on.
So we cannot use this column on it's own to uniquely identify each record. 
The same is true for the product id. The values for this column 
are also duplicated. So in this table we use the combination of
the values in both these columns to uniquely identify 
each oder item. As an example, in this order we have 
3 items, for products, 1, 4, and 6, and 
for each product, we have a quantity and unit price.
So if we use the combination of the values in both these values, 
we can uniquely identify each order item, in other words, we don't have 
two records for order ID 2, and product ID 1, 
we only have a single record for that item, 
now let's open this table in the design mode. So over here we 
find this middle icon that looks like a tool. Note that this yellow 
key that represents the primary key exists on both these columns. 
This is what we call a composite primary key. The composite primary key 
contains more then one column. Now why does this matter? 
Well, when you have a table with a composite primary key. 
You need to learn how to join that table with other tables. For example, 
here we have this table, order item notes, that we use to keep
notes in each order item. Let's look at the data here. 
So we have this column note id, right? Which uniquely identifies the 
records in this table, next to that we have order ID and product ID. 
you learn that the combination of these two columns uniquely represents 
and order ID. So here for order number 2, 
for product number 1, we have two notes. Now let me show you how
join this table with the order items table. So, back to our 
query, you can see that I have already selected the SQL store
database, so I'm not going to type out a U statement. Alright, let's select 
like everything from the order 
items table. Give it an alias, now we need to
join this with order item notes, also 
we give it an alias. How are we going to join these tables? 
Based on two columns, back to the order items table 
these are the columns that we need to use in our joint condition. 
So, in the order items table we have this 
order ID column, these should be equal to the
same column in order item notes table. So, 
in.order id. But this is not enough, 
we should also join these tables based on the product ID number. 
So, we type out and, and then type out the 
second condition, so order items.
product ID should be equal to order item notes.product 
id. This is what we call a compound joint 
condition. So we have multiple conditions to join these
two tables. 
In this tutorial 
I'm going to talk about the implicit joint syntax in MySQL. 
So here we have a basic inner join, we're selecting everything from the orders table, 
joining it with customers table on, orders.customer
id. Equal to customers.customerid. Pretty basic. 
There is another way to write this query using implicit join 
syntax. Let me show you how this works. So, 
we select everything 
from now here we can type out multiple table names. 
so, orders, customers. 
And we can also give them an alias, so c and 
o. And then we move this join condition, 
to the where clause, so I'm going to copy this from here, 
type out the where clause, and paste the condition. These two queries, 
are equivalent. What we have here is called implicit 
joint syntax. Now even though MySQL supports the syntax 
it's something that I suggest you not to use, because if you accidentally forget 
to type out the where clause, you will get a cross join. Let me show you
what I mean. So first I'm going to delete the first query. 
And execute this 
so we get ten records because we have 
10 orders in this database. So far so good. What happens
if you accidentally type out
the where clause. Instead of 10 records we're going to get 
probably 100 records. Because every record
in the order table, is now joined with every record in the 
customers table. This is what we call a cross turn. Now later in this
section I'm going to talk about cross joins in more detail, but what I want to talk about 
in this tutorial, is that it's better to use an explicit 
joint syntax, so, we use, join 
because this syntax forces you to type out the joint condition, if 
you simply join orders with customers, without typing 
the join condition, you're going to get a syntax error. So to recap, 
be aware of the implicit join syntax, but write all of 
your joints using the explicit syntax. 
Earlier in this section I told you that in SQL we have two types of forms. 
Inner joins and outer joins. And so far you have 
only seen examples of inner joins. And I also told you that this inner keyword is 
optional, so whenever you type out a join, you're using an inner join. 
In this tutorial, we're going to look at outer joins and the problems they
solve. So, let's start by writing a query that uses an 
inner join, and then we'll convert hat inner join and outer join. 
So, select everything from the customers table 
join it in the orders table, 
on c.customer id should be equal to 
o.customer ID. Pretty basic 
right? Now for clarity, let's pick a few columns from these
two tables .So for the customers table I want to pick customer 
id. And first name, 
and from the orders table, I want to pick order id. 
Now finally, let's sort the results so we can clearly see what 
we get. So order by c.customer 
id. Let's execute that query and see what we get. 
So, here' the result. For customer number 2 called 
inis or inis whatever, you have 2 orders, order 4, 
and order 7. Similarly for customer number 5, we have 
2 orders and so on. Now there is something missing in this result. 
We only see customers who have an order in our system, these are 
customers 2, 5, 6, 7, 8, and 10. But
if you look at the customers table, you can see that 
you have other customers like customer number 10, customers number 3, and so on. 
Currently we don't have any orders for these customers, and that's the reason 
we don't see them in this results set. But what if you want to see all the 
customers whether they have an order or not? That's when we use an 
outer join. Let me show you how that works. So back to our query 
the reason we only saw customers who have an order was because 
of this join condition, When joining these two tables, you are only 
returning records that match his condition. So for a
given customer, if we do have an order, that record
is returned. But as you saw a second ago, some customers don't have 
an order. So for those customers this condition is not 
valid. And that is the reason they are not returned in the result set. 
To solve this problem we use an outer join. Now in SQL we 
have two types of outer joins. We have left joins and right 
joins. When we use a left join, 
all the records from the left table, in this case customers are 
returned whether this condition is true or not. So we 
get all the customers, and if they do have an order, we'll see the order id 
as well. Let's execute this query and see what we get. So, 
there you go. Customer number 1, 
doesn't have an order and that's why we get null in this cell. 
Customer number 2 has two orders, 4, and 7, customer 
number 3 also doesn't have an order so we get null for order id. 
This is the result of a left join. So back to our query 
when we use a left join, all the records from the left 
table are returned whether this condition is true or not. 
Now what if we use a right join. In this 
case, all the records from the orders table are returned whether this condition is 
true or not. Let's execute this query and see what we get. 
So, we get he same result as before. 
when we use an inner join, because we are selecting all the records from the right table 
which is the orders table, so we don't see all the customers 
we see all the orders. Now if you want to use a right join, and 
still see all the customers, you need to swap the order of these tables. So, 
we put the orders table first that's going to be our left table. 
And then, we put the customers on the right side, 
so now with this query we'll return all the records from the right table 
which is the customers table. We execute this we get 
all the customers whether they have an order or not. 
Beautiful. Now one last thing before we finish this tutorial, 
I've seen developers use the outer keyword here. So either 
right outer join or left outer join. But technically 
the outer keyword is optional just like the inner keyword, so you don't have to type it out. 
So I'm going to remove this to make this code shorter and easier to 
understand. So to recap, if you have the join keyword directly, and 
if you do a left or right join you're doing a 
inner outer join. 
Here's your exercise for this tutorial. I want you
to write a query that produces this result. So we should have three columns here. Product 
ID, name, and quantity that I picked from the 
order items table, so here we need to join the products table. 
With order items table. So we can see how many times each product is ordered. 
However, in an inner join we will only see the products that 
have an order, but here I'm doing an outer join, so, 
product number 7, has never been ordered, but still exists in the result. 
Is it null, or the quantity? So go ahead and write an outer 
join, or use this result. 
Alright, first we select 
everything from the products table and then 
to a left join with the order items table. 
Our join condition is p.product 
id equals oi.product id. 
So because we'll get all the products 
in the products table whether this condition is true or not. If you have never 
been ordered, you still see them in the result. Now, let's 
pick a few columns for clarity. So p.productid 
p.name and oi.
quantity. That's it. Let's execute the query.
We get the same result as before. So all the products are here. 
And product number 7 has never been ordered so we see 
null for the quantity. 
Similar 
to inner joins, we can use outer joins between multiple tables. Let me show
you. So here's the query that we wrote in the last tutorial, you are doing a 
left join between customers and orders tables. 
So when we execute this query, you get all the customer 
whether they have an order or not. If you have an order you see
the order id. Beautiful. Now if you look at the orders
table, you can see that some of our orders have a
shipper id. These are the orders that have been shipped. So now let's join 
orders table with the shippers table to display the name of the shipper in the result. 
So back to our query, after this left join, 
let's write another join, here I'm doing an inner join. 
So let's inner join the orders table with the shippers table. 
Join shippers, we call it sh, on 
what is the join condition. Well, oh.shipper 
id, should be equal to sh.shipper 
id. Alright? So in this query we have 
a left outer join and inner join. Let's see 
what we get, alright, we only 
see 5 records. But you have more orders. So here you have the same problem 
we have before. Some of our orders don't have a shipper, and that is why 
they are not returned here. In other words, this join condition
is not true, for some of our orders. So back to the orders table, 
a an example, this first order doesn't have a shipper
shipper id is null, and that is why it is not returned with a query result. 
So to solve this problem, you should use a left join, you want to make sure
that all orders are returned whether they have a shipper or not. 
So back to the query, you need to replace this inner join 
with the left join, so let's execute the query and see what happens. 
Now we should have quite a few more orders, there
you go, now to make this example more interesting, I'm going to add the ship
-per name here. So back to our select
boss, let's add a new column, shipper.name. 
Now we can give it an alias like shipper
let's execute the query and here's the result.
So we get all the customers whether they have an order or 
not. And for those who do have an order, we get all the orders
whether we have a shipper or not. This is the power
of outer joins. Now in the last tutorial, you learned that you can get the
same result, in both the left join or the right join, you just have to
swap the order of the tables. However, as a best practice of what
to avoid using right joins, because when you're joining multiple tables and you have 
left and right and inner join, things get really complex. So, 
someone else reading your code, will have difficulty visualizing how you're joining these tables. 
As an example, if you have a right join here and then a left join 
after, it will be harder to visualize how these tables are getting joined. 
So, as a best practice, avoid right joins, and use left joins 
instead. 
And, here is your exercise for this tutorial. 
I want you to write a query that produces this result. So here you have these columns 
order date, order id, the first name of the customer
the shipper and we can see that some of our orders are not shipped yet. 
So here we have null, and here finally, we have the status. 
So go ahead, spend 2-3 minutes on this exercise, when you're done continue 
watching. 
Alright, let's select everything 
from the orders table, now you should join this with
customers, on, hold.customerid. 
Should be equal to c.customer id. Here I'm using
an inner join, because every order does have a customer. So, 
this condition is always valid, it doesn't matter if we use a left join or a 
inner join here, now, okay? Now before going any further let's 
take our columns. So from the orders table, I'm going to pick order id. 
Followed by order date. And then, 
customer.firstname. 
Which we can optionally rename to customer. 
Alright, next we need to select the shipper. So, we
join the result with the shippers table, 
on order.shipperid equal 
to shipper.shipperid. However, if we use an inner join here,
because some of our orders don't have a shipper, we are only 
going to see the orders that have been shipped. Let me show you. So, 
for clarity, I'm going to add the shippers name here, so shipper
.name as shipper. Let's execute the query 
there you go, we only see the orders that have been shipped. 
But we want to see all the orders, right? So, we need to 
change the second joint to a left join. 
So all orders are returned whether they have a shipper or not. 
Let's execute the query one more time, 
there you go. Now we see all the orders from number 1-10. 
Beautiful. Finally, we need to add the status comment here. 
So, we need to do another join here, join
with order status's, which we aggregate 
as os, on oh.status equals 
to os.orderstatusid. 
We can see that I have designed our database such that sometimes our column names 
are exactly identical, but in other cases they don't match. 
So in order table we call this column, status, as opposed to 
order status id, and this is deliberate because a lot of 
real databases are like that. Alright, now let's add
the status name here, so order, status.name as
status. Execute the query, 
and we can see all the orders here, 
for each order we have the data, the customer, the supper and the status. 
Earlier, we talked about self joins in
SQL. So here in the SQLhr database, we have this
employees table, we rote a query to get 
all the employees and their manager. So here we have this column, reports 
to that specifies the manager for each employee. So let's go back
and rewrite this query to get all the employees and their manager. 
Back to our query editor window, first let's use
a SQL hr database. Then select everything 
from the employees table,
we give it an alias and then join it with itself. 
So this is what we call a self join. Now we're going to use a different alias 
like m for managers. Now, what
is the joint condition e.reports to, should be equal to 
m.employee ID, right? 
Now for clarity, let's pick only three columns, so either the id 
employee.first name. 
And m.firstname which we rename to 
manager. Alright, let's execute this query and see what we get. 
So, here's the result 
as you can see all these employees have the same manager. 
However, there is something missing here. We don't have a record for this person, this 
manager himself. So what is missing is a record where 
we can see the employee id for this person, their name and their 
manager which should be null because this person is the CEO or the 
head of the company. But why is this happening? The reason is, 
our inner join, because this condition we have here will only 
return people who have manager. We can solve this problem by using a 
left join. So, we do a left join, because we want to get every
employee in this table whether they have a manager or not. 
Okay, now let's execute the query one more time. 
There you go. Now we have a record for this person 
the manager, as you can see this person does not have a manger, that's why
we have null here. 
Back to our SQL store database 
here we have a simple query that joins the orders table, 
with a customers table. And here's our join condition. We have several examples 
of this before. Now as our queries get more complex 
these joint conditions get in the way, they make our queries hard to read, but the good news 
is that in MySQL, we have a powerful feature for simplifying 
these queries. If the column name is exactly the same 
across these two tables, we can replace the on clause. 
With a using clause which is simpler and shorter. 
So I'm going to comment out this line and instead type out using 
in parenthesis, we type out the column name, that is custom. 
customer id. What we have in line 7 is exactly identical to what we have 
on line 6. That is shorter and easier to read. So, 
let me delete this line. We can add another join
statement here to join the orders for the shippers here, so join with 
shippers using 
shipper id. In both these tables we have a column with the exact 
same name. Alright, now let's execute this query 
this is what we get, you have the order id followed by the 
first name of the customer. Let's add a new column here, 
so, I'm going to add sh 
.name that is the name of the shipper, 
now obviously because some of our orders are not shipped, we have to replace this 
inner join to the left join. So we can
use the using keyword with both inner and outer joins. Let's execute 
the query one more time. There you go. 
Now, we have the name of the shipper next to each order, beautiful, 
however, we cannot use this technique to join the result with the 
order status's table. Because in the orders table we have 
this column called status, but in order status's table, this column has a different 
name. It's order status id. Let me show you. So, 
order status's. columns, there you go, order status id. 
So the using keyword only works if the column name is 
exactly the same across different tables. Now what if we have multiple 
columns in our join condition. For example, earlier we talked about 
tis order items table, I told you that in this table we have 
a composite primary key, which basically means a primary key that consists 
of multiple columns. So the combination of these two columns uniquely 
identifies each record in this table. Now if I join this table, 
with order item notes table. In our join 
join condition, we should compare both these columns with their corresponding 
columns in the order item notes table. So let's quickly 
write that query and then simplify it with the using keyword. 
So, select everything from 
order items, now, join it with order 
item notes on 
so here we need to compare oi.order 
id with yn.orderid, and 
oi.productid=
to oin.productid. This join 
condition is kind of messy, it's hard to read this query. Now let's
simplify this query with the using keyword. So we type out using. In parenthesis 
we add both columns and then separate them using a comma. 
So, ordered and product 
id. Isn't that better? 
Now, for our exercise, back to our
SQL invoicing database write a query to select the payment 
from the payments table and produce something like this. So in this table we have the date 
the client, the amount and the payment method, we can see. 
On what date who has paid how much using what payment method. 
Alright, I'm going to use the SQL
invoicing database, and then select everything from the 
payments table, join it with the clients table. 
Using client id because in 
both these tables, you have the client id table. Next we need to join this with 
payment methods, however, they 
column name between these two tables is different, so in the payment 
table we have a column called payment method. But in payment 
methods table, our column is called payment method ID. So here we 
cannot use the using keyword, and we'll have to use
the on clause. So on p.payment 
underline method equals pm. 
paymentmethodid. Now let's pick our columns. 
So, payment.date client.name. 
And we rename this as client, next we pick
m out, and finally, the payment method, 
so, let's rename that to payment_method 
and execute the query, there we go, this is what we get. 
The date, the client, the amount, and the payment method. 
In MySQL, we also have another 
simpler way, to join two tales, it's called a natural join, and it's
easier to code, but it's not something to recommend, because sometimes it produces unexpected
results. But let me quickly show you how it works in case you see it somewhere
so at least you're familiar with it. So back to the previous example, 
let's select everything from the orders table, that
we should do a natural join with the customer's table. 
Now with this natural join, we don't exactly specify the column name. 
So the database engine will look at these two tables and it will join 
them based on the common columns. The columns don't have the same 
name. And that is the reason this query is shorted right. 
So, for clarity, let's pick a couple of columns here, o.order 
id and c. let's say first name. 
Let's execute the query, there you go. 
so we see all the orders and the customers replace them. 
So natural joins are really easy to code but they can 
be a little bit dangerous, because we're letting the database engine 
guess the join, you don't have control over it. For this very reason, 
natural joins can produce unexpected results, and that's why
I discourage you to use them. 
In this tutorial, 
were going to look at cross joins in SQL. We use cross joins to
mine or join every record from the first table, with every record, 
in a second table. Here is an example, let's select 
everything from the customers table to 
now here we do a cross join with the products table. 
So every record in the customers table, will be combined with 
every record in the products table. And that is why we don't have 
a condition here. Okay? So this is what we call a cross join 
now for clarity let's pick a couple of columns like
see that first name we rename it as customer
and then product.name which we rename to 
product. Also, let's sort the result 
by customer. first name. 
Now, let's execute the query, here's the result of the cross join, 
so first we have amber as the customer, and here are all
combinations of amber with different products. 
Next we have Barbara or whatever it is, and again we have the combination of this custom 
with all the products. Now in this particular example, it doesn't really make
sense to use a cross join, a real example for using 
cross join is where you have a table of sizes like small, 
medium, large, and a table of colors, like red, blue, green whatever. 
And then you want to combine all the sizes with all the 
colors. That is when you use a cross join. 
Wha we have here is called the explicit syntax for cross join, you also
have the implicit syntax which looks like this. Instead of typing out
the cross join, you type out multiple tables in the 
from clause. So customers and orders. 
Both these queries produce the same result. But I personally prefer to use 
the explicit syntax because it's more clear. 
And here's a simple exercise for you. Do a cross join between shippers and 
products. First do it using the implicit syntax, 
and then using the explicit syntax. It's pretty straight forward, I just want you to 
get your hands dirty in the code and get used to this syntax. 
Alright, first I'm going to use the explicit syntax, and then I'm going to
place the syntax. So let's start by selecting everything from 
2 tables, shippers and products, 
now for clarity I'm going to pick two columns, shipper.
name which we rename to the shipper. And product.name which we 
order everything by 
shipper
Let's execute the query, this is what we get. So the combination of all shippers
and all products beautiful,  now let's use the 
explicit syntax, so we select everything from the base table, 
in this case shippers and then do a cross join with products. 
That produces the same exact result. 
We covered everything about joins, you learned 
that with joins we can combine columns with multiple tables, but 
in SQL we can also combine rows with multiple tables, and this
is extremely powerful. And let me show you how this works. First we have 
a quick look at our orders table, and select everything from the order 
table. Now if you look at the data, 
we can see that the first order was placed in the current year, 
2019, all the other orders were placed in previous years. Now
let's say you want to create a report, get all the orders, and next to each order, 
add a label. If the order is placed in the current year, the table is 
going to be active, and if the order is placed in previous years, you want to label it 
as archives. So, let's change our 
query and change our condition here. First you want to get all
the orders in the current year. So where order 
date is greater than or equal to 2019, 
0101. Now I just want to highlight that this is 
not the ideal way to get the orders in the current year, because here we have hard 
coded 2019. So if you execute this query next year, we are not 
going to get the right result. But don't worry about this for now. Later in the course I will show you how to 
get the orders in the current year, without hard coding a date here. 
So, let's execute this query, now we get 
only one order. Let's hand pick a couple of columns here. 
So, order id, 
and order date. And also I want to add a string, 
literal here, like active. Right? 
Let's execute this query, this is what we get. We get 3 
columns, order id, order date, and active, and in this column, 
argument we have this string value. Active. Now let's
rename this column to status, alright?
And execute the query, that is better, 
now we want to write another query similar to this that will return the order 
in the previous year, but with a different label, archive. 
So, to save time, I'm going to copy this
few lines and paste them right after our first
select statement. Now note that here we have a syntax error, because we didn't 
terminate the first select statement with a semi colon, but don't
worry about it, we're going to get back to this in a second so for the second 
query, we want to return a different a different label, archive, and we want 
to change our condition to less then 
2019. Now, select only these few lines. 
And execute this query, either by clicking on this icon here, 
or using the keyword shortcut you learned earlier in the course. 
There you go, here are all the 
orders from the previous year, with the label archive. 
This query returns 9 records. The previous query returned 1 record. 
now using the union operator we can combine data from
these two queries, so, in between 
our select statement we type out union 
now let's execute the query one more time, so here's our first 
order in the current year that is active and below that we have 
the orders in the previous years. So using the union operator we can combine
records for multiple queries. Now in this example, both our queries are
against the same table, but we can also have queries against different 
tables and then combine the result into one result set. 
Let me show you another example. So I'm going to delete everything here.
Let's select the first name, 
from the customers table, and then we can union that with select 
the name from the shippers table. 
Let's execute the query's in one result set
we can see all the customers and the shippers. Now as far as 
I know, there is no real world care for this particular query. But what I
Want to point out is that with union we can combine results from multiple 
query's. These query's can be against the same table or different 
tables. In your database, you can have a table like archive
orders, and another table like order 
and then you could combine all the archive and active orders into one 
result set. Just remember, that the number of columns that the query 
returns should be equal, otherwise you're going to get an error. For example, 
let's select the first name and last name from customers 
and then union that with the name of 
shippers. When we execute this query, we get an error, because the first part 
of this query returns two columns, but the second part returns one column. 
So MySQL doesn't know how to combine these records. 
And one last thing before we finish this tutorial. If you look at the result here, 
the name of this column is based on this
first query, so the first query returns first name, and that's why this column is called 
first name. If you change the order of these queries, 
and move this union up here, now let's run this query 
as you can see our column is called name. 
So whatever we have in this first query is used to determine the name of 
columns. Here we can also rename the column to full name. 
There you go. 
Here's your exercise for this tutorial. Write a query for this report. 
So here we have four columns, customer ID, points, and 
title. Now as you know we don't have this column in the customers table, 
so we have calculated the values of this column, based on 
the points each customer had. If they have less then 2,000 points, 
their type is bronze. If they have between 2,000 and 
3,000 points they are silver customers, and if they have more then 
3,000 points, they are gold customers. Also note that here we have sort 
the result by the first name. So go ahead and spend
two minutes to write this query. 
Alright, first let's get the bronze customers, 
so select everything from customers where 
points is less then 2,000. 
Now here we want to pick 3 columns, customer id, 
first name, end points. And finally we 
add a new column to a string literal, bronze 
let's run this query and see what we get. So these are all the bronze 
customers, but the name of this column in bronze, we don't want that.
So, let's rename this to type. Now this is off the screen so 
I'm going to break this up into multiple lines 
that makers our query bigger and easier to read. 
There you go, let's run the query one more time, now the column is called type. 
Beautiful. Now we should do union 
and repeat this query, but extract the silver customers. 
So I'm going to paste this query here and then make a 
couple of changes here, I'm going to replace bronze with silver, 
and change the condition to between 2,000 
and 3,000 let's run our query, see what we get 
so, we have all the bronze customers first, 
followed by all the silver customers. So the order of these records is based 
on our queries. In our first query we got the bronze customers, which is why 
they are listed first. But this is not what we want. You want 
to order the result by the first name of our customers. So, 
let's apply an order by at the end
so order by first name. Now there is one more piece remaining. 
You should do a union one more time and write a query to get 
the gold customers. SO I'm going to select these few lines. 
And paste them here. 
Now let's change silver to gold, 
and the condition to (?) greater then 3000. 
And finally we do an imported by. Let's run the query one more time. 
And here's the end result, our customers 
are sorted by first name, bronze, silver and
gold customers. 
In this section I'm going to teach you how
to insert, update, and delete data. Before we get started 
let's have a closer look at our customers table. So click on 
this middle icon to open this table in the design mode. 
What you see here might look a little bit intimidating at first, but trust me 
it's so easy, and in this tutorial, I'm going to explain exactly what we have in
these columns. So on the left side, you can see the column 
next to that you can see the data type for each column, so our customer id column 
can only accept integer value. Integers are whole numbers
like 1234 and so on. You don't have decimal points, etc. 
First thing is a var chart which is short for variable 
character. And in parenthesis, you can see 50, that basically 
means in this column you can have a maximum 
of characters now if the name of a customer is only 5 characters long the only 
store those 5 characters. So even though the max 
length for this column is 50, you're not going to waste the space if this customer 
name is less then 50 characters. That is why here we have 
4char which is short for variable. In contrast we have 
another data type that is character. If you had character 50 here, 
and the name of the customer was only 5 characters long, MySQL 
will insert additional 45 spaces to fill this column. 
So this is a waste of space. So as a best practice, 
Most oft he type we use var char to store strings 
or textural values. Now here on the right side we have this column 
pk, which is short for primary key. So customer 
id is marked as the primary key, and that is why we have this yellow key here, 
so the values in this column uniquely identify each 
customer. Next to that we have nn which is short for not null
and that determines if this column can except null values or not. 
In this case, every customer record, must have the customer id. 
First name, last name, as well as these other attributes. 
But birthdays and phone are optional. So in these columns we 
can have null values, Now we have another calling here, ai, 
which is short for auto increment and this is often used 
with primary key columns, so every time we insert a new 
record in this table, we let MySQL or our database engine insert 
a value in this column, so essentially it gets the customer id 
for the last row, and it will increment it by 1, by the time
you serve a new record. So if you look at the data you can 
see that currently we only have 10 customers here. So if you have a new customer here, 
MySQL will sign 11 to the new customer, okay?
And finally here we have another column that specifies 
the default value for each column. For example, for birthday 
and phone columns, the default values or null, 
So if you don't supply a value MySQL will supply the null values 
for these columns. Similarly we have another null value, 
for the points column, so if we don't supply the points for a customer, MySQL
will use 0, now we have a few other columns here which are not important 
at this stage, you will learn about them later in this course. So now 
you understand the attribute of each column, let's go ahead 
and insert data into this table. 
In this tutorial, 
you're going to learn how to insert a row into a table. For that we're going to use 
the insert into statement. Where are we going to 
insert this row? Into the customers table, so we type out 
the name of the table here followed by the values clause. 
And here in parenthesis we supply the values for every 
column in this table, so back to our table definition, 
these are all the columns, first we need to supply a value for the customer id 
column. However, in this column, the auto increment 
attribute is enabled, and as I told you before, if we don't supply a value, 
MySQL will generate a unique value for us. 
So we can go back to our statement and either assign 
an explicit value or use default to let MySQL 
take care of generating this value. This is the preferred approach. Because if we use this value 
an explicit value like 200 it is possible that you might have 
another customer with the same id. So when you execute the statement, you're going to get an error. 
Because you cannot have duplicate values in this column. Every value
should be unique, so here we're going to use the default keyword to let you generate
a unique value for the customer id, and after that we need to 
supply a value or the first name and last name columns. 
So, let's say Jon Smith. 
Note that I have enclosed these values with quotes, because as I have told you, 
string and for in SQL, we should always enclose string and
values with quotes. Either single or double quotes, okay? 
Now, what else? Back to our customer table, 
after the last name you have birthdate, however, 
as we can see, this column is optional because this check box is not checked. So 
here we can use null or an explicit value. Null means the absence 
of a value. So back t our statement, you can type out 
the birthdate, like 1990 January 1st or 
you can use the null keyword to leave out this value. 
Now in this demo, I'm going to use a value date, 
now to make this code cleaner and more readable, I'm going to break it up into 
multiple lines. That's better, 
now back to our table, next we have phone and phone is 
also optional, because this checkboxes not checked, and null is the 
default value for this column. So here we can explicitly pass 
null, or use the default keyword and then put null into this 
column. It's exactly the same. So, back to our 
statement, you can pass null or default. 
Both these keywords will have the same result. In this case I'm going to use the null 
keyword. Alright, let's have one more look at our table, 
next we have 4 more columns that are 
required, so address, city, state, and points. And note that points 
has the default value of 0, so we can either use an explicit value like 
total value like 200, or use the default keyword and let MySQL generate
0. So, back to our statement, let's type out 
an address, it doesn't really matter. 
Followed by a city, and a state, let's say california, 
and finally points, again we use explicit value 
or default, so this is how we can insert a row into 
a table. However, in this example, you're only 
supplying values for first name, last name, birthdate and 
these address fields. So you're leaving out phone number 
the customer id and the points. So there's another way 
to write the statement. Let me show you. So after the table name you can 
optionally supply the stuff columns that you want 
to insert values into. In this case first name, 
last name, birthdate 
and once again I'm going to break up this statement into multiple lines 
So 3 more columns, 
address, city, and state, 
so these are the 6 columns that we're going to supply values
for. With this change, we don't have to use these default 
or null values, we only supply values for these columns. 
So I'm going to remove default from here, and null, and finally 
this last default keyword. 
So, the 6 values that you supplied here are used for the 6th column. 
Now with this change, you can also reorder the columns. 
We don't have to list them in the same order, they were defined 
in the customers table, for example you can put the last name first, 
and then obviously we should also swap the order of these values, 
so we can list them in any orders. Now we can execute 
the statement, now if you look at the output window 
down on the bottom you should see the statement followed by one rows 
unfortunately I cannot resize this window to show you this message, but if you look down
below you can see that one word was affected, which basically means 
one record was inserted into this table. Now, 
let's look at the data in the customers table 
so the last row is the one that we inserted, we can see that the 
MySQL automatically generated the value 11, this is the effect 
of auto increment attribute. So it takes the value of the last row, 
and incrememnts it by 1. So here we have the first name. Last name, 
birthdate, you didn't supply a value for the phone attribute, so, 
that's why we have null here, we also have address, city 
state, and the default value of 0 for the points. 
In this tutorial, you're going to learn how to 
insert multiple rows in one go. For this we're going to use the shippers 
table, let's have a quick look at the table definition 
so here we have 2 columns, shipper id and name. Shipper id is 
primary key, it's not nullable, and it's an auto incremented 
column. So we're going to let MySQL generate values for this column. Easy. 
You only need to supply a value for the name column. So back to our 
query editor window, we type out insert 
into shippers in parenthesis we specify the name of the column 
we want to insert values into, in this case name 
followed by the values clause. Here we add a pair of 
parenthesis with a value like shipper one. Now
insert multiple rows all you have to do is insert a comma 
followed by another pair of parenthesis. So, 
shipper 2, one more time, comma, shipper 3, 
this is how you can insert multiple rows in 1 row, 
now let's execute this statement, alright, 
and then inspect the data in the shippers data. 
There you go. So initially we only had
5 shippers and here are the 3 new shippers that we inserted. Note that MySQL 
automatically generated the values for the shipper id column. 
So we have 67 and 8. 
Alright, here's your exercise
for this tutorial. Write a statement to insert three rows 
in the products table, it's really easy you can knock it out in a minute, 
So here's our products table, we only have 4 columns, 
we're going to leave out the first column because it's an auto increments  column 
so we only have to supply values for name, quality, unit price. 
Back to our query editor window, let's insert 
into products the columns are 
name, quanitty in stock, and unit 
price. And the values are going to be let's say product 1, 
stock is going to be 10 and the unit price is going to be 1, 
.95. Now I'm going to select these values.
copy, paste it, like this, 
change the values accordingly, and 
finally the last row for the 3 
there you go, let's execute this statement, alright 
and then verify the result so
in the products table, now we should have 3 new records, 
now the id's you see here are 15, 16, and 17. 
Because before recording this video I actually inserted a few records in this table and then 
deleted them. So I had product ID's 11, 12
13, and 14. And even though they're actually deleted from 
this table, MySQL remembers their id's so instead of incrementing 
10 x 11, it incremented 14 which is the last record 
from before. And that's why you generated 15. On your computer, 
the items are going to be 11, 12, 13. 
So far you have only learned how to insert data into a singular table. 
In this tutorial, I'm going to show you how to insert data into multiple tables. Here's 
a really good example, look at the orders table, what columns do we have? 
We have the order id, we have the customer 
id, so we know who has placed the order, we know the date of the order, 
you know the status, comments, as well as shipping 
information, but the actual items for this order are not in this table, they 
are in the order items table. So in this table, we have 4 columns 
we have the order id, so we know what order these items 
for. We have the product id, so we know what product 
order, in what quantity, and in what price. So an actual 
order can have 1 or more order items. 
This is what we call a parent child relationship. So this relationship 
the orders table is the parent, and the order items table is the 
child. So one row in the orders table can have 1 or more children 
inside the order items table. Now in this tutorial, I'm going to show you 
how to insert an order and all it's items. So you will learn 
how to insert data into multiple cables. alright, back 
to our query editor window. First we need to insert the order, 
so insert, into, let me close 
the navigator panel, we want to insert a record into the order 
table, now what columns do we have here?
So we have these columns but only the first four are the 
and actually the first one, we don't want to worry about, because that's an auto increment column. 
So we only want to supply values for customer id, order date, 
and status. So back to our query, specifying those
columns here, customer id, order date, 
and status, now let's supply the value. 
In the customer id column, we need to add a 
valid customer id. So let's have a quick look at our customers 
table, there you go. In this table, 
we have 11 records. So these are the valid customer id's. 
Now back to our query, let's use 1 for customer query 
and then 2019, January the 2nd 
for the order date, and one for the order status, once again 
in this column, we need to insert a valid order status 
id. If you don't supply a valid id, MySQL is going to get
ahead of us. So we insert an order here, 
the items, now back to our order items table, 
in this table, we have this order id column, so here's the 
as soon as we insert an order, MySQL is going to generate 
an id for our new order now we need to access that id in 
order to insert the items in this table. How can we do that? 
Well, back to our query editor window, 
in MySQL, we have a bunch of built in functions, and a function 
is basically a piece of code that we use ourself. Just like a function is a feature 
in your tv. Every tv comes with a bunch of functions like 
power on, power off, change the volume, change the channel so on. 
So MySQL and other database engines come with a  bunch of built in functions 
that we can use in our programs. One of these funcitons
is last insert id. We can call or 
execute this function, by adding parenthesis here, and this will return the ID 
that MySQL generates when we insert a new row. 
So, before going any further, let's just select these, 
and make sure you get the right result. Now we have a syntax error here because we didn't terminate 
the first statement with a semi colon, alright, now let's execute this query, 
alright, so the id of the new order is 
12. Let's verify that. So back to the orders 
table let's look at the data. On my machine I have 
12 records here, I actually created 1 just before recording this video, so on your 
machine you're going to have 11 orders. 
Now back to our query window now that we know how to  get the id of the newly inserted 
record, we can use that id to insert the child records. 
So, we're going to write another insert statement, 
insert into order items, let's have 
another look at the columns in this table. So we have 4 columns 
on all of them are required, so there's really no need to specify the column name 
in our insert statement, you simply supply values or order id, 
product id, quantity and unit price. So, here 
in the values clause, we add parenthesis, 
what is our order id? That is the value returned 
from calling this function. So I'm going to cut this from here and 
next we need to supply a valid photo id, 
but let's say product 1, quantity, let's say 1. 
And the unit price 2.95 dollars. 
Now let's delete this select we don't really need it anymore 
let's add another set of values, so once again, we're going to call
last insert id, to get the id of a new order, we're going to 
change the product to product number 2, and add a different price. 
That's it. Now let's execute this 
statement and see what we get. Alright, so, 
back to our orders table, let's refresh the records here, alright 
so we have a new order, order number 13, 
beautiful, now let's look at the orders items table, here's the order
items, let's open the table. So we should have 
2 items, or order number 13. Beautiful. 
So this is how you insert hierarchical data in SQL. 
In this tutorial, I'm going to show you how to copy data from one 
table to another. For example, in our orders table, currently we have 
about a dozen records. Now let's say we want to create a copy of this table 
called orders archive and you want to insert every row that we have 
in this table into that new table. If you have 10 orders, 
we don't want to quote an insert statement with a ten set of values, 
that is very time consuming, so I want to show you a powerful technique to 
uniquely copy data from one table to another. First we need to create this new table, order 
archive. For that we're going to use the create 
table as statement. So create table 
orders archive as. 
Now right after that we write a select statement 
to get everything from the orders table. 
Now let's see what happens when we execute this query, there you go.
So back in the navigator panel, we have to refresh this view
by clicking on this icon over here, now we 
have a new table, orders archive, let's look at the data, 
so you can see all the orders are here and we have the exact same column 
as the orders table. However, if you open this table in the 
design mode, you cans ee that in this table, we don't have a primary key. 
So the order id column is not marked as a primary key. 
And also it's not marked as an auto increment column, so when we create a table
using this technique MySQl will ignore these attributes, 
and that means if you want to explicitly insert the record 
into this new table, you have to supply a value for order id, 
because this column is no longer an auto increment column. 
So, using create table as statement you can quickly create 
a copy of a table, now we refer to this select statement 
as a sub query, so a subquery is a select statement 
that is part of another SQL statement. 
Now we can also use a sub query and an insert statement and that is a very
powerful technique. It allows us to do really cool things. Let me show you. 
So first, let's right click the orders archive table, 
and click on truncate table, because we want to delete 
all the data in this table. Alright, it's asking for confirmation 
let's truncate the table, so now back to this table. 
Let's refresh the table, we don't have any records here, alright? 
Now back to our query editor, let's say you want to copy 
only a subset of records from the orders table into this table, 
like all the orders placed before 2019. So first let's select 
everything from the orders table where 
order date is less then 2019, January 1st. 
So, these are all the orders, order
s
copy these orders into he orders archive table. So
we can use this select statement as a subquery  
in an insert statement, we write insert 
into orders archive 
now we don't need to supply the column names, because we're going to 
play values for every column that we have in this query. 
So, we did that, and 
this is ane xample of using a select statement as a subquery 
in an insert statement. Let's execute this, 
alright, now back to the table, let's refresh the records 
we only have the orders placed before 2019. 
Alright, here's a really, really, really coo exercise 
back to our SQL invoicing database. Look at the invoices table. 
So in this table, we have these columns, 
(?) id number, client id number which is associated or related 
to the client id column, in the clients table, followed by 
a few other columns, now let's say you want to create a copy of the record 
in this table, and put them in a new table called invoices archive. 
However in that table, instead of the client id
column, we want to have the client name column, so you want to join 
table with the clients table, and then use that query as a sub query in a create table statement. 
Also, to mae the exercise more interesting, 
I want you to copy only the invoices that do have a payment. So if 
you look over here, this payment data column here, determines 
if a payment has been made, towards this invoice or not. So select 
only the invoices that do have a payment date, it's a really really good 
exercise, spend two to three minutes on this and then come back and continue watching. 
Alright, first I'm going to use the SQL invoicing data, 
base, now let's select everything from the 
invoices table and join it to the clients table. 
here I'm going to use the using statement to simplify 
my join. What column are we going to use for joining? The client id 
column. Let's execute this query up to this point. 
Alright, so first we see client id column 
is used for joining these tables, after that we have the columns from 
the invoices table like invoice id number and so on. Followed by 
the columns from the clients table. Name 
address and so on. Obviously we don't want all these columns, we only want 
the columns from the invoices table but we should replace the client id 
column with he client name column. So let's have 
a quick look at the design of the invoices table 
here we have invoices id, number, 
client id, we want to replace this column with the client name. 
Back to our query, I'm going to pick, 
invoice id, number 
and then client.name, let's rename it to client 
what other columns do we have here? We have 
invoice total and payment total so let's add those as well, 
invoice total as well as payment total, 
we also have three columns, 
for dates, invoice date, due date, and payment date, 
so, let me close the navigator panel. Invoice 
date payment date and 
due date. Now technically because these columns only exist 
in the invoices table, we don't have to prefix them with the
table alias. So we can simplify the code like this, however, 
I personally prefer to prefix them, because that gives me a clear 
picture of how I'm joining these tables. It's just a personal preference 
another developer might disagree and that's fine, so whatever you prefer.
That's perfectly fine, let's execute the query and make sure 
we get the right result, so we have the invoice 
ID  number client beautiful, followed by these other 
columns, now I want to filter the result, and return 
only the invoices that do have a payment. So we can either 
return records that have a payment date, or the records that have 
a payment total of greater then 0. Both are perfectly 
fine, so back to our query, 
down at the bottom, let's add the where clause, where payment 
date is not null. That's better. 
Let's execute the query one more time, now we get only these 
handful of invoices, beautiful, finally let's use our 
query, as a subquery in a create table as
statement. So right before 
select we type create table, invoices, 
archive, as there you go, let's execute 
the query beautiful, now back to the navigator panel, 
let's refresh the view, so here's our new table, 
invoice and archive, let's look at the data, there you go. 
You only have the invoices page and here's the name of the
client for each invoice. Beautiful. Now just note that 
if you execute this query one more time, you're going to get an error because we already have a 
table called invoices archive. Later in the course I will show you how 
to draw tables, that's pretty easy, but for now you can just right click
and go to draw table and then confirm 
alright, and then you can run the query one more time. 
In this tutorial I'm going to show you how to update data in
SQL. So back to our invoices table, 
look at the first record here. The payment total for 
this record is 0, and obviously there is no payment date. 
Now let's imagine that there was a problem int he system that recorded this information. 
Let's say the client paid ten dollars for the invoice. So we should update this
record in this table. That is very easy, back ti our query editor, 
window, we use the update statement to update one or more records
in a table. What table? In this case invoices. 
Next we add a seth clause and this is where we specify a new value 
for one more or columns. In this case we want to update
payment total. Let's say to ten dollars. We should also update 
payment date. So here's a column to add more columns 
we set this to date value, let's say 
2019, March 1st, and then we type 
out a condition, with this condition we identify 
the record or the records that need to be updated. In this case we want to
update the invoice number 1. So, 
back to our query, we type out invoice id 
equal to 1. Let's execute this. Beautiful, 
Now back to our table, let's refresh the data by clicking on this icon. 
Alright, we can see that payment total is updated to ten. 
And we also have a payment date. Beautiful. Now lets say we actually 
updated the wrong record, maybe we should have updated invoice 
number 3, so we should update this table one more time, and restore the 
original values in this column, back to our query 
we can set the payment total to 0, and 
the payment date to null. So we can use the null
keyword to insert the null value in a column that accepts 
null values. Now back to the navigator panel, let's open the 
table in the design mode. We can see that the payment total column 
has a default value of 0, and the payment date column 
has the default value of null. So back in our query 
we can also set payment total tod default and MySQL 
will use the default value for this column, which is in this case 0. 
So, let's execute this statement one more time, beautiful. 
Now, back to the table, let's refresh the data, so payment total is set
to 0. And payment date is null. Beautiful. 
Now let's go ahead and update the third payment. Look at the
invoice total. That is $147. For this example let's 
imagine that the client made 50% of the total 
amount on the due date. So, back to our query 
editor window, instead of using a literal value window here like $70
we can write an expression, we want to calculate 50%
of invoice total. So invoice total, 
x 0.5. Now let me break this code into multiple 
lines so we can see clearly, now we should 
set the payment date, as I told you this client made the payment 
on the due date, so we can set this to due date. 
Whatever value we have in this column will be used to set the payment date. 
Now obviously we need to update the invoice id, 
number 3, now back in the table, let's refresh the data. 
Alright look, payment total is updated, and it's set
to almost 50% of he invoice total. However, 
this number is truncated so we don't have the digits after the decimal point. 
Don't worry about it for now, we'll come back to this when we talk about data points 
later in the course. Also we can see that payment date is set 
to the same value we have in the due date column. 
In the last tutorial we learned how to update a single record using the updates
statement. Now if you want to update multiple records, the syntax is 
exactly the same, but the condition you type out here, has to be more general. 
For example, back to the invoices table, you can see that we have multiple 
invoices for client number 3. You can write a statement 
to update all the invoices for this client. So back to our
query editor window, we change our condition to, 
where client id equals 3. However, if 
you execute this statement with MySQL workbench which is the software we've been using 
in this course, you're going to get an error, because by default, MySQL workbench 
runs in the safe update mode. So it allows you to update only 
a single record. You're not going to have this problem if you use another client for 
MySQL or if you write this statement in your application code 
this is only specific for MySQL workbench. Now
let me show you how to get around this. On the top we go to
MySQl workbench menu and then preface this. 
On this dial up box, on the left side, click on SQL editor 
and then down on the bottom, 
untick this checkbox, save updates, so this 
prevents you from accidentally updating or deleting a bunch of records in a table, 
so let's goa head with this, now we need to 
reconnect to this instance of MySQL. So, let's copy 
all the code here, and close this local instance 
window. Alright? Now, on the home page, double click this
connection to reconnect, there you go, and then paste 
all that Sql code. Now let's 
execute this, beautiful, all the invoices for client number 3 are updated. 
Here we can also use the in operator, let's say 
we want to update all the invoices for clients number 3 and number 4. 
So all the operators you learned to use in the where clause also 
apply here. Now technically this where clause is optional, so if you want 
to update all the records in a table, you simply leave it out. 
Alright here's your exercise for this tutorial. Back to our SQL store database, 
write a SQL statement to give any customers, 
born before 1990, 15 extra points. 
Alright first we're going to use SQL 
store, then, write an update statement. To update the customers table, 
set the points to point 
plus 15, so here we're using the expression to update 
the points column, for anyone born before 
1990. So where birth date is less then 
1990, January 1st. 
Alright, let's execute this query, alright, now 
let's open up the customers table one more time, 
so anyone who was born before 1990 now has an extra 
50 points. 
In this tutorial we're going to learn how to 
use subqueries in an update statement, it's extemely powerful, 
so we're going to continue with the example from the last tutorial, but we're going to
make it more interesting. Here we're updating all the invoices for 
client number 3, but what if we don't have the id of the client? We only have the
name? For example, you might even have an application, and in that application
the user types in the name of the client, so first we should find the 
id for that client, and then use that id to update all the invoices. 
How do we do that? Well, let's have a quick look at our clients 
table, so here we have this client 
my words, let's say you have the name, you want to find the id. 
So back to our query window. After our update statement 
I'm going to write the select statement to select the client id column, 
from the clients table, where name equals 
my works. Now here we have 
a syntax error, because we didn't terminate the last 
don't worry about that, we're going to get back to that in a second. Let's just select these few lines and 
execute this query. The idea of this client is 
2. Beautiful. Now we can use this select statement as 
a subquery in a update statement. So as I told you before, 
a subquery is a select statement that is within another SQL 
statement. So, instead of hard coding 3 here, 
we're going to use this select statement as a subquery, but 
we need to put it in parenthesis, so MySQL will 
execute this query first, it will return the client ID and then
use it in this condition. So for clarity 
let's remove the line break and indent 
these few lines. So this is the end result. Now 
we execute this query, and this updated all the invoices for this client. 
Now, what if this query returns multiple clients? 
For example, back to the clients table, let's imagine you want to update 
the invoices for all clients located in New York or California. 
So, we need to update our subquery, 
like this, where state 
in California, and 
New York. Now before executing the entire statement, 
let's just select our subquery and execute it to see what we get. 
So we get two client ID's, one and 
three, beautiful, now because this query, this subquery 
returns mutliple records, we cannot use an equal sign 
here anymore, so we need to replace this with an in operator. 
And now this statement updates the invoices for all the clients 
located in these two statements. Let's execute it, 
beautiful, everything worked. So as a best practice, before executing your 
update statement, run your query to see what records you're going to update. So you don't 
accidentally update the records that shouldn't be updated. Now here we 
have a subquery but even if we didn't have a subquery, you could still
query the records that we're going to update. Let me show you. So let's imagine 
we're going to update all the invoices where payment 
date is null. Before executing this entire update 
statement, I would run a query like this. Select, start 
I would start from invoices where payment date is null. 
Now let's execute this query, 
these are the two records that don't have payment date, so once we're confident that
we're updating the right records, then, we come back here, 
and get rid of this select statement, and just attach the where clause 
to our update statement. 
Alright, here's your 
exercise for this tutorial, back to our SQL store database, look at the 
orders table, as you can see, several orders don't have a 
comment, I want you to write a SQL statement to update the comments or orders
for customers who have more then 3000 points. 
So customers who have more then 3000 points, regard
them as gold customers. Find their orders, if they have placed an order
update the comments column and set it to gold customer. 
That's a really good exercise. 
Alright, first we need to find 
the gold customers, so select everything from the customers table, 
where points is greater then 3000. 
And by the way, because current database is SQL invoice 
we either have to type out a use statement on the top, or 
double click this database before executing this query. So, 
there you go. We have three gold customers 
now we need to get the ID of these customers to use them in an update 
statement. So, we only select customers 
Id here and then select this statement as a subquery 
in an update statement. So, 
update, orders, set comments to 
gold customer, where 
customer id because we're dealing with multiple customer id's 
we need to use the in operator and then to use it, 
as a subquery, we need to enclose it in parenthesis. 
Let's indent the code, that's better, so here 
is the final solution. 
So you have learned how to insert and update data, in this lecture, we're going to finish this section 
by learning how to delete data. That is very easy. We use the delete 
from statement to delete records from a table. 
Let's say the invoices table. Now optionally we can add a search condition 
to identify the records we want to delete. If you don't write
this where clause with this statement, we delete all the records in this table. 
And obviously, that's very dangerous, so be very careful when executing this
statement. Now here let's say we want to delete the invoice 
with the id 1, so where invoice id goes to 1. 
Now here we can also use subqueries, let's say we want to delete all the invoices for 
the client called my works. First let's 
find this client, so select everything from the client's table 
where name equals to my works. 
Let's execute the second query, so
here's our client,  now we can get this client 
id and use it in our search condition. So where 
client id equals 2, this is where we add
our subquery, there you go, just like before, 
beautiful. So this is how we can delete data, 
in SQL. 
Alright, we're done with this section, but before going to the next section, I want you to
restore all these databases to their original state. Because in this section we 
added some data, we updated some data, we deleted some records, 
so if you don't restore these databases you may see different results going forward. 
So, restoring these databases is pretty easy. Here in My
SQL workbench, on the top go to the file menu 
and open SQL script. Then navigate to the directory 
where you stored the SQL scripts for this course, in case you lost 
that directory, go back to the first section, you have a lecture for downloading the
supplementary materials. So in this directory open 
create databases.SQL. 
Now execute this script to recreate all of our databases. 
Alright, beautiful, now let's open up the navigator panel, you can see the 
databases disappear from here, simply click on this refresh icon. 
Beautiful. Alright, we're done with this section, I will see you in the next 
section. Hey guys, Mosh here, 
in case you haven't seen my website yet, head over to codewithmosh
.com. This is my coding school where you can find plenty of courses 
on web and mobile application development. In fact recently I 
published a complete SQL course that is about 10 hours long, 
and it teaches you everything you need to know from the basic to advanced topics
such as database design, security, writing complex queries, 
transactions, events and much, much more. These are the topics 
that every software engineer must master. This Youtube 
course you've been watching is the first three hours of my complete SQL
course that is about 10 hours long. So if you want to master SQL 
and get job ready, I highly encourage you to get involved in my complete 
SQL course. You can watch it anytime, anywhere, as many times as you
want, you can watch it online or download the videos. The course comes with 
a 30 day money back guarantee and a certificate of completion 
that you can add to your resume. The price for this course is $149
but the first 200 students can get it for just
over $100. So if you're interseted, the link is below this video. 
