1. 1 Introduction to SQL

2. 2 Objectives Definition of terms Definition of terms Discuss advantages of standardized SQL Discuss advantages of standardized SQL Define a database using SQL data definition language Define a database using SQL data definition language Write single table queries using SQL Write single table queries using SQL Establish referential integrity using SQL Establish referential integrity using SQL Work with Views Work with Views

3. 3 The Physical Design Stage of SDLC Purpose –programming, testing, training, installation, documenting Deliverable – operational programs, documentation, training materials, program/data structures Database activity – physical database design and database implementation Project Identification and Selection Project Initiation and Planning Analysis Physical Design Implementation Maintenance Logical Design Implementation Physical Design

4. 4 SQL Overview Structured Query Language Structured Query Language The standard for relational database management systems (RDBMS) The standard for relational database management systems (RDBMS) SQL-92 and SQL-99 Standards – Purpose: SQL-92 and SQL-99 Standards – Purpose: Specify syntax/semantics for data definition and manipulation Specify syntax/semantics for data definition and manipulation Define data structures Define data structures Enable portability Enable portability Specify minimal (level 1) and complete (level 2) standards Specify minimal (level 1) and complete (level 2) standards Allow for later growth/enhancement to standard Allow for later growth/enhancement to standard

5. 5 Benefits of a Standardized Relational Language Reduced training costs Reduced training costs Productivity Productivity Application portability Application portability Application longevity Application longevity Reduced dependence on a single vendor Reduced dependence on a single vendor Cross-system communication Cross-system communication

6. 6 SQL Environment Catalog Catalog A set of schemas that constitute the description of a database A set of schemas that constitute the description of a database Schema Schema The structure that contains descriptions of objects created by a user (base tables, views, constraints) The structure that contains descriptions of objects created by a user (base tables, views, constraints) Data Definition Language (DDL) Data Definition Language (DDL) Commands that define a database, including creating, altering, and dropping tables and establishing constraints Commands that define a database, including creating, altering, and dropping tables and establishing constraints Data Manipulation Language (DML) Data Manipulation Language (DML) Commands that maintain and query a database Commands that maintain and query a database Data Control Language (DCL) Data Control Language (DCL) Commands that control a database, including administering privileges and committing data Commands that control a database, including administering privileges and committing data

7. 7 A simplified schematic of a typical SQL environment, as described by the SQL-92 standard

8. DATA TYPES: MySQL Numeric Data Types: INT, TINYINT, SMALLINT,MEDIUMINT,BIGINT, FLOAT, DOUBLE, DECIMAL Numeric Data Types: INT, TINYINT, SMALLINT,MEDIUMINT,BIGINT, FLOAT, DOUBLE, DECIMAL Data and Time Types: DATE, DATETIME,TIMESTAMP,TIME,YEAR Data and Time Types: DATE, DATETIME,TIMESTAMP,TIME,YEAR String Types: CHAR,VARCHAR,BLOB or TEXT,TINYBLOB or TINY TEXT,MEDIUMBLOB or MEDIUMTEXT,ENUM String Types: CHAR,VARCHAR,BLOB or TEXT,TINYBLOB or TINY TEXT,MEDIUMBLOB or MEDIUMTEXT,ENUM 8

9. 9 Some SQL Data types (Oracle) String types String types CHAR(n) – fixed-length character data, n characters long Maximum length = 2000 bytes CHAR(n) – fixed-length character data, n characters long Maximum length = 2000 bytes VARCHAR2(n) – variable length character data, maximum 4000 bytes VARCHAR2(n) – variable length character data, maximum 4000 bytes LONG – variable-length character data, up to 4GB. Maximum 1 per table LONG – variable-length character data, up to 4GB. Maximum 1 per table Numeric types Numeric types NUMBER(p,q) – general purpose numeric data type NUMBER(p,q) – general purpose numeric data type INTEGER(p) – signed integer, p digits wide INTEGER(p) – signed integer, p digits wide FLOAT(p) – floating point in scientific notation with p binary digits precision FLOAT(p) – floating point in scientific notation with p binary digits precision Date/time type Date/time type DATE – fixed-length date/time in dd-mm-yy form DATE – fixed-length date/time in dd-mm-yy form

10. 10 ISO SQL Data Types

11. 11 DDL, DML, DCL, and the database development process

