~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/drizzled.cc

  • Committer: Brian Aker
  • Date: 2008-07-14 22:40:46 UTC
  • Revision ID: brian@tangent.org-20080714224046-x183907w9wp1txwv
Removed sql_manager. Ever heard of just setting up the OS to sync when you
want it to?

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