mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-22 06:44:16 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge bk-internal.mysql.com:/home/bk/mysql-5.1-marvel

Browse source 
into  mysql.com:/home/my/mysql-5.1
This commit is contained in:
monty@narttu.mysql.fi 2007-08-14 15:22:44 +03:00
commit 914620e0c0
142 changed files with 1910 additions and 1172 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
BUILD/compile-solaris-sparc-forte
View file

@ -3,7 +3,13 @@
# Assume Forte is installed in /opt/SUNWSpro and ld is installed in
# /usr/ccs/bin
PATH=/opt/SUNWspro/bin/:/usr/ccs/bin:$PATH
PATH=/opt/SUNWspro/bin:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin:$PATH
prefix="/usr/local/mysql"
if test -n "$MYSQL_BUILD_PREFIX"
then
prefix="$MYSQL_BUILD_PREFIX"
fi
make -k maintainer-clean || true
/bin/rm -f */.deps/*.P config.cache
@ -12,9 +18,9 @@ path=`dirname $0`
. "$path/autorun.sh"
# For "optimal" code for this computer add -fast to EXTRA
# To compile 64 bit, add -xarch=v9 to EXTRA_64_BIT
# To compile 32/64 bit, uncomment/comment EXTRA_64_BIT
EXTRA_64_BIT="-xarch=v9" # Remove comment to get 64 bit binaries
EXTRA_64_BIT="-m64"
EXTRA="-fast" # Remove comment to target current machine
#
@ -22,10 +28,9 @@ EXTRA="-fast" # Remove comment to target current machine
#
STD="-mt -D_FORTEC_ $EXTRA $EXTRA_64_BIT"
ASFLAGS="$EXTRA_64_BIT" \
CC=cc-5.0 CFLAGS="-Xa -xstrconst $STD" \
CXX=CC CXXFLAGS="-noex $STD" \
./configure --prefix=/usr/local/mysql --enable-assembler --with-extra-charsets=complex --enable-thread-safe-client
./configure --prefix=/usr/local/mysql --enable-assembler --with-extra-charsets=complex --enable-thread-safe-client --prefix=$PREFIX
make -j 4
if [ $? = 0 ]

20
client/mysql.cc
View file

@ -196,6 +196,8 @@ void tee_putc(int c, FILE *file);
static void tee_print_sized_data(const char *, unsigned int, unsigned int, bool);
/* The names of functions that actually do the manipulation. */
static int get_options(int argc,char **argv);
extern "C" my_bool get_one_option(int optid, const struct my_option *opt,
char *argument);
static int com_quit(String *str,char*),
com_go(String *str,char*), com_ego(String *str,char*),
com_print(String *str,char*),
@ -349,8 +351,8 @@ static ulong start_timer(void);
static void end_timer(ulong start_time,char *buff);
static void mysql_end_timer(ulong start_time,char *buff);
static void nice_time(double sec,char *buff,bool part_second);
static sig_handler mysql_end(int sig);
static sig_handler handle_sigint(int sig);
extern "C" sig_handler mysql_end(int sig);
extern "C" sig_handler handle_sigint(int sig);
int main(int argc,char *argv[])
{
@ -814,7 +816,7 @@ and you are welcome to modify and redistribute it under the GPL license\n");
}
static my_bool
my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
char *argument)
{
@ -1427,7 +1429,7 @@ static bool add_line(String &buffer,char *line,char *in_string,
#ifdef HAVE_READLINE
static char *new_command_generator(const char *text, int);
static char **new_mysql_completion (const char *text, int start, int end);
extern "C" char **new_mysql_completion (const char *text, int start, int end);
/*
Tell the GNU Readline library how to complete. We want to try to complete
@ -1436,9 +1438,9 @@ static char **new_mysql_completion (const char *text, int start, int end);
*/
#if defined(USE_NEW_READLINE_INTERFACE) || defined(USE_LIBEDIT_INTERFACE)
char *no_completion(const char*,int)
extern "C" char *no_completion(const char*,int)
#else
char *no_completion()
extern "C" char *no_completion()
#endif
{
return 0; /* No filename completion */
@ -1540,9 +1542,9 @@ static void initialize_readline (char *name)
array of matches, or NULL if there aren't any.
*/
static char **new_mysql_completion (const char *text,
int start __attribute__((unused)),
int end __attribute__((unused)))
char **new_mysql_completion (const char *text,
int start __attribute__((unused)),
int end __attribute__((unused)))
{
if (!status.batch && !quick)
#if defined(USE_NEW_READLINE_INTERFACE)

2
client/mysql_upgrade.c
View file

@ -451,7 +451,7 @@ static int run_query(const char *query, DYNAMIC_STRING *ds_res,
MYF(MY_WME))) < 0)
die("Failed to create temporary file for defaults");
if (my_write(fd, query, strlen(query),
if (my_write(fd, (uchar*) query, strlen(query),
MYF(MY_FNABP | MY_WME)))
die("Failed to write to '%s'", query_file_path);

8
client/mysqladmin.cc
View file

@ -71,10 +71,12 @@ static uint ex_var_count, max_var_length, max_val_length;
static void print_version(void);
static void usage(void);
extern "C" my_bool get_one_option(int optid, const struct my_option *opt,
char *argument);
static my_bool sql_connect(MYSQL *mysql, uint wait);
static int execute_commands(MYSQL *mysql,int argc, char **argv);
static int drop_db(MYSQL *mysql,const char *db);
static sig_handler endprog(int signal_number);
extern "C" sig_handler endprog(int signal_number);
static void nice_time(ulong sec,char *buff);
static void print_header(MYSQL_RES *result);
static void print_top(MYSQL_RES *result);
@ -230,7 +232,7 @@ static struct my_option my_long_options[] =
static const char *load_default_groups[]= { "mysqladmin","client",0 };
static my_bool
my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
char *argument)
{
@ -430,7 +432,7 @@ int main(int argc,char *argv[])
}
static sig_handler endprog(int signal_number __attribute__((unused)))
sig_handler endprog(int signal_number __attribute__((unused)))
{
interrupted=1;
}

4
client/mysqlbinlog.cc
View file

@ -1030,14 +1030,14 @@ static int dump_log_entries(const char* logname)
like CREATE PROCEDURE safely
*/
fprintf(result_file, "DELIMITER /*!*/;\n");
strcpy(print_event_info.delimiter, "/*!*/;");
strmov(print_event_info.delimiter, "/*!*/;");
rc= (remote_opt ? dump_remote_log_entries(&print_event_info, logname) :
dump_local_log_entries(&print_event_info, logname));
/* Set delimiter back to semicolon */
fprintf(result_file, "DELIMITER ;\n");
strcpy(print_event_info.delimiter, ";");
strmov(print_event_info.delimiter, ";");
return rc;
}

4
client/mysqlcheck.c
View file

@ -677,7 +677,7 @@ static void print_result()
*/
if (found_error && opt_auto_repair && what_to_do != DO_REPAIR &&
strcmp(row[3],"OK"))
insert_dynamic(&tables4repair, prev);
insert_dynamic(&tables4repair, (uchar*) prev);
found_error=0;
if (opt_silent)
continue;
@ -697,7 +697,7 @@ static void print_result()
}
/* add the last table to be repaired to the list */
if (found_error && opt_auto_repair && what_to_do != DO_REPAIR)
insert_dynamic(&tables4repair, prev);
insert_dynamic(&tables4repair, (uchar*) prev);
mysql_free_result(res);
}

572
client/mysqldump.c
View file

@ -1236,6 +1236,125 @@ static int switch_character_set_results(MYSQL *mysql, const char *cs_name)
return mysql_real_query(mysql, query_buffer, query_length);
}
/**
Rewrite CREATE TRIGGER statement, enclosing DEFINER clause in
version-specific comment.
This function parses the CREATE TRIGGER statement and encloses
DEFINER-clause in version-specific comment:
input query: CREATE DEFINER=a@b TRIGGER ...
rewritten query: CREATE * / / *!50017 DEFINER=a@b * / / *!50003 TRIGGER ...
@note This function will go away when WL#3995 is implemented.
@param[in] trigger_def_str CREATE TRIGGER statement string.
@param[in] trigger_def_length length of the trigger_def_str.
@return pointer to the new allocated query string.
*/
static char *cover_definer_clause_in_trigger(const char *trigger_def_str,
uint trigger_def_length)
{
char *query_str= NULL;
char *definer_begin= my_case_str(trigger_def_str, trigger_def_length,
C_STRING_WITH_LEN(" DEFINER"));
char *definer_end;
if (!definer_begin)
return NULL;
definer_end= my_case_str(definer_begin, strlen(definer_begin),
C_STRING_WITH_LEN(" TRIGGER"));
if (definer_end)
{
char *query_str_tail;
/*
Allocate memory for new query string: original string
from SHOW statement and version-specific comments.
*/
query_str= alloc_query_str(trigger_def_length + 23);
query_str_tail= strnmov(query_str,
trigger_def_str,
definer_begin - trigger_def_str);
query_str_tail= strmov(query_str_tail,
"*/ /*!50017");
query_str_tail= strnmov(query_str_tail,
definer_begin,
definer_end - definer_begin);
query_str_tail= strxmov(query_str_tail,
"*/ /*!50003",
definer_end,
NullS);
}
return query_str;
}
/**
Rewrite CREATE FUNCTION or CREATE PROCEDURE statement, enclosing DEFINER
clause in version-specific comment.
This function parses the CREATE FUNCTION | PROCEDURE statement and
encloses DEFINER-clause in version-specific comment:
input query: CREATE DEFINER=a@b FUNCTION ...
rewritten query: CREATE * / / *!50020 DEFINER=a@b * / / *!50003 FUNCTION ...
@note This function will go away when WL#3995 is implemented.
@param[in] def_str CREATE FUNCTION|PROCEDURE statement string.
@param[in] def_length length of the def_str.
@return pointer to the new allocated query string.
*/
static char *cover_definer_clause_in_sp(const char *def_str,
uint def_str_length)
{
char *query_str= NULL;
char *definer_begin= my_case_str(def_str, def_str_length,
C_STRING_WITH_LEN(" DEFINER"));
char *definer_end;
if (!definer_begin)
return NULL;
definer_end= my_case_str(definer_begin, strlen(definer_begin),
C_STRING_WITH_LEN(" PROCEDURE"));
if (!definer_end)
{
definer_end= my_case_str(definer_begin, strlen(definer_begin),
C_STRING_WITH_LEN(" FUNCTION"));
}
if (definer_end)
{
char *query_str_tail;
/*
Allocate memory for new query string: original string
from SHOW statement and version-specific comments.
*/
query_str= alloc_query_str(def_str_length + 23);
query_str_tail= strnmov(query_str, def_str, definer_begin - def_str);
query_str_tail= strmov(query_str_tail, "*/ /*!50020");
query_str_tail= strnmov(query_str_tail, definer_begin,
definer_end - definer_begin);
query_str_tail= strxmov(query_str_tail, "*/ /*!50003",
definer_end, NullS);
}
return query_str;
}
/*
Open a new .sql file to dump the table or view into
@ -1710,7 +1829,7 @@ static uint dump_events_for_db(char *db)
MYSQL_ROW row, event_list_row;
char db_cl_name[MY_CS_NAME_SIZE];
int db_cl_altered;
int db_cl_altered= FALSE;
DBUG_ENTER("dump_events_for_db");
DBUG_PRINT("enter", ("db: '%s'", db));
@ -1775,16 +1894,36 @@ static uint dump_events_for_db(char *db)
fprintf(sql_file, "DELIMITER %s\n", delimiter);
if (switch_db_collation(sql_file, db_name_buff, delimiter, db_cl_name,
row[6], &db_cl_altered))
if (mysql_num_fields(event_res) >= 7)
{
DBUG_RETURN(1);
}
if (switch_db_collation(sql_file, db_name_buff, delimiter,
db_cl_name, row[6], &db_cl_altered))
{
DBUG_RETURN(1);
}
switch_cs_variables(sql_file, delimiter,
row[4], /* character_set_client */
row[4], /* character_set_results */
row[5]); /* collation_connection */
switch_cs_variables(sql_file, delimiter,
row[4], /* character_set_client */
row[4], /* character_set_results */
row[5]); /* collation_connection */
}
else
{
/*
mysqldump is being run against the server, that does not
provide character set information in SHOW CREATE
statements.
NOTE: the dump may be incorrect, since character set
information is required in order to restore event properly.
*/
fprintf(sql_file,
"--\n"
"-- WARNING: old server version. "
"The following dump may be incomplete.\n"
"--\n");
}
switch_sql_mode(sql_file, delimiter, row[1]);
@ -1797,13 +1936,17 @@ static uint dump_events_for_db(char *db)
restore_time_zone(sql_file, delimiter);
restore_sql_mode(sql_file, delimiter);
restore_cs_variables(sql_file, delimiter);
if (db_cl_altered)
if (mysql_num_fields(event_res) >= 7)
{
if (restore_db_collation(sql_file, db_name_buff, delimiter,
db_cl_name))
DBUG_RETURN(1);
restore_cs_variables(sql_file, delimiter);
if (db_cl_altered)
{
if (restore_db_collation(sql_file, db_name_buff, delimiter,
db_cl_name))
DBUG_RETURN(1);
}
}
}
} /* end of event printing */
@ -1871,7 +2014,7 @@ static uint dump_routines_for_db(char *db)
MYSQL_ROW row, routine_list_row;
char db_cl_name[MY_CS_NAME_SIZE];
int db_cl_altered;
int db_cl_altered= FALSE;
DBUG_ENTER("dump_routines_for_db");
DBUG_PRINT("enter", ("db: '%s'", db));
@ -1938,74 +2081,45 @@ static uint dump_routines_for_db(char *db)
}
else if (strlen(row[2]))
{
char *query_str= NULL;
char *definer_begin;
char *query_str;
if (opt_drop)
fprintf(sql_file, "/*!50003 DROP %s IF EXISTS %s */;\n",
routine_type[i], routine_name);
/*
Cover DEFINER-clause in version-specific comments.
query_str= cover_definer_clause_in_sp(row[2], strlen(row[2]));
TODO: this is definitely a BAD IDEA to parse SHOW CREATE output.
However, we can not use INFORMATION_SCHEMA instead:
1. INFORMATION_SCHEMA provides data in UTF8, but here we
need data in the original character set;
2. INFORMATION_SCHEMA does not provide information about
routine parameters now.
*/
definer_begin= my_case_str(row[2], strlen(row[2]),
C_STRING_WITH_LEN(" DEFINER"));
if (definer_begin)
if (mysql_num_fields(routine_res) >= 6)
{
char *definer_end= my_case_str(definer_begin,
strlen(definer_begin),
C_STRING_WITH_LEN(" PROCEDURE"));
if (!definer_end)
if (switch_db_collation(sql_file, db_name_buff, ";",
db_cl_name, row[5], &db_cl_altered))
{
definer_end= my_case_str(definer_begin, strlen(definer_begin),
C_STRING_WITH_LEN(" FUNCTION"));
DBUG_RETURN(1);
}
if (definer_end)
{
char *query_str_tail;
/*
Allocate memory for new query string: original string
from SHOW statement and version-specific comments.
*/
query_str= alloc_query_str(strlen(row[2]) + 23);
query_str_tail= strnmov(query_str, row[2],
definer_begin - row[2]);
query_str_tail= strmov(query_str_tail, "*/ /*!50020");
query_str_tail= strnmov(query_str_tail, definer_begin,
definer_end - definer_begin);
query_str_tail= strxmov(query_str_tail, "*/ /*!50003",
definer_end, NullS);
}
switch_cs_variables(sql_file, ";",
row[3], /* character_set_client */
row[3], /* character_set_results */
row[4]); /* collation_connection */
}
/*
we need to change sql_mode only for the CREATE
PROCEDURE/FUNCTION otherwise we may need to re-quote routine_name
*/
if (switch_db_collation(sql_file, db_name_buff, ";",
db_cl_name, row[5], &db_cl_altered))
else
{
DBUG_RETURN(1);
/*
mysqldump is being run against the server, that does not
provide character set information in SHOW CREATE
statements.
NOTE: the dump may be incorrect, since character set
information is required in order to restore stored
procedure/function properly.
*/
fprintf(sql_file,
"--\n"
"-- WARNING: old server version. "
"The following dump may be incomplete.\n"
"--\n");
}
switch_cs_variables(sql_file, ";",
row[3], /* character_set_client */
row[3], /* character_set_results */
row[4]); /* collation_connection */
switch_sql_mode(sql_file, ";", row[1]);
@ -2016,12 +2130,16 @@ static uint dump_routines_for_db(char *db)
(const char *) (query_str != NULL ? query_str : row[2]));
restore_sql_mode(sql_file, ";");
restore_cs_variables(sql_file, ";");
if (db_cl_altered)
if (mysql_num_fields(routine_res) >= 6)
{
if (restore_db_collation(sql_file, db_name_buff, ";", db_cl_name))
DBUG_RETURN(1);
restore_cs_variables(sql_file, ";");
if (db_cl_altered)
{
if (restore_db_collation(sql_file, db_name_buff, ";", db_cl_name))
DBUG_RETURN(1);
}
}
my_free(query_str, MYF(MY_ALLOW_ZERO_PTR));
@ -2560,153 +2678,211 @@ continue_xml:
DBUG_RETURN((uint) num_fields);
} /* get_table_structure */
static void dump_trigger_old(MYSQL_RES *show_triggers_rs,
MYSQL_ROW *show_trigger_row,
const char *table_name)
{
FILE *sql_file= md_result_file;
/*
char quoted_table_name_buf[NAME_LEN * 2 + 3];
char *quoted_table_name= quote_name(table_name, quoted_table_name_buf, 1);
dump_triggers_for_table
char name_buff[NAME_LEN * 4 + 3];
Dumps the triggers given a table/db name. This should be called after
the tables have been dumped in case a trigger depends on the existence
of a table
DBUG_ENTER("dump_trigger_old");
fprintf(sql_file,
"--\n"
"-- WARNING: old server version. "
"The following dump may be incomplete.\n"
"--\n");
if (opt_compact)
fprintf(sql_file, "/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE*/;\n");
fprintf(sql_file,
"DELIMITER ;;\n"
"/*!50003 SET SESSION SQL_MODE=\"%s\" */;;\n"
"/*!50003 CREATE */ ",
(*show_trigger_row)[6]);
if (mysql_num_fields(show_triggers_rs) > 7)
{
/*
mysqldump can be run against the server, that does not support
definer in triggers (there is no DEFINER column in SHOW TRIGGERS
output). So, we should check if we have this column before
accessing it.
*/
size_t user_name_len;
char user_name_str[USERNAME_LENGTH + 1];
char quoted_user_name_str[USERNAME_LENGTH * 2 + 3];
size_t host_name_len;
char host_name_str[HOSTNAME_LENGTH + 1];
char quoted_host_name_str[HOSTNAME_LENGTH * 2 + 3];
parse_user((*show_trigger_row)[7],
strlen((*show_trigger_row)[7]),
user_name_str, &user_name_len,
host_name_str, &host_name_len);
fprintf(sql_file,
"/*!50017 DEFINER=%s@%s */ ",
quote_name(user_name_str, quoted_user_name_str, FALSE),
quote_name(host_name_str, quoted_host_name_str, FALSE));
}
fprintf(sql_file,
"/*!50003 TRIGGER %s %s %s ON %s FOR EACH ROW%s%s */;;\n"
"DELIMITER ;\n",
quote_name((*show_trigger_row)[0], name_buff, 0), /* Trigger */
(*show_trigger_row)[4], /* Timing */
(*show_trigger_row)[1], /* Event */
quoted_table_name,
(strchr(" \t\n\r", *((*show_trigger_row)[3]))) ? "" : " ",
(*show_trigger_row)[3] /* Statement */);
if (opt_compact)
fprintf(sql_file, "/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE */;\n");
DBUG_VOID_RETURN;
}
static int dump_trigger(MYSQL_RES *show_create_trigger_rs,
const char *db_name,
const char *db_cl_name)
{
FILE *sql_file= md_result_file;
MYSQL_ROW row;
int db_cl_altered= FALSE;
DBUG_ENTER("dump_trigger");
while ((row= mysql_fetch_row(show_create_trigger_rs)))
{
char *query_str= cover_definer_clause_in_trigger(row[2], strlen(row[2]));
if (switch_db_collation(sql_file, db_name, ";",
db_cl_name, row[5], &db_cl_altered))
DBUG_RETURN(TRUE);
switch_cs_variables(sql_file, ";",
row[3], /* character_set_client */
row[3], /* character_set_results */
row[4]); /* collation_connection */
switch_sql_mode(sql_file, ";", row[1]);
fprintf(sql_file,
"DELIMITER ;;\n"
"/*!50003 %s */;;\n"
"DELIMITER ;\n",
(const char *) (query_str != NULL ? query_str : row[2]));
restore_sql_mode(sql_file, ";");
restore_cs_variables(sql_file, ";");
if (db_cl_altered)
{
if (restore_db_collation(sql_file, db_name, ";", db_cl_name))
DBUG_RETURN(TRUE);
}
my_free(query_str, MYF(MY_ALLOW_ZERO_PTR));
}
DBUG_RETURN(FALSE);
}
/**
Dump the triggers for a given table.
This should be called after the tables have been dumped in case a trigger
depends on the existence of a table.
@param[in] table_name
@param[in] db_name
@return Error status.
@retval TRUE error has occurred.
@retval FALSE operation succeed.
*/
static void dump_triggers_for_table(char *table, char *db_name)
static int dump_triggers_for_table(char *table_name, char *db_name)
{
char *result_table;
char name_buff[NAME_LEN*4+3], table_buff[NAME_LEN*2+3];
char name_buff[NAME_LEN*4+3];
char query_buff[QUERY_LENGTH];
uint old_opt_compatible_mode=opt_compatible_mode;
FILE *sql_file= md_result_file;
MYSQL_RES *result;
uint old_opt_compatible_mode= opt_compatible_mode;
MYSQL_RES *show_triggers_rs;
MYSQL_ROW row;
char db_cl_name[MY_CS_NAME_SIZE];
int db_cl_altered;
DBUG_ENTER("dump_triggers_for_table");
DBUG_PRINT("enter", ("db: %s, table: %s", db_name, table));
DBUG_PRINT("enter", ("db: %s, table_name: %s", db_name, table_name));
/* Do not use ANSI_QUOTES on triggers in dump */
opt_compatible_mode&= ~MASK_ANSI_QUOTES;
result_table= quote_name(table, table_buff, 1);
my_snprintf(query_buff, sizeof(query_buff),
"SHOW TRIGGERS LIKE %s",
quote_for_like(table, name_buff));
if (mysql_query_with_error_report(mysql, &result, query_buff))
{
if (path)
my_fclose(sql_file, MYF(MY_WME));
DBUG_VOID_RETURN;
}
/* Get database collation. */
if (fetch_db_collation(db_name, db_cl_name, sizeof (db_cl_name)))
DBUG_VOID_RETURN;
if (switch_character_set_results(mysql, "binary"))
DBUG_VOID_RETURN;
DBUG_RETURN(TRUE);
if (fetch_db_collation(db_name, db_cl_name, sizeof (db_cl_name)))
DBUG_RETURN(TRUE);
/* Get list of triggers. */
my_snprintf(query_buff, sizeof(query_buff),
"SHOW TRIGGERS LIKE %s",
quote_for_like(table_name, name_buff));
if (mysql_query_with_error_report(mysql, &show_triggers_rs, query_buff))
DBUG_RETURN(TRUE);
/* Dump triggers. */
while ((row= mysql_fetch_row(result)))
while ((row= mysql_fetch_row(show_triggers_rs)))
{
MYSQL_RES *res2;
my_snprintf(query_buff, sizeof (query_buff),
"SHOW CREATE TRIGGER %s",
quote_name(row[0], name_buff, TRUE));
if (mysql_query_with_error_report(mysql, &res2, query_buff))
if (mysql_query(mysql, query_buff))
{
if (path)
my_fclose(sql_file, MYF(MY_WME));
maybe_exit(EX_MYSQLERR);
DBUG_VOID_RETURN;
}
while ((row= mysql_fetch_row(res2)))
{
char *query_str= NULL;
char *definer_begin;
/*
Cover DEFINER-clause in version-specific comments.
mysqldump is being run against old server, that does not support
SHOW CREATE TRIGGER statement. We should use SHOW TRIGGERS output.
TODO: this is definitely a BAD IDEA to parse SHOW CREATE output.
However, we can not use INFORMATION_SCHEMA instead:
1. INFORMATION_SCHEMA provides data in UTF8, but here we
need data in the original character set;
2. INFORMATION_SCHEMA does not provide information about
routine parameters now.
NOTE: the dump may be incorrect, as old SHOW TRIGGERS does not
provide all the necessary information to restore trigger properly.
*/
definer_begin= my_case_str(row[2], strlen(row[2]),
C_STRING_WITH_LEN(" DEFINER"));
if (definer_begin)
{
char *definer_end= my_case_str(definer_begin, strlen(definer_begin),
C_STRING_WITH_LEN(" TRIGGER"));
if (definer_end)
{
char *query_str_tail;
/*
Allocate memory for new query string: original string
from SHOW statement and version-specific comments.
*/
query_str= alloc_query_str(strlen(row[2]) + 23);
query_str_tail= strnmov(query_str, row[2],
definer_begin - row[2]);
query_str_tail= strmov(query_str_tail, "*/ /*!50017");
query_str_tail= strnmov(query_str_tail, definer_begin,
definer_end - definer_begin);
query_str_tail= strxmov(query_str_tail, "*/ /*!50003",
definer_end, NullS);
}
}
if (switch_db_collation(sql_file, db_name, ";",
db_cl_name, row[5], &db_cl_altered))
DBUG_VOID_RETURN;
switch_cs_variables(sql_file, ";",
row[3], /* character_set_client */
row[3], /* character_set_results */
row[4]); /* collation_connection */
switch_sql_mode(sql_file, ";", row[1]);
fprintf(sql_file,
"DELIMITER ;;\n"
"/*!50003 %s */;;\n"
"DELIMITER ;\n",
(const char *) (query_str != NULL ? query_str : row[2]));
restore_sql_mode(sql_file, ";");
restore_cs_variables(sql_file, ";");
if (db_cl_altered)
{
if (restore_db_collation(sql_file, db_name, ";", db_cl_name))
DBUG_VOID_RETURN;
}
my_free(query_str, MYF(MY_ALLOW_ZERO_PTR));
dump_trigger_old(show_triggers_rs, &row, table_name);
}
mysql_free_result(res2);
else
{
MYSQL_RES *show_create_trigger_rs= mysql_store_result(mysql);
if (!show_create_trigger_rs ||
dump_trigger(show_create_trigger_rs, db_name, db_cl_name))
{
DBUG_RETURN(TRUE);
}
mysql_free_result(show_create_trigger_rs);
}
}
mysql_free_result(result);
mysql_free_result(show_triggers_rs);
if (switch_character_set_results(mysql, default_charset))
DBUG_VOID_RETURN;
DBUG_RETURN(TRUE);
/*
make sure to set back opt_compatible mode to
@ -2714,7 +2890,7 @@ static void dump_triggers_for_table(char *table, char *db_name)
*/
opt_compatible_mode=old_opt_compatible_mode;
DBUG_VOID_RETURN;
DBUG_RETURN(FALSE);
}
static void add_load_option(DYNAMIC_STRING *str, const char *option,
@ -3737,9 +3913,9 @@ static int init_dumping(char *database, int init_func(char*))
/* Return 1 if we should copy the table */
my_bool include_table(uchar* hash_key, uint len)
my_bool include_table(const uchar *hash_key, size_t len)
{
return !hash_search(&ignore_table, (uchar*) hash_key, len);
return !hash_search(&ignore_table, hash_key, len);
}
@ -3767,7 +3943,7 @@ static int dump_all_tables_in_db(char *database)
for (numrows= 0 ; (table= getTableName(1)) ; )
{
char *end= strmov(afterdot, table);
if (include_table(hash_key,end - hash_key))
if (include_table((uchar*) hash_key,end - hash_key))
{
numrows++;
dynstr_append_checked(&query, quote_name(table, table_buff, 1));
@ -3788,14 +3964,21 @@ static int dump_all_tables_in_db(char *database)
while ((table= getTableName(0)))
{
char *end= strmov(afterdot, table);
if (include_table(hash_key, end - hash_key))
if (include_table((uchar*) hash_key, end - hash_key))
{
dump_table(table,database);
my_free(order_by, MYF(MY_ALLOW_ZERO_PTR));
order_by= 0;
if (opt_dump_triggers && ! opt_xml &&
mysql_get_server_version(mysql) >= 50009)
dump_triggers_for_table(table, database);
{
if (dump_triggers_for_table(table, database))
{
if (path)
my_fclose(md_result_file, MYF(MY_WME));
maybe_exit(EX_MYSQLERR);
}
}
}
}
if (opt_events && !opt_xml &&
@ -3860,7 +4043,7 @@ static my_bool dump_all_views_in_db(char *database)
for (numrows= 0 ; (table= getTableName(1)); )
{
char *end= strmov(afterdot, table);
if (include_table(hash_key,end - hash_key))
if (include_table((uchar*) hash_key,end - hash_key))
{
numrows++;
dynstr_append_checked(&query, quote_name(table, table_buff, 1));
@ -3881,7 +4064,7 @@ static my_bool dump_all_views_in_db(char *database)
while ((table= getTableName(0)))
{
char *end= strmov(afterdot, table);
if (include_table(hash_key, end - hash_key))
if (include_table((uchar*) hash_key, end - hash_key))
get_view_structure(table, database);
}
if (opt_xml)
@ -4021,7 +4204,14 @@ static int dump_selected_tables(char *db, char **table_names, int tables)
dump_table(*pos, db);
if (opt_dump_triggers &&
mysql_get_server_version(mysql) >= 50009)
dump_triggers_for_table(*pos, db);
{
if (dump_triggers_for_table(*pos, db))
{
if (path)
my_fclose(md_result_file, MYF(MY_WME));
maybe_exit(EX_MYSQLERR);
}
}
}
/* Dump each selected view */

10
client/mysqlslap.c
View file

@ -1354,7 +1354,7 @@ get_options(int *argc,char ***argv)
}
tmp_string= (char *)my_malloc(sbuf.st_size + 1,
MYF(MY_ZEROFILL|MY_FAE|MY_WME));
my_read(data_file, tmp_string, sbuf.st_size, MYF(0));
my_read(data_file, (uchar*) tmp_string, sbuf.st_size, MYF(0));
tmp_string[sbuf.st_size]= '\0';
my_close(data_file,MYF(0));
parse_delimiter(tmp_string, &create_statements, delimiter[0]);
@ -1381,7 +1381,7 @@ get_options(int *argc,char ***argv)
}
tmp_string= (char *)my_malloc(sbuf.st_size + 1,
MYF(MY_ZEROFILL|MY_FAE|MY_WME));
my_read(data_file, tmp_string, sbuf.st_size, MYF(0));
my_read(data_file, (uchar*) tmp_string, sbuf.st_size, MYF(0));
tmp_string[sbuf.st_size]= '\0';
my_close(data_file,MYF(0));
if (user_supplied_query)
@ -1412,7 +1412,7 @@ get_options(int *argc,char ***argv)
}
tmp_string= (char *)my_malloc(sbuf.st_size + 1,
MYF(MY_ZEROFILL|MY_FAE|MY_WME));
my_read(data_file, tmp_string, sbuf.st_size, MYF(0));
my_read(data_file, (uchar*) tmp_string, sbuf.st_size, MYF(0));
tmp_string[sbuf.st_size]= '\0';
my_close(data_file,MYF(0));
if (user_supplied_pre_statements)
@ -1443,7 +1443,7 @@ get_options(int *argc,char ***argv)
}
tmp_string= (char *)my_malloc(sbuf.st_size + 1,
MYF(MY_ZEROFILL|MY_FAE|MY_WME));
my_read(data_file, tmp_string, sbuf.st_size, MYF(0));
my_read(data_file, (uchar*) tmp_string, sbuf.st_size, MYF(0));
tmp_string[sbuf.st_size]= '\0';
my_close(data_file,MYF(0));
if (user_supplied_post_statements)
@ -2076,7 +2076,7 @@ print_conclusions_csv(conclusions *con)
con->users, /* Children used */
con->avg_rows /* Queries run */
);
my_write(csv_file, buffer, (uint)strlen(buffer), MYF(0));
my_write(csv_file, (uchar*) buffer, (uint)strlen(buffer), MYF(0));
}
void

