database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

Merge 10.5 into 10.6

Browse Source
This commit is contained in:
Marko Mäkelä
2021-09-06 10:31:32 +03:00
parent 4c1ed54bfc 84c578c795
commit 7730dd392b
22 changed files with 257 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
mysql-test/suite/s3/basic.result
View File

@ -2,23 +2,25 @@ drop table if exists t1;
# #
# Test simple create of s3 table # Test simple create of s3 table
# #
create or replace table t1 (a int, b int, key (a)) engine=aria; create or replace table t1 (a int, b int, c varchar(1000), key (a), key(c)) engine=aria;
insert into t1 select seq,seq+10 from seq_1_to_10000; insert into t1 select seq, seq+10, repeat(char(65+ mod(seq, 20)),mod(seq,1000)) from seq_1_to_10000;
alter table t1 engine=s3; alter table t1 engine=s3;
show create table t1; show create table t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL, `a` int(11) DEFAULT NULL,
`b` int(11) DEFAULT NULL, `b` int(11) DEFAULT NULL,
KEY `a` (`a`) `c` varchar(1000) DEFAULT NULL,
KEY `a` (`a`),
KEY `c` (`c`)
) ENGINE=S3 DEFAULT CHARSET=latin1 PAGE_CHECKSUM=1 ) ENGINE=S3 DEFAULT CHARSET=latin1 PAGE_CHECKSUM=1
select * from information_schema.tables where table_schema="database" and table_name="t1";; select * from information_schema.tables where table_schema="database" and table_name="t1";;
TABLE_CATALOG TABLE_SCHEMA TABLE_NAME TABLE_TYPE ENGINE VERSION ROW_FORMAT TABLE_ROWS AVG_ROW_LENGTH DATA_LENGTH MAX_DATA_LENGTH INDEX_LENGTH DATA_FREE AUTO_INCREMENT CREATE_TIME UPDATE_TIME CHECK_TIME TABLE_COLLATION CHECKSUM CREATE_OPTIONS TABLE_COMMENT MAX_INDEX_LENGTH TEMPORARY TABLE_CATALOG TABLE_SCHEMA TABLE_NAME TABLE_TYPE ENGINE VERSION ROW_FORMAT TABLE_ROWS AVG_ROW_LENGTH DATA_LENGTH MAX_DATA_LENGTH INDEX_LENGTH DATA_FREE AUTO_INCREMENT CREATE_TIME UPDATE_TIME CHECK_TIME TABLE_COLLATION CHECKSUM CREATE_OPTIONS TABLE_COMMENT MAX_INDEX_LENGTH TEMPORARY
def # t1 BASE TABLE S3 10 Page 10000 33 335872 # 122880 0 NULL # # # latin1_swedish_ci NULL page_checksum=1 9007199254732800 # def # t1 BASE TABLE S3 10 Page 10000 567 5677056 # 761856 0 NULL # # # latin1_swedish_ci NULL page_checksum=1 2305843009213685760 #
show table status like "t1"; show table status like "t1";
Name Engine Version Row_format Rows Avg_row_length Data_length Max_data_length Index_length Data_free Auto_increment Create_time Update_time Check_time Collation Checksum Create_options Comment Max_index_length Temporary Name Engine Version Row_format Rows Avg_row_length Data_length Max_data_length Index_length Data_free Auto_increment Create_time Update_time Check_time Collation Checksum Create_options Comment Max_index_length Temporary
t1 S3 10 Page 10000 33 335872 # 122880 0 NULL # # # latin1_swedish_ci NULL page_checksum=1 # N t1 S3 10 Page 10000 567 5677056 # 761856 0 NULL # # # latin1_swedish_ci NULL page_checksum=1 # N
select * from t1 limit 10; select a,b from t1 limit 10;
a b a b
1 11 1 11
2 12 2 12
@ -33,7 +35,7 @@ a b
select count(*) from t1; select count(*) from t1;
count(*) count(*)
10000 10000
select * from t1 where a between 10 and 20; select a,b from t1 where a between 10 and 20;
a b a b
10 20 10 20
11 21 11 21
@ -55,15 +57,53 @@ update t1 set b=100 where a=1;
ERROR HY000: Table 't1' is read only ERROR HY000: Table 't1' is read only
delete from t1 where a>10; delete from t1 where a>10;
ERROR HY000: Table 't1' is read only ERROR HY000: Table 't1' is read only
#
# Analyze, repair, optimize and check table
#
set @@use_stat_tables='never';
truncate mysql.table_stats;
check table t1 fast;
Table Op Msg_type Msg_text
database.t1 check status Table is already up to date
check table t1 quick;
Table Op Msg_type Msg_text
database.t1 check status OK
check table t1 extended;
Table Op Msg_type Msg_text
database.t1 check status OK
analyze table t1;
Table Op Msg_type Msg_text
database.t1 analyze status Table 'database.t1' is read only
analyze table t1 persistent for all;
Table Op Msg_type Msg_text
database.t1 analyze status Table 'database.t1' is read only
database.t1 analyze status Engine-independent statistics collected
database.t1 analyze status OK
repair table t1;
Table Op Msg_type Msg_text
database.t1 repair Error Table 't1' is read only
database.t1 repair status Operation failed
optimize table t1;
Table Op Msg_type Msg_text
database.t1 optimize Error Table 't1' is read only
database.t1 optimize status Operation failed
select * from mysql.table_stats;
db_name table_name cardinality
database t1 10000
#
# Converting table back to Aria
#
alter table t1 engine=aria; alter table t1 engine=aria;
show create table t1; show create table t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL, `a` int(11) DEFAULT NULL,
`b` int(11) DEFAULT NULL, `b` int(11) DEFAULT NULL,
KEY `a` (`a`) `c` varchar(1000) DEFAULT NULL,
KEY `a` (`a`),
KEY `c` (`c`)
) ENGINE=Aria DEFAULT CHARSET=latin1 PAGE_CHECKSUM=1 ) ENGINE=Aria DEFAULT CHARSET=latin1 PAGE_CHECKSUM=1
select * from t1 limit 10; select a,b from t1 limit 10;
a b a b
1 11 1 11
2 12 2 12

