Package org.apache.derby.impl.store.raw.data

Class RAFContainer

  • All Implemented Interfaces:
    java.security.PrivilegedExceptionAction<java.lang.Object>, Cacheable, TypedFormat, Lockable
    Direct Known Subclasses:
    RAFContainer4, TempRAFContainer
    class RAFContainer
extends FileContainer
implements java.security.PrivilegedExceptionAction<java.lang.Object>
    RAFContainer (short for RandomAccessFileContainer) is a concrete subclass of FileContainer for FileContainers which are implemented on java.io.RandomAccessFile.

    • Field Detail

      • needsSync

        protected boolean needsSync

      • actionCode

        private int actionCode

      • CREATE_CONTAINER_ACTION

        private static final int CREATE_CONTAINER_ACTION
        See Also:
        Constant Field Values

      • GET_RANDOM_ACCESS_FILE_ACTION

        private static final int GET_RANDOM_ACCESS_FILE_ACTION
        See Also:
        Constant Field Values

      • REOPEN_CONTAINER_ACTION

        private static final int REOPEN_CONTAINER_ACTION
        See Also:
        Constant Field Values

      • actionStub

        private boolean actionStub

      • actionErrorOK

        private boolean actionErrorOK

      • actionTryAlternatePath

        private boolean actionTryAlternatePath

      • inBackup

        private boolean inBackup

      • inRemove

        private boolean inRemove

      • fileName

        private java.lang.String fileName

    • Method Detail

      • readPage

        protected void readPage​(long pageNumber,
                        byte[] pageData)
                 throws java.io.IOException,
                        StandardException
        Read a page into the supplied array.
        MT - thread safe
        Specified by:
        readPage in class FileContainer
        Throws:
        java.io.IOException - exception reading page
        StandardException - Standard Derby error policy

      • writePage

        protected void writePage​(long pageNumber,
                         byte[] pageData,
                         boolean syncPage)
                  throws java.io.IOException,
                         StandardException
        Write a page from the supplied array.
        MT - thread safe
        Specified by:
        writePage in class FileContainer
        Throws:
        StandardException - Standard Derby error policy
        java.io.IOException - IO error accessing page

      • updatePageArray

        protected byte[] updatePageArray​(long pageNumber,
                                 byte[] pageData,
                                 byte[] encryptionBuf,
                                 boolean encryptWithNewEngine)
                          throws StandardException,
                                 java.io.IOException
        Updates the page array with container header if the page is a first allocation page and encrypts the page data if the database is encrypted.
        Parameters:
        pageNumber - the page number of the page
        pageData - byte array that has the actual page data.
        encryptionBuf - buffer that is used to store encrypted version of the page, or null if encryption is to be skipped
        encryptWithNewEngine - whether to use the new encryption engine for encryption (only considered if encryptionBuf != null)
        Returns:
        byte array of the the page data as it should be on the disk.
        Throws:
        StandardException
        java.io.IOException

      • clean

        public void clean​(boolean forRemove)
           throws StandardException
        Clean the container.

        Write out the container header and sync all dirty pages of this container to disk before returning.

        checkpoint calls this interface through callbacks by telling the cache manager to clean all containers in the open container cache. This sync of the file happens as part of writing and then syncing the container header in writeRAFHeader().

        Specified by:
        clean in interface Cacheable
        Parameters:
        forRemove - Is clean called because container is being removed?
        Throws:
        StandardException - Standard exception policy.

      • clearDirty

        private void clearDirty()

      • preAllocate

        protected int preAllocate​(long lastPreallocPagenum,
                          int preAllocSize)
        Preallocate some pages if need be
        Specified by:
        preAllocate in class FileContainer
        Parameters:
        lastPreallocPagenum - the last preallocated page number as known by the allocation page
        preAllocSize - try to preallocate this page number of pages. Since only the container knows how many pages are actually on disk, it may determine that certain number of pages that the allocation page thinks need to be preallocated is already allocated, in those case, act as if the preallocation is successful.
        Returns:
        number of successfully preallocated page, or 0 if no page has been preallocated

      • truncatePages

        protected void truncatePages​(long lastValidPagenum)
                      throws StandardException
        Truncate pages of a container.

        Truncate all pages from lastValidPagenum+1 through the end of the file.

        Specified by:
        truncatePages in class BaseContainer
        Parameters:
        lastValidPagenum - The page number of the last valid page of the file. All pages after this one are truncated.
        Throws:
        StandardException - Standard exception policy.

      • writeRAFHeader

        private void writeRAFHeader​(java.lang.Object identity,
                            StorageRandomAccessFile file,
                            boolean create,
                            boolean syncFile)
                     throws java.io.IOException,
                            StandardException
        Write the header of a random access file and sync it
        Parameters:
        create - if true, the container is being created if false, the container already exist
        syncFile - if true, sync the file
        Throws:
        java.io.IOException
        StandardException

      • copyFile

        private void copyFile​(StorageFile from,
                      java.io.File to)
               throws StandardException
        Copy the contents of a StorageFile to a java.io.File.
        Parameters:
        from - the file to copy from
        to - the file to copy to
        Throws:
        StandardException - if the copying failed

      • removeFile

        private void removeFile​(java.io.File file)
                 throws StandardException
        Remove a file.
        Parameters:
        file - the file to remove
        Throws:
        StandardException - if the file could not be removed

      • openContainer

        boolean openContainer​(ContainerKey newIdentity)
               throws StandardException
        Description copied from class: FileContainer
        Open a container.

        Longer descrption of routine.

        Open a container. Open the file that maps to this container, if the file does not exist then we assume the container was never created. If the file exists but we have trouble opening it then we throw some exception.
        MT - single thread required - Enforced by cache manager.

        Specified by:
        openContainer in class FileContainer
        Throws:
        StandardException - Standard exception policy.

      • reopenContainer

        protected void reopenContainer​(ContainerKey currentIdentity)
                        throws StandardException
        Only used by RAFContainer4 (NIO) to reopen RAF when its channel gets closed due to interrupts.
        Parameters:
        currentIdentity -
        Throws:
        StandardException - standard exception policy

      • backupContainer

        protected void backupContainer​(BaseContainerHandle handle,
                               java.lang.String backupLocation)
                        throws StandardException
        Backup the container. The container is written to the backup by reading the pages through the page cache, and then writing into the backup container. If the container is dropped(commitetd drop), only container stub is copied to the backup using simple file copy. MT - At any given time only one backup thread is allowed, but when backup in progress DML/DDL operations can run in parallel. Pages are latched while writing them to the backup to avoid copying partial changes to the pages. Online backup does not acquire any user level locks , so users can drop tables when backup is in progress. So it is possible that Container Removal request can come in when container backup is in progress. This case is handled by using the synchronization on this object monitor and using inRemove and inBackup flags. Conatiner removal checks if backup is in progress and wait for the backup to yield to continue the removal. Basic idea is to give preference to remove by stopping the backup of the container temporarily, when the remove container is requested by another thread. Generally, it takes more time to backup a regular container than the stub becuase stub is just one page. After each page copy, a check is made to find if a remove is requested and if it is then backup of the container is aborted and the backup thread puts itself into the wait state until remove request thread notifies that the remove is complete. When remove request compeletes stub is copied into the backup. Compress is blocked when backup is in progesss, so truncation of the container can not happen when backup is in progess. No need to synchronize backup of the container with truncation.
        Specified by:
        backupContainer in class FileContainer
        Parameters:
        handle - the container handle.
        backupLocation - location of the backup container.
        Throws:
        StandardException - Derby Standard error policy

      • encryptOrDecryptContainer

        protected void encryptOrDecryptContainer​(BaseContainerHandle handle,
                                         java.lang.String newFilePath,
                                         boolean doEncrypt)
                                  throws StandardException
        Creates encrypted or decrypted version of the container. Reads all the pages of the container from the original container through the page cache, then either encrypts page data with the new encryption mechanism or leaves the page data un-encrypted, and finally writes the data to the specified new container file.

        The encryption and decryption engines used to carry out the cryptographic operation(s) are configured through the raw store, and accessed via the data factory. Note that the pages have already been decrypted before being put into the page cache.

        Specified by:
        encryptOrDecryptContainer in class BaseContainer
        Parameters:
        handle - the container handle
        newFilePath - file to store the new version of the container in
        doEncrypt - tells whether to encrypt or not
        Throws:
        StandardException - Derby Standard error policy

      • getRandomAccessFile

        private java.io.RandomAccessFile getRandomAccessFile​(java.io.File file)
                                              throws java.io.IOException
        Get a RandomAccessFile for accessing a file in read-write mode.
        Parameters:
        file - the file to access
        Returns:
        a RandomAccessFile
        Throws:
        java.io.FileNotFoundException - if file cannot be opened in read-write mode
        java.io.IOException - if some other I/O error happens

      • run

        public java.lang.Object run()
                     throws StandardException
        Specified by:
        run in interface java.security.PrivilegedExceptionAction<java.lang.Object>
        Throws:
        StandardException