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

Merge bk-internal.mysql.com:/home/bk/mysql-5.0

Browse Source 
into  mysql.com:/home/my/mysql-5.0
This commit is contained in:
monty@mysql.com 2005-10-08 03:37:23 +03:00
commit 17d7ba931d
33 changed files with 385 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BUILD/FINISH.sh
View File

@ -14,7 +14,7 @@ path=`dirname $0`
if [ -z "$just_clean" ]
then
commands="$commands
CFLAGS=\"$cflags\" CXX=\"$CXX\" CXXFLAGS=\"$cxxflags\" CXXLDFLAGS=\"$CXXLDFLAGS\" \
CC=\"$CC\" CFLAGS=\"$cflags\" CXX=\"$CXX\" CXXFLAGS=\"$cxxflags\" CXXLDFLAGS=\"$CXXLDFLAGS\" \
$configure"
fi

4
BUILD/SETUP.sh
View File

@ -104,6 +104,10 @@ else
make=make
fi
if test -z "$CC" ; then
CC=gcc
fi
if test -z "$CXX" ; then
CXX=gcc
fi

76
client/mysql.cc
View File

@ -320,7 +320,7 @@ static void initialize_readline (char *name);
static void fix_history(String *final_command);
#endif
static COMMANDS *find_command (char *name,char cmd_name);
static COMMANDS *find_command(char *name,char cmd_name);
static bool add_line(String &buffer,char *line,char *in_string,
bool *ml_comment);
static void remove_cntrl(String &buffer);
@ -1109,10 +1109,12 @@ static int read_and_execute(bool interactive)
}
static COMMANDS *find_command (char *name,char cmd_char)
static COMMANDS *find_command(char *name,char cmd_char)
{
uint len;
char *end;
DBUG_ENTER("find_command");
DBUG_PRINT("enter",("name: '%s' char: %d", name ? name : "NULL", cmd_char));
if (!name)
{
@ -1124,12 +1126,16 @@ static COMMANDS *find_command (char *name,char cmd_char)
while (my_isspace(charset_info,*name))
name++;
/*
As special case we allow row that starts with word delimiter
to be able to change delimiter if someone has delimiter 'delimiter'.
If there is an \\g in the row or if the row has a delimiter but
this is not a delimiter command, let add_line() take care of
parsing the row and calling find_command()
*/
if (strstr(name, "\\g") || (strstr(name, delimiter) &&
strncmp(name, "delimiter", 9)))
return ((COMMANDS *) 0);
strlen(name) >= 9 &&
my_strnncoll(charset_info,(uchar*) name,
9,
(const uchar*) "delimiter", 9)))
DBUG_RETURN((COMMANDS *) 0);
if ((end=strcont(name," \t")))
{
len=(uint) (end - name);
@ -1145,15 +1151,18 @@ static COMMANDS *find_command (char *name,char cmd_char)
for (uint i= 0; commands[i].name; i++)
{
if (commands[i].func &&
((name &&
((name &&
!my_strnncoll(charset_info,(uchar*)name,len,
(uchar*)commands[i].name,len) &&
!commands[i].name[len] &&
(!end || (end && commands[i].takes_params))) ||
!name && commands[i].cmd_char == cmd_char))
return (&commands[i]);
{
DBUG_PRINT("exit",("found command: %s", commands[i].name));
DBUG_RETURN(&commands[i]);
}
}
return ((COMMANDS *) 0);
DBUG_RETURN((COMMANDS *) 0);
}
@ -1164,15 +1173,16 @@ static bool add_line(String &buffer,char *line,char *in_string,
char buff[80], *pos, *out;
COMMANDS *com;
bool need_space= 0;
DBUG_ENTER("add_line");
if (!line[0] && buffer.is_empty())
return 0;
DBUG_RETURN(0);
#ifdef HAVE_READLINE
if (status.add_to_history && line[0] && not_in_history(line))
add_history(line);
#endif
#ifdef USE_MB
char *strend=line+(uint) strlen(line);
char *end_of_line=line+(uint) strlen(line);
#endif
for (pos=out=line ; (inchar= (uchar) *pos) ; pos++)
@ -1181,13 +1191,14 @@ static bool add_line(String &buffer,char *line,char *in_string,
buffer.is_empty())
continue;
#ifdef USE_MB
int l;
int length;
if (use_mb(charset_info) &&
(l = my_ismbchar(charset_info, pos, strend))) {
while (l--)
*out++ = *pos++;
pos--;
continue;
(length= my_ismbchar(charset_info, pos, end_of_line)))
{
while (length--)
*out++ = *pos++;
pos--;
continue;
}
#endif
if (!*ml_comment && inchar == '\\')
@ -1207,7 +1218,7 @@ static bool add_line(String &buffer,char *line,char *in_string,
const String tmp(line,(uint) (out-line), charset_info);
buffer.append(tmp);
if ((*com->func)(&buffer,pos-1) > 0)
return 1; // Quit
DBUG_RETURN(1); // Quit
if (com->takes_params)
{
for (pos++ ;
@ -1225,29 +1236,40 @@ static bool add_line(String &buffer,char *line,char *in_string,
{
sprintf(buff,"Unknown command '\\%c'.",inchar);
if (put_info(buff,INFO_ERROR) > 0)
return 1;
DBUG_RETURN(1);
*out++='\\';
*out++=(char) inchar;
continue;
}
}
else if (!*ml_comment && (*pos == *delimiter &&
is_prefix(pos + 1, delimiter + 1)) &&
!*in_string)
else if (!*ml_comment && !*in_string &&
(*pos == *delimiter && is_prefix(pos + 1, delimiter + 1) ||
buffer.length() == 0 && (out - line) >= 9 &&
!my_strcasecmp(charset_info, line, "delimiter")))
{
uint old_delimiter_length= delimiter_length;
if (out != line)
buffer.append(line, (uint) (out - line)); // Add this line
if ((com= find_command(buffer.c_ptr(), 0)))
{
if (com->func == com_delimiter)
{
/*
Delimiter wants the get rest of the given line as argument to
allow one to change ';' to ';;' and back
*/
char *end= strend(pos);
buffer.append(pos, (uint) (end - pos));
/* Ensure pos will point at \0 after the pos+= below */
pos= end - old_delimiter_length + 1;
}
if ((*com->func)(&buffer, buffer.c_ptr()) > 0)
return 1; // Quit
DBUG_RETURN(1); // Quit
}
else
{
if (com_go(&buffer, 0) > 0) // < 0 is not fatal
return 1;
DBUG_RETURN(1);
}
buffer.length(0);
out= line;
@ -1299,9 +1321,9 @@ static bool add_line(String &buffer,char *line,char *in_string,
if (buffer.length() + length >= buffer.alloced_length())
buffer.realloc(buffer.length()+length+IO_SIZE);
if (!(*ml_comment) && buffer.append(line,length))
return 1;
DBUG_RETURN(1);
}
return 0;
DBUG_RETURN(0);
}
/*****************************************************************

59
client/mysqldump.c
View File

@ -1172,23 +1172,25 @@ static void print_xml_row(FILE *xml_file, const char *row_name,
This function has logic to print the appropriate syntax depending on whether
this is a procedure or functions
RETURN 0 succes, 1 if error
RETURN
0 Success
1 Error
*/
static uint dump_routines_for_db (char *db)
static uint dump_routines_for_db(char *db)
{
char query_buff[512];
const char *routine_type[]={"FUNCTION", "PROCEDURE"};
char db_name_buff[NAME_LEN*2+3], name_buff[NAME_LEN*2+3], *routine_name;
const char *routine_type[]= {"FUNCTION", "PROCEDURE"};
char db_name_buff[NAME_LEN*2+3], name_buff[NAME_LEN*2+3];
char *routine_name;
int i;
FILE *sql_file = md_result_file;
FILE *sql_file= md_result_file;
MYSQL_RES *routine_res, *routine_list_res;
MYSQL_ROW row, routine_list_row;
DBUG_ENTER("dump_routines_for_db");
DBUG_PRINT("enter", ("db: '%s'", db));
mysql_real_escape_string(sock, db_name_buff, db, strlen(db));
DBUG_PRINT("enter", ("db: '%s'", db_name_buff));
/* nice comments */
if (opt_comments)
@ -1201,10 +1203,10 @@ static uint dump_routines_for_db (char *db)
if (lock_tables)
mysql_query(sock, "LOCK TABLES mysql.proc READ");
fprintf(sql_file, "DELIMITER //\n");
fprintf(sql_file, "DELIMITER ;;\n");
/* 0, retrieve and dump functions, 1, procedures */
for (i=0; i <= 1; i++)
for (i= 0; i <= 1; i++)
{
my_snprintf(query_buff, sizeof(query_buff),
"SHOW %s STATUS WHERE Db = '%s'",
@ -1216,18 +1218,18 @@ static uint dump_routines_for_db (char *db)
if (mysql_num_rows(routine_list_res))
{
while((routine_list_row= mysql_fetch_row(routine_list_res)))
while ((routine_list_row= mysql_fetch_row(routine_list_res)))
{
DBUG_PRINT("info", ("retrieving CREATE %s for %s", routine_type[i],
name_buff));
routine_name=quote_name(routine_list_row[1], name_buff, 0);
routine_name= quote_name(routine_list_row[1], name_buff, 0);
my_snprintf(query_buff, sizeof(query_buff), "SHOW CREATE %s %s",
routine_type[i], routine_name);
if (mysql_query_with_error_report(sock, &routine_res, query_buff))
DBUG_RETURN(1);
while ((row=mysql_fetch_row(routine_res)))
while ((row= mysql_fetch_row(routine_res)))
{
/*
if the user has EXECUTE privilege he see routine names, but NOT the
@ -1238,16 +1240,18 @@ static uint dump_routines_for_db (char *db)
if (strlen(row[2]))
{
if (opt_drop)
fprintf(sql_file, "/*!50003 DROP %s IF EXISTS %s */ //\n",
fprintf(sql_file, "/*!50003 DROP %s IF EXISTS %s */;;\n",
routine_type[i], routine_name);
/*
we need to change sql_mode only for the CREATE PROCEDURE/FUNCTION
otherwise we may need to re-quote routine_name
we need to change sql_mode only for the CREATE
PROCEDURE/FUNCTION otherwise we may need to re-quote routine_name
*/;
fprintf(sql_file, "/*!50003 SET SESSION SQL_MODE=\"%s\"*/ //\n",
fprintf(sql_file, "/*!50003 SET SESSION SQL_MODE=\"%s\"*/;;\n",
row[1] /* sql_mode */);
fprintf(sql_file, "/*!50003 %s */ //\n", row[2]);
fprintf(sql_file, "/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ //\n");
fprintf(sql_file, "/*!50003 %s */;;\n", row[2]);
fprintf(sql_file,
"/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/"
";;\n");
}
} /* end of routine printing */
} /* end of list of routines */
@ -1753,7 +1757,6 @@ static void dump_triggers_for_table (char *table, char *db)
char name_buff[NAME_LEN*4+3], table_buff[NAME_LEN*2+3];
char query_buff[512];
FILE *sql_file = md_result_file;
DBUG_ENTER("dump_triggers_for_table");
DBUG_PRINT("enter", ("db: %s, table: %s", db, table));
result_table= quote_name(table, table_buff, 1);
@ -1771,11 +1774,11 @@ static void dump_triggers_for_table (char *table, char *db)
}
if (mysql_num_rows(result))
fprintf(sql_file, "\n/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE*/;\n\
DELIMITER //;\n");
DELIMITER ;;\n");
while ((row=mysql_fetch_row(result)))
{
fprintf(sql_file, "/*!50003 SET SESSION SQL_MODE=\"%s\" */ //\n\
/*!50003 CREATE TRIGGER %s %s %s ON %s FOR EACH ROW%s */ //\n\n",
fprintf(sql_file, "/*!50003 SET SESSION SQL_MODE=\"%s\" */;;\n\
/*!50003 CREATE TRIGGER %s %s %s ON %s FOR EACH ROW%s */;;\n\n",
row[6], /* sql_mode */
quote_name(row[0], name_buff, 0), /* Trigger */
row[4], /* Timing */
@ -1785,8 +1788,8 @@ DELIMITER //;\n");
}
if (mysql_num_rows(result))
fprintf(sql_file,
"DELIMITER ;//\n\
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE */;");
"DELIMITER ;\n"
"/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE */;\n");
mysql_free_result(result);
DBUG_VOID_RETURN;
}
@ -1812,10 +1815,10 @@ static char *add_load_option(char *ptr,const char *object,
/*
** Allow the user to specify field terminator strings like:
** "'", "\", "\\" (escaped backslash), "\t" (tab), "\n" (newline)
** This is done by doubleing ' and add a end -\ if needed to avoid
** syntax errors from the SQL parser.
Allow the user to specify field terminator strings like:
"'", "\", "\\" (escaped backslash), "\t" (tab), "\n" (newline)
This is done by doubling ' and add a end -\ if needed to avoid
syntax errors from the SQL parser.
*/
static char *field_escape(char *to,const char *from,uint length)

8
client/mysqltest.c
View File

@ -143,7 +143,8 @@ typedef struct
long code;
} st_error;
static st_error global_error[] = {
static st_error global_error[] =
{
#include <mysqld_ername.h>
{ 0, 0 }
};
@ -218,7 +219,8 @@ static int ps_match_re(char *);
static char *ps_eprint(int);
static void ps_free_reg(void);
static const char *embedded_server_groups[] = {
static const char *embedded_server_groups[]=
{
"server",
"embedded",
"mysqltest_SERVER",
@ -1286,7 +1288,7 @@ int do_modify_var(struct st_query *query, const char *name,
if (*p != '$')
die("First argument to %s must be a variable (start with $)", name);
v= var_get(p, &p, 1, 0);
switch (operator){
switch (operator) {
case DO_DEC:
v->int_val--;
break;

1
include/my_sys.h
View File

@ -98,7 +98,6 @@ extern int NEAR my_errno; /* Last error in mysys */
#define MY_RETURN_REAL_PATH 32 /* return full path for file */
#define MY_SAFE_PATH 64 /* Return NULL if too long path */
#define MY_RELATIVE_PATH 128 /* name is relative to 'dir' */
#define MY_UNIX_PATH 256 /* convert path to UNIX format */
/* My seek flags */
#define MY_SEEK_SET 0

10
mysql-test/r/alter_table.result
View File

@ -541,16 +541,16 @@ create table t1 ( a timestamp );
alter table t1 add unique ( a(1) );
ERROR HY000: Incorrect sub part key; the used key part isn't a string, the used length is longer than the key part, or the storage engine doesn't support unique sub keys
drop table t1;
create database mysqltest1;
create database mysqltest;
create table t1 (c1 int);
alter table t1 rename mysqltest1.t1;
alter table t1 rename mysqltest.t1;
drop table t1;
ERROR 42S02: Unknown table 't1'
alter table mysqltest1.t1 rename t1;
alter table mysqltest.t1 rename t1;
drop table t1;
create table t1 (c1 int);
use mysqltest1;
drop database mysqltest1;
use mysqltest;
drop database mysqltest;
alter table test.t1 rename t1;
ERROR 3D000: No database selected
alter table test.t1 rename test.t1;

3
mysql-test/r/func_str.result
View File

@ -818,6 +818,9 @@ lpad(12345, 5, "#")
SELECT conv(71, 10, 36), conv('1Z', 36, 10);
conv(71, 10, 36) conv('1Z', 36, 10)
1Z 71
SELECT conv(71, 10, 37), conv('1Z', 37, 10), conv(0,1,10),conv(0,0,10), conv(0,-1,10);
conv(71, 10, 37) conv('1Z', 37, 10) conv(0,1,10) conv(0,0,10) conv(0,-1,10)
NULL NULL NULL NULL NULL
create table t1 (id int(1), str varchar(10)) DEFAULT CHARSET=utf8;
insert into t1 values (1,'aaaaaaaaaa'), (2,'bbbbbbbbbb');
create table t2 (id int(1), str varchar(10)) DEFAULT CHARSET=utf8;

1
mysql-test/r/mysql.result
View File

@ -1,6 +1,7 @@
drop table if exists t1;
create table t1(a int);
insert into t1 values(1);
ERROR at line 9: DELIMITER must be followed by a 'delimiter' character or string
Test default delimiter ;
a

70
mysql-test/r/mysqldump.result
View File

@ -1869,31 +1869,32 @@ UNLOCK TABLES;
/*!40000 ALTER TABLE `t1` ENABLE KEYS */;
/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE*/;
DELIMITER //;
/*!50003 SET SESSION SQL_MODE="" */ //
DELIMITER ;;
/*!50003 SET SESSION SQL_MODE="" */;;
/*!50003 CREATE TRIGGER `trg1` BEFORE INSERT ON `t1` FOR EACH ROW
begin
if new.a > 10 then
set new.a := 10;
set new.a := 11;
end if;
end */ //
end */;;
/*!50003 SET SESSION SQL_MODE="" */ //
/*!50003 SET SESSION SQL_MODE="" */;;
/*!50003 CREATE TRIGGER `trg2` BEFORE UPDATE ON `t1` FOR EACH ROW begin
if old.a % 2 = 0 then set new.b := 12; end if;
end */ //
end */;;
/*!50003 SET SESSION SQL_MODE="STRICT_TRANS_TABLES,STRICT_ALL_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,TRADITIONAL,NO_AUTO_CREATE_USER" */ //
/*!50003 SET SESSION SQL_MODE="STRICT_TRANS_TABLES,STRICT_ALL_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,TRADITIONAL,NO_AUTO_CREATE_USER" */;;
/*!50003 CREATE TRIGGER `trg3` AFTER UPDATE ON `t1` FOR EACH ROW
begin
if new.a = -1 then
set @fired:= "Yes";
end if;
end */ //
end */;;
DELIMITER ;//
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE */;DROP TABLE IF EXISTS `t2`;
DELIMITER ;
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE */;
DROP TABLE IF EXISTS `t2`;
CREATE TABLE `t2` (
`a` int(11) default NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
@ -1905,17 +1906,18 @@ UNLOCK TABLES;
/*!40000 ALTER TABLE `t2` ENABLE KEYS */;
/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE*/;
DELIMITER //;
/*!50003 SET SESSION SQL_MODE="STRICT_TRANS_TABLES,STRICT_ALL_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,TRADITIONAL,NO_AUTO_CREATE_USER" */ //
DELIMITER ;;
/*!50003 SET SESSION SQL_MODE="STRICT_TRANS_TABLES,STRICT_ALL_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,TRADITIONAL,NO_AUTO_CREATE_USER" */;;
/*!50003 CREATE TRIGGER `trg4` BEFORE INSERT ON `t2` FOR EACH ROW
begin
if new.a > 10 then
set @fired:= "No";
end if;
end */ //
end */;;
DELIMITER ;//
DELIMITER ;
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE */;
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
@ -2077,37 +2079,37 @@ LOCK TABLES `t1` WRITE;
INSERT INTO `t1` VALUES (1),(2),(3),(4),(5);
UNLOCK TABLES;
/*!40000 ALTER TABLE `t1` ENABLE KEYS */;
DELIMITER //
/*!50003 DROP FUNCTION IF EXISTS `bug9056_func1` */ //
/*!50003 SET SESSION SQL_MODE=""*/ //
DELIMITER ;;
/*!50003 DROP FUNCTION IF EXISTS `bug9056_func1` */;;
/*!50003 SET SESSION SQL_MODE=""*/;;
/*!50003 CREATE FUNCTION `bug9056_func1`(a INT, b INT) RETURNS int(11)
RETURN a+b */ //
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ //
/*!50003 DROP FUNCTION IF EXISTS `bug9056_func2` */ //
/*!50003 SET SESSION SQL_MODE=""*/ //
RETURN a+b */;;
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/;;
/*!50003 DROP FUNCTION IF EXISTS `bug9056_func2` */;;
/*!50003 SET SESSION SQL_MODE=""*/;;
/*!50003 CREATE FUNCTION `bug9056_func2`(f1 char binary) RETURNS char(1)
begin
set f1= concat( 'hello', f1 );
return f1;
end */ //
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ //
/*!50003 DROP PROCEDURE IF EXISTS `a'b` */ //
/*!50003 SET SESSION SQL_MODE="REAL_AS_FLOAT,PIPES_AS_CONCAT,ANSI_QUOTES,IGNORE_SPACE,ANSI"*/ //
end */;;
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/;;
/*!50003 DROP PROCEDURE IF EXISTS `a'b` */;;
/*!50003 SET SESSION SQL_MODE="REAL_AS_FLOAT,PIPES_AS_CONCAT,ANSI_QUOTES,IGNORE_SPACE,ANSI"*/;;
/*!50003 CREATE PROCEDURE "a'b"()
select 1 */ //
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ //
/*!50003 DROP PROCEDURE IF EXISTS `bug9056_proc1` */ //
/*!50003 SET SESSION SQL_MODE=""*/ //
select 1 */;;
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/;;
/*!50003 DROP PROCEDURE IF EXISTS `bug9056_proc1` */;;
/*!50003 SET SESSION SQL_MODE=""*/;;
/*!50003 CREATE PROCEDURE `bug9056_proc1`(IN a INT, IN b INT, OUT c INT)
BEGIN SELECT a+b INTO c; end */ //
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ //
/*!50003 DROP PROCEDURE IF EXISTS `bug9056_proc2` */ //
/*!50003 SET SESSION SQL_MODE=""*/ //
BEGIN SELECT a+b INTO c; end */;;
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/;;
/*!50003 DROP PROCEDURE IF EXISTS `bug9056_proc2` */;;
/*!50003 SET SESSION SQL_MODE=""*/;;
/*!50003 CREATE PROCEDURE `bug9056_proc2`(OUT a INT)
BEGIN
select sum(id) from t1 into a;
END */ //
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/ //
END */;;
/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE*/;;
DELIMITER ;
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;

1
mysql-test/r/mysqlshow.result
View File

@ -1,3 +1,4 @@
DROP TABLE IF EXISTS t1,t2;
CREATE TABLE t1 (a int);
INSERT INTO t1 VALUES (1),(2),(3);
CREATE TABLE t2 (a int, b int);

10
mysql-test/t/alter_table.test
View File

@ -373,24 +373,24 @@ drop table t1;
# Bug#11493 - Alter table rename to default database does not work without
# db name qualifying
#
create database mysqltest1;
create database mysqltest;
create table t1 (c1 int);
# Move table to other database.
alter table t1 rename mysqltest1.t1;
alter table t1 rename mysqltest.t1;
# Assure that it has moved.
--error 1051
drop table t1;
# Move table back.
alter table mysqltest1.t1 rename t1;
alter table mysqltest.t1 rename t1;
# Assure that it is back.
drop table t1;
# Now test for correct message if no database is selected.
# Create t1 in 'test'.
create table t1 (c1 int);
# Change to other db.
use mysqltest1;
use mysqltest;
# Drop the current db. This de-selects any db.
drop database mysqltest1;
drop database mysqltest;
# Now test for correct message.
--error 1046
alter table test.t1 rename t1;

1
mysql-test/t/func_str.test
View File

@ -467,6 +467,7 @@ SELECT lpad(12345, 5, "#");
#
SELECT conv(71, 10, 36), conv('1Z', 36, 10);
SELECT conv(71, 10, 37), conv('1Z', 37, 10), conv(0,1,10),conv(0,0,10), conv(0,-1,10);
#
# Bug in SUBSTRING when mixed with CONCAT and ORDER BY (Bug #3089)

2
mysql-test/t/mysql.test
View File

@ -14,7 +14,7 @@ create table t1(a int);
insert into t1 values(1);
# Test delimiters
--exec $MYSQL test < "./t/mysql_delimiter.sql"
--exec $MYSQL test 2>&1 < "./t/mysql_delimiter.sql"
--disable_query_log
# Test delimiter : supplied on the command line

4
mysql-test/t/mysqlshow.test
View File

@ -1,6 +1,10 @@
# Can't run test of external client with embedded server
-- source include/not_embedded.inc
--disable_warnings
DROP TABLE IF EXISTS t1,t2;
--enable_warnings
#
## Bug #5036 mysqlshow is missing a column
#

16
mysys/mf_format.c
View File

@ -17,13 +17,12 @@
#include "mysys_priv.h"
#include <m_string.h>
/*
Formats a filename with possible replace of directory of extension
Function can handle the case where 'to' == 'name'
For a description of the flag values, consult my_sys.h
The arguments should be in unix format.
*/
/*
Formats a filename with possible replace of directory of extension
Function can handle the case where 'to' == 'name'
For a description of the flag values, consult my_sys.h
The arguments should be in unix format.
*/
my_string fn_format(my_string to, const char *name, const char *dir,
const char *extension, uint flag)
@ -54,8 +53,7 @@ my_string fn_format(my_string to, const char *name, const char *dir,
pack_dirname(dev,dev); /* Put in ./.. and ~/.. */
if (flag & MY_UNPACK_FILENAME)
(void) unpack_dirname(dev,dev); /* Replace ~/.. with dir */
if (flag & MY_UNIX_PATH)
to_unix_path(dev); /* Fix to MySQL representation */
if ((pos= (char*) strchr(name,FN_EXTCHAR)) != NullS)
{
if ((flag & MY_REPLACE_EXT) == 0) /* If we should keep old ext */

79
sql/ha_federated.cc
View File

@ -480,6 +480,7 @@ static int check_foreign_data_source(
String query(query_buffer, sizeof(query_buffer), &my_charset_bin);
MYSQL *mysql;
DBUG_ENTER("ha_federated::check_foreign_data_source");
/* Zero the length, otherwise the string will have misc chars */
query.length(0);
@ -564,6 +565,7 @@ static int parse_url_error(FEDERATED_SHARE *share, TABLE *table, int error_num)
char buf[FEDERATED_QUERY_BUFFER_SIZE];
int buf_len;
DBUG_ENTER("ha_federated parse_url_error");
if (share->scheme)
{
DBUG_PRINT("info",
@ -572,11 +574,9 @@ static int parse_url_error(FEDERATED_SHARE *share, TABLE *table, int error_num)
my_free((gptr) share->scheme, MYF(0));
share->scheme= 0;
}
buf_len= (table->s->connect_string.length > (FEDERATED_QUERY_BUFFER_SIZE - 1))
? FEDERATED_QUERY_BUFFER_SIZE - 1 : table->s->connect_string.length;
strnmov(buf, table->s->connect_string.str, buf_len);
buf[buf_len]= '\0';
buf_len= min(table->s->connect_string.length,
FEDERATED_QUERY_BUFFER_SIZE-1);
strmake(buf, table->s->connect_string.str, buf_len);
my_error(error_num, MYF(0), buf);
DBUG_RETURN(error_num);
}
@ -767,12 +767,9 @@ uint ha_federated::convert_row_to_internal_format(byte *record, MYSQL_ROW row)
{
ulong *lengths;
Field **field;
DBUG_ENTER("ha_federated::convert_row_to_internal_format");
// num_fields= mysql_num_fields(stored_result);
lengths= mysql_fetch_lengths(stored_result);
memset(record, 0, table->s->null_bytes);
for (field= table->field; *field; field++)
@ -1127,8 +1124,8 @@ bool ha_federated::create_where_from_key(String *to,
char tmpbuff[FEDERATED_QUERY_BUFFER_SIZE];
String tmp(tmpbuff, sizeof(tmpbuff), system_charset_info);
const key_range *ranges[2]= { start_key, end_key };
DBUG_ENTER("ha_federated::create_where_from_key");
tmp.length(0);
if (start_key == NULL && end_key == NULL)
DBUG_RETURN(1);
@ -1334,7 +1331,6 @@ static FEDERATED_SHARE *get_share(const char *table_name, TABLE *table)
query.append(FEDERATED_FROM);
query.append(FEDERATED_BTICK);
if (!(share= (FEDERATED_SHARE *)
my_multi_malloc(MYF(MY_WME),
&share, sizeof(*share),
@ -1389,8 +1385,8 @@ error:
static int free_share(FEDERATED_SHARE *share)
{
DBUG_ENTER("free_share");
pthread_mutex_lock(&federated_mutex);
pthread_mutex_lock(&federated_mutex);
if (!--share->use_count)
{
hash_delete(&federated_open_tables, (byte*) share);
@ -1581,7 +1577,6 @@ int ha_federated::write_row(byte *buf)
values_string.length(0);
insert_string.length(0);
insert_field_value_string.length(0);
DBUG_ENTER("ha_federated::write_row");
DBUG_PRINT("info",
("table charset name %s csname %s",
@ -1708,7 +1703,6 @@ int ha_federated::optimize(THD* thd, HA_CHECK_OPT* check_opt)
{
char query_buffer[STRING_BUFFER_USUAL_SIZE];
String query(query_buffer, sizeof(query_buffer), &my_charset_bin);
DBUG_ENTER("ha_federated::optimize");
query.length(0);
@ -1732,7 +1726,6 @@ int ha_federated::repair(THD* thd, HA_CHECK_OPT* check_opt)
{
char query_buffer[STRING_BUFFER_USUAL_SIZE];
String query(query_buffer, sizeof(query_buffer), &my_charset_bin);
DBUG_ENTER("ha_federated::repair");
query.length(0);
@ -1778,14 +1771,16 @@ int ha_federated::repair(THD* thd, HA_CHECK_OPT* check_opt)
int ha_federated::update_row(const byte *old_data, byte *new_data)
{
/*
This used to control how the query was built. If there was a primary key,
the query would be built such that there was a where clause with only
that column as the condition. This is flawed, because if we have a multi-part
primary key, it would only use the first part! We don't need to do this anyway,
because read_range_first will retrieve the correct record, which is what is used
to build the WHERE clause. We can however use this to append a LIMIT to the end
if there is NOT a primary key. Why do this? Because we only are updating one
record, and LIMIT enforces this.
This used to control how the query was built. If there was a
primary key, the query would be built such that there was a where
clause with only that column as the condition. This is flawed,
because if we have a multi-part primary key, it would only use the
first part! We don't need to do this anyway, because
read_range_first will retrieve the correct record, which is what
is used to build the WHERE clause. We can however use this to
append a LIMIT to the end if there is NOT a primary key. Why do
this? Because we only are updating one record, and LIMIT enforces
this.
*/
bool has_a_primary_key= (table->s->primary_key == 0 ? TRUE : FALSE);
/*
@ -1812,7 +1807,6 @@ int ha_federated::update_row(const byte *old_data, byte *new_data)
String where_string(where_buffer,
sizeof(where_buffer),
&my_charset_bin);
DBUG_ENTER("ha_federated::update_row");
/*
set string lengths to 0 to avoid misc chars in string
@ -2007,12 +2001,10 @@ int ha_federated::index_read_idx(byte *buf, uint index, const byte *key,
sizeof(sql_query_buffer),
&my_charset_bin);
key_range range;
DBUG_ENTER("ha_federated::index_read_idx");
index_string.length(0);
sql_query.length(0);
DBUG_ENTER("ha_federated::index_read_idx");
statistic_increment(table->in_use->status_var.ha_read_key_count,
&LOCK_status);
@ -2101,8 +2093,8 @@ int ha_federated::read_range_first(const key_range *start_key,
String sql_query(sql_query_buffer,
sizeof(sql_query_buffer),
&my_charset_bin);
DBUG_ENTER("ha_federated::read_range_first");
if (start_key == NULL && end_key == NULL)
DBUG_RETURN(0);
@ -2417,7 +2409,6 @@ void ha_federated::info(uint flag)
MYSQL_RES *result= 0;
MYSQL_ROW row;
String status_query_string(status_buf, sizeof(status_buf), &my_charset_bin);
DBUG_ENTER("ha_federated::info");
error_code= ER_QUERY_ON_FOREIGN_DATA_SOURCE;
@ -2508,10 +2499,10 @@ error:
int ha_federated::delete_all_rows()
{
DBUG_ENTER("ha_federated::delete_all_rows");
char query_buffer[FEDERATED_QUERY_BUFFER_SIZE];
String query(query_buffer, sizeof(query_buffer), &my_charset_bin);
DBUG_ENTER("ha_federated::delete_all_rows");
query.length(0);
query.set_charset(system_charset_info);
@ -2606,32 +2597,14 @@ THR_LOCK_DATA **ha_federated::store_lock(THD *thd,
int ha_federated::create(const char *name, TABLE *table_arg,
HA_CREATE_INFO *create_info)
{
int retval= 0;
/*
only a temporary share, to test the url
*/
FEDERATED_SHARE tmp_share;
int retval;
FEDERATED_SHARE tmp_share; // Only a temporary share, to test the url
DBUG_ENTER("ha_federated::create");
if ((retval= parse_url(&tmp_share, table_arg, 1)))
goto error;
if (!(retval= parse_url(&tmp_share, table_arg, 1)))
retval= check_foreign_data_source(&tmp_share, 1);
if ((retval= check_foreign_data_source(&tmp_share, 1)))
goto error;
if (tmp_share.scheme)
{
my_free((gptr) tmp_share.scheme, MYF(0));
tmp_share.scheme= 0;
}
DBUG_RETURN(retval);
error:
if (tmp_share.scheme)
{
my_free((gptr) tmp_share.scheme, MYF(0));
tmp_share.scheme= 0;
}
my_free((gptr) tmp_share.scheme, MYF(MY_ALLOW_ZERO_PTR));
DBUG_RETURN(retval);
}

46
sql/item.cc
View File

@ -817,9 +817,12 @@ String *Item_splocal::val_str(String *sp)
{
DBUG_ASSERT(fixed);
Item *it= this_item();
String *ret= it->val_str(sp);
String *res= it->val_str(sp);
null_value= it->null_value;
if (!res)
return NULL;
/*
This way we mark returned value of val_str as const,
so that various functions (e.g. CONCAT) won't try to
@ -836,12 +839,11 @@ String *Item_splocal::val_str(String *sp)
Item_param class contain some more details on the topic.
*/
if (!ret)
return NULL;
str_value_ptr.set(ret->ptr(), ret->length(),
ret->charset());
return &str_value_ptr;
if (res != &str_value)
str_value.set(res->ptr(), res->length(), res->charset());
else
res->mark_as_const();
return &str_value;
}
@ -858,17 +860,13 @@ my_decimal *Item_splocal::val_decimal(my_decimal *decimal_value)
bool Item_splocal::is_null()
{
Item *it= this_item();
bool ret= it->is_null();
null_value= it->null_value;
return ret;
return it->is_null();
}
Item *
Item_splocal::this_item()
{
THD *thd= current_thd;
return thd->spcont->get_item(m_offset);
}
@ -882,25 +880,23 @@ Item_splocal::this_item_addr(THD *thd, Item **addr)
Item *
Item_splocal::this_const_item() const
{
THD *thd= current_thd;
return thd->spcont->get_item(m_offset);
}
Item::Type
Item_splocal::type() const
{
THD *thd= current_thd;
if (thd->spcont)
if (thd && thd->spcont)
return thd->spcont->get_item(m_offset)->type();
return NULL_ITEM; // Anything but SUBSELECT_ITEM
}
bool Item_splocal::fix_fields(THD *, Item **)
bool Item_splocal::fix_fields(THD *thd_arg, Item **ref)
{
Item *it= this_item();
Item *it;
thd= thd_arg; // Must be set before this_item()
it= this_item();
DBUG_ASSERT(it->fixed);
max_length= it->max_length;
decimals= it->decimals;
@ -928,6 +924,7 @@ void Item_splocal::print(String *str)
/*****************************************************************************
Item_name_const methods
*****************************************************************************/
double Item_name_const::val_real()
{
DBUG_ASSERT(fixed);
@ -966,9 +963,7 @@ my_decimal *Item_name_const::val_decimal(my_decimal *decimal_value)
bool Item_name_const::is_null()
{
bool ret= value_item->is_null();
null_value= value_item->null_value;
return ret;
return value_item->is_null();
}
Item::Type Item_name_const::type() const
@ -977,7 +972,7 @@ Item::Type Item_name_const::type() const
}
bool Item_name_const::fix_fields(THD *thd, Item **)
bool Item_name_const::fix_fields(THD *thd, Item **ref)
{
char buf[128];
String *item_name;
@ -2783,7 +2778,7 @@ int Item_copy_string::save_in_field(Field *field, bool no_conversions)
*/
/* ARGSUSED */
bool Item::fix_fields(THD *thd, Item ** ref)
bool Item::fix_fields(THD *thd, Item **ref)
{
// We do not check fields which are fixed during construction
@ -4765,8 +4760,7 @@ String *Item_ref::val_str(String* tmp)
bool Item_ref::is_null()
{
DBUG_ASSERT(fixed);
(void) (*ref)->val_int_result();
return (*ref)->null_value;
return (*ref)->is_null();
}

14
sql/item.h
View File

@ -721,13 +721,7 @@ class Item_splocal : public Item
public:
LEX_STRING m_name;
/*
Buffer, pointing to the string value of the item. We need it to
protect internal buffer from changes. See comment to analogous
member in Item_param for more details.
*/
String str_value_ptr;
THD *thd;
/*
Position of this reference to SP variable in the statement (the
@ -739,10 +733,10 @@ public:
Value of 0 means that this object doesn't corresponding to reference to
SP variable in query text.
*/
int pos_in_query;
uint pos_in_query;
Item_splocal(LEX_STRING name, uint offset, int pos_in_q=0)
: m_offset(offset), m_name(name), pos_in_query(pos_in_q)
Item_splocal(LEX_STRING name, uint offset, uint pos_in_q=0)
: m_offset(offset), m_name(name), thd(0), pos_in_query(pos_in_q)
{
maybe_null= TRUE;
}

25
sql/item_func.cc
View File

@ -2015,7 +2015,6 @@ String *Item_func_min_max::val_str(String *str)
{
String *res;
LINT_INIT(res);
null_value= 0;
for (uint i=0; i < arg_count ; i++)
{
if (i == 0)
@ -2030,14 +2029,11 @@ String *Item_func_min_max::val_str(String *str)
if ((cmp_sign < 0 ? cmp : -cmp) < 0)
res=res2;
}
else
res= 0;
}
if ((null_value= args[i]->null_value))
break;
return 0;
}
if (res) // If !NULL
res->set_charset(collation.collation);
res->set_charset(collation.collation);
return res;
}
case ROW_RESULT:
@ -2054,7 +2050,6 @@ double Item_func_min_max::val_real()
{
DBUG_ASSERT(fixed == 1);
double value=0.0;
null_value= 0;
for (uint i=0; i < arg_count ; i++)
{
if (i == 0)
@ -2076,7 +2071,6 @@ longlong Item_func_min_max::val_int()
{
DBUG_ASSERT(fixed == 1);
longlong value=0;
null_value= 0;
for (uint i=0; i < arg_count ; i++)
{
if (i == 0)
@ -2097,21 +2091,21 @@ longlong Item_func_min_max::val_int()
my_decimal *Item_func_min_max::val_decimal(my_decimal *dec)
{
DBUG_ASSERT(fixed == 1);
my_decimal tmp_buf, *tmp, *res= NULL;
null_value= 0;
my_decimal tmp_buf, *tmp, *res;
LINT_INIT(res);
for (uint i=0; i < arg_count ; i++)
{
if (i == 0)
res= args[i]->val_decimal(dec);
else
{
tmp= args[i]->val_decimal(&tmp_buf);
if (args[i]->null_value)
res= 0;
else if ((my_decimal_cmp(tmp, res) * cmp_sign) < 0)
tmp= args[i]->val_decimal(&tmp_buf); // Zero if NULL
if (tmp && (my_decimal_cmp(tmp, res) * cmp_sign) < 0)
{
if (tmp == &tmp_buf)
{
/* Move value out of tmp_buf as this will be reused on next loop */
my_decimal2decimal(tmp, dec);
res= dec;
}
@ -2120,7 +2114,10 @@ my_decimal *Item_func_min_max::val_decimal(my_decimal *dec)
}
}
if ((null_value= args[i]->null_value))
{
res= 0;
break;
}
}
return res;
}

5
sql/log_event.cc
View File

@ -121,8 +121,9 @@ static char *pretty_print_str(char *packet, char *str, int len)
static inline char* slave_load_file_stem(char*buf, uint file_id,
int event_server_id)
{
fn_format(buf,"SQL_LOAD-",slave_load_tmpdir, "",
MY_UNPACK_FILENAME | MY_UNIX_PATH);
fn_format(buf,"SQL_LOAD-",slave_load_tmpdir, "", MY_UNPACK_FILENAME);
to_unix_path(buf);
buf = strend(buf);
buf = int10_to_str(::server_id, buf, 10);
*buf++ = '-';

10
sql/opt_range.cc
View File

@ -7040,19 +7040,15 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree)
*/
if (thd->query_id == cur_field->query_id)
{
bool is_covered= FALSE;
KEY_PART_INFO *key_part= cur_index_info->key_part;
KEY_PART_INFO *key_part_end= key_part + cur_index_info->key_parts;
for (; key_part != key_part_end ; key_part++)
for (;;)
{
if (key_part->field == cur_field)
{
is_covered= TRUE;
break;
}
if (++key_part == key_part_end)
goto next_index; // Field was not part of key
}
if (!is_covered)
goto next_index;
}
}
}

1
sql/sp_head.cc
View File

@ -794,6 +794,7 @@ static bool subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str)
splocal < sp_vars_uses.back(); splocal++)
{
Item *val;
(*splocal)->thd= thd; // fix_fields() is not yet done
/* append the text between sp ref occurences */
res|= qbuf.append(cur + prev_pos, (*splocal)->pos_in_query - prev_pos);
prev_pos= (*splocal)->pos_in_query + (*splocal)->m_name.length;

14
sql/sql_class.cc
View File

@ -1703,15 +1703,19 @@ Statement_map::Statement_map() :
int Statement_map::insert(Statement *statement)
{
int rc= my_hash_insert(&st_hash, (byte *) statement);
int res= my_hash_insert(&st_hash, (byte *) statement);
if (res)
return res;
if (statement->name.str)
{
if ((rc= my_hash_insert(&names_hash, (byte*)statement)))
if ((res= my_hash_insert(&names_hash, (byte*)statement)))
{
hash_delete(&st_hash, (byte*)statement);
return res;
}
}
if (rc == 0)
last_found_statement= statement;
return rc;
last_found_statement= statement;
return res;
}

30
sql/sql_parse.cc
View File

@ -4526,7 +4526,8 @@ end_with_restore_list:
command[thd->lex->create_view_mode].length);
view_store_options(thd, first_table, &buff);
buff.append("VIEW ", 5);
if (!first_table->current_db_used)
/* Test if user supplied a db (ie: we did not use thd->db) */
if (first_table->db != thd->db && first_table->db[0])
{
append_identifier(thd, &buff, first_table->db,
first_table->db_length);
@ -4852,7 +4853,6 @@ check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
bool db_is_pattern= test(want_access & GRANT_ACL);
#endif
ulong dummy;
const char *db_name;
DBUG_ENTER("check_access");
DBUG_PRINT("enter",("db: %s want_access: %lu master_access: %lu",
db ? db : "", want_access, sctx->master_access));
@ -4870,15 +4870,16 @@ check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
DBUG_RETURN(TRUE); /* purecov: tested */
}
db_name= db ? db : thd->db;
if (schema_db)
{
if (want_access & ~(SELECT_ACL | EXTRA_ACL))
{
if (!no_errors)
{
const char *db_name= db ? db : thd->db;
my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
sctx->priv_user,
sctx->priv_host, db_name);
sctx->priv_user, sctx->priv_host, db_name);
}
DBUG_RETURN(TRUE);
}
else
@ -6144,14 +6145,12 @@ TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
{
ptr->db= thd->db;
ptr->db_length= thd->db_length;
ptr->current_db_used= 1;
}
else
{
/* The following can't be "" as we may do 'casedn_str()' on it */
ptr->db= empty_c_string;
ptr->db_length= 0;
ptr->current_db_used= 1;
}
if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
ptr->db= thd->strdup(ptr->db);
@ -7451,9 +7450,9 @@ Item *negate_expression(THD *thd, Item *expr)
Assign as view definer current user
SYNOPSIS
default_definer()
Secytity_context current decurity context
definer structure where it should be assigned
default_view_definer()
sctx current security context
definer structure where it should be assigned
RETURN
FALSE OK
@ -7464,15 +7463,14 @@ bool default_view_definer(Security_context *sctx, st_lex_user *definer)
{
definer->user.str= sctx->priv_user;
definer->user.length= strlen(sctx->priv_user);
if (*sctx->priv_host != 0)
{
definer->host.str= sctx->priv_host;
definer->host.length= strlen(sctx->priv_host);
}
else
if (!*sctx->priv_host)
{
my_error(ER_NO_VIEW_USER, MYF(0));
return TRUE;
}
definer->host.str= sctx->priv_host;
definer->host.length= strlen(sctx->priv_host);
return FALSE;
}

106
sql/sql_prepare.cc
View File

@ -101,6 +101,11 @@ public:
class Prepared_statement: public Statement
{
public:
enum flag_values
{
IS_IN_USE= 1
};
THD *thd;
Select_fetch_protocol_prep result;
Protocol *protocol;
@ -131,19 +136,8 @@ public:
bool execute(String *expanded_query, bool open_cursor);
/* Destroy this statement */
bool deallocate();
/* Possible values of flags */
#if defined(_MSC_VER) && _MSC_VER < 1300
static const int IS_IN_USE;
#else
static const int IS_IN_USE= 1;
#endif
};
/* VC6 can't handle initializing in declaration */
#if defined(_MSC_VER) && _MSC_VER < 1300
const int Prepared_statement::IS_IN_USE= 1;
#endif
/******************************************************************************
Implementation
@ -1830,7 +1824,7 @@ static bool init_param_array(Prepared_statement *stmt)
void mysql_stmt_prepare(THD *thd, const char *packet, uint packet_length)
{
Prepared_statement *stmt= new Prepared_statement(thd, &thd->protocol_prep);
bool rc;
bool error;
DBUG_ENTER("mysql_stmt_prepare");
DBUG_PRINT("prep_query", ("%s", packet));
@ -1853,12 +1847,12 @@ void mysql_stmt_prepare(THD *thd, const char *packet, uint packet_length)
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(),QUERY_PRIOR);
rc= stmt->prepare(packet, packet_length);
error= stmt->prepare(packet, packet_length);
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(),WAIT_PRIOR);
if (rc)
if (error)
{
/* Statement map deletes statement on erase */
thd->stmt_map.erase(stmt);
@ -1900,7 +1894,7 @@ static const char *get_dynamic_sql_string(LEX *lex, uint *query_len)
CHARSET_INFO *to_cs= thd->variables.collation_connection;
bool needs_conversion;
user_var_entry *entry;
String *pstr= &str;
String *var_value= &str;
uint32 unused, len;
/*
Convert @var contents to string in connection character set. Although
@ -1914,13 +1908,13 @@ static const char *get_dynamic_sql_string(LEX *lex, uint *query_len)
&& entry->value)
{
my_bool is_var_null;
pstr= entry->val_str(&is_var_null, &str, NOT_FIXED_DEC);
var_value= entry->val_str(&is_var_null, &str, NOT_FIXED_DEC);
/*
NULL value of variable checked early as entry->value so here
we can't get NULL in normal conditions
*/
DBUG_ASSERT(!is_var_null);
if (!pstr)
if (!var_value)
goto end;
}
else
@ -1932,22 +1926,25 @@ static const char *get_dynamic_sql_string(LEX *lex, uint *query_len)
str.set("NULL", 4, &my_charset_latin1);
}
needs_conversion= String::needs_conversion(pstr->length(),
pstr->charset(), to_cs, &unused);
needs_conversion= String::needs_conversion(var_value->length(),
var_value->charset(), to_cs,
&unused);
len= needs_conversion ? pstr->length() * to_cs->mbmaxlen : pstr->length();
len= (needs_conversion ? var_value->length() * to_cs->mbmaxlen :
var_value->length());
if (!(query_str= alloc_root(thd->mem_root, len+1)))
goto end;
if (needs_conversion)
{
uint dummy_errors;
len= copy_and_convert(query_str, len, to_cs, pstr->ptr(), pstr->length(),
pstr->charset(), &dummy_errors);
len= copy_and_convert(query_str, len, to_cs, var_value->ptr(),
var_value->length(), var_value->charset(),
&dummy_errors);
}
else
memcpy(query_str, pstr->ptr(), pstr->length());
query_str[len]= '\0';
memcpy(query_str, var_value->ptr(), var_value->length());
query_str[len]= '\0'; // Safety (mostly for debug)
*query_len= len;
}
else
@ -1997,10 +1994,9 @@ void mysql_sql_stmt_prepare(THD *thd)
Prepared_statement *stmt;
const char *query;
uint query_len;
DBUG_ENTER("mysql_sql_stmt_prepare");
DBUG_ASSERT(thd->protocol == &thd->protocol_simple);
if ((stmt= (Prepared_statement*) thd->stmt_map.find_by_name(name)))
{
/*
@ -2182,7 +2178,7 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length)
uchar *packet_end= (uchar *) packet + packet_length - 1;
#endif
Prepared_statement *stmt;
bool rc;
bool error;
DBUG_ENTER("mysql_stmt_execute");
packet+= 9; /* stmt_id + 5 bytes of flags */
@ -2217,12 +2213,11 @@ void mysql_stmt_execute(THD *thd, char *packet, uint packet_length)
#endif
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(),QUERY_PRIOR);
rc= stmt->execute(&expanded_query,
test(flags & (ulong) CURSOR_TYPE_READ_ONLY));
error= stmt->execute(&expanded_query,
test(flags & (ulong) CURSOR_TYPE_READ_ONLY));
if (!(specialflag & SPECIAL_NO_PRIOR))
my_pthread_setprio(pthread_self(), WAIT_PRIOR);
if (rc == 0)
if (error == 0)
mysql_log.write(thd, COM_STMT_EXECUTE, "[%lu] %s", stmt->id, thd->query);
DBUG_VOID_RETURN;
@ -2261,9 +2256,7 @@ void mysql_sql_stmt_execute(THD *thd)
LEX_STRING *name= &lex->prepared_stmt_name;
/* Query text for binary, general or slow log, if any of them is open */
String expanded_query;
DBUG_ENTER("mysql_sql_stmt_execute");
DBUG_PRINT("info", ("EXECUTE: %.*s\n", name->length, name->str));
if (!(stmt= (Prepared_statement*) thd->stmt_map.find_by_name(name)))
@ -2408,7 +2401,6 @@ void mysql_stmt_close(THD *thd, char *packet)
/* There is always space for 4 bytes in packet buffer */
ulong stmt_id= uint4korr(packet);
Prepared_statement *stmt;
DBUG_ENTER("mysql_stmt_close");
if (!(stmt= find_prepared_statement(thd, stmt_id, "mysql_stmt_close")))
@ -2418,7 +2410,7 @@ void mysql_stmt_close(THD *thd, char *packet)
The only way currently a statement can be deallocated when it's
in use is from within Dynamic SQL.
*/
DBUG_ASSERT(! (stmt->flags & Prepared_statement::IS_IN_USE));
DBUG_ASSERT(! (stmt->flags & (uint) Prepared_statement::IS_IN_USE));
(void) stmt->deallocate();
DBUG_VOID_RETURN;
@ -2462,7 +2454,7 @@ void mysql_sql_stmt_close(THD *thd)
mysql_stmt_get_longdata()
thd Thread handle
packet String to append
packet_length Length of string
packet_length Length of string (including end \0)
DESCRIPTION
Get a part of a long data. To make the protocol efficient, we are
@ -2479,13 +2471,12 @@ void mysql_stmt_get_longdata(THD *thd, char *packet, ulong packet_length)
Prepared_statement *stmt;
Item_param *param;
char *packet_end= packet + packet_length - 1;
DBUG_ENTER("mysql_stmt_get_longdata");
statistic_increment(thd->status_var.com_stmt_send_long_data, &LOCK_status);
#ifndef EMBEDDED_LIBRARY
/* Minimal size of long data packet is 6 bytes */
if ((ulong) (packet_end - packet) < MYSQL_LONG_DATA_HEADER)
if (packet_length <= MYSQL_LONG_DATA_HEADER)
{
my_error(ER_WRONG_ARGUMENTS, MYF(0), "mysql_stmt_send_long_data");
DBUG_VOID_RETURN;
@ -2592,7 +2583,7 @@ Prepared_statement::Prepared_statement(THD *thd_arg, Protocol *protocol_arg)
param_array(0),
param_count(0),
last_errno(0),
flags(IS_IN_USE)
flags((uint) IS_IN_USE)
{
*last_error= '\0';
}
@ -2709,7 +2700,7 @@ bool Prepared_statement::set_name(LEX_STRING *name_arg)
bool Prepared_statement::prepare(const char *packet, uint packet_len)
{
bool rc;
bool error;
Statement stmt_backup;
Query_arena *old_stmt_arena;
DBUG_ENTER("Prepared_statement::prepare");
@ -2740,7 +2731,7 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
lex->safe_to_cache_query= FALSE;
lex->stmt_prepare_mode= TRUE;
rc= yyparse((void *)thd) || thd->is_fatal_error ||
error= yyparse((void *)thd) || thd->is_fatal_error ||
thd->net.report_error || init_param_array(this);
/*
While doing context analysis of the query (in check_prepared_statement)
@ -2764,10 +2755,10 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
*/
DBUG_ASSERT(thd->free_list == NULL);
if (rc == 0)
rc= check_prepared_statement(this, name.str != 0);
if (error == 0)
error= check_prepared_statement(this, name.str != 0);
if (rc && lex->sphead)
if (error && lex->sphead)
{
delete lex->sphead;
lex->sphead= NULL;
@ -2777,14 +2768,14 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
thd->restore_backup_statement(this, &stmt_backup);
thd->stmt_arena= old_stmt_arena;
if (rc == 0)
if (error == 0)
{
setup_set_params();
init_stmt_after_parse(lex);
state= Query_arena::PREPARED;
flags&= ~IS_IN_USE;
flags&= ~ (uint) IS_IN_USE;
}
DBUG_RETURN(rc);
DBUG_RETURN(error);
}
/*
@ -2806,6 +2797,10 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
Preconditions, postconditions.
------------------------------
See the comment for Prepared_statement::prepare().
RETURN
FALSE ok
TRUE Error
*/
bool Prepared_statement::execute(String *expanded_query, bool open_cursor)
@ -2813,7 +2808,7 @@ bool Prepared_statement::execute(String *expanded_query, bool open_cursor)
Statement stmt_backup;
Query_arena *old_stmt_arena;
Item *old_free_list;
bool rc= TRUE;
bool error= TRUE;
statistic_increment(thd->status_var.com_stmt_execute, &LOCK_status);
@ -2823,7 +2818,7 @@ bool Prepared_statement::execute(String *expanded_query, bool open_cursor)
my_message(last_errno, last_error, MYF(0));
return TRUE;
}
if (flags & IS_IN_USE)
if (flags & (uint) IS_IN_USE)
{
my_error(ER_PS_NO_RECURSION, MYF(0));
return TRUE;
@ -2885,9 +2880,10 @@ bool Prepared_statement::execute(String *expanded_query, bool open_cursor)
reinit_stmt_before_use(thd, lex);
thd->protocol= protocol; /* activate stmt protocol */
rc= open_cursor ? mysql_open_cursor(thd, (uint) ALWAYS_MATERIALIZED_CURSOR,
&result, &cursor) :
mysql_execute_command(thd);
error= (open_cursor ?
mysql_open_cursor(thd, (uint) ALWAYS_MATERIALIZED_CURSOR,
&result, &cursor) :
mysql_execute_command(thd));
thd->protocol= &thd->protocol_simple; /* use normal protocol */
/* Assert that if an error, no cursor is open */
@ -2906,8 +2902,8 @@ bool Prepared_statement::execute(String *expanded_query, bool open_cursor)
state= Query_arena::EXECUTED;
error:
flags&= ~IS_IN_USE;
return rc;
flags&= ~ (uint) IS_IN_USE;
return error;
}
@ -2917,7 +2913,7 @@ bool Prepared_statement::deallocate()
{
/* We account deallocate in the same manner as mysql_stmt_close */
statistic_increment(thd->status_var.com_stmt_close, &LOCK_status);
if (flags & IS_IN_USE)
if (flags & (uint) IS_IN_USE)
{
my_error(ER_PS_NO_RECURSION, MYF(0));
return TRUE;

18
sql/sql_table.cc
View File

@ -1571,7 +1571,7 @@ bool mysql_create_table(THD *thd,const char *db, const char *table_name,
DBUG_RETURN(TRUE);
}
if (wait_if_global_read_lock(thd, 0, 1))
DBUG_RETURN(error);
DBUG_RETURN(TRUE);
VOID(pthread_mutex_lock(&LOCK_open));
if (!internal_tmp_table && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
{
@ -1636,20 +1636,20 @@ bool mysql_create_table(THD *thd,const char *db, const char *table_name,
mysql_bin_log.write(&qinfo);
}
error= FALSE;
goto end;
warn:
error= 0;
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
alias);
create_info->table_existed= 1; // Mark that table existed
end:
VOID(pthread_mutex_unlock(&LOCK_open));
start_waiting_global_read_lock(thd);
thd->proc_info="After create";
DBUG_RETURN(error);
warn:
error= FALSE;
push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
alias);
create_info->table_existed= 1; // Mark that table existed
goto end;
}
/*

2
sql/structs.h
View File

@ -20,7 +20,7 @@
struct st_table;
class Field;
#define STRING_WITH_LEN(X) X, (sizeof(X)-1)
#define STRING_WITH_LEN(X) ((char*) X), (sizeof(X)-1)
typedef struct st_lex_string
{

16
sql/table.cc
View File

@ -457,9 +457,11 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat,
{
outparam->null_flags=null_pos=(uchar*) record+1;
null_bit_pos= (db_create_options & HA_OPTION_PACK_RECORD) ? 0 : 1;
/* null_bytes below is only correct under the condition that
there are no bit fields. Correct values is set below after the
table struct is initialized */
/*
null_bytes below is only correct under the condition that
there are no bit fields. Correct values is set below after the
table struct is initialized
*/
share->null_bytes= (share->null_fields + null_bit_pos + 7) / 8;
}
else
@ -872,8 +874,12 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat,
}
}
/* the correct null_bytes can now be set, since bitfields have been taken into account */
share->null_bytes= null_pos - (uchar*) outparam->null_flags + (null_bit_pos + 7) / 8;
/*
the correct null_bytes can now be set, since bitfields have been taken
into account
*/
share->null_bytes= (null_pos - (uchar*) outparam->null_flags +
(null_bit_pos + 7) / 8);
share->last_null_bit_pos= null_bit_pos;
/* The table struct is now initialized; Open the table */

2
sql/table.h
View File

@ -585,8 +585,6 @@ typedef struct st_table_list
bool compact_view_format; /* Use compact format for SHOW CREATE VIEW */
/* view where processed */
bool where_processed;
/* db part was not defined in table definition */
bool current_db_used;
/* FRMTYPE_ERROR if any type is acceptable */
enum frm_type_enum required_type;
char timestamp_buffer[20]; /* buffer for timestamp (19+1) */

2
strings/decimal.c
View File

@ -2018,7 +2018,7 @@ int decimal_mul(decimal_t *from1, decimal_t *from2, decimal_t *to)
if (to->buf < buf1)
{
dec1 *cur_d= to->buf;
for (; d_to_move; d_to_move--, cur_d++, buf1++)
for (; d_to_move--; cur_d++, buf1++)
*cur_d= *buf1;
}
return error;

137
strings/longlong2str-x86.s
View File

@ -26,95 +26,88 @@
.type longlong2str_with_dig_vector,@function
longlong2str_with_dig_vector:
subl $80,%esp
subl $80,%esp # Temporary buffer for up to 64 radix-2 digits
pushl %ebp
pushl %esi
pushl %edi
pushl %ebx
movl 100(%esp),%esi # Lower part of val
movl 112(%esp),%ebx # Radix
movl 104(%esp),%ebp # Higher part of val
movl %ebx,%eax
movl 108(%esp),%edi # get dst
testl %eax,%eax
jge .L144
movl 100(%esp),%esi # esi = Lower part of val
movl 112(%esp),%ebx # ebx = Radix
movl 104(%esp),%ebp # ebp = Higher part of val
movl 108(%esp),%edi # edi = dst
addl $36,%eax
cmpl $34,%eax
ja .Lerror # Wrong radix
testl %ebp,%ebp
jge .L146
testl %ebx,%ebx
jge .L144 # Radix was positive
negl %ebx # Change radix to positive
testl %ebp,%ebp # Test if given value is negative
jge .L144
movb $45,(%edi) # Add sign
incl %edi # Change sign of val
negl %esi
adcl $0,%ebp
negl %ebp
.L146:
negl %ebx # Change radix to positive
jmp .L148
.align 4
.L144:
addl $-2,%eax
.L144: # Test that radix is between 2 and 36
movl %ebx, %eax
addl $-2,%eax # Test that radix is between 2 and 36
cmpl $34,%eax
ja .Lerror # Radix in range
ja .Lerror # Radix was not in range
.L148:
movl %esi,%eax # Test if zero (for easy loop)
orl %ebp,%eax
jne .L150
movb $48,(%edi)
incl %edi
jmp .L10_end
.align 4
.L150:
leal 92(%esp),%ecx # End of buffer
movl %edi, 108(%esp) # Store possible modified dest
movl 116(%esp), %edi # dig_vec_upper
jmp .L155
.align 4
testl %ebp,%ebp # Test if value > 0xFFFFFFFF
jne .Llongdiv
cmpl %ebx, %esi # Test if <= radix, for easy loop
movl %esi, %eax # Value in eax (for Llow)
jae .Llow
.L153:
# val is stored in in ebp:esi
# Value is one digit (negative or positive)
movb (%eax,%edi),%bl
movl 108(%esp),%edi # get dst
movb %bl,(%edi)
incl %edi # End null here
jmp .L10_end
movl %ebp,%eax # High part of value
.Llongdiv:
# Value in ebp:esi. div the high part by the radix,
# then div remainder + low part by the radix.
movl %ebp,%eax # edx=0,eax=high(from ebp)
xorl %edx,%edx
decl %ecx
divl %ebx
movl %eax,%ebp
movl %eax,%ebp # edx=result of last, eax=low(from esi)
movl %esi,%eax
divl %ebx
decl %ecx
movl %eax,%esi # quotent in ebp:esi
movb (%edx,%edi),%al # al is faster than dl
movb %al,(%ecx) # store value in buff
.align 4
.L155:
movl %eax,%esi # ebp:esi = quotient
movb (%edx,%edi),%dl # Store result number in temporary buffer
testl %ebp,%ebp
ja .L153
testl %esi,%esi # rest value
jl .L153
je .L160 # Ready
movl %esi,%eax
movb %dl,(%ecx) # store value in buff
ja .Llongdiv # (Higher part of val still > 0)
.align 4
.L154: # Do rest with integer precision
cltd
divl %ebx
.Llow: # Do rest with integer precision
# Value in 0:eax. div 0 + low part by the radix.
xorl %edx,%edx
decl %ecx
divl %ebx
movb (%edx,%edi),%dl # bh is always zero as ebx=radix < 36
testl %eax,%eax
movb %dl,(%ecx)
jne .L154
jne .Llow
.L160:
movl 108(%esp),%edi # get dst
.L10_mov:
movl %ecx,%esi
leal 92(%esp),%ecx # End of buffer
subl %esi,%ecx
rep
movsb
.Lcopy_end:
leal 92(%esp),%esi # End of buffer
.Lmov: # mov temporary buffer to result (%ecx -> %edi)
movb (%ecx), %al
movb %al, (%edi)
incl %ecx
incl %edi
cmpl %ecx,%esi
jne .Lmov
.L10_end:
movl %edi,%eax # Pointer to end null
@ -166,21 +159,23 @@ longlong10_to_str:
negl %esi # Change sign of val (ebp:esi)
adcl $0,%ebp
negl %ebp
.align 4
.L10_10:
leal 92(%esp),%ecx # End of buffer
movl %esi,%eax # Test if zero (for easy loop)
orl %ebp,%eax
jne .L10_30 # Not zero
testl %ebp,%ebp # Test if value > 0xFFFFFFFF
jne .L10_longdiv
cmpl $10, %esi # Test if <= radix, for easy loop
movl %esi, %ebx # Value in eax (for L10_low)
jae .L10_low
# Here when value is zero
movb $48,(%edi)
# Value is one digit (negative or positive)
addb $48, %bl
movb %bl,(%edi)
incl %edi
jmp .L10_end
.align 4
.L10_20:
.L10_longdiv:
# val is stored in in ebp:esi
movl %ebp,%eax # High part of value
xorl %edx,%edx
@ -195,17 +190,15 @@ longlong10_to_str:
.L10_30:
testl %ebp,%ebp
ja .L10_20
testl %esi,%esi # rest value
jl .L10_20 # Unsigned, do ulonglong div once more
je .L10_mov # Ready
ja .L10_longdiv
movl %esi,%ebx # Move val to %ebx
.L10_low:
# The following code uses some tricks to change division by 10 to
# multiplication and shifts
movl $0xcccccccd,%esi
.L10_40:
.L10_40: # Divide %ebx with 10
movl %ebx,%eax
mull %esi
decl %ecx
@ -218,7 +211,7 @@ longlong10_to_str:
movl %edx,%ebx
testl %ebx,%ebx
jne .L10_40
jmp .L10_mov # Shared end with longlong10_to_str
jmp .Lcopy_end # Shared end with longlong2str
.L10end:
.size longlong10_to_str,.L10end-longlong10_to_str

4
strings/my_strtoll10.c
View File

@ -21,8 +21,8 @@
#undef ULONGLONG_MAX
/* Needed under MetroWerks Compiler, since MetroWerks compiler does not properly handle a constant expression containing a mod operator */
#if defined(__NETWARE__) && defined(__MWERKS__)
ulonglong tmp;
#define ULONGLONG_MAX (tmp =(~(ulonglong) 0))
static ulonglong ulonglong_max= ~(ulonglong) 0;
#define ULONGLONG_MAX ulonglong_max
#else
#define ULONGLONG_MAX (~(ulonglong) 0)
#endif /* __NETWARE__ && __MWERKS__ */