39
mysql-test/suite/s3/basic.test
View File

@ -13,8 +13,8 @@ drop table if exists t1;
--echo # Test simple create of s3 table --echo # Test simple create of s3 table
--echo # --echo #
create or replace table t1 (a int, b int, key (a)) engine=aria; create or replace table t1 (a int, b int, c varchar(1000), key (a), key(c)) engine=aria;
insert into t1 select seq,seq+10 from seq_1_to_10000; insert into t1 select seq, seq+10, repeat(char(65+ mod(seq, 20)),mod(seq,1000)) from seq_1_to_10000;
alter table t1 engine=s3; alter table t1 engine=s3;
show create table t1; show create table t1;
@ -23,9 +23,9 @@ show create table t1;
--eval select * from information_schema.tables where table_schema="$database" and table_name="t1"; --eval select * from information_schema.tables where table_schema="$database" and table_name="t1";
--replace_column 8 # 12 # 13 # 14 # 19 # --replace_column 8 # 12 # 13 # 14 # 19 #
show table status like "t1"; show table status like "t1";
select * from t1 limit 10; select a,b from t1 limit 10;
select count(*) from t1; select count(*) from t1;
select * from t1 where a between 10 and 20; select a,b from t1 where a between 10 and 20;
--replace_column 9 # --replace_column 9 #
explain select * from t1 where a between 10 and 20; explain select * from t1 where a between 10 and 20;
--error ER_OPEN_AS_READONLY --error ER_OPEN_AS_READONLY
@ -34,9 +34,38 @@ insert into t1 values (1,1);
update t1 set b=100 where a=1; update t1 set b=100 where a=1;
--error ER_OPEN_AS_READONLY --error ER_OPEN_AS_READONLY
delete from t1 where a>10; delete from t1 where a>10;
--echo #
--echo # Analyze, repair, optimize and check table
--echo #
set @@use_stat_tables='never';
truncate mysql.table_stats;
--replace_result $database database
check table t1 fast;
--replace_result $database database
check table t1 quick;
--replace_result $database database
check table t1 extended;
--replace_result $database database
analyze table t1;
--replace_result $database database
analyze table t1 persistent for all;
--replace_result $database database
repair table t1;
--replace_result $database database
optimize table t1;
--replace_result $database database
select * from mysql.table_stats;
--echo #
--echo # Converting table back to Aria
--echo #
alter table t1 engine=aria; alter table t1 engine=aria;
show create table t1; show create table t1;
select * from t1 limit 10; select a,b from t1 limit 10;
select count(*) from t1; select count(*) from t1;
delete from t1 where a=1; delete from t1 where a=1;
drop table t1; drop table t1;

7
mysql-test/suite/s3/partition.result
View File

@ -54,14 +54,15 @@ ALTER TABLE t2 TRUNCATE PARTITION p3;
ERROR HY000: Table 't2' is read only ERROR HY000: Table 't2' is read only
ALTER TABLE t2 ANALYZE PARTITION p3; ALTER TABLE t2 ANALYZE PARTITION p3;
Table Op Msg_type Msg_text Table Op Msg_type Msg_text
s3.t2 analyze error Table 's3.t2' is read only s3.t2 analyze status Table 's3.t2' is read only
s3.t2 analyze status Engine-independent statistics collected
s3.t2 analyze status OK
SELECT count(*) FROM t2; SELECT count(*) FROM t2;
count(*) count(*)
6 6
ALTER TABLE t2 CHECK PARTITION p3; ALTER TABLE t2 CHECK PARTITION p3;
Table Op Msg_type Msg_text Table Op Msg_type Msg_text
s3.t2 check error Subpartition p3sp0 returned error s3.t2 check status OK
s3.t2 check error Unknown - internal error 165 during operation
SELECT count(*) FROM t2; SELECT count(*) FROM t2;
count(*) count(*)
6 6

28
mysys/mf_keycache.c
View File

