SQL CREATE DATABASE Statement

Syntax
CREATE DATABASE databasename;
Example
CREATE DATABASE testDB;

SQL DROP DATABASE Statement

Syntax
DROP DATABASE databasename;
Example
DROP DATABASE testDB;

SQL CREATE TABLE Statement

Syntax
CREATE TABLE table_name (
column1 datatype,
column2 datatype,
column3 datatype,
....
);

Example
CREATE TABLE Persons (
PersonID int,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);

SQL DROP TABLE Statement

Syntax
DROP TABLE table_name;
Example
DROP TABLE Shippers;
SQL TRUNCATE TABLE
The TRUNCATE TABLE statement is used to delete the data inside a
table, but not the table itself.
Syntax
TRUNCATE TABLE table_name;

SQL ALTER TABLE Statement

 SQL ALTER TABLE Statement
The ALTER TABLE statement is used to add, delete, or modify columns
in an existing table.

The ALTER TABLE statement is also used to add and drop various
constraints on an existing table.

 ALTER TABLE - ADD Column

To add a column in a table, use the following syntax:

ALTER TABLE table_name

ADD column_name datatype;
 ALTER TABLE - DROP COLUMN
To delete a column in a table, use the following syntax (notice that
some database systems don't allow deleting a column):

ALTER TABLE table_name

DROP COLUMN column_name;
 ALTER TABLE - ALTER/MODIFY COLUMN
To change the data type of a column in a table, use the following
syntax:

 SQL Server / MS Access:

ALTER TABLE table_name

ALTER COLUMN column_name datatype;
 My SQL / Oracle (prior version 10G):

ALTER TABLE table_name

MODIFY COLUMN column_name datatype;
 Oracle 10G and later:

ALTER TABLE table_name

MODIFY column_name datatype;

SQL Constraints
SQL constraints are used to specify rules for data in a table.

SQL Create Constraints

Constraints can be specified when the table is created with the
CREATE TABLE statement, or after the table is created with the ALTER
TABLE statement.

Syntax
CREATE TABLE table_name (
column1 datatype constraint,
column2 datatype constraint,
column3 datatype constraint,
....
);
SQL Constraints
SQL constraints are used to specify rules for the data in a table.

Constraints are used to limit the type of data that can go into a
table. This ensures the accuracy and reliability of the data in the
table. If there is any violation between the constraint and the data
action, the action is aborted.

Constraints can be column level or table level. Column level

constraints apply to a column, and table level constraints apply to
the whole table.

The following constraints are commonly used in SQL:

NOT NULL - Ensures that a column cannot have a NULL value

UNIQUE - Ensures that all values in a column are different
PRIMARY KEY - A combination of a NOT NULL and UNIQUE. Uniquely
identifies each row in a table
FOREIGN KEY - Uniquely identifies a row/record in another table
CHECK - Ensures that all values in a column satisfies a specific
condition
DEFAULT - Sets a default value for a column when no value is
specified
INDEX - Used to create and retrieve data from the database very
quickly

SQL NOT NULL Constraint

SQL NOT NULL Constraint

By default, a column can hold NULL values.

The NOT NULL constraint enforces a column to NOT accept NULL values.

This enforces a field to always contain a value, which means that

you cannot insert a new record, or update a record without adding a
value to this field.

The following SQL ensures that the "ID", "LastName", and "FirstName"
columns will NOT accept NULL values:

Example
CREATE TABLE Persons (
ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255) NOT NULL,
Age int
);

SQL UNIQUE Constraint

SQL UNIQUE Constraint
The UNIQUE constraint ensures that all values in a column are
different.

Both the UNIQUE and PRIMARY KEY constraints provide a guarantee for
uniqueness for a column or set of columns.

A PRIMARY KEY constraint automatically has a UNIQUE constraint.

However, you can have many UNIQUE constraints per table, but only
one PRIMARY KEY constraint per table.

SQL UNIQUE Constraint on CREATE TABLE

The following SQL creates a UNIQUE constraint on the "ID" column
when the "Persons" table is created:

SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL UNIQUE,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int
);
MySQL:

