12 mysql qs notes

[email protected] MySQL: SCHOOL (DATABASE) STUDENT (Table/Relation (Main or Primary Table)

MARKS (Related Table)

A DATABASE may be defined as a collection of interrelated data stored together to serve multiple applications. A DBMS(Database Management System) refers to a software that is responsible for storing, maintaining and utilizing databases. A database along with a DBMS is referred as a Database System. Advantages of a Database System:

1. Databases reduce the data redundancy to a large extent: Duplication of data is known as data redundancy.

2. They can control data inconsistency: Inconsistency happens when two entries about the same data do not agree.

3. Database facilitates sharing of data 4. Databases enforce standards: The Database system can ensure that all data stored centrally follow the

applicable standards. 5. Databases can ensure data security: Data security refers to protection of data against accidental or

intentional disclosure to unauthorized persons or unauthorized modification or destruction 6. Databases maintain integrity.

Table/Relation Table is a database object or structure where the data is stored. A table will contain rows and columns. A row in a table is called 'tuple' and the column in the table is called 'Attribute' or Field. Domain: This is a pool of values from which actual values appearing in a given column are drawn. Degree : This refers to number of attributes or columns in a table. Cardinality: This refers to the number of rows or tuples in a relation. Primary Key • It is a unique and non-nullable attribute of the table i.e. PK field cannot contain NULL values • The primary key of a relational table uniquely identifies each record in the table. Foreign key (Field that is a „Primary Key‟ in some other table.) • It is a field in a relational table that matches the primary key column of another table. • Foreign key is used to establish and enforce a link between the data in two tables. Candidate Keys • A key that uniquely identifies rows in a table. Any of the identified candidate keys can be used as the table's primary key. Super Key • A Candidate Key as a Super Key that contains only the minimum number of columns necessary to determine uniqueness. Referential Integrity: It is a system of rules that a DBMS uses to ensure that relationships between records in a related tables are valid and the users don‟t accidentally delete or change related data.

REGNO SNAME STD SEC

121 AMIT 12 D

122 SANJAY 12 D

123 ARUN 12 C

124 SUNIL 12 A

REGNO TERM TOTAL

121 1 445

121 2 432

121 3 446

122 1 467

122 2 455

123 1 421

123 2 468

ATTRIBUTES/FIELDS/COLUMNS

ROWS / TUPLES / RECORDS

PRIMARY KEY

FOREIGN KEY

[email protected] MySQL: You can set referential integrity when all the following conditions are met:

The matching field from the „main table‟ is a primary key. The related fields have the same data type. Both the related tables belong to the same database.

When referential integrity is enforced, you must observe the following rules:

1. You can‟t enter a value in the „foreign key field‟ of the related table that doesn‟t exist in the „primary key field‟ of the main table. However you can enter a „null‟ value in the foreign key specifying that the records are unrelated.

2. You can‟t delete a record from a primary table if matching records exist in a related table. 3. You can‟t change a primary key value in the main table, if that record has related records.

Categories if SQL commands Data Definition Language: SQL statements that can be used either interactively or within programming language source code to define databases and their components are DDL commands.

CREATE -Create tables ALTER -Changing the table definition DROP -Drop tables RENAME -Renaming table TRUNCATE -Deletes the data

Data Manipulation Language [DML] These are SQL statements that can be used to manipulate the data in a relational table. It includes …

SELECT - extracts data from a database table UPDATE - updates data in a database table DELETE - deletes data from a database table INSERT INTO - inserts new data into a database table

Data Control Language[DCL] These are SQL statements that can be used for control access to data in a database. It includes…

GRANT -to allow specified users to perform specified tasks. REVOKE- to cancel previously granted or denied permissions

Transaction Control Language[TCL] These are SQL statements that can be used for used to control transactional processing in a database. These includes

COMMIT -to make changes in a table permanent. ROLLBACK -to undo all changes of a transaction

Null Values: if a column in a row has no value, then column is said to contain a null value. You should use a null value when the actual value is not known or when a value would not be meaningful.

Note that, Don‟t use null to represent a value of zero, because they are not equivalent. Any arithmetic expression containing a null value ALWAYS evaluates to null.

Comment: it is a text that is not executed. It is only for documentation purpose. These can be written in MySQL in three ways:

Comments enclosed in /* ……*/ Comments beginning with two hyphens followed by a space (-- ). This

is a single line comment. Comment beginning with # symbol. This is also a single line comment.

Constraints: It is a condition or check applicable on a field or set of fields. Common type are:

1. not null ensures that a column cannot have null value. If you don‟t provide a value for such a column, it will result in an error

2. default provides a default value for a column when none is specified. 3. unique ensures that all values in a column are different. 4. check ensures that all values in a column satisfies a certain criteria. 5. primary key the value of this column will be used to uniquely identify a row. 6. foreign key used to ensure referential integrity of the data.

Note that PK cannot have null values but UNIQUE can have. Also, there can be ONLY ONE PK in a table while multiple fields can be UNIQUE. Different ways of using CHECK constraint:

… std int(2) CHECK (std>=9 and std<=12), ….. … sal int(6) CHECK (sal BETWEEN 10000 AND 20000), ….. … section char(2) CHECK (section IN („A‟,‟B‟,‟C‟,‟D‟,‟E‟)), …. … city varchar(15) CHECK (city NOT IN („KOTA‟)), …. … mf char(2) CHECK (mf IN („M‟,‟F‟)), ….

[email protected] MySQL: create database abc; use abc ; ( this command will make the database „abc‟ active) Now create the following two tables:

CREATE TABLE dept ( -> deptno int(4) primary key, -> dname varchar(20) not null , -> loc varchar (20) not null ) ;

CREATE TABLE empl ( -> empno int(6) primary key , -> ename varchar (25) not null , -> job varchar(15) not null, -> mgr int(6) , -> hiredate date , -> sal decimal(10,2) check (sal > 0) , -> comm decimal(6,2) , -> deptno int(4) default 10, -> foreign key (deptno) references dept(deptno) ) ;

INSERTING ROWS/RECORDS/TUPLES: The rows are added to the table using „INSERT‟ command of SQL. You can Insert records in two ways:

1. Without specifying column names: In this case, you need to provide values for all the fields of the table and in the same order in which they appear in the table definition.

INSERT INTO empl VALUES -> (8369,‟SMITH‟,‟CLERK‟,8902,‟1990-12-18‟,800,NULL,20 ) ;

2. With specifying column names: In this case, you need to provide values ONLY for those fields that appear in the column list of INSERT statement and also in the same order as they appear in the column list.

The values for the columns that you omit in the column list of INSERT statement will be set to NULL

If you omit a column in the column list of INSERT statement and if you have given a „default‟ constraint for that column, then that default value will be set for that omitted column.

INSERT INTO empl (empno, ename, job, hiredate, sal) -> VALUES (8893,‟AMIR‟,‟PRESIDENT‟,‟1991-11-18‟,5000); In the above example,

the value for the omitted column „mgr‟ will be set to null the value for the omitted column „comm‟ will be set to null the value for the omitted column „deptno‟ will be set to 10 because it has

been given a default value with a default constraint. „

Dates are by default entered in „YYYY-MM-DD‟ format. Now INSERT the following records in „dept‟

Deptno Dname Loc

10 ACCOUNTING DELHI

20 MARKETING MUMBAI

30 SALES JAIPUR

40 PRODUCTION BANGLORE

Making simple queries through „SELECT‟ command:

1. To view ALL the Records and ALL columns: SELECT * FROM EMPL ;

To VIEW SELECTIVE RECORDS FROM THE TABLE WE WILL USE „WHERE‟ CLAUSE WITH „SELECT‟ STATEMENT.

2. To view selective columns:

SELECT empno, ename FROM empl; 3. To view unique values from a column, „DISTINCT‟ keyword is used.

SELECT DISTINCT job FROM empl ; 4. To view records of employees who are „managers‟:

SELECT * FROM empl WHERE job=‟manager‟ ; 5. To view those records where a column contains „null‟ values:

SELECT * FROM empl WHERE comm. IS NULL; 6. To view those records where a column DOES NOT contains „null‟ values:

SELECT * FROM empl WHERE comm IS NOT NULL;

You can check more than 2 conditions by using „AND‟ & „OR‟ keywords. With „AND’, both the conditions have to be TRUE if the entire condition has to be TRUE.

With „OR’, any one of the two condition has to be TRUE if the entire condition has to be TRUE.

[email protected] MySQL: 7. Display those „managers who are getting a salary more than 1000:

SELECT * FROM empl WHERE job=‟manager‟ AND sal>1000; 8. Display all those employees who are „managers‟ or „clerks‟.

SELECT * FROM empl WHERE job=‟manager‟ OR job=‟clerk‟; 9. Display all those managers and clerks who are getting salary more than 1000.

SELECT * FROM empl WHERE (job=‟manager‟ OR job=‟clerk‟) AND sal>1000 ;

Identify the logical error with the following query: SELECT * FROM empl WHERE job=‟manager‟ OR job=‟clerk‟ AND sal>1000 ;

To check conditions based on a range of values, the „BETWEEN‟ clause is used with SELECT

statement. This operator defines a range of values that the column values must fall in to make the condition true. The range includes both lower and upper value.

10. To view records where an employee gets a salary between 2000 to 3000.

SELECT * FROM empl WHERE sal BETWEEN 2000 AND 3000. 11. To view records where an employee don‟t get a salary between 2000 to 3000.

SELECT * FROM empl WHERE sal NOT BETWEEN 2000 AND 3000.

To check conditions based on LIST, „IN‟ and „NOT IN‟ clause are used with SELECT statement. The „IN‟ and „NOT IN‟ operator selects values that match any value in a given list of values.

12. To view records of members who live in „Jaipur‟ or „Kota‟ or „Jodhpur‟ from the table „shop‟.

SELECT * FROM shop WHERE city IN(„Jaipur‟,‟Jodhpur‟,‟Kota‟) ; 13. To view records of members who DO NOT live in „Udaipur‟.

SELECT * FROM shop WHERE city NOT IN(„Udaipur‟);

1) Conditions based on pattern matches. SQL includes a string-matching operator „LIKE‟ and „NOT LIKE‟ for comparisons on character strings using patterns. Patterns are described using two special wildcard characters:

% -> this character matches any substring.

_ -> this character matches any one character.

14. To view records of employees whose name begin with „A‟. SELECT * FROM empl WHERE ename LIKE „A%‟ ;

15. To view records where a name is a 4 lettered. SELECT * FROM empl WHERE ename LIKE „____‟ ;

16. To view records where name starts with „A‟ and ends with „S‟: SELECT * FROM empl WHERE ename LIKE „A%S‟ ;

17. To view records where „A‟ is the second character and „S‟ is the second last character in name field. SELECT * FROM empl WHERE ename LIKE „_A%S_‟ ;

18. To view records where name does not contain „in‟ anywhere. SELECT * FROM empl WHERE ename NOT LIKE „%IN%‟ ;

To view records in a sorted manner, „ORDER BY‟ clause is used with „SELECT‟ statement. The default sort order is ascending. To sort in descending order, add „desc‟ after the column name.

19. Display records in sorted manner by the name of the employees.

SELECT * FROM empl ORDER BY ename ; 20. Display records of those employees who are „managers‟ in the descending order of their name:

SELECT * FROM empl WHERE job=‟MANAGER‟ ORDER BY ename DESC ; 21. Display records of all the employees in the sorted order of their jobs in ascending order and names

in descending order. SELECT * FROM empl ORDER BY job, ename desc ;

To make changes to a record, „UPDATE‟ command will be used. 22. To increase the salary of all those employees who are „clerks‟ by 10%.

UPDATE empl SET sal=sal + (10/100*sal) WHERE job=‟CLERK‟ ; 23. Change the name of „SETH‟ to „SID‟.

UPDATE empl SET ename=‟SID‟ WHERE empno=8521; ( Can you guess why I have not written: …..WHERE ename=‟SETH‟…..)

To delete record(s), „DELETE‟ command will be used. 24. Delete all the records from empl table:

DELETE FROM empl; ( Note that it is NOT DELETE * FROM empl) 25. Delete records of all those employees who do not get any commission:

DELETE FROM empl WHERE comm. IS NULL ;

NOTE that, you can use all those statements with „WHERE clause of UPDATE and DELETE‟ which you used with „SELECT‟ statement. Also, „UPDATE‟ and „DELETE‟ statements will not produce any output on the screen.

[email protected] MySQL: Database Integrity Constraints: when you create a table, you can place constraints on the values that can be entered into its fields. If constraints are specified, SQL will reject any values entered or changed through insert or update command that violate the criteria you define. A constraint refers to a condition or a check that is applied to a column(field) or set of columns in a table. The constraints applied to maintain data integrity are also known as database integrity constraints. Following are some commonly used database constraints : (a) UNIQUE (b) CHECK (c) DEFAULT (d) PRIMARY KEY (e) FOREIGN KEY „NOT NULL‟ keyword immediately after column name and its data type indicates that the specific column can never have NULL or empty values. -> Column Constraints apply only to individual columns and they appear in front of the specific column. CREATE TABLE students ( regno int(6) NOT NULL PRIMARY KEY, sname varchar(30) NOT NULL , std int(3) NOT NULL CHECK (std BETWEEN 1 AND 12) , section char(2) NOT NULL CHECK (section IN („A‟ , „B‟, „C‟, „D‟, „E‟ ) ), mf char(2) NOT NULL CHECK (mf IN („M‟, „F‟ ) ) , city varchar(15) NOT NULL DEFAULT „Jaipur‟ , mobile int(10) UNIQUE ) ; All the above constraints are being used with columns so they are termed as „COLUMN CONSTRAINTS. -> Table Constraints apply to groups of one or more columns and they appear in the end of table definition. The above table can be created using table constraints in the following way : CREATE TABLE students ( regno int(6) NOT NULL , sname varchar(30) NOT NULL , std int(3) NOT NULL , section char(2) NOT NULL , mf char(2) NOT NULL , city varchar(15) NOT NULL DEFAULT „Jaipur‟ , mobile int(10) UNIQUE , PRIMARY KEY (REGNO), CHECK (std BETWEEN 1 AND 12) , CHECK (section IN („A‟, „B‟, „C‟, „D‟, „E‟) ) , CHECK (mf IN („M‟, „F‟ ) ) , UNIQUE (mobile) ) ; UNIQUE constraint : This constraint ensure that no two rows have the same value in the specified column(s). PRIMARY KEY constraint: this constraint declares the specified column as the PK of the table. UNIQUE and PRIMARY KEY both ensures unique values for each row for the specified column. But the differences are : UNIQUE allows NULL values. PK does not allow NULL values. Multiple columns with this constraints ONLY one column or group of columns with this can exist. Constraint can exist. DEFAULT constraint: Using this constraint, a default value for a column can be specified. This is a column constraint. If you don‟t specify a value with INSERT INTO command for this column then the value specified with DEFAULT constraint will be assigned for that column. CHECK constraint: this limits values that can be inserted into a column of a table. With CHECK following properties can be used :