12. 12 SQL Database Definition Data Definition Language (DDL) Data Definition Language (DDL) Major CREATE statements: Major CREATE statements: CREATE SCHEMA – defines a portion of the database owned by a particular user CREATE SCHEMA – defines a portion of the database owned by a particular user CREATE TABLE – defines a table and its columns CREATE TABLE – defines a table and its columns CREATE VIEW – defines a logical table from one or more views CREATE VIEW – defines a logical table from one or more views Other CREATE statements: CHARACTER SET, COLLATION, TRANSLATION, ASSERTION, DOMAIN Other CREATE statements: CHARACTER SET, COLLATION, TRANSLATION, ASSERTION, DOMAIN

13. 13 Table Creation General syntax for CREATE TABLE Steps in table creation: 1.Identify data types for attributes 2.Identify columns that can and cannot be null 3.Identify columns that must be unique (candidate keys) 4.Identify primary key- foreign key mates 5.Determine default values 6.Identify constraints on columns (domain specifications) 7.Create the table and associated indexes

14. Table Creation: Mysql root@host# mysql -u root -p Enter password:******* mysql> use TUTORIALS; Database changed mysql> root@host# mysql -u root -p Enter password:******* mysql> use TUTORIALS; Database changed mysql> CREATE TABLE tutorials_tbl( tutorial_id INT NOT NULL AUTO_INCREMENT, tutorial_title VARCHAR(100) NOT NULL, tutorial_author VARCHAR(40) NOT NULL, submission_date DATE, PRIMARY KEY ( tutorial_id ) ); CREATE TABLE tutorials_tbl( tutorial_id INT NOT NULL AUTO_INCREMENT, tutorial_title VARCHAR(100) NOT NULL, tutorial_author VARCHAR(40) NOT NULL, submission_date DATE, PRIMARY KEY ( tutorial_id ) ); Query OK, 0 rows affected (0.16 sec) Query OK, 0 rows affected (0.16 sec) mysql> mysql> 14

15. Table Creation: Mysql CREATE TABLE parent ( id INT NOT NULL, PRIMARY KEY (id) ) ENGINE=INNODB; CREATE TABLE parent ( id INT NOT NULL, PRIMARY KEY (id) ) ENGINE=INNODB; CREATE TABLE child ( id INT, parent_id INT, INDEX par_ind (parent_id), FOREIGN KEY (parent_id) REFERENCES parent(id) ON DELETE CASCADE ) ENGINE=INNODB; CREATE TABLE child ( id INT, parent_id INT, INDEX par_ind (parent_id), FOREIGN KEY (parent_id) REFERENCES parent(id) ON DELETE CASCADE ) ENGINE=INNODB; 15

16. 16 The following slides create tables for this enterprise data model

17. 17 Figure 7-6: SQL database definition commands for Pine Valley Furniture Overall table definitions

18. 18 Defining attributes and their data types

19. 19 Non-nullable specification Identifying primary key Primary keys can never have NULL values

20. 20 Non-nullable specifications Primary key Some primary keys are composite – composed of multiple attributes

21. 21 Default value Domain constraint Controlling the values in attributes

22. 22 Primary key of parent table Identifying foreign keys and establishing relationships Foreign key of dependent table

23. 23 Data Integrity Controls Referential integrity – constraint that ensures that foreign key values of a table must match primary key values of a related table in 1:M relationships Referential integrity – constraint that ensures that foreign key values of a table must match primary key values of a related table in 1:M relationships Restricting: Restricting: Deletes of primary records Deletes of primary records Updates of primary records Updates of primary records Inserts of dependent records Inserts of dependent records

24. 24 Relational integrity is enforced via the primary- key to foreign- key match

25. 25 Changing and Removing Tables ALTER TABLE statement allows you to change column specifications: ALTER TABLE statement allows you to change column specifications: ALTER TABLE CUSTOMER_T ADD (TYPE VARCHAR(2)) ALTER TABLE CUSTOMER_T ADD (TYPE VARCHAR(2)) DROP TABLE statement allows you to remove tables from your schema: DROP TABLE statement allows you to remove tables from your schema: DROP TABLE CUSTOMER_T DROP TABLE CUSTOMER_T

