Data ModelingSeminar

February 18, 2012

Lesson 3Standard SQL

Lesson 3

Standard SQL

Standard SQL Data Statements – query and modify tables and columns

SELECT Statement – query tables and views in the database INSERT Statement – add rows to tables UPDATE Statement – modify columns in table rows DELETE Statement – remove rows from tables

Schema Statements – maintain schema (catalog) CREATE TABLE Statement – create tables CREATE VIEW Statement – create views DROP TABLE Statement -- drop tables DROP VIEW Statement -- drop views

Constraints & Programmability Constraints Procedures Function Triggers

Standard SQL – Data Statements SELECT Statement -- query tables and views in the database

SELECT Statement Basics SELECT Clause FROM Clause WHERE Clause

Extended Query Capabilities ORDER BY Clause Value Expressions Joining Tables Subqueries Grouping Queries (GROUP BY) Aggregate Queries (Set Functions) Union Queries (UNION)

SQL Modification Statements INSERT Statement -- add rows to tables VALUES Clause

UPDATE Statement -- modify columns in table rows SET Clause

DELETE Statement -- remove rows from tables

SELECT Statement BasicsThe SQL SELECT statement queries data from tables in the

database. The statement begins with the SELECT keyword. The basic SELECT statement has 3 clauses:

SELECT FROM WHERE

The SELECT clause specifies the table columns that are retrieved. The FROM clause specifies the tables accessed. The WHERE clause specifies which table rows are used.

The WHERE clause is optional; if missing, all table rows are used. For example, SELECT name FROM s WHERE city='Rome'• This query accesses rows from the table - s. • It then It then filters those rows where the city column contains Rome. • Finally, the query retrieves the name column from each filtered row.

SELECT - Extended Query Capabilities Sorting Query Results -- using the ORDER BY clause Expressions -- in the SELECT clause and WHERE clause

Literal -- self-defining values Function Call -- expression functions System Value -- builtin system values Special Construct -- special expression construct Numeric or String Operator -- expression operators

Joining Tables -- in the FROM clause Outer Join -- extended join Self Join -- joining a table to itself

Subqueries -- embedding a query in another Predicate Subqueries -- subqueries in logical expressions Scalar Subqueries -- subqueries in scalar expressions Table Subqueries -- subqueries in the FROM clause

Grouping Queries -- using the GROUP BY clause, Set Function and HAVING clause GROUP BY Clause -- specifying grouping columns Set Functions -- summary functions HAVING Clause -- filtering grouped rows

Aggregate Queries -- using Set Functions and the HAVING clause Union Queries -- using the query operator, UNION

Union-Compatible Queries -- query requirements for Union

Joining TablesThe FROM clause allows more than 1 table in

its list, however simply listing more than one table will very rarely produce the expected results.

The rows from one table must be correlated with the rows of the others.

This correlation is known as joining.

Join ExampleAn example can best illustrate the rationale behind joins. The following query:

SELECT * FROM sp, p

Produces:

sno pno qty pno descr color

S1 P1 NULL P1 Widget Blue

S1 P1 NULL P2 Widget Red

S1 P1 NULL P3 Dongle Green

S2 P1 200 P1 Widget Blue

S2 P1 200 P2 Widget Red

S2 P1 200 P3 Dongle Green

S3 P1 1000 P1 Widget Blue

S3 P1 1000 P2 Widget Red

S3 P1 1000 P3 Dongle Green

S3 P2 200 P1 Widget Blue

S3 P2 200 P2 Widget Red

S3 P2 200 P3 Dongle Green

SELECT * FROM sp, p

Each row in sp is arbitrarily combined with each

Inner Join ExampleA more usable query would correlate the

rows from sp with rows from p, for instance matching on the common column -- pno:

SELECT * FROM sp, p WHERE sp.pno = p.pno

sno pno qty pno descr color

S1 P1 NULL P1 Widget Blue

S2 P1 200 P1 Widget Blue

S3 P1 1000 P1 Widget Blue

S3 P2 200 P2 Widget Red

This produces:

Outer JoinsAn outer join provides the ability to include unmatched rows in the

query results. The outer join combines the unmatched row in one of the tables with

an artificial row for the other table. This artificial row has all columns set to null.

The outer join is specified in the FROM clause and has the following general format: table-1 { LEFT | RIGHT | FULL } OUTER JOIN table-2 ON predicate-1

predicate-1 is a join predicate for the outer join. It can only reference columns from the joined tables.

The LEFT, RIGHT or FULL specifiers give the type of join: LEFT -- only unmatched rows from the left side table (table-1) are retained RIGHT -- only unmatched rows from the right side table (table-2) are

