~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/drizzled.cc

  • Committer: Brian Aker
  • Date: 2008-07-16 01:30:24 UTC
  • Revision ID: brian@tangent.org-20080716013024-nmnogwdpa459jrch
First pass of cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
 
#include <drizzled/server_includes.h>
17
 
#include <mysys/my_bit.h>
 
16
#include "mysql_priv.h"
 
17
#include <m_ctype.h>
 
18
#include <my_dir.h>
 
19
#include <my_bit.h>
18
20
#include "slave.h"
19
21
#include "rpl_mi.h"
20
22
#include "sql_repl.h"
21
23
#include "rpl_filter.h"
 
24
#include "repl_failsafe.h"
22
25
#include "stacktrace.h"
23
 
#include <mysys/mysys_err.h>
24
 
#include <sys/poll.h>
25
 
#include <netinet/tcp.h>
26
 
#include <drizzled/drizzled_error_messages.h>
27
 
 
28
 
#if TIME_WITH_SYS_TIME
29
 
# include <sys/time.h>
30
 
# include <time.h>
31
 
#else
32
 
# if HAVE_SYS_TIME_H
33
 
#  include <sys/time.h>
34
 
# else
35
 
#  include <time.h>
36
 
# endif
37
 
#endif
38
 
 
39
 
#include <storage/myisam/ha_myisam.h>
 
26
#include "mysqld_suffix.h"
 
27
#include "mysys_err.h"
 
28
 
 
29
#include "../storage/myisam/ha_myisam.h"
40
30
 
41
31
#ifdef HAVE_SYS_PRCTL_H
42
32
#include <sys/prctl.h>
46
36
#define DEFAULT_SKIP_THREAD_PRIORITY 0
47
37
#endif
48
38
 
49
 
#include <mysys/thr_alarm.h>
50
 
#include <libdrizzle/errmsg.h>
51
 
#include <locale.h>
 
39
#include <thr_alarm.h>
 
40
#include <errmsg.h>
52
41
 
53
 
#define mysqld_charset &my_charset_utf8_general_ci
 
42
#define mysqld_charset &my_charset_latin1
54
43
 
55
44
#ifdef HAVE_purify
56
45
#define IF_PURIFY(A,B) (A)
58
47
#define IF_PURIFY(A,B) (B)
59
48
#endif
60
49
 
61
 
#define MAX_MEM_TABLE_SIZE SIZE_MAX
 
50
#if SIZEOF_CHARP == 4
 
51
#define MAX_MEM_TABLE_SIZE ~(ulong) 0
 
52
#else
 
53
#define MAX_MEM_TABLE_SIZE ~(uint64_t) 0
 
54
#endif
62
55
 
63
56
/* We have HAVE_purify below as this speeds up the shutdown of MySQL */
64
57
 
72
65
#ifndef __GNU_LIBRARY__
73
66
#define __GNU_LIBRARY__                         // Skip warnings in getopt.h
74
67
#endif
75
 
#include <mysys/my_getopt.h>
 
68
#include <my_getopt.h>
76
69
#ifdef HAVE_SYSENT_H
77
70
#include <sysent.h>
78
71
#endif
82
75
#ifdef HAVE_GRP_H
83
76
#include <grp.h>
84
77
#endif
 
78
#include <my_net.h>
85
79
 
86
80
#include <sys/resource.h>
87
81
 
100
94
#endif
101
95
 
102
96
#define SIGNAL_FMT "signal %d"
103
 
 
 
97
  
104
98
 
105
99
#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)
106
100
#include <ieeefp.h>
149
143
 
150
144
} /* cplusplus */
151
145
 
152
 
#define DRIZZLE_KILL_SIGNAL SIGTERM
153
 
 
154
 
#include <mysys/my_pthread.h>                   // For thr_setconcurency()
155
 
 
156
 
#include <libdrizzle/gettext.h>
 
146
#define MYSQL_KILL_SIGNAL SIGTERM
 
147
 
 
148
#include <my_pthread.h>                 // For thr_setconcurency()
157
149
 
158
150
#ifdef SOLARIS
159
151
extern "C" int gethostname(char *name, int namelen);
160
152
#endif
161
153
 
162
 
extern "C" RETSIGTYPE handle_segfault(int sig);
 
154
extern "C" sig_handler handle_segfault(int sig);
163
155
 
164
156
/* Constants */
165
157
 
172
164
static const char *optimizer_switch_names[]=
173
165
{
174
166
  "no_materialization", "no_semijoin",
175
 
  NULL
 
167
  NullS
176
168
};
177
169
 
178
170
/* Corresponding defines are named OPTIMIZER_SWITCH_XXX */
188
180
 
189
181
static const char *tc_heuristic_recover_names[]=
190
182
{
191
 
  "COMMIT", "ROLLBACK", NULL
 
183
  "COMMIT", "ROLLBACK", NullS
192
184
};
193
185
static TYPELIB tc_heuristic_recover_typelib=
194
186
{
207
199
/*
208
200
  Used with --help for detailed option
209
201
*/
210
 
static bool opt_help= false;
 
202
static bool opt_help= 0, opt_verbose= 0;
211
203
 
212
204
arg_cmp_func Arg_comparator::comparator_matrix[5][2] =
213
205
{{&Arg_comparator::compare_string,     &Arg_comparator::compare_e_string},
216
208
 {&Arg_comparator::compare_row,        &Arg_comparator::compare_e_row},
217
209
 {&Arg_comparator::compare_decimal,    &Arg_comparator::compare_e_decimal}};
218
210
 
219
 
const char *log_output_names[] = { "NONE", "FILE", NULL};
220
 
static const unsigned int log_output_names_len[]= { 4, 4, 0 };
 
211
const char *log_output_names[] = { "NONE", "FILE", "TABLE", NullS};
 
212
static const unsigned int log_output_names_len[]= { 4, 4, 5, 0 };
221
213
TYPELIB log_output_typelib= {array_elements(log_output_names)-1,"",
222
 
                             log_output_names,
 
214
                             log_output_names, 
223
215
                             (unsigned int *) log_output_names_len};
224
216
 
225
217
/* static variables */
226
218
 
227
219
/* the default log output is log tables */
 
220
static bool lower_case_table_names_used= 0;
228
221
static bool volatile select_thread_in_use, signal_thread_in_use;
229
222
static bool volatile ready_to_exit;
230
223
static bool opt_debugging= 0, opt_console= 0;
231
 
static uint32_t kill_cached_threads, wake_thread;
232
 
static uint32_t killed_threads, thread_created;
233
 
static uint32_t max_used_connections;
234
 
static volatile uint32_t cached_thread_count= 0;
 
224
static bool opt_short_log_format= 0;
 
225
static uint kill_cached_threads, wake_thread;
 
226
static ulong killed_threads, thread_created;
 
227
static ulong max_used_connections;
 
228
static volatile ulong cached_thread_count= 0;
235
229
static char *mysqld_user, *mysqld_chroot, *log_error_file_ptr;
236
230
static char *opt_init_slave, *language_ptr, *opt_init_connect;
237
231
static char *default_character_set_name;
238
232
static char *character_set_filesystem_name;
239
233
static char *lc_time_names_name;
240
234
static char *my_bind_addr_str;
241
 
static char *default_collation_name;
 
235
static char *default_collation_name; 
242
236
static char *default_storage_engine_str;
243
 
static char compiled_default_collation_name[]= DRIZZLE_DEFAULT_COLLATION_NAME;
 
237
static char compiled_default_collation_name[]= MYSQL_DEFAULT_COLLATION_NAME;
244
238
static I_List<THD> thread_cache;
245
239
static double long_query_time;
246
240
 
249
243
/* Global variables */
250
244
 
251
245
bool opt_bin_log;
 
246
bool opt_log; 
 
247
bool opt_slow_log;
252
248
ulong log_output_options;
253
249
bool opt_log_queries_not_using_indexes= false;
254
 
bool opt_error_log= 0;
 
250
bool opt_error_log= IF_WIN(1,0);
 
251
bool opt_disable_networking= false;
255
252
bool opt_skip_show_db= false;
256
253
bool opt_character_set_client_handshake= 1;
257
254
bool server_id_supplied = 0;
268
265
bool opt_safe_user_create = 0;
269
266
bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
270
267
bool opt_log_slave_updates= 0;
271
 
static struct pollfd fds[UINT8_MAX];
272
 
static uint8_t pollfd_count= 0;
273
268
 
274
269
/*
275
270
  Legacy global handlerton. These will be removed (please do not add more).
280
275
bool opt_readonly;
281
276
bool use_temp_pool;
282
277
bool relay_log_purge;
 
278
bool opt_sync_frm;
 
279
bool opt_secure_auth= false;
283
280
char* opt_secure_file_priv= 0;
 
281
bool opt_log_slow_admin_statements= 0;
 
282
bool opt_log_slow_slave_statements= 0;
 
283
bool lower_case_file_system= 0;
 
284
bool opt_old_style_user_limits= 0;
 
285
bool trust_function_creators= 0;
284
286
/*
285
287
  True if there is at least one per-hour limit for some user, so we should
286
288
  check them before each query (and possibly reset counters when hour is
287
289
  changed). False otherwise.
288
290
*/
 
291
volatile bool mqh_used = 0;
289
292
bool opt_noacl;
290
293
 
291
294
ulong opt_binlog_rows_event_max_size;
292
 
const char *binlog_format_names[]= {"MIXED", "STATEMENT", "ROW", NULL};
 
295
const char *binlog_format_names[]= {"MIXED", "STATEMENT", "ROW", NullS};
293
296
TYPELIB binlog_format_typelib=
294
297
  { array_elements(binlog_format_names) - 1, "",
295
298
    binlog_format_names, NULL };
296
 
uint32_t opt_binlog_format_id= (uint32_t) BINLOG_FORMAT_UNSPEC;
 
299
ulong opt_binlog_format_id= (ulong) BINLOG_FORMAT_UNSPEC;
297
300
const char *opt_binlog_format= binlog_format_names[opt_binlog_format_id];
298
301
#ifdef HAVE_INITGROUPS
299
302
static bool calling_initgroups= false; /**< Used in SIGSEGV handler. */
300
303
#endif
301
 
uint32_t mysqld_port, test_flags, select_errors, dropping_tables, ha_open_options;
302
 
uint32_t mysqld_port_timeout;
303
 
uint32_t delay_key_write_options, protocol_version;
304
 
uint32_t lower_case_table_names= 1;
305
 
uint32_t tc_heuristic_recover= 0;
306
 
uint32_t volatile thread_count, thread_running;
 
304
uint mysqld_port, test_flags, select_errors, dropping_tables, ha_open_options;
 
305
uint mysqld_port_timeout;
 
306
uint delay_key_write_options, protocol_version;
 
307
uint lower_case_table_names;
 
308
uint tc_heuristic_recover= 0;
 
309
uint volatile thread_count, thread_running;
307
310
uint64_t thd_startup_options;
308
311
ulong back_log, connect_timeout, server_id;
309
312
ulong table_cache_size, table_def_size;
310
313
ulong what_to_log;
311
 
ulong slow_launch_time, slave_open_temp_tables;
312
 
ulong open_files_limit;
313
 
ulong max_binlog_size;
314
 
ulong max_relay_log_size;
315
 
ulong slave_net_timeout;
316
 
ulong slave_trans_retries;
 
314
ulong query_buff_size, slow_launch_time, slave_open_temp_tables;
 
315
ulong open_files_limit, max_binlog_size, max_relay_log_size;
 
316
ulong slave_net_timeout, slave_trans_retries;
317
317
bool slave_allow_batching;
318
318
ulong slave_exec_mode_options;
319
319
const char *slave_exec_mode_str= "STRICT";
320
 
ulong thread_cache_size= 0;
321
 
ulong thread_pool_size= 0;
322
 
ulong binlog_cache_size= 0;
323
 
ulong max_binlog_cache_size= 0;
324
 
uint32_t refresh_version;  /* Increments on each reload */
 
320
ulong thread_cache_size=0, thread_pool_size= 0;
 
321
ulong binlog_cache_size=0, max_binlog_cache_size=0;
 
322
ulong refresh_version;  /* Increments on each reload */
325
323
query_id_t global_query_id;
326
 
ulong aborted_threads;
327
 
ulong aborted_connects;
328
 
ulong specialflag= 0;
329
 
ulong binlog_cache_use= 0;
330
 
ulong binlog_cache_disk_use= 0;
331
 
ulong max_connections;
332
 
ulong max_connect_errors;
333
 
uint32_t  max_user_connections= 0;
334
 
ulong thread_id=1L;
335
 
ulong current_pid;
336
 
ulong slow_launch_threads = 0;
337
 
ulong sync_binlog_period;
 
324
ulong aborted_threads, aborted_connects;
 
325
ulong specialflag=0;
 
326
ulong binlog_cache_use= 0, binlog_cache_disk_use= 0;
 
327
ulong max_connections, max_connect_errors;
 
328
uint  max_user_connections= 0;
 
329
ulong thread_id=1L,current_pid;
 
330
ulong slow_launch_threads = 0, sync_binlog_period;
338
331
ulong expire_logs_days = 0;
339
332
ulong rpl_recovery_rank=0;
340
333
const char *log_output_str= "FILE";
382
375
     language[FN_REFLEN], reg_ext[FN_EXTLEN], mysql_charsets_dir[FN_REFLEN],
383
376
     *opt_init_file, *opt_tc_log_file;
384
377
char mysql_unpacked_real_data_home[FN_REFLEN];
385
 
uint32_t reg_ext_length;
 
378
uint reg_ext_length;
386
379
const key_map key_map_empty(0);
387
380
key_map key_map_full(0);                        // Will be initialized later
388
381
 
389
382
const char *opt_date_time_formats[3];
390
383
 
391
 
uint32_t mysql_data_home_len;
 
384
uint mysql_data_home_len;
392
385
char mysql_data_home_buff[2], *mysql_data_home=mysql_real_data_home;
393
386
char server_version[SERVER_VERSION_LENGTH];
394
387
char *opt_mysql_tmpdir;
 
388
const char **errmesg;                   /**< Error messages */
395
389
const char *myisam_recover_options_str="OFF";
396
390
const char *myisam_stats_method_str="nulls_unequal";
397
391
 
410
404
Ge_creator ge_creator;
411
405
Le_creator le_creator;
412
406
 
 
407
FILE *bootstrap_file;
 
408
int bootstrap_error;
413
409
FILE *stderror_file=0;
414
410
 
415
411
I_List<THD> threads;
424
420
MY_TMPDIR mysql_tmpdir_list;
425
421
MY_BITMAP temp_pool;
426
422
 
427
 
const CHARSET_INFO *system_charset_info, *files_charset_info ;
428
 
const CHARSET_INFO *national_charset_info, *table_alias_charset;
429
 
const CHARSET_INFO *character_set_filesystem;
 
423
CHARSET_INFO *system_charset_info, *files_charset_info ;
 
424
CHARSET_INFO *national_charset_info, *table_alias_charset;
 
425
CHARSET_INFO *character_set_filesystem;
430
426
 
431
427
MY_LOCALE *my_default_lc_time_names;
432
428
 
433
 
SHOW_COMP_OPTION have_symlink;
434
 
SHOW_COMP_OPTION have_compress;
 
429
SHOW_COMP_OPTION have_symlink, have_dlopen;
 
430
SHOW_COMP_OPTION have_crypt, have_compress;
435
431
 
436
432
/* Thread specific variables */
437
433
 
438
434
pthread_key(MEM_ROOT**,THR_MALLOC);
439
435
pthread_key(THD*, THR_THD);
440
436
pthread_mutex_t LOCK_mysql_create_db, LOCK_open, LOCK_thread_count,
441
 
                LOCK_status, LOCK_global_read_lock,
 
437
                LOCK_mapped_file, LOCK_status, LOCK_global_read_lock,
442
438
                LOCK_error_log, LOCK_uuid_generator,
 
439
                LOCK_crypt,
443
440
                LOCK_global_system_variables,
444
441
                LOCK_user_conn, LOCK_slave_list, LOCK_active_mi,
445
442
                LOCK_connection_count;
452
449
pthread_cond_t  COND_server_started;
453
450
 
454
451
/* replication parameters, if master_host is not NULL, we are a slave */
455
 
uint32_t report_port= DRIZZLE_PORT;
 
452
uint report_port= MYSQL_PORT;
456
453
uint32_t master_retry_count= 0;
457
454
char *master_info_file;
458
455
char *relay_log_info_file, *report_user, *report_password, *report_host;
459
456
char *opt_relay_logname = 0, *opt_relaylog_index_name=0;
460
 
char *opt_logname;
 
457
char *opt_logname, *opt_slow_logname;
461
458
 
462
459
/* Static variables */
463
460
 
465
462
#ifdef HAVE_STACK_TRACE_ON_SEGV
466
463
static bool opt_do_pstack;
467
464
#endif /* HAVE_STACK_TRACE_ON_SEGV */
 
465
static bool opt_bootstrap, opt_myisam_log;
468
466
static int cleanup_done;
469
 
static uint32_t opt_myisam_block_size;
 
467
static ulong opt_specialflag, opt_myisam_block_size;
470
468
static char *opt_binlog_index_name;
471
469
static char *opt_tc_heuristic_recover;
472
470
static char *mysql_home_ptr, *pidfile_name_ptr;
474
472
static char **defaults_argv;
475
473
static char *opt_bin_logname;
476
474
 
 
475
static my_socket ip_sock;
477
476
struct rand_struct sql_rand; ///< used by sql_class.cc:THD::THD()
478
477
 
479
478
struct passwd *user_info;
480
479
static pthread_t select_thread;
481
 
static uint32_t thr_kill_signal;
 
480
static uint thr_kill_signal;
482
481
 
483
482
/* OS specific variables */
484
483
 
490
489
  Number of currently active user connections. The variable is protected by
491
490
  LOCK_connection_count.
492
491
*/
493
 
uint32_t connection_count= 0;
 
492
uint connection_count= 0;
494
493
 
495
494
/* Function declarations */
496
495
 
505
504
void handle_connections_sockets();
506
505
pthread_handler_t kill_server_thread(void *arg);
507
506
pthread_handler_t handle_slave(void *arg);
508
 
static uint32_t find_bit_type(const char *x, TYPELIB *bit_lib);
509
 
static uint32_t find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
 
507
static ulong find_bit_type(const char *x, TYPELIB *bit_lib);
 
508
static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
510
509
                                   const char *option);
511
510
static void clean_up(bool print_message);
 
511
static int test_if_case_insensitive(const char *dir_name);
512
512
 
513
513
static void usage(void);
514
514
static void start_signal_handler(void);
545
545
      break;                                    // allready dead
546
546
#endif
547
547
    set_timespec(abstime, 2);
548
 
    for (uint32_t tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
 
548
    for (uint tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
549
549
    {
550
550
      error=pthread_cond_timedwait(&COND_thread_count,&LOCK_thread_count,
551
551
                                   &abstime);
554
554
    }
555
555
#ifdef EXTRA_DEBUG
556
556
    if (error != 0 && !count++)
557
 
      sql_print_error(_("Got error %d from pthread_cond_timedwait"),error);
 
557
      sql_print_error("Got error %d from pthread_cond_timedwait",error);
558
558
#endif
559
559
    close_server_sock();
560
560
  }
562
562
 
563
563
 
564
564
  /* Abort listening to new connections */
 
565
  if (!opt_disable_networking )
565
566
  {
566
 
    int x;
567
 
 
568
 
    for (x= 0; x < pollfd_count; x++)
 
567
    if (ip_sock != INVALID_SOCKET)
569
568
    {
570
 
      if (fds[x].fd != -1)
571
 
      {
572
 
        (void) shutdown(fds[x].fd, SHUT_RDWR);
573
 
        (void) close(fds[x].fd);
574
 
        fds[x].fd= -1;
575
 
      }
 
569
      (void) shutdown(ip_sock, SHUT_RDWR);
 
570
      (void) closesocket(ip_sock);
 
571
      ip_sock= INVALID_SOCKET;
576
572
    }
577
573
  }
578
 
 
579
574
  end_thr_alarm(0);                      // Abort old alarms.
580
575
 
581
576
  /*
656
651
static void close_server_sock()
657
652
{
658
653
#ifdef HAVE_CLOSE_SERVER_SOCK
 
654
  my_socket tmp_sock;
 
655
  tmp_sock=ip_sock;
 
656
  if (tmp_sock != INVALID_SOCKET)
659
657
  {
660
 
    int x;
661
 
 
662
 
    for (x= 0; x < pollfd_count; x++)
663
 
    {
664
 
      if (fds[x].fd != -1)
665
 
      {
666
 
        (void) shutdown(fds[x].fd, SHUT_RDWR);
667
 
        (void) close(fds[x].fd);
668
 
        fds[x].fd= -1;
669
 
      }
670
 
    }
 
658
    ip_sock=INVALID_SOCKET;
 
659
    VOID(shutdown(tmp_sock, SHUT_RDWR));
671
660
  }
 
661
  return;;
672
662
#endif
673
663
}
674
664
 
682
672
#endif
683
673
 
684
674
#if defined(HAVE_PTHREAD_KILL)
685
 
  pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL);
 
675
  pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
686
676
#elif !defined(SIGNALS_DONT_BREAK_READ)
687
 
  kill(current_pid, DRIZZLE_KILL_SIGNAL);
 
677
  kill(current_pid, MYSQL_KILL_SIGNAL);
688
678
#endif
689
679
  shutdown_in_progress=1;                       // Safety if kill didn't work
690
680
#ifdef SIGNALS_DONT_BREAK_READ
694
684
    abort_loop=1;
695
685
    if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
696
686
                           (void*) 0))
697
 
      sql_print_error(_("Can't create thread to kill server"));
 
687
      sql_print_error("Can't create thread to kill server");
698
688
  }
699
689
#endif
700
690
  return;;
722
712
  abort_loop=1;                                 // This should be set
723
713
  if (sig != 0) // 0 is not a valid signal number
724
714
    my_sigset(sig, SIG_IGN);                    /* purify inspected */
725
 
  if (sig == DRIZZLE_KILL_SIGNAL || sig == 0)
726
 
    sql_print_information(_(ER(ER_NORMAL_SHUTDOWN)),my_progname);
 
715
  if (sig == MYSQL_KILL_SIGNAL || sig == 0)
 
716
    sql_print_information(ER(ER_NORMAL_SHUTDOWN),my_progname);
727
717
  else
728
 
    sql_print_error(_(ER(ER_GOT_SIGNAL)),my_progname,sig); /* purecov: inspected */
729
 
 
 
718
    sql_print_error(ER(ER_GOT_SIGNAL),my_progname,sig); /* purecov: inspected */
 
719
  
730
720
  close_connections();
731
 
  if (sig != DRIZZLE_KILL_SIGNAL &&
 
721
  if (sig != MYSQL_KILL_SIGNAL &&
732
722
      sig != 0)
733
723
    unireg_abort(1);                            /* purecov: inspected */
734
724
  else
758
748
#endif
759
749
 
760
750
 
761
 
extern "C" RETSIGTYPE print_signal_warning(int sig)
 
751
extern "C" sig_handler print_signal_warning(int sig)
762
752
{
763
753
  if (global_system_variables.log_warnings)
764
 
    sql_print_warning(_("Got signal %d from thread %lud"), sig,my_thread_id());
765
 
#ifndef HAVE_BSD_SIGNALS
 
754
    sql_print_warning("Got signal %d from thread %ld", sig,my_thread_id());
 
755
#ifdef DONT_REMEMBER_SIGNAL
766
756
  my_sigset(sig,print_signal_warning);          /* int. thread system calls */
767
757
#endif
768
758
  if (sig == SIGALRM)
795
785
{
796
786
 
797
787
  if (exit_code)
798
 
    sql_print_error(_("Aborting\n"));
 
788
    sql_print_error("Aborting\n");
799
789
  else if (opt_help)
800
790
    usage();
801
 
  clean_up(!opt_help && (exit_code)); /* purecov: inspected */
 
791
  clean_up(!opt_help && (exit_code || !opt_bootstrap)); /* purecov: inspected */
802
792
  mysqld_exit(exit_code);
803
793
}
804
794
 
817
807
  if (cleanup_done++)
818
808
    return; /* purecov: inspected */
819
809
 
 
810
  /*
 
811
    make sure that handlers finish up
 
812
    what they have that is dependent on the binlog
 
813
  */
 
814
  ha_binlog_end(current_thd);
 
815
 
820
816
  logger.cleanup_base();
821
817
 
822
818
  mysql_bin_log.cleanup();
836
832
  if (tc_log)
837
833
    tc_log->close();
838
834
  xid_cache_free();
839
 
  delete_elements(&key_caches, (void (*)(const char*, unsigned char*)) free_key_cache);
 
835
  delete_elements(&key_caches, (void (*)(const char*, uchar*)) free_key_cache);
840
836
  multi_keycache_free();
841
837
  free_status_vars();
842
838
  end_thr_alarm(1);                     /* Free allocated memory */
843
839
  my_free_open_file_info();
844
 
  free((char*) global_system_variables.date_format);
845
 
  free((char*) global_system_variables.time_format);
846
 
  free((char*) global_system_variables.datetime_format);
 
840
  my_free((char*) global_system_variables.date_format,
 
841
          MYF(MY_ALLOW_ZERO_PTR));
 
842
  my_free((char*) global_system_variables.time_format,
 
843
          MYF(MY_ALLOW_ZERO_PTR));
 
844
  my_free((char*) global_system_variables.datetime_format,
 
845
          MYF(MY_ALLOW_ZERO_PTR));
847
846
  if (defaults_argv)
848
847
    free_defaults(defaults_argv);
849
 
  free(sys_init_connect.value);
850
 
  free(sys_init_slave.value);
 
848
  my_free(sys_init_connect.value, MYF(MY_ALLOW_ZERO_PTR));
 
849
  my_free(sys_init_slave.value, MYF(MY_ALLOW_ZERO_PTR));
 
850
  my_free(sys_var_general_log_path.value, MYF(MY_ALLOW_ZERO_PTR));
 
851
  my_free(sys_var_slow_log_path.value, MYF(MY_ALLOW_ZERO_PTR));
851
852
  free_tmpdir(&mysql_tmpdir_list);
852
 
  free(slave_load_tmpdir);
853
 
  if (opt_bin_logname)
854
 
    free(opt_bin_logname);
855
 
  if (opt_relay_logname)
856
 
    free(opt_relay_logname);
857
 
  if (opt_secure_file_priv)
858
 
    free(opt_secure_file_priv);
 
853
  my_free(slave_load_tmpdir,MYF(MY_ALLOW_ZERO_PTR));
 
854
  x_free(opt_bin_logname);
 
855
  x_free(opt_relay_logname);
 
856
  x_free(opt_secure_file_priv);
859
857
  bitmap_free(&temp_pool);
 
858
  end_slave_list();
860
859
  delete binlog_filter;
861
860
  delete rpl_filter;
862
 
 
863
 
  (void) my_delete(pidfile_name,MYF(0));        // This may not always exist
864
 
 
865
 
  if (print_message && server_start_time)
866
 
    sql_print_information(_(ER(ER_SHUTDOWN_COMPLETE)),my_progname);
 
861
  vio_end();
 
862
 
 
863
  if (!opt_bootstrap)
 
864
    (void) my_delete(pidfile_name,MYF(0));      // This may not always exist
 
865
  if (print_message && errmesg && server_start_time)
 
866
    sql_print_information(ER(ER_SHUTDOWN_COMPLETE),my_progname);
867
867
  thread_scheduler.end();
868
 
  /* Returns NULL on globerrs, we don't want to try to free that */
869
 
  //void *freeme=
870
 
  (void *)my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST);
871
 
  // TODO!!!! EPIC FAIL!!!! This sefaults if uncommented.
872
 
/*  if (freeme != NULL)
873
 
    free(freeme);  */
 
868
  finish_client_errs();
 
869
  my_free((uchar*) my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST),
 
870
          MYF(MY_WME | MY_FAE | MY_ALLOW_ZERO_PTR));
874
871
  /* Tell main we are ready */
875
872
  logger.cleanup_end();
876
873
  (void) pthread_mutex_lock(&LOCK_thread_count);
892
889
*/
893
890
static void wait_for_signal_thread_to_end()
894
891
{
895
 
  uint32_t i;
 
892
  uint i;
896
893
  /*
897
894
    Wait up to 10 seconds for signal thread to die. We use this mainly to
898
895
    avoid getting warnings that my_thread_end has not been called
899
896
  */
900
897
  for (i= 0 ; i < 100 && signal_thread_in_use; i++)
901
898
  {
902
 
    if (pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL) != ESRCH)
 
899
    if (pthread_kill(signal_thread, MYSQL_KILL_SIGNAL) != ESRCH)
903
900
      break;
904
901
    my_sleep(100);                              // Give it time to die
905
902
  }
912
909
  (void) pthread_mutex_destroy(&LOCK_lock_db);
913
910
  (void) pthread_mutex_destroy(&LOCK_open);
914
911
  (void) pthread_mutex_destroy(&LOCK_thread_count);
 
912
  (void) pthread_mutex_destroy(&LOCK_mapped_file);
915
913
  (void) pthread_mutex_destroy(&LOCK_status);
916
914
  (void) pthread_mutex_destroy(&LOCK_error_log);
 
915
  (void) pthread_mutex_destroy(&LOCK_crypt);
917
916
  (void) pthread_mutex_destroy(&LOCK_user_conn);
918
917
  (void) pthread_mutex_destroy(&LOCK_connection_count);
 
918
  (void) pthread_mutex_destroy(&LOCK_rpl_status);
 
919
  (void) pthread_cond_destroy(&COND_rpl_status);
919
920
  (void) pthread_mutex_destroy(&LOCK_active_mi);
920
921
  (void) rwlock_destroy(&LOCK_sys_init_connect);
921
922
  (void) rwlock_destroy(&LOCK_sys_init_slave);
938
939
static void set_ports()
939
940
{
940
941
  char  *env;
941
 
  if (!mysqld_port)
 
942
  if (!mysqld_port && !opt_disable_networking)
942
943
  {                                     // Get port if not from commandline
943
 
    mysqld_port= DRIZZLE_PORT;
 
944
    mysqld_port= MYSQL_PORT;
944
945
 
945
946
    /*
946
947
      if builder specifically requested a default port, use that
948
949
      only if they didn't do we check /etc/services (and, failing
949
950
      on that, fall back to the factory default of 4427).
950
951
      either default can be overridden by the environment variable
951
 
      DRIZZLE_TCP_PORT, which in turn can be overridden with command
 
952
      MYSQL_TCP_PORT, which in turn can be overridden with command
952
953
      line options.
953
954
    */
954
955
 
 
956
#if MYSQL_PORT_DEFAULT == 0
955
957
    struct  servent *serv_ptr;
956
 
    if ((serv_ptr= getservbyname("drizzle", "tcp")))
 
958
    if ((serv_ptr= getservbyname("mysql", "tcp")))
957
959
      mysqld_port= ntohs((u_short) serv_ptr->s_port); /* purecov: inspected */
958
 
 
959
 
    if ((env = getenv("DRIZZLE_TCP_PORT")))
 
960
#endif
 
961
    if ((env = getenv("MYSQL_TCP_PORT")))
960
962
      mysqld_port= (uint) atoi(env);            /* purecov: inspected */
961
 
 
962
 
    assert(mysqld_port);
963
963
  }
964
964
}
965
965
 
979
979
      /* purecov: begin tested */
980
980
      tmp_user_info= getpwnam(user);
981
981
      if ((!tmp_user_info || user_id != tmp_user_info->pw_uid) &&
982
 
          global_system_variables.log_warnings)
983
 
        sql_print_warning(_("One can only use the --user switch "
984
 
                            "if running as root\n"));
 
982
          global_system_variables.log_warnings)
 