6
client/mysqltest.c
View file

@ -1514,7 +1514,7 @@ void var_query_set(VAR *var, const char *query, const char** query_end)
void var_set_query_get_value(struct st_command *command, VAR *var)
{
ulong row_no;
long row_no;
int col_no= -1;
MYSQL_RES* res;
MYSQL* mysql= &cur_con->mysql;
@ -1591,7 +1591,7 @@ void var_set_query_get_value(struct st_command *command, VAR *var)
while ((row= mysql_fetch_row(res)))
{
if (++rows == row_no)
if (++rows == (ulong) row_no)
{
DBUG_PRINT("info", ("At row %ld, column %d is '%s'",
@ -2584,7 +2584,7 @@ void do_send_quit(struct st_command *command)
DBUG_PRINT("info", ("con->name: %s", con->name));
if (!strcmp(con->name, name))
{
simple_command(&con->mysql,COM_QUIT,NullS,0,1);
simple_command(&con->mysql,COM_QUIT,0,0,1);
DBUG_VOID_RETURN;
}
}

6
client/sql_string.cc
View file

@ -805,10 +805,8 @@ copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
const uchar *from_end= (const uchar*) from+from_length;
char *to_start= to;
uchar *to_end= (uchar*) to+to_length;
int (*mb_wc)(struct charset_info_st *, my_wc_t *, const uchar *,
const uchar *) = from_cs->cset->mb_wc;
int (*wc_mb)(struct charset_info_st *, my_wc_t, uchar *s, uchar *e)=
to_cs->cset->wc_mb;
my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
uint error_count= 0;
while (1)

3
configure.in
View file

@ -743,7 +743,7 @@ AC_CHECK_HEADERS(fcntl.h float.h floatingpoint.h ieeefp.h limits.h \
unistd.h utime.h sys/utime.h termio.h termios.h sched.h crypt.h alloca.h \
sys/ioctl.h malloc.h sys/malloc.h sys/ipc.h sys/shm.h linux/config.h \
sys/prctl.h \
sys/resource.h sys/param.h port.h)
sys/resource.h sys/param.h port.h ieeefp.h)
AC_CHECK_HEADERS([xfs/xfs.h])
@ -757,6 +757,7 @@ AC_CHECK_LIB(m, floor, [], AC_CHECK_LIB(m, __infinity))
AC_CHECK_LIB(nsl_r, gethostbyname_r, [],
AC_CHECK_LIB(nsl, gethostbyname_r))
AC_CHECK_FUNC(gethostbyname_r)
AC_CHECK_LIB(mtmalloc, malloc)
AC_CHECK_FUNC(setsockopt, , AC_CHECK_LIB(socket, setsockopt))
AC_CHECK_FUNC(yp_get_default_domain, ,

9
extra/replace.c
View file

@ -309,9 +309,9 @@ static int insert_pointer_name(reg1 POINTER_ARRAY *pa,char * name)
old_count*sizeof(*pa->flag));
}
pa->flag[pa->typelib.count]=0; /* Reset flag */
pa->typelib.type_names[pa->typelib.count++]= pa->str+pa->length;
pa->typelib.type_names[pa->typelib.count++]= (char*) (pa->str+pa->length);
pa->typelib.type_names[pa->typelib.count]= NullS; /* Put end-mark */
VOID(strmov(pa->str+pa->length,name));
VOID(strmov((char*) pa->str + pa->length, name));
pa->length+=length;
DBUG_RETURN(0);
} /* insert_pointer_name */
@ -988,7 +988,8 @@ int n;
return 0;
/* Read in new stuff. */
if ((i=(int) my_read(fd, buffer + bufbytes, (uint) bufread,MYF(MY_WME))) < 0)
if ((i=(int) my_read(fd, (uchar*) buffer + bufbytes,
(size_t) bufread, MYF(MY_WME))) < 0)
return -1;
/* Kludge to pretend every nonempty file ends with a newline. */
@ -1039,7 +1040,7 @@ FILE *in,*out;
return 1;
if (!my_eof)
out_buff[length++]=save_char; /* Don't write added newline */
if (my_fwrite(out,out_buff,length,MYF(MY_WME | MY_NABP)))
if (my_fwrite(out, (uchar*) out_buff, length, MYF(MY_WME | MY_NABP)))
DBUG_RETURN(1);
}
}

25
include/m_ctype.h
View file

