0% found this document useful (0 votes)

12 views

SQL Pdf_class

sql description

Uploaded by

Ayush Kumar

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

12 views

SQL Pdf_class

sql description

Uploaded by

Ayush Kumar

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 93

1

CHAPTER

SQL Overview

S QL tutorial gives unique learning on Structured Query Language and it helps to make practice on SQL

commands which provides immediate results. SQL is a language of database, it includes database creation,
deletion, fetching rows and modifying rows etc.
SQL is an ANSI (American National Standards Institute) standard, but there are many different versions of the
SQL language.

What is SQL?
SQL is Structured Query Language, which is a computer language for storing, manipulating and retrieving data
stored in relational database.

SQL is the standard language for Relation Database System. All relational database management systems like
MySQL, MS Access, Oracle, Sybase, Informix, postgres and SQL Server use SQL as standard database
language.

Also, they are using different dialects, such as:

 MS SQL Server using T-SQL,

 Oracle using PL/SQL,

 MS Access version of SQL is called JET SQL (native format) etc.

Why SQL?
 Allows users to access data in relational database management systems.

 Allows users to describe the data.

 Allows users to define the data in database and manipulate that data.

 Allows to embed within other languages using SQL modules, libraries & pre-compilers.

 Allows users to create and drop databases and tables.

TUTORIALS POINT
Simply Easy Learning
 Allows users to create view, stored procedure, functions in a database.

 Allows users to set permissions on tables, procedures and views

History:
 1970 -- Dr. E. F. "Ted" of IBM is known as the father of relational databases. He described a relational model
for databases.
 1974 -- Structured Query Language appeared.
 1978 -- IBM worked to develop Codd's ideas and released a product named System/R.
 1986 -- IBM developed the first prototype of relational database and standardized by ANSI. The first relational
database was released by Relational Software and its later becoming Oracle.

SQL Process:
When you are executing an SQL command for any RDBMS, the system determines the best way to carry out your
request and SQL engine figures out how to interpret the task.

There are various components included in the process. These components are Query Dispatcher, Optimization
Engines, Classic Query Engine and SQL Query Engine, etc. Classic query engine handles all non-SQL queries,
but SQL query engine won't handle logical files.

Following is a simple diagram showing SQL Architecture:

TUTORIALS POINT
Simply Easy Learning
SQL Commands:
The standard SQL commands to interact with relational databases are CREATE, SELECT, INSERT, UPDATE,
DELETE and DROP. These commands can be classified into groups based on their nature:

DDL - Data Definition Language:

Command Description

CREATE Creates a new table, a view of a table, or other object in database

ALTER Modifies an existing database object, such as a table.

DROP Deletes an entire table, a view of a table or other object in the database.

DML - Data Manipulation Language:

Command Description

INSERT Creates a record

UPDATE Modifies records

DELETE Deletes records

DCL - Data Control Language:

Command Description

GRANT Gives a privilege to user

REVOKE Takes back privileges granted from user

DQL - Data Query Language:

Command Description

SELECT Retrieves certain records from one or more tables

TUTORIALS POINT
Simply Easy Learning
2
CHAPTER

SQL RDBMS Concepts

What is RDBMS?

R DBMS stands for Relational Database Management System. RDBMS is the basis for SQL and for all

modern database systems like MS SQL Server, IBM DB2, Oracle, MySQL, and Microsoft Access.
A Relational database management system (RDBMS) is a database management system (DBMS) that is based on
the relational model as introduced by E. F. Codd.

What is table?
The data0 in RDBMS is stored in database objects called tables. The table is a collection of related data entries
and it consists of columns and rows.
Remember, a table is the most common and simplest form of data storage in a relational database. Following is
the example of a CUSTOMERS table:

+----+----------+-----+-----------+----------+

| ID | NAME | AGE | ADDRESS | SALARY |

+----+----------+-----+-----------+----------+

| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |

| 2 | Khilan | 25 | Delhi | 1500.00 |

| 3 | kaushik | 23 | Kota | 2000.00 |

| 4 | Chaitali | 25 | Mumbai | 6500.00 |

| 5 | Hardik | 27 | Bhopal | 8500.00 |

| 6 | Komal | 22 | MP | 4500.00 |

| 7 | Muffy | 24 | Indore | 10000.00 |

+----+----------+-----+-----------+----------+

TUTORIALS POINT
Simply Easy Learning
What is field?
Every table is broken up into smaller entities called fields. The fields in the CUSTOMERS table consist of ID,
NAME, AGE, ADDRESS and SALARY.

A field is a column in a table that is designed to maintain specific information about every record in the table.

What is record or row?

A record, also called a row of data, is each individual entry that exists in a table. For example, there are 7 records
in the above CUSTOMERS table. Following is a single row of data or record in the CUSTOMERS table:

+----+----------+-----+-----------+----------+

| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |

+----+----------+-----+-----------+----------+

A record is a horizontal entity in a table.

What is column?
A column is a vertical entity in a table that contains all information associated with a specific field in a table.

For example, a column in the CUSTOMERS table is ADDRESS, which represents location description and would
consist of the following:

+-----------+

| ADDRESS |

+-----------+

| Ahmedabad |

| Delhi |

| Kota |

| Mumbai |

| Bhopal |

| MP |

| Indore |

+----+------+

What is NULL value?

A NULL value in a table is a value in a field that appears to be blank, which means a field with a NULL value is a
field with no value.

It is very important to understand that a NULL value is different than a zero value or a field that contains spaces. A
field with a NULL value is one that has been left blank during record creation.

TUTORIALS POINT
Simply Easy Learning
SQL Constraints:
Constraints are the rules enforced on data columns on table. These are used to limit the type of data that can go
into a table. This ensures the accuracy and reliability of the data in the database.

Constraints could be column level or table level. Column level constraints are applied only to one column, whereas
table level constraints are applied to the whole table.

Following are commonly used constraints available in SQL:

 NOT NULL Constraint: Ensures that a column cannot have NULL value.
 DEFAULT Constraint: Provides a default value for a column when none is specified.
 UNIQUE Constraint: Ensures that all values in a column are different.
 PRIMARY Key: Uniquely identified each rows/records in a database table.
 FOREIGN Key: Uniquely identified a rows/records in any another database table.
 CHECK Constraint: The CHECK constraint ensures that all values in a column satisfy certain conditions.
 INDEX: Use to create and retrieve data from the database very quickly.

NOT NULL Constraint:

By default, a column can hold NULL values. If you do not want a column to have a NULL value, then you need to
define such constraint on this column specifying that NULL is now not allowed for that column.

A NULL is not the same as no data, rather, it represents unknown data.

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns, three of which,
ID and NAME and AGE, specify not to accept NULLs:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

If CUSTOMERS table has already been created, then to add a NOT NULL constraint to SALARY column in Oracle
and MySQL, you would write a statement similar to the following:

ALTER TABLE CUSTOMERS

MODIFY SALARY DECIMAL (18, 2) NOT NULL;

TUTORIALS POINT
Simply Easy Learning
DEFAULT Constraint:
The DEFAULT constraint provides a default value to a column when the INSERT INTO statement does not provide
a specific value.

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns. Here, SALARY
column is set to 5000.00 by default, so in case INSERT INTO statement does not provide a value for this column.
then by default this column would be set to 5000.00.

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2) DEFAULT 5000.00,

PRIMARY KEY (ID)

);

If CUSTOMERS table has already been created, then to add a DFAULT constraint to SALARY column, you would
write a statement similar to the following:

ALTER TABLE CUSTOMERS

MODIFY SALARY DECIMAL (18, 2) DEFAULT 5000.00;

Drop Default Constraint:

To drop a DEFAULT constraint, use the following SQL:

ALTER TABLE CUSTOMERS

ALTER COLUMN SALARY DROP DEFAULT;

UNIQUE Constraint:
The UNIQUE Constraint prevents two records from having identical values in a particular column. In the
CUSTOMERS table, for example, you might want to prevent two or more people from having identical age.

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns. Here, AGE
column is set to UNIQUE, so that you can not have two records with same age:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

TUTORIALS POINT
Simply Easy Learning
NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL UNIQUE,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

If CUSTOMERS table has already been created, then to add a UNIQUE constraint to AGE column, you would write
a statement similar to the following:

ALTER TABLE CUSTOMERS

MODIFY AGE INT NOT NULL UNIQUE;

You can also use following syntax, which supports naming the constraint in multiple columns as well:

ALTER TABLE CUSTOMERS

ADD CONSTRAINT myUniqueConstraint UNIQUE(AGE, SALARY);

DROP a UNIQUE Constraint:

To drop a UNIQUE constraint, use the following SQL:

ALTER TABLE CUSTOMERS

DROP CONSTRAINT myUniqueConstraint;

If you are using MySQL, then you can use the following syntax:

ALTER TABLE CUSTOMERS

DROP INDEX myUniqueConstraint;

PRIMARY Key:
A primary key is a field in a table which uniquely identifies each row/record in a database table. Primary keys must
contain unique values. A primary key column cannot have NULL values.

A table can have only one primary key, which may consist of single or multiple fields. When multiple fields are used
as a primary key, they are called a composite key.

If a table has a primary key defined on any field(s), then you can not have two records having the same value of
that field(s).

Note: You would use these concepts while creating database tables.

Create Primary Key:

Here is the syntax to define ID attribute as a primary key in a CUSTOMERS table.

TUTORIALS POINT
Simply Easy Learning
CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

To create a PRIMARY KEY constraint on the "ID" column when CUSTOMERS table already exists, use the
following SQL syntax:

ALTER TABLE CUSTOMER ADD PRIMARY KEY (ID);

NOTE: If you use the ALTER TABLE statement to add a primary key, the primary key column(s) must already have
been declared to not contain NULL values (when the table was first created).
For defining a PRIMARY KEY constraint on multiple columns, use the following SQL syntax:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID, NAME)

);

To create a PRIMARY KEY constraint on the "ID" and "NAMES" columns when CUSTOMERS table already exists,
use the following SQL syntax:

ALTER TABLE CUSTOMERS

ADD CONSTRAINT PK_CUSTID PRIMARY KEY (ID, NAME);

Delete Primary Key:

You can clear the primary key constraints from the table, Use Syntax:

ALTER TABLE CUSTOMERS DROP PRIMARY KEY ;

TUTORIALS POINT
Simply Easy Learning
FOREIGN Key:
A foreign key is a key used to link two tables together. This is sometimes called a referencing key.

Foreign Key is a column or a combination of columns whose values match a Primary Key in a different table.

The relationship between 2 tables matches the Primary Key in one of the tables with a Foreign Key in the
second table.
If a table has a primary key defined on any field(s), then you can not have two records having the same value of
that field(s).

Example:
Consider the structure of the two tables as follows:

CUSTOMERS table:
CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

ORDERS table:

CREATE TABLE ORDERS (

ID INT NOT NULL,

DATE DATETIME,

CUSTOMER_ID INT references CUSTOMERS(ID),

AMOUNT double,

PRIMARY KEY (ID)

);

If ORDERS table has already been created, and the foreign key has not yet been set, use the syntax for specifying
a foreign key by altering a table.

ALTER TABLE ORDERS

ADD FOREIGN KEY (Customer_ID) REFERENCES CUSTOMERS (ID);

TUTORIALS POINT
Simply Easy Learning
DROP a FOREIGN KEY Constraint:
To drop a FOREIGN KEY constraint, use the following SQL:

ALTER TABLE ORDERS

DROP FOREIGN KEY;

CHECK Constraint:
The CHECK Constraint enables a condition to check the value being entered into a record. If the condition
evaluates to false, the record violates the constraint and isn’t entered into the table.

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns. Here, we add a
CHECK with AGE column, so that you can not have any CUSTOMER below 18 years:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL CHECK (AGE >= 18),

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

If CUSTOMERS table has already been created, then to add a CHECK constraint to AGE column, you would write
a statement similar to the following:

ALTER TABLE CUSTOMERS

MODIFY AGE INT NOT NULL CHECK (AGE >= 18 );

You can also use following syntax, which supports naming the constraint in multiple columns as well:

ALTER TABLE CUSTOMERS

ADD CONSTRAINT myCheckConstraint CHECK(AGE >= 18);

DROP a CHECK Constraint:

To drop a CHECK constraint, use the following SQL. This syntax does not work with MySQL:

ALTER TABLE CUSTOMERS

DROP CONSTRAINT myCheckConstraint;

TUTORIALS POINT
Simply Easy Learning
INDEX:
The INDEX is used to create and retrieve data from the database very quickly. Index can be created by using
single or group of columns in a table. When index is created, it is assigned a ROWID for each row before it sorts
out the data.

