IMPLEMENTING TRANSACTION AND SECURITY doc

3B.1 Relational Database Desi
g
n
L
L
E
E
S
S
S
S
O
O
N
N
:
:
3
3
B
B
I
I
M
M
P
P
L
L
E
E

M
M
E
E
N
N
T
T
I
I
N
N
G
G
T
T
R
R
A
A
N
N
S
S
A
A
C
C
T
T

I
I
O
O
N
N
A
A
N
N
D
D
S
S
E
E
C
C
U
U
R
R
I
I
T
T
Y
Y
O
O

b
b
j
j
e
e
c
c
t
t
i
i
v
v
e
e
s
s
In this section, you will learn to:

Describe Transaction Processing

Describe Transaction Recovery

Define Transaction Log
 Identify the Concurrency Problems
 Identify the Types of Locks
 Define a Deadlock
 Describe the Security Scheme Concepts
 Establish the Security Scheme

3B.2
Relational Database Desi
g
n
Implementing Transaction and Security Lesson 3B / Slide 1 of 25©NIIT
Implementing Transaction and Security
Objectives
In this section, you will learn to:
•
Describe Transaction processing
•
Describe Transaction Recovery
•
Define Transaction Log
•
Identify the Concurrency Problems
•
Identify the Types of Locks
•
Define a Deadlock
•
Describe the Security Scheme Concepts
•
Establish the Security Scheme
I
I
N
N
S
S

T
T
R
R
U
U
C
C
T
T
O
O
R
R
N
N
O
O
T
T
E
E
S
S
Lesson Overview
The lesson introduces the concept of transaction processing, transaction recovery, and
transaction log. This lesson also describes concurrency problems that can occur in a
database and explains locking as a technique to avoid concurrency problems. In
addition, this lesson identifies the various security schemes and explains how to
establish a security scheme.

3B.3 Relational Database Desi
g
n
Implementing Transaction and Security Lesson 3B / Slide 2 of 25©NIIT
Implementing Transaction and Security
Pre-assessment Questions
1. Which SQL statements are used to create and delete tables?
a. DDL
b. DQL
c. DML
d. DCL
2. A _____ is a named, derived, virtual table that does not exist physically.
a. Source table
b. Query
c. View
d. Base table
3. Which type of view includes all rows but only some columns of the source table?
a. Joined
b. Column subset
c. Grouped
d. Row subset
3B.4
Relational Database Desi
g
n
Implementing Transaction and Security Lesson 3B / Slide 3 of 25©NIIT
Implementing Transaction and Security
Pre-assessment Questions (Contd )
4. Which data integrity constraint requires that a column contain a non-null value?
a. Entity integrity

b. Referential integrity
c. Business rules
d. Required data
5. For any event that causes a change in the contents of a table, a user can specify
an associated action that the DBMS should carry out. What is this action called?
a. Log
b. Trigger
c. Integrity
d. Relation
3B.5 Relational Database Desi
g
n
Implementing Transaction and Security Lesson 3B / Slide 4 of 25©NIIT
Implementing Transaction and Security
Solutions
Ans1. DDL
Ans2. View
Ans3. Column subset
Ans4. Required data
Ans5. Trigger
3B.6
Relational Database Desi
g
n
D
D
A
A
T
T

A
A
B
B
A
A
S
S
E
E
T
T
R
R
A
A
N
N
S
S
A
A
C
C
T
T
I
I
O
O

N
N
P
P
R
R
O
O
C
C
E
E
S
S
S
S
I
I
N
N
G
G
Implementing Transaction and Security Lesson 3B / Slide 5 of 25©NIIT
Implementing Transaction and Security
Database Transaction Processing
•
A transaction is a sequence of one or more SQL statements that
together form a logical unit of work.
•
All the statements that constitute a transaction must be executed

