Documentation of 'org.apache.derby.impl.store.raw.data.BaseDataFileFactory' Java class
BaseDataFileFactory
Skip navigation links
org.apache.derby.impl.store.raw.data

Class BaseDataFileFactory

  • All Implemented Interfaces:
    java.security.PrivilegedExceptionAction<java.lang.Object>, CacheableFactory, ModuleControl, ModuleSupportable, Corruptable, DataFactory
    Direct Known Subclasses:
    BaseDataFileFactoryJ4

    public class BaseDataFileFactory
extends java.lang.Object
implements DataFactory, CacheableFactory, ModuleControl, ModuleSupportable, java.security.PrivilegedExceptionAction<java.lang.Object>
    Provides the abstract class with most of the implementation of DataFactory and ModuleControl shared by all the different filesystem implementations.

    RESOLVE (mikem - 2/19/98) - Currently only getContainerClass() is abstract, there are probably more routines which should be abstract. Also the other implementations should probably inherit from the abstract class, rather than from the DataFileFactory class. Also there probably should be a generic directory and the rest of the filesystem implementations parallel to it. I wanted to limit the changes going into the branch and then fix inheritance stuff in main.

    The code in this class was moved over from DataFileFactory.java and then that file was made to inherit from this one.

    • Constructor Detail

      • BaseDataFileFactory

        public BaseDataFileFactory()

    • Method Detail

      • canSupport

        public boolean canSupport(java.util.Properties startParams)
        Description copied from interface: ModuleSupportable
        See if this implementation can support any attributes that are listed in properties. This call may be made on a newly created instance before the boot() method has been called, or after the boot method has been called for a running module.

        The module can check for attributes in the properties to see if it can fulfill the required behaviour. E.g. the raw store may define an attribute called RawStore.Recoverable. If a temporary raw store is required the property RawStore.recoverable=false would be added to the properties before calling bootServiceModule. If a raw store cannot support this attribute its canSupport method would return null. Also see the Monitor class's prologue to see how the identifier is used in looking up properties.
        Actually a better way maybe to have properties of the form RawStore.Attributes.mandatory=recoverable,smallfootprint and RawStore.Attributes.requested=oltp,fast

        Specified by:
        canSupport in interface ModuleSupportable
        Returns:
        true if this instance can be used, false otherwise.

      • boot

        public void boot(boolean create,
                 java.util.Properties startParams)
          throws StandardException
        Description copied from interface: ModuleControl
        Boot this module with the given properties. Creates a module instance that can be found using the findModule() methods of Monitor. The module can only be found using one of these findModule() methods once this method has returned.

        An implementation's boot method can throw StandardException. If it is thrown the module is not registered by the monitor and therefore cannot be found through a findModule(). In this case the module's stop() method is not called, thus throwing this exception must free up any resources.

        When create is true the contents of the properties object will be written to the service.properties of the persistent service. Thus any code that requires an entry in service.properties must explicitly place the value in this properties set using the put method.
        Typically the properties object contains one or more default properties sets, which are not written out to service.properties. These default sets are how callers modify the create process. In a JDBC connection database create the first set of defaults is a properties object that contains the attributes that were set on the jdbc:derby: URL. This attributes properties set has the second default properties set as its default. This set (which could be null) contains the properties that the user set on their DriverManager.getConnection() call, and are thus not owned by Derby code, and thus must not be modified by Derby code.

        When create is false the properties object contains all the properties set in the service.properties file plus a limited number of attributes from the JDBC URL attributes or connection properties set. This avoids properties set by the user compromising the boot process. An example of a property passed in from the JDBC world is the bootPassword for encrypted databases.

        Code should not hold onto the passed in properties reference after boot time as its contents may change underneath it. At least after the complete boot is completed, the links to all the default sets will be removed.

        Specified by:
        boot in interface ModuleControl
        Throws:
        StandardException - Module cannot be started.
        See Also:
        Monitor, ModuleFactory

      • stop

        public void stop()
        Description copied from interface: ModuleControl
        Stop the module. The module may be found via a findModule() method until some time after this method returns. Therefore the factory must be prepared to reject requests to it once it has been stopped. In addition other modules may cache a reference to the module and make requests of it after it has been stopped, these requests should be rejected as well.
        Specified by:
        stop in interface ModuleControl
        Specified by:
        stop in interface DataFactory
        See Also:
        Monitor, ModuleFactory

      • openContainer

        public ContainerHandle openContainer(RawTransaction t,
                                     ContainerKey containerId,
                                     LockingPolicy locking,
                                     int mode)
                              throws StandardException
        Description copied from interface: DataFactory
        Open a container that is not droped.
        Specified by:
        openContainer in interface DataFactory
        Parameters:
        t - the raw transaction that is opening the container
        containerId - the container's identity
        locking - the locking policy
        mode - see the different mode in @see ContainerHandle then will return a null handle if the container is dropped.
        Returns:
        the handle to the opened container
        Throws:
        StandardException - Standard Derby error policy

      • addContainer

        public long addContainer(RawTransaction t,
                         long segmentId,
                         long input_containerid,
                         int mode,
                         java.util.Properties tableProperties,
                         int temporaryFlag)
                  throws StandardException
        Add a container with a specified page size to a segment.
        Specified by:
        addContainer in interface DataFactory
        Parameters:
        t - the transaction that is creating the container
        segmentId - the segment where the container is to go
        mode - whether or not to LOGGED or not. The effect of this mode is only for this addContainer call, not persisently stored throughout the lifetime of the container
        tableProperties - properties of the container that is persistently stored throughout the lifetime of the container
        Returns:
        the containerId of the newly created container
        Throws:
        StandardException - Standard Derby error policy

      • addAndLoadStreamContainer

        public long addAndLoadStreamContainer(RawTransaction t,
                                      long segmentId,
                                      java.util.Properties tableProperties,
                                      RowSource rowSource)
                               throws StandardException
        Add and load a stream container
        Specified by:
        addAndLoadStreamContainer in interface DataFactory
        Parameters:
        t - the transaction that is creating the container
        segmentId - the segment where the container is to go
        tableProperties - properties of the container that is persistently stored throughout the lifetime of the container
        rowSource - the data to load the container with
        Returns:
        the containerId of the newly created stream container
        Throws:
        StandardException - Standard Derby error policy

      • dropContainer

        public void dropContainer(RawTransaction t,
                          ContainerKey ckey)
                   throws StandardException
        Drop a container.

        Synchronisation

        This call will mark the container as dropped and then obtain an CX lock (table level exclusive lock) on the container. Once a container has been marked as dropped it cannot be retrieved by an openContainer() call unless explicitly with droppedOK.

        Once the exclusive lock has been obtained the container is removed and all its pages deallocated. The container will be fully removed at the commit time of the transaction.

        Specified by:
        dropContainer in interface DataFactory
        Throws:
        StandardException - Standard Derby error policy

      • checkpoint

        public void checkpoint()
                throws StandardException
        Implement checkpoint operation, write/sync all pages in cache.

        The derby write ahead log algorithm uses checkpoint of the data cache to determine points of the log no longer required by restart recovery.

        This implementation uses the 2 cache interfaces to force all dirty pages to disk: WRITE DIRTY PAGES TO OS: In the first step all pages in the page cache are written, but not synced (pagecache.cleanAll). The cachemanager cleanAll() interface guarantees that every dirty page that exists when this call is first made will have it's clean() method called. The data cache (CachedPage.clean()), will call writePage but not sync the page. By using the java write then sync, the checkpoint is usually doing async I/O, allowing the OS to schedule multiple I/O's to the file as efficiently as it can. Note that it has been observed that checkpoints can flood the I/O system because these writes are not synced, see DERBY-799 - checkpoint should probably somehow restrict the rate it sends out those I/O's - it was observed a simple sleep every N writes fixed most of the problem. FORCE THOSE DIRTY WRITES TO DISK: To force the I/O's to disk, the system calls each open dirty file and uses the java interface to sync any outstanding dirty pages to disk (containerCache.cleanAll()). The open container cache does this work in RAFContainer.clean() by writing it's header out and syncing the file. (Note if any change is made to checkpoint to sync the writes vs. syncing the file, one probably still needs to write the container header out and sync it).

        Specified by:
        checkpoint in interface DataFactory
        Throws:
        StandardException - Standard exception policy.

      • removeStubsOK

        public void removeStubsOK()
        Description copied from interface: DataFactory
        Tell the data factory it is OK to remove committed deleted containers when the data factory shuts down.
        Specified by:
        removeStubsOK in interface DataFactory

      • getIntParameter

        public int getIntParameter(java.lang.String parameterName,
                           java.util.Properties properties,
                           int defaultValue,
                           int minimumValue,
                           int maximumValue)

      • getRootDirectory

        public java.lang.String getRootDirectory()
        Get the root directory of the data storage area. Is always guaranteed to be an absolute path.

      • getContainerPath

        public StorageFile getContainerPath(ContainerKey containerId,
                                    boolean stub)
        Return the path to a container file.

        Return the path to a container file that is relative to the root directory.

        The format of the name of an existing container file is: segNNN/cXXX.dat The format of the name of a stub describing a dropped container file is: segNNN/dXXX.dat NNN = segment number, currently 0 is where normal db files are found. XXX = The hex representation of the container number The store will always create containers with this format name, but the store will also recognize the following two formats when attempting to open files - as some copy tools have uppercased our filesnames when moving across operating systems: The format of the name of an existing container file is: segNNN/CXXX.DAT The format of the name of a stub describing a dropped container file is: segNNN/DXXX.DAT

        Parameters:
        containerId - The container being opened/created
        stub - True if the file name for the stub is requested, otherwise the file name for the data file
        Returns:
        The StorageFile representing path to container relative to root.

      • getAlternateContainerPath

        public StorageFile getAlternateContainerPath(ContainerKey containerId,
                                             boolean stub)
        Return an alternate path to container file relative to the root directory. The alternate path uses upper case 'C','D', and 'DAT' instead of lower case - there have been cases of people copying the database and somehow upper casing all the file names. The intended use is as a bug fix for track 3444.
        Parameters:
        containerId - The container being opened/created
        stub - True if the file name for the stub is requested, otherwise the file name for the data file

      • stubFileToRemoveAfterCheckPoint

        public void stubFileToRemoveAfterCheckPoint(StorageFile file,
                                            LogInstant logInstant,
                                            java.lang.Object identity)
        keeps track of information about the stub files of the committed deleted containers. We use the info to delete them at checkpoints. In addition to the file info , we also keep track of the identity of the container; which helps to remove entry in the cache and the log instant when the stub was created, which helps us to figure out whether we require the stub file for the crash recovery. We maintain the information in a hashtable: key(LOG INSTANT) Values: File handle , and ContainerIdentity.

      • removeDroppedContainerFileStubs

        public void removeDroppedContainerFileStubs(LogInstant redoLWM)
                                     throws StandardException
        Delete the stub files that are not required for recovery. A stub file is not required to be around if the recovery is not going to see any log record that belongs to that container. Since the stub files are created as a post commit operation, they are not necessary during undo operation of the recovery. To remove a stub file we have to be sure that it was created before the redoLWM in the check point record. We can be sure that the stub is not required if the log instant when it was created is less than the redoLWM.
        Specified by:
        removeDroppedContainerFileStubs in interface DataFactory
        Throws:
        StandardException - Standard Derby error policy

      • databaseEncrypted

        public final boolean databaseEncrypted()
        Description copied from interface: DataFactory
        Returns if data base is in encrypted mode.
        Specified by:
        databaseEncrypted in interface DataFactory
        Returns:
        true if database encrypted false otherwise

      • setDatabaseEncrypted

        public void setDatabaseEncrypted(boolean isEncrypted)
        Sets whether the database is encrypted.
        Specified by:
        setDatabaseEncrypted in interface DataFactory
        Parameters:
        isEncrypted - true if the database is encrypted, false otherwise

      • getEncryptionBlockSize

        public int getEncryptionBlockSize()
        Returns the encryption block size used by the algorithm at time of creation of an encrypted database
        Specified by:
        getEncryptionBlockSize in interface DataFactory

      • getVersionedName

        public java.lang.String getVersionedName(java.lang.String name,
                                         long generationId)

      • getMaxContainerId

        public long getMaxContainerId()
                       throws StandardException
        Return an id which can be used to create a container.

        Return an id number with is greater than any existing container in the current database. Caller will use this to allocate future container numbers - most likely caching the value and then incrementing it as it is used.

        Specified by:
        getMaxContainerId in interface DataFactory
        Returns:
        The an id which can be used to create a container.
        Throws:
        StandardException - Standard exception policy.

      • setupCacheCleaner

        public void setupCacheCleaner(DaemonService daemon)
        Set up the cache cleaner for the container cache and the page cache.
        Specified by:
        setupCacheCleaner in interface DataFactory
        Parameters:
        daemon - daemon service to use for background cleaning

      • unfreezePersistentStore

        public void unfreezePersistentStore()
        Description copied from interface: DataFactory
        Backup restore - start writing dirty pages or container to disk
        Specified by:
        unfreezePersistentStore in interface DataFactory

      • writeInProgress

        public void writeInProgress()
                     throws StandardException
        Description copied from interface: DataFactory
        Backup restore - don't allow the persistent store to be frozen - or if it is already frozen, block. A write is about to commence.
        Specified by:
        writeInProgress in interface DataFactory
        Throws:
        StandardException - Standard Derby error policy

      • writeFinished

        public void writeFinished()
        Description copied from interface: DataFactory
        Backup restore - write finished, if this is the last writer, allow the persistent store to proceed.
        Specified by:
        writeFinished in interface DataFactory

      • isReadOnly

        public boolean isReadOnly()
        Is the store read-only.
        Specified by:
        isReadOnly in interface DataFactory

      • run

        public final java.lang.Object run()
                           throws java.io.IOException,
                                  StandardException
        Specified by:
        run in interface java.security.PrivilegedExceptionAction<java.lang.Object>
        Throws:
        java.io.IOException
        StandardException
Skip navigation links

DataMelt 3.0 © DataMelt by jWork.ORG

You see the box below because you did not login.