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

1376

1377

("no-named-commands,g",

1378

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

1379

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

1302

1380

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

1303

1381

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

1382

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

1383

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

1384

("skip-line-numbers,L",

1385

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

1386

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

1387

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

1306

1388

("skip-column-names,N",

1307

1389

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

1308

1390

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

1309

1391

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

1310

1392

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

1311

1393

N_("Output in table format."))

1312

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

1394

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

1313

1395

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

1396

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

1315

1397

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

1316

1398

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

1317

1399

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

1328

1410

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

1329

1411

;

1330

1412

1331

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

1413

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

1332

1414

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

1415

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

1416

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

1417

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

1418

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

1336

1419

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

1337

1420

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

1343

1426

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

1344

1427

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

1345

1428

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

1346

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

1429

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

1347

1430

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

1348

1431

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

1349

1432

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

1360

1443

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

1444

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

1362

1445

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

1446

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

1447

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

1448

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

1365

1449

N_("Shutdown the server"))

1366

1450

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

1367

1451

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

1368

1452

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

1453

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

1370

1454

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

1455

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

1456

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

1372

1457

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

1458

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

1374

1459

N_("Max length of input line"))

1375

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

1460

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

1376

1461

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

1377

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

1462

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

1378

1463

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

1379

1464

;

1380

1465

1381

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

1466

po::options_description client_options("Options specific to the client");

1382

1467

client_options.add_options()

1468

("mysql,m", po::value<bool>(&opt_mysql)->default_value(true)->zero_tokens(),

1469

N_("Use MySQL Protocol."))

1383

1470

("host,h", po::value<string>(&current_host)->default_value("localhost"),

1384

1471

N_("Connect to host"))

1385

1472

("password,P", po::value<string>(&current_password)->default_value(PASSWORD_SENTINEL),

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

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

1396

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

1478

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

1479

N_("The protocol of connection (tcp,socket,pipe,memory)."))

1397

1480

;

1398

1481

1399

po::options_description long_options(N_("Allowed Options"));

1482

po::options_description long_options("Allowed Options");

1400

1483

long_options.add(commandline_options).add(drizzle_options).add(client_options);

1401

1484

1402

1485

std::string system_config_dir_drizzle(SYSCONFDIR);

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

1600

1651

1601

1652

if (one_database)

1602

1653

skip_updates= true;

1603

1604

if (vm.count("protocol"))

1605

{

1606

std::transform(opt_protocol.begin(), opt_protocol.end(),

1607

opt_protocol.begin(), ::tolower);

1608

1609

if (not opt_protocol.compare("mysql"))

1610

use_drizzle_protocol=false;

1611

else if (not opt_protocol.compare("drizzle"))

1612

use_drizzle_protocol=true;

1613

else

1614

{

1615

cout << _("Error: Unknown protocol") << " '" << opt_protocol << "'" << endl;

1616

exit(-1);

1617

}

1618

}

1619

1654

1620

1655

if (vm.count("port"))

1621

1656

{

1622

1657

opt_drizzle_port= vm["port"].as<uint32_t>();

1669

1704

{

1670

1705

opt_silent++;

1671

1706

}

1707

if (vm.count("version"))

1708

{

1709

printf(_("drizzle Ver %s Distrib %s, for %s-%s (%s) using readline %s\n"),

1710

VER.c_str(), drizzle_version(),

1711

HOST_VENDOR, HOST_OS, HOST_CPU,

1712

rl_library_version);

1713

1714

exit(0);

1715

}

1672

1716

1673

if (vm.count("help") || vm.count("version"))

1717

if (vm.count("help"))

1674

1718

{

1675

printf(_("Drizzle client %s build %s, for %s-%s (%s) using readline %s\n"),

1676

drizzle_version(), VERSION,

1719

printf(_("drizzle Ver %s Distrib %s, for %s-%s (%s) using readline %s\n"),

1720

VER.c_str(), drizzle_version(),

1677

1721

HOST_VENDOR, HOST_OS, HOST_CPU,

1678

1722

rl_library_version);

1679

if (vm.count("version"))

1680

exit(0);

1681

1723

1682

1724

"This software comes with ABSOLUTELY NO WARRANTY. "

1683

1725

"This is free software,\n"

1684

1726

"and you are welcome to modify and redistribute it "

1685

1727

"under the GPL license\n"));

1686

1728

printf(_("Usage: drizzle [OPTIONS] [database]\n"));

1687

cout << long_options;

1729

cout<<long_options;

1688

1730

exit(0);

1689

1731

}

