merged
This commit is contained in:
commit
8dc77f267b
@ -22,6 +22,11 @@ functions */
|
||||
#define _WIN32_WINNT 0x0500
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER) && _MSC_VER >= 1400
|
||||
/* Avoid endless warnings about sprintf() etc. being unsafe. */
|
||||
#define _CRT_SECURE_NO_DEPRECATE 1
|
||||
#endif
|
||||
|
||||
#include <sys/locking.h>
|
||||
#include <windows.h>
|
||||
#include <math.h> /* Because of rint() */
|
||||
@ -329,6 +334,11 @@ inline double ulonglong2double(ulonglong value)
|
||||
#define HAVE_SETFILEPOINTER
|
||||
#define HAVE_VIO_READ_BUFF
|
||||
|
||||
#if defined(_WIN64) && defined(_M_X64)
|
||||
/* Avoid type conflicts with built-in functions. */
|
||||
#define HAVE_STRNLEN
|
||||
#endif
|
||||
|
||||
#ifndef __NT__
|
||||
#undef FILE_SHARE_DELETE
|
||||
#define FILE_SHARE_DELETE 0 /* Not implemented on Win 98/ME */
|
||||
|
@ -33,7 +33,7 @@ typedef void (*hash_free_key)(void *);
|
||||
|
||||
typedef struct st_hash {
|
||||
uint key_offset,key_length; /* Length of key if const length */
|
||||
uint records,blength,current_record;
|
||||
uint records, blength;
|
||||
uint flags;
|
||||
DYNAMIC_ARRAY array; /* Place for hash_keys */
|
||||
hash_get_key get_key;
|
||||
@ -41,6 +41,9 @@ typedef struct st_hash {
|
||||
CHARSET_INFO *charset;
|
||||
} HASH;
|
||||
|
||||
/* A search iterator state */
|
||||
typedef uint HASH_SEARCH_STATE;
|
||||
|
||||
#define hash_init(A,B,C,D,E,F,G,H) _hash_init(A,B,C,D,E,F,G, H CALLER_INFO)
|
||||
my_bool _hash_init(HASH *hash, CHARSET_INFO *charset,
|
||||
uint default_array_elements, uint key_offset,
|
||||
@ -49,12 +52,15 @@ my_bool _hash_init(HASH *hash, CHARSET_INFO *charset,
|
||||
void hash_free(HASH *tree);
|
||||
void my_hash_reset(HASH *hash);
|
||||
byte *hash_element(HASH *hash,uint idx);
|
||||
gptr hash_search(HASH *info,const byte *key,uint length);
|
||||
gptr hash_next(HASH *info,const byte *key,uint length);
|
||||
gptr hash_search(const HASH *info, const byte *key, uint length);
|
||||
gptr hash_first(const HASH *info, const byte *key, uint length,
|
||||
HASH_SEARCH_STATE *state);
|
||||
gptr hash_next(const HASH *info, const byte *key, uint length,
|
||||
HASH_SEARCH_STATE *state);
|
||||
my_bool my_hash_insert(HASH *info,const byte *data);
|
||||
my_bool hash_delete(HASH *hash,byte *record);
|
||||
my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length);
|
||||
void hash_replace(HASH *hash, uint idx, byte *new_row);
|
||||
void hash_replace(HASH *hash, HASH_SEARCH_STATE *state, byte *new_row);
|
||||
my_bool hash_check(HASH *hash); /* Only in debug library */
|
||||
|
||||
#define hash_clear(H) bzero((char*) (H),sizeof(*(H)))
|
||||
|
@ -862,6 +862,7 @@ typedef off_t os_off_t;
|
||||
#define SOCKET_EAGAIN WSAEINPROGRESS
|
||||
#define SOCKET_ETIMEDOUT WSAETIMEDOUT
|
||||
#define SOCKET_EWOULDBLOCK WSAEWOULDBLOCK
|
||||
#define SOCKET_EADDRINUSE WSAEADDRINUSE
|
||||
#define SOCKET_ENFILE ENFILE
|
||||
#define SOCKET_EMFILE EMFILE
|
||||
#elif defined(OS2)
|
||||
@ -870,6 +871,7 @@ typedef off_t os_off_t;
|
||||
#define SOCKET_EAGAIN SOCEINPROGRESS
|
||||
#define SOCKET_ETIMEDOUT SOCKET_EINTR
|
||||
#define SOCKET_EWOULDBLOCK SOCEWOULDBLOCK
|
||||
#define SOCKET_EADDRINUSE SOCEADDRINUSE
|
||||
#define SOCKET_ENFILE SOCENFILE
|
||||
#define SOCKET_EMFILE SOCEMFILE
|
||||
#define closesocket(A) soclose(A)
|
||||
@ -880,6 +882,7 @@ typedef off_t os_off_t;
|
||||
#define SOCKET_EAGAIN EAGAIN
|
||||
#define SOCKET_ETIMEDOUT SOCKET_EINTR
|
||||
#define SOCKET_EWOULDBLOCK EWOULDBLOCK
|
||||
#define SOCKET_EADDRINUSE EADDRINUSE
|
||||
#define SOCKET_ENFILE ENFILE
|
||||
#define SOCKET_EMFILE EMFILE
|
||||
#endif
|
||||
|
@ -890,7 +890,14 @@ sub mtr_exit ($) {
|
||||
# cluck("Called mtr_exit()");
|
||||
mtr_timer_stop_all($::glob_timers);
|
||||
local $SIG{HUP} = 'IGNORE';
|
||||
kill('HUP', -$$);
|
||||
# ToDo: Signalling -$$ will only work if we are the process group
|
||||
# leader (in fact on QNX it will signal our session group leader,
|
||||
# which might be Do-compile or Pushbuild, causing tests to be
|
||||
# aborted). So we only do it if we are the group leader. We might
|
||||
# set ourselves as the group leader at startup (with
|
||||
# POSIX::setpgrp(0,0)), but then care must be needed to always do
|
||||
# proper child process cleanup.
|
||||
kill('HUP', -$$) if $$ == getpgrp();
|
||||
sleep 2;
|
||||
exit($code);
|
||||
}
|
||||
|
@ -804,6 +804,12 @@ sub command_line_setup () {
|
||||
}
|
||||
}
|
||||
|
||||
# On QNX, /tmp/dir/master.sock and /tmp/dir//master.sock seem to be
|
||||
# considered different, so avoid the extra slash (/) in the socket
|
||||
# paths.
|
||||
my $sockdir = $opt_tmpdir;
|
||||
$sockdir =~ s|/+$||;
|
||||
|
||||
# Put this into a hash, will be a C struct
|
||||
|
||||
$master->[0]=
|
||||
@ -812,7 +818,7 @@ sub command_line_setup () {
|
||||
path_myerr => "$opt_vardir/log/master.err",
|
||||
path_mylog => "$opt_vardir/log/master.log",
|
||||
path_mypid => "$opt_vardir/run/master.pid",
|
||||
path_mysock => "$opt_tmpdir/master.sock",
|
||||
path_mysock => "$sockdir/master.sock",
|
||||
path_myport => $opt_master_myport,
|
||||
start_timeout => 400, # enough time create innodb tables
|
||||
|
||||
@ -825,7 +831,7 @@ sub command_line_setup () {
|
||||
path_myerr => "$opt_vardir/log/master1.err",
|
||||
path_mylog => "$opt_vardir/log/master1.log",
|
||||
path_mypid => "$opt_vardir/run/master1.pid",
|
||||
path_mysock => "$opt_tmpdir/master1.sock",
|
||||
path_mysock => "$sockdir/master1.sock",
|
||||
path_myport => $opt_master_myport + 1,
|
||||
start_timeout => 400, # enough time create innodb tables
|
||||
};
|
||||
@ -836,7 +842,7 @@ sub command_line_setup () {
|
||||
path_myerr => "$opt_vardir/log/slave.err",
|
||||
path_mylog => "$opt_vardir/log/slave.log",
|
||||
path_mypid => "$opt_vardir/run/slave.pid",
|
||||
path_mysock => "$opt_tmpdir/slave.sock",
|
||||
path_mysock => "$sockdir/slave.sock",
|
||||
path_myport => $opt_slave_myport,
|
||||
start_timeout => 400,
|
||||
};
|
||||
@ -847,7 +853,7 @@ sub command_line_setup () {
|
||||
path_myerr => "$opt_vardir/log/slave1.err",
|
||||
path_mylog => "$opt_vardir/log/slave1.log",
|
||||
path_mypid => "$opt_vardir/run/slave1.pid",
|
||||
path_mysock => "$opt_tmpdir/slave1.sock",
|
||||
path_mysock => "$sockdir/slave1.sock",
|
||||
path_myport => $opt_slave_myport + 1,
|
||||
start_timeout => 300,
|
||||
};
|
||||
@ -858,7 +864,7 @@ sub command_line_setup () {
|
||||
path_myerr => "$opt_vardir/log/slave2.err",
|
||||
path_mylog => "$opt_vardir/log/slave2.log",
|
||||
path_mypid => "$opt_vardir/run/slave2.pid",
|
||||
path_mysock => "$opt_tmpdir/slave2.sock",
|
||||
path_mysock => "$sockdir/slave2.sock",
|
||||
path_myport => $opt_slave_myport + 2,
|
||||
start_timeout => 300,
|
||||
};
|
||||
@ -868,7 +874,7 @@ sub command_line_setup () {
|
||||
path_err => "$opt_vardir/log/im.err",
|
||||
path_log => "$opt_vardir/log/im.log",
|
||||
path_pid => "$opt_vardir/run/im.pid",
|
||||
path_sock => "$opt_tmpdir/im.sock",
|
||||
path_sock => "$sockdir/im.sock",
|
||||
port => $im_port,
|
||||
start_timeout => $master->[0]->{'start_timeout'},
|
||||
admin_login => 'im_admin',
|
||||
@ -883,7 +889,7 @@ sub command_line_setup () {
|
||||
server_id => 1,
|
||||
port => $im_mysqld1_port,
|
||||
path_datadir => "$opt_vardir/im_mysqld_1.data",
|
||||
path_sock => "$opt_tmpdir/mysqld_1.sock",
|
||||
path_sock => "$sockdir/mysqld_1.sock",
|
||||
path_pid => "$opt_vardir/run/mysqld_1.pid",
|
||||
};
|
||||
|
||||
@ -892,7 +898,7 @@ sub command_line_setup () {
|
||||
server_id => 2,
|
||||
port => $im_mysqld2_port,
|
||||
path_datadir => "$opt_vardir/im_mysqld_2.data",
|
||||
path_sock => "$opt_tmpdir/mysqld_2.sock",
|
||||
path_sock => "$sockdir/mysqld_2.sock",
|
||||
path_pid => "$opt_vardir/run/mysqld_2.pid",
|
||||
nonguarded => 1,
|
||||
};
|
||||
|
@ -272,7 +272,6 @@ a b
|
||||
create table if not exists t1 select 3 as 'a',4 as 'b';
|
||||
Warnings:
|
||||
Note 1050 Table 't1' already exists
|
||||
Warning 1364 Field 'a' doesn't have a default value
|
||||
create table if not exists t1 select 3 as 'a',3 as 'b';
|
||||
ERROR 23000: Duplicate entry '3' for key 1
|
||||
select * from t1;
|
||||
@ -630,8 +629,6 @@ create table t1 (
|
||||
a varchar(112) charset utf8 collate utf8_bin not null,
|
||||
primary key (a)
|
||||
) select 'test' as a ;
|
||||
Warnings:
|
||||
Warning 1364 Field 'a' doesn't have a default value
|
||||
show create table t1;
|
||||
Table Create Table
|
||||
t1 CREATE TABLE `t1` (
|
||||
@ -647,9 +644,6 @@ create table t1 (
|
||||
a varchar(12) charset utf8 collate utf8_bin not null,
|
||||
b int not null, primary key (a)
|
||||
) select a, 1 as b from t2 ;
|
||||
Warnings:
|
||||
Warning 1364 Field 'a' doesn't have a default value
|
||||
Warning 1364 Field 'b' doesn't have a default value
|
||||
show create table t1;
|
||||
Table Create Table
|
||||
t1 CREATE TABLE `t1` (
|
||||
@ -661,12 +655,37 @@ drop table t1;
|
||||
create table t1 (
|
||||
a varchar(12) charset utf8 collate utf8_bin not null,
|
||||
b int not null, primary key (a)
|
||||
) select 'a' as a , 1 as b from t2 ;
|
||||
) select a, 1 as c from t2 ;
|
||||
Warnings:
|
||||
Warning 1364 Field 'a' doesn't have a default value
|
||||
Warning 1364 Field 'b' doesn't have a default value
|
||||
show create table t1;
|
||||
Table Create Table
|
||||
t1 CREATE TABLE `t1` (
|
||||
`b` int(11) NOT NULL,
|
||||
`a` varchar(12) character set utf8 collate utf8_bin NOT NULL,
|
||||
`c` bigint(1) NOT NULL default '0',
|
||||
PRIMARY KEY (`a`)
|
||||
) ENGINE=MyISAM DEFAULT CHARSET=latin1
|
||||
drop table t1;
|
||||
create table t1 (
|
||||
a varchar(12) charset utf8 collate utf8_bin not null,
|
||||
b int null, primary key (a)
|
||||
) select a, 1 as c from t2 ;
|
||||
show create table t1;
|
||||
Table Create Table
|
||||
t1 CREATE TABLE `t1` (
|
||||
`b` int(11) default NULL,
|
||||
`a` varchar(12) character set utf8 collate utf8_bin NOT NULL,
|
||||
`c` bigint(1) NOT NULL default '0',
|
||||
PRIMARY KEY (`a`)
|
||||
) ENGINE=MyISAM DEFAULT CHARSET=latin1
|
||||
drop table t1;
|
||||
create table t1 (
|
||||
a varchar(12) charset utf8 collate utf8_bin not null,
|
||||
b int not null, primary key (a)
|
||||
) select 'a' as a , 1 as b from t2 ;
|
||||
show create table t1;
|
||||
Table Create Table
|
||||
t1 CREATE TABLE `t1` (
|
||||
`a` varchar(12) character set utf8 collate utf8_bin NOT NULL,
|
||||
`b` int(11) NOT NULL,
|
||||
@ -677,8 +696,6 @@ create table t1 (
|
||||
a varchar(12) charset utf8 collate utf8_bin,
|
||||
b int not null, primary key (a)
|
||||
) select 'a' as a , 1 as b from t2 ;
|
||||
Warnings:
|
||||
Warning 1364 Field 'b' doesn't have a default value
|
||||
show create table t1;
|
||||
Table Create Table
|
||||
t1 CREATE TABLE `t1` (
|
||||
@ -697,8 +714,6 @@ a1 varchar(12) charset utf8 collate utf8_bin not null,
|
||||
a2 int, a3 int, a4 int, a5 int, a6 int, a7 int, a8 int, a9 int,
|
||||
primary key (a1)
|
||||
) select a1,a2,a3,a4,a5,a6,a7,a8,a9 from t1 ;
|
||||
Warnings:
|
||||
Warning 1364 Field 'a1' doesn't have a default value
|
||||
drop table t2;
|
||||
create table t2 (
|
||||
a1 varchar(12) charset utf8 collate utf8_bin,
|
||||
@ -714,8 +729,6 @@ a1 varchar(12) charset utf8 collate utf8_bin not null,
|
||||
a2 int, a3 int, a4 int, a5 int, a6 int, a7 int, a8 int, a9 int,
|
||||
primary key (a1)
|
||||
) select a1,a2,a3,a4,a5,a6,a7,a8,a9 from t1 ;
|
||||
Warnings:
|
||||
Warning 1364 Field 'a1' doesn't have a default value
|
||||
drop table t2;
|
||||
create table t2 ( a int default 3, b int default 3)
|
||||
select a1,a2 from t1;
|
||||
|
@ -1,4 +1,4 @@
|
||||
drop table if exists t1;
|
||||
drop table if exists t1,t3,t4,t5;
|
||||
create table t1 (a int, b char(10), key a(a), key b(a,b));
|
||||
insert into t1 values
|
||||
(17,"ddd"),(18,"eee"),(19,"fff"),(19,"yyy"),
|
||||
|
@ -5,8 +5,6 @@ select ((@id := kill_id) - kill_id) from t1;
|
||||
((@id := kill_id) - kill_id)
|
||||
0
|
||||
kill @id;
|
||||
select 1;
|
||||
Got one of the listed errors
|
||||
select ((@id := kill_id) - kill_id) from t1;
|
||||
((@id := kill_id) - kill_id)
|
||||
0
|
||||
|
@ -1,4 +1,4 @@
|
||||
DROP TABLE IF EXISTS t1,t2;
|
||||
DROP TABLE IF EXISTS t1,t2,test1,test2;
|
||||
CREATE TABLE t1 (a int);
|
||||
INSERT INTO t1 VALUES (1),(2),(3);
|
||||
CREATE TABLE t2 (a int, b int);
|
||||
|
@ -57,6 +57,9 @@ insert into t1 values (15);
|
||||
grant CREATE ROUTINE, EXECUTE on mysqltest1.* to "zedjzlcsjhd"@127.0.0.1;
|
||||
grant SELECT on mysqltest1.t1 to "zedjzlcsjhd"@127.0.0.1;
|
||||
grant SELECT, INSERT on mysqltest1.t2 to "zedjzlcsjhd"@127.0.0.1;
|
||||
SELECT 1;
|
||||
1
|
||||
1
|
||||
create procedure foo4()
|
||||
deterministic
|
||||
begin
|
||||
|
@ -767,8 +767,7 @@ deallocate prepare stmt1;
|
||||
drop procedure p1;
|
||||
drop table t1, t2, t3;
|
||||
create table t1 (a int);
|
||||
drop procedure if exists p2;
|
||||
CREATE PROCEDURE `p2`()
|
||||
CREATE PROCEDURE `p1`()
|
||||
begin
|
||||
insert into t1 values (1);
|
||||
end//
|
||||
@ -777,8 +776,8 @@ begin
|
||||
declare done int default 0;
|
||||
set done= not done;
|
||||
end//
|
||||
CALL p2();
|
||||
drop procedure p2;
|
||||
CALL p1();
|
||||
drop procedure p1;
|
||||
drop table t1;
|
||||
create trigger t1_bi before insert on test.t1 for each row set @a:=0;
|
||||
ERROR 3D000: No database selected
|
||||
|
@ -2423,6 +2423,9 @@ drop view v1;
|
||||
drop table t1;
|
||||
create table t1(f1 int, f2 int);
|
||||
insert into t1 values (null, 10), (null,2);
|
||||
select f1, sum(f2) from t1 group by f1;
|
||||
f1 sum(f2)
|
||||
NULL 12
|
||||
create view v1 as select * from t1;
|
||||
select f1, sum(f2) from v1 group by f1;
|
||||
f1 sum(f2)
|
||||
|
@ -564,6 +564,22 @@ create table t1 (
|
||||
show create table t1;
|
||||
drop table t1;
|
||||
|
||||
--warning 1364
|
||||
create table t1 (
|
||||
a varchar(12) charset utf8 collate utf8_bin not null,
|
||||
b int not null, primary key (a)
|
||||
) select a, 1 as c from t2 ;
|
||||
show create table t1;
|
||||
drop table t1;
|
||||
|
||||
--warning 1364
|
||||
create table t1 (
|
||||
a varchar(12) charset utf8 collate utf8_bin not null,
|
||||
b int null, primary key (a)
|
||||
) select a, 1 as c from t2 ;
|
||||
show create table t1;
|
||||
drop table t1;
|
||||
|
||||
--warning 1364
|
||||
create table t1 (
|
||||
a varchar(12) charset utf8 collate utf8_bin not null,
|
||||
|
@ -11,6 +11,5 @@
|
||||
##############################################################################
|
||||
|
||||
sp-goto : GOTO is currently is disabled - will be fixed in the future
|
||||
kill : Unstable test case, bug#9712
|
||||
subselect : Bug#15706
|
||||
type_time : Bug#15805
|
||||
|
@ -3,7 +3,7 @@
|
||||
#
|
||||
|
||||
--disable_warnings
|
||||
drop table if exists t1;
|
||||
drop table if exists t1,t3,t4,t5;
|
||||
--enable_warnings
|
||||
|
||||
create table t1 (a int, b char(10), key a(a), key b(a,b));
|
||||
|
@ -25,11 +25,18 @@ select ((@id := kill_id) - kill_id) from t1;
|
||||
kill @id;
|
||||
|
||||
connection con1;
|
||||
--sleep 1
|
||||
--sleep 2
|
||||
|
||||
# this statement should fail
|
||||
--error 2006,2013
|
||||
--disable_query_log
|
||||
--disable_result_log
|
||||
# One of the following statements should fail
|
||||
--error 0,2006,2013
|
||||
select 1;
|
||||
--error 0,2006,2013
|
||||
select 1;
|
||||
--enable_query_log
|
||||
--enable_result_log
|
||||
|
||||
--enable_reconnect
|
||||
# this should work, and we should have a new connection_id()
|
||||
select ((@id := kill_id) - kill_id) from t1;
|
||||
|
@ -2,7 +2,7 @@
|
||||
-- source include/not_embedded.inc
|
||||
|
||||
--disable_warnings
|
||||
DROP TABLE IF EXISTS t1,t2;
|
||||
DROP TABLE IF EXISTS t1,t2,test1,test2;
|
||||
--enable_warnings
|
||||
|
||||
#
|
||||
|
@ -87,6 +87,14 @@ grant CREATE ROUTINE, EXECUTE on mysqltest1.* to "zedjzlcsjhd"@127.0.0.1;
|
||||
grant SELECT on mysqltest1.t1 to "zedjzlcsjhd"@127.0.0.1;
|
||||
grant SELECT, INSERT on mysqltest1.t2 to "zedjzlcsjhd"@127.0.0.1;
|
||||
|
||||
# ToDo: BUG#14931: There is a race between the last grant binlogging, and
|
||||
# the binlogging in the new connection made below, causing sporadic test
|
||||
# failures due to switched statement order in binlog. To fix this we do
|
||||
# SELECT 1 in the first connection before starting the second, ensuring
|
||||
# that binlogging is done in the expected order.
|
||||
# Please remove this SELECT 1 when BUG#14931 is fixed.
|
||||
SELECT 1;
|
||||
|
||||
connect (con1,127.0.0.1,zedjzlcsjhd,,mysqltest1,$MASTER_MYPORT,);
|
||||
connection con1;
|
||||
|
||||
|
@ -930,11 +930,8 @@ drop table t1, t2, t3;
|
||||
# operator.
|
||||
#
|
||||
create table t1 (a int);
|
||||
--disable_warnings
|
||||
drop procedure if exists p2;
|
||||
--enable_warnings
|
||||
DELIMITER //;
|
||||
CREATE PROCEDURE `p2`()
|
||||
CREATE PROCEDURE `p1`()
|
||||
begin
|
||||
insert into t1 values (1);
|
||||
end//
|
||||
@ -944,8 +941,8 @@ begin
|
||||
set done= not done;
|
||||
end//
|
||||
DELIMITER ;//
|
||||
CALL p2();
|
||||
drop procedure p2;
|
||||
CALL p1();
|
||||
drop procedure p1;
|
||||
drop table t1;
|
||||
|
||||
#
|
||||
|
@ -2275,6 +2275,7 @@ drop table t1;
|
||||
#
|
||||
create table t1(f1 int, f2 int);
|
||||
insert into t1 values (null, 10), (null,2);
|
||||
select f1, sum(f2) from t1 group by f1;
|
||||
create view v1 as select * from t1;
|
||||
select f1, sum(f2) from v1 group by f1;
|
||||
drop view v1;
|
||||
|
60
mysys/hash.c
60
mysys/hash.c
@ -36,9 +36,10 @@ typedef struct st_hash_info {
|
||||
|
||||
static uint hash_mask(uint hashnr,uint buffmax,uint maxlength);
|
||||
static void movelink(HASH_LINK *array,uint pos,uint next_link,uint newlink);
|
||||
static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length);
|
||||
static int hashcmp(const HASH *hash, HASH_LINK *pos, const byte *key,
|
||||
uint length);
|
||||
|
||||
static uint calc_hash(HASH *hash,const byte *key,uint length)
|
||||
static uint calc_hash(const HASH *hash, const byte *key, uint length)
|
||||
{
|
||||
ulong nr1=1, nr2=4;
|
||||
hash->charset->coll->hash_sort(hash->charset,(uchar*) key,length,&nr1,&nr2);
|
||||
@ -63,7 +64,6 @@ _hash_init(HASH *hash,CHARSET_INFO *charset,
|
||||
hash->key_offset=key_offset;
|
||||
hash->key_length=key_length;
|
||||
hash->blength=1;
|
||||
hash->current_record= NO_RECORD; /* For the future */
|
||||
hash->get_key=get_key;
|
||||
hash->free=free_element;
|
||||
hash->flags=flags;
|
||||
@ -135,7 +135,6 @@ void my_hash_reset(HASH *hash)
|
||||
reset_dynamic(&hash->array);
|
||||
/* Set row pointers so that the hash can be reused at once */
|
||||
hash->blength= 1;
|
||||
hash->current_record= NO_RECORD;
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
@ -147,7 +146,8 @@ void my_hash_reset(HASH *hash)
|
||||
*/
|
||||
|
||||
static inline char*
|
||||
hash_key(HASH *hash,const byte *record,uint *length,my_bool first)
|
||||
hash_key(const HASH *hash, const byte *record, uint *length,
|
||||
my_bool first)
|
||||
{
|
||||
if (hash->get_key)
|
||||
return (*hash->get_key)(record,length,first);
|
||||
@ -163,8 +163,8 @@ static uint hash_mask(uint hashnr,uint buffmax,uint maxlength)
|
||||
return (hashnr & ((buffmax >> 1) -1));
|
||||
}
|
||||
|
||||
static uint hash_rec_mask(HASH *hash,HASH_LINK *pos,uint buffmax,
|
||||
uint maxlength)
|
||||
static uint hash_rec_mask(const HASH *hash, HASH_LINK *pos,
|
||||
uint buffmax, uint maxlength)
|
||||
{
|
||||
uint length;
|
||||
byte *key= (byte*) hash_key(hash,pos->data,&length,0);
|
||||
@ -186,14 +186,25 @@ unsigned int rec_hashnr(HASH *hash,const byte *record)
|
||||
}
|
||||
|
||||
|
||||
/* Search after a record based on a key */
|
||||
/* Sets info->current_ptr to found record */
|
||||
gptr hash_search(const HASH *hash, const byte *key, uint length)
|
||||
{
|
||||
HASH_SEARCH_STATE state;
|
||||
return hash_first(hash, key, length, &state);
|
||||
}
|
||||
|
||||
gptr hash_search(HASH *hash,const byte *key,uint length)
|
||||
/*
|
||||
Search after a record based on a key
|
||||
|
||||
NOTE
|
||||
Assigns the number of the found record to HASH_SEARCH_STATE state
|
||||
*/
|
||||
|
||||
gptr hash_first(const HASH *hash, const byte *key, uint length,
|
||||
HASH_SEARCH_STATE *current_record)
|
||||
{
|
||||
HASH_LINK *pos;
|
||||
uint flag,idx;
|
||||
DBUG_ENTER("hash_search");
|
||||
DBUG_ENTER("hash_first");
|
||||
|
||||
flag=1;
|
||||
if (hash->records)
|
||||
@ -206,7 +217,7 @@ gptr hash_search(HASH *hash,const byte *key,uint length)
|
||||
if (!hashcmp(hash,pos,key,length))
|
||||
{
|
||||
DBUG_PRINT("exit",("found key at %d",idx));
|
||||
hash->current_record= idx;
|
||||
*current_record= idx;
|
||||
DBUG_RETURN (pos->data);
|
||||
}
|
||||
if (flag)
|
||||
@ -218,31 +229,32 @@ gptr hash_search(HASH *hash,const byte *key,uint length)
|
||||
}
|
||||
while ((idx=pos->next) != NO_RECORD);
|
||||
}
|
||||
hash->current_record= NO_RECORD;
|
||||
*current_record= NO_RECORD;
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
||||
/* Get next record with identical key */
|
||||
/* Can only be called if previous calls was hash_search */
|
||||
|
||||
gptr hash_next(HASH *hash,const byte *key,uint length)
|
||||
gptr hash_next(const HASH *hash, const byte *key, uint length,
|
||||
HASH_SEARCH_STATE *current_record)
|
||||
{
|
||||
HASH_LINK *pos;
|
||||
uint idx;
|
||||
|
||||
if (hash->current_record != NO_RECORD)
|
||||
if (*current_record != NO_RECORD)
|
||||
{
|
||||
HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
|
||||
for (idx=data[hash->current_record].next; idx != NO_RECORD ; idx=pos->next)
|
||||
for (idx=data[*current_record].next; idx != NO_RECORD ; idx=pos->next)
|
||||
{
|
||||
pos=data+idx;
|
||||
if (!hashcmp(hash,pos,key,length))
|
||||
{
|
||||
hash->current_record= idx;
|
||||
*current_record= idx;
|
||||
return pos->data;
|
||||
}
|
||||
}
|
||||
hash->current_record=NO_RECORD;
|
||||
*current_record= NO_RECORD;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -281,7 +293,8 @@ static void movelink(HASH_LINK *array,uint find,uint next_link,uint newlink)
|
||||
!= 0 key of record != key
|
||||
*/
|
||||
|
||||
static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length)
|
||||
static int hashcmp(const HASH *hash, HASH_LINK *pos, const byte *key,
|
||||
uint length)
|
||||
{
|
||||
uint rec_keylength;
|
||||
byte *rec_key= (byte*) hash_key(hash,pos->data,&rec_keylength,1);
|
||||
@ -307,7 +320,6 @@ my_bool my_hash_insert(HASH *info,const byte *record)
|
||||
if (!(empty=(HASH_LINK*) alloc_dynamic(&info->array)))
|
||||
return(TRUE); /* No more memory */
|
||||
|
||||
info->current_record= NO_RECORD;
|
||||
data=dynamic_element(&info->array,0,HASH_LINK*);
|
||||
halfbuff= info->blength >> 1;
|
||||
|
||||
@ -450,7 +462,6 @@ my_bool hash_delete(HASH *hash,byte *record)
|
||||
}
|
||||
|
||||
if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
|
||||
hash->current_record= NO_RECORD;
|
||||
lastpos=data+hash->records;
|
||||
|
||||
/* Remove link to record */
|
||||
@ -543,7 +554,6 @@ my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length)
|
||||
if ((idx=pos->next) == NO_RECORD)
|
||||
DBUG_RETURN(1); /* Not found in links */
|
||||
}
|
||||
hash->current_record= NO_RECORD;
|
||||
org_link= *pos;
|
||||
empty=idx;
|
||||
|
||||
@ -593,10 +603,10 @@ byte *hash_element(HASH *hash,uint idx)
|
||||
isn't changed
|
||||
*/
|
||||
|
||||
void hash_replace(HASH *hash, uint idx, byte *new_row)
|
||||
void hash_replace(HASH *hash, HASH_SEARCH_STATE *current_record, byte *new_row)
|
||||
{
|
||||
if (idx != NO_RECORD) /* Safety */
|
||||
dynamic_element(&hash->array,idx,HASH_LINK*)->data=new_row;
|
||||
if (*current_record != NO_RECORD) /* Safety */
|
||||
dynamic_element(&hash->array, *current_record, HASH_LINK*)->data= new_row;
|
||||
}
|
||||
|
||||
|
||||
|
@ -74,7 +74,7 @@ static int do_test()
|
||||
bzero((char*) key1,sizeof(key1[0])*1000);
|
||||
|
||||
printf("- Creating hash\n");
|
||||
if (hash_init(&hash,recant/2,0,6,0,free_record,0))
|
||||
if (hash_init(&hash, default_charset_info, recant/2, 0, 6, 0, free_record, 0))
|
||||
goto err;
|
||||
printf("- Writing records:\n");
|
||||
|
||||
@ -172,15 +172,16 @@ static int do_test()
|
||||
break;
|
||||
if (key1[j] > 1)
|
||||
{
|
||||
HASH_SEARCH_STATE state;
|
||||
printf("- Testing identical read\n");
|
||||
sprintf(key,"%6d",j);
|
||||
pos=1;
|
||||
if (!(recpos=hash_search(&hash,key,0)))
|
||||
if (!(recpos= hash_first(&hash, key, 0, &state)))
|
||||
{
|
||||
printf("can't find key1: \"%s\"\n",key);
|
||||
goto err;
|
||||
}
|
||||
while (hash_next(&hash,key,0) && pos < (ulong) (key1[j]+10))
|
||||
while (hash_next(&hash, key, 0, &state) && pos < (ulong) (key1[j]+10))
|
||||
pos++;
|
||||
if (pos != (ulong) key1[j])
|
||||
{
|
||||
@ -189,7 +190,7 @@ static int do_test()
|
||||
}
|
||||
}
|
||||
printf("- Creating output heap-file 2\n");
|
||||
if (hash_init(&hash2,hash.records,0,0,hash2_key,free_record,0))
|
||||
if (hash_init(&hash2, default_charset_info, hash.records, 0, 0, hash2_key, free_record,0))
|
||||
goto err;
|
||||
|
||||
printf("- Copying and removing records\n");
|
||||
|
@ -447,7 +447,7 @@ All benchmarks takes the following options:
|
||||
--create-options=#
|
||||
Extra argument to all create statements. If you for example want to
|
||||
create all MySQL tables as BDB tables use:
|
||||
--create-options=TYPE=BDB
|
||||
--create-options=ENGINE=BDB
|
||||
|
||||
--database (Default $opt_database)
|
||||
In which database the test tables are created.
|
||||
|
@ -174,29 +174,29 @@ sub new
|
||||
|
||||
# Some fixes that depends on the environment
|
||||
if (defined($main::opt_create_options) &&
|
||||
$main::opt_create_options =~ /type=heap/i)
|
||||
$main::opt_create_options =~ /engine=heap/i)
|
||||
{
|
||||
$limits{'working_blobs'} = 0; # HEAP tables can't handle BLOB's
|
||||
}
|
||||
if (defined($main::opt_create_options) &&
|
||||
$main::opt_create_options =~ /type=innodb/i)
|
||||
$main::opt_create_options =~ /engine=innodb/i)
|
||||
{
|
||||
$self->{'transactions'} = 1; # Transactions enabled
|
||||
}
|
||||
if (defined($main::opt_create_options) &&
|
||||
$main::opt_create_options =~ /type=ndb/i)
|
||||
$main::opt_create_options =~ /engine=ndb/i)
|
||||
{
|
||||
$self->{'transactions'} = 1; # Transactions enabled
|
||||
$limits{'max_columns'} = 90; # Max number of columns in table
|
||||
$limits{'max_tables'} = 32; # No comments
|
||||
}
|
||||
if (defined($main::opt_create_options) &&
|
||||
$main::opt_create_options =~ /type=bdb/i)
|
||||
$main::opt_create_options =~ /engine=bdb/i)
|
||||
{
|
||||
$self->{'transactions'} = 1; # Transactions enabled
|
||||
}
|
||||
if (defined($main::opt_create_options) &&
|
||||
$main::opt_create_options =~ /type=gemini/i)
|
||||
$main::opt_create_options =~ /engine=gemini/i)
|
||||
{
|
||||
$limits{'working_blobs'} = 0; # Blobs not implemented yet
|
||||
$limits{'max_tables'} = 500;
|
||||
|
@ -6209,8 +6209,8 @@ Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table)
|
||||
This is done to ensure that ALTER TABLE will convert old VARCHAR fields
|
||||
to now VARCHAR fields.
|
||||
*/
|
||||
if (new_field= new Field_varstring(field_length, maybe_null(),
|
||||
field_name, new_table, charset()))
|
||||
if ((new_field= new Field_varstring(field_length, maybe_null(),
|
||||
field_name, new_table, charset())))
|
||||
{
|
||||
/*
|
||||
delayed_insert::get_local_table() needs a ptr copied from old table.
|
||||
|
@ -2616,8 +2616,7 @@ int ha_federated::stash_remote_error()
|
||||
{
|
||||
DBUG_ENTER("ha_federated::stash_remote_error()");
|
||||
remote_error_number= mysql_errno(mysql);
|
||||
my_snprintf(remote_error_buf, sizeof(remote_error_buf), "%s",
|
||||
mysql_error(mysql));
|
||||
strmake(remote_error_buf, mysql_error(mysql), sizeof(remote_error_buf)-1);
|
||||
DBUG_RETURN(HA_FEDERATED_ERROR_WITH_REMOTE_SYSTEM);
|
||||
}
|
||||
|
||||
|
@ -300,7 +300,8 @@ Thd_ndb::~Thd_ndb()
|
||||
if (ndb)
|
||||
{
|
||||
#ifndef DBUG_OFF
|
||||
Ndb::Free_list_usage tmp; tmp.m_name= 0;
|
||||
Ndb::Free_list_usage tmp;
|
||||
tmp.m_name= 0;
|
||||
while (ndb->get_free_list_usage(&tmp))
|
||||
{
|
||||
uint leaked= (uint) tmp.m_created - tmp.m_free;
|
||||
@ -312,8 +313,8 @@ Thd_ndb::~Thd_ndb()
|
||||
}
|
||||
#endif
|
||||
delete ndb;
|
||||
}
|
||||
ndb= NULL;
|
||||
}
|
||||
changed_tables.empty();
|
||||
}
|
||||
|
||||
@ -4903,7 +4904,8 @@ bool ndbcluster_end()
|
||||
if (g_ndb)
|
||||
{
|
||||
#ifndef DBUG_OFF
|
||||
Ndb::Free_list_usage tmp; tmp.m_name= 0;
|
||||
Ndb::Free_list_usage tmp;
|
||||
tmp.m_name= 0;
|
||||
while (g_ndb->get_free_list_usage(&tmp))
|
||||
{
|
||||
uint leaked= (uint) tmp.m_created - tmp.m_free;
|
||||
@ -4915,9 +4917,8 @@ bool ndbcluster_end()
|
||||
}
|
||||
#endif
|
||||
delete g_ndb;
|
||||
}
|
||||
g_ndb= NULL;
|
||||
if (g_ndb_cluster_connection)
|
||||
}
|
||||
delete g_ndb_cluster_connection;
|
||||
g_ndb_cluster_connection= NULL;
|
||||
|
||||
@ -7463,7 +7464,8 @@ ndbcluster_show_status(THD* thd)
|
||||
if (have_ndbcluster != SHOW_OPTION_YES)
|
||||
{
|
||||
my_message(ER_NOT_SUPPORTED_YET,
|
||||
"Cannot call SHOW NDBCLUSTER STATUS because skip-ndbcluster is defined",
|
||||
"Cannot call SHOW NDBCLUSTER STATUS because skip-ndbcluster is "
|
||||
"defined",
|
||||
MYF(0));
|
||||
DBUG_RETURN(TRUE);
|
||||
}
|
||||
@ -7474,13 +7476,15 @@ ndbcluster_show_status(THD* thd)
|
||||
field_list.push_back(new Item_return_int("free", 10,MYSQL_TYPE_LONG));
|
||||
field_list.push_back(new Item_return_int("sizeof", 10,MYSQL_TYPE_LONG));
|
||||
|
||||
if (protocol->send_fields(&field_list, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
|
||||
if (protocol->send_fields(&field_list,
|
||||
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
|
||||
DBUG_RETURN(TRUE);
|
||||
|
||||
if (get_thd_ndb(thd) && get_thd_ndb(thd)->ndb)
|
||||
{
|
||||
Ndb* ndb= (get_thd_ndb(thd))->ndb;
|
||||
Ndb::Free_list_usage tmp; tmp.m_name= 0;
|
||||
Ndb::Free_list_usage tmp;
|
||||
tmp.m_name= 0;
|
||||
while (ndb->get_free_list_usage(&tmp))
|
||||
{
|
||||
protocol->prepare_for_resend();
|
||||
|
@ -300,39 +300,56 @@ handler *get_new_handler(TABLE *table, MEM_ROOT *alloc, enum db_type db_type)
|
||||
case DB_TYPE_HASH:
|
||||
return new (alloc) ha_hash(table);
|
||||
#endif
|
||||
case DB_TYPE_MRG_MYISAM:
|
||||
case DB_TYPE_MRG_ISAM:
|
||||
return new (alloc) ha_myisammrg(table);
|
||||
#ifdef HAVE_BERKELEY_DB
|
||||
case DB_TYPE_BERKELEY_DB:
|
||||
if (have_berkeley_db == SHOW_OPTION_YES)
|
||||
return new (alloc) ha_berkeley(table);
|
||||
return NULL;
|
||||
#endif
|
||||
#ifdef HAVE_INNOBASE_DB
|
||||
case DB_TYPE_INNODB:
|
||||
if (have_innodb == SHOW_OPTION_YES)
|
||||
return new (alloc) ha_innobase(table);
|
||||
return NULL;
|
||||
#endif
|
||||
#ifdef HAVE_EXAMPLE_DB
|
||||
case DB_TYPE_EXAMPLE_DB:
|
||||
if (have_example_db == SHOW_OPTION_YES)
|
||||
return new (alloc) ha_example(table);
|
||||
return NULL;
|
||||
#endif
|
||||
#if defined(HAVE_ARCHIVE_DB)
|
||||
case DB_TYPE_ARCHIVE_DB:
|
||||
if (have_archive_db == SHOW_OPTION_YES)
|
||||
return new (alloc) ha_archive(table);
|
||||
return NULL;
|
||||
#endif
|
||||
#ifdef HAVE_BLACKHOLE_DB
|
||||
case DB_TYPE_BLACKHOLE_DB:
|
||||
if (have_blackhole_db == SHOW_OPTION_YES)
|
||||
return new (alloc) ha_blackhole(table);
|
||||
return NULL;
|
||||
#endif
|
||||
#ifdef HAVE_FEDERATED_DB
|
||||
case DB_TYPE_FEDERATED_DB:
|
||||
if (have_federated_db == SHOW_OPTION_YES)
|
||||
return new (alloc) ha_federated(table);
|
||||
return NULL;
|
||||
#endif
|
||||
#ifdef HAVE_CSV_DB
|
||||
case DB_TYPE_CSV_DB:
|
||||
if (have_csv_db == SHOW_OPTION_YES)
|
||||
return new (alloc) ha_tina(table);
|
||||
return NULL;
|
||||
#endif
|
||||
#ifdef HAVE_NDBCLUSTER_DB
|
||||
case DB_TYPE_NDBCLUSTER:
|
||||
if (have_ndbcluster == SHOW_OPTION_YES)
|
||||
return new (alloc) ha_ndbcluster(table);
|
||||
return NULL;
|
||||
#endif
|
||||
case DB_TYPE_HEAP:
|
||||
return new (alloc) ha_heap(table);
|
||||
@ -346,8 +363,6 @@ handler *get_new_handler(TABLE *table, MEM_ROOT *alloc, enum db_type db_type)
|
||||
/* Fall back to MyISAM */
|
||||
case DB_TYPE_MYISAM:
|
||||
return new (alloc) ha_myisam(table);
|
||||
case DB_TYPE_MRG_MYISAM:
|
||||
return new (alloc) ha_myisammrg(table);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -4890,6 +4890,12 @@ int Item_ref::save_in_field(Field *to, bool no_conversions)
|
||||
}
|
||||
|
||||
|
||||
void Item_ref::save_org_in_field(Field *field)
|
||||
{
|
||||
(*ref)->save_org_in_field(field);
|
||||
}
|
||||
|
||||
|
||||
void Item_ref::make_field(Send_field *field)
|
||||
{
|
||||
(*ref)->make_field(field);
|
||||
|
@ -1745,11 +1745,7 @@ public:
|
||||
void make_field(Send_field *field);
|
||||
bool fix_fields(THD *, Item **);
|
||||
int save_in_field(Field *field, bool no_conversions);
|
||||
void save_org_in_field(Field *field)
|
||||
{
|
||||
(*ref)->save_org_in_field(field);
|
||||
null_value= (*ref)->null_value;
|
||||
}
|
||||
void save_org_in_field(Field *field);
|
||||
enum Item_result result_type () const { return (*ref)->result_type(); }
|
||||
enum_field_types field_type() const { return (*ref)->field_type(); }
|
||||
Field *get_tmp_table_field()
|
||||
|
@ -723,6 +723,7 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list)
|
||||
char key[MAX_DBKEY_LENGTH];
|
||||
char *db= table_list->db;
|
||||
uint key_length;
|
||||
HASH_SEARCH_STATE state;
|
||||
DBUG_ENTER("lock_table_name");
|
||||
DBUG_PRINT("enter",("db: %s name: %s", db, table_list->table_name));
|
||||
|
||||
@ -733,9 +734,9 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list)
|
||||
|
||||
|
||||
/* Only insert the table if we haven't insert it already */
|
||||
for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
|
||||
for (table=(TABLE*) hash_first(&open_cache, (byte*)key, key_length, &state);
|
||||
table ;
|
||||
table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
|
||||
table = (TABLE*) hash_next(&open_cache, (byte*)key, key_length, &state))
|
||||
if (table->in_use == thd)
|
||||
DBUG_RETURN(0);
|
||||
|
||||
|
@ -114,13 +114,24 @@ static char *pretty_print_str(char *packet, char *str, int len)
|
||||
|
||||
|
||||
/*
|
||||
Creates a temporary name for load data infile:
|
||||
|
||||
SYNOPSIS
|
||||
slave_load_file_stem()
|
||||
buf Store new filename here
|
||||
file_id File_id (part of file name)
|
||||
event_server_id Event_id (part of file name)
|
||||
ext Extension for file name
|
||||
|
||||
RETURN
|
||||
Pointer to start of extension
|
||||
*/
|
||||
|
||||
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
|
||||
static inline char* slave_load_file_stem(char*buf, uint file_id,
|
||||
int event_server_id)
|
||||
static char *slave_load_file_stem(char *buf, uint file_id,
|
||||
int event_server_id, const char *ext)
|
||||
{
|
||||
char *res;
|
||||
fn_format(buf,"SQL_LOAD-",slave_load_tmpdir, "", MY_UNPACK_FILENAME);
|
||||
to_unix_path(buf);
|
||||
|
||||
@ -129,7 +140,9 @@ static inline char* slave_load_file_stem(char*buf, uint file_id,
|
||||
*buf++ = '-';
|
||||
buf = int10_to_str(event_server_id, buf, 10);
|
||||
*buf++ = '-';
|
||||
return int10_to_str(file_id, buf, 10);
|
||||
res= int10_to_str(file_id, buf, 10);
|
||||
strmov(res, ext); // Add extension last
|
||||
return res; // Pointer to extension
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -901,7 +914,6 @@ void Log_event::print_header(FILE* file, PRINT_EVENT_INFO* print_event_info)
|
||||
/* Pretty-print event common header if header is exactly 19 bytes */
|
||||
if (print_event_info->common_header_len == LOG_EVENT_MINIMAL_HEADER_LEN)
|
||||
{
|
||||
DBUG_ASSERT(hexdump_from == (unsigned long) hexdump_from);
|
||||
fprintf(file, "# Position Timestamp Type Master ID "
|
||||
"Size Master Pos Flags \n");
|
||||
fprintf(file, "# %8.8lx %02x %02x %02x %02x %02x "
|
||||
@ -927,7 +939,6 @@ void Log_event::print_header(FILE* file, PRINT_EVENT_INFO* print_event_info)
|
||||
|
||||
if (i % 16 == 15)
|
||||
{
|
||||
DBUG_ASSERT(hexdump_from == (unsigned long) hexdump_from);
|
||||
fprintf(file, "# %8.8lx %-48.48s |%16s|\n",
|
||||
(unsigned long) (hexdump_from + (i & 0xfffffff0)),
|
||||
hex_string, char_string);
|
||||
@ -941,14 +952,12 @@ void Log_event::print_header(FILE* file, PRINT_EVENT_INFO* print_event_info)
|
||||
*c= '\0';
|
||||
|
||||
/* Non-full last line */
|
||||
if (hex_string[0]) {
|
||||
DBUG_ASSERT(hexdump_from == (unsigned long) hexdump_from);
|
||||
if (hex_string[0])
|
||||
fprintf(file, "# %8.8lx %-48.48s |%s|\n# ",
|
||||
(unsigned long) (hexdump_from + (i & 0xfffffff0)),
|
||||
hex_string, char_string);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
@ -4164,16 +4173,15 @@ void Create_file_log_event::pack_info(Protocol *protocol)
|
||||
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
|
||||
int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
|
||||
{
|
||||
char proc_info[17+FN_REFLEN+10], *fname_buf= proc_info+17;
|
||||
char *p;
|
||||
char proc_info[17+FN_REFLEN+10], *fname_buf;
|
||||
char *ext;
|
||||
int fd = -1;
|
||||
IO_CACHE file;
|
||||
int error = 1;
|
||||
|
||||
bzero((char*)&file, sizeof(file));
|
||||
p = slave_load_file_stem(fname_buf, file_id, server_id);
|
||||
strmov(p, ".info"); // strmov takes less code than memcpy
|
||||
strnmov(proc_info, STRING_WITH_LEN("Making temp file ")); // no end 0
|
||||
fname_buf= strmov(proc_info, "Making temp file ");
|
||||
ext= slave_load_file_stem(fname_buf, file_id, server_id, ".info");
|
||||
thd->proc_info= proc_info;
|
||||
my_delete(fname_buf, MYF(0)); // old copy may exist already
|
||||
if ((fd= my_create(fname_buf, CREATE_MODE,
|
||||
@ -4182,19 +4190,21 @@ int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
|
||||
init_io_cache(&file, fd, IO_SIZE, WRITE_CACHE, (my_off_t)0, 0,
|
||||
MYF(MY_WME|MY_NABP)))
|
||||
{
|
||||
slave_print_error(rli,my_errno, "Error in Create_file event: could not open file '%s'", fname_buf);
|
||||
slave_print_error(rli,my_errno,
|
||||
"Error in Create_file event: could not open file '%s'",
|
||||
fname_buf);
|
||||
goto err;
|
||||
}
|
||||
|
||||
// a trick to avoid allocating another buffer
|
||||
strmov(p, ".data");
|
||||
fname= fname_buf;
|
||||
fname_len = (uint)(p-fname) + 5;
|
||||
fname_len= (uint) (strmov(ext, ".data") - fname);
|
||||
if (write_base(&file))
|
||||
{
|
||||
strmov(p, ".info"); // to have it right in the error message
|
||||
strmov(ext, ".info"); // to have it right in the error message
|
||||
slave_print_error(rli,my_errno,
|
||||
"Error in Create_file event: could not write to file '%s'",
|
||||
"Error in Create_file event: could not write to file "
|
||||
"'%s'",
|
||||
fname_buf);
|
||||
goto err;
|
||||
}
|
||||
@ -4207,12 +4217,16 @@ int Create_file_log_event::exec_event(struct st_relay_log_info* rli)
|
||||
O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
|
||||
MYF(MY_WME))) < 0)
|
||||
{
|
||||
slave_print_error(rli,my_errno, "Error in Create_file event: could not open file '%s'", fname_buf);
|
||||
slave_print_error(rli,my_errno,
|
||||
"Error in Create_file event: could not open file '%s'",
|
||||
fname_buf);
|
||||
goto err;
|
||||
}
|
||||
if (my_write(fd, (byte*) block, block_len, MYF(MY_WME+MY_NABP)))
|
||||
{
|
||||
slave_print_error(rli,my_errno, "Error in Create_file event: write to '%s' failed", fname_buf);
|
||||
slave_print_error(rli,my_errno,
|
||||
"Error in Create_file event: write to '%s' failed",
|
||||
fname_buf);
|
||||
goto err;
|
||||
}
|
||||
error=0; // Everything is ok
|
||||
@ -4336,13 +4350,12 @@ int Append_block_log_event::get_create_or_append() const
|
||||
int Append_block_log_event::exec_event(struct st_relay_log_info* rli)
|
||||
{
|
||||
char proc_info[17+FN_REFLEN+10], *fname= proc_info+17;
|
||||
char *p= slave_load_file_stem(fname, file_id, server_id);
|
||||
int fd;
|
||||
int error = 1;
|
||||
DBUG_ENTER("Append_block_log_event::exec_event");
|
||||
|
||||
memcpy(p, ".data", 6);
|
||||
strnmov(proc_info, STRING_WITH_LEN("Making temp file ")); // no end 0
|
||||
fname= strmov(proc_info, "Making temp file ");
|
||||
slave_load_file_stem(fname, file_id, server_id, ".data");
|
||||
thd->proc_info= proc_info;
|
||||
if (get_create_or_append())
|
||||
{
|
||||
@ -4468,10 +4481,9 @@ void Delete_file_log_event::pack_info(Protocol *protocol)
|
||||
int Delete_file_log_event::exec_event(struct st_relay_log_info* rli)
|
||||
{
|
||||
char fname[FN_REFLEN+10];
|
||||
char *p= slave_load_file_stem(fname, file_id, server_id);
|
||||
memcpy(p, ".data", 6);
|
||||
char *ext= slave_load_file_stem(fname, file_id, server_id, ".data");
|
||||
(void) my_delete(fname, MYF(MY_WME));
|
||||
memcpy(p, ".info", 6);
|
||||
strmov(ext, ".info");
|
||||
(void) my_delete(fname, MYF(MY_WME));
|
||||
return Log_event::exec_event(rli);
|
||||
}
|
||||
@ -4564,19 +4576,21 @@ void Execute_load_log_event::pack_info(Protocol *protocol)
|
||||
int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
|
||||
{
|
||||
char fname[FN_REFLEN+10];
|
||||
char *p= slave_load_file_stem(fname, file_id, server_id);
|
||||
char *ext;
|
||||
int fd;
|
||||
int error= 1;
|
||||
IO_CACHE file;
|
||||
Load_log_event *lev= 0;
|
||||
|
||||
memcpy(p, ".info", 6);
|
||||
ext= slave_load_file_stem(fname, file_id, server_id, ".info");
|
||||
if ((fd = my_open(fname, O_RDONLY | O_BINARY | O_NOFOLLOW,
|
||||
MYF(MY_WME))) < 0 ||
|
||||
init_io_cache(&file, fd, IO_SIZE, READ_CACHE, (my_off_t)0, 0,
|
||||
MYF(MY_WME|MY_NABP)))
|
||||
{
|
||||
slave_print_error(rli,my_errno, "Error in Exec_load event: could not open file '%s'", fname);
|
||||
slave_print_error(rli,my_errno,
|
||||
"Error in Exec_load event: could not open file '%s'",
|
||||
fname);
|
||||
goto err;
|
||||
}
|
||||
if (!(lev = (Load_log_event*)Log_event::read_log_event(&file,
|
||||
@ -4584,7 +4598,9 @@ int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
|
||||
rli->relay_log.description_event_for_exec)) ||
|
||||
lev->get_type_code() != NEW_LOAD_EVENT)
|
||||
{
|
||||
slave_print_error(rli,0, "Error in Exec_load event: file '%s' appears corrupted", fname);
|
||||
slave_print_error(rli,0,
|
||||
"Error in Exec_load event: file '%s' appears corrupted",
|
||||
fname);
|
||||
goto err;
|
||||
}
|
||||
|
||||
@ -4629,7 +4645,7 @@ int Execute_load_log_event::exec_event(struct st_relay_log_info* rli)
|
||||
fd= -1;
|
||||
}
|
||||
(void) my_delete(fname, MYF(MY_WME));
|
||||
memcpy(p, ".data", 6);
|
||||
memcpy(ext, ".data", 6);
|
||||
(void) my_delete(fname, MYF(MY_WME));
|
||||
error = 0;
|
||||
|
||||
@ -4827,11 +4843,10 @@ Execute_load_query_log_event::exec_event(struct st_relay_log_info* rli)
|
||||
memcpy(p, query, fn_pos_start);
|
||||
p+= fn_pos_start;
|
||||
fname= (p= strmake(p, STRING_WITH_LEN(" INFILE \'")));
|
||||
p= slave_load_file_stem(p, file_id, server_id);
|
||||
fname_end= (p= strmake(p, STRING_WITH_LEN(".data")));
|
||||
p= slave_load_file_stem(p, file_id, server_id, ".data");
|
||||
fname_end= p= strend(p); // Safer than p=p+5
|
||||
*(p++)='\'';
|
||||
switch (dup_handling)
|
||||
{
|
||||
switch (dup_handling) {
|
||||
case LOAD_DUP_IGNORE:
|
||||
p= strmake(p, STRING_WITH_LEN(" IGNORE"));
|
||||
break;
|
||||
|
@ -1401,7 +1401,7 @@ static void network_init(void)
|
||||
{
|
||||
if (((ret= bind(ip_sock, my_reinterpret_cast(struct sockaddr *) (&IPaddr),
|
||||
sizeof(IPaddr))) >= 0) ||
|
||||
(socket_errno != EADDRINUSE) ||
|
||||
(socket_errno != SOCKET_EADDRINUSE) ||
|
||||
(waited >= mysqld_port_timeout))
|
||||
break;
|
||||
sql_print_information("Retrying bind on TCP/IP port %u", mysqld_port);
|
||||
@ -1613,7 +1613,7 @@ void end_thread(THD *thd, bool put_in_cache)
|
||||
wake_thread--;
|
||||
thd=thread_cache.get();
|
||||
thd->real_id=pthread_self();
|
||||
thd->thread_stack= (char *) &thd;
|
||||
thd->thread_stack= (char*) &thd; // For store_globals
|
||||
(void) thd->store_globals();
|
||||
thd->thr_create_time= time(NULL);
|
||||
threads.append(thd);
|
||||
|
@ -5737,6 +5737,7 @@ bool QUICK_ROR_UNION_SELECT::check_if_keys_used(List<Item> *fields)
|
||||
|
||||
/*
|
||||
Create quick select from ref/ref_or_null scan.
|
||||
|
||||
SYNOPSIS
|
||||
get_quick_select_for_ref()
|
||||
thd Thread handle
|
||||
@ -5756,15 +5757,18 @@ bool QUICK_ROR_UNION_SELECT::check_if_keys_used(List<Item> *fields)
|
||||
QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
|
||||
TABLE_REF *ref, ha_rows records)
|
||||
{
|
||||
MEM_ROOT *old_root= thd->mem_root;
|
||||
/* The following call may change thd->mem_root */
|
||||
QUICK_RANGE_SELECT *quick= new QUICK_RANGE_SELECT(thd, table, ref->key, 0);
|
||||
/* save mem_root set by QUICK_RANGE_SELECT constructor */
|
||||
MEM_ROOT *alloc= thd->mem_root;
|
||||
MEM_ROOT *old_root, *alloc;
|
||||
QUICK_RANGE_SELECT *quick;
|
||||
KEY *key_info = &table->key_info[ref->key];
|
||||
KEY_PART *key_part;
|
||||
QUICK_RANGE *range;
|
||||
uint part;
|
||||
|
||||
old_root= thd->mem_root;
|
||||
/* The following call may change thd->mem_root */
|
||||
quick= new QUICK_RANGE_SELECT(thd, table, ref->key, 0);
|
||||
/* save mem_root set by QUICK_RANGE_SELECT constructor */
|
||||
alloc= thd->mem_root;
|
||||
/*
|
||||
return back default mem_root (thd->mem_root) changed by
|
||||
QUICK_RANGE_SELECT constructor
|
||||
|
@ -944,6 +944,6 @@ File_parser_dummy_hook::process_unknown_string(char *&unknown_key,
|
||||
char *end)
|
||||
{
|
||||
DBUG_ENTER("file_parser_dummy_hook::process_unknown_string");
|
||||
DBUG_PRINT("info", ("unknown key:%60s", unknown_key));
|
||||
DBUG_PRINT("info", ("Unknown key: '%60s'", unknown_key));
|
||||
DBUG_RETURN(FALSE);
|
||||
}
|
||||
|
34
sql/sp.cc
34
sql/sp.cc
@ -399,14 +399,14 @@ db_load_routine(THD *thd, int type, sp_name *name, sp_head **sphp,
|
||||
const char *body, st_sp_chistics &chistics,
|
||||
const char *definer, longlong created, longlong modified)
|
||||
{
|
||||
LEX *oldlex= thd->lex, newlex;
|
||||
sp_rcontext *save_spcont= thd->spcont;
|
||||
LEX *old_lex= thd->lex, newlex;
|
||||
String defstr;
|
||||
char olddb[128];
|
||||
bool dbchanged;
|
||||
ulong old_sql_mode= thd->variables.sql_mode;
|
||||
ha_rows select_limit= thd->variables.select_limit;
|
||||
int ret= SP_INTERNAL_ERROR;
|
||||
ha_rows old_select_limit= thd->variables.select_limit;
|
||||
sp_rcontext *old_spcont= thd->spcont;
|
||||
int ret;
|
||||
|
||||
thd->variables.sql_mode= sql_mode;
|
||||
thd->variables.select_limit= HA_POS_ERROR;
|
||||
@ -422,7 +422,10 @@ db_load_routine(THD *thd, int type, sp_name *name, sp_head **sphp,
|
||||
returns, strlen(returns),
|
||||
body, strlen(body),
|
||||
&chistics))
|
||||
{
|
||||
ret= SP_INTERNAL_ERROR;
|
||||
goto end;
|
||||
}
|
||||
|
||||
dbchanged= FALSE;
|
||||
if ((ret= sp_use_new_db(thd, name->m_db.str, olddb, sizeof(olddb),
|
||||
@ -451,10 +454,10 @@ db_load_routine(THD *thd, int type, sp_name *name, sp_head **sphp,
|
||||
(*sphp)->optimize();
|
||||
}
|
||||
end:
|
||||
thd->spcont= save_spcont;
|
||||
thd->spcont= old_spcont;
|
||||
thd->variables.sql_mode= old_sql_mode;
|
||||
thd->variables.select_limit= select_limit;
|
||||
thd->lex= oldlex;
|
||||
thd->variables.select_limit= old_select_limit;
|
||||
thd->lex= old_lex;
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -926,7 +929,6 @@ sp_find_routine(THD *thd, int type, sp_name *name, sp_cache **cp,
|
||||
ulong depth= (type == TYPE_ENUM_PROCEDURE ?
|
||||
thd->variables.max_sp_recursion_depth :
|
||||
0);
|
||||
|
||||
DBUG_ENTER("sp_find_routine");
|
||||
DBUG_PRINT("enter", ("name: %.*s.%.*s, type: %d, cache only %d",
|
||||
name->m_db.length, name->m_db.str,
|
||||
@ -936,6 +938,11 @@ sp_find_routine(THD *thd, int type, sp_name *name, sp_cache **cp,
|
||||
if ((sp= sp_cache_lookup(cp, name)))
|
||||
{
|
||||
ulong level;
|
||||
sp_head *new_sp;
|
||||
const char *returns= "";
|
||||
char definer[HOSTNAME_LENGTH+USERNAME_LENGTH+2];
|
||||
String retstr(64);
|
||||
|
||||
DBUG_PRINT("info", ("found: 0x%lx", (ulong)sp));
|
||||
if (sp->m_first_free_instance)
|
||||
{
|
||||
@ -946,7 +953,7 @@ sp_find_routine(THD *thd, int type, sp_name *name, sp_cache **cp,
|
||||
DBUG_ASSERT(!(sp->m_first_free_instance->m_flags & sp_head::IS_INVOKED));
|
||||
if (sp->m_first_free_instance->m_recursion_level > depth)
|
||||
{
|
||||
sp->recursion_level_error();
|
||||
sp->recursion_level_error(thd);
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
DBUG_RETURN(sp->m_first_free_instance);
|
||||
@ -954,14 +961,10 @@ sp_find_routine(THD *thd, int type, sp_name *name, sp_cache **cp,
|
||||
level= sp->m_last_cached_sp->m_recursion_level + 1;
|
||||
if (level > depth)
|
||||
{
|
||||
sp->recursion_level_error();
|
||||
sp->recursion_level_error(thd);
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
{
|
||||
sp_head *new_sp;
|
||||
const char *returns= "";
|
||||
char definer[HOSTNAME_LENGTH+USERNAME_LENGTH+2];
|
||||
String retstr(64);
|
||||
|
||||
strxmov(definer, sp->m_definer_user.str, "@",
|
||||
sp->m_definer_host.str, NullS);
|
||||
if (type == TYPE_ENUM_FUNCTION)
|
||||
@ -985,7 +988,6 @@ sp_find_routine(THD *thd, int type, sp_name *name, sp_cache **cp,
|
||||
}
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
}
|
||||
if (!cache_only)
|
||||
{
|
||||
if (db_find_routine(thd, type, name, &sp) == SP_OK)
|
||||
|
@ -24,6 +24,13 @@
|
||||
#include "sp_rcontext.h"
|
||||
#include "sp_cache.h"
|
||||
|
||||
/*
|
||||
Sufficient max length of printed destinations and frame offsets (all uints).
|
||||
*/
|
||||
#define SP_INSTR_UINT_MAXLEN 8
|
||||
#define SP_STMT_PRINT_MAXLEN 40
|
||||
|
||||
|
||||
Item_result
|
||||
sp_map_result_type(enum enum_field_types type)
|
||||
{
|
||||
@ -867,17 +874,17 @@ subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str)
|
||||
|
||||
SYNOPSIS
|
||||
sp_head::recursion_level_error()
|
||||
thd Thread handle
|
||||
|
||||
NOTE
|
||||
For functions and triggers we return error about prohibited recursion.
|
||||
For stored procedures we return about reaching recursion limit.
|
||||
*/
|
||||
|
||||
void sp_head::recursion_level_error()
|
||||
void sp_head::recursion_level_error(THD *thd)
|
||||
{
|
||||
if (m_type == TYPE_ENUM_PROCEDURE)
|
||||
{
|
||||
THD *thd= current_thd;
|
||||
my_error(ER_SP_RECURSION_LIMIT, MYF(0),
|
||||
thd->variables.max_sp_recursion_depth,
|
||||
m_name.str);
|
||||
@ -928,14 +935,15 @@ sp_head::execute(THD *thd)
|
||||
DBUG_ASSERT(!(m_flags & IS_INVOKED));
|
||||
m_flags|= IS_INVOKED;
|
||||
m_first_instance->m_first_free_instance= m_next_cached_sp;
|
||||
DBUG_PRINT("info", ("first free for 0x%lx ++: 0x%lx->0x%lx, level: %lu, flags %x",
|
||||
(ulong)m_first_instance, this, m_next_cached_sp,
|
||||
(m_next_cached_sp ?
|
||||
m_next_cached_sp->m_recursion_level :
|
||||
0),
|
||||
(m_next_cached_sp ?
|
||||
m_next_cached_sp->m_flags :
|
||||
0)));
|
||||
if (m_next_cached_sp)
|
||||
{
|
||||
DBUG_PRINT("info",
|
||||
("first free for 0x%lx ++: 0x%lx->0x%lx level: %lu flags %x",
|
||||
(ulong)m_first_instance, (ulong) this,
|
||||
(ulong) m_next_cached_sp,
|
||||
m_next_cached_sp->m_recursion_level,
|
||||
m_next_cached_sp->m_flags));
|
||||
}
|
||||
/*
|
||||
Check that if there are not any instances after this one then
|
||||
pointer to the last instance points on this instance or if there are
|
||||
@ -1103,13 +1111,15 @@ sp_head::execute(THD *thd)
|
||||
state= EXECUTED;
|
||||
|
||||
done:
|
||||
DBUG_PRINT("info", ("err_status=%d killed=%d query_error=%d",
|
||||
DBUG_PRINT("info", ("err_status: %d killed: %d query_error: %d",
|
||||
err_status, thd->killed, thd->query_error));
|
||||
|
||||
if (thd->killed)
|
||||
err_status= TRUE;
|
||||
/* If the DB has changed, the pointer has changed too, but the
|
||||
original thd->db will then have been freed */
|
||||
/*
|
||||
If the DB has changed, the pointer has changed too, but the
|
||||
original thd->db will then have been freed
|
||||
*/
|
||||
if (dbchanged)
|
||||
{
|
||||
/*
|
||||
@ -1120,10 +1130,11 @@ sp_head::execute(THD *thd)
|
||||
err_status|= mysql_change_db(thd, olddb, 1);
|
||||
}
|
||||
m_flags&= ~IS_INVOKED;
|
||||
DBUG_PRINT("info", ("first free for 0x%lx --: 0x%lx->0x%lx, level: %lu, flags %x",
|
||||
DBUG_PRINT("info",
|
||||
("first free for 0x%lx --: 0x%lx->0x%lx, level: %lu, flags %x",
|
||||
(ulong) m_first_instance,
|
||||
m_first_instance->m_first_free_instance, this,
|
||||
m_recursion_level, m_flags));
|
||||
(ulong) m_first_instance->m_first_free_instance,
|
||||
(ulong) this, m_recursion_level, m_flags));
|
||||
/*
|
||||
Check that we have one of following:
|
||||
|
||||
@ -1133,7 +1144,7 @@ sp_head::execute(THD *thd)
|
||||
|
||||
2) There are some free instances which mean that first free instance
|
||||
should go just after this one and recursion level of that free instance
|
||||
should be on 1 more then recursion leven of this instance.
|
||||
should be on 1 more then recursion level of this instance.
|
||||
*/
|
||||
DBUG_ASSERT((m_first_instance->m_first_free_instance == 0 &&
|
||||
this == m_first_instance->m_last_cached_sp &&
|
||||
@ -1741,16 +1752,16 @@ sp_head::set_info(longlong created, longlong modified,
|
||||
|
||||
|
||||
void
|
||||
sp_head::set_definer(char *definer, uint definerlen)
|
||||
|
||||
sp_head::set_definer(const char *definer, uint definerlen)
|
||||
{
|
||||
char *p= strrchr(definer, '@');
|
||||
const char *p= strrchr(definer, '@');
|
||||
|
||||
if (!p)
|
||||
{
|
||||
m_definer_user.str= strmake_root(mem_root, "", 0);
|
||||
m_definer_user.str= (char*) "";
|
||||
m_definer_user.length= 0;
|
||||
|
||||
m_definer_host.str= strmake_root(mem_root, "", 0);
|
||||
m_definer_host.str= (char*) "";
|
||||
m_definer_host.length= 0;
|
||||
}
|
||||
else
|
||||
@ -1845,9 +1856,9 @@ sp_head::show_create_procedure(THD *thd)
|
||||
byte *sql_mode_str;
|
||||
ulong sql_mode_len;
|
||||
bool full_access;
|
||||
|
||||
DBUG_ENTER("sp_head::show_create_procedure");
|
||||
DBUG_PRINT("info", ("procedure %s", m_name.str));
|
||||
|
||||
LINT_INIT(sql_mode_str);
|
||||
LINT_INIT(sql_mode_len);
|
||||
|
||||
@ -2200,12 +2211,7 @@ sp_instr_stmt::execute(THD *thd, uint *nextp)
|
||||
DBUG_RETURN(res);
|
||||
}
|
||||
|
||||
/*
|
||||
Sufficient max length of printed destinations and frame offsets (all uints).
|
||||
*/
|
||||
#define SP_INSTR_UINT_MAXLEN 8
|
||||
|
||||
#define SP_STMT_PRINT_MAXLEN 40
|
||||
void
|
||||
sp_instr_stmt::print(String *str)
|
||||
{
|
||||
@ -2227,16 +2233,16 @@ sp_instr_stmt::print(String *str)
|
||||
/* Copy the query string and replace '\n' with ' ' in the process */
|
||||
for (i= 0 ; i < len ; i++)
|
||||
{
|
||||
if (m_query.str[i] == '\n')
|
||||
str->qs_append(' ');
|
||||
else
|
||||
str->qs_append(m_query.str[i]);
|
||||
char c= m_query.str[i];
|
||||
if (c == '\n')
|
||||
c= ' ';
|
||||
str->qs_append(c);
|
||||
}
|
||||
if (m_query.length > SP_STMT_PRINT_MAXLEN)
|
||||
str->qs_append(STRING_WITH_LEN("...")); /* Indicate truncated string */
|
||||
str->qs_append('"');
|
||||
}
|
||||
#undef SP_STMT_PRINT_MAXLEN
|
||||
|
||||
|
||||
int
|
||||
sp_instr_stmt::exec_core(THD *thd, uint *nextp)
|
||||
@ -2602,6 +2608,7 @@ sp_instr_hpush_jump::execute(THD *thd, uint *nextp)
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
sp_instr_hpush_jump::print(String *str)
|
||||
{
|
||||
@ -2612,8 +2619,7 @@ sp_instr_hpush_jump::print(String *str)
|
||||
str->qs_append(m_dest);
|
||||
str->qs_append(' ');
|
||||
str->qs_append(m_frame);
|
||||
switch (m_type)
|
||||
{
|
||||
switch (m_type) {
|
||||
case SP_HANDLER_NONE:
|
||||
str->qs_append(STRING_WITH_LEN(" NONE")); // This would be a bug
|
||||
break;
|
||||
@ -2627,11 +2633,13 @@ sp_instr_hpush_jump::print(String *str)
|
||||
str->qs_append(STRING_WITH_LEN(" UNDO"));
|
||||
break;
|
||||
default:
|
||||
str->qs_append(STRING_WITH_LEN(" UNKNOWN:")); // This would be a bug as well
|
||||
// This would be a bug as well
|
||||
str->qs_append(STRING_WITH_LEN(" UNKNOWN:"));
|
||||
str->qs_append(m_type);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint
|
||||
sp_instr_hpush_jump::opt_mark(sp_head *sp)
|
||||
{
|
||||
|
@ -285,7 +285,7 @@ public:
|
||||
void set_info(longlong created, longlong modified,
|
||||
st_sp_chistics *chistics, ulong sql_mode);
|
||||
|
||||
void set_definer(char *definer, uint definerlen);
|
||||
void set_definer(const char *definer, uint definerlen);
|
||||
|
||||
void reset_thd_mem_root(THD *thd);
|
||||
|
||||
@ -294,7 +294,7 @@ public:
|
||||
void optimize();
|
||||
void opt_mark(uint ip);
|
||||
|
||||
void recursion_level_error();
|
||||
void recursion_level_error(THD *thd);
|
||||
|
||||
inline sp_instr *
|
||||
get_instr(uint i)
|
||||
|
@ -2244,14 +2244,14 @@ static GRANT_NAME *name_hash_search(HASH *name_hash,
|
||||
char helping [NAME_LEN*2+USERNAME_LENGTH+3];
|
||||
uint len;
|
||||
GRANT_NAME *grant_name,*found=0;
|
||||
HASH_SEARCH_STATE state;
|
||||
|
||||
len = (uint) (strmov(strmov(strmov(helping,user)+1,db)+1,tname)-helping)+ 1;
|
||||
for (grant_name=(GRANT_NAME*) hash_search(name_hash,
|
||||
(byte*) helping,
|
||||
len) ;
|
||||
for (grant_name= (GRANT_NAME*) hash_first(name_hash, (byte*) helping,
|
||||
len, &state);
|
||||
grant_name ;
|
||||
grant_name= (GRANT_NAME*) hash_next(name_hash,(byte*) helping,
|
||||
len))
|
||||
len, &state))
|
||||
{
|
||||
if (exact)
|
||||
{
|
||||
@ -3553,7 +3553,7 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables,
|
||||
of other queries). For simple queries first_not_own_table is 0.
|
||||
*/
|
||||
for (i= 0, table= tables;
|
||||
table && table != first_not_own_table && i < number;
|
||||
table != first_not_own_table && i < number;
|
||||
table= table->next_global, i++)
|
||||
{
|
||||
/* Remove SHOW_VIEW_ACL, because it will be checked during making view */
|
||||
|
@ -1085,6 +1085,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
|
||||
char key[MAX_DBKEY_LENGTH];
|
||||
uint key_length;
|
||||
char *alias= table_list->alias;
|
||||
HASH_SEARCH_STATE state;
|
||||
DBUG_ENTER("open_table");
|
||||
|
||||
/* find a unused table in the open table cache */
|
||||
@ -1247,9 +1248,11 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
|
||||
if (thd->handler_tables)
|
||||
mysql_ha_flush(thd, (TABLE_LIST*) NULL, MYSQL_HA_REOPEN_ON_USAGE, TRUE);
|
||||
|
||||
for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
|
||||
for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
|
||||
&state);
|
||||
table && table->in_use ;
|
||||
table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
|
||||
table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
|
||||
&state))
|
||||
{
|
||||
if (table->s->version != refresh_version)
|
||||
{
|
||||
@ -1621,10 +1624,12 @@ bool table_is_used(TABLE *table, bool wait_for_name_lock)
|
||||
{
|
||||
char *key= table->s->table_cache_key;
|
||||
uint key_length= table->s->key_length;
|
||||
for (TABLE *search=(TABLE*) hash_search(&open_cache,
|
||||
(byte*) key,key_length) ;
|
||||
HASH_SEARCH_STATE state;
|
||||
for (TABLE *search= (TABLE*) hash_first(&open_cache, (byte*) key,
|
||||
key_length, &state);
|
||||
search ;
|
||||
search = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
|
||||
search= (TABLE*) hash_next(&open_cache, (byte*) key,
|
||||
key_length, &state))
|
||||
{
|
||||
if (search->locked_by_flush ||
|
||||
search->locked_by_name && wait_for_name_lock ||
|
||||
@ -5059,15 +5064,17 @@ bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
|
||||
bool result=0, signalled= 0;
|
||||
DBUG_ENTER("remove_table_from_cache");
|
||||
|
||||
|
||||
key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
|
||||
for (;;)
|
||||
{
|
||||
HASH_SEARCH_STATE state;
|
||||
result= signalled= 0;
|
||||
|
||||
for (table=(TABLE*) hash_search(&open_cache,(byte*) key,key_length) ;
|
||||
for (table= (TABLE*) hash_first(&open_cache, (byte*) key, key_length,
|
||||
&state);
|
||||
table;
|
||||
table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length))
|
||||
table= (TABLE*) hash_next(&open_cache, (byte*) key, key_length,
|
||||
&state))
|
||||
{
|
||||
THD *in_use;
|
||||
table->s->version=0L; /* Free when thread is ready */
|
||||
|
@ -3050,6 +3050,7 @@ my_bool Query_cache::move_by_type(byte **border,
|
||||
}
|
||||
case Query_cache_block::TABLE:
|
||||
{
|
||||
HASH_SEARCH_STATE record_idx;
|
||||
DBUG_PRINT("qcache", ("block 0x%lx TABLE", (ulong) block));
|
||||
if (*border == 0)
|
||||
break;
|
||||
@ -3067,7 +3068,7 @@ my_bool Query_cache::move_by_type(byte **border,
|
||||
byte *key;
|
||||
uint key_length;
|
||||
key=query_cache_table_get_key((byte*) block, &key_length, 0);
|
||||
hash_search(&tables, (byte*) key, key_length);
|
||||
hash_first(&tables, (byte*) key, key_length, &record_idx);
|
||||
|
||||
block->destroy();
|
||||
new_block->init(len);
|
||||
@ -3101,7 +3102,7 @@ my_bool Query_cache::move_by_type(byte **border,
|
||||
/* Fix pointer to table name */
|
||||
new_block->table()->table(new_block->table()->db() + tablename_offset);
|
||||
/* Fix hash to point at moved block */
|
||||
hash_replace(&tables, tables.current_record, (byte*) new_block);
|
||||
hash_replace(&tables, &record_idx, (byte*) new_block);
|
||||
|
||||
DBUG_PRINT("qcache", ("moved %lu bytes to 0x%lx, new gap at 0x%lx",
|
||||
len, (ulong) new_block, (ulong) *border));
|
||||
@ -3109,6 +3110,7 @@ my_bool Query_cache::move_by_type(byte **border,
|
||||
}
|
||||
case Query_cache_block::QUERY:
|
||||
{
|
||||
HASH_SEARCH_STATE record_idx;
|
||||
DBUG_PRINT("qcache", ("block 0x%lx QUERY", (ulong) block));
|
||||
if (*border == 0)
|
||||
break;
|
||||
@ -3126,7 +3128,7 @@ my_bool Query_cache::move_by_type(byte **border,
|
||||
byte *key;
|
||||
uint key_length;
|
||||
key=query_cache_query_get_key((byte*) block, &key_length, 0);
|
||||
hash_search(&queries, (byte*) key, key_length);
|
||||
hash_first(&queries, (byte*) key, key_length, &record_idx);
|
||||
// Move table of used tables
|
||||
memmove((char*) new_block->table(0), (char*) block->table(0),
|
||||
ALIGN_SIZE(n_tables*sizeof(Query_cache_block_table)));
|
||||
@ -3194,7 +3196,7 @@ my_bool Query_cache::move_by_type(byte **border,
|
||||
net->query_cache_query= (gptr) new_block;
|
||||
}
|
||||
/* Fix hash to point at moved block */
|
||||
hash_replace(&queries, queries.current_record, (byte*) new_block);
|
||||
hash_replace(&queries, &record_idx, (byte*) new_block);
|
||||
DBUG_PRINT("qcache", ("moved %lu bytes to 0x%lx, new gap at 0x%lx",
|
||||
len, (ulong) new_block, (ulong) *border));
|
||||
break;
|
||||
|
@ -227,6 +227,7 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, bool reopen)
|
||||
/* add to hash */
|
||||
if (my_hash_insert(&thd->handler_tables_hash, (byte*) hash_tables))
|
||||
{
|
||||
my_free((char*) hash_tables, MYF(0));
|
||||
mysql_ha_close(thd, tables);
|
||||
goto err;
|
||||
}
|
||||
@ -369,26 +370,6 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables,
|
||||
DBUG_PRINT("info-in-hash",("'%s'.'%s' as '%s' tab %p",
|
||||
hash_tables->db, hash_tables->table_name,
|
||||
hash_tables->alias, table));
|
||||
/* Table might have been flushed. */
|
||||
if (table && (table->s->version != refresh_version))
|
||||
{
|
||||
/*
|
||||
We must follow the thd->handler_tables chain, as we need the
|
||||
address of the 'next' pointer referencing this table
|
||||
for close_thread_table().
|
||||
*/
|
||||
for (table_ptr= &(thd->handler_tables); *table_ptr != table;
|
||||
table_ptr= &(*table_ptr)->next) /* no-op */ ;
|
||||
(*table_ptr)->file->ha_index_or_rnd_end();
|
||||
VOID(pthread_mutex_lock(&LOCK_open));
|
||||
if (close_thread_table(thd, table_ptr))
|
||||
{
|
||||
/* Tell threads waiting for refresh that something has happened */
|
||||
VOID(pthread_cond_broadcast(&COND_refresh));
|
||||
}
|
||||
VOID(pthread_mutex_unlock(&LOCK_open));
|
||||
table= hash_tables->table= NULL;
|
||||
}
|
||||
if (!table)
|
||||
{
|
||||
/*
|
||||
@ -433,6 +414,13 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables,
|
||||
}
|
||||
tables->table=table;
|
||||
|
||||
HANDLER_TABLES_HACK(thd);
|
||||
lock= mysql_lock_tables(thd, &tables->table, 1, 0, ¬_used);
|
||||
HANDLER_TABLES_HACK(thd);
|
||||
|
||||
if (!lock)
|
||||
goto err0; // mysql_lock_tables() printed error message already
|
||||
|
||||
if (cond && ((!cond->fixed &&
|
||||
cond->fix_fields(thd, &cond)) || cond->check_cols(1)))
|
||||
goto err0;
|
||||
@ -452,13 +440,6 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables,
|
||||
|
||||
protocol->send_fields(&list, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
|
||||
|
||||
HANDLER_TABLES_HACK(thd);
|
||||
lock= mysql_lock_tables(thd, &tables->table, 1, 0, ¬_used);
|
||||
HANDLER_TABLES_HACK(thd);
|
||||
|
||||
if (!lock)
|
||||
goto err0; // mysql_lock_tables() printed error message already
|
||||
|
||||
/*
|
||||
In ::external_lock InnoDB resets the fields which tell it that
|
||||
the handle is used in the HANDLER interface. Tell it again that
|
||||
|
@ -2437,6 +2437,10 @@ select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
|
||||
/* First field to copy */
|
||||
field= table->field+table->s->fields - values.elements;
|
||||
|
||||
/* Mark all fields that are given values */
|
||||
for (Field **f= field ; *f ; f++)
|
||||
(*f)->query_id= thd->query_id;
|
||||
|
||||
/* Don't set timestamp if used */
|
||||
table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
|
||||
|
||||
|
@ -1185,6 +1185,7 @@ end_thread:
|
||||
or this thread has been schedule to handle the next query
|
||||
*/
|
||||
thd= current_thd;
|
||||
thd->thread_stack= (char*) &thd;
|
||||
} while (!(test_flags & TEST_NO_THREADS));
|
||||
/* The following is only executed if we are not using --one-thread */
|
||||
return(0); /* purecov: deadcode */
|
||||
@ -4853,7 +4854,6 @@ end_with_restore_list:
|
||||
if (thd->one_shot_set && lex->sql_command != SQLCOM_SET_OPTION)
|
||||
reset_one_shot_variables(thd);
|
||||
|
||||
|
||||
/*
|
||||
The return value for ROW_COUNT() is "implementation dependent" if the
|
||||
statement is not DELETE, INSERT or UPDATE, but -1 is what JDBC and ODBC
|
||||
@ -4865,13 +4865,10 @@ end_with_restore_list:
|
||||
if (lex->sql_command != SQLCOM_CALL && lex->sql_command != SQLCOM_EXECUTE &&
|
||||
uc_update_queries[lex->sql_command]<2)
|
||||
thd->row_count_func= -1;
|
||||
goto cleanup;
|
||||
DBUG_RETURN(res || thd->net.report_error);
|
||||
|
||||
error:
|
||||
res= 1;
|
||||
|
||||
cleanup:
|
||||
DBUG_RETURN(res || thd->net.report_error);
|
||||
DBUG_RETURN(1);
|
||||
}
|
||||
|
||||
|
||||
@ -5094,7 +5091,7 @@ check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
|
||||
the given table list refers to the list for prelocking (contains tables
|
||||
of other queries). For simple queries first_not_own_table is 0.
|
||||
*/
|
||||
for (; tables && tables != first_not_own_table; tables= tables->next_global)
|
||||
for (; tables != first_not_own_table; tables= tables->next_global)
|
||||
{
|
||||
if (tables->schema_table &&
|
||||
(want_access & ~(SELECT_ACL | EXTRA_ACL | FILE_ACL)))
|
||||
|
@ -10700,7 +10700,7 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
|
||||
item->save_org_in_field(group->field);
|
||||
/* Store in the used key if the field was 0 */
|
||||
if (item->maybe_null)
|
||||
group->buff[-1]=item->null_value ? 1 : 0;
|
||||
group->buff[-1]= (char) group->field->is_null();
|
||||
}
|
||||
if (!table->file->index_read(table->record[1],
|
||||
join->tmp_table_param.group_buff,0,
|
||||
|
@ -51,6 +51,13 @@ static File_option triggers_file_parameters[]=
|
||||
{ { 0, 0 }, 0, FILE_OPTIONS_STRING }
|
||||
};
|
||||
|
||||
File_option sql_modes_parameters=
|
||||
{
|
||||
{(char*) STRING_WITH_LEN("sql_modes") },
|
||||
offsetof(class Table_triggers_list, definition_modes_list),
|
||||
FILE_OPTIONS_ULLLIST
|
||||
};
|
||||
|
||||
/*
|
||||
This must be kept up to date whenever a new option is added to the list
|
||||
above, as it specifies the number of required parameters of the trigger in
|
||||
@ -779,7 +786,7 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db,
|
||||
sizeof(LEX_STRING))))
|
||||
DBUG_RETURN(1); // EOM
|
||||
|
||||
trg_definer->str= "";
|
||||
trg_definer->str= (char*) "";
|
||||
trg_definer->length= 0;
|
||||
|
||||
while (it++)
|
||||
@ -1171,7 +1178,7 @@ bool Table_triggers_list::process_triggers(THD *thd, trg_event_type event,
|
||||
|
||||
if (is_special_var_used(event, time_type))
|
||||
{
|
||||
TABLE_LIST table_list;
|
||||
TABLE_LIST table_list, **save_query_tables_own_last;
|
||||
bzero((char *) &table_list, sizeof (table_list));
|
||||
table_list.db= (char *) table->s->db;
|
||||
table_list.db_length= strlen(table_list.db);
|
||||
@ -1179,8 +1186,13 @@ bool Table_triggers_list::process_triggers(THD *thd, trg_event_type event,
|
||||
table_list.table_name_length= strlen(table_list.table_name);
|
||||
table_list.alias= (char *) table->alias;
|
||||
table_list.table= table;
|
||||
save_query_tables_own_last= thd->lex->query_tables_own_last;
|
||||
thd->lex->query_tables_own_last= 0;
|
||||
|
||||
if (check_table_access(thd, SELECT_ACL | UPDATE_ACL, &table_list, 0))
|
||||
err_status= check_table_access(thd, SELECT_ACL | UPDATE_ACL,
|
||||
&table_list, 0);
|
||||
thd->lex->query_tables_own_last= save_query_tables_own_last;
|
||||
if (err_status)
|
||||
{
|
||||
sp_restore_security_context(thd, save_ctx);
|
||||
return TRUE;
|
||||
@ -1222,32 +1234,29 @@ bool Table_triggers_list::process_triggers(THD *thd, trg_event_type event,
|
||||
TRUE Error
|
||||
*/
|
||||
|
||||
#define INVALID_SQL_MODES_LENGTH 13
|
||||
|
||||
bool
|
||||
Handle_old_incorrect_sql_modes_hook::process_unknown_string(char *&unknown_key,
|
||||
gptr base,
|
||||
MEM_ROOT *mem_root,
|
||||
char *end)
|
||||
{
|
||||
#define INVALID_SQL_MODES_LENGTH 13
|
||||
DBUG_ENTER("handle_old_incorrect_sql_modes");
|
||||
DBUG_PRINT("info", ("unknown key:%60s", unknown_key));
|
||||
|
||||
if (unknown_key + INVALID_SQL_MODES_LENGTH + 1 < end &&
|
||||
unknown_key[INVALID_SQL_MODES_LENGTH] == '=' &&
|
||||
!memcmp(unknown_key, STRING_WITH_LEN("sql_modes")))
|
||||
{
|
||||
char *ptr= unknown_key + INVALID_SQL_MODES_LENGTH + 1;
|
||||
|
||||
DBUG_PRINT("info", ("sql_modes affected by BUG#14090 detected"));
|
||||
push_warning_printf(current_thd,
|
||||
MYSQL_ERROR::WARN_LEVEL_NOTE,
|
||||
ER_OLD_FILE_FORMAT,
|
||||
ER(ER_OLD_FILE_FORMAT),
|
||||
(char *)path, "TRIGGER");
|
||||
File_option sql_modes_parameters=
|
||||
{
|
||||
{(char *) STRING_WITH_LEN("sql_modes") },
|
||||
offsetof(class Table_triggers_list, definition_modes_list),
|
||||
FILE_OPTIONS_ULLLIST
|
||||
};
|
||||
char *ptr= unknown_key + INVALID_SQL_MODES_LENGTH + 1;
|
||||
if (get_file_options_ulllist(ptr, end, unknown_key, base,
|
||||
&sql_modes_parameters, mem_root))
|
||||
{
|
||||
|
Loading…
x
Reference in New Issue
Block a user