Examples of org.apache.derby.iapi.store.raw.ContainerHandle

org.apache.derby.iapi.store.raw.ContainerHandle
A Container contains a contigious address space of pages, the pages start at page number Container.FIRST_PAGE_NUMBER and are numbered sequentially. The page size is set at addContainer() time. RESOLVE: this style of coding is not currently enforced If the caller calls getPage (or one of its variants) more than once on the same page, the caller must call unlatch a corresponding number of times in order to ensure that the page is latched. For example:
```
 Container c; Page p1 = c.getPage(Container.FIRST_PAGE_NUMBER); Page p2 = c.getPage(Container.FIRST_PAGE_NUMBER); p1.unlatch();  -- Page is still latched. p2.unlatch();  -- Page is now unlatched. 
```
There is no restriction on the order in which latching and unlatching is done. In the example, p1 could have been unlatched after p2 with no ill effects.
Open container modes ContainerHandle.MODE are used to open or create the container. Unlike TableProperties, MODEs are not permanantely associated with the container, it is effective only for the lifetime of the containerHandle itself.
A container may use any of these mode flags when it is opened.
- MODE_READONLY - Open the container in read only mode.
- MODE_FORUPDATE - Open the container in update mode, if the underlying storage does not allow updates then the container will be opned in read only mode.
- MODE_UNLOGGED - If Unset, any changes to the container are logged. If set, any user changes to the container are unlogged. It is guaranteed at commit time that all changes made during the transaction will have been flushed to disk. Using this mode automatically opens the container in container locking, isolation 3 level. The state of the container following an abort or any type of rollback is unspecified.
- MODE_CREATE_UNLOGGED - If set, not only are user changes to the container are unlogged, page allocations are also unlogged. This MODE is only useful for container is created in the same statement and no change on the container (other than the create) is ever logged. The difference between MODE_UNLOGGED and MODE_CREATE_UNLOGGED is that page allocation is also unlogged and commit of nested transaction will not cause the container to be forced from the cache. Unlike MODE_UNLOGGED, MODE_CREATE_UNLOGGED does not force the cache. It is up to the client of raw store to force the cache at the appropriate time - this allows a statement to create and open the container serveral times for bulk loading without logging or doing any synchronous I/O.
- MODE_LOCK_NOWAIT - if set, then don't wait for the container lock, else wait for the container lock. This flag only dictates whether the lock should be waited for or not. After the container is successfully opened, whether this bit is set or not has no effect on the container handle.
If neither or both of the {MODE_READONLY, MODE_FORUPDATE} modes are specified then the behaviour of the container is unspecified.
MODE_UNLOGGED must be set for MODE_CREATE_UNLOGGED to be set.
Temporary Containers
If when creating a container the segment used is ContainerHandle.TEMPORARY_SEGMENT then the container is a temporary container. Temporary containers are not logged or locked and do not live across re-boots of the system. In addition any abort or rollback including rollbacks to savepoints truncate the container if it has been opened for update since the last commit or abort. Temporary containers are private to a transaction and must only be used a single thread within the transaction at any time, these restrictions are not currently enforced.
When opening a temporary container for update access these additional mode flags may be used
- MODE_TRUNCATE_ON_COMMIT - At commit/abort time container is truncated.
- MODE_DROP_ON_COMMIT - At commit/abort time the container is dropped.
- MODE_TEMP_IS_KEPT - At commit/abort time the container is kept around.
If a temporary container is opened multiple times in the same transaction with different modes then the most severe mode is used, ie. none < truncate on commit < drop on commit. The MODE_UNLOGGED, MODE_CREAT_UNLOGGED flags are ignored when opening a temporary container, not logged is always assumed.

   * @exception  StandardException  Standard exception policy.
     **/
    public void setEstimatedRowCount(long count)
    throws StandardException
    {
        ContainerHandle container = open_conglom.getContainer();


        if (container == null)
            open_conglom.reopen();


        open_conglom.getContainer().setEstimatedRowCount(

View Full Code Here




        // need to open the container and insert the row.  Since we are
        // creating it no need to bother with locking since no one can get
        // to it until after we have created it and returned it's id.
        ContainerHandle container = null;
        Page            page      = null;


        try
        {
            container = 
                rawtran.openContainer(
                    id, (LockingPolicy) null, 
                    ContainerHandle.MODE_FORUPDATE | 
                        (isTemporary() ? ContainerHandle.MODE_TEMP_IS_KEPT : 0));


            // row in slot 0 of heap page 1 which is just a single column with
            // the heap entry.
            DataValueDescriptor[] control_row = new DataValueDescriptor[1];
            control_row[0] = this;


            page =
                container.getPage(ContainerHandle.FIRST_PAGE_NUMBER);


            page.insertAtSlot(
                Page.FIRST_SLOT_NUMBER,
                control_row,
                (FormatableBitSet) null,
                (LogicalUndo) null, 
                Page.INSERT_OVERFLOW,
                AccessFactoryGlobals.HEAP_OVERFLOW_THRESHOLD);
            page.unlatch();
            page = null;


            // Don't include the control row in the estimated row count.
            container.setEstimatedRowCount(0, /* unused flag */ 0);
        }
        finally
        {
            if (container != null)
                container.close();
            if (page !=null)
                page.unlatch();
        }
  }

View Full Code Here

    Storable            template_column)
        throws StandardException
    {
        // need to open the container and update the row containing the 
        // serialized format of the heap.  
        ContainerHandle container = null;
        Page            page      = null;
        Transaction     rawtran   = xact_manager.getRawStoreXact();


        try
        {
            container = 
                rawtran.openContainer(
                    id, 
                    rawtran.newLockingPolicy(
                        LockingPolicy.MODE_CONTAINER,
                        TransactionController.ISOLATION_SERIALIZABLE, true),
                    ContainerHandle.MODE_FORUPDATE | 
                        (isTemporary() ? ContainerHandle.MODE_TEMP_IS_KEPT : 0));


            if (column_id != format_ids.length)
            {
                if (SanityManager.DEBUG)
                    SanityManager.THROWASSERT(
                        "column_id = " + column_id +
                        "format_ids.length = " + format_ids.length +
                        "format_ids = " + format_ids);


                throw(StandardException.newException(
                        SQLState.HEAP_TEMPLATE_MISMATCH,
                        new Long(column_id), 
                        new Long(this.format_ids.length)));
            }


            // create a new array, and copy old values to it.
            int[] old_format_ids = format_ids;
            format_ids              = new int[old_format_ids.length + 1];
            System.arraycopy(
                old_format_ids, 0, format_ids, 0, old_format_ids.length);


            // add the new column
            format_ids[old_format_ids.length] = 
                template_column.getTypeFormatId();


           
            // row in slot 0 of heap page 1 which is just a single column with
            // the heap entry.
            DataValueDescriptor[] control_row = new DataValueDescriptor[1];
            control_row[0] = this;


            page =
                container.getPage(ContainerHandle.FIRST_PAGE_NUMBER);


            page.updateAtSlot(
                Page.FIRST_SLOT_NUMBER,
                control_row,
                (FormatableBitSet) null);


            page.unlatch();
            page = null;
        }
        finally
        {
            if (container != null)
                container.close();
            if (page !=null)
                page.unlatch();
        }


        return;

View Full Code Here

    OpenConglomerate    open_conglom)
        throws StandardException
    {
        super.init(open_conglom);


        ContainerHandle container = open_conglom.getContainer();


        // look up costs from raw store.
        num_rows  = container.getEstimatedRowCount(/*unused flag*/ 0);


        // Don't use 0 rows (use 1 instead), as 0 rows often leads the 
        // optimizer to produce plans which don't use indexes because of the 0 
        // row edge case.
        //
        // Eventually the plan is recompiled when rows are added, but we
        // have seen multiple customer cases of deadlocks and timeouts 
        // because of these 0 row based plans.  
        if (num_rows == 0)
            num_rows = 1;


        // eliminate the allocation page from the count.
        num_pages = container.getEstimatedPageCount(/* unused flag */ 0);


        Properties prop = new Properties();
        prop.put(Property.PAGE_SIZE_PARAMETER, "");
        container.getContainerProperties(prop);
        page_size = 
            Integer.parseInt(prop.getProperty(Property.PAGE_SIZE_PARAMETER));


        row_size = (num_pages * page_size / num_rows);

View Full Code Here

    TransactionManager  xact_manager,
    ContainerKey        container_key)
    throws StandardException
    {
        Conglomerate    btree      = null;
        ContainerHandle container  = null;
        ControlRow      root       = null;


        try
        {
            // open readonly, with no locks.  Dirty read is ok as it is the
            // responsibility of client code to make sure this data is not
            // changing while being read.  The only changes that currently
            // happen to this data is creation and deletion - no updates
            // ever happen to btree conglomerates.
            container = 
                (xact_manager.getRawStoreXact()).openContainer(
                    container_key,
                    (LockingPolicy) null,
                    ContainerHandle.MODE_READONLY);


            if (container == null)
            {
                // thrown a "known" error if the conglomerate does not exist 
                // which is checked for explicitly by callers of the store 
                // interface.


                throw StandardException.newException(
                    SQLState.STORE_CONGLOMERATE_DOES_NOT_EXIST, 
                    new Long(container_key.getContainerId()));
            }


            // The conglomerate is located in the control row on the root page.
            root = ControlRow.get(container, BTree.ROOTPAGEID);


            if (SanityManager.DEBUG)
                SanityManager.ASSERT(root.getPage().isLatched());


            // read the Conglomerate from it's entry in the control row.
            btree = (B2I) root.getConglom(B2I.FORMAT_NUMBER);


            if (SanityManager.DEBUG)
                SanityManager.ASSERT(btree instanceof B2I);
        }
        finally
        {


            if (root != null)
                root.release();


            if (container != null)
                container.close();
        }


        // if any error, just return null - meaning can't access the container.


        return(btree);

View Full Code Here


    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) 
            {

View Full Code Here

         *  for restore to work correctly. That is 
         *  why we are using a open call that let us
         *  open dropped containers.
         */


        ContainerHandle containerHdl = openDroppedContainer((RawTransaction)rt, 
                                  identity, lockPolicy, 
                                  ContainerHandle.MODE_READONLY);
        /*
         * Note 1:
         * If a container creation is  in progress , open call will wait 
         * until it is complete; It will never return a handle to a 
         * container that is partially created. (see cache manager code
         * for more details)
         *
         * Note 2: 
         * if a container creation failed in the middle after the list 
         * of the names are read from seg0, it will not exist in
         * the database any more, so nothing to backup.  Attempt 
         * to open such container will return null.
         * 
         */


        if( containerHdl !=  null) {
          containerHdl.backupContainer(backupDir.getPath());
          containerHdl.close();
        }
      }
    } else
    {
      if (SanityManager.DEBUG)

View Full Code Here


    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) 
            {

View Full Code Here


    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) 
            {

View Full Code Here

         *  for restore to work correctly. That is 
         *  why we are using a open call that let us
         *  open dropped containers.
         */


        ContainerHandle containerHdl = openDroppedContainer((RawTransaction)rt, 
                                  identity, lockPolicy, 
                                  ContainerHandle.MODE_READONLY);
        /*
         * Note 1:
         * If a container creation is  in progress , open call will wait 
         * until it is complete; It will never return a handle to a 
         * container that is partially created. (see cache manager code
         * for more details)
         *
         * Note 2: 
         * if a container creation failed in the middle after the list 
         * of the names are read from seg0, it will not exist in
         * the database any more, so nothing to backup.  Attempt 
         * to open such container will return null.
         * 
         */


        if( containerHdl !=  null) {
          containerHdl.backupContainer(backupDir.getPath());
          containerHdl.close();
        }
      }
    } else
    {
      if (SanityManager.DEBUG)

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.derby.iapi.store.raw.ContainerHandle

org.apache.derby.impl.store.access.btree.index.B2IFactory

org.apache.derby.impl.store.access.btree.index.B2IForwardScan

org.apache.derby.impl.store.access.btree.index.B2IUndo

org.apache.derby.impl.store.access.conglomerate.GenericController

org.apache.derby.impl.store.access.conglomerate.GenericScanController

org.apache.derby.impl.store.access.heap.D_HeapController

org.apache.derby.impl.store.access.heap.Heap

org.apache.derby.impl.store.access.heap.HeapConglomerateFactory

org.apache.derby.impl.store.access.heap.HeapCostController

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

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.