This chapter describes the SQL*Loader control file. The following topics are included:

1. Sqlldr Ctl File Options
2. Sqlldr Control File Syntax
3. Sqlldr Control File Options

• Tag;Count c#;101811 java;62386 php;53884.net;49639 javascript;46608 asp.net;45444 c++;38691 jquery;38321 iphone;35754 python;31852 sql;25316 mysql;23236 html;21936 sql-server;18360 ruby-on-rails;18181 c;17256 objective-c;17250 css;16429 wpf;15950 android;15614 asp.net-mvc;15034 windows;12838 ruby.
• Consumer credit counseling service wa. Christian credit counseling programs. Consolidation counseling credit debt massachusetts. Sqlldr Control File Defaultifempty. Control File Contents. The SQL*Loader control file is a text file that contains data definition language (DDL) instructions. DDL is used to control the following.

I have a CSV file. How can I tell the sqlldr control file to load missing values as NULL. (ie the table schema allows NULL for certain column) Example of CSV 1,Name1 2,Name2 3, 4,Name3 Could you.

Control File Contents

The SQL*Loader control file is a text file that contains data definition language (DDL) instructions. DDL is used to control the following aspects of a SQL*Loader session:

• Where SQL*Loader will find the data to load

• How SQL*Loader expects that data to be formatted

• How SQL*Loader will be configured (memory management, rejecting records, interrupted load handling, and so on) as it loads the data

• How SQL*Loader will manipulate the data being loaded

See Appendix A for syntax diagrams of the SQL*Loader DDL.

To create the SQL*Loader control file, use a text editor such as vi or xemacs.create.

In general, the control file has three main sections, in the following order:

• Sessionwide information

• Table and field-list information

• Input data (optional section)

Example 8-1 shows a sample control file.

Example 8-1 Sample Control File

In this sample control file, the numbers that appear to the left would not appear in a real control file. They are keyed in this sample to the explanatory notes in the following list:

1. This is how comments are entered in a control file. See Comments in the Control File.

2. The LOAD DATA statement tells SQL*Loader that this is the beginning of a new data load. See Appendix A for syntax information.

3. The INFILE clause specifies the name of a datafile containing data that you want to load. See Specifying Datafiles.

4. The BADFILE clause specifies the name of a file into which rejected records are placed. See Specifying the Bad File.

5. The DISCARDFILE clause specifies the name of a file into which discarded records are placed. See Specifying the Discard File.

6. The APPEND clause is one of the options you can use when loading data into a table that is not empty. See Loading Data into Nonempty Tables.

   To load data into a table that is empty, you would use the INSERT clause. See Loading Data into Empty Tables.

7. The INTO TABLE clause enables you to identify tables, fields, and datatypes. It defines the relationship between records in the datafile and tables in the database. See Specifying Table Names.

8. The WHEN clause specifies one or more field conditions. SQL*Loader decides whether or not to load the data based on these field conditions. See Loading Records Based on a Condition.

9. The TRAILING NULLCOLSclause tells SQL*Loader to treat any relatively positioned columns that are not present in the record as null columns. See Handling Short Records with Missing Data.

10. The remainder of the control file contains the field list, which provides information about column formats in the table being loaded. See Chapter 9 for information about that section of the control file.

Comments in the Control File

Comments can appear anywhere in the command section of the file, but they should not appear within the data. Precede any comment with two hyphens, for example:

All text to the right of the double hyphen is ignored, until the end of the line.

Specifying Command-Line Parameters in the Control File

You can specify command-line parameters in the SQL*Loader control file using the OPTIONS clause. This can be useful when you typically invoke a control file with the same set of options. The OPTIONS clause precedes the LOADDATA statement.

OPTIONS Clause

The following command-line parameters can be specified using the OPTIONS clause. These parameters are described in greater detail in Chapter 7.

The following is an example use of the OPTIONS clause that you could use in a SQL*Loader control file:

Specifying Filenames and Object Names

In general, SQL*Loader follows the SQL standard for specifying object names (for example, table and column names). The information in this section discusses the following topics:

Filenames That Conflict with SQL and SQL*Loader Reserved Words

SQL and SQL*Loader reserved words must be specified within double quotation marks. The only SQL*Loader reserved word is CONSTANT.

