Derby - Class org.apache.derby.impl.store.raw.data.BaseDataFileFactory

   Copyright 1998, 2004 The Apache Software Foundation or its licensors, as applicable.

   Licensed under the Apache License, Version 2.0 (the "License");

   you may not use this file except in compliance with the License.

   You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software

   distributed under the License is distributed on an "AS IS" BASIS,

   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   See the License for the specific language governing permissions and

   limitations under the License.

*/

Provides the abstract class with most of the implementation of DataFactory and

ModuleControl shared by all the different filesystem implementations.

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.

that file was made to inherit from this one.

**/

    implements DataFactory, CacheableFactory, ModuleControl, ModuleSupportable, PrivilegedExceptionAction

    private String subSubProtocol;

    StorageFactory storageFactory;

    /* writableStorageFactory == (WritableStorageFactory) storageFactory if storageFactory also

     * implements WritableStorageFactory, null if the storageFactory is read-only.

     */

    WritableStorageFactory writableStorageFactory;

  private     long        nextContainerId = System.currentTimeMillis();

  private     boolean         databaseEncrypted;

  private     CacheManager  pageCache;

  private     CacheManager  containerCache;

  private     LogFactory      logFactory;

  private     ProductVersionHolder jbmsVersion;

  private     RawStoreFactory  rawStoreFactory; // associated raw store factory

  private     String      dataDirectory;   // root directory of files.

    private     boolean         throwDBlckException; // if true throw db.lck

                                                 // exception, even on systems

                                                 // where lock file is not

                                                 // guaranteed.

  private     UUID            identifier;      // unique id for locking

  private     Object          freezeSemaphore;

    // is the data store frozen - protected by freezeSemaphore

  private     boolean         isFrozen;      

    // how many writers are currently active in the data store -

    // protected by freezeSemaphore

  private     int             writersInProgress;

  private boolean removeStubsOK;

  private boolean isCorrupt;

    // the database is being created, no logging

  private boolean inCreateNoLog; 

  // lock against other JBMS opening the same database

  private StorageRandomAccessFile fileLockOnDB;

  private StorageFile exFileLock; //file handle to get exclusive lock

  private HeaderPrintWriter istream;

  private static final String LINE =

  "----------------------------------------------------------------";

    // debug only flag - disable syncing of data during page allocation.

    boolean dataNotSyncedAtAllocation;

    // debug only flag - disable syncing of data during checkpoint.

    boolean dataNotSyncedAtCheckpoint;

  // these fields can be accessed directly by subclasses if it needs a

  // different set of actions

  private PageActions       loggablePageActions;

  private AllocationActions loggableAllocActions;

  private boolean        readOnly;     // is this a read only data store

    private boolean supportsRandomAccess;

  private FileResource      fileHandler;  // my file handler, set by a

                                                // sub-class in its boot method.

  //hash table to keep track of information about dropped containers stubs

  private Hashtable droppedTableStubInfo;

  private Hashtable postRecoveryRemovedFiles;

    // PrivilegedAction actions

    private int actionCode;

    private static final int GET_TEMP_DIRECTORY_ACTION = 1;

    private static final int REMOVE_TEMP_DIRECTORY_ACTION = 2;

    private static final int GET_CONTAINER_PATH_ACTION = 3;

    private ContainerKey containerId;

    private boolean stub;

    private static final int GET_ALTERNATE_CONTAINER_PATH_ACTION = 4;

    private static final int FIND_MAX_CONTAINER_ID_ACTION = 5;

    private static final int DELETE_IF_EXISTS_ACTION = 6;

    private static final int GET_PATH_ACTION = 7;

    private static final int POST_RECOVERY_REMOVE_ACTION = 8;

    private static final int REMOVE_STUBS_ACTION = 9;

    private StorageFile actionFile;

    private static final int BOOT_ACTION = 10;

    private static final int GET_LOCK_ON_DB_ACTION = 11;

    private UUID myUUID;

    private UUIDFactory uuidFactory;

    private String databaseDirectory;

    private static final int RELEASE_LOCK_ON_DB_ACTION = 12;

    private static final int RESTORE_DATA_DIRECTORY_ACTION = 13;

    private String backupPath;

    private File backupRoot;

    private String[] bfilelist;

  /*

  ** Constructor

  */

  public BaseDataFileFactory() {

  }

  /*

  ** Methods of ModuleControl

  */

  public boolean canSupport(Properties startParams) {

    String serviceType = startParams.getProperty(PersistentService.TYPE);

    if (serviceType == null)

      return false;

    if (!handleServiceType(startParams, serviceType))

      return false;

    if (startParams.getProperty(PersistentService.ROOT) == null)

      return false;

    return true;

  }

  public void  boot(boolean create, Properties startParams) throws StandardException {

    jbmsVersion = Monitor.getMonitor().getEngineVersion();

    dataDirectory = startParams.getProperty(PersistentService.ROOT);

    UUIDFactory uf = Monitor.getMonitor().getUUIDFactory();

    identifier = uf.createUUID();

        PersistentService ps = Monitor.getMonitor().getServiceType(this);

        try

        {

            storageFactory =

            ps.getStorageFactoryInstance( true,

                                          dataDirectory,

                                          startParams.getProperty(Property.STORAGE_TEMP_DIRECTORY,

                                                                  PropertyUtil.getSystemProperty(Property.STORAGE_TEMP_DIRECTORY)),

                                          identifier.toANSIidentifier());

        }

        catch( IOException ioe)

        {

            if( create)

                throw StandardException.newException( SQLState.SERVICE_DIRECTORY_CREATE_ERROR, dataDirectory, ioe);

            else

                throw StandardException.newException( SQLState.DATABASE_NOT_FOUND, ioe, dataDirectory);

        }

        if( storageFactory instanceof WritableStorageFactory)

            writableStorageFactory = (WritableStorageFactory) storageFactory;

        actionCode = BOOT_ACTION;

        try{

            AccessController.doPrivileged( this);

        }

        catch( PrivilegedActionException pae) { } // BOOT_ACTION does not throw any exceptions.

       

        String value =

            startParams.getProperty(Property.FORCE_DATABASE_LOCK,

                PropertyUtil.getSystemProperty(Property.FORCE_DATABASE_LOCK));

        throwDBlckException =

            Boolean.valueOf(

                (value != null ? value.trim() : value)).booleanValue();

    if (!isReadOnly())    // read only db, not interested in filelock

      getJBMSLockOnDB(identifier, uf, dataDirectory);

    // restoreFrom and createFrom operations also need to know if database is encrypted

    String dataEncryption = startParams.getProperty(Attribute.DATA_ENCRYPTION);

    databaseEncrypted = Boolean.valueOf(dataEncryption).booleanValue();

    //If the database is being restored/created from backup

    //the restore the data directory(seg*) from backup

    String restoreFrom =null;

    restoreFrom = startParams.getProperty(Attribute.CREATE_FROM);

    if(restoreFrom == null)

      restoreFrom = startParams.getProperty(Attribute.RESTORE_FROM);

    if(restoreFrom == null)

      restoreFrom = startParams.getProperty(Attribute.ROLL_FORWARD_RECOVERY_FROM);

    if(restoreFrom !=null)

    {

      try{

        restoreDataDirectory(restoreFrom);

      }catch(StandardException se)

      {

        releaseJBMSLockOnDB();

        throw se;

      }

    }

    logMsg(LINE);

    long bootTime = System.currentTimeMillis();

    logMsg(CheapDateFormatter.formatDate(bootTime) +

         MessageService.getTextMessage(MessageId.STORE_BOOT_MSG,

                           jbmsVersion,

                        identifier,

                        dataDirectory));

    uf = null;

    CacheFactory cf = (CacheFactory) Monitor.startSystemModule(org.apache.derby.iapi.reference.Module.CacheFactory);

      int pageCacheSize = getIntParameter(

          RawStoreFactory.PAGE_CACHE_SIZE_PARAMETER,

                    null,

                    RawStoreFactory.PAGE_CACHE_SIZE_DEFAULT,

                    RawStoreFactory.PAGE_CACHE_SIZE_MINIMUM,

                    RawStoreFactory.PAGE_CACHE_SIZE_MAXIMUM);

    pageCache =

        cf.newCacheManager(this,

                    "PageCache",

                    pageCacheSize / 2,

                    pageCacheSize);

      int fileCacheSize = getIntParameter(

          "derby.storage.fileCacheSize",

                    null,

                    100,

                    2,

                    100);

    containerCache = cf.newCacheManager(this, "ContainerCache", fileCacheSize / 2, fileCacheSize);

    if (create)

    {

      String noLog =

        startParams.getProperty(Property.CREATE_WITH_NO_LOG);

      inCreateNoLog = (noLog != null && Boolean.valueOf(noLog).booleanValue());

    }

    freezeSemaphore = new Object();

    droppedTableStubInfo = new Hashtable();

        if (Performance.MEASURE)

        {

            // debug only flag - disable syncing of data during checkpoint.

            dataNotSyncedAtCheckpoint =

                PropertyUtil.getSystemBoolean(

                    Property.STORAGE_DATA_NOT_SYNCED_AT_CHECKPOINT);

            // debug only flag - disable syncing of data during page allocation.

            dataNotSyncedAtAllocation =

                PropertyUtil.getSystemBoolean(

                    Property.STORAGE_DATA_NOT_SYNCED_AT_ALLOCATION);

            if (dataNotSyncedAtCheckpoint)

                Monitor.logMessage(

                    "Warning: " +

                    Property.STORAGE_DATA_NOT_SYNCED_AT_CHECKPOINT +

                    "set to true.");

            if (dataNotSyncedAtAllocation)

                Monitor.logMessage(

                    "Warning: " +

                    Property.STORAGE_DATA_NOT_SYNCED_AT_ALLOCATION +

                    "set to true.");

    }

        fileHandler = new RFResource( this);

  } // end of boot

  public void  stop() {

    boolean OK = false;

    if (rawStoreFactory != null)

    {

      DaemonService rawStoreDaemon = rawStoreFactory.getDaemon();

      if (rawStoreDaemon != null)

        rawStoreDaemon.stop();

    }

    long shutdownTime = System.currentTimeMillis();

    logMsg("\n" + CheapDateFormatter.formatDate(shutdownTime) +

                MessageService.getTextMessage(

                    MessageId.STORE_SHUTDOWN_MSG,

                    getIdentifier()));

    istream.println(LINE);

    if (!isCorrupt) {

      try {

        if (pageCache != null && containerCache != null) {

          pageCache.shutdown();

          containerCache.shutdown();

          OK = true;

        }

      } catch (StandardException se) {

        se.printStackTrace(istream.getPrintWriter());

      }

    }

    removeTempDirectory();

    if (isReadOnly())    // do enough to close all files, then return

        {

      return;

        }

    // re-enable stub removal until a better method can be found.

    // only remove stub if caches are cleaned

    if (removeStubsOK && OK) 

      removeStubs();

    releaseJBMSLockOnDB();

  } // end of stop

  /*

  ** CacheableFactory

  */

  public Cacheable newCacheable(CacheManager cm) {

    if (cm == pageCache) {

      StoredPage sp = new StoredPage();

      sp.setFactory(this);

      return sp;

    }

    // container cache

    return newContainerObject();

  }

  /**

    Database creation finished

    @exception StandardException Standard cloudscape exception policy.

  */

  public void createFinished() throws StandardException

  {

    if (!inCreateNoLog)

        {

      throw StandardException.newException(

                SQLState.FILE_DATABASE_NOT_IN_CREATE);

        }

    // the changes in cache are not logged, they have to be flushed to disk

    checkpoint();

    inCreateNoLog = false;

  }

  /*

  ** Methods of DataFactory

  */

 

  public ContainerHandle openContainer(RawTransaction t,

                     ContainerKey containerId,

                     LockingPolicy locking,

                     int mode)

    throws StandardException {

      return openContainer(t, containerId, locking, mode,

             false /* is not dropped */);

  }

  /**

    @see DataFactory#openDroppedContainer

    @exception StandardException Standard Cloudscape error policy

  */

  public RawContainerHandle openDroppedContainer(RawTransaction t,

                     ContainerKey containerId, 

                     LockingPolicy locking,

                     int mode)

     throws StandardException 

  {

    // since we are opening a possible dropped container

    // lets not add any actions that will take palce on a commit.

    mode |= ContainerHandle.MODE_NO_ACTIONS_ON_COMMIT;

      return openContainer(t, containerId, locking, mode,

                 true /* droppedOK */);

  }

  /**

    @see DataFactory#openContainer

    @exception StandardException Standard Cloudscape error policy

  */

  private RawContainerHandle openContainer(RawTransaction t, ContainerKey identity,

                     LockingPolicy locking,

                     int mode, boolean droppedOK)

     throws StandardException

  {

    if (SanityManager.DEBUG) {

      if ((mode & (ContainerHandle.MODE_READONLY | ContainerHandle.MODE_FORUPDATE))

        == (ContainerHandle.MODE_READONLY | ContainerHandle.MODE_FORUPDATE))

        SanityManager.THROWASSERT("update and readonly mode specified");

    }

    boolean waitForLock = ((mode & ContainerHandle.MODE_LOCK_NOWAIT) == 0);

    if ((mode & ContainerHandle.MODE_OPEN_FOR_LOCK_ONLY) != 0) {

     

      // Open a container for lock only, we don't care if it exists, is

            // deleted or anything about it. The container handle we return is

            // closed and cannot be used for fetch or update etc.

      BaseContainerHandle lockOnlyHandle = 

                new BaseContainerHandle(

                    getIdentifier(), t, identity, locking, mode);

      if (lockOnlyHandle.useContainer(true, waitForLock))

        return lockOnlyHandle;

      else

        return null;

    }

    BaseContainerHandle c;

    // see if the container exists 

    FileContainer container = (FileContainer) containerCache.find(identity);

    if (container == null)

      return null;

   

    if (identity.getSegmentId() == ContainerHandle.TEMPORARY_SEGMENT) {

      if (SanityManager.DEBUG) {

        SanityManager.ASSERT(container instanceof TempRAFContainer);

      }

      if ((mode & ContainerHandle.MODE_TEMP_IS_KEPT) == ContainerHandle.MODE_TEMP_IS_KEPT) {

        // if the mode is kept, then, we do not want to truncate

        mode |= ContainerHandle.MODE_UNLOGGED;

      } else {

        // this should be OK even if the table was opened read-only

        mode |= ContainerHandle.MODE_UNLOGGED | ContainerHandle.MODE_TRUNCATE_ON_ROLLBACK;

      }

     

      locking =

                t.newLockingPolicy(

                    LockingPolicy.MODE_NONE,

                    TransactionController.ISOLATION_NOLOCK, true);

    } else {

      // real tables

      if (inCreateNoLog)

        mode |= (ContainerHandle.MODE_UNLOGGED | ContainerHandle.MODE_CREATE_UNLOGGED);

      // make sure everything is logged if logArchived is turn on

      // clear all UNLOGGED flag

      if (!inCreateNoLog && logFactory.logArchived())

        mode &= ~(ContainerHandle.MODE_UNLOGGED |

              ContainerHandle.MODE_CREATE_UNLOGGED);

      // if mode is UNLOGGED but not CREATE_HNLOGGED, then force the

      // container from cache when the transaction commits.  For

      // CREATE_UNLOGGED, client has the responsibility of forcing the

      // cache.

      if (((mode & ContainerHandle.MODE_UNLOGGED) == ContainerHandle.MODE_UNLOGGED) &&

        ((mode & ContainerHandle.MODE_CREATE_UNLOGGED) == 0)) {

        mode |= ContainerHandle.MODE_FLUSH_ON_COMMIT;

      }

    }

    PageActions pageActions = null;

    AllocationActions allocActions = null;

    if ((mode & ContainerHandle.MODE_FORUPDATE) ==

      ContainerHandle.MODE_FORUPDATE) 

    {

      if ((mode & ContainerHandle.MODE_UNLOGGED) == 0)

      {

        // get the current loggable actions

        pageActions = getLoggablePageActions();

        allocActions = getLoggableAllocationActions();

       

      } else {

        // unlogged

        pageActions = new DirectActions();

        allocActions = new DirectAllocActions();

        // RESOLVE: need to get rid of this automatic escalation if

        // MODE_CREATE_UNLOGGED for sure, why need it at all?

        //

        //  locking = t.newLockingPolicy(LockingPolicy.MODE_CONTAINER,

        //    TransactionController.ISOLATION_SERIALIZABLE, true);

      }

    }

    c = new BaseContainerHandle(getIdentifier(), t, pageActions,

                  allocActions, locking, container, mode); 

    // see if we can use the container

    try {

      if (!c.useContainer(droppedOK, waitForLock)) {

        containerCache.release(container);

        return null;

      }

    } catch (StandardException se) {

      containerCache.release(container);

      throw se;

    }

    return c;

   

  }

  /** Add a container with a specified page size to a segment.

    @exception StandardException Standard Cloudscape error policy

  */

  public long addContainer(

    RawTransaction  t,

    long            segmentId,

    long            input_containerid,

    int             mode,

    Properties      tableProperties,

    int             temporaryFlag)

        throws StandardException

  {

    if (SanityManager.DEBUG) {

      if ((mode & ContainerHandle.MODE_CREATE_UNLOGGED) != 0)

        SanityManager.ASSERT(

                    (mode & ContainerHandle.MODE_UNLOGGED) != 0,

                    "cannot have CREATE_UNLOGGED set but UNLOGGED not set");

    }

        // If client has provided a containerid then use it, else use the

        // internally generated one from getNextId().

        long containerId =

            ((input_containerid != ContainerHandle.DEFAULT_ASSIGN_ID) ?

                 input_containerid : getNextId());

    ContainerKey identity = new ContainerKey(segmentId, containerId);

    boolean tmpContainer = (segmentId == ContainerHandle.TEMPORARY_SEGMENT);

    ContainerHandle ch = null;

    LockingPolicy   cl = null;

    if (!tmpContainer)

        {

      // lock the container before we create it.

      if (isReadOnly())

            {

        throw StandardException.newException(

                        SQLState.DATA_CONTAINER_READ_ONLY);

            }

      cl = t.newLockingPolicy(LockingPolicy.MODE_CONTAINER,

          TransactionController.ISOLATION_SERIALIZABLE, true);

     

      if (SanityManager.DEBUG)

        SanityManager.ASSERT(cl != null);

      ch = t.openContainer(identity, cl,

                   (ContainerHandle.MODE_FORUPDATE |

                    ContainerHandle.MODE_OPEN_FOR_LOCK_ONLY));

    }

    FileContainer container =

      (FileContainer) containerCache.create(identity, tableProperties);

    // create the first alloc page and the first user page,

    // if this fails for any reason the transaction

    // will roll back and the container will be dropped (removed)

    ContainerHandle containerHdl = null;

    Page            firstPage    = null;

    try {

      // if opening a temporary container with IS_KEPT flag set,

      // make sure to open it with IS_KEPT too.

      if (tmpContainer &&

        ((temporaryFlag & TransactionController.IS_KEPT) ==

                     TransactionController.IS_KEPT))

            {

        mode |= ContainerHandle.MODE_TEMP_IS_KEPT;

      }

      // open no-locking as we already have the container locked

      containerHdl =

                t.openContainer(

                    identity, null, (ContainerHandle.MODE_FORUPDATE | mode));

      // we just added it, containerHdl should not be null

            if (SanityManager.DEBUG)

                SanityManager.ASSERT(containerHdl != null);

      if (!tmpContainer)

            {

        // make it persistent (in concept if not in reality)

        RawContainerHandle rch = (RawContainerHandle)containerHdl;

        ContainerOperation lop =

          new ContainerOperation(rch, ContainerOperation.CREATE);

        // mark the container as pre-dirtied so that if a checkpoint

        // happens after the log record is sent to the log stream, the

        // cache cleaning will wait for this change.

        rch.preDirty(true);

        try

        {

          t.logAndDo(lop);

          // flush the log to reduce the window between where

          // the container is created & synced and the log record

          // for it makes it to disk. If we fail in this

          // window we will leave a stranded container file.

          flush(t.getLastLogInstant());

        }

        finally

        {

          // in case logAndDo fail, make sure the container is not

          // stuck in preDirty state.

          rch.preDirty(false);

        }

      }

      firstPage = containerHdl.addPage();

    } finally {

      if (firstPage != null) {

        firstPage.unlatch();

        firstPage = null;

      }

     

      containerCache.release(container);

      if (containerHdl != null) {

        containerHdl.close();

        containerHdl = null;

      }

      if (!tmpContainer)

            {

                // this should do nothing, since we requested isolation 3

                // but we can't assume that, so call the policy correctly.

        cl.unlockContainer(t, ch); 

      }

    }

    return containerId;

  }

  /** Add and load a stream container

    @exception StandardException Standard Cloudscape error policy

  */

  public long addAndLoadStreamContainer(RawTransaction t, long segmentId,

      Properties tableProperties, RowSource rowSource)

    throws StandardException

  {

    long containerId = getNextId();

    ContainerKey identity = new ContainerKey(segmentId, containerId);

    // create and load the stream container

    StreamFileContainer sContainer = new StreamFileContainer(identity, this, tableProperties);

    sContainer.load(rowSource);

    return containerId;

  }

  /**

    open an exsisting streamContainer

    @see DataFactory#openStreamContainer

    @exception StandardException Standard Cloudscape error policy

  */

  public StreamContainerHandle openStreamContainer(

    RawTransaction  t,

    long            segmentId,

    long            containerId,

    boolean         hold)

     throws StandardException

  {

    ContainerKey identity = new ContainerKey(segmentId, containerId);

    StreamFileContainerHandle c;

    // open the container with the identity

    StreamFileContainer container = new StreamFileContainer(identity, this);

    container = container.open(false);

    if (container == null)

      return null;

    c = new StreamFileContainerHandle(getIdentifier(), t, container, hold); 

    // see if we can use the container

    if (c.useContainer())

      return c;

    else

      return null;

  }

  /**

    Drop a stream container.

      <P><B>Synchronisation</B>

    <P>

    This call will remove the container.

    @exception StandardException Standard Cloudscape error policy

  */

  public void dropStreamContainer(RawTransaction t, long segmentId, long containerId)

    throws StandardException

  {

    boolean tmpContainer = (segmentId == ContainerHandle.TEMPORARY_SEGMENT);

    StreamContainerHandle containerHdl = null;

    try

    {

      ContainerKey ckey = new ContainerKey(segmentId, containerId);

      // close all open containers and 'onCommit' objects of this container

      t.notifyObservers(ckey);

      containerHdl = t.openStreamContainer(segmentId, containerId, false);

      if (tmpContainer && (containerHdl != null))

      {

        containerHdl.removeContainer();

        return;

      }

    }

    finally

    {

      if (containerHdl != null)

        containerHdl.close();

    }

  }

  /**

    re-Create a container during recovery load tran.

    called ONLY during recovery load tran.

    @exception StandardException Standard Cloudscape Error policy

   */

  public void reCreateContainerForLoadTran(RawTransaction t,

      long segmentId, long containerId, ByteArray containerInfo)

     throws StandardException

  {

    if (SanityManager.DEBUG)

      SanityManager.ASSERT(segmentId != ContainerHandle.TEMPORARY_SEGMENT,

        "Cannot recreate temp container during load tran");

    ContainerKey identity = new ContainerKey(segmentId, containerId);

    // no need to lock container during load tran

    // no need to create any page for the container, they will be created

    // as their log records are encountered later in load tran

    FileContainer container =

      (FileContainer)containerCache.create(identity, containerInfo);

    containerCache.release(container);

  }

  /**

    Drop a container.

      <P><B>Synchronisation</B>

    <P>

    This call will mark the container as dropped and then obtain an CX lock

    on the container. Once a container has been marked as dropped it cannot

    be retrieved by an openContainer() call unless explicitly with droppedOK.

    <P>

    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.

    @exception StandardException Standard Cloudscape error policy

  */

  public void dropContainer(RawTransaction t, ContainerKey ckey)

     throws StandardException

  {

    boolean tmpContainer =

            (ckey.getSegmentId() == ContainerHandle.TEMPORARY_SEGMENT);

    LockingPolicy cl = null;

    if (!tmpContainer) {

      if (isReadOnly())

            {

        throw StandardException.newException(

                        SQLState.DATA_CONTAINER_READ_ONLY);

            }

      cl =

                t.newLockingPolicy(

                    LockingPolicy.MODE_CONTAINER,

                    TransactionController.ISOLATION_SERIALIZABLE, true);

   

      if (SanityManager.DEBUG)

        SanityManager.ASSERT(cl != null);

    }

    // close all open containers and 'onCommit' objects of this container

    t.notifyObservers(ckey);

    RawContainerHandle containerHdl = (RawContainerHandle)

      t.openContainer(ckey, cl, ContainerHandle.MODE_FORUPDATE);

    // If container is already dropped or is no longer there, throw

    // containerVanished exception unless container is temporary, in that

    // case just return.  Upper layer is supposed to prevent such from

    // happening thru some means other than the lock we are getting here.

    try

    {

      if (containerHdl == null ||

        containerHdl.getContainerStatus() != RawContainerHandle.NORMAL)

      {

        // If we are a temp container, don't worry about it.

        if (tmpContainer)

        {

          if (containerHdl != null)

            containerHdl.removeContainer((LogInstant)null);

          return;

        }

        else

                {

          throw StandardException.newException(

                            SQLState.DATA_CONTAINER_VANISHED, ckey);

                }

      }

      // Container exist, is updatable and we got the lock.

      if (tmpContainer)

      {

        containerHdl.dropContainer((LogInstant)null, true);

        containerHdl.removeContainer((LogInstant)null);

      }

      else

      {

        ContainerOperation lop =

          new ContainerOperation(containerHdl, ContainerOperation.DROP);

        // mark the container as pre-dirtied so that if a checkpoint

        // happens after the log record is sent to the log stream, the

        // cache cleaning will wait for this change.

        containerHdl.preDirty(true);

        try

        {

          t.logAndDo(lop);

        }

        finally

        {

          // in case logAndDo fail, make sure the container is not

          // stuck in preDirty state.

          containerHdl.preDirty(false);

        }

        // remember this as a post commit work item

        Serviceable p = new ReclaimSpace(ReclaimSpace.CONTAINER, ckey,

                         this, true /* service ASAP */);

        if (SanityManager.DEBUG)

                {

                    if (SanityManager.DEBUG_ON(DaemonService.DaemonTrace))

                    {

                        SanityManager.DEBUG(

                            DaemonService.DaemonTrace,

                            "Add post commit work " + p);

                    }

                }

        t.addPostCommitWork(p);

      }

    }

    finally

    {

      if (containerHdl != null)

        containerHdl.close();

    }

  }

  public void checkpoint() throws StandardException {

    pageCache.cleanAll();

    containerCache.cleanAll();

  }

  public void idle() throws StandardException {

    pageCache.ageOut();

    containerCache.ageOut();

  }

  public void setRawStoreFactory(RawStoreFactory rsf, boolean create,

                   Properties startParams)

     throws StandardException

  {

    rawStoreFactory = rsf;

    /*

     * boot the log factory here because different implementation of the

     * data  factory wants different types of log factory

     */

    bootLogFactory(create, startParams);

  }

  /**

    Return my unique identifier

    @see DataFactory#getIdentifier

  */

  public UUID getIdentifier() {

    return identifier;

  }

  /*

  ** Called by post commit daemon, calling ReclaimSpace.performWork()

  */

  public int reclaimSpace(Serviceable work, ContextManager contextMgr)

     throws StandardException

  {

    if (work == null)

      return Serviceable.DONE;

    Transaction tran =

            rawStoreFactory.findUserTransaction(

                contextMgr, AccessFactoryGlobals.SYS_TRANS_NAME);

    if (SanityManager.DEBUG)

    {

      SanityManager.ASSERT(tran != null, "null transaction");

      if (SanityManager.DEBUG_ON(DaemonService.DaemonTrace))

        SanityManager.DEBUG(DaemonService.DaemonTrace,

                  "Performing post commit work " + work);

    }

    return ReclaimSpaceHelper.reclaimSpace(this, (RawTransaction)tran,

                         (ReclaimSpace)work);

  }

  /**

    Really this is just a convience routine for callers that might not

    have access to a log factory.

  */

  public StandardException markCorrupt(StandardException originalError) {

    boolean firsttime = !isCorrupt;

    isCorrupt = true;

    if (getLogFactory() != null)