@ -170,6 +170,14 @@ extern MY_COLLATION_HANDLER my_collation_8bit_bin_handler;
extern MY_COLLATION_HANDLER my_collation_8bit_simple_ci_handler;
extern MY_COLLATION_HANDLER my_collation_ucs2_uca_handler;
/* Some typedef to make it easy for C++ to make function pointers */
typedef int (*my_charset_conv_mb_wc)(struct charset_info_st *, my_wc_t *,
const uchar *, const uchar *);
typedef int (*my_charset_conv_wc_mb)(struct charset_info_st *, my_wc_t,
uchar *, uchar *);
typedef size_t (*my_charset_conv_case)(struct charset_info_st *,
char *, size_t, char *, size_t);
/* See strings/CHARSET_INFO.txt about information on this structure */
typedef struct my_charset_handler_st
@ -188,11 +196,9 @@ typedef struct my_charset_handler_st
size_t (*numcells)(struct charset_info_st *, const char *b, const char *e);
/* Unicode conversion */
int (*mb_wc)(struct charset_info_st *cs,my_wc_t *wc,
const uchar *s,const uchar *e);
int (*wc_mb)(struct charset_info_st *cs,my_wc_t wc,
uchar *s,uchar *e);
my_charset_conv_mb_wc mb_wc;
my_charset_conv_wc_mb wc_mb;
/* CTYPE scanner */
int (*ctype)(struct charset_info_st *cs, int *ctype,
const uchar *s, const uchar *e);
@ -200,11 +206,10 @@ typedef struct my_charset_handler_st
/* Functions for case and sort conversion */
size_t (*caseup_str)(struct charset_info_st *, char *);
size_t (*casedn_str)(struct charset_info_st *, char *);
size_t (*caseup)(struct charset_info_st *, char *src, size_t srclen,
char *dst, size_t dstlen);
size_t (*casedn)(struct charset_info_st *, char *src, size_t srclen,
char *dst, size_t dstlen);
my_charset_conv_case caseup;
my_charset_conv_case casedn;
/* Charset dependant snprintf() */
size_t (*snprintf)(struct charset_info_st *, char *to, size_t n,
const char *fmt,

1
include/my_sys.h
View file

@ -225,6 +225,7 @@ extern CHARSET_INFO compiled_charsets[];
/* statistics */
extern ulong my_file_opened,my_stream_opened, my_tmp_file_created;
extern ulong my_file_total_opened;
extern uint mysys_usage_id;
extern my_bool my_init_done;

2
include/myisam.h
View file

@ -455,7 +455,7 @@ typedef struct st_sort_info
enum data_file_type new_data_file_type;
MI_INFO *info;
MI_CHECK *param;
char *buff;
uchar *buff;
SORT_KEY_BLOCKS *key_block,*key_block_end;
SORT_FT_BUF *ft_buf;
/* sync things */

75
libmysql/libmysql.c
View file

@ -341,7 +341,7 @@ my_bool STDCALL mysql_master_send_query(MYSQL *mysql, const char *q,
DBUG_RETURN(1);
master->reconnect= 1;
mysql->last_used_con = master;
DBUG_RETURN(simple_command(master, COM_QUERY, q, length, 1));
DBUG_RETURN(simple_command(master, COM_QUERY, (const uchar*) q, length, 1));
}
@ -375,7 +375,8 @@ my_bool STDCALL mysql_slave_send_query(MYSQL *mysql, const char *q,
0,0,0,0))
DBUG_RETURN(1);
slave_to_use->reconnect= 1;
DBUG_RETURN(simple_command(slave_to_use, COM_QUERY, q, length, 1));
DBUG_RETURN(simple_command(slave_to_use, COM_QUERY, (const uchar*) q,
length, 1));
}
@ -669,7 +670,8 @@ int cli_read_change_user_result(MYSQL *mysql, char *buff, const char *passwd)
password in old format. The reply contains scramble_323.
*/
scramble_323(buff, mysql->scramble, passwd);
if (my_net_write(net, buff, SCRAMBLE_LENGTH_323 + 1) || net_flush(net))
if (my_net_write(net, (uchar*) buff, SCRAMBLE_LENGTH_323 + 1) ||
net_flush(net))
{
net->last_errno= CR_SERVER_LOST;
strmov(net->sqlstate, unknown_sqlstate);
@ -720,7 +722,7 @@ my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
end= strmov(end, db ? db : "") + 1;
/* Write authentication package */
simple_command(mysql,COM_CHANGE_USER, buff,(ulong) (end-buff),1);
simple_command(mysql,COM_CHANGE_USER, (uchar*) buff, (ulong) (end-buff), 1);
rc= (*mysql->methods->read_change_user_result)(mysql, buff, passwd);
@ -830,7 +832,7 @@ my_bool handle_local_infile(MYSQL *mysql, const char *net_filename)
if ((*options->local_infile_init)(&li_ptr, net_filename,
options->local_infile_userdata))
{
VOID(my_net_write(net,"",0)); /* Server needs one packet */
VOID(my_net_write(net,(const uchar*) "",0)); /* Server needs one packet */
net_flush(net);
strmov(net->sqlstate, unknown_sqlstate);
net->last_errno= (*options->local_infile_error)(li_ptr,
@ -844,7 +846,7 @@ my_bool handle_local_infile(MYSQL *mysql, const char *net_filename)
(*options->local_infile_read)(li_ptr, buf,
packet_length)) > 0)
{
if (my_net_write(net,buf,readcount))
if (my_net_write(net, (uchar*) buf, readcount))
{
DBUG_PRINT("error",
("Lost connection to MySQL server during LOAD DATA of local file"));
@ -856,7 +858,7 @@ my_bool handle_local_infile(MYSQL *mysql, const char *net_filename)
}
/* Send empty packet to mark end of file */
if (my_net_write(net,"",0) || net_flush(net))
if (my_net_write(net, (const uchar*) "", 0) || net_flush(net))
{
strmov(net->sqlstate, unknown_sqlstate);
net->last_errno=CR_SERVER_LOST;
@ -1242,7 +1244,8 @@ mysql_list_fields(MYSQL *mysql, const char *table, const char *wild)
end=strmake(strmake(buff, table,128)+1,wild ? wild : "",128);
free_old_query(mysql);
if (simple_command(mysql,COM_FIELD_LIST,buff,(ulong) (end-buff),1) ||
if (simple_command(mysql, COM_FIELD_LIST, (uchar*) buff,
(ulong) (end-buff), 1) ||
!(fields= (*mysql->methods->list_fields)(mysql)))
DBUG_RETURN(NULL);
@ -1313,7 +1316,7 @@ mysql_shutdown(MYSQL *mysql, enum mysql_enum_shutdown_level shutdown_level)
uchar level[1];
DBUG_ENTER("mysql_shutdown");
level[0]= (uchar) shutdown_level;
DBUG_RETURN(simple_command(mysql, COM_SHUTDOWN, (char *)level, 1, 0));
DBUG_RETURN(simple_command(mysql, COM_SHUTDOWN, level, 1, 0));
}
@ -1323,14 +1326,14 @@ mysql_refresh(MYSQL *mysql,uint options)
uchar bits[1];
DBUG_ENTER("mysql_refresh");
bits[0]= (uchar) options;
DBUG_RETURN(simple_command(mysql,COM_REFRESH,(char*) bits,1,0));
DBUG_RETURN(simple_command(mysql, COM_REFRESH, bits, 1, 0));
}
int STDCALL
mysql_kill(MYSQL *mysql,ulong pid)
{
char buff[4];
uchar buff[4];
DBUG_ENTER("mysql_kill");
int4store(buff,pid);
DBUG_RETURN(simple_command(mysql,COM_PROCESS_KILL,buff,sizeof(buff),0));
@ -1340,7 +1343,7 @@ mysql_kill(MYSQL *mysql,ulong pid)
int STDCALL
mysql_set_server_option(MYSQL *mysql, enum enum_mysql_set_option option)
{
char buff[2];
uchar buff[2];
DBUG_ENTER("mysql_set_server_option");
int2store(buff, (uint) option);
DBUG_RETURN(simple_command(mysql, COM_SET_OPTION, buff, sizeof(buff), 0));
@ -2059,7 +2062,7 @@ mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, ulong length)
if ((int) stmt->state > (int) MYSQL_STMT_INIT_DONE)
{
/* This is second prepare with another statement */
char buff[MYSQL_STMT_HEADER]; /* 4 bytes - stmt id */
uchar buff[MYSQL_STMT_HEADER]; /* 4 bytes - stmt id */
if (reset_stmt_handle(stmt, RESET_LONG_DATA | RESET_STORE_RESULT))
DBUG_RETURN(1);
@ -2089,7 +2092,7 @@ mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, ulong length)
}
}
if (stmt_command(mysql, COM_STMT_PREPARE, query, length, stmt))
if (stmt_command(mysql, COM_STMT_PREPARE, (const uchar*) query, length, stmt))
{
set_stmt_errmsg(stmt, mysql->net.last_error, mysql->net.last_errno,
mysql->net.sqlstate);
@ -2425,9 +2428,9 @@ static void store_param_str(NET *net, MYSQL_BIND *param)
{
/* param->length is always set in mysql_stmt_bind_param */
ulong length= *param->length;
char *to= (char *) net_store_length((char *) net->write_pos, length);
uchar *to= net_store_length(net->write_pos, length);
memcpy(to, param->buffer, length);
net->write_pos= (uchar*) to+length;
net->write_pos= to+length;
}
@ -2495,10 +2498,9 @@ static my_bool execute(MYSQL_STMT *stmt, char *packet, ulong length)
{
MYSQL *mysql= stmt->mysql;
NET *net= &mysql->net;
char buff[4 /* size of stmt id */ +
5 /* execution flags */];
uchar buff[4 /* size of stmt id */ +
5 /* execution flags */];
my_bool res;
DBUG_ENTER("execute");
DBUG_DUMP("packet", packet, length);
@ -2508,7 +2510,7 @@ static my_bool execute(MYSQL_STMT *stmt, char *packet, ulong length)
int4store(buff+5, 1); /* iteration count */
res= test(cli_advanced_command(mysql, COM_STMT_EXECUTE, buff, sizeof(buff),
packet, length, 1, NULL) ||
(uchar*) packet, length, 1, NULL) ||
(*mysql->methods->read_query_result)(mysql));
stmt->affected_rows= mysql->affected_rows;
stmt->server_status= mysql->server_status;
@ -2587,7 +2589,7 @@ int cli_stmt_execute(MYSQL_STMT *stmt)
}
length= (ulong) (net->write_pos - net->buff);
/* TODO: Look into avoding the following memdup */
if (!(param_data= my_memdup((const char*) net->buff, length, MYF(0))))
if (!(param_data= my_memdup(net->buff, length, MYF(0))))
{
set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate);
DBUG_RETURN(1);
@ -2714,8 +2716,8 @@ stmt_read_row_from_cursor(MYSQL_STMT *stmt, unsigned char **row)
MYSQL *mysql= stmt->mysql;
NET *net= &mysql->net;
MYSQL_DATA *result= &stmt->result;
char buff[4 /* statement id */ +
4 /* number of rows to fetch */];
uchar buff[4 /* statement id */ +
4 /* number of rows to fetch */];
free_root(&result->alloc, MYF(MY_KEEP_PREALLOC));
result->data= NULL;
@ -2724,7 +2726,7 @@ stmt_read_row_from_cursor(MYSQL_STMT *stmt, unsigned char **row)
int4store(buff, stmt->stmt_id);
int4store(buff + 4, stmt->prefetch_rows); /* number of rows to fetch */
if ((*mysql->methods->advanced_command)(mysql, COM_STMT_FETCH,
buff, sizeof(buff), NullS, 0,
buff, sizeof(buff), (uchar*) 0, 0,
1, NULL))
{
set_stmt_errmsg(stmt, net->last_error, net->last_errno, net->sqlstate);
@ -3380,7 +3382,7 @@ mysql_stmt_send_long_data(MYSQL_STMT *stmt, uint param_number,
{
MYSQL *mysql= stmt->mysql;
/* Packet header: stmt id (4 bytes), param no (2 bytes) */
char buff[MYSQL_LONG_DATA_HEADER];
uchar buff[MYSQL_LONG_DATA_HEADER];
int4store(buff, stmt->stmt_id);
int2store(buff + 4, param_number);
@ -3391,7 +3393,7 @@ mysql_stmt_send_long_data(MYSQL_STMT *stmt, uint param_number,
This is intentional to save bandwidth.
*/
if ((*mysql->methods->advanced_command)(mysql, COM_STMT_SEND_LONG_DATA,
buff, sizeof(buff), data,
buff, sizeof(buff), (uchar*) data,
length, 1, NULL))
{
set_stmt_errmsg(stmt, mysql->net.last_error,
@ -3719,19 +3721,20 @@ static void fetch_long_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field,
}
default:
{
char buff[22]; /* Enough for longlong */
char *end= longlong10_to_str(value, buff, is_unsigned ? 10: -10);
uchar buff[22]; /* Enough for longlong */
uchar *end= (uchar*) longlong10_to_str(value, (char*) buff,
is_unsigned ? 10: -10);
/* Resort to string conversion which supports all typecodes */
uint length= (uint) (end-buff);
if (field->flags & ZEROFILL_FLAG && length < field->length &&
field->length < 21)
{
bmove_upp((char*) buff+field->length,buff+length, length);
bfill((char*) buff, field->length - length,'0');
bmove_upp(buff+field->length,buff+length, length);
bfill(buff, field->length - length,'0');
length= field->length;
}
fetch_string_with_conversion(param, buff, length);
fetch_string_with_conversion(param, (char*) buff, length);
break;
}
}
@ -4785,14 +4788,14 @@ int STDCALL mysql_stmt_store_result(MYSQL_STMT *stmt)
Server side cursor exist, tell server to start sending the rows
*/
NET *net= &mysql->net;
char buff[4 /* statement id */ +
4 /* number of rows to fetch */];
uchar buff[4 /* statement id */ +
4 /* number of rows to fetch */];
/* Send row request to the server */
int4store(buff, stmt->stmt_id);
int4store(buff + 4, (int)~0); /* number of rows to fetch */
if (cli_advanced_command(mysql, COM_STMT_FETCH, buff, sizeof(buff),
NullS, 0, 1, NULL))
(uchar*) 0, 0, 1, NULL))
{
set_stmt_errmsg(stmt, net->last_error, net->last_errno, net->sqlstate);
DBUG_RETURN(1);
@ -4976,7 +4979,7 @@ static my_bool reset_stmt_handle(MYSQL_STMT *stmt, uint flags)
Reset the server side statement and close the server side
cursor if it exists.
*/
char buff[MYSQL_STMT_HEADER]; /* packet header: 4 bytes for stmt id */
uchar buff[MYSQL_STMT_HEADER]; /* packet header: 4 bytes for stmt id */
int4store(buff, stmt->stmt_id);
if ((*mysql->methods->advanced_command)(mysql, COM_STMT_RESET, buff,
sizeof(buff), 0, 0, 0, NULL))
@ -5037,7 +5040,7 @@ my_bool STDCALL mysql_stmt_close(MYSQL_STMT *stmt)
net_clear_error(&mysql->net);
if ((int) stmt->state > (int) MYSQL_STMT_INIT_DONE)
{
char buff[MYSQL_STMT_HEADER]; /* 4 bytes - stmt id */
uchar buff[MYSQL_STMT_HEADER]; /* 4 bytes - stmt id */
if (mysql->unbuffered_fetch_owner == &stmt->unbuffered_fetch_cancelled)
mysql->unbuffered_fetch_owner= 0;

4
libmysql/manager.c
View file

@ -158,7 +158,7 @@ MYSQL_MANAGER* STDCALL mysql_manager_connect(MYSQL_MANAGER* con,
}
sprintf(msg_buf,"%-.16s %-.16s\n",user,passwd);
msg_len=strlen(msg_buf);
if (my_net_write(&con->net,msg_buf,msg_len) || net_flush(&con->net))
if (my_net_write(&con->net,(uchar*) msg_buf,msg_len) || net_flush(&con->net))
{
con->last_errno=con->net.last_errno;
strmov(con->last_error,"Write error on socket");
@ -218,7 +218,7 @@ int STDCALL mysql_manager_command(MYSQL_MANAGER* con,const char* cmd,
{
if (!cmd_len)
cmd_len=strlen(cmd);
if (my_net_write(&con->net,(char*)cmd,cmd_len) || net_flush(&con->net))
if (my_net_write(&con->net,(const uchar*)cmd,cmd_len) || net_flush(&con->net))
{
con->last_errno=errno;
strmov(con->last_error,"Write error on socket");

4
mysql-test/r/ctype_cp932_binlog_stm.result
View file

@ -41,8 +41,8 @@ BEGIN
INSERT INTO t4 VALUES (ins1, ins2, ind);
END
master-bin.000001 783 Query 1 999 use `test`; INSERT INTO t4 VALUES ( NAME_CONST('ins1',_latin1 0x466F6F2773206120426172), NAME_CONST('ins2',_cp932 0xED40ED41ED42), NAME_CONST('ind',47.93))
master-bin.000001 999 Query 1 1085 use `test`; DROP PROCEDURE bug18293
master-bin.000001 1085 Query 1 1161 use `test`; DROP TABLE t4
master-bin.000001 999 Query 1 1088 use `test`; DROP PROCEDURE bug18293
master-bin.000001 1088 Query 1 1167 use `test`; DROP TABLE t4
End of 5.0 tests
SHOW BINLOG EVENTS FROM 364;
ERROR HY000: Error when executing command SHOW BINLOG EVENTS: Wrong offset or I/O error

14
mysql-test/r/federated.result
View file

@ -1920,6 +1920,20 @@ a b
2 Curly
drop table federated.t1;
drop table federated.t1;
Bug#18287 create federated table always times out, error 1159 ' '
Test that self-references work
create table federated.t1 (a int primary key);
create table federated.t2 (a int primary key)
ENGINE=FEDERATED
connection='mysql://root@127.0.0.1:SLAVE_PORT/federated/t1';
insert into federated.t1 (a) values (1);
select * from federated.t2;
a
1
drop table federated.t1, federated.t2;
CREATE TABLE federated.t1 (a INT PRIMARY KEY) DEFAULT CHARSET=utf8;
CREATE TABLE federated.t1 (a INT PRIMARY KEY)
ENGINE=FEDERATED

70
mysql-test/r/lock.result
View file

@ -96,4 +96,74 @@ ERROR HY000: You can't combine write-locking of system tables with other tables
LOCK TABLES mysql.time_zone READ, mysql.proc WRITE;
ERROR HY000: You can't combine write-locking of system tables with other tables or lock types
DROP TABLE t1;
Bug#5719 impossible to lock VIEW
Just covering existing behaviour with tests.
Consistency has not been found here.
drop view if exists v_bug5719;
drop table if exists t1, t2, t3;
create table t1 (a int);
create temporary table t2 (a int);
create table t3 (a int);
create view v_bug5719 as select 1;
lock table v_bug5719 write;
select * from t1;
ERROR HY000: Table 't1' was not locked with LOCK TABLES
Allowed to select from a temporary talbe under LOCK TABLES
select * from t2;
a
select * from t3;
ERROR HY000: Table 't3' was not locked with LOCK TABLES
select * from v_bug5719;
1
1
drop view v_bug5719;
sic: did not left LOCK TABLES mode automatically
select * from t1;
ERROR HY000: Table 't1' was not locked with LOCK TABLES
unlock tables;
create view v_bug5719 as select * from t1;
lock tables v_bug5719 write;
select * from v_bug5719;
a
Allowed to use an underlying table under LOCK TABLES <view>
select * from t1;
a
Allowed to select from a temporary table under LOCK TABLES
select * from t2;
a
select * from t3;
ERROR HY000: Table 't3' was not locked with LOCK TABLES
drop table t1;
sic: left LOCK TABLES mode
select * from t3;
a
select * from v_bug5719;
ERROR HY000: View 'test.v_bug5719' references invalid table(s) or column(s) or function(s) or definer/invoker of view lack rights to use them
unlock tables;
drop view v_bug5719;
When limitation to use temporary tables in views is removed, please
add a test that shows what happens under LOCK TABLES when a view
references a temporary table, is locked, and the underlying table
is dropped.
create view v_bug5719 as select * from t2;
ERROR HY000: View's SELECT refers to a temporary table 't2'
Cleanup.
drop table t2, t3;
End of 5.1 tests.

10
mysql-test/r/lock_multi.result
View file

@ -95,3 +95,13 @@ alter table t1 auto_increment=0; alter table t1 auto_increment=0; alter table t1
alter table t1 auto_increment=0; alter table t1 auto_increment=0; alter table t1 auto_increment=0; alter table t1 auto_increment=0; alter table t1 auto_increment=0; //
unlock tables;
drop table t1;
create table t1 (i int);
lock table t1 read;
update t1 set i= 10;;
select * from t1;;
kill query ID;
i
ERROR 70100: Query execution was interrupted
unlock tables;
drop table t1;
End of 5.1 tests

4
mysql-test/r/log_state.result
View file

@ -37,14 +37,14 @@ set session long_query_time=1;
select sleep(2);
sleep(2)
0
select * from mysql.slow_log;
select * from mysql.slow_log where sql_text NOT LIKE '%slow_log%';
start_time user_host query_time lock_time rows_sent rows_examined db last_insert_id insert_id server_id sql_text
set global slow_query_log= ON;
set session long_query_time=1;
select sleep(2);
sleep(2)
0
select * from mysql.slow_log;
select * from mysql.slow_log where sql_text NOT LIKE '%slow_log%';
start_time user_host query_time lock_time rows_sent rows_examined db last_insert_id insert_id server_id sql_text
TIMESTAMP USER_HOST QUERY_TIME 00:00:00 1 0 test 0 0 1 select sleep(2)
show global variables

14
mysql-test/t/federated.test
View file

@ -1725,6 +1725,20 @@ drop table federated.t1;
connection slave;
drop table federated.t1;
--echo
--echo Bug#18287 create federated table always times out, error 1159 ' '
--echo
--echo Test that self-references work
--echo
connection slave;
create table federated.t1 (a int primary key);
--replace_result $SLAVE_MYPORT SLAVE_PORT
eval create table federated.t2 (a int primary key)
ENGINE=FEDERATED
connection='mysql://root@127.0.0.1:$SLAVE_MYPORT/federated/t1';
insert into federated.t1 (a) values (1);
select * from federated.t2;
drop table federated.t1, federated.t2;
#
# BUG#29875 Disable support for transactions

65
mysql-test/t/lock.test
View file

@ -148,5 +148,70 @@ LOCK TABLES mysql.time_zone READ, mysql.proc WRITE;
DROP TABLE t1;
--echo
--echo Bug#5719 impossible to lock VIEW
--echo
--echo Just covering existing behaviour with tests.
--echo Consistency has not been found here.
--echo
--disable_warnings
drop view if exists v_bug5719;
drop table if exists t1, t2, t3;
--enable_warnings
create table t1 (a int);
create temporary table t2 (a int);
create table t3 (a int);
create view v_bug5719 as select 1;
lock table v_bug5719 write;
--error ER_TABLE_NOT_LOCKED
select * from t1;
--echo
--echo Allowed to select from a temporary talbe under LOCK TABLES
--echo
select * from t2;
--error ER_TABLE_NOT_LOCKED
select * from t3;
select * from v_bug5719;
drop view v_bug5719;
--echo
--echo sic: did not left LOCK TABLES mode automatically
--echo
--error ER_TABLE_NOT_LOCKED
select * from t1;
unlock tables;
create view v_bug5719 as select * from t1;
lock tables v_bug5719 write;
select * from v_bug5719;
--echo
--echo Allowed to use an underlying table under LOCK TABLES <view>
--echo
select * from t1;
--echo
--echo Allowed to select from a temporary table under LOCK TABLES
--echo
select * from t2;
--error ER_TABLE_NOT_LOCKED
select * from t3;
drop table t1;
--echo
--echo sic: left LOCK TABLES mode
--echo
select * from t3;
--error ER_VIEW_INVALID
select * from v_bug5719;
unlock tables;
drop view v_bug5719;
--echo
--echo When limitation to use temporary tables in views is removed, please
--echo add a test that shows what happens under LOCK TABLES when a view
--echo references a temporary table, is locked, and the underlying table
--echo is dropped.
--echo
--error ER_VIEW_SELECT_TMPTABLE
create view v_bug5719 as select * from t2;
--echo
--echo Cleanup.
--echo
drop table t2, t3;
--echo End of 5.1 tests.

35
mysql-test/t/lock_multi.test
View file

@ -270,3 +270,38 @@ drop table t1;
# End of 5.0 tests
#
# Bug #21281 "Pending write lock is incorrectly removed when its
# statement being KILLed"
#
create table t1 (i int);
connection locker;
lock table t1 read;
connection writer;
--send update t1 set i= 10;
connection reader;
let $wait_condition=
select count(*) = 1 from information_schema.processlist
where state = "Locked" and info = "update t1 set i= 10";
--source include/wait_condition.inc
--send select * from t1;
connection default;
let $wait_condition=
select count(*) = 1 from information_schema.processlist
where state = "Locked" and info = "select * from t1";
--source include/wait_condition.inc
let $ID= `select id from information_schema.processlist where state = "Locked" and info = "update t1 set i= 10"`;
--replace_result $ID ID
eval kill query $ID;
connection reader;
--reap
connection writer;
--error ER_QUERY_INTERRUPTED
--reap
connection locker;
unlock tables;
connection default;
drop table t1;
--echo End of 5.1 tests

4
mysql-test/t/log_state.test
View file

@ -28,7 +28,7 @@ connection con1;
set session long_query_time=1;
select sleep(2);
--replace_column 1 TIMESTAMP 2 USER_HOST 3 QUERY_TIME
select * from mysql.slow_log;
select * from mysql.slow_log where sql_text NOT LIKE '%slow_log%';
connection default;
set global slow_query_log= ON;
@ -36,7 +36,7 @@ connection con1;
set session long_query_time=1;
select sleep(2);
--replace_column 1 TIMESTAMP 2 USER_HOST 3 QUERY_TIME
select * from mysql.slow_log;
select * from mysql.slow_log where sql_text NOT LIKE '%slow_log%';
connection default;
show global variables
where Variable_name = 'log' or Variable_name = 'log_slow_queries' or

1
mysys/my_fopen.c
View file

@ -76,6 +76,7 @@ FILE *my_fopen(const char *filename, int flags, myf MyFlags)
my_strdup(filename,MyFlags)))
{
my_stream_opened++;
my_file_total_opened++;
my_file_info[fileno(fd)].type = STREAM_BY_FOPEN;
pthread_mutex_unlock(&THR_LOCK_open);
DBUG_PRINT("exit",("stream: 0x%lx", (long) fd));

1
mysys/my_open.c
View file

@ -151,6 +151,7 @@ File my_register_filename(File fd, const char *FileName, enum file_type
if ((my_file_info[fd].name = (char*) my_strdup(FileName,MyFlags)))
{
my_file_opened++;
my_file_total_opened++;
my_file_info[fd].type = type_of_file;
#if defined(THREAD) && !defined(HAVE_PREAD)
pthread_mutex_init(&my_file_info[fd].mutex,MY_MUTEX_INIT_FAST);

1
mysys/my_static.c
View file

@ -30,6 +30,7 @@ const char *my_progname=0;
char NEAR curr_dir[FN_REFLEN]= {0},
NEAR home_dir_buff[FN_REFLEN]= {0};
ulong my_stream_opened=0,my_file_opened=0, my_tmp_file_created=0;
ulong my_file_total_opened= 0;
int NEAR my_umask=0664, NEAR my_umask_dir=0777;
#ifndef THREAD
int NEAR my_errno=0;

51
mysys/thr_alarm.c
View file

@ -38,7 +38,7 @@ uint thr_client_alarm;
static int alarm_aborted=1; /* No alarm thread */
my_bool thr_alarm_inited= 0;
volatile my_bool alarm_thread_running= 0;
time_t next_alarm_expire_time= ~ (time_t) 0;
static sig_handler process_alarm_part2(int sig);
#if !defined(__WIN__)
@ -71,6 +71,7 @@ void init_thr_alarm(uint max_alarms)
sigset_t s;
DBUG_ENTER("init_thr_alarm");
alarm_aborted=0;
next_alarm_expire_time= ~ (time_t) 0;
init_queue(&alarm_queue,max_alarms+1,offsetof(ALARM,expire_time),0,
compare_ulong,NullS);
sigfillset(&full_signal_set); /* Neaded to block signals */
@ -150,22 +151,28 @@ void resize_thr_alarm(uint max_alarms)
my_bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm_data)
{
ulong now;
time_t now;
#ifndef USE_ONE_SIGNAL_HAND
sigset_t old_mask;
#endif
my_bool reschedule;
struct st_my_thread_var *current_my_thread_var= my_thread_var;
DBUG_ENTER("thr_alarm");
DBUG_PRINT("enter",("thread: %s sec: %d",my_thread_name(),sec));
now=(ulong) my_time(0);
now= my_time(0);
#ifndef USE_ONE_SIGNAL_HAND
pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
#endif
pthread_mutex_lock(&LOCK_alarm); /* Lock from threads & alarms */
if (alarm_aborted > 0)
{ /* No signal thread */
DBUG_PRINT("info", ("alarm aborted"));
*alrm= 0; /* No alarm */
pthread_mutex_unlock(&LOCK_alarm);
#ifndef USE_ONE_SIGNAL_HAND
pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
#endif
DBUG_RETURN(1);
}
if (alarm_aborted < 0)
@ -179,14 +186,14 @@ my_bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm_data)
fprintf(stderr,"Warning: thr_alarm queue is full\n");
*alrm= 0; /* No alarm */
pthread_mutex_unlock(&LOCK_alarm);
#ifndef USE_ONE_SIGNAL_HAND
pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
#endif
DBUG_RETURN(1);
}
max_used_alarms=alarm_queue.elements+1;
}
reschedule= (!alarm_queue.elements ||
(int) (((ALARM*) queue_top(&alarm_queue))->expire_time - now) >
(int) sec);
reschedule= (ulong) next_alarm_expire_time > (ulong) now + sec;
if (!alarm_data)
{
if (!(alarm_data=(ALARM*) my_malloc(sizeof(ALARM),MYF(MY_WME))))
@ -194,7 +201,9 @@ my_bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm_data)
DBUG_PRINT("info", ("failed my_malloc()"));
*alrm= 0; /* No alarm */
pthread_mutex_unlock(&LOCK_alarm);
#ifndef USE_ONE_SIGNAL_HAND
pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
#endif
DBUG_RETURN(1);
}
alarm_data->malloced=1;
@ -212,12 +221,17 @@ my_bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm_data)
{
DBUG_PRINT("info", ("reschedule"));
if (pthread_equal(pthread_self(),alarm_thread))
{
alarm(sec); /* purecov: inspected */
next_alarm_expire_time= now + sec;
}
else
reschedule_alarms(); /* Reschedule alarms */
}
pthread_mutex_unlock(&LOCK_alarm);
#ifndef USE_ONE_SIGNAL_HAND
pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
#endif
(*alrm)= &alarm_data->alarmed;
DBUG_RETURN(0);
}
@ -230,11 +244,15 @@ my_bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm_data)
void thr_end_alarm(thr_alarm_t *alarmed)
{
ALARM *alarm_data;
#ifndef USE_ONE_SIGNAL_HAND
sigset_t old_mask;
#endif
uint i, found=0;
DBUG_ENTER("thr_end_alarm");
#ifndef USE_ONE_SIGNAL_HAND
pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
#endif
pthread_mutex_lock(&LOCK_alarm);
alarm_data= (ALARM*) ((uchar*) *alarmed - offsetof(ALARM,alarmed));
@ -261,7 +279,9 @@ void thr_end_alarm(thr_alarm_t *alarmed)
(long) *alarmed));
}
pthread_mutex_unlock(&LOCK_alarm);
#ifndef USE_ONE_SIGNAL_HAND
pthread_sigmask(SIG_SETMASK,&old_mask,NULL);
#endif
DBUG_VOID_RETURN;
}
@ -380,10 +400,18 @@ static sig_handler process_alarm_part2(int sig __attribute__((unused)))
alarm(0); /* Remove old alarm */
#endif
alarm((uint) (alarm_data->expire_time-now));
next_alarm_expire_time= alarm_data->expire_time;
}
#endif
}
}
else
{
/*
Ensure that next time we call thr_alarm(), we will schedule a new alarm
*/
next_alarm_expire_time= ~(time_t) 0;
}
DBUG_VOID_RETURN;
}
@ -537,6 +565,7 @@ static void *alarm_handler(void *arg __attribute__((unused)))
{
abstime.tv_sec=sleep_time;
abstime.tv_nsec=0;
next_alarm_expire_time= sleep_time;
if ((error=pthread_cond_timedwait(&COND_alarm,&LOCK_alarm,&abstime)) &&
error != ETIME && error != ETIMEDOUT)
{
@ -549,12 +578,16 @@ static void *alarm_handler(void *arg __attribute__((unused)))
}
else if (alarm_aborted == -1)
break;
else if ((error=pthread_cond_wait(&COND_alarm,&LOCK_alarm)))
else
{
next_alarm_expire_time= ~ (time_t) 0;
if ((error=pthread_cond_wait(&COND_alarm,&LOCK_alarm)))
{
#ifdef MAIN
printf("Got error: %d from ptread_cond_wait (errno: %d)\n",
error,errno);
printf("Got error: %d from ptread_cond_wait (errno: %d)\n",
error,errno);
#endif
}
}
process_alarm(0);
}

40
mysys/thr_lock.c
View file

@ -384,6 +384,9 @@ static inline my_bool have_specific_lock(THR_LOCK_DATA *data,
}
static void wake_up_waiters(THR_LOCK *lock);
static enum enum_thr_lock_result
wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
my_bool in_wait_list)
@ -445,8 +448,13 @@ wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
else
wait->last=data->prev;
data->type= TL_UNLOCK; /* No lock */
check_locks(data->lock, "killed or timed out wait_for_lock", 1);
wake_up_waiters(data->lock);
}
else
{
check_locks(data->lock, "aborted wait_for_lock", 0);
}
check_locks(data->lock,"failed wait_for_lock",0);
}
else
{
@ -776,6 +784,26 @@ void thr_unlock(THR_LOCK_DATA *data)
lock->read_no_write_count--;
data->type=TL_UNLOCK; /* Mark unlocked */
check_locks(lock,"after releasing lock",1);
wake_up_waiters(lock);
pthread_mutex_unlock(&lock->mutex);
DBUG_VOID_RETURN;
}
/**
@brief Wake up all threads which pending requests for the lock
can be satisfied.
@param lock Lock for which threads should be woken up
*/
static void wake_up_waiters(THR_LOCK *lock)
{
THR_LOCK_DATA *data;
enum thr_lock_type lock_type;
DBUG_ENTER("wake_up_waiters");
if (!lock->write.data) /* If no active write locks */
{
@ -827,11 +855,7 @@ void thr_unlock(THR_LOCK_DATA *data)
data=lock->write_wait.data; /* Free this too */
}
if (data->type >= TL_WRITE_LOW_PRIORITY)
{
check_locks(lock,"giving write lock",0);
pthread_mutex_unlock(&lock->mutex);
DBUG_VOID_RETURN;
}
goto end;
/* Release possible read locks together with the write lock */
}
if (lock->read_wait.data)
@ -886,8 +910,7 @@ void thr_unlock(THR_LOCK_DATA *data)
free_all_read_locks(lock,0);
}
end:
check_locks(lock,"thr_unlock",0);
pthread_mutex_unlock(&lock->mutex);
check_locks(lock, "after waking up waiters", 0);
DBUG_VOID_RETURN;
}
@ -1101,6 +1124,7 @@ my_bool thr_abort_locks_for_thread(THR_LOCK *lock, my_thread_id thread_id)
lock->write_wait.last= data->prev;
}
}
wake_up_waiters(lock);
pthread_mutex_unlock(&lock->mutex);
DBUG_RETURN(found);
}

4
regex/regcomp.c
View file

