CS1403 /Database design and management Department of IT/AML 2022 - 2023

Systems
UNIT-II Relational database Design
Functional Dependency
The functional dependency is a relationship that exists between two attributes. It typically exists between the
primary key and non-key attribute within a table.
X→Y
The left side of FD is known as a determinant, the right side of the production is known as a dependent.
For example:
Assume we have an employee table with attributes: Emp_Id, Emp_Name, Emp_Address.
Here Emp_Id attribute can uniquely identify the Emp_Name attribute of employee table because if we know the
Emp_Id, we can tell that employee name associated with it.
Functional dependency can be written as:
Emp_Id → Emp_Name
Types of Functional dependency

Trivial functional dependency

o A → B has trivial functional dependency if B is a subset ofA.
o The following dependencies are also trivial like: A → A, B →B
Example:
Consider a table with two columns Employee_Id and Employee_Name.
{Employee_id,Employee_Name} → Employee_Id is a trivial functional dependency as
Employee_Id is a subset of {Employee_Id,Employee_Name}.
3. Also, Employee_Id → Employee_Id andEmployee_Name → Employee_Name are trivial dependenciestoo.

Non-trivial functional dependency

A → B has a non-trivial functional dependency if B is not a subset of A.
When A intersection B is NULL, then A → B is called as complete non-trivial.
Example:
ID → Name,
Name → DOB
Normalization of Database
Database Normalization is a technique of organizing the data in the database. Normalization is a systematic

St. Joseph’s College of Engineering

CS1403 /Database design and management Department of IT/AML 2022 - 2023
Systems
approach of decomposing tables to eliminate data redundancy(repetition) and undesirable characteristics like
Insertion, Update and Deletion anomalies. It is a multi-step process that puts data into tabular form, removing
duplicated data from the relation tables.
Normalization is used for mainly two purposes,

 Eliminating reduntant(useless)data.
 Ensuring data dependencies make sense i.e data is logicallystored.

Problems Without Normalization

If a table is not properly normalized and have data redundancy then it will not only eat up extra memory space but
will also make it difficult to handle and update the database, without facing data loss. Insertion, Updation and
Deletion Anomalies are very frequent if database is not normalized. To understand these anomalies let us take an
example of a Student table.

rollno name branch hod office_tel

401 Akon CSE Mr. X 53337

402 Bkon CSE Mr. X 53337

403 Ckon CSE Mr. X 53337

404 Dkon CSE Mr. X 53337

In the table above, we have data of 4 Computer Sci. students. As we can see, data for the fields branch, hod(Head
of Department) and office_tel is repeated for the students who are in the same branch in the college, this is Data
Redundancy.
Insertion Anomaly
Suppose for a new admission, until and unless a student opts for a branch, data of the student cannot be inserted, or
else we will have to set the branch information as NULL.
Also, if we have to insert data of 100 students of same branch, then the branch information will be repeated for all
those 100 students.
These scenarios are nothing but Insertion anomalies.
Updation Anomaly
What if Mr. X leaves the college? or is no longer the HOD of computer science department? In that case all the
student records will have to be updated, and if by mistake we miss any record, it will lead to data inconsistency.
This is Updation anomaly.
Deletion Anomaly
In our Student table, two different informations are kept together, Student information and Branch information.
Hence, at the end of the academic year, if student records are deleted, we will also lose the branch information.
This is Deletion anomaly.

St. Joseph’s College of Engineering

CS1403 /Database design and management Department of IT/AML 2022 - 2023
Systems
Normalization Rule
Normalization rules are divided into the following normal forms:
1. First NormalForm
2. Second NormalForm
3. Third NormalForm
4. BCNF
5. Fourth NormalForm
6. Fifth NormalForm
First Normal Form (1NF)
For a table to be in the First Normal Form, it should follow the following 4 rules:
1. It should only have single(atomic) valuedattributes/columns.
2. Values stored in a column should be of the samedomain
3. All the columns in a table should have uniquenames.
4. And the order in which data is stored, does notmatter.
Rules for First Normal Form
The first normal form expects you to follow a few simple rules while designing your database, and they are:
Rule 1: Single Valued Attributes
Each column of your table should be single valued which means they should not contain multiple values. We
will explain this with help of an example later, let's see the other rules for now.
Rule 2: Attribute Domain should not change
This is more of a "Common Sense" rule. In each column the values stored must be of the same kind or type.
For example: If you have a column dob to save date of births of a set of people, then you cannot or you must
not save 'names' of some of them in that column along with 'date of birth' of others in that column. It should
hold only 'date of birth' for all the records/rows.
Rule 3: Unique name for Attributes/Columns
This rule expects that each column in a table should have a unique name. This is to avoid confusion at the time
of retrieving data or performing any other operation on the stored data.
If one or more columns have same name, then the DBMS system will be left confused.
Rule 4: Order doesn't matters
This rule says that the order in which you store the data in your table doesn't matter.

