← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/drizzled.cc

Removed DBUG symbols and fixed TRUE/FALSE

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/drizzled.cc
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 ~(ulonglong) 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 my_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
 
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;
 
223
static my_bool opt_debugging= 0, opt_external_locking= 0, opt_console= 0;
 
224
static my_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
my_bool opt_log, opt_slow_log;
252
247
ulong log_output_options;
253
 
bool opt_log_queries_not_using_indexes= false;
254
 
bool opt_error_log= 0;
255
 
bool opt_skip_show_db= false;
256
 
bool opt_character_set_client_handshake= 1;
 
248
my_bool opt_log_queries_not_using_indexes= 0;
 
249
bool opt_error_log= IF_WIN(1,0);
 
250
bool opt_disable_networking=0, opt_skip_show_db=0;
 
251
my_bool opt_character_set_client_handshake= 1;
257
252
bool server_id_supplied = 0;
258
253
bool opt_endinfo, using_udf_functions;
259
 
bool locked_in_memory;
 
254
my_bool locked_in_memory;
260
255
bool opt_using_transactions, using_update_log;
261
256
bool volatile abort_loop;
262
257
bool volatile shutdown_in_progress;
263
 
bool opt_skip_slave_start = 0; ///< If set, slave is not autostarted
264
 
bool opt_reckless_slave = 0;
265
 
bool opt_enable_named_pipe= 0;
266
 
bool opt_local_infile;
267
 
bool opt_slave_compressed_protocol;
268
 
bool opt_safe_user_create = 0;
269
 
bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
270
 
bool opt_log_slave_updates= 0;
271
 
static struct pollfd fds[UINT8_MAX];
272
 
static uint8_t pollfd_count= 0;
 
258
my_bool opt_skip_slave_start = 0; ///< If set, slave is not autostarted
 
259
my_bool opt_reckless_slave = 0;
 
260
my_bool opt_enable_named_pipe= 0;
 
261
my_bool opt_local_infile, opt_slave_compressed_protocol;
 
262
my_bool opt_safe_user_create = 0;
 
263
my_bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
 
264
my_bool opt_log_slave_updates= 0;
273
265
 
274
266
/*
275
267
  Legacy global handlerton. These will be removed (please do not add more).
277
269
handlerton *heap_hton;
278
270
handlerton *myisam_hton;
279
271
 
280
 
bool opt_readonly;
281
 
bool use_temp_pool;
282
 
bool relay_log_purge;
 
272
my_bool opt_readonly, use_temp_pool, relay_log_purge;
 
273
my_bool opt_sync_frm;
 
274
my_bool opt_secure_auth= 0;
283
275
char* opt_secure_file_priv= 0;
 
276
my_bool opt_log_slow_admin_statements= 0;
 
277
my_bool opt_log_slow_slave_statements= 0;
 
278
my_bool lower_case_file_system= 0;
 
279
my_bool opt_old_style_user_limits= 0, trust_function_creators= 0;
284
280
/*
285
281
  True if there is at least one per-hour limit for some user, so we should
286
282
  check them before each query (and possibly reset counters when hour is
287
283
  changed). False otherwise.
288
284
*/
289
 
bool opt_noacl;
 
285
volatile bool mqh_used = 0;
 
286
my_bool opt_noacl;
290
287
 
291
288
ulong opt_binlog_rows_event_max_size;
292
 
const char *binlog_format_names[]= {"MIXED", "STATEMENT", "ROW", NULL};
 
289
const char *binlog_format_names[]= {"MIXED", "STATEMENT", "ROW", NullS};
293
290
TYPELIB binlog_format_typelib=
294
291
  { array_elements(binlog_format_names) - 1, "",
295
292
    binlog_format_names, NULL };
296
 
uint32_t opt_binlog_format_id= (uint32_t) BINLOG_FORMAT_UNSPEC;
 
293
ulong opt_binlog_format_id= (ulong) BINLOG_FORMAT_UNSPEC;
297
294
const char *opt_binlog_format= binlog_format_names[opt_binlog_format_id];
298
295
#ifdef HAVE_INITGROUPS
299
 
static bool calling_initgroups= false; /**< Used in SIGSEGV handler. */
 
296
static bool calling_initgroups= FALSE; /**< Used in SIGSEGV handler. */
300
297
#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;
307
 
uint64_t thd_startup_options;
 
298
uint mysqld_port, test_flags, select_errors, dropping_tables, ha_open_options;
 
299
uint mysqld_port_timeout;
 
300
uint delay_key_write_options, protocol_version;
 
301
uint lower_case_table_names;
 
302
uint tc_heuristic_recover= 0;
 
303
uint volatile thread_count, thread_running;
 
304
ulonglong thd_startup_options;
308
305
ulong back_log, connect_timeout, server_id;
309
306
ulong table_cache_size, table_def_size;
310
307
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;
317
 
bool slave_allow_batching;
 
308
ulong query_buff_size, slow_launch_time, slave_open_temp_tables;
 
309
ulong open_files_limit, max_binlog_size, max_relay_log_size;
 
310
ulong slave_net_timeout, slave_trans_retries;
 
311
my_bool slave_allow_batching;
318
312
ulong slave_exec_mode_options;
319
313
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 */
 
314
ulong thread_cache_size=0, thread_pool_size= 0;
 
315
ulong binlog_cache_size=0, max_binlog_cache_size=0;
 
316
ulong refresh_version;  /* Increments on each reload */
325
317
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;
 
318
ulong aborted_threads, aborted_connects;
 
319
ulong flush_time;
 
320
ulong specialflag=0;
 
321
ulong binlog_cache_use= 0, binlog_cache_disk_use= 0;
 
322
ulong max_connections, max_connect_errors;
 
323
uint  max_user_connections= 0;
 
324
ulong thread_id=1L,current_pid;
 
325
ulong slow_launch_threads = 0, sync_binlog_period;
338
326
ulong expire_logs_days = 0;
339
327
ulong rpl_recovery_rank=0;
340
328
const char *log_output_str= "FILE";
382
370
     language[FN_REFLEN], reg_ext[FN_EXTLEN], mysql_charsets_dir[FN_REFLEN],
383
371
     *opt_init_file, *opt_tc_log_file;
384
372
char mysql_unpacked_real_data_home[FN_REFLEN];
385
 
uint32_t reg_ext_length;
 
373
uint reg_ext_length;
386
374
const key_map key_map_empty(0);
387
375
key_map key_map_full(0);                        // Will be initialized later
388
376
 
389
377
const char *opt_date_time_formats[3];
390
378
 
391
 
uint32_t mysql_data_home_len;
 
379
uint mysql_data_home_len;
392
380
char mysql_data_home_buff[2], *mysql_data_home=mysql_real_data_home;
393
381
char server_version[SERVER_VERSION_LENGTH];
394
382
char *opt_mysql_tmpdir;
 
383
const char **errmesg;                   /**< Error messages */
395
384
const char *myisam_recover_options_str="OFF";
396
385
const char *myisam_stats_method_str="nulls_unequal";
397
386
 
410
399
Ge_creator ge_creator;
411
400
Le_creator le_creator;
412
401
 
 
402
FILE *bootstrap_file;
 
403
int bootstrap_error;
413
404
FILE *stderror_file=0;
414
405
 
415
406
I_List<THD> threads;
424
415
MY_TMPDIR mysql_tmpdir_list;
425
416
MY_BITMAP temp_pool;
426
417
 
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;
 
418
CHARSET_INFO *system_charset_info, *files_charset_info ;
 
419
CHARSET_INFO *national_charset_info, *table_alias_charset;
 
420
CHARSET_INFO *character_set_filesystem;
430
421
 
431
422
MY_LOCALE *my_default_lc_time_names;
432
423
 
433
 
SHOW_COMP_OPTION have_symlink;
434
 
SHOW_COMP_OPTION have_compress;
 
424
SHOW_COMP_OPTION have_symlink, have_dlopen;
 
425
SHOW_COMP_OPTION have_crypt, have_compress;
435
426
 
436
427
/* Thread specific variables */
437
428
 
438
429
pthread_key(MEM_ROOT**,THR_MALLOC);
439
430
pthread_key(THD*, THR_THD);
440
431
pthread_mutex_t LOCK_mysql_create_db, LOCK_open, LOCK_thread_count,
441
 
                LOCK_status, LOCK_global_read_lock,
 
432
                LOCK_mapped_file, LOCK_status, LOCK_global_read_lock,
442
433
                LOCK_error_log, LOCK_uuid_generator,
 
434
                LOCK_crypt,
443
435
                LOCK_global_system_variables,
444
436
                LOCK_user_conn, LOCK_slave_list, LOCK_active_mi,
445
437
                LOCK_connection_count;
452
444
pthread_cond_t  COND_server_started;
453
445
 
454
446
/* replication parameters, if master_host is not NULL, we are a slave */
455
 
uint32_t report_port= DRIZZLE_PORT;
456
 
uint32_t master_retry_count= 0;
 
447
uint report_port= MYSQL_PORT;
 
448
ulong master_retry_count=0;
457
449
char *master_info_file;
458
450
char *relay_log_info_file, *report_user, *report_password, *report_host;
459
451
char *opt_relay_logname = 0, *opt_relaylog_index_name=0;
460
 
char *opt_logname;
 
452
char *opt_logname, *opt_slow_logname;
461
453
 
462
454
/* Static variables */
463
455
 
464
456
static bool kill_in_progress, segfaulted;
465
457
#ifdef HAVE_STACK_TRACE_ON_SEGV
466
 
static bool opt_do_pstack;
 
458
static my_bool opt_do_pstack;
467
459
#endif /* HAVE_STACK_TRACE_ON_SEGV */
 
460
static my_bool opt_bootstrap, opt_myisam_log;
468
461
static int cleanup_done;
469
 
static uint32_t opt_myisam_block_size;
 
462
static ulong opt_specialflag, opt_myisam_block_size;
470
463
static char *opt_binlog_index_name;
471
464
static char *opt_tc_heuristic_recover;
472
465
static char *mysql_home_ptr, *pidfile_name_ptr;
474
467
static char **defaults_argv;
475
468
static char *opt_bin_logname;
476
469
 
 
470
static my_socket ip_sock;
477
471
struct rand_struct sql_rand; ///< used by sql_class.cc:THD::THD()
478
472
 
479
473
struct passwd *user_info;
480
474
static pthread_t select_thread;
481
 
static uint32_t thr_kill_signal;
 
475
static uint thr_kill_signal;
482
476
 
483
477
/* OS specific variables */
484
478
 
485
479
bool mysqld_embedded=0;
486
480
 
 
481
#ifndef DBUG_OFF
 
482
static const char* default_dbug_option;
 
483
#endif
 
484
 
487
485
scheduler_functions thread_scheduler;
488
486
 
489
487
/**
490
488
  Number of currently active user connections. The variable is protected by
491
489
  LOCK_connection_count.
492
490
*/
493
 
uint32_t connection_count= 0;
 
491
uint connection_count= 0;
494
492
 
495
493
/* Function declarations */
496
494
 
497
495
pthread_handler_t signal_hand(void *arg);
498
496
static void mysql_init_variables(void);
499
497
static void get_options(int *argc,char **argv);
500
 
extern "C" bool mysqld_get_one_option(int, const struct my_option *, char *);
 
498
extern "C" my_bool mysqld_get_one_option(int, const struct my_option *, char *);
501
499
static void set_server_version(void);
502
500
static int init_thread_environment();
503
501
static char *get_relative_path(const char *path);
505
503
void handle_connections_sockets();
506
504
pthread_handler_t kill_server_thread(void *arg);
507
505
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,
 
506
static ulong find_bit_type(const char *x, TYPELIB *bit_lib);
 
507
static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
510
508
                                   const char *option);
511
509
static void clean_up(bool print_message);
 
510
static int test_if_case_insensitive(const char *dir_name);
512
511
 
513
512
static void usage(void);
514
513
static void start_signal_handler(void);
532
531
  kill_cached_threads++;
533
532
  flush_thread_cache();
534
533
 
 
534
  /* kill flush thread */
 
535
  (void) pthread_mutex_lock(&LOCK_manager);
 
536
  if (manager_thread_in_use)
 
537
  {
 
538
   (void) pthread_cond_signal(&COND_manager);
 
539
  }
 
540
  (void) pthread_mutex_unlock(&LOCK_manager);
 
541
 
535
542
  /* kill connection thread */
536
543
  (void) pthread_mutex_lock(&LOCK_thread_count);
537
544
 
545
552
      break;                                    // allready dead
546
553
#endif
547
554
    set_timespec(abstime, 2);
548
 
    for (uint32_t tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
 
555
    for (uint tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
549
556
    {
550
557
      error=pthread_cond_timedwait(&COND_thread_count,&LOCK_thread_count,
551
558
                                   &abstime);
554
561
    }
555
562
#ifdef EXTRA_DEBUG
556
563
    if (error != 0 && !count++)
557
 
      sql_print_error(_("Got error %d from pthread_cond_timedwait"),error);
 
564
      sql_print_error("Got error %d from pthread_cond_timedwait",error);
558
565
#endif
559
566
    close_server_sock();
560
567
  }
562
569
 
563
570
 
564
571
  /* Abort listening to new connections */
 
572
  if (!opt_disable_networking )
565
573
  {
566
 
    int x;
567
 
 
568
 
    for (x= 0; x < pollfd_count; x++)
 
574
    if (ip_sock != INVALID_SOCKET)
569
575
    {
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
 
      }
 
576
      (void) shutdown(ip_sock, SHUT_RDWR);
 
577
      (void) closesocket(ip_sock);
 
578
      ip_sock= INVALID_SOCKET;
576
579
    }
577
580
  }
578
 
 
579
581
  end_thr_alarm(0);                      // Abort old alarms.
580
582
 
581
583
  /*
656
658
static void close_server_sock()
657
659
{
658
660
#ifdef HAVE_CLOSE_SERVER_SOCK
 
661
  my_socket tmp_sock;
 
662
  tmp_sock=ip_sock;
 
663
  if (tmp_sock != INVALID_SOCKET)
659
664
  {
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
 
    }
 
665
    ip_sock=INVALID_SOCKET;
 
666
    VOID(shutdown(tmp_sock, SHUT_RDWR));
671
667
  }
 
668
  return;;
672
669
#endif
673
670
}
674
671
 
682
679
#endif
683
680
 
684
681
#if defined(HAVE_PTHREAD_KILL)
685
 
  pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL);
 
682
  pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
686
683
#elif !defined(SIGNALS_DONT_BREAK_READ)
687
 
  kill(current_pid, DRIZZLE_KILL_SIGNAL);
 
684
  kill(current_pid, MYSQL_KILL_SIGNAL);
688
685
#endif
689
686
  shutdown_in_progress=1;                       // Safety if kill didn't work
690
687
#ifdef SIGNALS_DONT_BREAK_READ
694
691
    abort_loop=1;
695
692
    if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
696
693
                           (void*) 0))
697
 
      sql_print_error(_("Can't create thread to kill server"));
 
694
      sql_print_error("Can't create thread to kill server");
698
695
  }
699
696
#endif
700
697
  return;;
718
715
  // if there is a signal during the kill in progress, ignore the other
719
716
  if (kill_in_progress)                         // Safety
720
717
    RETURN_FROM_KILL_SERVER;
721
 
  kill_in_progress=true;
 
718
  kill_in_progress=TRUE;
722
719
  abort_loop=1;                                 // This should be set
723
720
  if (sig != 0) // 0 is not a valid signal number
724
721
    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);
 
722
  if (sig == MYSQL_KILL_SIGNAL || sig == 0)
 
723
    sql_print_information(ER(ER_NORMAL_SHUTDOWN),my_progname);
727
724
  else
728
 
    sql_print_error(_(ER(ER_GOT_SIGNAL)),my_progname,sig); /* purecov: inspected */
729
 
 
 
725
    sql_print_error(ER(ER_GOT_SIGNAL),my_progname,sig); /* purecov: inspected */
 
726
  
730
727
  close_connections();
731
 
  if (sig != DRIZZLE_KILL_SIGNAL &&
 
728
  if (sig != MYSQL_KILL_SIGNAL &&
732
729
      sig != 0)
733
730
    unireg_abort(1);                            /* purecov: inspected */
734
731
  else
758
755
#endif
759
756
 
760
757
 
761
 
extern "C" RETSIGTYPE print_signal_warning(int sig)
 
758
extern "C" sig_handler print_signal_warning(int sig)
762
759
{
763
760
  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
 
761
    sql_print_warning("Got signal %d from thread %ld", sig,my_thread_id());
 
762
#ifdef DONT_REMEMBER_SIGNAL
766
763
  my_sigset(sig,print_signal_warning);          /* int. thread system calls */
767
764
#endif
768
765
  if (sig == SIGALRM)
795
792
{
796
793
 
797
794
  if (exit_code)
798
 
    sql_print_error(_("Aborting\n"));
 
795
    sql_print_error("Aborting\n");
799
796
  else if (opt_help)
800
797
    usage();
801
 
  clean_up(!opt_help && (exit_code)); /* purecov: inspected */
 
798
  clean_up(!opt_help && (exit_code || !opt_bootstrap)); /* purecov: inspected */
802
799
  mysqld_exit(exit_code);
803
800
}
804
801
 
817
814
  if (cleanup_done++)
818
815
    return; /* purecov: inspected */
819
816
 
 
817
  /*
 
818
    make sure that handlers finish up
 
819
    what they have that is dependent on the binlog
 
820
  */
 
821
  ha_binlog_end(current_thd);
 
822
 
820
823
  logger.cleanup_base();
821
824
 
822
825
  mysql_bin_log.cleanup();
836
839
  if (tc_log)
837
840
    tc_log->close();
838
841
  xid_cache_free();
839
 
  delete_elements(&key_caches, (void (*)(const char*, unsigned char*)) free_key_cache);
 
842
  delete_elements(&key_caches, (void (*)(const char*, uchar*)) free_key_cache);
840
843
  multi_keycache_free();
841
844
  free_status_vars();
842
845
  end_thr_alarm(1);                     /* Free allocated memory */
843
846
  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);
 
847
  my_free((char*) global_system_variables.date_format,
 
848
          MYF(MY_ALLOW_ZERO_PTR));
 
849
  my_free((char*) global_system_variables.time_format,
 
850
          MYF(MY_ALLOW_ZERO_PTR));
 
851
  my_free((char*) global_system_variables.datetime_format,
 
852
          MYF(MY_ALLOW_ZERO_PTR));
847
853
  if (defaults_argv)
848
854
    free_defaults(defaults_argv);
849
 
  free(sys_init_connect.value);
850
 
  free(sys_init_slave.value);
 
855
  my_free(sys_init_connect.value, MYF(MY_ALLOW_ZERO_PTR));
 
856
  my_free(sys_init_slave.value, MYF(MY_ALLOW_ZERO_PTR));
 
857
  my_free(sys_var_general_log_path.value, MYF(MY_ALLOW_ZERO_PTR));
 
858
  my_free(sys_var_slow_log_path.value, MYF(MY_ALLOW_ZERO_PTR));
851
859
  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);
 
860
  my_free(slave_load_tmpdir,MYF(MY_ALLOW_ZERO_PTR));
 
861
  x_free(opt_bin_logname);
 
862
  x_free(opt_relay_logname);
 
863
  x_free(opt_secure_file_priv);
859
864
  bitmap_free(&temp_pool);
 
865
  end_slave_list();
860
866
  delete binlog_filter;
861
867
  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);
 
868
  vio_end();
 
869
 
 
870
  if (!opt_bootstrap)
 
871
    (void) my_delete(pidfile_name,MYF(0));      // This may not always exist
 
872
  if (print_message && errmesg && server_start_time)
 
873
    sql_print_information(ER(ER_SHUTDOWN_COMPLETE),my_progname);
867
874
  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);  */
 
875
  finish_client_errs();
 
876
  my_free((uchar*) my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST),
 
877
          MYF(MY_WME | MY_FAE | MY_ALLOW_ZERO_PTR));
874
878
  /* Tell main we are ready */
875
879
  logger.cleanup_end();
876
880
  (void) pthread_mutex_lock(&LOCK_thread_count);
892
896
*/
893
897
static void wait_for_signal_thread_to_end()
894
898
{
895
 
  uint32_t i;
 
899
  uint i;
896
900
  /*
897
901
    Wait up to 10 seconds for signal thread to die. We use this mainly to
898
902
    avoid getting warnings that my_thread_end has not been called
899
903
  */
900
904
  for (i= 0 ; i < 100 && signal_thread_in_use; i++)
901
905
  {
902
 
    if (pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL) != ESRCH)
 
906
    if (pthread_kill(signal_thread, MYSQL_KILL_SIGNAL) != ESRCH)
903
907
      break;
904
908
    my_sleep(100);                              // Give it time to die
905
909
  }
912
916
  (void) pthread_mutex_destroy(&LOCK_lock_db);
913
917
  (void) pthread_mutex_destroy(&LOCK_open);
914
918
  (void) pthread_mutex_destroy(&LOCK_thread_count);
 
919
  (void) pthread_mutex_destroy(&LOCK_mapped_file);
915
920
  (void) pthread_mutex_destroy(&LOCK_status);
916
921
  (void) pthread_mutex_destroy(&LOCK_error_log);
 
922
  (void) pthread_mutex_destroy(&LOCK_manager);
 
923
  (void) pthread_mutex_destroy(&LOCK_crypt);
917
924
  (void) pthread_mutex_destroy(&LOCK_user_conn);
918
925
  (void) pthread_mutex_destroy(&LOCK_connection_count);
 
926
  (void) pthread_mutex_destroy(&LOCK_rpl_status);
 
927
  (void) pthread_cond_destroy(&COND_rpl_status);
919
928
  (void) pthread_mutex_destroy(&LOCK_active_mi);
920
929
  (void) rwlock_destroy(&LOCK_sys_init_connect);
921
930
  (void) rwlock_destroy(&LOCK_sys_init_slave);
928
937
  (void) pthread_cond_destroy(&COND_global_read_lock);
929
938
  (void) pthread_cond_destroy(&COND_thread_cache);
930
939
  (void) pthread_cond_destroy(&COND_flush_thread_cache);
 
940
  (void) pthread_cond_destroy(&COND_manager);
931
941
}
932
942
 
933
943
 
938
948
static void set_ports()
939
949
{
940
950
  char  *env;
941
 
  if (!mysqld_port)
 
951
  if (!mysqld_port && !opt_disable_networking)
942
952
  {                                     // Get port if not from commandline
943
 
    mysqld_port= DRIZZLE_PORT;
 
953
    mysqld_port= MYSQL_PORT;
944
954
 
945
955
    /*
946
956
      if builder specifically requested a default port, use that
947
957
      (even if it coincides with our factory default).
948
958
      only if they didn't do we check /etc/services (and, failing
949
 
      on that, fall back to the factory default of 4427).
 
959
      on that, fall back to the factory default of 3306).
950
960
      either default can be overridden by the environment variable
951
 
      DRIZZLE_TCP_PORT, which in turn can be overridden with command
 
961
      MYSQL_TCP_PORT, which in turn can be overridden with command
952
962
      line options.
953
963
    */
954
964
 
 
965
#if MYSQL_PORT_DEFAULT == 0
955
966
    struct  servent *serv_ptr;
956
 
    if ((serv_ptr= getservbyname("drizzle", "tcp")))
 
967
    if ((serv_ptr= getservbyname("mysql", "tcp")))
957
968
      mysqld_port= ntohs((u_short) serv_ptr->s_port); /* purecov: inspected */
958
 
 
959
 
    if ((env = getenv("DRIZZLE_TCP_PORT")))
 
969
#endif
 
970
    if ((env = getenv("MYSQL_TCP_PORT")))
960
971
      mysqld_port= (uint) atoi(env);            /* purecov: inspected */
961
 
 
962
 
    assert(mysqld_port);
963
972
  }
964
973
}
965
974
 
979
988
      /* purecov: begin tested */
980
989
      tmp_user_info= getpwnam(user);
981
990
      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"));
 
991
          global_system_variables.log_warnings)
 
992
        sql_print_warning(
 
993
                    "One can only use the --user switch if running as root\n");
985
994
      /* purecov: end */
986
995
    }
987
996
    return NULL;
988
997
  }
989
998
  if (!user)
990
999
  {
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
 
 
 
1000
    if (!opt_bootstrap)
 
1001
    {
 
1002
      sql_print_error("Fatal error: Please read \"Security\" section of the manual to find out how to run mysqld as root!\n");
 
1003
      unireg_abort(1);
 
1004
    }
995
1005
    return NULL;
996
1006
  }
997
1007
  /* purecov: begin tested */
1012
1022
  /* purecov: end */
1013
1023
 
1014
1024
err:
1015
 
  sql_print_error(_("Fatal error: Can't change to run as user '%s' ;  "
1016
 
                    "Please check that the user exists!\n"),user);
 
1025
  sql_print_error("Fatal error: Can't change to run as user '%s' ;  Please check that the user exists!\n",user);
1017
1026
  unireg_abort(1);
1018
1027
 
1019
1028
#ifdef PR_SET_DUMPABLE
1038
1047
    calling_initgroups as a flag to the SIGSEGV handler that is then used to
1039
1048
    output a specific message to help the user resolve this problem.
1040
1049
  */
1041
 
  calling_initgroups= true;
 
1050
  calling_initgroups= TRUE;
1042
1051
  initgroups((char*) user, user_info_arg->pw_gid);
1043
 
  calling_initgroups= false;
 
1052
  calling_initgroups= FALSE;
1044
1053
#endif
1045
1054
  if (setgid(user_info_arg->pw_gid) == -1)