983
        sql_print_warning(
 
984
                    "One can only use the --user switch if running as root\n");
985
985
      /* purecov: end */
986
986
    }
987
987
    return NULL;
988
988
  }
989
989
  if (!user)
990
990
  {
991
 
    sql_print_error(_("Fatal error: Please read \"Security\" section of "
992
 
                      "the manual to find out how to run mysqld as root!\n"));
993
 
    unireg_abort(1);
994
 
 
 
991
    if (!opt_bootstrap)
 
992
    {
 
993
      sql_print_error("Fatal error: Please read \"Security\" section of the manual to find out how to run mysqld as root!\n");
 
994
      unireg_abort(1);
 
995
    }
995
996
    return NULL;
996
997
  }
997
998
  /* purecov: begin tested */
1012
1013
  /* purecov: end */
1013
1014
 
1014
1015
err:
1015
 
  sql_print_error(_("Fatal error: Can't change to run as user '%s' ;  "
1016
 
                    "Please check that the user exists!\n"),user);
 
1016
  sql_print_error("Fatal error: Can't change to run as user '%s' ;  Please check that the user exists!\n",user);
1017
1017
  unireg_abort(1);
1018
1018
 
1019
1019
#ifdef PR_SET_DUMPABLE
1086
1086
 
1087
1087
static void network_init(void)
1088
1088
{
 
1089
  int   arg;
1089
1090
  int   ret;
1090
 
  uint32_t  waited;
1091
 
  uint32_t  this_wait;
1092
 
  uint32_t  retry;
 
1091
  uint  waited;
 
1092
  uint  this_wait;
 
1093
  uint  retry;
1093
1094
  char port_buf[NI_MAXSERV];
1094
 
  struct addrinfo *ai;
1095
 
  struct addrinfo *next;
1096
 
  struct addrinfo hints;
1097
 
  int error;
1098
1095
 
1099
1096
  if (thread_scheduler.init())
1100
1097
    unireg_abort(1);                    /* purecov: inspected */
1101
1098
 
1102
1099
  set_ports();
1103
1100
 
1104
 
  memset(fds, 0, sizeof(struct pollfd) * UINT8_MAX);
1105
 
  memset(&hints, 0, sizeof (hints));
1106
 
  hints.ai_flags= AI_PASSIVE;
1107
 
  hints.ai_socktype= SOCK_STREAM;
1108
 
 
1109
 
  snprintf(port_buf, NI_MAXSERV, "%d", mysqld_port);
1110
 
  error= getaddrinfo(my_bind_addr_str, port_buf, &hints, &ai);
1111
 
  if (error != 0)
1112
 
  {
1113
 
    sql_perror(ER(ER_IPSOCK_ERROR));            /* purecov: tested */
1114
 
    unireg_abort(1);                            /* purecov: tested */
1115
 
  }
1116
 
 
1117
 
  for (next= ai, pollfd_count= 0; next; next= next->ai_next, pollfd_count++)
1118
 
  {
1119
 
    int ip_sock;
1120
 
 
1121
 
    ip_sock= socket(next->ai_family, next->ai_socktype, next->ai_protocol);
1122
 
 
1123
 
    if (ip_sock == -1)
1124
 
    {
1125
 
      sql_perror(ER(ER_IPSOCK_ERROR));          /* purecov: tested */
1126
 
      unireg_abort(1);                          /* purecov: tested */
1127
 
    }
1128
 
 
1129
 
    fds[pollfd_count].fd= ip_sock;
1130
 
    fds[pollfd_count].events= POLLIN | POLLERR;
1131
 
 
1132
 
    /* Add options for our listening socket */
1133
 
    {
1134
 
      int error;
1135
 
      struct linger ling = {0, 0};
1136
 
      int flags =1;
 
1101
  if (mysqld_port != 0 && !opt_disable_networking && !opt_bootstrap)
 
1102
  {
 
1103
    struct addrinfo *ai;
 
1104
    struct addrinfo hints;
 
1105
    int error;
 
1106
 
 
1107
    bzero(&hints, sizeof (hints));
 
1108
    hints.ai_flags= AI_PASSIVE;
 
1109
    hints.ai_socktype= SOCK_STREAM;
 
1110
    hints.ai_family= AF_UNSPEC;
 
1111
 
 
1112
    snprintf(port_buf, NI_MAXSERV, "%d", mysqld_port);
 
1113
    error= getaddrinfo(my_bind_addr_str, port_buf, &hints, &ai);
 
1114
    if (error != 0)
 
1115
    {
 
1116
      sql_perror(ER(ER_IPSOCK_ERROR));          /* purecov: tested */
 
1117
      unireg_abort(1);                          /* purecov: tested */
 
1118
    }
 
1119
 
 
1120
 
 
1121
    ip_sock= socket(ai->ai_family, ai->ai_socktype,
 
1122
                    ai->ai_protocol);
 
1123
 
 
1124
    if (ip_sock == INVALID_SOCKET)
 
1125
    {
 
1126
      sql_perror(ER(ER_IPSOCK_ERROR));          /* purecov: tested */
 
1127
      unireg_abort(1);                          /* purecov: tested */
 
1128
    }
 
1129
 
 
1130
    /*
 
1131
      We should not use SO_REUSEADDR on windows as this would enable a
 
1132
      user to open two mysqld servers with the same TCP/IP port.
 
1133
    */
 
1134
    arg= 1;
 
1135
    (void) setsockopt(ip_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,sizeof(arg));
1137
1136
 
1138
1137
#ifdef IPV6_V6ONLY
1139
 
      if (next->ai_family == AF_INET6) 
1140
 
      {
1141
 
        error= setsockopt(ip_sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &flags, sizeof(flags));
1142
 
        if (error != 0)
1143
 
        {
1144
 
          perror("setsockopt");
1145
 
          assert(error == 0);
1146
 
        }
1147
 
      }
1148
 
#endif   
1149
 
      error= setsockopt(ip_sock, SOL_SOCKET, SO_REUSEADDR, (char*)&flags, sizeof(flags));
1150
 
      if (error != 0)
1151
 
      {
1152
 
        perror("setsockopt");
1153
 
        assert(error == 0);
1154
 
      }
1155
 
      error= setsockopt(ip_sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
1156
 
      if (error != 0)
1157
 
      {
1158
 
        perror("setsockopt");
1159
 
        assert(error == 0);
1160
 
      }
1161
 
      error= setsockopt(ip_sock, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
1162
 
      if (error != 0)
1163
 
      {
1164
 
        perror("setsockopt");
1165
 
        assert(error == 0);
1166
 
      }
1167
 
      error= setsockopt(ip_sock, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
1168
 
      if (error != 0)
1169
 
      {
1170
 
        perror("setsockopt");
1171
 
        assert(error == 0);
1172
 
      }
 
1138
     /*
 
1139
       For interoperability with older clients, IPv6 socket should
 
1140
       listen on both IPv6 and IPv4 wildcard addresses.
 
1141
       Turn off IPV6_V6ONLY option.
 
1142
     */
 
1143
    if (ai->ai_family == AF_INET6)
 
1144
    {
 
1145
      arg= 0;      
 
1146
      (void) setsockopt(ip_sock, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&arg,
 
1147
                sizeof(arg));
1173
1148
    }
1174
 
 
1175
 
 
 
1149
#endif
1176
1150
    /*
1177
1151
      Sometimes the port is not released fast enough when stopping and
1178
1152
      restarting the server. This happens quite often with the test suite
1183
1157
    */
1184
1158
    for (waited= 0, retry= 1; ; retry++, waited+= this_wait)
1185
1159
    {
1186
 
      if (((ret= bind(ip_sock, next->ai_addr, next->ai_addrlen)) >= 0 ) ||
1187
 
          (errno != EADDRINUSE) ||
 
1160
      if (((ret= bind(ip_sock, ai->ai_addr, ai->ai_addrlen)) >= 0 ) ||
 
1161
          (socket_errno != SOCKET_EADDRINUSE) ||
1188
1162
          (waited >= mysqld_port_timeout))
1189
1163
        break;
1190
 
      sql_print_information(_("Retrying bind on TCP/IP port %u"), mysqld_port);
 
1164
      sql_print_information("Retrying bind on TCP/IP port %u", mysqld_port);
1191
1165
      this_wait= retry * retry / 3 + 1;
1192
1166
      sleep(this_wait);
1193
1167
    }
 
1168
    freeaddrinfo(ai);
1194
1169
    if (ret < 0)
1195
1170
    {
1196
 
      sql_perror(_("Can't start server: Bind on TCP/IP port"));
1197
 
      sql_print_error(_("Do you already have another drizzled server running "
1198
 
                        "on port: %d ?"),mysqld_port);
 
1171
      sql_perror("Can't start server: Bind on TCP/IP port");
 
1172
      sql_print_error("Do you already have another mysqld server running on port: %d ?",mysqld_port);
1199
1173
      unireg_abort(1);
1200
1174
    }
1201
1175
    if (listen(ip_sock,(int) back_log) < 0)
1202
1176
    {
1203
 
      sql_perror(_("Can't start server: listen() on TCP/IP port"));
1204
 
      sql_print_error(_("listen() on TCP/IP failed with error %d"),
1205
 
                      errno);
 
1177
      sql_perror("Can't start server: listen() on TCP/IP port");
 
1178
      sql_print_error("listen() on TCP/IP failed with error %d",
 
1179
                      socket_errno);
1206
1180
      unireg_abort(1);
1207
1181
    }
1208
1182
  }
1209
1183
 
1210
 
  freeaddrinfo(ai);
1211
 
  return;
 
1184
  return;;
1212
1185
}
1213
1186
 
1214
1187
/**
1221
1194
  @note
1222
1195
    For the connection that is doing shutdown, this is called twice
1223
1196
*/
1224
 
void close_connection(THD *thd, uint32_t errcode, bool lock)
 
1197
void close_connection(THD *thd, uint errcode, bool lock)
1225
1198
{
1226
1199
  st_vio *vio;
1227
1200
  if (lock)
1231
1204
  {
1232
1205
    if (errcode)
1233
1206
      net_send_error(thd, errcode, ER(errcode)); /* purecov: inspected */
1234
 
    net_close(&(thd->net));             /* vio is freed in delete thd */
 
1207
    vio_close(vio);                     /* vio is freed in delete thd */
1235
1208
  }
1236
1209
  if (lock)
1237
1210
    (void) pthread_mutex_unlock(&LOCK_thread_count);
1241
1214
 
1242
1215
/** Called when a thread is aborted. */
1243
1216
/* ARGSUSED */
1244
 
extern "C" RETSIGTYPE end_thread_signal(int sig __attribute__((unused)))
 
1217
extern "C" sig_handler end_thread_signal(int sig __attribute__((unused)))
1245
1218
{
1246
1219
  THD *thd=current_thd;
1247
 
  if (thd)
 
1220
  if (thd && ! thd->bootstrap)
1248
1221
  {
1249
1222
    statistic_increment(killed_threads, &LOCK_status);
1250
1223
    thread_scheduler.end_thread(thd,0);         /* purecov: inspected */
1388
1361
  @todo
1389
1362
    One should have to fix that thr_alarm know about this thread too.
1390
1363
*/
1391
 
extern "C" RETSIGTYPE abort_thread(int sig __attribute__((unused)))
 
1364
extern "C" sig_handler abort_thread(int sig __attribute__((unused)))
1392
1365
{
1393
1366
  THD *thd=current_thd;
1394
1367
  if (thd)
1406
1379
#endif
1407
1380
 
1408
1381
 
1409
 
extern "C" RETSIGTYPE handle_segfault(int sig)
 
1382
extern "C" sig_handler handle_segfault(int sig)
1410
1383
{
1411
1384
  time_t curr_time;
1412
1385
  struct tm tm;
 
1386
  THD *thd=current_thd;
1413
1387
 
1414
1388
  /*
1415
1389
    Strictly speaking, one needs a mutex here
1419
1393
  */
1420
1394
  if (segfaulted)
1421
1395
  {
1422
 
    fprintf(stderr, _("Fatal " SIGNAL_FMT " while backtracing\n"), sig);
 
1396
    fprintf(stderr, "Fatal " SIGNAL_FMT " while backtracing\n", sig);
1423
1397
    exit(1);
1424
1398
  }
1425
1399
 
1428
1402
  curr_time= my_time(0);
1429
1403
  localtime_r(&curr_time, &tm);
1430
1404
 
1431
 
  fprintf(stderr,"%02d%02d%02d %2d:%02d:%02d - mysqld got "
1432
 
          SIGNAL_FMT " ;\n"
1433
 
          "This could be because you hit a bug. It is also possible that "
1434
 
          "this binary\n or one of the libraries it was linked against is "
1435
 
          "corrupt, improperly built,\n or misconfigured. This error can "
1436
 
          "also be caused by malfunctioning hardware.\n",
 
1405
  fprintf(stderr,"\
 
1406
%02d%02d%02d %2d:%02d:%02d - mysqld got " SIGNAL_FMT " ;\n\
 
1407
This could be because you hit a bug. It is also possible that this binary\n\
 
1408
or one of the libraries it was linked against is corrupt, improperly built,\n\
 
1409
or misconfigured. This error can also be caused by malfunctioning hardware.\n",
1437
1410
          tm.tm_year % 100, tm.tm_mon+1, tm.tm_mday,
1438
1411
          tm.tm_hour, tm.tm_min, tm.tm_sec,
1439
 
          sig);
1440
 
  fprintf(stderr, _("We will try our best to scrape up some info that "
1441
 
                    "will hopefully help diagnose\n"
1442
 
                    "the problem, but since we have already crashed, "
1443
 
                    "something is definitely wrong\nand this may fail.\n\n"));
1444
 
  fprintf(stderr, "key_buffer_size=%u\n",
1445
 
          (uint32_t) dflt_key_cache->key_cache_mem_size);
 
1412
          sig);
 
1413
  fprintf(stderr, "\
 
1414
We will try our best to scrape up some info that will hopefully help diagnose\n\
 
1415
the problem, but since we have already crashed, something is definitely wrong\n\
 
1416
and this may fail.\n\n");
 
1417
  fprintf(stderr, "key_buffer_size=%lu\n",
 
1418
          (ulong) dflt_key_cache->key_cache_mem_size);
1446
1419
  fprintf(stderr, "read_buffer_size=%ld\n", (long) global_system_variables.read_buff_size);
1447
 
  fprintf(stderr, "max_used_connections=%u\n", max_used_connections);
 
1420
  fprintf(stderr, "max_used_connections=%lu\n", max_used_connections);
1448
1421
  fprintf(stderr, "max_threads=%u\n", thread_scheduler.max_threads);
1449
1422
  fprintf(stderr, "thread_count=%u\n", thread_count);
1450
1423
  fprintf(stderr, "connection_count=%u\n", connection_count);
1451
 
  fprintf(stderr, _("It is possible that mysqld could use up to \n"
1452
 
                    "key_buffer_size + (read_buffer_size + "
1453
 
                    "sort_buffer_size)*max_threads = %lu K\n"
1454
 
                    "bytes of memory\n"
1455
 
                    "Hope that's ok; if not, decrease some variables in the "
1456
 
                    "equation.\n\n"),
1457
 
                    ((uint32_t) dflt_key_cache->key_cache_mem_size +
1458
 
                     (global_system_variables.read_buff_size +
1459
 
                      global_system_variables.sortbuff_size) *
1460
 
                     thread_scheduler.max_threads +
 
1424
  fprintf(stderr, "It is possible that mysqld could use up to \n\
 
1425
key_buffer_size + (read_buffer_size + sort_buffer_size)*max_threads = %lu K\n\
 
1426
bytes of memory\n", ((ulong) dflt_key_cache->key_cache_mem_size +
 
1427
                     (global_system_variables.read_buff_size +
 
1428
                      global_system_variables.sortbuff_size) *
 
1429
                     thread_scheduler.max_threads +
1461
1430
                     max_connections * sizeof(THD)) / 1024);
 
1431
  fprintf(stderr, "Hope that's ok; if not, decrease some variables in the equation.\n\n");
1462
1432
 
1463
1433
#ifdef HAVE_STACKTRACE
1464
 
  THD *thd= current_thd;
1465
 
 
1466
1434
  if (!(test_flags & TEST_NO_STACKTRACE))
1467
1435
  {
1468
1436
    fprintf(stderr,"thd: 0x%lx\n",(long) thd);
1469
 
    fprintf(stderr,_("Attempting backtrace. You can use the following "
1470
 
                     "information to find out\n"
1471
 
                     "where mysqld died. If you see no messages after this, "
1472
 
                     "something went\n"
1473
 
                     "terribly wrong...\n"));
1474
 
    print_stacktrace(thd ? (unsigned char*) thd->thread_stack : (unsigned char*) 0,
 
1437
    fprintf(stderr,"\
 
1438
Attempting backtrace. You can use the following information to find out\n\
 
1439
where mysqld died. If you see no messages after this, something went\n\
 
1440
terribly wrong...\n");  
 
1441
    print_stacktrace(thd ? (uchar*) thd->thread_stack : (uchar*) 0,
1475
1442
                     my_thread_stack_size);
1476
1443
  }
1477
1444
  if (thd)
1494
1461
      kreason= "KILLED_NO_VALUE";
1495
1462
      break;
1496
1463
    }
1497
 
    fprintf(stderr, _("Trying to get some variables.\n"
1498
 
                      "Some pointers may be invalid and cause the "
1499
 
                      "dump to abort...\n"));
 
1464
    fprintf(stderr, "Trying to get some variables.\n\
 
1465
Some pointers may be invalid and cause the dump to abort...\n");
1500
1466
    safe_print_str("thd->query", thd->query, 1024);
1501
 
    fprintf(stderr, "thd->thread_id=%"PRIu32"\n", (uint32_t) thd->thread_id);
 
1467
    fprintf(stderr, "thd->thread_id=%lu\n", (ulong) thd->thread_id);
1502
1468
    fprintf(stderr, "thd->killed=%s\n", kreason);
1503
1469
  }
 
1470
  fprintf(stderr, "\
 
1471
The manual page at http://dev.mysql.com/doc/mysql/en/crashing.html contains\n\
 
1472
information that should help you find out what is causing the crash.\n");
1504
1473
  fflush(stderr);
1505
1474
#endif /* HAVE_STACKTRACE */
1506
1475
 
1507
1476
#ifdef HAVE_INITGROUPS
1508
1477
  if (calling_initgroups)
1509
 
    fprintf(stderr, _("\nThis crash occured while the server was calling "
1510
 
                      "initgroups(). This is\n"
1511
 
                      "often due to the use of a drizzled that is statically "
1512
 
                      "linked against glibc\n"
1513
 
                      "and configured to use LDAP in /etc/nsswitch.conf. "
1514
 
                      "You will need to either\n"
1515
 
                      "upgrade to a version of glibc that does not have this "
1516
 
                      "problem (2.3.4 or\n"
1517
 
                      "later when used with nscd), disable LDAP in your "
1518
 
                      "nsswitch.conf, or use a\n"
1519
 
                      "drizzled that is not statically linked.\n"));
 
1478
    fprintf(stderr, "\n\
 
1479
This crash occured while the server was calling initgroups(). This is\n\
 
1480
often due to the use of a mysqld that is statically linked against glibc\n\
 
1481
and configured to use LDAP in /etc/nsswitch.conf. You will need to either\n\
 
1482
upgrade to a version of glibc that does not have this problem (2.3.4 or\n\
 
1483
later when used with nscd), disable LDAP in your nsswitch.conf, or use a\n\
 
1484
mysqld that is not statically linked.\n");
1520
1485
#endif
1521
1486
 
1522
1487
  if (thd_lib_detected == THD_LIB_LT && !getenv("LD_ASSUME_KERNEL"))
1523
 
    fprintf(stderr,
1524
 
            _("\nYou are running a statically-linked LinuxThreads binary "
1525
 
              "on an NPTL system.\n"
1526
 
              "This can result in crashes on some distributions due "
1527
 
              "to LT/NPTL conflicts.\n"
1528
 
              "You should either build a dynamically-linked binary, or force "
1529
 
              "LinuxThreads\n"
1530
 
              "to be used with the LD_ASSUME_KERNEL environment variable. "
1531
 
              "Please consult\n"
1532
 
              "the documentation for your distribution on how to do that.\n"));
1533
 
 
 
1488
    fprintf(stderr,"\n\
 
1489
You are running a statically-linked LinuxThreads binary on an NPTL system.\n\
 
1490
This can result in crashes on some distributions due to LT/NPTL conflicts.\n\
 
1491
You should either build a dynamically-linked binary, or force LinuxThreads\n\
 
1492
to be used with the LD_ASSUME_KERNEL environment variable. Please consult\n\
 
1493
the documentation for your distribution on how to do that.\n");
 
1494
  
1534
1495
  if (locked_in_memory)
1535
1496
  {
1536
 
    fprintf(stderr,
1537
 
            _("\nThe '--memlock' argument, which was enabled, uses system "
1538
 
              "calls that are\n"
1539
 
              "unreliable and unstable on some operating systems and "
1540
 
              "operating-system\n"
1541
 
              "versions (notably, some versions of Linux).  "
1542
 
              "This crash could be due to use\n"
1543
 
              "of those buggy OS calls.  You should consider whether you "
1544
 
              "really need the\n"
1545
 
              "'--memlock' parameter and/or consult the OS "
1546
 
              "distributor about 'mlockall'\n bugs.\n"));
 
1497
    fprintf(stderr, "\n\
 
1498
The \"--memlock\" argument, which was enabled, uses system calls that are\n\
 
1499
unreliable and unstable on some operating systems and operating-system\n\
 
1500
versions (notably, some versions of Linux).  This crash could be due to use\n\
 
1501
of those buggy OS calls.  You should consider whether you really need the\n\
 
1502
\"--memlock\" parameter and/or consult the OS distributer about \"mlockall\"\n\
 
1503
bugs.\n");
1547
1504
  }
1548
1505
 
1549
1506
#ifdef HAVE_WRITE_CORE
1550
1507
  if (test_flags & TEST_CORE_ON_SIGNAL)
1551
1508
  {
1552
 
    fprintf(stderr, _("Writing a core file\n"));
 
1509
    fprintf(stderr, "Writing a core file\n");
1553
1510
    fflush(stderr);
1554
1511
    write_core(sig);
1555
1512
  }
1596
1553
    STRUCT_RLIMIT rl;
1597
1554
    rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
1598
1555
    if (setrlimit(RLIMIT_CORE, &rl) && global_system_variables.log_warnings)
1599
 
      sql_print_warning(_("setrlimit could not change the size of core files "
1600
 
                          "to 'infinity';  We may not be able to generate a "
1601
 
                          "core file on signals"));
 
1556
      sql_print_warning("setrlimit could not change the size of core files to 'infinity';  We may not be able to generate a core file on signals");
1602
1557
  }
1603
1558
#endif
1604
1559
  (void) sigemptyset(&set);
1645
1600
  (void) pthread_attr_init(&thr_attr);
1646
1601
  pthread_attr_setscope(&thr_attr, PTHREAD_SCOPE_SYSTEM);
1647
1602
  (void) pthread_attr_setdetachstate(&thr_attr, PTHREAD_CREATE_DETACHED);
 
1603
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
1648
1604
  {
1649
1605
    struct sched_param tmp_sched_param;
1650
1606
 
1664
1620
  (void) pthread_mutex_lock(&LOCK_thread_count);
1665
1621
  if ((error=pthread_create(&signal_thread,&thr_attr,signal_hand,0)))
1666
1622
  {
1667
 
    sql_print_error(_("Can't create interrupt-thread (error %d, errno: %d)"),
1668
 
                    error,errno);
 
1623
    sql_print_error("Can't create interrupt-thread (error %d, errno: %d)",
 
1624
                    error,errno);
1669
1625
    exit(1);
1670
1626
  }
1671
1627
  (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
1709
1665
  (void) sigaddset(&set,SIGTSTP);
1710
1666
 
1711
1667
  /* Save pid to this process (or thread on Linux) */
1712
 
  create_pid_file();
 
1668
  if (!opt_bootstrap)
 
1669
    create_pid_file();
1713
1670
 
1714
1671
#ifdef HAVE_STACK_TRACE_ON_SEGV
1715
1672
  if (opt_do_pstack)
1716
1673
  {
1717
 
    sprintf(pstack_file_name,"mysqld-%lu-%%d-%%d.backtrace", (uint32_t)getpid());
 
1674
    sprintf(pstack_file_name,"mysqld-%lu-%%d-%%d.backtrace", (ulong)getpid());
1718
1675
    pstack_install_segv_action(pstack_file_name);
1719
1676
  }
1720
1677
#endif /* HAVE_STACK_TRACE_ON_SEGV */
1752
1709
    case SIGQUIT:
1753
1710
    case SIGKILL:
1754
1711
#ifdef EXTRA_DEBUG
1755
 
      sql_print_information(_("Got signal %d to shutdown mysqld"),sig);
 
1712
      sql_print_information("Got signal %d to shutdown mysqld",sig);
1756
1713
#endif
1757
1714
      /* switch to the old log message processing */
 
1715
      logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,
 
1716
                          opt_log ? LOG_FILE:LOG_NONE);
1758
1717
      if (!abort_loop)
1759
1718
      {
1760
1719
        abort_loop=1;                           // mark abort for threads
1761
1720
#ifdef USE_ONE_SIGNAL_HAND
1762
1721
        pthread_t tmp;
 
1722
        if (!(opt_specialflag & SPECIAL_NO_PRIOR))
1763
1723
        {
1764
1724
          struct sched_param tmp_sched_param;
1765
1725
 
1769
1729
        }
1770
1730
        if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
1771
1731
                           (void*) &sig))
1772
 
          sql_print_error(_("Can't create thread to kill server"));
 
1732
          sql_print_error("Can't create thread to kill server");
1773
1733
#else
1774
1734
        kill_server((void*) sig);       // MIT THREAD has a alarm thread
1775
1735
#endif
1783
1743
                     (REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
1784
1744
                      REFRESH_GRANT |
1785
1745
                      REFRESH_THREADS | REFRESH_HOSTS),
1786
 
                     (TableList*) 0, &not_used); // Flush logs
 
1746
                     (TABLE_LIST*) 0, &not_used); // Flush logs
 
1747
      }
 
1748
      /* reenable logs after the options were reloaded */
 
1749
      if (log_output_options & LOG_NONE)
 
1750
      {
 
1751
        logger.set_handlers(LOG_FILE,
 
1752
                            opt_slow_log ? LOG_TABLE : LOG_NONE,
 
1753
                            opt_log ? LOG_TABLE : LOG_NONE);
 
1754
      }
 
1755
      else
 
1756
      {
 
1757
        logger.set_handlers(LOG_FILE,
 
1758
                            opt_slow_log ? log_output_options : LOG_NONE,
 
1759
                            opt_log ? log_output_options : LOG_NONE);
1787
1760
      }
1788
1761
      break;
1789
1762
#ifdef USE_ONE_SIGNAL_HAND
1793
1766
#endif
1794
1767
    default:
1795
1768
#ifdef EXTRA_DEBUG
1796
 
      sql_print_warning(_("Got signal: %d  error: %d"),sig,error); /* purecov: tested */
 
1769
      sql_print_warning("Got signal: %d  error: %d",sig,error); /* purecov: tested */
1797
1770
#endif
1798
1771
      break;                                    /* purecov: tested */
1799
1772
    }
1801
1774
  return(0);                                    /* purecov: deadcode */
1802
1775
}
1803
1776
 
1804
 
static void check_data_home(const char *path __attribute__((unused)))
 
1777
static void check_data_home(const char *path __attribute__((__unused__)))
1805
1778
{}
1806
1779
 
1807
1780
#endif  /* __WIN__*/
1812
1785
  for the client.
1813
1786
*/
1814
1787
/* ARGSUSED */
1815
 
extern "C" void my_message_sql(uint32_t error, const char *str, myf MyFlags);
 
1788
extern "C" void my_message_sql(uint error, const char *str, myf MyFlags);
1816
1789
 
1817
 
void my_message_sql(uint32_t error, const char *str, myf MyFlags)
 
1790
void my_message_sql(uint error, const char *str, myf MyFlags)
1818
1791
{
1819
1792
  THD *thd;
1820
1793
  /*
1826
1799
    if (MyFlags & ME_FATALERROR)
1827
1800
      thd->is_fatal_error= 1;
1828
1801
 
 
1802
#ifdef BUG_36098_FIXED
 
1803
    mysql_audit_general(thd,MYSQL_AUDIT_GENERAL_ERROR,error,my_time(0),
 
1804
                        0,0,str,str ? strlen(str) : 0,
 
1805
                        thd->query,thd->query_length,
 
1806
                        thd->variables.character_set_client,
 
1807
                        thd->row_count);
 
1808
#endif
 
1809
 
 
1810
 
1829
1811
    /*
1830
1812
      TODO: There are two exceptions mechanism (THD and sp_rcontext),
1831
1813
      this could be improved by having a common stack of handlers.
1832
1814
    */
1833
1815
    if (thd->handle_error(error, str,
1834
 
                          DRIZZLE_ERROR::WARN_LEVEL_ERROR))
 
1816
                          MYSQL_ERROR::WARN_LEVEL_ERROR))
1835
1817
      return;;
1836
1818
 
1837
1819
    thd->is_slave_error=  1; // needed to catch query errors during replication
1860
1842
        inside push_warning.
1861
1843
      */
1862
1844
      thd->no_warnings_for_error= true;
1863
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_ERROR, error, str);
 
1845
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error, str);
1864
1846
      thd->no_warnings_for_error= false;
1865
1847
    }
1866
1848
  }
1881
1863
 
1882
1864
void my_str_free_mysqld(void *ptr)
1883
1865
{
1884
 
  free((unsigned char*)ptr);
 
1866
  my_free((uchar*)ptr, MYF(MY_FAE));
1885
1867
}
1886
1868
 
1887
1869
 
1888
1870
static const char *load_default_groups[]= {
1889
 
"mysqld","server", DRIZZLE_BASE_VERSION, 0, 0};
 
1871
"mysqld","server", MYSQL_BASE_VERSION, 0, 0};
1890
1872
 
1891
1873
 
1892
1874
/**
1905
1887
    1 error
1906
1888
*/
1907
1889
 
1908
 
static bool init_global_datetime_format(enum enum_drizzle_timestamp_type format_type,
 
1890
static bool init_global_datetime_format(timestamp_type format_type,
1909
1891
                                        DATE_TIME_FORMAT **var_ptr)
1910
1892
{
1911
1893
  /* Get command line option */
1923
1905
  }
1924
1906
  if (!(*var_ptr= date_time_format_make(format_type, str, strlen(str))))
1925
1907
  {
1926
 
    fprintf(stderr, _("Wrong date/time format specifier: %s\n"), str);
 
1908
    fprintf(stderr, "Wrong date/time format specifier: %s\n", str);
1927
1909
    return 1;
1928
1910
  }
1929
1911
  return 0;
1933
1915
  {"admin_commands",       (char*) offsetof(STATUS_VAR, com_other), SHOW_LONG_STATUS},
1934
1916
  {"assign_to_keycache",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ASSIGN_TO_KEYCACHE]), SHOW_LONG_STATUS},
1935
1917
  {"alter_db",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB]), SHOW_LONG_STATUS},
 
1918
  {"alter_db_upgrade",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB_UPGRADE]), SHOW_LONG_STATUS},
1936
1919
  {"alter_table",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_TABLE]), SHOW_LONG_STATUS},