@ -164,18 +164,18 @@ typedef struct st_simple_key_cache_cb
size_t key_cache_mem_size; /* specified size of the cache memory */ size_t key_cache_mem_size; /* specified size of the cache memory */
size_t allocated_mem_size; /* size of the memory actually allocated */ size_t allocated_mem_size; /* size of the memory actually allocated */
uint key_cache_block_size; /* size of the page buffer of a cache block */ uint key_cache_block_size; /* size of the page buffer of a cache block */
ulong min_warm_blocks; /* min number of warm blocks; */ size_t min_warm_blocks; /* min number of warm blocks; */
ulong age_threshold; /* age threshold for hot blocks */ size_t age_threshold; /* age threshold for hot blocks */
ulonglong keycache_time; /* total number of block link operations */ ulonglong keycache_time; /* total number of block link operations */
uint hash_entries; /* max number of entries in the hash table */ uint hash_entries; /* max number of entries in the hash table */
uint changed_blocks_hash_size; /* Number of hash buckets for file blocks */ uint changed_blocks_hash_size; /* Number of hash buckets for file blocks */
int hash_links; /* max number of hash links */ int hash_links; /* max number of hash links */
int hash_links_used; /* number of hash links currently used */ int hash_links_used; /* number of hash links currently used */
int disk_blocks; /* max number of blocks in the cache */ int disk_blocks; /* max number of blocks in the cache */
ulong blocks_used; /* maximum number of concurrently used blocks */ size_t blocks_used; /* maximum number of concurrently used blocks */
ulong blocks_unused; /* number of currently unused blocks */ size_t blocks_unused; /* number of currently unused blocks */
ulong blocks_changed; /* number of currently dirty blocks */ size_t blocks_changed; /* number of currently dirty blocks */
ulong warm_blocks; /* number of blocks in warm sub-chain */ size_t warm_blocks; /* number of blocks in warm sub-chain */
ulong cnt_for_resize_op; /* counter to block resize operation */ ulong cnt_for_resize_op; /* counter to block resize operation */
long blocks_available; /* number of blocks available in the LRU chain */ long blocks_available; /* number of blocks available in the LRU chain */
HASH_LINK **hash_root; /* arr. of entries into hash table buckets */ HASH_LINK **hash_root; /* arr. of entries into hash table buckets */
@ -478,7 +478,7 @@ int init_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
size_t use_mem, uint division_limit, size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size) uint age_threshold, uint changed_blocks_hash_size)
{ {
ulong blocks, hash_links; size_t blocks, hash_links;
size_t length; size_t length;
int error; int error;
DBUG_ENTER("init_simple_key_cache"); DBUG_ENTER("init_simple_key_cache");
@ -519,8 +519,8 @@ int init_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
DBUG_PRINT("info", ("key_cache_block_size: %u", DBUG_PRINT("info", ("key_cache_block_size: %u",
key_cache_block_size)); key_cache_block_size));
blocks= (ulong) (use_mem / (sizeof(BLOCK_LINK) + 2 * sizeof(HASH_LINK) + blocks= use_mem / (sizeof(BLOCK_LINK) + 2 * sizeof(HASH_LINK) +
sizeof(HASH_LINK*) * 5/4 + key_cache_block_size)); sizeof(HASH_LINK*) * 5/4 + key_cache_block_size);
/* Changed blocks hash needs to be a power of 2 */ /* Changed blocks hash needs to be a power of 2 */
changed_blocks_hash_size= my_round_up_to_next_power(MY_MAX(changed_blocks_hash_size, changed_blocks_hash_size= my_round_up_to_next_power(MY_MAX(changed_blocks_hash_size,
@ -532,7 +532,7 @@ int init_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
for ( ; ; ) for ( ; ; )
{ {
/* Set my_hash_entries to the next bigger 2 power */ /* Set my_hash_entries to the next bigger 2 power */
if ((keycache->hash_entries= next_power(blocks)) < blocks * 5/4) if ((keycache->hash_entries= next_power((uint)blocks)) < blocks * 5/4)
keycache->hash_entries<<= 1; keycache->hash_entries<<= 1;
hash_links= 2 * blocks; hash_links= 2 * blocks;
#if defined(MAX_THREADS) #if defined(MAX_THREADS)
@ -543,8 +543,8 @@ int init_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
ALIGN_SIZE(hash_links * sizeof(HASH_LINK)) + ALIGN_SIZE(hash_links * sizeof(HASH_LINK)) +
ALIGN_SIZE(sizeof(HASH_LINK*) * ALIGN_SIZE(sizeof(HASH_LINK*) *
keycache->hash_entries) + keycache->hash_entries) +
sizeof(BLOCK_LINK*)* (changed_blocks_hash_size*2))) + sizeof(BLOCK_LINK*)* ((size_t)changed_blocks_hash_size*2))) +
((size_t) blocks * keycache->key_cache_block_size) > use_mem && blocks > 8) (blocks * keycache->key_cache_block_size) > use_mem && blocks > 8)
blocks--; blocks--;
keycache->allocated_mem_size= blocks * keycache->key_cache_block_size; keycache->allocated_mem_size= blocks * keycache->key_cache_block_size;
if ((keycache->block_mem= my_large_malloc(&keycache->allocated_mem_size, if ((keycache->block_mem= my_large_malloc(&keycache->allocated_mem_size,
@ -584,7 +584,7 @@ int init_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
} }
keycache->blocks_unused= blocks; keycache->blocks_unused= blocks;
keycache->disk_blocks= (int) blocks; keycache->disk_blocks= (int) blocks;
keycache->hash_links= hash_links; keycache->hash_links= (int)hash_links;
keycache->hash_links_used= 0; keycache->hash_links_used= 0;
keycache->free_hash_list= NULL; keycache->free_hash_list= NULL;
keycache->blocks_used= keycache->blocks_changed= 0; keycache->blocks_used= keycache->blocks_changed= 0;
@ -4854,7 +4854,7 @@ static int cache_empty(SIMPLE_KEY_CACHE_CB *keycache)
} }
if (errcnt) if (errcnt)
{ {
fprintf(stderr, "blocks: %d used: %lu\n", fprintf(stderr, "blocks: %d used: %zu\n",
keycache->disk_blocks, keycache->blocks_used); keycache->disk_blocks, keycache->blocks_used);
fprintf(stderr, "hash_links: %d used: %d\n", fprintf(stderr, "hash_links: %d used: %d\n",
keycache->hash_links, keycache->hash_links_used); keycache->hash_links, keycache->hash_links_used);

3
sql/ha_partition.cc
View File

@ -1523,7 +1523,8 @@ int ha_partition::handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt,
/* print a line which partition the error belongs to */ /* print a line which partition the error belongs to */
if (error != HA_ADMIN_NOT_IMPLEMENTED && if (error != HA_ADMIN_NOT_IMPLEMENTED &&
error != HA_ADMIN_ALREADY_DONE && error != HA_ADMIN_ALREADY_DONE &&
error != HA_ADMIN_TRY_ALTER) error != HA_ADMIN_TRY_ALTER &&
error != HA_ERR_TABLE_READONLY)
{ {
print_admin_msg(thd, MYSQL_ERRMSG_SIZE, &msg_error, print_admin_msg(thd, MYSQL_ERRMSG_SIZE, &msg_error,
table_share->db.str, table->alias, table_share->db.str, table->alias,

23
sql/signal_handler.cc
View File

@ -1,5 +1,5 @@
/* Copyright (c) 2011, 2012, Oracle and/or its affiliates. /* Copyright (c) 2011, 2012, Oracle and/or its affiliates.
Copyright (c) 2011, 2014, SkySQL Ab. Copyright (c) 2011, 2021, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
@ -174,19 +174,19 @@ extern "C" sig_handler handle_fatal_signal(int sig)
my_safe_printf_stderr("Server version: %s\n", server_version); my_safe_printf_stderr("Server version: %s\n", server_version);
if (dflt_key_cache) if (dflt_key_cache)
my_safe_printf_stderr("key_buffer_size=%lu\n", my_safe_printf_stderr("key_buffer_size=%zu\n",
(ulong) dflt_key_cache->key_cache_mem_size); dflt_key_cache->key_cache_mem_size);
my_safe_printf_stderr("read_buffer_size=%ld\n", my_safe_printf_stderr("read_buffer_size=%lu\n",
(long) global_system_variables.read_buff_size); global_system_variables.read_buff_size);
my_safe_printf_stderr("max_used_connections=%lu\n", my_safe_printf_stderr("max_used_connections=%lu\n",
(ulong) max_used_connections); max_used_connections);
if (thread_scheduler) if (thread_scheduler)
my_safe_printf_stderr("max_threads=%u\n", my_safe_printf_stderr("max_threads=%lu\n",
(uint) thread_scheduler->max_threads + thread_scheduler->max_threads +
(uint) extra_max_connections); extra_max_connections);
my_safe_printf_stderr("thread_count=%u\n", THD_count::value()); my_safe_printf_stderr("thread_count=%u\n", THD_count::value());
@ -195,11 +195,10 @@ extern "C" sig_handler handle_fatal_signal(int sig)
my_safe_printf_stderr("It is possible that mysqld could use up to \n" my_safe_printf_stderr("It is possible that mysqld could use up to \n"
"key_buffer_size + " "key_buffer_size + "
"(read_buffer_size + sort_buffer_size)*max_threads = " "(read_buffer_size + sort_buffer_size)*max_threads = "
"%lu K bytes of memory\n", "%zu K bytes of memory\n",
(ulong)
(dflt_key_cache->key_cache_mem_size + (dflt_key_cache->key_cache_mem_size +
(global_system_variables.read_buff_size + (global_system_variables.read_buff_size +
global_system_variables.sortbuff_size) * (size_t)global_system_variables.sortbuff_size) *
(thread_scheduler->max_threads + extra_max_connections) + (thread_scheduler->max_threads + extra_max_connections) +
(max_connections + extra_max_connections) * (max_connections + extra_max_connections) *
sizeof(THD)) / 1024); sizeof(THD)) / 1024);

50
sql/sql_admin.cc
View File

@ -33,6 +33,7 @@
#include "sql_statistics.h" #include "sql_statistics.h"
#include "wsrep_mysqld.h" #include "wsrep_mysqld.h"
const LEX_CSTRING msg_status= {STRING_WITH_LEN("status")};
const LEX_CSTRING msg_repair= { STRING_WITH_LEN("repair") }; const LEX_CSTRING msg_repair= { STRING_WITH_LEN("repair") };
const LEX_CSTRING msg_assign_to_keycache= const LEX_CSTRING msg_assign_to_keycache=
{ STRING_WITH_LEN("assign_to_keycache") }; { STRING_WITH_LEN("assign_to_keycache") };
@ -490,6 +491,20 @@ static bool wsrep_toi_replication(THD *thd, TABLE_LIST *tables)
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */
static void send_read_only_warning(THD *thd, const LEX_CSTRING *msg_status,
const LEX_CSTRING *table_name)
{
Protocol *protocol= thd->protocol;
char buf[MYSQL_ERRMSG_SIZE];
size_t length;
length= my_snprintf(buf, sizeof(buf),
ER_THD(thd, ER_OPEN_AS_READONLY),
table_name->str);
protocol->store(msg_status, system_charset_info);
protocol->store(buf, length, system_charset_info);
}
/** /**
Collect field names of result set that will be sent to a client Collect field names of result set that will be sent to a client
@ -774,20 +789,16 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
goto send_result; goto send_result;
} }
if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify) if ((table->table->db_stat & HA_READ_ONLY) && open_for_modify &&
operator_func != &handler::ha_analyze)
{ {
/* purecov: begin inspected */ /* purecov: begin inspected */
char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
size_t length;
enum_sql_command save_sql_command= lex->sql_command; enum_sql_command save_sql_command= lex->sql_command;
DBUG_PRINT("admin", ("sending error message")); DBUG_PRINT("admin", ("sending error message"));
protocol->prepare_for_resend(); protocol->prepare_for_resend();
protocol->store(&table_name, system_charset_info); protocol->store(&table_name, system_charset_info);
protocol->store(operator_name, system_charset_info); protocol->store(operator_name, system_charset_info);
protocol->store(&error_clex_str, system_charset_info); send_read_only_warning(thd, &error_clex_str, &table_name);
length= my_snprintf(buff, sizeof(buff), ER_THD(thd, ER_OPEN_AS_READONLY),
table_name.str);
protocol->store(buff, length, system_charset_info);
trans_commit_stmt(thd); trans_commit_stmt(thd);
trans_commit(thd); trans_commit(thd);
close_thread_tables(thd); close_thread_tables(thd);
@ -923,6 +934,15 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
if (compl_result_code == HA_ADMIN_OK && collect_eis) if (compl_result_code == HA_ADMIN_OK && collect_eis)
{ {
if (result_code == HA_ERR_TABLE_READONLY)
{
protocol->prepare_for_resend();
protocol->store(&table_name, system_charset_info);
protocol->store(operator_name, system_charset_info);
send_read_only_warning(thd, &msg_status, &table_name);
(void) protocol->write();
result_code= HA_ADMIN_OK;
}
/* /*
Here we close and reopen table in read mode because operation of Here we close and reopen table in read mode because operation of
collecting statistics is long and it will be better do not block collecting statistics is long and it will be better do not block
@ -1032,7 +1052,7 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
protocol->prepare_for_resend(); protocol->prepare_for_resend();
protocol->store(&table_name, system_charset_info); protocol->store(&table_name, system_charset_info);
protocol->store(operator_name, system_charset_info); protocol->store(operator_name, system_charset_info);
protocol->store(STRING_WITH_LEN("status"), system_charset_info); protocol->store(&msg_status, system_charset_info);
protocol->store(STRING_WITH_LEN("Engine-independent statistics collected"), protocol->store(STRING_WITH_LEN("Engine-independent statistics collected"),
system_charset_info); system_charset_info);
if (protocol->write()) if (protocol->write())
@ -1102,25 +1122,25 @@ send_result_message:
break; break;
case HA_ADMIN_OK: case HA_ADMIN_OK:
protocol->store(STRING_WITH_LEN("status"), system_charset_info); protocol->store(&msg_status, system_charset_info);
protocol->store(STRING_WITH_LEN("OK"), system_charset_info); protocol->store(STRING_WITH_LEN("OK"), system_charset_info);
break; break;
case HA_ADMIN_FAILED: case HA_ADMIN_FAILED:
protocol->store(STRING_WITH_LEN("status"), system_charset_info); protocol->store(&msg_status, system_charset_info);
protocol->store(STRING_WITH_LEN("Operation failed"), protocol->store(STRING_WITH_LEN("Operation failed"),
system_charset_info); system_charset_info);
break; break;
case HA_ADMIN_REJECT: case HA_ADMIN_REJECT:
protocol->store(STRING_WITH_LEN("status"), system_charset_info); protocol->store(&msg_status, system_charset_info);
protocol->store(STRING_WITH_LEN("Operation need committed state"), protocol->store(STRING_WITH_LEN("Operation need committed state"),
system_charset_info); system_charset_info);
open_for_modify= FALSE; open_for_modify= FALSE;
break; break;
case HA_ADMIN_ALREADY_DONE: case HA_ADMIN_ALREADY_DONE:
protocol->store(STRING_WITH_LEN("status"), system_charset_info); protocol->store(&msg_status, system_charset_info);
protocol->store(STRING_WITH_LEN("Table is already up to date"), protocol->store(STRING_WITH_LEN("Table is already up to date"),
system_charset_info); system_charset_info);
break; break;
@ -1265,7 +1285,11 @@ send_result_message:
fatal_error=1; fatal_error=1;
break; break;
} }
case HA_ERR_TABLE_READONLY:
{
send_read_only_warning(thd, &msg_status, &table_name);
break;
}
default: // Probably HA_ADMIN_INTERNAL_ERROR default: // Probably HA_ADMIN_INTERNAL_ERROR
{ {
char buf[MYSQL_ERRMSG_SIZE]; char buf[MYSQL_ERRMSG_SIZE];

9
sql/sql_class.cc
View File

@ -4901,11 +4901,13 @@ void destroy_thd(MYSQL_THD thd)
extern "C" pthread_key(struct st_my_thread_var *, THR_KEY_mysys); extern "C" pthread_key(struct st_my_thread_var *, THR_KEY_mysys);
MYSQL_THD create_background_thd() MYSQL_THD create_background_thd()
{ {
DBUG_ASSERT(!current_thd); auto save_thd = current_thd;
set_current_thd(nullptr);
auto save_mysysvar= pthread_getspecific(THR_KEY_mysys); auto save_mysysvar= pthread_getspecific(THR_KEY_mysys);
/* /*
Allocate new mysys_var specifically this THD, Allocate new mysys_var specifically new THD,
so that e.g safemalloc, DBUG etc are happy. so that e.g safemalloc, DBUG etc are happy.
*/ */
pthread_setspecific(THR_KEY_mysys, 0); pthread_setspecific(THR_KEY_mysys, 0);
@ -4913,7 +4915,8 @@ MYSQL_THD create_background_thd()
auto thd_mysysvar= pthread_getspecific(THR_KEY_mysys); auto thd_mysysvar= pthread_getspecific(THR_KEY_mysys);
auto thd= new THD(0); auto thd= new THD(0);
pthread_setspecific(THR_KEY_mysys, save_mysysvar); pthread_setspecific(THR_KEY_mysys, save_mysysvar);
thd->set_psi(PSI_CALL_get_thread()); thd->set_psi(nullptr);
set_current_thd(save_thd);
/* /*
Workaround the adverse effect of incrementing thread_count Workaround the adverse effect of incrementing thread_count

4
storage/innobase/btr/btr0cur.cc
View File

@ -3344,11 +3344,11 @@ static void btr_cur_prefetch_siblings(const buf_block_t *block,
if (prev == FIL_NULL); if (prev == FIL_NULL);
else if (space->acquire()) else if (space->acquire())
buf_read_page_background(space, page_id_t(space->id, prev), buf_read_page_background(space, page_id_t(space->id, prev),
block->zip_size(), false); block->zip_size());
if (next == FIL_NULL); if (next == FIL_NULL);
else if (space->acquire()) else if (space->acquire())
buf_read_page_background(space, page_id_t(space->id, next), buf_read_page_background(space, page_id_t(space->id, next),
block->zip_size(), false); block->zip_size());
} }
/*************************************************************//** /*************************************************************//**

2
storage/innobase/buf/buf0dump.cc
View File

@ -684,7 +684,7 @@ buf_load()
} }
space->reacquire(); space->reacquire();
buf_read_page_background(space, dump[i], zip_size, true); buf_read_page_background(space, dump[i], zip_size);
if (buf_load_abort_flag) { if (buf_load_abort_flag) {
if (space) { if (space) {

7
storage/innobase/buf/buf0rea.cc
View File

@ -495,14 +495,13 @@ an exclusive lock on the buffer frame. The flag is cleared and the x-lock
released by the i/o-handler thread. released by the i/o-handler thread.
@param[in,out] space tablespace @param[in,out] space tablespace
@param[in] page_id page id @param[in] page_id page id
@param[in] zip_size ROW_FORMAT=COMPRESSED page size, or 0 @param[in] zip_size ROW_FORMAT=COMPRESSED page size, or 0 */
@param[in] sync true if synchronous aio is desired */
void buf_read_page_background(fil_space_t *space, const page_id_t page_id, void buf_read_page_background(fil_space_t *space, const page_id_t page_id,
ulint zip_size, bool sync) ulint zip_size)
{ {
dberr_t err; dberr_t err;
if (buf_read_page_low(&err, space, sync, BUF_READ_ANY_PAGE, if (buf_read_page_low(&err, space, false, BUF_READ_ANY_PAGE,
page_id, zip_size, false)) { page_id, zip_size, false)) {
srv_stats.buf_pool_reads.add(1); srv_stats.buf_pool_reads.add(1);
} }

7
storage/innobase/include/buf0rea.h
View File

@ -1,7 +1,7 @@
/***************************************************************************** /*****************************************************************************
Copyright (c) 1995, 2015, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 1995, 2015, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2015, 2020, MariaDB Corporation. Copyright (c) 2015, 2021, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it under 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 the terms of the GNU General Public License as published by the Free Software
@ -48,10 +48,9 @@ an exclusive lock on the buffer frame. The flag is cleared and the x-lock
released by the i/o-handler thread. released by the i/o-handler thread.
@param[in,out] space tablespace @param[in,out] space tablespace
@param[in] page_id page id @param[in] page_id page id
@param[in] zip_size ROW_FORMAT=COMPRESSED page size, or 0 @param[in] zip_size ROW_FORMAT=COMPRESSED page size, or 0 */
@param[in] sync true if synchronous aio is desired */
void buf_read_page_background(fil_space_t *space, const page_id_t page_id, void buf_read_page_background(fil_space_t *space, const page_id_t page_id,
ulint zip_size, bool sync) ulint zip_size)
MY_ATTRIBUTE((nonnull)); MY_ATTRIBUTE((nonnull));
/** Applies a random read-ahead in buf_pool if there are at least a threshold /** Applies a random read-ahead in buf_pool if there are at least a threshold

30
storage/maria/aria_s3_copy.cc
View File

@ -40,8 +40,10 @@ static const char *opt_s3_host_name= DEFAULT_AWS_HOST_NAME;
static const char *opt_database; static const char *opt_database;
static const char *opt_s3_bucket="MariaDB"; static const char *opt_s3_bucket="MariaDB";
static my_bool opt_compression, opt_verbose, opt_force, opt_s3_debug; static my_bool opt_compression, opt_verbose, opt_force, opt_s3_debug;
static my_bool opt_s3_use_http;
static ulong opt_operation= OP_IMPOSSIBLE, opt_protocol_version= 1; static ulong opt_operation= OP_IMPOSSIBLE, opt_protocol_version= 1;
static ulong opt_block_size; static ulong opt_block_size;
static ulong opt_s3_port;
static char **default_argv=0; static char **default_argv=0;
static ms3_st *global_s3_client= 0; static ms3_st *global_s3_client= 0;
@ -65,6 +67,12 @@ static struct my_option my_long_options[] =
{"s3_host_name", 'h', "Host name to S3 provider", {"s3_host_name", 'h', "Host name to S3 provider",
(char**) &opt_s3_host_name, (char**) &opt_s3_host_name, 0, (char**) &opt_s3_host_name, (char**) &opt_s3_host_name, 0,
GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"s3_port", 'p', "Port number to connect to (0 means use default)",
(char**) &opt_s3_port, (char**) &opt_s3_port, 0, GET_ULONG, REQUIRED_ARG,
0, 0, 65536, 0, 1, 0 },
{"s3_use_http", 'P', "If true, force use of HTTP protocol",
(char**) &opt_s3_use_http, (char**) &opt_s3_use_http,
0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
{"compress", 'c', "Use compression", &opt_compression, &opt_compression, {"compress", 'c', "Use compression", &opt_compression, &opt_compression,
0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0}, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
{"op", 'o', "Operation to execute. One of 'from_s3', 'to_s3' or " {"op", 'o', "Operation to execute. One of 'from_s3', 'to_s3' or "
@ -196,6 +204,7 @@ int main(int argc, char** argv)
{ {
MY_INIT(argv[0]); MY_INIT(argv[0]);
get_options(&argc,(char***) &argv); get_options(&argc,(char***) &argv);
size_t block_size= opt_block_size;
s3_init_library(); s3_init_library();
if (!(global_s3_client= ms3_init(opt_s3_access_key, if (!(global_s3_client= ms3_init(opt_s3_access_key,
@ -207,15 +216,22 @@ int main(int argc, char** argv)
my_exit(1); my_exit(1);
} }
{ ms3_set_option(global_s3_client, MS3_OPT_BUFFER_CHUNK_SIZE, &block_size);
size_t block_size= opt_block_size;
uint8_t protocol_version= (uint8_t) opt_protocol_version;
ms3_set_option(global_s3_client, MS3_OPT_BUFFER_CHUNK_SIZE, &block_size);
if (protocol_version) if (opt_protocol_version)
ms3_set_option(global_s3_client, MS3_OPT_FORCE_PROTOCOL_VERSION, {
&protocol_version); uint8_t protocol_version= (uint8_t) opt_protocol_version;
ms3_set_option(global_s3_client, MS3_OPT_FORCE_PROTOCOL_VERSION,
&protocol_version);
} }
if (opt_s3_port)
{
int port= (int) opt_s3_port;
ms3_set_option(global_s3_client, MS3_OPT_PORT_NUMBER, &port);
}
if (opt_s3_use_http)
ms3_set_option(global_s3_client, MS3_OPT_USE_HTTP, NULL);
for (; *argv ; argv++) for (; *argv ; argv++)
{ {

15
storage/maria/ha_maria.cc
View File

@ -1278,6 +1278,7 @@ int ha_maria::check(THD * thd, HA_CHECK_OPT * check_opt)
if (!file || !param) return HA_ADMIN_INTERNAL_ERROR; if (!file || !param) return HA_ADMIN_INTERNAL_ERROR;
unmap_file(file); unmap_file(file);
register_handler(file);
maria_chk_init(param); maria_chk_init(param);
param->thd= thd; param->thd= thd;
param->op_name= "check"; param->op_name= "check";
@ -1333,14 +1334,18 @@ int ha_maria::check(THD * thd, HA_CHECK_OPT * check_opt)
{ {
ulonglong old_testflag= param->testflag; ulonglong old_testflag= param->testflag;
param->testflag |= T_MEDIUM; param->testflag |= T_MEDIUM;
if (!(error= init_io_cache(&param->read_cache, file->dfile.file,
my_default_record_cache_size, READ_CACHE, /* BLOCK_RECORD does not need a cache as it is using the page cache */
share->pack.header_length, 1, MYF(MY_WME)))) if (file->s->data_file_type != BLOCK_RECORD)
{ error= init_io_cache(&param->read_cache, file->dfile.file,
my_default_record_cache_size, READ_CACHE,
share->pack.header_length, 1, MYF(MY_WME));
if (!error)
error= maria_chk_data_link(param, file, error= maria_chk_data_link(param, file,
MY_TEST(param->testflag & T_EXTEND)); MY_TEST(param->testflag & T_EXTEND));
if (file->s->data_file_type != BLOCK_RECORD)
end_io_cache(&param->read_cache); end_io_cache(&param->read_cache);
}
param->testflag= old_testflag; param->testflag= old_testflag;
} }
} }

5
storage/maria/ha_s3.h
View File

@ -44,11 +44,6 @@ public:
DBUG_ENTER("delete_row"); DBUG_ENTER("delete_row");
DBUG_RETURN(HA_ERR_TABLE_READONLY); DBUG_RETURN(HA_ERR_TABLE_READONLY);
} }
int check(THD *, HA_CHECK_OPT *) override
{
DBUG_ENTER("delete_row");
DBUG_RETURN(HA_ERR_TABLE_READONLY);
}
int analyze(THD *, HA_CHECK_OPT *) override int analyze(THD *, HA_CHECK_OPT *) override
{ {
DBUG_ENTER("analyze"); DBUG_ENTER("analyze");

6
storage/maria/ma_check.c
View File

@ -414,6 +414,12 @@ int maria_chk_size(HA_CHECK *param, register MARIA_HA *info)
char buff[22],buff2[22]; char buff[22],buff2[22];
DBUG_ENTER("maria_chk_size"); DBUG_ENTER("maria_chk_size");
if (info->s3)
{
/* We cannot check file sizes for S3 */
DBUG_RETURN(0);
}
if (!(param->testflag & T_SILENT)) if (!(param->testflag & T_SILENT))
puts("- check file-size"); puts("- check file-size");

8
storage/maria/ma_pagecache.c
View File

@ -2772,7 +2772,7 @@ retry:
#ifdef WITH_S3_STORAGE_ENGINE #ifdef WITH_S3_STORAGE_ENGINE
static void read_big_block(PAGECACHE *pagecache, static void read_big_block(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block) PAGECACHE_BLOCK_LINK *block)
{ {
int page_st; int page_st;
size_t big_block_size_in_pages; size_t big_block_size_in_pages;
@ -2810,6 +2810,11 @@ static void read_big_block(PAGECACHE *pagecache,
if (block_to_read->status & PCBLOCK_ERROR) if (block_to_read->status & PCBLOCK_ERROR)
{ {
/* We get first block with an error so all operation failed */ /* We get first block with an error so all operation failed */
DBUG_PRINT("error", ("Got error when reading first page"));
block->status|= PCBLOCK_ERROR;
block->error= block_to_read->error;
remove_reader(block_to_read);
unreg_request(pagecache, block_to_read, 1);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
if (block_to_read->status & PCBLOCK_BIG_READ) if (block_to_read->status & PCBLOCK_BIG_READ)
@ -3952,7 +3957,6 @@ void pagecache_set_write_on_delete_by_link(PAGECACHE_BLOCK_LINK *block)
@retval 0 deleted or was not present at all @retval 0 deleted or was not present at all
@retval 1 error @retval 1 error
*/ */
static my_bool pagecache_delete_internal(PAGECACHE *pagecache, static my_bool pagecache_delete_internal(PAGECACHE *pagecache,

4
storage/maria/s3_func.c
View File

@ -583,8 +583,8 @@ int aria_copy_from_s3(ms3_st *s3_client, const char *aws_bucket,
if (s3_get_object(s3_client, aws_bucket, aws_path, &block, 0, 0)) if (s3_get_object(s3_client, aws_bucket, aws_path, &block, 0, 0))
{ {
my_printf_error(EE_FILENOTFOUND, "Table %s doesn't exist in s3", MYF(0), my_printf_error(EE_FILENOTFOUND, "File %s/%s doesn't exist in s3", MYF(0),
filename); database,filename);
goto err; goto err;
} }
if (block.length < MARIA_STATE_INFO_SIZE) if (block.length < MARIA_STATE_INFO_SIZE)

18
storage/spider/mysql-test/spider/bugfix/r/mdev_25684.result Normal file
View File

@ -0,0 +1,18 @@
for master_1
for child2
child2_1
child2_2
child2_3
for child3
MDEV-25684 Crash in THD::find_temporary_table while calling spider_direct_sql UDF without temporary table created
connection master_1;
SELECT SPIDER_DIRECT_SQL('SELECT * FROM s', 'non_existing_temporary_table', 'srv "s_2_1"');
ERROR HY000: Temporary table 'test.non_existing_temporary_table' is not found
for master_1
for child2
child2_1
child2_2
child2_3
for child3

3
storage/spider/mysql-test/spider/bugfix/t/mdev_25684.cnf Normal file
View File

@ -0,0 +1,3 @@
!include include/default_mysqld.cnf
!include ../my_1_1.cnf
!include ../my_2_1.cnf

19
storage/spider/mysql-test/spider/bugfix/t/mdev_25684.test Normal file
View File

@ -0,0 +1,19 @@
--disable_query_log
--disable_result_log
--source ../../t/test_init.inc
--enable_result_log
--enable_query_log
--echo
--echo MDEV-25684 Crash in THD::find_temporary_table while calling spider_direct_sql UDF without temporary table created
--echo
--connection master_1
--error 12703
SELECT SPIDER_DIRECT_SQL('SELECT * FROM s', 'non_existing_temporary_table', 'srv "s_2_1"');
--disable_query_log
--disable_result_log
--source ../../t/test_deinit.inc
--enable_result_log
--enable_query_log

4
storage/spider/spd_sys_table.cc
View File

@ -3934,6 +3934,10 @@ TABLE *spider_find_temporary_table(
) { ) {
DBUG_ENTER("spider_find_temporary_table"); DBUG_ENTER("spider_find_temporary_table");
#ifdef SPIDER_open_temporary_table #ifdef SPIDER_open_temporary_table
if (!thd->has_temporary_tables())
{
DBUG_RETURN(NULL);
}
if (thd->open_temporary_table(table_list)) if (thd->open_temporary_table(table_list))
{ {
DBUG_RETURN(NULL); DBUG_RETURN(NULL);