26. Changing and Removing Tables ALTER TABLE CUSTOMER ADD (CATEGORY VARCHAR(2)); ALTER TABLE CUSTOMER ADD (CATEGORY VARCHAR(2)); UPDATE CUSTOMER SET CATEGORY = ‘A’ WHERE CUSTOMERID= 1; UPDATE CUSTOMER SET CATEGORY = ‘A’ WHERE CUSTOMERID= 1; ALTER TABLE CUSTOMER DROP CATERGORY; ALTER TABLE CUSTOMER DROP CATERGORY; ALTER TABLE CUSTOMER MODIFY CATEGORY varchar; ALTER TABLE CUSTOMER MODIFY CATEGORY varchar; ALTER TABLE CUSTOMER CHANGE CATEGORY C.CATEGORY varchar(10); ALTER TABLE CUSTOMER CHANGE CATEGORY C.CATEGORY varchar(10);

27. Changing and Removing Tables ALTER TABLE CUSTOMER MODIFY ID varchar(20) PRIMARY KEY; ALTER TABLE CUSTOMER MODIFY ID varchar(20) PRIMARY KEY; ALTER TABLE CUSTOMER MODIFY ID varchar(20) NOT NULL PRIMARY KEY ALTER TABLE CUSTOMER MODIFY ID varchar(20) NOT NULL PRIMARY KEY ALTER TABLE CUSTOMER MODIFY ID varchar(20) primary key AUTO_INCREMENT; ALTER TABLE CUSTOMER MODIFY ID varchar(20) primary key AUTO_INCREMENT; ALTER TABLE CUSTOMER ADD PRIMARY KEY (Id) ALTER TABLE CUSTOMER ADD PRIMARY KEY (Id) ALTER TABLE CUSTOMER DROP PRIMARY KEY; ALTER TABLE CUSTOMER DROP PRIMARY KEY;

28. 28 Schema Definition Control processing/storage efficiency: Control processing/storage efficiency: Choice of indexes Choice of indexes File organizations for base tables File organizations for base tables File organizations for indexes File organizations for indexes Data clustering Data clustering Statistics maintenance Statistics maintenance Creating indexes Creating indexes Speed up random/sequential access to base table data Speed up random/sequential access to base table data Example Example CREATE INDEX NAME_IDX ON CUSTOMER_T(CUSTOMER_NAME) CREATE INDEX NAME_IDX ON CUSTOMER_T(CUSTOMER_NAME) This makes an index for the CUSTOMER_NAME field of the CUSTOMER_T table This makes an index for the CUSTOMER_NAME field of the CUSTOMER_T table

29. 29 Insert Statement Adds data to a table Adds data to a table Inserting into a table Inserting into a table INSERT INTO CUSTOMER_T VALUES (001, ‘Contemporary Casuals’, 1355 S. Himes Blvd.’, ‘Gainesville’, ‘FL’, 32601); INSERT INTO CUSTOMER_T VALUES (001, ‘Contemporary Casuals’, 1355 S. Himes Blvd.’, ‘Gainesville’, ‘FL’, 32601); Inserting a record that has some null attributes requires identifying the fields that actually get data Inserting a record that has some null attributes requires identifying the fields that actually get data INSERT INTO PRODUCT_T (PRODUCT_ID, PRODUCT_DESCRIPTION,PRODUCT_FINISH, STANDARD_PRICE, PRODUCT_ON_HAND) VALUES (1, ‘End Table’, ‘Cherry’, 175, 8); INSERT INTO PRODUCT_T (PRODUCT_ID, PRODUCT_DESCRIPTION,PRODUCT_FINISH, STANDARD_PRICE, PRODUCT_ON_HAND) VALUES (1, ‘End Table’, ‘Cherry’, 175, 8); Inserting from another table Inserting from another table INSERT INTO CA_CUSTOMER_T SELECT * FROM CUSTOMER_T WHERE STATE = ‘CA’; INSERT INTO CA_CUSTOMER_T SELECT * FROM CUSTOMER_T WHERE STATE = ‘CA’;

30. Insert Statement Importing Data with LOAD DATA: Importing Data with LOAD DATA: mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl; mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl; 30

31. 31 Delete Statement Removes rows from a table Removes rows from a table Delete certain rows Delete certain rows DELETE FROM CUSTOMER_T WHERE STATE = ‘HI’; DELETE FROM CUSTOMER_T WHERE STATE = ‘HI’; Delete all rows Delete all rows DELETE FROM CUSTOMER_T; DELETE FROM CUSTOMER_T;

