SQL

From Wikipedia, the free encyclopedia

Jump to: navigation, search

This article is about the database language. For the airport with IATA code SQL, see
San Carlos Airport.

SQL Paradigm Multi-paradigm

Appeared in 1974

Designed by Donald D. Chamberlin

Raymond F. Boyce

Developer IBM

Stable release SQL:2008 (2008)

Typing discipline Static, strong

Major implementations Many

Dialects SQL-86, SQL-89, SQL-92, SQL:1999, SQL:2003, SQL:2008

Influenced by Datalog

Influenced Agena, CQL, LINQ, Windows PowerShell

OS Cross-platform

SQL (officially pronounced /ˌɛskjuːˈɛl/ like "S-Q-L" but is often pronounced /ˈsiːkwəl/
like "Sequel"),[1] often referred to as Structured Query Language,[2][3] is a
database computer language designed for managing data in relational database
management systems (RDBMS), and originally based upon relational algebra. Its
scope includes data insert, query, update and delete, schema creation and
modification, and data access control. SQL was one of the first languages for Edgar
F. Codd's relational model in his influential 1970 paper, "A Relational Model of Data
for Large Shared Data Banks"[4] and became the most widely used language for
relational databases.[2][5]

Contents

[hide]
 * 1 History

* 2 Language elements

o 2.1 Queries

+ 2.1.1 Null and three-valued logic (3VL)

o 2.2 Data manipulation

o 2.3 Transaction controls

o 2.4 Data definition

o 2.5 Data types

+ 2.5.1 Character strings

+ 2.5.2 Bit strings

+ 2.5.3 Numbers

+ 2.5.4 Date and time

o 2.6 Data control

o 2.7 Procedural extensions

* 3 Criticisms of SQL

o 3.1 Cross-vendor portability

* 4 Standardization

o 4.1 Standard structure

* 5 Alternatives to SQL

* 6 See also

* 7 References

* 8 External links

[edit] History

SQL was developed at IBM by Donald D. Chamberlin and Raymond F. Boyce in the
early 1970s. This version, initially called SEQUEL (Structured English Query
Language), was designed to manipulate and retrieve data stored in IBM's original
relational database management system, System R, which a group at IBM San Jose
Research Laboratory had developed during the 1970s.[6] The acronym SEQUEL was
later changed to SQL because "SEQUEL" was a trademark of the UK-based Hawker
Siddeley aircraft company.[7]

The first Relational Database Management System (RDBMS) was RDMS, developed
at MIT in the early 1970s, soon followed by Ingres, developed in 1974 at U.C.
Berkeley. Ingres implemented a query language known as QUEL, which was later
supplanted in the marketplace by SQL.[7]

In the late 1970s, Relational Software, Inc. (now Oracle Corporation) saw the
potential of the concepts described by Codd, Chamberlin, and Boyce and developed
their own SQL-based RDBMS with aspirations of selling it to the U.S. Navy, Central
Intelligence Agency, and other U.S. government agencies. In the summer of 1979,
Relational Software, Inc. introduced the first commercially available implementation
of SQL, Oracle V2 (Version2) for VAX computers. Oracle V2 beat IBM's release of the
System/38 RDBMS to market by a few weeks.[citation needed]

After testing SQL at customer test sites to determine the usefulness and practicality
of the system, IBM began developing commercial products based on their System R
prototype including System/38, SQL/DS, and DB2, which were commercially
available in 1979, 1981, and 1983, respectively.[8]

Common criticisms of SQL include a lack of cross-platform portability between

vendors, inappropriate handling of missing data (see Null (SQL)), and unnecessarily
complex and occasionally ambiguous language grammar and semantics[citation
needed]. It also lacks the rigour of more formal languages such as relational
algebra[citation needed].

[edit] Language elements

This chart shows several of the SQL language elements that compose a single
statement.

The SQL language is sub-divided into several language elements, including:

 * Clauses, which are in some cases optional, constituent components of
statements and queries.[9]

* Expressions which can produce either scalar values or tables consisting of

columns and rows of data.

* Predicates which specify conditions that can be evaluated to SQL three-valued

logic (3VL) or Boolean (true/false/unknown) truth values and which are used to limit
the effects of statements and queries, or to change program flow.

* Queries which retrieve data based on specific criteria.

* Statements which may have a persistent effect on schemas and data, or which
may control transactions, program flow, connections, sessions, or diagnostics.

o SQL statements also include the semicolon (";") statement terminator.

Though not required on every platform, it is defined as a standard part of the SQL
grammar.

* Insignificant whitespace is generally ignored in SQL statements and queries,

making it easier to format SQL code for readability.

[edit] Queries

The most common operation in SQL is the query, which is performed with the
declarative SELECT statement. SELECT retrieves data from one or more tables, or
expressions. Standard SELECT statements have no persistent effects on the
database. Some non-standard implementations of SELECT can have persistent
effects, such as the SELECT INTO syntax that exists in some databases.[10]

Queries allow the user to describe desired data, leaving the database management
system (DBMS) responsible for planning, optimizing, and performing the physical
operations necessary to produce that result as it chooses.

A query includes a list of columns to be included in the final result immediately

following the SELECT keyword. An asterisk ("*") can also be used to specify that the
query should return all columns of the queried tables. SELECT is the most complex
statement in SQL, with optional keywords and clauses that include:
 * The FROM clause which indicates the table(s) from which data is to be
retrieved. The FROM clause can include optional JOIN subclauses to specify the rules
for joining tables.

* The WHERE clause includes a comparison predicate, which restricts the rows
returned by the query. The WHERE clause eliminates all rows from the result set for
which the comparison predicate does not evaluate to True.

* The GROUP BY clause is used to project rows having common values into a
smaller set of rows. GROUP BY is often used in conjunction with SQL aggregation
functions or to eliminate duplicate rows from a result set. The WHERE clause is
applied before the GROUP BY clause.

* The HAVING clause includes a predicate used to filter rows resulting from the
GROUP BY clause. Because it acts on the results of the GROUP BY clause,
aggregation functions can be used in the HAVING clause predicate.

* The ORDER BY clause identifies which columns are used to sort the resulting
data, and in which direction they should be sorted (options are ascending or
descending). Without an ORDER BY clause, the order of rows returned by an SQL
query is undefined.

The following is an example of a SELECT query that returns a list of expensive

books. The query retrieves all rows from the Book table in which the price column
contains a value greater than 100.00. The result is sorted in ascending order by
title. The asterisk (*) in the select list indicates that all columns of the Book table
should be included in the result set.

SELECT *

FROM Book

WHERE price > 100.00

ORDER BY title;

The example below demonstrates a query of multiple tables, grouping, and

aggregation, by returning a list of books and the number of authors associated with
each book.

SELECT Book.title,
 count(*) AS Authors

FROM Book JOIN Book_author

ON Book.isbn = Book_author.isbn

GROUP BY Book.title;

Example output might resemble the following:

Title Authors

---------------------- -------

SQL Examples and Guide 4

The Joy of SQL 1

An Introduction to SQL 2

Pitfalls of SQL 1

Under the precondition that isbn is the only common column name of the two tables
and that a column named title only exists in the Books table, the above query could
be rewritten in the following form:

SELECT title,

count(*) AS Authors

FROM Book NATURAL JOIN Book_author

GROUP BY title;

However, many vendors either do not support this approach, or require certain
column naming conventions in order for natural joins to work effectively.

SQL includes operators and functions for calculating values on stored values. SQL
allows the use of expressions in the select list to project data, as in the following
example which returns a list of books that cost more than 100.00 with an additional
sales_tax column containing a sales tax figure calculated at 6% of the price.

SELECT isbn,

title,

price,

price * 0.06 AS sales_tax

FROM Book

WHERE price > 100.00

ORDER BY title;

[edit] Null and three-valued logic (3VL)

The idea of Null was introduced into SQL to handle missing information in the
relational model. The introduction of Null (or Unknown) along with True and False is
the foundation of three-valued logic. Null does not have a value (and is not a
member of any data domain) but is rather a placeholder or “mark” for missing
information. Therefore comparisons with Null can never result in either True or False
but always in the third logical result, Unknown.[11]

SQL uses Null to handle missing information. It supports three-valued logic (3VL)
and the rules governing SQL three-valued logic (3VL) are shown below (p and q
represent logical states).[12] The word NULL is also a reserved keyword in SQL,
used to identify the Null special marker.

Additionally, since SQL operators return Unknown when comparing anything with
Null, SQL provides two Null-specific comparison predicates: The IS NULL and IS NOT
NULL test whether data is or is not Null.[13]
Note that SQL returns only results for which the WHERE clause returns a value of
True. I.e., it excludes results with values of False, but also those whose value is
Unknown.

p AND q p

True False Unknown

q True True False Unknown

False False False False

Unknown Unknown False Unknown

p OR q p

True False Unknown

q True True True True

False True False Unknown

Unknown True Unknown Unknown

p NOT p

True False

False True

Unknown Unknown

p=q p

True False Unknown

q True True False Unknown

False False True Unknown

Unknown Unknown Unknown Unknown

