| org.apache.derby.iapi.store.access.StoreCostController
All known Subclasses: org.apache.derby.impl.store.access.btree.BTreeCostController, org.apache.derby.impl.store.access.heap.HeapCostController, org.apache.derby.impl.store.access.conglomerate.GenericCostController,
| StoreCostController | | public interface StoreCostController extends RowCountable(Code) | | The StoreCostController interface provides methods that an access client
(most likely the system optimizer) can use to get store's estimated cost of
various operations on the conglomerate the StoreCostController was opened
for.
It is likely that the implementation of StoreCostController will open
the conglomerate and will leave the conglomerate open until the
StoreCostController is closed. This represents a significant amount of
work, so the caller if possible should attempt to open the StoreCostController
once per unit of work and rather than close and reopen the controller. For
instance if the optimizer needs to cost 2 different scans against a single
conglomerate, it should use one instance of the StoreCostController.
The locking behavior of the implementation of a StoreCostController is
undefined, it may or may not get locks on the underlying conglomerate. It
may or may not hold locks until end of transaction.
An optimal implementation will not get any locks on the underlying
conglomerate, thus allowing concurrent access to the table by a executing
query while another query is optimizing.
See Also: TransactionController.openStoreCost
See Also: RowCountable |
| Method Summary | |
| void | close()
Close the controller.
Close the open controller. | | public double | getFetchFromFullKeyCost(FormatableBitSet validColumns, int access_type)
Return the cost of exact key lookup.
Return the estimated cost of calling ScanController.fetch()
on the current conglomerate, with start and stop positions set such
that an exact match is expected.
This call returns the cost of a fetchNext() performed on a scan which
has been positioned with a start position which specifies exact match
on all keys in the row.
Example:
In the case of a btree this call can be used to determine the cost of
doing an exact probe into btree, giving all key columns. | | public double | getFetchFromRowLocationCost(FormatableBitSet validColumns, int access_type)
Return the cost of calling ConglomerateController.fetch().
Return the estimated cost of calling ConglomerateController.fetch()
on the current conglomerate. | | public void | getScanCost(int scan_type, long row_count, int group_size, boolean forUpdate, FormatableBitSet scanColumnList, DataValueDescriptor[] template, DataValueDescriptor[] startKeyValue, int startSearchOperator, DataValueDescriptor[] stopKeyValue, int stopSearchOperator, boolean reopen_scan, int access_type, StoreCostResult cost_result)
Calculate the cost of a scan.
Cause this object to calculate the cost of performing the described
scan. | | RowLocation | newRowLocationTemplate()
Return an "empty" row location object of the correct type. |
| BASE_CACHED_ROW_FETCH_COST | | final public static double BASE_CACHED_ROW_FETCH_COST(Code) | | |
| BASE_GROUPSCAN_ROW_COST | | final public static double BASE_GROUPSCAN_ROW_COST(Code) | | |
| BASE_HASHSCAN_ROW_FETCH_COST | | final public static double BASE_HASHSCAN_ROW_FETCH_COST(Code) | | |
| BASE_NONGROUPSCAN_ROW_FETCH_COST | | final public static double BASE_NONGROUPSCAN_ROW_FETCH_COST(Code) | | |
| BASE_ROW_PER_BYTECOST | | final public static double BASE_ROW_PER_BYTECOST(Code) | | |
| BASE_UNCACHED_ROW_FETCH_COST | | final public static double BASE_UNCACHED_ROW_FETCH_COST(Code) | | |
| STORECOST_CLUSTERED | | final public static int STORECOST_CLUSTERED(Code) | | Indicates that access to the page necessary to fulfill the fetch
request is likely to be a page "recently" used. See
getFetchFromFullKeyCost() and getScanCost().
|
| STORECOST_SCAN_NORMAL | | final public static int STORECOST_SCAN_NORMAL(Code) | | Used for the scan_type parameter to the getScanCost() routine.
STORECOST_SCAN_SET - The entire result set will be retrieved using the
the fetchSet() interface.
|
| STORECOST_SCAN_SET | | final public static int STORECOST_SCAN_SET(Code) | | Used for the scan_type parameter to the getScanCost() routine.
STORECOST_SCAN_NORMAL indicates that the scan will use the standard
next/fetch, where each fetch can retrieve 1 or many rows (if
fetchNextGroup() interface is used).
|
| close | | void close() throws StandardException(Code) | | Close the controller.
Close the open controller. This method always succeeds, and never
throws any exceptions. Callers must not use the StoreCostController
Cost controller after closing it; they are strongly advised to clear
out the scan controller reference after closing.
exception:
StandardException - Standard exception policy. |
| getFetchFromFullKeyCost | | public double getFetchFromFullKeyCost(FormatableBitSet validColumns, int access_type) throws StandardException(Code) | | Return the cost of exact key lookup.
Return the estimated cost of calling ScanController.fetch()
on the current conglomerate, with start and stop positions set such
that an exact match is expected.
This call returns the cost of a fetchNext() performed on a scan which
has been positioned with a start position which specifies exact match
on all keys in the row.
Example:
In the case of a btree this call can be used to determine the cost of
doing an exact probe into btree, giving all key columns. This cost
can be used if the client knows it will be doing an exact key probe
but does not have the key's at optimize time to use to make a call to
getScanCost()
Parameters:
validColumns - A description of which columns to return fromrow on the page into "templateRow." templateRow,and validColumns work together todescribe the row to be returned by the fetch - see RowUtil for description of how these three parameters work together to describe a fetched "row".
Parameters:
access_type - Describe the type of access the query will beperforming to the ScanController. STORECOST_CLUSTERED - The location of one scanis likely clustered "close" to the previous scan. For instance if the query plan wereto used repeated "reopenScan()'s" to probefor the next key in an index, then this flagshould be be specified. If this flag is not set then each scan will be costed independantof any other predicted scan access. The cost of the fetch.
exception:
StandardException - Standard exception policy.
See Also: RowUtil |
| getFetchFromRowLocationCost | | public double getFetchFromRowLocationCost(FormatableBitSet validColumns, int access_type) throws StandardException(Code) | | Return the cost of calling ConglomerateController.fetch().
Return the estimated cost of calling ConglomerateController.fetch()
on the current conglomerate. This gives the cost of finding a record
in the conglomerate given the exact RowLocation of the record in
question.
The validColumns parameter describe what kind of row
is being fetched, ie. it may be cheaper to fetch a partial row than a
complete row.
Parameters:
validColumns - A description of which columns to return fromrow on the page into "templateRow." templateRow,and validColumns work together todescribe the row to be returned by the fetch - see RowUtil for description of how these three parameters work together to describe a fetched "row".
Parameters:
access_type - Describe the type of access the query will beperforming to the ConglomerateController. STORECOST_CLUSTERED - The location of one fetchis likely clustered "close" to the next fetch. For instance if the query plan wereto sort the RowLocations of a heap and thenuse those RowLocations sequentially to probe into the heap, then this flag shouldbe specified. If this flag is not set thenaccess to the table is assumed to berandom - ie. the type of access one gets if you scan an index and probe each rowin turn into the base table is "random". The cost of the fetch.
exception:
StandardException - Standard exception policy.
See Also: RowUtil |
| getScanCost | | public void getScanCost(int scan_type, long row_count, int group_size, boolean forUpdate, FormatableBitSet scanColumnList, DataValueDescriptor[] template, DataValueDescriptor[] startKeyValue, int startSearchOperator, DataValueDescriptor[] stopKeyValue, int stopSearchOperator, boolean reopen_scan, int access_type, StoreCostResult cost_result) throws StandardException(Code) | | Calculate the cost of a scan.
Cause this object to calculate the cost of performing the described
scan. The interface is setup such that first a call is made to
calcualteScanCost(), and then subsequent calls to accessor routines
are made to get various pieces of information about the cost of
the scan.
For the purposes of costing this routine is going to assume that
a page will remain in cache between the time one next()/fetchNext()
call and a subsequent next()/fetchNext() call is made within a scan.
The result of costing the scan is placed in the "cost_result".
The cost of the scan is stored by calling
cost_result.setEstimatedCost(cost).
The estimated row count is stored by calling
cost_result.setEstimatedRowCount(row_count).
The estimated cost of the scan assumes the caller will
execute a fetchNext() loop for every row that qualifies between
start and stop position. Note that this cost is different than
execution a next(),fetch() loop; or if the scan is going to be
terminated by client prior to reaching the stop condition.
The estimated number of rows returned from the scan
assumes the caller will execute a fetchNext() loop for every
row that qualifies between start and stop position.
Parameters:
scan_type - The type of scan that will be executed. Thereare currently 2 types:STORECOST_SCAN_NORMAL - scans will be executedusing the standard next/fetch, where each fetchcan retrieve 1 or many rows (if fetchNextGroup()interface is used).STORECOST_SCAN_SET - The entire result set willbe retrieved using the the fetchSet() interface.
Parameters:
row_count - Estimated total row count of the table. The current system tracks row counts in heaps betterthan btree's (btree's have "rows" which are notuser rows - branch rows, control rows), so if available the client shouldpass in the base table's row count into thisroutine to be used as the index's row count.If the caller has no idea, pass in -1.
Parameters:
group_size - The number of rows to be returned by a singlefetch call for STORECOST_SCAN_NORMAL scans.
Parameters:
forUpdate - Should be true if the caller intends to update through the scan.
Parameters:
scanColumnList - A description of which columns to return from every fetch in the scan. template, and scanColumnList work togetherto describe the row to be returned by the scan - see RowUtil for description of how these three parameters work together to describe a "row".
Parameters:
template - A prototypical row which the scan may use tomaintain its position in the conglomerate. Not all access method scan types will require this, if they don't it's ok to pass in null.In order to scan a conglomerate one must allocate 2 separate "row" templates. The "row" template passed into openScan is for the privateuse of the scan itself, and no access to itshould be made by the caller while the scan is still open. Because of this the scanner must allocate another "row" template to hold the values returned from fetch(). Note that this template must be for the full row, whether a partial row scan is being executed or not.
Parameters:
startKeyValue - An indexable row which holds a (partial) key value which, in combination with the startSearchOperator, defines the starting position of the scan. If null, the startingposition of the scan is the first row of the conglomerate. The startKeyValue must onlyreference columns included in the scanColumnList.
Parameters:
startSearchOperator - an operator which defines how the startKeyValueis to be searched for. If startSearchOperation is ScanController.GE, the scan starts on the first row which is greater than or equal to the startKeyValue. If startSearchOperation is ScanController.GT, the scan starts on the firstrow whose key is greater than startKeyValue. ThestartSearchOperation parameter is ignored if thestartKeyValue parameter is null.
Parameters:
stopKeyValue - An indexable row which holds a (partial) key value which, in combination with the stopSearchOperator, defines the ending positionof the scan. If null, the ending position of thescan is the last row of the conglomerate. ThestopKeyValue must only reference columns includedin the scanColumnList.
Parameters:
stopSearchOperator - an operator which defines how the stopKeyValueis used to determine the scan stopping position. If stopSearchOperation is ScanController.GE, thescan stops just before the first row which isgreater than or equal to the stopKeyValue. If stopSearchOperation is ScanController.GT, the scan stops just before the first row whose key is greater than startKeyValue. ThestopSearchOperation parameter is ignored if thestopKeyValue parameter is null.
Parameters:
access_type - Describe the type of access the query will beperforming to the ScanController. STORECOST_CLUSTERED - The location of one scanis likely clustered "close" to the previous scan. For instance if the query plan wereto used repeated "reopenScan()'s" to probefor the next key in an index, then this flagshould be be specified. If this flag is not set then each scan will be costed independantof any other predicted scan access.
exception:
StandardException - Standard exception policy.
See Also: RowUtil |
|
|