~drizzle-trunk/drizzle/development

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

1232

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

1233

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

1234

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

1235

("version,V",

1236

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

1237

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

1238

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

1239

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

1240

"requests in a very short time."))

1241

("bulk-insert-buffer-size",

1242

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

1243

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

1244

"a limit per thread!"))

1245

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

1246

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

1247

"value."))

1248

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

1249

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

1250

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

1251

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

1252

("join-heap-threshold",

1253

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

1254

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

1255

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

1256

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

1257

("max-connect-errors", po::value<uint64_t>(&max_connect_errors)->default_value(MAX_CONNECT_ERRORS)->notifier(&check_limits_mce),

1258

N_("If there is more than this number of interrupted connections from a "

1259

"host this host will be blocked from further connections."))

1260

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

1261

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

1262

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

1263

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

1264

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

1265

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

1266

"return an error."))

1267

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

1268

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

1269

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

1270

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

1271

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

1272

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

1273

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

1274

"rest are ignored)."))

1275

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

1276

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

1277

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

1278

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

1279

"rows to file."))

1280

("disable-optimizer-prune",

1281

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

1282

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

1283

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

1284

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

1285

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

1286

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

1287

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

1288

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

1289

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

1290

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

1291

"testing/comparison)."))

1292

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

1293

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

1294

("query-alloc-block-size",

1295

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

1296

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

1297

("query-prealloc-size",

1298

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

1299

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

1300

("range-alloc-block-size",

1301

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

1302

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

1303

("read-buffer-size",

1304

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

1305

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

1306

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

1307

"want to increase this value."))

1308

("read-buffer-threshold",

1309

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

1310

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

1311

("read-rnd-buffer-size",

1312

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

1313

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

1314

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

1315

"to the value of record_buffer."))

1316

("read-rnd-threshold",

1317

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

1318

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

1319

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

1320

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

1321

("sort-buffer-size",

1322

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

1323

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

1324

("sort-heap-threshold",

1325

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

1326

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

1327

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

1328

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

1329

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

1330

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

1331

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

1332

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

1333

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

1334

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

1335

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

1336

("tmp-table-size",

1337

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

1338

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

1339

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

1340

;

1341

1342

full_options.add(long_options);

1343

full_options.add(plugin_load_options);

1344

1345

initial_options.add(config_options);

1346

initial_options.add(plugin_load_options);

1347

1348

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

1349

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

1350

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

1351

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

1352

unknown_options=

1353

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

1354

1355

try

1356

{

1357

po::store(parsed, vm);

1358

}

1359

catch (std::exception&)

1360

{

1361

errmsg_printf(ERRMSG_LVL_ERROR, _("Duplicate entry for command line option\n"));

1362

unireg_abort(1);

1363

}

1364

1365

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

1366

{

1367

fs::path system_config_file_drizzle(system_config_dir);

1368

system_config_file_drizzle /= "drizzled.cnf";

1369

defaults_file_list.insert(defaults_file_list.begin(),

1370

system_config_file_drizzle.file_string());

1371

1372

fs::path config_conf_d_location(system_config_dir);

1373

config_conf_d_location /= "conf.d";

1374

1375

1376

CachedDirectory config_conf_d(config_conf_d_location.file_string());

1377

if (not config_conf_d.fail())

2048

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

2049

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

2050

2051

2052

Add server status variables to the dynamic list of

2053

status variables that is shown by SHOW STATUS.

2054

Later, in plugin_init, and mysql_install_plugin

2055

new entries could be added to that list.

2056

2057

if (add_status_vars(status_vars))

2058

return 1; // an error was already reported

2059

2060

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

2061

defaults_argv=argv;

2062

defaults_argc=argc;

2063

get_options(&defaults_argc, defaults_argv);

2064

set_server_version();

2065

2066

2067

/* connections and databases needs lots of files */

2068

{

2069

uint files, wanted_files, max_open_files;

2070

2071

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

2072

wanted_files= 10+max_connections+table_cache_size*2;

2073

2074

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

2075

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

2076

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

2077

was already allocated. However below we report a warning and

2078

recompute values only if we got less file handles than were

2079

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

2080

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

2081

requested (value of wanted_files).

2082

2083

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

2084

open_files_limit);

2085

files= my_set_max_open_files(max_open_files);

2086

2087

if (files < wanted_files)

1378

2088

{

1379

1380

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

1381

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

1382

++iter)

2089

if (!open_files_limit)

1383

2090

{

1384

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

1385

1386

if (not file_entry.empty()

1387

&& file_entry != "."

1388

&& file_entry != "..")

1389

{

1390

fs::path the_entry(config_conf_d_location);

1391

the_entry /= file_entry;

1392

defaults_file_list.push_back(the_entry.file_string());

1393

}

2091

2092

If we have requested too much file handles than we bring

2093

max_connections in supported bounds.

2094

2095

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

2096

max_connections);

2097

2098

Decrease table_cache_size according to max_connections, but

2099

not below TABLE_OPEN_CACHE_MIN. Outer min() ensures that we

2100

never increase table_cache_size automatically (that could

2101

happen if max_connections is decreased above).

2102

2103

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

2104

TABLE_OPEN_CACHE_MIN),

2105

table_cache_size);

2106

if (global_system_variables.log_warnings)

2107

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

2108

files, max_connections, table_cache_size);

1394

2109

}

1395

}

1396

}

1397

1398

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

1399

1400

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

1401

try

1402

{

1403

po::notify(vm);

1404

}

1405

catch (po::validation_error &err)

1406

{

1407

errmsg_printf(ERRMSG_LVL_ERROR,

1408

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

1409

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

1410

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

1411

unireg_abort(1);

1412

}

1413

1414

process_defaults_files();

1415

1416

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

1417

plugin loader options */

1418

1419

try

1420

{

1421

po::notify(vm);

1422

}

1423

catch (po::validation_error &err)

1424

{

1425

errmsg_printf(ERRMSG_LVL_ERROR,

1426

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

1427

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

1428

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

1429

unireg_abort(1);

1430

}

1431

1432

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

1433

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

1434

1435

1436

if (plugin_init(plugins, plugin_options))

1437

{

1438

errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to initialize plugins\n"));

1439

unireg_abort(1);

1440

}

1441

1442

full_options.add(plugin_options);

1443

1444

vector<string> final_unknown_options;

1445

try

1446

{

1447

po::parsed_options final_parsed=

1448

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

1449

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

1450

1451

final_unknown_options=

1452

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

1453

1454

po::store(final_parsed, vm);

1455

1456

}

1457

catch (po::validation_error &err)

1458

{

1459

errmsg_printf(ERRMSG_LVL_ERROR,

1460

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

1461

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

1462

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

1463

unireg_abort(1);

1464

}

1465

catch (po::invalid_command_line_syntax &err)

1466

{

1467

errmsg_printf(ERRMSG_LVL_ERROR,

1468

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

1469

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

1470

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

1471

unireg_abort(1);

1472

}

1473

catch (po::unknown_option &err)

1474

{

1475

errmsg_printf(ERRMSG_LVL_ERROR,

1476

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

1477

err.what());

1478

unireg_abort(1);

1479

}

1480

1481

try

1482

{

1483

po::notify(vm);

1484

}

1485

catch (po::validation_error &err)

1486

{

1487

errmsg_printf(ERRMSG_LVL_ERROR,

1488

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

1489

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

1490

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

1491

unireg_abort(1);

1492

}

1493

1494

get_options();

1495

1496

/* Inverted Booleans */

1497

1498

global_system_variables.optimizer_prune_level=

1499

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

1500

1501

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

1502

{

1503

if ((user_info= check_user(drizzled_user)))

1504

{

1505

set_user(drizzled_user, user_info);

1506

}

1507

}

1508

1509

fix_paths();

1510

1511

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

1512

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

1513

2110

else if (global_system_variables.log_warnings)

2111

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

2112

}

2113

open_files_limit= files;

2114

}

2115

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

2116

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

2117

return 1;

2118

init_client_errs();

2119

lex_init();

1514

2120

if (item_create_init())

1515

2121

return 1;

1516

if (sys_var_init())

1517

return 1;

1518

/* Creates static regex matching for temporal values */

1519

if (! init_temporal_formats())

1520

return 1;

1521

1522

if (!(default_charset_info=

1523

get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

2122

item_init();

2123

if (set_var_init())

2124

return 1;

2125

if (init_replication_sys_vars())

2126

return 1;

2127

mysys_uses_curses=0;

2128

2129

Process a comma-separated character set list and choose

2130

the first available character set. This is mostly for

2131

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

2132

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

2133

2134

for (;;)

1524

2135

{

1525

errmsg_printf(ERRMSG_LVL_ERROR, _("Error getting default charset"));

1526

return 1; // Eof of the list

2136

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

2137

if (next_character_set_name)

2138

*next_character_set_name++= '\0';

2139

if (!(default_charset_info=

2140

get_charset_by_csname(default_character_set_name,

2141

MY_CS_PRIMARY, MYF(MY_WME))))

2142

{

2143

if (next_character_set_name)

2144

{

2145

default_character_set_name= next_character_set_name;

2146

default_collation_name= 0; // Ignore collation

2147

}

2148

else

2149

return 1; // Eof of the list

2150

}

2151

else

2152

break;

1527

2153

}

1528

2154

1529

if (vm.count("scheduler"))

1530

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

1531

1532

2155

if (default_collation_name)

1533

2156

{

1534

const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);

1535

if (not default_collation)

2157

CHARSET_INFO *default_collation;

2158

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

2159

if (!default_collation)

1536

2160

{

1537

errmsg_printf(ERRMSG_LVL_ERROR, _(ER(ER_UNKNOWN_COLLATION)), default_collation_name);

2161

sql_print_error(ER(ER_UNKNOWN_COLLATION), default_collation_name);

1538

2162

return 1;

1539

2163

}

1540

if (not my_charset_same(default_charset_info, default_collation))

2164

if (!my_charset_same(default_charset_info, default_collation))

1541

2165

{

1542

errmsg_printf(ERRMSG_LVL_ERROR, _(ER(ER_COLLATION_CHARSET_MISMATCH)),

1543

default_collation_name,

1544

default_charset_info->csname);

2166

sql_print_error(ER(ER_COLLATION_CHARSET_MISMATCH),

2167

default_collation_name,

2168

default_charset_info->csname);

1545

2169

return 1;

1546

2170

}

1547

2171

default_charset_info= default_collation;

1548

2172

}

1549

2173

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

1550

2174

global_system_variables.collation_server= default_charset_info;

1551

1552

if (not (character_set_filesystem=

1553

get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))

1554

{

1555

errmsg_printf(ERRMSG_LVL_ERROR, _("Error setting collation"));

2175

global_system_variables.collation_database= default_charset_info;

2176

global_system_variables.collation_connection= default_charset_info;

2177

global_system_variables.character_set_results= default_charset_info;

2178

global_system_variables.character_set_client= default_charset_info;

2179

2180

global_system_variables.optimizer_use_mrr= 1;

2181

global_system_variables.optimizer_switch= 0;

2182

2183

if (!(character_set_filesystem=

2184

get_charset_by_csname(character_set_filesystem_name,

2185

MY_CS_PRIMARY, MYF(MY_WME))))

1556

2186

return 1;

1557

}

1558

2187

global_system_variables.character_set_filesystem= character_set_filesystem;

1559

2188

1560

2189

if (!(my_default_lc_time_names=

1561

2190

my_locale_by_name(lc_time_names_name)))

1562

2191

{

1563

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

2192

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

1564

2193

return 1;

1565

2194

}

1566

2195

global_system_variables.lc_time_names= my_default_lc_time_names;

1567

1568

/* Reset table_alias_charset */

1569

table_alias_charset= files_charset_info;

1570

1571

return 0;

1572

}

1573

1574

1575

int init_server_components(module::Registry &plugins)

2196

2197

sys_init_connect.value_length= 0;

2198

if ((sys_init_connect.value= opt_init_connect))

2199

sys_init_connect.value_length= strlen(opt_init_connect);

2200

else

2201

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

2202

2203

sys_init_slave.value_length= 0;

2204

if ((sys_init_slave.value= opt_init_slave))

2205

sys_init_slave.value_length= strlen(opt_init_slave);

2206

else

2207

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

2208

2209

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

2210

if (opt_log && opt_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 option, log tables are used. "

2214

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

2215

2216

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

2217

&& !(log_output_options & LOG_NONE))

2218

sql_print_warning("Although a path was specified for the "

2219

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

2220

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

2221

2222

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

2223

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

2224

sys_var_general_log_path.value_length= strlen(s);

2225

2226

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

2227

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

2228

sys_var_slow_log_path.value_length= strlen(s);

2229

2230

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

2231

return 1;

2232

if (my_database_names_init())

2233

return 1;

2234

2235

2236

Ensure that lower_case_table_names is set on system where we have case

2237

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

2238

get corrupted if accesses with names of different case.

2239

2240

lower_case_file_system= test_if_case_insensitive(mysql_real_data_home);

2241

if (!lower_case_table_names && lower_case_file_system == 1)

2242

{

2243

if (lower_case_table_names_used)

2244

{

2245

if (global_system_variables.log_warnings)

2246

sql_print_warning("\

2247

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

2248

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

2249

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

2250

You should consider changing lower_case_table_names to 1 or 2",

2251

mysql_real_data_home);

2252

}

2253

else

2254

{

2255

if (global_system_variables.log_warnings)

2256

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

2257

lower_case_table_names= 2;

2258

}

2259

}

2260

else if (lower_case_table_names == 2 &&

2261

!(lower_case_file_system=

2262

(test_if_case_insensitive(mysql_real_data_home) == 1)))

2263

{

2264

if (global_system_variables.log_warnings)

2265

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

2266

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

2267

"lower_case_table_names to 0 to avoid future problems.",

2268

mysql_real_data_home);

2269

lower_case_table_names= 0;

2270

}

2271

else

2272

{

2273

lower_case_file_system=

2274

(test_if_case_insensitive(mysql_real_data_home) == 1);

2275

}

2276

2277

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

2278

table_alias_charset= (lower_case_table_names ?

2279

files_charset_info :

2280

&my_charset_bin);

2281

2282

return 0;

2283

}

2284

2285

2286

static int init_thread_environment()

2287

{

2288

(void) pthread_mutex_init(&LOCK_mysql_create_db,MY_MUTEX_INIT_SLOW);

2289

(void) pthread_mutex_init(&LOCK_lock_db,MY_MUTEX_INIT_SLOW);

2290

(void) pthread_mutex_init(&LOCK_open, NULL);

2291

(void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);

2292

(void) pthread_mutex_init(&LOCK_mapped_file,MY_MUTEX_INIT_SLOW);

2293

(void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);

2294

(void) pthread_mutex_init(&LOCK_error_log,MY_MUTEX_INIT_FAST);

2295

(void) pthread_mutex_init(&LOCK_manager,MY_MUTEX_INIT_FAST);

2296

(void) pthread_mutex_init(&LOCK_crypt,MY_MUTEX_INIT_FAST);

2297

(void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);

2298

(void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);

2299

(void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);

2300

(void) my_rwlock_init(&LOCK_system_variables_hash, NULL);

2301

(void) pthread_mutex_init(&LOCK_global_read_lock, MY_MUTEX_INIT_FAST);

2302

(void) pthread_mutex_init(&LOCK_uuid_generator, MY_MUTEX_INIT_FAST);

2303

(void) pthread_mutex_init(&LOCK_connection_count, MY_MUTEX_INIT_FAST);

2304

(void) my_rwlock_init(&LOCK_sys_init_connect, NULL);

2305

(void) my_rwlock_init(&LOCK_sys_init_slave, NULL);

2306

(void) pthread_cond_init(&COND_thread_count,NULL);

2307

(void) pthread_cond_init(&COND_refresh,NULL);

2308

(void) pthread_cond_init(&COND_global_read_lock,NULL);

2309

(void) pthread_cond_init(&COND_thread_cache,NULL);

2310

(void) pthread_cond_init(&COND_flush_thread_cache,NULL);

2311

(void) pthread_cond_init(&COND_manager,NULL);

2312

(void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);

2313

(void) pthread_cond_init(&COND_rpl_status, NULL);

2314

2315

/* Parameter for threads created for connections */

2316

(void) pthread_attr_init(&connection_attrib);

2317

(void) pthread_attr_setdetachstate(&connection_attrib,

2318

PTHREAD_CREATE_DETACHED);

2319

pthread_attr_setscope(&connection_attrib, PTHREAD_SCOPE_SYSTEM);

2320

if (!(opt_specialflag & SPECIAL_NO_PRIOR))

2321

{

2322

struct sched_param tmp_sched_param;

2323

2324

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

2325

tmp_sched_param.sched_priority= WAIT_PRIOR;

2326

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

2327

}

2328

2329

if (pthread_key_create(&THR_THD,NULL) ||

2330

pthread_key_create(&THR_MALLOC,NULL))

2331

{

2332

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

2333

return 1;

2334

}

2335

return 0;

2336

}

2337

2338

2339

static int init_server_components()

1576

2340

{

1577

2341

1578

2342

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

1579

2343

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

1580

2344

1581

if (table_cache_init())

1582

{

1583

errmsg_printf(ERRMSG_LVL_ERROR, _("Could not initialize table cache\n"));

2345

if (table_cache_init() | table_def_init())

1584

2346

unireg_abort(1);

1585

}

1586

1587

// Resize the definition Cache at startup

1588

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

1589

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

1590

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

1591

2347

2348

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

1592

2349

setup_fpu();

2350

init_thr_lock();

2351

init_slave_list();

1593

2352

1594

2353

/* Setup logs */

1595

2354

2355

2356

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

2357

help information. Since the implementation of plugin server

2358

variables the help output is now written much later.

2359

2360

if (opt_error_log && !opt_help)

2361

{

2362

if (!log_error_file_ptr[0])

2363

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

2364

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

2365

else

2366

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

2367

MY_UNPACK_FILENAME | MY_SAFE_PATH);

2368

if (!log_error_file[0])

2369

opt_error_log= 1; // Too long file name

2370

else

2371

{

2372

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

2373

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

2374

}

2375

}

2376

1596

2377

if (xid_cache_init())

1597

2378

{

1598

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

1599

unireg_abort(1);

1600

}

2379

sql_print_error("Out of memory");

2380

unireg_abort(1);

2381

}

2382

2383

if (!opt_bin_log)

2384

if (opt_binlog_format_id != BINLOG_FORMAT_UNSPEC)

2385

{

2386

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

2387

"--binlog-format work.");

2388

unireg_abort(1);

2389

}

2390

else

2391

{

2392

global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;

2393

}

2394

else

2395

if (opt_binlog_format_id == BINLOG_FORMAT_UNSPEC)

2396

global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;

2397

else

2398

{

2399

assert(global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC);

2400

}

2401

2402

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

2403

assert((uint)global_system_variables.binlog_format <=

2404

array_elements(binlog_format_names)-1);

2405

2406

if (opt_log_slave_updates && replicate_same_server_id)

2407

{

2408

sql_print_error("\

2409

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

2410

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

2411

server.");

2412

unireg_abort(1);

2413

}

2414

2415

if (opt_bin_log)

2416

{

2417

char buf[FN_REFLEN];

2418

const char *ln;

2419

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

2420

if (!opt_bin_logname && !opt_binlog_index_name)

2421

{

2422

2423

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

2424

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

2425

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

2426

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

2427

only give warning, not error.

2428

2429

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

2430

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

2431

"may break when this MySQL server acts as a "

2432

"master and has his hostname changed!! Please "

2433

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

2434

}

2435

if (ln == buf)

2436

{

2437

my_free(opt_bin_logname, MYF(MY_ALLOW_ZERO_PTR));

2438

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

2439

}

2440

if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln))

2441

{

2442

unireg_abort(1);

2443

}

2444

2445

2446

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

2447

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

2448

2449

using_update_log=1;

2450

}