Proper indexes are good for performance in large databases, but you need to be careful while creating index.
Selection of fields depends on what you are using in your SQL queries.

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

Now, you can create index on single or multiple columns using the following syntax:

CREATE INDEX index_name

ON table_name ( column1, column2.....);

To create an INDEX on AGE column, to optimize the search on customers for a particular age, following is the SQL
syntax:

CREATE INDEX idx_age

ON CUSTOMERS ( AGE );

DROP an INDEX Constraint:

To drop an INDEX constraint, use the following SQL:

ALTER TABLE CUSTOMERS

DROP INDEX idx_age;

Data Integrity:
The following categories of the data integrity exist with each RDBMS:

 Entity Integrity : There are no duplicate rows in a table.

TUTORIALS POINT
Simply Easy Learning
 Domain Integrity : Enforces valid entries for a given column by restricting the type, the format, or the
range of values.
 Referential Integrity : Rows cannot be deleted which are used by other records.

 User-Defined Integrity : Enforces some specific business rules that do not fall into entity, domain, or
referential integrity.

Database Normalization
Database normalization is the process of efficiently organizing data in a database. There are two reasons of the
normalization process:

 Eliminating redundant data, for example, storing the same data in more than one table.

 Ensuring data dependencies make sense.

Both of these are worthy goals as they reduce the amount of space a database consumes and ensure that data is
logically stored. Normalization consists of a series of guidelines that help guide you in creating a good database
structure.

Normalization guidelines are divided into normal forms; think of form as the format or the way a database structure
is laid out. The aim of normal forms is to organize the database structure so that it complies with the rules of first
normal form, then second normal form, and finally third normal form.

It's your choice to take it further and go to fourth normal form, fifth normal form, and so on, but generally speaking,
third normal form is enough.

 First Normal Form (1NF)

 Second Normal Form (2NF)

 Third Normal Form (3NF)

First Normal Form

First normal form (1NF) sets the very basic rules for an organized database:

 Define the data items required, because they become the columns in a table. Place related data items in a
table.

 Ensure that there are no repeating groups of data.

 Ensure that there is a primary key.

First Rule of 1NF:

You must define the data items. This means looking at the data to be stored, organizing the data into columns,
defining what type of data each column contains, and finally putting related columns into their own table.

For example, you put all the columns relating to locations of meetings in the Location table, those relating to
members in the MemberDetails table, and so on.

Second Rule of 1NF:

The next step is ensuring that there are no repeating groups of data. Consider we have the following table:

TUTORIALS POINT
Simply Easy Learning
CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25),

ORDERS VARCHAR(155)

);

So if we populate this table for a single customer having multiple orders, then it would be something as follows:

ID NAME AGE ADDRESS ORDERS

100 Sachin 36 Lower West Side Cannon XL-200

100 Sachin 36 Lower West Side Battery XL-200

100 Sachin 36 Lower West Side Tripod Large

But as per 1NF, we need to ensure that there are no repeating groups of data. So let us break above table into two
parts and join them using a key as follows:

CUSTOMERS table:
CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25),

PRIMARY KEY (ID)

);

This table would have the following record:

ID NAME AGE ADDRESS

100 Sachin 36 Lower West Side

ORDERS table:
CREATE TABLE ORDERS(

ID INT NOT NULL,

CUSTOMER_ID INT NOT NULL,

ORDERS VARCHAR(155),

TUTORIALS POINT
Simply Easy Learning
PRIMARY KEY (ID)

);

This table would have the following records:

ID CUSTOMER_ID ORDERS

10 100 Cannon XL-200

11 100 Battery XL-200

12 100 Tripod Large

Third Rule of 1NF:

The final rule of the first normal form, create a primary key for each table which we have already created.

Second Normal Form

Second normal form states that it should meet all the rules for 1NF and there must be no partial dependences of
any of the columns on the primary key:

Consider a customer-order relation and you want to store customer ID, customer name, order ID and order detail,
and date of purchase:

CREATE TABLE CUSTOMERS(

CUST_ID INT NOT NULL,

CUST_NAME VARCHAR (20) NOT NULL,

ORDER_ID INT NOT NULL,

ORDER_DETAIL VARCHAR (20) NOT NULL,

SALE_DATE DATETIME,

PRIMARY KEY (CUST_ID, ORDER_ID)

);

This table is in first normal form, in that it obeys all the rules of first normal form. In this table, the primary key
consists of CUST_ID and ORDER_ID. Combined, they are unique assuming same customer would hardly order
same thing.

However, the table is not in second normal form because there are partial dependencies of primary keys and
columns. CUST_NAME is dependent on CUST_ID, and there's no real link between a customer's name and what
he purchased. Order detail and purchase date are also dependent on ORDER_ID, but they are not dependent on
CUST_ID, because there's no link between a CUST_ID and an ORDER_DETAIL or their SALE_DATE.

To make this table comply with second normal form, you need to separate the columns into three tables.

First, create a table to store the customer details as follows:

TUTORIALS POINT
Simply Easy Learning
CREATE TABLE CUSTOMERS(

CUST_ID INT NOT NULL,

CUST_NAME VARCHAR (20) NOT NULL,

PRIMARY KEY (CUST_ID)

);

Next, create a table to store details of each order:

CREATE TABLE ORDERS(

ORDER_ID INT NOT NULL,

ORDER_DETAIL VARCHAR (20) NOT NULL,

PRIMARY KEY (ORDER_ID)

);

Finally, create a third table storing just CUST_ID and ORDER_ID to keep track of all the orders for a customer:

CREATE TABLE CUSTMERORDERS(

CUST_ID INT NOT NULL,

ORDER_ID INT NOT NULL,

SALE_DATE DATETIME,

PRIMARY KEY (CUST_ID, ORDER_ID)

);

Third Normal Form

A table is in third normal form when the following conditions are met:

 It is in second normal form.

 All nonprimary fields are dependent on the primary key.

The dependency of nonprimary fields is between the data. For example, in the below table, street name, city, and
state are unbreakably bound to the zip code.

CREATE TABLE CUSTOMERS(

CUST_ID INT NOT NULL,

CUST_NAME VARCHAR (20) NOT NULL,

DOB DATE,

STREET VARCHAR(200),

TUTORIALS POINT
Simply Easy Learning
CITY VARCHAR(100),

STATE VARCHAR(100),

ZIP VARCHAR(12),

EMAIL_ID VARCHAR(256),

PRIMARY KEY (CUST_ID)

);

The dependency between zip code and address is called a transitive dependency. To comply with third normal
form, all you need to do is move the Street, City, and State fields into their own table, which you can call the Zip
Code table:

CREATE TABLE ADDRESS(

ZIP VARCHAR(12),

STREET VARCHAR(200),

CITY VARCHAR(100),

STATE VARCHAR(100),

PRIMARY KEY (ZIP)

);

Next, alter the CUSTOMERS table as follows:

CREATE TABLE CUSTOMERS(

CUST_ID INT NOT NULL,

CUST_NAME VARCHAR (20) NOT NULL,

DOB DATE,

ZIP VARCHAR(12),

EMAIL_ID VARCHAR(256),

PRIMARY KEY (CUST_ID)

);

The advantages of removing transitive dependencies are mainly twofold. First, the amount of data duplication is
reduced and therefore your database becomes smaller.

The second advantage is data integrity. When duplicated data changes, there's a big risk of updating only some of
the data, especially if it's spread out in a number of different places in the database. For example, if address and
zip code data were stored in three or four different tables, then any changes in zip codes would need to ripple out
to every record in those three or four tables.

TUTORIALS POINT
Simply Easy Learning
4
CHAPTER

SQL Syntax

S QL is followed by unique set of rules and guidelines called Syntax. This tutorial gives you a quick start with

SQL by listing all the basic SQL Syntax:

All the SQL statements start with any of the keywords like SELECT, INSERT, UPDATE, DELETE, ALTER, DROP,
CREATE, USE, SHOW and all the statements end with a semicolon (;).

Important point to be noted is that SQL is case insensitive, which means SELECT and select have same meaning
in SQL statements, but MySQL makes difference in table names. So if you are working with MySQL, then you
need to give table names as they exist in the database.

SQL SELECT Statement:

SELECT column1, column2....columnN
FROM table_name;

SQL DISTINCT Clause:

SELECT DISTINCT column1, column2....columnN
FROM table_name;

SQL WHERE Clause:

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION;

SQL AND/OR Clause:

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION-1 {AND|OR} CONDITION-2;

TUTORIALS POINT
Simply Easy Learning
SQL IN Clause:
SELECT column1, column2....columnN
FROM table_name
WHERE column_name IN (val-1, val-2,...val-N);

SQL BETWEEN Clause:

SELECT column1, column2....columnN
FROM table_name
WHERE column_name BETWEEN val-1 AND val-2;

SQL LIKE Clause:

SELECT column1, column2....columnN
FROM table_name
WHERE column_name LIKE { PATTERN };

SQL ORDER BY Clause:

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION
ORDER BY column_name {ASC|DESC};

SQL GROUP BY Clause:

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name;

SQL COUNT Clause:

SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;

SQL HAVING Clause:

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

SQL CREATE TABLE Statement:

CREATE TABLE table_name(

TUTORIALS POINT
Simply Easy Learning
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);

SQL DROP TABLE Statement:

DROP TABLE table_name;

SQL CREATE INDEX Statement:

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

SQL DROP INDEX Statement:

ALTER TABLE table_name
DROP INDEX index_name;

SQL DESC Statement:

DESC table_name;

SQL TRUNCATE TABLE Statement:

TRUNCATE TABLE table_name;

SQL ALTER TABLE Statement:

ALTER TABLE table_name {ADD|DROP|MODIFY} column_name {data_ype};

SQL ALTER TABLE Statement (Rename):

ALTER TABLE table_name RENAME TO new_table_name;

SQL INSERT INTO Statement:

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

SQL UPDATE Statement:

UPDATE table_name

TUTORIALS POINT
Simply Easy Learning
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE CONDITION ];

SQL DELETE Statement:

DELETE FROM table_name
WHERE {CONDITION};

SQL CREATE DATABASE Statement:

CREATE DATABASE database_name;

SQL DROP DATABASE Statement:

DROP DATABASE database_name;

SQL USE Statement:

USE DATABASE database_name;

SQL COMMIT Statement:

COMMIT;

SQL ROLLBACK Statement:

ROLLBACK;

TUTORIALS POINT
Simply Easy Learning
5
CHAPTER

SQL Data Types

S QL data type is an attribute that specifies type of data of any object. Each column, variable and expression

has related data type in SQL.

You would use these data types while creating your tables. You would choose a particular data type for a table
column based on your requirement.

SQL Server offers six categories of data types for your use:

Exact Numeric Data Types:

DATA TYPE FROM TO

Bigint -9,223,372,036,854,775,808 9,223,372,036,854,775,807

Int -2,147,483,648 2,147,483,647

Smallint -32,768 32,767

Tinyint 0 255

Bit 0 1

Decimal -10^38 +1 10^38 -1

Numeric -10^38 +1 10^38 -1

Money -922,337,203,685,477.5808 +922,337,203,685,477.5807

Smallmoney -214,748.3648 +214,748.3647

Approximate Numeric Data Types:

DATA TYPE FROM TO

Float -1.79E + 308 1.79E + 308

Real -3.40E + 38 3.40E + 38

TUTORIALS POINT
Simply Easy Learning
Date and Time Data Types:
DATA TYPE FROM TO

Datetime Jan 1, 1753 Dec 31, 9999

Smalldatetime Jan 1, 1900 Jun 6, 2079

Date Stores a date like June 30, 1991

Time Stores a time of day like 12:30 P.M.

Note: Here, datetime has 3.33 milliseconds accuracy where as smalldatetime has 1 minute accuracy.

Character Strings Data Types:

DATA TYPE FROM TO

Maximum length of 8,000 characters.( Fixed length non-Unicode

Char Char
characters)

Varchar Varchar Maximum of 8,000 characters.(Variable-length non-Unicode data).

Maximum length of 231characters, Variable-length non-Unicode data

varchar(max) varchar(max)
(SQL Server 2005 only).

Variable-length non-Unicode data with a maximum length of

Text text
2,147,483,647 characters.

Unicode Character Strings Data Types:

DATA TYPE Description

Nchar Maximum length of 4,000 characters.( Fixed length Unicode)

Nvarchar Maximum length of 4,000 characters.(Variable length Unicode)

Maximum length of 231characters (SQL Server 2005 only).( Variable length

nvarchar(max)
Unicode)