@ -1479,8 +1479,8 @@ sopno pos;
}
{
int length=(HERE()-pos-1)*sizeof(sop);
bmove_upp((char *) &p->strip[pos+1]+length,
(char *) &p->strip[pos]+length,
bmove_upp((uchar *) &p->strip[pos+1]+length,
(uchar *) &p->strip[pos]+length,
length);
}
#ifdef OLD_CODE

102
scripts/mysql_install_db.sh
View file

@ -31,6 +31,7 @@ force=0
in_rpm=0
ip_only=0
windows=0
source_install=0
usage()
{
@ -41,7 +42,7 @@ Usage: $0 [OPTIONS]
--force Causes mysql_install_db to run even if DNS does not
work. In that case, grant table entries that normally
use hostnames will use IP addresses.
--ldata=path The path to the MySQL data directory.
--ldata=path The path to the MySQL data directory. Same as --datadir.
--rpm For internal use. This option is used by RPM files
during the MySQL installation process.
--skip-name-resolve Use IP addresses rather than hostnames when creating
@ -120,6 +121,13 @@ parse_arguments()
# package.
windows=1 ;;
--source-install)
# This is used when you want to run mysqld directly from the
# source tree (for example when you are developing MySQL and
# only want to create the default tables but don't want to
# install mysqld yet.
source_install=1 ;;
*)
if test -n "$pick_args"
then
@ -147,15 +155,22 @@ find_in_basedir()
file=$1; shift
base="$basedir"
if test -z "$base"
then
# Assume source installation if basedir is not given
base="."
fi
for dir in "$@"
do
if test -f "$basedir/$dir/$file"
if test -f "$base/$dir/$file"
then
if test -n "$return_dir"
then
echo "$basedir/$dir"
echo "$base/$dir"
else
echo "$basedir/$dir/$file"
echo "$base/$dir/$file"
fi
break
fi
@ -164,11 +179,17 @@ find_in_basedir()
missing_in_basedir()
{
echo "FATAL ERROR: Could not find $* inside --basedir"
echo
echo "When using --basedir you must point either into a MySQL binary"
echo "distribution directory or a compiled tree previously populated"
echo "by 'make install'"
if test -z "$basedir"
then
echo "FATAL ERROR: Could not find $* inside --basedir"
echo
echo "When using --basedir you must point either into a MySQL binary"
echo "distribution directory or a compiled tree previously populated"
echo "by 'make install'"
else
echo "FATAL ERROR: Can't find $*. Please specify your installation"
echo "directory with the '--basedir=' option."
fi
}
# Ok, let's go. We first need to parse arguments which are required by
@ -178,15 +199,10 @@ parse_arguments PICK-ARGS-FROM-ARGV "$@"
# We can now find my_print_defaults, either in the supplied --basedir
# location or in the installed area.
if test -n "$basedir"
print_defaults=`find_in_basedir my_print_defaults bin extra`
if test -z "$print_defaults"
then
print_defaults=`find_in_basedir my_print_defaults bin extra`
if ! test -x "$print_defaults"
then
missing_in_basedir my_print_defaults
exit 1
fi
else
print_defaults="@bindir@/my_print_defaults"
if ! test -x "$print_defaults"
then
@ -194,7 +210,8 @@ else
echo
echo "If you are using a binary release, you must run this script from"
echo "within the directory the archive extracted into. If you compiled"
echo "MySQL yourself you must run 'make install' first."
echo "MySQL yourself you must run 'make install' first or use"
echo "use --source-install --install-dir=xxx from the top source directory"
exit 1
fi
fi
@ -205,10 +222,11 @@ parse_arguments `$print_defaults $defaults mysqld mysql_install_db`
parse_arguments PICK-ARGS-FROM-ARGV "$@"
# Path to MySQL installation directory
if test -z "$basedir"
if test -z "$basedir" -a "$source_install" = 0
then
basedir="@prefix@"
bindir="@bindir@"
extra_bindir="$bindir"
mysqld="@libexecdir@/mysqld"
pkgdatadir="@pkgdatadir@"
else
@ -216,17 +234,33 @@ else
# We set up bootstrap-specific paths later, so skip this for --windows
if test "$windows" -eq 0
then
pkgdatadir=`find_in_basedir --dir fill_help_tables.sql share share/mysql`
if test -z "$pkgdatadir"
then
missing_in_basedir fill_help_tables.sql
exit 1
fi
mysqld=`find_in_basedir mysqld libexec sbin bin`
if ! test -x "$mysqld"
if test -z "$basedir"
then
missing_in_basedir mysqld
exit 1
# We come here when source-install is given
bindir="$basedir/bin"
extra_bindir="$bindir"
fi
if test -x "$mysqld"
then
pkgdatadir=`find_in_basedir --dir fill_help_tables.sql share share/mysql scripts`
if test -z "$pkgdatadir"
then
missing_in_basedir fill_help_tables.sql
exit 1
fi
else
if test -x "./sql/mysqld"
then
# Source installation
mysqld="./sql/mysqld"
bindir="./client"
extra_bindir="./extra"
pkgdatadir="./scripts"
mysqld_opt="--language=./sql/share/english"
else
missing_in_basedir mysqld
fi
fi
fi
fi
@ -272,7 +306,7 @@ fi
# already tested above).
if test ! -x "$mysqld"
then
echo "FATAL ERROR: $mysqld not found!"
echo "FATAL ERROR: 'mysqld' executable not found!"
exit 1
fi
@ -282,14 +316,14 @@ hostname=`@HOSTNAME@`
# Check if hostname is valid
if test "$windows" -eq 0 -a "$in_rpm" -eq 0 -a "$force" -eq 0
then
resolved=`$bindir/resolveip $hostname 2>&1`
resolved=`$extra_bindir/resolveip $hostname 2>&1`
if [ $? -ne 0 ]
then
resolved=`$bindir/resolveip localhost 2>&1`
resolved=`$extra_bindir/resolveip localhost 2>&1`
if [ $? -ne 0 ]
then
echo "Neither host '$hostname' nor 'localhost' could be looked up with"
echo "$bindir/resolveip"
echo "$extra_bindir/resolveip"
echo "Please configure the 'hostname' command to return a correct"
echo "hostname."
echo "If you want to solve this at a later stage, restart this script"
@ -332,7 +366,7 @@ fi
# Peform the install of system tables
mysqld_bootstrap="${MYSQLD_BOOTSTRAP-$mysqld}"
mysqld_install_cmd_line="$mysqld_bootstrap $defaults $mysqld_opt --bootstrap \
--basedir=$basedir --datadir=$ldata --loose-skip-innodb \
--basedir=$basedir --datadir=$ldata --log-warnings=0 --loose-skip-innodb \
--loose-skip-ndbcluster $args --max_allowed_packet=8M \
--net_buffer_length=16K"
@ -374,7 +408,7 @@ then
echo "$bindir/mysqladmin -u root -h $hostname password 'new-password'"
echo "See the manual for more instructions."
if test "$in_rpm" -eq 0
if test "$in_rpm" -eq 0 -a "$source_install" -eq 0
then
echo "You can start the MySQL daemon with:"
echo "cd @prefix@ ; $bindir/mysqld_safe &"

3
server-tools/instance-manager/angel.cc
View file

