merge
Docs/manual.texi: Auto merged
This commit is contained in:
commit
bfefbf8b3b
@ -22287,11 +22287,11 @@ The buffer that is allocated when sorting the index when doing a
|
||||
@code{ALTER TABLE}.
|
||||
|
||||
@item @code{myisam_bulk_insert_tree_size}
|
||||
@strong{MySQL} uses special tree-like cache to make bulk inserts (that is,
|
||||
@code{MyISAM} uses special tree-like cache to make bulk inserts (that is,
|
||||
@code{INSERT ... SELECT},
|
||||
@code{INSERT ... VALUES (...), (...), ...}, and
|
||||
@code{LOAD DATA INFILE}) faster. This variable limits
|
||||
the size of the cache tree in bytes @strong{per thread, per index}.
|
||||
the size of the cache tree in bytes @strong{per thread, per table}.
|
||||
Default value is 8 MB.
|
||||
|
||||
@item @code{myisam_max_extra_sort_file_size}.
|
||||
@ -24011,7 +24011,7 @@ The following options to @code{mysqld} can be used to change the behavior of
|
||||
@item @code{--delay-key-write-for-all-tables} @tab Don't flush key buffers between writes for any MyISAM table
|
||||
@item @code{-O myisam_max_extra_sort_file_size=#} @tab Used to help @strong{MySQL} to decide when to use the slow but safe key cache index create method. @strong{NOTE} that this parameter is given in megabytes!
|
||||
@item @code{-O myisam_max_sort_file_size=#} @tab Don't use the fast sort index method to created index if the temporary file would get bigger than this. @strong{NOTE} that this paramter is given in megabytes!
|
||||
@item @code{-O myisam_bulk_insert_tree_size=#} @tab Size of tree cache used in bulk insert optimization. @strong{NOTE} that this is a limit @strong{per index}!
|
||||
@item @code{-O myisam_bulk_insert_tree_size=#} @tab Size of tree cache used in bulk insert optimization. @strong{NOTE} that this is the total size used for all index in one table.
|
||||
@end multitable
|
||||
|
||||
The automatic recovery is activated if you start @code{mysqld} with
|
||||
|
@ -34,19 +34,13 @@ int main(int argc, char **argv)
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (!(sock = mysql_connect(&mysql,NULL,0,0)))
|
||||
if (!(sock = mysql_real_connect(&mysql,NULL,NULL,NULL,argv[1],0,NULL,0)))
|
||||
{
|
||||
fprintf(stderr,"Couldn't connect to engine!\n%s\n",mysql_error(&mysql));
|
||||
perror("");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (mysql_select_db(sock,argv[1]))
|
||||
{
|
||||
fprintf(stderr,"Couldn't select database %s!\n%s\n",argv[1],
|
||||
mysql_error(sock));
|
||||
}
|
||||
|
||||
num = atoi(argv[2]);
|
||||
count = 0;
|
||||
while (count < num)
|
||||
|
@ -126,24 +126,30 @@ typedef struct st_mysql_data {
|
||||
|
||||
struct st_mysql_options {
|
||||
unsigned int connect_timeout,client_flag;
|
||||
my_bool compress,named_pipe;
|
||||
my_bool rpl_probe; /* on connect, find out the replication
|
||||
role of the server, and establish connections
|
||||
to all the peers */
|
||||
my_bool rpl_parse; /* each call to mysql_real_query() will parse
|
||||
it to tell if it is a read or a write, and
|
||||
direct it to the slave or the master */
|
||||
my_bool no_master_reads; /* if set, never read from
|
||||
a master,only from slave, when doing
|
||||
a read that is replication-aware */
|
||||
unsigned int port;
|
||||
char *host,*init_command,*user,*password,*unix_socket,*db;
|
||||
char *my_cnf_file,*my_cnf_group, *charset_dir, *charset_name;
|
||||
my_bool use_ssl; /* if to use SSL or not */
|
||||
char *ssl_key; /* PEM key file */
|
||||
char *ssl_cert; /* PEM cert file */
|
||||
char *ssl_ca; /* PEM CA file */
|
||||
char *ssl_capath; /* PEM directory of CA-s? */
|
||||
my_bool use_ssl; /* if to use SSL or not */
|
||||
my_bool compress,named_pipe;
|
||||
/*
|
||||
on connect, find out the replication role of the server, and
|
||||
establish connections to all the peers
|
||||
*/
|
||||
my_bool rpl_probe;
|
||||
/*
|
||||
each call to mysql_real_query() will parse it to tell if it is a read
|
||||
or a write, and direct it to the slave or the master
|
||||
*/
|
||||
my_bool rpl_parse;
|
||||
/*
|
||||
if set, never read from a master,only from slave, when doing
|
||||
a read that is replication-aware
|
||||
*/
|
||||
my_bool no_master_reads;
|
||||
};
|
||||
|
||||
enum mysql_option { MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_COMPRESS,
|
||||
@ -154,7 +160,8 @@ enum mysql_option { MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_COMPRESS,
|
||||
enum mysql_status { MYSQL_STATUS_READY,MYSQL_STATUS_GET_RESULT,
|
||||
MYSQL_STATUS_USE_RESULT};
|
||||
|
||||
/* there are three types of queries - the ones that have to go to
|
||||
/*
|
||||
There are three types of queries - the ones that have to go to
|
||||
the master, the ones that go to a slave, and the adminstrative
|
||||
type which must happen on the pivot connectioin
|
||||
*/
|
||||
@ -191,15 +198,13 @@ typedef struct st_mysql {
|
||||
struct st_mysql* master, *next_slave;
|
||||
|
||||
struct st_mysql* last_used_slave; /* needed for round-robin slave pick */
|
||||
struct st_mysql* last_used_con; /* needed for send/read/store/use
|
||||
result to work
|
||||
correctly with replication
|
||||
*/
|
||||
my_bool rpl_pivot; /* set if this is the original connection,
|
||||
not a master or a slave we have added though
|
||||
mysql_rpl_probe() or mysql_set_master()/
|
||||
mysql_add_slave()
|
||||
/* needed for send/read/store/use result to work correctly with replication */
|
||||
struct st_mysql* last_used_con;
|
||||
/*
|
||||
Set if this is the original connection, not a master or a slave we have
|
||||
added though mysql_rpl_probe() or mysql_set_master()/ mysql_add_slave()
|
||||
*/
|
||||
my_bool rpl_pivot;
|
||||
} MYSQL;
|
||||
|
||||
|
||||
@ -246,11 +251,8 @@ int STDCALL mysql_ssl_set(MYSQL *mysql, const char *key,
|
||||
char * STDCALL mysql_ssl_cipher(MYSQL *mysql);
|
||||
int STDCALL mysql_ssl_clear(MYSQL *mysql);
|
||||
#endif /* HAVE_OPENSSL */
|
||||
MYSQL * STDCALL mysql_connect(MYSQL *mysql, const char *host,
|
||||
const char *user, const char *passwd);
|
||||
my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
|
||||
const char *passwd, const char *db);
|
||||
#if MYSQL_VERSION_ID >= 32200
|
||||
MYSQL * STDCALL mysql_real_connect(MYSQL *mysql, const char *host,
|
||||
const char *user,
|
||||
const char *passwd,
|
||||
@ -258,14 +260,6 @@ MYSQL * STDCALL mysql_real_connect(MYSQL *mysql, const char *host,
|
||||
unsigned int port,
|
||||
const char *unix_socket,
|
||||
unsigned int clientflag);
|
||||
#else
|
||||
MYSQL * STDCALL mysql_real_connect(MYSQL *mysql, const char *host,
|
||||
const char *user,
|
||||
const char *passwd,
|
||||
unsigned int port,
|
||||
const char *unix_socket,
|
||||
unsigned int clientflag);
|
||||
#endif
|
||||
void STDCALL mysql_close(MYSQL *sock);
|
||||
int STDCALL mysql_select_db(MYSQL *mysql, const char *db);
|
||||
int STDCALL mysql_query(MYSQL *mysql, const char *q);
|
||||
@ -285,8 +279,10 @@ int STDCALL mysql_slave_query(MYSQL *mysql, const char *q,
|
||||
int STDCALL mysql_slave_send_query(MYSQL *mysql, const char *q,
|
||||
unsigned int length);
|
||||
|
||||
/* enable/disable parsing of all queries to decide
|
||||
if they go on master or slave */
|
||||
/*
|
||||
enable/disable parsing of all queries to decide if they go on master or
|
||||
slave
|
||||
*/
|
||||
void STDCALL mysql_enable_rpl_parse(MYSQL* mysql);
|
||||
void STDCALL mysql_disable_rpl_parse(MYSQL* mysql);
|
||||
/* get the value of the parse flag */
|
||||
@ -313,9 +309,6 @@ int STDCALL mysql_add_slave(MYSQL* mysql, const char* host,
|
||||
const char* user,
|
||||
const char* passwd);
|
||||
|
||||
|
||||
int STDCALL mysql_create_db(MYSQL *mysql, const char *DB);
|
||||
int STDCALL mysql_drop_db(MYSQL *mysql, const char *DB);
|
||||
int STDCALL mysql_shutdown(MYSQL *mysql);
|
||||
int STDCALL mysql_dump_debug_info(MYSQL *mysql);
|
||||
int STDCALL mysql_refresh(MYSQL *mysql,
|
||||
@ -364,9 +357,15 @@ char * STDCALL mysql_odbc_escape_string(MYSQL *mysql,
|
||||
void STDCALL myodbc_remove_escape(MYSQL *mysql,char *name);
|
||||
unsigned int STDCALL mysql_thread_safe(void);
|
||||
|
||||
|
||||
#define mysql_reload(mysql) mysql_refresh((mysql),REFRESH_GRANT)
|
||||
|
||||
#ifndef USE_OLD_FUNCTIONS
|
||||
MYSQL * STDCALL mysql_connect(MYSQL *mysql, const char *host,
|
||||
const char *user, const char *passwd);
|
||||
int STDCALL mysql_create_db(MYSQL *mysql, const char *DB);
|
||||
int STDCALL mysql_drop_db(MYSQL *mysql, const char *DB);
|
||||
#endif
|
||||
|
||||
/* new api functions */
|
||||
|
||||
#define HAVE_MYSQL_REAL_CONNECT
|
||||
|
@ -212,6 +212,5 @@
|
||||
#define ER_CREATE_DB_WITH_READ_LOCK 1209
|
||||
#define ER_CONNECT_TO_MASTER 1210
|
||||
#define ER_QUERY_ON_MASTER 1211
|
||||
#define ER_SHOW_BINLOG_EVENTS 1212
|
||||
#define ER_SHOW_NEW_MASTER 1213
|
||||
#define ER_ERROR_MESSAGES 214
|
||||
#define ER_ERROR_WHEN_EXECUTING_COMMAND 1212
|
||||
#define ER_ERROR_MESSAGES 213
|
||||
|
@ -770,8 +770,9 @@ int _mi_init_bulk_insert(MI_INFO *info)
|
||||
if (info->bulk_insert)
|
||||
return 0;
|
||||
|
||||
info->bulk_insert=(TREE *)my_malloc(
|
||||
(sizeof(TREE)+sizeof(bulk_insert_param))*share->base.keys, MYF(0));
|
||||
info->bulk_insert=(TREE *)
|
||||
my_malloc((sizeof(TREE)+sizeof(bulk_insert_param))*share->base.keys,
|
||||
MYF(0));
|
||||
|
||||
if (!info->bulk_insert)
|
||||
return HA_ERR_OUT_OF_MEM;
|
||||
@ -785,7 +786,8 @@ int _mi_init_bulk_insert(MI_INFO *info)
|
||||
if (!(key->flag & HA_NOSAME) && share->base.auto_key != i+1
|
||||
&& test(share->state.key_map & ((ulonglong) 1 << i)))
|
||||
{
|
||||
init_tree(& info->bulk_insert[i], 0, myisam_bulk_insert_tree_size, 0,
|
||||
init_tree(& info->bulk_insert[i], 0,
|
||||
myisam_bulk_insert_tree_size / share->base.keys, 0,
|
||||
(qsort_cmp2)keys_compare, 0,
|
||||
(tree_element_free) keys_free, (void *)params);
|
||||
}
|
||||
|
@ -21,7 +21,7 @@ drop table t1;
|
||||
#
|
||||
--error 1064
|
||||
select x'hello';
|
||||
--error 1064
|
||||
--error 1054
|
||||
select 0xfg;
|
||||
|
||||
#
|
||||
|
@ -97,6 +97,7 @@ void init_tree(TREE *tree, uint default_alloc_size, uint memory_limit,
|
||||
DBUG_ENTER("init_tree");
|
||||
DBUG_PRINT("enter",("tree: %lx size: %d",tree,size));
|
||||
|
||||
if (!default_alloc_size)
|
||||
default_alloc_size= DEFAULT_ALLOC_SIZE;
|
||||
bzero((gptr) &tree->null_element,sizeof(tree->null_element));
|
||||
tree->root= &tree->null_element;
|
||||
|
@ -86,11 +86,10 @@ ha_rows filesort(TABLE *table, SORT_FIELD *sortorder, uint s_length,
|
||||
my_b_clear(&tempfile);
|
||||
buffpek= (BUFFPEK *) NULL; sort_keys= (uchar **) NULL; error= 1;
|
||||
maxbuffer=1;
|
||||
bzero((char*) ¶m,sizeof(param));
|
||||
param.ref_length= table->file->ref_length;
|
||||
param.sort_length=sortlength(sortorder,s_length)+ param.ref_length;
|
||||
param.max_rows= max_rows;
|
||||
param.examined_rows=0;
|
||||
param.unique_buff=0;
|
||||
|
||||
if (select && select->quick)
|
||||
{
|
||||
@ -686,9 +685,16 @@ int merge_buffers(SORTPARAM *param, IO_CACHE *from_file,
|
||||
BUFFPEK *buffpek,**refpek;
|
||||
QUEUE queue;
|
||||
qsort2_cmp cmp;
|
||||
volatile bool *killed= ¤t_thd->killed;
|
||||
bool not_killable;
|
||||
DBUG_ENTER("merge_buffers");
|
||||
|
||||
statistic_increment(filesort_merge_passes, &LOCK_status);
|
||||
if (param->not_killable)
|
||||
{
|
||||
killed= ¬_killable;
|
||||
not_killable=0;
|
||||
}
|
||||
|
||||
error=0;
|
||||
offset=(sort_length=param->sort_length)-param->ref_length;
|
||||
@ -738,6 +744,10 @@ int merge_buffers(SORTPARAM *param, IO_CACHE *from_file,
|
||||
|
||||
while (queue.elements > 1)
|
||||
{
|
||||
if (*killed)
|
||||
{
|
||||
error=1; goto err; /* purecov: inspected */
|
||||
}
|
||||
for (;;)
|
||||
{
|
||||
buffpek=(BUFFPEK*) queue_top(&queue);
|
||||
|
@ -245,9 +245,9 @@ public:
|
||||
int get_data_size()
|
||||
{
|
||||
return q_len + db_len + 2 +
|
||||
sizeof(uint32) // thread_id
|
||||
+ sizeof(uint32) // exec_time
|
||||
+ sizeof(uint16) // error_code
|
||||
4 // thread_id
|
||||
+ 4 // exec_time
|
||||
+ 2 // error_code
|
||||
;
|
||||
}
|
||||
|
||||
|
@ -222,5 +222,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -216,5 +216,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -213,5 +213,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -213,5 +213,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -217,5 +217,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -213,5 +213,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -216,5 +216,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -213,5 +213,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -215,5 +215,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -213,5 +213,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -215,5 +215,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -213,5 +213,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -215,5 +215,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -215,5 +215,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -217,5 +217,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -213,5 +213,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -217,5 +217,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -216,5 +216,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -221,5 +221,4 @@
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"Error when executing command %s: %-.128s",
|
||||
|
@ -214,5 +214,4 @@
|
||||
"CREATE DATABASE no permitido mientras un thread está ejerciendo un bloqueo de lectura global",
|
||||
"Error de coneccion a master: %-128s",
|
||||
"Error executando el query en master: %-128%",
|
||||
"Error de SHOW BINLOG EVENTS: %-128%",
|
||||
"Error de SHOW NEW MASTER: %-128%",
|
||||
"Error de %s: %-128%",
|
||||
|
@ -209,9 +209,8 @@
|
||||
"Lock wait timeout exceeded",
|
||||
"The total number of locks exceeds the lock table size",
|
||||
"Update locks cannot be acquired during a READ UNCOMMITTED transaction",
|
||||
"DROP DATABASE not allowed while thread is holding global read lock",
|
||||
"CREATE DATABASE not allowed while thread is holding global read lock",
|
||||
"Error connecting to master: %-.128s",
|
||||
"Error running query on master: %-.128s",
|
||||
"Error in SHOW BINLOG EVENTS: %-.128s",
|
||||
"Error in SHOW NEW MASTER: %-.128s",
|
||||
"DROP DATABASE är inte tillåtet när man har ett globalt läs-lås",
|
||||
"CREATE DATABASE är inte tillåtet när man har ett globalt läs-lås",
|
||||
"Fick fel vid anslutning till master: %-.128s",
|
||||
"Fick fel vid utförande av command på mastern: %-.128s",
|
||||
"Fick fel vid utförande av %s: %-.128s",
|
||||
|
@ -421,7 +421,7 @@ public:
|
||||
virtual int prepare(List<Item> &list) { return 0; }
|
||||
virtual bool send_fields(List<Item> &list,uint flag)=0;
|
||||
virtual bool send_data(List<Item> &items)=0;
|
||||
virtual void initialize_tables (JOIN *join=0) {};
|
||||
virtual void initialize_tables (JOIN *join=0) {}
|
||||
virtual void send_error(uint errcode,const char *err)=0;
|
||||
virtual bool send_eof()=0;
|
||||
virtual void abort() {}
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB & Sinisa
|
||||
/* Copyright (C) 2000 MySQL AB
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
@ -316,8 +316,8 @@ multi_delete::multi_delete(THD *thd_arg, TABLE_LIST *dt,
|
||||
#endif
|
||||
|
||||
(void) dt->table->file->extra(HA_EXTRA_NO_READCHECK);
|
||||
(void) dt->table->file->extra(HA_EXTRA_NO_KEYREAD);
|
||||
/* Don't use key read with MULTI-TABLE-DELETE */
|
||||
(void) dt->table->file->extra(HA_EXTRA_NO_KEYREAD);
|
||||
dt->table->used_keys=0;
|
||||
for (dt=dt->next ; dt ; dt=dt->next,counter++)
|
||||
{
|
||||
@ -366,50 +366,38 @@ multi_delete::prepare(List<Item> &values)
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
||||
inline static void
|
||||
link_in_list(SQL_LIST *list,byte *element,byte **next)
|
||||
{
|
||||
list->elements++;
|
||||
(*list->next)=element;
|
||||
list->next=next;
|
||||
*next=0;
|
||||
}
|
||||
|
||||
void
|
||||
multi_delete::initialize_tables(JOIN *join)
|
||||
{
|
||||
SQL_LIST *new_list=(SQL_LIST *) sql_alloc(sizeof(SQL_LIST));
|
||||
new_list->elements=0; new_list->first=0;
|
||||
new_list->next= (byte**) &(new_list->first);
|
||||
TABLE_LIST *walk;
|
||||
table_map tables_to_delete_from=0;
|
||||
for (walk= delete_tables ; walk ; walk=walk->next)
|
||||
tables_to_delete_from|= walk->table->map;
|
||||
|
||||
walk= delete_tables;
|
||||
for (JOIN_TAB *tab=join->join_tab, *end=join->join_tab+join->tables;
|
||||
tab < end;
|
||||
tab++)
|
||||
{
|
||||
TABLE_LIST *walk;
|
||||
for (walk=(TABLE_LIST*) delete_tables ; walk ; walk=walk->next)
|
||||
if (!strcmp(tab->table->path,walk->table->path))
|
||||
break;
|
||||
if (walk) // Table need not be the one to be deleted
|
||||
if (tab->table->map & tables_to_delete_from)
|
||||
{
|
||||
register TABLE_LIST *ptr = (TABLE_LIST *) sql_alloc(sizeof(TABLE_LIST));
|
||||
memcpy(ptr,walk,sizeof(TABLE_LIST)); ptr->next=0;
|
||||
link_in_list(new_list,(byte*) ptr,(byte**) &ptr->next);
|
||||
/* We are going to delete from this table */
|
||||
walk->table=tab->table;
|
||||
walk=walk->next;
|
||||
}
|
||||
}
|
||||
delete_tables=(TABLE_LIST *)new_list->first;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
multi_delete::~multi_delete()
|
||||
{
|
||||
|
||||
/* Add back EXTRA_READCHECK; In 4.0.1 we shouldn't need this anymore */
|
||||
for (table_being_deleted=delete_tables ;
|
||||
table_being_deleted ;
|
||||
table_being_deleted=table_being_deleted->next)
|
||||
{
|
||||
VOID(table_being_deleted->table->file->extra(HA_EXTRA_READCHECK));
|
||||
}
|
||||
(void) table_being_deleted->table->file->extra(HA_EXTRA_READCHECK);
|
||||
|
||||
for (uint counter = 0; counter < num_of_tables-1; counter++)
|
||||
{
|
||||
if (tempfiles[counter])
|
||||
|
262
sql/sql_repl.cc
262
sql/sql_repl.cc
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
|
||||
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB & Sasha
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
@ -76,13 +76,8 @@ static int fake_rotate_event(NET* net, String* packet, char* log_file_name,
|
||||
char header[LOG_EVENT_HEADER_LEN], buf[ROTATE_HEADER_LEN];
|
||||
memset(header, 0, 4); // when does not matter
|
||||
header[EVENT_TYPE_OFFSET] = ROTATE_EVENT;
|
||||
char* p = strrchr(log_file_name, FN_LIBCHAR);
|
||||
// find the last slash
|
||||
if(p)
|
||||
p++;
|
||||
else
|
||||
p = log_file_name;
|
||||
|
||||
char* p = log_file_name+dirname_length(log_file_name);
|
||||
uint ident_len = (uint) strlen(p);
|
||||
ulong event_len = ident_len + ROTATE_EVENT_OVERHEAD;
|
||||
int4store(header + SERVER_ID_OFFSET, server_id);
|
||||
@ -101,6 +96,16 @@ static int fake_rotate_event(NET* net, String* packet, char* log_file_name,
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define get_object(p, obj) \
|
||||
{\
|
||||
uint len = (uint)*p++; \
|
||||
if (p + len > p_end || len >= sizeof(obj)) \
|
||||
goto err; \
|
||||
strmake(obj,(char*) p,len); \
|
||||
p+= len; \
|
||||
}\
|
||||
|
||||
|
||||
int register_slave(THD* thd, uchar* packet, uint packet_length)
|
||||
{
|
||||
uint len;
|
||||
@ -116,24 +121,9 @@ int register_slave(THD* thd, uchar* packet, uint packet_length)
|
||||
|
||||
si->server_id = uint4korr(p);
|
||||
p += 4;
|
||||
len = (uint)*p++;
|
||||
if(p + len > p_end || len > sizeof(si->host) - 1)
|
||||
goto err;
|
||||
memcpy(si->host, p, len);
|
||||
si->host[len] = 0;
|
||||
p += len;
|
||||
len = *p++;
|
||||
if(p + len > p_end || len > sizeof(si->user) - 1)
|
||||
goto err;
|
||||
memcpy(si->user, p, len);
|
||||
si->user[len] = 0;
|
||||
p += len;
|
||||
len = *p++;
|
||||
if(p + len > p_end || len > sizeof(si->password) - 1)
|
||||
goto err;
|
||||
memcpy(si->password, p, len);
|
||||
si->password[len] = 0;
|
||||
p += len;
|
||||
get_object(p,si->host);
|
||||
get_object(p,si->user);
|
||||
get_object(p,si->password);
|
||||
si->port = uint2korr(p);
|
||||
pthread_mutex_lock(&LOCK_slave_list);
|
||||
|
||||
@ -144,6 +134,7 @@ int register_slave(THD* thd, uchar* packet, uint packet_length)
|
||||
res = hash_insert(&slave_list, (byte*) si);
|
||||
pthread_mutex_unlock(&LOCK_slave_list);
|
||||
return res;
|
||||
|
||||
err:
|
||||
if (si)
|
||||
my_free((byte*)si, MYF(MY_WME));
|
||||
@ -156,10 +147,10 @@ static int send_file(THD *thd)
|
||||
NET* net = &thd->net;
|
||||
int fd = -1,bytes, error = 1;
|
||||
char fname[FN_REFLEN+1];
|
||||
char *buf;
|
||||
const char *errmsg = 0;
|
||||
int old_timeout;
|
||||
uint packet_len;
|
||||
char buf[IO_SIZE]; // It's safe to alloc this
|
||||
DBUG_ENTER("send_file");
|
||||
|
||||
// the client might be slow loading the data, give him wait_timeout to do
|
||||
@ -167,40 +158,32 @@ static int send_file(THD *thd)
|
||||
old_timeout = thd->net.timeout;
|
||||
thd->net.timeout = thd->inactive_timeout;
|
||||
|
||||
// spare the stack
|
||||
if(!(buf = alloc_root(&thd->mem_root,IO_SIZE)))
|
||||
{
|
||||
errmsg = "Out of memory";
|
||||
goto err;
|
||||
}
|
||||
|
||||
// we need net_flush here because the client will not know it needs to send
|
||||
// us the file name until it has processed the load event entry
|
||||
if (net_flush(net) || (packet_len = my_net_read(net)) == packet_error)
|
||||
{
|
||||
errmsg = "Failed reading file name";
|
||||
errmsg = "while reading file name";
|
||||
goto err;
|
||||
}
|
||||
|
||||
*((char*)net->read_pos + packet_len) = 0; // terminate with \0
|
||||
//for fn_format
|
||||
// terminate with \0 for fn_format
|
||||
*((char*)net->read_pos + packet_len) = 0;
|
||||
fn_format(fname, (char*) net->read_pos + 1, "", "", 4);
|
||||
// this is needed to make replicate-ignore-db
|
||||
if (!strcmp(fname,"/dev/null"))
|
||||
goto end;
|
||||
|
||||
if ((fd = my_open(fname, O_RDONLY, MYF(MY_WME))) < 0)
|
||||
if ((fd = my_open(fname, O_RDONLY, MYF(0))) < 0)
|
||||
{
|
||||
errmsg = "Failed on my_open()";
|
||||
errmsg = "on open of file";
|
||||
goto err;
|
||||
}
|
||||
|
||||
while ((bytes = (int) my_read(fd, (byte*) buf, IO_SIZE,
|
||||
MYF(MY_WME))) > 0)
|
||||
while ((bytes = (int) my_read(fd, (byte*) buf, IO_SIZE, MYF(0))) > 0)
|
||||
{
|
||||
if (my_net_write(net, buf, bytes))
|
||||
{
|
||||
errmsg = "Failed on my_net_write()";
|
||||
errmsg = "while writing data to client";
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
@ -209,7 +192,7 @@ static int send_file(THD *thd)
|
||||
if (my_net_write(net, "", 0) || net_flush(net) ||
|
||||
(my_net_read(net) == packet_error))
|
||||
{
|
||||
errmsg = "failed negotiating file transfer close";
|
||||
errmsg = "while negotiating file transfer close";
|
||||
goto err;
|
||||
}
|
||||
error = 0;
|
||||
@ -217,10 +200,10 @@ static int send_file(THD *thd)
|
||||
err:
|
||||
thd->net.timeout = old_timeout;
|
||||
if (fd >= 0)
|
||||
(void) my_close(fd, MYF(MY_WME));
|
||||
(void) my_close(fd, MYF(0));
|
||||
if (errmsg)
|
||||
{
|
||||
sql_print_error("failed in send_file() : %s", errmsg);
|
||||
sql_print_error("Failed in send_file() %s", errmsg);
|
||||
DBUG_PRINT("error", (errmsg));
|
||||
}
|
||||
DBUG_RETURN(error);
|
||||
@ -232,6 +215,7 @@ File open_binlog(IO_CACHE *log, const char *log_file_name,
|
||||
{
|
||||
File file;
|
||||
char magic[4];
|
||||
|
||||
if ((file = my_open(log_file_name, O_RDONLY | O_BINARY, MYF(MY_WME))) < 0 ||
|
||||
init_io_cache(log, file, IO_SIZE*2, READ_CACHE, 0, 0,
|
||||
MYF(MY_WME)))
|
||||
@ -242,20 +226,22 @@ File open_binlog(IO_CACHE *log, const char *log_file_name,
|
||||
|
||||
if (my_b_read(log, (byte*) magic, sizeof(magic)))
|
||||
{
|
||||
*errmsg = "I/O error reading binlog magic number";
|
||||
*errmsg = "I/O error reading the header from the binary log";
|
||||
goto err;
|
||||
}
|
||||
if (memcmp(magic, BINLOG_MAGIC, 4))
|
||||
if (memcmp(magic, BINLOG_MAGIC, sizeof(magic)))
|
||||
{
|
||||
*errmsg = "Binlog has bad magic number, fire your magician";
|
||||
*errmsg = "Binlog has bad magic number; It's not a binary log file that can be used by this version of MySQL";
|
||||
goto err;
|
||||
}
|
||||
return file;
|
||||
|
||||
err:
|
||||
if (file > 0)
|
||||
if (file >= 0)
|
||||
{
|
||||
my_close(file,MYF(0));
|
||||
end_io_cache(log);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -273,6 +259,7 @@ void adjust_linfo_offsets(my_off_t purge_offset)
|
||||
if ((linfo = tmp->current_linfo))
|
||||
{
|
||||
pthread_mutex_lock(&linfo->lock);
|
||||
// Why (monty): I don't understand this comment
|
||||
// no big deal if we just started reading the log
|
||||
// nothing to adjust
|
||||
if (linfo->index_file_offset < purge_offset)
|
||||
@ -282,7 +269,6 @@ void adjust_linfo_offsets(my_off_t purge_offset)
|
||||
pthread_mutex_unlock(&linfo->lock);
|
||||
}
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&LOCK_thread_count);
|
||||
}
|
||||
|
||||
@ -316,11 +302,12 @@ bool log_in_use(const char* log_name)
|
||||
int purge_master_logs(THD* thd, const char* to_log)
|
||||
{
|
||||
char search_file_name[FN_REFLEN];
|
||||
const char* errmsg = 0;
|
||||
|
||||
mysql_bin_log.make_log_name(search_file_name, to_log);
|
||||
int res = mysql_bin_log.purge_logs(thd, search_file_name);
|
||||
const char* errmsg = 0;
|
||||
switch(res)
|
||||
{
|
||||
|
||||
switch(res) {
|
||||
case 0: break;
|
||||
case LOG_INFO_EOF: errmsg = "Target log not found in binlog index"; break;
|
||||
case LOG_INFO_IO: errmsg = "I/O error reading log index file"; break;
|
||||
@ -333,8 +320,7 @@ binlog purge"; break;
|
||||
case LOG_INFO_FATAL: errmsg = "Fatal error during purge"; break;
|
||||
case LOG_INFO_IN_USE: errmsg = "A purgeable log is in use, will not purge";
|
||||
break;
|
||||
default:
|
||||
errmsg = "Unknown error during purge"; break;
|
||||
default: errmsg = "Unknown error during purge"; break;
|
||||
}
|
||||
|
||||
if (errmsg)
|
||||
@ -412,14 +398,14 @@ impossible position";
|
||||
|
||||
my_b_seek(&log, pos); // Seek will done on next read
|
||||
packet->length(0);
|
||||
packet->append("\0", 1);
|
||||
// we need to start a packet with something other than 255
|
||||
// to distiquish it from error
|
||||
packet->append("\0", 1);
|
||||
|
||||
// tell the client log name with a fake rotate_event
|
||||
// if we are at the start of the log
|
||||
if (pos == 4)
|
||||
{
|
||||
// tell the client log name with a fake rotate_event
|
||||
if (fake_rotate_event(net, packet, log_file_name, &errmsg))
|
||||
goto err;
|
||||
packet->length(0);
|
||||
@ -461,8 +447,7 @@ impossible position";
|
||||
|
||||
if (error != LOG_READ_EOF)
|
||||
{
|
||||
switch(error)
|
||||
{
|
||||
switch(error) {
|
||||
case LOG_READ_BOGUS:
|
||||
errmsg = "bogus data in log event";
|
||||
break;
|
||||
@ -488,9 +473,9 @@ impossible position";
|
||||
|
||||
if (!(flags & BINLOG_DUMP_NON_BLOCK) &&
|
||||
mysql_bin_log.is_active(log_file_name))
|
||||
{
|
||||
// block until there is more data in the log
|
||||
// unless non-blocking mode requested
|
||||
{
|
||||
if (net_flush(net))
|
||||
{
|
||||
errmsg = "failed on net_flush()";
|
||||
@ -586,8 +571,7 @@ impossible position";
|
||||
bool loop_breaker = 0;
|
||||
// need this to break out of the for loop from switch
|
||||
thd->proc_info = "switching to next log";
|
||||
switch(mysql_bin_log.find_next_log(&linfo))
|
||||
{
|
||||
switch (mysql_bin_log.find_next_log(&linfo)) {
|
||||
case LOG_INFO_EOF:
|
||||
loop_breaker = (flags & BINLOG_DUMP_NON_BLOCK);
|
||||
break;
|
||||
@ -624,6 +608,7 @@ impossible position";
|
||||
thd->current_linfo = 0;
|
||||
pthread_mutex_unlock(&LOCK_thread_count);
|
||||
DBUG_VOID_RETURN;
|
||||
|
||||
err:
|
||||
thd->proc_info = "waiting to finalize termination";
|
||||
end_io_cache(&log);
|
||||
@ -643,9 +628,10 @@ impossible position";
|
||||
|
||||
int start_slave(THD* thd , bool net_report)
|
||||
{
|
||||
int slave_errno = 0;
|
||||
if (!thd) thd = current_thd;
|
||||
NET* net = &thd->net;
|
||||
int slave_errno = 0;
|
||||
|
||||
if (check_access(thd, PROCESS_ACL, any_db))
|
||||
return 1;
|
||||
pthread_mutex_lock(&LOCK_slave);
|
||||
@ -681,11 +667,12 @@ int start_slave(THD* thd , bool net_report)
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int stop_slave(THD* thd, bool net_report )
|
||||
{
|
||||
int slave_errno = 0;
|
||||
if (!thd) thd = current_thd;
|
||||
NET* net = &thd->net;
|
||||
int slave_errno = 0;
|
||||
|
||||
if (check_access(thd, PROCESS_ACL, any_db))
|
||||
return 1;
|
||||
@ -712,7 +699,8 @@ int stop_slave(THD* thd, bool net_report )
|
||||
|
||||
if (slave_errno)
|
||||
{
|
||||
if(net_report) send_error(net, slave_errno);
|
||||
if (net_report)
|
||||
send_error(net, slave_errno);
|
||||
return 1;
|
||||
}
|
||||
else if (net_report)
|
||||
@ -721,6 +709,7 @@ int stop_slave(THD* thd, bool net_report )
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void reset_slave()
|
||||
{
|
||||
MY_STAT stat_area;
|
||||
@ -738,13 +727,13 @@ void reset_slave()
|
||||
|
||||
end_master_info(&glob_mi);
|
||||
fn_format(fname, master_info_file, mysql_data_home, "", 4+32);
|
||||
if(my_stat(fname, &stat_area, MYF(0)))
|
||||
if(my_delete(fname, MYF(MY_WME)))
|
||||
if (my_stat(fname, &stat_area, MYF(0)) && my_delete(fname, MYF(MY_WME)))
|
||||
return;
|
||||
if (slave_was_running)
|
||||
start_slave(0,0);
|
||||
}
|
||||
|
||||
|
||||
void kill_zombie_dump_threads(uint32 slave_server_id)
|
||||
{
|
||||
pthread_mutex_lock(&LOCK_thread_count);
|
||||
@ -775,10 +764,10 @@ void kill_zombie_dump_threads(uint32 slave_server_id)
|
||||
pthread_mutex_unlock(&tmp->mysys_var->mutex);
|
||||
}
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&LOCK_thread_count);
|
||||
}
|
||||
|
||||
|
||||
int change_master(THD* thd)
|
||||
{
|
||||
bool slave_was_running;
|
||||
@ -821,9 +810,7 @@ int change_master(THD* thd)
|
||||
}
|
||||
|
||||
if (lex_mi->host)
|
||||
{
|
||||
strmake(glob_mi.host, lex_mi->host, sizeof(glob_mi.host));
|
||||
}
|
||||
if (lex_mi->user)
|
||||
strmake(glob_mi.user, lex_mi->user, sizeof(glob_mi.user));
|
||||
if (lex_mi->password)
|
||||
@ -844,6 +831,7 @@ int change_master(THD* thd)
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void reset_master()
|
||||
{
|
||||
if (!mysql_bin_log.is_open())
|
||||
@ -865,9 +853,9 @@ void reset_master()
|
||||
mysql_bin_log.close(1); // exiting close
|
||||
my_delete(mysql_bin_log.get_index_fname(), MYF(MY_WME));
|
||||
mysql_bin_log.open(opt_bin_logname,LOG_BIN);
|
||||
|
||||
}
|
||||
|
||||
|
||||
int cmp_master_pos(const char* log_file_name1, ulonglong log_pos1,
|
||||
const char* log_file_name2, ulonglong log_pos2)
|
||||
{
|
||||
@ -881,6 +869,7 @@ int cmp_master_pos(const char* log_file_name1, ulonglong log_pos1,
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
static inline int cmp_master_pos(Slave_log_event* sev, LEX_MASTER_INFO* mi)
|
||||
{
|
||||
return cmp_master_pos(sev->master_log, sev->master_pos, mi->log_file_name,
|
||||
@ -917,16 +906,6 @@ static int find_target_pos(LEX_MASTER_INFO* mi, IO_CACHE* log, char* errmsg)
|
||||
}
|
||||
}
|
||||
|
||||
static void copy_base_name(char* dest, char* src)
|
||||
{
|
||||
char* p;
|
||||
p = strrchr(src, FN_LIBCHAR);
|
||||
if (p)
|
||||
p++;
|
||||
else
|
||||
p = src;
|
||||
strmov(dest, p);
|
||||
}
|
||||
|
||||
int translate_master(THD* thd, LEX_MASTER_INFO* mi, char* errmsg)
|
||||
{
|
||||
@ -955,6 +934,16 @@ int translate_master(THD* thd, LEX_MASTER_INFO* mi, char* errmsg)
|
||||
}
|
||||
|
||||
linfo.index_file_offset = 0;
|
||||
|
||||
/*
|
||||
WARNING: POSSIBLE BUG:
|
||||
Sasha, you are setting an uninitialized linfo into
|
||||
thd->current_linfo.
|
||||
What will happen if some other thread calls log_in_use() or
|
||||
adjust_linfo_offsets() after the next instruction as linfo may
|
||||
contain anything ?
|
||||
*/
|
||||
|
||||
thd->current_linfo = &linfo;
|
||||
search_file_name[0] = 0;
|
||||
|
||||
@ -970,41 +959,33 @@ int translate_master(THD* thd, LEX_MASTER_INFO* mi, char* errmsg)
|
||||
|
||||
for (;;)
|
||||
{
|
||||
|
||||
if ((file=open_binlog(&log, linfo.log_file_name, &errmsg_p)) < 0)
|
||||
{
|
||||
pthread_mutex_unlock(log_lock);
|
||||
strmov(errmsg, errmsg_p);
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (!(sev = find_slave_event(&log, linfo.log_file_name, errmsg)))
|
||||
{
|
||||
pthread_mutex_unlock(log_lock);
|
||||
goto err;
|
||||
}
|
||||
|
||||
cmp_res = cmp_master_pos(sev, mi);
|
||||
delete sev;
|
||||
|
||||
if (!cmp_res)
|
||||
{
|
||||
pthread_mutex_unlock(log_lock);
|
||||
copy_base_name(mi->log_file_name, linfo.log_file_name);
|
||||
/* Copy basename */
|
||||
fn_format(mi->log_file_name, linfo.log_file_name, "","",1);
|
||||
mi->pos = my_b_tell(&log);
|
||||
goto mi_inited;
|
||||
}
|
||||
|
||||
if (!last_pos && cmp_res > 0)
|
||||
else if (cmp_res > 0)
|
||||
{
|
||||
pthread_mutex_unlock(log_lock);
|
||||
strmov(errmsg, "Slave event in first log points past the \
|
||||
target position");
|
||||
if (!last_pos)
|
||||
{
|
||||
strmov(errmsg,
|
||||
"Slave event in first log points past the target position");
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (last_pos && cmp_res > 0)
|
||||
{
|
||||
end_io_cache(&log);
|
||||
(void) my_close(file, MYF(MY_WME));
|
||||
if (init_io_cache(&log, (file = last_file), IO_SIZE, READ_CACHE, 0, 0,
|
||||
@ -1013,15 +994,13 @@ target position");
|
||||
errmsg[0] = 0;
|
||||
goto err;
|
||||
}
|
||||
|
||||
goto found_log;
|
||||
break;
|
||||
}
|
||||
|
||||
strmov(last_log_name, linfo.log_file_name);
|
||||
last_pos = my_b_tell(&log);
|
||||
|
||||
switch (mysql_bin_log.find_next_log(&linfo))
|
||||
{
|
||||
switch (mysql_bin_log.find_next_log(&linfo)) {
|
||||
case LOG_INFO_EOF:
|
||||
if (last_file >= 0)
|
||||
(void)my_close(last_file, MYF(MY_WME));
|
||||
@ -1030,7 +1009,6 @@ target position");
|
||||
case 0:
|
||||
break;
|
||||
default:
|
||||
pthread_mutex_unlock(log_lock);
|
||||
strmov(errmsg, "Error reading log index");
|
||||
goto err;
|
||||
}
|
||||
@ -1044,15 +1022,13 @@ target position");
|
||||
found_log:
|
||||
my_b_seek(&log, last_pos);
|
||||
if (find_target_pos(mi,&log,errmsg))
|
||||
{
|
||||
pthread_mutex_unlock(log_lock);
|
||||
goto err;
|
||||
}
|
||||
pthread_mutex_unlock(log_lock);
|
||||
copy_base_name(mi->log_file_name, last_log_name);
|
||||
fn_format(mi->log_file_name, last_log_name, "","",1); /* Copy basename */
|
||||
|
||||
mi_inited:
|
||||
error = 0;
|
||||
err:
|
||||
pthread_mutex_unlock(log_lock);
|
||||
end_io_cache(&log);
|
||||
pthread_mutex_lock(&LOCK_thread_count);
|
||||
thd->current_linfo = 0;
|
||||
@ -1078,7 +1054,6 @@ static Slave_log_event* find_slave_event(IO_CACHE* log,
|
||||
(char*)log_file_name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
delete ev;
|
||||
|
||||
if (!(ev = Log_event::read_log_event(log, 0)))
|
||||
@ -1101,6 +1076,7 @@ static Slave_log_event* find_slave_event(IO_CACHE* log,
|
||||
return (Slave_log_event*)ev;
|
||||
}
|
||||
|
||||
|
||||
int show_new_master(THD* thd)
|
||||
{
|
||||
DBUG_ENTER("show_new_master");
|
||||
@ -1108,10 +1084,12 @@ int show_new_master(THD* thd)
|
||||
char errmsg[SLAVE_ERRMSG_SIZE];
|
||||
LEX_MASTER_INFO* lex_mi = &thd->lex.mi;
|
||||
|
||||
errmsg[0]=0; // Safety
|
||||
if (translate_master(thd, lex_mi, errmsg))
|
||||
{
|
||||
if (errmsg[0])
|
||||
net_printf(&thd->net, ER_SHOW_NEW_MASTER, errmsg);
|
||||
net_printf(&thd->net, ER_ERROR_WHEN_EXECUTING_COMMAND,
|
||||
"SHOW NEW MASTER", errmsg);
|
||||
else
|
||||
send_error(&thd->net, 0);
|
||||
|
||||
@ -1186,8 +1164,7 @@ int show_binlog_events(THD* thd)
|
||||
pthread_mutex_lock(mysql_bin_log.get_log_lock());
|
||||
my_b_seek(&log, pos);
|
||||
|
||||
for (event_count = 0;
|
||||
(ev = Log_event::read_log_event(&log, 0));)
|
||||
for (event_count = 0; (ev = Log_event::read_log_event(&log, 0)); )
|
||||
{
|
||||
if (event_count >= limit_start &&
|
||||
ev->net_send(thd, linfo.log_file_name, pos))
|
||||
@ -1223,7 +1200,8 @@ err:
|
||||
|
||||
if (errmsg)
|
||||
{
|
||||
net_printf(&thd->net, ER_SHOW_BINLOG_EVENTS, errmsg);
|
||||
net_printf(&thd->net, ER_ERROR_WHEN_EXECUTING_COMMAND,
|
||||
"SHOW BINLOG EVENTS", errmsg);
|
||||
DBUG_RETURN(1);
|
||||
}
|
||||
|
||||
@ -1234,8 +1212,11 @@ err:
|
||||
|
||||
int show_slave_hosts(THD* thd)
|
||||
{
|
||||
DBUG_ENTER("show_slave_hosts");
|
||||
List<Item> field_list;
|
||||
NET* net = &thd->net;
|
||||
String* packet = &thd->packet;
|
||||
DBUG_ENTER("show_slave_hosts");
|
||||
|
||||
field_list.push_back(new Item_empty_string("Server_id", 20));
|
||||
field_list.push_back(new Item_empty_string("Host", 20));
|
||||
if (opt_show_slave_auth_info)
|
||||
@ -1247,13 +1228,10 @@ int show_slave_hosts(THD* thd)
|
||||
|
||||
if (send_fields(thd, field_list, 1))
|
||||
DBUG_RETURN(-1);
|
||||
String* packet = &thd->packet;
|
||||
uint i;
|
||||
NET* net = &thd->net;
|
||||
|
||||
pthread_mutex_lock(&LOCK_slave_list);
|
||||
|
||||
for(i = 0; i < slave_list.records; ++i)
|
||||
for (uint i = 0; i < slave_list.records; ++i)
|
||||
{
|
||||
SLAVE_INFO* si = (SLAVE_INFO*) hash_element(&slave_list, i);
|
||||
packet->length(0);
|
||||
@ -1276,6 +1254,7 @@ int show_slave_hosts(THD* thd)
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
||||
|
||||
int show_binlog_info(THD* thd)
|
||||
{
|
||||
DBUG_ENTER("show_binlog_info");
|
||||
@ -1315,6 +1294,7 @@ int show_binlog_info(THD* thd)
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
||||
|
||||
int show_binlogs(THD* thd)
|
||||
{
|
||||
const char* errmsg = 0;
|
||||
@ -1380,6 +1360,7 @@ err:
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int connect_to_master(THD *thd, MYSQL* mysql, MASTER_INFO* mi)
|
||||
{
|
||||
if (!mc_mysql_connect(mysql, mi->host, mi->user, mi->password, 0,
|
||||
@ -1392,15 +1373,19 @@ int connect_to_master(THD *thd, MYSQL* mysql, MASTER_INFO* mi)
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static inline void cleanup_mysql_results(MYSQL_RES* db_res,
|
||||
MYSQL_RES** cur, MYSQL_RES** start)
|
||||
{
|
||||
for( ; cur >= start; --cur)
|
||||
{
|
||||
if (*cur)
|
||||
mc_mysql_free_result(*cur);
|
||||
}
|
||||
mc_mysql_free_result(db_res);
|
||||
}
|
||||
|
||||
|
||||
static inline int fetch_db_tables(THD* thd, MYSQL* mysql, const char* db,
|
||||
MYSQL_RES* table_res)
|
||||
{
|
||||
@ -1429,6 +1414,7 @@ static inline int fetch_db_tables(THD* thd, MYSQL* mysql, const char* db,
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int load_master_data(THD* thd)
|
||||
{
|
||||
MYSQL mysql;
|
||||
@ -1438,9 +1424,9 @@ int load_master_data(THD* thd)
|
||||
|
||||
mc_mysql_init(&mysql);
|
||||
|
||||
pthread_mutex_lock(&LOCK_slave);
|
||||
// we do not want anyone messing with the slave at all for the entire
|
||||
// duration of the data load;
|
||||
pthread_mutex_lock(&LOCK_slave);
|
||||
|
||||
// first, kill the slave
|
||||
if ((slave_was_running = slave_running))
|
||||
@ -1489,8 +1475,8 @@ int load_master_data(THD* thd)
|
||||
// capabilities - to be replaced once online backup is working
|
||||
// we wait to issue FLUSH TABLES WITH READ LOCK for as long as we
|
||||
// can to minimize the lock time
|
||||
if(mc_mysql_query(&mysql, "FLUSH TABLES WITH READ LOCK", 0)
|
||||
|| mc_mysql_query(&mysql, "SHOW MASTER STATUS",0) ||
|
||||
if (mc_mysql_query(&mysql, "FLUSH TABLES WITH READ LOCK", 0) ||
|
||||
mc_mysql_query(&mysql, "SHOW MASTER STATUS",0) ||
|
||||
!(master_status_res = mc_mysql_store_result(&mysql)))
|
||||
{
|
||||
net_printf(&thd->net, error = ER_QUERY_ON_MASTER,
|
||||
@ -1504,22 +1490,24 @@ int load_master_data(THD* thd)
|
||||
table_res_end = table_res + num_dbs;
|
||||
|
||||
for(cur_table_res = table_res; cur_table_res < table_res_end;
|
||||
++cur_table_res)
|
||||
cur_table_res++)
|
||||
{
|
||||
MYSQL_ROW row = mc_mysql_fetch_row(db_res);
|
||||
// since we know how many rows we have, this can never be NULL
|
||||
|
||||
MYSQL_ROW row = mc_mysql_fetch_row(db_res);
|
||||
char* db = row[0];
|
||||
int drop_error = 0;
|
||||
int drop_error;
|
||||
|
||||
/*
|
||||
Do not replicate databases excluded by rules
|
||||
also skip mysql database - in most cases the user will
|
||||
mess up and not exclude mysql database with the rules when
|
||||
he actually means to - in this case, he is up for a surprise if
|
||||
his priv tables get dropped and downloaded from master
|
||||
TO DO - add special option, not enabled
|
||||
by default, to allow inclusion of mysql database into load
|
||||
data from master
|
||||
*/
|
||||
|
||||
// do not replicate databases excluded by rules
|
||||
// also skip mysql database - in most cases the user will
|
||||
// mess up and not exclude mysql database with the rules when
|
||||
// he actually means to - in this case, he is up for a surprise if
|
||||
// his priv tables get dropped and downloaded from master
|
||||
// TO DO - add special option, not enabled
|
||||
// by default, to allow inclusion of mysql database into load
|
||||
// data from master
|
||||
if (!db_ok(db, replicate_do_db, replicate_ignore_db) ||
|
||||
!strcmp(db,"mysql"))
|
||||
{
|
||||
@ -1561,10 +1549,12 @@ int load_master_data(THD* thd)
|
||||
{
|
||||
MYSQL_ROW row = mc_mysql_fetch_row(master_status_res);
|
||||
|
||||
// we need this check because the master may not be running with
|
||||
// log-bin, but it will still allow us to do all the steps
|
||||
// of LOAD DATA FROM MASTER - no reason to forbid it, really,
|
||||
// although it does not make much sense for the user to do it
|
||||
/*
|
||||
We need this check because the master may not be running with
|
||||
log-bin, but it will still allow us to do all the steps
|
||||
of LOAD DATA FROM MASTER - no reason to forbid it, really,
|
||||
although it does not make much sense for the user to do it
|
||||
*/
|
||||
if (row[0] && row[1])
|
||||
{
|
||||
strmake(glob_mi.log_file_name, row[0], sizeof(glob_mi.log_file_name));
|
||||
@ -1585,6 +1575,7 @@ int load_master_data(THD* thd)
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
err:
|
||||
pthread_mutex_unlock(&LOCK_slave);
|
||||
if (slave_was_running)
|
||||
@ -1595,6 +1586,3 @@ err:
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
@ -114,7 +114,7 @@ int mysqld_show_open_tables(THD *thd,const char *db,const char *wild)
|
||||
if (send_fields(thd,field_list,1))
|
||||
DBUG_RETURN(1);
|
||||
|
||||
if (list_open_tables(thd,&tables,db,wild))
|
||||
if (!(open_list=list_open_tables(thd,wild)) && thd->fatal_error)
|
||||
DBUG_RETURN(-1);
|
||||
|
||||
List_iterator<char> it(tables);
|
||||
|
@ -37,6 +37,7 @@ typedef struct st_sort_param {
|
||||
SORT_FIELD *local_sortorder;
|
||||
SORT_FIELD *end;
|
||||
uchar *unique_buff;
|
||||
bool not_killable;
|
||||
#ifdef USE_STRCOLL
|
||||
char* tmp_buffer;
|
||||
#endif
|
||||
|
@ -128,10 +128,12 @@ bool Unique::get(TABLE *table)
|
||||
return 1;
|
||||
reinit_io_cache(outfile,WRITE_CACHE,0L,0,0);
|
||||
|
||||
bzero((char*) &sort_param,sizeof(sort_param));
|
||||
sort_param.max_rows= elements;
|
||||
sort_param.sort_form=table;
|
||||
sort_param.sort_length=sort_param.ref_length=tree.size_of_element;
|
||||
sort_param.keys= max_in_memory_size / sort_param.sort_length;
|
||||
sort_param.not_killable=1;
|
||||
|
||||
if (!(sort_buffer=(uchar*) my_malloc((sort_param.keys+1) *
|
||||
sort_param.sort_length,
|
||||
|
Loading…
x
Reference in New Issue
Block a user