Universal quantification is not explicitly supported by SQL, and must be worked out
as a negated existential quantification.[14][15][16]
There is also the "<row value expression> IS DISTINCT FROM <row value
expression>" infixed comparison operator which returns TRUE unless both operands
are equal or both are NULL. Likewise, IS NOT DISTINCT FROM is defined as "NOT
(<row value expression> IS DISTINCT FROM <row value expression>")

[edit] Data manipulation

The Data Manipulation Language (DML) is the subset of SQL used to add, update
and delete data:

* INSERT adds rows (formally tuples) to an existing table, e.g.,:

INSERT INTO My_table

(field1, field2, field3)

VALUES

('test', 'N', NULL);

* UPDATE modifies a set of existing table rows, e.g.,:

UPDATE My_table

SET field1 = 'updated value'

WHERE field2 = 'N';

* DELETE removes existing rows from a table, e.g.,:

DELETE FROM My_table

WHERE field2 = 'N';

 * MERGE is used to combine the data of multiple tables. It combines the INSERT
and UPDATE elements. It is defined in the SQL:2003 standard; prior to that, some
databases provided similar functionality via different syntax, sometimes called
"upsert".

[edit] Transaction controls

Transactions, if available, wrap DML operations:

* START TRANSACTION (or BEGIN WORK, or BEGIN TRANSACTION, depending on

SQL dialect) mark the start of a database transaction, which either completes
entirely or not at all.

* SAVE TRANSACTION (or SAVEPOINT ) save the state of the database at the
current point in transaction

CREATE TABLE tbl_1(id int);

INSERT INTO tbl_1(id) value(1);

INSERT INTO tbl_1(id) value(2);

COMMIT;

UPDATE tbl_1 SET id=200 WHERE id=1;

SAVEPOINT id-1upd;

UPDATE tbl_1 SET id=1000 WHERE id=2;

ROLLBACK TO id-1upd;

SELECT id FROM tbl_1;

* COMMIT causes all data changes in a transaction to be made permanent.

* ROLLBACK causes all data changes since the last COMMIT or ROLLBACK to be
discarded, leaving the state of the data as it was prior to those changes.
Once the COMMIT statement completes, the transaction's changes cannot be rolled
back.

COMMIT and ROLLBACK terminate the current transaction and release data locks. In
the absence of a START TRANSACTION or similar statement, the semantics of SQL
are implementation-dependent. Example: A classic bank transfer of funds
transaction.

START TRANSACTION;

UPDATE Account SET amount=amount-200 WHERE account_number=1234;

UPDATE Account SET amount=amount+200 WHERE account_number=2345;

IF ERRORS=0 COMMIT;

IF ERRORS<>0 ROLLBACK;

[edit] Data definition

The Data Definition Language (DDL) manages table and index structure. The most
basic items of DDL are the CREATE, ALTER, RENAME, DROP and TRUNCATE
statements:

* CREATE creates an object (a table, for example) in the database.

* DROP deletes an object in the database, usually irretrievably, i.e. it cannot be

rolled back.

* TRUNCATE deletes all data from a table in a very fast way. It usually implies a
subsequent COMMIT operation i.e. it cannot be rolled back.

* ALTER modifies the structure of an existing object in various ways—for

example, adding a column to an existing table.

Example:
CREATE TABLE My_table

my_field1 INT,

my_field2 VARCHAR(50),

my_field3 DATE NOT NULL,

PRIMARY KEY (my_field1, my_field2)

);

[edit] Data types

Each column in an SQL table declares the type(s) that column may contain. ANSI
SQL includes the following datatypes.[17]

[edit] Character strings

* CHARACTER(n) or CHAR(n) — fixed-width n-character string, padded with

spaces as needed

* CHARACTER VARYING(n) or VARCHAR(n) — variable-width string with a

maximum size of n characters

* NATIONAL CHARACTER(n) or NCHAR(n) — fixed width string supporting an

international character set

* NATIONAL CHARACTER VARYING(n) or NVARCHAR(n) — variable-width NCHAR

string

[edit] Bit strings

* BIT(n) — an array of n bits

* BIT VARYING(n) — an array of up to n bits

[edit] Numbers

* INTEGER and SMALLINT

* FLOAT, REAL and DOUBLE PRECISION

* NUMERIC(precision, scale) or DECIMAL(precision, scale)

SQL provides a function to round numerics or dates, called TRUNC (in Informix, DB2,
PostgreSQL, Oracle and MySQL) or ROUND (in Informix, Sybase, Oracle, PostgreSQL
and Microsoft SQL Server)[18]

[edit] Date and time

* DATE — for date values (e.g., 2010-05-30)

* TIME — for time values (e.g., 14:55:37). The granularity of the time value is
usually a tick (100 nanoseconds).

* TIME WITH TIME ZONE or TIMESTAMP — the same as TIME, but including details
about the time zone in question.

* TIMESTAMP — This is a DATE and a TIME put together in one variable (e.g.,
2010-05-30 14:55:37).

* TIMESTAMP WITH TIME ZONE or TIMESTAMPTZ — the same as TIMESTAMP, but

including details about the time zone in question.

SQL provides several functions for generating a date / time variable out of a date /
time string (TO_DATE, TO_TIME, TO_TIMESTAMP), as well as for extracting the
respective members (seconds, for instance) of such variables. The current system
date / time of the database server can be called by using functions like NOW.

[edit] Data control

The Data Control Language (DCL) authorizes users and groups of users to access
and manipulate data. Its two main statements are:
 * GRANT authorizes one or more users to perform an operation or a set of
operations on an object.

* REVOKE eliminates a grant, which may be the default grant.

Example:

GRANT SELECT, UPDATE

ON My_table

TO some_user, another_user;

REVOKE SELECT, UPDATE

ON My_table

FROM some_user, another_user;

[edit] Procedural extensions

SQL is designed for a specific purpose: to query data contained in a relational

database. SQL is a set-based, declarative query language, not an imperative
language such as C or BASIC. However, there are extensions to Standard SQL which
add procedural programming language functionality, such as control-of-flow
constructs. These are:

Source Common

Name Full Name

ANSI/ISO Standard SQL/PSM SQL/Persistent Stored Modules

Interbase/

Firebird PSQL Procedural SQL

IBM SQL PL SQL Procedural Language (implements SQL/PSM)

Microsoft/
Sybase T-SQL Transact-SQL

Mimer SQL SQL/PSM SQL/Persistent Stored Module (implements SQL/PSM)

MySQL SQL/PSM SQL/Persistent Stored Module (implements SQL/PSM)

Oracle PL/SQL Procedural Language/SQL (based on Ada)

PostgreSQL PL/pgSQL Procedural Language/PostgreSQL Structured Query

Language (based on Oracle PL/SQL)

PostgreSQL PL/PSM Procedural Language/Persistent Stored Modules

(implements SQL/PSM)

In addition to the standard SQL/PSM extensions and proprietary SQL extensions,

procedural and object-oriented programmability is available on many SQL platforms
via DBMS integration with other languages. The SQL standard defines SQL/JRT
extensions (SQL Routines and Types for the Java Programming Language) to
support Java code in SQL databases. SQL Server 2005 uses the SQLCLR (SQL Server
Common Language Runtime) to host managed .NET assemblies in the database,
while prior versions of SQL Server were restricted to using unmanaged extended
stored procedures which were primarily written in C. Other database platforms, like
MySQL and Postgres, allow functions to be written in a wide variety of languages
including Perl, Python, Tcl, and C.

[edit] Criticisms of SQL

SQL is a declarative computer language for use with relational databases.

Interestingly, many of the original SQL features were inspired by, but violated, the
semantics of the relational model and its tuple calculus realization. Recent
extensions to SQL achieved relational completeness, but have worsened the
violations, as documented in The Third Manifesto.

Practical criticisms of SQL include:

* Implementations are inconsistent and, usually, incompatible between vendors.

In particular date and time syntax, string concatenation, nulls, and comparison case
sensitivity vary from vendor to vendor.

* The language makes it too easy to do a Cartesian join (joining all possible
combinations), which results in "run-away" result sets when WHERE clauses are
mistyped. Cartesian joins are so rarely used in practice that requiring an explicit
CARTESIAN keyword may be warranted. (SQL 1992 introduced the CROSS JOIN
keyword that allows the user to make clear that a Cartesian join is intended, but the
shorthand "comma-join" with no predicate is still acceptable syntax, which still
invites the same mistake.)

* It is also possible to misconstruct a WHERE on an update or delete, thereby

affecting more rows in a table than desired. (A work-around is to use transactions or
habitually type in the WHERE clause first, then fill in the rest later.)

* The grammar of SQL is perhaps unnecessarily complex, borrowing a COBOL-like

keyword approach, when a function-influenced syntax could result in more re-use of
fewer grammar and syntax rules.

[edit] Cross-vendor portability

Popular implementations of SQL commonly omit support for basic features of

Standard SQL, such as the DATE or TIME data types. As a result, SQL code can
rarely be ported between database systems without modifications.

There are several reasons for this lack of portability between database systems:

* The complexity and size of the SQL standard means that most implementors do
not support the entire standard.

* The standard does not specify database behavior in several important areas
(e.g., indexes, file storage...), leaving implementations to decide how to behave.