32. 32 Update Statement Modifies data in existing rows Modifies data in existing rows UPDATE PRODUCT_T SET UNIT_PRICE = 775 WHERE PRODUCT_ID = 7; UPDATE PRODUCT_T SET UNIT_PRICE = 775 WHERE PRODUCT_ID = 7;

33. The SELECT Statement Is used for queries on single or multiple tables. It has the following clauses: Is used for queries on single or multiple tables. It has the following clauses: SELECT - Lists the columns (and expressions involving columns) from base tables or views to be projected into the table that will be the result of the command SELECT - Lists the columns (and expressions involving columns) from base tables or views to be projected into the table that will be the result of the command FROM - Identifies the table(s) or view(s) from which columns will be chosen to appear in the result table, and includes the tables or views needed to join tables to process the query FROM - Identifies the table(s) or view(s) from which columns will be chosen to appear in the result table, and includes the tables or views needed to join tables to process the query WHERE - Includes the conditions for row selection within a single table or view, and the conditions between tables or views for joining WHERE - Includes the conditions for row selection within a single table or view, and the conditions between tables or views for joining The first two are required, and the third is necessary when only certain table rows are to be retrieved, or multiple tables are to be joined The first two are required, and the third is necessary when only certain table rows are to be retrieved, or multiple tables are to be joined

34. SELECT Example Find products with standard price less than $275 Find products with standard price less than $275 SELECT PRODUCT_NAME, STANDARD_PRICE SELECT PRODUCT_NAME, STANDARD_PRICE FROM PRODUCT_V FROM PRODUCT_V WHERE STANDARD_PRICE < 275 WHERE STANDARD_PRICE < 275 Comparison Operators in SQL

35. Distinct and * If the user does not want to see duplicate rows in the result, SELECT DISTINCT can be used, so SELECT DISTINCT PRODUCT_NAME would display a results table without duplicate rows If the user does not want to see duplicate rows in the result, SELECT DISTINCT can be used, so SELECT DISTINCT PRODUCT_NAME would display a results table without duplicate rows SELECT * (where * is a wildcard to indicate all columns) displays all columns from all the tables or views in the FROM clause SELECT * (where * is a wildcard to indicate all columns) displays all columns from all the tables or views in the FROM clause

36. 36 SELECT : Alias  The SQL allows renaming relations and attributes using the as clause: old-name as new-name Alias is an alternative column or table name Alias is an alternative column or table name SELECT CUST.CUSTOMER AS NAME, CUST.CUSTOMER_ADDRESS FROM CUSTOMER_V CUST WHERE NAME = ‘Home Furnishings’;

37. SELECT : Alias  Find the name, loan number and loan amount of all customers; rename the column name loan_number as loan_id. select customer_name, borrower.loan_number as loan_id, amount from borrower, loan where borrower.loan_number = loan.loan_number

38. 38 COUNT and SUM Find number of Managers and sum of their salaries. SELECT COUNT(staffNo) AS count, SELECT COUNT(staffNo) AS count, SUM(salary) AS sum FROM Staff WHERE position = ‘Manager’;

39. 39 SELECT Example Using a Function Using the COUNT aggregate function to find totals Using the COUNT aggregate function to find totals SELECT COUNT(*) FROM ORDER_LINE_V WHERE ORDER_ID = 1004; Note: with aggregate functions you can’t have single-valued columns included in the SELECT clause

40. 40 Use of MIN, MAX, AVG Find minimum, maximum, and average staff salary. SELECT MIN(salary) AS min, SELECT MIN(salary) AS min, MAX(salary) AS max, AVG(salary) AS avg AVG(salary) AS avg FROM Staff;

41. Aggregate Functions These functions operate on the multiset of values of a column of a relation, and return a value These functions operate on the multiset of values of a column of a relation, and return a value avg: average value min: minimum value max: maximum value sum: sum of values count: number of values

42. Aggregate Functions (Cont.)  Find the average account balance at the Perryridge branch. n Find the number of depositors in the bank. n Find the number of tuples in the customer relation. select avg (balance) from account where branch_name = ‘Perryridge’ select count (*) from customer select count (distinct customer_name) from depositor

43. Aggregate Functions – Group By  Find the number of depositors for each branch. Note: Attributes in select clause outside of aggregate functions must appear in group by list select branch_name, count (distinct customer_name) from depositor, account where depositor.account_number = account.account_number group by branch_name

