| org.apache.derby.impl.store.access.conglomerate.GenericCostController
 org.apache.derby.impl.store.access.heap.HeapCostController
| HeapCostController | | public class HeapCostController extends GenericCostController implements StoreCostController(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.
The StoreCostController gives 2 kinds of cost information
|
| Method Summary | |
| 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. | | public void | init(OpenConglomerate open_conglom)
Initialize the cost controller. |
| num_pages | | long num_pages(Code) | | Only lookup these estimates from raw store once.
|
| page_size | | long page_size(Code) | | |
| 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 describes 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 |
|
|