1. THE DATABASE LANGUAGE SQL
Chapter 6
THE DATABASE LANGUAGE SQL

2. 1. Project due 11/28 Exam III 11/14 3. Please print all tables DB1-DB3

3. Section 6.1
Simple Queries in SQL select Distinct model from aplche; select year from aplche where model='BEL AIR'; select description, litres as ltr, engine_type as ENG, Cubic_inches as CID, RLINK from aplche where model='BEL AIR' and year=74; select * from radcrx where rlink=2080; select MOD4 from radcrx where rlink=2080;

4. 6.1.4 Pattern Matching in SQL (cont’d)
Example 6.8 SELECT title FROM Movies WHERE title LIKE 'STAR''s%';
Note that if your string contains single quote, put another single quote to distinguish between surrounding single quotes and the single quote itself.
Retrieve all movies that contain the ‘s in their name like: Logan’s Run, Alice’s Restaurant

5. 6.1.4 Pattern Matching in SQL (DB2)
Example 6.8a
SELECT E.SSN, E.LNAME, E.BDATE
FROM EMPLOYEE E
WHERE E.ADDRESS LIKE
'%BELLAIRE%';

6. 6. The Database Language SQL
6.1 Simple Queries in SQL
6.2 Queries Involving More Than One Relation
6.3 Subqueries
6.4 Full-Relation Operation
6.5 Database Modification
6.6 Transactions in SQL
6.7 Summary of Chapter 6
6.8 References for chapter 6

7. Section 6.1
Simple Queries in SQL

8. 6.1 Simple Queries in SQL 6.1.1 Projecting in SQL
6.1.2 Selecting in SQL
6.1.3 Comparison of Strings
6.1.4 Pattern Matching in SQL
6.1.5 Dates and Times
6.1.6 Null Values and Comparisons Involving NULL
6.1.7 The Truth-Value UNKNOWN
6.1.8 Ordering the Output
6.1.9 Exercises for Section 6.1

9. 6.1 Simple Queries in SQL (Selection and Projection)
Example 6.1
Selection
(SELECT * FROM Movies WHERE studioName = ‘Disney’ AND year = 1990);
projection
SELECT title, length FROM MOVIES

10. 6.1.6 Null Values and Comparisons Involving NULL (cont’d)
Example 6.9 Let x have the value NULL x + 3 is NULL x IS NULL or x IS NOT NULL
select studioname from movies_null where null +3 = null; NO OUTPUT
select studioname from movies_null where
null +3 IS null; all OUTPUT

11. 6.1.7 The Truth-Value UNKNOWN
Example 6.10 SELECT Studioname
FROM Movies_null WHERE length is null;
SELECT Studioname
FROM Movies_null WHERE length = null;
“>” and comparison are the same; NO PUTPUT

12. 6.1.8 Ordering the Output (cont’d)
Example 6.11 SELECT producerC#,title FROM Movies WHERE studioName = 'DISNEY' AND year = 1990 ORDER BY length DESC, title;
Also can be ORDERed BY year – 10 (expressions)

13. Queries Involving More Than One Relation
Section 6.2
Queries Involving More Than One Relation

14. 6.2 Queries Involving More Than One Relation
6.2.1 Products and Joins in SQL
6.2.2 Disambiguating Attributes
6.2.3 Tuple Variables
6.2.4 Interpreting Multi-Relation Queries
6.2.5 Union, Intersection, and Difference of Queries
6.2.6 Exercises for Section 6.2