Ntext Maximum length of 1,073,741,823 characters. ( Variable length Unicode )

Binary Data Types:

DATA TYPE Description

Binary Maximum length of 8,000 bytes(Fixed-length binary data )

Varbinary Maximum length of 8,000 bytes.(Variable length binary data)

TUTORIALS POINT
Simply Easy Learning
Maximum length of 231 bytes (SQL Server 2005 only). ( Variable length Binary
varbinary(max)
data)

Image Maximum length of 2,147,483,647 bytes. ( Variable length Binary Data)

Misc Data Types:

DATA TYPE Description

Stores values of various SQL Server-supported data types, except text, ntext, and
sql_variant
timestamp.

Stores a database-wide unique number that gets updated every time a row gets
timestamp
updated

uniqueidentifier Stores a globally unique identifier (GUID)

Stores XML data. You can store xml instances in a column or a variable (SQL Server
xml
2005 only).

cursor Reference to a cursor object

table Stores a result set for later processing

TUTORIALS POINT
Simply Easy Learning
6
CHAPTER

SQL Operators
What is an Operator in SQL?

A n operator is a reserved word or a character used primarily in an SQL statement's WHERE clause to

perform operation(s), such as comparisons and arithmetic operations.

Operators are used to specify conditions in an SQL statement and to serve as conjunctions for multiple conditions
in a statement.

 Arithmetic operators

 Comparison operators

 Logical operators

 Operators used to negate conditions

SQL Arithmetic Operators:

Assume variable a holds 10 and variable b holds 20, then:

Operator Description Example

a + b will
+ Addition - Adds values on either side of the operator
give 30

a - b will
- Subtraction - Subtracts right hand operand from left hand operand
give -10

a * b will
* Multiplication - Multiplies values on either side of the operator
give 200

b / a will
/ Division - Divides left hand operand by right hand operand
give 2

b % a will
% Modulus - Divides left hand operand by right hand operand and returns remainder
give 0

TUTORIALS POINT
Simply Easy Learning
Here are simple examples showing usage of SQL Arithmetic Operators:

SQL> select 10+ 20;

+--------+
| 10+ 20 |
+--------+
| 30 |
+--------+
1 row in set (0.00 sec)

SQL> select 10 * 20;

+---------+
| 10 * 20 |
+---------+
| 200 |
+---------+
1 row in set (0.00 sec)

SQL> select 10 / 5;
+--------+
| 10 / 5 |
+--------+
| 2.0000 |
+--------+
1 row in set (0.03 sec)

SQL> select 12 % 5;
+---------+
| 12 % 5 |
+---------+
| 2 |
+---------+
1 row in set (0.00 sec)

SQL Comparison Operators:

Assume variable a holds 10 and variable b holds 20, then:

Operator Description Example

(a = b) is
= Checks if the values of two operands are equal or not, if yes then condition becomes true.
not true.

Checks if the values of two operands are equal or not, if values are not equal then (a != b)
!=
condition becomes true. is true.

Checks if the values of two operands are equal or not, if values are not equal then (a <> b)
<>
condition becomes true. is true.

Checks if the value of left operand is greater than the value of right operand, if yes then (a > b) is
>
condition becomes true. not true.

Checks if the value of left operand is less than the value of right operand, if yes then (a < b) is
<
condition becomes true. true.

(a >= b)
Checks if the value of left operand is greater than or equal to the value of right operand, if
>= is not
yes then condition becomes true.
true.

TUTORIALS POINT
Simply Easy Learning
Checks if the value of left operand is less than or equal to the value of right operand, if (a <= b)
<=
yes then condition becomes true. is true.

Checks if the value of left operand is not less than the value of right operand, if yes then (a !< b)
!<
condition becomes true. is false.

Checks if the value of left operand is not greater than the value of right operand, if yes (a !> b)
!>
then condition becomes true. is true.

Consider the CUSTOMERS table having the following records:

SQL> SELECT * FROM CUSTOMERS;

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)

Here are simple examples showing usage of SQL Comparison Operators:

SQL> SELECT * FROM CUSTOMERS WHERE SALARY > 5000;

+----+----------+-----+---------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+
3 rows in set (0.00 sec)

SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 2000;

+----+---------+-----+-----------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+---------+-----+-----------+---------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+---------+-----+-----------+---------+
2 rows in set (0.00 sec)

SQL> SELECT * FROM CUSTOMERS WHERE SALARY != 2000;

+----+----------+-----+---------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+
5 rows in set (0.00 sec)

SQL> SELECT * FROM CUSTOMERS WHERE SALARY <> 2000;

+----+----------+-----+---------+----------+

TUTORIALS POINT
Simply Easy Learning
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+
5 rows in set (0.00 sec)

SQL> SELECT * FROM CUSTOMERS WHERE SALARY >= 6500;

SQL Logical Operators:

Here is a list of all the logical operators available in SQL.

Operator Description

ALL The ALL operator is used to compare a value to all values in another value set.

AND The AND operator allows the existence of multiple conditions in an SQL statement's WHERE clause.

The ANY operator is used to compare a value to any applicable value in the list according to the
ANY
condition.

The BETWEEN operator is used to search for values that are within a set of values, given the
BETWEEN
minimum value and the maximum value.

The EXISTS operator is used to search for the presence of a row in a specified table that meets
EXISTS
certain criteria.

IN The IN operator is used to compare a value to a list of literal values that have been specified.

LIKE The LIKE operator is used to compare a value to similar values using wildcard operators.

The NOT operator reverses the meaning of the logical operator with which it is used. Eg: NOT
NOT
EXISTS, NOT BETWEEN, NOT IN, etc. This is a negate operator.

OR The OR operator is used to combine multiple conditions in an SQL statement's WHERE clause.

IS NULL The NULL operator is used to compare a value with a NULL value.

UNIQUE The UNIQUE operator searches every row of a specified table for uniqueness (no duplicates).

Consider the CUSTOMERS table having the following records:

SQL> SELECT * FROM CUSTOMERS;

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+

TUTORIALS POINT
Simply Easy Learning
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)

Here are simple examples showing usage of SQL Comparison Operators:

SQL> SELECT * FROM CUSTOMERS WHERE AGE >= 25 AND SALARY >= 6500;
+----+----------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+---------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+---------+---------+
2 rows in set (0.00 sec)

SQL> SELECT * FROM CUSTOMERS WHERE AGE >= 25 OR SALARY >= 6500;
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
5 rows in set (0.00 sec)

SQL> SELECT * FROM CUSTOMERS WHERE AGE IS NOT NULL;

SQL> SELECT * FROM CUSTOMERS WHERE NAME LIKE 'Ko%';

+----+-------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+-------+-----+---------+---------+
| 6 | Komal | 22 | MP | 4500.00 |
+----+-------+-----+---------+---------+
1 row in set (0.00 sec)

SQL> SELECT * FROM CUSTOMERS WHERE AGE IN ( 25, 27 );

+----+----------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+---------+

TUTORIALS POINT
Simply Easy Learning
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+---------+---------+
3 rows in set (0.00 sec)

SQL> SELECT * FROM CUSTOMERS WHERE AGE BETWEEN 25 AND 27;

+----+----------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+---------+---------+
3 rows in set (0.00 sec)

SQL> SELECT AGE FROM CUSTOMERS

WHERE EXISTS (SELECT AGE FROM CUSTOMERS WHERE SALARY > 6500);
+-----+
| AGE |
+-----+
| 32 |
| 25 |
| 23 |
| 25 |
| 27 |
| 22 |
| 24 |
+-----+
7 rows in set (0.02 sec)

SQL> SELECT * FROM CUSTOMERS

WHERE AGE > ALL (SELECT AGE FROM CUSTOMERS WHERE SALARY > 6500);
+----+--------+-----+-----------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+--------+-----+-----------+---------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
+----+--------+-----+-----------+---------+
1 row in set (0.02 sec)

SQL> SELECT * FROM CUSTOMERS

WHERE AGE > ANY (SELECT AGE FROM CUSTOMERS WHERE SALARY > 6500);
+----+----------+-----+-----------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+---------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+-----------+---------+
4 rows in set (0.00 sec)

TUTORIALS POINT
Simply Easy Learning
8
CHAPTER

SQL CREATE Database

T he SQL CREATE DATABASE statement is used to create new SQL database.

Syntax:
Basic syntax of CREATE DATABASE statement is as follows:

CREATE DATABASE DatabaseName;

Always database name should be unique within the RDBMS.

Example:
If you want to create new database <testDB>, then CREATE DATABASE statement would be as follows:

SQL> CREATE DATABASE testDB;

Make sure you have admin privilege before creating any database. Once a database is created, you can check it in
the list of databases as follows:

SQL> SHOW DATABASES;

TUTORIALS POINT
Simply Easy Learning
9
CHAPTER

DROP or DELETE Database

T he SQL DROP DATABASE statement is used to drop an existing database in SQL schema.

Syntax:
Basic syntax of DROP DATABASE statement is as follows:

DROP DATABASE DatabaseName;

Always database name should be unique within the RDBMS.

Example:
If you want to delete an existing database <testDB>, then DROP DATABASE statement would be as follows:

SQL> DROP DATABASE testDB;

NOTE: Be careful before using this operation because by deleting an existing database would result in loss of
complete information stored in the database.
Make sure you have admin privilege before dropping any database. Once a database is dropped, you can check it.

SQL> in the list of databases as follows:SHOW DATABASES;

TUTORIALS POINT
Simply Easy Learning
CHAPTER

10
SQL SELECT Database

W hen you have multiple databases in your SQL Schema, then before starting your operation, you

would need to select a database where all the operations would be performed.

The SQL USE statement is used to select any existing database in SQL schema.

Syntax:
Basic syntax of USE statement is as follows:

USE DatabaseName;

Always database name should be unique within the RDBMS.

Example:
You can check available databases as follows:

SQL> SHOW DATABASES;

Now, if you want to work with AMROOD database, then you can execute the following SQL command and start
working with AMROOD database:

SQL> USE AMROOD;

TUTORIALS POINT
Simply Easy Learning
CHAPTER

11
SQL CREATE Table

C reating a basic table involves naming the table and defining its columns and each column's data type.

The SQL CREATE TABLE statement is used to create a new table.

Syntax:
Basic syntax of CREATE TABLE statement is as follows:

CREATE TABLE table_name(

column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);

CREATE TABLE is the keyword telling the database system what you want to do. In this case, you want to create
a new table. The unique name or identifier for the table follows the CREATE TABLE statement.

Then in brackets comes the list defining each column in the table and what sort of data type it is. The syntax
becomes clearer with an example below.

A copy of an existing table can be created using a combination of the CREATE TABLE statement and the SELECT
statement. You can check complete details at Create Table Using another Table.

Create Table Using another Table

A copy of an existing table can be created using a combination of the CREATE TABLE statement and the SELECT
statement.

The new table has the same column definitions. All columns or specific columns can be selected.

When you create a new table using existing table, new table would be populated using existing values in the old
table.

Syntax:
The basic syntax for creating a table from another table is as follows:

TUTORIALS POINT
Simply Easy Learning
CREATE TABLE NEW_TABLE_NAME AS
SELECT [ column1, column2...columnN ]
FROM EXISTING_TABLE_NAME
[ WHERE ]

Here, column1, column2...are the fields of existing table and same would be used to create fields of new table.

Example:
Following is an example, which would create a table SALARY using CUSTOMERS table and having fields
customer ID and customer SALARY:

SQL> CREATE TABLE SALARY AS

SELECT ID, SALARY
FROM CUSTOMERS;

This would create new table SALARY, which would have the following records:

+----+----------+
| ID | SALARY |
+----+----------+
| 1 | 2000.00 |
| 2 | 1500.00 |
| 3 | 2000.00 |
| 4 | 6500.00 |
| 5 | 8500.00 |
| 6 | 4500.00 |
| 7 | 10000.00 |
+----+----------+

Example:
Following is an example, which creates a CUSTOMERS table with ID as primary key and NOT NULL are the
constraints showing that these fileds can not be NULL while creating records in this table:

SQL> CREATE TABLE CUSTOMERS(

ID INT NOT NULL,
NAME VARCHAR (20) NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR (25) ,
SALARY DECIMAL (18, 2),
PRIMARY KEY (ID)
);

You can verify if your table has been created successfully by looking at the message displayed by the SQL server,
otherwise you can use DESC command as follows:

SQL> DESC CUSTOMERS;

