← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/drizzled.cc

Removed/replaced DBUG symbols and standardized TRUE/FALSE

Show diffs side-by-side

added added

removed removed

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