← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/mysqld.cc

  • Committer: Monty Taylor
  • Date: 2008-07-05 18:10:38 UTC
  • mto: This revision was merged to the branch mainline in revision 63.
  • Revision ID: monty@inaugust.com-20080705181038-0ih0nnamu5qrut0y
Fixed prototypes. Cleaned define a little bit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/mysqld.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
 
248
242
 
249
243
/* Global variables */
250
244
 
251
 
bool opt_bin_log;
 
245
bool opt_update_log, 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, opt_allow_suspicious_udfs;
 
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;
470
 
static char *opt_binlog_index_name;
 
462
static ulong opt_specialflag, opt_myisam_block_size;
 
463
static char *opt_update_logname, *opt_binlog_index_name;
471
464
static char *opt_tc_heuristic_recover;
472
465
static char *mysql_home_ptr, *pidfile_name_ptr;
473
466
static int defaults_argc;
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);
504
502
static void fix_paths(void);
505
503
void handle_connections_sockets();
506
504
pthread_handler_t kill_server_thread(void *arg);
 
505
static void bootstrap(FILE *file);
 
506
static bool read_init_file(char *file_name);
507
507
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,
 
508
static ulong find_bit_type(const char *x, TYPELIB *bit_lib);
 
509
static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
510
510
                                   const char *option);
511
511
static void clean_up(bool print_message);
 
512
static int test_if_case_insensitive(const char *dir_name);
512
513
 
513
514
static void usage(void);
514
515
static void start_signal_handler(void);
527
528
#ifdef EXTRA_DEBUG
528
529
  int count=0;
529
530
#endif
 
531
  DBUG_ENTER("close_connections");
530
532
 
531
533
  /* Clear thread cache */
532
534
  kill_cached_threads++;
533
535
  flush_thread_cache();
534
536
 
 
537
  /* kill flush thread */
 
538
  (void) pthread_mutex_lock(&LOCK_manager);
 
539
  if (manager_thread_in_use)
 
540
  {
 
541
    DBUG_PRINT("quit", ("killing manager thread: 0x%lx",
 
542
                        (ulong)manager_thread));
 
543
   (void) pthread_cond_signal(&COND_manager);
 
544
  }
 
545
  (void) pthread_mutex_unlock(&LOCK_manager);
 
546
 
535
547
  /* kill connection thread */
 
548
  DBUG_PRINT("quit", ("waiting for select thread: 0x%lx",
 
549
                      (ulong) select_thread));
536
550
  (void) pthread_mutex_lock(&LOCK_thread_count);
537
551
 
538
552
  while (select_thread_in_use)
539
553
  {
540
554
    struct timespec abstime;
541
555
    int error;
 
556
    DBUG_PRINT("info",("Waiting for select thread"));
542
557
 
543
558
#ifndef DONT_USE_THR_ALARM
544
559
    if (pthread_kill(select_thread, thr_client_alarm))
545
560
      break;                                    // allready dead
546
561
#endif
547
562
    set_timespec(abstime, 2);
548
 
    for (uint32_t tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
 
563
    for (uint tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
549
564
    {
550
565
      error=pthread_cond_timedwait(&COND_thread_count,&LOCK_thread_count,
551
566
                                   &abstime);
554
569
    }
555
570
#ifdef EXTRA_DEBUG
556
571
    if (error != 0 && !count++)
557
 
      sql_print_error(_("Got error %d from pthread_cond_timedwait"),error);
 
572
      sql_print_error("Got error %d from pthread_cond_timedwait",error);
558
573
#endif
559
574
    close_server_sock();
560
575
  }
562
577
 
563
578
 
564
579
  /* Abort listening to new connections */
 
580
  DBUG_PRINT("quit",("Closing sockets"));
 
581
  if (!opt_disable_networking )
565
582
  {
566
 
    int x;
567
 
 
568
 
    for (x= 0; x < pollfd_count; x++)
 
583
    if (ip_sock != INVALID_SOCKET)
569
584
    {
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
 
      }
 
585
      (void) shutdown(ip_sock, SHUT_RDWR);
 
586
      (void) closesocket(ip_sock);
 
587
      ip_sock= INVALID_SOCKET;
576
588
    }
577
589
  }
578
 
 
579
590
  end_thr_alarm(0);                      // Abort old alarms.
580
591
 
581
592
  /*
590
601
  I_List_iterator<THD> it(threads);
591
602
  while ((tmp=it++))
592
603
  {
 
604
    DBUG_PRINT("quit",("Informing thread %ld that it's time to die",
 
605
                       tmp->thread_id));
593
606
    /* We skip slave threads & scheduler on this first loop through. */
594
607
    if (tmp->slave_thread)
595
608
      continue;
624
637
 
625
638
  for (;;)
626
639
  {
 
640
    DBUG_PRINT("quit",("Locking LOCK_thread_count"));
627
641
    (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
628
642
    if (!(tmp=threads.get()))
629
643
    {
 
644
      DBUG_PRINT("quit",("Unlocking LOCK_thread_count"));
630
645
      (void) pthread_mutex_unlock(&LOCK_thread_count);
631
646
      break;
632
647
    }
639
654
                           tmp->main_security_ctx.user : ""));
640
655
      close_connection(tmp,0,0);
641
656
    }
 
657
    DBUG_PRINT("quit",("Unlocking LOCK_thread_count"));
642
658
    (void) pthread_mutex_unlock(&LOCK_thread_count);
643
659
  }
644
660
  /* All threads has now been aborted */
 
661
  DBUG_PRINT("quit",("Waiting for threads to die (count=%u)",thread_count));
645
662
  (void) pthread_mutex_lock(&LOCK_thread_count);
646
663
  while (thread_count)
647
664
  {
648
665
    (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
 
666
    DBUG_PRINT("quit",("One thread died (count=%u)",thread_count));
649
667
  }
650
668
  (void) pthread_mutex_unlock(&LOCK_thread_count);
651
669
 
652
 
  return;;
 
670
  DBUG_PRINT("quit",("close_connections thread"));
 
671
  DBUG_VOID_RETURN;
653
672
}
654
673
 
655
674
 
656
675
static void close_server_sock()
657
676
{
658
677
#ifdef HAVE_CLOSE_SERVER_SOCK
 
678
  DBUG_ENTER("close_server_sock");
 
679
  my_socket tmp_sock;
 
680
  tmp_sock=ip_sock;
 
681
  if (tmp_sock != INVALID_SOCKET)
659
682
  {
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
 
    }
 
683
    ip_sock=INVALID_SOCKET;
 
684
    DBUG_PRINT("info",("calling shutdown on TCP/IP socket"));
 
685
    VOID(shutdown(tmp_sock, SHUT_RDWR));
671
686
  }
 
687
  DBUG_VOID_RETURN;
672
688
#endif
673
689
}
674
690
 
675
691
 
676
692
void kill_mysql(void)
677
693
{
 
694
  DBUG_ENTER("kill_mysql");
678
695
 
679
696
#if defined(SIGNALS_DONT_BREAK_READ)
680
697
  abort_loop=1;                                 // Break connection loops
682
699
#endif
683
700
 
684
701
#if defined(HAVE_PTHREAD_KILL)
685
 
  pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL);
 
702
  if (pthread_kill(signal_thread, MYSQL_KILL_SIGNAL))
 
703
  {
 
704
    DBUG_PRINT("error",("Got error %d from pthread_kill",errno)); /* purecov: inspected */
 
705
  }
686
706
#elif !defined(SIGNALS_DONT_BREAK_READ)
687
 
  kill(current_pid, DRIZZLE_KILL_SIGNAL);
 
707
  kill(current_pid, MYSQL_KILL_SIGNAL);
688
708
#endif
 
709
  DBUG_PRINT("quit",("After pthread_kill"));
689
710
  shutdown_in_progress=1;                       // Safety if kill didn't work
690
711
#ifdef SIGNALS_DONT_BREAK_READ
691
712
  if (!kill_in_progress)
694
715
    abort_loop=1;
695
716
    if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
696
717
                           (void*) 0))
697
 
      sql_print_error(_("Can't create thread to kill server"));
 
718
      sql_print_error("Can't create thread to kill server");
698
719
  }
699
720
#endif
700
 
  return;;
 
721
  DBUG_VOID_RETURN;
701
722
}
702
723
 
703
724
/**
712
733
*/
713
734
 
714
735
static void *kill_server(void *sig_ptr)
715
 
#define RETURN_FROM_KILL_SERVER return(0)
 
736
#define RETURN_FROM_KILL_SERVER DBUG_RETURN(0)
716
737
{
 
738
  DBUG_ENTER("kill_server");
717
739
  int sig=(int) (long) sig_ptr;                 // This is passed a int
718
740
  // if there is a signal during the kill in progress, ignore the other
719
741
  if (kill_in_progress)                         // Safety
720
742
    RETURN_FROM_KILL_SERVER;
721
 
  kill_in_progress=true;
 
743
  kill_in_progress=TRUE;
722
744
  abort_loop=1;                                 // This should be set
723
745
  if (sig != 0) // 0 is not a valid signal number
724
746
    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);
 
747
  if (sig == MYSQL_KILL_SIGNAL || sig == 0)
 
748
    sql_print_information(ER(ER_NORMAL_SHUTDOWN),my_progname);
727
749
  else
728
 
    sql_print_error(_(ER(ER_GOT_SIGNAL)),my_progname,sig); /* purecov: inspected */
729
 
 
 
750
    sql_print_error(ER(ER_GOT_SIGNAL),my_progname,sig); /* purecov: inspected */
 
751
  
730
752
  close_connections();
731
 
  if (sig != DRIZZLE_KILL_SIGNAL &&
 
753
  if (sig != MYSQL_KILL_SIGNAL &&
732
754
      sig != 0)
733
755
    unireg_abort(1);                            /* purecov: inspected */
734
756
  else
758
780
#endif
759
781
 
760
782
 
761
 
extern "C" RETSIGTYPE print_signal_warning(int sig)
 
783
extern "C" sig_handler print_signal_warning(int sig)
762
784
{
763
785
  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
 
786
    sql_print_warning("Got signal %d from thread %ld", sig,my_thread_id());
 
787
#ifdef DONT_REMEMBER_SIGNAL
766
788
  my_sigset(sig,print_signal_warning);          /* int. thread system calls */
767
789
#endif
768
790
  if (sig == SIGALRM)
793
815
 
794
816
extern "C" void unireg_abort(int exit_code)
795
817
{
 
818
  DBUG_ENTER("unireg_abort");
796
819
 
797
820
  if (exit_code)
798
 
    sql_print_error(_("Aborting\n"));
 
821
    sql_print_error("Aborting\n");
799
822
  else if (opt_help)
800
823
    usage();
801
 
  clean_up(!opt_help && (exit_code)); /* purecov: inspected */
 
824
  clean_up(!opt_help && (exit_code || !opt_bootstrap)); /* purecov: inspected */
 
825
  DBUG_PRINT("quit",("done with cleanup in unireg_abort"));
802
826
  mysqld_exit(exit_code);
803
827
}
804
828
 
814
838
 
815
839
void clean_up(bool print_message)
816
840
{
 
841
  DBUG_PRINT("exit",("clean_up"));
817
842
  if (cleanup_done++)
818
843
    return; /* purecov: inspected */
819
844
 
 
845
  /*
 
846
    make sure that handlers finish up
 
847
    what they have that is dependent on the binlog
 
848
  */
 
849
  ha_binlog_end(current_thd);
 
850
 
820
851
  logger.cleanup_base();
821
852
 
822
853
  mysql_bin_log.cleanup();
836
867
  if (tc_log)
837
868
    tc_log->close();
838
869
  xid_cache_free();
839
 
  delete_elements(&key_caches, (void (*)(const char*, unsigned char*)) free_key_cache);
 
870
  delete_elements(&key_caches, (void (*)(const char*, uchar*)) free_key_cache);
840
871
  multi_keycache_free();
841
872
  free_status_vars();
842
873
  end_thr_alarm(1);                     /* Free allocated memory */
843
874
  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);
 
875
  my_free((char*) global_system_variables.date_format,
 
876
          MYF(MY_ALLOW_ZERO_PTR));
 
877
  my_free((char*) global_system_variables.time_format,
 
878
          MYF(MY_ALLOW_ZERO_PTR));
 
879
  my_free((char*) global_system_variables.datetime_format,
 
880
          MYF(MY_ALLOW_ZERO_PTR));
847
881
  if (defaults_argv)
848
882
    free_defaults(defaults_argv);
849
 
  free(sys_init_connect.value);
850
 
  free(sys_init_slave.value);
 
883
  my_free(sys_init_connect.value, MYF(MY_ALLOW_ZERO_PTR));
 
884
  my_free(sys_init_slave.value, MYF(MY_ALLOW_ZERO_PTR));
 
885
  my_free(sys_var_general_log_path.value, MYF(MY_ALLOW_ZERO_PTR));
 
886
  my_free(sys_var_slow_log_path.value, MYF(MY_ALLOW_ZERO_PTR));
851
887
  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);
 
888
  my_free(slave_load_tmpdir,MYF(MY_ALLOW_ZERO_PTR));
 
889
  x_free(opt_bin_logname);
 
890
  x_free(opt_relay_logname);
 
891
  x_free(opt_secure_file_priv);
859
892
  bitmap_free(&temp_pool);
 
893
  end_slave_list();
860
894
  delete binlog_filter;
861
895
  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);
 
896
  vio_end();
 
897
 
 
898
  if (!opt_bootstrap)
 
899
    (void) my_delete(pidfile_name,MYF(0));      // This may not always exist
 
900
  if (print_message && errmesg && server_start_time)
 
901
    sql_print_information(ER(ER_SHUTDOWN_COMPLETE),my_progname);
867
902
  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);  */
 
903
  finish_client_errs();
 
904
  my_free((uchar*) my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST),
 
905
          MYF(MY_WME | MY_FAE | MY_ALLOW_ZERO_PTR));
 
906
  DBUG_PRINT("quit", ("Error messages freed"));
874
907
  /* Tell main we are ready */
875
908
  logger.cleanup_end();
876
909
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
910
  DBUG_PRINT("quit", ("got thread count lock"));
877
911
  ready_to_exit=1;
878
912
  /* do the broadcast inside the lock to ensure that my_end() is not called */
879
913
  (void) pthread_cond_broadcast(&COND_thread_count);
883
917
    The following lines may never be executed as the main thread may have
884
918
    killed us
885
919
  */
 
920
  DBUG_PRINT("quit", ("done with cleanup"));
886
921
} /* clean_up */
887
922
 
888
923
 
892
927
*/
893
928
static void wait_for_signal_thread_to_end()
894
929
{
895
 
  uint32_t i;
 
930
  uint i;
896
931
  /*
897
932
    Wait up to 10 seconds for signal thread to die. We use this mainly to
898
933
    avoid getting warnings that my_thread_end has not been called
899
934
  */
900
935
  for (i= 0 ; i < 100 && signal_thread_in_use; i++)
901
936
  {
902
 
    if (pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL) != ESRCH)
 
937
    if (pthread_kill(signal_thread, MYSQL_KILL_SIGNAL) != ESRCH)
903
938
      break;
904
939
    my_sleep(100);                              // Give it time to die
905
940
  }
912
947
  (void) pthread_mutex_destroy(&LOCK_lock_db);
913
948
  (void) pthread_mutex_destroy(&LOCK_open);
914
949
  (void) pthread_mutex_destroy(&LOCK_thread_count);
 
950
  (void) pthread_mutex_destroy(&LOCK_mapped_file);
915
951
  (void) pthread_mutex_destroy(&LOCK_status);
916
952
  (void) pthread_mutex_destroy(&LOCK_error_log);
 
953
  (void) pthread_mutex_destroy(&LOCK_manager);
 
954
  (void) pthread_mutex_destroy(&LOCK_crypt);
917
955
  (void) pthread_mutex_destroy(&LOCK_user_conn);
918
956
  (void) pthread_mutex_destroy(&LOCK_connection_count);
 
957
  (void) pthread_mutex_destroy(&LOCK_rpl_status);
 
958
  (void) pthread_cond_destroy(&COND_rpl_status);
919
959
  (void) pthread_mutex_destroy(&LOCK_active_mi);
920
960
  (void) rwlock_destroy(&LOCK_sys_init_connect);
921
961
  (void) rwlock_destroy(&LOCK_sys_init_slave);
928
968
  (void) pthread_cond_destroy(&COND_global_read_lock);
929
969
  (void) pthread_cond_destroy(&COND_thread_cache);
930
970
  (void) pthread_cond_destroy(&COND_flush_thread_cache);
 
971
  (void) pthread_cond_destroy(&COND_manager);
931
972
}
932
973
 
933
974
 
938
979
static void set_ports()
939
980
{
940
981
  char  *env;
941
 
  if (!mysqld_port)
 
982
  if (!mysqld_port && !opt_disable_networking)
942
983
  {                                     // Get port if not from commandline
943
 
    mysqld_port= DRIZZLE_PORT;
 
984
    mysqld_port= MYSQL_PORT;
944
985
 
945
986
    /*
946
987
      if builder specifically requested a default port, use that
947
988
      (even if it coincides with our factory default).
948
989
      only if they didn't do we check /etc/services (and, failing
949
 
      on that, fall back to the factory default of 4427).
 
990
      on that, fall back to the factory default of 3306).
950
991
      either default can be overridden by the environment variable
951
 
      DRIZZLE_TCP_PORT, which in turn can be overridden with command
 
992
      MYSQL_TCP_PORT, which in turn can be overridden with command
952
993
      line options.
953
994
    */
954
995
 
 
996
#if MYSQL_PORT_DEFAULT == 0
955
997
    struct  servent *serv_ptr;
956
 
    if ((serv_ptr= getservbyname("drizzle", "tcp")))
 
998
    if ((serv_ptr= getservbyname("mysql", "tcp")))
957
999
      mysqld_port= ntohs((u_short) serv_ptr->s_port); /* purecov: inspected */
958
 
 
959
 
    if ((env = getenv("DRIZZLE_TCP_PORT")))
 
1000
#endif
 
1001
    if ((env = getenv("MYSQL_TCP_PORT")))
960
1002
      mysqld_port= (uint) atoi(env);            /* purecov: inspected */
961
 
 
962
 
    assert(mysqld_port);
963
1003
  }
964
1004
}
965
1005
 
979
1019
      /* purecov: begin tested */
980
1020
      tmp_user_info= getpwnam(user);
981
1021
      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"));
 
1022
          global_system_variables.log_warnings)
 
1023
        sql_print_warning(
 
1024
                    "One can only use the --user switch if running as root\n");
985
1025
      /* purecov: end */
986
1026
    }
987
1027
    return NULL;
988
1028
  }
989
1029
  if (!user)
990
1030
  {
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
 
 
 
1031
    if (!opt_bootstrap)
 
1032
    {
 
1033
      sql_print_error("Fatal error: Please read \"Security\" section of the manual to find out how to run mysqld as root!\n");
 
1034
      unireg_abort(1);
 
1035
    }
995
1036
    return NULL;
996
1037
  }
997
1038
  /* purecov: begin tested */
1012
1053
  /* purecov: end */
1013
1054
 
1014
1055
err:
1015
 
  sql_print_error(_("Fatal error: Can't change to run as user '%s' ;  "
1016
 
                    "Please check that the user exists!\n"),user);
 
1056
  sql_print_error("Fatal error: Can't change to run as user '%s' ;  Please check that the user exists!\n",user);
1017
1057
  unireg_abort(1);
1018
1058
 