2451

2452

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

2453

process_key_caches(&ha_init_key_cache);

1601

2454

1602

2455

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

1603

ha_init_errors();

2456

if (ha_init_errors())

2457

return(1);

1604

2458

2459

if (plugin_init(&defaults_argc, defaults_argv,

2460

(opt_noacl ? PLUGIN_INIT_SKIP_PLUGIN_TABLE : 0) |

2461

(opt_help ? PLUGIN_INIT_SKIP_INITIALIZATION : 0)))

2462

{

2463

sql_print_error("Failed to initialize plugins.");

2464

unireg_abort(1);

2465

}

1605

2466

1606

2467

if (opt_help)

1607

2468

unireg_abort(0);

1608

2469

1609

if (plugin_finalize(plugins))

1610

{

1611

unireg_abort(1);

1612

}

1613

1614

string scheduler_name;

1615

if (opt_scheduler)

1616

{

1617

scheduler_name= opt_scheduler;

1618

}

1619

else

1620

{

1621

scheduler_name= opt_scheduler_default;

1622

opt_scheduler= opt_scheduler_default;

1623

}

1624

1625

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

1626

{

1627

errmsg_printf(ERRMSG_LVL_ERROR,

1628

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

2470

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

2471

if (defaults_argc > 1)

2472

{

2473

int ho_error;

2474

char **tmp_argv= defaults_argv;

2475

struct my_option no_opts[]=

2476

{

2477

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

2478

};

2479

2480

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

2481

that there are unprocessed options.

2482

But we need to preserve defaults_argv pointer intact for

2483

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

2484

2485

my_getopt_skip_unknown= 0;

2486

2487

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

2488

mysqld_get_one_option)))

2489

unireg_abort(ho_error);

2490

2491

if (defaults_argc)

2492

{

2493

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

2494

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

2495

my_progname, *tmp_argv);

1629

2496

unireg_abort(1);

1630

}

1631

1632

1633

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

1634

"memory" engine which will be configurable longterm.

1635

1636

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

1637

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

1638

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

1639

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

2497

}

2498

}

2499

2500

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

2501

if (!errmesg[0][0])

2502

unireg_abort(1);

2503

2504

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

2505

if (ha_init())

2506

{

2507

sql_print_error("Can't init databases");

2508

unireg_abort(1);

2509

}

2510

2511

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

2512

opt_log ? LOG_FILE:LOG_NONE);

1640

2513

1641

2514

1642

2515

Check that the default storage engine is actually available.

1643

2516

1644

2517

if (default_storage_engine_str)

1645

2518

{

1646

const std::string name(default_storage_engine_str);

1647

plugin::StorageEngine *engine;

1648

1649

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

1650

if (engine == NULL)

1651

{

1652

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

1653

default_storage_engine_str);

1654

unireg_abort(1);

1655

}

1656

global_system_variables.storage_engine= engine;

1657

}

1658

1659

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

1660

{

1661

/* This function alredy generates error messages */

1662

unireg_abort(1);

1663

}

2519

LEX_STRING name= { default_storage_engine_str,

2520

strlen(default_storage_engine_str) };

2521

plugin_ref plugin;

2522

handlerton *hton;

2523

2524

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

2525

hton= plugin_data(plugin, handlerton*);

2526

else

2527

{

2528

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

2529

default_storage_engine_str);

2530

unireg_abort(1);

2531

}

2532

if (!ha_storage_engine_is_enabled(hton))

2533

{

2534

if (!opt_bootstrap)

2535

{

2536

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

2537

default_storage_engine_str);

2538

unireg_abort(1);

2539

}

2540

assert(global_system_variables.table_plugin);

2541

}

2542

else

2543

{

2544

2545

Need to unlock as global_system_variables.table_plugin

2546

was acquired during plugin_init()

2547

2548

plugin_unlock(0, global_system_variables.table_plugin);

2549

global_system_variables.table_plugin= plugin;

2550

}

2551

}

2552

2553

tc_log= (total_ha_2pc > 1 ? (opt_bin_log ?

2554

(TC_LOG *) &mysql_bin_log :

2555

(TC_LOG *) &tc_log_mmap) :

2556

(TC_LOG *) &tc_log_dummy);

2557

2558

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

2559

{

2560

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

2561

unireg_abort(1);

2562

}

2563

2564

if (ha_recover(0))

2565

{

2566

unireg_abort(1);

2567

}

2568

2569

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

2570

WRITE_CACHE, 0, max_binlog_size, 0))

2571

unireg_abort(1);

2572

2573

if (opt_bin_log && expire_logs_days)

2574

{

2575

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

2576

if (purge_time >= 0)

2577

mysql_bin_log.purge_logs_before_date(purge_time);

2578

}

2579

2580

if (opt_myisam_log)

2581

(void) mi_log(1);

2582

2583

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

2584

if (locked_in_memory && !getuid())

2585

{

2586

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

2587

{ // this should never happen

2588

sql_perror("setreuid");

2589

unireg_abort(1);

2590

}

2591

if (mlockall(MCL_CURRENT))

2592

{

2593

if (global_system_variables.log_warnings)

2594

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

2595

locked_in_memory= 0;

2596

}

2597

if (user_info)

2598

set_user(mysqld_user, user_info);

2599

}

2600

else

2601

#endif

2602

locked_in_memory=0;

1664

2603

1665

2604

init_update_queries();

1666

1667

2605

return(0);

1668

2606

}

1669

2607

1670

2608

2609

static void create_maintenance_thread()

2610

{

2611

if (flush_time && flush_time != ~(ulong) 0L)

2612

{

2613

pthread_t hThread;

2614

if (pthread_create(&hThread,&connection_attrib,handle_manager,0))

2615

sql_print_warning("Can't create thread to manage maintenance");

2616

}

2617

}

2618

2619

2620

int main(int argc, char **argv)

2621

{

2622

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

2623

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

2624

2625

/* Set signal used to kill MySQL */

2626

#if defined(SIGUSR2)

2627

thr_kill_signal= thd_lib_detected == THD_LIB_LT ? SIGINT : SIGUSR2;

2628

#else

2629

thr_kill_signal= SIGINT;

2630

#endif

2631

2632

2633

Perform basic logger initialization logger. Should be called after

2634

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

2635

2636

logger.init_base();

2637

2638

#ifdef _CUSTOMSTARTUPCONFIG_

2639

if (_cust_check_startup())

2640

{

2641

/ * _cust_check_startup will report startup failure error * /

2642

exit(1);

2643

}

2644

#endif

2645

2646

if (init_common_variables(MYSQL_CONFIG_NAME,

2647

argc, argv, load_default_groups))

2648

unireg_abort(1); // Will do exit

2649

2650

init_signals();

2651

if (!(opt_specialflag & SPECIAL_NO_PRIOR))

2652

{

2653

struct sched_param tmp_sched_param;

2654

2655

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

2656

tmp_sched_param.sched_priority= my_thread_stack_size*2;

2657

(void)pthread_setschedparam(pthread_self(), SCHED_OTHER, &tmp_sched_param);

2658

}

2659

pthread_attr_setstacksize(&connection_attrib,my_thread_stack_size);

2660

#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE

2661

{

2662

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

2663

size_t stack_size= 0;

2664

pthread_attr_getstacksize(&connection_attrib, &stack_size);

2665

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

2666

if (stack_size && stack_size < my_thread_stack_size)

2667

{

2668

if (global_system_variables.log_warnings)

2669

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

2670

my_thread_stack_size, (long) stack_size);

2671

my_thread_stack_size= stack_size;

2672

}

2673

}

2674

#endif

2675

2676

select_thread=pthread_self();

2677

select_thread_in_use=1;

2678

2679

2680

We have enough space for fiddling with the argv, continue

2681

2682

check_data_home(mysql_real_data_home);

2683

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

2684

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

2685

mysql_data_home= mysql_data_home_buff;

2686

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

2687

mysql_data_home[1]=0;

2688

mysql_data_home_len= 2;

2689

2690

if ((user_info= check_user(mysqld_user)))

2691

{

2692

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

2693

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

2694

set_effective_user(user_info);

2695

else

2696

#endif

2697

set_user(mysqld_user, user_info);

2698

}

2699

2700

if (opt_bin_log && !server_id)

2701

{

2702

server_id= 1;

2703

#ifdef EXTRA_DEBUG

2704

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

2705

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

2706

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

2707

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

2708

#endif

2709

}

2710

2711

if (init_server_components())

2712

unireg_abort(1);

2713

2714

network_init();

2715

2716

2717

Initialize my_str_malloc() and my_str_free()

2718

2719

my_str_malloc= &my_str_malloc_mysqld;

2720

my_str_free= &my_str_free_mysqld;

2721

2722

2723

init signals & alarm

2724

After this we can't quit by a simple unireg_abort

2725

2726

error_handler_hook= my_message_sql;

2727

start_signal_handler(); // Creates pidfile

2728

2729

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

2730

{

2731

abort_loop=1;

2732

select_thread_in_use=0;

2733

(void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);

2734

2735

if (!opt_bootstrap)

2736

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

2737

2738

exit(1);

2739

}

2740

2741

init_status_vars();

2742

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

2743

opt_skip_slave_start= 1;

2744

2745

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

2746

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

2747

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

2748

memory); a message has already been printed.

2749

2750

if (init_slave() && !active_mi)

2751

{

2752

unireg_abort(1);

2753

}

2754

2755

create_maintenance_thread();

2756

2757

sql_print_information(ER(ER_STARTUP),my_progname,server_version,

2758

"", mysqld_port, MYSQL_COMPILATION_COMMENT);

2759

2760

2761

handle_connections_sockets();

2762

2763

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

2764

2765

2766

#ifdef EXTRA_DEBUG2

2767

sql_print_error("Before Lock_thread_count");

2768

#endif

2769

(void) pthread_mutex_lock(&LOCK_thread_count);

2770

select_thread_in_use=0; // For close_connections

2771

(void) pthread_mutex_unlock(&LOCK_thread_count);

2772

(void) pthread_cond_broadcast(&COND_thread_count);

2773

#ifdef EXTRA_DEBUG2

2774

sql_print_error("After lock_thread_count");

2775

#endif

2776

2777

/* Wait until cleanup is done */

2778

(void) pthread_mutex_lock(&LOCK_thread_count);

2779

while (!ready_to_exit)

2780

pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);

2781

(void) pthread_mutex_unlock(&LOCK_thread_count);

2782

2783

clean_up(1);

2784

mysqld_exit(0);

2785

}

2786

2787

2788

/**

2789

Create new thread to handle incoming connection.

2790

2791

This function will create new thread to handle the incoming

2792

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

2793

'thd' will be pushed into 'threads'.

2794

2795

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

2796

handled inside this function.

2797

2798

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

2799

2800

2801

static void create_new_thread(THD *thd)

2802

{

2803

2804

2805

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

2806

only (max_connections + 1) connections.

2807

2808

2809

pthread_mutex_lock(&LOCK_connection_count);

2810

2811

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

2812

{

2813

pthread_mutex_unlock(&LOCK_connection_count);

2814

2815

close_connection(thd, ER_CON_COUNT_ERROR, 1);

2816

delete thd;

2817

return;;

2818

}

2819

2820

++connection_count;

2821

2822

if (connection_count > max_used_connections)

2823

max_used_connections= connection_count;

2824

2825

pthread_mutex_unlock(&LOCK_connection_count);

2826

2827

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

2828

2829

pthread_mutex_lock(&LOCK_thread_count);

2830

2831

2832

The initialization of thread_id is done in create_embedded_thd() for

2833

the embedded library.

2834

TODO: refactor this to avoid code duplication there

2835

2836

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

2837

2838

thread_count++;

2839

2840

thread_scheduler.add_connection(thd);

2841

2842

return;;

2843

}

2844

2845

2846

#ifdef SIGNALS_DONT_BREAK_READ

2847

inline void kill_broken_server()

2848

{

2849

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

2850

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

2851

{

2852

select_thread_in_use = 0;

2853

/* The following call will never return */

2854

kill_server((void*) MYSQL_KILL_SIGNAL);

2855

}

2856

}

2857

#define MAYBE_BROKEN_SYSCALL kill_broken_server();

2858

#else

2859

#define MAYBE_BROKEN_SYSCALL

2860

#endif

2861

2862

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

2863

2864

void handle_connections_sockets()

2865

{

2866

my_socket sock,new_sock;

2867

uint error_count=0;

2868

uint max_used_connection= (uint)ip_sock+1;

2869

fd_set readFDs,clientFDs;

2870

THD *thd;

2871

struct sockaddr_storage cAddr;

2872

int ip_flags=0, flags;

2873

st_vio *vio_tmp;

2874

2875

FD_ZERO(&clientFDs);

2876

if (ip_sock != INVALID_SOCKET)

2877

{

2878

FD_SET(ip_sock,&clientFDs);

2879

ip_flags = fcntl(ip_sock, F_GETFL, 0);

2880

}

2881

MAYBE_BROKEN_SYSCALL;

2882

while (!abort_loop)

2883

{

2884

readFDs=clientFDs;

2885

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

2886

{

2887

if (socket_errno != SOCKET_EINTR)

2888

{

2889

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

2890

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

2891

}

2892

MAYBE_BROKEN_SYSCALL

2893

continue;

2894

}

2895

if (abort_loop)

2896

{

2897

MAYBE_BROKEN_SYSCALL;

2898

break;

2899

}

2900

2901

/* Is this a new connection request ? */

2902

{

2903

sock = ip_sock;

2904

flags= ip_flags;

2905

}

2906

2907

#if !defined(NO_FCNTL_NONBLOCK)

2908

if (!(test_flags & TEST_BLOCKING))

2909

{

2910

#if defined(O_NONBLOCK)

2911

fcntl(sock, F_SETFL, flags | O_NONBLOCK);

2912

#elif defined(O_NDELAY)

2913

fcntl(sock, F_SETFL, flags | O_NDELAY);

2914

#endif

2915

}

2916

#endif /* NO_FCNTL_NONBLOCK */

2917

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

2918

{

2919

size_socket length= sizeof(struct sockaddr_storage);

2920

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

2921

&length);

2922

if (new_sock != INVALID_SOCKET ||

2923

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

2924

break;

2925

MAYBE_BROKEN_SYSCALL;

2926

#if !defined(NO_FCNTL_NONBLOCK)

2927

if (!(test_flags & TEST_BLOCKING))

2928

{

2929

if (retry == MAX_ACCEPT_RETRY - 1)

2930

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

2931

}

2932

#endif

2933

}

2934

#if !defined(NO_FCNTL_NONBLOCK)

2935

if (!(test_flags & TEST_BLOCKING))

2936

fcntl(sock, F_SETFL, flags);

2937

#endif

2938

if (new_sock == INVALID_SOCKET)

2939

{

2940

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

2941

sql_perror("Error in accept");

2942

MAYBE_BROKEN_SYSCALL;

2943

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

2944

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

2945

continue;

2946

}

2947

2948

{

2949

size_socket dummyLen;

2950

struct sockaddr_storage dummy;

2951

dummyLen = sizeof(dummy);

2952

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

2953

(socklen_t *)&dummyLen) < 0 )

2954

{

2955

sql_perror("Error on new connection socket");

2956

(void) shutdown(new_sock, SHUT_RDWR);

2957

(void) closesocket(new_sock);

2958

continue;

2959

}

2960

}

2961

2962

2963

** Don't allow too many connections

2964

2965

2966

if (!(thd= new THD))

2967

{

2968

(void) shutdown(new_sock, SHUT_RDWR);

2969

VOID(closesocket(new_sock));

2970

continue;

2971

}

2972

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

2973

my_net_init(&thd->net,vio_tmp))

2974

{

2975

2976

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

2977

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

2978

structure.

2979

2980

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

2981

vio_delete(vio_tmp);

2982

else

2983

{

2984

(void) shutdown(new_sock, SHUT_RDWR);

2985

(void) closesocket(new_sock);

2986

}

2987

delete thd;

2988

continue;

2989

}

2990

2991

create_new_thread(thd);

2992

}

2993

}

2994

2995

1671

2996

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

1672

2997

Handle start options

1673

2998

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

1674

2999

1675

enum options_drizzled

3000

enum options_mysqld

1676

3001