EX. city char(20) CHECK (city IN („Jaipur‟, „Ajmer‟, „Kota‟, „Udaipur‟) ), …..

EX. salary float(10,2) CHECK (sal > 5000.00 ), …….

EX. std int(3) CHECK (std BETWEEN 1 and 12 ) , …..

EX. orddate char(10) CHECK (orddate LIKE „--/--/----„ ) , ……

FOREIGN KEY constraint: Referential Integrity is ensured through this constraint. Whenever two tables are related by a common column, then the related column(s) in the „Parent Table‟ (Primary Table) should either be declared as „Primary Key‟ or as UNIQUE and the related column(s) in the „Child Table‟ should have a „Foreign Key‟ constraint. Ex. Considering the table „Student‟ you created previously as a „Parent Table‟, we have a field „regno‟ as a Primary Key. Now we will create a „Child table‟ called „test‟ with the related field „regno‟ which should be declared as Foreign Key . Note that the datatype of the related field should be of the same type.

Column Constraints

Table Constraints

[email protected] MySQL: In this example, Foreign Key is named as „References‟ as it is used as a Column Constraint: CREATE TABLE test ( regno int(6) not null references student (regno ) , term int (2) not null check (term > 0 and term <4 ) , eng int(3) check (eng <= 70) , ) ; The OTHER way to declare Foreign Key In this example, Foreign Key is named as „FOREIGN KEY ‟ as it is used as a Table Constraint: CREATE TABLE test ( regno int(6) not null , term int (2) not null check (term > 0 and term <4 ) , eng int(3) check (eng <= 70) , FOREIGN KEY (regno) REFERENCES student ( regno ) ON DELETE CASCADE ON UPDATE CASCADE ) ; Role of FOREIGN KEY / REFERENCES Constraint: it results in rejection of INSERT or UPDATE statement if a corresponding value does not currently exists

in the „PARENT or PRIMARY TABLE‟ if ON DELETE CASCADE option has been set , then upon deleting a row in the „Parent Table‟ all its

related records in the „CHILD TABLE‟ gets deleted. In the absence of this clause, it rejects the deletion operation if corresponding record in the „Child Table‟ exists.

if ON UPDATE CASCADE option has been set , then upon updating a row in the „Parent Table‟ all its

related records in the „CHILD TABLE‟ gets updated. In the absence of this clause, it rejects the updation operation if corresponding record in the „Child Table‟ exists.

The Foreign Key column in the Child Table must reference a „Primary Key‟ or „Unique‟ column in the

„Parent Table‟. Both the related columns in the Parent and Child Table must have the same data type.

Assigning Names to Constraints: By default MySQL assigns a unique name to each constraint defined by you. MySQL names constraints as : „SYS_Cn‟ where „n‟ is an integer that makes the constraint name unique. Ex. SYS_C003121, SYS_C001592 etc. However, you yourself can name a constraint created by you. This can be done as following :

CREATE TABLE test ( regno int(6) not null , term int (2) not null check (term > 0 and term <4 ) , eng int(3) check (eng <= 70) , phy int(3) check ( phy <=70) , che int(3) check ( che <=70) , mat int(3) check ( mat <=70) , inf int(3) check ( inf <=70) , CONSTRAINT regno_test FOREIGN KEY (regno) REFERENCES student ( regno ) ON DELETE CASCADE ON UPDATE CASCADE ) ;

Copy all the records of empl table into empl2 table. For this to happen, „empl2‟ should have the

same structure as that of „empl‟ table. INSERT INTO empl2 VALUES ( SELECT * FROM empl) ;

Display the structure of the table. DESCRIBE empl; OR DESC empl ;

2) To perform simple calculations you can write the expression or formulae to be calculated

next to the SELECT keyword: 1. To calculate 3.1415 * 6 + 2 / 23 * 3

SELECT 3.1415 * 6 + 2 / 23 * 3 ; 2. To display current system date

SELECT CURDATE();

3) The table in which foreign key is defined is called as „referencing table‟ or „child table‟. A table to which a foreign key points to is called a „referenced table‟ or „parent table‟ or „primary table‟

[email protected] MySQL: Using „COLUMN ALIASES‟: the columns/fields that you select in a query can be given a different name for display/output purposes ONLY. Column Alias means another name given to a column for output.

1. Display name, salary and commission field from „empl‟ table by using a meaning column alias name for the three columns:

SELECT ename AS “Name”, sal AS “Salary”, comm AS “Commission” FROM empl ;

2. Display name and annual salary for each employee using a suitable column alias name:

SELECT ename AS “Name”, sal AS “SALARY”, sal * 12 AS “Annual Salary” FROM empl ;

Note that sal * 12 is a calculated column and NOT a real column as such.

4) The ALTER TABLE command is used to change definitions of existing tables. This is a DDL command that works on a table structure rather than table data. This command is used to:

Add a new column/field to the table [ ADD clause ]

Add an integrity constraint to the table.

Redefine a column (datatype, size, default value etc.) [ MODIFY clause ]

Rename a column/field. [CHANGE clause ]

Delete a column/field. [ DROP clause ]

1. Write a query to add a new column „telno‟ of type int(12) in the table „empl‟

ALTER TABLE empl ADD ( telno int(12) ) ;

2. Write a query to modify column „job‟ of „empl‟ table to have a new width of 20 characters.

ALTER TABLE empl MODIFY job varchar(20) NOT NULL ;

3. Write a query to change the column name „telno‟ to „tel_number‟ of table „empl‟

ALTER TABLE empl CHANGE telno tel_number int(12) ;

4. Write a query to remove „tel_number‟ field from „empl‟ table.

ALTER TABLE empl DROP tel_number;

5. Write a query to set „sno‟ field of a table „student‟ as primary key which was not done earlier.

ALTER TABLE student ADD PRIMARY KEY(sno);

6. Write a query to set „sno‟ field of related table „test‟ as foreign key which will be referring „sno‟ field of „student‟ table which was not done at the time of creating the table

ALTER TABLE test ADD CONSTRAINT test_student FOREIGN KEY(sno) REFERENCES student ;