+---------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID | int(11) | NO | PRI | | |
| NAME | varchar(20) | NO | | | |
| AGE | int(11) | NO | | | |
| ADDRESS | char(25) | YES | | NULL | |
| SALARY | decimal(18,2) | YES | | NULL | |
+---------+---------------+------+-----+---------+-------+

TUTORIALS POINT
Simply Easy Learning
5 rows in set (0.00 sec)

Now, you have CUSTOMERS table available in your database which you can use to store required information
related to customers.

TUTORIALS POINT
Simply Easy Learning
CHAPTER

12
SQL DROP or DELETE Table

T he SQL DROP TABLE statement is used to remove a table definition and all data, indexes, triggers,

constraints, and permission specifications for that table.

NOTE: You have to be careful while using this command because once a table is deleted then all the information
available in the table would also be lost forever.

Syntax:
Basic syntax of DROP TABLE statement is as follows:

DROP TABLE table_name;

Example:
Let us first verify CUSTOMERS table and then we would delete it from the database:

SQL> DESC CUSTOMERS;

This means CUSTOMERS table is available in the database, so let us drop it as follows:

SQL> DROP TABLE CUSTOMERS;

Query OK, 0 rows affected (0.01 sec)

Now, if you would try DESC command, then you would get error as follows:

SQL> DESC CUSTOMERS;

ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist

Here, TEST is database name which we are using for our examples.

TUTORIALS POINT
Simply Easy Learning
CHAPTER

13
SQL INSERT Query

T he SQL INSERT INTO Statement is used to add new rows of data to a table in the database.

Syntax:
There are two basic syntaxes of INSERT INTO statement as follows:

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)]

VALUES (value1, value2, value3,...valueN);

Here, column1, column2,...columnN are the names of the columns in the table into which you want to insert data.
You may not need to specify the column(s) name in the SQL query if you are adding values for all the columns of
the table. But make sure the order of the values is in the same order as the columns in the table. The SQL INSERT
INTO syntax would be as follows:

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Example:
Following statements would create six records in CUSTOMERS table:

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (6, 'Komal', 22, 'MP', 4500.00 );

You can create a record in CUSTOMERS table using second syntax as follows:

TUTORIALS POINT
Simply Easy Learning
INSERT INTO CUSTOMERS
VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );

All the above statements would produce the following records in CUSTOMERS table:

Populate one table using another table:

You can populate data into a table through select statement over another table provided another table has a set of
fields, which are required to populate first table. Here is the syntax:

INSERT INTO first_table_name [(column1, column2, ... columnN)]

SELECT column1, column2, ...columnN
FROM second_table_name
[WHERE condition];

TUTORIALS POINT
Simply Easy Learning
CHAPTER

14
SQL SELECT Query

S QL SELECT Statement is used to fetch the data from a database table which returns data in the form of

result table. These result tables are called result-sets.

Syntax:
The basic syntax of SELECT statement is as follows:

SELECT column1, column2, columnN FROM table_name;

Here, column1, column2...are the fields of a table whose values you want to fetch. If you want to fetch all the fields
available in the field, then you can use the following syntax:

SELECT * FROM table_name;

Example:
Consider the CUSTOMERS table having the following records:

Following is an example, which would fetch ID, Name and Salary fields of the customers available in
CUSTOMERS table:

SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;

This would produce the following result:

+----+----------+----------+
| ID | NAME | SALARY |

TUTORIALS POINT
Simply Easy Learning
+----+----------+----------+
| 1 | Ramesh | 2000.00 |
| 2 | Khilan | 1500.00 |
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+

If you want to fetch all the fields of CUSTOMERS table, then use the following query:

SQL> SELECT * FROM CUSTOMERS;

This would produce the following result:

TUTORIALS POINT
Simply Easy Learning
CHAPTER

15
SQL WHERE Clause

T he SQL WHERE clause is used to specify a condition while fetching the data from single table or joining

with multiple tables.

If the given condition is satisfied, then only it returns specific value from the table. You would use WHERE clause
to filter the records and fetching only necessary records.

The WHERE clause is not only used in SELECT statement, but it is also used in UPDATE, DELETE statement,
etc., which we would examine in subsequent chapters.

Syntax:
The basic syntax of SELECT statement with WHERE clause is as follows:

SELECT column1, column2, columnN

FROM table_name
WHERE [condition]

You can specify a condition using comparison or logical operators like >, <, =, LIKE, NOT etc. Below examples
would make this concept clear.

Example:
Consider the CUSTOMERS table having the following records:

Following is an example, which would fetch ID, Name and Salary fields from the CUSTOMERS table where salary
is greater than 2000:

TUTORIALS POINT
Simply Easy Learning
SQL> SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000;

This would produce the following result:

+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+

Following is an example, which would fetch ID, Name and Salary fields from the CUSTOMERS table for a
customer with name Hardik. Here, it is important to note that all the strings should be given inside single quotes ('')
where as numeric values should be given without any quote as in above example:

SQL> SELECT ID, NAME, SALARY

FROM CUSTOMERS
WHERE NAME = 'Hardik';

This would produce the following result:

+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 5 | Hardik | 8500.00 |
+----+----------+----------+

TUTORIALS POINT
Simply Easy Learning
CHAPTER

16
SQL AND and OR Operators

T he SQL AND and OR operators are used to combine multiple conditions to narrow data in an SQL

statement. These two operators are called conjunctive operators.

These operators provide a means to make multiple comparisons with different operators in the same SQL
statement.

The AND Operator:

The AND operator allows the existence of multiple conditions in an SQL statement's WHERE clause.

Syntax:
The basic syntax of AND operator with WHERE clause is as follows:

SELECT column1, column2, columnN

FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

You can combine N number of conditions using AND operator. For an action to be taken by the SQL statement,
whether it be a transaction or query, all conditions separated by the AND must be TRUE.

Example:
Consider the CUSTOMERS table having the following records:

Following is an example, which would fetch ID, Name and Salary fields from the CUSTOMERS table where salary
is greater than 2000 AND age is less tan 25 years:

TUTORIALS POINT
Simply Easy Learning
SQL> SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;

This would produce the following result:

+----+-------+----------+
| ID | NAME | SALARY |
+----+-------+----------+
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+-------+----------+

The OR Operator:
The OR operator is used to combine multiple conditions in an SQL statement's WHERE clause.

Syntax:
The basic syntax of OR operator with WHERE clause is as follows:

SELECT column1, column2, columnN

FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

You can combine N number of conditions using OR operator. For an action to be taken by the SQL statement,
whether it be a transaction or query, only any ONE of the conditions separated by the OR must be TRUE.

Example:
Consider the CUSTOMERS table having the following records:

Following is an example, which would fetch ID, Name and Salary fields from the CUSTOMERS table where salary
is greater than 2000 OR age is less tan 25 years:

SQL> SELECT ID, NAME, SALARY

FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;

This would produce the following result:

+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |

TUTORIALS POINT
Simply Easy Learning
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+

TUTORIALS POINT
Simply Easy Learning
CHAPTER

17
SQL UPDATE Query

T he SQL UPDATE Query is used to modify the existing records in a table.

You can use WHERE clause with UPDATE query to update selected rows, otherwise all the rows would be
affected.

Syntax:
The basic syntax of UPDATE query with WHERE clause is as follows:

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

You can combine N number of conditions using AND or OR operators.

Example:
Consider the CUSTOMERS table having the following records:

Following is an example, which would update ADDRESS for a customer whose ID is 6:

SQL> UPDATE CUSTOMERS

SET ADDRESS = 'Pune'
WHERE ID = 6;

Now, CUSTOMERS table would have the following records:

TUTORIALS POINT
Simply Easy Learning
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | Pune | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

If you want to modify all ADDRESS and SALARY column values in CUSTOMERS table, you do not need to use
WHERE clause and UPDATE query would be as follows:

SQL> UPDATE CUSTOMERS

SET ADDRESS = 'Pune', SALARY = 1000.00;

Now, CUSTOMERS table would have the following records:

+----+----------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+---------+
| 1 | Ramesh | 32 | Pune | 1000.00 |
| 2 | Khilan | 25 | Pune | 1000.00 |
| 3 | kaushik | 23 | Pune | 1000.00 |
| 4 | Chaitali | 25 | Pune | 1000.00 |
| 5 | Hardik | 27 | Pune | 1000.00 |
| 6 | Komal | 22 | Pune | 1000.00 |
| 7 | Muffy | 24 | Pune | 1000.00 |
+----+----------+-----+---------+---------+

TUTORIALS POINT
Simply Easy Learning
CHAPTER

18
SQL DELETE Query

T he SQL DELETE Query is used to delete the existing records from a table.

You can use WHERE clause with DELETE query to delete selected rows, otherwise all the records would be
deleted.

Syntax:
The basic syntax of DELETE query with WHERE clause is as follows:

DELETE FROM table_name

WHERE [condition];

You can combine N number of conditions using AND or OR operators.

Example:
Consider the CUSTOMERS table having the following records:

Following is an example, which would DELETE a customer, whose ID is 6:

SQL> DELETE FROM CUSTOMERS

WHERE ID = 6;

Now, CUSTOMERS table would have the following records:

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |

TUTORIALS POINT
Simply Easy Learning
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

If you want to DELETE all the records from CUSTOMERS table, you do not need to use WHERE clause and
DELETE query would be as follows:

SQL> DELETE FROM CUSTOMERS;

Now, CUSTOMERS table would not have any record.

TUTORIALS POINT
Simply Easy Learning
CHAPTER

19
SQL LIKE Clause

T he SQL LIKE clause is used to compare a value to similar values using wildcard operators. There are two

wildcards used in conjunction with the LIKE operator:

 The percent sign (%)

 The underscore (_)

The percent sign represents zero, one, or multiple characters. The underscore represents a single number or
character. The symbols can be used in combinations.

Syntax:
The basic syntax of % and _ is as follows:

SELECT FROM table_name

WHERE column LIKE 'XXXX%'

SELECT FROM table_name

WHERE column LIKE '%XXXX%'

SELECT FROM table_name

WHERE column LIKE 'XXXX_'

SELECT FROM table_name

WHERE column LIKE '_XXXX'

SELECT FROM table_name

WHERE column LIKE '_XXXX_'

You can combine N number of conditions using AND or OR operators. Here, XXXX could be any numeric or string
value.

TUTORIALS POINT
Simply Easy Learning
Example:
Here are number of examples showing WHERE part having different LIKE clause with '%' and '_' operators:

Statement Description

WHERE SALARY LIKE '200%' Finds any values that start with 200

WHERE SALARY LIKE

Finds any values that have 200 in any position
'%200%'

WHERE SALARY LIKE '_00%' Finds any values that have 00 in the second and third positions

WHERE SALARY LIKE

Finds any values that start with 2 and are at least 3 characters in length
'2_%_%'

WHERE SALARY LIKE '%2' Finds any values that end with 2

WHERE SALARY LIKE '_2%3' Finds any values that have a 2 in the second position and end with a 3

WHERE SALARY LIKE '2___3' Finds any values in a five-digit number that start with 2 and end with 3

Let us take a real example, consider the CUSTOMERS table having the following records:

Following is an example, which would display all the records from CUSTOMERS table where SALARY starts with
200:

SQL> SELECT * FROM CUSTOMERS

WHERE SALARY LIKE '200%';

This would produce the following result:

TUTORIALS POINT
Simply Easy Learning
CHAPTER

21
SQL ORDER BY Clause

T he SQL ORDER BY clause is used to sort the data in ascending or descending order, based on one or

more columns. Some database sorts query results in ascending order by default.

Syntax:
The basic syntax of ORDER BY clause is as follows:

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

You can use more than one column in the ORDER BY clause. Make sure whatever column you are using to sort,
that column should be in column-list.

Example:
Consider the CUSTOMERS table having the following records:

Following is an example, which would sort the result in ascending order by NAME and SALARY:

SQL> SELECT * FROM CUSTOMERS

ORDER BY NAME, SALARY;

This would produce the following result:

+----+----------+-----+-----------+----------+

TUTORIALS POINT
Simply Easy Learning
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
+----+----------+-----+-----------+----------+

Following is an example, which would sort the result in descending order by NAME:

SQL> SELECT * FROM CUSTOMERS

ORDER BY NAME DESC;

This would produce the following result:

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+-----+-----------+----------+

TUTORIALS POINT
Simply Easy Learning
CHAPTER

22
SQL Group By

T he SQL GROUP BY clause is used in collaboration with the SELECT statement to arrange identical data

into groups.
The GROUP BY clause follows the WHERE clause in a SELECT statement and precedes the ORDER BY clause.

