Manipulating Data

Objectives
After completing this lesson, you should be able to
do the following:
• Describe each DML statement
• Insert rows into a table
• Update rows in a table
• Delete rows from a table
• Merge rows in a table
• Control transactions
 Data Manipulation Language
• A DML statement is executed when you:
– Add new rows to a table
– Modify existing rows in a table
– Remove existing rows from a table
• A transaction consists of a collection of DML
statements that form a logical unit of work.
 Adding a New Row to a Table
New
DEPARTMENTS row

…insert a new row

into the
DEPARMENTS
table…
The INSERT Statement Syntax
• Add new rows to a table by using the INSERT
statement.
INSERT INTO table [(column [, column...])]
VALUES (value [, value...]);

• Only one row is inserted at a time with this syntax.

 Inserting New Rows
• Insert a new row containing values for each column.
• List values in the default order of the columns in the
table.
• Optionally, list the columns in the INSERT clause.

INSERT INTO departments(department_id, department_name,

manager_id, location_id)
VALUES (70, 'Public Relations', 100, 1700);
•1 Enclose character and date values within single
row created.
quotation marks.
Inserting Rows with Null Values
• Implicit method: Omit the column from the
column list.
INSERT INTO departments (department_id,
department_name )
VALUES (30, 'Purchasing');
1 row created.

• Explicit method: Specify the NULL keyword in the

VALUES clause.
INSERT INTO departments
VALUES (100, 'Finance', NULL, NULL);
1 row created.
 Inserting Special Values
The SYSDATE function records the current date
and time.
INSERT INTO employees (employee_id,
first_name, last_name,
email, phone_number,
hire_date, job_id, salary,
commission_pct, manager_id,
department_id)
VALUES (113,
'Louis', 'Popp',
'LPOPP', '515.124.4567',
SYSDATE, 'AC_ACCOUNT', 6900,
NULL, 205, 100);
1 row created.
 Inserting Specific Date Values
• Add a new employee.
INSERT INTO employees
VALUES (114,
'Den', 'Raphealy',
'DRAPHEAL', '515.127.4561',
TO_DATE('FEB 3, 1999', 'MON DD, YYYY'),
'AC_ACCOUNT', 11000, NULL, 100, 30);
1 row created.
• Verify your addition.
 Creating a Script
• Use & substitution in a SQL statement to prompt
for values.
• & is a placeholder for the variable value.
INSERT INTO departments
(department_id, department_name, location_id)
VALUES (&department_id, '&department_name',&location);

1 row created.
 Copying Rows
from Another Table
• Write your INSERT statement with a subquery.
INSERT INTO sales_reps(id, name, salary, commission_pct)
SELECT employee_id, last_name, salary, commission_pct
FROM employees
WHERE job_id LIKE '%REP%';

4 rows created.
• Do not use the VALUES clause.
• Match the number of columns in the INSERT clause
to those in the subquery.
 Changing Data in a Table
EMPLOYEES

Update rows in the EMPLOYEES table.

The UPDATE Statement Syntax
• Modify existing rows with the UPDATE statement.
UPDATE table
SET column = value [, column = value, ...]
[WHERE condition];

• Update more than one row at a time, if required.

 Updating Rows in a Table
• Specific row or rows are modified if you specify
the WHERE clause.
UPDATE employees
SET department_id = 70
WHERE employee_id = 113;
1 row updated.
• All rows in the table are modified if you omit the
WHERE clause.
UPDATE copy_emp
SET department_id = 110;
22 rows updated.
 Updating Two Columns with a
Subquery
Update employee 114’s job and salary to match that of
employee 205.
UPDATE employees
SET job_id = (SELECT job_id
FROM employees
WHERE employee_id = 205),
salary = (SELECT salary
FROM employees
WHERE employee_id = 205)
WHERE employee_id = 114;
1 row updated.
 Updating Rows Based
on Another Table
Use subqueries in UPDATE statements to update
rows in a table based on values from another table.
UPDATE copy_emp
SET department_id = (SELECT department_id
FROM employees
WHERE employee_id = 100)
WHERE job_id = (SELECT job_id
FROM employees
WHERE employee_id = 200);
1 row updated.
 Updating Rows:
Integrity Constraint Error

UPDATE employees
SET department_id = 55
WHERE department_id = 110;

UPDATE employees
*
ERROR at line 1:
ORA-02291: integrity constraint (HR.EMP_DEPT_FK)
violated - parent key not found
Removing a Row from a Table
DEPARTMENTS

Delete a row from the DEPARTMENTS table.

 The DELETE Statement

You can remove existing rows from a table by using

the DELETE statement.
DELETE [FROM] table
[WHERE condition];
 Deleting Rows from a Table
• Specific rows are deleted if you specify the WHERE
clause.
DELETE FROM departments
WHERE department_name = 'Finance';
1 row deleted.

• All rows in the table are deleted if you omit the

WHERE clause.

DELETE FROM copy_emp;