1690

1732

1733

1775

/* call the SIGWINCH handler to get the default term width */

1734

1776

window_resize(0);

1735

1777

#endif

1736

std::vector<char> output_buff;

1737

output_buff.resize(512);

1738

1739

snprintf(&output_buff[0], output_buff.size(),

1740

_("Welcome to the Drizzle client.. Commands end with %s or \\g."),

1741

delimiter);

1742

1743

put_info(&output_buff[0], INFO_INFO, 0, 0);

1778

1779

put_info(_("Welcome to the Drizzle client.. Commands end with ; or \\g."),

1780

INFO_INFO,0,0);

1744

1781

1745

1782

glob_buffer= new string();

1746

1783

glob_buffer->reserve(512);

1747

1784

1785

std::vector<char> output_buff;

1786

output_buff.resize(512);

1748

1787

snprintf(&output_buff[0], output_buff.size(),

1749

_("Your Drizzle connection id is %u\nConnection protocol: %s\nServer version: %s\n"),

1788

_("Your Drizzle connection id is %u\nServer version: %s\n"),

1750

1789

drizzle_con_thread_id(&con),

1751

opt_protocol.c_str(),

1752

1790

server_version_string(&con));

1753

1791

put_info(&output_buff[0], INFO_INFO, 0, 0);

1754

1792

1755

1756

1793

initialize_readline((char *)current_prompt.c_str());

1757

1794

if (!status.getBatch() && !quick)

1758

1795

{

1801

1838

1802

1839

catch(exception &err)

1803

1840

{

1804

cerr << _("Error:") << err.what() << endl;

1841

cerr<<"Error:"<<err.what()<<endl;

1805

1842

}

1806

1843

return(0); // Keep compiler happy

1807

1844

}

1823

1860

1824

1861

if (sig >= 0)

1825

1862

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

1826

delete glob_buffer;

1827

delete processed_prompt;

1863

if (glob_buffer)

1864

delete glob_buffer;

1865

if (processed_prompt)

1866

delete processed_prompt;

1828

1867

opt_password.erase();

1829

1868

free(histfile);

1830

1869

free(histfile_tmp);

1848

1887

void handle_sigint(int sig)

1849

1888

{

1850

1889

char kill_buffer[40];

1851

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

1890

drizzle_con_st kill_drizzle;

1852

1891

drizzle_result_st res;

1853

1892

drizzle_return_t ret;

1854

1893

1857

1896

goto err;

1858

1897

}

1859

1898

1860

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

1861

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

1862

use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)

1899

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

1900

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

1901

opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE) == NULL)

1863

1902

{

1864

1903

goto err;

1865

1904

}

1868

1907

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

1869

1908

drizzle_con_thread_id(&con));

1870

1909

1871

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

1910

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

1872

1911

drizzle_result_free(&res);

1873

1912

1874

drizzle_con_free(kill_drizzle.get());

1913

drizzle_con_free(&kill_drizzle);

1875

1914

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

1876

1915

1877

1916

interrupted_query= 1;

2342

2381

{

2343

2382

*out++='\n';

2344

2383

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

2384

if ((!*ml_comment || preserve_comments))

2352

2385

buffer->append(line, length);

2353

2386

}

2623

2656