44. Aggregate Functions – Having Clause  Find the names of all branches where the average account balance is more than $1,200. Note: predicates in the having clause are applied after the formation of groups whereas predicates in the where clause are applied before forming groups select branch_name, avg (balance) from account group by branch_name having avg (balance) > 1200

45. Tuple Variables  Tuple variables are defined in the from clause via the use of the as clause.  Find the customer names and their loan numbers for all customers having a loan at some branch. select distinct T.branch_name from branch as T, branch as S where T.assets > S.assets and S.branch_city = ‘ Brooklyn’ n Find the names of all branches that have greater assets than some branch located in Brooklyn. select customer_name, T.loan_number, S.amount from borrower as T, loan as S where T.loan_number = S.loan_number

46. 46 SELECT Statement Used for queries on single or multiple tables Used for queries on single or multiple tables Clauses of the SELECT statement: Clauses of the SELECT statement: SELECT SELECT List the columns (and expressions) that should be returned from the query List the columns (and expressions) that should be returned from the query FROM FROM Indicate the table(s) or view(s) from which data will be obtained Indicate the table(s) or view(s) from which data will be obtained WHERE WHERE Indicate the conditions under which a row will be included in the result Indicate the conditions under which a row will be included in the result GROUP BY GROUP BY Indicate categorization of results Indicate categorization of results HAVING HAVING Indicate the conditions under which a category (group) will be included Indicate the conditions under which a category (group) will be included ORDER BY ORDER BY Sorts the result according to specified criteria Sorts the result according to specified criteria

47. 47 SQL statement processing order

48. 48 Evaluation of GroupBy with Having

49. 49 SELECT Example Find products with standard price less than $275 Find products with standard price less than $275 SELECT PRODUCT_NAME, STANDARD_PRICE FROM PRODUCT_V WHERE STANDARD_PRICE < 275; Table 7-3: Comparison Operators in SQL

50. 50 SELECT Example – Boolean Operators AND, OR, and NOT Operators for customizing conditions in WHERE clause AND, OR, and NOT Operators for customizing conditions in WHERE clause SELECT PRODUCT_DESCRIPTION, PRODUCT_FINISH, STANDARD_PRICE FROM PRODUCT_V WHERE (PRODUCT_DESCRIPTION LIKE ‘%Desk’ OR PRODUCT_DESCRIPTION LIKE ‘%Table’) AND UNIT_PRICE > 300; Note: the LIKE operator allows you to compare strings using wildcards. For example, the % wildcard in ‘%Desk’ indicates that all strings that have any number of characters preceding the word “Desk” will be allowed

51. 51 Pattern Matching Example To find names beginning with ‘b’: To find names beginning with ‘b’: mysql> SELECT * FROM pet WHERE name LIKE "b%"; +--------+--------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+------------+ | Buffy | Harold | dog | f | 1989-05-13 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +--------+--------+---------+------+------------+------------+

52. 52 Pattern Matching Example To find names ending with `fy': To find names ending with `fy': mysql> SELECT * FROM pet WHERE name LIKE "%fy"; +--------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+-------+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +--------+--------+---------+------+------------+-------+

53. 53 Pattern Matching Example To find names containing a ‘w’: To find names containing a ‘w’: mysql> SELECT * FROM pet WHERE name LIKE "%w%"; +----------+-------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +----------+-------+---------+------+------------+------------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL | +----------+-------+---------+------+------------+------------+

54. 54 Pattern Matching Example To find names containing exactly five characters, use the _ pattern character: To find names containing exactly five characters, use the _ pattern character: mysql> SELECT * FROM pet WHERE name LIKE "_____"; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+

55. 55 Regular Expression Matching The other type of pattern matching provided by MySQL uses extended regular expressions. The other type of pattern matching provided by MySQL uses extended regular expressions. When you test for a match for this type of pattern, use the REGEXP and NOT REGEXP operators (or RLIKE and NOT RLIKE, which are synonyms). When you test for a match for this type of pattern, use the REGEXP and NOT REGEXP operators (or RLIKE and NOT RLIKE, which are synonyms).

56. String Operations  SQL includes a string-matching operator for comparisons on character strings. The operator “like” uses patterns that are described using two special characters:  percent (%). The % character matches any substring.  underscore (_). The _ character matches any character.  Find the names of all customers whose street includes the substring “Main”. select customer_name from customer where customer_street like ‘ %Main% ’  Match the name “Main%” like ‘ Main\% ’ escape ‘ \ ’  SQL supports a variety of string operations such as  concatenation (using “||”)  converting from upper to lower case (and vice versa)  finding string length, extracting substrings, etc.

