From 692fcc9f33afb84bfb94ea25d941d46aebb0c3a3 Mon Sep 17 00:00:00 2001 From: Jiachen1018 Date: Sat, 30 Mar 2024 09:58:03 +0800 Subject: [PATCH] rm useless in cbo get --- storage/tianchi/ha_tse.cc | 25 ++++++------ storage/tianchi/ha_tsepart.cc | 48 +++++++++++------------ storage/tianchi/tse_cbo.cc | 61 +++++++++++------------------- storage/tianchi/tse_cbo.h | 2 +- storage/tianchi/tse_srv.h | 7 ++-- storage/tianchi/tse_srv_mq_stub.cc | 57 +++++++++++----------------- 6 files changed, 86 insertions(+), 114 deletions(-) diff --git a/storage/tianchi/ha_tse.cc b/storage/tianchi/ha_tse.cc index d013587..5ea036c 100644 --- a/storage/tianchi/ha_tse.cc +++ b/storage/tianchi/ha_tse.cc @@ -3232,7 +3232,7 @@ EXTER_ATTACK int ha_tse::rnd_pos(uchar *buf, uchar *pos) { void ha_tse::info_low() { if (m_share && m_share->cbo_stats != nullptr) { - stats.records = m_share->cbo_stats->tse_cbo_stats_table.estimate_rows; + stats.records = m_share->cbo_stats->tse_cbo_stats_table->estimate_rows; } } @@ -3919,7 +3919,7 @@ ha_rows ha_tse::records_in_range(uint inx, key_range *min_key, * we need this to make sure that our optimizer continue to work even when we * miscalculated the density, and it's still prefer index read */ - n_rows += m_share->cbo_stats->tse_cbo_stats_table.estimate_rows * density; + n_rows += m_share->cbo_stats->tse_cbo_stats_table->estimate_rows * density; } /* @@ -5225,16 +5225,17 @@ 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, nullptr, nullptr, nullptr}; - - m_share->cbo_stats->tse_cbo_stats_table.columns = + *m_share->cbo_stats = {0, 0, 0, 0, 0, nullptr, nullptr}; + m_share->cbo_stats->tse_cbo_stats_table = + (tse_cbo_stats_table_t*)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(tse_cbo_stats_table_t), MYF(MY_WME)); + 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)); THD* thd = ha_thd(); 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 = + m_share->cbo_stats->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); @@ -5260,7 +5261,7 @@ int ha_tse::get_cbo_stats_4share() } } update_member_tch(m_tch, tse_hton, thd); - ret = tse_get_cbo_stats(&m_tch, m_share->cbo_stats, &m_share->cbo_stats->tse_cbo_stats_table, 0, 0); + ret = tse_get_cbo_stats(&m_tch, m_share->cbo_stats, m_share->cbo_stats->tse_cbo_stats_table, 0, 0); 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; @@ -5281,10 +5282,12 @@ 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((m_share->cbo_stats->ndv_keys)); + m_share->cbo_stats->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(m_share->cbo_stats->tse_cbo_stats_table); + m_share->cbo_stats->tse_cbo_stats_table = nullptr; my_free((uchar *)(m_share->cbo_stats)); m_share->cbo_stats = nullptr; diff --git a/storage/tianchi/ha_tsepart.cc b/storage/tianchi/ha_tsepart.cc index d93889b..d2658be 100644 --- a/storage/tianchi/ha_tsepart.cc +++ b/storage/tianchi/ha_tsepart.cc @@ -801,7 +801,7 @@ void ha_tsepart::info_low() { table->part_info->num_parts; for (uint part_id = m_part_info->get_first_used_partition(); part_id < part_num; part_id = m_part_info->get_next_used_partition(part_id)) { - stats.records += m_part_share->cbo_stats->tse_cbo_stats_part_table[part_id].estimate_rows; + stats.records += m_part_share->cbo_stats->tse_cbo_stats_table[part_id].estimate_rows; } } } @@ -840,8 +840,8 @@ for (uint part_id = m_part_info->get_first_used_partition(); part_id < part_num; } else if (tse_max_key.len > tse_min_key.len) { tse_min_key.cmp_type = CMP_TYPE_NULL; } - density = calc_density_one_table(inx, &key, m_part_share->cbo_stats->tse_cbo_stats_part_table[part_id], *table); - n_rows_num += m_part_share->cbo_stats->tse_cbo_stats_part_table[part_id].estimate_rows * density; + density = calc_density_one_table(inx, &key, &m_part_share->cbo_stats->tse_cbo_stats_table[part_id], *table); + n_rows_num += m_part_share->cbo_stats->tse_cbo_stats_table[part_id].estimate_rows * density; } /* @@ -968,23 +968,22 @@ int ha_tsepart::initialize_cbo_stats() { uint32_t part_num = m_is_sub_partitioned ? table->part_info->num_parts * table->part_info->num_subparts : table->part_info->num_parts; - m_part_share->cbo_stats = (tianchi_cbo_stats_t*)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(tianchi_cbo_stats_t), MYF(MY_WME)); - if (m_part_share->cbo_stats == nullptr) { - 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, nullptr, nullptr, nullptr}; + m_part_share->cbo_stats = (tianchi_cbo_stats_t*)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(tianchi_cbo_stats_t), MYF(MY_WME)); + if (m_part_share->cbo_stats == nullptr) { + 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, nullptr, nullptr}; - m_part_share->cbo_stats->part_cnt = part_num; + m_part_share->cbo_stats->part_cnt = part_num; - m_part_share->cbo_stats->tse_cbo_stats_part_table = - (tse_cbo_stats_table_t*)my_malloc(PSI_NOT_INSTRUMENTED, part_num * sizeof(tse_cbo_stats_table_t), MYF(MY_WME)); - + m_part_share->cbo_stats->tse_cbo_stats_table = + (tse_cbo_stats_table_t*)my_malloc(PSI_NOT_INSTRUMENTED, part_num * sizeof(tse_cbo_stats_table_t), MYF(MY_WME)); + m_part_share->cbo_stats->ndv_keys = + (uint32_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->keys * sizeof(uint32_t), MYF(MY_WME)); for (uint i = 0; i < part_num; i++) { - m_part_share->cbo_stats->tse_cbo_stats_part_table[i].columns = + m_part_share->cbo_stats->tse_cbo_stats_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); @@ -1022,7 +1021,7 @@ int ha_tsepart::get_cbo_stats_4share() for (uint32_t i = 0; icbo_stats, &m_part_share->cbo_stats->tse_cbo_stats_part_table[first_partid], first_partid, num_part_fetch); + ret = tse_get_cbo_stats(&m_tch, m_part_share->cbo_stats, &m_part_share->cbo_stats->tse_cbo_stats_table[first_partid], first_partid, num_part_fetch); update_sess_ctx_by_tch(m_tch, get_tse_hton(), thd); if (ret != CT_SUCCESS) { return ret; @@ -1033,7 +1032,7 @@ int ha_tsepart::get_cbo_stats_4share() num_part_fetch = part_cnt - first_partid; if (num_part_fetch > 0) { update_member_tch(m_tch, get_tse_hton(), thd); - ret = tse_get_cbo_stats(&m_tch, m_part_share->cbo_stats, &m_part_share->cbo_stats->tse_cbo_stats_part_table[first_partid], first_partid, num_part_fetch); + ret = tse_get_cbo_stats(&m_tch, m_part_share->cbo_stats, &m_part_share->cbo_stats->tse_cbo_stats_table[first_partid], first_partid, num_part_fetch); update_sess_ctx_by_tch(m_tch, get_tse_hton(), thd); } @@ -1058,16 +1057,15 @@ void ha_tsepart::free_cbo_stats() { tse_log_system("[free memory]normal table : %s alloc size :%lu", table->alias, calculate_size_of_cbo_part_stats(table,part_num)); } for (uint i = 0; i < part_num; i++) { - my_free(m_part_share->cbo_stats->tse_cbo_stats_part_table[i].columns); - m_part_share->cbo_stats->tse_cbo_stats_part_table[i].columns = nullptr; - my_free(m_part_share->cbo_stats->tse_cbo_stats_part_table[i].ndv_keys); - m_part_share->cbo_stats->tse_cbo_stats_part_table[i].ndv_keys = nullptr; + my_free(m_part_share->cbo_stats->tse_cbo_stats_table[i].columns); + m_part_share->cbo_stats->tse_cbo_stats_table[i].columns = 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->ndv_keys)); + m_part_share->cbo_stats->ndv_keys = nullptr; + my_free(m_part_share->cbo_stats->tse_cbo_stats_table); + m_part_share->cbo_stats->tse_cbo_stats_table = nullptr; my_free(m_part_share->cbo_stats); m_part_share->cbo_stats = nullptr; - } int ha_tsepart::check(THD *, HA_CHECK_OPT *) diff --git a/storage/tianchi/tse_cbo.cc b/storage/tianchi/tse_cbo.cc index ac2852a..4ee642b 100644 --- a/storage/tianchi/tse_cbo.cc +++ b/storage/tianchi/tse_cbo.cc @@ -157,20 +157,20 @@ static double calc_balance_hist_equal_density(tse_cbo_stats_column_t *col_stat, return col_stat->density; } -static double calc_equal_null_density(tse_cbo_stats_table_t cbo_stats, uint32 col_id, bool is_null) +static double calc_equal_null_density(tse_cbo_stats_table_t *cbo_stats, uint32 col_id, bool is_null) { - tse_cbo_stats_column_t *col_stat = &cbo_stats.columns[col_id]; + tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; double density = DEFAULT_RANGE_DENSITY; - if (cbo_stats.estimate_rows > 0) { - density = (double)col_stat->num_null / cbo_stats.estimate_rows; + if (cbo_stats->estimate_rows > 0) { + density = (double)col_stat->num_null / cbo_stats->estimate_rows; } return is_null ? density : (double)1 - density; } -double calc_hist_equal_density(tse_cbo_stats_table_t cbo_stats, cache_variant_t *val, +double calc_hist_equal_density(tse_cbo_stats_table_t *cbo_stats, cache_variant_t *val, uint32 col_id, enum_field_types field_type) { - tse_cbo_stats_column_t *col_stat = &cbo_stats.columns[col_id]; + tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; double density = col_stat->density; uint32 hist_count = col_stat->hist_count; if (hist_count == 0) { @@ -186,9 +186,9 @@ double calc_hist_equal_density(tse_cbo_stats_table_t cbo_stats, cache_variant_t return density; } -static double calc_hist_between_frequency(tse_cbo_stats_table_t cbo_stats, field_stats_val stats_val, enum_field_types field_type, uint32 col_id) +static double calc_hist_between_frequency(tse_cbo_stats_table_t *cbo_stats, field_stats_val stats_val, enum_field_types field_type, uint32 col_id) { - tse_cbo_stats_column_t *col_stat = &cbo_stats.columns[col_id]; + tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; double density = col_stat->density; uint32 hist_count = col_stat->hist_count; if (hist_count == 0) { @@ -317,9 +317,9 @@ static int calc_hist_range_boundary(field_stats_val stats_val, enum_field_types return hi_pos - lo_pos; } -static double calc_hist_between_balance(tse_cbo_stats_table_t cbo_stats, field_stats_val stats_val, enum_field_types field_type, uint32 col_id) +static double calc_hist_between_balance(tse_cbo_stats_table_t *cbo_stats, field_stats_val stats_val, enum_field_types field_type, uint32 col_id) { - tse_cbo_stats_column_t *col_stat = &cbo_stats.columns[col_id]; + tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; double density = col_stat->density; uint32 hist_count = col_stat->hist_count; if (hist_count == 0) { @@ -337,11 +337,11 @@ static double calc_hist_between_balance(tse_cbo_stats_table_t cbo_stats, field_s return density; } -static double calc_hist_between_density(tse_cbo_stats_table_t cbo_stats, +static double calc_hist_between_density(tse_cbo_stats_table_t *cbo_stats, uint32 col_id, enum_field_types field_type, field_stats_val stats_val) { double density; - tse_cbo_stats_column_t *col_stat = &cbo_stats.columns[col_id]; + tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; if (col_stat->hist_type == FREQUENCY_HIST) { // HISTOGRAM_FREQUENCY density = calc_hist_between_frequency(cbo_stats, stats_val, field_type, col_id); @@ -352,7 +352,7 @@ static double calc_hist_between_density(tse_cbo_stats_table_t cbo_stats, return density; } -double calc_density_by_cond(tse_cbo_stats_table_t cbo_stats, KEY_PART_INFO cur_index_part, tse_range_key *key, +double calc_density_by_cond(tse_cbo_stats_table_t *cbo_stats, KEY_PART_INFO cur_index_part, tse_range_key *key, uint32_t key_offset) { double density = DEFAULT_RANGE_DENSITY; @@ -373,8 +373,8 @@ double calc_density_by_cond(tse_cbo_stats_table_t cbo_stats, KEY_PART_INFO cur_i cache_variant_t *low_val; cache_variant_t *high_val; - low_val = &cbo_stats.columns[col_id].low_value; - high_val = &cbo_stats.columns[col_id].high_value; + low_val = &cbo_stats->columns[col_id].low_value; + high_val = &cbo_stats->columns[col_id].high_value; cache_variant_t min_key_val; cache_variant_t max_key_val; @@ -401,9 +401,9 @@ double calc_density_by_cond(tse_cbo_stats_table_t cbo_stats, KEY_PART_INFO cur_i } double calc_density_one_table(uint16_t idx_id, tse_range_key *key, - tse_cbo_stats_table_t cbo_stats, const TABLE &table) + tse_cbo_stats_table_t *cbo_stats, const TABLE &table) { - if (cbo_stats.estimate_rows == 0) { // no stats or empty table + if (cbo_stats->estimate_rows == 0) { // no stats or empty table return 0; } double density = 1.0; @@ -424,7 +424,7 @@ double calc_density_one_table(uint16_t idx_id, tse_range_key *key, col_id = cur_index_part.field->field_index(); uint32_t offset = cur_index_part.field->is_nullable() ? 1 : 0;//null值标记位 - if (cbo_stats.columns[col_id].total_rows == 0) { //空表 + if (cbo_stats->columns[col_id].total_rows == 0) { //空表 col_product = 0; } else if (key_offset + offset + cur_index_part.field->key_length() == key_len) {// col_product = calc_density_by_cond(cbo_stats, cur_index_part, key, key_offset); @@ -455,33 +455,18 @@ double calc_density_one_table(uint16_t idx_id, tse_range_key *key, 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_id < cbo_stats->part_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; - } - if (estimate_rows == 0) { + uint32_t *n_diff = cbo_stats->ndv_keys; + uint32_t records = cbo_stats->records; + if (records == 0) { return; } 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); + rec_per_key = static_cast(records); } else { - rec_per_key = static_cast(estimate_rows / *(n_diff+i)); + rec_per_key = static_cast(records / *(n_diff+i)); } if (rec_per_key < 1.0) { rec_per_key = 1.0; diff --git a/storage/tianchi/tse_cbo.h b/storage/tianchi/tse_cbo.h index 7516bf7..080e073 100644 --- a/storage/tianchi/tse_cbo.h +++ b/storage/tianchi/tse_cbo.h @@ -71,7 +71,7 @@ typedef struct { } part_info_t; double calc_density_one_table(uint16_t idx_id, tse_range_key *key, - tse_cbo_stats_table_t cbo_stats, const TABLE &table); + tse_cbo_stats_table_t *cbo_stats, const TABLE &table); void tse_index_stats_update(TABLE *table, tianchi_cbo_stats_t *cbo_stats); #endif diff --git a/storage/tianchi/tse_srv.h b/storage/tianchi/tse_srv.h index e503406..ff5c05c 100644 --- a/storage/tianchi/tse_srv.h +++ b/storage/tianchi/tse_srv.h @@ -127,7 +127,6 @@ typedef struct { typedef struct { uint32_t total_rows; uint32_t num_buckets; - uint32_t num_distinct; uint32_t num_null; double density; tse_cbo_hist_type_t hist_type; @@ -144,7 +143,6 @@ typedef struct { typedef struct { uint32_t estimate_rows; tse_cbo_stats_column_t *columns; - uint32_t *ndv_keys; } tse_cbo_stats_table_t; /* @@ -155,9 +153,10 @@ typedef struct { uint32_t part_cnt; uint32_t msg_len; uint32_t key_len; + uint32_t records; bool is_updated; - tse_cbo_stats_table_t tse_cbo_stats_table; - tse_cbo_stats_table_t *tse_cbo_stats_part_table; + uint32_t *ndv_keys; + tse_cbo_stats_table_t *tse_cbo_stats_table; } tianchi_cbo_stats_t; #pragma pack() diff --git a/storage/tianchi/tse_srv_mq_stub.cc b/storage/tianchi/tse_srv_mq_stub.cc index 834b3e4..a68cff5 100644 --- a/storage/tianchi/tse_srv_mq_stub.cc +++ b/storage/tianchi/tse_srv_mq_stub.cc @@ -756,7 +756,7 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb return ERR_ALLOC_MEMORY; } - bool is_part_table = stats->tse_cbo_stats_part_table != nullptr ? true : false; + bool is_part_table = stats->part_cnt ? true : false; req->stats->msg_len = stats->msg_len; req->stats->part_cnt = stats->part_cnt; req->first_partid = first_partid; @@ -765,21 +765,20 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb void *shm_inst_4_keys = get_one_shm_inst(tch); void *shm_inst_4_table = get_one_shm_inst(tch); tse_cbo_stats_column_t* part_columns; - uint32_t *part_ndv_keys; + req->stats->ndv_keys = (uint32_t*)alloc_share_mem(shm_inst_4_keys, stats->key_len); + if (req->stats->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_stats, req->stats); + free_share_mem(shm_inst_4_req, req); + return ERR_ALLOC_MEMORY; + } if (!is_part_table) { req->tse_cbo_stats_table = (tse_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_table, sizeof(tse_cbo_stats_table_t)); req->tse_cbo_stats_table->columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, req->stats->msg_len); if (req->tse_cbo_stats_table->columns == NULL) { tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_columns, req->stats->msg_len); - free_share_mem(shm_inst_4_stats, req->stats); - free_share_mem(shm_inst_4_req, req); - return ERR_ALLOC_MEMORY; - } - req->tse_cbo_stats_table->ndv_keys = (uint32_t*)alloc_share_mem(shm_inst_4_keys, stats->key_len); - if (req->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->tse_cbo_stats_table->columns); + free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; @@ -789,6 +788,7 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb (tse_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_table, num_part_fetch * sizeof(tse_cbo_stats_table_t)); if (req->tse_cbo_stats_table == NULL) { tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_table, num_part_fetch * sizeof(tse_cbo_stats_table_t)); + free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; @@ -796,23 +796,13 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb part_columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, stats->msg_len * num_part_fetch); if (part_columns == NULL) { tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_columns, stats->msg_len * num_part_fetch); - free_share_mem(shm_inst_4_table, req->tse_cbo_stats_table); - free_share_mem(shm_inst_4_stats, req->stats); - 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_table, req->tse_cbo_stats_table); + free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); 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->tse_cbo_stats_table[i].columns = part_columns + i * (stats->msg_len / sizeof(tse_cbo_stats_column_t)); - req->tse_cbo_stats_table[i].ndv_keys = part_ndv_keys + i * (stats->key_len / sizeof(uint32_t)); } } @@ -822,29 +812,26 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb if (ret == CT_SUCCESS) { if (req->result == CT_SUCCESS) { stats->is_updated = req->stats->is_updated; - if (!is_part_table) { - *tch = req->tch; - memcpy(tse_cbo_stats_table->columns, req->tse_cbo_stats_table->columns, stats->msg_len); - memcpy(tse_cbo_stats_table->ndv_keys, req->tse_cbo_stats_table->ndv_keys, stats->key_len); - - tse_cbo_stats_table->estimate_rows = req->tse_cbo_stats_table->estimate_rows; - } else { - for (uint i = 0; i < num_part_fetch; i++) { - tse_cbo_stats_table[i].estimate_rows = req->tse_cbo_stats_table[i].estimate_rows; - memcpy(tse_cbo_stats_table[i].columns, req->tse_cbo_stats_table[i].columns, stats->msg_len); - memcpy(tse_cbo_stats_table[i].ndv_keys, req->tse_cbo_stats_table[i].ndv_keys, stats->key_len); - } + memcpy(stats->ndv_keys, req->stats->ndv_keys, stats->key_len); + if (!is_part_table) { + *tch = req->tch; + memcpy(tse_cbo_stats_table->columns, req->tse_cbo_stats_table->columns, stats->msg_len); + tse_cbo_stats_table->estimate_rows = req->tse_cbo_stats_table->estimate_rows; + } else { + for (uint i = 0; i < num_part_fetch; i++) { + tse_cbo_stats_table[i].estimate_rows = req->tse_cbo_stats_table[i].estimate_rows; + memcpy(tse_cbo_stats_table[i].columns, req->tse_cbo_stats_table[i].columns, stats->msg_len); } + } } result = req->result; } if (!is_part_table) { free_share_mem(shm_inst_4_columns, req->tse_cbo_stats_table->columns); - free_share_mem(shm_inst_4_keys, req->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_keys, req->stats->ndv_keys); free_share_mem(shm_inst_4_table, req->tse_cbo_stats_table); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); -- Gitee