{

2624

2657

string query;

2625

2658

2626

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

2659

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

2627

2660

query.append(table_row[0]);

2628

query.append("`");

2661

query.append("'");

2629

2662

2630

2663

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

2631

2664

&ret) != NULL)

2695

2728

The different commands

2696

2729

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

2697

2730

2698

int drizzleclient_real_query_for_lazy(const char *buf, size_t length,

2731

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2699

2732

drizzle_result_st *result,

2700

2733

uint32_t *error_code)

2701

2734

{

2734

2767

return 0;

2735

2768

2736

2769

if (drizzle_con_error(&con)[0])

2737

{

2738

int ret= put_error(&con, result);

2739

drizzle_result_free(result);

2740

return ret;

2741

}

2770

return put_error(&con, result);

2742

2771

return 0;

2743

2772

}

2744

2773

2747

2776

{

2748

2777

2749

2778

char buff[32], *end;

2750

std::vector<char> output_buff;

2751

output_buff.resize(512);

2752

2779

2753

2780

put_info(_("List of all Drizzle commands:"), INFO_INFO,0,0);

2754

2781

if (!named_cmds)

2755

{

2756

snprintf(&output_buff[0], output_buff.size(),

2757

_("Note that all text commands must be first on line and end with '%s' or \\g"),

2758

delimiter);

2759

put_info(&output_buff[0], INFO_INFO, 0, 0);

2760

}

2782

put_info(_("Note that all text commands must be first on line and end with ';'"),INFO_INFO,0,0);

2761

2783

for (i = 0; commands[i].getName(); i++)

2762

2784

{

2763

2785

end= strcpy(buff, commands[i].getName());

2973

2995

{

2974

2996

if (!(PAGER= popen(pager.c_str(), "w")))

2975

2997

{

2976

tee_fprintf(stdout,_( "popen() failed! defaulting PAGER to stdout!\n"));

2998

tee_fprintf(stdout, "popen() failed! defaulting PAGER to stdout!\n");

2977

2999

PAGER= stdout;

2978

3000

}

2979

3001

}

2995

3017

end_tee();

2996

3018

if (!(new_outfile= fopen(file_name, "a")))

2997

3019

{

2998

tee_fprintf(stdout, _("Error logging to file '%s'\n"), file_name);

3020

tee_fprintf(stdout, "Error logging to file '%s'\n", file_name);

2999

3021

return;

3000

3022

}

3001

3023

OUTFILE = new_outfile;

3002

3024

outfile.assign(file_name);

3003

tee_fprintf(stdout, _("Logging to file '%s'\n"), file_name);

3025

tee_fprintf(stdout, "Logging to file '%s'\n", file_name);

3004

3026

opt_outfile= 1;

3005

3027

3006

3028

return;

3084

3106

3085

3107

while ((field = drizzle_column_next(result)))

3086

3108

{

3087

tee_fprintf(PAGER, _("Field %3u: `%s`\n"

3109

tee_fprintf(PAGER, "Field %3u: `%s`\n"

3088

3110

"Catalog: `%s`\n"

3089

3111

"Database: `%s`\n"

3090

3112

"Table: `%s`\n"

3094

3116

"Length: %lu\n"

3095

3117

"Max_length: %lu\n"

3096

3118

"Decimals: %u\n"

3097

"Flags: %s\n\n"),

3119

"Flags: %s\n\n",

3098

3120

++i,

3099

3121

drizzle_column_name(field), drizzle_column_catalog(field),

3100

3122

drizzle_column_db(field), drizzle_column_table(field),

3551

3573

{

3552

3574

if (outfile.empty())

3553

3575

{

3554

printf(_("No previous outfile available, you must give a filename!\n"));

3576

printf("No previous outfile available, you must give a filename!\n");

3555

3577

return 0;

3556

3578

}

3557

3579

else if (opt_outfile)

3558

3580

{

3559

tee_fprintf(stdout, _("Currently logging to file '%s'\n"), outfile.c_str());

3581

tee_fprintf(stdout, "Currently logging to file '%s'\n", outfile.c_str());

3560

3582

return 0;

3561

3583

}

3562

3584

else

3576

3598

end[0]= 0;

3577

3599

if (end == file_name)

3578

3600

{

3579

printf(_("No outfile specified!\n"));

3601

printf("No outfile specified!\n");

3580

3602

return 0;

3581

3603

}

3582

3604

init_tee(file_name);

3589

3611

{

3590

3612

if (opt_outfile)

3591

3613

end_tee();

3592

tee_fprintf(stdout, _("Outfile disabled.\n"));

3614

tee_fprintf(stdout, "Outfile disabled.\n");

3593

3615

return 0;

3594

3616

}

3595

3617

3612

3634

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

3613

3635

while (param && isspace(*param))

3614

3636

param++;

3615

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

3637

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

3616

3638

{

3617

3639

if (!default_pager_set)

3618

3640

{

3619

tee_fprintf(stdout, _("Default pager wasn't set, using stdout.\n"));

3641

tee_fprintf(stdout, "Default pager wasn't set, using stdout.\n");

3620

3642

opt_nopager=1;

3621

3643

pager.assign("stdout");

3622

3644

PAGER= stdout;

3636

3658

default_pager.assign(pager_name);

3637

3659

}

3638

3660

opt_nopager=0;

3639

tee_fprintf(stdout, _("PAGER set to '%s'\n"), pager.c_str());

3661

tee_fprintf(stdout, "PAGER set to '%s'\n", pager.c_str());

3640

3662

return 0;

3641

3663

}

3642

3664

3647

3669

pager.assign("stdout");

3648

3670

opt_nopager=1;

3649

3671

PAGER= stdout;

3650

tee_fprintf(stdout, _("PAGER set to stdout\n"));

3672

tee_fprintf(stdout, "PAGER set to stdout\n");

3651

3673

return 0;

3652

3674

}

3653

3675

3730

3752

3731

3753

if (connected)

3732

3754

{

3733

sprintf(buff, _("Connection id: %u"), drizzle_con_thread_id(&con));

3755

sprintf(buff,"Connection id: %u",drizzle_con_thread_id(&con));

3734

3756

put_info(buff,INFO_INFO,0,0);

3735

sprintf(buff, _("Current database: %.128s\n"),

3736

!current_db.empty() ? current_db.c_str() : _("*** NONE ***"));

3757

sprintf(buff,"Current database: %.128s\n",

3758

!current_db.empty() ? current_db.c_str() : "*** NONE ***");

3737

3759

put_info(buff,INFO_INFO,0,0);

3738

3760

}

3739

3761

return error;

3753

3775

while (isspace(*line))

3754

3776

line++;

3755

3777

if (!(param = strchr(line, ' '))) // Skip command name

3756

return put_info(_("Usage: \\. <filename> | source <filename>"),

3778

return put_info("Usage: \\. <filename> | source <filename>",

3757

3779

INFO_ERROR, 0,0);

3758

3780

while (isspace(*param))

3759

3781

param++;

3768

3790

if (!(sql_file = fopen(source_name, "r")))

3769

3791

{

3770

3792

char buff[FN_REFLEN+60];

3771

sprintf(buff, _("Failed to open file '%s', error: %d"), source_name,errno);

3793

sprintf(buff,"Failed to open file '%s', error: %d", source_name,errno);

3772

3794

return put_info(buff, INFO_ERROR, 0 ,0);

3773

3795

}

3774

3796

3776

3798

if (line_buff == NULL)

3777

3799

{

3778

3800

fclose(sql_file);

3779

return put_info(_("Can't initialize LineBuffer"), INFO_ERROR, 0, 0);

3801

return put_info("Can't initialize LineBuffer", INFO_ERROR, 0, 0);

3780

3802

}

3781

3803

3782

3804

/* Save old status */

3812

3834

3813

3835

if (!tmp || !*tmp)

3814

3836

{

3815

put_info(_("DELIMITER must be followed by a 'delimiter' character or string"),

3837

put_info("DELIMITER must be followed by a 'delimiter' character or string",

3816

3838

INFO_ERROR, 0, 0);

3817

3839

return 0;

3818

3840

}

3820

3842

{

3821

3843

if (strstr(tmp, "\\"))

3822

3844

{

3823

put_info(_("DELIMITER cannot contain a backslash character"),

3845

put_info("DELIMITER cannot contain a backslash character",

3824

3846

INFO_ERROR, 0, 0);

3825

3847

return 0;

3826

3848

}

3845

3867

tmp= get_arg(buff, 0);

3846

3868

if (!tmp || !*tmp)

3847

3869

{

3848

put_info(_("USE must be followed by a database name"), INFO_ERROR, 0, 0);

3870

put_info("USE must be followed by a database name", INFO_ERROR, 0, 0);

3849

3871

return 0;

3850

3872

}

3851

3873

3913

3935

build_completion_hash(opt_rehash, 1);

3914

3936

}

3915

3937

3916

put_info(_("Database changed"),INFO_INFO, 0, 0);

3938

put_info("Database changed",INFO_INFO, 0, 0);

3917

3939

return 0;

3918

3940

}

3919

3941

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

3942

static int

3959

3943

com_warnings(string *, const char *)

3960

3944

{

3961

3945

show_warnings = 1;

3962

put_info(_("Show warnings enabled."),INFO_INFO, 0, 0);

3946

put_info("Show warnings enabled.",INFO_INFO, 0, 0);

3963

3947

return 0;

3964

3948

}

3965

3949

3967

3951

com_nowarnings(string *, const char *)

3968

3952

{

3969

3953

show_warnings = 0;

3970

put_info(_("Show warnings disabled."),INFO_INFO, 0, 0);

3954

put_info("Show warnings disabled.",INFO_INFO, 0, 0);

3971

3955

return 0;

3972

3956

}

3973

3957

4045

4029

drizzle_free(&drizzle);

4046

4030

}

4047

4031

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

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

4056

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

4057

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

4058

options) == NULL)

4032

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

4033

(char *)password.c_str(), (char *)database.c_str(), opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE) == NULL)

4059

4034

{

4060

4035

(void) put_error(&con, NULL);

4061

4036

(void) fflush(stdout);

4111

4086

drizzle_return_t ret;

4112

4087

4113

4088

tee_puts("--------------", stdout);

4114

printf(_("Drizzle client %s build %s, for %s-%s (%s) using readline %s\n"),

4115

drizzle_version(), VERSION,

4116

HOST_VENDOR, HOST_OS, HOST_CPU,

4117

rl_library_version);

4089

printf(_("drizzle Ver %s Distrib %s, for %s-%s (%s) using readline %s\n"),

4090

VER.c_str(), drizzle_version(),

4091

HOST_VENDOR, HOST_OS, HOST_CPU,

4092

rl_library_version); /* Print version */

4093

4118

4094

4119

4095

if (connected)

4120

4096

{

4121

tee_fprintf(stdout, _("\nConnection id:\t\t%lu\n"),drizzle_con_thread_id(&con));

4097

tee_fprintf(stdout, "\nConnection id:\t\t%lu\n",drizzle_con_thread_id(&con));

4122

4098

4123

4099

Don't remove "limit 1",

4124

4100

it is protection againts SQL_SELECT_LIMIT=0

4130

4106

drizzle_row_t cur=drizzle_row_next(&result);

4131

4107

if (cur)

4132

4108

{

4133

tee_fprintf(stdout, _("Current database:\t%s\n"), cur[0] ? cur[0] : "");

4134

tee_fprintf(stdout, _("Current user:\t\t%s\n"), cur[1]);

4109

tee_fprintf(stdout, "Current database:\t%s\n", cur[0] ? cur[0] : "");

4110

tee_fprintf(stdout, "Current user:\t\t%s\n", cur[1]);

4135

4111

}

4136

4112

drizzle_result_free(&result);

4137

4113

}

4138

4114

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

4139

4115

drizzle_result_free(&result);

4140

tee_puts(_("SSL:\t\t\tNot in use"), stdout);

4116

tee_puts("SSL:\t\t\tNot in use", stdout);

4141

4117

}

4142

4118

else

4143

4119

{

4144

4120

vidattr(A_BOLD);

4145

tee_fprintf(stdout, _("\nNo connection\n"));

4121

tee_fprintf(stdout, "\nNo connection\n");

4146

4122

vidattr(A_NORMAL);

4147

4123

return 0;

4148

4124

}

4149

4125

if (skip_updates)

4150

4126

{

4151

4127

vidattr(A_BOLD);

4152

tee_fprintf(stdout, _("\nAll updates ignored to this database\n"));

4128

tee_fprintf(stdout, "\nAll updates ignored to this database\n");

4153

4129

vidattr(A_NORMAL);

4154

4130

}

4155

tee_fprintf(stdout, _("Current pager:\t\t%s\n"), pager.c_str());

4156

tee_fprintf(stdout, _("Using outfile:\t\t'%s'\n"), opt_outfile ? outfile.c_str() : "");

4157

tee_fprintf(stdout, _("Using delimiter:\t%s\n"), delimiter);

4158

tee_fprintf(stdout, _("Server version:\t\t%s\n"), server_version_string(&con));

4159

tee_fprintf(stdout, _("Protocol:\t\t%s\n"), opt_protocol.c_str());

4160

tee_fprintf(stdout, _("Protocol version:\t%d\n"), drizzle_con_protocol_version(&con));

4161

tee_fprintf(stdout, _("Connection:\t\t%s\n"), drizzle_con_host(&con));

4131

tee_fprintf(stdout, "Current pager:\t\t%s\n", pager.c_str());

4132

tee_fprintf(stdout, "Using outfile:\t\t'%s'\n", opt_outfile ? outfile.c_str() : "");

4133

tee_fprintf(stdout, "Using delimiter:\t%s\n", delimiter);

4134

tee_fprintf(stdout, "Server version:\t\t%s\n", server_version_string(&con));

4135

tee_fprintf(stdout, "Protocol version:\t%d\n", drizzle_con_protocol_version(&con));

4136

tee_fprintf(stdout, "Connection:\t\t%s\n", drizzle_con_host(&con));

4162

4137

/* XXX need to save this from result

4163

4138

if ((id= drizzleclient_insert_id(&drizzle)))

4164

4139

tee_fprintf(stdout, "Insert id:\t\t%s\n", internal::llstr(id, buff));

4165

4140

4166

4141

4167

4142

if (drizzle_con_uds(&con))

4168

tee_fprintf(stdout, _("UNIX socket:\t\t%s\n"), drizzle_con_uds(&con));

4143

tee_fprintf(stdout, "UNIX socket:\t\t%s\n", drizzle_con_uds(&con));

4169

4144

else

4170

tee_fprintf(stdout, _("TCP port:\t\t%d\n"), drizzle_con_port(&con));

4145

tee_fprintf(stdout, "TCP port:\t\t%d\n", drizzle_con_port(&con));

4171

4146

4172

4147

if (safe_updates)

4173

4148

{

4174

4149

vidattr(A_BOLD);

4175

tee_fprintf(stdout, _("\nNote that you are running in safe_update_mode:\n"));

4150

tee_fprintf(stdout, "\nNote that you are running in safe_update_mode:\n");

4176

4151

vidattr(A_NORMAL);

4177

tee_fprintf(stdout, _("\

4152

tee_fprintf(stdout, "\

4178

4153

UPDATEs and DELETEs that don't use a key in the WHERE clause are not allowed.\n\

4179

4154

(One can force an UPDATE/DELETE by adding LIMIT # at the end of the command.)\n \

4180

4155

SELECT has an automatic 'LIMIT %lu' if LIMIT is not used.\n \

4181

Max number of examined row combination in a join is set to: %lu\n\n"),

4156

Max number of examined row combination in a join is set to: %lu\n\n",

4182

4157

select_limit, max_join_size);

4183

4158

}

4184

4159

tee_puts("--------------\n", stdout);

4236

4211

if (info_type == INFO_ERROR)

4237

4212

{

4238

4213

(void) fflush(file);

4239

fprintf(file,_("ERROR"));

4214

fprintf(file,"ERROR");

4240

4215

if (error)

4241

4216

{

4242

4217

if (sqlstate)

4279

4254

if (error)

4280

4255

{

4281

4256

if (sqlstate)

4282

(void) tee_fprintf(file, _("ERROR %d (%s): "), error, sqlstate);

4257

(void) tee_fprintf(file, "ERROR %d (%s): ", error, sqlstate);

4283

4258

else

4284

(void) tee_fprintf(file, _("ERROR %d: "), error);

4259

(void) tee_fprintf(file, "ERROR %d: ", error);

4285

4260

}

4286

4261

else

4287

tee_puts(_("ERROR: "), file);

4262

tee_puts("ERROR: ", file);

4288

4263

}

4289

4264

else

4290

4265

vidattr(A_BOLD);

4417

4392

tmp_buff_str << tmp;

4418

4393

4419

4394

if (tmp > 1)

4420

tmp_buff_str << _(" hours ");

4395

tmp_buff_str << " hours ";

4421

4396

else

4422

tmp_buff_str << _(" hour ");

4397

tmp_buff_str << " hour ";

4423

4398

}

4424

4399

if (sec >= 60.0)

4425

4400

{

4426

4401

tmp=(uint32_t) floor(sec/60.0);

4427

4402

sec-=60.0*tmp;

4428

tmp_buff_str << tmp << _(" min ");

4403

tmp_buff_str << tmp << " min ";

4429

4404

}

4430

4405

if (part_second)

4431

4406

tmp_buff_str.precision(2);

4432

4407

else

4433

4408

tmp_buff_str.precision(0);

4434

tmp_buff_str << sec << _(" sec");

4409

tmp_buff_str << sec << " sec";

4435

4410

strcpy(buff, tmp_buff_str.str().c_str());

4436

4411

}

4437

4412

4532

4507

if (!full_username)

4533

4508

init_username();

4534

4509

processed_prompt->append(part_username ? part_username :

4535

(!current_user.empty() ? current_user : _("(unknown)")));

4510

(!current_user.empty() ? current_user : "(unknown)"));

4536

4511

break;

4537

4512

case PROMPT_CHAR:

4538

4513

{

4652

4627

{

4653

4628

const char *ptr=strchr(line, ' ');

4654

4629

if (ptr == NULL)

4655

tee_fprintf(stdout, _("Returning to default PROMPT of %s\n"),

4630

tee_fprintf(stdout, "Returning to default PROMPT of %s\n",

4656

4631

default_prompt);

4657

4632

prompt_counter = 0;

4658

4633

char * tmpptr= strdup(ptr ? ptr+1 : default_prompt);

4659

4634

if (tmpptr == NULL)

4660

tee_fprintf(stdout, _("Memory allocation error. Not changing prompt\n"));

4635

tee_fprintf(stdout, "Memory allocation error. Not changing prompt\n");

4661

4636

else

4662

4637

{

4663

4638

current_prompt.erase();

4664

4639

current_prompt= tmpptr;

4665

tee_fprintf(stdout, _("PROMPT set to '%s'\n"), current_prompt.c_str());

4640

tee_fprintf(stdout, "PROMPT set to '%s'\n", current_prompt.c_str());

4666

4641

}

4667

4642

return 0;

4668

4643

}

Older »