to maintain consistency of the database.
•
The DBMS is responsible for ensuring consistency of the database.
This holds true even if the application program aborts or a
hardware failure occurs in the middle of a transaction.
•
The DBMS must never allow a partial transaction.
•
To maintain consistency, the DBMS undoes all the changes made
by an incomplete transaction.
A transaction is a sequence of one or more SQL statements that together form a
logical unit of work. Each statement in a transaction performs a part of the task and
all the statements together complete the task. A transaction occurs when a database
is modified. All the statements that constitute a transaction must be executed to
maintain consistency of the database.
Let us consider an example of a typical transaction. A student orders for a book. The
order processing program will:
Query the table that contains the details of the books to check if the book is available.
Insert the order details into a table that holds the order details.
3B.7 Relational Database Desi
g
n
Update the table containing product details to reduce the quantity on hand by the
quantity ordered.
These three actions in the above sequence form a single logical transaction. The
concept of transaction processing is critical for programs that update a database
because it ensures the integrity of the database.
As a rule, the statements in a transaction are executed as a single unit of work in the
database. Either all the statements will be executed successfully, or none of the
statements will be executed.

The DBMS is responsible for ensuring consistency of the database. This holds true
even if the application program aborts or a hardware failure occurs in the middle of a
transaction. The DBMS must never allow a partial transaction.
Consider the above example of a transaction. If the order processing program aborts
after the second step, the database would reflect a partial transaction and be in an
inconsistent state. To maintain consistency, the DBMS undoes all the changes made
by an incomplete transaction as shown in the following figure. Therefore, a DBMS
guarantees that if a transaction executes some updates and a failure occurs before
completing the transaction, the updates are undone.
3B.8
Relational Database Desi
g
n
SELECT
UPDATE
UPDATE
DELETE
Program
Error!
DBMS
undoes all
changes
Transaction
The SQL Transaction Concept
SELECT
UPDATE
UPDATE
DELETE
INSERT
Database state after

transaction
Database state before
transaction
SELECT
UPDATE
Hardware
Failure
DBMS
undoes all
changes
3B.9 Relational Database Desi
g
n
Transaction Recovery
Implementing Transaction and Security Lesson 3B / Slide 6 of 25©NIIT
Implementing Transaction and Security
Transaction Recovery
•
The two SQL operations that support transaction processing are:
•
COMMIT operation
•
ROLLBACK operation
The two SQL operations that support transaction processing are:

The COMMIT operation
This signifies a successful end-of-transaction. It confirms the DBMS that a logical
unit of work has been successfully completed. The database is consistent and all
updates made by the transaction have been committed or made permanent.
The ROLLBACK operation

This signals an unsuccessful end-of-transaction. It specifies that there has been
a failure and the database is inconsistent. All updates made by the transaction
till the point of failure must be rolled back or undone.
3B.10
Relational Database Desi
g
n
Transaction Log
Implementing Transaction and Security Lesson 3B / Slide 7 of 25©NIIT
Implementing Transaction and Security
Transaction Log
•
To undo the changes made to a database, the DBMS maintains a
transaction log.
•
The transaction log tracks all the transactions made.
•
When a user executes a SQL statement that modifies the database,
the DBMS writes a record in the transaction log.
•
The transaction log displays the following two copies of each row
affected by the statement. One copy displays the row before the
statement was executed and the other copy displays the row with
the changes.
•
If the user executes a commit, the end-of-transaction is noted in
the transaction log. If the user executes a ROLLBACK, the DBMS
examines the log to find the copy of the rows before the change.
To undo the changes made to a database, the DBMS maintains a transaction log. The
transaction log tracks all the transactions made.

When a user executes a SQL statement that modifies the database, the DBMS actually
writes a record in the transaction log. The transaction log displays two copies of each
row affected by the statement. One copy displays the row before the statement was
executed and the other copy displays the row with the changes. The DBMS modifies
the row on the disk only after the log is written. If the user executes a commit, the
end-of-transaction is noted in the transaction log. If the user executes a ROLLBACK,
the DBMS examines the log to find the copy of the rows before the change. Using this,
the DBMS restores the database to its earlier state, undoing all changes made during
the transaction. The following figure illustrates the way in which the transaction log
works in an RDBMS.
3B.11 Relational Database Desi
g
n
UPDATE
INSERT
COMMIT
DBMS
Transaction Log
Row Location:
Before:
After: (empty)
Row Location:
Before:
After: (empty)
Row Location:
Before:
After: (empty)
Row Location:
Before:
After:

Transaction
Committed
The Transaction Log
SQL statement sequence
Time: 12:01
Time: 12:04
Time: 12:05
Time: 12:06
DELETE
3B.12
Relational Database Desi
g
n
Concurrency Problem
Implementing Transaction and Security Lesson 3B / Slide 8 of 25©NIIT
Implementing Transaction and Security
Concurrency Problem
•
Transaction processing is complicated in multi-user systems.
•
The DBMS needs to recover properly from system failures or
errors, and also ensure that the users’ actions do not interfere with
each other.
•
There are three problems that can occur in a multi-user
environment:
•
The lost update problem
•
The uncommitted dependency problem