CREATE TABLE Persons (

 ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
UNIQUE (ID)
);
To name a UNIQUE constraint, and to define a UNIQUE constraint on
multiple columns, use the following SQL syntax:

MySQL / SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
CONSTRAINT UC_Person UNIQUE (ID,LastName)
);

SQL UNIQUE Constraint on ALTER TABLE

To create a UNIQUE constraint on the "ID" column when the table is
already created, use the following SQL:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD UNIQUE (ID);
To name a UNIQUE constraint, and to define a UNIQUE constraint on
multiple columns, use the following SQL syntax:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD CONSTRAINT UC_Person UNIQUE (ID,LastName);
DROP a UNIQUE Constraint
To drop a UNIQUE constraint, use the following SQL:

MySQL:

ALTER TABLE Persons

DROP INDEX UC_Person;
SQL Server / Oracle / MS Access:

ALTER TABLE Persons

DROP CONSTRAINT UC_Person;

SQL UNIQUE Constraint

❮ PreviousNext ❯
SQL UNIQUE Constraint
The UNIQUE constraint ensures that all values in a column are
different.

Both the UNIQUE and PRIMARY KEY constraints provide a guarantee for
uniqueness for a column or set of columns.

A PRIMARY KEY constraint automatically has a UNIQUE constraint.

However, you can have many UNIQUE constraints per table, but only
one PRIMARY KEY constraint per table.

SQL UNIQUE Constraint on CREATE TABLE

The following SQL creates a UNIQUE constraint on the "ID" column
when the "Persons" table is created:

SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL UNIQUE,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int
);
MySQL:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
UNIQUE (ID)
);
To name a UNIQUE constraint, and to define a UNIQUE constraint on
multiple columns, use the following SQL syntax:

MySQL / SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
CONSTRAINT UC_Person UNIQUE (ID,LastName)
);

SQL UNIQUE Constraint on ALTER TABLE

To create a UNIQUE constraint on the "ID" column when the table is
already created, use the following SQL:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD UNIQUE (ID);
To name a UNIQUE constraint, and to define a UNIQUE constraint on
multiple columns, use the following SQL syntax:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD CONSTRAINT UC_Person UNIQUE (ID,LastName);
DROP a UNIQUE Constraint
To drop a UNIQUE constraint, use the following SQL:

MySQL:

ALTER TABLE Persons

DROP INDEX UC_Person;
SQL Server / Oracle / MS Access:

ALTER TABLE Persons

DROP CONSTRAINT UC_Person;

SQL PRIMARY KEY Constraint

SQL PRIMARY KEY Constraint
The PRIMARY KEY constraint uniquely identifies each record in a
database table.

Primary keys must contain UNIQUE values, and cannot contain NULL
values.

A table can have only one primary key, which may consist of single
or multiple fields.

 SQL PRIMARY KEY on CREATE TABLE

The following SQL creates a PRIMARY KEY on the "ID" column when the
"Persons" table is created:

MySQL:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
PRIMARY KEY (ID)
);
SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL PRIMARY KEY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int
);
To allow naming of a PRIMARY KEY constraint, and for defining a
PRIMARY KEY constraint on multiple columns, use the following SQL
syntax:

MySQL / SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
CONSTRAINT PK_Person PRIMARY KEY (ID,LastName)
);
Note: In the example above there is only ONE PRIMARY KEY
(PK_Person). However, the VALUE of the primary key is made up of TWO
COLUMNS (ID + LastName).

 SQL PRIMARY KEY on ALTER TABLE

To create a PRIMARY KEY constraint on the "ID" column when the table
is already created, use the following SQL:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD PRIMARY KEY (ID);
To allow naming of a PRIMARY KEY constraint, and for defining a
PRIMARY KEY constraint on multiple columns, use the following SQL
syntax:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD CONSTRAINT PK_Person PRIMARY KEY (ID,LastName);
Note: If you use the ALTER TABLE statement to add a primary key, the
primary key column(s) must already have been declared to not contain
NULL values (when the table was first created).

DROP a PRIMARY KEY Constraint

To drop a PRIMARY KEY constraint, use the following SQL:

MySQL:

ALTER TABLE Persons