15. 6.2.1 Products and Joins in SQL (Cartesian Product)
Example 6.12a
Movies(title, year, length, genre, studioName, producerC#)
MovieExec(name, address, cert#, netWorth)
SELECT *
FROM Movies, MovieExec

16. 6.2.1 Products and Joins in SQL (Equi/Theta Join)
Example 6.12a
SELECT *
FROM Movies, MovieExec
WHERE title = 'STAR''s WARS'
AND producerC# = cert#;

17. 6.2.1 Products and Joins in SQL (Natural Join)
Example 6.12b
SELECT
title, year, length, InColor, studioName,
producerC#,name,address,netWorth
FROM Movies, MovieExec
WHERE title = 'STAR''s WARS'
AND producerC# = cert#;

18. 6.2.1 Natural Joins in SQL (DB1)
SELECT
S.SNUM, S.SNAME, S.STATUS, S.CITY, P.PNUM, P.PNAME, P.COLOR, P.WEIGHT
FROM SUPPLIERS S, PARTS P
Where S.CITY=P.CITY;

19. 6.2.3 Tuple Variables (cont’d)
Example 6.14
SELECT Star1.name, Star2.name
FROM MovieStar Star1, MovieStar Star2
WHERE Star1.address = Star2.address
AND Star1.name < Star2.name;
What’s the role of the second condition?
What would happen if we use <>?

20. 6.2.4 Interpreting Multi-Relation Queries (relational algebra)
Example 6.15
Convert the query of example 6.14 to RA.
ΠL1 (σC1 And C2 (R X T))
Where:
R = MovieStar Star1
T = MovieStar Star2
L1 = Star1.name, Start2.name
C1 = Star1.address = Star2.address
C2 = Star1.name < Star2.name

21. 6.2.5 Union, Intersection, and Difference of Queries (cont’d)
Example 6.16
(SELECT name, address FROM MovieStar
WHERE gender = 'M')
INTERSECT
(SELECT name, address FROM MovieExec
WHERE netWorth > );

22. 6.2.5 Union, Intersection, and Difference of Queries (cont’d)
Example 6.17
(SELECT name, address FROM MovieStar)
MINUS
(SELECT name, address FROM MovieExec);

23. 6.2.5 Union, Intersection, and Difference of Queries (cont’d)
Example 6.18
(SELECT title,year FROM Movies_e)
UNION/INTERSECT
(SELECT movieTitle AS title, movieYear AS year
FROM StarsIn_e);
(SELECT title,year FROM Movies)
FROM StarsIn);
Data Type has to agree first

24. 6.2.6 Exercises for Section 6.2

25. Section 6.3
Subqueries

26. 6.3 Subqueries 6.3.1 Subqueries that Produce Scalar Values
6.3.2 Conditions Involving Relations
6.3.3 Conditions Involving Tuples
6.3.4 Correlated Subqueries
6.3.5 Subqueries in From Clauses
6.3.6 SQL Join Expressions
6.3.7 Natural Joins
6.3.8 Outer Joins
6.3.9 Exercises for Section 6.3

27. 6.3.1 Subqueries that Produce Scalar Values (1)
Example 6.12 Two database Pointers)
SELECT name
FROM MovieExec
WHERE cert# = (SELECT producerC#
FROM Movies
WHERE title = 'STAR''s WARS' and producerC# > 950);
What would happen if the subquery retrieve zero or more than one tuple?

28. 6.3.1 Subqueries that Produce Scalar Values (2)
Example 6.19 (another version of Example 6.12)
SELECT name
FROM MovieExec
WHERE cert# in (SELECT producerC#
FROM Movies
WHERE title = 'STAR''s WARS' );
Explain the movements of database pointers.
(double loops)

29. 6.3.1 Subqueries that Produce Scalar Values (2b)
Example 6.19b
SELECT name
FROM MovieExec
WHERE cert# NOT in (SELECT producerC#
FROM Movies
WHERE title = 'STAR''s WARS' );
Compare the logic with the logic of next page

30. 6.3.1 Subqueries that Produce Scalar Values (2c)
Example 6.19c Which is correct, b or c?
SELECT name
FROM MovieExec
WHERE cert# in (SELECT producerC#
FROM Movies
WHERE title <>(NOT =)'STAR''s WARS' );
Compare the logic with that of last page