•
The inconsistent data problem
•
The most popular way of ensuring concurrency control is the
mechanism of locking.
Transaction processing is complicated in multi-user systems. The DBMS needs to
recover properly from system failures or errors, and also ensure that the users’
actions do not interfere with each other. Each user must be able to access the
database without worrying about the actions of other users. There are three problems
that can occur in a multi-user environment:
The lost update problem
The uncommitted dependency problem
The inconsistent data problem
We will discuss each of these in detail here.
3B.13 Relational Database Desi
g
n
The Lost Update Problem
Consider the previous example of an order processing application. Suppose, the
quantity on hand for the book is 500 units. User A receives an order of 300 units for
the book at 1400 hours. User B receives an order of 400 units for the same book at
1410 hours. User A updates the quantity on hand for the book at 1405 hours based on
the value displayed before 1400 hours. The update value for quantity on hand
becomes 200 units (500-300). User B then updates the same record at 1412 hours
based on the value displayed at 1400 hours. The updated value becomes 100 units
(500-400).
The handling of these two transactions makes the database inconsistent. The first
update of user A is lost. It is overwritten by user B’s transaction. Both the orders for
the book are accepted, but there are not enough units of the book to satisfy both the
orders. Further, the database displays that there are still 100 units of the book in

stock.
The Uncommitted Dependency Problem
Suppose there are 200 units of the book. At 1200 hours, user A receives an order for
150 units. User A checks the products table, finds that there are 200 units available,
and updates the table to display 50 units remaining. The transaction is not committed.
At 1205 hours, user B receives an order for 100 units of the book. User B checks the
products table and finds that only 50 units are available. The order is not accepted. At
1210 hours, user A rolls back the transaction because the customer decided to cancel
the order.
As user B was allowed to view the uncommitted data, the order from the second
customer was refused. In case user B’s customer had decided to take the 50 available
units of the book, user B would have updated the table to display zero units available.
However, when user A issued a ROLLBACK, the value of available units would be set
back to 200 units, even though 50 units of the book have been committed to user B’s
customer. The problem is that the user who was allowed to view uncommitted data
has acted upon the data thereby producing errors.
The Inconsistent Data Problem
Assume that user A runs a report program that scans the orders table, a list of orders,
and computes their total. Suppose a situation occurs where the program retrieves
order number 100066, prints it, and adds the value of the order, say 100$ to the
total. Meanwhile, the customer who had placed the order calls user A to cancel the
previous order and place a substitute order for $120. The order entry program handles
the modification successfully. A few seconds later, the report program encounters this
new order, prints it, and adds $120 to the total.
3B.14
Relational Database Desi
g
n
Therefore, the report program includes the values of both the orders. This is different
from the uncommitted data problem. Here, the report program has processed both,

the data before and after the change, and this produced erroneous results.
As the above examples prove, when users share access to a database, there may be
data corruption. Therefore, if two transactions are executed simultaneously, there
must be a method by which DBMS ensures that the results will be the same
irrespective of who accesses the data first.
The most popular way of ensuring concurrency control is the mechanism of locking.
I
I
N
N
S
S
T
T
R
R
U
U
C
C
T
T
O
O
R
R
N
N
O
O

T
T
E
E
S
S
Database Transaction Processing
You can give the following additional information about transaction processing and
transaction recovery:
A transaction is required to maintain the following:
1. Correctness: Each transaction must be a program that preserves database
consistency.
2. Atomicity: All or none of the operations associated with a transaction must be
completely executed.
Ensuring correctness is the responsibility of the application programmer, while
ensuring atomicity is the responsibility of the transaction management component of
the database system.
Transaction processing is supported by two transaction recovery statements:
1. COMMIT
2. ROLLBACK
A transaction that successfully completes its execution is termed as a committed
transaction. A committed transaction transforms the database from one consistent
state to another consistent state. In case a transaction fails to complete its execution
successfully, it is termed as an aborted transaction. To maintain atomicity in the
database, it needs to be ensured that the aborted transaction does not affect the state
of the database. Therefore, the state of the database needs to be restored to the state
before the start of the transaction. This is called rollback of a transaction. The effect of
3B.15 Relational Database Desi
g
n

