~drizzle-trunk/drizzle/development

("transaction-message-threshold", po::value<size_t>(&transaction_message_threshold)->default_value(1024*1024)->notifier(&check_limits_transaction_message_threshold),

1203

_("Max message size written to transaction log, valid values 131072 - 1048576 bytes."))

1204

("user,u", po::value<string>(),

1205

_("Run drizzled daemon as user."))

1206

("version,V",

1207

_("Output version information and exit."))

1208

("back-log", po::value<back_log_constraints>(&back_log),

1209

_("The number of outstanding connection requests Drizzle can have. This "

1210

"comes into play when the main Drizzle thread gets very many connection "

1211

"requests in a very short time."))

1212

("bulk-insert-buffer-size",

1213

po::value<uint64_t>(&global_system_variables.bulk_insert_buff_size)->default_value(8192*1024),

1214

_("Size of tree cache used in bulk insert optimization. Note that this is "

1215

"a limit per thread!"))

1216

("div-precision-increment", po::value<uint32_t>(&global_system_variables.div_precincrement)->default_value(4)->notifier(&check_limits_dpi),

1217

_("Precision of the result of '/' operator will be increased on that "

1218

"value."))

1219

("group-concat-max-len", po::value<uint64_t>(&global_system_variables.group_concat_max_len)->default_value(1024)->notifier(&check_limits_gcml),

1220

_("The maximum length of the result of function group_concat."))

1221

("join-buffer-size", po::value<uint64_t>(&global_system_variables.join_buff_size)->default_value(128*1024L)->notifier(&check_limits_join_buffer_size),

1222

_("The size of the buffer that is used for full joins."))

1223

("join-heap-threshold",

1224

po::value<uint64_t>()->default_value(0),

1225

_("A global cap on the amount of memory that can be allocated by session join buffers (0 means unlimited)"))

1226

("max-allowed-packet", po::value<uint32_t>(&global_system_variables.max_allowed_packet)->default_value(64*1024*1024L)->notifier(&check_limits_map),

1227

_("Max packetlength to send/receive from to server."))

1228

("max-error-count", po::value<uint64_t>(&global_system_variables.max_error_count)->default_value(DEFAULT_ERROR_COUNT)->notifier(&check_limits_max_err_cnt),

1229

_("Max number of errors/warnings to store for a statement."))

1230

("max-heap-table-size", po::value<uint64_t>(&global_system_variables.max_heap_table_size)->default_value(16*1024*1024L)->notifier(&check_limits_mhts),

1231

_("Don't allow creation of heap tables bigger than this."))

1232

("max-join-size", po::value<drizzled::ha_rows>(&global_system_variables.max_join_size)->default_value(INT32_MAX)->notifier(&check_limits_max_join_size),

1233

_("Joins that are probably going to read more than max_join_size records "

1234

"return an error."))

1235

("max-length-for-sort-data", po::value<uint64_t>(&global_system_variables.max_length_for_sort_data)->default_value(1024)->notifier(&check_limits_mlfsd),

1236

_("Max number of bytes in sorted records."))

1237

("max-seeks-for-key", po::value<uint64_t>(&global_system_variables.max_seeks_for_key)->default_value(ULONG_MAX)->notifier(&check_limits_msfk),

1238

_("Limit assumed max number of seeks when looking up rows based on a key"))

1239

("max-sort-length", po::value<size_t>(&global_system_variables.max_sort_length)->default_value(1024)->notifier(&check_limits_max_sort_length),

1240

_("The number of bytes to use when sorting BLOB or TEXT values "

1241

"(only the first max_sort_length bytes of each value are used; the "

1242

"rest are ignored)."))

1243

("max-write-lock-count", po::value<uint64_t>(&max_write_lock_count)->default_value(UINT64_MAX),

1244

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

1245

("min-examined-row-limit", po::value<uint64_t>(&global_system_variables.min_examined_row_limit)->default_value(0)->notifier(&check_limits_merl),

1246

_("Don't log queries which examine less than min_examined_row_limit "

1247

"rows to file."))

1248

("disable-optimizer-prune",

1249

_("Do not apply any heuristic(s) during query optimization to prune, "

1250

"thus perform an exhaustive search from the optimizer search space."))

1251

("optimizer-search-depth", po::value<uint32_t>(&global_system_variables.optimizer_search_depth)->default_value(0)->notifier(&check_limits_osd),

1252

_("Maximum depth of search performed by the query optimizer. Values "

1253

"larger than the number of relations in a query result in better query "

1254

"plans, but take longer to compile a query. Smaller values than the "

1255

"number of tables in a relation result in faster optimization, but may "

1256

"produce very bad query plans. If set to 0, the system will "

1257

"automatically pick a reasonable value; if set to MAX_TABLES+2, the "

1258

"optimizer will switch to the original find_best (used for "

1259

"testing/comparison)."))

1260

("preload-buffer-size", po::value<uint64_t>(&global_system_variables.preload_buff_size)->default_value(32*1024L)->notifier(&check_limits_pbs),

1261

_("The size of the buffer that is allocated when preloading indexes"))

1262

("query-alloc-block-size",

1263

po::value<uint32_t>(&global_system_variables.query_alloc_block_size)->default_value(QUERY_ALLOC_BLOCK_SIZE)->notifier(&check_limits_qabs),

1264

_("Allocation block size for query parsing and execution"))

1265

("query-prealloc-size",

1266

po::value<uint32_t>(&global_system_variables.query_prealloc_size)->default_value(QUERY_ALLOC_PREALLOC_SIZE)->notifier(&check_limits_qps),

1267

_("Persistent buffer for query parsing and execution"))

1268

("range-alloc-block-size",

1269

po::value<size_t>(&global_system_variables.range_alloc_block_size)->default_value(RANGE_ALLOC_BLOCK_SIZE)->notifier(&check_limits_rabs),

1270

_("Allocation block size for storing ranges during optimization"))

1271

("read-buffer-size",

1272

po::value<uint32_t>(&global_system_variables.read_buff_size)->default_value(128*1024L)->notifier(&check_limits_read_buffer_size),

1273

_("Each thread that does a sequential scan allocates a buffer of this "

1274

"size for each table it scans. If you do many sequential scans, you may "

1275

"want to increase this value."))

1276

("read-buffer-threshold",

1277

po::value<uint64_t>()->default_value(0),

1278

_("A global cap on the size of read-buffer-size (0 means unlimited)"))

1279

("read-rnd-buffer-size",

1280

po::value<uint32_t>(&global_system_variables.read_rnd_buff_size)->default_value(256*1024L)->notifier(&check_limits_read_rnd_buffer_size),

1281

_("When reading rows in sorted order after a sort, the rows are read "

1282

"through this buffer to avoid a disk seeks. If not set, then it's set "

1283

"to the value of record_buffer."))

1284

("read-rnd-threshold",

1285

po::value<uint64_t>()->default_value(0),

1286

_("A global cap on the size of read-rnd-buffer-size (0 means unlimited)"))

1287

("scheduler", po::value<string>(),

1288

_("Select scheduler to be used (by default multi-thread)."))

1289

("sort-buffer-size",

1290

po::value<size_t>(&global_system_variables.sortbuff_size)->default_value(MAX_SORT_MEMORY)->notifier(&check_limits_sort_buffer_size),

1291

_("Each thread that needs to do a sort allocates a buffer of this size."))

1292

("sort-heap-threshold",

1293

po::value<uint64_t>()->default_value(0),

1294

_("A global cap on the amount of memory that can be allocated by session sort buffers (0 means unlimited)"))

1295

("table-definition-cache", po::value<size_t>(&table_def_size)->default_value(128)->notifier(&check_limits_tdc),

1296

_("The number of cached table definitions."))

1297

("table-open-cache", po::value<uint64_t>(&table_cache_size)->default_value(TABLE_OPEN_CACHE_DEFAULT)->notifier(&check_limits_toc),

1298

_("The number of cached open tables."))

1299

("table-lock-wait-timeout", po::value<uint64_t>(&table_lock_wait_timeout)->default_value(50)->notifier(&check_limits_tlwt),

1300

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

1301

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

1302

("thread-stack", po::value<size_t>(&my_thread_stack_size)->default_value(DEFAULT_THREAD_STACK)->notifier(&check_limits_thread_stack),

1303

_("The stack size for each thread."))

1304

("tmp-table-size",

1305

po::value<uint64_t>(&global_system_variables.tmp_table_size)->default_value(16*1024*1024L)->notifier(&check_limits_tmp_table_size),

1306

_("If an internal in-memory temporary table exceeds this size, Drizzle will"

1307

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

1308

("verbose", po::value<std::string>()->default_value(error::verbose_string())->notifier(&error::check_verbosity),

1309

_("The stack size for each thread."))

1310

;

1311

1312

full_options.add(long_options);

1313

full_options.add(plugin_load_options);

1314

1315

initial_options.add(config_options);

1316

initial_options.add(plugin_load_options);

1317

1318

int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;

1319

/* Get options about where config files and the like are */

1320

po::parsed_options parsed= po::command_line_parser(argc, argv).style(style).

1321

options(initial_options).allow_unregistered().run();

1322

unknown_options=

1323

po::collect_unrecognized(parsed.options, po::include_positional);

1324

1325

try

1326

{

1327

po::store(parsed, vm);

1328

}

1329

catch (std::exception&)

1330

{

1331

errmsg_printf(error::ERROR, _("Duplicate entry for command line option\n"));

1332

unireg_abort(1);

1333

}

1334

1335

if (not vm["no-defaults"].as<bool>())

1336

{

1337

fs::path system_config_file_drizzle(system_config_dir);

1338

system_config_file_drizzle /= "drizzled.cnf";

1339

defaults_file_list.insert(defaults_file_list.begin(),

1340

system_config_file_drizzle.file_string());

1341

1342

fs::path config_conf_d_location(system_config_dir);

1343

config_conf_d_location /= "conf.d";

1344

1345

1346

CachedDirectory config_conf_d(config_conf_d_location.file_string());

1347

if (not config_conf_d.fail())

2043

strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);

2044

strmov(fn_ext(pidfile_name),".pid"); // Add proper extension

2045

2046

2047

Add server status variables to the dynamic list of

2048

status variables that is shown by SHOW STATUS.

2049

Later, in plugin_init, and mysql_install_plugin

2050

new entries could be added to that list.

2051

2052

if (add_status_vars(status_vars))

2053

return 1; // an error was already reported

2054

2055

load_defaults(conf_file_name, groups, &argc, &argv);

2056

defaults_argv=argv;

2057

defaults_argc=argc;

2058

get_options(&defaults_argc, defaults_argv);

2059

set_server_version();

2060

2061

2062

/* connections and databases needs lots of files */

2063

{

2064

uint files, wanted_files, max_open_files;

2065

2066

/* MyISAM requires two file handles per table. */

2067

wanted_files= 10+max_connections+table_cache_size*2;

2068

2069

We are trying to allocate no less than max_connections*5 file

2070

handles (i.e. we are trying to set the limit so that they will

2071

be available). In addition, we allocate no less than how much

2072

was already allocated. However below we report a warning and

2073

recompute values only if we got less file handles than were

2074

explicitly requested. No warning and re-computation occur if we

2075

can't get max_connections*5 but still got no less than was

2076

requested (value of wanted_files).

2077

2078

max_open_files= max(max(wanted_files, max_connections*5),

2079

open_files_limit);

2080

files= my_set_max_open_files(max_open_files);

2081

2082

if (files < wanted_files)

1348

2083

{

1349

1350

for (CachedDirectory::Entries::const_iterator iter= config_conf_d.getEntries().begin();

1351

iter != config_conf_d.getEntries().end();

1352

++iter)

2084

if (!open_files_limit)

1353

2085

{

1354

string file_entry((*iter)->filename);

1355

1356

if (not file_entry.empty()

1357

&& file_entry != "."

1358

&& file_entry != "..")

1359

{

1360

fs::path the_entry(config_conf_d_location);

1361

the_entry /= file_entry;

1362

defaults_file_list.push_back(the_entry.file_string());

1363

}

2086

2087

If we have requested too much file handles than we bring

2088

max_connections in supported bounds.

2089

2090

max_connections= (ulong) min(files-10-TABLE_OPEN_CACHE_MIN*2,

2091

max_connections);

2092

2093

Decrease table_cache_size according to max_connections, but

2094

not below TABLE_OPEN_CACHE_MIN. Outer min() ensures that we

2095

never increase table_cache_size automatically (that could

2096

happen if max_connections is decreased above).

2097

2098

table_cache_size= (ulong) min(max((files-10-max_connections)/2,

2099

TABLE_OPEN_CACHE_MIN),

2100

table_cache_size);

2101

if (global_system_variables.log_warnings)

2102

sql_print_warning("Changed limits: max_open_files: %u max_connections: %ld table_cache: %ld",

2103

files, max_connections, table_cache_size);

1364

2104

}

1365

}

1366

}

1367

1368

/* TODO: here is where we should add a process_env_vars */

1369

1370

/* We need a notify here so that plugin_init will work properly */

1371

try

1372

{

1373

po::notify(vm);

1374

}

1375

catch (po::validation_error &err)

1376

{

1377

errmsg_printf(error::ERROR,

1378

_("%s: %s.\n"

1379

"Use --help to get a list of available options\n"),

1380

internal::my_progname, err.what());

1381

unireg_abort(1);

1382

}

1383

1384

process_defaults_files();

1385

1386

/* Process with notify a second time because a config file may contain

1387

plugin loader options */

1388

1389

try

1390

{

1391

po::notify(vm);

1392

}

1393

catch (po::validation_error &err)

1394

{

1395

errmsg_printf(error::ERROR,

1396

_("%s: %s.\n"

1397

"Use --help to get a list of available options\n"),

1398

internal::my_progname, err.what());

1399

unireg_abort(1);

1400

}

1401

1402

return 0;

1403

}

1404

1405

int init_remaining_variables(module::Registry &plugins)

1406

{

1407

int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;

1408

1409

current_pid= getpid(); /* Save for later ref */

1410

1411

/* At this point, we've read all the options we need to read from files and

1412

collected most of them into unknown options - now let's load everything

1413

1414

1415

if (plugin_init(plugins, plugin_options))

1416

{

1417

errmsg_printf(error::ERROR, _("Failed to initialize plugins\n"));

1418

unireg_abort(1);

1419

}

1420

1421

full_options.add(plugin_options);

1422

1423

vector<string> final_unknown_options;

1424

try

1425

{

1426

po::parsed_options final_parsed=

1427

po::command_line_parser(unknown_options).style(style).

1428

options(full_options).extra_parser(dpo::parse_size_arg).run();

1429

1430

final_unknown_options=

1431

po::collect_unrecognized(final_parsed.options, po::include_positional);

1432

1433

po::store(final_parsed, vm);

1434

1435

}

1436

catch (po::validation_error &err)

1437

{

1438

errmsg_printf(error::ERROR,

1439

_("%s: %s.\n"

1440

"Use --help to get a list of available options\n"),

1441

internal::my_progname, err.what());

1442

unireg_abort(1);

1443

}

1444

catch (po::invalid_command_line_syntax &err)

1445

{

1446

errmsg_printf(error::ERROR,

1447

_("%s: %s.\n"

1448

"Use --help to get a list of available options\n"),

1449

internal::my_progname, err.what());

1450

unireg_abort(1);

1451

}

1452

catch (po::unknown_option &err)

1453

{

1454

errmsg_printf(error::ERROR,

1455

_("%s\nUse --help to get a list of available options\n"),

1456

err.what());

1457

unireg_abort(1);

1458

}

1459

1460

try

1461

{

1462

po::notify(vm);

1463

}

1464

catch (po::validation_error &err)

1465

{

1466

errmsg_printf(error::ERROR,

1467

_("%s: %s.\n"

1468

"Use --help to get a list of available options\n"),

1469

internal::my_progname, err.what());

1470

unireg_abort(1);

1471

}

1472

1473

get_options();

1474

1475

/* Inverted Booleans */

1476

1477

global_system_variables.optimizer_prune_level=

1478

vm.count("disable-optimizer-prune") ? false : true;

1479

1480

if (vm.count("help") == 0 && vm.count("help-extended") == 0)

1481

{

1482

if ((user_info= check_user(drizzled_user)))

1483

{

1484

set_user(drizzled_user, user_info);

1485

}

1486

}

1487

1488

fix_paths();

1489

1490

init_time(); /* Init time-functions (read zone) */

1491

2105

else if (global_system_variables.log_warnings)

2106

sql_print_warning("Could not increase number of max_open_files to more than %u (request: %u)", files, wanted_files);

2107

}

2108

open_files_limit= files;

2109

}

2110

unireg_init(opt_specialflag); /* Set up extern variabels */

2111

if (init_errmessage()) /* Read error messages from file */

2112

return 1;

2113

init_client_errs();

2114

lex_init();

1492

2115

if (item_create_init())

1493

2116

return 1;

1494

if (sys_var_init())

1495

return 1;

1496

/* Creates static regex matching for temporal values */

1497

if (! init_temporal_formats())

1498

return 1;

1499

1500

if (!(default_charset_info=

1501

get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

2117

item_init();

2118

if (set_var_init())

2119

return 1;

2120

if (init_replication_sys_vars())

2121

return 1;

2122

2123

Process a comma-separated character set list and choose

2124

the first available character set. This is mostly for

2125

test purposes, to be able to start "mysqld" even if

2126

the requested character set is not available (see bug#18743).

2127

2128

for (;;)

1502

2129

{

1503

errmsg_printf(error::ERROR, _("Error getting default charset"));

1504

return 1; // Eof of the list

2130

char *next_character_set_name= strchr(default_character_set_name, ',');

2131

if (next_character_set_name)

2132

*next_character_set_name++= '\0';

2133

if (!(default_charset_info=

2134

get_charset_by_csname(default_character_set_name,

2135

MY_CS_PRIMARY, MYF(MY_WME))))

2136

{

2137

if (next_character_set_name)

2138

{

2139

default_character_set_name= next_character_set_name;

2140

default_collation_name= 0; // Ignore collation

2141

}

2142

else

2143

return 1; // Eof of the list

2144

}

2145

else

2146

break;

1505

2147

}

1506

2148

1507

if (vm.count("scheduler"))

1508

opt_scheduler= vm["scheduler"].as<string>().c_str();

1509

1510

2149

if (default_collation_name)

1511

2150

{

1512

const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);

1513

if (not default_collation)

2151

CHARSET_INFO *default_collation;

2152

default_collation= get_charset_by_name(default_collation_name, MYF(0));

2153

if (!default_collation)

1514

2154

{

1515

errmsg_printf(error::ERROR, _(ER(ER_UNKNOWN_COLLATION)), default_collation_name);

2155

sql_print_error(ER(ER_UNKNOWN_COLLATION), default_collation_name);

1516

2156

return 1;

1517

2157

}

1518

if (not my_charset_same(default_charset_info, default_collation))

2158

if (!my_charset_same(default_charset_info, default_collation))

1519

2159

{

1520

errmsg_printf(error::ERROR, _(ER(ER_COLLATION_CHARSET_MISMATCH)),

1521

default_collation_name,

1522

default_charset_info->csname);

2160

sql_print_error(ER(ER_COLLATION_CHARSET_MISMATCH),

2161

default_collation_name,

2162

default_charset_info->csname);

1523

2163

return 1;

1524

2164

}

1525

2165

default_charset_info= default_collation;

1526

2166

}

1527

2167

/* Set collactions that depends on the default collation */

1528

2168

global_system_variables.collation_server= default_charset_info;

1529

1530

if (not (character_set_filesystem=

1531

get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))

1532

{

1533

errmsg_printf(error::ERROR, _("Error setting collation"));

2169

global_system_variables.collation_database= default_charset_info;

2170

global_system_variables.collation_connection= default_charset_info;

2171

global_system_variables.character_set_results= default_charset_info;

2172

global_system_variables.character_set_client= default_charset_info;

2173

2174

global_system_variables.optimizer_use_mrr= 1;

2175

global_system_variables.optimizer_switch= 0;

2176

2177

if (!(character_set_filesystem=

2178

get_charset_by_csname(character_set_filesystem_name,

2179

MY_CS_PRIMARY, MYF(MY_WME))))

1534

2180

return 1;

1535

}

1536

2181

global_system_variables.character_set_filesystem= character_set_filesystem;

1537

2182

1538

2183

if (!(my_default_lc_time_names=

1539

2184

my_locale_by_name(lc_time_names_name)))

1540

2185

{

1541

errmsg_printf(error::ERROR, _("Unknown locale: '%s'"), lc_time_names_name);

2186

sql_print_error("Unknown locale: '%s'", lc_time_names_name);

1542

2187

return 1;

1543

2188

}

1544

2189

global_system_variables.lc_time_names= my_default_lc_time_names;

1545

1546

/* Reset table_alias_charset */

1547

table_alias_charset= files_charset_info;

1548

1549

return 0;

1550

}

1551

1552

1553

int init_server_components(module::Registry &plugins)

2190

2191

sys_init_connect.value_length= 0;

2192

if ((sys_init_connect.value= opt_init_connect))

2193

sys_init_connect.value_length= strlen(opt_init_connect);

2194

else

2195

sys_init_connect.value=my_strdup("",MYF(0));

2196

2197

sys_init_slave.value_length= 0;

2198

if ((sys_init_slave.value= opt_init_slave))

2199

sys_init_slave.value_length= strlen(opt_init_slave);

2200

else

2201

sys_init_slave.value=my_strdup("",MYF(0));

2202

2203

/* check log options and issue warnings if needed */

2204

if (opt_log && opt_logname && !(log_output_options & LOG_FILE) &&

2205

!(log_output_options & LOG_NONE))

2206

sql_print_warning("Although a path was specified for the "

2207

"--log option, log tables are used. "

2208

"To enable logging to files use the --log-output option.");

2209

2210

if (opt_slow_log && opt_slow_logname && !(log_output_options & LOG_FILE)

2211

&& !(log_output_options & LOG_NONE))

2212

sql_print_warning("Although a path was specified for the "

2213

"--log-slow-queries option, log tables are used. "

2214

"To enable logging to files use the --log-output=file option.");

2215

2216

s= opt_logname ? opt_logname : make_default_log_name(buff, ".log");

2217

sys_var_general_log_path.value= my_strdup(s, MYF(0));

2218

sys_var_general_log_path.value_length= strlen(s);

2219

2220

s= opt_slow_logname ? opt_slow_logname : make_default_log_name(buff, "-slow.log");

2221

sys_var_slow_log_path.value= my_strdup(s, MYF(0));

2222

sys_var_slow_log_path.value_length= strlen(s);

2223

2224

if (use_temp_pool && bitmap_init(&temp_pool,0,1024,1))

2225

return 1;

2226

if (my_database_names_init())

2227

return 1;

2228

2229

2230

Ensure that lower_case_table_names is set on system where we have case

2231

insensitive names. If this is not done the users MyISAM tables will

2232

get corrupted if accesses with names of different case.

2233

2234

lower_case_file_system= test_if_case_insensitive(mysql_real_data_home);

2235

if (!lower_case_table_names && lower_case_file_system == 1)

2236

{

2237

if (lower_case_table_names_used)

2238

{

2239

if (global_system_variables.log_warnings)

2240

sql_print_warning("\

2241

You have forced lower_case_table_names to 0 through a command-line \

2242

option, even though your file system '%s' is case insensitive. This means \

2243

that you can corrupt a MyISAM table by accessing it with different cases. \

2244

You should consider changing lower_case_table_names to 1 or 2",

2245

mysql_real_data_home);

2246

}

2247

else

2248

{

2249

if (global_system_variables.log_warnings)

2250

sql_print_warning("Setting lower_case_table_names=2 because file system for %s is case insensitive", mysql_real_data_home);

2251

lower_case_table_names= 2;

2252

}

2253

}

2254

else if (lower_case_table_names == 2 &&

2255

!(lower_case_file_system=

2256

(test_if_case_insensitive(mysql_real_data_home) == 1)))

2257

{

2258

if (global_system_variables.log_warnings)

2259

sql_print_warning("lower_case_table_names was set to 2, even though your "

2260

"the file system '%s' is case sensitive. Now setting "

2261

"lower_case_table_names to 0 to avoid future problems.",

2262

mysql_real_data_home);

2263

lower_case_table_names= 0;

2264

}

2265

else

2266

{

2267

lower_case_file_system=

2268

(test_if_case_insensitive(mysql_real_data_home) == 1);

2269

}

2270

2271

/* Reset table_alias_charset, now that lower_case_table_names is set. */

2272

table_alias_charset= (lower_case_table_names ?

2273

files_charset_info :

2274

&my_charset_bin);

2275

2276

return 0;

2277

}

2278

2279

2280

static int init_thread_environment()

2281

{

2282

(void) pthread_mutex_init(&LOCK_mysql_create_db,MY_MUTEX_INIT_SLOW);

2283

(void) pthread_mutex_init(&LOCK_lock_db,MY_MUTEX_INIT_SLOW);

2284

(void) pthread_mutex_init(&LOCK_open, NULL);

2285

(void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);

2286

(void) pthread_mutex_init(&LOCK_mapped_file,MY_MUTEX_INIT_SLOW);

2287

(void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);

2288

(void) pthread_mutex_init(&LOCK_error_log,MY_MUTEX_INIT_FAST);

2289

(void) pthread_mutex_init(&LOCK_crypt,MY_MUTEX_INIT_FAST);

2290

(void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);

2291

(void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);

2292

(void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);

2293

(void) my_rwlock_init(&LOCK_system_variables_hash, NULL);

2294

(void) pthread_mutex_init(&LOCK_global_read_lock, MY_MUTEX_INIT_FAST);

2295

(void) pthread_mutex_init(&LOCK_uuid_generator, MY_MUTEX_INIT_FAST);

2296

(void) pthread_mutex_init(&LOCK_connection_count, MY_MUTEX_INIT_FAST);

2297

(void) my_rwlock_init(&LOCK_sys_init_connect, NULL);

2298

(void) my_rwlock_init(&LOCK_sys_init_slave, NULL);

2299

(void) pthread_cond_init(&COND_thread_count,NULL);

2300

(void) pthread_cond_init(&COND_refresh,NULL);

2301

(void) pthread_cond_init(&COND_global_read_lock,NULL);

2302

(void) pthread_cond_init(&COND_thread_cache,NULL);

2303

(void) pthread_cond_init(&COND_flush_thread_cache,NULL);

2304

(void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);

2305

(void) pthread_cond_init(&COND_rpl_status, NULL);

2306

2307

/* Parameter for threads created for connections */

2308

(void) pthread_attr_init(&connection_attrib);

2309

(void) pthread_attr_setdetachstate(&connection_attrib,

2310

PTHREAD_CREATE_DETACHED);

2311

pthread_attr_setscope(&connection_attrib, PTHREAD_SCOPE_SYSTEM);

2312

if (!(opt_specialflag & SPECIAL_NO_PRIOR))

2313

{

2314

struct sched_param tmp_sched_param;

2315

2316

memset(&tmp_sched_param, 0, sizeof(tmp_sched_param));

2317

tmp_sched_param.sched_priority= WAIT_PRIOR;

2318

(void)pthread_attr_setschedparam(&connection_attrib, &tmp_sched_param);

2319

}

2320

2321

if (pthread_key_create(&THR_THD,NULL) ||

2322

pthread_key_create(&THR_MALLOC,NULL))

2323

{

2324

sql_print_error("Can't create thread-keys");

2325

return 1;

2326

}

2327

return 0;

2328

}

2329

2330

2331

static int init_server_components()

1554

2332

{

1555

2333

1556

2334

We need to call each of these following functions to ensure that

1557

2335

all things are initialized so that unireg_abort() doesn't fail

1558

2336

1559

if (table_cache_init())

1560

{

1561

errmsg_printf(error::ERROR, _("Could not initialize table cache\n"));

2337

if (table_cache_init() | table_def_init())

1562

2338

unireg_abort(1);

1563

}

1564

1565

// Resize the definition Cache at startup

1566

table::Cache::singleton().rehash(table_def_size);

1567

definition::Cache::singleton().rehash(table_def_size);

1568

message::Cache::singleton().rehash(table_def_size);

1569

2339

2340

randominit(&sql_rand,(ulong) server_start_time,(ulong) server_start_time/2);

1570

2341

setup_fpu();

2342

init_thr_lock();

2343

init_slave_list();

1571

2344

1572

2345

/* Setup logs */

1573

2346

2347

2348

Enable old-fashioned error log, except when the user has requested

2349

help information. Since the implementation of plugin server

2350

variables the help output is now written much later.

2351

2352

if (opt_error_log && !opt_help)

2353

{

2354

if (!log_error_file_ptr[0])

2355

fn_format(log_error_file, pidfile_name, mysql_data_home, ".err",

2356

MY_REPLACE_EXT); /* replace '.<domain>' by '.err', bug#4997 */

2357

else

2358

fn_format(log_error_file, log_error_file_ptr, mysql_data_home, ".err",

2359

MY_UNPACK_FILENAME | MY_SAFE_PATH);

2360

if (!log_error_file[0])

2361

opt_error_log= 1; // Too long file name

2362

else

2363

{

2364

if (freopen(log_error_file, "a+", stdout))

2365

freopen(log_error_file, "a+", stderr);

2366

}

2367

}

2368

1574

2369

if (xid_cache_init())

1575

2370

{

1576

errmsg_printf(error::ERROR, _("XA cache initialization failed: Out of memory\n"));

1577

unireg_abort(1);

1578

}

2371

sql_print_error("Out of memory");

2372

unireg_abort(1);

2373

}

2374

2375

if (!opt_bin_log)

2376

if (opt_binlog_format_id != BINLOG_FORMAT_UNSPEC)

2377

{

2378

sql_print_error("You need to use --log-bin to make "

2379

"--binlog-format work.");

2380

unireg_abort(1);

2381

}

2382

else

2383

{

2384

global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;

2385

}

2386

else

2387

if (opt_binlog_format_id == BINLOG_FORMAT_UNSPEC)

2388

global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;

2389

else

2390

{

2391

assert(global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC);

2392

}

2393

2394

/* Check that we have not let the format to unspecified at this point */

2395

assert((uint)global_system_variables.binlog_format <=

2396

array_elements(binlog_format_names)-1);

2397

2398

if (opt_log_slave_updates && replicate_same_server_id)

2399

{

2400

sql_print_error("\

2401

using --replicate-same-server-id in conjunction with \

2402

--log-slave-updates is impossible, it would lead to infinite loops in this \

2403

server.");

2404

unireg_abort(1);

2405

}

2406

2407

if (opt_bin_log)

2408

{

2409

char buf[FN_REFLEN];

2410

const char *ln;

2411

ln= mysql_bin_log.generate_name(opt_bin_logname, "-bin", 1, buf);

2412

if (!opt_bin_logname && !opt_binlog_index_name)

2413

{

2414

2415

User didn't give us info to name the binlog index file.

2416

Picking `hostname`-bin.index like did in 4.x, causes replication to

2417

fail if the hostname is changed later. So, we would like to instead

2418

require a name. But as we don't want to break many existing setups, we

2419

only give warning, not error.

2420

2421

sql_print_warning("No argument was provided to --log-bin, and "

2422

"--log-bin-index was not used; so replication "

2423

"may break when this MySQL server acts as a "

2424

"master and has his hostname changed!! Please "

2425

"use '--log-bin=%s' to avoid this problem.", ln);

2426

}

2427

if (ln == buf)

2428

{

2429

my_free(opt_bin_logname, MYF(MY_ALLOW_ZERO_PTR));

2430

opt_bin_logname=my_strdup(buf, MYF(0));

2431

}

2432

if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln))

2433

{

2434

unireg_abort(1);

2435

}

2436

2437

2438

Used to specify which type of lock we need to use for queries of type

2439

INSERT ... SELECT. This will change when we have row level logging.

2440

2441

using_update_log=1;

2442

}

2443

2444

/* call ha_init_key_cache() on all key caches to init them */

2445

process_key_caches(&ha_init_key_cache);

1579

2446

1580

2447

/* Allow storage engine to give real error messages */

1581

ha_init_errors();

2448

if (ha_init_errors())

2449

return(1);

1582

2450

2451

if (plugin_init(&defaults_argc, defaults_argv,

2452

(opt_noacl ? PLUGIN_INIT_SKIP_PLUGIN_TABLE : 0) |

2453

(opt_help ? PLUGIN_INIT_SKIP_INITIALIZATION : 0)))

2454

{

2455

sql_print_error("Failed to initialize plugins.");

2456

unireg_abort(1);

2457

}

1583

2458

1584

2459

if (opt_help)

1585

2460

unireg_abort(0);

1586

2461

1587

if (plugin_finalize(plugins))

1588

{

1589

unireg_abort(1);

1590

}

1591

1592

string scheduler_name;

1593

if (opt_scheduler)

1594

{

1595

scheduler_name= opt_scheduler;

1596

}

1597

else

1598

{

1599

scheduler_name= opt_scheduler_default;

1600

opt_scheduler= opt_scheduler_default;

1601

}

1602

1603

if (plugin::Scheduler::setPlugin(scheduler_name))

1604

{

1605

errmsg_printf(error::ERROR,

1606

_("No scheduler found, cannot continue!\n"));

2462

/* we do want to exit if there are any other unknown options */

2463

if (defaults_argc > 1)

2464

{

2465

int ho_error;

2466

char **tmp_argv= defaults_argv;

2467

struct my_option no_opts[]=

2468

{

2469

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

2470

};

2471

2472

We need to eat any 'loose' arguments first before we conclude

2473

that there are unprocessed options.

2474

But we need to preserve defaults_argv pointer intact for

2475

free_defaults() to work. Thus we use a copy here.

2476

2477

my_getopt_skip_unknown= 0;

2478

2479

if ((ho_error= handle_options(&defaults_argc, &tmp_argv, no_opts,

2480

mysqld_get_one_option)))

2481

unireg_abort(ho_error);

2482

2483

if (defaults_argc)

2484

{

2485

fprintf(stderr, "%s: Too many arguments (first extra is '%s').\n"

2486

"Use --verbose --help to get a list of available options\n",

2487

my_progname, *tmp_argv);

1607

2488

unireg_abort(1);

1608

}

1609

1610

1611

This is entirely for legacy. We will create a new "disk based" engine and a

1612

"memory" engine which will be configurable longterm.

1613

1614

const std::string myisam_engine_name("MyISAM");

1615

const std::string heap_engine_name("MEMORY");

1616

myisam_engine= plugin::StorageEngine::findByName(myisam_engine_name);

1617

heap_engine= plugin::StorageEngine::findByName(heap_engine_name);

2489

}

2490

}

2491

2492

/* if the errmsg.sys is not loaded, terminate to maintain behaviour */

2493

if (!errmesg[0][0])

2494

unireg_abort(1);

2495

2496

/* We have to initialize the storage engines before CSV logging */

2497

if (ha_init())

2498

{

2499

sql_print_error("Can't init databases");

2500

unireg_abort(1);

2501

}

2502

2503

logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,

2504

opt_log ? LOG_FILE:LOG_NONE);