1937
1920
  {"analyze",              (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ANALYZE]), SHOW_LONG_STATUS},
1938
1921
  {"begin",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BEGIN]), SHOW_LONG_STATUS},
1971
1954
  {"savepoint",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SAVEPOINT]), SHOW_LONG_STATUS},
1972
1955
  {"select",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SELECT]), SHOW_LONG_STATUS},
1973
1956
  {"set_option",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SET_OPTION]), SHOW_LONG_STATUS},
 
1957
  {"show_binlog_events",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOG_EVENTS]), SHOW_LONG_STATUS},
1974
1958
  {"show_binlogs",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOGS]), SHOW_LONG_STATUS},
 
1959
  {"show_charsets",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CHARSETS]), SHOW_LONG_STATUS},
 
1960
  {"show_collations",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLLATIONS]), SHOW_LONG_STATUS},
1975
1961
  {"show_create_db",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE_DB]), SHOW_LONG_STATUS},
1976
1962
  {"show_create_table",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE]), SHOW_LONG_STATUS},
1977
1963
  {"show_databases",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_DATABASES]), SHOW_LONG_STATUS},
1983
1969
  {"show_open_tables",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_OPEN_TABLES]), SHOW_LONG_STATUS},
1984
1970
  {"show_plugins",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PLUGINS]), SHOW_LONG_STATUS},
1985
1971
  {"show_processlist",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PROCESSLIST]), SHOW_LONG_STATUS},
 
1972
  {"show_slave_hosts",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_HOSTS]), SHOW_LONG_STATUS},
1986
1973
  {"show_slave_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_STAT]), SHOW_LONG_STATUS},
1987
1974
  {"show_status",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},
1988
1975
  {"show_table_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLE_STATUS]), SHOW_LONG_STATUS},
1995
1982
  {"unlock_tables",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UNLOCK_TABLES]), SHOW_LONG_STATUS},
1996
1983
  {"update",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE]), SHOW_LONG_STATUS},
1997
1984
  {"update_multi",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE_MULTI]), SHOW_LONG_STATUS},
1998
 
  {NULL, NULL, SHOW_LONG}
 
1985
  {NullS, NullS, SHOW_LONG}
1999
1986
};
2000
1987
 
2001
1988
static int init_common_variables(const char *conf_file_name, int argc,
2002
1989
                                 char **argv, const char **groups)
2003
1990
{
 
1991
  char buff[FN_REFLEN], *s;
2004
1992
  umask(((~my_umask) & 0666));
2005
1993
  my_decimal_set_zero(&decimal_zero); // set decimal_zero constant;
2006
1994
  tzset();                      // Set tzname
2007
1995
 
2008
 
  max_system_variables.pseudo_thread_id= UINT32_MAX;
 
1996
  max_system_variables.pseudo_thread_id= (ulong)~0;
2009
1997
  server_start_time= flush_status_time= my_time(0);
2010
1998
  rpl_filter= new Rpl_filter;
2011
1999
  binlog_filter= new Rpl_filter;
2012
 
  if (!rpl_filter || !binlog_filter)
 
2000
  if (!rpl_filter || !binlog_filter) 
2013
2001
  {
2014
2002
    sql_perror("Could not allocate replication and binlog filters");
2015
2003
    exit(1);
2037
2025
  global_system_variables.time_zone= my_tz_SYSTEM;
2038
2026
 
2039
2027
  /*
2040
 
    Init mutexes for the global DRIZZLE_BIN_LOG objects.
 
2028
    Init mutexes for the global MYSQL_BIN_LOG objects.
2041
2029
    As safe_mutex depends on what MY_INIT() does, we can't init the mutexes of
2042
 
    global DRIZZLE_BIN_LOGs in their constructors, because then they would be
 
2030
    global MYSQL_BIN_LOGs in their constructors, because then they would be
2043
2031
    inited before MY_INIT(). So we do it here.
2044
2032
  */
2045
2033
  mysql_bin_log.init_pthread_objects();
2047
2035
  if (gethostname(glob_hostname,sizeof(glob_hostname)) < 0)
2048
2036
  {
2049
2037
    strmake(glob_hostname, STRING_WITH_LEN("localhost"));
2050
 
    sql_print_warning(_("gethostname failed, using '%s' as hostname"),
 
2038
    sql_print_warning("gethostname failed, using '%s' as hostname",
2051
2039
                      glob_hostname);
2052
2040
    strmake(pidfile_name, STRING_WITH_LEN("mysql"));
2053
2041
  }
2054
2042
  else
2055
2043
  strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
2056
 
  my_stpcpy(fn_ext(pidfile_name),".pid");               // Add proper extension
 
2044
  strmov(fn_ext(pidfile_name),".pid");          // Add proper extension
2057
2045
 
2058
2046
  /*
2059
2047
    Add server status variables to the dynamic list of
2073
2061
 
2074
2062
  /* connections and databases needs lots of files */
2075
2063
  {
2076
 
    uint32_t files, wanted_files, max_open_files;
 
2064
    uint files, wanted_files, max_open_files;
2077
2065
 
2078
2066
    /* MyISAM requires two file handles per table. */
2079
2067
    wanted_files= 10+max_connections+table_cache_size*2;
2087
2075
      can't get max_connections*5 but still got no less than was
2088
2076
      requested (value of wanted_files).
2089
2077
    */
2090
 
    max_open_files= cmax(cmax((uint32_t)wanted_files, max_connections*5),
2091
 
                         open_files_limit);
 
2078
    max_open_files= max(max(wanted_files, max_connections*5),
 
2079
                        open_files_limit);
2092
2080
    files= my_set_max_open_files(max_open_files);
2093
2081
 
2094
2082
    if (files < wanted_files)
2099
2087
          If we have requested too much file handles than we bring
2100
2088
          max_connections in supported bounds.
2101
2089
        */
2102
 
        max_connections= (uint32_t) cmin((uint32_t)files-10-TABLE_OPEN_CACHE_MIN*2,
 
2090
        max_connections= (ulong) min(files-10-TABLE_OPEN_CACHE_MIN*2,
2103
2091
                                     max_connections);
2104
2092
        /*
2105
2093
          Decrease table_cache_size according to max_connections, but
2106
 
          not below TABLE_OPEN_CACHE_MIN.  Outer cmin() ensures that we
 
2094
          not below TABLE_OPEN_CACHE_MIN.  Outer min() ensures that we
2107
2095
          never increase table_cache_size automatically (that could
2108
2096
          happen if max_connections is decreased above).
2109
2097
        */
2110
 
        table_cache_size= (uint32_t) cmin(cmax((files-10-max_connections)/2,
2111
 
                                          (uint32_t)TABLE_OPEN_CACHE_MIN),
 
2098
        table_cache_size= (ulong) min(max((files-10-max_connections)/2,
 
2099
                                          TABLE_OPEN_CACHE_MIN),
2112
2100
                                      table_cache_size);
2113
 
        if (global_system_variables.log_warnings)
2114
 
          sql_print_warning(_("Changed limits: max_open_files: %u  "
2115
 
                              "max_connections: %ld  table_cache: %ld"),
2116
 
                            files, max_connections, table_cache_size);
 
2101
        if (global_system_variables.log_warnings)
 
2102
          sql_print_warning("Changed limits: max_open_files: %u  max_connections: %ld  table_cache: %ld",
 
2103
                        files, max_connections, table_cache_size);
2117
2104
      }
2118
2105
      else if (global_system_variables.log_warnings)
2119
 
        sql_print_warning(_("Could not increase number of max_open_files "
2120
 
                            "to more than %u (request: %u)"),
2121
 
                          files, wanted_files);
 
2106
        sql_print_warning("Could not increase number of max_open_files to more than %u (request: %u)", files, wanted_files);
2122
2107
    }
2123
2108
    open_files_limit= files;
2124
2109
  }
2125
 
  unireg_init(0); /* Set up extern variabels */
 
2110
  unireg_init(opt_specialflag); /* Set up extern variabels */
2126
2111
  if (init_errmessage())        /* Read error messages from file */
2127
2112
    return 1;
 
2113
  init_client_errs();
2128
2114
  lex_init();
2129
2115
  if (item_create_init())
2130
2116
    return 1;
2133
2119
    return 1;
2134
2120
  if (init_replication_sys_vars())
2135
2121
    return 1;
 
2122
  mysys_uses_curses=0;
2136
2123
  /*
2137
2124
    Process a comma-separated character set list and choose
2138
2125
    the first available character set. This is mostly for
2162
2149
 
2163
2150
  if (default_collation_name)
2164
2151
  {
2165
 
    const CHARSET_INFO * const default_collation=
2166
 
      get_charset_by_name(default_collation_name, MYF(0));
 
2152
    CHARSET_INFO *default_collation;
 
2153
    default_collation= get_charset_by_name(default_collation_name, MYF(0));
2167
2154
    if (!default_collation)
2168
2155
    {
2169
 
      sql_print_error(_(ER(ER_UNKNOWN_COLLATION)), default_collation_name);
 
2156
      sql_print_error(ER(ER_UNKNOWN_COLLATION), default_collation_name);
2170
2157
      return 1;
2171
2158
    }
2172
2159
    if (!my_charset_same(default_charset_info, default_collation))
2173
2160
    {
2174
 
      sql_print_error(_(ER(ER_COLLATION_CHARSET_MISMATCH)),
2175
 
                      default_collation_name,
2176
 
                      default_charset_info->csname);
 
2161
      sql_print_error(ER(ER_COLLATION_CHARSET_MISMATCH),
 
2162
                      default_collation_name,
 
2163
                      default_charset_info->csname);
2177
2164
      return 1;
2178
2165
    }
2179
2166
    default_charset_info= default_collation;
2188
2175
  global_system_variables.optimizer_use_mrr= 1;
2189
2176
  global_system_variables.optimizer_switch= 0;
2190
2177
 
2191
 
  if (!(character_set_filesystem=
 
2178
  if (!(character_set_filesystem= 
2192
2179
        get_charset_by_csname(character_set_filesystem_name,
2193
2180
                              MY_CS_PRIMARY, MYF(MY_WME))))
2194
2181
    return 1;
2197
2184
  if (!(my_default_lc_time_names=
2198
2185
        my_locale_by_name(lc_time_names_name)))
2199
2186
  {
2200
 
    sql_print_error(_("Unknown locale: '%s'"), lc_time_names_name);
 
2187
    sql_print_error("Unknown locale: '%s'", lc_time_names_name);
2201
2188
    return 1;
2202
2189
  }
2203
2190
  global_system_variables.lc_time_names= my_default_lc_time_names;
2204
 
 
 
2191
  
2205
2192
  sys_init_connect.value_length= 0;
2206
2193
  if ((sys_init_connect.value= opt_init_connect))
2207
2194
    sys_init_connect.value_length= strlen(opt_init_connect);
2214
2201
  else
2215
2202
    sys_init_slave.value=my_strdup("",MYF(0));
2216
2203
 
 
2204
  /* check log options and issue warnings if needed */
 
2205
  if (opt_log && opt_logname && !(log_output_options & LOG_FILE) &&
 
2206
      !(log_output_options & LOG_NONE))
 
2207
    sql_print_warning("Although a path was specified for the "
 
2208
                      "--log option, log tables are used. "
 
2209
                      "To enable logging to files use the --log-output option.");
 
2210
 
 
2211
  if (opt_slow_log && opt_slow_logname && !(log_output_options & LOG_FILE)
 
2212
      && !(log_output_options & LOG_NONE))
 
2213
    sql_print_warning("Although a path was specified for the "
 
2214
                      "--log-slow-queries option, log tables are used. "
 
2215
                      "To enable logging to files use the --log-output=file option.");
 
2216
 
 
2217
  s= opt_logname ? opt_logname : make_default_log_name(buff, ".log");
 
2218
  sys_var_general_log_path.value= my_strdup(s, MYF(0));
 
2219
  sys_var_general_log_path.value_length= strlen(s);
 
2220
 
 
2221
  s= opt_slow_logname ? opt_slow_logname : make_default_log_name(buff, "-slow.log");
 
2222
  sys_var_slow_log_path.value= my_strdup(s, MYF(0));
 
2223
  sys_var_slow_log_path.value_length= strlen(s);
 
2224
 
2217
2225
  if (use_temp_pool && bitmap_init(&temp_pool,0,1024,1))
2218
2226
    return 1;
2219
2227
  if (my_database_names_init())
2220
2228
    return 1;
2221
2229
 
 
2230
  /*
 
2231
    Ensure that lower_case_table_names is set on system where we have case
 
2232
    insensitive names.  If this is not done the users MyISAM tables will
 
2233
    get corrupted if accesses with names of different case.
 
2234
  */
 
2235
  lower_case_file_system= test_if_case_insensitive(mysql_real_data_home);
 
2236
  if (!lower_case_table_names && lower_case_file_system == 1)
 
2237
  {
 
2238
    if (lower_case_table_names_used)
 
2239
    {
 
2240
      if (global_system_variables.log_warnings)
 
2241
        sql_print_warning("\
 
2242
You have forced lower_case_table_names to 0 through a command-line \
 
2243
option, even though your file system '%s' is case insensitive.  This means \
 
2244
that you can corrupt a MyISAM table by accessing it with different cases. \
 
2245
You should consider changing lower_case_table_names to 1 or 2",
 
2246
                        mysql_real_data_home);
 
2247
    }
 
2248
    else
 
2249
    {
 
2250
      if (global_system_variables.log_warnings)
 
2251
        sql_print_warning("Setting lower_case_table_names=2 because file system for %s is case insensitive", mysql_real_data_home);
 
2252
      lower_case_table_names= 2;
 
2253
    }
 
2254
  }
 
2255
  else if (lower_case_table_names == 2 &&
 
2256
           !(lower_case_file_system=
 
2257
             (test_if_case_insensitive(mysql_real_data_home) == 1)))
 
2258
  {
 
2259
    if (global_system_variables.log_warnings)
 
2260
      sql_print_warning("lower_case_table_names was set to 2, even though your "
 
2261
                        "the file system '%s' is case sensitive.  Now setting "
 
2262
                        "lower_case_table_names to 0 to avoid future problems.",
 
2263
                        mysql_real_data_home);
 
2264
    lower_case_table_names= 0;
 
2265
  }
 
2266
  else
 
2267
  {
 
2268
    lower_case_file_system=
 
2269
      (test_if_case_insensitive(mysql_real_data_home) == 1);
 
2270
  }
2222
2271
 
2223
2272
  /* Reset table_alias_charset, now that lower_case_table_names is set. */
2224
 
  lower_case_table_names= 1; /* This we need to look at */
2225
 
  table_alias_charset= files_charset_info;
 
2273
  table_alias_charset= (lower_case_table_names ?
 
2274
                        files_charset_info :
 
2275
                        &my_charset_bin);
2226
2276
 
2227
2277
  return 0;
2228
2278
}
2234
2284
  (void) pthread_mutex_init(&LOCK_lock_db,MY_MUTEX_INIT_SLOW);
2235
2285
  (void) pthread_mutex_init(&LOCK_open, NULL);
2236
2286
  (void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);
 
2287
  (void) pthread_mutex_init(&LOCK_mapped_file,MY_MUTEX_INIT_SLOW);
2237
2288
  (void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);
2238
2289
  (void) pthread_mutex_init(&LOCK_error_log,MY_MUTEX_INIT_FAST);
 
2290
  (void) pthread_mutex_init(&LOCK_crypt,MY_MUTEX_INIT_FAST);
2239
2291
  (void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);
2240
2292
  (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
2241
2293
  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
2250
2302
  (void) pthread_cond_init(&COND_global_read_lock,NULL);
2251
2303
  (void) pthread_cond_init(&COND_thread_cache,NULL);
2252
2304
  (void) pthread_cond_init(&COND_flush_thread_cache,NULL);
 
2305
  (void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);
 
2306
  (void) pthread_cond_init(&COND_rpl_status, NULL);
2253
2307
 
2254
2308
  /* Parameter for threads created for connections */
2255
2309
  (void) pthread_attr_init(&connection_attrib);
2256
2310
  (void) pthread_attr_setdetachstate(&connection_attrib,
2257
2311
                                     PTHREAD_CREATE_DETACHED);
2258
2312
  pthread_attr_setscope(&connection_attrib, PTHREAD_SCOPE_SYSTEM);
 
2313
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
2259
2314
  {
2260
2315
    struct sched_param tmp_sched_param;
2261
2316
 
2267
2322
  if (pthread_key_create(&THR_THD,NULL) ||
2268
2323
      pthread_key_create(&THR_MALLOC,NULL))
2269
2324
  {
2270
 
    sql_print_error(_("Can't create thread-keys"));
 
2325
    sql_print_error("Can't create thread-keys");
2271
2326
    return 1;
2272
2327
  }
2273
2328
  return 0;
2283
2338
  if (table_cache_init() | table_def_init())
2284
2339
    unireg_abort(1);
2285
2340
 
2286
 
  randominit(&sql_rand,(uint32_t) server_start_time,(uint32_t) server_start_time/2);
 
2341
  randominit(&sql_rand,(ulong) server_start_time,(ulong) server_start_time/2);
2287
2342
  setup_fpu();
2288
2343
  init_thr_lock();
 
2344
  init_slave_list();
2289
2345
 
2290
2346
  /* Setup logs */
2291
2347
 
2313
2369
 
2314
2370
  if (xid_cache_init())
2315
2371
  {
2316
 
    sql_print_error(_("Out of memory"));
 
2372
    sql_print_error("Out of memory");
2317
2373
    unireg_abort(1);
2318
2374
  }
2319
2375
 
2320
2376
  if (!opt_bin_log)
2321
2377
    if (opt_binlog_format_id != BINLOG_FORMAT_UNSPEC)
2322
2378
    {
2323
 
      sql_print_error(_("You need to use --log-bin to make "
2324
 
                        "--binlog-format work."));
 
2379
      sql_print_error("You need to use --log-bin to make "
 
2380
                      "--binlog-format work.");
2325
2381
      unireg_abort(1);
2326
2382
    }
2327
2383
    else
2332
2388
    if (opt_binlog_format_id == BINLOG_FORMAT_UNSPEC)
2333
2389
      global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;
2334
2390
    else
2335
 
    {
 
2391
    { 
2336
2392
      assert(global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC);
2337
2393
    }
2338
2394
 
2342
2398
 
2343
2399
  if (opt_log_slave_updates && replicate_same_server_id)
2344
2400
  {
2345
 
    sql_print_error(_("using --replicate-same-server-id in conjunction with "
2346
 
                      "--log-slave-updates is impossible, it would lead to "
2347
 
                      "infinite loops in this server."));
 
2401
    sql_print_error("\
 
2402
using --replicate-same-server-id in conjunction with \
 
2403
--log-slave-updates is impossible, it would lead to infinite loops in this \
 
2404
server.");
2348
2405
    unireg_abort(1);
2349
2406
  }
2350
2407
 
2362
2419
        require a name. But as we don't want to break many existing setups, we
2363
2420
        only give warning, not error.
2364
2421
      */
2365
 
      sql_print_warning(_("No argument was provided to --log-bin, and "
2366
 
                          "--log-bin-index was not used; so replication "
2367
 
                          "may break when this Drizzle server acts as a "
2368
 
                          "master and has his hostname changed!! Please "
2369
 
                          "use '--log-bin=%s' to avoid this problem."), ln);
 
2422
      sql_print_warning("No argument was provided to --log-bin, and "
 
2423
                        "--log-bin-index was not used; so replication "
 
2424
                        "may break when this MySQL server acts as a "
 
2425
                        "master and has his hostname changed!! Please "
 
2426
                        "use '--log-bin=%s' to avoid this problem.", ln);
2370
2427
    }
2371
2428
    if (ln == buf)
2372
2429
    {
2373
 
      free(opt_bin_logname);
 
2430
      my_free(opt_bin_logname, MYF(MY_ALLOW_ZERO_PTR));
2374
2431
      opt_bin_logname=my_strdup(buf, MYF(0));
2375
2432
    }
2376
2433
    if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln))
2396
2453
                  (opt_noacl ? PLUGIN_INIT_SKIP_PLUGIN_TABLE : 0) |
2397
2454
                  (opt_help ? PLUGIN_INIT_SKIP_INITIALIZATION : 0)))
2398
2455
  {
2399
 
    sql_print_error(_("Failed to initialize plugins."));
 
2456
    sql_print_error("Failed to initialize plugins.");
2400
2457
    unireg_abort(1);
2401
2458
  }
2402
2459
 
2426
2483
 
2427
2484
    if (defaults_argc)
2428
2485
    {
2429
 
      fprintf(stderr,
2430
 
              _("%s: Too many arguments (first extra is '%s').\n"
2431
 
                "Use --verbose --help to get a list of available options\n"),
 
2486
      fprintf(stderr, "%s: Too many arguments (first extra is '%s').\n"
 
2487
              "Use --verbose --help to get a list of available options\n",
2432
2488
              my_progname, *tmp_argv);
2433
2489
      unireg_abort(1);
2434
2490
    }
2435
2491
  }
2436
2492
 
 
2493
  /* if the errmsg.sys is not loaded, terminate to maintain behaviour */
 
2494
  if (!errmesg[0][0])
 
2495
    unireg_abort(1);
 
2496
 
2437
2497
  /* We have to initialize the storage engines before CSV logging */
2438
2498
  if (ha_init())
2439
2499
  {
2440
 
    sql_print_error(_("Can't init databases"));
 
2500
    sql_print_error("Can't init databases");
2441
2501
    unireg_abort(1);
2442
2502
  }
2443
2503
 
 
2504
  logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,
 
2505
                      opt_log ? LOG_FILE:LOG_NONE);
 
2506
 
2444
2507
  /*
2445
2508
    Check that the default storage engine is actually available.
2446
2509
  */
2450
2513
                       strlen(default_storage_engine_str) };
2451
2514
    plugin_ref plugin;
2452
2515
    handlerton *hton;
2453
 
 
 
2516
    
2454
2517
    if ((plugin= ha_resolve_by_name(0, &name)))
2455
 
    {
2456
 
      hton= plugin_data(plugin,handlerton *);
2457
 
    }
 
2518
      hton= plugin_data(plugin, handlerton*);
2458
2519
    else
2459
2520
    {
2460
 
      sql_print_error(_("Unknown/unsupported table type: %s"),
 
2521
      sql_print_error("Unknown/unsupported table type: %s",
2461
2522
                      default_storage_engine_str);
2462
2523
      unireg_abort(1);
2463
2524
    }
2464
2525
    if (!ha_storage_engine_is_enabled(hton))
2465
2526
    {
2466
 
      sql_print_error(_("Default storage engine (%s) is not available"),
2467
 
                      default_storage_engine_str);
2468
 
      unireg_abort(1);
 
2527
      if (!opt_bootstrap)
 
2528
      {
 
2529
        sql_print_error("Default storage engine (%s) is not available",
 
2530
                        default_storage_engine_str);
 
2531
        unireg_abort(1);
 
2532
      }
2469
2533
      assert(global_system_variables.table_plugin);
2470
2534
    }
2471
2535
    else
2472
2536
    {
2473
2537
      /*
2474
 
        Need to unlock as global_system_variables.table_plugin
 
2538
        Need to unlock as global_system_variables.table_plugin 
2475
2539
        was acquired during plugin_init()
2476
2540
      */
2477
2541
      plugin_unlock(0, global_system_variables.table_plugin);
2486
2550
 
2487
2551
  if (tc_log->open(opt_bin_log ? opt_bin_logname : opt_tc_log_file))
2488
2552
  {
2489
 
    sql_print_error(_("Can't initialize tc_log"));
 
2553
    sql_print_error("Can't init tc log");
2490
2554
    unireg_abort(1);
2491
2555
  }
2492
2556
 
2506
2570
      mysql_bin_log.purge_logs_before_date(purge_time);
2507
2571
  }
2508
2572
 
 
2573
  if (opt_myisam_log)
 
2574
    (void) mi_log(1);
 
2575
 
2509
2576
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
2510
2577
  if (locked_in_memory && !getuid())
2511
2578
  {
2517
2584
    if (mlockall(MCL_CURRENT))
2518
2585
    {
2519
2586
      if (global_system_variables.log_warnings)
2520
 
        sql_print_warning(_("Failed to lock memory. Errno: %d\n"),errno);
 
2587
        sql_print_warning("Failed to lock memory. Errno: %d\n",errno);
2521
2588
      locked_in_memory= 0;
2522
2589
    }
2523
2590
    if (user_info)
2534
2601
 
2535
2602
int main(int argc, char **argv)
2536
2603
{
2537
 
#if defined(ENABLE_NLS)
2538
 
# if defined(HAVE_LOCALE_H)
2539
 
  setlocale(LC_ALL, "");
2540
 
# endif
2541
 
  bindtextdomain("drizzle", LOCALEDIR);
2542
 
  textdomain("drizzle");
2543
 
#endif
2544
 
 
2545
2604
  MY_INIT(argv[0]);             // init my_sys library & pthreads
2546
2605
  /* nothing should come before this line ^^^ */
2547
2606
 
2566
2625
  }
2567
2626
#endif
2568
2627
 
2569
 
  if (init_common_variables(DRIZZLE_CONFIG_NAME,
 
2628
  if (init_common_variables(MYSQL_CONFIG_NAME,
2570
2629
                            argc, argv, load_default_groups))
2571
2630
    unireg_abort(1);                            // Will do exit
2572
2631
 
2583
2642
    if (stack_size && stack_size < my_thread_stack_size)
2584
2643
    {
2585
2644
      if (global_system_variables.log_warnings)
2586
 
      {
2587
 
        /* %zu is not yet in C++ */
2588
 
        uint64_t size_tmp= (uint64_t)stack_size;
2589
 
        sql_print_warning(_("Asked for %u thread stack, but got %"PRIu64),
2590
 
                          my_thread_stack_size, size_tmp);
2591
 
      }
 
2645
        sql_print_warning("Asked for %lu thread stack, but got %ld",
 
2646
                          my_thread_stack_size, (long) stack_size);
2592
2647
      my_thread_stack_size= stack_size;
2593
2648
    }
2594
2649
  }
2622
2677
  {
2623
2678
    server_id= 1;
2624
2679
#ifdef EXTRA_DEBUG
2625
 
    sql_print_warning(_("You have enabled the binary log, but you haven't set "
2626
 
                        "server-id to a non-zero value: we force server id to "
2627
 
                        "1; updates will be logged to the binary log, but "
2628
 
                        "connections from slaves will not be accepted."));
 
2680
    sql_print_warning("You have enabled the binary log, but you haven't set "
 
2681
                      "server-id to a non-zero value: we force server id to 1; "
 
2682
                      "updates will be logged to the binary log, but "
 
2683
                      "connections from slaves will not be accepted.");
2629
2684
#endif
2630
2685
  }
2631
2686
 
2647
2702
  error_handler_hook= my_message_sql;
2648
2703
  start_signal_handler();                               // Creates pidfile
2649
2704
 
2650
 
  if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name))
 
2705
  if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name, opt_bootstrap))