1046
1055
  {
1086
1095
 
1087
1096
static void network_init(void)
1088
1097
{
 
1098
  int   arg;
1089
1099
  int   ret;
1090
 
  uint32_t  waited;
1091
 
  uint32_t  this_wait;
1092
 
  uint32_t  retry;
 
1100
  uint  waited;
 
1101
  uint  this_wait;
 
1102
  uint  retry;
1093
1103
  char port_buf[NI_MAXSERV];
1094
 
  struct addrinfo *ai;
1095
 
  struct addrinfo *next;
1096
 
  struct addrinfo hints;
1097
 
  int error;
1098
1104
 
1099
1105
  if (thread_scheduler.init())
1100
1106
    unireg_abort(1);                    /* purecov: inspected */
1101
1107
 
1102
1108
  set_ports();
1103
1109
 
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;
 
1110
  if (mysqld_port != 0 && !opt_disable_networking && !opt_bootstrap)
 
1111
  {
 
1112
    struct addrinfo *ai;
 
1113
    struct addrinfo hints;
 
1114
    int error;
 
1115
 
 
1116
    bzero(&hints, sizeof (hints));
 
1117
    hints.ai_flags= AI_PASSIVE;
 
1118
    hints.ai_socktype= SOCK_STREAM;
 
1119
    hints.ai_family= AF_UNSPEC;
 
1120
 
 
1121
    snprintf(port_buf, NI_MAXSERV, "%d", mysqld_port);
 
1122
    error= getaddrinfo(my_bind_addr_str, port_buf, &hints, &ai);
 
1123
    if (error != 0)
 
1124
    {
 
1125
      sql_perror(ER(ER_IPSOCK_ERROR));          /* purecov: tested */
 
1126
      unireg_abort(1);                          /* purecov: tested */
 
1127
    }
 
1128
 
 
1129
 
 
1130
    ip_sock= socket(ai->ai_family, ai->ai_socktype,
 
1131
                    ai->ai_protocol);
 
1132
 
 
1133
    if (ip_sock == INVALID_SOCKET)
 
1134
    {
 
1135
      sql_perror(ER(ER_IPSOCK_ERROR));          /* purecov: tested */
 
1136
      unireg_abort(1);                          /* purecov: tested */
 
1137
    }
 
1138
 
 
1139
    /*
 
1140
      We should not use SO_REUSEADDR on windows as this would enable a
 
1141
      user to open two mysqld servers with the same TCP/IP port.
 
1142
    */
 
1143
    arg= 1;
 
1144
    (void) setsockopt(ip_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,sizeof(arg));
1137
1145
 
1138
1146
#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
 
      }
 
1147
     /*
 
1148
       For interoperability with older clients, IPv6 socket should
 
1149
       listen on both IPv6 and IPv4 wildcard addresses.
 
1150
       Turn off IPV6_V6ONLY option.
 
1151
     */
 
1152
    if (ai->ai_family == AF_INET6)
 
1153
    {
 
1154
      arg= 0;      
 
1155
      (void) setsockopt(ip_sock, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&arg,
 
1156
                sizeof(arg));
1173
1157
    }
1174
 
 
1175
 
 
 
1158
#endif
1176
1159
    /*
1177
1160
      Sometimes the port is not released fast enough when stopping and
1178
1161
      restarting the server. This happens quite often with the test suite
1183
1166
    */
1184
1167
    for (waited= 0, retry= 1; ; retry++, waited+= this_wait)
1185
1168
    {
1186
 
      if (((ret= bind(ip_sock, next->ai_addr, next->ai_addrlen)) >= 0 ) ||
1187
 
          (errno != EADDRINUSE) ||
 
1169
      if (((ret= bind(ip_sock, ai->ai_addr, ai->ai_addrlen)) >= 0 ) ||
 
1170
          (socket_errno != SOCKET_EADDRINUSE) ||
1188
1171
          (waited >= mysqld_port_timeout))
1189
1172
        break;
1190
 
      sql_print_information(_("Retrying bind on TCP/IP port %u"), mysqld_port);
 
1173
      sql_print_information("Retrying bind on TCP/IP port %u", mysqld_port);
1191
1174
      this_wait= retry * retry / 3 + 1;
1192
1175
      sleep(this_wait);
1193
1176
    }
 
1177
    freeaddrinfo(ai);
1194
1178
    if (ret < 0)
1195
1179
    {
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);
 
1180
      sql_perror("Can't start server: Bind on TCP/IP port");
 
1181
      sql_print_error("Do you already have another mysqld server running on port: %d ?",mysqld_port);
1199
1182
      unireg_abort(1);
1200
1183
    }
1201
1184
    if (listen(ip_sock,(int) back_log) < 0)
1202
1185
    {
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);
 
1186
      sql_perror("Can't start server: listen() on TCP/IP port");
 
1187
      sql_print_error("listen() on TCP/IP failed with error %d",
 
1188
                      socket_errno);
1206
1189
      unireg_abort(1);
1207
1190
    }
1208
1191
  }
1209
1192
 
1210
 
  freeaddrinfo(ai);
1211
 
  return;
 
1193
  return;;
1212
1194
}
1213
1195
 
1214
1196
/**
1221
1203
  @note
1222
1204
    For the connection that is doing shutdown, this is called twice
1223
1205
*/
1224
 
void close_connection(THD *thd, uint32_t errcode, bool lock)
 
1206
void close_connection(THD *thd, uint errcode, bool lock)
1225
1207
{
1226
1208
  st_vio *vio;
1227
1209
  if (lock)
1231
1213
  {
1232
1214
    if (errcode)
1233
1215
      net_send_error(thd, errcode, ER(errcode)); /* purecov: inspected */
1234
 
    net_close(&(thd->net));             /* vio is freed in delete thd */
 
1216
    vio_close(vio);                     /* vio is freed in delete thd */
1235
1217
  }
1236
1218
  if (lock)
1237
1219
    (void) pthread_mutex_unlock(&LOCK_thread_count);
1241
1223
 
1242
1224
/** Called when a thread is aborted. */
1243
1225
/* ARGSUSED */
1244
 
extern "C" RETSIGTYPE end_thread_signal(int sig __attribute__((unused)))
 
1226
extern "C" sig_handler end_thread_signal(int sig __attribute__((unused)))
1245
1227
{
1246
1228
  THD *thd=current_thd;
1247
 
  if (thd)
 
1229
  if (thd && ! thd->bootstrap)
1248
1230
  {
1249
1231
    statistic_increment(killed_threads, &LOCK_status);
1250
1232
    thread_scheduler.end_thread(thd,0);         /* purecov: inspected */
1388
1370
  @todo
1389
1371
    One should have to fix that thr_alarm know about this thread too.
1390
1372
*/
1391
 
extern "C" RETSIGTYPE abort_thread(int sig __attribute__((unused)))
 
1373
extern "C" sig_handler abort_thread(int sig __attribute__((unused)))
1392
1374
{
1393
1375
  THD *thd=current_thd;
1394
1376
  if (thd)
1406
1388
#endif
1407
1389
 
1408
1390
 
1409
 
extern "C" RETSIGTYPE handle_segfault(int sig)
 
1391
extern "C" sig_handler handle_segfault(int sig)
1410
1392
{
1411
1393
  time_t curr_time;
1412
1394
  struct tm tm;
 
1395
  THD *thd=current_thd;
1413
1396
 
1414
1397
  /*
1415
1398
    Strictly speaking, one needs a mutex here
1419
1402
  */
1420
1403
  if (segfaulted)
1421
1404
  {
1422
 
    fprintf(stderr, _("Fatal " SIGNAL_FMT " while backtracing\n"), sig);
 
1405
    fprintf(stderr, "Fatal " SIGNAL_FMT " while backtracing\n", sig);
1423
1406
    exit(1);
1424
1407
  }
1425
1408
 
1428
1411
  curr_time= my_time(0);
1429
1412
  localtime_r(&curr_time, &tm);
1430
1413
 
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",
 
1414
  fprintf(stderr,"\
 
1415
%02d%02d%02d %2d:%02d:%02d - mysqld got " SIGNAL_FMT " ;\n\
 
1416
This could be because you hit a bug. It is also possible that this binary\n\
 
1417
or one of the libraries it was linked against is corrupt, improperly built,\n\
 
1418
or misconfigured. This error can also be caused by malfunctioning hardware.\n",
1437
1419
          tm.tm_year % 100, tm.tm_mon+1, tm.tm_mday,
1438
1420
          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);
 
1421
          sig);
 
1422
  fprintf(stderr, "\
 
1423
We will try our best to scrape up some info that will hopefully help diagnose\n\
 
1424
the problem, but since we have already crashed, something is definitely wrong\n\
 
1425
and this may fail.\n\n");
 
1426
  fprintf(stderr, "key_buffer_size=%lu\n",
 
1427
          (ulong) dflt_key_cache->key_cache_mem_size);
1446
1428
  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);
 
1429
  fprintf(stderr, "max_used_connections=%lu\n", max_used_connections);
1448
1430
  fprintf(stderr, "max_threads=%u\n", thread_scheduler.max_threads);
1449
1431
  fprintf(stderr, "thread_count=%u\n", thread_count);
1450
1432
  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 +
 
1433
  fprintf(stderr, "It is possible that mysqld could use up to \n\
 
1434
key_buffer_size + (read_buffer_size + sort_buffer_size)*max_threads = %lu K\n\
 
1435
bytes of memory\n", ((ulong) dflt_key_cache->key_cache_mem_size +
 
1436
                     (global_system_variables.read_buff_size +
 
1437
                      global_system_variables.sortbuff_size) *
 
1438
                     thread_scheduler.max_threads +
1461
1439
                     max_connections * sizeof(THD)) / 1024);
 
1440
  fprintf(stderr, "Hope that's ok; if not, decrease some variables in the equation.\n\n");
1462
1441
 
1463
1442
#ifdef HAVE_STACKTRACE
1464
 
  THD *thd= current_thd;
1465
 
 
1466
1443
  if (!(test_flags & TEST_NO_STACKTRACE))
1467
1444
  {
1468
1445
    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,
 
1446
    fprintf(stderr,"\
 
1447
Attempting backtrace. You can use the following information to find out\n\
 
1448
where mysqld died. If you see no messages after this, something went\n\
 
1449
terribly wrong...\n");  
 
1450
    print_stacktrace(thd ? (uchar*) thd->thread_stack : (uchar*) 0,
1475
1451
                     my_thread_stack_size);
1476
1452
  }
1477
1453
  if (thd)
1494
1470
      kreason= "KILLED_NO_VALUE";
1495
1471
      break;
1496
1472
    }
1497
 
    fprintf(stderr, _("Trying to get some variables.\n"
1498
 
                      "Some pointers may be invalid and cause the "
1499
 
                      "dump to abort...\n"));
 
1473
    fprintf(stderr, "Trying to get some variables.\n\
 
1474
Some pointers may be invalid and cause the dump to abort...\n");
1500
1475
    safe_print_str("thd->query", thd->query, 1024);
1501
 
    fprintf(stderr, "thd->thread_id=%"PRIu32"\n", (uint32_t) thd->thread_id);
 
1476
    fprintf(stderr, "thd->thread_id=%lu\n", (ulong) thd->thread_id);
1502
1477
    fprintf(stderr, "thd->killed=%s\n", kreason);
1503
1478
  }
 
1479
  fprintf(stderr, "\
 
1480
The manual page at http://dev.mysql.com/doc/mysql/en/crashing.html contains\n\
 
1481
information that should help you find out what is causing the crash.\n");
1504
1482
  fflush(stderr);
1505
1483
#endif /* HAVE_STACKTRACE */
1506
1484
 
1507
1485
#ifdef HAVE_INITGROUPS
1508
1486
  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"));
 
1487
    fprintf(stderr, "\n\
 
1488
This crash occured while the server was calling initgroups(). This is\n\
 
1489
often due to the use of a mysqld that is statically linked against glibc\n\
 
1490
and configured to use LDAP in /etc/nsswitch.conf. You will need to either\n\
 
1491
upgrade to a version of glibc that does not have this problem (2.3.4 or\n\
 
1492
later when used with nscd), disable LDAP in your nsswitch.conf, or use a\n\
 
1493
mysqld that is not statically linked.\n");
1520
1494
#endif
1521
1495
 
1522
1496
  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
 
 
 
1497
    fprintf(stderr,"\n\
 
1498
You are running a statically-linked LinuxThreads binary on an NPTL system.\n\
 
1499
This can result in crashes on some distributions due to LT/NPTL conflicts.\n\
 
1500
You should either build a dynamically-linked binary, or force LinuxThreads\n\
 
1501
to be used with the LD_ASSUME_KERNEL environment variable. Please consult\n\
 
1502
the documentation for your distribution on how to do that.\n");
 
1503
  
1534
1504
  if (locked_in_memory)
1535
1505
  {
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"));
 
1506
    fprintf(stderr, "\n\
 
1507
The \"--memlock\" argument, which was enabled, uses system calls that are\n\
 
1508
unreliable and unstable on some operating systems and operating-system\n\
 
1509
versions (notably, some versions of Linux).  This crash could be due to use\n\
 
1510
of those buggy OS calls.  You should consider whether you really need the\n\
 
1511
\"--memlock\" parameter and/or consult the OS distributer about \"mlockall\"\n\
 
1512
bugs.\n");
1547
1513
  }
1548
1514
 
1549
1515
#ifdef HAVE_WRITE_CORE
1550
1516
  if (test_flags & TEST_CORE_ON_SIGNAL)
1551
1517
  {
1552
 
    fprintf(stderr, _("Writing a core file\n"));
 
1518
    fprintf(stderr, "Writing a core file\n");
1553
1519
    fflush(stderr);
1554
1520
    write_core(sig);
1555
1521
  }
1596
1562
    STRUCT_RLIMIT rl;
1597
1563
    rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
1598
1564
    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"));
 
1565
      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
1566
  }
1603
1567
#endif
1604
1568
  (void) sigemptyset(&set);
1645
1609
  (void) pthread_attr_init(&thr_attr);
1646
1610
  pthread_attr_setscope(&thr_attr, PTHREAD_SCOPE_SYSTEM);
1647
1611
  (void) pthread_attr_setdetachstate(&thr_attr, PTHREAD_CREATE_DETACHED);
 
1612
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
1648
1613
  {
1649
1614
    struct sched_param tmp_sched_param;
1650
1615
 
1664
1629
  (void) pthread_mutex_lock(&LOCK_thread_count);
1665
1630
  if ((error=pthread_create(&signal_thread,&thr_attr,signal_hand,0)))
1666
1631
  {
1667
 
    sql_print_error(_("Can't create interrupt-thread (error %d, errno: %d)"),
1668
 
                    error,errno);
 
1632
    sql_print_error("Can't create interrupt-thread (error %d, errno: %d)",
 
1633
                    error,errno);
1669
1634
    exit(1);
1670
1635
  }
1671
1636
  (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
1709
1674
  (void) sigaddset(&set,SIGTSTP);
1710
1675
 
1711
1676
  /* Save pid to this process (or thread on Linux) */
1712
 
  create_pid_file();
 
1677
  if (!opt_bootstrap)
 
1678
    create_pid_file();
1713
1679
 
1714
1680
#ifdef HAVE_STACK_TRACE_ON_SEGV
1715
1681
  if (opt_do_pstack)
1716
1682
  {
1717
 
    sprintf(pstack_file_name,"mysqld-%lu-%%d-%%d.backtrace", (uint32_t)getpid());
 
1683
    sprintf(pstack_file_name,"mysqld-%lu-%%d-%%d.backtrace", (ulong)getpid());
1718
1684
    pstack_install_segv_action(pstack_file_name);
1719
1685
  }
1720
1686
#endif /* HAVE_STACK_TRACE_ON_SEGV */
1752
1718
    case SIGQUIT:
1753
1719
    case SIGKILL:
1754
1720
#ifdef EXTRA_DEBUG
1755
 
      sql_print_information(_("Got signal %d to shutdown mysqld"),sig);
 
1721
      sql_print_information("Got signal %d to shutdown mysqld",sig);
1756
1722
#endif
1757
1723
      /* switch to the old log message processing */
 
1724
      logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,
 
1725
                          opt_log ? LOG_FILE:LOG_NONE);
1758
1726
      if (!abort_loop)
1759
1727
      {
1760
1728
        abort_loop=1;                           // mark abort for threads
1761
1729
#ifdef USE_ONE_SIGNAL_HAND
1762
1730
        pthread_t tmp;
 
1731
        if (!(opt_specialflag & SPECIAL_NO_PRIOR))
1763
1732
        {
1764
1733
          struct sched_param tmp_sched_param;
1765
1734
 
1769
1738
        }
1770
1739
        if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
1771
1740
                           (void*) &sig))
1772
 
          sql_print_error(_("Can't create thread to kill server"));
 
1741
          sql_print_error("Can't create thread to kill server");
1773
1742
#else
1774
1743
        kill_server((void*) sig);       // MIT THREAD has a alarm thread
1775
1744
#endif
1779
1748
      if (!abort_loop)
1780
1749
      {
1781
1750
        bool not_used;
 
1751
        mysql_print_status();           // Print some debug info
1782
1752
        reload_cache((THD*) 0,
1783
1753
                     (REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
1784
1754
                      REFRESH_GRANT |
1785
1755
                      REFRESH_THREADS | REFRESH_HOSTS),
1786
 
                     (TableList*) 0, &not_used); // Flush logs
 
1756
                     (TABLE_LIST*) 0, &not_used); // Flush logs
 
1757
      }
 
1758
      /* reenable logs after the options were reloaded */
 
1759
      if (log_output_options & LOG_NONE)
 
1760
      {
 
1761
        logger.set_handlers(LOG_FILE,
 
1762
                            opt_slow_log ? LOG_TABLE : LOG_NONE,
 
1763
                            opt_log ? LOG_TABLE : LOG_NONE);
 
1764
      }
 
1765
      else
 
1766
      {
 
1767
        logger.set_handlers(LOG_FILE,
 
1768
                            opt_slow_log ? log_output_options : LOG_NONE,
 
1769
                            opt_log ? log_output_options : LOG_NONE);
1787
1770
      }
1788
1771
      break;
1789
1772
#ifdef USE_ONE_SIGNAL_HAND
1793
1776
#endif
1794
1777
    default:
1795
1778
#ifdef EXTRA_DEBUG
1796
 
      sql_print_warning(_("Got signal: %d  error: %d"),sig,error); /* purecov: tested */
 
1779
      sql_print_warning("Got signal: %d  error: %d",sig,error); /* purecov: tested */
1797
1780
#endif
1798
1781
      break;                                    /* purecov: tested */
1799
1782
    }
1801
1784
  return(0);                                    /* purecov: deadcode */
1802
1785
}
1803
1786
 
1804
 
static void check_data_home(const char *path __attribute__((unused)))
 
1787
static void check_data_home(const char *path)
1805
1788
{}
1806
1789
 
1807
1790
#endif  /* __WIN__*/
1812
1795
  for the client.
1813
1796
*/
1814
1797
/* ARGSUSED */
1815
 
extern "C" void my_message_sql(uint32_t error, const char *str, myf MyFlags);
 
1798
extern "C" void my_message_sql(uint error, const char *str, myf MyFlags);
1816
1799
 
1817
 
void my_message_sql(uint32_t error, const char *str, myf MyFlags)
 
1800
void my_message_sql(uint error, const char *str, myf MyFlags)
1818
1801
{
1819
1802
  THD *thd;
1820
1803
  /*
1826
1809
    if (MyFlags & ME_FATALERROR)
1827
1810
      thd->is_fatal_error= 1;
1828
1811
 
 
1812
#ifdef BUG_36098_FIXED
 
1813
    mysql_audit_general(thd,MYSQL_AUDIT_GENERAL_ERROR,error,my_time(0),
 
1814
                        0,0,str,str ? strlen(str) : 0,
 
1815
                        thd->query,thd->query_length,
 
1816
                        thd->variables.character_set_client,
 
1817
                        thd->row_count);
 
1818
#endif
 
1819
 
 
1820
 
1829
1821
    /*
1830
1822
      TODO: There are two exceptions mechanism (THD and sp_rcontext),
1831
1823
      this could be improved by having a common stack of handlers.
1832
1824
    */
1833
1825
    if (thd->handle_error(error, str,
1834
 
                          DRIZZLE_ERROR::WARN_LEVEL_ERROR))
 
1826
                          MYSQL_ERROR::WARN_LEVEL_ERROR))
1835
1827
      return;;
1836
1828
 
1837
1829
    thd->is_slave_error=  1; // needed to catch query errors during replication
1840
1832
      thd->lex->current_select == 0 if lex structure is not inited
1841
1833
      (not query command (COM_QUERY))
1842
1834
    */
1843
 
    if (! (thd->lex->current_select &&
1844
 
        thd->lex->current_select->no_error && !thd->is_fatal_error))
 
1835
    if (thd->lex->current_select &&
 
1836
        thd->lex->current_select->no_error && !thd->is_fatal_error)
 
1837
    {
 
1838
      /* DBUG_WAS_HERE */
 
1839
    }
 
1840
    else
1845
1841
    {
1846
1842
      if (! thd->main_da.is_error())            // Return only first message
1847
1843
      {
1859
1855
        Suppress infinite recursion if there a memory allocation error
1860
1856
        inside push_warning.
1861
1857
      */
1862
 
      thd->no_warnings_for_error= true;
1863
 
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_ERROR, error, str);
1864
 
      thd->no_warnings_for_error= false;
 
1858
      thd->no_warnings_for_error= TRUE;
 
1859
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error, str);
 
1860
      thd->no_warnings_for_error= FALSE;
1865
1861
    }
1866
1862
  }
1867
1863
  if (!thd || MyFlags & ME_NOREFRESH)
1881
1877
 
1882
1878
void my_str_free_mysqld(void *ptr)
1883
1879
{
1884
 
  free((unsigned char*)ptr);
 
1880
  my_free((uchar*)ptr, MYF(MY_FAE));
1885
1881
}
1886
1882
 
1887
1883
 
1888
1884
static const char *load_default_groups[]= {
1889
 
"mysqld","server", DRIZZLE_BASE_VERSION, 0, 0};
 
1885
"mysqld","server", MYSQL_BASE_VERSION, 0, 0};
1890
1886
 
1891
1887
 
1892
1888
/**
1905
1901
    1 error
1906
1902
*/
1907
1903
 
1908
 
static bool init_global_datetime_format(enum enum_drizzle_timestamp_type format_type,
 
1904
static bool init_global_datetime_format(timestamp_type format_type,
1909
1905
                                        DATE_TIME_FORMAT **var_ptr)
1910
1906
{
1911
1907
  /* Get command line option */
1923
1919
  }
1924
1920
  if (!(*var_ptr= date_time_format_make(format_type, str, strlen(str))))
1925
1921
  {
1926
 
    fprintf(stderr, _("Wrong date/time format specifier: %s\n"), str);
 
1922
    fprintf(stderr, "Wrong date/time format specifier: %s\n", str);
1927
1923
    return 1;
1928
1924
  }
1929
1925
  return 0;
1933
1929
  {"admin_commands",       (char*) offsetof(STATUS_VAR, com_other), SHOW_LONG_STATUS},
1934
1930
  {"assign_to_keycache",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ASSIGN_TO_KEYCACHE]), SHOW_LONG_STATUS},
1935
1931
  {"alter_db",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB]), SHOW_LONG_STATUS},
 
1932
  {"alter_db_upgrade",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB_UPGRADE]), SHOW_LONG_STATUS},
1936
1933
  {"alter_table",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_TABLE]), SHOW_LONG_STATUS},
1937
1934
  {"analyze",              (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ANALYZE]), SHOW_LONG_STATUS},
1938
1935
  {"begin",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BEGIN]), SHOW_LONG_STATUS},
1971
1968
  {"savepoint",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SAVEPOINT]), SHOW_LONG_STATUS},
1972
1969
  {"select",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SELECT]), SHOW_LONG_STATUS},
1973
1970
  {"set_option",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SET_OPTION]), SHOW_LONG_STATUS},
 
1971
  {"show_binlog_events",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOG_EVENTS]), SHOW_LONG_STATUS},
1974
1972
  {"show_binlogs",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOGS]), SHOW_LONG_STATUS},
 
1973
  {"show_charsets",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CHARSETS]), SHOW_LONG_STATUS},
 
1974
  {"show_collations",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLLATIONS]), SHOW_LONG_STATUS},
1975
1975
  {"show_create_db",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE_DB]), SHOW_LONG_STATUS},
1976
1976
  {"show_create_table",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE]), SHOW_LONG_STATUS},
1977
1977
  {"show_databases",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_DATABASES]), SHOW_LONG_STATUS},
1983
1983
  {"show_open_tables",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_OPEN_TABLES]), SHOW_LONG_STATUS},
1984
1984
  {"show_plugins",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PLUGINS]), SHOW_LONG_STATUS},
1985
1985
  {"show_processlist",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PROCESSLIST]), SHOW_LONG_STATUS},
 
1986
  {"show_slave_hosts",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_HOSTS]), SHOW_LONG_STATUS},
1986
1987
  {"show_slave_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_STAT]), SHOW_LONG_STATUS},
1987
1988
  {"show_status",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},
1988
1989
  {"show_table_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLE_STATUS]), SHOW_LONG_STATUS},
1995
1996
  {"unlock_tables",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UNLOCK_TABLES]), SHOW_LONG_STATUS},
1996
1997
  {"update",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE]), SHOW_LONG_STATUS},
1997
1998
  {"update_multi",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE_MULTI]), SHOW_LONG_STATUS},
1998
 
  {NULL, NULL, SHOW_LONG}
 
1999
  {NullS, NullS, SHOW_LONG}
1999
2000
};
2000
2001
 
2001
2002
static int init_common_variables(const char *conf_file_name, int argc,
2002
2003
                                 char **argv, const char **groups)
