SQL

(Michelle Calles)

What is SQL? Stands for structured Query Language. Lets you access and
manipulate databases.
Some of The Most Important SQL Commands

 SELECT - extracts data from a database

 UPDATE - updates data in a database
 DELETE - deletes data from a database
 INSERT INTO - inserts new data into a database
 CREATE DATABASE - creates a new database
 ALTER DATABASE - modifies a database
 CREATE TABLE - creates a new table
 ALTER TABLE - modifies a table
 DROP TABLE - deletes a table
 CREATE INDEX - creates an index (search key)
 DROP INDEX - deletes an index

The SELECT statement is used to select data from a database. The data
returned is stored in a result table, called the result-set.

Syntax.

SELECT column1, column2, ...
FROM table_name;

If you want to select all the fields available in the table, use the following syntax:
Syntax.

SELECT * FROM table_name;

The following SQL statement selects all the columns from the
"Customers" table:
Syntax.

SELECT * FROM Customers;

The SELECT DISTINCT statement is used to return only distinct (different)

values. Inside a table, a column often contains many duplicate values; and
sometimes you only want to list the different (distinct) values.
Syntax.

SELECT DISTINCT column1, column2,…
FROM table_name;
SQL
(Michelle Calles)
The following SQL statement lists the number of different (distinct)
customer countries:
Syntax.

SELECT COUNT (DISTINCT Country) 
FROM Customers;

The WHERE clause is used to filter records, clause is used to extract only
those records that fulfill a specified condition.

Syntax.

SELECT column1,  column2, ...

FROM table_name
WHERE condition;

Example.

SELECT * FROM Customers
WHERE Country='Mexico';

Example.

SELECT * FROM Customers
WHERE CustomerID=1;

The

Syntax.

SELECT column1, column2, ...
FROM table_name
WHERE condition1 AND condition2 AND condition3
...;

WHERE clause can be combined with AND, OR, and NOT operators. The
SQL
(Michelle Calles)
AND operator displays a record if all the conditions separated by AND are
TRUE.

Example.

SELECT * FROM Customers
WHERE Country='Germany' AND City='Berlin';

The OR operator displays a record if any of the conditions separated by OR

is TRUE.
Syntax.

SELECT column1, column2, ...
FROM table_name
WHERE condition1 OR condition2 OR condition3 .
..;
Example.

SELECT * FROM Customers
WHERE City='Berlin' OR City='München';

The NOT operator displays a record if the condition(s) is NOT TRUE.

Syntax.

SELECT column1, column2, ...
FROM table_name
WHERE NOT condition;

Example.

SELECT * FROM Customers
WHERE NOT Country='Germany';

You can also combine the AND, OR and NOT operators.

Example.

SELECT * FROM Customers
WHERE Country='Germany' AND (City='Berlin' OR City='München');
SQL
(Michelle Calles)
Example.

SELECT * FROM Customers
WHERE NOT Country='Germany' AND NOT Country='USA';

The ORDER BY keyword is used to sort the result-set in ascending or

descending order.

Sintax.

SELECT column1, column2, ...
FROM table_name
ORDER BY column1, column2, ... ASC|DESC;

Example.

SELECT * FROM Customers
ORDER BY Country;

Example.

SELECT * FROM Customers
ORDER BY Country DESC;

Example.

SELECT * FROM Customers
ORDER BY Country ASC;

ORDER BY Several Columns

Example.

SELECT * FROM Customers
ORDER BY Country, CustomerName;

Example.

SELECT * FROM Customers
ORDER BY Country ASC, CustomerName DESC;
SQL
(Michelle Calles)
The INSERT INTO statement is used to insert new records in a table. 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:
Syntax.

INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...);

Example.

INSERT INTO Customers (CustomerName, City, Country)

VALUES ('Cardinal', 'Stavanger', 'Norway');

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:

Syntax.

INSERT INTO table_name
VALUES (value1, value2, value3, ...);

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. We will have to use the IS NULL and IS NOT NULL
operators instead.
Syntax.

SELECT column_names
FROM table_name
WHERE column_name IS NULL;

Syntax.

SELECT column_names
FROM table_name
WHERE column_name IS NOT NULL;
SQL
(Michelle Calles)
Example.

SELECT CustomerName, ContactName, Address

FROM Customers
WHERE Address IS NULL;

The UPDATE statement is used to modify the existing records in a table.

Syntax.

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

Example.

UPDATE Customers
SET ContactName = 'Alfred Schmidt', City= 'Frankfurt'
WHERE CustomerID = 1;