EXAMPLE
Create a table to store student data which will have student's roll no., their name and the name of subjects they
have opted for.
Here is the table, with some sample data added to it.

roll_no name subject

101 Akon OS, CN
103 Ckon Java
102 Bkon C, C++

The table already satisfies 3 rules out of the 4 rules, as all our column names are unique, we have stored data
in the order we wanted to and we have not inter-mixed different type of data incolumns.

St. Joseph’s College of Engineering

CS1403 /Database design and management Department of IT/AML 2022 - 2023
Systems
But out of the 3 different students in our table, 2 have opted for more than 1 subject. And we have stored the
subject names in a single column. But as per the 1st Normal form each column must contain atomic value.
It's very simple, because all we have to do is break the values into atomic values.
Here is our updated table and it now satisfies the First Normal Form.
roll_no name subject
101 Akon OS
101 Akon CN
103 Ckon Java
102 Bkon C
102 Bkon C++

By doing so, although a few values are getting repeated but values for the subject column are now atomic for
each record/row. Using the First Normal Form, data redundancy increases, as there will be many columns with
same data in multiple rows but each row as a whole will be unique.
Second Normal Form (2NF)
For a table to be in the Second Normal Form,
1. It should be in the First Normalform.
2. And, it should not have PartialDependency.
Dependency
Let's take an example of a Student table with columns student_id, name, reg_no(registration
number), branch and address(student's home address).
student_ reg_n branc addre
name
id o h ss

In this table, student_id is the primary key and will be unique for every row, hence we can use student_id to
fetch any row of data from this table
Even for a case, where student names are same, if we know the student_id we can easily fetch the correct
record.
student_id name reg_no branch address
10 Akon 07-WY CSE Kerala
11 Akon 08-WY IT Gujarat

Hence we can say a Primary Key for a table is the column or a group of columns(composite key) which can
uniquely identify each record in the table.
I can ask from branch name of student with student_id 10, and I can get it. Similarly, if I ask for name of
student with student_id 10 or 11, I will get it. So all I need is student_id and every other column depends on it,
or can be fetched using it.This is Dependency and we also call it Functional Dependency.
Partial Dependency
Now that we know what dependency is, we are in a better state to understand what partial dependency is.
For a simple table like Student, a single column like student_id can uniquely identfy all the records in a table.
But this is not true all the time. So now let's extend our example to see if more than 1 column together can act

St. Joseph’s College of Engineering

CS1403 /Database design and management Department of IT/AML 2022 - 2023
Systems
as a primary key.
Let's create another table for Subject, which will have subject_id and subject_name fields and subject_id will
be the primary key.
subject_i subject_nam
d e
1 Java
2 C++
3 Php
Now we have a Student table with student information and another table Subject for storing subject
information.
Let's create another table Score, to store the marks obtained by students in the respective subjects. We will also
be saving name of the teacher who teaches that subject along with marks.
subject_i
score_id student_id marks teacher
d
1 10 1 70 JavaTeacher
2 10 2 75 C++Teacher
3 11 1 80 JavaTeacher

In the score table we are saving the student_id to know which student's marks are these and subject_id to
know for which subject the marks are for.
Together, student_id + subject_id forms a Candidate Key which can be the Primary key.
To get me marks of student with student_id 10, can you get it from this table? No, because you don't know for
which subject. And if I give you subject_id, you would not know for which student. Hence we need student_id
+ subject_id to uniquely identify anyrow.
But where is PartialDependency?
Now if you look at the Score table, we have a column names teacher which is only dependent on the subject,
for Java it's Java Teacher and for C++ it's C++ Teacher & so on.
Now as we just discussed that the primary key for this table is a composition of two columns whic h
is student_id & subject_id but the teacher's name only depends on subject, hence the subject_id, and has
nothing to do withstudent_id.
This is Partial Dependency, where an attribute in a table depends on only a part of the primary key and not on
the whole key.
How to remove Partial Dependency?
There can be many different solutions for this, but out objective is to remove teacher's name from Score table.
The simplest solution is to remove columns teacher from Score table and add it to the Subject table. Hence, the
Subject table will become:
subject_id subject_name teacher
1 Java Java Teacher
2 C++ C++ Teacher
3 Php Php Teacher

St. Joseph’s College of Engineering

CS1403 /Database design and management Department of IT/AML 2022 - 2023
Systems

And our Score table is now in the second normal form, with no partial dependency.
score_ student_ subject_ mar
id id id ks
1 10 1 70
2 10 2 75
3 11

St. Joseph’s College of Engineering

CS1403 /Database design and Management Department of IT&AML 2022 - 2023
Systems

Third Normal Form (3NF)

A table is said to be in the Third Normal Form when,
1. It is in the Second Normalform.
2. And, it doesn't have TransitiveDependency.
So let's use the same example, where we have 3 tables, Student, Subject and Score.

StudentTable
student_i
name reg_no branch address
d
10 Akon 07-WY CSE Kerala
11 Akon 08-WY IT Gujarat
12 Bkon 09-WY IT Rajasthan

SubjectTable
subject_id subject_name teacher
1 Java Java Teacher
2 C++ C++ Teacher
3 Php Php Teacher

Score Table
In the Score table, we need to store some more information, which is the exam name and total marks, so let's
add 2 more columns to the Score table.
student_i subject_i
score_id marks
d d
1 10 1 70
2 10 2 75
3 11 1 80

Transitive Dependency
With exam_name and total_marks added to our Score table, it saves more data now. Primary key for the Score
table is a composite key, which means it's made up of two attributes or columns → student_id + subject_id.
The new column exam_name depends on both student and subject. For example, a mechanical engineering
student will have Workshop exam but a computer science student won't. And for some subjects you have
Practical exams and for some you don't. So we can say that exam_name is dependent on
both student_id and subject_id.
And what about our second new column total_marks? Does it depend on our Score table's primary key?

St. Joseph’s College of Engineering

CS1403 /Database design and Management Department of IT&AML 2022 - 2023
Systems
Well, the column total_marks depends on exam_name as with exam type the total score changes. For example,
practicals are of less marks while theory exams are of more marks.
But, exam_name is just another column in the score table. It is not a primary key or even a part of the primary
key, and total_marks depends on it.
This is Transitive Dependency. When a non-prime attribute depends on other non-prime attributes rather than
depending upon the prime attributes or primary key.
How to remove Transitive Dependency
Again the solution is very simple. Take out the columns exam_name and total_marks from Score table and put
them in an Exam table and use the exam_id wherever required.
Score Table: In 3rd Normal Form
student_i subject_
score_id marks exam_id
d id

The new Exam table

total_mark
exam_id exam_name
s
1 Workshop 200
2 Mains 70
3 Practicals 30
Advantage of removing Transitive Dependency
The advantage of removing transitive dependency is,
 Amount of data duplication isreduced.
 Data integrityachieved.
Boyce and Codd Normal Form (BCNF)
Boyce and Codd Normal Form is a higher version of the Third Normal form. This form deals with certain type
of anomaly that is not handled by 3NF. A 3NF table which does not have multiple overlapping candidate keys
is said to be in BCNF. For a table to be in BCNF, following conditions must be satisfied:
 R must be in 3rd NormalForm
 and, for each functional dependency ( X → Y ), X should be a super Key.In simple words, it means, that
for a dependency A → B, A cannot be a non-prime attribute, if B is a primeattribute.
Example
College enrolment table with columns student_id, subject and professor.
student_id subject professor
101 Java P.Java
101 C++ P.Cpp
102 Java P.Java2
103 C# P.Chash
104 Java P.Java
In the table above:
One student can enroll for multiple subjects. For example, student with student_id 101, has opted for subjects -
Java & C++
 For each subject, a professor is assigned to thestudent.
 And, there can be multiple professors teaching one subject like Java.
What do you think should be the PrimaryKey?

St. Joseph’s College of Engineering

CS1403 /Database design and Management Department of IT&AML 2022 - 2023
Systems
Well, in the table above student_id, subject together form the primary key, because
using student_id and subject, we can find all the columns of the table.
One more important point to note here is, one professor teaches only one subject, but one subject may have
two different professors.
Hence, there is a dependency between subject and professor here, where subject depends on the professor
name.
This table satisfies the 1st Normal form because all the values are atomic, column names are unique and all the
values stored in a particular column are of same domain.
This table also satisfies the 2nd Normal Form as there is no Partial Dependency.
And, there is no Transitive Dependency, hence the table also satisfies the 3rd Normal Form.
But this table is not in Boyce-Codd Normal Form.
Why this table is not in BCNF?
In the table above, student_id, subject form primary key, which means subject column is a prime attribute.
But, there is one more dependency, professor → subject.
And while subject is a prime attribute, professor is a non-prime attribute, which is not allowed by BCNF.
How to satisfy BCNF?
To make this relation(table) satisfy BCNF, we will decompose this table into two tables, student table
and professor table.
Below we have the structure for both the tables.
Student Table
student_id p_id
101 1
101 2
Professor Table
p_id professor subject
1 P.Java Java
2 P.Cpp C++
And now, this relation satisfy Boyce-Codd Normal Form.
Fourth Normal Form (4NF)
A table is said to be in the Fourth Normal Form when,
1. It is in the Boyce-Codd NormalForm.
2. And, it doesn't have Multi-ValuedDependency.
Multi-valued Dependency
A table is said to have multi-valued dependency, if the following conditions are true,
1. For a dependency A → B, if for a single value of A, multiple value of B exists, then the table mayhave
multi-valueddependency.
2. Also, a table should have at-least 3 columns for it to have a multi-valueddependency.
3. And, for a relation R(A,B,C), if there is a multi-valued dependency between, A and B, then B and C
should be independent of eachother.
If all these conditions are true for any relation(table), it is said to have multi-valued dependency.

St. Joseph’s College of Engineering

CS1403 /Database design and Management Department of IT&AML 2022 - 2023
Systems
Example
Below we have a college enrolment table with columns s_id, course and hobby.
cours
s_id hobby
e
Scienc
1 Cricket
e
1 Maths Hockey
2 C# Cricket
2 Php Hockey
From the table above, student with s_id 1 has opted for two courses, Science and Maths, and has two
hobbies, Cricket andHockey.
You must be thinking what problem this can lead to, right?
Well the two records for student with s_id 1, will give rise to two more records, as shown below, because for
one student, two hobbies exists, hence along with both the courses, these hobbies should be specified.
s_id course hobby
1 Science Cricket
1 Maths Hockey
1 Science Hockey
1 Maths Cricket
And, in the table above, there is no relationship between the columns course and hobby. They are independent
of each other.
So there is multi-value dependency, which leads to un-necessary repetition of data and other anomalies as
well.
How to satisfy 4th Normal Form?
To make the above relation satify the 4th normal form, we can decompose the table into 2 tables.
CourseOpted Table
s_id course
1 Science
1 Maths
2 C#
2 Php
Hobbies Table,
s_id hobby
1 Cricket
1 Hockey
2 Cricket
2 Hockey
Now this relation satisfies the fourth normal form.
A table can also have functional dependency along with multi-valued dependency. In that case, the
functionally dependent columns are moved in a separate table and the multi-valued dependent columns are
moved to separatetables.

St. Joseph’s College of Engineering

CS1403 /Database design and Management Department of IT&AML 2022 - 2023
Systems
Fifth Normal Form (5NF)
A database is said to be in 5NF, if and only if,
1. It's in4NF
2. If we can decompose table further to eliminate redundancy and anomaly, and when we re-join the
decomposed tables by means of candidate keys, we should not be losing the original data or anynew
record set should not arise. In simple words, joining two or more decomposed table should not lose
records nor create newrecords.
What is Join Dependency
If a table can be recreated by joining multiple tables and each of this table have a subset of the attributes of the
table, then the table is in Join Dependency. It is a generalization of Multivalued DependencyJoin Dependency
can be related to 5NF, wherein a relation is in 5NF, only if it is already in 4NF and it cannot be decomposed
further.
Example
<Employee>
EmpName EmpSkills EmpJob (Assigned Work)
Tom Networking EJ001
Harry WebDevelopment EJ002
Katie Programming EJ002

The above table can be decomposed into the following three tables; therefore it is not in 5NF:

<EmployeeSkills>
EmpName EmpSkills
Tom Networking
Harry WebDevelopment
Katie Programming
<EmployeeJob>
EmpName EmpJob
Tom EJ001
Harry EJ002
Katie EJ002
<JobSkills>
EmpSkills EmpJob
Networking EJ001
WebDevelopment EJ002
Programming EJ002

Our Join Dependency:

{(EmpName, EmpSkills ), ( EmpName, EmpJob), (EmpSkills, EmpJob)}

St. Joseph’s College of Engineering

CS1403 /Database design and Management Department of IT&AML 2022 - 2023
Systems
The above relations have join dependency, so they are not in 5NF. That would mean that a join relation of the
above three relations is equal to our original relation <Employee>.

FIFTH NORMAL FORM EXAMPLE

Consider an example of different Subjects taught by different lecturers and the lecturers taking classes for
different semesters.
Note: Please consider that Semester 1 has Mathematics, Physics and Chemistry and Semester 2 has only
Mathematics in its academic year!!

In above table, Rose takes both Mathematics and Physics class for Semester 1, but she does not take Physics
class for Semester 2. In this case, combination of all these 3 fields is required to identify a valid data. Imagine
we want to add a new class - Semester3 but do not know which Subject and who will be taking that subject.
We would be simply inserting a new entry with Class as Semester3 and leaving Lecturer and subject as NULL.
As we discussed above, it's not a good to have such entries. Moreover, all the three columns together act as a
primary key, we cannot leave other two columns blank!
Hence we have to decompose the table in such a way that it satisfies all the rules till 4NF and when join them
by using keys, it should yield correct record. Here, we can represent each lecturer's Subject area and their
classes in a better way. We can divide above table into three - (SUBJECT, LECTURER), (LECTURER,
CLASS), (SUBJECT, CLASS)

Now, each of combinations is in three different tables. If we need to identify who is teaching which subject to
which semester, we need join the keys of each table and get the result.
For example, who teaches Physics to Semester 1, we would be selecting Physics and Semester1 from table 3
above, join with table1 using Subject to filter out the lecturer names. Then join with table2 using Lecturer to
get correct lecturer name. That is we joined key columns of each table to get the correct data. Hence there is no
lose or new data - satisfying 5NF condition.

St. Joseph’s College of Engineering

CS1403 /Database design and Management Department of IT&AML 2022 - 2023
Systems
EMBEDDED SQL
Embedded SQL is a method of inserting inline SQL statements or queries into the code of a programming language,
which is known as a host language. Because the host language cannot parse SQL, the inserted SQL is parsed by an
embedded preprocessor.
Embedded SQL is a robust and convenient method of combining the computing power of a programming language
with SQL's specialized data management and manipulation capabilities.
Structure of embedded SQL
Structure of embedded SQL defines step by step process of establishing a connection with DB and executing the
code in the DB within the high level language.
Connection toDB
This is the first step while writing
a query in high level languages.
First connection to the DB that we
are accessing needs to be
established. This can be done using
the keyword CONNECT. But it
has to precede with ‗EXEC SQL‘
to indicate that it is a SQL
statement. EXEC SQL CONNECT
db_name;
EXEC SQL CONNECT HR_USER; //connects to DB HR_USER
Once connection is established with DB, we can perform DB transactions. Since these DB transactions are
dependent on the values and variables of the host language. Depending on their values, query will be written
and executed. Similarly, results of DB query will be returned to the host language which will be captured by
the variables of host language. Hence we need to declare the variables to pass the value to the query and get
the values from query. There are two types of variables used in the hostlanguage.
 Host variable : These are the variables of host language used to pass the value to the query as well as to capture
the values returned by the query. Since SQL is dependent on host language we have to use variables of host
language and such variables are known as host variable. But these host variables should be declared within
the SQL area or within SQL code. That means compiler should be able to differentiate it from normal C
variables. Hence we have to declare host variables within BEGIN DECLARE and END DECLARE section.
Again, these declare block should be enclosed within EXEC SQL and‗;‘.
EXEC SQL BEGIN DECLARE SECTION;
int STD_ID;
char STD_NAME [15];
char ADDRESS[20];
EXEC SQL END DECLARE SECTION;
We can note here that variables are written inside begin and end block of the SQL, but they are declared using
C code. It does not use SQL code to declare the variables. Why? This is because they are host variables –
variables of C language. Hence we cannot use SQL syntax to declare them. Host language supports almost all
the datatypes from int, char, long, float, double, pointer, array, string, structuresetc.
When host variables are used in a SQL query, it should be preceded by colon – ‗:‘ to indicate that it is a host
variable. Hence when pre-compiler compiles SQL code, it substitutes the value of host variable andcompiles.
St. Joseph’s College of Engineering
CS1403 /Database design and Management Department of IT&AML 2022 - 2023
Systems
EXEC SQL SELECT * FROM STUDENT WHERE STUDENT_ID =:STD_ID;
The following code is a simple embedded SQL program, written in C. The program illustrates many,
but not all, of the embedded SQL techniques. The program prompts the user for an order number,
retrieves the customer number, salesperson, and status of the order, and displays the retrieved
information on the screen.
int main() {
EXEC SQL INCLUDE SQLCA;
EXEC SQL BEGIN DECLARE SECTION;
intOrderID; /* Employee ID(fromuser) */
intCustID; /* Retrievedcustomer ID */
char SalesPerson[10] /* Retrievedsalespersonname */
charStatus[6] /* Retrievedorderstatus */
EXEC SQL END DECLARE SECTION;

/* Set up error processing */

EXEC SQL WHENEVER SQLERROR GOTO query_error;
EXEC SQL WHENEVER NOT FOUND GOTO
bad_number;

/* Prompt the user for order number */

printf ("Enter order number: ");
scanf_s("%d", &OrderID);

/* Execute the SQL query */

EXEC SQL SELECT CustID, SalesPerson,
Status FROM Orders
WHERE OrderID = :OrderID
INTO :CustID, :SalesPerson, :Status;
/* Display the results */
printf ("Customer number: %d\n",
CustID); printf ("Salesperson: %s\n",
SalesPerson); printf ("Status: %s\n",
Status);
exit();

query_error:
printf ("SQL error: %ld\n", sqlca-
>sqlcode); exit();

bad_number:
printf ("Invalid order number.\n");
exit(); }

St. Joseph’s College of Engineering

 CS1403 /Database design and Management Department of IT&AML 2022 - 2023
Systems
DYNAMIC SQL
The main disadvantage of embedded SQL is that it supports only static SQLs. If we need to build up
queries at run time, then we can use dynamic sql. That means if query changes according to user input, then it
always better to use dynamic SQL. Like we said above, the query when user enters student name alone and
when user enters both student name and address, is different. If we use embedded SQL, one cannot implement
this requirement in the code. In such case dynamic SQL helps the user to develop query depending on the
values entered by him, without making him know which query is being executed. It can also be used when we
do not know which SQL statements like Insert, Delete update or select needs to be used, when number of host
variables is unknown, or when datatypes of host variables are unknown or when there is direct reference to
DB objects like tables, views, indexes are required.
However this will make user requirement simple and easy but it may make query lengthier and complex. That
means depending upon user inputs, the query may grow or shrink making the code flexible enough to handle
all the possibilities. In embedded SQL, compiler knows the query in advance and pre-compiler compiles the
SQL code much before C compiles the code for execution. Hence embedded SQLs will be faster in execution.
But in the case of dynamic SQL, queries are created, compiled and executed only at the run time. This makes
the dynamic SQL little complex, and timeconsuming.
Since query needs to be prepared at run time, in addition to the structures discussed in embedded SQL, we
have threemore clauses indynamic SQL. Theseare mainly used to build the query and execute them at
runtime.
PREPARE
Since dynamic SQL builds a query at run time, as a first step we need to capture all the inputs from the user. It
will be stored in a string variable. Depending on the inputs received from the user, string variable is appended
with inputs and SQL keywords. These SQL like string statements are then converted into SQL query. This is
done by using PREPAREstatement.
For example, below is the small snippet from dynamic SQL. Here sql_stmt is a character variable, which
holds inputs from the users along with SQL commands. But is cannot be considered as SQL query as it is still
a sting value. It needs to be converted into a proper SQL query which is done at the last line using PREPARE
statement. Here sql_query is also a string variable, but it holds the string as a SQLquery.
EXECUTE
This statement is used to compile and execute the SQL statements prepared in
DB. EXEC SQL EXECUTE sql_query;
EXECUTEIMMEDIATE
This statement is used to prepare SQL statement as well as execute the SQL statements in DB. It performs the
task of PREPARE and EXECUTE in a singleline. EXEC SQL EXECUTE IMMEDIATE :sql_stmt;
Dynamic SQL will not have any SELECT queries and host variables. But it can be any other SQL statements
like insert, delete, update, grant etc. But when we use insert/ delete/ updates in this type, we cannot use host
variables. All the input values will be hardcoded. Hence the SQL statements can be directly executed using
EXECUTE IMMEDIATE rather than using PREPARE and then EXECUTE.
EXEC SQL EXECUTE IMMEDIATE ‗GRANT SELECT ON STUDENT TO Faculty‘;
EXEC SQL EXECUTE IMMEDIATE ‗DELETE FROM STUDENT WHERE STD_ID = 100‘;
EXEC SQL EXECUTE IMMEDIATE ‗UPDATE STUDENT SET ADDRESS = ‗Troy‘ WHERE STD_ID
=100‘;
St. Joseph’s College of Engineering