conglomerate.java

derby database source code.good for you.

    public StaticCompiledOpenConglomInfo getStaticCompiledConglomInfo(
    TransactionController   tc,
    long                    conglomId)
		throws StandardException;

    /**
     * Return dynamic information about the conglomerate to be dynamically 
     * reused in repeated execution of a statement.
     * <p>
     * The dynamic info is a set of variables to be used in a given 
     * ScanController or ConglomerateController.  It can only be used in one 
     * controller at a time.  It is up to the caller to insure the correct 
     * thread access to this info.  The type of info in this is a scratch 
     * template for btree traversal, other scratch variables for qualifier 
     * evaluation, ...
     * <p>
     *
	 * @return The dynamic information.
     *
     * @param conglomId The identifier of the conglomerate to open.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    public DynamicCompiledOpenConglomInfo getDynamicCompiledConglomInfo(
    long        conglomId)
		throws StandardException;

    /**
     * Is this conglomerate temporary?
     * <p>
     *
	 * @return whether conglomerate is temporary or not.
     **/
    boolean isTemporary();

    /**
     * Bulk load into the conglomerate.
     * <p>
     * Individual rows that are loaded into the conglomerate are not
	 * logged. After this operation, the underlying database must be backed up
	 * with a database backup rather than an transaction log backup (when we 
     * have them). This warning is put here for the benefit of future 
     * generation.
     * <p>
	 * @param xact_manager  The TransactionController under which this operation
	 *                      takes place.
     *
	 * @param createConglom If true, the conglomerate is being created in the 
     *                      same operation as the openAndLoadConglomerate.  
     *                      The enables further optimization as recovery does
     *                      not require page allocation to be logged. 
     *
	 * @param rowSource     Where the rows come from.
     *
	 * @return The number of rows loaded.
     *
     * @exception StandardException Standard exception policy.  If 
     * conglomerage supports uniqueness checks and has been created to 
     * disallow duplicates, and one of the rows being loaded had key columns 
     * which were duplicate of a row already in the conglomerate, then 
     * raise SQLState.STORE_CONGLOMERATE_DUPLICATE_KEY_EXCEPTION.
     *
     **/
	public long load(
	TransactionManager      xact_manager,
	boolean                 createConglom,
	RowLocationRetRowSource rowSource)
		 throws StandardException;


    /**
     * Open a conglomerate controller.
     * <p>
     *
	 * @return The open ConglomerateController.
     *
     * @param xact_manager   The access xact to associate all ops on cc with.
     * @param rawtran        The raw store xact to associate all ops on cc with.
     * @param open_mode      A bit mask of TransactionController.MODE_* bits,
     *                       indicating info about the open.
     * @param lock_level     Either TransactionController.MODE_TABLE or
     *                       TransactionController.MODE_RECORD, as passed into
     *                       the openConglomerate() call.
     * @param locking_policy The LockingPolicy to use to open the conglomerate.
     *
	 * @exception  StandardException  Standard exception policy.
     *
     * @see TransactionController
     **/
	ConglomerateController open(
    TransactionManager              xact_manager,
    Transaction                     rawtran, 
    boolean                         hold,
    int                             open_mode,
    int                             lock_level,
    LockingPolicy                   locking_policy,
    StaticCompiledOpenConglomInfo   static_info,
    DynamicCompiledOpenConglomInfo  dynamic_info)
		throws StandardException;

    /**
     * Open a scan controller.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
	ScanManager openScan(
    TransactionManager              xact_manager,
    Transaction                     rawtran,
    boolean                         hold,
    int                             open_mode,
    int                             lock_level,
    LockingPolicy                   locking_policy,
    int                             isolation_level,
	FormatableBitSet				scanColumnList,
    DataValueDescriptor[]	        startKeyValue,
    int                             startSearchOperator,
    Qualifier                       qualifier[][],
    DataValueDescriptor[]           stopKeyValue,
    int                             stopSearchOperator,
    StaticCompiledOpenConglomInfo   static_info,
    DynamicCompiledOpenConglomInfo  dynamic_info)
        throws StandardException;

    /**
     * Online compress table.
     *
     * Returns a ScanManager which can be used to move rows
     * around in a table, creating a block of free pages at the end of the
     * table.  The process of executing the scan will move rows from the end 
     * of the table toward the beginning.  The GroupFetchScanController will
     * return the old row location, the new row location, and the actual data 
     * of any row moved.  Note that this scan only returns moved rows, not an
     * entire set of rows, the scan is designed specifically to be
     * used by either explicit user call of the SYSCS_ONLINE_COMPRESS_TABLE()
     * procedure, or internal background calls to compress the table.
     *
     * The old and new row locations are returned so that the caller can
     * update any indexes necessary.
     *
     * This scan always returns all collumns of the row.
     * 
     * All inputs work exactly as in openScan().  The return is 
     * a GroupFetchScanController, which only allows fetches of groups
     * of rows from the conglomerate.
     * <p>
     * Note that all Conglomerates may not implement openCompressScan(), 
     * currently only the Heap conglomerate implements this scan.
     *
	 * @return The GroupFetchScanController to be used to fetch the rows.
     *
     * @param hold                  see openScan()
     * @param open_mode             see openScan()
     * @param lock_level            see openScan()
     * @param isolation_level       see openScan()
     *
	 * @exception  StandardException  Standard exception policy.
     **/
	ScanManager defragmentConglomerate(
    TransactionManager              xact_manager,
    Transaction                     rawtran,
    boolean                         hold,
    int                             open_mode,
    int                             lock_level,
    LockingPolicy                   locking_policy,
    int                             isolation_level)
        throws StandardException;

	void purgeConglomerate(
    TransactionManager              xact_manager,
    Transaction                     rawtran)
        throws StandardException;

	void compressConglomerate(
    TransactionManager              xact_manager,
    Transaction                     rawtran)
        throws StandardException;

    /**
     * Return an open StoreCostController for the conglomerate.
     * <p>
     * Return an open StoreCostController which can be used to ask about 
     * the estimated row counts and costs of ScanController and 
     * ConglomerateController operations, on the given conglomerate.
     * <p>
	 * @param xact_manager The TransactionController under which this 
     *                     operation takes place.
	 * @param rawtran  raw transaction context in which scan is managed.
     *
	 * @return The open StoreCostController.
     *
	 * @exception  StandardException  Standard exception policy.
     *
     * @see StoreCostController
     **/
    StoreCostController openStoreCost(
    TransactionManager  xact_manager,
    Transaction         rawtran)
		throws StandardException;

}