database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

keep bk happy

Browse Source
This commit is contained in:
monty@donna.mysql.com
2001-01-22 04:46:32 +02:00
parent 8a9b1e9248
commit 0f28f7a414
8 changed files with 421 additions and 407 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Docs/manual.texi
View File

@ -40712,6 +40712,11 @@ not yet 100 % confident in this code.
@appendixsubsec Changes in release 3.23.32
@itemize @bullet
@item
Fixed bug in @code{SHOW LOGS} when there wheren't any BDB logs.
@item
Fixed a timing problem in replication that could delay sending an update
to the client until a new update was done.
@item
Don't convert field names when using @code{mysql_list_fields()}. This is
to keep this code compatible with @code{SHOW FIELDS}.
@item

4
mysql-test/mysql-test-run.sh
View File

@ -239,7 +239,7 @@ SLAVE_MYSQLD=$MYSQLD #this can be changed later if we are doing gcov
#--
wait_for_server_start ()
{
$MYSQL -e "select 1" --silent -w1 --host=127.0.0.1 --port=$1 \
$MYSQL --no-defaults -u $DBUSER -e "select 1" --silent -w1 --host=127.0.0.1 --port=$1 \
>/dev/null
}
@ -492,7 +492,7 @@ mysql_restart () {
mysql_loadstd () {
cp $STD_DATA/*.frm $STD_DATA/*.MRG $MASTER_MYDDIR/test
# cp $STD_DATA/*.frm $STD_DATA/*.MRG $MASTER_MYDDIR/test
return 1
}

16
sql/ha_berkeley.cc
View File

@ -253,15 +253,19 @@ int berkeley_show_logs(THD *thd)
{
DBUG_PRINT("error", ("log_archive failed (error %d)", error));
db_env->err(db_env, error, "log_archive: DB_ARCH_ABS");
if (error== DB_NOTFOUND)
error=0; // No log files
goto err;
}
/* Error is 0 here */
if (all_logs)
{
for (a = all_logs, f = free_logs; *a; ++a)
{
packet->length(0);
net_store_data(packet,*a);
net_store_data(packet,"BDB");
if (*f && strcmp(*a, *f) == 0)
if (f && *f && strcmp(*a, *f) == 0)
{
++f;
net_store_data(packet, SHOW_LOG_STATUS_FREE);
@ -270,10 +274,12 @@ int berkeley_show_logs(THD *thd)
net_store_data(packet, SHOW_LOG_STATUS_INUSE);
if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
{
error=1;
goto err;
}
error=0;
}
}
err:
free_root(&show_logs_root,MYF(0));
my_pthread_setspecific_ptr(THR_MALLOC,old_root);
@ -1042,6 +1048,7 @@ int ha_berkeley::update_row(const byte * old_row, byte * new_row)
ulong thd_options = table->in_use ? table->in_use->options : 0;
bool primary_key_changed;
DBUG_ENTER("update_row");
LINT_INIT(error);
statistic_increment(ha_update_count,&LOCK_status);
if (table->time_stamp)
@ -1066,7 +1073,6 @@ int ha_berkeley::update_row(const byte * old_row, byte * new_row)
}
sub_trans = transaction;
LINT_INIT(error);
for (uint retry=0 ; retry < berkeley_trans_retry ; retry++)
{
key_map changed_keys = 0;

6
sql/item_func.cc
View File

@ -1399,6 +1399,7 @@ longlong Item_master_pos_wait::val_int()
String *log_name = args[0]->val_str(&value);
int event_count;
null_value=0;
if (thd->slave_thread || !log_name || !log_name->length())
{
null_value = 1;
@ -1406,7 +1407,10 @@ longlong Item_master_pos_wait::val_int()
}
ulong pos = (ulong)args[1]->val_int();
if ((event_count = glob_mi.wait_for_pos(thd, log_name, pos)) == -1)
null_value = 1;;
{
null_value = 1;
event_count=0;
}
return event_count;
}

8
sql/mini_client.cc
View File

@ -298,9 +298,9 @@ static int mc_sock_connect(my_socket s, const struct sockaddr *name,
return(-1);
if (s_err)
{ /* getsockopt() could suceed */
{ // getsockopt() could succeed
errno = s_err;
return(-1); /* but return an error... */
return(-1); // but return an error...
}
return(0); /* It's all good! */
#endif
@ -403,8 +403,8 @@ my_bool STDCALL mc_mysql_reconnect(MYSQL *mysql)
int STDCALL
mc_simple_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
uint length, my_bool skipp_check)
mc_simple_command(MYSQL *mysql,enum enum_server_command command,
const char *arg, uint length, my_bool skipp_check)
{
NET *net= &mysql->net;
int result= -1;

189
sql/slave.cc
View File

@ -122,15 +122,17 @@ int tables_ok(THD* thd, TABLE_LIST* tables)
return 0;
}
if (wild_do_table_inited && find_wild(&replicate_wild_do_table,
hash_key, len)) return 1;
hash_key, len))
return 1;
if (wild_ignore_table_inited && find_wild(&replicate_wild_ignore_table,
hash_key, len)) return 0;
hash_key, len))
return 0;
}
return !do_table_inited && !wild_do_table_inited;
// if no explicit rule found
// and there was a do list, do not replicate. If there was
// no do list, go ahead
return !do_table_inited && !wild_do_table_inited;
}
@ -138,8 +140,8 @@ int add_table_rule(HASH* h, const char* table_spec)
{
const char* dot = strchr(table_spec, '.');
if(!dot) return 1;
// len is always > 0 because we know the there exists a '.'
uint len = (uint)strlen(table_spec);
if(!len) return 1;
TABLE_RULE_ENT* e = (TABLE_RULE_ENT*)my_malloc(sizeof(TABLE_RULE_ENT)
+ len, MYF(MY_WME));
if(!e) return 1;
@ -156,7 +158,6 @@ int add_wild_table_rule(DYNAMIC_ARRAY* a, const char* table_spec)
const char* dot = strchr(table_spec, '.');
if(!dot) return 1;
uint len = (uint)strlen(table_spec);
if(!len) return 1;
TABLE_RULE_ENT* e = (TABLE_RULE_ENT*)my_malloc(sizeof(TABLE_RULE_ENT)
+ len, MYF(MY_WME));
if(!e) return 1;
@ -227,9 +228,10 @@ int db_ok(const char* db, I_List<i_string> &do_list,
if(do_list.is_empty() && ignore_list.is_empty())
return 1; // ok to replicate if the user puts no constraints
if(!db)
return 0; // if the user has specified restrictions on which databases to replicate
// if the user has specified restrictions on which databases to replicate
// and db was not selected, do not replicate
if(!db)
return 0;
if(!do_list.is_empty()) // if the do's are not empty
{
@ -255,23 +257,25 @@ int db_ok(const char* db, I_List<i_string> &do_list,
}
return 1;
}
}
static int init_strvar_from_file(char* var, int max_size, IO_CACHE* f,
char* default_val)
{
if(my_b_gets(f,var, max_size))
uint length;
if ((length=my_b_gets(f,var, max_size)))
{
char* last_p = strend(var) - 1;
int c;
if(*last_p == '\n') *last_p = 0; // if we stopped on newline, kill it
char* last_p = var + length -1;
if (*last_p == '\n')
*last_p = 0; // if we stopped on newline, kill it
else
while( ((c=my_b_get(f)) != '\n' && c != my_b_EOF));
{
// if we truncated a line or stopped on last char, remove all chars
// up to and including newline
int c;
while( ((c=my_b_get(f)) != '\n' && c != my_b_EOF));
}
return 0;
}
else if (default_val)
@ -279,12 +283,10 @@ static int init_strvar_from_file(char* var, int max_size, IO_CACHE* f,
strmake(var, default_val, max_size);
return 0;
}
return 1;
}
static int init_intvar_from_file(int* var, IO_CACHE* f,
int default_val)
static int init_intvar_from_file(int* var, IO_CACHE* f, int default_val)
{
char buf[32];
@ -334,9 +336,9 @@ static int create_table_from_dump(THD* thd, NET* net, const char* db,
thd->query_error = 0;
thd->net.no_send_ok = 1;
thd->proc_info = "Creating table from master dump";
// save old db in case we are creating in a different database
char* save_db = thd->db;
thd->db = thd->last_nx_db; // in case we are creating in a different
// database
thd->db = thd->last_nx_db;
mysql_parse(thd, thd->query, packet_len); // run create table
thd->db = save_db; // leave things the way the were before
@ -376,9 +378,10 @@ static int create_table_from_dump(THD* thd, NET* net, const char* db,
check_opt.quick = 1;
thd->proc_info = "rebuilding the index on master dump table";
Vio* save_vio = thd->net.vio;
thd->net.vio = 0; // we do not want repair() to spam us with messages
// we do not want repair() to spam us with messages
// just send them to the error log, and report the failure in case of
// problems
thd->net.vio = 0;
if (file->repair(thd,&check_opt ))
{
net_printf(&thd->net, ER_INDEX_REBUILD,tables.table->real_name );
@ -423,15 +426,12 @@ int fetch_nx_table(THD* thd, MASTER_INFO* mi)
}
error = 0;
err:
if (mysql)
{
mc_mysql_close(mysql);
mysql = 0;
}
if (nx_errno && thd->net.vio)
send_error(&thd->net, nx_errno, "Error in fetch_nx_table");
return error;
}
@ -450,12 +450,12 @@ int init_master_info(MASTER_INFO* mi)
{
if (mi->inited)
return 0;
int fd;
int fd,length,error;
MY_STAT stat_area;
char fname[FN_REFLEN+128];
const char *msg;
fn_format(fname, master_info_file, mysql_data_home, "", 4+16+32);
// we need a mutex while we are changing master info parameters to
// keep other threads from reading bogus info
@ -463,12 +463,13 @@ int init_master_info(MASTER_INFO* mi)
mi->pending = 0;
fd = mi->fd;
if(!my_stat(fname, &stat_area, MYF(0))) // we do not want any messages
// if the file does not exist
// we do not want any messages if the file does not exist
if (!my_stat(fname, &stat_area, MYF(0)))
{
// if someone removed the file from underneath our feet, just close
// the old descriptor and re-create the old file
if(fd >= 0) my_close(fd, MYF(MY_WME));
if (fd >= 0)
my_close(fd, MYF(MY_WME));
if ((fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0
|| init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,0,
MYF(MY_WME)))
@ -490,7 +491,6 @@ int init_master_info(MASTER_INFO* mi)
strmake(mi->password, master_password, sizeof(mi->password) - 1);
mi->port = master_port;
mi->connect_retry = master_connect_retry;
}
else // file exists
{
@ -506,24 +506,19 @@ int init_master_info(MASTER_INFO* mi)
return 1;
}
if(!my_b_gets(&mi->file, mi->log_file_name, sizeof(mi->log_file_name)))
if (!(length=my_b_gets(&mi->file, mi->log_file_name,
sizeof(mi->log_file_name))))
{
sql_print_error("Error reading log file name from master info file ");
end_io_cache(&mi->file);
my_close(fd, MYF(0));
pthread_mutex_unlock(&mi->lock);
return 1;
msg="Error reading log file name from master info file ";
goto error;
}
*(strend(mi->log_file_name) - 1) = 0; // kill \n
mi->log_file_name[length]= 0; // kill \n
char buf[FN_REFLEN];
if(!my_b_gets(&mi->file, buf, sizeof(buf)))
{
sql_print_error("Error reading log file position from master info file");
end_io_cache(&mi->file);
my_close(fd, MYF(0));
pthread_mutex_unlock(&mi->lock);
return 1;
msg="Error reading log file position from master info file";
goto error;
}
mi->pos = strtoull(buf,(char**) 0, 10);
@ -538,11 +533,8 @@ int init_master_info(MASTER_INFO* mi)
init_intvar_from_file((int*)&mi->connect_retry, &mi->file,
master_connect_retry))
{
sql_print_error("Error reading master configuration");
end_io_cache(&mi->file);
my_close(fd, MYF(0));
pthread_mutex_unlock(&mi->lock);
return 1;
msg="Error reading master configuration";
goto error;
}
}
@ -550,15 +542,17 @@ int init_master_info(MASTER_INFO* mi)
// now change the cache from READ to WRITE - must do this
// before flush_master_info
reinit_io_cache(&mi->file, WRITE_CACHE, 0L,0,1);
if(flush_master_info(mi))
{
error=test(flush_master_info(mi));
pthread_mutex_unlock(&mi->lock);
return error;
error:
sql_print_error(msg);
end_io_cache(&mi->file);
my_close(fd, MYF(0));
pthread_mutex_unlock(&mi->lock);
return 1;
}
pthread_mutex_unlock(&mi->lock);
return 0;
}
int show_master_info(THD* thd)
{
@ -610,8 +604,8 @@ int flush_master_info(MASTER_INFO* mi)
my_b_seek(file, 0L);
my_b_printf(file, "%s\n%s\n%s\n%s\n%s\n%d\n%d\n",
mi->log_file_name, llstr(mi->pos, lbuf), mi->host, mi->user, mi->password,
mi->port, mi->connect_retry);
mi->log_file_name, llstr(mi->pos, lbuf), mi->host, mi->user,
mi->password, mi->port, mi->connect_retry);
flush_io_cache(file);
return 0;
}
@ -619,16 +613,18 @@ int flush_master_info(MASTER_INFO* mi)
int st_master_info::wait_for_pos(THD* thd, String* log_name, ulong log_pos)
{
if (!inited) return -1;
bool pos_reached = 0;
bool pos_reached;
int event_count = 0;
for(;!pos_reached && !thd->killed;)
pthread_mutex_lock(&lock);
do
{
int cmp_result;
char* basename;
pthread_mutex_lock(&lock);
if (*log_file_name)
{
basename = strrchr(log_file_name, FN_LIBCHAR);
/*
We should use dirname_length() here when we have a version of
this that doesn't modify the argument */
char *basename = strrchr(log_file_name, FN_LIBCHAR);
if (basename)
++basename;
else
@ -640,20 +636,19 @@ int st_master_info::wait_for_pos(THD* thd, String* log_name, ulong log_pos)
cmp_result = 0;
pos_reached = ((!cmp_result && pos >= log_pos) || cmp_result > 0);
if(!pos_reached && !thd->killed)
if (pos_reached || thd->killed)
break;
{
const char* msg = thd->enter_cond(&cond, &lock,
"Waiting for master update");
pthread_cond_wait(&cond, &lock);
thd->exit_cond(msg);
event_count++;
pos_reached = (pos >= log_pos);
}
} while (!pos_reached && !thd->killed);
pthread_mutex_unlock(&lock);
if(thd->killed)
return -1;
}
return event_count;
return thd->killed ? -1 : event_count;
}
@ -715,12 +710,17 @@ static int safe_sleep(THD* thd, int sec)
while (start_time < end_time)
{
int nap_time = (int) (end_time - start_time);
thr_alarm(&alarmed, 2 * nap_time,&alarm_buff); // the only reason we are asking for alarm is so that
// we will be woken up in case of murder, so if we do not get killed, set the alarm
// so it goes off after we wake up naturally
/*
the only reason we are asking for alarm is so that
we will be woken up in case of murder, so if we do not get killed,
set the alarm so it goes off after we wake up naturally
*/
thr_alarm(&alarmed, 2 * nap_time,&alarm_buff);
sleep(nap_time);
if (thr_alarm_in_use(&alarmed)) // if we wake up before the alarm goes off, hit the button
thr_end_alarm(&alarmed); // so it will not wake up the wife and kids :-)
// if we wake up before the alarm goes off, hit the button
// so it will not wake up the wife and kids :-)
if (thr_alarm_in_use(&alarmed))
thr_end_alarm(&alarmed);
if (slave_killed(thd))
return 1;
@ -742,10 +742,10 @@ static int request_dump(MYSQL* mysql, MASTER_INFO* mi)
len = (uint) strlen(logname);
memcpy(buf + 10, logname,len);
if (mc_simple_command(mysql, COM_BINLOG_DUMP, buf, len + 10, 1))
{
// something went wrong, so we will just reconnect and retry later
// in the future, we should do a better error analysis, but for
// now we just fill up the error log :-)
{
sql_print_error("Error on COM_BINLOG_DUMP: %s, will retry in %d secs",
mc_mysql_error(mysql), master_connect_retry);
return 1;
@ -786,8 +786,10 @@ command");
static uint read_event(MYSQL* mysql, MASTER_INFO *mi)
{
uint len = packet_error;
int read_errno = EINTR; // for convinience lets think we start by
// for convinience lets think we start by
// being in the interrupted state :-)
int read_errno = EINTR;
// my_real_read() will time us out
// we check if we were told to die, and if not, try reading again
#ifndef DBUG_OFF
@ -795,7 +797,8 @@ static uint read_event(MYSQL* mysql, MASTER_INFO *mi)
return packet_error;
#endif
while (!abort_loop && !abort_slave && len == packet_error && read_errno == EINTR )
while (!abort_loop && !abort_slave && len == packet_error &&
read_errno == EINTR )
{
len = mc_net_safe_read(mysql);
read_errno = errno;
@ -820,7 +823,6 @@ server_errno=%d)",
DBUG_PRINT("info",( "len=%u, net->read_pos[4] = %d\n",
len, mysql->net.read_pos[4]));
return len - 1;
}
@ -848,8 +850,7 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
thd->set_time(); // time the query
ev->when = time(NULL);
switch(type_code)
{
switch(type_code) {
case QUERY_EVENT:
{
Query_log_event* qev = (Query_log_event*)ev;
@ -886,8 +887,8 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
}
thd->db = 0; // prevent db from being freed
thd->query = 0; // just to be sure
thd->convert_set = 0; // assume no convert for next query
// unless set explictly
// assume no convert for next query unless set explictly
thd->convert_set = 0;
close_thread_tables(thd);
if (thd->query_error || thd->fatal_error)
@ -989,9 +990,10 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
net->pkt_nr = thd->net.pkt_nr;
}
}
else // we will just ask the master to send us /dev/null if we do not want to
// load the data :-)
else
{
// we will just ask the master to send us /dev/null if we do not
// want to load the data :-)
skip_load_data_infile(net);
}
@ -1077,7 +1079,6 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
break;
}
}
}
else
{
@ -1125,8 +1126,8 @@ pthread_handler_decl(handle_slave,arg __attribute__((unused)))
bool retried_once = 0;
ulonglong last_failed_pos = 0;
my_thread_init(); // needs to be up here, otherwise we get a coredump
// trying to use DBUG_ stuff
// needs to call my_thread_init(), otherwise we get a coredump in DBUG_ stuff
my_thread_init();
thd = new THD; // note that contructor of THD uses DBUG_ !
thd->set_time();
DBUG_ENTER("handle_slave");
@ -1141,8 +1142,8 @@ pthread_handler_decl(handle_slave,arg __attribute__((unused)))
DBUG_PRINT("info",("master info: log_file_name=%s, position=%d",
glob_mi.log_file_name, glob_mi.pos));
mysql = mc_mysql_init(NULL);
if(!mysql)
if (!(mysql = mc_mysql_init(NULL)))
{
sql_print_error("Slave thread: error in mc_mysql_init()");
goto err;
@ -1255,12 +1256,11 @@ reconnecting to retry, log '%s' position %ld", RPL_LOG_NAME,
#ifndef DBUG_OFF
else
{
stuck_count++;
// show a little mercy, allow slave to read one more event
// before cutting him off - otherwise he gets stuck
// on Invar events, since they do not advance the offset
// immediately
if(stuck_count > 2)
if (++stuck_count > 2)
events_till_disconnect++;
}
#endif
@ -1276,10 +1276,7 @@ position %ld",
RPL_LOG_NAME, glob_mi.pos);
thd->query = thd->db = 0; // extra safety
if(mysql)
{
mc_mysql_close(mysql);
mysql = 0;
}
thd->proc_info = "waiting for slave mutex on exit";
pthread_mutex_lock(&LOCK_slave);
slave_running = 0;
@ -1299,8 +1296,10 @@ position %ld",
DBUG_RETURN(0); // Can't return anything here
}
/* try to connect until successful or slave killed */
static int safe_connect(THD* thd, MYSQL* mysql, MASTER_INFO* mi)
// will try to connect until successful or slave killed
{
int slave_was_killed;
#ifndef DBUG_OFF
@ -1322,13 +1321,14 @@ static int safe_connect(THD* thd, MYSQL* mysql, MASTER_INFO* mi)
return slave_was_killed;
}
// will try to connect until successful or slave killed
/* try to connect until successful or slave killed */
static int safe_reconnect(THD* thd, MYSQL* mysql, MASTER_INFO* mi)
{
int slave_was_killed;
mi->pending = 0; // if we lost connection after reading a state set event
// if we lost connection after reading a state set event
// we will be re-reading it, so pending needs to be cleared
mi->pending = 0;
#ifndef DBUG_OFF
events_till_disconnect = disconnect_slave_event_count;
#endif
@ -1354,4 +1354,3 @@ replication resumed in log '%s' at position %ld", glob_mi.user,
template class I_List_iterator<i_string>;
template class I_List_iterator<i_string_pair>;
#endif

10
sql/sql_repl.cc
View File

@ -311,8 +311,9 @@ sweepstakes if you report the bug";
// we need to start a packet with something other than 255
// to distiquish it from error
if(pos == 4) // tell the client log name with a fake rotate_event
// tell the client log name with a fake rotate_event
// if we are at the start of the log
if(pos == 4)
{
if (fake_rotate_event(net, packet, log_file_name, &errmsg))
goto err;
@ -345,7 +346,6 @@ sweepstakes if you report the bug";
packet->append("\0",1);
}
if (error != LOG_READ_EOF)
{
switch(error)
@ -399,7 +399,8 @@ sweepstakes if you report the bug";
// no one will update the log while we are reading
// now, but we'll be quick and just read one record
switch(Log_event::read_log_event(&log, packet, log_lock))
pthread_mutex_lock(log_lock);
switch (Log_event::read_log_event(&log, packet, (pthread_mutex_t*) 0))
{
case 0:
read_packet = 1;
@ -407,15 +408,14 @@ sweepstakes if you report the bug";
// slave
break;
case LOG_READ_EOF:
pthread_mutex_lock(log_lock);
pthread_cond_wait(&COND_binlog_update, log_lock);
pthread_mutex_unlock(log_lock);
break;
default:
fatal_error = 1;
break;
}
pthread_mutex_unlock(log_lock);
pthread_mutex_lock(&thd->mysys_var->mutex);
thd->mysys_var->current_mutex= 0;

2
sql/sql_show.cc
View File

@ -592,7 +592,7 @@ mysqld_show_logs(THD *thd)
#ifdef HAVE_BERKELEY_DB
if (berkeley_show_logs(thd))
DBUG_RETURN(1);
DBUG_RETURN(-1);
#endif
send_eof(&thd->net);