The DELETE statement is used to delete existing records in a table.

Syntax.

DELETE FROM table_name WHERE condition;

Example.

DELETE FROM Customers WHERE CustomerName='Alfreds
Futterkiste';

It is possible to delete all rows in a table without deleting the table. This
means that the table structure, attributes, and indexes will be intact:

Syntax.

DELETE FROM table_name;
SQL
(Michelle Calles)

Example.

DELETE FROM Customers;

The SELECT TOP clause is used to specify the number of records to return. The
SELECT TOP clause is useful on large tables with thousands of records. Returning
a large number of records can impact on performance.

Syntax. (SQL Server)

SELECT TOP number|percent column_name(s)
FROM table_name
WHERE condition;

Syntax. (MySQL)

SELECT column_name(s)
FROM table_name
WHERE condition
LIMIT number;

Syntax. (Oracle)

SELECT column_name(s)
FROM table_name
WHERE ROWNUM <= number;

The following SQL statement selects the first three records from the
"Customers" table:
Syntax.

SELECT TOP 3 * FROM Customers;
The following SQL statement shows the equivalent example using the
LIMIT clause:
Syntax.

SELECT * FROM Customers
The following SQL statement shows the equivalent example using
LIMIT 3;
ROWNUM:

Syntax.

SELECT * FROM Customers
WHERE ROWNUM <= 3;
SQL
(Michelle Calles)

The following SQL statement selects the first 50% of the records from the
"Customers" table:
Syntax.

SELECT TOP 50 PERCENT * FROM Customers;

ADD a WHERE CLAUSE

The following SQL statement selects the first three records from the
"Customers" table, where the country is "Germany":
Syntax.

SELECT TOP 3 * FROM Customers
WHERE Country='Germany';

The following SQL statement shows the equivalent example using the LIMIT
clause:
Syntax.

SELECT * FROM Customers
WHERE Country='Germany'
LIMIT 3;

The following SQL statement shows the equivalent example using

ROWNUM:

Syntax.

SELECT * FROM Customers
WHERE Country='Germany' A
ND ROWNUM <= 3;

The MIN() function returns the smallest value of the selected column.

Syntax.

SELECT MIN(column_name)
FROM table_name
WHERE condition;
Example.

SELECT MIN(Price) AS SmallestPrice
FROM Products;
SQL
(Michelle Calles)
The MAX() function returns the largest value of the selected column.

Syntax.

SELECT MAX(column_name)
FROM table_name
WHERE condition;

Example.

SELECT MAX(Price) AS LargestPrice
FROM Products;

The COUNT() function returns the number of rows that matches a

specified criteria.
Syntax.

SELECT COUNT(column_name)
FROM table_name
WHERE condition;

Example.

SELECT COUNT(ProductID)
FROM Products;

The AVG() function returns the average value of a numeric column.

Syntax.

SELECT AVG(column_name)
FROM table_name
WHERE condition;

Example.

SELECT AVG(Price)
FROM Products;

The SUM() function returns the total sum of a numeric column.

Syntax.

SELECT SUM(column_name)
FROM table_name
WHERE condition;

Example.
SQL
(Michelle Calles)

The LIKE operator is used in a WHERE clause to search for a specified

pattern in a column. There are two wildcards often used in conjunction with
the LIKE operator:

 % - The percent sign represents zero, one, or multiple characters

 _ - The underscore represents a single character

Syntax.

SELECT column1, column2, ...

FROM table_name
WHERE columnn LIKE pattern;

Example.

SELECT * FROM Customers
WHERE CustomerName LIKE 'a%';

Wildcard Characters in MS Access.

SQL
(Michelle Calles)

Wildcard Characters in SQL Server.

All the wildcards can also be used in combinations!

Here are some examples showing different LIKE operators with '%' and '_'
wildcards:

Using the % Wildcard

Example.

SELECT * FROM Customers
WHERE City LIKE 'ber%';

Using the _ Wildcard

Example.

SELECT * FROM Customers
WHERE City LIKE '_ondon';
SQL
(Michelle Calles)

Using the [charlist] Wildcard

Example.

SELECT * FROM Customers
WHERE City LIKE '[bsp]%';

Example.

SELECT * FROM Customers
WHERE City LIKE '[a-c]%';

Using the [!charlist] Wildcard(! = no)

Example.

SELECT * FROM Customers
WHERE City LIKE '[!bsp]%';

Example.

SELECT * FROM Customers
WHERE City NOT LIKE '[bsp]%';

