VMS Help  —  RMU72  Using LogMiner for Rdb, Information Returned
    LogMiner for Rdb appends several output fields to the data
    fields, creating an output record. The output record contains
    fixed-length fields in a binary data format (that is, integer
    fields are not converted to text strings). The data fields
    correspond to the extracted table columns. This information
    may or may not be required by all applications and readers of
    the data. There is currently no available method to restrict or
    reorder the output fields.

    Extracted data field contents are the fields that are actually
    stored in the Oracle Rdb database. COMPUTED BY fields are not
    extracted because they are not stored in the database or in the
    after-image journal file. Segmented string (BLOB) contents are
    not extracted.

    Output Fields describes the output fields and data types of an
    output record.

    Table 23 Output Fields

                                 Byte
    Field Name    Data Type      LengthDescription

    ACTION        CHAR (1)       1     Indicates record state.
                                       "M" indicates an insert or
                                       modify action. "D" indicates a
                                       delete action. "E" indicates
                                       stream end-of-file (EOF)
                                       when a callback routine is
                                       being used. "P" indicates
                                       a value from the command
                                       line Parameter qualifier
                                       when a callback routine is
                                       being used (see Parameter
                                       qualifier). "C" indicates
                                       transaction commit information
                                       when the Include=Action=Commit
                                       qualifier is specified.
    RELATION_     CHAR (31)      31    Table name. Space padded to 31
    NAME                               characters.
    RECORD_TYPE   INTEGER        4     The Oracle Rdb internal
                  (Longword)           relation identifier.
    DATA_LEN      SMALLINT       2     Length, in bytes, of the data
                  (Word)               record content.
    NBV_LEN       SMALLINT       2     Length, in bits, of the null
                  (Word)               bit vector content.
    DBK           BIGINT         8     Records logical database key.
                  (Quadword)           The database key is a 3-field
                                       structure containing a 16-
                                       bit line number, a 32-bit
                                       page number and a 16-bit area
                                       number.
    START_TAD     DATE VMS       8     Date-time of the start of the
                  (Quadword)           transaction.
    COMMIT_TAD    DATE VMS       8     Date-time of the commitment of
                  (Quadword)           the transaction.
    TSN           BIGINT         8     Transaction sequence number of
                  (Quadword)           the transaction that performed
                                       the record operation.
    RECORD_       SMALLINT       2     Record version.
    VERSION       (Word)
    Record Data   Varies               Actual data record field
                                       contents.
    Record NBV    BIT VECTOR           Null bit vector. There is
                  (array of            one bit for each field in the
                  bits)                data record. If a bit value
                                       is 1, the corresponding field
                                       is NULL; if a bit value is
                                       0, the corresponding field
                                       is not NULL and contains an
                                       actual data value. The null
                                       bit vector begins on a byte
                                       boundary. Any extra bits in
                                       the final byte of the vector
                                       after the final null bit are
                                       unused.
Close Help