Syntax:
The basic syntax of GROUP BY clause is given below. The GROUP BY clause must follow the conditions in the
WHERE clause and must precede the ORDER BY clause if one is used.

SELECT column1, column2

FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2

Example:
Consider the CUSTOMERS table having the following records:

If you want to know the total amount of salary on each customer, then GROUP BY query would be as follows:

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS

GROUP BY NAME;

This would produce the following result:

TUTORIALS POINT
Simply Easy Learning
+----------+-------------+
| NAME | SUM(SALARY) |
+----------+-------------+
| Chaitali | 6500.00 |
| Hardik | 8500.00 |
| kaushik | 2000.00 |
| Khilan | 1500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 2000.00 |
+----------+-------------+

Now, let us have following table where CUSTOMERS table has the following records with duplicate names:

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Ramesh | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Now again, if you want to know the total amount of salary on each customer, then GROUP BY query would be as
follows:

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS

GROUP BY NAME;

This would produce the following result:

+---------+-------------+
| NAME | SUM(SALARY) |
+---------+-------------+
| Hardik | 8500.00 |
| kaushik | 8500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 3500.00 |
+---------+-------------+

TUTORIALS POINT
Simply Easy Learning
CHAPTER

23
SQL Distinct Keyword

T he SQL DISTINCT keyword is used in conjunction with SELECT statement to eliminate all the duplicate

records and fetching only unique records.

There may be a situation when you have multiple duplicate records in a table. While fetching such records, it
makes more sense to fetch only unique records instead of fetching duplicate records.

Syntax:
The basic syntax of DISTINCT keyword to eliminate duplicate records is as follows:

SELECT DISTINCT column1, column2,.....columnN

FROM table_name
WHERE [condition]

Example:
Consider the CUSTOMERS table having the following records:

First, let us see how the following SELECT query returns duplicate salary records:

SQL> SELECT SALARY FROM CUSTOMERS

ORDER BY SALARY;

This would produce the following result where salary 2000 is coming twice which is a duplicate record from the
original table.

TUTORIALS POINT
Simply Easy Learning
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+

Now, let us use DISTINCT keyword with the above SELECT query and see the result:

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS

ORDER BY SALARY;

This would produce the following result where we do not have any duplicate entry:

+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+

TUTORIALS POINT
Simply Easy Learning
CHAPTER

25
SQL Constraints

C onstraints are the rules enforced on data columns on table. These are used to limit the type of data that

can go into a table. This ensures the accuracy and reliability of the data in the database.

Contraints could be column level or table level. Column level constraints are applied only to one column where as
table level constraints are applied to the whole table.

Following are commonly used constraints available in SQL. These constraints have already been discussed
in SQL - RDBMS Concepts chapter but its worth to revise them at this point.

Following are commonly used constraints available in SQL:

 NOT NULL Constraint: Ensures that a column cannot have NULL value.
 DEFAULT Constraint: Provides a default value for a column when none is specified.
 UNIQUE Constraint: Ensures that all values in a column are different.
 PRIMARY Key: Uniquely identified each rows/records in a database table.
 FOREIGN Key: Uniquely identified a row/record in any other database table.
 CHECK Constraint: The CHECK constraint ensures that all values in a column satisfy certain conditions.
 INDEX: Use to create and retrieve data from the database very quickly.

NOT NULL Constraint:

A NULL is not the same as no data, rather, it represents unknown data.

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns, three of which,
ID and NAME and AGE, specify not to accept NULLs:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

TUTORIALS POINT
Simply Easy Learning
ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

If CUSTOMERS table has already been created, then to add a NOT NULL constraint to SALARY column in Oracle
and MySQL, you would write a statement similar to the following:

ALTER TABLE CUSTOMERS

MODIFY SALARY DECIMAL (18, 2) NOT NULL;

DEFAULT Constraint:
The DEFAULT constraint provides a default value to a column when the INSERT INTO statement does not provide
a specific value.

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns. Here, SALARY
column is set to 5000.00 by default, so in case INSERT INTO statement does not provide a value for this column,
then by default this column would be set to 5000.00.

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2) DEFAULT 5000.00,

PRIMARY KEY (ID)

);

If CUSTOMERS table has already been created, then to add a DFAULT constraint to SALARY column, you would
write a statement similar to the following:

ALTER TABLE CUSTOMERS

MODIFY SALARY DECIMAL (18, 2) DEFAULT 5000.00;

Drop Default Constraint:

To drop a DEFAULT constraint, use the following SQL:

ALTER TABLE CUSTOMERS

ALTER COLUMN SALARY DROP DEFAULT;

TUTORIALS POINT
Simply Easy Learning
UNIQUE Constraint:
The UNIQUE Constraint prevents two records from having identical values in a particular column. In the
CUSTOMERS table, for example, you might want to prevent two or more people from having identical age.

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns. Here, AGE
column is set to UNIQUE, so that you can not have two records with same age:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL UNIQUE,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

If CUSTOMERS table has already been created, then to add a UNIQUE constraint to AGE column, you would write
a statement similar to the following:

ALTER TABLE CUSTOMERS

MODIFY AGE INT NOT NULL UNIQUE;

You can also use the following syntax, which supports naming the constraint in multiple columns as well:

ALTER TABLE CUSTOMERS

ADD CONSTRAINT myUniqueConstraint UNIQUE(AGE, SALARY);

DROP a UNIQUE Constraint:

To drop a UNIQUE constraint, use the following SQL:

ALTER TABLE CUSTOMERS

DROP CONSTRAINT myUniqueConstraint;

If you are using MySQL, then you can use the following syntax:

ALTER TABLE CUSTOMERS

DROP INDEX myUniqueConstraint;

TUTORIALS POINT
Simply Easy Learning
PRIMARY Key:
A primary key is a field in a table which uniquely identifies each row/record in a database table. Primary keys must
contain unique values. A primary key column cannot have NULL values.

A table can have only one primary key, which may consist of single or multiple fields. When multiple fields are used
as a primary key, they are called a composite key.

If a table has a primary key defined on any field(s), then you can not have two records having the same value of
that field(s).

Note: You would use these concepts while creating database tables.

Create Primary Key:

Here is the syntax to define ID attribute as a primary key in a CUSTOMERS table.

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

To create a PRIMARY KEY constraint on the "ID" column when CUSTOMERS table already exists, use the
following SQL syntax:

ALTER TABLE CUSTOMER ADD PRIMARY KEY (ID);

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID, NAME)

);

TUTORIALS POINT
Simply Easy Learning
To create a PRIMARY KEY constraint on the "ID" and "NAMES" columns when CUSTOMERS table already exists,
use the following SQL syntax:

ALTER TABLE CUSTOMERS

ADD CONSTRAINT PK_CUSTID PRIMARY KEY (ID, NAME);

Delete Primary Key:

You can clear the primary key constraints from the table, Use Syntax:

ALTER TABLE CUSTOMERS DROP PRIMARY KEY ;

FOREIGN Key:
A foreign key is a key used to link two tables together. This is sometimes called a referencing key.

Primary key field from one table and insert it into the other table where it becomes a foreign key i.e., Foreign Key is
a column or a combination of columns, whose values match a Primary Key in a different table.

Example:
Consider the structure of the two tables as follows:

CUSTOMERS table:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

ORDERS table:
CREATE TABLE ORDERS (

ID INT NOT NULL,

DATE DATETIME,

CUSTOMER_ID INT references CUSTOMERS(ID),

TUTORIALS POINT
Simply Easy Learning
AMOUNT double,

PRIMARY KEY (ID)

);

If ORDERS table has already been created, and the foreign key has not yet been, use the syntax for specifying a
foreign key by altering a table.

ALTER TABLE ORDERS

ADD FOREIGN KEY (Customer_ID) REFERENCES CUSTOMERS (ID);

DROP a FOREIGN KEY Constraint:

To drop a FOREIGN KEY constraint, use the following SQL:

ALTER TABLE ORDERS

DROP FOREIGN KEY;

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns. Here, we add a
CHECK with AGE column, so that you can not have any CUSTOMER below 18 years:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL CHECK (AGE >= 18),

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

If CUSTOMERS table has already been created, then to add a CHECK constraint to AGE column, you would write
a statement similar to the following:

ALTER TABLE CUSTOMERS

MODIFY AGE INT NOT NULL CHECK (AGE >= 18 );

You can also use following syntax, which supports naming the constraint and multiple columns as well:

ALTER TABLE CUSTOMERS

TUTORIALS POINT
Simply Easy Learning
ADD CONSTRAINT myCheckConstraint CHECK(AGE >= 18);

DROP a CHECK Constraint:

To drop a CHECK constraint, use the following SQL. This syntax does not work with MySQL:

ALTER TABLE CUSTOMERS

DROP CONSTRAINT myCheckConstraint;

INDEX:
The INDEX is used to create and retrieve data from the database very quickly. Index can be created by using
single or group of columns in a table. When index is created, it is assigned a ROWID for each row before it sorts
out the data.

Proper indexes are good for performance in large databases, but you need to be careful while creating index.
Selection of fields depends on what you are using in your SQL queries.

Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five columns:

CREATE TABLE CUSTOMERS(

ID INT NOT NULL,

NAME VARCHAR (20) NOT NULL,

AGE INT NOT NULL,

ADDRESS CHAR (25) ,

SALARY DECIMAL (18, 2),

PRIMARY KEY (ID)

);

Now, you can create index on single or multiple columns using the followwng syntax:

CREATE INDEX index_name

ON table_name ( column1, column2.....);

To create an INDEX on AGE column, to optimize the search on customers for a particular age, following is the SQL
syntax:

CREATE INDEX idx_age

ON CUSTOMERS ( AGE );

DROP an INDEX Constraint:

To drop an INDEX constraint, use the following SQL:

TUTORIALS POINT
Simply Easy Learning
ALTER TABLE CUSTOMERS

DROP INDEX idx_age;

Constraints can be specified when a table is created with the CREATE TABLE statement or you can use ALTER
TABLE statment to create constraints even after the table is created.

Dropping Constraints:
Any constraint that you have defined can be dropped using the ALTER TABLE command with the DROP
CONSTRAINT option.

For example, to drop the primary key constraint in the EMPLOYEES table, you can use the following command:

ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;

Some implementations may provide shortcuts for dropping certain constraints. For example, to drop the primary
key constraint for a table in Oracle, you can use the following command:

ALTER TABLE EMPLOYEES DROP PRIMARY KEY;

Some implementations allow you to disable constraints. Instead of permanently dropping a constraint from the
database, you may want to temporarily disable the constraint, and then enable it later.

Integrity Constraints:
Integrity constraints are used to ensure accuracy and consistency of data in a relational database. Data integrity is
handled in a relational database through the concept of referential integrity.

There are many types of integrity constraints that play a role in referential integrity (RI). These constraints include
Primary Key, Foreign Key, Unique Constraints and other constraints mentioned above.

TUTORIALS POINT
Simply Easy Learning
CHAPTER

26
SQL Joins

T he SQL Joins clause is used to combine records from two or more tables in a database. A JOIN is a

means for combining fields from two tables by using values common to each.
Consider the following two tables, (a) CUSTOMERS table is as follows:

(b) Another table is ORDERS as follows:

+-----+---------------------+-------------+--------+
|OID | DATE | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+

Now, let us join these two tables in our SELECT statement as follows:

SQL> SELECT ID, NAME, AGE, AMOUNT

FROM CUSTOMERS, ORDERS
WHERE CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

This would produce the following result:

+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |

TUTORIALS POINT
Simply Easy Learning
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+

Here, it is noticeable that the join is performed in the WHERE clause. Several operators can be used to join tables,
such as =, <, >, <>, <=, >=, !=, BETWEEN, LIKE, and NOT; they can all be used to join tables. However, the most
common operator is the equal symbol.

SQL Join Types:

There are different types of joins available in SQL:
 INNER JOIN: returns rows when there is a match in both tables.
 LEFT JOIN: returns all rows from the left table, even if there are no matches in the right table.
 RIGHT JOIN: returns all rows from the right table, even if there are no matches in the left table.
 FULL JOIN: returns rows when there is a match in one of the tables.
 SELF JOIN: is used to join a table to itself as if the table were two tables, temporarily renaming at least one
table in the SQL statement.
 CARTESIAN JOIN: returns the Cartesian product of the sets of records from the two or more joined tables.

INNER JOIN
The most frequently used and important of the joins is the INNER JOIN. They are also referred to as an
EQUIJOIN.
The INNER JOIN creates a new result table by combining column values of two tables (table1 and table2) based
upon the join-predicate. The query compares each row of table1 with each row of table2 to find all pairs of rows
which satisfy the join-predicate. When the join-predicate is satisfied, column values for each matched pair of rows
of A and B are combined into a result row.