In this query, you have noticed ADD CONSTRAINT test_student: this statement is actually naming a foreign key constraint as „test_student‟ instead of the default name provided by MySQL.

Also notice REFERENCES student: here you have not provided the field name of the student table to which this related table is referring to. The reason is, if the name of the related field have the same name as that in the „main table‟ or „primary table‟ then you need not to write the field name. the other way this command could have been written was as follows:

ALTER TABLE test ADD CONSTRAINT test_student FOREIGN KEY(sno) REFERENCES student(sno)

7. Write a query to set „custno‟ field of related table „shop‟ as foreign key which will be referring „custnumber‟ field of „customer‟ table which was not done at the time of creating the table

ALTER TABLE shop ADD CONSTRAINT shop_cust FOREIGN KEY(custno) REFERENCES customer(custnumber) ;

In this query since the name of the related fields in both the tables are different, you need to give the field name along with the „main table‟ name with references keyword.

8. Write a query to remove foreign key constraint from „shop table‟.

ALTER TABLE shop DROP FOREIGN KEY shop_cust ; 9. Write a query to remove primary key constraint from „customer table‟.

ALTER TABLE customer DROP PRIMARY KEY ;

In 8th

query NOTE that to remove a foreign key constraint you HAVE to give a name to the FOREIGN KEY CONSTRAINT and the reason being that you can have any number of FOREIGN KEYS defined in a table.

In 9th

query, you need NOT HAVE to give a name to PRIMARY KEY constraint and the reason being that you can have ONLY ONE PK in a table.

NOTE that PRIMARY KEY constraint implies two more constraints automatically namely „UNIQUE‟ and „NOT NULL‟ .

[email protected] MySQL:

„EMPL‟ TABLE

empno Ename Job mgr Hiredate Sal comm deptno

8369 SMITH CLERK 8902 1990-12-18 800.00 NULL 20

8499 ANYA SALESMAN 8698 1991-02-20 1600.00 300 30

8521 SETH SALESMAN 8698 1991-02-22 1250.00 500 30

8566 MAHADEVAN MANAGER 8839 1991-04-02 2985.00 NULL 20

8654 MOMIN SALESMAN 8698 1991-09-28 1250.00 1400 30

8698 BINA MANAGER 8839 1991-05-01 2850.00 NULL 30

8882 SHIVANSH MANAGER 8839 1991-06-09 2450.00 NULL 10

8888 SCOTT ANALYST 8566 1992-12-09 3000.00 NULL 20

8893 AMIR PRESIDENT NULL 1991-11-18 5000.00 0.00 10

8844 KULDEEP SALESMAN 8698 1991-09-08 1500.00 NULL 30

8886 ANOOP CLERK 8888 1993-01-12 1100.00 NULL 20

8900 JATIN CLERK 8698 1991-12-03 950.00 NULL 30

8902 FAKIR ANALYST 8566 1991-12-03 3000.00 NULL 20

8934 MITA CLERK 8882 1992-01-23 1300.00 NULL NULL

Now write the queries for the following based on the „empl‟ table: 1. Display all records and all columns from the table. 2. Display employee number and the name of all the employees from the table. 3. Display employee name, salary, commission and salary added with commission from the table. 4. Write a query to display employee name, salary and department number of those employees who are not

getting any commission. 5. Write a query to display employee name, number, salary and annual salary of all those employees who are

getting commission with suitable alias names. 6. List all department numbers from the table. 7. List all the unique department numbers from the table. 8. List details of all clerks who have not been assigned department as yet. 9. List details of all those employees with 4 lettered name. 10. List the details of all those employees whose annual salary is between 25000 to 40000. 11. How many job types are offered to employees? 12. List the details of employees who earn more commission than their salaries. 13. Write a query to display the name, job title and salary of employees who do not have a manager. 14. Write a query to display the name of employees whose name contains „A‟ as third alphabet. 15. Write a query to display the name of the employees whose name contains „T‟ as the last alphabet. 16. Write a query to display the name of employee who is having „L‟ as any alphabet of the name. 17. Write a query to display name and salary of those employees whose salary is greater than or equal to 2200

from the table. 18. Write a query to display name and salary of all those employees who don‟t have salary in the range of 2500

to 4000. 19. Write a query to display the name of those employees whose name contains „M‟ as first alphabet and „L‟ as

third alphabet. 20. Display all those records where employee name contains „sh‟ in the name field. 21. Display records of those „clerks‟ who earn a salary more than 1000. 22. Display records of those clerks and salesman who earn a salary more than 1000. 23. Display all records in a sorted order by job and then by name. 24. Display records in sorted order of their names in descending order and jobs in ascending order. 25. Display records of those employees who have joined after 1 July 1991. 26. Display records of those employees who work in department 10. 27. Display records of those „clerks‟ who work in department # 10 or 20. 28. Display those „managers‟ whose name begin with „s‟. 29. Display those „salesman‟ or „managers‟ who work in department 30. 30. Display names of those employees who are not getting any commission.

Student ( Table)

studentno class Name Game grade1 Supw grade2

10 7 SAMEER CRICKET B PHOTOGRAPHY A

11 8 SUJIT TENNIS A GARDENING C

12 7 KAMAL SWIMMING B PHOTOGRAPHY B

13 7 VEENA TENNIS C COOKING A

14 9 ARCHANA VOLLEYBALL A LITERATURE A

15 10 ARPIT CRICKET A GARDENING C

1. Display the names of the students who are getting a grade „C‟ in either GAME or SUPW. 2. Display the different games offered in the school. 3. Display the SUPW taken up by the students, whose name starts with „A‟. 4. Display all the students whose game is cricket or tennis. 5. Display all the students whose game is cricket or tennis and they are in class 7. 6. Display records of those students who have got „A‟ grade in both GAME and SUPW. 7. Display names of those students who are in class 9 – 10. 8. Display records of all those students whose name contains „R‟ anywhere. 9. Display the records of all those students whose name begins with „A‟ and who have opted for cricket. 10. Display records of those students who have got „A‟ grade in either „Photography‟ or „Gardening‟.


CREATE TABLE dept ( -> deptno int(4) primary key, -> dname varchar(20) not null , -> loc varchar (20) not null ) ;

CREATE TABLE empl ( -> empno int(6) primary key , -> ename varchar (25) not null , -> job varchar(15) not null, -> mgr int(6) , -> hiredate date , -> sal decimal(10,2) check (sal > 0) , -> comm decimal(6,2) , -> deptno int(4) default 10, -> foreign key (deptno) references dept(deptno) ) ;

JOINS

A JOIN is a query that combines rows from two or more tables. In such a query, more than one table are listed in FROM clause. The function of combining data from multiple tables is called „joining‟.

1) In the above two tables, „deptno‟ field in „dept table‟ is a primary key. And the „empl table‟ contains the field „deptno‟ which is a foreign key as it is deriving its value from the „deptno‟ field of „dept table‟.

In “Unrestricted Join” or “Cartesian Product” of two tables, all possible combinations are formed of all rows of both the tables.

SELECT * FROM empl , dept ; It returns n1 x n2 rows where n1(empl) is number of rows in first table and n2(dept) is number of rows in second table.