DROP PRIMARY KEY;
SQL Server / Oracle / MS Access:

ALTER TABLE Persons

DROP CONSTRAINT PK_Person;

SQL FOREIGN KEY Constraint

SQL FOREIGN KEY Constraint
A FOREIGN KEY is a key used to link two tables together.

A FOREIGN KEY is a field (or collection of fields) in one table that

refers to the PRIMARY KEY in another table.

The table containing the foreign key is called the child table, and
the table containing the candidate key is called the referenced or
parent table.

Look at the following two tables:

"Persons" table:

PersonID LastName FirstName Age

1 Hansen Ola 30
2 Svendson Tove 23
3 Pettersen Kari 20
"Orders" table:

OrderID OrderNumber PersonID

1 77895 3
2 44678 3
3 22456 2
4 24562 1
Notice that the "PersonID" column in the "Orders" table points to
the "PersonID" column in the "Persons" table.

The "PersonID" column in the "Persons" table is the PRIMARY KEY in

the "Persons" table.

The "PersonID" column in the "Orders" table is a FOREIGN KEY in the

"Orders" table.

The FOREIGN KEY constraint is used to prevent actions that would

destroy links between tables.

The FOREIGN KEY constraint also prevents invalid data from being
inserted into the foreign key column, because it has to be one of
the values contained in the table it points to.

SQL FOREIGN KEY on CREATE TABLE

The following SQL creates a FOREIGN KEY on the "PersonID" column
when the "Orders" table is created:

MySQL:

CREATE TABLE Orders (

OrderID int NOT NULL,
OrderNumber int NOT NULL,
PersonID int,
PRIMARY KEY (OrderID),
FOREIGN KEY (PersonID) REFERENCES Persons(PersonID)
);
SQL Server / Oracle / MS Access:

CREATE TABLE Orders (

OrderID int NOT NULL PRIMARY KEY,
OrderNumber int NOT NULL,
PersonID int FOREIGN KEY REFERENCES Persons(PersonID)
);
To allow naming of a FOREIGN KEY constraint, and for defining a
FOREIGN KEY constraint on multiple columns, use the following SQL
syntax:

MySQL / SQL Server / Oracle / MS Access:

CREATE TABLE Orders (

OrderID int NOT NULL,
OrderNumber int NOT NULL,
PersonID int,
PRIMARY KEY (OrderID),
CONSTRAINT FK_PersonOrder FOREIGN KEY (PersonID)
REFERENCES Persons(PersonID)
);
SQL FOREIGN KEY on ALTER TABLE
To create a FOREIGN KEY constraint on the "PersonID" column when the
"Orders" table is already created, use the following SQL:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Orders

ADD FOREIGN KEY (PersonID) REFERENCES Persons(PersonID);
To allow naming of a FOREIGN KEY constraint, and for defining a
FOREIGN KEY constraint on multiple columns, use the following SQL
syntax:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Orders

ADD CONSTRAINT FK_PersonOrder
FOREIGN KEY (PersonID) REFERENCES Persons(PersonID);
DROP a FOREIGN KEY Constraint
To drop a FOREIGN KEY constraint, use the following SQL:

MySQL:

ALTER TABLE Orders

DROP FOREIGN KEY FK_PersonOrder;
SQL Server / Oracle / MS Access:

ALTER TABLE Orders

DROP CONSTRAINT FK_PersonOrder;

SQL CHECK Constraint

SQL CHECK Constraint
The CHECK constraint is used to limit the value range that can be
placed in a column.

If you define a CHECK constraint on a single column it allows only

certain values for this column.

If you define a CHECK constraint on a table it can limit the values

in certain columns based on values in other columns in the row.

 SQL CHECK on CREATE TABLE

The following SQL creates a CHECK constraint on the "Age" column
when the "Persons" table is created. The CHECK constraint ensures
that you can not have any person below 18 years:

MySQL:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
CHECK (Age>=18)
);
SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int CHECK (Age>=18)
);
To allow naming of a CHECK constraint, and for defining a CHECK
constraint on multiple columns, use the following SQL syntax:

MySQL / SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
City varchar(255),
CONSTRAINT CHK_Person CHECK (Age>=18 AND City='Sandnes')
);
  SQL CHECK on ALTER TABLE
