All language subtitles for sql-720p-en

DOUG LLOYD: So in our videos on web development,

we've talked a couple of times now about what a database is.

And in this video, we're going to get into a bit more detail

and show you exactly what a database is, why we would use it,

and how we might manipulate it.

In order for us to build websites that are sort of more complex than just

a page where they just go and see news, for example,

we might need a database to store information,

such as username and password combinations

so that a user attempts to log in.

That log-in information is sent to the database.

It is checked against information in the database

to see whether that username-password combination matches.

And if so, it lets the user in.

We might also store other stuff for users, like their shopping history

or really any other information that you might

want to keep long-term for a user.

Now, if you ever used programs like Microsoft Excel or Google Sheets

or Numbers, you're probably familiar with the basic idea of a database.

A database consists of a couple of different levels of hierarchy.

Within a database, we have tables.

And within each of those tables, we have rows and columns.

And if you are familiar with Excel, or perhaps even if you're not,

let's take a quick second and I can draw this analogy for you

about what a database, a table, a row, a column is.

And then we can translate that in just a moment to the same idea in SQL.

So on my screen here, I've opened up an Excel file.

And across the top here, you see I have these letters--

A, B, C, D, E. These would be different columns in my file.

Down the left side, I have numbered rows, where I might put information.

So, for example, I might just put my name here in cell A1.

So it's in the A column in the first row.

Now, down at the bottom left is a feature

that you may not have used too much if you don't use Excel very frequently.

But there's these notions of sheets.

Sheets are sort of akin to different tables.

Notice that when I switch to sheet 2, the data that was in sheet 1, my name,

is no longer there.

So each sheet has its own unique set of rows and columns.

But all of these sheets are still bound up in one single file called Book 1.

So the analogy here is that Book 1 is our database, which

contains a different number of tables, which in Excel parlance

is just a sheet.

And each sheet has columns that we can put data in

and rows that we can put data in, as well.

So there are a couple of different types of database engines

that we can use in our programs.

We're going to talk about SQL, S-Q-L, which stands for the Structured Query

Language.

The Structure Query Language is a programming language

whose sole purpose in life is to query or ask questions of or retrieve data

from a database.

And there are many different implementations of SQL.

Two of the most popular are as follows-- we have

MySQL which is an open-source platform.

It is very commonly used to establish relational databases.

We're not going to get into a lot of detail

in this video about what a relational database is

versus other types of database.

But just know that there are more than one type,

and we cover relational databases in this course.

Another type, which we actually have used in CS50 since 2016,

is SQLite, which has a very similar feature set to MySQL.

But it's just a little more lightweight.

It's a little easier to use on CS50 IDE.

And so that's why we're actually going to be using that one in the class.

Now, regardless of which implementation of SQL that you use, a lot of them

will come with a tool called phpMyAdmin, which is a GUI or Graphical User

Interface tool that is used to execute some

of the more tedious or mundane database queries in a more user-m friendly way

because you can just click and do things in the web browser.

And those are most commonly used to build databases in the first place

and to set up tables because that's the first thing you're

going to do once you get your database configured, is to create a table.

Because without a table, we have no rows and columns.

And without rows and columns, we can't store any data.

Tables have very cumbersome syntax that is used to set them up.

And so using phpMyAdmin, the graphical interface, to build your table

is definitely gonna come in handy.

In the process of building your table, you're

going to have to specify exactly which columns

are going to be stored in that table.

So at the very beginning, when you create your table, you say,

my table's going to store usernames and passwords

and whatever sort of other information you want.

and you have to specify that before you have inserted any data into the table.

So you have to design ahead of time what your table is going to look like.

Once you've done that, pretty much every query except for, like,

deleting the database and deleting the table

that you're going to use on that table going forward

is going to refer to data which is stored

in the different rows of the table.

Just like in C, every column of our SQL table

is capable of holding data of different data types.

So in C, for example, we had characters and strings and integers and floats.

And SQL has a few more data types than that.

This is just 20 of them, and this is not even an exhaustive list.

But some of these things should look familiar.

So, for example, we have int, which can store integers.

But we also have these four other types, which can hold integers

with different upper bounds.

So you may recall from C that the upper bound of integer

is 2 to the 31st power, or 2 to the 32nd power if they're unsigned integers.

But here we can say small ints or tiny ints

or medium or big ints, each of which have

different upper bounds on the values.

Decimal and float stand in place of double and float,

which we're familiar with from C. We can also store date and time stamps

in SQL databases.

There's no data type for that that's native to C.

But in SQL, there are a couple of different ways to do this.

We can even do more exotic things like store geometry or line strings.

And what are these?

Well, geometry and line strings can be used to store in a SQL database

