Class InsertOperation

    • Field Detail

      • doMeSlot

        protected int doMeSlot
      • insertFlag

        protected byte insertFlag
      • startColumn

        protected transient int startColumn
        next column that need to be inserted.
      • preparedLog

        protected transient ByteArray preparedLog
    • Method Detail

      • writeExternal

        public void writeExternal​(java.io.ObjectOutput out)
                           throws java.io.IOException
        Write this out.
        Specified by:
        writeExternal in interface java.io.Externalizable
        Overrides:
        writeExternal in class LogicalPageOperation
        Throws:
        java.io.IOException - error writing to log stream
      • readExternal

        public void readExternal​(java.io.ObjectInput in)
                          throws java.io.IOException,
                                 java.lang.ClassNotFoundException
        Read this in
        Specified by:
        readExternal in interface java.io.Externalizable
        Overrides:
        readExternal in class LogicalPageOperation
        Throws:
        java.io.IOException - error reading from log stream
        java.lang.ClassNotFoundException - log stream corrupted
      • getTypeFormatId

        public int getTypeFormatId()
        Return my format identifier.
        Returns:
        The identifier. (A UUID stuffed in an array of 16 bytes).
      • doMe

        public void doMe​(Transaction xact,
                         LogInstant instant,
                         LimitObjectInput in)
                  throws StandardException,
                         java.io.IOException
        Description copied from interface: Loggable
        Apply the change indicated by this operation and optional data. If this method fail, the system will be shut down because the log record has already been written to disk. Moreover, the log record will be replayed during recovery and this doMe method will be called on the same page again, so if it fails again, recovery will fail and the database cannot be started. So it is very important to make sure that every resource you need, such as disk space, has been acquired before the logAndDo method is called!
        This method cannot acquire any resource (like latching of a page) since it is called underneath the logging system, ie., the log record has already been written to the log stream.

        The available() method of in indicates how much data can be read, i.e. how much was originally written.

        Parameters:
        xact - the Transaction
        instant - the log instant of this operation
        in - optional data
        Throws:
        java.io.IOException - Can be thrown by any of the methods of ObjectInput.
        StandardException - Standard Derby policy.
        See Also:
        Loggable.doMe(org.apache.derby.iapi.store.raw.Transaction, org.apache.derby.iapi.store.raw.log.LogInstant, org.apache.derby.iapi.services.io.LimitObjectInput)
      • restoreLoggedRow

        public void restoreLoggedRow​(java.lang.Object[] row,
                                     LimitObjectInput in)
                              throws StandardException,
                                     java.io.IOException
        Restore the row stored in the optional data of the log record.
        Parameters:
        row - an IN/OUT parameter, caller passed in the row with the correct column number and type, the log operation will restore the row with the optional data stored in the log record.
        Throws:
        java.io.IOException - error reading from log stream
        StandardException - Standard Derby error policy
        See Also:
        LogicalUndo
      • restoreMe

        public void restoreMe​(Transaction xact,
                              BasePage undoPage,
                              LogInstant CLRinstant,
                              LimitObjectInput in)
                       throws StandardException,
                              java.io.IOException
        restore the before image of the page
        Specified by:
        restoreMe in class PageBasicOperation
        Parameters:
        xact - the Transaction doing the rollback
        undoPage - the page to rollback changes on
        CLRinstant - the log instant of this (PageUndo) operation
        in - optional data for the rollback operation
        Throws:
        StandardException - Standard Derby Error Policy
        java.io.IOException - problem reading the complete log record from the input stream
      • getPreparedLog

        public ByteArray getPreparedLog()
        Description copied from class: PageBasicOperation
        the default for optional data is set to null. If an operation has optional data, the operation need to prepare the optional data for this method. WARNING: If a log operation extends this class, and the operation has optional data, it MUST overwrite this method to return a ByteArray that contains the optional data.
        Specified by:
        getPreparedLog in interface Loggable
        Overrides:
        getPreparedLog in class PageBasicOperation
      • getNextStartColumn

        public int getNextStartColumn()
      • writeOptionalDataToBuffer

        private void writeOptionalDataToBuffer​(RawTransaction t,
                                               DynamicByteArrayOutputStream logBuffer,
                                               java.lang.Object[] row,
                                               FormatableBitSet validColumns,
                                               boolean isLongColumn,
                                               int realStartColumn,
                                               int realSpaceOnPage,
                                               int overflowThreshold)
                                        throws StandardException,
                                               java.io.IOException
        Writes out the row that is to be inserted as the optional data.
        Throws:
        java.io.IOException - Can be thrown by any of the methods of ObjectOutput
        StandardException - Standard Derby policy.