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

1377

1378

("no-named-commands,g",

1379

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

1380

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

1302

1381

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

1303

1382

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

1383

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

1384

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

1385

("skip-line-numbers,L",

1386

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

1387

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

1388

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

1306

1389

("skip-column-names,N",

1307

1390

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

1308

1391

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

1309

1392

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

1310

1393

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

1311

1394

N_("Output in table format."))

1312

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

1395

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

1313

1396

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

1397

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

1315

1398

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

1316

1399

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

1317

1400

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

1328

1411

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

1329

1412

;

1330

1413

1331

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

1414

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

1332

1415

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

1416

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

1417

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

1418

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

1419

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

1336

1420

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

1337

1421

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

1343

1427

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

1344

1428

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

1345

1429

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

1346

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

1430

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

1347

1431

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

1348

1432

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

1349

1433

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

1360

1444

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

1445

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

1362

1446

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

1447

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

1448

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

1449

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

1365

1450

N_("Shutdown the server"))

1366

1451

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

1367

1452

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

1368

1453

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

1454

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

1370

1455

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

1456

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

1457

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

1372

1458

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

1459

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

1374

1460

N_("Max length of input line"))

1375

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

1461

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

1376

1462

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

1377

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

1463

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

1378

1464

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

1379

1465

;

1380

1466

1381

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

1467

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

1382

1468

client_options.add_options()

1469

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

1470

N_("Use MySQL Protocol."))

1383

1471

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

1384

1472

N_("Connect to host"))

1385

1473

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

1386

1474

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

1387

1475

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

1388

1476

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

1477

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

1393

#endif

1394

1478

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

1479

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

1480

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

1397

1481

;

1398

1482

1399

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

1483

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

1400

1484

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

1401

1485

1402

1486

std::string system_config_dir_drizzle(SYSCONFDIR);

1406

1490

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

1407

1491

1408

1492

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

1493

1418

1494

po::variables_map vm;

1419

1495

1420

1496

po::positional_options_description p;

1421

1497

p.add("database", 1);

1422

1498

1423

// Disable allow_guessing

1424

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

1425

1426

1499

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

1427

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

1428

vm);

1500

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

1429

1501

1430

1502

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

1431

1503

{

1436

1508

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

1437

1509

1438

1510

ifstream user_drizzle_ifs(user_config_dir_drizzle.c_str());

1439

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

1511

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

1440

1512

1441

1513

ifstream user_client_ifs(user_config_dir_client.c_str());

1442

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

1514

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

1443

1515

1444

1516

ifstream system_drizzle_ifs(system_config_dir_drizzle.c_str());

1445

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

1517

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

1446

1518

1447

1519

ifstream system_client_ifs(system_config_dir_client.c_str());

1448

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

1520

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

1449

1521

}

1450

1522

1451

1523

po::notify(vm);

1452

1524

1453

#ifdef DRIZZLE_ADMIN_TOOL

1454

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1455

getenv("DRIZZLE_PS1") :

1456

"drizzleadmin> ");

1457

#else

1458

1525

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1459

1526

getenv("DRIZZLE_PS1") :

1460

1527

"drizzle> ");

1461

#endif

1462

1528

if (default_prompt == NULL)

1463

1529

{

1464

1530

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

1510

1576

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

1511

1577

}

1512

1578

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

1579

if (vm.count("delimiter"))

1528

1580

{

1529

1581

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

1600

1652

1601

1653

if (one_database)

1602

1654

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

1655

1620

1656

if (vm.count("port"))

1621

1657

{

1622

1658

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

1669

1705

{

1670

1706

opt_silent++;

1671

1707

}

1708

if (vm.count("version"))

1709

{

1710

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

1711

VER.c_str(), drizzle_version(),

1712

HOST_VENDOR, HOST_OS, HOST_CPU,

1713

rl_library_version);

1714

1715

exit(0);

1716

}

1672

1717

1673

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

1718

if (vm.count("help"))

1674

1719

{

1675

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

1676

drizzle_version(), VERSION,

1720

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

1721

VER.c_str(), drizzle_version(),

1677

1722

HOST_VENDOR, HOST_OS, HOST_CPU,

1678

1723

rl_library_version);

1679

if (vm.count("version"))

1680

exit(0);

1681

1724

1682

1725

"This software comes with ABSOLUTELY NO WARRANTY. "

1683

1726

"This is free software,\n"

1684

1727

"and you are welcome to modify and redistribute it "

1685

1728

"under the GPL license\n"));

