mirror of
https://github.com/MariaDB/server.git
synced 2025-06-03 07:02:23 +03:00
Merge 10.2 into 10.3
This commit is contained in:
commit
7396dfcca7
@ -3130,7 +3130,7 @@ static int
|
||||
com_help(String *buffer __attribute__((unused)),
|
||||
char *line __attribute__((unused)))
|
||||
{
|
||||
reg1 int i, j;
|
||||
int i, j;
|
||||
char * help_arg= strchr(line,' '), buff[32], *end;
|
||||
if (help_arg)
|
||||
{
|
||||
|
@ -1462,7 +1462,7 @@ void close_statements()
|
||||
for (con= connections; con < next_con; con++)
|
||||
{
|
||||
if (con->stmt)
|
||||
mysql_stmt_close(con->stmt);
|
||||
do_stmt_close(con);
|
||||
con->stmt= 0;
|
||||
}
|
||||
DBUG_VOID_RETURN;
|
||||
|
@ -3050,7 +3050,7 @@ static dberr_t xb_assign_undo_space_start()
|
||||
name[dirnamelen++] = OS_PATH_SEPARATOR;
|
||||
}
|
||||
|
||||
snprintf(name + dirnamelen, strlen(name) + strlen("ibdata1"),
|
||||
snprintf(name + dirnamelen, (sizeof name) - dirnamelen,
|
||||
"%s", "ibdata1");
|
||||
|
||||
file = os_file_create(0, name, OS_FILE_OPEN,
|
||||
|
@ -217,7 +217,7 @@ extern int heap_write(HP_INFO *info,const uchar *buff);
|
||||
extern int heap_update(HP_INFO *info,const uchar *old,const uchar *newdata);
|
||||
extern int heap_rrnd(HP_INFO *info,uchar *buf,uchar *pos);
|
||||
extern int heap_scan_init(HP_INFO *info);
|
||||
extern int heap_scan(register HP_INFO *info, uchar *record);
|
||||
extern int heap_scan(HP_INFO *info, uchar *record);
|
||||
extern int heap_delete(HP_INFO *info,const uchar *buff);
|
||||
extern int heap_info(HP_INFO *info,HEAPINFO *x,int flag);
|
||||
extern int heap_create(const char *name,
|
||||
|
@ -366,7 +366,7 @@ int maria_sort_index(HA_CHECK *param, MARIA_HA *info, char * name);
|
||||
int maria_zerofill(HA_CHECK *param, MARIA_HA *info, const char *name);
|
||||
int maria_repair_by_sort(HA_CHECK *param, MARIA_HA *info,
|
||||
const char *name, my_bool rep_quick);
|
||||
int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
|
||||
int maria_repair_parallel(HA_CHECK *param, MARIA_HA *info,
|
||||
const char *name, my_bool rep_quick);
|
||||
int maria_change_to_newfile(const char *filename, const char *old_ext,
|
||||
const char *new_ext, time_t backup_time,
|
||||
|
@ -373,7 +373,7 @@ typedef struct st_mi_sort_param
|
||||
int (*key_read)(struct st_mi_sort_param *,void *);
|
||||
int (*key_write)(struct st_mi_sort_param *, const void *);
|
||||
void (*lock_in_memory)(HA_CHECK *);
|
||||
int (*write_keys)(struct st_mi_sort_param *, register uchar **,
|
||||
int (*write_keys)(struct st_mi_sort_param *, uchar **,
|
||||
ulonglong , struct st_buffpek *, IO_CACHE *);
|
||||
my_off_t (*read_to_buffer)(IO_CACHE *,struct st_buffpek *, uint);
|
||||
int (*write_key)(struct st_mi_sort_param *, IO_CACHE *,uchar *,
|
||||
@ -383,16 +383,15 @@ typedef struct st_mi_sort_param
|
||||
/* functions in mi_check */
|
||||
void myisamchk_init(HA_CHECK *param);
|
||||
int chk_status(HA_CHECK *param, MI_INFO *info);
|
||||
int chk_del(HA_CHECK *param, register MI_INFO *info, ulonglong test_flag);
|
||||
int chk_del(HA_CHECK *param, MI_INFO *info, ulonglong test_flag);
|
||||
int chk_size(HA_CHECK *param, MI_INFO *info);
|
||||
int chk_key(HA_CHECK *param, MI_INFO *info);
|
||||
int chk_data_link(HA_CHECK *param, MI_INFO *info, my_bool extend);
|
||||
int mi_repair(HA_CHECK *param, register MI_INFO *info,
|
||||
char * name, int rep_quick);
|
||||
int mi_sort_index(HA_CHECK *param, register MI_INFO *info, char * name);
|
||||
int mi_repair_by_sort(HA_CHECK *param, register MI_INFO *info,
|
||||
int mi_repair(HA_CHECK *param, MI_INFO *info, char * name, int rep_quick);
|
||||
int mi_sort_index(HA_CHECK *param, MI_INFO *info, char * name);
|
||||
int mi_repair_by_sort(HA_CHECK *param, MI_INFO *info,
|
||||
const char * name, int rep_quick);
|
||||
int mi_repair_parallel(HA_CHECK *param, register MI_INFO *info,
|
||||
int mi_repair_parallel(HA_CHECK *param, MI_INFO *info,
|
||||
const char * name, int rep_quick);
|
||||
int change_to_newfile(const char * filename, const char * old_ext,
|
||||
const char * new_ext, time_t backup_time, myf myflags);
|
||||
|
@ -1,2 +1,32 @@
|
||||
let $wait_condition = SELECT 1 FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'wsrep_ready' AND VARIABLE_VALUE = 'ON';
|
||||
--source include/wait_condition.inc
|
||||
# include/galera_wait_ready.inc
|
||||
#
|
||||
# Waits for galera node to transition to READY state.
|
||||
#
|
||||
|
||||
--enable_reconnect
|
||||
--disable_query_log
|
||||
--disable_result_log
|
||||
let $wait_counter = 600;
|
||||
while ($wait_counter)
|
||||
{
|
||||
--disable_abort_on_error
|
||||
let $success = `SELECT VARIABLE_VALUE = 'ON' FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'wsrep_ready'`;
|
||||
--enable_abort_on_error
|
||||
if ($success)
|
||||
{
|
||||
let $wait_counter = 0;
|
||||
}
|
||||
if (!$success)
|
||||
{
|
||||
real_sleep 0.1;
|
||||
dec $wait_counter;
|
||||
}
|
||||
}
|
||||
|
||||
if (!$success)
|
||||
{
|
||||
die "Server did not transition to READY state";
|
||||
}
|
||||
--disable_reconnect
|
||||
--enable_query_log
|
||||
--enable_result_log
|
||||
|
@ -4596,6 +4596,37 @@ c1 mediumtext YES NULL
|
||||
DROP TABLE t1;
|
||||
set sql_mode=default;
|
||||
#
|
||||
# MDEV-15624 Changing the default character set to utf8mb4 changes query evaluation in a very surprising way
|
||||
#
|
||||
SET NAMES utf8;
|
||||
CREATE TABLE t1 (id INT);
|
||||
INSERT INTO t1 VALUES (1),(2),(3);
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, REPLACE(uuid_short(), '0', CAST('o' AS CHAR CHARACTER SET ucs2)) AS c FROM t1) AS d1;
|
||||
COUNT(DISTINCT c)
|
||||
3
|
||||
SELECT DISTINCT REPLACE(uuid_short(), '0', CAST('o' AS CHAR CHARACTER SET ucs2)) AS c FROM t1;
|
||||
c
|
||||
xxxxxxxxxxxxxxxxx
|
||||
xxxxxxxxxxxxxxxxx
|
||||
xxxxxxxxxxxxxxxxx
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, INSERT(uuid_short(), 1, 1, CAST('0' AS CHAR CHARACTER SET ucs2)) AS c FROM t1) AS d1;
|
||||
COUNT(DISTINCT c)
|
||||
3
|
||||
SELECT DISTINCT INSERT(uuid_short(), 1, 1, CAST('0' AS CHAR CHARACTER SET ucs2)) AS c FROM t1;
|
||||
c
|
||||
xxxxxxxxxxxxxxxxx
|
||||
xxxxxxxxxxxxxxxxx
|
||||
xxxxxxxxxxxxxxxxx
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, CONCAT(uuid_short(), CAST('0' AS CHAR CHARACTER SET ucs2)) AS c FROM t1) AS d1;
|
||||
COUNT(DISTINCT c)
|
||||
3
|
||||
SELECT DISTINCT CONCAT(uuid_short(), CAST('0' AS CHAR CHARACTER SET ucs2)) AS c FROM t1;
|
||||
c
|
||||
xxxxxxxxxxxxxxxxx
|
||||
xxxxxxxxxxxxxxxxx
|
||||
xxxxxxxxxxxxxxxxx
|
||||
DROP TABLE t1;
|
||||
#
|
||||
# End of 5.5 tests
|
||||
#
|
||||
#
|
||||
|
@ -851,6 +851,28 @@ DROP TABLE t1;
|
||||
set sql_mode=default;
|
||||
|
||||
|
||||
--echo #
|
||||
--echo # MDEV-15624 Changing the default character set to utf8mb4 changes query evaluation in a very surprising way
|
||||
--echo #
|
||||
|
||||
SET NAMES utf8;
|
||||
CREATE TABLE t1 (id INT);
|
||||
INSERT INTO t1 VALUES (1),(2),(3);
|
||||
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, REPLACE(uuid_short(), '0', CAST('o' AS CHAR CHARACTER SET ucs2)) AS c FROM t1) AS d1;
|
||||
--replace_column 1 xxxxxxxxxxxxxxxxx
|
||||
SELECT DISTINCT REPLACE(uuid_short(), '0', CAST('o' AS CHAR CHARACTER SET ucs2)) AS c FROM t1;
|
||||
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, INSERT(uuid_short(), 1, 1, CAST('0' AS CHAR CHARACTER SET ucs2)) AS c FROM t1) AS d1;
|
||||
--replace_column 1 xxxxxxxxxxxxxxxxx
|
||||
SELECT DISTINCT INSERT(uuid_short(), 1, 1, CAST('0' AS CHAR CHARACTER SET ucs2)) AS c FROM t1;
|
||||
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, CONCAT(uuid_short(), CAST('0' AS CHAR CHARACTER SET ucs2)) AS c FROM t1) AS d1;
|
||||
--replace_column 1 xxxxxxxxxxxxxxxxx
|
||||
SELECT DISTINCT CONCAT(uuid_short(), CAST('0' AS CHAR CHARACTER SET ucs2)) AS c FROM t1;
|
||||
DROP TABLE t1;
|
||||
|
||||
|
||||
--echo #
|
||||
--echo # End of 5.5 tests
|
||||
--echo #
|
||||
|
@ -2868,6 +2868,29 @@ SELECT LENGTH(data) AS len FROM (SELECT REPEAT('☃', 65536) AS data ) AS sub;
|
||||
len
|
||||
196608
|
||||
#
|
||||
# MDEV-15624 Changing the default character set to utf8mb4 changes query evaluation in a very surprising way
|
||||
#
|
||||
SET NAMES utf8mb4;
|
||||
CREATE TABLE t1 (id INT);
|
||||
INSERT INTO t1 VALUES (1),(2),(3);
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, REPLACE(UUID(), "-", "") AS c FROM t1) AS d1;
|
||||
COUNT(DISTINCT c)
|
||||
3
|
||||
SELECT DISTINCT INSERT(uuid(), 9, 1, "X") AS c FROM t1;
|
||||
c
|
||||
xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx
|
||||
xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx
|
||||
xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, INSERT(UUID(), 9, 1, "X") AS c FROM t1) AS d1;
|
||||
COUNT(DISTINCT c)
|
||||
3
|
||||
SELECT DISTINCT INSERT(UUID(), 9, 1, "X") AS c FROM t1;
|
||||
c
|
||||
xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx
|
||||
xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx
|
||||
xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx
|
||||
DROP TABLE t1;
|
||||
#
|
||||
# End of 5.5 tests
|
||||
#
|
||||
#
|
||||
|
@ -1850,6 +1850,25 @@ SELECT LENGTH(data) AS len FROM (SELECT REPEAT('☃', 21846) AS data ) AS sub;
|
||||
SELECT LENGTH(data) AS len FROM (SELECT REPEAT('☃', 65535) AS data ) AS sub;
|
||||
SELECT LENGTH(data) AS len FROM (SELECT REPEAT('☃', 65536) AS data ) AS sub;
|
||||
|
||||
--echo #
|
||||
--echo # MDEV-15624 Changing the default character set to utf8mb4 changes query evaluation in a very surprising way
|
||||
--echo #
|
||||
|
||||
SET NAMES utf8mb4;
|
||||
CREATE TABLE t1 (id INT);
|
||||
INSERT INTO t1 VALUES (1),(2),(3);
|
||||
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, REPLACE(UUID(), "-", "") AS c FROM t1) AS d1;
|
||||
--replace_column 1 xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx
|
||||
SELECT DISTINCT INSERT(uuid(), 9, 1, "X") AS c FROM t1;
|
||||
|
||||
SELECT COUNT(DISTINCT c) FROM (SELECT id, INSERT(UUID(), 9, 1, "X") AS c FROM t1) AS d1;
|
||||
--replace_column 1 xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx
|
||||
SELECT DISTINCT INSERT(UUID(), 9, 1, "X") AS c FROM t1;
|
||||
|
||||
DROP TABLE t1;
|
||||
|
||||
|
||||
--echo #
|
||||
--echo # End of 5.5 tests
|
||||
--echo #
|
||||
|
@ -2,8 +2,10 @@ Windows bug: happens when a new line is exactly at the right offset.
|
||||
The following options may be given as the first argument:
|
||||
--print-defaults Print the program argument list and exit.
|
||||
--no-defaults Don't read default options from any option file.
|
||||
The following specify which files/extra groups are read (specified before remaining options):
|
||||
--defaults-file=# Only read default options from the given file #.
|
||||
--defaults-extra-file=# Read this file after the global files are read.
|
||||
--defaults-group-suffix=# Additionally read default groups with # appended as a suffix.
|
||||
|
||||
--allow-suspicious-udfs
|
||||
Allows use of UDFs consisting of only one symbol xxx()
|
||||
|
@ -237,6 +237,14 @@ a a
|
||||
5 10
|
||||
DROP TABLE temp1, temp2;
|
||||
|
||||
# MDEV-14185 CREATE TEMPORARY TABLE AS SELECT causes error 1290 with read_only and InnoDB.
|
||||
|
||||
CREATE TEMPORARY TABLE temp1 ENGINE=INNODB AS SELECT a FROM t1;
|
||||
SELECT * FROM temp1;
|
||||
a
|
||||
1
|
||||
DROP TABLE temp1;
|
||||
|
||||
# Disconnect and cleanup
|
||||
|
||||
disconnect con1;
|
||||
|
@ -240,6 +240,15 @@ UPDATE temp1,temp2 SET temp1.a = 5, temp2.a = 10;
|
||||
SELECT * FROM temp1, temp2;
|
||||
DROP TABLE temp1, temp2;
|
||||
|
||||
--echo
|
||||
--echo # MDEV-14185 CREATE TEMPORARY TABLE AS SELECT causes error 1290 with read_only and InnoDB.
|
||||
--echo
|
||||
|
||||
CREATE TEMPORARY TABLE temp1 ENGINE=INNODB AS SELECT a FROM t1;
|
||||
SELECT * FROM temp1;
|
||||
DROP TABLE temp1;
|
||||
|
||||
|
||||
--echo
|
||||
--echo # Disconnect and cleanup
|
||||
--echo
|
||||
|
@ -171,6 +171,13 @@ create database mysqltest1;
|
||||
create procedure mysqltest1.foo() select "foo";
|
||||
update mysql.proc set name='' where db='mysqltest1';
|
||||
drop database mysqltest1;
|
||||
create procedure p1() set @foo = 10;
|
||||
alter table mysql.proc drop primary key;
|
||||
drop procedure p1;
|
||||
ERROR HY000: Cannot load from mysql.proc. The table is probably corrupted
|
||||
alter table mysql.proc add primary key (db,name,type);
|
||||
drop procedure p1;
|
||||
# Start of 10.3 tests
|
||||
#
|
||||
# MDEV-15444 Querying I_S.PARAMETERS can crash with a corrupted mysql.proc
|
||||
#
|
||||
|
@ -286,6 +286,17 @@ create procedure mysqltest1.foo() select "foo";
|
||||
update mysql.proc set name='' where db='mysqltest1';
|
||||
drop database mysqltest1;
|
||||
|
||||
#
|
||||
# BUG#26881798: SERVER EXITS WHEN PRIMARY KEY IN MYSQL.PROC IS DROPPED
|
||||
#
|
||||
create procedure p1() set @foo = 10;
|
||||
alter table mysql.proc drop primary key;
|
||||
--error ER_CANNOT_LOAD_FROM_TABLE_V2
|
||||
drop procedure p1;
|
||||
alter table mysql.proc add primary key (db,name,type);
|
||||
drop procedure p1;
|
||||
|
||||
--echo # Start of 10.3 tests
|
||||
|
||||
--echo #
|
||||
--echo # MDEV-15444 Querying I_S.PARAMETERS can crash with a corrupted mysql.proc
|
||||
|
@ -2503,6 +2503,26 @@ SELECT 2 IN (SELECT 2 from DUAL WHERE 1 != 1);
|
||||
SET optimizer_switch= @@global.optimizer_switch;
|
||||
set @@tmp_table_size= @@global.tmp_table_size;
|
||||
#
|
||||
# MDEV-14515: Wrong results for tableless query with subquery in WHERE
|
||||
# and implicit aggregation
|
||||
#
|
||||
create table t1 (i1 int, i2 int);
|
||||
insert into t1 values (1314, 1084),(1330, 1084),(1401, 1084),(580, 1084);
|
||||
create table t2 (cd int);
|
||||
insert into t2 values
|
||||
(1330), (1330), (1330), (1330), (1330), (1330), (1330), (1330),
|
||||
(1330), (1330), (1330), (1330), (1330), (1330), (1330), (1330);
|
||||
select max(10) from dual
|
||||
where exists (select 1 from t2 join t1 on t1.i1 = t2.cd and t1.i2 = 345);
|
||||
max(10)
|
||||
NULL
|
||||
insert into t2 select * from t2;
|
||||
select max(10) from dual
|
||||
where exists (select 1 from t2 join t1 on t1.i1 = t2.cd and t1.i2 = 345);
|
||||
max(10)
|
||||
NULL
|
||||
DROP TABLE t1,t2;
|
||||
#
|
||||
# MDEV-10232 Scalar result of subquery changes after adding an outer select stmt
|
||||
#
|
||||
create table t1(c1 int, c2 int, primary key(c2));
|
||||
|
@ -2043,6 +2043,29 @@ SELECT 2 IN (SELECT 2 from DUAL WHERE 1 != 1);
|
||||
SET optimizer_switch= @@global.optimizer_switch;
|
||||
set @@tmp_table_size= @@global.tmp_table_size;
|
||||
|
||||
--echo #
|
||||
--echo # MDEV-14515: Wrong results for tableless query with subquery in WHERE
|
||||
--echo # and implicit aggregation
|
||||
--echo #
|
||||
|
||||
create table t1 (i1 int, i2 int);
|
||||
insert into t1 values (1314, 1084),(1330, 1084),(1401, 1084),(580, 1084);
|
||||
|
||||
create table t2 (cd int);
|
||||
insert into t2 values
|
||||
(1330), (1330), (1330), (1330), (1330), (1330), (1330), (1330),
|
||||
(1330), (1330), (1330), (1330), (1330), (1330), (1330), (1330);
|
||||
|
||||
select max(10) from dual
|
||||
where exists (select 1 from t2 join t1 on t1.i1 = t2.cd and t1.i2 = 345);
|
||||
|
||||
insert into t2 select * from t2;
|
||||
|
||||
select max(10) from dual
|
||||
where exists (select 1 from t2 join t1 on t1.i1 = t2.cd and t1.i2 = 345);
|
||||
|
||||
DROP TABLE t1,t2;
|
||||
|
||||
--echo #
|
||||
--echo # MDEV-10232 Scalar result of subquery changes after adding an outer select stmt
|
||||
--echo #
|
||||
|
@ -2,7 +2,7 @@
|
||||
# -*- cperl -*-
|
||||
|
||||
# Copyright (c) 2004, 2014, Oracle and/or its affiliates.
|
||||
# Copyright (c) 2009, 2017, MariaDB Corporation
|
||||
# Copyright (c) 2009, 2018, MariaDB Corporation
|
||||
#
|
||||
# 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
|
||||
|
@ -476,9 +476,9 @@ def test tb1 f19 19 NULL YES smallint NULL NULL 5 0 NULL NULL NULL smallint(5) u
|
||||
def test tb1 f2 2 NULL YES char 1 1 NULL NULL NULL latin1 latin1_bin char(1) NEVER NULL
|
||||
def test tb1 f20 20 NULL YES smallint NULL NULL 5 0 NULL NULL NULL smallint(5) unsigned zerofill NEVER NULL
|
||||
def test tb1 f21 21 NULL YES mediumint NULL NULL 7 0 NULL NULL NULL mediumint(9) NEVER NULL
|
||||
def test tb1 f22 22 NULL YES mediumint NULL NULL 7 0 NULL NULL NULL mediumint(8) unsigned NEVER NULL
|
||||
def test tb1 f23 23 NULL YES mediumint NULL NULL 7 0 NULL NULL NULL mediumint(8) unsigned zerofill NEVER NULL
|
||||
def test tb1 f24 24 NULL YES mediumint NULL NULL 7 0 NULL NULL NULL mediumint(8) unsigned zerofill NEVER NULL
|
||||
def test tb1 f22 22 NULL YES mediumint NULL NULL 8 0 NULL NULL NULL mediumint(8) unsigned NEVER NULL
|
||||
def test tb1 f23 23 NULL YES mediumint NULL NULL 8 0 NULL NULL NULL mediumint(8) unsigned zerofill NEVER NULL
|
||||
def test tb1 f24 24 NULL YES mediumint NULL NULL 8 0 NULL NULL NULL mediumint(8) unsigned zerofill NEVER NULL
|
||||
def test tb1 f25 25 NULL YES int NULL NULL 10 0 NULL NULL NULL int(11) NEVER NULL
|
||||
def test tb1 f26 26 NULL YES int NULL NULL 10 0 NULL NULL NULL int(10) unsigned NEVER NULL
|
||||
def test tb1 f27 27 NULL YES int NULL NULL 10 0 NULL NULL NULL int(10) unsigned zerofill NEVER NULL
|
||||
@ -600,9 +600,9 @@ def test tb3 f135 18 999 NO smallint NULL NULL 5 0 NULL NULL NULL smallint(5) un
|
||||
def test tb3 f136 19 00999 NO smallint NULL NULL 5 0 NULL NULL NULL smallint(5) unsigned zerofill NEVER NULL
|
||||
def test tb3 f137 20 00999 NO smallint NULL NULL 5 0 NULL NULL NULL smallint(5) unsigned zerofill NEVER NULL
|
||||
def test tb3 f138 21 9999 NO mediumint NULL NULL 7 0 NULL NULL NULL mediumint(9) NEVER NULL
|
||||
def test tb3 f139 22 9999 NO mediumint NULL NULL 7 0 NULL NULL NULL mediumint(8) unsigned NEVER NULL
|
||||
def test tb3 f140 23 00009999 NO mediumint NULL NULL 7 0 NULL NULL NULL mediumint(8) unsigned zerofill NEVER NULL
|
||||
def test tb3 f141 24 00009999 NO mediumint NULL NULL 7 0 NULL NULL NULL mediumint(8) unsigned zerofill NEVER NULL
|
||||
def test tb3 f139 22 9999 NO mediumint NULL NULL 8 0 NULL NULL NULL mediumint(8) unsigned NEVER NULL
|
||||
def test tb3 f140 23 00009999 NO mediumint NULL NULL 8 0 NULL NULL NULL mediumint(8) unsigned zerofill NEVER NULL
|
||||
def test tb3 f141 24 00009999 NO mediumint NULL NULL 8 0 NULL NULL NULL mediumint(8) unsigned zerofill NEVER NULL
|
||||
def test tb3 f142 25 99999 NO int NULL NULL 10 0 NULL NULL NULL int(11) NEVER NULL
|
||||
def test tb3 f143 26 99999 NO int NULL NULL 10 0 NULL NULL NULL int(10) unsigned NEVER NULL
|
||||
def test tb3 f144 27 0000099999 NO int NULL NULL 10 0 NULL NULL NULL int(10) unsigned zerofill NEVER NULL
|
||||
|
@ -5,6 +5,4 @@
|
||||
--eval SET GLOBAL wsrep_cluster_address = '$wsrep_cluster_address_orig';
|
||||
--enable_query_log
|
||||
|
||||
--enable_reconnect
|
||||
--source include/wait_until_connected_again.inc
|
||||
--source include/wait_until_ready.inc
|
||||
--source include/galera_wait_ready.inc
|
||||
|
@ -64,7 +64,9 @@ INSERT INTO t1 VALUES ('node1_to_be_rollbacked_after');
|
||||
--connection node_2
|
||||
--echo Starting server ...
|
||||
--source include/start_mysqld.inc
|
||||
--source include/wait_until_ready.inc
|
||||
|
||||
--let $wait_condition = SELECT VARIABLE_VALUE = 2 FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'wsrep_cluster_size'
|
||||
--source include/wait_condition.inc
|
||||
|
||||
SET AUTOCOMMIT=OFF;
|
||||
START TRANSACTION;
|
||||
|
@ -24,7 +24,6 @@ COMMIT;
|
||||
--source include/kill_galera.inc
|
||||
|
||||
--connection node_1
|
||||
--source include/wait_until_connected_again.inc
|
||||
--let $wait_condition = SELECT VARIABLE_VALUE = 1 FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'wsrep_cluster_size'
|
||||
--source include/wait_condition.inc
|
||||
|
||||
@ -59,7 +58,9 @@ INSERT INTO t1 VALUES ('node1_to_be_rollbacked_after');
|
||||
|
||||
--echo Starting server ...
|
||||
--source include/start_mysqld.inc
|
||||
--source include/wait_until_ready.inc
|
||||
|
||||
--let $wait_condition = SELECT VARIABLE_VALUE = 2 FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'wsrep_cluster_size'
|
||||
--source include/wait_condition.inc
|
||||
|
||||
SET AUTOCOMMIT=OFF;
|
||||
START TRANSACTION;
|
||||
|
@ -72,7 +72,9 @@ INSERT INTO t1 (f1) VALUES ('node1_to_be_rollbacked_after');
|
||||
--connection node_2
|
||||
--echo Starting server ...
|
||||
--source include/start_mysqld.inc
|
||||
--source include/wait_until_ready.inc
|
||||
|
||||
--let $wait_condition = SELECT VARIABLE_VALUE = 2 FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'wsrep_cluster_size'
|
||||
--source include/wait_condition.inc
|
||||
|
||||
SET AUTOCOMMIT=OFF;
|
||||
START TRANSACTION;
|
||||
|
@ -56,7 +56,9 @@ INSERT INTO t1 VALUES ('node1_to_be_rollbacked_after');
|
||||
--connection node_2
|
||||
--echo Starting server ...
|
||||
--source include/start_mysqld.inc
|
||||
--source include/wait_until_ready.inc
|
||||
|
||||
--let $wait_condition = SELECT VARIABLE_VALUE = 2 FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'wsrep_cluster_size'
|
||||
--source include/wait_condition.inc
|
||||
|
||||
SET AUTOCOMMIT=OFF;
|
||||
START TRANSACTION;
|
||||
|
@ -12,11 +12,4 @@ if ($galera_wsrep_start_position == '') {
|
||||
--exec echo "restart:$start_mysqld_params" > $_expect_file_name
|
||||
}
|
||||
|
||||
# Turn on reconnect
|
||||
--enable_reconnect
|
||||
|
||||
# Call script that will poll the server waiting for it to be back online again
|
||||
--source include/wait_until_connected_again.inc
|
||||
|
||||
# Turn off reconnect again
|
||||
--disable_reconnect
|
||||
--source include/galera_wait_ready.inc
|
||||
|
@ -57,3 +57,7 @@ WHERE NAME='test/t';
|
||||
TABLE_ID NAME FLAG N_COLS SPACE ROW_FORMAT ZIP_PAGE_SIZE SPACE_TYPE
|
||||
# test/t 33 6 # Dynamic 0 Single
|
||||
DROP TABLE t;
|
||||
CREATE TABLE t1(c1 INT) ENGINE=InnoDB;
|
||||
ALTER TABLE t1 ADD CONSTRAINT UNIQUE KEY i1(c1);
|
||||
ALTER TABLE t1 CHANGE c1 c1 INT NOT NULL,ADD KEY(c1);
|
||||
DROP TABLE t1;
|
||||
|
24
mysql-test/suite/innodb/r/innodb_bug27216817.result
Normal file
24
mysql-test/suite/innodb/r/innodb_bug27216817.result
Normal file
@ -0,0 +1,24 @@
|
||||
create table t1 (a int not null, b int not null) engine=innodb;
|
||||
insert t1 values (1,2),(3,4);
|
||||
lock table t1 write, t1 tr read;
|
||||
flush status;
|
||||
alter table t1 add primary key (b);
|
||||
show status like 'Handler_read_rnd_next';
|
||||
Variable_name Value
|
||||
Handler_read_rnd_next 0
|
||||
unlock tables;
|
||||
alter table t1 drop primary key;
|
||||
lock table t1 write;
|
||||
flush status;
|
||||
alter table t1 add primary key (b);
|
||||
show status like 'Handler_read_rnd_next';
|
||||
Variable_name Value
|
||||
Handler_read_rnd_next 0
|
||||
unlock tables;
|
||||
alter table t1 drop primary key;
|
||||
flush status;
|
||||
alter table t1 add primary key (b);
|
||||
show status like 'Handler_read_rnd_next';
|
||||
Variable_name Value
|
||||
Handler_read_rnd_next 0
|
||||
drop table t1;
|
@ -71,6 +71,11 @@ WHERE NAME='test/t';
|
||||
|
||||
DROP TABLE t;
|
||||
|
||||
CREATE TABLE t1(c1 INT) ENGINE=InnoDB;
|
||||
ALTER TABLE t1 ADD CONSTRAINT UNIQUE KEY i1(c1);
|
||||
ALTER TABLE t1 CHANGE c1 c1 INT NOT NULL,ADD KEY(c1);
|
||||
DROP TABLE t1;
|
||||
|
||||
# Check that all connections opened by test cases in this file are really
|
||||
# gone so execution of other tests won't be affected by their presence.
|
||||
--source include/wait_until_count_sessions.inc
|
||||
|
28
mysql-test/suite/innodb/t/innodb_bug27216817.test
Normal file
28
mysql-test/suite/innodb/t/innodb_bug27216817.test
Normal file
@ -0,0 +1,28 @@
|
||||
#
|
||||
# BUG#27216817: INNODB: FAILING ASSERTION:
|
||||
# PREBUILT->TABLE->N_MYSQL_HANDLES_OPENED == 1
|
||||
#
|
||||
|
||||
source include/have_innodb.inc;
|
||||
create table t1 (a int not null, b int not null) engine=innodb;
|
||||
insert t1 values (1,2),(3,4);
|
||||
|
||||
lock table t1 write, t1 tr read;
|
||||
flush status;
|
||||
alter table t1 add primary key (b);
|
||||
show status like 'Handler_read_rnd_next';
|
||||
unlock tables;
|
||||
alter table t1 drop primary key;
|
||||
|
||||
lock table t1 write;
|
||||
flush status;
|
||||
alter table t1 add primary key (b);
|
||||
show status like 'Handler_read_rnd_next';
|
||||
unlock tables;
|
||||
alter table t1 drop primary key;
|
||||
|
||||
flush status;
|
||||
alter table t1 add primary key (b);
|
||||
show status like 'Handler_read_rnd_next';
|
||||
|
||||
drop table t1;
|
@ -35,3 +35,13 @@ ALTER TABLE t1 REORGANIZE PARTITION p1 INTO
|
||||
PARTITION p3 VALUES IN (4,5,6)
|
||||
);
|
||||
DROP TABLE t1;
|
||||
|
||||
#
|
||||
# MDEV-15456 Server crashes upon adding or dropping a partition in ALTER under LOCK TABLE after ER_SAME_NAME_PARTITION
|
||||
#
|
||||
create table t1 (i int) partition by range(i) (partition p0 values less than (10));
|
||||
lock table t1 write;
|
||||
--error ER_SAME_NAME_PARTITION
|
||||
alter table t1 add partition (partition p0 values less than (20));
|
||||
alter table t1 add partition (partition p1 values less than (20)) /* comment */;
|
||||
drop table t1;
|
||||
|
@ -42,3 +42,9 @@ PARTITION p3 VALUES IN (4,5,6)
|
||||
);
|
||||
ERROR HY000: Syntax error: LIST PARTITIONING requires definition of VALUES IN for each partition
|
||||
DROP TABLE t1;
|
||||
create table t1 (i int) partition by range(i) (partition p0 values less than (10));
|
||||
lock table t1 write;
|
||||
alter table t1 add partition (partition p0 values less than (20));
|
||||
ERROR HY000: Duplicate partition name p0
|
||||
alter table t1 add partition (partition p1 values less than (20)) /* comment */;
|
||||
drop table t1;
|
||||
|
@ -69,3 +69,9 @@ PARTITION p3 VALUES IN (4,5,6)
|
||||
);
|
||||
ERROR HY000: Syntax error: LIST PARTITIONING requires definition of VALUES IN for each partition
|
||||
DROP TABLE t1;
|
||||
create table t1 (i int) partition by range(i) (partition p0 values less than (10));
|
||||
lock table t1 write;
|
||||
alter table t1 add partition (partition p0 values less than (20));
|
||||
ERROR HY000: Duplicate partition name p0
|
||||
alter table t1 add partition (partition p1 values less than (20)) /* comment */;
|
||||
drop table t1;
|
||||
|
@ -42,6 +42,12 @@ PARTITION p3 VALUES IN (4,5,6)
|
||||
);
|
||||
ERROR HY000: Syntax error: LIST PARTITIONING requires definition of VALUES IN for each partition
|
||||
DROP TABLE t1;
|
||||
create table t1 (i int) partition by range(i) (partition p0 values less than (10));
|
||||
lock table t1 write;
|
||||
alter table t1 add partition (partition p0 values less than (20));
|
||||
ERROR HY000: Duplicate partition name p0
|
||||
alter table t1 add partition (partition p1 values less than (20)) /* comment */;
|
||||
drop table t1;
|
||||
create table t1 ( c1 int, c2 int, c3 varchar(100)) delay_key_write=1
|
||||
partition by key(c1) (
|
||||
partition p01 data directory = 'MYSQL_TMP_DIR'
|
||||
|
@ -1,5 +1,5 @@
|
||||
/* Copyright (c) 2006, 2010, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2016, MariaDB
|
||||
/* Copyright (c) 2006, 2018, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -102,8 +102,8 @@ retry:
|
||||
do { /* PTR() isn't necessary below, head is a dummy node */
|
||||
cursor->curr= (LF_SLIST *)(*cursor->prev);
|
||||
lf_pin(pins, 1, cursor->curr);
|
||||
} while (*cursor->prev != (intptr)cursor->curr && LF_BACKOFF());
|
||||
|
||||
} while (my_atomic_loadptr((void**)cursor->prev) != cursor->curr &&
|
||||
LF_BACKOFF());
|
||||
for (;;)
|
||||
{
|
||||
if (unlikely(!cursor->curr))
|
||||
|
@ -1099,10 +1099,12 @@ void print_defaults(const char *conf_file, const char **groups)
|
||||
}
|
||||
}
|
||||
puts("\nThe following options may be given as the first argument:\n\
|
||||
--print-defaults Print the program argument list and exit.\n\
|
||||
--no-defaults Don't read default options from any option file.\n\
|
||||
--defaults-file=# Only read default options from the given file #.\n\
|
||||
--defaults-extra-file=# Read this file after the global files are read.");
|
||||
--print-defaults Print the program argument list and exit.\n\
|
||||
--no-defaults Don't read default options from any option file.\n\
|
||||
The following specify which files/extra groups are read (specified before remaining options):\n\
|
||||
--defaults-file=# Only read default options from the given file #.\n\
|
||||
--defaults-extra-file=# Read this file after the global files are read.\n\
|
||||
--defaults-group-suffix=# Additionally read default groups with # appended as a suffix.");
|
||||
}
|
||||
|
||||
|
||||
|
@ -1571,7 +1571,7 @@ read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row, ulong *lengths)
|
||||
}
|
||||
else
|
||||
{
|
||||
if (len > (ulong) (end_pos - pos))
|
||||
if (pos + len > end_pos)
|
||||
{
|
||||
set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
|
||||
return -1;
|
||||
|
@ -1558,7 +1558,7 @@ public:
|
||||
}
|
||||
virtual bool sp_prepare_and_store_item(THD *thd, Item **value);
|
||||
|
||||
friend int cre_myisam(char * name, register TABLE *form, uint options,
|
||||
friend int cre_myisam(char * name, TABLE *form, uint options,
|
||||
ulonglong auto_increment_value);
|
||||
friend class Copy_field;
|
||||
friend class Item_avg_field;
|
||||
|
@ -1166,12 +1166,11 @@ Type_handler_real_result::make_sort_key(uchar *to, Item *item,
|
||||
|
||||
/** Make a sort-key from record. */
|
||||
|
||||
static void make_sortkey(register Sort_param *param,
|
||||
register uchar *to, uchar *ref_pos)
|
||||
static void make_sortkey(Sort_param *param, uchar *to, uchar *ref_pos)
|
||||
{
|
||||
reg3 Field *field;
|
||||
reg1 SORT_FIELD *sort_field;
|
||||
reg5 uint length;
|
||||
Field *field;
|
||||
SORT_FIELD *sort_field;
|
||||
uint length;
|
||||
|
||||
for (sort_field=param->local_sortorder ;
|
||||
sort_field != param->end ;
|
||||
@ -1261,7 +1260,7 @@ static void make_sortkey(register Sort_param *param,
|
||||
|
||||
static void register_used_fields(Sort_param *param)
|
||||
{
|
||||
reg1 SORT_FIELD *sort_field;
|
||||
SORT_FIELD *sort_field;
|
||||
TABLE *table=param->sort_form;
|
||||
|
||||
for (sort_field= param->local_sortorder ;
|
||||
@ -1460,7 +1459,7 @@ static bool check_if_pq_applicable(Sort_param *param,
|
||||
int merge_many_buff(Sort_param *param, uchar *sort_buffer,
|
||||
BUFFPEK *buffpek, uint *maxbuffer, IO_CACHE *t_file)
|
||||
{
|
||||
register uint i;
|
||||
uint i;
|
||||
IO_CACHE t_file2,*from_file,*to_file,*temp;
|
||||
BUFFPEK *lastbuff;
|
||||
DBUG_ENTER("merge_many_buff");
|
||||
@ -1515,7 +1514,7 @@ cleanup:
|
||||
uint read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
|
||||
uint rec_length)
|
||||
{
|
||||
register uint count;
|
||||
uint count;
|
||||
uint length;
|
||||
|
||||
if ((count=(uint) MY_MIN((ha_rows) buffpek->max_keys,buffpek->count)))
|
||||
@ -1819,7 +1818,7 @@ int merge_buffers(Sort_param *param, IO_CACHE *from_file,
|
||||
}
|
||||
else
|
||||
{
|
||||
register uchar *end;
|
||||
uchar *end;
|
||||
src= buffpek->key+offset;
|
||||
for (end= src+buffpek->mem_count*rec_length ;
|
||||
src != end ;
|
||||
|
@ -401,8 +401,8 @@ int main(int argc,char **argv)
|
||||
static SYMBOL *get_hash_symbol(const char *s,\n\
|
||||
unsigned int len,bool function)\n\
|
||||
{\n\
|
||||
register uchar *hash_map;\n\
|
||||
register const char *cur_str= s;\n\
|
||||
uchar *hash_map;\n\
|
||||
const char *cur_str= s;\n\
|
||||
\n\
|
||||
if (len == 0) {\n\
|
||||
DBUG_PRINT(\"warning\", (\"get_hash_symbol() received a request for a zero-length symbol, which is probably a mistake.\"));\
|
||||
@ -414,25 +414,25 @@ static SYMBOL *get_hash_symbol(const char *s,\n\
|
||||
if (function){\n\
|
||||
if (len>sql_functions_max_len) return 0;\n\
|
||||
hash_map= sql_functions_map;\n\
|
||||
register uint32 cur_struct= uint4korr(hash_map+((len-1)*4));\n\
|
||||
uint32 cur_struct= uint4korr(hash_map+((len-1)*4));\n\
|
||||
\n\
|
||||
for (;;){\n\
|
||||
register uchar first_char= (uchar)cur_struct;\n\
|
||||
uchar first_char= (uchar)cur_struct;\n\
|
||||
\n\
|
||||
if (first_char == 0)\n\
|
||||
{\n\
|
||||
register int16 ires= (int16)(cur_struct>>16);\n\
|
||||
int16 ires= (int16)(cur_struct>>16);\n\
|
||||
if (ires==array_elements(symbols)) return 0;\n\
|
||||
register SYMBOL *res;\n\
|
||||
SYMBOL *res;\n\
|
||||
if (ires>=0) \n\
|
||||
res= symbols+ires;\n\
|
||||
else\n\
|
||||
res= sql_functions-ires-1;\n\
|
||||
register uint count= (uint) (cur_str - s);\n\
|
||||
uint count= (uint) (cur_str - s);\n\
|
||||
return lex_casecmp(cur_str,res->name+count,len-count) ? 0 : res;\n\
|
||||
}\n\
|
||||
\n\
|
||||
register uchar cur_char= (uchar)to_upper_lex[(uchar)*cur_str];\n\
|
||||
uchar cur_char= (uchar)to_upper_lex[(uchar)*cur_str];\n\
|
||||
if (cur_char<first_char) return 0;\n\
|
||||
cur_struct>>=8;\n\
|
||||
if (cur_char>(uchar)cur_struct) return 0;\n\
|
||||
@ -448,20 +448,20 @@ static SYMBOL *get_hash_symbol(const char *s,\n\
|
||||
}else{\n\
|
||||
if (len>symbols_max_len) return 0;\n\
|
||||
hash_map= symbols_map;\n\
|
||||
register uint32 cur_struct= uint4korr(hash_map+((len-1)*4));\n\
|
||||
uint32 cur_struct= uint4korr(hash_map+((len-1)*4));\n\
|
||||
\n\
|
||||
for (;;){\n\
|
||||
register uchar first_char= (uchar)cur_struct;\n\
|
||||
uchar first_char= (uchar)cur_struct;\n\
|
||||
\n\
|
||||
if (first_char==0){\n\
|
||||
register int16 ires= (int16)(cur_struct>>16);\n\
|
||||
if (first_char==0) {\n\
|
||||
int16 ires= (int16)(cur_struct>>16);\n\
|
||||
if (ires==array_elements(symbols)) return 0;\n\
|
||||
register SYMBOL *res= symbols+ires;\n\
|
||||
register uint count= (uint) (cur_str - s);\n\
|
||||
SYMBOL *res= symbols+ires;\n\
|
||||
uint count= (uint) (cur_str - s);\n\
|
||||
return lex_casecmp(cur_str,res->name+count,len-count)!=0 ? 0 : res;\n\
|
||||
}\n\
|
||||
\n\
|
||||
register uchar cur_char= (uchar)to_upper_lex[(uchar)*cur_str];\n\
|
||||
uchar cur_char= (uchar)to_upper_lex[(uchar)*cur_str];\n\
|
||||
if (cur_char<first_char) return 0;\n\
|
||||
cur_struct>>=8;\n\
|
||||
if (cur_char>(uchar)cur_struct) return 0;\n\
|
||||
|
@ -2983,7 +2983,7 @@ int handler::ha_rnd_init_with_error(bool scan)
|
||||
*/
|
||||
int handler::read_first_row(uchar * buf, uint primary_key)
|
||||
{
|
||||
register int error;
|
||||
int error;
|
||||
DBUG_ENTER("handler::read_first_row");
|
||||
|
||||
/*
|
||||
@ -4469,18 +4469,6 @@ handler::check_if_supported_inplace_alter(TABLE *altered_table,
|
||||
DBUG_RETURN(HA_ALTER_INPLACE_NOT_SUPPORTED);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Default implementation to support in-place alter table
|
||||
and old online add/drop index API
|
||||
*/
|
||||
|
||||
void handler::notify_table_changed()
|
||||
{
|
||||
ha_create_partitioning_metadata(table->s->path.str, NULL, CHF_INDEX_FLAG);
|
||||
}
|
||||
|
||||
|
||||
void Alter_inplace_info::report_unsupported_error(const char *not_supported,
|
||||
const char *try_instead)
|
||||
{
|
||||
@ -4579,7 +4567,6 @@ handler::ha_create_partitioning_metadata(const char *name,
|
||||
*/
|
||||
DBUG_ASSERT(m_lock_type == F_UNLCK ||
|
||||
(!old_name && strcmp(name, table_share->path.str)));
|
||||
mark_trx_read_write();
|
||||
|
||||
return create_partitioning_metadata(name, old_name, action_flag);
|
||||
}
|
||||
|
@ -4271,7 +4271,7 @@ protected:
|
||||
|
||||
@note No errors are allowed during notify_table_changed().
|
||||
*/
|
||||
virtual void notify_table_changed();
|
||||
virtual void notify_table_changed() { }
|
||||
|
||||
public:
|
||||
/* End of On-line/in-place ALTER TABLE interface. */
|
||||
|
@ -5855,8 +5855,8 @@ void Item_func_like::turboBM_compute_bad_character_shifts()
|
||||
|
||||
bool Item_func_like::turboBM_matches(const char* text, int text_len) const
|
||||
{
|
||||
register int bcShift;
|
||||
register int turboShift;
|
||||
int bcShift;
|
||||
int turboShift;
|
||||
int shift = pattern_len;
|
||||
int j = 0;
|
||||
int u = 0;
|
||||
@ -5870,7 +5870,7 @@ bool Item_func_like::turboBM_matches(const char* text, int text_len) const
|
||||
{
|
||||
while (j <= tlmpl)
|
||||
{
|
||||
register int i= plm1;
|
||||
int i= plm1;
|
||||
while (i >= 0 && pattern[i] == text[i + j])
|
||||
{
|
||||
i--;
|
||||
@ -5880,7 +5880,7 @@ bool Item_func_like::turboBM_matches(const char* text, int text_len) const
|
||||
if (i < 0)
|
||||
return 1;
|
||||
|
||||
register const int v = plm1 - i;
|
||||
const int v= plm1 - i;
|
||||
turboShift = u - v;
|
||||
bcShift = bmBc[(uint) (uchar) text[i + j]] - plm1 + i;
|
||||
shift = MY_MAX(turboShift, bcShift);
|
||||
@ -5901,7 +5901,7 @@ bool Item_func_like::turboBM_matches(const char* text, int text_len) const
|
||||
{
|
||||
while (j <= tlmpl)
|
||||
{
|
||||
register int i = plm1;
|
||||
int i= plm1;
|
||||
while (i >= 0 && likeconv(cs,pattern[i]) == likeconv(cs,text[i + j]))
|
||||
{
|
||||
i--;
|
||||
@ -5911,7 +5911,7 @@ bool Item_func_like::turboBM_matches(const char* text, int text_len) const
|
||||
if (i < 0)
|
||||
return 1;
|
||||
|
||||
register const int v = plm1 - i;
|
||||
const int v= plm1 - i;
|
||||
turboShift = u - v;
|
||||
bcShift = bmBc[(uint) likeconv(cs, text[i + j])] - plm1 + i;
|
||||
shift = MY_MAX(turboShift, bcShift);
|
||||
|
@ -3077,8 +3077,8 @@ longlong Item_func_ord::val_int()
|
||||
#ifdef USE_MB
|
||||
if (use_mb(res->charset()))
|
||||
{
|
||||
register const char *str=res->ptr();
|
||||
register uint32 n=0, l=my_ismbchar(res->charset(),str,str+res->length());
|
||||
const char *str=res->ptr();
|
||||
uint32 n=0, l=my_ismbchar(res->charset(),str,str+res->length());
|
||||
if (!l)
|
||||
return (longlong)((uchar) *str);
|
||||
while (l--)
|
||||
|
@ -3001,6 +3001,7 @@ public:
|
||||
Item_func_uuid_short(THD *thd): Item_longlong_func(thd) {}
|
||||
const char *func_name() const { return "uuid_short"; }
|
||||
longlong val_int();
|
||||
bool const_item() const { return false; }
|
||||
void fix_length_and_dec()
|
||||
{ max_length= 21; unsigned_flag=1; }
|
||||
table_map used_tables() const { return RAND_TABLE_BIT; }
|
||||
|
@ -1078,7 +1078,7 @@ String *Item_func_reverse::val_str(String *str)
|
||||
#ifdef USE_MB
|
||||
if (use_mb(res->charset()))
|
||||
{
|
||||
register uint32 l;
|
||||
uint32 l;
|
||||
while (ptr < end)
|
||||
{
|
||||
if ((l= my_ismbchar(res->charset(),ptr,end)))
|
||||
@ -1128,7 +1128,7 @@ String *Item_func_replace::val_str_internal(String *str,
|
||||
bool alloced=0;
|
||||
#ifdef USE_MB
|
||||
const char *ptr,*end,*strend,*search,*search_end;
|
||||
register uint32 l;
|
||||
uint32 l;
|
||||
bool binary_cmp;
|
||||
#endif
|
||||
THD *thd= 0;
|
||||
@ -1188,7 +1188,7 @@ redo:
|
||||
{
|
||||
if (*ptr == *search)
|
||||
{
|
||||
register char *i,*j;
|
||||
char *i,*j;
|
||||
i=(char*) ptr+1; j=(char*) search+1;
|
||||
while (j != search_end)
|
||||
if (*i++ != *j++) goto skip;
|
||||
@ -1799,14 +1799,14 @@ String *Item_func_substr_index::val_str(String *str)
|
||||
const char *search= delimiter->ptr();
|
||||
const char *search_end= search+delimiter_length;
|
||||
int32 n=0,c=count,pass;
|
||||
register uint32 l;
|
||||
uint32 l;
|
||||
for (pass=(count>0);pass<2;++pass)
|
||||
{
|
||||
while (ptr < end)
|
||||
{
|
||||
if (*ptr == *search)
|
||||
{
|
||||
register char *i,*j;
|
||||
char *i,*j;
|
||||
i=(char*) ptr+1; j=(char*) search+1;
|
||||
while (j != search_end)
|
||||
if (*i++ != *j++) goto skip;
|
||||
@ -1974,7 +1974,7 @@ String *Item_func_rtrim::val_str(String *str)
|
||||
end= ptr+res->length();
|
||||
#ifdef USE_MB
|
||||
char *p=ptr;
|
||||
register uint32 l;
|
||||
uint32 l;
|
||||
#endif
|
||||
if (remove_length == 1)
|
||||
{
|
||||
@ -2059,7 +2059,7 @@ String *Item_func_trim::val_str(String *str)
|
||||
if (use_mb(collation.collation))
|
||||
{
|
||||
char *p=ptr;
|
||||
register uint32 l;
|
||||
uint32 l;
|
||||
loop:
|
||||
while (ptr + remove_length < end)
|
||||
{
|
||||
|
@ -1630,6 +1630,7 @@ public:
|
||||
DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII);
|
||||
fix_char_length(MY_UUID_STRING_LENGTH);
|
||||
}
|
||||
bool const_item() const { return false; }
|
||||
table_map used_tables() const { return RAND_TABLE_BIT; }
|
||||
const char *func_name() const{ return "uuid"; }
|
||||
String *val_str(String *);
|
||||
|
@ -52,8 +52,8 @@
|
||||
int find_ref_key(KEY *key, uint key_count, uchar *record, Field *field,
|
||||
uint *key_length, uint *keypart)
|
||||
{
|
||||
reg2 int i;
|
||||
reg3 KEY *key_info;
|
||||
int i;
|
||||
KEY *key_info;
|
||||
uint fieldpos;
|
||||
|
||||
fieldpos= field->offset(record);
|
||||
@ -499,7 +499,7 @@ int key_cmp(KEY_PART_INFO *key_part, const uchar *key, uint key_length)
|
||||
if (key_part->null_bit)
|
||||
{
|
||||
/* This key part allows null values; NULL is lower than everything */
|
||||
register bool field_is_null= key_part->field->is_null();
|
||||
bool field_is_null= key_part->field->is_null();
|
||||
if (*key) // If range key is null
|
||||
{
|
||||
/* the range is expecting a null value */
|
||||
|
@ -379,7 +379,7 @@ end:
|
||||
|
||||
static int lock_external(THD *thd, TABLE **tables, uint count)
|
||||
{
|
||||
reg1 uint i;
|
||||
uint i;
|
||||
int lock_type,error;
|
||||
DBUG_ENTER("lock_external");
|
||||
|
||||
@ -539,7 +539,7 @@ void mysql_lock_remove(THD *thd, MYSQL_LOCK *locked,TABLE *table)
|
||||
{
|
||||
if (locked)
|
||||
{
|
||||
reg1 uint i;
|
||||
uint i;
|
||||
for (i=0; i < locked->table_count; i++)
|
||||
{
|
||||
if (locked->table[i] == table)
|
||||
|
@ -2459,7 +2459,7 @@ static int find_uniq_filename(char *name, ulong next_log_number)
|
||||
uint i;
|
||||
char buff[FN_REFLEN], ext_buf[FN_REFLEN];
|
||||
struct st_my_dir *dir_info;
|
||||
reg1 struct fileinfo *file_info;
|
||||
struct fileinfo *file_info;
|
||||
ulong max_found, next, UNINIT_VAR(number);
|
||||
size_t buf_length, length;
|
||||
char *start, *end;
|
||||
@ -8516,10 +8516,9 @@ void MYSQL_BIN_LOG::set_max_size(ulong max_size_arg)
|
||||
0 String is not a number
|
||||
*/
|
||||
|
||||
static bool test_if_number(register const char *str,
|
||||
ulong *res, bool allow_wildcards)
|
||||
static bool test_if_number(const char *str, ulong *res, bool allow_wildcards)
|
||||
{
|
||||
reg2 int flag;
|
||||
int flag;
|
||||
const char *start;
|
||||
DBUG_ENTER("test_if_number");
|
||||
|
||||
|
119
sql/log_event.cc
119
sql/log_event.cc
@ -1,6 +1,6 @@
|
||||
/*
|
||||
Copyright (c) 2000, 2016, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2016, MariaDB
|
||||
Copyright (c) 2000, 2018, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -4831,6 +4831,24 @@ Query_log_event::Query_log_event(const char* buf, uint event_len,
|
||||
db= (char *)start;
|
||||
query= (char *)(start + db_len + 1);
|
||||
q_len= data_len - db_len -1;
|
||||
|
||||
if (data_len && (data_len < db_len ||
|
||||
data_len < q_len ||
|
||||
data_len != (db_len + q_len + 1)))
|
||||
{
|
||||
q_len= 0;
|
||||
query= NULL;
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
uint32 max_length= uint32(event_len - ((const char*)(end + db_len + 1) -
|
||||
(buf - common_header_len)));
|
||||
if (q_len != max_length)
|
||||
{
|
||||
q_len= 0;
|
||||
query= NULL;
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
/**
|
||||
Append the db length at the end of the buffer. This will be used by
|
||||
Query_cache::send_result_to_client() in case the query cache is On.
|
||||
@ -5377,6 +5395,19 @@ int Query_log_event::do_apply_event(rpl_group_info *rgi,
|
||||
you.
|
||||
*/
|
||||
thd->catalog= catalog_len ? (char *) catalog : (char *)"";
|
||||
|
||||
size_t valid_len= Well_formed_prefix(system_charset_info,
|
||||
db, db_len, NAME_LEN).length();
|
||||
|
||||
if (valid_len != db_len)
|
||||
{
|
||||
rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
|
||||
ER_THD(thd, ER_SLAVE_FATAL_ERROR),
|
||||
"Invalid database name in Query event.");
|
||||
thd->is_slave_error= true;
|
||||
goto end;
|
||||
}
|
||||
|
||||
new_db.length= db_len;
|
||||
new_db.str= (char *) rpl_filter->get_rewrite_db(db, &new_db.length);
|
||||
thd->set_db(&new_db); /* allocates a copy of 'db' */
|
||||
@ -5518,7 +5549,23 @@ int Query_log_event::do_apply_event(rpl_group_info *rgi,
|
||||
}
|
||||
else
|
||||
thd->variables.collation_database= thd->db_charset;
|
||||
|
||||
|
||||
{
|
||||
const CHARSET_INFO *cs= thd->charset();
|
||||
/*
|
||||
We cannot ask for parsing a statement using a character set
|
||||
without state_maps (parser internal data).
|
||||
*/
|
||||
if (!cs->state_map)
|
||||
{
|
||||
rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
|
||||
ER_THD(thd, ER_SLAVE_FATAL_ERROR),
|
||||
"character_set cannot be parsed");
|
||||
thd->is_slave_error= true;
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Record any GTID in the same transaction, so slave state is
|
||||
transactionally consistent.
|
||||
@ -6074,7 +6121,13 @@ int Start_log_event_v3::do_apply_event(rpl_group_info *rgi)
|
||||
*/
|
||||
break;
|
||||
default:
|
||||
/* this case is impossible */
|
||||
/*
|
||||
This case is not expected. It can be either an event corruption or an
|
||||
unsupported binary log version.
|
||||
*/
|
||||
rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
|
||||
ER_THD(thd, ER_SLAVE_FATAL_ERROR),
|
||||
"Binlog version not supported");
|
||||
DBUG_RETURN(1);
|
||||
}
|
||||
DBUG_RETURN(error);
|
||||
@ -6993,6 +7046,9 @@ int Load_log_event::copy_log_event(const char *buf, ulong event_len,
|
||||
|
||||
fields = (char*)field_lens + num_fields;
|
||||
table_name = fields + field_block_len;
|
||||
if (strlen(table_name) > NAME_LEN)
|
||||
goto err;
|
||||
|
||||
db = table_name + table_name_len + 1;
|
||||
DBUG_EXECUTE_IF ("simulate_invalid_address",
|
||||
db_len = data_len;);
|
||||
@ -9066,6 +9122,13 @@ User_var_log_event(const char* buf, uint event_len,
|
||||
buf+= description_event->common_header_len +
|
||||
description_event->post_header_len[USER_VAR_EVENT-1];
|
||||
name_len= uint4korr(buf);
|
||||
/* Avoid reading out of buffer */
|
||||
if ((buf - buf_start) + UV_NAME_LEN_SIZE + name_len > event_len)
|
||||
{
|
||||
error= true;
|
||||
goto err;
|
||||
}
|
||||
|
||||
name= (char *) buf + UV_NAME_LEN_SIZE;
|
||||
|
||||
/*
|
||||
@ -9122,7 +9185,12 @@ User_var_log_event(const char* buf, uint event_len,
|
||||
Old events will not have this extra byte, thence,
|
||||
we keep the flags set to UNDEF_F.
|
||||
*/
|
||||
size_t bytes_read= ((val + val_len) - buf_start);
|
||||
size_t bytes_read= (val + val_len) - buf_start;
|
||||
if (bytes_read > size_t(event_len))
|
||||
{
|
||||
error= true;
|
||||
goto err;
|
||||
}
|
||||
if ((data_written - bytes_read) > 0)
|
||||
{
|
||||
flags= (uint) *(buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
|
||||
@ -9354,7 +9422,12 @@ int User_var_log_event::do_apply_event(rpl_group_info *rgi)
|
||||
}
|
||||
|
||||
if (!(charset= get_charset(charset_number, MYF(MY_WME))))
|
||||
{
|
||||
rgi->rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
|
||||
ER_THD(thd, ER_SLAVE_FATAL_ERROR),
|
||||
"Invalid character set for User var event");
|
||||
DBUG_RETURN(1);
|
||||
}
|
||||
LEX_CSTRING user_var_name;
|
||||
user_var_name.str= name;
|
||||
user_var_name.length= name_len;
|
||||
@ -9369,12 +9442,26 @@ int User_var_log_event::do_apply_event(rpl_group_info *rgi)
|
||||
{
|
||||
switch (type) {
|
||||
case REAL_RESULT:
|
||||
if (val_len != 8)
|
||||
{
|
||||
rgi->rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
|
||||
ER_THD(thd, ER_SLAVE_FATAL_ERROR),
|
||||
"Invalid variable length at User var event");
|
||||
return 1;
|
||||
}
|
||||
float8get(real_val, val);
|
||||
it= new (thd->mem_root) Item_float(thd, real_val, 0);
|
||||
val= (char*) &real_val; // Pointer to value in native format
|
||||
val_len= 8;
|
||||
break;
|
||||
case INT_RESULT:
|
||||
if (val_len != 8)
|
||||
{
|
||||
rgi->rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
|
||||
ER_THD(thd, ER_SLAVE_FATAL_ERROR),
|
||||
"Invalid variable length at User var event");
|
||||
return 1;
|
||||
}
|
||||
int_val= (longlong) uint8korr(val);
|
||||
it= new (thd->mem_root) Item_int(thd, int_val);
|
||||
val= (char*) &int_val; // Pointer to value in native format
|
||||
@ -9382,6 +9469,13 @@ int User_var_log_event::do_apply_event(rpl_group_info *rgi)
|
||||
break;
|
||||
case DECIMAL_RESULT:
|
||||
{
|
||||
if (val_len < 3)
|
||||
{
|
||||
rgi->rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
|
||||
ER_THD(thd, ER_SLAVE_FATAL_ERROR),
|
||||
"Invalid variable length at User var event");
|
||||
return 1;
|
||||
}
|
||||
Item_decimal *dec= new (thd->mem_root) Item_decimal(thd, (uchar*) val+2, val[0], val[1]);
|
||||
it= dec;
|
||||
val= (char *)dec->val_decimal(NULL);
|
||||
@ -10797,6 +10891,14 @@ Rows_log_event::Rows_log_event(const char *buf, uint event_len,
|
||||
DBUG_PRINT("debug", ("Reading from %p", ptr_after_width));
|
||||
m_width = net_field_length(&ptr_after_width);
|
||||
DBUG_PRINT("debug", ("m_width=%lu", m_width));
|
||||
|
||||
/* Avoid reading out of buffer */
|
||||
if (ptr_after_width + (m_width + 7) / 8 > (uchar*)buf + event_len)
|
||||
{
|
||||
m_cols.bitmap= NULL;
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
/* if my_bitmap_init fails, catched in is_valid() */
|
||||
if (likely(!my_bitmap_init(&m_cols,
|
||||
m_width <= sizeof(m_bitbuf)*8 ? m_bitbuf : NULL,
|
||||
@ -10845,7 +10947,12 @@ Rows_log_event::Rows_log_event(const char *buf, uint event_len,
|
||||
|
||||
const uchar* const ptr_rows_data= (const uchar*) ptr_after_width;
|
||||
|
||||
size_t const data_size= event_len - (ptr_rows_data - (const uchar *) buf);
|
||||
size_t const read_size= ptr_rows_data - (const unsigned char *) buf;
|
||||
if (read_size > event_len)
|
||||
{
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
size_t const data_size= event_len - read_size;
|
||||
DBUG_PRINT("info",("m_table_id: %lu m_flags: %d m_width: %lu data_size: %lu",
|
||||
m_table_id, m_flags, m_width, (ulong) data_size));
|
||||
|
||||
|
@ -1,4 +1,5 @@
|
||||
/* Copyright (c) 2007, 2016, Oracle and/or its affiliates.
|
||||
/* Copyright (c) 2007, 2018, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -1233,6 +1234,13 @@ Old_rows_log_event::Old_rows_log_event(const char *buf, uint event_len,
|
||||
DBUG_PRINT("debug", ("Reading from %p", ptr_after_width));
|
||||
m_width = net_field_length(&ptr_after_width);
|
||||
DBUG_PRINT("debug", ("m_width=%lu", m_width));
|
||||
/* Avoid reading out of buffer */
|
||||
if (ptr_after_width + m_width > (uchar *)buf + event_len)
|
||||
{
|
||||
m_cols.bitmap= NULL;
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
/* if my_bitmap_init fails, catched in is_valid() */
|
||||
if (likely(!my_bitmap_init(&m_cols,
|
||||
m_width <= sizeof(m_bitbuf)*8 ? m_bitbuf : NULL,
|
||||
|
@ -49,8 +49,7 @@ extern "C" {
|
||||
*/
|
||||
|
||||
|
||||
int _my_b_net_read(register IO_CACHE *info, uchar *Buffer,
|
||||
size_t Count __attribute__((unused)))
|
||||
int _my_b_net_read(IO_CACHE *info, uchar *Buffer, size_t)
|
||||
{
|
||||
ulong read_length;
|
||||
NET *net= &(current_thd)->net;
|
||||
|
@ -5961,5 +5961,6 @@ bool JOIN::choose_tableless_subquery_plan()
|
||||
tmp_having= having;
|
||||
}
|
||||
}
|
||||
exec_const_cond= conds;
|
||||
return FALSE;
|
||||
}
|
||||
|
@ -90,7 +90,7 @@
|
||||
|
||||
void hash_password(ulong *result, const char *password, uint password_len)
|
||||
{
|
||||
register ulong nr=1345345333L, add=7, nr2=0x12345671L;
|
||||
ulong nr=1345345333L, add=7, nr2=0x12345671L;
|
||||
ulong tmp;
|
||||
const char *password_end= password + password_len;
|
||||
for (; password < password_end; password++)
|
||||
@ -325,7 +325,7 @@ hex2octet(uint8 *to, const char *str, uint len)
|
||||
const char *str_end= str + len;
|
||||
while (str < str_end)
|
||||
{
|
||||
register char tmp= char_val(*str++);
|
||||
char tmp= char_val(*str++);
|
||||
*to++= (tmp << 4) | char_val(*str++);
|
||||
}
|
||||
}
|
||||
|
@ -91,7 +91,7 @@ recursion_point:
|
||||
}
|
||||
|
||||
{
|
||||
register struct LS_STRUCT_NAME *sp0= sp++;
|
||||
struct LS_STRUCT_NAME *sp0= sp++;
|
||||
sp->list_len= sp0->list_len >> 1;
|
||||
sp0->list_len-= sp->list_len;
|
||||
sp->return_point= 0;
|
||||
@ -100,7 +100,7 @@ recursion_point:
|
||||
return_point0:
|
||||
sp->list1= sorted_list;
|
||||
{
|
||||
register struct LS_STRUCT_NAME *sp0= sp++;
|
||||
struct LS_STRUCT_NAME *sp0= sp++;
|
||||
list= list_end;
|
||||
sp->list_len= sp0->list_len;
|
||||
sp->return_point= 1;
|
||||
@ -108,9 +108,9 @@ return_point0:
|
||||
goto recursion_point;
|
||||
return_point1:
|
||||
{
|
||||
register LS_LIST_ITEM **hook= &sorted_list;
|
||||
register LS_LIST_ITEM *list1= sp->list1;
|
||||
register LS_LIST_ITEM *list2= sorted_list;
|
||||
LS_LIST_ITEM **hook= &sorted_list;
|
||||
LS_LIST_ITEM *list1= sp->list1;
|
||||
LS_LIST_ITEM *list2= sorted_list;
|
||||
|
||||
if (LS_COMPARE_FUNC_CALL(list1, list2))
|
||||
{
|
||||
|
@ -631,7 +631,7 @@ static int init_rr_cache(THD *thd, READ_RECORD *info)
|
||||
|
||||
static int rr_from_cache(READ_RECORD *info)
|
||||
{
|
||||
reg1 uint i;
|
||||
uint i;
|
||||
ulong length;
|
||||
my_off_t rest_of_file;
|
||||
int16 error;
|
||||
|
@ -223,7 +223,7 @@ static void set_slave_max_allowed_packet(THD *thd, MYSQL *mysql)
|
||||
void init_thread_mask(int* mask,Master_info* mi,bool inverse)
|
||||
{
|
||||
bool set_io = mi->slave_running, set_sql = mi->rli.slave_running;
|
||||
register int tmp_mask=0;
|
||||
int tmp_mask=0;
|
||||
DBUG_ENTER("init_thread_mask");
|
||||
|
||||
if (set_io)
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
Copyright (c) 2002, 2016, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2017, MariaDB
|
||||
Copyright (c) 2002, 2018, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -423,7 +423,7 @@ private:
|
||||
bool m_print_once;
|
||||
|
||||
public:
|
||||
Proc_table_intact() : m_print_once(TRUE) {}
|
||||
Proc_table_intact() : m_print_once(TRUE) { has_keys= TRUE; }
|
||||
|
||||
protected:
|
||||
void report_error(uint code, const char *fmt, ...);
|
||||
|
@ -1,5 +1,5 @@
|
||||
/* Copyright (c) 2000, 2016, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2016, MariaDB
|
||||
Copyright (c) 2009, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -11379,7 +11379,7 @@ int fill_schema_applicable_roles(THD *thd, TABLE_LIST *tables, COND *cond)
|
||||
|
||||
int wild_case_compare(CHARSET_INFO *cs, const char *str,const char *wildstr)
|
||||
{
|
||||
reg3 int flag;
|
||||
int flag;
|
||||
DBUG_ENTER("wild_case_compare");
|
||||
DBUG_PRINT("enter",("str: '%s' wildstr: '%s'",str,wildstr));
|
||||
while (*wildstr)
|
||||
|
@ -1,5 +1,5 @@
|
||||
/* Copyright (c) 2010, 2015, Oracle and/or its affiliates.
|
||||
Copyright (c) 2011, 2016, MariaDB
|
||||
Copyright (c) 2011, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -240,7 +240,7 @@ static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
|
||||
|
||||
if (thd->locked_tables_list.locked_tables())
|
||||
{
|
||||
if (thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_list.reopen_tables(thd, false))
|
||||
goto end;
|
||||
/* Restore the table in the table list with the new opened table */
|
||||
table_list->table= pos_in_locked_tables->table;
|
||||
|
@ -484,7 +484,7 @@ err_with_reopen:
|
||||
old locks. This should always succeed (unless some external process
|
||||
has removed the tables)
|
||||
*/
|
||||
if (thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_list.reopen_tables(thd, false))
|
||||
result= true;
|
||||
/*
|
||||
Since downgrade_lock() won't do anything with shared
|
||||
@ -811,7 +811,10 @@ void close_thread_tables(THD *thd)
|
||||
we will exit this function a few lines below.
|
||||
*/
|
||||
if (! thd->lex->requires_prelocking())
|
||||
{
|
||||
thd->locked_tables_list.reopen_tables(thd, true);
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
/*
|
||||
We are in the top-level statement of a prelocked statement,
|
||||
@ -2298,7 +2301,8 @@ void Locked_tables_list::unlink_from_list(THD *thd,
|
||||
If mode is not LTM_LOCK_TABLES, we needn't do anything. Moreover,
|
||||
outside this mode pos_in_locked_tables value is not trustworthy.
|
||||
*/
|
||||
if (thd->locked_tables_mode != LTM_LOCK_TABLES)
|
||||
if (thd->locked_tables_mode != LTM_LOCK_TABLES &&
|
||||
thd->locked_tables_mode != LTM_PRELOCKED_UNDER_LOCK_TABLES)
|
||||
return;
|
||||
|
||||
/*
|
||||
@ -2402,7 +2406,7 @@ unlink_all_closed_tables(THD *thd, MYSQL_LOCK *lock, size_t reopen_count)
|
||||
*/
|
||||
|
||||
bool
|
||||
Locked_tables_list::reopen_tables(THD *thd)
|
||||
Locked_tables_list::reopen_tables(THD *thd, bool need_reopen)
|
||||
{
|
||||
Open_table_context ot_ctx(thd, MYSQL_OPEN_REOPEN);
|
||||
uint reopen_count= 0;
|
||||
@ -2413,8 +2417,20 @@ Locked_tables_list::reopen_tables(THD *thd)
|
||||
for (TABLE_LIST *table_list= m_locked_tables;
|
||||
table_list; table_list= table_list->next_global)
|
||||
{
|
||||
if (table_list->table) /* The table was not closed */
|
||||
continue;
|
||||
if (need_reopen)
|
||||
{
|
||||
if (!table_list->table || !table_list->table->needs_reopen())
|
||||
continue;
|
||||
/* no need to remove the table from the TDC here, thus (TABLE*)1 */
|
||||
close_all_tables_for_name(thd, table_list->table->s,
|
||||
HA_EXTRA_NOT_USED, (TABLE*)1);
|
||||
DBUG_ASSERT(table_list->table == NULL);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (table_list->table) /* The table was not closed */
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Links into thd->open_tables upon success */
|
||||
if (open_table(thd, table_list, &ot_ctx))
|
||||
@ -7253,7 +7269,7 @@ bool setup_fields(THD *thd, Ref_ptr_array ref_pointer_array,
|
||||
List<Item> *sum_func_list, List<Item> *pre_fix,
|
||||
bool allow_sum_func)
|
||||
{
|
||||
reg2 Item *item;
|
||||
Item *item;
|
||||
enum_column_usage saved_column_usage= thd->column_usage;
|
||||
nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
|
||||
List_iterator<Item> it(fields);
|
||||
|
@ -1,4 +1,6 @@
|
||||
/* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
Copyright (c) 2011, 2018, MariaDB
|
||||
|
||||
|
||||
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
|
||||
|
@ -1910,7 +1910,7 @@ public:
|
||||
void unlink_all_closed_tables(THD *thd,
|
||||
MYSQL_LOCK *lock,
|
||||
size_t reopen_count);
|
||||
bool reopen_tables(THD *thd);
|
||||
bool reopen_tables(THD *thd, bool need_reopen);
|
||||
bool restore_lock(THD *thd, TABLE_LIST *dst_table_list, TABLE *table,
|
||||
MYSQL_LOCK *lock);
|
||||
void add_back_last_deleted_lock(TABLE_LIST *dst_table_list);
|
||||
|
@ -338,7 +338,7 @@ static void del_dbopt(const char *path)
|
||||
static bool write_db_opt(THD *thd, const char *path,
|
||||
Schema_specification_st *create)
|
||||
{
|
||||
register File file;
|
||||
File file;
|
||||
char buf[256]; // Should be enough for one option
|
||||
bool error=1;
|
||||
|
||||
|
@ -89,7 +89,7 @@ static int write_delayed(THD *thd, TABLE *table, enum_duplicates duplic,
|
||||
LEX_STRING query, bool ignore, bool log_on);
|
||||
static void end_delayed_insert(THD *thd);
|
||||
pthread_handler_t handle_delayed_insert(void *arg);
|
||||
static void unlink_blobs(register TABLE *table);
|
||||
static void unlink_blobs(TABLE *table);
|
||||
#endif
|
||||
static bool check_view_insertability(THD *thd, TABLE_LIST *view);
|
||||
|
||||
@ -3198,7 +3198,7 @@ pthread_handler_t handle_delayed_insert(void *arg)
|
||||
|
||||
/* Remove all pointers to data for blob fields so that original table doesn't try to free them */
|
||||
|
||||
static void unlink_blobs(register TABLE *table)
|
||||
static void unlink_blobs(TABLE *table)
|
||||
{
|
||||
for (Field **ptr=table->field ; *ptr ; ptr++)
|
||||
{
|
||||
@ -3209,7 +3209,7 @@ static void unlink_blobs(register TABLE *table)
|
||||
|
||||
/* Free blobs stored in current row */
|
||||
|
||||
static void free_delayed_insert_blobs(register TABLE *table)
|
||||
static void free_delayed_insert_blobs(TABLE *table)
|
||||
{
|
||||
for (Field **ptr=table->field ; *ptr ; ptr++)
|
||||
{
|
||||
@ -3221,7 +3221,7 @@ static void free_delayed_insert_blobs(register TABLE *table)
|
||||
|
||||
/* set value field for blobs to point to data in record */
|
||||
|
||||
static void set_delayed_insert_blobs(register TABLE *table)
|
||||
static void set_delayed_insert_blobs(TABLE *table)
|
||||
{
|
||||
for (Field **ptr=table->field ; *ptr ; ptr++)
|
||||
{
|
||||
|
@ -1078,7 +1078,7 @@ Lex_input_stream::unescape(CHARSET_INFO *cs, char *to,
|
||||
bool Lex_input_stream::get_text(Lex_string_with_metadata_st *dst, uint sep,
|
||||
int pre_skip, int post_skip)
|
||||
{
|
||||
reg1 uchar c;
|
||||
uchar c;
|
||||
uint found_escape=0;
|
||||
CHARSET_INFO *cs= m_thd->charset();
|
||||
|
||||
@ -1261,7 +1261,7 @@ static inline uint int_token(const char *str,uint length)
|
||||
*/
|
||||
bool consume_comment(Lex_input_stream *lip, int remaining_recursions_permitted)
|
||||
{
|
||||
reg1 uchar c;
|
||||
uchar c;
|
||||
while (! lip->eof())
|
||||
{
|
||||
c= lip->yyGet();
|
||||
@ -1405,7 +1405,7 @@ int ORAlex(YYSTYPE *yylval, THD *thd)
|
||||
|
||||
static int lex_one_token(YYSTYPE *yylval, THD *thd)
|
||||
{
|
||||
reg1 uchar UNINIT_VAR(c);
|
||||
uchar UNINIT_VAR(c);
|
||||
bool comment_closed;
|
||||
int tokval, result_state;
|
||||
uint length;
|
||||
|
@ -8145,7 +8145,7 @@ TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
|
||||
List<String> *partition_names,
|
||||
LEX_STRING *option)
|
||||
{
|
||||
register TABLE_LIST *ptr;
|
||||
TABLE_LIST *ptr;
|
||||
TABLE_LIST *UNINIT_VAR(previous_table_ref); /* The table preceding the current one. */
|
||||
LEX_CSTRING alias_str;
|
||||
LEX *lex= thd->lex;
|
||||
|
@ -1,5 +1,5 @@
|
||||
/* Copyright (c) 2005, 2017, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2017, SkySQL Ab.
|
||||
Copyright (c) 2009, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -6785,7 +6785,7 @@ static void alter_partition_lock_handling(ALTER_PARTITION_PARAM_TYPE *lpt)
|
||||
thd->set_stmt_da(&tmp_stmt_da);
|
||||
}
|
||||
|
||||
if (thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_list.reopen_tables(thd, false))
|
||||
sql_print_warning("We failed to reacquire LOCKs in ALTER TABLE");
|
||||
|
||||
if (stmt_da)
|
||||
@ -6991,7 +6991,7 @@ err_exclusive_lock:
|
||||
thd->set_stmt_da(&tmp_stmt_da);
|
||||
}
|
||||
|
||||
if (thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_list.reopen_tables(thd, false))
|
||||
sql_print_warning("We failed to reacquire LOCKs in ALTER TABLE");
|
||||
|
||||
if (stmt_da)
|
||||
|
@ -630,7 +630,7 @@ bool Sql_cmd_alter_table_exchange_partition::
|
||||
better to keep master/slave in consistent state. Alternative would be to
|
||||
try to revert the exchange operation and issue error.
|
||||
*/
|
||||
(void) thd->locked_tables_list.reopen_tables(thd);
|
||||
(void) thd->locked_tables_list.reopen_tables(thd, false);
|
||||
|
||||
if ((error= write_bin_log(thd, TRUE, thd->query(), thd->query_length())))
|
||||
{
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
Copyright (c) 2005, 2013, Oracle and/or its affiliates.
|
||||
Copyright (c) 2010, 2017, MariaDB Corporation.
|
||||
Copyright (c) 2005, 2018, Oracle and/or its affiliates.
|
||||
Copyright (c) 2010, 2018, MariaDB Corporation
|
||||
|
||||
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
|
||||
@ -2330,6 +2330,16 @@ bool mysql_uninstall_plugin(THD *thd, const LEX_CSTRING *name,
|
||||
if (! (table= open_ltable(thd, &tables, TL_WRITE, MYSQL_LOCK_IGNORE_TIMEOUT)))
|
||||
DBUG_RETURN(TRUE);
|
||||
|
||||
if (!table->key_info)
|
||||
{
|
||||
my_printf_error(ER_UNKNOWN_ERROR,
|
||||
"The table %s.%s has no primary key. "
|
||||
"Please check the table definition and "
|
||||
"create the primary key accordingly.", MYF(0),
|
||||
table->s->db.str, table->s->table_name.str);
|
||||
DBUG_RETURN(TRUE);
|
||||
}
|
||||
|
||||
/*
|
||||
Pre-acquire audit plugins for events that may potentially occur
|
||||
during [UN]INSTALL PLUGIN.
|
||||
|
@ -427,7 +427,7 @@ static bool send_prep_stmt(Prepared_statement *stmt,
|
||||
|
||||
static ulong get_param_length(uchar **packet, ulong len)
|
||||
{
|
||||
reg1 uchar *pos= *packet;
|
||||
uchar *pos= *packet;
|
||||
if (len < 1)
|
||||
return 0;
|
||||
if (*pos < 251)
|
||||
|
@ -1,5 +1,5 @@
|
||||
/* Copyright (c) 2000, 2014, Oracle and/or its affiliates.
|
||||
Copyright (c) 2010, 2014, Monty Program Ab.
|
||||
/* Copyright (c) 2000, 2018, Oracle and/or its affiliates.
|
||||
Copyright (c) 2010, 2018, Monty Program Ab.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
|
@ -351,7 +351,7 @@ bool handle_select(THD *thd, LEX *lex, select_result *result,
|
||||
ulong setup_tables_done_option)
|
||||
{
|
||||
bool res;
|
||||
register SELECT_LEX *select_lex = &lex->select_lex;
|
||||
SELECT_LEX *select_lex = &lex->select_lex;
|
||||
DBUG_ENTER("handle_select");
|
||||
MYSQL_SELECT_START(thd->query());
|
||||
|
||||
|
@ -2617,7 +2617,7 @@ int collect_statistics_for_index(THD *thd, TABLE *table, uint index)
|
||||
DBUG_ENTER("collect_statistics_for_index");
|
||||
|
||||
/* No statistics for FULLTEXT indexes. */
|
||||
if (key_info->flags & HA_FULLTEXT)
|
||||
if (key_info->flags & (HA_FULLTEXT|HA_SPATIAL))
|
||||
DBUG_RETURN(rc);
|
||||
|
||||
Index_prefix_calc index_prefix_calc(thd, table, key_info);
|
||||
|
@ -667,8 +667,8 @@ int String::strstr(const String &s,uint32 offset)
|
||||
if (!s.length())
|
||||
return ((int) offset); // Empty string is always found
|
||||
|
||||
register const char *str = Ptr+offset;
|
||||
register const char *search=s.ptr();
|
||||
const char *str = Ptr+offset;
|
||||
const char *search=s.ptr();
|
||||
const char *end=Ptr+str_length-s.length()+1;
|
||||
const char *search_end=s.ptr()+s.length();
|
||||
skip:
|
||||
@ -676,7 +676,7 @@ skip:
|
||||
{
|
||||
if (*str++ == *search)
|
||||
{
|
||||
register char *i,*j;
|
||||
char *i,*j;
|
||||
i=(char*) str; j=(char*) search+1;
|
||||
while (j != search_end)
|
||||
if (*i++ != *j++) goto skip;
|
||||
@ -697,8 +697,8 @@ int String::strrstr(const String &s,uint32 offset)
|
||||
{
|
||||
if (!s.length())
|
||||
return offset; // Empty string is always found
|
||||
register const char *str = Ptr+offset-1;
|
||||
register const char *search=s.ptr()+s.length()-1;
|
||||
const char *str = Ptr+offset-1;
|
||||
const char *search=s.ptr()+s.length()-1;
|
||||
|
||||
const char *end=Ptr+s.length()-2;
|
||||
const char *search_end=s.ptr()-1;
|
||||
@ -707,7 +707,7 @@ skip:
|
||||
{
|
||||
if (*str-- == *search)
|
||||
{
|
||||
register char *i,*j;
|
||||
char *i,*j;
|
||||
i=(char*) str; j=(char*) search-1;
|
||||
while (j != search_end)
|
||||
if (*i-- != *j--) goto skip;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
Copyright (c) 2000, 2016, Oracle and/or its affiliates.
|
||||
Copyright (c) 2010, 2017, MariaDB Corporation.
|
||||
Copyright (c) 2010, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -5173,7 +5173,7 @@ bool mysql_create_table(THD *thd, TABLE_LIST *create_table,
|
||||
This should always work as we have a meta lock on the table.
|
||||
*/
|
||||
thd->locked_tables_list.add_back_last_deleted_lock(pos_in_locked_tables);
|
||||
if (thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_list.reopen_tables(thd, false))
|
||||
{
|
||||
thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
|
||||
result= 1;
|
||||
@ -5625,7 +5625,7 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
|
||||
This should always work as we have a meta lock on the table.
|
||||
*/
|
||||
thd->locked_tables_list.add_back_last_deleted_lock(pos_in_locked_tables);
|
||||
if (thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_list.reopen_tables(thd, false))
|
||||
{
|
||||
thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
|
||||
res= 1; // We got an error
|
||||
@ -7633,7 +7633,7 @@ static bool mysql_inplace_alter_table(THD *thd,
|
||||
HA_EXTRA_PREPARE_FOR_RENAME :
|
||||
HA_EXTRA_NOT_USED,
|
||||
NULL);
|
||||
if (thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_list.reopen_tables(thd, false))
|
||||
thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
|
||||
/* QQ; do something about metadata locks ? */
|
||||
}
|
||||
@ -9967,7 +9967,7 @@ bool mysql_alter_table(THD *thd, const LEX_CSTRING *new_db, const LEX_CSTRING *n
|
||||
|
||||
end_inplace:
|
||||
|
||||
if (thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_list.reopen_tables(thd, false))
|
||||
goto err_with_mdl_after_alter;
|
||||
|
||||
THD_STAGE_INFO(thd, stage_end);
|
||||
|
@ -1,5 +1,6 @@
|
||||
/*
|
||||
Copyright (c) 2004, 2012, Oracle and/or its affiliates.
|
||||
Copyright (c) 2010, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -588,7 +589,7 @@ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create)
|
||||
Ignore the return value for now. It's better to
|
||||
keep master/slave in consistent state.
|
||||
*/
|
||||
if (thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_list.reopen_tables(thd, false))
|
||||
thd->clear_error();
|
||||
|
||||
/*
|
||||
|
@ -1,5 +1,5 @@
|
||||
/* Copyright (c) 2010, 2015, Oracle and/or its affiliates.
|
||||
Copyright (c) 2013, 2015, MariaDB
|
||||
Copyright (c) 2012, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -427,7 +427,7 @@ bool Sql_cmd_truncate_table::truncate_table(THD *thd, TABLE_LIST *table_ref)
|
||||
*/
|
||||
error= dd_recreate_table(thd, table_ref->db.str, table_ref->table_name.str);
|
||||
|
||||
if (thd->locked_tables_mode && thd->locked_tables_list.reopen_tables(thd))
|
||||
if (thd->locked_tables_mode && thd->locked_tables_list.reopen_tables(thd, false))
|
||||
thd->locked_tables_list.unlink_all_closed_tables(thd, NULL, 0);
|
||||
|
||||
/* No need to binlog a failed truncate-by-recreate. */
|
||||
@ -500,4 +500,3 @@ bool Sql_cmd_truncate_table::execute(THD *thd)
|
||||
|
||||
DBUG_RETURN(res);
|
||||
}
|
||||
|
||||
|
23
sql/table.cc
23
sql/table.cc
@ -1,5 +1,5 @@
|
||||
/* Copyright (c) 2000, 2015, Oracle and/or its affiliates.
|
||||
Copyright (c) 2008, 2016, MariaDB
|
||||
/* Copyright (c) 2000, 2017, Oracle and/or its affiliates.
|
||||
Copyright (c) 2008, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -3539,7 +3539,7 @@ partititon_err:
|
||||
table TABLE object to free
|
||||
*/
|
||||
|
||||
int closefrm(register TABLE *table)
|
||||
int closefrm(TABLE *table)
|
||||
{
|
||||
int error=0;
|
||||
DBUG_ENTER("closefrm");
|
||||
@ -3576,7 +3576,7 @@ int closefrm(register TABLE *table)
|
||||
|
||||
/* Deallocate temporary blob storage */
|
||||
|
||||
void free_blobs(register TABLE *table)
|
||||
void free_blobs(TABLE *table)
|
||||
{
|
||||
uint *ptr, *end;
|
||||
for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ;
|
||||
@ -4195,7 +4195,7 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
|
||||
|
||||
/* Whether the table definition has already been validated. */
|
||||
if (table->s->table_field_def_cache == table_def)
|
||||
DBUG_RETURN(FALSE);
|
||||
goto end;
|
||||
|
||||
if (table->s->fields != table_def->count)
|
||||
{
|
||||
@ -4228,6 +4228,8 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
|
||||
is backward compatible.
|
||||
*/
|
||||
}
|
||||
else
|
||||
{
|
||||
StringBuffer<1024> sql_type(system_charset_info);
|
||||
sql_type.extra_allocation(256); // Allocate min 256 characters at once
|
||||
for (i=0 ; i < table_def->count; i++, field_def++)
|
||||
@ -4313,6 +4315,7 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
|
||||
error= TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (table_def->primary_key_parts)
|
||||
{
|
||||
@ -4357,6 +4360,16 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
|
||||
if (! error)
|
||||
table->s->table_field_def_cache= table_def;
|
||||
|
||||
end:
|
||||
|
||||
if (has_keys && !error && !table->key_info)
|
||||
{
|
||||
report_error(0, "Incorrect definition of table %s.%s: "
|
||||
"indexes are missing",
|
||||
table->s->db.str, table->alias.c_ptr());
|
||||
error= TRUE;
|
||||
}
|
||||
|
||||
DBUG_RETURN(error);
|
||||
}
|
||||
|
||||
|
10
sql/table.h
10
sql/table.h
@ -1,8 +1,7 @@
|
||||
#ifndef TABLE_INCLUDED
|
||||
#define TABLE_INCLUDED
|
||||
/* Copyright (c) 2000, 2013, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2014, SkySQL Ab.
|
||||
Copyright (c) 2016, 2017, MariaDB Corporation.
|
||||
/* Copyright (c) 2000, 2017, Oracle and/or its affiliates.
|
||||
Copyright (c) 2009, 2018, MariaDB
|
||||
|
||||
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
|
||||
@ -487,10 +486,11 @@ typedef struct st_table_field_def
|
||||
class Table_check_intact
|
||||
{
|
||||
protected:
|
||||
bool has_keys;
|
||||
virtual void report_error(uint code, const char *fmt, ...)= 0;
|
||||
|
||||
public:
|
||||
Table_check_intact() {}
|
||||
Table_check_intact(bool keys= false) : has_keys(keys) {}
|
||||
virtual ~Table_check_intact() {}
|
||||
|
||||
/** Checks whether a table is intact. */
|
||||
@ -505,6 +505,8 @@ class Table_check_intact_log_error : public Table_check_intact
|
||||
{
|
||||
protected:
|
||||
void report_error(uint, const char *fmt, ...);
|
||||
public:
|
||||
Table_check_intact_log_error() : Table_check_intact(true) {}
|
||||
};
|
||||
|
||||
|
||||
|
@ -209,7 +209,7 @@ static double get_merge_many_buffs_cost(uint *buffer,
|
||||
uint last_n_elems, int elem_size,
|
||||
uint compare_factor)
|
||||
{
|
||||
register int i;
|
||||
int i;
|
||||
double total_cost= 0.0;
|
||||
uint *buff_elems= buffer; /* #s of elements in each of merged sequences */
|
||||
|
||||
|
@ -77,7 +77,7 @@ public:
|
||||
inline static int get_cost_calc_buff_size(size_t nkeys, uint key_size,
|
||||
size_t max_in_memory_size)
|
||||
{
|
||||
register size_t max_elems_in_tree=
|
||||
size_t max_elems_in_tree=
|
||||
max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size);
|
||||
return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
|
||||
}
|
||||
|
@ -96,7 +96,7 @@ extern uint hp_rb_key_length(HP_KEYDEF *keydef, const uchar *key);
|
||||
extern uint hp_rb_null_key_length(HP_KEYDEF *keydef, const uchar *key);
|
||||
extern uint hp_rb_var_key_length(HP_KEYDEF *keydef, const uchar *key);
|
||||
extern my_bool hp_if_null_in_key(HP_KEYDEF *keyinfo, const uchar *record);
|
||||
extern int hp_close(register HP_INFO *info);
|
||||
extern int hp_close(HP_INFO *info);
|
||||
extern void hp_clear(HP_SHARE *info);
|
||||
extern void hp_clear_keys(HP_SHARE *info);
|
||||
extern uint hp_rb_pack_key(HP_KEYDEF *keydef, uchar *key, const uchar *old,
|
||||
|
@ -1,10 +1,10 @@
|
||||
/*****************************************************************************
|
||||
|
||||
Copyright (c) 2000, 2017, Oracle and/or its affiliates. All Rights Reserved.
|
||||
Copyright (c) 2013, 2018, MariaDB Corporation.
|
||||
Copyright (c) 2000, 2018, Oracle and/or its affiliates. All Rights Reserved.
|
||||
Copyright (c) 2008, 2009 Google Inc.
|
||||
Copyright (c) 2009, Percona Inc.
|
||||
Copyright (c) 2012, Facebook Inc.
|
||||
Copyright (c) 2013, 2018, MariaDB Corporation.
|
||||
|
||||
Portions of this file contain modifications contributed and copyrighted by
|
||||
Google, Inc. Those modifications are gratefully acknowledged and are described
|
||||
@ -12628,10 +12628,9 @@ create_table_info_t::create_table_update_dict()
|
||||
dict_table_autoinc_unlock(innobase_table);
|
||||
}
|
||||
|
||||
dict_table_close(innobase_table, FALSE, FALSE);
|
||||
|
||||
innobase_parse_hint_from_comment(m_thd, innobase_table, m_form->s);
|
||||
|
||||
dict_table_close(innobase_table, FALSE, FALSE);
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
||||
@ -15331,6 +15330,7 @@ ha_innobase::start_stmt(
|
||||
case SQLCOM_INSERT:
|
||||
case SQLCOM_UPDATE:
|
||||
case SQLCOM_DELETE:
|
||||
case SQLCOM_REPLACE:
|
||||
init_table_handle_for_HANDLER();
|
||||
m_prebuilt->select_lock_type = LOCK_X;
|
||||
m_prebuilt->stored_select_lock_type = LOCK_X;
|
||||
|
@ -2785,14 +2785,9 @@ innobase_create_key_defs(
|
||||
ulint primary_key_number;
|
||||
|
||||
if (new_primary) {
|
||||
if (n_add == 0) {
|
||||
DBUG_ASSERT(got_default_clust);
|
||||
DBUG_ASSERT(altered_table->s->primary_key
|
||||
== 0);
|
||||
primary_key_number = 0;
|
||||
} else {
|
||||
primary_key_number = *add;
|
||||
}
|
||||
DBUG_ASSERT(n_add || got_default_clust);
|
||||
DBUG_ASSERT(n_add || !altered_table->s->primary_key);
|
||||
primary_key_number = altered_table->s->primary_key;
|
||||
} else if (got_default_clust) {
|
||||
/* Create the GEN_CLUST_INDEX */
|
||||
index_def_t* index = indexdef++;
|
||||
|
@ -479,6 +479,7 @@ dtype_get_fixed_size_low(
|
||||
return(0);
|
||||
}
|
||||
#endif /* UNIV_DEBUG */
|
||||
/* fall through */
|
||||
case DATA_CHAR:
|
||||
case DATA_FIXBINARY:
|
||||
case DATA_INT:
|
||||
@ -552,6 +553,7 @@ dtype_get_min_size_low(
|
||||
return(0);
|
||||
}
|
||||
#endif /* UNIV_DEBUG */
|
||||
/* fall through */
|
||||
case DATA_CHAR:
|
||||
case DATA_FIXBINARY:
|
||||
case DATA_INT:
|
||||
|
@ -86,6 +86,11 @@ struct Pool {
|
||||
for (Element* elem = m_start; elem != m_last; ++elem) {
|
||||
|
||||
ut_ad(elem->m_pool == this);
|
||||
/* Unpoison the memory for AddressSanitizer */
|
||||
MEM_UNDEFINED(&elem->m_type, sizeof elem->m_type);
|
||||
/* Declare the contents as initialized for Valgrind;
|
||||
we checked this in mem_free(). */
|
||||
UNIV_MEM_VALID(&elem->m_type, sizeof elem->m_type);
|
||||
Factory::destroy(&elem->m_type);
|
||||
}
|
||||
|
||||
@ -122,7 +127,18 @@ struct Pool {
|
||||
|
||||
m_lock_strategy.exit();
|
||||
|
||||
return(elem != NULL ? &elem->m_type : 0);
|
||||
if (elem) {
|
||||
/* Unpoison the memory for AddressSanitizer */
|
||||
MEM_UNDEFINED(&elem->m_type, sizeof elem->m_type);
|
||||
/* Declare the memory initialized for Valgrind.
|
||||
The trx_t that are released to the pool are
|
||||
actually initialized; we checked that by
|
||||
UNIV_MEM_ASSERT_RW() in mem_free() below. */
|
||||
UNIV_MEM_VALID(&elem->m_type, sizeof elem->m_type);
|
||||
return &elem->m_type;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/** Add the object to the pool.
|
||||
@ -133,8 +149,10 @@ struct Pool {
|
||||
byte* p = reinterpret_cast<byte*>(ptr + 1);
|
||||
|
||||
elem = reinterpret_cast<Element*>(p - sizeof(*elem));
|
||||
UNIV_MEM_ASSERT_RW(&elem->m_type, sizeof elem->m_type);
|
||||
|
||||
elem->m_pool->put(elem);
|
||||
MEM_NOACCESS(&elem->m_type, sizeof elem->m_type);
|
||||
}
|
||||
|
||||
protected:
|
||||
|
@ -87,17 +87,13 @@ page_dir_find_owner_slot(
|
||||
/*=====================*/
|
||||
const rec_t* rec) /*!< in: the physical record */
|
||||
{
|
||||
const page_t* page;
|
||||
register uint16 rec_offs_bytes;
|
||||
register const page_dir_slot_t* slot;
|
||||
register const page_dir_slot_t* first_slot;
|
||||
register const rec_t* r = rec;
|
||||
|
||||
ut_ad(page_rec_check(rec));
|
||||
|
||||
page = page_align(rec);
|
||||
first_slot = page_dir_get_nth_slot(page, 0);
|
||||
slot = page_dir_get_nth_slot(page, page_dir_get_n_slots(page) - 1);
|
||||
const page_t* page = page_align(rec);
|
||||
const page_dir_slot_t* first_slot = page_dir_get_nth_slot(page, 0);
|
||||
const page_dir_slot_t* slot = page_dir_get_nth_slot(
|
||||
page, page_dir_get_n_slots(page) - 1);
|
||||
const rec_t* r = rec;
|
||||
|
||||
if (page_is_comp(page)) {
|
||||
while (rec_get_n_owned_new(r) == 0) {
|
||||
@ -113,7 +109,7 @@ page_dir_find_owner_slot(
|
||||
}
|
||||
}
|
||||
|
||||
rec_offs_bytes = mach_encode_2(r - page);
|
||||
uint16 rec_offs_bytes = mach_encode_2(r - page);
|
||||
|
||||
while (UNIV_LIKELY(*(uint16*) slot != rec_offs_bytes)) {
|
||||
|
||||
|
@ -490,6 +490,14 @@ void trx_free(trx_t*& trx)
|
||||
ut_ad(trx->will_lock == 0);
|
||||
|
||||
trx_pools->mem_free(trx);
|
||||
/* Unpoison the memory for innodb_monitor_set_option;
|
||||
it is operating also on the freed transaction objects. */
|
||||
MEM_UNDEFINED(&trx->mutex, sizeof trx->mutex);
|
||||
MEM_UNDEFINED(&trx->undo_mutex, sizeof trx->undo_mutex);
|
||||
/* Declare the contents as initialized for Valgrind;
|
||||
we checked that it was initialized in trx_pools->mem_free(trx). */
|
||||
UNIV_MEM_VALID(&trx->mutex, sizeof trx->mutex);
|
||||
UNIV_MEM_VALID(&trx->undo_mutex, sizeof trx->undo_mutex);
|
||||
|
||||
trx = NULL;
|
||||
}
|
||||
|
@ -3087,7 +3087,7 @@ static enum data_file_type maria_row_type(HA_CREATE_INFO *info)
|
||||
}
|
||||
|
||||
|
||||
int ha_maria::create(const char *name, register TABLE *table_arg,
|
||||
int ha_maria::create(const char *name, TABLE *table_arg,
|
||||
HA_CREATE_INFO *ha_create_info)
|
||||
{
|
||||
int error;
|
||||
|
@ -190,8 +190,7 @@ MARIA_RECORD_POS _ma_write_init_block_record(MARIA_HA *info,
|
||||
const uchar *record);
|
||||
my_bool _ma_write_block_record(MARIA_HA *info, const uchar *record);
|
||||
my_bool _ma_write_abort_block_record(MARIA_HA *info);
|
||||
my_bool _ma_compare_block_record(register MARIA_HA *info,
|
||||
register const uchar *record);
|
||||
my_bool _ma_compare_block_record(MARIA_HA *info, const uchar *record);
|
||||
void _ma_compact_block_page(MARIA_SHARE *share, uchar *buff, uint rownr,
|
||||
my_bool extend_block, TrID min_read_from,
|
||||
uint min_row_length);
|
||||
|
@ -110,7 +110,7 @@ typedef struct st_maria_sort_param
|
||||
int (*key_read)(struct st_maria_sort_param *, uchar *);
|
||||
int (*key_write)(struct st_maria_sort_param *, const uchar *);
|
||||
void (*lock_in_memory)(HA_CHECK *);
|
||||
int (*write_keys)(struct st_maria_sort_param *, register uchar **,
|
||||
int (*write_keys)(struct st_maria_sort_param *, uchar **,
|
||||
ulonglong , struct st_buffpek *, IO_CACHE *);
|
||||
my_off_t (*read_to_buffer)(IO_CACHE *,struct st_buffpek *, uint);
|
||||
int (*write_key)(struct st_maria_sort_param *, IO_CACHE *,uchar *,
|
||||
@ -1052,7 +1052,7 @@ my_off_t _ma_no_keypos_to_recpos(MARIA_SHARE *share, my_off_t pos);
|
||||
extern my_bool _ma_ck_write(MARIA_HA *info, MARIA_KEY *key);
|
||||
extern my_bool _ma_enlarge_root(MARIA_HA *info, MARIA_KEY *key,
|
||||
MARIA_RECORD_POS *root);
|
||||
int _ma_insert(register MARIA_HA *info, MARIA_KEY *key,
|
||||
int _ma_insert(MARIA_HA *info, MARIA_KEY *key,
|
||||
MARIA_PAGE *anc_page, uchar *key_pos, uchar *key_buff,
|
||||
MARIA_PAGE *father_page, uchar *father_key_pos,
|
||||
my_bool insert_last);
|
||||
@ -1094,7 +1094,7 @@ extern void _ma_store_bin_pack_key(MARIA_KEYDEF *keyinfo, uchar *key_pos,
|
||||
MARIA_KEY_PARAM *s_temp);
|
||||
|
||||
extern my_bool _ma_ck_delete(MARIA_HA *info, MARIA_KEY *key);
|
||||
extern my_bool _ma_ck_real_delete(register MARIA_HA *info, MARIA_KEY *key,
|
||||
extern my_bool _ma_ck_real_delete(MARIA_HA *info, MARIA_KEY *key,
|
||||
my_off_t *root);
|
||||
extern int _ma_readinfo(MARIA_HA *info, int lock_flag, int check_keybuffer);
|
||||
extern int _ma_writeinfo(MARIA_HA *info, uint options);
|
||||
@ -1166,7 +1166,7 @@ extern my_bool _ma_fetch_keypage(MARIA_PAGE *page, MARIA_HA *info,
|
||||
extern my_bool _ma_write_keypage(MARIA_PAGE *page,
|
||||
enum pagecache_page_lock lock, int level);
|
||||
extern int _ma_dispose(MARIA_HA *info, my_off_t pos, my_bool page_not_read);
|
||||
extern my_off_t _ma_new(register MARIA_HA *info, int level,
|
||||
extern my_off_t _ma_new(MARIA_HA *info, int level,
|
||||
MARIA_PINNED_PAGE **page_link);
|
||||
extern my_bool _ma_compact_keypage(MARIA_PAGE *page, TrID min_read_from);
|
||||
extern uint transid_store_packed(MARIA_HA *info, uchar *to, ulonglong trid);
|
||||
@ -1354,7 +1354,7 @@ extern MARIA_HA *_ma_test_if_reopen(const char *filename);
|
||||
my_bool _ma_check_table_is_closed(const char *name, const char *where);
|
||||
int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share);
|
||||
int _ma_open_keyfile(MARIA_SHARE *share);
|
||||
void _ma_setup_functions(register MARIA_SHARE *share);
|
||||
void _ma_setup_functions(MARIA_SHARE *share);
|
||||
my_bool _ma_dynmap_file(MARIA_HA *info, my_off_t size);
|
||||
void _ma_remap_file(MARIA_HA *info, my_off_t size);
|
||||
|
||||
@ -1436,7 +1436,7 @@ extern my_bool maria_flush_log_for_page_none(PAGECACHE_IO_HOOK_ARGS *args);
|
||||
extern PAGECACHE *maria_log_pagecache;
|
||||
extern void ma_set_index_cond_func(MARIA_HA *info, index_cond_func_t func,
|
||||
void *func_arg);
|
||||
ICP_RESULT ma_check_index_cond(register MARIA_HA *info, uint keynr, uchar *record);
|
||||
ICP_RESULT ma_check_index_cond(MARIA_HA *info, uint keynr, uchar *record);
|
||||
|
||||
extern my_bool ma_yield_and_check_if_killed(MARIA_HA *info, int inx);
|
||||
extern my_bool ma_killed_standalone(MARIA_HA *);
|
||||
|
@ -2118,7 +2118,7 @@ void ha_myisam::update_create_info(HA_CREATE_INFO *create_info)
|
||||
}
|
||||
|
||||
|
||||
int ha_myisam::create(const char *name, register TABLE *table_arg,
|
||||
int ha_myisam::create(const char *name, TABLE *table_arg,
|
||||
HA_CREATE_INFO *ha_create_info)
|
||||
{
|
||||
int error;
|
||||
|
@ -539,8 +539,7 @@ extern uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
|
||||
uchar *key, uchar *keypos,
|
||||
uint *return_key_length);
|
||||
extern uint _mi_keylength(MI_KEYDEF *keyinfo, uchar *key);
|
||||
extern uint _mi_keylength_part(MI_KEYDEF *keyinfo, register uchar *key,
|
||||
HA_KEYSEG *end);
|
||||
extern uint _mi_keylength_part(MI_KEYDEF *keyinfo, uchar *key, HA_KEYSEG *end);
|
||||
extern uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, uchar *from);
|
||||
extern int _mi_search_next(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
|
||||
uint key_length, uint nextflag, my_off_t pos);
|
||||
@ -719,12 +718,12 @@ my_bool check_table_is_closed(const char *name, const char *where);
|
||||
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share);
|
||||
|
||||
int mi_open_keyfile(MYISAM_SHARE *share);
|
||||
void mi_setup_functions(register MYISAM_SHARE *share);
|
||||
void mi_setup_functions(MYISAM_SHARE *share);
|
||||
my_bool mi_dynmap_file(MI_INFO *info, my_off_t size);
|
||||
int mi_munmap_file(MI_INFO *info);
|
||||
void mi_remap_file(MI_INFO *info, my_off_t size);
|
||||
|
||||
ICP_RESULT mi_check_index_cond(register MI_INFO *info, uint keynr, uchar *record);
|
||||
ICP_RESULT mi_check_index_cond(MI_INFO *info, uint keynr, uchar *record);
|
||||
/* Functions needed by mi_check */
|
||||
int killed_ptr(HA_CHECK *param);
|
||||
void mi_check_print_error(HA_CHECK *param, const char *fmt, ...);
|
||||
|
@ -1575,7 +1575,7 @@ int ha_myisammrg::create_mrg(const char *name, HA_CREATE_INFO *create_info)
|
||||
}
|
||||
|
||||
|
||||
int ha_myisammrg::create(const char *name, register TABLE *form,
|
||||
int ha_myisammrg::create(const char *name, TABLE *form,
|
||||
HA_CREATE_INFO *create_info)
|
||||
{
|
||||
char buff[FN_REFLEN];
|
||||
|
@ -27,6 +27,8 @@
|
||||
#define BOOST_ALL_NO_LIB 1
|
||||
#define BOOST_NO_RTTI 1
|
||||
#define BOOST_NO_TYPEID 1
|
||||
#define BOOST_NO_HASH 1
|
||||
#define BOOST_NO_SLIST 1
|
||||
|
||||
#ifdef DBUG_OFF
|
||||
#define NDEBUG 1
|
||||
|
@ -27,9 +27,6 @@
|
||||
#include "oqgraph_judy.h"
|
||||
#include "oqgraph_thunk.h"
|
||||
|
||||
#define BOOST_NO_HASH 1
|
||||
#define BOOST_NO_SLIST 1
|
||||
|
||||
#include <boost/graph/directed_graph.hpp>
|
||||
#include <boost/graph/adjacency_iterator.hpp>
|
||||
|
||||
|
@ -2215,7 +2215,7 @@ start_mutex_wait_v1(PSI_mutex_locker_state *state,
|
||||
if (! pfs_mutex->m_enabled)
|
||||
return NULL;
|
||||
|
||||
register uint flags;
|
||||
uint flags;
|
||||
ulonglong timer_start= 0;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
@ -2313,7 +2313,7 @@ start_rwlock_wait_v1(PSI_rwlock_locker_state *state,
|
||||
if (! pfs_rwlock->m_enabled)
|
||||
return NULL;
|
||||
|
||||
register uint flags;
|
||||
uint flags;
|
||||
ulonglong timer_start= 0;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
@ -2421,7 +2421,7 @@ start_cond_wait_v1(PSI_cond_locker_state *state,
|
||||
if (! pfs_cond->m_enabled)
|
||||
return NULL;
|
||||
|
||||
register uint flags;
|
||||
uint flags;
|
||||
ulonglong timer_start= 0;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
@ -2565,7 +2565,7 @@ start_table_io_wait_v1(PSI_table_locker_state *state,
|
||||
|
||||
PFS_thread *pfs_thread= my_pthread_getspecific_ptr(PFS_thread*, THR_PFS);
|
||||
|
||||
register uint flags;
|
||||
uint flags;
|
||||
ulonglong timer_start= 0;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
@ -2691,7 +2691,7 @@ start_table_lock_wait_v1(PSI_table_locker_state *state,
|
||||
|
||||
DBUG_ASSERT((uint) lock_type < array_elements(table_lock_operation_map));
|
||||
|
||||
register uint flags;
|
||||
uint flags;
|
||||
ulonglong timer_start= 0;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
@ -2799,7 +2799,7 @@ get_thread_file_name_locker_v1(PSI_file_locker_state *state,
|
||||
if (flag_thread_instrumentation && ! pfs_thread->m_enabled)
|
||||
return NULL;
|
||||
|
||||
register uint flags;
|
||||
uint flags;
|
||||
|
||||
state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
|
||||
flags= STATE_FLAG_THREAD;
|
||||
@ -2868,7 +2868,7 @@ get_thread_file_stream_locker_v1(PSI_file_locker_state *state,
|
||||
if (! pfs_file->m_enabled)
|
||||
return NULL;
|
||||
|
||||
register uint flags;
|
||||
uint flags;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
{
|
||||
@ -2974,7 +2974,7 @@ get_thread_file_descriptor_locker_v1(PSI_file_locker_state *state,
|
||||
DBUG_ASSERT(pfs_file->m_class != NULL);
|
||||
PFS_file_class *klass= pfs_file->m_class;
|
||||
|
||||
register uint flags;
|
||||
uint flags;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
{
|
||||
@ -3063,7 +3063,7 @@ start_socket_wait_v1(PSI_socket_locker_state *state,
|
||||
if (!pfs_socket->m_enabled || pfs_socket->m_idle)
|
||||
return NULL;
|
||||
|
||||
register uint flags= 0;
|
||||
uint flags= 0;
|
||||
ulonglong timer_start= 0;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
@ -3322,7 +3322,7 @@ start_idle_wait_v1(PSI_idle_locker_state* state, const char *src_file, uint src_
|
||||
if (!global_idle_class.m_enabled)
|
||||
return NULL;
|
||||
|
||||
register uint flags= 0;
|
||||
uint flags= 0;
|
||||
ulonglong timer_start= 0;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
@ -3404,7 +3404,7 @@ static void end_idle_wait_v1(PSI_idle_locker* locker)
|
||||
ulonglong timer_end= 0;
|
||||
ulonglong wait_time= 0;
|
||||
|
||||
register uint flags= state->m_flags;
|
||||
uint flags= state->m_flags;
|
||||
|
||||
if (flags & STATE_FLAG_TIMED)
|
||||
{
|
||||
@ -3474,7 +3474,7 @@ static void end_mutex_wait_v1(PSI_mutex_locker* locker, int rc)
|
||||
DBUG_ASSERT(mutex != NULL);
|
||||
PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
|
||||
|
||||
register uint flags= state->m_flags;
|
||||
uint flags= state->m_flags;
|
||||
|
||||
if (flags & STATE_FLAG_TIMED)
|
||||
{
|
||||
@ -3795,7 +3795,7 @@ static void end_table_io_wait_v1(PSI_table_locker* locker)
|
||||
break;
|
||||
}
|
||||
|
||||
register uint flags= state->m_flags;
|
||||
uint flags= state->m_flags;
|
||||
|
||||
if (flags & STATE_FLAG_TIMED)
|
||||
{
|
||||
@ -3866,7 +3866,7 @@ static void end_table_lock_wait_v1(PSI_table_locker* locker)
|
||||
|
||||
PFS_single_stat *stat= & table->m_table_stat.m_lock_stat.m_stat[state->m_index];
|
||||
|
||||
register uint flags= state->m_flags;
|
||||
uint flags= state->m_flags;
|
||||
|
||||
if (flags & STATE_FLAG_TIMED)
|
||||
{
|
||||
@ -4029,7 +4029,7 @@ static void start_file_wait_v1(PSI_file_locker *locker,
|
||||
PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
|
||||
DBUG_ASSERT(state != NULL);
|
||||
|
||||
register uint flags= state->m_flags;
|
||||
uint flags= state->m_flags;
|
||||
|
||||
if (flags & STATE_FLAG_TIMED)
|
||||
{
|
||||
@ -4065,7 +4065,7 @@ static void end_file_wait_v1(PSI_file_locker *locker,
|
||||
ulonglong timer_end= 0;
|
||||
ulonglong wait_time= 0;
|
||||
PFS_byte_stat *byte_stat;
|
||||
register uint flags= state->m_flags;
|
||||
uint flags= state->m_flags;
|
||||
size_t bytes= ((int)byte_count > -1 ? byte_count : 0);
|
||||
|
||||
PFS_file_stat *file_stat;
|
||||
@ -4420,7 +4420,7 @@ get_thread_statement_locker_v1(PSI_statement_locker_state *state,
|
||||
if (! klass->m_enabled)
|
||||
return NULL;
|
||||
|
||||
register uint flags;
|
||||
uint flags;
|
||||
|
||||
if (flag_thread_instrumentation)
|
||||
{
|
||||
@ -4597,7 +4597,7 @@ static void start_statement_v1(PSI_statement_locker *locker,
|
||||
PSI_statement_locker_state *state= reinterpret_cast<PSI_statement_locker_state*> (locker);
|
||||
DBUG_ASSERT(state != NULL);
|
||||
|
||||
register uint flags= state->m_flags;
|
||||
uint flags= state->m_flags;
|
||||
ulonglong timer_start= 0;
|
||||
|
||||
if (flags & STATE_FLAG_TIMED)
|
||||
@ -4799,7 +4799,7 @@ static void end_statement_v1(PSI_statement_locker *locker, void *stmt_da)
|
||||
|
||||
ulonglong timer_end= 0;
|
||||
ulonglong wait_time= 0;
|
||||
register uint flags= state->m_flags;
|
||||
uint flags= state->m_flags;
|
||||
|
||||
if (flags & STATE_FLAG_TIMED)
|
||||
{
|
||||
@ -5027,7 +5027,7 @@ static void end_socket_wait_v1(PSI_socket_locker *locker, size_t byte_count)
|
||||
ulonglong timer_end= 0;
|
||||
ulonglong wait_time= 0;
|
||||
PFS_byte_stat *byte_stat;
|
||||
register uint flags= state->m_flags;
|
||||
uint flags= state->m_flags;
|
||||
size_t bytes= ((int)byte_count > -1 ? byte_count : 0);
|
||||
|
||||
switch (state->m_operation)
|
||||
|
@ -79,7 +79,7 @@ inline uint randomized_index(const void *ptr, uint max_size)
|
||||
static uint seed1= 0;
|
||||
static uint seed2= 0;
|
||||
uint result;
|
||||
register intptr value;
|
||||
intptr value;
|
||||
|
||||
if (unlikely(max_size == 0))
|
||||
return 0;
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user