* The SQL standard precisely specifies the syntax that a conforming database
system must implement. However, the standard's specification of the semantics of
language constructs is less well-defined, leading to ambiguity.

* Many database vendors have large existing customer bases; where the SQL
standard conflicts with the prior behavior of the vendor's database, the vendor may
be unwilling to break backward compatibility.

* Software vendors often desire to create incompatibilities with other products, as

it provides a strong incentive for their existing users to remain loyal (see vendor
lock-in).
[edit] Standardization

SQL was adopted as a standard by the American National Standards Institute (ANSI)
in 1986 as SQL-86[19] and International Organization for Standardization (ISO) in
1987. The original SQL standard declared that the official pronunciation for SQL is
"es queue el".[2] Many English-speaking database professionals still use the
nonstandard[20] pronunciation /ˈsiːkwəl/ (like the word "sequel").

Until 1996, the National Institute of Standards and Technology (NIST) data
management standards program certified DBMS compliance with the SQL standard.
Vendors now self-certify the compliance of their products.[21]

The SQL standard has gone through a number of revisions, as shown below:

Year Name Alias Comments

1986 SQL-86 SQL-87 First formalized by ANSI.

1989 SQL-89 FIPS 127-1 Minor revision, adopted as FIPS 127-1.

1992 SQL-92 SQL2, FIPS 127-2 Major revision (ISO 9075), Entry Level SQL-
92 adopted as FIPS 127-2.

1999 SQL:1999 SQL3 Added regular expression matching, recursive queries,

triggers, support for procedural and control-of-flow statements, non-scalar types,
and some object-oriented features.

2003 SQL:2003 Introduced XML-related features, window functions,

standardized sequences, and columns with auto-generated values (including
identity-columns).

2006 SQL:2006 ISO/IEC 9075-14:2006 defines ways in which SQL can be

used in conjunction with XML. It defines ways of importing and storing XML data in
an SQL database, manipulating it within the database and publishing both XML and
conventional SQL-data in XML form. In addition, it enables applications to integrate
into their SQL code the use of XQuery, the XML Query Language published by the
World Wide Web Consortium (W3C), to concurrently access ordinary SQL-data and
XML documents.

2008 SQL:2008 Legalizes ORDER BY outside cursor definitions. Adds

INSTEAD OF triggers. Adds the TRUNCATE statement.[22]
Interested parties may purchase SQL standards documents from ISO or ANSI. A
draft of SQL:2008 is freely available as a zip archive.[23]

[edit] Standard structure

The SQL standard is divided into several parts, including:

SQL Framework, provides logical concept

SQL/Foundation, defined in ISO/IEC 9075, Part 2. This part of the standard contains
the most central elements of the language. It consists of both mandatory and
optional features.

The SQL/Bindings, specifies how SQL is to be bound to variable host

languages,excluding Java.

The SQL/CLI, or Call-Level Interface, part is defined in ISO/IEC 9075, Part 3. SQL/CLI
defines common interfacing components (structures and procedures) that can be
used to execute SQL statements from applications written in other programming
languages. SQL/CLI is defined in such a way that SQL statements and SQL/CLI
procedure calls are treated as separate from the calling application's source code.
Open Database Connectivity is a well-known superset of SQL/CLI. This part of the
standard consists solely of mandatory features.

The SQL/PSM, or Persistent Stored Modules, part is defined by ISO/IEC 9075, Part 4.
SQL/PSM standardizes procedural extensions for SQL, including flow of control,
condition handling, statement condition signals and resignals, cursors and local
variables, and assignment of expressions to variables and parameters. In addition,
SQL/PSM formalizes declaration and maintenance of persistent database language
routines (e.g., "stored procedures"). This part of the standard consists solely of
optional features.

The SQL/MED, or Management of External Data, part is defined by ISO/IEC 9075,

Part 9. SQL/MED provides extensions to SQL that define foreign-data wrappers and
datalink types to allow SQL to manage external data. External data is data that is
accessible to, but not managed by, an SQL-based DBMS. This part of the standard
consists solely of optional features.

The SQL/OLB, or Object Language Bindings, part is defined by ISO/IEC 9075, Part 10.
SQL/OLB defines the syntax and symantics of SQLJ, which is SQL embedded in Java.
The standard also describes mechanisms to ensure binary portability of SQLJ
applications, and specifies various Java packages and their contained classes. This
part of the standard consists solely of optional features.

The SQL/MM (Multimedia), This extends SQL to deal intelligently with large,complex
and sometimes streaming items of data, such as video,audio and spatial data.

The SQL/Schemata, or Information and Definition Schemas, part is defined by

ISO/IEC 9075, Part 11. SQL/Schemata defines the Information Schema and Definition
Schema, providing a common set of tools to make SQL databases and objects self-
describing. These tools include the SQL object identifier, structure and integrity
constraints, security and authorization specifications, features and packages of
ISO/IEC 9075, support of features provided by SQL-based DBMS implementations,
SQL-based DBMS implementation information and sizing items, and the values
supported by the DBMS implementations.[24] This part of the standard contains
both mandatory and optional features.

The SQL/JRT, or SQL Routines and Types for the Java Programming Language, part is
defined by ISO/IEC 9075, Part 13. SQL/JRT specifies the ability to invoke static Java
methods as routines from within SQL applications. It also calls for the ability to use
Java classes as SQL structured user-defined types. This part of the standard consists
solely of optional features.

The SQL/XML, or XML-Related Specifications, part is defined by ISO/IEC 9075, Part

14. SQL/XML specifies SQL-based extensions for using XML in conjunction with SQL.
The XML data type is introduced, as well as several routines, functions, and XML-to-
SQL data type mappings to support manipulation and storage of XML in an SQL
database. This part of the standard consists solely of optional features.

[edit] Alternatives to SQL

A distinction should be made between alternatives to relational query languages
and alternatives to SQL. Below are proposed relational alternatives to SQL. See
navigational database for alternatives to relational:

* .QL - object-oriented Datalog

* 4D Query Language (4D QL)

* Datalog

* Hibernate Query Language (HQL) - A Java-based tool that uses modified SQL

* HTSQL - URL based query method

* IBM Business System 12 (IBM BS12) - one of the first fully relational database
management systems, introduced in 1982

* ISBL

* Java Persistence Query Language (JPQL) - The query language used by the Java
Persistence API in Java EE5

* LINQ

* Object Query Language

* QBE (Query By Example) created by Moshè Zloof, IBM 1977

* Quel introduced in 1974 by the U.C. Berkeley Ingres project.

* Tutorial D

* XQuery

[edit] See also

* Comparison of object-relational database management systems

* Comparison of relational database management systems

* D (data language specification)

* D4 (programming language) (an implementation of D)

* Hierarchical model
 * List of relational database management systems

* MUMPS

* NoSQL

* Search suggest drop-down list

========

---------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------

http://sqlcourse.com/intro.html

What is SQL?

SQL (pronounced "ess-que-el") stands for Structured Query Language. SQL is used
to communicate with a database. According to ANSI (American National Standards
Institute), it is the standard language for relational database management systems.
SQL statements are used to perform tasks such as update data on a database, or
retrieve data from a database. Some common relational database management
systems that use SQL are: Oracle, Sybase, Microsoft SQL Server, Access, Ingres, etc.
Although most database systems use SQL, most of them also have their own
additional proprietary extensions that are usually only used on their system.
However, the standard SQL commands such as "Select", "Insert", "Update",
"Delete", "Create", and "Drop" can be used to accomplish almost everything that
one needs to do with a database. This tutorial will provide you with the instruction
on the basics of each of these commands as well as allow you to put them to
practice using the SQL Interpreter.
Table Basics

A relational database system contains one or more objects called tables. The data
or information for the database are stored in these tables. Tables are uniquely
identified by their names and are comprised of columns and rows. Columns contain
the column name, data type, and any other attributes for the column. Rows contain
the records or data for the columns. Here is a sample table called "weather".

city, state, high, and low are the columns. The rows contain the data for this table:

Weather

city state high low

Phoenix Arizona 105 90

Tucson Arizona 101 92

Flagstaff Arizona 88 69

San Diego California 77 60

Albuquerque NewMexico 80 72

Selecting Data

The select statement is used to query the database and retrieve selected data that
match the criteria that you specify. Here is the format of a simple select statement:

select "column1"

[,"column2",etc]

from "tablename"
 [where "condition"];

[] = optional

The column names that follow the select keyword determine which columns will be
returned in the results. You can select as many column names that you'd like, or
you can use a "*" to select all columns.

The table name that follows the keyword from specifies the table that will be
queried to retrieve the desired results.

The where clause (optional) specifies which data values or rows will be returned or
displayed, based on the criteria described after the keyword where.

Conditional selections used in the where clause:

= Equal

> Greater than

< Less than

>= Greater than or equal

<= Less than or equal

<> Not equal to

LIKE *See note below

The LIKE pattern matching operator can also be used in the conditional selection of
the where clause. Like is a very powerful operator that allows you to select only
rows that are "like" what you specify. The percent sign "%" can be used as a wild
card to match any possible character that might appear before or after the
characters specified. For example:

select first, last, city

 from empinfo

where first LIKE 'Er%';

This SQL statement will match any first names that start with 'Er'. Strings must be in
single quotes.

Or you can specify,