{

1677

OPT_SOCKET=256,

1678

OPT_BIND_ADDRESS,

1679

OPT_PID_FILE,

1680

OPT_STORAGE_ENGINE,

1681

OPT_INIT_FILE,

3002

OPT_ISAM_LOG=256, OPT_SKIP_NEW,

3003

OPT_SKIP_GRANT, OPT_SKIP_LOCK,

3004

OPT_ENABLE_LOCK, OPT_USE_LOCKING,

3005

OPT_SOCKET, OPT_UPDATE_LOG,

3006

OPT_BIN_LOG,

3007

OPT_BIN_LOG_INDEX,

3008

OPT_BIND_ADDRESS, OPT_PID_FILE,

3009

OPT_SKIP_PRIOR, OPT_BIG_TABLES,

3010

OPT_STANDALONE,

3011

OPT_CONSOLE, OPT_LOW_PRIORITY_UPDATES,

3012

OPT_SHORT_LOG_FORMAT,

3013

OPT_FLUSH, OPT_SAFE,

3014

OPT_BOOTSTRAP, OPT_SKIP_SHOW_DB,

3015

OPT_STORAGE_ENGINE, OPT_INIT_FILE,

3016

OPT_DELAY_KEY_WRITE_ALL, OPT_SLOW_QUERY_LOG,

3017

OPT_DELAY_KEY_WRITE, OPT_CHARSETS_DIR,

3018

OPT_MASTER_INFO_FILE,

3019

OPT_MASTER_RETRY_COUNT, OPT_LOG_TC, OPT_LOG_TC_SIZE,

3020

OPT_SQL_BIN_UPDATE_SAME, OPT_REPLICATE_DO_DB,

3021

OPT_REPLICATE_IGNORE_DB, OPT_LOG_SLAVE_UPDATES,

3022

OPT_BINLOG_DO_DB, OPT_BINLOG_IGNORE_DB,

3023

OPT_BINLOG_FORMAT,

3024

OPT_BINLOG_ROWS_EVENT_MAX_SIZE,

1682

3025

OPT_WANT_CORE,

1683

OPT_MEMLOCK,

1684

OPT_SERVER_ID,

1685

OPT_TC_HEURISTIC_RECOVER,

3026

OPT_MEMLOCK, OPT_MYISAM_RECOVER,

3027

OPT_REPLICATE_REWRITE_DB, OPT_SERVER_ID,

3028

OPT_SKIP_SLAVE_START,

3029

OPT_REPLICATE_DO_TABLE,

3030

OPT_REPLICATE_IGNORE_TABLE, OPT_REPLICATE_WILD_DO_TABLE,

3031

OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,

3032

OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,

3033

OPT_ABORT_SLAVE_EVENT_COUNT,

3034

OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,

3035

OPT_ENGINE_CONDITION_PUSHDOWN,

1686

3036

OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,

1687

3037

OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,

1688

OPT_DO_PSTACK,

1689

OPT_LOCAL_INFILE,

1690

OPT_BACK_LOG,

1691

OPT_JOIN_BUFF_SIZE,

1692

OPT_MAX_ALLOWED_PACKET,

1693

OPT_MAX_CONNECT_ERRORS,

3038

OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,

3039

OPT_SAFE_USER_CREATE,

3040

OPT_DO_PSTACK, OPT_REPORT_HOST,

3041

OPT_REPORT_USER, OPT_REPORT_PASSWORD, OPT_REPORT_PORT,

3042

OPT_SHOW_SLAVE_AUTH_INFO,

3043

OPT_SLAVE_LOAD_TMPDIR, OPT_NO_MIX_TYPE,

3044

OPT_RPL_RECOVERY_RANK,

3045

OPT_RELAY_LOG, OPT_RELAY_LOG_INDEX, OPT_RELAY_LOG_INFO_FILE,

3046

OPT_SLAVE_SKIP_ERRORS, OPT_SLAVE_ALLOW_BATCHING, OPT_DES_KEY_FILE, OPT_LOCAL_INFILE,

3047

OPT_SSL_SSL, OPT_SSL_KEY, OPT_SSL_CERT, OPT_SSL_CA,

3048

OPT_SSL_CAPATH, OPT_SSL_CIPHER,

3049

OPT_BACK_LOG, OPT_BINLOG_CACHE_SIZE,

3050

OPT_CONNECT_TIMEOUT,

3051

OPT_FLUSH_TIME, OPT_FT_MIN_WORD_LEN, OPT_FT_BOOLEAN_SYNTAX,

3052

OPT_INTERACTIVE_TIMEOUT, OPT_JOIN_BUFF_SIZE,

3053

OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,

3054

OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,

3055

OPT_LONG_QUERY_TIME,

3056

OPT_LOWER_CASE_TABLE_NAMES, OPT_MAX_ALLOWED_PACKET,

3057

OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,

3058

OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,

1694

3059

OPT_MAX_HEP_TABLE_SIZE,

1695

OPT_MAX_JOIN_SIZE,

1696

OPT_MAX_SORT_LENGTH,

3060

OPT_MAX_JOIN_SIZE, OPT_MAX_PREPARED_STMT_COUNT,

3061

OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,

1697

3062

OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,

1698

3063

OPT_MAX_LENGTH_FOR_SORT_DATA,

1699

3064

OPT_MAX_WRITE_LOCK_COUNT, OPT_BULK_INSERT_BUFFER_SIZE,

1701

3066

OPT_MYISAM_BLOCK_SIZE, OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,

1702

3067

OPT_MYISAM_MAX_SORT_FILE_SIZE, OPT_MYISAM_SORT_BUFFER_SIZE,

1703

3068

OPT_MYISAM_USE_MMAP, OPT_MYISAM_REPAIR_THREADS,

1704

OPT_NET_BUFFER_LENGTH,

3069

OPT_MYISAM_STATS_METHOD,

3070

OPT_NET_BUFFER_LENGTH, OPT_NET_RETRY_COUNT,

3071

OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,

3072

OPT_OPEN_FILES_LIMIT,

1705

3073

OPT_PRELOAD_BUFFER_SIZE,

1706

OPT_RECORD_BUFFER,

1707

OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT,

1708

OPT_DEBUGGING,

3074

OPT_QUERY_CACHE_LIMIT, OPT_QUERY_CACHE_MIN_RES_UNIT, OPT_QUERY_CACHE_SIZE,

3075

OPT_QUERY_CACHE_TYPE, OPT_QUERY_CACHE_WLOCK_INVALIDATE, OPT_RECORD_BUFFER,

3076

OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT, OPT_RELAY_LOG_SPACE_LIMIT,

3077

OPT_RELAY_LOG_PURGE,

3078

OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,

3079

OPT_SLAVE_TRANS_RETRIES, OPT_READONLY, OPT_DEBUGGING,

1709

3080

OPT_SORT_BUFFER, OPT_TABLE_OPEN_CACHE, OPT_TABLE_DEF_CACHE,

3081

OPT_THREAD_CONCURRENCY, OPT_THREAD_CACHE_SIZE,

1710

3082

OPT_TMP_TABLE_SIZE, OPT_THREAD_STACK,

1711

3083

OPT_WAIT_TIMEOUT,

3084

OPT_ERROR_LOG_FILE,

3085

OPT_DEFAULT_WEEK_FORMAT,

1712

3086

OPT_RANGE_ALLOC_BLOCK_SIZE,

1713

3087

OPT_QUERY_ALLOC_BLOCK_SIZE, OPT_QUERY_PREALLOC_SIZE,

1714

3088

OPT_TRANS_ALLOC_BLOCK_SIZE, OPT_TRANS_PREALLOC_SIZE,

3089

OPT_SYNC_FRM, OPT_SYNC_BINLOG,

3090

OPT_SYNC_REPLICATION,

3091

OPT_SYNC_REPLICATION_SLAVE_ID,

3092

OPT_SYNC_REPLICATION_TIMEOUT,

3093

OPT_ENABLE_SHARED_MEMORY,

3094

OPT_SHARED_MEMORY_BASE_NAME,

1715

3095

OPT_OLD_ALTER_TABLE,

3096

OPT_EXPIRE_LOGS_DAYS,

1716

3097

OPT_GROUP_CONCAT_MAX_LEN,

1717

3098

OPT_DEFAULT_COLLATION,

3099

OPT_CHARACTER_SET_CLIENT_HANDSHAKE,

1718

3100

OPT_CHARACTER_SET_FILESYSTEM,

1719

3101

OPT_LC_TIME_NAMES,

1720

3102

OPT_INIT_CONNECT,

3103

OPT_INIT_SLAVE,

3104

OPT_SECURE_AUTH,

3105

OPT_DATE_FORMAT,

3106

OPT_TIME_FORMAT,

3107

OPT_DATETIME_FORMAT,

3108

OPT_LOG_QUERIES_NOT_USING_INDEXES,

1721

3109

OPT_DEFAULT_TIME_ZONE,

3110

OPT_SYSDATE_IS_NOW,

1722

3111

OPT_OPTIMIZER_SEARCH_DEPTH,

1723

OPT_SCHEDULER,

1724

OPT_PROTOCOL,

1725

3112

OPT_OPTIMIZER_PRUNE_LEVEL,

3113

OPT_UPDATABLE_VIEWS_WITH_LIMIT,

1726

3114

OPT_AUTO_INCREMENT, OPT_AUTO_INCREMENT_OFFSET,

1727

3115

OPT_ENABLE_LARGE_PAGES,

1728

3116

OPT_TIMED_MUTEXES,

3117

OPT_OLD_STYLE_USER_LIMITS,

3118

OPT_LOG_SLOW_ADMIN_STATEMENTS,

1729

3119

OPT_TABLE_LOCK_WAIT_TIMEOUT,

1730

OPT_PLUGIN_ADD,

1731

OPT_PLUGIN_REMOVE,

1732

3120

OPT_PLUGIN_LOAD,

1733

3121

OPT_PLUGIN_DIR,

3122

OPT_LOG_OUTPUT,

1734

3123

OPT_PORT_OPEN_TIMEOUT,

3124

OPT_PROFILING,

3125

OPT_KEEP_FILES_ON_CREATE,

3126

OPT_GENERAL_LOG,

3127

OPT_SLOW_LOG,

3128

OPT_THREAD_HANDLING,

3129

OPT_INNODB_ROLLBACK_ON_TIMEOUT,

1735

3130

OPT_SECURE_FILE_PRIV,

1736

3131

OPT_MIN_EXAMINED_ROW_LIMIT,

1737

OPT_PRINT_DEFAULTS

3132

OPT_LOG_SLOW_SLAVE_STATEMENTS,

3133

OPT_OLD_MODE,

3134

OPT_POOL_OF_THREADS,

3135

OPT_SLAVE_EXEC_MODE

1738

3136

};

1739

3137

1740

3138

1741

struct option my_long_options[] =

3139

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

3140

3141

struct my_option my_long_options[] =

1742

3142

{

1743

1744

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

3143

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

1745

3144

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

1746

3145

0, 0},

3146

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

3147

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

3148

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

3149

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

3150

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

3151

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

1747

3152

