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

1199

_("Default transaction isolation level."))

1200

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

1201

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

1233

1202

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

1234

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

1235

("version,V",

1236

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

1203

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

1204

("version,V",

1205

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

1237

1206

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

1238

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

1207

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

1239

1208

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

1240

1209

"requests in a very short time."))

1241

("bulk-insert-buffer-size",

1210

("bulk-insert-buffer-size",

1242

1211

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

1243

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

1212

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

1244

1213

"a limit per thread!"))

1245

1214

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

1246

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

1215

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

1247

1216

"value."))

1248

1217

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

1249

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

1218

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

1250

1219

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

1251

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

1220

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

1252

1221

("join-heap-threshold",

1253

1222

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

1223

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

1255

1224

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

1256

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

1257

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

1258

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

1259

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

1225

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

1260

1226

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

1261

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

1227

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

1262

1228

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

1263

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

1229

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

1264

1230

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

1265

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

1231

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

1266

1232

"return an error."))

1267

1233

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

1268

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

1234

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

1269

1235

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

1270

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

1271

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

1272

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

1236

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

1237

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

1238

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

1273

1239

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

1274

1240

"rest are ignored)."))

1275

1241

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

1276

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

1242

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

1277

1243

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

1278

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

1244

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

1279

1245

"rows to file."))

1280

1246

("disable-optimizer-prune",

1281

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

1247

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

1282

1248

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

1283

1249

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

1284

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

1250

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

1285

1251

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

1286

1252

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

1287

1253

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

1290

1256

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

1291

1257

"testing/comparison)."))

1292

1258

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

1293

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

1294