a mapping out or a drawing out of an area on a map, such as using GIS data.

And we can actually store that in our SQL table

and recreate that exact drawing a little bit later on.

Text sort of stands in the stead of strings

for just arbitrarily large chunks of text.

Enums are also a type that exists in C, but we don't talk about them too much

in C. But really quickly, what an enum is is it is a column of your table

that can be used to store a limited set of values.

So, for example, I could have an enum that is called,

like, favorite colors, for example.

And I could specify when I'm building my table

that it can only be capable of holding red, green, and blue.

If you tried to insert a row that had purple in that place,

that wouldn't work because it is not one of the enumerated values that

can be stored in that column.

There are also char and varchar.

And these are not quite the same as what you might think they are in C.

So let's just take a quick second to explain

the difference between these two data types, which are pretty important.

So unlike in C, char does not refer to a single character.

It is actually sort of akin to our notion of a string,

but with a caveat that that string is a fixed length.

And typically when we specify a char or a varchar type,

we have to specify the length of that string at the outset,

just like we do in c.

So, for example, my column type might be a char 10.

That means that I can store 10 character strings

in that column of my table, exactly 10 character strings.

So if I tried to store, for example, the word

"hi," H-I, which is just two letters, that would go into the column OK.

But it would also store 8 extra--

the equivalent of null bytes, basically, so that I still had 10 characters,

per se, in that column for that row.

And if I tried to store, like, a 15-character string,

that wouldn't work.

I'd only end up storing the first 10 letters.

So it's always going to be 10, every time.

A varchar, on the other hand, refers to a variable-length string.

So if I said that my column was varchar 99,

I can store 1, 2, 3, 4, 5 character strings, up to 99 characters

long, without having to have all of this extra sort of slack space

or null bytes or zeros tacked onto the end.

So char, fixed-length strings.

Varchar, variable-length strings.

We won't get into the difference between why

you might want to use one or the other.

But there are reasons why you might not always want to use a varchar,

and you might want to use a char in some situations.

Now, SQLite actually has many or all of these same data types.

But the difference there is that each of those data types

is affiliated with what's called a type affinity to simplify things.

So that whole list of 20--

or more, really-- can be reduced to one of these five different affinities--

null, integer, real, text, and blob.

Null is probably pretty obvious-- nothing.

Integer-- whole numbers.

Real-- that would include things like decimal and float.

Text would include things like char and varchar.

Blob is just-- that would be more like the geometry or data that isn't really

text, but it's just a large number of bits or bytes.

That would be a blob.

And everything can reduce to one of these five different type affinities.

So after specifying the columns, it's also really important in our SQL table

to have one other consideration, which is to have

one column which is our primary key.

Why do we need a primary key?

The reason is every row of our table, in order

to make our SQL queries most effective, should be able to be uniquely

and quickly identified.

So choosing the right primary key will allow

us to make sure that there is one value in every row that is completely unique.

And if that is true, if there is one column in every row that's unique,

then we can uniquely identify or very quickly identify

which row we're talking about.

Now, it's also possible to establish a joint primary key,

which is just a combination of, say, two columns--

but it can be an arbitrarily large number of columns--

that is always guaranteed to be unique.

So I could have one column that could always have A's or B's or C's.

I could have another column that has ones and twos and threes and fours.

I could have multiple A's and multiple B's and multiple C's, multiple ones,

twos, and threes.

But across all of those rows, I'm only ever allowed

to have 1 combination of A1.

I can have B1, C1.

I can have A2, A3, A4.

But there's only ever one combination of those two columns that is unique.

That would also be acceptable because that is a joint primary key.

Now, SQL is a programming language, like other programming languages

that we've discussed.

But it has a very limited vocabulary.

Now, there are more things that you can do with SQL than we're

going to talk about in this video because in this video

we're just going to talk about the four operations

that one can perform on a table, or the four main operations that you'll

most likely perform on the table--

INSERT, SELECT, UPDATE, and DELETE.

And these four things we'll get into a bit more detail in just a second about.

But these are definitely the most common four things

you'll be doing with the tables that you're building,

certainly in CS50, but also probably more generally whenever you're

working with databases.

So for all of the examples that we're going to cover in this video,

we're going to consider a database that contains

these two tables called users and moms.

And you can see users has four different columns-- idnum, username, password,

and fullname.

And moms has two different columns, username and mother.

And let's now start to work with these and see

how we can manipulate this database and the tables within it to--

for whatever reason we need them to-- be updated in our website.

So the first operation we'll cover is insert.

And as you might expect, it adds information to a table.

Now, SQL queries have a certain structure to them.

And so with each of these operations, what I'm going to do

is give you the general sort of skeleton of what a query might look like.

And then we'll use a couple of examples of that query