2651
2706
  {
2652
2707
    abort_loop=1;
2653
2708
    select_thread_in_use=0;
2654
 
    (void) pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL);
 
2709
    (void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
2655
2710
 
2656
 
    (void) my_delete(pidfile_name,MYF(MY_WME)); // Not needed anymore
 
2711
    if (!opt_bootstrap)
 
2712
      (void) my_delete(pidfile_name,MYF(MY_WME));       // Not needed anymore
2657
2713
 
2658
2714
    exit(1);
2659
2715
  }
2660
2716
 
2661
2717
  init_status_vars();
 
2718
  if (opt_bootstrap) /* If running with bootstrap, do not start replication. */
 
2719
    opt_skip_slave_start= 1;
2662
2720
  /*
2663
2721
    init_slave() must be called after the thread keys are created.
2664
2722
    Some parts of the code (e.g. SHOW STATUS LIKE 'slave_running' and other
2670
2728
    unireg_abort(1);
2671
2729
  }
2672
2730
 
2673
 
  sql_print_information(_(ER(ER_STARTUP)),my_progname,server_version,
2674
 
                        "", mysqld_port, DRIZZLE_COMPILATION_COMMENT);
 
2731
  sql_print_information(ER(ER_STARTUP),my_progname,server_version,
 
2732
                        "", mysqld_port, MYSQL_COMPILATION_COMMENT);
2675
2733
 
2676
2734
 
2677
2735
  handle_connections_sockets();
2678
2736
 
2679
2737
  /* (void) pthread_attr_destroy(&connection_attrib); */
2680
 
 
 
2738
  
2681
2739
 
2682
2740
#ifdef EXTRA_DEBUG2
2683
 
  sql_print_error(_("Before Lock_thread_count"));
 
2741
  sql_print_error("Before Lock_thread_count");
2684
2742
#endif
2685
2743
  (void) pthread_mutex_lock(&LOCK_thread_count);
2686
2744
  select_thread_in_use=0;                       // For close_connections
2687
2745
  (void) pthread_mutex_unlock(&LOCK_thread_count);
2688
2746
  (void) pthread_cond_broadcast(&COND_thread_count);
2689
2747
#ifdef EXTRA_DEBUG2
2690
 
  sql_print_error(_("After lock_thread_count"));
 
2748
  sql_print_error("After lock_thread_count");
2691
2749
#endif
2692
2750
 
2693
2751
  /* Wait until cleanup is done */
2763
2821
inline void kill_broken_server()
2764
2822
{
2765
2823
  /* hack to get around signals ignored in syscalls for problem OS's */
2766
 
  if ((ip_sock == -1))
 
2824
  if ((!opt_disable_networking && ip_sock == INVALID_SOCKET))
2767
2825
  {
2768
2826
    select_thread_in_use = 0;
2769
2827
    /* The following call will never return */
2770
 
    kill_server((void*) DRIZZLE_KILL_SIGNAL);
 
2828
    kill_server((void*) MYSQL_KILL_SIGNAL);
2771
2829
  }
2772
2830
}
2773
2831
#define MAYBE_BROKEN_SYSCALL kill_broken_server();
2779
2837
 
