1 – ANSI_FORMAT
Syntax options:
ANSI_FORMAT
NOANSI_FORMAT
Specifies whether the SQL precompiler accepts terminal-format
COBOL or ANSI-format COBOL.
The default is the terminal format COBOL NOANSI_FORMAT qualifier.
2 – ARCHITECTURE
Syntax options:
ARCHITECTURE=GENERIC
ARCHITECTURE=HOST
ARCHITECTURE=EV4
ARCHITECTURE=EV5
ARCHITECTURE=EV56
ARCHITECTURE=PCA56
ARCHITECTURE=EV6
ARCHITECTURE=EV67
ARCHITECTURE=EV68
ARCHITECTURE=EV7
For improved performance of generated code, the ARCHITECTURE
command line qualifier can be used on OpenVMS Alpha systems. The
ARCHITECTURE qualifier is ignored on Itanium systems.
The ARCHITECTURE qualifier specifies the lowest version of the
Alpha architecture where this code will run. This allows the
compiler to generate more efficient code, with the tradeoff that
code may not run on older systems.
All Alpha processors implement a core set of instructions and, in
some cases, the following extensions:
o Byte/word extension (BWX) - The instructions that comprise the
BWX extension are LDBU, LDWU, SEXTB, SEXTW, STB, and STW.
o Square-root and floating-point convert extension (FIX) - The
instructions that comprise the FIX extension are FTOIS, FTOIT,
ITOFF, ITOFS, ITOFT, SQRTF, SQRTG, SQRTS, and SQRTT.
o Count extension (CIX) - The instructions that comprise the CIX
extension are CTLZ, CTPOP, and CTTZ.
o Multimedia extension (MVI) - The instructions that comprise
the MVI extension are MAXSB8, MAXSW4, MAXUB8, MAXUW4, MINSB8,
MINSW4, MINUB8, MINUW4, PERR, PKLB, PKWB, UNPKBL, and UNPKBW.
The Alpha Architecture Reference Manual describes the extensions
in detail.
The keyword specified with the ARCHITECTURE qualifier determines
which instructions the compiler can generate and which coding
rules it must follow.
o GENERIC - Generate instructions that are appropriate for all
Alpha processors. This option is the default and is equivalent
to /ARCH=EV4.
o HOST - Generate instructions for the processor that the
compiler is running on (for example, EV56 instructions on
an EV56 processor, EV7 instructions on an EV7 processor, and
so on).
o EV4 - Generate instructions for the EV4 processor (21064,
20164A, 21066, and 21068 chips). Applications compiled with
this option will not incur any emulation overhead on any Alpha
processor.
o EV5 - Generate instructions for the EV5 processor (some 21164
chips). (Note that the EV5 and EV56 processors both have the
same chip number - 21164.) Applications compiled with this
option will not incur any emulation overhead on any Alpha
processor.
o EV56 - Generate instructions for EV56 processors (some 21164
chips). This option permits the compiler to generate any
EV4 instruction plus any instructions contained in the BWX
extension. Applications compiled with this option may incur
emulation overhead on EV4 and EV5 processors.
o PCA56 - Generate instructions for PCA56 processors (21164PC
chips). This option permits the compiler to generate any EV4
instruction plus any instructions contained in the BWX and MVI
extensions. Applications compiled with this option may incur
emulation overhead on EV4 and EV5 processors.
o EV6 - Generate instructions for EV6 processors (21264
chips). This option permits the compiler to generate any
EV4 instruction, any instruction contained in the BWX and
MVI extensions, plus any instructions added for the EV6
chip. These new instructions include a floating-point square
root instruction (SQRT), integer/floating-point register
transfer instructions, and additional instructions to identify
extensions and processor groups. Applications compiled with
this option may incur emulation overhead on EV4, EV5, EV56,
and PCA56 processors.
o EV67 or EV68 - Generate instructions for EV67 and EV68
processors (21264A chips). This option permits the
compiler to generate any EV6 instruction plus the new bit
count instructions (CTLZ, CTPOP, and CTTZ). However, the
precompilers do not currently generate any of the new bit
count instructions and the EV67 and EV68 have identical
instruction scheduling models so the EV67 and EV68 are
essentially identical to the EV6. Applications compiled with
this option may incur emulation overhead on EV4, EV5, EV56,
and PCA56 processors.
o EV7 - Generate instructions for the EV7 processor (21364
chip). This option permits the compiler to generate any EV67
instruction. There are no additional instructions available
on the EV7 processor but the compiler does have different
instruction scheduling and prefetch rules for tuning code
for the EV7. Applications compiled with this option may incur
emulation overhead on EV4, EV5, EV56, and PCA56 processors.
The OpenVMS Alpha operating system includes an instruction
emulator. This capability allows any Alpha chip to execute and
produce correct results from Alpha instructions even if some of
the instructions are not implemented on the chip. Applications
using emulated instructions will run correctly but may incur
significant emulation overhead at run time.
Of the available extension types, the Byte/word extension (BWX)
will often be beneficial for increased performance of Rdb-based
applications. In addition, for those Alpha implementations
that support quad-issue of instructions (the EV6 and later
processors), the compiler does have different instruction
scheduling and prefetch rules for tuning code.
For highest levels of performance of generated code, Oracle
recommends that the ARCHITECTURE qualifier be specified with
the keyword that most closely matches the lowest processor type
of the machine where the program will execute.
LANGUAGE COMPILER SUPPORT FOR ARCHITECTURE
If specified, the ARCHITECTURE qualifier is passed on the
command line to the specified language compiler by the SQL
Precompiler. The language compiler being used must support
the ARCHITECTURE qualifier and the architecture keyword
value when the ARCHITECTURE qualifier is specified.
3 – c-string-options
Controls how SQL handles C host language character strings.
Use either or both of the [NO]BLANK_FILL and [NO]FIXED_CDD_
STRINGS options with the C_STRING keyword to control C string
characteristics.
4 – C_STRING
Syntax options:
SQLOPTIONS= (C_STRING=[NO]BLANK_FILL)
SQLOPTIONS= (C_STRING=[NO]FIXED_CDD_STRINGS)
SQLOPTIONS= (C_STRING=([NO]BLANK_FILL, [NO]FIXED_CDD_STRINGS))
Specifies how to handle C host language character strings:
o [NO]BLANK_FILL (default: BLANK_FILL)
Controls whether or not C character strings are filled with
blanks as required by the SQL89 and ANSI/ISO SQL standards or
if the null terminator is placed after the last data byte of
the source string.
o [NO]FIXED_CDD_STRINGS (default: NOFIXED_CDD_STRINGS)
Controls whether or not SQL treats C character strings from
CDD/Repository record definitions as fixed-length character
strings or C null-terminated strings.
5 – CONNECT
Syntax options:
SQLOPTIONS= (CONNECT)
SQLOPTIONS= (NOCONNECT)
Specifies whether or not SQL allows multiple user connections
and access to global databases across modules. All SQL modules
in an application must be compiled with connections enabled or
disabled.
The SQLOPTIONS=NOCONNECT qualifier is the default.
6 – CONSTRAINT_MODE
Syntax options:
SQLOPTIONS= (CONSTRAINT_MODE=IMMEDIATE)
SQLOPTIONS= (CONSTRAINT_MODE=DEFERRED)
SQLOPTIONS= (CONSTRAINT_MODE=ON)
SQLOPTIONS= (CONSTRAINT_MODE=OFF)
You can optionally specify either the SQLOPTIONS=(CONSTRAINT_
MODE=IMMEDIATE) or SQLOPTIONS=(CONSTRAINT_MODE=DEFERRED)
qualifier on the SQL precompiler command line to set the
default constraint evaluation mode for commit-time constraints.
(This qualifier does not affect the evaluation of verb-time
constraints.) The default is DEFERRED; that is, commit-time
constraints are evaluated at commit time.
Setting constraints IMMEDIATE causes each affected constraint
to be evaluated immediately, as well as at the end of each
statement, until the SET ALL CONSTRAINTS DEFERRED statement
is issued, or until the transaction completes with a commit or
rollback operation.
The SET ALL CONSTRAINTS statement overrides the constraint
evaluation mode specified in the SQLOPTIONS qualifier. For more
information about the default constraint mode, see the Oracle Rdb
SQL Reference Manual.
SQL users who require ANSI-standard SQL compatibility should set
constraints as IMMEDIATE. The default (CONSTRAINT_MODE=DEFERRED)
is acceptable for most other users.
The qualifiers CONSTRAINT_MODE=ON and CONSTRAINT_MODE=OFF
duplicate the behavior of the qualifiers CONSTRAINT_
MODE=IMMEDIATE and CONSTRAINT_MODE=DEFERRED, respectively.
7 – context-file-name
An SQL command procedure containing DECLARE statements that you
want to apply when your program compiles and executes. See the
Oracle Rdb SQL Reference Manual for information about context-
file-name.
8 – database-options
Specifies that the SQL precompiler correctly processes a program
for access to the specified database type. For more information
regarding database options, see the Oracle Rdb SQL Reference
Manual.
The precompiler database option can in turn be overridden by an
attach to a database at run time. On the DECLARE statement, SQL
sets the database options of the specified database.
By default, the SQL precompiler determines the valid database
from the database used to compile the program. If no database
is used to compile the program, the precompiler processes the
program for a database created with the most recent version of
Oracle Rdb.
9 – DECLARE_MESSAGE_VECTOR
Syntax options:
SQLOPTIONS= (DECLARE_MESSAGE_VECTOR)
SQLOPTIONS= (NODECLARE_MESSAGE_VECTOR)
Specifies that the RDB$MESSAGE_VECTOR structure be declared in
the host language as part of the SQLCA during SQLPRE processing.
You can use this switch with language compilers that support the
'$' special character.
The default is the SQLOPTIONS=(DECLARE_MESSAGE_VECTOR) qualifier.
10 – EXTEND_SOURCE
Syntax options:
EXTEND_SOURCE
NOEXTEND_SOURCE
Allows the SQL precompiler to view 132 columns of FORTRAN source
rather than the default of 72 columns.
11 – EXTERNAL_GLOBALS
Syntax options:
SQLOPTIONS= (EXTERNAL_GLOBALS)
SQLOPTIONS= (NOEXTERNAL_GLOBALS)
Specifies whether or not alias references are coerced into alias
definitions. An alias definition is an alias declared with the
GLOBAL keyword (the default) in the DECLARE ALIAS statement. An
alias reference is an alias declared with the EXTERNAL keyword in
the DECLARE ALIAS statement.
The EXTERNAL_GLOBALS qualifier treats alias references as alias
definitions. This qualifier provides compatibility with versions
prior to V7.0.
The NOEXTERNAL_GLOBALS qualifier treats alias references as alias
references. The NOEXTERNAL_GLOBALS qualifier may be useful on
OpenVMS if your application shares an alias between multiple
shareable images.
The default on OpenVMS is the SQLOPTIONS=(EXTERNAL_GLOBALS)
qualifier.
For information on using aliases and shareable images, see the
Oracle Rdb Guide to SQL Programming.
12 – FLAG_NONSTANDARD
Syntax options:
SQLOPTIONS= (FLAG_NONSTANDARD)
SQLOPTIONS= (FLAG_NONSTANDARD=SQL92_ENTRY)
SQLOPTIONS= (FLAG_NONSTANDARD=SQL89)
SQLOPTIONS= (FLAG_NONSTANDARD=MIA)
SQLOPTIONS= (NOFLAG_NONSTANDARD)
Specifies whether or not SQL identifies nonstandard syntax.
Nonstandard syntax, called an extension, refers to syntax that
is not part of the ANSI/ISO SQL standard or the Multivendor
Integration Architecture (MIA) standard. You can specify the
following options:
o (FLAG_NONSTANDARD)
Notifies you of syntax that is an extension to the ANSI/ISO
SQL standard.
o (FLAG_NONSTANDARD=SQL92_ENTRY)
Notifies you of syntax that is an extension to the ANSI/ISO
SQL standard. This qualifier has the same effect on flagging
as does the (FLAG_NONSTANDARD) qualifier.
o (FLAG_NONSTANDARD=SQL89)
Notifies you of syntax that is an extension to the ANSI/ISO
1989 standard.
o (FLAG_NONSTANDARD=MIA)
Notifies you of syntax that is an extension to the MIA
standard.
o (NOFLAG_NONSTANDARD)
Prevents notification of extensions.
The default is the SQLOPTIONS=(NOFLAG_NONSTANDARD) qualifier.
13 – FLOAT
Syntax options:
FLOAT=D_FLOAT
FLOAT=G_FLOAT
FLOAT=IEEE_FLOAT
Specifies the floating point representation that the SQL
precompiler uses for floating point data types in a formal
parameter list and specifies the floating point qualifier passed
to the language compiler.
The SQL Precompiler translates embedded SQL into host language
declarations and procedure calls. In addition it generates the
procedures behind the procedure calls. The /FLOAT qualifier
for SQL$PRE determines the floating point format that SQL$PRE
assumes for host language variables and, hence, determines the
conversions that will be made internal to the generated SQL
procedures. When SQL$PRE calls the host language compiler to
process the precompiled program it passes an equivalent qualifier
to its /FLOAT qualifer that is supported by the host language.
This means that to the extent that the floating point format
of host language variables is determined by a /FLOAT qualifier,
the floating point formats of the host language variables and
the parameters of procedure calls generated by SQL$PRE are
guaranteed to be compatible. When the host language provides
a type which explicitly declares the floating point format of
the an individual variable, SQL$PRE uses that information to
determine the conversion needed regardless of the setting of the
/FLOAT qualifier.
The SQL Precompiler's default floating point format for single
or double precision floating point types is F-Floating and G-
Floating format, respectively. This is equivalent to using a
qualifier of /FLOAT=G_FLOAT with the SQL$PRE command.
If a host language variable is a record or structure (for example
a qualified parameter in the INTO clause of a singleton SELECT
statement), any fields in the record or structure that are of a
floating point type follow the same rules as described above.
NOTE
The Common Data Dictionary supports floating point types.
However when the /FLOAT qualifier specifies IEEE_FLOAT,
these types may not be used.
14 – G_FLOAT
Syntax options:
G_FLOAT
NOG_FLOAT
The /G_FLOAT and /NOG_FLOAT qualifiers are for backwards
compatibility. They are equivalent to /FLOAT=G_FLOAT and
/FLOAT=D_FLOAT, respectively. You should not specify both /FLOAT
and /[NO]G_FLOAT qualifiers.
15 – INITIALIZE_HANDLES
Syntax options:
SQLOPTIONS= (INITIALIZE_HANDLES)
SQLOPTIONS= (NOINITIALIZE_HANDLES)
Specifies whether or not alias definitions are coerced into alias
references. The NOINITIALIZE_HANDLES qualifier causes all alias
declarations to be treated as alias references.
An alias definition is an alias declared with the GLOBAL keyword
(the default) in the DECLARE ALIAS statement. An alias reference
is an alias declared with the EXTERNAL keyword in the DECLARE
ALIAS statement.
The NOINITIALIZE_HANDLES qualifier may be useful for existing
source code on OpenVMS in coercing alias definitions into alias
references. Because there is usually no distinction between a
definition and a reference on OpenVMS, your application might
declare an alias definition where an alias reference is needed.
If you reorganize your application into multiple images that
share aliases, you must distinguish the alias definition from
the alias reference. In this case, use the NOINITIALIZE_HANDLES
qualifier to coerce a definition into a reference without
changing your source code.
If your application correctly declares alias references with the
EXTERNAL keyword, use the NOEXTERNAL_GLOBALS qualifier, instead
of [NO]INITIALIZE_HANDLES to override the default on OpenVMS and
cause SQL to treat alias references properly as references.
The default is the SQLOPTIONS=INITIALIZE_HANDLES qualifier. This
qualifier overrides the [NO]EXTERNAL_GLOBALS qualifier.
The SQLOPTIONS=[NO]INITIALIZE_HANDLES qualifier is maintained for
compatibility with previous versions of Oracle Rdb. For V7.0 and
higher, use the [NO]EXTERNAL_GLOBALS qualifier, which provides
more precise control over alias definition.
For information on using aliases and shareable images, see the
Oracle Rdb Guide to SQL Programming.
16 – LIST
Syntax options:
LIST
NOLIST
Oracle Rdb determines whether or not the SQL precompiler
generates a list file (default file extension .lis) that contains
information about the SQL compilation and the host language
compilation. In addition, if the logical name SQL$KEEP_PREP_FILES
is defined, the SQL precompiler retains an intermediate module
list file (file extension .mli), which contains information about
the SQL compilation only. If you specify the LIST qualifier and
do not include a file specification, the SQL precompiler creates
a list file with the same file name as your source file with the
file extension .lis.
The NOLIST qualifier is the default.
17 – MACHINE_CODE
Syntax options:
MACHINE_CODE
NOMACHINE_CODE
Oracle Rdb specifies whether or not the SQL precompiler includes
machine code in the list file; however, to generate the list
file with the machine code in it, you must also specify the LIST
qualifier.
The NOMACHINE_CODE qualifier is the default.
18 – OBJECT
Syntax options:
OBJECT
NOOBJECT
Specifies whether or not the SQL precompiler creates an object
file when compiling the source file if the compilation does not
generate fatal errors; and, if an object file is produced, what
the file is named. If you specify the OBJECT qualifier and do
not include a file specification, the precompiler creates an
object file with the same file name as the source file and the
file extension .obj. You can specify the OBJECT qualifier for any
language except Ada.
The OBJECT qualifier is the default.
19 – OPTIMIZATION_LEVEL
Specifies the optimizer strategy to be used to process all
queries within your SQL module language program. Select the:
o AGGRESSIVE_SELECTIVITY option if you expect a small number of
rows to be selected.
o DEFAULT option to accept the Oracle Rdb defaults: FAST_FIRST
and DEFAULT SELECTIVITY.
o FAST_FIRST option if you want your program to return data to
the user as quickly as possible, even at the expense of total
throughput.
o SAMPLED_SELECTIVITY option to use literals in the query to
perform preliminary estimation on indices.
o TOTAL_TIME option if you want your program to run at the
fastest possible rate, returning all the data as quickly as
possible. If your application runs in batch, accesses all the
records in a query, and performs updates or writes reports,
you should specify TOTAL_TIME.
You can select either the TOTAL_TIME or the FAST_FIRST option in
conjunction with either the AGGRESSIVE_SELECTIVITY or SAMPLED_
SELECTIVITY option. Use a comma to separate the keywords and
enclosed the list in parentheses.
The following example shows how to use the OPTIMIZATION_LEVEL
qualifier:
$ SQL$PRE/SQLOPTIONS=OPTIMIZATION_LEVEL=(TOTAL_TIME,SAMPLED_SELECTIVITY) APPCODE.SC
Any query that explicitly includes an OPTIMIZE WITH, or OPTIMIZE_
FOR clause is not affected by the settings established using the
OPTIMIZATION_LEVEL qualifier.
You affect the optimizer strategy of static SQL queries with
the optimization level qualifier; however, the default optimizer
strategy set by the OPTIMIZATION_LEVEL option can be overridden
by the default optimizer strategy set in a top-level SELECT
statement.
In contrast, the SET OPTIMIZATION LEVEL statement specifies the
query optimization level for dynamic SQL query compilation only;
the statement does not affect the SQL compile-time environment
nor does it affect the run-time environment of static queries.
20 – PASSWORD_DEFAULT
Syntax options:
SQLOPTIONS= (PASSWORD_DEFAULT=password)
Specifies the user's password at compile time.
If you use the USING DEFAULT clause of the DECLARE ALIAS
statement, you use this qualifier to pass the compile-time user's
password to the program.
21 – pre-host-file-spec
The file specification for a host language source file that
contains embedded SQL statements. The default file extension
for the source file depends on the host language specified in the
language qualifier.
Language Default File Extension
Ada .sqlada
C .sc
COBOL .sco
FORTRAN .sfo
Pascal .spa
PL/I .spl
If the host language is Ada or COBOL, the file name (without the
file extension) cannot be longer than 27 characters.
The precompiler command line allows a list of host language
source files in this argument, but only processes the first file
specification it encounters. If you specify a list of files, the
precompiler:
o Gives a warning message that only the first file on the line
will be precompiled
o Ignores the other file specifications and passes them along to
the host language compiler in the same order as they appeared
on the precompiler command line
For instance, the following command lines are valid, but only the
MY_FILE host language file is precompiled:
$ SQLPRE/PLI/LIS/DEB MY_FILE+MY_TLB_1/LIB+MY_TLB_2/LIB
$ SQLPRE/PASCAL MY_FILE,MY_OTHER_FILE
$ SQLPRE/COB/DEB MY_FILE,MY_NODB_FILE
$ SQLPRE/CC MY_FILE+REST_OF_APPL+APPL_TLB/LIB
For the previous command lines, the precompiler passes the
following corresponding command lines to the host language
compiler:
$ PLI/LIS/DEB MY_FILE.PLI;n+MY_TLB_1/LIB+MY_TLB_2/LIB/NOG_FLOAT
$ PAS MY_FILE.PAS;n,MY_OTHER_FILE
$ COB/DEB MY_FILE.COB;n,MY_NODB_FILE
$ CC MY_FILE.C;n+REST_OF_APPL+APPL_TLB/LIB/NOG_FLOAT
The ;n notation signifies the version number of the host language
file generated by the SQL precompiler.
22 – pre-lang-qualifiers
Refers to the host language in which the program containing
embedded SQL procedures is written. You must supply a language
qualifier. The host language qualifier values are ADA, CC,
CC=VAXC, CC=DECC, COBOL, FORTRAN, PASCAL, and PLI.
The following statements apply to the CC SQL precompiler switch:
o The CC=VAXC switch instructs the precompiler to compile
the source as a VAXC source. If the VAXC compiler is not
installed, the DECC compiler is used with the /STANDARD=VAXC
host language compiler switch.
o The CC=DECC switch instructs the precompiler to compile
the source as a DECC source. If the DECC compiler is not
installed, you will get a DCL error.
o The default keyword, either VAXC or DECC, is based on your
system configuration. If the VAXC compiler is installed on
your system, VAXC is the default keyword. If the DECC compiler
is installed, DECC is the default keyword. If both compilers
are installed, the default is based on whichever C compiler
your system manager has specified.
23 – pre-qualifiers
Refers to the optional qualifiers allowed on the SQL precompiler
command line.
24 – PRAGMA
Syntax options:
SQLOPTIONS= (PRAGMA = IDENT = string-literal)
SQLOPTIONS= (NOPRAGMA)
Using the IDENT keyword with the PRAGMA qualifier allows the user
to pass a text string to the SQL Precompiler to be written to the
Object Module Header. This is a way to note the generation of the
compiler module.
If the PRAGMA (IDENT ...) clause is used as part of the DECLARE
MODULE statement, then that value will override any value used on
the command line.
The ANALYZE/OBJECT and LIBRARY command can be used to display
this ident string, and the value will be displayed in LINKER map
files.
OpenVMS limits the IDENT string to a 15 octet string. If the
string is longer than this (even with trailing spaces) then an
error will be reported by the SQL precompiler.
The following example demonstrates the use of the qualifier to
establish the generation of the compiler module.
$ SQL$PRE/CC TEST/SQLOPTION=(PRAGMA=IDENT="v1.2-32")
25 – QUERY_CPU_TIME_LIMIT
Syntax options:
SQLOPTIONS= (QUERY_CPU_TIME_LIMIT=total-seconds)
Limits the amount of CPU time used to optimize a query for
execution. If the query is not optimized and prepared for
execution before the CPU time limit is reached, an error message
is returned.
The default is unlimited time for the query to compile. Dynamic
SQL options are inherited from the compilation qualifier.
26 – QUERY_ESTIMATES
Syntax options:
SQLOPTIONS= (QUERY_ESTIMATES)
SQLOPTIONS= (NOQUERY_ESTIMATES)
Specifies whether or not SQL returns the estimated number
of rows and estimated number of disk I/O operations in
the SQLCA structure. If you specify the QUERY_ESTIMATES
keyword, SQL returns the estimated number of rows in the field
SQLCA.SQLERRD[2] and the estimated number of disk I/O operations
in the field SQLCA.SQLERRD[3]. The value of SQLCA.SQLERRD[2]
and SQLCA.SQLERRD[3] is normally 0 after you execute an OPEN
statement for a table.
The SQLOPTIONS=QUERY_ESTIMATES qualifier is the default.
27 – QUERY_MAX_ROWS
Syntax options:
SQLOPTIONS= (QUERY_MAX_ROWS=total-rows)
Limits the number of records returned during query processing by
counting the number of rows returned by the query and returning
an error message if the query exceeds the total number of rows
specified.
The default is an unlimited number of record fetches. Dynamic SQL
options are inherited from the compilation qualifier.
28 – QUERY_TIME_LIMIT
Syntax options:
SQLOPTIONS= (QUERY_TIME_LIMIT=total-seconds)
Limits the number of records returned during query processing
by counting the number of seconds used to process the query and
returning an error message if the query exceeds the total number
of seconds specified.
The default is unlimited time for the query to compile. Dynamic
SQL options are inherited from the compilation qualifier.
29 – QUIET_COMMIT___NOQUIET_COMMIT
Syntax options:
SQLOPTIONS= (QUIET_COMMIT)
SQLOPTIONS= (NOQUIET_COMMIT)
QUIET COMMIT disables error reporting for the COMMIT and ROLLBACK
statements if either statement is executed when no transaction is
active.
By default, if there is no active transaction, SQL will raise
an error when COMMIT or ROLLBACK is executed. This default,
(NOQUIET_COMMIT), is retained for backward compatibility for
applications that wish to detect the situation. If QUIET_COMMIT
is specified, a COMMIT or ROLLBACK executes successfully when
there is no active transaction.
NOTE
Within a compound statement, the COMMIT and ROLLBACK
statements are always ignored if no transaction is active.
30 – ROLLBACK_ON_EXIT
Syntax options:
SQLOPTIONS= (ROLLBACK_ON_EXIT)
Rolls back outstanding transactions when a program exits from
SQL.
On OpenVMS, outstanding transactions are committed when a program
exits from SQL by default. Therefore, if you want to roll back
changes, specify this qualifier on the command line.
31 – TRANSACTION_DEFAULT
Syntax options:
SQLOPTIONS= (TRANSACTION_DEFAULT = IMPLICIT)
SQLOPTIONS= (TRANSACTION_DEFAULT = DISTRIBUTED)
SQLOPTIONS= (NOTRANSACTION_DEFAULT)
Specifies when SQL starts a transaction and how SQL handles
default distributed transactions. You can specify the following
options:
o SQLOPTIONS = (TRANSACTION_DEFAULT = IMPLICIT)
Causes SQL to start a transaction when you issue either a SET
TRANSACTION statement or the first executable SQL statement in
a session.
o SQLOPTIONS = (TRANSACTION_DEFAULT = DISTRIBUTED)
Causes SQL to use the distributed transaction identifier
(TID) for the default distributed transaction established
by the DECdtm system service SYS$START_TRANS. Using this
option eliminates the need to declare context structures in
SQL precompiled programs and to use the USING CONTEXT clause
in embedded SQL statements. Because it closes all cursors,
it also eliminates the need to call the SQL_CLOSE_CURSORS
routine.
You must explicitly call the DECdtm system services when you
use this option.
This option provides support for the Structured Transaction
Definition Language (STDL) of the Multivendor Integration
Architecture (MIA) standard.
If you specify the USING CONTEXT clause in embedded SQL
statements, you must declare a context structure.
o SQLOPTIONS=(NOTRANSACTION_DEFAULT)
Causes SQL not to start a transaction unless you execute a SET
TRANSACTION statement. If you use this qualifier and issue an
executable statement without first issuing a SET TRANSACTION
statement, SQL returns an error.
The default is SQLOPTIONS = (TRANSACTION_DEFAULT = IMPLICIT).
32 – USER_DEFAULT
Syntax options:
SQLOPTIONS= (USER_DEFAULT=username)
Specifies the user name at compile time.
If you use the USER DEFAULT clause of the DECLARE ALIAS
statement, you use this qualifier to pass the compile-time user
name to the program.
33 – WARN
Syntax options:
SQLOPTIONS= WARN
SQLOPTIONS= NOWARN
Specifies whether or not the SQL precompiler writes informational
and warning messages to the preprocessed host language source
file and to SYS$ERROR and SYS$OUTPUT (if different from
SYS$ERROR). The WARN qualifier accepts the following options:
o [NO]WARNING
Specifies whether or not the SQL precompiler writes
informational and warning messages to your terminal, a list
file, or both.
o [NO]DEPRECATE
Specifies whether or not the SQL precompiler writes diagnostic
messages about deprecated features.
Deprecated features are features that are currently allowed
but will not be allowed in future versions of SQL; that is,
they will be obsolete. For example, one deprecated feature is
the use of obsolete keywords such as VERB_TIME instead of VERB
TIME. A complete list of deprecated features appears on line
in the interactive SQL Help utility.
The SQLOPTIONS=WARN qualifier is equivalent to the
SQLOPTIONS=WARN=(WARNING, DEPRECATE) qualifier. The
SQLOPTIONS=NOWARN qualifier is equivalent to the
SQLOPTIONS=WARN=(NOWARNING, NODEPRECATE) qualifier.
You can specify the SQLOPTIONS=WARN=WARNING qualifier if you
prefer to have all warning messages except those about deprecated
features. You can specify the SQLOPTIONS=WARN=(NOWARNING,
DEPRECATE) qualifier if you prefer the deprecated feature
messages only.
34 – warning-option
Specifies whether the SQL precompiler writes warning or
diagnostic messages to your terminal, a list file, or both. Use
either or both the [NO]WARNING or [NO]DEPRECATE options with the
WARN qualifier. If you specify only a single warning option, you
do not need to use parentheses.