1686

1729

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

1687

cout << long_options;

1730

cout<<long_options;

1688

1731

exit(0);

1689

1732

}

1690

1733

1746

1789

glob_buffer->reserve(512);

1747

1790

1748

1791

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

1749

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

1792

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

1750

1793

drizzle_con_thread_id(&con),

1751

opt_protocol.c_str(),

1752

1794

server_version_string(&con));

1753

1795

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

1754

1796

1755

1756

1797

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

1757

1798

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

1758

1799

{

1801

1842

1802

1843

catch(exception &err)

1803

1844

{

1804

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

1845

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

1805

1846

}

1806

1847

return(0); // Keep compiler happy

1807

1848

}

1823

1864

1824

1865

if (sig >= 0)

1825

1866

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

1826

delete glob_buffer;

1827

delete processed_prompt;

1867

if (glob_buffer)

1868

delete glob_buffer;

1869

if (processed_prompt)

1870

delete processed_prompt;

1828

1871

opt_password.erase();

1829

1872

free(histfile);

1830

1873

free(histfile_tmp);

1848

1891

void handle_sigint(int sig)

1849

1892

{

1850

1893

char kill_buffer[40];

1851

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

1894

drizzle_con_st kill_drizzle;

1852

1895

drizzle_result_st res;

1853

1896

drizzle_return_t ret;

1854

1897

1857

1900

goto err;

1858

1901

}

1859

1902

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)

1903

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

1904

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

1905

opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE) == NULL)

1863

1906

{

1864

1907

goto err;

1865

1908

}

1868

1911

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

1869

1912

drizzle_con_thread_id(&con));

1870

1913

1871

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

1914

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

1872

1915

drizzle_result_free(&res);

1873

1916

1874

drizzle_con_free(kill_drizzle.get());

1917

drizzle_con_free(&kill_drizzle);

1875

1918

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

1876

1919

1877

1920

interrupted_query= 1;

2342

2385

{

2343

2386

*out++='\n';

2344

2387

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

2388

if ((!*ml_comment || preserve_comments))

2352

2389

buffer->append(line, length);

2353

2390

}

2623

2660

{

2624

2661

string query;

2625

2662

2626

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

2663

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

2627

2664

query.append(table_row[0]);

2628

query.append("`");

2665

query.append("'");

2629

2666

2630

2667

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

2631

2668

&ret) != NULL)

2695

2732

The different commands

2696

2733

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

2697

2734

2698

int drizzleclient_real_query_for_lazy(const char *buf, size_t length,

2735

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2699

2736

drizzle_result_st *result,

2700

2737

uint32_t *error_code)

2701

2738

{

2734

2771

return 0;

2735

2772

2736

2773

if (drizzle_con_error(&con)[0])

2737

{

2738

int ret= put_error(&con, result);

2739

drizzle_result_free(result);

2740

return ret;

2741

}

2774

return put_error(&con, result);

2742

2775

return 0;

2743

2776

}

2744

2777

2973

3006

{

2974

3007

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

2975

3008

{

2976

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

3009

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

2977

3010

PAGER= stdout;

2978

3011

}

2979

3012

}

2995

3028

end_tee();

2996

3029

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

2997

3030

{

2998

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

3031

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

2999

3032

return;

3000

3033

}

3001

3034

OUTFILE = new_outfile;

3002

3035

outfile.assign(file_name);

3003

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

3036

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

3004

3037

opt_outfile= 1;

3005

3038

3006

3039

return;

3084

3117

3085

3118

while ((field = drizzle_column_next(result)))

3086

3119

