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

1302

N_("Default transaction isolation level."))

1204

1303

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

1205

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

1304

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

1206

1305

("version,V",

1207

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

1208

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

1209

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

1306

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

1307

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

1308

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

1210

1309

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

1211

1310

"requests in a very short time."))

1212

1311

("bulk-insert-buffer-size",

1213

1312

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 "

1313

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

1215

1314

"a limit per thread!"))

1216

1315

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

1316

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

1218

1317

"value."))

1219

1318

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

1319

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

1221

1320

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

1222

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

1223

("join-heap-threshold",

1224

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

1225

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

1226

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

1227

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

1321

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

1322

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

1323

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

1324

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

1325

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

1326

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

1228

1327

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

1328

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

1230

1329

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

1330

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

1232

1331

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

1332

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

1234

1333

"return an error."))

1235

1334

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

1335

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

1237

1336

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

1337

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

1239

1338

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

1339

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

1241

1340

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

1242

1341

"rest are ignored)."))

1243

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

1244

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

1342

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

1343

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

1245

1344

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

1345

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

1247

1346

"rows to file."))

1248

1347

("disable-optimizer-prune",

1249

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

1348

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

1250

1349

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

1251

1350

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

1351

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

1253

1352

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

1254

1353

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

1255

1354

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

1258

1357

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

1259

1358

"testing/comparison)."))

1260

1359

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

1360

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

1262

1361