To create a CHECK constraint on the "Age" column when the table is
already created, use the following SQL:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD CHECK (Age>=18);
To allow naming of a CHECK constraint, and for defining a CHECK
constraint on multiple columns, use the following SQL syntax:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD CONSTRAINT CHK_PersonAge CHECK (Age>=18 AND City='Sandnes');
DROP a CHECK Constraint
To drop a CHECK constraint, use the following SQL:

SQL Server / Oracle / MS Access:

ALTER TABLE Persons

DROP CONSTRAINT CHK_PersonAge;
MySQL:

ALTER TABLE Persons

DROP CHECK CHK_PersonAge;

SQL DEFAULT Constraint

SQL DEFAULT Constraint
The DEFAULT constraint is used to provide a default value for a
column.

The default value will be added to all new records IF no other value
is specified.

 SQL DEFAULT on CREATE TABLE

The following SQL sets a DEFAULT value for the "City" column when
the "Persons" table is created:

My SQL / SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
City varchar(255) DEFAULT 'Sandnes'
);
The DEFAULT constraint can also be used to insert system values, by
using functions like GETDATE():

CREATE TABLE Orders (

ID int NOT NULL,
OrderNumber int NOT NULL,
OrderDate date DEFAULT GETDATE()
);
 SQL DEFAULT on ALTER TABLE
To create a DEFAULT constraint on the "City" column when the table
is already created, use the following SQL:
MySQL:

ALTER TABLE Persons

ALTER City SET DEFAULT 'Sandnes';
SQL Server / MS Access:

ALTER TABLE Persons

ALTER COLUMN City SET DEFAULT 'Sandnes';
Oracle:

ALTER TABLE Persons

MODIFY City DEFAULT 'Sandnes';
DROP a DEFAULT Constraint
To drop a DEFAULT constraint, use the following SQL:

MySQL:

ALTER TABLE Persons

ALTER City DROP DEFAULT;
SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ALTER COLUMN City DROP DEFAULT;

SQL CREATE INDEX Statement

SQL CREATE INDEX Statement
The CREATE INDEX statement is used to create indexes in tables.

Indexes are used to retrieve data from the database very fast. The
users cannot see the indexes, they are just used to speed up
searches/queries.

Note: Updating a table with indexes takes more time than updating a
table without (because the indexes also need an update). So, only
create indexes on columns that will be frequently searched against.

CREATE INDEX Syntax

Creates an index on a table. Duplicate values are allowed:

CREATE INDEX index_name

ON table_name (column1, column2, ...);
CREATE UNIQUE INDEX Syntax
Creates a unique index on a table. Duplicate values are not allowed:

CREATE UNIQUE INDEX index_name

ON table_name (column1, column2, ...);
Note: The syntax for creating indexes varies among different
databases. Therefore: Check the syntax for creating indexes in your
database.

CREATE INDEX Example

The SQL statement below creates an index named "idx_lastname" on the
"LastName" column in the "Persons" table:

CREATE INDEX idx_lastname

ON Persons (LastName);
If you want to create an index on a combination of columns, you can
list the column names within the parentheses, separated by commas:

CREATE INDEX idx_pname

ON Persons (LastName, FirstName);
DROP INDEX Statement
The DROP INDEX statement is used to delete an index in a table.

MS Access:

DROP INDEX index_name ON table_name;

SQL Server:

DROP INDEX table_name.index_name;

DB2/Oracle:

DROP INDEX index_name;

MySQL:

ALTER TABLE table_name

DROP INDEX index_name;

SQL AUTO INCREMENT Field

AUTO INCREMENT Field
Auto-increment allows a unique number to be generated automatically
when a new record is inserted into a table.

Often this is the primary key field that we would like to be created
automatically every time a new record is inserted.

Syntax for MySQL

The following SQL statement defines the "ID" column to be an auto-
increment primary key field in the "Persons" table:

CREATE TABLE Persons (

ID int NOT NULL AUTO_INCREMENT,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
PRIMARY KEY (ID)
);
MySQL uses the AUTO_INCREMENT keyword to perform an auto-increment
feature.