2003
2004
{
 
2005
  char buff[FN_REFLEN], *s;
2004
2006
  umask(((~my_umask) & 0666));
2005
2007
  my_decimal_set_zero(&decimal_zero); // set decimal_zero constant;
2006
2008
  tzset();                      // Set tzname
2007
2009
 
2008
 
  max_system_variables.pseudo_thread_id= UINT32_MAX;
 
2010
  max_system_variables.pseudo_thread_id= (ulong)~0;
2009
2011
  server_start_time= flush_status_time= my_time(0);
2010
2012
  rpl_filter= new Rpl_filter;
2011
2013
  binlog_filter= new Rpl_filter;
2012
 
  if (!rpl_filter || !binlog_filter)
 
2014
  if (!rpl_filter || !binlog_filter) 
2013
2015
  {
2014
2016
    sql_perror("Could not allocate replication and binlog filters");
2015
2017
    exit(1);
2037
2039
  global_system_variables.time_zone= my_tz_SYSTEM;
2038
2040
 
2039
2041
  /*
2040
 
    Init mutexes for the global DRIZZLE_BIN_LOG objects.
 
2042
    Init mutexes for the global MYSQL_BIN_LOG objects.
2041
2043
    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
 
2044
    global MYSQL_BIN_LOGs in their constructors, because then they would be
2043
2045
    inited before MY_INIT(). So we do it here.
2044
2046
  */
2045
2047
  mysql_bin_log.init_pthread_objects();
2047
2049
  if (gethostname(glob_hostname,sizeof(glob_hostname)) < 0)
2048
2050
  {
2049
2051
    strmake(glob_hostname, STRING_WITH_LEN("localhost"));
2050
 
    sql_print_warning(_("gethostname failed, using '%s' as hostname"),
 
2052
    sql_print_warning("gethostname failed, using '%s' as hostname",
2051
2053
                      glob_hostname);
2052
2054
    strmake(pidfile_name, STRING_WITH_LEN("mysql"));
2053
2055
  }
2054
2056
  else
2055
2057
  strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
2056
 
  my_stpcpy(fn_ext(pidfile_name),".pid");               // Add proper extension
 
2058
  strmov(fn_ext(pidfile_name),".pid");          // Add proper extension
2057
2059
 
2058
2060
  /*
2059
2061
    Add server status variables to the dynamic list of
2064
2066
  if (add_status_vars(status_vars))
2065
2067
    return 1; // an error was already reported
2066
2068
 
 
2069
#ifndef DBUG_OFF
 
2070
  /*
 
2071
    We have few debug-only commands in com_status_vars, only visible in debug
 
2072
    builds. for simplicity we enable the assert only in debug builds
 
2073
 
 
2074
    There are 7 Com_ variables which don't have corresponding SQLCOM_ values:
 
2075
    (TODO strictly speaking they shouldn't be here, should not have Com_ prefix
 
2076
    that is. Perhaps Stmt_ ? Comstmt_ ? Prepstmt_ ?)
 
2077
 
 
2078
      Com_admin_commands       => com_other
 
2079
      Com_stmt_close           => com_stmt_close
 
2080
      Com_stmt_execute         => com_stmt_execute
 
2081
      Com_stmt_fetch           => com_stmt_fetch
 
2082
      Com_stmt_prepare         => com_stmt_prepare
 
2083
      Com_stmt_reset           => com_stmt_reset
 
2084
      Com_stmt_send_long_data  => com_stmt_send_long_data
 
2085
 
 
2086
    With this correction the number of Com_ variables (number of elements in
 
2087
    the array, excluding the last element - terminator) must match the number
 
2088
    of SQLCOM_ constants.
 
2089
  */
 
2090
  compile_time_assert(sizeof(com_status_vars)/sizeof(com_status_vars[0]) - 1 ==
 
2091
                     SQLCOM_END + 7);
 
2092
#endif
 
2093
 
2067
2094
  load_defaults(conf_file_name, groups, &argc, &argv);
2068
2095
  defaults_argv=argv;
2069
2096
  defaults_argc=argc;
2073
2100
 
2074
2101
  /* connections and databases needs lots of files */
2075
2102
  {
2076
 
    uint32_t files, wanted_files, max_open_files;
 
2103
    uint files, wanted_files, max_open_files;
2077
2104
 
2078
2105
    /* MyISAM requires two file handles per table. */
2079
2106
    wanted_files= 10+max_connections+table_cache_size*2;
2087
2114
      can't get max_connections*5 but still got no less than was
2088
2115
      requested (value of wanted_files).
2089
2116
    */
2090
 
    max_open_files= cmax(cmax((uint32_t)wanted_files, max_connections*5),
2091
 
                         open_files_limit);
 
2117
    max_open_files= max(max(wanted_files, max_connections*5),
 
2118
                        open_files_limit);
2092
2119
    files= my_set_max_open_files(max_open_files);
2093
2120
 
2094
2121
    if (files < wanted_files)
2099
2126
          If we have requested too much file handles than we bring
2100
2127
          max_connections in supported bounds.
2101
2128
        */
2102
 
        max_connections= (uint32_t) cmin((uint32_t)files-10-TABLE_OPEN_CACHE_MIN*2,
 
2129
        max_connections= (ulong) min(files-10-TABLE_OPEN_CACHE_MIN*2,
2103
2130
                                     max_connections);
2104
2131
        /*
2105
2132
          Decrease table_cache_size according to max_connections, but
2106
 
          not below TABLE_OPEN_CACHE_MIN.  Outer cmin() ensures that we
 
2133
          not below TABLE_OPEN_CACHE_MIN.  Outer min() ensures that we
2107
2134
          never increase table_cache_size automatically (that could
2108
2135
          happen if max_connections is decreased above).
2109
2136
        */
2110
 
        table_cache_size= (uint32_t) cmin(cmax((files-10-max_connections)/2,
2111
 
                                          (uint32_t)TABLE_OPEN_CACHE_MIN),
 
2137
        table_cache_size= (ulong) min(max((files-10-max_connections)/2,
 
2138
                                          TABLE_OPEN_CACHE_MIN),
2112
2139
                                      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);
 
2140
        if (global_system_variables.log_warnings)
 
2141
          sql_print_warning("Changed limits: max_open_files: %u  max_connections: %ld  table_cache: %ld",
 
2142
                        files, max_connections, table_cache_size);
2117
2143
      }
2118
2144
      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);
 
2145
        sql_print_warning("Could not increase number of max_open_files to more than %u (request: %u)", files, wanted_files);
2122
2146
    }
2123
2147
    open_files_limit= files;
2124
2148
  }
2125
 
  unireg_init(0); /* Set up extern variabels */
 
2149
  unireg_init(opt_specialflag); /* Set up extern variabels */
2126
2150
  if (init_errmessage())        /* Read error messages from file */
2127
2151
    return 1;
 
2152
  init_client_errs();
2128
2153
  lex_init();
2129
2154
  if (item_create_init())
2130
2155
    return 1;
2133
2158
    return 1;
2134
2159
  if (init_replication_sys_vars())
2135
2160
    return 1;
 
2161
  mysys_uses_curses=0;
2136
2162
  /*
2137
2163
    Process a comma-separated character set list and choose
2138
2164
    the first available character set. This is mostly for
2162
2188
 
2163
2189
  if (default_collation_name)
2164
2190
  {
2165
 
    const CHARSET_INFO * const default_collation=
2166
 
      get_charset_by_name(default_collation_name, MYF(0));
 
2191
    CHARSET_INFO *default_collation;
 
2192
    default_collation= get_charset_by_name(default_collation_name, MYF(0));
2167
2193
    if (!default_collation)
2168
2194
    {
2169
 
      sql_print_error(_(ER(ER_UNKNOWN_COLLATION)), default_collation_name);
 
2195
      sql_print_error(ER(ER_UNKNOWN_COLLATION), default_collation_name);
2170
2196
      return 1;
2171
2197
    }
2172
2198
    if (!my_charset_same(default_charset_info, default_collation))
2173
2199
    {
2174
 
      sql_print_error(_(ER(ER_COLLATION_CHARSET_MISMATCH)),
2175
 
                      default_collation_name,
2176
 
                      default_charset_info->csname);
 
2200
      sql_print_error(ER(ER_COLLATION_CHARSET_MISMATCH),
 
2201
                      default_collation_name,
 
2202
                      default_charset_info->csname);
2177
2203
      return 1;
2178
2204
    }
2179
2205
    default_charset_info= default_collation;
2188
2214
  global_system_variables.optimizer_use_mrr= 1;
2189
2215
  global_system_variables.optimizer_switch= 0;
2190
2216
 
2191
 
  if (!(character_set_filesystem=
 
2217
  if (!(character_set_filesystem= 
2192
2218
        get_charset_by_csname(character_set_filesystem_name,
2193
2219
                              MY_CS_PRIMARY, MYF(MY_WME))))
2194
2220
    return 1;
2197
2223
  if (!(my_default_lc_time_names=
2198
2224
        my_locale_by_name(lc_time_names_name)))
2199
2225
  {
2200
 
    sql_print_error(_("Unknown locale: '%s'"), lc_time_names_name);
 
2226
    sql_print_error("Unknown locale: '%s'", lc_time_names_name);
2201
2227
    return 1;
2202
2228
  }
2203
2229
  global_system_variables.lc_time_names= my_default_lc_time_names;
2204
 
 
 
2230
  
2205
2231
  sys_init_connect.value_length= 0;
2206
2232
  if ((sys_init_connect.value= opt_init_connect))
2207
2233
    sys_init_connect.value_length= strlen(opt_init_connect);
2214
2240
  else
2215
2241
    sys_init_slave.value=my_strdup("",MYF(0));
2216
2242
 
 
2243
  /* check log options and issue warnings if needed */
 
2244
  if (opt_log && opt_logname && !(log_output_options & LOG_FILE) &&
 
2245
      !(log_output_options & LOG_NONE))
 
2246
    sql_print_warning("Although a path was specified for the "
 
2247
                      "--log option, log tables are used. "
 
2248
                      "To enable logging to files use the --log-output option.");
 
2249
 
 
2250
  if (opt_slow_log && opt_slow_logname && !(log_output_options & LOG_FILE)
 
2251
      && !(log_output_options & LOG_NONE))
 
2252
    sql_print_warning("Although a path was specified for the "
 
2253
                      "--log-slow-queries option, log tables are used. "
 
2254
                      "To enable logging to files use the --log-output=file option.");
 
2255
 
 
2256
  s= opt_logname ? opt_logname : make_default_log_name(buff, ".log");
 
2257
  sys_var_general_log_path.value= my_strdup(s, MYF(0));
 
2258
  sys_var_general_log_path.value_length= strlen(s);
 
2259
 
 
2260
  s= opt_slow_logname ? opt_slow_logname : make_default_log_name(buff, "-slow.log");
 
2261
  sys_var_slow_log_path.value= my_strdup(s, MYF(0));
 
2262
  sys_var_slow_log_path.value_length= strlen(s);
 
2263
 
2217
2264
  if (use_temp_pool && bitmap_init(&temp_pool,0,1024,1))
2218
2265
    return 1;
2219
2266
  if (my_database_names_init())
2220
2267
    return 1;
2221
2268
 
 
2269
  /*
 
2270
    Ensure that lower_case_table_names is set on system where we have case
 
2271
    insensitive names.  If this is not done the users MyISAM tables will
 
2272
    get corrupted if accesses with names of different case.
 
2273
  */
 
2274
  lower_case_file_system= test_if_case_insensitive(mysql_real_data_home);
 
2275
  if (!lower_case_table_names && lower_case_file_system == 1)
 
2276
  {
 
2277
    if (lower_case_table_names_used)
 
2278
    {
 
2279
      if (global_system_variables.log_warnings)
 
2280
        sql_print_warning("\
 
2281
You have forced lower_case_table_names to 0 through a command-line \
 
2282
option, even though your file system '%s' is case insensitive.  This means \
 
2283
that you can corrupt a MyISAM table by accessing it with different cases. \
 
2284
You should consider changing lower_case_table_names to 1 or 2",
 
2285
                        mysql_real_data_home);
 
2286
    }
 
2287
    else
 
2288
    {
 
2289
      if (global_system_variables.log_warnings)
 
2290
        sql_print_warning("Setting lower_case_table_names=2 because file system for %s is case insensitive", mysql_real_data_home);
 
2291
      lower_case_table_names= 2;
 
2292
    }
 
2293
  }
 
2294
  else if (lower_case_table_names == 2 &&
 
2295
           !(lower_case_file_system=
 
2296
             (test_if_case_insensitive(mysql_real_data_home) == 1)))
 
2297
  {
 
2298
    if (global_system_variables.log_warnings)
 
2299
      sql_print_warning("lower_case_table_names was set to 2, even though your "
 
2300
                        "the file system '%s' is case sensitive.  Now setting "
 
2301
                        "lower_case_table_names to 0 to avoid future problems.",
 
2302
                        mysql_real_data_home);
 
2303
    lower_case_table_names= 0;
 
2304
  }
 
2305
  else
 
2306
  {
 
2307
    lower_case_file_system=
 
2308
      (test_if_case_insensitive(mysql_real_data_home) == 1);
 
2309
  }
2222
2310
 
2223
2311
  /* 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;
 
2312
  table_alias_charset= (lower_case_table_names ?
 
2313
                        files_charset_info :
 
2314
                        &my_charset_bin);
2226
2315
 
2227
2316
  return 0;
2228
2317
}
2234
2323
  (void) pthread_mutex_init(&LOCK_lock_db,MY_MUTEX_INIT_SLOW);
2235
2324
  (void) pthread_mutex_init(&LOCK_open, NULL);
2236
2325
  (void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);
 
2326
  (void) pthread_mutex_init(&LOCK_mapped_file,MY_MUTEX_INIT_SLOW);
2237
2327
  (void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);
2238
2328
  (void) pthread_mutex_init(&LOCK_error_log,MY_MUTEX_INIT_FAST);
 
2329
  (void) pthread_mutex_init(&LOCK_manager,MY_MUTEX_INIT_FAST);
 
2330
  (void) pthread_mutex_init(&LOCK_crypt,MY_MUTEX_INIT_FAST);
2239
2331
  (void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);
2240
2332
  (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
2241
2333
  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
2250
2342
  (void) pthread_cond_init(&COND_global_read_lock,NULL);
2251
2343
  (void) pthread_cond_init(&COND_thread_cache,NULL);
2252
2344
  (void) pthread_cond_init(&COND_flush_thread_cache,NULL);
 
2345
  (void) pthread_cond_init(&COND_manager,NULL);
 
2346
  (void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);
 
2347
  (void) pthread_cond_init(&COND_rpl_status, NULL);
2253
2348
 
2254
2349
  /* Parameter for threads created for connections */
2255
2350
  (void) pthread_attr_init(&connection_attrib);
2256
2351
  (void) pthread_attr_setdetachstate(&connection_attrib,
2257
2352
                                     PTHREAD_CREATE_DETACHED);
2258
2353
  pthread_attr_setscope(&connection_attrib, PTHREAD_SCOPE_SYSTEM);
 
2354
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
2259
2355
  {
2260
2356
    struct sched_param tmp_sched_param;
2261
2357
 
2267
2363
  if (pthread_key_create(&THR_THD,NULL) ||
2268
2364
      pthread_key_create(&THR_MALLOC,NULL))
2269
2365
  {
2270
 
    sql_print_error(_("Can't create thread-keys"));
 
2366
    sql_print_error("Can't create thread-keys");
2271
2367
    return 1;
2272
2368
  }
2273
2369
  return 0;
2283
2379
  if (table_cache_init() | table_def_init())
2284
2380
    unireg_abort(1);
2285
2381
 
2286
 
  randominit(&sql_rand,(uint32_t) server_start_time,(uint32_t) server_start_time/2);
 
2382
  randominit(&sql_rand,(ulong) server_start_time,(ulong) server_start_time/2);
2287
2383
  setup_fpu();
2288
2384
  init_thr_lock();
 
2385
  init_slave_list();
2289
2386
 
2290
2387
  /* Setup logs */
2291
2388
 
2313
2410
 
2314
2411
  if (xid_cache_init())
2315
2412
  {
2316
 
    sql_print_error(_("Out of memory"));
 
2413
    sql_print_error("Out of memory");
2317
2414
    unireg_abort(1);
2318
2415
  }
2319
2416
 
2320
2417
  if (!opt_bin_log)
2321
2418
    if (opt_binlog_format_id != BINLOG_FORMAT_UNSPEC)
2322
2419
    {
2323
 
      sql_print_error(_("You need to use --log-bin to make "
2324
 
                        "--binlog-format work."));
 
2420
      sql_print_error("You need to use --log-bin to make "
 
2421
                      "--binlog-format work.");
2325
2422
      unireg_abort(1);
2326
2423
    }
2327
2424
    else
2332
2429
    if (opt_binlog_format_id == BINLOG_FORMAT_UNSPEC)
2333
2430
      global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;
2334
2431
    else
2335
 
    {
 
2432
    { 
2336
2433
      assert(global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC);
2337
2434
    }
2338
2435
 
2342
2439
 
2343
2440
  if (opt_log_slave_updates && replicate_same_server_id)
2344
2441
  {
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."));
 
2442
    sql_print_error("\
 
2443
using --replicate-same-server-id in conjunction with \
 
2444
--log-slave-updates is impossible, it would lead to infinite loops in this \
 
2445
server.");
2348
2446
    unireg_abort(1);
2349
2447
  }
2350
2448
 
2362
2460
        require a name. But as we don't want to break many existing setups, we
2363
2461
        only give warning, not error.
2364
2462
      */
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);
 
2463
      sql_print_warning("No argument was provided to --log-bin, and "
 
2464
                        "--log-bin-index was not used; so replication "
 
2465
                        "may break when this MySQL server acts as a "
 
2466
                        "master and has his hostname changed!! Please "
 
2467
                        "use '--log-bin=%s' to avoid this problem.", ln);
2370
2468
    }
2371
2469
    if (ln == buf)
2372
2470
    {
2373
 
      free(opt_bin_logname);
 
2471
      my_free(opt_bin_logname, MYF(MY_ALLOW_ZERO_PTR));
2374
2472
      opt_bin_logname=my_strdup(buf, MYF(0));
2375
2473
    }
2376
2474
    if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln))
2396
2494
                  (opt_noacl ? PLUGIN_INIT_SKIP_PLUGIN_TABLE : 0) |
2397
2495
                  (opt_help ? PLUGIN_INIT_SKIP_INITIALIZATION : 0)))
2398
2496
  {
2399
 
    sql_print_error(_("Failed to initialize plugins."));
 
2497
    sql_print_error("Failed to initialize plugins.");
2400
2498
    unireg_abort(1);
2401
2499
  }
2402
2500
 
2426
2524
 
2427
2525
    if (defaults_argc)
2428
2526
    {
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"),
 
2527
      fprintf(stderr, "%s: Too many arguments (first extra is '%s').\n"
 
2528
              "Use --verbose --help to get a list of available options\n",
2432
2529
              my_progname, *tmp_argv);
2433
2530
      unireg_abort(1);
2434
2531
    }
2435
2532
  }
2436
2533
 
 
2534
  /* if the errmsg.sys is not loaded, terminate to maintain behaviour */
 
2535
  if (!errmesg[0][0])
 
2536
    unireg_abort(1);
 
2537
 
2437
2538
  /* We have to initialize the storage engines before CSV logging */
2438
2539
  if (ha_init())
2439
2540
  {
2440
 
    sql_print_error(_("Can't init databases"));
 
2541
    sql_print_error("Can't init databases");
2441
2542
    unireg_abort(1);
2442
2543
  }
2443
2544
 
 
2545
  logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,
 
2546
                      opt_log ? LOG_FILE:LOG_NONE);
 
2547
 
2444
2548
  /*
2445
2549
    Check that the default storage engine is actually available.
2446
2550
  */
2450
2554
                       strlen(default_storage_engine_str) };
2451
2555
    plugin_ref plugin;
2452
2556
    handlerton *hton;
2453
 
 
 
2557
    
2454
2558
    if ((plugin= ha_resolve_by_name(0, &name)))
2455
 
    {
2456
 
      hton= plugin_data(plugin,handlerton *);
2457
 
    }
 
2559
      hton= plugin_data(plugin, handlerton*);
2458
2560
    else
2459
2561
    {
2460
 
      sql_print_error(_("Unknown/unsupported table type: %s"),
 
2562
      sql_print_error("Unknown/unsupported table type: %s",
2461
2563
                      default_storage_engine_str);
2462
2564
      unireg_abort(1);
2463
2565
    }
2464
2566
    if (!ha_storage_engine_is_enabled(hton))
2465
2567
    {
2466
 
      sql_print_error(_("Default storage engine (%s) is not available"),
2467
 
                      default_storage_engine_str);
2468
 
      unireg_abort(1);
 
2568
      if (!opt_bootstrap)
 
2569
      {
 
2570
        sql_print_error("Default storage engine (%s) is not available",
 
2571
                        default_storage_engine_str);
 
2572
        unireg_abort(1);
 
2573
      }
2469
2574
      assert(global_system_variables.table_plugin);
2470
2575
    }
2471
2576
    else
2472
2577
    {
2473
2578
      /*
2474
 
        Need to unlock as global_system_variables.table_plugin
 
2579
        Need to unlock as global_system_variables.table_plugin 
2475
2580
        was acquired during plugin_init()
2476
2581
      */
2477
2582
      plugin_unlock(0, global_system_variables.table_plugin);
2486
2591
 
2487
2592
  if (tc_log->open(opt_bin_log ? opt_bin_logname : opt_tc_log_file))
2488
2593
  {
2489
 
    sql_print_error(_("Can't initialize tc_log"));
 
2594
    sql_print_error("Can't init tc log");
2490
2595
    unireg_abort(1);
2491
2596
  }
2492
2597
 
2506
2611
      mysql_bin_log.purge_logs_before_date(purge_time);
2507
2612
  }
2508
2613
 
 
2614
  if (opt_myisam_log)
 
2615
    (void) mi_log(1);
 
2616
 
2509
2617
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
2510
2618
  if (locked_in_memory && !getuid())
2511
2619
  {
2517
2625
    if (mlockall(MCL_CURRENT))
2518
2626
    {
2519
2627
      if (global_system_variables.log_warnings)
2520
 
        sql_print_warning(_("Failed to lock memory. Errno: %d\n"),errno);
 
2628
        sql_print_warning("Failed to lock memory. Errno: %d\n",errno);
2521
2629
      locked_in_memory= 0;
2522
2630
    }
2523
2631
    if (user_info)
2532
2640
}
2533
2641
 
2534
2642
 
 
2643
static void create_maintenance_thread()
 
2644
{
 
2645
  if (flush_time && flush_time != ~(ulong) 0L)
 
2646
  {
 
2647
    pthread_t hThread;
 
2648
    if (pthread_create(&hThread,&connection_attrib,handle_manager,0))
 
2649
      sql_print_warning("Can't create thread to manage maintenance");
 
2650
  }
 
2651
}
 
2652
 
 
2653
 
2535
2654
int main(int argc, char **argv)
2536
2655
{
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
2656
  MY_INIT(argv[0]);             // init my_sys library & pthreads
2546
2657
  /* nothing should come before this line ^^^ */
2547
2658
 
2566
2677
  }
2567
2678
#endif
2568
2679
 
2569
 
  if (init_common_variables(DRIZZLE_CONFIG_NAME,
 
2680
  if (init_common_variables(MYSQL_CONFIG_NAME,
2570
2681
                            argc, argv, load_default_groups))
2571
2682
    unireg_abort(1);                            // Will do exit
2572
2683
 
2573
2684
  init_signals();
 
2685
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
 
2686
  {
 
2687
    struct sched_param tmp_sched_param;
2574
2688
 
 
2689
    memset(&tmp_sched_param, 0, sizeof(tmp_sched_param));
 
2690
    tmp_sched_param.sched_priority= my_thread_stack_size*2;
 
2691
    (void)pthread_setschedparam(pthread_self(), SCHED_OTHER, &tmp_sched_param);
 
2692
  }
2575
2693
  pthread_attr_setstacksize(&connection_attrib,my_thread_stack_size);
2576
 
 
2577
2694
#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE
2578
2695
  {
2579
2696
    /* Retrieve used stack size;  Needed for checking stack overflows */
2583
2700
    if (stack_size && stack_size < my_thread_stack_size)
2584
2701
    {
2585
2702
      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
 
      }
 
2703
        sql_print_warning("Asked for %lu thread stack, but got %ld",
 
2704
                          my_thread_stack_size, (long) stack_size);
2592
2705
      my_thread_stack_size= stack_size;
2593
2706
    }
2594
2707
  }
2622
2735
  {
2623
2736
    server_id= 1;
2624
2737
#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."));
 
2738
    sql_print_warning("You have enabled the binary log, but you haven't set "
 
2739
                      "server-id to a non-zero value: we force server id to 1; "
 
2740
                      "updates will be logged to the binary log, but "
 
2741
                      "connections from slaves will not be accepted.");
2629
2742
#endif
2630
2743
  }
2631
2744
 
2647
2760
  error_handler_hook= my_message_sql;
2648
2761
  start_signal_handler();                               // Creates pidfile
2649
2762
 
2650
 
  if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name))
 
2763
  if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name, opt_bootstrap))
2651
2764
  {
2652
2765
    abort_loop=1;
2653
2766
    select_thread_in_use=0;
2654
 
    (void) pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL);
 
2767
    (void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
2655
2768
 
2656
 
    (void) my_delete(pidfile_name,MYF(MY_WME)); // Not needed anymore
 
2769
    if (!opt_bootstrap)
 
2770
      (void) my_delete(pidfile_name,MYF(MY_WME));       // Not needed anymore
2657
2771
 
2658
2772
    exit(1);
2659
2773
  }
2660
2774
 
 
2775
  udf_init();
 
2776
 
2661
2777
  init_status_vars();
 
2778
  if (opt_bootstrap) /* If running with bootstrap, do not start replication. */
 
2779
    opt_skip_slave_start= 1;
2662
2780
  /*
2663
2781
    init_slave() must be called after the thread keys are created.
2664
2782
    Some parts of the code (e.g. SHOW STATUS LIKE 'slave_running' and other
2670
2788
    unireg_abort(1);
2671
2789
  }
2672
2790
 
2673
 
  sql_print_information(_(ER(ER_STARTUP)),my_progname,server_version,
2674
 
                        "", mysqld_port, DRIZZLE_COMPILATION_COMMENT);
 
2791
  create_maintenance_thread();
 
2792
 
 
2793
  sql_print_information(ER(ER_STARTUP),my_progname,server_version,
 
2794
                        "", mysqld_port, MYSQL_COMPILATION_COMMENT);
2675
2795
 
2676
2796
 
2677
2797
  handle_connections_sockets();
2678
2798
 
2679
2799
  /* (void) pthread_attr_destroy(&connection_attrib); */
2680
 
 
 
2800
  
2681
2801
 
2682
2802
#ifdef EXTRA_DEBUG2
2683
 
  sql_print_error(_("Before Lock_thread_count"));
 
2803
  sql_print_error("Before Lock_thread_count");
2684
2804
#endif
2685
2805
  (void) pthread_mutex_lock(&LOCK_thread_count);
2686
2806
  select_thread_in_use=0;                       // For close_connections
2687
2807
  (void) pthread_mutex_unlock(&LOCK_thread_count);
2688
2808
  (void) pthread_cond_broadcast(&COND_thread_count);
2689
2809
#ifdef EXTRA_DEBUG2
2690
 
  sql_print_error(_("After lock_thread_count"));
 
2810
  sql_print_error("After lock_thread_count");
2691
2811
#endif
2692
2812
 
2693
2813
  /* Wait until cleanup is done */
2763
2883
inline void kill_broken_server()
2764
2884
{
2765
2885
  /* hack to get around signals ignored in syscalls for problem OS's */
2766
 
  if ((ip_sock == -1))
 
2886
  if ((!opt_disable_networking && ip_sock == INVALID_SOCKET))
2767
2887
  {
2768
2888
    select_thread_in_use = 0;
2769
2889
    /* The following call will never return */
2770
 
    kill_server((void*) DRIZZLE_KILL_SIGNAL);
 
2890
    kill_server((void*) MYSQL_KILL_SIGNAL);
2771
2891
  }
2772
2892
}
2773
2893
#define MAYBE_BROKEN_SYSCALL kill_broken_server();
2779
2899
 