1618

2505

1619

2506

1620

2507

Check that the default storage engine is actually available.

1621

2508

1622

2509

if (default_storage_engine_str)

1623

2510

{

1624

const std::string name(default_storage_engine_str);

1625

plugin::StorageEngine *engine;

1626

1627

engine= plugin::StorageEngine::findByName(name);

1628

if (engine == NULL)

1629

{

1630

errmsg_printf(error::ERROR, _("Unknown/unsupported storage engine: %s\n"),

1631

default_storage_engine_str);

1632

unireg_abort(1);

1633

}

1634

global_system_variables.storage_engine= engine;

1635

}

1636

1637

if (plugin::XaResourceManager::recoverAllXids())

1638

{

1639

/* This function alredy generates error messages */

1640

unireg_abort(1);

1641

}

2511

LEX_STRING name= { default_storage_engine_str,

2512

strlen(default_storage_engine_str) };

2513

plugin_ref plugin;

2514

handlerton *hton;

2515

2516

if ((plugin= ha_resolve_by_name(0, &name)))

2517

hton= plugin_data(plugin, handlerton*);

2518

else

2519

{

2520

sql_print_error("Unknown/unsupported table type: %s",

2521

default_storage_engine_str);

2522

unireg_abort(1);

2523

}

2524

if (!ha_storage_engine_is_enabled(hton))

2525

{

2526

if (!opt_bootstrap)

2527

{

2528

sql_print_error("Default storage engine (%s) is not available",

2529

default_storage_engine_str);

2530

unireg_abort(1);

2531

}

2532

assert(global_system_variables.table_plugin);

2533

}

2534

else

2535

{

2536

2537

Need to unlock as global_system_variables.table_plugin

2538

was acquired during plugin_init()

2539

2540

plugin_unlock(0, global_system_variables.table_plugin);

2541

global_system_variables.table_plugin= plugin;

2542

}

2543

}

2544

2545

tc_log= (total_ha_2pc > 1 ? (opt_bin_log ?

2546

(TC_LOG *) &mysql_bin_log :

2547

(TC_LOG *) &tc_log_mmap) :

2548

(TC_LOG *) &tc_log_dummy);

2549

2550

if (tc_log->open(opt_bin_log ? opt_bin_logname : opt_tc_log_file))

2551

{

2552

sql_print_error("Can't init tc log");

2553

unireg_abort(1);

2554

}

2555

2556

if (ha_recover(0))

2557

{

2558

unireg_abort(1);

2559

}

2560

2561

if (opt_bin_log && mysql_bin_log.open(opt_bin_logname, LOG_BIN, 0,

2562

WRITE_CACHE, 0, max_binlog_size, 0))

2563

unireg_abort(1);

2564

2565

if (opt_bin_log && expire_logs_days)

2566

{

2567

time_t purge_time= server_start_time - expire_logs_days*24*60*60;

2568

if (purge_time >= 0)

2569

mysql_bin_log.purge_logs_before_date(purge_time);

2570

}

2571

2572

if (opt_myisam_log)

2573

(void) mi_log(1);

2574

2575

#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)

2576

if (locked_in_memory && !getuid())

2577

{

2578

if (setreuid((uid_t)-1, 0) == -1)

2579

{ // this should never happen

2580

sql_perror("setreuid");

2581

unireg_abort(1);

2582

}

2583

if (mlockall(MCL_CURRENT))

2584

{

2585

if (global_system_variables.log_warnings)

2586

sql_print_warning("Failed to lock memory. Errno: %d\n",errno);

2587

locked_in_memory= 0;

2588

}

2589

if (user_info)

2590

set_user(mysqld_user, user_info);

2591

}

2592

else

2593

#endif

2594

locked_in_memory=0;

1642

2595

1643

2596

init_update_queries();

1644

1645

2597

return(0);

1646

2598

}

1647

2599

1648

2600

2601

int main(int argc, char **argv)

2602