The join in which columns are compared for equality is called “Equi-Join”. In this, all columns from joining table appear in the output even if they are identical.

SELECT * FROM empl , dept WHERE empl.deptno = dept.deptno ; -- this is a join condition

In this, we are joining two tables empl and dept on the basis of their common field deptno. Also notice empl.deptno: this type of statement is termed as qualified field names. A field name needs to be qualified with its table name when two tables contain a field with the same name so as to avoid ambiguity. To qualify a field name you need to type the table name followed by the dot and the field name.

The join in which only one of the identical columns coming from the joined tables appear is called a Natural Join.

SELECT empl.* , dname, loc FROM empl, dept WHERE empl.deptno = dept.deptno ;

JOINING TABLES USING JOIN CLAUSES

A JOIN clause without a join condition will create a CARTESIAN PRODUCT of two tables: SELECT * FROM empl JOIN dept ;

If no join condition is specified with a JOIN clause, a Cartesian Product is the output. To create equi-join on some common field of two tables, write the query as: SELECT * FROM empl JOIN dept ON ( empl.deptno = dept.deptno ) ;

You can specify join fields through USING clause also in place of ON clause, but with USING clause you just have to specify the name of the join field whereas with ON clause, join condition is specified. But USING clause requires that joining fields have the same name in both the tables. SELECT * FROM empl JOIN dept USING (deptno) ; USING sub clause with JOIN clause produces a “Natural Join” whereas ON sub clause with JOIN clause produces “Equi-Join”

A CROSS JOIN clause will obtain the Cartesian product of two tables and also you can‟t give a join

condition with such type of join. SELECT * FROM empl CROSS JOIN dept ;

A NATURAL JOIN clause joins two table based on a common field. Also this clause will display the common field only once. But specifying this clause requires that joining field of both the tables must have the same name.

SELECT * FROM empl NATURAL JOIN dept ; In the above query, you need not specify a join condition. But if joining fields have different names than this clause will not work and you have to write the query with ”=” sign as :

SELECT * FROM shop, customer WHERE shop.custno = customer.cno ;

In the above query you can see that the related field of both the tables has different names that is „custno‟ in „shop table‟ and „cno‟ in „customer table‟ and as such NATURAL JOIN clause will not work.


When you display an “equi join” or “natural join”, it shows only the matched rows. But if we want to know which all rows from a table did not match with other, MySQL “Left Join” or “Right Join” will be used.

1. When using LEFT JOIN all rows from the first(left) table will be returned whether there are matches in the second table or not. For unmatched rows in the first table, NULL is shown in columns of second table. For example, dept table has a deptno which is not there in empl table, then if you left join dept table with empl, NULL is returned for non-existing values in empl table: SELECT dept.* ,ename,mgr,sal FROM dept LEFT JOIN empl ON dept.deptno = empl.deptno ; Lets see how the above query works: MySQL starts with the left table (dept here). For each row from the table dept MySQL scans the table empl, finds the deptno of the enployees and returns employee name(ename), manager‟s code(mdr) and his salary(sal). Then these fields of empl table are joined with the matching row from the table dept. for unmatched rows, it returns NULL for ename, mgr and sal fields.

2. RIGHT JOIN works just like LJ but with table order reversed. All rows from second(right) table are going to be returned whether or not there are matches in the first table.

Now queries based on two tables: 1. Consider the tables „HANDSETS‟ and „CUSTOMER‟ given below:

HANDSETS TABLE

SetCode SetName TouchScreen PhoneCost

N1 Nokia 2G N 5000

N2 Nokia 3G Y 8000

B1 BlackBerry N 14000

CUSTOMER TABLE

CustNo SetNo CustAddress

1 N2 Delhi

2 B1 Mumbai

3 N2 Mumbai

4 N1 Kolkata

5 B1 Delhi

a. Display the CustNo, CustAddress, and corresponding SetName for each customer. b. Display the Customer details for each customer who uses a Nokia handset. c. Give the output of the following query:

SELECT setno, setname FROM handsets,customer WHERE setno=setcode AND CustAddress=‟Delhi‟ ;

2. Consider the tables „DOCTORS and „PATIENTS‟ given below:

DOCTORS TABLE

DocID DocName Department OPD_Days

101 M. Pandey ENT TTS

102 G.P.Gupta Paed MWF

201 C.K. Sharma Ortho MWF

PATIENTS TABLE

PatNo PatName Department DocID

1 Neeraj ENT 101

2 Mohit Ortho 201

3 Ragini ENT 101

4 Mohit Paed 102

5 Nandini Ortho 201

a. Display the PatNo, PatName and corresponding DocName for each patient. b. Display the list of patients whose OPD-Days are MWF. c. Give the output of the following query:

SELECT opd_days, COUNT(*) FROM doctors, patients WHERE patients.department = doctors.department GROUP BY opd_days ;


Types of SQL Functions:

Single row functions (Scalar): works with a single row at a time. These functions return a result for every row of a queried table.

Multiple row functions (Group or Aggregate): work with data of multiple rows at a time and return aggregate value.

How are aggregate functions in MySQL?

Aggregate functions perform summary operations on a set of values, such as counting, averaging, or finding minimum or maximum values. Aggregate functions often are used in conjunction with a GROUP BY clause to arrange values from a result set into groups. In this case, the aggregate function produces a summary value for each group.

The GROUP BY clause combines all those records that have identical values in a particular field or a group of fields. In other words this clause is used in SELECT statements to divide the table into groups. Grouping can be done by a column name, or with aggregate functions in which case the aggregate produces a value for each group.

Grouping can be based on the values in one or more columns of the selected rows. For example, the Country table indicates which continent each country is part of, so you can group the records by continent and calculate the average population of countries in each continent:

SELECT Continent, AVG(Population) FROM Country GROUP BY Continent;

2) Placing conditions on Groups by HAVING clause: The HAVING clause places conditions on groups in contrast to WHERE clause that places conditions on individual rows. While WHERE conditions cannot include aggregate functions, HAVING conditions can do.

Functions such as AVG() that calculate summary values for groups are known as "aggregate" functions because they're based on aggregates or groups of values. There are several types of aggregate functions. Those discussed here are as follows:

MIN() and MAX() find smallest and largest values.

SUM() and AVG() summarize numeric values to produce sums (totals) and averages.

COUNT() counts rows, values, or the number of distinct values.

Aggregate functions may be used with or without a GROUP BY clause that places rows into groups. Without a GROUP BY clause, an aggregate function calculates a summary value based on the entire set of selected rows. (That is, MySQL treats all the rows as a single group.)

With a GROUP BY clause, an aggregate function calculates a summary value for each group. For example, if a WHERE clause selects 20 rows and the GROUP BY clause arranges them into four groups of five rows each, a summary function produces a value for each of the four groups.

The MIN() and MAX() Aggregate Functions

MIN() and MAX() are comparison functions. They return smallest or largest numeric values, lexically first or last string values, and earliest or latest temporal values. The following queries determine the smallest and largest country populations and the lexically first and last country names:

mysql> SELECT MIN(Population), MAX(Population) FROM Country; +-----------------+-----------------+ | MIN(Population) | MAX(Population) | +-----------------+-----------------+ | 0 | 1277558000 | +-----------------+-----------------+ mysql> SELECT MIN(Name), MAX(Name) FROM Country; +-------------+-----------+ | MIN(Name) | MAX(Name) | +-------------+-----------+ | Afghanistan | Zimbabwe | +-------------+-----------+

It is to be noted that MIN() and MAX() ignore NULL values.

The SUM() and AVG() Aggregate Functions

The SUM() and AVG() functions calculate sums and averages. For example, the Country table in the world database contains a Population column, so you can calculate the total world population and the average population per country like this:

http://www.mysqlfaqs.net/mysql-faqs/Funtions-and-Operators/How-are-aggregate-functions-in-MySQL


mysql> SELECT SUM(Population), AVG(Population) FROM Country; +-----------------+-----------------+ | SUM(Population) | AVG(Population) | +-----------------+-----------------+ | 6078749450 | 25434098.1172 | +-----------------+-----------------+

SUM() and AVG() are most commonly used with numeric values. If you use them with other types of values, those values are subject to numeric conversion, which might not produce a sensible result.

It is to be noted that SUM() and AVG() ignore NULL values.

The COUNT() Aggregate Function

The COUNT() function can be used in several ways to count either rows or values. To illustrate, the examples here use the following table that has several rows containing various combinations of NULL and non-NULL values:

mysql> SELECT i, j FROM t; +------+------+ | i | j | +------+------+ | 1 | NULL | | NULL | 2 | | 1 | 1 | | 1 | 1 | | 1 | 3 | | NULL | NULL | | 1 | NULL | +------+------+

COUNT() may be used as follows:

COUNT(*) counts the total number of rows:

mysql> SELECT COUNT(*) FROM t;

| COUNT(*) |

| 7 |

COUNT(expression) counts the number of non-NULL values of the given expression. It's common for expression to be a column name, in which case COUNT() counts the number of non-NULL values in the column:

mysql> SELECT COUNT(i), COUNT(j) FROM t;

| COUNT(i) | COUNT(j) |

| 5 | 4 |

COUNT(DISTINCT expression) counts the number of distinct (unique) non-NULL values of the given expression. expression can be a column name to count the number of distinct non-NULL values in the column:

mysql> SELECT COUNT(DISTINCT i), COUNT(DISTINCT j) FROM t;

| COUNT(DISTINCT i) | COUNT(DISTINCT j) |

| 1 | 3 |

It's also possible to give a list of expressions separated by commas. In this case, COUNT() returns the number of distinct combinations of values that contain no NULL values. The following query counts the number of distinct rows for which neither i nor j is NULL:

mysql> SELECT COUNT(DISTINCT i, j) FROM t; | COUNT(DISTINCT i, j) | | 2 |

Aggregation for NULL Values or Empty Sets

In general, aggregate functions ignore NULL values. The exception is COUNT(), which behaves as follows:

COUNT(*) does not ignore NULL values because it counts rows, even those that contain NULL values.

COUNT(expression) and COUNT(DISTINCT) do ignore NULL values.


A SELECT statement might produce an empty result set if the table is empty or the WHERE clause selects no rows from it. If the set of values passed to an aggregate function is empty, the function computes the most sensible value. For COUNT(), the result is zero. But functions such as MIN(), MAX(), SUM(), AVG(), and GROUP_CONCAT() return NULL.

Examples of Aggregate Functions based on “empl” table: 1) Display number of records in the table.

SELECT COUNT(*) FROM EMPL; 2) Display total number of departments in the table.

SELECT COUNT(DEPTNO) FROM EMPL; 3) Display count of employees working in each job in the table.

SELECT JOB, COUNT(JOB) FROM EMPL GROUP BY JOB; 4) Display total number of employees working in each department.

SELECT DEPTNO, COUNT(DEPTNO) FROM EMPL GROUP BY DEPTNO; 5) Display total employees working those jobs where job name begins with „s‟.

SELECT JOB, COUNT(JOB) FROM EMPL GROUP BY JOB HAVING JOB LIKE „S%‟;

6) Display total employees and total salary given to those jobs where job name begins with „s‟. SELECT JOB, COUNT(JOB), SUM(SAL) FROM EMPL GROUP BY JOB HAVING JOB LIKE „S%‟;

7) Display count and sum of those jobs where number of employees working is more than 2. SELECT JOB, COUNT(JOB), SUM(SAL) FROM EMPL GROUP BY JOB HAVING COUNT(JOB) > 2;

8) Display count and sum of those jobs where total salary assigned to the job is greater than 5000. SELECT JOB, COUNT(JOB), SUM(SAL) FROM EMPL GROUP BY JOB HAVING SUM(SAL) > 5000 ;

9) Display maximum salary in the table. SELECT MAX(SAL) FROM EMPL;

10) Display the details of the employee who is getting the maximum salary in the table. SELECT * FROM EMPL WHERE SAL = ( SELECT MAX(SAL) FROM EMPL ) ;

Here we have used a sub-query inside a query. Also make sure that the sub-query SHOULD return ONE and ONLY ONE record.

11) Display the name of employee who is getting maximum salary in a particular job. SELECT ENAME, JOB AS J, SAL FROM EMPL WHERE SAL >= (SELECT MAX(SAL) FROM EMPL GROUP BY JOB HAVING JOB=J) ;

12) Display those employees whose name begins with „s‟ from each job type. SELECT ENAME, JOB FROM EMPL WHERE ENAME LIKE „S%‟ GROUP BY JOB ;

13) Group records department-wise than job-wise. SELECT DEPTNO, JOB, COUNT(DEPTNO) FROM EMPL GROUP BY DEPTNO, JOB ;

14) Display total salary given to each department. SELECT DEPTNO, SUM(SAL) FROM EMPL GROUP BY DEPTNO;

15) Display total salary given to department # 10. SELECT DEPTNO, SUM(SAL) FROM EMPL WHERE DEPTNO=10 GROUP BY DEPTNO; OR SELECT DEPTNO, SUM(SAL) FROM EMPL GROUP BY DEPTNO HAVING DEPTNO=10 ;;

16) Display total salary, average salary and total employees working in each department. SELECT DEPTNO, SUM(SAL), AVG(SAL), COUNT(DEPTNO) FROM EMPL GROUP BY DEPTNO;

17) Display the details of the employee who is getting maximum salary in that department. SELECT DEPTNO AS D, ENAME, SAL FROM EMPL WHERE SAL >= (SELECT MAX(SAL) FROM EMPL GROUP BY DEPTNO HAVING DEPTNO=D) OR DEPTNO IS NULL ORDER BY DEPTNO;

18) Display highest and lowest salary and their difference of each department. SELECT DEPTNO, MAX(SAL), MIN(SAL), MAX(SAL) – MIN(SAL) FROM EMPL GROUP BY DEPTNO;

19) Display salary, commission and sum of total and commission for each employee. Ensure that the total salary should not be a null value.

