1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/bb-10.2-ext' into 10.3

Browse Source
This commit is contained in:
Alexander Barkov 2018-02-04 18:40:06 +04:00
commit 217fc122c8
69 changed files with 483 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
client/completion_hash.cc
View File

@ -49,7 +49,7 @@ int completion_hash_init(HashTable *ht, uint nSize)
ht->initialized = 0; ht->initialized = 0;
return FAILURE; return FAILURE;
} }
init_alloc_root(&ht->mem_root, 8192, 0, MYF(0)); init_alloc_root(&ht->mem_root, "completion_hash", 8192, 0, MYF(0));
ht->pHashFunction = hashpjw; ht->pHashFunction = hashpjw;
ht->nTableSize = nSize; ht->nTableSize = nSize;
ht->initialized = 1; ht->initialized = 1;

2
client/mysql.cc
View File

@ -1205,7 +1205,7 @@ int main(int argc,char *argv[])
} }
glob_buffer.realloc(512); glob_buffer.realloc(512);
completion_hash_init(&ht, 128); completion_hash_init(&ht, 128);
init_alloc_root(&hash_mem_root, 16384, 0, MYF(0)); init_alloc_root(&hash_mem_root, "hash", 16384, 0, MYF(0));
if (sql_connect(current_host,current_db,current_user,opt_password, if (sql_connect(current_host,current_db,current_user,opt_password,
opt_silent)) opt_silent))
{ {

2
client/mysqldump.c
View File

@ -4980,7 +4980,7 @@ static int dump_selected_tables(char *db, char **table_names, int tables)
if (init_dumping(db, init_dumping_tables)) if (init_dumping(db, init_dumping_tables))
DBUG_RETURN(1); DBUG_RETURN(1);
init_alloc_root(&glob_root, 8192, 0, MYF(0)); init_alloc_root(&glob_root, "glob_root", 8192, 0, MYF(0));
if (!(dump_tables= pos= (char**) alloc_root(&glob_root, if (!(dump_tables= pos= (char**) alloc_root(&glob_root,
tables * sizeof(char *)))) tables * sizeof(char *))))
die(EX_EOM, "alloc_root failure."); die(EX_EOM, "alloc_root failure.");

2
client/mysqltest.cc
View File

@ -9146,7 +9146,7 @@ int main(int argc, char **argv)
#endif #endif
init_dynamic_string(&ds_res, "", 2048, 2048); init_dynamic_string(&ds_res, "", 2048, 2048);
init_alloc_root(&require_file_root, 1024, 1024, MYF(0)); init_alloc_root(&require_file_root, "require_file", 1024, 1024, MYF(0));
parse_args(argc, argv); parse_args(argc, argv);

1
include/my_alloc.h
View File

@ -52,6 +52,7 @@ typedef struct st_mem_root
unsigned int first_block_usage; unsigned int first_block_usage;
void (*error_handler)(void); void (*error_handler)(void);
const char *name;
} MEM_ROOT; } MEM_ROOT;
#ifdef __cplusplus #ifdef __cplusplus

5
include/my_sys.h
View File

@ -893,8 +893,9 @@ extern void my_free_lock(void *ptr);
#define alloc_root_inited(A) ((A)->min_malloc != 0) #define alloc_root_inited(A) ((A)->min_malloc != 0)
#define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8) #define ALLOC_ROOT_MIN_BLOCK_SIZE (MALLOC_OVERHEAD + sizeof(USED_MEM) + 8)
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0) #define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
extern void init_alloc_root(MEM_ROOT *mem_root, size_t block_size, extern void init_alloc_root(MEM_ROOT *mem_root, const char *name,
size_t pre_alloc_size, myf my_flags); size_t block_size, size_t pre_alloc_size,
myf my_flags);
extern void *alloc_root(MEM_ROOT *mem_root, size_t Size); extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
extern void *multi_alloc_root(MEM_ROOT *mem_root, ...); extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
extern void free_root(MEM_ROOT *root, myf MyFLAGS); extern void free_root(MEM_ROOT *root, myf MyFLAGS);

1
include/mysql.h.pp
View File

@ -242,6 +242,7 @@ typedef struct st_mem_root
unsigned int block_num; unsigned int block_num;
unsigned int first_block_usage; unsigned int first_block_usage;
void (*error_handler)(void); void (*error_handler)(void);
const char *name;
} MEM_ROOT; } MEM_ROOT;
typedef struct st_typelib { typedef struct st_typelib {
unsigned int count; unsigned int count;

2
libmysqld/emb_qcache.cc
View File

@ -418,7 +418,7 @@ int emb_load_querycache_result(THD *thd, Querycache_stream *src)
if (!data) if (!data)
goto err; goto err;
init_alloc_root(&data->alloc, 8192,0,MYF(0)); init_alloc_root(&data->alloc, "embedded_query_cache", 8192,0,MYF(0));
f_alloc= &data->alloc; f_alloc= &data->alloc;
data->fields= src->load_int(); data->fields= src->load_int();

4
libmysqld/lib_sql.cc
View File

@ -655,7 +655,7 @@ void init_embedded_mysql(MYSQL *mysql, int client_flag)
thd->mysql= mysql; thd->mysql= mysql;
mysql->server_version= server_version; mysql->server_version= server_version;
mysql->client_flag= client_flag; mysql->client_flag= client_flag;
init_alloc_root(&mysql->field_alloc, 8192, 0, MYF(0)); init_alloc_root(&mysql->field_alloc, "fields", 8192, 0, MYF(0));
} }
/** /**
@ -971,7 +971,7 @@ int Protocol::begin_dataset()
return 1; return 1;
alloc= &data->alloc; alloc= &data->alloc;
/* Assume rowlength < 8192 */ /* Assume rowlength < 8192 */
init_alloc_root(alloc, 8192, 0, MYF(0)); init_alloc_root(alloc, "protocol", 8192, 0, MYF(0));
alloc->min_malloc= sizeof(MYSQL_ROWS); alloc->min_malloc= sizeof(MYSQL_ROWS);
return 0; return 0;
} }

7
libmysqld/libmysql.c
View File