Syntax:
The basic syntax of INNER JOIN is as follows:

SELECT table1.column1, table2.column2...

FROM table1
INNER JOIN table2
ON table1.common_filed = table2.common_field;

Example:
Consider the following two tables, (a) CUSTOMERS table is as follows:

(b) Another table is ORDERS as follows:

+-----+---------------------+-------------+--------+

TUTORIALS POINT
Simply Easy Learning
| OID | DATE | ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+

Now, let us join these two tables using INNER JOIN as follows:

SQL> SELECT ID, NAME, AMOUNT, DATE

FROM CUSTOMERS
INNER JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

This would produce the following result:

+----+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+----+----------+--------+---------------------+
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+----+----------+--------+---------------------+

LEFT JOIN
The SQL LEFT JOIN returns all rows from the left table, even if there are no matches in the right table. This means
that if the ON clause matches 0 (zero) records in right table, the join will still return a row in the result, but with
NULL in each column from right table.
This means that a left join returns all the values from the left table, plus matched values from the right table or
NULL in case of no matching join predicate.

Syntax:
The basic syntax of LEFT JOIN is as follows:

SELECT table1.column1, table2.column2...

FROM table1
LEFT JOIN table2
ON table1.common_filed = table2.common_field;

Here given condition could be any given expression based on your requirement.

Example:
Consider the following two tables, (a) CUSTOMERS table is as follows:

TUTORIALS POINT
Simply Easy Learning
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

(b) Another table is ORDERS as follows:

+-----+---------------------+-------------+--------+
| OID | DATE | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+

Now, let us join these two tables using LEFT JOIN as follows:

SQL> SELECT ID, NAME, AMOUNT, DATE

FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

This would produce the following result:

+----+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+----+----------+--------+---------------------+
| 1 | Ramesh | NULL | NULL |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 5 | Hardik | NULL | NULL |
| 6 | Komal | NULL | NULL |
| 7 | Muffy | NULL | NULL |
+----+----------+--------+---------------------+

RIGHT JOIN
The SQL RIGHT JOIN returns all rows from the right table, even if there are no matches in the left table. This
means that if the ON clause matches 0 (zero) records in left table, the join will still return a row in the result, but
with NULL in each column from left table.
This means that a right join returns all the values from the right table, plus matched values from the left table or
NULL in case of no matching join predicate.

Syntax:
The basic syntax of RIGHT JOIN is as follows:

SELECT table1.column1, table2.column2...

FROM table1
RIGHT JOIN table2
ON table1.common_filed = table2.common_field;

Example:
Consider the following two tables, (a) CUSTOMERS table is as follows:

TUTORIALS POINT
Simply Easy Learning
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

(b) Another table is ORDERS as follows:

Now, let us join these two tables using RIGHT JOIN as follows:

SQL> SELECT ID, NAME, AMOUNT, DATE

FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

This would produce the following result:

+------+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+------+----------+--------+---------------------+
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

FULL JOIN
The SQL FULL JOIN combines the results of both left and right outer joins.
The joined table will contain all records from both tables, and fill in NULLs for missing matches on either side.

Syntax:
The basic syntax of FULL JOIN is as follows:

SELECT table1.column1, table2.column2...

FROM table1
FULL JOIN table2
ON table1.common_filed = table2.common_field;

Here given condition could be any given expression based on your requirement.

TUTORIALS POINT
Simply Easy Learning
Example:
Consider the following two tables, (a) CUSTOMERS table is as follows:

(b) Another table is ORDERS as follows:

Now, let us join these two tables using FULL JOIN as follows:

SQL> SELECT ID, NAME, AMOUNT, DATE

FROM CUSTOMERS
FULL JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

This would produce the following result:

+------+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+------+----------+--------+---------------------+
| 1 | Ramesh | NULL | NULL |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 5 | Hardik | NULL | NULL |
| 6 | Komal | NULL | NULL |
| 7 | Muffy | NULL | NULL |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

If your Database does not support FULL JOIN like MySQL does not support FULL JOIN, then you can use UNION
ALL clause to combine two JOINS as follows:

SQL> SELECT ID, NAME, AMOUNT, DATE

FROM CUSTOMERS
LEFT JOIN ORDERS

TUTORIALS POINT
Simply Easy Learning
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID

SELF JOIN
The SQL SELF JOIN is used to join a table to itself as if the table were two tables, temporarily renaming at least
one table in the SQL statement.

Syntax:
The basic syntax of SELF JOIN is as follows:
SELECT a.column_name, b.column_name...
FROM table1 a, table1 b
WHERE a.common_filed = b.common_field;

Here, WHERE clause could be any given expression based on your requirement.

Example:
Consider the following two tables, (a) CUSTOMERS table is as follows:

Now, let us join this table using SELF JOIN as follows:

SQL> SELECT a.ID, b.NAME, a.SALARY

FROM CUSTOMERS a, CUSTOMERS b
WHERE a.SALARY < b.SALARY;

This would produce the following result:

+----+----------+---------+
| ID | NAME | SALARY |
+----+----------+---------+
| 2 | Ramesh | 1500.00 |
| 2 | kaushik | 1500.00 |
| 1 | Chaitali | 2000.00 |
| 2 | Chaitali | 1500.00 |
| 3 | Chaitali | 2000.00 |
| 6 | Chaitali | 4500.00 |
| 1 | Hardik | 2000.00 |
| 2 | Hardik | 1500.00 |
| 3 | Hardik | 2000.00 |
| 4 | Hardik | 6500.00 |

TUTORIALS POINT
Simply Easy Learning
| 6 | Hardik | 4500.00 |
| 1 | Komal | 2000.00 |
| 2 | Komal | 1500.00 |
| 3 | Komal | 2000.00 |
| 1 | Muffy | 2000.00 |
| 2 | Muffy | 1500.00 |
| 3 | Muffy | 2000.00 |
| 4 | Muffy | 6500.00 |
| 5 | Muffy | 8500.00 |
| 6 | Muffy | 4500.00 |
+----+----------+---------+

CARTESIAN JOIN
The CARTESIAN JOIN or CROSS JOIN returns the cartesian product of the sets of records from the two or more
joined tables. Thus, it equates to an inner join where the join-condition always evaluates to True or where the join-
condition is absent from the statement.

Syntax:
The basic syntax of INNER JOIN is as follows:

SELECT table1.column1, table2.column2...

FROM table1, table2 [, table3 ]

Example:
Consider the following two tables, (a) CUSTOMERS table is as follows:

(b) Another table is ORDERS as follows:

Now, let us join these two tables using INNER JOIN as follows:

SQL> SELECT ID, NAME, AMOUNT, DATE

FROM CUSTOMERS, ORDERS;

TUTORIALS POINT
Simply Easy Learning
This would produce the following result:

+----+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+----+----------+--------+---------------------+
| 1 | Ramesh | 3000 | 2009-10-08 00:00:00 |
| 1 | Ramesh | 1500 | 2009-10-08 00:00:00 |
| 1 | Ramesh | 1560 | 2009-11-20 00:00:00 |
| 1 | Ramesh | 2060 | 2008-05-20 00:00:00 |
| 2 | Khilan | 3000 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 2 | Khilan | 2060 | 2008-05-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 2060 | 2008-05-20 00:00:00 |
| 4 | Chaitali | 3000 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 5 | Hardik | 3000 | 2009-10-08 00:00:00 |
| 5 | Hardik | 1500 | 2009-10-08 00:00:00 |
| 5 | Hardik | 1560 | 2009-11-20 00:00:00 |
| 5 | Hardik | 2060 | 2008-05-20 00:00:00 |
| 6 | Komal | 3000 | 2009-10-08 00:00:00 |
| 6 | Komal | 1500 | 2009-10-08 00:00:00 |
| 6 | Komal | 1560 | 2009-11-20 00:00:00 |
| 6 | Komal | 2060 | 2008-05-20 00:00:00 |
| 7 | Muffy | 3000 | 2009-10-08 00:00:00 |
| 7 | Muffy | 1500 | 2009-10-08 00:00:00 |
| 7 | Muffy | 1560 | 2009-11-20 00:00:00 |
| 7 | Muffy | 2060 | 2008-05-20 00:00:00 |
+----+----------+--------+---------------------+

TUTORIALS POINT
Simply Easy Learning
CHAPTER

33
SQL - Using Views

A view is nothing more than a SQL statement that is stored in the database with an associated name. A

view is actually a composition of a table in the form of a predefined SQL query.

A view can contain all rows of a table or select rows from a table. A view can be created from one or many tables
which depends on the written SQL query to create a view.

Views, which are kind of virtual tables, allow users to do the following:

 Structure data in a way that users or classes of users find natural or intuitive.

 Restrict access to the data such that a user can see and (sometimes) modify exactly what they need and no
more.

 Summarize data from various tables which can be used to generate reports.

Creating Views:
Database views are created using the CREATE VIEW statement. Views can be created from a single table,
multiple tables, or another view.

To create a view, a user must have the appropriate system privilege according to the specific implementation.

The basic CREATE VIEW syntax is as follows:

CREATE VIEW view_name AS

SELECT column1, column2.....
FROM table_name
WHERE [condition];

You can include multiple tables in your SELECT statement in very similar way as you use them in normal SQL
SELECT query.

Example:
Consider the CUSTOMERS table having the following records:

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |

TUTORIALS POINT
Simply Easy Learning
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Now, following is the example to create a view from CUSTOMERS table. This view would be used to have
customer name and age from CUSTOMERS table:

SQL > CREATE VIEW CUSTOMERS_VIEW AS

SELECT name, age
FROM CUSTOMERS;

Now, you can query CUSTOMERS_VIEW in similar way as you query an actual table. Following is the example:

SQL > SELECT * FROM CUSTOMERS_VIEW;

This would produce the following result:

+----------+-----+
| name | age |
+----------+-----+
| Ramesh | 32 |
| Khilan | 25 |
| kaushik | 23 |
| Chaitali | 25 |
| Hardik | 27 |
| Komal | 22 |
| Muffy | 24 |
+----------+-----+

The WITH CHECK OPTION:

The WITH CHECK OPTION is a CREATE VIEW statement option. The purpose of the WITH CHECK OPTION is
to ensure that all UPDATE and INSERTs satisfy the condition(s) in the view definition.

If they do not satisfy the condition(s), the UPDATE or INSERT returns an error.

The following is an example of creating same view CUSTOMERS_VIEW with the WITH CHECK OPTION:

CREATE VIEW CUSTOMERS_VIEW AS

SELECT name, age
FROM CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;

The WITH CHECK OPTION in this case should deny the entry of any NULL values in the view's AGE column,
because the view is defined by data that does not have a NULL value in the AGE column.

Updating a View:
A view can be updated under certain conditions:

TUTORIALS POINT
Simply Easy Learning
 The SELECT clause may not contain the keyword DISTINCT.

 The SELECT clause may not contain summary functions.

 The SELECT clause may not contain set functions.

 The SELECT clause may not contain set operators.

 The SELECT clause may not contain an ORDER BY clause.

 The FROM clause may not contain multiple tables.

 The WHERE clause may not contain subqueries.

 The query may not contain GROUP BY or HAVING.

 Calculated columns may not be updated.

 All NOT NULL columns from the base table must be included in the view in order for the INSERT query to
function.

So if a view satisfies all the abovementioned rules then you can update a view. Following is an example to update
the age of Ramesh:

SQL > UPDATE CUSTOMERS_VIEW

SET AGE = 35
WHERE name='Ramesh';

This would ultimately update the base table CUSTOMERS and same would reflect in the view itself. Now, try to
query base table, and SELECT statement would produce the following result:

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 35 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Inserting Rows into a View:

Rows of data can be inserted into a view. The same rules that apply to the UPDATE command also apply to the
INSERT command.

Here, we can not insert rows in CUSTOMERS_VIEW because we have not included all the NOT NULL columns in
this view, otherwise you can insert rows in a view in similar way as you insert them in a table.

TUTORIALS POINT
Simply Easy Learning
Deleting Rows into a View:
Rows of data can be deleted from a view. The same rules that apply to the UPDATE and INSERT commands
apply to the DELETE command.

Following is an example to delete a record having AGE= 22.

SQL > DELETE FROM CUSTOMERS_VIEW

WHERE age = 22;

This would ultimately delete a row from the base table CUSTOMERS and same would reflect in the view itself.
Now, try to query base table, and SELECT statement would produce the following result:

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 35 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Dropping Views:
Obviously, where you have a view, you need a way to drop the view if it is no longer needed. The syntax is very
simple as given below:

