1  Logical_Names
   This section describes new Oracle Rdb logical names and changes to
   other Oracle Rdb logical names. For complete information on Oracle Rdb
   logical names, see the Oracle Rdb Guide to Database Performance and
   Tuning.
 

2  RDMS$BIND_VM_SEGMENT_Changed
   The logical names RDMS$BIND_VM_SEGMENT changed to RDM$BIND_
   VM_SEGMENT, that is, without the S. This logical name prevents
   memory fragmentation and allows certain applications which would
   otherwise run out of virtual memory to execute correctly.

                                  NOTE

      The RDM$BIND_VM_SEGMENT logical name is not for general
      use, as preserving larger block sizes (by preventing
      fragmentation) may cause problems for some applications.

   To use this logical name use the DCL command as follows:

   $ DEFINE RDM$BIND_VM_SEGMENT 1

   Use this logical name either on the system experiencing the
   problem or in some other appropriate place such as in the
   LOGIN.COM file of the users experiencing the difficulty.
 

2  RDMS$BIND_QG_TIMEOUT
   The RDMS$BIND_QG_TIMEOUT logical name is used to set the query
   optimizer elapsed time limit. The elapsed time that the query
   optimizer spends compiling a query can now be limited by defining
   the logical name RDMS$BIND_QG_TIMEOUT and specifying a value
   in seconds. A timer is established which will cause the query
   compilation to be aborted if too much elapsed time has passed.
   This logical name is translated at attach time and supersedes all
   options specified in the application.

   The following DCL command is used to define the RDMS$BIND_QG_
   TIMEOUT logical name and set a value of 120 seconds.

   $ DEFINE RDMS$BIND_QG_TIMEOUT 120

   In this example, the query optimizer will abort the query
   compilation after 120 seconds have elapsed.

   See the RDMS$BIND_QG_REC_LIMIT help topic at this level for
   information on how to limit the number of records delivered
   during query processing.
 

2  RDMS$BIND_QG_REC_LIMIT
   The RDMS$BIND_QG_REC_LIMIT logical name is used to set the
   query optimizer row number delivery limit. The number of rows
   delivered during query processing can now be limited by defining
   the logical name RDMS$BIND_QG_REC_LIMIT and specifying a value
   of n records. Defining this logical name is useful for any
   query that returns large quantities of rows and is likely to
   do large numbers of I/O operations. This limit counts the rows
   being returned by the query. Note that this value is independent
   of the number of records read by the application, for example
   intermediate records for a join, or component records for an
   aggregate. It is very similar to the LIMIT TO clause in SQL.
   However, if this limit is exceeded, an error message is returned.
   This logical name is translated at attach time and supersedes all
   options specified in the application.

   The following DCL command is used to define the RDMS$BIND_QG_REC_
   LIMIT logical name and set a value of 20 records:

   $ DEFINE RDMS$BIND_QG_REC_LIMIT 20

   In this example, the query optimizer will terminate processing
   the query after 20 records are returned.

   See the RDMS$BIND_QG_TIMEOUT help topic at this level for
   information on how to limit the elapsed time that the query
   optimizer can spend compiling a query.
 

2  RDM$BIND_CKPT_TRANS_INTERVAL
   You can use the RDM$BIND_CKPT_TRANS_INTERVAL logical name to
   define a process-specific checkpoint interval value when undo
   /redo recovery processing is enabled. By default, a process
   checkpoints when the AIJ block size limit is reached or the time
   interval limit is exceeded, whichever occurs first. The RDM$BIND_
   CKPT_TRANS_INTERVAL logical name uses the number of transactions
   as the checkpoint trigger. For example, if you define RDM$BIND_
   CKPT_TRANS_INTERVAL to be 10, the process on which the logical
   is defined checkpoints after committing ten transactions IF the
   transaction limit is reached before the block size or time limits
   are exceeded.
 

2  RDMS$USE_OLD_UPDATE_RULES
   This section discusses use of the RDMS$USE_OLD_UPDATE_RULES
   logical name to preserve update behavior. You cannot modify or
   erase records in a relation if the relation is joined with other
   relations.

                                  NOTE

      This restriction applies to RDO, RDBPRE, and RDML only. SQL
      syntax does not allow this type of update.

   However, updates to a relation are allowed if you join the
   relation with other relations in a subquery.

   This update restriction can cause applications that depend on
   the previous update behavior to fail unless update queries are
   modified. You can use the RDMS$USE_OLD_UPDATE_RULES logical
   name to retain the previous update behavior, then modify your
   applications.

   Define the RDMS$USE_OLD_UPDATE_RULES logical name to be 1, as
   shown below, to enforce the old update rules.

   $ DEFINE RDMS$USE_OLD_UPDATE_RULES 1

   Support for this logical name will be removed in a future release
   of Oracle Rdb.
 

2  RDMS$BIND_WORK_FILE_Changed
   The RDMS$BIND_WORK_FILE logical name is used to redirect the
   location of temporary files that Oracle Rdb sometimes creates for
   use in matching operations. Oracle Rdb creates the file when the
   process running the query runs out of virtual memory, and deletes
   the file once the query is completed.

   You can define RDMS$BIND_WORK_FILE and specify a device name and
   directory. This enables the file to use resource identifiers for
   disk quota allocation.

   The following example shows how to assign the location of
   temporary files to a specific device and directory.

   $ DEFINE RDMS$BIND_WORK_FILE WORK$DISK:[RDB.WORK]