~drizzle-trunk/drizzle/development

N_("Enable named commands. Named commands mean this program's internal commands; see drizzle> help . When enabled, the named commands can be used from any line of the query, otherwise only from the first line, before an enter."))

1378

1379

("no-named-commands,g",

1380

N_("Named commands are disabled. Use \\* form only, or use named commands only in the beginning of a line ending with a semicolon (;) Since version 10.9 the client now starts with this option ENABLED by default! Disable with '-G'. Long format commands still work from the first line. WARNING: option deprecated; use --disable-named-commands instead."))

1381

("ignore-spaces,i", N_("Ignore space after function names."))

1302

1382

("no-beep,b", po::value<bool>(&opt_nobeep)->default_value(false)->zero_tokens(),

1303

1383

N_("Turn off beep on error."))

1304

("disable-line-numbers", N_("Do not write line numbers for errors."))

1305

("disable-column-names", N_("Do not write column names in results."))

1384

("line-numbers", po::value<bool>(&line_numbers)->default_value(true)->zero_tokens(),

1385

N_("Write line numbers for errors."))

1386

("skip-line-numbers,L",

1387

N_("Don't write line number for errors. WARNING: -L is deprecated, use long version of this option instead."))

1388

("column-name", po::value<bool>(&column_names)->default_value(true)->zero_tokens(),

1389

N_("Write column names in results."))

1306

1390

("skip-column-names,N",

1307

1391

N_("Don't write column names in results. WARNING: -N is deprecated, use long version of this options instead."))

1308

1392

("set-variable,O", po::value<string>(),

1309

1393

N_("Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value."))

1310

1394

("table,t", po::value<bool>(&output_tables)->default_value(false)->zero_tokens(),

1311

1395

N_("Output in table format."))

1312

