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

1231

N_("Default transaction isolation level."))

1232

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

1233

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

1204

1234

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

1205

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

1235

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

1206

1236

("version,V",

1207

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

1237

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

1208

1238

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

1209

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

1239

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

1210

1240

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

1211

1241

"requests in a very short time."))

1212

1242

("bulk-insert-buffer-size",

1213

1243

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 "

1244

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

1215

1245

"a limit per thread!"))

1216

1246

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

1247

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

1218

1248

"value."))

1219

1249

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

1250

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

1221

1251

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

1252

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

1223

1253

("join-heap-threshold",

1224

1254

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

1255

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

1226

1256

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

1257

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

1258

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

1259

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

1260

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

1228

1261

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

1262

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

1230

1263

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

1264

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

1232

1265

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

1266

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

1234

1267

"return an error."))

1235

1268

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

1269

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

1237

1270

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

1271

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

1239

1272

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

1273

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

1241

1274

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

1242

1275

"rest are ignored)."))

1243

1276

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

1277

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

1245

1278

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

1279

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

1247

1280

"rows to file."))

1248

1281

("disable-optimizer-prune",

1249

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

1282

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

1250

1283

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

1251

1284

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

1285

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

1253

1286

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

1254

1287

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

1255

1288

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

1258

1291

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

1259

1292

"testing/comparison)."))

1260

1293

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

1294

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

1262

1295