22 rows deleted.
 Deleting Rows Based
on Another Table
Use subqueries in DELETE statements to remove
rows from a table based on values from another table.

DELETE FROM employees

WHERE department_id =
(SELECT department_id
FROM departments
WHERE department_name LIKE '%Public%');
1 row deleted.
 Deleting Rows:
Integrity Constraint Error

DELETE FROM departments

WHERE department_id = 60;

DELETE FROM departments

*
ERROR at line 1:
ORA-02292: integrity constraint (HR.EMP_DEPT_FK)
violated - child record found
 Using a Subquery in an INSERT
Statement
INSERT INTO
(SELECT employee_id, last_name,
email, hire_date, job_id, salary,
department_id
FROM employees
WHERE department_id = 50)
VALUES (99999, 'Taylor', 'DTAYLOR',
TO_DATE('07-JUN-99', 'DD-MON-RR'),
'ST_CLERK', 5000, 50);

1 row created.
 Using a Subquery in an INSERT
Statement
• Verify
SELECT the results last_name, email, hire_date,
employee_id,
job_id, salary, department_id
FROM employees
WHERE department_id = 50;
 Database Transactions
A database transaction consists of one of the
following:
• DML statements which constitute one consistent
change to the data
• One DDL statement
• One DCL statement
 Database Transactions
• Begin when the first DML SQL statement is
executed
• End with one of the following events:
– A COMMIT or ROLLBACK statement is issued
– A DDL or DCL statement executes (automatic
commit)
– The user exits iSQL*Plus
– The system crashes
 Advantages of COMMIT
and ROLLBACK Statements
With COMMIT and ROLLBACK statements, you can:
• Ensure data consistency
• Preview data changes before making changes
permanent
• Group logically related operations
 Controlling Transactions
Time COMMIT
Transaction

DELETE
SAVEPOINT A
INSERT

UPDATE
SAVEPOINT B
INSERT ROLLBACK ROLLBACK ROLLBACK
to SAVEPOINT B to SAVEPOINT A
 Rolling Back Changes
to a Marker
• Create a marker in a current transaction by using the
SAVEPOINT statement.
• Roll back to that marker by using the ROLLBACK
TO SAVEPOINT statement.
UPDATE...
SAVEPOINT update_done;
Savepoint created.
INSERT...
ROLLBACK TO update_done;
Rollback complete.
Implicit Transaction Processing
• An automatic commit occurs under the following
circumstances:
– DDL statement is issued
– DCL statement is issued
– Normal exit from iSQL*Plus, without explicitly
issuing COMMIT or ROLLBACK statements
• An automatic rollback occurs under an abnormal
termination of iSQL*Plus or a system failure.
 State of the Data
Before COMMIT or ROLLBACK
• The previous state of the data can be recovered.
• The current user can review the results of the DML
operations by using the SELECT statement.
• Other users cannot view the results of the DML
statements by the current user.
• The affected rows are locked; other users cannot
change the data within the affected rows.
State of the Data after COMMIT
• Data changes are made permanent in the database.
• The previous state of the data is permanently lost.
• All users can view the results.
• Locks on the affected rows are released; those rows
are available for other users to manipulate.
• All savepoints are erased.
 Committing Data
• Make the changes.
DELETE FROM employees
WHERE employee_id = 99999;
1 row deleted.

INSERT INTO departments

VALUES (290, 'Corporate Tax', NULL, 1700);
1 row inserted.

• Commit the changes.

COMMIT;
Commit complete.
State of the Data After ROLLBACK
Discard all pending changes by using the ROLLBACK
statement:
• Data changes are undone.
• Previous state of the data is restored.
• Locks on the affected rows are released.

DELETE FROM copy_emp;

22 rows deleted.
ROLLBACK;
Rollback complete.
 Statement-Level Rollback
• If a single DML statement fails during execution, only
that statement is rolled back.
• The Oracle server implements an implicit savepoint.
• All other changes are retained.
• The user should terminate transactions explicitly by
executing a COMMIT or ROLLBACK statement.
 Read Consistency
• Read consistency guarantees a consistent view of
the data at all times.
• Changes made by one user do not conflict with
changes made by another user.
• Read consistency ensures that on the same data:
– Readers do not wait for writers.
– Writers do not wait for readers.
 Implementation of Read Consistency
User A
UPDATE employees Data
SET salary = 7000 blocks
WHERE last_name = 'Goyal';

Rollback
segments

changed
SELECT * and
FROM userA.employees; Read unchanged
consistent data
image before
change
“old” data
User B
 Locking
In an Oracle database, locks:
• Prevent destructive interaction between
concurrent transactions
• Require no user action
• Are held for the duration of the transaction
• Are of two types: explicit locking and implicit
locking
 Implicit Locking
• Two lock modes:
– Exclusive: Locks out other users
– Share: Allows other users to access
• High level of data concurrency:
– DML: Table share, row exclusive
– Queries: No locks required
– DDL: Protects object definitions
• Locks held until commit or rollback