@ -176,6 +176,8 @@ static bool create_pid_file()
appropriately.
*************************************************************************/
extern "C" void reap_child(int);
void reap_child(int __attribute__((unused)) signo)
{
/* NOTE: As we have only one child, no need to cycle waitpid(). */
@ -197,6 +199,7 @@ void reap_child(int __attribute__((unused)) signo)
Set termination status and return.
*************************************************************************/
extern "C" void terminate(int signo);
void terminate(int signo)
{
shutdown_request_signo= signo;

4
server-tools/instance-manager/thread_registry.cc
View file

@ -27,7 +27,9 @@
enum { THREAD_KICK_OFF_SIGNAL= SIGUSR2 };
static void handle_signal(int __attribute__((unused)) sig_no)
extern "C" void handle_signal(int);
void handle_signal(int __attribute__((unused)) sig_no)
{
}
#endif

12
sql-common/client.c
View file

@ -2302,7 +2302,7 @@ CLI_MYSQL_REAL_CONNECT(MYSQL *mysql,const char *host, const char *user,
db= 0;
}
/* Write authentication package */
if (my_net_write(net,buff,(ulong) (end-buff)) || net_flush(net))
if (my_net_write(net, (uchar*) buff, (size_t) (end-buff)) || net_flush(net))
{
set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
ER(CR_SERVER_LOST_EXTENDED),
@ -2334,7 +2334,8 @@ CLI_MYSQL_REAL_CONNECT(MYSQL *mysql,const char *host, const char *user,
password in old format.
*/
scramble_323(buff, mysql->scramble, passwd);
if (my_net_write(net, buff, SCRAMBLE_LENGTH_323 + 1) || net_flush(net))
if (my_net_write(net, (uchar*) buff, SCRAMBLE_LENGTH_323 + 1) ||
net_flush(net))
{
set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
ER(CR_SERVER_LOST_EXTENDED),
@ -2531,7 +2532,8 @@ mysql_select_db(MYSQL *mysql, const char *db)
DBUG_ENTER("mysql_select_db");
DBUG_PRINT("enter",("db: '%s'",db));
if ((error=simple_command(mysql,COM_INIT_DB,db,(ulong) strlen(db),0)))
if ((error=simple_command(mysql,COM_INIT_DB, (const uchar*) db,
(ulong) strlen(db),0)))
DBUG_RETURN(error);
my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
mysql->db=my_strdup(db,MYF(MY_WME));
@ -2644,7 +2646,7 @@ void STDCALL mysql_close(MYSQL *mysql)
free_old_query(mysql);
mysql->status=MYSQL_STATUS_READY; /* Force command */
mysql->reconnect=0;
simple_command(mysql,COM_QUIT,NullS,0,1);
simple_command(mysql,COM_QUIT,(uchar*) 0,0,1);
end_server(mysql); /* Sets mysql->net.vio= 0 */
}
mysql_close_free_options(mysql);
@ -2775,7 +2777,7 @@ mysql_send_query(MYSQL* mysql, const char* query, ulong length)
mysql->last_used_con = mysql;
#endif
DBUG_RETURN(simple_command(mysql, COM_QUERY, query, length, 1));
DBUG_RETURN(simple_command(mysql, COM_QUERY, (uchar*) query, length, 1));
}

9
sql-common/my_time.c
View file

@ -301,9 +301,6 @@ str_to_datetime(const char *str, uint length, MYSQL_TIME *l_time,
field_length= 6; /* 6 digits */
}
continue;
/* No part seconds */
date[++i]= 0;
}
while (str != end &&
(my_ispunct(&my_charset_latin1,*str) ||
@ -569,12 +566,12 @@ my_bool str_to_time(const char *str, uint length, MYSQL_TIME *l_time,
/* Fix the date to assume that seconds was given */
if (!found_hours && !found_days)
{
bmove_upp((char*) (date+4), (char*) (date+state),
bmove_upp((uchar*) (date+4), (uchar*) (date+state),
sizeof(long)*(state-1));
bzero((char*) date, sizeof(long)*(4-state));
bzero((uchar*) date, sizeof(long)*(4-state));
}
else
bzero((char*) (date+state), sizeof(long)*(4-state));
bzero((uchar*) (date+state), sizeof(long)*(4-state));
}
fractional:

8
sql-common/pack.c
View file

@ -99,23 +99,23 @@ uchar *net_store_length(uchar *packet, ulonglong length)
if (length < (ulonglong) LL(251))
{
*packet=(uchar) length;
return (char*) packet+1;
return packet+1;
}
/* 251 is reserved for NULL */
if (length < (ulonglong) LL(65536))
{
*packet++=252;
int2store(packet,(uint) length);
return (char*) packet+2;
return packet+2;
}
if (length < (ulonglong) LL(16777216))
{
*packet++=253;
int3store(packet,(ulong) length);
return (char*) packet+3;
return packet+3;
}
*packet++=254;
int8store(packet,length);
return (char*) packet+8;
return packet+8;
}

9
sql/event_db_repository.cc
View file

@ -390,8 +390,9 @@ Event_db_repository::index_read_for_db_for_i_s(THD *thd, TABLE *schema_table,
}
key_copy(key_buf, event_table->record[0], key_info, key_len);
if (!(ret= event_table->file->index_read(event_table->record[0], key_buf,
(key_part_map)1, HA_READ_PREFIX)))
if (!(ret= event_table->file->index_read_map(event_table->record[0], key_buf,
(key_part_map)1,
HA_READ_PREFIX)))
{
DBUG_PRINT("info",("Found rows. Let's retrieve them. ret=%d", ret));
do
@ -839,8 +840,8 @@ Event_db_repository::find_named_event(LEX_STRING db, LEX_STRING name,
key_copy(key, table->record[0], table->key_info, table->key_info->key_length);
if (table->file->index_read_idx(table->record[0], 0, key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (table->file->index_read_idx_map(table->record[0], 0, key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{
DBUG_PRINT("info", ("Row not found"));
DBUG_RETURN(TRUE);

5
sql/event_queue.cc
View file

@ -52,8 +52,9 @@
execute_at.second_part is not considered during comparison
*/
static int
event_queue_element_compare_q(void *vptr, uchar* a, uchar *b)
extern "C" int event_queue_element_compare_q(void *, uchar *, uchar *);
int event_queue_element_compare_q(void *vptr, uchar* a, uchar *b)
{
my_time_t lhs = ((Event_queue_element *)a)->execute_at;
my_time_t rhs = ((Event_queue_element *)b)->execute_at;

6
sql/field.cc
View file

@ -6172,12 +6172,12 @@ uint Field::is_equal(Create_field *new_field)
/* If one of the fields is binary and the other one isn't return 1 else 0 */
bool Field_str::compare_str_field_flags(Create_field *new_field, uint32 flags)
bool Field_str::compare_str_field_flags(Create_field *new_field, uint32 flag_arg)
{
return (((new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
!(flags & (BINCMP_FLAG | BINARY_FLAG))) ||
!(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) ||
(!(new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
(flags & (BINCMP_FLAG | BINARY_FLAG))));
(flag_arg & (BINCMP_FLAG | BINARY_FLAG))));
}

48
sql/ha_partition.cc
View file

@ -1125,7 +1125,7 @@ int ha_partition::handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt,
0 Success
*/
int ha_partition::prepare_new_partition(TABLE *table,
int ha_partition::prepare_new_partition(TABLE *tbl,
HA_CREATE_INFO *create_info,
handler *file, const char *part_name,
partition_element *p_elem)
@ -1134,13 +1134,13 @@ int ha_partition::prepare_new_partition(TABLE *table,
bool create_flag= FALSE;
DBUG_ENTER("prepare_new_partition");
if ((error= set_up_table_before_create(table, part_name, create_info,
if ((error= set_up_table_before_create(tbl, part_name, create_info,
0, p_elem)))
goto error;
if ((error= file->create(part_name, table, create_info)))
if ((error= file->create(part_name, tbl, create_info)))
goto error;
create_flag= TRUE;
if ((error= file->ha_open(table, part_name, m_mode, m_open_test_lock)))
if ((error= file->ha_open(tbl, part_name, m_mode, m_open_test_lock)))
goto error;
/*
Note: if you plan to add another call that may return failure,
@ -1776,7 +1776,7 @@ partition_element *ha_partition::find_partition_element(uint part_id)
4) Data file name on partition
*/
int ha_partition::set_up_table_before_create(TABLE *table,
int ha_partition::set_up_table_before_create(TABLE *tbl,
const char *partition_name_with_path,
HA_CREATE_INFO *info,
uint part_id,
@ -1793,8 +1793,8 @@ int ha_partition::set_up_table_before_create(TABLE *table,
if (!part_elem)
DBUG_RETURN(1); // Fatal error
}
table->s->max_rows= part_elem->part_max_rows;
table->s->min_rows= part_elem->part_min_rows;
tbl->s->max_rows= part_elem->part_max_rows;
tbl->s->min_rows= part_elem->part_min_rows;
partition_name= strrchr(partition_name_with_path, FN_LIBCHAR);
if ((part_elem->index_file_name &&
(error= append_file_to_dir(thd,
@ -3400,11 +3400,11 @@ int ha_partition::index_end()
used in conjuntion with multi read ranges.
*/
int ha_partition::index_read(uchar * buf, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
int ha_partition::index_read_map(uchar *buf, const uchar *key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
{
DBUG_ENTER("ha_partition::index_read");
DBUG_ENTER("ha_partition::index_read_map");
end_range= 0;
m_index_scan_type= partition_index_read;
@ -3566,7 +3566,7 @@ int ha_partition::common_first_last(uchar *buf)
index_read_last()
buf Read row in MySQL Row Format
key Key
keylen Length of key
keypart_map Which part of key is used
RETURN VALUE
>0 Error code
@ -3577,8 +3577,8 @@ int ha_partition::common_first_last(uchar *buf)
Can only be used on indexes supporting HA_READ_ORDER
*/
int ha_partition::index_read_last(uchar *buf, const uchar *key,
key_part_map keypart_map)
int ha_partition::index_read_last_map(uchar *buf, const uchar *key,
key_part_map keypart_map)
{
DBUG_ENTER("ha_partition::index_read_last");
@ -3929,9 +3929,9 @@ int ha_partition::handle_unordered_scan_next_partition(uchar * buf)
switch (m_index_scan_type) {
case partition_index_read:
DBUG_PRINT("info", ("index_read on partition %d", i));
error= file->index_read(buf, m_start_key.key,
m_start_key.keypart_map,
m_start_key.flag);
error= file->index_read_map(buf, m_start_key.key,
m_start_key.keypart_map,
m_start_key.flag);
break;
case partition_index_first:
DBUG_PRINT("info", ("index_first on partition %d", i));
@ -4020,10 +4020,10 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
switch (m_index_scan_type) {
case partition_index_read:
error= file->index_read(rec_buf_ptr,
m_start_key.key,
m_start_key.keypart_map,
m_start_key.flag);
error= file->index_read_map(rec_buf_ptr,
m_start_key.key,
m_start_key.keypart_map,
m_start_key.flag);
break;
case partition_index_first:
error= file->index_first(rec_buf_ptr);
@ -4034,9 +4034,9 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
reverse_order= TRUE;
break;
case partition_index_read_last:
error= file->index_read_last(rec_buf_ptr,
m_start_key.key,
m_start_key.keypart_map);
error= file->index_read_last_map(rec_buf_ptr,
m_start_key.key,
m_start_key.keypart_map);
reverse_order= TRUE;
break;
default:

10
sql/ha_partition.h
View file

@ -387,9 +387,9 @@ public:
index_init initializes an index before using it and index_end does
any end processing needed.
*/
virtual int index_read(uchar * buf, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag);
virtual int index_read_map(uchar * buf, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag);
virtual int index_init(uint idx, bool sorted);
virtual int index_end();
@ -402,8 +402,8 @@ public:
virtual int index_first(uchar * buf);
virtual int index_last(uchar * buf);
virtual int index_next_same(uchar * buf, const uchar * key, uint keylen);
virtual int index_read_last(uchar * buf, const uchar * key,
key_part_map keypart_map);
virtual int index_read_last_map(uchar * buf, const uchar * key,
key_part_map keypart_map);
/*
read_first_row is virtual method but is only implemented by

26
sql/handler.cc
View file

@ -25,8 +25,6 @@
#include "mysql_priv.h"
#include "rpl_filter.h"
#include <myisampack.h>
#include <errno.h>
@ -64,7 +62,7 @@ static const LEX_STRING sys_table_aliases[]=
};
const char *ha_row_type[] = {
"", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT", "?","?","?"
"", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT", "PAGE", "?","?","?"
};
const char *tx_isolation_names[] =
@ -1993,9 +1991,9 @@ void handler::get_auto_increment(ulonglong offset, ulonglong increment,
key_copy(key, table->record[0],
table->key_info + table->s->next_number_index,
table->s->next_number_key_offset);
error= index_read(table->record[1], key,
make_prev_keypart_map(table->s->next_number_keypart),
HA_READ_PREFIX_LAST);
error= index_read_map(table->record[1], key,
make_prev_keypart_map(table->s->next_number_keypart),
HA_READ_PREFIX_LAST);
/*
MySQL needs to call us for next row: assume we are inserting ("a",null)
here, we return 3, and next this statement will want to insert
@ -3218,10 +3216,10 @@ int handler::read_range_first(const key_range *start_key,
if (!start_key) // Read first record
result= index_first(table->record[0]);
else
result= index_read(table->record[0],
start_key->key,
start_key->keypart_map,
start_key->flag);
result= index_read_map(table->record[0],
start_key->key,
start_key->keypart_map,
start_key->flag);
if (result)
DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND)
? HA_ERR_END_OF_FILE
@ -3293,15 +3291,15 @@ int handler::compare_key(key_range *range)
}
int handler::index_read_idx(uchar * buf, uint index, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
int handler::index_read_idx_map(uchar * buf, uint index, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
{
int error, error1;
error= index_init(index, 0);
if (!error)
{
error= index_read(buf, key, keypart_map, find_flag);
error= index_read_map(buf, key, keypart_map, find_flag);
error1= index_end();
}
return error ? error : error1;

71
sql/handler.h
View file

@ -278,7 +278,7 @@ enum legacy_db_type
enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED,
ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED,
ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT, ROW_TYPE_PAGES };
ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT, ROW_TYPE_PAGE };
enum enum_binlog_func {
BFN_RESET_LOGS= 1,
@ -321,6 +321,7 @@ enum enum_binlog_command {
#define HA_CREATE_USED_PASSWORD (1L << 17)
#define HA_CREATE_USED_CONNECTION (1L << 18)
#define HA_CREATE_USED_KEY_BLOCK_SIZE (1L << 19)
#define HA_CREATE_USED_TRANSACTIONAL (1L << 20)
typedef ulonglong my_xid; // this line is the same as in log_event.h
#define MYSQL_XID_PREFIX "MySQLXid"
@ -788,6 +789,7 @@ class partition_info;
struct st_partition_iter;
#define NOT_A_PARTITION_ID ((uint32)-1)
enum ha_choice { HA_CHOICE_UNDEF, HA_CHOICE_NO, HA_CHOICE_YES };
typedef struct st_ha_create_information
{
@ -810,6 +812,8 @@ typedef struct st_ha_create_information
uint options; /* OR of HA_CREATE_ options */
uint merge_insert_method;
uint extra_size; /* length of extra data segment */
/* 0 not used, 1 if not transactional, 2 if transactional */
enum ha_choice transactional;
bool table_existed; /* 1 in create if table existed */
bool frm_only; /* 1 if no ha_create_table() */
bool varchar; /* 1 if table has a VARCHAR */
@ -1277,27 +1281,28 @@ public:
enum ha_rkey_function find_flag)
{ return HA_ERR_WRONG_COMMAND; }
public:
/**
@brief
Positions an index cursor to the index specified in the handle. Fetches the
row if available. If the key value is null, begin at the first key of the
index.
*/
virtual int index_read(uchar * buf, const uchar * key, key_part_map keypart_map,
enum ha_rkey_function find_flag)
{
uint key_len= calculate_key_len(table, active_index, key, keypart_map);
return index_read(buf, key, key_len, find_flag);
}
/**
@brief
Positions an index cursor to the index specified in the handle. Fetches the
row if available. If the key value is null, begin at the first key of the
index.
*/
virtual int index_read_idx(uchar * buf, uint index, const uchar * key,
/**
@brief
Positions an index cursor to the index specified in the handle. Fetches the
row if available. If the key value is null, begin at the first key of the
index.
*/
virtual int index_read_map(uchar * buf, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag);
enum ha_rkey_function find_flag)
{
uint key_len= calculate_key_len(table, active_index, key, keypart_map);
return index_read(buf, key, key_len, find_flag);
}
/**
@brief
Positions an index cursor to the index specified in the handle. Fetches the
row if available. If the key value is null, begin at the first key of the
index.
*/
virtual int index_read_idx_map(uchar * buf, uint index, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag);
virtual int index_next(uchar * buf)
{ return HA_ERR_WRONG_COMMAND; }
virtual int index_prev(uchar * buf)
@ -1311,17 +1316,17 @@ public:
virtual int index_read_last(uchar * buf, const uchar * key, uint key_len)
{ return (my_errno=HA_ERR_WRONG_COMMAND); }
public:
/**
@brief
The following functions works like index_read, but it find the last
row with the current key value or prefix.
*/
virtual int index_read_last(uchar * buf, const uchar * key,
key_part_map keypart_map)
{
uint key_len= calculate_key_len(table, active_index, key, keypart_map);
return index_read_last(buf, key, key_len);
}
/**
@brief
The following functions works like index_read, but it find the last
row with the current key value or prefix.
*/
virtual int index_read_last_map(uchar * buf, const uchar * key,
key_part_map keypart_map)
{
uint key_len= calculate_key_len(table, active_index, key, keypart_map);
return index_read_last(buf, key, key_len);
}
virtual int read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
KEY_MULTI_RANGE *ranges, uint range_count,
bool sorted, HANDLER_BUFFER *buffer);
@ -1864,7 +1869,7 @@ int ha_find_files(THD *thd,const char *db,const char *path,
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name);
/* key cache */
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache);
extern "C" int ha_init_key_cache(const char *name, KEY_CACHE *key_cache);
int ha_resize_key_cache(KEY_CACHE *key_cache);
int ha_change_key_cache_param(KEY_CACHE *key_cache);
int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache);

16
sql/item.cc
View file

@ -1705,7 +1705,7 @@ void Item_ident_for_show::make_field(Send_field *tmp_field)
tmp_field->type=field->type();
tmp_field->flags= field->table->maybe_null ?
(field->flags & ~NOT_NULL_FLAG) : field->flags;
tmp_field->decimals= 0;
tmp_field->decimals= field->decimals();
}
/**********************************************/
@ -3869,15 +3869,15 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
if ((*res)->type() == Item::FIELD_ITEM)
{
/*
It's an Item_field referencing another Item_field in the select
list.
use the field from the Item_field in the select list and leave
the Item_field instance in place.
It's an Item_field referencing another Item_field in the select
list.
Use the field from the Item_field in the select list and leave
the Item_field instance in place.
*/
Field *field= (*((Item_field**)res))->field;
Field *new_field= (*((Item_field**)res))->field;
if (field == NULL)
if (new_field == NULL)
{
/* The column to which we link isn't valid. */
my_error(ER_BAD_FIELD_ERROR, MYF(0), (*res)->name,
@ -3885,7 +3885,7 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
return(1);
}
set_field(field);
set_field(new_field);
return 0;
}
else

4
sql/item_cmpfunc.cc
View file

@ -3017,11 +3017,11 @@ uchar *in_longlong::get_value(Item *item)
void in_datetime::set(uint pos,Item *item)
{
Item **tmp= &item;
Item **tmp_item= &item;
bool is_null;
struct packed_longlong *buff= &((packed_longlong*) base)[pos];
buff->val= get_datetime_value(thd, &tmp, 0, warn_item, &is_null);
buff->val= get_datetime_value(thd, &tmp_item, 0, warn_item, &is_null);
buff->unsigned_flag= 1L;
}

1
sql/item_cmpfunc.h
View file

@ -1158,7 +1158,6 @@ public:
class Item_func_in :public Item_func_opt_neg
{
public:
Item_result cmp_type;
/*
an array of values when the right hand arguments of IN
are all SQL constant and there are no nulls

4
sql/item_func.cc
View file

@ -4375,11 +4375,11 @@ int Item_func_set_user_var::save_in_field(Field *field, bool no_conversions,
else if (result_type() == DECIMAL_RESULT)
{
my_decimal decimal_value;
my_decimal *value= entry->val_decimal(&null_value, &decimal_value);
my_decimal *val= entry->val_decimal(&null_value, &decimal_value);
if (null_value)
return set_field_to_null(field);
field->set_notnull();
error=field->store_decimal(value);
error=field->store_decimal(val);
}
else
{

17
sql/item_strfunc.cc
View file

@ -1049,6 +1049,23 @@ String *Item_str_conv::val_str(String *str)
}
void Item_func_lcase::fix_length_and_dec()
{
collation.set(args[0]->collation);
multiply= collation.collation->casedn_multiply;
converter= collation.collation->cset->casedn;
max_length= args[0]->max_length * multiply;
}
void Item_func_ucase::fix_length_and_dec()
{
collation.set(args[0]->collation);
multiply= collation.collation->caseup_multiply;
converter= collation.collation->cset->caseup;
max_length= args[0]->max_length * multiply;
}
String *Item_func_left::val_str(String *str)
{
DBUG_ASSERT(fixed == 1);

19
sql/item_strfunc.h
View file

@ -145,8 +145,7 @@ class Item_str_conv :public Item_str_func
{
protected:
uint multiply;
size_t (*converter)(CHARSET_INFO *cs, char *src, size_t srclen,
char *dst, size_t dstlen);
my_charset_conv_case converter;
String tmp_value;
public:
Item_str_conv(Item *item) :Item_str_func(item) {}
@ -159,13 +158,7 @@ class Item_func_lcase :public Item_str_conv
public:
Item_func_lcase(Item *item) :Item_str_conv(item) {}
const char *func_name() const { return "lcase"; }
void fix_length_and_dec()
{
collation.set(args[0]->collation);
multiply= collation.collation->casedn_multiply;
converter= collation.collation->cset->casedn;
max_length= args[0]->max_length * multiply;
}
void fix_length_and_dec();
};
class Item_func_ucase :public Item_str_conv
@ -173,13 +166,7 @@ class Item_func_ucase :public Item_str_conv
public:
Item_func_ucase(Item *item) :Item_str_conv(item) {}
const char *func_name() const { return "ucase"; }
void fix_length_and_dec()
{
collation.set(args[0]->collation);
multiply= collation.collation->caseup_multiply;
converter= collation.collation->cset->caseup;
max_length= args[0]->max_length * multiply;
}
void fix_length_and_dec();
};

16
sql/item_subselect.cc
View file

@ -2129,10 +2129,10 @@ int subselect_uniquesubquery_engine::exec()
if (!table->file->inited)
table->file->ha_index_init(tab->ref.key, 0);
error= table->file->index_read(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT);
error= table->file->index_read_map(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT);
if (error &&
error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
error= report_error(table, error);
@ -2239,10 +2239,10 @@ int subselect_indexsubquery_engine::exec()
if (!table->file->inited)
table->file->ha_index_init(tab->ref.key, 1);
error= table->file->index_read(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT);
error= table->file->index_read_map(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT);
if (error &&
error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
error= report_error(table, error);

20
sql/item_xmlfunc.cc
View file

@ -570,13 +570,13 @@ String *Item_nodeset_func_rootelement::val_nodeset(String *nodeset)
String * Item_nodeset_func_union::val_nodeset(String *nodeset)
{
uint numnodes= pxml->length() / sizeof(MY_XML_NODE);
uint num_nodes= pxml->length() / sizeof(MY_XML_NODE);
String set0, *s0= args[0]->val_nodeset(&set0);
String set1, *s1= args[1]->val_nodeset(&set1);
String both_str;
both_str.alloc(numnodes);
both_str.alloc(num_nodes);
char *both= (char*) both_str.ptr();
bzero((void*)both, numnodes);
bzero((void*)both, num_nodes);
MY_XPATH_FLT *flt;
fltbeg= (MY_XPATH_FLT*) s0->ptr();
@ -590,7 +590,7 @@ String * Item_nodeset_func_union::val_nodeset(String *nodeset)
both[flt->num]= 1;
nodeset->length(0);
for (uint i= 0, pos= 0; i < numnodes; i++)
for (uint i= 0, pos= 0; i < num_nodes; i++)
{
if (both[i])
((XPathFilter*)nodeset)->append_element(i, pos++);
@ -2656,7 +2656,9 @@ static uint xml_parent_tag(MY_XML_NODE *items, uint nitems, uint level)
RETURN
Currently only MY_XML_OK
*/
static int xml_enter(MY_XML_PARSER *st,const char *attr, size_t len)
extern "C" int xml_enter(MY_XML_PARSER *st,const char *attr, size_t len);
int xml_enter(MY_XML_PARSER *st,const char *attr, size_t len)
{
MY_XML_USER_DATA *data= (MY_XML_USER_DATA*)st->user_data;
MY_XML_NODE *nodes= (MY_XML_NODE*) data->pxml->ptr();
@ -2687,7 +2689,9 @@ static int xml_enter(MY_XML_PARSER *st,const char *attr, size_t len)
RETURN
Currently only MY_XML_OK
*/
static int xml_value(MY_XML_PARSER *st,const char *attr, size_t len)
extern "C" int xml_value(MY_XML_PARSER *st,const char *attr, size_t len);
int xml_value(MY_XML_PARSER *st,const char *attr, size_t len)
{
MY_XML_USER_DATA *data= (MY_XML_USER_DATA*)st->user_data;
MY_XML_NODE *nodes= (MY_XML_NODE*) data->pxml->ptr();
@ -2717,7 +2721,9 @@ static int xml_value(MY_XML_PARSER *st,const char *attr, size_t len)
RETURN
Currently only MY_XML_OK
*/
static int xml_leave(MY_XML_PARSER *st,const char *attr, size_t len)
extern "C" int xml_leave(MY_XML_PARSER *st,const char *attr, size_t len);
int xml_leave(MY_XML_PARSER *st,const char *attr, size_t len)
{
MY_XML_USER_DATA *data= (MY_XML_USER_DATA*)st->user_data;
DBUG_ASSERT(data->level > 0);

1
sql/key.cc
View file

@ -480,6 +480,7 @@ int key_cmp(KEY_PART_INFO *key_part, const uchar *key, uint key_length)
rec0 Pointer to table->record[0]
first_rec Pointer to record compare with
second_rec Pointer to record compare against first_rec
DESCRIPTION
This method is set-up such that it can be called directly from the
priority queue and it is attempted to be optimised as much as possible

9
sql/log.cc
View file

@ -1934,7 +1934,7 @@ bool MYSQL_QUERY_LOG::write(time_t event_time, const char *user_host,
{
char buff[32];
uint length= 0;
char time_buff[MAX_TIME_SIZE];
char local_time_buff[MAX_TIME_SIZE];
struct tm start;
uint time_buff_len= 0;
@ -1950,13 +1950,13 @@ bool MYSQL_QUERY_LOG::write(time_t event_time, const char *user_host,
localtime_r(&event_time, &start);
time_buff_len= my_snprintf(time_buff, MAX_TIME_SIZE,
time_buff_len= my_snprintf(local_time_buff, MAX_TIME_SIZE,
"%02d%02d%02d %2d:%02d:%02d",
start.tm_year % 100, start.tm_mon + 1,
start.tm_mday, start.tm_hour,
start.tm_min, start.tm_sec);
if (my_b_write(&log_file, (uchar*) &time_buff, time_buff_len))
if (my_b_write(&log_file, (uchar*) local_time_buff, time_buff_len))
goto err;
}
else
@ -2346,8 +2346,7 @@ bool MYSQL_BIN_LOG::open(const char *log_name,
s.flags|= LOG_EVENT_BINLOG_IN_USE_F;
if (!s.is_valid())
goto err;
if (null_created_arg)
s.created= 0;
s.dont_set_created= null_created_arg;
if (s.write(&log_file))
goto err;
bytes_written+= s.data_written;

117
sql/log_event.cc
View file

@ -641,6 +641,7 @@ void Log_event::init_show_field_list(List<Item>* field_list)
bool Log_event::write_header(IO_CACHE* file, ulong event_data_length)
{
uchar header[LOG_EVENT_HEADER_LEN];
ulong now;
DBUG_ENTER("Log_event::write_header");
/* Store number of bytes that will be written by this event */
@ -691,18 +692,7 @@ bool Log_event::write_header(IO_CACHE* file, ulong event_data_length)
log_pos= my_b_safe_tell(file)+data_written;
}
/*
Set time of when to when the query started. Since this function is
called from init_server_components() as well, it might be that the
current thread is not defined. In that case, we take the current
time instead. It is safe to call my_time() here since the first
time this line is reached is through the init_server_components()
call, which is after the my_init() call in the main() function (or
it's replacement, for some platforms).
*/
THD *thd= current_thd;
if (!when)
when= thd ? thd->start_time : my_time(0);
now= get_time(); // Query start time
/*
Header will be of size LOG_EVENT_HEADER_LEN for all events, except for
@ -711,7 +701,7 @@ bool Log_event::write_header(IO_CACHE* file, ulong event_data_length)
because we read them before knowing the format).
*/
int4store(header, (ulong) when); // timestamp
int4store(header, now); // timestamp
header[EVENT_TYPE_OFFSET]= get_type_code();
int4store(header+ SERVER_ID_OFFSET, server_id);
int4store(header+ EVENT_LEN_OFFSET, data_written);
@ -820,10 +810,12 @@ end:
#ifndef MYSQL_CLIENT
Log_event* Log_event::read_log_event(IO_CACHE* file,
pthread_mutex_t* log_lock,
const Format_description_log_event *description_event)
const Format_description_log_event
*description_event)
#else
Log_event* Log_event::read_log_event(IO_CACHE* file,
const Format_description_log_event *description_event)
const Format_description_log_event
*description_event)
#endif
{
DBUG_ENTER("Log_event::read_log_event");
@ -1478,7 +1470,7 @@ Query_log_event::Query_log_event()
/*
SYNOPSIS
Query_log_event::Query_log_event()
thd - thread handle
thd_arg - thread handle
query_arg - array of char representing the query
query_length - size of the `query_arg' array
using_trans - there is a modified transactional table
@ -1494,10 +1486,12 @@ Query_log_event::Query_log_event()
*/
Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
ulong query_length, bool using_trans,
bool suppress_use, THD::killed_state killed_status_arg)
bool suppress_use,
THD::killed_state killed_status_arg)
:Log_event(thd_arg,
(thd_arg->thread_specific_used ? LOG_EVENT_THREAD_SPECIFIC_F : 0) |
(suppress_use ? LOG_EVENT_SUPPRESS_USE_F : 0),
(thd_arg->thread_specific_used ? LOG_EVENT_THREAD_SPECIFIC_F :
0) |
(suppress_use ? LOG_EVENT_SUPPRESS_USE_F : 0),
using_trans),
data_buf(0), query(query_arg), catalog(thd_arg->catalog),
db(thd_arg->db), q_len((uint32) query_length),
@ -1518,10 +1512,10 @@ Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
error_code=
(killed_status_arg == THD::NOT_KILLED) ? thd_arg->net.last_errno :
((thd_arg->system_thread & SYSTEM_THREAD_DELAYED_INSERT) ? 0 :
thd->killed_errno());
thd_arg->killed_errno());
time(&end_time);
exec_time = (ulong) (end_time - thd->start_time);
exec_time = (ulong) (end_time - thd_arg->start_time);
catalog_len = (catalog) ? (uint32) strlen(catalog) : 0;
/* status_vars_len is set just before writing the event */
db_len = (db) ? (uint32) strlen(db) : 0;
@ -1530,15 +1524,15 @@ Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
/*
If we don't use flags2 for anything else than options contained in
thd->options, it would be more efficient to flags2=thd_arg->options
thd_arg->options, it would be more efficient to flags2=thd_arg->options
(OPTIONS_WRITTEN_TO_BINLOG would be used only at reading time).
But it's likely that we don't want to use 32 bits for 3 bits; in the future
we will probably want to reclaim the 29 bits. So we need the &.
*/
flags2= (uint32) (thd_arg->options & OPTIONS_WRITTEN_TO_BIN_LOG);
DBUG_ASSERT(thd->variables.character_set_client->number < 256*256);
DBUG_ASSERT(thd->variables.collation_connection->number < 256*256);
DBUG_ASSERT(thd->variables.collation_server->number < 256*256);
DBUG_ASSERT(thd_arg->variables.character_set_client->number < 256*256);
DBUG_ASSERT(thd_arg->variables.collation_connection->number < 256*256);
DBUG_ASSERT(thd_arg->variables.collation_server->number < 256*256);
int2store(charset, thd_arg->variables.character_set_client->number);
int2store(charset+2, thd_arg->variables.collation_connection->number);
int2store(charset+4, thd_arg->variables.collation_server->number);
@ -2264,9 +2258,10 @@ Muted_query_log_event::Muted_query_log_event()
**************************************************************************/
#ifndef MYSQL_CLIENT
Start_log_event_v3::Start_log_event_v3() :Log_event(), binlog_version(BINLOG_VERSION), artificial_event(0)
Start_log_event_v3::Start_log_event_v3()
:Log_event(), created(0), binlog_version(BINLOG_VERSION),
artificial_event(0), dont_set_created(0)
{
created= when;
memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
}
#endif
@ -2336,7 +2331,8 @@ void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
*/
Start_log_event_v3::Start_log_event_v3(const char* buf,
const Format_description_log_event* description_event)
const Format_description_log_event
*description_event)
:Log_event(buf, description_event)
{
buf+= description_event->common_header_len;
@ -2348,6 +2344,7 @@ Start_log_event_v3::Start_log_event_v3(const char* buf,
created= uint4korr(buf+ST_CREATED_OFFSET);
/* We use log_pos to mark if this was an artificial event or not */
artificial_event= (log_pos == 0);
dont_set_created= 1;
}
@ -2361,6 +2358,8 @@ bool Start_log_event_v3::write(IO_CACHE* file)
char buff[START_V3_HEADER_LEN];
int2store(buff + ST_BINLOG_VER_OFFSET,binlog_version);
memcpy(buff + ST_SERVER_VER_OFFSET,server_version,ST_SERVER_VER_LEN);
if (!dont_set_created)
created= when= get_time();
int4store(buff + ST_CREATED_OFFSET,created);
return (write_header(file, sizeof(buff)) ||
my_b_safe_write(file, (uchar*) buff, sizeof(buff)));
@ -2391,8 +2390,7 @@ bool Start_log_event_v3::write(IO_CACHE* file)
int Start_log_event_v3::do_apply_event(RELAY_LOG_INFO const *rli)
{
DBUG_ENTER("Start_log_event_v3::do_apply_event");
switch (binlog_version)
{
switch (binlog_version) {
case 3:
case 4:
/*
@ -2463,7 +2461,6 @@ Format_description_log_event::
Format_description_log_event(uint8 binlog_ver, const char* server_ver)
:Start_log_event_v3()
{
created= when;
binlog_version= binlog_ver;
switch (binlog_ver) {
case 4: /* MySQL 5.0 */
@ -2615,6 +2612,8 @@ bool Format_description_log_event::write(IO_CACHE* file)
uchar buff[FORMAT_DESCRIPTION_HEADER_LEN];
int2store(buff + ST_BINLOG_VER_OFFSET,binlog_version);
memcpy((char*) buff + ST_SERVER_VER_OFFSET,server_version,ST_SERVER_VER_LEN);
if (!dont_set_created)
created= when= get_time();
int4store(buff + ST_CREATED_OFFSET,created);
buff[ST_COMMON_HEADER_LEN_OFFSET]= LOG_EVENT_HEADER_LEN;
memcpy((char*) buff+ST_COMMON_HEADER_LEN_OFFSET+1, (uchar*) post_header_len,
@ -4921,8 +4920,9 @@ err:
*/
#ifndef MYSQL_CLIENT
Append_block_log_event::Append_block_log_event(THD* thd_arg, const char* db_arg,
char* block_arg,
Append_block_log_event::Append_block_log_event(THD *thd_arg,
const char *db_arg,
char *block_arg,
uint block_len_arg,
bool using_trans)
:Log_event(thd_arg,0, using_trans), block(block_arg),
@ -5171,7 +5171,8 @@ int Delete_file_log_event::do_apply_event(RELAY_LOG_INFO const *rli)
*/
#ifndef MYSQL_CLIENT
Execute_load_log_event::Execute_load_log_event(THD *thd_arg, const char* db_arg,
Execute_load_log_event::Execute_load_log_event(THD *thd_arg,
const char* db_arg,
bool using_trans)
:Log_event(thd_arg, 0, using_trans), file_id(thd_arg->file_id), db(db_arg)
{
@ -5372,7 +5373,7 @@ int Begin_load_query_log_event::get_create_or_append() const
#ifndef MYSQL_CLIENT
Execute_load_query_log_event::
Execute_load_query_log_event(THD* thd_arg, const char* query_arg,
Execute_load_query_log_event(THD *thd_arg, const char* query_arg,
ulong query_length_arg, uint fn_pos_start_arg,
uint fn_pos_end_arg,
enum_load_dup_handling dup_handling_arg,
@ -7112,7 +7113,9 @@ int Write_rows_log_event::do_after_row_operations(TABLE *table, int error)
return error? error : local_error;
}
int Write_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli,
int Write_rows_log_event::do_prepare_row(THD *thd_arg,
RELAY_LOG_INFO const *rli,
TABLE *table,
uchar const *const row_start,
uchar const **const row_end)
@ -7123,7 +7126,7 @@ int Write_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli,
if (int error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end,
&m_master_reclength, table->write_set, WRITE_ROWS_EVENT))
{
thd->net.last_errno= error;
thd_arg->net.last_errno= error;
return error;
}
bitmap_copy(table->read_set, table->write_set);
@ -7386,11 +7389,12 @@ replace_record(THD *thd, TABLE *table,
DBUG_RETURN(ENOMEM);
}
key_copy((uchar*)key.get(), table->record[0], table->key_info + keynum, 0);
error= table->file->index_read_idx(table->record[1], keynum,
(const uchar*)key.get(),
HA_WHOLE_KEY,
HA_READ_KEY_EXACT);
key_copy((uchar*)key.get(), table->record[0], table->key_info + keynum,
0);
error= table->file->index_read_idx_map(table->record[1], keynum,
(const uchar*)key.get(),
HA_WHOLE_KEY,
HA_READ_KEY_EXACT);
if (error)
{
table->file->print_error(error, MYF(0));
@ -7641,8 +7645,8 @@ static int find_and_fetch_row(TABLE *table, uchar *key)
my_ptrdiff_t const pos=
table->s->null_bytes > 0 ? table->s->null_bytes - 1 : 0;
table->record[1][pos]= 0xFF;
if ((error= table->file->index_read(table->record[1], key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT)))
if ((error= table->file->index_read_map(table->record[1], key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT)))
{
table->file->print_error(error, MYF(0));
table->file->ha_index_end();
@ -7842,7 +7846,8 @@ int Delete_rows_log_event::do_after_row_operations(TABLE *table, int error)
return error;
}
int Delete_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli,
int Delete_rows_log_event::do_prepare_row(THD *thd_arg,
RELAY_LOG_INFO const *rli,
TABLE *table,
uchar const *const row_start,
uchar const **const row_end)
@ -7851,7 +7856,7 @@ int Delete_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli,
if (int error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end,
&m_master_reclength, table->read_set, DELETE_ROWS_EVENT))
{
thd->net.last_errno= error;
thd_arg->net.last_errno= error;
return error;
}
@ -8008,7 +8013,10 @@ int Update_rows_log_event::do_before_row_operations(TABLE *table)
int Update_rows_log_event::do_after_row_operations(TABLE *table, int error)
{
/*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/
/*
error= ToDo:find out what this should really be, this triggers
close_scan in nbd, returning error?
*/
table->file->ha_index_or_rnd_end();
my_free(m_memory, MYF(MY_ALLOW_ZERO_PTR));
m_memory= NULL;
@ -8018,7 +8026,8 @@ int Update_rows_log_event::do_after_row_operations(TABLE *table, int error)
return error;
}
int Update_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli,
int Update_rows_log_event::do_prepare_row(THD *thd_arg,
RELAY_LOG_INFO const *rli,
TABLE *table,
uchar const *const row_start,
uchar const **const row_end)
@ -8033,9 +8042,10 @@ int Update_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli,
/* record[0] is the before image for the update */
if ((error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end,
&m_master_reclength, table->read_set, UPDATE_ROWS_EVENT)))
&m_master_reclength, table->read_set,
UPDATE_ROWS_EVENT)))
{
thd->net.last_errno= error;
thd_arg->net.last_errno= error;
return error;
}
@ -8043,9 +8053,10 @@ int Update_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli,
uchar const *next_start = *row_end;
/* m_after_image is the after image for the update */
if ((error= unpack_row(rli, table, m_width, next_start, &m_cols_ai, row_end,
&m_master_reclength, table->write_set, UPDATE_ROWS_EVENT)))
&m_master_reclength, table->write_set,
UPDATE_ROWS_EVENT)))
{
thd->net.last_errno= error;
thd_arg->net.last_errno= error;
return error;
}
@ -8229,5 +8240,3 @@ Incident_log_event::write_data_body(IO_CACHE *file)
DBUG_ENTER("Incident_log_event::write_data_body");
DBUG_RETURN(write_str(file, m_message.str, m_message.length));
}

77
sql/log_event.h
View file

@ -57,8 +57,8 @@
which increments every time we write an event to the binlog) (3 bytes).
Q: how do we handle when the counter is overflowed and restarts from 0 ?
- Query and Load (Create or Execute) events may have a more precise timestamp
(with microseconds), number of matched/affected/warnings rows
- Query and Load (Create or Execute) events may have a more precise
timestamp (with microseconds), number of matched/affected/warnings rows
and fields of session variables: SQL_MODE,
FOREIGN_KEY_CHECKS, UNIQUE_CHECKS, SQL_AUTO_IS_NULL, the collations and
charsets, the PASSWORD() version (old/new/...).
@ -708,7 +708,8 @@ public:
*/
static Log_event* read_log_event(IO_CACHE* file,
pthread_mutex_t* log_lock,
const Format_description_log_event *description_event);
const Format_description_log_event
*description_event);
static int read_log_event(IO_CACHE* file, String* packet,
pthread_mutex_t* log_lock);
/*
@ -736,7 +737,8 @@ public:
Log_event() : temp_buf(0) {}
/* avoid having to link mysqlbinlog against libpthread */
static Log_event* read_log_event(IO_CACHE* file,
const Format_description_log_event *description_event);
const Format_description_log_event
*description_event);
/* print*() functions are used by mysqlbinlog */
virtual void print(FILE* file, PRINT_EVENT_INFO* print_event_info) = 0;
void print_timestamp(IO_CACHE* file, time_t *ts = 0);
@ -777,7 +779,8 @@ public:
virtual bool is_valid() const = 0;
virtual bool is_artificial_event() { return 0; }
inline bool get_cache_stmt() const { return cache_stmt; }
Log_event(const char* buf, const Format_description_log_event* description_event);
Log_event(const char* buf, const Format_description_log_event
*description_event);
virtual ~Log_event() { free_temp_buf();}
void register_temp_buf(char* buf) { temp_buf = buf; }
void free_temp_buf()
@ -800,6 +803,8 @@ public:
/* returns the human readable name of the event's type */
const char* get_type_str();
/* Return start of query time or current time */
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
public:
@ -811,7 +816,8 @@ public:
@see do_apply_event
*/
int apply_event(RELAY_LOG_INFO const *rli) {
int apply_event(RELAY_LOG_INFO const *rli)
{
return do_apply_event(rli);
}
@ -920,6 +926,18 @@ protected:
*/
virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli);
inline ulong get_time()
{
THD *tmp_thd;
if (when)
return (ulong) when;
if (thd)
return thd->start_time;
if ((tmp_thd= current_thd))
return tmp_thd->start_time;
return my_time(0);
}
#endif
};
@ -1151,7 +1169,8 @@ private:
char **fn_start, char **fn_end);
protected:
int copy_log_event(const char *buf, ulong event_len,
int body_offset, const Format_description_log_event* description_event);
int body_offset,
const Format_description_log_event* description_event);
public:
ulong thread_id;
@ -1296,6 +1315,11 @@ public:
setting log_event == 0 (for now).
*/
bool artificial_event;
/*
We set this to 1 if we don't want to have the created time in the log,
which is the case when we rollover to a new log.
*/
bool dont_set_created;
#ifndef MYSQL_CLIENT
Start_log_event_v3();
@ -1362,7 +1386,8 @@ public:
Format_description_log_event(uint8 binlog_ver, const char* server_ver=0);
Format_description_log_event(const char* buf, uint event_len,
const Format_description_log_event* description_event);
const Format_description_log_event
*description_event);
~Format_description_log_event() { my_free((uchar*)post_header_len, MYF(0)); }
Log_event_type get_type_code() { return FORMAT_DESCRIPTION_EVENT;}
#ifndef MYSQL_CLIENT
@ -1420,7 +1445,8 @@ public:
void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
#endif
Intvar_log_event(const char* buf, const Format_description_log_event* description_event);
Intvar_log_event(const char* buf,
const Format_description_log_event *description_event);
~Intvar_log_event() {}
Log_event_type get_type_code() { return INTVAR_EVENT;}
const char* get_var_type_name();
@ -1467,7 +1493,8 @@ class Rand_log_event: public Log_event
void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
#endif
Rand_log_event(const char* buf, const Format_description_log_event* description_event);
Rand_log_event(const char* buf,
const Format_description_log_event *description_event);
~Rand_log_event() {}
Log_event_type get_type_code() { return RAND_EVENT;}
int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ }
@ -1510,7 +1537,8 @@ class Xid_log_event: public Log_event
void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
#endif
Xid_log_event(const char* buf, const Format_description_log_event* description_event);
Xid_log_event(const char* buf,
const Format_description_log_event *description_event);
~Xid_log_event() {}
Log_event_type get_type_code() { return XID_EVENT;}
int get_data_size() { return sizeof(xid); }
@ -1556,7 +1584,8 @@ public:
void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
#endif
User_var_log_event(const char* buf, const Format_description_log_event* description_event);
User_var_log_event(const char* buf,
const Format_description_log_event *description_event);
~User_var_log_event() {}
Log_event_type get_type_code() { return USER_VAR_EVENT;}
#ifndef MYSQL_CLIENT
@ -1588,7 +1617,8 @@ public:
void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
#endif
Stop_log_event(const char* buf, const Format_description_log_event* description_event):
Stop_log_event(const char* buf,
const Format_description_log_event *description_event):
Log_event(buf, description_event)
{}
~Stop_log_event() {}
@ -1697,7 +1727,8 @@ public:
#endif /* HAVE_REPLICATION */
#else
void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool enable_local);
void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
bool enable_local);
#endif
Create_file_log_event(const char* buf, uint event_len,
@ -1772,7 +1803,8 @@ public:
#endif
Append_block_log_event(const char* buf, uint event_len,
const Format_description_log_event* description_event);
const Format_description_log_event
*description_event);
~Append_block_log_event() {}
Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
int get_data_size() { return block_len + APPEND_BLOCK_HEADER_LEN ;}
@ -1808,7 +1840,8 @@ public:
#endif /* HAVE_REPLICATION */
#else
void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool enable_local);
void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
bool enable_local);
#endif
Delete_file_log_event(const char* buf, uint event_len,
@ -1851,7 +1884,8 @@ public:
#endif
Execute_load_log_event(const char* buf, uint event_len,
const Format_description_log_event* description_event);
const Format_description_log_event
*description_event);
~Execute_load_log_event() {}
Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
int get_data_size() { return EXEC_LOAD_HEADER_LEN ;}
@ -1890,7 +1924,8 @@ public:
#endif /* HAVE_REPLICATION */
#endif
Begin_load_query_log_event(const char* buf, uint event_len,
const Format_description_log_event* description_event);
const Format_description_log_event
*description_event);
~Begin_load_query_log_event() {}
Log_event_type get_type_code() { return BEGIN_LOAD_QUERY_EVENT; }
};
@ -1942,7 +1977,8 @@ public:
const char *local_fname);
#endif
Execute_load_query_log_event(const char* buf, uint event_len,
const Format_description_log_event *description_event);
const Format_description_log_event
*description_event);
~Execute_load_query_log_event() {}
Log_event_type get_type_code() { return EXECUTE_LOAD_QUERY_EVENT; }
@ -1969,7 +2005,8 @@ public:
Log_event's ctor, this way we can extract maximum information from the
event's header (the unique ID for example).
*/
Unknown_log_event(const char* buf, const Format_description_log_event* description_event):
Unknown_log_event(const char* buf,
const Format_description_log_event *description_event):
Log_event(buf, description_event)
{}
~Unknown_log_event() {}

6
sql/log_event_old.cc
View file

@ -5,7 +5,7 @@
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
int
Write_rows_log_event_old::do_prepare_row(THD *thd,
Write_rows_log_event_old::do_prepare_row(THD *thd_arg,
RELAY_LOG_INFO const *rli,
TABLE *table,
uchar const *row_start,
@ -25,7 +25,7 @@ Write_rows_log_event_old::do_prepare_row(THD *thd,
int
Delete_rows_log_event_old::do_prepare_row(THD *thd,
Delete_rows_log_event_old::do_prepare_row(THD *thd_arg,
RELAY_LOG_INFO const *rli,
TABLE *table,
uchar const *row_start,
@ -58,7 +58,7 @@ Delete_rows_log_event_old::do_prepare_row(THD *thd,
}
int Update_rows_log_event_old::do_prepare_row(THD *thd,
int Update_rows_log_event_old::do_prepare_row(THD *thd_arg,
RELAY_LOG_INFO const *rli,
TABLE *table,
uchar const *row_start,

6
sql/mysql_priv.h
View file

@ -168,7 +168,7 @@ public:
protected:
Object_creation_ctx() {}
virtual Object_creation_ctx *create_backup_ctx(THD *thd) = 0;
virtual Object_creation_ctx *create_backup_ctx(THD *thd) const = 0;
virtual void change_env(THD *thd) const = 0;
@ -204,7 +204,7 @@ protected:
CHARSET_INFO *connection_cl);
protected:
virtual Object_creation_ctx *create_backup_ctx(THD *thd);
virtual Object_creation_ctx *create_backup_ctx(THD *thd) const;
virtual void change_env(THD *thd) const;
@ -1643,7 +1643,7 @@ bool key_cmp_if_same(TABLE *form,const uchar *key,uint index,uint key_length);
void key_unpack(String *to,TABLE *form,uint index);
bool is_key_used(TABLE *table, uint idx, const MY_BITMAP *fields);
int key_cmp(KEY_PART_INFO *key_part, const uchar *key, uint key_length);
int key_rec_cmp(void *key_info, uchar *a, uchar *b);
extern "C" int key_rec_cmp(void *key_info, uchar *a, uchar *b);
bool init_errmessage(void);
#endif /* MYSQL_SERVER */

52
sql/mysqld.cc
View file

@ -693,7 +693,7 @@ struct st_VioSSLFd *ssl_acceptor_fd;
pthread_handler_t signal_hand(void *arg);
static void mysql_init_variables(void);
static void get_options(int *argc,char **argv);
static my_bool get_one_option(int, const struct my_option *, char *);
extern "C" my_bool mysqld_get_one_option(int, const struct my_option *, char *);
static void set_server_version(void);
static int init_thread_environment();
static char *get_relative_path(const char *path);
@ -1141,6 +1141,7 @@ void unireg_end(void)
extern "C" void unireg_abort(int exit_code)
{
DBUG_ENTER("unireg_abort");
if (exit_code)
sql_print_error("Aborting\n");
else if (opt_help)
@ -2353,7 +2354,7 @@ static void init_signals(void)
sigaddset(&set,SIGTSTP);
#endif
if (thd_lib_detected != THD_LIB_LT)
sigaddset(&set,THR_SERVER_ALARM);
sigaddset(&set,THR_SERVER_ALARM);
if (test_flags & TEST_SIGINT)
{
// May be SIGINT
@ -2549,7 +2550,9 @@ static void check_data_home(const char *path)
/* ARGSUSED */
static int my_message_sql(uint error, const char *str, myf MyFlags)
extern "C" int my_message_sql(uint error, const char *str, myf MyFlags);
int my_message_sql(uint error, const char *str, myf MyFlags)
{
THD *thd;
DBUG_ENTER("my_message_sql");
@ -2612,13 +2615,16 @@ static int my_message_sql(uint error, const char *str, myf MyFlags)
#ifndef EMBEDDED_LIBRARY
static void *my_str_malloc_mysqld(size_t size)
extern "C" void *my_str_malloc_mysqld(size_t size);
extern "C" void my_str_free_mysqld(void *ptr);
void *my_str_malloc_mysqld(size_t size)
{
return my_malloc(size, MYF(MY_FAE));
}
static void my_str_free_mysqld(void *ptr)
void my_str_free_mysqld(void *ptr)
{
my_free((uchar*)ptr, MYF(MY_FAE));
}
@ -3418,7 +3424,7 @@ server.");
my_getopt_skip_unknown= 0;
if ((ho_error= handle_options(&defaults_argc, &tmp_argv, no_opts,
get_one_option)))
mysqld_get_one_option)))
unireg_abort(ho_error);
if (defaults_argc)
@ -3902,7 +3908,6 @@ we force server id to 2, but this MySQL server will not act as a slave.");
*/
if (init_slave() && !active_mi)
{
end_thr_alarm(1); // Don't allow alarms
unireg_abort(1);
}
@ -3910,16 +3915,12 @@ we force server id to 2, but this MySQL server will not act as a slave.");
{
select_thread_in_use= 0; // Allow 'kill' to work
bootstrap(stdin);
end_thr_alarm(1); // Don't allow alarms
unireg_abort(bootstrap_error ? 1 : 0);
}
if (opt_init_file)
{
if (read_init_file(opt_init_file))
{
end_thr_alarm(1); // Don't allow alarms
unireg_abort(1);
}
}
execute_ddl_log_recovery();
@ -6873,6 +6874,7 @@ SHOW_VAR status_vars[]= {
{"Open_streams", (char*) &my_stream_opened, SHOW_LONG_NOFLUSH},
{"Open_table_definitions", (char*) &show_table_definitions, SHOW_FUNC},
{"Open_tables", (char*) &show_open_tables, SHOW_FUNC},
{"Opened_files", (char*) &my_file_total_opened, SHOW_LONG_NOFLUSH},
{"Opened_tables", (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},
{"Prepared_stmt_count", (char*) &show_prepared_stmt_count, SHOW_FUNC},
#ifdef HAVE_QUERY_CACHE
@ -7240,9 +7242,10 @@ static void mysql_init_variables(void)
}
static my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
char *argument)
my_bool
mysqld_get_one_option(int optid,
const struct my_option *opt __attribute__((unused)),
char *argument)
{
switch(optid) {
case '#':
@ -7738,7 +7741,10 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
/* Handle arguments for multiple key caches */
static uchar* *
extern "C" uchar **mysql_getopt_value(const char *keyname, uint key_length,
const struct my_option *option);
uchar* *
mysql_getopt_value(const char *keyname, uint key_length,
const struct my_option *option)
{
@ -7767,11 +7773,19 @@ mysql_getopt_value(const char *keyname, uint key_length,
}
static void option_error_reporter(enum loglevel level, const char *format, ...)
extern "C" void option_error_reporter(enum loglevel level, const char *format, ...);
void option_error_reporter(enum loglevel level, const char *format, ...)
{
va_list args;
va_start(args, format);
vprint_msg_to_log(level, format, args);
/* Don't print warnings for --loose options during bootstrap */
if (level == ERROR_LEVEL || !opt_bootstrap ||
global_system_variables.log_warnings)
{
vprint_msg_to_log(level, format, args);
}
va_end(args);
}
@ -7789,7 +7803,7 @@ static void get_options(int *argc,char **argv)
my_getopt_skip_unknown= TRUE;
if ((ho_error= handle_options(argc, &argv, my_long_options,
get_one_option)))
mysqld_get_one_option)))
exit(ho_error);
(*argc)++; /* add back one for the progname handle_options removes */
/* no need to do this for argv as we are discarding it. */
@ -8150,7 +8164,7 @@ void refresh_status(THD *thd)
add_to_status(&global_status_var, &thd->status_var);
/* Reset thread's status variables */
bzero((char*) &thd->status_var, sizeof(thd->status_var));
bzero((uchar*) &thd->status_var, sizeof(thd->status_var));
/* Reset some global variables */
reset_status_vars();

59
sql/opt_range.cc
View file

@ -8375,7 +8375,8 @@ int QUICK_RANGE_SELECT::get_next_prefix(uint prefix_length,
{
/* Read the next record in the same range with prefix after cur_prefix. */
DBUG_ASSERT(cur_prefix != 0);
result= file->index_read(record, cur_prefix, keypart_map, HA_READ_AFTER_KEY);
result= file->index_read_map(record, cur_prefix, keypart_map,
HA_READ_AFTER_KEY);
if (result || (file->compare_key(file->end_range) <= 0))
DBUG_RETURN(result);
}
@ -8446,9 +8447,10 @@ int QUICK_RANGE_SELECT_GEOM::get_next()
}
last_range= *(cur_range++);
result= file->index_read(record, last_range->min_key,
last_range->min_keypart_map,
(ha_rkey_function)(last_range->flag ^ GEOM_FLAG));
result= file->index_read_map(record, last_range->min_key,
last_range->min_keypart_map,
(ha_rkey_function)(last_range->flag ^
GEOM_FLAG));
if (result != HA_ERR_KEY_NOT_FOUND && result != HA_ERR_END_OF_FILE)
DBUG_RETURN(result);
last_range= 0; // Not found, to next range
@ -8579,18 +8581,19 @@ int QUICK_SELECT_DESC::get_next()
if (last_range->flag & EQ_RANGE)
{
result = file->index_read(record, last_range->max_key,
last_range->max_keypart_map, HA_READ_KEY_EXACT);
result = file->index_read_map(record, last_range->max_key,
last_range->max_keypart_map,
HA_READ_KEY_EXACT);
}
else
{
DBUG_ASSERT(last_range->flag & NEAR_MAX ||
range_reads_after_key(last_range));
result=file->index_read(record, last_range->max_key,
last_range->max_keypart_map,
((last_range->flag & NEAR_MAX) ?
HA_READ_BEFORE_KEY :
HA_READ_PREFIX_LAST_OR_PREV));
result=file->index_read_map(record, last_range->max_key,
last_range->max_keypart_map,
((last_range->flag & NEAR_MAX) ?
HA_READ_BEFORE_KEY :
HA_READ_PREFIX_LAST_OR_PREV));
}
if (result)
{
@ -10446,9 +10449,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::get_next()
first sub-group with the extended prefix.
*/
if (!have_min && !have_max && key_infix_len > 0)
result= file->index_read(record, group_prefix,
make_prev_keypart_map(real_key_parts),
HA_READ_KEY_EXACT);
result= file->index_read_map(record, group_prefix,
make_prev_keypart_map(real_key_parts),
HA_READ_KEY_EXACT);
result= have_min ? min_res : have_max ? max_res : result;
} while ((result == HA_ERR_KEY_NOT_FOUND || result == HA_ERR_END_OF_FILE) &&
@ -10510,9 +10513,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min()
/* Apply the constant equality conditions to the non-group select fields */
if (key_infix_len > 0)
{
if ((result= file->index_read(record, group_prefix,
make_prev_keypart_map(real_key_parts),
HA_READ_KEY_EXACT)))
if ((result= file->index_read_map(record, group_prefix,
make_prev_keypart_map(real_key_parts),
HA_READ_KEY_EXACT)))
DBUG_RETURN(result);
}
@ -10527,9 +10530,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min()
{
/* Find the first subsequent record without NULL in the MIN/MAX field. */
key_copy(tmp_record, record, index_info, 0);
result= file->index_read(record, tmp_record,
make_keypart_map(real_key_parts),
HA_READ_AFTER_KEY);
result= file->index_read_map(record, tmp_record,
make_keypart_map(real_key_parts),
HA_READ_AFTER_KEY);
/*
Check if the new record belongs to the current group by comparing its
prefix with the group's prefix. If it is from the next group, then the
@ -10584,9 +10587,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_max()
if (min_max_ranges.elements > 0)
result= next_max_in_range();
else
result= file->index_read(record, group_prefix,
make_prev_keypart_map(real_key_parts),
HA_READ_PREFIX_LAST);
result= file->index_read_map(record, group_prefix,
make_prev_keypart_map(real_key_parts),
HA_READ_PREFIX_LAST);
DBUG_RETURN(result);
}
@ -10637,9 +10640,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_prefix()
else
{
/* Load the first key in this group into record. */
result= file->index_read(record, group_prefix,
make_prev_keypart_map(group_key_parts),
HA_READ_AFTER_KEY);
result= file->index_read_map(record, group_prefix,
make_prev_keypart_map(group_key_parts),
HA_READ_AFTER_KEY);
if (result)
DBUG_RETURN(result);
}
@ -10716,7 +10719,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min_in_range()
HA_READ_AFTER_KEY : HA_READ_KEY_OR_NEXT;
}
result= file->index_read(record, group_prefix, keypart_map, find_flag);
result= file->index_read_map(record, group_prefix, keypart_map, find_flag);
if (result)
{
if ((result == HA_ERR_KEY_NOT_FOUND || result == HA_ERR_END_OF_FILE) &&
@ -10849,7 +10852,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_max_in_range()
HA_READ_BEFORE_KEY : HA_READ_PREFIX_LAST_OR_PREV;
}
result= file->index_read(record, group_prefix, keypart_map, find_flag);
result= file->index_read_map(record, group_prefix, keypart_map, find_flag);
if (result)
{

31
sql/opt_sum.cc
View file

@ -270,9 +270,10 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
Closed interval: Either The MIN argument is non-nullable, or
we have a >= predicate for the MIN argument.
*/
error= table->file->index_read(table->record[0], ref.key_buff,
make_prev_keypart_map(ref.key_parts),
HA_READ_KEY_OR_NEXT);
error= table->file->index_read_map(table->record[0],
ref.key_buff,
make_prev_keypart_map(ref.key_parts),
HA_READ_KEY_OR_NEXT);
else
{
/*
@ -281,9 +282,10 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
2) there is a > predicate on it, nullability is irrelevant.
We need to scan the next bigger record first.
*/
error= table->file->index_read(table->record[0], ref.key_buff,
make_prev_keypart_map(ref.key_parts),
HA_READ_AFTER_KEY);
error= table->file->index_read_map(table->record[0],
ref.key_buff,
make_prev_keypart_map(ref.key_parts),
HA_READ_AFTER_KEY);
/*
If the found record is outside the group formed by the search
prefix, or there is no such record at all, check if all
@ -305,9 +307,10 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
key_cmp_if_same(table, ref.key_buff, ref.key, prefix_len)))
{
DBUG_ASSERT(item_field->field->real_maybe_null());
error= table->file->index_read(table->record[0], ref.key_buff,
make_prev_keypart_map(ref.key_parts),
HA_READ_KEY_EXACT);
error= table->file->index_read_map(table->record[0],
ref.key_buff,
make_prev_keypart_map(ref.key_parts),
HA_READ_KEY_EXACT);
}
}
}
@ -394,11 +397,11 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
if (!ref.key_length)
error= table->file->index_last(table->record[0]);
else
error= table->file->index_read(table->record[0], key_buff,
make_prev_keypart_map(ref.key_parts),
range_fl & NEAR_MAX ?
HA_READ_BEFORE_KEY :
HA_READ_PREFIX_LAST_OR_PREV);
error= table->file->index_read_map(table->record[0], key_buff,
make_prev_keypart_map(ref.key_parts),
range_fl & NEAR_MAX ?
HA_READ_BEFORE_KEY :
HA_READ_PREFIX_LAST_OR_PREV);
if (!error && reckey_in_range(1, &ref, item_field->field,
conds, range_fl, prefix_len))
error= HA_ERR_KEY_NOT_FOUND;

8
sql/partition_info.cc
View file

@ -91,10 +91,10 @@ partition_info *partition_info::get_clone()
#define MAX_PART_NAME_SIZE 8
char *partition_info::create_default_partition_names(uint part_no,
uint no_parts,
uint no_parts_arg,
uint start_no)
{
char *ptr= (char*) sql_calloc(no_parts*MAX_PART_NAME_SIZE);
char *ptr= (char*) sql_calloc(no_parts_arg*MAX_PART_NAME_SIZE);
char *move_ptr= ptr;
uint i= 0;
DBUG_ENTER("create_default_partition_names");
@ -105,11 +105,11 @@ char *partition_info::create_default_partition_names(uint part_no,
{
my_sprintf(move_ptr, (move_ptr,"p%u", (start_no + i)));
move_ptr+=MAX_PART_NAME_SIZE;
} while (++i < no_parts);
} while (++i < no_parts_arg);
}
else
{
mem_alloc_error(no_parts*MAX_PART_NAME_SIZE);
mem_alloc_error(no_parts_arg*MAX_PART_NAME_SIZE);
}
DBUG_RETURN(ptr);
}

8
sql/rpl_filter.cc
View file

@ -362,9 +362,11 @@ Rpl_filter::add_ignore_db(const char* table_spec)
ignore_db.push_back(db);
}
extern "C" uchar *get_table_key(const uchar *, size_t *, my_bool);
extern "C" void free_table_ent(void* a);
static uchar* get_table_key(const uchar* a, size_t *len,
my_bool __attribute__((unused)))
uchar *get_table_key(const uchar* a, size_t *len,
my_bool __attribute__((unused)))
{
TABLE_RULE_ENT *e= (TABLE_RULE_ENT *) a;
@ -373,7 +375,7 @@ static uchar* get_table_key(const uchar* a, size_t *len,
}
static void free_table_ent(void* a)
void free_table_ent(void* a)
{
TABLE_RULE_ENT *e= (TABLE_RULE_ENT *) a;

15
sql/set_var.cc
View file

@ -3266,11 +3266,12 @@ bool sys_var_thd_storage_engine::check(THD *thd, set_var *var)
var->save_result.plugin= NULL;
if (var->value->result_type() == STRING_RESULT)
{
LEX_STRING name;
LEX_STRING engine_name;
handlerton *hton;
if (!(res=var->value->val_str(&str)) ||
!(name.str= (char *)res->ptr()) || !(name.length= res->length()) ||
!(var->save_result.plugin= ha_resolve_by_name(thd, &name)) ||
!(engine_name.str= (char *)res->ptr()) ||
!(engine_name.length= res->length()) ||
!(var->save_result.plugin= ha_resolve_by_name(thd, &engine_name)) ||
!(hton= plugin_data(var->save_result.plugin, handlerton *)) ||
ha_checktype(thd, ha_legacy_type(hton), 1, 0) != hton)
{
@ -3292,13 +3293,13 @@ uchar *sys_var_thd_storage_engine::value_ptr(THD *thd, enum_var_type type,
{
uchar* result;
handlerton *hton;
LEX_STRING *name;
LEX_STRING *engine_name;
plugin_ref plugin= thd->variables.*offset;
if (type == OPT_GLOBAL)
plugin= my_plugin_lock(thd, &(global_system_variables.*offset));
hton= plugin_data(plugin, handlerton*);
name= &hton2plugin[hton->slot]->name;
result= (uchar *) thd->strmake(name->str, name->length);
engine_name= &hton2plugin[hton->slot]->name;
result= (uchar *) thd->strmake(engine_name->str, engine_name->length);
if (type == OPT_GLOBAL)
plugin_unlock(thd, plugin);
return result;
@ -3585,7 +3586,7 @@ void free_key_cache(const char *name, KEY_CACHE *key_cache)
}
bool process_key_caches(int (* func) (const char *name, KEY_CACHE *))
bool process_key_caches(process_key_cache_t func)
{
I_List_iterator<NAMED_LIST> it(key_caches);
NAMED_LIST *element;

10
sql/set_var.h
View file

@ -1128,6 +1128,11 @@ public:
};
extern "C"
{
typedef int (*process_key_cache_t) (const char *, KEY_CACHE *);
}
/* Named lists (used for keycaches) */
class NAMED_LIST :public ilink
@ -1152,8 +1157,7 @@ public:
{
my_free((uchar*) name, MYF(0));
}
friend bool process_key_caches(int (* func) (const char *name,
KEY_CACHE *));
friend bool process_key_caches(process_key_cache_t func);
friend void delete_elements(I_List<NAMED_LIST> *list,
void (*free_element)(const char*, uchar*));
};
@ -1201,6 +1205,6 @@ extern sys_var_str sys_var_general_log_path, sys_var_slow_log_path;
KEY_CACHE *get_key_cache(LEX_STRING *cache_name);
KEY_CACHE *get_or_create_key_cache(const char *name, uint length);
void free_key_cache(const char *name, KEY_CACHE *key_cache);
bool process_key_caches(int (* func) (const char *name, KEY_CACHE *));
bool process_key_caches(process_key_cache_t func);
void delete_elements(I_List<NAMED_LIST> *list,
void (*free_element)(const char*, uchar*));

13
sql/sp.cc
View file

@ -97,7 +97,8 @@ public:
protected:
virtual Object_creation_ctx *create_backup_ctx(THD *thd) const
{
return new Stored_routine_creation_ctx(thd);
DBUG_ENTER("Stored_routine_creation_ctx::create_backup_ctx");
DBUG_RETURN(new Stored_routine_creation_ctx(thd));
}
private:
@ -348,8 +349,8 @@ db_find_routine_aux(THD *thd, int type, sp_name *name, TABLE *table)
key_copy(key, table->record[0], table->key_info,
table->key_info->key_length);
if (table->file->index_read_idx(table->record[0], 0, key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (table->file->index_read_idx_map(table->record[0], 0, key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
DBUG_RETURN(SP_KEY_NOT_FOUND);
DBUG_RETURN(SP_OK);
@ -1182,9 +1183,9 @@ sp_drop_db_routines(THD *thd, char *db)
ret= SP_OK;
table->file->ha_index_init(0, 1);
if (! table->file->index_read(table->record[0],
(uchar *)table->field[MYSQL_PROC_FIELD_DB]->ptr,
(key_part_map)1, HA_READ_KEY_EXACT))
if (! table->file->index_read_map(table->record[0],
(uchar *)table->field[MYSQL_PROC_FIELD_DB]->ptr,
(key_part_map)1, HA_READ_KEY_EXACT))
{
int nxtres;
bool deleted= FALSE;

11
sql/sp_cache.cc
View file

@ -214,8 +214,12 @@ void sp_cache_flush_obsolete(sp_cache **cp)
Internal functions
*************************************************************************/
static uchar *hash_get_key_for_sp_head(const uchar *ptr, size_t *plen,
my_bool first)
extern "C" uchar *hash_get_key_for_sp_head(const uchar *ptr, size_t *plen,
my_bool first);
extern "C" void hash_free_sp_head(void *p);
uchar *hash_get_key_for_sp_head(const uchar *ptr, size_t *plen,
my_bool first)
{
sp_head *sp= (sp_head *)ptr;
*plen= sp->m_qname.length;
@ -223,8 +227,7 @@ static uchar *hash_get_key_for_sp_head(const uchar *ptr, size_t *plen,
}
static void
hash_free_sp_head(void *p)
void hash_free_sp_head(void *p)
{
sp_head *sp= (sp_head *)p;
delete sp;

17
sql/sp_head.cc
View file

@ -32,6 +32,8 @@
#include <my_user.h>
extern "C" uchar *sp_table_key(const uchar *ptr, size_t *plen, my_bool first);
Item_result
sp_map_result_type(enum enum_field_types type)
{
@ -483,7 +485,6 @@ sp_head::sp_head()
*/
m_db= m_name= m_qname= str_reset;
extern uchar *sp_table_key(const uchar *ptr, size_t *plen, my_bool first);
DBUG_ENTER("sp_head::sp_head");
m_backpatch.empty();
@ -1077,6 +1078,12 @@ sp_head::execute(THD *thd)
thd->query_error= 0;
old_arena= thd->stmt_arena;
/*
Switch query context. This has to be done early as this is sometimes
allocated trough sql_alloc
*/
saved_creation_ctx= m_creation_ctx->set_n_backup(thd);
/*
We have to save/restore this info when we are changing call level to
be able properly do close_thread_tables() in instructions.
@ -1122,10 +1129,6 @@ sp_head::execute(THD *thd)
*/
thd->spcont->callers_arena= &backup_arena;
/* Switch query context. */
saved_creation_ctx= m_creation_ctx->set_n_backup(thd);
do
{
sp_instr *i;
@ -3602,8 +3605,8 @@ typedef struct st_sp_table
uint8 trg_event_map;
} SP_TABLE;
uchar *
sp_table_key(const uchar *ptr, size_t *plen, my_bool first)
uchar *sp_table_key(const uchar *ptr, size_t *plen, my_bool first)
{
SP_TABLE *tab= (SP_TABLE *)ptr;
*plen= tab->qname.length;

47
sql/sql_acl.cc
View file

@ -1815,9 +1815,9 @@ static bool update_user_table(THD *thd, TABLE *table,
key_copy((uchar *) user_key, table->record[0], table->key_info,
table->key_info->key_length);
if (table->file->index_read_idx(table->record[0], 0,
(uchar *) user_key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (table->file->index_read_idx_map(table->record[0], 0,
(uchar *) user_key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{
my_message(ER_PASSWORD_NO_MATCH, ER(ER_PASSWORD_NO_MATCH),
MYF(0)); /* purecov: deadcode */
@ -1908,8 +1908,9 @@ static int replace_user_table(THD *thd, TABLE *table, const LEX_USER &combo,
key_copy(user_key, table->record[0], table->key_info,
table->key_info->key_length);
if (table->file->index_read_idx(table->record[0], 0, user_key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (table->file->index_read_idx_map(table->record[0], 0, user_key,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{
/* what == 'N' means revoke */
if (what == 'N')
@ -2131,8 +2132,9 @@ static int replace_db_table(TABLE *table, const char *db,
key_copy(user_key, table->record[0], table->key_info,
table->key_info->key_length);
if (table->file->index_read_idx(table->record[0],0, user_key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (table->file->index_read_idx_map(table->record[0],0, user_key,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{
if (what == 'N')
{ // no row, no revoke
@ -2348,8 +2350,8 @@ GRANT_TABLE::GRANT_TABLE(TABLE *form, TABLE *col_privs)
col_privs->field[4]->store("",0, &my_charset_latin1);
col_privs->file->ha_index_init(0, 1);
if (col_privs->file->index_read(col_privs->record[0], (uchar*) key,
(key_part_map)15, HA_READ_KEY_EXACT))
if (col_privs->file->index_read_map(col_privs->record[0], (uchar*) key,
(key_part_map)15, HA_READ_KEY_EXACT))
{
cols = 0; /* purecov: deadcode */
col_privs->file->ha_index_end();
@ -2511,8 +2513,8 @@ static int replace_column_table(GRANT_TABLE *g_t,
key_copy(user_key, table->record[0], table->key_info,
table->key_info->key_length);
if (table->file->index_read(table->record[0], user_key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (table->file->index_read_map(table->record[0], user_key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{
if (revoke_grant)
{
@ -2589,8 +2591,9 @@ static int replace_column_table(GRANT_TABLE *g_t,
key_copy(user_key, table->record[0], table->key_info,
key_prefix_length);
if (table->file->index_read(table->record[0], user_key, (key_part_map)15,
HA_READ_KEY_EXACT))
if (table->file->index_read_map(table->record[0], user_key,
(key_part_map)15,
HA_READ_KEY_EXACT))
goto end;
/* Scan through all rows with the same host,db,user and table */
@ -2691,8 +2694,9 @@ static int replace_table_table(THD *thd, GRANT_TABLE *grant_table,
key_copy(user_key, table->record[0], table->key_info,
table->key_info->key_length);
if (table->file->index_read_idx(table->record[0], 0, user_key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (table->file->index_read_idx_map(table->record[0], 0, user_key,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{
/*
The following should never happen as we first check the in memory
@ -2816,9 +2820,10 @@ static int replace_routine_table(THD *thd, GRANT_NAME *grant_name,
TRUE);
store_record(table,record[1]); // store at pos 1
if (table->file->index_read_idx(table->record[0], 0,
(uchar*) table->field[0]->ptr, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (table->file->index_read_idx_map(table->record[0], 0,
(uchar*) table->field[0]->ptr,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{
/*
The following should never happen as we first check the in memory
@ -5015,9 +5020,9 @@ static int handle_grant_table(TABLE_LIST *tables, uint table_no, bool drop,
table->key_info->key_part[1].store_length);
key_copy(user_key, table->record[0], table->key_info, key_prefix_length);
if ((error= table->file->index_read_idx(table->record[0], 0,
user_key, (key_part_map)3,
HA_READ_KEY_EXACT)))
if ((error= table->file->index_read_idx_map(table->record[0], 0,
user_key, (key_part_map)3,
HA_READ_KEY_EXACT)))
{
if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
{

15
sql/sql_class.cc
View file

@ -2730,14 +2730,17 @@ void mark_transaction_to_rollback(THD *thd, bool all)
pthread_mutex_t LOCK_xid_cache;
HASH xid_cache;
static uchar *xid_get_hash_key(const uchar *ptr, size_t *length,
extern "C" uchar *xid_get_hash_key(const uchar *, size_t *, my_bool);
extern "C" void xid_free_hash(void *);
uchar *xid_get_hash_key(const uchar *ptr, size_t *length,
my_bool not_used __attribute__((unused)))
{
*length=((XID_STATE*)ptr)->xid.key_length();
return ((XID_STATE*)ptr)->xid.key();
}
static void xid_free_hash (void *ptr)
void xid_free_hash(void *ptr)
{
if (!((XID_STATE*)ptr)->in_thd)
my_free((uchar*)ptr, MYF(0));
@ -3271,13 +3274,13 @@ int THD::binlog_flush_pending_rows_event(bool stmt_end)
RETURN VALUE
Error code, or 0 if no error.
*/
int THD::binlog_query(THD::enum_binlog_query_type qtype, char const *query,
int THD::binlog_query(THD::enum_binlog_query_type qtype, char const *query_arg,
ulong query_len, bool is_trans, bool suppress_use,
THD::killed_state killed_status_arg)
{
DBUG_ENTER("THD::binlog_query");
DBUG_PRINT("enter", ("qtype=%d, query='%s'", qtype, query));
DBUG_ASSERT(query && mysql_bin_log.is_open());
DBUG_PRINT("enter", ("qtype: %d query: '%s'", qtype, query_arg));
DBUG_ASSERT(query_arg && mysql_bin_log.is_open());
/*
If we are not in prelocked mode, mysql_unlock_tables() will be
@ -3333,7 +3336,7 @@ int THD::binlog_query(THD::enum_binlog_query_type qtype, char const *query,
flush the pending rows event if necessary.
*/
{
Query_log_event qinfo(this, query, query_len, is_trans, suppress_use,
Query_log_event qinfo(this, query_arg, query_len, is_trans, suppress_use,
killed_status_arg);
qinfo.flags|= LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F;
/*

4
sql/sql_class.h
View file

@ -1316,10 +1316,10 @@ public:
mode, row-based binlogging is used for such cases where two
auto_increment columns are inserted.
*/
inline void record_first_successful_insert_id_in_cur_stmt(ulonglong id)
inline void record_first_successful_insert_id_in_cur_stmt(ulonglong id_arg)
{
if (first_successful_insert_id_in_cur_stmt == 0)
first_successful_insert_id_in_cur_stmt= id;
first_successful_insert_id_in_cur_stmt= id_arg;
}
inline ulonglong read_first_successful_insert_id_in_prev_stmt(void)
{

21
sql/sql_db.cc
View file

@ -59,8 +59,10 @@ typedef struct my_dblock_st
lock_db key.
*/
static uchar* lock_db_get_key(my_dblock_t *ptr, size_t *length,
my_bool not_used __attribute__((unused)))
extern "C" uchar* lock_db_get_key(my_dblock_t *, size_t *, my_bool not_used);
uchar* lock_db_get_key(my_dblock_t *ptr, size_t *length,
my_bool not_used __attribute__((unused)))
{
*length= ptr->name_length;
return (uchar*) ptr->name;
@ -71,7 +73,9 @@ static uchar* lock_db_get_key(my_dblock_t *ptr, size_t *length,
Free lock_db hash element.
*/
static void lock_db_free_element(void *ptr)
extern "C" void lock_db_free_element(void *ptr);
void lock_db_free_element(void *ptr)
{
my_free(ptr, MYF(0));
}
@ -155,8 +159,11 @@ typedef struct my_dbopt_st
Function we use in the creation of our hash to get key.
*/
static uchar* dboptions_get_key(my_dbopt_t *opt, size_t *length,
my_bool not_used __attribute__((unused)))
extern "C" uchar* dboptions_get_key(my_dbopt_t *opt, size_t *length,
my_bool not_used);
uchar* dboptions_get_key(my_dbopt_t *opt, size_t *length,
my_bool not_used __attribute__((unused)))
{
*length= opt->name_length;
return (uchar*) opt->name;
@ -182,7 +189,9 @@ static inline void write_to_binlog(THD *thd, char *query, uint q_len,
Function to free dboptions hash element
*/
static void free_dbopt(void *dbopt)
extern "C" void free_dbopt(void *dbopt);
void free_dbopt(void *dbopt)
{
my_free((uchar*) dbopt, MYF(0));
}

6
sql/sql_delete.cc
View file

@ -760,7 +760,7 @@ void multi_delete::send_error(uint errcode,const char *err)
int multi_delete::do_deletes()
{
int local_error= 0, counter= 0, error;
int local_error= 0, counter= 0, tmp_error;
bool will_batch;
DBUG_ENTER("do_deletes");
DBUG_ASSERT(do_delete);
@ -814,11 +814,11 @@ int multi_delete::do_deletes()
break;
}
}
if (will_batch && (error= table->file->end_bulk_delete()))
if (will_batch && (tmp_error= table->file->end_bulk_delete()))
{
if (!local_error)
{
local_error= error;
local_error= tmp_error;
table->file->print_error(local_error,MYF(0));
}
}

4
sql/sql_handler.cc
View file

@ -541,8 +541,8 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables,
table->file->ha_index_or_rnd_end();
table->file->ha_index_init(keyno, 1);
key_copy(key, table->record[0], table->key_info + keyno, key_len);
error= table->file->index_read(table->record[0],
key, keypart_map, ha_rkey_mode);
error= table->file->index_read_map(table->record[0],
key, keypart_map, ha_rkey_mode);
mode=rkey_to_rnext[(int)ha_rkey_mode];
break;
}

10
sql/sql_help.cc
View file

@ -294,9 +294,9 @@ int get_topics_for_keyword(THD *thd, TABLE *topics, TABLE *relations,
rkey_id->store((longlong) key_id, TRUE);
rkey_id->get_key_image(buff, rkey_id->pack_length(), Field::itRAW);
int key_res= relations->file->index_read(relations->record[0],
buff, (key_part_map) 1,
HA_READ_KEY_EXACT);
int key_res= relations->file->index_read_map(relations->record[0],
buff, (key_part_map) 1,
HA_READ_KEY_EXACT);
for ( ;
!key_res && key_id == (int16) rkey_id->val_int() ;
@ -308,8 +308,8 @@ int get_topics_for_keyword(THD *thd, TABLE *topics, TABLE *relations,
field->store((longlong) topic_id, TRUE);
field->get_key_image(topic_id_buff, field->pack_length(), Field::itRAW);
if (!topics->file->index_read(topics->record[0], topic_id_buff,
(key_part_map)1, HA_READ_KEY_EXACT))
if (!topics->file->index_read_map(topics->record[0], topic_id_buff,
(key_part_map)1, HA_READ_KEY_EXACT))
{
memorize_variant_topic(thd,topics,count,find_fields,
names,name,description,example);

14
sql/sql_insert.cc
View file

@ -1398,9 +1398,9 @@ int write_record(THD *thd, TABLE *table,COPY_INFO *info)
}
}
key_copy((uchar*) key,table->record[0],table->key_info+key_nr,0);
if ((error=(table->file->index_read_idx(table->record[1],key_nr,
(uchar*) key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))))
if ((error=(table->file->index_read_idx_map(table->record[1],key_nr,
(uchar*) key, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))))
goto err;
}
if (info->handle_duplicates == DUP_UPDATE)
@ -3556,13 +3556,13 @@ select_create::binlog_show_create_table(TABLE **tables, uint count)
char buf[2048];
String query(buf, sizeof(buf), system_charset_info);
int result;
TABLE_LIST table_list;
TABLE_LIST tmp_table_list;
memset(&table_list, 0, sizeof(table_list));
table_list.table = *tables;
memset(&tmp_table_list, 0, sizeof(tmp_table_list));
tmp_table_list.table = *tables;
query.length(0); // Have to zero it since constructor doesn't
result= store_create_info(thd, &table_list, &query, create_info);
result= store_create_info(thd, &tmp_table_list, &query, create_info);
DBUG_ASSERT(result == 0); /* store_create_info() always return 0 */
thd->binlog_query(THD::STMT_QUERY_TYPE,

8
sql/sql_lex.cc
View file

@ -2826,8 +2826,8 @@ void st_select_lex::fix_prepare_information(THD *thd, Item **conds,
SYNOPSIS
set_index_hint_type()
type the kind of hints to be added from now on.
clause the clause to use for hints to be added from now on.
type_arg The kind of hints to be added from now on.
clause The clause to use for hints to be added from now on.
DESCRIPTION
Used in filling up the tagged hints list.
@ -2836,10 +2836,10 @@ void st_select_lex::fix_prepare_information(THD *thd, Item **conds,
Then the context variable index_hint_type can be reset to the
next hint type.
*/
void st_select_lex::set_index_hint_type(enum index_hint_type type,
void st_select_lex::set_index_hint_type(enum index_hint_type type_arg,
index_clause_map clause)
{
current_index_hint_type= type;
current_index_hint_type= type_arg;
current_index_hint_clause= clause;
}

29
sql/sql_plugin.cc
View file

@ -1058,8 +1058,12 @@ err:
}
static uchar *get_hash_key(const uchar *buff, size_t *length,
my_bool not_used __attribute__((unused)))
extern "C" uchar *get_plugin_hash_key(const uchar *, size_t *, my_bool);
extern "C" uchar *get_bookmark_hash_key(const uchar *, size_t *, my_bool);
uchar *get_plugin_hash_key(const uchar *buff, size_t *length,
my_bool not_used __attribute__((unused)))
{
struct st_plugin_int *plugin= (st_plugin_int *)buff;
*length= (uint)plugin->name.length;
@ -1067,8 +1071,8 @@ static uchar *get_hash_key(const uchar *buff, size_t *length,
}
static uchar *get_bookmark_hash_key(const uchar *buff, size_t *length,
my_bool not_used __attribute__((unused)))
uchar *get_bookmark_hash_key(const uchar *buff, size_t *length,
my_bool not_used __attribute__((unused)))
{
struct st_bookmark *var= (st_bookmark *)buff;
*length= var->name_len + 1;
@ -1115,7 +1119,7 @@ int plugin_init(int *argc, char **argv, int flags)
for (i= 0; i < MYSQL_MAX_PLUGIN_TYPE_NUM; i++)
{
if (hash_init(&plugin_hash[i], system_charset_info, 16, 0, 0,
get_hash_key, NULL, HASH_UNIQUE))
get_plugin_hash_key, NULL, HASH_UNIQUE))
goto err;
}
@ -1702,9 +1706,10 @@ bool mysql_uninstall_plugin(THD *thd, const LEX_STRING *name)
table->use_all_columns();
table->field[0]->store(name->str, name->length, system_charset_info);
if (! table->file->index_read_idx(table->record[0], 0,
(uchar *)table->field[0]->ptr, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (! table->file->index_read_idx_map(table->record[0], 0,
(uchar *)table->field[0]->ptr,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{
int error;
if ((error= table->file->ha_delete_row(table->record[0])))
@ -2769,8 +2774,10 @@ static void plugin_opt_set_limits(struct my_option *options,
options->arg_type= OPT_ARG;
}
extern "C" my_bool get_one_plugin_option(int optid, const struct my_option *,
char *);
static my_bool get_one_option(int optid __attribute__((unused)),
my_bool get_one_plugin_option(int optid __attribute__((unused)),
const struct my_option *opt,
char *argument)
{
@ -3078,7 +3085,7 @@ static int test_plugin_options(MEM_ROOT *tmp_root, struct st_plugin_int *tmp,
DBUG_RETURN(-1);
}
error= handle_options(argc, &argv, opts, get_one_option);
error= handle_options(argc, &argv, opts, get_one_plugin_option);
(*argc)++; /* add back one for the program name */
if (error)
@ -3140,7 +3147,7 @@ static int test_plugin_options(MEM_ROOT *tmp_root, struct st_plugin_int *tmp,
DBUG_RETURN(0);
}
if (enabled_saved)
if (enabled_saved && global_system_variables.log_warnings)
sql_print_information("Plugin '%s' disabled by command line option",
tmp->name.str);
DBUG_RETURN(1);

44
sql/sql_select.cc
View file

@ -11151,10 +11151,10 @@ int safe_index_read(JOIN_TAB *tab)
{
int error;
TABLE *table= tab->table;
if ((error=table->file->index_read(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT)))
if ((error=table->file->index_read_map(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT)))
return report_error(table, error);
return 0;
}
@ -11290,10 +11290,10 @@ join_read_const(JOIN_TAB *tab)
error=HA_ERR_KEY_NOT_FOUND;
else
{
error=table->file->index_read_idx(table->record[0],tab->ref.key,
(uchar*) tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT);
error=table->file->index_read_idx_map(table->record[0],tab->ref.key,
(uchar*) tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT);
}
if (error)
{
@ -11334,10 +11334,10 @@ join_read_key(JOIN_TAB *tab)
table->status=STATUS_NOT_FOUND;
return -1;
}
error=table->file->index_read(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT);
error=table->file->index_read_map(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT);
if (error && error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
return report_error(table, error);
}
@ -11363,10 +11363,10 @@ join_read_always_key(JOIN_TAB *tab)
}
if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))
return -1;
if ((error=table->file->index_read(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT)))
if ((error=table->file->index_read_map(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts),
HA_READ_KEY_EXACT)))
{
if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
return report_error(table, error);
@ -11391,8 +11391,9 @@ join_read_last_key(JOIN_TAB *tab)
table->file->ha_index_init(tab->ref.key, tab->sorted);
if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))
return -1;
if ((error=table->file->index_read_last(table->record[0],
tab->ref.key_buff, make_prev_keypart_map(tab->ref.key_parts))))
if ((error=table->file->index_read_last_map(table->record[0],
tab->ref.key_buff,
make_prev_keypart_map(tab->ref.key_parts))))
{
if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
return report_error(table, error);
@ -11933,9 +11934,10 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
if (item->maybe_null)
group->buff[-1]= (char) group->field->is_null();
}
if (!table->file->index_read(table->record[1],
join->tmp_table_param.group_buff, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (!table->file->index_read_map(table->record[1],
join->tmp_table_param.group_buff,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{ /* Update old record */
restore_record(table,record[1]);
update_tmptable_sum_func(join->sum_funcs,table);

21
sql/sql_servers.cc
View file

@ -516,9 +516,10 @@ int insert_server_record(TABLE *table, FOREIGN_SERVER *server)
system_charset_info);
/* read index until record is that specified in server_name */
if ((error= table->file->index_read_idx(table->record[0], 0,
(uchar *)table->field[0]->ptr, HA_WHOLE_KEY,
HA_READ_KEY_EXACT)))
if ((error= table->file->index_read_idx_map(table->record[0], 0,
(uchar *)table->field[0]->ptr,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT)))
{
/* if not found, err */
if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
@ -858,9 +859,10 @@ update_server_record(TABLE *table, FOREIGN_SERVER *server)
server->server_name_length,
system_charset_info);
if ((error= table->file->index_read_idx(table->record[0], 0,
(uchar *)table->field[0]->ptr, ~(longlong)0,
HA_READ_KEY_EXACT)))
if ((error= table->file->index_read_idx_map(table->record[0], 0,
(uchar *)table->field[0]->ptr,
~(longlong)0,
HA_READ_KEY_EXACT)))
{
if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
table->file->print_error(error, MYF(0));
@ -914,9 +916,10 @@ delete_server_record(TABLE *table,
/* set the field that's the PK to the value we're looking for */
table->field[0]->store(server_name, server_name_length, system_charset_info);
if ((error= table->file->index_read_idx(table->record[0], 0,
(uchar *)table->field[0]->ptr, HA_WHOLE_KEY,
HA_READ_KEY_EXACT)))
if ((error= table->file->index_read_idx_map(table->record[0], 0,
(uchar *)table->field[0]->ptr,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT)))
{
if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
table->file->print_error(error, MYF(0));

13
sql/sql_show.cc
View file

@ -1356,6 +1356,11 @@ int store_create_info(THD *thd, TABLE_LIST *table_list, String *packet,
packet->append(STRING_WITH_LEN(" ROW_FORMAT="));
packet->append(ha_row_type[(uint) share->row_type]);
}
if (share->transactional != HA_CHOICE_UNDEF)
{
packet->append(STRING_WITH_LEN(" TRANSACTIONAL="));
packet->append(share->transactional == HA_CHOICE_YES ? "1" : "0", 1);
}
if (table->s->key_block_size)
{
char *end;
@ -3393,6 +3398,12 @@ static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
ptr=strxmov(ptr, " row_format=",
ha_row_type[(uint) share->row_type],
NullS);
if (share->transactional != HA_CHOICE_UNDEF)
{
ptr= strxmov(ptr, " TRANSACTIONAL=",
(share->transactional == HA_CHOICE_YES ? "1" : "0"),
NullS);
}
#ifdef WITH_PARTITION_STORAGE_ENGINE
if (show_table->s->db_type() == partition_hton &&
show_table->part_info != NULL &&
@ -3434,7 +3445,7 @@ static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
case ROW_TYPE_COMPACT:
tmp_buff= "Compact";
break;
case ROW_TYPE_PAGES:
case ROW_TYPE_PAGE:
tmp_buff= "Paged";
break;
}

12
sql/sql_string.cc
View file

@ -797,10 +797,8 @@ copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
const uchar *from_end= (const uchar*) from+from_length;
char *to_start= to;
uchar *to_end= (uchar*) to+to_length;
int (*mb_wc)(struct charset_info_st *, my_wc_t *, const uchar *,
const uchar *) = from_cs->cset->mb_wc;
int (*wc_mb)(struct charset_info_st *, my_wc_t, uchar *s, uchar *e)=
to_cs->cset->wc_mb;
my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
uint error_count= 0;
while (1)
@ -942,10 +940,8 @@ well_formed_copy_nchars(CHARSET_INFO *to_cs,
{
int cnvres;
my_wc_t wc;
int (*mb_wc)(struct charset_info_st *, my_wc_t *,
const uchar *, const uchar *)= from_cs->cset->mb_wc;
int (*wc_mb)(struct charset_info_st *, my_wc_t,
uchar *s, uchar *e)= to_cs->cset->wc_mb;
my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
const uchar *from_end= (const uchar*) from + from_length;
uchar *to_end= (uchar*) to + to_length;
char *to_start= to;

2
sql/sql_table.cc
View file

@ -5282,6 +5282,8 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
}
if (!(used_fields & HA_CREATE_USED_KEY_BLOCK_SIZE))
create_info->key_block_size= table->s->key_block_size;
if (!(used_fields & HA_CREATE_USED_TRANSACTIONAL))
create_info->transactional= table->s->transactional;
if (!create_info->tablespace && create_info->storage_media != HA_SM_MEMORY)
{

7
sql/sql_udf.cc
View file

@ -551,9 +551,10 @@ int mysql_drop_function(THD *thd,const LEX_STRING *udf_name)
goto err;
table->use_all_columns();
table->field[0]->store(exact_name_str, exact_name_len, &my_charset_bin);
if (!table->file->index_read_idx(table->record[0], 0,
(uchar*) table->field[0]->ptr, HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
if (!table->file->index_read_idx_map(table->record[0], 0,
(uchar*) table->field[0]->ptr,
HA_WHOLE_KEY,
HA_READ_KEY_EXACT))
{
int error;
if ((error = table->file->ha_delete_row(table->record[0])))

13
sql/sql_yacc.yy
View file

@ -857,6 +857,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
%token OUT_SYM /* SQL-2003-R */
%token OWNER_SYM
%token PACK_KEYS_SYM
%token PAGE_SYM
%token PARAM_MARKER
%token PARSER_SYM
%token PARTIAL /* SQL-2003-N */
@ -1009,6 +1010,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
%token TO_SYM /* SQL-2003-R */
%token TRAILING /* SQL-2003-R */
%token TRANSACTION_SYM
%token TRANSACTIONAL_SYM
%token TRIGGERS_SYM
%token TRIGGER_SYM /* SQL-2003-R */
%token TRIM /* SQL-2003-N */
@ -4364,6 +4366,12 @@ create_table_option:
Lex->create_info.used_fields|= HA_CREATE_USED_KEY_BLOCK_SIZE;
Lex->create_info.key_block_size= $3;
}
| TRANSACTIONAL_SYM opt_equal ulong_num
{
Lex->create_info.used_fields|= HA_CREATE_USED_TRANSACTIONAL;
Lex->create_info.transactional= ($3 != 0 ? HA_CHOICE_YES :
HA_CHOICE_NO);
}
;
default_charset:
@ -4442,7 +4450,8 @@ row_types:
| DYNAMIC_SYM { $$= ROW_TYPE_DYNAMIC; }
| COMPRESSED_SYM { $$= ROW_TYPE_COMPRESSED; }
| REDUNDANT_SYM { $$= ROW_TYPE_REDUNDANT; }
| COMPACT_SYM { $$= ROW_TYPE_COMPACT; };
| COMPACT_SYM { $$= ROW_TYPE_COMPACT; }
| PAGE_SYM { $$= ROW_TYPE_PAGE; };
merge_insert_types:
NO_SYM { $$= MERGE_INSERT_DISABLED; }
@ -10073,6 +10082,7 @@ keyword_sp:
| ONE_SHOT_SYM {}
| ONE_SYM {}
| PACK_KEYS_SYM {}
| PAGE_SYM {}
| PARTIAL {}
| PARTITIONING_SYM {}
| PARTITIONS_SYM {}
@ -10142,6 +10152,7 @@ keyword_sp:
| TEXT_SYM {}
| THAN_SYM {}
| TRANSACTION_SYM {}
| TRANSACTIONAL_SYM {}
| TRIGGERS_SYM {}
| TIMESTAMP {}
| TIMESTAMP_ADD {}

6
sql/strfunc.cc
View file

@ -265,10 +265,8 @@ uint strconvert(CHARSET_INFO *from_cs, const char *from,
my_wc_t wc;
char *to_start= to;
uchar *to_end= (uchar*) to + to_length - 1;
int (*mb_wc)(struct charset_info_st *, my_wc_t *, const uchar *,
const uchar *)= from_cs->cset->mb_wc;
int (*wc_mb)(struct charset_info_st *, my_wc_t, uchar *s, uchar *e)=
to_cs->cset->wc_mb;
my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
uint error_count= 0;
while (1)

39
sql/table.cc
View file

@ -51,11 +51,13 @@ inline bool is_system_table_name(const char *name, uint length);
Object_creation_ctx *Object_creation_ctx::set_n_backup(THD *thd)
{
Object_creation_ctx *backup_ctx= create_backup_ctx(thd);
Object_creation_ctx *backup_ctx;
DBUG_ENTER("Object_creation_ctx::set_n_backup");
backup_ctx= create_backup_ctx(thd);
change_env(thd);
return backup_ctx;
DBUG_RETURN(backup_ctx);
}
void Object_creation_ctx::restore_env(THD *thd, Object_creation_ctx *backup_ctx)
@ -84,7 +86,7 @@ Default_object_creation_ctx::Default_object_creation_ctx(
{ }
Object_creation_ctx *
Default_object_creation_ctx::create_backup_ctx(THD *thd)
Default_object_creation_ctx::create_backup_ctx(THD *thd) const
{
return new Default_object_creation_ctx(thd);
}
@ -703,7 +705,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
if (!head[32]) // New frm file in 3.23
{
share->avg_row_length= uint4korr(head+34);
share-> row_type= (row_type) head[40];
share->transactional= (ha_choice) head[39];
share->row_type= (row_type) head[40];
share->table_charset= get_charset((uint) head[38],MYF(0));
share->null_field_first= 1;
}
@ -2433,6 +2436,7 @@ File create_frm(THD *thd, const char *name, const char *db,
int4store(fileinfo+34,create_info->avg_row_length);
fileinfo[38]= (create_info->default_table_charset ?
create_info->default_table_charset->number : 0);
fileinfo[39]= (uchar) create_info->transactional;
fileinfo[40]= (uchar) create_info->row_type;
/* Next few bytes were for RAID support */
fileinfo[41]= 0;
@ -2484,6 +2488,7 @@ void update_create_info_from_table(HA_CREATE_INFO *create_info, TABLE *table)
create_info->row_type= share->row_type;
create_info->default_table_charset= share->table_charset;
create_info->table_charset= 0;
create_info->comment= share->comment;
DBUG_VOID_RETURN;
}
@ -4564,11 +4569,11 @@ Item_subselect *TABLE_LIST::containing_subselect()
FALSE no errors found
TRUE found and reported an error.
*/
bool TABLE_LIST::process_index_hints(TABLE *table)
bool TABLE_LIST::process_index_hints(TABLE *tbl)
{
/* initialize the result variables */
table->keys_in_use_for_query= table->keys_in_use_for_group_by=
table->keys_in_use_for_order_by= table->s->keys_in_use;
tbl->keys_in_use_for_query= tbl->keys_in_use_for_group_by=
tbl->keys_in_use_for_order_by= tbl->s->keys_in_use;
/* index hint list processing */
if (index_hints)
@ -4620,8 +4625,8 @@ bool TABLE_LIST::process_index_hints(TABLE *table)
Check if an index with the given name exists and get his offset in
the keys bitmask for the table
*/
if (table->s->keynames.type_names == 0 ||
(pos= find_type(&table->s->keynames, hint->key_name.str,
if (tbl->s->keynames.type_names == 0 ||
(pos= find_type(&tbl->s->keynames, hint->key_name.str,
hint->key_name.length, 1)) <= 0)
{
my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), hint->key_name.str, alias);
@ -4657,7 +4662,7 @@ bool TABLE_LIST::process_index_hints(TABLE *table)
!index_order[INDEX_HINT_FORCE].is_clear_all() ||
!index_group[INDEX_HINT_FORCE].is_clear_all())
{
table->force_index= TRUE;
tbl->force_index= TRUE;
index_join[INDEX_HINT_USE].merge(index_join[INDEX_HINT_FORCE]);
index_order[INDEX_HINT_USE].merge(index_order[INDEX_HINT_FORCE]);
index_group[INDEX_HINT_USE].merge(index_group[INDEX_HINT_FORCE]);
@ -4665,20 +4670,20 @@ bool TABLE_LIST::process_index_hints(TABLE *table)
/* apply USE INDEX */
if (!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join)
table->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);
tbl->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);
if (!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order)
table->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);
tbl->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);
if (!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group)
table->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);
tbl->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);
/* apply IGNORE INDEX */
table->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);
table->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);
table->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);
tbl->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);
tbl->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);
tbl->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);
}
/* make sure covering_keys don't include indexes disabled with a hint */
table->covering_keys.intersect(table->keys_in_use_for_query);
tbl->covering_keys.intersect(tbl->keys_in_use_for_query);
return 0;
}

1
sql/table.h
View file

@ -310,6 +310,7 @@ typedef struct st_table_share
}
enum row_type row_type; /* How rows are stored */
enum tmp_table_type tmp_table;
enum ha_choice transactional;
uint ref_count; /* How many TABLE objects uses this */
uint open_count; /* Number of tables in open list */

16
sql/tztime.cc
View file

@ -1854,8 +1854,8 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
*/
(void)table->file->ha_index_init(0, 1);
if (table->file->index_read(table->record[0], table->field[0]->ptr,
HA_WHOLE_KEY, HA_READ_KEY_EXACT))
if (table->file->index_read_map(table->record[0], table->field[0]->ptr,
HA_WHOLE_KEY, HA_READ_KEY_EXACT))
{
#ifdef EXTRA_DEBUG
/*
@ -1881,8 +1881,8 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
table->field[0]->store((longlong) tzid, TRUE);
(void)table->file->ha_index_init(0, 1);
if (table->file->index_read(table->record[0], table->field[0]->ptr,
HA_WHOLE_KEY, HA_READ_KEY_EXACT))
if (table->file->index_read_map(table->record[0], table->field[0]->ptr,
HA_WHOLE_KEY, HA_READ_KEY_EXACT))
{
sql_print_error("Can't find description of time zone '%u'", tzid);
goto end;
@ -1908,8 +1908,8 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
table->field[0]->store((longlong) tzid, TRUE);
(void)table->file->ha_index_init(0, 1);
res= table->file->index_read(table->record[0], table->field[0]->ptr,
(key_part_map)1, HA_READ_KEY_EXACT);
res= table->file->index_read_map(table->record[0], table->field[0]->ptr,
(key_part_map)1, HA_READ_KEY_EXACT);
while (!res)
{
ttid= (uint)table->field[1]->val_int();
@ -1979,8 +1979,8 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
table->field[0]->store((longlong) tzid, TRUE);
(void)table->file->ha_index_init(0, 1);
res= table->file->index_read(table->record[0], table->field[0]->ptr,
(key_part_map)1, HA_READ_KEY_EXACT);
res= table->file->index_read_map(table->record[0], table->field[0]->ptr,
(key_part_map)1, HA_READ_KEY_EXACT);
while (!res)
{
ttime= (my_time_t)table->field[1]->val_int();

2
storage/archive/archive_reader.c
View file

@ -263,7 +263,7 @@ int main(int argc, char *argv[])
frm_file= my_open(argv[1], O_CREAT|O_RDWR|O_BINARY, MYF(0));
ptr= (char *)my_malloc(sizeof(char) * reader_handle.frm_length, MYF(0));
azread_frm(&reader_handle, ptr);
my_write(frm_file, ptr, reader_handle.frm_length, MYF(0));
my_write(frm_file, (uchar*) ptr, reader_handle.frm_length, MYF(0));
my_close(frm_file, MYF(0));
my_free(ptr, MYF(0));
}

13
storage/archive/azio.c
View file

@ -190,7 +190,8 @@ void write_header(azio_stream *s)
*(ptr + AZ_DIRTY_POS)= (unsigned char)s->dirty; /* Start of Data Block Index Block */
/* Always begin at the begining, and end there as well */
my_pwrite(s->file, buffer, AZHEADER_SIZE + AZMETA_BUFFER_SIZE, 0, MYF(0));
my_pwrite(s->file, (uchar*) buffer, AZHEADER_SIZE + AZMETA_BUFFER_SIZE, 0,
MYF(0));
}
/* ===========================================================================
@ -821,7 +822,7 @@ int azwrite_frm(azio_stream *s, char *blob, unsigned int length)
s->frm_length= length;
s->start+= length;
my_pwrite(s->file, blob, s->frm_length, s->frm_start_pos, MYF(0));
my_pwrite(s->file, (uchar*) blob, s->frm_length, s->frm_start_pos, MYF(0));
write_header(s);
my_seek(s->file, 0, MY_SEEK_END, MYF(0));
@ -831,7 +832,7 @@ int azwrite_frm(azio_stream *s, char *blob, unsigned int length)
int azread_frm(azio_stream *s, char *blob)
{
my_pread(s->file, blob, s->frm_length, s->frm_start_pos, MYF(0));
my_pread(s->file, (uchar*) blob, s->frm_length, s->frm_start_pos, MYF(0));
return 0;
}
@ -852,7 +853,8 @@ int azwrite_comment(azio_stream *s, char *blob, unsigned int length)
s->comment_length= length;
s->start+= length;
my_pwrite(s->file, blob, s->comment_length, s->comment_start_pos, MYF(0));
my_pwrite(s->file, (uchar*) blob, s->comment_length, s->comment_start_pos,
MYF(0));
write_header(s);
my_seek(s->file, 0, MY_SEEK_END, MYF(0));
@ -862,7 +864,8 @@ int azwrite_comment(azio_stream *s, char *blob, unsigned int length)
int azread_comment(azio_stream *s, char *blob)
{
my_pread(s->file, blob, s->comment_length, s->comment_start_pos, MYF(0));
my_pread(s->file, (uchar*) blob, s->comment_length, s->comment_start_pos,
MYF(0));
return 0;
}

10
storage/blackhole/ha_blackhole.cc
View file

@ -184,8 +184,8 @@ THR_LOCK_DATA **ha_blackhole::store_lock(THD *thd,
}
int ha_blackhole::index_read(uchar * buf, const uchar * key,
key_part_map keypart_map,
int ha_blackhole::index_read_map(uchar * buf, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
{
DBUG_ENTER("ha_blackhole::index_read");
@ -193,7 +193,7 @@ int ha_blackhole::index_read(uchar * buf, const uchar * key,
}
int ha_blackhole::index_read_idx(uchar * buf, uint idx, const uchar * key,
int ha_blackhole::index_read_idx_map(uchar * buf, uint idx, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
{
@ -202,8 +202,8 @@ int ha_blackhole::index_read_idx(uchar * buf, uint idx, const uchar * key,
}
int ha_blackhole::index_read_last(uchar * buf, const uchar * key,
key_part_map keypart_map)
int ha_blackhole::index_read_last_map(uchar * buf, const uchar * key,
key_part_map keypart_map)
{
DBUG_ENTER("ha_blackhole::index_read_last");
DBUG_RETURN(HA_ERR_END_OF_FILE);

11
storage/blackhole/ha_blackhole.h
View file

@ -76,11 +76,12 @@ public:
int rnd_init(bool scan);
int rnd_next(uchar *buf);
int rnd_pos(uchar * buf, uchar *pos);
int index_read(uchar * buf, const uchar * key, key_part_map keypart_map,
enum ha_rkey_function find_flag);
int index_read_idx(uchar * buf, uint idx, const uchar * key,
key_part_map keypart_map, enum ha_rkey_function find_flag);
int index_read_last(uchar * buf, const uchar * key, key_part_map keypart_map);
int index_read_map(uchar * buf, const uchar * key, key_part_map keypart_map,
enum ha_rkey_function find_flag);
int index_read_idx_map(uchar * buf, uint idx, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag);
int index_read_last_map(uchar * buf, const uchar * key, key_part_map keypart_map);
int index_next(uchar * buf);
int index_prev(uchar * buf);
int index_first(uchar * buf);

4
storage/csv/ha_tina.cc
View file

@ -68,6 +68,10 @@ static int free_share(TINA_SHARE *share);
static int read_meta_file(File meta_file, ha_rows *rows);
static int write_meta_file(File meta_file, ha_rows rows, bool dirty);
extern "C" void tina_get_status(void* param, int concurrent_insert);
extern "C" void tina_update_status(void* param);
extern "C" my_bool tina_check_status(void* param);
/* Stuff for shares */
pthread_mutex_t tina_mutex;
static HASH tina_open_tables;

8
storage/example/ha_example.cc
View file

@ -420,10 +420,10 @@ int ha_example::delete_row(const uchar *buf)
index.
*/
int ha_example::index_read(uchar *buf, const uchar *key,
key_part_map keypart_map __attribute__((unused)),
enum ha_rkey_function find_flag
__attribute__((unused)))
int ha_example::index_read_map(uchar *buf, const uchar *key,
key_part_map keypart_map __attribute__((unused)),
enum ha_rkey_function find_flag
__attribute__((unused)))
{
DBUG_ENTER("ha_example::index_read");
DBUG_RETURN(HA_ERR_WRONG_COMMAND);

4
storage/example/ha_example.h
View file

@ -195,8 +195,8 @@ public:
We implement this in ha_example.cc. It's not an obligatory method;
skip it and and MySQL will treat it as not implemented.
*/
int index_read(uchar *buf, const uchar *key,
key_part_map keypart_map, enum ha_rkey_function find_flag);
int index_read_map(uchar *buf, const uchar *key,
key_part_map keypart_map, enum ha_rkey_function find_flag);
/** @brief
We implement this in ha_example.cc. It's not an obligatory method;

14
storage/heap/ha_heap.cc
View file

@ -270,8 +270,9 @@ int ha_heap::delete_row(const uchar * buf)
return res;
}
int ha_heap::index_read(uchar * buf, const uchar * key, key_part_map keypart_map,
enum ha_rkey_function find_flag)
int ha_heap::index_read_map(uchar *buf, const uchar *key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
{
DBUG_ASSERT(inited==INDEX);
ha_statistic_increment(&SSV::ha_read_key_count);
@ -280,7 +281,8 @@ int ha_heap::index_read(uchar * buf, const uchar * key, key_part_map keypart_map
return error;
}
int ha_heap::index_read_last(uchar *buf, const uchar *key, key_part_map keypart_map)
int ha_heap::index_read_last_map(uchar *buf, const uchar *key,
key_part_map keypart_map)
{
DBUG_ASSERT(inited==INDEX);
ha_statistic_increment(&SSV::ha_read_key_count);
@ -290,9 +292,9 @@ int ha_heap::index_read_last(uchar *buf, const uchar *key, key_part_map keypart_
return error;
}
int ha_heap::index_read_idx(uchar * buf, uint index, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
int ha_heap::index_read_idx_map(uchar *buf, uint index, const uchar *key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
{
ha_statistic_increment(&SSV::ha_read_key_count);
int error = heap_rkey(file, buf, index, key, keypart_map, find_flag);

11
storage/heap/ha_heap.h
View file

@ -79,11 +79,12 @@ public:
ulonglong nb_desired_values,
ulonglong *first_value,
ulonglong *nb_reserved_values);
int index_read(uchar * buf, const uchar * key, key_part_map keypart_map,
enum ha_rkey_function find_flag);
int index_read_last(uchar *buf, const uchar *key, key_part_map keypart_map);
int index_read_idx(uchar * buf, uint index, const uchar * key,
key_part_map keypart_map, enum ha_rkey_function find_flag);
int index_read_map(uchar * buf, const uchar * key, key_part_map keypart_map,
enum ha_rkey_function find_flag);
int index_read_last_map(uchar *buf, const uchar *key, key_part_map keypart_map);
int index_read_idx_map(uchar * buf, uint index, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag);
int index_next(uchar * buf);
int index_prev(uchar * buf);
int index_first(uchar * buf);

18
storage/heap/hp_test1.c
View file

@ -32,7 +32,7 @@ int main(int argc, char **argv)
{
int i,j,error,deleted;
HP_INFO *file;
char record[128],key[32];
uchar record[128],key[32];
const char *filename;
HP_KEYDEF keyinfo[10];
HA_KEYSEG keyseg[4];
@ -65,12 +65,12 @@ int main(int argc, char **argv)
!(file= heap_open(filename, 2)))
goto err;
printf("- Writing records:s\n");
strmov(record," ..... key ");
strmov((char*) record," ..... key ");
for (i=49 ; i>=1 ; i-=2 )
{
j=i%25 +1;
sprintf(key,"%6d",j);
sprintf((char*) key,"%6d",j);
bmove(record+1,key,6);
error=heap_write(file,record);
if (heap_check_heap(file,0))
@ -92,18 +92,18 @@ int main(int argc, char **argv)
for (i=1 ; i<=10 ; i++)
{
if (i == remove_ant) { VOID(heap_close(file)) ; return (0) ; }
sprintf(key,"%6d",(j=(int) ((rand() & 32767)/32767.*25)));
sprintf((char*) key,"%6d",(j=(int) ((rand() & 32767)/32767.*25)));
if ((error = heap_rkey(file,record,0,key,6,HA_READ_KEY_EXACT)))
{
if (verbose || (flags[j] == 1 ||
(error && my_errno != HA_ERR_KEY_NOT_FOUND)))
printf("key: %s rkey: %3d my_errno: %3d\n",key,error,my_errno);
printf("key: %s rkey: %3d my_errno: %3d\n",(char*) key,error,my_errno);
}
else
{
error=heap_delete(file,record);
if (error || verbose)
printf("key: %s delete: %d my_errno: %d\n",key,error,my_errno);
printf("key: %s delete: %d my_errno: %d\n",(char*) key,error,my_errno);
flags[j]=0;
if (! error)
deleted++;
@ -118,7 +118,7 @@ int main(int argc, char **argv)
printf("- Reading records with key\n");
for (i=1 ; i<=25 ; i++)
{
sprintf(key,"%6d",i);
sprintf((char*) key,"%6d",i);
bmove(record+1,key,6);
my_errno=0;
error=heap_rkey(file,record,0,key,6,HA_READ_KEY_EXACT);
@ -127,7 +127,7 @@ int main(int argc, char **argv)
(error && (flags[i] != 0 || my_errno != HA_ERR_KEY_NOT_FOUND)))
{
printf("key: %s rkey: %3d my_errno: %3d record: %s\n",
key,error,my_errno,record+1);
(char*) key,error,my_errno,record+1);
}
}
@ -150,7 +150,7 @@ int main(int argc, char **argv)
if (verbose || (error != 0 && error != HA_ERR_RECORD_DELETED))
{
printf("pos: %2d ni_rrnd: %3d my_errno: %3d record: %s\n",
i-1,error,my_errno,record+1);
i-1,error,my_errno,(char*) record+1);
}
}
}

Some files were not shown because too many files have changed in this diff Show more