select first, last

from empinfo

where last LIKE '%s';

This statement will match any last names that end in a 's'.

select * from empinfo

where first = 'Eric';

This will only select rows where the first name equals 'Eric' exactly.

Sample Table: empinfo

first last id age city state

John Jones 9998045 Payson Arizona

Mary Jones 9998225 Payson Arizona

Eric Edwards 8823232 San Diego California

Mary Ann Edwards 8823332 Phoenix Arizona

Ginger Howell 9800242 Cottonwood Arizona

Sebastian Smith 9200123 Gila Bend Arizona

Gus Gray 2232235 Bagdad Arizona

Mary Ann May 3232652 Tucson Arizona

Erica Williams 3232760 Show Low Arizona

Leroy Brown 3238022 Pinetop Arizona

Elroy Cleaver 3238222 Globe Arizona

Enter the following sample select statements in the SQL Interpreter Form at the
bottom of this page. Before you press "submit", write down your expected results.
Press "submit", and compare the results.

select first, last, city from empinfo;

select last, city, age from empinfo

where age > 30;

select first, last, city, state from empinfo

where first LIKE 'J%';

select * from empinfo;

select first, last, from empinfo

where last LIKE '%s';

select first, last, age from empinfo

where last LIKE '%illia%';

select * from empinfo where first = 'Eric';

Select statement exercises

Enter select statements to:

1. Display the first name and age for everyone that's in the table.

2. Display the first name, last name, and city for everyone that's not from Payson.

3. Display all columns for everyone that is over 40 years old.

4. Display the first and last names for everyone whose last name ends in an "ay".

5. Display all columns for everyone whose first name equals "Mary".

6. Display all columns for everyone whose first name contains "Mary".

-------------------------------------

Selecting Data Answers:

1.

Display everyone's first name and their age for everyone that's in table.

select first,

age

from empinfo;

2.

Display the first name, last name, and city for everyone that's not from Payson.

select first,
 last,

city

from empinfo

where city <>

'Payson';

3.

Display all columns for everyone that is over 40 years old.

select * from empinfo

where age > 40;

4.

Display the first and last names for everyone whose last name ends in an "ay".

select first, last from empinfo

where last LIKE '%ay';

5.

Display all columns for everyone whose first name equals "Mary".

select * from empinfo

where first = 'Mary';

 6.

Display all columns for everyone whose first name contains "Mary".

select * from empinfo

where first LIKE '%Mary%';

-------------------------------------------------------------------------------------------------------------------

web address for sql interpreter :

http://sqlcourse.com/select.html

-------------------------------------------------------------------------------------------------------------------

Creating Tables

The create table statement is used to create a new table. Here is the format of a
simple create table statement:

create table "tablename"

("column1" "data type",

"column2" "data type",

"column3" "data type");

Format of create table if you were to use optional constraints:

create table "tablename"

("column1" "data type"

[constraint],
"column2" "data type"

[constraint],

"column3" "data type"

[constraint]);

[ ] = optional

Note: You may have as many columns as you'd like, and the constraints are
optional.

Example:

create table employee

(first varchar(15),

last varchar(20),

age number(3),

address varchar(30),

city varchar(20),

state varchar(20));

To create a new table, enter the keywords create table followed by the table name,
followed by an open parenthesis, followed by the first column name, followed by the
data type for that column, followed by any optional constraints, and followed by a
closing parenthesis. It is important to make sure you use an open parenthesis
before the beginning table, and a closing parenthesis after the end of the last
column definition. Make sure you seperate each column definition with a comma. All
SQL statements should end with a ";".

The table and column names must start with a letter and can be followed by letters,
numbers, or underscores - not to exceed a total of 30 characters in length. Do not
use any SQL reserved keywords as names for tables or column names (such as
"select", "create", "insert", etc).

Data types specify what the type of data can be for that particular column. If a
column called "Last_Name", is to be used to hold names, then that particular
column should have a "varchar" (variable-length character) data type.

Here are the most common Data types:

char(size) Fixed-length character string. Size is specified in parenthesis. Max 255

bytes.

varchar(size) Variable-length character string. Max size is specified in

parenthesis.

number(size) Number value with a max number of column digits specified in

parenthesis.

date Date value

number(size,d) Number value with a maximum number of digits of "size" total,

with a maximum number of "d" digits to the right of the decimal.

What are constraints? When tables are created, it is common for one or more
columns to have constraints associated with them. A constraint is basically a rule
associated with a column that the data entered into that column must follow. For
example, a "unique" constraint specifies that no two records can have the same
value in a particular column. They must all be unique. The other two most popular
constraints are "not null" which specifies that a column can't be left blank, and
"primary key". A "primary key" constraint defines a unique identification of each
record (or row) in a table. All of these and more will be covered in the future
Advanced release of this Tutorial. Constraints can be entered in this SQL interpreter,
however, they are not supported in this Intro to SQL tutorial & interpreter. They will
be covered and supported in the future release of the Advanced SQL tutorial - that
is, if "response" is good.

It's now time for you to design and create your own table. You will use this table
throughout the rest of the tutorial. If you decide to change or redesign the table,
you can either drop it and recreate it or you can create a completely different one.
The SQL statement drop will be covered later.
Create Table Exercise

You have just started a new company. It is time to hire some employees. You will
need to create a table that will contain the following information about your new
employees: firstname, lastname, title, age, and salary. After you create the table,
you should receive a small form on the screen with the appropriate column names.
If you are missing any columns, you need to double check your SQL statement and
recreate the table. Once it's created successfully, go to the "Insert" lesson.

IMPORTANT: When selecting a table name, it is important to select a unique name

that no one else will use or guess. Your table names should have an underscore
followed by your initials and the digits of your birth day and month. For example,
Tom Smith, who was born on November 2nd, would name his table
myemployees_ts0211 Use this convention for all of the tables you create. Your
tables will remain on a shared database until you drop them, or they will be cleaned
up if they aren't accessed in 4-5 days. If "support" is good, I hope to eventually
extend this to at least one week. When you are finished with your table, it is
important to drop your table (covered in last lesson).

---------------------------------------------------------------------------------------------------------------

Creating Tables Answer:

Your create statement should resemble:

create table

myemployees_ts0211

(firstname varchar(30),

lastname varchar(30),

title varchar(30),

age number(2),

salary number(8,2));

------------------------------
Inserting into a Table

The insert statement is used to insert or add a row of data into the table.

To insert records into a table, enter the key words insert into followed by the table
name, followed by an open parenthesis, followed by a list of column names
separated by commas, followed by a closing parenthesis, followed by the keyword
values, followed by the list of values enclosed in parenthesis. The values that you
enter will be held in the rows and they will match up with the column names that
you specify. Strings should be enclosed in single quotes, and numbers should not.

insert into "tablename"

(first_column,...last_column)

values (first_value,...last_value);

In the example below, the column name first will match up with the value 'Luke',
and the column name state will match up with the value 'Georgia'.

Example:

insert into employee

(first, last, age, address, city, state)

values ('Luke', 'Duke', 45, '2130 Boars Nest',

'Hazard Co', 'Georgia');

Note: All strings should be enclosed between single quotes: 'string'

Insert statement exercises

It is time to insert data into your new employee table.

Your first three employees are the following:

Jonie Weber, Secretary, 28, 19500.00

Potsy Weber, Programmer, 32, 45300.00

Dirk Smith, Programmer II, 45, 75020.00

Enter these employees into your table first, and then insert at least 5 more of your
own list of employees in the table.

After they're inserted into the table, enter select statements to:

1. Select all columns for everyone in your employee table.

2. Select all columns for everyone with a salary over 30000.

3. Select first and last names for everyone that's under 30 years old.

4. Select first name, last name, and salary for anyone with "Programmer" in their
title.

5. Select all columns for everyone whose last name contains "ebe".

6. Select the first name for everyone whose first name equals "Potsy".

7. Select all columns for everyone over 80 years old.

8. Select all columns for everyone whose last name ends in "ith".

Create at least 5 of your own select statements based on specific information that
you'd like to retrieve.

-------------------

Inserting into a Table Answers

Your Insert statements should be similar to: (note: use your own table name that
you created)

insert into

myemployees_ts0211

(firstname, lastname,

title, age, salary)

values ('Jonie', 'Weber',

'Secretary', 28,

19500.00);

1.

Select all columns for everyone in your employee table.

select * from

myemployees_ts0211

2.

Select all columns for everyone with a salary over 30000.

select * from

myemployees_ts0211

where salary > 30000

 3.

Select first and last names for everyone that's under 30 years old.

select firstname, lastname

from myemployees_ts0211

where age < 30

4.

Select first name, last name, and salary for anyone with "Programmer" in their
title.

select firstname, lastname, salary

from myemployees_ts0211

where title LIKE '%Programmer%'

5.

Select all columns for everyone whose last name contains "ebe".

select * from

myemployees_ts0211

where lastname LIKE '%ebe%'

6.
 Select the first name for everyone whose first name equals "Potsy".

select firstname from

myemployees_ts0211

where firstname = 'Potsy'

7.

Select all columns for everyone over 80 years old.

select * from

myemployees_ts0211

where age > 80

8.

Select all columns for everyone whose last name ends in "ith".