{

2603

MY_INIT(argv[0]); // init my_sys library & pthreads

2604

/* nothing should come before this line ^^^ */

2605

2606

/* Set signal used to kill MySQL */

2607

#if defined(SIGUSR2)

2608

thr_kill_signal= thd_lib_detected == THD_LIB_LT ? SIGINT : SIGUSR2;

2609

#else

2610

thr_kill_signal= SIGINT;

2611

#endif

2612

2613

2614

Perform basic logger initialization logger. Should be called after

2615

MY_INIT, as it initializes mutexes. Log tables are inited later.

2616

2617

logger.init_base();

2618

2619

#ifdef _CUSTOMSTARTUPCONFIG_

2620

if (_cust_check_startup())

2621

{

2622

/ * _cust_check_startup will report startup failure error * /

2623

exit(1);

2624

}

2625

#endif

2626

2627

if (init_common_variables(MYSQL_CONFIG_NAME,

2628

argc, argv, load_default_groups))

2629

unireg_abort(1); // Will do exit

2630

2631

init_signals();

2632

2633

pthread_attr_setstacksize(&connection_attrib,my_thread_stack_size);

2634

2635

#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE

2636

{

2637

/* Retrieve used stack size; Needed for checking stack overflows */

2638

size_t stack_size= 0;

2639

pthread_attr_getstacksize(&connection_attrib, &stack_size);

2640

/* We must check if stack_size = 0 as Solaris 2.9 can return 0 here */

2641

if (stack_size && stack_size < my_thread_stack_size)

2642

{

2643

if (global_system_variables.log_warnings)

2644

sql_print_warning("Asked for %lu thread stack, but got %ld",

2645

my_thread_stack_size, (long) stack_size);

2646

my_thread_stack_size= stack_size;

2647

}

2648

}

2649

#endif

2650

2651

select_thread=pthread_self();

2652

select_thread_in_use=1;

2653

2654

2655

We have enough space for fiddling with the argv, continue

2656

2657

check_data_home(mysql_real_data_home);

2658

if (my_setwd(mysql_real_data_home,MYF(MY_WME)) && !opt_help)

2659

unireg_abort(1); /* purecov: inspected */

2660

mysql_data_home= mysql_data_home_buff;

2661

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

2662

mysql_data_home[1]=0;

2663

mysql_data_home_len= 2;

2664

2665

if ((user_info= check_user(mysqld_user)))

2666

{

2667

#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)

2668

if (locked_in_memory) // getuid() == 0 here

2669

set_effective_user(user_info);

2670

else

2671

#endif

2672

set_user(mysqld_user, user_info);

2673

}

2674

2675

if (opt_bin_log && !server_id)

2676

{

2677

server_id= 1;

2678

#ifdef EXTRA_DEBUG

2679

sql_print_warning("You have enabled the binary log, but you haven't set "

2680

"server-id to a non-zero value: we force server id to 1; "

2681

"updates will be logged to the binary log, but "

2682

"connections from slaves will not be accepted.");

2683

#endif

2684

}

2685

2686

if (init_server_components())

2687

unireg_abort(1);

2688

2689

network_init();

2690

2691

2692

Initialize my_str_malloc() and my_str_free()

2693

2694

my_str_malloc= &my_str_malloc_mysqld;

2695

my_str_free= &my_str_free_mysqld;

2696

2697

2698

init signals & alarm

2699

After this we can't quit by a simple unireg_abort

2700

2701

error_handler_hook= my_message_sql;

2702

start_signal_handler(); // Creates pidfile

2703

2704

if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name, opt_bootstrap))

2705

{

2706

abort_loop=1;

2707

select_thread_in_use=0;

2708

(void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);

2709

2710

if (!opt_bootstrap)

2711

(void) my_delete(pidfile_name,MYF(MY_WME)); // Not needed anymore

2712

2713

exit(1);

2714

}

2715

2716

init_status_vars();

2717

if (opt_bootstrap) /* If running with bootstrap, do not start replication. */

2718

opt_skip_slave_start= 1;

2719

2720

init_slave() must be called after the thread keys are created.

2721

Some parts of the code (e.g. SHOW STATUS LIKE 'slave_running' and other

2722

places) assume that active_mi != 0, so let's fail if it's 0 (out of

2723

memory); a message has already been printed.

2724

2725

if (init_slave() && !active_mi)

2726

{

2727

unireg_abort(1);

2728

}

2729

2730

sql_print_information(ER(ER_STARTUP),my_progname,server_version,

2731

"", mysqld_port, MYSQL_COMPILATION_COMMENT);

2732

2733

2734

handle_connections_sockets();

2735

2736

/* (void) pthread_attr_destroy(&connection_attrib); */

2737

2738

2739

#ifdef EXTRA_DEBUG2

2740

sql_print_error("Before Lock_thread_count");

2741

#endif

2742

(void) pthread_mutex_lock(&LOCK_thread_count);

2743

select_thread_in_use=0; // For close_connections

2744

(void) pthread_mutex_unlock(&LOCK_thread_count);

2745

(void) pthread_cond_broadcast(&COND_thread_count);

2746

#ifdef EXTRA_DEBUG2

2747

sql_print_error("After lock_thread_count");

2748

#endif

2749

2750

/* Wait until cleanup is done */

2751

(void) pthread_mutex_lock(&LOCK_thread_count);

2752

while (!ready_to_exit)

2753

pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);

2754

(void) pthread_mutex_unlock(&LOCK_thread_count);

2755

2756

clean_up(1);

2757

mysqld_exit(0);

2758

}

2759

2760

2761

/**

2762

Create new thread to handle incoming connection.

2763

2764

This function will create new thread to handle the incoming

2765

connection. If there are idle cached threads one will be used.

2766

'thd' will be pushed into 'threads'.

2767

2768

In single-threaded mode (\#define ONE_THREAD) connection will be

2769

handled inside this function.

2770

2771

@param[in,out] thd Thread handle of future thread.

2772

2773

2774

static void create_new_thread(THD *thd)

2775

{

2776

2777

2778

Don't allow too many connections. We roughly check here that we allow

2779

only (max_connections + 1) connections.

2780

2781

2782

pthread_mutex_lock(&LOCK_connection_count);

2783

2784

if (connection_count >= max_connections + 1 || abort_loop)

2785

{

2786

pthread_mutex_unlock(&LOCK_connection_count);

2787

2788

close_connection(thd, ER_CON_COUNT_ERROR, 1);

2789

delete thd;

2790

return;;

2791

}

2792

2793

++connection_count;

2794

2795

if (connection_count > max_used_connections)

2796

max_used_connections= connection_count;

2797

2798

pthread_mutex_unlock(&LOCK_connection_count);

2799

2800

/* Start a new thread to handle connection. */

2801

2802

pthread_mutex_lock(&LOCK_thread_count);

2803

2804

2805

The initialization of thread_id is done in create_embedded_thd() for

2806

the embedded library.

2807

TODO: refactor this to avoid code duplication there

2808

2809

thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;

2810

2811

thread_count++;

2812

2813

thread_scheduler.add_connection(thd);

2814

2815

return;;

2816

}

2817

2818

2819

#ifdef SIGNALS_DONT_BREAK_READ

2820

inline void kill_broken_server()

2821

{

2822

/* hack to get around signals ignored in syscalls for problem OS's */

2823

if ((!opt_disable_networking && ip_sock == INVALID_SOCKET))

2824

{

2825

select_thread_in_use = 0;

2826

/* The following call will never return */

2827

kill_server((void*) MYSQL_KILL_SIGNAL);

2828

}

2829

}

2830

#define MAYBE_BROKEN_SYSCALL kill_broken_server();

2831

#else

2832

#define MAYBE_BROKEN_SYSCALL

2833

#endif

2834

2835

/* Handle new connections and spawn new process to handle them */

2836

2837

void handle_connections_sockets()

2838

{

2839

my_socket sock,new_sock;

2840

uint error_count=0;

2841

uint max_used_connection= (uint)ip_sock+1;

2842

fd_set readFDs,clientFDs;

2843

THD *thd;

2844

struct sockaddr_storage cAddr;

2845

int ip_flags=0, flags;

2846

st_vio *vio_tmp;

2847

2848

FD_ZERO(&clientFDs);

2849

if (ip_sock != INVALID_SOCKET)

2850

{

2851

FD_SET(ip_sock,&clientFDs);

2852

ip_flags = fcntl(ip_sock, F_GETFL, 0);

2853

}

2854

MAYBE_BROKEN_SYSCALL;

2855

while (!abort_loop)

2856

{

2857

readFDs=clientFDs;

2858

if (select((int) max_used_connection,&readFDs,0,0,0) < 0)

2859

{

2860

if (socket_errno != SOCKET_EINTR)

2861

{

2862

if (!select_errors++ && !abort_loop) /* purecov: inspected */

2863

sql_print_error("mysqld: Got error %d from select",socket_errno); /* purecov: inspected */

2864

}

2865

MAYBE_BROKEN_SYSCALL

2866

continue;

2867

}

2868

if (abort_loop)

2869

{

2870

MAYBE_BROKEN_SYSCALL;

2871

break;

2872

}

2873

2874

/* Is this a new connection request ? */

2875

{

2876

sock = ip_sock;

2877

flags= ip_flags;

2878

}

2879

2880

#if !defined(NO_FCNTL_NONBLOCK)

2881

if (!(test_flags & TEST_BLOCKING))

2882

{

2883

#if defined(O_NONBLOCK)

2884

fcntl(sock, F_SETFL, flags | O_NONBLOCK);

2885

#elif defined(O_NDELAY)

2886

fcntl(sock, F_SETFL, flags | O_NDELAY);

2887

#endif

2888

}

2889

#endif /* NO_FCNTL_NONBLOCK */

2890

for (uint retry=0; retry < MAX_ACCEPT_RETRY; retry++)

2891

{

2892

size_socket length= sizeof(struct sockaddr_storage);

2893

new_sock= accept(sock, (struct sockaddr *)(&cAddr),

2894

&length);

2895

if (new_sock != INVALID_SOCKET ||

2896

(socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))

2897

break;

2898

MAYBE_BROKEN_SYSCALL;

2899

#if !defined(NO_FCNTL_NONBLOCK)

2900

if (!(test_flags & TEST_BLOCKING))

2901

{

2902

if (retry == MAX_ACCEPT_RETRY - 1)

2903

fcntl(sock, F_SETFL, flags); // Try without O_NONBLOCK

2904

}

2905

#endif

2906

}

2907

#if !defined(NO_FCNTL_NONBLOCK)

2908

if (!(test_flags & TEST_BLOCKING))

2909

fcntl(sock, F_SETFL, flags);

2910

#endif

2911

if (new_sock == INVALID_SOCKET)

2912

{

2913

if ((error_count++ & 255) == 0) // This can happen often

2914

sql_perror("Error in accept");

2915

MAYBE_BROKEN_SYSCALL;

2916

if (socket_errno == SOCKET_ENFILE || socket_errno == SOCKET_EMFILE)

2917

sleep(1); // Give other threads some time

2918

continue;

2919

}

2920

2921

{

2922

size_socket dummyLen;

2923

struct sockaddr_storage dummy;

2924

dummyLen = sizeof(dummy);

2925

if ( getsockname(new_sock,(struct sockaddr *)&dummy,

2926

(socklen_t *)&dummyLen) < 0 )

2927

{

2928

sql_perror("Error on new connection socket");

2929

(void) shutdown(new_sock, SHUT_RDWR);

2930

(void) closesocket(new_sock);

2931

continue;

2932

}

2933

}

2934

2935

2936

** Don't allow too many connections

2937

2938

2939

if (!(thd= new THD))

2940

{

2941

(void) shutdown(new_sock, SHUT_RDWR);

2942

VOID(closesocket(new_sock));

2943

continue;

2944

}

2945

if (!(vio_tmp=vio_new(new_sock, VIO_TYPE_TCPIP, sock == 0)) ||

2946

my_net_init(&thd->net,vio_tmp))

2947

{

2948

2949

Only delete the temporary vio if we didn't already attach it to the

2950

NET object. The destructor in THD will delete any initialized net

2951

structure.

2952

2953

if (vio_tmp && thd->net.vio != vio_tmp)

2954

vio_delete(vio_tmp);

2955

else

2956

{

2957

(void) shutdown(new_sock, SHUT_RDWR);

2958

(void) closesocket(new_sock);

2959

}

2960

delete thd;

2961

continue;

2962

}

2963

2964

create_new_thread(thd);

2965

}

2966

}

2967

2968

1649

2969

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

1650

2970

Handle start options

1651

2971

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

1652

2972

1653

enum options_drizzled

2973

enum options_mysqld

1654

2974

{

1655

OPT_SOCKET=256,

1656

OPT_BIND_ADDRESS,

1657

OPT_PID_FILE,

1658

OPT_STORAGE_ENGINE,

1659

OPT_INIT_FILE,

2975

OPT_ISAM_LOG=256, OPT_SKIP_NEW,

2976

OPT_SKIP_GRANT,

2977

OPT_ENABLE_LOCK, OPT_USE_LOCKING,

2978

OPT_SOCKET, OPT_UPDATE_LOG,

2979

OPT_BIN_LOG,

2980

OPT_BIN_LOG_INDEX,

2981

OPT_BIND_ADDRESS, OPT_PID_FILE,

2982

OPT_SKIP_PRIOR, OPT_BIG_TABLES,

2983

OPT_STANDALONE,

2984

OPT_CONSOLE, OPT_LOW_PRIORITY_UPDATES,

2985

OPT_SHORT_LOG_FORMAT,

2986

OPT_FLUSH, OPT_SAFE,

2987

OPT_BOOTSTRAP, OPT_SKIP_SHOW_DB,

2988

OPT_STORAGE_ENGINE, OPT_INIT_FILE,

2989

OPT_DELAY_KEY_WRITE_ALL, OPT_SLOW_QUERY_LOG,

2990

OPT_DELAY_KEY_WRITE, OPT_CHARSETS_DIR,

2991

OPT_MASTER_INFO_FILE,

2992

OPT_MASTER_RETRY_COUNT, OPT_LOG_TC, OPT_LOG_TC_SIZE,

2993

OPT_SQL_BIN_UPDATE_SAME, OPT_REPLICATE_DO_DB,

2994

OPT_REPLICATE_IGNORE_DB, OPT_LOG_SLAVE_UPDATES,

2995

OPT_BINLOG_DO_DB, OPT_BINLOG_IGNORE_DB,

2996

OPT_BINLOG_FORMAT,

2997

OPT_BINLOG_ROWS_EVENT_MAX_SIZE,

1660

2998

OPT_WANT_CORE,

1661

OPT_MEMLOCK,

1662

OPT_SERVER_ID,

1663

OPT_TC_HEURISTIC_RECOVER,

2999

OPT_MEMLOCK, OPT_MYISAM_RECOVER,

3000

OPT_REPLICATE_REWRITE_DB, OPT_SERVER_ID,

3001

OPT_SKIP_SLAVE_START,

3002

OPT_REPLICATE_DO_TABLE,

3003

OPT_REPLICATE_IGNORE_TABLE, OPT_REPLICATE_WILD_DO_TABLE,

3004

OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,

3005

OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,

3006

OPT_ABORT_SLAVE_EVENT_COUNT,

3007

OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,

3008

OPT_ENGINE_CONDITION_PUSHDOWN,

1664

3009

OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,

1665

3010

OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,

1666

OPT_DO_PSTACK,

1667

OPT_LOCAL_INFILE,

1668

OPT_BACK_LOG,

1669

OPT_JOIN_BUFF_SIZE,

1670

OPT_MAX_ALLOWED_PACKET,

3011

OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,

3012

OPT_SAFE_USER_CREATE,

3013

OPT_DO_PSTACK, OPT_REPORT_HOST,

3014

OPT_REPORT_USER, OPT_REPORT_PASSWORD, OPT_REPORT_PORT,

3015

OPT_SHOW_SLAVE_AUTH_INFO,

3016

OPT_SLAVE_LOAD_TMPDIR, OPT_NO_MIX_TYPE,

3017

OPT_RPL_RECOVERY_RANK,

3018

OPT_RELAY_LOG, OPT_RELAY_LOG_INDEX, OPT_RELAY_LOG_INFO_FILE,

3019

OPT_SLAVE_SKIP_ERRORS, OPT_SLAVE_ALLOW_BATCHING, OPT_DES_KEY_FILE, OPT_LOCAL_INFILE,

3020

OPT_SSL_SSL, OPT_SSL_KEY, OPT_SSL_CERT, OPT_SSL_CA,

3021

OPT_SSL_CAPATH, OPT_SSL_CIPHER,

3022

OPT_BACK_LOG, OPT_BINLOG_CACHE_SIZE,

3023

OPT_CONNECT_TIMEOUT,

3024

OPT_FLUSH_TIME,

3025

OPT_INTERACTIVE_TIMEOUT, OPT_JOIN_BUFF_SIZE,

3026

OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,

3027

OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,

3028

OPT_LONG_QUERY_TIME,

3029

OPT_LOWER_CASE_TABLE_NAMES, OPT_MAX_ALLOWED_PACKET,

3030

OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,

3031

OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,

1671

3032

OPT_MAX_HEP_TABLE_SIZE,

1672

OPT_MAX_JOIN_SIZE,

1673

OPT_MAX_SORT_LENGTH,

3033

OPT_MAX_JOIN_SIZE, OPT_MAX_PREPARED_STMT_COUNT,

3034

OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,

1674

3035

OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,

1675

3036

OPT_MAX_LENGTH_FOR_SORT_DATA,

1676

3037

OPT_MAX_WRITE_LOCK_COUNT, OPT_BULK_INSERT_BUFFER_SIZE,

1678

3039

OPT_MYISAM_BLOCK_SIZE, OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,

1679

3040

OPT_MYISAM_MAX_SORT_FILE_SIZE, OPT_MYISAM_SORT_BUFFER_SIZE,

1680

3041

OPT_MYISAM_USE_MMAP, OPT_MYISAM_REPAIR_THREADS,

1681

OPT_NET_BUFFER_LENGTH,

3042

OPT_MYISAM_STATS_METHOD,

3043

OPT_NET_BUFFER_LENGTH, OPT_NET_RETRY_COUNT,

3044

OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,

3045

OPT_OPEN_FILES_LIMIT,

1682

3046

OPT_PRELOAD_BUFFER_SIZE,

1683

OPT_RECORD_BUFFER,

1684

OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT,

1685

OPT_DEBUGGING,

3047

OPT_QUERY_CACHE_LIMIT, OPT_QUERY_CACHE_MIN_RES_UNIT, OPT_QUERY_CACHE_SIZE,

3048

OPT_QUERY_CACHE_TYPE, OPT_QUERY_CACHE_WLOCK_INVALIDATE, OPT_RECORD_BUFFER,

3049

OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT, OPT_RELAY_LOG_SPACE_LIMIT,

3050

OPT_RELAY_LOG_PURGE,

3051

OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,

3052

OPT_SLAVE_TRANS_RETRIES, OPT_READONLY, OPT_DEBUGGING,

1686

3053

OPT_SORT_BUFFER, OPT_TABLE_OPEN_CACHE, OPT_TABLE_DEF_CACHE,

3054

OPT_THREAD_CONCURRENCY, OPT_THREAD_CACHE_SIZE,

1687

3055

OPT_TMP_TABLE_SIZE, OPT_THREAD_STACK,

1688

3056

OPT_WAIT_TIMEOUT,

3057

OPT_ERROR_LOG_FILE,

3058

OPT_DEFAULT_WEEK_FORMAT,

1689

3059

OPT_RANGE_ALLOC_BLOCK_SIZE,

1690

3060

OPT_QUERY_ALLOC_BLOCK_SIZE, OPT_QUERY_PREALLOC_SIZE,

1691

3061

OPT_TRANS_ALLOC_BLOCK_SIZE, OPT_TRANS_PREALLOC_SIZE,

3062

OPT_SYNC_FRM, OPT_SYNC_BINLOG,

3063

OPT_SYNC_REPLICATION,

3064

OPT_SYNC_REPLICATION_SLAVE_ID,

3065

OPT_SYNC_REPLICATION_TIMEOUT,

3066

OPT_ENABLE_SHARED_MEMORY,

3067

OPT_SHARED_MEMORY_BASE_NAME,

1692

3068

OPT_OLD_ALTER_TABLE,

3069

OPT_EXPIRE_LOGS_DAYS,

1693

3070

OPT_GROUP_CONCAT_MAX_LEN,

1694

3071

OPT_DEFAULT_COLLATION,

3072

OPT_CHARACTER_SET_CLIENT_HANDSHAKE,

1695

3073

OPT_CHARACTER_SET_FILESYSTEM,

1696

3074

OPT_LC_TIME_NAMES,

1697

3075

OPT_INIT_CONNECT,

3076

OPT_INIT_SLAVE,

3077

OPT_SECURE_AUTH,

3078

OPT_DATE_FORMAT,

3079

OPT_TIME_FORMAT,

3080

OPT_DATETIME_FORMAT,

3081

OPT_LOG_QUERIES_NOT_USING_INDEXES,

1698

3082

OPT_DEFAULT_TIME_ZONE,

3083

OPT_SYSDATE_IS_NOW,

1699

3084

OPT_OPTIMIZER_SEARCH_DEPTH,

1700

OPT_SCHEDULER,

1701

OPT_PROTOCOL,

1702

3085

OPT_OPTIMIZER_PRUNE_LEVEL,

3086

OPT_UPDATABLE_VIEWS_WITH_LIMIT,

1703

3087

OPT_AUTO_INCREMENT, OPT_AUTO_INCREMENT_OFFSET,

1704

3088

OPT_ENABLE_LARGE_PAGES,

1705

3089

OPT_TIMED_MUTEXES,

3090

OPT_OLD_STYLE_USER_LIMITS,

3091

OPT_LOG_SLOW_ADMIN_STATEMENTS,

1706

3092

OPT_TABLE_LOCK_WAIT_TIMEOUT,

1707

OPT_PLUGIN_ADD,

1708

OPT_PLUGIN_REMOVE,

1709

3093

OPT_PLUGIN_LOAD,

1710

3094

OPT_PLUGIN_DIR,

3095

OPT_LOG_OUTPUT,

1711

3096

OPT_PORT_OPEN_TIMEOUT,

3097

OPT_PROFILING,

3098

OPT_KEEP_FILES_ON_CREATE,

3099

OPT_GENERAL_LOG,

3100

OPT_SLOW_LOG,

3101

OPT_THREAD_HANDLING,

3102

OPT_INNODB_ROLLBACK_ON_TIMEOUT,

1712

3103

OPT_SECURE_FILE_PRIV,

1713

3104

OPT_MIN_EXAMINED_ROW_LIMIT,

1714

OPT_PRINT_DEFAULTS

3105

OPT_LOG_SLOW_SLAVE_STATEMENTS,

3106

OPT_OLD_MODE,

3107

OPT_POOL_OF_THREADS,

3108

OPT_SLAVE_EXEC_MODE

1715

3109

};