{"auto-increment-increment", OPT_AUTO_INCREMENT,

1748

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

3153

"Auto-increment columns are incremented by this",

1749

3154

(char**) &global_system_variables.auto_increment_increment,

1750

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

1751

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

3155

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

3156

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

1752

3157

{"auto-increment-offset", OPT_AUTO_INCREMENT_OFFSET,

1753

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

1754

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

3158

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

1755

3159

(char**) &global_system_variables.auto_increment_offset,

1756

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

1757

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

3160

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

3161

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

1758

3162

{"basedir", 'b',

1759

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

1760

"relative to this."),

1761

NULL, NULL, 0, GET_STR, REQUIRED_ARG,

1762

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

1763

{"chroot", 'r',

1764

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

1765

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

1766

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

1767

{"collation-server", OPT_DEFAULT_COLLATION,

1768

N_("Set the default collation."),

3163

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

3164

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

3165

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

3166

{"big-tables", OPT_BIG_TABLES,

3167

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

3168

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

3169

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

3170

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

3171

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

3172

{"binlog_format", OPT_BINLOG_FORMAT,

3173

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

3174

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

3175

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

3176

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

3177

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

3178

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

3179

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

3180

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

3181

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

3182

{"binlog-do-db", OPT_BINLOG_DO_DB,

3183

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

3184

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

3185

{"binlog-ignore-db", OPT_BINLOG_IGNORE_DB,

3186

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

3187

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

3188

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

3189

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

3190

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

3191

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

3192

(char**) &opt_binlog_rows_event_max_size,

3193

(char**) &opt_binlog_rows_event_max_size, 0,

3194

GET_ULONG, REQUIRED_ARG,

3195

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

3196

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

3197

/* app_type */ 0

3198

3199

#ifndef DISABLE_GRANT_OPTIONS

3200

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

3201

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

3202

#endif

3203

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

3204

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

3205

(char**) &opt_character_set_client_handshake,

3206

(char**) &opt_character_set_client_handshake,

3207

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

3208

{"character-set-filesystem", OPT_CHARACTER_SET_FILESYSTEM,

3209

"Set the filesystem character set.",

3210

(char**) &character_set_filesystem_name,

3211

(char**) &character_set_filesystem_name,

3212

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

3213

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

3214

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

3215

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

3216

{"character-sets-dir", OPT_CHARSETS_DIR,

3217

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

3218

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

3219

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

3220

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

3221

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

3222

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

1769

3223

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

1770

3224

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

1771

{"completion-type", OPT_COMPLETION_TYPE,

1772

N_("Default completion type."),

3225

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

1773

3226

(char**) &global_system_variables.completion_type,

1774

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

3227

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

1775

3228

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

1776

{"core-file", OPT_WANT_CORE,

1777

N_("Write core on errors."),

1778

0, 0, 0, GET_NO_ARG,

3229

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

3230

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

3231

0, 0, 0},

3232

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

1779

3233

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

1780

{"datadir", 'h',

1781

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

1782

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

3234

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

3235

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

3236

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

3237

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

3238

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

3239

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

3240

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

3241

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

1783

3242

{"default-storage-engine", OPT_STORAGE_ENGINE,

1784

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

1785

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

1786

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

1787

{"default-time-zone", OPT_DEFAULT_TIME_ZONE,

1788

N_("Set the default time zone."),

3243

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

3244

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

3245

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

3246

{"default-table-type", OPT_STORAGE_ENGINE,

3247

"(deprecated) Use --default-storage-engine.",

3248

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

3249

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

3250

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

1789

3251

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

1790

3252

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

3253

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

3254

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

3255

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

3256

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

3257

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

3258

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

3259

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

3260

(char**) &disconnect_slave_event_count,

3261

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

3262

0, 0, 0},

3263

#ifdef HAVE_STACK_TRACE_ON_SEGV

3264

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

3265

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

3266

0, 0, 0, 0},

3267

#endif /* HAVE_STACK_TRACE_ON_SEGV */

3268

{"engine-condition-pushdown",

3269

OPT_ENGINE_CONDITION_PUSHDOWN,

3270

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

3271

(char**) &global_system_variables.engine_condition_pushdown,

3272

(char**) &global_system_variables.engine_condition_pushdown,

3273

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

1791

3274

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

1792

{"exit-info", 'T',

1793

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

1794

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

3275

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

3276

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

3277

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

3278

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

1795

3279

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

1796

3280

easier to do */

1797

3281

{"gdb", OPT_DEBUGGING,

1798

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

3282

"Set up signals usable for debugging",

1799

3283

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

1800

3284

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

3285

{"general-log", OPT_GENERAL_LOG,

3286

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

3287

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

3288

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

3289

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

3290

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

3291

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

3292

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

3293

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

3294

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

3295

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

3296

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

3297

{"language", 'L',

3298

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

3299

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

3300

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

1801

3301

{"lc-time-names", OPT_LC_TIME_NAMES,

1802

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

3302

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

1803

3303

(char**) &lc_time_names_name,

1804

3304

(char**) &lc_time_names_name,

1805

3305

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

1806

{"log-warnings", 'W',

1807

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

3306

{"local-infile", OPT_LOCAL_INFILE,

3307

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

3308

(char**) &opt_local_infile,

3309

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

3310

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

3311

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

3312

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

3313

{"log-bin", OPT_BIN_LOG,

3314

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

3315

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

3316

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

3317

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

3318

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

3319

{"log-bin-index", OPT_BIN_LOG_INDEX,

3320

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

3321

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

3322

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

3323

3324

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

3325

binary logging.

3326

3327

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

3328

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

3329

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

3330

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

3331

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

3332

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

3333

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

3334

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

3335

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

3336

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

3337

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

3338

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

3339

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

3340

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

3341

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

3342

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

3343

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

3344

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

3345

#ifdef WITH_CSV_STORAGE_ENGINE

3346

{"log-output", OPT_LOG_OUTPUT,

3347

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

3348

"FILE or NONE.",

3349

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

3350

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

3351

#endif

3352

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

3353

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

3354

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

3355

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

3356

{"log-short-format", OPT_SHORT_LOG_FORMAT,

3357

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

3358

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

3359

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

3360

{"log-slave-updates", OPT_LOG_SLAVE_UPDATES,

3361

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

3362

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

3363

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

3364

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

3365

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

3366

(char**) &opt_log_slow_admin_statements,

3367

(char**) &opt_log_slow_admin_statements,

3368

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

3369

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

3370

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

3371

(char**) &opt_log_slow_slave_statements,

3372

(char**) &opt_log_slow_slave_statements,

3373

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

3374

{"log-slow-queries", OPT_SLOW_QUERY_LOG,

3375

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

3376

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

3377

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

3378

{"log-tc", OPT_LOG_TC,

3379

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

3380

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

3381

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

3382

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

3383

#ifdef HAVE_MMAP

3384

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

3385

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

3386

REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, ULONG_MAX, 0,

3387

TC_LOG_PAGE_SIZE, 0},

3388

#endif

3389

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

1808

3390

(char**) &global_system_variables.log_warnings,

1809

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

3391

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

1810

3392

0, 0, 0},

1811

{"pid-file", OPT_PID_FILE,

1812

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

1813

NULL, NULL, 0, GET_STR,

1814

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

3393

{"low-priority-updates", OPT_LOW_PRIORITY_UPDATES,

3394

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

3395

(char**) &global_system_variables.low_priority_updates,

3396

(char**) &max_system_variables.low_priority_updates,

3397

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

3398

{"master-info-file", OPT_MASTER_INFO_FILE,

3399

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

3400

thread is in the master's binlogs.",

3401

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

3402

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

3403

{"master-retry-count", OPT_MASTER_RETRY_COUNT,

3404

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

3405

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

3406

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

3407

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

3408

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

3409

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

3410

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

3411

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

3412

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

3413

{"myisam-recover", OPT_MYISAM_RECOVER,

3414

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

3415

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

3416

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

3417

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

3418

(char**) &global_system_variables.new_mode,

3419

(char**) &max_system_variables.new_mode,

3420

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

3421

{"old-alter-table", OPT_OLD_ALTER_TABLE,

3422

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

3423

(char**) &global_system_variables.old_alter_table,

3424

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

3425

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

3426

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

3427

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

3428

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

3429

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

3430

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

3431

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

3432

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

3433

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

3434

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

3435

#if MYSQL_PORT_DEFAULT == 0

3436

"/etc/services, "

3437

#endif

3438

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

3439

(char**) &mysqld_port,

3440

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

1815

3441

{"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,

1816

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

1817

"(Default: no wait)"),

1818

(char**) &drizzled_bind_timeout,

1819

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

3442

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

3443

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

3444

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

3445

{"relay-log", OPT_RELAY_LOG,

3446

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

3447

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

3448

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

3449

{"relay-log-index", OPT_RELAY_LOG_INDEX,

3450

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

3451

relay logs.",

3452

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

3453

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

3454

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

3455

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

3456

thread is in the relay logs.",

3457

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

3458

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

3459

{"replicate-do-db", OPT_REPLICATE_DO_DB,

3460

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

3461

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

3462

{"replicate-do-table", OPT_REPLICATE_DO_TABLE,

3463

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

3464

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

3465

{"replicate-ignore-db", OPT_REPLICATE_IGNORE_DB,

3466

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

3467

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

3468

{"replicate-ignore-table", OPT_REPLICATE_IGNORE_TABLE,

3469

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

3470

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

3471

{"replicate-rewrite-db", OPT_REPLICATE_REWRITE_DB,

3472

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

3473

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

3474

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

3475

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

3476

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

3477

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

3478

(char**) &replicate_same_server_id,

3479

(char**) &replicate_same_server_id,

3480

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

3481

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

3482

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

3483

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

3484

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

3485

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

3486

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

3487

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

3488

{"report-host", OPT_REPORT_HOST,

3489

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

3490

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

3491

0, 0, 0, 0},

3492

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

3493

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

3494

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

3495

{"report-port", OPT_REPORT_PORT,

3496

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

3497

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

3498

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

3499

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

3500

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

1820

3501

{"secure-file-priv", OPT_SECURE_FILE_PRIV,

1821

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

1822

"within specified directory"),

1823

NULL, NULL, 0,

3502

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

3503

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

1824

3504

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

1825

3505

{"server-id", OPT_SERVER_ID,

1826

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

1827

"replication partners."),

1828

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

3506

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

3507

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

1829

3508

0, 0, 0},

3509

{"set-variable", 'O',

3510

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

3511

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

3512

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

3513

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

3514

{"skip-slave-start", OPT_SKIP_SLAVE_START,

3515

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

3516

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

1830

3517

{"skip-stack-trace", OPT_SKIP_STACK_TRACE,

1831

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

1832

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

3518

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

1833

3519

0, 0, 0, 0},

1834

{"symbolic-links", 's',

1835

N_("Enable symbolic link support."),

1836

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

3520

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

3521

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

3522

{"skip-thread-priority", OPT_SKIP_PRIOR,

3523

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

3524

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

3525

{"slave-load-tmpdir", OPT_SLAVE_LOAD_TMPDIR,

3526

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

3527

replicating a LOAD DATA INFILE command.",

3528

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

3529

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

3530

{"slave-skip-errors", OPT_SLAVE_SKIP_ERRORS,

3531

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

3532

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

3533

{"slave-exec-mode", OPT_SLAVE_EXEC_MODE,

3534

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

3535

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

3536

{"slow-query-log", OPT_SLOW_LOG,

3537

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

3538

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

3539

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

3540

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

3541

log and this option does nothing anymore.",

3542

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

3543

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

3544

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

1837

3545

1838

3546

The system call realpath() produces warnings under valgrind and

1839

3547

purify. These are not suppressed: instead we disable symlinks

1840

3548

option if compiled with valgrind support.

1841

3549

1842

3550

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

3551

{"sysdate-is-now", OPT_SYSDATE_IS_NOW,

3552

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

3553

(char**) &global_system_variables.sysdate_is_now,

3554

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

3555

{"tc-heuristic-recover", OPT_TC_HEURISTIC_RECOVER,

3556

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

3557

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

3558

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

3559

{"temp-pool", OPT_TEMP_POOL,

3560

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

3561

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

3562

0, 0, 0, 0, 0},

1843

3563

{"timed_mutexes", OPT_TIMED_MUTEXES,

1844

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

1845

"supported)"),

1846

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

3564

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

3565

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

1847

3566

0, 0, 0, 0, 0},

1848

3567

{"tmpdir", 't',

1849

N_("Path for temporary files."),

1850

(char**) &opt_drizzle_tmpdir,

1851

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

3568

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

3569

"colon (:)"

3570

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

3571

(char**) &opt_mysql_tmpdir,

3572

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

1852

3573

{"transaction-isolation", OPT_TX_ISOLATION,

1853

N_("Default transaction isolation level."),

1854

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

3574

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

1855

3575

0, 0, 0, 0, 0},

1856

{"user", 'u',

1857

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

1858

0, 0, 0, GET_STR, REQUIRED_ARG,

3576

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

3577

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

3578

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

3579

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

1859

3580

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

1860

{"version", 'V',

1861

N_("Output version information and exit."),

1862

0, 0, 0, GET_NO_ARG,

3581

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

3582

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

3583

0, 0},

3584

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

1863

3585

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

1864

{"back_log", OPT_BACK_LOG,

1865

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

1866

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

1867

"requests in a very short time."),

1868

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

3586

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

3587

(char**) &global_system_variables.log_warnings,

3588

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

3589

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

3590

{ "back_log", OPT_BACK_LOG,

3591

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

3592

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

1869

3593

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

1870

{ "bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,

1871

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

1872

"a limit per thread!"),

1873

(char**) &global_system_variables.bulk_insert_buff_size,

1874

(char**) &max_system_variables.bulk_insert_buff_size,

1875

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

1876

{ "div_precision_increment", OPT_DIV_PRECINCREMENT,

1877

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

1878

"value."),

3594

{"binlog_cache_size", OPT_BINLOG_CACHE_SIZE,

3595

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

3596

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

3597

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

3598

{"bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,

3599

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

3600

(char**) &global_system_variables.bulk_insert_buff_size,

3601

(char**) &max_system_variables.bulk_insert_buff_size,

3602

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

3603

{"connect_timeout", OPT_CONNECT_TIMEOUT,

3604

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

3605

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

3606

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

3607

{ "date_format", OPT_DATE_FORMAT,

3608

"The DATE format (For future).",

3609

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],

3610

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],

3611

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

3612

{ "datetime_format", OPT_DATETIME_FORMAT,

3613

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

3614

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],

3615

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],

3616

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

3617

{ "default_week_format", OPT_DEFAULT_WEEK_FORMAT,

3618

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

3619

(char**) &global_system_variables.default_week_format,

3620

(char**) &max_system_variables.default_week_format,

3621

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

3622

{"div_precision_increment", OPT_DIV_PRECINCREMENT,

3623

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

1879

3624

(char**) &global_system_variables.div_precincrement,

1880

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

3625

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

1881

3626

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

3627

{"expire_logs_days", OPT_EXPIRE_LOGS_DAYS,

3628

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

3629

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

3630

(char**) &expire_logs_days,

3631

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

3632

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

3633

{ "flush_time", OPT_FLUSH_TIME,

3634

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

3635

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

3636

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

1882

3637

{ "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,

1883

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

3638

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

1884

3639

(char**) &global_system_variables.group_concat_max_len,

1885

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

3640

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

1886

3641

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

1887

{ "join_buffer_size", OPT_JOIN_BUFF_SIZE,

1888

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

3642

{"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,

3643

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

3644

(char**) &global_system_variables.net_interactive_timeout,

3645

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

3646

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

3647

{"join_buffer_size", OPT_JOIN_BUFF_SIZE,

3648

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

1889

3649

(char**) &global_system_variables.join_buff_size,

1890

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

3650

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

1891

3651

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

1892

3652

MALLOC_OVERHEAD, IO_SIZE, 0},

3653

{"keep_files_on_create", OPT_KEEP_FILES_ON_CREATE,

3654

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

3655

(char**) &global_system_variables.keep_files_on_create,

3656

(char**) &max_system_variables.keep_files_on_create,

3657

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

3658

{"key_buffer_size", OPT_KEY_BUFFER_SIZE,

3659

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

3660

(char**) &dflt_key_cache_var.param_buff_size,

3661

(char**) 0,

3662

0, (GET_ULL | GET_ASK_ADDR),

3663

REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, SIZE_T_MAX, MALLOC_OVERHEAD,

3664

IO_SIZE, 0},

3665

{"key_cache_age_threshold", OPT_KEY_CACHE_AGE_THRESHOLD,

3666

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

3667

(char**) &dflt_key_cache_var.param_age_threshold,

3668

(char**) 0,

3669

0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,

3670

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

3671

{"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,

3672

"The default size of key cache blocks",

3673

(char**) &dflt_key_cache_var.param_block_size,

3674

(char**) 0,

3675

0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,

3676

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

3677

{"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,

3678

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

3679

(char**) &dflt_key_cache_var.param_division_limit,

3680

(char**) 0,

3681

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

3682

1, 100, 0, 1, 0},

3683

{"long_query_time", OPT_LONG_QUERY_TIME,

3684

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

3685

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

3686

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

3687

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

3688

{"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,

3689

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

3690

(char**) &lower_case_table_names,

3691

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

3692

#ifdef FN_NO_CASE_SENCE

3693

3694

#else

3695

3696

#endif

3697

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

1893

3698

{"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,

1894

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

3699

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

1895

3700

(char**) &global_system_variables.max_allowed_packet,

1896

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

1897

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

3701

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

3702

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

3703

{"max_binlog_cache_size", OPT_MAX_BINLOG_CACHE_SIZE,

3704

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

3705

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

3706

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

3707

{"max_binlog_size", OPT_MAX_BINLOG_SIZE,

3708

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

3709

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

3710

The minimum value for this variable is 4096.",

3711

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

3712

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

1898

3713

{"max_connect_errors", OPT_MAX_CONNECT_ERRORS,

1899

N_("If there is more than this number of interrupted connections from a "

1900

"host this host will be blocked from further connections."),

1901

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

1902

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

3714

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

3715

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

3716

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

3717

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

3718

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

3719

{"max_connections", OPT_MAX_CONNECTIONS,

3720

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

3721

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

3722

0},

1903

3723

{"max_error_count", OPT_MAX_ERROR_COUNT,

1904

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

3724

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

1905

3725

(char**) &global_system_variables.max_error_count,

1906

3726

(char**) &max_system_variables.max_error_count,

1907

0, GET_UINT64, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 0, 65535, 0, 1, 0},

3727

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

1908

3728

{"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,

1909

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

3729

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

1910

3730

(char**) &global_system_variables.max_heap_table_size,

1911

3731

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

1912

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

3732

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

1913

3733

MALLOC_OVERHEAD, 1024, 0},

1914

3734

{"max_join_size", OPT_MAX_JOIN_SIZE,

1915

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

1916

"return an error."),

3735

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

1917

3736

(char**) &global_system_variables.max_join_size,

1918

3737

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

1919

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

1920

{"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,

1921

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

1922

(char**) &global_system_variables.max_length_for_sort_data,

1923

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

1924

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

3738

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

3739

{"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,

3740

"Max number of bytes in sorted records.",

3741

(char**) &global_system_variables.max_length_for_sort_data,

3742

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

3743

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

3744

{"max_relay_log_size", OPT_MAX_RELAY_LOG_SIZE,

3745

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

3746

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

3747

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

1925

3748

{ "max_seeks_for_key", OPT_MAX_SEEKS_FOR_KEY,

1926

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

3749

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

1927

3750

(char**) &global_system_variables.max_seeks_for_key,

1928

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

3751

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

1929

3752

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

1930

3753

{"max_sort_length", OPT_MAX_SORT_LENGTH,

1931

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

1932

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

1933

"rest are ignored)."),

3754

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

1934

3755

(char**) &global_system_variables.max_sort_length,

1935

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

3756

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

1936

3757

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

3758

{"max_tmp_tables", OPT_MAX_TMP_TABLES,

3759

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

3760

(char**) &global_system_variables.max_tmp_tables,

3761

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

3762

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

1937

3763

{"max_write_lock_count", OPT_MAX_WRITE_LOCK_COUNT,

1938

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

1939

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

3764

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

3765

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

1940

3766

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

1941

3767

{"min_examined_row_limit", OPT_MIN_EXAMINED_ROW_LIMIT,

1942

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

1943

"rows to file."),

3768

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

1944

3769

(char**) &global_system_variables.min_examined_row_limit,

1945

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

1946

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

3770

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

3771

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

3772

{"myisam_block_size", OPT_MYISAM_BLOCK_SIZE,

3773

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

3774

(char**) &opt_myisam_block_size,

3775

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

3776

MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, MI_MAX_KEY_BLOCK_LENGTH,

3777

0, MI_MIN_KEY_BLOCK_LENGTH, 0},

3778

{"myisam_data_pointer_size", OPT_MYISAM_DATA_POINTER_SIZE,

3779

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

3780

(char**) &myisam_data_pointer_size,

3781

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

3782

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

3783

{"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,

3784

"Deprecated option",

3785

(char**) &global_system_variables.myisam_max_extra_sort_file_size,

3786

(char**) &max_system_variables.myisam_max_extra_sort_file_size,

3787

0, GET_ULL, REQUIRED_ARG, (ulonglong) MI_MAX_TEMP_LENGTH,

3788

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

3789

{"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,

3790

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

3791

(char**) &global_system_variables.myisam_max_sort_file_size,

3792

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

3793

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

3794

0, 1024*1024, 0},

3795

{"myisam_repair_threads", OPT_MYISAM_REPAIR_THREADS,

3796

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

3797

(char**) &global_system_variables.myisam_repair_threads,

3798

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

3799

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

3800

{"myisam_sort_buffer_size", OPT_MYISAM_SORT_BUFFER_SIZE,

3801

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

3802

(char**) &global_system_variables.myisam_sort_buff_size,

3803

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

3804

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

3805

{"myisam_stats_method", OPT_MYISAM_STATS_METHOD,

3806

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

3807

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

3808

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

3809

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

3810

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

3811

{"net_buffer_length", OPT_NET_BUFFER_LENGTH,

3812

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

3813

(char**) &global_system_variables.net_buffer_length,

3814

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

3815

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

3816

{"net_read_timeout", OPT_NET_READ_TIMEOUT,

3817

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

3818

(char**) &global_system_variables.net_read_timeout,

3819

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

3820

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

3821

{"net_retry_count", OPT_NET_RETRY_COUNT,

3822

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

3823

(char**) &global_system_variables.net_retry_count,

3824

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

3825

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

3826

{"net_write_timeout", OPT_NET_WRITE_TIMEOUT,

3827

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

3828

(char**) &global_system_variables.net_write_timeout,

3829

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

3830

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

3831

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

3832

(char**) &global_system_variables.old_mode,

3833

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

3834

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

3835

{"open_files_limit", OPT_OPEN_FILES_LIMIT,

3836

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

3837

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

3838

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

1947

3839

{"optimizer_prune_level", OPT_OPTIMIZER_PRUNE_LEVEL,

1948

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

1949

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

1950

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

1951

"true - prune plans based on number of retrieved rows."),

1952

(char**) &global_system_variables.optimizer_prune_level,

1953

(char**) &max_system_variables.optimizer_prune_level,

1954

0, GET_BOOL, OPT_ARG, 1, 0, 1, 0, 1, 0},

3840

"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.",

3841

(char**) &global_system_variables.optimizer_prune_level,

3842

(char**) &max_system_variables.optimizer_prune_level,

3843

0, GET_ULONG, OPT_ARG, 1, 0, 1, 0, 1, 0},

1955

3844

{"optimizer_search_depth", OPT_OPTIMIZER_SEARCH_DEPTH,

1956

N_("Maximum depth of search performed by the query optimizer. Values "

1957

"larger than the number of relations in a query result in better query "

1958

"plans, but take longer to compile a query. Smaller values than the "

1959

"number of tables in a relation result in faster optimization, but may "

1960

"produce very bad query plans. If set to 0, the system will "

1961

"automatically pick a reasonable value; if set to MAX_TABLES+2, the "

1962

"optimizer will switch to the original find_best (used for "

1963

"testing/comparison)."),

3845

"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).",

1964

3846

(char**) &global_system_variables.optimizer_search_depth,

1965

3847

(char**) &max_system_variables.optimizer_search_depth,

1966

0, GET_UINT, OPT_ARG, 0, 0, MAX_TABLES+2, 0, 1, 0},

3848

0, GET_ULONG, OPT_ARG, MAX_TABLES+1, 0, MAX_TABLES+2, 0, 1, 0},

1967

3849

{"plugin_dir", OPT_PLUGIN_DIR,

1968

N_("Directory for plugins."),

1969

NULL, NULL, 0,

1970

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1971

{"plugin_add", OPT_PLUGIN_ADD,

1972

N_("Optional comma separated list of plugins to load at startup in addition "

1973

"to the default list of plugins. "

1974

"[for example: --plugin_add=crc32,logger_gearman]"),

1975

NULL, NULL, 0,

1976

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1977

{"plugin_remove", OPT_PLUGIN_ADD,

1978

N_("Optional comma separated list of plugins to not load at startup. Effectively "

1979

"removes a plugin from the list of plugins to be loaded. "

1980

"[for example: --plugin_remove=crc32,logger_gearman]"),

1981

NULL, NULL, 0,

3850

"Directory for plugins.",

3851

(char**) &opt_plugin_dir_ptr, (char**) &opt_plugin_dir_ptr, 0,

1982

3852

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1983

3853

{"plugin_load", OPT_PLUGIN_LOAD,

1984

N_("Optional comma separated list of plugins to load at starup instead of "

1985

"the default plugin load list. "

1986

"[for example: --plugin_load=crc32,logger_gearman]"),

1987

NULL, NULL, 0,

3854

"Optional colon separated list of plugins to load, where each plugin is "

3855

"identified by name and path to library seperated by an equals.",

3856

(char**) &opt_plugin_load, (char**) &opt_plugin_load, 0,

1988

3857

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1989

3858

{"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,

1990

N_("The size of the buffer that is allocated when preloading indexes"),

3859

"The size of the buffer that is allocated when preloading indexes",

1991

3860

(char**) &global_system_variables.preload_buff_size,

1992

(char**) &max_system_variables.preload_buff_size, 0, GET_ULL,

3861

(char**) &max_system_variables.preload_buff_size, 0, GET_ULONG,

1993

3862

REQUIRED_ARG, 32*1024L, 1024, 1024*1024*1024L, 0, 1, 0},

1994

3863

{"query_alloc_block_size", OPT_QUERY_ALLOC_BLOCK_SIZE,

1995

N_("Allocation block size for query parsing and execution"),

3864

"Allocation block size for query parsing and execution",

1996

3865

(char**) &global_system_variables.query_alloc_block_size,

1997

(char**) &max_system_variables.query_alloc_block_size, 0, GET_UINT,

3866

(char**) &max_system_variables.query_alloc_block_size, 0, GET_ULONG,

1998

3867

REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},

1999

3868

{"query_prealloc_size", OPT_QUERY_PREALLOC_SIZE,

2000

N_("Persistent buffer for query parsing and execution"),

3869

"Persistent buffer for query parsing and execution",

2001

3870

(char**) &global_system_variables.query_prealloc_size,

2002

(char**) &max_system_variables.query_prealloc_size, 0, GET_UINT,

3871

(char**) &max_system_variables.query_prealloc_size, 0, GET_ULONG,

2003

3872

REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,

2004

3873

ULONG_MAX, 0, 1024, 0},

2005

3874

{"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,

2006

N_("Allocation block size for storing ranges during optimization"),

3875

"Allocation block size for storing ranges during optimization",

2007

3876

(char**) &global_system_variables.range_alloc_block_size,

2008

(char**) &max_system_variables.range_alloc_block_size, 0, GET_SIZE,

2009

REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, (int64_t)SIZE_MAX,

3877

(char**) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,

3878

REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, ULONG_MAX,

2010

3879

0, 1024, 0},

2011

3880

{"read_buffer_size", OPT_RECORD_BUFFER,

2012

N_("Each thread that does a sequential scan allocates a buffer of this "

2013

"size for each table it scans. If you do many sequential scans, you may "

2014

"want to increase this value."),

2015

(char**) &global_system_variables.read_buff_size,

2016

(char**) &max_system_variables.read_buff_size,0, GET_UINT, REQUIRED_ARG,

2017

128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT32_MAX, MALLOC_OVERHEAD, IO_SIZE,

2018

0},

3881

"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.",

3882

(char**) &global_system_variables.read_buff_size,

3883

(char**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,

3884

128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE,

3885

0},

3886

{"read_only", OPT_READONLY,

3887

"Make all non-temporary tables read-only, with the exception for replication (slave) threads and users with the SUPER privilege",

3888

(char**) &opt_readonly,

3889

(char**) &opt_readonly,

3890

0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},

2019

3891

{"read_rnd_buffer_size", OPT_RECORD_RND_BUFFER,

2020

N_("When reading rows in sorted order after a sort, the rows are read "

2021

"through this buffer to avoid a disk seeks. If not set, then it's set "

2022

"to the value of record_buffer."),

3892

"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.",

2023

3893

(char**) &global_system_variables.read_rnd_buff_size,

2024

3894

(char**) &max_system_variables.read_rnd_buff_size, 0,

2025

GET_UINT, REQUIRED_ARG, 256*1024L, 64 /*IO_SIZE*2+MALLOC_OVERHEAD*/ ,

2026

UINT32_MAX, MALLOC_OVERHEAD, 1 /* Small lower limit to be able to test MRR */, 0},

2027

{"scheduler", OPT_SCHEDULER,

2028

N_("Select scheduler to be used (by default multi-thread)."),

2029

(char**)&opt_scheduler, (char**)&opt_scheduler,

2030

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

2031

/* x8 compared to MySQL's x2. We have UTF8 to consider. */

3895

GET_ULONG, REQUIRED_ARG, 256*1024L, 64 /*IO_SIZE*2+MALLOC_OVERHEAD*/ ,

3896

INT_MAX32, MALLOC_OVERHEAD, 1 /* Small lower limit to be able to test MRR */, 0},

3897

{"record_buffer", OPT_RECORD_BUFFER,

3898

"Alias for read_buffer_size",

3899

(char**) &global_system_variables.read_buff_size,

3900

(char**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,

3901

128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE, 0},

3902

{"relay_log_purge", OPT_RELAY_LOG_PURGE,

3903

"0 = do not purge relay logs. 1 = purge them as soon as they are no more needed.",

3904

(char**) &relay_log_purge,

3905

(char**) &relay_log_purge, 0, GET_BOOL, NO_ARG,

3906

1, 0, 1, 0, 1, 0},

3907

{"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,

3908

"Maximum space to use for all relay logs.",

3909

(char**) &relay_log_space_limit,

3910

(char**) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,

3911

(longlong) ULONG_MAX, 0, 1, 0},

3912

{"slave_compressed_protocol", OPT_SLAVE_COMPRESSED_PROTOCOL,

3913

"Use compression on master/slave protocol.",

3914

(char**) &opt_slave_compressed_protocol,

3915

(char**) &opt_slave_compressed_protocol,

3916

0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},

3917

{"slave_net_timeout", OPT_SLAVE_NET_TIMEOUT,

3918

"Number of seconds to wait for more data from a master/slave connection before aborting the read.",

3919

(char**) &slave_net_timeout, (char**) &slave_net_timeout, 0,

3920

GET_ULONG, REQUIRED_ARG, SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},

3921

{"slave_transaction_retries", OPT_SLAVE_TRANS_RETRIES,

3922

"Number of times the slave SQL thread will retry a transaction in case "

3923

"it failed with a deadlock or elapsed lock wait timeout, "

3924

"before giving up and stopping.",

3925

(char**) &slave_trans_retries, (char**) &slave_trans_retries, 0,

3926

GET_ULONG, REQUIRED_ARG, 10L, 0L, (longlong) ULONG_MAX, 0, 1, 0},

3927

{"slave-allow-batching", OPT_SLAVE_ALLOW_BATCHING,

3928

"Allow slave to batch requests.",

3929

(char**) &slave_allow_batching, (char**) &slave_allow_batching,

3930

0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},

3931

{"slow_launch_time", OPT_SLOW_LAUNCH_TIME,

3932

"If creating the thread takes longer than this value (in seconds), the Slow_launch_threads counter will be incremented.",

3933

(char**) &slow_launch_time, (char**) &slow_launch_time, 0, GET_ULONG,

3934

REQUIRED_ARG, 2L, 0L, LONG_TIMEOUT, 0, 1, 0},

2032

3935

{"sort_buffer_size", OPT_SORT_BUFFER,

2033

N_("Each thread that needs to do a sort allocates a buffer of this size."),

3936

"Each thread that needs to do a sort allocates a buffer of this size.",

2034

3937

(char**) &global_system_variables.sortbuff_size,

2035

(char**) &max_system_variables.sortbuff_size, 0, GET_SIZE, REQUIRED_ARG,

2036

MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*8, (int64_t)SIZE_MAX,

3938

(char**) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,

3939

MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ULONG_MAX,

2037

3940

MALLOC_OVERHEAD, 1, 0},

3941

{"sync-binlog", OPT_SYNC_BINLOG,

3942

"Synchronously flush binary log to disk after every #th event. "

3943

"Use 0 (default) to disable synchronous flushing.",

3944

(char**) &sync_binlog_period, (char**) &sync_binlog_period, 0, GET_ULONG,

3945

REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1, 0},

3946

{"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default.",

3947

(char**) &opt_sync_frm, (char**) &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,

3948

0, 0, 0, 0},

3949

{"table_cache", OPT_TABLE_OPEN_CACHE,

3950

"Deprecated; use --table_open_cache instead.",

3951

(char**) &table_cache_size, (char**) &table_cache_size, 0, GET_ULONG,

3952

REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},

2038

3953

{"table_definition_cache", OPT_TABLE_DEF_CACHE,

2039

N_("The number of cached table definitions."),

3954

"The number of cached table definitions.",

2040

3955

(char**) &table_def_size, (char**) &table_def_size,

2041

0, GET_SIZE, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},

3956

0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},

2042

3957

{"table_open_cache", OPT_TABLE_OPEN_CACHE,

2043

N_("The number of cached open tables."),

2044

(char**) &table_cache_size, (char**) &table_cache_size, 0, GET_UINT64,

2045

REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, TABLE_OPEN_CACHE_MIN, 512*1024L, 0, 1, 0},

3958

"The number of cached open tables.",

3959

(char**) &table_cache_size, (char**) &table_cache_size, 0, GET_ULONG,

3960

REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},

2046

3961

{"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,

2047

N_("Timeout in seconds to wait for a table level lock before returning an "

2048

"error. Used only if the connection has active cursors."),

3962

"Timeout in seconds to wait for a table level lock before returning an "

3963

"error. Used only if the connection has active cursors.",

2049

3964

(char**) &table_lock_wait_timeout, (char**) &table_lock_wait_timeout,

2050

0, GET_ULL, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},

3965

0, GET_ULONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},

3966

{"thread_cache_size", OPT_THREAD_CACHE_SIZE,

3967

"How many threads we should keep in a cache for reuse.",

3968

(char**) &thread_cache_size, (char**) &thread_cache_size, 0, GET_ULONG,

3969

REQUIRED_ARG, 0, 0, 16384, 0, 1, 0},

3970

{"thread_pool_size", OPT_THREAD_CACHE_SIZE,

3971

"How many threads we should create to handle query requests in case of 'thread_handling=pool-of-threads'",

3972

(char**) &thread_pool_size, (char**) &thread_pool_size, 0, GET_ULONG,

3973

REQUIRED_ARG, 20, 1, 16384, 0, 1, 0},

2051

3974

{"thread_stack", OPT_THREAD_STACK,

2052

N_("The stack size for each thread."),

2053

(char**) &my_thread_stack_size,

2054

(char**) &my_thread_stack_size, 0, GET_SIZE,

2055

REQUIRED_ARG,DEFAULT_THREAD_STACK,

2056

UINT32_C(1024*512), (int64_t)SIZE_MAX, 0, 1024, 0},

3975

"The stack size for each thread.", (char**) &my_thread_stack_size,

3976

(char**) &my_thread_stack_size, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,

3977

1024L*128L, ULONG_MAX, 0, 1024, 0},

3978

{ "time_format", OPT_TIME_FORMAT,

3979

"The TIME format (for future).",

3980

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],

3981

(char**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],

3982

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

2057

3983

{"tmp_table_size", OPT_TMP_TABLE_SIZE,

2058

N_("If an internal in-memory temporary table exceeds this size, Drizzle will"

2059

" automatically convert it to an on-disk MyISAM table."),

3984

"If an internal in-memory temporary table exceeds this size, MySQL will"

3985

" automatically convert it to an on-disk MyISAM table.",

2060

3986

(char**) &global_system_variables.tmp_table_size,

2061

3987

(char**) &max_system_variables.tmp_table_size, 0, GET_ULL,

2062

REQUIRED_ARG, 16*1024*1024L, 1024, (int64_t)MAX_MEM_TABLE_SIZE, 0, 1, 0},

3988

REQUIRED_ARG, 16*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},

3989

{"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,

3990

"Allocation block size for transactions to be stored in binary log",

3991

(char**) &global_system_variables.trans_alloc_block_size,

3992

(char**) &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,

3993

REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},

3994

{"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,

3995

"Persistent buffer for transactions to be stored in binary log",

3996

(char**) &global_system_variables.trans_prealloc_size,

3997

(char**) &max_system_variables.trans_prealloc_size, 0, GET_ULONG,

3998

REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, ULONG_MAX, 0, 1024, 0},

3999

{"wait_timeout", OPT_WAIT_TIMEOUT,

4000

"The number of seconds the server waits for activity on a connection before closing it.",

4001

(char**) &global_system_variables.net_wait_timeout,

4002

(char**) &max_system_variables.net_wait_timeout, 0, GET_ULONG,

4003

REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT),

4004

0, 1, 0},

2063

4005

{0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}

2064

4006

};

2065

4007

4008

static int show_net_compression(THD *thd __attribute__((__unused__)),

4009

SHOW_VAR *var,

4010

char *buff __attribute__((__unused__)))

4011

{

4012

var->type= SHOW_MY_BOOL;

4013

var->value= (char *)&thd->net.compress;

4014

return 0;

4015

}

4016

4017

static st_show_var_func_container

4018

show_net_compression_cont= { &show_net_compression };

4019

4020

static int show_starttime(THD *thd, SHOW_VAR *var, char *buff)

4021

{

4022

var->type= SHOW_LONG;

4023

var->value= buff;

4024

*((long *)buff)= (long) (thd->query_start() - server_start_time);

4025

return 0;

4026

}

4027

4028

static st_show_var_func_container

4029

show_starttime_cont= { &show_starttime };

4030

4031

static int show_flushstatustime(THD *thd, SHOW_VAR *var, char *buff)

4032

{

4033

var->type= SHOW_LONG;

4034

var->value= buff;

4035

*((long *)buff)= (long) (thd->query_start() - flush_status_time);

4036

return 0;

4037

}

4038

4039

static st_show_var_func_container

4040

show_flushstatustime_cont= { &show_flushstatustime };

4041

4042

static int show_slave_running(THD *thd __attribute__((__unused__)),

4043

SHOW_VAR *var, char *buff)

4044

{

4045

var->type= SHOW_MY_BOOL;

4046

pthread_mutex_lock(&LOCK_active_mi);

4047

var->value= buff;

4048

*((my_bool *)buff)= (my_bool) (active_mi && active_mi->slave_running &&

4049

active_mi->rli.slave_running);

4050

pthread_mutex_unlock(&LOCK_active_mi);

4051

return 0;

4052

}

4053

4054

static st_show_var_func_container

4055

show_slave_running_cont= { &show_slave_running };

4056

4057

static int show_slave_retried_trans(THD *thd __attribute__((__unused__)),

4058

SHOW_VAR *var, char *buff)

4059

{

4060

4061

TODO: with multimaster, have one such counter per line in

4062

SHOW SLAVE STATUS, and have the sum over all lines here.

4063

4064

pthread_mutex_lock(&LOCK_active_mi);

4065

if (active_mi)

4066

{

4067

var->type= SHOW_LONG;

4068

var->value= buff;

4069

pthread_mutex_lock(&active_mi->rli.data_lock);

4070

*((long *)buff)= (long)active_mi->rli.retried_trans;

4071

pthread_mutex_unlock(&active_mi->rli.data_lock);

4072

}

4073

else

4074

var->type= SHOW_UNDEF;

4075

pthread_mutex_unlock(&LOCK_active_mi);

4076

return 0;

4077

}

4078

4079

static st_show_var_func_container

4080

show_slave_retried_trans_cont= { &show_slave_retried_trans };

4081

4082

static int show_slave_received_heartbeats(THD *thd __attribute__((__unused__)),

4083

SHOW_VAR *var, char *buff)

4084

{

4085

pthread_mutex_lock(&LOCK_active_mi);

4086

if (active_mi)

4087

{

4088

var->type= SHOW_LONGLONG;

4089

var->value= buff;

4090

pthread_mutex_lock(&active_mi->rli.data_lock);

4091

*((longlong *)buff)= active_mi->received_heartbeats;

4092

pthread_mutex_unlock(&active_mi->rli.data_lock);

4093

}

4094

else

4095

var->type= SHOW_UNDEF;

4096

pthread_mutex_unlock(&LOCK_active_mi);

4097

return 0;

4098

}

4099

4100

static st_show_var_func_container

4101

show_slave_received_heartbeats_cont= { &show_slave_received_heartbeats };

4102

4103

static int show_heartbeat_period(THD *thd __attribute__((__unused__)),

4104

SHOW_VAR *var, char *buff)

4105

{

4106

pthread_mutex_lock(&LOCK_active_mi);

4107

if (active_mi)

4108

{

4109

var->type= SHOW_CHAR;

4110

var->value= buff;

4111

my_sprintf(buff, (buff, "%.3f",active_mi->heartbeat_period));

4112

}

4113

else

4114

var->type= SHOW_UNDEF;

4115

pthread_mutex_unlock(&LOCK_active_mi);

4116

return 0;

4117

}

4118

4119

static st_show_var_func_container

4120

show_heartbeat_period_cont= { &show_heartbeat_period};

4121

4122

static int show_open_tables(THD *thd __attribute__((__unused__)),

4123

SHOW_VAR *var, char *buff)

4124

{

4125

var->type= SHOW_LONG;

4126

var->value= buff;

4127

*((long *)buff)= (long)cached_open_tables();

4128

return 0;

4129

}

4130

4131

static int show_table_definitions(THD *thd __attribute__((__unused__)),

4132

SHOW_VAR *var, char *buff)

4133

{

4134

var->type= SHOW_LONG;

4135

var->value= buff;

4136

*((long *)buff)= (long)cached_table_definitions();

4137

return 0;

4138

}

4139

4140

static st_show_var_func_container

4141

show_open_tables_cont= { &show_open_tables };

4142

static st_show_var_func_container

4143

show_table_definitions_cont= { &show_table_definitions };

4144

4145

4146

Variables shown by SHOW STATUS in alphabetical order

4147

4148

4149

SHOW_VAR status_vars[]= {

4150

{"Aborted_clients", (char*) &aborted_threads, SHOW_LONG},

4151

{"Aborted_connects", (char*) &aborted_connects, SHOW_LONG},

4152

{"Binlog_cache_disk_use", (char*) &binlog_cache_disk_use, SHOW_LONG},

4153

{"Binlog_cache_use", (char*) &binlog_cache_use, SHOW_LONG},

4154

{"Bytes_received", (char*) offsetof(STATUS_VAR, bytes_received), SHOW_LONGLONG_STATUS},

4155

{"Bytes_sent", (char*) offsetof(STATUS_VAR, bytes_sent), SHOW_LONGLONG_STATUS},

4156

{"Com", (char*) com_status_vars, SHOW_ARRAY},

4157

{"Compression", (char*) &show_net_compression_cont, SHOW_FUNC},

4158

{"Connections", (char*) &thread_id, SHOW_LONG_NOFLUSH},

4159

{"Created_tmp_disk_tables", (char*) offsetof(STATUS_VAR, created_tmp_disk_tables), SHOW_LONG_STATUS},

4160

{"Created_tmp_files", (char*) &my_tmp_file_created, SHOW_LONG},

4161

{"Created_tmp_tables", (char*) offsetof(STATUS_VAR, created_tmp_tables), SHOW_LONG_STATUS},

4162

{"Flush_commands", (char*) &refresh_version, SHOW_LONG_NOFLUSH},

4163

{"Handler_commit", (char*) offsetof(STATUS_VAR, ha_commit_count), SHOW_LONG_STATUS},

4164

{"Handler_delete", (char*) offsetof(STATUS_VAR, ha_delete_count), SHOW_LONG_STATUS},

4165

{"Handler_discover", (char*) offsetof(STATUS_VAR, ha_discover_count), SHOW_LONG_STATUS},

4166

{"Handler_prepare", (char*) offsetof(STATUS_VAR, ha_prepare_count), SHOW_LONG_STATUS},

4167

{"Handler_read_first", (char*) offsetof(STATUS_VAR, ha_read_first_count), SHOW_LONG_STATUS},

4168

{"Handler_read_key", (char*) offsetof(STATUS_VAR, ha_read_key_count), SHOW_LONG_STATUS},

4169

{"Handler_read_next", (char*) offsetof(STATUS_VAR, ha_read_next_count), SHOW_LONG_STATUS},

4170

{"Handler_read_prev", (char*) offsetof(STATUS_VAR, ha_read_prev_count), SHOW_LONG_STATUS},

4171

{"Handler_read_rnd", (char*) offsetof(STATUS_VAR, ha_read_rnd_count), SHOW_LONG_STATUS},

4172

{"Handler_read_rnd_next", (char*) offsetof(STATUS_VAR, ha_read_rnd_next_count), SHOW_LONG_STATUS},

4173

{"Handler_rollback", (char*) offsetof(STATUS_VAR, ha_rollback_count), SHOW_LONG_STATUS},

4174

{"Handler_savepoint", (char*) offsetof(STATUS_VAR, ha_savepoint_count), SHOW_LONG_STATUS},

4175

{"Handler_savepoint_rollback",(char*) offsetof(STATUS_VAR, ha_savepoint_rollback_count), SHOW_LONG_STATUS},

4176

{"Handler_update", (char*) offsetof(STATUS_VAR, ha_update_count), SHOW_LONG_STATUS},

4177

{"Handler_write", (char*) offsetof(STATUS_VAR, ha_write_count), SHOW_LONG_STATUS},

4178

{"Key_blocks_not_flushed", (char*) offsetof(KEY_CACHE, global_blocks_changed), SHOW_KEY_CACHE_LONG},

4179

{"Key_blocks_unused", (char*) offsetof(KEY_CACHE, blocks_unused), SHOW_KEY_CACHE_LONG},

4180

{"Key_blocks_used", (char*) offsetof(KEY_CACHE, blocks_used), SHOW_KEY_CACHE_LONG},

4181

{"Key_read_requests", (char*) offsetof(KEY_CACHE, global_cache_r_requests), SHOW_KEY_CACHE_LONGLONG},

4182

{"Key_reads", (char*) offsetof(KEY_CACHE, global_cache_read), SHOW_KEY_CACHE_LONGLONG},

4183

{"Key_write_requests", (char*) offsetof(KEY_CACHE, global_cache_w_requests), SHOW_KEY_CACHE_LONGLONG},

4184

{"Key_writes", (char*) offsetof(KEY_CACHE, global_cache_write), SHOW_KEY_CACHE_LONGLONG},

4185

{"Last_query_cost", (char*) offsetof(STATUS_VAR, last_query_cost), SHOW_DOUBLE_STATUS},

4186

{"Max_used_connections", (char*) &max_used_connections, SHOW_LONG},

4187

{"Open_files", (char*) &my_file_opened, SHOW_LONG_NOFLUSH},

4188

{"Open_streams", (char*) &my_stream_opened, SHOW_LONG_NOFLUSH},

4189

{"Open_table_definitions", (char*) &show_table_definitions_cont, SHOW_FUNC},

4190

{"Open_tables", (char*) &show_open_tables_cont, SHOW_FUNC},

4191

{"Opened_files", (char*) &my_file_total_opened, SHOW_LONG_NOFLUSH},

4192

{"Opened_tables", (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},

4193

{"Opened_table_definitions", (char*) offsetof(STATUS_VAR, opened_shares), SHOW_LONG_STATUS},

4194

{"Questions", (char*) offsetof(STATUS_VAR, questions), SHOW_LONG_STATUS},

4195

{"Select_full_join", (char*) offsetof(STATUS_VAR, select_full_join_count), SHOW_LONG_STATUS},

4196

{"Select_full_range_join", (char*) offsetof(STATUS_VAR, select_full_range_join_count), SHOW_LONG_STATUS},

4197

{"Select_range", (char*) offsetof(STATUS_VAR, select_range_count), SHOW_LONG_STATUS},

4198

{"Select_range_check", (char*) offsetof(STATUS_VAR, select_range_check_count), SHOW_LONG_STATUS},

4199

{"Select_scan", (char*) offsetof(STATUS_VAR, select_scan_count), SHOW_LONG_STATUS},

4200

{"Slave_open_temp_tables", (char*) &slave_open_temp_tables, SHOW_LONG},

4201

{"Slave_retried_transactions",(char*) &show_slave_retried_trans_cont, SHOW_FUNC},

4202

{"Slave_heartbeat_period", (char*) &show_heartbeat_period_cont, SHOW_FUNC},

4203

{"Slave_received_heartbeats",(char*) &show_slave_received_heartbeats_cont, SHOW_FUNC},

4204

{"Slave_running", (char*) &show_slave_running_cont, SHOW_FUNC},

4205

{"Slow_launch_threads", (char*) &slow_launch_threads, SHOW_LONG},

4206

{"Slow_queries", (char*) offsetof(STATUS_VAR, long_query_count), SHOW_LONG_STATUS},

4207

{"Sort_merge_passes", (char*) offsetof(STATUS_VAR, filesort_merge_passes), SHOW_LONG_STATUS},

4208

{"Sort_range", (char*) offsetof(STATUS_VAR, filesort_range_count), SHOW_LONG_STATUS},

4209

{"Sort_rows", (char*) offsetof(STATUS_VAR, filesort_rows), SHOW_LONG_STATUS},

4210

{"Sort_scan", (char*) offsetof(STATUS_VAR, filesort_scan_count), SHOW_LONG_STATUS},

4211

{"Table_locks_immediate", (char*) &locks_immediate, SHOW_LONG},

4212

{"Table_locks_waited", (char*) &locks_waited, SHOW_LONG},

4213

#ifdef HAVE_MMAP

4214

{"Tc_log_max_pages_used", (char*) &tc_log_max_pages_used, SHOW_LONG},

4215

{"Tc_log_page_size", (char*) &tc_log_page_size, SHOW_LONG},

4216

{"Tc_log_page_waits", (char*) &tc_log_page_waits, SHOW_LONG},

4217

#endif

4218

{"Threads_cached", (char*) &cached_thread_count, SHOW_LONG_NOFLUSH},

4219

{"Threads_connected", (char*) &connection_count, SHOW_INT},

4220

{"Threads_created", (char*) &thread_created, SHOW_LONG_NOFLUSH},

4221

{"Threads_running", (char*) &thread_running, SHOW_INT},

4222

{"Uptime", (char*) &show_starttime_cont, SHOW_FUNC},

4223

{"Uptime_since_flush_status",(char*) &show_flushstatustime_cont, SHOW_FUNC},

4224

{NullS, NullS, SHOW_LONG}

4225

};

4226

2066

4227

static void print_version(void)

2067

4228

{

4229

set_server_version();

2068

4230

2069

4231

Note: the instance manager keys off the string 'Ver' so it can find the

2070

version from the output of 'drizzled --version', so don't change it!

4232

version from the output of 'mysqld --version', so don't change it!

2071

4233

2072

printf("%s Ver %s for %s-%s on %s (%s)\n",internal::my_progname,

2073

PANDORA_RELEASE_VERSION, HOST_VENDOR, HOST_OS, HOST_CPU,

2074

COMPILATION_COMMENT);

4234

printf("%s Ver %s for %s on %s (%s)\n",my_progname,

4235

server_version,SYSTEM_TYPE,MACHINE_TYPE, MYSQL_COMPILATION_COMMENT);

2075

4236

}

2076

4237

2077

4238

static void usage(void)

2078

4239

{

2079

if (!(default_charset_info= get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

4240

if (!(default_charset_info= get_charset_by_csname(default_character_set_name,

4241

MY_CS_PRIMARY,

4242

MYF(MY_WME))))

2080

4243

exit(1);

2081

4244

if (!default_collation_name)

2082

4245

default_collation_name= (char*) default_charset_info->name;

2083

4246

print_version();

2084

2085

"This software comes with ABSOLUTELY NO WARRANTY. "

2086

"This is free software,\n"

2087

"and you are welcome to modify and redistribute it under the GPL "

2088

"license\n\n"));

2089

2090

2091

printf(_("Usage: %s [OPTIONS]\n"), internal::my_progname);

2092

2093

po::options_description all_options("Drizzled Options");

2094

all_options.add(config_options);

2095

all_options.add(plugin_load_options);

2096

all_options.add(long_options);

2097

all_options.add(plugin_options);

2098

cout << all_options << endl;

2099

4247

puts("\

4248

4249

This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\

4250

and you are welcome to modify and redistribute it under the GPL license\n\n\

4251

Starts the MySQL database server\n");

4252

4253

printf("Usage: %s [OPTIONS]\n", my_progname);

4254

if (!opt_verbose)

4255

puts("\nFor more help options (several pages), use mysqld --verbose --help");

4256

else

4257

{

4258

print_defaults(MYSQL_CONFIG_NAME,load_default_groups);

4259

puts("");

4260

set_ports();

4261

4262

/* Print out all the options including plugin supplied options */

4263

my_print_help_inc_plugins(my_long_options, sizeof(my_long_options)/sizeof(my_option));

4264

4265

puts("\n\

4266

To see what values a running MySQL server is using, type\n\

4267

'mysqladmin variables' instead of 'mysqld --verbose --help'.");

4268

}

2100

4269

}

2101

4270

4271

2102

4272

/**

2103

Initialize all Drizzle global variables to default values.

4273

Initialize all MySQL global variables to default values.

2104

4274

2105

4275

We don't need to set numeric variables refered to in my_long_options

2106

4276

as these are initialized by my_getopt.

2115

4285

as these are initialized by my_getopt.

2116

4286

2117

4287

2118

static void drizzle_init_variables(void)

4288

static void mysql_init_variables(void)

2119

4289

{

2120

4290

/* Things reset to zero */

4291

opt_skip_slave_start= opt_reckless_slave = 0;

4292

mysql_home[0]= pidfile_name[0]= log_error_file[0]= 0;

4293

opt_log= opt_slow_log= 0;

4294

log_output_options= find_bit_type(log_output_str, &log_output_typelib);

4295

opt_bin_log= 0;

4296

opt_disable_networking= opt_skip_show_db=0;

4297

opt_logname= opt_binlog_index_name= opt_slow_logname= 0;

2121

4298

opt_tc_log_file= (char *)"tc.log"; // no hostname in tc_log file name !

4299

opt_secure_auth= 0;

4300

opt_secure_file_priv= 0;

4301

opt_bootstrap= opt_myisam_log= 0;

4302

mqh_used= 0;

4303

segfaulted= kill_in_progress= 0;

2122

4304

cleanup_done= 0;

2123

dropping_tables= ha_open_options=0;

2124

test_flags.reset();

2125

wake_thread=0;

2126

abort_loop= select_thread_in_use= false;

4305

defaults_argc= 0;

4306

defaults_argv= 0;

4307

server_id_supplied= 0;

4308

test_flags= select_errors= dropping_tables= ha_open_options=0;

4309

thread_count= thread_running= kill_cached_threads= wake_thread=0;

4310

slave_open_temp_tables= 0;

4311

cached_thread_count= 0;

4312

opt_endinfo= using_udf_functions= 0;

4313

opt_using_transactions= using_update_log= 0;

4314

abort_loop= select_thread_in_use= signal_thread_in_use= 0;

2127

4315

ready_to_exit= shutdown_in_progress= 0;

2128

drizzled_user= drizzled_chroot= 0;

2129

memset(&current_global_counters, 0, sizeof(current_global_counters));

2130

key_map_full.set();

4316

aborted_threads= aborted_connects= 0;

4317

specialflag= 0;

4318

binlog_cache_use= binlog_cache_disk_use= 0;

4319

max_used_connections= slow_launch_threads = 0;

4320

mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;

4321

errmesg= 0;

4322

opt_mysql_tmpdir= my_bind_addr_str= NullS;

4323

bzero((uchar*) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));

4324

bzero((char *) &global_status_var, sizeof(global_status_var));

4325

key_map_full.set_all();

2131

4326

2132

4327

/* Character sets */

2133

4328

system_charset_info= &my_charset_utf8_general_ci;

2134

4329

files_charset_info= &my_charset_utf8_general_ci;

4330

national_charset_info= &my_charset_utf8_general_ci;

2135

4331

table_alias_charset= &my_charset_bin;

2136

4332

character_set_filesystem= &my_charset_bin;

2137

4333

4334

opt_date_time_formats[0]= opt_date_time_formats[1]= opt_date_time_formats[2]= 0;

4335

2138

4336

/* Things with default values that are not zero */

2139

session_startup_options= (OPTION_AUTO_IS_NULL | OPTION_SQL_NOTES);

4337

delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;

4338

slave_exec_mode_options= 0;

4339

slave_exec_mode_options= (uint)

4340

find_bit_type_or_exit(slave_exec_mode_str, &slave_exec_mode_typelib, NULL);

4341

opt_specialflag= SPECIAL_ENGLISH;

4342

ip_sock= INVALID_SOCKET;

4343

mysql_home_ptr= mysql_home;

4344

pidfile_name_ptr= pidfile_name;

4345

log_error_file_ptr= log_error_file;

4346

language_ptr= language;

4347

mysql_data_home= mysql_real_data_home;

4348

thd_startup_options= (OPTION_AUTO_IS_NULL | OPTION_BIN_LOG |

4349

OPTION_QUOTE_SHOW_CREATE | OPTION_SQL_NOTES);

4350

protocol_version= PROTOCOL_VERSION;

4351

what_to_log= ~ (1L << (uint) COM_TIME);

2140

4352

refresh_version= 1L; /* Increments on each reload */

2141

global_thread_id= 1UL;

2142

session::Cache::singleton().getCache().clear();

4353

global_query_id= thread_id= 1L;

4354

strmov(server_version, MYSQL_SERVER_VERSION);

4355

myisam_recover_options_str= "OFF";

4356

myisam_stats_method_str= "nulls_unequal";

4357

threads.empty();

4358

thread_cache.empty();

4359

key_caches.empty();

4360

if (!(dflt_key_cache= get_or_create_key_cache(default_key_cache_base.str,

4361

default_key_cache_base.length)))

4362

exit(1);

4363

/* set key_cache_hash.default_value = dflt_key_cache */

4364

multi_keycache_init();

4365

4366

/* Set directory paths */

4367

strmake(language, LANGUAGE, sizeof(language)-1);

4368

strmake(mysql_real_data_home, get_relative_path(DATADIR),

4369

sizeof(mysql_real_data_home)-1);

4370

mysql_data_home_buff[0]=FN_CURLIB; // all paths are relative from here

4371

mysql_data_home_buff[1]=0;

4372

mysql_data_home_len= 2;

4373

4374

/* Replication parameters */

4375

master_info_file= (char*) "master.info",

4376

relay_log_info_file= (char*) "relay-log.info";

4377

report_user= report_password = report_host= 0; /* TO BE DELETED */

4378

opt_relay_logname= opt_relaylog_index_name= 0;

2143

4379

2144

4380

/* Variables in libraries */

2145

default_character_set_name= "utf8";

2146

default_collation_name= (char *)compiled_default_collation_name;

2147

character_set_filesystem_name= "binary";

4381

charsets_dir= 0;

4382

default_character_set_name= (char*) MYSQL_DEFAULT_CHARSET_NAME;

4383

default_collation_name= compiled_default_collation_name;

4384

sys_charset_system.set((char*) system_charset_info->csname);

4385

character_set_filesystem_name= (char*) "binary";

2148

4386

lc_time_names_name= (char*) "en_US";

2149

4387

/* Set default values for some option variables */

2150

default_storage_engine_str= (char*) "innodb";

2151

global_system_variables.storage_engine= NULL;

4388

default_storage_engine_str= (char*) "MyISAM";

4389

global_system_variables.table_plugin= NULL;

2152

4390

global_system_variables.tx_isolation= ISO_REPEATABLE_READ;

2153

global_system_variables.select_limit= (uint64_t) HA_POS_ERROR;

2154

max_system_variables.select_limit= (uint64_t) HA_POS_ERROR;

2155

global_system_variables.max_join_size= (uint64_t) HA_POS_ERROR;

2156

max_system_variables.max_join_size= (uint64_t) HA_POS_ERROR;

2157

max_system_variables.auto_increment_increment= UINT64_MAX;

2158

max_system_variables.auto_increment_offset= UINT64_MAX;

2159

max_system_variables.completion_type= 2;

2160

max_system_variables.log_warnings= true;

2161

max_system_variables.bulk_insert_buff_size= ULONG_MAX;

2162

max_system_variables.div_precincrement= DECIMAL_MAX_SCALE;

2163

max_system_variables.group_concat_max_len= ULONG_MAX;

2164

max_system_variables.join_buff_size= ULONG_MAX;

2165

max_system_variables.max_allowed_packet= 1024L*1024L*1024L;

2166

max_system_variables.max_error_count= 65535;

2167

max_system_variables.max_heap_table_size= MAX_MEM_TABLE_SIZE;

2168

max_system_variables.max_join_size= INT32_MAX;

2169

max_system_variables.max_length_for_sort_data= 8192*1024L;

2170

max_system_variables.max_seeks_for_key= ULONG_MAX;

2171

max_system_variables.max_sort_length= 8192*1024L;

2172

max_system_variables.min_examined_row_limit= ULONG_MAX;

2173

max_system_variables.optimizer_prune_level= 1;

2174

max_system_variables.optimizer_search_depth= MAX_TABLES+2;

2175

max_system_variables.preload_buff_size= 1024*1024*1024L;

2176

max_system_variables.query_alloc_block_size= UINT32_MAX;

2177

max_system_variables.query_prealloc_size= UINT32_MAX;

2178

max_system_variables.range_alloc_block_size= SIZE_MAX;

2179

max_system_variables.read_buff_size= INT32_MAX;

2180

max_system_variables.read_rnd_buff_size= UINT32_MAX;

2181

max_system_variables.sortbuff_size= SIZE_MAX;

2182

max_system_variables.tmp_table_size= MAX_MEM_TABLE_SIZE;

2183

2184

opt_scheduler_default= (char*) "multi_thread";

4391

global_system_variables.select_limit= (ulonglong) HA_POS_ERROR;

4392

max_system_variables.select_limit= (ulonglong) HA_POS_ERROR;

4393

global_system_variables.max_join_size= (ulonglong) HA_POS_ERROR;

4394

max_system_variables.max_join_size= (ulonglong) HA_POS_ERROR;

4395

global_system_variables.old_alter_table= 0;

4396

global_system_variables.binlog_format= BINLOG_FORMAT_UNSPEC;

4397

4398

Default behavior for 4.1 and 5.0 is to treat NULL values as unequal

4399

when collecting index statistics for MyISAM tables.

4400

4401

global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;

2185

4402

2186

4403

/* Variables that depends on compile options */

4404

opt_error_log= IF_WIN(1,0);

2187

4405

#ifdef HAVE_BROKEN_REALPATH

2188

4406

have_symlink=SHOW_OPTION_NO;

2189

4407

#else

2190

4408

have_symlink=SHOW_OPTION_YES;

2191

4409

#endif

4410

#ifdef HAVE_DLOPEN

4411

have_dlopen=SHOW_OPTION_YES;

4412

#else

4413

have_dlopen=SHOW_OPTION_NO;

4414

#endif

4415

#ifdef HAVE_CRYPT

4416

have_crypt=SHOW_OPTION_YES;

4417

#else

4418

have_crypt=SHOW_OPTION_NO;

4419

#endif

4420

#ifdef HAVE_COMPRESS

4421

have_compress= SHOW_OPTION_YES;

4422

#else

4423

have_compress= SHOW_OPTION_NO;

4424

#endif

2192

4425

2193

connection_count= 0;

4426

const char *tmpenv;

4427

if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))

4428

tmpenv = DEFAULT_MYSQL_HOME;

4429

(void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);

2194

4430

}

2195

4431

2196

4432

2197

/**

2198

@todo

2199

- FIXME add EXIT_TOO_MANY_ARGUMENTS to "drizzled/error.h" and return that code?

2200

2201

static void get_options()

4433

my_bool

4434

mysqld_get_one_option(int optid,

4435

const struct my_option *opt __attribute__((unused)),

4436

char *argument)

2202

4437

{

2203

2204

fs::path &data_home_catalog= getDataHomeCatalog();

2205

data_home_catalog= getDataHome();

2206

data_home_catalog /= "local";

2207

2208

if (vm.count("user"))

2209

{

2210

if (! drizzled_user || ! strcmp(drizzled_user, vm["user"].as<string>().c_str()))

2211

drizzled_user= (char *)vm["user"].as<string>().c_str();

2212

4438

switch(optid) {

4439

case '#':

4440

opt_endinfo=1; /* unireg: memory allocation */

4441

break;

4442

case 'a':

4443

global_system_variables.tx_isolation= ISO_SERIALIZABLE;

4444

break;

4445

case 'b':

4446

strmake(mysql_home,argument,sizeof(mysql_home)-1);

4447

break;

4448

case 'C':

4449

if (default_collation_name == compiled_default_collation_name)

4450

default_collation_name= 0;

4451

break;

4452

case 'l':

4453

opt_log=1;

4454

break;

4455

case 'h':

4456

strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);

4457

/* Correct pointer set by my_getopt (for embedded library) */

4458

mysql_data_home= mysql_real_data_home;

4459

mysql_data_home_len= strlen(mysql_data_home);

4460

break;

4461

case 'u':

4462

if (!mysqld_user || !strcmp(mysqld_user, argument))

4463

mysqld_user= argument;

2213

4464

else

2214

errmsg_printf(ERRMSG_LVL_WARN, _("Ignoring user change to '%s' because the user was "

2215

"set to '%s' earlier on the command line\n"),

2216

vm["user"].as<string>().c_str(), drizzled_user);

2217

}

2218

2219

if (vm.count("version"))

2220

{

4465

sql_print_warning("Ignoring user change to '%s' because the user was set to '%s' earlier on the command line\n", argument, mysqld_user);

4466

break;

4467

case 'L':

4468

strmake(language, argument, sizeof(language)-1);

4469

break;

4470

case OPT_SLAVE_SKIP_ERRORS:

4471

init_slave_skip_errors(argument);

4472

break;

4473

case OPT_SLAVE_EXEC_MODE:

4474

slave_exec_mode_options= (uint)

4475

find_bit_type_or_exit(argument, &slave_exec_mode_typelib, "");

4476

break;

4477

case 'V':

2221

4478

print_version();

2222

4479

exit(0);

2223

}

2224

2225

if (vm.count("sort-heap-threshold"))

2226

{

2227

if ((vm["sort-heap-threshold"].as<uint64_t>() > 0) and

2228

(vm["sort-heap-threshold"].as<uint64_t>() <

2229

global_system_variables.sortbuff_size))

2230

{

2231

cout << N_("Error: sort-heap-threshold cannot be less than sort-buffer-size") << endl;

2232

exit(-1);

2233

}

2234

2235

global_sort_buffer.setMaxSize(vm["sort-heap-threshold"].as<uint64_t>());

2236

}

2237

2238

if (vm.count("join-heap-threshold"))

2239

{

2240

if ((vm["join-heap-threshold"].as<uint64_t>() > 0) and

2241

(vm["join-heap-threshold"].as<uint64_t>() <

2242

global_system_variables.join_buff_size))

2243

{

2244

cout << N_("Error: join-heap-threshold cannot be less than join-buffer-size") << endl;

2245

exit(-1);

2246

}

2247

2248

global_join_buffer.setMaxSize(vm["join-heap-threshold"].as<uint64_t>());

2249

}

2250

2251

if (vm.count("read-rnd-threshold"))

2252

{

2253

if ((vm["read-rnd-threshold"].as<uint64_t>() > 0) and

2254

(vm["read-rnd-threshold"].as<uint64_t>() <

2255

global_system_variables.read_rnd_buff_size))

2256

{

2257

cout << N_("Error: read-rnd-threshold cannot be less than read-rnd-buffer-size") << endl;

2258

exit(-1);

2259

}

2260

2261

global_read_rnd_buffer.setMaxSize(vm["read-rnd-threshold"].as<uint64_t>());

2262

}

2263

2264

if (vm.count("read-buffer-threshold"))

2265

{

2266

if ((vm["read-buffer-threshold"].as<uint64_t>() > 0) and

2267

(vm["read-buffer-threshold"].as<uint64_t>() <

2268

global_system_variables.read_buff_size))

2269

{

2270

cout << N_("Error: read-buffer-threshold cannot be less than read-buffer-size") << endl;

2271

exit(-1);

2272

}

2273

2274

global_read_buffer.setMaxSize(vm["read-buffer-threshold"].as<uint64_t>());

2275

}

2276

2277

if (vm.count("exit-info"))

2278

{

2279

if (vm["exit-info"].as<long>())

2280

{

2281

test_flags.set((uint32_t) vm["exit-info"].as<long>());

2282

}

2283

}

2284

2285

if (vm.count("want-core"))

2286

{

2287

test_flags.set(TEST_CORE_ON_SIGNAL);

2288

}

2289

2290

if (vm.count("skip-stack-trace"))

2291

{

2292

test_flags.set(TEST_NO_STACKTRACE);

2293

}

2294

2295

if (vm.count("skip-symlinks"))

2296

{

2297

internal::my_use_symdir=0;

2298

}

2299

2300

if (vm.count("transaction-isolation"))

4480

case 'W':

4481

if (!argument)

4482

global_system_variables.log_warnings++;

4483

else if (argument == disabled_my_option)

4484

global_system_variables.log_warnings= 0L;

4485

else

4486

global_system_variables.log_warnings= atoi(argument);

4487

break;

4488

case 'T':

4489

test_flags= argument ? (uint) atoi(argument) : 0;

4490

opt_endinfo=1;

4491

break;

4492

case (int) OPT_BIG_TABLES:

4493

thd_startup_options|=OPTION_BIG_TABLES;

4494

break;

4495

case (int) OPT_ISAM_LOG:

4496

opt_myisam_log=1;

4497

break;

4498

case (int) OPT_BIN_LOG:

4499

opt_bin_log= test(argument != disabled_my_option);

4500

break;

4501

case (int) OPT_ERROR_LOG_FILE:

4502

opt_error_log= 1;

4503

break;

4504

case (int)OPT_REPLICATE_IGNORE_DB:

4505

{

4506

rpl_filter->add_ignore_db(argument);

4507

break;

4508

}

4509

case (int)OPT_REPLICATE_DO_DB:

4510

{

4511

rpl_filter->add_do_db(argument);

4512

break;

4513

}

4514

case (int)OPT_REPLICATE_REWRITE_DB:

4515

{

4516

char* key = argument,*p, *val;

4517

4518

if (!(p= strstr(argument, "->")))

4519

{

4520

fprintf(stderr,

4521

"Bad syntax in replicate-rewrite-db - missing '->'!\n");

4522

exit(1);

4523

}

4524

val= p--;

4525

while (my_isspace(mysqld_charset, *p) && p > argument)

4526

*p-- = 0;

4527

if (p == argument)

4528

{

4529

fprintf(stderr,

4530

"Bad syntax in replicate-rewrite-db - empty FROM db!\n");

4531

exit(1);

4532

}

4533

*val= 0;

4534

val+= 2;

4535

while (*val && my_isspace(mysqld_charset, *val))

4536

*val++;

4537

if (!*val)

4538

{

4539

fprintf(stderr,

4540

"Bad syntax in replicate-rewrite-db - empty TO db!\n");

4541

exit(1);

4542

}

4543

4544

rpl_filter->add_db_rewrite(key, val);

4545

break;

4546

}

4547

4548

case (int)OPT_BINLOG_IGNORE_DB:

4549

{

4550

binlog_filter->add_ignore_db(argument);

4551

break;

4552

}

4553

case OPT_BINLOG_FORMAT:

4554

{

4555

int id;

4556

id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);

4557

global_system_variables.binlog_format= opt_binlog_format_id= id - 1;

4558

break;

4559

}

4560

case (int)OPT_BINLOG_DO_DB:

4561

{

4562

binlog_filter->add_do_db(argument);

4563

break;

4564

}

4565

case (int)OPT_REPLICATE_DO_TABLE:

4566

{

4567

if (rpl_filter->add_do_table(argument))

4568

{

4569

fprintf(stderr, "Could not add do table rule '%s'!\n", argument);

4570

exit(1);

4571

}

4572

break;

4573

}

4574

case (int)OPT_REPLICATE_WILD_DO_TABLE:

4575

{

4576

if (rpl_filter->add_wild_do_table(argument))

4577

{

4578

fprintf(stderr, "Could not add do table rule '%s'!\n", argument);

4579

exit(1);

4580

}

4581

break;

4582

}

4583

case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:

4584

{

4585

if (rpl_filter->add_wild_ignore_table(argument))

4586

{

4587

fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);

4588

exit(1);

4589

}

4590

break;

4591

}

4592

case (int)OPT_REPLICATE_IGNORE_TABLE:

4593

{

4594

if (rpl_filter->add_ignore_table(argument))

4595

{

4596

fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);

4597

exit(1);

4598

}

4599

break;

4600

}

4601

case (int) OPT_SLOW_QUERY_LOG:

4602

opt_slow_log= 1;

4603

break;

4604

#ifdef WITH_CSV_STORAGE_ENGINE

4605

case OPT_LOG_OUTPUT:

4606

{

4607

if (!argument || !argument[0])

4608

{

4609

log_output_options= LOG_FILE;

4610

log_output_str= log_output_typelib.type_names[1];

4611

}

4612

else

4613

{

4614

log_output_str= argument;

4615

log_output_options=

4616

find_bit_type_or_exit(argument, &log_output_typelib, opt->name);

4617

}

4618

break;

4619

}

4620

#endif

4621

case (int) OPT_SKIP_NEW:

4622

opt_specialflag|= SPECIAL_NO_NEW_FUNC;

4623

delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;

4624

myisam_concurrent_insert=0;

4625

myisam_recover_options= HA_RECOVER_NONE;

4626

my_use_symdir=0;

4627

ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);

4628

break;

4629

case (int) OPT_SAFE:

4630

opt_specialflag|= SPECIAL_SAFE_MODE;

4631

delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;

4632

myisam_recover_options= HA_RECOVER_DEFAULT;

4633

ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);

4634

break;

4635

case (int) OPT_SKIP_PRIOR:

4636

opt_specialflag|= SPECIAL_NO_PRIOR;

4637

break;

4638

case (int) OPT_SKIP_LOCK:

4639

opt_external_locking=0;

4640

break;

4641

case (int) OPT_SKIP_SHOW_DB:

4642

opt_skip_show_db=1;

4643

opt_specialflag|=SPECIAL_SKIP_SHOW_DB;

4644

break;

4645

case (int) OPT_WANT_CORE:

4646

test_flags |= TEST_CORE_ON_SIGNAL;

4647

break;

4648

case (int) OPT_SKIP_STACK_TRACE:

4649

test_flags|=TEST_NO_STACKTRACE;

4650

break;

4651

case (int) OPT_SKIP_SYMLINKS:

4652

my_use_symdir=0;

4653

break;

4654

case (int) OPT_BIND_ADDRESS:

4655

{

4656

struct addrinfo *res_lst, hints;

4657

4658

bzero(&hints, sizeof(struct addrinfo));

4659

hints.ai_socktype= SOCK_STREAM;

4660

hints.ai_protocol= IPPROTO_TCP;

4661

4662

if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0)

4663

{

4664

sql_print_error("Can't start server: cannot resolve hostname!");

4665

exit(1);

4666

}

4667

4668

if (res_lst->ai_next)

4669

{

4670

sql_print_error("Can't start server: bind-address refers to multiple interfaces!");

4671

exit(1);

4672

}

4673

freeaddrinfo(res_lst);

4674

}

4675

break;

4676

case (int) OPT_PID_FILE:

4677

strmake(pidfile_name, argument, sizeof(pidfile_name)-1);

4678

break;

4679

case OPT_CONSOLE:

4680

if (opt_console)

4681

opt_error_log= 0; // Force logs to stdout

4682

break;

4683

case (int) OPT_FLUSH:

4684

myisam_flush=1;

4685

flush_time=0; // No auto flush

4686

break;

4687

case OPT_LOW_PRIORITY_UPDATES:

4688

thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;

4689

global_system_variables.low_priority_updates=1;

4690

break;

4691

case OPT_BOOTSTRAP:

4692

opt_noacl=opt_bootstrap=1;

4693

break;

4694

case OPT_SERVER_ID:

4695

server_id_supplied = 1;

4696

break;

4697

case OPT_DELAY_KEY_WRITE_ALL:

4698

if (argument != disabled_my_option)

4699

argument= (char*) "ALL";

4700

/* Fall through */

4701

case OPT_DELAY_KEY_WRITE:

4702

if (argument == disabled_my_option)

4703

delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;

4704

else if (! argument)

4705

delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;

4706

else

4707

{

4708

int type;

4709

type= find_type_or_exit(argument, &delay_key_write_typelib, opt->name);

4710

delay_key_write_options= (uint) type-1;

4711

}

4712

break;

4713

case OPT_CHARSETS_DIR:

4714

strmake(mysql_charsets_dir, argument, sizeof(mysql_charsets_dir)-1);

4715

charsets_dir = mysql_charsets_dir;

4716

break;

4717

case OPT_TX_ISOLATION:

2301

4718

{

2302

4719

int type;

2303

type= find_type_or_exit((char *)vm["transaction-isolation"].as<string>().c_str(), &tx_isolation_typelib, "transaction-isolation");

4720

type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);

2304

4721

global_system_variables.tx_isolation= (type-1);

2305

}

2306

2307

/* @TODO Make this all strings */

2308

if (vm.count("default-storage-engine"))

2309

{

2310

default_storage_engine_str= (char *)vm["default-storage-engine"].as<string>().c_str();

2311

}

4722

break;

4723

}

4724

case OPT_MYISAM_RECOVER:

4725

{

4726

if (!argument)

4727

{

4728

myisam_recover_options= HA_RECOVER_DEFAULT;

4729

myisam_recover_options_str= myisam_recover_typelib.type_names[0];

4730

}

4731

else if (!argument[0])

4732

{

4733

myisam_recover_options= HA_RECOVER_NONE;

4734

myisam_recover_options_str= "OFF";

4735

}

4736

else

4737

{

4738

myisam_recover_options_str=argument;

4739

myisam_recover_options=

4740

find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);

4741

}

4742

ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;

4743

break;

4744

}

4745

case OPT_TC_HEURISTIC_RECOVER:

4746

tc_heuristic_recover= find_type_or_exit(argument,

4747

&tc_heuristic_recover_typelib,

4748

opt->name);

4749

break;

4750

case OPT_MYISAM_STATS_METHOD:

4751

{

4752

ulong method_conv;

4753

int method;

4754

4755

myisam_stats_method_str= argument;

4756

method= find_type_or_exit(argument, &myisam_stats_method_typelib,

4757

opt->name);

4758

switch (method-1) {

4759

case 2:

4760

method_conv= MI_STATS_METHOD_IGNORE_NULLS;

4761

break;

4762

case 1:

4763

method_conv= MI_STATS_METHOD_NULLS_EQUAL;

4764

break;

4765

case 0:

4766

default:

4767

method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;

4768

break;

4769

}

4770

global_system_variables.myisam_stats_method= method_conv;

4771

break;

4772

}

4773

case OPT_LOWER_CASE_TABLE_NAMES:

4774

lower_case_table_names= argument ? atoi(argument) : 1;

4775

lower_case_table_names_used= 1;

4776

break;

4777

}

4778

return 0;

4779

}

4780

4781

4782

/** Handle arguments for multiple key caches. */

4783

4784

extern "C" char **mysql_getopt_value(const char *keyname, uint key_length,

4785

const struct my_option *option);

4786

4787

char**

4788

mysql_getopt_value(const char *keyname, uint key_length,

4789

const struct my_option *option)

4790

{

4791

switch (option->id) {

4792

case OPT_KEY_BUFFER_SIZE:

4793

case OPT_KEY_CACHE_BLOCK_SIZE:

4794

case OPT_KEY_CACHE_DIVISION_LIMIT:

4795

case OPT_KEY_CACHE_AGE_THRESHOLD:

4796

{

4797

KEY_CACHE *key_cache;

4798

if (!(key_cache= get_or_create_key_cache(keyname, key_length)))

4799

exit(1);

4800

switch (option->id) {

4801

case OPT_KEY_BUFFER_SIZE:

4802

return (char**) &key_cache->param_buff_size;

4803

case OPT_KEY_CACHE_BLOCK_SIZE:

4804

return (char**) &key_cache->param_block_size;

4805

case OPT_KEY_CACHE_DIVISION_LIMIT:

4806

return (char**) &key_cache->param_division_limit;

4807

case OPT_KEY_CACHE_AGE_THRESHOLD:

4808

return (char**) &key_cache->param_age_threshold;

4809

}

4810

}

4811

}

4812

return (char **)option->value;

4813

}

4814

4815

4816

extern "C" void option_error_reporter(enum loglevel level, const char *format, ...);

4817

4818

void option_error_reporter(enum loglevel level, const char *format, ...)

4819

{

4820

va_list args;

4821

va_start(args, format);

4822

4823

/* Don't print warnings for --loose options during bootstrap */

4824

if (level == ERROR_LEVEL || !opt_bootstrap ||

4825

global_system_variables.log_warnings)

4826

{

4827

vprint_msg_to_log(level, format, args);

4828

}

4829

va_end(args);

4830

}

4831

4832

4833

/**

4834

@todo

4835

- FIXME add EXIT_TOO_MANY_ARGUMENTS to "mysys_err.h" and return that code?

4836

4837

static void get_options(int *argc,char **argv)

4838

{

4839

int ho_error;

4840

4841

my_getopt_register_get_addr(mysql_getopt_value);

4842

my_getopt_error_reporter= option_error_reporter;

2312

4843

2313

4844

/* Skip unknown options so that they may be processed later by plugins */

2314

my_getopt_skip_unknown= true;

2315

4845

my_getopt_skip_unknown= TRUE;

4846

4847

if ((ho_error= handle_options(argc, &argv, my_long_options,

4848

mysqld_get_one_option)))

4849

exit(ho_error);

4850

(*argc)++; /* add back one for the progname handle_options removes */

4851

/* no need to do this for argv as we are discarding it. */

4852

4853

if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes ||

4854

opt_log_slow_slave_statements) &&

4855

!opt_slow_log)

4856

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");

2316

4857

2317

4858

#if defined(HAVE_BROKEN_REALPATH)

2318

internal::my_use_symdir=0;

2319

internal::my_disable_symlinks=1;

4859

my_use_symdir=0;

4860

my_disable_symlinks=1;

2320

4861

have_symlink=SHOW_OPTION_NO;

2321

4862

#else

2322

if (!internal::my_use_symdir)

4863

if (!my_use_symdir)

2323

4864

{

2324

internal::my_disable_symlinks=1;

4865

my_disable_symlinks=1;

2325

4866

have_symlink=SHOW_OPTION_DISABLED;

2326

4867

}

2327

4868

#endif

2328

4869

if (opt_debugging)

2329

4870

{

2330

4871

/* Allow break with SIGINT, no core or stack trace */

2331

test_flags.set(TEST_SIGINT);

2332

test_flags.set(TEST_NO_STACKTRACE);

2333

test_flags.reset(TEST_CORE_ON_SIGNAL);

4872

test_flags|= TEST_SIGINT | TEST_NO_STACKTRACE;

4873

test_flags&= ~TEST_CORE_ON_SIGNAL;

2334

4874

}

4875

/* Set global MyISAM variables from delay_key_write_options */

4876

fix_delay_key_write((THD*) 0, OPT_GLOBAL);

4877

/* Set global slave_exec_mode from its option */

4878

fix_slave_exec_mode(OPT_GLOBAL);

2335

4879

2336

if (drizzled_chroot)

2337

set_root(drizzled_chroot);

4880

if (mysqld_chroot)

4881

set_root(mysqld_chroot);

4882

fix_paths();

2338

4883

2339

4884

2340

4885

Set some global variables from the global_system_variables

2341

4886

In most cases the global variables will not be used

2342

4887

2343

internal::my_default_record_cache_size=global_system_variables.read_buff_size;

2344

}

2345

2346

2347

static void fix_paths()

2348

{

2349

fs::path pid_file_path(pid_file);

2350

if (pid_file_path.root_path().string() == "")

2351

{

2352

pid_file_path= getDataHome();

2353

pid_file_path /= pid_file;

2354

}

2355

pid_file= fs::system_complete(pid_file_path);

2356

2357

if (not opt_help)

2358

{

2359

const char *tmp_string= getenv("TMPDIR") ? getenv("TMPDIR") : NULL;

2360

struct stat buf;

2361

drizzle_tmpdir.clear();

2362

2363

if (vm.count("tmpdir"))

2364

{

2365

drizzle_tmpdir.append(vm["tmpdir"].as<string>());

2366

}

2367

else if (tmp_string == NULL)

2368

{

2369

drizzle_tmpdir.append(getDataHome().file_string());

2370

drizzle_tmpdir.push_back(FN_LIBCHAR);

2371

drizzle_tmpdir.append(GLOBAL_TEMPORARY_EXT);

2372

}

4888

my_disable_locking= myisam_single_user= test(opt_external_locking == 0);

4889

my_default_record_cache_size=global_system_variables.read_buff_size;

4890

myisam_max_temp_length=

4891

(my_off_t) global_system_variables.myisam_max_sort_file_size;

4892

4893

/* Set global variables based on startup options */

4894

myisam_block_size=(uint) 1 << my_bit_log2(opt_myisam_block_size);

4895

4896

/* long_query_time is in microseconds */

4897

global_system_variables.long_query_time= max_system_variables.long_query_time=

4898

(longlong) (long_query_time * 1000000.0);

4899

4900

if (opt_short_log_format)

4901

opt_specialflag|= SPECIAL_SHORT_LOG_FORMAT;

4902

4903

if (init_global_datetime_format(MYSQL_TIMESTAMP_DATE,

4904

&global_system_variables.date_format) ||

4905

init_global_datetime_format(MYSQL_TIMESTAMP_TIME,

4906

&global_system_variables.time_format) ||

4907

init_global_datetime_format(MYSQL_TIMESTAMP_DATETIME,

4908

&global_system_variables.datetime_format))

4909

exit(1);

4910

4911

pool_of_threads_scheduler(&thread_scheduler); /* purecov: tested */

4912

}

4913

4914

4915

4916

Create version name for running mysqld version

4917

We automaticly add suffixes -debug, -embedded and -log to the version

4918

name to make the version more descriptive.

4919

(MYSQL_SERVER_SUFFIX is set by the compilation environment)

4920

4921

4922

static void set_server_version(void)

4923

{

4924

char *end= strxmov(server_version, MYSQL_SERVER_VERSION,

4925

MYSQL_SERVER_SUFFIX_STR, NullS);

4926

if (opt_log || opt_slow_log || opt_bin_log)

4927

strmov(end, "-log"); // This may slow down system

4928

}

4929

4930

4931

static char *get_relative_path(const char *path)

4932

{

4933

if (test_if_hard_path(path) &&

4934

is_prefix(path,DEFAULT_MYSQL_HOME) &&

4935

strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))

4936

{

4937

path+=(uint) strlen(DEFAULT_MYSQL_HOME);

4938

while (*path == FN_LIBCHAR)

4939

path++;

4940

}

4941

return (char*) path;

4942

}

4943

4944

4945

/**

4946

Fix filename and replace extension where 'dir' is relative to

4947

mysql_real_data_home.

4948

@return

4949

1 if len(path) > FN_REFLEN

4950

4951

4952

bool

4953

fn_format_relative_to_data_home(char * to, const char *name,

4954

const char *dir, const char *extension)

4955

{

4956

char tmp_path[FN_REFLEN];

4957

if (!test_if_hard_path(dir))

4958

{

4959

strxnmov(tmp_path,sizeof(tmp_path)-1, mysql_real_data_home,

4960

dir, NullS);

4961

dir=tmp_path;

4962

}

4963

return !fn_format(to, name, dir, extension,

4964

MY_APPEND_EXT | MY_UNPACK_FILENAME | MY_SAFE_PATH);

4965

}

4966

4967

4968

static void fix_paths(void)

4969

{

4970

char buff[FN_REFLEN],*pos;

4971

convert_dirname(mysql_home,mysql_home,NullS);

4972

/* Resolve symlinks to allow 'mysql_home' to be a relative symlink */

4973

my_realpath(mysql_home,mysql_home,MYF(0));

4974

/* Ensure that mysql_home ends in FN_LIBCHAR */

4975

pos=strend(mysql_home);

4976

if (pos[-1] != FN_LIBCHAR)

4977

{

4978

pos[0]= FN_LIBCHAR;

4979

pos[1]= 0;

4980

}

4981

convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);

4982

(void) fn_format(buff, mysql_real_data_home, "", "",

4983

(MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));

4984

(void) unpack_dirname(mysql_unpacked_real_data_home, buff);

4985

convert_dirname(language,language,NullS);

4986

(void) my_load_path(mysql_home,mysql_home,""); // Resolve current dir

4987

(void) my_load_path(mysql_real_data_home,mysql_real_data_home,mysql_home);

4988

(void) my_load_path(pidfile_name,pidfile_name,mysql_real_data_home);

4989

(void) my_load_path(opt_plugin_dir, opt_plugin_dir_ptr ? opt_plugin_dir_ptr :

4990

get_relative_path(PLUGINDIR), mysql_home);

4991

opt_plugin_dir_ptr= opt_plugin_dir;

4992

4993

char *sharedir=get_relative_path(SHAREDIR);

4994

if (test_if_hard_path(sharedir))

4995

strmake(buff,sharedir,sizeof(buff)-1); /* purecov: tested */

4996

else

4997

strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NullS);

4998

convert_dirname(buff,buff,NullS);

4999

(void) my_load_path(language,language,buff);

5000

5001

/* If --character-sets-dir isn't given, use shared library dir */

5002

if (charsets_dir != mysql_charsets_dir)

5003

{

5004

strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,

5005

CHARSET_DIR, NullS);

5006

}

5007

(void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);

5008

convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NullS);

5009

charsets_dir=mysql_charsets_dir;

5010

5011

if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))

5012

exit(1);

5013

if (!slave_load_tmpdir)

5014

{

5015

if (!(slave_load_tmpdir = (char*) my_strdup(mysql_tmpdir, MYF(MY_FAE))))

5016

exit(1);

5017

}

5018

5019

Convert the secure-file-priv option to system format, allowing

5020

a quick strcmp to check if read or write is in an allowed dir

5021

5022

if (opt_secure_file_priv)

5023

{

5024

convert_dirname(buff, opt_secure_file_priv, NullS);

5025

my_free(opt_secure_file_priv, MYF(0));

5026

opt_secure_file_priv= my_strdup(buff, MYF(MY_FAE));

5027

}

5028

}

5029

5030

5031

static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,

5032

const char *option)

5033

{

5034

ulong res;

5035

5036

const char **ptr;

5037

5038

if ((res= find_bit_type(x, bit_lib)) == ~(ulong) 0)

5039

{

5040

ptr= bit_lib->type_names;

5041

if (!*x)

5042

fprintf(stderr, "No option given to %s\n", option);

2373

5043

else

2374

{

2375

drizzle_tmpdir.append(tmp_string);

2376

}

2377

2378

drizzle_tmpdir= fs::path(fs::system_complete(fs::path(drizzle_tmpdir))).file_string();

2379

assert(drizzle_tmpdir.size());

2380

2381

if (mkdir(drizzle_tmpdir.c_str(), 0777) == -1)

2382

{

2383

if (errno != EEXIST)

2384

{

2385

perror(drizzle_tmpdir.c_str());

2386

exit(1);

2387

}

2388

}

2389

2390

if (stat(drizzle_tmpdir.c_str(), &buf) || (S_ISDIR(buf.st_mode) == false))

2391

{

2392

perror(drizzle_tmpdir.c_str());

2393

exit(1);

2394

}

2395

}

2396

2397

}

2398

2399

} /* namespace drizzled */

2400

5044

fprintf(stderr, "Wrong option to %s. Option(s) given: %s\n", option, x);

5045

fprintf(stderr, "Alternatives are: '%s'", *ptr);

5046

while (*++ptr)

5047

fprintf(stderr, ",'%s'", *ptr);

5048

fprintf(stderr, "\n");

5049

exit(1);

5050

}

5051

return res;

5052

}

5053

5054

5055

/**

5056

@return

5057

a bitfield from a string of substrings separated by ','

5058

5059

~(ulong) 0 on error.

5060

5061

5062

static ulong find_bit_type(const char *x, TYPELIB *bit_lib)

5063

{

5064

bool found_end;

5065

int found_count;

5066

const char *end,*i,*j;

5067

const char **array, *pos;

5068

ulong found,found_int,bit;

5069

5070

found=0;

5071

found_end= 0;

5072

pos=(char *) x;

5073

while (*pos == ' ') pos++;

5074

found_end= *pos == 0;

5075

while (!found_end)

5076

{

5077

if (!*(end=strcend(pos,','))) /* Let end point at fieldend */

5078

{

5079

while (end > pos && end[-1] == ' ')

5080

end--; /* Skip end-space */

5081

found_end=1;

5082

}

5083

found_int=0; found_count=0;

5084

for (array=bit_lib->type_names, bit=1 ; (i= *array++) ; bit<<=1)

5085

{

5086

j=pos;

5087

while (j != end)

5088

{

5089

if (my_toupper(mysqld_charset,*i++) !=

5090

my_toupper(mysqld_charset,*j++))

5091

goto skip;

5092

}

5093

found_int=bit;

5094

if (! *i)

5095

{

5096

found_count=1;

5097

break;

5098

}

5099

else if (j != pos) // Half field found

5100

{

5101

found_count++; // Could be one of two values

5102

}

5103

skip: ;

5104

}

5105

if (found_count != 1)

5106

return(~(ulong) 0); // No unique value

5107

found|=found_int;

5108

pos=end+1;

5109

}

5110

5111

return(found);

5112

} /* find_bit_type */

5113

5114

5115

/**

5116

Check if file system used for databases is case insensitive.

5117

5118

@param dir_name Directory to test

5119

5120

@retval

5121

-1 Don't know (Test failed)

5122

@retval

5123

0 File system is case sensitive

5124

@retval

5125

1 File system is case insensitive

5126

5127

5128

static int test_if_case_insensitive(const char *dir_name)

5129

{

5130

int result= 0;

5131

File file;

5132

char buff[FN_REFLEN], buff2[FN_REFLEN];

5133

struct stat stat_info;

5134

5135

fn_format(buff, glob_hostname, dir_name, ".lower-test",

5136

MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);

5137

fn_format(buff2, glob_hostname, dir_name, ".LOWER-TEST",

5138

MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);

5139

(void) my_delete(buff2, MYF(0));

5140

if ((file= my_create(buff, 0666, O_RDWR, MYF(0))) < 0)

5141

{

5142

sql_print_warning("Can't create test file %s", buff);

5143

return(-1);

5144

}

5145

my_close(file, MYF(0));

5146

if (!stat(buff2, &stat_info))

5147

result= 1; // Can access file

5148

(void) my_delete(buff, MYF(MY_WME));

5149

return(result);

5150

}

5151

5152

5153

/**

5154

Create file to store pid number.

5155

5156

static void create_pid_file()

5157

{

5158

File file;

5159

if ((file = my_create(pidfile_name,0664,

5160

O_WRONLY | O_TRUNC, MYF(MY_WME))) >= 0)

5161

{

5162

char buff[21], *end;

5163

end= int10_to_str((long) getpid(), buff, 10);

5164

*end++= '\n';

5165

if (!my_write(file, (uchar*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))

5166

{

5167

(void) my_close(file, MYF(0));

5168

return;

5169

}

5170

(void) my_close(file, MYF(0));

5171

}

5172

sql_perror("Can't start server: can't create PID file");

5173

exit(1);

5174

}

5175

5176

/** Clear most status variables. */

5177

void refresh_status(THD *thd)

5178

{

5179

pthread_mutex_lock(&LOCK_status);

5180

5181

/* Add thread's status variabes to global status */

5182

add_to_status(&global_status_var, &thd->status_var);

5183

5184

/* Reset thread's status variables */

5185

bzero((uchar*) &thd->status_var, sizeof(thd->status_var));

5186

5187

/* Reset some global variables */

5188

reset_status_vars();

5189

5190

/* Reset the counters of all key caches (default and named). */

5191

process_key_caches(reset_key_cache_counters);

5192

flush_status_time= time((time_t*) 0);

5193

pthread_mutex_unlock(&LOCK_status);

5194

5195

5196

Set max_used_connections to the number of currently open

5197

connections. Lock LOCK_thread_count out of LOCK_status to avoid

5198

deadlocks. Status reset becomes not atomic, but status data is

5199

not exact anyway.

5200

5201

pthread_mutex_lock(&LOCK_thread_count);

5202

max_used_connections= thread_count;

5203

pthread_mutex_unlock(&LOCK_thread_count);

5204

}

5205

5206

5207

/*****************************************************************************

5208

Instantiate templates

5209

*****************************************************************************/

5210

5211

#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

5212

/* Used templates */

5213

template class I_List<THD>;

5214

template class I_List_iterator<THD>;

5215

template class I_List<i_string>;

5216

template class I_List<i_string_pair>;

5217

template class I_List<NAMED_LIST>;

5218

template class I_List<Statement>;

5219

template class I_List_iterator<Statement>;

5220

#endif

Older »