By default, the starting value for AUTO_INCREMENT is 1, and it will

increment by 1 for each new record.

To let the AUTO_INCREMENT sequence start with another value, use the
following SQL statement:

ALTER TABLE Persons AUTO_INCREMENT=100;

To insert a new record into the "Persons" table, we will NOT have to
specify a value for the "ID" column (a unique value will be added
automatically):

INSERT INTO Persons (FirstName,LastName)

VALUES ('Lars','Monsen');
The SQL statement above would insert a new record into the "Persons"
table. The "ID" column would be assigned a unique value. The
"FirstName" column would be set to "Lars" and the "LastName" column
would be set to "Monsen".

Syntax for SQL Server

The following SQL statement defines the "ID" column to be an auto-
increment primary key field in the "Persons" table:

CREATE TABLE Persons (

ID int IDENTITY(1,1) PRIMARY KEY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int
);
The MS SQL Server uses the IDENTITY keyword to perform an auto-
increment feature.

In the example above, the starting value for IDENTITY is 1, and it

will increment by 1 for each new record.

Tip: To specify that the "ID" column should start at value 10 and
increment by 5, change it to IDENTITY(10,5).

To insert a new record into the "Persons" table, we will NOT have to
specify a value for the "ID" column (a unique value will be added
automatically):

INSERT INTO Persons (FirstName,LastName)

VALUES ('Lars','Monsen');
The SQL statement above would insert a new record into the "Persons"
table. The "ID" column would be assigned a unique value. The
"FirstName" column would be set to "Lars" and the "LastName" column
would be set to "Monsen".

Syntax for Access

The following SQL statement defines the "ID" column to be an auto-
increment primary key field in the "Persons" table:

CREATE TABLE Persons (

ID Integer PRIMARY KEY AUTOINCREMENT,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int
);
The MS Access uses the AUTOINCREMENT keyword to perform an auto-
increment feature.

By default, the starting value for AUTOINCREMENT is 1, and it will

increment by 1 for each new record.

Tip: To specify that the "ID" column should start at value 10 and
increment by 5, change the autoincrement to AUTOINCREMENT(10,5).

To insert a new record into the "Persons" table, we will NOT have to
specify a value for the "ID" column (a unique value will be added
automatically):

INSERT INTO Persons (FirstName,LastName)

VALUES ('Lars','Monsen');
The SQL statement above would insert a new record into the "Persons"
table. The "P_Id" column would be assigned a unique value. The
 "FirstName" column would be set to "Lars" and the "LastName" column
would be set to "Monsen".

Syntax for Oracle

In Oracle the code is a little bit more tricky.

You will have to create an auto-increment field with the sequence

object (this object generates a number sequence).

Use the following CREATE SEQUENCE syntax:

CREATE SEQUENCE seq_person

MINVALUE 1
START WITH 1
INCREMENT BY 1
CACHE 10;
The code above creates a sequence object called seq_person, that
starts with 1 and will increment by 1. It will also cache up to 10
values for performance. The cache option specifies how many sequence
values will be stored in memory for faster access.

To insert a new record into the "Persons" table, we will have to use
the nextval function (this function retrieves the next value from
seq_person sequence):

INSERT INTO Persons (ID,FirstName,LastName)

VALUES (seq_person.nextval,'Lars','Monsen');
The SQL statement above would insert a new record into the "Persons"
table. The "ID" column would be assigned the next number from the
seq_person sequence. The "FirstName" column would be set to "Lars"
and the "LastName" column would be set to "Monsen".

SQL INSERT INTO Statement

The SQL INSERT INTO Statement
The INSERT INTO statement is used to insert new records in a table.

INSERT INTO Syntax

It is possible to write the INSERT INTO statement in two ways.

The first way specifies both the column names and the values to be inserted:

INSERT INTO table_name (column1, column2, column3, ...)

VALUES (value1, value2, value3, ...);
If you are adding values for all the columns of the table, you do not need to
specify the column names in the SQL query. However, make sure the order of the
values is in the same order as the columns in the table. The INSERT INTO syntax
would be as follows:

INSERT INTO table_name