1019
1059
#ifdef PR_SET_DUMPABLE
1030
1070
static void set_user(const char *user, struct passwd *user_info_arg)
1031
1071
{
1032
1072
  /* purecov: begin tested */
1033
 
  assert(user_info_arg != 0);
 
1073
  DBUG_ASSERT(user_info_arg != 0);
1034
1074
#ifdef HAVE_INITGROUPS
1035
1075
  /*
1036
1076
    We can get a SIGSEGV when calling initgroups() on some systems when NSS
1038
1078
    calling_initgroups as a flag to the SIGSEGV handler that is then used to
1039
1079
    output a specific message to help the user resolve this problem.
1040
1080
  */
1041
 
  calling_initgroups= true;
 
1081
  calling_initgroups= TRUE;
1042
1082
  initgroups((char*) user, user_info_arg->pw_gid);
1043
 
  calling_initgroups= false;
 
1083
  calling_initgroups= FALSE;
1044
1084
#endif
1045
1085
  if (setgid(user_info_arg->pw_gid) == -1)
1046
1086
  {
1058
1098
 
1059
1099
static void set_effective_user(struct passwd *user_info_arg)
1060
1100
{
1061
 
  assert(user_info_arg != 0);
 
1101
  DBUG_ASSERT(user_info_arg != 0);
1062
1102
  if (setregid((gid_t)-1, user_info_arg->pw_gid) == -1)
1063
1103
  {
1064
1104
    sql_perror("setregid");
1086
1126
 
1087
1127
static void network_init(void)
1088
1128
{
 
1129
  int   arg;
1089
1130
  int   ret;
1090
 
  uint32_t  waited;
1091
 
  uint32_t  this_wait;
1092
 
  uint32_t  retry;
 
1131
  uint  waited;
 
1132
  uint  this_wait;
 
1133
  uint  retry;
1093
1134
  char port_buf[NI_MAXSERV];
1094
 
  struct addrinfo *ai;
1095
 
  struct addrinfo *next;
1096
 
  struct addrinfo hints;
1097
 
  int error;
 
1135
  DBUG_ENTER("network_init");
1098
1136
 
1099
1137
  if (thread_scheduler.init())
1100
1138
    unireg_abort(1);                    /* purecov: inspected */
1101
1139
 
1102
1140
  set_ports();
1103
1141
 
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;
 
1142
  if (mysqld_port != 0 && !opt_disable_networking && !opt_bootstrap)
 
1143
  {
 
1144
    struct addrinfo *ai;
 
1145
    struct addrinfo hints;
 
1146
    int error;
 
1147
    DBUG_PRINT("general",("IP Socket is %d",mysqld_port));
 
1148
 
 
1149
    bzero(&hints, sizeof (hints));
 
1150
    hints.ai_flags= AI_PASSIVE;
 
1151
    hints.ai_socktype= SOCK_STREAM;
 
1152
    hints.ai_family= AF_UNSPEC;
 
1153
 
 
1154
    my_snprintf(port_buf, NI_MAXSERV, "%d", mysqld_port);
 
1155
    error= getaddrinfo(my_bind_addr_str, port_buf, &hints, &ai);
 
1156
    if (error != 0)
 
1157
    {
 
1158
      DBUG_PRINT("error",("Got error: %d from getaddrinfo()", error));
 
1159
      sql_perror(ER(ER_IPSOCK_ERROR));          /* purecov: tested */
 
1160
      unireg_abort(1);                          /* purecov: tested */
 
1161
    }
 
1162
 
 
1163
 
 
1164
    ip_sock= socket(ai->ai_family, ai->ai_socktype,
 
1165
                    ai->ai_protocol);
 
1166
 
 
1167
    if (ip_sock == INVALID_SOCKET)
 
1168
    {
 
1169
      DBUG_PRINT("error",("Got error: %d from socket()",socket_errno));
 
1170
      sql_perror(ER(ER_IPSOCK_ERROR));          /* purecov: tested */
 
1171
      unireg_abort(1);                          /* purecov: tested */
 
1172
    }
 
1173
 
 
1174
    /*
 
1175
      We should not use SO_REUSEADDR on windows as this would enable a
 
1176
      user to open two mysqld servers with the same TCP/IP port.
 
1177
    */
 
1178
    arg= 1;
 
1179
    (void) setsockopt(ip_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,sizeof(arg));
1137
1180
 
1138
1181
#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
 
      }
 
1182
     /*
 
1183
       For interoperability with older clients, IPv6 socket should
 
1184
       listen on both IPv6 and IPv4 wildcard addresses.
 
1185
       Turn off IPV6_V6ONLY option.
 
1186
     */
 
1187
    if (ai->ai_family == AF_INET6)
 
1188
    {
 
1189
      arg= 0;      
 
1190
      (void) setsockopt(ip_sock, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&arg,
 
1191
                sizeof(arg));
1173
1192
    }
1174
 
 
1175
 
 
 
1193
#endif
1176
1194
    /*
1177
1195
      Sometimes the port is not released fast enough when stopping and
1178
1196
      restarting the server. This happens quite often with the test suite
1183
1201
    */
1184
1202
    for (waited= 0, retry= 1; ; retry++, waited+= this_wait)
1185
1203
    {
1186
 
      if (((ret= bind(ip_sock, next->ai_addr, next->ai_addrlen)) >= 0 ) ||
1187
 
          (errno != EADDRINUSE) ||
 
1204
      if (((ret= bind(ip_sock, ai->ai_addr, ai->ai_addrlen)) >= 0 ) ||
 
1205
          (socket_errno != SOCKET_EADDRINUSE) ||
1188
1206
          (waited >= mysqld_port_timeout))
1189
1207
        break;
1190
 
      sql_print_information(_("Retrying bind on TCP/IP port %u"), mysqld_port);
 
1208
      sql_print_information("Retrying bind on TCP/IP port %u", mysqld_port);
1191
1209
      this_wait= retry * retry / 3 + 1;
1192
1210
      sleep(this_wait);
1193
1211
    }
 
1212
    freeaddrinfo(ai);
1194
1213
    if (ret < 0)
1195
1214
    {
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);
 
1215
      DBUG_PRINT("error",("Got error: %d from bind",socket_errno));
 
1216
      sql_perror("Can't start server: Bind on TCP/IP port");
 
1217
      sql_print_error("Do you already have another mysqld server running on port: %d ?",mysqld_port);
1199
1218
      unireg_abort(1);
1200
1219
    }
1201
1220
    if (listen(ip_sock,(int) back_log) < 0)
1202
1221
    {
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);
 
1222
      sql_perror("Can't start server: listen() on TCP/IP port");
 
1223
      sql_print_error("listen() on TCP/IP failed with error %d",
 
1224
                      socket_errno);
1206
1225
      unireg_abort(1);
1207
1226
    }
1208
1227
  }
1209
1228
 
1210
 
  freeaddrinfo(ai);
1211
 
  return;
 
1229
  DBUG_PRINT("info",("server started"));
 
1230
  DBUG_VOID_RETURN;
1212
1231
}
1213
1232
 
1214
1233
/**
1221
1240
  @note
1222
1241
    For the connection that is doing shutdown, this is called twice
1223
1242
*/
1224
 
void close_connection(THD *thd, uint32_t errcode, bool lock)
 
1243
void close_connection(THD *thd, uint errcode, bool lock)
1225
1244
{
1226
1245
  st_vio *vio;
 
1246
  DBUG_ENTER("close_connection");
 
1247
  DBUG_PRINT("enter",("fd: %s  error: '%s'",
 
1248
                      thd->net.vio ? vio_description(thd->net.vio) :
 
1249
                      "(not connected)",
 
1250
                      errcode ? ER(errcode) : ""));
1227
1251
  if (lock)
1228
1252
    (void) pthread_mutex_lock(&LOCK_thread_count);
1229
1253
  thd->killed= THD::KILL_CONNECTION;
1231
1255
  {
1232
1256
    if (errcode)
1233
1257
      net_send_error(thd, errcode, ER(errcode)); /* purecov: inspected */
1234
 
    net_close(&(thd->net));             /* vio is freed in delete thd */
 
1258
    vio_close(vio);                     /* vio is freed in delete thd */
1235
1259
  }
1236
1260
  if (lock)
1237
1261
    (void) pthread_mutex_unlock(&LOCK_thread_count);
1238
 
  return;;
 
1262
  DBUG_VOID_RETURN;
1239
1263
}
1240
1264
 
1241
1265
 
1242
1266
/** Called when a thread is aborted. */
1243
1267
/* ARGSUSED */
1244
 
extern "C" RETSIGTYPE end_thread_signal(int sig __attribute__((unused)))
 
1268
extern "C" sig_handler end_thread_signal(int sig __attribute__((unused)))
1245
1269
{
1246
1270
  THD *thd=current_thd;
1247
 
  if (thd)
 
1271
  DBUG_ENTER("end_thread_signal");
 
1272
  if (thd && ! thd->bootstrap)
1248
1273
  {
1249
1274
    statistic_increment(killed_threads, &LOCK_status);
1250
1275
    thread_scheduler.end_thread(thd,0);         /* purecov: inspected */
1251
1276
  }
1252
 
  return;;                              /* purecov: deadcode */
 
1277
  DBUG_VOID_RETURN;                             /* purecov: deadcode */
1253
1278
}
1254
1279
 
1255
1280
 
1266
1291
 
1267
1292
void unlink_thd(THD *thd)
1268
1293
{
 
1294
  DBUG_ENTER("unlink_thd");
 
1295
  DBUG_PRINT("enter", ("thd: 0x%lx", (long) thd));
1269
1296
  thd->cleanup();
1270
1297
 
1271
1298
  pthread_mutex_lock(&LOCK_connection_count);
1275
1302
  (void) pthread_mutex_lock(&LOCK_thread_count);
1276
1303
  thread_count--;
1277
1304
  delete thd;
1278
 
  return;;
 
1305
  DBUG_VOID_RETURN;
1279
1306
}
1280
1307
 
1281
1308
 
1302
1329
      ! abort_loop && !kill_cached_threads)
1303
1330
  {
1304
1331
    /* Don't kill the thread, just put it in cache for reuse */
 
1332
    DBUG_PRINT("info", ("Adding thread to cache"));
1305
1333
    cached_thread_count++;
1306
1334
    while (!abort_loop && ! wake_thread && ! kill_cached_threads)
1307
1335
      (void) pthread_cond_wait(&COND_thread_cache, &LOCK_thread_count);
1351
1379
 
1352
1380
bool one_thread_per_connection_end(THD *thd, bool put_in_cache)
1353
1381
{
 
1382
  DBUG_ENTER("one_thread_per_connection_end");
1354
1383
  unlink_thd(thd);
1355
1384
  if (put_in_cache)
1356
1385
    put_in_cache= cache_thread();
1357
1386
  pthread_mutex_unlock(&LOCK_thread_count);
1358
1387
  if (put_in_cache)
1359
 
    return(0);                             // Thread is reused
 
1388
    DBUG_RETURN(0);                             // Thread is reused
1360
1389
 
1361
1390
  /* It's safe to broadcast outside a lock (COND... is not deleted here) */
 
1391
  DBUG_PRINT("signal", ("Broadcasting COND_thread_count"));
1362
1392
  my_thread_end();
1363
1393
  (void) pthread_cond_broadcast(&COND_thread_count);
1364
1394
 
1365
1395
  pthread_exit(0);
1366
 
  return(0);                               // Impossible
 
1396
  DBUG_RETURN(0);                               // Impossible
1367
1397
}
1368
1398
 
1369
1399
 
1388
1418
  @todo
1389
1419
    One should have to fix that thr_alarm know about this thread too.
1390
1420
*/
1391
 
extern "C" RETSIGTYPE abort_thread(int sig __attribute__((unused)))
 
1421
extern "C" sig_handler abort_thread(int sig __attribute__((unused)))
1392
1422
{
1393
1423
  THD *thd=current_thd;
 
1424
  DBUG_ENTER("abort_thread");
1394
1425
  if (thd)
1395
1426
    thd->killed= THD::KILL_CONNECTION;
1396
 
  return;;
 
1427
  DBUG_VOID_RETURN;
1397
1428
}
1398
1429
#endif
1399
1430
 
1406
1437
#endif
1407
1438
 
1408
1439
 
1409
 
extern "C" RETSIGTYPE handle_segfault(int sig)
 
1440
extern "C" sig_handler handle_segfault(int sig)
1410
1441
{
1411
1442
  time_t curr_time;
1412
1443
  struct tm tm;
 
1444
  THD *thd=current_thd;
1413
1445
 
1414
1446
  /*
1415
1447
    Strictly speaking, one needs a mutex here
1419
1451
  */
1420
1452
  if (segfaulted)
1421
1453
  {
1422
 
    fprintf(stderr, _("Fatal " SIGNAL_FMT " while backtracing\n"), sig);
 
1454
    fprintf(stderr, "Fatal " SIGNAL_FMT " while backtracing\n", sig);
1423
1455
    exit(1);
1424
1456
  }
1425
1457
 
1428
1460
  curr_time= my_time(0);
1429
1461
  localtime_r(&curr_time, &tm);
1430
1462
 
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",
 
1463
  fprintf(stderr,"\
 
1464
%02d%02d%02d %2d:%02d:%02d - mysqld got " SIGNAL_FMT " ;\n\
 
1465
This could be because you hit a bug. It is also possible that this binary\n\
 
1466
or one of the libraries it was linked against is corrupt, improperly built,\n\
 
1467
or misconfigured. This error can also be caused by malfunctioning hardware.\n",
1437
1468
          tm.tm_year % 100, tm.tm_mon+1, tm.tm_mday,
1438
1469
          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);
 
1470
          sig);
 
1471
  fprintf(stderr, "\
 
1472
We will try our best to scrape up some info that will hopefully help diagnose\n\
 
1473
the problem, but since we have already crashed, something is definitely wrong\n\
 
1474
and this may fail.\n\n");
 
1475
  fprintf(stderr, "key_buffer_size=%lu\n",
 
1476
          (ulong) dflt_key_cache->key_cache_mem_size);
1446
1477
  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);
 
1478
  fprintf(stderr, "max_used_connections=%lu\n", max_used_connections);
1448
1479
  fprintf(stderr, "max_threads=%u\n", thread_scheduler.max_threads);
1449
1480
  fprintf(stderr, "thread_count=%u\n", thread_count);
1450
1481
  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 +
 
1482
  fprintf(stderr, "It is possible that mysqld could use up to \n\
 
1483
key_buffer_size + (read_buffer_size + sort_buffer_size)*max_threads = %lu K\n\
 
1484
bytes of memory\n", ((ulong) dflt_key_cache->key_cache_mem_size +
 
1485
                     (global_system_variables.read_buff_size +
 
1486
                      global_system_variables.sortbuff_size) *
 
1487
                     thread_scheduler.max_threads +
1461
1488
                     max_connections * sizeof(THD)) / 1024);
 
1489
  fprintf(stderr, "Hope that's ok; if not, decrease some variables in the equation.\n\n");
1462
1490
 
1463
1491
#ifdef HAVE_STACKTRACE
1464
 
  THD *thd= current_thd;
1465
 
 
1466
1492
  if (!(test_flags & TEST_NO_STACKTRACE))
1467
1493
  {
1468
1494
    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,
 
1495
    fprintf(stderr,"\
 
1496
Attempting backtrace. You can use the following information to find out\n\
 
1497
where mysqld died. If you see no messages after this, something went\n\
 
1498
terribly wrong...\n");  
 
1499
    print_stacktrace(thd ? (uchar*) thd->thread_stack : (uchar*) 0,
1475
1500
                     my_thread_stack_size);
1476
1501
  }
1477
1502
  if (thd)
1494
1519
      kreason= "KILLED_NO_VALUE";
1495
1520
      break;
1496
1521
    }
1497
 
    fprintf(stderr, _("Trying to get some variables.\n"
1498
 
                      "Some pointers may be invalid and cause the "
1499
 
                      "dump to abort...\n"));
 
1522
    fprintf(stderr, "Trying to get some variables.\n\
 
1523
Some pointers may be invalid and cause the dump to abort...\n");
1500
1524
    safe_print_str("thd->query", thd->query, 1024);
1501
 
    fprintf(stderr, "thd->thread_id=%"PRIu32"\n", (uint32_t) thd->thread_id);
 
1525
    fprintf(stderr, "thd->thread_id=%lu\n", (ulong) thd->thread_id);
1502
1526
    fprintf(stderr, "thd->killed=%s\n", kreason);
1503
1527
  }
 
1528
  fprintf(stderr, "\
 
1529
The manual page at http://dev.mysql.com/doc/mysql/en/crashing.html contains\n\
 
1530
information that should help you find out what is causing the crash.\n");
1504
1531
  fflush(stderr);
1505
1532
#endif /* HAVE_STACKTRACE */
1506
1533
 
1507
1534
#ifdef HAVE_INITGROUPS
1508
1535
  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"));
 
1536
    fprintf(stderr, "\n\
 
1537
This crash occured while the server was calling initgroups(). This is\n\
 
1538
often due to the use of a mysqld that is statically linked against glibc\n\
 
1539
and configured to use LDAP in /etc/nsswitch.conf. You will need to either\n\
 
1540
upgrade to a version of glibc that does not have this problem (2.3.4 or\n\
 
1541
later when used with nscd), disable LDAP in your nsswitch.conf, or use a\n\
 
1542
mysqld that is not statically linked.\n");
1520
1543
#endif
1521
1544
 
1522
1545
  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
 
 
 
1546
    fprintf(stderr,"\n\
 
1547
You are running a statically-linked LinuxThreads binary on an NPTL system.\n\
 
1548
This can result in crashes on some distributions due to LT/NPTL conflicts.\n\
 
1549
You should either build a dynamically-linked binary, or force LinuxThreads\n\
 
1550
to be used with the LD_ASSUME_KERNEL environment variable. Please consult\n\
 
1551
the documentation for your distribution on how to do that.\n");
 
1552
  
1534
1553
  if (locked_in_memory)
1535
1554
  {
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"));
 
1555
    fprintf(stderr, "\n\
 
1556
The \"--memlock\" argument, which was enabled, uses system calls that are\n\
 
1557
unreliable and unstable on some operating systems and operating-system\n\
 
1558
versions (notably, some versions of Linux).  This crash could be due to use\n\
 
1559
of those buggy OS calls.  You should consider whether you really need the\n\
 
1560
\"--memlock\" parameter and/or consult the OS distributer about \"mlockall\"\n\
 
1561
bugs.\n");
1547
1562
  }
1548
1563
 
1549
1564
#ifdef HAVE_WRITE_CORE
1550
1565
  if (test_flags & TEST_CORE_ON_SIGNAL)
1551
1566
  {
1552
 
    fprintf(stderr, _("Writing a core file\n"));
 
1567
    fprintf(stderr, "Writing a core file\n");
1553
1568
    fflush(stderr);
1554
1569
    write_core(sig);
1555
1570
  }
1569
1584
{
1570
1585
  sigset_t set;
1571
1586
  struct sigaction sa;
 
1587
  DBUG_ENTER("init_signals");
1572
1588
 
1573
1589
  my_sigset(THR_SERVER_ALARM,print_signal_warning); // Should never be called!
1574
1590
 
1596
1612
    STRUCT_RLIMIT rl;
1597
1613
    rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
1598
1614
    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"));
 
1615
      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
1616
  }
1603
1617
#endif
1604
1618
  (void) sigemptyset(&set);
1633
1647
    sigaddset(&set,SIGINT);
1634
1648
  sigprocmask(SIG_SETMASK,&set,NULL);
1635
1649
  pthread_sigmask(SIG_SETMASK,&set,NULL);
1636
 
  return;;
 
1650
  DBUG_VOID_RETURN;
1637
1651
}
1638
1652
 
1639
1653
 
1641
1655
{
1642
1656
  int error;
1643
1657
  pthread_attr_t thr_attr;
 
1658
  DBUG_ENTER("start_signal_handler");
1644
1659
 
1645
1660
  (void) pthread_attr_init(&thr_attr);
1646
1661
  pthread_attr_setscope(&thr_attr, PTHREAD_SCOPE_SYSTEM);
1647
1662
  (void) pthread_attr_setdetachstate(&thr_attr, PTHREAD_CREATE_DETACHED);
 
1663
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
1648
1664
  {
1649
1665
    struct sched_param tmp_sched_param;
1650
1666
 
1664
1680
  (void) pthread_mutex_lock(&LOCK_thread_count);
1665
1681
  if ((error=pthread_create(&signal_thread,&thr_attr,signal_hand,0)))
1666
1682
  {
1667
 
    sql_print_error(_("Can't create interrupt-thread (error %d, errno: %d)"),
1668
 
                    error,errno);
 
1683
    sql_print_error("Can't create interrupt-thread (error %d, errno: %d)",
 
1684
                    error,errno);
1669
1685
    exit(1);
1670
1686
  }
1671
1687
  (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
1672
1688
  pthread_mutex_unlock(&LOCK_thread_count);
1673
1689
 
1674
1690
  (void) pthread_attr_destroy(&thr_attr);
1675
 
  return;;
 
1691
  DBUG_VOID_RETURN;
1676
1692
}
1677
1693
 
1678
1694
 
1683
1699
  sigset_t set;
1684
1700
  int sig;
1685
1701
  my_thread_init();                             // Init new thread
 
1702
  DBUG_ENTER("signal_hand");
1686
1703
  signal_thread_in_use= 1;
1687
1704
 
1688
1705
  /*
1709
1726
  (void) sigaddset(&set,SIGTSTP);
1710
1727
 
1711
1728
  /* Save pid to this process (or thread on Linux) */
1712
 
  create_pid_file();
 
1729
  if (!opt_bootstrap)
 
1730
    create_pid_file();
1713
1731
 
1714
1732
#ifdef HAVE_STACK_TRACE_ON_SEGV
1715
1733
  if (opt_do_pstack)
1716
1734
  {
1717
 
    sprintf(pstack_file_name,"mysqld-%lu-%%d-%%d.backtrace", (uint32_t)getpid());
 
1735
    sprintf(pstack_file_name,"mysqld-%lu-%%d-%%d.backtrace", (ulong)getpid());
1718
1736
    pstack_install_segv_action(pstack_file_name);
1719
1737
  }
1720
1738
#endif /* HAVE_STACK_TRACE_ON_SEGV */
1743
1761
      while ((error=my_sigwait(&set,&sig)) == EINTR) ;
1744
1762
    if (cleanup_done)
1745
1763
    {
 
1764
      DBUG_PRINT("quit",("signal_handler: calling my_thread_end()"));
1746
1765
      my_thread_end();
1747
1766
      signal_thread_in_use= 0;
1748
1767
      pthread_exit(0);                          // Safety
1752
1771
    case SIGQUIT:
1753
1772
    case SIGKILL:
1754
1773
#ifdef EXTRA_DEBUG
1755
 
      sql_print_information(_("Got signal %d to shutdown mysqld"),sig);
 
1774
      sql_print_information("Got signal %d to shutdown mysqld",sig);
1756
1775
#endif
1757
1776
      /* switch to the old log message processing */
 
1777
      logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,
 
1778
                          opt_log ? LOG_FILE:LOG_NONE);
 
1779
      DBUG_PRINT("info",("Got signal: %d  abort_loop: %d",sig,abort_loop));
1758
1780
      if (!abort_loop)
1759
1781
      {
1760
1782
        abort_loop=1;                           // mark abort for threads
1761
1783
#ifdef USE_ONE_SIGNAL_HAND
1762
1784
        pthread_t tmp;
 
1785
        if (!(opt_specialflag & SPECIAL_NO_PRIOR))
1763
1786
        {
1764
1787
          struct sched_param tmp_sched_param;
1765
1788
 
1769
1792
        }
1770
1793
        if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
1771
1794
                           (void*) &sig))
1772
 
          sql_print_error(_("Can't create thread to kill server"));
 
1795
          sql_print_error("Can't create thread to kill server");
1773
1796
#else
1774
1797
        kill_server((void*) sig);       // MIT THREAD has a alarm thread
1775
1798
#endif
1779
1802
      if (!abort_loop)
1780
1803
      {
1781
1804
        bool not_used;
 
1805
        mysql_print_status();           // Print some debug info
1782
1806
        reload_cache((THD*) 0,
1783
1807
                     (REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
1784
1808
                      REFRESH_GRANT |
1785
1809
                      REFRESH_THREADS | REFRESH_HOSTS),
1786
 
                     (TableList*) 0, &not_used); // Flush logs
 
1810
                     (TABLE_LIST*) 0, &not_used); // Flush logs
 
1811
      }
 
1812
      /* reenable logs after the options were reloaded */
 
1813
      if (log_output_options & LOG_NONE)
 
1814
      {
 
1815
        logger.set_handlers(LOG_FILE,
 
1816
                            opt_slow_log ? LOG_TABLE : LOG_NONE,
 
1817
                            opt_log ? LOG_TABLE : LOG_NONE);
 
1818
      }
 
1819
      else
 
1820
      {
 
1821
        logger.set_handlers(LOG_FILE,
 
1822
                            opt_slow_log ? log_output_options : LOG_NONE,
 
1823
                            opt_log ? log_output_options : LOG_NONE);
1787
1824
      }
1788
1825
      break;
1789
1826
#ifdef USE_ONE_SIGNAL_HAND
1793
1830
#endif
1794
1831
    default:
1795
1832
#ifdef EXTRA_DEBUG
1796
 
      sql_print_warning(_("Got signal: %d  error: %d"),sig,error); /* purecov: tested */
 
1833
      sql_print_warning("Got signal: %d  error: %d",sig,error); /* purecov: tested */
1797
1834
#endif
1798
1835
      break;                                    /* purecov: tested */
1799
1836
    }
1801
1838
  return(0);                                    /* purecov: deadcode */
1802
1839
}
1803
1840
 
1804
 
static void check_data_home(const char *path __attribute__((unused)))
 
1841
static void check_data_home(const char *path)
1805
1842
{}
1806
1843
 
1807
1844
#endif  /* __WIN__*/
1812
1849
  for the client.
1813
1850
*/
1814
1851
/* ARGSUSED */
1815
 
extern "C" void my_message_sql(uint32_t error, const char *str, myf MyFlags);
 
1852
extern "C" void my_message_sql(uint error, const char *str, myf MyFlags);
1816
1853
 
1817
 
void my_message_sql(uint32_t error, const char *str, myf MyFlags)
 
1854
void my_message_sql(uint error, const char *str, myf MyFlags)
1818
1855
{
1819
1856
  THD *thd;
 
1857
  DBUG_ENTER("my_message_sql");
 
1858
  DBUG_PRINT("error", ("error: %u  message: '%s'", error, str));
1820
1859
  /*
1821
1860
    Put here following assertion when situation with EE_* error codes
1822
1861
    will be fixed
 
1862
    DBUG_ASSERT(error != 0);
1823
1863
  */
1824
1864
  if ((thd= current_thd))
1825
1865
  {
1826
1866
    if (MyFlags & ME_FATALERROR)
1827
1867
      thd->is_fatal_error= 1;
1828
1868
 
 
1869
#ifdef BUG_36098_FIXED
 
1870
    mysql_audit_general(thd,MYSQL_AUDIT_GENERAL_ERROR,error,my_time(0),
 
1871
                        0,0,str,str ? strlen(str) : 0,
 
1872
                        thd->query,thd->query_length,
 
1873
                        thd->variables.character_set_client,
 
1874
                        thd->row_count);
 
1875
#endif
 
1876
 
 
1877
 
1829
1878
    /*
1830
1879
      TODO: There are two exceptions mechanism (THD and sp_rcontext),
1831
1880
      this could be improved by having a common stack of handlers.
1832
1881
    */
1833
1882
    if (thd->handle_error(error, str,
1834
 
                          DRIZZLE_ERROR::WARN_LEVEL_ERROR))
1835
 
      return;;
 
1883
                          MYSQL_ERROR::WARN_LEVEL_ERROR))
 
1884
      DBUG_VOID_RETURN;
1836
1885
 
1837
1886
    thd->is_slave_error=  1; // needed to catch query errors during replication
1838
1887
 
1840
1889
      thd->lex->current_select == 0 if lex structure is not inited
1841
1890
      (not query command (COM_QUERY))
1842
1891
    */
1843
 
    if (! (thd->lex->current_select &&
1844
 
        thd->lex->current_select->no_error && !thd->is_fatal_error))
 
1892
    if (thd->lex->current_select &&
 
1893
        thd->lex->current_select->no_error && !thd->is_fatal_error)
 
1894
    {
 
1895
      DBUG_PRINT("error",
 
1896
                 ("Error converted to warning: current_select: no_error %d  "
 
1897
                  "fatal_error: %d",
 
1898
                  (thd->lex->current_select ?
 
1899
                   thd->lex->current_select->no_error : 0),
 
1900
                  (int) thd->is_fatal_error));
 
1901
    }
 
1902
    else
1845
1903
    {
1846
1904
      if (! thd->main_da.is_error())            // Return only first message
1847
1905
      {
1859
1917
        Suppress infinite recursion if there a memory allocation error
1860
1918
        inside push_warning.
1861
1919
      */
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;
 
1920
      thd->no_warnings_for_error= TRUE;
 
1921
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error, str);
 
1922
      thd->no_warnings_for_error= FALSE;
1865
1923
    }
1866
1924
  }
1867
1925
  if (!thd || MyFlags & ME_NOREFRESH)
1868
1926
    sql_print_error("%s: %s",my_progname,str); /* purecov: inspected */
1869
 
  return;;
 
1927
  DBUG_VOID_RETURN;
1870
1928
}
1871
1929
 
1872
1930
 
1881
1939
 
1882
1940
void my_str_free_mysqld(void *ptr)
1883
1941
{
1884
 
  free((unsigned char*)ptr);
 
1942
  my_free((uchar*)ptr, MYF(MY_FAE));
1885
1943
}
1886
1944
 
1887
1945
 
1888
1946
static const char *load_default_groups[]= {
1889
 
"mysqld","server", DRIZZLE_BASE_VERSION, 0, 0};
 
1947
"mysqld","server", MYSQL_BASE_VERSION, 0, 0};
1890
1948
 
1891
1949
 
1892
1950
/**
1905
1963
    1 error
1906
1964
*/
1907
1965
 
1908
 
static bool init_global_datetime_format(enum enum_drizzle_timestamp_type format_type,
 
1966
static bool init_global_datetime_format(timestamp_type format_type,
1909
1967
                                        DATE_TIME_FORMAT **var_ptr)
1910
1968
{
1911
1969
  /* Get command line option */
1923
1981
  }
1924
1982
  if (!(*var_ptr= date_time_format_make(format_type, str, strlen(str))))
1925
1983
  {
1926
 
    fprintf(stderr, _("Wrong date/time format specifier: %s\n"), str);
 
1984
    fprintf(stderr, "Wrong date/time format specifier: %s\n", str);
1927
1985
    return 1;
1928
1986
  }
1929
1987
  return 0;
1933
1991
  {"admin_commands",       (char*) offsetof(STATUS_VAR, com_other), SHOW_LONG_STATUS},
1934
1992
  {"assign_to_keycache",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ASSIGN_TO_KEYCACHE]), SHOW_LONG_STATUS},
1935
1993
  {"alter_db",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB]), SHOW_LONG_STATUS},
 
1994
  {"alter_db_upgrade",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB_UPGRADE]), SHOW_LONG_STATUS},
1936
1995
  {"alter_table",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_TABLE]), SHOW_LONG_STATUS},
 
1996
  {"alter_tablespace",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_TABLESPACE]), SHOW_LONG_STATUS},
1937
1997
  {"analyze",              (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ANALYZE]), SHOW_LONG_STATUS},
1938
1998
  {"begin",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BEGIN]), SHOW_LONG_STATUS},
1939
1999
  {"binlog",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BINLOG_BASE64_EVENT]), SHOW_LONG_STATUS},
1971
2031
  {"savepoint",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SAVEPOINT]), SHOW_LONG_STATUS},
1972
2032
  {"select",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SELECT]), SHOW_LONG_STATUS},
1973
2033
  {"set_option",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SET_OPTION]), SHOW_LONG_STATUS},
 
2034
  {"show_binlog_events",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOG_EVENTS]), SHOW_LONG_STATUS},
1974
2035
  {"show_binlogs",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOGS]), SHOW_LONG_STATUS},
 
2036
  {"show_charsets",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CHARSETS]), SHOW_LONG_STATUS},
 
2037
  {"show_collations",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLLATIONS]), SHOW_LONG_STATUS},