2780
2838
void handle_connections_sockets()
2781
2839
{
2782
 
  int x;
2783
 
  int sock,new_sock;
2784
 
  uint32_t error_count=0;
 
2840
  my_socket sock,new_sock;
 
2841
  uint error_count=0;
 
2842
  uint max_used_connection= (uint)ip_sock+1;
 
2843
  fd_set readFDs,clientFDs;
2785
2844
  THD *thd;
2786
2845
  struct sockaddr_storage cAddr;
 
2846
  int ip_flags=0, flags;
 
2847
  st_vio *vio_tmp;
2787
2848
 
 
2849
  FD_ZERO(&clientFDs);
 
2850
  if (ip_sock != INVALID_SOCKET)
 
2851
  {
 
2852
    FD_SET(ip_sock,&clientFDs);
 
2853
    ip_flags = fcntl(ip_sock, F_GETFL, 0);
 
2854
  }
2788
2855
  MAYBE_BROKEN_SYSCALL;
2789
2856
  while (!abort_loop)
2790
2857
  {
2791
 
    int number_of;
2792
 
 
2793
 
    if ((number_of= poll(fds, pollfd_count, -1)) == -1)
 
2858
    readFDs=clientFDs;
 
2859
    if (select((int) max_used_connection,&readFDs,0,0,0) < 0)
2794
2860
    {
2795
 
      if (errno != EINTR)
 
2861
      if (socket_errno != SOCKET_EINTR)
2796
2862
      {
2797
 
        if (!select_errors++ && !abort_loop)    /* purecov: inspected */
2798
 
          sql_print_error(_("drizzled: Got error %d from select"),
2799
 
                          errno); /* purecov: inspected */
 
2863
        if (!select_errors++ && !abort_loop)    /* purecov: inspected */
 
2864
          sql_print_error("mysqld: Got error %d from select",socket_errno); /* purecov: inspected */
2800
2865
      }
2801
2866
      MAYBE_BROKEN_SYSCALL
2802
2867
      continue;
2803
2868
    }
2804
 
    if (number_of == 0)
2805
 
      continue;
2806
 
 
2807
 
#ifdef FIXME_IF_WE_WERE_KEEPING_THIS
2808
 
    assert(number_of > 1); /* Not handling this at the moment */
2809
 
#endif
2810
 
 
2811
2869
    if (abort_loop)
2812
2870
    {
2813
2871
      MAYBE_BROKEN_SYSCALL;
2814
2872
      break;
2815
2873
    }
2816
2874
 
2817
 
    for (x= 0, sock= -1; x < pollfd_count; x++)
 
2875
    /* Is this a new connection request ? */
2818
2876
    {
2819
 
      if (fds[x].revents == POLLIN)
2820
 
      {
2821
 
        sock= fds[x].fd;
2822
 
        break;
2823
 
      }
 
2877
      sock = ip_sock;
 
2878
      flags= ip_flags;
2824
2879
    }
2825
 
    assert(sock != -1);
2826
2880
 
2827
 
    for (uint32_t retry=0; retry < MAX_ACCEPT_RETRY; retry++)
2828
 
    {
2829
 
      SOCKET_SIZE_TYPE length= sizeof(struct sockaddr_storage);
 
2881
#if !defined(NO_FCNTL_NONBLOCK)
 
2882
    if (!(test_flags & TEST_BLOCKING))
 
2883
    {
 
2884
#if defined(O_NONBLOCK)
 
2885
      fcntl(sock, F_SETFL, flags | O_NONBLOCK);
 
2886
#elif defined(O_NDELAY)
 
2887
      fcntl(sock, F_SETFL, flags | O_NDELAY);
 
2888
#endif
 
2889
    }
 
2890
#endif /* NO_FCNTL_NONBLOCK */
 
2891
    for (uint retry=0; retry < MAX_ACCEPT_RETRY; retry++)
 
2892
    {
 
2893
      size_socket length= sizeof(struct sockaddr_storage);
2830
2894
      new_sock= accept(sock, (struct sockaddr *)(&cAddr),
2831
2895
                       &length);
2832
 
      if (new_sock != -1 || (errno != EINTR && errno != EAGAIN))
 
2896
      if (new_sock != INVALID_SOCKET ||
 
2897
          (socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))
2833
2898
        break;
 
2899
      MAYBE_BROKEN_SYSCALL;
 
2900
#if !defined(NO_FCNTL_NONBLOCK)
 
2901
      if (!(test_flags & TEST_BLOCKING))
 
2902
      {
 
2903
        if (retry == MAX_ACCEPT_RETRY - 1)
 
2904
          fcntl(sock, F_SETFL, flags);          // Try without O_NONBLOCK
 
2905
      }
 
2906
#endif
2834
2907
    }
2835
 
 
2836
 
 
2837
 
    if (new_sock == -1)
 
2908
#if !defined(NO_FCNTL_NONBLOCK)
 
2909
    if (!(test_flags & TEST_BLOCKING))
 
2910
      fcntl(sock, F_SETFL, flags);
 
2911
#endif
 
2912
    if (new_sock == INVALID_SOCKET)
2838
2913
    {
2839
2914
      if ((error_count++ & 255) == 0)           // This can happen often
2840
2915
        sql_perror("Error in accept");
2841
2916
      MAYBE_BROKEN_SYSCALL;
2842
 
      if (errno == ENFILE || errno == EMFILE)
 
2917
      if (socket_errno == SOCKET_ENFILE || socket_errno == SOCKET_EMFILE)
2843
2918
        sleep(1);                               // Give other threads some time
2844
2919
      continue;
2845
2920
    }
2846
2921
 
2847
2922
    {
2848
 
      SOCKET_SIZE_TYPE dummyLen;
 
2923
      size_socket dummyLen;
2849
2924
      struct sockaddr_storage dummy;
2850
2925
      dummyLen = sizeof(dummy);
2851
 
      if (  getsockname(new_sock,(struct sockaddr *)&dummy,
2852
 
                        (socklen_t *)&dummyLen) < 0  )
2853
 
      {
2854
 
        sql_perror("Error on new connection socket");
2855
 
        (void) shutdown(new_sock, SHUT_RDWR);
2856
 
        (void) close(new_sock);
2857
 
        continue;
2858
 
      }
2859
 
      dummyLen = sizeof(dummy);
2860
 
      if ( getpeername(new_sock, (struct sockaddr *)&dummy,
2861
 
                       (socklen_t *)&dummyLen) < 0)
2862
 
      {
2863
 
        sql_perror("Error on new connection socket");
2864
 
        (void) shutdown(new_sock, SHUT_RDWR);
2865
 
        (void) close(new_sock);
2866
 
         continue;
 
2926
      if (  getsockname(new_sock,(struct sockaddr *)&dummy, 
 
2927
                  (socklen_t *)&dummyLen) < 0  )
 
2928
      {
 
2929
        sql_perror("Error on new connection socket");
 
2930
        (void) shutdown(new_sock, SHUT_RDWR);
 
2931
        (void) closesocket(new_sock);
 
2932
        continue;
2867
2933
      }
2868
2934
    }
2869
2935
 
2874
2940
    if (!(thd= new THD))
2875
2941
    {
2876
2942
      (void) shutdown(new_sock, SHUT_RDWR);
2877
 
      close(new_sock);
 
2943
      VOID(closesocket(new_sock));
2878
2944
      continue;
2879
2945
    }
2880
 
    if (net_init_sock(&thd->net, new_sock, sock == 0))
 
2946
    if (!(vio_tmp=vio_new(new_sock, VIO_TYPE_TCPIP, sock == 0)) ||
 
2947
        my_net_init(&thd->net,vio_tmp))
2881
2948
    {
 
2949
      /*
 
2950
        Only delete the temporary vio if we didn't already attach it to the
 
2951
        NET object. The destructor in THD will delete any initialized net
 
2952
        structure.
 
2953
      */
 
2954
      if (vio_tmp && thd->net.vio != vio_tmp)
 
2955
        vio_delete(vio_tmp);
 
2956
      else
 
2957
      {
 
2958
        (void) shutdown(new_sock, SHUT_RDWR);
 
2959
        (void) closesocket(new_sock);
 
2960
      }
2882
2961
      delete thd;
2883
2962
      continue;
2884
2963
    }
2894
2973
 
2895
2974
enum options_mysqld
2896
2975
{
2897
 
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW,
2898
 
  OPT_SKIP_GRANT,
 
2976
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW, 
 
2977
  OPT_SKIP_GRANT,              
2899
2978
  OPT_ENABLE_LOCK,             OPT_USE_LOCKING,
2900
2979
  OPT_SOCKET,                  OPT_UPDATE_LOG,
2901
 
  OPT_BIN_LOG,
 
2980
  OPT_BIN_LOG,                 
2902
2981
  OPT_BIN_LOG_INDEX,
2903
2982
  OPT_BIND_ADDRESS,            OPT_PID_FILE,
2904
 
  OPT_SKIP_PRIOR,
 
2983
  OPT_SKIP_PRIOR,              OPT_BIG_TABLES,
2905
2984
  OPT_STANDALONE,
2906
2985
  OPT_CONSOLE,                 OPT_LOW_PRIORITY_UPDATES,
2907
2986
  OPT_SHORT_LOG_FORMAT,
2908
2987
  OPT_FLUSH,                   OPT_SAFE,
 
2988
  OPT_BOOTSTRAP,               OPT_SKIP_SHOW_DB,
2909
2989
  OPT_STORAGE_ENGINE,          OPT_INIT_FILE,
2910
 
  OPT_DELAY_KEY_WRITE_ALL,
 
2990
  OPT_DELAY_KEY_WRITE_ALL,     OPT_SLOW_QUERY_LOG,
2911
2991
  OPT_DELAY_KEY_WRITE,         OPT_CHARSETS_DIR,
2912
2992
  OPT_MASTER_INFO_FILE,
2913
2993
  OPT_MASTER_RETRY_COUNT,      OPT_LOG_TC, OPT_LOG_TC_SIZE,
2915
2995
  OPT_REPLICATE_IGNORE_DB,     OPT_LOG_SLAVE_UPDATES,
2916
2996
  OPT_BINLOG_DO_DB,            OPT_BINLOG_IGNORE_DB,
2917
2997
  OPT_BINLOG_FORMAT,
2918
 
  OPT_BINLOG_ROWS_EVENT_MAX_SIZE,
 
2998
  OPT_BINLOG_ROWS_EVENT_MAX_SIZE, 
2919
2999
  OPT_WANT_CORE,
2920
3000
  OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,
2921
3001
  OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID,
2925
3005
  OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,
2926
3006
  OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,
2927
3007
  OPT_ABORT_SLAVE_EVENT_COUNT,
2928
 
  OPT_ENGINE_CONDITION_PUSHDOWN,
 
3008
  OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
 
3009
  OPT_ENGINE_CONDITION_PUSHDOWN, 
2929
3010
  OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,
2930
3011
  OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,
2931
3012
  OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,
2950
3031
  OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,
2951
3032
  OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,
2952
3033
  OPT_MAX_HEP_TABLE_SIZE,
2953
 
  OPT_MAX_JOIN_SIZE,
 
3034
  OPT_MAX_JOIN_SIZE, OPT_MAX_PREPARED_STMT_COUNT,
2954
3035
  OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,
2955
3036
  OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,
2956
3037
  OPT_MAX_LENGTH_FOR_SORT_DATA,
2964
3045
  OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,
2965
3046
  OPT_OPEN_FILES_LIMIT,
2966
3047
  OPT_PRELOAD_BUFFER_SIZE,
2967
 
  OPT_RECORD_BUFFER,
 
3048
  OPT_QUERY_CACHE_LIMIT, OPT_QUERY_CACHE_MIN_RES_UNIT, OPT_QUERY_CACHE_SIZE,
 
3049
  OPT_QUERY_CACHE_TYPE, OPT_QUERY_CACHE_WLOCK_INVALIDATE, OPT_RECORD_BUFFER,
2968
3050
  OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT, OPT_RELAY_LOG_SPACE_LIMIT,
2969
3051
  OPT_RELAY_LOG_PURGE,
2970
3052
  OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,
2997
3079
  OPT_DATE_FORMAT,
2998
3080
  OPT_TIME_FORMAT,
2999
3081
  OPT_DATETIME_FORMAT,
 
3082
  OPT_LOG_QUERIES_NOT_USING_INDEXES,
3000
3083
  OPT_DEFAULT_TIME_ZONE,
3001
3084
  OPT_SYSDATE_IS_NOW,
3002
3085
  OPT_OPTIMIZER_SEARCH_DEPTH,
3006
3089
  OPT_ENABLE_LARGE_PAGES,
3007
3090
  OPT_TIMED_MUTEXES,
3008
3091
  OPT_OLD_STYLE_USER_LIMITS,
 
3092
  OPT_LOG_SLOW_ADMIN_STATEMENTS,
3009
3093
  OPT_TABLE_LOCK_WAIT_TIMEOUT,
3010
3094
  OPT_PLUGIN_LOAD,
3011
3095
  OPT_PLUGIN_DIR,
 
3096
  OPT_LOG_OUTPUT,
3012
3097
  OPT_PORT_OPEN_TIMEOUT,
3013
3098
  OPT_PROFILING,
3014
3099
  OPT_KEEP_FILES_ON_CREATE,
3015
3100
  OPT_GENERAL_LOG,
 
3101
  OPT_SLOW_LOG,
3016
3102
  OPT_THREAD_HANDLING,
3017
3103
  OPT_INNODB_ROLLBACK_ON_TIMEOUT,
3018
3104
  OPT_SECURE_FILE_PRIV,
3019
3105
  OPT_MIN_EXAMINED_ROW_LIMIT,
 
3106
  OPT_LOG_SLOW_SLAVE_STATEMENTS,
3020
3107
  OPT_OLD_MODE,
3021
3108
  OPT_POOL_OF_THREADS,
3022
3109
  OPT_SLAVE_EXEC_MODE
3023
3110
};
3024
3111
 
3025
3112
 
3026
 
#define LONG_TIMEOUT ((uint32_t) 3600L*24L*365L)
 
3113
#define LONG_TIMEOUT ((ulong) 3600L*24L*365L)
3027
3114
 
3028
3115
struct my_option my_long_options[] =
3029
3116
{
3030
 
  {"help", '?', N_("Display this help and exit."),
 
3117
  {"help", '?', "Display this help and exit.", 
3031
3118
   (char**) &opt_help, (char**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
3032
3119
   0, 0},
3033
3120
  {"abort-slave-event-count", OPT_ABORT_SLAVE_EVENT_COUNT,
3034
 
   N_("Option used by mysql-test for debugging and testing of replication."),
 
3121
   "Option used by mysql-test for debugging and testing of replication.",
3035
3122
   (char**) &abort_slave_event_count,  (char**) &abort_slave_event_count,
3036
3123
   0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3124
  {"ansi", 'a', "Use ANSI SQL syntax instead of MySQL syntax. This mode will also set transaction isolation level 'serializable'.", 0, 0, 0,
 
3125
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3037
3126
  {"auto-increment-increment", OPT_AUTO_INCREMENT,
3038
 
   N_("Auto-increment columns are incremented by this"),
 
3127
   "Auto-increment columns are incremented by this",
3039
3128
   (char**) &global_system_variables.auto_increment_increment,
3040
3129
   (char**) &max_system_variables.auto_increment_increment, 0, GET_ULONG,
3041
3130
   OPT_ARG, 1, 1, 65535, 0, 1, 0 },
3042
3131
  {"auto-increment-offset", OPT_AUTO_INCREMENT_OFFSET,
3043
 
   N_("Offset added to Auto-increment columns. Used when "
3044
 
      "auto-increment-increment != 1"),
 
3132
   "Offset added to Auto-increment columns. Used when auto-increment-increment != 1",
3045
3133
   (char**) &global_system_variables.auto_increment_offset,
3046
3134
   (char**) &max_system_variables.auto_increment_offset, 0, GET_ULONG, OPT_ARG,
3047
3135
   1, 1, 65535, 0, 1, 0 },
3048
3136
  {"basedir", 'b',
3049
 
   N_("Path to installation directory. All paths are usually resolved "
3050
 
      "relative to this."),
 
3137
   "Path to installation directory. All paths are usually resolved relative to this.",
3051
3138
   (char**) &mysql_home_ptr, (char**) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,
3052
3139
   0, 0, 0, 0, 0, 0},
3053
 
  {"bind-address", OPT_BIND_ADDRESS, N_("IP address to bind to."),
 
3140
  {"big-tables", OPT_BIG_TABLES,
 
3141
   "Allow big result sets by saving all temporary sets on file (Solves most 'table full' errors).",
 
3142
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3143
  {"bind-address", OPT_BIND_ADDRESS, "IP address to bind to.",
3054
3144
   (char**) &my_bind_addr_str, (char**) &my_bind_addr_str, 0, GET_STR,
3055
3145
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3056
3146
  {"binlog_format", OPT_BINLOG_FORMAT,
3057
 
   N_("Does not have any effect without '--log-bin'. "
3058
 
      "Tell the master the form of binary logging to use: either 'row' for "
3059
 
      "row-based binary logging, or 'statement' for statement-based binary "
3060
 
      "logging, or 'mixed'. 'mixed' is statement-based binary logging except "
3061
 
      "for those statements where only row-based is correct: those which "
3062
 
      "involve user-defined functions (i.e. UDFs) or the UUID() function; for "
3063
 
      "those, row-based binary logging is automatically used. ")
 
3147
   "Does not have any effect without '--log-bin'. "
 
3148
   "Tell the master the form of binary logging to use: either 'row' for "
 
3149
   "row-based binary logging, or 'statement' for statement-based binary "
 
3150
   "logging, or 'mixed'. 'mixed' is statement-based binary logging except "
 
3151
   "for those statements where only row-based is correct: those which "
 
3152
   "involve user-defined functions (i.e. UDFs) or the UUID() function; for "
 
3153
   "those, row-based binary logging is automatically used. "
3064
3154
   ,(char**) &opt_binlog_format, (char**) &opt_binlog_format,
3065
3155
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3066
3156
  {"binlog-do-db", OPT_BINLOG_DO_DB,
3067
 
   N_("Tells the master it should log updates for the specified database, and "
3068
 
      "exclude all others not explicitly mentioned."),
 
3157
   "Tells the master it should log updates for the specified database, and exclude all others not explicitly mentioned.",
3069
3158
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3070
3159
  {"binlog-ignore-db", OPT_BINLOG_IGNORE_DB,
3071
 
   N_("Tells the master that updates to the given database should not "
3072
 
      "be logged tothe binary log."),
 
3160
   "Tells the master that updates to the given database should not be logged tothe binary log.",
3073
3161
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3074
3162
  {"binlog-row-event-max-size", OPT_BINLOG_ROWS_EVENT_MAX_SIZE,
3075
 
   N_("The maximum size of a row-based binary log event in bytes. Rows will "
3076
 
      "be grouped into events smaller than this size if possible. "
3077
 
      "The value has to be a multiple of 256."),
3078
 
   (char**) &opt_binlog_rows_event_max_size,
3079
 
   (char**) &opt_binlog_rows_event_max_size, 0,
3080
 
   GET_ULONG, REQUIRED_ARG,
3081
 
   /* def_value */ 1024, /* min_value */  256, /* max_value */ ULONG_MAX,
3082
 
   /* sub_size */     0, /* block_size */ 256,
 
3163
   "The maximum size of a row-based binary log event in bytes. Rows will be "
 
3164
   "grouped into events smaller than this size if possible. "
 
3165
   "The value has to be a multiple of 256.",
 
3166
   (char**) &opt_binlog_rows_event_max_size, 
 
3167
   (char**) &opt_binlog_rows_event_max_size, 0, 
 
3168
   GET_ULONG, REQUIRED_ARG, 
 
3169
   /* def_value */ 1024, /* min_value */  256, /* max_value */ ULONG_MAX, 
 
3170
   /* sub_size */     0, /* block_size */ 256, 
3083
3171
   /* app_type */ 0
3084
3172
  },
 
3173
#ifndef DISABLE_GRANT_OPTIONS
 
3174
  {"bootstrap", OPT_BOOTSTRAP, "Used by mysql installation scripts.", 0, 0, 0,
 
3175
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3176
#endif
3085
3177
  {"character-set-client-handshake", OPT_CHARACTER_SET_CLIENT_HANDSHAKE,
3086
 
   N_("Don't ignore client side character set value sent during handshake."),
 
3178
   "Don't ignore client side character set value sent during handshake.",
3087
3179
   (char**) &opt_character_set_client_handshake,
3088
3180
   (char**) &opt_character_set_client_handshake,
3089
3181
    0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
3090
3182
  {"character-set-filesystem", OPT_CHARACTER_SET_FILESYSTEM,
3091
 
   N_("Set the filesystem character set."),
 
3183
   "Set the filesystem character set.",
3092
3184
   (char**) &character_set_filesystem_name,
3093
3185
   (char**) &character_set_filesystem_name,
3094
3186
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3095
 
  {"character-set-server", 'C',
3096
 
   N_("Set the default character set."),
 
3187
  {"character-set-server", 'C', "Set the default character set.",
3097
3188
   (char**) &default_character_set_name, (char**) &default_character_set_name,
3098
3189
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3099
3190
  {"character-sets-dir", OPT_CHARSETS_DIR,
3100
 
   N_("Directory where character sets are."), (char**) &charsets_dir,
 
3191
   "Directory where character sets are.", (char**) &charsets_dir,
3101
3192
   (char**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3102
 
  {"chroot", 'r',
3103
 
   N_("Chroot mysqld daemon during startup."),
 
3193
  {"chroot", 'r', "Chroot mysqld daemon during startup.",
3104
3194
   (char**) &mysqld_chroot, (char**) &mysqld_chroot, 0, GET_STR, REQUIRED_ARG,
3105
3195
   0, 0, 0, 0, 0, 0},
3106
 
  {"collation-server", OPT_DEFAULT_COLLATION,
3107
 
   N_("Set the default collation."),
 
3196
  {"collation-server", OPT_DEFAULT_COLLATION, "Set the default collation.",
3108
3197
   (char**) &default_collation_name, (char**) &default_collation_name,
3109
3198
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3110
 
  {"completion-type", OPT_COMPLETION_TYPE,
3111
 
   N_("Default completion type."),
 
3199
  {"completion-type", OPT_COMPLETION_TYPE, "Default completion type.",
3112
3200
   (char**) &global_system_variables.completion_type,
3113
3201
   (char**) &max_system_variables.completion_type, 0, GET_ULONG,
3114
3202
   REQUIRED_ARG, 0, 0, 2, 0, 1, 0},
3115
 
  {"console", OPT_CONSOLE,
3116
 
   N_("Write error output on screen."),
 
3203
  {"console", OPT_CONSOLE, "Write error output on screen; Don't remove the console window on windows.",
3117
3204
   (char**) &opt_console, (char**) &opt_console, 0, GET_BOOL, NO_ARG, 0, 0, 0,
3118
3205
   0, 0, 0},
3119
 
  {"core-file", OPT_WANT_CORE,
3120
 
   N_("Write core on errors."),
3121
 
   0, 0, 0, GET_NO_ARG,
 
3206
  {"core-file", OPT_WANT_CORE, "Write core on errors.", 0, 0, 0, GET_NO_ARG,
3122
3207
   NO_ARG, 0, 0, 0, 0, 0, 0},
3123
 
  {"datadir", 'h',
3124
 
   N_("Path to the database root."),
3125
 
   (char**) &mysql_data_home,
 
3208
  {"datadir", 'h', "Path to the database root.", (char**) &mysql_data_home,
3126
3209
   (char**) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3210
  {"default-character-set", 'C', "Set the default character set (deprecated option, use --character-set-server instead).",
 
3211
   (char**) &default_character_set_name, (char**) &default_character_set_name,
 
3212
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
 
3213
  {"default-collation", OPT_DEFAULT_COLLATION, "Set the default collation (deprecated option, use --collation-server instead).",
 
3214
   (char**) &default_collation_name, (char**) &default_collation_name,
 
3215
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3127
3216
  {"default-storage-engine", OPT_STORAGE_ENGINE,
3128
 
   N_("Set the default storage engine (table type) for tables."),
3129
 
   (char**)&default_storage_engine_str, (char**)&default_storage_engine_str,
3130
 
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3131
 
  {"default-time-zone", OPT_DEFAULT_TIME_ZONE,
3132
 
   N_("Set the default time zone."),
 
3217
   "Set the default storage engine (table type) for tables.",
 
3218
   (char**)&default_storage_engine_str, (char**)&default_storage_engine_str,
 
3219
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3220
  {"default-table-type", OPT_STORAGE_ENGINE,
 
3221
   "(deprecated) Use --default-storage-engine.",
 
3222
   (char**)&default_storage_engine_str, (char**)&default_storage_engine_str,
 
3223
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3224
  {"default-time-zone", OPT_DEFAULT_TIME_ZONE, "Set the default time zone.",
3133
3225
   (char**) &default_tz_name, (char**) &default_tz_name,
3134
3226
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3135
 
  {"delay-key-write", OPT_DELAY_KEY_WRITE,
3136
 
   N_("Type of DELAY_KEY_WRITE."),
 
3227
  {"delay-key-write", OPT_DELAY_KEY_WRITE, "Type of DELAY_KEY_WRITE.",
3137
3228
   0,0,0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3229
  {"delay-key-write-for-all-tables", OPT_DELAY_KEY_WRITE_ALL,
 
3230
   "Don't flush key buffers between writes for any MyISAM table (Deprecated option, use --delay-key-write=all instead).",
 
3231
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3138
3232
  {"disconnect-slave-event-count", OPT_DISCONNECT_SLAVE_EVENT_COUNT,
3139
 
   N_("Option used by mysql-test for debugging and testing of replication."),
 
3233
   "Option used by mysql-test for debugging and testing of replication.",
3140
3234
   (char**) &disconnect_slave_event_count,
3141
3235
   (char**) &disconnect_slave_event_count, 0, GET_INT, REQUIRED_ARG, 0, 0, 0,
3142
3236
   0, 0, 0},
3143
3237
#ifdef HAVE_STACK_TRACE_ON_SEGV
3144
 
  {"enable-pstack", OPT_DO_PSTACK,
3145
 
   N_("Print a symbolic stack trace on failure."),
 
3238
  {"enable-pstack", OPT_DO_PSTACK, "Print a symbolic stack trace on failure.",
3146
3239
   (char**) &opt_do_pstack, (char**) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
3147
3240
   0, 0, 0, 0},
3148
3241
#endif /* HAVE_STACK_TRACE_ON_SEGV */
3149
3242
  {"engine-condition-pushdown",
3150
3243
   OPT_ENGINE_CONDITION_PUSHDOWN,
3151
 
   N_("Push supported query conditions to the storage engine."),
 
3244
   "Push supported query conditions to the storage engine.",
3152
3245
   (char**) &global_system_variables.engine_condition_pushdown,
3153
3246
   (char**) &global_system_variables.engine_condition_pushdown,
3154
3247
   0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
3155
3248
  /* See how it's handled in get_one_option() */
3156
 
  {"exit-info", 'T',
3157
 
   N_("Used for debugging;  Use at your own risk!"),
3158
 
   0, 0, 0, GET_LONG, OPT_ARG, 0, 0, 0, 0, 0, 0},
3159
 
  {"flush", OPT_FLUSH,
3160
 
   N_("Flush tables to disk between SQL commands."),
3161
 
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3249
  {"exit-info", 'T', "Used for debugging;  Use at your own risk!", 0, 0, 0,
 
3250
   GET_LONG, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3251
  {"flush", OPT_FLUSH, "Flush tables to disk between SQL commands.", 0, 0, 0,
 
3252
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3162
3253
  /* We must always support the next option to make scripts like mysqltest
3163
3254
     easier to do */
3164
3255
  {"gdb", OPT_DEBUGGING,
3165
 
   N_("Set up signals usable for debugging"),
 
3256
   "Set up signals usable for debugging",
3166
3257
   (char**) &opt_debugging, (char**) &opt_debugging,
3167
3258
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3168
 
  {"init-connect", OPT_INIT_CONNECT,
3169
 
   N_("Command(s) that are executed for each new connection"),
 
3259
  {"general-log", OPT_GENERAL_LOG,
 
3260
   "Enable|disable general log", (char**) &opt_log,
 
3261
   (char**) &opt_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3262
  {"init-connect", OPT_INIT_CONNECT, "Command(s) that are executed for each new connection",
3170
3263
   (char**) &opt_init_connect, (char**) &opt_init_connect, 0, GET_STR_ALLOC,
3171
3264
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3172
 
  {"init-file", OPT_INIT_FILE,
3173
 
   N_("Read SQL commands from this file at startup."),
 
3265
  {"init-file", OPT_INIT_FILE, "Read SQL commands from this file at startup.",
3174
3266
   (char**) &opt_init_file, (char**) &opt_init_file, 0, GET_STR, REQUIRED_ARG,
3175
3267
   0, 0, 0, 0, 0, 0},
3176
 
  {"init-slave", OPT_INIT_SLAVE,
3177
 
   N_("Command(s) that are executed when a slave connects to this master"),
 
3268
  {"init-slave", OPT_INIT_SLAVE, "Command(s) that are executed when a slave connects to this master",
3178
3269
   (char**) &opt_init_slave, (char**) &opt_init_slave, 0, GET_STR_ALLOC,
3179
3270
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3180
3271
  {"language", 'L',
3181
 
   N_("(IGNORED)"),
 
3272
   "Client error messages in given language. May be given as a full path.",
3182
3273
   (char**) &language_ptr, (char**) &language_ptr, 0, GET_STR, REQUIRED_ARG,
3183
3274
   0, 0, 0, 0, 0, 0},
3184
3275
  {"lc-time-names", OPT_LC_TIME_NAMES,
3185
 
   N_("Set the language used for the month names and the days of the week."),
 
3276
   "Set the language used for the month names and the days of the week.",
3186
3277
   (char**) &lc_time_names_name,
3187
3278
   (char**) &lc_time_names_name,
3188
3279
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3189
3280
  {"local-infile", OPT_LOCAL_INFILE,
3190
 
   N_("Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0)."),
 
3281
   "Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0).",
3191
3282
   (char**) &opt_local_infile,
3192
3283
   (char**) &opt_local_infile, 0, GET_BOOL, OPT_ARG,
3193
3284
   1, 0, 0, 0, 0, 0},
3194
 
  {"log", 'l',
3195
 
   N_("Log connections and queries to file."),
3196
 
   (char**) &opt_logname,
 
3285
  {"log", 'l', "Log connections and queries to file.", (char**) &opt_logname,
3197
3286
   (char**) &opt_logname, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
3198
3287
  {"log-bin", OPT_BIN_LOG,
3199
 
   N_("Log update queries in binary format. Optional argument is the "
3200
 
      "location for the binary log files.(Strongly "
3201
 
      "recommended to avoid replication problems if server's hostname "
3202
 
      "changes)"),
 
3288
   "Log update queries in binary format. Optional (but strongly recommended "
 
3289
   "to avoid replication problems if server's hostname changes) argument "
 
3290
   "should be the chosen location for the binary log files.",
3203
3291
   (char**) &opt_bin_logname, (char**) &opt_bin_logname, 0, GET_STR_ALLOC,
3204
3292
   OPT_ARG, 0, 0, 0, 0, 0, 0},
3205
3293
  {"log-bin-index", OPT_BIN_LOG_INDEX,
3206
 
   N_("File that holds the names for last binary log files."),
 
3294
   "File that holds the names for last binary log files.",
3207
3295
   (char**) &opt_binlog_index_name, (char**) &opt_binlog_index_name, 0, GET_STR,
3208
3296
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3209
 
  {"log-error", OPT_ERROR_LOG_FILE,
3210
 
   N_("Error log file."),
 
3297
  /*
 
3298
    This option starts with "log-bin" to emphasize that it is specific of
 
3299
    binary logging.
 
3300
  */
 
3301
  {"log-bin-trust-function-creators", OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
 
3302
   "If equal to 0 (the default), then when --log-bin is used, creation of "
 
3303
   "a stored function (or trigger) is allowed only to users having the SUPER privilege "
 
3304
   "and only if this stored function (trigger) may not break binary logging."
 
3305
   "Note that if ALL connections to this server ALWAYS use row-based binary "
 
3306
   "logging, the security issues do not exist and the binary logging cannot "
 
3307
   "break, so you can safely set this to 1."
 
3308
   ,(char**) &trust_function_creators, (char**) &trust_function_creators, 0,
 
3309
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3310
  {"log-error", OPT_ERROR_LOG_FILE, "Error log file.",
3211
3311
   (char**) &log_error_file_ptr, (char**) &log_error_file_ptr, 0, GET_STR,
3212
3312
   OPT_ARG, 0, 0, 0, 0, 0, 0},
3213
 
  {"log-isam", OPT_ISAM_LOG,
3214
 
   N_("Log all MyISAM changes to file."),
 
3313
  {"log-isam", OPT_ISAM_LOG, "Log all MyISAM changes to file.",
3215
3314
   (char**) &myisam_log_filename, (char**) &myisam_log_filename, 0, GET_STR,
3216
3315
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3316
  {"log-long-format", '0',
 
3317
   "Log some extra information to update log. Please note that this option is deprecated; see --log-short-format option.", 
 
3318
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3319
#ifdef WITH_CSV_STORAGE_ENGINE
 
3320
  {"log-output", OPT_LOG_OUTPUT,
 
3321
   "Syntax: log-output[=value[,value...]], where \"value\" could be TABLE, "
 
3322
   "FILE or NONE.",
 
3323
   (char**) &log_output_str, (char**) &log_output_str, 0,
 
3324
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3325
#endif
 
3326
  {"log-queries-not-using-indexes", OPT_LOG_QUERIES_NOT_USING_INDEXES,
 
3327
   "Log queries that are executed without benefit of any index to the slow log if it is open.",
 
3328
   (char**) &opt_log_queries_not_using_indexes, (char**) &opt_log_queries_not_using_indexes,
 
3329
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3330
  {"log-short-format", OPT_SHORT_LOG_FORMAT,
 
3331
   "Don't log extra information to update and slow-query logs.",
 
3332
   (char**) &opt_short_log_format, (char**) &opt_short_log_format,
 
3333
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3217
3334
  {"log-slave-updates", OPT_LOG_SLAVE_UPDATES,
3218
 
   N_("Tells the slave to log the updates from the slave thread to the binary "
3219
 
      "log. You will need to turn it on if you plan to "
3220
 
      "daisy-chain the slaves."),
3221
 
   (char**) &opt_log_slave_updates, (char**) &opt_log_slave_updates,
3222
 
   0, GET_BOOL,
 
3335
   "Tells the slave to log the updates from the slave thread to the binary log. You will need to turn it on if you plan to daisy-chain the slaves.",
 
3336
   (char**) &opt_log_slave_updates, (char**) &opt_log_slave_updates, 0, GET_BOOL,
3223
3337
   NO_ARG, 0, 0, 0, 0, 0, 0},
 
3338
  {"log-slow-admin-statements", OPT_LOG_SLOW_ADMIN_STATEMENTS,
 
3339
   "Log slow OPTIMIZE, ANALYZE, ALTER and other administrative statements to the slow log if it is open.",
 
3340
   (char**) &opt_log_slow_admin_statements,
 
3341
   (char**) &opt_log_slow_admin_statements,
 
3342
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3343
 {"log-slow-slave-statements", OPT_LOG_SLOW_SLAVE_STATEMENTS,
 
3344
  "Log slow statements executed by slave thread to the slow log if it is open.",
 
3345
  (char**) &opt_log_slow_slave_statements,
 
3346
  (char**) &opt_log_slow_slave_statements,
 
3347
  0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3348
  {"log-slow-queries", OPT_SLOW_QUERY_LOG,
 
3349
    "Log slow queries to a table or log file. Defaults logging to table mysql.slow_log or hostname-slow.log if --log-output=file is used. Must be enabled to activate other slow log options.",
 
3350
   (char**) &opt_slow_logname, (char**) &opt_slow_logname, 0, GET_STR, OPT_ARG,
 
3351
   0, 0, 0, 0, 0, 0},
3224
3352
  {"log-tc", OPT_LOG_TC,
3225
 
   N_("Path to transaction coordinator log (used for transactions that affect "
3226
 
      "more than one storage engine, when binary log is disabled)"),
 
3353
   "Path to transaction coordinator log (used for transactions that affect "
 
3354
   "more than one storage engine, when binary log is disabled)",
3227
3355
   (char**) &opt_tc_log_file, (char**) &opt_tc_log_file, 0, GET_STR,
3228
3356
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3229
3357
#ifdef HAVE_MMAP
3230
 
  {"log-tc-size", OPT_LOG_TC_SIZE,
3231
 
   N_("Size of transaction coordinator log."),
 
3358
  {"log-tc-size", OPT_LOG_TC_SIZE, "Size of transaction coordinator log.",
3232
3359
   (char**) &opt_tc_log_size, (char**) &opt_tc_log_size, 0, GET_ULONG,
3233
3360
   REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, ULONG_MAX, 0,
3234
3361
   TC_LOG_PAGE_SIZE, 0},
3235
3362
#endif
3236
 
  {"log-warnings", 'W',
3237
 
   N_("Log some not critical warnings to the log file."),
 
3363
  {"log-warnings", 'W', "Log some not critical warnings to the log file.",
3238
3364
   (char**) &global_system_variables.log_warnings,
3239
3365
   (char**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, 0,
3240
3366
   0, 0, 0},
3241
3367
  {"low-priority-updates", OPT_LOW_PRIORITY_UPDATES,
3242
 
   N_("INSERT/DELETE/UPDATE has lower priority than selects."),
 
3368
   "INSERT/DELETE/UPDATE has lower priority than selects.",
3243
3369
   (char**) &global_system_variables.low_priority_updates,
3244
3370
   (char**) &max_system_variables.low_priority_updates,
3245
3371
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3246
3372
  {"master-info-file", OPT_MASTER_INFO_FILE,
3247
 
   N_("The location and name of the file that remembers the master and "
3248
 
      "where the I/O replication thread is in the master's binlogs."),
 
3373
   "The location and name of the file that remembers the master and where the I/O replication \
 
3374
thread is in the master's binlogs.",
3249
3375
   (char**) &master_info_file, (char**) &master_info_file, 0, GET_STR,
3250
3376
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3251
3377
  {"master-retry-count", OPT_MASTER_RETRY_COUNT,
3252
 
   N_("The number of tries the slave will make to connect to the master "
3253
 
      "before giving up."),
 
3378
   "The number of tries the slave will make to connect to the master before giving up.",
3254
3379
   (char**) &master_retry_count, (char**) &master_retry_count, 0, GET_ULONG,
3255
3380
   REQUIRED_ARG, 3600*24, 0, 0, 0, 0, 0},
3256
3381
  {"max-binlog-dump-events", OPT_MAX_BINLOG_DUMP_EVENTS,
3257
 
   N_("Option used by mysql-test for debugging and testing of replication."),
 
3382
   "Option used by mysql-test for debugging and testing of replication.",
3258
3383
   (char**) &max_binlog_dump_events, (char**) &max_binlog_dump_events, 0,
3259
3384
   GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3260
 
  {"memlock", OPT_MEMLOCK,
3261
 
   N_("Lock mysqld in memory."),
3262
 
   (char**) &locked_in_memory,
 
3385
  {"memlock", OPT_MEMLOCK, "Lock mysqld in memory.", (char**) &locked_in_memory,
3263
3386
   (char**) &locked_in_memory, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3264
3387
  {"myisam-recover", OPT_MYISAM_RECOVER,
3265
 
   N_("Syntax: myisam-recover[=option[,option...]], where option can be "
3266
 
      "DEFAULT, BACKUP, FORCE or QUICK."),
 
3388
   "Syntax: myisam-recover[=option[,option...]], where option can be DEFAULT, BACKUP, FORCE or QUICK.",
3267
3389
   (char**) &myisam_recover_options_str, (char**) &myisam_recover_options_str, 0,
3268
3390
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
3269
 
  {"new", 'n',
3270
 
   N_("Use very new possible 'unsafe' functions."),
 
3391
  {"new", 'n', "Use very new possible 'unsafe' functions.",
3271
3392
   (char**) &global_system_variables.new_mode,
3272
3393
   (char**) &max_system_variables.new_mode,
3273
3394
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3274
3395
  {"old-alter-table", OPT_OLD_ALTER_TABLE,
3275
 
   N_("Use old, non-optimized alter table."),
 
3396
   "Use old, non-optimized alter table.",
3276
3397
   (char**) &global_system_variables.old_alter_table,
3277
3398
   (char**) &max_system_variables.old_alter_table, 0, GET_BOOL, NO_ARG,
3278
3399
   0, 0, 0, 0, 0, 0},
3279
 
  {"pid-file", OPT_PID_FILE,
3280
 
   N_("Pid file used by safe_mysqld."),
 
3400
  {"old-style-user-limits", OPT_OLD_STYLE_USER_LIMITS,
 
3401
   "Enable old-style user limits (before 5.0.3 user resources were counted per each user+host vs. per account)",
 
3402
   (char**) &opt_old_style_user_limits, (char**) &opt_old_style_user_limits,
 
3403
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3404
  {"pid-file", OPT_PID_FILE, "Pid file used by safe_mysqld.",
3281
3405
   (char**) &pidfile_name_ptr, (char**) &pidfile_name_ptr, 0, GET_STR,
3282
3406
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3283
 
  {"port", 'P',
3284
 
   N_("Port number to use for connection or 0 for default to, in "
3285
 
      "order of preference, my.cnf, $DRIZZLE_TCP_PORT, "
3286
 
      "built-in default (" STRINGIFY_ARG(DRIZZLE_PORT) ")."),
 
3407
  {"port", 'P', "Port number to use for connection or 0 for default to, in "
 
3408
   "order of preference, my.cnf, $MYSQL_TCP_PORT, "
 
3409
#if MYSQL_PORT_DEFAULT == 0
 
3410
   "/etc/services, "
 
3411
#endif
 
3412
   "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",
3287
3413
   (char**) &mysqld_port,
3288
3414
   (char**) &mysqld_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3289
3415
  {"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,
3290
 
   N_("Maximum time in seconds to wait for the port to become free. "
3291
 
      "(Default: no wait)"),
3292
 
   (char**) &mysqld_port_timeout,
 
3416
   "Maximum time in seconds to wait for the port to become free. "
 
3417
   "(Default: no wait)", (char**) &mysqld_port_timeout,
3293
3418
   (char**) &mysqld_port_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3294
3419
  {"relay-log", OPT_RELAY_LOG,
3295
 
   N_("The location and name to use for relay logs."),
 
3420
   "The location and name to use for relay logs.",
3296
3421
   (char**) &opt_relay_logname, (char**) &opt_relay_logname, 0,
3297
3422
   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3298
3423
  {"relay-log-index", OPT_RELAY_LOG_INDEX,
3299
 
   N_("The location and name to use for the file that keeps a list of the "
3300
 
      "last relay logs."),
 
3424
   "The location and name to use for the file that keeps a list of the last \
 
3425
relay logs.",
3301
3426
   (char**) &opt_relaylog_index_name, (char**) &opt_relaylog_index_name, 0,
3302
3427
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3303
3428
  {"relay-log-info-file", OPT_RELAY_LOG_INFO_FILE,
3304
 
   N_("The location and name of the file that remembers where the SQL "
3305
 
      "replication thread is in the relay logs."),
 
3429
   "The location and name of the file that remembers where the SQL replication \
 
3430
thread is in the relay logs.",
3306
3431
   (char**) &relay_log_info_file, (char**) &relay_log_info_file, 0, GET_STR,
3307
3432
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3308
3433
  {"replicate-do-db", OPT_REPLICATE_DO_DB,
3309
 
   N_("Tells the slave thread to restrict replication to the specified "
3310
 
      "database. To specify more than one database, use the directive "
3311
 
      "multiple times, once for each database. Note that this will only work "
3312
 
      "if you do not use cross-database queries such as UPDATE "
3313
 
      "some_db.some_table SET foo='bar' while having selected a different or "
3314
 
      "no database. If you need cross database updates to work, use "
3315
 
      "replicate-wild-do-table=db_name.%."),
 
3434
   "Tells the slave thread to restrict replication to the specified database. To specify more than one database, use the directive multiple times, once for each database. Note that this will only work if you do not use cross-database queries such as UPDATE some_db.some_table SET foo='bar' while having selected a different or no database. If you need cross database updates to work, make sure you have 3.23.28 or later, and use replicate-wild-do-table=db_name.%.",
3316
3435
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3317
3436
  {"replicate-do-table", OPT_REPLICATE_DO_TABLE,
3318
 
   N_("Tells the slave thread to restrict replication to the specified table. "
3319
 
      "To specify more than one table, use the directive multiple times, once "
3320
 
      "for each table. This will work for cross-database updates, in contrast "
3321
 
      "to replicate-do-db."),
 
3437
   "Tells the slave thread to restrict replication to the specified table. To specify more than one table, use the directive multiple times, once for each table. This will work for cross-database updates, in contrast to replicate-do-db.",
3322
3438
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3323
3439
  {"replicate-ignore-db", OPT_REPLICATE_IGNORE_DB,
3324
 
   N_("Tells the slave thread to not replicate to the specified database. To "
3325
 
      "specify more than one database to ignore, use the directive multiple "
3326
 
      "times, once for each database. This option will not work if you use "
3327
 
      "cross database updates. If you need cross database updates to work, "
3328
 
      "use replicate-wild-ignore-table=db_name.%. "),
 
3440
   "Tells the slave thread to not replicate to the specified database. To specify more than one database to ignore, use the directive multiple times, once for each database. This option will not work if you use cross database updates. If you need cross database updates to work, make sure you have 3.23.28 or later, and use replicate-wild-ignore-table=db_name.%. ",
3329
3441
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3330
3442
  {"replicate-ignore-table", OPT_REPLICATE_IGNORE_TABLE,
3331
 
   N_("Tells the slave thread to not replicate to the specified table. To "
3332
 
      "specify more than one table to ignore, use the directive multiple "
3333
 
      "times, once for each table. This will work for cross-datbase updates, "
3334
 
      "in contrast to replicate-ignore-db."),
 
3443
   "Tells the slave thread to not replicate to the specified table. To specify more than one table to ignore, use the directive multiple times, once for each table. This will work for cross-datbase updates, in contrast to replicate-ignore-db.",
3335
3444
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3336
3445
  {"replicate-rewrite-db", OPT_REPLICATE_REWRITE_DB,
3337
 
   N_("Updates to a database with a different name than the original. "
3338
 
      "Example: replicate-rewrite-db=master_db_name->slave_db_name."),
 
3446
   "Updates to a database with a different name than the original. Example: replicate-rewrite-db=master_db_name->slave_db_name.",
3339
3447
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3340
3448
  {"replicate-same-server-id", OPT_REPLICATE_SAME_SERVER_ID,
3341
 
   N_("In replication, if set to 1, do not skip events having our server id. "
3342
 
      "Default value is 0 (to break infinite loops in circular replication). "
3343
 
      "Can't be set to 1 if --log-slave-updates is used."),
 
3449
   "In replication, if set to 1, do not skip events having our server id. \
 
3450
Default value is 0 (to break infinite loops in circular replication). \
 
3451
Can't be set to 1 if --log-slave-updates is used.",
3344
3452
   (char**) &replicate_same_server_id,
3345
3453
   (char**) &replicate_same_server_id,
3346
3454
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3347
3455
  {"replicate-wild-do-table", OPT_REPLICATE_WILD_DO_TABLE,
3348
 
   N_("Tells the slave thread to restrict replication to the tables that "
3349
 
      "match the specified wildcard pattern. To specify more than one table, "
3350
 
      "use the directive multiple times, once for each table. This will work "
3351
 
      "for cross-database updates. Example: replicate-wild-do-table=foo%.bar% "
3352
 
      "will replicate only updates to tables in all databases that start with "
3353
 
      "foo and whose table names start with bar."),
 
3456
   "Tells the slave thread to restrict replication to the tables that match the specified wildcard pattern. To specify more than one table, use the directive multiple times, once for each table. This will work for cross-database updates. Example: replicate-wild-do-table=foo%.bar% will replicate only updates to tables in all databases that start with foo and whose table names start with bar.",
3354
3457
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3355
3458
  {"replicate-wild-ignore-table", OPT_REPLICATE_WILD_IGNORE_TABLE,
3356
 
   N_("Tells the slave thread to not replicate to the tables that match the "
3357
 
      "given wildcard pattern. To specify more than one table to ignore, use "
3358
 
      "the directive multiple times, once for each table. This will work for "
3359
 
      "cross-database updates. Example: replicate-wild-ignore-table=foo%.bar% "
3360
 
      "will not do updates to tables in databases that start with foo and "
3361
 
      "whose table names start with bar."),
 
3459
   "Tells the slave thread to not replicate to the tables that match the given wildcard pattern. To specify more than one table to ignore, use the directive multiple times, once for each table. This will work for cross-database updates. Example: replicate-wild-ignore-table=foo%.bar% will not do updates to tables in databases that start with foo and whose table names start with bar.",
3362
3460
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3363
3461
  // In replication, we may need to tell the other servers how to connect
3364
3462
  {"report-host", OPT_REPORT_HOST,
3365
 
   N_("Hostname or IP of the slave to be reported to to the master during "
3366
 
      "slave registration. Will appear in the output of SHOW SLAVE HOSTS. "
3367
 
      "Leave unset if you do not want the slave to register itself with the "
3368
 
      "master. Note that it is not sufficient for the master to simply read "
3369
 
      "the IP of the slave off the socket once the slave connects. Due to NAT "
3370
 
      "and other routing issues, that IP may not be valid for connecting to "
3371
 
      "the slave from the master or other hosts."),
 
3463
   "Hostname or IP of the slave to be reported to to the master during slave registration. Will appear in the output of SHOW SLAVE HOSTS. Leave unset if you do not want the slave to register itself with the master. Note that it is not sufficient for the master to simply read the IP of the slave off the socket once the slave connects. Due to NAT and other routing issues, that IP may not be valid for connecting to the slave from the master or other hosts.",
3372
3464
   (char**) &report_host, (char**) &report_host, 0, GET_STR, REQUIRED_ARG, 0, 0,
3373
3465
   0, 0, 0, 0},
3374
3466
  {"report-password", OPT_REPORT_PASSWORD, "Undocumented.",
3375
3467
   (char**) &report_password, (char**) &report_password, 0, GET_STR,
3376
3468
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3377
3469
  {"report-port", OPT_REPORT_PORT,
3378
 
   N_("Port for connecting to slave reported to the master during slave "
3379
 
      "registration. Set it only if the slave is listening on a non-default "
3380
 
      "port or if you have a special tunnel from the master or other clients "
3381
 
      "to the slave. If not sure, leave this option unset."),
 
3470
   "Port for connecting to slave reported to the master during slave registration. Set it only if the slave is listening on a non-default port or if you have a special tunnel from the master or other clients to the slave. If not sure, leave this option unset.",
3382
3471
   (char**) &report_port, (char**) &report_port, 0, GET_UINT, REQUIRED_ARG,
3383
 
   DRIZZLE_PORT, 0, 0, 0, 0, 0},
3384
 
  {"safe-mode", OPT_SAFE,
3385
 
   N_("Skip some optimize stages (for testing)."),
 
3472
   MYSQL_PORT, 0, 0, 0, 0, 0},
 
3473
  {"safe-mode", OPT_SAFE, "Skip some optimize stages (for testing).",
3386
3474
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3387
3475
  {"secure-file-priv", OPT_SECURE_FILE_PRIV,
3388
 
   N_("Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files "
3389
 
      "within specified directory"),
 
3476
   "Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files within specified directory",
3390
3477
   (char**) &opt_secure_file_priv, (char**) &opt_secure_file_priv, 0,
3391
3478
   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3392
3479
  {"server-id", OPT_SERVER_ID,
3393
 
   N_("Uniquely identifies the server instance in the community of "
3394
 
      "replication partners."),
 
3480
   "Uniquely identifies the server instance in the community of replication partners.",
3395
3481
   (char**) &server_id, (char**) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,
3396
3482
   0, 0, 0},
3397
 
  {"skip-new", OPT_SKIP_NEW,
3398
 
   N_("Don't use new, possible wrong routines."),
 
3483
  {"set-variable", 'O',
 
3484
   "Change the value of a variable. Please note that this option is deprecated;you can set variables directly with --variable-name=value.",
 
3485
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3486
  {"skip-new", OPT_SKIP_NEW, "Don't use new, possible wrong routines.",
3399
3487
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3400
3488
  {"skip-slave-start", OPT_SKIP_SLAVE_START,
3401
 
   N_("If set, slave is not autostarted."),
3402
 
   (char**) &opt_skip_slave_start,
 
3489
   "If set, slave is not autostarted.", (char**) &opt_skip_slave_start,
3403
3490
   (char**) &opt_skip_slave_start, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3404
3491
  {"skip-stack-trace", OPT_SKIP_STACK_TRACE,
3405
 
   N_("Don't print a stack trace on failure."),
3406
 
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
 
3492
   "Don't print a stack trace on failure.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
3407
3493
   0, 0, 0, 0},
 
3494
  {"skip-symlink", OPT_SKIP_SYMLINKS, "Don't allow symlinking of tables. Deprecated option.  Use --skip-symbolic-links instead.",
 
3495
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3408
3496
  {"skip-thread-priority", OPT_SKIP_PRIOR,
3409
 
   N_("Don't give threads different priorities."),
3410
 
   0, 0, 0, GET_NO_ARG, NO_ARG,
 
3497
   "Don't give threads different priorities.", 0, 0, 0, GET_NO_ARG, NO_ARG,
3411
3498
   DEFAULT_SKIP_THREAD_PRIORITY, 0, 0, 0, 0, 0},
3412
3499
  {"slave-load-tmpdir", OPT_SLAVE_LOAD_TMPDIR,
3413
 
   N_("The location where the slave should put its temporary files when "
3414
 
      "replicating a LOAD DATA INFILE command."),
 
3500
   "The location where the slave should put its temporary files when \
 
3501
replicating a LOAD DATA INFILE command.",
3415
3502
   (char**) &slave_load_tmpdir, (char**) &slave_load_tmpdir, 0, GET_STR_ALLOC,
3416
3503
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3417
3504
  {"slave-skip-errors", OPT_SLAVE_SKIP_ERRORS,
3418
 
   N_("Tells the slave thread to continue replication when a query event "
3419
 
      "returns an error from the provided list."),
 
3505
   "Tells the slave thread to continue replication when a query event returns an error from the provided list.",
3420
3506
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3421
3507
  {"slave-exec-mode", OPT_SLAVE_EXEC_MODE,
3422
 
   N_("Modes for how replication events should be executed.  Legal values are "
3423
 
      "STRICT (default) and IDEMPOTENT. In IDEMPOTENT mode, replication will "
3424
 
      "not stop for operations that are idempotent. In STRICT mode, "
3425
 
      "replication will stop on any unexpected difference between the master "
3426
 
      "and the slave."),
3427
 
   (char**) &slave_exec_mode_str, (char**) &slave_exec_mode_str,
3428
 
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3508
   "Modes for how replication events should be executed.  Legal values are STRICT (default) and IDEMPOTENT. In IDEMPOTENT mode, replication will not stop for operations that are idempotent. In STRICT mode, replication will stop on any unexpected difference between the master and the slave.",
 
3509
   (char**) &slave_exec_mode_str, (char**) &slave_exec_mode_str, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3510
  {"slow-query-log", OPT_SLOW_LOG,
 
3511
   "Enable|disable slow query log", (char**) &opt_slow_log,
 
3512
   (char**) &opt_slow_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
3429
3513
  {"sql-bin-update-same", OPT_SQL_BIN_UPDATE_SAME,
3430
 
   N_("(INGORED)"),
 
3514
   "The update log is deprecated since version 5.0, is replaced by the binary \
 
3515
log and this option does nothing anymore.",
3431
3516
   0, 0, 0, GET_DISABLED, NO_ARG, 0, 0, 0, 0, 0, 0},
3432
 
  {"symbolic-links", 's',
3433
 
   N_("Enable symbolic link support."),
 
3517
  {"symbolic-links", 's', "Enable symbolic link support.",
3434
3518
   (char**) &my_use_symdir, (char**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
3435
3519
   /*
3436
3520
     The system call realpath() produces warnings under valgrind and
3439
3523
   */
3440
3524
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
3441
3525
  {"sysdate-is-now", OPT_SYSDATE_IS_NOW,
3442
 
   N_("Non-default option to alias SYSDATE() to NOW() to make it "
3443
 
      "safe-replicable."),
 
3526
   "Non-default option to alias SYSDATE() to NOW() to make it safe-replicable. Since 5.0, SYSDATE() returns a `dynamic' value different for different invocations, even within the same statement.",
3444
3527
   (char**) &global_system_variables.sysdate_is_now,
3445
3528
   0, 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3446
3529
  {"tc-heuristic-recover", OPT_TC_HEURISTIC_RECOVER,
3447
 
   N_("Decision to use in heuristic recover process. Possible values are "
3448
 
      "COMMIT or ROLLBACK."),
 
3530
   "Decision to use in heuristic recover process. Possible values are COMMIT or ROLLBACK.",
3449
3531
   (char**) &opt_tc_heuristic_recover, (char**) &opt_tc_heuristic_recover,
3450
3532
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3451
3533
  {"temp-pool", OPT_TEMP_POOL,
3452
 
   N_("Using this option will cause most temporary files created to use a "
3453
 
      "small set of names, rather than a unique name for each new file."),
 
3534
   "Using this option will cause most temporary files created to use a small set of names, rather than a unique name for each new file.",
3454
3535
   (char**) &use_temp_pool, (char**) &use_temp_pool, 0, GET_BOOL, NO_ARG, 1,
3455
3536
   0, 0, 0, 0, 0},
3456
3537
  {"timed_mutexes", OPT_TIMED_MUTEXES,
3457
 
   N_("Specify whether to time mutexes (only InnoDB mutexes are currently "
3458
 
      "supported)"),
3459
 
   (char**) &timed_mutexes, (char**) &timed_mutexes, 0, GET_BOOL, NO_ARG, 0,
 
3538
   "Specify whether to time mutexes (only InnoDB mutexes are currently supported)",
 
3539
   (char**) &timed_mutexes, (char**) &timed_mutexes, 0, GET_BOOL, NO_ARG, 0, 
3460
3540
    0, 0, 0, 0, 0},
3461
3541
  {"tmpdir", 't',
3462
 
   N_("Path for temporary files. Several paths may be specified, separated "
3463
 
      "by a colon (:)"
3464
 
      ", in this case they are used in a round-robin fashion."),
 
3542
   "Path for temporary files. Several paths may be specified, separated by a "
 
3543
   "colon (:)"
 
3544
   ", in this case they are used in a round-robin fashion.",
3465
3545
   (char**) &opt_mysql_tmpdir,
3466
3546
   (char**) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3467
3547
  {"transaction-isolation", OPT_TX_ISOLATION,
3468
 
   N_("Default transaction isolation level."),
3469
 
   0, 0, 0, GET_STR, REQUIRED_ARG, 0,
 
3548
   "Default transaction isolation level.", 0, 0, 0, GET_STR, REQUIRED_ARG, 0,
3470
3549
   0, 0, 0, 0, 0},
3471
 
  {"user", 'u',
3472
 
   N_("Run mysqld daemon as user."),
3473
 
   0, 0, 0, GET_STR, REQUIRED_ARG,
 
3550
  {"use-symbolic-links", 's', "Enable symbolic link support. Deprecated option; use --symbolic-links instead.",
 
3551
   (char**) &my_use_symdir, (char**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
 
3552
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
 
3553
  {"user", 'u', "Run mysqld daemon as user.", 0, 0, 0, GET_STR, REQUIRED_ARG,
3474
3554
   0, 0, 0, 0, 0, 0},
3475
 
  {"version", 'V',
3476
 
   N_("Output version information and exit."),
3477
 
   0, 0, 0, GET_NO_ARG,
 
3555
  {"verbose", 'v', "Used with --help option for detailed help",
 
3556
   (char**) &opt_verbose, (char**) &opt_verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
3557
   0, 0},
 
3558
  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,
3478
3559
   NO_ARG, 0, 0, 0, 0, 0, 0},
3479
 
  {"back_log", OPT_BACK_LOG,
3480
 
   N_("The number of outstanding connection requests MySQL can have. This "
3481
 
      "comes into play when the main MySQL thread gets very many connection "
3482
 
      "requests in a very short time."),
 
3560
  {"warnings", 'W', "Deprecated; use --log-warnings instead.",
 
3561
   (char**) &global_system_variables.log_warnings,
 
3562
   (char**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG,
 
3563
   1, 0, ULONG_MAX, 0, 0, 0},
 
3564
  { "back_log", OPT_BACK_LOG,
 
3565
    "The number of outstanding connection requests MySQL can have. This comes into play when the main MySQL thread gets very many connection requests in a very short time.",
3483
3566
    (char**) &back_log, (char**) &back_log, 0, GET_ULONG,
3484
3567
    REQUIRED_ARG, 50, 1, 65535, 0, 1, 0 },
3485
 
  { "binlog_cache_size", OPT_BINLOG_CACHE_SIZE,
3486
 
    N_("The size of the cache to hold the SQL statements for the binary log "
3487
 
       "during a transaction. If you often use big, multi-statement "
3488
 
       "transactions you can increase this to get more performance."),
3489
 
    (char**) &binlog_cache_size, (char**) &binlog_cache_size, 0, GET_ULONG,
3490
 
    REQUIRED_ARG, 32*1024L, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},
3491
 
  { "bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,
3492
 
    N_("Size of tree cache used in bulk insert optimisation. Note that this is "
3493
 
       "a limit per thread!"),
3494
 
    (char**) &global_system_variables.bulk_insert_buff_size,
3495
 
    (char**) &max_system_variables.bulk_insert_buff_size,
3496
 
    0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, ULONG_MAX, 0, 1, 0},
3497
 
  { "connect_timeout", OPT_CONNECT_TIMEOUT,
3498
 
    N_("The number of seconds the mysqld server is waiting for a connect "
3499
 
       "packet before responding with 'Bad handshake'."),
 
3568
  {"binlog_cache_size", OPT_BINLOG_CACHE_SIZE,
 
3569
   "The size of the cache to hold the SQL statements for the binary log during a transaction. If you often use big, multi-statement transactions you can increase this to get more performance.",
 
3570
   (char**) &binlog_cache_size, (char**) &binlog_cache_size, 0, GET_ULONG,
 
3571
   REQUIRED_ARG, 32*1024L, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},
 
3572
  {"bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,
 
3573
   "Size of tree cache used in bulk insert optimisation. Note that this is a limit per thread!",
 
3574
   (char**) &global_system_variables.bulk_insert_buff_size,
 
3575
   (char**) &max_system_variables.bulk_insert_buff_size,
 
3576
   0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, ULONG_MAX, 0, 1, 0},
 
3577
  {"connect_timeout", OPT_CONNECT_TIMEOUT,
 
3578
   "The number of seconds the mysqld server is waiting for a connect packet before responding with 'Bad handshake'.",
3500
3579
    (char**) &connect_timeout, (char**) &connect_timeout,
3501
 
    0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
 
3580
   0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
3502
3581
  { "date_format", OPT_DATE_FORMAT,
3503
 
    N_("The DATE format (For future)."),
3504
 
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_DATE],
3505
 
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_DATE],
 
3582
    "The DATE format (For future).",
 
3583
    (char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
 
3584
    (char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
3506
3585
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3507
3586
  { "datetime_format", OPT_DATETIME_FORMAT,
3508
 
    N_("The DATETIME/TIMESTAMP format (for future)."),
3509
 
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_DATETIME],
3510
 
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_DATETIME],
 
3587
    "The DATETIME/TIMESTAMP format (for future).",
 
3588
    (char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
 
3589
    (char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
3511
3590
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3512
3591
  { "default_week_format", OPT_DEFAULT_WEEK_FORMAT,
3513
 
    N_("The default week format used by WEEK() functions."),
 
3592
    "The default week format used by WEEK() functions.",
3514
3593
    (char**) &global_system_variables.default_week_format,
3515
3594
    (char**) &max_system_variables.default_week_format,
3516
3595
    0, GET_ULONG, REQUIRED_ARG, 0, 0, 7L, 0, 1, 0},
3517
 
  { "div_precision_increment", OPT_DIV_PRECINCREMENT,
3518
 
   N_("Precision of the result of '/' operator will be increased on that "
3519
 
      "value."),
 
3596
  {"div_precision_increment", OPT_DIV_PRECINCREMENT,
 
3597
   "Precision of the result of '/' operator will be increased on that value.",
3520
3598
   (char**) &global_system_variables.div_precincrement,
3521
3599
   (char**) &max_system_variables.div_precincrement, 0, GET_ULONG,
3522
3600
   REQUIRED_ARG, 4, 0, DECIMAL_MAX_SCALE, 0, 0, 0},
3523
 
  { "expire_logs_days", OPT_EXPIRE_LOGS_DAYS,
3524
 
    N_("If non-zero, binary logs will be purged after expire_logs_days "
3525
 
       "days; possible purges happen at startup and at binary log rotation."),
3526
 
    (char**) &expire_logs_days,
3527
 
    (char**) &expire_logs_days, 0, GET_ULONG,
3528
 
    REQUIRED_ARG, 0, 0, 99, 0, 1, 0},
 
3601
  {"expire_logs_days", OPT_EXPIRE_LOGS_DAYS,
 
3602
   "If non-zero, binary logs will be purged after expire_logs_days "
 
3603
   "days; possible purges happen at startup and at binary log rotation.",
 
3604
   (char**) &expire_logs_days,
 
3605
   (char**) &expire_logs_days, 0, GET_ULONG,
 
3606
   REQUIRED_ARG, 0, 0, 99, 0, 1, 0},
3529
3607
  { "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,
3530
 
    N_("The maximum length of the result of function  group_concat."),
 
3608
    "The maximum length of the result of function  group_concat.",
3531
3609
    (char**) &global_system_variables.group_concat_max_len,
3532
3610
    (char**) &max_system_variables.group_concat_max_len, 0, GET_ULONG,
3533
3611
    REQUIRED_ARG, 1024, 4, ULONG_MAX, 0, 1, 0},
3534
 
  { "interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
3535
 
    N_("The number of seconds the server waits for activity on an interactive "
3536
 
       "connection before closing it."),
 
3612
  {"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
 
3613
   "The number of seconds the server waits for activity on an interactive connection before closing it.",
3537
3614
   (char**) &global_system_variables.net_interactive_timeout,
3538
3615
   (char**) &max_system_variables.net_interactive_timeout, 0,
3539
3616
   GET_ULONG, REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
3540
 
  { "join_buffer_size", OPT_JOIN_BUFF_SIZE,
3541
 
    N_("The size of the buffer that is used for full joins."),
 
3617
  {"join_buffer_size", OPT_JOIN_BUFF_SIZE,
 
3618
   "The size of the buffer that is used for full joins.",
3542
3619
   (char**) &global_system_variables.join_buff_size,
3543
3620
   (char**) &max_system_variables.join_buff_size, 0, GET_ULONG,
3544
3621
   REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ULONG_MAX,
3545
3622
   MALLOC_OVERHEAD, IO_SIZE, 0},
3546
3623
  {"keep_files_on_create", OPT_KEEP_FILES_ON_CREATE,
3547
 
   N_("Don't overwrite stale .MYD and .MYI even if no directory is specified."),
 
3624
   "Don't overwrite stale .MYD and .MYI even if no directory is specified.",
3548
3625
   (char**) &global_system_variables.keep_files_on_create,
3549
3626
   (char**) &max_system_variables.keep_files_on_create,
3550
3627
   0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
3551
3628
  {"key_buffer_size", OPT_KEY_BUFFER_SIZE,
3552
 
   N_("The size of the buffer used for index blocks for MyISAM tables. "
3553
 
      "Increase this to get better index handling (for all reads and multiple "
3554
 
      "writes) to as much as you can afford;"),
 
3629
   "The size of the buffer used for index blocks for MyISAM tables. Increase this to get better index handling (for all reads and multiple writes) to as much as you can afford; 64M on a 256M machine that mainly runs MySQL is quite common.",
3555
3630
   (char**) &dflt_key_cache_var.param_buff_size,
3556
3631
   (char**) 0,
3557
3632
   0, (GET_ULL | GET_ASK_ADDR),
3558
3633
   REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, SIZE_T_MAX, MALLOC_OVERHEAD,
3559
3634
   IO_SIZE, 0},
3560
3635
  {"key_cache_age_threshold", OPT_KEY_CACHE_AGE_THRESHOLD,
3561
 
   N_("This characterizes the number of hits a hot block has to be untouched "
3562
 
      "until it is considered aged enough to be downgraded to a warm block. "
3563
 
      "This specifies the percentage ratio of that number of hits to the "
3564
 
      "total number of blocks in key cache"),
 
3636
   "This characterizes the number of hits a hot block has to be untouched until it is considered aged enough to be downgraded to a warm block. This specifies the percentage ratio of that number of hits to the total number of blocks in key cache",
3565
3637
   (char**) &dflt_key_cache_var.param_age_threshold,
3566
3638
   (char**) 0,
3567
 
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
 
3639
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG, 
3568
3640
   300, 100, ULONG_MAX, 0, 100, 0},
3569
3641
  {"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,
3570
 
   N_("The default size of key cache blocks"),
 
3642
   "The default size of key cache blocks",
3571
3643
   (char**) &dflt_key_cache_var.param_block_size,
3572
3644
   (char**) 0,
3573
3645
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
3574
3646
   KEY_CACHE_BLOCK_SIZE, 512, 1024 * 16, 0, 512, 0},
3575
3647
  {"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,
3576
 
   N_("The minimum percentage of warm blocks in key cache"),
 
3648
   "The minimum percentage of warm blocks in key cache",
3577
3649
   (char**) &dflt_key_cache_var.param_division_limit,
3578
3650
   (char**) 0,
3579
3651
   0, (GET_ULONG | GET_ASK_ADDR) , REQUIRED_ARG, 100,
3580
3652
   1, 100, 0, 1, 0},
3581
3653
  {"long_query_time", OPT_LONG_QUERY_TIME,
3582
 
   N_("Log all queries that have taken more than long_query_time seconds to "
3583
 
      "execute to file. The argument will be treated as a decimal value with "
3584
 
      "microsecond precission."),
 
3654
   "Log all queries that have taken more than long_query_time seconds to execute to file. "
 
3655
   "The argument will be treated as a decimal value with microsecond precission.",
3585
3656
   (char**) &long_query_time, (char**) &long_query_time, 0, GET_DOUBLE,
3586
3657
   REQUIRED_ARG, 10, 0, LONG_TIMEOUT, 0, 0, 0},
 
3658
  {"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,
 
3659
   "If set to 1 table names are stored in lowercase on disk and table names will be case-insensitive.  Should be set to 2 if you are using a case insensitive file system",
 
3660
   (char**) &lower_case_table_names,
 
3661
   (char**) &lower_case_table_names, 0, GET_UINT, OPT_ARG,
 
3662
#ifdef FN_NO_CASE_SENCE
 
3663
    1
 
3664
#else
 
3665
    0
 
3666
#endif
 
3667
   , 0, 2, 0, 1, 0},
3587
3668
  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
3588
 
   N_("Max packetlength to send/receive from to server."),
 
3669
   "Max packetlength to send/receive from to server.",
3589
3670
   (char**) &global_system_variables.max_allowed_packet,
3590
3671
   (char**) &max_system_variables.max_allowed_packet, 0, GET_ULONG,
3591
3672
   REQUIRED_ARG, 1024*1024L, 1024, 1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},
3592
3673
  {"max_binlog_cache_size", OPT_MAX_BINLOG_CACHE_SIZE,
3593
 
   N_("Can be used to restrict the total size used to cache a "
3594
 
      "multi-transaction query."),
 
3674
   "Can be used to restrict the total size used to cache a multi-transaction query.",
3595
3675
   (char**) &max_binlog_cache_size, (char**) &max_binlog_cache_size, 0,
3596
3676
   GET_ULONG, REQUIRED_ARG, ULONG_MAX, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},
3597
3677
  {"max_binlog_size", OPT_MAX_BINLOG_SIZE,
3598
 
   N_("Binary log will be rotated automatically when the size exceeds this "
3599
 
      "value. Will also apply to relay logs if max_relay_log_size is 0. "
3600
 
      "The minimum value for this variable is 4096."),
 
3678
   "Binary log will be rotated automatically when the size exceeds this \
 
3679
value. Will also apply to relay logs if max_relay_log_size is 0. \
 
3680
The minimum value for this variable is 4096.",
3601
3681
   (char**) &max_binlog_size, (char**) &max_binlog_size, 0, GET_ULONG,
3602
3682
   REQUIRED_ARG, 1024*1024L*1024L, IO_SIZE, 1024*1024L*1024L, 0, IO_SIZE, 0},
3603
3683
  {"max_connect_errors", OPT_MAX_CONNECT_ERRORS,
3604
 
   N_("If there is more than this number of interrupted connections from a "
3605
 
      "host this host will be blocked from further connections."),
 
3684
   "If there is more than this number of interrupted connections from a host this host will be blocked from further connections.",
3606
3685
   (char**) &max_connect_errors, (char**) &max_connect_errors, 0, GET_ULONG,
3607
 
   REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ULONG_MAX, 0, 1, 0},
 
3686
    REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ULONG_MAX, 0, 1, 0},
3608
3687
  // Default max_connections of 151 is larger than Apache's default max
3609
3688
  // children, to avoid "too many connections" error in a common setup
3610
3689
  {"max_connections", OPT_MAX_CONNECTIONS,
3611
 
   N_("The number of simultaneous clients allowed."),
3612
 
   (char**) &max_connections,
 
3690
   "The number of simultaneous clients allowed.", (char**) &max_connections,
3613
3691
   (char**) &max_connections, 0, GET_ULONG, REQUIRED_ARG, 151, 1, 100000, 0, 1,
3614
3692
   0},
3615
3693
  {"max_error_count", OPT_MAX_ERROR_COUNT,
3616
 
   N_("Max number of errors/warnings to store for a statement."),
 
3694
   "Max number of errors/warnings to store for a statement.",
3617
3695
   (char**) &global_system_variables.max_error_count,
3618
3696
   (char**) &max_system_variables.max_error_count,
3619
3697
   0, GET_ULONG, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 0, 65535, 0, 1, 0},
3620
3698
  {"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,
3621
 
   N_("Don't allow creation of heap tables bigger than this."),
 
3699
   "Don't allow creation of heap tables bigger than this.",
3622
3700
   (char**) &global_system_variables.max_heap_table_size,
3623
3701
   (char**) &max_system_variables.max_heap_table_size, 0, GET_ULL,
3624
3702
   REQUIRED_ARG, 16*1024*1024L, 16384, MAX_MEM_TABLE_SIZE,
3625
3703
   MALLOC_OVERHEAD, 1024, 0},
3626
3704
  {"max_join_size", OPT_MAX_JOIN_SIZE,
3627
 
   N_("Joins that are probably going to read more than max_join_size records "
3628
 
      "return an error."),
 
3705
   "Joins that are probably going to read more than max_join_size records return an error.",
3629
3706
   (char**) &global_system_variables.max_join_size,
3630
3707
   (char**) &max_system_variables.max_join_size, 0, GET_HA_ROWS, REQUIRED_ARG,
3631
 
   INT32_MAX, 1, INT32_MAX, 0, 1, 0},
3632
 
  {"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,
3633
 
   N_("Max number of bytes in sorted records."),
3634
 
   (char**) &global_system_variables.max_length_for_sort_data,
3635
 
   (char**) &max_system_variables.max_length_for_sort_data, 0, GET_ULONG,
3636
 
   REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
 
3708
   ~0L, 1, ~0L, 0, 1, 0},
 
3709
   {"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,
 
3710
    "Max number of bytes in sorted records.",
 
3711
    (char**) &global_system_variables.max_length_for_sort_data,
 
3712
    (char**) &max_system_variables.max_length_for_sort_data, 0, GET_ULONG,
 
3713
    REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
3637
3714
  {"max_relay_log_size", OPT_MAX_RELAY_LOG_SIZE,
3638
 
   N_("If non-zero: relay log will be rotated automatically when the size "
3639
 
      "exceeds this value; if zero (the default): when the size exceeds "
3640
 
      "max_binlog_size. 0 excepted, the minimum value for this variable "
3641
 
      "is 4096."),
 
3715
   "If non-zero: relay log will be rotated automatically when the size exceeds this value; if zero (the default): when the size exceeds max_binlog_size. 0 excepted, the minimum value for this variable is 4096.",
3642
3716
   (char**) &max_relay_log_size, (char**) &max_relay_log_size, 0, GET_ULONG,
3643
3717
   REQUIRED_ARG, 0L, 0L, 1024*1024L*1024L, 0, IO_SIZE, 0},
3644
3718
  { "max_seeks_for_key", OPT_MAX_SEEKS_FOR_KEY,
3645
 
    N_("Limit assumed max number of seeks when looking up rows based on a key"),
 
3719
    "Limit assumed max number of seeks when looking up rows based on a key",
3646
3720
    (char**) &global_system_variables.max_seeks_for_key,
3647
3721
    (char**) &max_system_variables.max_seeks_for_key, 0, GET_ULONG,
3648
3722
    REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0 },
3649
3723
  {"max_sort_length", OPT_MAX_SORT_LENGTH,
3650
 
   N_("The number of bytes to use when sorting BLOB or TEXT values "
3651
 
      "(only the first max_sort_length bytes of each value are used; the "
3652
 
      "rest are ignored)."),
 
3724
   "The number of bytes to use when sorting BLOB or TEXT values (only the first max_sort_length bytes of each value are used; the rest are ignored).",
3653
3725
   (char**) &global_system_variables.max_sort_length,
3654
3726
   (char**) &max_system_variables.max_sort_length, 0, GET_ULONG,
3655
3727
   REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
3656
3728
  {"max_tmp_tables", OPT_MAX_TMP_TABLES,
3657
 
   N_("Maximum number of temporary tables a client can keep open at a time."),
 
3729
   "Maximum number of temporary tables a client can keep open at a time.",
3658
3730
   (char**) &global_system_variables.max_tmp_tables,
3659
3731
   (char**) &max_system_variables.max_tmp_tables, 0, GET_ULONG,
3660
3732
   REQUIRED_ARG, 32, 1, ULONG_MAX, 0, 1, 0},
3661
3733
  {"max_write_lock_count", OPT_MAX_WRITE_LOCK_COUNT,
3662
 
   N_("After this many write locks, allow some read locks to run in between."),
 
3734
   "After this many write locks, allow some read locks to run in between.",
3663
3735
   (char**) &max_write_lock_count, (char**) &max_write_lock_count, 0, GET_ULONG,
3664
3736
   REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0},
3665
3737
  {"min_examined_row_limit", OPT_MIN_EXAMINED_ROW_LIMIT,
3666
 
   N_("Don't log queries which examine less than min_examined_row_limit "
3667
 
      "rows to file."),
 
3738
   "Don't log queries which examine less than min_examined_row_limit rows to file.",
3668
3739
   (char**) &global_system_variables.min_examined_row_limit,
3669
3740
   (char**) &max_system_variables.min_examined_row_limit, 0, GET_ULONG,
3670
 
   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1L, 0},
 
3741
  REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1L, 0},
3671
3742
  {"myisam_block_size", OPT_MYISAM_BLOCK_SIZE,
3672
 
   N_("Block size to be used for MyISAM index pages."),
 
3743
   "Block size to be used for MyISAM index pages.",
3673
3744
   (char**) &opt_myisam_block_size,
3674
3745
   (char**) &opt_myisam_block_size, 0, GET_ULONG, REQUIRED_ARG,
3675
3746
   MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, MI_MAX_KEY_BLOCK_LENGTH,
3676
3747
   0, MI_MIN_KEY_BLOCK_LENGTH, 0},
3677
3748
  {"myisam_data_pointer_size", OPT_MYISAM_DATA_POINTER_SIZE,
3678
 
   N_("Default pointer size to be used for MyISAM tables."),
 
3749
   "Default pointer size to be used for MyISAM tables.",
3679
3750
   (char**) &myisam_data_pointer_size,
3680
3751
   (char**) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,
3681
3752
   6, 2, 7, 0, 1, 0},
 
3753
  {"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
 
3754
   "Deprecated option",
 
3755
   (char**) &global_system_variables.myisam_max_extra_sort_file_size,
 
3756
   (char**) &max_system_variables.myisam_max_extra_sort_file_size,
 
3757
   0, GET_ULL, REQUIRED_ARG, (uint64_t) MI_MAX_TEMP_LENGTH,
 
3758
   0, (uint64_t) MAX_FILE_SIZE, 0, 1, 0},
3682
3759
  {"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,
3683
 
   N_("Don't use the fast sort index method to created index if the "
3684
 
      "temporary file would get bigger than this."),
 
3760
   "Don't use the fast sort index method to created index if the temporary file would get bigger than this.",
3685
3761
   (char**) &global_system_variables.myisam_max_sort_file_size,
3686
3762
   (char**) &max_system_variables.myisam_max_sort_file_size, 0,
3687
3763
   GET_ULL, REQUIRED_ARG, (int64_t) LONG_MAX, 0, (uint64_t) MAX_FILE_SIZE,
3688
3764
   0, 1024*1024, 0},
3689
3765
  {"myisam_repair_threads", OPT_MYISAM_REPAIR_THREADS,
3690
 
   N_("Number of threads to use when repairing MyISAM tables. The value of "
3691
 
      "1 disables parallel repair."),
 
3766
   "Number of threads to use when repairing MyISAM tables. The value of 1 disables parallel repair.",
3692
3767
   (char**) &global_system_variables.myisam_repair_threads,
3693
3768
   (char**) &max_system_variables.myisam_repair_threads, 0,
3694
3769
   GET_ULONG, REQUIRED_ARG, 1, 1, ULONG_MAX, 0, 1, 0},
3695
3770
  {"myisam_sort_buffer_size", OPT_MYISAM_SORT_BUFFER_SIZE,
3696
 
   N_("The buffer that is allocated when sorting the index when doing a "
3697
 
      "REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE."),
 
3771
   "The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE.",
3698
3772
   (char**) &global_system_variables.myisam_sort_buff_size,
3699
3773
   (char**) &max_system_variables.myisam_sort_buff_size, 0,
3700
 
   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, INT32_MAX, 0, 1, 0},
 
3774
   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, ~0L, 0, 1, 0},
3701
3775
  {"myisam_stats_method", OPT_MYISAM_STATS_METHOD,
3702
 
   N_("Specifies how MyISAM index statistics collection code should threat "
3703
 
      "NULLs. Possible values of name are 'nulls_unequal' "
3704
 
      "(default behavior), "
3705
 
      "'nulls_equal' (emulate MySQL 4.0 behavior), and 'nulls_ignored'."),
 
3776
   "Specifies how MyISAM index statistics collection code should threat NULLs. "
 
3777
   "Possible values of name are \"nulls_unequal\" (default behavior for 4.1/5.0), "
 
3778
   "\"nulls_equal\" (emulate 4.0 behavior), and \"nulls_ignored\".",
3706
3779
   (char**) &myisam_stats_method_str, (char**) &myisam_stats_method_str, 0,
3707
3780
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3708
3781
  {"net_buffer_length", OPT_NET_BUFFER_LENGTH,
3709
 
   N_("Buffer length for TCP/IP and socket communication."),
 
3782
   "Buffer length for TCP/IP and socket communication.",
3710
3783
   (char**) &global_system_variables.net_buffer_length,
3711
3784
   (char**) &max_system_variables.net_buffer_length, 0, GET_ULONG,
3712
3785
   REQUIRED_ARG, 16384, 1024, 1024*1024L, 0, 1024, 0},
3713
3786
  {"net_read_timeout", OPT_NET_READ_TIMEOUT,
3714
 
   N_("Number of seconds to wait for more data from a connection before "
3715
 
      "aborting the read."),
 
3787
   "Number of seconds to wait for more data from a connection before aborting the read.",
3716
3788
   (char**) &global_system_variables.net_read_timeout,
3717
3789
   (char**) &max_system_variables.net_read_timeout, 0, GET_ULONG,
3718
3790
   REQUIRED_ARG, NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
3719
3791
  {"net_retry_count", OPT_NET_RETRY_COUNT,
3720
 
   N_("If a read on a communication port is interrupted, retry this many "
3721
 
      "times before giving up."),
 
3792
   "If a read on a communication port is interrupted, retry this many times before giving up.",
3722
3793
   (char**) &global_system_variables.net_retry_count,
3723
3794
   (char**) &max_system_variables.net_retry_count,0,
3724
3795
   GET_ULONG, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, ULONG_MAX, 0, 1, 0},
3725
3796
  {"net_write_timeout", OPT_NET_WRITE_TIMEOUT,
3726
 
   N_("Number of seconds to wait for a block to be written to a connection "
3727
 
      "before aborting the write."),
 
3797
   "Number of seconds to wait for a block to be written to a connection  before aborting the write.",
3728
3798
   (char**) &global_system_variables.net_write_timeout,
3729
3799
   (char**) &max_system_variables.net_write_timeout, 0, GET_ULONG,
3730
3800
   REQUIRED_ARG, NET_WRITE_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
3731
 
  { "old", OPT_OLD_MODE,
3732
 
    N_("Use compatible behavior."),
 
3801
  { "old", OPT_OLD_MODE, "Use compatible behavior.", 
3733
3802
    (char**) &global_system_variables.old_mode,
3734
 
    (char**) &max_system_variables.old_mode, 0, GET_BOOL, NO_ARG,
 
3803
    (char**) &max_system_variables.old_mode, 0, GET_BOOL, NO_ARG, 
3735
3804
    0, 0, 0, 0, 0, 0},
3736
3805
  {"open_files_limit", OPT_OPEN_FILES_LIMIT,
3737
 
   N_("If this is not 0, then mysqld will use this value to reserve file "
3738
 
      "descriptors to use with setrlimit(). If this value is 0 then mysqld "
3739
 
      "will reserve max_connections*5 or max_connections + table_cache*2 "
3740
 
      "(whichever is larger) number of files."),
 
3806
   "If this is not 0, then mysqld will use this value to reserve file descriptors to use with setrlimit(). If this value is 0 then mysqld will reserve max_connections*5 or max_connections + table_cache*2 (whichever is larger) number of files.",
3741
3807
   (char**) &open_files_limit, (char**) &open_files_limit, 0, GET_ULONG,
3742
3808
   REQUIRED_ARG, 0, 0, OS_FILE_LIMIT, 0, 1, 0},
3743
3809
  {"optimizer_prune_level", OPT_OPTIMIZER_PRUNE_LEVEL,
3744
 
   N_("Controls the heuristic(s) applied during query optimization to prune "
3745
 
      "less-promising partial plans from the optimizer search space. Meaning: "
3746
 
      "0 - do not apply any heuristic, thus perform exhaustive search; "
3747
 
      "1 - prune plans based on number of retrieved rows."),
 
3810
   "Controls the heuristic(s) applied during query optimization to prune less-promising partial plans from the optimizer search space. Meaning: 0 - do not apply any heuristic, thus perform exhaustive search; 1 - prune plans based on number of retrieved rows.",
3748
3811
   (char**) &global_system_variables.optimizer_prune_level,
3749
3812
   (char**) &max_system_variables.optimizer_prune_level,
3750
3813
   0, GET_ULONG, OPT_ARG, 1, 0, 1, 0, 1, 0},
3751
3814
  {"optimizer_search_depth", OPT_OPTIMIZER_SEARCH_DEPTH,
3752
 
   N_("Maximum depth of search performed by the query optimizer. Values "
3753
 
      "larger than the number of relations in a query result in better query "
3754
 
      "plans, but take longer to compile a query. Smaller values than the "
3755
 
      "number of tables in a relation result in faster optimization, but may "
3756
 
      "produce very bad query plans. If set to 0, the system will "
3757
 
      "automatically pick a reasonable value; if set to MAX_TABLES+2, the "
3758
 
      "optimizer will switch to the original find_best (used for "
3759
 
      "testing/comparison)."),
 
3815
   "Maximum depth of search performed by the query optimizer. Values larger than the number of relations in a query result in better query plans, but take longer to compile a query. Smaller values than the number of tables in a relation result in faster optimization, but may produce very bad query plans. If set to 0, the system will automatically pick a reasonable value; if set to MAX_TABLES+2, the optimizer will switch to the original find_best (used for testing/comparison).",
3760
3816
   (char**) &global_system_variables.optimizer_search_depth,
3761
3817
   (char**) &max_system_variables.optimizer_search_depth,
3762
3818
   0, GET_ULONG, OPT_ARG, MAX_TABLES+1, 0, MAX_TABLES+2, 0, 1, 0},
3763
3819
  {"plugin_dir", OPT_PLUGIN_DIR,
3764
 
   N_("Directory for plugins."),
 
3820
   "Directory for plugins.",
3765
3821
   (char**) &opt_plugin_dir_ptr, (char**) &opt_plugin_dir_ptr, 0,
3766
3822
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3767
3823
  {"plugin_load", OPT_PLUGIN_LOAD,
3768
 
   N_("Optional comma separated list of plugins to load, where each plugin is "
3769
 
      "identified by the name of the shared library. "
3770
 
      "[for example: --plugin_load=libmd5udf.so]"),
 
3824
   "Optional colon separated list of plugins to load, where each plugin is "
 
3825
   "identified by name and path to library seperated by an equals.",
3771
3826
   (char**) &opt_plugin_load, (char**) &opt_plugin_load, 0,
3772
3827
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3773
3828
  {"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,
3774
 
   N_("The size of the buffer that is allocated when preloading indexes"),
 
3829
   "The size of the buffer that is allocated when preloading indexes",
3775
3830
   (char**) &global_system_variables.preload_buff_size,
3776
3831
   (char**) &max_system_variables.preload_buff_size, 0, GET_ULONG,
3777
3832
   REQUIRED_ARG, 32*1024L, 1024, 1024*1024*1024L, 0, 1, 0},
3778
3833
  {"query_alloc_block_size", OPT_QUERY_ALLOC_BLOCK_SIZE,
3779
 
   N_("Allocation block size for query parsing and execution"),
 
3834
   "Allocation block size for query parsing and execution",
3780
3835
   (char**) &global_system_variables.query_alloc_block_size,
3781
3836
   (char**) &max_system_variables.query_alloc_block_size, 0, GET_ULONG,
3782
3837
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
3783
3838
  {"query_prealloc_size", OPT_QUERY_PREALLOC_SIZE,
3784
 
   N_("Persistent buffer for query parsing and execution"),
 
3839
   "Persistent buffer for query parsing and execution",
3785
3840
   (char**) &global_system_variables.query_prealloc_size,
3786
3841
   (char**) &max_system_variables.query_prealloc_size, 0, GET_ULONG,
3787
3842
   REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,
3788
3843
   ULONG_MAX, 0, 1024, 0},
3789
3844
  {"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,
3790
 
   N_("Allocation block size for storing ranges during optimization"),
 
3845
   "Allocation block size for storing ranges during optimization",
3791
3846
   (char**) &global_system_variables.range_alloc_block_size,
3792
3847
   (char**) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,
3793
3848
   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, ULONG_MAX,
3794
3849
   0, 1024, 0},
3795
3850
  {"read_buffer_size", OPT_RECORD_BUFFER,
3796
 
   N_("Each thread that does a sequential scan allocates a buffer of this "
3797
 
      "size for each table it scans. If you do many sequential scans, you may "
3798
 
      "want to increase this value."),
 
3851
   "Each thread that does a sequential scan allocates a buffer of this size for each table it scans. If you do many sequential scans, you may want to increase this value.",
3799
3852
   (char**) &global_system_variables.read_buff_size,
3800
3853
   (char**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
3801
3854
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT32_MAX, MALLOC_OVERHEAD, IO_SIZE,
3802
3855
   0},
3803
3856
  {"read_only", OPT_READONLY,
3804
 
   N_("Make all non-temporary tables read-only, with the exception for "
3805
 
      "replication (slave) threads and users with the SUPER privilege"),
 
3857
   "Make all non-temporary tables read-only, with the exception for replication (slave) threads and users with the SUPER privilege",
3806
3858
   (char**) &opt_readonly,
3807
3859
   (char**) &opt_readonly,
3808
3860
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3809
3861
  {"read_rnd_buffer_size", OPT_RECORD_RND_BUFFER,
3810
 
   N_("When reading rows in sorted order after a sort, the rows are read "
3811
 
      "through this buffer to avoid a disk seeks. If not set, then it's set "
3812
 
      "to the value of record_buffer."),
 
3862
   "When reading rows in sorted order after a sort, the rows are read through this buffer to avoid a disk seeks. If not set, then it's set to the value of record_buffer.",
3813
3863
   (char**) &global_system_variables.read_rnd_buff_size,
3814
3864
   (char**) &max_system_variables.read_rnd_buff_size, 0,
3815
3865
   GET_ULONG, REQUIRED_ARG, 256*1024L, 64 /*IO_SIZE*2+MALLOC_OVERHEAD*/ ,
3818
3868
   "Alias for read_buffer_size",
3819
3869
   (char**) &global_system_variables.read_buff_size,
3820
3870
   (char**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
3821
 
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD,
3822
 
   INT32_MAX, MALLOC_OVERHEAD, IO_SIZE, 0},
 
3871
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT32_MAX, MALLOC_OVERHEAD, IO_SIZE, 0},
3823
3872
  {"relay_log_purge", OPT_RELAY_LOG_PURGE,
3824
 
   N_("0 = do not purge relay logs. "
3825
 
      "1 = purge them as soon as they are no more needed."),
 
3873
   "0 = do not purge relay logs. 1 = purge them as soon as they are no more needed.",
3826
3874
   (char**) &relay_log_purge,
3827
3875
   (char**) &relay_log_purge, 0, GET_BOOL, NO_ARG,
3828
3876
   1, 0, 1, 0, 1, 0},
3829
3877
  {"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,
3830
 
   N_("Maximum space to use for all relay logs."),
 
3878
   "Maximum space to use for all relay logs.",
3831
3879
   (char**) &relay_log_space_limit,
3832
3880
   (char**) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,
3833
3881
   (int64_t) ULONG_MAX, 0, 1, 0},
3834
3882
  {"slave_compressed_protocol", OPT_SLAVE_COMPRESSED_PROTOCOL,
3835
 
   N_("Use compression on master/slave protocol."),
 
3883
   "Use compression on master/slave protocol.",
3836
3884
   (char**) &opt_slave_compressed_protocol,
3837
3885
   (char**) &opt_slave_compressed_protocol,
3838
3886
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3839
3887
  {"slave_net_timeout", OPT_SLAVE_NET_TIMEOUT,
3840
 
   N_("Number of seconds to wait for more data from a master/slave connection "
3841
 
      "before aborting the read."),
 
3888
   "Number of seconds to wait for more data from a master/slave connection before aborting the read.",
3842
3889
   (char**) &slave_net_timeout, (char**) &slave_net_timeout, 0,
3843
3890
   GET_ULONG, REQUIRED_ARG, SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
3844
3891
  {"slave_transaction_retries", OPT_SLAVE_TRANS_RETRIES,
3845
 
   N_("Number of times the slave SQL thread will retry a transaction in case "
3846
 
      "it failed with a deadlock or elapsed lock wait timeout, "
3847
 
      "before giving up and stopping."),
 
3892
   "Number of times the slave SQL thread will retry a transaction in case "
 
3893
   "it failed with a deadlock or elapsed lock wait timeout, "
 
3894
   "before giving up and stopping.",
3848
3895
   (char**) &slave_trans_retries, (char**) &slave_trans_retries, 0,
3849
3896
   GET_ULONG, REQUIRED_ARG, 10L, 0L, (int64_t) ULONG_MAX, 0, 1, 0},
3850
3897
  {"slave-allow-batching", OPT_SLAVE_ALLOW_BATCHING,
3851
 
   N_("Allow slave to batch requests."),
 
3898
   "Allow slave to batch requests.",
3852
3899
   (char**) &slave_allow_batching, (char**) &slave_allow_batching,
3853
3900
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3854
3901
  {"slow_launch_time", OPT_SLOW_LAUNCH_TIME,
3855
 
   N_("If creating the thread takes longer than this value (in seconds), the "
3856
 
      "Slow_launch_threads counter will be incremented."),
 
3902
   "If creating the thread takes longer than this value (in seconds), the Slow_launch_threads counter will be incremented.",
3857
3903
   (char**) &slow_launch_time, (char**) &slow_launch_time, 0, GET_ULONG,
3858
3904
   REQUIRED_ARG, 2L, 0L, LONG_TIMEOUT, 0, 1, 0},
3859
3905
  {"sort_buffer_size", OPT_SORT_BUFFER,
3860
 
   N_("Each thread that needs to do a sort allocates a buffer of this size."),
 
3906
   "Each thread that needs to do a sort allocates a buffer of this size.",
3861
3907
   (char**) &global_system_variables.sortbuff_size,
3862
3908
   (char**) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
3863
3909
   MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ULONG_MAX,
3864
3910
   MALLOC_OVERHEAD, 1, 0},
3865
3911
  {"sync-binlog", OPT_SYNC_BINLOG,
3866
 
   N_("Synchronously flush binary log to disk after every #th event. "
3867
 
      "Use 0 (default) to disable synchronous flushing."),
 
3912
   "Synchronously flush binary log to disk after every #th event. "
 
3913
   "Use 0 (default) to disable synchronous flushing.",
3868
3914
   (char**) &sync_binlog_period, (char**) &sync_binlog_period, 0, GET_ULONG,
3869
3915
   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1, 0},
 
3916
  {"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default.",
 
3917
   (char**) &opt_sync_frm, (char**) &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,
 
3918
   0, 0, 0, 0},
 
3919
  {"table_cache", OPT_TABLE_OPEN_CACHE,
 
3920
   "Deprecated; use --table_open_cache instead.",
 
3921
   (char**) &table_cache_size, (char**) &table_cache_size, 0, GET_ULONG,
 
3922
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
3870
3923
  {"table_definition_cache", OPT_TABLE_DEF_CACHE,
3871
 
   N_("The number of cached table definitions."),
 
3924
   "The number of cached table definitions.",
3872
3925
   (char**) &table_def_size, (char**) &table_def_size,
3873
3926
   0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
3874
3927
  {"table_open_cache", OPT_TABLE_OPEN_CACHE,
3875
 
   N_("The number of cached open tables."),
 
3928
   "The number of cached open tables.",
3876
3929
   (char**) &table_cache_size, (char**) &table_cache_size, 0, GET_ULONG,
3877
3930
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
3878
3931
  {"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,
3879
 
   N_("Timeout in seconds to wait for a table level lock before returning an "
3880
 
      "error. Used only if the connection has active cursors."),
 
3932
   "Timeout in seconds to wait for a table level lock before returning an "
 
3933
   "error. Used only if the connection has active cursors.",
3881
3934
   (char**) &table_lock_wait_timeout, (char**) &table_lock_wait_timeout,
3882
3935
   0, GET_ULONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
3883
3936
  {"thread_cache_size", OPT_THREAD_CACHE_SIZE,
3884
 
   N_("How many threads we should keep in a cache for reuse."),
 
3937
   "How many threads we should keep in a cache for reuse.",
3885
3938
   (char**) &thread_cache_size, (char**) &thread_cache_size, 0, GET_ULONG,
3886
3939
   REQUIRED_ARG, 0, 0, 16384, 0, 1, 0},
3887
3940
  {"thread_pool_size", OPT_THREAD_CACHE_SIZE,
3888
 
   N_("How many threads we should create to handle query requests in case of "
3889
 
      "'thread_handling=pool-of-threads'"),
 
3941
   "How many threads we should create to handle query requests in case of 'thread_handling=pool-of-threads'",
3890
3942
   (char**) &thread_pool_size, (char**) &thread_pool_size, 0, GET_ULONG,
3891
3943
   REQUIRED_ARG, 20, 1, 16384, 0, 1, 0},
3892
3944
  {"thread_stack", OPT_THREAD_STACK,
3893
 
   N_("The stack size for each thread."),
3894
 
   (char**) &my_thread_stack_size,
3895
 
   (char**) &my_thread_stack_size, 0, GET_ULONG,
3896
 
   REQUIRED_ARG,DEFAULT_THREAD_STACK,
 
3945
   "The stack size for each thread.", (char**) &my_thread_stack_size,
 
3946
   (char**) &my_thread_stack_size, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,
3897
3947
   1024L*128L, ULONG_MAX, 0, 1024, 0},
3898
3948
  { "time_format", OPT_TIME_FORMAT,
3899
 
    N_("The TIME format (for future)."),
3900
 
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_TIME],
3901
 
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_TIME],
 
3949
    "The TIME format (for future).",
 
3950
    (char**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
 
3951
    (char**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
3902
3952
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3903
3953
  {"tmp_table_size", OPT_TMP_TABLE_SIZE,
3904
 
   N_("If an internal in-memory temporary table exceeds this size, MySQL will"
3905
 
      " automatically convert it to an on-disk MyISAM table."),
 
3954
   "If an internal in-memory temporary table exceeds this size, MySQL will"
 
3955
   " automatically convert it to an on-disk MyISAM table.",
3906
3956
   (char**) &global_system_variables.tmp_table_size,
3907
3957
   (char**) &max_system_variables.tmp_table_size, 0, GET_ULL,
3908
3958
   REQUIRED_ARG, 16*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},
3909
3959
  {"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,
3910
 
   N_("Allocation block size for transactions to be stored in binary log"),
 
3960
   "Allocation block size for transactions to be stored in binary log",
3911
3961
   (char**) &global_system_variables.trans_alloc_block_size,
3912
3962
   (char**) &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,
3913
3963
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
3914
3964
  {"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,
3915
 
   N_("Persistent buffer for transactions to be stored in binary log"),
 
3965
   "Persistent buffer for transactions to be stored in binary log",
3916
3966
   (char**) &global_system_variables.trans_prealloc_size,
3917
3967
   (char**) &max_system_variables.trans_prealloc_size, 0, GET_ULONG,
3918
3968
   REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
3919
3969
  {"wait_timeout", OPT_WAIT_TIMEOUT,
3920
 
   N_("The number of seconds the server waits for activity on a connection "
3921
 
      "before closing it."),
 
3970
   "The number of seconds the server waits for activity on a connection before closing it.",
3922
3971
   (char**) &global_system_variables.net_wait_timeout,
3923
3972
   (char**) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
3924
 
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT,
 
3973
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT32_MAX/1000, LONG_TIMEOUT),
3925
3974
   0, 1, 0},
3926
3975
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
3927
3976
};
3928
3977
 
3929
 
static int show_net_compression(THD *thd __attribute__((unused)),
 
3978
static int show_net_compression(THD *thd __attribute__((__unused__)),
3930
3979
                                SHOW_VAR *var,
3931
 
                                char *buff __attribute__((unused)))
 
3980
                                char *buff __attribute__((__unused__)))
3932
3981
{
3933
3982
  var->type= SHOW_MY_BOOL;
3934
3983
  var->value= (char *)&thd->net.compress;
3960
4009
static st_show_var_func_container
3961
4010
show_flushstatustime_cont= { &show_flushstatustime };
3962
4011
 
3963
 
static int show_slave_running(THD *thd __attribute__((unused)),
 
4012
static int show_slave_running(THD *thd __attribute__((__unused__)),
3964
4013
                              SHOW_VAR *var, char *buff)
3965
4014
{
3966
4015
  var->type= SHOW_MY_BOOL;
3975
4024
static st_show_var_func_container
3976
4025
show_slave_running_cont= { &show_slave_running };
3977
4026
 
3978
 
static int show_slave_retried_trans(THD *thd __attribute__((unused)),
 
4027
static int show_slave_retried_trans(THD *thd __attribute__((__unused__)),
3979
4028
                                    SHOW_VAR *var, char *buff)
3980
4029
{
3981
4030
  /*
4000
4049
static st_show_var_func_container
4001
4050
show_slave_retried_trans_cont= { &show_slave_retried_trans };
4002
4051
 
4003
 
static int show_slave_received_heartbeats(THD *thd __attribute__((unused)),
 
4052
static int show_slave_received_heartbeats(THD *thd __attribute__((__unused__)),
4004
4053
                                          SHOW_VAR *var, char *buff)
4005
4054
{
4006
4055
  pthread_mutex_lock(&LOCK_active_mi);
4021
4070
static st_show_var_func_container
4022
4071
show_slave_received_heartbeats_cont= { &show_slave_received_heartbeats };
4023
4072
 
4024
 
static int show_heartbeat_period(THD *thd __attribute__((unused)),
 
4073
static int show_heartbeat_period(THD *thd __attribute__((__unused__)),
4025
4074
                                 SHOW_VAR *var, char *buff)
4026
4075
{
4027
4076
  pthread_mutex_lock(&LOCK_active_mi);
4029
4078
  {
4030
4079
    var->type= SHOW_CHAR;
4031
4080
    var->value= buff;
4032
 
    sprintf(buff, "%.3f",active_mi->heartbeat_period);
 
4081
    my_sprintf(buff, (buff, "%.3f",active_mi->heartbeat_period));
4033
4082
  }
4034
4083
  else
4035
4084
    var->type= SHOW_UNDEF;
4040
4089
static st_show_var_func_container
4041
4090
show_heartbeat_period_cont= { &show_heartbeat_period};
4042
4091
 
4043
 
static int show_open_tables(THD *thd __attribute__((unused)),
 
4092
static int show_open_tables(THD *thd __attribute__((__unused__)),
4044
4093
                            SHOW_VAR *var, char *buff)
4045
4094
{
4046
4095
  var->type= SHOW_LONG;
4049
4098
  return 0;
4050
4099
}
4051
4100
 
4052
 
static int show_table_definitions(THD *thd __attribute__((unused)),
 
4101
static int show_table_definitions(THD *thd __attribute__((__unused__)),
4053
4102
                                  SHOW_VAR *var, char *buff)
4054
4103
{
4055
4104
  var->type= SHOW_LONG;
4142
4191
  {"Threads_running",          (char*) &thread_running,         SHOW_INT},
4143
4192
  {"Uptime",                   (char*) &show_starttime_cont,         SHOW_FUNC},
4144
4193
  {"Uptime_since_flush_status",(char*) &show_flushstatustime_cont,   SHOW_FUNC},
4145
 
  {NULL, NULL, SHOW_LONG}
 
4194
  {NullS, NullS, SHOW_LONG}
4146
4195
};
4147
4196
 
4148
4197
static void print_version(void)
4153
4202
    version from the output of 'mysqld --version', so don't change it!
4154
4203
  */
4155
4204
  printf("%s  Ver %s for %s on %s (%s)\n",my_progname,
4156
 
         server_version,SYSTEM_TYPE,MACHINE_TYPE, DRIZZLE_COMPILATION_COMMENT);
 
4205
         server_version,SYSTEM_TYPE,MACHINE_TYPE, MYSQL_COMPILATION_COMMENT);
4157
4206
}
4158
4207
 
4159
4208
static void usage(void)
4165
4214
  if (!default_collation_name)
4166
4215
    default_collation_name= (char*) default_charset_info->name;
4167
4216
  print_version();
4168
 
  puts(_("Copyright (C) 2000 MySQL AB, by Monty and others\n"
4169
 
         "This software comes with ABSOLUTELY NO WARRANTY. "
4170
 
         "This is free software,\n"
4171
 
         "and you are welcome to modify and redistribute it under the GPL "
4172
 
         "license\n\n"
4173
 
         "Starts the Drizzle database server\n"));
 
4217
  puts("\
 
4218
Copyright (C) 2000 MySQL AB, by Monty and others\n\
 
4219
This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\
 
4220
and you are welcome to modify and redistribute it under the GPL license\n\n\
 
4221
Starts the MySQL database server\n");
4174
4222
 
4175
 
  printf(_("Usage: %s [OPTIONS]\n"), my_progname);
 
4223
  printf("Usage: %s [OPTIONS]\n", my_progname);
 
4224
  if (!opt_verbose)
 
4225
    puts("\nFor more help options (several pages), use mysqld --verbose --help");
 
4226
  else
4176
4227
  {
4177
 
#ifdef FOO
4178
 
  print_defaults(DRIZZLE_CONFIG_NAME,load_default_groups);
 
4228
  print_defaults(MYSQL_CONFIG_NAME,load_default_groups);
4179
4229
  puts("");
4180
4230
  set_ports();
4181
 
#endif
4182
4231
 
4183
4232
  /* Print out all the options including plugin supplied options */
4184
4233
  my_print_help_inc_plugins(my_long_options, sizeof(my_long_options)/sizeof(my_option));
4185
4234
 
4186
 
  puts(_("\nTo see what values a running Drizzle server is using, type\n"
4187
 
         "'drizzleadmin variables' instead of 'drizzled --help'."));
 
4235
  puts("\n\
 
4236
To see what values a running MySQL server is using, type\n\
 
4237
'mysqladmin variables' instead of 'mysqld --verbose --help'.");
4188
4238
  }
4189
4239
}
4190
4240
 
4210
4260
  /* Things reset to zero */
4211
4261
  opt_skip_slave_start= opt_reckless_slave = 0;
4212
4262
  mysql_home[0]= pidfile_name[0]= log_error_file[0]= 0;
 
4263
  opt_log= opt_slow_log= 0;
4213
4264
  log_output_options= find_bit_type(log_output_str, &log_output_typelib);
4214
4265
  opt_bin_log= 0;
4215
 
  opt_skip_show_db=0;
4216
 
  opt_logname= opt_binlog_index_name= 0;
 
4266
  opt_disable_networking= opt_skip_show_db=0;
 
4267
  opt_logname= opt_binlog_index_name= opt_slow_logname= 0;
4217
4268
  opt_tc_log_file= (char *)"tc.log";      // no hostname in tc_log file name !
 
4269
  opt_secure_auth= 0;
4218
4270
  opt_secure_file_priv= 0;
 
4271
  opt_bootstrap= opt_myisam_log= 0;
 
4272
  mqh_used= 0;
4219
4273
  segfaulted= kill_in_progress= 0;
4220
4274
  cleanup_done= 0;
4221
4275
  defaults_argc= 0;
4234
4288
  binlog_cache_use=  binlog_cache_disk_use= 0;
4235
4289
  max_used_connections= slow_launch_threads = 0;
4236
4290
  mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;
4237
 
  opt_mysql_tmpdir= my_bind_addr_str= NULL;
4238
 
  memset(&mysql_tmpdir_list, 0, sizeof(mysql_tmpdir_list));
4239
 
  memset(&global_status_var, 0, sizeof(global_status_var));
 
4291
  errmesg= 0;
 
4292
  opt_mysql_tmpdir= my_bind_addr_str= NullS;
 
4293
  bzero((uchar*) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));
 
4294
  bzero((char *) &global_status_var, sizeof(global_status_var));
4240
4295
  key_map_full.set_all();
4241
4296
 
4242
4297
  /* Character sets */
4253
4308
  slave_exec_mode_options= 0;
4254
4309
  slave_exec_mode_options= (uint)
4255
4310
    find_bit_type_or_exit(slave_exec_mode_str, &slave_exec_mode_typelib, NULL);
 
4311
  opt_specialflag= SPECIAL_ENGLISH;
 
4312
  ip_sock= INVALID_SOCKET;
4256
4313
  mysql_home_ptr= mysql_home;
4257
4314
  pidfile_name_ptr= pidfile_name;
4258
4315
  log_error_file_ptr= log_error_file;
4264
4321
  what_to_log= ~ (1L << (uint) COM_TIME);
4265
4322
  refresh_version= 1L;  /* Increments on each reload */
4266
4323
  global_query_id= thread_id= 1L;
4267
 
  my_stpcpy(server_version, DRIZZLE_SERVER_VERSION);
 
4324
  strmov(server_version, MYSQL_SERVER_VERSION);
4268
4325
  myisam_recover_options_str= "OFF";
4269
4326
  myisam_stats_method_str= "nulls_unequal";
4270
4327
  threads.empty();
4292
4349
 
4293
4350
  /* Variables in libraries */
4294
4351
  charsets_dir= 0;
4295
 
  default_character_set_name= (char*) DRIZZLE_DEFAULT_CHARSET_NAME;
 
4352
  default_character_set_name= (char*) MYSQL_DEFAULT_CHARSET_NAME;
4296
4353
  default_collation_name= compiled_default_collation_name;
 
4354
  sys_charset_system.set((char*) system_charset_info->csname);
4297
4355
  character_set_filesystem_name= (char*) "binary";
4298
4356
  lc_time_names_name= (char*) "en_US";
4299
4357
  /* Set default values for some option variables */
4300
 
  default_storage_engine_str= (char*) "innodb";
 
4358
  default_storage_engine_str= (char*) "MyISAM";
4301
4359
  global_system_variables.table_plugin= NULL;
4302
4360
  global_system_variables.tx_isolation= ISO_REPEATABLE_READ;
4303
4361
  global_system_variables.select_limit= (uint64_t) HA_POS_ERROR;
4313
4371
  global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;
4314
4372
 
4315
4373
  /* Variables that depends on compile options */
4316
 
  opt_error_log= 0;
 
4374
  opt_error_log= IF_WIN(1,0);
4317
4375
#ifdef HAVE_BROKEN_REALPATH
4318
4376
  have_symlink=SHOW_OPTION_NO;
4319
4377
#else
4320
4378
  have_symlink=SHOW_OPTION_YES;
4321
4379
#endif
 
4380
#ifdef HAVE_DLOPEN
 
4381
  have_dlopen=SHOW_OPTION_YES;
 
4382
#else
 
4383
  have_dlopen=SHOW_OPTION_NO;
 
4384
#endif
 
4385
#ifdef HAVE_CRYPT
 
4386
  have_crypt=SHOW_OPTION_YES;
 
4387
#else
 
4388
  have_crypt=SHOW_OPTION_NO;
 
4389
#endif
4322
4390
#ifdef HAVE_COMPRESS
4323
4391
  have_compress= SHOW_OPTION_YES;
4324
4392
#else
4327
4395
 
4328
4396
  const char *tmpenv;
4329
4397
  if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))
4330
 
    tmpenv = DEFAULT_DRIZZLE_HOME;
 
4398
    tmpenv = DEFAULT_MYSQL_HOME;
4331
4399
  (void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);
4332
4400
}
4333
4401
 
4351
4419
    if (default_collation_name == compiled_default_collation_name)
4352
4420
      default_collation_name= 0;
4353
4421
    break;
 
4422
  case 'l':
 
4423
    opt_log=1;
 
4424
    break;
4354
4425
  case 'h':
4355
4426
    strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);
4356
4427
    /* Correct pointer set by my_getopt (for embedded library) */
4361
4432
    if (!mysqld_user || !strcmp(mysqld_user, argument))
4362
4433
      mysqld_user= argument;
4363
4434
    else
4364
 
      sql_print_warning(_("Ignoring user change to '%s' because the user was "
4365
 
                          "set to '%s' earlier on the command line\n"),
4366
 
                        argument, mysqld_user);
 
4435
      sql_print_warning("Ignoring user change to '%s' because the user was set to '%s' earlier on the command line\n", argument, mysqld_user);
4367
4436
    break;
4368
4437
  case 'L':
4369
4438
    strmake(language, argument, sizeof(language)-1);
4390
4459
    test_flags= argument ? (uint) atoi(argument) : 0;
4391
4460
    opt_endinfo=1;
4392
4461
    break;
 
4462
  case (int) OPT_BIG_TABLES:
 
4463
    thd_startup_options|=OPTION_BIG_TABLES;
 
4464
    break;
 
4465
  case (int) OPT_ISAM_LOG:
 
4466
    opt_myisam_log=1;
 
4467
    break;
4393
4468
  case (int) OPT_BIN_LOG:
4394
4469
    opt_bin_log= test(argument != disabled_my_option);
4395
4470
    break;
4397
4472
    opt_error_log= 1;
4398
4473
    break;
4399
4474
  case (int)OPT_REPLICATE_IGNORE_DB:
4400
 
    {
4401
 
      rpl_filter->add_ignore_db(argument);
4402
 
      break;
4403
 
    }
 
4475
  {
 
4476
    rpl_filter->add_ignore_db(argument);
 
4477
    break;
 
4478
  }
4404
4479
  case (int)OPT_REPLICATE_DO_DB:
4405
 
    {
4406
 
      rpl_filter->add_do_db(argument);
4407
 
      break;
4408
 
    }
 
4480
  {
 
4481
    rpl_filter->add_do_db(argument);
 
4482
    break;
 
4483
  }
4409
4484
  case (int)OPT_REPLICATE_REWRITE_DB:
4410
 
    {
4411
 
      char* key = argument,*p, *val;
4412
 
 
4413
 
      if (!(p= strstr(argument, "->")))
4414
 
      {
4415
 
        fprintf(stderr,
4416
 
                _("Bad syntax in replicate-rewrite-db - missing '->'!\n"));
4417
 
        exit(1);
4418
 
      }
4419
 
      val= p--;
4420
 
      while (my_isspace(mysqld_charset, *p) && p > argument)
4421
 
        *p-- = 0;
4422
 
      if (p == argument)
4423
 
      {
4424
 
        fprintf(stderr,
4425
 
                _("Bad syntax in replicate-rewrite-db - empty FROM db!\n"));
4426
 
        exit(1);
4427
 
      }
4428
 
      *val= 0;
4429
 
      val+= 2;
4430
 
      while (*val && my_isspace(mysqld_charset, *val))
4431
 
        *val++;
4432
 
      if (!*val)
4433
 
      {
4434
 
        fprintf(stderr,
4435
 
                _("Bad syntax in replicate-rewrite-db - empty TO db!\n"));
4436
 
        exit(1);
4437
 
      }
4438
 
 
4439
 
      rpl_filter->add_db_rewrite(key, val);
4440
 
      break;
4441
 
    }
 
4485
  {
 
4486
    char* key = argument,*p, *val;
 
4487
 
 
4488
    if (!(p= strstr(argument, "->")))
 
4489
    {
 
4490
      fprintf(stderr,
 
4491
              "Bad syntax in replicate-rewrite-db - missing '->'!\n");
 
4492
      exit(1);
 
4493
    }
 
4494
    val= p--;
 
4495
    while (my_isspace(mysqld_charset, *p) && p > argument)
 
4496
      *p-- = 0;
 
4497
    if (p == argument)
 
4498
    {
 
4499
      fprintf(stderr,
 
4500
              "Bad syntax in replicate-rewrite-db - empty FROM db!\n");
 
4501
      exit(1);
 
4502
    }
 
4503
    *val= 0;
 
4504
    val+= 2;
 
4505
    while (*val && my_isspace(mysqld_charset, *val))
 
4506
      *val++;
 
4507
    if (!*val)
 
4508
    {
 
4509
      fprintf(stderr,
 
4510
              "Bad syntax in replicate-rewrite-db - empty TO db!\n");
 
4511
      exit(1);
 
4512
    }
 
4513
 
 
4514
    rpl_filter->add_db_rewrite(key, val);
 
4515
    break;
 
4516
  }
4442
4517
 
4443
4518
  case (int)OPT_BINLOG_IGNORE_DB:
4444
 
    {
4445
 
      binlog_filter->add_ignore_db(argument);
4446
 
      break;
4447
 
    }
 
4519
  {
 
4520
    binlog_filter->add_ignore_db(argument);
 
4521
    break;
 
4522
  }
4448
4523
  case OPT_BINLOG_FORMAT:
4449
 
    {
4450
 
      int id;
4451
 
      id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);
4452
 
      global_system_variables.binlog_format= opt_binlog_format_id= id - 1;
4453
 
      break;
4454
 
    }
 
4524
  {
 
4525
    int id;
 
4526
    id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);
 
4527
    global_system_variables.binlog_format= opt_binlog_format_id= id - 1;
 
4528
    break;
 
4529
  }
4455
4530
  case (int)OPT_BINLOG_DO_DB:
4456
 
    {
4457
 
      binlog_filter->add_do_db(argument);
4458
 
      break;
4459
 
    }
 
4531
  {
 
4532
    binlog_filter->add_do_db(argument);
 
4533
    break;
 
4534
  }
4460
4535
  case (int)OPT_REPLICATE_DO_TABLE:
 
4536
  {
 
4537
    if (rpl_filter->add_do_table(argument))
4461
4538
    {
4462
 
      if (rpl_filter->add_do_table(argument))
4463
 
      {
4464
 
        fprintf(stderr, _("Could not add do table rule '%s'!\n"), argument);
4465
 
        exit(1);
4466
 
      }
4467
 
      break;
 
4539
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
 
4540
      exit(1);
4468
4541
    }
 
4542
    break;
 
4543
  }
4469
4544
  case (int)OPT_REPLICATE_WILD_DO_TABLE:
 
4545
  {
 
4546
    if (rpl_filter->add_wild_do_table(argument))
4470
4547
    {
4471
 
      if (rpl_filter->add_wild_do_table(argument))
4472
 
      {
4473
 
        fprintf(stderr, _("Could not add do table rule '%s'!\n"), argument);
4474
 
        exit(1);
4475
 
      }
4476
 
      break;
 
4548
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
 
4549
      exit(1);
4477
4550
    }
 
4551
    break;
 
4552
  }
4478
4553
  case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:
 
4554
  {
 
4555
    if (rpl_filter->add_wild_ignore_table(argument))
4479
4556
    {
4480
 
      if (rpl_filter->add_wild_ignore_table(argument))
4481
 
      {
4482
 
        fprintf(stderr, _("Could not add ignore table rule '%s'!\n"), argument);
4483
 
        exit(1);
4484
 
      }
4485
 
      break;
 
4557
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
 
4558
      exit(1);
4486
4559
    }
 
4560
    break;
 
4561
  }
4487
4562
  case (int)OPT_REPLICATE_IGNORE_TABLE:
4488
 
    {
4489
 
      if (rpl_filter->add_ignore_table(argument))
4490
 
      {
4491
 
        fprintf(stderr, _("Could not add ignore table rule '%s'!\n"), argument);
4492
 
        exit(1);
4493
 
      }
4494
 
      break;
4495
 
    }
 
4563
  {
 
4564
    if (rpl_filter->add_ignore_table(argument))
 
4565
    {
 
4566
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
 
4567
      exit(1);
 
4568
    }
 
4569
    break;
 
4570
  }
 
4571
  case (int) OPT_SLOW_QUERY_LOG:
 
4572
    opt_slow_log= 1;
 
4573
    break;
 
4574
#ifdef WITH_CSV_STORAGE_ENGINE
 
4575
  case  OPT_LOG_OUTPUT:
 
4576
  {
 
4577
    if (!argument || !argument[0])
 
4578
    {
 
4579
      log_output_options= LOG_FILE;
 
4580
      log_output_str= log_output_typelib.type_names[1];
 
4581
    }
 
4582
    else
 
4583
    {
 
4584
      log_output_str= argument;
 
4585
      log_output_options=
 
4586
        find_bit_type_or_exit(argument, &log_output_typelib, opt->name);
 
4587
  }
 
4588
    break;
 
4589
  }
 
4590
#endif
 
4591
  case (int) OPT_SKIP_NEW:
 
4592
    opt_specialflag|= SPECIAL_NO_NEW_FUNC;
 
4593
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
 
4594
    myisam_concurrent_insert=0;
 
4595
    myisam_recover_options= HA_RECOVER_NONE;
 
4596
    my_use_symdir=0;
 
4597
    ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);
 
4598
    break;
 
4599
  case (int) OPT_SAFE:
 
4600
    opt_specialflag|= SPECIAL_SAFE_MODE;
 
4601
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
 
4602
    myisam_recover_options= HA_RECOVER_DEFAULT;
 
4603
    ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);
 
4604
    break;
 
4605
  case (int) OPT_SKIP_PRIOR:
 
4606
    opt_specialflag|= SPECIAL_NO_PRIOR;
 
4607
    break;
 
4608
  case (int) OPT_SKIP_SHOW_DB:
 
4609
    opt_skip_show_db=1;
 
4610
    opt_specialflag|=SPECIAL_SKIP_SHOW_DB;
 
4611
    break;
4496
4612
  case (int) OPT_WANT_CORE:
4497
4613
    test_flags |= TEST_CORE_ON_SIGNAL;
4498
4614
    break;
4504
4620
    break;
4505
4621
  case (int) OPT_BIND_ADDRESS:
4506
4622
    {
4507
 
      struct addrinfo *res_lst, hints;
 
4623
      struct addrinfo *res_lst, hints;    
4508
4624
 
4509
 
      memset(&hints, 0, sizeof(struct addrinfo));
 
4625
      bzero(&hints, sizeof(struct addrinfo));
4510
4626
      hints.ai_socktype= SOCK_STREAM;
4511
4627
      hints.ai_protocol= IPPROTO_TCP;
4512
4628
 
4513
 
      if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0)
 
4629
      if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0) 
4514
4630
      {
4515
 
        sql_print_error(_("Can't start server: cannot resolve hostname!"));
 
4631
        sql_print_error("Can't start server: cannot resolve hostname!");
4516
4632
        exit(1);
4517
4633
      }
4518
4634
 
4519
4635
      if (res_lst->ai_next)
4520
4636
      {
4521
 
        sql_print_error(_("Can't start server: bind-address refers to "
4522
 
                          "multiple interfaces!"));
 
4637
        sql_print_error("Can't start server: bind-address refers to multiple interfaces!");
4523
4638
        exit(1);
4524
4639
      }
4525
4640
      freeaddrinfo(res_lst);
4536
4651
    thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;
4537
4652
    global_system_variables.low_priority_updates=1;
4538
4653
    break;
 
4654
  case OPT_BOOTSTRAP:
 
4655
    opt_noacl=opt_bootstrap=1;
 
4656
    break;
4539
4657
  case OPT_SERVER_ID:
4540
4658
    server_id_supplied = 1;
4541
4659
    break;
4560
4678
    charsets_dir = mysql_charsets_dir;
4561
4679
    break;
4562
4680
  case OPT_TX_ISOLATION:
4563
 
    {
4564
 
      int type;
4565
 
      type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);
4566
 
      global_system_variables.tx_isolation= (type-1);
4567
 
      break;
4568
 
    }
 
4681
  {
 
4682
    int type;
 
4683
    type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);
 
4684
    global_system_variables.tx_isolation= (type-1);
 
4685
    break;
 
4686
  }
4569
4687
  case OPT_MYISAM_RECOVER:
4570
 
    {
4571
 
      if (!argument)
4572
 
      {
4573
 
        myisam_recover_options=    HA_RECOVER_DEFAULT;
4574
 
        myisam_recover_options_str= myisam_recover_typelib.type_names[0];
4575
 
      }
4576
 
      else if (!argument[0])
4577
 
      {
4578
 
        myisam_recover_options= HA_RECOVER_NONE;
4579
 
        myisam_recover_options_str= "OFF";
4580
 
      }
4581
 
      else
4582
 
      {
4583
 
        myisam_recover_options_str=argument;
4584
 
        myisam_recover_options=
4585
 
          find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);
4586
 
      }
4587
 
      ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
4588
 
      break;
4589
 
    }
 
4688
  {
 
4689
    if (!argument)
 
4690
    {
 
4691
      myisam_recover_options=    HA_RECOVER_DEFAULT;
 
4692
      myisam_recover_options_str= myisam_recover_typelib.type_names[0];
 
4693
    }
 
4694
    else if (!argument[0])
 
4695
    {
 
4696
      myisam_recover_options= HA_RECOVER_NONE;
 
4697
      myisam_recover_options_str= "OFF";
 
4698
    }
 
4699
    else
 
4700
    {
 
4701
      myisam_recover_options_str=argument;
 
4702
      myisam_recover_options=
 
4703
        find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);
 
4704
    }
 
4705
    ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
 
4706
    break;
 
4707
  }
4590
4708
  case OPT_TC_HEURISTIC_RECOVER:
4591
4709
    tc_heuristic_recover= find_type_or_exit(argument,
4592
4710
                                            &tc_heuristic_recover_typelib,
4593
4711
                                            opt->name);
4594
4712
    break;
4595
4713
  case OPT_MYISAM_STATS_METHOD:
4596
 
    {
4597
 
      uint32_t method_conv;
4598
 
      int method;
 
4714
  {
 
4715
    ulong method_conv;
 
4716
    int method;
4599
4717
 
4600
 
      myisam_stats_method_str= argument;
4601
 
      method= find_type_or_exit(argument, &myisam_stats_method_typelib,
4602
 
                                opt->name);
4603
 
      switch (method-1) {
4604
 
      case 2:
4605
 
        method_conv= MI_STATS_METHOD_IGNORE_NULLS;
4606
 
        break;
4607
 
      case 1:
4608
 
        method_conv= MI_STATS_METHOD_NULLS_EQUAL;
4609
 
        break;
4610
 
      case 0:
4611
 
      default:
4612
 
        method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
4613
 
        break;
4614
 
      }
4615
 
      global_system_variables.myisam_stats_method= method_conv;
 
4718
    myisam_stats_method_str= argument;
 
4719
    method= find_type_or_exit(argument, &myisam_stats_method_typelib,
 
4720
                              opt->name);
 
4721
    switch (method-1) {
 
4722
    case 2:
 
4723
      method_conv= MI_STATS_METHOD_IGNORE_NULLS;
 
4724
      break;
 
4725
    case 1:
 
4726
      method_conv= MI_STATS_METHOD_NULLS_EQUAL;
 
4727
      break;
 
4728
    case 0:
 
4729
    default:
 
4730
      method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
4616
4731
      break;
4617
4732
    }
 
4733
    global_system_variables.myisam_stats_method= method_conv;
 
4734
    break;
 
4735
  }
 
4736
  case OPT_LOWER_CASE_TABLE_NAMES:
 
4737
    lower_case_table_names= argument ? atoi(argument) : 1;
 
4738
    lower_case_table_names_used= 1;
 
4739
    break;
4618
4740
  }
4619
4741
  return 0;
4620
4742
}
4622
4744
 
4623
4745
/** Handle arguments for multiple key caches. */
4624
4746
 
4625
 
extern "C" char **mysql_getopt_value(const char *keyname, uint32_t key_length,
 
4747
extern "C" char **mysql_getopt_value(const char *keyname, uint key_length,
4626
4748
                                      const struct my_option *option);
4627
4749
 
4628
4750
char**
4629
 
mysql_getopt_value(const char *keyname, uint32_t key_length,
 
4751
mysql_getopt_value(const char *keyname, uint key_length,
4630
4752
                   const struct my_option *option)
4631
4753
{
4632
4754
  switch (option->id) {
4662
4784
  va_start(args, format);
4663
4785
 
4664
4786
  /* Don't print warnings for --loose options during bootstrap */
4665
 
  if (level == ERROR_LEVEL || global_system_variables.log_warnings)
 
4787
  if (level == ERROR_LEVEL || !opt_bootstrap ||
 
4788
      global_system_variables.log_warnings)
4666
4789
  {
4667
4790
    vprint_msg_to_log(level, format, args);
4668
4791
  }
4690
4813
  (*argc)++; /* add back one for the progname handle_options removes */
4691
4814
             /* no need to do this for argv as we are discarding it. */
4692
4815
 
 
4816
  if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes ||
 
4817
       opt_log_slow_slave_statements) &&
 
4818
      !opt_slow_log)
 
4819
    sql_print_warning("options --log-slow-admin-statements, --log-queries-not-using-indexes and --log-slow-slave-statements have no effect if --log-slow-queries is not set");
 
4820
 
4693
4821
#if defined(HAVE_BROKEN_REALPATH)
4694
4822
  my_use_symdir=0;
4695
4823
  my_disable_symlinks=1;
4731
4859
  global_system_variables.long_query_time= max_system_variables.long_query_time=
4732
4860
    (int64_t) (long_query_time * 1000000.0);
4733
4861
 
4734
 
  if (init_global_datetime_format(DRIZZLE_TIMESTAMP_DATE,
 
4862
  if (opt_short_log_format)
 
4863
    opt_specialflag|= SPECIAL_SHORT_LOG_FORMAT;
 
4864
 
 
4865
  if (init_global_datetime_format(MYSQL_TIMESTAMP_DATE,
4735
4866
                                  &global_system_variables.date_format) ||
4736
 
      init_global_datetime_format(DRIZZLE_TIMESTAMP_TIME,
 
4867
      init_global_datetime_format(MYSQL_TIMESTAMP_TIME,
4737
4868
                                  &global_system_variables.time_format) ||
4738
 
      init_global_datetime_format(DRIZZLE_TIMESTAMP_DATETIME,
 
4869
      init_global_datetime_format(MYSQL_TIMESTAMP_DATETIME,
4739
4870
                                  &global_system_variables.datetime_format))
4740
4871
    exit(1);
4741
4872
 
4747
4878
  Create version name for running mysqld version
4748
4879
  We automaticly add suffixes -debug, -embedded and -log to the version
4749
4880
  name to make the version more descriptive.
4750
 
  (DRIZZLE_SERVER_SUFFIX is set by the compilation environment)
 
4881
  (MYSQL_SERVER_SUFFIX is set by the compilation environment)
4751
4882
*/
4752
4883
 
4753
 
#ifdef DRIZZLE_SERVER_SUFFIX
4754
 
#define DRIZZLE_SERVER_SUFFIX_STR STRINGIFY_ARG(DRIZZLE_SERVER_SUFFIX)
4755
 
#else
4756
 
#define DRIZZLE_SERVER_SUFFIX_STR DRIZZLE_SERVER_SUFFIX_DEF
4757
 
#endif
4758
 
 
4759
4884
static void set_server_version(void)
4760
4885
{
4761
 
  char *end= strxmov(server_version, DRIZZLE_SERVER_VERSION,
4762
 
                     DRIZZLE_SERVER_SUFFIX_STR, NULL);
4763
 
  if (opt_bin_log)
4764
 
    my_stpcpy(end, "-log");                        // This may slow down system
 
4886
  char *end= strxmov(server_version, MYSQL_SERVER_VERSION,
 
4887
                     MYSQL_SERVER_SUFFIX_STR, NullS);
 
4888
  if (opt_log || opt_slow_log || opt_bin_log)
 
4889
    strmov(end, "-log");                        // This may slow down system
4765
4890
}
4766
4891
 
4767
4892
 
4768
4893
static char *get_relative_path(const char *path)
4769
4894
{
4770
4895
  if (test_if_hard_path(path) &&
4771
 
      is_prefix(path,DEFAULT_DRIZZLE_HOME) &&
4772
 
      strcmp(DEFAULT_DRIZZLE_HOME,FN_ROOTDIR))
 
4896
      is_prefix(path,DEFAULT_MYSQL_HOME) &&
 
4897
      strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))
4773
4898
  {
4774
 
    path+=(uint) strlen(DEFAULT_DRIZZLE_HOME);
 
4899
    path+=(uint) strlen(DEFAULT_MYSQL_HOME);
4775
4900
    while (*path == FN_LIBCHAR)
4776
4901
      path++;
4777
4902
  }
4794
4919
  if (!test_if_hard_path(dir))
4795
4920
  {
4796
4921
    strxnmov(tmp_path,sizeof(tmp_path)-1, mysql_real_data_home,
4797
 
             dir, NULL);
 
4922
             dir, NullS);
4798
4923
    dir=tmp_path;
4799
4924
  }
4800
4925
  return !fn_format(to, name, dir, extension,
4805
4930
static void fix_paths(void)
4806
4931
{
4807
4932
  char buff[FN_REFLEN],*pos;
4808
 
  convert_dirname(mysql_home,mysql_home,NULL);
 
4933
  convert_dirname(mysql_home,mysql_home,NullS);
4809
4934
  /* Resolve symlinks to allow 'mysql_home' to be a relative symlink */
4810
4935
  my_realpath(mysql_home,mysql_home,MYF(0));
4811
4936
  /* Ensure that mysql_home ends in FN_LIBCHAR */
4812
 
  pos= strchr(mysql_home, '\0');
 
4937
  pos=strend(mysql_home);
4813
4938
  if (pos[-1] != FN_LIBCHAR)
4814
4939
  {
4815
4940
    pos[0]= FN_LIBCHAR;
4816
4941
    pos[1]= 0;
4817
4942
  }
4818
 
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NULL);
 
4943
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);
4819
4944
  (void) fn_format(buff, mysql_real_data_home, "", "",
4820
4945
                   (MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));
4821
4946
  (void) unpack_dirname(mysql_unpacked_real_data_home, buff);
4822
 
  convert_dirname(language,language,NULL);
 
4947
  convert_dirname(language,language,NullS);
4823
4948
  (void) my_load_path(mysql_home,mysql_home,""); // Resolve current dir
4824
4949
  (void) my_load_path(mysql_real_data_home,mysql_real_data_home,mysql_home);
4825
4950
  (void) my_load_path(pidfile_name,pidfile_name,mysql_real_data_home);
4831
4956
  if (test_if_hard_path(sharedir))
4832
4957
    strmake(buff,sharedir,sizeof(buff)-1);              /* purecov: tested */
4833
4958
  else
4834
 
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NULL);
4835
 
  convert_dirname(buff,buff,NULL);
 
4959
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NullS);
 
4960
  convert_dirname(buff,buff,NullS);
4836
4961
  (void) my_load_path(language,language,buff);
4837
4962
 
4838
4963
  /* If --character-sets-dir isn't given, use shared library dir */
4839
4964
  if (charsets_dir != mysql_charsets_dir)
4840
4965
  {
4841
4966
    strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,
4842
 
             CHARSET_DIR, NULL);
 
4967
             CHARSET_DIR, NullS);
4843
4968
  }
4844
4969
  (void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);
4845
 
  convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NULL);
 
4970
  convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NullS);
4846
4971
  charsets_dir=mysql_charsets_dir;
4847
4972
 
4848
4973
  if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))
4858
4983
   */
4859
4984
  if (opt_secure_file_priv)
4860
4985
  {
4861
 
    convert_dirname(buff, opt_secure_file_priv, NULL);
4862
 
    free(opt_secure_file_priv);
 
4986
    convert_dirname(buff, opt_secure_file_priv, NullS);
 
4987
    my_free(opt_secure_file_priv, MYF(0));
4863
4988
    opt_secure_file_priv= my_strdup(buff, MYF(MY_FAE));
4864
4989
  }
4865
4990
}
4866
4991
 
4867
4992
 
4868
 
static uint32_t find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
 
4993
static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
4869
4994
                                   const char *option)
4870
4995
{
4871
 
  uint32_t res;
 
4996
  ulong res;
4872
4997
 
4873
4998
  const char **ptr;
4874
 
 
4875
 
  if ((res= find_bit_type(x, bit_lib)) == ~(uint32_t) 0)
 
4999
  
 
5000
  if ((res= find_bit_type(x, bit_lib)) == ~(ulong) 0)
4876
5001
  {
4877
5002
    ptr= bit_lib->type_names;
4878
5003
    if (!*x)
4879
 
      fprintf(stderr, _("No option given to %s\n"), option);
 
5004
      fprintf(stderr, "No option given to %s\n", option);
4880
5005
    else
4881
 
      fprintf(stderr, _("Wrong option to %s. Option(s) given: %s\n"),
4882
 
              option, x);
4883
 
    fprintf(stderr, _("Alternatives are: '%s'"), *ptr);
 
5006
      fprintf(stderr, "Wrong option to %s. Option(s) given: %s\n", option, x);
 
5007
    fprintf(stderr, "Alternatives are: '%s'", *ptr);
4884
5008
    while (*++ptr)
4885
5009
      fprintf(stderr, ",'%s'", *ptr);
4886
5010
    fprintf(stderr, "\n");
4894
5018
  @return
4895
5019
    a bitfield from a string of substrings separated by ','
4896
5020
    or
4897
 
    ~(uint32_t) 0 on error.
 
5021
    ~(ulong) 0 on error.
4898
5022
*/
4899
5023
 
4900
 
static uint32_t find_bit_type(const char *x, TYPELIB *bit_lib)
 
5024
static ulong find_bit_type(const char *x, TYPELIB *bit_lib)
4901
5025
{
4902
5026
  bool found_end;
4903
5027
  int  found_count;
4904
5028
  const char *end,*i,*j;
4905
5029
  const char **array, *pos;
4906
 
  uint32_t found,found_int,bit;
 
5030
  ulong found,found_int,bit;
4907
5031
 
4908
5032
  found=0;
4909
5033
  found_end= 0;
4912
5036
  found_end= *pos == 0;
4913
5037
  while (!found_end)
4914
5038
  {
4915
 
    if ((end=strrchr(pos,',')) != NULL)         /* Let end point at fieldend */
 
5039
    if (!*(end=strcend(pos,',')))               /* Let end point at fieldend */
4916
5040
    {
4917
5041
      while (end > pos && end[-1] == ' ')
4918
5042
        end--;                                  /* Skip end-space */
4919
5043
      found_end=1;
4920
5044
    }
4921
 
    else
4922
 
    {
4923
 
        end=pos+strlen(pos);
4924
 
        found_end=1;
4925
 
    }
4926
5045
    found_int=0; found_count=0;
4927
5046
    for (array=bit_lib->type_names, bit=1 ; (i= *array++) ; bit<<=1)
4928
5047
    {
4946
5065
skip: ;
4947
5066
    }
4948
5067
    if (found_count != 1)
4949
 
      return(~(uint32_t) 0);                            // No unique value
 
5068
      return(~(ulong) 0);                               // No unique value
4950
5069
    found|=found_int;
4951
5070
    pos=end+1;
4952
5071
  }
4956
5075
 
4957
5076
 
4958
5077
/**
 
5078
  Check if file system used for databases is case insensitive.
 
5079
 
 
5080
  @param dir_name                       Directory to test
 
5081
 
 
5082
  @retval
 
5083
    -1  Don't know (Test failed)
 
5084
  @retval
 
5085
    0   File system is case sensitive
 
5086
  @retval
 
5087
    1   File system is case insensitive
 
5088
*/
 
5089
 
 
5090
static int test_if_case_insensitive(const char *dir_name)
 
5091
{
 
5092
  int result= 0;
 
5093
  File file;
 
5094
  char buff[FN_REFLEN], buff2[FN_REFLEN];
 
5095
  struct stat stat_info;
 
5096
 
 
5097
  fn_format(buff, glob_hostname, dir_name, ".lower-test",
 
5098
            MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
 
5099
  fn_format(buff2, glob_hostname, dir_name, ".LOWER-TEST",
 
5100
            MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
 
5101
  (void) my_delete(buff2, MYF(0));
 
5102
  if ((file= my_create(buff, 0666, O_RDWR, MYF(0))) < 0)
 
5103
  {
 
5104
    sql_print_warning("Can't create test file %s", buff);
 
5105
    return(-1);
 
5106
  }
 
5107
  my_close(file, MYF(0));
 
5108
  if (!stat(buff2, &stat_info))
 
5109
    result= 1;                                  // Can access file
 
5110
  (void) my_delete(buff, MYF(MY_WME));
 
5111
  return(result);
 
5112
}
 
5113
 
 
5114
 
 
5115
/**
4959
5116
  Create file to store pid number.
4960
5117
*/
4961
5118
static void create_pid_file()
4967
5124
    char buff[21], *end;
4968
5125
    end= int10_to_str((long) getpid(), buff, 10);
4969
5126
    *end++= '\n';
4970
 
    if (!my_write(file, (unsigned char*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))
 
5127
    if (!my_write(file, (uchar*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))
4971
5128
    {
4972
5129
      (void) my_close(file, MYF(0));
4973
5130
      return;
4987
5144
  add_to_status(&global_status_var, &thd->status_var);
4988
5145
 
4989
5146
  /* Reset thread's status variables */
4990
 
  memset(&thd->status_var, 0, sizeof(thd->status_var));
 
5147
  bzero((uchar*) &thd->status_var, sizeof(thd->status_var));
4991
5148
 
4992
5149
  /* Reset some global variables */
4993
5150
  reset_status_vars();