~drizzle-trunk/drizzle/development

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

1215

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

1307

N_("Default transaction isolation level."))

1308

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

1309

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

1216

1310

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

1217

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

1311

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

1218

1312

("version,V",

1219

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

1220

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

1221

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

1313

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

1314

("back-log", po::value<uint32_t>(&back_log)->default_value(50)->notifier(&check_limits_back_log),

1315

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

1222

1316

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

1223

1317

"requests in a very short time."))

1224

1318

("bulk-insert-buffer-size",

1225

1319

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

1226

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

1320

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

1227

1321

"a limit per thread!"))

1228

1322

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

1229

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

1323

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

1230

1324

"value."))

1231

1325

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

1232

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

1326

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

1233

1327

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

1234

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

1235

("join-heap-threshold",

1236

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

1237

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

1238

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

1239

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

1328

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

1329

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

1330

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

1331

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

1332

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

1333

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

1240

1334

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

1241

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

1335

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

1242

1336

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

1243

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

1337

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

1244

1338

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

1245

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

1339

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

1246

1340

"return an error."))

1247

1341

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

1248

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

1342

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

1249

1343

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

1250

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

1344

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

1251

1345

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

1252

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

1346

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

1253

1347

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

1254

1348

"rest are ignored)."))

1255

1349

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

1256

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

1350

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

1257

1351

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

1258

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

1352

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

1259

1353

"rows to file."))

1260

1354

("disable-optimizer-prune",

1261

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

1355

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

1262

1356

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

1263

1357

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

1264

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

1358

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

1265

1359

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

1266

1360

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

1267

1361

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

1270

1364

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

1271

1365

"testing/comparison)."))

1272

1366

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

1273

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

1367

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

1274

1368