The IN operator allows you to specify multiple values in a WHERE clause.

The IN operator is a shorthand for multiple OR conditions.

Syntax.

SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1, value2, ...);

Syntax. (or)

SELECT column_name(s)
FROM table_name
WHERE column_name IN (SELECT STATEMENT);

Example.

SELECT * FROM Customers
WHERE Country IN ('Germany', 'France', 'UK');
SQL
(Michelle Calles)

The BETWEEN operator selects values within a given range. The values can be
numbers, text, or dates. The BETWEEN operator is inclusive: begin and end
values are included.

Syntax.

SELECT column_name(s)
FROM table_name
WHERE column_name BETWEEN value1 AND value2;

Example.

SELECT * FROM Products
WHERE Price BETWEEN 10 AND 20;

To display the products outside the range of the previous example, use
NOT BETWEEN:
Example.

SELECT * FROM Products
WHERE Price NOT BETWEEN 10 AND 20;

BETWEEN with IN

Example.

SELECT * FROM Products
WHERE (Price BETWEEN 10 AND 20)
AND NOT CategoryID IN (1,2,3);
BETWEEN Text Values
Example.

SELECT * FROM Products
WHERE ProductName BETWEEN 'Carnarvon
Tigers' AND 'Mozzarella di Giovanni'
ORDER BY ProductName;
 SQL
(Michelle Calles)

NOT BETWEEN Text Values

Example.

SELECT * FROM Products
WHERE ProductName NOT BETWEEN 'Carnarvon
Tigers' AND 'Mozzarella di Giovanni'
ORDER BY ProductName;

SQL aliases are used to give a table, or a column in a table, a temporary name.
Aliases are often used to make column names more readable. An alias only exists
for the duration of the query.
Syntax. (alias column)

SELECT column_name AS alias_name
FROM table_name;

Example. (alias column)

SELECT CustomerID AS ID,
CustomerName AS Customer
FROM Customers;
The following SQL statement creates two aliases, one for the
CustomerName column and one for the ContactName column. Note: It
requires double quotation marks or square brackets if the alias name
contains spaces:
Example.

SELECT CustomerName AS Customer,
ContactName AS [Contact Person]
FROM Customers;

The following SQL statement creates an alias named "Address" that

combine four columns (Address, PostalCode, City and Country):

Syntax.

Syntax
SELECT CustomerName, (alias table)
Address + ', ' + PostalCode + ' ' + City + ', ' +
Country AS Address
FROM Customers; SELECT column_name(s)
FROM table_name AS alias_name;
 SQL
(Michelle Calles)

The following SQL statement selects all the orders from the customer with
CustomerID=4 (Around the Horn). We use the "Customers" and "Orders"
tables, and give them the table aliases of "c" and "o" respectively (Here we
use aliases to make the SQL shorter):
Example.

SELECT o.OrderID, o.OrderDate, c.CustomerName

FROM Customers AS c, Orders AS o
WHERE c.CustomerName="Around the Horn" AND c.CustomerID=o.CustomerID;

The following SQL statement is the same as above, but without aliases:
Example.

SELECT Orders.OrderID, Orders.OrderDate, Customers.CustomerName

FROM Customers, Orders
WHERE Customers.CustomerName="Around the
Horn" AND Customers.CustomerID=Orders.CustomerID;

Aliases can be useful when:

 There are more than one table involved in a query

 Functions are used in the query
 Column names are big or not very readable
 Two or more columns are combined together

A JOIN clause is used to combine rows from two or more tables, based on a
related column between them.
Example.

SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate

FROM Orders
INNER JOIN Customers ON Orders.CustomerID=Customers.CustomerID;

Here are the different types of the JOINs in SQL:

 (INNER) JOIN: Returns records that have matching values in both

tables
 LEFT (OUTER) JOIN: Return all records from the left table, and the
matched records from the right table
 SQL
(Michelle Calles)
 RIGHT (OUTER) JOIN: Return all records from the right table, and
the matched records from the left table
 FULL (OUTER) JOIN: Return all records when there is a match in
either left or right table

The INNER JOIN keyword selects records that have matching values in
both tables.
Example.

SELECT column_name(s)
FROM table1
INNER JOIN table2
ON table1.column_name = table2.column_name;

Example.

SELECT Orders.OrderID, Customers.CustomerName
FROM Orders
INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID;

JOIN Three Tables

Example.

SELECT Orders.OrderID, Customers.CustomerName, Shippers.ShipperName