("query-alloc-block-size",

1263

1362

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

1363

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

1265

1364

("query-prealloc-size",

1266

1365

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

1366

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

1268

1367

("range-alloc-block-size",

1269

1368

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

1369

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

1271

1370

("read-buffer-size",

1272

1371

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 "

1372

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

1274

1373

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

1275

1374

"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

1375

("read-rnd-buffer-size",

1280

1376

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 "

1377

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

1282

1378

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

1283

1379

"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

1380

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

1288

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

1381

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

1289

1382

("sort-buffer-size",

1290

1383

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

1384

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

1295

1385

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

1296

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

1386

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

1297

1387

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

1388

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

1299

1389

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

1390

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

1301

1391

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

1302

1392

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

1393

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

1304

1394

("tmp-table-size",

1305

1395

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"

1396

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

1307

1397

" 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

1398

;

1311

1399

1312

1400

full_options.add(long_options);

1326

1414

{

1327

1415

po::store(parsed, vm);

1328

1416

}

1329

catch (std::exception&)

1417

catch (...)

1330

1418

{

1331

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

1419

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

1332

1420

unireg_abort(1);

1333

1421

}

1334

1422

1335

1423

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

1336

1424

{

1337

fs::path system_config_file_drizzle(system_config_dir);

1338

system_config_file_drizzle /= "drizzled.cnf";

1339

1425

defaults_file_list.insert(defaults_file_list.begin(),

1340

system_config_file_drizzle.file_string());

1341

1342

fs::path config_conf_d_location(system_config_dir);

1343

config_conf_d_location /= "conf.d";

1344

1345

1346

CachedDirectory config_conf_d(config_conf_d_location.file_string());

1347

if (not config_conf_d.fail())

1426

system_config_file_drizzle);

1427

}

1428

1429

string config_conf_d_location(vm["config-dir"].as<string>());

1430

config_conf_d_location.append("/conf.d");

1431

CachedDirectory config_conf_d(config_conf_d_location);

1432

if (not config_conf_d.fail())

1433

{

1434

1435

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

1436

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

1437

++iter)

1348

1438

{

1349

1350

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

1351

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

1352

++iter)

1439

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

1440

1441

if (not file_entry.empty()

1442

&& file_entry != "."

1443

&& file_entry != "..")

1353

1444

{

1354

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

1355

1356

if (not file_entry.empty()

1357

&& file_entry != "."

1358

&& file_entry != "..")

1359

{

1360

fs::path the_entry(config_conf_d_location);

1361

the_entry /= file_entry;

1362

defaults_file_list.push_back(the_entry.file_string());

1363

}

1445

string the_entry(config_conf_d_location);

1446

the_entry.push_back('/');

1447

the_entry.append(file_entry);

1448

defaults_file_list.push_back(the_entry);

1364

1449

}

1365

1450

}

1366

1451

}

1367

1452

1453

process_defaults_files();

1368

1454

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

1369

1455

1370

1456

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

1371

try

1372

{

1373

po::notify(vm);

1374

}

1375

catch (po::validation_error &err)

1376

{

1377

errmsg_printf(error::ERROR,

1378

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

1379

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

1380

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

1381

unireg_abort(1);

1382

}

1383

1384

process_defaults_files();

1385

1386

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

1387

plugin loader options */

1388

1389

try

1390

{

1391

po::notify(vm);

1392

}

1393

catch (po::validation_error &err)

1394

{

1395

errmsg_printf(error::ERROR,

1396

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

1397

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

1398

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

1399

unireg_abort(1);

1400

}

1401

1402

return 0;

1403

}

1404

1405

int init_remaining_variables(module::Registry &plugins)

1406

{

1407

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

1408

1409

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

1410

1457

po::notify(vm);

1411

1458

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

1412

1459

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

1413

1460

1414

1461

1415

1462

if (plugin_init(plugins, plugin_options))

1416

1463

{

1417

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

1464

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

1418

1465

unireg_abort(1);

1419

1466

}

1420

1467

1425

1472

{

1426

1473

po::parsed_options final_parsed=

1427

1474

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

1428

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

1475

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

1429

1476

1430

1477

final_unknown_options=

1431

1478

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

1433

1480

po::store(final_parsed, vm);

1434

1481

1435

1482

}

1436

catch (po::validation_error &err)

1437

{

1438

errmsg_printf(error::ERROR,

1439

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

1440

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

1441

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

1442

unireg_abort(1);

1443

}

1444

1483

catch (po::invalid_command_line_syntax &err)

1445

1484

{

1446

errmsg_printf(error::ERROR,

1485

errmsg_printf(ERRMSG_LVL_ERROR,

1447

1486

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

1448

1487

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

1449

1488

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

1451

1490

}

1452

1491

catch (po::unknown_option &err)

1453

1492

{

1454

errmsg_printf(error::ERROR,

1493

errmsg_printf(ERRMSG_LVL_ERROR,

1455

1494

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

1456

1495

err.what());

1457

1496

unireg_abort(1);

1458

1497

}

1459

1498

1460

try

1461

{

1462

po::notify(vm);

1463

}

1464

catch (po::validation_error &err)

1465

{

1466

errmsg_printf(error::ERROR,

1467

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

1468

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

1469

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

1470

unireg_abort(1);

1471

}

1499

po::notify(vm);

1472

1500

1473

1501

get_options();

1474

1502

1487

1515

1488

1516

fix_paths();

1489

1517

1518

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

1490

1519

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

1491

1520

1492

1521

if (item_create_init())

1493

1522

return 1;

1494

if (sys_var_init())

1523

if (set_var_init())

1495

1524

return 1;

1496

1525

/* Creates static regex matching for temporal values */

1497

1526

if (! init_temporal_formats())

1500

1529

if (!(default_charset_info=

1501

1530

get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

1502

1531

{

1503

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

1532

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

1504

1533

return 1; // Eof of the list

1505

1534

}

1506

1535

1512

1541

const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);

1513

1542

if (not default_collation)

1514

1543

{

1515

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

1544

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

1516

1545

return 1;

1517

1546

}

1518

1547

if (not my_charset_same(default_charset_info, default_collation))

1519

1548

{

1520

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

1549

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

1521

1550

default_collation_name,

1522

1551

default_charset_info->csname);

1523

1552

return 1;

1530

1559

if (not (character_set_filesystem=

1531

1560

get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))

1532

1561

{

1533

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

1562

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

1534

1563

return 1;

1535

1564

}

1536

1565

global_system_variables.character_set_filesystem= character_set_filesystem;

1538

1567

if (!(my_default_lc_time_names=

1539

1568

my_locale_by_name(lc_time_names_name)))

1540

1569

{

1541

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

1570

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

1542

1571

return 1;

1543

1572

}

1544

1573

global_system_variables.lc_time_names= my_default_lc_time_names;

1558

1587

1559

1588

if (table_cache_init())

1560

1589

{

1561

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

1590

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

1562

1591

unireg_abort(1);

1563

1592

}

1564

1565

// Resize the definition Cache at startup

1566

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

1567

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

1568

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

1593

TableShare::cacheStart();

1569

1594

1570

1595

setup_fpu();

1571

1596

1573

1598

1574

1599

if (xid_cache_init())

1575

1600

{

1576

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

1601

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

1577

1602

unireg_abort(1);

1578

1603

}

1579

1604

1602

1627

1603

1628

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

1604

1629

{

1605

errmsg_printf(error::ERROR,

1630

errmsg_printf(ERRMSG_LVL_ERROR,

1606

1631

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

1607

1632

unireg_abort(1);

1608

1633

}

1627

1652

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

1628

1653

if (engine == NULL)

1629

1654

{

1630

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

1655

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

1631

1656

default_storage_engine_str);

1632

1657

unireg_abort(1);

1633

1658

}

1668

1693

OPT_BACK_LOG,

1669

1694

OPT_JOIN_BUFF_SIZE,

1670

1695

OPT_MAX_ALLOWED_PACKET,

1696

OPT_MAX_CONNECT_ERRORS,

1671

1697

OPT_MAX_HEP_TABLE_SIZE,

1672

1698

OPT_MAX_JOIN_SIZE,

1673

1699

OPT_MAX_SORT_LENGTH,

1721

1747

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

1722

1748

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

1723

1749

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

1750

{"auto-increment-increment", OPT_AUTO_INCREMENT,

1728

1751

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

1729

1752

(char**) &global_system_variables.auto_increment_increment,

1730

1753

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

1731

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

1754

OPT_ARG, 1, 1, UINT64_MAX, 0, 1, 0 },

1732

1755

{"auto-increment-offset", OPT_AUTO_INCREMENT_OFFSET,

1733

1756

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

1734

1757

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

1735

1758

(char**) &global_system_variables.auto_increment_offset,

1736

1759

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

1737

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

1760

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

1738

1761

{"basedir", 'b',

1739

1762

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

1740

1763

"relative to this."),

1741

NULL, NULL, 0, GET_STR, REQUIRED_ARG,

1764

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

1742

1765

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

1743

1766

{"chroot", 'r',

1744

1767

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

1760

1783

{"datadir", 'h',

1761

1784

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

1762

1785

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

1786

{"default-storage-engine", OPT_STORAGE_ENGINE,

1787

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

1788

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

1789

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

1790

{"default-time-zone", OPT_DEFAULT_TIME_ZONE,

1791

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

1792

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

1793

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

1763

1794

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

1764

1795

{"exit-info", 'T',

1765

1796

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

1770

1801

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

1771

1802

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

1772

1803

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

1804

{"lc-time-names", OPT_LC_TIME_NAMES,

1805

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

1806

(char**) &lc_time_names_name,

1807

(char**) &lc_time_names_name,

1808

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

1773

1809

{"log-warnings", 'W',

1774

1810

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

1775

1811

(char**) &global_system_variables.log_warnings,

1777

1813

0, 0, 0},

1778

1814

{"pid-file", OPT_PID_FILE,

1779

1815

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

1780

NULL, NULL, 0, GET_STR,

1816

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

1781

1817

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

1782

1818

{"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,

1783

1819

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

1787

1823

{"secure-file-priv", OPT_SECURE_FILE_PRIV,

1788

1824

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

1789

1825

"within specified directory"),

1790

NULL, NULL, 0,

1826

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

1791

1827

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

1792

1828

{"server-id", OPT_SERVER_ID,

1793

1829

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

1812

1848

"supported)"),

1813

1849

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

1814

1850

0, 0, 0, 0, 0},

1851

{"tmpdir", 't',

1852

N_("Path for temporary files."),

1853

(char**) &opt_drizzle_tmpdir,

1854

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

1815

1855

{"transaction-isolation", OPT_TX_ISOLATION,

1816

1856

N_("Default transaction isolation level."),

1817

1857

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

1820

1860

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

1821

1861

0, 0, 0, GET_STR, REQUIRED_ARG,

1822

1862

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

1863

{"version", 'V',

1864

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

1865

0, 0, 0, GET_NO_ARG,

1866

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

1823

1867

{"back_log", OPT_BACK_LOG,

1824

1868

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

1825

1869

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

1838

1882

(char**) &global_system_variables.div_precincrement,

1839

1883

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

1840

1884

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

1885

{ "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,

1886

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

1887

(char**) &global_system_variables.group_concat_max_len,

1888

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

1889

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

1841

1890

{ "join_buffer_size", OPT_JOIN_BUFF_SIZE,

1842

1891

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

1843

1892

(char**) &global_system_variables.join_buff_size,

1848

1897

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

1849

1898

(char**) &global_system_variables.max_allowed_packet,

1850

1899

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

1851

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

1900

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

1901

{"max_connect_errors", OPT_MAX_CONNECT_ERRORS,

1902

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

1903

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

1904

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

1905

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

1906

{"max_error_count", OPT_MAX_ERROR_COUNT,

1907

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

1908

(char**) &global_system_variables.max_error_count,

1909

(char**) &max_system_variables.max_error_count,

1910

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

1852

1911

{"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,

1853

1912

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

1854

1913

(char**) &global_system_variables.max_heap_table_size,

1855

1914

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

1856

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

1915

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

1857

1916

MALLOC_OVERHEAD, 1024, 0},

1858

1917

{"max_join_size", OPT_MAX_JOIN_SIZE,

1859

1918

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

1950

2009

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

1951

2010

(char**) &global_system_variables.range_alloc_block_size,

1952

2011

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

1953

REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, (int64_t)SIZE_MAX,

2012

REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, SIZE_MAX,

1954

2013

0, 1024, 0},

1955

2014

{"read_buffer_size", OPT_RECORD_BUFFER,

1956

2015

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

1968

2027

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

1969

2028

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

1970

2029

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

2030

{"scheduler", OPT_SCHEDULER,

2031

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

2032

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

2033

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

1971

2034

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

1972

2035

{"sort_buffer_size", OPT_SORT_BUFFER,

1973

2036

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

1974

2037

(char**) &global_system_variables.sortbuff_size,

1975

2038

(char**) &max_system_variables.sortbuff_size, 0, GET_SIZE, REQUIRED_ARG,

1976

MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*8, (int64_t)SIZE_MAX,

2039

MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*8, SIZE_MAX,

1977

2040

MALLOC_OVERHEAD, 1, 0},

1978

2041

{"table_definition_cache", OPT_TABLE_DEF_CACHE,

1979

2042

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

1993

2056

(char**) &my_thread_stack_size,

1994

2057

(char**) &my_thread_stack_size, 0, GET_SIZE,

1995

2058

REQUIRED_ARG,DEFAULT_THREAD_STACK,

1996

UINT32_C(1024*512), (int64_t)SIZE_MAX, 0, 1024, 0},

2059

UINT32_C(1024*512), SIZE_MAX, 0, 1024, 0},

1997

2060

{"tmp_table_size", OPT_TMP_TABLE_SIZE,

1998

2061

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

1999

2062

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

2000

2063

(char**) &global_system_variables.tmp_table_size,

2001

2064

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

2002

REQUIRED_ARG, 16*1024*1024L, 1024, (int64_t)MAX_MEM_TABLE_SIZE, 0, 1, 0},

2065

REQUIRED_ARG, 16*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},

2003

2066

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

2004

2067

};

2005

2068

2058

2121

static void drizzle_init_variables(void)

2059

2122

{

2060

2123

/* Things reset to zero */

2124

drizzle_home[0]= pidfile_name[0]= 0;

2061

2125

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

2126

opt_secure_file_priv= 0;

2062

2127

cleanup_done= 0;

2063

2128

dropping_tables= ha_open_options=0;

2064

getDebug().reset();

2129

test_flags.reset();

2065

2130

wake_thread=0;

2066

2131

abort_loop= select_thread_in_use= false;

2067

shutdown_in_progress= 0;

2132

ready_to_exit= shutdown_in_progress= 0;

2068

2133

drizzled_user= drizzled_chroot= 0;

2069

2134

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

2070

2135

key_map_full.set();

2076

2141

character_set_filesystem= &my_charset_bin;

2077

2142

2078

2143

/* Things with default values that are not zero */

2144

drizzle_home_ptr= drizzle_home;

2145

pidfile_name_ptr= pidfile_name;

2079

2146

session_startup_options= (OPTION_AUTO_IS_NULL | OPTION_SQL_NOTES);

2080

2147

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

2081

2148

global_thread_id= 1UL;

2082

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

2149

getSessionList().clear();

2083

2150

2084

2151

/* Variables in libraries */

2085

2152

default_character_set_name= "utf8";

2097

2164

max_system_variables.auto_increment_increment= UINT64_MAX;

2098

2165

max_system_variables.auto_increment_offset= UINT64_MAX;

2099

2166

max_system_variables.completion_type= 2;

2100

max_system_variables.log_warnings= true;

2167

max_system_variables.log_warnings= 1;

2101

2168

max_system_variables.bulk_insert_buff_size= ULONG_MAX;

2102

2169

max_system_variables.div_precincrement= DECIMAL_MAX_SCALE;

2103

2170

max_system_variables.group_concat_max_len= ULONG_MAX;

2129

2196

#else

2130

2197

have_symlink=SHOW_OPTION_YES;

2131

2198

#endif

2199

2200

const char *tmpenv;

2201

if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))

2202

tmpenv = PREFIX;

2203

(void) strncpy(drizzle_home, tmpenv, sizeof(drizzle_home)-1);

2204

2205

connection_count= 0;

2132

2206

}

2133

2207

2134

2208

2139

2213

static void get_options()

2140

2214

{

2141

2215

2142

fs::path &data_home_catalog= getDataHomeCatalog();

2216

if (vm.count("base-dir"))

2217

{

2218

strncpy(drizzle_home,vm["base-dir"].as<string>().c_str(),sizeof(drizzle_home)-1);

2219

}

2220

2221

if (vm.count("datadir"))

2222

{

2223

getDataHome()= vm["datadir"].as<string>();

2224

}

2225

string &data_home_catalog= getDataHomeCatalog();

2143

2226

data_home_catalog= getDataHome();

2144

data_home_catalog /= "local";

2227

data_home_catalog.push_back('/');

2228

data_home_catalog.append("local");

2145

2229

2146

2230

if (vm.count("user"))

2147

2231

{

2149

2233

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

2150

2234

2151

2235

else

2152

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

2236

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

2153

2237

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

2154

2238

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

2155

2239

}

2160

2244

exit(0);

2161

2245

}

2162

2246

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

2247

if (vm.count("log-warnings"))

2248

{

2249

if (vm["log-warnings"].as<string>().empty())

2250

global_system_variables.log_warnings++;

2251

else if (vm["log-warnings"].as<string>().compare("0"))

2252

global_system_variables.log_warnings= 0L;

2253

else

2254

global_system_variables.log_warnings= atoi(vm["log-warnings"].as<string>().c_str());

2213

2255

}

2214

2256

2215

2257

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

2216

2258

{

2217

2259

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

2218

2260

{

2219

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

2261

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

2220

2262

}

2221

2263

}

2222

2264

2223

2265

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

2224

2266

{

2225

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

2267

test_flags.set(TEST_CORE_ON_SIGNAL);

2226

2268

}

2227

2269

2228

2270

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

2229

2271

{

2230

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

2272

test_flags.set(TEST_NO_STACKTRACE);

2231

2273

}

2232

2274

2233

2275

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

2235

2277

internal::my_use_symdir=0;

2236

2278

}

2237

2279

2280

if (vm.count("pid-file"))

2281

{

2282

strncpy(pidfile_name, vm["pid-file"].as<string>().c_str(), sizeof(pidfile_name)-1);

2283

}

2284

2238

2285

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

2239

2286

{

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;

2287

int type;

2288

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

2289

global_system_variables.tx_isolation= (type-1);

2242

2290

}

2243

2291

2244

2292

/* @TODO Make this all strings */

2265

2313

if (opt_debugging)

2266

2314

{

2267

2315

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

2316

test_flags.set(TEST_SIGINT);

2317

test_flags.set(TEST_NO_STACKTRACE);

2318

test_flags.reset(TEST_CORE_ON_SIGNAL);

2271

2319

}

2272

2320

2273

2321

if (drizzled_chroot)

2281

2329

}

2282

2330

2283

2331

2332

static const char *get_relative_path(const char *path)

2333

{

2334

if (internal::test_if_hard_path(path) &&

2335

(strncmp(path, PREFIX, strlen(PREFIX)) == 0) &&

2336

strcmp(PREFIX,FN_ROOTDIR))

2337

{

2338

if (strlen(PREFIX) < strlen(path))

2339

path+=(size_t) strlen(PREFIX);

2340

while (*path == FN_LIBCHAR)

2341

path++;

2342

}

2343

return path;

2344

}

2345

2346

2284

2347

static void fix_paths()

2285

2348

{

2286

fs::path pid_file_path(pid_file);

2349

char buff[FN_REFLEN],*pos,rp_buff[PATH_MAX];

2350

internal::convert_dirname(drizzle_home,drizzle_home,NULL);

2351

/* Resolve symlinks to allow 'drizzle_home' to be a relative symlink */

2352

#if defined(HAVE_BROKEN_REALPATH)

2353

internal::my_load_path(drizzle_home, drizzle_home, NULL);

2354

#else

2355

if (!realpath(drizzle_home,rp_buff))

2356

internal::my_load_path(rp_buff, drizzle_home, NULL);

2357

rp_buff[FN_REFLEN-1]= '\0';

2358

strcpy(drizzle_home,rp_buff);

2359

/* Ensure that drizzle_home ends in FN_LIBCHAR */

2360

pos= strchr(drizzle_home, '\0');

2361

#endif

2362

if (pos[-1] != FN_LIBCHAR)

2363

{

2364

pos[0]= FN_LIBCHAR;

2365

pos[1]= 0;

2366

}

2367

(void) internal::my_load_path(drizzle_home, drizzle_home,""); // Resolve current dir

2368

2369

fs::path pid_file_path(pidfile_name);

2287

2370

if (pid_file_path.root_path().string() == "")

2288

2371

{

2289

pid_file_path= getDataHome();

2290

pid_file_path /= pid_file;

2291

}

2292

pid_file= fs::system_complete(pid_file_path);

2372

pid_file_path= fs::path(getDataHome());

2373

pid_file_path /= pidfile_name;

2374

}

2375

strncpy(pidfile_name, pid_file_path.file_string().c_str(), sizeof(pidfile_name)-1);

2376

2377

2378

const char *sharedir= get_relative_path(PKGDATADIR);

2379

if (internal::test_if_hard_path(sharedir))

2380

strncpy(buff,sharedir,sizeof(buff)-1);

2381

else

2382

{

2383

strcpy(buff, drizzle_home);

2384

strncat(buff, sharedir, sizeof(buff)-strlen(drizzle_home)-1);

2385

}

2386

internal::convert_dirname(buff,buff,NULL);

2293

2387

2294

2388

if (not opt_help)

2295

2389

{

2303

2397

}

2304

2398

else if (tmp_string == NULL)

2305

2399

{

2306

drizzle_tmpdir.append(getDataHome().file_string());

2400

drizzle_tmpdir.append(getDataHome());

2307

2401

drizzle_tmpdir.push_back(FN_LIBCHAR);

2308

2402

drizzle_tmpdir.append(GLOBAL_TEMPORARY_EXT);

2309

2403

}

2319

2413

{

2320

2414

if (errno != EEXIST)

2321

2415

{

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

2416

perror(drizzle_tmpdir.c_str());

2323

2417

exit(1);

2324

2418

}

2325

2419

}

2326

2420

2327

2421

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

2328

2422

{

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

2423

perror(drizzle_tmpdir.c_str());

2330

2424

exit(1);

2331

2425

}

2332

2426

}

2333

2427

2428

2429

Convert the secure-file-priv option to system format, allowing

2430

a quick strcmp to check if read or write is in an allowed dir

2431

2432

if (vm.count("secure-file-priv"))

2433

{

2434

internal::convert_dirname(buff, vm["secure-file-priv"].as<string>().c_str(), NULL);

2435

free(opt_secure_file_priv);

2436

opt_secure_file_priv= strdup(buff);

2437

if (opt_secure_file_priv == NULL)

2438

exit(1);

2439

}

2334

2440

}

2335

2441

2336

2442

} /* namespace drizzled */

Older »