a committed transaction cannot be undone by aborting the transaction. It can be
undone only by writing and executing a compensating transaction.
Ask the students to define a transaction log and identify its function. This will help
students recall the information about transaction log.
You can give the following additional information about concurrency problems:
In a multiprogramming environment, several transactions may be executed
concurrently. This may give rise to database inconsistencies despite individual
transactions executing with correctness. The consistency in such cases can be
maintained by the concept of serializability. One way to ensure serializability is by
ensuring that data items are accessed in a mutually exclusive manner. In this way,
when one transaction accesses a data item, no other transaction can modify that data
item. This can be effectively implemented by ensuring that a transaction needs to hold
a lock on a data item to be able to access it.
3B.16
Relational Database Desi
g
n
L
L
O
O
C
C
K
K
I
I
N
N
G

G
Implementing Transaction and Security Lesson 3B / Slide 9 of 25©NIIT
Implementing Transaction and Security
Locking
•
When a transaction needs to be sure that a particular database
object must not change unpredictably while it is not aware of such
a change happening, it acquires a lock.
•
The effect of the lock is to lock all other transactions out, and thus
prevent them from changing the database object.
•
The first transaction will process the object and the object will
remain stable as long as the transaction requires it to be so.
•
The locking technique solves all three of the concurrency problems.
•
Locking may cause a transaction to wait for a long time while the
part of the database that it wants to access is locked by other
transactions.
When a transaction needs to be sure that a particular database object must not
change unpredictably while it is not aware of such a change happening, it acquires a
lock. The effect of this lock is to lock all other transactions out, and thus prevent them
from changing the database object. The first transaction will process the object and
the object will remain stable as long as the transaction requires it to be so.
Suppose transaction A accesses the database. The DBMS locks every piece of data
that the transaction modifies. Transaction B starts processing at the same time. The
DBMS also locks the part of the database that it accesses. If transaction B tries to
access a part of the database that has been locked by transaction A, the DBMS will
block the access and the transaction B will have to wait until the data is unlocked. The

DBMS releases the lock held by transaction A as soon as a COMMIT or ROLLBACK
operation is executed.
3B.17 Relational Database Desi
g
n
The DBMS then allows transaction B to proceed. Transaction B can now lock the same
piece of database, protecting it from other transactions.
Types of Locks
Implementing Transaction and Security Lesson 3B / Slide 10 of 25©NIIT
Implementing Transaction and Security
Types of Locks
•
There are basically two types of locks:
•
Shared: A shared lock is used by the DBMS when a
transaction wants to read data from the database. Another
transaction occurring at the same time can also acquire a
shared lock on the same data, allowing the other transaction
to read the data.
•
Exclusive: An exclusive lock is used by the DBMS when a
transaction wants to update data in the database. When a
transaction has an exclusive lock on some data, no other
transaction can acquire either an exclusive or a shared lock on
the same data.
There are basically two types of locks:
Shared

Exclusive
A shared lock is used by the DBMS when a transaction wants to read data from the

database. Another transaction occurring at the same time can also acquire a shared
lock on the same data, allowing the other transaction to read the data.
An exclusive lock is used by the DBMS when a transaction wants to update data in the
database. When a transaction has an exclusive lock on some data, no other
transaction can acquire either an exclusive or a shared lock on the same data.
If transaction A holds an exclusive lock on some data and transaction B requests
either type of lock on the same data, transaction B will have to wait until the lock is
released.
3B.18
Relational Database Desi
g
n
If transaction A holds a shared lock on some data and transaction B requests for an
exclusive lock on the same data, transaction B will have to wait until transaction A’s
lock is released.
If transaction A holds a shared lock and transaction B also requests for a shared lock,
transaction B’s request will be granted. Both the transactions will hold shared locks on
the same data.
Therefore, the locking technique solves all three of the concurrency problems. It
prevents lost updates, uncommitted dependencies, and inconsistent data from
corrupting the database. However, locking introduces a new problem. It may cause a
transaction to wait for a long time while the part of the database that it wants to
access is locked by other transactions.
Deadlock
Implementing Transaction and Security Lesson 3B / Slide 11 of 25©NIIT
Implementing Transaction and Security
Deadlock
•
Locking can introduce the problem of deadlock.
•