You must use double quotation marks if the object name contains special characters other than those recognized by SQL ($, #, _), or if the name is case sensitive.

Specifying SQL Strings

You must specify SQL strings within double quotation marks. The SQL string applies SQL operators to data fields.

Operating System Considerations

The following sections discuss situations in which your course of action may depend on the operating system you are using.

Specifying a Complete Path

If you encounter problems when trying to specify a complete path name, it may be due to an operating system-specific incompatibility caused by special characters in the specification. In many cases, specifying the path name within single quotation marks prevents errors.

Backslash Escape Character

Sqlldr Ctl File Options

In DDL syntax, you can place a double quotation mark inside a string delimited by double quotation marks by preceding it with the escape character, ' (if the escape character is allowed on your operating system). The same rule applies when single quotation marks are required in a string delimited by single quotation marks.

For example, homedirdata'normmydata contains a double quotation mark. Preceding the double quotation mark with a backslash indicates that the double quotation mark is to be taken literally:

You can also put the escape character itself into a string by entering it twice.

For example:

Nonportable Strings

Sqlldr Control File Syntax

There are two kinds of character strings in a SQL*Loader control file that are not portable between operating systems: filename and file processing option strings. When you convert to a different operating system, you will probably need to modify these strings. All other strings in a SQL*Loader control file should be portable between operating systems.

Using the Backslash as an Escape Character

If your operating system uses the backslash character to separate directories in a path name, and if the version of the Oracle database running on your operating system implements the backslash escape character for filenames and other nonportable strings, then you must specify double backslashes in your path names and use single quotation marks.

Escape Character Is Sometimes Disallowed

The version of the Oracle database running on your operating system may not implement the escape character for nonportable strings. When the escape character is disallowed, a backslash is treated as a normal character, rather than as an escape character (although it is still usable in all other strings). Then path names such as the following can be specified normally:

Double backslashes are not needed.

Because the backslash is not recognized as an escape character, strings within single quotation marks cannot be embedded inside another string delimited by single quotation marks. This rule also holds for double quotation marks. A string within double quotation marks cannot be embedded inside another string delimited by double quotation marks.

Identifying XML Type Tables

As of Oracle Database 10g, the XMLTYPE clause is available for use in a SQL*Loader control file. This clause is of the format XMLTYPE(field name). It is used to identify XML type tables so that the correct SQL statement can be constructed. Example 8-2 shows how the clause can be used in a SQL*Loader control file.

Example 8-2 Identifying XML Type Tables in the SQL*Loader Control File

Specifying Datafiles

To specify a datafile that contains the data to be loaded, use the INFILE keyword, followed by the filename and optional file processing options string. You can specify multiple files by using multiple INFILE keywords.

Examples of INFILE Syntax

The following list shows different ways you can specify INFILE syntax:

• Data contained in the control file itself:

• Data contained in a file named sample with a default extension of .dat:

• Data contained in a file named datafile.dat with a full path specified:

  
  

  Note: Filenames that include spaces or punctuation marks must be enclosed in single quotation marks.

  
  

  Specifying Multiple Datafiles

  To load data from multiple datafiles in one SQL*Loader run, use an INFILE clause for each datafile. Datafiles need not have the same file processing options, although the layout of the records must be identical. For example, two files could be specified with completely different file processing options strings, and a third could consist of data in the control file.

  You can also specify a separate discard file and bad file for each datafile. In such a case, the separate bad files and discard files must be declared immediately after each datafile name. For example, the following excerpt from a control file specifies four datafiles with separate bad and discard files:

  • For mydat1.dat, both a bad file and discard file are explicitly specified. Therefore both files are created, as needed.

  • For mydat2.dat, neither a bad file nor a discard file is specified. Therefore, only the bad file is created, as needed. If created, the bad file has the default filename and extension mydat2.bad. The discard file is not created, even if rows are discarded.

  • For mydat3.dat, the default bad file is created, if needed. A discard file with the specified name (mydat3.dis) is created, as needed.

  • For mydat4.dat, the default bad file is created, if needed. Because the DISCARDMAX option is used, SQL*Loader assumes that a discard file is required and creates it with the default name mydat4.dsc.

Identifying Data in the Control File with BEGINDATA

If the data is included in the control file itself, then the INFILE clause is followed by an asterisk rather than a filename. The actual data is placed in the control file after the load configuration specifications.

Sqlldr Control File Options

Specify the BEGINDATA statement before the first data record. The syntax is:

Keep the following points in mind when using the BEGINDATA statement:

• If you omit the BEGINDATA statement but include data in the control file, SQL*Loader tries to interpret your data as control information and issues an error message. If your data is in a separate file, do not use the BEGINDATA statement.

• Do not use spaces or other characters on the same line as the BEGINDATA statement, or the line containing BEGINDATA will be interpreted as the first line of data.

• Do not put comments after BEGINDATA, or they will also be interpreted as data.

  
  

  See Also: Specifying Datafiles for an explanation of using INFILE Case study 1, Loading Variable-Length Data (see SQL*Loader Case Studies for information on how to access case studies)

  
  

  Specifying Datafile Format and Buffering

  When configuring SQL*Loader, you can specify an operating system-dependent file processing options string (os_file_proc_clause) in the control file to specify file format and buffering.

  For example, suppose that your operating system has the following option-string syntax:

  
  Description of the illustration recsize_spec.gif
  

  In this syntax, RECSIZE is the size of a fixed-length record, and BUFFERS is the number of buffers to use for asynchronous I/O.

  To declare a file named mydata.dat as a file that contains 80-byte records and instruct SQL*Loader to use 8 I/O buffers, you would use the following control file entry:

  
  

  Note: This example uses the recommended convention of single quotation marks for filenames and double quotation marks for everything else.

  
  

  Specifying the Bad File

  When SQL*Loader executes, it can create a file called a bad file or reject file in which it places records that were rejected because of formatting errors or because they caused Oracle errors. If you have specified that a bad file is to be created, the following applies:

  • If one or more records are rejected, the bad file is created and the rejected records are logged.

  • If no records are rejected, then the bad file is not created. When this occurs, you must reinitialize the bad file for the next run.

  • If the bad file is created, it overwrites any existing file with the same name; ensure that you do not overwrite a file you wish to retain.

    
    

    Note: On some systems, a new version of the file may be created if a file with the same name already exists.

    
    

    How Bad Files Are Handled with LOBFILEs and SDFs

    Data from LOBFILEs and SDFs is not written to a bad file when there are rejected rows. If there is an error loading a LOB, the row is not rejected. Rather, the LOB column is left empty (not null with a length of zero (0) bytes). However, when the LOBFILE is being used to load an XML column and there is an error loading this LOB data, then the XML column is left as null.

    Criteria for Rejected Records

    A record can be rejected for the following reasons:

    1. Upon insertion, the record causes an Oracle error (such as invalid data for a given datatype).

    2. The record is formatted incorrectly so that SQL*Loader cannot find field boundaries.

    3. The record violates a constraint or tries to make a unique index non-unique.

    If the data can be evaluated according to the WHEN clause criteria (even with unbalanced delimiters), then it is either inserted or rejected.

    Neither a conventional path nor a direct path load will write a row to any table if it is rejected because of reason number 2 in the previous list.

    Additionally, a conventional path load will not write a row to any tables if reason number 1 or 3 in the previous list is violated for any one table. The row is rejected for that table and written to the reject file.

    The log file indicates the Oracle error for each rejected record. Case study 4 demonstrates rejected records. (See SQL*Loader Case Studies for information on how to access case studies.)

  Specifying the Discard File

  During execution, SQL*Loader can create a discard file for records that do not meet any of the loading criteria. The records contained in this file are called discarded records. Discarded records do not satisfy any of the WHEN clauses specified in the control file. These records differ from rejected records. Discarded records do not necessarily have any bad data. No insert is attempted on a discarded record.

  A discard file is created according to the following rules:

  • You have specified a discard filename and one or more records fail to satisfy all of the WHEN clauses specified in the control file. (If the discard file is created, it overwrites any existing file with the same name, so be sure that you do not overwrite any files you wish to retain.)

  • If no records are discarded, then a discard file is not created.

  To create a discard file from within a control file, specify any of the following: DISCARDFILEfilename, DISCARDS, or DISCARDMAX.

  To create a discard file from the command line, specify either DISCARD or DISCARDMAX.

  You can specify the discard file directly by specifying its name, or indirectly by specifying the maximum number of discards.

  The discard file is created in the same record and file format as the datafile. For datafiles in stream record format, the same record terminator that is found in the datafile is also used in the discard file.

  Specifying the Discard File in the Control File

  To specify the name of the file, use the DISCARDFILE clause, followed by the filename.

  
  Description of the illustration discard.gif
  

  The DISCARDFILE clause specifies that a discard filename follows.

  The filename parameter specifies a valid filename specification for your platform. Any spaces or punctuation marks in the filename must be enclosed in single quotation marks.

  The default filename is the name of the datafile, and the default file extension or file type is .dsc. A discard filename specified on the command line overrides one specified in the control file. If a discard file with that name already exists, it is either overwritten or a new version is created, depending on your operating system.

  Specifying the Discard File from the Command Line

  See DISCARD (filename) for information about how to specify a discard file from the command line.

  A filename specified on the command line overrides any discard file that you may have specified in the control file.

  Examples of Specifying a Discard File Name

  The following list shows different ways you can specify a name for the discard file from within the control file:

  • To specify a discard file with filename circular and default file extension or file type of .dsc:

  • To specify a discard file named notappl with the file extension or file type of .may:

  • To specify a full path to the discard file forget.me:

  Criteria for Discarded Records

  If there is no INTO TABLE clause specified for a record, the record is discarded. This situation occurs when every INTO TABLE clause in the SQL*Loader control file has a WHEN clause and, either the record fails to match any of them, or all fields are null.

  No records are discarded if an INTO TABLE clause is specified without a WHEN clause. An attempt is made to insert every record into such a table. Therefore, records may be rejected, but none are discarded.

  Case study 7, Extracting Data from a Formatted Report, provides an example of using a discard file. (See SQL*Loader Case Studies for information on how to access case studies.)

  How Discard Files Are Handled with LOBFILEs and SDFs

  Data from LOBFILEs and SDFs is not written to a discard file when there are discarded rows.

  Limiting the Number of Discarded Records

  You can limit the number of records to be discarded for each datafile by specifying an integer for either the DISCARDS or DISCARDMAX keyword.

  When the discard limit is reached, processing of the datafile terminates and continues with the next datafile, if one exists.

  You can specify a different number of discards for each datafile. Or, if you specify the number of discards only once, then the maximum number of discards specified applies to all files.

  If you specify a maximum number of discards, but no discard filename, SQL*Loader creates a discard file with the default filename and file extension or file type.

  Handling Different Character Encoding Schemes

  SQL*Loader supports different character encoding schemes (called character sets, or code pages). SQL*Loader uses features of Oracle's globalization support technology to handle the various single-byte and multibyte character encoding schemes available today.

  
  

  See Also: Oracle Database Globalization Support Guide

  
  

  Unicode Character Sets

  SQL*Loader supports loading data that is in a Unicode character set.

  Unicode is a universal encoded character set that supports storage of information from most languages in a single character set. Unicode provides a unique code value for every character, regardless of the platform, program, or language. There are two different encodings for Unicode, UTF-16 and UTF-8.

  
  

  Note: In this manual, you will see the terms UTF-16 and UTF16 both used. The term UTF-16 is a general reference to UTF-16 encoding for Unicode. The term UTF16 (no hyphen) is the specific name of the character set and is what you should specify for the CHARACTERSET parameter when you want to use UTF-16 encoding. This also applies to UTF-8 and UTF8.

  
  

  Database Character Sets

  The Oracle database uses the database character set for data stored in SQL CHAR datatypes (CHAR,VARCHAR2,CLOB, and LONG), for identifiers such as table names, and for SQL statements and PL/SQL source code. Only single-byte character sets and varying-width character sets that include either ASCII or EBCDIC characters are supported as database character sets. Multibyte fixed-width character sets (for example, AL16UTF16) are not supported as the database character set.

  An alternative character set can be used in the database for data stored in SQL NCHAR datatypes (NCHAR,NVARCHAR, and NCLOB). This alternative character set is called the database national character set. Only Unicode character sets are supported as the database national character set.

  Datafile Character Sets

  By default, the datafile is in the character set defined by the NLS_LANG parameter. The datafile character sets supported with NLS_LANG are the same as those supported as database character sets. SQL*Loader supports all Oracle-supported character sets in the datafile (even those not supported as database character sets).

  For example, SQL*Loader supports multibyte fixed-width character sets (such as AL16UTF16 and JA16EUCFIXED) in the datafile. SQL*Loader also supports UTF-16 encoding with little-endian byte ordering. However, the Oracle database supports only UTF-16 encoding with big-endian byte ordering (AL16UTF16) and only as a database national character set, not as a database character set.

  The character set of the datafile can be set up by using the NLS_LANG parameter or by specifying a SQL*Loader CHARACTERSET parameter.

  Input Character Conversion

  The default character set for all datafiles, if the CHARACTERSET parameter is not specified, is the session character set defined by the NLS_LANG parameter. The character set used in input datafiles can be specified with the CHARACTERSET parameter.

  SQL*Loader has the capacity to automatically convert data from the datafile character set to the database character set or the database national character set, when they differ.

  When data character set conversion is required, the target character set should be a superset of the source datafile character set. Otherwise, characters that have no equivalent in the target character set are converted to replacement characters, often a default character such as a question mark (?). This causes loss of data.

  The sizes of the database character types CHAR and VARCHAR2 can be specified in bytes (byte-length semantics) or in characters (character-length semantics). If they are specified in bytes, and data character set conversion is required, the converted values may take more bytes than the source values if the target character set uses more bytes than the source character set for any character that is converted. This will result in the following error message being reported if the larger target value exceeds the size of the database column:

  You can avoid this problem by specifying the database column size in characters and also by using character sizes in the control file to describe the data. Another way to avoid this problem is to ensure that the maximum column size is large enough, in bytes, to hold the converted value.

  
  

  See Also: Oracle Database Concepts for more information about character-length semantics in the database

  
  

  CHARACTERSET Parameter

  Specifying the CHARACTERSET parameter tells SQL*Loader the character set of the input datafile. The default character set for all datafiles, if the CHARACTERSET parameter is not specified, is the session character set defined by the NLS_LANG parameter. Only character data (fields in the SQL*Loader datatypes CHAR,VARCHAR,VARCHARC, numeric EXTERNAL, and the datetime and interval datatypes) is affected by the character set of the datafile.

  The CHARACTERSET syntax is as follows:

  The char_set_name variable specifies the character set name. Normally, the specified name must be the name of an Oracle-supported character set.

  For UTF-16 Unicode encoding, use the name UTF16 rather than AL16UTF16. AL16UTF16, which is the supported Oracle character set name for UTF-16 encoded data, is only for UTF-16 data that is in big-endian byte order. However, because you are allowed to set up data using the byte order of the system where you create the datafile, the data in the datafile can be either big endian or little endian. Therefore, a different character set name (UTF16) is used. The character set name AL16UTF16 is also supported. But if you specify AL16UTF16 for a datafile that has little-endian byte order, SQL*Loader issues a warning message and processes the datafile as big endian.

  The CHARACTERSET parameter can be specified for primary datafiles as well as LOBFILEs and SDFs. It is possible to specify different character sets for different input datafiles. A CHARACTERSET parameter specified before the INFILE parameter applies to the entire list of primary datafiles. If the CHARACTERSET parameter is specified for primary datafiles, the specified value will also be used as the default for LOBFILEs and SDFs. This default setting can be overridden by specifying the CHARACTERSET parameter with the LOBFILE or SDF specification.

  The character set specified with the CHARACTERSET parameter does not apply to data in the control file (specified with INFILE). To load data in a character set other than the one specified for your session by the NLS_LANG parameter, you must place the data in a separate datafile.

  
  

  See Also: Oracle Database Globalization Support Guide for more information about the names of the supported character sets Case study 11, Loading Data in the Unicode Character Set, for an example of loading a datafile that contains little-endian UTF-16 encoded data. (See SQL*Loader Case Studies for information on how to access case studies.)

  
  

  Control File Character Set

  The SQL*Loader control file itself is assumed to be in the character set specified for your session by the NLS_LANG parameter. If the control file character set is different from the datafile character set, keep the following issue in mind. Delimiters and comparison clause values specified in the SQL*Loader control file as character strings are converted from the control file character set to the datafile character set before any comparisons are made. To ensure that the specifications are correct, you may prefer to specify hexadecimal strings, rather than character string values.

  If hexadecimal strings are used with a datafile in the UTF-16 Unicode encoding, the byte order is different on a big-endian versus a little-endian system. For example, ',' (comma) in UTF-16 on a big-endian system is X'002c'. On a little-endian system it is X'2c00'. SQL*Loader requires that you always specify hexadecimal strings in big-endian format. If necessary, SQL*Loader swaps the bytes before making comparisons. This allows the same syntax to be used in the control file on both a big-endian and a little-endian system.

  Record terminators for datafiles that are in stream format in the UTF-16 Unicode encoding default to 'n' in UTF-16 (that is, 0x000A on a big-endian system and 0x0A00 on a little-endian system). You can override these default settings by using the 'STR 'char_str' or the 'STRx'hex_str'' specification on the INFILE line. For example, you could use either of the following to specify that 'ab' is to be used as the record terminator, instead of 'n'.

  Any data included after the BEGINDATA statement is also assumed to be in the character set specified for your session by the NLS_LANG parameter.

  For the SQL*Loader datatypes (CHAR,VARCHAR,VARCHARC,DATE, and EXTERNAL numerics), SQL*Loader supports lengths of character fields that are specified in either bytes (byte-length semantics) or characters (character-length semantics). For example, the specification CHAR(10) in the control file can mean 10 bytes or 10 characters. These are equivalent if the datafile uses a single-byte character set. However, they are often different if the datafile uses a multibyte character set.

  To avoid insertion errors caused by expansion of character strings during character set conversion, use character-length semantics in both the datafile and the target database columns.

  Character-Length Semantics

  Byte-length semantics are the default for all datafiles except those that use the UTF16 character set (which uses character-length semantics by default). To override the default you can specify CHAR or CHARACTER, as shown in the following syntax:

  
  Description of the illustration char_length.gif
  

  The LENGTH parameter is placed after the CHARACTERSET parameter in the SQL*Loader control file. The LENGTH parameter applies to the syntax specification for primary datafiles as well as to LOBFILEs and secondary datafiles (SDFs). It is possible to specify different length semantics for different input datafiles. However, a LENGTH specification before the INFILE parameters applies to the entire list of primary datafiles. The LENGTH specification specified for the primary datafile is used as the default for LOBFILEs and SDFs. You can override that default by specifying LENGTH with the LOBFILE or SDF specification. Unlike the CHARACTERSET parameter, the LENGTH parameter can also apply to data contained within the control file itself (that is, INFILE * syntax).

  You can specify CHARACTER instead of CHAR for the LENGTH parameter.

  If character-length semantics are being used for a SQL*Loader datafile, then the following SQL*Loader datatypes will use character-length semantics:

  • CHAR

  • VARCHAR

  • VARCHARC

  • DATE

  • EXTERNAL numerics (INTEGER, FLOAT, DECIMAL, and ZONED)

  For the VARCHAR datatype, the length subfield is still a binary SMALLINT length subfield, but its value indicates the length of the character string in characters.

  The following datatypes use byte-length semantics even if character-length semantics are being used for the datafile, because the data is binary, or is in a special binary-encoded form in the case of ZONED and DECIMAL:

  • INTEGER

  • SMALLINT

  • FLOAT

  • DOUBLE

  • BYTEINT

  • ZONED

  • DECIMAL

  • RAW

  • VARRAW

  • VARRAWC

  • GRAPHIC

  • GRAPHIC EXTERNAL

  • VARGRAPHIC

  The start and end arguments to the POSITION parameter are interpreted in bytes, even if character-length semantics are in use in a datafile. This is necessary to handle datafiles that have a mix of data of different datatypes, some of which use character-length semantics, and some of which use byte-length semantics. It is also needed to handle position with the VARCHAR datatype, which has a SMALLINT length field and then the character data. The SMALLINT length field takes up a certain number of bytes depending on the system (usually 2 bytes), but its value indicates the length of the character string in characters.

  Character-length semantics in the datafile can be used independent of whether or not character-length semantics are used for the database columns. Therefore, the datafile and the database columns can use either the same or different length semantics.

  Interrupted Loads

  Loads are interrupted and discontinued for a number of reasons. A primary reason is space errors, in which SQL*Loader runs out of space for data rows or index entries. A load might also be discontinued because the maximum number of errors was exceeded, an unexpected error was returned to SQL*Loader from the server, a record was too long in the datafile, or a Ctrl+C was executed.

  The behavior of SQL*Loader when a load is discontinued varies depending on whether it is a conventional path load or a direct path load, and on the reason the load was interrupted. Additionally, when an interrupted load is continued, the use and value of the SKIP parameter can vary depending on the particular case. The following sections explain the possible scenarios.

  Discontinued Direct Path Loads

  In a direct path load, the behavior of a discontinued load varies depending on the reason the load was discontinued:

  Load Discontinued Because of Space Errors

  If a load is discontinued because of space errors, the behavior of SQL*Loader depends on whether or not you are loading data into multiple subpartitions.

  • Space errors when loading data into multiple subpartitions (that is, loading into a partitioned table, a composite partitioned table, or one partition of a composite partitioned table):

    If space errors occur when loading into multiple subpartitions, the load is discontinued and no data is saved unless ROWS has been specified (in which case, all data that was previously committed will be saved). The reason for this behavior is that it is possible rows might be loaded out of order. This is because each row is assigned (not necessarily in order) to a partition and each partition is loaded separately. If the load discontinues before all rows assigned to partitions are loaded, the row for record 'n' may have been loaded, but not the row for record 'n-1'. Therefore, the load cannot be continued by simply using SKIP=N .

  • Space errors when loading data into an unpartitioned table, one partition of a partitioned table, or one subpartition of a composite partitioned table:

    If there is one INTO TABLE statement in the control file, SQL*Loader commits as many rows as were loaded before the error occurred.

    If there are multiple INTO TABLE statements in the control file, SQL*Loader loads data already read from the datafile into other tables and then commits the data.

    In either case, this behavior is independent of whether or not the ROWS parameter was specified. When you continue the load, you can use the SKIP parameter to skip rows that have already been loaded. In the case of multiple INTO TABLE statements, a different number of rows could have been loaded into each table, so to continue the load you would need to specify a different value for the SKIP parameter for every table. SQL*Loader only reports the value for the SKIP parameter if it is the same for all tables.

  Load Discontinued Because Maximum Number of Errors Exceeded

  If the maximum number of errors is exceeded, SQL*Loader stops loading records into any table and the work done to that point is committed. This means that when you continue the load, the value you specify for the SKIP parameter may be different for different tables. SQL*Loader reports the value for the SKIP parameter only if it is the same for all tables.

  Load Discontinued Because of Fatal Errors

  If a fatal error is encountered, the load is stopped and no data is saved unless ROWS was specified at the beginning of the load. In that case, all data that was previously committed is saved. SQL*Loader reports the value for the SKIP parameter only if it is the same for all tables.

  Load Discontinued Because a Ctrl+C Was Issued

  If SQL*Loader is in the middle of saving data when a Ctrl+C is issued, it continues to do the save and then stops the load after the save completes. Otherwise, SQL*Loader stops the load without committing any work that was not committed already. This means that the value of the SKIP parameter will be the same for all tables.

  Status of Tables and Indexes After an Interrupted Load

  When a load is discontinued, any data already loaded remains in the tables, and the tables are left in a valid state. If the conventional path is used, all indexes are left in a valid state.

  If the direct path load method is used, any indexes that run out of space are left in an unusable state. You must drop these indexes before the load can continue. You can re-create the indexes either before continuing or after the load completes.

  Other indexes are valid if no other errors occurred. See Indexes Left in an Unusable State for other reasons why an index might be left in an unusable state.

  Using the Log File to Determine Load Status

  The SQL*Loader log file tells you the state of the tables and indexes and the number of logical records already read from the input datafile. Use this information to resume the load where it left off.

  Continuing Single-Table Loads

  When SQL*Loader must discontinue a direct path or conventional path load before it is finished, some rows have probably already been committed or marked with savepoints. To continue the discontinued load, use the SKIP parameter to specify the number of logical records that have already been processed by the previous load. At the time the load is discontinued, the value for SKIP is written to the log file in a message similar to the following:

  This message specifying the value of the SKIP parameter is preceded by a message indicating why the load was discontinued.

  Note that for multiple-table loads, the value of the SKIP parameter is displayed only if it is the same for all tables.

  Assembling Logical Records from Physical Records

  As of Oracle9i, user-defined record sizes larger than 64 KB are supported (see READSIZE (read buffer size)). This reduces the need to break up logical records into multiple physical records. However, there may still be situations in which you may want to do so. At some point, when you want to combine those multiple physical records back into one logical record, you can use one of the following clauses, depending on your data:

  • CONCATENATE

  • CONTINUEIF

  Using CONCATENATE to Assemble Logical Records

  Use CONCATENATE when you want SQL*Loader to always combine the same number of physical records to form one logical record. In the following example, integer specifies the number of physical records to combine.

  The integer value specified for CONCATENATE determines the number of physical record structures that SQL*Loader allocates for each row in the column array. Because the default value for COLUMNARRAYROWS is large, if you also specify a large value for CONCATENATE, then excessive memory allocation can occur. If this happens, you can improve performance by reducing the value of the COLUMNARRAYROWS parameter to lower the number of rows in a column array.

  
  

  See Also:

  
  

  Using CONTINUEIF to Assemble Logical Records

  Use CONTINUEIF if the number of physical records to be combined varies. The CONTINUEIF clause is followed by a condition that is evaluated for each physical record, as it is read. For example, two records might be combined if a pound sign (#) were in byte position 80 of the first record. If any other character were there, the second record would not be added to the first.

  The full syntax for CONTINUEIF adds even more flexibility:

  
  Description of the illustration continueif.gif
  

  Table 8-2 describes the parameters for the CONTINUEIF clause.

  Table 8-2 Parameters for the CONTINUEIF Clause

  Parameter	Description
  THIS	If the condition is true in the current record, then the next physical record is read and concatenated to the current physical record, continuing until the condition is false. If the condition is false, then the current physical record becomes the last physical record of the current logical record. THIS is the default.
  NEXT	If the condition is true in the next record, then the current physical record is concatenated to the current logical record, continuing until the condition is false.
  operator	The supported operators are equal (=) and not equal (!= or <>). For the equal operator, the field and comparison string must match exactly for the condition to be true. For the not equal operator, they may differ in any character.
  LAST	This test is similar to THIS, but the test is always against the last nonblank character. If the last nonblank character in the current physical record meets the test, then the next physical record is read and concatenated to the current physical record, continuing until the condition is false. If the condition is false in the current record, then the current physical record is the last physical record of the current logical record. LAST allows only a single character-continuation field (as opposed to THIS and NEXT, which allow multiple character-continuation fields).
  pos_spec	Specifies the starting and ending column numbers in the physical record. Column numbers start with 1. Either a hyphen or a colon is acceptable (start-end or start:end). If you omit end, the length of the continuation field is the length of the byte string or character string. If you use end, and the length of the resulting continuation field is not the same as that of the byte string or the character string, the shorter one is padded. Character strings are padded with blanks, hexadecimal strings with zeros.
  str	A string of characters to be compared to the continuation field defined by start and end, according to the operator. The string must be enclosed in double or single quotation marks. The comparison is made character by character, blank padding on the right if necessary.
  X'hex-str'	A string of bytes in hexadecimal format used in the same way as str. X'1FB033' would represent the three bytes with values 1F, B0, and 33 (hexadecimal).
  PRESERVE	Includes 'char_string' or X'hex_string' in the logical record. The default is to exclude them.

  
  

  The positions in the CONTINUEIF clause refer to positions in each physical record. This is the only time you refer to positions in physical records. All other references are to logical records.

  For CONTINUEIFTHIS and CONTINUEIFLAST, if the PRESERVE parameter is not specified, the continuation field is removed from all physical records when the logical record is assembled. That is, data values are allowed to span the records with no extra characters (continuation characters) in the middle. For example, if CONTINUEIFTHIS(3:5)='***' is specified, then positions 3 through 5 are removed from all records. This means that the continuation characters are removed if they are in positions 3 through 5 of the record. It also means that the characters in positions 3 through 5 are removed from the record even if the continuation characters are not in positions 3 through 5.

  For CONTINUEIFTHIS and CONTINUEIFLAST, if the PRESERVE parameter is used, the continuation field is kept in all physical records when the logical record is assembled.

  CONTINUEIFLAST differs from CONTINUEIFTHIS and CONTINUEIFNEXT. For CONTINUEIFLAST, where the positions of the continuation field vary from record to record, the continuation field is never removed, even if PRESERVE is not specified.

  Example 8-3 through Example 8-6 show the use of CONTINUEIF THIS and CONTINUEIF NEXT, with and without the PRESERVE parameter.

  Example 8-3 CONTINUEIF THIS Without the PRESERVE Parameter

  Assume that you have physical records 14 bytes long and that a period represents a space:

  In this example, the CONTINUEIF THIS clause does not use the PRESERVE parameter:

  Therefore, the logical records are assembled as follows:

  Note that columns 1 and 2 (for example, %% in physical record 1) are removed from the physical records when the logical records are assembled.

  Example 8-4 CONTINUEIF THIS with the PRESERVE Parameter

  Assume that you have the same physical records as in Example 8-3.

  In this example, the CONTINUEIF THIS clause uses the PRESERVE parameter:

  Therefore, the logical records are assembled as follows:

  Note that columns 1 and 2 are not removed from the physical records when the logical records are assembled.

  Example 8-5 CONTINUEIF NEXT Without the PRESERVE Parameter

  Assume that you have physical records 14 bytes long and that a period represents a space:

  In this example, the CONTINUEIF NEXT clause does not use the PRESERVE parameter:

  Therefore, the logical records are assembled as follows (the same results as for Example 8-3).

  Example 8-6 CONTINUEIF NEXT with the PRESERVE Parameter

  Assume that you have the same physical records as in Example 8-5.

  In this example, the CONTINUEIF NEXT clause uses the PRESERVE parameter:

  Therefore, the logical records are assembled as follows:

  
  

  See Also: Case study 4, Loading Combined Physical Records, for an example of the CONTINUEIF clause. (See SQL*Loader Case Studies for information on how to access case studies.)

  
  

  Loading Logical Records into Tables

  This section describes the way in which you specify:

  • Which tables you want to load

  • Which records you want to load into them

  • Default data delimiters for those records

  • How to handle short records with missing data

  Specifying Table Names

  The INTOTABLE clause of the LOADDATA statement enables you to identify tables, fields, and datatypes. It defines the relationship between records in the datafile and tables in the database. The specification of fields and datatypes is described in later sections.

  INTO TABLE Clause

  Among its many functions, the INTOTABLE clause enables you to specify the table into which you load data. To load multiple tables, you include one INTOTABLE clause for each table you wish to load.

  To begin an INTOTABLE clause, use the keywords INTOTABLE, followed by the name of the Oracle table that is to receive the data.

  The syntax is as follows:

  
  Description of the illustration into_table1.gif
  

  The table must already exist. The table name should be enclosed in double quotation marks if it is the same as any SQL or SQL*Loader reserved keyword, if it contains any special characters, or if it is case sensitive.

  The user must have INSERT privileges for the table being loaded. If the table is not in the user's schema, then the user must either use a synonym to reference the table or include the schema name as part of the table name (for example, scott.emp refers to the table emp in the scott schema).

  
  

  Note: SQL*Loader considers the default schema to be whatever schema is current after your connect to the database finishes executing. This means that the default schema will not necessarily be the one you specified in the connect string, if there are logon triggers present that get executed during connection to a database. If you have a logon trigger that changes your current schema to a different one when you connect to a certain database, then SQL*Loader uses that new schema as the default.

  
  

  Table-Specific Loading Method

  When you are loading a table, you can use the INTOTABLE clause to specify a table-specific loading method (INSERT, APPEND,REPLACE, or TRUNCATE) that applies only to that table. That method overrides the global table-loading method. The global table-loading method is INSERT, by default, unless a different method was specified before any INTOTABLE clauses. The following sections discuss using these options to load data into empty and nonempty tables.

  Loading Data into Empty Tables

  If the tables you are loading into are empty, use the INSERT option.

  INSERT

  This is SQL*Loader's default method. It requires the table to be empty before loading. SQL*Loader terminates with an error if the table contains rows. Case study 1, Loading Variable-Length Data, provides an example. (See SQL*Loader Case Studies for information on how to access case studies.)

  Loading Data into Nonempty Tables

  If the tables you are loading into already contain data, you have three options:

  • APPEND

  • REPLACE

  • TRUNCATE

    
    

    Caution: When REPLACE or TRUNCATE is specified, the entire table is replaced, not just individual rows. After the rows are successfully deleted, a COMMIT statement is issued. You cannot recover the data that was in the table before the load, unless it was saved with Export or a comparable utility.

    
    

    REPLACE

    With REPLACE, all rows in the table are deleted and the new data is loaded. The table must be in your schema, or you must have DELETE privilege on the table. Case study 4, Loading Combined Physical Records, provides an example. (See SQL*Loader Case Studies for information on how to access case studies.)

    The row deletes cause any delete triggers defined on the table to fire. If DELETE CASCADE has been specified for the table, then the cascaded deletes are carried out. For more information about cascaded deletes, see the information about data integrity in Oracle Database Concepts.

    Updating Existing Rows

    The REPLACE method is a table replacement, not a replacement of individual rows. SQL*Loader does not update existing records, even if they have null columns. To update existing rows, use the following procedure:

    1. Load your data into a work table.

    2. Use the SQL language UPDATE statement with correlated subqueries.

    3. Drop the work table.

    For more information, see the UPDATE statement in Oracle Database SQL Reference.

    TRUNCATE

    The SQL TRUNCATE statement quickly and efficiently deletes all rows from a table or cluster, to achieve the best possible performance. For the TRUNCATE statement to operate, the table's referential integrity constraints must first be disabled. If they have not been disabled, SQL*Loader returns an error.

    Once the integrity constraints have been disabled, DELETE CASCADE is no longer defined for the table. If the DELETE CASCADE functionality is needed, then the contents of the table must be manually deleted before the load begins.

    The table must be in your schema, or you must have the DROP ANY TABLE privilege.

    
    

    See Also: Oracle Database Administrator's Guide for more information about the TRUNCATE statement

    
    

    Table-Specific OPTIONS Parameter

    The OPTIONS parameter can be specified for individual tables in a parallel load. (It is valid only for a parallel load.)

    The syntax for the OPTIONS parameter is as follows:

    It is not necessarily the very first serial number shipped, butit can be used to determine the approximate year your Ruger firearm wasshipped.Ruger does not necessarily produce firearms in serial number order. Also, within a model family the same serial number prefix may be used to produce a variety of different models, all in the same block of serial numbers. There are occasions when blocks of serial numbers have been manufactured out of sequence, sometimes years later. This number should be used as a point of referenceonly. Ruger GP100® Serial Number HistoryGP100® RevolverCalibers: 22 LR, 38 Spl, 357 Mag, 10mm Auto, 44 SplBeginning Serial Number:Years of Production:111991901991921991991921961951951911911952082002032052022002082062062072012072022002042015The above chart shows the approximate first serial number shipped forthe indicated year. Ruger serial number decoder.

    
    Description of the illustration into_table3.gif
    

    
    

    See Also: Parameters for Parallel Direct Path Loads

    
    

    Loading Records Based on a Condition

    You can choose to load or discard a logical record by using the WHEN clause to test a condition in the record.

    The WHEN clause appears after the table name and is followed by one or more field conditions. The syntax for field_condition is as follows:

    
    Description of the illustration fld_cond.gif
    

    For example, the following clause indicates that any record with the value 'q' in the fifth column position should be loaded:

    A WHEN clause can contain several comparisons, provided each is preceded by AND. Parentheses are optional, but should be used for clarity with multiple comparisons joined by AND, for example:

    
    

    See Also: Using the WHEN, NULLIF, and DEFAULTIF Clauses for information about how SQL*Loader evaluates WHEN clauses, as opposed to NULLIF and DEFAULTIF clauses Case study 5, Loading Data into Multiple Tables, for an example of using the WHEN clause. (See SQL*Loader Case Studies for information on how to access case studies.)

    
    

    Specifying Default Data Delimiters

    If all data fields are terminated similarly in the datafile, you can use the FIELDS clause to indicate the default delimiters. The syntax for the fields_spec,termination_spec, and enclosure_spec clauses is as follows:

    fields_spec

    
    Description of the illustration fields_spec.gif
    

    termination_spec

    
    Description of the illustration terminat.gif
    

    
    

    Note: Terminator strings can contain one or more characters. Also, TERMINATED BY EOF applies only to loading LOBs from a LOBFILE.

    
    

    enclosure_spec

    
    Description of the illustration enclose.gif
    

    
    

    Note: Enclosure strings can contain one or more characters.

    
    

    Handling Short Records with Missing Data

    When the control file definition specifies more fields for a record than are present in the record, SQL*Loader must determine whether the remaining (specified) columns should be considered null or whether an error should be generated.

    If the control file definition explicitly states that a field's starting position is beyond the end of the logical record, then SQL*Loader always defines the field as null. If a field is defined with a relative position (such as dname and loc in the following example), and the record ends before the field is found, then SQL*Loader could either treat the field as null or generate an error. SQL*Loader uses the presence or absence of the TRAILING NULLCOLS clause (shown in the following syntax diagram) to determine the course of action.

    
    Description of the illustration into_table6.gif
    

    
    Description of the illustration into_table7.gif
    

    TRAILING NULLCOLS Clause

    The TRAILINGNULLCOLS clause tells SQL*Loader to treat any relatively positioned columns that are not present in the record as null columns.

    For example, consider the following data:

    Assume that the preceding data is read with the following control file and the record ends after dname:

    In this case, the remaining loc field is set to null. Without the TRAILING NULLCOLS clause, an error would be generated due to missing data.

    
    

    See Also: Case study 7, Extracting Data from a Formatted Report, for an example of using TRAILING NULLCOLS. (See SQL*Loader Case Studies for information on how to access case studies.)

    
    

    Index Options

    This section describes the following SQL*Loader options that control how index entries are created:

    • SORTEDINDEXES

    • SINGLEROW

    SORTED INDEXES Clause

    The SORTEDINDEXES clause applies to direct path loads. It tells SQL*Loader that the incoming data has already been sorted on the specified indexes, allowing SQL*Loader to optimize performance.

    SINGLEROW Option

    The SINGLEROW option is intended for use during a direct path load with APPEND on systems with limited memory, or when loading a small number of records into a large table. This option inserts each index entry directly into the index, one record at a time.

    By default, SQL*Loader does not use SINGLEROW to append records to a table. Instead, index entries are put into a separate, temporary storage area and merged with the original index at the end of the load. This method achieves better performance and produces an optimal index, but it requires extra storage space. During the merge operation, the original index, the new index, and the space for new entries all simultaneously occupy storage space.

    With the SINGLEROW option, storage space is not required for new index entries or for a new index. The resulting index may not be as optimal as a freshly sorted one, but it takes less space to produce. It also takes more time because additional UNDO information is generated for each index insert. This option is suggested for use when either of the following situations exists:

    • Available storage is limited.

    • The number of records to be loaded is small compared to the size of the table (a ratio of 1:20 or less is recommended).

    Benefits of Using Multiple INTO TABLE Clauses

    Multiple INTOTABLE clauses enable you to:

    • Load data into different tables

    • Extract multiple logical records from a single input record

    • Distinguish different input record formats

    • Distinguish different input row object subtypes

    In the first case, it is common for the INTO TABLE clauses to refer to the same table. This section illustrates the different ways to use multiple INTO TABLE clauses and shows you how to use the POSITION parameter.

    
    

    Note: A key point when using multiple INTO TABLE clauses is that field scanning continues from where it left off when a new INTO TABLE clause is processed. The remainder of this section details important ways to make use of that behavior. It also describes alternative ways of using fixed field locations or the POSITION parameter.

    
    

    Distinguishing Different Input Record Formats

    A single datafile might contain records in a variety of formats. Consider the following data, in which emp and dept records are intermixed:

    A record ID field distinguishes between the two formats. Department records have a 1 in the first column, while employee records have a 2. The following control file uses exact positioning to load this data:

    Relative Positioning Based on the POSITION Parameter

    The records in the previous example could also be loaded as delimited data. In this case, however, it is necessary to use the POSITION parameter. The following control file could be used:

    The POSITION parameter in the second INTO TABLE clause is necessary to load this data correctly. It causes field scanning to start over at column 1 when checking for data that matches the second format. Without it, SQL*Loader would look for the recid field after dname.

    Distinguishing Different Input Row Object Subtypes

    A single datafile may contain records made up of row objects inherited from the same base row object type. For example, consider the following simple object type and object table definitions, in which a nonfinal base object type is defined along with two object subtypes that inherit their row objects from the base type:

    The following input datafile contains a mixture of these row objects subtypes. A type ID field distinguishes between the three subtypes. person_t objects have a P in the first column, employee_t objects have an E, and student_t objects have an S.

    The following control file uses relative positioning based on the POSITION parameter to load this data. Note the use of the TREATAS clause with a specific object type name. This informs SQL*Loader that all input row objects for the object table will conform to the definition of the named object type.

    
    

    Note: Multiple subtypes cannot be loaded with the same INTOTABLE statement. Instead, you must use multiple INTOTABLE statements and have each one load a different subtype.

    
    

    Loading Data into Multiple Tables

    By using the POSITION parameter with multiple INTO TABLE clauses, data from a single record can be loaded into multiple normalized tables. See case study 5, Loading Data into Multiple Tables, for an example. (See SQL*Loader Case Studies for information about how to access case studies.).

    Summary

    Multiple INTO TABLE clauses allow you to extract multiple logical records from a single input record and recognize different record formats in the same file.

    For delimited data, proper use of the POSITION parameter is essential for achieving the expected results.

    When the POSITION parameter is not used, multiple INTO TABLE clauses process different parts of the same (delimited data) input record, allowing multiple tables to be loaded from one record. When the POSITION parameter is used, multiple INTO TABLE clauses can process the same record in different ways, allowing multiple formats to be recognized in one input file.

    Bind Arrays and Conventional Path Loads

    SQL*Loader uses the SQL array-interface option to transfer data to the database. Multiple rows are read at one time and stored in the bind array. When SQL*Loader sends the Oracle database an INSERT command, the entire array is inserted at one time. After the rows in the bind array are inserted, a COMMIT statement is issued.

    The determination of bind array size pertains to SQL*Loader's conventional path option. It does not apply to the direct path load method because a direct path load uses the direct path API, rather than Oracle's SQL interface.

    
    

    See Also: Oracle Call Interface Programmer's Guide for more information about the concepts of direct path loading

    
    

    Performance Implications of Bind Arrays

    Large bind arrays minimize the number of calls to the Oracle database and maximize performance. In general, you gain large improvements in performance with each increase in the bind array size up to 100 rows. Increasing the bind array size to be greater than 100 rows generally delivers more modest improvements in performance. The size (in bytes) of 100 rows is typically a good value to use.

    In general, any reasonably large size permits SQL*Loader to operate effectively. It is not usually necessary to perform the detailed calculations described in this section. Read this section when you need maximum performance or an explanation of memory usage.

    Specifying Number of Rows Versus Size of Bind Array

    When you specify a bind array size using the command-line parameter BINDSIZE (see BINDSIZE (maximum size)) or the OPTIONS clause in the control file (see OPTIONS Clause), you impose an upper limit on the bind array. The bind array never exceeds that maximum.

    As part of its initialization, SQL*Loader determines the size in bytes required to load a single row. If that size is too large to fit within the specified maximum, the load terminates with an error.

    SQL*Loader then multiplies that size by the number of rows for the load, whether that value was specified with the command-line parameter ROWS (see ROWS (rows per commit)) or the OPTIONS clause in the control file (see OPTIONS Clause).

    If that size fits within the bind array maximum, the load continues—SQL*Loader does not try to expand the number of rows to reach the maximum bind array size. If the number of rows and the maximum bind array size are both specified, SQL*Loader always uses the smaller value for the bind array.

    If the maximum bind array size is too small to accommodate the initial number of rows, SQL*Loader uses a smaller number of rows that fits within the maximum.

    Calculations to Determine Bind Array Size

    The bind array's size is equivalent to the number of rows it contains times the maximum length of each row. The maximum length of a row is equal to the sum of the maximum field lengths, plus overhead, as follows:

    Many fields do not vary in size. These fixed-length fields are the same for each loaded row. For these fields, the maximum length of the field is the field size, in bytes, as described in SQL*Loader Datatypes. There is no overhead for these fields.

    The fields that can vary in size from row to row are:

    • CHAR

    • DATE

    • INTERVALDAYTOSECOND

    • INTERVALDAYTOYEAR

    • LONGVARRAW

    • numeric EXTERNAL

    • TIME

    • TIMESTAMP

    • TIMEWITHTIMEZONE

    • TIMESTAMPWITHTIMEZONE

    • VARCHAR

    • VARCHARC

    • VARGRAPHIC

    • VARRAW

    • VARRAWC

    The maximum length of these datatypes is described in SQL*Loader Datatypes. The maximum lengths describe the number of bytes that the fields can occupy in the input data record. That length also describes the amount of storage that each field occupies in the bind array, but the bind array includes additional overhead for fields that can vary in size.

    When the character datatypes (CHAR, DATE, and numeric EXTERNAL) are specified with delimiters, any lengths specified for these fields are maximum lengths. When specified without delimiters, the size in the record is fixed, but the size of the inserted field may still vary, due to whitespace trimming. So internally, these datatypes are always treated as varying-length fields—even when they are fixed-length fields.

    A length indicator is included for each of these fields in the bind array. The space reserved for the field in the bind array is large enough to hold the longest possible value of the field. The length indicator gives the actual length of the field for each row.

    
    

    Note: In conventional path loads, LOBFILEs are not included when allocating the size of a bind array.

    
    

    Calculating the Size of Field Buffers

    Table 8-3 through Table 8-6 summarize the memory requirements for each datatype. 'L' is the length specified in the control file. 'P' is precision. 'S' is the size of the length indicator. For more information about these values, see SQL*Loader Datatypes.

    Table 8-3 Fixed-Length Fields

    Datatype	Size in Bytes (Operating System-Dependent)
    INTEGER	The size of the INT datatype, in C
    INTEGER(N)	N bytes
    SMALLINT	The size of SHORT INT datatype, in C
    FLOAT	The size of the FLOAT datatype, in C
    DOUBLE	The size of the DOUBLE datatype, in C
    BYTEINT	The size of UNSIGNED CHAR, in C
    VARRAW	The size of UNSIGNED SHORT, plus 4096 bytes or whatever is specified as max_length
    LONG VARRAW	The size of UNSIGNED INT, plus 4096 bytes or whatever is specified as max_length
    VARCHARC	Composed of 2 numbers. The first specifies length, and the second (which is optional) specifies max_length (default is 4096 bytes).
    VARRAWC	This datatype is for RAW data. It is composed of 2 numbers. The first specifies length, and the second (which is optional) specifies max_length (default is 4096 bytes).

    
    

    Table 8-4 Nongraphic Fields

    Datatype	Default Size	Specified Size
    (packed) DECIMAL	None	(N+1)/2, rounded up
    ZONED	None	P
    RAW	None	L
    CHAR (no delimiters)	1	L + S
    datetime and interval (no delimiters)	None	L + S
    numeric EXTERNAL (no delimiters)	None	L + S

    
    

    Table 8-5 Graphic Fields

    Datatype	Default Size	Length Specified with POSITION	Length Specified with DATATYPE
    GRAPHIC	None	L	2*L
    GRAPHIC EXTERNAL	None	L - 2	2*(L-2)
    VARGRAPHIC	4KB*2	L+S	(2*L)+S

    
    

    Table 8-6 Variable-Length Fields

    Datatype	Default Size	Maximum Length Specified (L)
    VARCHAR	4KB	L+S
    CHAR (delimited)	255	L+S
    datetime and interval (delimited)	255	L+S
    numeric EXTERNAL (delimited)	255	L+S

    
    

    Minimizing Memory Requirements for Bind Arrays

    Pay particular attention to the default sizes allocated for VARCHAR, VARGRAPHIC, and the delimited forms of CHAR, DATE, and numeric EXTERNAL fields. They can consume enormous amounts of memory—especially when multiplied by the number of rows in the bind array. It is best to specify the smallest possible maximum length for these fields. Consider the following example:

    With byte-length semantics, this example uses (10 + 2) * 64 = 768 bytes in the bind array, assuming that the length indicator is 2 bytes long and that 64 rows are loaded at a time.

    With character-length semantics, the same example uses ((10 * s) + 2) * 64 bytes in the bind array, where 's' is the maximum size in bytes of a character in the datafile character set.

    Now consider the following example:

    Regardless of whether byte-length semantics or character-length semantics are used, this example uses (255 + 2) * 64 = 16,448 bytes, because the default maximum size for a delimited field is 255 bytes. This can make a considerable difference in the number of rows that fit into the bind array.

    Calculating Bind Array Size for Multiple INTO TABLE Clauses

    When calculating a bind array size for a control file that has multiple INTOTABLE clauses, calculate as if the INTOTABLE clauses were not present. Imagine all of the fields listed in the control file as one, long data structure—that is, the format of a single row in the bind array.

    If the same field in the data record is mentioned in multiple INTOTABLE clauses, additional space in the bind array is required each time it is mentioned. It is especially important to minimize the buffer allocations for such fields.

    
    

    Note: Generated data is produced by the SQL*Loader functions CONSTANT, EXPRESSION, RECNUM, SYSDATE, and SEQUENCE. Such generated data does not require any space in the bind array.