("safe-updates,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),

1396

("safe-updates,U", po::value<bool>(&safe_updates)->default_value(0)->zero_tokens(),

1313

1397

N_("Only allow UPDATE and DELETE that uses keys."))

1314

("i-am-a-dummy,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),

1398

("i-am-a-dummy,U", po::value<bool>(&safe_updates)->default_value(0)->zero_tokens(),

1315

1399

N_("Synonym for option --safe-updates, -U."))

1316

1400

("verbose,v", po::value<string>(&opt_verbose)->default_value(""),

1317

1401

N_("-v vvv implies that verbose= 3, Used to specify verbose"))

1330

1414

1331

1415

po::options_description drizzle_options(N_("Options specific to the drizzle client"));

1332

1416

drizzle_options.add_options()

1333

("disable-auto-rehash,A",

1334

N_("Disable automatic rehashing. One doesn't need to use 'rehash' to get table and field completion, but startup and reconnecting may take a longer time."))

1417

("auto-rehash", po::value<bool>(&opt_rehash)->default_value(true)->zero_tokens(),

1418

N_("Enable automatic rehashing. One doesn't need to use 'rehash' to get table and field completion, but startup and reconnecting may take a longer time. Disable with --disable-auto-rehash."))

1419

("no-auto-rehash,A",N_("No automatic rehashing. One has to use 'rehash' to get table and field completion. This gives a quicker start of drizzle_st and disables rehashing on reconnect. WARNING: options deprecated; use --disable-auto-rehash instead."))

1335

1420

("auto-vertical-output", po::value<bool>(&auto_vertical_output)->default_value(false)->zero_tokens(),

1336

1421

N_("Automatically switch to vertical output mode if the result is wider than the terminal width."))

1337

1422

("database,D", po::value<string>(&current_db)->default_value(""),

1343

1428

("execute,e", po::value<string>(),

1344

1429

N_("Execute command and quit. (Disables --force and history file)"))

1345

1430

("local-infile", po::value<bool>(&opt_local_infile)->default_value(false)->zero_tokens(),

1346

N_("Enable LOAD DATA LOCAL INFILE."))

1431

N_("Enable/disable LOAD DATA LOCAL INFILE."))

1347

1432

("unbuffered,n", po::value<bool>(&unbuffered)->default_value(false)->zero_tokens(),

1348

1433

N_("Flush buffer after each query."))

1349

1434

("sigint-ignore", po::value<bool>(&opt_sigint_ignore)->default_value(false)->zero_tokens(),

1360

1445

N_("Don't cache result, print it row by row. This may slow down the server if the output is suspended. Doesn't use history file."))

1361

1446

("raw,r", po::value<bool>(&opt_raw_data)->default_value(false)->zero_tokens(),

1362

1447

N_("Write fields without conversion. Used with --batch."))

1363

("disable-reconnect", N_("Do not reconnect if the connection is lost."))

1364

("shutdown", po::value<bool>()->zero_tokens(),

1448

("reconnect", po::value<bool>(&opt_reconnect)->default_value(true)->zero_tokens(),

1449

N_("Reconnect if the connection is lost. Disable with --disable-reconnect. This option is enabled by default."))

1450

("shutdown", po::value<bool>(&opt_shutdown)->default_value(false)->zero_tokens(),

1365

1451

N_("Shutdown the server"))

1366

1452

("silent,s", N_("Be more silent. Print results with a tab as separator, each row on new line."))

1367

1453

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

1368

1454

N_("Append everything into outfile. See interactive help (\\h) also. Does not work in batch mode. Disable with --disable-tee. This option is disabled by default."))

1369

1455

("disable-tee", po::value<bool>()->default_value(false)->zero_tokens(),

1370

1456

N_("Disable outfile. See interactive help (\\h) also."))

1371

("connect-timeout", po::value<uint32_t>(&opt_connect_timeout)->default_value(0)->notifier(&check_timeout_value),

1457

("wait,w", N_("Wait and retry if connection is down."))

1458

("connect_timeout", po::value<uint32_t>(&opt_connect_timeout)->default_value(0)->notifier(&check_timeout_value),

1372

1459

N_("Number of seconds before connection timeout."))

1373

("max-input-line", po::value<uint32_t>(&opt_max_input_line)->default_value(16*1024L*1024L)->notifier(&check_max_input_line),

1460

("max_input_line", po::value<uint32_t>(&opt_max_input_line)->default_value(16*1024L*1024L)->notifier(&check_max_input_line),

1374

1461

N_("Max length of input line"))

1375

("select-limit", po::value<uint32_t>(&select_limit)->default_value(1000L),

1462

("select_limit", po::value<uint32_t>(&select_limit)->default_value(1000L),

1376

1463

N_("Automatic limit for SELECT when using --safe-updates"))

1377

("max-join-size", po::value<uint32_t>(&max_join_size)->default_value(1000000L),

1464

("max_join_size", po::value<uint32_t>(&max_join_size)->default_value(1000000L),

1378

1465

N_("Automatic limit for rows in a join when using --safe-updates"))

1379

1466

;

1380

1467

1386

1473

N_("Password to use when connecting to server. If password is not given it's asked from the tty."))

1387

1474

("port,p", po::value<uint32_t>()->default_value(0),

1388

1475

N_("Port number to use for connection or 0 for default to, in order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, built-in default"))

1389

#ifdef DRIZZLE_ADMIN_TOOL

1390

("user,u", po::value<string>(&current_user)->default_value("root"),

1391

#else

1392

1476

("user,u", po::value<string>(&current_user)->default_value(""),

1393

#endif

1394

1477

N_("User for login if not current user."))

1395

1478

("protocol",po::value<string>(&opt_protocol)->default_value("mysql"),

1396

1479

N_("The protocol of connection (mysql or drizzle)."))

1406

1489

system_config_dir_client.append("/drizzle/client.cnf");

1407

1490

1408

1491

std::string user_config_dir((getenv("XDG_CONFIG_HOME")? getenv("XDG_CONFIG_HOME"):"~/.config"));

1409

1410

if (user_config_dir.compare(0, 2, "~/") == 0)

1411

{

1412

char *homedir;

1413

homedir= getenv("HOME");

1414

if (homedir != NULL)

1415

user_config_dir.replace(0, 1, homedir);

1416

}

1417

1492

1418

1493

po::variables_map vm;

1419

1494

1420

1495

po::positional_options_description p;

1421

1496

p.add("database", 1);

1422

1497

1423

// Disable allow_guessing

1424

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

1425

1426

1498

po::store(po::command_line_parser(argc, argv).options(long_options).

1427

style(style).positional(p).extra_parser(parse_password_arg).run(),

1428

vm);

1499

positional(p).extra_parser(parse_password_arg).run(), vm);

1429

1500

1430

1501

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

1431

1502

{

1436

1507

user_config_dir_client.append("/drizzle/client.cnf");

1437

1508

1438

1509

ifstream user_drizzle_ifs(user_config_dir_drizzle.c_str());

1439

po::store(dpo::parse_config_file(user_drizzle_ifs, drizzle_options), vm);

1510

po::store(parse_config_file(user_drizzle_ifs, drizzle_options), vm);

1440

1511

1441

1512

ifstream user_client_ifs(user_config_dir_client.c_str());

1442

po::store(dpo::parse_config_file(user_client_ifs, client_options), vm);

1513

po::store(parse_config_file(user_client_ifs, client_options), vm);

1443

1514

1444

1515

ifstream system_drizzle_ifs(system_config_dir_drizzle.c_str());

1445

store(dpo::parse_config_file(system_drizzle_ifs, drizzle_options), vm);

1516

store(parse_config_file(system_drizzle_ifs, drizzle_options), vm);

1446

1517

1447

1518

ifstream system_client_ifs(system_config_dir_client.c_str());

1448

po::store(dpo::parse_config_file(system_client_ifs, client_options), vm);

1519

po::store(parse_config_file(system_client_ifs, client_options), vm);

1449

1520

}

1450

1521

1451

1522

po::notify(vm);

1452

1523

1453

#ifdef DRIZZLE_ADMIN_TOOL

1454

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1455

getenv("DRIZZLE_PS1") :

1456

"drizzleadmin> ");

1457

#else

1458

1524

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1459

1525

getenv("DRIZZLE_PS1") :

1460

1526

"drizzle> ");

1461

#endif

1462

1527

if (default_prompt == NULL)

1463

1528

{

1464

1529

fprintf(stderr, _("Memory allocation error while constructing initial "

1510

1575

close(stdout_fileno_copy); /* Clean up dup(). */

1511

1576

}

1512

1577

1513

/* Inverted Booleans */

1514

1515

line_numbers= (vm.count("disable-line-numbers")) ? false : true;

1516

column_names= (vm.count("disable-column-names")) ? false : true;

1517

opt_rehash= (vm.count("disable-auto-rehash")) ? false : true;

1518

opt_reconnect= (vm.count("disable-reconnect")) ? false : true;

1519

1520

/* Don't rehash with --shutdown */

1521

if (vm.count("shutdown"))

1522

{

1523

opt_rehash= false;

1524

opt_shutdown= true;

1525

}

1526

1527

1578

if (vm.count("delimiter"))

1528

1579

{

1529

1580

/* Check that delimiter does not contain a backslash */

1823

1874

1824

1875

if (sig >= 0)

1825

1876

put_info(sig ? _("Aborted") : _("Bye"), INFO_RESULT,0,0);

1826

delete glob_buffer;

1827

delete processed_prompt;

1877

if (glob_buffer)

1878

delete glob_buffer;

1879

if (processed_prompt)

1880

delete processed_prompt;

1828

1881

opt_password.erase();

1829

1882

free(histfile);

1830

1883

free(histfile_tmp);

1848

1901

void handle_sigint(int sig)

1849

1902

{

1850

1903

char kill_buffer[40];

1851

boost::scoped_ptr<drizzle_con_st> kill_drizzle(new drizzle_con_st);

1904

drizzle_con_st kill_drizzle;

1852

1905

drizzle_result_st res;

1853

1906

drizzle_return_t ret;

1854

1907

1857

1910

goto err;

1858

1911

}

1859

1912

1860

if (drizzle_con_add_tcp(&drizzle, kill_drizzle.get(), current_host.c_str(),

1913

if (drizzle_con_add_tcp(&drizzle, &kill_drizzle, current_host.c_str(),

1861

1914

opt_drizzle_port, current_user.c_str(), opt_password.c_str(), NULL,

1862

1915

use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)

1863

1916

{

1868

1921

sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u",

1869

1922

drizzle_con_thread_id(&con));

1870

1923

1871

if (drizzle_query_str(kill_drizzle.get(), &res, kill_buffer, &ret) != NULL)

1924

if (drizzle_query_str(&kill_drizzle, &res, kill_buffer, &ret) != NULL)

1872

1925

drizzle_result_free(&res);

1873

1926

1874

drizzle_con_free(kill_drizzle.get());

1927

drizzle_con_free(&kill_drizzle);

1875

1928

tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));

1876

1929

1877

1930

interrupted_query= 1;

2342

2395

{

2343

2396

*out++='\n';

2344

2397

uint32_t length=(uint32_t) (out-line);

2345

if ((buffer->length() + length) > opt_max_input_line)

2346

{

2347

status.setExitStatus(1);

2348

put_info(_("Not found a delimiter within max_input_line of input"), INFO_ERROR, 0, 0);

2349

return 1;

2350

}

2351

2398

if ((!*ml_comment || preserve_comments))

2352

2399

buffer->append(line, length);

2353

2400

}

2623

2670

{

2624

2671

string query;

2625

2672

2626

query.append("show fields in `");

2673

query.append("show fields in '");

2627

2674

query.append(table_row[0]);

2628

query.append("`");

2675

query.append("'");

2629

2676

2630

2677

if (drizzle_query(&con, &fields, query.c_str(), query.length(),

2631

2678

&ret) != NULL)

2695

2742

The different commands

2696

2743

***************************************************************************/

2697

2744

2698

int drizzleclient_real_query_for_lazy(const char *buf, size_t length,

2745

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2699

2746

drizzle_result_st *result,

2700

2747

uint32_t *error_code)

2701

2748

{

3612

3659

/* Skip the spaces between the command and the argument */

3613

3660

while (param && isspace(*param))

3614

3661

param++;

3615

if (!param || (*param == '\0')) // if pager was not given, use the default

3662

if (!param || !strlen(param)) // if pager was not given, use the default

3616

3663

{

3617

3664

if (!default_pager_set)

3618

3665

{

3917

3964

return 0;

3918

3965

}

3919

3966

3920

static int com_shutdown(string *, const char *)

3921

{

3922

drizzle_result_st result;

3923

drizzle_return_t ret;

3924

3925

if (verbose)

3926

{

3927

printf(_("shutting down drizzled"));

3928

if (opt_drizzle_port > 0)

3929

printf(_(" on port %d"), opt_drizzle_port);

3930

printf("... ");

3931

}

3932

3933

if (drizzle_shutdown(&con, &result, DRIZZLE_SHUTDOWN_DEFAULT,

3934

&ret) == NULL || ret != DRIZZLE_RETURN_OK)

3935

{

3936

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3937

{

3938

fprintf(stderr, _("shutdown failed; error: '%s'"),

3939

drizzle_result_error(&result));

3940

drizzle_result_free(&result);

3941

}

3942

else

3943

{

3944

fprintf(stderr, _("shutdown failed; error: '%s'"),

3945

drizzle_con_error(&con));

3946

}

3947

return false;

3948

}

3949

3950

drizzle_result_free(&result);

3951

3952

if (verbose)

3953

printf(_("done\n"));

3954

3955

return false;

3956

}

3957

3958

3967

static int

3959

3968

com_warnings(string *, const char *)

3960

3969

{

4045

4054

drizzle_free(&drizzle);

4046

4055

}

4047

4056

drizzle_create(&drizzle);

4048

4049

#ifdef DRIZZLE_ADMIN_TOOL

4050

drizzle_con_options_t options= (drizzle_con_options_t) (DRIZZLE_CON_ADMIN | (use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL));

4051

#else

4052

drizzle_con_options_t options= (drizzle_con_options_t) (use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);

4053

#endif

4054

4055

4057

if (drizzle_con_add_tcp(&drizzle, &con, (char *)host.c_str(),

4056

4058

opt_drizzle_port, (char *)user.c_str(),

4057

4059

(char *)password.c_str(), (char *)database.c_str(),

4058

options) == NULL)

4060

use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)

4059

4061

{

4060

4062

(void) put_error(&con, NULL);

4061

4063

(void) fflush(stdout);

Older »