VALUES (value1, value2, value3, ...);
Demo Database
Below is a selection from the "Customers" table in the Northwind sample database:
CustomerID CustomerName ContactName Address City PostalCode Country
89 White Clover Karl Jablonski 305 - 14th Ave. S. Suite Seattle 98128 USA
Markets 3B
90 Wilman Kala Matti Keskuskatu 45 Helsinki 21240 Finland
Karttunen
91 Wolski Zbyszek ul. Filtrowa 68 Walla 01-012 Poland

INSERT INTO Example

The following SQL statement inserts a new record in the "Customers" table:

Example
INSERT INTO Customers (CustomerName, ContactName, Address, City, PostalCode,
Country)
VALUES ('Cardinal', 'Tom B. Erichsen', 'Skagen 21', 'Stavanger', '4006', 'Norway');
Try it Yourself »
The selection from the "Customers" table will now look like this:

CustomerID CustomerName ContactName Address City PostalCode Country

89 White Clover Karl Jablonski 305 - 14th Ave. S. Suite Seattle 98128 USA
Markets 3B
90 Wilman Kala Matti Keskuskatu 45 Helsinki 21240 Finland
Karttunen
91 Wolski Zbyszek ul. Filtrowa 68 Walla 01-012 Poland
92 Cardinal Tom B. Skagen 21 Stavanger 4006 Norway
Erichsen

Did you notice that we did not insert any number into the CustomerID field?
The CustomerID column is an auto-increment field and will be generated automatically
when a new record is inserted into the table.

Insert Data Only in Specified Columns

It is also possible to only insert data in specific columns.

The following SQL statement will insert a new record, but only insert data in the
"CustomerName", "City", and "Country" columns (CustomerID will be updated
automatically):

Example
INSERT INTO Customers (CustomerName, City, Country)
VALUES ('Cardinal', 'Stavanger', 'Norway');
Try it Yourself »
The selection from the "Customers" table will now look like this:

CustomerID CustomerName ContactName Address City PostalCode Country

89 White Clover Karl Jablonski 305 - 14th Ave. S. Suite Seattle 98128 USA
Markets 3B
90 Wilman Kala Matti Keskuskatu 45 Helsinki 21240 Finland
Karttunen
91 Wolski Zbyszek ul. Filtrowa 68 Walla 01-012 Poland
92 Cardinal Null Null Stavanger Null Norway

SQL NULL Values

What is a NULL Value?
A field with a NULL value is a field with no value.

If a field in a table is optional, it is possible to insert a new

record or update a record without adding a value to this field.
Then, the field will be saved with a NULL value.

Note: It is very important to understand that a NULL value is

different from a zero value or a field that contains spaces. A field
with a NULL value is one that has been left blank during record
creation!

How to Test for NULL Values?

It is not possible to test for NULL values with comparison
operators, such as =, <, or <>.

We will have to use the IS NULL and IS NOT NULL operators instead.

IS NULL Syntax
SELECT column_names
FROM table_name
WHERE column_name IS NULL;
IS NOT NULL Syntax
SELECT column_names
FROM table_name
WHERE column_name IS NOT NULL;
Demo Database
Assume we have the following "Persons" table:

ID LastName FirstName Address City

1 Doe John 542 W. 27th Street New York
2 Bloggs Joe London
3 Roe Jane New York
4 Smith John 110 Bishopsgate London
Suppose that the "Address" column in the "Persons" table is
optional. If a record is inserted with no value for "Address", the
"Address" column will be saved with a NULL value.

The IS NULL Operator

The following SQL statement uses the IS NULL operator to list all
persons that have no address:

SELECT LastName, FirstName, Address FROM Persons

WHERE Address IS NULL;
The result-set will look like this:

LastName FirstName Address

Bloggs Joe
Roe Jane
Tip: Always use IS NULL to look for NULL values.

The IS NOT NULL Operator

The following SQL statement uses the IS NOT NULL operator to list
all persons that do have an address:

SELECT LastName, FirstName, Address FROM Persons

WHERE Address IS NOT NULL;
The result-set will look like this:

LastName FirstName Address

Doe John 542 W. 27th Street
Smith John 110 Bishopsgate