31. 6.3.1 Subqueries that Produce Scalar Values (3)
Example 6.19d.
SELECT name
FROM MovieExec M1
WHERE Exists
(SELECT producerC#
FROM Movies M2
WHERE title = 'STAR WARS' and M1.cert# = M2.producerC# );
Compare the logic with previous pages

32. 6.3.1 Subqueries that Produce Scalar Values (3 DB1)
Example 6.12 Get supplier names for suppliers who supply part P2.
SELECT SNAME
FROM SUPPLIERS
WHERE SNUM in (SELECT SNUM
FROM SHIPMENTS
WHERE PNUM='P2');
CONVERT into temp join

33. 6.3.1 Subqueries that Produce Scalar Values (3 DB1)
Example 6.12
SELECT SNUM
FROM SUPPLIERS
WHERE CITY =
(SELECT CITY
WHERE SNUM='S1');

34. 6.3.1 Subqueries that Produce Scalar Values (3 DB1)
Example 6.12
SELECT SNAME
FROM SUPPLIER
WHERE EXISTS
(SELECT *
FROM SHIPMENT
WHERE SNUM = Supplier.Snum
AND PNUM = 'P2');

35. 6.3.1 Subqueries that Produce Scalar Values (3 DB1)
Get supplier names for suppliers who do not supply part P2.
SELECT SNAME
FROM SUPPLIERS S
WHERE NOT EXISTS
(SELECT *
FROM SHIPMENTS
WHERE SNUM=S.Snum
AND PNUM='P2');

36. 6.3.1 Subqueries that Produce Scalar Values (3b DB2)
Example 6.19d.
SELECT E.FNAME, E.LNAME
FROM EMPLOYEE E
WHERE Exists
(SELECT *
FROM WORKS_ON W
WHERE W.WSSN = E.SSN AND W.PNO <> 1);

37. 6.3.1 Subqueries that Produce Scalar Values (4)
Example 6.19e. (Temp join)
SELECT name
FROM MovieExec M, (SELECT producerC#
FROM Movies
WHERE title = 'STAR''s WARS') T
WHERE M.cert# = T.producerC#;
Compare the logic with previous pages

38. 6.3.1N Updates
Change (increment) the quantity of every part supplied by supplier S2 by 100.
UPDATE SHIPMENTS
SET QTY = QTY + 100
WHERE SNUM = 'S2';

39. 6.3.1N Updates
Set the shipment quantity to zero for all suppliers in London.
UPDATE SHIPMENT
SET QTY = 0
WHERE 'London' =
(SELECT CITY
FROM SUPPLIER
WHERE SNUM=
SP.SNUM);

40. 6.3.1N Delete
DELETE
General format :
FROM table
[WHERE predicate];

41. 6.3.1N Delete Delete part P3. DELETE FROM FIRST1a
WHERE PNUM = 'P2' and SNUM = 'S3';

42. 6.3.1N Delete Delete all shipments for suppliers in London. DELETE
FROM SHIPMENT
WHERE 'London'=
(SELECT CITY
FROM SUPPLIER
WHERE S.Snum=
SP.Snum);

43. 6.3.1N INSERT General format 1 : INSERT
INTO table [(field [,field]...)]
VALUES (constant [,constant]...);

44. 6.3.1N INSERT general format 2 : INSERT INTO table [(field[,field])]
SELECT FROM WHERE

45. SELECT SUM(SALARY)
FROM FIRST1a

46. 6.3.3 Conditions Involving Tuples (One/two Columns Relation)
Example 6.20: Main Example
SELECT name
FROM MovieExec
WHERE cert# IN
(SELECT producerC# FROM Movies
WHERE (title, year) IN
(SELECT movieTitle, movieYear
FROM StarsIN
WHERE starName = 'SAMUEL HENRY') );

47. 6.3.3 Conditions Involving Tuples (One/two Column Relation)
Example 6.20a: Partial checking
SELECT producerC# FROM Movies
WHERE (title, year) IN
(SELECT movieTitle, movieYear
FROM StarsIN
WHERE starName = 'SAMUEL HENRY');

48. 6.3.3 Conditions Involving Tuples (One/two Column Relation)
Example 6.20b: Partial checking
(SELECT title, year FROM Movies_e)
Intersect
(SELECT movieTitle, movieYear
FROM StarsIN_e
WHERE starName = 'SAMUEL HENRY');

49. 6.3.3a Conditions Involving Tuples (temp join query)
Example 6.20c: (temp join query)
SELECT * FROM Movies M, (SELECT movieTitle, movieYear
FROM StarsIN
WHERE starName = 'SAMUEL HENRY') T
WHERE M.title=T.movieTitle and
M.year =T.movieyear;

50. 6.3.3 Conditions Involving Tuples (using Join Queries)
For example, the previous query can be written as join query: (not recommended)
SELECT name
FROM MovieExec, Movies, StarsIN
WHERE title = movieTitle
AND year = movieYear
And starName = 'SAMUEL HENRY';

51. 6.3.3 Conditions Involving Tuples (One/two Column Relation)
Example 6.20: Main Example
Query all the producers of movies in which 'SAMUEL HENRY stars.
SELECT name
FROM MovieExec
WHERE cert# IN
(SELECT producerC# FROM Movies
WHERE (title, year) IN
(SELECT movieTitle, movieYear
FROM StarsIN
WHERE starName = 'SAMUEL HENRY') );

52. 6.3.4 Correlated Subqueries
The simplest subquery is evaluated once and the result is used in a higher-level query.
Some times a subquery is required to be evaluated several times, once for each assignment of a value that comes from a tuple variable outside the subquery.
A subquery of this type is called correlated subquery.

53. 6.3.4 Correlated Subqueries (Monday:quiz)
Example 6.21
Query the titles that have been used for two or more movies.
SELECT title
FROM Movies_e old
WHERE year < ANY
(SELECT year FROM Movies_e
WHERE title = old.title);

54. 6.3.4 Correlated Subqueries
SELECT old.title FROM Movies_e old, (SELECT * FROM Movies_e) Temp WHERE temp.title = old.title and old.year < ANY(temp.year);

55. 6.3.4 Correlated Subqueries
SELECT old.title FROM Movies_e old, (SELECT year, title FROM Movies_e) Temp WHERE temp.title = old.title and old.year < ANY(temp.year);

56. 6.3.5 Subqueries in From Clauses
In a FROM list, we my use a parenthesized subquery.
The subquery must have a tuple variable or alias.

57. 6.3.9 Exercises for Section 6.3

58. Full-Relation Operations
Section 6.4
Full-Relation Operations

59. 6.4 Full-Relation Operations
6.4.1 Eliminating Duplicates
6.4.2 Duplicates in Unions, Intersections, and Differences
6.4.3 Grouping and Aggregation in SQL
6.4.4 Aggregation Operators
6.4.5 Grouping
6.4.6 Grouping, Aggregation, and Nulls
6.4.7 Having Clauses
6.4.8 Exercises for Section 6.4

60. 6.4.1 Eliminating Duplicates
SQL does not eliminate duplicate tuples by itself. So, it does not treat the relations as a set. It treats the relations as a bag.
To eliminate duplicate tuples, use DISTINCT keyword after SELECT as the next example shows.
Note that duplicate tuples elimination is a very expensive operation for database, so, use DISTINCT keyword wisely.

61. 6.4.1 Eliminating Duplicates
Example 6.27(new ex)
Query all the producers of movies in which 'SAMUEL HENRY'stars.
SELECT DISTINCT name
FROM MovieExec, Movies, StarsIN
WHERE cert# = producerC#
AND title = movieTitle
AND year = movieYear
And starName = 'SAMUEL HENRY';

62. 6.4.2 Duplicates in Unions, Intersections, and Differences
Duplicate tuples are eliminated in UNION, INTERSECT, and EXCEPT.
In other words, bags are converted to sets.
If you don't want this conversion, use keyword ALL after the operators.
Example 6.28
(SELECT title, year FROM Movies)
UNION ALL
(SELECT movieTitle AS title, movieYear AS year FROM StarsIn);

63. 6.4.4 Aggregation Operators
SQL uses the five aggregation operators: SUM, AVG, MIN, MAX, and COUNT
These operators can be applied to scalar expressions, typically, a column name.
One exception is COUNT(*) which counts all the tuples of a query output.
We can eliminate the duplicate values before applying aggregation operators by using DISTINCT keyword. For example: COUNT(DISTINCT x)

64. 6.4.4 Aggregation Operators (cont'd)
Example 6.29
Find the average net worth of all movie executives.
SELECT AVG(netWorth)
FROM MovieExec;

65. 6.4.4 Aggregation Operators (cont'd)
Example 6.30
Count the number of tuples in the StarsIn relation.
SELECT COUNT(*)
FROM StarsIn;
SELECT COUNT(starName)
These two statements do the same but you will see the difference in later slides.

66. 6.4.5 Grouping
We can group the tuples by using GROUP BY clause following the WHERE clause.
The keywords GROUP BY are followed by a list of grouping attributes.

67. 6.4.5 Grouping (cont'd) Example 6.31
Find sum of the movies length each studio is produced.
SELECT studioName,
SUM(length) AS Total_Length
FROM Movies
GROUP BY studioName;

68. 6.4.5 Grouping (cont'd)
In a SELECT clause that has aggregation, only those attributes that are mentioned in the GROUP BY clause may appear unaggregated.
For example, in previous example, if you want to add genre in the SELECT list, then, you must mention it in the GROUP BY list as well.
SELECT studioName, incolor,
SUM(length) AS Total_Length
FROM Movies
GROUP BY studioName, incolor;

69. 6.4.5 Grouping (cont'd)
It is possible to use GROUP BY in a more complex queries about several relations.
In these cases the following steps are applied:
Produce the output relation based on the select-from-where parts.
Group the tuples according to the list of attributes mentioned in the GROUP BY list.
Apply the aggregation operators

70. 6.4.5 Grouping (cont'd) Example 6.32
Create a list of each producer name and the total length of film produced.
SELECT name, SUM(length)
FROM MovieExec, Movies
WHERE producerC# = cert#
GROUP BY name;

71. 6.4.6 Grouping, Aggregation, and Nulls
What would happen to aggregation operators if the attributes have null values?
There are a few rules to remember

72. 6.4.6 Grouping, Aggregation, and Nulls (cont'd)
NULL values are ignored when the aggregation operator is applied on an attribute.
COUNT(*) counts all tuples of a relation, therefore, it counts the tuples even if the tuple contains NULL value.
NULL is treated as an ordinary value when forming groups.
When we perform an aggregation, except COUNT, over an empty bag, the result is NULL. The COUNT of an empty bag is 0

73. 6.4.6 Grouping, Aggregation, and Nulls (cont'd)
What's the result of the following SELECT?
select length,sum(length) from movies_null group by length;
SELECT A, SUM(B)
FROM R
GROUP BY A;
The result is (NULL, NULL) because SUM(B) addes one NULL value which is NULL.

74. 6.4.7 HAVING Clauses
So far, we have learned how to restrict tuples from contributing in the output of a query.
How about if we don't want to list all groups?
HAVING clause is used to restrict groups.
HAVING clause followed by one or more conditions about the group.

75. 6.4.7 HAVING Clauses (cont'd)
Example 6.34
Query the total film length for only those producers who made at least one film prior to 2000.
SELECT name, year, SUM(length)
FROM MovieExec, Movies
WHERE producerC# = cert#
GROUP BY name, year
HAVING MIN(year) < 2000;

76. 6.4.7 HAVING Clauses (cont'd)
The rules we should remember about HAVING:
An aggregation in a HAVING clause applies only to the tuples of the group being tested.
Any attribute of relations in the FROM clause may be aggregated in the HAVING clause, but only those attributes that are in the GROUP BY list may appear unaggregated in the HAVING clause (the same rule as for the SELECT clause).

77. 6.4.7 HAVING Clauses (cont'd)
The order of clauses in SQL queries would be:
SELECT
FROM
WHERE
GROUP BY
HAVING
Only SELECT and FROM are mandatory.

78. 3.1.1 Definition of Functional Dependency ((lectured in6.4)
Title, Year  Length InColor StudioName Select title, year, count(length) From Movies_null Group by Title, Year ; Select title, year, count(StudioName) From Movies

79. 3.1.1 Definition of Functional Dependency (lectured in6.4)
PNUM, SNUM  SALARY, STATUS, CITY,QTY Select PNUM, SNUM, count(QTY) From First1a Group by PNUM, SNUM ; Select PNUM, SNUM, count(CITY)

80. 3.1.1 Definition of Functional Dependency ((lectured in6.4))
Select PNUM, SNUM, count(STATUS) From First1a Group by PNUM, SNUM ; Select PNUM, SNUM, count(SALARY)

81. 3.1.1 Definition of Functional Dependency ((lectured in6.4))
PNUM, SNUM  SALARY, STATUS, CITY,QTY Select SNUM, count(CITY) From First1a Group by SNUM ; Select SNUM, count(UNIQUE CITY)

82. 3.1.1 Definition of Functional Dependency ((lectured in6.4))
CITY ---- STATUS Select CITY, count(STATUS) From First1a Group by CITY ; Select CITY, count(UNIQUE STATUS) Group by CITY;

83. 3.1.1 Definition of Functional Dependency (lectured in6.4)
Title Year  Length InColor StudioName Select title, year, count(InColor) From Movies_null Group by Title, Year having count(InColor) <=1; Select count(InColor) having count(InColor) > 1;

84. 3.1.1 Definition of Functional Dependency ((lectured in6.4))
Title Year  Length InColor StudioName Select title, year, count(InColor) From Movies_null Group by Title, Year having count(InColor) <=1; Select title, year, count(StudioName) From Movies Group by Title, Year ;

85. 6.4.8 Exercises for Section 6.4

86. Database Modifications
Section 6.5
Database Modifications

87. 6.5 Database Modifications
6.5.1 Insertion
6.5.2 Deletion
6.5.3 Updates
6.5.4 Exercises for Section 6.5

88. 6.5.1 Insertion
The syntax of INSERT statement: INSERT INTO R(A1, ..., AN) VALUES (v1, ..., vn);
If the list of attributes doesn't include all attributes, then it put default values for the missing attributes.

89. 6.5.1 Insertion (cont'd) Example 6.35
INSERT INTO StarsIn(MovieTitle, movieYear, starName)
VALUES ('The Maltese Falcon', 1942, 'Sydney Greenstreet');
If we are sure about the order of the attributes, then we can write the statement as follows:
INSERT INTO StarsIn

90. 6.5.1 Insertion (cont'd)
The simple insert can insert only one tuple, however, if you want to insert multiple tuples , then you can use the following syntax:
INSERT INTO R(A1, ..., AN) SELECT v1, ..., vn FROM R1, R2, ..., RN WHERE <condition>;

91. 6.5.1 Insertion (cont'd) Example 6.36
Suppose that we want to insert all studio names that are mentioned in the Movies relation but they are not in the Studio yet.
INSERT INTO Studio(name) SELECT DISTINCT studioName FROM Movies WHERE studionName NOT IN (SELECT name
FROM Studio);

92. CREATE TABLE Movies_T (
title VARCHAR(22), year INTEGER,
length INTEGER, inColor CHAR(1),
studioName CHAR(60), producerC# INTEGER,
PRIMARY KEY (title, year) );
INSERT INTO Movies_T
SELECT
title,year,length,inColor,studioName,producerC#
FROM Movies;

93. Can be used (not recommended)
CREATE TABLE Movies_T1 as
SELECT * FROM Movies ;

94. 6.5.2 Deletion
The syntax of DELETE statement: DELETE FROM R WHERE <condition>;
Every tuples satisfying the condition will be deleted from the relation R.

95. 6.5.2 Deletion (cont'd) Example 6.37 DELETE FROM StarsIn
WHERE movieTitle = 'The Maltese Falcon' AND
movieYear = 1942 AND
starName = 'Sydney Greenstreet';

96. 6.5.2 Deletion (cont'd) Example 6.38
Delete all movie executives whose net worth is less than ten million dollars.
DELETE FROM MovieExec
WHERE netWorth < ;

97. 6.5.3 Updates
The syntax of UPDATE statement: UPDATE R SET <value-assignment> WHERE <condition>;
Every tuples satisfying the condition will be updated from the relation R.
If there are more than one value-assignment, we should separate them with comma.

98. 6.5.3 Updates
Example 6.39
Attach the title 'Pres.' in front of the name of every movie executive who is the president of a studio.
UPDATE MovieExec_e
SET name = 'Pres.'||name
WHERE cert# IN (SELECT PRODUCERC# FROM Movies);

99. 6.5.4 Exercises for Section 6.5

100. Transactions in SQL (SKIP 2012)
Section 6.6
Transactions in SQL (SKIP 2012)

101. 6.6 Transactions in SQL 6.6.1 Serializability 6.6.2 Atomicity
6.6.4 Read-Only Transactions
6.6.5 Dirty Reads
6.6.6 Other Isolation Levels
6.6.7 Exercises for Section 6.6

102. 6.6 Transactions in SQL Up to this point, we assumed that:
the SQL operations are done by one user.
The operations are done one at a time.
There is no hardware/software failure in middle of a database modification. Therefore, the operations are done atomically.
In Real life, situations are totally different.
There are millions of users using the same database and it is possible to have some concurrent operations on one tuple.

103. 6.6.1 Serializability
In applications like web services, banking, or airline reservations, hundreds to thousands operations per second are done on one database.
It's quite possible to have two or more operations affecting the same, let's say, one bank account.
If these operations overlap in time, then they may act in a strange way.
Let's take an example.

104. 6.6.1 Serializability (cont'd)
Example 6.40
Consider an airline reservation web application. Users can book their desired seat by themselves.
The application is using the following schema:
Flights(fltNo, fltDae, seatNo, seatStatus)
When a user requests the available seats for the flight no 123 on date , the following query is issued:

105. 6.6.1 Serializability (cont'd)
SELECT seatNo
FROM Flights
WHERE fltNo = 123 AND
fltDate = DATE ' ' AND
seatStatus = 'available';
When the customer clicks on the seat# 22A, the seat status is changed by the following SQL:
UPDATE Flights
SET seatStatus = 'occupied'
seatNo = '22A';

106. 6.6.1 Serializability (cont'd)
What would happen if two users at the same time click on the reserve button for the same seat#?
Both see the same seats available and both reserve the same seat.
To prevent these happen, SQL has some solutions.
We group a set of operations that need to be performed together. This is called 'transaction'.

107. 6.6.1 Serializability (cont'd)
For example, the query and the update in example 6.40 can be grouped in a transaction.
SQL allows the programmer to stat that a certain transaction must be serializable with respect to other transactions.
That is, these transactions must behave as if they were run serially, one at a time with no overlap.

108. 6.6.2 Atomicity
What would happen if a transaction consisting of two operations is in progress and after the first operation is done, the database and/or network crashes?
Let's take an example.

109. 6.6.2 Atomicity (cont'd) Example 6.41
Consider a bank's account records system with the following relation:
Accounts(acctNo, balance)
Let's suppose that $100 is going to transfer from acctNo 123 to acctNo 456.
To do this, the following two steps should be done:
Add $100 to account# 456
Subtract $100 from account# 123.

110. 6.6.2 Atomicity (cont'd) The needed SQL statements are as follows:
UPDATE Accounts
SET balance = balance + 100
WHERE acctNo = 456;
SET balance = balance - 100
WHERE acctNo = 123;
What would happen if right after the first operation, the database crashes?

111. 6.6.2 Atomicity (cont'd)
The problem addressed by example 6.41 is that certain combinations of operations need to be done atomically.
That is, either they are both done or neither is done.

112. 6.6.3 Transactions
The solution to the problems of serialization and atomicity is to group database operations into transactions.
A transaction is a set of one or more operations on the database that must be executed atomically and in a serializable manner.
To create a transation, we use the following SQL command:
START TRANSACTION

113. 6.6.3 Transactions (cont'd) There are two ways to end a transaction:
The SQL receives COMMIT command.
The SQL receives ROLLBACK command.
COMMIT command causes all changes become permanent in the database.
ROLLBACK command causes all changes undone.

114. 6.6.4 Read-Only Transactions
We saw that when a transaction read a data and then want to write something, is prone to serialization problems.
When a transaction only reads data and does not write data, we have more freedom to let the transaction execute in parallel with other transactions.
We call these transactions read-only.

115. 6.6.4 Read-Only Transactions (cont'd)
Example 6.43
Suppose we want to read data from the Flights relation of example 6.40 to determine whether a certain seat was available?
What's the worst thing that can happen?
When we query the availability of a certain seat, that seat was being booked or was being released by the execution of some other program. Then we get the wrong answer.

116. 6.6.4 Read-Only Transactions (cont'd)
If we tell the SQL that our current transaction is read-only, then SQL allows our transaction be executed with other read-only transactions in parallel.
The syntax of SQL command for read-only setting:
SET TRANSACTION READ ONLY;
We put this statement before our read-only transaction.

117. 6.6.4 Read-Only Transactions (cont'd)
The syntax of SQL command for read-write setting:
SET TRANSACTION READ WRITE;
We put this statement before our read-write transaction.
This option is the default.

118. 6.6.5 Dirty Reads
The data that is written but not committed yet is called dirty data.
A dirty read is a read of dirty data written by another transaction.
The risk in reading dirty data is that the transaction that wrote it never commit it.

119. 6.6.5 Dirty Reads (cont'd) Example 6.44
Consider the account transfer of example 6.41.
Here are the steps:
Add money to account 2.
Test if account 1 has enough money?
If there is not enough money, remove the money from account 2 and end.
If there is, subtract the money from account 1 and end.
Imagine, there are 3 accounts A1, A2, and A3 with $100, $200, and $300.

120. 6.6.5 Dirty Reads (cont'd) Example 6.44 (cont'd) Let's suppose:
Transaction T1 transfers $150 from A1 to A2
Transaction T2 transfers $250 from A2 to A3
What would happen if the dirty read is allowed?

121. 6.6.5 Dirty Reads (cont'd)
The syntax of SQL command for dirty-read setting:
SET TRANSACTION READ WRITE
ISOLATION LEVEL READ UNCOMMITTED;
We put this statement before our read-write transaction.
This option is the default.

122. 6.6.6 Other Isolation Levels
There are four isolation level.
We have seen the first two before.
Serializable (default)
Read-uncommitted
Read-committed Syntax: SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
Repeatable-read Syntax SET TRANSACTION ISOLATION LEVEL READ COMMITTED;

123. 6.6.6 Other Isolation Levels (cont'd)
For each the default is 'READ WRITE' (except the isolation READ UNCOMMITTED that the default is 'READ ONLY') and if you want 'READ ONLY', you should mention it explicitly.
The default isolation level is 'SERIALIZABLE'.
Note that if a transaction T is acting in 'SERIALIZABLE' level and the other one is acting in 'READ UNCOMMITTED' level, then this transaction can see the dirty data of T. It means that each one acts based on their level.

124. 6.6.6 Other Isolation Levels (cont'd)
Under READ COMMITTED isolation, it forbids reading the dirty data.
But it does not guarantee that if we issue several queries, we get the same tuples.
That's because there may be some new committed tuples by other transactions.

125. 6.6.6 Other Isolation Levels (cont'd)
Example 6.46 Let's consider the seat choosing problem under 'READ COMMITTED' isolation. Your query won't see seat as available if another transaction reserved it but not committed yet. You may see different set of seats in subsequent queries depends on if the other transactions commit their reservations or rollback them.

126. 6.6.6 Other Isolation Levels (cont'd)
Under REPEATABLE READ isolation, if a tuple is retrieved for the first time, then we are sure that the same tuple will be retrieve if the query is repeated.
But the query may show more tuples because of the phantom tuples.
A phantom tuple is a tuple that is inserted by other transactions.

127. 6.6.6 Other Isolation Levels (cont'd)
Example 6.47 Let's continue the seat choosing problem under 'REPEATABLE READ' isolation. If a seat is available on the first query, then it will remain available at the subsequent queries. Now suppose that some new tuples are inserted into the flight relation (phantom tuples) for that particular flight for any reason. Then the subsequent queries retrieve the new tuples as well.

128. 6.6.6 Other Isolation Levels (cont'd)
Properties of SQL isolation levels
Isolation Level
Dirty Read
Non-repeatable Read
Phantom
Read Uncommitted 
Read Committed -
Repeatable Read
Serializable

129. 6.6.7 Exercises for Section 6.6

130. 6.7 Summary of Chapter 6

131. 6.8 References for Chapter 6