@ -1533,8 +1533,9 @@ mysql_stmt_init(MYSQL *mysql)
DBUG_RETURN(NULL); DBUG_RETURN(NULL);
} }
init_alloc_root(&stmt->mem_root, 2048,2048, MYF(MY_THREAD_SPECIFIC)); init_alloc_root(&stmt->mem_root, "stmt", 2048,2048, MYF(MY_THREAD_SPECIFIC));
init_alloc_root(&stmt->result.alloc, 4096, 4096, MYF(MY_THREAD_SPECIFIC)); init_alloc_root(&stmt->result.alloc, "result", 4096, 4096,
MYF(MY_THREAD_SPECIFIC));
stmt->result.alloc.min_malloc= sizeof(MYSQL_ROWS); stmt->result.alloc.min_malloc= sizeof(MYSQL_ROWS);
mysql->stmts= list_add(mysql->stmts, &stmt->list); mysql->stmts= list_add(mysql->stmts, &stmt->list);
stmt->list.data= stmt; stmt->list.data= stmt;
@ -1545,7 +1546,7 @@ mysql_stmt_init(MYSQL *mysql)
strmov(stmt->sqlstate, not_error_sqlstate); strmov(stmt->sqlstate, not_error_sqlstate);
/* The rest of statement members was bzeroed inside malloc */ /* The rest of statement members was bzeroed inside malloc */
init_alloc_root(&stmt->extension->fields_mem_root, 2048, 0, init_alloc_root(&stmt->extension->fields_mem_root, "extension", 2048, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
DBUG_RETURN(stmt); DBUG_RETURN(stmt);

32
mysql-test/r/ps.result
View File

@ -1741,7 +1741,7 @@ execute stmt using @a;
show create table t1; show create table t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`?` decimal(2,1) DEFAULT NULL `?` decimal(2,1) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
drop table t1; drop table t1;
drop table if exists t1; drop table if exists t1;
@ -4435,7 +4435,7 @@ EXECUTE stmt USING 10.123;
SHOW CREATE TABLE t1; SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c1` decimal(5,3) DEFAULT NULL `c1` decimal(5,3) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1; DROP TABLE t1;
EXECUTE stmt USING 10.123e0; EXECUTE stmt USING 10.123e0;
@ -4449,49 +4449,49 @@ EXECUTE stmt USING CURRENT_DATE;
SHOW CREATE TABLE t1; SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c1` date DEFAULT NULL `c1` date NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1; DROP TABLE t1;
EXECUTE stmt USING CURRENT_TIMESTAMP; EXECUTE stmt USING CURRENT_TIMESTAMP;
SHOW CREATE TABLE t1; SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c1` datetime DEFAULT NULL `c1` datetime NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1; DROP TABLE t1;
EXECUTE stmt USING CURRENT_TIMESTAMP(3); EXECUTE stmt USING CURRENT_TIMESTAMP(3);
SHOW CREATE TABLE t1; SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c1` datetime(3) DEFAULT NULL `c1` datetime(3) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1; DROP TABLE t1;
EXECUTE stmt USING CURRENT_TIMESTAMP(6); EXECUTE stmt USING CURRENT_TIMESTAMP(6);
SHOW CREATE TABLE t1; SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c1` datetime(6) DEFAULT NULL `c1` datetime(6) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1; DROP TABLE t1;
EXECUTE stmt USING CURRENT_TIME; EXECUTE stmt USING CURRENT_TIME;
SHOW CREATE TABLE t1; SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c1` time DEFAULT NULL `c1` time NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1; DROP TABLE t1;
EXECUTE stmt USING CURRENT_TIME(3); EXECUTE stmt USING CURRENT_TIME(3);
SHOW CREATE TABLE t1; SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c1` time(3) DEFAULT NULL `c1` time(3) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1; DROP TABLE t1;
EXECUTE stmt USING CURRENT_TIME(6); EXECUTE stmt USING CURRENT_TIME(6);
SHOW CREATE TABLE t1; SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c1` time(6) DEFAULT NULL `c1` time(6) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1; DROP TABLE t1;
DEALLOCATE PREPARE stmt; DEALLOCATE PREPARE stmt;
@ -4636,7 +4636,7 @@ SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`a` bigint(20) NOT NULL, `a` bigint(20) NOT NULL,
`b` decimal(3,1) DEFAULT NULL, `b` decimal(3,1) NOT NULL,
`c` double NOT NULL, `c` double NOT NULL,
`d` tinytext NOT NULL `d` tinytext NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
@ -4648,7 +4648,7 @@ SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`a` int(2) NOT NULL, `a` int(2) NOT NULL,
`b` decimal(3,1) DEFAULT NULL, `b` decimal(3,1) NOT NULL,
`c` double NOT NULL, `c` double NOT NULL,
`d` varchar(3) NOT NULL `d` varchar(3) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
@ -4663,11 +4663,11 @@ TIMESTAMP'2001-01-01 10:20:30.123';
SHOW CREATE TABLE t1; SHOW CREATE TABLE t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`t1` time DEFAULT NULL, `t1` time NOT NULL,
`t2` time(3) DEFAULT NULL, `t2` time(3) NOT NULL,
`d1` date DEFAULT NULL, `d1` date NOT NULL,
`dt1` datetime DEFAULT NULL, `dt1` datetime NOT NULL,
`dt2` datetime(3) DEFAULT NULL `dt2` datetime(3) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
DROP TABLE t1; DROP TABLE t1;
# #

129
mysql-test/r/type_time.result
View File

@ -1283,3 +1283,132 @@ a
10:20:32 10:20:32
DROP TABLE t1; DROP TABLE t1;
SET timestamp=DEFAULT; SET timestamp=DEFAULT;
#
# MDEV-15176 Storing DATETIME-alike VARCHAR data into TIME produces wrong results
#
SET sql_mode='';
CREATE OR REPLACE TABLE t0 (d VARCHAR(64));
INSERT INTO t0 VALUES ('0000-00-00 10:20:30');
INSERT INTO t0 VALUES ('0000-00-01 10:20:30');
INSERT INTO t0 VALUES ('0000-01-00 10:20:30');
INSERT INTO t0 VALUES ('0000-01-01 10:20:30');
INSERT INTO t0 VALUES ('0001-00-00 10:20:30');
INSERT INTO t0 VALUES ('0001-00-01 10:20:30');
INSERT INTO t0 VALUES ('0001-01-00 10:20:30');
INSERT INTO t0 VALUES ('0001-01-01 10:20:30');
SET @@global.mysql56_temporal_format=false;
CREATE OR REPLACE TABLE t1 (d VARCHAR(64), t0 TIME(0), t1 TIME(1));
INSERT INTO t1 SELECT d,d,d FROM t0;
Warnings:
Note 1265 Data truncated for column 't0' at row 3
Note 1265 Data truncated for column 't1' at row 3
Note 1265 Data truncated for column 't0' at row 4
Note 1265 Data truncated for column 't1' at row 4
Note 1265 Data truncated for column 't0' at row 5
Note 1265 Data truncated for column 't1' at row 5
Note 1265 Data truncated for column 't0' at row 6
Note 1265 Data truncated for column 't1' at row 6
Note 1265 Data truncated for column 't0' at row 7
Note 1265 Data truncated for column 't1' at row 7
Note 1265 Data truncated for column 't0' at row 8
Note 1265 Data truncated for column 't1' at row 8
SELECT * FROM t1 ORDER BY d;
d t0 t1
0000-00-00 10:20:30 10:20:30 10:20:30.0
0000-00-01 10:20:30 34:20:30 34:20:30.0
0000-01-00 10:20:30 10:20:30 10:20:30.0
0000-01-01 10:20:30 10:20:30 10:20:30.0
0001-00-00 10:20:30 10:20:30 10:20:30.0
0001-00-01 10:20:30 10:20:30 10:20:30.0
0001-01-00 10:20:30 10:20:30 10:20:30.0
0001-01-01 10:20:30 10:20:30 10:20:30.0
DROP TABLE t1;
CREATE OR REPLACE TABLE t1 (d VARCHAR(64), t0 TIME(0), t1 TIME(1));
INSERT INTO t1 SELECT CONCAT(d,'x'),CONCAT(d,'x'),CONCAT(d,'x') FROM t0;
Warnings:
Warning 1265 Data truncated for column 't0' at row 1
Warning 1265 Data truncated for column 't1' at row 1
Warning 1265 Data truncated for column 't0' at row 2
Warning 1265 Data truncated for column 't1' at row 2
Warning 1265 Data truncated for column 't0' at row 3
Warning 1265 Data truncated for column 't1' at row 3
Warning 1265 Data truncated for column 't0' at row 4
Warning 1265 Data truncated for column 't1' at row 4
Warning 1265 Data truncated for column 't0' at row 5
Warning 1265 Data truncated for column 't1' at row 5
Warning 1265 Data truncated for column 't0' at row 6
Warning 1265 Data truncated for column 't1' at row 6
Warning 1265 Data truncated for column 't0' at row 7
Warning 1265 Data truncated for column 't1' at row 7
Warning 1265 Data truncated for column 't0' at row 8
Warning 1265 Data truncated for column 't1' at row 8
SELECT * FROM t1;
d t0 t1
0000-00-00 10:20:30x 10:20:30 10:20:30.0
0000-00-01 10:20:30x 34:20:30 34:20:30.0
0000-01-00 10:20:30x 10:20:30 10:20:30.0
0000-01-01 10:20:30x 10:20:30 10:20:30.0
0001-00-00 10:20:30x 10:20:30 10:20:30.0
0001-00-01 10:20:30x 10:20:30 10:20:30.0
0001-01-00 10:20:30x 10:20:30 10:20:30.0
0001-01-01 10:20:30x 10:20:30 10:20:30.0
DROP TABLE t1;
SET @@global.mysql56_temporal_format=true;
CREATE OR REPLACE TABLE t1 (d VARCHAR(64), t0 TIME(0), t1 TIME(1));
INSERT INTO t1 SELECT d,d,d FROM t0;
Warnings:
Note 1265 Data truncated for column 't0' at row 3
Note 1265 Data truncated for column 't1' at row 3
Note 1265 Data truncated for column 't0' at row 4
Note 1265 Data truncated for column 't1' at row 4
Note 1265 Data truncated for column 't0' at row 5
Note 1265 Data truncated for column 't1' at row 5
Note 1265 Data truncated for column 't0' at row 6
Note 1265 Data truncated for column 't1' at row 6
Note 1265 Data truncated for column 't0' at row 7
Note 1265 Data truncated for column 't1' at row 7
Note 1265 Data truncated for column 't0' at row 8
Note 1265 Data truncated for column 't1' at row 8
SELECT * FROM t1;
d t0 t1
0000-00-00 10:20:30 10:20:30 10:20:30.0
0000-00-01 10:20:30 34:20:30 34:20:30.0
0000-01-00 10:20:30 10:20:30 10:20:30.0
0000-01-01 10:20:30 10:20:30 10:20:30.0
0001-00-00 10:20:30 10:20:30 10:20:30.0
0001-00-01 10:20:30 10:20:30 10:20:30.0
0001-01-00 10:20:30 10:20:30 10:20:30.0
0001-01-01 10:20:30 10:20:30 10:20:30.0
DROP TABLE t1;
CREATE OR REPLACE TABLE t1 (d VARCHAR(64), t0 TIME(0), t1 TIME(1));
INSERT INTO t1 SELECT CONCAT(d,'x'),CONCAT(d,'x'),CONCAT(d,'x') FROM t0;
Warnings:
Warning 1265 Data truncated for column 't0' at row 1
Warning 1265 Data truncated for column 't1' at row 1
Warning 1265 Data truncated for column 't0' at row 2
Warning 1265 Data truncated for column 't1' at row 2
Warning 1265 Data truncated for column 't0' at row 3
Warning 1265 Data truncated for column 't1' at row 3
Warning 1265 Data truncated for column 't0' at row 4
Warning 1265 Data truncated for column 't1' at row 4
Warning 1265 Data truncated for column 't0' at row 5
Warning 1265 Data truncated for column 't1' at row 5
Warning 1265 Data truncated for column 't0' at row 6
Warning 1265 Data truncated for column 't1' at row 6
Warning 1265 Data truncated for column 't0' at row 7
Warning 1265 Data truncated for column 't1' at row 7
Warning 1265 Data truncated for column 't0' at row 8
Warning 1265 Data truncated for column 't1' at row 8
SELECT * FROM t1 ORDER BY d;
d t0 t1
0000-00-00 10:20:30x 10:20:30 10:20:30.0
0000-00-01 10:20:30x 34:20:30 34:20:30.0
0000-01-00 10:20:30x 10:20:30 10:20:30.0
0000-01-01 10:20:30x 10:20:30 10:20:30.0
0001-00-00 10:20:30x 10:20:30 10:20:30.0
0001-00-01 10:20:30x 10:20:30 10:20:30.0
0001-01-00 10:20:30x 10:20:30 10:20:30.0
0001-01-01 10:20:30x 10:20:30 10:20:30.0
DROP TABLE t1;
DROP TABLE t0;
SET sql_mode=DEFAULT;

38
mysql-test/t/type_time.test
View File

@ -776,3 +776,41 @@ INSERT INTO t1 VALUES ('10:20:30'),('10:20:31'),('10:20:32');
SELECT a FROM t1 WHERE a IN (102030,TIME'10:20:31',TIMESTAMP'2001-01-01 10:20:32') ORDER BY a; SELECT a FROM t1 WHERE a IN (102030,TIME'10:20:31',TIMESTAMP'2001-01-01 10:20:32') ORDER BY a;
DROP TABLE t1; DROP TABLE t1;
SET timestamp=DEFAULT; SET timestamp=DEFAULT;
--echo #
--echo # MDEV-15176 Storing DATETIME-alike VARCHAR data into TIME produces wrong results
--echo #
SET sql_mode='';
CREATE OR REPLACE TABLE t0 (d VARCHAR(64));
INSERT INTO t0 VALUES ('0000-00-00 10:20:30');
INSERT INTO t0 VALUES ('0000-00-01 10:20:30');
INSERT INTO t0 VALUES ('0000-01-00 10:20:30');
INSERT INTO t0 VALUES ('0000-01-01 10:20:30');
INSERT INTO t0 VALUES ('0001-00-00 10:20:30');
INSERT INTO t0 VALUES ('0001-00-01 10:20:30');
INSERT INTO t0 VALUES ('0001-01-00 10:20:30');
INSERT INTO t0 VALUES ('0001-01-01 10:20:30');
SET @@global.mysql56_temporal_format=false;
CREATE OR REPLACE TABLE t1 (d VARCHAR(64), t0 TIME(0), t1 TIME(1));
INSERT INTO t1 SELECT d,d,d FROM t0;
SELECT * FROM t1 ORDER BY d;
DROP TABLE t1;
CREATE OR REPLACE TABLE t1 (d VARCHAR(64), t0 TIME(0), t1 TIME(1));
INSERT INTO t1 SELECT CONCAT(d,'x'),CONCAT(d,'x'),CONCAT(d,'x') FROM t0;
SELECT * FROM t1;
DROP TABLE t1;
SET @@global.mysql56_temporal_format=true;
CREATE OR REPLACE TABLE t1 (d VARCHAR(64), t0 TIME(0), t1 TIME(1));
INSERT INTO t1 SELECT d,d,d FROM t0;
SELECT * FROM t1;
DROP TABLE t1;
CREATE OR REPLACE TABLE t1 (d VARCHAR(64), t0 TIME(0), t1 TIME(1));
INSERT INTO t1 SELECT CONCAT(d,'x'),CONCAT(d,'x'),CONCAT(d,'x') FROM t0;
SELECT * FROM t1 ORDER BY d;
DROP TABLE t1;
DROP TABLE t0;
SET sql_mode=DEFAULT;

19
mysys/my_alloc.c
View File

@ -32,6 +32,7 @@
SYNOPSIS SYNOPSIS
init_alloc_root() init_alloc_root()
mem_root - memory root to initialize mem_root - memory root to initialize
name - name of memroot (for debugging)
block_size - size of chunks (blocks) used for memory allocation block_size - size of chunks (blocks) used for memory allocation
(It is external size of chunk i.e. it should include (It is external size of chunk i.e. it should include
memory required for internal structures, thus it memory required for internal structures, thus it
@ -51,13 +52,13 @@
Because of this, we store in MY_THREAD_SPECIFIC as bit 1 in block_size Because of this, we store in MY_THREAD_SPECIFIC as bit 1 in block_size
*/ */
void init_alloc_root(MEM_ROOT *mem_root, size_t block_size, void init_alloc_root(MEM_ROOT *mem_root, const char *name, size_t block_size,
size_t pre_alloc_size __attribute__((unused)), size_t pre_alloc_size __attribute__((unused)),
myf my_flags) myf my_flags)
{ {
DBUG_ENTER("init_alloc_root"); DBUG_ENTER("init_alloc_root");
DBUG_PRINT("enter",("root: %p prealloc: %zu", mem_root, DBUG_PRINT("enter",("root: %p name: %s prealloc: %zu", mem_root,
pre_alloc_size)); name, pre_alloc_size));
mem_root->free= mem_root->used= mem_root->pre_alloc= 0; mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc= 32; mem_root->min_malloc= 32;
@ -69,6 +70,7 @@ void init_alloc_root(MEM_ROOT *mem_root, size_t block_size,
mem_root->block_num= 4; /* We shift this with >>2 */ mem_root->block_num= 4; /* We shift this with >>2 */
mem_root->first_block_usage= 0; mem_root->first_block_usage= 0;
mem_root->total_alloc= 0; mem_root->total_alloc= 0;
mem_root->name= name;
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG)) #if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size) if (pre_alloc_size)
@ -172,7 +174,7 @@ void *alloc_root(MEM_ROOT *mem_root, size_t length)
#if defined(HAVE_valgrind) && defined(EXTRA_DEBUG) #if defined(HAVE_valgrind) && defined(EXTRA_DEBUG)
reg1 USED_MEM *next; reg1 USED_MEM *next;
DBUG_ENTER("alloc_root"); DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root)); DBUG_PRINT("enter",("root: %p name: %s", mem_root, mem_root->name));
DBUG_ASSERT(alloc_root_inited(mem_root)); DBUG_ASSERT(alloc_root_inited(mem_root));
@ -207,7 +209,7 @@ void *alloc_root(MEM_ROOT *mem_root, size_t length)
reg1 USED_MEM *next= 0; reg1 USED_MEM *next= 0;
reg2 USED_MEM **prev; reg2 USED_MEM **prev;
DBUG_ENTER("alloc_root"); DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root)); DBUG_PRINT("enter",("root: %p name: %s", mem_root, mem_root->name));
DBUG_ASSERT(alloc_root_inited(mem_root)); DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory", DBUG_EXECUTE_IF("simulate_out_of_memory",
@ -298,6 +300,10 @@ void *multi_alloc_root(MEM_ROOT *root, ...)
char **ptr, *start, *res; char **ptr, *start, *res;
size_t tot_length, length; size_t tot_length, length;
DBUG_ENTER("multi_alloc_root"); DBUG_ENTER("multi_alloc_root");
/*
We don't need to do DBUG_PRINT here as it will be done when alloc_root
is called
*/
va_start(args, root); va_start(args, root);
tot_length= 0; tot_length= 0;
@ -382,7 +388,8 @@ void free_root(MEM_ROOT *root, myf MyFlags)
{ {
reg1 USED_MEM *next,*old; reg1 USED_MEM *next,*old;
DBUG_ENTER("free_root"); DBUG_ENTER("free_root");
DBUG_PRINT("enter",("root: %p flags: %u", root, (uint) MyFlags)); DBUG_PRINT("enter",("root: %p name: %s flags: %u", root, root->name,
(uint) MyFlags));
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG)) #if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
/* /*

4
mysys/my_default.c
View File

@ -518,7 +518,7 @@ int my_load_defaults(const char *conf_file, const char **groups,
uint args_sep= my_getopt_use_args_separator ? 1 : 0; uint args_sep= my_getopt_use_args_separator ? 1 : 0;
DBUG_ENTER("load_defaults"); DBUG_ENTER("load_defaults");
init_alloc_root(&alloc, 512, 0, MYF(0)); init_alloc_root(&alloc, "my_load_defaults", 512, 0, MYF(0));
if ((dirs= init_default_directories(&alloc)) == NULL) if ((dirs= init_default_directories(&alloc)) == NULL)
goto err; goto err;
/* /*
@ -1041,7 +1041,7 @@ void my_print_default_files(const char *conf_file)
{ {
const char **dirs; const char **dirs;
MEM_ROOT alloc; MEM_ROOT alloc;
init_alloc_root(&alloc, 512, 0, MYF(0)); init_alloc_root(&alloc, "my_print_defaults", 512, 0, MYF(0));
if ((dirs= init_default_directories(&alloc)) == NULL) if ((dirs= init_default_directories(&alloc)) == NULL)
{ {

4
mysys/my_lib.c
View File

@ -136,7 +136,7 @@ MY_DIR *my_dir(const char *path, myf MyFlags)
MYF(MyFlags))) MYF(MyFlags)))
goto error; goto error;
init_alloc_root(&dirh->root, NAMES_START_SIZE, NAMES_START_SIZE, init_alloc_root(&dirh->root, "dir", NAMES_START_SIZE, NAMES_START_SIZE,
MYF(MyFlags)); MYF(MyFlags));
dp= (struct dirent*) dirent_tmp; dp= (struct dirent*) dirent_tmp;
@ -245,7 +245,7 @@ MY_DIR *my_dir(const char *path, myf MyFlags)
MYF(MyFlags))) MYF(MyFlags)))
goto error; goto error;
init_alloc_root(&dirh->root, NAMES_START_SIZE, NAMES_START_SIZE, init_alloc_root(&dirh->root, "dir", NAMES_START_SIZE, NAMES_START_SIZE,
MYF(MyFlags)); MYF(MyFlags));
if ((handle=_findfirst(tmp_path,&find)) == -1L) if ((handle=_findfirst(tmp_path,&find)) == -1L)

3
mysys/tree.c
View File

@ -130,7 +130,8 @@ void init_tree(TREE *tree, size_t default_alloc_size, size_t memory_limit,
} }
if (!(tree->with_delete= MY_TEST(my_flags & MY_TREE_WITH_DELETE))) if (!(tree->with_delete= MY_TEST(my_flags & MY_TREE_WITH_DELETE)))
{ {
init_alloc_root(&tree->mem_root, default_alloc_size, 0, MYF(my_flags)); init_alloc_root(&tree->mem_root, "tree", default_alloc_size, 0,
MYF(my_flags));
tree->mem_root.min_malloc= sizeof(TREE_ELEMENT)+tree->size_of_element; tree->mem_root.min_malloc= sizeof(TREE_ELEMENT)+tree->size_of_element;
} }
DBUG_VOID_RETURN; DBUG_VOID_RETURN;

4
sql-common/client.c
View File

@ -740,7 +740,7 @@ void free_old_query(MYSQL *mysql)
if (mysql->fields) if (mysql->fields)
free_root(&mysql->field_alloc,MYF(0)); free_root(&mysql->field_alloc,MYF(0));
/* Assume rowlength < 8192 */ /* Assume rowlength < 8192 */
init_alloc_root(&mysql->field_alloc, 8192, 0, init_alloc_root(&mysql->field_alloc, "fields", 8192, 0,
MYF(mysql->options.use_thread_specific_memory ? MYF(mysql->options.use_thread_specific_memory ?
MY_THREAD_SPECIFIC : 0)); MY_THREAD_SPECIFIC : 0));
mysql->fields= 0; mysql->fields= 0;
@ -1464,7 +1464,7 @@ MYSQL_DATA *cli_read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
DBUG_RETURN(0); DBUG_RETURN(0);
} }
/* Assume rowlength < 8192 */ /* Assume rowlength < 8192 */
init_alloc_root(&result->alloc, 8192, 0, init_alloc_root(&result->alloc, "result", 8192, 0,
MYF(mysql->options.use_thread_specific_memory ? MYF(mysql->options.use_thread_specific_memory ?
MY_THREAD_SPECIFIC : 0)); MY_THREAD_SPECIFIC : 0));
result->alloc.min_malloc=sizeof(MYSQL_ROWS); result->alloc.min_malloc=sizeof(MYSQL_ROWS);