SELECT ENAME, SAL, COMM, SAL + IFNULL(COMM,0) AS “TOTAL” FROM EMPL; The IFNULL function will substitute any NULL value in „comm‟ field with 0 and thus the

result displayed will be a Non-NULL value. 20) Display those jobs where number of employees is less than 3.

SELECT JOB, COUNT(*) FROM EMPL GROUP BY JOB HAVING COUNT(*) < 3 ; 21) Display employee number his name, his manager code and his manager‟s name from the table.

SELECT E1.EMPNO, E1.ENAME, E1.MGR, E2.ENAME FROM EMPL AS E1 LEFT JOIN EMPL AS E2 ON E1.MGR = E2.MGR ;

If you include a non-group expression in the select list of a query with GROUP BY, MySQL will not produce any error. Rather it will pick value of the non-group field from the first row of the group. Such queries may result in ambiguous result. Ex. SELECT ENAME, SUM(SAL) FROM EMPL GROUP BY DEPTNO; This query will display the first name of the first group of dept#.

[email protected] MySQL: SINGLE ROW FUNCTIONS (Scalar)

A Function is a special type of pre defined command that perform some operation and return a single value.

Following are some commonly used String, Numeric and DateTime functions . These functions are row level

functions i.e. these functions works on each row if used with tables.

CHAR(N) CHAR() interprets each argument N as an integer and returns a string consisting of the characters given

by the code values of those integers. NULL values are skipped.

mysql> SELECT CHAR(77,121,83,81,'76');

MySQL

CONCAT(str1,str2,...) Returns the string that results from concatenating the arguments. May have one or more

arguments.

mysql> SELECT CONCAT('My', 'S', 'QL');

| MySQL

INSTR(str,substr) Returns the position of the first occurrence of substring substr in string str. This is the same as

the two-argument form of LOCATE(), except that the order of the arguments is reversed.

mysql> SELECT INSTR('jaipur', 'ur');

| 5

LCASE(str) LCASE() is a synonym for LOWER().

LEFT(str,len) Returns the leftmost len characters from the string str, or NULL if any argument is NULL.

