- commits - lists.mariadb.org

[Commits] 51ef5419426: MDEV-22019: Sig 11 in next_breadth_first_tab | max_sort_length setting + double GROUP BY leads to crash
by Varun 26 Mar '20

26 Mar '20

revision-id: 51ef54194268b07be6cddca83f88c5dcba67b5d9 (mariadb-10.2.30-177-g51ef5419426) parent(s): 5918b17004674f425f2cd1d4f0bac29b3bcecb35 author: Varun Gupta committer: Varun Gupta timestamp: 2020-03-26 16:54:44 +0530 message: MDEV-22019: Sig 11 in next_breadth_first_tab | max_sort_length setting + double GROUP BY leads to crash No need to create a temp table for aggregation if we have encountered some error. --- mysql-test/r/group_by.result | 14 ++++++++++++++ mysql-test/t/group_by.test | 17 +++++++++++++++++ sql/sql_select.cc | 8 ++++++-- sql/sql_show.cc | 7 +++---- 4 files changed, 40 insertions(+), 6 deletions(-) diff --git a/mysql-test/r/group_by.result b/mysql-test/r/group_by.result index cbce6340c47..c996627486c 100644 --- a/mysql-test/r/group_by.result +++ b/mysql-test/r/group_by.result @@ -2861,3 +2861,17 @@ SELECT 1 FROM t1 GROUP BY REPEAT((BINARY pk), v1), AES_DECRYPT((@A := i1), 20852) WITH ROLLUP HAVING LOAD_FILE('a') ; 1 drop table t1; +# +# MDEV-22019: Sig 11 in next_breadth_first_tab | max_sort_length setting + double +# GROUP BY leads to crash +# +CALL mtr.add_suppression("Out of sort memory"); +CALL mtr.add_suppression("Sort aborted"); +SET @save_max_sort_length= @@max_sort_length; +SET max_sort_length=2000000; +SELECT * FROM information_schema.tables t JOIN information_schema.columns c +ON t.table_schema=c.table_schema +WHERE c.table_schema=(SELECT COUNT(*) FROM INFORMATION_SCHEMA.columns GROUP BY column_type) +GROUP BY t.table_name; +ERROR HY001: Out of sort memory, consider increasing server sort buffer size +SET max_sort_length= @save_max_sort_length; diff --git a/mysql-test/t/group_by.test b/mysql-test/t/group_by.test index 0436cd16e7c..324b41ce23c 100644 --- a/mysql-test/t/group_by.test +++ b/mysql-test/t/group_by.test @@ -1979,3 +1979,20 @@ GROUP BY REPEAT((BINARY pk), v1), AES_DECRYPT((@A := i1), 20852) WITH ROLLUP HAV SELECT 1 FROM t1 GROUP BY REPEAT((BINARY pk), v1), AES_DECRYPT((@A := i1), 20852) WITH ROLLUP HAVING LOAD_FILE('a') ; drop table t1; + +--echo # +--echo # MDEV-22019: Sig 11 in next_breadth_first_tab | max_sort_length setting + double +--echo # GROUP BY leads to crash +--echo # + + +CALL mtr.add_suppression("Out of sort memory"); +CALL mtr.add_suppression("Sort aborted"); +SET @save_max_sort_length= @@max_sort_length; +SET max_sort_length=2000000; +--error ER_OUT_OF_SORTMEMORY +SELECT * FROM information_schema.tables t JOIN information_schema.columns c +ON t.table_schema=c.table_schema +WHERE c.table_schema=(SELECT COUNT(*) FROM INFORMATION_SCHEMA.columns GROUP BY column_type) +GROUP BY t.table_name; +SET max_sort_length= @save_max_sort_length; diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 97002ef071f..c601946cfa0 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -2210,8 +2210,12 @@ JOIN::optimize_inner() having_is_correlated= MY_TEST(having->used_tables() & OUTER_REF_TABLE_BIT); tmp_having= having; - if ((select_lex->options & OPTION_SCHEMA_TABLE)) - optimize_schema_tables_reads(this); + if ((select_lex->options & OPTION_SCHEMA_TABLE) && + optimize_schema_tables_reads(this)) + DBUG_RETURN(TRUE); + + if (unlikely(thd->is_error())) + DBUG_RETURN(TRUE); /* The loose index scan access method guarantees that all grouping or diff --git a/sql/sql_show.cc b/sql/sql_show.cc index 78ca1d09e7a..4e37b53b87e 100644 --- a/sql/sql_show.cc +++ b/sql/sql_show.cc @@ -8299,7 +8299,6 @@ static bool optimize_for_get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond bool optimize_schema_tables_reads(JOIN *join) { THD *thd= join->thd; - bool result= 0; DBUG_ENTER("optimize_schema_tables_reads"); JOIN_TAB *tab; @@ -8334,11 +8333,11 @@ bool optimize_schema_tables_reads(JOIN *join) */ cond= tab->cache_select->cond; } - - optimize_for_get_all_tables(thd, table_list, cond); + if (optimize_for_get_all_tables(thd, table_list, cond)) + DBUG_RETURN(TRUE); // Handle OOM } } - DBUG_RETURN(result); + DBUG_RETURN(FALSE); }

1 0

[Commits] f2b801bd023: Remove the redundant iter->Seek() call in ha_rocksdb::check_and_lock_sk
by psergey 25 Mar '20

25 Mar '20

