Edit: optimizer_costs.h
#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 *, OPTIMIZER_COSTS *, TABLE *); bool process_optimizer_costs(process_optimizer_costs_t func, TABLE *param); } #endif /* OPTIMIZER_COSTS_INCLUDED */
Cancel