2
sql-common/client_plugin.c
View File

@ -251,7 +251,7 @@ int mysql_client_plugin_init()
bzero(&mysql, sizeof(mysql)); /* dummy mysql for set_mysql_extended_error */ bzero(&mysql, sizeof(mysql)); /* dummy mysql for set_mysql_extended_error */
mysql_mutex_init(0, &LOCK_load_client_plugin, MY_MUTEX_INIT_SLOW); mysql_mutex_init(0, &LOCK_load_client_plugin, MY_MUTEX_INIT_SLOW);
init_alloc_root(&mem_root, 128, 128, MYF(0)); init_alloc_root(&mem_root, "client_plugin", 128, 128, MYF(0));
bzero(&plugin_list, sizeof(plugin_list)); bzero(&plugin_list, sizeof(plugin_list));

6
sql/compat56.cc
View File

@ -45,8 +45,10 @@
*/ */
longlong TIME_to_longlong_time_packed(const MYSQL_TIME *ltime) longlong TIME_to_longlong_time_packed(const MYSQL_TIME *ltime)
{ {
/* If month is 0, we mix day with hours: "1 00:10:10" -> "24:00:10" */ DBUG_ASSERT(ltime->year == 0);
long hms= (((ltime->month ? 0 : ltime->day * 24) + ltime->hour) << 12) | DBUG_ASSERT(ltime->month == 0);
// Mix days with hours: "1 00:10:10" -> "24:00:10"
long hms= ((ltime->day * 24 + ltime->hour) << 12) |
(ltime->minute << 6) | ltime->second; (ltime->minute << 6) | ltime->second;
longlong tmp= MY_PACKED_TIME_MAKE(hms, ltime->second_part); longlong tmp= MY_PACKED_TIME_MAKE(hms, ltime->second_part);
return ltime->neg ? -tmp : tmp; return ltime->neg ? -tmp : tmp;

2
sql/event_data_objects.cc
View File

@ -209,7 +209,7 @@ Event_basic::Event_basic()
{ {
DBUG_ENTER("Event_basic::Event_basic"); DBUG_ENTER("Event_basic::Event_basic");
/* init memory root */ /* init memory root */
init_sql_alloc(&mem_root, 256, 512, MYF(0)); init_sql_alloc(&mem_root, "Event_basic", 256, 512, MYF(0));
dbname.str= name.str= NULL; dbname.str= name.str= NULL;
dbname.length= name.length= 0; dbname.length= name.length= 0;
time_zone= NULL; time_zone= NULL;

57
sql/field.cc
View File

@ -2239,7 +2239,7 @@ bool Field::get_date(MYSQL_TIME *ltime,ulonglong fuzzydate)
Needs to be changed if/when we want to support different time formats. Needs to be changed if/when we want to support different time formats.
*/ */
int Field::store_time_dec(MYSQL_TIME *ltime, uint dec) int Field::store_time_dec(const MYSQL_TIME *ltime, uint dec)
{ {
ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED; ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
char buff[MAX_DATE_STRING_REP_LENGTH]; char buff[MAX_DATE_STRING_REP_LENGTH];
@ -3288,7 +3288,7 @@ int Field_new_decimal::store_decimal(const my_decimal *decimal_value)
} }
int Field_new_decimal::store_time_dec(MYSQL_TIME *ltime, uint dec_arg) int Field_new_decimal::store_time_dec(const MYSQL_TIME *ltime, uint dec_arg)
{ {
my_decimal decimal_value; my_decimal decimal_value;
return store_value(date2my_decimal(ltime, &decimal_value)); return store_value(date2my_decimal(ltime, &decimal_value));
@ -3527,7 +3527,7 @@ Item *Field_new_decimal::get_equal_const_item(THD *thd, const Context &ctx,
} }
int Field_num::store_time_dec(MYSQL_TIME *ltime, uint dec_arg) int Field_num::store_time_dec(const MYSQL_TIME *ltime, uint dec_arg)
{ {
longlong v= TIME_to_ulonglong(ltime); longlong v= TIME_to_ulonglong(ltime);
if (ltime->neg == 0) if (ltime->neg == 0)
@ -4801,7 +4801,7 @@ int Field_real::store_decimal(const my_decimal *dm)
return store(dbl); return store(dbl);
} }
int Field_real::store_time_dec(MYSQL_TIME *ltime, uint dec_arg) int Field_real::store_time_dec(const MYSQL_TIME *ltime, uint dec_arg)
{ {
return store(TIME_to_double(ltime)); return store(TIME_to_double(ltime));
} }
@ -5083,7 +5083,7 @@ copy_or_convert_to_datetime(THD *thd, const MYSQL_TIME *from, MYSQL_TIME *to)
} }
int Field_timestamp::store_time_dec(MYSQL_TIME *ltime, uint dec) int Field_timestamp::store_time_dec(const MYSQL_TIME *ltime, uint dec)
{ {
int unused; int unused;
ErrConvTime str(ltime); ErrConvTime str(ltime);
@ -5640,7 +5640,7 @@ int Field_temporal_with_date::store(longlong nr, bool unsigned_val)
} }
int Field_temporal_with_date::store_time_dec(MYSQL_TIME *ltime, uint dec) int Field_temporal_with_date::store_time_dec(const MYSQL_TIME *ltime, uint dec)
{ {
int error= 0, have_smth_to_conv= 1; int error= 0, have_smth_to_conv= 1;
ErrConvTime str(ltime); ErrConvTime str(ltime);
@ -5757,34 +5757,38 @@ int Field_time::store_TIME_with_warning(MYSQL_TIME *ltime,
int was_cut, int was_cut,
int have_smth_to_conv) int have_smth_to_conv)
{ {
Sql_condition::enum_warning_level trunc_level= Sql_condition::WARN_LEVEL_WARN;
int ret= 2;
ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED; ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
if (!have_smth_to_conv) if (!have_smth_to_conv)
{ {
bzero(ltime, sizeof(*ltime)); bzero(ltime, sizeof(*ltime));
was_cut= MYSQL_TIME_WARN_TRUNCATED; store_TIME(ltime);
ret= 1; set_warnings(Sql_condition::WARN_LEVEL_WARN, str, MYSQL_TIME_WARN_TRUNCATED);
return 1;
} }
else if (!MYSQL_TIME_WARN_HAVE_WARNINGS(was_cut) && if (ltime->year != 0 || ltime->month != 0)
((ltime->year || ltime->month) ||
MYSQL_TIME_WARN_HAVE_NOTES(was_cut)))
{ {
if (ltime->year || ltime->month) ltime->year= ltime->month= ltime->day= 0;
ltime->year= ltime->month= ltime->day= 0; was_cut|= MYSQL_TIME_NOTE_TRUNCATED;
trunc_level= Sql_condition::WARN_LEVEL_NOTE;
was_cut|= MYSQL_TIME_WARN_TRUNCATED;
ret= 3;
} }
set_warnings(trunc_level, str, was_cut, MYSQL_TIMESTAMP_TIME); my_time_trunc(ltime, decimals());
store_TIME(ltime); store_TIME(ltime);
return was_cut ? ret : 0; if (!MYSQL_TIME_WARN_HAVE_WARNINGS(was_cut) &&
MYSQL_TIME_WARN_HAVE_NOTES(was_cut))
{
set_warnings(Sql_condition::WARN_LEVEL_NOTE, str,
was_cut | MYSQL_TIME_WARN_TRUNCATED);
return 3;
}
set_warnings(Sql_condition::WARN_LEVEL_WARN, str, was_cut);
return was_cut ? 2 : 0;
} }
void Field_time::store_TIME(MYSQL_TIME *ltime) void Field_time::store_TIME(const MYSQL_TIME *ltime)
{ {
DBUG_ASSERT(ltime->year == 0);
DBUG_ASSERT(ltime->month == 0);
long tmp= (ltime->day*24L+ltime->hour)*10000L + long tmp= (ltime->day*24L+ltime->hour)*10000L +
(ltime->minute*100+ltime->second); (ltime->minute*100+ltime->second);
if (ltime->neg) if (ltime->neg)
@ -5832,7 +5836,7 @@ static void calc_datetime_days_diff(MYSQL_TIME *ltime, long days)
} }
int Field_time::store_time_dec(MYSQL_TIME *ltime, uint dec) int Field_time::store_time_dec(const MYSQL_TIME *ltime, uint dec)
{ {
MYSQL_TIME l_time= *ltime; MYSQL_TIME l_time= *ltime;
ErrConvTime str(ltime); ErrConvTime str(ltime);
@ -6018,8 +6022,10 @@ int Field_time_hires::reset()
} }
void Field_time_hires::store_TIME(MYSQL_TIME *ltime) void Field_time_hires::store_TIME(const MYSQL_TIME *ltime)
{ {
DBUG_ASSERT(ltime->year == 0);
DBUG_ASSERT(ltime->month == 0);
ulonglong packed= sec_part_shift(pack_time(ltime), dec) + zero_point; ulonglong packed= sec_part_shift(pack_time(ltime), dec) + zero_point;
store_bigendian(packed, ptr, Field_time_hires::pack_length()); store_bigendian(packed, ptr, Field_time_hires::pack_length());
} }
@ -6201,9 +6207,8 @@ int Field_timef::reset()
return 0; return 0;
} }
void Field_timef::store_TIME(MYSQL_TIME *ltime) void Field_timef::store_TIME(const MYSQL_TIME *ltime)
{ {
my_time_trunc(ltime, decimals());
longlong tmp= TIME_to_longlong_time_packed(ltime); longlong tmp= TIME_to_longlong_time_packed(ltime);
my_time_packed_to_binary(tmp, ptr, dec); my_time_packed_to_binary(tmp, ptr, dec);
} }
@ -6292,7 +6297,7 @@ int Field_year::store(longlong nr, bool unsigned_val)
} }
int Field_year::store_time_dec(MYSQL_TIME *ltime, uint dec_arg) int Field_year::store_time_dec(const MYSQL_TIME *ltime, uint dec_arg)
{ {
ErrConvTime str(ltime); ErrConvTime str(ltime);
if (Field_year::store(ltime->year, 0)) if (Field_year::store(ltime->year, 0))

29
sql/field.h
View File

@ -829,9 +829,9 @@ public:
virtual int store(double nr)=0; virtual int store(double nr)=0;
virtual int store(longlong nr, bool unsigned_val)=0; virtual int store(longlong nr, bool unsigned_val)=0;
virtual int store_decimal(const my_decimal *d)=0; virtual int store_decimal(const my_decimal *d)=0;
virtual int store_time_dec(MYSQL_TIME *ltime, uint dec); virtual int store_time_dec(const MYSQL_TIME *ltime, uint dec);
virtual int store_timestamp(my_time_t timestamp, ulong sec_part); virtual int store_timestamp(my_time_t timestamp, ulong sec_part);
int store_time(MYSQL_TIME *ltime) int store_time(const MYSQL_TIME *ltime)
{ return store_time_dec(ltime, TIME_SECOND_PART_DIGITS); } { return store_time_dec(ltime, TIME_SECOND_PART_DIGITS); }
int store(const char *to, uint length, CHARSET_INFO *cs, int store(const char *to, uint length, CHARSET_INFO *cs,
enum_check_fields check_level); enum_check_fields check_level);
@ -1711,7 +1711,7 @@ public:
field_metadata, length)); field_metadata, length));
return length; return length;
} }
int store_time_dec(MYSQL_TIME *ltime, uint dec); int store_time_dec(const MYSQL_TIME *ltime, uint dec);
double pos_in_interval(Field *min, Field *max) double pos_in_interval(Field *min, Field *max)
{ {
return pos_in_interval_val_real(min, max); return pos_in_interval_val_real(min, max);
@ -1856,7 +1856,7 @@ public:
field_length >= from->field_length; field_length >= from->field_length;
} }
int store_decimal(const my_decimal *); int store_decimal(const my_decimal *);
int store_time_dec(MYSQL_TIME *ltime, uint dec); int store_time_dec(const MYSQL_TIME *ltime, uint dec);
bool get_date(MYSQL_TIME *ltime, ulonglong fuzzydate); bool get_date(MYSQL_TIME *ltime, ulonglong fuzzydate);
my_decimal *val_decimal(my_decimal *); my_decimal *val_decimal(my_decimal *);
bool val_bool() { return val_real() != 0e0; } bool val_bool() { return val_real() != 0e0; }
@ -1946,7 +1946,7 @@ public:
int store(const char *to, uint length, CHARSET_INFO *charset); int store(const char *to, uint length, CHARSET_INFO *charset);
int store(double nr); int store(double nr);
int store(longlong nr, bool unsigned_val); int store(longlong nr, bool unsigned_val);
int store_time_dec(MYSQL_TIME *ltime, uint dec); int store_time_dec(const MYSQL_TIME *ltime, uint dec);
int store_decimal(const my_decimal *); int store_decimal(const my_decimal *);
double val_real(void); double val_real(void);
longlong val_int(void); longlong val_int(void);
@ -2474,7 +2474,7 @@ public:
int store(const char *to, uint length, CHARSET_INFO *charset); int store(const char *to, uint length, CHARSET_INFO *charset);
int store(double nr); int store(double nr);
int store(longlong nr, bool unsigned_val); int store(longlong nr, bool unsigned_val);
int store_time_dec(MYSQL_TIME *ltime, uint dec); int store_time_dec(const MYSQL_TIME *ltime, uint dec);
int store_decimal(const my_decimal *); int store_decimal(const my_decimal *);
bool validate_value_in_record(THD *thd, const uchar *record) const; bool validate_value_in_record(THD *thd, const uchar *record) const;
}; };
@ -2496,7 +2496,7 @@ public:
int store(const char *to,uint length,CHARSET_INFO *charset); int store(const char *to,uint length,CHARSET_INFO *charset);
int store(double nr); int store(double nr);
int store(longlong nr, bool unsigned_val); int store(longlong nr, bool unsigned_val);
int store_time_dec(MYSQL_TIME *ltime, uint dec); int store_time_dec(const MYSQL_TIME *ltime, uint dec);
int store_decimal(const my_decimal *); int store_decimal(const my_decimal *);
int store_timestamp(my_time_t timestamp, ulong sec_part); int store_timestamp(my_time_t timestamp, ulong sec_part);
int save_in_field(Field *to); int save_in_field(Field *to);
@ -2699,7 +2699,7 @@ public:
int store(const char *to,uint length,CHARSET_INFO *charset); int store(const char *to,uint length,CHARSET_INFO *charset);
int store(double nr); int store(double nr);
int store(longlong nr, bool unsigned_val); int store(longlong nr, bool unsigned_val);
int store_time_dec(MYSQL_TIME *ltime, uint dec); int store_time_dec(const MYSQL_TIME *ltime, uint dec);
double val_real(void); double val_real(void);
longlong val_int(void); longlong val_int(void);
String *val_str(String*,String *); String *val_str(String*,String *);
@ -2780,9 +2780,14 @@ class Field_time :public Field_temporal {
*/ */
long curdays; long curdays;
protected: protected:
virtual void store_TIME(MYSQL_TIME *ltime); virtual void store_TIME(const MYSQL_TIME *ltime);
int store_TIME_with_warning(MYSQL_TIME *ltime, const ErrConv *str, int store_TIME_with_warning(MYSQL_TIME *ltime, const ErrConv *str,
int was_cut, int have_smth_to_conv); int was_cut, int have_smth_to_conv);
void set_warnings(Sql_condition::enum_warning_level level,
const ErrConv *str, int was_cut)
{
Field_temporal::set_warnings(level, str, was_cut, MYSQL_TIMESTAMP_TIME);
}
bool check_zero_in_date_with_warn(ulonglong fuzzydate); bool check_zero_in_date_with_warn(ulonglong fuzzydate);
static void do_field_time(Copy_field *copy); static void do_field_time(Copy_field *copy);
public: public:
@ -2809,7 +2814,7 @@ public:
return real_type() == from->real_type() && return real_type() == from->real_type() &&
decimals() == from->decimals(); decimals() == from->decimals();
} }
int store_time_dec(MYSQL_TIME *ltime, uint dec); int store_time_dec(const MYSQL_TIME *ltime, uint dec);
int store(const char *to,uint length,CHARSET_INFO *charset); int store(const char *to,uint length,CHARSET_INFO *charset);
int store(double nr); int store(double nr);
int store(longlong nr, bool unsigned_val); int store(longlong nr, bool unsigned_val);
@ -2864,7 +2869,7 @@ public:
*/ */
class Field_time_hires :public Field_time_with_dec { class Field_time_hires :public Field_time_with_dec {
longlong zero_point; longlong zero_point;
void store_TIME(MYSQL_TIME *ltime); void store_TIME(const MYSQL_TIME *);
public: public:
Field_time_hires(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg, Field_time_hires(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg, enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
@ -2890,7 +2895,7 @@ public:
TIME(0..6) - MySQL56 version TIME(0..6) - MySQL56 version
*/ */
class Field_timef :public Field_time_with_dec { class Field_timef :public Field_time_with_dec {
void store_TIME(MYSQL_TIME *ltime); void store_TIME(const MYSQL_TIME *ltime);
int save_field_metadata(uchar *metadata_ptr) int save_field_metadata(uchar *metadata_ptr)
{ {
*metadata_ptr= (uchar) decimals(); *metadata_ptr= (uchar) decimals();

2
sql/ha_partition.cc
View File

@ -244,7 +244,7 @@ ha_partition::ha_partition(handlerton *hton, TABLE_SHARE *share)
void ha_partition::ha_partition_init() void ha_partition::ha_partition_init()
{ {
init_alloc_root(&m_mem_root, 512, 512, MYF(0)); init_alloc_root(&m_mem_root, "ha_partition", 512, 512, MYF(0));
init_handler_variables(); init_handler_variables();
} }

41
sql/item.cc
View File

@ -1793,7 +1793,7 @@ Item_splocal::Item_splocal(THD *thd, const LEX_CSTRING *sp_var_name,
bool Item_splocal::fix_fields(THD *thd, Item **ref) bool Item_splocal::fix_fields(THD *thd, Item **ref)
{ {
Item *item= thd->spcont->get_item(m_var_idx); Item_field *item= thd->spcont->get_variable(m_var_idx);
set_handler(item->type_handler()); set_handler(item->type_handler());
return fix_fields_from_item(thd, ref, item); return fix_fields_from_item(thd, ref, item);
} }
@ -1804,7 +1804,7 @@ Item_splocal::this_item()
{ {
DBUG_ASSERT(m_sp == m_thd->spcont->m_sp); DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
DBUG_ASSERT(fixed); DBUG_ASSERT(fixed);
return m_thd->spcont->get_item(m_var_idx); return m_thd->spcont->get_variable(m_var_idx);
} }
const Item * const Item *
@ -1812,7 +1812,7 @@ Item_splocal::this_item() const
{ {
DBUG_ASSERT(m_sp == m_thd->spcont->m_sp); DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
DBUG_ASSERT(fixed); DBUG_ASSERT(fixed);
return m_thd->spcont->get_item(m_var_idx); return m_thd->spcont->get_variable(m_var_idx);
} }
@ -1821,7 +1821,7 @@ Item_splocal::this_item_addr(THD *thd, Item **)
{ {
DBUG_ASSERT(m_sp == thd->spcont->m_sp); DBUG_ASSERT(m_sp == thd->spcont->m_sp);
DBUG_ASSERT(fixed); DBUG_ASSERT(fixed);
return thd->spcont->get_item_addr(m_var_idx); return thd->spcont->get_variable_addr(m_var_idx);
} }
@ -1918,7 +1918,7 @@ bool Item_splocal::check_cols(uint n)
bool Item_splocal_row_field::fix_fields(THD *thd, Item **ref) bool Item_splocal_row_field::fix_fields(THD *thd, Item **ref)
{ {
Item *item= thd->spcont->get_item(m_var_idx)->element_index(m_field_idx); Item *item= thd->spcont->get_variable(m_var_idx)->element_index(m_field_idx);
return fix_fields_from_item(thd, ref, item); return fix_fields_from_item(thd, ref, item);
} }
@ -1928,7 +1928,7 @@ Item_splocal_row_field::this_item()
{ {
DBUG_ASSERT(m_sp == m_thd->spcont->m_sp); DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
DBUG_ASSERT(fixed); DBUG_ASSERT(fixed);
return m_thd->spcont->get_item(m_var_idx)->element_index(m_field_idx); return m_thd->spcont->get_variable(m_var_idx)->element_index(m_field_idx);
} }
@ -1937,7 +1937,7 @@ Item_splocal_row_field::this_item() const
{ {
DBUG_ASSERT(m_sp == m_thd->spcont->m_sp); DBUG_ASSERT(m_sp == m_thd->spcont->m_sp);
DBUG_ASSERT(fixed); DBUG_ASSERT(fixed);
return m_thd->spcont->get_item(m_var_idx)->element_index(m_field_idx); return m_thd->spcont->get_variable(m_var_idx)->element_index(m_field_idx);
} }
@ -1946,7 +1946,7 @@ Item_splocal_row_field::this_item_addr(THD *thd, Item **)
{ {
DBUG_ASSERT(m_sp == thd->spcont->m_sp); DBUG_ASSERT(m_sp == thd->spcont->m_sp);
DBUG_ASSERT(fixed); DBUG_ASSERT(fixed);
return thd->spcont->get_item(m_var_idx)->addr(m_field_idx); return thd->spcont->get_variable(m_var_idx)->addr(m_field_idx);
} }
@ -1977,7 +1977,7 @@ bool Item_splocal_row_field_by_name::fix_fields(THD *thd, Item **it)
m_var_idx, m_var_idx,
m_field_name)) m_field_name))
return true; return true;
Item *item= thd->spcont->get_item(m_var_idx)->element_index(m_field_idx); Item *item= thd->spcont->get_variable(m_var_idx)->element_index(m_field_idx);
set_handler(item->type_handler()); set_handler(item->type_handler());
return fix_fields_from_item(thd, it, item); return fix_fields_from_item(thd, it, item);
} }
@ -2899,7 +2899,7 @@ Item_sp::execute_impl(THD *thd, Item **args, uint arg_count)
(m_sp->agg_type() == NOT_AGGREGATE && !func_ctx)); (m_sp->agg_type() == NOT_AGGREGATE && !func_ctx));
if (!func_ctx) if (!func_ctx)
{ {
init_sql_alloc(&sp_mem_root, MEM_ROOT_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&sp_mem_root, "Item_sp", MEM_ROOT_BLOCK_SIZE, 0, MYF(0));
*sp_query_arena= Query_arena(&sp_mem_root, *sp_query_arena= Query_arena(&sp_mem_root,
Query_arena::STMT_INITIALIZED_FOR_SP); Query_arena::STMT_INITIALIZED_FOR_SP);
} }
@ -4009,7 +4009,10 @@ Item_param::Item_param(THD *thd, const LEX_CSTRING *name_arg,
void Item_param::set_null() void Item_param::set_null()
{ {
DBUG_ENTER("Item_param::set_null"); DBUG_ENTER("Item_param::set_null");
/* These are cleared after each execution by reset() method */ /*
These are cleared after each execution by reset() method or by setting
other value.
*/
null_value= 1; null_value= 1;
/* /*
Because of NULL and string values we need to set max_length for each new Because of NULL and string values we need to set max_length for each new
@ -4033,6 +4036,7 @@ void Item_param::set_int(longlong i, uint32 max_length_arg)
max_length= max_length_arg; max_length= max_length_arg;
decimals= 0; decimals= 0;
maybe_null= 0; maybe_null= 0;
null_value= 0;
fix_type(Item::INT_ITEM); fix_type(Item::INT_ITEM);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -4047,6 +4051,7 @@ void Item_param::set_double(double d)
max_length= DBL_DIG + 8; max_length= DBL_DIG + 8;
decimals= NOT_FIXED_DEC; decimals= NOT_FIXED_DEC;
maybe_null= 0; maybe_null= 0;
null_value= 0;
fix_type(Item::REAL_ITEM); fix_type(Item::REAL_ITEM);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -4079,6 +4084,7 @@ void Item_param::set_decimal(const char *str, ulong length)
my_decimal_precision_to_length_no_truncation(value.m_decimal.precision(), my_decimal_precision_to_length_no_truncation(value.m_decimal.precision(),
decimals, unsigned_flag); decimals, unsigned_flag);
maybe_null= 0; maybe_null= 0;
null_value= 0;
fix_type(Item::DECIMAL_ITEM); fix_type(Item::DECIMAL_ITEM);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -4095,6 +4101,8 @@ void Item_param::set_decimal(const my_decimal *dv, bool unsigned_arg)
unsigned_flag= unsigned_arg; unsigned_flag= unsigned_arg;
max_length= my_decimal_precision_to_length(value.m_decimal.intg + decimals, max_length= my_decimal_precision_to_length(value.m_decimal.intg + decimals,
decimals, unsigned_flag); decimals, unsigned_flag);
maybe_null= 0;
null_value= 0;
fix_type(Item::DECIMAL_ITEM); fix_type(Item::DECIMAL_ITEM);
} }
@ -4105,6 +4113,8 @@ void Item_param::fix_temporal(uint32 max_length_arg, uint decimals_arg)
collation.set_numeric(); collation.set_numeric();
max_length= max_length_arg; max_length= max_length_arg;
decimals= decimals_arg; decimals= decimals_arg;
maybe_null= 0;
null_value= 0;
fix_type(Item::DATE_ITEM); fix_type(Item::DATE_ITEM);
} }
@ -4114,6 +4124,8 @@ void Item_param::set_time(const MYSQL_TIME *tm,
{ {
DBUG_ASSERT(value.type_handler()->cmp_type() == TIME_RESULT); DBUG_ASSERT(value.type_handler()->cmp_type() == TIME_RESULT);
value.time= *tm; value.time= *tm;
maybe_null= 0;
null_value= 0;
fix_temporal(max_length_arg, decimals_arg); fix_temporal(max_length_arg, decimals_arg);
} }
@ -4148,6 +4160,7 @@ void Item_param::set_time(MYSQL_TIME *tm, timestamp_type time_type,
set_zero_time(&value.time, MYSQL_TIMESTAMP_ERROR); set_zero_time(&value.time, MYSQL_TIMESTAMP_ERROR);
} }
maybe_null= 0; maybe_null= 0;
null_value= 0;
fix_temporal(max_length_arg, fix_temporal(max_length_arg,
tm->second_part > 0 ? TIME_SECOND_PART_DIGITS : 0); tm->second_part > 0 ? TIME_SECOND_PART_DIGITS : 0);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
@ -4184,6 +4197,7 @@ bool Item_param::set_str(const char *str, ulong length,
collation.set(tocs, DERIVATION_COERCIBLE); collation.set(tocs, DERIVATION_COERCIBLE);
max_length= length; max_length= length;
maybe_null= 0; maybe_null= 0;
null_value= 0;
/* max_length and decimals are set after charset conversion */ /* max_length and decimals are set after charset conversion */
/* sic: str may be not null-terminated, don't add DBUG_PRINT here */ /* sic: str may be not null-terminated, don't add DBUG_PRINT here */
fix_type(Item::STRING_ITEM); fix_type(Item::STRING_ITEM);
@ -4219,6 +4233,7 @@ bool Item_param::set_longdata(const char *str, ulong length)
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
state= LONG_DATA_VALUE; state= LONG_DATA_VALUE;
maybe_null= 0; maybe_null= 0;
null_value= 0;
fix_type(Item::STRING_ITEM); fix_type(Item::STRING_ITEM);
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);
@ -4878,7 +4893,9 @@ Item_param::set_value(THD *thd, sp_rcontext *ctx, Item **it)
set_null(); set_null();
return false; return false;
} }
return null_value= false; /* It is wrapper => other set_* shoud set null_value */
DBUG_ASSERT(null_value == false);
return false;
} }