1975
2038
  {"show_create_db",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE_DB]), SHOW_LONG_STATUS},
1976
2039
  {"show_create_table",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE]), SHOW_LONG_STATUS},
1977
2040
  {"show_databases",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_DATABASES]), SHOW_LONG_STATUS},
1983
2046
  {"show_open_tables",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_OPEN_TABLES]), SHOW_LONG_STATUS},
1984
2047
  {"show_plugins",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PLUGINS]), SHOW_LONG_STATUS},
1985
2048
  {"show_processlist",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PROCESSLIST]), SHOW_LONG_STATUS},
 
2049
  {"show_slave_hosts",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_HOSTS]), SHOW_LONG_STATUS},
1986
2050
  {"show_slave_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_STAT]), SHOW_LONG_STATUS},
1987
2051
  {"show_status",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},
1988
2052
  {"show_table_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLE_STATUS]), SHOW_LONG_STATUS},
1991
2055
  {"show_warnings",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_WARNS]), SHOW_LONG_STATUS},
1992
2056
  {"slave_start",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_START]), SHOW_LONG_STATUS},
1993
2057
  {"slave_stop",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_STOP]), SHOW_LONG_STATUS},
 
2058
  {"stmt_close",           (char*) offsetof(STATUS_VAR, com_stmt_close), SHOW_LONG_STATUS},
1994
2059
  {"truncate",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_TRUNCATE]), SHOW_LONG_STATUS},
1995
2060
  {"unlock_tables",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UNLOCK_TABLES]), SHOW_LONG_STATUS},
1996
2061
  {"update",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE]), SHOW_LONG_STATUS},
1997
2062
  {"update_multi",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE_MULTI]), SHOW_LONG_STATUS},
1998
 
  {NULL, NULL, SHOW_LONG}
 
2063
  {NullS, NullS, SHOW_LONG}
1999
2064
};
2000
2065
 
2001
2066
static int init_common_variables(const char *conf_file_name, int argc,
2002
2067
                                 char **argv, const char **groups)
2003
2068
{
 
2069
  char buff[FN_REFLEN], *s;
2004
2070
  umask(((~my_umask) & 0666));
2005
2071
  my_decimal_set_zero(&decimal_zero); // set decimal_zero constant;
2006
2072
  tzset();                      // Set tzname
2007
2073
 
2008
 
  max_system_variables.pseudo_thread_id= UINT32_MAX;
 
2074
  max_system_variables.pseudo_thread_id= (ulong)~0;
2009
2075
  server_start_time= flush_status_time= my_time(0);
2010
2076
  rpl_filter= new Rpl_filter;
2011
2077
  binlog_filter= new Rpl_filter;
2012
 
  if (!rpl_filter || !binlog_filter)
 
2078
  if (!rpl_filter || !binlog_filter) 
2013
2079
  {
2014
2080
    sql_perror("Could not allocate replication and binlog filters");
2015
2081
    exit(1);
2037
2103
  global_system_variables.time_zone= my_tz_SYSTEM;
2038
2104
 
2039
2105
  /*
2040
 
    Init mutexes for the global DRIZZLE_BIN_LOG objects.
 
2106
    Init mutexes for the global MYSQL_BIN_LOG objects.
2041
2107
    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
 
2108
    global MYSQL_BIN_LOGs in their constructors, because then they would be
2043
2109
    inited before MY_INIT(). So we do it here.
2044
2110
  */
2045
2111
  mysql_bin_log.init_pthread_objects();
2047
2113
  if (gethostname(glob_hostname,sizeof(glob_hostname)) < 0)
2048
2114
  {
2049
2115
    strmake(glob_hostname, STRING_WITH_LEN("localhost"));
2050
 
    sql_print_warning(_("gethostname failed, using '%s' as hostname"),
 
2116
    sql_print_warning("gethostname failed, using '%s' as hostname",
2051
2117
                      glob_hostname);
2052
2118
    strmake(pidfile_name, STRING_WITH_LEN("mysql"));
2053
2119
  }
2054
2120
  else
2055
2121
  strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
2056
 
  my_stpcpy(fn_ext(pidfile_name),".pid");               // Add proper extension
 
2122
  strmov(fn_ext(pidfile_name),".pid");          // Add proper extension
2057
2123
 
2058
2124
  /*
2059
2125
    Add server status variables to the dynamic list of
2064
2130
  if (add_status_vars(status_vars))
2065
2131
    return 1; // an error was already reported
2066
2132
 
 
2133
#ifndef DBUG_OFF
 
2134
  /*
 
2135
    We have few debug-only commands in com_status_vars, only visible in debug
 
2136
    builds. for simplicity we enable the assert only in debug builds
 
2137
 
 
2138
    There are 7 Com_ variables which don't have corresponding SQLCOM_ values:
 
2139
    (TODO strictly speaking they shouldn't be here, should not have Com_ prefix
 
2140
    that is. Perhaps Stmt_ ? Comstmt_ ? Prepstmt_ ?)
 
2141
 
 
2142
      Com_admin_commands       => com_other
 
2143
      Com_stmt_close           => com_stmt_close
 
2144
      Com_stmt_execute         => com_stmt_execute
 
2145
      Com_stmt_fetch           => com_stmt_fetch
 
2146
      Com_stmt_prepare         => com_stmt_prepare
 
2147
      Com_stmt_reset           => com_stmt_reset
 
2148
      Com_stmt_send_long_data  => com_stmt_send_long_data
 
2149
 
 
2150
    With this correction the number of Com_ variables (number of elements in
 
2151
    the array, excluding the last element - terminator) must match the number
 
2152
    of SQLCOM_ constants.
 
2153
  */
 
2154
  compile_time_assert(sizeof(com_status_vars)/sizeof(com_status_vars[0]) - 1 ==
 
2155
                     SQLCOM_END + 7);
 
2156
#endif
 
2157
 
2067
2158
  load_defaults(conf_file_name, groups, &argc, &argv);
2068
2159
  defaults_argv=argv;
2069
2160
  defaults_argc=argc;
2070
2161
  get_options(&defaults_argc, defaults_argv);
2071
2162
  set_server_version();
2072
2163
 
 
2164
  DBUG_PRINT("info",("%s  Ver %s for %s on %s\n",my_progname,
 
2165
                     server_version, SYSTEM_TYPE,MACHINE_TYPE));
2073
2166
 
2074
2167
  /* connections and databases needs lots of files */
2075
2168
  {
2076
 
    uint32_t files, wanted_files, max_open_files;
 
2169
    uint files, wanted_files, max_open_files;
2077
2170
 
2078
2171
    /* MyISAM requires two file handles per table. */
2079
2172
    wanted_files= 10+max_connections+table_cache_size*2;
2087
2180
      can't get max_connections*5 but still got no less than was
2088
2181
      requested (value of wanted_files).
2089
2182
    */
2090
 
    max_open_files= cmax(cmax((uint32_t)wanted_files, max_connections*5),
2091
 
                         open_files_limit);
 
2183
    max_open_files= max(max(wanted_files, max_connections*5),
 
2184
                        open_files_limit);
2092
2185
    files= my_set_max_open_files(max_open_files);
2093
2186
 
2094
2187
    if (files < wanted_files)
2099
2192
          If we have requested too much file handles than we bring
2100
2193
          max_connections in supported bounds.
2101
2194
        */
2102
 
        max_connections= (uint32_t) cmin((uint32_t)files-10-TABLE_OPEN_CACHE_MIN*2,
 
2195
        max_connections= (ulong) min(files-10-TABLE_OPEN_CACHE_MIN*2,
2103
2196
                                     max_connections);
2104
2197
        /*
2105
2198
          Decrease table_cache_size according to max_connections, but
2106
 
          not below TABLE_OPEN_CACHE_MIN.  Outer cmin() ensures that we
 
2199
          not below TABLE_OPEN_CACHE_MIN.  Outer min() ensures that we
2107
2200
          never increase table_cache_size automatically (that could
2108
2201
          happen if max_connections is decreased above).
2109
2202
        */
2110
 
        table_cache_size= (uint32_t) cmin(cmax((files-10-max_connections)/2,
2111
 
                                          (uint32_t)TABLE_OPEN_CACHE_MIN),
 
2203
        table_cache_size= (ulong) min(max((files-10-max_connections)/2,
 
2204
                                          TABLE_OPEN_CACHE_MIN),
2112
2205
                                      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);
 
2206
        DBUG_PRINT("warning",
 
2207
                   ("Changed limits: max_open_files: %u  max_connections: %ld  table_cache: %ld",
 
2208
                    files, max_connections, table_cache_size));
 
2209
        if (global_system_variables.log_warnings)
 
2210
          sql_print_warning("Changed limits: max_open_files: %u  max_connections: %ld  table_cache: %ld",
 
2211
                        files, max_connections, table_cache_size);
2117
2212
      }
2118
2213
      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);
 
2214
        sql_print_warning("Could not increase number of max_open_files to more than %u (request: %u)", files, wanted_files);
2122
2215
    }
2123
2216
    open_files_limit= files;
2124
2217
  }
2125
 
  unireg_init(0); /* Set up extern variabels */
 
2218
  unireg_init(opt_specialflag); /* Set up extern variabels */
2126
2219
  if (init_errmessage())        /* Read error messages from file */
2127
2220
    return 1;
 
2221
  init_client_errs();
2128
2222
  lex_init();
2129
2223
  if (item_create_init())
2130
2224
    return 1;
2133
2227
    return 1;
2134
2228
  if (init_replication_sys_vars())
2135
2229
    return 1;
 
2230
  mysys_uses_curses=0;
2136
2231
  /*
2137
2232
    Process a comma-separated character set list and choose
2138
2233
    the first available character set. This is mostly for
2162
2257
 
2163
2258
  if (default_collation_name)
2164
2259
  {
2165
 
    const CHARSET_INFO * const default_collation=
2166
 
      get_charset_by_name(default_collation_name, MYF(0));
 
2260
    CHARSET_INFO *default_collation;
 
2261
    default_collation= get_charset_by_name(default_collation_name, MYF(0));
2167
2262
    if (!default_collation)
2168
2263
    {
2169
 
      sql_print_error(_(ER(ER_UNKNOWN_COLLATION)), default_collation_name);
 
2264
      sql_print_error(ER(ER_UNKNOWN_COLLATION), default_collation_name);
2170
2265
      return 1;
2171
2266
    }
2172
2267
    if (!my_charset_same(default_charset_info, default_collation))
2173
2268
    {
2174
 
      sql_print_error(_(ER(ER_COLLATION_CHARSET_MISMATCH)),
2175
 
                      default_collation_name,
2176
 
                      default_charset_info->csname);
 
2269
      sql_print_error(ER(ER_COLLATION_CHARSET_MISMATCH),
 
2270
                      default_collation_name,
 
2271
                      default_charset_info->csname);
2177
2272
      return 1;
2178
2273
    }
2179
2274
    default_charset_info= default_collation;
2188
2283
  global_system_variables.optimizer_use_mrr= 1;
2189
2284
  global_system_variables.optimizer_switch= 0;
2190
2285
 
2191
 
  if (!(character_set_filesystem=
 
2286
  if (!(character_set_filesystem= 
2192
2287
        get_charset_by_csname(character_set_filesystem_name,
2193
2288
                              MY_CS_PRIMARY, MYF(MY_WME))))
2194
2289
    return 1;
2197
2292
  if (!(my_default_lc_time_names=
2198
2293
        my_locale_by_name(lc_time_names_name)))
2199
2294
  {
2200
 
    sql_print_error(_("Unknown locale: '%s'"), lc_time_names_name);
 
2295
    sql_print_error("Unknown locale: '%s'", lc_time_names_name);
2201
2296
    return 1;
2202
2297
  }
2203
2298
  global_system_variables.lc_time_names= my_default_lc_time_names;
2204
 
 
 
2299
  
2205
2300
  sys_init_connect.value_length= 0;
2206
2301
  if ((sys_init_connect.value= opt_init_connect))
2207
2302
    sys_init_connect.value_length= strlen(opt_init_connect);
2214
2309
  else
2215
2310
    sys_init_slave.value=my_strdup("",MYF(0));
2216
2311
 
 
2312
  /* check log options and issue warnings if needed */
 
2313
  if (opt_log && opt_logname && !(log_output_options & LOG_FILE) &&
 
2314
      !(log_output_options & LOG_NONE))
 
2315
    sql_print_warning("Although a path was specified for the "
 
2316
                      "--log option, log tables are used. "
 
2317
                      "To enable logging to files use the --log-output option.");
 
2318
 
 
2319
  if (opt_slow_log && opt_slow_logname && !(log_output_options & LOG_FILE)
 
2320
      && !(log_output_options & LOG_NONE))
 
2321
    sql_print_warning("Although a path was specified for the "
 
2322
                      "--log-slow-queries option, log tables are used. "
 
2323
                      "To enable logging to files use the --log-output=file option.");
 
2324
 
 
2325
  s= opt_logname ? opt_logname : make_default_log_name(buff, ".log");
 
2326
  sys_var_general_log_path.value= my_strdup(s, MYF(0));
 
2327
  sys_var_general_log_path.value_length= strlen(s);
 
2328
 
 
2329
  s= opt_slow_logname ? opt_slow_logname : make_default_log_name(buff, "-slow.log");
 
2330
  sys_var_slow_log_path.value= my_strdup(s, MYF(0));
 
2331
  sys_var_slow_log_path.value_length= strlen(s);
 
2332
 
2217
2333
  if (use_temp_pool && bitmap_init(&temp_pool,0,1024,1))
2218
2334
    return 1;
2219
2335
  if (my_database_names_init())
2220
2336
    return 1;
2221
2337
 
 
2338
  /*
 
2339
    Ensure that lower_case_table_names is set on system where we have case
 
2340
    insensitive names.  If this is not done the users MyISAM tables will
 
2341
    get corrupted if accesses with names of different case.
 
2342
  */
 
2343
  DBUG_PRINT("info", ("lower_case_table_names: %d", lower_case_table_names));
 
2344
  lower_case_file_system= test_if_case_insensitive(mysql_real_data_home);
 
2345
  if (!lower_case_table_names && lower_case_file_system == 1)
 
2346
  {
 
2347
    if (lower_case_table_names_used)
 
2348
    {
 
2349
      if (global_system_variables.log_warnings)
 
2350
        sql_print_warning("\
 
2351
You have forced lower_case_table_names to 0 through a command-line \
 
2352
option, even though your file system '%s' is case insensitive.  This means \
 
2353
that you can corrupt a MyISAM table by accessing it with different cases. \
 
2354
You should consider changing lower_case_table_names to 1 or 2",
 
2355
                        mysql_real_data_home);
 
2356
    }
 
2357
    else
 
2358
    {
 
2359
      if (global_system_variables.log_warnings)
 
2360
        sql_print_warning("Setting lower_case_table_names=2 because file system for %s is case insensitive", mysql_real_data_home);
 
2361
      lower_case_table_names= 2;
 
2362
    }
 
2363
  }
 
2364
  else if (lower_case_table_names == 2 &&
 
2365
           !(lower_case_file_system=
 
2366
             (test_if_case_insensitive(mysql_real_data_home) == 1)))
 
2367
  {
 
2368
    if (global_system_variables.log_warnings)
 
2369
      sql_print_warning("lower_case_table_names was set to 2, even though your "
 
2370
                        "the file system '%s' is case sensitive.  Now setting "
 
2371
                        "lower_case_table_names to 0 to avoid future problems.",
 
2372
                        mysql_real_data_home);
 
2373
    lower_case_table_names= 0;
 
2374
  }
 
2375
  else
 
2376
  {
 
2377
    lower_case_file_system=
 
2378
      (test_if_case_insensitive(mysql_real_data_home) == 1);
 
2379
  }
2222
2380
 
2223
2381
  /* 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;
 
2382
  table_alias_charset= (lower_case_table_names ?
 
2383
                        files_charset_info :
 
2384
                        &my_charset_bin);
2226
2385
 
2227
2386
  return 0;
2228
2387
}
2234
2393
  (void) pthread_mutex_init(&LOCK_lock_db,MY_MUTEX_INIT_SLOW);
2235
2394
  (void) pthread_mutex_init(&LOCK_open, NULL);
2236
2395
  (void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);
 
2396
  (void) pthread_mutex_init(&LOCK_mapped_file,MY_MUTEX_INIT_SLOW);
2237
2397
  (void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);
2238
2398
  (void) pthread_mutex_init(&LOCK_error_log,MY_MUTEX_INIT_FAST);
 
2399
  (void) pthread_mutex_init(&LOCK_manager,MY_MUTEX_INIT_FAST);
 
2400
  (void) pthread_mutex_init(&LOCK_crypt,MY_MUTEX_INIT_FAST);
2239
2401
  (void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);
2240
2402
  (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
2241
2403
  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
2250
2412
  (void) pthread_cond_init(&COND_global_read_lock,NULL);
2251
2413
  (void) pthread_cond_init(&COND_thread_cache,NULL);
2252
2414
  (void) pthread_cond_init(&COND_flush_thread_cache,NULL);
 
2415
  (void) pthread_cond_init(&COND_manager,NULL);
 
2416
  (void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);
 
2417
  (void) pthread_cond_init(&COND_rpl_status, NULL);
2253
2418
 
2254
2419
  /* Parameter for threads created for connections */
2255
2420
  (void) pthread_attr_init(&connection_attrib);
2256
2421
  (void) pthread_attr_setdetachstate(&connection_attrib,
2257
2422
                                     PTHREAD_CREATE_DETACHED);
2258
2423
  pthread_attr_setscope(&connection_attrib, PTHREAD_SCOPE_SYSTEM);
 
2424
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
2259
2425
  {
2260
2426
    struct sched_param tmp_sched_param;
2261
2427
 
2267
2433
  if (pthread_key_create(&THR_THD,NULL) ||
2268
2434
      pthread_key_create(&THR_MALLOC,NULL))
2269
2435
  {
2270
 
    sql_print_error(_("Can't create thread-keys"));
 
2436
    sql_print_error("Can't create thread-keys");
2271
2437
    return 1;
2272
2438
  }
2273
2439
  return 0;
2276
2442
 
2277
2443
static int init_server_components()
2278
2444
{
 
2445
  DBUG_ENTER("init_server_components");
2279
2446
  /*
2280
2447
    We need to call each of these following functions to ensure that
2281
2448
    all things are initialized so that unireg_abort() doesn't fail
2283
2450
  if (table_cache_init() | table_def_init())
2284
2451
    unireg_abort(1);
2285
2452
 
2286
 
  randominit(&sql_rand,(uint32_t) server_start_time,(uint32_t) server_start_time/2);
 
2453
  randominit(&sql_rand,(ulong) server_start_time,(ulong) server_start_time/2);
2287
2454
  setup_fpu();
2288
2455
  init_thr_lock();
 
2456
  init_slave_list();
2289
2457
 
2290
2458
  /* Setup logs */
2291
2459
 
2313
2481
 
2314
2482
  if (xid_cache_init())
2315
2483
  {
2316
 
    sql_print_error(_("Out of memory"));
2317
 
    unireg_abort(1);
2318
 
  }
2319
 
 
 
2484
    sql_print_error("Out of memory");
 
2485
    unireg_abort(1);
 
2486
  }
 
2487
 
 
2488
  /* need to configure logging before initializing storage engines */
 
2489
  if (opt_update_log)
 
2490
  {
 
2491
    /*
 
2492
      Update log is removed since 5.0. But we still accept the option.
 
2493
      The idea is if the user already uses the binlog and the update log,
 
2494
      we completely ignore any option/variable related to the update log, like
 
2495
      if the update log did not exist. But if the user uses only the update
 
2496
      log, then we translate everything into binlog for him (with warnings).
 
2497
      Implementation of the above :
 
2498
      - If mysqld is started with --log-update and --log-bin,
 
2499
      ignore --log-update (print a warning), push a warning when SQL_LOG_UPDATE
 
2500
      is used, and turn off --sql-bin-update-same.
 
2501
      This will completely ignore SQL_LOG_UPDATE
 
2502
      - If mysqld is started with --log-update only,
 
2503
      change it to --log-bin (with the filename passed to log-update,
 
2504
      plus '-bin') (print a warning), push a warning when SQL_LOG_UPDATE is
 
2505
      used, and turn on --sql-bin-update-same.
 
2506
      This will translate SQL_LOG_UPDATE to SQL_LOG_BIN.
 
2507
 
 
2508
      Note that we tell the user that --sql-bin-update-same is deprecated and
 
2509
      does nothing, and we don't take into account if he used this option or
 
2510
      not; but internally we give this variable a value to have the behaviour
 
2511
      we want (i.e. have SQL_LOG_UPDATE influence SQL_LOG_BIN or not).
 
2512
      As sql-bin-update-same, log-update and log-bin cannot be changed by the
 
2513
      user after starting the server (they are not variables), the user will
 
2514
      not later interfere with the settings we do here.
 
2515
    */
 
2516
    if (opt_bin_log)
 
2517
    {
 
2518
      opt_sql_bin_update= 0;
 
2519
      sql_print_error("The update log is no longer supported by MySQL in \
 
2520
version 5.0 and above. It is replaced by the binary log.");
 
2521
    }
 
2522
    else
 
2523
    {
 
2524
      opt_sql_bin_update= 1;
 
2525
      opt_bin_log= 1;
 
2526
      if (opt_update_logname)
 
2527
      {
 
2528
        /* as opt_bin_log==0, no need to free opt_bin_logname */
 
2529
        if (!(opt_bin_logname= my_strdup(opt_update_logname, MYF(MY_WME))))
 
2530
          exit(EXIT_OUT_OF_MEMORY);
 
2531
        sql_print_error("The update log is no longer supported by MySQL in \
 
2532
version 5.0 and above. It is replaced by the binary log. Now starting MySQL \
 
2533
with --log-bin='%s' instead.",opt_bin_logname);
 
2534
      }
 
2535
      else
 
2536
        sql_print_error("The update log is no longer supported by MySQL in \
 
2537
version 5.0 and above. It is replaced by the binary log. Now starting MySQL \
 
2538
with --log-bin instead.");
 
2539
    }
 
2540
  }
 
2541
  if (opt_log_slave_updates && !opt_bin_log)
 
2542
  {
 
2543
    sql_print_error("You need to use --log-bin to make "
 
2544
                    "--log-slave-updates work.");
 
2545
    unireg_abort(1);
 
2546
  }
2320
2547
  if (!opt_bin_log)
2321
2548
    if (opt_binlog_format_id != BINLOG_FORMAT_UNSPEC)
2322
 
    {
2323
 
      sql_print_error(_("You need to use --log-bin to make "
2324
 
                        "--binlog-format work."));
2325
 
      unireg_abort(1);
2326
 
    }
 
2549
  {
 
2550
    sql_print_error("You need to use --log-bin to make "
 
2551
                    "--binlog-format work.");
 
2552
    unireg_abort(1);
 
2553
  }
2327
2554
    else
2328
 
    {
 
2555
  {
2329
2556
      global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;
2330
2557
    }
2331
2558
  else
2332
2559
    if (opt_binlog_format_id == BINLOG_FORMAT_UNSPEC)
2333
2560
      global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;
2334
2561
    else
2335
 
    {
2336
 
      assert(global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC);
2337
 
    }
 
2562
    { 
 
2563
      DBUG_ASSERT(global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC);
 
2564
  }
2338
2565
 
2339
2566
  /* Check that we have not let the format to unspecified at this point */
2340
 
  assert((uint)global_system_variables.binlog_format <=
 
2567
  DBUG_ASSERT((uint)global_system_variables.binlog_format <=
2341
2568
              array_elements(binlog_format_names)-1);
2342
2569
 
2343
2570
  if (opt_log_slave_updates && replicate_same_server_id)
2344
2571
  {
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."));
 
2572
    sql_print_error("\
 
2573
using --replicate-same-server-id in conjunction with \
 
2574
--log-slave-updates is impossible, it would lead to infinite loops in this \
 
2575
server.");
2348
2576
    unireg_abort(1);
2349
2577
  }
2350
2578
 
2362
2590
        require a name. But as we don't want to break many existing setups, we
2363
2591
        only give warning, not error.
2364
2592
      */
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);
 
2593
      sql_print_warning("No argument was provided to --log-bin, and "
 
2594
                        "--log-bin-index was not used; so replication "
 
2595
                        "may break when this MySQL server acts as a "
 
2596
                        "master and has his hostname changed!! Please "
 
2597
                        "use '--log-bin=%s' to avoid this problem.", ln);
2370
2598
    }
2371
2599
    if (ln == buf)
2372
2600
    {
2373
 
      free(opt_bin_logname);
 
2601
      my_free(opt_bin_logname, MYF(MY_ALLOW_ZERO_PTR));
2374
2602
      opt_bin_logname=my_strdup(buf, MYF(0));
2375
2603
    }
2376
2604
    if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln))
2390
2618
 
2391
2619
  /* Allow storage engine to give real error messages */
2392
2620
  if (ha_init_errors())
2393
 
    return(1);
 
2621
    DBUG_RETURN(1);
2394
2622
 
2395
2623
  if (plugin_init(&defaults_argc, defaults_argv,
2396
2624
                  (opt_noacl ? PLUGIN_INIT_SKIP_PLUGIN_TABLE : 0) |
2397
2625
                  (opt_help ? PLUGIN_INIT_SKIP_INITIALIZATION : 0)))
2398
2626
  {
2399
 
    sql_print_error(_("Failed to initialize plugins."));
 
2627
    sql_print_error("Failed to initialize plugins.");
2400
2628
    unireg_abort(1);
2401
2629
  }
2402
2630
 
2426
2654
 
2427
2655
    if (defaults_argc)
2428
2656
    {
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"),
 
2657
      fprintf(stderr, "%s: Too many arguments (first extra is '%s').\n"
 
2658
              "Use --verbose --help to get a list of available options\n",
2432
2659
              my_progname, *tmp_argv);
2433
2660
      unireg_abort(1);
2434
2661
    }
2435
2662
  }
2436
2663
 
 
2664
  /* if the errmsg.sys is not loaded, terminate to maintain behaviour */
 
2665
  if (!errmesg[0][0])
 
2666
    unireg_abort(1);
 
2667
 
2437
2668
  /* We have to initialize the storage engines before CSV logging */
2438
2669
  if (ha_init())
2439
2670
  {
2440
 
    sql_print_error(_("Can't init databases"));
 
2671
    sql_print_error("Can't init databases");
2441
2672
    unireg_abort(1);
2442
2673
  }
2443
2674
 
 
2675
  logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,
 
2676
                      opt_log ? LOG_FILE:LOG_NONE);
 
2677
 
2444
2678
  /*
2445
2679
    Check that the default storage engine is actually available.
2446
2680
  */
2450
2684
                       strlen(default_storage_engine_str) };
2451
2685
    plugin_ref plugin;
2452
2686
    handlerton *hton;
2453
 
 
 
2687
    
2454
2688
    if ((plugin= ha_resolve_by_name(0, &name)))
2455
 
    {
2456
 
      hton= plugin_data(plugin,handlerton *);
2457
 
    }
 
2689
      hton= plugin_data(plugin, handlerton*);
2458
2690
    else
2459
2691
    {
2460
 
      sql_print_error(_("Unknown/unsupported table type: %s"),
 
2692
      sql_print_error("Unknown/unsupported table type: %s",
2461
2693
                      default_storage_engine_str);
2462
2694
      unireg_abort(1);
2463
2695
    }
2464
2696
    if (!ha_storage_engine_is_enabled(hton))
2465
2697
    {
2466
 
      sql_print_error(_("Default storage engine (%s) is not available"),
2467
 
                      default_storage_engine_str);
2468
 
      unireg_abort(1);
2469
 
      assert(global_system_variables.table_plugin);
 
2698
      if (!opt_bootstrap)
 
2699
      {
 
2700
        sql_print_error("Default storage engine (%s) is not available",
 
2701
                        default_storage_engine_str);
 
2702
        unireg_abort(1);
 
2703
      }
 
2704
      DBUG_ASSERT(global_system_variables.table_plugin);
2470
2705
    }
2471
2706
    else
2472
2707
    {
2473
2708
      /*
2474
 
        Need to unlock as global_system_variables.table_plugin
 
2709
        Need to unlock as global_system_variables.table_plugin 
2475
2710
        was acquired during plugin_init()
2476
2711
      */
2477
2712
      plugin_unlock(0, global_system_variables.table_plugin);
2486
2721
 
2487
2722
  if (tc_log->open(opt_bin_log ? opt_bin_logname : opt_tc_log_file))
2488
2723
  {
2489
 
    sql_print_error(_("Can't initialize tc_log"));
 
2724
    sql_print_error("Can't init tc log");
2490
2725
    unireg_abort(1);
2491
2726
  }
2492
2727
 
2506
2741
      mysql_bin_log.purge_logs_before_date(purge_time);
2507
2742
  }
2508
2743
 
 
2744
  if (opt_myisam_log)
 
2745
    (void) mi_log(1);
 
2746
 
2509
2747
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
2510
2748
  if (locked_in_memory && !getuid())
2511
2749
  {
2517
2755
    if (mlockall(MCL_CURRENT))
2518
2756
    {
2519
2757
      if (global_system_variables.log_warnings)
2520
 
        sql_print_warning(_("Failed to lock memory. Errno: %d\n"),errno);
 
2758
        sql_print_warning("Failed to lock memory. Errno: %d\n",errno);
2521
2759
      locked_in_memory= 0;
2522
2760
    }
2523
2761
    if (user_info)
2527
2765
#endif
2528
2766
    locked_in_memory=0;
2529
2767
 
 
2768
  ft_init_stopwords();
 
2769
 
2530
2770
  init_update_queries();
2531
 
  return(0);
 
2771
  DBUG_RETURN(0);
 
2772
}
 
2773
 
 
2774
 
 
2775
static void create_maintenance_thread()
 
2776
{
 
2777
  if (flush_time && flush_time != ~(ulong) 0L)
 
2778
  {
 
2779
    pthread_t hThread;
 
2780
    if (pthread_create(&hThread,&connection_attrib,handle_manager,0))
 
2781
      sql_print_warning("Can't create thread to manage maintenance");
 
2782
  }
2532
2783
}
2533
2784
 
2534
2785
 
2535
2786
int main(int argc, char **argv)
2536
2787
{
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
2788
  MY_INIT(argv[0]);             // init my_sys library & pthreads
2546
2789
  /* nothing should come before this line ^^^ */
2547
2790
 
2566
2809
  }
2567
2810
#endif
2568
2811
 
2569
 
  if (init_common_variables(DRIZZLE_CONFIG_NAME,
 
2812
  if (init_common_variables(MYSQL_CONFIG_NAME,
2570
2813
                            argc, argv, load_default_groups))
2571
2814
    unireg_abort(1);                            // Will do exit
2572
2815
 
2573
2816
  init_signals();
 
2817
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
 
2818
  {
 
2819
    struct sched_param tmp_sched_param;
2574
2820
 
 
2821
    memset(&tmp_sched_param, 0, sizeof(tmp_sched_param));
 
2822
    tmp_sched_param.sched_priority= my_thread_stack_size*2;
 
2823
    (void)pthread_setschedparam(pthread_self(), SCHED_OTHER, &tmp_sched_param);
 
2824
  }
2575
2825
  pthread_attr_setstacksize(&connection_attrib,my_thread_stack_size);
2576
 
 
2577
2826
#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE
2578
2827
  {
2579
2828
    /* Retrieve used stack size;  Needed for checking stack overflows */
2583
2832
    if (stack_size && stack_size < my_thread_stack_size)
2584
2833
    {
2585
2834
      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
 
      }
 
2835
        sql_print_warning("Asked for %lu thread stack, but got %ld",
 
2836
                          my_thread_stack_size, (long) stack_size);
2592
2837
      my_thread_stack_size= stack_size;
2593
2838
    }
2594
2839
  }
2622
2867
  {
2623
2868
    server_id= 1;
2624
2869
#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."));
 
2870
    sql_print_warning("You have enabled the binary log, but you haven't set "
 
2871
                      "server-id to a non-zero value: we force server id to 1; "
 
2872
                      "updates will be logged to the binary log, but "
 
2873
                      "connections from slaves will not be accepted.");
2629
2874
#endif
2630
2875
  }
2631
2876
 
2647
2892
  error_handler_hook= my_message_sql;
2648
2893
  start_signal_handler();                               // Creates pidfile
2649
2894
 
2650
 
  if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name))
 
2895
  if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name, opt_bootstrap))