Deadlock is a situation in which two or more transactions are in a
simultaneous wait state, each one waiting for one of the others to
release a lock before it can proceed.
•
To deal with deadlocks, the DBMS periodically checks the locks
held by various transactions.
•
When it detects a deadlock, the DBMS chooses one of the
transactions as the deadlock loser and rolls back that transaction.
It releases the lock held by the transaction and allows the other
transaction to proceed.
•
The losing transaction receives an error message, informing that it
has lost the deadlock, and its transactions have been rolled back.
•
If a deadlock loss occurs in interactive SQL, the SQL statement can
be retyped.
•
If a deadlock occurs in an application program, the application
program must be prepared to handle this situation.
Locking can introduce the problem of deadlock. Deadlock is a situation in which two or
more transactions are in a simultaneous wait state, each one waiting for one of the
others to release a lock before it can proceed.
3B.19 Relational Database Desi
g
n
Consider a situation where program A updates the orders table, thereby locking a part
of it. Program B updates the products table, locking part of it. Program A now needs to
update the products table and program B needs to update the orders table. Each
program tries to update a part of the table that is not locked by the other program.

Each program waits for the other program to commit the transaction and unlock the
data.
This is an example that involves two transactions. There are times when four or five
transactions may be involved in a deadlock, creating further complication.
To deal with deadlocks, the DBMS periodically checks the locks held by various
transactions. When it detects a deadlock, the DBMS chooses one of the transactions as
the deadlock loser and rolls back that transaction. It releases the lock held by the
transaction and allows the other transaction to proceed.
The losing transaction receives an error message, informing that it has lost the
deadlock, and its transactions have been rolled back. This method prevents an eternal
deadlock or database corruption. If a deadlock loss occurs in interactive SQL, the SQL
statement can be retyped. If a deadlock occurs in an application program, the
application program must be prepared to handle this situation.
I
I
N
N
S
S
T
T
R
R
U
U
C
C
T
T
O

O
R
R
N
N
O
O
T
T
E
E
S
S
Deadlock
A system is in a state of deadlock if there exists a set of transactions such that every
transaction in a set is waiting for another transaction in the set. There are two primary
methods of handling deadlocks:
1. Use a deadlock prevention protocol to ensure that the system will never enter
a deadlock state.
2. Allow the system to enter a deadlock state and then try to recover using a
deadlock detection and recovery scheme.
Deadlock prevention:
The various deadlock prevention schemes are:
1. Each transaction locks all its data before beginning its execution
3B.20
Relational Database Desi
g
n
2. Using the nonpreemptive technique of wait-die scheme. In this scheme, when
a transaction requests a data item held by another transaction, the requesting

transaction is allowed to wait only if it has a smaller timestamp than the other
transaction. Otherwise, the requesting transaction is rolled back.
3. Using the preemptive technique of wound-wait scheme. In this scheme, when
a transaction requests a data item held by another transaction, the requesting
transaction is allowed to wait only if it has a larger timestamp than the other
transaction. Otherwise, the transaction holding the data item is rolled back.
The various features of deadlock detection and recovery are:
1. Maintaining information about the current allocation of data items to
transactions, as well as any outstanding data item requests.
2. Providing an algorithm that uses this information to determine whether the
system has entered a deadlock state.
3. Recovering from the deadlock when the detection algorithm determines that a
deadlock exists.
3B.21 Relational Database Desi
g
n
D
D
A
A
T
T
A
A
B
B
A
A
S
S

E
E
S
S
E
E
C
C
U
U
R
R
I
I
T
T
Y
Y
Implementing Transaction and Security Lesson 3B / Slide 12 of 25©NIIT
Implementing Transaction and Security
Database Security
•
The security requirements of a database are many and varied.
•
Some typical examples of security requirements are:
•
Data in a table should be accessible to only selected users.
•
Selected users should be allowed to update data while other
users should only be allowed to view and retrieve data.

•
For some tables, access should be restricted on a
column-by-column basis.
•
Selected users should only be allowed to access tables using
application programs.
•
Enforcing security restrictions is a responsibility of the DBMS.
The data of an organization is its most important asset. Therefore, maintaining its
security is of tremendous concern to the organization. The security requirements of a
database are many and varied. Some typical examples of security requirements are:

Data in a table should be accessible to only selected users.
Selected users should be allowed to update data while other users should only
be allowed to view and retrieve data.
For some tables, access should be restricted on a column-by-column basis.
Selected users should only be allowed to access tables using application
programs.
Enforcing security restrictions is a responsibility of the DBMS.
3B.22
Relational Database Desi
g
n
Security Scheme Concepts
Implementing Transaction and Security Lesson 3B / Slide 13 of 25©NIIT
Implementing Transaction and Security
Security Scheme Concepts
•
The security scheme of a DBMS is based on three concepts:
•

Users
•
Database objects
•
Privileges
The security scheme of a DBMS is based on three concepts:

Users

Database objects
Privileges
Users access the database. Every time the DBMS inserts, updates, deletes, or selects
a row, or performs any other operation, it does so on behalf of the users. The DBMS
permits or prevents actions on the database, depending on which the user is making
the request. As stated earlier, some users may not be authorized to perform certain
operations. We will examine this in detail during this session.
Database objects are items to which security can be applied. Security restrictions
are usually applied to tables and views. However, security can also be applied to other
objects like application programs.
3B.23 Relational Database Desi
g
n
Privileges are actions that a user is permitted to perform on a given database object.
In this session, we will look at the various privileges, and how they are granted to
users.
Users
Implementing Transaction and Security Lesson 3B / Slide 14 of 25©NIIT
Implementing Transaction and Security
Users
•

Each user is assigned a user-id that identifies the user to the DBMS
software.
•
The user-id determines whether the statement will be permitted or
prevented by the DBMS.
•
In most DBMSs, both a user-id and an associated password must
be specified. The DBMS checks the password to verify if the user is
authorized to specify the user-id supplied.
•
Depending on the situation:
•
Each user is assigned a separate user-id.
•
A user-id is assigned to two or more users.
•
In a large production database, there are groups of users with
similar needs. Within each group, all users have identical needs for
data access.
Each user is assigned a user-id that identifies the user to the DBMS software. User-ids
are assigned by the DBA. The user-id determines whether the statement will be
permitted or prevented by the DBMS. If the user-id is authorized to perform the
requested operation, the DBMS permits the user to perform the operation, else it
prevents the user from doing so.
In most DBMSs, both a user-id and an associated password must be specified. The
DBMS checks the password to verify if the user is authorized to specify the user-id
supplied. This is how DBMS double-checks the authority of the user.
Depending on the situation:
Each user is assigned a separate user-id.
3B.24

Relational Database Desi
g
n
A user-id is assigned to two or more users.
In a large production database, there are groups of users with similar needs. Within
each group, all users have identical needs for data access. For convenience, the same
user-id may be assigned to every person in the group. For example, the people in the
order processing department form a user group. All the people in this group need to
access the same data that is probably, data about products and customers. Thus,
these persons will share the same user-id and have the same access rights on the
same database objects.
Database Objects
Implementing Transaction and Security Lesson 3B / Slide 15 of 25©NIIT
Implementing Transaction and Security
Database Objects
•
Security restrictions apply to specific objects in a database.
•
The objects to which security can be applied are:
•
Tables
•
Views
•
Each table or view can be individually protected.
•
Access to a table or view can be permitted to some users and
prevented from others.
Security restrictions apply to specific objects in a database. The objects to which
security can be applied are:

Tables
Views
3B.25 Relational Database Desi
g
n
Each table or view can be individually protected. Access to a table or view can be
permitted to some users and prevented from others.
Privileges
Implementing Transaction and Security Lesson 3B / Slide 16 of 25©NIIT
Implementing Transaction and Security
Privileges
•
Privileges are the set of actions that a user can perform on a
database object.
•
Four privileges can be specified for tables and views. These are:
•
SELECT privilege
•
INSERT privilege
•
DELETE privilege
•
UPDATE privilege
•
The owner of a table has all the privileges for that table.
•
The owner can also grant other users the privileges to access that
table.
•

The owner of a view has only the SELECT privilege.
•
To get the other privileges, the owner of a view must be granted
these privileges on the source table of the view.
Privileges are the set of actions that a user can perform on a database object. Four
privileges can be specified for tables and views. These are:
SELECT privilege
INSERT privilege
DELETE privilege
UPDATE privilege
The SELECT privilege allows you to retrieve data from a table or view. If you have this
privilege, you can specify the table or view name with the FROM clause of the SELECT
statement.