2780
2900
void handle_connections_sockets()
2781
2901
{
2782
 
  int x;
2783
 
  int sock,new_sock;
2784
 
  uint32_t error_count=0;
 
2902
  my_socket sock,new_sock;
 
2903
  uint error_count=0;
 
2904
  uint max_used_connection= (uint)ip_sock+1;
 
2905
  fd_set readFDs,clientFDs;
2785
2906
  THD *thd;
2786
2907
  struct sockaddr_storage cAddr;
 
2908
  int ip_flags=0, flags;
 
2909
  st_vio *vio_tmp;
2787
2910
 
 
2911
  FD_ZERO(&clientFDs);
 
2912
  if (ip_sock != INVALID_SOCKET)
 
2913
  {
 
2914
    FD_SET(ip_sock,&clientFDs);
 
2915
    ip_flags = fcntl(ip_sock, F_GETFL, 0);
 
2916
  }
2788
2917
  MAYBE_BROKEN_SYSCALL;
2789
2918
  while (!abort_loop)
2790
2919
  {
2791
 
    int number_of;
2792
 
 
2793
 
    if ((number_of= poll(fds, pollfd_count, -1)) == -1)
 
2920
    readFDs=clientFDs;
 
2921
    if (select((int) max_used_connection,&readFDs,0,0,0) < 0)
2794
2922
    {
2795
 
      if (errno != EINTR)
 
2923
      if (socket_errno != SOCKET_EINTR)
2796
2924
      {
2797
 
        if (!select_errors++ && !abort_loop)    /* purecov: inspected */
2798
 
          sql_print_error(_("drizzled: Got error %d from select"),
2799
 
                          errno); /* purecov: inspected */
 
2925
        if (!select_errors++ && !abort_loop)    /* purecov: inspected */
 
2926
          sql_print_error("mysqld: Got error %d from select",socket_errno); /* purecov: inspected */
2800
2927
      }
2801
2928
      MAYBE_BROKEN_SYSCALL
2802
2929
      continue;
2803
2930
    }
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
2931
    if (abort_loop)
2812
2932
    {
2813
2933
      MAYBE_BROKEN_SYSCALL;
2814
2934
      break;
2815
2935
    }
2816
2936
 
2817
 
    for (x= 0, sock= -1; x < pollfd_count; x++)
 
2937
    /* Is this a new connection request ? */
2818
2938
    {
2819
 
      if (fds[x].revents == POLLIN)
2820
 
      {
2821
 
        sock= fds[x].fd;
2822
 
        break;
2823
 
      }
 
2939
      sock = ip_sock;
 
2940
      flags= ip_flags;
2824
2941
    }
2825
 
    assert(sock != -1);
2826
2942
 
2827
 
    for (uint32_t retry=0; retry < MAX_ACCEPT_RETRY; retry++)
2828
 
    {
2829
 
      SOCKET_SIZE_TYPE length= sizeof(struct sockaddr_storage);
 
2943
#if !defined(NO_FCNTL_NONBLOCK)
 
2944
    if (!(test_flags & TEST_BLOCKING))
 
2945
    {
 
2946
#if defined(O_NONBLOCK)
 
2947
      fcntl(sock, F_SETFL, flags | O_NONBLOCK);
 
2948
#elif defined(O_NDELAY)
 
2949
      fcntl(sock, F_SETFL, flags | O_NDELAY);
 
2950
#endif
 
2951
    }
 
2952
#endif /* NO_FCNTL_NONBLOCK */
 
2953
    for (uint retry=0; retry < MAX_ACCEPT_RETRY; retry++)
 
2954
    {
 
2955
      size_socket length= sizeof(struct sockaddr_storage);
2830
2956
      new_sock= accept(sock, (struct sockaddr *)(&cAddr),
2831
2957
                       &length);
2832
 
      if (new_sock != -1 || (errno != EINTR && errno != EAGAIN))
 
2958
      if (new_sock != INVALID_SOCKET ||
 
2959
          (socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))
2833
2960
        break;
 
2961
      MAYBE_BROKEN_SYSCALL;
 
2962
#if !defined(NO_FCNTL_NONBLOCK)
 
2963
      if (!(test_flags & TEST_BLOCKING))
 
2964
      {
 
2965
        if (retry == MAX_ACCEPT_RETRY - 1)
 
2966
          fcntl(sock, F_SETFL, flags);          // Try without O_NONBLOCK
 
2967
      }
 
2968
#endif
2834
2969
    }
2835
 
 
2836
 
 
2837
 
    if (new_sock == -1)
 
2970
#if !defined(NO_FCNTL_NONBLOCK)
 
2971
    if (!(test_flags & TEST_BLOCKING))
 
2972
      fcntl(sock, F_SETFL, flags);
 
2973
#endif
 
2974
    if (new_sock == INVALID_SOCKET)
2838
2975
    {
2839
2976
      if ((error_count++ & 255) == 0)           // This can happen often
2840
2977
        sql_perror("Error in accept");
2841
2978
      MAYBE_BROKEN_SYSCALL;
2842
 
      if (errno == ENFILE || errno == EMFILE)
 
2979
      if (socket_errno == SOCKET_ENFILE || socket_errno == SOCKET_EMFILE)
2843
2980
        sleep(1);                               // Give other threads some time
2844
2981
      continue;
2845
2982
    }
2846
2983
 
2847
2984
    {
2848
 
      SOCKET_SIZE_TYPE dummyLen;
 
2985
      size_socket dummyLen;
2849
2986
      struct sockaddr_storage dummy;
2850
2987
      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;
 
2988
      if (  getsockname(new_sock,(struct sockaddr *)&dummy, 
 
2989
                  (socklen_t *)&dummyLen) < 0  )
 
2990
      {
 
2991
        sql_perror("Error on new connection socket");
 
2992
        (void) shutdown(new_sock, SHUT_RDWR);
 
2993
        (void) closesocket(new_sock);
 
2994
        continue;
2867
2995
      }
2868
2996
    }
2869
2997
 
2874
3002
    if (!(thd= new THD))
2875
3003
    {
2876
3004
      (void) shutdown(new_sock, SHUT_RDWR);
2877
 
      close(new_sock);
 
3005
      VOID(closesocket(new_sock));
2878
3006
      continue;
2879
3007
    }
2880
 
    if (net_init_sock(&thd->net, new_sock, sock == 0))
 
3008
    if (!(vio_tmp=vio_new(new_sock, VIO_TYPE_TCPIP, sock == 0)) ||
 
3009
        my_net_init(&thd->net,vio_tmp))
2881
3010
    {
 
3011
      /*
 
3012
        Only delete the temporary vio if we didn't already attach it to the
 
3013
        NET object. The destructor in THD will delete any initialized net
 
3014
        structure.
 
3015
      */
 
3016
      if (vio_tmp && thd->net.vio != vio_tmp)
 
3017
        vio_delete(vio_tmp);
 
3018
      else
 
3019
      {
 
3020
        (void) shutdown(new_sock, SHUT_RDWR);
 
3021
        (void) closesocket(new_sock);
 
3022
      }
2882
3023
      delete thd;
2883
3024
      continue;
2884
3025
    }
2894
3035
 
2895
3036
enum options_mysqld
2896
3037
{
2897
 
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW,
2898
 
  OPT_SKIP_GRANT,
 
3038
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW, 
 
3039
  OPT_SKIP_GRANT,              OPT_SKIP_LOCK, 
2899
3040
  OPT_ENABLE_LOCK,             OPT_USE_LOCKING,
2900
3041
  OPT_SOCKET,                  OPT_UPDATE_LOG,
2901
 
  OPT_BIN_LOG,
 
3042
  OPT_BIN_LOG,                 
2902
3043
  OPT_BIN_LOG_INDEX,
2903
3044
  OPT_BIND_ADDRESS,            OPT_PID_FILE,
2904
 
  OPT_SKIP_PRIOR,
 
3045
  OPT_SKIP_PRIOR,              OPT_BIG_TABLES,
2905
3046
  OPT_STANDALONE,
2906
3047
  OPT_CONSOLE,                 OPT_LOW_PRIORITY_UPDATES,
2907
3048
  OPT_SHORT_LOG_FORMAT,
2908
3049
  OPT_FLUSH,                   OPT_SAFE,
 
3050
  OPT_BOOTSTRAP,               OPT_SKIP_SHOW_DB,
2909
3051
  OPT_STORAGE_ENGINE,          OPT_INIT_FILE,
2910
 
  OPT_DELAY_KEY_WRITE_ALL,
 
3052
  OPT_DELAY_KEY_WRITE_ALL,     OPT_SLOW_QUERY_LOG,
2911
3053
  OPT_DELAY_KEY_WRITE,         OPT_CHARSETS_DIR,
2912
3054
  OPT_MASTER_INFO_FILE,
2913
3055
  OPT_MASTER_RETRY_COUNT,      OPT_LOG_TC, OPT_LOG_TC_SIZE,
2915
3057
  OPT_REPLICATE_IGNORE_DB,     OPT_LOG_SLAVE_UPDATES,
2916
3058
  OPT_BINLOG_DO_DB,            OPT_BINLOG_IGNORE_DB,
2917
3059
  OPT_BINLOG_FORMAT,
2918
 
  OPT_BINLOG_ROWS_EVENT_MAX_SIZE,
 
3060
#ifndef DBUG_OFF
 
3061
  OPT_BINLOG_SHOW_XID,
 
3062
#endif
 
3063
  OPT_BINLOG_ROWS_EVENT_MAX_SIZE, 
2919
3064
  OPT_WANT_CORE,
2920
3065
  OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,
2921
3066
  OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID,
2925
3070
  OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,
2926
3071
  OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,
2927
3072
  OPT_ABORT_SLAVE_EVENT_COUNT,
2928
 
  OPT_ENGINE_CONDITION_PUSHDOWN,
 
3073
  OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
 
3074
  OPT_ENGINE_CONDITION_PUSHDOWN, 
2929
3075
  OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,
2930
3076
  OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,
2931
3077
  OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,
2941
3087
  OPT_SSL_CAPATH, OPT_SSL_CIPHER,
2942
3088
  OPT_BACK_LOG, OPT_BINLOG_CACHE_SIZE,
2943
3089
  OPT_CONNECT_TIMEOUT,
2944
 
  OPT_FLUSH_TIME,
 
3090
  OPT_FLUSH_TIME, OPT_FT_MIN_WORD_LEN, OPT_FT_BOOLEAN_SYNTAX,
2945
3091
  OPT_INTERACTIVE_TIMEOUT, OPT_JOIN_BUFF_SIZE,
2946
3092
  OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,
2947
3093
  OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,
2950
3096
  OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,
2951
3097
  OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,
2952
3098
  OPT_MAX_HEP_TABLE_SIZE,
2953
 
  OPT_MAX_JOIN_SIZE,
 
3099
  OPT_MAX_JOIN_SIZE, OPT_MAX_PREPARED_STMT_COUNT,
2954
3100
  OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,
2955
3101
  OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,
2956
3102
  OPT_MAX_LENGTH_FOR_SORT_DATA,
2964
3110
  OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,
2965
3111
  OPT_OPEN_FILES_LIMIT,
2966
3112
  OPT_PRELOAD_BUFFER_SIZE,
2967
 
  OPT_RECORD_BUFFER,
 
3113
  OPT_QUERY_CACHE_LIMIT, OPT_QUERY_CACHE_MIN_RES_UNIT, OPT_QUERY_CACHE_SIZE,
 
3114
  OPT_QUERY_CACHE_TYPE, OPT_QUERY_CACHE_WLOCK_INVALIDATE, OPT_RECORD_BUFFER,
2968
3115
  OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT, OPT_RELAY_LOG_SPACE_LIMIT,
2969
3116
  OPT_RELAY_LOG_PURGE,
2970
3117
  OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,
2984
3131
  OPT_SYNC_REPLICATION_TIMEOUT,
2985
3132
  OPT_ENABLE_SHARED_MEMORY,
2986
3133
  OPT_SHARED_MEMORY_BASE_NAME,
 
3134
  OPT_OLD_PASSWORDS,
2987
3135
  OPT_OLD_ALTER_TABLE,
2988
3136
  OPT_EXPIRE_LOGS_DAYS,
2989
3137
  OPT_GROUP_CONCAT_MAX_LEN,
2997
3145
  OPT_DATE_FORMAT,
2998
3146
  OPT_TIME_FORMAT,
2999
3147
  OPT_DATETIME_FORMAT,
 
3148
  OPT_LOG_QUERIES_NOT_USING_INDEXES,
3000
3149
  OPT_DEFAULT_TIME_ZONE,
3001
3150
  OPT_SYSDATE_IS_NOW,
3002
3151
  OPT_OPTIMIZER_SEARCH_DEPTH,
3006
3155
  OPT_ENABLE_LARGE_PAGES,
3007
3156
  OPT_TIMED_MUTEXES,
3008
3157
  OPT_OLD_STYLE_USER_LIMITS,
 
3158
  OPT_LOG_SLOW_ADMIN_STATEMENTS,
3009
3159
  OPT_TABLE_LOCK_WAIT_TIMEOUT,
3010
3160
  OPT_PLUGIN_LOAD,
3011
3161
  OPT_PLUGIN_DIR,
 
3162
  OPT_LOG_OUTPUT,
3012
3163
  OPT_PORT_OPEN_TIMEOUT,
3013
3164
  OPT_PROFILING,
3014
3165
  OPT_KEEP_FILES_ON_CREATE,
3015
3166
  OPT_GENERAL_LOG,
 
3167
  OPT_SLOW_LOG,
3016
3168
  OPT_THREAD_HANDLING,
3017
3169
  OPT_INNODB_ROLLBACK_ON_TIMEOUT,
3018
3170
  OPT_SECURE_FILE_PRIV,
3019
3171
  OPT_MIN_EXAMINED_ROW_LIMIT,
 
3172
  OPT_LOG_SLOW_SLAVE_STATEMENTS,
3020
3173
  OPT_OLD_MODE,
3021
3174
  OPT_POOL_OF_THREADS,
3022
3175
  OPT_SLAVE_EXEC_MODE
3023
3176
};
3024
3177
 
3025
3178
 
3026
 
#define LONG_TIMEOUT ((uint32_t) 3600L*24L*365L)
 
3179
#define LONG_TIMEOUT ((ulong) 3600L*24L*365L)
3027
3180
 
3028
3181
struct my_option my_long_options[] =
3029
3182
{
3030
 
  {"help", '?', N_("Display this help and exit."),
3031
 
   (char**) &opt_help, (char**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
3183
  {"help", '?', "Display this help and exit.", 
 
3184
   (uchar**) &opt_help, (uchar**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
3032
3185
   0, 0},
3033
3186
  {"abort-slave-event-count", OPT_ABORT_SLAVE_EVENT_COUNT,
3034
 
   N_("Option used by mysql-test for debugging and testing of replication."),
3035
 
   (char**) &abort_slave_event_count,  (char**) &abort_slave_event_count,
 
3187
   "Option used by mysql-test for debugging and testing of replication.",
 
3188
   (uchar**) &abort_slave_event_count,  (uchar**) &abort_slave_event_count,
3036
3189
   0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3190
  {"ansi", 'a', "Use ANSI SQL syntax instead of MySQL syntax. This mode will also set transaction isolation level 'serializable'.", 0, 0, 0,
 
3191
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3037
3192
  {"auto-increment-increment", OPT_AUTO_INCREMENT,
3038
 
   N_("Auto-increment columns are incremented by this"),
3039
 
   (char**) &global_system_variables.auto_increment_increment,
3040
 
   (char**) &max_system_variables.auto_increment_increment, 0, GET_ULONG,
 
3193
   "Auto-increment columns are incremented by this",
 
3194
   (uchar**) &global_system_variables.auto_increment_increment,
 
3195
   (uchar**) &max_system_variables.auto_increment_increment, 0, GET_ULONG,
3041
3196
   OPT_ARG, 1, 1, 65535, 0, 1, 0 },
3042
3197
  {"auto-increment-offset", OPT_AUTO_INCREMENT_OFFSET,
3043
 
   N_("Offset added to Auto-increment columns. Used when "
3044
 
      "auto-increment-increment != 1"),
3045
 
   (char**) &global_system_variables.auto_increment_offset,
3046
 
   (char**) &max_system_variables.auto_increment_offset, 0, GET_ULONG, OPT_ARG,
 
3198
   "Offset added to Auto-increment columns. Used when auto-increment-increment != 1",
 
3199
   (uchar**) &global_system_variables.auto_increment_offset,
 
3200
   (uchar**) &max_system_variables.auto_increment_offset, 0, GET_ULONG, OPT_ARG,
3047
3201
   1, 1, 65535, 0, 1, 0 },
3048
3202
  {"basedir", 'b',
3049
 
   N_("Path to installation directory. All paths are usually resolved "
3050
 
      "relative to this."),
3051
 
   (char**) &mysql_home_ptr, (char**) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,
 
3203
   "Path to installation directory. All paths are usually resolved relative to this.",
 
3204
   (uchar**) &mysql_home_ptr, (uchar**) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,
3052
3205
   0, 0, 0, 0, 0, 0},
3053
 
  {"bind-address", OPT_BIND_ADDRESS, N_("IP address to bind to."),
3054
 
   (char**) &my_bind_addr_str, (char**) &my_bind_addr_str, 0, GET_STR,
 
3206
  {"big-tables", OPT_BIG_TABLES,
 
3207
   "Allow big result sets by saving all temporary sets on file (Solves most 'table full' errors).",
 
3208
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3209
  {"bind-address", OPT_BIND_ADDRESS, "IP address to bind to.",
 
3210
   (uchar**) &my_bind_addr_str, (uchar**) &my_bind_addr_str, 0, GET_STR,
3055
3211
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3056
3212
  {"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. ")
3064
 
   ,(char**) &opt_binlog_format, (char**) &opt_binlog_format,
 
3213
   "Does not have any effect without '--log-bin'. "
 
3214
   "Tell the master the form of binary logging to use: either 'row' for "
 
3215
   "row-based binary logging, or 'statement' for statement-based binary "
 
3216
   "logging, or 'mixed'. 'mixed' is statement-based binary logging except "
 
3217
   "for those statements where only row-based is correct: those which "
 
3218
   "involve user-defined functions (i.e. UDFs) or the UUID() function; for "
 
3219
   "those, row-based binary logging is automatically used. "
 
3220
   ,(uchar**) &opt_binlog_format, (uchar**) &opt_binlog_format,
3065
3221
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3066
3222
  {"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."),
 
3223
   "Tells the master it should log updates for the specified database, and exclude all others not explicitly mentioned.",
3069
3224
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3070
3225
  {"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."),
 
3226
   "Tells the master that updates to the given database should not be logged tothe binary log.",
3073
3227
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3074
3228
  {"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,
 
3229
   "The maximum size of a row-based binary log event in bytes. Rows will be "
 
3230
   "grouped into events smaller than this size if possible. "
 
3231
   "The value has to be a multiple of 256.",
 
3232
   (uchar**) &opt_binlog_rows_event_max_size, 
 
3233
   (uchar**) &opt_binlog_rows_event_max_size, 0, 
 
3234
   GET_ULONG, REQUIRED_ARG, 
 
3235
   /* def_value */ 1024, /* min_value */  256, /* max_value */ ULONG_MAX, 
 
3236
   /* sub_size */     0, /* block_size */ 256, 
3083
3237
   /* app_type */ 0
3084
3238
  },
 
3239
#ifndef DISABLE_GRANT_OPTIONS
 
3240
  {"bootstrap", OPT_BOOTSTRAP, "Used by mysql installation scripts.", 0, 0, 0,
 
3241
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3242
#endif
3085
3243
  {"character-set-client-handshake", OPT_CHARACTER_SET_CLIENT_HANDSHAKE,
3086
 
   N_("Don't ignore client side character set value sent during handshake."),
3087
 
   (char**) &opt_character_set_client_handshake,
3088
 
   (char**) &opt_character_set_client_handshake,
 
3244
   "Don't ignore client side character set value sent during handshake.",
 
3245
   (uchar**) &opt_character_set_client_handshake,
 
3246
   (uchar**) &opt_character_set_client_handshake,
3089
3247
    0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
3090
3248
  {"character-set-filesystem", OPT_CHARACTER_SET_FILESYSTEM,
3091
 
   N_("Set the filesystem character set."),
3092
 
   (char**) &character_set_filesystem_name,
3093
 
   (char**) &character_set_filesystem_name,
 
3249
   "Set the filesystem character set.",
 
3250
   (uchar**) &character_set_filesystem_name,
 
3251
   (uchar**) &character_set_filesystem_name,
3094
3252
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3095
 
  {"character-set-server", 'C',
3096
 
   N_("Set the default character set."),
3097
 
   (char**) &default_character_set_name, (char**) &default_character_set_name,
 
3253
  {"character-set-server", 'C', "Set the default character set.",
 
3254
   (uchar**) &default_character_set_name, (uchar**) &default_character_set_name,
3098
3255
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3099
3256
  {"character-sets-dir", OPT_CHARSETS_DIR,
3100
 
   N_("Directory where character sets are."), (char**) &charsets_dir,
3101
 
   (char**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3102
 
  {"chroot", 'r',
3103
 
   N_("Chroot mysqld daemon during startup."),
3104
 
   (char**) &mysqld_chroot, (char**) &mysqld_chroot, 0, GET_STR, REQUIRED_ARG,
 
3257
   "Directory where character sets are.", (uchar**) &charsets_dir,
 
3258
   (uchar**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3259
  {"chroot", 'r', "Chroot mysqld daemon during startup.",
 
3260
   (uchar**) &mysqld_chroot, (uchar**) &mysqld_chroot, 0, GET_STR, REQUIRED_ARG,
3105
3261
   0, 0, 0, 0, 0, 0},
3106
 
  {"collation-server", OPT_DEFAULT_COLLATION,
3107
 
   N_("Set the default collation."),
3108
 
   (char**) &default_collation_name, (char**) &default_collation_name,
 
3262
  {"collation-server", OPT_DEFAULT_COLLATION, "Set the default collation.",
 
3263
   (uchar**) &default_collation_name, (uchar**) &default_collation_name,
3109
3264
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3110
 
  {"completion-type", OPT_COMPLETION_TYPE,
3111
 
   N_("Default completion type."),
3112
 
   (char**) &global_system_variables.completion_type,
3113
 
   (char**) &max_system_variables.completion_type, 0, GET_ULONG,
 
3265
  {"completion-type", OPT_COMPLETION_TYPE, "Default completion type.",
 
3266
   (uchar**) &global_system_variables.completion_type,
 
3267
   (uchar**) &max_system_variables.completion_type, 0, GET_ULONG,
3114
3268
   REQUIRED_ARG, 0, 0, 2, 0, 1, 0},
3115
 
  {"console", OPT_CONSOLE,
3116
 
   N_("Write error output on screen."),
3117
 
   (char**) &opt_console, (char**) &opt_console, 0, GET_BOOL, NO_ARG, 0, 0, 0,
 
3269
  {"console", OPT_CONSOLE, "Write error output on screen; Don't remove the console window on windows.",
 
3270
   (uchar**) &opt_console, (uchar**) &opt_console, 0, GET_BOOL, NO_ARG, 0, 0, 0,
3118
3271
   0, 0, 0},
3119
 
  {"core-file", OPT_WANT_CORE,
3120
 
   N_("Write core on errors."),
3121
 
   0, 0, 0, GET_NO_ARG,
 
3272
  {"core-file", OPT_WANT_CORE, "Write core on errors.", 0, 0, 0, GET_NO_ARG,
3122
3273
   NO_ARG, 0, 0, 0, 0, 0, 0},
3123
 
  {"datadir", 'h',
3124
 
   N_("Path to the database root."),
3125
 
   (char**) &mysql_data_home,
3126
 
   (char**) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3274
  {"datadir", 'h', "Path to the database root.", (uchar**) &mysql_data_home,
 
3275
   (uchar**) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3276
#ifndef DBUG_OFF
 
3277
  {"debug", '#', "Debug log.", (uchar**) &default_dbug_option,
 
3278
   (uchar**) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3279
#endif
 
3280
  {"default-character-set", 'C', "Set the default character set (deprecated option, use --character-set-server instead).",
 
3281
   (uchar**) &default_character_set_name, (uchar**) &default_character_set_name,
 
3282
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
 
3283
  {"default-collation", OPT_DEFAULT_COLLATION, "Set the default collation (deprecated option, use --collation-server instead).",
 
3284
   (uchar**) &default_collation_name, (uchar**) &default_collation_name,
 
3285
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3127
3286
  {"default-storage-engine", OPT_STORAGE_ENGINE,
3128
 
   N_("Set the default storage engine (table type) for tables."),
3129
 
   (char**)&default_storage_engine_str, (char**)&default_storage_engine_str,
3130
 
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3131
 
  {"default-time-zone", OPT_DEFAULT_TIME_ZONE,
3132
 
   N_("Set the default time zone."),
3133
 
   (char**) &default_tz_name, (char**) &default_tz_name,
 
3287
   "Set the default storage engine (table type) for tables.",
 
3288
   (uchar**)&default_storage_engine_str, (uchar**)&default_storage_engine_str,
 
3289
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3290
  {"default-table-type", OPT_STORAGE_ENGINE,
 
3291
   "(deprecated) Use --default-storage-engine.",
 
3292
   (uchar**)&default_storage_engine_str, (uchar**)&default_storage_engine_str,
 
3293
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3294
  {"default-time-zone", OPT_DEFAULT_TIME_ZONE, "Set the default time zone.",
 
3295
   (uchar**) &default_tz_name, (uchar**) &default_tz_name,
3134
3296
   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."),
 
3297
  {"delay-key-write", OPT_DELAY_KEY_WRITE, "Type of DELAY_KEY_WRITE.",
3137
3298
   0,0,0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3299
  {"delay-key-write-for-all-tables", OPT_DELAY_KEY_WRITE_ALL,
 
3300
   "Don't flush key buffers between writes for any MyISAM table (Deprecated option, use --delay-key-write=all instead).",
 
3301
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3138
3302
  {"disconnect-slave-event-count", OPT_DISCONNECT_SLAVE_EVENT_COUNT,
3139
 
   N_("Option used by mysql-test for debugging and testing of replication."),
3140
 
   (char**) &disconnect_slave_event_count,
3141
 
   (char**) &disconnect_slave_event_count, 0, GET_INT, REQUIRED_ARG, 0, 0, 0,
 
3303
   "Option used by mysql-test for debugging and testing of replication.",
 
3304
   (uchar**) &disconnect_slave_event_count,
 
3305
   (uchar**) &disconnect_slave_event_count, 0, GET_INT, REQUIRED_ARG, 0, 0, 0,
3142
3306
   0, 0, 0},
3143
3307
#ifdef HAVE_STACK_TRACE_ON_SEGV
3144
 
  {"enable-pstack", OPT_DO_PSTACK,
3145
 
   N_("Print a symbolic stack trace on failure."),
3146
 
   (char**) &opt_do_pstack, (char**) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
 
3308
  {"enable-pstack", OPT_DO_PSTACK, "Print a symbolic stack trace on failure.",
 
3309
   (uchar**) &opt_do_pstack, (uchar**) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
3147
3310
   0, 0, 0, 0},
3148
3311
#endif /* HAVE_STACK_TRACE_ON_SEGV */
3149
3312
  {"engine-condition-pushdown",
3150
3313
   OPT_ENGINE_CONDITION_PUSHDOWN,
3151
 
   N_("Push supported query conditions to the storage engine."),
3152
 
   (char**) &global_system_variables.engine_condition_pushdown,
3153
 
   (char**) &global_system_variables.engine_condition_pushdown,
 
3314
   "Push supported query conditions to the storage engine.",
 
3315
   (uchar**) &global_system_variables.engine_condition_pushdown,
 
3316
   (uchar**) &global_system_variables.engine_condition_pushdown,
3154
3317
   0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
3155
3318
  /* 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},
 
3319
  {"exit-info", 'T', "Used for debugging;  Use at your own risk!", 0, 0, 0,
 
3320
   GET_LONG, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3321
  {"flush", OPT_FLUSH, "Flush tables to disk between SQL commands.", 0, 0, 0,
 
3322
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3162
3323
  /* We must always support the next option to make scripts like mysqltest
3163
3324
     easier to do */
3164
3325
  {"gdb", OPT_DEBUGGING,
3165
 
   N_("Set up signals usable for debugging"),
3166
 
   (char**) &opt_debugging, (char**) &opt_debugging,
 
3326
   "Set up signals usable for debugging",
 
3327
   (uchar**) &opt_debugging, (uchar**) &opt_debugging,
3167
3328
   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"),
3170
 
   (char**) &opt_init_connect, (char**) &opt_init_connect, 0, GET_STR_ALLOC,
 
3329
  {"general-log", OPT_GENERAL_LOG,
 
3330
   "Enable|disable general log", (uchar**) &opt_log,
 
3331
   (uchar**) &opt_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3332
  {"init-connect", OPT_INIT_CONNECT, "Command(s) that are executed for each new connection",
 
3333
   (uchar**) &opt_init_connect, (uchar**) &opt_init_connect, 0, GET_STR_ALLOC,
3171
3334
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3172
 
  {"init-file", OPT_INIT_FILE,
3173
 
   N_("Read SQL commands from this file at startup."),
3174
 
   (char**) &opt_init_file, (char**) &opt_init_file, 0, GET_STR, REQUIRED_ARG,
 
3335
  {"init-file", OPT_INIT_FILE, "Read SQL commands from this file at startup.",
 
3336
   (uchar**) &opt_init_file, (uchar**) &opt_init_file, 0, GET_STR, REQUIRED_ARG,
3175
3337
   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"),
3178
 
   (char**) &opt_init_slave, (char**) &opt_init_slave, 0, GET_STR_ALLOC,
 
3338
  {"init-slave", OPT_INIT_SLAVE, "Command(s) that are executed when a slave connects to this master",
 
3339
   (uchar**) &opt_init_slave, (uchar**) &opt_init_slave, 0, GET_STR_ALLOC,
3179
3340
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3180
3341
  {"language", 'L',
3181
 
   N_("(IGNORED)"),
3182
 
   (char**) &language_ptr, (char**) &language_ptr, 0, GET_STR, REQUIRED_ARG,
 
3342
   "Client error messages in given language. May be given as a full path.",
 
3343
   (uchar**) &language_ptr, (uchar**) &language_ptr, 0, GET_STR, REQUIRED_ARG,
3183
3344
   0, 0, 0, 0, 0, 0},
3184
3345
  {"lc-time-names", OPT_LC_TIME_NAMES,
3185
 
   N_("Set the language used for the month names and the days of the week."),
3186
 
   (char**) &lc_time_names_name,
3187
 
   (char**) &lc_time_names_name,
 
3346
   "Set the language used for the month names and the days of the week.",
 
3347
   (uchar**) &lc_time_names_name,
 
3348
   (uchar**) &lc_time_names_name,
3188
3349
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3189
3350
  {"local-infile", OPT_LOCAL_INFILE,
3190
 
   N_("Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0)."),
3191
 
   (char**) &opt_local_infile,
3192
 
   (char**) &opt_local_infile, 0, GET_BOOL, OPT_ARG,
 
3351
   "Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0).",
 
3352
   (uchar**) &opt_local_infile,
 
3353
   (uchar**) &opt_local_infile, 0, GET_BOOL, OPT_ARG,
3193
3354
   1, 0, 0, 0, 0, 0},
3194
 
  {"log", 'l',
3195
 
   N_("Log connections and queries to file."),
3196
 
   (char**) &opt_logname,
3197
 
   (char**) &opt_logname, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3355
  {"log", 'l', "Log connections and queries to file.", (uchar**) &opt_logname,
 
3356
   (uchar**) &opt_logname, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
3198
3357
  {"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)"),
3203
 
   (char**) &opt_bin_logname, (char**) &opt_bin_logname, 0, GET_STR_ALLOC,
 
3358
   "Log update queries in binary format. Optional (but strongly recommended "
 
3359
   "to avoid replication problems if server's hostname changes) argument "
 
3360
   "should be the chosen location for the binary log files.",
 
3361
   (uchar**) &opt_bin_logname, (uchar**) &opt_bin_logname, 0, GET_STR_ALLOC,
3204
3362
   OPT_ARG, 0, 0, 0, 0, 0, 0},
3205
3363
  {"log-bin-index", OPT_BIN_LOG_INDEX,
3206
 
   N_("File that holds the names for last binary log files."),
3207
 
   (char**) &opt_binlog_index_name, (char**) &opt_binlog_index_name, 0, GET_STR,
 
3364
   "File that holds the names for last binary log files.",
 
3365
   (uchar**) &opt_binlog_index_name, (uchar**) &opt_binlog_index_name, 0, GET_STR,
3208
3366
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3209
 
  {"log-error", OPT_ERROR_LOG_FILE,
3210
 
   N_("Error log file."),
3211
 
   (char**) &log_error_file_ptr, (char**) &log_error_file_ptr, 0, GET_STR,
3212
 
   OPT_ARG, 0, 0, 0, 0, 0, 0},
3213
 
  {"log-isam", OPT_ISAM_LOG,
3214
 
   N_("Log all MyISAM changes to file."),
3215
 
   (char**) &myisam_log_filename, (char**) &myisam_log_filename, 0, GET_STR,
3216
 
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3367
  /*
 
3368
    This option starts with "log-bin" to emphasize that it is specific of
 
3369
    binary logging.
 
3370
  */
 
3371
  {"log-bin-trust-function-creators", OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
 
3372
   "If equal to 0 (the default), then when --log-bin is used, creation of "
 
3373
   "a stored function (or trigger) is allowed only to users having the SUPER privilege "
 
3374
   "and only if this stored function (trigger) may not break binary logging."
 
3375
   "Note that if ALL connections to this server ALWAYS use row-based binary "
 
3376
   "logging, the security issues do not exist and the binary logging cannot "
 
3377
   "break, so you can safely set this to 1."
 
3378
   ,(uchar**) &trust_function_creators, (uchar**) &trust_function_creators, 0,
 
3379
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3380
  {"log-error", OPT_ERROR_LOG_FILE, "Error log file.",
 
3381
   (uchar**) &log_error_file_ptr, (uchar**) &log_error_file_ptr, 0, GET_STR,
 
3382
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3383
  {"log-isam", OPT_ISAM_LOG, "Log all MyISAM changes to file.",
 
3384
   (uchar**) &myisam_log_filename, (uchar**) &myisam_log_filename, 0, GET_STR,
 
3385
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3386
  {"log-long-format", '0',
 
3387
   "Log some extra information to update log. Please note that this option is deprecated; see --log-short-format option.", 
 
3388
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3389
#ifdef WITH_CSV_STORAGE_ENGINE
 
3390
  {"log-output", OPT_LOG_OUTPUT,
 
3391
   "Syntax: log-output[=value[,value...]], where \"value\" could be TABLE, "
 
3392
   "FILE or NONE.",
 
3393
   (uchar**) &log_output_str, (uchar**) &log_output_str, 0,
 
3394
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3395
#endif
 
3396
  {"log-queries-not-using-indexes", OPT_LOG_QUERIES_NOT_USING_INDEXES,
 
3397
   "Log queries that are executed without benefit of any index to the slow log if it is open.",
 
3398
   (uchar**) &opt_log_queries_not_using_indexes, (uchar**) &opt_log_queries_not_using_indexes,
 
3399
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3400
  {"log-short-format", OPT_SHORT_LOG_FORMAT,
 
3401
   "Don't log extra information to update and slow-query logs.",
 
3402
   (uchar**) &opt_short_log_format, (uchar**) &opt_short_log_format,
 
3403
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3217
3404
  {"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,
 
3405
   "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.",
 
3406
   (uchar**) &opt_log_slave_updates, (uchar**) &opt_log_slave_updates, 0, GET_BOOL,
3223
3407
   NO_ARG, 0, 0, 0, 0, 0, 0},
 
3408
  {"log-slow-admin-statements", OPT_LOG_SLOW_ADMIN_STATEMENTS,
 
3409
   "Log slow OPTIMIZE, ANALYZE, ALTER and other administrative statements to the slow log if it is open.",
 
3410
   (uchar**) &opt_log_slow_admin_statements,
 
3411
   (uchar**) &opt_log_slow_admin_statements,
 
3412
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3413
 {"log-slow-slave-statements", OPT_LOG_SLOW_SLAVE_STATEMENTS,
 
3414
  "Log slow statements executed by slave thread to the slow log if it is open.",
 
3415
  (uchar**) &opt_log_slow_slave_statements,
 
3416
  (uchar**) &opt_log_slow_slave_statements,
 
3417
  0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3418
  {"log-slow-queries", OPT_SLOW_QUERY_LOG,
 
3419
    "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.",
 
3420
   (uchar**) &opt_slow_logname, (uchar**) &opt_slow_logname, 0, GET_STR, OPT_ARG,
 
3421
   0, 0, 0, 0, 0, 0},
3224
3422
  {"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)"),
3227
 
   (char**) &opt_tc_log_file, (char**) &opt_tc_log_file, 0, GET_STR,
 
3423
   "Path to transaction coordinator log (used for transactions that affect "
 
3424
   "more than one storage engine, when binary log is disabled)",
 
3425
   (uchar**) &opt_tc_log_file, (uchar**) &opt_tc_log_file, 0, GET_STR,
3228
3426
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3229
3427
#ifdef HAVE_MMAP
3230
 
  {"log-tc-size", OPT_LOG_TC_SIZE,
3231
 
   N_("Size of transaction coordinator log."),
3232
 
   (char**) &opt_tc_log_size, (char**) &opt_tc_log_size, 0, GET_ULONG,
 
3428
  {"log-tc-size", OPT_LOG_TC_SIZE, "Size of transaction coordinator log.",
 
3429
   (uchar**) &opt_tc_log_size, (uchar**) &opt_tc_log_size, 0, GET_ULONG,
3233
3430
   REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, ULONG_MAX, 0,
3234
3431
   TC_LOG_PAGE_SIZE, 0},
3235
3432
#endif
3236
 
  {"log-warnings", 'W',
3237
 
   N_("Log some not critical warnings to the log file."),
3238
 
   (char**) &global_system_variables.log_warnings,
3239
 
   (char**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, 0,
 
3433
  {"log-warnings", 'W', "Log some not critical warnings to the log file.",
 
3434
   (uchar**) &global_system_variables.log_warnings,
 
3435
   (uchar**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, 0,
3240
3436
   0, 0, 0},
3241
3437
  {"low-priority-updates", OPT_LOW_PRIORITY_UPDATES,
3242
 
   N_("INSERT/DELETE/UPDATE has lower priority than selects."),
3243
 
   (char**) &global_system_variables.low_priority_updates,
3244
 
   (char**) &max_system_variables.low_priority_updates,
 
3438
   "INSERT/DELETE/UPDATE has lower priority than selects.",
 
3439
   (uchar**) &global_system_variables.low_priority_updates,
 
3440
   (uchar**) &max_system_variables.low_priority_updates,
3245
3441
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3246
3442
  {"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."),
3249
 
   (char**) &master_info_file, (char**) &master_info_file, 0, GET_STR,
 
3443
   "The location and name of the file that remembers the master and where the I/O replication \
 
3444
thread is in the master's binlogs.",
 
3445
   (uchar**) &master_info_file, (uchar**) &master_info_file, 0, GET_STR,
3250
3446
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3251
3447
  {"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."),
3254
 
   (char**) &master_retry_count, (char**) &master_retry_count, 0, GET_ULONG,
 
3448
   "The number of tries the slave will make to connect to the master before giving up.",
 
3449
   (uchar**) &master_retry_count, (uchar**) &master_retry_count, 0, GET_ULONG,
3255
3450
   REQUIRED_ARG, 3600*24, 0, 0, 0, 0, 0},
3256
3451
  {"max-binlog-dump-events", OPT_MAX_BINLOG_DUMP_EVENTS,
3257
 
   N_("Option used by mysql-test for debugging and testing of replication."),
3258
 
   (char**) &max_binlog_dump_events, (char**) &max_binlog_dump_events, 0,
 
3452
   "Option used by mysql-test for debugging and testing of replication.",
 
3453
   (uchar**) &max_binlog_dump_events, (uchar**) &max_binlog_dump_events, 0,
3259
3454
   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,
3263
 
   (char**) &locked_in_memory, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3455
  {"memlock", OPT_MEMLOCK, "Lock mysqld in memory.", (uchar**) &locked_in_memory,
 
3456
   (uchar**) &locked_in_memory, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3264
3457
  {"myisam-recover", OPT_MYISAM_RECOVER,
3265
 
   N_("Syntax: myisam-recover[=option[,option...]], where option can be "
3266
 
      "DEFAULT, BACKUP, FORCE or QUICK."),
3267
 
   (char**) &myisam_recover_options_str, (char**) &myisam_recover_options_str, 0,
 
3458
   "Syntax: myisam-recover[=option[,option...]], where option can be DEFAULT, BACKUP, FORCE or QUICK.",
 
3459
   (uchar**) &myisam_recover_options_str, (uchar**) &myisam_recover_options_str, 0,
3268
3460
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
3269
 
  {"new", 'n',
3270
 
   N_("Use very new possible 'unsafe' functions."),
3271
 
   (char**) &global_system_variables.new_mode,
3272
 
   (char**) &max_system_variables.new_mode,
 
3461
  {"new", 'n', "Use very new possible 'unsafe' functions.",
 
3462
   (uchar**) &global_system_variables.new_mode,
 
3463
   (uchar**) &max_system_variables.new_mode,
3273
3464
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3274
3465
  {"old-alter-table", OPT_OLD_ALTER_TABLE,
3275
 
   N_("Use old, non-optimized alter table."),
3276
 
   (char**) &global_system_variables.old_alter_table,
3277
 
   (char**) &max_system_variables.old_alter_table, 0, GET_BOOL, NO_ARG,
3278
 
   0, 0, 0, 0, 0, 0},
3279
 
  {"pid-file", OPT_PID_FILE,
3280
 
   N_("Pid file used by safe_mysqld."),
3281
 
   (char**) &pidfile_name_ptr, (char**) &pidfile_name_ptr, 0, GET_STR,
 
3466
   "Use old, non-optimized alter table.",
 
3467
   (uchar**) &global_system_variables.old_alter_table,
 
3468
   (uchar**) &max_system_variables.old_alter_table, 0, GET_BOOL, NO_ARG,
 
3469
   0, 0, 0, 0, 0, 0},
 
3470
  {"old-passwords", OPT_OLD_PASSWORDS, "Use old password encryption method (needed for 4.0 and older clients).",
 
3471
   (uchar**) &global_system_variables.old_passwords,
 
3472
   (uchar**) &max_system_variables.old_passwords, 0, GET_BOOL, NO_ARG,
 
3473
   0, 0, 0, 0, 0, 0},
 
3474
  {"old-style-user-limits", OPT_OLD_STYLE_USER_LIMITS,
 
3475
   "Enable old-style user limits (before 5.0.3 user resources were counted per each user+host vs. per account)",
 
3476
   (uchar**) &opt_old_style_user_limits, (uchar**) &opt_old_style_user_limits,
 
3477
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3478
  {"pid-file", OPT_PID_FILE, "Pid file used by safe_mysqld.",
 
3479
   (uchar**) &pidfile_name_ptr, (uchar**) &pidfile_name_ptr, 0, GET_STR,
3282
3480
   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) ")."),
3287
 
   (char**) &mysqld_port,
3288
 
   (char**) &mysqld_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3481
  {"port", 'P', "Port number to use for connection or 0 for default to, in "
 
3482
   "order of preference, my.cnf, $MYSQL_TCP_PORT, "
 
3483
#if MYSQL_PORT_DEFAULT == 0
 
3484
   "/etc/services, "
 
3485
#endif
 
3486
   "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",
 
3487
   (uchar**) &mysqld_port,
 
3488
   (uchar**) &mysqld_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3289
3489
  {"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,
3293
 
   (char**) &mysqld_port_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3490
   "Maximum time in seconds to wait for the port to become free. "
 
3491
   "(Default: no wait)", (uchar**) &mysqld_port_timeout,
 
3492
   (uchar**) &mysqld_port_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3294
3493
  {"relay-log", OPT_RELAY_LOG,
3295
 
   N_("The location and name to use for relay logs."),
3296
 
   (char**) &opt_relay_logname, (char**) &opt_relay_logname, 0,
 
3494
   "The location and name to use for relay logs.",
 
3495
   (uchar**) &opt_relay_logname, (uchar**) &opt_relay_logname, 0,
3297
3496
   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3298
3497
  {"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."),
3301
 
   (char**) &opt_relaylog_index_name, (char**) &opt_relaylog_index_name, 0,
 
3498
   "The location and name to use for the file that keeps a list of the last \
 
3499
relay logs.",
 
3500
   (uchar**) &opt_relaylog_index_name, (uchar**) &opt_relaylog_index_name, 0,
3302
3501
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3303
3502
  {"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."),
3306
 
   (char**) &relay_log_info_file, (char**) &relay_log_info_file, 0, GET_STR,
 
3503
   "The location and name of the file that remembers where the SQL replication \
 
3504
thread is in the relay logs.",
 
3505
   (uchar**) &relay_log_info_file, (uchar**) &relay_log_info_file, 0, GET_STR,
3307
3506
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3308
3507
  {"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.%."),
 
3508
   "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
3509
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3317
3510
  {"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."),
 
3511
   "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
3512
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3323
3513
  {"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.%. "),
 
3514
   "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
3515
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3330
3516
  {"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."),
 
3517
   "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
3518
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3336
3519
  {"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."),
 
3520
   "Updates to a database with a different name than the original. Example: replicate-rewrite-db=master_db_name->slave_db_name.",
3339
3521
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3340
3522
  {"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."),
3344
 
   (char**) &replicate_same_server_id,
3345
 
   (char**) &replicate_same_server_id,
 
3523
   "In replication, if set to 1, do not skip events having our server id. \
 
3524
Default value is 0 (to break infinite loops in circular replication). \
 
3525
Can't be set to 1 if --log-slave-updates is used.",
 
3526
   (uchar**) &replicate_same_server_id,
 
3527
   (uchar**) &replicate_same_server_id,
3346
3528
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3347
3529
  {"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."),
 
3530
   "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
3531
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3355
3532
  {"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."),
 
3533
   "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
3534
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3363
3535
  // In replication, we may need to tell the other servers how to connect
3364
3536
  {"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."),
3372
 
   (char**) &report_host, (char**) &report_host, 0, GET_STR, REQUIRED_ARG, 0, 0,
 
3537
   "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.",
 
3538
   (uchar**) &report_host, (uchar**) &report_host, 0, GET_STR, REQUIRED_ARG, 0, 0,
3373
3539
   0, 0, 0, 0},
3374
3540
  {"report-password", OPT_REPORT_PASSWORD, "Undocumented.",
3375
 
   (char**) &report_password, (char**) &report_password, 0, GET_STR,
 
3541
   (uchar**) &report_password, (uchar**) &report_password, 0, GET_STR,
3376
3542
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3377
3543
  {"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."),
3382
 
   (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)."),
 
3544
   "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.",
 
3545
   (uchar**) &report_port, (uchar**) &report_port, 0, GET_UINT, REQUIRED_ARG,
 
3546
   MYSQL_PORT, 0, 0, 0, 0, 0},
 
3547
  {"safe-mode", OPT_SAFE, "Skip some optimize stages (for testing).",
3386
3548
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3387
3549
  {"secure-file-priv", OPT_SECURE_FILE_PRIV,
3388
 
   N_("Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files "
3389
 
      "within specified directory"),
3390
 
   (char**) &opt_secure_file_priv, (char**) &opt_secure_file_priv, 0,
 
3550
   "Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files within specified directory",
 
3551
   (uchar**) &opt_secure_file_priv, (uchar**) &opt_secure_file_priv, 0,
3391
3552
   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3392
3553
  {"server-id", OPT_SERVER_ID,
3393
 
   N_("Uniquely identifies the server instance in the community of "
3394
 
      "replication partners."),
3395
 
   (char**) &server_id, (char**) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,
 
3554
   "Uniquely identifies the server instance in the community of replication partners.",
 
3555
   (uchar**) &server_id, (uchar**) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,
3396
3556
   0, 0, 0},
3397
 
  {"skip-new", OPT_SKIP_NEW,
3398
 
   N_("Don't use new, possible wrong routines."),
 
3557
  {"set-variable", 'O',
 
3558
   "Change the value of a variable. Please note that this option is deprecated;you can set variables directly with --variable-name=value.",
 
3559
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3560
  {"skip-new", OPT_SKIP_NEW, "Don't use new, possible wrong routines.",
3399
3561
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3400
3562
  {"skip-slave-start", OPT_SKIP_SLAVE_START,
3401
 
   N_("If set, slave is not autostarted."),
3402
 
   (char**) &opt_skip_slave_start,
3403
 
   (char**) &opt_skip_slave_start, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3563
   "If set, slave is not autostarted.", (uchar**) &opt_skip_slave_start,
 
3564
   (uchar**) &opt_skip_slave_start, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3404
3565
  {"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,
 
3566
   "Don't print a stack trace on failure.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
3407
3567
   0, 0, 0, 0},
 
3568
  {"skip-symlink", OPT_SKIP_SYMLINKS, "Don't allow symlinking of tables. Deprecated option.  Use --skip-symbolic-links instead.",
 
3569
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3408
3570
  {"skip-thread-priority", OPT_SKIP_PRIOR,
3409
 
   N_("Don't give threads different priorities."),
3410
 
   0, 0, 0, GET_NO_ARG, NO_ARG,
 
3571
   "Don't give threads different priorities.", 0, 0, 0, GET_NO_ARG, NO_ARG,
3411
3572
   DEFAULT_SKIP_THREAD_PRIORITY, 0, 0, 0, 0, 0},
3412
3573
  {"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."),
3415
 
   (char**) &slave_load_tmpdir, (char**) &slave_load_tmpdir, 0, GET_STR_ALLOC,
 
3574
   "The location where the slave should put its temporary files when \
 
3575
replicating a LOAD DATA INFILE command.",
 
3576
   (uchar**) &slave_load_tmpdir, (uchar**) &slave_load_tmpdir, 0, GET_STR_ALLOC,
3416
3577
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3417
3578
  {"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."),
 
3579
   "Tells the slave thread to continue replication when a query event returns an error from the provided list.",
3420
3580
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3421
3581
  {"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},
 
3582
   "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.",
 
3583
   (uchar**) &slave_exec_mode_str, (uchar**) &slave_exec_mode_str, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3584
  {"slow-query-log", OPT_SLOW_LOG,
 
3585
   "Enable|disable slow query log", (uchar**) &opt_slow_log,
 
3586
   (uchar**) &opt_slow_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3587
  {"sporadic-binlog-dump-fail", OPT_SPORADIC_BINLOG_DUMP_FAIL,
 
3588
   "Option used by mysql-test for debugging and testing of replication.",
 
3589
   (uchar**) &opt_sporadic_binlog_dump_fail,
 
3590
   (uchar**) &opt_sporadic_binlog_dump_fail, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,
 
3591
   0},
3429
3592
  {"sql-bin-update-same", OPT_SQL_BIN_UPDATE_SAME,
3430
 
   N_("(INGORED)"),
 
3593
   "The update log is deprecated since version 5.0, is replaced by the binary \
 
3594
log and this option does nothing anymore.",
3431
3595
   0, 0, 0, GET_DISABLED, NO_ARG, 0, 0, 0, 0, 0, 0},
3432
 
  {"symbolic-links", 's',
3433
 
   N_("Enable symbolic link support."),
3434
 
   (char**) &my_use_symdir, (char**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
 
3596
  {"symbolic-links", 's', "Enable symbolic link support.",
 
3597
   (uchar**) &my_use_symdir, (uchar**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
3435
3598
   /*
3436
3599
     The system call realpath() produces warnings under valgrind and
3437
3600
     purify. These are not suppressed: instead we disable symlinks
3439
3602
   */
3440
3603
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
3441
3604
  {"sysdate-is-now", OPT_SYSDATE_IS_NOW,
3442
 
   N_("Non-default option to alias SYSDATE() to NOW() to make it "
3443
 
      "safe-replicable."),
3444
 
   (char**) &global_system_variables.sysdate_is_now,
 
3605
   "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.",
 
3606
   (uchar**) &global_system_variables.sysdate_is_now,
3445
3607
   0, 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3446
3608
  {"tc-heuristic-recover", OPT_TC_HEURISTIC_RECOVER,
3447
 
   N_("Decision to use in heuristic recover process. Possible values are "
3448
 
      "COMMIT or ROLLBACK."),
3449
 
   (char**) &opt_tc_heuristic_recover, (char**) &opt_tc_heuristic_recover,
 
3609
   "Decision to use in heuristic recover process. Possible values are COMMIT or ROLLBACK.",
 
3610
   (uchar**) &opt_tc_heuristic_recover, (uchar**) &opt_tc_heuristic_recover,
3450
3611
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3451
3612
  {"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."),
3454
 
   (char**) &use_temp_pool, (char**) &use_temp_pool, 0, GET_BOOL, NO_ARG, 1,
 
3613
   "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.",
 
3614
   (uchar**) &use_temp_pool, (uchar**) &use_temp_pool, 0, GET_BOOL, NO_ARG, 1,
3455
3615
   0, 0, 0, 0, 0},
3456
3616
  {"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,
 
3617
   "Specify whether to time mutexes (only InnoDB mutexes are currently supported)",
 
3618
   (uchar**) &timed_mutexes, (uchar**) &timed_mutexes, 0, GET_BOOL, NO_ARG, 0, 
3460
3619
    0, 0, 0, 0, 0},
3461
3620
  {"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."),
3465
 
   (char**) &opt_mysql_tmpdir,
3466
 
   (char**) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3621
   "Path for temporary files. Several paths may be specified, separated by a "
 
3622
   "colon (:)"
 
3623
   ", in this case they are used in a round-robin fashion.",
 
3624
   (uchar**) &opt_mysql_tmpdir,
 
3625
   (uchar**) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3467
3626
  {"transaction-isolation", OPT_TX_ISOLATION,
3468
 
   N_("Default transaction isolation level."),
3469
 
   0, 0, 0, GET_STR, REQUIRED_ARG, 0,
 
3627
   "Default transaction isolation level.", 0, 0, 0, GET_STR, REQUIRED_ARG, 0,
3470
3628
   0, 0, 0, 0, 0},
3471
 
  {"user", 'u',
3472
 
   N_("Run mysqld daemon as user."),
3473
 
   0, 0, 0, GET_STR, REQUIRED_ARG,
 
3629
  {"use-symbolic-links", 's', "Enable symbolic link support. Deprecated option; use --symbolic-links instead.",
 
3630
   (uchar**) &my_use_symdir, (uchar**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
 
3631
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
 
3632
  {"user", 'u', "Run mysqld daemon as user.", 0, 0, 0, GET_STR, REQUIRED_ARG,
3474
3633
   0, 0, 0, 0, 0, 0},
3475
 
  {"version", 'V',
3476
 
   N_("Output version information and exit."),
3477
 
   0, 0, 0, GET_NO_ARG,
 
3634
  {"verbose", 'v', "Used with --help option for detailed help",
 
3635
   (uchar**) &opt_verbose, (uchar**) &opt_verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
3636
   0, 0},
 
3637
  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,
3478
3638
   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."),
3483
 
    (char**) &back_log, (char**) &back_log, 0, GET_ULONG,
 
3639
  {"warnings", 'W', "Deprecated; use --log-warnings instead.",
 
3640
   (uchar**) &global_system_variables.log_warnings,
 
3641
   (uchar**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG,
 
3642
   1, 0, ULONG_MAX, 0, 0, 0},
 
3643
  { "back_log", OPT_BACK_LOG,
 
3644
    "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.",
 
3645
    (uchar**) &back_log, (uchar**) &back_log, 0, GET_ULONG,
3484
3646
    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'."),
3500
 
    (char**) &connect_timeout, (char**) &connect_timeout,
3501
 
    0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
 
3647
  {"binlog_cache_size", OPT_BINLOG_CACHE_SIZE,
 
3648
   "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.",
 
3649
   (uchar**) &binlog_cache_size, (uchar**) &binlog_cache_size, 0, GET_ULONG,
 
3650
   REQUIRED_ARG, 32*1024L, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},
 
3651
  {"bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,
 
3652
   "Size of tree cache used in bulk insert optimisation. Note that this is a limit per thread!",
 
3653
   (uchar**) &global_system_variables.bulk_insert_buff_size,
 
3654
   (uchar**) &max_system_variables.bulk_insert_buff_size,
 
3655
   0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, ULONG_MAX, 0, 1, 0},
 
3656
  {"connect_timeout", OPT_CONNECT_TIMEOUT,
 
3657
   "The number of seconds the mysqld server is waiting for a connect packet before responding with 'Bad handshake'.",
 
3658
    (uchar**) &connect_timeout, (uchar**) &connect_timeout,
 
3659
   0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
3502
3660
  { "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],
 
3661
    "The DATE format (For future).",
 
3662
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
 
3663
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
3506
3664
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3507
3665
  { "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],
 
3666
    "The DATETIME/TIMESTAMP format (for future).",
 
3667
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
 
3668
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
3511
3669
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3512
3670
  { "default_week_format", OPT_DEFAULT_WEEK_FORMAT,
3513
 
    N_("The default week format used by WEEK() functions."),
3514
 
    (char**) &global_system_variables.default_week_format,
3515
 
    (char**) &max_system_variables.default_week_format,
 
3671
    "The default week format used by WEEK() functions.",
 
3672
    (uchar**) &global_system_variables.default_week_format,
 
3673
    (uchar**) &max_system_variables.default_week_format,
3516
3674
    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."),
3520
 
   (char**) &global_system_variables.div_precincrement,
3521
 
   (char**) &max_system_variables.div_precincrement, 0, GET_ULONG,
 
3675
  {"div_precision_increment", OPT_DIV_PRECINCREMENT,
 
3676
   "Precision of the result of '/' operator will be increased on that value.",
 
3677
   (uchar**) &global_system_variables.div_precincrement,
 
3678
   (uchar**) &max_system_variables.div_precincrement, 0, GET_ULONG,
3522
3679
   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},
 
3680
  {"expire_logs_days", OPT_EXPIRE_LOGS_DAYS,
 
3681
   "If non-zero, binary logs will be purged after expire_logs_days "
 
3682
   "days; possible purges happen at startup and at binary log rotation.",
 
3683
   (uchar**) &expire_logs_days,
 
3684
   (uchar**) &expire_logs_days, 0, GET_ULONG,
 
3685
   REQUIRED_ARG, 0, 0, 99, 0, 1, 0},
 
3686
  { "flush_time", OPT_FLUSH_TIME,
 
3687
    "A dedicated thread is created to flush all tables at the given interval.",
 
3688
    (uchar**) &flush_time, (uchar**) &flush_time, 0, GET_ULONG, REQUIRED_ARG,
 
3689
    FLUSH_TIME, 0, LONG_TIMEOUT, 0, 1, 0},
3529
3690
  { "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,
3530
 
    N_("The maximum length of the result of function  group_concat."),
3531
 
    (char**) &global_system_variables.group_concat_max_len,
3532
 
    (char**) &max_system_variables.group_concat_max_len, 0, GET_ULONG,
 
3691
    "The maximum length of the result of function  group_concat.",
 
3692
    (uchar**) &global_system_variables.group_concat_max_len,
 
3693
    (uchar**) &max_system_variables.group_concat_max_len, 0, GET_ULONG,
3533
3694
    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."),
3537
 
   (char**) &global_system_variables.net_interactive_timeout,
3538
 
   (char**) &max_system_variables.net_interactive_timeout, 0,
 
3695
  {"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
 
3696
   "The number of seconds the server waits for activity on an interactive connection before closing it.",
 
3697
   (uchar**) &global_system_variables.net_interactive_timeout,
 
3698
   (uchar**) &max_system_variables.net_interactive_timeout, 0,
3539
3699
   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."),
3542
 
   (char**) &global_system_variables.join_buff_size,
3543
 
   (char**) &max_system_variables.join_buff_size, 0, GET_ULONG,
 
3700
  {"join_buffer_size", OPT_JOIN_BUFF_SIZE,
 
3701
   "The size of the buffer that is used for full joins.",
 
3702
   (uchar**) &global_system_variables.join_buff_size,
 
3703
   (uchar**) &max_system_variables.join_buff_size, 0, GET_ULONG,
3544
3704
   REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ULONG_MAX,
3545
3705
   MALLOC_OVERHEAD, IO_SIZE, 0},
3546
3706
  {"keep_files_on_create", OPT_KEEP_FILES_ON_CREATE,
3547
 
   N_("Don't overwrite stale .MYD and .MYI even if no directory is specified."),
3548
 
   (char**) &global_system_variables.keep_files_on_create,
3549
 
   (char**) &max_system_variables.keep_files_on_create,
 
3707
   "Don't overwrite stale .MYD and .MYI even if no directory is specified.",
 
3708
   (uchar**) &global_system_variables.keep_files_on_create,
 
3709
   (uchar**) &max_system_variables.keep_files_on_create,
3550
3710
   0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
3551
3711
  {"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;"),
3555
 
   (char**) &dflt_key_cache_var.param_buff_size,
3556
 
   (char**) 0,
 
3712
   "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.",
 
3713
   (uchar**) &dflt_key_cache_var.param_buff_size,
 
3714
   (uchar**) 0,
3557
3715
   0, (GET_ULL | GET_ASK_ADDR),
3558
3716
   REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, SIZE_T_MAX, MALLOC_OVERHEAD,
3559
3717
   IO_SIZE, 0},
3560
3718
  {"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"),
3565
 
   (char**) &dflt_key_cache_var.param_age_threshold,
3566
 
   (char**) 0,
3567
 
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
 
3719
   "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",
 
3720
   (uchar**) &dflt_key_cache_var.param_age_threshold,
 
3721
   (uchar**) 0,
 
3722
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG, 
3568
3723
   300, 100, ULONG_MAX, 0, 100, 0},
3569
3724
  {"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,
3570
 
   N_("The default size of key cache blocks"),
3571
 
   (char**) &dflt_key_cache_var.param_block_size,
3572
 
   (char**) 0,
 
3725
   "The default size of key cache blocks",
 
3726
   (uchar**) &dflt_key_cache_var.param_block_size,
 
3727
   (uchar**) 0,
3573
3728
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
3574
3729
   KEY_CACHE_BLOCK_SIZE, 512, 1024 * 16, 0, 512, 0},
3575
3730
  {"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,
3576
 
   N_("The minimum percentage of warm blocks in key cache"),
3577
 
   (char**) &dflt_key_cache_var.param_division_limit,
3578
 
   (char**) 0,
 
3731
   "The minimum percentage of warm blocks in key cache",
 
3732
   (uchar**) &dflt_key_cache_var.param_division_limit,
 
3733
   (uchar**) 0,
3579
3734
   0, (GET_ULONG | GET_ASK_ADDR) , REQUIRED_ARG, 100,
3580
3735
   1, 100, 0, 1, 0},
3581
3736
  {"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."),
3585
 
   (char**) &long_query_time, (char**) &long_query_time, 0, GET_DOUBLE,
 
3737
   "Log all queries that have taken more than long_query_time seconds to execute to file. "
 
3738
   "The argument will be treated as a decimal value with microsecond precission.",
 
3739
   (uchar**) &long_query_time, (uchar**) &long_query_time, 0, GET_DOUBLE,
3586
3740
   REQUIRED_ARG, 10, 0, LONG_TIMEOUT, 0, 0, 0},
 
3741
  {"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,
 
3742
   "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",
 
3743
   (uchar**) &lower_case_table_names,
 
3744
   (uchar**) &lower_case_table_names, 0, GET_UINT, OPT_ARG,
 
3745
#ifdef FN_NO_CASE_SENCE
 
3746
    1
 
3747
#else
 
3748
    0
 
3749
#endif
 
3750
   , 0, 2, 0, 1, 0},
3587
3751
  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
3588
 
   N_("Max packetlength to send/receive from to server."),
3589
 
   (char**) &global_system_variables.max_allowed_packet,
3590
 
   (char**) &max_system_variables.max_allowed_packet, 0, GET_ULONG,
 
3752
   "Max packetlength to send/receive from to server.",
 
3753
   (uchar**) &global_system_variables.max_allowed_packet,
 
3754
   (uchar**) &max_system_variables.max_allowed_packet, 0, GET_ULONG,
3591
3755
   REQUIRED_ARG, 1024*1024L, 1024, 1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},
3592
3756
  {"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."),
3595
 
   (char**) &max_binlog_cache_size, (char**) &max_binlog_cache_size, 0,
 
3757
   "Can be used to restrict the total size used to cache a multi-transaction query.",
 
3758
   (uchar**) &max_binlog_cache_size, (uchar**) &max_binlog_cache_size, 0,
3596
3759
   GET_ULONG, REQUIRED_ARG, ULONG_MAX, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},
3597
3760
  {"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."),
3601
 
   (char**) &max_binlog_size, (char**) &max_binlog_size, 0, GET_ULONG,
 
3761
   "Binary log will be rotated automatically when the size exceeds this \
 
3762
value. Will also apply to relay logs if max_relay_log_size is 0. \
 
3763
The minimum value for this variable is 4096.",
 
3764
   (uchar**) &max_binlog_size, (uchar**) &max_binlog_size, 0, GET_ULONG,
3602
3765
   REQUIRED_ARG, 1024*1024L*1024L, IO_SIZE, 1024*1024L*1024L, 0, IO_SIZE, 0},
3603
3766
  {"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."),
3606
 
   (char**) &max_connect_errors, (char**) &max_connect_errors, 0, GET_ULONG,
3607
 
   REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ULONG_MAX, 0, 1, 0},
 
3767
   "If there is more than this number of interrupted connections from a host this host will be blocked from further connections.",
 
3768
   (uchar**) &max_connect_errors, (uchar**) &max_connect_errors, 0, GET_ULONG,
 
3769
    REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ULONG_MAX, 0, 1, 0},
3608
3770
  // Default max_connections of 151 is larger than Apache's default max
3609
3771
  // children, to avoid "too many connections" error in a common setup
3610
3772
  {"max_connections", OPT_MAX_CONNECTIONS,
3611
 
   N_("The number of simultaneous clients allowed."),
3612
 
   (char**) &max_connections,
3613
 
   (char**) &max_connections, 0, GET_ULONG, REQUIRED_ARG, 151, 1, 100000, 0, 1,
 
3773
   "The number of simultaneous clients allowed.", (uchar**) &max_connections,
 
3774
   (uchar**) &max_connections, 0, GET_ULONG, REQUIRED_ARG, 151, 1, 100000, 0, 1,
3614
3775
   0},
3615
3776
  {"max_error_count", OPT_MAX_ERROR_COUNT,
3616
 
   N_("Max number of errors/warnings to store for a statement."),
3617
 
   (char**) &global_system_variables.max_error_count,
3618
 
   (char**) &max_system_variables.max_error_count,
 
3777
   "Max number of errors/warnings to store for a statement.",
 
3778
   (uchar**) &global_system_variables.max_error_count,
 
3779
   (uchar**) &max_system_variables.max_error_count,
3619
3780
   0, GET_ULONG, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 0, 65535, 0, 1, 0},
3620
3781
  {"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,
3621
 
   N_("Don't allow creation of heap tables bigger than this."),
3622
 
   (char**) &global_system_variables.max_heap_table_size,
3623
 
   (char**) &max_system_variables.max_heap_table_size, 0, GET_ULL,
 
3782
   "Don't allow creation of heap tables bigger than this.",
 
3783
   (uchar**) &global_system_variables.max_heap_table_size,
 
3784
   (uchar**) &max_system_variables.max_heap_table_size, 0, GET_ULL,
3624
3785
   REQUIRED_ARG, 16*1024*1024L, 16384, MAX_MEM_TABLE_SIZE,
3625
3786
   MALLOC_OVERHEAD, 1024, 0},
3626
3787
  {"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."),
3629
 
   (char**) &global_system_variables.max_join_size,
3630
 
   (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},
 
3788
   "Joins that are probably going to read more than max_join_size records return an error.",
 
3789
   (uchar**) &global_system_variables.max_join_size,
 
3790
   (uchar**) &max_system_variables.max_join_size, 0, GET_HA_ROWS, REQUIRED_ARG,
 
3791
   ~0L, 1, ~0L, 0, 1, 0},
 
3792
   {"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,
 
3793
    "Max number of bytes in sorted records.",
 
3794
    (uchar**) &global_system_variables.max_length_for_sort_data,
 
3795
    (uchar**) &max_system_variables.max_length_for_sort_data, 0, GET_ULONG,
 
3796
    REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
3637
3797
  {"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."),
3642
 
   (char**) &max_relay_log_size, (char**) &max_relay_log_size, 0, GET_ULONG,
 
3798
   "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.",
 
3799
   (uchar**) &max_relay_log_size, (uchar**) &max_relay_log_size, 0, GET_ULONG,
3643
3800
   REQUIRED_ARG, 0L, 0L, 1024*1024L*1024L, 0, IO_SIZE, 0},
3644
3801
  { "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"),
3646
 
    (char**) &global_system_variables.max_seeks_for_key,
3647
 
    (char**) &max_system_variables.max_seeks_for_key, 0, GET_ULONG,
 
3802
    "Limit assumed max number of seeks when looking up rows based on a key",
 
3803
    (uchar**) &global_system_variables.max_seeks_for_key,
 
3804
    (uchar**) &max_system_variables.max_seeks_for_key, 0, GET_ULONG,
3648
3805
    REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0 },
3649
3806
  {"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)."),
3653
 
   (char**) &global_system_variables.max_sort_length,
3654
 
   (char**) &max_system_variables.max_sort_length, 0, GET_ULONG,
 
3807
   "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).",
 
3808
   (uchar**) &global_system_variables.max_sort_length,
 
3809
   (uchar**) &max_system_variables.max_sort_length, 0, GET_ULONG,
3655
3810
   REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
3656
3811
  {"max_tmp_tables", OPT_MAX_TMP_TABLES,
3657
 
   N_("Maximum number of temporary tables a client can keep open at a time."),
3658
 
   (char**) &global_system_variables.max_tmp_tables,
3659
 
   (char**) &max_system_variables.max_tmp_tables, 0, GET_ULONG,
 
3812
   "Maximum number of temporary tables a client can keep open at a time.",
 
3813
   (uchar**) &global_system_variables.max_tmp_tables,
 
3814
   (uchar**) &max_system_variables.max_tmp_tables, 0, GET_ULONG,
3660
3815
   REQUIRED_ARG, 32, 1, ULONG_MAX, 0, 1, 0},
3661
3816
  {"max_write_lock_count", OPT_MAX_WRITE_LOCK_COUNT,
3662
 
   N_("After this many write locks, allow some read locks to run in between."),
3663
 
   (char**) &max_write_lock_count, (char**) &max_write_lock_count, 0, GET_ULONG,
 
3817
   "After this many write locks, allow some read locks to run in between.",
 
3818
   (uchar**) &max_write_lock_count, (uchar**) &max_write_lock_count, 0, GET_ULONG,
3664
3819
   REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0},
3665
3820
  {"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."),
3668
 
   (char**) &global_system_variables.min_examined_row_limit,
3669
 
   (char**) &max_system_variables.min_examined_row_limit, 0, GET_ULONG,
3670
 
   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1L, 0},
 
3821
   "Don't log queries which examine less than min_examined_row_limit rows to file.",
 
3822
   (uchar**) &global_system_variables.min_examined_row_limit,
 
3823
   (uchar**) &max_system_variables.min_examined_row_limit, 0, GET_ULONG,
 
3824
  REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1L, 0},
3671
3825
  {"myisam_block_size", OPT_MYISAM_BLOCK_SIZE,
3672
 
   N_("Block size to be used for MyISAM index pages."),
3673
 
   (char**) &opt_myisam_block_size,
3674
 
   (char**) &opt_myisam_block_size, 0, GET_ULONG, REQUIRED_ARG,
 
3826
   "Block size to be used for MyISAM index pages.",
 
3827
   (uchar**) &opt_myisam_block_size,
 
3828
   (uchar**) &opt_myisam_block_size, 0, GET_ULONG, REQUIRED_ARG,
3675
3829
   MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, MI_MAX_KEY_BLOCK_LENGTH,
3676
3830
   0, MI_MIN_KEY_BLOCK_LENGTH, 0},
3677
3831
  {"myisam_data_pointer_size", OPT_MYISAM_DATA_POINTER_SIZE,
3678
 
   N_("Default pointer size to be used for MyISAM tables."),
3679
 
   (char**) &myisam_data_pointer_size,
3680
 
   (char**) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,
 
3832
   "Default pointer size to be used for MyISAM tables.",
 
3833
   (uchar**) &myisam_data_pointer_size,
 
3834
   (uchar**) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,
3681
3835
   6, 2, 7, 0, 1, 0},
 
3836
  {"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
 
3837
   "Deprecated option",
 
3838
   (uchar**) &global_system_variables.myisam_max_extra_sort_file_size,
 
3839
   (uchar**) &max_system_variables.myisam_max_extra_sort_file_size,
 
3840
   0, GET_ULL, REQUIRED_ARG, (ulonglong) MI_MAX_TEMP_LENGTH,
 
3841
   0, (ulonglong) MAX_FILE_SIZE, 0, 1, 0},
3682
3842
  {"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."),
3685
 
   (char**) &global_system_variables.myisam_max_sort_file_size,
3686
 
   (char**) &max_system_variables.myisam_max_sort_file_size, 0,
3687
 
   GET_ULL, REQUIRED_ARG, (int64_t) LONG_MAX, 0, (uint64_t) MAX_FILE_SIZE,
 
3843
   "Don't use the fast sort index method to created index if the temporary file would get bigger than this.",
 
3844
   (uchar**) &global_system_variables.myisam_max_sort_file_size,
 
3845
   (uchar**) &max_system_variables.myisam_max_sort_file_size, 0,
 
3846
   GET_ULL, REQUIRED_ARG, (longlong) LONG_MAX, 0, (ulonglong) MAX_FILE_SIZE,
3688
3847
   0, 1024*1024, 0},
3689
3848
  {"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."),
3692
 
   (char**) &global_system_variables.myisam_repair_threads,
3693
 
   (char**) &max_system_variables.myisam_repair_threads, 0,
 
3849
   "Number of threads to use when repairing MyISAM tables. The value of 1 disables parallel repair.",
 
3850
   (uchar**) &global_system_variables.myisam_repair_threads,
 
3851
   (uchar**) &max_system_variables.myisam_repair_threads, 0,
3694
3852
   GET_ULONG, REQUIRED_ARG, 1, 1, ULONG_MAX, 0, 1, 0},
3695
3853
  {"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."),
3698
 
   (char**) &global_system_variables.myisam_sort_buff_size,
3699
 
   (char**) &max_system_variables.myisam_sort_buff_size, 0,
3700
 
   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, INT32_MAX, 0, 1, 0},
 
3854
   "The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE.",
 
3855
   (uchar**) &global_system_variables.myisam_sort_buff_size,
 
3856
   (uchar**) &max_system_variables.myisam_sort_buff_size, 0,
 
3857
   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, ~0L, 0, 1, 0},
3701
3858
  {"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'."),
3706
 
   (char**) &myisam_stats_method_str, (char**) &myisam_stats_method_str, 0,
 
3859
   "Specifies how MyISAM index statistics collection code should threat NULLs. "
 
3860
   "Possible values of name are \"nulls_unequal\" (default behavior for 4.1/5.0), "
 
3861
   "\"nulls_equal\" (emulate 4.0 behavior), and \"nulls_ignored\".",
 
3862
   (uchar**) &myisam_stats_method_str, (uchar**) &myisam_stats_method_str, 0,
3707
3863
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3708
3864
  {"net_buffer_length", OPT_NET_BUFFER_LENGTH,
3709
 
   N_("Buffer length for TCP/IP and socket communication."),
3710
 
   (char**) &global_system_variables.net_buffer_length,
3711
 
   (char**) &max_system_variables.net_buffer_length, 0, GET_ULONG,
 
3865
   "Buffer length for TCP/IP and socket communication.",
 
3866
   (uchar**) &global_system_variables.net_buffer_length,
 
3867
   (uchar**) &max_system_variables.net_buffer_length, 0, GET_ULONG,
3712
3868
   REQUIRED_ARG, 16384, 1024, 1024*1024L, 0, 1024, 0},
3713
3869
  {"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."),
3716
 
   (char**) &global_system_variables.net_read_timeout,
3717
 
   (char**) &max_system_variables.net_read_timeout, 0, GET_ULONG,
 
3870
   "Number of seconds to wait for more data from a connection before aborting the read.",
 
3871
   (uchar**) &global_system_variables.net_read_timeout,
 
3872
   (uchar**) &max_system_variables.net_read_timeout, 0, GET_ULONG,
3718
3873
   REQUIRED_ARG, NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
3719
3874
  {"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."),
3722
 
   (char**) &global_system_variables.net_retry_count,
3723
 
   (char**) &max_system_variables.net_retry_count,0,
 
3875
   "If a read on a communication port is interrupted, retry this many times before giving up.",
 
3876
   (uchar**) &global_system_variables.net_retry_count,
 
3877
   (uchar**) &max_system_variables.net_retry_count,0,
3724
3878
   GET_ULONG, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, ULONG_MAX, 0, 1, 0},
3725
3879
  {"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."),
3728
 
   (char**) &global_system_variables.net_write_timeout,
3729
 
   (char**) &max_system_variables.net_write_timeout, 0, GET_ULONG,
 
3880
   "Number of seconds to wait for a block to be written to a connection  before aborting the write.",
 
3881
   (uchar**) &global_system_variables.net_write_timeout,
 
3882
   (uchar**) &max_system_variables.net_write_timeout, 0, GET_ULONG,
3730
3883
   REQUIRED_ARG, NET_WRITE_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
3731
 
  { "old", OPT_OLD_MODE,
3732
 
    N_("Use compatible behavior."),
3733
 
    (char**) &global_system_variables.old_mode,
3734
 
    (char**) &max_system_variables.old_mode, 0, GET_BOOL, NO_ARG,
 
3884
  { "old", OPT_OLD_MODE, "Use compatible behavior.", 
 
3885
    (uchar**) &global_system_variables.old_mode,
 
3886
    (uchar**) &max_system_variables.old_mode, 0, GET_BOOL, NO_ARG, 
3735
3887
    0, 0, 0, 0, 0, 0},
3736
3888
  {"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."),
3741
 
   (char**) &open_files_limit, (char**) &open_files_limit, 0, GET_ULONG,
 
3889
   "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.",
 
3890
   (uchar**) &open_files_limit, (uchar**) &open_files_limit, 0, GET_ULONG,
3742
3891
   REQUIRED_ARG, 0, 0, OS_FILE_LIMIT, 0, 1, 0},
3743
3892
  {"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."),
3748
 
   (char**) &global_system_variables.optimizer_prune_level,
3749
 
   (char**) &max_system_variables.optimizer_prune_level,
 
3893
   "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.",
 
3894
   (uchar**) &global_system_variables.optimizer_prune_level,
 
3895
   (uchar**) &max_system_variables.optimizer_prune_level,
3750
3896
   0, GET_ULONG, OPT_ARG, 1, 0, 1, 0, 1, 0},
3751
3897
  {"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)."),
3760
 
   (char**) &global_system_variables.optimizer_search_depth,
3761
 
   (char**) &max_system_variables.optimizer_search_depth,
 
3898
   "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).",
 
3899
   (uchar**) &global_system_variables.optimizer_search_depth,
 
3900
   (uchar**) &max_system_variables.optimizer_search_depth,
3762
3901
   0, GET_ULONG, OPT_ARG, MAX_TABLES+1, 0, MAX_TABLES+2, 0, 1, 0},
3763
3902
  {"plugin_dir", OPT_PLUGIN_DIR,
3764
 
   N_("Directory for plugins."),
3765
 
   (char**) &opt_plugin_dir_ptr, (char**) &opt_plugin_dir_ptr, 0,
 
3903
   "Directory for plugins.",
 
3904
   (uchar**) &opt_plugin_dir_ptr, (uchar**) &opt_plugin_dir_ptr, 0,
3766
3905
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3767
3906
  {"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]"),
3771
 
   (char**) &opt_plugin_load, (char**) &opt_plugin_load, 0,
 
3907
   "Optional colon separated list of plugins to load, where each plugin is "
 
3908
   "identified by name and path to library seperated by an equals.",
 
3909
   (uchar**) &opt_plugin_load, (uchar**) &opt_plugin_load, 0,
3772
3910
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3773
3911
  {"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,
3774
 
   N_("The size of the buffer that is allocated when preloading indexes"),
3775
 
   (char**) &global_system_variables.preload_buff_size,
3776
 
   (char**) &max_system_variables.preload_buff_size, 0, GET_ULONG,
 
3912
   "The size of the buffer that is allocated when preloading indexes",
 
3913
   (uchar**) &global_system_variables.preload_buff_size,
 
3914
   (uchar**) &max_system_variables.preload_buff_size, 0, GET_ULONG,
3777
3915
   REQUIRED_ARG, 32*1024L, 1024, 1024*1024*1024L, 0, 1, 0},
3778
3916
  {"query_alloc_block_size", OPT_QUERY_ALLOC_BLOCK_SIZE,
3779
 
   N_("Allocation block size for query parsing and execution"),
3780
 
   (char**) &global_system_variables.query_alloc_block_size,
3781
 
   (char**) &max_system_variables.query_alloc_block_size, 0, GET_ULONG,
 
3917
   "Allocation block size for query parsing and execution",
 
3918
   (uchar**) &global_system_variables.query_alloc_block_size,
 
3919
   (uchar**) &max_system_variables.query_alloc_block_size, 0, GET_ULONG,
3782
3920
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
3783
3921
  {"query_prealloc_size", OPT_QUERY_PREALLOC_SIZE,
3784
 
   N_("Persistent buffer for query parsing and execution"),
3785
 
   (char**) &global_system_variables.query_prealloc_size,
3786
 
   (char**) &max_system_variables.query_prealloc_size, 0, GET_ULONG,
 
3922
   "Persistent buffer for query parsing and execution",
 
3923
   (uchar**) &global_system_variables.query_prealloc_size,
 
3924
   (uchar**) &max_system_variables.query_prealloc_size, 0, GET_ULONG,
3787
3925
   REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,
3788
3926
   ULONG_MAX, 0, 1024, 0},
3789
3927
  {"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,
3790
 
   N_("Allocation block size for storing ranges during optimization"),
3791
 
   (char**) &global_system_variables.range_alloc_block_size,
3792
 
   (char**) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,
 
3928
   "Allocation block size for storing ranges during optimization",
 
3929
   (uchar**) &global_system_variables.range_alloc_block_size,
 
3930
   (uchar**) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,
3793
3931
   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, ULONG_MAX,
3794
3932
   0, 1024, 0},
3795
3933
  {"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."),
3799
 
   (char**) &global_system_variables.read_buff_size,
3800
 
   (char**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
3801
 
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT32_MAX, MALLOC_OVERHEAD, IO_SIZE,
 
3934
   "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.",
 
3935
   (uchar**) &global_system_variables.read_buff_size,
 
3936
   (uchar**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
 
3937
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE,
3802
3938
   0},
3803
3939
  {"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"),
3806
 
   (char**) &opt_readonly,
3807
 
   (char**) &opt_readonly,
 
3940
   "Make all non-temporary tables read-only, with the exception for replication (slave) threads and users with the SUPER privilege",
 
3941
   (uchar**) &opt_readonly,
 
3942
   (uchar**) &opt_readonly,
3808
3943
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3809
3944
  {"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."),
3813
 
   (char**) &global_system_variables.read_rnd_buff_size,
3814
 
   (char**) &max_system_variables.read_rnd_buff_size, 0,
 
3945
   "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.",
 
3946
   (uchar**) &global_system_variables.read_rnd_buff_size,
 
3947
   (uchar**) &max_system_variables.read_rnd_buff_size, 0,
3815
3948
   GET_ULONG, REQUIRED_ARG, 256*1024L, 64 /*IO_SIZE*2+MALLOC_OVERHEAD*/ ,
3816
 
   INT32_MAX, MALLOC_OVERHEAD, 1 /* Small lower limit to be able to test MRR */, 0},
 
3949
   INT_MAX32, MALLOC_OVERHEAD, 1 /* Small lower limit to be able to test MRR */, 0},
3817
3950
  {"record_buffer", OPT_RECORD_BUFFER,
3818
3951
   "Alias for read_buffer_size",
3819
 
   (char**) &global_system_variables.read_buff_size,
3820
 
   (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},
 
3952
   (uchar**) &global_system_variables.read_buff_size,
 
3953
   (uchar**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
 
3954
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE, 0},
3823
3955
  {"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."),
3826
 
   (char**) &relay_log_purge,
3827
 
   (char**) &relay_log_purge, 0, GET_BOOL, NO_ARG,
 
3956
   "0 = do not purge relay logs. 1 = purge them as soon as they are no more needed.",
 
3957
   (uchar**) &relay_log_purge,
 
3958
   (uchar**) &relay_log_purge, 0, GET_BOOL, NO_ARG,
3828
3959
   1, 0, 1, 0, 1, 0},
3829
3960
  {"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,
3830
 
   N_("Maximum space to use for all relay logs."),
3831
 
   (char**) &relay_log_space_limit,
3832
 
   (char**) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,
3833
 
   (int64_t) ULONG_MAX, 0, 1, 0},
 
3961
   "Maximum space to use for all relay logs.",
 
3962
   (uchar**) &relay_log_space_limit,
 
3963
   (uchar**) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,
 
3964
   (longlong) ULONG_MAX, 0, 1, 0},
3834
3965
  {"slave_compressed_protocol", OPT_SLAVE_COMPRESSED_PROTOCOL,
3835
 
   N_("Use compression on master/slave protocol."),
3836
 
   (char**) &opt_slave_compressed_protocol,
3837
 
   (char**) &opt_slave_compressed_protocol,
 
3966
   "Use compression on master/slave protocol.",
 
3967
   (uchar**) &opt_slave_compressed_protocol,
 
3968
   (uchar**) &opt_slave_compressed_protocol,
3838
3969
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3839
3970
  {"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."),
3842
 
   (char**) &slave_net_timeout, (char**) &slave_net_timeout, 0,
 
3971
   "Number of seconds to wait for more data from a master/slave connection before aborting the read.",
 
3972
   (uchar**) &slave_net_timeout, (uchar**) &slave_net_timeout, 0,
3843
3973
   GET_ULONG, REQUIRED_ARG, SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
3844
3974
  {"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."),
3848
 
   (char**) &slave_trans_retries, (char**) &slave_trans_retries, 0,
3849
 
   GET_ULONG, REQUIRED_ARG, 10L, 0L, (int64_t) ULONG_MAX, 0, 1, 0},
 
3975
   "Number of times the slave SQL thread will retry a transaction in case "
 
3976
   "it failed with a deadlock or elapsed lock wait timeout, "
 
3977
   "before giving up and stopping.",
 
3978
   (uchar**) &slave_trans_retries, (uchar**) &slave_trans_retries, 0,
 
3979
   GET_ULONG, REQUIRED_ARG, 10L, 0L, (longlong) ULONG_MAX, 0, 1, 0},
3850
3980
  {"slave-allow-batching", OPT_SLAVE_ALLOW_BATCHING,
3851
 
   N_("Allow slave to batch requests."),
3852
 
   (char**) &slave_allow_batching, (char**) &slave_allow_batching,
 
3981
   "Allow slave to batch requests.",
 
3982
   (uchar**) &slave_allow_batching, (uchar**) &slave_allow_batching,
3853
3983
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3854
3984
  {"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."),
3857
 
   (char**) &slow_launch_time, (char**) &slow_launch_time, 0, GET_ULONG,
 
3985
   "If creating the thread takes longer than this value (in seconds), the Slow_launch_threads counter will be incremented.",
 
3986
   (uchar**) &slow_launch_time, (uchar**) &slow_launch_time, 0, GET_ULONG,
3858
3987
   REQUIRED_ARG, 2L, 0L, LONG_TIMEOUT, 0, 1, 0},
3859
3988
  {"sort_buffer_size", OPT_SORT_BUFFER,
3860
 
   N_("Each thread that needs to do a sort allocates a buffer of this size."),
3861
 
   (char**) &global_system_variables.sortbuff_size,
3862
 
   (char**) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
 
3989
   "Each thread that needs to do a sort allocates a buffer of this size.",
 
3990
   (uchar**) &global_system_variables.sortbuff_size,
 
3991
   (uchar**) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
3863
3992
   MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ULONG_MAX,
3864
3993
   MALLOC_OVERHEAD, 1, 0},
3865
3994
  {"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."),
3868
 
   (char**) &sync_binlog_period, (char**) &sync_binlog_period, 0, GET_ULONG,
 
3995
   "Synchronously flush binary log to disk after every #th event. "
 
3996
   "Use 0 (default) to disable synchronous flushing.",
 
3997
   (uchar**) &sync_binlog_period, (uchar**) &sync_binlog_period, 0, GET_ULONG,
3869
3998
   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1, 0},
 
3999
  {"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default.",
 
4000
   (uchar**) &opt_sync_frm, (uchar**) &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,
 
4001
   0, 0, 0, 0},
 
4002
  {"table_cache", OPT_TABLE_OPEN_CACHE,
 
4003
   "Deprecated; use --table_open_cache instead.",
 
4004
   (uchar**) &table_cache_size, (uchar**) &table_cache_size, 0, GET_ULONG,
 
4005
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
3870
4006
  {"table_definition_cache", OPT_TABLE_DEF_CACHE,
3871
 
   N_("The number of cached table definitions."),
3872
 
   (char**) &table_def_size, (char**) &table_def_size,
 
4007
   "The number of cached table definitions.",
 
4008
   (uchar**) &table_def_size, (uchar**) &table_def_size,
3873
4009
   0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
3874
4010
  {"table_open_cache", OPT_TABLE_OPEN_CACHE,
3875
 
   N_("The number of cached open tables."),
3876
 
   (char**) &table_cache_size, (char**) &table_cache_size, 0, GET_ULONG,
 
4011
   "The number of cached open tables.",
 
4012
   (uchar**) &table_cache_size, (uchar**) &table_cache_size, 0, GET_ULONG,
3877
4013
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
3878
4014
  {"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."),
3881
 
   (char**) &table_lock_wait_timeout, (char**) &table_lock_wait_timeout,
 
4015
   "Timeout in seconds to wait for a table level lock before returning an "
 
4016
   "error. Used only if the connection has active cursors.",
 
4017
   (uchar**) &table_lock_wait_timeout, (uchar**) &table_lock_wait_timeout,
3882
4018
   0, GET_ULONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
3883
4019
  {"thread_cache_size", OPT_THREAD_CACHE_SIZE,
3884
 
   N_("How many threads we should keep in a cache for reuse."),
3885
 
   (char**) &thread_cache_size, (char**) &thread_cache_size, 0, GET_ULONG,
 
4020
   "How many threads we should keep in a cache for reuse.",
 
4021
   (uchar**) &thread_cache_size, (uchar**) &thread_cache_size, 0, GET_ULONG,
3886
4022
   REQUIRED_ARG, 0, 0, 16384, 0, 1, 0},
3887
4023
  {"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'"),
3890
 
   (char**) &thread_pool_size, (char**) &thread_pool_size, 0, GET_ULONG,
 
4024
   "How many threads we should create to handle query requests in case of 'thread_handling=pool-of-threads'",
 
4025
   (uchar**) &thread_pool_size, (uchar**) &thread_pool_size, 0, GET_ULONG,
3891
4026
   REQUIRED_ARG, 20, 1, 16384, 0, 1, 0},
3892
4027
  {"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,
 
4028
   "The stack size for each thread.", (uchar**) &my_thread_stack_size,
 
4029
   (uchar**) &my_thread_stack_size, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,
3897
4030
   1024L*128L, ULONG_MAX, 0, 1024, 0},
3898
4031
  { "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],
 
4032
    "The TIME format (for future).",
 
4033
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
 
4034
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
3902
4035
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3903
4036
  {"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."),
3906
 
   (char**) &global_system_variables.tmp_table_size,
3907
 
   (char**) &max_system_variables.tmp_table_size, 0, GET_ULL,
 
4037
   "If an internal in-memory temporary table exceeds this size, MySQL will"
 
4038
   " automatically convert it to an on-disk MyISAM table.",
 
4039
   (uchar**) &global_system_variables.tmp_table_size,
 
4040
   (uchar**) &max_system_variables.tmp_table_size, 0, GET_ULL,
3908
4041
   REQUIRED_ARG, 16*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},
3909
4042
  {"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,
3910
 
   N_("Allocation block size for transactions to be stored in binary log"),
3911
 
   (char**) &global_system_variables.trans_alloc_block_size,
3912
 
   (char**) &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,
 
4043
   "Allocation block size for transactions to be stored in binary log",
 
4044
   (uchar**) &global_system_variables.trans_alloc_block_size,
 
4045
   (uchar**) &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,
3913
4046
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
3914
4047
  {"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,
3915
 
   N_("Persistent buffer for transactions to be stored in binary log"),
3916
 
   (char**) &global_system_variables.trans_prealloc_size,
3917
 
   (char**) &max_system_variables.trans_prealloc_size, 0, GET_ULONG,
 
4048
   "Persistent buffer for transactions to be stored in binary log",
 
4049
   (uchar**) &global_system_variables.trans_prealloc_size,
 
4050
   (uchar**) &max_system_variables.trans_prealloc_size, 0, GET_ULONG,
3918
4051
   REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
3919
4052
  {"wait_timeout", OPT_WAIT_TIMEOUT,
3920
 
   N_("The number of seconds the server waits for activity on a connection "
3921
 
      "before closing it."),
3922
 
   (char**) &global_system_variables.net_wait_timeout,
3923
 
   (char**) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
3924
 
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT,
 
4053
   "The number of seconds the server waits for activity on a connection before closing it.",
 
4054
   (uchar**) &global_system_variables.net_wait_timeout,
 
4055
   (uchar**) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
 
4056
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT),
3925
4057
   0, 1, 0},
3926
4058
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
3927
4059
};
3928
4060
 
3929
 
static int show_net_compression(THD *thd __attribute__((unused)),
3930
 
                                SHOW_VAR *var,
3931
 
                                char *buff __attribute__((unused)))
 
4061
static int show_net_compression(THD *thd, SHOW_VAR *var, char *buff)
3932
4062
{
3933
4063
  var->type= SHOW_MY_BOOL;
3934
4064
  var->value= (char *)&thd->net.compress;
3935
4065
  return 0;
3936
4066
}
3937
4067
 
3938
 
static st_show_var_func_container
3939
 
show_net_compression_cont= { &show_net_compression };
3940
 
 
3941
4068
static int show_starttime(THD *thd, SHOW_VAR *var, char *buff)
3942
4069
{
3943
4070
  var->type= SHOW_LONG;
3946
4073
  return 0;
3947
4074
}
3948
4075
 
3949
 
static st_show_var_func_container
3950
 
show_starttime_cont= { &show_starttime };
3951
 
 
3952
4076
static int show_flushstatustime(THD *thd, SHOW_VAR *var, char *buff)
3953
4077
{
3954
4078
  var->type= SHOW_LONG;
3957
4081
  return 0;
3958
4082
}
3959
4083
 
3960
 
static st_show_var_func_container
3961
 
show_flushstatustime_cont= { &show_flushstatustime };
3962
 
 
3963
 
static int show_slave_running(THD *thd __attribute__((unused)),
3964
 
                              SHOW_VAR *var, char *buff)
 
4084
static int show_slave_running(THD *thd, SHOW_VAR *var, char *buff)
3965
4085
{
3966
4086
  var->type= SHOW_MY_BOOL;
3967
4087
  pthread_mutex_lock(&LOCK_active_mi);
3968
4088
  var->value= buff;
3969
 
  *((bool *)buff)= (bool) (active_mi && active_mi->slave_running &&
 
4089
  *((my_bool *)buff)= (my_bool) (active_mi && active_mi->slave_running &&
3970
4090
                                 active_mi->rli.slave_running);
3971
4091
  pthread_mutex_unlock(&LOCK_active_mi);
3972
4092
  return 0;
3973
4093
}
3974
4094
 
3975
 
static st_show_var_func_container
3976
 
show_slave_running_cont= { &show_slave_running };
3977
 
 
3978
 
static int show_slave_retried_trans(THD *thd __attribute__((unused)),
3979
 
                                    SHOW_VAR *var, char *buff)
 
4095
static int show_slave_retried_trans(THD *thd, SHOW_VAR *var, char *buff)
3980
4096
{
3981
4097
  /*
3982
4098
    TODO: with multimaster, have one such counter per line in
3997
4113
  return 0;
3998
4114
}
3999
4115
 
4000
 
static st_show_var_func_container
4001
 
show_slave_retried_trans_cont= { &show_slave_retried_trans };
4002
 
 
4003
 
static int show_slave_received_heartbeats(THD *thd __attribute__((unused)),
4004
 
                                          SHOW_VAR *var, char *buff)
 
4116
static int show_slave_received_heartbeats(THD *thd, SHOW_VAR *var, char *buff)
4005
4117
{
4006
4118
  pthread_mutex_lock(&LOCK_active_mi);
4007
4119
  if (active_mi)
4009
4121
    var->type= SHOW_LONGLONG;
4010
4122
    var->value= buff;
4011
4123
    pthread_mutex_lock(&active_mi->rli.data_lock);
4012
 
    *((int64_t *)buff)= active_mi->received_heartbeats;
 
4124
    *((longlong *)buff)= active_mi->received_heartbeats;
4013
4125
    pthread_mutex_unlock(&active_mi->rli.data_lock);
4014
4126
  }
4015
4127
  else
4018
4130
  return 0;
4019
4131
}
4020
4132
 
4021
 
static st_show_var_func_container
4022
 
show_slave_received_heartbeats_cont= { &show_slave_received_heartbeats };
4023
 
 
4024
 
static int show_heartbeat_period(THD *thd __attribute__((unused)),
4025
 
                                 SHOW_VAR *var, char *buff)
 
4133
static int show_heartbeat_period(THD *thd, SHOW_VAR *var, char *buff)
4026
4134
{
4027
4135
  pthread_mutex_lock(&LOCK_active_mi);
4028
4136
  if (active_mi)
4029
4137
  {
4030
4138
    var->type= SHOW_CHAR;
4031
4139
    var->value= buff;
4032
 
    sprintf(buff, "%.3f",active_mi->heartbeat_period);
 
4140
    my_sprintf(buff, (buff, "%.3f",active_mi->heartbeat_period));
4033
4141
  }
4034
4142
  else
4035
4143
    var->type= SHOW_UNDEF;
4037
4145
  return 0;
4038
4146
}
4039
4147
 
4040
 
static st_show_var_func_container
4041
 
show_heartbeat_period_cont= { &show_heartbeat_period};
4042
4148
 
4043
 
static int show_open_tables(THD *thd __attribute__((unused)),
4044
 
                            SHOW_VAR *var, char *buff)
 
4149
static int show_open_tables(THD *thd, SHOW_VAR *var, char *buff)
4045
4150
{
4046
4151
  var->type= SHOW_LONG;
4047
4152
  var->value= buff;
4049
4154
  return 0;
4050
4155
}
4051
4156
 
4052
 
static int show_table_definitions(THD *thd __attribute__((unused)),
4053
 
                                  SHOW_VAR *var, char *buff)
 
4157
static int show_table_definitions(THD *thd, SHOW_VAR *var, char *buff)
4054
4158
{
4055
4159
  var->type= SHOW_LONG;
4056
4160
  var->value= buff;
4058
4162
  return 0;
4059
4163
}
4060
4164
 
4061
 
static st_show_var_func_container
4062
 
show_open_tables_cont= { &show_open_tables };
4063
 
static st_show_var_func_container
4064
 
show_table_definitions_cont= { &show_table_definitions };
4065
 
 
4066
4165
/*
4067
4166
  Variables shown by SHOW STATUS in alphabetical order
4068
4167
*/
4075
4174
  {"Bytes_received",           (char*) offsetof(STATUS_VAR, bytes_received), SHOW_LONGLONG_STATUS},
4076
4175
  {"Bytes_sent",               (char*) offsetof(STATUS_VAR, bytes_sent), SHOW_LONGLONG_STATUS},
4077
4176
  {"Com",                      (char*) com_status_vars, SHOW_ARRAY},
4078
 
  {"Compression",              (char*) &show_net_compression_cont, SHOW_FUNC},
 
4177
  {"Compression",              (char*) &show_net_compression, SHOW_FUNC},
4079
4178
  {"Connections",              (char*) &thread_id,              SHOW_LONG_NOFLUSH},
4080
4179
  {"Created_tmp_disk_tables",  (char*) offsetof(STATUS_VAR, created_tmp_disk_tables), SHOW_LONG_STATUS},
4081
4180
  {"Created_tmp_files",        (char*) &my_tmp_file_created,    SHOW_LONG},
4107
4206
  {"Max_used_connections",     (char*) &max_used_connections,  SHOW_LONG},
4108
4207
  {"Open_files",               (char*) &my_file_opened,         SHOW_LONG_NOFLUSH},
4109
4208
  {"Open_streams",             (char*) &my_stream_opened,       SHOW_LONG_NOFLUSH},
4110
 
  {"Open_table_definitions",   (char*) &show_table_definitions_cont, SHOW_FUNC},
4111
 
  {"Open_tables",              (char*) &show_open_tables_cont,       SHOW_FUNC},
 
4209
  {"Open_table_definitions",   (char*) &show_table_definitions, SHOW_FUNC},
 
4210
  {"Open_tables",              (char*) &show_open_tables,       SHOW_FUNC},
4112
4211
  {"Opened_files",             (char*) &my_file_total_opened, SHOW_LONG_NOFLUSH},
4113
4212
  {"Opened_tables",            (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},
4114
4213
  {"Opened_table_definitions", (char*) offsetof(STATUS_VAR, opened_shares), SHOW_LONG_STATUS},
4119
4218
  {"Select_range_check",       (char*) offsetof(STATUS_VAR, select_range_check_count), SHOW_LONG_STATUS},
4120
4219
  {"Select_scan",              (char*) offsetof(STATUS_VAR, select_scan_count), SHOW_LONG_STATUS},
4121
4220
  {"Slave_open_temp_tables",   (char*) &slave_open_temp_tables, SHOW_LONG},
4122
 
  {"Slave_retried_transactions",(char*) &show_slave_retried_trans_cont, SHOW_FUNC},
4123
 
  {"Slave_heartbeat_period",   (char*) &show_heartbeat_period_cont, SHOW_FUNC},
4124
 
  {"Slave_received_heartbeats",(char*) &show_slave_received_heartbeats_cont, SHOW_FUNC},
4125
 
  {"Slave_running",            (char*) &show_slave_running_cont,     SHOW_FUNC},
 
4221
  {"Slave_retried_transactions",(char*) &show_slave_retried_trans, SHOW_FUNC},
 
4222
  {"Slave_heartbeat_period",   (char*) &show_heartbeat_period, SHOW_FUNC},
 
4223
  {"Slave_received_heartbeats",(char*) &show_slave_received_heartbeats, SHOW_FUNC},
 
4224
  {"Slave_running",            (char*) &show_slave_running,     SHOW_FUNC},
4126
4225
  {"Slow_launch_threads",      (char*) &slow_launch_threads,    SHOW_LONG},
4127
4226
  {"Slow_queries",             (char*) offsetof(STATUS_VAR, long_query_count), SHOW_LONG_STATUS},
4128
4227
  {"Sort_merge_passes",        (char*) offsetof(STATUS_VAR, filesort_merge_passes), SHOW_LONG_STATUS},
4140
4239
  {"Threads_connected",        (char*) &connection_count,       SHOW_INT},
4141
4240
  {"Threads_created",          (char*) &thread_created,         SHOW_LONG_NOFLUSH},
4142
4241
  {"Threads_running",          (char*) &thread_running,         SHOW_INT},
4143
 
  {"Uptime",                   (char*) &show_starttime_cont,         SHOW_FUNC},
4144
 
  {"Uptime_since_flush_status",(char*) &show_flushstatustime_cont,   SHOW_FUNC},
4145
 
  {NULL, NULL, SHOW_LONG}
 
4242
  {"Uptime",                   (char*) &show_starttime,         SHOW_FUNC},
 
4243
  {"Uptime_since_flush_status",(char*) &show_flushstatustime,   SHOW_FUNC},
 
4244
  {NullS, NullS, SHOW_LONG}
4146
4245
};
4147
4246
 
4148
4247
static void print_version(void)
4153
4252
    version from the output of 'mysqld --version', so don't change it!
4154
4253
  */
4155
4254
  printf("%s  Ver %s for %s on %s (%s)\n",my_progname,
4156
 
         server_version,SYSTEM_TYPE,MACHINE_TYPE, DRIZZLE_COMPILATION_COMMENT);
 
4255
         server_version,SYSTEM_TYPE,MACHINE_TYPE, MYSQL_COMPILATION_COMMENT);
4157
4256
}
4158
4257
 
4159
4258
static void usage(void)
4165
4264
  if (!default_collation_name)
4166
4265
    default_collation_name= (char*) default_charset_info->name;
4167
4266
  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"));
 
4267
  puts("\
 
4268
Copyright (C) 2000 MySQL AB, by Monty and others\n\
 
4269
This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\
 
4270
and you are welcome to modify and redistribute it under the GPL license\n\n\
 
4271
Starts the MySQL database server\n");
4174
4272
 
4175
 
  printf(_("Usage: %s [OPTIONS]\n"), my_progname);
 
4273
  printf("Usage: %s [OPTIONS]\n", my_progname);
 
4274
  if (!opt_verbose)
 
4275
    puts("\nFor more help options (several pages), use mysqld --verbose --help");
 
4276
  else
4176
4277
  {
4177
 
#ifdef FOO
4178
 
  print_defaults(DRIZZLE_CONFIG_NAME,load_default_groups);
 
4278
  print_defaults(MYSQL_CONFIG_NAME,load_default_groups);
4179
4279
  puts("");
4180
4280
  set_ports();
4181
 
#endif
4182
4281
 
4183
4282
  /* Print out all the options including plugin supplied options */
4184
4283
  my_print_help_inc_plugins(my_long_options, sizeof(my_long_options)/sizeof(my_option));
4185
4284
 
4186
 
  puts(_("\nTo see what values a running Drizzle server is using, type\n"
4187
 
         "'drizzleadmin variables' instead of 'drizzled --help'."));
 
4285
  puts("\n\
 
4286
To see what values a running MySQL server is using, type\n\
 
4287
'mysqladmin variables' instead of 'mysqld --verbose --help'.");
4188
4288
  }
4189
4289
}
4190
4290
 
4210
4310
  /* Things reset to zero */
4211
4311
  opt_skip_slave_start= opt_reckless_slave = 0;
4212
4312
  mysql_home[0]= pidfile_name[0]= log_error_file[0]= 0;
 
4313
  opt_log= opt_slow_log= 0;
4213
4314
  log_output_options= find_bit_type(log_output_str, &log_output_typelib);
4214
4315
  opt_bin_log= 0;
4215
 
  opt_skip_show_db=0;
4216
 
  opt_logname= opt_binlog_index_name= 0;
 
4316
  opt_disable_networking= opt_skip_show_db=0;
 
4317
  opt_logname= opt_binlog_index_name= opt_slow_logname= 0;
4217
4318
  opt_tc_log_file= (char *)"tc.log";      // no hostname in tc_log file name !
 
4319
  opt_secure_auth= 0;
4218
4320
  opt_secure_file_priv= 0;
 
4321
  opt_bootstrap= opt_myisam_log= 0;
 
4322
  mqh_used= 0;
4219
4323
  segfaulted= kill_in_progress= 0;
4220
4324
  cleanup_done= 0;
4221
4325
  defaults_argc= 0;
4234
4338
  binlog_cache_use=  binlog_cache_disk_use= 0;
4235
4339
  max_used_connections= slow_launch_threads = 0;
4236
4340
  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));
 
4341
  errmesg= 0;
 
4342
  opt_mysql_tmpdir= my_bind_addr_str= NullS;
 
4343
  bzero((uchar*) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));
 
4344
  bzero((char *) &global_status_var, sizeof(global_status_var));
4240
4345
  key_map_full.set_all();
4241
4346
 
4242
4347
  /* Character sets */
4253
4358
  slave_exec_mode_options= 0;
4254
4359
  slave_exec_mode_options= (uint)
4255
4360
    find_bit_type_or_exit(slave_exec_mode_str, &slave_exec_mode_typelib, NULL);
 
4361
  opt_specialflag= SPECIAL_ENGLISH;
 
4362
  ip_sock= INVALID_SOCKET;
4256
4363
  mysql_home_ptr= mysql_home;
4257
4364
  pidfile_name_ptr= pidfile_name;
4258
4365
  log_error_file_ptr= log_error_file;
4264
4371
  what_to_log= ~ (1L << (uint) COM_TIME);
4265
4372
  refresh_version= 1L;  /* Increments on each reload */
4266
4373
  global_query_id= thread_id= 1L;
4267
 
  my_stpcpy(server_version, DRIZZLE_SERVER_VERSION);
 
4374
  strmov(server_version, MYSQL_SERVER_VERSION);
4268
4375
  myisam_recover_options_str= "OFF";
4269
4376
  myisam_stats_method_str= "nulls_unequal";
4270
4377
  threads.empty();
4292
4399
 
4293
4400
  /* Variables in libraries */
4294
4401
  charsets_dir= 0;
4295
 
  default_character_set_name= (char*) DRIZZLE_DEFAULT_CHARSET_NAME;
 
4402
  default_character_set_name= (char*) MYSQL_DEFAULT_CHARSET_NAME;
4296
4403
  default_collation_name= compiled_default_collation_name;
 
4404
  sys_charset_system.set((char*) system_charset_info->csname);
4297
4405
  character_set_filesystem_name= (char*) "binary";
4298
4406
  lc_time_names_name= (char*) "en_US";
4299
4407
  /* Set default values for some option variables */
4300
 
  default_storage_engine_str= (char*) "innodb";
 
4408
  default_storage_engine_str= (char*) "MyISAM";
4301
4409
  global_system_variables.table_plugin= NULL;
4302
4410
  global_system_variables.tx_isolation= ISO_REPEATABLE_READ;
4303
 
  global_system_variables.select_limit= (uint64_t) HA_POS_ERROR;
4304
 
  max_system_variables.select_limit=    (uint64_t) HA_POS_ERROR;
4305
 
  global_system_variables.max_join_size= (uint64_t) HA_POS_ERROR;
4306
 
  max_system_variables.max_join_size=   (uint64_t) HA_POS_ERROR;
 
4411
  global_system_variables.select_limit= (ulonglong) HA_POS_ERROR;
 
4412
  max_system_variables.select_limit=    (ulonglong) HA_POS_ERROR;
 
4413
  global_system_variables.max_join_size= (ulonglong) HA_POS_ERROR;
 
4414
  max_system_variables.max_join_size=   (ulonglong) HA_POS_ERROR;
 
4415
  global_system_variables.old_passwords= 0;
4307
4416
  global_system_variables.old_alter_table= 0;
4308
4417
  global_system_variables.binlog_format= BINLOG_FORMAT_UNSPEC;
4309
4418
  /*
4313
4422
  global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;
4314
4423
 
4315
4424
  /* Variables that depends on compile options */
4316
 
  opt_error_log= 0;
 
4425
#ifndef DBUG_OFF
 
4426
  default_dbug_option=IF_WIN("d:t:i:O,\\mysqld.trace",
 
4427
                             "d:t:i:o,/tmp/mysqld.trace");
 
4428
#endif
 
4429
  opt_error_log= IF_WIN(1,0);
4317
4430
#ifdef HAVE_BROKEN_REALPATH
4318
4431
  have_symlink=SHOW_OPTION_NO;
4319
4432
#else
4320
4433
  have_symlink=SHOW_OPTION_YES;
4321
4434
#endif
 
4435
#ifdef HAVE_DLOPEN
 
4436
  have_dlopen=SHOW_OPTION_YES;
 
4437
#else
 
4438
  have_dlopen=SHOW_OPTION_NO;
 
4439
#endif
 
4440
#ifdef HAVE_CRYPT
 
4441
  have_crypt=SHOW_OPTION_YES;
 
4442
#else
 
4443
  have_crypt=SHOW_OPTION_NO;
 
4444
#endif
4322
4445
#ifdef HAVE_COMPRESS
4323
4446
  have_compress= SHOW_OPTION_YES;
4324
4447
#else
4327
4450
 
4328
4451
  const char *tmpenv;
4329
4452
  if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))
4330
 
    tmpenv = DEFAULT_DRIZZLE_HOME;
 
4453
    tmpenv = DEFAULT_MYSQL_HOME;
4331
4454
  (void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);
4332
4455
}
4333
4456
 
4334
4457
 
4335
 
bool
 
4458
my_bool
4336
4459
mysqld_get_one_option(int optid,
4337
4460
                      const struct my_option *opt __attribute__((unused)),
4338
4461
                      char *argument)
4339
4462
{
4340
4463
  switch(optid) {
4341
4464
  case '#':
 
4465
#ifndef DBUG_OFF
 
4466
    DBUG_SET_INITIAL(argument ? argument : default_dbug_option);
 
4467
#endif
4342
4468
    opt_endinfo=1;                              /* unireg: memory allocation */
4343
4469
    break;
4344
4470
  case 'a':
4351
4477
    if (default_collation_name == compiled_default_collation_name)
4352
4478
      default_collation_name= 0;
4353
4479
    break;
 
4480
  case 'l':
 
4481
    opt_log=1;
 
4482
    break;
4354
4483
  case 'h':
4355
4484
    strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);
4356
4485
    /* Correct pointer set by my_getopt (for embedded library) */
4361
4490
    if (!mysqld_user || !strcmp(mysqld_user, argument))
4362
4491
      mysqld_user= argument;
4363
4492
    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);
 
4493
      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
4494
    break;
4368
4495
  case 'L':
4369
4496
    strmake(language, argument, sizeof(language)-1);
4390
4517
    test_flags= argument ? (uint) atoi(argument) : 0;
4391
4518
    opt_endinfo=1;
4392
4519
    break;
 
4520
  case (int) OPT_BIG_TABLES:
 
4521
    thd_startup_options|=OPTION_BIG_TABLES;
 
4522
    break;
 
4523
  case (int) OPT_ISAM_LOG:
 
4524
    opt_myisam_log=1;
 
4525
    break;
4393
4526
  case (int) OPT_BIN_LOG:
4394
4527
    opt_bin_log= test(argument != disabled_my_option);
4395
4528
    break;
4397
4530
    opt_error_log= 1;
4398
4531
    break;
4399
4532
  case (int)OPT_REPLICATE_IGNORE_DB:
4400
 
    {
4401
 
      rpl_filter->add_ignore_db(argument);
4402
 
      break;
4403
 
    }
 
4533
  {
 
4534
    rpl_filter->add_ignore_db(argument);
 
4535
    break;
 
4536
  }
4404
4537
  case (int)OPT_REPLICATE_DO_DB:
4405
 
    {
4406
 
      rpl_filter->add_do_db(argument);
4407
 
      break;
4408
 
    }
 
4538
  {
 
4539
    rpl_filter->add_do_db(argument);
 
4540
    break;
 
4541
  }
4409
4542
  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
 
    }
 
4543
  {
 
4544
    char* key = argument,*p, *val;
 
4545
 
 
4546
    if (!(p= strstr(argument, "->")))
 
4547
    {
 
4548
      fprintf(stderr,
 
4549
              "Bad syntax in replicate-rewrite-db - missing '->'!\n");
 
4550
      exit(1);
 
4551
    }
 
4552
    val= p--;
 
4553
    while (my_isspace(mysqld_charset, *p) && p > argument)
 
4554
      *p-- = 0;
 
4555
    if (p == argument)
 
4556
    {
 
4557
      fprintf(stderr,
 
4558
              "Bad syntax in replicate-rewrite-db - empty FROM db!\n");
 
4559
      exit(1);
 
4560
    }
 
4561
    *val= 0;
 
4562
    val+= 2;
 
4563
    while (*val && my_isspace(mysqld_charset, *val))
 
4564
      *val++;
 
4565
    if (!*val)
 
4566
    {
 
4567
      fprintf(stderr,
 
4568
              "Bad syntax in replicate-rewrite-db - empty TO db!\n");
 
4569
      exit(1);
 
4570
    }
 
4571
 
 
4572
    rpl_filter->add_db_rewrite(key, val);
 
4573
    break;
 
4574
  }
4442
4575
 
4443
4576
  case (int)OPT_BINLOG_IGNORE_DB:
4444
 
    {
4445
 
      binlog_filter->add_ignore_db(argument);
4446
 
      break;
4447
 
    }
 
4577
  {
 
4578
    binlog_filter->add_ignore_db(argument);
 
4579
    break;
 
4580
  }
4448
4581
  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
 
    }
 
4582
  {
 
4583
    int id;
 
4584
    id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);
 
4585
    global_system_variables.binlog_format= opt_binlog_format_id= id - 1;
 
4586
    break;
 
4587
  }
4455
4588
  case (int)OPT_BINLOG_DO_DB:
4456
 
    {
4457
 
      binlog_filter->add_do_db(argument);
4458
 
      break;
4459
 
    }
 
4589
  {
 
4590
    binlog_filter->add_do_db(argument);
 
4591
    break;
 
4592
  }
4460
4593
  case (int)OPT_REPLICATE_DO_TABLE:
 
4594
  {
 
4595
    if (rpl_filter->add_do_table(argument))
4461
4596
    {
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;
 
4597
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
 
4598
      exit(1);
4468
4599
    }
 
4600
    break;
 
4601
  }
4469
4602
  case (int)OPT_REPLICATE_WILD_DO_TABLE:
 
4603
  {
 
4604
    if (rpl_filter->add_wild_do_table(argument))
4470
4605
    {
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;
 
4606
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
 
4607
      exit(1);
4477
4608
    }
 
4609
    break;
 
4610
  }
4478
4611
  case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:
 
4612
  {
 
4613
    if (rpl_filter->add_wild_ignore_table(argument))
4479
4614
    {
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;
 
4615
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
 
4616
      exit(1);
4486
4617
    }
 
4618
    break;
 
4619
  }
4487
4620
  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
 
    }
 
4621
  {
 
4622
    if (rpl_filter->add_ignore_table(argument))
 
4623
    {
 
4624
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
 
4625
      exit(1);
 
4626
    }
 
4627
    break;
 
4628
  }
 
4629
  case (int) OPT_SLOW_QUERY_LOG:
 
4630
    opt_slow_log= 1;
 
4631
    break;
 
4632
#ifdef WITH_CSV_STORAGE_ENGINE
 
4633
  case  OPT_LOG_OUTPUT:
 
4634
  {
 
4635
    if (!argument || !argument[0])
 
4636
    {
 
4637
      log_output_options= LOG_FILE;
 
4638
      log_output_str= log_output_typelib.type_names[1];
 
4639
    }
 
4640
    else
 
4641
    {
 
4642
      log_output_str= argument;
 
4643
      log_output_options=
 
4644
        find_bit_type_or_exit(argument, &log_output_typelib, opt->name);
 
4645
  }
 
4646
    break;
 
4647
  }
 
4648
#endif
 
4649
  case (int) OPT_SKIP_NEW:
 
4650
    opt_specialflag|= SPECIAL_NO_NEW_FUNC;
 
4651
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
 
4652
    myisam_concurrent_insert=0;
 
4653
    myisam_recover_options= HA_RECOVER_NONE;
 
4654
    my_use_symdir=0;
 
4655
    ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);
 
4656
    break;
 
4657
  case (int) OPT_SAFE:
 
4658
    opt_specialflag|= SPECIAL_SAFE_MODE;
 
4659
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
 
4660
    myisam_recover_options= HA_RECOVER_DEFAULT;
 
4661
    ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);
 
4662
    break;
 
4663
  case (int) OPT_SKIP_PRIOR:
 
4664
    opt_specialflag|= SPECIAL_NO_PRIOR;
 
4665
    break;
 
4666
  case (int) OPT_SKIP_LOCK:
 
4667
    opt_external_locking=0;
 
4668
    break;
 
4669
  case (int) OPT_SKIP_SHOW_DB:
 
4670
    opt_skip_show_db=1;
 
4671
    opt_specialflag|=SPECIAL_SKIP_SHOW_DB;
 
4672
    break;
4496
4673
  case (int) OPT_WANT_CORE:
4497
4674
    test_flags |= TEST_CORE_ON_SIGNAL;
4498
4675
    break;
4504
4681
    break;
4505
4682
  case (int) OPT_BIND_ADDRESS:
4506
4683
    {
4507
 
      struct addrinfo *res_lst, hints;
 
4684
      struct addrinfo *res_lst, hints;    
4508
4685
 
4509
 
      memset(&hints, 0, sizeof(struct addrinfo));
 
4686
      bzero(&hints, sizeof(struct addrinfo));
4510
4687
      hints.ai_socktype= SOCK_STREAM;
4511
4688
      hints.ai_protocol= IPPROTO_TCP;
4512
4689
 
4513
 
      if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0)
 
4690
      if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0) 
4514
4691
      {
4515
 
        sql_print_error(_("Can't start server: cannot resolve hostname!"));
 
4692
        sql_print_error("Can't start server: cannot resolve hostname!");
4516
4693
        exit(1);
4517
4694
      }
4518
4695
 
4519
4696
      if (res_lst->ai_next)
4520
4697
      {
4521
 
        sql_print_error(_("Can't start server: bind-address refers to "
4522
 
                          "multiple interfaces!"));
 
4698
        sql_print_error("Can't start server: bind-address refers to multiple interfaces!");
4523
4699
        exit(1);
4524
4700
      }
4525
4701
      freeaddrinfo(res_lst);
4532
4708
    if (opt_console)
4533
4709
      opt_error_log= 0;                 // Force logs to stdout
4534
4710
    break;
 
4711
  case (int) OPT_FLUSH:
 
4712
    myisam_flush=1;
 
4713
    flush_time=0;                       // No auto flush
 
4714
    break;
4535
4715
  case OPT_LOW_PRIORITY_UPDATES:
4536
4716
    thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;
4537
4717
    global_system_variables.low_priority_updates=1;
4538
4718
    break;
 
4719
  case OPT_BOOTSTRAP:
 
4720
    opt_noacl=opt_bootstrap=1;
 
4721
    break;
4539
4722
  case OPT_SERVER_ID:
4540
4723
    server_id_supplied = 1;
4541
4724
    break;
4560
4743
    charsets_dir = mysql_charsets_dir;
4561
4744
    break;
4562
4745
  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
 
    }
 
4746
  {
 
4747
    int type;
 
4748
    type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);
 
4749
    global_system_variables.tx_isolation= (type-1);
 
4750
    break;
 
4751
  }
4569
4752
  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
 
    }
 
4753
  {
 
4754
    if (!argument)
 
4755
    {
 
4756
      myisam_recover_options=    HA_RECOVER_DEFAULT;
 
4757
      myisam_recover_options_str= myisam_recover_typelib.type_names[0];
 
4758
    }
 
4759
    else if (!argument[0])
 
4760
    {
 
4761
      myisam_recover_options= HA_RECOVER_NONE;
 
4762
      myisam_recover_options_str= "OFF";
 
4763
    }
 
4764
    else
 
4765
    {
 
4766
      myisam_recover_options_str=argument;
 
4767
      myisam_recover_options=
 
4768
        find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);
 
4769
    }
 
4770
    ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
 
4771
    break;
 
4772
  }
4590
4773
  case OPT_TC_HEURISTIC_RECOVER:
4591
4774
    tc_heuristic_recover= find_type_or_exit(argument,
4592
4775
                                            &tc_heuristic_recover_typelib,
4593
4776
                                            opt->name);
4594
4777
    break;
4595
4778
  case OPT_MYISAM_STATS_METHOD:
4596
 
    {
4597
 
      uint32_t method_conv;
4598
 
      int method;
 
4779
  {
 
4780
    ulong method_conv;
 
4781
    int method;
4599
4782
 
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;
 
4783
    myisam_stats_method_str= argument;
 
4784
    method= find_type_or_exit(argument, &myisam_stats_method_typelib,
 
4785
                              opt->name);
 
4786
    switch (method-1) {
 
4787
    case 2:
 
4788
      method_conv= MI_STATS_METHOD_IGNORE_NULLS;
 
4789
      break;
 
4790
    case 1:
 
4791
      method_conv= MI_STATS_METHOD_NULLS_EQUAL;
 
4792
      break;
 
4793
    case 0:
 
4794
    default:
 
4795
      method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
4616
4796
      break;
4617
4797
    }
 
4798
    global_system_variables.myisam_stats_method= method_conv;
 
4799
    break;
 
4800
  }
 
4801
  case OPT_LOWER_CASE_TABLE_NAMES:
 
4802
    lower_case_table_names= argument ? atoi(argument) : 1;
 
4803
    lower_case_table_names_used= 1;
 
4804
    break;
4618
4805
  }
4619
4806
  return 0;
4620
4807
}
4622
4809
 
4623
4810
/** Handle arguments for multiple key caches. */
4624
4811
 
4625
 
extern "C" char **mysql_getopt_value(const char *keyname, uint32_t key_length,
 
4812
extern "C" uchar **mysql_getopt_value(const char *keyname, uint key_length,
4626
4813
                                      const struct my_option *option);
4627
4814
 
4628
 
char**
4629
 
mysql_getopt_value(const char *keyname, uint32_t key_length,
 
4815
uchar* *
 
4816
mysql_getopt_value(const char *keyname, uint key_length,
4630
4817
                   const struct my_option *option)
4631
4818
{
4632
4819
  switch (option->id) {
4640
4827
      exit(1);
4641
4828
    switch (option->id) {
4642
4829
    case OPT_KEY_BUFFER_SIZE:
4643
 
      return (char**) &key_cache->param_buff_size;
 
4830
      return (uchar**) &key_cache->param_buff_size;
4644
4831
    case OPT_KEY_CACHE_BLOCK_SIZE:
4645
 
      return (char**) &key_cache->param_block_size;
 
4832
      return (uchar**) &key_cache->param_block_size;
4646
4833
    case OPT_KEY_CACHE_DIVISION_LIMIT:
4647
 
      return (char**) &key_cache->param_division_limit;
 
4834
      return (uchar**) &key_cache->param_division_limit;
4648
4835
    case OPT_KEY_CACHE_AGE_THRESHOLD:
4649
 
      return (char**) &key_cache->param_age_threshold;
 
4836
      return (uchar**) &key_cache->param_age_threshold;
4650
4837
    }
4651
4838
  }
4652
4839
  }
4653
 
  return (char **)option->value;
 
4840
  return option->value;
4654
4841
}
4655
4842
 
4656
4843
 
4662
4849
  va_start(args, format);
4663
4850
 
4664
4851
  /* Don't print warnings for --loose options during bootstrap */
4665
 
  if (level == ERROR_LEVEL || global_system_variables.log_warnings)
 
4852
  if (level == ERROR_LEVEL || !opt_bootstrap ||
 
4853
      global_system_variables.log_warnings)
4666
4854
  {
4667
4855
    vprint_msg_to_log(level, format, args);
4668
4856
  }
4682
4870
  my_getopt_error_reporter= option_error_reporter;
4683
4871
 
4684
4872
  /* Skip unknown options so that they may be processed later by plugins */
4685
 
  my_getopt_skip_unknown= true;
 
4873
  my_getopt_skip_unknown= TRUE;
4686
4874
 
4687
4875
  if ((ho_error= handle_options(argc, &argv, my_long_options,
4688
4876
                                mysqld_get_one_option)))
4690
4878
  (*argc)++; /* add back one for the progname handle_options removes */
4691
4879
             /* no need to do this for argv as we are discarding it. */
4692
4880
 
 
4881
  if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes ||
 
4882
       opt_log_slow_slave_statements) &&
 
4883
      !opt_slow_log)
 
4884
    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");
 
4885
 
4693
4886
#if defined(HAVE_BROKEN_REALPATH)
4694
4887
  my_use_symdir=0;
4695
4888
  my_disable_symlinks=1;
4720
4913
    Set some global variables from the global_system_variables
4721
4914
    In most cases the global variables will not be used
4722
4915
  */
 
4916
  my_disable_locking= myisam_single_user= test(opt_external_locking == 0);
4723
4917
  my_default_record_cache_size=global_system_variables.read_buff_size;
4724
4918
  myisam_max_temp_length=
4725
4919
    (my_off_t) global_system_variables.myisam_max_sort_file_size;
4729
4923
 
4730
4924
  /* long_query_time is in microseconds */
4731
4925
  global_system_variables.long_query_time= max_system_variables.long_query_time=
4732
 
    (int64_t) (long_query_time * 1000000.0);
4733
 
 
4734
 
  if (init_global_datetime_format(DRIZZLE_TIMESTAMP_DATE,
 
4926
    (longlong) (long_query_time * 1000000.0);
 
4927
 
 
4928
  if (opt_short_log_format)
 
4929
    opt_specialflag|= SPECIAL_SHORT_LOG_FORMAT;
 
4930
 
 
4931
  if (init_global_datetime_format(MYSQL_TIMESTAMP_DATE,
4735
4932
                                  &global_system_variables.date_format) ||
4736
 
      init_global_datetime_format(DRIZZLE_TIMESTAMP_TIME,
 
4933
      init_global_datetime_format(MYSQL_TIMESTAMP_TIME,
4737
4934
                                  &global_system_variables.time_format) ||
4738
 
      init_global_datetime_format(DRIZZLE_TIMESTAMP_DATETIME,
 
4935
      init_global_datetime_format(MYSQL_TIMESTAMP_DATETIME,
4739
4936
                                  &global_system_variables.datetime_format))
4740
4937
    exit(1);
4741
4938
 
4747
4944
  Create version name for running mysqld version
4748
4945
  We automaticly add suffixes -debug, -embedded and -log to the version
4749
4946
  name to make the version more descriptive.
4750
 
  (DRIZZLE_SERVER_SUFFIX is set by the compilation environment)
 
4947
  (MYSQL_SERVER_SUFFIX is set by the compilation environment)
4751
4948
*/
4752
4949
 
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
4950
static void set_server_version(void)
4760
4951
{
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
 
4952
  char *end= strxmov(server_version, MYSQL_SERVER_VERSION,
 
4953
                     MYSQL_SERVER_SUFFIX_STR, NullS);
 
4954
#ifndef DBUG_OFF
 
4955
  if (!strstr(MYSQL_SERVER_SUFFIX_STR, "-debug"))
 
4956
    end= strmov(end, "-debug");
 
4957
#endif
 
4958
  if (opt_log || opt_slow_log || opt_bin_log)
 
4959
    strmov(end, "-log");                        // This may slow down system
4765
4960
}
4766
4961
 
4767
4962
 
4768
4963
static char *get_relative_path(const char *path)
4769
4964
{
4770
4965
  if (test_if_hard_path(path) &&
4771
 
      is_prefix(path,DEFAULT_DRIZZLE_HOME) &&
4772
 
      strcmp(DEFAULT_DRIZZLE_HOME,FN_ROOTDIR))
 
4966
      is_prefix(path,DEFAULT_MYSQL_HOME) &&
 
4967
      strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))
4773
4968
  {
4774
 
    path+=(uint) strlen(DEFAULT_DRIZZLE_HOME);
 
4969
    path+=(uint) strlen(DEFAULT_MYSQL_HOME);
4775
4970
    while (*path == FN_LIBCHAR)
4776
4971
      path++;
4777
4972
  }
4794
4989
  if (!test_if_hard_path(dir))
4795
4990
  {
4796
4991
    strxnmov(tmp_path,sizeof(tmp_path)-1, mysql_real_data_home,
4797
 
             dir, NULL);
 
4992
             dir, NullS);
4798
4993
    dir=tmp_path;
4799
4994
  }
4800
4995
  return !fn_format(to, name, dir, extension,
4805
5000
static void fix_paths(void)
4806
5001
{
4807
5002
  char buff[FN_REFLEN],*pos;
4808
 
  convert_dirname(mysql_home,mysql_home,NULL);
 
5003
  convert_dirname(mysql_home,mysql_home,NullS);
4809
5004
  /* Resolve symlinks to allow 'mysql_home' to be a relative symlink */
4810
5005
  my_realpath(mysql_home,mysql_home,MYF(0));
4811
5006
  /* Ensure that mysql_home ends in FN_LIBCHAR */
4812
 
  pos= strchr(mysql_home, '\0');
 
5007
  pos=strend(mysql_home);
4813
5008
  if (pos[-1] != FN_LIBCHAR)
4814
5009
  {
4815
5010
    pos[0]= FN_LIBCHAR;
4816
5011
    pos[1]= 0;
4817
5012
  }
4818
 
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NULL);
 
5013
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);
4819
5014
  (void) fn_format(buff, mysql_real_data_home, "", "",
4820
5015
                   (MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));
4821
5016
  (void) unpack_dirname(mysql_unpacked_real_data_home, buff);
4822
 
  convert_dirname(language,language,NULL);
 
5017
  convert_dirname(language,language,NullS);
4823
5018
  (void) my_load_path(mysql_home,mysql_home,""); // Resolve current dir
4824
5019
  (void) my_load_path(mysql_real_data_home,mysql_real_data_home,mysql_home);
4825
5020
  (void) my_load_path(pidfile_name,pidfile_name,mysql_real_data_home);
4831
5026
  if (test_if_hard_path(sharedir))
4832
5027
    strmake(buff,sharedir,sizeof(buff)-1);              /* purecov: tested */
4833
5028
  else
4834
 
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NULL);
4835
 
  convert_dirname(buff,buff,NULL);
 
5029
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NullS);
 
5030
  convert_dirname(buff,buff,NullS);
4836
5031
  (void) my_load_path(language,language,buff);
4837
5032
 
4838
5033
  /* If --character-sets-dir isn't given, use shared library dir */
4839
5034
  if (charsets_dir != mysql_charsets_dir)
4840
5035
  {
4841
5036
    strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,
4842
 
             CHARSET_DIR, NULL);
 
5037
             CHARSET_DIR, NullS);
4843
5038
  }
4844
5039
  (void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);
4845
 
  convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NULL);
 
5040
  convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NullS);
4846
5041
  charsets_dir=mysql_charsets_dir;
4847
5042
 
4848
5043
  if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))
4858
5053
   */
4859
5054
  if (opt_secure_file_priv)
4860
5055
  {
4861
 
    convert_dirname(buff, opt_secure_file_priv, NULL);
4862
 
    free(opt_secure_file_priv);
 
5056
    convert_dirname(buff, opt_secure_file_priv, NullS);
 
5057
    my_free(opt_secure_file_priv, MYF(0));
4863
5058
    opt_secure_file_priv= my_strdup(buff, MYF(MY_FAE));
4864
5059
  }
4865
5060
}
4866
5061
 
4867
5062
 
4868
 
static uint32_t find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
 
5063
static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
4869
5064
                                   const char *option)
4870
5065
{
4871
 
  uint32_t res;
 
5066
  ulong res;
4872
5067
 
4873
5068
  const char **ptr;
4874
 
 
4875
 
  if ((res= find_bit_type(x, bit_lib)) == ~(uint32_t) 0)
 
5069
  
 
5070
  if ((res= find_bit_type(x, bit_lib)) == ~(ulong) 0)
4876
5071
  {
4877
5072
    ptr= bit_lib->type_names;
4878
5073
    if (!*x)
4879
 
      fprintf(stderr, _("No option given to %s\n"), option);
 
5074
      fprintf(stderr, "No option given to %s\n", option);
4880
5075
    else
4881
 
      fprintf(stderr, _("Wrong option to %s. Option(s) given: %s\n"),
4882
 
              option, x);
4883
 
    fprintf(stderr, _("Alternatives are: '%s'"), *ptr);
 
5076
      fprintf(stderr, "Wrong option to %s. Option(s) given: %s\n", option, x);
 
5077
    fprintf(stderr, "Alternatives are: '%s'", *ptr);
4884
5078
    while (*++ptr)
4885
5079
      fprintf(stderr, ",'%s'", *ptr);
4886
5080
    fprintf(stderr, "\n");
4894
5088
  @return
4895
5089
    a bitfield from a string of substrings separated by ','
4896
5090
    or
4897
 
    ~(uint32_t) 0 on error.
 
5091
    ~(ulong) 0 on error.
4898
5092
*/
4899
5093
 
4900
 
static uint32_t find_bit_type(const char *x, TYPELIB *bit_lib)
 
5094
static ulong find_bit_type(const char *x, TYPELIB *bit_lib)
4901
5095
{
4902
5096
  bool found_end;
4903
5097
  int  found_count;
4904
5098
  const char *end,*i,*j;
4905
5099
  const char **array, *pos;
4906
 
  uint32_t found,found_int,bit;
 
5100
  ulong found,found_int,bit;
4907
5101
 
4908
5102
  found=0;
4909
5103
  found_end= 0;
4912
5106
  found_end= *pos == 0;
4913
5107
  while (!found_end)
4914
5108
  {
4915
 
    if ((end=strrchr(pos,',')) != NULL)         /* Let end point at fieldend */
 
5109
    if (!*(end=strcend(pos,',')))               /* Let end point at fieldend */
4916
5110
    {
4917
5111
      while (end > pos && end[-1] == ' ')
4918
5112
        end--;                                  /* Skip end-space */
4919
5113
      found_end=1;
4920
5114
    }
4921
 
    else
4922
 
    {
4923
 
        end=pos+strlen(pos);
4924
 
        found_end=1;
4925
 
    }
4926
5115
    found_int=0; found_count=0;
4927
5116
    for (array=bit_lib->type_names, bit=1 ; (i= *array++) ; bit<<=1)
4928
5117
    {
4946
5135
skip: ;
4947
5136
    }
4948
5137
    if (found_count != 1)
4949
 
      return(~(uint32_t) 0);                            // No unique value
 
5138
      return(~(ulong) 0);                               // No unique value
4950
5139
    found|=found_int;
4951
5140
    pos=end+1;
4952
5141
  }
4956
5145
 
4957
5146
 
4958
5147
/**
 
5148
  Check if file system used for databases is case insensitive.
 
5149
 
 
5150
  @param dir_name                       Directory to test
 
5151
 
 
5152
  @retval
 
5153
    -1  Don't know (Test failed)
 
5154
  @retval
 
5155
    0   File system is case sensitive
 
5156
  @retval
 
5157
    1   File system is case insensitive
 
5158
*/
 
5159
 
 
5160
static int test_if_case_insensitive(const char *dir_name)
 
5161
{
 
5162
  int result= 0;
 
5163
  File file;
 
5164
  char buff[FN_REFLEN], buff2[FN_REFLEN];
 
5165
  struct stat stat_info;
 
5166
 
 
5167
  fn_format(buff, glob_hostname, dir_name, ".lower-test",
 
5168
            MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
 
5169
  fn_format(buff2, glob_hostname, dir_name, ".LOWER-TEST",
 
5170
            MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
 
5171
  (void) my_delete(buff2, MYF(0));
 
5172
  if ((file= my_create(buff, 0666, O_RDWR, MYF(0))) < 0)
 
5173
  {
 
5174
    sql_print_warning("Can't create test file %s", buff);
 
5175
    return(-1);
 
5176
  }
 
5177
  my_close(file, MYF(0));
 
5178
  if (!stat(buff2, &stat_info))
 
5179
    result= 1;                                  // Can access file
 
5180
  (void) my_delete(buff, MYF(MY_WME));
 
5181
  return(result);
 
5182
}
 
5183
 
 
5184
 
 
5185
/**
4959
5186
  Create file to store pid number.
4960
5187
*/
4961
5188
static void create_pid_file()
4967
5194
    char buff[21], *end;
4968
5195
    end= int10_to_str((long) getpid(), buff, 10);
4969
5196
    *end++= '\n';
4970
 
    if (!my_write(file, (unsigned char*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))
 
5197
    if (!my_write(file, (uchar*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))
4971
5198
    {
4972
5199
      (void) my_close(file, MYF(0));
4973
5200
      return;
4987
5214
  add_to_status(&global_status_var, &thd->status_var);
4988
5215
 
4989
5216
  /* Reset thread's status variables */
4990
 
  memset(&thd->status_var, 0, sizeof(thd->status_var));
 
5217
  bzero((uchar*) &thd->status_var, sizeof(thd->status_var));
4991
5218
 
4992
5219
  /* Reset some global variables */
4993
5220
  reset_status_vars();