2651
2896
  {
2652
2897
    abort_loop=1;
2653
2898
    select_thread_in_use=0;
2654
 
    (void) pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL);
 
2899
    (void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
2655
2900
 
2656
 
    (void) my_delete(pidfile_name,MYF(MY_WME)); // Not needed anymore
 
2901
    if (!opt_bootstrap)
 
2902
      (void) my_delete(pidfile_name,MYF(MY_WME));       // Not needed anymore
2657
2903
 
2658
2904
    exit(1);
2659
2905
  }
2660
2906
 
 
2907
  udf_init();
 
2908
 
2661
2909
  init_status_vars();
 
2910
  if (opt_bootstrap) /* If running with bootstrap, do not start replication. */
 
2911
    opt_skip_slave_start= 1;
2662
2912
  /*
2663
2913
    init_slave() must be called after the thread keys are created.
2664
2914
    Some parts of the code (e.g. SHOW STATUS LIKE 'slave_running' and other
2670
2920
    unireg_abort(1);
2671
2921
  }
2672
2922
 
2673
 
  sql_print_information(_(ER(ER_STARTUP)),my_progname,server_version,
2674
 
                        "", mysqld_port, DRIZZLE_COMPILATION_COMMENT);
 
2923
  if (opt_bootstrap)
 
2924
  {
 
2925
    select_thread_in_use= 0;                    // Allow 'kill' to work
 
2926
    bootstrap(stdin);
 
2927
    unireg_abort(bootstrap_error ? 1 : 0);
 
2928
  }
 
2929
  if (opt_init_file)
 
2930
  {
 
2931
    if (read_init_file(opt_init_file))
 
2932
      unireg_abort(1);
 
2933
  }
 
2934
 
 
2935
  create_maintenance_thread();
 
2936
 
 
2937
  sql_print_information(ER(ER_STARTUP),my_progname,server_version,
 
2938
                        "", mysqld_port, MYSQL_COMPILATION_COMMENT);
2675
2939
 
2676
2940
 
2677
2941
  handle_connections_sockets();
2678
2942
 
2679
2943
  /* (void) pthread_attr_destroy(&connection_attrib); */
2680
 
 
 
2944
  
 
2945
  DBUG_PRINT("quit",("Exiting main thread"));
2681
2946
 
2682
2947
#ifdef EXTRA_DEBUG2
2683
 
  sql_print_error(_("Before Lock_thread_count"));
 
2948
  sql_print_error("Before Lock_thread_count");
2684
2949
#endif
2685
2950
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
2951
  DBUG_PRINT("quit", ("Got thread_count mutex"));
2686
2952
  select_thread_in_use=0;                       // For close_connections
2687
2953
  (void) pthread_mutex_unlock(&LOCK_thread_count);
2688
2954
  (void) pthread_cond_broadcast(&COND_thread_count);
2689
2955
#ifdef EXTRA_DEBUG2
2690
 
  sql_print_error(_("After lock_thread_count"));
 
2956
  sql_print_error("After lock_thread_count");
2691
2957
#endif
2692
2958
 
2693
2959
  /* Wait until cleanup is done */
2702
2968
 
2703
2969
 
2704
2970
/**
 
2971
  Execute all commands from a file. Used by the mysql_install_db script to
 
2972
  create MySQL privilege tables without having to start a full MySQL server.
 
2973
*/
 
2974
 
 
2975
static void bootstrap(FILE *file)
 
2976
{
 
2977
  DBUG_ENTER("bootstrap");
 
2978
 
 
2979
  THD *thd= new THD;
 
2980
  thd->bootstrap=1;
 
2981
  my_net_init(&thd->net,(st_vio*) 0);
 
2982
  thd->max_client_packet_length= thd->net.max_packet;
 
2983
  thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
 
2984
  thread_count++;
 
2985
 
 
2986
  bootstrap_file=file;
 
2987
  if (pthread_create(&thd->real_id,&connection_attrib,handle_bootstrap,
 
2988
                     (void*) thd))
 
2989
  {
 
2990
    sql_print_warning("Can't create thread to handle bootstrap");
 
2991
    bootstrap_error=-1;
 
2992
    DBUG_VOID_RETURN;
 
2993
  }
 
2994
  /* Wait for thread to die */
 
2995
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
2996
  while (thread_count)
 
2997
  {
 
2998
    (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
 
2999
    DBUG_PRINT("quit",("One thread died (count=%u)",thread_count));
 
3000
  }
 
3001
  (void) pthread_mutex_unlock(&LOCK_thread_count);
 
3002
 
 
3003
  DBUG_VOID_RETURN;
 
3004
}
 
3005
 
 
3006
 
 
3007
static bool read_init_file(char *file_name)
 
3008
{
 
3009
  FILE *file;
 
3010
  DBUG_ENTER("read_init_file");
 
3011
  DBUG_PRINT("enter",("name: %s",file_name));
 
3012
  if (!(file=my_fopen(file_name,O_RDONLY,MYF(MY_WME))))
 
3013
    return(1);
 
3014
  bootstrap(file);
 
3015
  (void) my_fclose(file,MYF(MY_WME));
 
3016
  return 0;
 
3017
}
 
3018
 
 
3019
 
 
3020
/**
2705
3021
  Create new thread to handle incoming connection.
2706
3022
 
2707
3023
    This function will create new thread to handle the incoming
2716
3032
 
2717
3033
static void create_new_thread(THD *thd)
2718
3034
{
 
3035
  DBUG_ENTER("create_new_thread");
2719
3036
 
2720
3037
  /*
2721
3038
    Don't allow too many connections. We roughly check here that we allow
2728
3045
  {
2729
3046
    pthread_mutex_unlock(&LOCK_connection_count);
2730
3047
 
 
3048
    DBUG_PRINT("error",("Too many connections"));
2731
3049
    close_connection(thd, ER_CON_COUNT_ERROR, 1);
2732
3050
    delete thd;
2733
 
    return;;
 
3051
    DBUG_VOID_RETURN;
2734
3052
  }
2735
3053
 
2736
3054
  ++connection_count;
2755
3073
 
2756
3074
  thread_scheduler.add_connection(thd);
2757
3075
 
2758
 
  return;;
 
3076
  DBUG_VOID_RETURN;
2759
3077
}
2760
3078
 
2761
3079
 
2763
3081
inline void kill_broken_server()
2764
3082
{
2765
3083
  /* hack to get around signals ignored in syscalls for problem OS's */
2766
 
  if ((ip_sock == -1))
 
3084
  if ((!opt_disable_networking && ip_sock == INVALID_SOCKET))
2767
3085
  {
2768
3086
    select_thread_in_use = 0;
2769
3087
    /* The following call will never return */
2770
 
    kill_server((void*) DRIZZLE_KILL_SIGNAL);
 
3088
    kill_server((void*) MYSQL_KILL_SIGNAL);
2771
3089
  }
2772
3090
}
2773
3091
#define MAYBE_BROKEN_SYSCALL kill_broken_server();
2779
3097
 