FROM ((Orders
INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID)
INNER JOIN Shippers ON Orders.ShipperID = Shippers.ShipperID);

The LEFT JOIN keyword returns all records from the left table (table1),
and the matched records from the right table (table2). The result is NULL
from the right side, if there is no match.
Syntax.

SELECT column_name(s)
FROM table1
LEFT JOIN table2
ON table1.column_name = table2.column_name;
 SQL
(Michelle Calles)
Note: In some databases LEFT JOIN is called LEFT OUTER JOIN.

Example.

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
LEFT JOIN Orders ON Customers.CustomerID = Orders.CustomerID
ORDER BY Customers.CustomerName;

Note: The LEFT JOIN keyword returns all records from the left table (Customers),
even if there are no matches in the right table (Orders).
The RIGHT JOIN keyword returns all records from the right table (table2),
and the matched records from the left table (table1). The result is NULL
from the left side, when there is no match.
Syntax.

SELECT column_name(s)
FROM table1
RIGHT JOIN table2
ON table1.column_name = table2.column_name;

Note: In some databases RIGHT JOIN is called RIGHT OUTER JOIN.

Example.

SELECT Orders.OrderID, Employees.LastName, Employees.FirstName

FROM Orders
RIGHT JOIN Employees ON Orders.EmployeeID = Employees.EmployeeID
ORDER BY Orders.OrderID;
SQL
(Michelle Calles)
The FULL OUTER JOIN keyword return all records when there is a match in either
left (table1) or right (table2) table records.
Note: FULL OUTER JOIN can potentially return very large result-sets!
Tip: FULL OUTER JOIN and FULL JOIN are the same.
Syntax.

SELECT column_name(s)
FROM table1
FULL OUTER JOIN table2
ON table1.column_name = table2.column_name
WHERE condition;

Example.

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
FULL OUTER JOIN Orders ON Customers.CustomerID=Orders.CustomerID
ORDER BY Customers.CustomerName;

A self-JOIN is a regular join, but the table is joined with itself.

Syntax.

SELECT column_name(s)
FROM table1 T1, table1 T2
WHERE condition;

Example.

SELECT A.CustomerName AS CustomerName1,
B.CustomerName AS CustomerName2, A.City
FROM Customers A, Customers B
WHERE A.CustomerID <> B.CustomerID
AND A.City = B.City 
ORDER BY A.City;
SQL
(Michelle Calles)
The UNION operator is used to combine the result-set of two or more SELECT
statements.

 Each SELECT statement within UNION must have the same number of
columns
 The columns must also have similar data types

 The columns in each SELECT statement must also be in the same order

Syntax.

SELECT column_name(s) FROM table1
UNION
SELECT column_name(s) FROM table2;

Example.

SELECT 'Customer' As Type, ContactName,
City, Country
FROM Customers
UNION
SELECT 'Supplier', ContactName, City,
Country
FROM Suppliers;

The UNION operator selects only distinct values by default. To allow duplicate
values, use UNION ALL:
Syntax.

SELECT column_name(s) FROM table1
UNION ALL
SELECT column_name(s) FROM table2;

Example.

SELECT City, Country FROM Customers
WHERE Country='Germany'
UNION ALL
SELECT City, Country FROM Suppliers
WHERE Country='Germany'
ORDER BY City;UNION ALL
SELECT City, Country FROM Suppliers
WHERE Country='Germany'
ORDER BY City;
 SQL
(Michelle Calles)

Example.

SELECT City, Country FROM Customers
WHERE Country='Germany'
UNION
SELECT City, Country FROM Suppliers
WHERE Country='Germany'
ORDER BY City;

The GROUP BY statement is often used with aggregate functions (COUNT, MAX,
MIN, SUM, AVG) to group the result-set by one or more columns.
Syntax.

SELECT column_name(s)
FROM table_name
WHERE condition
GROUP BY column_name(s)
ORDER BY column_name(s);

Example.

SELECT COUNT(CustomerID), Country
FROM Customers
GROUP BY Country;

Example.

SELECT COUNT(CustomerID), Country
FROM Customers
GROUP BY Country
ORDER BY COUNT(CustomerID) DESC;

Group by with Join

Example.

SELECT Shippers.ShipperName, COUNT(Orders.OrderID) AS NumberOfOrders FROM Orders
LEFT JOIN Shippers ON Orders.ShipperID = Shippers.ShipperID
GROUP BY ShipperName;
 SQL
(Michelle Calles)