57. 57 SELECT Example – Sorting Results with the ORDER BY Clause Sort the results first by STATE, and within a state by CUSTOMER_NAME Sort the results first by STATE, and within a state by CUSTOMER_NAME SELECT CUSTOMER_NAME, CITY, STATE FROM CUSTOMER_V WHERE STATE IN (‘FL’, ‘TX’, ‘CA’, ‘HI’) ORDER BY STATE, CUSTOMER_NAME; Note: the IN operator in this example allows you to include rows whose STATE value is either FL, TX, CA, or HI. It is more efficient than separate OR conditions

58. SELECT : In and not in lists To match a list of values, use IN To match a list of values, use IN e.g. list all customers who live in the warmer American states: e.g. list all customers who live in the warmer American states: IN: SELECT * FROM CUSTOMER_V SELECT * FROM CUSTOMER_V WHERE STATE IN (‘Nairobi’); WHERE STATE IN (‘Nairobi’);NOT: SELECT * FROM CUSTOMER_V WHERE STATE NOT IN (‘Nairobi’); WHERE STATE NOT IN (‘Nairobi’);

59. Ordering the Display of Tuples  List in alphabetic order the names of all customers having a loan in Perryridge branch select distinct customer_name from borrower, loan where borrower loan_number = loan.loan_number and branch_name = ‘ Perryridge ’ order by customer_name  We may specify desc for descending order or asc for ascending order, for each attribute; ascending order is the default.  Example: order by customer_name desc

60. 60 SELECT Example – Categorizing Results Using the GROUP BY Clause For use with aggregate functions For use with aggregate functions Scalar aggregate: single value returned from SQL query with aggregate function Scalar aggregate: single value returned from SQL query with aggregate function Vector aggregate: multiple values returned from SQL query with aggregate function (via GROUP BY) Vector aggregate: multiple values returned from SQL query with aggregate function (via GROUP BY) SELECT STATE, COUNT(STATE) FROM CUSTOMER_V GROUP BY STATE; Note: you can use single-value fields with aggregate functions if they are included in the GROUP BY clause

61. 61 SELECT Example – Qualifying Results by Categories Using the HAVING Clause For use with GROUP BY For use with GROUP BY SELECT STATE, COUNT(STATE) FROM CUSTOMER_V GROUP BY STATE HAVING COUNT(STATE) > 1; Like a WHERE clause, but it operates on groups (categories), not on individual rows. Here, only those groups with total numbers greater than 1 will be included in final result

62. 62 SQL statement processing order

63. 63 Using and Defining Views Views provide users controlled access to tables Views provide users controlled access to tables Base Table – table containing the raw data Base Table – table containing the raw data Dynamic View Dynamic View A “virtual table” created dynamically upon request by a user A “virtual table” created dynamically upon request by a user No data actually stored; instead data from base table made available to user No data actually stored; instead data from base table made available to user Based on SQL SELECT statement on base tables or other views Based on SQL SELECT statement on base tables or other views Materialized View Materialized View Copy or replication of data Copy or replication of data Data actually stored Data actually stored Must be refreshed periodically to match the corresponding base tables Must be refreshed periodically to match the corresponding base tables

64. View Base Relation Views: Security create view cs_students as (select studno, name, tutor,year from student where hons = ‘ cs ’);

65. Views: Query Simplification create view course_staff as (select courseno,subject, staff.lecturer, roomno from course, staff where course.lecturer = staff.lecturer );

66. Views: Query Simplification Course_Totals un-updateable create view coursetotals as (select courseno,count(*) from enrol group by courseno );

67. Views: Logical Data Independence Restructured Database create view student as (select sd.studno, name, hons, tutor, year, totalaverage from student_details sd, marks where sd.studno = marks.studno );

68. Views: Data Integrity Check option enforces the constraint that any insert or update on the view satisfy the where clause Check option enforces the constraint that any insert or update on the view satisfy the where clause create view cs_students as (select studno, name, tutor, year from student where hons = ‘cs’ ) with check option constraint cs ;

69. 69 Sample CREATE VIEW CREATE VIEW EXPENSIVE_STUFF_V AS SELECT PRODUCT_ID, PRODUCT_NAME, UNIT_PRICE FROM PRODUCT_T WHERE UNIT_PRICE >300 WITH CHECK_OPTION;  View has a name  View is based on a SELECT statement  CHECK_OPTION works only for updateable views and prevents updates that would create rows not included in the view