to see how it affects our table.

So an insert query, in general, looks something like this--

INSERT INTO table.

So we specify what table we want to insert into.

And then we have parentheses, columns-- which

is a comma-separated list of all of the columns of our table

that we want to insert data into.

Then we have VALUES, and then a comma-separated list of the values

that we want to put into those columns in the same order.

So for example, I might want to INSERT INTO users into these three columns--

username, password, name.

The values, respectively-- newman, in lowercase, USMAIL--

that's going to be corresponding to the password--

and then capital-N Newman for fullname.

So assuming that I execute this query on the users table shown here,

what's going to happen?

Well, this is what's going to happen.

We're going to add this row because we inserted into the users table.

But you might be asking yourself, wait a minute.

You never specified ID number.

So how exactly did ID number get there?

I mean, you specified newman and USMAIL and Newman.

But that 12, that was never part of our query.

And you're right.

Because when you define the column that ultimately ends up

being your table's primary key, it's usually a good idea

to have that column be an integer.

It's not a requirement, but it's usually a good idea.

And because having a primary key is so important,

you might want to specify it to autoincrement.

And what this basically means is you can forget

to include it as part of your query.

And if you do, it will automatically insert a value there

that is unique from every other value in that column,

typically by just incrementing by one every time,

so that that row is still guaranteed to be unique.

Because if it wasn't set to autoincrement

and we just forgot to omit it, there might

be a couple of rows that are actually blank or null there.

But if that's our primary key, if ID number is our primary key,

and we have a couple of rows that are blank there, now they're not unique.

We have two rows that are blank.

We can't uniquely identify them.

And so when you set up your primary key, you usually want it to be an integer,

and you usually want it to autoincrement so that you can completely

forget about having to worry about that and let the table do it for you.

So that's how 12 got there.

I had specified my idnum column do autoincrement every time I

make an insert into the table.

Let's do this another time.

Let's insert into the other table, insert into the moms table,

the following values into these following columns.

We can INSERT INTO the username and mother columns of the users table

the VALUES kramer and Babs Kramer.

And just like what we saw before, this is what we would have as a result.

We would just insert that row, and it would now

be part of our database and part of our tables.

So that's the insert operation.

Now let's talk about the second operation, which is select.

So if insert is used to put information into a table,

select is used to get that information back out of the table

so that we can do something with it.

Select queries also have a very similar skeleton.

And they look like this--

SELECT and then whatever columns you want

to choose FROM whichever table you want to choose them from.

And then optionally in red here, these two other things--

WHERE some condition is satisfied.

And we usually, in the context of SQL, refer to a condition as a predicate.

But basically, we're just checking to see that some situation is true.

And we might want to, for example, order them by a specific column so

that they are organized alphabetically by the values in some column

or whatever else.

We don't have to do either WHERE or ORDER BY.

But generally WHERE in particular is going

to be used so that you don't get your entire database back.

And ORDER BY just helps to keep things a little more organized.

So, for example, here's a select query that we could use--

SELECT idnum, fullname from the users table.

So let's see what's going to happen here.

So remember, I'm selecting idnum and fullname from the users table.

Well, what is the select query going to return to me?

This information here.

It's going to look at each row of the table,

and it's going to just pull out the ID number and the full name

and give me all of those down the entire users table.

My user table only consists of three rows,

so it's given me three pairs of information,

three idnum-fullname combinations.

Now let's say I want to restrict my search

a little bit, my query a little bit.

SELECT password FROM users WHERE idnum is less than 12.

So now I'm adding a predicate or a condition to my select query.

What's going to happen here?

Well, I'm going to get this information.

This is just the password column from the users table

where the ID number in that row is less than 12.

So only rows 10 and 11's password get given back to me.

12's does not because 12 is not less than 12.

There's one other thing we can do with a select query, and that's to select *.

SELECT * from moms where username equals jerry.

* is just shorthand for every column.

So instead of having to specify username, mother, the two columns here,

or, if I was using the users table, having to specify idnum,

username, password, fullname, I can just say SELECT *.

Give me everything in that row.

And if I SELECT * from moms where username equals jerry,

I am given this set of information back.

So here's the thing that's cool about databases,

though-- we don't have to just have two tables.

And in particular, we don't have to have just one

table that stores every relevant piece of information about a user.

If we wanted to store, in addition to what we have there, information

like their address and their date of birth and their social security number

or whatever else we wanted to keep about them,

this table could get bigger and bigger and bigger and bigger

to the point where it becomes almost annoying to have to use it.

But we can use relationships between different tables.

And that's where the term relational comes

into play for a relational database.

We can set up our tables within our databases

carefully enough that we can use relationships between them

to pull information from where we need it without all that information having

