From abb994c8965f03f6916b4841bac02ad5a6113191 Mon Sep 17 00:00:00 2001 From: solid-yang Date: Mon, 18 Mar 2024 10:40:45 +0800 Subject: [PATCH 1/2] check sign before setting unsigned variables in remote node --- storage/tianchi/ctc_meta_data.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/storage/tianchi/ctc_meta_data.cc b/storage/tianchi/ctc_meta_data.cc index 9243d2d..db39c84 100644 --- a/storage/tianchi/ctc_meta_data.cc +++ b/storage/tianchi/ctc_meta_data.cc @@ -623,6 +623,11 @@ static void ctc_get_set_var_item(THD* new_thd, sys_var* sysvar, Item** res MY_AT case SHOW_LONG: case SHOW_LONGLONG: case SHOW_HA_ROWS: + if (var_value.c_str()[0] != '-') { + *res = new (new_thd->mem_root) + Item_uint(var_value.c_str(), (uint)var_value.length()); + break; + } case SHOW_SIGNED_INT: case SHOW_SIGNED_LONG: case SHOW_SIGNED_LONGLONG: -- Gitee From efb9af49b046e4e0248befe8c4cd6e250a4a1b87 Mon Sep 17 00:00:00 2001 From: Jiachen1018 Date: Mon, 18 Mar 2024 11:56:56 +0800 Subject: [PATCH 2/2] index stats --- storage/tianchi/ha_tse.cc | 10 ++++++++- storage/tianchi/ha_tsepart.cc | 9 +++++++- storage/tianchi/tse_cbo.cc | 36 ++++++++++++++++++++++++++++++ storage/tianchi/tse_cbo.h | 1 + storage/tianchi/tse_srv.h | 2 ++ storage/tianchi/tse_srv_mq_stub.cc | 24 ++++++++++++++++++++ 6 files changed, 80 insertions(+), 2 deletions(-) diff --git a/storage/tianchi/ha_tse.cc b/storage/tianchi/ha_tse.cc index 21b8e4a..79ff998 100644 --- a/storage/tianchi/ha_tse.cc +++ b/storage/tianchi/ha_tse.cc @@ -5243,7 +5243,7 @@ int ha_tse::initialize_cbo_stats() tse_log_error("alloc shm mem failed, m_share->cbo_stats size(%lu)", sizeof(tianchi_cbo_stats_t)); return ERR_ALLOC_MEMORY; } - *m_share->cbo_stats = {0, 0, 0, 0, 0, 0, nullptr, nullptr}; + *m_share->cbo_stats = {0, 0, 0, 0, 0, 0, 0, nullptr, nullptr, nullptr}; m_share->cbo_stats->tse_cbo_stats_table.columns = (tse_cbo_stats_column_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->fields * sizeof(tse_cbo_stats_column_t), MYF(MY_WME)); @@ -5251,7 +5251,12 @@ int ha_tse::initialize_cbo_stats() if (user_var_set(thd, "ctc_show_alloc_cbo_stats_mem")) { tse_log_system("[alloc memory]normal table : %s alloc size :%lu", table->alias, calculate_size_of_cbo_stats(table)); } + + m_share->cbo_stats->tse_cbo_stats_table.ndv_keys = + (uint32_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->keys * sizeof(uint32_t), MYF(MY_WME)); + m_share->cbo_stats->msg_len = table->s->fields * sizeof(tse_cbo_stats_column_t); + m_share->cbo_stats->key_len = table->s->keys * sizeof(uint32_t); return CT_SUCCESS; } @@ -5277,6 +5282,7 @@ int ha_tse::get_cbo_stats_4share() update_sess_ctx_by_tch(m_tch, tse_hton, thd); if (ret == CT_SUCCESS && m_share->cbo_stats->is_updated) { m_share->need_fetch_cbo = false; + tse_index_stats_update(table, m_share->cbo_stats); } m_share->get_cbo_time = now; } @@ -5293,6 +5299,8 @@ void ha_tse::free_cbo_stats() if (user_var_set(thd, "ctc_show_alloc_cbo_stats_mem")) { tse_log_system("[free memory]normal table : %s alloc size :%lu", table->alias, calculate_size_of_cbo_stats(table)); } + my_free((m_share->cbo_stats->tse_cbo_stats_table.ndv_keys)); + m_share->cbo_stats->tse_cbo_stats_table.ndv_keys = nullptr; my_free((m_share->cbo_stats->tse_cbo_stats_table.columns)); m_share->cbo_stats->tse_cbo_stats_table.columns = nullptr; my_free((uchar *)(m_share->cbo_stats)); diff --git a/storage/tianchi/ha_tsepart.cc b/storage/tianchi/ha_tsepart.cc index 5e0d15f..58e52f9 100644 --- a/storage/tianchi/ha_tsepart.cc +++ b/storage/tianchi/ha_tsepart.cc @@ -973,7 +973,7 @@ int ha_tsepart::initialize_cbo_stats() { tse_log_error("alloc shm mem failed, m_part_share->cbo_stats size(%lu)", sizeof(tianchi_cbo_stats_t)); return ERR_ALLOC_MEMORY; } - *m_part_share->cbo_stats = {0, 0, 0, 0, 0, 0, nullptr, nullptr}; + *m_part_share->cbo_stats = {0, 0, 0, 0, 0, 0, 0, nullptr, nullptr, nullptr}; m_part_share->cbo_stats->part_cnt = part_num; @@ -983,8 +983,12 @@ int ha_tsepart::initialize_cbo_stats() { for (uint i = 0; i < part_num; i++) { m_part_share->cbo_stats->tse_cbo_stats_part_table[i].columns = (tse_cbo_stats_column_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->fields * sizeof(tse_cbo_stats_column_t), MYF(MY_WME)); + m_part_share->cbo_stats->tse_cbo_stats_part_table[i].ndv_keys = + (uint32_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->keys * sizeof(uint32_t), MYF(MY_WME)); } m_part_share->cbo_stats->msg_len = table->s->fields * sizeof(tse_cbo_stats_column_t); + m_part_share->cbo_stats->key_len = table->s->keys * sizeof(uint32_t); + THD* thd = ha_thd(); if (user_var_set(thd, "ctc_show_alloc_cbo_stats_mem")) { tse_log_system("[alloc memory]part table first_partid: %s alloc size :%lu", table->alias, calculate_size_of_cbo_part_stats(table,part_num)); @@ -1031,6 +1035,7 @@ int ha_tsepart::get_cbo_stats_4share() update_sess_ctx_by_tch(m_tch, get_tse_hton(), thd); if (ret == CT_SUCCESS && m_part_share->cbo_stats->is_updated) { m_part_share->need_fetch_cbo = false; + tse_index_stats_update(table, m_part_share->cbo_stats); } m_part_share->get_cbo_time = now; } @@ -1050,6 +1055,8 @@ void ha_tsepart::free_cbo_stats() { } my_free(m_part_share->cbo_stats->tse_cbo_stats_part_table[0].columns); m_part_share->cbo_stats->tse_cbo_stats_part_table[0].columns = nullptr; + my_free(m_part_share->cbo_stats->tse_cbo_stats_part_table[0].ndv_keys); + m_part_share->cbo_stats->tse_cbo_stats_part_table[0].ndv_keys = nullptr; my_free(m_part_share->cbo_stats->tse_cbo_stats_part_table); m_part_share->cbo_stats->tse_cbo_stats_part_table = nullptr; my_free(m_part_share->cbo_stats); diff --git a/storage/tianchi/tse_cbo.cc b/storage/tianchi/tse_cbo.cc index b472748..7bb6391 100644 --- a/storage/tianchi/tse_cbo.cc +++ b/storage/tianchi/tse_cbo.cc @@ -403,3 +403,39 @@ double calc_density_one_table(uint16_t idx_id, tse_range_key *key, return density; } +void tse_index_stats_update(TABLE *table, tianchi_cbo_stats_t *cbo_stats) +{ + rec_per_key_t rec_per_key; + bool is_part_table = (cbo_stats->tse_cbo_stats_part_table != nullptr); + uint32_t estimate_rows = 0; + + KEY sk; + uint32_t *n_diff; + if (is_part_table) { + // set to the biggest part + assert(cbo_stats->part_cnt); + for (uint32 part_id = 0; part_idpart_cnt; part_id++) { + if (estimate_rows < cbo_stats->tse_cbo_stats_part_table[part_id].estimate_rows) { + estimate_rows = cbo_stats->tse_cbo_stats_part_table[part_id].estimate_rows; + n_diff = cbo_stats->tse_cbo_stats_part_table[part_id].ndv_keys; + } + } + } else { + n_diff = cbo_stats->tse_cbo_stats_table.ndv_keys; + estimate_rows = cbo_stats->tse_cbo_stats_table.estimate_rows; + } + for (uint32 i = 0; i < table->s->keys; i++){ + sk = table->key_info[i]; + if (*(n_diff+i) == 0) { + rec_per_key = static_cast(estimate_rows); + } else { + rec_per_key = static_cast(estimate_rows / *(n_diff+i)); + } + if (rec_per_key < 1.0) { + rec_per_key = 1.0; + } + for (uint32 j=0;jstats->msg_len = stats->msg_len; req->stats->part_cnt = stats->part_cnt; void *shm_inst_4_columns = get_one_shm_inst(tch); + void *shm_inst_4_keys = get_one_shm_inst(tch); void *shm_inst_4_part_table = get_one_shm_inst(tch); tse_cbo_stats_column_t* part_columns; + uint32_t *part_ndv_keys; if (!is_part_table) { req->stats->tse_cbo_stats_table.columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, req->stats->msg_len); if (req->stats->tse_cbo_stats_table.columns == NULL) { @@ -770,6 +772,14 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32 free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; } + req->stats->tse_cbo_stats_table.ndv_keys = (uint32_t*)alloc_share_mem(shm_inst_4_keys, stats->key_len); + if (req->stats->tse_cbo_stats_table.ndv_keys == NULL) { + tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_keys, stats->key_len); + free_share_mem(shm_inst_4_columns, req->stats->tse_cbo_stats_table.columns); + free_share_mem(shm_inst_4_stats, req->stats); + free_share_mem(shm_inst_4_req, req); + return ERR_ALLOC_MEMORY; + } } else { req->stats->first_partid = first_partid; req->stats->num_part_fetch = num_part_fetch; @@ -789,8 +799,18 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32 free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; } + part_ndv_keys = (uint32_t*)alloc_share_mem(shm_inst_4_keys, stats->key_len * num_part_fetch); + if (part_ndv_keys == NULL) { + tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_keys, stats->key_len * num_part_fetch); + free_share_mem(shm_inst_4_columns, part_columns); + free_share_mem(shm_inst_4_part_table, req->stats->tse_cbo_stats_part_table); + free_share_mem(shm_inst_4_stats, req->stats); + free_share_mem(shm_inst_4_req, req); + return ERR_ALLOC_MEMORY; + } for (uint i = 0; i < num_part_fetch; i++) { req->stats->tse_cbo_stats_part_table[i].columns = part_columns + i * (stats->msg_len / sizeof(tse_cbo_stats_column_t)); + req->stats->tse_cbo_stats_part_table[i].ndv_keys = part_ndv_keys + i * (stats->key_len / sizeof(uint32_t)); } } @@ -802,6 +822,7 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32 if (!is_part_table) { *tch = req->tch; memcpy(stats->tse_cbo_stats_table.columns, req->stats->tse_cbo_stats_table.columns, stats->msg_len); + memcpy(stats->tse_cbo_stats_table.ndv_keys, req->stats->tse_cbo_stats_table.ndv_keys, stats->key_len); stats->is_updated = req->stats->is_updated; stats->tse_cbo_stats_table.estimate_rows = req->stats->tse_cbo_stats_table.estimate_rows; } else { @@ -809,6 +830,7 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32 for (uint i = 0; i < num_part_fetch; i++) { stats->tse_cbo_stats_part_table[i+first_partid].estimate_rows = req->stats->tse_cbo_stats_part_table[i].estimate_rows; memcpy(stats->tse_cbo_stats_part_table[i+first_partid].columns, req->stats->tse_cbo_stats_part_table[i].columns, stats->msg_len); + memcpy(stats->tse_cbo_stats_part_table[i+first_partid].ndv_keys, req->stats->tse_cbo_stats_part_table[i].ndv_keys, stats->key_len); } } } @@ -816,8 +838,10 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, uint32 } if (!is_part_table) { free_share_mem(shm_inst_4_columns, req->stats->tse_cbo_stats_table.columns); + free_share_mem(shm_inst_4_keys, req->stats->tse_cbo_stats_table.ndv_keys); } else { free_share_mem(shm_inst_4_columns, part_columns); + free_share_mem(shm_inst_4_keys, part_ndv_keys); free_share_mem(shm_inst_4_part_table, req->stats->tse_cbo_stats_part_table); } free_share_mem(shm_inst_4_stats, req->stats); -- Gitee