~drizzle-trunk/drizzle/development

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

1203

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

1281

N_("Default transaction isolation level."))

1282

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

1283

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

1204

1284

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

1205

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

1285

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

1206

1286

("version,V",

1207

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

1287

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

1208

1288

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

1209

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

1289

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

1210

1290

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

1211

1291

"requests in a very short time."))

1212

1292

("bulk-insert-buffer-size",

1213

1293

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

1214

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

1294

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

1215

1295

"a limit per thread!"))

1216

1296

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

1217

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

1297

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

1218

1298

"value."))

1219

1299

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

1220

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

1300

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

1221

1301

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

1222

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

1223

("join-heap-threshold",

1224

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

1225

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

1302

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

1226

1303

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

1227

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

1304

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

1305

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

1306

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

1307

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

1228

1308

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

1229

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

1309

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

1230

1310

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

1231

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

1311

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

1232

1312

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

1233

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

1313

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

1234

1314

"return an error."))

1235

1315

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

1236

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

1316

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

1237

1317

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

1238

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

1318

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

1239

1319

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

1240

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

1320

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

1241

1321

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

1242

1322

"rest are ignored)."))

1243

1323

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

1244

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

1324

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

1245

1325

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

1246

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

1326

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

1247

1327

"rows to file."))

1248

1328

("disable-optimizer-prune",

1249

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

1329

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

1250

1330

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

1251

1331

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

1252

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

1332

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

1253

1333

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

1254

1334

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

1255

1335

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

1258

1338

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

1259

1339

"testing/comparison)."))

1260

1340

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

1261

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

1341

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

1262

1342