("query-alloc-block-size",

1275

1369

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

1276

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

1370

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

1277

1371

("query-prealloc-size",

1278

1372

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

1279

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

1373

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

1280

1374

("range-alloc-block-size",

1281

1375

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

1282

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

1376

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

1283

1377

("read-buffer-size",

1284

1378

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

1285

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

1379

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

1286

1380

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

1287

1381

"want to increase this value."))

1288

("read-buffer-threshold",

1289

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

1290

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

1291

1382

("read-rnd-buffer-size",

1292

1383

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

1293

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

1384

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

1294

1385

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

1295

1386

"to the value of record_buffer."))

1296

("read-rnd-threshold",

1297

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

1298

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

1299

1387

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

1300

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

1388

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

1301

1389

("sort-buffer-size",

1302

1390

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

1303

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

1304

("sort-heap-threshold",

1305

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

1306

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

1391

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

1307

1392

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

1308

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

1393

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

1309

1394

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

1310

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

1395

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

1311

1396

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

1312

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

1397

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

1313

1398

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

1314

1399

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

1315

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

1400

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

1316

1401

("tmp-table-size",

1317

1402

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

1318

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

1403

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

1319

1404

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

1320

1405

;

1321

1406

1336

1421

{

1337

1422

po::store(parsed, vm);

1338

1423

}

1339

catch (std::exception&)

1424

catch (...)

1340

1425

{

1341

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

1426

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

1342

1427

unireg_abort(1);

1343

1428

}

1344

1429

1345

1430

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

1346

1431

{

1347

fs::path system_config_file_drizzle(system_config_dir);

1348

system_config_file_drizzle /= "drizzled.cnf";

1349

1432

defaults_file_list.insert(defaults_file_list.begin(),

1350

system_config_file_drizzle.file_string());

1351

1352

fs::path config_conf_d_location(system_config_dir);

1353

config_conf_d_location /= "conf.d";

1354

1355

1356

CachedDirectory config_conf_d(config_conf_d_location.file_string());

1357

if (not config_conf_d.fail())

1433

system_config_file_drizzle);

1434

}

1435

1436

fs::path config_conf_d_location(system_config_dir);

1437

config_conf_d_location /= "conf.d";

1438

1439

CachedDirectory config_conf_d(config_conf_d_location.file_string());

1440

if (not config_conf_d.fail())

1441

{

1442

1443

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

1444

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

1445

++iter)

1358

1446

{

1359

1360

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

1361

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

1362

++iter)

1447

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

1448

1449

if (not file_entry.empty()

1450

&& file_entry != "."

1451

&& file_entry != "..")

1363

1452

{

1364

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

1365

1366

if (not file_entry.empty()

1367

&& file_entry != "."

1368

&& file_entry != "..")

1369

{

1370

fs::path the_entry(config_conf_d_location);

1371

the_entry /= file_entry;

1372

defaults_file_list.push_back(the_entry.file_string());

1373

}

1453

fs::path the_entry(config_conf_d_location);

1454

the_entry /= file_entry;

1455

defaults_file_list.push_back(the_entry.file_string());

1374

1456

}

1375

1457

}

1376

1458

}

1377

1459

1460

process_defaults_files();

1378

1461

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

1379

1462

1380

1463

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

1381

try

1382

{

1383

po::notify(vm);

1384

}

1385

catch (po::validation_error &err)

1386

{

1387

errmsg_printf(error::ERROR,

1388

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

1389

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

1390

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

1391

unireg_abort(1);

1392

}

1393

1394

process_defaults_files();

1395

1396

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

1397

plugin loader options */

1398

1399

try

1400

{

1401

po::notify(vm);

1402

}

1403

catch (po::validation_error &err)

1404

{

1405

errmsg_printf(error::ERROR,

1406

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

1407

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

1408

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

1409

unireg_abort(1);

1410

}

1411

1412

return 0;

1413

}

1414

1415

int init_remaining_variables(module::Registry &plugins)

1416

{

1417

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

1418

1419

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

1420

1464

po::notify(vm);

1421

1465

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

1422

1466

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

1423

1467

1424

1468

1425

1469

if (plugin_init(plugins, plugin_options))

1426

1470

{

1427

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

1471

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

1428

1472

unireg_abort(1);

1429

1473

}

1430

1474

1435

1479

{

1436

1480

po::parsed_options final_parsed=

1437

1481

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

1438

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

1482

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

1439

1483

1440

1484

final_unknown_options=

1441

1485

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

1443

1487

po::store(final_parsed, vm);

1444

1488

1445

1489

}

1446

catch (po::validation_error &err)

1447

{

1448

errmsg_printf(error::ERROR,

1449

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

1450

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

1451

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

1452

unireg_abort(1);

1453

}

1454

1490

catch (po::invalid_command_line_syntax &err)

1455

1491

{

1456

errmsg_printf(error::ERROR,

1492

errmsg_printf(ERRMSG_LVL_ERROR,

1457

1493

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

1458

1494

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

1459

1495

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

1461

1497

}

1462

1498

catch (po::unknown_option &err)

1463

1499

{

1464

errmsg_printf(error::ERROR,

1500

errmsg_printf(ERRMSG_LVL_ERROR,

1465

1501

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

1466

1502

err.what());

1467

1503

unireg_abort(1);

1468

1504

}

1469

1505

1470

try

1471

{

1472

po::notify(vm);

1473

}

1474

catch (po::validation_error &err)

1475

{

1476

errmsg_printf(error::ERROR,

1477

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

1478

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

1479

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

1480

unireg_abort(1);

1481

}

1506

po::notify(vm);

1482

1507

1483

1508

get_options();

1484

1509

1497

1522

1498

1523

fix_paths();

1499

1524

1525

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

1500

1526

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

1501

1527

1502

1528

if (item_create_init())

1503

1529

return 1;

1504

if (sys_var_init())

1530

if (set_var_init())

1505

1531

return 1;

1506

1532

/* Creates static regex matching for temporal values */

1507

1533

if (! init_temporal_formats())

1510

1536

if (!(default_charset_info=

1511

1537

get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

1512

1538

{

1513

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

1539

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

1514

1540

return 1; // Eof of the list

1515

1541

}

1516

1542

1522

1548

const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);

1523

1549

if (not default_collation)

1524

1550

{

1525

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

1551

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

1526

1552

return 1;

1527

1553

}

1528

1554

if (not my_charset_same(default_charset_info, default_collation))

1529

1555

{

1530

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

1556

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

1531

1557

default_collation_name,

1532

1558

default_charset_info->csname);

1533

1559

return 1;

1540

1566

if (not (character_set_filesystem=

1541

1567

get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))

1542

1568

{

1543

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

1569

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

1544

1570

return 1;

1545

1571

}

1546

1572

global_system_variables.character_set_filesystem= character_set_filesystem;

1548

1574

if (!(my_default_lc_time_names=

1549

1575

my_locale_by_name(lc_time_names_name)))

1550

1576

{

1551

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

1577

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

1552

1578

return 1;

1553

1579

}

1554

1580

global_system_variables.lc_time_names= my_default_lc_time_names;

1568

1594

1569

1595

if (table_cache_init())

1570

1596

{

1571

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

1597

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

1572

1598

unireg_abort(1);

1573

1599

}

1574

1575

// Resize the definition Cache at startup

1576

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

1577

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

1578

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

1600

TableShare::cacheStart();

1579

1601

1580

1602

setup_fpu();

1581

1603

1583

1605

1584

1606

if (xid_cache_init())

1585

1607

{

1586

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

1608

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

1587

1609

unireg_abort(1);

1588

1610

}

1589

1611

1612

1634

1613

1635

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

1614

1636

{

1615

errmsg_printf(error::ERROR,

1637

errmsg_printf(ERRMSG_LVL_ERROR,

1616

1638

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

1617

1639

unireg_abort(1);

1618

1640

}

1637

1659

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

1638

1660

if (engine == NULL)

1639

1661

{

1640

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

1662

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

1641

1663

default_storage_engine_str);

1642

1664

unireg_abort(1);

1643

1665

}

1678

1700

OPT_BACK_LOG,

1679

1701

OPT_JOIN_BUFF_SIZE,

1680

1702

OPT_MAX_ALLOWED_PACKET,

1703

OPT_MAX_CONNECT_ERRORS,

1681

1704

OPT_MAX_HEP_TABLE_SIZE,

1682

1705

OPT_MAX_JOIN_SIZE,

1683

1706

OPT_MAX_SORT_LENGTH,

1731

1754

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

1732

1755

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

1733

1756

0, 0},

1734

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

1735

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

1736

0, 0},

1737

1757

{"auto-increment-increment", OPT_AUTO_INCREMENT,

1738

1758

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

1739

1759

(char**) &global_system_variables.auto_increment_increment,

1770

1790

{"datadir", 'h',

1771

1791

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

1772

1792

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

1793

{"default-storage-engine", OPT_STORAGE_ENGINE,

1794

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

1795

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

1796

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

1797

{"default-time-zone", OPT_DEFAULT_TIME_ZONE,

1798

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

1799

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

1800

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

1773

1801

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

1774

1802

{"exit-info", 'T',

1775

1803

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

1780

1808

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

1781

1809

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

1782

1810

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

1811

{"lc-time-names", OPT_LC_TIME_NAMES,

1812

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

1813

(char**) &lc_time_names_name,

1814

(char**) &lc_time_names_name,

1815

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

1783

1816

{"log-warnings", 'W',

1784

1817

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

1785

1818

(char**) &global_system_variables.log_warnings,

1822

1855

"supported)"),

1823

1856

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

1824

1857

0, 0, 0, 0, 0},

1858

{"tmpdir", 't',

1859

N_("Path for temporary files."),

1860

(char**) &opt_drizzle_tmpdir,

1861

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

1825

1862

{"transaction-isolation", OPT_TX_ISOLATION,

1826

1863

N_("Default transaction isolation level."),

1827

1864

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

1830

1867

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

1831

1868

0, 0, 0, GET_STR, REQUIRED_ARG,

1832

1869

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

1870

{"version", 'V',

1871

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

1872

0, 0, 0, GET_NO_ARG,

1873

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

1833

1874

{"back_log", OPT_BACK_LOG,

1834

1875

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

1835

1876

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

1848

1889

(char**) &global_system_variables.div_precincrement,

1849

1890

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

1850

1891

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

1892

{ "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,

1893

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

1894

(char**) &global_system_variables.group_concat_max_len,

1895

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

1896

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

1851

1897

{ "join_buffer_size", OPT_JOIN_BUFF_SIZE,

1852

1898

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

1853

1899

(char**) &global_system_variables.join_buff_size,

1858

1904

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

1859

1905

(char**) &global_system_variables.max_allowed_packet,

1860

1906

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

1861

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

1907

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

1908

{"max_connect_errors", OPT_MAX_CONNECT_ERRORS,

1909

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

1910

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

1911

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

1912

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

1913

{"max_error_count", OPT_MAX_ERROR_COUNT,

1914

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

1915

(char**) &global_system_variables.max_error_count,

1916

(char**) &max_system_variables.max_error_count,

1917

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

1862

1918

{"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,

1863

1919

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

1864

1920

(char**) &global_system_variables.max_heap_table_size,

1978

2034

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

1979

2035

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

1980

2036

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

2037

{"scheduler", OPT_SCHEDULER,

2038

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

2039

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

2040

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

1981

2041

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

1982

2042

{"sort_buffer_size", OPT_SORT_BUFFER,

1983

2043

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

2071

2131

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

2072

2132

cleanup_done= 0;

2073

2133

dropping_tables= ha_open_options=0;

2074

getDebug().reset();

2134

test_flags.reset();

2075

2135

wake_thread=0;

2076

2136

abort_loop= select_thread_in_use= false;

2077

shutdown_in_progress= 0;

2137

ready_to_exit= shutdown_in_progress= 0;

2078

2138

drizzled_user= drizzled_chroot= 0;

2079

2139

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

2080

2140

key_map_full.set();

2089

2149

session_startup_options= (OPTION_AUTO_IS_NULL | OPTION_SQL_NOTES);

2090

2150

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

2091

2151

global_thread_id= 1UL;

2092

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

2152

getSessionList().clear();

2093

2153

2094

2154

/* Variables in libraries */

2095

2155

default_character_set_name= "utf8";

2139

2199

#else

2140

2200

have_symlink=SHOW_OPTION_YES;

2141

2201

#endif

2202

2203

connection_count= 0;

2142

2204

}

2143

2205

2144

2206

2159

2221

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

2160

2222

2161

2223

else

2162

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

2224

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

2163

2225

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

2164

2226

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

2165

2227

}

2170

2232

exit(0);

2171

2233

}

2172

2234

2173

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

2174

{

2175

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

2176

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

2177

global_system_variables.sortbuff_size))

2178

{

2179

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

2180

exit(-1);

2181

}

2182

2183

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

2184

}

2185

2186

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

2187

{

2188

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

2189

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

2190

global_system_variables.join_buff_size))

2191

{

2192

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

2193

exit(-1);

2194

}

2195

2196

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

2197

}

2198

2199

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

2200

{

2201

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

2202

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

2203

global_system_variables.read_rnd_buff_size))

2204

{

2205

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

2206

exit(-1);

2207

}

2208

2209

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

2210

}

2211

2212

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

2213

{

2214

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

2215

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

2216

global_system_variables.read_buff_size))

2217

{

2218

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

2219

exit(-1);

2220

}

2221

2222

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

2223

}

2224

2225

2235

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

2226

2236

{

2227

2237

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

2228

2238

{

2229

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

2239

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

2230

2240

}

2231

2241

}

2232

2242

2233

2243

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

2234

2244

{

2235

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

2245

test_flags.set(TEST_CORE_ON_SIGNAL);

2236

2246

}

2237

2247

2238

2248

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

2239

2249

{

2240

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

2250

test_flags.set(TEST_NO_STACKTRACE);

2241

2251

}

2242

2252

2243

2253

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

2247

2257

2248

2258

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

2249

2259

{

2250

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

2251

global_system_variables.tx_isolation= type - 1;

2260

int type;

2261

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

2262

global_system_variables.tx_isolation= (type-1);

2252

2263

}

2253

2264

2254

2265

/* @TODO Make this all strings */

2275

2286

if (opt_debugging)

2276

2287

{

2277

2288

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

2278

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

2279

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

2280

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

2289

test_flags.set(TEST_SIGINT);

2290

test_flags.set(TEST_NO_STACKTRACE);

2291

test_flags.reset(TEST_CORE_ON_SIGNAL);

2281

2292

}

2282

2293

2283

2294

if (drizzled_chroot)

2299

2310

pid_file_path= getDataHome();

2300

2311

pid_file_path /= pid_file;

2301

2312

}

2302

pid_file= fs::system_complete(pid_file_path);

2313

pid_file= pid_file_path;

2303

2314

2304

2315

if (not opt_help)

2305

2316

{

2329

2340

{

2330

2341

if (errno != EEXIST)

2331

2342

{

2332

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

2343

perror(drizzle_tmpdir.c_str());

2333

2344

exit(1);

2334

2345

}

2335

2346

}

2336

2347

2337

2348

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

2338

2349

{

2339

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

2350

perror(drizzle_tmpdir.c_str());

2340

2351

exit(1);

2341

2352

}

2342

2353

}

Older »