~drizzle-trunk/drizzle/development

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

1232

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

1233

1204

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

1234

1205

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

1235

1206

("version,V",

1236

1207

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

1237

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

1208

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

1238

1209

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

1239

1210

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

1240

1211

"requests in a very short time."))

1249

1220

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

1250

1221

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

1251

1222

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

1252

("join-heap-threshold",

1253

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

1254

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

1255

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

1223

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

1256

1224

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

1257

1225

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

1258

1226

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

1272

1240

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

1273

1241

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

1274

1242

"rest are ignored)."))

1275

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

1243

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

1276

1244

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

1277

1245

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

1278

1246

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

1289

1257

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

1290

1258

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

1291

1259

"testing/comparison)."))

1260

("plugin-dir", po::value<string>(),

1261

N_("Directory for plugins."))

1262

("plugin-add", po::value<vector<string> >()->composing()->notifier(&compose_plugin_add),

1263

N_("Optional comma separated list of plugins to load at startup in addition "

1264

"to the default list of plugins. "

1265

"[for example: --plugin_add=crc32,logger_gearman]"))

1266

("plugin-remove", po::value<vector<string> >()->composing()->notifier(&compose_plugin_remove),

1267

N_("Optional comma separated list of plugins to not load at startup. Effectively "

1268

"removes a plugin from the list of plugins to be loaded. "

1269

"[for example: --plugin_remove=crc32,logger_gearman]"))

1270

("plugin-load", po::value<string>()->notifier(&notify_plugin_load)->default_value(PANDORA_PLUGIN_LIST),

1271

N_("Optional comma separated list of plugins to load at starup instead of "

1272

"the default plugin load list. "

1273

"[for example: --plugin_load=crc32,logger_gearman]"))

1292

1274

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

1293

1275

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

1294

1276

("query-alloc-block-size",

1305

1287

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

1306

1288

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

1307

1289

"want to increase this value."))

1308

("read-buffer-threshold",

1309

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

1310

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

1311

1290

("read-rnd-buffer-size",

1312

1291

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

1313

1292

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

1314

1293

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

1315

1294

"to the value of record_buffer."))

1316