The HAVING clause was added to SQL because the WHERE keyword could
not be used with aggregate functions.

Syntax.

SELECT column_name(s)
FROM table_name
WHERE condition
GROUP BY column_name(s)
HAVING condition
ORDER BY column_name(s);

Example.

SELECT COUNT(CustomerID), Country
FROM Customers
GROUP BY Country
HAVING COUNT(CustomerID) > 5;

Example.

SELECT COUNT(CustomerID), Country
FROM Customers
GROUP BY Country
HAVING COUNT(CustomerID) > 5
ORDER BY COUNT(CustomerID) DESC;

The EXISTS operator is used to test for the existence of any record in a
subquery. The EXISTS operator returns true if the subquery returns one or
more records.
Syntax.

SELECT column_name(s)
FROM table_name
WHERE EXISTS
(SELECT column_name FROM table_name WHERE condition);

Example.

SELECT SupplierName
FROM Suppliers
WHERE EXISTS (SELECT ProductName FROM Products WHERE Products.SupplierID =
Suppliers.supplierID AND Price < 20);
 SQL
(Michelle Calles)

The ANY and ALL operators are used with a WHERE or HAVING clause

The ANY operator returns true if any of the subquery values meet the condition.

Syntax.

SELECT column_name(s)
FROM table_name
WHERE column_name operator ANY
(SELECT column_name FROM table_name WHERE condition);

Example.

SELECT ProductName
FROM Products
WHERE ProductID
= ANY (SELECT ProductID FROM OrderDetails WHERE Quantity = 10);

The ALL operator returns true if all of the subquery values meet the
condition.

Syntax.

SELECT column_name(s)
FROM table_name
WHERE column_name operator ALL
(SELECT column_name FROM table_name WHERE condition);

Example.

SELECT ProductName
FROM Products
WHERE ProductID = ALL (SELECT ProductID FROM OrderDetails WHERE Quantity = 10);

The SELECT INTO statement copies data from one table into a new table.

Copy all columns into a new table:

Syntax.

SELECT *
INTO newtable [IN externaldb]
FROM oldtable
WHERE condition;);
SQL
(Michelle Calles)

Copy only some columns into a new table:

Syntax.

SELECT column1, column2, column3, ...
INTO newtable [IN externaldb]
FROM oldtable
WHERE condition;

Example.

SELECT * INTO CustomersBackup2017
FROM Customers;

Tip: SELECT INTO can also be used to create a new, empty table using the
schema of another. Just add a WHERE clause that causes the query to
return no data:
Example.

SELECT * INTO newtable
FROM oldtable
WHERE 1 = 0;

The INSERT INTO SELECT statement copies data from one table and inserts it
into another table.

 INSERT INTO SELECT requires that data types in source and target tables
match
 The existing records in the target table are unaffected

Copy all columns from one table to another table :

Syntax.

INSERT INTO table2
SELECT * FROM table1
WHERE condition;

Copy only some columns from one table into another table:
Syntax.

INSERT INTO table2 (column1, column2, column3, ...)
SELECT column1, column2, column3, ...
FROM table1
WHERE condition;
 SQL
(Michelle Calles)

The following SQL statement copies "Suppliers" into "Customers" (the

columns that are not filled with data, will contain NULL):
Example.

INSERT INTO Customers (CustomerName, City, Country)

SELECT SupplierName, City, Country FROM Suppliers;

The following SQL statement copies "Suppliers" into "Customers" (fill all
columns):

Example.

INSERT INTO Customers (CustomerName, ContactName, Address, City, PostalCode, Country)

SELECT SupplierName, ContactName, Address, City, PostalCode, Country FROM Suppliers;

The CASE statement goes through conditions and returns a value when the
first condition is met (like an IF-THEN-ELSE statement). So, once a
condition is true, it will stop reading and return the result. If no conditions
are true, it returns the value in the ELSE clause.

If there is no ELSE part and no conditions are true, it returns NULL.

Syntax.

CASE
    WHEN condition1 THEN result1
    WHEN condition2 THEN result2
    WHEN conditionN THEN resultN
    ELSE result
END;

The following SQL goes through conditions and returns a value when the
first condition is met:
Example.

SELECT OrderID, Quantity,
CASE
    WHEN Quantity > 30 THEN "The quantity is greater than 30"
    WHEN Quantity = 30 THEN "The quantity is 30"
    ELSE "The quantity is under 30"
END AS QuantityText
FROM OrderDetails;
 SQL
(Michelle Calles)

The MySQL IFNULL() function lets you return an alternative value if an expression
is NULL:

Syntax.

SELECT ProductName, UnitPrice * (UnitsInStock + IFNULL(UnitsOnOrder, 0))

FROM Products;

or we can use the COALESCE() function, like this:

Syntax.

SELECT ProductName, UnitPrice * (UnitsInStock + COALESCE(UnitsOnOrder, 0))

FROM Products;

The SQL Server ISNULL() function lets you return an alternative value when an
expression is NULL:

Syntax.

SELECT ProductName, UnitPrice * (UnitsInStock + ISNULL(UnitsOnOrder, 0))

FROM Products;

A stored procedure is a prepared SQL code that you can save, so the code can
be reused over and over again.

So if you have an SQL query that you write over and over again, save it as a stored
procedure, and then just call it to execute it.

You can also pass parameters to a stored procedure, so that the stored procedure
can act based on the parameter value(s) that is passed.

Syntax.

CREATE PROCEDURE procedure_name
AS
sql_statement
GO;

Example.

CREATE PROCEDURE SelectAllCustomers
AS
SELECT * FROM Customers
GO;
SQL
(Michelle Calles)

Execute a Stored Procedure

Syntax.

EXEC procedure_name;

Example.

EXEC SelectAllCustomers;

Stored Procedure With Multiple Parameters

Setting up multiple parameters is very easy. Just list each parameter and the data
type separated by a comma as shown below.
The following SQL statement creates a stored procedure that selects Customers
from a particular City with a particular PostalCode from the "Customers" table:

Example.

CREATE PROCEDURE SelectAllCustomers @City
nvarchar(30), @PostalCode nvarchar(10)
AS
SELECT * FROM Customers WHERE City =
@City AND PostalCode = @PostalCode
GO;

Execute the stored procedure above as follows:

Example.

EXEC SelectAllCustomers City = "London", PostalCode = "WA1 1DP";

Single line comments start with --.

Any text between -- and the end of the line will be ignored (will not be executed).
The following example uses a single-line comment as an explanation:
Syntax.

--Select all:
SELECT * FROM Customers;
SQL
(Michelle Calles)

Multi-line comments start with /* and end with */.

Syntax.

/*Select all the columns

of all the records
in the Customers table:*/
SELECT * FROM Customers;
The CREATE DATABASE statement is used to create a new SQL database.
Syntax.

CREATE DATABASE testDB;

The DROP DATABASE statement is used to drop an existing SQL

database.
Syntax.

DROP DATABASE databasename;

Example.

DROP DATABASE testDB;

The BACKUP DATABASE statement is used in SQL Server to create a full

back up of an existing SQL database.
Syntax.

BACKUP DATABASE databasename
TO DISK = 'filepath';
SQL
(Michelle Calles)
A differential back up only backs up the parts of the database that have
changed since the last full database backup.
Syntax.

BACKUP DATABASE databasename
TO DISK = 'filepath'
Example.WITH DIFFERENTIAL;

BACKUP DATABASE testDB
TO DISK = 'D:\backups\testDB.bak';

Example.

BACKUP DATABASE testDB
TO DISK = 'D:\backups\testDB.bak'
WITH DIFFERENTIAL;

The CREATE TABLE statement is used to create a new table in a database.

Syntax.

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

The column parameters specify the names of the columns of the table.The
datatype parameter specifies the type of data the column can hold (e.g. varchar,
integer, date, etc.).
Example.

CREATE TABLE Persons (
    PersonID int,
    LastName varchar(255),
    FirstName varchar(255),
    Address varchar(255),
    City varchar(255) 
);
SQL
(Michelle Calles)

Create Table Using Another Table.

A copy of an existing table can also be created using CREATE TABLE.
The new table gets the same column definitions. All columns or specific columns
can be selected.
If you create a new table using an existing table, the new table will be filled with the
existing values from the old table.

Syntax.

CREATE TABLE new_table_name AS
    SELECT column1, column2,...
    FROM existing_table_name
    WHERE ....;

Example.

CREATE TABLE TestTable AS
SELECT customername, contactname
FROM customers;

The DROP TABLE statement is used to drop an existing table in a database.

Syntax.

DROP TABLE table_name;

Example.

DROP TABLE Shippers;

The TRUNCATE TABLE statement is used to delete the data inside a table,
but not the table itself.
Syntax.

TRUNCATE TABLE table_name;
SQL
(Michelle Calles)

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.

Syntax. (Add column)

ALTER TABLE table_name
Example. ADD column_name
(Add column) datatype;