mysql> SELECT LEFT(‘rajasthan', 3);

raj

LENGTH(str) Returns the length of the string str, measured in bytes. .

mysql> SELECT LENGTH('text');

| 4

LOWER(str) Returns the string str with all characters changed to lowercase according to the current character set

mapping.

mysql> SELECT LOWER('QUADRATICALLY');

| quadratically

LTRIM(str) Returns the string str with leading space characters removed.

mysql> SELECT LTRIM(' hello');

hello

MID(str,pos,len) MID(str,pos,len) is a synonym for SUBSTRING(str,pos,len).

REPEAT(str,count) Returns a string consisting of the string str repeated count times. If count is less than 1, returns

an empty string. Returns NULL if str or count are NULL.

mysql> SELECT REPEAT('MySQL', 3);

| MySQLMySQLMySQL

REVERSE(str) Returns the string str with the order of the characters reversed.

mysql> SELECT REVERSE('abcd');

| dcba

RIGHT(str,len) Returns the rightmost len characters from the string str, or NULL if any argument is NULL.

mysql> SELECT RIGHT('jaipur', 2);

| ur

RTRIM(str) Returns the string str with trailing space characters removed.

mysql> SELECT RTRIM('hello ');

| hello

STRCMP(str1, str2) Compares two strings and returns 0 if both strings are equal, it returns -1 if the first argument is

smaller than the second according to the current sort order otherwise it returns 1.

mysql> SELECT STRCMP('MOHD', 'MOHD');

| 0

mysql> SELECT STRCMP('AMOHD', 'MOHD');

| -1


mysql> SELECT STRCMP('MOHD', 'AMOHD');

| 1

SUBSTRING(str,pos) OR SUBSTRING(str FROM pos) OR SUBSTRING(str,pos,len)

The forms without a len argument return a substring from string str starting at position pos. The forms with a len argument

return a substring len characters long from string str, starting at position pos. The forms that use FROM are standard SQL

syntax. It is also possible to use a negative value for pos. In this case, the beginning of the substring is pos characters from

the end of the string, rather than the beginning. A negative value may be used for pos in any of the forms of this function.

mysql> SELECT SUBSTRING('Quadratically',5);

| ratically |

mysql> SELECT SUBSTRING(‘rajasthan' FROM 6);

|than

mysql> SELECT SUBSTRING('Quadratically',5,6);

| ratica

TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str) TRIM([remstr FROM] str) Returns the

string str with all remstr prefixes or suffixes removed. If none of the specifiers BOTH, LEADING, or TRAILING is given,

BOTH is assumed. remstr is optional and, if not specified, spaces are removed.

mysql> SELECT TRIM(' bar ');

| bar

UCASE(str) UPPER(str) Returns the string str with all characters changed to uppercase according to the

current character set mapping.

mysql> SELECT UPPER('Xaviers');

| XAVIERS

Numeric Functions

ABS(X) The ABS() function returns the absolute value of X. Consider the following example:

mysql> SELECT ABS(2);

| 2

mysql> SELECT ABS(-2);

| 2

CEIL(X) CEILING(X) These function return the smallest integer value that is not smaller than X. Consider the

following example:

mysql> SELECT CEILING(3.46);

| 4

mysql> SELECT CEIL(-6.43);

| -6

FLOOR(X) This function returns the largest integer value that is not greater than X.

mysql>SELECT FLOOR(7.55);

| 7

FORMAT(X,D) The FORMAT() function is used to format the number X in the following format: ###,###,###.##

truncated to D decimal places.

mysql>SELECT FORMAT(423423234.65434453,2);

| 423,423,234.65

GREATEST(n1,n2,n3,..........) The GREATEST() function returns the greatest value in the set of input parameters (n1,

n2, n3, a nd so on).

mysql>SELECT GREATEST(3,5,1,8,33,99,34,55,67,43);

| 99

LEAST(N1,N2,N3,N4,......) The LEAST() function is the opposite of the GREATEST() function. Its purpose is to

return the least-valued item from the value list (N1, N2, N3, and so on).

mysql>SELECT LEAST(3,5,1,8,33,99,34,55,67,43);

| 1

[email protected] MySQL: MOD(N,M) This function returns the remainder of N divided by M. Consider the following example:

mysql>SELECT MOD(29,3);

| 2

POW(X,Y) POWER(X,Y) These two functions return the value of X raised to the power of Y.

mysql> SELECT POWER(3,3);

| 27

ROUND(X) ROUND(X,D) This function returns X rounded to the nearest integer. If a second argument,

D, is supplied, then the function returns X rounded to D decimal places. D must be positive or all digits to the right of the

decimal point will be removed. Consider the following example:

mysql>SELECT ROUND(5.693893);

| 6

mysql>SELECT ROUND(5.693893,2);

| 5.69

SIGN(X) This function returns the sign of X (negative, zero, or positive) as .1, 0, or 1.

mysql>SELECT SIGN(-4.65);

| -1

mysql>SELECT SIGN(0);

| 0 |

mysql>SELECT SIGN(4.65);

| 1

SQRT(X) This function returns the non-negative square root of X. Consider the following example:

mysql>SELECT SQRT(49);

| 7

TRUNCATE(X,D) This function is used to return the value of X truncated to D number of decimal places. If D is 0,

then the decimal point is removed. If D is negative, then D number of values in the integer part of the value is truncated.

Consider the following example:

mysql>SELECT TRUNCATE(7.536432,2);

| 7.53

CURDATE() Returns the current date as a value in 'YYYY-MM-DD' or YYYYMMDD format, depending on whether

the function is used in a string or numeric context.

mysql> SELECT CURDATE();

| 1997-12-15

mysql> SELECT CURDATE() + 0;

| 19971215

CURRENT_DATE and CURRENT_DATE() CURRENT_DATE and CURRENT_DATE() are synonyms for

CURDATE()

CURTIME() Returns the current time as a value in 'HH:MM:SS' or HHMMSS format, depending on whether the

function is used in a string or numeric context. The value is expressed in the current time zone.

mysql> SELECT CURTIME();

| 23:50:26

CURRENT_TIME and CURRENT_TIME() CURRENT_TIME and CURRENT_TIME() are synonyms for

CURTIME().

DATE(expr) Extracts the date part of the date or datetime expression expr.

mysql> SELECT DATE('2003-12-31 01:02:03');

| 2003-12-31

DAY(date) DAY() is a synonym for DAYOFMONTH().

DAYNAME(date) Returns the name of the weekday for date.

mysql> SELECT DAYNAME('1998-02-05');

| Thursday

DAYOFMONTH(date) Returns the day of the month for date, in the range 0 to 31.


mysql> SELECT DAYOFMONTH('1998-02-03');

| 3

DAYOFWEEK(date) Returns the weekday index for date (1 = Sunday, 2 = Monday, ., 7 = Saturday). These index

values correspond to the ODBC standard.

mysql> SELECT DAYOFWEEK('1998-02-03');

| 3

DAYOFYEAR(date) Returns the day of the year for date, in the range 1 to 366.

mysql> SELECT DAYOFYEAR('1998-02-03');

| 34

HOUR(time) Returns the hour for time. The range of the return value is 0 to 23 for time-of-day values. However, the

range of TIME values actually is much larger, so HOUR can return values greater than 23.

mysql> SELECT HOUR('10:05:03');

| 10

LAST_DAY(date) Takes a date or datetime value and returns the corresponding value for the last day of the month.

Returns NULL if the argument is invalid.

MINUTE(time) Returns the minute for time, in the range 0 to 59.

MONTH(date) Returns the month for date, in the range 0 to 12.

mysql> SELECT MONTH('1998-02-03')

| 2

MONTHNAME(date) Returns the full name of the month for date.

mysql> SELECT MONTHNAME('1998-02-05');

| February

NOW() Returns the current date and time as a value in 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS format,

depending on whether the function is used in a string or numeric context. The value is expressed in the current time zone.

mysql> SELECT NOW();

| 1997-12-15 23:50:26

SECOND(time) Returns the second for time, in the range 0 to 59.

SYSDATE() Returns the current date and time as a value in 'YYYY-MM-DD HH:MM:SS' or

YYYYMMDDHHMMSS format, depending on whether the function is used in a string or numeric context.

mysql> SELECT SYSDATE();

| 2006-04-12 13:47:44

TIME(expr) Extracts the time part of the time or datetime expression expr and returns it as a string.

mysql> SELECT TIME('2003-12-31 01:02:03');

| 01:02:03

YEAR(date) Returns the year for date, in the range 1000 to 9999, or 0 for the .zero. date.

mysql> SELECT YEAR('98-02-03');

| 1998


DATABASE TRANSACTIONS

A TRANSACTION is a logical unit of work that must succeed or fail in its entirety. This means that a transaction may involve many sub-steps which should either all be carried out successfully or all should be ignored if some failure occurs. Transaction Properties: In order to maintain the data integrity, the database system maintains the following properties of the transaction often termed as ACID properties:

Atomicity: this property ensures „All or None‟ operations are carried out i.e. the transaction runs to completion as an indivisible unit, at the end of which either no change at all will be made to the database or the database will have changed in a consistent manner. This property has two states:

o DONE state means a transaction must complete successfully and its effect should be visible in the database.

o NEVER STARTED state means if a transaction fails during execution then all its modifications must be undone to bring back the database to the last consistent state i.e. remove all the effects of a failed transaction.

Consistency: this ensures that if the database was in a consistent state before the start of the transaction, then upon its termination, the database will be in a consistent state.

Isolation: this implies that each transaction is unaware of other transaction executing concurrently in the system.

Durability: this ensures that on the successful completion of a transaction i.e. when a transaction is COMMITed, the changes made by it to the database persist, even if there are system failures.

MySQL offers a set of commands for transaction control purpose and these subset of commands are known as TCL (Transaction Control Language commands):

a. BEGIN | START TRANSACTION marks the beginning of a transaction. b. COMMIT ends the current transaction by saving database changes and start a new transaction. c. ROLLBACK ends the current transaction by discarding database changes and starts a new

transaction. d. SAVEPOINT defines breakpoints for the transaction to allow partial rollbacks. e. SET AUTOCOMMIT enables or disables the default autocommit mode.

Explain how the following sql script would affect the table:

1. START TRANSACTION 2. UPDATE ….. 3. INSERT … 4. SAVEPOINT S1 5. INSERT… 6. SAVEPOINT S2 7. DELETE… 8. ROLLBACK WORK TO SAVEPOINT S2 9. UPDATE… 10. ROLLBACK WORK TO SAVPOINT S1 11. UPDATE… 12. DELETE… 13. COMMIT WORK

Statement 1: transaction begins Statement 2 -3 : these two changes are not yet permanent Statement 4: a savepoint is defined with the name s1 Statement 5: this change is not yet permanent Statement 6: a savepoint is defined with the name s2 Statement 7: this change is not yet permanent Statement 8: a rollback is issued. However, only those changes performed after savepoint s2 are

undone. The statement 7 will be undone. Statement 9: this change is not yet permanent Statement 10: a rollback to savepoint s1 is entered. All changes performed after statement 4 is

undone. Thus statement 5, 7, 9 will be undone. Statement 11-12: these two changes are not yet permanent. Statement 13: all non-permanent changes are made permanent. Thus statements 2, 3, 11 and 12 will

be made permanent. Note that a transaction ends with:

An explicit COMMIT statement and the changes will be committed or

An explicit ROLLBACK statement and the changes will be undone or

An explicit START TRANSACTION statement the transaction is committed or

Implicitly by issuing any DDL command a transaction is committed. SET AUTOCOMMIT: by default, MySQL has autocommit “ON”, which means if you do not start a transaction explicitly through BEGIN or START TRANSACTION command, then every statement is considered one transaction and is committed there and then. SET AUTOCOMMIT=1; will enable auto-commit. To disable auto-commit type: SET AUTOCOMMIT=0; this is to make sure that changes made by statement are not made permanent until you explicitly issue a COMMIT command.

12 mysql qs notes

Documents

single line

aggregate

create table

current time

ignore null

database integrity

foreign key

display total