DROP VIEW view_name;

Following is an example to drop CUSTOMERS_VIEW from CUSTOMERS table:

DROP VIEW CUSTOMERS_VIEW;

TUTORIALS POINT
Simply Easy Learning
CHAPTER

34
SQL HAVING CLAUSE

T
results.
he HAVING clause enables you to specify conditions that filter which group results appear in the final

The WHERE clause places conditions on the selected columns, whereas the HAVING clause places conditions on
groups created by the GROUP BY clause.

Syntax:
The following is the position of the HAVING clause in a query:

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

The HAVING clause must follow the GROUP BY clause in a query and must also precede the ORDER BY clause
if used. The following is the syntax of the SELECT statement, including the HAVING clause:

SELECT column1, column2

FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Example:
Consider the CUSTOMERS table having the following records:

TUTORIALS POINT
Simply Easy Learning
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Following is the example, which would display record for which similar age count would be more than or equal to 2:

SQL > SELECT *

FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

This would produce the following result:

+----+--------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+--------+-----+---------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
+----+--------+-----+---------+---------+

TUTORIALS POINT
Simply Easy Learning
CHAPTER

40
SQL Sub Queries

A Subquery or Inner query or Nested query is a query within another SQL query and embedded within

the WHERE clause.

A subquery is used to return data that will be used in the main query as a condition to further restrict the data to
be retrieved.

Subqueries can be used with the SELECT, INSERT, UPDATE, and DELETE statements along with the operators
like =, <, >, >=, <=, IN, BETWEEN etc.

There are a few rules that subqueries must follow:

 Subqueries must be enclosed within parentheses.

 A subquery can have only one column in the SELECT clause, unless multiple columns are in the main query
for the subquery to compare its selected columns.

 An ORDER BY cannot be used in a subquery, although the main query can use an ORDER BY. The GROUP
BY can be used to perform the same function as the ORDER BY in a subquery.

 Subqueries that return more than one row can only be used with multiple value operators, such as the IN
operator.

 The SELECT list cannot include any references to values that evaluate to a BLOB, ARRAY, CLOB, or
NCLOB.

 A subquery cannot be immediately enclosed in a set function.

 The BETWEEN operator cannot be used with a subquery; however, the BETWEEN operator can be used
within the subquery.

Subqueries with the SELECT Statement:

Subqueries are most frequently used with the SELECT statement. The basic syntax is as follows:

SELECT column_name [, column_name ]

FROM table1 [, table2 ]
WHERE column_name OPERATOR

TUTORIALS POINT
Simply Easy Learning
(SELECT column_name [, column_name ]
FROM table1 [, table2 ]
[WHERE])

Example:
Consider the CUSTOMERS table having the following records:

Now, let us check the following subquery with SELECT statement:

SQL> SELECT *
FROM CUSTOMERS
WHERE ID IN (SELECT ID
FROM CUSTOMERS
WHERE SALARY > 4500) ;

This would produce the following result:

Subqueries with the INSERT Statement:

Subqueries also can be used with INSERT statements. The INSERT statement uses the data returned from the
subquery to insert into another table. The selected data in the subquery can be modified with any of the character,
date or number functions.

The basic syntax is as follows:

INSERT INTO table_name [ (column1 [, column2 ]) ]

SELECT [ *|column1 [, column2 ]
FROM table1 [, table2 ]
[ WHERE VALUE OPERATOR ]

Example:
Consider a table CUSTOMERS_BKP with similar structure as CUSTOMERS table. Now to copy complete
CUSTOMERS table into CUSTOMERS_BKP, following is the syntax:

SQL> INSERT INTO CUSTOMERS_BKP

SELECT * FROM CUSTOMERS

TUTORIALS POINT
Simply Easy Learning
WHERE ID IN (SELECT ID
FROM CUSTOMERS) ;

Subqueries with the UPDATE Statement:

The subquery can be used in conjunction with the UPDATE statement. Either single or multiple columns in a table
can be updated when using a subquery with the UPDATE statement.

The basic syntax is as follows:

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]

Example:
Assuming, we have CUSTOMERS_BKP table available which is backup of CUSTOMERS table.

Following example updates SALARY by 0.25 times in CUSTOMERS table for all the customers whose AGE is
greater than or equal to 27:

SQL> UPDATE CUSTOMERS

SET SALARY = SALARY * 0.25
WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
WHERE AGE >= 27 );

This would impact two rows and finally CUSTOMERS table would have the following records:

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 35 | Ahmedabad | 125.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 2125.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Subqueries with the DELETE Statement:

The subquery can be used in conjunction with the DELETE statement like with any other statements mentioned
above.

The basic syntax is as follows:

DELETE FROM TABLE_NAME

[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]

TUTORIALS POINT
Simply Easy Learning
Example:
Assuming, we have CUSTOMERS_BKP table available which is backup of CUSTOMERS table.

Following example deletes records from CUSTOMERS table for all the customers whose AGE is greater than or
equal to 27:

SQL> DELETE FROM CUSTOMERS

WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
WHERE AGE > 27 );

This would impact two rows and finally CUSTOMERS table would have the following records:

+----+----------+-----+---------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+

TUTORIALS POINT
Simply Easy Learning
CHAPTER

41
SQL – Using Sequences

A sequence is a set of integers 1, 2, 3, ... that are generated in order on demand. Sequences are

frequently used in databases because many applications require each row in a table to contain a unique value, and
sequences provide an easy way to generate them.

This chapter describes how to use sequences in MySQL.

Using AUTO_INCREMENT column:

The simplest way in MySQL to use sequences is to define a column as AUTO_INCREMENT and leave rest of the
things to MySQL to take care.

Example:
Try out the following example. This will create table and after that it will insert few rows in this table where it is not
required to give record ID because its auto-incremented by MySQL.

mysql> CREATE TABLE INSECT