1716

3110

1717

3111

1718

struct option my_long_options[] =

3112

#define LONG_TIMEOUT ((ulong) 3600L*24L*365L)

3113

3114

struct my_option my_long_options[] =

1719

3115

{

1720

1721

{"help", '?', N_("Display this help and exit."),

3116

{"help", '?', "Display this help and exit.",

1722

3117

(char**) &opt_help, (char**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

1723

3118

0, 0},

1724

{"daemon", 'd', N_("Run as daemon."),

1725

(char**) &opt_daemon, (char**) &opt_daemon, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

1726

0, 0},

3119

{"abort-slave-event-count", OPT_ABORT_SLAVE_EVENT_COUNT,

3120

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

3121

(char**) &abort_slave_event_count, (char**) &abort_slave_event_count,

3122

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

3123

{"ansi", 'a', "Use ANSI SQL syntax instead of MySQL syntax. This mode will also set transaction isolation level 'serializable'.", 0, 0, 0,

3124

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

1727

3125

{"auto-increment-increment", OPT_AUTO_INCREMENT,

1728

N_("Auto-increment columns are incremented by this"),

3126

"Auto-increment columns are incremented by this",

1729

3127

(char**) &global_system_variables.auto_increment_increment,

1730

(char**) &max_system_variables.auto_increment_increment, 0, GET_ULL,

1731

OPT_ARG, 1, 1, INT64_MAX, 0, 1, 0 },

3128

(char**) &max_system_variables.auto_increment_increment, 0, GET_ULONG,

3129

OPT_ARG, 1, 1, 65535, 0, 1, 0 },

1732

3130

{"auto-increment-offset", OPT_AUTO_INCREMENT_OFFSET,

1733

N_("Offset added to Auto-increment columns. Used when "

1734

"auto-increment-increment != 1"),

3131

"Offset added to Auto-increment columns. Used when auto-increment-increment != 1",

1735

3132

(char**) &global_system_variables.auto_increment_offset,

1736

(char**) &max_system_variables.auto_increment_offset, 0, GET_ULL, OPT_ARG,

1737

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

3133

(char**) &max_system_variables.auto_increment_offset, 0, GET_ULONG, OPT_ARG,

3134

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

1738

3135

{"basedir", 'b',

1739

N_("Path to installation directory. All paths are usually resolved "

1740

"relative to this."),

1741

NULL, NULL, 0, GET_STR, REQUIRED_ARG,

1742

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

1743

{"chroot", 'r',

1744

N_("Chroot drizzled daemon during startup."),

1745

(char**) &drizzled_chroot, (char**) &drizzled_chroot, 0, GET_STR, REQUIRED_ARG,

1746

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

1747

{"collation-server", OPT_DEFAULT_COLLATION,

1748

N_("Set the default collation."),

3136

"Path to installation directory. All paths are usually resolved relative to this.",

3137

(char**) &mysql_home_ptr, (char**) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,

3138

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

3139

{"big-tables", OPT_BIG_TABLES,

3140

"Allow big result sets by saving all temporary sets on file (Solves most 'table full' errors).",

3141

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

3142

{"bind-address", OPT_BIND_ADDRESS, "IP address to bind to.",

3143

(char**) &my_bind_addr_str, (char**) &my_bind_addr_str, 0, GET_STR,

3144

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

3145

{"binlog_format", OPT_BINLOG_FORMAT,

3146

"Does not have any effect without '--log-bin'. "

3147

"Tell the master the form of binary logging to use: either 'row' for "

3148

"row-based binary logging, or 'statement' for statement-based binary "

3149

"logging, or 'mixed'. 'mixed' is statement-based binary logging except "

3150

"for those statements where only row-based is correct: those which "

3151

"involve user-defined functions (i.e. UDFs) or the UUID() function; for "

3152

"those, row-based binary logging is automatically used. "

3153

,(char**) &opt_binlog_format, (char**) &opt_binlog_format,

3154

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

3155

{"binlog-do-db", OPT_BINLOG_DO_DB,

3156

"Tells the master it should log updates for the specified database, and exclude all others not explicitly mentioned.",

3157

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

3158

{"binlog-ignore-db", OPT_BINLOG_IGNORE_DB,

3159

"Tells the master that updates to the given database should not be logged tothe binary log.",

3160

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

3161

{"binlog-row-event-max-size", OPT_BINLOG_ROWS_EVENT_MAX_SIZE,

3162

"The maximum size of a row-based binary log event in bytes. Rows will be "

3163

"grouped into events smaller than this size if possible. "

3164

"The value has to be a multiple of 256.",

3165

(char**) &opt_binlog_rows_event_max_size,

3166

(char**) &opt_binlog_rows_event_max_size, 0,

3167

GET_ULONG, REQUIRED_ARG,

3168

/* def_value */ 1024, /* min_value */ 256, /* max_value */ ULONG_MAX,

3169

/* sub_size */ 0, /* block_size */ 256,

3170

/* app_type */ 0

3171

3172

#ifndef DISABLE_GRANT_OPTIONS

3173

{"bootstrap", OPT_BOOTSTRAP, "Used by mysql installation scripts.", 0, 0, 0,

3174

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

3175

#endif

3176

{"character-set-client-handshake", OPT_CHARACTER_SET_CLIENT_HANDSHAKE,

3177

"Don't ignore client side character set value sent during handshake.",

3178

(char**) &opt_character_set_client_handshake,

3179

(char**) &opt_character_set_client_handshake,

3180

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

3181

{"character-set-filesystem", OPT_CHARACTER_SET_FILESYSTEM,

3182

"Set the filesystem character set.",

3183

(char**) &character_set_filesystem_name,

3184

(char**) &character_set_filesystem_name,

3185

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

3186

{"character-set-server", 'C', "Set the default character set.",

3187

(char**) &default_character_set_name, (char**) &default_character_set_name,

3188

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

3189

{"character-sets-dir", OPT_CHARSETS_DIR,

3190

"Directory where character sets are.", (char**) &charsets_dir,

3191

(char**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3192

{"chroot", 'r', "Chroot mysqld daemon during startup.",

3193

(char**) &mysqld_chroot, (char**) &mysqld_chroot, 0, GET_STR, REQUIRED_ARG,

3194

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

3195

{"collation-server", OPT_DEFAULT_COLLATION, "Set the default collation.",

1749

3196

(char**) &default_collation_name, (char**) &default_collation_name,

1750

3197

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

1751

{"completion-type", OPT_COMPLETION_TYPE,

1752

N_("Default completion type."),

3198

{"completion-type", OPT_COMPLETION_TYPE, "Default completion type.",

1753

3199

(char**) &global_system_variables.completion_type,

1754

(char**) &max_system_variables.completion_type, 0, GET_UINT,

3200

(char**) &max_system_variables.completion_type, 0, GET_ULONG,

1755

3201

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

1756

{"core-file", OPT_WANT_CORE,

1757

N_("Write core on errors."),

1758

0, 0, 0, GET_NO_ARG,

3202

{"console", OPT_CONSOLE, "Write error output on screen; Don't remove the console window on windows.",

3203

(char**) &opt_console, (char**) &opt_console, 0, GET_BOOL, NO_ARG, 0, 0, 0,

3204

0, 0, 0},

3205

{"core-file", OPT_WANT_CORE, "Write core on errors.", 0, 0, 0, GET_NO_ARG,

1759

3206

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

1760

{"datadir", 'h',

1761

N_("Path to the database root."),

1762

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

3207

{"datadir", 'h', "Path to the database root.", (char**) &mysql_data_home,

3208

(char**) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3209

{"default-character-set", 'C', "Set the default character set (deprecated option, use --character-set-server instead).",

3210

(char**) &default_character_set_name, (char**) &default_character_set_name,

3211

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

3212

{"default-collation", OPT_DEFAULT_COLLATION, "Set the default collation (deprecated option, use --collation-server instead).",

3213

(char**) &default_collation_name, (char**) &default_collation_name,

3214

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

3215

{"default-storage-engine", OPT_STORAGE_ENGINE,

3216

"Set the default storage engine (table type) for tables.",

3217

(char**)&default_storage_engine_str, (char**)&default_storage_engine_str,

3218

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

3219

{"default-time-zone", OPT_DEFAULT_TIME_ZONE, "Set the default time zone.",

3220

(char**) &default_tz_name, (char**) &default_tz_name,

3221

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

3222

{"delay-key-write", OPT_DELAY_KEY_WRITE, "Type of DELAY_KEY_WRITE.",

3223

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

3224

{"delay-key-write-for-all-tables", OPT_DELAY_KEY_WRITE_ALL,

3225

"Don't flush key buffers between writes for any MyISAM table (Deprecated option, use --delay-key-write=all instead).",

3226

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

3227

{"disconnect-slave-event-count", OPT_DISCONNECT_SLAVE_EVENT_COUNT,

3228

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

3229

(char**) &disconnect_slave_event_count,

3230

(char**) &disconnect_slave_event_count, 0, GET_INT, REQUIRED_ARG, 0, 0, 0,

3231

0, 0, 0},

3232

#ifdef HAVE_STACK_TRACE_ON_SEGV

3233

{"enable-pstack", OPT_DO_PSTACK, "Print a symbolic stack trace on failure.",

3234

(char**) &opt_do_pstack, (char**) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,

3235

0, 0, 0, 0},

3236

#endif /* HAVE_STACK_TRACE_ON_SEGV */

3237

{"engine-condition-pushdown",

3238

OPT_ENGINE_CONDITION_PUSHDOWN,

3239

"Push supported query conditions to the storage engine.",

3240

(char**) &global_system_variables.engine_condition_pushdown,

3241

(char**) &global_system_variables.engine_condition_pushdown,

3242

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

1763

3243

/* See how it's handled in get_one_option() */

1764

{"exit-info", 'T',

1765

N_("Used for debugging; Use at your own risk!"),

1766

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

3244

{"exit-info", 'T', "Used for debugging; Use at your own risk!", 0, 0, 0,

3245

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

3246

{"flush", OPT_FLUSH, "Flush tables to disk between SQL commands.", 0, 0, 0,

3247

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

1767

3248

/* We must always support the next option to make scripts like mysqltest

1768

3249

easier to do */

1769

3250

{"gdb", OPT_DEBUGGING,

1770

N_("Set up signals usable for debugging"),

3251

"Set up signals usable for debugging",

1771

3252

(char**) &opt_debugging, (char**) &opt_debugging,

1772

3253

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

1773

{"log-warnings", 'W',

1774

N_("Log some not critical warnings to the log file."),

3254

{"general-log", OPT_GENERAL_LOG,

3255

"Enable|disable general log", (char**) &opt_log,

3256

(char**) &opt_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},

3257

{"init-connect", OPT_INIT_CONNECT, "Command(s) that are executed for each new connection",

3258

(char**) &opt_init_connect, (char**) &opt_init_connect, 0, GET_STR_ALLOC,

3259

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

3260

{"init-file", OPT_INIT_FILE, "Read SQL commands from this file at startup.",

3261

(char**) &opt_init_file, (char**) &opt_init_file, 0, GET_STR, REQUIRED_ARG,

3262

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

3263

{"init-slave", OPT_INIT_SLAVE, "Command(s) that are executed when a slave connects to this master",

3264

(char**) &opt_init_slave, (char**) &opt_init_slave, 0, GET_STR_ALLOC,

3265

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

3266

{"language", 'L',

3267

"Client error messages in given language. May be given as a full path.",

3268

(char**) &language_ptr, (char**) &language_ptr, 0, GET_STR, REQUIRED_ARG,

3269

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

3270

{"lc-time-names", OPT_LC_TIME_NAMES,

3271

"Set the language used for the month names and the days of the week.",

3272

(char**) &lc_time_names_name,

3273

(char**) &lc_time_names_name,

3274

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

3275

{"local-infile", OPT_LOCAL_INFILE,

3276

"Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0).",

3277

(char**) &opt_local_infile,

3278

(char**) &opt_local_infile, 0, GET_BOOL, OPT_ARG,

3279

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

3280

{"log", 'l', "Log connections and queries to file.", (char**) &opt_logname,

3281

(char**) &opt_logname, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

3282

{"log-bin", OPT_BIN_LOG,

3283

"Log update queries in binary format. Optional (but strongly recommended "

3284

"to avoid replication problems if server's hostname changes) argument "

3285

"should be the chosen location for the binary log files.",

3286

(char**) &opt_bin_logname, (char**) &opt_bin_logname, 0, GET_STR_ALLOC,

3287

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

3288

{"log-bin-index", OPT_BIN_LOG_INDEX,

3289

"File that holds the names for last binary log files.",

3290

(char**) &opt_binlog_index_name, (char**) &opt_binlog_index_name, 0, GET_STR,

3291

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

3292

3293

This option starts with "log-bin" to emphasize that it is specific of

3294

binary logging.

3295

3296

{"log-bin-trust-function-creators", OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,

3297

"If equal to 0 (the default), then when --log-bin is used, creation of "

3298

"a stored function (or trigger) is allowed only to users having the SUPER privilege "

3299

"and only if this stored function (trigger) may not break binary logging."

3300

"Note that if ALL connections to this server ALWAYS use row-based binary "

3301

"logging, the security issues do not exist and the binary logging cannot "

3302

"break, so you can safely set this to 1."

3303

,(char**) &trust_function_creators, (char**) &trust_function_creators, 0,

3304

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

3305

{"log-error", OPT_ERROR_LOG_FILE, "Error log file.",

3306

(char**) &log_error_file_ptr, (char**) &log_error_file_ptr, 0, GET_STR,

3307

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

3308

{"log-isam", OPT_ISAM_LOG, "Log all MyISAM changes to file.",

3309

(char**) &myisam_log_filename, (char**) &myisam_log_filename, 0, GET_STR,

3310

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

3311

{"log-long-format", '0',

3312

"Log some extra information to update log. Please note that this option is deprecated; see --log-short-format option.",

3313

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

3314

#ifdef WITH_CSV_STORAGE_ENGINE

3315

{"log-output", OPT_LOG_OUTPUT,

3316

"Syntax: log-output[=value[,value...]], where \"value\" could be TABLE, "

3317

"FILE or NONE.",

3318

(char**) &log_output_str, (char**) &log_output_str, 0,

3319

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

3320

#endif

3321

{"log-queries-not-using-indexes", OPT_LOG_QUERIES_NOT_USING_INDEXES,

3322

"Log queries that are executed without benefit of any index to the slow log if it is open.",

3323

(char**) &opt_log_queries_not_using_indexes, (char**) &opt_log_queries_not_using_indexes,

3324

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

3325

{"log-short-format", OPT_SHORT_LOG_FORMAT,

3326

"Don't log extra information to update and slow-query logs.",

3327

(char**) &opt_short_log_format, (char**) &opt_short_log_format,

3328

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

3329

{"log-slave-updates", OPT_LOG_SLAVE_UPDATES,

3330

"Tells the slave to log the updates from the slave thread to the binary log. You will need to turn it on if you plan to daisy-chain the slaves.",

3331

(char**) &opt_log_slave_updates, (char**) &opt_log_slave_updates, 0, GET_BOOL,

3332

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

3333

{"log-slow-admin-statements", OPT_LOG_SLOW_ADMIN_STATEMENTS,

3334

"Log slow OPTIMIZE, ANALYZE, ALTER and other administrative statements to the slow log if it is open.",

3335

(char**) &opt_log_slow_admin_statements,

3336

(char**) &opt_log_slow_admin_statements,

3337

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

3338

{"log-slow-slave-statements", OPT_LOG_SLOW_SLAVE_STATEMENTS,

3339

"Log slow statements executed by slave thread to the slow log if it is open.",

3340

(char**) &opt_log_slow_slave_statements,

3341

(char**) &opt_log_slow_slave_statements,

3342

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

3343

{"log-slow-queries", OPT_SLOW_QUERY_LOG,

3344

"Log slow queries to a table or log file. Defaults logging to table mysql.slow_log or hostname-slow.log if --log-output=file is used. Must be enabled to activate other slow log options.",

3345

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

3346

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

3347

{"log-tc", OPT_LOG_TC,

3348

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

3349

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

3350

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

3351

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

3352

#ifdef HAVE_MMAP

3353

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

3354

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

3355

REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, ULONG_MAX, 0,

3356

TC_LOG_PAGE_SIZE, 0},

3357

#endif

3358

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

1775

3359

(char**) &global_system_variables.log_warnings,

1776

(char**) &max_system_variables.log_warnings, 0, GET_BOOL, OPT_ARG, 1, 0, 0,

3360

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

1777

3361

0, 0, 0},

1778

{"pid-file", OPT_PID_FILE,

1779

N_("Pid file used by drizzled."),

1780

NULL, NULL, 0, GET_STR,

1781

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

3362

{"low-priority-updates", OPT_LOW_PRIORITY_UPDATES,

3363

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

3364

(char**) &global_system_variables.low_priority_updates,

3365

(char**) &max_system_variables.low_priority_updates,

3366

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

3367

{"master-info-file", OPT_MASTER_INFO_FILE,

3368

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

3369

thread is in the master's binlogs.",

3370

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

3371

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

3372

{"master-retry-count", OPT_MASTER_RETRY_COUNT,

3373

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

3374

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

3375

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

3376

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

3377

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

3378

(char**) &max_binlog_dump_events, (char**) &max_binlog_dump_events, 0,

3379

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

3380

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

3381

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

3382

{"myisam-recover", OPT_MYISAM_RECOVER,

3383

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

3384

(char**) &myisam_recover_options_str, (char**) &myisam_recover_options_str, 0,

3385

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

3386

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

3387

(char**) &global_system_variables.new_mode,

3388

(char**) &max_system_variables.new_mode,

3389

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

3390

{"old-alter-table", OPT_OLD_ALTER_TABLE,

3391

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

3392

(char**) &global_system_variables.old_alter_table,

3393

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

3394

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

3395

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

3396

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

3397

(char**) &opt_old_style_user_limits, (char**) &opt_old_style_user_limits,

3398

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

3399

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

3400

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

3401

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

3402

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

3403

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

3404

#if MYSQL_PORT_DEFAULT == 0

3405

"/etc/services, "

3406

#endif

3407

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

3408

(char**) &mysqld_port,

3409

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

1782

3410

{"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,

1783

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

1784

"(Default: no wait)"),

1785

(char**) &drizzled_bind_timeout,

1786

(char**) &drizzled_bind_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

3411

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

3412

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

3413

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

3414

{"relay-log", OPT_RELAY_LOG,

3415

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

3416

(char**) &opt_relay_logname, (char**) &opt_relay_logname, 0,

3417

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

3418

{"relay-log-index", OPT_RELAY_LOG_INDEX,

3419

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

3420

relay logs.",

3421

(char**) &opt_relaylog_index_name, (char**) &opt_relaylog_index_name, 0,

3422

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

3423

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

3424

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

3425

thread is in the relay logs.",

3426

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

3427

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

3428

{"replicate-do-db", OPT_REPLICATE_DO_DB,

3429

"Tells the slave thread to restrict replication to the specified database. To specify more than one database, use the directive multiple times, once for each database. Note that this will only work if you do not use cross-database queries such as UPDATE some_db.some_table SET foo='bar' while having selected a different or no database. If you need cross database updates to work, make sure you have 3.23.28 or later, and use replicate-wild-do-table=db_name.%.",

3430

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

3431

{"replicate-do-table", OPT_REPLICATE_DO_TABLE,

3432

"Tells the slave thread to restrict replication to the specified table. To specify more than one table, use the directive multiple times, once for each table. This will work for cross-database updates, in contrast to replicate-do-db.",

3433

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

3434

{"replicate-ignore-db", OPT_REPLICATE_IGNORE_DB,

3435

"Tells the slave thread to not replicate to the specified database. To specify more than one database to ignore, use the directive multiple times, once for each database. This option will not work if you use cross database updates. If you need cross database updates to work, make sure you have 3.23.28 or later, and use replicate-wild-ignore-table=db_name.%. ",

3436

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

3437

{"replicate-ignore-table", OPT_REPLICATE_IGNORE_TABLE,

3438

"Tells the slave thread to not replicate to the specified table. To specify more than one table to ignore, use the directive multiple times, once for each table. This will work for cross-datbase updates, in contrast to replicate-ignore-db.",

3439

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

3440

{"replicate-rewrite-db", OPT_REPLICATE_REWRITE_DB,

3441

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

3442

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

3443

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

3444

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

3445

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

3446

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

3447

(char**) &replicate_same_server_id,

3448

(char**) &replicate_same_server_id,

3449

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

3450

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

3451

"Tells the slave thread to restrict replication to the tables that match the specified wildcard pattern. To specify more than one table, use the directive multiple times, once for each table. This will work for cross-database updates. Example: replicate-wild-do-table=foo%.bar% will replicate only updates to tables in all databases that start with foo and whose table names start with bar.",

3452

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

3453

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

3454

"Tells the slave thread to not replicate to the tables that match the given wildcard pattern. To specify more than one table to ignore, use the directive multiple times, once for each table. This will work for cross-database updates. Example: replicate-wild-ignore-table=foo%.bar% will not do updates to tables in databases that start with foo and whose table names start with bar.",

3455

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

3456

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

3457

{"report-host", OPT_REPORT_HOST,

3458

"Hostname or IP of the slave to be reported to to the master during slave registration. Will appear in the output of SHOW SLAVE HOSTS. Leave unset if you do not want the slave to register itself with the master. Note that it is not sufficient for the master to simply read the IP of the slave off the socket once the slave connects. Due to NAT and other routing issues, that IP may not be valid for connecting to the slave from the master or other hosts.",

3459

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

3460

0, 0, 0, 0},

3461

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

3462

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

3463

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

3464

{"report-port", OPT_REPORT_PORT,

3465

"Port for connecting to slave reported to the master during slave registration. Set it only if the slave is listening on a non-default port or if you have a special tunnel from the master or other clients to the slave. If not sure, leave this option unset.",

3466

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

3467

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

3468

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

3469

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

1787

3470

{"secure-file-priv", OPT_SECURE_FILE_PRIV,

1788

N_("Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files "

1789

"within specified directory"),

1790

NULL, NULL, 0,

3471

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

3472

(char**) &opt_secure_file_priv, (char**) &opt_secure_file_priv, 0,

1791

3473

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

1792

3474

{"server-id", OPT_SERVER_ID,

1793

N_("Uniquely identifies the server instance in the community of "

1794

"replication partners."),

1795

(char**) &server_id, (char**) &server_id, 0, GET_UINT32, REQUIRED_ARG, 0, 0, 0,

3475

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

3476

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

1796

3477

0, 0, 0},

3478

{"set-variable", 'O',

3479

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

3480

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

3481

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

3482

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

3483

{"skip-slave-start", OPT_SKIP_SLAVE_START,

3484

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

3485

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

1797

3486

{"skip-stack-trace", OPT_SKIP_STACK_TRACE,

1798

N_("Don't print a stack trace on failure."),

1799

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

3487

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

1800

3488

0, 0, 0, 0},

1801

{"symbolic-links", 's',

1802

N_("Enable symbolic link support."),

1803

(char**) &internal::my_use_symdir, (char**) &internal::my_use_symdir, 0, GET_BOOL, NO_ARG,

3489

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

3490

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

3491

{"skip-thread-priority", OPT_SKIP_PRIOR,

3492

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

3493

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

3494

{"slave-load-tmpdir", OPT_SLAVE_LOAD_TMPDIR,

3495

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

3496

replicating a LOAD DATA INFILE command.",

3497

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

3498

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

3499

{"slave-skip-errors", OPT_SLAVE_SKIP_ERRORS,

3500

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

3501

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

3502

{"slave-exec-mode", OPT_SLAVE_EXEC_MODE,

3503

"Modes for how replication events should be executed. Legal values are STRICT (default) and IDEMPOTENT. In IDEMPOTENT mode, replication will not stop for operations that are idempotent. In STRICT mode, replication will stop on any unexpected difference between the master and the slave.",

3504

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

3505

{"slow-query-log", OPT_SLOW_LOG,

3506

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

3507

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

3508

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

3509

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

3510

log and this option does nothing anymore.",

3511

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

3512

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

3513

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

1804

3514

1805

3515

The system call realpath() produces warnings under valgrind and

1806

3516

purify. These are not suppressed: instead we disable symlinks

1807

3517

option if compiled with valgrind support.

1808

3518

1809

3519

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

3520

{"sysdate-is-now", OPT_SYSDATE_IS_NOW,

3521

"Non-default option to alias SYSDATE() to NOW() to make it safe-replicable. Since 5.0, SYSDATE() returns a `dynamic' value different for different invocations, even within the same statement.",

3522

(char**) &global_system_variables.sysdate_is_now,

3523

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

3524

{"tc-heuristic-recover", OPT_TC_HEURISTIC_RECOVER,

3525

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

3526

(char**) &opt_tc_heuristic_recover, (char**) &opt_tc_heuristic_recover,

3527

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

3528

{"temp-pool", OPT_TEMP_POOL,

3529

"Using this option will cause most temporary files created to use a small set of names, rather than a unique name for each new file.",

3530

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

3531

0, 0, 0, 0, 0},

1810

3532

{"timed_mutexes", OPT_TIMED_MUTEXES,

1811

N_("Specify whether to time mutexes (only InnoDB mutexes are currently "

1812

"supported)"),

1813

(char**) &internal::timed_mutexes, (char**) &internal::timed_mutexes, 0, GET_BOOL, NO_ARG, 0,

3533

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

3534

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

1814

3535

0, 0, 0, 0, 0},

3536

{"tmpdir", 't',

3537

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

3538

"colon (:)"

3539

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

3540

(char**) &opt_mysql_tmpdir,

3541

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

1815

3542

{"transaction-isolation", OPT_TX_ISOLATION,

1816

N_("Default transaction isolation level."),

1817

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

3543

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

1818

3544

0, 0, 0, 0, 0},

1819

{"user", 'u',

1820

N_("Run drizzled daemon as user."),

1821

0, 0, 0, GET_STR, REQUIRED_ARG,

3545

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

3546

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

3547

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

3548

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

1822

3549

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

1823

{"back_log", OPT_BACK_LOG,

1824

N_("The number of outstanding connection requests Drizzle can have. This "

1825

"comes into play when the main Drizzle thread gets very many connection "

1826

"requests in a very short time."),

1827

(char**) &back_log, (char**) &back_log, 0, GET_UINT,

3550

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

3551

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

3552

0, 0},

3553

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

3554

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

3555

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

3556

(char**) &global_system_variables.log_warnings,

3557

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

3558

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

3559

{ "back_log", OPT_BACK_LOG,

3560

"The number of outstanding connection requests MySQL can have. This comes into play when the main MySQL thread gets very many connection requests in a very short time.",

3561

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

1828

3562

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

1829

{ "bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,

1830

N_("Size of tree cache used in bulk insert optimization. Note that this is "

1831

"a limit per thread!"),

1832

(char**) &global_system_variables.bulk_insert_buff_size,

1833

(char**) &max_system_variables.bulk_insert_buff_size,

1834

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

1835

{ "div_precision_increment", OPT_DIV_PRECINCREMENT,

1836

N_("Precision of the result of '/' operator will be increased on that "

1837

"value."),

3563

{"binlog_cache_size", OPT_BINLOG_CACHE_SIZE,

3564

"The size of the cache to hold the SQL statements for the binary log during a transaction. If you often use big, multi-statement transactions you can increase this to get more performance.",

3565

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

3566

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

3567

{"bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,

3568

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

3569

(char**) &global_system_variables.bulk_insert_buff_size,

3570

(char**) &max_system_variables.bulk_insert_buff_size,

3571

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

3572

{"connect_timeout", OPT_CONNECT_TIMEOUT,

3573

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

3574

(char**) &connect_timeout, (char**) &connect_timeout,

3575

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

3576

{ "date_format", OPT_DATE_FORMAT,

3577

"The DATE format (For future).",

3578

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],

3579

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],

3580

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

3581

{ "datetime_format", OPT_DATETIME_FORMAT,

3582

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

3583

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],

3584

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],

3585

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

3586

{ "default_week_format", OPT_DEFAULT_WEEK_FORMAT,

3587

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

3588

(char**) &global_system_variables.default_week_format,

3589

(char**) &max_system_variables.default_week_format,

3590

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

3591

{"div_precision_increment", OPT_DIV_PRECINCREMENT,

3592

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

1838

3593

(char**) &global_system_variables.div_precincrement,

1839

(char**) &max_system_variables.div_precincrement, 0, GET_UINT,

3594

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

1840

3595

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

1841

{ "join_buffer_size", OPT_JOIN_BUFF_SIZE,

1842

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

3596

{"expire_logs_days", OPT_EXPIRE_LOGS_DAYS,

3597

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

3598

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

3599

(char**) &expire_logs_days,

3600

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

3601

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

3602

{ "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,

3603

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

3604

(char**) &global_system_variables.group_concat_max_len,

3605

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

3606

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

3607

{"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,

3608

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

3609

(char**) &global_system_variables.net_interactive_timeout,

3610

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

3611

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

3612

{"join_buffer_size", OPT_JOIN_BUFF_SIZE,

3613

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

1843

3614

(char**) &global_system_variables.join_buff_size,

1844

(char**) &max_system_variables.join_buff_size, 0, GET_UINT64,

3615

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

1845

3616

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

1846

3617

MALLOC_OVERHEAD, IO_SIZE, 0},

3618

{"keep_files_on_create", OPT_KEEP_FILES_ON_CREATE,

3619

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

3620

(char**) &global_system_variables.keep_files_on_create,

3621

(char**) &max_system_variables.keep_files_on_create,

3622

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

3623

{"key_buffer_size", OPT_KEY_BUFFER_SIZE,

3624

"The size of the buffer used for index blocks for MyISAM tables. Increase this to get better index handling (for all reads and multiple writes) to as much as you can afford; 64M on a 256M machine that mainly runs MySQL is quite common.",

3625

(char**) &dflt_key_cache_var.param_buff_size,

3626

(char**) 0,

3627

0, (GET_ULL | GET_ASK_ADDR),

3628

REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, SIZE_T_MAX, MALLOC_OVERHEAD,

3629

IO_SIZE, 0},

3630

{"key_cache_age_threshold", OPT_KEY_CACHE_AGE_THRESHOLD,

3631

"This characterizes the number of hits a hot block has to be untouched until it is considered aged enough to be downgraded to a warm block. This specifies the percentage ratio of that number of hits to the total number of blocks in key cache",

3632

(char**) &dflt_key_cache_var.param_age_threshold,

3633

(char**) 0,

3634

0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,

3635

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

3636

{"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,

3637

"The default size of key cache blocks",

3638

(char**) &dflt_key_cache_var.param_block_size,

3639

(char**) 0,

3640

0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,

3641

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

3642

{"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,

3643

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

3644

(char**) &dflt_key_cache_var.param_division_limit,

3645

(char**) 0,

3646

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

3647

1, 100, 0, 1, 0},

3648

{"long_query_time", OPT_LONG_QUERY_TIME,

3649

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

3650

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

3651

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

3652

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

3653

{"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,

3654

"If set to 1 table names are stored in lowercase on disk and table names will be case-insensitive. Should be set to 2 if you are using a case insensitive file system",

3655

(char**) &lower_case_table_names,

3656

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

3657

#ifdef FN_NO_CASE_SENCE

3658

3659

#else

3660

3661

#endif

3662

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

1847

3663

{"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,

1848

N_("Max packetlength to send/receive from to server."),

3664

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

1849

3665

(char**) &global_system_variables.max_allowed_packet,

1850

(char**) &max_system_variables.max_allowed_packet, 0, GET_UINT32,

1851

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

3666

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

3667

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

3668

{"max_binlog_cache_size", OPT_MAX_BINLOG_CACHE_SIZE,

3669

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

3670

(char**) &max_binlog_cache_size, (char**) &max_binlog_cache_size, 0,

3671

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

3672

{"max_binlog_size", OPT_MAX_BINLOG_SIZE,

3673

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

3674

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

3675

The minimum value for this variable is 4096.",

3676

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

3677

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

3678

{"max_connect_errors", OPT_MAX_CONNECT_ERRORS,

3679

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

3680

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

3681

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

3682

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

3683

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

3684

{"max_connections", OPT_MAX_CONNECTIONS,

3685

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

3686

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

3687

0},

3688

{"max_error_count", OPT_MAX_ERROR_COUNT,

3689

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

3690

(char**) &global_system_variables.max_error_count,

3691

(char**) &max_system_variables.max_error_count,

3692

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

1852

3693

{"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,

1853

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

3694

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

1854

3695

(char**) &global_system_variables.max_heap_table_size,

1855

3696

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

1856

REQUIRED_ARG, 16*1024*1024L, 16384, (int64_t)MAX_MEM_TABLE_SIZE,

3697

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

1857

3698

MALLOC_OVERHEAD, 1024, 0},

1858

3699

{"max_join_size", OPT_MAX_JOIN_SIZE,

1859

N_("Joins that are probably going to read more than max_join_size records "

1860

"return an error."),

3700

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

1861

3701

(char**) &global_system_variables.max_join_size,

1862

3702

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

1863

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

1864

{"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,

1865

N_("Max number of bytes in sorted records."),

1866

(char**) &global_system_variables.max_length_for_sort_data,

1867

(char**) &max_system_variables.max_length_for_sort_data, 0, GET_ULL,

1868

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

3703

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

3704

{"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,

3705

"Max number of bytes in sorted records.",

3706

(char**) &global_system_variables.max_length_for_sort_data,

3707

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

3708

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

3709

{"max_relay_log_size", OPT_MAX_RELAY_LOG_SIZE,

3710

"If non-zero: relay log will be rotated automatically when the size exceeds this value; if zero (the default): when the size exceeds max_binlog_size. 0 excepted, the minimum value for this variable is 4096.",

3711

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

3712

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

1869

3713

{ "max_seeks_for_key", OPT_MAX_SEEKS_FOR_KEY,

1870

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

3714

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

1871

3715

(char**) &global_system_variables.max_seeks_for_key,

1872

(char**) &max_system_variables.max_seeks_for_key, 0, GET_UINT64,

3716

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

1873

3717

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

1874

3718

{"max_sort_length", OPT_MAX_SORT_LENGTH,

1875

N_("The number of bytes to use when sorting BLOB or TEXT values "

1876

"(only the first max_sort_length bytes of each value are used; the "

1877

"rest are ignored)."),

3719

"The number of bytes to use when sorting BLOB or TEXT values (only the first max_sort_length bytes of each value are used; the rest are ignored).",

1878

3720

(char**) &global_system_variables.max_sort_length,

1879

(char**) &max_system_variables.max_sort_length, 0, GET_SIZE,

3721

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

1880

3722

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

3723

{"max_tmp_tables", OPT_MAX_TMP_TABLES,

3724

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

3725

(char**) &global_system_variables.max_tmp_tables,

3726

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

3727

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

1881

3728

{"max_write_lock_count", OPT_MAX_WRITE_LOCK_COUNT,

1882

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

1883

(char**) &max_write_lock_count, (char**) &max_write_lock_count, 0, GET_ULL,

3729

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

3730

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

1884

3731

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

1885

3732

{"min_examined_row_limit", OPT_MIN_EXAMINED_ROW_LIMIT,

1886

N_("Don't log queries which examine less than min_examined_row_limit "

1887

"rows to file."),

3733

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

1888

3734

(char**) &global_system_variables.min_examined_row_limit,

1889

(char**) &max_system_variables.min_examined_row_limit, 0, GET_ULL,

1890

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

3735

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

3736

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

3737

{"myisam_block_size", OPT_MYISAM_BLOCK_SIZE,

3738

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

3739

(char**) &opt_myisam_block_size,

3740

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

3741

MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, MI_MAX_KEY_BLOCK_LENGTH,

3742

0, MI_MIN_KEY_BLOCK_LENGTH, 0},

3743

{"myisam_data_pointer_size", OPT_MYISAM_DATA_POINTER_SIZE,

3744

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

3745

(char**) &myisam_data_pointer_size,

3746

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

3747

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

3748

{"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,

3749

"Deprecated option",

3750

(char**) &global_system_variables.myisam_max_extra_sort_file_size,

3751

(char**) &max_system_variables.myisam_max_extra_sort_file_size,

3752

0, GET_ULL, REQUIRED_ARG, (uint64_t) MI_MAX_TEMP_LENGTH,

3753

0, (uint64_t) MAX_FILE_SIZE, 0, 1, 0},

3754

{"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,

3755

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

3756

(char**) &global_system_variables.myisam_max_sort_file_size,

3757

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

3758

GET_ULL, REQUIRED_ARG, (int64_t) LONG_MAX, 0, (uint64_t) MAX_FILE_SIZE,

3759

0, 1024*1024, 0},

3760

{"myisam_repair_threads", OPT_MYISAM_REPAIR_THREADS,

3761

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

3762

(char**) &global_system_variables.myisam_repair_threads,

3763

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

3764

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

3765

{"myisam_sort_buffer_size", OPT_MYISAM_SORT_BUFFER_SIZE,

3766

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

3767

(char**) &global_system_variables.myisam_sort_buff_size,

3768

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

3769

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

3770

{"myisam_stats_method", OPT_MYISAM_STATS_METHOD,

3771

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

3772

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

3773

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

3774

(char**) &myisam_stats_method_str, (char**) &myisam_stats_method_str, 0,

3775

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

3776

{"net_buffer_length", OPT_NET_BUFFER_LENGTH,

3777

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

3778

(char**) &global_system_variables.net_buffer_length,

3779

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

3780

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

3781

{"net_read_timeout", OPT_NET_READ_TIMEOUT,

3782

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

3783

(char**) &global_system_variables.net_read_timeout,

3784

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

3785

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

3786

{"net_retry_count", OPT_NET_RETRY_COUNT,

3787

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

3788

(char**) &global_system_variables.net_retry_count,

3789

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

3790

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

3791

{"net_write_timeout", OPT_NET_WRITE_TIMEOUT,

3792

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

3793

(char**) &global_system_variables.net_write_timeout,

3794

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

3795

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

3796

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

3797

(char**) &global_system_variables.old_mode,

3798

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

3799

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

3800

{"open_files_limit", OPT_OPEN_FILES_LIMIT,

3801

"If this is not 0, then mysqld will use this value to reserve file descriptors to use with setrlimit(). If this value is 0 then mysqld will reserve max_connections*5 or max_connections + table_cache*2 (whichever is larger) number of files.",

3802

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

3803

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

1891

3804

{"optimizer_prune_level", OPT_OPTIMIZER_PRUNE_LEVEL,

1892

N_("Controls the heuristic(s) applied during query optimization to prune "

1893

"less-promising partial plans from the optimizer search space. Meaning: "

1894

"false - do not apply any heuristic, thus perform exhaustive search; "

1895

"true - prune plans based on number of retrieved rows."),

1896

(char**) &global_system_variables.optimizer_prune_level,

1897

(char**) &max_system_variables.optimizer_prune_level,

1898

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

3805

"Controls the heuristic(s) applied during query optimization to prune less-promising partial plans from the optimizer search space. Meaning: 0 - do not apply any heuristic, thus perform exhaustive search; 1 - prune plans based on number of retrieved rows.",

3806

(char**) &global_system_variables.optimizer_prune_level,

3807

(char**) &max_system_variables.optimizer_prune_level,

3808

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

1899

3809

{"optimizer_search_depth", OPT_OPTIMIZER_SEARCH_DEPTH,

1900

N_("Maximum depth of search performed by the query optimizer. Values "

1901

"larger than the number of relations in a query result in better query "

1902

"plans, but take longer to compile a query. Smaller values than the "

1903

"number of tables in a relation result in faster optimization, but may "

1904

"produce very bad query plans. If set to 0, the system will "

1905

"automatically pick a reasonable value; if set to MAX_TABLES+2, the "

1906

"optimizer will switch to the original find_best (used for "

1907

"testing/comparison)."),

3810

"Maximum depth of search performed by the query optimizer. Values larger than the number of relations in a query result in better query plans, but take longer to compile a query. Smaller values than the number of tables in a relation result in faster optimization, but may produce very bad query plans. If set to 0, the system will automatically pick a reasonable value; if set to MAX_TABLES+2, the optimizer will switch to the original find_best (used for testing/comparison).",

1908

3811

(char**) &global_system_variables.optimizer_search_depth,

1909

3812

(char**) &max_system_variables.optimizer_search_depth,

1910

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

3813

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

1911

3814

{"plugin_dir", OPT_PLUGIN_DIR,

1912

N_("Directory for plugins."),

1913

NULL, NULL, 0,

1914

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

1915

{"plugin_add", OPT_PLUGIN_ADD,

1916

N_("Optional comma separated list of plugins to load at startup in addition "

1917

"to the default list of plugins. "

1918

"[for example: --plugin_add=crc32,logger_gearman]"),

1919

NULL, NULL, 0,

1920

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

1921

{"plugin_remove", OPT_PLUGIN_ADD,

1922

N_("Optional comma separated list of plugins to not load at startup. Effectively "

1923

"removes a plugin from the list of plugins to be loaded. "

1924

"[for example: --plugin_remove=crc32,logger_gearman]"),

1925

NULL, NULL, 0,

3815

"Directory for plugins.",

3816

(char**) &opt_plugin_dir_ptr, (char**) &opt_plugin_dir_ptr, 0,

1926

3817

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

1927

3818

{"plugin_load", OPT_PLUGIN_LOAD,

1928

N_("Optional comma separated list of plugins to load at starup instead of "

1929

"the default plugin load list. "

1930

"[for example: --plugin_load=crc32,logger_gearman]"),

1931

NULL, NULL, 0,

3819

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

3820

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

3821

(char**) &opt_plugin_load, (char**) &opt_plugin_load, 0,

1932

3822

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

1933

3823

{"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,

1934

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

3824

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

1935

3825

(char**) &global_system_variables.preload_buff_size,

1936

(char**) &max_system_variables.preload_buff_size, 0, GET_ULL,

3826

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

1937

3827

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

1938

3828

{"query_alloc_block_size", OPT_QUERY_ALLOC_BLOCK_SIZE,

1939

N_("Allocation block size for query parsing and execution"),

3829

"Allocation block size for query parsing and execution",

1940

3830

(char**) &global_system_variables.query_alloc_block_size,

1941

(char**) &max_system_variables.query_alloc_block_size, 0, GET_UINT,

3831

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

1942

3832

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

1943

3833

{"query_prealloc_size", OPT_QUERY_PREALLOC_SIZE,

1944

N_("Persistent buffer for query parsing and execution"),

3834

"Persistent buffer for query parsing and execution",

1945

3835

(char**) &global_system_variables.query_prealloc_size,

1946

(char**) &max_system_variables.query_prealloc_size, 0, GET_UINT,

3836

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

1947

3837

REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,

1948

3838

ULONG_MAX, 0, 1024, 0},

1949

3839

{"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,

1950

N_("Allocation block size for storing ranges during optimization"),

3840

"Allocation block size for storing ranges during optimization",

1951

3841

(char**) &global_system_variables.range_alloc_block_size,

1952

(char**) &max_system_variables.range_alloc_block_size, 0, GET_SIZE,

1953

REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, (int64_t)SIZE_MAX,

3842

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

3843

REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, ULONG_MAX,

1954

3844

0, 1024, 0},

1955

3845

{"read_buffer_size", OPT_RECORD_BUFFER,

1956

N_("Each thread that does a sequential scan allocates a buffer of this "

1957

"size for each table it scans. If you do many sequential scans, you may "

1958

"want to increase this value."),

1959

(char**) &global_system_variables.read_buff_size,

1960

(char**) &max_system_variables.read_buff_size,0, GET_UINT, REQUIRED_ARG,

1961

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

1962

0},

3846

"Each thread that does a sequential scan allocates a buffer of this size for each table it scans. If you do many sequential scans, you may want to increase this value.",

3847

(char**) &global_system_variables.read_buff_size,

3848

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

3849

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

3850

0},

3851

{"read_only", OPT_READONLY,

3852

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

3853

(char**) &opt_readonly,

3854

(char**) &opt_readonly,

3855

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

1963

3856

{"read_rnd_buffer_size", OPT_RECORD_RND_BUFFER,

1964

N_("When reading rows in sorted order after a sort, the rows are read "

1965

"through this buffer to avoid a disk seeks. If not set, then it's set "

1966

"to the value of record_buffer."),

3857

"When reading rows in sorted order after a sort, the rows are read through this buffer to avoid a disk seeks. If not set, then it's set to the value of record_buffer.",

1967

3858

(char**) &global_system_variables.read_rnd_buff_size,

1968

3859

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

1969

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

1970

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

1971

/* x8 compared to MySQL's x2. We have UTF8 to consider. */

3860

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

3861

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

3862

{"record_buffer", OPT_RECORD_BUFFER,

3863

"Alias for read_buffer_size",

3864

(char**) &global_system_variables.read_buff_size,

3865

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

3866

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

3867

{"relay_log_purge", OPT_RELAY_LOG_PURGE,

3868

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

3869

(char**) &relay_log_purge,

3870

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

3871

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

3872

{"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,

3873

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

3874

(char**) &relay_log_space_limit,

3875

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

3876

(int64_t) ULONG_MAX, 0, 1, 0},

3877

{"slave_compressed_protocol", OPT_SLAVE_COMPRESSED_PROTOCOL,

3878

"Use compression on master/slave protocol.",

3879

(char**) &opt_slave_compressed_protocol,

3880

(char**) &opt_slave_compressed_protocol,

3881

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

3882

{"slave_net_timeout", OPT_SLAVE_NET_TIMEOUT,

3883

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

3884

(char**) &slave_net_timeout, (char**) &slave_net_timeout, 0,

3885

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

3886

{"slave_transaction_retries", OPT_SLAVE_TRANS_RETRIES,

3887

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

3888

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

3889

"before giving up and stopping.",

3890

(char**) &slave_trans_retries, (char**) &slave_trans_retries, 0,

3891

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

3892

{"slave-allow-batching", OPT_SLAVE_ALLOW_BATCHING,

3893

"Allow slave to batch requests.",

3894

(char**) &slave_allow_batching, (char**) &slave_allow_batching,

3895

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

3896

{"slow_launch_time", OPT_SLOW_LAUNCH_TIME,

3897

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

3898

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

3899

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

1972

3900

{"sort_buffer_size", OPT_SORT_BUFFER,

1973

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

3901

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

1974

3902

(char**) &global_system_variables.sortbuff_size,

1975

(char**) &max_system_variables.sortbuff_size, 0, GET_SIZE, REQUIRED_ARG,

1976

MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*8, (int64_t)SIZE_MAX,

3903

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

3904

MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ULONG_MAX,

1977

3905

MALLOC_OVERHEAD, 1, 0},

3906

{"sync-binlog", OPT_SYNC_BINLOG,

3907

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

3908

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

3909

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

3910

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

3911

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

3912

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

3913

0, 0, 0, 0},

3914

{"table_cache", OPT_TABLE_OPEN_CACHE,

3915

"Deprecated; use --table_open_cache instead.",

3916

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

3917

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

1978

3918

{"table_definition_cache", OPT_TABLE_DEF_CACHE,

1979

N_("The number of cached table definitions."),

3919

"The number of cached table definitions.",

1980

3920

(char**) &table_def_size, (char**) &table_def_size,

1981

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

3921

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

1982

3922

{"table_open_cache", OPT_TABLE_OPEN_CACHE,

1983

N_("The number of cached open tables."),

1984

(char**) &table_cache_size, (char**) &table_cache_size, 0, GET_UINT64,

1985

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

3923

"The number of cached open tables.",

3924

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

3925

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

1986

3926

{"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,

1987

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

1988

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

3927

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

3928

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

1989

3929

(char**) &table_lock_wait_timeout, (char**) &table_lock_wait_timeout,

1990

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

3930

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

3931

{"thread_cache_size", OPT_THREAD_CACHE_SIZE,

3932

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

3933

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

3934

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

3935

{"thread_pool_size", OPT_THREAD_CACHE_SIZE,

3936

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

3937

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

3938

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

1991

3939

{"thread_stack", OPT_THREAD_STACK,

1992

N_("The stack size for each thread."),

1993

(char**) &my_thread_stack_size,

1994

(char**) &my_thread_stack_size, 0, GET_SIZE,

1995

REQUIRED_ARG,DEFAULT_THREAD_STACK,

1996

UINT32_C(1024*512), (int64_t)SIZE_MAX, 0, 1024, 0},

3940

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

3941

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

3942

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

3943

{ "time_format", OPT_TIME_FORMAT,

3944

"The TIME format (for future).",

3945

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],

3946

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],

3947

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

1997

3948

{"tmp_table_size", OPT_TMP_TABLE_SIZE,

1998

N_("If an internal in-memory temporary table exceeds this size, Drizzle will"

1999

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

3949

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

3950

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

2000

3951

(char**) &global_system_variables.tmp_table_size,

2001

3952

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

2002

REQUIRED_ARG, 16*1024*1024L, 1024, (int64_t)MAX_MEM_TABLE_SIZE, 0, 1, 0},

3953

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

3954

{"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,

3955

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

3956

(char**) &global_system_variables.trans_alloc_block_size,

3957

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

3958

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

3959

{"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,

3960

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

3961

(char**) &global_system_variables.trans_prealloc_size,

3962

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

3963

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

3964

{"wait_timeout", OPT_WAIT_TIMEOUT,

3965

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

3966

(char**) &global_system_variables.net_wait_timeout,

3967

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

3968

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

3969

0, 1, 0},

2003

3970

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

2004

3971

};

2005

3972

3973

static int show_net_compression(THD *thd __attribute__((__unused__)),

3974

SHOW_VAR *var,

3975

char *buff __attribute__((__unused__)))

3976

{

3977

var->type= SHOW_MY_BOOL;

3978

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

3979

return 0;

3980

}

3981

3982

static st_show_var_func_container

3983

show_net_compression_cont= { &show_net_compression };

3984

3985

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

3986

{

3987

var->type= SHOW_LONG;

3988

var->value= buff;

3989

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

3990

return 0;

3991

}

3992

3993

static st_show_var_func_container

3994

show_starttime_cont= { &show_starttime };

3995

3996

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

3997

{

3998

var->type= SHOW_LONG;

3999

var->value= buff;

4000

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

4001

return 0;

4002

}

4003

4004

static st_show_var_func_container

4005

show_flushstatustime_cont= { &show_flushstatustime };

4006

4007

static int show_slave_running(THD *thd __attribute__((__unused__)),

4008

SHOW_VAR *var, char *buff)

4009

{

4010

var->type= SHOW_MY_BOOL;

4011

pthread_mutex_lock(&LOCK_active_mi);

4012

var->value= buff;

4013

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

4014

active_mi->rli.slave_running);

4015

pthread_mutex_unlock(&LOCK_active_mi);

4016

return 0;

4017

}

4018

4019

static st_show_var_func_container

4020

show_slave_running_cont= { &show_slave_running };

4021

4022

static int show_slave_retried_trans(THD *thd __attribute__((__unused__)),

4023

SHOW_VAR *var, char *buff)

4024

{

4025

4026

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

4027

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

4028

4029

pthread_mutex_lock(&LOCK_active_mi);

4030

if (active_mi)

4031

{

4032

var->type= SHOW_LONG;

4033

var->value= buff;

4034

pthread_mutex_lock(&active_mi->rli.data_lock);

4035

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

4036

pthread_mutex_unlock(&active_mi->rli.data_lock);

4037

}

4038

else

4039

var->type= SHOW_UNDEF;

4040

pthread_mutex_unlock(&LOCK_active_mi);

4041

return 0;

4042

}

4043

4044

static st_show_var_func_container

4045

show_slave_retried_trans_cont= { &show_slave_retried_trans };

4046

4047

static int show_slave_received_heartbeats(THD *thd __attribute__((__unused__)),

4048

SHOW_VAR *var, char *buff)

4049

{

4050

pthread_mutex_lock(&LOCK_active_mi);

4051

if (active_mi)

4052

{

4053

var->type= SHOW_LONGLONG;

4054

var->value= buff;

4055

pthread_mutex_lock(&active_mi->rli.data_lock);

4056

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

4057

pthread_mutex_unlock(&active_mi->rli.data_lock);

4058

}

4059

else

4060

var->type= SHOW_UNDEF;

4061

pthread_mutex_unlock(&LOCK_active_mi);

4062

return 0;

4063

}

4064

4065

static st_show_var_func_container

4066

show_slave_received_heartbeats_cont= { &show_slave_received_heartbeats };

4067

4068

static int show_heartbeat_period(THD *thd __attribute__((__unused__)),

4069

SHOW_VAR *var, char *buff)

4070

{

4071

pthread_mutex_lock(&LOCK_active_mi);

4072

if (active_mi)

4073

{

4074

var->type= SHOW_CHAR;

4075

var->value= buff;

4076

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

4077

}

4078

else

4079

var->type= SHOW_UNDEF;

4080

pthread_mutex_unlock(&LOCK_active_mi);

4081

return 0;

4082

}

4083

4084

static st_show_var_func_container

4085

show_heartbeat_period_cont= { &show_heartbeat_period};

4086

4087

static int show_open_tables(THD *thd __attribute__((__unused__)),

4088

SHOW_VAR *var, char *buff)

4089

{

4090

var->type= SHOW_LONG;

4091

var->value= buff;

4092

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

4093

return 0;

4094

}

4095

4096

static int show_table_definitions(THD *thd __attribute__((__unused__)),

4097

SHOW_VAR *var, char *buff)

4098

{

4099

var->type= SHOW_LONG;

4100

var->value= buff;

4101

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

4102

return 0;

4103

}

4104

4105

static st_show_var_func_container

4106

show_open_tables_cont= { &show_open_tables };

4107

static st_show_var_func_container

4108

show_table_definitions_cont= { &show_table_definitions };

4109

4110

4111

Variables shown by SHOW STATUS in alphabetical order

4112

4113

4114

SHOW_VAR status_vars[]= {

4115

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

4116

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

4117

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

4118

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

4119

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

4120

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

4121

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

4122

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

4123

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

4124

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

4125

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

4126

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

4127

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

4128

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

4129

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

4130

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

4131

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

4132

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

4133

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

4134

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

4135

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

4136

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

4137

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

4138

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

4139

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

4140

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

4141

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

4142

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

4143

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

4144

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

4145

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

4146

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

4147

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

4148

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

4149

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

4150

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

4151

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

4152

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

4153

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

4154

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

4155

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

4156

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

4157

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

4158

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

4159

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

4160

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

4161

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

4162

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

4163

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

4164

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

4165

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

4166

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

4167

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

4168

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

4169

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

4170

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

4171

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

4172

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

4173

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

4174

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

4175

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

4176

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

4177

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

4178

#ifdef HAVE_MMAP

4179

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

4180

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

4181

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

4182

#endif

4183

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

4184

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

4185

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

4186

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

4187

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

4188

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

4189

{NullS, NullS, SHOW_LONG}

4190

};

4191

2006

4192

static void print_version(void)

2007

4193

{

4194

set_server_version();

2008

4195

2009

4196

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

2010

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

4197

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

2011

4198

2012

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

2013

PANDORA_RELEASE_VERSION, HOST_VENDOR, HOST_OS, HOST_CPU,

2014

COMPILATION_COMMENT);

4199

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

4200

server_version,SYSTEM_TYPE,MACHINE_TYPE, MYSQL_COMPILATION_COMMENT);

2015

4201

}

2016

4202

2017

4203

static void usage(void)

2018

4204

{

2019

if (!(default_charset_info= get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

4205

if (!(default_charset_info= get_charset_by_csname(default_character_set_name,

4206

MY_CS_PRIMARY,

4207

MYF(MY_WME))))

2020

4208

exit(1);

2021

4209

if (!default_collation_name)

2022

4210

default_collation_name= (char*) default_charset_info->name;

2023

4211

print_version();

2024

2025

"This software comes with ABSOLUTELY NO WARRANTY. "

2026

"This is free software,\n"

2027

"and you are welcome to modify and redistribute it under the GPL "

2028

"license\n\n"));

2029

2030

2031

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

2032

2033

po::options_description all_options("Drizzled Options");

2034

all_options.add(config_options);

2035

all_options.add(plugin_load_options);

2036

all_options.add(long_options);

2037

all_options.add(plugin_options);

2038

cout << all_options << endl;

2039

4212

puts("\

4213

4214

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

4215

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

4216

Starts the MySQL database server\n");

4217

4218

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

4219

if (!opt_verbose)

4220

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

4221

else

4222

{

4223

print_defaults(MYSQL_CONFIG_NAME,load_default_groups);

4224

puts("");

4225

set_ports();

4226

4227

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

4228

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

4229

4230

puts("\n\

4231

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

4232

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

4233

}

2040

4234

}

2041

4235

4236

2042

4237

/**

2043

Initialize all Drizzle global variables to default values.

4238

Initialize all MySQL global variables to default values.

2044

4239

2045

4240

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

2046

4241

as these are initialized by my_getopt.

2055

4250

as these are initialized by my_getopt.

2056

4251

2057

4252

2058

static void drizzle_init_variables(void)

4253

static void mysql_init_variables(void)

2059

4254

{

2060

4255

/* Things reset to zero */

4256

opt_skip_slave_start= opt_reckless_slave = 0;

4257

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

4258

opt_log= opt_slow_log= 0;

4259

log_output_options= find_bit_type(log_output_str, &log_output_typelib);

4260

opt_bin_log= 0;

4261

opt_disable_networking= opt_skip_show_db=0;

4262

opt_logname= opt_binlog_index_name= opt_slow_logname= 0;

2061

4263

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

4264

opt_secure_auth= 0;

4265

opt_secure_file_priv= 0;

4266

opt_bootstrap= opt_myisam_log= 0;

4267

segfaulted= kill_in_progress= 0;

2062

4268

cleanup_done= 0;

2063

dropping_tables= ha_open_options=0;

2064

getDebug().reset();

2065

wake_thread=0;

2066

abort_loop= select_thread_in_use= false;

2067

shutdown_in_progress= 0;

2068

drizzled_user= drizzled_chroot= 0;

2069

memset(&current_global_counters, 0, sizeof(current_global_counters));

2070

key_map_full.set();

4269

defaults_argc= 0;

4270

defaults_argv= 0;

4271

server_id_supplied= 0;

4272

test_flags= select_errors= dropping_tables= ha_open_options=0;

4273

thread_count= thread_running= kill_cached_threads= wake_thread=0;

4274

slave_open_temp_tables= 0;

4275

cached_thread_count= 0;

4276

opt_endinfo= using_udf_functions= 0;

4277

opt_using_transactions= using_update_log= 0;

4278

abort_loop= select_thread_in_use= signal_thread_in_use= 0;

4279

ready_to_exit= shutdown_in_progress= 0;

4280

aborted_threads= aborted_connects= 0;

4281

specialflag= 0;

4282

binlog_cache_use= binlog_cache_disk_use= 0;

4283

max_used_connections= slow_launch_threads = 0;

4284

mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;

4285

errmesg= 0;

4286

opt_mysql_tmpdir= my_bind_addr_str= NullS;

4287

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

4288

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

4289

key_map_full.set_all();

2071

4290

2072

4291

/* Character sets */

2073

4292

system_charset_info= &my_charset_utf8_general_ci;

2074

4293

files_charset_info= &my_charset_utf8_general_ci;

4294

national_charset_info= &my_charset_utf8_general_ci;

2075

4295

table_alias_charset= &my_charset_bin;

2076

4296

character_set_filesystem= &my_charset_bin;

2077

4297

4298

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

4299

2078

4300

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

2079

session_startup_options= (OPTION_AUTO_IS_NULL | OPTION_SQL_NOTES);

4301

delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;

4302

slave_exec_mode_options= 0;

4303

slave_exec_mode_options= (uint)

4304

find_bit_type_or_exit(slave_exec_mode_str, &slave_exec_mode_typelib, NULL);

4305

opt_specialflag= SPECIAL_ENGLISH;

4306

ip_sock= INVALID_SOCKET;

4307

mysql_home_ptr= mysql_home;

4308

pidfile_name_ptr= pidfile_name;

4309

log_error_file_ptr= log_error_file;

4310

language_ptr= language;

4311

mysql_data_home= mysql_real_data_home;

4312

thd_startup_options= (OPTION_AUTO_IS_NULL | OPTION_BIN_LOG |

4313

OPTION_QUOTE_SHOW_CREATE | OPTION_SQL_NOTES);

4314

protocol_version= PROTOCOL_VERSION;

4315

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

2080

4316

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

2081

global_thread_id= 1UL;

2082

session::Cache::singleton().getCache().clear();

4317

global_query_id= thread_id= 1L;

4318

strmov(server_version, MYSQL_SERVER_VERSION);

4319

myisam_recover_options_str= "OFF";

4320

myisam_stats_method_str= "nulls_unequal";

4321

threads.empty();

4322

thread_cache.empty();

4323

key_caches.empty();

4324

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

4325

default_key_cache_base.length)))

4326

exit(1);

4327

/* set key_cache_hash.default_value = dflt_key_cache */

4328

multi_keycache_init();

4329

4330

/* Set directory paths */

4331

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

4332

strmake(mysql_real_data_home, get_relative_path(DATADIR),

4333

sizeof(mysql_real_data_home)-1);

4334

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

4335

mysql_data_home_buff[1]=0;

4336

mysql_data_home_len= 2;

4337

4338

/* Replication parameters */

4339

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

4340

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

4341

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

4342

opt_relay_logname= opt_relaylog_index_name= 0;

2083

4343

2084

4344

/* Variables in libraries */

2085

default_character_set_name= "utf8";

2086

default_collation_name= (char *)compiled_default_collation_name;

2087

character_set_filesystem_name= "binary";

4345

charsets_dir= 0;

4346

default_character_set_name= (char*) MYSQL_DEFAULT_CHARSET_NAME;

4347

default_collation_name= compiled_default_collation_name;

4348

sys_charset_system.set((char*) system_charset_info->csname);

4349

character_set_filesystem_name= (char*) "binary";

2088

4350

lc_time_names_name= (char*) "en_US";

2089

4351

/* Set default values for some option variables */

2090

4352

default_storage_engine_str= (char*) "innodb";

2091

global_system_variables.storage_engine= NULL;

4353

global_system_variables.table_plugin= NULL;

2092

4354

global_system_variables.tx_isolation= ISO_REPEATABLE_READ;

2093

4355

global_system_variables.select_limit= (uint64_t) HA_POS_ERROR;

2094

4356

max_system_variables.select_limit= (uint64_t) HA_POS_ERROR;

2095

4357

global_system_variables.max_join_size= (uint64_t) HA_POS_ERROR;

2096

4358

max_system_variables.max_join_size= (uint64_t) HA_POS_ERROR;

2097

max_system_variables.auto_increment_increment= UINT64_MAX;

2098

max_system_variables.auto_increment_offset= UINT64_MAX;

2099

max_system_variables.completion_type= 2;

2100

max_system_variables.log_warnings= true;

2101

max_system_variables.bulk_insert_buff_size= ULONG_MAX;

2102

max_system_variables.div_precincrement= DECIMAL_MAX_SCALE;

2103

max_system_variables.group_concat_max_len= ULONG_MAX;

2104

max_system_variables.join_buff_size= ULONG_MAX;

2105

max_system_variables.max_allowed_packet= 1024L*1024L*1024L;

2106

max_system_variables.max_error_count= 65535;

2107

max_system_variables.max_heap_table_size= MAX_MEM_TABLE_SIZE;

2108

max_system_variables.max_join_size= INT32_MAX;

2109

max_system_variables.max_length_for_sort_data= 8192*1024L;

2110

max_system_variables.max_seeks_for_key= ULONG_MAX;

2111

max_system_variables.max_sort_length= 8192*1024L;

2112

max_system_variables.min_examined_row_limit= ULONG_MAX;

2113

max_system_variables.optimizer_prune_level= 1;

2114

max_system_variables.optimizer_search_depth= MAX_TABLES+2;

2115

max_system_variables.preload_buff_size= 1024*1024*1024L;

2116

max_system_variables.query_alloc_block_size= UINT32_MAX;

2117

max_system_variables.query_prealloc_size= UINT32_MAX;

2118

max_system_variables.range_alloc_block_size= SIZE_MAX;

2119

max_system_variables.read_buff_size= INT32_MAX;

2120

max_system_variables.read_rnd_buff_size= UINT32_MAX;

2121

max_system_variables.sortbuff_size= SIZE_MAX;

2122

max_system_variables.tmp_table_size= MAX_MEM_TABLE_SIZE;

2123

2124

opt_scheduler_default= (char*) "multi_thread";

4359

global_system_variables.old_alter_table= 0;

4360

global_system_variables.binlog_format= BINLOG_FORMAT_UNSPEC;

4361

4362

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

4363

when collecting index statistics for MyISAM tables.

4364

4365

global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;

2125

4366

2126

4367

/* Variables that depends on compile options */

4368

opt_error_log= IF_WIN(1,0);

2127

4369

#ifdef HAVE_BROKEN_REALPATH

2128

4370

have_symlink=SHOW_OPTION_NO;

2129

4371

#else

2130

4372

have_symlink=SHOW_OPTION_YES;

2131

4373

#endif

4374

#ifdef HAVE_CRYPT

4375

have_crypt=SHOW_OPTION_YES;

4376

#else

4377

have_crypt=SHOW_OPTION_NO;

4378

#endif

4379

#ifdef HAVE_COMPRESS

4380

have_compress= SHOW_OPTION_YES;

4381

#else

4382

have_compress= SHOW_OPTION_NO;

4383

#endif

4384

4385

const char *tmpenv;

4386

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

4387

tmpenv = DEFAULT_MYSQL_HOME;

4388

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

2132

4389

}

2133

4390

2134

4391

2135

/**

2136

@todo

2137

- FIXME add EXIT_TOO_MANY_ARGUMENTS to "drizzled/error.h" and return that code?

2138

2139

static void get_options()

4392

bool

4393

mysqld_get_one_option(int optid,

4394

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

4395

char *argument)

2140

4396

{

2141

2142

fs::path &data_home_catalog= getDataHomeCatalog();

2143

data_home_catalog= getDataHome();

2144

data_home_catalog /= "local";

2145

2146

if (vm.count("user"))

2147

{

2148

if (! drizzled_user || ! strcmp(drizzled_user, vm["user"].as<string>().c_str()))

2149

drizzled_user= (char *)vm["user"].as<string>().c_str();

2150

4397

switch(optid) {

4398

case '#':

4399

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

4400

break;

4401

case 'a':

4402

global_system_variables.tx_isolation= ISO_SERIALIZABLE;

4403

break;

4404

case 'b':

4405

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

4406

break;

4407

case 'C':

4408

if (default_collation_name == compiled_default_collation_name)

4409

default_collation_name= 0;

4410

break;

4411

case 'l':

4412

opt_log=1;

4413

break;

4414

case 'h':

4415

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

4416

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

4417

mysql_data_home= mysql_real_data_home;

4418

mysql_data_home_len= strlen(mysql_data_home);

4419

break;

4420

case 'u':

4421

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

4422

mysqld_user= argument;

2151

4423

else

2152

errmsg_printf(error::WARN, _("Ignoring user change to '%s' because the user was "

2153

"set to '%s' earlier on the command line\n"),

2154

vm["user"].as<string>().c_str(), drizzled_user);

2155

}

2156

2157

if (vm.count("version"))

2158

{

4424

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

4425

break;

4426

case 'L':

4427

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

4428

break;

4429

case OPT_SLAVE_SKIP_ERRORS:

4430

init_slave_skip_errors(argument);

4431

break;

4432

case OPT_SLAVE_EXEC_MODE:

4433

slave_exec_mode_options= (uint)

4434

find_bit_type_or_exit(argument, &slave_exec_mode_typelib, "");

4435

break;

4436

case 'V':

2159

4437

print_version();

2160

4438

exit(0);

2161

}

2162

2163

if (vm.count("sort-heap-threshold"))

2164

{

2165

if ((vm["sort-heap-threshold"].as<uint64_t>() > 0) and

2166

(vm["sort-heap-threshold"].as<uint64_t>() <

2167

global_system_variables.sortbuff_size))

2168

{

2169

cout << _("Error: sort-heap-threshold cannot be less than sort-buffer-size") << endl;

2170

exit(-1);

2171

}

2172

2173

global_sort_buffer.setMaxSize(vm["sort-heap-threshold"].as<uint64_t>());

2174

}

2175

2176

if (vm.count("join-heap-threshold"))

2177

{

2178

if ((vm["join-heap-threshold"].as<uint64_t>() > 0) and

2179

(vm["join-heap-threshold"].as<uint64_t>() <

2180

global_system_variables.join_buff_size))

2181

{

2182

cout << _("Error: join-heap-threshold cannot be less than join-buffer-size") << endl;

2183

exit(-1);

2184

}

2185

2186

global_join_buffer.setMaxSize(vm["join-heap-threshold"].as<uint64_t>());

2187

}

2188

2189

if (vm.count("read-rnd-threshold"))

2190

{

2191

if ((vm["read-rnd-threshold"].as<uint64_t>() > 0) and

2192

(vm["read-rnd-threshold"].as<uint64_t>() <

2193

global_system_variables.read_rnd_buff_size))

2194

{

2195

cout << _("Error: read-rnd-threshold cannot be less than read-rnd-buffer-size") << endl;

2196

exit(-1);

2197

}

2198

2199

global_read_rnd_buffer.setMaxSize(vm["read-rnd-threshold"].as<uint64_t>());

2200

}

2201

2202

if (vm.count("read-buffer-threshold"))

2203

{

2204

if ((vm["read-buffer-threshold"].as<uint64_t>() > 0) and

2205

(vm["read-buffer-threshold"].as<uint64_t>() <

2206

global_system_variables.read_buff_size))

2207

{

2208

cout << _("Error: read-buffer-threshold cannot be less than read-buffer-size") << endl;

2209

exit(-1);

2210

}

2211

2212

global_read_buffer.setMaxSize(vm["read-buffer-threshold"].as<uint64_t>());

2213

}

2214

2215

if (vm.count("exit-info"))

2216

{

2217

if (vm["exit-info"].as<long>())

2218

{

2219

getDebug().set((uint32_t) vm["exit-info"].as<long>());

2220

}

2221

}

2222

2223

if (vm.count("want-core"))

2224

{

2225

getDebug().set(debug::CORE_ON_SIGNAL);

2226

}

2227

2228

if (vm.count("skip-stack-trace"))

2229

{

2230

getDebug().set(debug::NO_STACKTRACE);

2231

}

2232

2233

if (vm.count("skip-symlinks"))

2234

{

2235

internal::my_use_symdir=0;

2236

}

2237

2238

if (vm.count("transaction-isolation"))

2239

{

2240

int type= tx_isolation_typelib.find_type_or_exit(vm["transaction-isolation"].as<string>().c_str(), "transaction-isolation");

2241

global_system_variables.tx_isolation= type - 1;

2242

}

2243

2244

/* @TODO Make this all strings */

2245

if (vm.count("default-storage-engine"))

2246

{

2247

default_storage_engine_str= (char *)vm["default-storage-engine"].as<string>().c_str();

2248

}

4439

case 'W':

4440

if (!argument)

4441

global_system_variables.log_warnings++;

4442

else if (argument == disabled_my_option)

4443

global_system_variables.log_warnings= 0L;

4444

else

4445

global_system_variables.log_warnings= atoi(argument);

4446

break;

4447

case 'T':

4448

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

4449

opt_endinfo=1;

4450

break;

4451

case (int) OPT_BIG_TABLES:

4452

thd_startup_options|=OPTION_BIG_TABLES;

4453

break;

4454

case (int) OPT_ISAM_LOG:

4455

opt_myisam_log=1;

4456

break;

4457

case (int) OPT_BIN_LOG:

4458

opt_bin_log= test(argument != disabled_my_option);

4459

break;

4460

case (int) OPT_ERROR_LOG_FILE:

4461

opt_error_log= 1;

4462

break;

4463

case (int)OPT_REPLICATE_IGNORE_DB:

4464

{

4465

rpl_filter->add_ignore_db(argument);

4466

break;

4467

}

4468

case (int)OPT_REPLICATE_DO_DB:

4469

{

4470

rpl_filter->add_do_db(argument);

4471

break;

4472

}

4473

case (int)OPT_REPLICATE_REWRITE_DB:

4474

{

4475

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

4476

4477

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

4478

{

4479

fprintf(stderr,

4480

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

4481

exit(1);

4482

}

4483

val= p--;

4484

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

4485

*p-- = 0;

4486

if (p == argument)

4487

{

4488

fprintf(stderr,

4489

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

4490

exit(1);

4491

}

4492

*val= 0;

4493

val+= 2;

4494

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

4495

*val++;

4496

if (!*val)

4497

{

4498

fprintf(stderr,

4499

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

4500

exit(1);

4501

}

4502

4503

rpl_filter->add_db_rewrite(key, val);

4504

break;

4505

}

4506

4507

case (int)OPT_BINLOG_IGNORE_DB:

4508

{

4509

binlog_filter->add_ignore_db(argument);

4510

break;

4511

}

4512

case OPT_BINLOG_FORMAT:

4513

{

4514

int id;

4515

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

4516

global_system_variables.binlog_format= opt_binlog_format_id= id - 1;

4517

break;

4518

}

4519

case (int)OPT_BINLOG_DO_DB:

4520

{

4521

binlog_filter->add_do_db(argument);

4522

break;

4523

}

4524

case (int)OPT_REPLICATE_DO_TABLE:

4525

{

4526

if (rpl_filter->add_do_table(argument))

4527

{

4528

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

4529

exit(1);

4530

}

4531

break;

4532

}

4533

case (int)OPT_REPLICATE_WILD_DO_TABLE:

4534

{

4535

if (rpl_filter->add_wild_do_table(argument))

4536

{

4537

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

4538

exit(1);

4539

}

4540

break;

4541

}

4542

case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:

4543

{

4544

if (rpl_filter->add_wild_ignore_table(argument))

4545

{

4546

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

4547

exit(1);

4548

}

4549

break;

4550

}

4551

case (int)OPT_REPLICATE_IGNORE_TABLE:

4552

{

4553

if (rpl_filter->add_ignore_table(argument))

4554

{

4555

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

4556

exit(1);

4557

}

4558

break;

4559

}

4560

case (int) OPT_SLOW_QUERY_LOG:

4561

opt_slow_log= 1;

4562

break;

4563

#ifdef WITH_CSV_STORAGE_ENGINE

4564

case OPT_LOG_OUTPUT:

4565

{

4566

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

4567

{

4568

log_output_options= LOG_FILE;

4569

log_output_str= log_output_typelib.type_names[1];

4570

}

4571

else

4572

{

4573

log_output_str= argument;

4574

log_output_options=

4575

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

4576

}

4577

break;

4578

}

4579

#endif

4580

case (int) OPT_SKIP_NEW:

4581

opt_specialflag|= SPECIAL_NO_NEW_FUNC;

4582

delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;

4583

myisam_concurrent_insert=0;

4584

myisam_recover_options= HA_RECOVER_NONE;

4585

my_use_symdir=0;

4586

ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);

4587

break;

4588

case (int) OPT_SAFE:

4589

opt_specialflag|= SPECIAL_SAFE_MODE;

4590

delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;

4591

myisam_recover_options= HA_RECOVER_DEFAULT;

4592

ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);

4593

break;

4594

case (int) OPT_SKIP_PRIOR:

4595

opt_specialflag|= SPECIAL_NO_PRIOR;

4596

break;

4597

case (int) OPT_SKIP_SHOW_DB:

4598

opt_skip_show_db=1;

4599

opt_specialflag|=SPECIAL_SKIP_SHOW_DB;

4600

break;

4601

case (int) OPT_WANT_CORE:

4602

test_flags |= TEST_CORE_ON_SIGNAL;

4603

break;

4604

case (int) OPT_SKIP_STACK_TRACE:

4605

test_flags|=TEST_NO_STACKTRACE;

4606

break;

4607

case (int) OPT_SKIP_SYMLINKS:

4608

my_use_symdir=0;

4609

break;

4610

case (int) OPT_BIND_ADDRESS:

4611

{

4612

struct addrinfo *res_lst, hints;

4613

4614

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

4615

hints.ai_socktype= SOCK_STREAM;

4616

hints.ai_protocol= IPPROTO_TCP;

4617

4618

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

4619

{

4620

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

4621

exit(1);

4622

}

4623

4624

if (res_lst->ai_next)

4625

{

4626

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

4627

exit(1);

4628

}

4629

freeaddrinfo(res_lst);

4630

}

4631

break;

4632

case (int) OPT_PID_FILE:

4633

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

4634

break;

4635

case OPT_CONSOLE:

4636

if (opt_console)

4637

opt_error_log= 0; // Force logs to stdout

4638

break;

4639

case OPT_LOW_PRIORITY_UPDATES:

4640

thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;

4641

global_system_variables.low_priority_updates=1;

4642

break;

4643

case OPT_BOOTSTRAP:

4644

opt_noacl=opt_bootstrap=1;

4645

break;

4646

case OPT_SERVER_ID:

4647

server_id_supplied = 1;

4648

break;

4649

case OPT_DELAY_KEY_WRITE_ALL:

4650

if (argument != disabled_my_option)

4651

argument= (char*) "ALL";

4652

/* Fall through */

4653

case OPT_DELAY_KEY_WRITE:

4654

if (argument == disabled_my_option)

4655

delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;

4656

else if (! argument)

4657

delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;

4658

else

4659

{

4660

int type;

4661

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

4662

delay_key_write_options= (uint) type-1;

4663

}

4664

break;

4665

case OPT_CHARSETS_DIR:

4666

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

4667

charsets_dir = mysql_charsets_dir;

4668

break;

4669

case OPT_TX_ISOLATION:

4670

{

4671

int type;

4672

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

4673

global_system_variables.tx_isolation= (type-1);

4674

break;

4675

}

4676

case OPT_MYISAM_RECOVER:

4677

{

4678

if (!argument)

4679

{

4680

myisam_recover_options= HA_RECOVER_DEFAULT;

4681

myisam_recover_options_str= myisam_recover_typelib.type_names[0];

4682

}

4683

else if (!argument[0])

4684

{

4685

myisam_recover_options= HA_RECOVER_NONE;

4686

myisam_recover_options_str= "OFF";

4687

}

4688

else

4689

{

4690

myisam_recover_options_str=argument;

4691

myisam_recover_options=

4692

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

4693

}

4694

ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;

4695

break;

4696

}

4697

case OPT_TC_HEURISTIC_RECOVER:

4698

tc_heuristic_recover= find_type_or_exit(argument,

4699

&tc_heuristic_recover_typelib,

4700

opt->name);

4701

break;

4702

case OPT_MYISAM_STATS_METHOD:

4703

{

4704

ulong method_conv;

4705

int method;

4706

4707

myisam_stats_method_str= argument;

4708

method= find_type_or_exit(argument, &myisam_stats_method_typelib,

4709

opt->name);

4710

switch (method-1) {

4711

case 2:

4712

method_conv= MI_STATS_METHOD_IGNORE_NULLS;

4713

break;

4714

case 1:

4715

method_conv= MI_STATS_METHOD_NULLS_EQUAL;

4716

break;

4717

case 0:

4718

default:

4719

method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;

4720

break;

4721

}

4722

global_system_variables.myisam_stats_method= method_conv;

4723

break;

4724

}

4725

case OPT_LOWER_CASE_TABLE_NAMES:

4726

lower_case_table_names= argument ? atoi(argument) : 1;

4727

lower_case_table_names_used= 1;

4728

break;

4729

}

4730

return 0;

4731

}

4732

4733

4734

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

4735

4736

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

4737

const struct my_option *option);

4738

4739

char**

4740

mysql_getopt_value(const char *keyname, uint key_length,

4741

const struct my_option *option)

4742

{

4743

switch (option->id) {

4744

case OPT_KEY_BUFFER_SIZE:

4745

case OPT_KEY_CACHE_BLOCK_SIZE:

4746

case OPT_KEY_CACHE_DIVISION_LIMIT:

4747

case OPT_KEY_CACHE_AGE_THRESHOLD:

4748

{

4749

KEY_CACHE *key_cache;

4750

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

4751

exit(1);

4752

switch (option->id) {

4753

case OPT_KEY_BUFFER_SIZE:

4754

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

4755

case OPT_KEY_CACHE_BLOCK_SIZE:

4756

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

4757

case OPT_KEY_CACHE_DIVISION_LIMIT:

4758

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

4759

case OPT_KEY_CACHE_AGE_THRESHOLD:

4760

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

4761

}

4762

}

4763

}

4764

return (char **)option->value;

4765

}

4766

4767

4768

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

4769

4770

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

4771

{

4772

va_list args;

4773

va_start(args, format);

4774

4775

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

4776

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

4777

global_system_variables.log_warnings)

4778

{

4779

vprint_msg_to_log(level, format, args);

4780

}

4781

va_end(args);

4782

}

4783

4784

4785

/**

4786

@todo

4787

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

4788

4789

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

4790

{

4791

int ho_error;

4792

4793

my_getopt_register_get_addr(mysql_getopt_value);

4794

my_getopt_error_reporter= option_error_reporter;

2249

4795

2250

4796

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

2251

4797

my_getopt_skip_unknown= true;

2252

4798

4799

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

4800

mysqld_get_one_option)))

4801

exit(ho_error);

4802

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

4803

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

4804

4805

if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes ||

4806

opt_log_slow_slave_statements) &&

4807

!opt_slow_log)

4808

sql_print_warning("options --log-slow-admin-statements, --log-queries-not-using-indexes and --log-slow-slave-statements have no effect if --log-slow-queries is not set");

2253

4809

2254

4810

#if defined(HAVE_BROKEN_REALPATH)

2255

internal::my_use_symdir=0;

2256

internal::my_disable_symlinks=1;

4811

my_use_symdir=0;

4812

my_disable_symlinks=1;

2257

4813

have_symlink=SHOW_OPTION_NO;

2258

4814

#else

2259

if (!internal::my_use_symdir)

4815

if (!my_use_symdir)

2260

4816

{

2261

internal::my_disable_symlinks=1;

4817

my_disable_symlinks=1;

2262

4818

have_symlink=SHOW_OPTION_DISABLED;

2263

4819

}

2264

4820

#endif

2265

4821

if (opt_debugging)

2266

4822

{

2267

4823

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

2268

getDebug().set(debug::ALLOW_SIGINT);

2269

getDebug().set(debug::NO_STACKTRACE);

2270

getDebug().reset(debug::CORE_ON_SIGNAL);

4824

test_flags|= TEST_SIGINT | TEST_NO_STACKTRACE;

4825

test_flags&= ~TEST_CORE_ON_SIGNAL;

2271

4826

}

4827

/* Set global MyISAM variables from delay_key_write_options */

4828

fix_delay_key_write((THD*) 0, OPT_GLOBAL);

4829

/* Set global slave_exec_mode from its option */

4830

fix_slave_exec_mode(OPT_GLOBAL);

2272

4831

2273

if (drizzled_chroot)

2274

set_root(drizzled_chroot);

4832

if (mysqld_chroot)

4833

set_root(mysqld_chroot);

4834

fix_paths();

2275

4835

2276

4836

2277

4837

Set some global variables from the global_system_variables

2278

4838

In most cases the global variables will not be used

2279

4839

2280

internal::my_default_record_cache_size=global_system_variables.read_buff_size;

2281

}

2282

2283

2284

static void fix_paths()

2285

{

2286

fs::path pid_file_path(pid_file);

2287

if (pid_file_path.root_path().string() == "")

2288

{

2289

pid_file_path= getDataHome();

2290

pid_file_path /= pid_file;

2291

}

2292

pid_file= fs::system_complete(pid_file_path);

2293

2294

if (not opt_help)

2295

{

2296

const char *tmp_string= getenv("TMPDIR") ? getenv("TMPDIR") : NULL;

2297

struct stat buf;

2298

drizzle_tmpdir.clear();

2299

2300

if (vm.count("tmpdir"))

2301

{

2302

drizzle_tmpdir.append(vm["tmpdir"].as<string>());

2303

}

2304

else if (tmp_string == NULL)

2305

{

2306

drizzle_tmpdir.append(getDataHome().file_string());

2307

drizzle_tmpdir.push_back(FN_LIBCHAR);

2308

drizzle_tmpdir.append(GLOBAL_TEMPORARY_EXT);

2309

}

4840

my_default_record_cache_size=global_system_variables.read_buff_size;

4841

myisam_max_temp_length=

4842

(my_off_t) global_system_variables.myisam_max_sort_file_size;

4843

4844

/* Set global variables based on startup options */

4845

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

4846

4847

/* long_query_time is in microseconds */

4848

global_system_variables.long_query_time= max_system_variables.long_query_time=

4849

(int64_t) (long_query_time * 1000000.0);

4850

4851

if (opt_short_log_format)

4852

opt_specialflag|= SPECIAL_SHORT_LOG_FORMAT;

4853

4854

if (init_global_datetime_format(MYSQL_TIMESTAMP_DATE,

4855

&global_system_variables.date_format) ||

4856

init_global_datetime_format(MYSQL_TIMESTAMP_TIME,

4857

&global_system_variables.time_format) ||

4858

init_global_datetime_format(MYSQL_TIMESTAMP_DATETIME,

4859

&global_system_variables.datetime_format))

4860

exit(1);

4861

4862

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

4863

}

4864

4865

4866

4867

Create version name for running mysqld version

4868

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

4869

name to make the version more descriptive.

4870

(MYSQL_SERVER_SUFFIX is set by the compilation environment)

4871

4872

4873

static void set_server_version(void)

4874

{

4875

char *end= strxmov(server_version, MYSQL_SERVER_VERSION,

4876

MYSQL_SERVER_SUFFIX_STR, NullS);

4877

if (opt_log || opt_slow_log || opt_bin_log)

4878

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

4879

}

4880

4881

4882

static char *get_relative_path(const char *path)

4883

{

4884

if (test_if_hard_path(path) &&

4885

is_prefix(path,DEFAULT_MYSQL_HOME) &&

4886

strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))

4887

{

4888

path+=(uint) strlen(DEFAULT_MYSQL_HOME);

4889

while (*path == FN_LIBCHAR)

4890

path++;

4891

}

4892

return (char*) path;

4893

}

4894

4895

4896

/**

4897

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

4898

mysql_real_data_home.

4899

@return

4900

1 if len(path) > FN_REFLEN

4901

4902

4903

bool

4904

fn_format_relative_to_data_home(char * to, const char *name,

4905

const char *dir, const char *extension)

4906

{

4907

char tmp_path[FN_REFLEN];

4908

if (!test_if_hard_path(dir))

4909

{

4910

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

4911

dir, NullS);

4912

dir=tmp_path;

4913

}

4914

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

4915

MY_APPEND_EXT | MY_UNPACK_FILENAME | MY_SAFE_PATH);

4916

}

4917

4918

4919

static void fix_paths(void)

4920

{

4921

char buff[FN_REFLEN],*pos;

4922

convert_dirname(mysql_home,mysql_home,NullS);

4923

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

4924

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

4925

/* Ensure that mysql_home ends in FN_LIBCHAR */

4926

pos=strend(mysql_home);

4927

if (pos[-1] != FN_LIBCHAR)

4928

{

4929

pos[0]= FN_LIBCHAR;

4930

pos[1]= 0;

4931

}

4932

convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);

4933

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

4934

(MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));

4935

(void) unpack_dirname(mysql_unpacked_real_data_home, buff);

4936

convert_dirname(language,language,NullS);

4937

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

4938

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

4939

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

4940

(void) my_load_path(opt_plugin_dir, opt_plugin_dir_ptr ? opt_plugin_dir_ptr :

4941

get_relative_path(PLUGINDIR), mysql_home);

4942

opt_plugin_dir_ptr= opt_plugin_dir;

4943

4944

char *sharedir=get_relative_path(SHAREDIR);

4945

if (test_if_hard_path(sharedir))

4946

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

4947

else

4948

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

4949

convert_dirname(buff,buff,NullS);

4950

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

4951

4952

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

4953

if (charsets_dir != mysql_charsets_dir)

4954

{

4955

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

4956

CHARSET_DIR, NullS);

4957

}

4958

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

4959

convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NullS);

4960

charsets_dir=mysql_charsets_dir;

4961

4962

if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))

4963

exit(1);

4964

if (!slave_load_tmpdir)

4965

{

4966

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

4967

exit(1);

4968

}

4969

4970

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

4971

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

4972

4973

if (opt_secure_file_priv)

4974

{

4975

convert_dirname(buff, opt_secure_file_priv, NullS);

4976

my_free(opt_secure_file_priv, MYF(0));

4977

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

4978

}

4979

}

4980

4981

4982

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

4983

const char *option)

4984

{

4985

ulong res;

4986

4987

const char **ptr;

4988

4989

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

4990

{

4991

ptr= bit_lib->type_names;

4992

if (!*x)

4993

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

2310

4994

else

2311

{

2312

drizzle_tmpdir.append(tmp_string);

2313

}

2314

2315

drizzle_tmpdir= fs::path(fs::system_complete(fs::path(drizzle_tmpdir))).file_string();

2316

assert(drizzle_tmpdir.size());

2317

2318

if (mkdir(drizzle_tmpdir.c_str(), 0777) == -1)

2319

{

2320

if (errno != EEXIST)

2321

{

2322

errmsg_printf(error::ERROR, _("There was an error creating the '%s' part of the path '%s'. Please check the path exists and is writable.\n"), fs::path(drizzle_tmpdir).leaf().c_str(), drizzle_tmpdir.c_str());

2323

exit(1);

2324

}

2325

}

2326

2327

if (stat(drizzle_tmpdir.c_str(), &buf) || (S_ISDIR(buf.st_mode) == false))

2328

{

2329

errmsg_printf(error::ERROR, _("There was an error opening the path '%s', please check the path exists and is writable.\n"), drizzle_tmpdir.c_str());

2330

exit(1);

2331

}

2332

}

2333

2334

}

2335

2336

} /* namespace drizzled */

2337

4995

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

4996

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

4997

while (*++ptr)

4998

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

4999

fprintf(stderr, "\n");

5000

exit(1);

5001

}

5002

return res;

5003

}

5004

5005

5006

/**

5007

@return

5008

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

5009

5010

~(ulong) 0 on error.

5011

5012

5013

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

5014

{

5015

bool found_end;

5016

int found_count;

5017

const char *end,*i,*j;

5018

const char **array, *pos;

5019

ulong found,found_int,bit;

5020

5021

found=0;

5022

found_end= 0;

5023

pos=(char *) x;

5024

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

5025

found_end= *pos == 0;

5026

while (!found_end)

5027

{

5028

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

5029

{

5030

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

5031

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

5032

found_end=1;

5033

}

5034

found_int=0; found_count=0;

5035

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

5036

{

5037

j=pos;

5038

while (j != end)

5039

{

5040

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

5041

my_toupper(mysqld_charset,*j++))

5042

goto skip;

5043

}

5044

found_int=bit;

5045

if (! *i)

5046

{

5047

found_count=1;

5048

break;

5049

}

5050

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

5051

{

5052

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

5053

}

5054

skip: ;

5055

}

5056

if (found_count != 1)

5057

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

5058

found|=found_int;

5059

pos=end+1;

5060

}

5061

5062

return(found);

5063

} /* find_bit_type */

5064

5065

5066

/**

5067

Check if file system used for databases is case insensitive.

5068

5069

@param dir_name Directory to test

5070

5071

@retval

5072

-1 Don't know (Test failed)

5073

@retval

5074

0 File system is case sensitive

5075

@retval

5076

1 File system is case insensitive

5077

5078

5079

static int test_if_case_insensitive(const char *dir_name)

5080

{

5081

int result= 0;

5082

File file;

5083

char buff[FN_REFLEN], buff2[FN_REFLEN];

5084

struct stat stat_info;

5085

5086

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

5087

MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);

5088

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

5089

MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);

5090

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

5091

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

5092

{

5093

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

5094

return(-1);

5095

}

5096

my_close(file, MYF(0));

5097

if (!stat(buff2, &stat_info))

5098

result= 1; // Can access file

5099

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

5100

return(result);

5101

}

5102

5103

5104

/**

5105

Create file to store pid number.

5106

5107

static void create_pid_file()

5108

{

5109

File file;

5110

if ((file = my_create(pidfile_name,0664,

5111

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

5112

{

5113

char buff[21], *end;

5114

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

5115

*end++= '\n';

5116

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

5117

{

5118

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

5119

return;

5120

}

5121

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

5122

}

5123

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

5124

exit(1);

5125

}

5126

5127

/** Clear most status variables. */

5128

void refresh_status(THD *thd)

5129

{

5130

pthread_mutex_lock(&LOCK_status);

5131

5132

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

5133

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

5134

5135

/* Reset thread's status variables */

5136

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

5137

5138

/* Reset some global variables */

5139

reset_status_vars();

5140

5141

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

5142

process_key_caches(reset_key_cache_counters);

5143

flush_status_time= time((time_t*) 0);

5144

pthread_mutex_unlock(&LOCK_status);

5145

5146

5147

Set max_used_connections to the number of currently open

5148

connections. Lock LOCK_thread_count out of LOCK_status to avoid

5149

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

5150

not exact anyway.

5151

5152

pthread_mutex_lock(&LOCK_thread_count);

5153

max_used_connections= thread_count;

5154

pthread_mutex_unlock(&LOCK_thread_count);

5155

}

5156

5157

5158

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

5159

Instantiate templates

5160

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

5161

5162

#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

5163

/* Used templates */

5164

template class I_List<THD>;

5165

template class I_List_iterator<THD>;

5166

template class I_List<i_string>;

5167

template class I_List<i_string_pair>;

5168

template class I_List<NAMED_LIST>;

5169

template class I_List<Statement>;

5170

template class I_List_iterator<Statement>;

5171

#endif

Older »