70. 70 Advantages of Views Simplify query commands Simplify query commands Assist with data security (but don't rely on views for security, there are more important security measures) Assist with data security (but don't rely on views for security, there are more important security measures) Enhance programming productivity Enhance programming productivity Contain most current base table data Contain most current base table data Use little storage space Use little storage space Provide customized view for user Provide customized view for user Establish physical data independence Establish physical data independence

71. 71 Disadvantages of Views Use processing time each time view is referenced Use processing time each time view is referenced May or may not be directly updateable May or may not be directly updateable

72. Creating Users CREATE USER 'jeffrey'@'localhost' IDENTIFIED BY 'mypass'; CREATE USER 'jeffrey'@'localhost'; ( No password) CREATE USER 'jeffrey'@'localhost' IDENTIFIED BY PASSWORD '*90E462C37378CED12064BB3388827D2BA3A9B689'; DROP USER 'jeffrey'@'localhost'; 72

73. Users: Permissions SHOW GRANTS FOR user; SHOW GRANTS FOR user; SHOW GRANTS FOR 'rfc'@'localhost'; SHOW GRANTS FOR 'rfc'@'localhost'; GRANT SELECT, UPDATE, DELETE ON 'classicmodels'.* TO 'rfc'@'localhost‘ GRANT SELECT, UPDATE, DELETE ON 'classicmodels'.* TO 'rfc'@'localhost‘ GRANT ALL ON db1.* TO 'jeffrey'@'localhost'; GRANT SELECT ON db2.invoice TO 'jeffrey'@'localhost'; GRANT USAGE ON *.* TO 'jeffrey'@'localhost' WITH MAX_QUERIES_PER_HOUR 90; mysql> CREATE USER 'admin'@'localhost' IDENTIFIED BY 'admin_pass'; mysql> GRANT RELOAD,PROCESS ON *.* TO 'admin'@'localhost'; 73

74. Users: Permissions Revoking Revoking REVOKE INSERT ON *.* FROM 'jeffrey'@'localhost'; REVOKE INSERT ON *.* FROM 'jeffrey'@'localhost'; REVOKE ALL PRIVILEGES FROM user 'jeffrey'@'localhost'; REVOKE ALL PRIVILEGES FROM user 'jeffrey'@'localhost'; REVOKE UPDATE, DELETE ON classicmodels.* FROM 'rfc'@'localhost'; REVOKE UPDATE, DELETE ON classicmodels.* FROM 'rfc'@'localhost'; mysqladmin -u root -p mysqladmin -u root -p mysqladmin -u root -ppassword mysqladmin -u root -ppassword 74

75. Users: Permissions mysql> SHOW GRANTS FOR 'admin'@'localhost'; mysql> INSERT INTO user -> VALUES('localhost','monty',PASSWORD('some_pass'), 'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y'); INSERT INTO user SET Host='localhost',User='admin', Password=PASSWORD('admin_pass'), 75

76. Users: Permissions CREATE USER 'francis'@'localhost' IDENTIFIED BY 'frank'; CREATE USER 'francis'@'localhost' IDENTIFIED BY 'frank'; GRANT ALL ON customer.* TO 'francis'@'localhost‘ GRANT ALL ON customer.* TO 'francis'@'localhost‘ WITH MAX_QUERIES_PER_HOUR 20 MAX_UPDATES_PER_HOUR 10 MAX_CONNECTIONS_PER_HOUR 5 MAX_USER_CONNECTIONS 2; 76

77. Database: Security mysql> SELECT ENCRYPT('hello'); mysql> SELECT ENCRYPT('hello'); -> 'VxuFAJXVARROc' -> 'VxuFAJXVARROc' mysql> SELECT MD5('testing'); mysql> SELECT MD5('testing'); -> 'ae2b1fca515949e5d54fb22b8ed95575‘ -> 'ae2b1fca515949e5d54fb22b8ed95575‘ mysql> SELECT SHA1('abc'); mysql> SELECT SHA1('abc'); -> 'a9993e364706816aba3e25717850c26c9cd0d89d‘ -> 'a9993e364706816aba3e25717850c26c9cd0d89d‘ INSERT INTO t VALUES (1,AES_ENCRYPT('text', SHA1('My secret passphrase'))); INSERT INTO t VALUES (1,AES_ENCRYPT('text', SHA1('My secret passphrase')));  SHA1() can be considered a cryptographically more secure equivalent of MD5()  SHA-1 - 160-bit checksum for the string  MD5 -128-bit checksum for the string. 77