-> (
-> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
-> PRIMARY KEY (id),
-> name VARCHAR(30) NOT NULL, # type of insect
-> date DATE NOT NULL, # date collected
-> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO INSECT (id,name,date,origin) VALUES
-> (NULL,'housefly','2001-09-10','kitchen'),
-> (NULL,'millipede','2001-09-10','driveway'),
-> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3 Duplicates: 0 Warnings: 0
mysql> SELECT * FROM INSECT ORDER BY id;
+----+-------------+------------+------------+
| id | name | date | origin |
+----+-------------+------------+------------+
| 1 | housefly | 2001-09-10 | kitchen |
| 2 | millipede | 2001-09-10 | driveway |
| 3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

TUTORIALS POINT
Simply Easy Learning
Obtain AUTO_INCREMENT Values:
LAST_INSERT_ID( ) is a SQL function, so you can use it from within any client that understands how to issue SQL
statements. Otherwise, PERL and PHP scripts provide exclusive functions to retrieve auto-incremented value of
last record.

PERL Example:
Use the mysql_insertid attribute to obtain the AUTO_INCREMENT value generated by a query. This attribute is
accessed through either a database handle or a statement handle, depending on how you issue the query. The
following example references it through the database handle:

$dbh->do ("INSERT INTO INSECT (name,date,origin)

VALUES('moth','2001-09-14','windowsill')");
my $seq = $dbh->{mysql_insertid};

PHP Example:
After issuing a query that generates an AUTO_INCREMENT value, retrieve the value by calling mysql_insert_id(
):

mysql_query ("INSERT INTO INSECT (name,date,origin)

VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);

Renumbering an Existing Sequence:

There may be a case when you have deleted many records from a table and you want to resequence all the
records. This can be done by using a simple trick but you should be very careful to do so if your table is having
joins with other table.

If you determine that resequencing an AUTO_INCREMENT column is unavoidable, the way to do it is to drop the
column from the table, then add it again. The following example shows how to renumber the id values in the insect
table using this technique:

mysql> ALTER TABLE INSECT DROP id;

mysql> ALTER TABLE insect
-> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
-> ADD PRIMARY KEY (id);

Starting a Sequence at a Particular Value:

By default, MySQL will start sequence from 1 but you can specify any other number as well at the time of table
creation. Following is the example where MySQL will start sequence from 100.

mysql> CREATE TABLE INSECT

-> (
-> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
-> PRIMARY KEY (id),
-> name VARCHAR(30) NOT NULL, # type of insect
-> date DATE NOT NULL, # date collected
-> origin VARCHAR(30) NOT NULL # where collected
);

TUTORIALS POINT
Simply Easy Learning
Alternatively, you can create the table and then set the initial sequence value with ALTER TABLE.

mysql> ALTER TABLE t AUTO_INCREMENT = 100;

TUTORIALS POINT
Simply Easy Learning
CHAPTER

44
SQL Useful Functions

S QL has many built-in functions for performing processing on string or numeric data. Following is the list of

all useful SQL built-in functions:

 SQL COUNT Function - The SQL COUNT aggregate function is used to count the number of rows in a
database table.
 SQL MAX Function - The SQL MAX aggregate function allows us to select the highest (maximum) value for a
certain column.
 SQL MIN Function - The SQL MIN aggregate function allows us to select the lowest (minimum) value for a
certain column.
 SQL AVG Function - The SQL AVG aggregate function selects the average value for certain table column.
 SQL SUM Function - The SQL SUM aggregate function allows selecting the total for a numeric column.
 SQL SQRT Functions - This is used to generate a square root of a given number.
 SQL RAND Function - This is used to generate a random number using SQL command.
 SQL CONCAT Function - This is used to concatenate any string inside any SQL command.
 SQL Numeric Functions - Complete list of SQL functions required to manipulate numbers in SQL.
 SQL String Functions - Complete list of SQL functions required to manipulate strings in SQL.

SQL COUNT Function

SQL COUNT function is the simplest function and very useful in counting the number of records, which are expected to be
returned by a SELECT statement.
To understand COUNT function, consider an employee_tbl table, which is having the following records:

SQL> SELECT * FROM employee_tbl;

+------+------+------------+--------------------+
| id | name | work_date | daily_typing_pages |
+------+------+------------+--------------------+
| 1 | John | 2007-01-24 | 250 |
| 2 | Ram | 2007-05-27 | 220 |
| 3 | Jack | 2007-05-06 | 170 |
| 3 | Jack | 2007-04-06 | 100 |
| 4 | Jill | 2007-04-06 | 220 |
| 5 | Zara | 2007-06-06 | 300 |
| 5 | Zara | 2007-02-06 | 350 |
+------+------+------------+--------------------+
7 rows in set (0.00 sec)

Now suppose based on the above table you want to count total number of rows in this table, then you can do it as follows:

SQL>SELECT COUNT(*) FROM employee_tbl ;

TUTORIALS POINT
Simply Easy Learning
+----------+
| COUNT(*) |
+----------+
| 7 |
+----------+
1 row in set (0.01 sec)

Similarly, if you want to count the number of records for Zara, then it can be done as follows:

SQL>SELECT COUNT(*) FROM employee_tbl

-> WHERE name="Zara";
+----------+
| COUNT(*) |
+----------+
| 2 |
+----------+
1 row in set (0.04 sec)

NOTE: All the SQL queries are case insensitive, so it does not make any difference if you give ZARA or Zara in WHERE
CONDITION.

SQL MAX Function

SQL MAX function is used to find out the record with maximum value among a record set.
To understand MAX function, consider an employee_tbl table, which is having the following records:

SQL> SELECT * FROM employee_tbl;

Now suppose based on the above table you want to fetch maximum value of daily_typing_pages, then you can do
so simply using the following command:

SQL> SELECT MAX(daily_typing_pages)

-> FROM employee_tbl;
+-------------------------+
| MAX(daily_typing_pages) |
+-------------------------+
| 350 |
+-------------------------+
1 row in set (0.00 sec)

You can find all the records with maxmimum value for each name using GROUP BY clause as follows:

SQL> SELECT id, name, MAX(daily_typing_pages)

-> FROM employee_tbl GROUP BY name;
+------+------+-------------------------+
| id | name | MAX(daily_typing_pages) |
+------+------+-------------------------+
| 3 | Jack | 170 |
| 4 | Jill | 220 |

TUTORIALS POINT
Simply Easy Learning
| 1 | John | 250 |
| 2 | Ram | 220 |
| 5 | Zara | 350 |
+------+------+-------------------------+
5 rows in set (0.00 sec)

You can use MIN Function along with MAX function to find out minimum value as well. Try out the following
example:

SQL> SELECT MIN(daily_typing_pages) least, MAX(daily_typing_pages) max

-> FROM employee_tbl;
+-------+------+
| least | max |
+-------+------+
| 100 | 350 |
+-------+------+
1 row in set (0.01 sec)

SQL MIN Function

SQL MIN function is used to find out the record with minimum value among a record set.
To understand MIN function, consider an employee_tbl table, which is having the following records:

SQL> SELECT * FROM employee_tbl;

Now suppose based on the above table you want to fetch minimum value of daily_typing_pages, then you can do
so simply using the following command:

SQL> SELECT MIN(daily_typing_pages)

-> FROM employee_tbl;
+-------------------------+
| MIN(daily_typing_pages) |
+-------------------------+
| 100 |
+-------------------------+
1 row in set (0.00 sec)

You can find all the records with minimum value for each name using GROUP BY clause as follows:

SQL> SELECT id, name, work_date, MIN(daily_typing_pages)

-> FROM employee_tbl GROUP BY name;
+------+------+-------------------------+
| id | name | MIN(daily_typing_pages) |
+------+------+-------------------------+
| 3 | Jack | 100 |
| 4 | Jill | 220 |
| 1 | John | 250 |

TUTORIALS POINT
Simply Easy Learning
| 2 | Ram | 220 |
| 5 | Zara | 300 |
+------+------+-------------------------+
5 rows in set (0.00 sec)

You can use MIN Function along with MAX function to find out minimum value as well. Try out the following
example:

SQL> SELECT MIN(daily_typing_pages) least,

-> MAX(daily_typing_pages) max
-> FROM employee_tbl;
+-------+------+
| least | max |
+-------+------+
| 100 | 350 |
+-------+------+
1 row in set (0.01 sec)

SQL AVG Function

SQL AVG function is used to find out the average of a field in various records.
To understand AVG function, consider an employee_tbl table, which is having the following records:

SQL> SELECT * FROM employee_tbl;

Now suppose based on the above table you want to calculate average of all the dialy_typing_pages, then you can
do so by using the following command:

SQL> SELECT AVG(daily_typing_pages)

-> FROM employee_tbl;
+-------------------------+
| AVG(daily_typing_pages) |
+-------------------------+
| 230.0000 |
+-------------------------+
1 row in set (0.03 sec)

You can take average of various records set using GROUP BY clause. Following example will take average all the
records related to a single person and you will have average typed pages by every person.

SQL> SELECT name, AVG(daily_typing_pages)

TUTORIALS POINT
Simply Easy Learning
| John | 250.0000 |
| Ram | 220.0000 |
| Zara | 325.0000 |
+------+-------------------------+
5 rows in set (0.20 sec)

SQL SUM Function

SQL SUM function is used to find out the sum of a field in various records.
To understand SUM function, consider an employee_tbl table, which is having the following records:

SQL> SELECT * FROM employee_tbl;

Now suppose based on the above table you want to calculate total of all the dialy_typing_pages, then you can do
so by using the following command:

SQL> SELECT SUM(daily_typing_pages)

-> FROM employee_tbl;
+-------------------------+
| SUM(daily_typing_pages) |
+-------------------------+
| 1610 |
+-------------------------+
1 row in set (0.00 sec)

You can take sum of various records set using GROUP BY clause. Following example will sum up all the records
related to a single person and you will have total typed pages by every person.

SQL> SELECT name, SUM(daily_typing_pages)

-> FROM employee_tbl GROUP BY name;
+------+-------------------------+
| name | SUM(daily_typing_pages) |
+------+-------------------------+
| Jack | 270 |
| Jill | 220 |
| John | 250 |
| Ram | 220 |
| Zara | 650 |
+------+-------------------------+
5 rows in set (0.17 sec)

SQL SQRT Function

SQL SQRT function is used to find out the square root of any number. You can Use SELECT statement to find out
squre root of any number as follows:

TUTORIALS POINT
Simply Easy Learning

What Is SQL1
No ratings yet
What Is SQL1
62 pages
Restaurant Management System
No ratings yet
Restaurant Management System
59 pages
SQL Server Tutorial - Part 1
No ratings yet
SQL Server Tutorial - Part 1
17 pages
SQL Overview
No ratings yet
SQL Overview
91 pages
Dandii Boru College: Level-Iii
No ratings yet
Dandii Boru College: Level-Iii
54 pages
SQL Print
No ratings yet
SQL Print
18 pages
HND Computing UNIT 38: Database Management Systems
No ratings yet
HND Computing UNIT 38: Database Management Systems
21 pages
SQL - Overview
No ratings yet
SQL - Overview
14 pages
SQL Basics
No ratings yet
SQL Basics
34 pages
Basic SQL
No ratings yet
Basic SQL
147 pages
Basic SQL
100% (1)
Basic SQL
102 pages
SQL - Overview
No ratings yet
SQL - Overview
59 pages
Class - 1 Introduction To SQL Querying
No ratings yet
Class - 1 Introduction To SQL Querying
21 pages
Unit 4 SQL
No ratings yet
Unit 4 SQL
45 pages
What Is SQL?
No ratings yet
What Is SQL?
37 pages
SQL
No ratings yet
SQL
78 pages
SQL Tutorial
No ratings yet
SQL Tutorial
22 pages
BY Okello Emmanuel 0784990516
No ratings yet
BY Okello Emmanuel 0784990516
24 pages
1.SQL Quick Guide
No ratings yet
1.SQL Quick Guide
108 pages
Introduction To Structured Query Language11
No ratings yet
Introduction To Structured Query Language11
12 pages
Structured Query Language
No ratings yet
Structured Query Language
22 pages
5. Structured Query Language (SQL)for Final Exam
No ratings yet
5. Structured Query Language (SQL)for Final Exam
70 pages
MSSQL Server 2008 Developer
No ratings yet
MSSQL Server 2008 Developer
240 pages
What Is SQL?
No ratings yet
What Is SQL?
104 pages
Lab 5. Databases. Introduction To SQL (CS Open CourseWare)
100% (1)
Lab 5. Databases. Introduction To SQL (CS Open CourseWare)
11 pages
DDDM UNIT-3
No ratings yet
DDDM UNIT-3
58 pages
Lesson5-SQL (Structured Query Language)-More Notes
No ratings yet
Lesson5-SQL (Structured Query Language)-More Notes
59 pages
Into RDBMS and Normalization
No ratings yet
Into RDBMS and Normalization
12 pages
tt
No ratings yet
tt
11 pages
5.3 SQL
No ratings yet
5.3 SQL
29 pages
SQL - Quick Guide
No ratings yet
SQL - Quick Guide
163 pages
SQL1
100% (1)
SQL1
3 pages
Keyboard Comprehension
No ratings yet
Keyboard Comprehension
2 pages
Unit 3 PHP
No ratings yet
Unit 3 PHP
39 pages
ISM-AYUSH BANSAL Practical file-BBA 212
No ratings yet
ISM-AYUSH BANSAL Practical file-BBA 212
20 pages
DAY-1 - Introduction To Oracle DB & Basic SQL
No ratings yet
DAY-1 - Introduction To Oracle DB & Basic SQL
37 pages
SQL Notes
No ratings yet
SQL Notes
21 pages
CH 2 Introduction To SQL & SQL Queries
No ratings yet
CH 2 Introduction To SQL & SQL Queries
6 pages
SQL Notes
No ratings yet
SQL Notes
18 pages
Dbms Lab Controlled
No ratings yet
Dbms Lab Controlled
100 pages
Chapter 7 - 8: Working With Databases and SQL
No ratings yet
Chapter 7 - 8: Working With Databases and SQL
28 pages
Ism 212
No ratings yet
Ism 212
15 pages
DBMS lab session unit 5
No ratings yet
DBMS lab session unit 5
89 pages
SQL for Beginners to Advance Le - RAJPUT, ANANT
No ratings yet
SQL for Beginners to Advance Le - RAJPUT, ANANT
104 pages
DBMS2
No ratings yet
DBMS2
10 pages
Information System Management: Kamal Institute of Higher Education and Advance Technology Lab File
No ratings yet
Information System Management: Kamal Institute of Higher Education and Advance Technology Lab File
23 pages
Structured Query Language
No ratings yet
Structured Query Language
48 pages
SQL 1
No ratings yet
SQL 1
9 pages
Introduction To SQL
No ratings yet
Introduction To SQL
8 pages
SQL Tutorial
No ratings yet
SQL Tutorial
3 pages
Chapter 5 SQL PDF
No ratings yet
Chapter 5 SQL PDF
16 pages
SQL Lab Assign
No ratings yet
SQL Lab Assign
22 pages
Assignment 2 (2)
No ratings yet
Assignment 2 (2)
7 pages
dbms unit3
No ratings yet
dbms unit3
15 pages
Chapter4_session1-Introduction to SQL, DDL, DML
No ratings yet
Chapter4_session1-Introduction to SQL, DDL, DML
63 pages
Unit 3 DBMS
No ratings yet
Unit 3 DBMS
88 pages
Chapter 5 Intro To SQL Fall22
No ratings yet
Chapter 5 Intro To SQL Fall22
84 pages
ICTE242 Prac 4 5
No ratings yet
ICTE242 Prac 4 5
40 pages
3 SQL - RDBMS Concepts
No ratings yet
3 SQL - RDBMS Concepts
4 pages
Dbmsfile (43518002718)
No ratings yet
Dbmsfile (43518002718)
96 pages
SQL Interview Success From Beginner To Pro
From Everand
SQL Interview Success From Beginner To Pro
Shana
No ratings yet
MCQs Databases SQL - Notepad
No ratings yet
MCQs Databases SQL - Notepad
5 pages
Database Programming With SQL Section 13 Quiz
No ratings yet
Database Programming With SQL Section 13 Quiz
37 pages
Replication
100% (1)
Replication
27 pages
SQL theory & Query
No ratings yet
SQL theory & Query
23 pages
Project Budgets Export - 72
No ratings yet
Project Budgets Export - 72
12 pages
Examples On Triggers: Instructor: Mohamed Eltabakh Meltabakh@cs - Wpi.edu
No ratings yet
Examples On Triggers: Instructor: Mohamed Eltabakh Meltabakh@cs - Wpi.edu
15 pages
EasyCalc 64 1983 Commodore
No ratings yet
EasyCalc 64 1983 Commodore
88 pages
Intro To SQL
No ratings yet
Intro To SQL
27 pages
447019307-prog-3114-1122020
No ratings yet
447019307-prog-3114-1122020
17 pages
Document
No ratings yet
Document
97 pages
Discrete Math Lab Manual
No ratings yet
Discrete Math Lab Manual
158 pages
BCA sem 5 DBMS Practical file
No ratings yet
BCA sem 5 DBMS Practical file
32 pages
Assignment Nested Table
No ratings yet
Assignment Nested Table
8 pages
Practical Distributed Processing Using MySQL Built-In Functionality Presentation
No ratings yet
Practical Distributed Processing Using MySQL Built-In Functionality Presentation
46 pages
Assignment 1: A) Create The Tables With The Appropriate Integrity Constraints
No ratings yet
Assignment 1: A) Create The Tables With The Appropriate Integrity Constraints
16 pages
IP-065-PRACTICALS 2025-with answer
No ratings yet
IP-065-PRACTICALS 2025-with answer
3 pages
Moremastering The Art of Indexing
No ratings yet
Moremastering The Art of Indexing
54 pages
2337368_E_20250409 SAP Note
No ratings yet
2337368_E_20250409 SAP Note
5 pages
Unit 4 - PHP 0 Mysql Notes
No ratings yet
Unit 4 - PHP 0 Mysql Notes
62 pages
Practical:-1: QUES1: Using The Following Database
No ratings yet
Practical:-1: QUES1: Using The Following Database
66 pages
0 - Unit 7 DataBase Development
No ratings yet
0 - Unit 7 DataBase Development
6 pages
SQL Views
No ratings yet
SQL Views
5 pages
DB 2 PD
No ratings yet
DB 2 PD
20 pages
DML SOQL Theory
No ratings yet
DML SOQL Theory
40 pages
Cake PHP Cookbook
No ratings yet
Cake PHP Cookbook
863 pages
Dbms Project Insurance Management System Company: by Ghazal Shambayati NEU ID:001238014
No ratings yet
Dbms Project Insurance Management System Company: by Ghazal Shambayati NEU ID:001238014
27 pages
Oracle WebADI Setups and Backend Effected Queries
No ratings yet
Oracle WebADI Setups and Backend Effected Queries
42 pages
Advanced RDBMS: Rdbms Lab Table Creation Create The Following Tables
No ratings yet
Advanced RDBMS: Rdbms Lab Table Creation Create The Following Tables
14 pages
Db2 Class 12
No ratings yet
Db2 Class 12
23 pages