ALTER TABLE Customers
ADD Email varchar(255);

Syntax. (Drop column)

ALTER TABLE table_name
DROP COLUMN column_name datatype;

Example. (Drop column)

ALTER TABLE Customers
DROP COLUMN Email varchar;

To change the data type of a column in a table, use the following syntax:
Syntax. (SQL Server/ MS Access)

ALTER TABLE table_name
ALTER COLUMN column_name datatype;

Syntax. (MySQL/ Oracle)

ALTER TABLE table_name
MODIFY COLUMN column_name datatype;

Oracle.

ALTER TABLE table_name
MODIFY column_name datatype;
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
(Michelle Calles)

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
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.

Syntax.

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

SQL NOT NULL on ALTER TABLE

Syntax.

ALTER TABLE Persons
MODIFY Age int NOT NULL;
SQL
(Michelle Calles)

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.
Syntax. (SQL Server / Oracle / MS
Access)

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

Syntax. (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:
Syntax. (MySQL / SQL Server /
Oracle / MS Access)

CREATE TABLE Persons (
    ID int NOT NULL,
    LastName
varchar(255) NOT NULL,
    FirstName
varchar(255),
    Age int,
SQL
(Michelle Calles)

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

Syntax. (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:
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:

Syntax. (MySQL)

ALTER TABLE Persons
DROP INDEX UC_Person;

Syntax. (SQL Server / Oracle / MS Access)

ALTER TABLE Persons
DROP CONSTRAINT UC_Person;

The PRIMARY KEY constraint uniquely identifies each record in a table. Primary
keys must contain UNIQUE values, and cannot contain NULL values.
A table can have only ONE primary key; and in the table, this primary key can
consist of single or multiple columns (fields).
Syntax. (MySQL)

CREATE TABLE Persons (
    ID int NOT NULL,
    LastName
varchar(255) NOT NULL,
    FirstName
varchar(255),
SQL
(Michelle Calles)

Syntax. (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:

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:
Syntax. (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:
Syntax. (MySQL / SQL Server / Oracle / MS Access)

ALTER TABLE Persons
ADD CONSTRAINT PK_Person PRIMARY KEY (ID,LastName);
SQL
(Michelle Calles)

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:
Syntax. (MySQL)

ALTER TABLE Persons
DROP PRIMARY KEY;

Syntax. (SQL Server / Oracle / MS Access)

ALTER TABLE Persons
DROP CONSTRAINT PK_Person;

SQL FOREIGN KEY on CREATE TABLE

The following SQL creates a FOREIGN KEY on the "PersonID" column when the
"Orders" table is created:
Syntax. (MySQL)

CREATE TABLE Orders (
    OrderID int NOT NULL,
    OrderNumber int NOT NULL,
    PersonID int,
    PRIMARY KEY (OrderID),
    FOREIGN KEY (PersonID) REFERENCES Persons(PersonID)
);

Syntax. (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)
);
SQL
(Michelle Calles)

To allow naming of a FOREIGN KEY constraint, and for defining a FOREIGN KEY
constraint on multiple columns, use the following SQL syntax:

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:
Syntax. (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:

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:
Syntax. ( MySQL )

ALTER TABLE Orders
DROP FOREIGN KEY FK_PersonOrder;

Syntax. (SQL Server / Oracle / MS Access)

ALTER TABLE Orders
DROP CONSTRAINT FK_PersonOrder;
SQL
(Michelle Calles)

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.

Syntax. (MySQL)

CREATE TABLE Persons (
    ID int NOT NULL,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int,
    CHECK (Age>=18)
);

Syntax. (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:
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

 SQL
(Michelle Calles)
To create a CHECK constraint on the "Age" column when the table is already
created, use the following SQL:

Syntax. (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:

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:

Syntax. (MySQL / SQL Server / Oracle / MS Access)

ALTER TABLE Persons
DROP CONSTRAINT CHK_PersonAge;

Syntax. (MySQL)

ALTER TABLE Persons
DROP CHECK CHK_PersonAge;

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.
Syntax. (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():
Syntax.

CREATE TABLE Orders (
    ID int NOT NULL,
    OrderNumber int NOT NULL,
SQL
(Michelle Calles)

SQL DEFAULT on ALTER TABLE. To create a DEFAULT constraint on the "City"

column when the table is already created, use the following SQL:
Syntax. (MySQL)

ALTER TABLE Persons
ALTER City SET DEFAULT 'Sandnes';

Syntax. (SQL Server)

ALTER TABLE Persons
ADD CONSTRAINT df_City 
DEFAULT 'Sandnes' FOR City;

Syntax. (MS Access)

ALTER TABLE Persons
ALTER COLUMN City SET DEFAULT 'Sandnes';

Syntax. (Oracle)

ALTER TABLE Persons
MODIFY City DEFAULT 'Sandnes';

DROP a DEFAULT Constraint

To drop a DEFAULT constraint, use the following SQL:
Syntax. (MySQL)

ALTER TABLE Persons
ALTER City DROP DEFAULT;

Syntax. (SQL Server / Oracle / MS Access)

ALTER TABLE Persons
ALTER COLUMN City DROP DEFAULT

SQL CREATE INDEX Statement

SQL
(Michelle Calles)
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.

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

Syntax.

CREATE INDEX index_name
ON table_name (column1, column2, ...);

Creates a unique index on a table. Duplicate values are not allowed:

Syntax.

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.
Example.

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:

Example.

CREATE INDEX idx_lastname
ON Persons (LastNameFirstName);

The DROP INDEX statement is used to delete an index in a table.

Syntax. (MS Access)

DROP INDEX index_name ON table_name;

Syntax. (SQL Server)

DROP INDEX table_name.index_name;

Syntax. (DB2/Oracle)

DROP INDEX index_name;

Syntax. (My SQL)

ALTER TABLE table_name
DROP INDEX index_name;
SQL
(Michelle Calles)

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. (My SQL)

CREATE TABLE Persons (
    Personid int NOT NULL AUTO_INCREMENT,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int,
    PRIMARY KEY (Personid)
);

To let the AUTO_INCREMENT sequence start with another value, use the
following SQL statement:
Syntax. (My SQL)

ALTER TABLE Persons AUTO_INCREMENT=100;

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 "Personid" column
should start at value 10 and increment by 5, change it to IDENTITY(10,5).

Syntax. (SQL Server)

CREATE TABLE Persons (
    Personid int IDENTITY(1,1) PRIMARY KEY,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int
);

Syntax. (Access)

CREATE TABLE Persons (
    Personid AUTOINCREMENT PRIMARY KEY,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int
);
SQL
(Michelle Calles)

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:
Syntax. (Oracle)

CREATE SEQUENCE seq_person
MINVALUE 1
START WITH 1
INCREMENT BY 1
CACHE 10;

SQL Dates

As long as your data contains only the date portion, your queries will work as
expected. However, if a time portion is involved, it gets more complicated.

MySQL comes with the following data types for storing a date or a

date/time value in the database:

 DATE - format YYYY-MM-DD

 DATETIME - format: YYYY-MM-DD HH:MI:SS
 TIMESTAMP - format: YYYY-MM-DD HH:MI:SS
 YEAR - format YYYY or YY

SQL Server comes with the following data types for storing a date or a
date/time value in the database:

 DATE - format YYYY-MM-DD

 DATETIME - format: YYYY-MM-DD HH:MI:SS
 SMALLDATETIME - format: YYYY-MM-DD HH:MI:SS
 TIMESTAMP - format: a unique number

Note: The date types are chosen for a column when you create a new table
in your database!

Syntax.

SELECT * FROM Orders WHERE OrderDate='2008-11-11'
SQL
(Michelle Calles)

CREATE VIEW Statement

In SQL, a view is a virtual table based on the result-set of an SQL statement. A
view contains rows and columns, just like a real table. The fields in a view are
fields from one or more real tables in the database. You can add SQL functions,
WHERE, and JOIN statements to a view and present the data as if the data were
coming from one single table.

Syntax.

CREATE VIEW view_name AS
SELECT column1, column2, ...
FROM table_name
WHERE condition;

Example.

CREATE VIEW [Brazil Customers] 
AS
SELECT CustomerName,
ContactName
FROM Customers
WHERE Country = "Brazil";

We can query the view above as follows:

Example.

SELECT * FROM [Brazil Customers];

Updating a View. A view can be updated with the CREATE OR REPLACE VIEW
command.
Syntax.

CREATE OR REPLACE VIEW view_name AS
SELECT column1, column2, ...
FROM table_name
WHERE condition;

Example.

CREATE OR REPLACE VIEW [Brazil
Customers] AS
SELECT CustomerName, ContactName,
City
FROM Customers
SQL
(Michelle Calles)

A view is deleted with the DROP VIEW command

Syntax.

DROP VIEW view_name;

Example.

DROP VIEW [Brazil Customers];