("read-rnd-threshold",

1317

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

1318

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

1319

1295

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

1320

1296

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

1321

1297

("sort-buffer-size",

1322

1298

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

1323

1299

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

1324

("sort-heap-threshold",

1325

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

1326

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

1327

1300

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

1328

1301

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

1329

1302

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

1337

1310

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

1338

1311

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

1339

1312

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

1313

("no-defaults", po::value<bool>()->default_value(false)->zero_tokens(),

1314

N_("Configuration file defaults are not used if no-defaults is set"))

1315

("defaults-file", po::value<vector<string> >()->composing()->notifier(&compose_defaults_file_list),

1316

N_("Configuration file to use"))

1317

("config-dir", po::value<string>()->default_value(system_config_dir_drizzle),

1318

N_("Base location for config files"))

1340

1319

;

1341

1320

1342

full_options.add(long_options);

1343

full_options.add(plugin_load_options);

1344

1345

initial_options.add(config_options);

1346

initial_options.add(plugin_load_options);

1347

1321

// Disable allow_guessing

1348

1322

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

1349

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

1323

1350

1324

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

1351

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

1325

options(long_options).allow_unregistered().extra_parser(parse_size_arg).run();

1352

1326

unknown_options=

1353

1327

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

1354

1328

1356

1330

{

1357

1331

po::store(parsed, vm);

1358

1332

}

1359

catch (std::exception&)

1333

catch (...)

1360

1334

{

1361

1335

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

1362

1336

unireg_abort(1);

1364

1338

1365

1339

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

1366

1340

{

1367

fs::path system_config_file_drizzle(system_config_dir);

1368

system_config_file_drizzle /= "drizzled.cnf";

1369

1341

defaults_file_list.insert(defaults_file_list.begin(),

1370

system_config_file_drizzle.file_string());

1371

1372

fs::path config_conf_d_location(system_config_dir);

1373

config_conf_d_location /= "conf.d";

1374

1375

1376

CachedDirectory config_conf_d(config_conf_d_location.file_string());

1377

if (not config_conf_d.fail())

1342

system_config_file_drizzle);

1343

}

1344

1345

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

1346

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

1347

CachedDirectory config_conf_d(config_conf_d_location);

1348

if (not config_conf_d.fail())

1349

{

1350

1351

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

1352

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

1353

++iter)

1378

1354

{

1379

1380

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

1381

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

1382

++iter)

1355

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

1356

1357

if (not file_entry.empty()

1358

&& file_entry != "."

1359

&& file_entry != "..")

1383

1360

{

1384

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

1385

1386

if (not file_entry.empty()

1387

&& file_entry != "."

1388

&& file_entry != "..")

1389

{

1390

fs::path the_entry(config_conf_d_location);

1391

the_entry /= file_entry;

1392

defaults_file_list.push_back(the_entry.file_string());

1393

}

1361

string the_entry(config_conf_d_location);

1362

the_entry.push_back('/');

1363

the_entry.append(file_entry);

1364

defaults_file_list.push_back(the_entry);

1394

1365

}

1395

1366

}

1396

1367

}

1397

1368

1398

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

1399

1400

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

1401

try

1402

{

1403

po::notify(vm);

1404

}

1405

catch (po::validation_error &err)

1406

{

1407

errmsg_printf(ERRMSG_LVL_ERROR,

1408

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

1409

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

1410

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

1411

unireg_abort(1);

1412

}

1413

1369

po::notify(vm);

1414

1370

process_defaults_files();

1415

1416

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

1417

plugin loader options */

1418

1419

try

1420

{

1421

po::notify(vm);

1422

}

1423

catch (po::validation_error &err)

1424

{

1425

errmsg_printf(ERRMSG_LVL_ERROR,

1426

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

1427

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

1428

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

1429

unireg_abort(1);

1430

}

1431

1432

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

1433

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

1434

1435

1436

if (plugin_init(plugins, plugin_options))

1437

{

1438

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

1439

unireg_abort(1);

1440

}

1441

1442

full_options.add(plugin_options);

1443

1444

vector<string> final_unknown_options;

1445

try

1446

{

1447

po::parsed_options final_parsed=

1448

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

1449

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

1450

1451

final_unknown_options=

1452

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

1453

1454

po::store(final_parsed, vm);

1455

1456

}

1457

catch (po::validation_error &err)

1458

{

1459

errmsg_printf(ERRMSG_LVL_ERROR,

1460

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

1461

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

1462

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

1463

unireg_abort(1);

1464

}

1465

catch (po::invalid_command_line_syntax &err)

1466

{

1467

errmsg_printf(ERRMSG_LVL_ERROR,

1468

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

1469

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

1470

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

1471

unireg_abort(1);

1472

}

1473

catch (po::unknown_option &err)

1474

{

1475

errmsg_printf(ERRMSG_LVL_ERROR,

1476

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

1477

err.what());

1478

unireg_abort(1);

1479

}

1480

1481

try

1482

{

1483

po::notify(vm);

1484

}

1485

catch (po::validation_error &err)

1486

{

1487

errmsg_printf(ERRMSG_LVL_ERROR,

1488

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

1489

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

1490

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

1491

unireg_abort(1);

1492

}

1371

po::notify(vm);

1493

1372

1494

1373

get_options();

1495

1374

1506

1385

}

1507

1386

}

1508

1387

1509

fix_paths();

1388

fix_paths(argv[0]);

1510

1389

1511

1390

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

1512

1391

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

1513

1392

1514

1393

if (item_create_init())

1515

1394

return 1;

1516

if (sys_var_init())

1395

if (set_var_init())

1517

1396

return 1;

1518

1397

/* Creates static regex matching for temporal values */

1519

1398

if (! init_temporal_formats())

1526

1405

return 1; // Eof of the list

1527

1406

}

1528

1407

1529

if (vm.count("scheduler"))

1530

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

1531

1532

1408

if (default_collation_name)

1533

1409

{

1534

1410

const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);

1583

1459

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

1584

1460

unireg_abort(1);

1585

1461

}

1586

1587

// Resize the definition Cache at startup

1588

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

1589

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

1590

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

1462

TableShare::cacheStart();

1591

1463

1592

1464

setup_fpu();

1593

1465

1602

1474

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

1603

1475

ha_init_errors();

1604

1476

1605

1606

if (opt_help)

1477

if (plugin_init(plugins, plugin_options))

1478

{

1479

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

1480

unireg_abort(1);

1481

}

1482

1483

1484

if (opt_help || opt_help_extended)

1607

1485

unireg_abort(0);

1608

1486

1609

if (plugin_finalize(plugins))

1610

{

1611

unireg_abort(1);

1612

}

1487

vector<string> final_unknown_options;

1488

try

1489

{

1490

// Disable allow_guessing

1491

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

1492

po::parsed_options parsed=

1493

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

1494

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

1495

1496

final_unknown_options=

1497

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

1498

1499

po::store(parsed, vm);

1500

1501

}

1502

catch (po::invalid_command_line_syntax &err)

1503

{

1504

errmsg_printf(ERRMSG_LVL_ERROR,

1505

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

1506

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

1507

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

1508

unireg_abort(1);

1509

}

1510

catch (po::unknown_option &err)

1511

{

1512

errmsg_printf(ERRMSG_LVL_ERROR,

1513

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

1514

err.what());

1515

unireg_abort(1);

1516

}

1517

1518

po::notify(vm);

1519

1520

plugin_finalize(plugins);

1613

1521

1614

1522

string scheduler_name;

1615

1523

if (opt_scheduler)

1744

1652

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

1745

1653

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

1746

1654

0, 0},

1655

{"help-extended", '?',

1656

N_("Display this help and exit after initializing plugins."),

1657

(char**) &opt_help_extended, (char**) &opt_help_extended,

1658

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

1747

1659

{"auto-increment-increment", OPT_AUTO_INCREMENT,

1748

1660

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

1749

1661

(char**) &global_system_variables.auto_increment_increment,

1750

1662

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

1751

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

1663

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

1752

1664

{"auto-increment-offset", OPT_AUTO_INCREMENT_OFFSET,

1753

1665

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

1754

1666

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

1755

1667

(char**) &global_system_variables.auto_increment_offset,

1756

1668

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

1757

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

1669

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

1758

1670

{"basedir", 'b',

1759

1671

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

1760

1672

"relative to this."),

1761

NULL, NULL, 0, GET_STR, REQUIRED_ARG,

1673

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

1762

1674

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

1763

1675

{"chroot", 'r',

1764

1676

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

1779

1691

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

1780

1692

{"datadir", 'h',

1781

1693

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

1782

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

1694

(char**) &data_home,

1695

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

1783

1696

{"default-storage-engine", OPT_STORAGE_ENGINE,

1784

1697

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

1785

1698

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

1798

1711

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

1799

1712

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

1800

1713

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

1714

{"language", 'L',

1715

N_("(IGNORED)"),

1716

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

1717

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

1801

1718

{"lc-time-names", OPT_LC_TIME_NAMES,

1802

1719

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

1803

1720

(char**) &lc_time_names_name,

1809

1726

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

1810

1727

0, 0, 0},

1811

1728

{"pid-file", OPT_PID_FILE,

1812

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

1813

NULL, NULL, 0, GET_STR,

1729

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

1730

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

1814

1731

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

1815

1732

{"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,

1816

1733

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

1820

1737

{"secure-file-priv", OPT_SECURE_FILE_PRIV,

1821

1738

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

1822

1739

"within specified directory"),

1823

NULL, NULL, 0,

1740

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

1824

1741

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

1825

1742

{"server-id", OPT_SERVER_ID,

1826

1743

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

1894

1811

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

1895

1812

(char**) &global_system_variables.max_allowed_packet,

1896

1813

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

1897

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

1814

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

1898

1815

{"max_connect_errors", OPT_MAX_CONNECT_ERRORS,

1899

1816

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

1900

1817

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

1909

1826

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

1910

1827

(char**) &global_system_variables.max_heap_table_size,

1911

1828

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

1912

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

1829

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

1913

1830

MALLOC_OVERHEAD, 1024, 0},

1914

1831

{"max_join_size", OPT_MAX_JOIN_SIZE,

1915

1832

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

1966

1883

0, GET_UINT, OPT_ARG, 0, 0, MAX_TABLES+2, 0, 1, 0},

1967

1884

{"plugin_dir", OPT_PLUGIN_DIR,

1968

1885

N_("Directory for plugins."),

1969

NULL, NULL, 0,

1886

(char**) &opt_plugin_dir_ptr, (char**) &opt_plugin_dir_ptr, 0,

1970

1887

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

1971

1888

{"plugin_add", OPT_PLUGIN_ADD,

1972

1889

N_("Optional comma separated list of plugins to load at startup in addition "

2006

1923

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

2007

1924

(char**) &global_system_variables.range_alloc_block_size,

2008

1925

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

2009

REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, (int64_t)SIZE_MAX,

1926

REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, SIZE_MAX,

2010

1927

0, 1024, 0},

2011

1928

{"read_buffer_size", OPT_RECORD_BUFFER,

2012

1929

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

2033

1950

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

2034

1951

(char**) &global_system_variables.sortbuff_size,

2035

1952

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

2036

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

1953

MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*8, SIZE_MAX,

2037

1954

MALLOC_OVERHEAD, 1, 0},

2038

1955

{"table_definition_cache", OPT_TABLE_DEF_CACHE,

2039

1956

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

2053

1970

(char**) &my_thread_stack_size,

2054

1971

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

2055

1972

REQUIRED_ARG,DEFAULT_THREAD_STACK,

2056

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

1973

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

2057

1974

{"tmp_table_size", OPT_TMP_TABLE_SIZE,

2058

1975

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

2059

1976

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

2060

1977

(char**) &global_system_variables.tmp_table_size,

2061

1978

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

2062

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

1979

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

2063

1980

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

2064

1981

};

2065

1982

2091

2008

printf(_("Usage: %s [OPTIONS]\n"), internal::my_progname);

2092

2009

2093

2010

po::options_description all_options("Drizzled Options");

2094

all_options.add(config_options);

2095

all_options.add(plugin_load_options);

2096

2011

all_options.add(long_options);

2097

2012

all_options.add(plugin_options);

2098

2013

cout << all_options << endl;

2118

2033

static void drizzle_init_variables(void)

2119

2034

{

2120

2035

/* Things reset to zero */

2036

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

2121

2037

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

2038

opt_secure_file_priv= 0;

2122

2039

cleanup_done= 0;

2123

2040

dropping_tables= ha_open_options=0;

2124

2041

test_flags.reset();

2136

2053

character_set_filesystem= &my_charset_bin;

2137

2054

2138

2055

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

2056

drizzle_home_ptr= drizzle_home;

2057

pidfile_name_ptr= pidfile_name;

2058

language_ptr= language;

2059

data_home= data_home_real;

2139

2060

session_startup_options= (OPTION_AUTO_IS_NULL | OPTION_SQL_NOTES);

2140

2061

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

2141

2062

global_thread_id= 1UL;

2142

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

2063

getSessionList().clear();

2064

2065

/* Set directory paths */

2066

strncpy(language, LANGUAGE, sizeof(language)-1);

2067

strncpy(data_home_real, get_relative_path(LOCALSTATEDIR),

2068

sizeof(data_home_real)-1);

2069

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

2070

data_home_buff[1]=0;

2071

data_home_len= 2;

2143

2072

2144

2073

/* Variables in libraries */

2145

2074

default_character_set_name= "utf8";

2157

2086

max_system_variables.auto_increment_increment= UINT64_MAX;

2158

2087

max_system_variables.auto_increment_offset= UINT64_MAX;

2159

2088

max_system_variables.completion_type= 2;

2160

max_system_variables.log_warnings= true;

2089

max_system_variables.log_warnings= 1;

2161

2090

max_system_variables.bulk_insert_buff_size= ULONG_MAX;

2162

2091

max_system_variables.div_precincrement= DECIMAL_MAX_SCALE;

2163

2092

max_system_variables.group_concat_max_len= ULONG_MAX;

2190

2119

have_symlink=SHOW_OPTION_YES;

2191

2120

#endif

2192

2121

2122

const char *tmpenv;

2123

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

2124

tmpenv = PREFIX;

2125

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

2126

2193

2127

connection_count= 0;

2194

2128

}

2195

2129

2201

2135

static void get_options()

2202

2136

{

2203

2137

2204

fs::path &data_home_catalog= getDataHomeCatalog();

2205

data_home_catalog= getDataHome();

2206

data_home_catalog /= "local";

2138

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

2139

{

2140

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

2141

}

2142

2143

if (vm.count("datadir"))

2144

{

2145

strncpy(data_home_real,vm["datadir"].as<string>().c_str(), sizeof(data_home_real)-1);

2146

/* Correct pointer set by my_getopt (for embedded library) */

2147

data_home= data_home_real;

2148

data_home_len= strlen(data_home);

2149

}

2207

2150

2208

2151

if (vm.count("user"))

2209

2152

{

2216

2159

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

2217

2160

}

2218

2161

2162

if (vm.count("language"))

2163

{

2164

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

2165

}

2166

2219

2167

if (vm.count("version"))

2220

2168

{

2221

2169

print_version();

2222

2170

exit(0);

2223

2171

}

2224

2172

2225

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

2226

{

2227

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

2228

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

2229

global_system_variables.sortbuff_size))

2230

{

2231

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

2232

exit(-1);

2233

}

2234

2235

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

2236

}

2237

2238

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

2239

{

2240

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

2241

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

2242

global_system_variables.join_buff_size))

2243

{

2244

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

2245

exit(-1);

2246

}

2247

2248

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

2249

}

2250

2251

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

2252

{

2253

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

2254

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

2255

global_system_variables.read_rnd_buff_size))

2256

{

2257

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

2258

exit(-1);

2259

}

2260

2261

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

2262

}

2263

2264

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

2265

{

2266

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

2267

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

2268

global_system_variables.read_buff_size))

2269

{

2270

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

2271

exit(-1);

2272

}

2273

2274

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

2173

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

2174

{

2175

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

2176

global_system_variables.log_warnings++;

2177

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

2178

global_system_variables.log_warnings= 0L;

2179

else

2180

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

2275

2181

}

2276

2182

2277

2183

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

2297

2203

internal::my_use_symdir=0;

2298

2204

}

2299

2205

2206

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

2207

{

2208

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

2209

}

2210

2300

2211

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

2301

2212

{

2302

2213

int type;

2344

2255

}

2345

2256

2346

2257

2347

static void fix_paths()

2348

{

2349

fs::path pid_file_path(pid_file);

2350

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

2351

{

2352

pid_file_path= getDataHome();

2353

pid_file_path /= pid_file;

2354

}

2355

pid_file= fs::system_complete(pid_file_path);

2356

2357

if (not opt_help)

2258

static const char *get_relative_path(const char *path)

2259

{

2260

if (internal::test_if_hard_path(path) &&

2261

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

2262

strcmp(PREFIX,FN_ROOTDIR))

2263

{

2264

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

2265

path+=(size_t) strlen(PREFIX);

2266

while (*path == FN_LIBCHAR)

2267

path++;

2268

}

2269

return path;

2270

}

2271

2272

2273

static void fix_paths(string progname)

2274

{

2275

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

2276

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

2277

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

2278

#if defined(HAVE_BROKEN_REALPATH)

2279

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

2280

#else

2281

if (!realpath(drizzle_home,rp_buff))

2282

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

2283

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

2284

strcpy(drizzle_home,rp_buff);

2285

/* Ensure that drizzle_home ends in FN_LIBCHAR */

2286

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

2287

#endif

2288

if (pos[-1] != FN_LIBCHAR)

2289

{

2290

pos[0]= FN_LIBCHAR;

2291

pos[1]= 0;

2292

}

2293

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

2294

(void) internal::fn_format(buff, data_home_real, "", "",

2295

(MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));

2296

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

2297

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

2298

(void) internal::my_load_path(data_home_real, data_home_real,drizzle_home);

2299

(void) internal::my_load_path(pidfile_name, pidfile_name,data_home_real);

2300

2301

if (opt_plugin_dir_ptr == NULL)

2302

{

2303

/* No plugin dir has been specified. Figure out where the plugins are */

2304

if (progname[0] != FN_LIBCHAR)

2305

{

2306

/* We have a relative path and need to find the absolute */

2307

char working_dir[FN_REFLEN];

2308

char *working_dir_ptr= working_dir;

2309

working_dir_ptr= getcwd(working_dir_ptr, FN_REFLEN);

2310

string new_path(working_dir);

2311

if (*(new_path.end()-1) != '/')

2312

new_path.push_back('/');

2313

if (progname[0] == '.' && progname[1] == '/')

2314

new_path.append(progname.substr(2));

2315

else

2316

new_path.append(progname);

2317

progname.swap(new_path);

2318

}

2319

2320

/* Now, trim off the exe name */

2321

string progdir(progname.substr(0, progname.rfind(FN_LIBCHAR)+1));

2322

if (progdir.rfind(".libs/") != string::npos)

2323

{

2324

progdir.assign(progdir.substr(0, progdir.rfind(".libs/")));

2325

}

2326

string testlofile(progdir);

2327

testlofile.append("drizzled.lo");

2328

string testofile(progdir);

2329

testofile.append("drizzled.o");

2330

struct stat testfile_stat;

2331

if (stat(testlofile.c_str(), &testfile_stat) && stat(testofile.c_str(), &testfile_stat))

2332

{

2333

/* neither drizzled.lo or drizzled.o exist - we are not in a source dir.

2334

* Go on as usual

2335

2336

(void) internal::my_load_path(opt_plugin_dir, get_relative_path(PKGPLUGINDIR),

2337

drizzle_home);

2338

}

2339

else

2340

{

2341

/* We are in a source dir! Plugin dir is ../plugin/.libs */

2342

size_t last_libchar_pos= progdir.rfind(FN_LIBCHAR,progdir.size()-2)+1;

2343

string source_plugindir(progdir.substr(0,last_libchar_pos));

2344

source_plugindir.append("plugin/.libs");

2345

(void) internal::my_load_path(opt_plugin_dir, source_plugindir.c_str(), "");

2346

}

2347

}

2348

else

2349

{

2350

(void) internal::my_load_path(opt_plugin_dir, opt_plugin_dir_ptr, drizzle_home);

2351

}

2352

opt_plugin_dir_ptr= opt_plugin_dir;

2353

2354

const char *sharedir= get_relative_path(PKGDATADIR);

2355

if (internal::test_if_hard_path(sharedir))

2356

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

2357

else

2358

{

2359

strcpy(buff, drizzle_home);

2360

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

2361

}

2362

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

2363

(void) internal::my_load_path(language,language,buff);

2364

2365

if (not opt_help and not opt_help_extended)

2358

2366

{

2359

2367

const char *tmp_string= getenv("TMPDIR") ? getenv("TMPDIR") : NULL;

2360

2368

struct stat buf;

2366

2374

}

2367

2375

else if (tmp_string == NULL)

2368

2376

{

2369

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

2377

drizzle_tmpdir.append(data_home);

2370

2378

drizzle_tmpdir.push_back(FN_LIBCHAR);

2371

2379

drizzle_tmpdir.append(GLOBAL_TEMPORARY_EXT);

2372

2380

}

2375

2383

drizzle_tmpdir.append(tmp_string);

2376

2384

}

2377

2385

2378

drizzle_tmpdir= fs::path(fs::system_complete(fs::path(drizzle_tmpdir))).file_string();

2379

2386

assert(drizzle_tmpdir.size());

2380

2387

2381

2388

if (mkdir(drizzle_tmpdir.c_str(), 0777) == -1)

2394

2401

}

2395

2402

}

2396

2403

2404

2405

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

2406

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

2407

2408

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

2409

{

2410

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

2411

free(opt_secure_file_priv);

2412

opt_secure_file_priv= strdup(buff);

2413

if (opt_secure_file_priv == NULL)

2414

exit(1);

2415

}

2397

2416

}

2398

2417

2399

2418

} /* namespace drizzled */

Older »