to be located in the same table in the first place.

So, for example, here is our database as we last left it, with three rows

in each of the users and the moms tables.

Now let's imagine a hypothetical situation

where we want to pair a user's full name, which is currently only stored

in the users table, with their mother's name, which

is only stored in the mother table.

They're not on the same table right now.

So we can't use the same sort of select query that we used before.

We have to use what's called a select join query.

It looks pretty similar to the select query before.

But we're adding one extra piece of information, which

is what tables we're joining together.

So I want to select a specific set of columns from one table,

joining another table onto it just temporarily.

It doesn't really merge them.

But it creates this sort of hypothetical table that does merge them.

On predicate, where predicate is-- basically,

we're trying to find where the two tables overlap

so that we can create this merged table just temporarily

for purposes of this query, and then have them separate again.

So, for example, I might have a query that looks like this--

SELECT users.fullname, comma, moms.mother FROM users joining the moms

table onto it temporarily ON--

which is akin to WHERE--

users.username equals moms.username.

And this syntax is also a little unfamiliar, right?

I'm now prepending some of my column names with table names.

The reason I'm doing this is particularly because of the last line

there, where in each of those two tables I had a column called username.

I need to disambiguate between them.

So I need to specify what table and what column.

That's all that's happening here, is I'm being very explicit about which column

I want by specifying not only the column name, but also the table name.

So here is what would happen if I executed this select query.

Here are our two tables at the outset.

This is all of the information that I'm trying to get to start with.

I'm going to join these two tables together where where users.username

equals moms.username.

Newman does not appear in both tables.

So I'm not going to even come close to extracting that piece of information.

Kramer does not appear in both tables, so that one's out too.

But jerry and gcostanza both appear in both tables.

And so that is sort of the overlap point.

And you can think about this as if we have

our users table, which is like one circle over here,

and our moms table, which is one circle over here.

When we're joining, it's sort of like if it's a Venn diagram.

We're trying to figure out what those two tables have in common

and using that as, like, our anchor point for the join tables.

So that's what we did here.

We found where the two tables have data in common.

And based on that, we create this hypothetical table

called users & moms that contains all of the information that

appears in both of those tables.

But notice that the second column there sort of indicates the overlap.

This column refers to data that is in both users.username and moms.username.

So that's what we're extracting here.

But remember that this query, we didn't want everything.

It wasn't SELECT * FROM users JOIN moms WHERE users.username equals

moms.username.

Username We just want the full name and the mother's name.

And so that's what we extract.

And so that really long query just results

in us getting this set of information-- users.fullname and moms.mother

for every row in both tables where the username happens to be the same.

All right.

So that was a bit more complicated.

You probably won't do too many joins.

Fortunately, the last two operations are a little bit easier.

So update is the third of the four major operations.

This is what we use to modify information in the table

or change it or update information.

The skeleton looks like this--

UPDATE table SET column equals value-- so we're updating some column to have

a new piece of data in it--

WHERE predicates.

We're trying to figure out which row we want to update,

and then we're updating that column.

So, for example, I want to UPDATE users SET password equals

yadayada WHERE idnum equals 10.

You can probably guess what's going to happen here.

We're going to find the row whose ID number is 10,

and we're going update the password there from "fusilli" to "yadayada."

Pretty straightforward.

And the fourth and final operation that we do in SQL

most commonly is to delete, which strikes or completely removes

information from a table.

The basic framework looks something like this--

DELETE from some table WHERE predicate, or, again,

where some condition is satisfied.

So, for example, you might want to DELETE from our users table WHERE

the user name equals 'newman.'

Now, if we did that, and this was our table to start with,

you can probably guess what's going to happen.

After that query executes, the row whose username is newman

is no longer in our table.

Now, all of the operations that we just showed

are really easy to do in the graphical interface of phpMyAdmin,

which, again, comes with most implementations of SQL

that you might download.

Here's the catch, though-- phpMyAdmin, despite being

very user-friendly to use, requires manual intervention.

You're going to have to log in and click on some buttons

to delete information or update it or change it.

And we don't want to do that.

We're a webmaster, right?

We want things to happen automatically for us.

We want programs that we write to make those changes for us.

So we don't want to go into phpMyAdmin and make those changes.

We have to write code that does it for us.

Fortunately, SQL integrates really nicely

with a lot of modern programming languages such as Python or PHP

that have functions that you can use to connect to your database.

And then the programming language has other functions

that will query the database for you and make those changes.

Now, we're going to leave off for now exactly how those languages do that.

We'll save that for a video on those languages themselves.

But know that that is something that you can

do to avoid having to do any sort of manual intervention

when you want to update or do any sort of operation at all on your databases.

My name is Doug Lloyd.

This is CS50.