revision-id: f2b801bd023f169bae5e8a8a88334e5c6f1e788d (fb-prod201907-50-gf2b801bd023) parent(s): 1b7b8f7dcec371dabc74acabaae330146e367c7c author: Sergei Petrunia committer: Sergei Petrunia timestamp: 2020-03-25 11:33:56 +0300 message: Remove the redundant iter->Seek() call in ha_rocksdb::check_and_lock_sk read_key_exact() is called next, and it will mak iter->Seek() call itself. --- storage/rocksdb/ha_rocksdb.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/storage/rocksdb/ha_rocksdb.cc b/storage/rocksdb/ha_rocksdb.cc index 14006d05150..3a58567d05b 100644 --- a/storage/rocksdb/ha_rocksdb.cc +++ b/storage/rocksdb/ha_rocksdb.cc @@ -9792,7 +9792,6 @@ int ha_rocksdb::check_and_lock_sk(const uint key_id, Also need to scan RocksDB and verify the key has not been deleted in the transaction. */ - iter->Seek(new_slice); *found = !read_key_exact(kd, iter, all_parts_used, new_slice, row_info.tx->m_snapshot_timestamp); delete iter;

1 0

[Commits] 4f528bb514c: MDEV-22011: DISTINCT with JSON_ARRAYAGG gives wrong results
by Varun 24 Mar '20

24 Mar '20

revision-id: 4f528bb514c607d848b30119cea135e37e0d9c69 (mariadb-10.5.0-425-g4f528bb514c) parent(s): 1cd8e8213b6019794ca7f01e8276cfd1ba6408cf author: Varun Gupta committer: Varun Gupta timestamp: 2020-03-24 10:13:28 +0530 message: MDEV-22011: DISTINCT with JSON_ARRAYAGG gives wrong results For JSON_ARRAYAGG with DISTINCT also store the null bytes for the record inside the Unique object --- mysql-test/main/func_json.result | 4 +- sql/item_jsonfunc.cc | 36 ++++++++++++-- sql/item_jsonfunc.h | 9 ++-- sql/item_sum.cc | 101 ++++++++++++++++++++++++++++++++++----- sql/item_sum.h | 13 +++-- 5 files changed, 133 insertions(+), 30 deletions(-) diff --git a/mysql-test/main/func_json.result b/mysql-test/main/func_json.result index be6ea1a7b61..9a60f395d0d 100644 --- a/mysql-test/main/func_json.result +++ b/mysql-test/main/func_json.result @@ -1160,13 +1160,13 @@ JSON_ARRAYAGG(DISTINCT a) [1,2,3] SELECT JSON_ARRAYAGG(DISTINCT b) FROM t1; JSON_ARRAYAGG(DISTINCT b) -["Hello","World","This","Will","Work","!",null] +[null,"!","Hello","This","Will","Work","World"] SELECT JSON_ARRAYAGG(DISTINCT a LIMIT 2) FROM t1; JSON_ARRAYAGG(DISTINCT a LIMIT 2) [1,2] SELECT JSON_ARRAYAGG(DISTINCT b LIMIT 2) FROM t1; JSON_ARRAYAGG(DISTINCT b LIMIT 2) -["Hello","World"] +[null,"!"] # # JSON aggregation # diff --git a/sql/item_jsonfunc.cc b/sql/item_jsonfunc.cc index a3b5d3b7fac..ed496df8169 100644 --- a/sql/item_jsonfunc.cc +++ b/sql/item_jsonfunc.cc @@ -1452,6 +1452,31 @@ static int append_json_value(String *str, Item *item, String *tmp_val) } +bool append_json_value(String *str, String *res, Item *item, bool null_value) +{ + if (null_value) + return str->append("null", 4); + + if (item->type_handler()->is_bool_type()) + { + return ((*res)[0] == '1') ? + str->append("true", 4) : + str->append("false", 5); + } + + if (item->is_json_type()) + return str->append(res->ptr(), res->length()); + + if (item->result_type() == STRING_RESULT) + { + return str->append("\"", 1) || + st_append_escaped(str, res) || + str->append("\"", 1); + } + return st_append_escaped(str, res); +} + + static int append_json_keyname(String *str, Item *item, String *tmp_val) { String *sv= item->val_str(tmp_val); @@ -3621,12 +3646,13 @@ int Arg_comparator::compare_e_json_str_basic(Item *j, Item *s) } -String* Item_func_json_arrayagg::convert_to_json(Item *item, String *res) +bool Item_func_json_arrayagg::convert_to_json(String *str, String *res, + Item *item, bool null_value) { - String tmp; - res->length(0); - append_json_value(res, item, &tmp); - return res; + str->length(0); + if (append_json_value(str, res, item, null_value)) + return true; + return false; } diff --git a/sql/item_jsonfunc.h b/sql/item_jsonfunc.h index 44f9e8146c2..c155ed50396 100644 --- a/sql/item_jsonfunc.h +++ b/sql/item_jsonfunc.h @@ -545,6 +545,7 @@ class Item_func_json_arrayagg : public Item_func_group_concat Item_func_group_concat(thd, context_arg, is_distinct, is_select, is_order, is_separator, limit_clause, row_limit, offset_limit) { + exclude_nulls= FALSE; } Item_func_json_arrayagg(THD *thd, Item_func_json_arrayagg *item); bool is_json_type() { return true; } @@ -552,14 +553,10 @@ class Item_func_json_arrayagg : public Item_func_group_concat const char *func_name() const { return "json_arrayagg("; } enum Sumfunctype sum_func() const {return JSON_ARRAYAGG_FUNC;} - String* convert_to_json(Item *item, String *str); + bool convert_to_json(String *str, String *res, Item *item, bool null_value); String* val_str(String *str); - /* Overrides Item_func_group_concat::add() */ - bool add() - { - return Item_func_group_concat::add(false); - } + Item *get_copy(THD *thd) { return get_item_copy<Item_func_json_arrayagg>(thd, this); } }; diff --git a/sql/item_sum.cc b/sql/item_sum.cc index 5c732095573..a04dbdc19e2 100644 --- a/sql/item_sum.cc +++ b/sql/item_sum.cc @@ -3518,7 +3518,7 @@ String *Item_sum_udf_str::val_str(String *str) */ extern "C" -int group_concat_key_cmp_with_distinct(void* arg, const void* key1, +int group_concat_key_cmp_with_distinct(void* arg, const void* key1, const void* key2) { Item_func_group_concat *item_func= (Item_func_group_concat*)arg; @@ -3552,6 +3552,54 @@ int group_concat_key_cmp_with_distinct(void* arg, const void* key1, } +int group_concat_key_cmp_with_distinct_with_nulls(void* arg, + const void* key1_arg, + const void* key2_arg) +{ + Item_func_group_concat *item_func= (Item_func_group_concat*)arg; + + uchar *key1= (uchar*)key1_arg + item_func->table->s->null_bytes; + uchar *key2= (uchar*)key2_arg + item_func->table->s->null_bytes; + + for (uint i= 0; i < item_func->arg_count_field; i++) + { + Item *item= item_func->args[i]; + /* + If item is a const item then either get_tmp_table_field returns 0 + or it is an item over a const table. + */ + if (item->const_item()) + continue; + /* + We have to use get_tmp_table_field() instead of + real_item()->get_tmp_table_field() because we want the field in + the temporary table, not the original field + */ + Field *field= item->get_tmp_table_field(); + + if (!field) + continue; + + if (field->is_null_in_record((uchar*)key1_arg) && + field->is_null_in_record((uchar*)key2_arg)) + continue; + + if (field->is_null_in_record((uchar*)key1_arg)) + return -1; + + if (field->is_null_in_record((uchar*)key2_arg)) + return 1; + + uint offset= (field->offset(field->table->record[0]) - + field->table->s->null_bytes); + int res= field->cmp(key1 + offset, key2 + offset); + if (res) + return res; + } + return 0; +} + + /** function of sort for syntax: GROUP_CONCAT(expr,... ORDER BY col,... ) */ @@ -3621,6 +3669,7 @@ int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)), uint max_length= (uint)table->in_use->variables.group_concat_max_len; String tmp((char *)table->record[1], table->s->reclength, default_charset_info); + const bool exclude_nulls= item->exclude_nulls; String tmp2; uchar *key= (uchar *) key_arg; String *result= &item->result; @@ -3650,9 +3699,11 @@ int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)), result->append(*item->separator); + bool is_null= false; for (; arg < arg_end; arg++) { String *res; + is_null= false; /* We have to use get_tmp_table_field() instead of real_item()->get_tmp_table_field() because we want the field in @@ -3661,7 +3712,11 @@ int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)), because it contains both order and arg list fields. */ if ((*arg)->const_item()) + { res= (*arg)->val_str(&tmp); + if ((*arg)->null_value) + is_null= TRUE; + } else { Field *field= (*arg)->get_tmp_table_field(); @@ -3670,7 +3725,11 @@ int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)), uint offset= (field->offset(field->table->record[0]) - table->s->null_bytes); DBUG_ASSERT(offset < table->s->reclength); - res= field->val_str(&tmp, key + offset); + if (!exclude_nulls && field->is_null_in_record(key)) + is_null= true; + res= field->val_str(&tmp, + key + offset + (exclude_nulls ? 0 : + table->s->null_bytes +offset)); } else res= (*arg)->val_str(&tmp); @@ -3684,10 +3743,12 @@ int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)), appending it to the result */ Item_func_json_arrayagg *arrayagg= (Item_func_json_arrayagg *) item_arg; - res= arrayagg->convert_to_json(*arg, res); + if (arrayagg->convert_to_json(&tmp2, res, *arg, is_null)) + return 1; + result->append(tmp2); } - - result->append(*res); + else + result->append(*res); } } @@ -3753,7 +3814,7 @@ Item_func_group_concat(THD *thd, Name_resolution_context *context_arg, warning_for_row(FALSE), force_copy_fields(0), row_limit(NULL), offset_limit(NULL), limit_clause(limit_clause), - copy_offset_limit(0), copy_row_limit(0), original(0) + copy_offset_limit(0), copy_row_limit(0), original(0), exclude_nulls(TRUE) { Item *item_select; Item **arg_ptr; @@ -3822,7 +3883,8 @@ Item_func_group_concat::Item_func_group_concat(THD *thd, force_copy_fields(item->force_copy_fields), row_limit(item->row_limit), offset_limit(item->offset_limit), limit_clause(item->limit_clause),copy_offset_limit(item->copy_offset_limit), - copy_row_limit(item->copy_row_limit), original(item) + copy_row_limit(item->copy_row_limit), original(item), + exclude_nulls(item->exclude_nulls) { quick_group= item->quick_group; result.set_charset(collation.collation); @@ -3994,7 +4056,7 @@ bool Item_func_group_concat::repack_tree(THD *thd) */ #define GCONCAT_REPACK_FACTOR (1 << 10) -bool Item_func_group_concat::add(bool exclude_nulls) +bool Item_func_group_concat::add() { if (always_null && exclude_nulls) return 0; @@ -4020,6 +4082,14 @@ bool Item_func_group_concat::add(bool exclude_nulls) if (tree && (res= field->val_str(&buf))) row_str_len+= res->length(); } + else + { + /* + should not reach here, we create temp table for all the arguments of + the group_concat function + */ + DBUG_ASSERT(0); + } } null_value= FALSE; @@ -4029,7 +4099,9 @@ bool Item_func_group_concat::add(bool exclude_nulls) { /* Filter out duplicate rows. */ uint count= unique_filter->elements_in_tree(); - unique_filter->unique_add(table->record[0] + table->s->null_bytes); + unique_filter->unique_add(exclude_nulls ? + table->record[0] + table->s->null_bytes : + table->record[0]); if (count == unique_filter->elements_in_tree()) row_eligible= FALSE; } @@ -4055,7 +4127,9 @@ bool Item_func_group_concat::add(bool exclude_nulls) row to the output buffer here. That will be done in val_str. */ if (row_eligible && !warning_for_row && (!tree && !distinct)) - dump_leaf_key(table->record[0] + table->s->null_bytes, 1, this); + dump_leaf_key(exclude_nulls ? + table->record[0] + table->s->null_bytes : + table->record[0], 1, this); return 0; } @@ -4258,9 +4332,12 @@ bool Item_func_group_concat::setup(THD *thd) } if (distinct) - unique_filter= new Unique(group_concat_key_cmp_with_distinct, + unique_filter= new Unique((exclude_nulls ? + group_concat_key_cmp_with_distinct : + group_concat_key_cmp_with_distinct_with_nulls), (void*)this, - tree_key_length, + tree_key_length + (exclude_nulls ? 0: + table->s->null_bytes), ram_limitation(thd)); if ((row_limit && row_limit->cmp_type() != INT_RESULT) || (offset_limit && offset_limit->cmp_type() != INT_RESULT)) diff --git a/sql/item_sum.h b/sql/item_sum.h index b10d9f5974d..908dbe3cce9 100644 --- a/sql/item_sum.h +++ b/sql/item_sum.h @@ -1841,6 +1841,8 @@ class Item_sum_udf_str :public Item_sum_double C_MODE_START int group_concat_key_cmp_with_distinct(void* arg, const void* key1, const void* key2); +int group_concat_key_cmp_with_distinct_with_nulls(void* arg, const void* key1, + const void* key2); int group_concat_key_cmp_with_order(void* arg, const void* key1, const void* key2); int dump_leaf_key(void* key_arg, @@ -1897,14 +1899,19 @@ class Item_func_group_concat : public Item_sum */ Item_func_group_concat *original; + bool exclude_nulls; + /* Used by Item_func_group_concat and Item_func_json_arrayagg. The latter needs null values but the former doesn't. */ - bool add(bool exclude_nulls); + bool add(); friend int group_concat_key_cmp_with_distinct(void* arg, const void* key1, const void* key2); + friend int group_concat_key_cmp_with_distinct_with_nulls(void* arg, + const void* key1, + const void* key2); friend int group_concat_key_cmp_with_order(void* arg, const void* key1, const void* key2); friend int dump_leaf_key(void* key_arg, @@ -1940,10 +1947,6 @@ class Item_func_group_concat : public Item_sum return &type_handler_varchar; } void clear(); - bool add() - { - return add(true); - } void reset_field() { DBUG_ASSERT(0); } // not used void update_field() { DBUG_ASSERT(0); } // not used bool fix_fields(THD *,Item **);

1 0

[Commits] 7c56f46: MDEV-21883 Server crashes when joining a subselect with 32 tables and GROUP BY
by IgorBabaev 24 Mar '20

24 Mar '20

revision-id: 7c56f46d611eda7dadde83fa4049c2121d42382d (mariadb-10.3.18-190-g7c56f46) parent(s): 44298e4dea39280187c587c6e776ce8d04e350de author: Igor Babaev committer: Igor Babaev timestamp: 2020-03-23 19:20:48 -0700 message: MDEV-21883 Server crashes when joining a subselect with 32 tables and GROUP BY This bug could cause a crash for any query that used a derived table/view/CTE whose specification was a SELECT with a GROUP BY clause and a FROM list containing 32 or more table references. The problem appeared only in the cases when the splitting optimization could be applied to such derived table/view/CTE. --- mysql-test/main/derived_cond_pushdown.result | 85 ++++++++++++++++++++++++++++ mysql-test/main/derived_cond_pushdown.test | 51 +++++++++++++++++ sql/opt_split.cc | 2 +- 3 files changed, 137 insertions(+), 1 deletion(-) diff --git a/mysql-test/main/derived_cond_pushdown.result b/mysql-test/main/derived_cond_pushdown.result index 1ae78ae..532a6cc 100644 --- a/mysql-test/main/derived_cond_pushdown.result +++ b/mysql-test/main/derived_cond_pushdown.result @@ -16918,4 +16918,89 @@ Warnings: Note 1003 /* select#1 */ select `test`.`t1`.`id` AS `id`,`test`.`t1`.`a` AS `a` from `test`.`t1` semi join ((/* select#3 */ select `test`.`t1`.`id` AS `id`,`test`.`t1`.`a` AS `a` from `test`.`t1` left join `test`.`t2` on(`test`.`t2`.`ro_id` = `test`.`t1`.`id` and `test`.`t2`.`flag` = 1) where `test`.`t1`.`id` = `test`.`t1`.`id` group by `test`.`t1`.`id`) `dt`) where `dt`.`id` = `test`.`t1`.`id` drop view v1; drop table t1,t2; +# +# MDEV-21883: potentially splittable materialized derived +# that uses a join of 32 tables +# +CREATE TABLE t (id INT NOT NULL PRIMARY KEY); +INSERT INTO t values (1),(2),(3); +set statement optimizer_switch='split_materialized=off' for SELECT t.id FROM t +LEFT JOIN ( +SELECT t0.id FROM t AS t0 +LEFT JOIN t AS t1 ON 0=1 +LEFT JOIN t AS t2 ON 0=1 +LEFT JOIN t AS t3 ON 0=1 +LEFT JOIN t AS t4 ON 0=1 +LEFT JOIN t AS t5 ON 0=1 +LEFT JOIN t AS t6 ON 0=1 +LEFT JOIN t AS t7 ON 0=1 +LEFT JOIN t AS t8 ON 0=1 +LEFT JOIN t AS t9 ON 0=1 +LEFT JOIN t AS t10 ON 0=1 +LEFT JOIN t AS t11 ON 0=1 +LEFT JOIN t AS t12 ON 0=1 +LEFT JOIN t AS t13 ON 0=1 +LEFT JOIN t AS t14 ON 0=1 +LEFT JOIN t AS t15 ON 0=1 +LEFT JOIN t AS t16 ON 0=1 +LEFT JOIN t AS t17 ON 0=1 +LEFT JOIN t AS t18 ON 0=1 +LEFT JOIN t AS t19 ON 0=1 +LEFT JOIN t AS t20 ON 0=1 +LEFT JOIN t AS t21 ON 0=1 +LEFT JOIN t AS t22 ON 0=1 +LEFT JOIN t AS t23 ON 0=1 +LEFT JOIN t AS t24 ON 0=1 +LEFT JOIN t AS t25 ON 0=1 +LEFT JOIN t AS t26 ON 0=1 +LEFT JOIN t AS t27 ON 0=1 +LEFT JOIN t AS t28 ON 0=1 +LEFT JOIN t AS t29 ON 0=1 +LEFT JOIN t AS t30 ON 0=1 +LEFT JOIN t AS t31 ON 0=1 +GROUP BY t0.id) AS dt ON dt.id = t.id; +id +1 +2 +3 +set statement optimizer_switch='split_materialized=on' for SELECT t.id FROM t +LEFT JOIN ( +SELECT t0.id FROM t AS t0 +LEFT JOIN t AS t1 ON 0=1 +LEFT JOIN t AS t2 ON 0=1 +LEFT JOIN t AS t3 ON 0=1 +LEFT JOIN t AS t4 ON 0=1 +LEFT JOIN t AS t5 ON 0=1 +LEFT JOIN t AS t6 ON 0=1 +LEFT JOIN t AS t7 ON 0=1 +LEFT JOIN t AS t8 ON 0=1 +LEFT JOIN t AS t9 ON 0=1 +LEFT JOIN t AS t10 ON 0=1 +LEFT JOIN t AS t11 ON 0=1 +LEFT JOIN t AS t12 ON 0=1 +LEFT JOIN t AS t13 ON 0=1 +LEFT JOIN t AS t14 ON 0=1 +LEFT JOIN t AS t15 ON 0=1 +LEFT JOIN t AS t16 ON 0=1 +LEFT JOIN t AS t17 ON 0=1 +LEFT JOIN t AS t18 ON 0=1 +LEFT JOIN t AS t19 ON 0=1 +LEFT JOIN t AS t20 ON 0=1 +LEFT JOIN t AS t21 ON 0=1 +LEFT JOIN t AS t22 ON 0=1 +LEFT JOIN t AS t23 ON 0=1 +LEFT JOIN t AS t24 ON 0=1 +LEFT JOIN t AS t25 ON 0=1 +LEFT JOIN t AS t26 ON 0=1 +LEFT JOIN t AS t27 ON 0=1 +LEFT JOIN t AS t28 ON 0=1 +LEFT JOIN t AS t29 ON 0=1 +LEFT JOIN t AS t30 ON 0=1 +LEFT JOIN t AS t31 ON 0=1 +GROUP BY t0.id) AS dt ON dt.id = t.id; +id +1 +2 +3 +DROP TABLE t; # End of 10.3 tests diff --git a/mysql-test/main/derived_cond_pushdown.test b/mysql-test/main/derived_cond_pushdown.test index 525122e..592f23d 100644 --- a/mysql-test/main/derived_cond_pushdown.test +++ b/mysql-test/main/derived_cond_pushdown.test @@ -3371,4 +3371,55 @@ eval explain extended $q2; drop view v1; drop table t1,t2; +--echo # +--echo # MDEV-21883: potentially splittable materialized derived +--echo # that uses a join of 32 tables +--echo # + +CREATE TABLE t (id INT NOT NULL PRIMARY KEY); +INSERT INTO t values (1),(2),(3); + +let $q= +SELECT t.id FROM t +LEFT JOIN ( + SELECT t0.id FROM t AS t0 + LEFT JOIN t AS t1 ON 0=1 + LEFT JOIN t AS t2 ON 0=1 + LEFT JOIN t AS t3 ON 0=1 + LEFT JOIN t AS t4 ON 0=1 + LEFT JOIN t AS t5 ON 0=1 + LEFT JOIN t AS t6 ON 0=1 + LEFT JOIN t AS t7 ON 0=1 + LEFT JOIN t AS t8 ON 0=1 + LEFT JOIN t AS t9 ON 0=1 + LEFT JOIN t AS t10 ON 0=1 + LEFT JOIN t AS t11 ON 0=1 + LEFT JOIN t AS t12 ON 0=1 + LEFT JOIN t AS t13 ON 0=1 + LEFT JOIN t AS t14 ON 0=1 + LEFT JOIN t AS t15 ON 0=1 + LEFT JOIN t AS t16 ON 0=1 + LEFT JOIN t AS t17 ON 0=1 + LEFT JOIN t AS t18 ON 0=1 + LEFT JOIN t AS t19 ON 0=1 + LEFT JOIN t AS t20 ON 0=1 + LEFT JOIN t AS t21 ON 0=1 + LEFT JOIN t AS t22 ON 0=1 + LEFT JOIN t AS t23 ON 0=1 + LEFT JOIN t AS t24 ON 0=1 + LEFT JOIN t AS t25 ON 0=1 + LEFT JOIN t AS t26 ON 0=1 + LEFT JOIN t AS t27 ON 0=1 + LEFT JOIN t AS t28 ON 0=1 + LEFT JOIN t AS t29 ON 0=1 + LEFT JOIN t AS t30 ON 0=1 + LEFT JOIN t AS t31 ON 0=1 + GROUP BY t0.id) AS dt ON dt.id = t.id; + +eval set statement optimizer_switch='split_materialized=off' for $q; + +eval set statement optimizer_switch='split_materialized=on' for $q; + +DROP TABLE t; + --echo # End of 10.3 tests diff --git a/sql/opt_split.cc b/sql/opt_split.cc index 6f8248c..c70fac4 100644 --- a/sql/opt_split.cc +++ b/sql/opt_split.cc @@ -968,7 +968,7 @@ SplM_plan_info * JOIN_TAB::choose_best_splitting(double record_count, The plan for the chosen key has not been found in the cache. Build a new plan and save info on it in the cache */ - table_map all_table_map= (1 << join->table_count) - 1; + table_map all_table_map= (((table_map) 1) << join->table_count) - 1; reset_validity_vars_for_keyuses(best_key_keyuse_ext_start, best_table, best_key, remaining_tables, true); choose_plan(join, all_table_map & ~join->const_table_map);

1 0

[Commits] 03c1b08f0f9: Fix compile error on Windows
by psergey 22 Mar '20

22 Mar '20

revision-id: 03c1b08f0f96f55cc4ff06f7eb237d172875e063 (mariadb-10.5.0-427-g03c1b08f0f9) parent(s): 0da66e563076e9675a545757b76215c43258ad99 author: Sergei Petrunia committer: Sergei Petrunia timestamp: 2020-03-22 17:59:53 +0300 message: Fix compile error on Windows --- sql/sql_select.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 0a2af55326a..5eabdc74f45 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -7196,7 +7196,7 @@ double matching_candidates_in_table(JOIN_TAB *s, bool with_found_constraint, { TABLE *table= s->table; double sel= table->cond_selectivity; - double table_records= s->records; + double table_records= rows2double(s->records); dbl_records= table_records * sel; return dbl_records; }

1 0

[Commits] 0da66e56307: MDEV-21992: queries in innodb_ext_keys use sub-optimal plan with rowid filter
by psergey 22 Mar '20

22 Mar '20

revision-id: 0da66e563076e9675a545757b76215c43258ad99 (mariadb-10.5.0-426-g0da66e56307) parent(s): 8955a27cb0915f6f8a11e10575d5b382e1c2d8c4 author: Sergei Petrunia committer: Sergei Petrunia timestamp: 2020-03-22 17:05:15 +0300 message: MDEV-21992: queries in innodb_ext_keys use sub-optimal plan with rowid filter Don't construct rowid filter from indexes on which we do index-only scans. The idea is that in this case we can just use the scan that we've used to construct the filter. --- mysql-test/main/innodb_ext_key.result | 18 +++++++++--------- sql/rowid_filter.cc | 16 ++++++++++++++++ 2 files changed, 25 insertions(+), 9 deletions(-) diff --git a/mysql-test/main/innodb_ext_key.result b/mysql-test/main/innodb_ext_key.result index f29f81c0ee4..ff92b4506ba 100644 --- a/mysql-test/main/innodb_ext_key.result +++ b/mysql-test/main/innodb_ext_key.result @@ -13,7 +13,7 @@ set optimizer_switch='extended_keys=off'; explain select count(*) from lineitem where l_orderkey=130 and l_shipdate='1992-07-01'; id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE lineitem ref|filter PRIMARY,i_l_shipdate,i_l_orderkey,i_l_orderkey_quantity i_l_orderkey_quantity|i_l_shipdate 4|4 const 5 (0%) Using where; Using rowid filter +1 SIMPLE lineitem ref PRIMARY,i_l_shipdate,i_l_orderkey,i_l_orderkey_quantity PRIMARY 4 const 5 Using where flush status; select count(*) from lineitem where l_orderkey=130 and l_shipdate='1992-07-01'; count(*) @@ -21,9 +21,9 @@ count(*) show status like 'handler_read%'; Variable_name Value Handler_read_first 0 -Handler_read_key 2 +Handler_read_key 1 Handler_read_last 0 -Handler_read_next 7 +Handler_read_next 5 Handler_read_prev 0 Handler_read_retry 0 Handler_read_rnd 0 @@ -33,7 +33,7 @@ set optimizer_switch='extended_keys=on'; explain select count(*) from lineitem where l_orderkey=130 and l_shipdate='1992-07-01'; id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE lineitem ref|filter PRIMARY,i_l_shipdate,i_l_orderkey,i_l_orderkey_quantity i_l_orderkey|i_l_shipdate 4|8 const 5 (0%) Using where; Using rowid filter +1 SIMPLE lineitem ref PRIMARY,i_l_shipdate,i_l_orderkey,i_l_orderkey_quantity i_l_shipdate 8 const,const 1 Using index flush status; select count(*) from lineitem where l_orderkey=130 and l_shipdate='1992-07-01'; count(*) @@ -41,9 +41,9 @@ count(*) show status like 'handler_read%'; Variable_name Value Handler_read_first 0 -Handler_read_key 2 +Handler_read_key 1 Handler_read_last 0 -Handler_read_next 2 +Handler_read_next 1 Handler_read_prev 0 Handler_read_retry 0 Handler_read_rnd 0 @@ -274,7 +274,7 @@ explain select max(l_linenumber) from lineitem where l_shipdate='1992-07-01' and l_orderkey=130; id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE lineitem ref|filter PRIMARY,i_l_shipdate,i_l_orderkey,i_l_orderkey_quantity i_l_orderkey_quantity|i_l_shipdate 4|4 const 5 (0%) Using where; Using rowid filter +1 SIMPLE lineitem ref PRIMARY,i_l_shipdate,i_l_orderkey,i_l_orderkey_quantity PRIMARY 4 const 5 Using where flush status; select max(l_linenumber) from lineitem where l_shipdate='1992-07-01' and l_orderkey=130; @@ -283,9 +283,9 @@ max(l_linenumber) show status like 'handler_read%'; Variable_name Value Handler_read_first 0 -Handler_read_key 2 +Handler_read_key 1 Handler_read_last 0 -Handler_read_next 7 +Handler_read_next 5 Handler_read_prev 0 Handler_read_retry 0 Handler_read_rnd 0 diff --git a/sql/rowid_filter.cc b/sql/rowid_filter.cc index 865f22b431a..6fb7035a460 100644 --- a/sql/rowid_filter.cc +++ b/sql/rowid_filter.cc @@ -350,7 +350,19 @@ void TABLE::init_cost_info_for_usable_range_rowid_filters(THD *thd) From all indexes that can be used for range accesses select only such that - range filter pushdown is supported by the engine for them (1) - they are not clustered primary (2) + - they are not covering (2a) - the range filter containers for them are not too large (3) + + (2a) is based on this logic: if the index $IDX is covering, and we are + going to do a scan on it to build the filter, we can just use $IDX for + reading rows, and not as a filter for some other index. + In ideal world, we would not need to use this condition explicilty because + + cost(scan on $IDX) < cost(scan on $IDX)+cost(build the filter)+ ... + + cost(doing a scan on other index) + + however in reality cost formulas in different parts of the optimizer do not + agree with each other so this is needed. */ while ((key_no= it++) != key_map::Iterator::BITMAP_END) { @@ -358,6 +370,10 @@ void TABLE::init_cost_info_for_usable_range_rowid_filters(THD *thd) continue; if (key_no == s->primary_key && file->primary_key_is_clustered()) // !2 continue; + + if (covering_keys.is_set(key_no)) // !2a + continue; + if (quick_rows[key_no] > get_max_range_rowid_filter_elems_for_table(thd, this, SORTED_ARRAY_CONTAINER)) // !3

1 0

[Commits] a180dac: MDEV-17177 Crash in Item_func_in::cleanup() for SELECT executed via
by IgorBabaev 20 Mar '20

20 Mar '20

revision-id: a180dac22deedf6cae7ef026255102af37737d67 (mariadb-10.2.31-64-ga180dac) parent(s): a0ce62f804dc1a0073688bea46dc2e6728cf55e3 author: Igor Babaev committer: Igor Babaev timestamp: 2020-03-19 21:52:52 -0700 message: MDEV-17177 Crash in Item_func_in::cleanup() for SELECT executed via prepared statement The method Item_func_in::build_clone() that builds a clone item for an Item_func_in item first calls a generic method Item_func::build_item() that builds the the clones for the arguments of the Item_func_in item to be cloned, creates a copy of the Item_func_in object and attaches the clones for the arguments to this copy. Then the method Item_func_in::build_clone() makes the copy fully independent on the copied object in order to guarantee a proper destruction of the clone. The fact is the copy of the Item_func_in object is registered as any other item object and should be destructed as any other item object. If the method Item_func::build_item fails to build a clone of an argument then it returns 0. In this case no copy of the Item_func_in object should be created. Otherwise the finalizing actions for this copy would not be performed and the copy would remain in a state that would prevent its proper destruction. The code of Item_func_in::build_clone() before this patch created the copy of the Item_func_in object before cloning the argument items. If this cloning failed the server crashed when trying to destruct the copy item. The code of Item_row::build_clone() was changed similarly to the code of Item_func::build_clone though this code could not cause any problems. --- mysql-test/r/derived_cond_pushdown.result | 12 +++++++++++ mysql-test/t/derived_cond_pushdown.test | 16 ++++++++++++++ sql/item.cc | 35 +++++++++++++++++-------------- sql/item_row.cc | 11 ++++++---- 4 files changed, 54 insertions(+), 20 deletions(-) diff --git a/mysql-test/r/derived_cond_pushdown.result b/mysql-test/r/derived_cond_pushdown.result index 1010ed6..e2c2463 100644 --- a/mysql-test/r/derived_cond_pushdown.result +++ b/mysql-test/r/derived_cond_pushdown.result @@ -10581,4 +10581,16 @@ a b max_c a b dayname(v1.b) DROP VIEW v1; DROP TABLE t1, t2; SET optimizer_switch=DEFAULT; +# +# MDEV-17177: an attempt to push down IN predicate when one of +# the arguments is too complex to be cloned +# +CREATE TABLE t1 (a VARCHAR(8)); +INSERT INTO t1 VALUES ('abc'),('def'); +CREATE VIEW v1 AS SELECT * FROM t1 GROUP BY a; +SELECT * FROM v1 WHERE IF( a REGEXP 'def', 'foo', a ) IN ('abc', 'foobar'); +a +abc +DROP VIEW v1; +DROP TABLE t1; # End of 10.2 tests diff --git a/mysql-test/t/derived_cond_pushdown.test b/mysql-test/t/derived_cond_pushdown.test index ec15791..a7df65f 100644 --- a/mysql-test/t/derived_cond_pushdown.test +++ b/mysql-test/t/derived_cond_pushdown.test @@ -2168,4 +2168,20 @@ DROP TABLE t1, t2; SET optimizer_switch=DEFAULT; + + +--echo # +--echo # MDEV-17177: an attempt to push down IN predicate when one of +--echo # the arguments is too complex to be cloned +--echo # + +CREATE TABLE t1 (a VARCHAR(8)); +INSERT INTO t1 VALUES ('abc'),('def'); +CREATE VIEW v1 AS SELECT * FROM t1 GROUP BY a; + +SELECT * FROM v1 WHERE IF( a REGEXP 'def', 'foo', a ) IN ('abc', 'foobar'); + +DROP VIEW v1; +DROP TABLE t1; + --echo # End of 10.2 tests diff --git a/sql/item.cc b/sql/item.cc index 4f8433c..ab7340a 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -2389,37 +2389,40 @@ bool Item_func_or_sum::agg_item_set_converter(const DTCollation &coll, @param mem_root part of the memory for the clone @details - This method gets copy of the current item and also - build clones for its referencies. For the referencies - build_copy is called again. + This method fisrt builds clones of the arguments. If it is successful with + buiding the clones then it constructs a copy of this Item_func_or_sum object + and attaches to it the built clones of the arguments. @retval - clone of the item - 0 if an error occured + clone of the item on success + 0 on a failure */ Item* Item_func_or_sum::build_clone(THD *thd, MEM_ROOT *mem_root) { - Item_func_or_sum *copy= (Item_func_or_sum *) get_copy(thd, mem_root); - if (!copy) - return 0; + Item *copy_tmp_args[2]= {0,0}; + Item **copy_args= copy_tmp_args; if (arg_count > 2) { - copy->args= - (Item**) alloc_root(mem_root, sizeof(Item*) * arg_count); - if (!copy->args) + if (!(copy_args= (Item**) alloc_root(mem_root, sizeof(Item*) * arg_count))) return 0; } - else if (arg_count > 0) - copy->args= copy->tmp_arg; - - for (uint i= 0; i < arg_count; i++) { Item *arg_clone= args[i]->build_clone(thd, mem_root); if (!arg_clone) return 0; - copy->args[i]= arg_clone; + copy_args[i]= arg_clone; + } + Item_func_or_sum *copy= (Item_func_or_sum *) get_copy(thd, mem_root); + if (!copy) + return 0; + if (arg_count > 2) + copy->args= copy_args; + else if (arg_count > 0) + { + copy->args= copy->tmp_arg; + memcpy(copy->args, copy_args, sizeof(Item *) * arg_count); } return copy; } diff --git a/sql/item_row.cc b/sql/item_row.cc index 000253e..6ae049d 100644 --- a/sql/item_row.cc +++ b/sql/item_row.cc @@ -166,17 +166,20 @@ void Item_row::bring_value() Item* Item_row::build_clone(THD *thd, MEM_ROOT *mem_root) { - Item_row *copy= (Item_row *) get_copy(thd, mem_root); - if (!copy) + Item **copy_args= 0; + if (!(copy_args= (Item**) alloc_root(mem_root, sizeof(Item*) * arg_count))) return 0; - copy->args= (Item**) alloc_root(mem_root, sizeof(Item*) * arg_count); for (uint i= 0; i < arg_count; i++) { Item *arg_clone= args[i]->build_clone(thd, mem_root); if (!arg_clone) return 0; - copy->args[i]= arg_clone; + copy_args[i]= arg_clone; } + Item_row *copy= (Item_row *) get_copy(thd, mem_root); + if (!copy) + return 0; + copy->args= copy_args; return copy; }

1 0

[Commits] 9f187fd: Test MyRocks-style encoding
by psergey 16 Mar '20

16 Mar '20

revision-id: 9f187fd724c7c1c0217fe5fecf4e7ef361579497 () parent(s): c04d43a9833865607a2529c29801b52ef2a8c729 author: Sergei Petrunia committer: Sergei Petrunia timestamp: 2020-03-16 23:00:03 +0300 message: Test MyRocks-style encoding --- .gitignore | 5 +++++ 25-collect-results.sh | 18 ++++++++++++++++++ 25-setup-memcmp-trees.sh | 8 ++++++++ 25-varchar-memcmp.sh | 20 ++++++++++++++++++++ 4 files changed, 51 insertions(+) diff --git a/.gitignore b/.gitignore index dc2b0c7..8e56f01 100644 --- a/.gitignore +++ b/.gitignore @@ -28,3 +28,8 @@ my-mariadb-10.4.cnf my-mysql-8.0.cnf mysql-8.0-data mysql-8.0-vars.sh +10.5-memcmp +10.5-memcmp-data +10.5-memcmp-data.clean +10.5-memcmp-vars.sh +my-10.5-memcmp.cnf diff --git a/25-collect-results.sh b/25-collect-results.sh new file mode 100644 index 0000000..1f9c247 --- /dev/null +++ b/25-collect-results.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +set -e + +RES='result-varchars' + +#mkdir $RES + +bash filesort-bench1/06-make-collect-results.sh > $RES/collect-results.sql + +for SERVER in 10.5-new 10.5-memcmp ; do + + bash prepare-server.sh -r -m $SERVER + source $SERVER-vars.sh + + $MYSQL $MYSQL_ARGS test < $RES/collect-results.sql | tee $RES/results-$SERVER.txt + +done diff --git a/25-setup-memcmp-trees.sh b/25-setup-memcmp-trees.sh new file mode 100644 index 0000000..cf7bd78 --- /dev/null +++ b/25-setup-memcmp-trees.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +#./setup-server/setup-mariadb-current.sh 10.5 b753ac066bc26acda9deb707a31c112f1bbf9ec2 10.5-new +#./setup-server/setup-mariadb-current.sh 10.5 561b5ce3647a63c343f70ce183e408423b3fa65c 10.5-old + +./setup-server/setup-mariadb-current.sh 10.5-mdev21955 d187214b884f3f37eda052dacc701eece6284183 10.5-memcmp + + diff --git a/25-varchar-memcmp.sh b/25-varchar-memcmp.sh new file mode 100644 index 0000000..5156bf7 --- /dev/null +++ b/25-varchar-memcmp.sh @@ -0,0 +1,20 @@ +#!/bin/bash + +set -e + +RES='result-varchars' + +mkdir $RES + +bash filesort-bench1/06-make-varchar-bench.sh > $RES/varchar-bench.sql + +for SERVER in 10.5-memcmp 10.5-new ; do + + (cd $SERVER; git log -1) > $RES/tree-$SERVER.txt + + bash prepare-server.sh -m $SERVER + source $SERVER-vars.sh + echo $SERVER + $MYSQL $MYSQL_ARGS test < $RES/varchar-bench.sql | tee $RES/varchar-$SERVER.txt + +done

1 0

[Commits] d187214b884: MDEV-21955: Alternative way of doing packed-sort keys
by psergey 16 Mar '20

16 Mar '20

revision-id: d187214b884f3f37eda052dacc701eece6284183 (mariadb-10.5.0-329-gd187214b884) parent(s): b753ac066bc26acda9deb707a31c112f1bbf9ec2 author: Sergei Petrunia committer: Sergei Petrunia timestamp: 2020-03-16 22:43:23 +0300 message: MDEV-21955: Alternative way of doing packed-sort keys Use "Variable-Length Space Padded Encoding" that MyRocks uses. The value comparison function is memcmp(). A very crude just to evaluate the performance of this. --- sql/filesort.cc | 185 +++++++++++++++++++++++++++++++++++++++++++++++++++++++- sql/sql_class.h | 5 ++ 2 files changed, 188 insertions(+), 2 deletions(-) diff --git a/sql/filesort.cc b/sql/filesort.cc index 56f060b8c26..e7c8c4c19bd 100644 --- a/sql/filesort.cc +++ b/sql/filesort.cc @@ -103,7 +103,6 @@ void Sort_param::init_for_filesort(uint sortlen, TABLE *table, max_rows= maxrows; } - void Sort_param::try_to_pack_addons(ulong max_length_for_sort_data) { if (!using_addon_fields() || // no addons, or @@ -2165,6 +2164,9 @@ Type_handler_decimal_result::sort_length(THD *thd, @return Total length of sort buffer in bytes */ +static int get_segment_size_from_collation(const CHARSET_INFO *const cs); +static void rdb_get_mem_comparable_space(const CHARSET_INFO *const cs, + std::vector<uchar> **xfrm); static uint sortlength(THD *thd, Sort_keys *sort_keys, bool *multi_byte_charset, @@ -2195,6 +2197,7 @@ sortlength(THD *thd, Sort_keys *sort_keys, bool *multi_byte_charset, SORT_FIELD_ATTR::VARIABLE_SIZE : SORT_FIELD_ATTR::FIXED_SIZE; sortorder->cs= cs; + sortorder->space_xfrm= NULL; if (use_strnxfrm((cs=sortorder->field->sort_charset()))) { @@ -2207,6 +2210,10 @@ sortlength(THD *thd, Sort_keys *sort_keys, bool *multi_byte_charset, sortorder->length_bytes= number_storage_requirement(MY_MIN(sortorder->original_length, thd->variables.max_sort_length)); + //psergey-try: + sortorder->m_segment_size= get_segment_size_from_collation(cs); + rdb_get_mem_comparable_space(cs, &sortorder->space_xfrm); + sortorder->m_n_weights= sortorder->field->char_length(); } if ((sortorder->maybe_null= sortorder->field->maybe_null())) @@ -2215,6 +2222,7 @@ sortlength(THD *thd, Sort_keys *sort_keys, bool *multi_byte_charset, else { CHARSET_INFO *cs; + sortorder->space_xfrm= NULL; sortorder->item->type_handler()->sort_length(thd, sortorder->item, sortorder); sortorder->type= sortorder->item->type_handler()->is_packable() ? @@ -2228,6 +2236,7 @@ sortlength(THD *thd, Sort_keys *sort_keys, bool *multi_byte_charset, if (sortorder->is_variable_sized() && allow_packing_for_keys) { allow_packing_for_keys= sortorder->check_if_packing_possible(thd); + allow_packing_for_keys= false; // psergey-new sortorder->length_bytes= number_storage_requirement(MY_MIN(sortorder->original_length, thd->variables.max_sort_length)); @@ -2479,7 +2488,6 @@ SORT_INFO::~SORT_INFO() DBUG_VOID_RETURN; } - void Sort_param::try_to_pack_sortkeys() { #ifdef WITHOUT_PACKED_SORT_KEYS @@ -2850,7 +2858,27 @@ int SORT_FIELD_ATTR::compare_packed_fixed_size_vals(uchar *a, size_t *a_len, <0 key a_ptr less than b_ptr */ +int compare_packed_sort_keys(void *sort_param, + unsigned char **a_ptr, unsigned char **b_ptr) +{ + uchar *a= *a_ptr; + uchar *b= *b_ptr; + // length was saved with this: + // Sort_keys::store_sortkey_length(orig_to, length); + int a_len= uint4korr(a); + int b_len= uint4korr(b); + a+= Sort_keys::size_of_length_field; + b+= Sort_keys::size_of_length_field; + + int size= std::min(a_len, b_len); + int res; + if ((res= memcmp(a, b, size))) + return res; + return (a_len < b_len)? -1 : ( (a_len == b_len)? 0 : 1); + +} +#if 0 int compare_packed_sort_keys(void *sort_param, unsigned char **a_ptr, unsigned char **b_ptr) { @@ -2886,7 +2914,106 @@ int compare_packed_sort_keys(void *sort_param, retval= memcmp(a, b, param->res_length); return retval; } +#endif + + +///////////////////////////////////////////////////////////////////////////// +// psergey-try: +///////////////////////////////////////////////////////////////////////////// + +/* + Compare the string in [buf..buf_end) with a string that is an infinite + sequence of strings in space_xfrm +*/ + +static int rdb_compare_string_with_spaces( + const uchar *buf, const uchar *const buf_end, + const std::vector<uchar> *const space_xfrm) { + int cmp = 0; + while (buf < buf_end) { + size_t bytes = std::min((size_t)(buf_end - buf), space_xfrm->size()); + if ((cmp = memcmp(buf, space_xfrm->data(), bytes)) != 0) break; + buf += bytes; + } + return cmp; +} + +static int get_segment_size_from_collation(const CHARSET_INFO *const cs) { + int ret; + + enum collations_used { + COLLATION_UTF8MB4_BIN = 46, + COLLATION_LATIN1_BIN = 47, + COLLATION_UTF16LE_BIN = 55, + COLLATION_UTF32_BIN = 61, + COLLATION_UTF16_BIN = 62, + COLLATION_BINARY = 63, + COLLATION_UTF8_BIN = 83 + }; + + if (cs->number == COLLATION_UTF8MB4_BIN || cs->number == COLLATION_UTF16_BIN || + cs->number == COLLATION_UTF16LE_BIN || cs->number == COLLATION_UTF32_BIN) { + /* + In these collations, a character produces one weight, which is 3 bytes. + Segment has 3 characters, add one byte for VARCHAR_CMP_* marker, and we + get 3*3+1=10 + */ + ret = 10; + } else { + /* + All other collations. There are two classes: + - Unicode-based, except for collations mentioned in the if-condition. + For these all weights are 2 bytes long, a character may produce 0..8 + weights. + in any case, 8 bytes of payload in the segment guarantee that the last + space character won't span across segments. + + - Collations not based on unicode. These have length(strxfrm(' '))=1, + there nothing to worry about. + + In both cases, take 8 bytes payload + 1 byte for VARCHAR_CMP* marker. + */ + ret = 9; + } + return ret; +} + +const int RDB_SPACE_XFRM_SIZE = 20; + +static void rdb_get_mem_comparable_space(const CHARSET_INFO *const cs, + std::vector<uchar> **xfrm) { + //size_t *const xfrm_len, + //size_t *const mb_len) { + + // Upper bound of how many bytes can be occupied by multi-byte form of a + // character in any charset. + const int MAX_MULTI_BYTE_CHAR_SIZE = 4; + DBUG_ASSERT(cs->mbmaxlen <= MAX_MULTI_BYTE_CHAR_SIZE); + + // multi-byte form of the ' ' (space) character + uchar space_mb[MAX_MULTI_BYTE_CHAR_SIZE]; + + const size_t space_mb_len = cs->wc_mb( + (my_wc_t)cs->pad_char, space_mb, space_mb + sizeof(space_mb)); + // mem-comparable image of the space character + std::array<uchar, 20> space; + + const size_t space_len = cs->strnxfrm( + space.data(), sizeof(space), 1, space_mb, space_mb_len, 0); + + std::vector<uchar> *p= new std::vector<uchar>(space.data(), + space.data() + space_len); + while (p->size() < RDB_SPACE_XFRM_SIZE) { + p->insert(p->end(), space.data(), + space.data() + space_len); + } + + *xfrm = p; + //*xfrm = &rdb_mem_comparable_space[cs->number]->spaces_xfrm; + //*xfrm_len = rdb_mem_comparable_space[cs->number]->space_xfrm_len; + //*mb_len = rdb_mem_comparable_space[cs->number]->space_mb_len; +} /* @brief @@ -2911,6 +3038,59 @@ uint SORT_FIELD_ATTR::pack_sort_string(uchar *to, const LEX_CSTRING &str, CHARSET_INFO *cs) const { + const int VARCHAR_CMP_LESS_THAN_SPACES = 1; + const int VARCHAR_CMP_EQUAL_TO_SPACES = 2; + const int VARCHAR_CMP_GREATER_THAN_SPACES = 3; + + const size_t trimmed_len = cs->lengthsp(str.str, str.length); + uchar buf_space[1000]; + uchar *buf=buf_space; + const size_t xfrm_len = cs->strnxfrm((char*)buf, sizeof(buf_space), + m_n_weights, + str.str, trimmed_len, + 0/*flags*/); + + /* Got a mem-comparable image in 'buf'. Now, produce varlength encoding */ + uchar *const buf_end = buf + xfrm_len; + + size_t encoded_size = 0; + uchar *ptr = to; + size_t padding_bytes; + while (true) { + const size_t copy_len = + std::min<size_t>(m_segment_size - 1, buf_end - buf); + padding_bytes = m_segment_size - 1 - copy_len; + memcpy(ptr, buf, copy_len); + ptr += copy_len; + buf += copy_len; + + if (padding_bytes) { + memcpy(ptr, space_xfrm->data(), padding_bytes); + ptr += padding_bytes; + *ptr = VARCHAR_CMP_EQUAL_TO_SPACES; // last segment + } else { + // Compare the string suffix with a hypothetical infinite string of + // spaces. It could be that the first difference is beyond the end of + // current chunk. + const int cmp = + rdb_compare_string_with_spaces(buf, buf_end, space_xfrm); + + if (cmp < 0) { + *ptr = VARCHAR_CMP_LESS_THAN_SPACES; + } else if (cmp > 0) { + *ptr = VARCHAR_CMP_GREATER_THAN_SPACES; + } else { + // It turns out all the rest are spaces. + *ptr = VARCHAR_CMP_EQUAL_TO_SPACES; + } + } + encoded_size += m_segment_size; + + if (*(ptr++) == VARCHAR_CMP_EQUAL_TO_SPACES) break; + } + + return encoded_size; +#if 0 uchar *orig_to= to; size_t length, data_length; length= str.length; @@ -2934,6 +3114,7 @@ SORT_FIELD_ATTR::pack_sort_string(uchar *to, const LEX_CSTRING &str, to+= suffix_length; } return static_cast<uint>(to - orig_to); +#endif } diff --git a/sql/sql_class.h b/sql/sql_class.h index d756b047ffe..957d8d26a7c 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -6315,6 +6315,11 @@ struct SORT_FIELD_ATTR */ bool maybe_null; CHARSET_INFO *cs; + + uint m_segment_size; //psergey-try: + uint m_n_weights; // psergey-try + std::vector<uchar> *space_xfrm; + uint pack_sort_string(uchar *to, const LEX_CSTRING &str, CHARSET_INFO *cs) const; int compare_packed_fixed_size_vals(uchar *a, size_t *a_len,

1 0

[Commits] 878952d: Save tree info
by psergey 15 Mar '20

15 Mar '20

revision-id: 878952d1488d7646d870bd6e6e0752cb69ada1b1 () parent(s): 7734e151742b73523416ffa7ca4b6485611ff782 author: Sergei Petrunia committer: Sergei Petrunia timestamp: 2020-03-16 01:03:38 +0300 message: Save tree info --- run-test.sh | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/run-test.sh b/run-test.sh index 7a996ca..ef68cb1 100755 --- a/run-test.sh +++ b/run-test.sh @@ -61,6 +61,7 @@ if [ -d $RESULT_DIR ]; then exit 1 fi + echo "Starting test "$RUN_NAME" with $SERVER_DIR" if [[ $USE_PERF ]] ; then echo " Collecting perf profile" @@ -104,7 +105,7 @@ while true ; do sleep 5 client_attempts=0 while true ; do - $MYSQL_CMD -e "drop database sbtest" + $MYSQL_CMD -e "drop database if exists sbtest" $MYSQL_CMD -e "create database sbtest" if [ $? -eq 0 ]; then @@ -153,6 +154,9 @@ fi ## /usr/share/sysbench/oltp_write_only.lua --table-size=250000 --tables=4" SYSBENCH_TEST="oltp_write_only.lua" +(cd $SERVER_DIR && git log -1 ) > $RESULT_DIR/server-cset.txt +(cd $SERVER_DIR/rocksdb && git log -1 ) > $RESULT_DIR/rocksdb-cset.txt + cat > $RESULT_DIR/info.txt <<END SERVERNAME=$SERVERNAME SYSBENCH_TEST=$SYSBENCH_TEST

1 0