{

3087

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

3120

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

3088

3121

"Catalog: `%s`\n"

3089

3122

"Database: `%s`\n"

3090

3123

"Table: `%s`\n"

3094

3127

"Length: %lu\n"

3095

3128

"Max_length: %lu\n"

3096

3129

"Decimals: %u\n"

3097

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

3130

"Flags: %s\n\n",

3098

3131

++i,

3099

3132

drizzle_column_name(field), drizzle_column_catalog(field),

3100

3133

drizzle_column_db(field), drizzle_column_table(field),

3551

3584

{

3552

3585

if (outfile.empty())

3553

3586

{

3554

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

3587

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

3555

3588

return 0;

3556

3589

}

3557

3590

else if (opt_outfile)

3558

3591

{

3559

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

3592

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

3560

3593

return 0;

3561

3594

}

3562

3595

else

3576

3609

end[0]= 0;

3577

3610

if (end == file_name)

3578

3611

{

3579

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

3612

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

3580

3613

return 0;

3581

3614

}

3582

3615

init_tee(file_name);

3589

3622

{

3590

3623

if (opt_outfile)

3591

3624

end_tee();

3592

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

3625

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

3593

3626

return 0;

3594

3627

}

3595

3628

3612

3645

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

3613

3646

while (param && isspace(*param))

3614

3647

param++;

3615

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

3648

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

3616

3649

{

3617

3650

if (!default_pager_set)

3618

3651

{

3619

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

3652

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

3620

3653

opt_nopager=1;

3621

3654

pager.assign("stdout");

3622

3655

PAGER= stdout;

3636

3669

default_pager.assign(pager_name);

3637

3670

}

3638

3671

opt_nopager=0;

3639

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

3672

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

3640

3673

return 0;

3641

3674

}

3642

3675

3647

3680

pager.assign("stdout");

3648

3681

opt_nopager=1;

3649

3682

PAGER= stdout;

3650

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

3683

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

3651

3684

return 0;

3652

3685

}

3653

3686

3730

3763

3731

3764

if (connected)

3732

3765

{

3733

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

3766

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

3734

3767

put_info(buff,INFO_INFO,0,0);

3735

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

3736

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

3768

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

3769

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

3737

3770

put_info(buff,INFO_INFO,0,0);

3738

3771

}

3739

3772

return error;

3753

3786

while (isspace(*line))

3754

3787

line++;

3755

3788

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

3756

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

3789

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

3757

3790

INFO_ERROR, 0,0);

3758

3791

while (isspace(*param))

3759

3792

param++;

3768

3801

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

3769

3802

{

3770

3803

char buff[FN_REFLEN+60];

3771

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

3804

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

3772

3805

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

3773

3806

}

3774

3807

3776

3809

if (line_buff == NULL)

3777

3810

{

3778

3811

fclose(sql_file);

3779

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

3812

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

3780

3813

}

3781

3814

3782

3815

/* Save old status */

3812

3845

3813

3846

if (!tmp || !*tmp)

3814

3847

{

3815

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

3848

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

3816

3849

INFO_ERROR, 0, 0);

3817

3850

return 0;

3818

3851

}

3820

3853

{

3821

3854

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

3822

3855

{

3823

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

3856

put_info("DELIMITER cannot contain a backslash character",

3824

3857

INFO_ERROR, 0, 0);

3825

3858

return 0;

3826

3859

}

3845

3878

tmp= get_arg(buff, 0);

3846

3879

if (!tmp || !*tmp)

3847

3880

{

3848

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

3881

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

3849

3882

return 0;

3850

3883

}

3851

3884

3913

3946

build_completion_hash(opt_rehash, 1);

3914

3947

}

3915

3948

3916

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

3949

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

3917

3950

return 0;

3918

3951

}

3919

3952

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

3953

static int

3959

3954

com_warnings(string *, const char *)

3960

3955

{

3961

3956

show_warnings = 1;

3962

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

3957

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

3963

3958

return 0;

3964

3959

}

3965

3960

3967

3962

com_nowarnings(string *, const char *)

3968

3963

{

3969

3964

show_warnings = 0;

3970

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

3965

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

3971

3966

return 0;

3972

3967

}

3973

3968

4045

4040

drizzle_free(&drizzle);

4046

4041

}

4047

4042

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)

4043

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

4044

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

4059

4045