("query-alloc-block-size",

1263

1343

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

1264

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

1344

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

1265

1345

("query-prealloc-size",

1266

1346

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

1267

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

1347

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

1268

1348

("range-alloc-block-size",

1269

1349

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

1270

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

1350

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

1271

1351

("read-buffer-size",

1272

1352

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

1273

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

1353

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

1274

1354

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

1275

1355

"want to increase this value."))

1276

("read-buffer-threshold",

1277

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

1278

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

1279

1356

("read-rnd-buffer-size",

1280

1357

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

1281

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

1358

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

1282

1359

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

1283

1360

"to the value of record_buffer."))

1284

("read-rnd-threshold",

1285

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

1286

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

1287

1361

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

1288

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

1362

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

1289

1363

("sort-buffer-size",

1290

1364

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

1291

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

1292

("sort-heap-threshold",

1293

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

1294

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

1365

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

1295

1366

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

1296

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

1367

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

1297

1368

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

1298

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

1369

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

1299

1370

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

1300

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

1371

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

1301

1372

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

1302

1373

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

1303

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

1374

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

1304

1375

("tmp-table-size",

1305

1376

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

1306

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

1377

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

1307

1378

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

1308

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

1309

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

1310

1379

;

1311

1380

1312

1381

full_options.add(long_options);

1326

1395

{

1327

1396

po::store(parsed, vm);

1328

1397

}

1329

catch (std::exception&)

1398

catch (...)

1330

1399

{

1331

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

1400

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

1332

1401

unireg_abort(1);

1333

1402

}

1334

1403

1335

1404

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

1336

1405

{

1337

fs::path system_config_file_drizzle(system_config_dir);

1338

system_config_file_drizzle /= "drizzled.cnf";

1339

1406

defaults_file_list.insert(defaults_file_list.begin(),

1340

system_config_file_drizzle.file_string());

1407

system_config_file_drizzle);

1341

1408

1342

1409

fs::path config_conf_d_location(system_config_dir);

1343

1410

config_conf_d_location /= "conf.d";

1344

1411

1345

1346

1412

CachedDirectory config_conf_d(config_conf_d_location.file_string());

1347

1413

if (not config_conf_d.fail())

1348

1414

{

1374

1440

}

1375

1441

catch (po::validation_error &err)

1376

1442

{

1377

errmsg_printf(error::ERROR,

1443

errmsg_printf(ERRMSG_LVL_ERROR,

1378

1444

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

1379

1445

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

1380

1446

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

1392

1458

}

1393

1459

catch (po::validation_error &err)

1394

1460

{

1395

errmsg_printf(error::ERROR,

1461

errmsg_printf(ERRMSG_LVL_ERROR,

1396

1462

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

1397

1463

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

1398

1464

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

1399

1465

unireg_abort(1);

1400

1466

}

1401

1467

1402

return 0;

1403

}

1404

1405

int init_remaining_variables(module::Registry &plugins)

1406

{

1407

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

1408

1409

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

1410

1411

1468

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

1412

1469

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

1413

1470

1414

1471

1415

1472

if (plugin_init(plugins, plugin_options))

1416

1473

{

1417

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

1474

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

1418

1475

unireg_abort(1);

1419

1476

}

1420

1477

1425

1482

{

1426

1483

po::parsed_options final_parsed=

1427

1484

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

1428

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

1485

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

1429

1486

1430

1487

final_unknown_options=

1431

1488

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

1435

1492

}

1436

1493

catch (po::validation_error &err)

1437

1494

{

1438

errmsg_printf(error::ERROR,

1495

errmsg_printf(ERRMSG_LVL_ERROR,

1439

1496

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

1440

1497

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

1441

1498

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

1443

1500

}

1444

1501

catch (po::invalid_command_line_syntax &err)

1445

1502

{

1446

errmsg_printf(error::ERROR,

1503

errmsg_printf(ERRMSG_LVL_ERROR,

1447

1504

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

1448

1505

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

1449

1506

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

1451

1508

}

1452

1509

catch (po::unknown_option &err)

1453

1510

{

1454

errmsg_printf(error::ERROR,

1511

errmsg_printf(ERRMSG_LVL_ERROR,

1455

1512

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

1456

1513

err.what());

1457

1514

unireg_abort(1);

1463

1520

}

1464

1521

catch (po::validation_error &err)

1465

1522

{

1466

errmsg_printf(error::ERROR,

1523

errmsg_printf(ERRMSG_LVL_ERROR,

1467

1524

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

1468

1525

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

1469

1526

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

1487

1544

1488

1545

fix_paths();

1489

1546

1547

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

1490

1548

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

1491

1549

1492

1550

if (item_create_init())

1500

1558

if (!(default_charset_info=

1501

1559

get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

1502

1560

{

1503

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

1561

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

1504

1562

return 1; // Eof of the list

1505

1563

}

1506

1564

1512

1570

const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);

1513

1571

if (not default_collation)

1514

1572

{

1515

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

1573

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

1516

1574

return 1;

1517

1575

}

1518

1576

if (not my_charset_same(default_charset_info, default_collation))

1519

1577

{

1520

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

1578

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

1521

1579

default_collation_name,

1522

1580

default_charset_info->csname);

1523

1581

return 1;

1530

1588

if (not (character_set_filesystem=

1531

1589

get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))

1532

1590

{

1533

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

1591

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

1534

1592

return 1;

1535

1593

}

1536

1594

global_system_variables.character_set_filesystem= character_set_filesystem;

1538

1596

if (!(my_default_lc_time_names=

1539

1597

my_locale_by_name(lc_time_names_name)))

1540

1598

{

1541

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

1599

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

1542

1600

return 1;

1543

1601

}

1544

1602

global_system_variables.lc_time_names= my_default_lc_time_names;

1558

1616

1559

1617

if (table_cache_init())

1560

1618

{

1561

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

1619

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

1562

1620

unireg_abort(1);

1563

1621

}

1564

1622

1565

1623

// Resize the definition Cache at startup

1566

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

1567

1624

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

1568

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

1569

1625

1570

1626

setup_fpu();

1571

1627

1573

1629

1574

1630

if (xid_cache_init())

1575

1631

{

1576

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

1632

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

1577

1633

unireg_abort(1);

1578

1634

}

1579

1635

1602

1658

1603

1659

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

1604

1660

{

1605

errmsg_printf(error::ERROR,

1661

errmsg_printf(ERRMSG_LVL_ERROR,

1606

1662

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

1607

1663

unireg_abort(1);

1608

1664

}

1627

1683

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

1628

1684

if (engine == NULL)

1629

1685

{

1630

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

1686

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

1631

1687

default_storage_engine_str);

1632

1688

unireg_abort(1);

1633

1689

}

1668

1724

OPT_BACK_LOG,

1669

1725

OPT_JOIN_BUFF_SIZE,

1670

1726

OPT_MAX_ALLOWED_PACKET,

1727

OPT_MAX_CONNECT_ERRORS,

1671

1728

OPT_MAX_HEP_TABLE_SIZE,

1672

1729

OPT_MAX_JOIN_SIZE,

1673

1730

OPT_MAX_SORT_LENGTH,

1721

1778

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

1722

1779

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

1723

1780

0, 0},

1724

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

1725

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

1726

0, 0},

1727

1781

{"auto-increment-increment", OPT_AUTO_INCREMENT,

1728

1782

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

1729

1783

(char**) &global_system_variables.auto_increment_increment,

1760

1814

{"datadir", 'h',

1761

1815

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

1762

1816

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

1817

{"default-storage-engine", OPT_STORAGE_ENGINE,

1818

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

1819

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

1820

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

1821

{"default-time-zone", OPT_DEFAULT_TIME_ZONE,

1822

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

1823

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

1824

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

1763

1825

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

1764

1826

{"exit-info", 'T',

1765

1827

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

1770

1832

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

1771

1833

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

1772

1834

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

1835

{"lc-time-names", OPT_LC_TIME_NAMES,

1836

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

1837

(char**) &lc_time_names_name,

1838

(char**) &lc_time_names_name,

1839

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

1773

1840

{"log-warnings", 'W',

1774

1841

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

1775

1842

(char**) &global_system_variables.log_warnings,

1812

1879

"supported)"),

1813

1880

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

1814

1881

0, 0, 0, 0, 0},

1882

{"tmpdir", 't',

1883

N_("Path for temporary files."),

1884

(char**) &opt_drizzle_tmpdir,

1885

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

1815

1886

{"transaction-isolation", OPT_TX_ISOLATION,

1816

1887

N_("Default transaction isolation level."),

1817

1888

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

1820

1891

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

1821

1892

0, 0, 0, GET_STR, REQUIRED_ARG,

1822

1893

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

1894

{"version", 'V',

1895

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

1896

0, 0, 0, GET_NO_ARG,

1897

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

1823

1898

{"back_log", OPT_BACK_LOG,

1824

1899

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

1825

1900

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

1838

1913

(char**) &global_system_variables.div_precincrement,

1839

1914

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

1840

1915

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

1916

{ "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,

1917

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

1918

(char**) &global_system_variables.group_concat_max_len,

1919

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

1920

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

1841

1921

{ "join_buffer_size", OPT_JOIN_BUFF_SIZE,

1842

1922

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

1843

1923

(char**) &global_system_variables.join_buff_size,

1849

1929

(char**) &global_system_variables.max_allowed_packet,

1850

1930

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

1851

1931

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

1932

{"max_connect_errors", OPT_MAX_CONNECT_ERRORS,

1933

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

1934

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

1935

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

1936

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

1937

{"max_error_count", OPT_MAX_ERROR_COUNT,

1938

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

1939

(char**) &global_system_variables.max_error_count,

1940

(char**) &max_system_variables.max_error_count,

1941

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

1852

1942

{"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,

1853

1943

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

1854

1944

(char**) &global_system_variables.max_heap_table_size,

1968

2058

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

1969

2059

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

1970

2060

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

2061

{"scheduler", OPT_SCHEDULER,

2062

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

2063

(char**)&opt_scheduler, (char**)&opt_scheduler,

2064

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

1971

2065

/* x8 compared to MySQL's x2. We have UTF8 to consider. */

1972

2066

{"sort_buffer_size", OPT_SORT_BUFFER,

1973

2067

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

2061

2155

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

2062

2156

cleanup_done= 0;

2063

2157

dropping_tables= ha_open_options=0;

2064

getDebug().reset();

2158

test_flags.reset();

2065

2159

wake_thread=0;

2066

2160

abort_loop= select_thread_in_use= false;

2067

shutdown_in_progress= 0;

2161

ready_to_exit= shutdown_in_progress= 0;

2068

2162

drizzled_user= drizzled_chroot= 0;

2069

2163

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

2070

2164

key_map_full.set();

2079

2173

session_startup_options= (OPTION_AUTO_IS_NULL | OPTION_SQL_NOTES);

2080

2174

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

2081

2175

global_thread_id= 1UL;

2082

session::Cache::singleton().getCache().clear();

2176

getSessionList().clear();

2083

2177

2084

2178

/* Variables in libraries */

2085

2179

default_character_set_name= "utf8";

2129

2223

#else

2130

2224

have_symlink=SHOW_OPTION_YES;

2131

2225

#endif

2226

2227

connection_count= 0;

2132

2228

}

2133

2229

2134

2230

2149

2245

drizzled_user= (char *)vm["user"].as<string>().c_str();

2150

2246

2151

2247

else

2152

errmsg_printf(error::WARN, _("Ignoring user change to '%s' because the user was "

2248

errmsg_printf(ERRMSG_LVL_WARN, _("Ignoring user change to '%s' because the user was "

2153

2249

"set to '%s' earlier on the command line\n"),

2154

2250

vm["user"].as<string>().c_str(), drizzled_user);

2155

2251

}

2160

2256

exit(0);

2161

2257

}

2162

2258

2163

if (vm.count("sort-heap-threshold"))

2164

{

2165

if ((vm["sort-heap-threshold"].as<uint64_t>() > 0) and

2166

(vm["sort-heap-threshold"].as<uint64_t>() <

2167

global_system_variables.sortbuff_size))

2168

{

2169

cout << _("Error: sort-heap-threshold cannot be less than sort-buffer-size") << endl;

2170

exit(-1);

2171

}

2172

2173

global_sort_buffer.setMaxSize(vm["sort-heap-threshold"].as<uint64_t>());

2174

}

2175

2176

if (vm.count("join-heap-threshold"))

2177

{

2178

if ((vm["join-heap-threshold"].as<uint64_t>() > 0) and

2179

(vm["join-heap-threshold"].as<uint64_t>() <

2180

global_system_variables.join_buff_size))

2181

{

2182

cout << _("Error: join-heap-threshold cannot be less than join-buffer-size") << endl;

2183

exit(-1);

2184

}

2185

2186

global_join_buffer.setMaxSize(vm["join-heap-threshold"].as<uint64_t>());

2187

}

2188

2189

if (vm.count("read-rnd-threshold"))

2190

{

2191

if ((vm["read-rnd-threshold"].as<uint64_t>() > 0) and

2192

(vm["read-rnd-threshold"].as<uint64_t>() <

2193

global_system_variables.read_rnd_buff_size))

2194

{

2195

cout << _("Error: read-rnd-threshold cannot be less than read-rnd-buffer-size") << endl;

2196

exit(-1);

2197

}

2198

2199

global_read_rnd_buffer.setMaxSize(vm["read-rnd-threshold"].as<uint64_t>());

2200

}

2201

2202

if (vm.count("read-buffer-threshold"))

2203

{

2204

if ((vm["read-buffer-threshold"].as<uint64_t>() > 0) and

2205

(vm["read-buffer-threshold"].as<uint64_t>() <

2206

global_system_variables.read_buff_size))

2207

{

2208

cout << _("Error: read-buffer-threshold cannot be less than read-buffer-size") << endl;

2209

exit(-1);

2210

}

2211

2212

global_read_buffer.setMaxSize(vm["read-buffer-threshold"].as<uint64_t>());

2213

}

2214

2215

2259

if (vm.count("exit-info"))

2216

2260

{

2217

2261

if (vm["exit-info"].as<long>())

2218

2262

{

2219

getDebug().set((uint32_t) vm["exit-info"].as<long>());

2263

test_flags.set((uint32_t) vm["exit-info"].as<long>());

2220

2264

}

2221

2265

}

2222

2266

2223

2267

if (vm.count("want-core"))

2224

2268

{

2225

getDebug().set(debug::CORE_ON_SIGNAL);

2269

test_flags.set(TEST_CORE_ON_SIGNAL);

2226

2270

}

2227

2271

2228

2272

if (vm.count("skip-stack-trace"))

2229

2273

{

2230

getDebug().set(debug::NO_STACKTRACE);

2274

test_flags.set(TEST_NO_STACKTRACE);

2231

2275

}

2232

2276

2233

2277

if (vm.count("skip-symlinks"))

2237

2281

2238

2282

if (vm.count("transaction-isolation"))

2239

2283

{

2240

int type= tx_isolation_typelib.find_type_or_exit(vm["transaction-isolation"].as<string>().c_str(), "transaction-isolation");

2241

global_system_variables.tx_isolation= type - 1;

2284

int type;

2285

type= find_type_or_exit((char *)vm["transaction-isolation"].as<string>().c_str(), &tx_isolation_typelib, "transaction-isolation");

2286

global_system_variables.tx_isolation= (type-1);

2242

2287

}

2243

2288

2244

2289

/* @TODO Make this all strings */

2265

2310

if (opt_debugging)

2266

2311

{

2267

2312

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

2268

getDebug().set(debug::ALLOW_SIGINT);

2269

getDebug().set(debug::NO_STACKTRACE);

2270

getDebug().reset(debug::CORE_ON_SIGNAL);

2313

test_flags.set(TEST_SIGINT);

2314

test_flags.set(TEST_NO_STACKTRACE);

2315

test_flags.reset(TEST_CORE_ON_SIGNAL);

2271

2316

}

2272

2317

2273

2318

if (drizzled_chroot)

2289

2334

pid_file_path= getDataHome();

2290

2335

pid_file_path /= pid_file;

2291

2336

}

2292

pid_file= fs::system_complete(pid_file_path);

2337

pid_file= pid_file_path;

2293

2338

2294

2339

if (not opt_help)

2295

2340

{

2319

2364

{

2320

2365

if (errno != EEXIST)

2321

2366

{

2322

errmsg_printf(error::ERROR, _("There was an error creating the '%s' part of the path '%s'. Please check the path exists and is writable.\n"), fs::path(drizzle_tmpdir).leaf().c_str(), drizzle_tmpdir.c_str());

2367

perror(drizzle_tmpdir.c_str());

2323

2368

exit(1);

2324

2369

}

2325

2370

}

2326

2371

2327

2372

if (stat(drizzle_tmpdir.c_str(), &buf) || (S_ISDIR(buf.st_mode) == false))

2328

2373

{

2329

errmsg_printf(error::ERROR, _("There was an error opening the path '%s', please check the path exists and is writable.\n"), drizzle_tmpdir.c_str());

2374

perror(drizzle_tmpdir.c_str());

2330

2375

exit(1);

2331

2376

}

2332

2377

}

Older »