select * from

myemployees_ts0211

where lastname LIKE '%ith'

---------------------------------------------------------------------------------------------------------

Updating Records
The update statement is used to update or change records that match a specified
criteria. This is accomplished by carefully constructing a where clause.

update "tablename"

set "columnname" =

"newvalue"

[,"nextcolumn" =

"newvalue2"...]

where "columnname"

OPERATOR "value"

[and|or "column"

OPERATOR "value"];

[] = optional

[The above example was line wrapped for better viewing on this Web page.]

Examples:

update phone_book

set area_code = 623

where prefix = 979;

update phone_book

set last_name = 'Smith', prefix=555, suffix=9292

where last_name = 'Jones';

update employee

set age = age+1

where first_name='Mary' and last_name='Williams';

Update statement exercises

After each update, issue a select statement to verify your changes.

1. Jonie Weber just got married to Bob Williams. She has requested that her last
name be updated to Weber-Williams.

2. Dirk Smith's birthday is today, add 1 to his age.

3. All secretaries are now called "Administrative Assistant". Update all titles
accordingly.

4. Everyone that's making under 30000 are to receive a 3500 a year raise.

5. Everyone that's making over 33500 are to receive a 4500 a year raise.

6. All "Programmer II" titles are now promoted to "Programmer III".

7. All "Programmer" titles are now promoted to "Programmer II".

Create at least 5 of your own update statements and submit them.

-----------------------------------------------------

Answers to exercises
Become a Marketplace Partner

Business Insurance for the IT services industry.

Business EMail

Colocation and Data Center Experts

Your trusted Web Host since 1997

Colocation and Data Center Experts

Business Insurance for the IT services industry.

MARKETPLACE
 Image Ad

Build a Secure Online Intranet

Quick & Easy - An Intranet Everyone Can Use. Try CentralDesktop - Free 30-days!

www.CentralDesktop.com

Image Ad

Network Bandwidth Monitoring Software

Monitor Bandwidth, Network Traffic using Netflow. Get Reports,Alerts,Emails.Try

www.NetFlowAnalyzer.com

Image Ad

Need to archive your Website?

Ensure you are compliant - Let us archive a daily screenshot of your website

www.website-archive.com

Updating Records Answers:

1.

Jonie Weber just got married to Bob Williams. She has requested that her last
name be updated to Weber-Williams.

update

myemployees_ts0211

set lastname=

'Weber-Williams'

where firstname=

'Jonie'
 and lastname=

'Weber';

2.

Dirk Smith's birthday is today, add 1 to his age.

update myemployees_ts0211

set age=age+1

where firstname='Dirk' and lastname='Smith';

3.

All secretaries are now called "Administrative Assistant". Update all titles
accordingly.

update myemployees_ts0211

set title = 'Administrative Assistant'

where title = 'Secretary';

4.

Everyone that's making under 30000 are to receive a 3500 a year raise.

update myemployees_ts0211

set salary = salary + 3500

where salary < 30000;

 5.

Everyone that's making over 33500 are to receive a 4500 a year raise.

update myemployees_ts0211

set salary = salary + 4500

where salary > 33500;

6.

All "Programmer II" titles are now promoted to "Programmer III".

update myemployees_ts0211

set title = 'Programmer III'

where title = 'Programmer II'

7.

All "Programmer" titles are now promoted to "Programmer II".

update myemployees_ts0211

set title = 'Programmer II'

where title = 'Programmer'

------------------------------------------

Deleting Records
The delete statement is used to delete records or rows from the table.

delete from "tablename"

where "columnname"

OPERATOR "value"

[and|or "column"

OPERATOR "value"];

[ ] = optional

[The above example was line wrapped for better viewing on this Web page.]

Examples:

delete from employee;

Note: if you leave off the where clause, all records will be deleted!

delete from employee

where lastname = 'May';

delete from employee

where firstname = 'Mike' or firstname = 'Eric';

To delete an entire record/row from a table, enter "delete from" followed by the
table name, followed by the where clause which contains the conditions to delete. If
you leave off the where clause, all records will be deleted.

Delete statement exercises

(Use the select statement to verify your deletes):

1. Jonie Weber-Williams just quit, remove her record from the table.

2. It's time for budget cuts. Remove all employees who are making over 70000
dollars.

Create at least two of your own delete statements, and then issue a command to
delete all records from the table.

---------------

Deleting Records Answers:

1.

Jonie Weber-Williams just quit, remove her record from the table:

delete

from myemployees_ts0211

where lastname =

'Weber-Williams';

2.
 It's time for budget cuts. Remove all employees who are making over 70000
dollars.

delete

from myemployees_ts0211

where salary >

70000;

--------------

Drop a Table

The drop table command is used to delete a table and all rows in the table.

To delete an entire table including all of its rows, issue the drop table command
followed by the tablename. drop table is different from deleting all of the records in
the table. Deleting all of the records in the table leaves the table including column
and constraint information. Dropping the table removes the table definition as well
as all of its rows.

drop table "tablename"

Example:

drop table myemployees_ts0211;

Drop Table exercises

1. Drop your employee table.

-------------

==================================================
================================

SQLCourse2=========================================
=========================================

This continuation course will provide you with critical need-to-know advanced
features and clauses of the SELECT statement that weren't supported in the
previous SQLCourse.com site. Everything you learn here will be ANSI SQL compliant
and should work with most SQL databases such as Oracle, SQL Server, mySQL, MS
Access, Informix, Sybase, or any other ANSI SQL compliant database.

If you're already familar with the basics of SQL, you can still use this as a refresher,
and practice some SQL statements.

Start Here - Intro

This Intermediate/Advanced SQL Tutorial will cover the SELECT statement in great
detail. The SELECT statement is the core of SQL, and it is likely that the vast
majority of your SQL commands will be SELECT statements. Due to the enormous
amount of options available for the SELECT statement, this entire tutorial has been
dedicated to it.

When constructing SQL Queries (with the SELECT statement), it is very useful to
know all of the possible options and the best or more efficient way to do things. This
Tutorial will help provide you with those skills.

Although it is recommended that you go through SQLCourse.com (the original site)

or at least the SELECT statement on SQLCourse.com, it isn't required. YOu can start
with this site, and then proceed to SQLCourse.com when you are finished.
SQLCourse.com covers four other SQL Commands and allows you to practice those
as well.

---------------------

SELECT Statement

The SELECT statement is used to query the database and retrieve selected data
that match the criteria that you specify.

The SELECT statement has five main clauses to choose from, although, FROM is the
only required clause. Each of the clauses have a vast selection of options,
parameters, etc. The clauses will be listed below, but each of them will be covered
in more detail later in the tutorial.

Here is the format of the SELECT statement:

SELECT [ALL | DISTINCT] column1[,column2]

FROM table1[,table2]

[WHERE "conditions"]

[GROUP BY "column-list"]

