mirror of
https://github.com/MariaDB/server.git
synced 2025-01-31 02:51:44 +01:00
Merge sanja.is.com.ua:/home/bell/mysql/bk/mysql-4.1
into sanja.is.com.ua:/home/bell/mysql/bk/work-4.1
This commit is contained in:
commit
6df58cc97e
67 changed files with 2988 additions and 411 deletions
|
@ -24,12 +24,14 @@ bar@bar.udmsearch.izhnet.ru
|
|||
bar@deer.(none)
|
||||
bar@gw.udmsearch.izhnet.ru
|
||||
bar@mysql.com
|
||||
bar@noter.intranet.mysql.r18.ru
|
||||
bell@laptop.sanja.is.com.ua
|
||||
bell@sanja.is.com.ua
|
||||
bk@admin.bk
|
||||
bk@mysql.r18.ru
|
||||
brian@avenger.(none)
|
||||
brian@brian-akers-computer.local
|
||||
brian@private-client-ip-101.oz.net
|
||||
carsten@tsort.bitbybit.dk
|
||||
davida@isil.mysql.com
|
||||
dlenev@brandersnatch.localdomain
|
||||
|
@ -102,6 +104,7 @@ miguel@light.local
|
|||
miguel@sartre.local
|
||||
mikron@c-fb0ae253.1238-1-64736c10.cust.bredbandsbolaget.se
|
||||
mikron@mikael-ronstr-ms-dator.local
|
||||
mleich@mysql.com
|
||||
mmatthew@markslaptop.
|
||||
monty@bitch.mysql.fi
|
||||
monty@butch.
|
||||
|
|
|
@ -4,7 +4,7 @@ dnl Process this file with autoconf to produce a configure script.
|
|||
AC_INIT(sql/mysqld.cc)
|
||||
AC_CANONICAL_SYSTEM
|
||||
# The Docs Makefile.am parses this line!
|
||||
AM_INIT_AUTOMAKE(mysql, 4.1.5-gamma)
|
||||
AM_INIT_AUTOMAKE(mysql, 4.1.6-gamma)
|
||||
AM_CONFIG_HEADER(config.h)
|
||||
|
||||
PROTOCOL_VERSION=10
|
||||
|
|
|
@ -47,6 +47,7 @@ my_bool _hash_init(HASH *hash, CHARSET_INFO *charset,
|
|||
uint key_length, hash_get_key get_key,
|
||||
void (*free_element)(void*), uint flags CALLER_INFO_PROTO);
|
||||
void hash_free(HASH *tree);
|
||||
void 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);
|
||||
|
@ -56,7 +57,6 @@ 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);
|
||||
my_bool hash_check(HASH *hash); /* Only in debug library */
|
||||
|
||||
#define hash_clear(H) bzero((char*) (H),sizeof(*(H)))
|
||||
#define hash_inited(H) ((H)->array.buffer != 0)
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
@ -184,7 +184,8 @@ typedef struct my_charset_handler_st
|
|||
int base, char **e, int *err);
|
||||
double (*strntod)(struct charset_info_st *, char *s, uint l, char **e,
|
||||
int *err);
|
||||
|
||||
longlong (*my_strtoll10)(struct charset_info_st *cs,
|
||||
const char *nptr, char **endptr, int *error);
|
||||
ulong (*scan)(struct charset_info_st *, const char *b, const char *e,
|
||||
int sq);
|
||||
} MY_CHARSET_HANDLER;
|
||||
|
@ -303,6 +304,11 @@ int my_long10_to_str_8bit(CHARSET_INFO *, char *to, uint l, int radix,
|
|||
int my_longlong10_to_str_8bit(CHARSET_INFO *, char *to, uint l, int radix,
|
||||
longlong val);
|
||||
|
||||
longlong my_strtoll10_8bit(CHARSET_INFO *cs,
|
||||
const char *nptr, char **endptr, int *error);
|
||||
longlong my_strtoll10_ucs2(CHARSET_INFO *cs,
|
||||
const char *nptr, char **endptr, int *error);
|
||||
|
||||
void my_fill_8bit(CHARSET_INFO *cs, char* to, uint l, int fill);
|
||||
|
||||
my_bool my_like_range_simple(CHARSET_INFO *cs,
|
||||
|
|
|
@ -725,7 +725,8 @@ extern void my_free_lock(byte *ptr,myf flags);
|
|||
#define my_free_lock(A,B) my_free((A),(B))
|
||||
#endif
|
||||
#define alloc_root_inited(A) ((A)->min_malloc != 0)
|
||||
#define clear_alloc_root(A) bzero((void *) (A), sizeof(MEM_ROOT))
|
||||
#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; } while(0)
|
||||
extern void init_alloc_root(MEM_ROOT *mem_root, uint block_size,
|
||||
uint pre_alloc_size);
|
||||
extern gptr alloc_root(MEM_ROOT *mem_root,unsigned int Size);
|
||||
|
|
|
@ -46,7 +46,7 @@ mystringsobjects = strmov.lo strxmov.lo strxnmov.lo strnmov.lo \
|
|||
ctype-win1250ch.lo ctype-utf8.lo ctype-extra.lo \
|
||||
ctype-ucs2.lo ctype-gb2312.lo ctype-gbk.lo \
|
||||
ctype-sjis.lo ctype-tis620.lo ctype-ujis.lo \
|
||||
ctype-uca.lo xml.lo
|
||||
ctype-uca.lo xml.lo my_strtoll10.lo
|
||||
|
||||
mystringsextra= strto.c
|
||||
dbugobjects = dbug.lo # IT IS IN SAFEMALLOC.C sanity.lo
|
||||
|
|
|
@ -42,6 +42,7 @@ my_bool handle_local_infile(MYSQL *mysql, const char *net_filename);
|
|||
|
||||
void mysql_read_default_options(struct st_mysql_options *options,
|
||||
const char *filename,const char *group);
|
||||
void mysql_detach_stmt_list(LIST **stmt_list);
|
||||
MYSQL * STDCALL
|
||||
cli_mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
|
||||
const char *passwd, const char *db,
|
||||
|
|
|
@ -662,6 +662,7 @@ my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
|
|||
const char *passwd, const char *db)
|
||||
{
|
||||
char buff[512],*end=buff;
|
||||
int rc;
|
||||
DBUG_ENTER("mysql_change_user");
|
||||
|
||||
if (!user)
|
||||
|
@ -695,18 +696,26 @@ my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
|
|||
/* Write authentication package */
|
||||
simple_command(mysql,COM_CHANGE_USER, buff,(ulong) (end-buff),1);
|
||||
|
||||
if ((*mysql->methods->read_change_user_result)(mysql, buff, passwd))
|
||||
DBUG_RETURN(1);
|
||||
/* Free old connect information */
|
||||
my_free(mysql->user,MYF(MY_ALLOW_ZERO_PTR));
|
||||
my_free(mysql->passwd,MYF(MY_ALLOW_ZERO_PTR));
|
||||
my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
|
||||
rc= (*mysql->methods->read_change_user_result)(mysql, buff, passwd);
|
||||
|
||||
/* alloc new connect information */
|
||||
mysql->user= my_strdup(user,MYF(MY_WME));
|
||||
mysql->passwd=my_strdup(passwd,MYF(MY_WME));
|
||||
mysql->db= db ? my_strdup(db,MYF(MY_WME)) : 0;
|
||||
DBUG_RETURN(0);
|
||||
/*
|
||||
The server will close all statements no matter was the attempt
|
||||
to change user successful or not.
|
||||
*/
|
||||
mysql_detach_stmt_list(&mysql->stmts);
|
||||
if (rc == 0)
|
||||
{
|
||||
/* Free old connect information */
|
||||
my_free(mysql->user,MYF(MY_ALLOW_ZERO_PTR));
|
||||
my_free(mysql->passwd,MYF(MY_ALLOW_ZERO_PTR));
|
||||
my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
|
||||
|
||||
/* alloc new connect information */
|
||||
mysql->user= my_strdup(user,MYF(MY_WME));
|
||||
mysql->passwd=my_strdup(passwd,MYF(MY_WME));
|
||||
mysql->db= db ? my_strdup(db,MYF(MY_WME)) : 0;
|
||||
}
|
||||
DBUG_RETURN(rc);
|
||||
}
|
||||
|
||||
#if defined(HAVE_GETPWUID) && defined(NO_GETPWUID_DECL)
|
||||
|
|
|
@ -505,7 +505,7 @@ double rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
|
|||
amax = korr_func(a+len); \
|
||||
bmax = korr_func(b+len); \
|
||||
a_area *= (((double)amax) - ((double)amin)); \
|
||||
*ab_area *= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
|
||||
loc_ab_area *= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
|
||||
}
|
||||
|
||||
#define RT_AREA_INC_GET(type, get_func, len)\
|
||||
|
@ -516,7 +516,7 @@ double rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
|
|||
get_func(amax, a+len); \
|
||||
get_func(bmax, b+len); \
|
||||
a_area *= (((double)amax) - ((double)amin)); \
|
||||
*ab_area *= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
|
||||
loc_ab_area *= ((double)max(amax, bmax) - (double)min(amin, bmin)); \
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -526,6 +526,7 @@ double rtree_area_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b,
|
|||
uint key_length, double *ab_area)
|
||||
{
|
||||
double a_area= 1.0;
|
||||
double loc_ab_area= 1.0;
|
||||
|
||||
*ab_area= 1.0;
|
||||
for (; (int)key_length > 0; keyseg += 2)
|
||||
|
@ -575,7 +576,7 @@ double rtree_area_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b,
|
|||
RT_AREA_INC_GET(double, mi_float8get, 8);
|
||||
break;
|
||||
case HA_KEYTYPE_END:
|
||||
return *ab_area - a_area;
|
||||
goto safe_end;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
|
@ -584,7 +585,9 @@ double rtree_area_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b,
|
|||
a+= keyseg_length;
|
||||
b+= keyseg_length;
|
||||
}
|
||||
return *ab_area - a_area;
|
||||
safe_end:
|
||||
*ab_area= loc_ab_area;
|
||||
return loc_ab_area - a_area;
|
||||
}
|
||||
|
||||
#define RT_PERIM_INC_KORR(type, korr_func, len) \
|
||||
|
|
|
@ -110,10 +110,10 @@ select a,b from t1 where a=@arg00;
|
|||
set @arg00=NULL;
|
||||
set @arg01=2;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
select a,b from t1;
|
||||
select a,b from t1 order by a;
|
||||
set @arg00=0;
|
||||
execute stmt1 using @arg01, @arg00;
|
||||
select a,b from t1;
|
||||
select a,b from t1 order by a;
|
||||
|
||||
## update with subquery and several parameters
|
||||
set @arg00=23;
|
||||
|
@ -134,7 +134,7 @@ prepare stmt1 from 'update t1 set a=? where b=?
|
|||
and a not in (select ? from t2
|
||||
where b = ? or a = ?)';
|
||||
execute stmt1 using @arg04, @arg01, @arg02, @arg03, @arg00 ;
|
||||
select a,b from t1 ;
|
||||
select a,b from t1 order by a;
|
||||
drop table t2 ;
|
||||
|
||||
## update with parameters in limit
|
||||
|
@ -202,7 +202,7 @@ set @arg01=1 ;
|
|||
prepare stmt1 from 'insert into t1 set a=?, b=''sechs''
|
||||
on duplicate key update a=a + ?, b=concat(b,''modified'') ';
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
select * from t1;
|
||||
select * from t1 order by a;
|
||||
set @arg00=81 ;
|
||||
set @arg01=1 ;
|
||||
--error 1062
|
||||
|
@ -221,17 +221,17 @@ set @updated="updated" ;
|
|||
insert into t1 values(1000,'x1000_1') ;
|
||||
insert into t1 values(@1000,@x1000_2),(@1000,@x1000_3)
|
||||
on duplicate key update a = a + @100, b = concat(b,@updated) ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
delete from t1 where a >= 1000 ;
|
||||
insert into t1 values(1000,'x1000_1') ;
|
||||
prepare stmt1 from ' insert into t1 values(?,?),(?,?)
|
||||
on duplicate key update a = a + ?, b = concat(b,?) ';
|
||||
execute stmt1 using @1000, @x1000_2, @1000, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
delete from t1 where a >= 1000 ;
|
||||
insert into t1 values(1000,'x1000_1') ;
|
||||
execute stmt1 using @1000, @x1000_2, @1100, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
delete from t1 where a >= 1000 ;
|
||||
|
||||
## replace
|
||||
|
|
|
@ -45,19 +45,19 @@
|
|||
set @duplicate='duplicate ' ;
|
||||
set @1000=1000 ;
|
||||
set @5=5 ;
|
||||
select a,b from t1 where a < 5 ;
|
||||
select a,b from t1 where a < 5 order by a ;
|
||||
--enable_info
|
||||
insert into t1 select a + @1000, concat(@duplicate,b) from t1
|
||||
where a < @5 ;
|
||||
--disable_info
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
delete from t1 where a >= 1000 ;
|
||||
prepare stmt1 from ' insert into t1 select a + ?, concat(?,b) from t1
|
||||
where a < ? ' ;
|
||||
--enable_info
|
||||
execute stmt1 using @1000, @duplicate, @5;
|
||||
--disable_info
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
delete from t1 where a >= 1000 ;
|
||||
|
||||
set @float=1.00;
|
||||
|
@ -78,7 +78,7 @@ select b, a + @100 from t1
|
|||
where (a,b) in ( select sqrt(a+@1)+CAST(@float AS signed),b
|
||||
from t1);
|
||||
--disable_info
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
delete from t2 ;
|
||||
prepare stmt1 from ' insert into t2 (b,a)
|
||||
select ?, sum(first.a)
|
||||
|
@ -93,5 +93,5 @@ select b, a + ? from t1
|
|||
--enable_info
|
||||
execute stmt1 using @duplicate, @5, @five, @2, @100, @1, @float ;
|
||||
--disable_info
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
drop table t2;
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -485,3 +485,99 @@ MBRContains(GeomFromText('Polygon((0 0, 0 7, 7 7, 7 0, 0 0))'), a);
|
|||
AsText(a)
|
||||
POINT(1 1)
|
||||
drop table t1;
|
||||
CREATE TABLE t1 (Coordinates POINT NOT NULL, SPATIAL INDEX(Coordinates));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(383293632 1754448)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(564952612 157516260)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(903994614 180726515)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(98128178 141127631)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(862547902 799334546)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(341989013 850270906)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(803302376 93039099)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(857439153 817431356)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(319757546 343162742)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(826341972 717484432)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(305066789 201736238)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(626068992 616241497)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(55789424 755830108)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(802874458 312435220)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(153795660 551723671)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(242207428 537089292)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(553478119 807160039)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(694605552 457472733)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(987886554 792733729)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(598600363 850434457)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(592068275 940589376)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(700705362 395370650)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(33628474 558144514)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(212802006 353386020)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(901307256 39143977)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(70870451 206374045)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(240880214 696939443)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(822615542 296669638)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(452769551 625489999)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(609104858 606565210)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(177213669 851312285)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(143654501 730691787)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(658472325 838260052)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(188164520 646358878)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(630993781 786764883)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(496793334 223062055)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(727354258 197498696)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(618432704 760982731)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(755643210 831234710)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(114368751 656950466)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(870378686 185239202)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(863324511 111258900)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(882178645 685940052)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(407928538 334948195)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(311430051 17033395)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(941513405 488643719)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(868345680 85167906)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(219335507 526818004)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(923427958 407500026)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(173176882 554421738)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(194264908 669970217)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(777483793 921619165)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(867468912 395916497)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(682601897 623112122)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(227151206 796970647)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(280062588 97529892)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(982209849 143387099)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(208788792 864388493)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(829327151 616717329)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(199336688 140757201)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(633750724 140850093)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(629400920 502096404)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(226017998 848736426)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(28914408 149445955)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(256236452 202091290)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(703867693 450501360)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(872061506 481351486)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(372120524 739530418)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(877267982 54722420)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(362642540 104419188)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(851693067 642705127)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(201949080 833902916)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(786092225 410737872)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(698291409 615419376)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(27455201 897628096)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(756176576 661205925)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(38478189 385577496)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(163302328 264496186)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(234313922 192216735)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(413942141 490550373)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(394308025 117809834)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(941051732 266369530)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(599161319 313172256)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(5899948 476429301)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(367894677 368542487)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(580848489 219587743)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(11247614 782797569)'));
|
||||
drop table t1;
|
||||
create table t1 select POINT(1,3);
|
||||
show create table t1;
|
||||
Table Create Table
|
||||
t1 CREATE TABLE `t1` (
|
||||
`POINT(1,3)` longblob NOT NULL
|
||||
) ENGINE=MyISAM DEFAULT CHARSET=latin1
|
||||
drop table t1;
|
||||
|
|
|
@ -420,6 +420,9 @@ INSERT INTO t1 VALUES
|
|||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
ERROR 23000: Duplicate entry '10' for key 1
|
||||
select count(*) from t1;
|
||||
count(*)
|
||||
2000
|
||||
begin;
|
||||
SELECT COUNT(*) FROM t1;
|
||||
COUNT(*)
|
||||
|
@ -429,17 +432,128 @@ INSERT INTO t1 VALUES
|
|||
SELECT COUNT(*) FROM t1;
|
||||
COUNT(*)
|
||||
2005
|
||||
rollback;
|
||||
begin;
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
ERROR 23000: Duplicate entry '10' for key 1
|
||||
SELECT COUNT(*) FROM t1;
|
||||
COUNT(*)
|
||||
2000
|
||||
commit;
|
||||
SELECT COUNT(*) FROM t1;
|
||||
COUNT(*)
|
||||
ERROR HY000: Got error 4350 'Transaction already aborted' from ndbcluster
|
||||
select * from t1 where pk1=1;
|
||||
pk1 b c
|
||||
1 1 1
|
||||
select * from t1 where pk1=10;
|
||||
pk1 b c
|
||||
10 10 10
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
count(*)
|
||||
11
|
||||
select count(*) from t1;
|
||||
count(*)
|
||||
2000
|
||||
begin;
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
ERROR 23000: Duplicate entry '10' for key 1
|
||||
rollback;
|
||||
select * from t1 where pk1=1;
|
||||
pk1 b c
|
||||
1 1 1
|
||||
select * from t1 where pk1=10;
|
||||
pk1 b c
|
||||
10 10 10
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
count(*)
|
||||
11
|
||||
select count(*) from t1;
|
||||
count(*)
|
||||
2000
|
||||
begin;
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
ERROR 23000: Duplicate entry '10' for key 1
|
||||
SELECT * FROM t1 WHERE pk1=10;
|
||||
ERROR HY000: Got error 4350 'Transaction already aborted' from ndbcluster
|
||||
rollback;
|
||||
select * from t1 where pk1=1;
|
||||
pk1 b c
|
||||
1 1 1
|
||||
select * from t1 where pk1=10;
|
||||
pk1 b c
|
||||
10 10 10
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
count(*)
|
||||
11
|
||||
select count(*) from t1;
|
||||
count(*)
|
||||
2000
|
||||
begin;
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
ERROR 23000: Duplicate entry '10' for key 1
|
||||
SELECT * FROM t1 WHERE pk1=10;
|
||||
ERROR HY000: Got error 4350 'Transaction already aborted' from ndbcluster
|
||||
SELECT * FROM t1 WHERE pk1=10;
|
||||
ERROR HY000: Got error 4350 'Transaction already aborted' from ndbcluster
|
||||
commit;
|
||||
ERROR HY000: Got error 4350 'Transaction already aborted' from ndbcluster
|
||||
select * from t1 where pk1=1;
|
||||
pk1 b c
|
||||
1 1 1
|
||||
select * from t1 where pk1=10;
|
||||
pk1 b c
|
||||
10 10 10
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
count(*)
|
||||
11
|
||||
select count(*) from t1;
|
||||
count(*)
|
||||
2000
|
||||
begin;
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
ERROR 23000: Duplicate entry '10' for key 1
|
||||
INSERT INTO t1 values (4000, 40, 44);
|
||||
ERROR HY000: Got error 4350 'Transaction already aborted' from ndbcluster
|
||||
rollback;
|
||||
select * from t1 where pk1=1;
|
||||
pk1 b c
|
||||
1 1 1
|
||||
select * from t1 where pk1=10;
|
||||
pk1 b c
|
||||
10 10 10
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
count(*)
|
||||
11
|
||||
select count(*) from t1;
|
||||
count(*)
|
||||
2000
|
||||
insert into t1 select * from t1 where b < 10 order by pk1;
|
||||
ERROR 23000: Duplicate entry '9' for key 1
|
||||
begin;
|
||||
INSERT IGNORE INTO t1 VALUES(1,2,3);
|
||||
ERROR HY000: Table storage engine for 't1' doesn't have this option
|
||||
commit;
|
||||
select * from t1 where pk1=1;
|
||||
pk1 b c
|
||||
1 1 1
|
||||
INSERT IGNORE INTO t1 VALUES(1,2,3);
|
||||
ERROR HY000: Table storage engine for 't1' doesn't have this option
|
||||
select * from t1 where pk1=1;
|
||||
pk1 b c
|
||||
1 1 1
|
||||
REPLACE INTO t1 values(1, 2, 3);
|
||||
select * from t1 where pk1=1;
|
||||
pk1 b c
|
||||
1 2 3
|
||||
INSERT INTO t1 VALUES(1,1,1) ON DUPLICATE KEY UPDATE b=79;
|
||||
ERROR HY000: Table storage engine for 't1' doesn't have this option
|
||||
select * from t1 where pk1=1;
|
||||
pk1 b c
|
||||
1 2 3
|
||||
DROP TABLE t1;
|
||||
|
|
|
@ -270,3 +270,30 @@ execute stmt using @var;
|
|||
a
|
||||
deallocate prepare stmt;
|
||||
drop table t1;
|
||||
create table t1 (a bigint(20) not null primary key auto_increment);
|
||||
insert into t1 (a) values (null);
|
||||
select * from t1;
|
||||
a
|
||||
1
|
||||
prepare stmt from "insert into t1 (a) values (?)";
|
||||
set @var=null;
|
||||
execute stmt using @var;
|
||||
select * from t1;
|
||||
a
|
||||
1
|
||||
2
|
||||
drop table t1;
|
||||
create table t1 (a timestamp not null);
|
||||
prepare stmt from "insert into t1 (a) values (?)";
|
||||
execute stmt using @var;
|
||||
select * from t1;
|
||||
deallocate prepare stmt;
|
||||
drop table t1;
|
||||
prepare stmt from "select 'abc' like convert('abc' using utf8)";
|
||||
execute stmt;
|
||||
'abc' like convert('abc' using utf8)
|
||||
1
|
||||
execute stmt;
|
||||
'abc' like convert('abc' using utf8)
|
||||
1
|
||||
deallocate prepare stmt;
|
||||
|
|
|
@ -1015,16 +1015,16 @@ set @arg00=NULL;
|
|||
set @arg01=2;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
Warnings:
|
||||
Warning 1265 Data truncated for column 'a' at row 1
|
||||
select a,b from t1;
|
||||
Warning 1263 Data truncated; NULL supplied to NOT NULL column 'a' at row 1
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
0 two
|
||||
1 one
|
||||
3 three
|
||||
4 four
|
||||
set @arg00=0;
|
||||
execute stmt1 using @arg01, @arg00;
|
||||
select a,b from t1;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
2 two
|
||||
|
@ -1048,7 +1048,7 @@ prepare stmt1 from 'update t1 set a=? where b=?
|
|||
and a not in (select ? from t2
|
||||
where b = ? or a = ?)';
|
||||
execute stmt1 using @arg04, @arg01, @arg02, @arg03, @arg00 ;
|
||||
select a,b from t1 ;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
2 two
|
||||
|
@ -1142,19 +1142,19 @@ set @arg01=1 ;
|
|||
prepare stmt1 from 'insert into t1 set a=?, b=''sechs''
|
||||
on duplicate key update a=a + ?, b=concat(b,''modified'') ';
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
select * from t1;
|
||||
select * from t1 order by a;
|
||||
a b
|
||||
0 NULL
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
5 five
|
||||
7 sixmodified
|
||||
0 NULL
|
||||
8 eight
|
||||
9 nine
|
||||
81 8-1
|
||||
82 8-2
|
||||
9 nine
|
||||
set @arg00=81 ;
|
||||
set @arg01=1 ;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
|
@ -1170,7 +1170,7 @@ set @updated="updated" ;
|
|||
insert into t1 values(1000,'x1000_1') ;
|
||||
insert into t1 values(@1000,@x1000_2),(@1000,@x1000_3)
|
||||
on duplicate key update a = a + @100, b = concat(b,@updated) ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
|
@ -1179,14 +1179,14 @@ insert into t1 values(1000,'x1000_1') ;
|
|||
prepare stmt1 from ' insert into t1 values(?,?),(?,?)
|
||||
on duplicate key update a = a + ?, b = concat(b,?) ';
|
||||
execute stmt1 using @1000, @x1000_2, @1000, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
delete from t1 where a >= 1000 ;
|
||||
insert into t1 values(1000,'x1000_1') ;
|
||||
execute stmt1 using @1000, @x1000_2, @1100, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1200 x1000_1updatedupdated
|
||||
delete from t1 where a >= 1000 ;
|
||||
|
@ -1195,37 +1195,37 @@ ERROR HY000: This command is not supported in the prepared statement protocol ye
|
|||
set @duplicate='duplicate ' ;
|
||||
set @1000=1000 ;
|
||||
set @5=5 ;
|
||||
select a,b from t1 where a < 5 ;
|
||||
select a,b from t1 where a < 5 order by a ;
|
||||
a b
|
||||
0 NULL
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
0 NULL
|
||||
insert into t1 select a + @1000, concat(@duplicate,b) from t1
|
||||
where a < @5 ;
|
||||
affected rows: 5
|
||||
info: Records: 5 Duplicates: 0 Warnings: 0
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 NULL
|
||||
1001 duplicate one
|
||||
1002 duplicate two
|
||||
1003 duplicate three
|
||||
1004 duplicate four
|
||||
1000 NULL
|
||||
delete from t1 where a >= 1000 ;
|
||||
prepare stmt1 from ' insert into t1 select a + ?, concat(?,b) from t1
|
||||
where a < ? ' ;
|
||||
execute stmt1 using @1000, @duplicate, @5;
|
||||
affected rows: 5
|
||||
info: Records: 5 Duplicates: 0 Warnings: 0
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1004 duplicate four
|
||||
1003 duplicate three
|
||||
1002 duplicate two
|
||||
1001 duplicate one
|
||||
1000 NULL
|
||||
1001 duplicate one
|
||||
1002 duplicate two
|
||||
1003 duplicate three
|
||||
1004 duplicate four
|
||||
delete from t1 where a >= 1000 ;
|
||||
set @float=1.00;
|
||||
set @five='five' ;
|
||||
|
@ -1243,15 +1243,15 @@ where (a,b) in ( select sqrt(a+@1)+CAST(@float AS signed),b
|
|||
from t1);
|
||||
affected rows: 8
|
||||
info: Records: 8 Duplicates: 0 Warnings: 0
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
a b
|
||||
3 duplicate
|
||||
4 duplicate
|
||||
7 duplicate
|
||||
8 duplicate
|
||||
9 duplicate
|
||||
81 duplicate
|
||||
82 duplicate
|
||||
8 duplicate
|
||||
4 duplicate
|
||||
9 duplicate
|
||||
7 duplicate
|
||||
3 duplicate
|
||||
103 three
|
||||
delete from t2 ;
|
||||
prepare stmt1 from ' insert into t2 (b,a)
|
||||
|
@ -1267,15 +1267,15 @@ select b, a + ? from t1
|
|||
execute stmt1 using @duplicate, @5, @five, @2, @100, @1, @float ;
|
||||
affected rows: 8
|
||||
info: Records: 8 Duplicates: 0 Warnings: 0
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
a b
|
||||
3 duplicate
|
||||
4 duplicate
|
||||
7 duplicate
|
||||
8 duplicate
|
||||
9 duplicate
|
||||
81 duplicate
|
||||
82 duplicate
|
||||
8 duplicate
|
||||
4 duplicate
|
||||
9 duplicate
|
||||
7 duplicate
|
||||
3 duplicate
|
||||
103 three
|
||||
drop table t2;
|
||||
drop table t1, t_many_col_types;
|
||||
|
|
|
@ -1015,8 +1015,8 @@ set @arg00=NULL;
|
|||
set @arg01=2;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
Warnings:
|
||||
Warning 1265 Data truncated for column 'a' at row 1
|
||||
select a,b from t1;
|
||||
Warning 1263 Data truncated; NULL supplied to NOT NULL column 'a' at row 1
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
0 two
|
||||
1 one
|
||||
|
@ -1024,7 +1024,7 @@ a b
|
|||
4 four
|
||||
set @arg00=0;
|
||||
execute stmt1 using @arg01, @arg00;
|
||||
select a,b from t1;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
2 two
|
||||
|
@ -1048,7 +1048,7 @@ prepare stmt1 from 'update t1 set a=? where b=?
|
|||
and a not in (select ? from t2
|
||||
where b = ? or a = ?)';
|
||||
execute stmt1 using @arg04, @arg01, @arg02, @arg03, @arg00 ;
|
||||
select a,b from t1 ;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
2 two
|
||||
|
@ -1142,7 +1142,7 @@ set @arg01=1 ;
|
|||
prepare stmt1 from 'insert into t1 set a=?, b=''sechs''
|
||||
on duplicate key update a=a + ?, b=concat(b,''modified'') ';
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
select * from t1;
|
||||
select * from t1 order by a;
|
||||
a b
|
||||
0 NULL
|
||||
1 one
|
||||
|
@ -1170,7 +1170,7 @@ set @updated="updated" ;
|
|||
insert into t1 values(1000,'x1000_1') ;
|
||||
insert into t1 values(@1000,@x1000_2),(@1000,@x1000_3)
|
||||
on duplicate key update a = a + @100, b = concat(b,@updated) ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
|
@ -1179,14 +1179,14 @@ insert into t1 values(1000,'x1000_1') ;
|
|||
prepare stmt1 from ' insert into t1 values(?,?),(?,?)
|
||||
on duplicate key update a = a + ?, b = concat(b,?) ';
|
||||
execute stmt1 using @1000, @x1000_2, @1000, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
delete from t1 where a >= 1000 ;
|
||||
insert into t1 values(1000,'x1000_1') ;
|
||||
execute stmt1 using @1000, @x1000_2, @1100, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1200 x1000_1updatedupdated
|
||||
delete from t1 where a >= 1000 ;
|
||||
|
@ -1195,7 +1195,7 @@ ERROR HY000: This command is not supported in the prepared statement protocol ye
|
|||
set @duplicate='duplicate ' ;
|
||||
set @1000=1000 ;
|
||||
set @5=5 ;
|
||||
select a,b from t1 where a < 5 ;
|
||||
select a,b from t1 where a < 5 order by a ;
|
||||
a b
|
||||
0 NULL
|
||||
1 one
|
||||
|
@ -1206,7 +1206,7 @@ insert into t1 select a + @1000, concat(@duplicate,b) from t1
|
|||
where a < @5 ;
|
||||
affected rows: 5
|
||||
info: Records: 5 Duplicates: 0 Warnings: 0
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 NULL
|
||||
1001 duplicate one
|
||||
|
@ -1219,7 +1219,7 @@ where a < ? ' ;
|
|||
execute stmt1 using @1000, @duplicate, @5;
|
||||
affected rows: 5
|
||||
info: Records: 5 Duplicates: 0 Warnings: 0
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 NULL
|
||||
1001 duplicate one
|
||||
|
@ -1243,7 +1243,7 @@ where (a,b) in ( select sqrt(a+@1)+CAST(@float AS signed),b
|
|||
from t1);
|
||||
affected rows: 8
|
||||
info: Records: 8 Duplicates: 0 Warnings: 0
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
a b
|
||||
3 duplicate
|
||||
4 duplicate
|
||||
|
@ -1267,7 +1267,7 @@ select b, a + ? from t1
|
|||
execute stmt1 using @duplicate, @5, @five, @2, @100, @1, @float ;
|
||||
affected rows: 8
|
||||
info: Records: 8 Duplicates: 0 Warnings: 0
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
a b
|
||||
3 duplicate
|
||||
4 duplicate
|
||||
|
|
|
@ -1016,16 +1016,16 @@ set @arg00=NULL;
|
|||
set @arg01=2;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
Warnings:
|
||||
Warning 1265 Data truncated for column 'a' at row 1
|
||||
select a,b from t1;
|
||||
Warning 1263 Data truncated; NULL supplied to NOT NULL column 'a' at row 1
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
0 two
|
||||
1 one
|
||||
3 three
|
||||
4 four
|
||||
set @arg00=0;
|
||||
execute stmt1 using @arg01, @arg00;
|
||||
select a,b from t1;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
2 two
|
||||
|
@ -1049,7 +1049,7 @@ prepare stmt1 from 'update t1 set a=? where b=?
|
|||
and a not in (select ? from t2
|
||||
where b = ? or a = ?)';
|
||||
execute stmt1 using @arg04, @arg01, @arg02, @arg03, @arg00 ;
|
||||
select a,b from t1 ;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
2 two
|
||||
|
@ -1143,19 +1143,19 @@ set @arg01=1 ;
|
|||
prepare stmt1 from 'insert into t1 set a=?, b=''sechs''
|
||||
on duplicate key update a=a + ?, b=concat(b,''modified'') ';
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
select * from t1;
|
||||
select * from t1 order by a;
|
||||
a b
|
||||
0 NULL
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
5 five
|
||||
7 sixmodified
|
||||
0 NULL
|
||||
8 eight
|
||||
9 nine
|
||||
81 8-1
|
||||
82 8-2
|
||||
9 nine
|
||||
set @arg00=81 ;
|
||||
set @arg01=1 ;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
|
@ -1171,23 +1171,23 @@ set @updated="updated" ;
|
|||
insert into t1 values(1000,'x1000_1') ;
|
||||
insert into t1 values(@1000,@x1000_2),(@1000,@x1000_3)
|
||||
on duplicate key update a = a + @100, b = concat(b,@updated) ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1100 x1000_1updated
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
delete from t1 where a >= 1000 ;
|
||||
insert into t1 values(1000,'x1000_1') ;
|
||||
prepare stmt1 from ' insert into t1 values(?,?),(?,?)
|
||||
on duplicate key update a = a + ?, b = concat(b,?) ';
|
||||
execute stmt1 using @1000, @x1000_2, @1000, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
delete from t1 where a >= 1000 ;
|
||||
insert into t1 values(1000,'x1000_1') ;
|
||||
execute stmt1 using @1000, @x1000_2, @1100, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1200 x1000_1updatedupdated
|
||||
delete from t1 where a >= 1000 ;
|
||||
|
@ -1196,37 +1196,37 @@ ERROR HY000: This command is not supported in the prepared statement protocol ye
|
|||
set @duplicate='duplicate ' ;
|
||||
set @1000=1000 ;
|
||||
set @5=5 ;
|
||||
select a,b from t1 where a < 5 ;
|
||||
select a,b from t1 where a < 5 order by a ;
|
||||
a b
|
||||
0 NULL
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
0 NULL
|
||||
insert into t1 select a + @1000, concat(@duplicate,b) from t1
|
||||
where a < @5 ;
|
||||
affected rows: 5
|
||||
info: Records: 5 Duplicates: 0 Warnings: 0
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1002 duplicate two
|
||||
1000 NULL
|
||||
1001 duplicate one
|
||||
1002 duplicate two
|
||||
1003 duplicate three
|
||||
1004 duplicate four
|
||||
1000 NULL
|
||||
delete from t1 where a >= 1000 ;
|
||||
prepare stmt1 from ' insert into t1 select a + ?, concat(?,b) from t1
|
||||
where a < ? ' ;
|
||||
execute stmt1 using @1000, @duplicate, @5;
|
||||
affected rows: 5
|
||||
info: Records: 5 Duplicates: 0 Warnings: 0
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 NULL
|
||||
1004 duplicate four
|
||||
1003 duplicate three
|
||||
1002 duplicate two
|
||||
1001 duplicate one
|
||||
1002 duplicate two
|
||||
1003 duplicate three
|
||||
1004 duplicate four
|
||||
delete from t1 where a >= 1000 ;
|
||||
set @float=1.00;
|
||||
set @five='five' ;
|
||||
|
@ -1244,15 +1244,15 @@ where (a,b) in ( select sqrt(a+@1)+CAST(@float AS signed),b
|
|||
from t1);
|
||||
affected rows: 8
|
||||
info: Records: 8 Duplicates: 0 Warnings: 0
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
a b
|
||||
3 duplicate
|
||||
4 duplicate
|
||||
7 duplicate
|
||||
8 duplicate
|
||||
9 duplicate
|
||||
81 duplicate
|
||||
82 duplicate
|
||||
8 duplicate
|
||||
4 duplicate
|
||||
9 duplicate
|
||||
7 duplicate
|
||||
3 duplicate
|
||||
103 three
|
||||
delete from t2 ;
|
||||
prepare stmt1 from ' insert into t2 (b,a)
|
||||
|
@ -1268,15 +1268,15 @@ select b, a + ? from t1
|
|||
execute stmt1 using @duplicate, @5, @five, @2, @100, @1, @float ;
|
||||
affected rows: 8
|
||||
info: Records: 8 Duplicates: 0 Warnings: 0
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
a b
|
||||
3 duplicate
|
||||
4 duplicate
|
||||
7 duplicate
|
||||
8 duplicate
|
||||
9 duplicate
|
||||
81 duplicate
|
||||
82 duplicate
|
||||
8 duplicate
|
||||
4 duplicate
|
||||
9 duplicate
|
||||
7 duplicate
|
||||
3 duplicate
|
||||
103 three
|
||||
drop table t2;
|
||||
drop table t1, t_many_col_types;
|
||||
|
|
|
@ -1058,20 +1058,20 @@ set @arg00=NULL;
|
|||
set @arg01=2;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
Warnings:
|
||||
Warning 1265 Data truncated for column 'a' at row 1
|
||||
select a,b from t1;
|
||||
Warning 1263 Data truncated; NULL supplied to NOT NULL column 'a' at row 1
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
3 three
|
||||
0 two
|
||||
1 one
|
||||
3 three
|
||||
4 four
|
||||
set @arg00=0;
|
||||
execute stmt1 using @arg01, @arg00;
|
||||
select a,b from t1;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
3 three
|
||||
2 two
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
set @arg00=23;
|
||||
set @arg01='two';
|
||||
|
@ -1091,11 +1091,11 @@ prepare stmt1 from 'update t1 set a=? where b=?
|
|||
and a not in (select ? from t2
|
||||
where b = ? or a = ?)';
|
||||
execute stmt1 using @arg04, @arg01, @arg02, @arg03, @arg00 ;
|
||||
select a,b from t1 ;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
3 three
|
||||
2 two
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
drop table t2 ;
|
||||
set @arg00=1;
|
||||
|
@ -1185,19 +1185,19 @@ set @arg01=1 ;
|
|||
prepare stmt1 from 'insert into t1 set a=?, b=''sechs''
|
||||
on duplicate key update a=a + ?, b=concat(b,''modified'') ';
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
select * from t1;
|
||||
select * from t1 order by a;
|
||||
a b
|
||||
4 four
|
||||
3 three
|
||||
2 two
|
||||
0 NULL
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
5 five
|
||||
7 sixmodified
|
||||
0 NULL
|
||||
8 eight
|
||||
9 nine
|
||||
81 8-1
|
||||
82 8-2
|
||||
9 nine
|
||||
set @arg00=81 ;
|
||||
set @arg01=1 ;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
|
@ -1213,7 +1213,7 @@ set @updated="updated" ;
|
|||
insert into t1 values(1000,'x1000_1') ;
|
||||
insert into t1 values(@1000,@x1000_2),(@1000,@x1000_3)
|
||||
on duplicate key update a = a + @100, b = concat(b,@updated) ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
|
@ -1222,14 +1222,14 @@ insert into t1 values(1000,'x1000_1') ;
|
|||
prepare stmt1 from ' insert into t1 values(?,?),(?,?)
|
||||
on duplicate key update a = a + ?, b = concat(b,?) ';
|
||||
execute stmt1 using @1000, @x1000_2, @1000, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
delete from t1 where a >= 1000 ;
|
||||
insert into t1 values(1000,'x1000_1') ;
|
||||
execute stmt1 using @1000, @x1000_2, @1100, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1200 x1000_1updatedupdated
|
||||
delete from t1 where a >= 1000 ;
|
||||
|
@ -2253,20 +2253,20 @@ set @arg00=NULL;
|
|||
set @arg01=2;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
Warnings:
|
||||
Warning 1265 Data truncated for column 'a' at row 1
|
||||
select a,b from t1;
|
||||
Warning 1263 Data truncated; NULL supplied to NOT NULL column 'a' at row 1
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
3 three
|
||||
0 two
|
||||
1 one
|
||||
3 three
|
||||
4 four
|
||||
set @arg00=0;
|
||||
execute stmt1 using @arg01, @arg00;
|
||||
select a,b from t1;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
3 three
|
||||
2 two
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
set @arg00=23;
|
||||
set @arg01='two';
|
||||
|
@ -2286,11 +2286,11 @@ prepare stmt1 from 'update t1 set a=? where b=?
|
|||
and a not in (select ? from t2
|
||||
where b = ? or a = ?)';
|
||||
execute stmt1 using @arg04, @arg01, @arg02, @arg03, @arg00 ;
|
||||
select a,b from t1 ;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
3 three
|
||||
2 two
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
drop table t2 ;
|
||||
set @arg00=1;
|
||||
|
@ -2380,19 +2380,19 @@ set @arg01=1 ;
|
|||
prepare stmt1 from 'insert into t1 set a=?, b=''sechs''
|
||||
on duplicate key update a=a + ?, b=concat(b,''modified'') ';
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
select * from t1;
|
||||
select * from t1 order by a;
|
||||
a b
|
||||
4 four
|
||||
3 three
|
||||
2 two
|
||||
0 NULL
|
||||
1 one
|
||||
2 two
|
||||
3 three
|
||||
4 four
|
||||
5 five
|
||||
7 sixmodified
|
||||
0 NULL
|
||||
8 eight
|
||||
9 nine
|
||||
81 8-1
|
||||
82 8-2
|
||||
9 nine
|
||||
set @arg00=81 ;
|
||||
set @arg01=1 ;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
|
@ -2408,7 +2408,7 @@ set @updated="updated" ;
|
|||
insert into t1 values(1000,'x1000_1') ;
|
||||
insert into t1 values(@1000,@x1000_2),(@1000,@x1000_3)
|
||||
on duplicate key update a = a + @100, b = concat(b,@updated) ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
|
@ -2417,14 +2417,14 @@ insert into t1 values(1000,'x1000_1') ;
|
|||
prepare stmt1 from ' insert into t1 values(?,?),(?,?)
|
||||
on duplicate key update a = a + ?, b = concat(b,?) ';
|
||||
execute stmt1 using @1000, @x1000_2, @1000, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
delete from t1 where a >= 1000 ;
|
||||
insert into t1 values(1000,'x1000_1') ;
|
||||
execute stmt1 using @1000, @x1000_2, @1100, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1200 x1000_1updatedupdated
|
||||
delete from t1 where a >= 1000 ;
|
||||
|
|
|
@ -1015,8 +1015,8 @@ set @arg00=NULL;
|
|||
set @arg01=2;
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
Warnings:
|
||||
Warning 1265 Data truncated for column 'a' at row 1
|
||||
select a,b from t1;
|
||||
Warning 1263 Data truncated; NULL supplied to NOT NULL column 'a' at row 1
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
0 two
|
||||
1 one
|
||||
|
@ -1024,7 +1024,7 @@ a b
|
|||
4 four
|
||||
set @arg00=0;
|
||||
execute stmt1 using @arg01, @arg00;
|
||||
select a,b from t1;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
2 two
|
||||
|
@ -1048,7 +1048,7 @@ prepare stmt1 from 'update t1 set a=? where b=?
|
|||
and a not in (select ? from t2
|
||||
where b = ? or a = ?)';
|
||||
execute stmt1 using @arg04, @arg01, @arg02, @arg03, @arg00 ;
|
||||
select a,b from t1 ;
|
||||
select a,b from t1 order by a;
|
||||
a b
|
||||
1 one
|
||||
2 two
|
||||
|
@ -1142,7 +1142,7 @@ set @arg01=1 ;
|
|||
prepare stmt1 from 'insert into t1 set a=?, b=''sechs''
|
||||
on duplicate key update a=a + ?, b=concat(b,''modified'') ';
|
||||
execute stmt1 using @arg00, @arg01;
|
||||
select * from t1;
|
||||
select * from t1 order by a;
|
||||
a b
|
||||
0 NULL
|
||||
1 one
|
||||
|
@ -1170,7 +1170,7 @@ set @updated="updated" ;
|
|||
insert into t1 values(1000,'x1000_1') ;
|
||||
insert into t1 values(@1000,@x1000_2),(@1000,@x1000_3)
|
||||
on duplicate key update a = a + @100, b = concat(b,@updated) ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
|
@ -1179,14 +1179,14 @@ insert into t1 values(1000,'x1000_1') ;
|
|||
prepare stmt1 from ' insert into t1 values(?,?),(?,?)
|
||||
on duplicate key update a = a + ?, b = concat(b,?) ';
|
||||
execute stmt1 using @1000, @x1000_2, @1000, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 x1000_3
|
||||
1100 x1000_1updated
|
||||
delete from t1 where a >= 1000 ;
|
||||
insert into t1 values(1000,'x1000_1') ;
|
||||
execute stmt1 using @1000, @x1000_2, @1100, @x1000_3, @100, @updated ;
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1200 x1000_1updatedupdated
|
||||
delete from t1 where a >= 1000 ;
|
||||
|
@ -1195,7 +1195,7 @@ ERROR HY000: This command is not supported in the prepared statement protocol ye
|
|||
set @duplicate='duplicate ' ;
|
||||
set @1000=1000 ;
|
||||
set @5=5 ;
|
||||
select a,b from t1 where a < 5 ;
|
||||
select a,b from t1 where a < 5 order by a ;
|
||||
a b
|
||||
0 NULL
|
||||
1 one
|
||||
|
@ -1206,7 +1206,7 @@ insert into t1 select a + @1000, concat(@duplicate,b) from t1
|
|||
where a < @5 ;
|
||||
affected rows: 5
|
||||
info: Records: 5 Duplicates: 0 Warnings: 0
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 NULL
|
||||
1001 duplicate one
|
||||
|
@ -1219,7 +1219,7 @@ where a < ? ' ;
|
|||
execute stmt1 using @1000, @duplicate, @5;
|
||||
affected rows: 5
|
||||
info: Records: 5 Duplicates: 0 Warnings: 0
|
||||
select a,b from t1 where a >= 1000 ;
|
||||
select a,b from t1 where a >= 1000 order by a ;
|
||||
a b
|
||||
1000 NULL
|
||||
1001 duplicate one
|
||||
|
@ -1243,7 +1243,7 @@ where (a,b) in ( select sqrt(a+@1)+CAST(@float AS signed),b
|
|||
from t1);
|
||||
affected rows: 8
|
||||
info: Records: 8 Duplicates: 0 Warnings: 0
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
a b
|
||||
3 duplicate
|
||||
4 duplicate
|
||||
|
@ -1267,7 +1267,7 @@ select b, a + ? from t1
|
|||
execute stmt1 using @duplicate, @5, @five, @2, @100, @1, @float ;
|
||||
affected rows: 8
|
||||
info: Records: 8 Duplicates: 0 Warnings: 0
|
||||
select a,b from t2;
|
||||
select a,b from t2 order by a ;
|
||||
a b
|
||||
3 duplicate
|
||||
4 duplicate
|
||||
|
|
|
@ -198,4 +198,12 @@ CDF32C20E7E020F0FBE1E0EBEAF3 CDF32C20E7E020F0FBE1E0EBEAF3
|
|||
select hex(c1), hex(c2) from t1;
|
||||
hex(c1) hex(c2)
|
||||
CDF32C20E7E020F0FBE1E0EBEAF3 CDF32C20E7E020F0FBE1E0EBEAF3
|
||||
stop slave;
|
||||
delete from t1;
|
||||
change master to master_log_pos=5801;
|
||||
start slave until master_log_file='master-bin.000001', master_log_pos=5937;
|
||||
start slave;
|
||||
select hex(c1), hex(c2) from t1;
|
||||
hex(c1) hex(c2)
|
||||
CDF32C20E7E020F0FBE1E0EBEAF3 CDF32C20E7E020F0FBE1E0EBEAF3
|
||||
drop table t1;
|
||||
|
|
|
@ -1661,3 +1661,19 @@ t1 CREATE TABLE `t1` (
|
|||
`a` enum('ä','1','2') NOT NULL default 'ä'
|
||||
) ENGINE=MyISAM DEFAULT CHARSET=latin1
|
||||
drop table t1;
|
||||
set names latin1;
|
||||
CREATE TABLE t1 (
|
||||
a INT default 1,
|
||||
b ENUM('value','öäü_value','ÊÃÕ') character set latin1 NOT NULL
|
||||
);
|
||||
show create table t1;
|
||||
Table Create Table
|
||||
t1 CREATE TABLE `t1` (
|
||||
`a` int(11) default '1',
|
||||
`b` enum('value','öäü_value','ÊÃÕ') NOT NULL default 'value'
|
||||
) ENGINE=MyISAM DEFAULT CHARSET=latin1
|
||||
show columns from t1;
|
||||
Field Type Null Key Default Extra
|
||||
a int(11) YES 1
|
||||
b enum('value','öäü_value','ÊÃÕ') value
|
||||
drop table t1;
|
||||
|
|
|
@ -1297,4 +1297,6 @@ INSERT INTO t2 VALUES (2,011401,37,'breaking','dreaded','Steinberg','W');
|
|||
INSERT INTO t2 VALUES (3,011402,37,'Romans','scholastics','jarring','');
|
||||
INSERT INTO t2 VALUES (4,011403,37,'intercepted','audiology','tinily','');
|
||||
SELECT * FROM t2;
|
||||
OPTIMIZE TABLE t2;
|
||||
SELECT * FROM t2;
|
||||
drop table t1, t2;
|
||||
|
|
|
@ -190,3 +190,97 @@ select AsText(a) from t1 where
|
|||
and
|
||||
MBRContains(GeomFromText('Polygon((0 0, 0 7, 7 7, 7 0, 0 0))'), a);
|
||||
drop table t1;
|
||||
|
||||
CREATE TABLE t1 (Coordinates POINT NOT NULL, SPATIAL INDEX(Coordinates));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(383293632 1754448)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(564952612 157516260)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(903994614 180726515)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(98128178 141127631)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(862547902 799334546)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(341989013 850270906)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(803302376 93039099)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(857439153 817431356)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(319757546 343162742)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(826341972 717484432)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(305066789 201736238)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(626068992 616241497)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(55789424 755830108)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(802874458 312435220)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(153795660 551723671)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(242207428 537089292)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(553478119 807160039)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(694605552 457472733)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(987886554 792733729)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(598600363 850434457)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(592068275 940589376)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(700705362 395370650)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(33628474 558144514)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(212802006 353386020)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(901307256 39143977)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(70870451 206374045)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(240880214 696939443)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(822615542 296669638)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(452769551 625489999)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(609104858 606565210)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(177213669 851312285)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(143654501 730691787)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(658472325 838260052)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(188164520 646358878)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(630993781 786764883)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(496793334 223062055)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(727354258 197498696)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(618432704 760982731)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(755643210 831234710)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(114368751 656950466)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(870378686 185239202)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(863324511 111258900)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(882178645 685940052)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(407928538 334948195)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(311430051 17033395)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(941513405 488643719)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(868345680 85167906)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(219335507 526818004)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(923427958 407500026)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(173176882 554421738)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(194264908 669970217)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(777483793 921619165)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(867468912 395916497)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(682601897 623112122)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(227151206 796970647)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(280062588 97529892)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(982209849 143387099)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(208788792 864388493)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(829327151 616717329)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(199336688 140757201)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(633750724 140850093)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(629400920 502096404)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(226017998 848736426)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(28914408 149445955)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(256236452 202091290)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(703867693 450501360)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(872061506 481351486)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(372120524 739530418)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(877267982 54722420)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(362642540 104419188)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(851693067 642705127)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(201949080 833902916)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(786092225 410737872)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(698291409 615419376)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(27455201 897628096)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(756176576 661205925)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(38478189 385577496)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(163302328 264496186)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(234313922 192216735)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(413942141 490550373)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(394308025 117809834)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(941051732 266369530)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(599161319 313172256)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(5899948 476429301)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(367894677 368542487)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(580848489 219587743)'));
|
||||
INSERT INTO t1 VALUES(GeomFromText('POINT(11247614 782797569)'));
|
||||
drop table t1;
|
||||
|
||||
create table t1 select POINT(1,3);
|
||||
show create table t1;
|
||||
drop table t1;
|
||||
|
|
|
@ -437,26 +437,125 @@ INSERT INTO t1 VALUES
|
|||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
|
||||
select count(*) from t1;
|
||||
|
||||
|
||||
#
|
||||
# Test that select count(*) can see inserts made in the same transaction
|
||||
#
|
||||
begin;
|
||||
|
||||
#
|
||||
# Insert duplicate rows, inside transaction
|
||||
# since failing inserts rollbacks whole transaction
|
||||
# all select count (except second) return same value
|
||||
#
|
||||
SELECT COUNT(*) FROM t1;
|
||||
INSERT INTO t1 VALUES
|
||||
(2001,2001,2001),(2002,2002,2002),(2003,2003,2003),(2004,2004,2004),(2005,2005,2005);
|
||||
SELECT COUNT(*) FROM t1;
|
||||
rollback;
|
||||
|
||||
#
|
||||
# Insert duplicate rows, inside transaction
|
||||
# try to commit
|
||||
#
|
||||
begin;
|
||||
|
||||
--error 1062
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
SELECT COUNT(*) FROM t1;
|
||||
|
||||
--error 1296
|
||||
commit;
|
||||
SELECT COUNT(*) FROM t1;
|
||||
|
||||
select * from t1 where pk1=1;
|
||||
select * from t1 where pk1=10;
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
select count(*) from t1;
|
||||
|
||||
|
||||
#
|
||||
# Insert duplicate rows, inside transaction
|
||||
# rollback
|
||||
#
|
||||
begin;
|
||||
|
||||
--error 1062
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
|
||||
rollback;
|
||||
|
||||
select * from t1 where pk1=1;
|
||||
select * from t1 where pk1=10;
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
select count(*) from t1;
|
||||
|
||||
|
||||
#
|
||||
# Insert duplicate rows, inside transaction
|
||||
# then try to select, finally rollback
|
||||
#
|
||||
begin;
|
||||
|
||||
--error 1062
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
--error 1296
|
||||
SELECT * FROM t1 WHERE pk1=10;
|
||||
|
||||
rollback;
|
||||
|
||||
select * from t1 where pk1=1;
|
||||
select * from t1 where pk1=10;
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
select count(*) from t1;
|
||||
|
||||
|
||||
#
|
||||
# Insert duplicate rows, inside transaction
|
||||
# then try to select, finally commit
|
||||
#
|
||||
begin;
|
||||
|
||||
--error 1062
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
|
||||
--error 1296
|
||||
SELECT * FROM t1 WHERE pk1=10;
|
||||
|
||||
--error 1296
|
||||
SELECT * FROM t1 WHERE pk1=10;
|
||||
|
||||
--error 1296
|
||||
commit;
|
||||
|
||||
select * from t1 where pk1=1;
|
||||
select * from t1 where pk1=10;
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
select count(*) from t1;
|
||||
|
||||
|
||||
#
|
||||
# Insert duplicate rows, inside transaction
|
||||
# then try to do another insert
|
||||
#
|
||||
begin;
|
||||
|
||||
--error 1062
|
||||
INSERT INTO t1 VALUES
|
||||
(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5),
|
||||
(6,6,6),(7,7,7),(8,8,8),(9,9,9),(10,10,10);
|
||||
|
||||
--error 1296
|
||||
INSERT INTO t1 values (4000, 40, 44);
|
||||
|
||||
rollback;
|
||||
|
||||
select * from t1 where pk1=1;
|
||||
select * from t1 where pk1=10;
|
||||
select count(*) from t1 where pk1 <= 10 order by pk1;
|
||||
select count(*) from t1;
|
||||
|
||||
#
|
||||
# Insert duplicate rows using "insert .. select"
|
||||
|
@ -466,4 +565,21 @@ SELECT COUNT(*) FROM t1;
|
|||
insert into t1 select * from t1 where b < 10 order by pk1;
|
||||
|
||||
|
||||
begin;
|
||||
--error 1031
|
||||
INSERT IGNORE INTO t1 VALUES(1,2,3);
|
||||
commit;
|
||||
select * from t1 where pk1=1;
|
||||
|
||||
--error 1031
|
||||
INSERT IGNORE INTO t1 VALUES(1,2,3);
|
||||
select * from t1 where pk1=1;
|
||||
|
||||
REPLACE INTO t1 values(1, 2, 3);
|
||||
select * from t1 where pk1=1;
|
||||
|
||||
--error 1031
|
||||
INSERT INTO t1 VALUES(1,1,1) ON DUPLICATE KEY UPDATE b=79;
|
||||
select * from t1 where pk1=1;
|
||||
|
||||
DROP TABLE t1;
|
||||
|
|
|
@ -278,3 +278,39 @@ execute stmt using @var;
|
|||
deallocate prepare stmt;
|
||||
drop table t1;
|
||||
|
||||
#
|
||||
# BUG#5510 "inserting Null in AutoIncrement primary key Column Fails"
|
||||
# (prepared statements)
|
||||
# The cause: misuse of internal MySQL 'Field' API.
|
||||
#
|
||||
|
||||
create table t1 (a bigint(20) not null primary key auto_increment);
|
||||
insert into t1 (a) values (null);
|
||||
select * from t1;
|
||||
prepare stmt from "insert into t1 (a) values (?)";
|
||||
set @var=null;
|
||||
execute stmt using @var;
|
||||
select * from t1;
|
||||
drop table t1;
|
||||
#
|
||||
# check the same for timestamps
|
||||
#
|
||||
create table t1 (a timestamp not null);
|
||||
prepare stmt from "insert into t1 (a) values (?)";
|
||||
execute stmt using @var;
|
||||
--disable_result_log
|
||||
select * from t1;
|
||||
--enable_result_log
|
||||
deallocate prepare stmt;
|
||||
drop table t1;
|
||||
|
||||
#
|
||||
# BUG#5688 "Upgraded 4.1.5 Server seg faults" # (prepared statements)
|
||||
# The test case speaks for itself.
|
||||
# Just another place where we used wrong memory root for Items created
|
||||
# during statement prepare.
|
||||
#
|
||||
prepare stmt from "select 'abc' like convert('abc' using utf8)";
|
||||
execute stmt;
|
||||
execute stmt;
|
||||
deallocate prepare stmt;
|
||||
|
|
|
@ -148,6 +148,24 @@ INSERT INTO t1 (c1, c2) VALUES ('
|
|||
select hex(c1), hex(c2) from t1;
|
||||
sync_slave_with_master;
|
||||
select hex(c1), hex(c2) from t1;
|
||||
|
||||
# Now test for BUG##5705: SET CHARATER_SET_SERVERetc will be lost if
|
||||
# STOP SLAVE before following query
|
||||
|
||||
stop slave;
|
||||
delete from t1;
|
||||
change master to master_log_pos=5801;
|
||||
start slave until master_log_file='master-bin.000001', master_log_pos=5937;
|
||||
# Slave is supposed to stop _after_ the INSERT, even though 5937 is
|
||||
# the position of the beginning of the INSERT; after SET slave is not
|
||||
# supposed to increment position.
|
||||
wait_for_slave_to_stop;
|
||||
# When you merge this into 5.0 you will have to adjust positions
|
||||
# above; the first master_log_pos above should be the one of the SET,
|
||||
# the second should be the one of the INSERT.
|
||||
start slave;
|
||||
sync_with_master;
|
||||
select hex(c1), hex(c2) from t1;
|
||||
connection master;
|
||||
drop table t1;
|
||||
sync_slave_with_master;
|
||||
|
|
|
@ -45,3 +45,17 @@ create table t1 (a enum(0xE4, '1', '2') not null default 0xE4);
|
|||
show columns from t1;
|
||||
show create table t1;
|
||||
drop table t1;
|
||||
|
||||
|
||||
#
|
||||
# Bug #5628 German characters in field-defs will be '?'
|
||||
# with some table definitions
|
||||
#
|
||||
set names latin1;
|
||||
CREATE TABLE t1 (
|
||||
a INT default 1,
|
||||
b ENUM('value','öäü_value','ÊÃÕ') character set latin1 NOT NULL
|
||||
);
|
||||
show create table t1;
|
||||
show columns from t1;
|
||||
drop table t1;
|
||||
|
|
26
mysys/hash.c
26
mysys/hash.c
|
@ -88,6 +88,32 @@ void hash_free(HASH *hash)
|
|||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Delete all elements from the hash (the hash itself is to be reused).
|
||||
|
||||
SYNOPSIS
|
||||
hash_reset()
|
||||
hash the hash to delete elements of
|
||||
*/
|
||||
|
||||
void hash_reset(HASH *hash)
|
||||
{
|
||||
DBUG_ENTER("hash_reset");
|
||||
if (hash->free)
|
||||
{
|
||||
HASH_LINK *link= dynamic_element(&hash->array, 0, HASH_LINK*);
|
||||
HASH_LINK *end= link + hash->records;
|
||||
for (; link < end; ++link)
|
||||
(*hash->free)(link->data);
|
||||
}
|
||||
reset_dynamic(&hash->array);
|
||||
hash->records= 0;
|
||||
hash->blength= 1;
|
||||
hash->current_record= NO_RECORD;
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
/* some helper functions */
|
||||
|
||||
/*
|
||||
|
|
|
@ -22,6 +22,27 @@
|
|||
#undef EXTRA_DEBUG
|
||||
#define EXTRA_DEBUG
|
||||
|
||||
|
||||
/*
|
||||
Initialize memory root
|
||||
|
||||
SYNOPSIS
|
||||
init_alloc_root()
|
||||
mem_root - memory root to initialize
|
||||
block_size - size of chunks (blocks) used for memory allocation
|
||||
(It is external size of chunk i.e. it should include
|
||||
memory required for internal structures, thus it
|
||||
should be no less than ALLOC_ROOT_MIN_BLOCK_SIZE)
|
||||
pre_alloc_size - if non-0, then size of block that should be
|
||||
pre-allocated during memory root initialization.
|
||||
|
||||
DESCRIPTION
|
||||
This function prepares memory root for further use, sets initial size of
|
||||
chunk for memory allocation and pre-allocates first block if specified.
|
||||
Altough error can happen during execution of this function if pre_alloc_size
|
||||
is non-0 it won't be reported. Instead it will be reported as error in first
|
||||
alloc_root() on this memory root.
|
||||
*/
|
||||
void init_alloc_root(MEM_ROOT *mem_root, uint block_size,
|
||||
uint pre_alloc_size __attribute__((unused)))
|
||||
{
|
||||
|
@ -29,7 +50,7 @@ void init_alloc_root(MEM_ROOT *mem_root, uint block_size,
|
|||
DBUG_PRINT("enter",("root: 0x%lx", mem_root));
|
||||
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
|
||||
mem_root->min_malloc= 32;
|
||||
mem_root->block_size= block_size-MALLOC_OVERHEAD-sizeof(USED_MEM)-8;
|
||||
mem_root->block_size= block_size - ALLOC_ROOT_MIN_BLOCK_SIZE;
|
||||
mem_root->error_handler= 0;
|
||||
mem_root->block_num= 4; /* We shift this with >>2 */
|
||||
mem_root->first_block_usage= 0;
|
||||
|
@ -54,9 +75,9 @@ void init_alloc_root(MEM_ROOT *mem_root, uint block_size,
|
|||
SYNOPSIS
|
||||
reset_root_defaults()
|
||||
mem_root memory root to change defaults of
|
||||
block_size new value of block size. Must be
|
||||
greater than ~68 bytes (the exact value depends on
|
||||
platform and compilation flags)
|
||||
block_size new value of block size. Must be greater or equal
|
||||
than ALLOC_ROOT_MIN_BLOCK_SIZE (this value is about
|
||||
68 bytes and depends on platform and compilation flags)
|
||||
pre_alloc_size new size of preallocated block. If not zero,
|
||||
must be equal to or greater than block size,
|
||||
otherwise means 'no prealloc'.
|
||||
|
@ -70,7 +91,9 @@ void init_alloc_root(MEM_ROOT *mem_root, uint block_size,
|
|||
void reset_root_defaults(MEM_ROOT *mem_root, uint block_size,
|
||||
uint pre_alloc_size __attribute__((unused)))
|
||||
{
|
||||
mem_root->block_size= block_size-MALLOC_OVERHEAD-sizeof(USED_MEM)-8;
|
||||
DBUG_ASSERT(alloc_root_inited(mem_root));
|
||||
|
||||
mem_root->block_size= block_size - ALLOC_ROOT_MIN_BLOCK_SIZE;
|
||||
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
|
||||
if (pre_alloc_size)
|
||||
{
|
||||
|
@ -123,6 +146,8 @@ gptr alloc_root(MEM_ROOT *mem_root,unsigned int Size)
|
|||
DBUG_ENTER("alloc_root");
|
||||
DBUG_PRINT("enter",("root: 0x%lx", mem_root));
|
||||
|
||||
DBUG_ASSERT(alloc_root_inited(mem_root));
|
||||
|
||||
Size+=ALIGN_SIZE(sizeof(USED_MEM));
|
||||
if (!(next = (USED_MEM*) my_malloc(Size,MYF(MY_WME))))
|
||||
{
|
||||
|
@ -140,6 +165,8 @@ gptr alloc_root(MEM_ROOT *mem_root,unsigned int Size)
|
|||
reg1 USED_MEM *next= 0;
|
||||
reg2 USED_MEM **prev;
|
||||
|
||||
DBUG_ASSERT(alloc_root_inited(mem_root));
|
||||
|
||||
Size= ALIGN_SIZE(Size);
|
||||
if ((*(prev= &mem_root->free)) != NULL)
|
||||
{
|
||||
|
|
|
@ -229,10 +229,10 @@ LocalConfig::parseString(const char * connectString, char *line){
|
|||
|
||||
bool LocalConfig::readFile(const char * filename, bool &fopenError)
|
||||
{
|
||||
char line[150], line2[150];
|
||||
|
||||
char line[1024];
|
||||
|
||||
fopenError = false;
|
||||
|
||||
|
||||
FILE * file = fopen(filename, "r");
|
||||
if(file == 0){
|
||||
snprintf(line, 150, "Unable to open local config file: %s", filename);
|
||||
|
@ -241,31 +241,33 @@ bool LocalConfig::readFile(const char * filename, bool &fopenError)
|
|||
return false;
|
||||
}
|
||||
|
||||
unsigned int sz = 1024;
|
||||
char* theString = (char*)NdbMem_Allocate(sz);
|
||||
theString[0] = 0;
|
||||
BaseString theString;
|
||||
|
||||
fgets(theString, sz, file);
|
||||
while (fgets(line+1, 100, file)) {
|
||||
line[0] = ';';
|
||||
while (strlen(theString) + strlen(line) >= sz) {
|
||||
sz = sz*2;
|
||||
char *newString = (char*)NdbMem_Allocate(sz);
|
||||
strcpy(newString, theString);
|
||||
free(theString);
|
||||
theString = newString;
|
||||
while(fgets(line, 1024, file)){
|
||||
BaseString tmp(line);
|
||||
tmp.trim(" \t\n\r");
|
||||
if(tmp.length() > 0 && tmp.c_str()[0] != '#'){
|
||||
theString.append(tmp);
|
||||
break;
|
||||
}
|
||||
strcat(theString, line);
|
||||
}
|
||||
|
||||
bool return_value = parseString(theString, line);
|
||||
while (fgets(line, 1024, file)) {
|
||||
BaseString tmp(line);
|
||||
tmp.trim(" \t\n\r");
|
||||
if(tmp.length() > 0 && tmp.c_str()[0] != '#'){
|
||||
theString.append(";");
|
||||
theString.append(tmp);
|
||||
}
|
||||
}
|
||||
|
||||
bool return_value = parseString(theString.c_str(), line);
|
||||
|
||||
if (!return_value) {
|
||||
snprintf(line2, 150, "Reading %s: %s", filename, line);
|
||||
setError(0,line2);
|
||||
BaseString tmp;
|
||||
tmp.assfmt("Reading %s: %s", filename, line);
|
||||
setError(0, tmp.c_str());
|
||||
}
|
||||
|
||||
free(theString);
|
||||
fclose(file);
|
||||
return return_value;
|
||||
}
|
||||
|
|
|
@ -159,6 +159,7 @@ Configuration::Configuration()
|
|||
_initialStart = false;
|
||||
_daemonMode = false;
|
||||
m_config_retriever= 0;
|
||||
m_clusterConfig= 0;
|
||||
}
|
||||
|
||||
Configuration::~Configuration(){
|
||||
|
|
|
@ -145,27 +145,29 @@ NdbConnection::init()
|
|||
}//NdbConnection::init()
|
||||
|
||||
/*****************************************************************************
|
||||
setOperationErrorCode(int anErrorCode);
|
||||
setOperationErrorCode(int error);
|
||||
|
||||
Remark: Sets an error code on the connection object from an
|
||||
operation object.
|
||||
*****************************************************************************/
|
||||
void
|
||||
NdbConnection::setOperationErrorCode(int anErrorCode)
|
||||
NdbConnection::setOperationErrorCode(int error)
|
||||
{
|
||||
if (theError.code == 0)
|
||||
theError.code = anErrorCode;
|
||||
}//NdbConnection::setOperationErrorCode()
|
||||
DBUG_ENTER("NdbConnection::setOperationErrorCode");
|
||||
setErrorCode(error);
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
setOperationErrorCodeAbort(int anErrorCode);
|
||||
setOperationErrorCodeAbort(int error);
|
||||
|
||||
Remark: Sets an error code on the connection object from an
|
||||
operation object.
|
||||
*****************************************************************************/
|
||||
void
|
||||
NdbConnection::setOperationErrorCodeAbort(int anErrorCode)
|
||||
NdbConnection::setOperationErrorCodeAbort(int error)
|
||||
{
|
||||
DBUG_ENTER("NdbConnection::setOperationErrorCodeAbort");
|
||||
if (theTransactionIsStarted == false) {
|
||||
theCommitStatus = Aborted;
|
||||
} else if ((m_abortOption == AbortOnError) &&
|
||||
|
@ -173,9 +175,9 @@ NdbConnection::setOperationErrorCodeAbort(int anErrorCode)
|
|||
(theCommitStatus != Aborted)) {
|
||||
theCommitStatus = NeedAbort;
|
||||
}//if
|
||||
if (theError.code == 0)
|
||||
theError.code = anErrorCode;
|
||||
}//NdbConnection::setOperationErrorCodeAbort()
|
||||
setErrorCode(error);
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
setErrorCode(int anErrorCode);
|
||||
|
@ -183,10 +185,15 @@ setErrorCode(int anErrorCode);
|
|||
Remark: Sets an error indication on the connection object.
|
||||
*****************************************************************************/
|
||||
void
|
||||
NdbConnection::setErrorCode(int anErrorCode)
|
||||
NdbConnection::setErrorCode(int error)
|
||||
{
|
||||
DBUG_ENTER("NdbConnection::setErrorCode");
|
||||
DBUG_PRINT("enter", ("error: %d, theError.code: %d", error, theError.code));
|
||||
|
||||
if (theError.code == 0)
|
||||
theError.code = anErrorCode;
|
||||
theError.code = error;
|
||||
|
||||
DBUG_VOID_RETURN;
|
||||
}//NdbConnection::setErrorCode()
|
||||
|
||||
int
|
||||
|
@ -262,8 +269,12 @@ NdbConnection::execute(ExecType aTypeOfExec,
|
|||
AbortOption abortOption,
|
||||
int forceSend)
|
||||
{
|
||||
DBUG_ENTER("NdbConnection::execute");
|
||||
DBUG_PRINT("enter", ("aTypeOfExec: %d, abortOption: %d",
|
||||
aTypeOfExec, abortOption));
|
||||
|
||||
if (! theBlobFlag)
|
||||
return executeNoBlobs(aTypeOfExec, abortOption, forceSend);
|
||||
DBUG_RETURN(executeNoBlobs(aTypeOfExec, abortOption, forceSend));
|
||||
|
||||
/*
|
||||
* execute prepared ops in batches, as requested by blobs
|
||||
|
@ -346,7 +357,7 @@ NdbConnection::execute(ExecType aTypeOfExec,
|
|||
}
|
||||
} while (theFirstOpInList != NULL || tExecType != aTypeOfExec);
|
||||
|
||||
return ret;
|
||||
DBUG_RETURN(ret);
|
||||
}
|
||||
|
||||
int
|
||||
|
@ -354,6 +365,10 @@ NdbConnection::executeNoBlobs(ExecType aTypeOfExec,
|
|||
AbortOption abortOption,
|
||||
int forceSend)
|
||||
{
|
||||
DBUG_ENTER("NdbConnection::executeNoBlobs");
|
||||
DBUG_PRINT("enter", ("aTypeOfExec: %d, abortOption: %d",
|
||||
aTypeOfExec, abortOption));
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// We will start by preparing all operations in the transaction defined
|
||||
// since last execute or since beginning. If this works ok we will continue
|
||||
|
@ -376,7 +391,7 @@ NdbConnection::executeNoBlobs(ExecType aTypeOfExec,
|
|||
*/
|
||||
ndbout << "This timeout should never occur, execute(..)" << endl;
|
||||
setOperationErrorCodeAbort(4012); // Error code for "Cluster Failure"
|
||||
return -1;
|
||||
DBUG_RETURN(-1);
|
||||
}//if
|
||||
|
||||
/*
|
||||
|
@ -400,13 +415,13 @@ NdbConnection::executeNoBlobs(ExecType aTypeOfExec,
|
|||
}
|
||||
#endif
|
||||
if (theReturnStatus == ReturnFailure) {
|
||||
return -1;
|
||||
DBUG_RETURN(-1);
|
||||
}//if
|
||||
break;
|
||||
}
|
||||
}
|
||||
thePendingBlobOps = 0;
|
||||
return 0;
|
||||
DBUG_RETURN(0);
|
||||
}//NdbConnection::execute()
|
||||
|
||||
/*****************************************************************************
|
||||
|
@ -430,9 +445,15 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
|
|||
void* anyObject,
|
||||
AbortOption abortOption)
|
||||
{
|
||||
DBUG_ENTER("NdbConnection::executeAsynchPrepare");
|
||||
DBUG_PRINT("enter", ("aTypeOfExec: %d, aCallback: %x, anyObject: %x",
|
||||
aTypeOfExec, aCallback, anyObject));
|
||||
|
||||
/**
|
||||
* Reset error.code on execute
|
||||
*/
|
||||
if (theError.code != 0)
|
||||
DBUG_PRINT("enter", ("Resetting error %d on execute", theError.code));
|
||||
theError.code = 0;
|
||||
NdbScanOperation* tcOp = m_theFirstScanOperation;
|
||||
if (tcOp != 0){
|
||||
|
@ -441,7 +462,7 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
|
|||
int tReturnCode;
|
||||
tReturnCode = tcOp->executeCursor(theDBnode);
|
||||
if (tReturnCode == -1) {
|
||||
return;
|
||||
DBUG_VOID_RETURN;
|
||||
}//if
|
||||
tcOp = (NdbScanOperation*)tcOp->next();
|
||||
} // while
|
||||
|
@ -463,17 +484,6 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
|
|||
theCallbackFunction = aCallback;
|
||||
theCallbackObject = anyObject;
|
||||
m_abortOption = abortOption;
|
||||
// SendStatusType tSendStatus = theSendStatus;
|
||||
|
||||
// if (tSendStatus != InitState) {
|
||||
/****************************************************************************
|
||||
* The application is obviously doing strange things. We should probably
|
||||
* report to the application the problem in some manner. Since we don't have
|
||||
* a good way of handling the problem we avoid discovering the problem.
|
||||
* Should be handled at some point in time.
|
||||
****************************************************************************/
|
||||
// return;
|
||||
// }
|
||||
m_waitForReply = true;
|
||||
tNdb->thePreparedTransactionsArray[tnoOfPreparedTransactions] = this;
|
||||
theTransArrayIndex = tnoOfPreparedTransactions;
|
||||
|
@ -502,7 +512,11 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
|
|||
} else {
|
||||
theSendStatus = sendABORTfail;
|
||||
}//if
|
||||
return;
|
||||
if (theCommitStatus == Aborted){
|
||||
DBUG_PRINT("exit", ("theCommitStatus: Aborted"));
|
||||
setErrorCode(4350);
|
||||
}
|
||||
DBUG_VOID_RETURN;
|
||||
}//if
|
||||
if (tTransactionIsStarted == true) {
|
||||
if (tLastOp != NULL) {
|
||||
|
@ -520,7 +534,7 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
|
|||
* We will use the commit method.
|
||||
*********************************************************************/
|
||||
theSendStatus = sendCOMMITstate;
|
||||
return;
|
||||
DBUG_VOID_RETURN;
|
||||
} else {
|
||||
/**********************************************************************
|
||||
* We need to put it into the array of completed transactions to
|
||||
|
@ -532,7 +546,7 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
|
|||
* put it into the completed array.
|
||||
**********************************************************************/
|
||||
theSendStatus = sendCompleted;
|
||||
return; // No Commit with no operations is OK
|
||||
DBUG_VOID_RETURN; // No Commit with no operations is OK
|
||||
}//if
|
||||
}//if
|
||||
} else if (tTransactionIsStarted == false) {
|
||||
|
@ -560,7 +574,7 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
|
|||
* will put it into the completed array.
|
||||
***********************************************************************/
|
||||
theSendStatus = sendCompleted;
|
||||
return;
|
||||
DBUG_VOID_RETURN;
|
||||
}//if
|
||||
}
|
||||
|
||||
|
@ -573,7 +587,7 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
|
|||
tReturnCode = tOp->prepareSend(theTCConPtr, theTransactionId);
|
||||
if (tReturnCode == -1) {
|
||||
theSendStatus = sendABORTfail;
|
||||
return;
|
||||
DBUG_VOID_RETURN;
|
||||
}//if
|
||||
|
||||
/*************************************************************************
|
||||
|
@ -596,7 +610,7 @@ NdbConnection::executeAsynchPrepare( ExecType aTypeOfExec,
|
|||
theNoOfOpSent = 0;
|
||||
theNoOfOpCompleted = 0;
|
||||
theSendStatus = sendOperations;
|
||||
return;
|
||||
DBUG_VOID_RETURN;
|
||||
}//NdbConnection::executeAsynchPrepare()
|
||||
|
||||
void NdbConnection::close()
|
||||
|
@ -665,6 +679,8 @@ Remark: Send all operations belonging to this connection.
|
|||
int
|
||||
NdbConnection::doSend()
|
||||
{
|
||||
DBUG_ENTER("NdbConnection::doSend");
|
||||
|
||||
/*
|
||||
This method assumes that at least one operation have been defined. This
|
||||
is ensured by the caller of this routine (=execute).
|
||||
|
@ -687,7 +703,7 @@ NdbConnection::doSend()
|
|||
theSendStatus = sendTC_OP;
|
||||
theTransactionIsStarted = true;
|
||||
tNdb->insert_sent_list(this);
|
||||
return 0;
|
||||
DBUG_RETURN(0);
|
||||
}//case
|
||||
case sendABORT:
|
||||
case sendABORTfail:{
|
||||
|
@ -699,18 +715,18 @@ NdbConnection::doSend()
|
|||
theReturnStatus = ReturnFailure;
|
||||
}//if
|
||||
if (sendROLLBACK() == 0) {
|
||||
return 0;
|
||||
DBUG_RETURN(0);
|
||||
}//if
|
||||
break;
|
||||
}//case
|
||||
case sendCOMMITstate:
|
||||
if (sendCOMMIT() == 0) {
|
||||
return 0;
|
||||
DBUG_RETURN(0);
|
||||
}//if
|
||||
break;
|
||||
case sendCompleted:
|
||||
theNdb->insert_completed_list(this);
|
||||
return 0;
|
||||
DBUG_RETURN(0);
|
||||
default:
|
||||
ndbout << "Inconsistent theSendStatus = " << theSendStatus << endl;
|
||||
abort();
|
||||
|
@ -720,7 +736,7 @@ NdbConnection::doSend()
|
|||
theReleaseOnClose = true;
|
||||
theTransactionIsStarted = false;
|
||||
theCommitStatus = Aborted;
|
||||
return -1;
|
||||
DBUG_RETURN(-1);
|
||||
}//NdbConnection::doSend()
|
||||
|
||||
/**************************************************************************
|
||||
|
|
|
@ -29,24 +29,31 @@
|
|||
void
|
||||
Ndb::checkFailedNode()
|
||||
{
|
||||
for (NodeId i = 0; i < theNoOfDBnodes; i ++){
|
||||
DBUG_ENTER("Ndb::checkFailedNode");
|
||||
DBUG_PRINT("enter", ("theNoOfDBnodes: %d", theNoOfDBnodes));
|
||||
|
||||
DBUG_ASSERT(theNoOfDBnodes < MAX_NDB_NODES);
|
||||
for (int i = 0; i < theNoOfDBnodes; i++){
|
||||
const NodeId node_id = theDBnodes[i];
|
||||
DBUG_PRINT("info", ("i: %d, node_id: %d", i, node_id));
|
||||
|
||||
NdbConnection * tNdbCon = theConnectionArray[node_id];
|
||||
DBUG_ASSERT(node_id < MAX_NDB_NODES);
|
||||
if (the_release_ind[node_id] == 1){
|
||||
|
||||
/**
|
||||
* Release all connections in idle list (for node)
|
||||
*/
|
||||
NdbConnection * tNdbCon = theConnectionArray[node_id];
|
||||
theConnectionArray[node_id] = NULL;
|
||||
while (tNdbCon != NULL) {
|
||||
NdbConnection* tempNdbCon = tNdbCon;
|
||||
tNdbCon = tNdbCon->next();
|
||||
releaseNdbCon(tempNdbCon);
|
||||
}//while
|
||||
}
|
||||
the_release_ind[node_id] = 0;
|
||||
}//if
|
||||
}//for
|
||||
}
|
||||
}
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
#if 0
|
||||
|
|
|
@ -228,6 +228,7 @@ ErrorBundle ErrorCodes[] = {
|
|||
{ 4347, IE, "Bad state at alter index" },
|
||||
{ 4348, IE, "Inconsistency detected at alter index" },
|
||||
{ 4349, IE, "Inconsistency detected at index usage" },
|
||||
{ 4350, IE, "Transaction already aborted" },
|
||||
|
||||
/**
|
||||
* Application error
|
||||
|
|
|
@ -30,7 +30,7 @@ testSystemRestart \
|
|||
testTimeout \
|
||||
testTransactions \
|
||||
testDeadlock \
|
||||
test_event ndbapi_slow_select testReadPerf
|
||||
test_event ndbapi_slow_select testReadPerf testLcp
|
||||
|
||||
#flexTimedAsynch
|
||||
#testBlobs
|
||||
|
@ -68,6 +68,7 @@ testDeadlock_SOURCES = testDeadlock.cpp
|
|||
test_event_SOURCES = test_event.cpp
|
||||
ndbapi_slow_select_SOURCES = slow_select.cpp
|
||||
testReadPerf_SOURCES = testReadPerf.cpp
|
||||
testLcp_SOURCES = testLcp.cpp
|
||||
|
||||
INCLUDES_LOC = -I$(top_srcdir)/ndb/include/kernel
|
||||
|
||||
|
|
|
@ -2097,47 +2097,50 @@ int Bank::increaseSystemValue(SystemValueId sysValId, Uint64 &value){
|
|||
*
|
||||
*/
|
||||
|
||||
DBUG_ENTER("Bank::increaseSystemValue");
|
||||
|
||||
int check;
|
||||
|
||||
NdbConnection* pTrans = m_ndb.startTransaction();
|
||||
if (pTrans == NULL){
|
||||
ERR(m_ndb.getNdbError());
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
NdbOperation* pOp = pTrans->getNdbOperation("SYSTEM_VALUES");
|
||||
if (pOp == NULL) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pOp->readTupleExclusive();
|
||||
// check = pOp->readTuple();
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pOp->equal("SYSTEM_VALUES_ID", sysValId);
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
NdbRecAttr* valueRec = pOp->getValue("VALUE");
|
||||
if( valueRec ==NULL ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pTrans->execute(NoCommit);
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
value = valueRec->u_64_value();
|
||||
|
@ -2147,49 +2150,56 @@ int Bank::increaseSystemValue(SystemValueId sysValId, Uint64 &value){
|
|||
if (pOp2 == NULL) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pOp2->updateTuple();
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pOp2->equal("SYSTEM_VALUES_ID", sysValId);
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pOp2->setValue("VALUE", value);
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pTrans->execute(NoCommit);
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
NdbOperation* pOp3 = pTrans->getNdbOperation("SYSTEM_VALUES");
|
||||
if (pOp3 == NULL) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pOp3->readTuple();
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pOp3->equal("SYSTEM_VALUES_ID", sysValId);
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
// Read new value
|
||||
|
@ -2197,28 +2207,31 @@ int Bank::increaseSystemValue(SystemValueId sysValId, Uint64 &value){
|
|||
if( valueNewRec ==NULL ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
check = pTrans->execute(Commit);
|
||||
if( check == -1 ) {
|
||||
ERR(pTrans->getNdbError());
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
// Check that value updated equals the value we read after the update
|
||||
if (valueNewRec->u_64_value() != value){
|
||||
|
||||
printf("value actual=%lld\n", valueNewRec->u_64_value());
|
||||
printf("value expected=%lld actual=%lld\n", value, valueNewRec->u_64_value());
|
||||
|
||||
DBUG_PRINT("info", ("value expected=%ld actual=%ld", value, valueNewRec->u_64_value()));
|
||||
g_err << "getNextTransactionId: value was not updated" << endl;
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
return NDBT_FAILED;
|
||||
DBUG_RETURN(NDBT_FAILED);
|
||||
}
|
||||
|
||||
m_ndb.closeTransaction(pTrans);
|
||||
|
||||
|
||||
return 0;
|
||||
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
||||
int Bank::increaseSystemValue2(SystemValueId sysValId, Uint64 &value){
|
||||
|
|
320
ndb/test/ndbapi/testLcp.cpp
Normal file
320
ndb/test/ndbapi/testLcp.cpp
Normal file
|
@ -0,0 +1,320 @@
|
|||
|
||||
#include <NDBT.hpp>
|
||||
#include <NdbApi.hpp>
|
||||
#include <NdbRestarter.hpp>
|
||||
#include <HugoOperations.hpp>
|
||||
#include <UtilTransactions.hpp>
|
||||
#include <signaldata/DumpStateOrd.hpp>
|
||||
|
||||
struct CASE
|
||||
{
|
||||
bool start_row;
|
||||
bool end_row;
|
||||
bool curr_row;
|
||||
const char * op1;
|
||||
const char * op2;
|
||||
int val;
|
||||
};
|
||||
|
||||
static CASE g_ops[] =
|
||||
{
|
||||
{ false, true, false, "INSERT", 0, 0 },
|
||||
{ false, true, false, "INSERT", "UPDATE", 0 },
|
||||
{ false, false, false, "INSERT", "DELETE", 0 },
|
||||
{ true, true, false, "UPDATE", 0, 0 },
|
||||
{ true, true, false, "UPDATE", "UPDATE", 0 },
|
||||
{ true, false, false, "UPDATE", "DELETE", 0 },
|
||||
{ true, false, false, "DELETE", 0, 0 },
|
||||
{ true, true, false, "DELETE", "INSERT", 0 }
|
||||
};
|
||||
const size_t OP_COUNT = (sizeof(g_ops)/sizeof(g_ops[0]));
|
||||
|
||||
static Ndb* g_ndb = 0;
|
||||
static CASE* g_cases;
|
||||
static HugoOperations* g_hugo_ops;
|
||||
|
||||
static int g_rows = 1000;
|
||||
static int g_setup_tables = 1;
|
||||
static const char * g_tablename = "T1";
|
||||
static const NdbDictionary::Table* g_table = 0;
|
||||
static NdbRestarter g_restarter;
|
||||
|
||||
static int init_ndb(int argc, char** argv);
|
||||
static int parse_args(int argc, char** argv);
|
||||
static int connect_ndb();
|
||||
static int drop_all_tables();
|
||||
static int load_table();
|
||||
static int pause_lcp();
|
||||
static int do_op(int row);
|
||||
static int continue_lcp(int error);
|
||||
static int commit();
|
||||
static int restart();
|
||||
static int validate();
|
||||
|
||||
#define require(x) { bool b = x; if(!b){g_err << __LINE__ << endl; abort();}}
|
||||
|
||||
int
|
||||
main(int argc, char ** argv){
|
||||
|
||||
require(!init_ndb(argc, argv));
|
||||
require(!parse_args(argc, argv));
|
||||
require(!connect_ndb());
|
||||
|
||||
if(g_setup_tables){
|
||||
require(!drop_all_tables());
|
||||
|
||||
if(NDBT_Tables::createTable(g_ndb, g_tablename) != 0){
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
g_table = g_ndb->getDictionary()->getTable(g_tablename);
|
||||
if(g_table == 0){
|
||||
g_err << "Failed to retreive table: " << g_tablename << endl;
|
||||
exit(-1);
|
||||
}
|
||||
require(g_hugo_ops = new HugoOperations(* g_table));
|
||||
require(!g_hugo_ops->startTransaction(g_ndb));
|
||||
|
||||
g_cases= new CASE[g_rows];
|
||||
require(!load_table());
|
||||
|
||||
g_info << "Performing all ops wo/ inteference of LCP" << endl;
|
||||
|
||||
g_info << "Testing pre LCP operations, ZLCP_OP_WRITE_RT_BREAK" << endl;
|
||||
g_info << " where ZLCP_OP_WRITE_RT_BREAK is finished before SAVE_PAGES"
|
||||
<< endl;
|
||||
require(!pause_lcp());
|
||||
for(size_t j = 0; j<g_rows; j++){
|
||||
require(!do_op(j));
|
||||
}
|
||||
require(!continue_lcp(5900));
|
||||
require(!commit());
|
||||
require(!restart());
|
||||
require(!validate());
|
||||
|
||||
g_info << "Testing pre LCP operations, ZLCP_OP_WRITE_RT_BREAK" << endl;
|
||||
g_info << " where ZLCP_OP_WRITE_RT_BREAK is finished after SAVE_PAGES"
|
||||
<< endl;
|
||||
require(!load_table());
|
||||
require(!pause_lcp());
|
||||
for(size_t j = 0; j<g_rows; j++){
|
||||
require(!do_op(j));
|
||||
}
|
||||
require(!continue_lcp(5901));
|
||||
require(!commit());
|
||||
require(!restart());
|
||||
require(!validate());
|
||||
|
||||
g_info << "Testing pre LCP operations, undo-ed at commit" << endl;
|
||||
require(!load_table());
|
||||
require(!pause_lcp());
|
||||
for(size_t j = 0; j<g_rows; j++){
|
||||
require(!do_op(j));
|
||||
}
|
||||
require(!continue_lcp(5902));
|
||||
require(!commit());
|
||||
require(!continue_lcp(5903));
|
||||
require(!restart());
|
||||
require(!validate());
|
||||
}
|
||||
|
||||
static int init_ndb(int argc, char** argv)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int parse_args(int argc, char** argv)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int connect_ndb()
|
||||
{
|
||||
g_ndb = new Ndb("TEST_DB");
|
||||
g_ndb->init();
|
||||
if(g_ndb->waitUntilReady(30) == 0){
|
||||
int args[] = { DumpStateOrd::DihMaxTimeBetweenLCP };
|
||||
return g_restarter.dumpStateAllNodes(args, 1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int disconnect_ndb()
|
||||
{
|
||||
delete g_ndb;
|
||||
g_ndb = 0;
|
||||
g_table = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int drop_all_tables()
|
||||
{
|
||||
NdbDictionary::Dictionary * dict = g_ndb->getDictionary();
|
||||
require(dict);
|
||||
|
||||
BaseString db = g_ndb->getDatabaseName();
|
||||
BaseString schema = g_ndb->getSchemaName();
|
||||
|
||||
NdbDictionary::Dictionary::List list;
|
||||
if (dict->listObjects(list, NdbDictionary::Object::TypeUndefined) == -1){
|
||||
g_err << "Failed to list tables: " << endl
|
||||
<< dict->getNdbError() << endl;
|
||||
return -1;
|
||||
}
|
||||
for (unsigned i = 0; i < list.count; i++) {
|
||||
NdbDictionary::Dictionary::List::Element& elt = list.elements[i];
|
||||
switch (elt.type) {
|
||||
case NdbDictionary::Object::SystemTable:
|
||||
case NdbDictionary::Object::UserTable:
|
||||
g_ndb->setDatabaseName(elt.database);
|
||||
g_ndb->setSchemaName(elt.schema);
|
||||
if(dict->dropTable(elt.name) != 0){
|
||||
g_err << "Failed to drop table: "
|
||||
<< elt.database << "/" << elt.schema << "/" << elt.name <<endl;
|
||||
g_err << dict->getNdbError() << endl;
|
||||
return -1;
|
||||
}
|
||||
break;
|
||||
case NdbDictionary::Object::UniqueHashIndex:
|
||||
case NdbDictionary::Object::OrderedIndex:
|
||||
case NdbDictionary::Object::HashIndexTrigger:
|
||||
case NdbDictionary::Object::IndexTrigger:
|
||||
case NdbDictionary::Object::SubscriptionTrigger:
|
||||
case NdbDictionary::Object::ReadOnlyConstraint:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
g_ndb->setDatabaseName(db.c_str());
|
||||
g_ndb->setSchemaName(schema.c_str());
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int load_table()
|
||||
{
|
||||
UtilTransactions clear(* g_table);
|
||||
require(!clear.clearTable(g_ndb));
|
||||
|
||||
HugoOperations ops(* g_table);
|
||||
require(!ops.startTransaction(g_ndb));
|
||||
for(size_t i = 0; i<g_rows; i++){
|
||||
g_cases[i] = g_ops[ i % OP_COUNT];
|
||||
if(g_cases[i].start_row){
|
||||
g_cases[i].curr_row = true;
|
||||
g_cases[i].val = rand();
|
||||
require(!ops.pkInsertRecord(g_ndb, i, 1, g_cases[i].val));
|
||||
}
|
||||
if((i+1) % 100 == 0){
|
||||
require(!ops.execute_Commit(g_ndb));
|
||||
require(!ops.getTransaction()->restart());
|
||||
}
|
||||
}
|
||||
if((g_rows+1) % 100 != 0)
|
||||
require(!ops.execute_Commit(g_ndb));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int pause_lcp()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_op(int row)
|
||||
{
|
||||
HugoOperations & ops = * g_hugo_ops;
|
||||
if(strcmp(g_cases[row].op1, "INSERT") == 0){
|
||||
require(!g_cases[row].curr_row);
|
||||
g_cases[row].curr_row = true;
|
||||
g_cases[row].val = rand();
|
||||
require(!ops.pkInsertRecord(g_ndb, row, 1, g_cases[row].val));
|
||||
} else if(strcmp(g_cases[row].op1, "UPDATE") == 0){
|
||||
require(g_cases[row].curr_row);
|
||||
g_cases[row].val = rand();
|
||||
require(!ops.pkUpdateRecord(g_ndb, row, 1, g_cases[row].val));
|
||||
} else if(strcmp(g_cases[row].op1, "DELETE") == 0){
|
||||
require(g_cases[row].curr_row);
|
||||
g_cases[row].curr_row = false;
|
||||
require(!ops.pkDeleteRecord(g_ndb, row, 1));
|
||||
}
|
||||
|
||||
require(!ops.execute_NoCommit(g_ndb));
|
||||
|
||||
if(g_cases[row].op2 == 0){
|
||||
} else if(strcmp(g_cases[row].op2, "INSERT") == 0){
|
||||
require(!g_cases[row].curr_row);
|
||||
g_cases[row].curr_row = true;
|
||||
g_cases[row].val = rand();
|
||||
require(!ops.pkInsertRecord(g_ndb, row, 1, g_cases[row].val));
|
||||
} else if(strcmp(g_cases[row].op2, "UPDATE") == 0){
|
||||
require(g_cases[row].curr_row);
|
||||
g_cases[row].val = rand();
|
||||
require(!ops.pkUpdateRecord(g_ndb, row, 1, g_cases[row].val));
|
||||
} else if(strcmp(g_cases[row].op2, "DELETE") == 0){
|
||||
require(g_cases[row].curr_row);
|
||||
g_cases[row].curr_row = false;
|
||||
require(!ops.pkDeleteRecord(g_ndb, row, 1));
|
||||
}
|
||||
|
||||
if(g_cases[row].op2 != 0)
|
||||
require(!ops.execute_NoCommit(g_ndb));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int continue_lcp(int error)
|
||||
{
|
||||
error = 0;
|
||||
if(g_restarter.insertErrorInAllNodes(error) == 0){
|
||||
int args[] = { DumpStateOrd::DihStartLcpImmediately };
|
||||
return g_restarter.dumpStateAllNodes(args, 1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int commit()
|
||||
{
|
||||
HugoOperations & ops = * g_hugo_ops;
|
||||
int res = ops.execute_Commit(g_ndb);
|
||||
if(res == 0){
|
||||
return ops.getTransaction()->restart();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
static int restart()
|
||||
{
|
||||
g_info << "Restarting cluster" << endl;
|
||||
disconnect_ndb();
|
||||
delete g_hugo_ops;
|
||||
|
||||
require(!g_restarter.restartAll());
|
||||
require(!g_restarter.waitClusterStarted(30));
|
||||
require(!connect_ndb());
|
||||
|
||||
g_table = g_ndb->getDictionary()->getTable(g_tablename);
|
||||
require(g_table);
|
||||
require(g_hugo_ops = new HugoOperations(* g_table));
|
||||
require(!g_hugo_ops->startTransaction(g_ndb));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int validate()
|
||||
{
|
||||
HugoOperations ops(* g_table);
|
||||
for(size_t i = 0; i<g_rows; i++){
|
||||
require(g_cases[i].curr_row == g_cases[i].end_row);
|
||||
require(!ops.startTransaction(g_ndb));
|
||||
ops.pkReadRecord(g_ndb, i, 1);
|
||||
int res = ops.execute_Commit(g_ndb);
|
||||
if(g_cases[i].curr_row){
|
||||
require(res == 0 && ops.verifyUpdatesValue(g_cases[i].val) == 0);
|
||||
} else {
|
||||
require(res == 626);
|
||||
}
|
||||
ops.closeTransaction(g_ndb);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -859,6 +859,11 @@ void NDBT_TestSuite::execute(Ndb* ndb, const NdbDictionary::Table* pTab,
|
|||
else
|
||||
numTestsOk++;
|
||||
numTestsExecuted++;
|
||||
|
||||
if (result == NDBT_OK && createTable == true){
|
||||
pDict->dropTable(pTab->getName());
|
||||
}
|
||||
|
||||
delete ctx;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -2239,6 +2239,32 @@ static void mysql_close_free(MYSQL *mysql)
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
Clear connection pointer of every statement: this is necessary
|
||||
to give error on attempt to use a prepared statement of closed
|
||||
connection.
|
||||
|
||||
SYNOPSYS
|
||||
mysql_detach_stmt_list()
|
||||
stmt_list pointer to mysql->stmts
|
||||
*/
|
||||
|
||||
void mysql_detach_stmt_list(LIST **stmt_list)
|
||||
{
|
||||
#ifdef MYSQL_CLIENT
|
||||
/* Reset connection handle in all prepared statements. */
|
||||
LIST *element= *stmt_list;
|
||||
for (; element; element= element->next)
|
||||
{
|
||||
MYSQL_STMT *stmt= (MYSQL_STMT *) element->data;
|
||||
stmt->mysql= 0;
|
||||
/* No need to call list_delete for statement here */
|
||||
}
|
||||
*stmt_list= 0;
|
||||
#endif /* MYSQL_CLIENT */
|
||||
}
|
||||
|
||||
|
||||
void STDCALL mysql_close(MYSQL *mysql)
|
||||
{
|
||||
DBUG_ENTER("mysql_close");
|
||||
|
@ -2255,20 +2281,7 @@ void STDCALL mysql_close(MYSQL *mysql)
|
|||
}
|
||||
mysql_close_free_options(mysql);
|
||||
mysql_close_free(mysql);
|
||||
#ifdef MYSQL_CLIENT
|
||||
if (mysql->stmts)
|
||||
{
|
||||
/* Reset connection handle in all prepared statements. */
|
||||
LIST *element;
|
||||
for (element= mysql->stmts; element; element= element->next)
|
||||
{
|
||||
MYSQL_STMT *stmt= (MYSQL_STMT *) element->data;
|
||||
stmt->mysql= 0;
|
||||
/* No need to call list_delete for statement here */
|
||||
}
|
||||
mysql->stmts= 0;
|
||||
}
|
||||
#endif /*MYSQL_CLIENT*/
|
||||
mysql_detach_stmt_list(&mysql->stmts);
|
||||
#ifndef TO_BE_DELETED
|
||||
/* free/close slave list */
|
||||
if (mysql->rpl_pivot)
|
||||
|
|
|
@ -70,7 +70,6 @@
|
|||
Allow users to set compression level.
|
||||
Add truncate table command.
|
||||
Implement versioning, should be easy.
|
||||
Implement optimize so we can fix broken tables.
|
||||
Allow for errors, find a way to mark bad rows.
|
||||
See if during an optimize you can make the table smaller.
|
||||
Talk to the gzip guys, come up with a writable format so that updates are doable
|
||||
|
@ -88,6 +87,7 @@ static int archive_init= 0;
|
|||
|
||||
/* The file extension */
|
||||
#define ARZ ".ARZ"
|
||||
#define ARN ".ARN"
|
||||
|
||||
/*
|
||||
Used for hash table that tracks open tables.
|
||||
|
@ -117,7 +117,7 @@ static ARCHIVE_SHARE *get_share(const char *table_name, TABLE *table)
|
|||
if (!archive_init)
|
||||
{
|
||||
VOID(pthread_mutex_init(&archive_mutex,MY_MUTEX_INIT_FAST));
|
||||
if (!hash_init(&archive_open_tables,system_charset_info,32,0,0,
|
||||
if (hash_init(&archive_open_tables,system_charset_info,32,0,0,
|
||||
(hash_get_key) archive_get_key,0,0))
|
||||
{
|
||||
pthread_mutex_unlock(&LOCK_mysql_create_db);
|
||||
|
@ -205,7 +205,7 @@ static int free_share(ARCHIVE_SHARE *share)
|
|||
We just implement one additional file extension.
|
||||
*/
|
||||
const char **ha_archive::bas_ext() const
|
||||
{ static const char *ext[]= { ARZ, NullS }; return ext; }
|
||||
{ static const char *ext[]= { ARZ, ARN, NullS }; return ext; }
|
||||
|
||||
|
||||
/*
|
||||
|
@ -322,6 +322,11 @@ err:
|
|||
/*
|
||||
Look at ha_archive::open() for an explanation of the row format.
|
||||
Here we just write out the row.
|
||||
|
||||
Wondering about start_bulk_insert()? We don't implement it for
|
||||
archive since it optimizes for lots of writes. The only save
|
||||
for implementing start_bulk_insert() is that we could skip
|
||||
setting dirty to true each time.
|
||||
*/
|
||||
int ha_archive::write_row(byte * buf)
|
||||
{
|
||||
|
@ -380,17 +385,7 @@ int ha_archive::rnd_init(bool scan)
|
|||
pthread_mutex_lock(&share->mutex);
|
||||
if (share->dirty == TRUE)
|
||||
{
|
||||
/* I was having problems with OSX, but it worked for 10.3 so I am wrapping this with and ifdef */
|
||||
#ifdef BROKEN_GZFLUSH
|
||||
gzclose(share->archive_write);
|
||||
if ((share->archive_write= gzopen(share->data_file_name, "ab")) == NULL)
|
||||
{
|
||||
pthread_mutex_unlock(&share->mutex);
|
||||
DBUG_RETURN(errno ? errno : -1);
|
||||
}
|
||||
#else
|
||||
gzflush(share->archive_write, Z_SYNC_FLUSH);
|
||||
#endif
|
||||
share->dirty= FALSE;
|
||||
}
|
||||
pthread_mutex_unlock(&share->mutex);
|
||||
|
@ -504,6 +499,54 @@ int ha_archive::rnd_pos(byte * buf, byte *pos)
|
|||
DBUG_RETURN(get_row(buf));
|
||||
}
|
||||
|
||||
/*
|
||||
The table can become fragmented if data was inserted, read, and then
|
||||
inserted again. What we do is open up the file and recompress it completely.
|
||||
*/
|
||||
int ha_archive::optimize(THD* thd, HA_CHECK_OPT* check_opt)
|
||||
{
|
||||
DBUG_ENTER("ha_archive::optimize");
|
||||
int read; // Bytes read, gzread() returns int
|
||||
gzFile reader, writer;
|
||||
char block[IO_SIZE];
|
||||
char writer_filename[FN_REFLEN];
|
||||
|
||||
/* Lets create a file to contain the new data */
|
||||
fn_format(writer_filename,share->table_name,"",ARN, MY_REPLACE_EXT|MY_UNPACK_FILENAME);
|
||||
|
||||
/* Closing will cause all data waiting to be flushed, to be flushed */
|
||||
gzclose(share->archive_write);
|
||||
|
||||
if ((reader= gzopen(share->data_file_name, "rb")) == NULL)
|
||||
DBUG_RETURN(-1);
|
||||
|
||||
if ((writer= gzopen(writer_filename, "wb")) == NULL)
|
||||
{
|
||||
gzclose(reader);
|
||||
DBUG_RETURN(-1);
|
||||
}
|
||||
|
||||
while (read= gzread(reader, block, IO_SIZE))
|
||||
gzwrite(writer, block, read);
|
||||
|
||||
gzclose(reader);
|
||||
gzclose(writer);
|
||||
|
||||
my_rename(writer_filename,share->data_file_name,MYF(0));
|
||||
|
||||
/*
|
||||
We reopen the file in case some IO is waiting to go through.
|
||||
In theory the table is closed right after this operation,
|
||||
but it is possible for IO to still happen.
|
||||
I may be being a bit too paranoid right here.
|
||||
*/
|
||||
if ((share->archive_write= gzopen(share->data_file_name, "ab")) == NULL)
|
||||
DBUG_RETURN(errno ? errno : -1);
|
||||
share->dirty= FALSE;
|
||||
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
|
||||
Everything below here is default, please look at ha_example.cc for
|
||||
|
|
|
@ -112,7 +112,7 @@ public:
|
|||
int external_lock(THD *thd, int lock_type);
|
||||
ha_rows records_in_range(uint inx, key_range *min_key, key_range *max_key);
|
||||
int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info);
|
||||
|
||||
int optimize(THD* thd, HA_CHECK_OPT* check_opt);
|
||||
THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
|
||||
enum thr_lock_type lock_type);
|
||||
};
|
||||
|
|
|
@ -4300,8 +4300,9 @@ int Field_str::store(double nr)
|
|||
uint length;
|
||||
bool use_scientific_notation= TRUE;
|
||||
use_scientific_notation= TRUE;
|
||||
if (field_length < 32 && fabs(nr) < log_10[field_length]-1)
|
||||
if (field_length < 32 && fabs(nr) < log_10[field_length]-1)
|
||||
use_scientific_notation= FALSE;
|
||||
|
||||
length= (uint) my_sprintf(buff, (buff, "%-.*g",
|
||||
(use_scientific_notation ?
|
||||
max(0, (int)field_length-5) :
|
||||
|
|
|
@ -122,6 +122,8 @@ static const err_code_mapping err_map[]=
|
|||
{ 827, HA_ERR_RECORD_FILE_FULL },
|
||||
{ 832, HA_ERR_RECORD_FILE_FULL },
|
||||
|
||||
{ 0, 1 },
|
||||
|
||||
{ -1, -1 }
|
||||
};
|
||||
|
||||
|
@ -173,7 +175,7 @@ void ha_ndbcluster::records_update()
|
|||
DBUG_PRINT("info", ("id=%d, no_uncommitted_rows_count=%d",
|
||||
((const NDBTAB *)m_table)->getTableId(),
|
||||
info->no_uncommitted_rows_count));
|
||||
if (info->records == ~(ha_rows)0)
|
||||
// if (info->records == ~(ha_rows)0)
|
||||
{
|
||||
Uint64 rows;
|
||||
if(ndb_get_table_statistics(m_ndb, m_tabname, &rows, 0) == 0){
|
||||
|
@ -246,8 +248,6 @@ int ha_ndbcluster::ndb_err(NdbConnection *trans)
|
|||
{
|
||||
int res;
|
||||
const NdbError err= trans->getNdbError();
|
||||
if (!err.code)
|
||||
return 0; // Don't log things to DBUG log if no error
|
||||
DBUG_ENTER("ndb_err");
|
||||
|
||||
ERR_PRINT(err);
|
||||
|
@ -283,10 +283,11 @@ bool ha_ndbcluster::get_error_message(int error,
|
|||
DBUG_ENTER("ha_ndbcluster::get_error_message");
|
||||
DBUG_PRINT("enter", ("error: %d", error));
|
||||
|
||||
if (!m_ndb)
|
||||
Ndb *ndb= ((Thd_ndb*)current_thd->transaction.thd_ndb)->ndb;
|
||||
if (!ndb)
|
||||
DBUG_RETURN(false);
|
||||
|
||||
const NdbError err= m_ndb->getNdbError(error);
|
||||
const NdbError err= ndb->getNdbError(error);
|
||||
bool temporary= err.status==NdbError::TemporaryError;
|
||||
buf->set(err.message, strlen(err.message), &my_charset_bin);
|
||||
DBUG_PRINT("exit", ("message: %s, temporary: %d", buf->ptr(), temporary));
|
||||
|
@ -516,7 +517,7 @@ int ha_ndbcluster::get_ndb_blobs_value(NdbBlob *last_ndb_blob)
|
|||
*/
|
||||
|
||||
int ha_ndbcluster::get_ndb_value(NdbOperation *ndb_op, Field *field,
|
||||
uint fieldnr)
|
||||
uint fieldnr, byte* buf)
|
||||
{
|
||||
DBUG_ENTER("get_ndb_value");
|
||||
DBUG_PRINT("enter", ("fieldnr: %d flags: %o", fieldnr,
|
||||
|
@ -524,12 +525,15 @@ int ha_ndbcluster::get_ndb_value(NdbOperation *ndb_op, Field *field,
|
|||
|
||||
if (field != NULL)
|
||||
{
|
||||
DBUG_ASSERT(buf);
|
||||
if (ndb_supported_type(field->type()))
|
||||
{
|
||||
DBUG_ASSERT(field->ptr != NULL);
|
||||
if (! (field->flags & BLOB_FLAG))
|
||||
{
|
||||
m_value[fieldnr].rec= ndb_op->getValue(fieldnr, field->ptr);
|
||||
{
|
||||
byte *field_buf= buf + (field->ptr - table->record[0]);
|
||||
m_value[fieldnr].rec= ndb_op->getValue(fieldnr,
|
||||
field_buf);
|
||||
DBUG_RETURN(m_value[fieldnr].rec == NULL);
|
||||
}
|
||||
|
||||
|
@ -603,7 +607,7 @@ int ha_ndbcluster::get_metadata(const char *path)
|
|||
DBUG_ENTER("get_metadata");
|
||||
DBUG_PRINT("enter", ("m_tabname: %s, path: %s", m_tabname, path));
|
||||
|
||||
if (!(tab= dict->getTable(m_tabname, &m_table_info)))
|
||||
if (!(tab= dict->getTable(m_tabname)))
|
||||
ERR_RETURN(dict->getNdbError());
|
||||
DBUG_PRINT("info", ("Table schema version: %d", tab->getObjectVersion()));
|
||||
|
||||
|
@ -651,8 +655,8 @@ int ha_ndbcluster::get_metadata(const char *path)
|
|||
if (error)
|
||||
DBUG_RETURN(error);
|
||||
|
||||
// All checks OK, lets use the table
|
||||
m_table= (void*)tab;
|
||||
m_table= NULL;
|
||||
m_table_info= NULL;
|
||||
|
||||
DBUG_RETURN(build_index_list(table, ILBP_OPEN));
|
||||
}
|
||||
|
@ -767,6 +771,7 @@ void ha_ndbcluster::release_metadata()
|
|||
DBUG_PRINT("enter", ("m_tabname: %s", m_tabname));
|
||||
|
||||
m_table= NULL;
|
||||
m_table_info= NULL;
|
||||
|
||||
// Release index list
|
||||
for (i= 0; i < MAX_KEY; i++)
|
||||
|
@ -947,7 +952,7 @@ int ha_ndbcluster::pk_read(const byte *key, uint key_len, byte *buf)
|
|||
ERR_RETURN(trans->getNdbError());
|
||||
|
||||
// Read key at the same time, for future reference
|
||||
if (get_ndb_value(op, NULL, no_fields))
|
||||
if (get_ndb_value(op, NULL, no_fields, NULL))
|
||||
ERR_RETURN(trans->getNdbError());
|
||||
}
|
||||
else
|
||||
|
@ -964,7 +969,7 @@ int ha_ndbcluster::pk_read(const byte *key, uint key_len, byte *buf)
|
|||
if ((thd->query_id == field->query_id) ||
|
||||
retrieve_all_fields)
|
||||
{
|
||||
if (get_ndb_value(op, field, i))
|
||||
if (get_ndb_value(op, field, i, buf))
|
||||
ERR_RETURN(trans->getNdbError());
|
||||
}
|
||||
else
|
||||
|
@ -1018,7 +1023,7 @@ int ha_ndbcluster::complemented_pk_read(const byte *old_data, byte *new_data)
|
|||
if (!(field->flags & PRI_KEY_FLAG) &&
|
||||
(thd->query_id != field->query_id))
|
||||
{
|
||||
if (get_ndb_value(op, field, i))
|
||||
if (get_ndb_value(op, field, i, new_data))
|
||||
ERR_RETURN(trans->getNdbError());
|
||||
}
|
||||
}
|
||||
|
@ -1081,7 +1086,7 @@ int ha_ndbcluster::unique_index_read(const byte *key,
|
|||
if ((thd->query_id == field->query_id) ||
|
||||
(field->flags & PRI_KEY_FLAG))
|
||||
{
|
||||
if (get_ndb_value(op, field, i))
|
||||
if (get_ndb_value(op, field, i, buf))
|
||||
ERR_RETURN(op->getNdbError());
|
||||
}
|
||||
else
|
||||
|
@ -1480,7 +1485,7 @@ int ha_ndbcluster::define_read_attrs(byte* buf, NdbOperation* op)
|
|||
(field->flags & PRI_KEY_FLAG) ||
|
||||
retrieve_all_fields)
|
||||
{
|
||||
if (get_ndb_value(op, field, i))
|
||||
if (get_ndb_value(op, field, i, buf))
|
||||
ERR_RETURN(op->getNdbError());
|
||||
}
|
||||
else
|
||||
|
@ -1499,7 +1504,7 @@ int ha_ndbcluster::define_read_attrs(byte* buf, NdbOperation* op)
|
|||
if (!tab->getColumn(hidden_no))
|
||||
DBUG_RETURN(1);
|
||||
#endif
|
||||
if (get_ndb_value(op, NULL, hidden_no))
|
||||
if (get_ndb_value(op, NULL, hidden_no, NULL))
|
||||
ERR_RETURN(op->getNdbError());
|
||||
}
|
||||
|
||||
|
@ -1521,6 +1526,11 @@ int ha_ndbcluster::write_row(byte *record)
|
|||
NdbOperation *op;
|
||||
int res;
|
||||
DBUG_ENTER("write_row");
|
||||
|
||||
if(m_ignore_dup_key_not_supported)
|
||||
{
|
||||
DBUG_RETURN(HA_ERR_WRONG_COMMAND);
|
||||
}
|
||||
|
||||
statistic_increment(ha_write_count,&LOCK_status);
|
||||
if (table->timestamp_default_now)
|
||||
|
@ -2385,7 +2395,17 @@ void ha_ndbcluster::info(uint flag)
|
|||
if (flag & HA_STATUS_VARIABLE)
|
||||
{
|
||||
DBUG_PRINT("info", ("HA_STATUS_VARIABLE"));
|
||||
records_update();
|
||||
if (m_table_info)
|
||||
{
|
||||
records_update();
|
||||
}
|
||||
else
|
||||
{
|
||||
Uint64 rows;
|
||||
if(ndb_get_table_statistics(m_ndb, m_tabname, &rows, 0) == 0){
|
||||
records= rows;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (flag & HA_STATUS_ERRKEY)
|
||||
{
|
||||
|
@ -2479,14 +2499,20 @@ int ha_ndbcluster::extra(enum ha_extra_function operation)
|
|||
break;
|
||||
case HA_EXTRA_IGNORE_DUP_KEY: /* Dup keys don't rollback everything*/
|
||||
DBUG_PRINT("info", ("HA_EXTRA_IGNORE_DUP_KEY"));
|
||||
|
||||
DBUG_PRINT("info", ("Turning ON use of write instead of insert"));
|
||||
m_use_write= TRUE;
|
||||
if (current_thd->lex->sql_command == SQLCOM_REPLACE)
|
||||
{
|
||||
DBUG_PRINT("info", ("Turning ON use of write instead of insert"));
|
||||
m_use_write= TRUE;
|
||||
} else
|
||||
{
|
||||
m_ignore_dup_key_not_supported= TRUE;
|
||||
}
|
||||
break;
|
||||
case HA_EXTRA_NO_IGNORE_DUP_KEY:
|
||||
DBUG_PRINT("info", ("HA_EXTRA_NO_IGNORE_DUP_KEY"));
|
||||
DBUG_PRINT("info", ("Turning OFF use of write instead of insert"));
|
||||
m_use_write= false;
|
||||
m_ignore_dup_key_not_supported= false;
|
||||
break;
|
||||
case HA_EXTRA_RETRIEVE_ALL_COLS: /* Retrieve all columns, not just those
|
||||
where field->query_id is the same as
|
||||
|
@ -2766,6 +2792,16 @@ int ha_ndbcluster::external_lock(THD *thd, int lock_type)
|
|||
// Start of transaction
|
||||
retrieve_all_fields= FALSE;
|
||||
ops_pending= 0;
|
||||
{
|
||||
NDBDICT *dict= m_ndb->getDictionary();
|
||||
const NDBTAB *tab;
|
||||
void *tab_info;
|
||||
if (!(tab= dict->getTable(m_tabname, &tab_info)))
|
||||
ERR_RETURN(dict->getNdbError());
|
||||
DBUG_PRINT("info", ("Table schema version: %d", tab->getObjectVersion()));
|
||||
m_table= (void *)tab;
|
||||
m_table_info= tab_info;
|
||||
}
|
||||
no_uncommitted_rows_init(thd);
|
||||
}
|
||||
else
|
||||
|
@ -2788,6 +2824,8 @@ int ha_ndbcluster::external_lock(THD *thd, int lock_type)
|
|||
thd->transaction.stmt.ndb_tid= 0;
|
||||
}
|
||||
}
|
||||
m_table= NULL;
|
||||
m_table_info= NULL;
|
||||
if (m_active_trans)
|
||||
DBUG_PRINT("warning", ("m_active_trans != NULL"));
|
||||
if (m_active_cursor)
|
||||
|
@ -3273,6 +3311,7 @@ int ha_ndbcluster::alter_table_name(const char *from, const char *to)
|
|||
ERR_RETURN(dict->getNdbError());
|
||||
|
||||
m_table= NULL;
|
||||
m_table_info= NULL;
|
||||
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
@ -3364,6 +3403,7 @@ ha_ndbcluster::ha_ndbcluster(TABLE *table_arg):
|
|||
HA_NO_PREFIX_CHAR_KEYS),
|
||||
m_share(0),
|
||||
m_use_write(false),
|
||||
m_ignore_dup_key_not_supported(false),
|
||||
retrieve_all_fields(FALSE),
|
||||
rows_to_insert(1),
|
||||
rows_inserted(0),
|
||||
|
|
|
@ -211,7 +211,7 @@ class ha_ndbcluster: public handler
|
|||
int set_ndb_key(NdbOperation*, Field *field,
|
||||
uint fieldnr, const byte* field_ptr);
|
||||
int set_ndb_value(NdbOperation*, Field *field, uint fieldnr);
|
||||
int get_ndb_value(NdbOperation*, Field *field, uint fieldnr);
|
||||
int get_ndb_value(NdbOperation*, Field *field, uint fieldnr, byte*);
|
||||
friend int g_get_ndb_blobs_value(NdbBlob *ndb_blob, void *arg);
|
||||
int get_ndb_blobs_value(NdbBlob *last_ndb_blob);
|
||||
int set_primary_key(NdbOperation *op, const byte *key);
|
||||
|
@ -245,6 +245,7 @@ class ha_ndbcluster: public handler
|
|||
typedef union { NdbRecAttr *rec; NdbBlob *blob; void *ptr; } NdbValue;
|
||||
NdbValue m_value[NDB_MAX_ATTRIBUTES_IN_TABLE];
|
||||
bool m_use_write;
|
||||
bool m_ignore_dup_key_not_supported;
|
||||
bool retrieve_all_fields;
|
||||
ha_rows rows_to_insert;
|
||||
ha_rows rows_inserted;
|
||||
|
|
|
@ -891,7 +891,7 @@ int Item_param::save_in_field(Field *field, bool no_conversions)
|
|||
return field->store(str_value.ptr(), str_value.length(),
|
||||
str_value.charset());
|
||||
case NULL_VALUE:
|
||||
return set_field_to_null(field);
|
||||
return set_field_to_null_with_conversions(field, no_conversions);
|
||||
case NO_VALUE:
|
||||
default:
|
||||
DBUG_ASSERT(0);
|
||||
|
|
|
@ -188,17 +188,27 @@ void Item_bool_func2::fix_length_and_dec()
|
|||
{
|
||||
uint strong= 0;
|
||||
uint weak= 0;
|
||||
uint32 dummy_offset;
|
||||
DTCollation coll;
|
||||
|
||||
if (args[0]->result_type() == STRING_RESULT &&
|
||||
args[1]->result_type() == STRING_RESULT &&
|
||||
!my_charset_same(args[0]->collation.collation,
|
||||
args[1]->collation.collation) &&
|
||||
String::needs_conversion(0, args[0]->collation.collation,
|
||||
args[1]->collation.collation,
|
||||
&dummy_offset) &&
|
||||
!coll.set(args[0]->collation, args[1]->collation, TRUE))
|
||||
{
|
||||
Item* conv= 0;
|
||||
THD *thd= current_thd;
|
||||
Item_arena *arena= thd->current_arena, backup;
|
||||
strong= coll.strong;
|
||||
weak= strong ? 0 : 1;
|
||||
/*
|
||||
In case we're in statement prepare, create conversion item
|
||||
in its memory: it will be reused on each execute.
|
||||
*/
|
||||
if (arena->is_stmt_prepare())
|
||||
thd->set_n_backup_item_arena(arena, &backup);
|
||||
if (args[weak]->type() == STRING_ITEM)
|
||||
{
|
||||
String tmp, cstr;
|
||||
|
@ -211,21 +221,13 @@ void Item_bool_func2::fix_length_and_dec()
|
|||
}
|
||||
else
|
||||
{
|
||||
THD *thd= current_thd;
|
||||
/*
|
||||
In case we're in statement prepare, create conversion item
|
||||
in its memory: it will be reused on each execute.
|
||||
*/
|
||||
Item_arena *arena= thd->current_arena, backup;
|
||||
if (arena->is_stmt_prepare())
|
||||
thd->set_n_backup_item_arena(arena, &backup);
|
||||
conv= new Item_func_conv_charset(args[weak],
|
||||
args[strong]->collation.collation);
|
||||
if (arena->is_stmt_prepare())
|
||||
thd->restore_backup_item_arena(arena, &backup);
|
||||
conv->collation.set(args[weak]->collation.derivation);
|
||||
conv->fix_fields(thd, 0, &conv);
|
||||
}
|
||||
if (arena->is_stmt_prepare())
|
||||
thd->restore_backup_item_arena(arena, &backup);
|
||||
args[weak]= conv ? conv : args[weak];
|
||||
}
|
||||
}
|
||||
|
|
|
@ -27,6 +27,13 @@
|
|||
#include "sql_acl.h"
|
||||
#include <m_ctype.h>
|
||||
|
||||
void Item_geometry_func::fix_length_and_dec()
|
||||
{
|
||||
collation.set(&my_charset_bin);
|
||||
decimals=0;
|
||||
max_length=MAX_BLOB_WIDTH;
|
||||
}
|
||||
|
||||
|
||||
String *Item_func_geometry_from_text::val_str(String *str)
|
||||
{
|
||||
|
@ -44,6 +51,7 @@ String *Item_func_geometry_from_text::val_str(String *str)
|
|||
if ((arg_count == 2) && !args[1]->null_value)
|
||||
srid= (uint32)args[1]->val_int();
|
||||
|
||||
str->set_charset(&my_charset_bin);
|
||||
if (str->reserve(SRID_SIZE, 512))
|
||||
return 0;
|
||||
str->length(0);
|
||||
|
@ -54,12 +62,6 @@ String *Item_func_geometry_from_text::val_str(String *str)
|
|||
}
|
||||
|
||||
|
||||
void Item_func_geometry_from_text::fix_length_and_dec()
|
||||
{
|
||||
max_length=MAX_BLOB_WIDTH;
|
||||
}
|
||||
|
||||
|
||||
String *Item_func_geometry_from_wkb::val_str(String *str)
|
||||
{
|
||||
DBUG_ASSERT(fixed == 1);
|
||||
|
@ -71,6 +73,7 @@ String *Item_func_geometry_from_wkb::val_str(String *str)
|
|||
if ((arg_count == 2) && !args[1]->null_value)
|
||||
srid= (uint32)args[1]->val_int();
|
||||
|
||||
str->set_charset(&my_charset_bin);
|
||||
if (str->reserve(SRID_SIZE, 512))
|
||||
return 0;
|
||||
str->length(0);
|
||||
|
@ -84,12 +87,6 @@ String *Item_func_geometry_from_wkb::val_str(String *str)
|
|||
}
|
||||
|
||||
|
||||
void Item_func_geometry_from_wkb::fix_length_and_dec()
|
||||
{
|
||||
max_length=MAX_BLOB_WIDTH;
|
||||
}
|
||||
|
||||
|
||||
String *Item_func_as_wkt::val_str(String *str)
|
||||
{
|
||||
DBUG_ASSERT(fixed == 1);
|
||||
|
@ -138,12 +135,6 @@ String *Item_func_as_wkb::val_str(String *str)
|
|||
}
|
||||
|
||||
|
||||
void Item_func_as_wkb::fix_length_and_dec()
|
||||
{
|
||||
max_length= MAX_BLOB_WIDTH;
|
||||
}
|
||||
|
||||
|
||||
String *Item_func_geometry_type::val_str(String *str)
|
||||
{
|
||||
DBUG_ASSERT(fixed == 1);
|
||||
|
@ -180,6 +171,7 @@ String *Item_func_envelope::val_str(String *str)
|
|||
return 0;
|
||||
|
||||
srid= uint4korr(swkb->ptr());
|
||||
str->set_charset(&my_charset_bin);
|
||||
str->length(0);
|
||||
if (str->reserve(SRID_SIZE, 512))
|
||||
return 0;
|
||||
|
@ -202,6 +194,7 @@ String *Item_func_centroid::val_str(String *str)
|
|||
swkb->length() - SRID_SIZE))))
|
||||
return 0;
|
||||
|
||||
str->set_charset(&my_charset_bin);
|
||||
if (str->reserve(SRID_SIZE, 512))
|
||||
return 0;
|
||||
str->length(0);
|
||||
|
@ -232,6 +225,7 @@ String *Item_func_spatial_decomp::val_str(String *str)
|
|||
return 0;
|
||||
|
||||
srid= uint4korr(swkb->ptr());
|
||||
str->set_charset(&my_charset_bin);
|
||||
if (str->reserve(SRID_SIZE, 512))
|
||||
goto err;
|
||||
str->length(0);
|
||||
|
@ -279,6 +273,7 @@ String *Item_func_spatial_decomp_n::val_str(String *str)
|
|||
swkb->length() - SRID_SIZE)))))
|
||||
return 0;
|
||||
|
||||
str->set_charset(&my_charset_bin);
|
||||
if (str->reserve(SRID_SIZE, 512))
|
||||
goto err;
|
||||
srid= uint4korr(swkb->ptr());
|
||||
|
@ -333,6 +328,7 @@ String *Item_func_point::val_str(String *str)
|
|||
str->realloc(1 + 4 + SIZEOF_STORED_DOUBLE*2))))
|
||||
return 0;
|
||||
|
||||
str->set_charset(&my_charset_bin);
|
||||
str->length(0);
|
||||
str->q_append((char)Geometry::wkb_ndr);
|
||||
str->q_append((uint32)Geometry::wkb_point);
|
||||
|
@ -358,6 +354,7 @@ String *Item_func_spatial_collection::val_str(String *str)
|
|||
String arg_value;
|
||||
uint i;
|
||||
|
||||
str->set_charset(&my_charset_bin);
|
||||
str->length(0);
|
||||
if (str->reserve(1 + 4 + 4, 512))
|
||||
goto err;
|
||||
|
|
|
@ -23,24 +23,33 @@
|
|||
#pragma interface /* gcc class implementation */
|
||||
#endif
|
||||
|
||||
class Item_func_geometry_from_text: public Item_str_func
|
||||
class Item_geometry_func: public Item_str_func
|
||||
{
|
||||
public:
|
||||
Item_func_geometry_from_text(Item *a) :Item_str_func(a) {}
|
||||
Item_func_geometry_from_text(Item *a, Item *srid) :Item_str_func(a, srid) {}
|
||||
const char *func_name() const { return "geometryfromtext"; }
|
||||
String *val_str(String *);
|
||||
Item_geometry_func() :Item_str_func() {}
|
||||
Item_geometry_func(Item *a) :Item_str_func(a) {}
|
||||
Item_geometry_func(Item *a,Item *b) :Item_str_func(a,b) {}
|
||||
Item_geometry_func(Item *a,Item *b,Item *c) :Item_str_func(a,b,c) {}
|
||||
Item_geometry_func(List<Item> &list) :Item_str_func(list) {}
|
||||
void fix_length_and_dec();
|
||||
};
|
||||
|
||||
class Item_func_geometry_from_wkb: public Item_str_func
|
||||
class Item_func_geometry_from_text: public Item_geometry_func
|
||||
{
|
||||
public:
|
||||
Item_func_geometry_from_wkb(Item *a): Item_str_func(a) {}
|
||||
Item_func_geometry_from_wkb(Item *a, Item *srid): Item_str_func(a, srid) {}
|
||||
Item_func_geometry_from_text(Item *a) :Item_geometry_func(a) {}
|
||||
Item_func_geometry_from_text(Item *a, Item *srid) :Item_geometry_func(a, srid) {}
|
||||
const char *func_name() const { return "geometryfromtext"; }
|
||||
String *val_str(String *);
|
||||
};
|
||||
|
||||
class Item_func_geometry_from_wkb: public Item_geometry_func
|
||||
{
|
||||
public:
|
||||
Item_func_geometry_from_wkb(Item *a): Item_geometry_func(a) {}
|
||||
Item_func_geometry_from_wkb(Item *a, Item *srid): Item_geometry_func(a, srid) {}
|
||||
const char *func_name() const { return "geometryfromwkb"; }
|
||||
String *val_str(String *);
|
||||
void fix_length_and_dec();
|
||||
};
|
||||
|
||||
class Item_func_as_wkt: public Item_str_func
|
||||
|
@ -52,13 +61,12 @@ public:
|
|||
void fix_length_and_dec();
|
||||
};
|
||||
|
||||
class Item_func_as_wkb: public Item_str_func
|
||||
class Item_func_as_wkb: public Item_geometry_func
|
||||
{
|
||||
public:
|
||||
Item_func_as_wkb(Item *a): Item_str_func(a) {}
|
||||
Item_func_as_wkb(Item *a): Item_geometry_func(a) {}
|
||||
const char *func_name() const { return "aswkb"; }
|
||||
String *val_str(String *);
|
||||
void fix_length_and_dec();
|
||||
};
|
||||
|
||||
class Item_func_geometry_type: public Item_str_func
|
||||
|
@ -73,40 +81,37 @@ public:
|
|||
};
|
||||
};
|
||||
|
||||
class Item_func_centroid: public Item_str_func
|
||||
class Item_func_centroid: public Item_geometry_func
|
||||
{
|
||||
public:
|
||||
Item_func_centroid(Item *a): Item_str_func(a) {}
|
||||
Item_func_centroid(Item *a): Item_geometry_func(a) {}
|
||||
const char *func_name() const { return "centroid"; }
|
||||
String *val_str(String *);
|
||||
void fix_length_and_dec(){max_length=MAX_BLOB_WIDTH;}
|
||||
};
|
||||
|
||||
class Item_func_envelope: public Item_str_func
|
||||
class Item_func_envelope: public Item_geometry_func
|
||||
{
|
||||
public:
|
||||
Item_func_envelope(Item *a): Item_str_func(a) {}
|
||||
Item_func_envelope(Item *a): Item_geometry_func(a) {}
|
||||
const char *func_name() const { return "envelope"; }
|
||||
String *val_str(String *);
|
||||
void fix_length_and_dec(){max_length=MAX_BLOB_WIDTH;}
|
||||
};
|
||||
|
||||
class Item_func_point: public Item_str_func
|
||||
class Item_func_point: public Item_geometry_func
|
||||
{
|
||||
public:
|
||||
Item_func_point(Item *a, Item *b): Item_str_func(a, b) {}
|
||||
Item_func_point(Item *a, Item *b, Item *srid): Item_str_func(a, b, srid) {}
|
||||
Item_func_point(Item *a, Item *b): Item_geometry_func(a, b) {}
|
||||
Item_func_point(Item *a, Item *b, Item *srid): Item_geometry_func(a, b, srid) {}
|
||||
const char *func_name() const { return "point"; }
|
||||
String *val_str(String *);
|
||||
void fix_length_and_dec(){max_length=MAX_BLOB_WIDTH;}
|
||||
};
|
||||
|
||||
class Item_func_spatial_decomp: public Item_str_func
|
||||
class Item_func_spatial_decomp: public Item_geometry_func
|
||||
{
|
||||
enum Functype decomp_func;
|
||||
public:
|
||||
Item_func_spatial_decomp(Item *a, Item_func::Functype ft) :
|
||||
Item_str_func(a) { decomp_func = ft; }
|
||||
Item_geometry_func(a) { decomp_func = ft; }
|
||||
const char *func_name() const
|
||||
{
|
||||
switch (decomp_func)
|
||||
|
@ -123,15 +128,14 @@ public:
|
|||
}
|
||||
}
|
||||
String *val_str(String *);
|
||||
void fix_length_and_dec(){max_length=MAX_BLOB_WIDTH;}
|
||||
};
|
||||
|
||||
class Item_func_spatial_decomp_n: public Item_str_func
|
||||
class Item_func_spatial_decomp_n: public Item_geometry_func
|
||||
{
|
||||
enum Functype decomp_func_n;
|
||||
public:
|
||||
Item_func_spatial_decomp_n(Item *a, Item *b, Item_func::Functype ft):
|
||||
Item_str_func(a, b) { decomp_func_n = ft; }
|
||||
Item_geometry_func(a, b) { decomp_func_n = ft; }
|
||||
const char *func_name() const
|
||||
{
|
||||
switch (decomp_func_n)
|
||||
|
@ -148,10 +152,9 @@ public:
|
|||
}
|
||||
}
|
||||
String *val_str(String *);
|
||||
void fix_length_and_dec(){max_length=MAX_BLOB_WIDTH;}
|
||||
};
|
||||
|
||||
class Item_func_spatial_collection: public Item_str_func
|
||||
class Item_func_spatial_collection: public Item_geometry_func
|
||||
{
|
||||
String tmp_value;
|
||||
enum Geometry::wkbType coll_type;
|
||||
|
@ -159,13 +162,12 @@ class Item_func_spatial_collection: public Item_str_func
|
|||
public:
|
||||
Item_func_spatial_collection(
|
||||
List<Item> &list, enum Geometry::wkbType ct, enum Geometry::wkbType it):
|
||||
Item_str_func(list)
|
||||
Item_geometry_func(list)
|
||||
{
|
||||
coll_type=ct;
|
||||
item_type=it;
|
||||
}
|
||||
String *val_str(String *);
|
||||
void fix_length_and_dec(){max_length=MAX_BLOB_WIDTH;}
|
||||
const char *func_name() const { return "multipoint"; }
|
||||
};
|
||||
|
||||
|
|
|
@ -1091,7 +1091,15 @@ end:
|
|||
VOID(pthread_mutex_unlock(&LOCK_thread_count));
|
||||
close_thread_tables(thd);
|
||||
free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
|
||||
return (thd->query_error ? thd->query_error : Log_event::exec_event(rli));
|
||||
/*
|
||||
If there was an error we stop. Otherwise we increment positions. Note that
|
||||
we will not increment group* positions if we are just after a SET
|
||||
ONE_SHOT, because SET ONE_SHOT should not be separated from its following
|
||||
updating query.
|
||||
*/
|
||||
return (thd->query_error ? thd->query_error :
|
||||
(thd->one_shot_set ? (rli->inc_event_relay_log_pos(get_event_len()),0) :
|
||||
Log_event::exec_event(rli)));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
@ -2554,7 +2554,8 @@ static bool null_part_in_key(KEY_PART *key_part, const char *key, uint length)
|
|||
|
||||
QUICK_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table, TABLE_REF *ref)
|
||||
{
|
||||
QUICK_SELECT *quick=new QUICK_SELECT(thd, table, ref->key, 1);
|
||||
MEM_ROOT *old_root= my_pthread_getspecific_ptr(MEM_ROOT*, THR_MALLOC);
|
||||
QUICK_SELECT *quick= new QUICK_SELECT(thd, table, ref->key);
|
||||
KEY *key_info = &table->key_info[ref->key];
|
||||
KEY_PART *key_part;
|
||||
QUICK_RANGE *range;
|
||||
|
@ -2566,7 +2567,7 @@ QUICK_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table, TABLE_REF *ref)
|
|||
{
|
||||
if (thd->is_fatal_error)
|
||||
goto err; // out of memory
|
||||
return quick; // empty range
|
||||
goto ok; // empty range
|
||||
}
|
||||
|
||||
if (!(range= new QUICK_RANGE()))
|
||||
|
@ -2613,9 +2614,12 @@ QUICK_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table, TABLE_REF *ref)
|
|||
goto err;
|
||||
}
|
||||
|
||||
ok:
|
||||
my_pthread_setspecific_ptr(THR_MALLOC, old_root);
|
||||
return quick;
|
||||
|
||||
err:
|
||||
my_pthread_setspecific_ptr(THR_MALLOC, old_root);
|
||||
delete quick;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -221,7 +221,6 @@ THD::THD()
|
|||
|
||||
init();
|
||||
/* Initialize sub structures */
|
||||
clear_alloc_root(&transaction.mem_root);
|
||||
init_alloc_root(&warn_root, WARN_ALLOC_BLOCK_SIZE, WARN_ALLOC_PREALLOC_SIZE);
|
||||
user_connect=(USER_CONN *)0;
|
||||
hash_init(&user_vars, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0,
|
||||
|
@ -258,6 +257,7 @@ THD::THD()
|
|||
transaction.trans_log.end_of_file= max_binlog_cache_size;
|
||||
}
|
||||
#endif
|
||||
init_alloc_root(&transaction.mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
|
||||
{
|
||||
ulong tmp=sql_rnd_with_mutex();
|
||||
randominit(&rand, tmp + (ulong) &rand, tmp + (ulong) ::query_id);
|
||||
|
@ -303,12 +303,12 @@ void THD::init(void)
|
|||
void THD::init_for_queries()
|
||||
{
|
||||
ha_enable_transaction(this,TRUE);
|
||||
init_sql_alloc(&mem_root,
|
||||
variables.query_alloc_block_size,
|
||||
variables.query_prealloc_size);
|
||||
init_sql_alloc(&transaction.mem_root,
|
||||
variables.trans_alloc_block_size,
|
||||
variables.trans_prealloc_size);
|
||||
|
||||
reset_root_defaults(&mem_root, variables.query_alloc_block_size,
|
||||
variables.query_prealloc_size);
|
||||
reset_root_defaults(&transaction.mem_root,
|
||||
variables.trans_alloc_block_size,
|
||||
variables.trans_prealloc_size);
|
||||
}
|
||||
|
||||
|
||||
|
@ -328,6 +328,7 @@ void THD::change_user(void)
|
|||
cleanup();
|
||||
cleanup_done= 0;
|
||||
init();
|
||||
stmt_map.reset();
|
||||
hash_init(&user_vars, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0,
|
||||
(hash_get_key) get_var_key,
|
||||
(hash_free_key) free_user_var, 0);
|
||||
|
@ -1331,6 +1332,17 @@ void select_dumpvar::cleanup()
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
Create arena for already constructed THD.
|
||||
|
||||
SYNOPSYS
|
||||
Item_arena()
|
||||
thd - thread for which arena is created
|
||||
|
||||
DESCRIPTION
|
||||
Create arena for already existing THD using its variables as parameters
|
||||
for memory root initialization.
|
||||
*/
|
||||
Item_arena::Item_arena(THD* thd)
|
||||
:free_list(0),
|
||||
state(INITIALIZED)
|
||||
|
@ -1341,24 +1353,31 @@ Item_arena::Item_arena(THD* thd)
|
|||
}
|
||||
|
||||
|
||||
/* This constructor is called when Item_arena is a subobject of THD */
|
||||
/*
|
||||
Create arena and optionally initialize memory root.
|
||||
|
||||
Item_arena::Item_arena()
|
||||
SYNOPSYS
|
||||
Item_arena()
|
||||
init_mem_root - whenever we need to initialize memory root
|
||||
|
||||
DESCRIPTION
|
||||
Create arena and optionally initialize memory root with minimal
|
||||
possible parameters.
|
||||
|
||||
NOTE
|
||||
We use this constructor when arena is part of THD, but reinitialize
|
||||
its memory root in THD::init_for_queries() before execution of real
|
||||
statements.
|
||||
*/
|
||||
Item_arena::Item_arena(bool init_mem_root)
|
||||
:free_list(0),
|
||||
state(CONVENTIONAL_EXECUTION)
|
||||
{
|
||||
clear_alloc_root(&mem_root);
|
||||
}
|
||||
|
||||
|
||||
Item_arena::Item_arena(bool init_mem_root)
|
||||
:free_list(0),
|
||||
state(INITIALIZED)
|
||||
{
|
||||
if (init_mem_root)
|
||||
clear_alloc_root(&mem_root);
|
||||
init_alloc_root(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
|
||||
}
|
||||
|
||||
|
||||
Item_arena::Type Item_arena::type() const
|
||||
{
|
||||
DBUG_ASSERT("Item_arena::type()" == "abstract");
|
||||
|
@ -1366,10 +1385,6 @@ Item_arena::Type Item_arena::type() const
|
|||
}
|
||||
|
||||
|
||||
Item_arena::~Item_arena()
|
||||
{}
|
||||
|
||||
|
||||
/*
|
||||
Statement functions
|
||||
*/
|
||||
|
@ -1393,7 +1408,8 @@ Statement::Statement(THD *thd)
|
|||
*/
|
||||
|
||||
Statement::Statement()
|
||||
:id(0),
|
||||
:Item_arena((bool)TRUE),
|
||||
id(0),
|
||||
set_query_id(1),
|
||||
allow_sum_func(0), /* initialized later */
|
||||
lex(&main_lex),
|
||||
|
@ -1461,8 +1477,16 @@ void Item_arena::restore_backup_item_arena(Item_arena *set, Item_arena *backup)
|
|||
{
|
||||
set->set_item_arena(this);
|
||||
set_item_arena(backup);
|
||||
// reset backup mem_root to avoid its freeing
|
||||
init_alloc_root(&backup->mem_root, 0, 0);
|
||||
#ifdef NOT_NEEDED_NOW
|
||||
/*
|
||||
Reset backup mem_root to avoid its freeing.
|
||||
Since Item_arena's mem_root is freed only when it is part of Statement
|
||||
we need this only if we use some Statement's arena as backup storage.
|
||||
But we do this only with THD::stmt_backup and this Statement is specially
|
||||
handled in this respect. So this code is not really needed now.
|
||||
*/
|
||||
clear_alloc_root(&backup->mem_root);
|
||||
#endif
|
||||
}
|
||||
|
||||
void Item_arena::set_item_arena(Item_arena *set)
|
||||
|
|
|
@ -441,11 +441,23 @@ public:
|
|||
STATEMENT, PREPARED_STATEMENT, STORED_PROCEDURE
|
||||
};
|
||||
|
||||
/*
|
||||
This constructor is used only when Item_arena is created as
|
||||
backup storage for another instance of Item_arena.
|
||||
*/
|
||||
Item_arena() {};
|
||||
/*
|
||||
Create arena for already constructed THD using its variables as
|
||||
parameters for memory root initialization.
|
||||
*/
|
||||
Item_arena(THD *thd);
|
||||
Item_arena();
|
||||
/*
|
||||
Create arena and optionally init memory root with minimal values.
|
||||
Particularly used if Item_arena is part of Statement.
|
||||
*/
|
||||
Item_arena(bool init_mem_root);
|
||||
virtual Type type() const;
|
||||
virtual ~Item_arena();
|
||||
virtual ~Item_arena() {};
|
||||
|
||||
inline bool is_stmt_prepare() const { return (int)state < (int)PREPARED; }
|
||||
inline bool is_first_stmt_execute() const { return state == PREPARED; }
|
||||
|
@ -566,7 +578,7 @@ public:
|
|||
assignment in Statement::Statement)
|
||||
Non-empty statement names are unique too: attempt to insert a new statement
|
||||
with duplicate name causes older statement to be deleted
|
||||
|
||||
|
||||
Statements are auto-deleted when they are removed from the map and when the
|
||||
map is deleted.
|
||||
*/
|
||||
|
@ -575,7 +587,7 @@ class Statement_map
|
|||
{
|
||||
public:
|
||||
Statement_map();
|
||||
|
||||
|
||||
int insert(Statement *statement);
|
||||
|
||||
Statement *find_by_name(LEX_STRING *name)
|
||||
|
@ -608,11 +620,18 @@ public:
|
|||
}
|
||||
hash_delete(&st_hash, (byte *) statement);
|
||||
}
|
||||
/* Erase all statements (calls Statement destructor) */
|
||||
void reset()
|
||||
{
|
||||
hash_reset(&names_hash);
|
||||
hash_reset(&st_hash);
|
||||
last_found_statement= 0;
|
||||
}
|
||||
|
||||
~Statement_map()
|
||||
{
|
||||
hash_free(&st_hash);
|
||||
hash_free(&names_hash);
|
||||
hash_free(&st_hash);
|
||||
}
|
||||
private:
|
||||
HASH st_hash;
|
||||
|
|
|
@ -1265,6 +1265,8 @@ store_create_info(THD *thd, TABLE *table, String *packet)
|
|||
// check for surprises from the previous call to Field::sql_type()
|
||||
if (type.ptr() != tmp)
|
||||
type.set(tmp, sizeof(tmp), system_charset_info);
|
||||
else
|
||||
type.set_charset(system_charset_info);
|
||||
|
||||
field->sql_type(type);
|
||||
packet->append(type.ptr(), type.length(), system_charset_info);
|
||||
|
|
|
@ -6306,6 +6306,7 @@ static MY_CHARSET_HANDLER my_charset_big5_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -465,6 +465,7 @@ static MY_CHARSET_HANDLER my_charset_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -8673,6 +8673,7 @@ static MY_CHARSET_HANDLER my_charset_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -5724,6 +5724,7 @@ static MY_CHARSET_HANDLER my_charset_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -9955,6 +9955,7 @@ static MY_CHARSET_HANDLER my_charset_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -403,6 +403,7 @@ static MY_CHARSET_HANDLER my_charset_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -1283,6 +1283,12 @@ static my_bool my_coll_init_simple(CHARSET_INFO *cs,
|
|||
}
|
||||
|
||||
|
||||
longlong my_strtoll10_8bit(CHARSET_INFO *cs __attribute__((unused)),
|
||||
const char *nptr, char **endptr, int *error)
|
||||
{
|
||||
return my_strtoll10(nptr, endptr, error);
|
||||
}
|
||||
|
||||
|
||||
MY_CHARSET_HANDLER my_charset_8bit_handler=
|
||||
{
|
||||
|
@ -1309,6 +1315,7 @@ MY_CHARSET_HANDLER my_charset_8bit_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -4604,6 +4604,7 @@ static MY_CHARSET_HANDLER my_charset_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -946,6 +946,7 @@ static MY_CHARSET_HANDLER my_charset_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -18,6 +18,7 @@
|
|||
/* UCS2 support. Written by Alexander Barkov <bar@mysql.com> */
|
||||
|
||||
#include <my_global.h>
|
||||
#include <my_sys.h>
|
||||
#include "m_string.h"
|
||||
#include "m_ctype.h"
|
||||
#include <errno.h>
|
||||
|
@ -852,7 +853,6 @@ bs:
|
|||
return (negative ? -((longlong) res) : (longlong) res);
|
||||
}
|
||||
|
||||
|
||||
double my_strntod_ucs2(CHARSET_INFO *cs __attribute__((unused)),
|
||||
char *nptr, uint length,
|
||||
char **endptr, int *err)
|
||||
|
@ -1000,6 +1000,188 @@ cnv:
|
|||
}
|
||||
|
||||
|
||||
#undef ULONGLONG_MAX
|
||||
#define ULONGLONG_MAX (~(ulonglong) 0)
|
||||
#define MAX_NEGATIVE_NUMBER ((ulonglong) LL(0x8000000000000000))
|
||||
#define INIT_CNT 9
|
||||
#define LFACTOR ULL(1000000000)
|
||||
#define LFACTOR1 ULL(10000000000)
|
||||
#define LFACTOR2 ULL(100000000000)
|
||||
|
||||
static unsigned long lfactor[9]=
|
||||
{
|
||||
1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L
|
||||
};
|
||||
|
||||
|
||||
longlong my_strtoll10_ucs2(CHARSET_INFO *cs __attribute__((unused)),
|
||||
const char *nptr, char **endptr, int *error)
|
||||
{
|
||||
const char *s, *end, *start, *n_end, *true_end;
|
||||
unsigned char c;
|
||||
unsigned long i, j, k;
|
||||
ulonglong li;
|
||||
int negative;
|
||||
ulong cutoff, cutoff2, cutoff3;
|
||||
|
||||
s= nptr;
|
||||
/* If fixed length string */
|
||||
if (endptr)
|
||||
{
|
||||
/* Make sure string length is even */
|
||||
end= s + ((*endptr - s) / 2) * 2;
|
||||
while (s < end && !s[0] && (s[1] == ' ' || s[1] == '\t'))
|
||||
s+= 2;
|
||||
if (s == end)
|
||||
goto no_conv;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* We don't support null terminated strings in UCS2 */
|
||||
goto no_conv;
|
||||
}
|
||||
|
||||
/* Check for a sign. */
|
||||
negative= 0;
|
||||
if (!s[0] && s[1] == '-')
|
||||
{
|
||||
*error= -1; /* Mark as negative number */
|
||||
negative= 1;
|
||||
s+= 2;
|
||||
if (s == end)
|
||||
goto no_conv;
|
||||
cutoff= MAX_NEGATIVE_NUMBER / LFACTOR2;
|
||||
cutoff2= (MAX_NEGATIVE_NUMBER % LFACTOR2) / 100;
|
||||
cutoff3= MAX_NEGATIVE_NUMBER % 100;
|
||||
}
|
||||
else
|
||||
{
|
||||
*error= 0;
|
||||
if (!s[0] && s[1] == '+')
|
||||
{
|
||||
s+= 2;
|
||||
if (s == end)
|
||||
goto no_conv;
|
||||
}
|
||||
cutoff= ULONGLONG_MAX / LFACTOR2;
|
||||
cutoff2= ULONGLONG_MAX % LFACTOR2 / 100;
|
||||
cutoff3= ULONGLONG_MAX % 100;
|
||||
}
|
||||
|
||||
/* Handle case where we have a lot of pre-zero */
|
||||
if (!s[0] && s[1] == '0')
|
||||
{
|
||||
i= 0;
|
||||
do
|
||||
{
|
||||
s+= 2;
|
||||
if (s == end)
|
||||
goto end_i; /* Return 0 */
|
||||
}
|
||||
while (!s[0] && s[1] == '0');
|
||||
n_end= s + 2 * INIT_CNT;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Read first digit to check that it's a valid number */
|
||||
if (s[0] || (c= (s[1]-'0')) > 9)
|
||||
goto no_conv;
|
||||
i= c;
|
||||
s+= 2;
|
||||
n_end= s + 2 * (INIT_CNT-1);
|
||||
}
|
||||
|
||||
/* Handle first 9 digits and store them in i */
|
||||
if (n_end > end)
|
||||
n_end= end;
|
||||
for (; s != n_end ; s+= 2)
|
||||
{
|
||||
if (s[0] || (c= (s[1]-'0')) > 9)
|
||||
goto end_i;
|
||||
i= i*10+c;
|
||||
}
|
||||
if (s == end)
|
||||
goto end_i;
|
||||
|
||||
/* Handle next 9 digits and store them in j */
|
||||
j= 0;
|
||||
start= s; /* Used to know how much to shift i */
|
||||
n_end= true_end= s + 2 * INIT_CNT;
|
||||
if (n_end > end)
|
||||
n_end= end;
|
||||
do
|
||||
{
|
||||
if (s[0] || (c= (s[1]-'0')) > 9)
|
||||
goto end_i_and_j;
|
||||
j= j*10+c;
|
||||
s+= 2;
|
||||
} while (s != n_end);
|
||||
if (s == end)
|
||||
{
|
||||
if (s != true_end)
|
||||
goto end_i_and_j;
|
||||
goto end3;
|
||||
}
|
||||
if (s[0] || (c= (s[1]-'0')) > 9)
|
||||
goto end3;
|
||||
|
||||
/* Handle the next 1 or 2 digits and store them in k */
|
||||
k=c;
|
||||
s+= 2;
|
||||
if (s == end || s[0] || (c= (s[1]-'0')) > 9)
|
||||
goto end4;
|
||||
k= k*10+c;
|
||||
s+= 2;
|
||||
*endptr= (char*) s;
|
||||
|
||||
/* number string should have ended here */
|
||||
if (s != end && !s[0] && (c= (s[1]-'0')) <= 9)
|
||||
goto overflow;
|
||||
|
||||
/* Check that we didn't get an overflow with the last digit */
|
||||
if (i > cutoff || (i == cutoff && ((j > cutoff2 || j == cutoff2) &&
|
||||
k > cutoff3)))
|
||||
goto overflow;
|
||||
li=i*LFACTOR2+ (ulonglong) j*100 + k;
|
||||
return (longlong) li;
|
||||
|
||||
overflow: /* *endptr is set here */
|
||||
*error= MY_ERRNO_ERANGE;
|
||||
return negative ? LONGLONG_MIN : (longlong) ULONGLONG_MAX;
|
||||
|
||||
end_i:
|
||||
*endptr= (char*) s;
|
||||
return (negative ? ((longlong) -(long) i) : (longlong) i);
|
||||
|
||||
end_i_and_j:
|
||||
li= (ulonglong) i * lfactor[(uint) (s-start) / 2] + j;
|
||||
*endptr= (char*) s;
|
||||
return (negative ? -((longlong) li) : (longlong) li);
|
||||
|
||||
end3:
|
||||
li=(ulonglong) i*LFACTOR+ (ulonglong) j;
|
||||
*endptr= (char*) s;
|
||||
return (negative ? -((longlong) li) : (longlong) li);
|
||||
|
||||
end4:
|
||||
li=(ulonglong) i*LFACTOR1+ (ulonglong) j * 10 + k;
|
||||
*endptr= (char*) s;
|
||||
if (negative)
|
||||
{
|
||||
if (li > MAX_NEGATIVE_NUMBER)
|
||||
goto overflow;
|
||||
return -((longlong) li);
|
||||
}
|
||||
return (longlong) li;
|
||||
|
||||
no_conv:
|
||||
/* There was no number to convert. */
|
||||
*error= MY_ERRNO_EDOM;
|
||||
*endptr= (char *) nptr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static
|
||||
uint my_numchars_ucs2(CHARSET_INFO *cs __attribute__((unused)),
|
||||
const char *b, const char *e)
|
||||
|
@ -1439,6 +1621,7 @@ MY_CHARSET_HANDLER my_charset_ucs2_handler=
|
|||
my_strntoll_ucs2,
|
||||
my_strntoull_ucs2,
|
||||
my_strntod_ucs2,
|
||||
my_strtoll10_ucs2,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -8493,6 +8493,7 @@ static MY_CHARSET_HANDLER my_charset_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -2091,6 +2091,7 @@ MY_CHARSET_HANDLER my_charset_utf8_handler=
|
|||
my_strntoll_8bit,
|
||||
my_strntoull_8bit,
|
||||
my_strntod_8bit,
|
||||
my_strtoll10_8bit,
|
||||
my_scan_8bit
|
||||
};
|
||||
|
||||
|
|
|
@ -10251,7 +10251,7 @@ static void test_bug5194()
|
|||
/* Number of columns per row */
|
||||
const int COLUMN_COUNT= sizeof(float_array)/sizeof(*float_array);
|
||||
/* Number of rows per bulk insert to start with */
|
||||
const int MIN_ROWS_PER_INSERT= 260;
|
||||
const int MIN_ROWS_PER_INSERT= 262;
|
||||
/* Max number of rows per bulk insert to end with */
|
||||
const int MAX_ROWS_PER_INSERT= 300;
|
||||
const int MAX_PARAM_COUNT= COLUMN_COUNT*MAX_ROWS_PER_INSERT;
|
||||
|
@ -10391,6 +10391,34 @@ static void test_bug5194()
|
|||
}
|
||||
|
||||
|
||||
static void test_bug5315()
|
||||
{
|
||||
MYSQL_STMT *stmt;
|
||||
const char *stmt_text;
|
||||
int rc;
|
||||
|
||||
myheader("test_bug5315");
|
||||
|
||||
stmt_text= "SELECT 1";
|
||||
stmt= mysql_stmt_init(mysql);
|
||||
rc= mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));
|
||||
DBUG_ASSERT(rc == 0);
|
||||
mysql_change_user(mysql, opt_user, opt_password, current_db);
|
||||
rc= mysql_stmt_execute(stmt);
|
||||
DBUG_ASSERT(rc != 0);
|
||||
if (rc)
|
||||
printf("Got error (as expected):\n%s", mysql_stmt_error(stmt));
|
||||
/* check that connection is OK */
|
||||
mysql_stmt_close(stmt);
|
||||
stmt= mysql_stmt_init(mysql);
|
||||
rc= mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));
|
||||
DBUG_ASSERT(rc == 0);
|
||||
rc= mysql_stmt_execute(stmt);
|
||||
DBUG_ASSERT(rc == 0);
|
||||
mysql_stmt_close(stmt);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Read and parse arguments and MySQL options from my.cnf
|
||||
*/
|
||||
|
@ -10694,6 +10722,8 @@ int main(int argc, char **argv)
|
|||
test_bug5399(); /* check that statement id uniquely identifies
|
||||
statement */
|
||||
test_bug5194(); /* bulk inserts in prepared mode */
|
||||
test_bug5315(); /* check that mysql_change_user closes all
|
||||
prepared statements */
|
||||
/*
|
||||
XXX: PLEASE RUN THIS PROGRAM UNDER VALGRIND AND VERIFY THAT YOUR TEST
|
||||
DOESN'T CONTAIN WARNINGS/ERRORS BEFORE YOU PUSH.
|
||||
|
|
Loading…
Add table
Reference in a new issue