("query-alloc-block-size",

1263

1296

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

1297

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

1265

1298

("query-prealloc-size",

1266

1299

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

1300

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

1268

1301

("range-alloc-block-size",

1269

1302

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

1303

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

1271

1304

("read-buffer-size",

1272

1305

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 "

1306

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

1274

1307

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

1275

1308

"want to increase this value."))

1276

1309

("read-buffer-threshold",

1277

1310

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

1278

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

1311

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

1279

1312

("read-rnd-buffer-size",

1280

1313

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 "

1314

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

1282

1315

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

1283

1316

"to the value of record_buffer."))

1284

1317

("read-rnd-threshold",

1285

1318

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

1286

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

1319

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

1287

1320

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

1288

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

1321

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

1289

1322

("sort-buffer-size",

1290

1323

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

1324

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

1292

1325

("sort-heap-threshold",

1293

1326

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

1327

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

1295

1328

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

1296

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

1329

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

1297

1330

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

1331

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

1299

1332

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

1333

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

1301

1334

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

1302

1335

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

1336

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

1304

1337

("tmp-table-size",

1305

1338

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"

1339

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

1307

1340

" 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

1341

;

1311

1342

1312

1343

full_options.add(long_options);

1326

1357

{

1327

1358

po::store(parsed, vm);

1328

1359

}

1329

catch (std::exception&)

1360

catch (...)

1330

1361

{

1331

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

1362

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

1332

1363

unireg_abort(1);

1333

1364

}

1334

1365

1374

1405

}

1375

1406

catch (po::validation_error &err)

1376

1407

{

1377

errmsg_printf(error::ERROR,

1408

errmsg_printf(ERRMSG_LVL_ERROR,

1378

1409

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

1379

1410

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

1380

1411

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

1392

1423

}

1393

1424

catch (po::validation_error &err)

1394

1425

{

1395

errmsg_printf(error::ERROR,

1426

errmsg_printf(ERRMSG_LVL_ERROR,

1396

1427

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

1397

1428

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

1398

1429

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

1399

1430

unireg_abort(1);

1400

1431

}

1401

1432

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

1433

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

1412

1434

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

1413

1435

1414

1436

1415

1437

if (plugin_init(plugins, plugin_options))

1416

1438

{

1417

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

1439

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

1418

1440

unireg_abort(1);

1419

1441

}

1420

1442

1435

1457

}

1436

1458

catch (po::validation_error &err)

1437

1459

{

1438

errmsg_printf(error::ERROR,

1460

errmsg_printf(ERRMSG_LVL_ERROR,

1439

1461

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

1440

1462

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

1441

1463

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

1443

1465

}

1444

1466

catch (po::invalid_command_line_syntax &err)

1445

1467

{

1446

errmsg_printf(error::ERROR,

1468

errmsg_printf(ERRMSG_LVL_ERROR,

1447

1469

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

1448

1470

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

1449

1471

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

1451

1473

}

1452

1474

catch (po::unknown_option &err)

1453

1475

{

1454

errmsg_printf(error::ERROR,

1476

errmsg_printf(ERRMSG_LVL_ERROR,

1455

1477

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

1456

1478

err.what());

1457

1479

unireg_abort(1);

1463

1485

}

1464

1486

catch (po::validation_error &err)

1465

1487

{

1466

errmsg_printf(error::ERROR,

1488

errmsg_printf(ERRMSG_LVL_ERROR,

1467

1489

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

1468

1490

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

1469

1491

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

1487

1509

1488

1510

fix_paths();

1489

1511

1512

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

1490

1513

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

1491

1514

1492

1515

if (item_create_init())

1500

1523

if (!(default_charset_info=

1501

1524

get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

1502

1525

{

1503

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

1526

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

1504

1527

return 1; // Eof of the list

1505

1528

}

1506

1529

1512

1535

const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);

1513

1536

if (not default_collation)

1514

1537

{

1515

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

1538

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

1516

1539

return 1;

1517

1540

}

1518

1541

if (not my_charset_same(default_charset_info, default_collation))

1519

1542

{

1520

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

1543

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

1521

1544

default_collation_name,

1522

1545

default_charset_info->csname);

1523

1546

return 1;

1530

1553

if (not (character_set_filesystem=

1531

1554

get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))

1532

1555

{

1533

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

1556

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

1534

1557

return 1;

1535

1558

}

1536

1559

global_system_variables.character_set_filesystem= character_set_filesystem;

1538

1561

if (!(my_default_lc_time_names=

1539

1562

my_locale_by_name(lc_time_names_name)))

1540

1563

{

1541

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

1564

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

1542

1565

return 1;

1543

1566

}

1544

1567

global_system_variables.lc_time_names= my_default_lc_time_names;

1558

1581

1559

1582

if (table_cache_init())

1560

1583

{

1561

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

1584

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

1562

1585

unireg_abort(1);

1563

1586

}

1564

1587

1573

1596

1574

1597

if (xid_cache_init())

1575

1598

{

1576

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

1599

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

1577

1600

unireg_abort(1);

1578

1601

}

1579

1602

1625

1603

1626

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

1604

1627

{

1605

errmsg_printf(error::ERROR,

1628

errmsg_printf(ERRMSG_LVL_ERROR,

1606

1629

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

1607

1630

unireg_abort(1);

1608

1631

}

1627

1650

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

1628

1651

if (engine == NULL)

1629

1652

{

1630

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

1653

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

1631

1654

default_storage_engine_str);

1632

1655

unireg_abort(1);

1633

1656

}

1668

1691

OPT_BACK_LOG,

1669

1692

OPT_JOIN_BUFF_SIZE,

1670

1693

OPT_MAX_ALLOWED_PACKET,

1694

OPT_MAX_CONNECT_ERRORS,

1671

1695

OPT_MAX_HEP_TABLE_SIZE,

1672

1696

OPT_MAX_JOIN_SIZE,

1673

1697

OPT_MAX_SORT_LENGTH,

1721

1745

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

1722

1746

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

1723

1747

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

1748

{"auto-increment-increment", OPT_AUTO_INCREMENT,

1728

1749

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

1729

1750

(char**) &global_system_variables.auto_increment_increment,

1760

1781

{"datadir", 'h',

1761

1782

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

1762

1783

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

1784

{"default-storage-engine", OPT_STORAGE_ENGINE,

1785

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

1786

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

1787

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

1788

{"default-time-zone", OPT_DEFAULT_TIME_ZONE,

1789

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

1790

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

1791

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

1763

1792

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

1764

1793

{"exit-info", 'T',

1765

1794

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

1770

1799

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

1771

1800

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

1772

1801

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

1802

{"lc-time-names", OPT_LC_TIME_NAMES,

1803

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

1804

(char**) &lc_time_names_name,

1805

(char**) &lc_time_names_name,

1806

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

1773

1807

{"log-warnings", 'W',

1774

1808

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

1775

1809

(char**) &global_system_variables.log_warnings,

1812

1846

"supported)"),

1813

1847

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

1814

1848

0, 0, 0, 0, 0},

1849

{"tmpdir", 't',

1850

N_("Path for temporary files."),

1851

(char**) &opt_drizzle_tmpdir,

1852

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

1815

1853

{"transaction-isolation", OPT_TX_ISOLATION,

1816

1854

N_("Default transaction isolation level."),

1817

1855

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

1820

1858

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

1821

1859

0, 0, 0, GET_STR, REQUIRED_ARG,

1822

1860

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

1861

{"version", 'V',

1862

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

1863

0, 0, 0, GET_NO_ARG,

1864

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

1823

1865

{"back_log", OPT_BACK_LOG,

1824

1866

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

1825

1867

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

1838

1880

(char**) &global_system_variables.div_precincrement,

1839

1881

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

1840

1882

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

1883

{ "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,

1884

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

1885

(char**) &global_system_variables.group_concat_max_len,

1886

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

1887

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

1841

1888

{ "join_buffer_size", OPT_JOIN_BUFF_SIZE,

1842

1889

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

1843

1890

(char**) &global_system_variables.join_buff_size,

1849

1896

(char**) &global_system_variables.max_allowed_packet,

1850

1897

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

1851

1898

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

1899

{"max_connect_errors", OPT_MAX_CONNECT_ERRORS,

1900

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

1901

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

1902

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

1903

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

1904

{"max_error_count", OPT_MAX_ERROR_COUNT,

1905

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

1906

(char**) &global_system_variables.max_error_count,

1907

(char**) &max_system_variables.max_error_count,

1908

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

1852

1909

{"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,

1853

1910

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

1854

1911

(char**) &global_system_variables.max_heap_table_size,

1968

2025

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

1969

2026

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

1970

2027

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

2028

{"scheduler", OPT_SCHEDULER,

2029

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

2030

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

2031

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

1971

2032

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

1972

2033

{"sort_buffer_size", OPT_SORT_BUFFER,

1973

2034

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

2061

2122

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

2062

2123

cleanup_done= 0;

2063

2124

dropping_tables= ha_open_options=0;

2064

getDebug().reset();

2125

test_flags.reset();

2065

2126

wake_thread=0;

2066

2127

abort_loop= select_thread_in_use= false;

2067

shutdown_in_progress= 0;

2128

ready_to_exit= shutdown_in_progress= 0;

2068

2129

drizzled_user= drizzled_chroot= 0;

2069

2130

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

2070

2131

key_map_full.set();

2129

2190

#else

2130

2191

have_symlink=SHOW_OPTION_YES;

2131

2192

#endif

2193

2194

connection_count= 0;

2132

2195

}

2133

2196

2134

2197

2149

2212

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

2150

2213

2151

2214

else

2152

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

2215

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

2153

2216

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

2154

2217

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

2155

2218

}

2166

2229

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

2167

2230

global_system_variables.sortbuff_size))

2168

2231

{

2169

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

2232

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

2170

2233

exit(-1);

2171

2234

}

2172

2235

2179

2242

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

2180

2243

global_system_variables.join_buff_size))

2181

2244

{

2182

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

2245

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

2183

2246

exit(-1);

2184

2247

}

2185

2248

2192

2255

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

2193

2256

global_system_variables.read_rnd_buff_size))

2194

2257

{

2195

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

2258

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

2196

2259

exit(-1);

2197

2260

}

2198

2261

2205

2268

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

2206

2269

global_system_variables.read_buff_size))

2207

2270

{

2208

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

2271

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

2209

2272

exit(-1);

2210

2273

}

2211

2274

2216

2279

{

2217

2280

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

2218

2281

{

2219

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

2282

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

2220

2283

}

2221

2284

}

2222

2285

2223

2286

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

2224

2287

{

2225

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

2288

test_flags.set(TEST_CORE_ON_SIGNAL);

2226

2289

}

2227

2290

2228

2291

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

2229

2292

{

2230

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

2293

test_flags.set(TEST_NO_STACKTRACE);

2231

2294

}

2232

2295

2233

2296

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

2237

2300

2238

2301

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

2239

2302

{

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;

2303

int type;

2304

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

2305

global_system_variables.tx_isolation= (type-1);

2242

2306

}

2243

2307

2244

2308

/* @TODO Make this all strings */

2265

2329

if (opt_debugging)

2266

2330

{

2267

2331

/* 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);

2332

test_flags.set(TEST_SIGINT);

2333

test_flags.set(TEST_NO_STACKTRACE);

2334

test_flags.reset(TEST_CORE_ON_SIGNAL);

2271

2335

}

2272

2336

2273

2337

if (drizzled_chroot)

2319

2383

{

2320

2384

if (errno != EEXIST)

2321

2385

{

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

2386

perror(drizzle_tmpdir.c_str());

2323

2387

exit(1);

2324

2388

}

2325

2389

}

2326

2390

2327

2391

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

2328

2392

{

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

2393

perror(drizzle_tmpdir.c_str());

2330

2394

exit(1);

2331

2395

}

2332

2396

}

Older »