[HAVING "conditions]
[ORDER BY "column-list" [ASC | DESC] ]

FROM & WHERE clause quick review

Example:

SELECT name, age, salary

FROM employee

WHERE age > 50;

The above statement will select all of the values in the name, age, and salary
columns from the employee table whose age is greater than 50.

Note: Remember to put a semicolon at the end of your SQL statements. The ;
indicates that your SQL statment is complete and is ready to be interpreted.

Comparison Operators

= Equal

> Greater than

< Less than

>= Greater than or equal to

<= Less than or equal to

<> or != Not equal to

LIKE String comparison test

*Note about LIKE

Example:

SELECT name, title, dept

FROM employee

WHERE title LIKE 'Pro%';

The above statement will select all of the rows/values in the name, title, and dept
columns from the employee table whose title starts with 'Pro'. This may return job
titles including Programmer or Pro-wrestler.

ALL and DISTINCT are keywords used to select either ALL (default) or the "distinct"
or unique records in your query results. If you would like to retrieve just the unique
records in specified columns, you can use the "DISTINCT" keyword. DISTINCT will
discard the duplicate records for the columns you specified after the "SELECT"
statement: For example:

SELECT DISTINCT age

FROM employee_info;

This statement will return all of the unique ages in the employee_info table.
ALL will display "all" of the specified columns including all of the duplicates. The ALL
keyword is the default if nothing is specified.

Note: The following two tables will be used throughout this course. It is
recommended to have them open in another window or print them out.

Tutorial Tables

items_ordered

customers

Review Exercises

1. From the items_ordered table, select a list of all items purchased for customerid
10449. Display the customerid, item, and price for this customer.

2. Select all columns from the items_ordered table for whoever purchased a Tent.

3. Select the customerid, order_date, and item values from the items_ordered
table for any items in the item column that start with the letter "S".

4. Select the distinct items in the items_ordered table. In other words, display a
listing of each of the unique items from the items_ordered table.

5. Make up your own select statements and submit them.

::::::::::::

SELECT & FROM clause review

SELECT first_column_name, second_column_name

FROM table_name

WHERE first_column_name > 1000;

*The column names that follow the SELECT keyword determine which columns will
be returned in the results. You can select as many column names that you'd like, or
you can use a * to select all columns. The order they are specified will be the order
that they are returned in your query results.

*The table name that follows the keyword FROM specifies the table that will be
queried to retrieve the desired results.

*The WHERE clause (optional) specifies which data values or rows will be returned
or displayed, based on the criteria described after the keyword where

LIKE comparison test operator

SELECT first_column_name, second_column_name

FROM table_name

WHERE first_column_name LIKE 'Mc%';

::

The LIKE pattern matching operator can also be used in the conditional selection of
the where clause. Like is a very powerful character string comparison operator that
allows you to select only rows that are "like" what you specify. The percent sign "%"
can be used as a wild card to match any possible character that might appear
before or after the characters specified. For example:

select first, last, city

from empinfo

where first LIKE 'Mc%';

This SQL statement will match any first names that start with 'Mc'. Strings must be
in single quotes.

::

customerid order_date item quantity price

10330 30-Jun-1999 Pogo stick 1 28.00

10101 30-Jun-1999 Raft 1 58.00
10298 01-Jul-1999 Skateboard 1 33.00
10101 01-Jul-1999 Life Vest 4 125.00
10299 06-Jul-1999 Parachute 1 1250.00
10339 27-Jul-1999 Umbrella 1 4.50
10449 13-Aug-1999 Unicycle 1 180.79
10439 14-Aug-1999 Ski Poles 2 25.50
10101 18-Aug-1999 Rain Coat 1 18.30
10449 01-Sep-1999 Snow Shoes 1 45.00
10439 18-Sep-1999 Tent 1 88.00
10298 19-Sep-1999 Lantern 2 29.00
10410 28-Oct-1999 Sleeping Bag 1 89.22
10438 01-Nov-1999 Umbrella 1 6.75
10438 02-Nov-1999 Pillow 1 8.50
10298 01-Dec-1999 Helmet 1 22.00
10449 15-Dec-1999 Bicycle 1 380.50
10449 22-Dec-1999 Canoe 1 280.00
10101 30-Dec-1999 Hoola Hoop 3 14.75
10330 01-Jan-2000 Flashlight 4 28.00
10101 02-Jan-2000 Lantern 1 16.00
10299 18-Jan-2000 Inflatable Mattress 1 38.00
10438 18-Jan-2000 Tent 1 79.99
10413 19-Jan-2000 Lawnchair 4 32.00
10410 30-Jan-2000 Unicycle 1 192.50
10315 2-Feb-2000 Compass 1 8.00
10449 29-Feb-2000 Flashlight 1 4.50
10101 08-Mar-2000 Sleeping Bag 2 88.70
10298 18-Mar-2000 Pocket Knife 1 22.38
10449 19-Mar-2000 Canoe paddle 2 40.00
10298 01-Apr-2000 Ear Muffs 1 12.50
10330 19-Apr-2000 Shovel 1 16.75
customerid firstname lastname city state

10101 John Gray Lynden Washington

10298 Leroy Brown Pinetop Arizona
10299 Elroy Keller Snoqualmie Washington
10315 Lisa Jones Oshkosh Wisconsin
10325 Ginger Schultz Pocatello Idaho
10329 Kelly Mendoza Kailua Hawaii
10330 Shawn Dalton Cannon Beach Oregon
10338 Michael Howell Tillamook Oregon
10339 Anthony Sanchez Winslow Arizona
10408 Elroy Cleaver Globe Arizona
10410 Mary Ann Howell Charleston South Carolina
10413 Donald Davids Gila Bend Arizona
10419 Linda Sakahara Nogales Arizona
10429 Sarah Graham Greensboro North Carolina
10438 Kevin Smith Durango Colorado
10439 Conrad Giles Telluride Colorado
10449 Isabela Moore Yuma Arizona

SELECT Exercise Answers

Exercise #1

SELECT customerid, item, price

FROM items_ordered
WHERE customerid=10449;

Exercise #2

SELECT * FROM items_ordered

WHERE item = 'Tent';

Exercise #3
SELECT customerid, order_date, item
FROM items_ordered
WHERE item LIKE 's%';

Exercise #4

SELECT DISTINCT item

FROM items_ordered;

Aggregate Functions
MIN returns the smallest value in a given column

MAX returns the largest value in a given column

returns the sum of the numeric values in a

SUM
given column

AVG returns the average value of a given column

returns the total number of values in a given

COUNT
column

COUNT(
returns the number of rows in a table
*)

Aggregate functions are used to compute against a "returned column of numeric data" from your
SELECT statement. They basically summarize the results of a particular column of selected data.
We are covering these here since they are required by the next topic, "GROUP BY". Although
they are required for the "GROUP BY" clause, these functions can be used without the "GROUP
BY" clause. For example:

SELECT AVG(salary)

FROM employee;

This statement will return a single result which contains the average value of everything returned
in the salary column from the employee table.

Another example:
SELECT AVG(salary)

FROM employee;

WHERE title = 'Programmer';

This statement will return the average salary for all employees whose title is equal to
'Programmer'

Example:

SELECT Count(*)

FROM employees;

This particular statement is slightly different from the other aggregate functions since there isn't a
column supplied to the count function. This statement will return the number of rows in the
employees table.

Use these tables for the

exercises

items_ordered

customers

Review Exercises

1. Select the maximum price of any item ordered in the items_ordered table.
Hint: Select the maximum price only.

>

2. Select the average price of all of the items ordered that were purchased in
the month of Dec.
3. What are the total number of rows in the items_ordered table?
4. For all of the tents that were ordered in the items_ordered table, what is the
price of the lowest tent? Hint: Your query should return the price only.
Aggregate Function Exercise Answers

Exercise #1

SELECT max(price)
FROM items_ordered;

Exercise #2

SELECT avg(price)
FROM items_ordered
WHERE order_date LIKE '%Dec%';

Exercise #3

SELECT count(*)
FROM items_ordered;

Exercise #4

SELECT min(price) FROM items_ordered WHERE item = 'Tent';

GROUP BY clause

The GROUP BY clause will gather all of the rows together that contain data in the specified
column(s) and will allow aggregate functions to be performed on the one or more columns. This
can best be explained by an example:

GROUP BY clause syntax:

SELECT column1,
SUM(column2)

FROM "list-of-tables"

GROUP BY "column-list";

Let's say you would like to retrieve a list of the highest paid salaries in each dept:

SELECT max(salary), dept

FROM employee

GROUP BY dept;
This statement will select the maximum salary for the people in each unique department.
Basically, the salary for the person who makes the most in each department will be displayed.
Their, salary and their department will be returned.

Multiple Grouping Columns - What if I wanted to display their lastname too?

Use these tables for the

exercises

items_ordered

customers

For example, take a look at the items_ordered table. Let's say you want to group everything of
quantity 1 together, everything of quantity 2 together, everything of quantity 3 together, etc. If
you would like to determine what the largest cost item is for each grouped quantity (all quantity
1's, all quantity 2's, all quantity 3's, etc.), you would enter:

SELECT quantity, max(price)

FROM items_ordered

GROUP BY quantity;

Enter the statement in above, and take a look at the results to see if it returned what you were
expecting. Verify that the maximum price in each Quantity Group is really the maximum price.

Review Exercises

1. How many people are in each unique state in the customers table? Select the
state and display the number of people in each. Hint: count is used to count
rows in a column, sum works on numeric data only.
2. From the items_ordered table, select the item, maximum price, and minimum
price for each specific item in the table. Hint: The items will need to be
broken up into separate groups.
3. How many orders did each customer make? Use the items_ordered table.
Select the customerid, number of orders they made, and the sum of their
orders. Click the Group By answers link below if you have any problems.

GROUP BY Exercise Answers

Exercise #1
SELECT state, count(state)
FROM customers
GROUP BY state;

Exercise #2

SELECT item, max(price), min(price)

FROM items_ordered
GROUP BY item;

Exercise #3

SELECT customerid, count(customerid), sum(price)

FROM items_ordered
GROUP BY customerid;

HAVING clause

The HAVING clause allows you to specify conditions on the rows for each group - in other
words, which rows should be selected will be based on the conditions you specify. The HAVING
clause should follow the GROUP BY clause if you are going to use it.

HAVING clause syntax:

SELECT column1,
SUM(column2)

FROM "list-of-tables"

GROUP BY "column-list"

HAVING "condition";

HAVING can best be described by example. Let's say you have an employee table containing the
employee's name, department, salary, and age. If you would like to select the average salary for
each employee in each department, you could enter:

SELECT dept, avg(salary)

FROM employee

GROUP BY dept;

But, let's say that you want to ONLY calculate & display the average if their salary is over
20000:
SELECT dept, avg(salary)

FROM employee

GROUP BY dept

HAVING avg(salary) > 20000;

Use these tables for the
exercises

items_ordered

customers

Review Exercises (note: yes, they are similar to the group by exercises, but these contain
the HAVING clause requirements

1. How many people are in each unique state in the customers table that have
more than one person in the state? Select the state and display the number
of how many people are in each if it's greater than 1.
2. From the items_ordered table, select the item, maximum price, and minimum
price for each specific item in the table. Only display the results if the
maximum price for one of the items is greater than 190.00.
3. How many orders did each customer make? Use the items_ordered table.
Select the customerid, number of orders they made, and the sum of their
orders if they purchased more than 1 item.

Click the HAVING exercise answers link below if you have any problems.

HAVING Exercise Answers

Exercise #1

SELECT state, count(state)

FROM customers
GROUP BY state
HAVING count(state) > 1;

Exercise #2

SELECT item, max(price), min(price)

FROM items_ordered
GROUP BY item
HAVING max(price) > 190.00;

Exercise #3
SELECT customerid, count(customerid), sum(price)
FROM items_ordered
GROUP BY customerid
HAVING count(customerid) > 1;

ORDER BY clause

ORDER BY is an optional clause which will allow you to display the results of your query in a
sorted order (either ascending order or descending order) based on the columns that you specify
to order by.

ORDER BY clause syntax:

SELECT column1, SUM(column2)

FROM "list-of-tables"

ORDER BY

"column-list" [ASC | DESC];

[ ] = optional

This statement will select the employee_id, dept, name, age, and salary from the employee_info
table where the dept equals 'Sales' and will list the results in Ascending (default) order based on
their Salary.

ASC = Ascending Order - default

DESC = Descending Order

For example:

SELECT employee_id, dept, name, age, salary

FROM employee_info
WHERE dept = 'Sales'

ORDER BY salary;

If you would like to order based on multiple columns, you must seperate the columns with
commas. For example:

SELECT employee_id, dept, name, age, salary

FROM employee_info

WHERE dept = 'Sales'

ORDER BY salary, age DESC;

Use these tables for the
exercises

items_ordered

customers

Review Exercises

1. Select the lastname, firstname, and city for all customers in the customers
table. Display the results in Ascending Order based on the lastname.
2. Same thing as exercise #1, but display the results in Descending order.
3. Select the item and price for all of the items in the items_ordered table that
the price is greater than 10.00. Display the results in Ascending order based
on the price.

Click the ORDER BY Exercise Answers link below if you have any problems.

ORDER BY Exercise Answers

Exercise #1

SELECT lastname, firstname, city

FROM customers
ORDER BY lastname;

Exercise #2

SELECT lastname, firstname, city

FROM customers
ORDER BY lastname DESC;
Exercise #3

SELECT item, price

FROM items_ordered
WHERE price > 10.00
ORDER BY price ASC;

Combining conditions and Boolean Operators

The AND operator can be used to join two or more conditions in the WHERE clause. Both sides
of the AND condition must be true in order for the condition to be met and for those rows to be
displayed.

SELECT column1,
SUM(column2)

FROM "list-of-tables"

WHERE "condition1" AND

"condition2";

The OR operator can be used to join two or more conditions in the WHERE clause also.
However, either side of the OR operator can be true and the condition will be met - hence, the
rows will be displayed. With the OR operator, either side can be true or both sides can be true.

For example:

SELECT employeeid, firstname, lastname, title, salary

FROM employee_info

WHERE salary >= 50000.00 AND title = 'Programmer';

This statement will select the employeeid, firstname, lastname, title, and salary from the
employee_info table where the salary is greater than or equal to 50000.00 AND the title is equal
to 'Programmer'. Both of these conditions must be true in order for the rows to be returned in the
query. If either is false, then it will not be displayed.

Although they are not required, you can use paranthesis around your conditional expressions to
make it easier to read:

SELECT employeeid, firstname, lastname, title, salary

FROM employee_info

WHERE (salary >= 50000.00) AND (title = 'Programmer');

Another Example:

SELECT firstname, lastname, title, salary

FROM employee_info

WHERE (title = 'Sales') OR (title = 'Programmer');

This statement will select the firstname, lastname, title, and salary from the employee_info table
where the title is either equal to 'Sales' OR the title is equal to 'Programmer'.

Use these tables for the

exercises

items_ordered

customers

Review Exercises

1. Select the customerid, order_date, and item from the items_ordered table for
all items unless they are 'Snow Shoes' or if they are 'Ear Muffs'. Display the
rows as long as they are not either of these two items.
2. Select the item and price of all items that start with the letters 'S', 'P', or 'F'.

Click the exercise answers link below if you have any problems.

Combining Conditions and Boolean Operators Exercise

Answers

Exercise #1

SELECT customerid, order_date, item

FROM items_ordered
WHERE (item <> 'Snow shoes') AND (item <> 'Ear muffs');

Note: Yes, that is correct, you do want to use an AND here. If you were to use an OR here, then
either side of the OR will be true, and EVERY row will be displayed. For example, when it
encounters 'Ear muffs', it will evaluate to True since 'Ear muffs' are not equal to 'Snow shoes'.
Exercise #2

SELECT item, price

FROM items_ordered
WHERE (item LIKE 'S%') OR (item LIKE 'P%') OR (item LIKE 'F%');

IN and BETWEEN Conditional Operators

SELECT col1, SUM(col2)

FROM "list-of-tables"

WHERE col3 IN
(list-of-values);

SELECT col1, SUM(col2)

FROM "list-of-tables"

WHERE col3 BETWEEN value1

AND value2;

The IN conditional operator is really a set membership test operator. That is, it is used to test
whether or not a value (stated before the keyword IN) is "in" the list of values provided after the
keyword IN.

For example:

SELECT employeeid, lastname, salary

FROM employee_info

WHERE lastname IN ('Hernandez', 'Jones', 'Roberts', 'Ruiz');

This statement will select the employeeid, lastname, salary from the employee_info table where
the lastname is equal to either: Hernandez, Jones, Roberts, or Ruiz. It will return the rows if it is
ANY of these values.

The IN conditional operator can be rewritten by using compound conditions using the equals
operator and combining it with OR - with exact same output results:

SELECT employeeid, lastname, salary

FROM employee_info

WHERE lastname = 'Hernandez' OR lastname = 'Jones' OR lastname = 'Roberts'

OR lastname = 'Ruiz';
As you can see, the IN operator is much shorter and easier to read when you are testing for more
than two or three values.

You can also use NOT IN to exclude the rows in your list.

The BETWEEN conditional operator is used to test to see whether or not a value (stated before
the keyword BETWEEN) is "between" the two values stated after the keyword BETWEEN.

For example:

SELECT employeeid, age, lastname, salary

FROM employee_info

WHERE age BETWEEN 30 AND 40;

This statement will select the employeeid, age, lastname, and salary from the employee_info
table where the age is between 30 and 40 (including 30 and 40).

This statement can also be rewritten without the BETWEEN operator:

SELECT employeeid, age, lastname, salary

FROM employee_info

WHERE age >= 30 AND age <= 40;

You can also use NOT BETWEEN to exclude the values between your range.

Use these tables for the

exercises

items_ordered

customers

Review Exercises

1. Select the date, item, and price from the items_ordered table for all of the
rows that have a price value ranging from 10.00 to 80.00.
 2. Select the firstname, city, and state from the customers table for all of the
rows where the state value is either: Arizona, Washington, Oklahoma,
Colorado, or Hawaii.

Click the exercise answers link below if you have any problems.

IN & BETWEEN Exercise Answers

Exercise #1

SELECT order_date, item, price

FROM items_ordered
WHERE price BETWEEN 10.00 AND 80.00;

Exercise #2

SELECT firstname, city, state

FROM customers
WHERE state IN ('Arizona', 'Washington', 'Oklahoma', 'Colorado', 'Hawaii');

Mathematical Operators

Standard ANSI SQL-92 supports the following first four basic arithmetic operators:

+ addition

- subtraction

multiplicatio
*
n

/ division

% modulo

The modulo operator determines the integer remainder of the division. This operator is not ANSI
SQL supported, however, most databases support it. The following are some more useful
mathematical functions to be aware of since you might need them. These functions are not
standard in the ANSI SQL-92 specs, therefore they may or may not be available on the specific
RDBMS that you are using. However, they were available on several major database systems
that I tested. They WILL work on this tutorial.

ABS(x) returns the absolute value of x

SIGN(x) returns the sign of input x as -1, 0, or 1 (negative, zero, or positive

 respectively)

modulo - returns the integer remainder of x divided by y (same as x

MOD(x,y)
%y)

FLOOR(x) returns the largest integer value that is less than or equal to x

CEILING(x) or
returns the smallest integer value that is greater than or equal to x
CEIL(x)

POWER(x,y) returns the value of x raised to the power of y

ROUND(x) returns the value of x rounded to the nearest whole integer

returns the value of x rounded to the number of decimal places

ROUND(x,d)
specified by the value d

SQRT(x) returns the square-root value of x

For example:

SELECT round(salary), firstname

FROM employee_info

This statement will select the salary rounded to the nearest whole value and the firstname from
the employee_info table.

Use these tables for the

exercises

items_ordered

customers

Review Exercises

1. Select the item and per unit price for each item in the items_ordered table.
Hint: Divide the price by the quantity.

Click the exercise answers link below if you have any problems.
Mathematical Function Exercise Answers

Exercise #1

select item, sum(price)/sum(quantity)

from items_ordered
group by item;

Table Joins, a must

All of the queries up until this point have been useful with the exception of one major limitation -
that is, you've been selecting from only one table at a time with your SELECT statement. It is
time to introduce you to one of the most beneficial features of SQL & relational database
systems - the "Join". To put it simply, the "Join" makes relational database systems "relational".

Joins allow you to link data from two or more tables together into a single query result--from one
single SELECT statement.

A "Join" can be recognized in a SQL SELECT statement if it has more than one table after the
FROM keyword.

For example:

SELECT "list-of-columns"

FROM table1,table2

WHERE "search-condition(s)"

Joins can be explained easier by demonstrating what would happen if you worked with one table
only, and didn't have the ability to use "joins". This single table database is also sometimes
referred to as a "flat table". Let's say you have a one-table database that is used to keep track of
all of your customers and what they purchase from your store:

firs las addre cit stat zi dat ite pric

id
t t ss y e p e m e

Everytime a new row is inserted into the table, all columns will be be updated, thus resulting in
unnecessary "redundant data". For example, every time Wolfgang Schultz purchases something,
the following rows will be inserted into the table:

id first last address city stat zip date item price

 e

1098 Wolfgan Schult 300 N. 1st Yum 8500 03229 snowboar

AZ 45.00
2 g z Ave a 2 9 d

1098 Wolfgan Schult 300 N. 1st Yum 8500 08289 snow

AZ 35.00
2 g z Ave a 2 9 shovel

1098 Wolfgan Schult 300 N. 1st Yum 8500 09119

AZ gloves 15.00
2 g z Ave a 2 9

1098 Wolfgan Schult 300 N. 1st Yum 8500 10099

AZ lantern 35.00
2 g z Ave a 2 9

1098 Wolfgan Schult 300 N. 1st Yum 8500 02290

AZ tent 85.00
2 g z Ave a 2 0

An ideal database would have two tables:

1. One for keeping track of your customers

2. And the other to keep track of what they purchase:

"Customer_info" table:

customer_nu firstna lastna addre cit stat

zip
mber me me ss y e

"Purchases" table:

customer_nu dat ite pric

mber e m e

Now, whenever a purchase is made from a repeating customer, the 2nd table, "Purchases" only
needs to be updated! We've just eliminated useless redundant data, that is, we've just normalized
this database!

Notice how each of the tables have a common "cusomer_number" column. This column, which
contains the unique customer number will be used to JOIN the two tables. Using the two new
tables, let's say you would like to select the customer's name, and items they've purchased. Here
is an example of a join statement to accomplish this:
SELECT customer_info.firstname, customer_info.lastname, purchases.item

FROM customer_info, purchases

WHERE customer_info.customer_number = purchases.customer_number;

This particular "Join" is known as an "Inner Join" or "Equijoin". This is the most common type
of "Join" that you will see or use.

Notice that each of the colums are always preceeded with the table name and a period. This isn't
always required, however, it IS good practice so that you wont confuse which colums go with
what tables. It is required if the name column names are the same between the two tables. I
recommend preceeding all of your columns with the table names when using joins.

Note: The syntax described above will work with most Database Systems -including the one
with this tutorial. However, in the event that this doesn't work with yours, please check
your specific database documentation.

Although the above will probably work, here is the ANSI SQL-92 syntax specification for an
Inner Join using the preceding statement above that you might want to try:

SELECT customer_info.firstname, customer_info.lastname, purchases.item

FROM customer_info INNER JOIN purchases

ON customer_info.customer_number = purchases.customer_number;

Another example:

SELECT employee_info.employeeid, employee_info.lastname,

employee_sales.comission

FROM employee_info, employee_sales

WHERE employee_info.employeeid = employee_sales.employeeid;

This statement will select the employeeid, lastname (from the employee_info table), and the
comission value (from the employee_sales table) for all of the rows where the employeeid in the
employee_info table matches the employeeid in the employee_sales table.

Use these tables for the

exercises

items_ordered

customers
Review Exercises

1. Write a query using a join to determine which items were ordered by each of
the customers in the customers table. Select the customerid, firstname,
lastname, order_date, item, and price for everything each customer
purchased in the items_ordered table.
2. Repeat exercise #1, however display the results sorted by state in
descending order.

Click the exercise answers link below if you have any problems.

Answers to these Exercises

What about Outer Joins?

Table Join Exercise Answers

Exercise #1

SELECT customers.customerid, customers.firstname, customers.lastname,

items_ordered.order_date, items_ordered.item, items_ordered.price
FROM customers, items_ordered
WHERE customers.customerid = items_ordered.customerid;

Exercise #2

SELECT customers.customerid, customers.firstname, customers.state, items_ordered.item

FROM customers, items_ordered
WHERE customers.customerid = items_ordered.customerid
ORDER BY customers.state DESC;

SQL JOIN
The SQL JOIN clause is used whenever we have to select data from 2 or more
tables.

To be able to use SQL JOIN clause to extract data from 2 (or more) tables, we need a
relationship between certain columns in these tables.

We are going to illustrate our SQL JOIN example with the following 2 tables:

Customers:
 LastNam
CustomerID FirstName Email DOB Phone
e

John.Smith@yahoo.co
1 John Smith 2/4/1968 626 222-2222
m

2 Steven Goldfish goldfish@fishhere.net 4/4/1974 323 455-4545

3 Paula Brown pb@herowndomain.org 5/24/1978 416 323-3232

4 James Smith jim@supergig.co.uk 20/10/1980 416 323-8888

Sales:

CustomerID Date SaleAmount

2 5/6/2004 $100.22

1 5/7/2004 $99.95

3 5/7/2004 $122.95

3 5/13/2004 $100.00

4 5/22/2004 $555.55

As you can see those 2 tables have common field called CustomerID and thanks to that we can
extract information from both tables by matching their CustomerID columns.

Consider the following SQL statement:

SELECT Customers.FirstName, Customers.LastName, SUM(Sales.SaleAmount) AS

SalesPerCustomer
FROM Customers, Sales
WHERE Customers.CustomerID = Sales.CustomerID
GROUP BY Customers.FirstName, Customers.LastName

The SQL expression above will select all distinct customers (their first and last names) and the
total respective amount of dollars they have spent.
The SQL JOIN condition has been specified after the SQL WHERE clause and says that the 2
tables have to be matched by their respective CustomerID columns.
Here is the result of this SQL statement:

FirstName LastName SalesPerCustomers

John Smith $99.95

Steven Goldfish $100.22

Paula Brown $222.95

James Smith $555.55

The SQL statement above can be re-written using the SQL JOIN clause like this:

SELECT Customers.FirstName, Customers.LastName, SUM(Sales.SaleAmount) AS

SalesPerCustomer
FROM Customers JOIN Sales
ON Customers.CustomerID = Sales.CustomerID
GROUP BY Customers.FirstName, Customers.LastName

There are 2 types of SQL JOINS – INNER JOINS and OUTER JOINS. If you don't put
INNER or OUTER keywords in front of the SQL JOIN keyword, then INNER JOIN is used. In
short "INNER JOIN" = "JOIN" (note that different databases have different syntax for their
JOIN clauses).

The INNER JOIN will select all rows from both tables as long as there is a match between the
columns we are matching on. In case we have a customer in the Customers table, which still
hasn't made any orders (there are no entries for this customer in the Sales table), this customer
will not be listed in the result of our SQL query above.

If the Sales table has the following rows:

CustomerID Date SaleAmount

2 5/6/2004 $100.22

1 5/6/2004 $99.95

And we use the same SQL JOIN statement from above:

SELECT Customers.FirstName, Customers.LastName, SUM(Sales.SaleAmount) AS
SalesPerCustomer
FROM Customers JOIN Sales
ON Customers.CustomerID = Sales.CustomerID
GROUP BY Customers.FirstName, Customers.LastName

We'll get the following result:

FirstName LastName SalesPerCustomers

John Smith $99.95

Steven Goldfish $100.22

Even though Paula and James are listed as customers in the Customers table they won't be
displayed because they haven't purchased anything yet.

But what if you want to display all the customers and their sales, no matter if they have ordered
something or not? We’ll do that with the help of SQL OUTER JOIN clause.

The second type of SQL JOIN is called SQL OUTER JOIN and it has 2 sub-types called
LEFT OUTER JOIN and RIGHT OUTER JOIN.

The LEFT OUTER JOIN or simply LEFT JOIN (you can omit the OUTER keyword in most
databases), selects all the rows from the first table listed after the FROM clause, no matter if they
have matches in the second table.

If we slightly modify our last SQL statement to:

SELECT Customers.FirstName, Customers.LastName, SUM(Sales.SaleAmount) AS

SalesPerCustomer
FROM Customers LEFT JOIN Sales
ON Customers.CustomerID = Sales.CustomerID
GROUP BY Customers.FirstName, Customers.LastName

and the Sales table still has the following rows:

CustomerID Date SaleAmount

2 5/6/2004 $100.22
1 5/6/2004 $99.95

The result will be the following:

FirstName LastName SalesPerCustomers

John Smith $99.95

Steven Goldfish $100.22

Paula Brown NULL

James Smith NULL

As you can see we have selected everything from the Customers (first table). For all rows from
Customers, which don’t have a match in the Sales (second table), the SalesPerCustomer column
has amount NULL (NULL means a column contains nothing).

The RIGHT OUTER JOIN or just RIGHT JOIN behaves exactly as SQL LEFT JOIN,
except that it returns all rows from the second table (the right table in our SQL JOIN statement).

Other Resources :

http://www.sql-tutorial.net

http://www.w3schools.com/sql/default.asp