~drizzle-trunk/drizzle/development

"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.",

3834

(uchar**) &opt_slow_logname, (uchar**) &opt_slow_logname, 0, GET_STR, OPT_ARG,

3835

0, 0, 0, 0, 0, 0},

3836

{"log-tc", OPT_LOG_TC,

3837

"Path to transaction coordinator log (used for transactions that affect "

3838

"more than one storage engine, when binary log is disabled)",

3839

(uchar**) &opt_tc_log_file, (uchar**) &opt_tc_log_file, 0, GET_STR,

3840

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3841

#ifdef HAVE_MMAP

3842

{"log-tc-size", OPT_LOG_TC_SIZE, "Size of transaction coordinator log.",

3843

(uchar**) &opt_tc_log_size, (uchar**) &opt_tc_log_size, 0, GET_ULONG,

3844

REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, ULONG_MAX, 0,

3845

TC_LOG_PAGE_SIZE, 0},

3846

#endif

3847

{"log-update", OPT_UPDATE_LOG,

3848

"The update log is deprecated since version 5.0, is replaced by the binary \

3849

log and this option justs turns on --log-bin instead.",

3850

(uchar**) &opt_update_logname, (uchar**) &opt_update_logname, 0, GET_STR,

3851

OPT_ARG, 0, 0, 0, 0, 0, 0},

3852

{"log-warnings", 'W', "Log some not critical warnings to the log file.",

3853

(uchar**) &global_system_variables.log_warnings,

3854

(uchar**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, 0,

3855

0, 0, 0},

3856

{"low-priority-updates", OPT_LOW_PRIORITY_UPDATES,

3857

"INSERT/DELETE/UPDATE has lower priority than selects.",

3858

(uchar**) &global_system_variables.low_priority_updates,

3859

(uchar**) &max_system_variables.low_priority_updates,

3860

0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

3861

{"master-info-file", OPT_MASTER_INFO_FILE,

3862

"The location and name of the file that remembers the master and where the I/O replication \

3863

thread is in the master's binlogs.",

3864

(uchar**) &master_info_file, (uchar**) &master_info_file, 0, GET_STR,

3865

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3866

{"master-retry-count", OPT_MASTER_RETRY_COUNT,

3867

"The number of tries the slave will make to connect to the master before giving up.",

3868

(uchar**) &master_retry_count, (uchar**) &master_retry_count, 0, GET_ULONG,

3869

REQUIRED_ARG, 3600*24, 0, 0, 0, 0, 0},

3870

{"max-binlog-dump-events", OPT_MAX_BINLOG_DUMP_EVENTS,

3871

"Option used by mysql-test for debugging and testing of replication.",

3872

(uchar**) &max_binlog_dump_events, (uchar**) &max_binlog_dump_events, 0,

3873

GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3874

{"memlock", OPT_MEMLOCK, "Lock mysqld in memory.", (uchar**) &locked_in_memory,

3875

(uchar**) &locked_in_memory, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

3876

{"myisam-recover", OPT_MYISAM_RECOVER,

3877

"Syntax: myisam-recover[=option[,option...]], where option can be DEFAULT, BACKUP, FORCE or QUICK.",

3878

(uchar**) &myisam_recover_options_str, (uchar**) &myisam_recover_options_str, 0,

3879

GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

3880

{"new", 'n', "Use very new possible 'unsafe' functions.",

3881

(uchar**) &global_system_variables.new_mode,

3882

(uchar**) &max_system_variables.new_mode,

3883

0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

3884

{"old-alter-table", OPT_OLD_ALTER_TABLE,

3885

"Use old, non-optimized alter table.",

3886

(uchar**) &global_system_variables.old_alter_table,

3887

(uchar**) &max_system_variables.old_alter_table, 0, GET_BOOL, NO_ARG,

3888

0, 0, 0, 0, 0, 0},

3889

{"old-passwords", OPT_OLD_PASSWORDS, "Use old password encryption method (needed for 4.0 and older clients).",

3890

(uchar**) &global_system_variables.old_passwords,

3891

(uchar**) &max_system_variables.old_passwords, 0, GET_BOOL, NO_ARG,

3892

0, 0, 0, 0, 0, 0},

3893

{"one-thread", OPT_ONE_THREAD,

3894

"(deprecated): Only use one thread (for debugging under Linux). Use thread-handling=no-threads instead",

3895

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

3896

{"pool-of-threads", OPT_POOL_OF_THREADS,

3897

"Use pool of threads during testing. NOTE: Use thread-handling=pool-of-threads instead",

3898

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

3899

{"old-style-user-limits", OPT_OLD_STYLE_USER_LIMITS,

3900

"Enable old-style user limits (before 5.0.3 user resources were counted per each user+host vs. per account)",

3901

(uchar**) &opt_old_style_user_limits, (uchar**) &opt_old_style_user_limits,

3902

0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

3903

{"pid-file", OPT_PID_FILE, "Pid file used by safe_mysqld.",

3904

(uchar**) &pidfile_name_ptr, (uchar**) &pidfile_name_ptr, 0, GET_STR,

3905

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3906

{"port", 'P', "Port number to use for connection or 0 for default to, in "

3907

"order of preference, my.cnf, $MYSQL_TCP_PORT, "

3908

#if MYSQL_PORT_DEFAULT == 0

3909

"/etc/services, "

3910

#endif

3911

"built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",

3912

(uchar**) &mysqld_port,

3913

(uchar**) &mysqld_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3914

{"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,

3915

"Maximum time in seconds to wait for the port to become free. "

3916

"(Default: no wait)", (uchar**) &mysqld_port_timeout,

3917

(uchar**) &mysqld_port_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3918

{"relay-log", OPT_RELAY_LOG,

3919

"The location and name to use for relay logs.",

3920

(uchar**) &opt_relay_logname, (uchar**) &opt_relay_logname, 0,

3921

GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3922

{"relay-log-index", OPT_RELAY_LOG_INDEX,

3923

"The location and name to use for the file that keeps a list of the last \

3924

relay logs.",

3925

(uchar**) &opt_relaylog_index_name, (uchar**) &opt_relaylog_index_name, 0,

3926

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3927

{"relay-log-info-file", OPT_RELAY_LOG_INFO_FILE,

3928

"The location and name of the file that remembers where the SQL replication \

3929

thread is in the relay logs.",

3930

(uchar**) &relay_log_info_file, (uchar**) &relay_log_info_file, 0, GET_STR,

3931

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3932

{"replicate-do-db", OPT_REPLICATE_DO_DB,

3933

"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.%.",

3934

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3935

{"replicate-do-table", OPT_REPLICATE_DO_TABLE,

3936

"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.",

3937

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3938

{"replicate-ignore-db", OPT_REPLICATE_IGNORE_DB,

3939

"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.%. ",

3940

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3941

{"replicate-ignore-table", OPT_REPLICATE_IGNORE_TABLE,

3942

"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.",

3943

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3944

{"replicate-rewrite-db", OPT_REPLICATE_REWRITE_DB,

3945

"Updates to a database with a different name than the original. Example: replicate-rewrite-db=master_db_name->slave_db_name.",

3946

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3947

{"replicate-same-server-id", OPT_REPLICATE_SAME_SERVER_ID,

3948

"In replication, if set to 1, do not skip events having our server id. \

3949

Default value is 0 (to break infinite loops in circular replication). \

3950

Can't be set to 1 if --log-slave-updates is used.",

3951

(uchar**) &replicate_same_server_id,

3952

(uchar**) &replicate_same_server_id,

3953

0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

3954

{"replicate-wild-do-table", OPT_REPLICATE_WILD_DO_TABLE,

3955

"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.",

3956

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3957

{"replicate-wild-ignore-table", OPT_REPLICATE_WILD_IGNORE_TABLE,

3958

"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.",

3959

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3960

// In replication, we may need to tell the other servers how to connect

3961

{"report-host", OPT_REPORT_HOST,

3962

"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.",

3963

(uchar**) &report_host, (uchar**) &report_host, 0, GET_STR, REQUIRED_ARG, 0, 0,

3964

0, 0, 0, 0},

3965

{"report-password", OPT_REPORT_PASSWORD, "Undocumented.",

3966

(uchar**) &report_password, (uchar**) &report_password, 0, GET_STR,

3967

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3968

{"report-port", OPT_REPORT_PORT,

3969

"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.",

3970

(uchar**) &report_port, (uchar**) &report_port, 0, GET_UINT, REQUIRED_ARG,

3971

MYSQL_PORT, 0, 0, 0, 0, 0},

3972

{"safe-mode", OPT_SAFE, "Skip some optimize stages (for testing).",

3973

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

3974

{"secure-file-priv", OPT_SECURE_FILE_PRIV,

3975

"Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files within specified directory",

3976

(uchar**) &opt_secure_file_priv, (uchar**) &opt_secure_file_priv, 0,

3977

GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3978

{"server-id", OPT_SERVER_ID,

3979

"Uniquely identifies the server instance in the community of replication partners.",

3980

(uchar**) &server_id, (uchar**) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,

3981

0, 0, 0},

3982

{"set-variable", 'O',

3983

"Change the value of a variable. Please note that this option is deprecated;you can set variables directly with --variable-name=value.",

3984

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3985

{"skip-new", OPT_SKIP_NEW, "Don't use new, possible wrong routines.",

3986

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

3987

{"skip-slave-start", OPT_SKIP_SLAVE_START,

3988

"If set, slave is not autostarted.", (uchar**) &opt_skip_slave_start,

3989

(uchar**) &opt_skip_slave_start, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

3990

{"skip-stack-trace", OPT_SKIP_STACK_TRACE,

3991

"Don't print a stack trace on failure.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,

3992

0, 0, 0, 0},

3993

{"skip-symlink", OPT_SKIP_SYMLINKS, "Don't allow symlinking of tables. Deprecated option. Use --skip-symbolic-links instead.",

3994

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

3995

{"skip-thread-priority", OPT_SKIP_PRIOR,

3996

"Don't give threads different priorities.", 0, 0, 0, GET_NO_ARG, NO_ARG,

3997

DEFAULT_SKIP_THREAD_PRIORITY, 0, 0, 0, 0, 0},

3998

#ifdef HAVE_REPLICATION

3999

{"slave-load-tmpdir", OPT_SLAVE_LOAD_TMPDIR,

4000

"The location where the slave should put its temporary files when \

4001

replicating a LOAD DATA INFILE command.",

4002

(uchar**) &slave_load_tmpdir, (uchar**) &slave_load_tmpdir, 0, GET_STR_ALLOC,

4003

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4004

{"slave-skip-errors", OPT_SLAVE_SKIP_ERRORS,

4005

"Tells the slave thread to continue replication when a query event returns an error from the provided list.",

4006

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4007

{"slave-exec-mode", OPT_SLAVE_EXEC_MODE,

4008

"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.",

4009

(uchar**) &slave_exec_mode_str, (uchar**) &slave_exec_mode_str, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4010

#endif

4011

{"slow-query-log", OPT_SLOW_LOG,

4012

"Enable|disable slow query log", (uchar**) &opt_slow_log,

4013

(uchar**) &opt_slow_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},

4014

{"socket", OPT_SOCKET, "Socket file to use for connection.",

4015

(uchar**) &mysqld_unix_port, (uchar**) &mysqld_unix_port, 0, GET_STR,

4016

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4017

#ifdef HAVE_REPLICATION

4018

{"sporadic-binlog-dump-fail", OPT_SPORADIC_BINLOG_DUMP_FAIL,

4019

"Option used by mysql-test for debugging and testing of replication.",

4020

(uchar**) &opt_sporadic_binlog_dump_fail,

4021

(uchar**) &opt_sporadic_binlog_dump_fail, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,

4022

0},

4023

#endif /* HAVE_REPLICATION */

4024

{"sql-bin-update-same", OPT_SQL_BIN_UPDATE_SAME,

4025

"The update log is deprecated since version 5.0, is replaced by the binary \

4026

log and this option does nothing anymore.",

4027

0, 0, 0, GET_DISABLED, NO_ARG, 0, 0, 0, 0, 0, 0},

4028

{"symbolic-links", 's', "Enable symbolic link support.",

4029

(uchar**) &my_use_symdir, (uchar**) &my_use_symdir, 0, GET_BOOL, NO_ARG,

4030

4031

The system call realpath() produces warnings under valgrind and

4032

purify. These are not suppressed: instead we disable symlinks

4033

option if compiled with valgrind support.

4034

4035

IF_PURIFY(0,1), 0, 0, 0, 0, 0},

4036

{"sysdate-is-now", OPT_SYSDATE_IS_NOW,

4037

"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.",

4038

(uchar**) &global_system_variables.sysdate_is_now,

4039

0, 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},

4040

{"tc-heuristic-recover", OPT_TC_HEURISTIC_RECOVER,

4041

"Decision to use in heuristic recover process. Possible values are COMMIT or ROLLBACK.",

4042

(uchar**) &opt_tc_heuristic_recover, (uchar**) &opt_tc_heuristic_recover,

4043

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4044

{"temp-pool", OPT_TEMP_POOL,

4045

"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.",

4046

(uchar**) &use_temp_pool, (uchar**) &use_temp_pool, 0, GET_BOOL, NO_ARG, 1,

4047

0, 0, 0, 0, 0},

4048

{"timed_mutexes", OPT_TIMED_MUTEXES,

4049

"Specify whether to time mutexes (only InnoDB mutexes are currently supported)",

4050

(uchar**) &timed_mutexes, (uchar**) &timed_mutexes, 0, GET_BOOL, NO_ARG, 0,

4051

0, 0, 0, 0, 0},

4052

{"tmpdir", 't',

4053

"Path for temporary files. Several paths may be specified, separated by a "

4054

"colon (:)"

4055

", in this case they are used in a round-robin fashion.",

4056

(uchar**) &opt_mysql_tmpdir,

4057

(uchar**) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4058

{"transaction-isolation", OPT_TX_ISOLATION,

4059

"Default transaction isolation level.", 0, 0, 0, GET_STR, REQUIRED_ARG, 0,

4060

0, 0, 0, 0, 0},

4061

{"use-symbolic-links", 's', "Enable symbolic link support. Deprecated option; use --symbolic-links instead.",

4062

(uchar**) &my_use_symdir, (uchar**) &my_use_symdir, 0, GET_BOOL, NO_ARG,

4063

IF_PURIFY(0,1), 0, 0, 0, 0, 0},

4064

{"user", 'u', "Run mysqld daemon as user.", 0, 0, 0, GET_STR, REQUIRED_ARG,

4065

0, 0, 0, 0, 0, 0},

4066

{"verbose", 'v', "Used with --help option for detailed help",

4067

(uchar**) &opt_verbose, (uchar**) &opt_verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

4068

0, 0},

4069

{"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,

4070

NO_ARG, 0, 0, 0, 0, 0, 0},

4071

{"warnings", 'W', "Deprecated; use --log-warnings instead.",

4072

(uchar**) &global_system_variables.log_warnings,

4073

(uchar**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG,

4074

1, 0, ULONG_MAX, 0, 0, 0},

4075

{ "back_log", OPT_BACK_LOG,

4076

"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.",

4077

(uchar**) &back_log, (uchar**) &back_log, 0, GET_ULONG,

4078

REQUIRED_ARG, 50, 1, 65535, 0, 1, 0 },

4079

{"binlog_cache_size", OPT_BINLOG_CACHE_SIZE,

4080

"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.",

4081

(uchar**) &binlog_cache_size, (uchar**) &binlog_cache_size, 0, GET_ULONG,

4082

REQUIRED_ARG, 32*1024L, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},

4083

{"bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,

4084

"Size of tree cache used in bulk insert optimisation. Note that this is a limit per thread!",

4085

(uchar**) &global_system_variables.bulk_insert_buff_size,

4086

(uchar**) &max_system_variables.bulk_insert_buff_size,

4087

0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, ULONG_MAX, 0, 1, 0},

4088

{"connect_timeout", OPT_CONNECT_TIMEOUT,

4089

"The number of seconds the mysqld server is waiting for a connect packet before responding with 'Bad handshake'.",

4090

(uchar**) &connect_timeout, (uchar**) &connect_timeout,

4091

0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },

4092

{ "date_format", OPT_DATE_FORMAT,

4093

"The DATE format (For future).",

4094

(uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],

4095

(uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],

4096

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4097

{ "datetime_format", OPT_DATETIME_FORMAT,

4098

"The DATETIME/TIMESTAMP format (for future).",

4099

(uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],

4100

(uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],

4101

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4102

{ "default_week_format", OPT_DEFAULT_WEEK_FORMAT,

4103

"The default week format used by WEEK() functions.",

4104

(uchar**) &global_system_variables.default_week_format,

4105

(uchar**) &max_system_variables.default_week_format,

4106

0, GET_ULONG, REQUIRED_ARG, 0, 0, 7L, 0, 1, 0},

4107

{"div_precision_increment", OPT_DIV_PRECINCREMENT,

4108

"Precision of the result of '/' operator will be increased on that value.",

4109

(uchar**) &global_system_variables.div_precincrement,

4110

(uchar**) &max_system_variables.div_precincrement, 0, GET_ULONG,

4111

REQUIRED_ARG, 4, 0, DECIMAL_MAX_SCALE, 0, 0, 0},

4112

{"expire_logs_days", OPT_EXPIRE_LOGS_DAYS,

4113

"If non-zero, binary logs will be purged after expire_logs_days "

4114

"days; possible purges happen at startup and at binary log rotation.",

4115

(uchar**) &expire_logs_days,

4116

(uchar**) &expire_logs_days, 0, GET_ULONG,

4117

REQUIRED_ARG, 0, 0, 99, 0, 1, 0},

4118

{ "flush_time", OPT_FLUSH_TIME,

4119

"A dedicated thread is created to flush all tables at the given interval.",

4120

(uchar**) &flush_time, (uchar**) &flush_time, 0, GET_ULONG, REQUIRED_ARG,

4121

FLUSH_TIME, 0, LONG_TIMEOUT, 0, 1, 0},

4122

{ "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,

4123

"The maximum length of the result of function group_concat.",

4124

(uchar**) &global_system_variables.group_concat_max_len,

4125

(uchar**) &max_system_variables.group_concat_max_len, 0, GET_ULONG,

4126

REQUIRED_ARG, 1024, 4, ULONG_MAX, 0, 1, 0},

4127

{"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,

4128

"The number of seconds the server waits for activity on an interactive connection before closing it.",

4129

(uchar**) &global_system_variables.net_interactive_timeout,

4130

(uchar**) &max_system_variables.net_interactive_timeout, 0,

4131

GET_ULONG, REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},

4132

{"join_buffer_size", OPT_JOIN_BUFF_SIZE,

4133

"The size of the buffer that is used for full joins.",

4134

(uchar**) &global_system_variables.join_buff_size,

4135

(uchar**) &max_system_variables.join_buff_size, 0, GET_ULONG,

4136

REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ULONG_MAX,

4137

MALLOC_OVERHEAD, IO_SIZE, 0},

4138

{"keep_files_on_create", OPT_KEEP_FILES_ON_CREATE,

4139

"Don't overwrite stale .MYD and .MYI even if no directory is specified.",

4140

(uchar**) &global_system_variables.keep_files_on_create,

4141

(uchar**) &max_system_variables.keep_files_on_create,

4142

0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},

4143

{"key_buffer_size", OPT_KEY_BUFFER_SIZE,

4144

"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.",

4145

(uchar**) &dflt_key_cache_var.param_buff_size,

4146

(uchar**) 0,

4147

0, (GET_ULL | GET_ASK_ADDR),

4148

REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, SIZE_T_MAX, MALLOC_OVERHEAD,

4149

IO_SIZE, 0},

4150

{"key_cache_age_threshold", OPT_KEY_CACHE_AGE_THRESHOLD,

4151

"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",

4152

(uchar**) &dflt_key_cache_var.param_age_threshold,

4153

(uchar**) 0,

4154

0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,

4155

300, 100, ULONG_MAX, 0, 100, 0},

4156

{"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,

4157

"The default size of key cache blocks",

4158

(uchar**) &dflt_key_cache_var.param_block_size,

4159

(uchar**) 0,

4160

0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,

4161

KEY_CACHE_BLOCK_SIZE, 512, 1024 * 16, 0, 512, 0},

4162

{"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,

4163

"The minimum percentage of warm blocks in key cache",

4164

(uchar**) &dflt_key_cache_var.param_division_limit,

4165

(uchar**) 0,

4166

0, (GET_ULONG | GET_ASK_ADDR) , REQUIRED_ARG, 100,

4167

1, 100, 0, 1, 0},

4168

{"long_query_time", OPT_LONG_QUERY_TIME,

4169

"Log all queries that have taken more than long_query_time seconds to execute to file. "

4170

"The argument will be treated as a decimal value with microsecond precission.",

4171

(uchar**) &long_query_time, (uchar**) &long_query_time, 0, GET_DOUBLE,

4172

REQUIRED_ARG, 10, 0, LONG_TIMEOUT, 0, 0, 0},

4173

{"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,

4174

"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",

4175

(uchar**) &lower_case_table_names,

4176

(uchar**) &lower_case_table_names, 0, GET_UINT, OPT_ARG,

4177

#ifdef FN_NO_CASE_SENCE

4178

4179

#else

4180

4181

#endif

4182

, 0, 2, 0, 1, 0},

4183

{"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,

4184

"Max packetlength to send/receive from to server.",

4185

(uchar**) &global_system_variables.max_allowed_packet,

4186

(uchar**) &max_system_variables.max_allowed_packet, 0, GET_ULONG,

4187

REQUIRED_ARG, 1024*1024L, 1024, 1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},

4188

{"max_binlog_cache_size", OPT_MAX_BINLOG_CACHE_SIZE,

4189

"Can be used to restrict the total size used to cache a multi-transaction query.",

4190

(uchar**) &max_binlog_cache_size, (uchar**) &max_binlog_cache_size, 0,

4191

GET_ULONG, REQUIRED_ARG, ULONG_MAX, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},

4192

{"max_binlog_size", OPT_MAX_BINLOG_SIZE,

4193

"Binary log will be rotated automatically when the size exceeds this \

4194

value. Will also apply to relay logs if max_relay_log_size is 0. \

4195

The minimum value for this variable is 4096.",

4196

(uchar**) &max_binlog_size, (uchar**) &max_binlog_size, 0, GET_ULONG,

4197

REQUIRED_ARG, 1024*1024L*1024L, IO_SIZE, 1024*1024L*1024L, 0, IO_SIZE, 0},

4198

{"max_connect_errors", OPT_MAX_CONNECT_ERRORS,

4199

"If there is more than this number of interrupted connections from a host this host will be blocked from further connections.",

4200

(uchar**) &max_connect_errors, (uchar**) &max_connect_errors, 0, GET_ULONG,

4201

REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ULONG_MAX, 0, 1, 0},

4202

// Default max_connections of 151 is larger than Apache's default max

4203

// children, to avoid "too many connections" error in a common setup

4204

{"max_connections", OPT_MAX_CONNECTIONS,

4205

"The number of simultaneous clients allowed.", (uchar**) &max_connections,

4206

(uchar**) &max_connections, 0, GET_ULONG, REQUIRED_ARG, 151, 1, 100000, 0, 1,

4207

0},

4208

{"max_error_count", OPT_MAX_ERROR_COUNT,

4209

"Max number of errors/warnings to store for a statement.",

4210

(uchar**) &global_system_variables.max_error_count,

4211

(uchar**) &max_system_variables.max_error_count,

4212

0, GET_ULONG, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 0, 65535, 0, 1, 0},

4213

{"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,

4214

"Don't allow creation of heap tables bigger than this.",

4215

(uchar**) &global_system_variables.max_heap_table_size,

4216

(uchar**) &max_system_variables.max_heap_table_size, 0, GET_ULL,

4217

REQUIRED_ARG, 16*1024*1024L, 16384, MAX_MEM_TABLE_SIZE,

4218

MALLOC_OVERHEAD, 1024, 0},

4219

{"max_join_size", OPT_MAX_JOIN_SIZE,

4220

"Joins that are probably going to read more than max_join_size records return an error.",

4221

(uchar**) &global_system_variables.max_join_size,

4222

(uchar**) &max_system_variables.max_join_size, 0, GET_HA_ROWS, REQUIRED_ARG,

4223

~0L, 1, ~0L, 0, 1, 0},

4224

{"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,

4225

"Max number of bytes in sorted records.",

4226

(uchar**) &global_system_variables.max_length_for_sort_data,

4227

(uchar**) &max_system_variables.max_length_for_sort_data, 0, GET_ULONG,

4228

REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},

4229

{"max_prepared_stmt_count", OPT_MAX_PREPARED_STMT_COUNT,

4230

"Maximum number of prepared statements in the server.",

4231

(uchar**) &max_prepared_stmt_count, (uchar**) &max_prepared_stmt_count,

4232

0, GET_ULONG, REQUIRED_ARG, 16382, 0, 1*1024*1024, 0, 1, 0},

4233

{"max_relay_log_size", OPT_MAX_RELAY_LOG_SIZE,

4234

"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.",

4235

(uchar**) &max_relay_log_size, (uchar**) &max_relay_log_size, 0, GET_ULONG,

4236

REQUIRED_ARG, 0L, 0L, 1024*1024L*1024L, 0, IO_SIZE, 0},

4237

{ "max_seeks_for_key", OPT_MAX_SEEKS_FOR_KEY,

4238

"Limit assumed max number of seeks when looking up rows based on a key",

4239

(uchar**) &global_system_variables.max_seeks_for_key,

4240

(uchar**) &max_system_variables.max_seeks_for_key, 0, GET_ULONG,

4241

REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0 },

4242

{"max_sort_length", OPT_MAX_SORT_LENGTH,

4243

"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).",

4244

(uchar**) &global_system_variables.max_sort_length,

4245

(uchar**) &max_system_variables.max_sort_length, 0, GET_ULONG,

4246

REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},

4247

{"max_tmp_tables", OPT_MAX_TMP_TABLES,

4248

"Maximum number of temporary tables a client can keep open at a time.",

4249

(uchar**) &global_system_variables.max_tmp_tables,

4250

(uchar**) &max_system_variables.max_tmp_tables, 0, GET_ULONG,

4251

REQUIRED_ARG, 32, 1, ULONG_MAX, 0, 1, 0},

4252

{"max_write_lock_count", OPT_MAX_WRITE_LOCK_COUNT,

4253

"After this many write locks, allow some read locks to run in between.",

4254

(uchar**) &max_write_lock_count, (uchar**) &max_write_lock_count, 0, GET_ULONG,

4255

REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0},

4256

{"min_examined_row_limit", OPT_MIN_EXAMINED_ROW_LIMIT,

4257

"Don't log queries which examine less than min_examined_row_limit rows to file.",

4258

(uchar**) &global_system_variables.min_examined_row_limit,

4259

(uchar**) &max_system_variables.min_examined_row_limit, 0, GET_ULONG,

4260

REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1L, 0},

4261

{"myisam_block_size", OPT_MYISAM_BLOCK_SIZE,

4262

"Block size to be used for MyISAM index pages.",

4263

(uchar**) &opt_myisam_block_size,

4264

(uchar**) &opt_myisam_block_size, 0, GET_ULONG, REQUIRED_ARG,

4265

MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, MI_MAX_KEY_BLOCK_LENGTH,

4266

0, MI_MIN_KEY_BLOCK_LENGTH, 0},

4267

{"myisam_data_pointer_size", OPT_MYISAM_DATA_POINTER_SIZE,

4268

"Default pointer size to be used for MyISAM tables.",

4269

(uchar**) &myisam_data_pointer_size,

4270

(uchar**) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,

4271

6, 2, 7, 0, 1, 0},

4272

{"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,

4273

"Deprecated option",

4274

(uchar**) &global_system_variables.myisam_max_extra_sort_file_size,

4275

(uchar**) &max_system_variables.myisam_max_extra_sort_file_size,

4276

0, GET_ULL, REQUIRED_ARG, (ulonglong) MI_MAX_TEMP_LENGTH,

4277

0, (ulonglong) MAX_FILE_SIZE, 0, 1, 0},

4278

{"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,

4279

"Don't use the fast sort index method to created index if the temporary file would get bigger than this.",

4280

(uchar**) &global_system_variables.myisam_max_sort_file_size,

4281

(uchar**) &max_system_variables.myisam_max_sort_file_size, 0,

4282

GET_ULL, REQUIRED_ARG, (longlong) LONG_MAX, 0, (ulonglong) MAX_FILE_SIZE,

4283

0, 1024*1024, 0},

4284

{"myisam_repair_threads", OPT_MYISAM_REPAIR_THREADS,

4285

"Number of threads to use when repairing MyISAM tables. The value of 1 disables parallel repair.",

4286

(uchar**) &global_system_variables.myisam_repair_threads,

4287

(uchar**) &max_system_variables.myisam_repair_threads, 0,

4288

GET_ULONG, REQUIRED_ARG, 1, 1, ULONG_MAX, 0, 1, 0},

4289

{"myisam_sort_buffer_size", OPT_MYISAM_SORT_BUFFER_SIZE,

4290

"The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE.",

4291

(uchar**) &global_system_variables.myisam_sort_buff_size,

4292

(uchar**) &max_system_variables.myisam_sort_buff_size, 0,

4293

GET_ULONG, REQUIRED_ARG, 8192*1024, 4, ~0L, 0, 1, 0},

4294

{"myisam_stats_method", OPT_MYISAM_STATS_METHOD,

4295

"Specifies how MyISAM index statistics collection code should threat NULLs. "

4296

"Possible values of name are \"nulls_unequal\" (default behavior for 4.1/5.0), "

4297

"\"nulls_equal\" (emulate 4.0 behavior), and \"nulls_ignored\".",

4298

(uchar**) &myisam_stats_method_str, (uchar**) &myisam_stats_method_str, 0,

4299

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4300

{"net_buffer_length", OPT_NET_BUFFER_LENGTH,

4301

"Buffer length for TCP/IP and socket communication.",

4302

(uchar**) &global_system_variables.net_buffer_length,

4303

(uchar**) &max_system_variables.net_buffer_length, 0, GET_ULONG,

4304

REQUIRED_ARG, 16384, 1024, 1024*1024L, 0, 1024, 0},

4305

{"net_read_timeout", OPT_NET_READ_TIMEOUT,

4306

"Number of seconds to wait for more data from a connection before aborting the read.",

4307

(uchar**) &global_system_variables.net_read_timeout,

4308

(uchar**) &max_system_variables.net_read_timeout, 0, GET_ULONG,

4309

REQUIRED_ARG, NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},

4310

{"net_retry_count", OPT_NET_RETRY_COUNT,

4311

"If a read on a communication port is interrupted, retry this many times before giving up.",

4312

(uchar**) &global_system_variables.net_retry_count,

4313

(uchar**) &max_system_variables.net_retry_count,0,

4314

GET_ULONG, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, ULONG_MAX, 0, 1, 0},

4315

{"net_write_timeout", OPT_NET_WRITE_TIMEOUT,

4316

"Number of seconds to wait for a block to be written to a connection before aborting the write.",

4317

(uchar**) &global_system_variables.net_write_timeout,

4318

(uchar**) &max_system_variables.net_write_timeout, 0, GET_ULONG,

4319

REQUIRED_ARG, NET_WRITE_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},

4320

{ "old", OPT_OLD_MODE, "Use compatible behavior.",

4321

(uchar**) &global_system_variables.old_mode,

4322

(uchar**) &max_system_variables.old_mode, 0, GET_BOOL, NO_ARG,

4323

0, 0, 0, 0, 0, 0},

4324

{"open_files_limit", OPT_OPEN_FILES_LIMIT,

4325

"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.",

4326

(uchar**) &open_files_limit, (uchar**) &open_files_limit, 0, GET_ULONG,

4327

REQUIRED_ARG, 0, 0, OS_FILE_LIMIT, 0, 1, 0},

4328

{"optimizer_prune_level", OPT_OPTIMIZER_PRUNE_LEVEL,

4329

"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.",

4330

(uchar**) &global_system_variables.optimizer_prune_level,

4331

(uchar**) &max_system_variables.optimizer_prune_level,

4332

0, GET_ULONG, OPT_ARG, 1, 0, 1, 0, 1, 0},

4333

{"optimizer_search_depth", OPT_OPTIMIZER_SEARCH_DEPTH,

4334

"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).",

4335

(uchar**) &global_system_variables.optimizer_search_depth,

4336

(uchar**) &max_system_variables.optimizer_search_depth,

4337

0, GET_ULONG, OPT_ARG, MAX_TABLES+1, 0, MAX_TABLES+2, 0, 1, 0},

4338

{"plugin_dir", OPT_PLUGIN_DIR,

4339

"Directory for plugins.",

4340

(uchar**) &opt_plugin_dir_ptr, (uchar**) &opt_plugin_dir_ptr, 0,

4341

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4342

{"plugin_load", OPT_PLUGIN_LOAD,

4343

"Optional colon separated list of plugins to load, where each plugin is "

4344

"identified by name and path to library seperated by an equals.",

4345

(uchar**) &opt_plugin_load, (uchar**) &opt_plugin_load, 0,

4346

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4347

{"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,

4348

"The size of the buffer that is allocated when preloading indexes",

4349

(uchar**) &global_system_variables.preload_buff_size,

4350

(uchar**) &max_system_variables.preload_buff_size, 0, GET_ULONG,

4351

REQUIRED_ARG, 32*1024L, 1024, 1024*1024*1024L, 0, 1, 0},

4352

{"query_alloc_block_size", OPT_QUERY_ALLOC_BLOCK_SIZE,

4353

"Allocation block size for query parsing and execution",

4354

(uchar**) &global_system_variables.query_alloc_block_size,

4355

(uchar**) &max_system_variables.query_alloc_block_size, 0, GET_ULONG,

4356

REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},

4357

{"query_prealloc_size", OPT_QUERY_PREALLOC_SIZE,

4358

"Persistent buffer for query parsing and execution",

4359

(uchar**) &global_system_variables.query_prealloc_size,

4360

(uchar**) &max_system_variables.query_prealloc_size, 0, GET_ULONG,

4361

REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,

4362

ULONG_MAX, 0, 1024, 0},

4363

{"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,

4364

"Allocation block size for storing ranges during optimization",

4365

(uchar**) &global_system_variables.range_alloc_block_size,

4366

(uchar**) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,

4367

REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, ULONG_MAX,

4368

0, 1024, 0},

4369

{"read_buffer_size", OPT_RECORD_BUFFER,

4370

"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.",

4371

(uchar**) &global_system_variables.read_buff_size,

4372

(uchar**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,

4373

128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE,

4374

0},

4375

{"read_only", OPT_READONLY,

4376

"Make all non-temporary tables read-only, with the exception for replication (slave) threads and users with the SUPER privilege",

4377

(uchar**) &opt_readonly,

4378

(uchar**) &opt_readonly,

4379

0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},

4380

{"read_rnd_buffer_size", OPT_RECORD_RND_BUFFER,

4381

"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.",

4382

(uchar**) &global_system_variables.read_rnd_buff_size,

4383

(uchar**) &max_system_variables.read_rnd_buff_size, 0,

4384

GET_ULONG, REQUIRED_ARG, 256*1024L, 64 /*IO_SIZE*2+MALLOC_OVERHEAD*/ ,

4385

INT_MAX32, MALLOC_OVERHEAD, 1 /* Small lower limit to be able to test MRR */, 0},

4386

{"record_buffer", OPT_RECORD_BUFFER,

4387

"Alias for read_buffer_size",

4388

(uchar**) &global_system_variables.read_buff_size,

4389

(uchar**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,

4390

128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE, 0},

4391

#ifdef HAVE_REPLICATION

4392

{"relay_log_purge", OPT_RELAY_LOG_PURGE,

4393

"0 = do not purge relay logs. 1 = purge them as soon as they are no more needed.",

4394

(uchar**) &relay_log_purge,

4395

(uchar**) &relay_log_purge, 0, GET_BOOL, NO_ARG,

4396

1, 0, 1, 0, 1, 0},

4397

{"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,

4398

"Maximum space to use for all relay logs.",

4399

(uchar**) &relay_log_space_limit,

4400

(uchar**) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,

4401

(longlong) ULONG_MAX, 0, 1, 0},

4402

{"slave_compressed_protocol", OPT_SLAVE_COMPRESSED_PROTOCOL,

4403

"Use compression on master/slave protocol.",

4404

(uchar**) &opt_slave_compressed_protocol,

4405

(uchar**) &opt_slave_compressed_protocol,

4406

0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},

4407

{"slave_net_timeout", OPT_SLAVE_NET_TIMEOUT,

4408

"Number of seconds to wait for more data from a master/slave connection before aborting the read.",

4409

(uchar**) &slave_net_timeout, (uchar**) &slave_net_timeout, 0,

4410

GET_ULONG, REQUIRED_ARG, SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},

4411

{"slave_transaction_retries", OPT_SLAVE_TRANS_RETRIES,

4412

"Number of times the slave SQL thread will retry a transaction in case "

4413

"it failed with a deadlock or elapsed lock wait timeout, "

4414

"before giving up and stopping.",

4415

(uchar**) &slave_trans_retries, (uchar**) &slave_trans_retries, 0,

4416

GET_ULONG, REQUIRED_ARG, 10L, 0L, (longlong) ULONG_MAX, 0, 1, 0},

4417

{"slave-allow-batching", OPT_SLAVE_ALLOW_BATCHING,

4418

"Allow slave to batch requests.",

4419

(uchar**) &slave_allow_batching, (uchar**) &slave_allow_batching,

4420

0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},

4421

#endif /* HAVE_REPLICATION */

4422

{"slow_launch_time", OPT_SLOW_LAUNCH_TIME,

4423

"If creating the thread takes longer than this value (in seconds), the Slow_launch_threads counter will be incremented.",

4424

(uchar**) &slow_launch_time, (uchar**) &slow_launch_time, 0, GET_ULONG,

4425

REQUIRED_ARG, 2L, 0L, LONG_TIMEOUT, 0, 1, 0},

4426

{"sort_buffer_size", OPT_SORT_BUFFER,

4427

"Each thread that needs to do a sort allocates a buffer of this size.",

4428

(uchar**) &global_system_variables.sortbuff_size,

4429

(uchar**) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,

4430

MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ULONG_MAX,

4431

MALLOC_OVERHEAD, 1, 0},

4432

{"sync-binlog", OPT_SYNC_BINLOG,

4433

"Synchronously flush binary log to disk after every #th event. "

4434

"Use 0 (default) to disable synchronous flushing.",

4435

(uchar**) &sync_binlog_period, (uchar**) &sync_binlog_period, 0, GET_ULONG,

4436

REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1, 0},

4437

{"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default.",

4438

(uchar**) &opt_sync_frm, (uchar**) &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,

4439

0, 0, 0, 0},

4440

{"table_cache", OPT_TABLE_OPEN_CACHE,

4441

"Deprecated; use --table_open_cache instead.",

4442

(uchar**) &table_cache_size, (uchar**) &table_cache_size, 0, GET_ULONG,

4443

REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},

4444

{"table_definition_cache", OPT_TABLE_DEF_CACHE,

4445

"The number of cached table definitions.",

4446

(uchar**) &table_def_size, (uchar**) &table_def_size,

4447

0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},

4448

{"table_open_cache", OPT_TABLE_OPEN_CACHE,

4449

"The number of cached open tables.",

4450

(uchar**) &table_cache_size, (uchar**) &table_cache_size, 0, GET_ULONG,

4451

REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},

4452

{"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,

4453

"Timeout in seconds to wait for a table level lock before returning an "

4454

"error. Used only if the connection has active cursors.",

4455

(uchar**) &table_lock_wait_timeout, (uchar**) &table_lock_wait_timeout,

4456

0, GET_ULONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},

4457

{"thread_cache_size", OPT_THREAD_CACHE_SIZE,

4458

"How many threads we should keep in a cache for reuse.",

4459

(uchar**) &thread_cache_size, (uchar**) &thread_cache_size, 0, GET_ULONG,

4460

REQUIRED_ARG, 0, 0, 16384, 0, 1, 0},

4461

{"thread_concurrency", OPT_THREAD_CONCURRENCY,

4462

"Permits the application to give the threads system a hint for the desired number of threads that should be run at the same time.",

4463

(uchar**) &concurrency, (uchar**) &concurrency, 0, GET_ULONG, REQUIRED_ARG,

4464

DEFAULT_CONCURRENCY, 1, 512, 0, 1, 0},

4465

{"thread_pool_size", OPT_THREAD_CACHE_SIZE,

4466

"How many threads we should create to handle query requests in case of 'thread_handling=pool-of-threads'",

4467

(uchar**) &thread_pool_size, (uchar**) &thread_pool_size, 0, GET_ULONG,

4468

REQUIRED_ARG, 20, 1, 16384, 0, 1, 0},

4469

{"thread_stack", OPT_THREAD_STACK,

4470

"The stack size for each thread.", (uchar**) &my_thread_stack_size,

4471

(uchar**) &my_thread_stack_size, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,

4472

1024L*128L, ULONG_MAX, 0, 1024, 0},

4473

{ "time_format", OPT_TIME_FORMAT,

4474

"The TIME format (for future).",

4475

(uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],

4476

(uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],

4477

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4478

{"tmp_table_size", OPT_TMP_TABLE_SIZE,

4479

"If an internal in-memory temporary table exceeds this size, MySQL will"

4480

" automatically convert it to an on-disk MyISAM table.",

4481

(uchar**) &global_system_variables.tmp_table_size,

4482

(uchar**) &max_system_variables.tmp_table_size, 0, GET_ULL,

4483

REQUIRED_ARG, 16*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},

4484

{"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,

4485

"Allocation block size for transactions to be stored in binary log",

4486

(uchar**) &global_system_variables.trans_alloc_block_size,

4487

(uchar**) &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,

4488

REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},

4489

{"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,

4490

"Persistent buffer for transactions to be stored in binary log",

4491

(uchar**) &global_system_variables.trans_prealloc_size,

4492

(uchar**) &max_system_variables.trans_prealloc_size, 0, GET_ULONG,

4493

REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, ULONG_MAX, 0, 1024, 0},

4494

{"thread_handling", OPT_THREAD_HANDLING,

4495

"Define threads usage for handling queries: "

4496

"one-thread-per-connection or no-threads", 0, 0,

4497

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

4498

{"wait_timeout", OPT_WAIT_TIMEOUT,

4499

"The number of seconds the server waits for activity on a connection before closing it.",

4500

(uchar**) &global_system_variables.net_wait_timeout,

4501

(uchar**) &max_system_variables.net_wait_timeout, 0, GET_ULONG,

4502

REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT),

4503

0, 1, 0},

4504

{0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}

4505

};

4506

4507

static int show_net_compression(THD *thd, SHOW_VAR *var, char *buff)

4508

{

4509

var->type= SHOW_MY_BOOL;

4510

var->value= (char *)&thd->net.compress;

4511

return 0;

4512

}

4513

4514

static int show_starttime(THD *thd, SHOW_VAR *var, char *buff)

4515

{

4516

var->type= SHOW_LONG;

4517

var->value= buff;

4518

*((long *)buff)= (long) (thd->query_start() - server_start_time);

4519

return 0;

4520

}

4521

4522

static int show_flushstatustime(THD *thd, SHOW_VAR *var, char *buff)

4523

{

4524

var->type= SHOW_LONG;

4525

var->value= buff;

4526

*((long *)buff)= (long) (thd->query_start() - flush_status_time);

4527

return 0;

4528

}

4529

4530

#ifdef HAVE_REPLICATION

4531

static int show_slave_running(THD *thd, SHOW_VAR *var, char *buff)

4532

{

4533

var->type= SHOW_MY_BOOL;

4534

pthread_mutex_lock(&LOCK_active_mi);

4535

var->value= buff;

4536

*((my_bool *)buff)= (my_bool) (active_mi && active_mi->slave_running &&

4537

active_mi->rli.slave_running);

4538

pthread_mutex_unlock(&LOCK_active_mi);

4539

return 0;

4540

}

4541

4542

static int show_slave_retried_trans(THD *thd, SHOW_VAR *var, char *buff)

4543

{

4544

4545

TODO: with multimaster, have one such counter per line in

4546

SHOW SLAVE STATUS, and have the sum over all lines here.

4547

4548

pthread_mutex_lock(&LOCK_active_mi);

4549

if (active_mi)

4550

{

4551

var->type= SHOW_LONG;

4552

var->value= buff;

4553

pthread_mutex_lock(&active_mi->rli.data_lock);

4554

*((long *)buff)= (long)active_mi->rli.retried_trans;

4555

pthread_mutex_unlock(&active_mi->rli.data_lock);

4556

}

4557

else

4558

var->type= SHOW_UNDEF;

4559

pthread_mutex_unlock(&LOCK_active_mi);

4560

return 0;

4561

}

4562

4563

static int show_slave_received_heartbeats(THD *thd, SHOW_VAR *var, char *buff)

4564

{

4565

pthread_mutex_lock(&LOCK_active_mi);

4566

if (active_mi)

4567

{

4568

var->type= SHOW_LONGLONG;

4569

var->value= buff;

4570

pthread_mutex_lock(&active_mi->rli.data_lock);

4571

*((longlong *)buff)= active_mi->received_heartbeats;

4572

pthread_mutex_unlock(&active_mi->rli.data_lock);

4573

}

4574

else

4575

var->type= SHOW_UNDEF;

4576

pthread_mutex_unlock(&LOCK_active_mi);

4577

return 0;

4578

}

4579

4580

static int show_heartbeat_period(THD *thd, SHOW_VAR *var, char *buff)

4581

{

4582

pthread_mutex_lock(&LOCK_active_mi);

4583

if (active_mi)

4584

{

4585

var->type= SHOW_CHAR;

4586

var->value= buff;

4587

my_sprintf(buff, (buff, "%.3f",active_mi->heartbeat_period));

4588

}

4589

else

4590

var->type= SHOW_UNDEF;

4591

pthread_mutex_unlock(&LOCK_active_mi);

4592

return 0;

4593

}

4594

4595

4596

#endif /* HAVE_REPLICATION */

4597

4598

static int show_open_tables(THD *thd, SHOW_VAR *var, char *buff)

4599

{

4600

var->type= SHOW_LONG;

4601

var->value= buff;

4602

*((long *)buff)= (long)cached_open_tables();

4603

return 0;

4604

}

4605

4606

static int show_table_definitions(THD *thd, SHOW_VAR *var, char *buff)

4607

{

4608

var->type= SHOW_LONG;

4609

var->value= buff;

4610

*((long *)buff)= (long)cached_table_definitions();

4611

return 0;

4612

}

4613

4614

4615

Variables shown by SHOW STATUS in alphabetical order

4616

4617

4618

SHOW_VAR status_vars[]= {

4619

{"Aborted_clients", (char*) &aborted_threads, SHOW_LONG},

4620

{"Aborted_connects", (char*) &aborted_connects, SHOW_LONG},

4621

{"Binlog_cache_disk_use", (char*) &binlog_cache_disk_use, SHOW_LONG},

4622

{"Binlog_cache_use", (char*) &binlog_cache_use, SHOW_LONG},

4623

{"Bytes_received", (char*) offsetof(STATUS_VAR, bytes_received), SHOW_LONGLONG_STATUS},

4624

{"Bytes_sent", (char*) offsetof(STATUS_VAR, bytes_sent), SHOW_LONGLONG_STATUS},

4625

{"Com", (char*) com_status_vars, SHOW_ARRAY},

4626

{"Compression", (char*) &show_net_compression, SHOW_FUNC},

4627

{"Connections", (char*) &thread_id, SHOW_LONG_NOFLUSH},

4628

{"Created_tmp_disk_tables", (char*) offsetof(STATUS_VAR, created_tmp_disk_tables), SHOW_LONG_STATUS},

4629

{"Created_tmp_files", (char*) &my_tmp_file_created, SHOW_LONG},

4630

{"Created_tmp_tables", (char*) offsetof(STATUS_VAR, created_tmp_tables), SHOW_LONG_STATUS},

4631

{"Flush_commands", (char*) &refresh_version, SHOW_LONG_NOFLUSH},

4632

{"Handler_commit", (char*) offsetof(STATUS_VAR, ha_commit_count), SHOW_LONG_STATUS},

4633

{"Handler_delete", (char*) offsetof(STATUS_VAR, ha_delete_count), SHOW_LONG_STATUS},

4634

{"Handler_discover", (char*) offsetof(STATUS_VAR, ha_discover_count), SHOW_LONG_STATUS},

4635

{"Handler_prepare", (char*) offsetof(STATUS_VAR, ha_prepare_count), SHOW_LONG_STATUS},

4636

{"Handler_read_first", (char*) offsetof(STATUS_VAR, ha_read_first_count), SHOW_LONG_STATUS},

4637

{"Handler_read_key", (char*) offsetof(STATUS_VAR, ha_read_key_count), SHOW_LONG_STATUS},

4638

{"Handler_read_next", (char*) offsetof(STATUS_VAR, ha_read_next_count), SHOW_LONG_STATUS},

4639

{"Handler_read_prev", (char*) offsetof(STATUS_VAR, ha_read_prev_count), SHOW_LONG_STATUS},

4640

{"Handler_read_rnd", (char*) offsetof(STATUS_VAR, ha_read_rnd_count), SHOW_LONG_STATUS},

4641

{"Handler_read_rnd_next", (char*) offsetof(STATUS_VAR, ha_read_rnd_next_count), SHOW_LONG_STATUS},

4642

{"Handler_rollback", (char*) offsetof(STATUS_VAR, ha_rollback_count), SHOW_LONG_STATUS},

4643

{"Handler_savepoint", (char*) offsetof(STATUS_VAR, ha_savepoint_count), SHOW_LONG_STATUS},

4644

{"Handler_savepoint_rollback",(char*) offsetof(STATUS_VAR, ha_savepoint_rollback_count), SHOW_LONG_STATUS},

4645

{"Handler_update", (char*) offsetof(STATUS_VAR, ha_update_count), SHOW_LONG_STATUS},

4646

{"Handler_write", (char*) offsetof(STATUS_VAR, ha_write_count), SHOW_LONG_STATUS},

4647

{"Key_blocks_not_flushed", (char*) offsetof(KEY_CACHE, global_blocks_changed), SHOW_KEY_CACHE_LONG},

4648

{"Key_blocks_unused", (char*) offsetof(KEY_CACHE, blocks_unused), SHOW_KEY_CACHE_LONG},

4649

{"Key_blocks_used", (char*) offsetof(KEY_CACHE, blocks_used), SHOW_KEY_CACHE_LONG},

4650

{"Key_read_requests", (char*) offsetof(KEY_CACHE, global_cache_r_requests), SHOW_KEY_CACHE_LONGLONG},

4651

{"Key_reads", (char*) offsetof(KEY_CACHE, global_cache_read), SHOW_KEY_CACHE_LONGLONG},

4652

{"Key_write_requests", (char*) offsetof(KEY_CACHE, global_cache_w_requests), SHOW_KEY_CACHE_LONGLONG},

4653

{"Key_writes", (char*) offsetof(KEY_CACHE, global_cache_write), SHOW_KEY_CACHE_LONGLONG},

4654

{"Last_query_cost", (char*) offsetof(STATUS_VAR, last_query_cost), SHOW_DOUBLE_STATUS},

4655

{"Max_used_connections", (char*) &max_used_connections, SHOW_LONG},

4656

{"Open_files", (char*) &my_file_opened, SHOW_LONG_NOFLUSH},

4657

{"Open_streams", (char*) &my_stream_opened, SHOW_LONG_NOFLUSH},

4658

{"Open_table_definitions", (char*) &show_table_definitions, SHOW_FUNC},

4659

{"Open_tables", (char*) &show_open_tables, SHOW_FUNC},

4660

{"Opened_files", (char*) &my_file_total_opened, SHOW_LONG_NOFLUSH},

4661

{"Opened_tables", (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},

4662

{"Opened_table_definitions", (char*) offsetof(STATUS_VAR, opened_shares), SHOW_LONG_STATUS},

4663

{"Questions", (char*) offsetof(STATUS_VAR, questions), SHOW_LONG_STATUS},

4664

{"Select_full_join", (char*) offsetof(STATUS_VAR, select_full_join_count), SHOW_LONG_STATUS},

4665

{"Select_full_range_join", (char*) offsetof(STATUS_VAR, select_full_range_join_count), SHOW_LONG_STATUS},

4666

{"Select_range", (char*) offsetof(STATUS_VAR, select_range_count), SHOW_LONG_STATUS},

4667

{"Select_range_check", (char*) offsetof(STATUS_VAR, select_range_check_count), SHOW_LONG_STATUS},

4668

{"Select_scan", (char*) offsetof(STATUS_VAR, select_scan_count), SHOW_LONG_STATUS},

4669

{"Slave_open_temp_tables", (char*) &slave_open_temp_tables, SHOW_LONG},

4670

#ifdef HAVE_REPLICATION

4671

{"Slave_retried_transactions",(char*) &show_slave_retried_trans, SHOW_FUNC},

4672

{"Slave_heartbeat_period", (char*) &show_heartbeat_period, SHOW_FUNC},

4673

{"Slave_received_heartbeats",(char*) &show_slave_received_heartbeats, SHOW_FUNC},

4674

{"Slave_running", (char*) &show_slave_running, SHOW_FUNC},

4675

#endif

4676

{"Slow_launch_threads", (char*) &slow_launch_threads, SHOW_LONG},

4677

{"Slow_queries", (char*) offsetof(STATUS_VAR, long_query_count), SHOW_LONG_STATUS},

4678

{"Sort_merge_passes", (char*) offsetof(STATUS_VAR, filesort_merge_passes), SHOW_LONG_STATUS},

4679

{"Sort_range", (char*) offsetof(STATUS_VAR, filesort_range_count), SHOW_LONG_STATUS},

4680

{"Sort_rows", (char*) offsetof(STATUS_VAR, filesort_rows), SHOW_LONG_STATUS},

4681

{"Sort_scan", (char*) offsetof(STATUS_VAR, filesort_scan_count), SHOW_LONG_STATUS},

4682

{"Table_locks_immediate", (char*) &locks_immediate, SHOW_LONG},

4683

{"Table_locks_waited", (char*) &locks_waited, SHOW_LONG},

4684

#ifdef HAVE_MMAP

4685

{"Tc_log_max_pages_used", (char*) &tc_log_max_pages_used, SHOW_LONG},

4686

{"Tc_log_page_size", (char*) &tc_log_page_size, SHOW_LONG},

4687

{"Tc_log_page_waits", (char*) &tc_log_page_waits, SHOW_LONG},

4688

#endif

4689

{"Threads_cached", (char*) &cached_thread_count, SHOW_LONG_NOFLUSH},

4690

{"Threads_connected", (char*) &connection_count, SHOW_INT},

4691

{"Threads_created", (char*) &thread_created, SHOW_LONG_NOFLUSH},

4692

{"Threads_running", (char*) &thread_running, SHOW_INT},

4693

{"Uptime", (char*) &show_starttime, SHOW_FUNC},

4694

{"Uptime_since_flush_status",(char*) &show_flushstatustime, SHOW_FUNC},

4695

{NullS, NullS, SHOW_LONG}

4696

};

4697

4698

static void print_version(void)

4699

{

4700

set_server_version();

4701

4702

Note: the instance manager keys off the string 'Ver' so it can find the

4703

version from the output of 'mysqld --version', so don't change it!

4704

4705

printf("%s Ver %s for %s on %s (%s)\n",my_progname,

4706

server_version,SYSTEM_TYPE,MACHINE_TYPE, MYSQL_COMPILATION_COMMENT);

4707

}

4708

4709

static void usage(void)

4710

{

4711

if (!(default_charset_info= get_charset_by_csname(default_character_set_name,

4712

MY_CS_PRIMARY,

4713

MYF(MY_WME))))

4714

exit(1);

4715

if (!default_collation_name)

4716

default_collation_name= (char*) default_charset_info->name;

4717

print_version();

4718

puts("\

4719

4720

This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\

4721

and you are welcome to modify and redistribute it under the GPL license\n\n\

4722

Starts the MySQL database server\n");

4723

4724

printf("Usage: %s [OPTIONS]\n", my_progname);

4725

if (!opt_verbose)

4726

puts("\nFor more help options (several pages), use mysqld --verbose --help");

4727

else

4728

{

4729

print_defaults(MYSQL_CONFIG_NAME,load_default_groups);

4730

puts("");

4731

set_ports();

4732

4733

/* Print out all the options including plugin supplied options */

4734

my_print_help_inc_plugins(my_long_options, sizeof(my_long_options)/sizeof(my_option));

4735

4736

puts("\n\

4737

To see what values a running MySQL server is using, type\n\

4738

'mysqladmin variables' instead of 'mysqld --verbose --help'.");

4739

}

4740

}

4741

4742

4743

/**

4744

Initialize all MySQL global variables to default values.

4745

4746

We don't need to set numeric variables refered to in my_long_options

4747

as these are initialized by my_getopt.

4748

4749

@note

4750

The reason to set a lot of global variables to zero is to allow one to

4751

restart the embedded server with a clean environment

4752

It's also needed on some exotic platforms where global variables are

4753

not set to 0 when a program starts.

4754

4755

We don't need to set numeric variables refered to in my_long_options

4756

as these are initialized by my_getopt.

4757

4758

4759

static void mysql_init_variables(void)

4760

{

4761

/* Things reset to zero */

4762

opt_skip_slave_start= opt_reckless_slave = 0;

4763

mysql_home[0]= pidfile_name[0]= log_error_file[0]= 0;

4764

opt_log= opt_slow_log= 0;

4765

opt_update_log= 0;

4766

log_output_options= find_bit_type(log_output_str, &log_output_typelib);

4767

opt_bin_log= 0;

4768

opt_disable_networking= opt_skip_show_db=0;

4769

opt_logname= opt_update_logname= opt_binlog_index_name= opt_slow_logname= 0;

4770

opt_tc_log_file= (char *)"tc.log"; // no hostname in tc_log file name !

4771

opt_secure_auth= 0;

4772

opt_secure_file_priv= 0;

4773

opt_bootstrap= opt_myisam_log= 0;

4774

mqh_used= 0;

4775

segfaulted= kill_in_progress= 0;

4776

cleanup_done= 0;

4777

defaults_argc= 0;

4778

defaults_argv= 0;

4779

server_id_supplied= 0;

4780

test_flags= select_errors= dropping_tables= ha_open_options=0;

4781

thread_count= thread_running= kill_cached_threads= wake_thread=0;

4782

slave_open_temp_tables= 0;

4783

cached_thread_count= 0;

4784

opt_endinfo= using_udf_functions= 0;

4785

opt_using_transactions= using_update_log= 0;

4786

abort_loop= select_thread_in_use= signal_thread_in_use= 0;

4787

ready_to_exit= shutdown_in_progress= 0;

4788

aborted_threads= aborted_connects= 0;

4789

specialflag= 0;

4790

binlog_cache_use= binlog_cache_disk_use= 0;

4791

max_used_connections= slow_launch_threads = 0;

4792

mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;

4793

prepared_stmt_count= 0;

4794

errmesg= 0;

4795

mysqld_unix_port= opt_mysql_tmpdir= my_bind_addr_str= NullS;

4796

bzero((uchar*) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));

4797

bzero((char *) &global_status_var, sizeof(global_status_var));

4798

opt_large_pages= 0;

4799

key_map_full.set_all();

4800

4801

/* Character sets */

4802

system_charset_info= &my_charset_utf8_general_ci;

4803

files_charset_info= &my_charset_utf8_general_ci;

4804

national_charset_info= &my_charset_utf8_general_ci;

4805

table_alias_charset= &my_charset_bin;

4806

character_set_filesystem= &my_charset_bin;

4807

4808

opt_date_time_formats[0]= opt_date_time_formats[1]= opt_date_time_formats[2]= 0;

4809

4810

/* Things with default values that are not zero */

4811

delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;

4812

slave_exec_mode_options= 0;

4813

slave_exec_mode_options= (uint)

4814

find_bit_type_or_exit(slave_exec_mode_str, &slave_exec_mode_typelib, NULL);

4815

opt_specialflag= SPECIAL_ENGLISH;

4816

unix_sock= ip_sock= INVALID_SOCKET;

4817

mysql_home_ptr= mysql_home;

4818

pidfile_name_ptr= pidfile_name;

4819

log_error_file_ptr= log_error_file;

4820

language_ptr= language;

4821

mysql_data_home= mysql_real_data_home;

4822

thd_startup_options= (OPTION_AUTO_IS_NULL | OPTION_BIN_LOG |

4823

OPTION_QUOTE_SHOW_CREATE | OPTION_SQL_NOTES);

4824

protocol_version= PROTOCOL_VERSION;

4825

what_to_log= ~ (1L << (uint) COM_TIME);

4826

refresh_version= 1L; /* Increments on each reload */

4827

global_query_id= thread_id= 1L;

4828

strmov(server_version, MYSQL_SERVER_VERSION);

4829

myisam_recover_options_str= "OFF";

4830

myisam_stats_method_str= "nulls_unequal";

4831

threads.empty();

4832

thread_cache.empty();

4833

key_caches.empty();

4834

if (!(dflt_key_cache= get_or_create_key_cache(default_key_cache_base.str,

4835

default_key_cache_base.length)))

4836

exit(1);

4837

/* set key_cache_hash.default_value = dflt_key_cache */

4838

multi_keycache_init();

4839

4840

/* Set directory paths */

4841

strmake(language, LANGUAGE, sizeof(language)-1);

4842

strmake(mysql_real_data_home, get_relative_path(DATADIR),

4843

sizeof(mysql_real_data_home)-1);

4844

mysql_data_home_buff[0]=FN_CURLIB; // all paths are relative from here

4845

mysql_data_home_buff[1]=0;

4846

mysql_data_home_len= 2;

4847

4848

/* Replication parameters */

4849

master_info_file= (char*) "master.info",

4850

relay_log_info_file= (char*) "relay-log.info";

4851

report_user= report_password = report_host= 0; /* TO BE DELETED */

4852

opt_relay_logname= opt_relaylog_index_name= 0;

4853

4854

/* Variables in libraries */

4855

charsets_dir= 0;

4856

default_character_set_name= (char*) MYSQL_DEFAULT_CHARSET_NAME;

4857

default_collation_name= compiled_default_collation_name;

4858

sys_charset_system.value= (char*) system_charset_info->csname;

4859

character_set_filesystem_name= (char*) "binary";

4860

lc_time_names_name= (char*) "en_US";

4861

/* Set default values for some option variables */

4862

default_storage_engine_str= (char*) "MyISAM";

4863

global_system_variables.table_plugin= NULL;

4864

global_system_variables.tx_isolation= ISO_REPEATABLE_READ;

4865

global_system_variables.select_limit= (ulonglong) HA_POS_ERROR;

4866

max_system_variables.select_limit= (ulonglong) HA_POS_ERROR;

4867

global_system_variables.max_join_size= (ulonglong) HA_POS_ERROR;

4868

max_system_variables.max_join_size= (ulonglong) HA_POS_ERROR;

4869

global_system_variables.old_passwords= 0;

4870

global_system_variables.old_alter_table= 0;

4871

global_system_variables.binlog_format= BINLOG_FORMAT_UNSPEC;

4872

4873

Default behavior for 4.1 and 5.0 is to treat NULL values as unequal

4874

when collecting index statistics for MyISAM tables.

4875

4876

global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;

4877

4878

/* Variables that depends on compile options */

4879

#ifndef DBUG_OFF

4880

default_dbug_option=IF_WIN("d:t:i:O,\\mysqld.trace",

4881

"d:t:i:o,/tmp/mysqld.trace");

4882

#endif

4883

opt_error_log= IF_WIN(1,0);

4884

#ifdef HAVE_BROKEN_REALPATH

4885

have_symlink=SHOW_OPTION_NO;

4886

#else

4887

have_symlink=SHOW_OPTION_YES;

4888

#endif

4889

#ifdef HAVE_DLOPEN

4890

have_dlopen=SHOW_OPTION_YES;

4891

#else

4892

have_dlopen=SHOW_OPTION_NO;

4893

#endif

4894

#ifdef HAVE_CRYPT

4895

have_crypt=SHOW_OPTION_YES;

4896

#else

4897

have_crypt=SHOW_OPTION_NO;

4898

#endif

4899

#ifdef HAVE_COMPRESS

4900

have_compress= SHOW_OPTION_YES;

4901

#else

4902

have_compress= SHOW_OPTION_NO;

4903

#endif

4904

#if !defined(my_pthread_setprio) && !defined(HAVE_PTHREAD_SETSCHEDPARAM)

4905

opt_specialflag |= SPECIAL_NO_PRIOR;

4906

#endif

4907

4908

const char *tmpenv;

4909

if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))

4910

tmpenv = DEFAULT_MYSQL_HOME;

4911

(void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);

4912

}

4913

4914

4915

my_bool

4916

mysqld_get_one_option(int optid,

4917

const struct my_option *opt __attribute__((unused)),

4918

char *argument)

4919

{

4920

switch(optid) {

4921

case '#':

4922

#ifndef DBUG_OFF

4923

DBUG_SET_INITIAL(argument ? argument : default_dbug_option);

4924

#endif

4925

opt_endinfo=1; /* unireg: memory allocation */

4926

break;

4927

case 'a':

4928

global_system_variables.tx_isolation= ISO_SERIALIZABLE;

4929

break;

4930

case 'b':

4931

strmake(mysql_home,argument,sizeof(mysql_home)-1);

4932

break;

4933

case 'C':

4934

if (default_collation_name == compiled_default_collation_name)

4935

default_collation_name= 0;

4936

break;

4937

case 'l':

4938

opt_log=1;

4939

break;

4940

case 'h':

4941

strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);

4942

/* Correct pointer set by my_getopt (for embedded library) */

4943

mysql_data_home= mysql_real_data_home;

4944

mysql_data_home_len= strlen(mysql_data_home);

4945

break;

4946

case 'u':

4947

if (!mysqld_user || !strcmp(mysqld_user, argument))

4948

mysqld_user= argument;

4949

else

4950

sql_print_warning("Ignoring user change to '%s' because the user was set to '%s' earlier on the command line\n", argument, mysqld_user);

4951

break;

4952

case 'L':

4953

strmake(language, argument, sizeof(language)-1);

4954

break;

4955

case OPT_SLAVE_SKIP_ERRORS:

4956

init_slave_skip_errors(argument);

4957

break;

4958

case OPT_SLAVE_EXEC_MODE:

4959

slave_exec_mode_options= (uint)

4960

find_bit_type_or_exit(argument, &slave_exec_mode_typelib, "");

4961

break;

4962

case 'V':

4963

print_version();

4964

exit(0);

4965

case 'W':

4966

if (!argument)

4967

global_system_variables.log_warnings++;

4968

else if (argument == disabled_my_option)

4969

global_system_variables.log_warnings= 0L;

4970

else

4971

global_system_variables.log_warnings= atoi(argument);

4972

break;

4973

case 'T':

4974

test_flags= argument ? (uint) atoi(argument) : 0;

4975

opt_endinfo=1;

4976

break;

4977

case (int) OPT_BIG_TABLES:

4978

thd_startup_options|=OPTION_BIG_TABLES;

4979

break;

4980

case (int) OPT_ISAM_LOG:

4981

opt_myisam_log=1;

4982

break;

4983

case (int) OPT_UPDATE_LOG:

4984

opt_update_log=1;

4985

break;

4986

case (int) OPT_BIN_LOG:

4987

opt_bin_log= test(argument != disabled_my_option);

4988

break;

4989

case (int) OPT_ERROR_LOG_FILE:

4990

opt_error_log= 1;

4991

break;

4992

#ifdef HAVE_REPLICATION

4993

case (int)OPT_REPLICATE_IGNORE_DB:

4994

{

4995

rpl_filter->add_ignore_db(argument);

4996

break;

4997

}

4998

case (int)OPT_REPLICATE_DO_DB:

4999

{

5000

rpl_filter->add_do_db(argument);

5001

break;

5002

}

5003

case (int)OPT_REPLICATE_REWRITE_DB:

5004

{

5005

char* key = argument,*p, *val;

5006

5007

if (!(p= strstr(argument, "->")))

5008

{

5009

fprintf(stderr,

5010

"Bad syntax in replicate-rewrite-db - missing '->'!\n");

5011

exit(1);

5012

}

5013

val= p--;

5014

while (my_isspace(mysqld_charset, *p) && p > argument)

5015

*p-- = 0;

5016

if (p == argument)

5017

{

5018

fprintf(stderr,

5019

"Bad syntax in replicate-rewrite-db - empty FROM db!\n");

5020

exit(1);

5021

}

5022

*val= 0;

5023

val+= 2;

5024

while (*val && my_isspace(mysqld_charset, *val))

5025

*val++;

5026

if (!*val)

5027

{

5028

fprintf(stderr,

5029

"Bad syntax in replicate-rewrite-db - empty TO db!\n");

5030

exit(1);

5031

}

5032

5033

rpl_filter->add_db_rewrite(key, val);

5034

break;

5035

}

5036

5037

case (int)OPT_BINLOG_IGNORE_DB:

5038

{

5039

binlog_filter->add_ignore_db(argument);

5040

break;

5041

}

5042

case OPT_BINLOG_FORMAT:

5043

{

5044

int id;

5045

id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);

5046

global_system_variables.binlog_format= opt_binlog_format_id= id - 1;

5047

break;

5048

}

5049

case (int)OPT_BINLOG_DO_DB:

5050

{

5051

binlog_filter->add_do_db(argument);

5052

break;

5053

}

5054

case (int)OPT_REPLICATE_DO_TABLE:

5055

{

5056

if (rpl_filter->add_do_table(argument))

5057

{

5058

fprintf(stderr, "Could not add do table rule '%s'!\n", argument);

5059

exit(1);

5060

}

5061

break;

5062

}

5063

case (int)OPT_REPLICATE_WILD_DO_TABLE:

5064

{

5065

if (rpl_filter->add_wild_do_table(argument))

5066

{

5067

fprintf(stderr, "Could not add do table rule '%s'!\n", argument);

5068

exit(1);

5069

}

5070

break;

5071

}

5072

case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:

5073

{

5074

if (rpl_filter->add_wild_ignore_table(argument))

5075

{

5076

fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);

5077

exit(1);

5078

}

5079

break;

5080

}

5081

case (int)OPT_REPLICATE_IGNORE_TABLE:

5082

{

5083

if (rpl_filter->add_ignore_table(argument))

5084

{

5085

fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);

5086

exit(1);

5087

}

5088

break;

5089

}

5090

#endif /* HAVE_REPLICATION */

5091

case (int) OPT_SLOW_QUERY_LOG:

5092

opt_slow_log= 1;

5093

break;

5094

#ifdef WITH_CSV_STORAGE_ENGINE

5095

case OPT_LOG_OUTPUT:

5096

{

5097

if (!argument || !argument[0])

5098

{

5099

log_output_options= LOG_FILE;

5100

log_output_str= log_output_typelib.type_names[1];

5101

}

5102

else

5103

{

5104

log_output_str= argument;

5105

log_output_options=

5106

find_bit_type_or_exit(argument, &log_output_typelib, opt->name);

5107

}

5108

break;

5109

}

5110

#endif

5111

case (int) OPT_SKIP_NEW:

5112

opt_specialflag|= SPECIAL_NO_NEW_FUNC;

5113

delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;

5114

myisam_concurrent_insert=0;

5115

myisam_recover_options= HA_RECOVER_NONE;

5116

my_use_symdir=0;

5117

ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);

5118

break;

5119

case (int) OPT_SAFE:

5120

opt_specialflag|= SPECIAL_SAFE_MODE;

5121

delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;

5122

myisam_recover_options= HA_RECOVER_DEFAULT;

5123

ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);

5124

break;

5125

case (int) OPT_SKIP_PRIOR:

5126

opt_specialflag|= SPECIAL_NO_PRIOR;

5127

break;

5128

case (int) OPT_SKIP_LOCK:

5129

opt_external_locking=0;

5130

break;

5131

case (int) OPT_SKIP_SHOW_DB:

5132

opt_skip_show_db=1;

5133

opt_specialflag|=SPECIAL_SKIP_SHOW_DB;

5134

break;

5135

case (int) OPT_WANT_CORE:

5136

test_flags |= TEST_CORE_ON_SIGNAL;

5137

break;

5138

case (int) OPT_SKIP_STACK_TRACE:

5139

test_flags|=TEST_NO_STACKTRACE;

5140

break;

5141

case (int) OPT_SKIP_SYMLINKS:

5142

my_use_symdir=0;

5143

break;

5144

case (int) OPT_BIND_ADDRESS:

5145

{

5146

struct addrinfo *res_lst, hints;

5147

5148

bzero(&hints, sizeof(struct addrinfo));

5149

hints.ai_socktype= SOCK_STREAM;

5150

hints.ai_protocol= IPPROTO_TCP;

5151

5152

if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0)

5153

{

5154

sql_print_error("Can't start server: cannot resolve hostname!");

5155

exit(1);

5156

}

5157

5158

if (res_lst->ai_next)

5159

{

5160

sql_print_error("Can't start server: bind-address refers to multiple interfaces!");

5161

exit(1);

5162

}

5163

freeaddrinfo(res_lst);

5164

}

5165

break;

5166

case (int) OPT_PID_FILE:

5167

strmake(pidfile_name, argument, sizeof(pidfile_name)-1);

5168

break;

5169

case OPT_CONSOLE:

5170

if (opt_console)

5171

opt_error_log= 0; // Force logs to stdout

5172

break;

5173

case (int) OPT_FLUSH:

5174

myisam_flush=1;

5175

flush_time=0; // No auto flush

5176

break;

5177

case OPT_LOW_PRIORITY_UPDATES:

5178

thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;

5179

global_system_variables.low_priority_updates=1;

5180

break;

5181

case OPT_BOOTSTRAP:

5182

opt_noacl=opt_bootstrap=1;

5183

break;

5184

case OPT_SERVER_ID:

5185

server_id_supplied = 1;

5186

break;

5187

case OPT_DELAY_KEY_WRITE_ALL:

5188

if (argument != disabled_my_option)

5189

argument= (char*) "ALL";

5190

/* Fall through */

5191

case OPT_DELAY_KEY_WRITE:

5192

if (argument == disabled_my_option)

5193

delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;

5194

else if (! argument)

5195

delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;

5196

else

5197

{

5198

int type;

5199

type= find_type_or_exit(argument, &delay_key_write_typelib, opt->name);

5200

delay_key_write_options= (uint) type-1;

5201

}

5202

break;

5203

case OPT_CHARSETS_DIR:

5204

strmake(mysql_charsets_dir, argument, sizeof(mysql_charsets_dir)-1);

5205

charsets_dir = mysql_charsets_dir;

5206

break;

5207

case OPT_TX_ISOLATION:

5208

{

5209

int type;

5210

type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);

5211

global_system_variables.tx_isolation= (type-1);

5212

break;

5213

}

5214

case OPT_MYISAM_RECOVER:

5215

{

5216

if (!argument)

5217

{

5218

myisam_recover_options= HA_RECOVER_DEFAULT;

5219

myisam_recover_options_str= myisam_recover_typelib.type_names[0];

5220

}

5221

else if (!argument[0])

5222

{

5223

myisam_recover_options= HA_RECOVER_NONE;

5224

myisam_recover_options_str= "OFF";

5225

}

5226

else

5227

{

5228

myisam_recover_options_str=argument;

5229

myisam_recover_options=

5230

find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);

5231

}

5232

ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;

5233

break;

5234

}

5235

case OPT_TC_HEURISTIC_RECOVER:

5236

tc_heuristic_recover= find_type_or_exit(argument,

5237

&tc_heuristic_recover_typelib,

5238

opt->name);

5239

break;

5240

case OPT_MYISAM_STATS_METHOD:

5241

{

5242

ulong method_conv;

5243

int method;

5244

5245

myisam_stats_method_str= argument;

5246

method= find_type_or_exit(argument, &myisam_stats_method_typelib,

5247

opt->name);

5248

switch (method-1) {

5249

case 2:

5250

method_conv= MI_STATS_METHOD_IGNORE_NULLS;

5251

break;

5252

case 1:

5253

method_conv= MI_STATS_METHOD_NULLS_EQUAL;

5254

break;

5255

case 0:

5256

default:

5257

method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;

5258

break;

5259

}

5260

global_system_variables.myisam_stats_method= method_conv;

5261

break;

5262

}

5263

case OPT_ONE_THREAD:

5264

global_system_variables.thread_handling=

5265

SCHEDULER_ONE_THREAD_PER_CONNECTION;

5266

break;

5267

case OPT_POOL_OF_THREADS:

5268

global_system_variables.thread_handling=

5269

SCHEDULER_POOL_OF_THREADS;

5270

break;

5271

case OPT_THREAD_HANDLING:

5272

{

5273

global_system_variables.thread_handling=

5274

find_type_or_exit(argument, &thread_handling_typelib, opt->name)-1;

5275

break;

5276

}

5277

case OPT_LOWER_CASE_TABLE_NAMES:

5278

lower_case_table_names= argument ? atoi(argument) : 1;

5279

lower_case_table_names_used= 1;

5280

break;

5281

}

5282

return 0;

5283

}

5284

5285

5286

/** Handle arguments for multiple key caches. */

5287

5288

extern "C" uchar **mysql_getopt_value(const char *keyname, uint key_length,

5289

const struct my_option *option);

5290

5291

uchar* *

5292

mysql_getopt_value(const char *keyname, uint key_length,

5293

const struct my_option *option)

5294

{

5295

switch (option->id) {

5296

case OPT_KEY_BUFFER_SIZE:

5297

case OPT_KEY_CACHE_BLOCK_SIZE:

5298

case OPT_KEY_CACHE_DIVISION_LIMIT:

5299

case OPT_KEY_CACHE_AGE_THRESHOLD:

5300

{

5301

KEY_CACHE *key_cache;

5302

if (!(key_cache= get_or_create_key_cache(keyname, key_length)))

5303

exit(1);

5304

switch (option->id) {

5305

case OPT_KEY_BUFFER_SIZE:

5306

return (uchar**) &key_cache->param_buff_size;

5307

case OPT_KEY_CACHE_BLOCK_SIZE:

5308

return (uchar**) &key_cache->param_block_size;

5309

case OPT_KEY_CACHE_DIVISION_LIMIT:

5310

return (uchar**) &key_cache->param_division_limit;

5311

case OPT_KEY_CACHE_AGE_THRESHOLD:

5312

return (uchar**) &key_cache->param_age_threshold;

5313

}

5314

}

5315

}

5316

return option->value;

5317

}

5318

5319

5320

extern "C" void option_error_reporter(enum loglevel level, const char *format, ...);

5321

5322

void option_error_reporter(enum loglevel level, const char *format, ...)

5323

{

5324

va_list args;

5325

va_start(args, format);

5326

5327

/* Don't print warnings for --loose options during bootstrap */

5328

if (level == ERROR_LEVEL || !opt_bootstrap ||

5329

global_system_variables.log_warnings)

5330

{

5331

vprint_msg_to_log(level, format, args);

5332

}

5333

va_end(args);

5334

}

5335

5336

5337

/**

5338

@todo

5339

- FIXME add EXIT_TOO_MANY_ARGUMENTS to "mysys_err.h" and return that code?

5340

5341

static void get_options(int *argc,char **argv)

5342

{

5343

int ho_error;

5344

5345

my_getopt_register_get_addr(mysql_getopt_value);

5346

my_getopt_error_reporter= option_error_reporter;

5347

5348

/* Skip unknown options so that they may be processed later by plugins */

5349

my_getopt_skip_unknown= TRUE;

5350

5351

if ((ho_error= handle_options(argc, &argv, my_long_options,

5352

mysqld_get_one_option)))

5353

exit(ho_error);

5354

(*argc)++; /* add back one for the progname handle_options removes */

5355

/* no need to do this for argv as we are discarding it. */

5356

5357

if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes ||

5358

opt_log_slow_slave_statements) &&

5359

!opt_slow_log)

5360

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");

5361

5362

#if defined(HAVE_BROKEN_REALPATH)

5363

my_use_symdir=0;

5364

my_disable_symlinks=1;

5365

have_symlink=SHOW_OPTION_NO;

5366

#else

5367

if (!my_use_symdir)

5368

{

5369

my_disable_symlinks=1;

5370

have_symlink=SHOW_OPTION_DISABLED;

5371

}

5372

#endif

5373

if (opt_debugging)

5374

{

5375

/* Allow break with SIGINT, no core or stack trace */

5376

test_flags|= TEST_SIGINT | TEST_NO_STACKTRACE;

5377

test_flags&= ~TEST_CORE_ON_SIGNAL;

5378

}

5379

/* Set global MyISAM variables from delay_key_write_options */

5380

fix_delay_key_write((THD*) 0, OPT_GLOBAL);

5381

/* Set global slave_exec_mode from its option */

5382

fix_slave_exec_mode(OPT_GLOBAL);

5383

5384

if (mysqld_chroot)

5385

set_root(mysqld_chroot);

5386

fix_paths();

5387

5388

5389

Set some global variables from the global_system_variables

5390

In most cases the global variables will not be used

5391

5392

my_disable_locking= myisam_single_user= test(opt_external_locking == 0);

5393

my_default_record_cache_size=global_system_variables.read_buff_size;

5394

myisam_max_temp_length=

5395

(my_off_t) global_system_variables.myisam_max_sort_file_size;

5396

5397

/* Set global variables based on startup options */

5398

myisam_block_size=(uint) 1 << my_bit_log2(opt_myisam_block_size);

5399

5400

/* long_query_time is in microseconds */

5401

global_system_variables.long_query_time= max_system_variables.long_query_time=

5402

(longlong) (long_query_time * 1000000.0);

5403

5404

if (opt_short_log_format)

5405

opt_specialflag|= SPECIAL_SHORT_LOG_FORMAT;

5406

5407

if (init_global_datetime_format(MYSQL_TIMESTAMP_DATE,

5408

&global_system_variables.date_format) ||

5409

init_global_datetime_format(MYSQL_TIMESTAMP_TIME,

5410

&global_system_variables.time_format) ||

5411

init_global_datetime_format(MYSQL_TIMESTAMP_DATETIME,

5412

&global_system_variables.datetime_format))

5413

exit(1);

5414

5415

if (global_system_variables.thread_handling <=

5416

SCHEDULER_ONE_THREAD_PER_CONNECTION)

5417

one_thread_per_connection_scheduler(&thread_scheduler);

5418

else if (global_system_variables.thread_handling == SCHEDULER_NO_THREADS)

5419

one_thread_scheduler(&thread_scheduler);

5420

else

5421

pool_of_threads_scheduler(&thread_scheduler); /* purecov: tested */

5422

}

5423

5424

5425

5426

Create version name for running mysqld version

5427

We automaticly add suffixes -debug, -embedded and -log to the version

5428

name to make the version more descriptive.

5429

(MYSQL_SERVER_SUFFIX is set by the compilation environment)

5430

5431

5432

static void set_server_version(void)

5433

{

5434

char *end= strxmov(server_version, MYSQL_SERVER_VERSION,

5435

MYSQL_SERVER_SUFFIX_STR, NullS);

5436

#ifndef DBUG_OFF

5437

if (!strstr(MYSQL_SERVER_SUFFIX_STR, "-debug"))

5438

end= strmov(end, "-debug");

5439

#endif

5440

if (opt_log || opt_update_log || opt_slow_log || opt_bin_log)

5441

strmov(end, "-log"); // This may slow down system

5442

}

5443

5444

5445

static char *get_relative_path(const char *path)

5446

{

5447

if (test_if_hard_path(path) &&

5448

is_prefix(path,DEFAULT_MYSQL_HOME) &&

5449

strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))

5450

{

5451

path+=(uint) strlen(DEFAULT_MYSQL_HOME);

5452

while (*path == FN_LIBCHAR)

5453

path++;

5454

}

5455

return (char*) path;

5456

}

5457

5458

5459

/**

5460

Fix filename and replace extension where 'dir' is relative to

5461

mysql_real_data_home.

5462

@return

5463

1 if len(path) > FN_REFLEN

5464

5465

5466

bool

5467

fn_format_relative_to_data_home(char * to, const char *name,

5468

const char *dir, const char *extension)

5469

{

5470

char tmp_path[FN_REFLEN];

5471

if (!test_if_hard_path(dir))

5472

{

5473

strxnmov(tmp_path,sizeof(tmp_path)-1, mysql_real_data_home,

5474

dir, NullS);

5475

dir=tmp_path;

5476

}

5477

return !fn_format(to, name, dir, extension,

5478

MY_APPEND_EXT | MY_UNPACK_FILENAME | MY_SAFE_PATH);

5479

}

5480

5481

5482

static void fix_paths(void)

5483

{

5484

char buff[FN_REFLEN],*pos;

5485

convert_dirname(mysql_home,mysql_home,NullS);

5486

/* Resolve symlinks to allow 'mysql_home' to be a relative symlink */

5487

my_realpath(mysql_home,mysql_home,MYF(0));

5488

/* Ensure that mysql_home ends in FN_LIBCHAR */

5489

pos=strend(mysql_home);

5490

if (pos[-1] != FN_LIBCHAR)

5491

{

5492

pos[0]= FN_LIBCHAR;

5493

pos[1]= 0;

5494

}

5495

convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);

5496

(void) fn_format(buff, mysql_real_data_home, "", "",

5497

(MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));

5498

(void) unpack_dirname(mysql_unpacked_real_data_home, buff);

5499

convert_dirname(language,language,NullS);

5500

(void) my_load_path(mysql_home,mysql_home,""); // Resolve current dir

5501

(void) my_load_path(mysql_real_data_home,mysql_real_data_home,mysql_home);

5502

(void) my_load_path(pidfile_name,pidfile_name,mysql_real_data_home);

5503

(void) my_load_path(opt_plugin_dir, opt_plugin_dir_ptr ? opt_plugin_dir_ptr :

5504

get_relative_path(PLUGINDIR), mysql_home);

5505

opt_plugin_dir_ptr= opt_plugin_dir;

5506

5507

char *sharedir=get_relative_path(SHAREDIR);

5508

if (test_if_hard_path(sharedir))

5509

strmake(buff,sharedir,sizeof(buff)-1); /* purecov: tested */

5510

else

5511

strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NullS);

5512

convert_dirname(buff,buff,NullS);

5513

(void) my_load_path(language,language,buff);

5514

5515

/* If --character-sets-dir isn't given, use shared library dir */

5516

if (charsets_dir != mysql_charsets_dir)

5517

{

5518

strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,

5519

CHARSET_DIR, NullS);

5520

}

5521

(void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);

5522

convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NullS);

5523

charsets_dir=mysql_charsets_dir;

5524

5525

if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))

5526

exit(1);

5527

#ifdef HAVE_REPLICATION

5528

if (!slave_load_tmpdir)

5529

{

5530

if (!(slave_load_tmpdir = (char*) my_strdup(mysql_tmpdir, MYF(MY_FAE))))

5531

exit(1);

5532

}

5533

#endif /* HAVE_REPLICATION */

5534

5535

Convert the secure-file-priv option to system format, allowing

5536

a quick strcmp to check if read or write is in an allowed dir

5537

5538

if (opt_secure_file_priv)

5539

{

5540

convert_dirname(buff, opt_secure_file_priv, NullS);

5541

my_free(opt_secure_file_priv, MYF(0));

5542

opt_secure_file_priv= my_strdup(buff, MYF(MY_FAE));

5543

}

5544

}

5545

5546

5547

static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,

5548

const char *option)

5549

{

5550

ulong res;

5551

5552

const char **ptr;

5553

5554

if ((res= find_bit_type(x, bit_lib)) == ~(ulong) 0)

5555

{

5556

ptr= bit_lib->type_names;

5557

if (!*x)

5558

fprintf(stderr, "No option given to %s\n", option);

5559

else

5560

fprintf(stderr, "Wrong option to %s. Option(s) given: %s\n", option, x);

5561

fprintf(stderr, "Alternatives are: '%s'", *ptr);

5562

while (*++ptr)

5563

fprintf(stderr, ",'%s'", *ptr);

5564

fprintf(stderr, "\n");

5565

exit(1);

5566

}

5567

return res;

5568

}

5569

5570

5571

/**

5572

@return

5573

a bitfield from a string of substrings separated by ','

5574

5575

~(ulong) 0 on error.

5576

5577

5578

static ulong find_bit_type(const char *x, TYPELIB *bit_lib)

5579

{

5580

bool found_end;

5581

int found_count;

5582

const char *end,*i,*j;

5583

const char **array, *pos;

5584

ulong found,found_int,bit;

5585

DBUG_ENTER("find_bit_type");

5586

DBUG_PRINT("enter",("x: '%s'",x));

5587

5588

found=0;

5589

found_end= 0;

5590

pos=(char *) x;

5591

while (*pos == ' ') pos++;

5592

found_end= *pos == 0;

5593

while (!found_end)

5594

{

5595

if (!*(end=strcend(pos,','))) /* Let end point at fieldend */

5596

{

5597

while (end > pos && end[-1] == ' ')

5598

end--; /* Skip end-space */

5599

found_end=1;

5600

}

5601

found_int=0; found_count=0;

5602

for (array=bit_lib->type_names, bit=1 ; (i= *array++) ; bit<<=1)

5603

{

5604

j=pos;

5605

while (j != end)

5606

{

5607

if (my_toupper(mysqld_charset,*i++) !=

5608

my_toupper(mysqld_charset,*j++))

5609

goto skip;

5610

}

5611

found_int=bit;

5612

if (! *i)

5613

{

5614

found_count=1;

5615

break;

5616

}

5617

else if (j != pos) // Half field found

5618

{

5619

found_count++; // Could be one of two values

5620

}

5621

skip: ;

5622

}

5623

if (found_count != 1)

5624

DBUG_RETURN(~(ulong) 0); // No unique value

5625

found|=found_int;

5626

pos=end+1;

5627

}

5628

5629

DBUG_PRINT("exit",("bit-field: %ld",(ulong) found));

5630

DBUG_RETURN(found);

5631

} /* find_bit_type */

5632

5633

5634

/**

5635

Check if file system used for databases is case insensitive.

5636

5637

@param dir_name Directory to test

5638

5639

@retval

5640

-1 Don't know (Test failed)

5641

@retval

5642

0 File system is case sensitive

5643

@retval

5644

1 File system is case insensitive

5645

5646

5647

static int test_if_case_insensitive(const char *dir_name)

5648

{

5649

int result= 0;

5650

File file;

5651

char buff[FN_REFLEN], buff2[FN_REFLEN];

5652

MY_STAT stat_info;

5653

DBUG_ENTER("test_if_case_insensitive");

5654

5655

fn_format(buff, glob_hostname, dir_name, ".lower-test",

5656

MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);

5657

fn_format(buff2, glob_hostname, dir_name, ".LOWER-TEST",

5658

MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);

5659

(void) my_delete(buff2, MYF(0));

5660

if ((file= my_create(buff, 0666, O_RDWR, MYF(0))) < 0)

5661

{

5662

sql_print_warning("Can't create test file %s", buff);

5663

DBUG_RETURN(-1);

5664

}

5665

my_close(file, MYF(0));

5666

if (my_stat(buff2, &stat_info, MYF(0)))

5667

result= 1; // Can access file

5668

(void) my_delete(buff, MYF(MY_WME));

5669

DBUG_PRINT("exit", ("result: %d", result));

5670

DBUG_RETURN(result);

5671

}

5672

5673

5674

/**

5675

Create file to store pid number.

5676

5677

static void create_pid_file()

5678

{

5679

File file;

5680

if ((file = my_create(pidfile_name,0664,

5681

O_WRONLY | O_TRUNC, MYF(MY_WME))) >= 0)

5682

{

5683

char buff[21], *end;

5684

end= int10_to_str((long) getpid(), buff, 10);

5685

*end++= '\n';

5686

if (!my_write(file, (uchar*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))

5687

{

5688

(void) my_close(file, MYF(0));

5689

return;

5690

}

5691

(void) my_close(file, MYF(0));

5692

}

5693

sql_perror("Can't start server: can't create PID file");

5694

exit(1);

5695

}

5696

5697

/** Clear most status variables. */

5698

void refresh_status(THD *thd)

5699

{

5700

pthread_mutex_lock(&LOCK_status);

5701

5702

/* Add thread's status variabes to global status */

5703

add_to_status(&global_status_var, &thd->status_var);

5704

5705

/* Reset thread's status variables */

5706

bzero((uchar*) &thd->status_var, sizeof(thd->status_var));

5707

5708

/* Reset some global variables */

5709

reset_status_vars();

5710

5711

/* Reset the counters of all key caches (default and named). */

5712

process_key_caches(reset_key_cache_counters);

5713

flush_status_time= time((time_t*) 0);

5714

pthread_mutex_unlock(&LOCK_status);

5715

5716

5717

Set max_used_connections to the number of currently open

5718

connections. Lock LOCK_thread_count out of LOCK_status to avoid

5719

deadlocks. Status reset becomes not atomic, but status data is

5720

not exact anyway.

5721

5722

pthread_mutex_lock(&LOCK_thread_count);

5723

max_used_connections= thread_count;

5724

pthread_mutex_unlock(&LOCK_thread_count);

5725

}

5726

5727

5728

/*****************************************************************************

5729

Instantiate templates

5730

*****************************************************************************/

5731

5732

#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

5733

/* Used templates */

5734

template class I_List<THD>;

5735

template class I_List_iterator<THD>;

5736

template class I_List<i_string>;

5737

template class I_List<i_string_pair>;

5738

template class I_List<NAMED_LIST>;

5739

template class I_List<Statement>;

5740

template class I_List_iterator<Statement>;

5741

#endif

Older »