External tables

Oracle Database allows you read-only access to data in external tables. External tables are defined as tables that
do not reside in the database, and can be in any format for which an access driver is provided. By providing the
database with metadata describing an external table, the database is able to expose the data in the external table
as if it were data residing in a regular database table. The external data can be queried directly and in parallel
using SQL.

You can, for example, select, join, or sort external table data. You can also create views and synonyms for external
tables. However, no DML operations (UPDATE, INSERT, or DELETE) are possible, and no indexes can be created, on
external tables.
External tables provide a framework to unload the result of an arbitrary SELECT statement into a platformindependent Oracle-proprietary format that can be used by Oracle Data Pump. External tables provide a valuable
means for performing basic extraction, transformation, and loading (ETL) tasks that are common for data
warehousing.

The means of defining the metadata for external tables is through the CREATE TABLE...ORGANIZATION EXTERNAL
statement. This external table definition can be thought of as a view that allows running any SQL query against
external data without requiring that the external data first be loaded into the database. An access driver is the
actual mechanism used to read the external data in the table. When you use external tables to unload data, the
metadata is automatically created based on the data types in the SELECT statement.

Oracle Database provides two access drivers for external tables. The default access driver is ORACLE_LOADER,
which allows the reading of data from external files using the Oracle loader technology. The ORACLE_LOADER
access driver provides data mapping capabilities which are a subset of the control file syntax of SQL*Loader utility.
The second access driver, ORACLE_DATAPUMP, lets you unload datathat is, read data from the database and
insert it into an external table, represented by one or more external filesand then reload it into an Oracle
Database.

You create external tables using the CREATE TABLE statement with an ORGANIZATION EXTERNAL clause. This
statement creates only metadata in the data dictionary.
Note: External tables cannot have virtual columns.
The file emp1.dat contains the following sample data:
360,Jane,Janus,ST_CLERK,121,17-MAY-2001,3000,0,50,jjanus
361,Mark,Jasper,SA_REP,145,17-MAY-2001,8000,.1,80,mjasper
362,Brenda,Starr,AD_ASST,200,17-MAY-2001,5500,0,10,bstarr
363,Alex,Alda,AC_MGR,145,17-MAY-2001,9000,.15,80,aalda
The file emp2.dat contains the following sample data:
401,Jesse,Cromwell,HR_REP,203,17-MAY-2001,7000,0,40,jcromwel
402,Abby,Applegate,IT_PROG,103,17-MAY-2001,9000,.2,60,aapplega
403,Carol,Cousins,AD_VP,100,17-MAY-2001,27000,.3,90,ccousins
404,John,Richardson,AC_ACCOUNT,205,17-MAY-2001,5000,0,110,jrichard
The following SQL statements create an external table named admin_ext_employees in the hr schema and load
data from the external table into the hr.employees table.

CONNECT

AS SYSDBA;

CREATE OR REPLACE DIRECTORY admin_dat_dir

CREATE OR REPLACE DIRECTORY admin_log_dir
CREATE OR REPLACE DIRECTORY admin_bad_dir

AS '/flatfiles/data';
AS '/flatfiles/log';
AS '/flatfiles/bad';

GRANT READ ON DIRECTORY admin_dat_dir TO hr;

GRANT WRITE ON DIRECTORY admin_log_dir TO hr;
GRANT WRITE ON DIRECTORY admin_bad_dir TO hr;
-- create the external table

CREATE TABLE admin_ext_employees

(employee_id
NUMBER(4),
first_name
VARCHAR2(20),
last_name
VARCHAR2(25),
job_id
VARCHAR2(10),
manager_id
NUMBER(4),
hire_date
DATE,
salary
NUMBER(8,2),
commission_pct
NUMBER(2,2),
department_id
NUMBER(4),
email
VARCHAR2(25)
)
ORGANIZATION EXTERNAL
(
TYPE ORACLE_LOADER
DEFAULT DIRECTORY admin_dat_dir
ACCESS PARAMETERS
(
records delimited by newline
badfile admin_bad_dir:'empxt%a_%p.bad'
logfile admin_log_dir:'empxt%a_%p.log'
fields terminated by ','
missing field values are null
( employee_id, first_name, last_name, job_id, manager_id,
hire_date char date_format date mask "dd-mon-yyyy",
salary, commission_pct, department_id, email
)
)
LOCATION ('empxt1.dat', 'empxt2.dat')
)
PARALLEL
REJECT LIMIT UNLIMITED;
-- enable parallel for loading (good if lots of data to load)

ALTER SESSION ENABLE PARALLEL DML;

-- load the data in hr employees table

INSERT INTO employees (employee_id, first_name, last_name, job_id, manager_id,

hire_date, salary, commission_pct, department_id, email)
SELECT * FROM admin_ext_employees;
The following paragraphs contain descriptive information about this example.
The first few statements in this example create the directory objects for the operating system directories that
contain the data sources, and for the bad record and log files specified in the access parameters. You must also
grant READ or WRITE directory object privileges, as appropriate.

The TYPE specification indicates the access driver of the external table. The access driver is the API that interprets
the external data for the database. If you omit the TYPE specification, ORACLE_LOADER is the default access
driver. You must specify the ORACLE_DATAPUMP access driver if you specify the AS subquery clause to unload data
from one Oracle Database and reload it into the same or a different Oracle Database.
The access parameters, specified in the ACCESS PARAMETERS clause, are opaque to the database. These access
parameters are defined by the access driver, and are provided to the access driver by the database when the
external table is accessed. See Oracle Database Utilities for a description of the ORACLE_LOADER access
parameters.
The PARALLEL clause enables parallel query on the data sources. The granule of parallelism is by default a data
source, but parallel access within a data source is implemented whenever possible. For example, if PARALLEL=3
were specified, then multiple parallel execution servers could be working on a data source. But, parallel access
within a data source is provided by the access driver only if all of the following conditions are met:
The REJECT LIMIT clause specifies that there is no limit on the number of errors that can occur during a query of
the external data. For parallel access, the REJECT LIMIT applies to each parallel execution server independently. For
example, if a REJECT LIMIT of 10 is specified, then each parallel query process can allow up to 10 rejections.
Therefore, with a parallel degree of two and a REJECT LIMIT of 10, the statement might fail with between 10 and 20
rejections. If one parallel server processes all 10 rejections, then the limit is reached, and the statement is
terminated. However, one parallel execution server could process nine rejections and another parallel execution
server could process nine rejections and the statement will succeed with 18 rejections. Hence, the only precisely
enforced values for REJECT LIMIT on parallel query are 0 and UNLIMITED.
In this example, the INSERT INTO TABLE statement generates a dataflow from the external data source to the
Oracle Database SQL engine where data is processed. As data is parsed by the access driver from the external
table sources and provided to the external table interface, the external data is converted from its external
representation to its Oracle Database internal data type.