3
sql/log.cc
View File

@ -10005,7 +10005,8 @@ int TC_LOG_BINLOG::recover(LOG_INFO *linfo, const char *last_log_name,
goto err1; goto err1;
if (do_xa) if (do_xa)
init_alloc_root(&mem_root, TC_LOG_PAGE_SIZE, TC_LOG_PAGE_SIZE, MYF(0)); init_alloc_root(&mem_root, "TC_LOG_BINLOG", TC_LOG_PAGE_SIZE,
TC_LOG_PAGE_SIZE, MYF(0));
fdle->flags&= ~LOG_EVENT_BINLOG_IN_USE_F; // abort on the first error fdle->flags&= ~LOG_EVENT_BINLOG_IN_USE_F; // abort on the first error

4
sql/mysqld.cc
View File

@ -1375,7 +1375,7 @@ private:
void Buffered_logs::init() void Buffered_logs::init()
{ {
init_alloc_root(&m_root, 1024, 0, MYF(0)); init_alloc_root(&m_root, "Buffered_logs", 1024, 0, MYF(0));
} }
void Buffered_logs::cleanup() void Buffered_logs::cleanup()
@ -8753,7 +8753,7 @@ static int option_cmp(my_option *a, my_option *b)
static void print_help() static void print_help()
{ {
MEM_ROOT mem_root; MEM_ROOT mem_root;
init_alloc_root(&mem_root, 4096, 4096, MYF(0)); init_alloc_root(&mem_root, "help", 4096, 4096, MYF(0));
pop_dynamic(&all_options); pop_dynamic(&all_options);
add_many_options(&all_options, pfs_early_options, add_many_options(&all_options, pfs_early_options,

24
sql/opt_range.cc
View File

@ -1254,7 +1254,8 @@ QUICK_RANGE_SELECT::QUICK_RANGE_SELECT(THD *thd, TABLE *table, uint key_nr,
if (!no_alloc && !parent_alloc) if (!no_alloc && !parent_alloc)
{ {
// Allocates everything through the internal memroot // Allocates everything through the internal memroot
init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0, init_sql_alloc(&alloc, "QUICK_RANGE_SELECT",
thd->variables.range_alloc_block_size, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
thd->mem_root= &alloc; thd->mem_root= &alloc;
} }
@ -1351,7 +1352,8 @@ QUICK_INDEX_SORT_SELECT::QUICK_INDEX_SORT_SELECT(THD *thd_param,
index= MAX_KEY; index= MAX_KEY;
head= table; head= table;
bzero(&read_record, sizeof(read_record)); bzero(&read_record, sizeof(read_record));
init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0, init_sql_alloc(&alloc, "QUICK_INDEX_SORT_SELECT",
thd->variables.range_alloc_block_size, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -1422,7 +1424,8 @@ QUICK_ROR_INTERSECT_SELECT::QUICK_ROR_INTERSECT_SELECT(THD *thd_param,
head= table; head= table;
record= head->record[0]; record= head->record[0];
if (!parent_alloc) if (!parent_alloc)
init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0, init_sql_alloc(&alloc, "QUICK_ROR_INTERSECT_SELECT",
thd->variables.range_alloc_block_size, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
else else
bzero(&alloc, sizeof(MEM_ROOT)); bzero(&alloc, sizeof(MEM_ROOT));
@ -1698,7 +1701,8 @@ QUICK_ROR_UNION_SELECT::QUICK_ROR_UNION_SELECT(THD *thd_param,
head= table; head= table;
rowid_length= table->file->ref_length; rowid_length= table->file->ref_length;
record= head->record[0]; record= head->record[0];
init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0, init_sql_alloc(&alloc, "QUICK_ROR_UNION_SELECT",
thd->variables.range_alloc_block_size, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
thd_param->mem_root= &alloc; thd_param->mem_root= &alloc;
} }
@ -2453,7 +2457,8 @@ int SQL_SELECT::test_quick_select(THD *thd, key_map keys_to_use,
param.possible_keys.clear_all(); param.possible_keys.clear_all();
thd->no_errors=1; // Don't warn about NULL thd->no_errors=1; // Don't warn about NULL
init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0, init_sql_alloc(&alloc, "test_quick_select",
thd->variables.range_alloc_block_size, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
if (!(param.key_parts= if (!(param.key_parts=
(KEY_PART*) alloc_root(&alloc, (KEY_PART*) alloc_root(&alloc,
@ -3027,7 +3032,8 @@ bool calculate_cond_selectivity_for_table(THD *thd, TABLE *table, Item **cond)
SEL_TREE *tree; SEL_TREE *tree;
double rows; double rows;
init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0, init_sql_alloc(&alloc, "calculate_cond_selectivity_for_table",
thd->variables.range_alloc_block_size, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
param.thd= thd; param.thd= thd;
param.mem_root= &alloc; param.mem_root= &alloc;
@ -3444,7 +3450,8 @@ bool prune_partitions(THD *thd, TABLE *table, Item *pprune_cond)
my_bitmap_map *old_sets[2]; my_bitmap_map *old_sets[2];
prune_param.part_info= part_info; prune_param.part_info= part_info;
init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0, init_sql_alloc(&alloc, "prune_partitions",
thd->variables.range_alloc_block_size, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
range_par->mem_root= &alloc; range_par->mem_root= &alloc;
range_par->old_root= thd->mem_root; range_par->old_root= thd->mem_root;
@ -13621,7 +13628,8 @@ QUICK_GROUP_MIN_MAX_SELECT(TABLE *table, JOIN *join_arg, bool have_min_arg,
DBUG_ASSERT(!parent_alloc); DBUG_ASSERT(!parent_alloc);
if (!parent_alloc) if (!parent_alloc)
{ {
init_sql_alloc(&alloc, join->thd->variables.range_alloc_block_size, 0, init_sql_alloc(&alloc, "QUICK_GROUP_MIN_MAX_SELECT",
join->thd->variables.range_alloc_block_size, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
join->thd->mem_root= &alloc; join->thd->mem_root= &alloc;
} }

3
sql/opt_subselect.cc
View File

@ -4129,7 +4129,8 @@ SJ_TMP_TABLE::create_sj_weedout_tmp_table(THD *thd)
using_unique_constraint= TRUE; using_unique_constraint= TRUE;
/* STEP 3: Allocate memory for temptable description */ /* STEP 3: Allocate memory for temptable description */
init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC)); init_sql_alloc(&own_root, "SJ_TMP_TABLE",
TABLE_ALLOC_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC));
if (!multi_alloc_root(&own_root, if (!multi_alloc_root(&own_root,
&table, sizeof(*table), &table, sizeof(*table),
&share, sizeof(*share), &share, sizeof(*share),

3
sql/rpl_tblmap.cc
View File

@ -46,7 +46,8 @@ table_mapping::table_mapping()
offsetof(entry,table_id),sizeof(ulong), offsetof(entry,table_id),sizeof(ulong),
0,0,0); 0,0,0);
/* We don't preallocate any block, this is consistent with m_free=0 above */ /* We don't preallocate any block, this is consistent with m_free=0 above */
init_alloc_root(&m_mem_root, TABLE_ID_HASH_SIZE*sizeof(entry), 0, MYF(0)); init_alloc_root(&m_mem_root, "table_mapping",
TABLE_ID_HASH_SIZE*sizeof(entry), 0, MYF(0));
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }

24
sql/sp_head.cc
View File

@ -471,7 +471,8 @@ sp_head::operator new(size_t size) throw()
MEM_ROOT own_root; MEM_ROOT own_root;
sp_head *sp; sp_head *sp;
init_sql_alloc(&own_root, MEM_ROOT_BLOCK_SIZE, MEM_ROOT_PREALLOC, MYF(0)); init_sql_alloc(&own_root, "sp_head",
MEM_ROOT_BLOCK_SIZE, MEM_ROOT_PREALLOC, MYF(0));
sp= (sp_head *) alloc_root(&own_root, size); sp= (sp_head *) alloc_root(&own_root, size);
if (sp == NULL) if (sp == NULL)
DBUG_RETURN(NULL); DBUG_RETURN(NULL);
@ -999,7 +1000,8 @@ sp_head::execute(THD *thd, bool merge_da_on_success)
thd->select_number+= m_select_number; thd->select_number+= m_select_number;
/* init per-instruction memroot */ /* init per-instruction memroot */
init_sql_alloc(&execute_mem_root, MEM_ROOT_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&execute_mem_root, "per_instruction_memroot",
MEM_ROOT_BLOCK_SIZE, 0, MYF(0));
DBUG_ASSERT(!(m_flags & IS_INVOKED)); DBUG_ASSERT(!(m_flags & IS_INVOKED));
m_flags|= IS_INVOKED; m_flags|= IS_INVOKED;
@ -1520,7 +1522,6 @@ sp_head::execute_trigger(THD *thd,
MEM_ROOT call_mem_root; MEM_ROOT call_mem_root;
Query_arena call_arena(&call_mem_root, Query_arena::STMT_INITIALIZED_FOR_SP); Query_arena call_arena(&call_mem_root, Query_arena::STMT_INITIALIZED_FOR_SP);
Query_arena backup_arena; Query_arena backup_arena;
DBUG_ENTER("sp_head::execute_trigger"); DBUG_ENTER("sp_head::execute_trigger");
DBUG_PRINT("info", ("trigger %s", m_name.str)); DBUG_PRINT("info", ("trigger %s", m_name.str));
@ -1576,7 +1577,8 @@ sp_head::execute_trigger(THD *thd,
TODO: we should create sp_rcontext once per command and reuse it TODO: we should create sp_rcontext once per command and reuse it
on subsequent executions of a trigger. on subsequent executions of a trigger.
*/ */
init_sql_alloc(&call_mem_root, MEM_ROOT_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&call_mem_root, "execute_trigger", MEM_ROOT_BLOCK_SIZE, 0,
MYF(0));
thd->set_n_backup_active_arena(&call_arena, &backup_arena); thd->set_n_backup_active_arena(&call_arena, &backup_arena);
Row_definition_list defs; Row_definition_list defs;
@ -1713,7 +1715,7 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
/* Arguments must be fixed in Item_func_sp::fix_fields */ /* Arguments must be fixed in Item_func_sp::fix_fields */
DBUG_ASSERT(argp[arg_no]->fixed); DBUG_ASSERT(argp[arg_no]->fixed);
if ((err_status= (*func_ctx)->set_variable(thd, arg_no, &(argp[arg_no])))) if ((err_status= (*func_ctx)->set_parameter(thd, arg_no, &(argp[arg_no]))))
goto err_with_cleanup; goto err_with_cleanup;
} }
@ -1745,7 +1747,7 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
if (arg_no) if (arg_no)
binlog_buf.append(','); binlog_buf.append(',');
Item *item= (*func_ctx)->get_item(arg_no); Item_field *item= (*func_ctx)->get_parameter(arg_no);
str_value= item->type_handler()->print_item_value(thd, item, str_value= item->type_handler()->print_item_value(thd, item,
&str_value_holder); &str_value_holder);
if (str_value) if (str_value)
@ -1958,7 +1960,7 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
Item *tmp_item= null_item; Item *tmp_item= null_item;
if (!null_item || if (!null_item ||
nctx->set_variable(thd, i, &tmp_item)) nctx->set_parameter(thd, i, &tmp_item))
{ {
DBUG_PRINT("error", ("set variable failed")); DBUG_PRINT("error", ("set variable failed"));
err_status= TRUE; err_status= TRUE;
@ -1967,7 +1969,7 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
} }
else else
{ {
if (nctx->set_variable(thd, i, it_args.ref())) if (nctx->set_parameter(thd, i, it_args.ref()))
{ {
DBUG_PRINT("error", ("set variable 2 failed")); DBUG_PRINT("error", ("set variable 2 failed"));
err_status= TRUE; err_status= TRUE;
@ -2095,7 +2097,7 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
DBUG_ASSERT(srp); DBUG_ASSERT(srp);
if (srp->set_value(thd, octx, nctx->get_item_addr(i))) if (srp->set_value(thd, octx, nctx->get_variable_addr(i)))
{ {
DBUG_PRINT("error", ("set value failed")); DBUG_PRINT("error", ("set value failed"));
err_status= TRUE; err_status= TRUE;
@ -2103,7 +2105,7 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
} }
Send_field *out_param_info= new (thd->mem_root) Send_field(); Send_field *out_param_info= new (thd->mem_root) Send_field();
nctx->get_item(i)->make_field(thd, out_param_info); nctx->get_parameter(i)->make_field(thd, out_param_info);
out_param_info->db_name= m_db.str; out_param_info->db_name= m_db.str;
out_param_info->table_name= m_name.str; out_param_info->table_name= m_name.str;
out_param_info->org_table_name= m_name.str; out_param_info->org_table_name= m_name.str;
@ -4204,7 +4206,7 @@ sp_instr_cursor_copy_struct::exec_core(THD *thd, uint *nextp)
{ {
DBUG_ENTER("sp_instr_cursor_copy_struct::exec_core"); DBUG_ENTER("sp_instr_cursor_copy_struct::exec_core");
int ret= 0; int ret= 0;
Item_field_row *row= (Item_field_row*) thd->spcont->get_item(m_var); Item_field_row *row= (Item_field_row*) thd->spcont->get_variable(m_var);
DBUG_ASSERT(row->type_handler() == &type_handler_row); DBUG_ASSERT(row->type_handler() == &type_handler_row);
/* /*

12
sql/sp_rcontext.cc
View File

@ -316,7 +316,7 @@ bool sp_rcontext::init_var_items(THD *thd,
uint num_vars= m_root_parsing_ctx->max_var_index(); uint num_vars= m_root_parsing_ctx->max_var_index();
m_var_items.reset( m_var_items.reset(
static_cast<Item **> ( static_cast<Item_field **> (
thd->alloc(num_vars * sizeof (Item *))), thd->alloc(num_vars * sizeof (Item *))),
num_vars); num_vars);
@ -633,7 +633,7 @@ int sp_rcontext::set_variable_row_field_by_name(THD *thd, uint var_idx,
int sp_rcontext::set_variable_row(THD *thd, uint var_idx, List<Item> &items) int sp_rcontext::set_variable_row(THD *thd, uint var_idx, List<Item> &items)
{ {
DBUG_ENTER("sp_rcontext::set_variable_row"); DBUG_ENTER("sp_rcontext::set_variable_row");
DBUG_ASSERT(get_item(var_idx)->cols() == items.elements); DBUG_ASSERT(get_variable(var_idx)->cols() == items.elements);
Virtual_tmp_table *vtable= virtual_tmp_table_for_row(var_idx); Virtual_tmp_table *vtable= virtual_tmp_table_for_row(var_idx);
Sp_eval_expr_state state(thd); Sp_eval_expr_state state(thd);
DBUG_RETURN(vtable->sp_set_all_fields_from_item_list(thd, items)); DBUG_RETURN(vtable->sp_set_all_fields_from_item_list(thd, items));
@ -642,8 +642,8 @@ int sp_rcontext::set_variable_row(THD *thd, uint var_idx, List<Item> &items)
Virtual_tmp_table *sp_rcontext::virtual_tmp_table_for_row(uint var_idx) Virtual_tmp_table *sp_rcontext::virtual_tmp_table_for_row(uint var_idx)
{ {
DBUG_ASSERT(get_item(var_idx)->type() == Item::FIELD_ITEM); DBUG_ASSERT(get_variable(var_idx)->type() == Item::FIELD_ITEM);
DBUG_ASSERT(get_item(var_idx)->cmp_type() == ROW_RESULT); DBUG_ASSERT(get_variable(var_idx)->cmp_type() == ROW_RESULT);
Field *field= m_var_table->field[var_idx]; Field *field= m_var_table->field[var_idx];
Virtual_tmp_table **ptable= field->virtual_tmp_table_addr(); Virtual_tmp_table **ptable= field->virtual_tmp_table_addr();
DBUG_ASSERT(ptable); DBUG_ASSERT(ptable);
@ -808,7 +808,7 @@ int sp_cursor::fetch(THD *thd, List<sp_variable> *vars, bool error_on_no_data)
if (vars->elements != result.get_field_count() && if (vars->elements != result.get_field_count() &&
(vars->elements != 1 || (vars->elements != 1 ||
result.get_field_count() != result.get_field_count() !=
thd->spcont->get_item(vars->head()->offset)->cols())) thd->spcont->get_variable(vars->head()->offset)->cols()))
{ {
my_message(ER_SP_WRONG_NO_OF_FETCH_ARGS, my_message(ER_SP_WRONG_NO_OF_FETCH_ARGS,
ER_THD(thd, ER_SP_WRONG_NO_OF_FETCH_ARGS), MYF(0)); ER_THD(thd, ER_SP_WRONG_NO_OF_FETCH_ARGS), MYF(0));
@ -906,7 +906,7 @@ int sp_cursor::Select_fetch_into_spvars::send_data(List<Item> &items)
on attempt to assign a scalar value to a ROW variable. on attempt to assign a scalar value to a ROW variable.
*/ */
return spvar_list->elements == 1 && return spvar_list->elements == 1 &&
(item= thd->spcont->get_item(spvar_list->head()->offset)) && (item= thd->spcont->get_variable(spvar_list->head()->offset)) &&
item->type_handler() == &type_handler_row && item->type_handler() == &type_handler_row &&
item->cols() == items.elements ? item->cols() == items.elements ?
thd->spcont->set_variable_row(thd, spvar_list->head()->offset, items) : thd->spcont->set_variable_row(thd, spvar_list->head()->offset, items) :

26
sql/sp_rcontext.h
View File

@ -191,6 +191,11 @@ public:
// SP-variables. // SP-variables.
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
uint argument_count() const
{
return m_root_parsing_ctx->context_var_count();
}
int set_variable(THD *thd, uint var_idx, Item **value); int set_variable(THD *thd, uint var_idx, Item **value);
int set_variable_row_field(THD *thd, uint var_idx, uint field_idx, int set_variable_row_field(THD *thd, uint var_idx, uint field_idx,
Item **value); Item **value);
@ -198,11 +203,24 @@ public:
const LEX_CSTRING &field_name, const LEX_CSTRING &field_name,
Item **value); Item **value);
int set_variable_row(THD *thd, uint var_idx, List<Item> &items); int set_variable_row(THD *thd, uint var_idx, List<Item> &items);
Item *get_item(uint var_idx) const
int set_parameter(THD *thd, uint var_idx, Item **value)
{
DBUG_ASSERT(var_idx < argument_count());
return set_variable(thd, var_idx, value);
}
Item_field *get_variable(uint var_idx) const
{ return m_var_items[var_idx]; } { return m_var_items[var_idx]; }
Item **get_item_addr(uint var_idx) const Item **get_variable_addr(uint var_idx) const
{ return m_var_items.array() + var_idx; } { return ((Item **) m_var_items.array()) + var_idx; }
Item_field *get_parameter(uint var_idx) const
{
DBUG_ASSERT(var_idx < argument_count());
return get_variable(var_idx);
}
bool find_row_field_by_name_or_error(uint *field_idx, uint var_idx, bool find_row_field_by_name_or_error(uint *field_idx, uint var_idx,
const LEX_CSTRING &field_name); const LEX_CSTRING &field_name);
@ -381,7 +399,7 @@ private:
/// Collection of Item_field proxies, each of them points to the /// Collection of Item_field proxies, each of them points to the
/// corresponding field in m_var_table. /// corresponding field in m_var_table.
Bounds_checked_array<Item *> m_var_items; Bounds_checked_array<Item_field *> m_var_items;
/// This is a pointer to a field, which should contain return value for /// This is a pointer to a field, which should contain return value for
/// stored functions (only). For stored procedures, this pointer is NULL. /// stored functions (only). For stored procedures, this pointer is NULL.

6
sql/sql_acl.cc
View File

@ -1818,7 +1818,7 @@ static bool acl_load(THD *thd, const Grant_tables& tables)
grant_version++; /* Privileges updated */ grant_version++; /* Privileges updated */
const Host_table& host_table= tables.host_table(); const Host_table& host_table= tables.host_table();
init_sql_alloc(&acl_memroot, ACL_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&acl_memroot, "ACL", ACL_ALLOC_BLOCK_SIZE, 0, MYF(0));
if (host_table.table_exists()) // "host" table may not exist (e.g. in MySQL 5.6.7+) if (host_table.table_exists()) // "host" table may not exist (e.g. in MySQL 5.6.7+)
{ {
if (host_table.init_read_record(&read_record_info, thd)) if (host_table.init_read_record(&read_record_info, thd))
@ -2237,7 +2237,7 @@ static bool acl_load(THD *thd, const Grant_tables& tables)
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
MEM_ROOT temp_root; MEM_ROOT temp_root;
init_alloc_root(&temp_root, ACL_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_alloc_root(&temp_root, "ACL_tmp", ACL_ALLOC_BLOCK_SIZE, 0, MYF(0));
while (!(read_record_info.read_record())) while (!(read_record_info.read_record()))
{ {
char *hostname= safe_str(get_field(&temp_root, roles_mapping_table.host())); char *hostname= safe_str(get_field(&temp_root, roles_mapping_table.host()));
@ -7304,7 +7304,7 @@ static bool grant_load(THD *thd,
0,0,0, (my_hash_get_key) get_grant_table, 0,0); 0,0,0, (my_hash_get_key) get_grant_table, 0,0);
(void) my_hash_init(&func_priv_hash, &my_charset_utf8_bin, (void) my_hash_init(&func_priv_hash, &my_charset_utf8_bin,
0,0,0, (my_hash_get_key) get_grant_table, 0,0); 0,0,0, (my_hash_get_key) get_grant_table, 0,0);
init_sql_alloc(&grant_memroot, ACL_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&grant_memroot, "GRANT", ACL_ALLOC_BLOCK_SIZE, 0, MYF(0));
t_table= tables_priv.table(); t_table= tables_priv.table();
c_table= columns_priv.table(); c_table= columns_priv.table();

6
sql/sql_class.cc
View File

@ -781,8 +781,8 @@ THD::THD(my_thread_id id, bool is_wsrep_applier, bool skip_global_sys_var_lock)
the destructor works OK in case of an error. The main_mem_root the destructor works OK in case of an error. The main_mem_root
will be re-initialized in init_for_queries(). will be re-initialized in init_for_queries().
*/ */
init_sql_alloc(&main_mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0, init_sql_alloc(&main_mem_root, "THD::main_mem_root",
MYF(MY_THREAD_SPECIFIC)); ALLOC_ROOT_MIN_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC));
stmt_arena= this; stmt_arena= this;
thread_stack= 0; thread_stack= 0;
@ -3727,7 +3727,7 @@ int select_dumpvar::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
mvsp->type_handler() == &type_handler_row) mvsp->type_handler() == &type_handler_row)
{ {
// SELECT INTO row_type_sp_variable // SELECT INTO row_type_sp_variable
if (thd->spcont->get_item(mvsp->offset)->cols() != list.elements) if (thd->spcont->get_variable(mvsp->offset)->cols() != list.elements)
goto error; goto error;
m_var_sp_row= mvsp; m_var_sp_row= mvsp;
return 0; return 0;

6
sql/sql_class.h
View File

@ -1845,7 +1845,8 @@ public:
m_reopen_array(NULL), m_reopen_array(NULL),
m_locked_tables_count(0) m_locked_tables_count(0)
{ {
init_sql_alloc(&m_locked_tables_root, MEM_ROOT_BLOCK_SIZE, 0, init_sql_alloc(&m_locked_tables_root, "Locked_tables_list",
MEM_ROOT_BLOCK_SIZE, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
} }
void unlock_locked_tables(THD *thd); void unlock_locked_tables(THD *thd);
@ -2610,7 +2611,8 @@ public:
{ {
bzero((char*)this, sizeof(*this)); bzero((char*)this, sizeof(*this));
xid_state.xid.null(); xid_state.xid.null();
init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0, init_sql_alloc(&mem_root, "THD::transactions",
ALLOC_ROOT_MIN_BLOCK_SIZE, 0,
MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
} }
} transaction; } transaction;

2
sql/sql_error.cc
View File

@ -506,7 +506,7 @@ void Warning_info::init()
{ {
/* Initialize sub structures */ /* Initialize sub structures */
DBUG_ASSERT(initialized == 0); DBUG_ASSERT(initialized == 0);
init_sql_alloc(&m_warn_root, WARN_ALLOC_BLOCK_SIZE, init_sql_alloc(&m_warn_root, "Warning_info", WARN_ALLOC_BLOCK_SIZE,
WARN_ALLOC_PREALLOC_SIZE, MYF(MY_THREAD_SPECIFIC)); WARN_ALLOC_PREALLOC_SIZE, MYF(MY_THREAD_SPECIFIC));
initialized= 1; initialized= 1;
} }

3
sql/sql_handler.cc
View File

@ -382,7 +382,8 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, SQL_HANDLER *reopen)
/* copy data to sql_handler */ /* copy data to sql_handler */
if (!(sql_handler= new SQL_HANDLER(thd))) if (!(sql_handler= new SQL_HANDLER(thd)))
goto err; goto err;
init_alloc_root(&sql_handler->mem_root, 1024, 0, MYF(MY_THREAD_SPECIFIC)); init_alloc_root(&sql_handler->mem_root, "sql_handler", 1024, 0,
MYF(MY_THREAD_SPECIFIC));
sql_handler->db.length= tables->db.length; sql_handler->db.length= tables->db.length;
sql_handler->table_name.length= tables->table_name.length; sql_handler->table_name.length= tables->table_name.length;

4
sql/sql_lex.cc
View File

@ -4851,8 +4851,8 @@ bool LEX::set_arena_for_set_stmt(Query_arena *backup)
mem_root_for_set_stmt= new MEM_ROOT(); mem_root_for_set_stmt= new MEM_ROOT();
if (!(mem_root_for_set_stmt)) if (!(mem_root_for_set_stmt))
DBUG_RETURN(1); DBUG_RETURN(1);
init_sql_alloc(mem_root_for_set_stmt, ALLOC_ROOT_SET, ALLOC_ROOT_SET, init_sql_alloc(mem_root_for_set_stmt, "set_stmt",
MYF(MY_THREAD_SPECIFIC)); ALLOC_ROOT_SET, ALLOC_ROOT_SET, MYF(MY_THREAD_SPECIFIC));
} }
if (!(arena_for_set_stmt= new(mem_root_for_set_stmt) if (!(arena_for_set_stmt= new(mem_root_for_set_stmt)
Query_arena_memroot(mem_root_for_set_stmt, Query_arena_memroot(mem_root_for_set_stmt,

8
sql/sql_plugin.cc
View File

@ -1187,7 +1187,7 @@ static bool plugin_add(MEM_ROOT *tmp_root,
goto err; goto err;
if (my_hash_insert(&plugin_hash[plugin->type], (uchar*)tmp_plugin_ptr)) if (my_hash_insert(&plugin_hash[plugin->type], (uchar*)tmp_plugin_ptr))
tmp_plugin_ptr->state= PLUGIN_IS_FREED; tmp_plugin_ptr->state= PLUGIN_IS_FREED;
init_alloc_root(&tmp_plugin_ptr->mem_root, 4096, 4096, MYF(0)); init_alloc_root(&tmp_plugin_ptr->mem_root, "plugin", 4096, 4096, MYF(0));
if (name->str) if (name->str)
DBUG_RETURN(FALSE); // all done DBUG_RETURN(FALSE); // all done
@ -1577,9 +1577,9 @@ int plugin_init(int *argc, char **argv, int flags)
dlopen_count =0; dlopen_count =0;
init_alloc_root(&plugin_mem_root, 4096, 4096, MYF(0)); init_alloc_root(&plugin_mem_root, "plugin", 4096, 4096, MYF(0));
init_alloc_root(&plugin_vars_mem_root, 4096, 4096, MYF(0)); init_alloc_root(&plugin_vars_mem_root, "plugin_vars", 4096, 4096, MYF(0));
init_alloc_root(&tmp_root, 4096, 4096, MYF(0)); init_alloc_root(&tmp_root, "plugin_tmp", 4096, 4096, MYF(0));
if (my_hash_init(&bookmark_hash, &my_charset_bin, 32, 0, 0, if (my_hash_init(&bookmark_hash, &my_charset_bin, 32, 0, 0,
get_bookmark_hash_key, NULL, HASH_UNIQUE)) get_bookmark_hash_key, NULL, HASH_UNIQUE))

9
sql/sql_prepare.cc
View File

@ -3699,8 +3699,10 @@ Prepared_statement::Prepared_statement(THD *thd_arg)
read_types(0), read_types(0),
m_sql_mode(thd->variables.sql_mode) m_sql_mode(thd->variables.sql_mode)
{ {
init_sql_alloc(&main_mem_root, thd_arg->variables.query_alloc_block_size, init_sql_alloc(&main_mem_root, "Prepared_statement",
thd_arg->variables.query_prealloc_size, MYF(MY_THREAD_SPECIFIC)); thd_arg->variables.query_alloc_block_size,
thd_arg->variables.query_prealloc_size,
MYF(MY_THREAD_SPECIFIC));
*last_error= '\0'; *last_error= '\0';
} }
@ -5359,7 +5361,8 @@ bool Protocol_local::send_result_set_metadata(List<Item> *columns, uint)
{ {
DBUG_ASSERT(m_rset == 0 && !alloc_root_inited(&m_rset_root)); DBUG_ASSERT(m_rset == 0 && !alloc_root_inited(&m_rset_root));
init_sql_alloc(&m_rset_root, MEM_ROOT_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC)); init_sql_alloc(&m_rset_root, "send_result_set_metadata",
MEM_ROOT_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC));
if (! (m_rset= new (&m_rset_root) List<Ed_row>)) if (! (m_rset= new (&m_rset_root) List<Ed_row>))
return TRUE; return TRUE;

5
sql/sql_repl.cc
View File

@ -1224,8 +1224,9 @@ gtid_find_binlog_file(slave_connection_state *state, char *out_name,
const char *errormsg= NULL; const char *errormsg= NULL;
char buf[FN_REFLEN]; char buf[FN_REFLEN];
init_alloc_root(&memroot, 10*(FN_REFLEN+sizeof(binlog_file_entry)), 0, init_alloc_root(&memroot, "gtid_find_binlog_file",
MYF(MY_THREAD_SPECIFIC)); 10*(FN_REFLEN+sizeof(binlog_file_entry)),
0, MYF(MY_THREAD_SPECIFIC));
if (!(list= get_binlog_list(&memroot))) if (!(list= get_binlog_list(&memroot)))
{ {
errormsg= "Out of memory while looking for GTID position in binlog"; errormsg= "Out of memory while looking for GTID position in binlog";

17
sql/sql_select.cc
View File

@ -17145,7 +17145,8 @@ create_tmp_table(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields,
if (param->precomputed_group_by) if (param->precomputed_group_by)
copy_func_count+= param->sum_func_count; copy_func_count+= param->sum_func_count;
init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC)); init_sql_alloc(&own_root, "tmp_table", TABLE_ALLOC_BLOCK_SIZE, 0,
MYF(MY_THREAD_SPECIFIC));
if (!multi_alloc_root(&own_root, if (!multi_alloc_root(&own_root,
&table, sizeof(*table), &table, sizeof(*table),
@ -17899,18 +17900,19 @@ bool Virtual_tmp_table::init(uint field_count)
{ {
uint *blob_field; uint *blob_field;
uchar *bitmaps; uchar *bitmaps;
DBUG_ENTER("Virtual_tmp_table::init");
if (!multi_alloc_root(in_use->mem_root, if (!multi_alloc_root(in_use->mem_root,
&s, sizeof(*s), &s, sizeof(*s),
&field, (field_count + 1) * sizeof(Field*), &field, (field_count + 1) * sizeof(Field*),
&blob_field, (field_count + 1) * sizeof(uint), &blob_field, (field_count + 1) * sizeof(uint),
&bitmaps, bitmap_buffer_size(field_count) * 6, &bitmaps, bitmap_buffer_size(field_count) * 6,
NullS)) NullS))
return true; DBUG_RETURN(true);
bzero(s, sizeof(*s)); bzero(s, sizeof(*s));
s->blob_field= blob_field; s->blob_field= blob_field;
setup_tmp_table_column_bitmaps(this, bitmaps, field_count); setup_tmp_table_column_bitmaps(this, bitmaps, field_count);
m_alloced_field_count= field_count; m_alloced_field_count= field_count;
return false; DBUG_RETURN(false);
}; };
@ -17919,17 +17921,18 @@ bool Virtual_tmp_table::add(List<Spvar_definition> &field_list)
/* Create all fields and calculate the total length of record */ /* Create all fields and calculate the total length of record */
Spvar_definition *cdef; /* column definition */ Spvar_definition *cdef; /* column definition */
List_iterator_fast<Spvar_definition> it(field_list); List_iterator_fast<Spvar_definition> it(field_list);
for ( ; (cdef= it++); ) DBUG_ENTER("Virtual_tmp_table::add");
while ((cdef= it++))
{ {
Field *tmp; Field *tmp;
if (!(tmp= cdef->make_field(s, in_use->mem_root, 0, if (!(tmp= cdef->make_field(s, in_use->mem_root, 0,
(uchar*) (f_maybe_null(cdef->pack_flag) ? "" : 0), (uchar*) (f_maybe_null(cdef->pack_flag) ? "" : 0),
f_maybe_null(cdef->pack_flag) ? 1 : 0, f_maybe_null(cdef->pack_flag) ? 1 : 0,
&cdef->field_name))) &cdef->field_name)))
return true; DBUG_RETURN(true);
add(tmp); add(tmp);
} }
return false; DBUG_RETURN(false);
} }

2
sql/sql_select.h
View File

@ -2161,7 +2161,7 @@ public:
DBUG_ASSERT(s->blob_fields <= m_alloced_field_count); DBUG_ASSERT(s->blob_fields <= m_alloced_field_count);
s->blob_field[s->blob_fields - 1]= s->fields; s->blob_field[s->blob_fields - 1]= s->fields;
} }
s->fields++; new_field->field_index= s->fields++;
return false; return false;
} }

5
sql/sql_servers.cc
View File

@ -156,7 +156,8 @@ bool servers_init(bool dont_read_servers_table)
} }
/* Initialize the mem root for data */ /* Initialize the mem root for data */
init_sql_alloc(&mem, ACL_ALLOC_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC)); init_sql_alloc(&mem, "servers", ACL_ALLOC_BLOCK_SIZE, 0,
MYF(MY_THREAD_SPECIFIC));
if (dont_read_servers_table) if (dont_read_servers_table)
goto end; goto end;
@ -205,7 +206,7 @@ static bool servers_load(THD *thd, TABLE_LIST *tables)
my_hash_reset(&servers_cache); my_hash_reset(&servers_cache);
free_root(&mem, MYF(0)); free_root(&mem, MYF(0));
init_sql_alloc(&mem, ACL_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&mem, "servers_load", ACL_ALLOC_BLOCK_SIZE, 0, MYF(0));
if (init_read_record(&read_record_info,thd,table=tables[0].table, NULL, NULL, if (init_read_record(&read_record_info,thd,table=tables[0].table, NULL, NULL,
1,0, FALSE)) 1,0, FALSE))

7
sql/sql_show.cc
View File

@ -4891,7 +4891,8 @@ static int fill_schema_table_from_frm(THD *thd, TABLE *table,
if (schema_table->i_s_requested_object & OPEN_TRIGGER_ONLY) if (schema_table->i_s_requested_object & OPEN_TRIGGER_ONLY)
{ {
init_sql_alloc(&tbl.mem_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&tbl.mem_root, "fill_schema_table_from_frm",
TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0));
if (!Table_triggers_list::check_n_load(thd, db_name, if (!Table_triggers_list::check_n_load(thd, db_name,
table_name, &tbl, 1)) table_name, &tbl, 1))
{ {
@ -5174,8 +5175,8 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
goto err; goto err;
/* Use tmp_mem_root to allocate data for opened tables */ /* Use tmp_mem_root to allocate data for opened tables */
init_alloc_root(&tmp_mem_root, SHOW_ALLOC_BLOCK_SIZE, SHOW_ALLOC_BLOCK_SIZE, init_alloc_root(&tmp_mem_root, "get_all_tables", SHOW_ALLOC_BLOCK_SIZE,
MY_THREAD_SPECIFIC); SHOW_ALLOC_BLOCK_SIZE, MY_THREAD_SPECIFIC);
for (size_t i=0; i < db_names.elements(); i++) for (size_t i=0; i < db_names.elements(); i++)
{ {

3
sql/sql_table.cc
View File

@ -1131,7 +1131,8 @@ static int execute_ddl_log_action(THD *thd, DDL_LOG_ENTRY *ddl_log_entry)
ddl_log_entry->tmp_name)); ddl_log_entry->tmp_name));
handler_name.str= (char*)ddl_log_entry->handler_name; handler_name.str= (char*)ddl_log_entry->handler_name;
handler_name.length= strlen(ddl_log_entry->handler_name); handler_name.length= strlen(ddl_log_entry->handler_name);
init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC)); init_sql_alloc(&mem_root, "execute_ddl_log_action", TABLE_ALLOC_BLOCK_SIZE,
0, MYF(MY_THREAD_SPECIFIC));
if (!strcmp(ddl_log_entry->handler_name, reg_ext)) if (!strcmp(ddl_log_entry->handler_name, reg_ext))
frm_action= TRUE; frm_action= TRUE;
else else

10
sql/sql_trigger.cc
View File

@ -1792,10 +1792,11 @@ bool Table_triggers_list::drop_all_triggers(THD *thd, const LEX_CSTRING *db,
TABLE table; TABLE table;
char path[FN_REFLEN]; char path[FN_REFLEN];
bool result= 0; bool result= 0;
DBUG_ENTER("drop_all_triggers"); DBUG_ENTER("Triggers::drop_all_triggers");
bzero(&table, sizeof(table)); bzero(&table, sizeof(table));
init_sql_alloc(&table.mem_root, 8192, 0, MYF(0)); init_sql_alloc(&table.mem_root, "Triggers::drop_all_triggers", 8192, 0,
MYF(0));
if (Table_triggers_list::check_n_load(thd, db, name, &table, 1)) if (Table_triggers_list::check_n_load(thd, db, name, &table, 1))
{ {
@ -2043,10 +2044,11 @@ bool Table_triggers_list::change_table_name(THD *thd, const LEX_CSTRING *db,
bool result= 0; bool result= 0;
bool upgrading50to51= FALSE; bool upgrading50to51= FALSE;
Trigger *err_trigger; Trigger *err_trigger;
DBUG_ENTER("change_table_name"); DBUG_ENTER("Triggers::change_table_name");
bzero(&table, sizeof(table)); bzero(&table, sizeof(table));
init_sql_alloc(&table.mem_root, 8192, 0, MYF(0)); init_sql_alloc(&table.mem_root, "Triggers::change_table_name", 8192, 0,
MYF(0));
/* /*
This method interfaces the mysql server code protected by This method interfaces the mysql server code protected by

2
sql/sql_udf.cc
View File

@ -152,7 +152,7 @@ void udf_init()
mysql_rwlock_init(key_rwlock_THR_LOCK_udf, &THR_LOCK_udf); mysql_rwlock_init(key_rwlock_THR_LOCK_udf, &THR_LOCK_udf);
init_sql_alloc(&mem, UDF_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&mem, "udf", UDF_ALLOC_BLOCK_SIZE, 0, MYF(0));
THD *new_thd = new THD(0); THD *new_thd = new THD(0);
if (!new_thd || if (!new_thd ||
my_hash_init(&udf_hash,system_charset_info,32,0,0,get_hash_key, NULL, 0)) my_hash_init(&udf_hash,system_charset_info,32,0,0,get_hash_key, NULL, 0))

12
sql/table.cc
View File

@ -302,7 +302,7 @@ TABLE_SHARE *alloc_table_share(const char *db, const char *table_name,
path_length= build_table_filename(path, sizeof(path) - 1, path_length= build_table_filename(path, sizeof(path) - 1,
db, table_name, "", 0); db, table_name, "", 0);
init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&mem_root, "table_share", TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0));
if (multi_alloc_root(&mem_root, if (multi_alloc_root(&mem_root,
&share, sizeof(*share), &share, sizeof(*share),
&key_buff, key_length, &key_buff, key_length,
@ -328,7 +328,8 @@ TABLE_SHARE *alloc_table_share(const char *db, const char *table_name,
(const uchar*) "mysql", 6) == 0) (const uchar*) "mysql", 6) == 0)
share->not_usable_by_query_cache= 1; share->not_usable_by_query_cache= 1;
init_sql_alloc(&share->stats_cb.mem_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&share->stats_cb.mem_root, "share_stats",
TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0));
memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root)); memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root));
mysql_mutex_init(key_TABLE_SHARE_LOCK_share, mysql_mutex_init(key_TABLE_SHARE_LOCK_share,
@ -385,8 +386,8 @@ void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key,
This can't be MY_THREAD_SPECIFIC for slaves as they are freed This can't be MY_THREAD_SPECIFIC for slaves as they are freed
during cleanup() from Relay_log_info::close_temporary_tables() during cleanup() from Relay_log_info::close_temporary_tables()
*/ */
init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0, init_sql_alloc(&share->mem_root, "tmp_table_share", TABLE_ALLOC_BLOCK_SIZE,
MYF(thd->slave_thread ? 0 : MY_THREAD_SPECIFIC)); 0, MYF(thd->slave_thread ? 0 : MY_THREAD_SPECIFIC));
share->table_category= TABLE_CATEGORY_TEMPORARY; share->table_category= TABLE_CATEGORY_TEMPORARY;
share->tmp_table= INTERNAL_TMP_TABLE; share->tmp_table= INTERNAL_TMP_TABLE;
share->db.str= (char*) key; share->db.str= (char*) key;
@ -3150,7 +3151,8 @@ enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
error= OPEN_FRM_NEEDS_REBUILD; error= OPEN_FRM_NEEDS_REBUILD;
goto err; goto err;
} }
init_sql_alloc(&outparam->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&outparam->mem_root, "table", TABLE_ALLOC_BLOCK_SIZE, 0,
MYF(0));
if (outparam->alias.copy(alias->str, alias->length, table_alias_charset)) if (outparam->alias.copy(alias->str, alias->length, table_alias_charset))
goto err; goto err;

3
sql/table.h
View File

@ -1052,7 +1052,8 @@ private:
public: public:
Blob_mem_storage() :truncated_value(false) Blob_mem_storage() :truncated_value(false)
{ {
init_alloc_root(&storage, MAX_FIELD_VARCHARLENGTH, 0, MYF(0)); init_alloc_root(&storage, "Blob_mem_storage", MAX_FIELD_VARCHARLENGTH, 0,
MYF(0));
} }
~ Blob_mem_storage() ~ Blob_mem_storage()
{ {

3
sql/table_cache.cc
View File

@ -1301,7 +1301,8 @@ int tdc_iterate(THD *thd, my_hash_walk_action action, void *argument,
if (no_dups) if (no_dups)
{ {
init_alloc_root(&no_dups_argument.root, 4096, 4096, MYF(alloc_flags)); init_alloc_root(&no_dups_argument.root, "no_dups", 4096, 4096,
MYF(alloc_flags));
my_hash_init(&no_dups_argument.hash, &my_charset_bin, tdc_records(), 0, 0, my_hash_init(&no_dups_argument.hash, &my_charset_bin, tdc_records(), 0, 0,
eliminate_duplicates_get_key, 0, hash_flags); eliminate_duplicates_get_key, 0, hash_flags);
no_dups_argument.action= action; no_dups_argument.action= action;

7
sql/thr_malloc.cc
View File

@ -58,10 +58,11 @@ extern "C" {
} }
} }
void init_sql_alloc(MEM_ROOT *mem_root, uint block_size, uint pre_alloc, void init_sql_alloc(MEM_ROOT *mem_root,
myf my_flags) const char *area_name __attribute__((unused)),
uint block_size, uint pre_alloc, myf my_flags)
{ {
init_alloc_root(mem_root, block_size, pre_alloc, my_flags); init_alloc_root(mem_root, area_name, block_size, pre_alloc, my_flags);
mem_root->error_handler=sql_alloc_error_handler; mem_root->error_handler=sql_alloc_error_handler;
} }

4
sql/thr_malloc.h
View File

@ -18,8 +18,8 @@
typedef struct st_mem_root MEM_ROOT; typedef struct st_mem_root MEM_ROOT;
void init_sql_alloc(MEM_ROOT *root, uint block_size, uint pre_alloc_size, void init_sql_alloc(MEM_ROOT *root, const char *area_name, uint block_size,
myf my_flags); uint pre_alloc_size, myf my_flags);
char *sql_strmake_with_convert(THD *thd, const char *str, size_t arg_length, char *sql_strmake_with_convert(THD *thd, const char *str, size_t arg_length,
CHARSET_INFO *from_cs, CHARSET_INFO *from_cs,
size_t max_res_length, size_t max_res_length,

9
sql/tztime.cc
View File

@ -1631,7 +1631,7 @@ my_tz_init(THD *org_thd, const char *default_tzname, my_bool bootstrap)
my_hash_free(&tz_names); my_hash_free(&tz_names);
goto end; goto end;
} }
init_sql_alloc(&tz_storage, 32 * 1024, 0, MYF(0)); init_sql_alloc(&tz_storage, "timezone_storage", 32 * 1024, 0, MYF(0));
mysql_mutex_init(key_tz_LOCK, &tz_LOCK, MY_MUTEX_INIT_FAST); mysql_mutex_init(key_tz_LOCK, &tz_LOCK, MY_MUTEX_INIT_FAST);
tz_inited= 1; tz_inited= 1;
@ -2554,7 +2554,8 @@ scan_tz_dir(char * name_end, uint symlink_recursion_level, uint verbose)
} }
else if (MY_S_ISREG(cur_dir->dir_entry[i].mystat->st_mode)) else if (MY_S_ISREG(cur_dir->dir_entry[i].mystat->st_mode))
{ {
init_alloc_root(&tz_storage, 32768, 0, MYF(MY_THREAD_SPECIFIC)); init_alloc_root(&tz_storage, "timezone_storage", 32768, 0,
MYF(MY_THREAD_SPECIFIC));
if (!tz_load(fullname, &tz_info, &tz_storage)) if (!tz_load(fullname, &tz_info, &tz_storage))
print_tz_as_sql(root_name_end + 1, &tz_info); print_tz_as_sql(root_name_end + 1, &tz_info);
else else
@ -2728,7 +2729,7 @@ main(int argc, char **argv)
First argument is timezonefile. First argument is timezonefile.
The second is timezonename if opt_leap is not given The second is timezonename if opt_leap is not given
*/ */
init_alloc_root(&tz_storage, 32768, 0, MYF(0)); init_alloc_root(&tz_storage, "timezone_storage", 32768, 0, MYF(0));
if (tz_load(argv[0], &tz_info, &tz_storage)) if (tz_load(argv[0], &tz_info, &tz_storage))
{ {
@ -2802,7 +2803,7 @@ main(int argc, char **argv)
MY_INIT(argv[0]); MY_INIT(argv[0]);
init_alloc_root(&tz_storage, 32768, MYF(0)); init_alloc_root(&tz_storage, "timezone_storage", 32768, MYF(0));
/* let us set some well known timezone */ /* let us set some well known timezone */
setenv("TZ", "MET", 1); setenv("TZ", "MET", 1);

2
storage/cassandra/ha_cassandra.cc
View File

@ -866,7 +866,7 @@ static void alloc_strings_memroot(MEM_ROOT *mem_root)
The mem_root used to allocate UUID (of length 36 + \0) so make The mem_root used to allocate UUID (of length 36 + \0) so make
appropriate allocated size appropriate allocated size
*/ */
init_alloc_root(mem_root, init_alloc_root(mem_root, "cassandra",
(36 + 1 + ALIGN_SIZE(sizeof(USED_MEM))) * 10 + (36 + 1 + ALIGN_SIZE(sizeof(USED_MEM))) * 10 +
ALLOC_ROOT_MIN_BLOCK_SIZE, ALLOC_ROOT_MIN_BLOCK_SIZE,
(36 + 1 + ALIGN_SIZE(sizeof(USED_MEM))) * 10 + (36 + 1 + ALIGN_SIZE(sizeof(USED_MEM))) * 10 +

4
storage/csv/ha_tina.cc
View File

@ -514,7 +514,7 @@ ha_tina::ha_tina(handlerton *hton, TABLE_SHARE *table_arg)
buffer.set((char*)byte_buffer, IO_SIZE, &my_charset_bin); buffer.set((char*)byte_buffer, IO_SIZE, &my_charset_bin);
chain= chain_buffer; chain= chain_buffer;
file_buff= new Transparent_file(); file_buff= new Transparent_file();
init_alloc_root(&blobroot, BLOB_MEMROOT_ALLOC_SIZE, 0, MYF(0)); init_alloc_root(&blobroot, "ha_tina", BLOB_MEMROOT_ALLOC_SIZE, 0, MYF(0));
} }
@ -976,7 +976,7 @@ int ha_tina::open(const char *name, int mode, uint open_options)
*/ */
thr_lock_data_init(&share->lock, &lock, (void*) this); thr_lock_data_init(&share->lock, &lock, (void*) this);
ref_length= sizeof(my_off_t); ref_length= sizeof(my_off_t);
init_alloc_root(&blobroot, BLOB_MEMROOT_ALLOC_SIZE, 0, MYF(0)); init_alloc_root(&blobroot, "ha_tina", BLOB_MEMROOT_ALLOC_SIZE, 0, MYF(0));
share->lock.get_status= tina_get_status; share->lock.get_status= tina_get_status;
share->lock.update_status= tina_update_status; share->lock.update_status= tina_update_status;

2
storage/federated/ha_federated.cc
View File

@ -1517,7 +1517,7 @@ static FEDERATED_SHARE *get_share(const char *table_name, TABLE *table)
*/ */
query.length(0); query.length(0);
init_alloc_root(&mem_root, 256, 0, MYF(0)); init_alloc_root(&mem_root, "federated_share", 256, 0, MYF(0));
mysql_mutex_lock(&federated_mutex); mysql_mutex_lock(&federated_mutex);

4
storage/federatedx/ha_federatedx.cc
View File

@ -1520,7 +1520,7 @@ static FEDERATEDX_SERVER *get_server(FEDERATEDX_SHARE *share, TABLE *table)
mysql_mutex_assert_owner(&federatedx_mutex); mysql_mutex_assert_owner(&federatedx_mutex);
init_alloc_root(&mem_root, 4096, 4096, MYF(0)); init_alloc_root(&mem_root, "federated", 4096, 4096, MYF(0));
fill_server(&mem_root, &tmp_server, share, table ? table->s->table_charset : 0); fill_server(&mem_root, &tmp_server, share, table ? table->s->table_charset : 0);
@ -1578,7 +1578,7 @@ static FEDERATEDX_SHARE *get_share(const char *table_name, TABLE *table)
query.length(0); query.length(0);
bzero(&tmp_share, sizeof(tmp_share)); bzero(&tmp_share, sizeof(tmp_share));
init_alloc_root(&mem_root, 256, 0, MYF(0)); init_alloc_root(&mem_root, "federated", 256, 0, MYF(0));
mysql_mutex_lock(&federatedx_mutex); mysql_mutex_lock(&federatedx_mutex);

5
storage/maria/ma_check.c
View File

@ -3783,7 +3783,7 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info,
param->read_cache.end_of_file= sort_info.filelength; param->read_cache.end_of_file= sort_info.filelength;
sort_param.wordlist=NULL; sort_param.wordlist=NULL;
init_alloc_root(&sort_param.wordroot, FTPARSER_MEMROOT_ALLOC_SIZE, 0, init_alloc_root(&sort_param.wordroot, "sort", FTPARSER_MEMROOT_ALLOC_SIZE, 0,
MYF(param->malloc_flags)); MYF(param->malloc_flags));
sort_param.key_cmp=sort_key_cmp; sort_param.key_cmp=sort_key_cmp;
@ -4431,7 +4431,8 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info,
(FT_MAX_WORD_LEN_FOR_SORT * (FT_MAX_WORD_LEN_FOR_SORT *
sort_param[i].keyinfo->seg->charset->mbmaxlen); sort_param[i].keyinfo->seg->charset->mbmaxlen);
sort_param[i].key_length+=ft_max_word_len_for_sort-HA_FT_MAXBYTELEN; sort_param[i].key_length+=ft_max_word_len_for_sort-HA_FT_MAXBYTELEN;
init_alloc_root(&sort_param[i].wordroot, FTPARSER_MEMROOT_ALLOC_SIZE, 0, init_alloc_root(&sort_param[i].wordroot, "sort",
FTPARSER_MEMROOT_ALLOC_SIZE, 0,
MYF(param->malloc_flags)); MYF(param->malloc_flags));
} }
} }

2
storage/maria/ma_ft_boolean_search.c
View File

@ -574,7 +574,7 @@ FT_INFO * maria_ft_init_boolean_search(MARIA_HA *info, uint keynr,
bzero(& ftb->no_dupes, sizeof(TREE)); bzero(& ftb->no_dupes, sizeof(TREE));
ftb->last_word= 0; ftb->last_word= 0;
init_alloc_root(&ftb->mem_root, 1024, 1024, 0); init_alloc_root(&ftb->mem_root, "fulltext", 1024, 1024, 0);
ftb->queue.max_elements= 0; ftb->queue.max_elements= 0;
if (!(ftbe=(FTB_EXPR *)alloc_root(&ftb->mem_root, sizeof(FTB_EXPR)))) if (!(ftbe=(FTB_EXPR *)alloc_root(&ftb->mem_root, sizeof(FTB_EXPR))))
goto err; goto err;

3
storage/maria/ma_ft_parser.c
View File

@ -348,7 +348,8 @@ MYSQL_FTPARSER_PARAM* maria_ftparser_alloc_param(MARIA_HA *info)
info->ftparser_param= (MYSQL_FTPARSER_PARAM *) info->ftparser_param= (MYSQL_FTPARSER_PARAM *)
my_malloc(MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) * my_malloc(MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) *
info->s->ftkeys, MYF(MY_WME | MY_ZEROFILL)); info->s->ftkeys, MYF(MY_WME | MY_ZEROFILL));
init_alloc_root(&info->ft_memroot, FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0)); init_alloc_root(&info->ft_memroot, "fulltext_parser",
FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0));
} }
return info->ftparser_param; return info->ftparser_param;
} }

13
storage/mroonga/mrn_mysql_compat.h
View File

@ -60,7 +60,10 @@
# define KEY_N_KEY_PARTS(key) (key)->key_parts # define KEY_N_KEY_PARTS(key) (key)->key_parts
#endif #endif
#if defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100000 #if defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100213
# define mrn_init_alloc_root(PTR, SZ1, SZ2, FLAG) \
init_alloc_root(PTR, "mroonga", SZ1, SZ2, FLAG)
#elif defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100000
# define mrn_init_alloc_root(PTR, SZ1, SZ2, FLAG) \ # define mrn_init_alloc_root(PTR, SZ1, SZ2, FLAG) \
init_alloc_root(PTR, SZ1, SZ2, FLAG) init_alloc_root(PTR, SZ1, SZ2, FLAG)
#elif MYSQL_VERSION_ID >= 50706 #elif MYSQL_VERSION_ID >= 50706
@ -238,7 +241,13 @@
#endif #endif
#if defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100000 #if defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100000
# if MYSQL_VERSION_ID >= 100104 # if MYSQL_VERSION_ID >= 100213
# define mrn_init_sql_alloc(thd, mem_root) \
init_sql_alloc(mem_root, "Mroonga", \
TABLE_ALLOC_BLOCK_SIZE, \
0, \
MYF(thd->slave_thread ? 0 : MY_THREAD_SPECIFIC))
#elif MYSQL_VERSION_ID >= 100104
# define mrn_init_sql_alloc(thd, mem_root) \ # define mrn_init_sql_alloc(thd, mem_root) \
init_sql_alloc(mem_root, \ init_sql_alloc(mem_root, \
TABLE_ALLOC_BLOCK_SIZE, \ TABLE_ALLOC_BLOCK_SIZE, \

2
storage/myisam/ft_boolean_search.c
View File

@ -579,7 +579,7 @@ FT_INFO * ft_init_boolean_search(MI_INFO *info, uint keynr, uchar *query,
bzero(& ftb->no_dupes, sizeof(TREE)); bzero(& ftb->no_dupes, sizeof(TREE));
ftb->last_word= 0; ftb->last_word= 0;
init_alloc_root(&ftb->mem_root, 1024, 1024, MYF(0)); init_alloc_root(&ftb->mem_root, "fulltext", 1024, 1024, MYF(0));
ftb->queue.max_elements= 0; ftb->queue.max_elements= 0;
if (!(ftbe=(FTB_EXPR *)alloc_root(&ftb->mem_root, sizeof(FTB_EXPR)))) if (!(ftbe=(FTB_EXPR *)alloc_root(&ftb->mem_root, sizeof(FTB_EXPR))))
goto err; goto err;

3
storage/myisam/ft_parser.c
View File

@ -342,7 +342,8 @@ MYSQL_FTPARSER_PARAM* ftparser_alloc_param(MI_INFO *info)
info->ftparser_param= (MYSQL_FTPARSER_PARAM *) info->ftparser_param= (MYSQL_FTPARSER_PARAM *)
my_malloc(MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) * my_malloc(MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) *
info->s->ftkeys, MYF(MY_WME | MY_ZEROFILL)); info->s->ftkeys, MYF(MY_WME | MY_ZEROFILL));
init_alloc_root(&info->ft_memroot, FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0)); init_alloc_root(&info->ft_memroot, "fulltext_parser",
FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0));
} }
return info->ftparser_param; return info->ftparser_param;
} }

5
storage/myisam/mi_check.c
View File

@ -2291,7 +2291,7 @@ int mi_repair_by_sort(HA_CHECK *param, register MI_INFO *info,
mysql_file_seek(param->read_cache.file, 0L, MY_SEEK_END, MYF(0)); mysql_file_seek(param->read_cache.file, 0L, MY_SEEK_END, MYF(0));
sort_param.wordlist=NULL; sort_param.wordlist=NULL;
init_alloc_root(&sort_param.wordroot, FTPARSER_MEMROOT_ALLOC_SIZE, 0, init_alloc_root(&sort_param.wordroot, "sort", FTPARSER_MEMROOT_ALLOC_SIZE, 0,
MYF(param->malloc_flags)); MYF(param->malloc_flags));
if (share->data_file_type == DYNAMIC_RECORD) if (share->data_file_type == DYNAMIC_RECORD)
@ -2869,7 +2869,8 @@ int mi_repair_parallel(HA_CHECK *param, register MI_INFO *info,
uint ft_max_word_len_for_sort=FT_MAX_WORD_LEN_FOR_SORT* uint ft_max_word_len_for_sort=FT_MAX_WORD_LEN_FOR_SORT*
sort_param[i].keyinfo->seg->charset->mbmaxlen; sort_param[i].keyinfo->seg->charset->mbmaxlen;
sort_param[i].key_length+=ft_max_word_len_for_sort-HA_FT_MAXBYTELEN; sort_param[i].key_length+=ft_max_word_len_for_sort-HA_FT_MAXBYTELEN;
init_alloc_root(&sort_param[i].wordroot, FTPARSER_MEMROOT_ALLOC_SIZE, 0, init_alloc_root(&sort_param[i].wordroot, "sort",
FTPARSER_MEMROOT_ALLOC_SIZE, 0,
MYF(param->malloc_flags)); MYF(param->malloc_flags));
} }
} }

2
storage/myisammrg/ha_myisammrg.cc
View File

@ -120,7 +120,7 @@ static handler *myisammrg_create_handler(handlerton *hton,
ha_myisammrg::ha_myisammrg(handlerton *hton, TABLE_SHARE *table_arg) ha_myisammrg::ha_myisammrg(handlerton *hton, TABLE_SHARE *table_arg)
:handler(hton, table_arg), file(0), is_cloned(0) :handler(hton, table_arg), file(0), is_cloned(0)
{ {
init_sql_alloc(&children_mem_root, init_sql_alloc(&children_mem_root, "ha_myisammrg",
FN_REFLEN + ALLOC_ROOT_MIN_BLOCK_SIZE, 0, MYF(0)); FN_REFLEN + ALLOC_ROOT_MIN_BLOCK_SIZE, 0, MYF(0));
} }

2
storage/oqgraph/ha_oqgraph.cc
View File

@ -563,7 +563,7 @@ int ha_oqgraph::open(const char *name, int mode, uint test_if_locked)
init_tmp_table_share( thd, share, table->s->db.str, table->s->db.length, options->table_name, ""); init_tmp_table_share( thd, share, table->s->db.str, table->s->db.length, options->table_name, "");
// because of that, we need to reinitialize the memroot (to reset MY_THREAD_SPECIFIC flag) // because of that, we need to reinitialize the memroot (to reset MY_THREAD_SPECIFIC flag)
DBUG_ASSERT(share->mem_root.used == NULL); // it's still empty DBUG_ASSERT(share->mem_root.used == NULL); // it's still empty
init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0)); init_sql_alloc(&share->mem_root, "share", TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0));
// What I think this code is doing: // What I think this code is doing:
// * Our OQGRAPH table is `database_blah/name` // * Our OQGRAPH table is `database_blah/name`

7
storage/spider/hs_client/hs_compat.h
View File

@ -16,7 +16,12 @@
#ifndef HS_COMPAT_H #ifndef HS_COMPAT_H
#define HS_COMPAT_H #define HS_COMPAT_H
#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 #if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100213
#define SPD_INIT_DYNAMIC_ARRAY2(A, B, C, D, E, F) \
my_init_dynamic_array2(A, B, C, D, E, F)
#define SPD_INIT_ALLOC_ROOT(A, B, C, D) \
init_alloc_root(A, "spider", B, C, D)
#elif defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000
#define SPD_INIT_DYNAMIC_ARRAY2(A, B, C, D, E, F) \ #define SPD_INIT_DYNAMIC_ARRAY2(A, B, C, D, E, F) \
my_init_dynamic_array2(A, B, C, D, E, F) my_init_dynamic_array2(A, B, C, D, E, F)
#define SPD_INIT_ALLOC_ROOT(A, B, C, D) \ #define SPD_INIT_ALLOC_ROOT(A, B, C, D) \