2780
3098
void handle_connections_sockets()
2781
3099
{
2782
 
  int x;
2783
 
  int sock,new_sock;
2784
 
  uint32_t error_count=0;
 
3100
  my_socket sock,new_sock;
 
3101
  uint error_count=0;
 
3102
  uint max_used_connection= (uint)ip_sock+1;
 
3103
  fd_set readFDs,clientFDs;
2785
3104
  THD *thd;
2786
3105
  struct sockaddr_storage cAddr;
 
3106
  int ip_flags=0, flags;
 
3107
  st_vio *vio_tmp;
2787
3108
 
 
3109
  FD_ZERO(&clientFDs);
 
3110
  if (ip_sock != INVALID_SOCKET)
 
3111
  {
 
3112
    FD_SET(ip_sock,&clientFDs);
 
3113
#ifdef HAVE_FCNTL
 
3114
    ip_flags = fcntl(ip_sock, F_GETFL, 0);
 
3115
#endif
 
3116
  }
 
3117
  DBUG_PRINT("general",("Waiting for connections."));
2788
3118
  MAYBE_BROKEN_SYSCALL;
2789
3119
  while (!abort_loop)
2790
3120
  {
2791
 
    int number_of;
2792
 
 
2793
 
    if ((number_of= poll(fds, pollfd_count, -1)) == -1)
 
3121
    readFDs=clientFDs;
 
3122
    if (select((int) max_used_connection,&readFDs,0,0,0) < 0)
2794
3123
    {
2795
 
      if (errno != EINTR)
 
3124
      if (socket_errno != SOCKET_EINTR)
2796
3125
      {
2797
 
        if (!select_errors++ && !abort_loop)    /* purecov: inspected */
2798
 
          sql_print_error(_("drizzled: Got error %d from select"),
2799
 
                          errno); /* purecov: inspected */
 
3126
        if (!select_errors++ && !abort_loop)    /* purecov: inspected */
 
3127
          sql_print_error("mysqld: Got error %d from select",socket_errno); /* purecov: inspected */
2800
3128
      }
2801
3129
      MAYBE_BROKEN_SYSCALL
2802
3130
      continue;
2803
3131
    }
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
3132
    if (abort_loop)
2812
3133
    {
2813
3134
      MAYBE_BROKEN_SYSCALL;
2814
3135
      break;
2815
3136
    }
2816
3137
 
2817
 
    for (x= 0, sock= -1; x < pollfd_count; x++)
 
3138
    /* Is this a new connection request ? */
2818
3139
    {
2819
 
      if (fds[x].revents == POLLIN)
2820
 
      {
2821
 
        sock= fds[x].fd;
2822
 
        break;
2823
 
      }
 
3140
      sock = ip_sock;
 
3141
      flags= ip_flags;
2824
3142
    }
2825
 
    assert(sock != -1);
2826
3143
 
2827
 
    for (uint32_t retry=0; retry < MAX_ACCEPT_RETRY; retry++)
2828
 
    {
2829
 
      SOCKET_SIZE_TYPE length= sizeof(struct sockaddr_storage);
 
3144
#if !defined(NO_FCNTL_NONBLOCK)
 
3145
    if (!(test_flags & TEST_BLOCKING))
 
3146
    {
 
3147
#if defined(O_NONBLOCK)
 
3148
      fcntl(sock, F_SETFL, flags | O_NONBLOCK);
 
3149
#elif defined(O_NDELAY)
 
3150
      fcntl(sock, F_SETFL, flags | O_NDELAY);
 
3151
#endif
 
3152
    }
 
3153
#endif /* NO_FCNTL_NONBLOCK */
 
3154
    for (uint retry=0; retry < MAX_ACCEPT_RETRY; retry++)
 
3155
    {
 
3156
      size_socket length= sizeof(struct sockaddr_storage);
2830
3157
      new_sock= accept(sock, (struct sockaddr *)(&cAddr),
2831
3158
                       &length);
2832
 
      if (new_sock != -1 || (errno != EINTR && errno != EAGAIN))
 
3159
      if (new_sock != INVALID_SOCKET ||
 
3160
          (socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))
2833
3161
        break;
 
3162
      MAYBE_BROKEN_SYSCALL;
 
3163
#if !defined(NO_FCNTL_NONBLOCK)
 
3164
      if (!(test_flags & TEST_BLOCKING))
 
3165
      {
 
3166
        if (retry == MAX_ACCEPT_RETRY - 1)
 
3167
          fcntl(sock, F_SETFL, flags);          // Try without O_NONBLOCK
 
3168
      }
 
3169
#endif
2834
3170
    }
2835
 
 
2836
 
 
2837
 
    if (new_sock == -1)
 
3171
#if !defined(NO_FCNTL_NONBLOCK)
 
3172
    if (!(test_flags & TEST_BLOCKING))
 
3173
      fcntl(sock, F_SETFL, flags);
 
3174
#endif
 
3175
    if (new_sock == INVALID_SOCKET)
2838
3176
    {
2839
3177
      if ((error_count++ & 255) == 0)           // This can happen often
2840
3178
        sql_perror("Error in accept");
2841
3179
      MAYBE_BROKEN_SYSCALL;
2842
 
      if (errno == ENFILE || errno == EMFILE)
 
3180
      if (socket_errno == SOCKET_ENFILE || socket_errno == SOCKET_EMFILE)
2843
3181
        sleep(1);                               // Give other threads some time
2844
3182
      continue;
2845
3183
    }
2846
3184
 
2847
3185
    {
2848
 
      SOCKET_SIZE_TYPE dummyLen;
 
3186
      size_socket dummyLen;
2849
3187
      struct sockaddr_storage dummy;
2850
3188
      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;
 
3189
      if (  getsockname(new_sock,(struct sockaddr *)&dummy, 
 
3190
                  (socklen_t *)&dummyLen) < 0  )
 
3191
      {
 
3192
        sql_perror("Error on new connection socket");
 
3193
        (void) shutdown(new_sock, SHUT_RDWR);
 
3194
        (void) closesocket(new_sock);
 
3195
        continue;
2867
3196
      }
2868
3197
    }
2869
3198
 
2874
3203
    if (!(thd= new THD))
2875
3204
    {
2876
3205
      (void) shutdown(new_sock, SHUT_RDWR);
2877
 
      close(new_sock);
 
3206
      VOID(closesocket(new_sock));
2878
3207
      continue;
2879
3208
    }
2880
 
    if (net_init_sock(&thd->net, new_sock, sock == 0))
 
3209
    if (!(vio_tmp=vio_new(new_sock, VIO_TYPE_TCPIP, sock == 0)) ||
 
3210
        my_net_init(&thd->net,vio_tmp))
2881
3211
    {
 
3212
      /*
 
3213
        Only delete the temporary vio if we didn't already attach it to the
 
3214
        NET object. The destructor in THD will delete any initialized net
 
3215
        structure.
 
3216
      */
 
3217
      if (vio_tmp && thd->net.vio != vio_tmp)
 
3218
        vio_delete(vio_tmp);
 
3219
      else
 
3220
      {
 
3221
        (void) shutdown(new_sock, SHUT_RDWR);
 
3222
        (void) closesocket(new_sock);
 
3223
      }
2882
3224
      delete thd;
2883
3225
      continue;
2884
3226
    }
2894
3236
 
2895
3237
enum options_mysqld
2896
3238
{
2897
 
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW,
2898
 
  OPT_SKIP_GRANT,
 
3239
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW, 
 
3240
  OPT_SKIP_GRANT,              OPT_SKIP_LOCK, 
2899
3241
  OPT_ENABLE_LOCK,             OPT_USE_LOCKING,
2900
3242
  OPT_SOCKET,                  OPT_UPDATE_LOG,
2901
 
  OPT_BIN_LOG,
 
3243
  OPT_BIN_LOG,                 
2902
3244
  OPT_BIN_LOG_INDEX,
2903
3245
  OPT_BIND_ADDRESS,            OPT_PID_FILE,
2904
 
  OPT_SKIP_PRIOR,
 
3246
  OPT_SKIP_PRIOR,              OPT_BIG_TABLES,
2905
3247
  OPT_STANDALONE,
2906
3248
  OPT_CONSOLE,                 OPT_LOW_PRIORITY_UPDATES,
2907
3249
  OPT_SHORT_LOG_FORMAT,
2908
3250
  OPT_FLUSH,                   OPT_SAFE,
 
3251
  OPT_BOOTSTRAP,               OPT_SKIP_SHOW_DB,
2909
3252
  OPT_STORAGE_ENGINE,          OPT_INIT_FILE,
2910
 
  OPT_DELAY_KEY_WRITE_ALL,
 
3253
  OPT_DELAY_KEY_WRITE_ALL,     OPT_SLOW_QUERY_LOG,
2911
3254
  OPT_DELAY_KEY_WRITE,         OPT_CHARSETS_DIR,
2912
3255
  OPT_MASTER_INFO_FILE,
2913
3256
  OPT_MASTER_RETRY_COUNT,      OPT_LOG_TC, OPT_LOG_TC_SIZE,
2915
3258
  OPT_REPLICATE_IGNORE_DB,     OPT_LOG_SLAVE_UPDATES,
2916
3259
  OPT_BINLOG_DO_DB,            OPT_BINLOG_IGNORE_DB,
2917
3260
  OPT_BINLOG_FORMAT,
2918
 
  OPT_BINLOG_ROWS_EVENT_MAX_SIZE,
 
3261
#ifndef DBUG_OFF
 
3262
  OPT_BINLOG_SHOW_XID,
 
3263
#endif
 
3264
  OPT_BINLOG_ROWS_EVENT_MAX_SIZE, 
2919
3265
  OPT_WANT_CORE,
2920
3266
  OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,
2921
3267
  OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID,
2925
3271
  OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,
2926
3272
  OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,
2927
3273
  OPT_ABORT_SLAVE_EVENT_COUNT,
2928
 
  OPT_ENGINE_CONDITION_PUSHDOWN,
 
3274
  OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
 
3275
  OPT_ENGINE_CONDITION_PUSHDOWN, 
2929
3276
  OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,
2930
3277
  OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,
2931
3278
  OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,
2941
3288
  OPT_SSL_CAPATH, OPT_SSL_CIPHER,
2942
3289
  OPT_BACK_LOG, OPT_BINLOG_CACHE_SIZE,
2943
3290
  OPT_CONNECT_TIMEOUT,
2944
 
  OPT_FLUSH_TIME,
 
3291
  OPT_FLUSH_TIME, OPT_FT_MIN_WORD_LEN, OPT_FT_BOOLEAN_SYNTAX,
2945
3292
  OPT_INTERACTIVE_TIMEOUT, OPT_JOIN_BUFF_SIZE,
2946
3293
  OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,
2947
3294
  OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,
2950
3297
  OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,
2951
3298
  OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,
2952
3299
  OPT_MAX_HEP_TABLE_SIZE,
2953
 
  OPT_MAX_JOIN_SIZE,
 
3300
  OPT_MAX_JOIN_SIZE, OPT_MAX_PREPARED_STMT_COUNT,
2954
3301
  OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,
2955
3302
  OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,
2956
3303
  OPT_MAX_LENGTH_FOR_SORT_DATA,
2964
3311
  OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,
2965
3312
  OPT_OPEN_FILES_LIMIT,
2966
3313
  OPT_PRELOAD_BUFFER_SIZE,
2967
 
  OPT_RECORD_BUFFER,
 
3314
  OPT_QUERY_CACHE_LIMIT, OPT_QUERY_CACHE_MIN_RES_UNIT, OPT_QUERY_CACHE_SIZE,
 
3315
  OPT_QUERY_CACHE_TYPE, OPT_QUERY_CACHE_WLOCK_INVALIDATE, OPT_RECORD_BUFFER,
2968
3316
  OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT, OPT_RELAY_LOG_SPACE_LIMIT,
2969
3317
  OPT_RELAY_LOG_PURGE,
2970
3318
  OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,
2975
3323
  OPT_WAIT_TIMEOUT,
2976
3324
  OPT_ERROR_LOG_FILE,
2977
3325
  OPT_DEFAULT_WEEK_FORMAT,
2978
 
  OPT_RANGE_ALLOC_BLOCK_SIZE,
 
3326
  OPT_RANGE_ALLOC_BLOCK_SIZE, OPT_ALLOW_SUSPICIOUS_UDFS,
2979
3327
  OPT_QUERY_ALLOC_BLOCK_SIZE, OPT_QUERY_PREALLOC_SIZE,
2980
3328
  OPT_TRANS_ALLOC_BLOCK_SIZE, OPT_TRANS_PREALLOC_SIZE,
2981
3329
  OPT_SYNC_FRM, OPT_SYNC_BINLOG,
2984
3332
  OPT_SYNC_REPLICATION_TIMEOUT,
2985
3333
  OPT_ENABLE_SHARED_MEMORY,
2986
3334
  OPT_SHARED_MEMORY_BASE_NAME,
 
3335
  OPT_OLD_PASSWORDS,
2987
3336
  OPT_OLD_ALTER_TABLE,
2988
3337
  OPT_EXPIRE_LOGS_DAYS,
2989
3338
  OPT_GROUP_CONCAT_MAX_LEN,
2997
3346
  OPT_DATE_FORMAT,
2998
3347
  OPT_TIME_FORMAT,
2999
3348
  OPT_DATETIME_FORMAT,
 
3349
  OPT_LOG_QUERIES_NOT_USING_INDEXES,
3000
3350
  OPT_DEFAULT_TIME_ZONE,
3001
3351
  OPT_SYSDATE_IS_NOW,
3002
3352
  OPT_OPTIMIZER_SEARCH_DEPTH,
3006
3356
  OPT_ENABLE_LARGE_PAGES,
3007
3357
  OPT_TIMED_MUTEXES,
3008
3358
  OPT_OLD_STYLE_USER_LIMITS,
 
3359
  OPT_LOG_SLOW_ADMIN_STATEMENTS,
3009
3360
  OPT_TABLE_LOCK_WAIT_TIMEOUT,
3010
3361
  OPT_PLUGIN_LOAD,
3011
3362
  OPT_PLUGIN_DIR,
 
3363
  OPT_LOG_OUTPUT,
3012
3364
  OPT_PORT_OPEN_TIMEOUT,
3013
3365
  OPT_PROFILING,
3014
3366
  OPT_KEEP_FILES_ON_CREATE,
3015
3367
  OPT_GENERAL_LOG,
 
3368
  OPT_SLOW_LOG,
3016
3369
  OPT_THREAD_HANDLING,
3017
3370
  OPT_INNODB_ROLLBACK_ON_TIMEOUT,
3018
3371
  OPT_SECURE_FILE_PRIV,
3019
3372
  OPT_MIN_EXAMINED_ROW_LIMIT,
 
3373
  OPT_LOG_SLOW_SLAVE_STATEMENTS,
3020
3374
  OPT_OLD_MODE,
3021
3375
  OPT_POOL_OF_THREADS,
3022
3376
  OPT_SLAVE_EXEC_MODE
3023
3377
};
3024
3378
 
3025
3379
 
3026
 
#define LONG_TIMEOUT ((uint32_t) 3600L*24L*365L)
 
3380
#define LONG_TIMEOUT ((ulong) 3600L*24L*365L)
3027
3381
 
3028
3382
struct my_option my_long_options[] =
3029
3383
{
3030
 
  {"help", '?', N_("Display this help and exit."),
3031
 
   (char**) &opt_help, (char**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
3384
  {"help", '?', "Display this help and exit.", 
 
3385
   (uchar**) &opt_help, (uchar**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
3032
3386
   0, 0},
3033
3387
  {"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,
 
3388
   "Option used by mysql-test for debugging and testing of replication.",
 
3389
   (uchar**) &abort_slave_event_count,  (uchar**) &abort_slave_event_count,
3036
3390
   0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3391
  {"allow-suspicious-udfs", OPT_ALLOW_SUSPICIOUS_UDFS,
 
3392
   "Allows use of UDFs consisting of only one symbol xxx() "
 
3393
   "without corresponding xxx_init() or xxx_deinit(). That also means "
 
3394
   "that one can load any function from any library, for example exit() "
 
3395
   "from libc.so",
 
3396
   (uchar**) &opt_allow_suspicious_udfs, (uchar**) &opt_allow_suspicious_udfs,
 
3397
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3398
  {"ansi", 'a', "Use ANSI SQL syntax instead of MySQL syntax. This mode will also set transaction isolation level 'serializable'.", 0, 0, 0,
 
3399
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3037
3400
  {"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,
 
3401
   "Auto-increment columns are incremented by this",
 
3402
   (uchar**) &global_system_variables.auto_increment_increment,
 
3403
   (uchar**) &max_system_variables.auto_increment_increment, 0, GET_ULONG,
3041
3404
   OPT_ARG, 1, 1, 65535, 0, 1, 0 },
3042
3405
  {"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,
 
3406
   "Offset added to Auto-increment columns. Used when auto-increment-increment != 1",
 
3407
   (uchar**) &global_system_variables.auto_increment_offset,
 
3408
   (uchar**) &max_system_variables.auto_increment_offset, 0, GET_ULONG, OPT_ARG,
3047
3409
   1, 1, 65535, 0, 1, 0 },
3048
3410
  {"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,
 
3411
   "Path to installation directory. All paths are usually resolved relative to this.",
 
3412
   (uchar**) &mysql_home_ptr, (uchar**) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,
3052
3413
   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,
 
3414
  {"big-tables", OPT_BIG_TABLES,
 
3415
   "Allow big result sets by saving all temporary sets on file (Solves most 'table full' errors).",
 
3416
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3417
  {"bind-address", OPT_BIND_ADDRESS, "IP address to bind to.",
 
3418
   (uchar**) &my_bind_addr_str, (uchar**) &my_bind_addr_str, 0, GET_STR,
3055
3419
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3056
3420
  {"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,
 
3421
   "Does not have any effect without '--log-bin'. "
 
3422
   "Tell the master the form of binary logging to use: either 'row' for "
 
3423
   "row-based binary logging, or 'statement' for statement-based binary "
 
3424
   "logging, or 'mixed'. 'mixed' is statement-based binary logging except "
 
3425
   "for those statements where only row-based is correct: those which "
 
3426
   "involve user-defined functions (i.e. UDFs) or the UUID() function; for "
 
3427
   "those, row-based binary logging is automatically used. "
 
3428
   ,(uchar**) &opt_binlog_format, (uchar**) &opt_binlog_format,
3065
3429
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3066
3430
  {"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."),
 
3431
   "Tells the master it should log updates for the specified database, and exclude all others not explicitly mentioned.",
3069
3432
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3070
3433
  {"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."),
 
3434
   "Tells the master that updates to the given database should not be logged tothe binary log.",
3073
3435
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3074
3436
  {"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,
 
3437
   "The maximum size of a row-based binary log event in bytes. Rows will be "
 
3438
   "grouped into events smaller than this size if possible. "
 
3439
   "The value has to be a multiple of 256.",
 
3440
   (uchar**) &opt_binlog_rows_event_max_size, 
 
3441
   (uchar**) &opt_binlog_rows_event_max_size, 0, 
 
3442
   GET_ULONG, REQUIRED_ARG, 
 
3443
   /* def_value */ 1024, /* min_value */  256, /* max_value */ ULONG_MAX, 
 
3444
   /* sub_size */     0, /* block_size */ 256, 
3083
3445
   /* app_type */ 0
3084
3446
  },
 
3447
#ifndef DISABLE_GRANT_OPTIONS
 
3448
  {"bootstrap", OPT_BOOTSTRAP, "Used by mysql installation scripts.", 0, 0, 0,
 
3449
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3450
#endif
3085
3451
  {"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,
 
3452
   "Don't ignore client side character set value sent during handshake.",
 
3453
   (uchar**) &opt_character_set_client_handshake,
 
3454
   (uchar**) &opt_character_set_client_handshake,
3089
3455
    0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
3090
3456
  {"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,
 
3457
   "Set the filesystem character set.",
 
3458
   (uchar**) &character_set_filesystem_name,
 
3459
   (uchar**) &character_set_filesystem_name,
3094
3460
   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,
 
3461
  {"character-set-server", 'C', "Set the default character set.",
 
3462
   (uchar**) &default_character_set_name, (uchar**) &default_character_set_name,
3098
3463
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3099
3464
  {"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,
 
3465
   "Directory where character sets are.", (uchar**) &charsets_dir,
 
3466
   (uchar**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3467
  {"chroot", 'r', "Chroot mysqld daemon during startup.",
 
3468
   (uchar**) &mysqld_chroot, (uchar**) &mysqld_chroot, 0, GET_STR, REQUIRED_ARG,
3105
3469
   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,
 
3470
  {"collation-server", OPT_DEFAULT_COLLATION, "Set the default collation.",
 
3471
   (uchar**) &default_collation_name, (uchar**) &default_collation_name,
3109
3472
   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,
 
3473
  {"completion-type", OPT_COMPLETION_TYPE, "Default completion type.",
 
3474
   (uchar**) &global_system_variables.completion_type,
 
3475
   (uchar**) &max_system_variables.completion_type, 0, GET_ULONG,
3114
3476
   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,
 
3477
  {"console", OPT_CONSOLE, "Write error output on screen; Don't remove the console window on windows.",
 
3478
   (uchar**) &opt_console, (uchar**) &opt_console, 0, GET_BOOL, NO_ARG, 0, 0, 0,
3118
3479
   0, 0, 0},
3119
 
  {"core-file", OPT_WANT_CORE,
3120
 
   N_("Write core on errors."),
3121
 
   0, 0, 0, GET_NO_ARG,
 
3480
  {"core-file", OPT_WANT_CORE, "Write core on errors.", 0, 0, 0, GET_NO_ARG,
3122
3481
   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},
 
3482
  {"datadir", 'h', "Path to the database root.", (uchar**) &mysql_data_home,
 
3483
   (uchar**) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3484
#ifndef DBUG_OFF
 
3485
  {"debug", '#', "Debug log.", (uchar**) &default_dbug_option,
 
3486
   (uchar**) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3487
#endif
 
3488
  {"default-character-set", 'C', "Set the default character set (deprecated option, use --character-set-server instead).",
 
3489
   (uchar**) &default_character_set_name, (uchar**) &default_character_set_name,
 
3490
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
 
3491
  {"default-collation", OPT_DEFAULT_COLLATION, "Set the default collation (deprecated option, use --collation-server instead).",
 
3492
   (uchar**) &default_collation_name, (uchar**) &default_collation_name,
 
3493
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3127
3494
  {"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,
 
3495
   "Set the default storage engine (table type) for tables.",
 
3496
   (uchar**)&default_storage_engine_str, (uchar**)&default_storage_engine_str,
 
3497
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3498
  {"default-table-type", OPT_STORAGE_ENGINE,
 
3499
   "(deprecated) Use --default-storage-engine.",
 
3500
   (uchar**)&default_storage_engine_str, (uchar**)&default_storage_engine_str,
 
3501
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3502
  {"default-time-zone", OPT_DEFAULT_TIME_ZONE, "Set the default time zone.",
 
3503
   (uchar**) &default_tz_name, (uchar**) &default_tz_name,
3134
3504
   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."),
 
3505
  {"delay-key-write", OPT_DELAY_KEY_WRITE, "Type of DELAY_KEY_WRITE.",
3137
3506
   0,0,0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3507
  {"delay-key-write-for-all-tables", OPT_DELAY_KEY_WRITE_ALL,
 
3508
   "Don't flush key buffers between writes for any MyISAM table (Deprecated option, use --delay-key-write=all instead).",
 
3509
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3138
3510
  {"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,
 
3511
   "Option used by mysql-test for debugging and testing of replication.",
 
3512
   (uchar**) &disconnect_slave_event_count,
 
3513
   (uchar**) &disconnect_slave_event_count, 0, GET_INT, REQUIRED_ARG, 0, 0, 0,
3142
3514
   0, 0, 0},
3143
3515
#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,
 
3516
  {"enable-pstack", OPT_DO_PSTACK, "Print a symbolic stack trace on failure.",
 
3517
   (uchar**) &opt_do_pstack, (uchar**) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
3147
3518
   0, 0, 0, 0},
3148
3519
#endif /* HAVE_STACK_TRACE_ON_SEGV */
3149
3520
  {"engine-condition-pushdown",
3150
3521
   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,
 
3522
   "Push supported query conditions to the storage engine.",
 
3523
   (uchar**) &global_system_variables.engine_condition_pushdown,
 
3524
   (uchar**) &global_system_variables.engine_condition_pushdown,
3154
3525
   0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
3155
3526
  /* 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},
 
3527
  {"exit-info", 'T', "Used for debugging;  Use at your own risk!", 0, 0, 0,
 
3528
   GET_LONG, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3529
  {"flush", OPT_FLUSH, "Flush tables to disk between SQL commands.", 0, 0, 0,
 
3530
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3162
3531
  /* We must always support the next option to make scripts like mysqltest
3163
3532
     easier to do */
3164
3533
  {"gdb", OPT_DEBUGGING,
3165
 
   N_("Set up signals usable for debugging"),
3166
 
   (char**) &opt_debugging, (char**) &opt_debugging,
 
3534
   "Set up signals usable for debugging",
 
3535
   (uchar**) &opt_debugging, (uchar**) &opt_debugging,
3167
3536
   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,
 
3537
  {"general-log", OPT_GENERAL_LOG,
 
3538
   "Enable|disable general log", (uchar**) &opt_log,
 
3539
   (uchar**) &opt_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3540
  {"init-connect", OPT_INIT_CONNECT, "Command(s) that are executed for each new connection",
 
3541
   (uchar**) &opt_init_connect, (uchar**) &opt_init_connect, 0, GET_STR_ALLOC,
3171
3542
   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,
 
3543
  {"init-file", OPT_INIT_FILE, "Read SQL commands from this file at startup.",
 
3544
   (uchar**) &opt_init_file, (uchar**) &opt_init_file, 0, GET_STR, REQUIRED_ARG,
3175
3545
   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,
 
3546
  {"init-slave", OPT_INIT_SLAVE, "Command(s) that are executed when a slave connects to this master",
 
3547
   (uchar**) &opt_init_slave, (uchar**) &opt_init_slave, 0, GET_STR_ALLOC,
3179
3548
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3180
3549
  {"language", 'L',
3181
 
   N_("(IGNORED)"),
3182
 
   (char**) &language_ptr, (char**) &language_ptr, 0, GET_STR, REQUIRED_ARG,
 
3550
   "Client error messages in given language. May be given as a full path.",
 
3551
   (uchar**) &language_ptr, (uchar**) &language_ptr, 0, GET_STR, REQUIRED_ARG,
3183
3552
   0, 0, 0, 0, 0, 0},
3184
3553
  {"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,
 
3554
   "Set the language used for the month names and the days of the week.",
 
3555
   (uchar**) &lc_time_names_name,
 
3556
   (uchar**) &lc_time_names_name,
3188
3557
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
3189
3558
  {"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,
 
3559
   "Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0).",
 
3560
   (uchar**) &opt_local_infile,
 
3561
   (uchar**) &opt_local_infile, 0, GET_BOOL, OPT_ARG,
3193
3562
   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},
 
3563
  {"log", 'l', "Log connections and queries to file.", (uchar**) &opt_logname,
 
3564
   (uchar**) &opt_logname, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
3198
3565
  {"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,
 
3566
   "Log update queries in binary format. Optional (but strongly recommended "
 
3567
   "to avoid replication problems if server's hostname changes) argument "
 
3568
   "should be the chosen location for the binary log files.",
 
3569
   (uchar**) &opt_bin_logname, (uchar**) &opt_bin_logname, 0, GET_STR_ALLOC,
3204
3570
   OPT_ARG, 0, 0, 0, 0, 0, 0},
3205
3571
  {"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,
 
3572
   "File that holds the names for last binary log files.",
 
3573
   (uchar**) &opt_binlog_index_name, (uchar**) &opt_binlog_index_name, 0, GET_STR,
3208
3574
   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},
 
3575
  /*
 
3576
    This option starts with "log-bin" to emphasize that it is specific of
 
3577
    binary logging.
 
3578
  */
 
3579
  {"log-bin-trust-function-creators", OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
 
3580
   "If equal to 0 (the default), then when --log-bin is used, creation of "
 
3581
   "a stored function (or trigger) is allowed only to users having the SUPER privilege "
 
3582
   "and only if this stored function (trigger) may not break binary logging."
 
3583
   "Note that if ALL connections to this server ALWAYS use row-based binary "
 
3584
   "logging, the security issues do not exist and the binary logging cannot "
 
3585
   "break, so you can safely set this to 1."
 
3586
   ,(uchar**) &trust_function_creators, (uchar**) &trust_function_creators, 0,
 
3587
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3588
  {"log-error", OPT_ERROR_LOG_FILE, "Error log file.",
 
3589
   (uchar**) &log_error_file_ptr, (uchar**) &log_error_file_ptr, 0, GET_STR,
 
3590
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3591
  {"log-isam", OPT_ISAM_LOG, "Log all MyISAM changes to file.",
 
3592
   (uchar**) &myisam_log_filename, (uchar**) &myisam_log_filename, 0, GET_STR,
 
3593
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3594
  {"log-long-format", '0',
 
3595
   "Log some extra information to update log. Please note that this option is deprecated; see --log-short-format option.", 
 
3596
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3597
#ifdef WITH_CSV_STORAGE_ENGINE
 
3598
  {"log-output", OPT_LOG_OUTPUT,
 
3599
   "Syntax: log-output[=value[,value...]], where \"value\" could be TABLE, "
 
3600
   "FILE or NONE.",
 
3601
   (uchar**) &log_output_str, (uchar**) &log_output_str, 0,
 
3602
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3603
#endif
 
3604
  {"log-queries-not-using-indexes", OPT_LOG_QUERIES_NOT_USING_INDEXES,
 
3605
   "Log queries that are executed without benefit of any index to the slow log if it is open.",
 
3606
   (uchar**) &opt_log_queries_not_using_indexes, (uchar**) &opt_log_queries_not_using_indexes,
 
3607
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3608
  {"log-short-format", OPT_SHORT_LOG_FORMAT,
 
3609
   "Don't log extra information to update and slow-query logs.",
 
3610
   (uchar**) &opt_short_log_format, (uchar**) &opt_short_log_format,
 
3611
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3217
3612
  {"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,
 
3613
   "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.",
 
3614
   (uchar**) &opt_log_slave_updates, (uchar**) &opt_log_slave_updates, 0, GET_BOOL,
3223
3615
   NO_ARG, 0, 0, 0, 0, 0, 0},
 
3616
  {"log-slow-admin-statements", OPT_LOG_SLOW_ADMIN_STATEMENTS,
 
3617
   "Log slow OPTIMIZE, ANALYZE, ALTER and other administrative statements to the slow log if it is open.",
 
3618
   (uchar**) &opt_log_slow_admin_statements,
 
3619
   (uchar**) &opt_log_slow_admin_statements,
 
3620
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3621
 {"log-slow-slave-statements", OPT_LOG_SLOW_SLAVE_STATEMENTS,
 
3622
  "Log slow statements executed by slave thread to the slow log if it is open.",
 
3623
  (uchar**) &opt_log_slow_slave_statements,
 
3624
  (uchar**) &opt_log_slow_slave_statements,
 
3625
  0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3626
  {"log-slow-queries", OPT_SLOW_QUERY_LOG,
 
3627
    "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.",
 
3628
   (uchar**) &opt_slow_logname, (uchar**) &opt_slow_logname, 0, GET_STR, OPT_ARG,
 
3629
   0, 0, 0, 0, 0, 0},
3224
3630
  {"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,
 
3631
   "Path to transaction coordinator log (used for transactions that affect "
 
3632
   "more than one storage engine, when binary log is disabled)",
 
3633
   (uchar**) &opt_tc_log_file, (uchar**) &opt_tc_log_file, 0, GET_STR,
3228
3634
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3229
3635
#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,
 
3636
  {"log-tc-size", OPT_LOG_TC_SIZE, "Size of transaction coordinator log.",
 
3637
   (uchar**) &opt_tc_log_size, (uchar**) &opt_tc_log_size, 0, GET_ULONG,
3233
3638
   REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, ULONG_MAX, 0,
3234
3639
   TC_LOG_PAGE_SIZE, 0},
3235
3640
#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,
 
3641
  {"log-update", OPT_UPDATE_LOG,
 
3642
   "The update log is deprecated since version 5.0, is replaced by the binary \
 
3643
log and this option justs turns on --log-bin instead.",
 
3644
   (uchar**) &opt_update_logname, (uchar**) &opt_update_logname, 0, GET_STR,
 
3645
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3646
  {"log-warnings", 'W', "Log some not critical warnings to the log file.",
 
3647
   (uchar**) &global_system_variables.log_warnings,
 
3648
   (uchar**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, 0,
3240
3649
   0, 0, 0},
3241
3650
  {"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,
 
3651
   "INSERT/DELETE/UPDATE has lower priority than selects.",
 
3652
   (uchar**) &global_system_variables.low_priority_updates,
 
3653
   (uchar**) &max_system_variables.low_priority_updates,
3245
3654
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3246
3655
  {"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,
 
3656
   "The location and name of the file that remembers the master and where the I/O replication \
 
3657
thread is in the master's binlogs.",
 
3658
   (uchar**) &master_info_file, (uchar**) &master_info_file, 0, GET_STR,
3250
3659
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3251
3660
  {"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,
 
3661
   "The number of tries the slave will make to connect to the master before giving up.",
 
3662
   (uchar**) &master_retry_count, (uchar**) &master_retry_count, 0, GET_ULONG,
3255
3663
   REQUIRED_ARG, 3600*24, 0, 0, 0, 0, 0},
3256
3664
  {"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,
 
3665
   "Option used by mysql-test for debugging and testing of replication.",
 
3666
   (uchar**) &max_binlog_dump_events, (uchar**) &max_binlog_dump_events, 0,
3259
3667
   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},
 
3668
  {"memlock", OPT_MEMLOCK, "Lock mysqld in memory.", (uchar**) &locked_in_memory,
 
3669
   (uchar**) &locked_in_memory, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3264
3670
  {"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,
 
3671
   "Syntax: myisam-recover[=option[,option...]], where option can be DEFAULT, BACKUP, FORCE or QUICK.",
 
3672
   (uchar**) &myisam_recover_options_str, (uchar**) &myisam_recover_options_str, 0,
3268
3673
   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,
 
3674
  {"new", 'n', "Use very new possible 'unsafe' functions.",
 
3675
   (uchar**) &global_system_variables.new_mode,
 
3676
   (uchar**) &max_system_variables.new_mode,
3273
3677
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3274
3678
  {"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,
 
3679
   "Use old, non-optimized alter table.",
 
3680
   (uchar**) &global_system_variables.old_alter_table,
 
3681
   (uchar**) &max_system_variables.old_alter_table, 0, GET_BOOL, NO_ARG,
 
3682
   0, 0, 0, 0, 0, 0},
 
3683
  {"old-passwords", OPT_OLD_PASSWORDS, "Use old password encryption method (needed for 4.0 and older clients).",
 
3684
   (uchar**) &global_system_variables.old_passwords,
 
3685
   (uchar**) &max_system_variables.old_passwords, 0, GET_BOOL, NO_ARG,
 
3686
   0, 0, 0, 0, 0, 0},
 
3687
  {"old-style-user-limits", OPT_OLD_STYLE_USER_LIMITS,
 
3688
   "Enable old-style user limits (before 5.0.3 user resources were counted per each user+host vs. per account)",
 
3689
   (uchar**) &opt_old_style_user_limits, (uchar**) &opt_old_style_user_limits,
 
3690
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3691
  {"pid-file", OPT_PID_FILE, "Pid file used by safe_mysqld.",
 
3692
   (uchar**) &pidfile_name_ptr, (uchar**) &pidfile_name_ptr, 0, GET_STR,
3282
3693
   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},
 
3694
  {"port", 'P', "Port number to use for connection or 0 for default to, in "
 
3695
   "order of preference, my.cnf, $MYSQL_TCP_PORT, "
 
3696
#if MYSQL_PORT_DEFAULT == 0
 
3697
   "/etc/services, "
 
3698
#endif
 
3699
   "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",
 
3700
   (uchar**) &mysqld_port,
 
3701
   (uchar**) &mysqld_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3289
3702
  {"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},
 
3703
   "Maximum time in seconds to wait for the port to become free. "
 
3704
   "(Default: no wait)", (uchar**) &mysqld_port_timeout,
 
3705
   (uchar**) &mysqld_port_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3294
3706
  {"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,
 
3707
   "The location and name to use for relay logs.",
 
3708
   (uchar**) &opt_relay_logname, (uchar**) &opt_relay_logname, 0,
3297
3709
   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3298
3710
  {"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,
 
3711
   "The location and name to use for the file that keeps a list of the last \
 
3712
relay logs.",
 
3713
   (uchar**) &opt_relaylog_index_name, (uchar**) &opt_relaylog_index_name, 0,
3302
3714
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3303
3715
  {"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,
 
3716
   "The location and name of the file that remembers where the SQL replication \
 
3717
thread is in the relay logs.",
 
3718
   (uchar**) &relay_log_info_file, (uchar**) &relay_log_info_file, 0, GET_STR,
3307
3719
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3308
3720
  {"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.%."),
 
3721
   "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
3722
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3317
3723
  {"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."),
 
3724
   "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
3725
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3323
3726
  {"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.%. "),
 
3727
   "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
3728
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3330
3729
  {"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."),
 
3730
   "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
3731
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3336
3732
  {"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."),
 
3733
   "Updates to a database with a different name than the original. Example: replicate-rewrite-db=master_db_name->slave_db_name.",
3339
3734
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3340
3735
  {"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,
 
3736
   "In replication, if set to 1, do not skip events having our server id. \
 
3737
Default value is 0 (to break infinite loops in circular replication). \
 
3738
Can't be set to 1 if --log-slave-updates is used.",
 
3739
   (uchar**) &replicate_same_server_id,
 
3740
   (uchar**) &replicate_same_server_id,
3346
3741
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3347
3742
  {"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."),
 
3743
   "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
3744
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3355
3745
  {"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."),
 
3746
   "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
3747
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3363
3748
  // In replication, we may need to tell the other servers how to connect
3364
3749
  {"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,
 
3750
   "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.",
 
3751
   (uchar**) &report_host, (uchar**) &report_host, 0, GET_STR, REQUIRED_ARG, 0, 0,
3373
3752
   0, 0, 0, 0},
3374
3753
  {"report-password", OPT_REPORT_PASSWORD, "Undocumented.",
3375
 
   (char**) &report_password, (char**) &report_password, 0, GET_STR,
 
3754
   (uchar**) &report_password, (uchar**) &report_password, 0, GET_STR,
3376
3755
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3377
3756
  {"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)."),
 
3757
   "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.",
 
3758
   (uchar**) &report_port, (uchar**) &report_port, 0, GET_UINT, REQUIRED_ARG,
 
3759
   MYSQL_PORT, 0, 0, 0, 0, 0},
 
3760
  {"safe-mode", OPT_SAFE, "Skip some optimize stages (for testing).",
3386
3761
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3387
3762
  {"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,
 
3763
   "Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files within specified directory",
 
3764
   (uchar**) &opt_secure_file_priv, (uchar**) &opt_secure_file_priv, 0,
3391
3765
   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3392
3766
  {"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,
 
3767
   "Uniquely identifies the server instance in the community of replication partners.",
 
3768
   (uchar**) &server_id, (uchar**) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,
3396
3769
   0, 0, 0},
3397
 
  {"skip-new", OPT_SKIP_NEW,
3398
 
   N_("Don't use new, possible wrong routines."),
 
3770
  {"set-variable", 'O',
 
3771
   "Change the value of a variable. Please note that this option is deprecated;you can set variables directly with --variable-name=value.",
 
3772
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3773
  {"skip-new", OPT_SKIP_NEW, "Don't use new, possible wrong routines.",
3399
3774
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3400
3775
  {"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},
 
3776
   "If set, slave is not autostarted.", (uchar**) &opt_skip_slave_start,
 
3777
   (uchar**) &opt_skip_slave_start, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
3404
3778
  {"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,
 
3779
   "Don't print a stack trace on failure.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
3407
3780
   0, 0, 0, 0},
 
3781
  {"skip-symlink", OPT_SKIP_SYMLINKS, "Don't allow symlinking of tables. Deprecated option.  Use --skip-symbolic-links instead.",
 
3782
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
3408
3783
  {"skip-thread-priority", OPT_SKIP_PRIOR,
3409
 
   N_("Don't give threads different priorities."),
3410
 
   0, 0, 0, GET_NO_ARG, NO_ARG,
 
3784
   "Don't give threads different priorities.", 0, 0, 0, GET_NO_ARG, NO_ARG,
3411
3785
   DEFAULT_SKIP_THREAD_PRIORITY, 0, 0, 0, 0, 0},
3412
3786
  {"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,
 
3787
   "The location where the slave should put its temporary files when \
 
3788
replicating a LOAD DATA INFILE command.",
 
3789
   (uchar**) &slave_load_tmpdir, (uchar**) &slave_load_tmpdir, 0, GET_STR_ALLOC,
3416
3790
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3417
3791
  {"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."),
 
3792
   "Tells the slave thread to continue replication when a query event returns an error from the provided list.",
3420
3793
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3421
3794
  {"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},
 
3795
   "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.",
 
3796
   (uchar**) &slave_exec_mode_str, (uchar**) &slave_exec_mode_str, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3797
  {"slow-query-log", OPT_SLOW_LOG,
 
3798
   "Enable|disable slow query log", (uchar**) &opt_slow_log,
 
3799
   (uchar**) &opt_slow_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3800
  {"sporadic-binlog-dump-fail", OPT_SPORADIC_BINLOG_DUMP_FAIL,
 
3801
   "Option used by mysql-test for debugging and testing of replication.",
 
3802
   (uchar**) &opt_sporadic_binlog_dump_fail,
 
3803
   (uchar**) &opt_sporadic_binlog_dump_fail, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,
 
3804
   0},
3429
3805
  {"sql-bin-update-same", OPT_SQL_BIN_UPDATE_SAME,
3430
 
   N_("(INGORED)"),
 
3806
   "The update log is deprecated since version 5.0, is replaced by the binary \
 
3807
log and this option does nothing anymore.",
3431
3808
   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,
 
3809
  {"symbolic-links", 's', "Enable symbolic link support.",
 
3810
   (uchar**) &my_use_symdir, (uchar**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
3435
3811
   /*
3436
3812
     The system call realpath() produces warnings under valgrind and
3437
3813
     purify. These are not suppressed: instead we disable symlinks
3439
3815
   */
3440
3816
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
3441
3817
  {"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,
 
3818
   "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.",
 
3819
   (uchar**) &global_system_variables.sysdate_is_now,
3445
3820
   0, 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3446
3821
  {"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,
 
3822
   "Decision to use in heuristic recover process. Possible values are COMMIT or ROLLBACK.",
 
3823
   (uchar**) &opt_tc_heuristic_recover, (uchar**) &opt_tc_heuristic_recover,
3450
3824
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3451
3825
  {"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,
 
3826
   "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.",
 
3827
   (uchar**) &use_temp_pool, (uchar**) &use_temp_pool, 0, GET_BOOL, NO_ARG, 1,
3455
3828
   0, 0, 0, 0, 0},
3456
3829
  {"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,
 
3830
   "Specify whether to time mutexes (only InnoDB mutexes are currently supported)",
 
3831
   (uchar**) &timed_mutexes, (uchar**) &timed_mutexes, 0, GET_BOOL, NO_ARG, 0, 
3460
3832
    0, 0, 0, 0, 0},
3461
3833
  {"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},
 
3834
   "Path for temporary files. Several paths may be specified, separated by a "
 
3835
   "colon (:)"
 
3836
   ", in this case they are used in a round-robin fashion.",
 
3837
   (uchar**) &opt_mysql_tmpdir,
 
3838
   (uchar**) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3467
3839
  {"transaction-isolation", OPT_TX_ISOLATION,
3468
 
   N_("Default transaction isolation level."),
3469
 
   0, 0, 0, GET_STR, REQUIRED_ARG, 0,
 
3840
   "Default transaction isolation level.", 0, 0, 0, GET_STR, REQUIRED_ARG, 0,
3470
3841
   0, 0, 0, 0, 0},
3471
 
  {"user", 'u',
3472
 
   N_("Run mysqld daemon as user."),
3473
 
   0, 0, 0, GET_STR, REQUIRED_ARG,
 
3842
  {"use-symbolic-links", 's', "Enable symbolic link support. Deprecated option; use --symbolic-links instead.",
 
3843
   (uchar**) &my_use_symdir, (uchar**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
 
3844
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
 
3845
  {"user", 'u', "Run mysqld daemon as user.", 0, 0, 0, GET_STR, REQUIRED_ARG,
3474
3846
   0, 0, 0, 0, 0, 0},
3475
 
  {"version", 'V',
3476
 
   N_("Output version information and exit."),
3477
 
   0, 0, 0, GET_NO_ARG,
 
3847
  {"verbose", 'v', "Used with --help option for detailed help",
 
3848
   (uchar**) &opt_verbose, (uchar**) &opt_verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
3849
   0, 0},
 
3850
  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,
3478
3851
   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,
 
3852
  {"warnings", 'W', "Deprecated; use --log-warnings instead.",
 
3853
   (uchar**) &global_system_variables.log_warnings,
 
3854
   (uchar**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG,
 
3855
   1, 0, ULONG_MAX, 0, 0, 0},
 
3856
  { "back_log", OPT_BACK_LOG,
 
3857
    "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.",
 
3858
    (uchar**) &back_log, (uchar**) &back_log, 0, GET_ULONG,
3484
3859
    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 },
 
3860
  {"binlog_cache_size", OPT_BINLOG_CACHE_SIZE,
 
3861
   "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.",
 
3862
   (uchar**) &binlog_cache_size, (uchar**) &binlog_cache_size, 0, GET_ULONG,
 
3863
   REQUIRED_ARG, 32*1024L, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},
 
3864
  {"bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,
 
3865
   "Size of tree cache used in bulk insert optimisation. Note that this is a limit per thread!",
 
3866
   (uchar**) &global_system_variables.bulk_insert_buff_size,
 
3867
   (uchar**) &max_system_variables.bulk_insert_buff_size,
 
3868
   0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, ULONG_MAX, 0, 1, 0},
 
3869
  {"connect_timeout", OPT_CONNECT_TIMEOUT,
 
3870
   "The number of seconds the mysqld server is waiting for a connect packet before responding with 'Bad handshake'.",
 
3871
    (uchar**) &connect_timeout, (uchar**) &connect_timeout,
 
3872
   0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
3502
3873
  { "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],
 
3874
    "The DATE format (For future).",
 
3875
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
 
3876
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
3506
3877
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3507
3878
  { "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],
 
3879
    "The DATETIME/TIMESTAMP format (for future).",
 
3880
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
 
3881
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
3511
3882
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3512
3883
  { "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,
 
3884
    "The default week format used by WEEK() functions.",
 
3885
    (uchar**) &global_system_variables.default_week_format,
 
3886
    (uchar**) &max_system_variables.default_week_format,
3516
3887
    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,
 
3888
  {"div_precision_increment", OPT_DIV_PRECINCREMENT,
 
3889
   "Precision of the result of '/' operator will be increased on that value.",
 
3890
   (uchar**) &global_system_variables.div_precincrement,
 
3891
   (uchar**) &max_system_variables.div_precincrement, 0, GET_ULONG,
3522
3892
   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},
 
3893
  {"expire_logs_days", OPT_EXPIRE_LOGS_DAYS,
 
3894
   "If non-zero, binary logs will be purged after expire_logs_days "
 
3895
   "days; possible purges happen at startup and at binary log rotation.",
 
3896
   (uchar**) &expire_logs_days,
 
3897
   (uchar**) &expire_logs_days, 0, GET_ULONG,
 
3898
   REQUIRED_ARG, 0, 0, 99, 0, 1, 0},
 
3899
  { "flush_time", OPT_FLUSH_TIME,
 
3900
    "A dedicated thread is created to flush all tables at the given interval.",
 
3901
    (uchar**) &flush_time, (uchar**) &flush_time, 0, GET_ULONG, REQUIRED_ARG,
 
3902
    FLUSH_TIME, 0, LONG_TIMEOUT, 0, 1, 0},
3529
3903
  { "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,
 
3904
    "The maximum length of the result of function  group_concat.",
 
3905
    (uchar**) &global_system_variables.group_concat_max_len,
 
3906
    (uchar**) &max_system_variables.group_concat_max_len, 0, GET_ULONG,
3533
3907
    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,
 
3908
  {"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
 
3909
   "The number of seconds the server waits for activity on an interactive connection before closing it.",
 
3910
   (uchar**) &global_system_variables.net_interactive_timeout,
 
3911
   (uchar**) &max_system_variables.net_interactive_timeout, 0,
3539
3912
   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,
 
3913
  {"join_buffer_size", OPT_JOIN_BUFF_SIZE,
 
3914
   "The size of the buffer that is used for full joins.",
 
3915
   (uchar**) &global_system_variables.join_buff_size,
 
3916
   (uchar**) &max_system_variables.join_buff_size, 0, GET_ULONG,
3544
3917
   REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ULONG_MAX,
3545
3918
   MALLOC_OVERHEAD, IO_SIZE, 0},
3546
3919
  {"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,
 
3920
   "Don't overwrite stale .MYD and .MYI even if no directory is specified.",
 
3921
   (uchar**) &global_system_variables.keep_files_on_create,
 
3922
   (uchar**) &max_system_variables.keep_files_on_create,
3550
3923
   0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
3551
3924
  {"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,
 
3925
   "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.",
 
3926
   (uchar**) &dflt_key_cache_var.param_buff_size,
 
3927
   (uchar**) 0,
3557
3928
   0, (GET_ULL | GET_ASK_ADDR),
3558
3929
   REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, SIZE_T_MAX, MALLOC_OVERHEAD,
3559
3930
   IO_SIZE, 0},
3560
3931
  {"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,
 
3932
   "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",
 
3933
   (uchar**) &dflt_key_cache_var.param_age_threshold,
 
3934
   (uchar**) 0,
 
3935
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG, 
3568
3936
   300, 100, ULONG_MAX, 0, 100, 0},
3569
3937
  {"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,
 
3938
   "The default size of key cache blocks",
 
3939
   (uchar**) &dflt_key_cache_var.param_block_size,
 
3940
   (uchar**) 0,
3573
3941
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
3574
3942
   KEY_CACHE_BLOCK_SIZE, 512, 1024 * 16, 0, 512, 0},
3575
3943
  {"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,
 
3944
   "The minimum percentage of warm blocks in key cache",
 
3945
   (uchar**) &dflt_key_cache_var.param_division_limit,
 
3946
   (uchar**) 0,
3579
3947
   0, (GET_ULONG | GET_ASK_ADDR) , REQUIRED_ARG, 100,
3580
3948
   1, 100, 0, 1, 0},
3581
3949
  {"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,
 
3950
   "Log all queries that have taken more than long_query_time seconds to execute to file. "
 
3951
   "The argument will be treated as a decimal value with microsecond precission.",
 
3952
   (uchar**) &long_query_time, (uchar**) &long_query_time, 0, GET_DOUBLE,
3586
3953
   REQUIRED_ARG, 10, 0, LONG_TIMEOUT, 0, 0, 0},
 
3954
  {"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,
 
3955
   "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",
 
3956
   (uchar**) &lower_case_table_names,
 
3957
   (uchar**) &lower_case_table_names, 0, GET_UINT, OPT_ARG,
 
3958
#ifdef FN_NO_CASE_SENCE
 
3959
    1
 
3960
#else
 
3961
    0
 
3962
#endif
 
3963
   , 0, 2, 0, 1, 0},
3587
3964
  {"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,
 
3965
   "Max packetlength to send/receive from to server.",
 
3966
   (uchar**) &global_system_variables.max_allowed_packet,
 
3967
   (uchar**) &max_system_variables.max_allowed_packet, 0, GET_ULONG,
3591
3968
   REQUIRED_ARG, 1024*1024L, 1024, 1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},
3592
3969
  {"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,
 
3970
   "Can be used to restrict the total size used to cache a multi-transaction query.",
 
3971
   (uchar**) &max_binlog_cache_size, (uchar**) &max_binlog_cache_size, 0,
3596
3972
   GET_ULONG, REQUIRED_ARG, ULONG_MAX, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},
3597
3973
  {"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,
 
3974
   "Binary log will be rotated automatically when the size exceeds this \
 
3975
value. Will also apply to relay logs if max_relay_log_size is 0. \
 
3976
The minimum value for this variable is 4096.",
 
3977
   (uchar**) &max_binlog_size, (uchar**) &max_binlog_size, 0, GET_ULONG,
3602
3978
   REQUIRED_ARG, 1024*1024L*1024L, IO_SIZE, 1024*1024L*1024L, 0, IO_SIZE, 0},
3603
3979
  {"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},
 
3980
   "If there is more than this number of interrupted connections from a host this host will be blocked from further connections.",
 
3981
   (uchar**) &max_connect_errors, (uchar**) &max_connect_errors, 0, GET_ULONG,
 
3982
    REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ULONG_MAX, 0, 1, 0},
3608
3983
  // Default max_connections of 151 is larger than Apache's default max
3609
3984
  // children, to avoid "too many connections" error in a common setup
3610
3985
  {"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,
 
3986
   "The number of simultaneous clients allowed.", (uchar**) &max_connections,
 
3987
   (uchar**) &max_connections, 0, GET_ULONG, REQUIRED_ARG, 151, 1, 100000, 0, 1,
3614
3988
   0},
3615
3989
  {"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,
 
3990
   "Max number of errors/warnings to store for a statement.",
 
3991
   (uchar**) &global_system_variables.max_error_count,
 
3992
   (uchar**) &max_system_variables.max_error_count,
3619
3993
   0, GET_ULONG, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 0, 65535, 0, 1, 0},
3620
3994
  {"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,
 
3995
   "Don't allow creation of heap tables bigger than this.",
 
3996
   (uchar**) &global_system_variables.max_heap_table_size,
 
3997
   (uchar**) &max_system_variables.max_heap_table_size, 0, GET_ULL,
3624
3998
   REQUIRED_ARG, 16*1024*1024L, 16384, MAX_MEM_TABLE_SIZE,
3625
3999
   MALLOC_OVERHEAD, 1024, 0},
3626
4000
  {"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},
 
4001
   "Joins that are probably going to read more than max_join_size records return an error.",
 
4002
   (uchar**) &global_system_variables.max_join_size,
 
4003
   (uchar**) &max_system_variables.max_join_size, 0, GET_HA_ROWS, REQUIRED_ARG,
 
4004
   ~0L, 1, ~0L, 0, 1, 0},
 
4005
   {"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,
 
4006
    "Max number of bytes in sorted records.",
 
4007
    (uchar**) &global_system_variables.max_length_for_sort_data,
 
4008
    (uchar**) &max_system_variables.max_length_for_sort_data, 0, GET_ULONG,
 
4009
    REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
3637
4010
  {"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,
 
4011
   "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.",
 
4012
   (uchar**) &max_relay_log_size, (uchar**) &max_relay_log_size, 0, GET_ULONG,
3643
4013
   REQUIRED_ARG, 0L, 0L, 1024*1024L*1024L, 0, IO_SIZE, 0},
3644
4014
  { "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,
 
4015
    "Limit assumed max number of seeks when looking up rows based on a key",
 
4016
    (uchar**) &global_system_variables.max_seeks_for_key,
 
4017
    (uchar**) &max_system_variables.max_seeks_for_key, 0, GET_ULONG,
3648
4018
    REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0 },
3649
4019
  {"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,
 
4020
   "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).",
 
4021
   (uchar**) &global_system_variables.max_sort_length,
 
4022
   (uchar**) &max_system_variables.max_sort_length, 0, GET_ULONG,
3655
4023
   REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
3656
4024
  {"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,
 
4025
   "Maximum number of temporary tables a client can keep open at a time.",
 
4026
   (uchar**) &global_system_variables.max_tmp_tables,
 
4027
   (uchar**) &max_system_variables.max_tmp_tables, 0, GET_ULONG,
3660
4028
   REQUIRED_ARG, 32, 1, ULONG_MAX, 0, 1, 0},
3661
4029
  {"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,
 
4030
   "After this many write locks, allow some read locks to run in between.",
 
4031
   (uchar**) &max_write_lock_count, (uchar**) &max_write_lock_count, 0, GET_ULONG,
3664
4032
   REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0},
3665
4033
  {"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},
 
4034
   "Don't log queries which examine less than min_examined_row_limit rows to file.",
 
4035
   (uchar**) &global_system_variables.min_examined_row_limit,
 
4036
   (uchar**) &max_system_variables.min_examined_row_limit, 0, GET_ULONG,
 
4037
  REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1L, 0},
3671
4038
  {"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,
 
4039
   "Block size to be used for MyISAM index pages.",
 
4040
   (uchar**) &opt_myisam_block_size,
 
4041
   (uchar**) &opt_myisam_block_size, 0, GET_ULONG, REQUIRED_ARG,
3675
4042
   MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, MI_MAX_KEY_BLOCK_LENGTH,
3676
4043
   0, MI_MIN_KEY_BLOCK_LENGTH, 0},
3677
4044
  {"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,
 
4045
   "Default pointer size to be used for MyISAM tables.",
 
4046
   (uchar**) &myisam_data_pointer_size,
 
4047
   (uchar**) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,
3681
4048
   6, 2, 7, 0, 1, 0},
 
4049
  {"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
 
4050
   "Deprecated option",
 
4051
   (uchar**) &global_system_variables.myisam_max_extra_sort_file_size,
 
4052
   (uchar**) &max_system_variables.myisam_max_extra_sort_file_size,
 
4053
   0, GET_ULL, REQUIRED_ARG, (ulonglong) MI_MAX_TEMP_LENGTH,
 
4054
   0, (ulonglong) MAX_FILE_SIZE, 0, 1, 0},
3682
4055
  {"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,
 
4056
   "Don't use the fast sort index method to created index if the temporary file would get bigger than this.",
 
4057
   (uchar**) &global_system_variables.myisam_max_sort_file_size,
 
4058
   (uchar**) &max_system_variables.myisam_max_sort_file_size, 0,
 
4059
   GET_ULL, REQUIRED_ARG, (longlong) LONG_MAX, 0, (ulonglong) MAX_FILE_SIZE,
3688
4060
   0, 1024*1024, 0},
3689
4061
  {"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,
 
4062
   "Number of threads to use when repairing MyISAM tables. The value of 1 disables parallel repair.",
 
4063
   (uchar**) &global_system_variables.myisam_repair_threads,
 
4064
   (uchar**) &max_system_variables.myisam_repair_threads, 0,
3694
4065
   GET_ULONG, REQUIRED_ARG, 1, 1, ULONG_MAX, 0, 1, 0},
3695
4066
  {"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},
 
4067
   "The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE.",
 
4068
   (uchar**) &global_system_variables.myisam_sort_buff_size,
 
4069
   (uchar**) &max_system_variables.myisam_sort_buff_size, 0,
 
4070
   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, ~0L, 0, 1, 0},
3701
4071
  {"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,
 
4072
   "Specifies how MyISAM index statistics collection code should threat NULLs. "
 
4073
   "Possible values of name are \"nulls_unequal\" (default behavior for 4.1/5.0), "
 
4074
   "\"nulls_equal\" (emulate 4.0 behavior), and \"nulls_ignored\".",
 
4075
   (uchar**) &myisam_stats_method_str, (uchar**) &myisam_stats_method_str, 0,
3707
4076
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3708
4077
  {"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,
 
4078
   "Buffer length for TCP/IP and socket communication.",
 
4079
   (uchar**) &global_system_variables.net_buffer_length,
 
4080
   (uchar**) &max_system_variables.net_buffer_length, 0, GET_ULONG,
3712
4081
   REQUIRED_ARG, 16384, 1024, 1024*1024L, 0, 1024, 0},
3713
4082
  {"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,
 
4083
   "Number of seconds to wait for more data from a connection before aborting the read.",
 
4084
   (uchar**) &global_system_variables.net_read_timeout,
 
4085
   (uchar**) &max_system_variables.net_read_timeout, 0, GET_ULONG,
3718
4086
   REQUIRED_ARG, NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
3719
4087
  {"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,
 
4088
   "If a read on a communication port is interrupted, retry this many times before giving up.",
 
4089
   (uchar**) &global_system_variables.net_retry_count,
 
4090
   (uchar**) &max_system_variables.net_retry_count,0,
3724
4091
   GET_ULONG, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, ULONG_MAX, 0, 1, 0},
3725
4092
  {"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,
 
4093
   "Number of seconds to wait for a block to be written to a connection  before aborting the write.",
 
4094
   (uchar**) &global_system_variables.net_write_timeout,
 
4095
   (uchar**) &max_system_variables.net_write_timeout, 0, GET_ULONG,
3730
4096
   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,
 
4097
  { "old", OPT_OLD_MODE, "Use compatible behavior.", 
 
4098
    (uchar**) &global_system_variables.old_mode,
 
4099
    (uchar**) &max_system_variables.old_mode, 0, GET_BOOL, NO_ARG, 
3735
4100
    0, 0, 0, 0, 0, 0},
3736
4101
  {"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,
 
4102
   "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.",
 
4103
   (uchar**) &open_files_limit, (uchar**) &open_files_limit, 0, GET_ULONG,
3742
4104
   REQUIRED_ARG, 0, 0, OS_FILE_LIMIT, 0, 1, 0},
3743
4105
  {"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,
 
4106
   "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.",
 
4107
   (uchar**) &global_system_variables.optimizer_prune_level,
 
4108
   (uchar**) &max_system_variables.optimizer_prune_level,
3750
4109
   0, GET_ULONG, OPT_ARG, 1, 0, 1, 0, 1, 0},
3751
4110
  {"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,
 
4111
   "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).",
 
4112
   (uchar**) &global_system_variables.optimizer_search_depth,
 
4113
   (uchar**) &max_system_variables.optimizer_search_depth,
3762
4114
   0, GET_ULONG, OPT_ARG, MAX_TABLES+1, 0, MAX_TABLES+2, 0, 1, 0},
3763
4115
  {"plugin_dir", OPT_PLUGIN_DIR,
3764
 
   N_("Directory for plugins."),
3765
 
   (char**) &opt_plugin_dir_ptr, (char**) &opt_plugin_dir_ptr, 0,
 
4116
   "Directory for plugins.",
 
4117
   (uchar**) &opt_plugin_dir_ptr, (uchar**) &opt_plugin_dir_ptr, 0,
3766
4118
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3767
4119
  {"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,
 
4120
   "Optional colon separated list of plugins to load, where each plugin is "
 
4121
   "identified by name and path to library seperated by an equals.",
 
4122
   (uchar**) &opt_plugin_load, (uchar**) &opt_plugin_load, 0,
3772
4123
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3773
4124
  {"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,
 
4125
   "The size of the buffer that is allocated when preloading indexes",
 
4126
   (uchar**) &global_system_variables.preload_buff_size,
 
4127
   (uchar**) &max_system_variables.preload_buff_size, 0, GET_ULONG,
3777
4128
   REQUIRED_ARG, 32*1024L, 1024, 1024*1024*1024L, 0, 1, 0},
3778
4129
  {"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,
 
4130
   "Allocation block size for query parsing and execution",
 
4131
   (uchar**) &global_system_variables.query_alloc_block_size,
 
4132
   (uchar**) &max_system_variables.query_alloc_block_size, 0, GET_ULONG,
3782
4133
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
3783
4134
  {"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,
 
4135
   "Persistent buffer for query parsing and execution",
 
4136
   (uchar**) &global_system_variables.query_prealloc_size,
 
4137
   (uchar**) &max_system_variables.query_prealloc_size, 0, GET_ULONG,
3787
4138
   REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,
3788
4139
   ULONG_MAX, 0, 1024, 0},
3789
4140
  {"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,
 
4141
   "Allocation block size for storing ranges during optimization",
 
4142
   (uchar**) &global_system_variables.range_alloc_block_size,
 
4143
   (uchar**) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,
3793
4144
   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, ULONG_MAX,
3794
4145
   0, 1024, 0},
3795
4146
  {"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,
 
4147
   "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.",
 
4148
   (uchar**) &global_system_variables.read_buff_size,
 
4149
   (uchar**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
 
4150
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE,
3802
4151
   0},
3803
4152
  {"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,
 
4153
   "Make all non-temporary tables read-only, with the exception for replication (slave) threads and users with the SUPER privilege",
 
4154
   (uchar**) &opt_readonly,
 
4155
   (uchar**) &opt_readonly,
3808
4156
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3809
4157
  {"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,
 
4158
   "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.",
 
4159
   (uchar**) &global_system_variables.read_rnd_buff_size,
 
4160
   (uchar**) &max_system_variables.read_rnd_buff_size, 0,
3815
4161
   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},
 
4162
   INT_MAX32, MALLOC_OVERHEAD, 1 /* Small lower limit to be able to test MRR */, 0},
3817
4163
  {"record_buffer", OPT_RECORD_BUFFER,
3818
4164
   "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},
 
4165
   (uchar**) &global_system_variables.read_buff_size,
 
4166
   (uchar**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
 
4167
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE, 0},
3823
4168
  {"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,
 
4169
   "0 = do not purge relay logs. 1 = purge them as soon as they are no more needed.",
 
4170
   (uchar**) &relay_log_purge,
 
4171
   (uchar**) &relay_log_purge, 0, GET_BOOL, NO_ARG,
3828
4172
   1, 0, 1, 0, 1, 0},
3829
4173
  {"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},
 
4174
   "Maximum space to use for all relay logs.",
 
4175
   (uchar**) &relay_log_space_limit,
 
4176
   (uchar**) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,
 
4177
   (longlong) ULONG_MAX, 0, 1, 0},
3834
4178
  {"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,
 
4179
   "Use compression on master/slave protocol.",
 
4180
   (uchar**) &opt_slave_compressed_protocol,
 
4181
   (uchar**) &opt_slave_compressed_protocol,
3838
4182
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3839
4183
  {"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,
 
4184
   "Number of seconds to wait for more data from a master/slave connection before aborting the read.",
 
4185
   (uchar**) &slave_net_timeout, (uchar**) &slave_net_timeout, 0,
3843
4186
   GET_ULONG, REQUIRED_ARG, SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
3844
4187
  {"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},
 
4188
   "Number of times the slave SQL thread will retry a transaction in case "
 
4189
   "it failed with a deadlock or elapsed lock wait timeout, "
 
4190
   "before giving up and stopping.",
 
4191
   (uchar**) &slave_trans_retries, (uchar**) &slave_trans_retries, 0,
 
4192
   GET_ULONG, REQUIRED_ARG, 10L, 0L, (longlong) ULONG_MAX, 0, 1, 0},
3850
4193
  {"slave-allow-batching", OPT_SLAVE_ALLOW_BATCHING,
3851
 
   N_("Allow slave to batch requests."),
3852
 
   (char**) &slave_allow_batching, (char**) &slave_allow_batching,
 
4194
   "Allow slave to batch requests.",
 
4195
   (uchar**) &slave_allow_batching, (uchar**) &slave_allow_batching,
3853
4196
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
3854
4197
  {"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,
 
4198
   "If creating the thread takes longer than this value (in seconds), the Slow_launch_threads counter will be incremented.",
 
4199
   (uchar**) &slow_launch_time, (uchar**) &slow_launch_time, 0, GET_ULONG,
3858
4200
   REQUIRED_ARG, 2L, 0L, LONG_TIMEOUT, 0, 1, 0},
3859
4201
  {"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,
 
4202
   "Each thread that needs to do a sort allocates a buffer of this size.",
 
4203
   (uchar**) &global_system_variables.sortbuff_size,
 
4204
   (uchar**) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
3863
4205
   MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ULONG_MAX,
3864
4206
   MALLOC_OVERHEAD, 1, 0},
3865
4207
  {"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,
 
4208
   "Synchronously flush binary log to disk after every #th event. "
 
4209
   "Use 0 (default) to disable synchronous flushing.",
 
4210
   (uchar**) &sync_binlog_period, (uchar**) &sync_binlog_period, 0, GET_ULONG,
3869
4211
   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1, 0},
 
4212
  {"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default.",
 
4213
   (uchar**) &opt_sync_frm, (uchar**) &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,
 
4214
   0, 0, 0, 0},
 
4215
  {"table_cache", OPT_TABLE_OPEN_CACHE,
 
4216
   "Deprecated; use --table_open_cache instead.",
 
4217
   (uchar**) &table_cache_size, (uchar**) &table_cache_size, 0, GET_ULONG,
 
4218
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
3870
4219
  {"table_definition_cache", OPT_TABLE_DEF_CACHE,
3871
 
   N_("The number of cached table definitions."),
3872
 
   (char**) &table_def_size, (char**) &table_def_size,
 
4220
   "The number of cached table definitions.",
 
4221
   (uchar**) &table_def_size, (uchar**) &table_def_size,
3873
4222
   0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
3874
4223
  {"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,
 
4224
   "The number of cached open tables.",
 
4225
   (uchar**) &table_cache_size, (uchar**) &table_cache_size, 0, GET_ULONG,
3877
4226
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
3878
4227
  {"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,
 
4228
   "Timeout in seconds to wait for a table level lock before returning an "
 
4229
   "error. Used only if the connection has active cursors.",
 
4230
   (uchar**) &table_lock_wait_timeout, (uchar**) &table_lock_wait_timeout,
3882
4231
   0, GET_ULONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
3883
4232
  {"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,
 
4233
   "How many threads we should keep in a cache for reuse.",
 
4234
   (uchar**) &thread_cache_size, (uchar**) &thread_cache_size, 0, GET_ULONG,
3886
4235
   REQUIRED_ARG, 0, 0, 16384, 0, 1, 0},
3887
4236
  {"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,
 
4237
   "How many threads we should create to handle query requests in case of 'thread_handling=pool-of-threads'",
 
4238
   (uchar**) &thread_pool_size, (uchar**) &thread_pool_size, 0, GET_ULONG,
3891
4239
   REQUIRED_ARG, 20, 1, 16384, 0, 1, 0},
3892
4240
  {"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,
 
4241
   "The stack size for each thread.", (uchar**) &my_thread_stack_size,
 
4242
   (uchar**) &my_thread_stack_size, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,
3897
4243
   1024L*128L, ULONG_MAX, 0, 1024, 0},
3898
4244
  { "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],
 
4245
    "The TIME format (for future).",
 
4246
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
 
4247
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
3902
4248
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
3903
4249
  {"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,
 
4250
   "If an internal in-memory temporary table exceeds this size, MySQL will"
 
4251
   " automatically convert it to an on-disk MyISAM table.",
 
4252
   (uchar**) &global_system_variables.tmp_table_size,
 
4253
   (uchar**) &max_system_variables.tmp_table_size, 0, GET_ULL,
3908
4254
   REQUIRED_ARG, 16*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},
3909
4255
  {"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,
 
4256
   "Allocation block size for transactions to be stored in binary log",
 
4257
   (uchar**) &global_system_variables.trans_alloc_block_size,
 
4258
   (uchar**) &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,
3913
4259
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
3914
4260
  {"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,
 
4261
   "Persistent buffer for transactions to be stored in binary log",
 
4262
   (uchar**) &global_system_variables.trans_prealloc_size,
 
4263
   (uchar**) &max_system_variables.trans_prealloc_size, 0, GET_ULONG,
3918
4264
   REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
3919
4265
  {"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,
 
4266
   "The number of seconds the server waits for activity on a connection before closing it.",
 
4267
   (uchar**) &global_system_variables.net_wait_timeout,
 
4268
   (uchar**) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
 
4269
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT),
3925
4270
   0, 1, 0},
3926
4271
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
3927
4272
};
3928
4273
 
3929
 
static int show_net_compression(THD *thd __attribute__((unused)),
3930
 
                                SHOW_VAR *var,
3931
 
                                char *buff __attribute__((unused)))
 
4274
static int show_net_compression(THD *thd, SHOW_VAR *var, char *buff)
3932
4275
{
3933
4276
  var->type= SHOW_MY_BOOL;
3934
4277
  var->value= (char *)&thd->net.compress;
3935
4278
  return 0;
3936
4279
}
3937
4280
 
3938
 
static st_show_var_func_container
3939
 
show_net_compression_cont= { &show_net_compression };
3940
 
 
3941
4281
static int show_starttime(THD *thd, SHOW_VAR *var, char *buff)
3942
4282
{
3943
4283
  var->type= SHOW_LONG;
3946
4286
  return 0;
3947
4287
}
3948
4288
 
3949
 
static st_show_var_func_container
3950
 
show_starttime_cont= { &show_starttime };
3951
 
 
3952
4289
static int show_flushstatustime(THD *thd, SHOW_VAR *var, char *buff)
3953
4290
{
3954
4291
  var->type= SHOW_LONG;
3957
4294
  return 0;
3958
4295
}
3959
4296
 
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)
 
4297
static int show_slave_running(THD *thd, SHOW_VAR *var, char *buff)
3965
4298
{
3966
4299
  var->type= SHOW_MY_BOOL;
3967
4300
  pthread_mutex_lock(&LOCK_active_mi);
3968
4301
  var->value= buff;
3969
 
  *((bool *)buff)= (bool) (active_mi && active_mi->slave_running &&
 
4302
  *((my_bool *)buff)= (my_bool) (active_mi && active_mi->slave_running &&
3970
4303
                                 active_mi->rli.slave_running);
3971
4304
  pthread_mutex_unlock(&LOCK_active_mi);
3972
4305
  return 0;
3973
4306
}
3974
4307
 
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)
 
4308
static int show_slave_retried_trans(THD *thd, SHOW_VAR *var, char *buff)
3980
4309
{
3981
4310
  /*
3982
4311
    TODO: with multimaster, have one such counter per line in
3997
4326
  return 0;
3998
4327
}
3999
4328
 
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)
 
4329
static int show_slave_received_heartbeats(THD *thd, SHOW_VAR *var, char *buff)
4005
4330
{
4006
4331
  pthread_mutex_lock(&LOCK_active_mi);
4007
4332
  if (active_mi)
4009
4334
    var->type= SHOW_LONGLONG;
4010
4335
    var->value= buff;
4011
4336
    pthread_mutex_lock(&active_mi->rli.data_lock);
4012
 
    *((int64_t *)buff)= active_mi->received_heartbeats;
 
4337
    *((longlong *)buff)= active_mi->received_heartbeats;
4013
4338
    pthread_mutex_unlock(&active_mi->rli.data_lock);
4014
4339
  }
4015
4340
  else
4018
4343
  return 0;
4019
4344
}
4020
4345
 
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)
 
4346
static int show_heartbeat_period(THD *thd, SHOW_VAR *var, char *buff)
4026
4347
{
4027
4348
  pthread_mutex_lock(&LOCK_active_mi);
4028
4349
  if (active_mi)
4029
4350
  {
4030
4351
    var->type= SHOW_CHAR;
4031
4352
    var->value= buff;
4032
 
    sprintf(buff, "%.3f",active_mi->heartbeat_period);
 
4353
    my_sprintf(buff, (buff, "%.3f",active_mi->heartbeat_period));
4033
4354
  }
4034
4355
  else
4035
4356
    var->type= SHOW_UNDEF;
4037
4358
  return 0;
4038
4359
}
4039
4360
 
4040
 
static st_show_var_func_container
4041
 
show_heartbeat_period_cont= { &show_heartbeat_period};
4042
4361
 
4043
 
static int show_open_tables(THD *thd __attribute__((unused)),
4044
 
                            SHOW_VAR *var, char *buff)
 
4362
static int show_open_tables(THD *thd, SHOW_VAR *var, char *buff)
4045
4363
{
4046
4364
  var->type= SHOW_LONG;
4047
4365
  var->value= buff;
4049
4367
  return 0;
4050
4368
}
4051
4369
 
4052
 
static int show_table_definitions(THD *thd __attribute__((unused)),
4053
 
                                  SHOW_VAR *var, char *buff)
 
4370
static int show_table_definitions(THD *thd, SHOW_VAR *var, char *buff)
4054
4371
{
4055
4372
  var->type= SHOW_LONG;
4056
4373
  var->value= buff;
4058
4375
  return 0;
4059
4376
}
4060
4377
 
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
4378
/*
4067
4379
  Variables shown by SHOW STATUS in alphabetical order
4068
4380
*/
4075
4387
  {"Bytes_received",           (char*) offsetof(STATUS_VAR, bytes_received), SHOW_LONGLONG_STATUS},
4076
4388
  {"Bytes_sent",               (char*) offsetof(STATUS_VAR, bytes_sent), SHOW_LONGLONG_STATUS},
4077
4389
  {"Com",                      (char*) com_status_vars, SHOW_ARRAY},
4078
 
  {"Compression",              (char*) &show_net_compression_cont, SHOW_FUNC},
 
4390
  {"Compression",              (char*) &show_net_compression, SHOW_FUNC},
4079
4391
  {"Connections",              (char*) &thread_id,              SHOW_LONG_NOFLUSH},
4080
4392
  {"Created_tmp_disk_tables",  (char*) offsetof(STATUS_VAR, created_tmp_disk_tables), SHOW_LONG_STATUS},
4081
4393
  {"Created_tmp_files",        (char*) &my_tmp_file_created,    SHOW_LONG},
4107
4419
  {"Max_used_connections",     (char*) &max_used_connections,  SHOW_LONG},
4108
4420
  {"Open_files",               (char*) &my_file_opened,         SHOW_LONG_NOFLUSH},
4109
4421
  {"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},
 
4422
  {"Open_table_definitions",   (char*) &show_table_definitions, SHOW_FUNC},
 
4423
  {"Open_tables",              (char*) &show_open_tables,       SHOW_FUNC},
4112
4424
  {"Opened_files",             (char*) &my_file_total_opened, SHOW_LONG_NOFLUSH},
4113
4425
  {"Opened_tables",            (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},
4114
4426
  {"Opened_table_definitions", (char*) offsetof(STATUS_VAR, opened_shares), SHOW_LONG_STATUS},
4119
4431
  {"Select_range_check",       (char*) offsetof(STATUS_VAR, select_range_check_count), SHOW_LONG_STATUS},
4120
4432
  {"Select_scan",              (char*) offsetof(STATUS_VAR, select_scan_count), SHOW_LONG_STATUS},
4121
4433
  {"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},
 
4434
  {"Slave_retried_transactions",(char*) &show_slave_retried_trans, SHOW_FUNC},
 
4435
  {"Slave_heartbeat_period",   (char*) &show_heartbeat_period, SHOW_FUNC},
 
4436
  {"Slave_received_heartbeats",(char*) &show_slave_received_heartbeats, SHOW_FUNC},
 
4437
  {"Slave_running",            (char*) &show_slave_running,     SHOW_FUNC},
4126
4438
  {"Slow_launch_threads",      (char*) &slow_launch_threads,    SHOW_LONG},
4127
4439
  {"Slow_queries",             (char*) offsetof(STATUS_VAR, long_query_count), SHOW_LONG_STATUS},
4128
4440
  {"Sort_merge_passes",        (char*) offsetof(STATUS_VAR, filesort_merge_passes), SHOW_LONG_STATUS},
4140
4452
  {"Threads_connected",        (char*) &connection_count,       SHOW_INT},
4141
4453
  {"Threads_created",          (char*) &thread_created,         SHOW_LONG_NOFLUSH},
4142
4454
  {"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}
 
4455
  {"Uptime",                   (char*) &show_starttime,         SHOW_FUNC},
 
4456
  {"Uptime_since_flush_status",(char*) &show_flushstatustime,   SHOW_FUNC},
 
4457
  {NullS, NullS, SHOW_LONG}
4146
4458
};
4147
4459
 
4148
4460
static void print_version(void)
4153
4465
    version from the output of 'mysqld --version', so don't change it!
4154
4466
  */
4155
4467
  printf("%s  Ver %s for %s on %s (%s)\n",my_progname,
4156
 
         server_version,SYSTEM_TYPE,MACHINE_TYPE, DRIZZLE_COMPILATION_COMMENT);
 
4468
         server_version,SYSTEM_TYPE,MACHINE_TYPE, MYSQL_COMPILATION_COMMENT);
4157
4469
}
4158
4470
 
4159
4471
static void usage(void)
4165
4477
  if (!default_collation_name)
4166
4478
    default_collation_name= (char*) default_charset_info->name;
4167
4479
  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"));
 
4480
  puts("\
 
4481
Copyright (C) 2000 MySQL AB, by Monty and others\n\
 
4482
This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\
 
4483
and you are welcome to modify and redistribute it under the GPL license\n\n\
 
4484
Starts the MySQL database server\n");
4174
4485
 
4175
 
  printf(_("Usage: %s [OPTIONS]\n"), my_progname);
 
4486
  printf("Usage: %s [OPTIONS]\n", my_progname);
 
4487
  if (!opt_verbose)
 
4488
    puts("\nFor more help options (several pages), use mysqld --verbose --help");
 
4489
  else
4176
4490
  {
4177
 
#ifdef FOO
4178
 
  print_defaults(DRIZZLE_CONFIG_NAME,load_default_groups);
 
4491
  print_defaults(MYSQL_CONFIG_NAME,load_default_groups);
4179
4492
  puts("");
4180
4493
  set_ports();
4181
 
#endif
4182
4494
 
4183
4495
  /* Print out all the options including plugin supplied options */
4184
4496
  my_print_help_inc_plugins(my_long_options, sizeof(my_long_options)/sizeof(my_option));
4185
4497
 
4186
 
  puts(_("\nTo see what values a running Drizzle server is using, type\n"
4187
 
         "'drizzleadmin variables' instead of 'drizzled --help'."));
 
4498
  puts("\n\
 
4499
To see what values a running MySQL server is using, type\n\
 
4500
'mysqladmin variables' instead of 'mysqld --verbose --help'.");
4188
4501
  }
4189
4502
}
4190
4503
 
4210
4523
  /* Things reset to zero */
4211
4524
  opt_skip_slave_start= opt_reckless_slave = 0;
4212
4525
  mysql_home[0]= pidfile_name[0]= log_error_file[0]= 0;
 
4526
  opt_log= opt_slow_log= 0;
 
4527
  opt_update_log= 0;
4213
4528
  log_output_options= find_bit_type(log_output_str, &log_output_typelib);
4214
4529
  opt_bin_log= 0;
4215
 
  opt_skip_show_db=0;
4216
 
  opt_logname= opt_binlog_index_name= 0;
 
4530
  opt_disable_networking= opt_skip_show_db=0;
 
4531
  opt_logname= opt_update_logname= opt_binlog_index_name= opt_slow_logname= 0;
4217
4532
  opt_tc_log_file= (char *)"tc.log";      // no hostname in tc_log file name !
 
4533
  opt_secure_auth= 0;
4218
4534
  opt_secure_file_priv= 0;
 
4535
  opt_bootstrap= opt_myisam_log= 0;
 
4536
  mqh_used= 0;
4219
4537
  segfaulted= kill_in_progress= 0;
4220
4538
  cleanup_done= 0;
4221
4539
  defaults_argc= 0;
4234
4552
  binlog_cache_use=  binlog_cache_disk_use= 0;
4235
4553
  max_used_connections= slow_launch_threads = 0;
4236
4554
  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));
 
4555
  errmesg= 0;
 
4556
  opt_mysql_tmpdir= my_bind_addr_str= NullS;
 
4557
  bzero((uchar*) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));
 
4558
  bzero((char *) &global_status_var, sizeof(global_status_var));
4240
4559
  key_map_full.set_all();
4241
4560
 
4242
4561
  /* Character sets */
4253
4572
  slave_exec_mode_options= 0;
4254
4573
  slave_exec_mode_options= (uint)
4255
4574
    find_bit_type_or_exit(slave_exec_mode_str, &slave_exec_mode_typelib, NULL);
 
4575
  opt_specialflag= SPECIAL_ENGLISH;
 
4576
  ip_sock= INVALID_SOCKET;
4256
4577
  mysql_home_ptr= mysql_home;
4257
4578
  pidfile_name_ptr= pidfile_name;
4258
4579
  log_error_file_ptr= log_error_file;
4264
4585
  what_to_log= ~ (1L << (uint) COM_TIME);
4265
4586
  refresh_version= 1L;  /* Increments on each reload */
4266
4587
  global_query_id= thread_id= 1L;
4267
 
  my_stpcpy(server_version, DRIZZLE_SERVER_VERSION);
 
4588
  strmov(server_version, MYSQL_SERVER_VERSION);
4268
4589
  myisam_recover_options_str= "OFF";
4269
4590
  myisam_stats_method_str= "nulls_unequal";
4270
4591
  threads.empty();
4292
4613
 
4293
4614
  /* Variables in libraries */
4294
4615
  charsets_dir= 0;
4295
 
  default_character_set_name= (char*) DRIZZLE_DEFAULT_CHARSET_NAME;
 
4616
  default_character_set_name= (char*) MYSQL_DEFAULT_CHARSET_NAME;
4296
4617
  default_collation_name= compiled_default_collation_name;
 
4618
  sys_charset_system.set((char*) system_charset_info->csname);
4297
4619
  character_set_filesystem_name= (char*) "binary";
4298
4620
  lc_time_names_name= (char*) "en_US";
4299
4621
  /* Set default values for some option variables */
4300
 
  default_storage_engine_str= (char*) "innodb";
 
4622
  default_storage_engine_str= (char*) "MyISAM";
4301
4623
  global_system_variables.table_plugin= NULL;
4302
4624
  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;
 
4625
  global_system_variables.select_limit= (ulonglong) HA_POS_ERROR;
 
4626
  max_system_variables.select_limit=    (ulonglong) HA_POS_ERROR;
 
4627
  global_system_variables.max_join_size= (ulonglong) HA_POS_ERROR;
 
4628
  max_system_variables.max_join_size=   (ulonglong) HA_POS_ERROR;
 
4629
  global_system_variables.old_passwords= 0;
4307
4630
  global_system_variables.old_alter_table= 0;
4308
4631
  global_system_variables.binlog_format= BINLOG_FORMAT_UNSPEC;
4309
4632
  /*
4313
4636
  global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;
4314
4637
 
4315
4638
  /* Variables that depends on compile options */
4316
 
  opt_error_log= 0;
 
4639
#ifndef DBUG_OFF
 
4640
  default_dbug_option=IF_WIN("d:t:i:O,\\mysqld.trace",
 
4641
                             "d:t:i:o,/tmp/mysqld.trace");
 
4642
#endif
 
4643
  opt_error_log= IF_WIN(1,0);
4317
4644
#ifdef HAVE_BROKEN_REALPATH
4318
4645
  have_symlink=SHOW_OPTION_NO;
4319
4646
#else
4320
4647
  have_symlink=SHOW_OPTION_YES;
4321
4648
#endif
 
4649
#ifdef HAVE_DLOPEN
 
4650
  have_dlopen=SHOW_OPTION_YES;
 
4651
#else
 
4652
  have_dlopen=SHOW_OPTION_NO;
 
4653
#endif
 
4654
#ifdef HAVE_CRYPT
 
4655
  have_crypt=SHOW_OPTION_YES;
 
4656
#else
 
4657
  have_crypt=SHOW_OPTION_NO;
 
4658
#endif
4322
4659
#ifdef HAVE_COMPRESS
4323
4660
  have_compress= SHOW_OPTION_YES;
4324
4661
#else
4327
4664
 
4328
4665
  const char *tmpenv;
4329
4666
  if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))
4330
 
    tmpenv = DEFAULT_DRIZZLE_HOME;
 
4667
    tmpenv = DEFAULT_MYSQL_HOME;
4331
4668
  (void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);
4332
4669
}
4333
4670
 
4334
4671
 
4335
 
bool
 
4672
my_bool
4336
4673
mysqld_get_one_option(int optid,
4337
4674
                      const struct my_option *opt __attribute__((unused)),
4338
4675
                      char *argument)
4339
4676
{
4340
4677
  switch(optid) {
4341
4678
  case '#':
 
4679
#ifndef DBUG_OFF
 
4680
    DBUG_SET_INITIAL(argument ? argument : default_dbug_option);
 
4681
#endif
4342
4682
    opt_endinfo=1;                              /* unireg: memory allocation */
4343
4683
    break;
4344
4684
  case 'a':
4351
4691
    if (default_collation_name == compiled_default_collation_name)
4352
4692
      default_collation_name= 0;
4353
4693
    break;
 
4694
  case 'l':
 
4695
    opt_log=1;
 
4696
    break;
4354
4697
  case 'h':
4355
4698
    strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);
4356
4699
    /* Correct pointer set by my_getopt (for embedded library) */
4361
4704
    if (!mysqld_user || !strcmp(mysqld_user, argument))
4362
4705
      mysqld_user= argument;
4363
4706
    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);
 
4707
      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
4708
    break;
4368
4709
  case 'L':
4369
4710
    strmake(language, argument, sizeof(language)-1);
4390
4731
    test_flags= argument ? (uint) atoi(argument) : 0;
4391
4732
    opt_endinfo=1;
4392
4733
    break;
 
4734
  case (int) OPT_BIG_TABLES:
 
4735
    thd_startup_options|=OPTION_BIG_TABLES;
 
4736
    break;
 
4737
  case (int) OPT_ISAM_LOG:
 
4738
    opt_myisam_log=1;
 
4739
    break;
 
4740
  case (int) OPT_UPDATE_LOG:
 
4741
    opt_update_log=1;
 
4742
    break;
4393
4743
  case (int) OPT_BIN_LOG:
4394
4744
    opt_bin_log= test(argument != disabled_my_option);
4395
4745
    break;
4397
4747
    opt_error_log= 1;
4398
4748
    break;
4399
4749
  case (int)OPT_REPLICATE_IGNORE_DB:
4400
 
    {
4401
 
      rpl_filter->add_ignore_db(argument);
4402
 
      break;
4403
 
    }
 
4750
  {
 
4751
    rpl_filter->add_ignore_db(argument);
 
4752
    break;
 
4753
  }
4404
4754
  case (int)OPT_REPLICATE_DO_DB:
4405
 
    {
4406
 
      rpl_filter->add_do_db(argument);
4407
 
      break;
4408
 
    }
 
4755
  {
 
4756
    rpl_filter->add_do_db(argument);
 
4757
    break;
 
4758
  }
4409
4759
  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
 
    }
 
4760
  {
 
4761
    char* key = argument,*p, *val;
 
4762
 
 
4763
    if (!(p= strstr(argument, "->")))
 
4764
    {
 
4765
      fprintf(stderr,
 
4766
              "Bad syntax in replicate-rewrite-db - missing '->'!\n");
 
4767
      exit(1);
 
4768
    }
 
4769
    val= p--;
 
4770
    while (my_isspace(mysqld_charset, *p) && p > argument)
 
4771
      *p-- = 0;
 
4772
    if (p == argument)
 
4773
    {
 
4774
      fprintf(stderr,
 
4775
              "Bad syntax in replicate-rewrite-db - empty FROM db!\n");
 
4776
      exit(1);
 
4777
    }
 
4778
    *val= 0;
 
4779
    val+= 2;
 
4780
    while (*val && my_isspace(mysqld_charset, *val))
 
4781
      *val++;
 
4782
    if (!*val)
 
4783
    {
 
4784
      fprintf(stderr,
 
4785
              "Bad syntax in replicate-rewrite-db - empty TO db!\n");
 
4786
      exit(1);
 
4787
    }
 
4788
 
 
4789
    rpl_filter->add_db_rewrite(key, val);
 
4790
    break;
 
4791
  }
4442
4792
 
4443
4793
  case (int)OPT_BINLOG_IGNORE_DB:
4444
 
    {
4445
 
      binlog_filter->add_ignore_db(argument);
4446
 
      break;
4447
 
    }
 
4794
  {
 
4795
    binlog_filter->add_ignore_db(argument);
 
4796
    break;
 
4797
  }
4448
4798
  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
 
    }
 
4799
  {
 
4800
    int id;
 
4801
    id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);
 
4802
    global_system_variables.binlog_format= opt_binlog_format_id= id - 1;
 
4803
    break;
 
4804
  }
4455
4805
  case (int)OPT_BINLOG_DO_DB:
4456
 
    {
4457
 
      binlog_filter->add_do_db(argument);
4458
 
      break;
4459
 
    }
 
4806
  {
 
4807
    binlog_filter->add_do_db(argument);
 
4808
    break;
 
4809
  }
4460
4810
  case (int)OPT_REPLICATE_DO_TABLE:
 
4811
  {
 
4812
    if (rpl_filter->add_do_table(argument))
4461
4813
    {
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;
 
4814
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
 
4815
      exit(1);
4468
4816
    }
 
4817
    break;
 
4818
  }
4469
4819
  case (int)OPT_REPLICATE_WILD_DO_TABLE:
 
4820
  {
 
4821
    if (rpl_filter->add_wild_do_table(argument))
4470
4822
    {
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;
 
4823
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
 
4824
      exit(1);
4477
4825
    }
 
4826
    break;
 
4827
  }
4478
4828
  case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:
 
4829
  {
 
4830
    if (rpl_filter->add_wild_ignore_table(argument))
4479
4831
    {
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;
 
4832
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
 
4833
      exit(1);
4486
4834
    }
 
4835
    break;
 
4836
  }
4487
4837
  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
 
    }
 
4838
  {
 
4839
    if (rpl_filter->add_ignore_table(argument))
 
4840
    {
 
4841
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
 
4842
      exit(1);
 
4843
    }
 
4844
    break;
 
4845
  }
 
4846
  case (int) OPT_SLOW_QUERY_LOG:
 
4847
    opt_slow_log= 1;
 
4848
    break;
 
4849
#ifdef WITH_CSV_STORAGE_ENGINE
 
4850
  case  OPT_LOG_OUTPUT:
 
4851
  {
 
4852
    if (!argument || !argument[0])
 
4853
    {
 
4854
      log_output_options= LOG_FILE;
 
4855
      log_output_str= log_output_typelib.type_names[1];
 
4856
    }
 
4857
    else
 
4858
    {
 
4859
      log_output_str= argument;
 
4860
      log_output_options=
 
4861
        find_bit_type_or_exit(argument, &log_output_typelib, opt->name);
 
4862
  }
 
4863
    break;
 
4864
  }
 
4865
#endif
 
4866
  case (int) OPT_SKIP_NEW:
 
4867
    opt_specialflag|= SPECIAL_NO_NEW_FUNC;
 
4868
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
 
4869
    myisam_concurrent_insert=0;
 
4870
    myisam_recover_options= HA_RECOVER_NONE;
 
4871
    my_use_symdir=0;
 
4872
    ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);
 
4873
    break;
 
4874
  case (int) OPT_SAFE:
 
4875
    opt_specialflag|= SPECIAL_SAFE_MODE;
 
4876
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
 
4877
    myisam_recover_options= HA_RECOVER_DEFAULT;
 
4878
    ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);
 
4879
    break;
 
4880
  case (int) OPT_SKIP_PRIOR:
 
4881
    opt_specialflag|= SPECIAL_NO_PRIOR;
 
4882
    break;
 
4883
  case (int) OPT_SKIP_LOCK:
 
4884
    opt_external_locking=0;
 
4885
    break;
 
4886
  case (int) OPT_SKIP_SHOW_DB:
 
4887
    opt_skip_show_db=1;
 
4888
    opt_specialflag|=SPECIAL_SKIP_SHOW_DB;
 
4889
    break;
4496
4890
  case (int) OPT_WANT_CORE:
4497
4891
    test_flags |= TEST_CORE_ON_SIGNAL;
4498
4892
    break;
4504
4898
    break;
4505
4899
  case (int) OPT_BIND_ADDRESS:
4506
4900
    {
4507
 
      struct addrinfo *res_lst, hints;
 
4901
      struct addrinfo *res_lst, hints;    
4508
4902
 
4509
 
      memset(&hints, 0, sizeof(struct addrinfo));
 
4903
      bzero(&hints, sizeof(struct addrinfo));
4510
4904
      hints.ai_socktype= SOCK_STREAM;
4511
4905
      hints.ai_protocol= IPPROTO_TCP;
4512
4906
 
4513
 
      if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0)
 
4907
      if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0) 
4514
4908
      {
4515
 
        sql_print_error(_("Can't start server: cannot resolve hostname!"));
 
4909
        sql_print_error("Can't start server: cannot resolve hostname!");
4516
4910
        exit(1);
4517
4911
      }
4518
4912
 
4519
4913
      if (res_lst->ai_next)
4520
4914
      {
4521
 
        sql_print_error(_("Can't start server: bind-address refers to "
4522
 
                          "multiple interfaces!"));
 
4915
        sql_print_error("Can't start server: bind-address refers to multiple interfaces!");
4523
4916
        exit(1);
4524
4917
      }
4525
4918
      freeaddrinfo(res_lst);
4532
4925
    if (opt_console)
4533
4926
      opt_error_log= 0;                 // Force logs to stdout
4534
4927
    break;
 
4928
  case (int) OPT_FLUSH:
 
4929
    myisam_flush=1;
 
4930
    flush_time=0;                       // No auto flush
 
4931
    break;
4535
4932
  case OPT_LOW_PRIORITY_UPDATES:
4536
4933
    thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;
4537
4934
    global_system_variables.low_priority_updates=1;
4538
4935
    break;
 
4936
  case OPT_BOOTSTRAP:
 
4937
    opt_noacl=opt_bootstrap=1;
 
4938
    break;
4539
4939
  case OPT_SERVER_ID:
4540
4940
    server_id_supplied = 1;
4541
4941
    break;
4560
4960
    charsets_dir = mysql_charsets_dir;
4561
4961
    break;
4562
4962
  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
 
    }
 
4963
  {
 
4964
    int type;
 
4965
    type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);
 
4966
    global_system_variables.tx_isolation= (type-1);
 
4967
    break;
 
4968
  }
4569
4969
  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
 
    }
 
4970
  {
 
4971
    if (!argument)
 
4972
    {
 
4973
      myisam_recover_options=    HA_RECOVER_DEFAULT;
 
4974
      myisam_recover_options_str= myisam_recover_typelib.type_names[0];
 
4975
    }
 
4976
    else if (!argument[0])
 
4977
    {
 
4978
      myisam_recover_options= HA_RECOVER_NONE;
 
4979
      myisam_recover_options_str= "OFF";
 
4980
    }
 
4981
    else
 
4982
    {
 
4983
      myisam_recover_options_str=argument;
 
4984
      myisam_recover_options=
 
4985
        find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);
 
4986
    }
 
4987
    ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
 
4988
    break;
 
4989
  }
4590
4990
  case OPT_TC_HEURISTIC_RECOVER:
4591
4991
    tc_heuristic_recover= find_type_or_exit(argument,
4592
4992
                                            &tc_heuristic_recover_typelib,
4593
4993
                                            opt->name);
4594
4994
    break;
4595
4995
  case OPT_MYISAM_STATS_METHOD:
4596
 
    {
4597
 
      uint32_t method_conv;
4598
 
      int method;
 
4996
  {
 
4997
    ulong method_conv;
 
4998
    int method;
4599
4999
 
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;
 
5000
    myisam_stats_method_str= argument;
 
5001
    method= find_type_or_exit(argument, &myisam_stats_method_typelib,
 
5002
                              opt->name);
 
5003
    switch (method-1) {
 
5004
    case 2:
 
5005
      method_conv= MI_STATS_METHOD_IGNORE_NULLS;
 
5006
      break;
 
5007
    case 1:
 
5008
      method_conv= MI_STATS_METHOD_NULLS_EQUAL;
 
5009
      break;
 
5010
    case 0:
 
5011
    default:
 
5012
      method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
4616
5013
      break;
4617
5014
    }
 
5015
    global_system_variables.myisam_stats_method= method_conv;
 
5016
    break;
 
5017
  }
 
5018
  case OPT_LOWER_CASE_TABLE_NAMES:
 
5019
    lower_case_table_names= argument ? atoi(argument) : 1;
 
5020
    lower_case_table_names_used= 1;
 
5021
    break;
4618
5022
  }
4619
5023
  return 0;
4620
5024
}
4622
5026
 
4623
5027
/** Handle arguments for multiple key caches. */
4624
5028
 
4625
 
extern "C" char **mysql_getopt_value(const char *keyname, uint32_t key_length,
 
5029
extern "C" uchar **mysql_getopt_value(const char *keyname, uint key_length,
4626
5030
                                      const struct my_option *option);
4627
5031
 
4628
 
char**
4629
 
mysql_getopt_value(const char *keyname, uint32_t key_length,
 
5032
uchar* *
 
5033
mysql_getopt_value(const char *keyname, uint key_length,
4630
5034
                   const struct my_option *option)
4631
5035
{
4632
5036
  switch (option->id) {
4640
5044
      exit(1);
4641
5045
    switch (option->id) {
4642
5046
    case OPT_KEY_BUFFER_SIZE:
4643
 
      return (char**) &key_cache->param_buff_size;
 
5047
      return (uchar**) &key_cache->param_buff_size;
4644
5048
    case OPT_KEY_CACHE_BLOCK_SIZE:
4645
 
      return (char**) &key_cache->param_block_size;
 
5049
      return (uchar**) &key_cache->param_block_size;
4646
5050
    case OPT_KEY_CACHE_DIVISION_LIMIT:
4647
 
      return (char**) &key_cache->param_division_limit;
 
5051
      return (uchar**) &key_cache->param_division_limit;
4648
5052
    case OPT_KEY_CACHE_AGE_THRESHOLD:
4649
 
      return (char**) &key_cache->param_age_threshold;
 
5053
      return (uchar**) &key_cache->param_age_threshold;
4650
5054
    }
4651
5055
  }
4652
5056
  }
4653
 
  return (char **)option->value;
 
5057
  return option->value;
4654
5058
}
4655
5059
 
4656
5060
 
4662
5066
  va_start(args, format);
4663
5067
 
4664
5068
  /* Don't print warnings for --loose options during bootstrap */
4665
 
  if (level == ERROR_LEVEL || global_system_variables.log_warnings)
 
5069
  if (level == ERROR_LEVEL || !opt_bootstrap ||
 
5070
      global_system_variables.log_warnings)
4666
5071
  {
4667
5072
    vprint_msg_to_log(level, format, args);
4668
5073
  }
4682
5087
  my_getopt_error_reporter= option_error_reporter;
4683
5088
 
4684
5089
  /* Skip unknown options so that they may be processed later by plugins */
4685
 
  my_getopt_skip_unknown= true;
 
5090
  my_getopt_skip_unknown= TRUE;
4686
5091
 
4687
5092
  if ((ho_error= handle_options(argc, &argv, my_long_options,
4688
5093
                                mysqld_get_one_option)))
4690
5095
  (*argc)++; /* add back one for the progname handle_options removes */
4691
5096
             /* no need to do this for argv as we are discarding it. */
4692
5097
 
 
5098
  if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes ||
 
5099
       opt_log_slow_slave_statements) &&
 
5100
      !opt_slow_log)
 
5101
    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");
 
5102
 
4693
5103
#if defined(HAVE_BROKEN_REALPATH)
4694
5104
  my_use_symdir=0;
4695
5105
  my_disable_symlinks=1;
4720
5130
    Set some global variables from the global_system_variables
4721
5131
    In most cases the global variables will not be used
4722
5132
  */
 
5133
  my_disable_locking= myisam_single_user= test(opt_external_locking == 0);
4723
5134
  my_default_record_cache_size=global_system_variables.read_buff_size;
4724
5135
  myisam_max_temp_length=
4725
5136
    (my_off_t) global_system_variables.myisam_max_sort_file_size;
4729
5140
 
4730
5141
  /* long_query_time is in microseconds */
4731
5142
  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,
 
5143
    (longlong) (long_query_time * 1000000.0);
 
5144
 
 
5145
  if (opt_short_log_format)
 
5146
    opt_specialflag|= SPECIAL_SHORT_LOG_FORMAT;
 
5147
 
 
5148
  if (init_global_datetime_format(MYSQL_TIMESTAMP_DATE,
4735
5149
                                  &global_system_variables.date_format) ||
4736
 
      init_global_datetime_format(DRIZZLE_TIMESTAMP_TIME,
 
5150
      init_global_datetime_format(MYSQL_TIMESTAMP_TIME,
4737
5151
                                  &global_system_variables.time_format) ||
4738
 
      init_global_datetime_format(DRIZZLE_TIMESTAMP_DATETIME,
 
5152
      init_global_datetime_format(MYSQL_TIMESTAMP_DATETIME,
4739
5153
                                  &global_system_variables.datetime_format))
4740
5154
    exit(1);
4741
5155
 
4747
5161
  Create version name for running mysqld version
4748
5162
  We automaticly add suffixes -debug, -embedded and -log to the version
4749
5163
  name to make the version more descriptive.
4750
 
  (DRIZZLE_SERVER_SUFFIX is set by the compilation environment)
 
5164
  (MYSQL_SERVER_SUFFIX is set by the compilation environment)
4751
5165
*/
4752
5166
 
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
5167
static void set_server_version(void)
4760
5168
{
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
 
5169
  char *end= strxmov(server_version, MYSQL_SERVER_VERSION,
 
5170
                     MYSQL_SERVER_SUFFIX_STR, NullS);
 
5171
#ifndef DBUG_OFF
 
5172
  if (!strstr(MYSQL_SERVER_SUFFIX_STR, "-debug"))
 
5173
    end= strmov(end, "-debug");
 
5174
#endif
 
5175
  if (opt_log || opt_update_log || opt_slow_log || opt_bin_log)
 
5176
    strmov(end, "-log");                        // This may slow down system
4765
5177
}
4766
5178
 
4767
5179
 
4768
5180
static char *get_relative_path(const char *path)
4769
5181
{
4770
5182
  if (test_if_hard_path(path) &&
4771
 
      is_prefix(path,DEFAULT_DRIZZLE_HOME) &&
4772
 
      strcmp(DEFAULT_DRIZZLE_HOME,FN_ROOTDIR))
 
5183
      is_prefix(path,DEFAULT_MYSQL_HOME) &&
 
5184
      strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))
4773
5185
  {
4774
 
    path+=(uint) strlen(DEFAULT_DRIZZLE_HOME);
 
5186
    path+=(uint) strlen(DEFAULT_MYSQL_HOME);
4775
5187
    while (*path == FN_LIBCHAR)
4776
5188
      path++;
4777
5189
  }
4794
5206
  if (!test_if_hard_path(dir))
4795
5207
  {
4796
5208
    strxnmov(tmp_path,sizeof(tmp_path)-1, mysql_real_data_home,
4797
 
             dir, NULL);
 
5209
             dir, NullS);
4798
5210
    dir=tmp_path;
4799
5211
  }
4800
5212
  return !fn_format(to, name, dir, extension,
4805
5217
static void fix_paths(void)
4806
5218
{
4807
5219
  char buff[FN_REFLEN],*pos;
4808
 
  convert_dirname(mysql_home,mysql_home,NULL);
 
5220
  convert_dirname(mysql_home,mysql_home,NullS);
4809
5221
  /* Resolve symlinks to allow 'mysql_home' to be a relative symlink */
4810
5222
  my_realpath(mysql_home,mysql_home,MYF(0));
4811
5223
  /* Ensure that mysql_home ends in FN_LIBCHAR */
4812
 
  pos= strchr(mysql_home, '\0');
 
5224
  pos=strend(mysql_home);
4813
5225
  if (pos[-1] != FN_LIBCHAR)
4814
5226
  {
4815
5227
    pos[0]= FN_LIBCHAR;
4816
5228
    pos[1]= 0;
4817
5229
  }
4818
 
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NULL);
 
5230
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);
4819
5231
  (void) fn_format(buff, mysql_real_data_home, "", "",
4820
5232
                   (MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));
4821
5233
  (void) unpack_dirname(mysql_unpacked_real_data_home, buff);
4822
 
  convert_dirname(language,language,NULL);
 
5234
  convert_dirname(language,language,NullS);
4823
5235
  (void) my_load_path(mysql_home,mysql_home,""); // Resolve current dir
4824
5236
  (void) my_load_path(mysql_real_data_home,mysql_real_data_home,mysql_home);
4825
5237
  (void) my_load_path(pidfile_name,pidfile_name,mysql_real_data_home);
4831
5243
  if (test_if_hard_path(sharedir))
4832
5244
    strmake(buff,sharedir,sizeof(buff)-1);              /* purecov: tested */
4833
5245
  else
4834
 
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NULL);
4835
 
  convert_dirname(buff,buff,NULL);
 
5246
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NullS);
 
5247
  convert_dirname(buff,buff,NullS);
4836
5248
  (void) my_load_path(language,language,buff);
4837
5249
 
4838
5250
  /* If --character-sets-dir isn't given, use shared library dir */
4839
5251
  if (charsets_dir != mysql_charsets_dir)
4840
5252
  {
4841
5253
    strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,
4842
 
             CHARSET_DIR, NULL);
 
5254
             CHARSET_DIR, NullS);
4843
5255
  }
4844
5256
  (void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);
4845
 
  convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NULL);
 
5257
  convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NullS);
4846
5258
  charsets_dir=mysql_charsets_dir;
4847
5259
 
4848
5260
  if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))
4858
5270
   */
4859
5271
  if (opt_secure_file_priv)
4860
5272
  {
4861
 
    convert_dirname(buff, opt_secure_file_priv, NULL);
4862
 
    free(opt_secure_file_priv);
 
5273
    convert_dirname(buff, opt_secure_file_priv, NullS);
 
5274
    my_free(opt_secure_file_priv, MYF(0));
4863
5275
    opt_secure_file_priv= my_strdup(buff, MYF(MY_FAE));
4864
5276
  }
4865
5277
}
4866
5278
 
4867
5279
 
4868
 
static uint32_t find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
 
5280
static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
4869
5281
                                   const char *option)
4870
5282
{
4871
 
  uint32_t res;
 
5283
  ulong res;
4872
5284
 
4873
5285
  const char **ptr;
4874
 
 
4875
 
  if ((res= find_bit_type(x, bit_lib)) == ~(uint32_t) 0)
 
5286
  
 
5287
  if ((res= find_bit_type(x, bit_lib)) == ~(ulong) 0)
4876
5288
  {
4877
5289
    ptr= bit_lib->type_names;
4878
5290
    if (!*x)
4879
 
      fprintf(stderr, _("No option given to %s\n"), option);
 
5291
      fprintf(stderr, "No option given to %s\n", option);
4880
5292
    else
4881
 
      fprintf(stderr, _("Wrong option to %s. Option(s) given: %s\n"),
4882
 
              option, x);
4883
 
    fprintf(stderr, _("Alternatives are: '%s'"), *ptr);
 
5293
      fprintf(stderr, "Wrong option to %s. Option(s) given: %s\n", option, x);
 
5294
    fprintf(stderr, "Alternatives are: '%s'", *ptr);
4884
5295
    while (*++ptr)
4885
5296
      fprintf(stderr, ",'%s'", *ptr);
4886
5297
    fprintf(stderr, "\n");
4894
5305
  @return
4895
5306
    a bitfield from a string of substrings separated by ','
4896
5307
    or
4897
 
    ~(uint32_t) 0 on error.
 
5308
    ~(ulong) 0 on error.
4898
5309
*/
4899
5310
 
4900
 
static uint32_t find_bit_type(const char *x, TYPELIB *bit_lib)
 
5311
static ulong find_bit_type(const char *x, TYPELIB *bit_lib)
4901
5312
{
4902
5313
  bool found_end;
4903
5314
  int  found_count;
4904
5315
  const char *end,*i,*j;
4905
5316
  const char **array, *pos;
4906
 
  uint32_t found,found_int,bit;
 
5317
  ulong found,found_int,bit;
 
5318
  DBUG_ENTER("find_bit_type");
 
5319
  DBUG_PRINT("enter",("x: '%s'",x));
4907
5320
 
4908
5321
  found=0;
4909
5322
  found_end= 0;
4912
5325
  found_end= *pos == 0;
4913
5326
  while (!found_end)
4914
5327
  {
4915
 
    if ((end=strrchr(pos,',')) != NULL)         /* Let end point at fieldend */
 
5328
    if (!*(end=strcend(pos,',')))               /* Let end point at fieldend */
4916
5329
    {
4917
5330
      while (end > pos && end[-1] == ' ')
4918
5331
        end--;                                  /* Skip end-space */
4919
5332
      found_end=1;
4920
5333
    }
4921
 
    else
4922
 
    {
4923
 
        end=pos+strlen(pos);
4924
 
        found_end=1;
4925
 
    }
4926
5334
    found_int=0; found_count=0;
4927
5335
    for (array=bit_lib->type_names, bit=1 ; (i= *array++) ; bit<<=1)
4928
5336
    {
4946
5354
skip: ;
4947
5355
    }
4948
5356
    if (found_count != 1)
4949
 
      return(~(uint32_t) 0);                            // No unique value
 
5357
      DBUG_RETURN(~(ulong) 0);                          // No unique value
4950
5358
    found|=found_int;
4951
5359
    pos=end+1;
4952
5360
  }
4953
5361
 
4954
 
  return(found);
 
5362
  DBUG_PRINT("exit",("bit-field: %ld",(ulong) found));
 
5363
  DBUG_RETURN(found);
4955
5364
} /* find_bit_type */
4956
5365
 
4957
5366
 
4958
5367
/**
 
5368
  Check if file system used for databases is case insensitive.
 
5369
 
 
5370
  @param dir_name                       Directory to test
 
5371
 
 
5372
  @retval
 
5373
    -1  Don't know (Test failed)
 
5374
  @retval
 
5375
    0   File system is case sensitive
 
5376
  @retval
 
5377
    1   File system is case insensitive
 
5378
*/
 
5379
 
 
5380
static int test_if_case_insensitive(const char *dir_name)
 
5381
{
 
5382
  int result= 0;
 
5383
  File file;
 
5384
  char buff[FN_REFLEN], buff2[FN_REFLEN];
 
5385
  struct stat stat_info;
 
5386
  DBUG_ENTER("test_if_case_insensitive");
 
5387
 
 
5388
  fn_format(buff, glob_hostname, dir_name, ".lower-test",
 
5389
            MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
 
5390
  fn_format(buff2, glob_hostname, dir_name, ".LOWER-TEST",
 
5391
            MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
 
5392
  (void) my_delete(buff2, MYF(0));
 
5393
  if ((file= my_create(buff, 0666, O_RDWR, MYF(0))) < 0)
 
5394
  {
 
5395
    sql_print_warning("Can't create test file %s", buff);
 
5396
    DBUG_RETURN(-1);
 
5397
  }
 
5398
  my_close(file, MYF(0));
 
5399
  if (!stat(buff2, &stat_info))
 
5400
    result= 1;                                  // Can access file
 
5401
  (void) my_delete(buff, MYF(MY_WME));
 
5402
  DBUG_PRINT("exit", ("result: %d", result));
 
5403
  DBUG_RETURN(result);
 
5404
}
 
5405
 
 
5406
 
 
5407
/**
4959
5408
  Create file to store pid number.
4960
5409
*/
4961
5410
static void create_pid_file()
4967
5416
    char buff[21], *end;
4968
5417
    end= int10_to_str((long) getpid(), buff, 10);
4969
5418
    *end++= '\n';
4970
 
    if (!my_write(file, (unsigned char*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))
 
5419
    if (!my_write(file, (uchar*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))
4971
5420
    {
4972
5421
      (void) my_close(file, MYF(0));
4973
5422
      return;
4987
5436
  add_to_status(&global_status_var, &thd->status_var);
4988
5437
 
4989
5438
  /* Reset thread's status variables */
4990
 
  memset(&thd->status_var, 0, sizeof(thd->status_var));
 
5439
  bzero((uchar*) &thd->status_var, sizeof(thd->status_var));
4991
5440
 
4992
5441
  /* Reset some global variables */
4993
5442
  reset_status_vars();