diff options
Diffstat (limited to '')
| -rw-r--r-- | sql/optimizer_costs.h | 162 |
1 files changed, 162 insertions, 0 deletions
diff --git a/sql/optimizer_costs.h b/sql/optimizer_costs.h new file mode 100644 index 00000000..3b2300b9 --- /dev/null +++ b/sql/optimizer_costs.h @@ -0,0 +1,162 @@ +#ifndef OPTIMIZER_COSTS_INCLUDED +#define OPTIMIZER_COSTS_INCLUDED +/* + Copyright (c) 2022, MariaDB AB + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; version 2 of + the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +/* + This file defines costs structures and cost functions used by the optimizer +*/ + + +/* + OPTIMIZER_COSTS stores cost variables for each engine. They are stored + in linked_optimizer_costs (pointed to by handlerton) and TABLE_SHARE. +*/ + +#define OPTIMIZER_COST_UNDEF -1.0 +struct OPTIMIZER_COSTS +{ + double disk_read_cost; + double index_block_copy_cost; + double key_cmp_cost; + double key_copy_cost; + double key_lookup_cost; + double key_next_find_cost; + double disk_read_ratio; + double row_copy_cost; + double row_lookup_cost; + double row_next_find_cost; + double rowid_cmp_cost; + double rowid_copy_cost; + double initialized; // Set if default or connected with handlerton +}; + +/* Default optimizer costs */ +extern OPTIMIZER_COSTS default_optimizer_costs; +/* + These are used to avoid taking mutex while creating tmp tables + These are created once after the server is started so they are + not dynamic. +*/ +extern OPTIMIZER_COSTS heap_optimizer_costs, tmp_table_optimizer_costs; + +/* + Interface to the engine cost variables. See optimizer_defaults.h for + the default values. +*/ + +#define DISK_READ_RATIO costs->disk_read_ratio +#define KEY_LOOKUP_COST costs->key_lookup_cost +#define ROW_LOOKUP_COST costs->row_lookup_cost +#define INDEX_BLOCK_COPY_COST costs->index_block_copy_cost +#define KEY_COPY_COST costs->key_copy_cost +#define ROW_COPY_COST costs->row_copy_cost +#define ROW_COPY_COST_THD(THD) default_optimizer_costs.row_copy_cost +#define KEY_NEXT_FIND_COST costs->key_next_find_cost +#define ROW_NEXT_FIND_COST costs->row_next_find_cost +#define KEY_COMPARE_COST costs->key_cmp_cost +#define SORT_INDEX_CMP_COST default_optimizer_costs.key_cmp_cost +#define DISK_READ_COST costs->disk_read_cost +#define DISK_READ_COST_THD(thd) default_optimizer_costs.disk_read_cost + +/* Cost of comparing two rowids. This is set relative to KEY_COMPARE_COST */ +#define ROWID_COMPARE_COST costs->rowid_cmp_cost +#define ROWID_COMPARE_COST_THD(THD) default_optimizer_costs.rowid_cmp_cost + +/* Cost of comparing two rowids. This is set relative to KEY_COPY_COST */ +#define ROWID_COPY_COST costs->rowid_copy_cost + +/* Engine unrelated costs. Stored in THD so that the user can change them */ +#define WHERE_COST optimizer_where_cost +#define WHERE_COST_THD(THD) ((THD)->variables.optimizer_where_cost) +#define TABLE_SCAN_SETUP_COST optimizer_scan_setup_cost +#define TABLE_SCAN_SETUP_COST_THD(THD) (THD)->variables.optimizer_scan_setup_cost +#define INDEX_SCAN_SETUP_COST optimizer_scan_setup_cost/2 +/* Cost for doing duplicate removal in test_quick_select */ +#define DUPLICATE_REMOVAL_COST default_optimizer_costs.key_copy_cost + +/* Default fill factors of an (b-tree) index block is assumed to be 0.75 */ +#define INDEX_BLOCK_FILL_FACTOR_DIV 3 +#define INDEX_BLOCK_FILL_FACTOR_MUL 4 + +/* + These constants impact the cost of QSORT and priority queue sorting, + scaling the "n * log(n)" operations cost proportionally. + These factors are < 1.0 to scale down the sorting cost to be comparable + to 'read a row' = 1.0, (or 0.55 with default caching). + A factor of 0.1 makes the cost of get_pq_sort_cost(10, 10, false) =0.52 + (Reading 10 rows into a priority queue of 10 elements). + + One consenquence if this factor is too high is that priority_queue will + not use addon fields (to solve the sort without having to do an extra + re-read of rows) even if the number of LIMIT is low. +*/ +#define QSORT_SORT_SLOWNESS_CORRECTION_FACTOR (0.1) +#define PQ_SORT_SLOWNESS_CORRECTION_FACTOR (0.1) + +/* + Creating a record from the join cache is faster than getting a row from + the engine. JOIN_CACHE_ROW_COPY_COST_FACTOR is the factor used to + take this into account. This is multiplied with ROW_COPY_COST. +*/ +#define JOIN_CACHE_ROW_COPY_COST_FACTOR(thd) 1.0 + +/* + cost1 is better that cost2 only if cost1 + COST_EPS < cost2 + The main purpose of this is to ensure we use the first index or plan + when there are identical plans. Without COST_EPS some plans in the + test suite would vary depending on floating point calculations done + in different paths. +*/ +#define COST_EPS 0.0000001 + +#define COST_MAX (DBL_MAX * (1.0 - DBL_EPSILON)) + +static inline double COST_ADD(double c, double d) +{ + DBUG_ASSERT(c >= 0); + DBUG_ASSERT(d >= 0); + return (COST_MAX - (d) > (c) ? (c) + (d) : COST_MAX); +} + +static inline double COST_MULT(double c, double f) +{ + DBUG_ASSERT(c >= 0); + DBUG_ASSERT(f >= 0); + return (COST_MAX / (f) > (c) ? (c) * (f) : COST_MAX); +} + +OPTIMIZER_COSTS *get_optimizer_costs(const LEX_CSTRING *cache_name); +OPTIMIZER_COSTS *create_optimizer_costs(const char *name, size_t length); +OPTIMIZER_COSTS *get_or_create_optimizer_costs(const char *name, + size_t length); +bool create_default_optimizer_costs(); +void copy_tmptable_optimizer_costs(); +void free_all_optimizer_costs(); +struct TABLE; + +extern "C" +{ + typedef int (*process_optimizer_costs_t) (const LEX_CSTRING *, + const OPTIMIZER_COSTS *, + TABLE *); + bool process_optimizer_costs(process_optimizer_costs_t func, TABLE *param); +} + + +#endif /* OPTIMIZER_COSTS_INCLUDED */ |