78. SET OPERATORS 78

79. SET OPERATOR: UNION CREATE TABLE a (x INT, y VARCHAR(5)); CREATE TABLE a (x INT, y VARCHAR(5)); CREATE TABLE b (x INT, y VARCHAR(5)); CREATE TABLE b (x INT, y VARCHAR(5)); INSERT INTO a(x,y) VALUES(1,'A'); INSERT INTO a(x,y) VALUES(1,'A'); INSERT INTO a(x,y) VALUES(2,'B'); INSERT INTO a(x,y) VALUES(2,'B'); INSERT INTO a(x,y) VALUES(3,'C'); INSERT INTO a(x,y) VALUES(3,'C'); INSERT INTO a(x,y) VALUES(4,'D'); INSERT INTO a(x,y) VALUES(4,'D'); INSERT INTO b(x,y) VALUES(1,'A'); INSERT INTO b(x,y) VALUES(1,'A'); INSERT INTO b(x,y) VALUES(3,'C'); INSERT INTO b(x,y) VALUES(3,'C'); SELECT * FROM a UNION SELECT * FROM b; SELECT * FROM a UNION SELECT * FROM b; SELECT * FROM a UNION ALL SELECT * FROM b; SELECT * FROM a UNION ALL SELECT * FROM b;

80. SET OPERATOR: DIFFERENCE (MySQL supports no MINUS or EXCEPT) (MySQL supports no MINUS or EXCEPT) SELECT * FROM a WHERE (x,y) NOT IN (SELECT * FROM b); SELECT * FROM a WHERE (x,y) NOT IN (SELECT * FROM b); SELECT * FROM a SELECT * FROM a WHERE NOT EXISTS (SELECT * FROM b WHERE b.x = a.x AND b.y = a.y); 80

81. SET OPERATOR: INTERSECTION SELECT * FROM a WHERE (x,y) IN (SELECT * FROM b) SELECT * FROM a WHERE (x,y) IN (SELECT * FROM b) SELECT * FROM a WHERE EXISTS (SELECT * FROM b WHERE b.x=a.x AND b.y = a.y); SELECT * FROM a WHERE EXISTS (SELECT * FROM b WHERE b.x=a.x AND b.y = a.y); 81

82. SET OPERATOR: DIVISION CREATE TABLE c (x INT, y VARCHAR(5)); CREATE TABLE c (x INT, y VARCHAR(5)); CREATE TABLE d (x INT); CREATE TABLE d (x INT); INSERT INTO c(x,y) VALUES(1,'A'); INSERT INTO c(x,y) VALUES(1,'A'); INSERT INTO c(x,y) VALUES(2,'A'); INSERT INTO c(x,y) VALUES(2,'A'); INSERT INTO c(x,y) VALUES(3,'A'); INSERT INTO c(x,y) VALUES(3,'A'); INSERT INTO c(x,y) VALUES(1,'B'); INSERT INTO c(x,y) VALUES(1,'B'); INSERT INTO c(x,y) VALUES(2,'B'); INSERT INTO c(x,y) VALUES(2,'B'); INSERT INTO c(x,y) VALUES(3,'C'); INSERT INTO c(x,y) VALUES(3,'C'); INSERT INTO c(x,y) VALUES(3,'D'); INSERT INTO c(x,y) VALUES(3,'D'); INSERT INTO d(x) VALUES(1); INSERT INTO d(x) VALUES(1); INSERT INTO d(x) VALUES(2); INSERT INTO d(x) VALUES(2); INSERT INTO d(x) VALUES(3); INSERT INTO d(x) VALUES(3); 82

83. Examples of Division A/B A B1 B2 B3 A/B1A/B2A/B3

84. SET OPERATOR: DIVISION MySQL supports no DIVIDE MySQL supports no DIVIDE SELECT DISTINCT c1.y AS y SELECT DISTINCT c1.y AS y FROM c c1 WHERE NOT EXISTS (SELECT d.x FROM d WHERE d.x NOT IN (SELECT c2.x FROM c c2 WHERE c2.y = c1.y)); 84