("query-alloc-block-size",

1259

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

1260

("query-alloc-block-size",

1295

1261

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

1296

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

1262

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

1297

1263

("query-prealloc-size",

1298

1264

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

1299

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

1265

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

1300

1266

("range-alloc-block-size",

1301

1267

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

1302

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

1268

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

1303

1269

("read-buffer-size",

1304

1270

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

1305

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

1271

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

1306

1272

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

1307

1273

"want to increase this value."))

1308

1274

("read-buffer-threshold",

1309

1275

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

1310

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

1276

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

1311

1277

("read-rnd-buffer-size",

1312

1278

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

1313

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

1279

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

1314

1280

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

1315

1281

"to the value of record_buffer."))

1316

1282

("read-rnd-threshold",

1317

1283

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

1318

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

1284

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

1319

1285

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

1320

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

1286

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

1321

1287

("sort-buffer-size",

1322

1288

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

1323

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

1289

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

1324

1290

("sort-heap-threshold",

1325

1291

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

1292

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

1327

1293

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

1328

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

1294

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

1329

1295

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

1330

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

1296

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

1331

1297

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

1332

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

1298

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

1333

1299

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

1334

1300

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

1335

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

1336

("tmp-table-size",

1301

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

1302

("tmp-table-size",

1337

1303

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

1338

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

1304

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

1339

1305

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

1306

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

1307

_("The verbosity of messages from drizzled. Possible values are INSPECT, INFO, WARN or ERROR"))

1340

1308

;

1341

1309

1342

1310

full_options.add(long_options);

1358

1326

}

1359

1327

catch (std::exception&)

1360

1328

{

1361

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

1329

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

1362

1330

unireg_abort(1);

1363

1331

}

1364

1332

1404

1372

}

1405

1373

catch (po::validation_error &err)

1406

1374

{

1407

errmsg_printf(ERRMSG_LVL_ERROR,

1375

errmsg_printf(error::ERROR,

1408

1376

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

1409

1377

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

1410

1378

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

1422

1390

}

1423

1391

catch (po::validation_error &err)

1424

1392

{

1425

errmsg_printf(ERRMSG_LVL_ERROR,

1393

errmsg_printf(error::ERROR,

1426

1394

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

1427

1395

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

1428

1396

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

1429

1397

unireg_abort(1);

1430

1398

}

1431

1399

1400

return 0;

1401

}

1402

1403

int init_remaining_variables(module::Registry &plugins)

1404

{

1405

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

1406

1407

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

1408

1432

1409

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

1433

1410

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

1434

1411

1435

1412

1436

1413

if (plugin_init(plugins, plugin_options))

1437

1414

{

1438

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

1415

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

1439

1416

unireg_abort(1);

1440

1417

}

1441

1418

1456

1433

}

1457

1434

catch (po::validation_error &err)

1458

1435

{

1459

errmsg_printf(ERRMSG_LVL_ERROR,

1436

errmsg_printf(error::ERROR,

1460

1437

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

1461

1438

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

1462

1439

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

1464

1441

}

1465

1442

catch (po::invalid_command_line_syntax &err)

1466

1443

{

1467

errmsg_printf(ERRMSG_LVL_ERROR,

1444

errmsg_printf(error::ERROR,

1468

1445

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

1469

1446

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

1470

1447

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

1472

1449

}

1473

1450

catch (po::unknown_option &err)

1474

1451

{

1475

errmsg_printf(ERRMSG_LVL_ERROR,

1452

errmsg_printf(error::ERROR,

1476

1453

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

1477

1454

err.what());

1478

1455

unireg_abort(1);

1484

1461

}

1485

1462

catch (po::validation_error &err)

1486

1463

{

1487

errmsg_printf(ERRMSG_LVL_ERROR,

1464

errmsg_printf(error::ERROR,

1488

1465

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

1489

1466

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

1490

1467

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

1508

1485

1509

1486

fix_paths();

1510

1487

1511

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

1512

1488

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

1513

1489

1514

1490

if (item_create_init())

1522

1498

if (!(default_charset_info=

1523

1499

get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

1524

1500

{

1525

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

1501

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

1526

1502

return 1; // Eof of the list

1527

1503

}

1528

1504

1534

1510

const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);

1535

1511

if (not default_collation)

1536

1512

{

1537

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

1513

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

1538

1514

return 1;

1539

1515

}

1540

1516

if (not my_charset_same(default_charset_info, default_collation))

1541

1517

{

1542

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

1518

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

1543

1519

default_collation_name,

1544

1520

default_charset_info->csname);

1545

1521

return 1;

1552

1528

if (not (character_set_filesystem=

1553

1529

get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))

1554

1530

{

1555

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

1531

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

1556

1532

return 1;

1557

1533

}

1558

1534

global_system_variables.character_set_filesystem= character_set_filesystem;

1560

1536

if (!(my_default_lc_time_names=

1561

1537

my_locale_by_name(lc_time_names_name)))

1562

1538

{

1563

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

1539

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

1564

1540

return 1;

1565

1541

}

1566

1542

global_system_variables.lc_time_names= my_default_lc_time_names;

1580

1556

1581

1557

if (table_cache_init())

1582

1558

{

1583

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

1559

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

1584

1560

unireg_abort(1);

1585

1561

}

1586

1562

1591

1567

1592

1568

setup_fpu();

1593

1569

1594

/* Setup logs */

1595

1596

if (xid_cache_init())

1597

{

1598

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

1599

unireg_abort(1);

1600

}

1601

1602

1570

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

1603

1571

ha_init_errors();

1604

1572

1619

1587

else

1620

1588

{

1621

1589

scheduler_name= opt_scheduler_default;

1622

opt_scheduler= opt_scheduler_default;

1590

opt_scheduler= opt_scheduler_default;

1623

1591

}

1624

1592

1625

1593

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

1626

1594

{

1627

errmsg_printf(ERRMSG_LVL_ERROR,

1595

errmsg_printf(error::ERROR,

1628

1596

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

1629

1597

unireg_abort(1);

1630

1598

}

1649

1617

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

1650

1618

if (engine == NULL)

1651

1619

{

1652

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

1620

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

1653

1621

default_storage_engine_str);

1654

1622

unireg_abort(1);

1655

1623

}

1675

1643

enum options_drizzled

1676

1644

{

1677

1645

OPT_SOCKET=256,

1678

OPT_BIND_ADDRESS,

1646

OPT_BIND_ADDRESS,

1679

1647

OPT_PID_FILE,

1680

OPT_STORAGE_ENGINE,

1648

OPT_STORAGE_ENGINE,

1681

1649

OPT_INIT_FILE,

1682

1650

OPT_WANT_CORE,

1683

1651

OPT_MEMLOCK,

1690

1658

OPT_BACK_LOG,

1691

1659

OPT_JOIN_BUFF_SIZE,

1692

1660

OPT_MAX_ALLOWED_PACKET,

1693

OPT_MAX_CONNECT_ERRORS,

1694

1661

OPT_MAX_HEP_TABLE_SIZE,

1695

1662

OPT_MAX_JOIN_SIZE,

1696

1663

OPT_MAX_SORT_LENGTH,

1744

1711

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

1745

1712

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

1746

1713

0, 0},

1714

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

1715

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

1716

0, 0},

1747

1717

{"auto-increment-increment", OPT_AUTO_INCREMENT,

1748

1718

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

1749

1719

(char**) &global_system_variables.auto_increment_increment,

1780

1750

{"datadir", 'h',

1781

1751

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

1782

1752

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

1783

{"default-storage-engine", OPT_STORAGE_ENGINE,

1784

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

1785

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

1786

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

1787

{"default-time-zone", OPT_DEFAULT_TIME_ZONE,

1788

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

1789

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

1790

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

1791

1753

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

1792

1754

{"exit-info", 'T',

1793

1755

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

1798

1760

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

1799

1761

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

1800

1762

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

1801

{"lc-time-names", OPT_LC_TIME_NAMES,

1802

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

1803

(char**) &lc_time_names_name,

1804

(char**) &lc_time_names_name,

1805

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

1806

1763

{"log-warnings", 'W',

1807

1764

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

1808

1765

(char**) &global_system_variables.log_warnings,

1845

1802

"supported)"),

1846

1803

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

1847

1804

0, 0, 0, 0, 0},

1848

{"tmpdir", 't',

1849

N_("Path for temporary files."),

1850

(char**) &opt_drizzle_tmpdir,

1851

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

1852

1805

{"transaction-isolation", OPT_TX_ISOLATION,

1853

1806

N_("Default transaction isolation level."),

1854

1807

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

1857

1810

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

1858

1811

0, 0, 0, GET_STR, REQUIRED_ARG,

1859

1812

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

1860

{"version", 'V',

1861

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

1862

0, 0, 0, GET_NO_ARG,

1863

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

1864

1813

{"back_log", OPT_BACK_LOG,

1865

1814

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

1866

1815

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

1879

1828

(char**) &global_system_variables.div_precincrement,

1880

1829

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

1881

1830

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

1882

{ "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,

1883

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

1884

(char**) &global_system_variables.group_concat_max_len,

1885

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

1886

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

1887

1831

{ "join_buffer_size", OPT_JOIN_BUFF_SIZE,

1888

1832

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

1889

1833

(char**) &global_system_variables.join_buff_size,

1895

1839

(char**) &global_system_variables.max_allowed_packet,

1896

1840

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

1897

1841

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

1898

{"max_connect_errors", OPT_MAX_CONNECT_ERRORS,

1899

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

1900

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

1901

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

1902

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

1903

{"max_error_count", OPT_MAX_ERROR_COUNT,

1904

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

1905

(char**) &global_system_variables.max_error_count,

1906

(char**) &max_system_variables.max_error_count,

1907

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

1908

1842

{"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,

1909

1843

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

1910

1844

(char**) &global_system_variables.max_heap_table_size,

2024

1958

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

2025

1959

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

2026

1960

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

2027

{"scheduler", OPT_SCHEDULER,

2028

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

2029

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

2030

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

2031

1961

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

2032

1962

{"sort_buffer_size", OPT_SORT_BUFFER,

2033

1963

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

2087

2017

"and you are welcome to modify and redistribute it under the GPL "

2088

2018

"license\n\n"));

2089

2019

2090

2020

2091

2021

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

2092

2022

2093

2023

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

2121

2051

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

2122

2052

cleanup_done= 0;

2123

2053

dropping_tables= ha_open_options=0;

2124

test_flags.reset();

2054

getDebug().reset();

2125

2055

wake_thread=0;

2126

2056

abort_loop= select_thread_in_use= false;

2127

ready_to_exit= shutdown_in_progress= 0;

2057

shutdown_in_progress= 0;

2128

2058

drizzled_user= drizzled_chroot= 0;

2129

2059

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

2130

2060

key_map_full.set();

2189

2119

#else

2190

2120

have_symlink=SHOW_OPTION_YES;

2191

2121

#endif

2192

2193

connection_count= 0;

2194

2122

}

2195

2123

2196

2124

2203

2131

2204

2132

fs::path &data_home_catalog= getDataHomeCatalog();

2205

2133

data_home_catalog= getDataHome();

2206

data_home_catalog /= "local";

2134

data_home_catalog /= "local";

2207

2135

2208

2136

if (vm.count("user"))

2209

2137

{

2211

2139

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

2212

2140

2213

2141

else

2214

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

2142

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

2215

2143

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

2216

2144

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

2217

2145

}

2225

2153

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

2226

2154

{

2227

2155

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

2228

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

2156

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

2229

2157

global_system_variables.sortbuff_size))

2230

2158

{

2231

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

2159

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

2232

2160

exit(-1);

2233

2161

}

2234

2162

2241

2169

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

2242

2170

global_system_variables.join_buff_size))

2243

2171

{

2244

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

2172

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

2245

2173

exit(-1);

2246

2174

}

2247

2175

2254

2182

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

2255

2183

global_system_variables.read_rnd_buff_size))

2256

2184

{

2257

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

2185

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

2258

2186

exit(-1);

2259

2187

}

2260

2188

2267

2195

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

2268

2196

global_system_variables.read_buff_size))

2269

2197

{

2270

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

2198

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

2271

2199

exit(-1);

2272

2200

}

2273

2201

2278

2206

{

2279

2207

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

2280

2208

{

2281

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

2209

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

2282

2210

}

2283

2211

}

2284

2212

2285

2213

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

2286

2214

{

2287

test_flags.set(TEST_CORE_ON_SIGNAL);

2215

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

2288

2216

}

2289

2217

2290

2218

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

2291

2219

{

2292

test_flags.set(TEST_NO_STACKTRACE);

2220

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

2293

2221

}

2294

2222

2295

2223

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

2299

2227

2300

2228

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

2301

2229

{

2302

int type;

2303

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

2304

global_system_variables.tx_isolation= (type-1);

2230

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

2231

global_system_variables.tx_isolation= type - 1;

2305

2232

}

2306

2233

2307

2234

/* @TODO Make this all strings */

2328

2255

if (opt_debugging)

2329

2256

{

2330

2257

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

2331

test_flags.set(TEST_SIGINT);

2332

test_flags.set(TEST_NO_STACKTRACE);

2333

test_flags.reset(TEST_CORE_ON_SIGNAL);

2258

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

2259

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

2260

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

2334

2261

}

2335

2262

2336

2263

if (drizzled_chroot)

2382

2309

{

2383

2310

if (errno != EEXIST)

2384

2311

{

2385

perror(drizzle_tmpdir.c_str());

2312

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

2386

2313

exit(1);

2387

2314

}

2388

2315

}

2389

2316

2390

2317

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

2391

2318

{

2392

perror(drizzle_tmpdir.c_str());

2319

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

2393

2320

exit(1);

2394

2321

}

2395

2322

}

Older »