{

4060

4046

(void) put_error(&con, NULL);

4061

4047

(void) fflush(stdout);

4111

4097

drizzle_return_t ret;

4112

4098

4113

4099

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

4100

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

4101

VER.c_str(), drizzle_version(),

4102

HOST_VENDOR, HOST_OS, HOST_CPU,

4103

rl_library_version); /* Print version */

4104

4118

4105

4119

4106

if (connected)

4120

4107

{

4121

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

4108

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

4122

4109

4123

4110

Don't remove "limit 1",

4124

4111

it is protection againts SQL_SELECT_LIMIT=0

4130

4117

drizzle_row_t cur=drizzle_row_next(&result);

4131

4118

if (cur)

4132

4119

{

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

4120

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

4121

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

4135

4122

}

4136

4123

drizzle_result_free(&result);

4137

4124

}

4138

4125

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

4139

4126

drizzle_result_free(&result);

4140

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

4127

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

4141

4128

}

4142

4129

else

4143

4130

{

4144

4131

vidattr(A_BOLD);

4145

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

4132

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

4146

4133

vidattr(A_NORMAL);

4147

4134

return 0;

4148

4135

}

4149

4136

if (skip_updates)

4150

4137

{

4151

4138

vidattr(A_BOLD);

4152

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

4139

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

4153

4140

vidattr(A_NORMAL);

4154

4141

}

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

4142

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

4143

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

4144

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

4145

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

4146

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

4147

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

4162

4148

/* XXX need to save this from result

4163

4149

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

4164

4150

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

4165

4151

4166

4152

4167

4153

if (drizzle_con_uds(&con))

4168

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

4154

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

4169

4155

else

4170

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

4156

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

4171

4157

4172

4158

if (safe_updates)

4173

4159

{

4174

4160

vidattr(A_BOLD);

4175

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

4161

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

4176

4162

vidattr(A_NORMAL);

4177

tee_fprintf(stdout, _("\

4163

tee_fprintf(stdout, "\

4178

4164

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

4179

4165

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

4180

4166

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

4167

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

4182

4168

select_limit, max_join_size);

4183

4169

}

4184

4170

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

4236

4222

if (info_type == INFO_ERROR)

4237

4223

{

4238

4224

(void) fflush(file);

4239

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

4225

fprintf(file,"ERROR");

4240

4226

if (error)

4241

4227

{

4242

4228

if (sqlstate)

4279

4265

if (error)

4280

4266

{

4281

4267

if (sqlstate)

4282

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

4268

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

4283

4269

else

4284

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

4270

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

4285

4271

}

4286

4272

else

4287

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

4273

tee_puts("ERROR: ", file);

4288

4274

}

4289

4275

else

4290

4276

vidattr(A_BOLD);

4417

4403

tmp_buff_str << tmp;

4418

4404

4419

4405

if (tmp > 1)

4420

tmp_buff_str << _(" hours ");

4406

tmp_buff_str << " hours ";

4421

4407

else

4422

tmp_buff_str << _(" hour ");

4408

tmp_buff_str << " hour ";

4423

4409

}

4424

4410

if (sec >= 60.0)

4425

4411

{

4426

4412

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

4427

4413

sec-=60.0*tmp;

4428

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

4414

tmp_buff_str << tmp << " min ";

4429

4415

}

4430

4416

if (part_second)

4431

4417

tmp_buff_str.precision(2);

4432

4418

else

4433

4419

tmp_buff_str.precision(0);

4434

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

4420

tmp_buff_str << sec << " sec";

4435

4421

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

4436

4422

}

4437

4423

4532

4518

if (!full_username)

4533

4519

init_username();

4534

4520

processed_prompt->append(part_username ? part_username :

4535

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

4521

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

4536

4522

break;

4537

4523

case PROMPT_CHAR:

4538

4524

{

4652

4638

{

4653

4639

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

4654

4640

if (ptr == NULL)

4655

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

4641

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

4656

4642

default_prompt);

4657

4643

prompt_counter = 0;

4658

4644

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

4659

4645

if (tmpptr == NULL)

4660

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

4646

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

4661

4647

else

4662

4648

{

4663

4649

current_prompt.erase();

4664

4650

current_prompt= tmpptr;

4665

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

4651

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

4666

4652

}

4667

4653

return 0;

4668

4654

}

Older »