retained FULL -- unmatched rows from both tables (table-1 and table-2) are

retained

Outer Join Example: SELECT pno, descr, color, sno, qty FROM p LEFT OUTER JOIN sp ON p.pno = sp.pno

pno descr color sno qty

P1 Widget Blue S1 NULL

P1 Widget Blue S2 200

P1 Widget Blue S3 1000

P2 Widget Red S3 200

P3 Dongle Green NULL NULL

INSERT StatementThe INSERT Statement adds one or more rows to a table. It has two formats:

INSERT INTO table-1 [(column-list)] VALUES (value-list)&INSERT INTO table-1 [(column-list)] (query-specification)

The first form inserts a single row into table-1 and explicitly specifies the column values for the row.

The second form uses the result of query-specification to insert one or more rows into table-1. The result rows from the query are the rows added to the insert table. Note: the query cannot reference table-1.

UPDATE StatementThe UPDATE statement modifies columns in selected table rows. It has the following general format:

UPDATE table-1 SET set-list [WHERE predicate]

The optional WHERE Clause has the same format as in the SELECT Statement. The WHERE clause chooses which table rows to update. If it is missing, all rows are in table-1 are updated.

SET ClauseThe SET Clause in the UPDATE Statement updates (assigns new value to) columns in the selected table rows. It has the following general format:

SET column-1 = value-1 [, column-2 = value-2] ...

column-1 and column-2 are columns in the Update table.

value-1 and value-2 are expressions that can reference columns from the update table. They also can be the keyword -- NULL, to set the column

to null.

DELETE StatementThe DELETE Statement removes selected rows from a table. It has the following general format:

DELETE FROM table-1 [WHERE predicate]

The optional WHERE Clause has the same format as in the SELECT Statement.

The WHERE clause chooses which table rows to delete. If it is missing, all rows are in table-1 are removed.

The WHERE Clause predicate can contain subqueries, but the subqueries cannot reference table-1. This prevents situations where results are dependent on

the order of processing.

Schema Statements Maintain Schema (catalog)

CREATE TABLE Statement – create tablesCREATE VIEW Statement – create viewsDROP TABLE Statement – drop tables DROP VIEW Statement – drop views

ConstraintsCheckUniquePrimary KeyForeign KeyNot Null

CHECK constrains A constraint is an object which tells the DBMS: don't permit updates of the

database which would break rules established for business/integrity reasons.

A CHECK constraint works thus:

CREATE TABLE TABLE_1 (COLUMN_1 SMALLINT); -- make the table

ALTER TABLE TABLE_1 ADD CONSTRAINT CONSTRAINT_1 CHECK (COLUMN_1 > 0); -- make the constraint

INSERT INTO TABLE_1 VALUES (5); -- this succeeds

UPDATE TABLE_1 SET COLUMN_1 = -5; -- this fails

PRIMARY KEY constraintA PRIMARY KEY constraint works thus:

CREATE TABLE TABLE_1 (COLUMN_1 SMALLINT);

ALTER TABLE TABLE_1 ADD CONSTRAINT CONSTRAINT_1 PRIMARY KEY (COLUMN_1);

INSERT INTO TABLE_1 VALUES (5);

INSERT INTO TABLE_1 VALUES (5); • A table's primary key must contain unique values, so the second

INSERT in this example will fail. • Alternative: if all we want to say is "values must be unique", we

could say UNIQUE (COLUMN_1) instead of PRIMARY KEY (COLUMN_1).

FOREIGN KEY constraintA FOREIGN KEY constraint works thus:

CREATE TABLE TABLE_1 (COLUMN_1 SMALLINT);

ALTER TABLE TABLE_1 ADD CONSTRAINT CONSTRAINT_1 PRIMARY KEY (COLUMN_1);

INSERT INTO TABLE_1 VALUES (5);

CREATE TABLE TABLE_2 (COLUMN_1 SMALLINT);

ALTER TABLE TABLE_2 ADD CONSTRAINT FOREIGN KEY (COLUMN_1) REFERENCES TABLE_1;

INSERT INTO TABLE_2 VALUES (5);

INSERT INTO TABLE_2 VALUES (6);

• The first INSERT into TABLE_2 will succeed, because our foreign-key value (5) exists in the primary-key table that we're referencing.

• But we never inserted a 6 into TABLE_1, so we can't insert a 6 into TABLE_2, so the second INSERT in this example will fail.

ProgrammabilityStored ProcedureFunction

Scalar valueTable value

Trigger

Stored Procedure

Function – Scalar value

Function – Table value

Trigger

Questions

Lab 2Class Scheduling System in SQL Server

Create ClassSchedule databaseLoad dataExecute Queries