~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/drizzled.cc

  • Committer: Jay Pipes
  • Date: 2008-07-21 17:52:33 UTC
  • mto: (201.2.1 drizzle)
  • mto: This revision was merged to the branch mainline in revision 204.
  • Revision ID: jay@mysql.com-20080721175233-mtyz298j8xl3v63y
cleanup of FAQ file

Show diffs side-by-side

added added

removed removed

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