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

1302

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

1303

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

1306

("skip-column-names,N",

1307

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

1308

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

1309

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

1310

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

1311

N_("Output in table format."))

1312

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

1313

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

1315

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

1316

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

1317

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

1318

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

1319

("secure-auth", po::value<bool>(&opt_secure_auth)->default_value(false)->zero_tokens(),

1320

N_("Refuse client connecting to server if it uses old (pre-4.1.1) protocol"))

1321

("show-warnings", po::value<bool>(&show_warnings)->default_value(false)->zero_tokens(),

1322

N_("Show warnings after every statement."))

1323

("show-progress-size", po::value<uint32_t>(&show_progress_size)->default_value(0),

1324

N_("Number of lines before each import progress report."))

1325

("ping", po::value<bool>(&opt_ping)->default_value(false)->zero_tokens(),

1326

N_("Ping the server to check if it's alive."))

1327

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

1328

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

1329

;

1330

1331

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

1332

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

1335

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

1336

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

1337

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

1338

N_("Database to use."))

1339

("default-character-set",po::value<string>(),

1340

N_("(not used)"))

1341

("delimiter", po::value<string>(&delimiter_str)->default_value(";"),

1342

N_("Delimiter to be used."))

1343

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

1344

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

1345

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

1346

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

1347

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

1348

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

1349

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

1350

N_("Ignore SIGINT (CTRL-C)"))

1351

("one-database,o", po::value<bool>(&one_database)->default_value(false)->zero_tokens(),

1352

N_("Only update the default database. This is useful for skipping updates to other database in the update log."))

1353

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

1354

N_("Pager to use to display results. If you don't supply an option the default pager is taken from your ENV variable PAGER. Valid pagers are less, more, cat [> filename], etc. See interactive help (\\h) also. This option does not work in batch mode. Disable with --disable-pager. This option is disabled by default."))

1355

("disable-pager", po::value<bool>(&opt_nopager)->default_value(false)->zero_tokens(),

1356

N_("Disable pager and print to stdout. See interactive help (\\h) also."))

1357

("prompt", po::value<string>(&current_prompt)->default_value(""),

1358

N_("Set the drizzle prompt to this value."))

1359

("quick,q", po::value<bool>(&quick)->default_value(false)->zero_tokens(),

1360

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

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

1362

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

1365

N_("Shutdown the server"))

1366

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

1367

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

1368

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

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

1370

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

1372

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

1374

N_("Max length of input line"))

1375

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

1376

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

1377

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

1378

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

1379

;

1380

1381

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

1382

client_options.add_options()

1383

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

1384

N_("Connect to host"))

1385

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

1386

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

1387

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

1388

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

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

1393

#endif

1394

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

1397

;

1398

1399

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

1400

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

1401

1402

std::string system_config_dir_drizzle(SYSCONFDIR);

1403

system_config_dir_drizzle.append("/drizzle/drizzle.cnf");

1404

1405

std::string system_config_dir_client(SYSCONFDIR);

1406

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

1407

1408

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

1418

po::variables_map vm;

1419

1420

po::positional_options_description p;

1421

p.add("database", 1);

1422

1423

// Disable allow_guessing

1424

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

1425

1426

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

1427

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

1428

vm);

1429

1430

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

1431

{

1432

std::string user_config_dir_drizzle(user_config_dir);

1433

user_config_dir_drizzle.append("/drizzle/drizzle.cnf");

1434

1435

std::string user_config_dir_client(user_config_dir);

1436

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

1437

1438

ifstream user_drizzle_ifs(user_config_dir_drizzle.c_str());

1439

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

1440

1441

ifstream user_client_ifs(user_config_dir_client.c_str());

1442

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

1443

1444

ifstream system_drizzle_ifs(system_config_dir_drizzle.c_str());

1445

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

1446

1447

ifstream system_client_ifs(system_config_dir_client.c_str());

1448

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

1449

}

1450

1451

po::notify(vm);

1452

1453

#ifdef DRIZZLE_ADMIN_TOOL

1454

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1455

getenv("DRIZZLE_PS1") :

1456

"drizzleadmin> ");

1457

#else

1155

MY_INIT(argv[0]);

1156

delimiter_str= delimiter;

1458

1157

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1459

1158

getenv("DRIZZLE_PS1") :

1460

1159

"drizzle> ");

1461

#endif

1160

1462

1161

if (default_prompt == NULL)

1463

1162

{

1464

1163

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

1466

1165

exit(ENOMEM);

1467

1166

}

1468

1167

current_prompt= strdup(default_prompt);

1469

if (current_prompt.empty())

1168

if (current_prompt == NULL)

1470

1169

{

1471

1170

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

1472

1171

"prompt. Aborting.\n"));

1477

1176

1478

1177

prompt_counter=0;

1479

1178

1480

outfile.clear(); // no (default) outfile

1481

pager.assign("stdout"); // the default, if --pager wasn't given

1179

outfile[0]=0; // no (default) outfile

1180

strcpy(pager, "stdout"); // the default, if --pager wasn't given

1482

1181

{

1483

const char *tmp= getenv("PAGER");

1182

char *tmp=getenv("PAGER");

1484

1183

if (tmp && strlen(tmp))

1485

1184

{

1486

1185

default_pager_set= 1;

1487

default_pager.assign(tmp);

1186

strcpy(default_pager, tmp);

1488

1187

}

1489

1188

}

1490

if (! isatty(0) || ! isatty(1))

1189

if (!isatty(0) || !isatty(1))

1491

1190

{

1492

status.setBatch(1); opt_silent=1;

1191

status.batch=1; opt_silent=1;

1493

1192

ignore_errors=0;

1494

1193

}

1495

1194

else

1496

status.setAddToHistory(1);

1497

status.setExitStatus(1);

1195

status.add_to_history=1;

1196

status.exit_status=1;

1498

1197

1499

1198

{

1500

1199

1510

1209

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

1511

1210

}

1512

1211

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

if (vm.count("delimiter"))

1528

{

1529

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

1530

if (! strstr(delimiter_str.c_str(), "\\"))

1531

{

1532

delimiter= (char *)delimiter_str.c_str();

1533

}

1534

else

1535

{

1536

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

1537

INFO_ERROR,0,0);

1538

exit(-1);

1539

}

1540

1541

delimiter_length= (uint32_t)strlen(delimiter);

1542

}

1543

if (vm.count("tee"))

1544

{

1545

if (vm["tee"].as<string>().empty())

1546

{

1547

if (opt_outfile)

1548

end_tee();

1549

}

1550

else

1551

init_tee(vm["tee"].as<string>().c_str());

1552

}

1553

if (vm["disable-tee"].as<bool>() == true)

1554

{

1555

if (opt_outfile)

1556

end_tee();

1557

}

1558

if (vm.count("pager"))

1559

{

1560

if (vm["pager"].as<string>().empty())

1561

opt_nopager= 1;

1562

else

1563

{

1564

opt_nopager= 0;

1565

if (vm[pager].as<string>().length())

1566

{

1567

default_pager_set= 1;

1568

pager.assign(vm["pager"].as<string>());

1569

default_pager.assign(pager);

1570

}

1571

else if (default_pager_set)

1572

pager.assign(default_pager);

1573

else

1574

opt_nopager= 1;

1575

}

1576

}

1577

if (vm.count("disable-pager"))

1578

{

1579

opt_nopager= 1;

1580

}

1581

1582

if (vm.count("no-auto-rehash"))

1583

opt_rehash= 0;

1584

1585

if (vm.count("skip-column-names"))

1586

column_names= 0;

1587

1588

if (vm.count("execute"))

1589

{

1590

status.setBatch(1);

1591

status.setAddToHistory(1);

1592

if (status.getLineBuff() == NULL)

1593

status.setLineBuff(opt_max_input_line,NULL);

1594

if (status.getLineBuff() == NULL)

1595

{

1596

exit(1);

1597

}

1598

status.getLineBuff()->addString(vm["execute"].as<string>().c_str());

1599

}

1600

1601

if (one_database)

1602

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

1620

if (vm.count("port"))

1621

{

1622

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

1623

1624

/* If the port number is > 65535 it is not a valid port

1625

This also helps with potential data loss casting unsigned long to a

1626

uint32_t. */

1627

if (opt_drizzle_port > 65535)

1628

{

1629

printf(_("Error: Value of %" PRIu32 " supplied for port is not valid.\n"), opt_drizzle_port);

1630

exit(-1);

1631

}

1632

}

1633

1634

if (vm.count("password"))

1635

{

1636

if (!opt_password.empty())

1637

opt_password.erase();

1638

if (current_password == PASSWORD_SENTINEL)

1639

{

1640

opt_password= "";

1641

}

1642

else

1643

{

1644

opt_password= current_password;

1645

tty_password= false;

1646

}

1647

}

1648

else

1649

{

1650

tty_password= true;

1651

}

1652

1653

1654

if (!opt_verbose.empty())

1655

{

1656

verbose= opt_verbose.length();

1657

}

1658

1659

if (vm.count("batch"))

1660

{

1661

status.setBatch(1);

1662

status.setAddToHistory(0);

1663

if (opt_silent < 1)

1664

{

1665

opt_silent= 1;

1666

}

1667

}

1668

if (vm.count("silent"))

1669

{

1670

opt_silent++;

1671

}

1672

1673

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

1674

{

1675

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

1676

drizzle_version(), VERSION,

1677

HOST_VENDOR, HOST_OS, HOST_CPU,

1678

rl_library_version);

1679

if (vm.count("version"))

1680

exit(0);

1681

1682

"This software comes with ABSOLUTELY NO WARRANTY. "

1683

"This is free software,\n"

1684

"and you are welcome to modify and redistribute it "

1685

"under the GPL license\n"));

1686

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

1687

cout << long_options;

1688

exit(0);

1689

}

1690

1691

1692

if (process_options())

1693

{

1212

load_defaults("drizzle",load_default_groups,&argc,&argv);

1213

defaults_argv=argv;

1214

if (get_options(argc, (char **) argv))

1215

{

1216

free_defaults(defaults_argv);

1217

my_end(0);

1694

1218

exit(1);

1695

1219

}

1696

1220

1697

1221

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

1698

if (sql_connect(current_host, current_db, current_user, opt_password,opt_silent))

1222

if (sql_connect(current_host,current_db,current_user,opt_password,

1223

opt_silent))

1699

1224

{

1700

1225

quick= 1; // Avoid history

1701

status.setExitStatus(1);

1226

status.exit_status= 1;

1702

1227

drizzle_end(-1);

1703

1228

}

1704

1229

1706

1231

if (execute_commands(&command_error) != false)

1707

1232

{

1708

1233

/* we've executed a command so exit before we go into readline mode */

1234

free_defaults(defaults_argv);

1235

my_end(0);

1709

1236

exit(command_error);

1710

1237

}

1711

1238

1712

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

1239

if (status.batch && !status.line_buff)

1713

1240

{

1714

status.setLineBuff(opt_max_input_line, stdin);

1715

if (status.getLineBuff() == NULL)

1241

status.line_buff= new(std::nothrow) LineBuffer(opt_max_input_line, stdin);

1242

if (status.line_buff == NULL)

1716

1243

{

1244

free_defaults(defaults_argv);

1245

my_end(0);

1717

1246

exit(1);

1718

1247

}

1719

1248

}

1720

1249

1721

if (!status.getBatch())

1250

if (!status.batch)

1722

1251

ignore_errors=1; // Don't abort monitor

1723

1252

1724

1253

if (opt_sigint_ignore)

1733

1262

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

1734

1263

window_resize(0);

1735

1264

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

1265

1266

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

1267

INFO_INFO,0,0);

1744

1268

1745

1269

glob_buffer= new string();

1746

1270

glob_buffer->reserve(512);

1747

1271

1748

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

1749

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

1272

char * output_buff= (char *)malloc(512);

1273

memset(output_buff, '\0', 512);

1274

1275

sprintf(output_buff,

1276

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

1750

1277

drizzle_con_thread_id(&con),

1751

opt_protocol.c_str(),

1752

1278

server_version_string(&con));

1753

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

1754

1755

1756

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

1757

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

1279

put_info(output_buff, INFO_INFO, 0, 0);

1280

1281

initialize_readline(current_prompt);

1282

if (!status.batch && !quick)

1758

1283

{

1759

1284

/* read-history from file, default ~/.drizzle_history*/

1760

1285

if (getenv("DRIZZLE_HISTFILE"))

1793

1318

1794

1319

put_info(_("Type 'help;' or '\\h' for help. "

1795

1320

"Type '\\c' to clear the buffer.\n"),INFO_INFO,0,0);

1796

status.setExitStatus(read_and_execute(!status.getBatch()));

1321

status.exit_status= read_and_execute(!status.batch);

1797

1322

if (opt_outfile)

1798

1323

end_tee();

1799

1324

drizzle_end(0);

1800

}

1801

1325

1802

catch(exception &err)

1803

{

1804

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

1805

}

1806

1326

return(0); // Keep compiler happy

1807

1327

}

1808

1328

1810

1330

{

1811

1331

drizzle_con_free(&con);

1812

1332

drizzle_free(&drizzle);

1813

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

1333

if (!status.batch && !quick && histfile)

1814

1334

{

1815

1335

/* write-history */

1816

1336

if (verbose)

1817

1337

tee_fprintf(stdout, _("Writing history-file %s\n"),histfile);

1818

1338

if (!write_history(histfile_tmp))

1819

rename(histfile_tmp, histfile);

1339

my_rename(histfile_tmp, histfile, MYF(MY_WME));

1820

1340

}

1821

delete status.getLineBuff();

1822

status.setLineBuff(0);

1341

delete status.line_buff;

1342

status.line_buff= 0;

1823

1343

1824

1344

if (sig >= 0)

1825

1345

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

1826

delete glob_buffer;

1827

delete processed_prompt;

1828

opt_password.erase();

1346

if (glob_buffer)

1347

delete glob_buffer;

1348

if (processed_prompt)

1349

delete processed_prompt;

1350

free(opt_password);

1351

free(opt_drizzle_unix_port);

1829

1352

free(histfile);

1830

1353

free(histfile_tmp);

1831

current_db.erase();

1832

current_host.erase();

1833

current_user.erase();

1354

free(current_db);

1355

free(current_host);

1356

free(current_user);

1834

1357

free(full_username);

1835

1358

free(part_username);

1836

1359

free(default_prompt);

1837

current_prompt.erase();

1838

exit(status.getExitStatus());

1360

free(current_prompt);

1361

free_defaults(defaults_argv);

1362

my_end(my_end_arg);

1363

exit(status.exit_status);

1839

1364

}

1840

1365

1841

1366

1848

1373

void handle_sigint(int sig)

1849

1374

{

1850

1375

char kill_buffer[40];

1851

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

1376

drizzle_con_st kill_drizzle;

1852

1377

drizzle_result_st res;

1853

1378

drizzle_return_t ret;

1854

1379

1857

1382

goto err;

1858

1383

}

1859

1384

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)

1385

if (drizzle_con_add_tcp(&drizzle, &kill_drizzle, current_host,

1386

opt_drizzle_port, current_user, opt_password, NULL,

1387

DRIZZLE_CON_NONE) == NULL)

1863

1388

{

1864

1389

goto err;

1865

1390

}

1868

1393

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

1869

1394

drizzle_con_thread_id(&con));

1870

1395

1871

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

1396

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

1872

1397

drizzle_result_free(&res);

1873

1398

1874

drizzle_con_free(kill_drizzle.get());

1399

drizzle_con_free(&kill_drizzle);

1875

1400

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

1876

1401

1877

1402

interrupted_query= 1;

1893

1418

}

1894

1419

#endif

1895

1420

1896

1897

1898

static int process_options(void)

1421

static struct my_option my_long_options[] =

1422

{

1423

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

1424

0, 0, 0, 0, 0},

1425

{"help", 'I', N_("Synonym for -?"), 0, 0, 0, GET_NO_ARG, NO_ARG, 0,

1426

0, 0, 0, 0, 0},

1427

{"auto-rehash", OPT_AUTO_REHASH,

1428

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

1429

(char**) &opt_rehash, (char**) &opt_rehash, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0,

1430

0, 0},

1431

{"no-auto-rehash", 'A',

1432

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

1433

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

1434

{"auto-vertical-output", OPT_AUTO_VERTICAL_OUTPUT,

1435

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

1436

(char**) &auto_vertical_output, (char**) &auto_vertical_output, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1437

{"batch", 'B',

1438

N_("Don't use history file. Disable interactive behavior. (Enables --silent)"), 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1439

{"column-type-info", OPT_COLUMN_TYPES, N_("Display column type information."),

1440

(char**) &column_types_flag, (char**) &column_types_flag,

1441

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

1442

{"comments", 'c', N_("Preserve comments. Send comments to the server. The default is --skip-comments (discard comments), enable with --comments"),

1443

(char**) &preserve_comments, (char**) &preserve_comments,

1444

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

1445

{"compress", 'C', N_("Use compression in server/client protocol."),

1446

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

1447

0, 0, 0},

1448

{"debug-check", OPT_DEBUG_CHECK, N_("Check memory and open file usage at exit ."),

1449

(char**) &debug_check_flag, (char**) &debug_check_flag, 0,

1450

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

1451

{"debug-info", 'T', N_("Print some debug info at exit."), (char**) &debug_info_flag,

1452

(char**) &debug_info_flag, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1453

{"database", 'D', N_("Database to use."), (char**) &current_db,

1454

(char**) &current_db, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1455

{"default-character-set", OPT_DEFAULT_CHARSET,

1456

N_("(not used)"), 0,

1457

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

1458

{"delimiter", OPT_DELIMITER, N_("Delimiter to be used."), (char**) &delimiter_str,

1459

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

1460

{"execute", 'e', N_("Execute command and quit. (Disables --force and history file)"), 0,

1461

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

1462

{"vertical", 'E', N_("Print the output of a query (rows) vertically."),

1463

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

1464

0},

1465

{"force", 'f', N_("Continue even if we get an sql error."),

1466

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

1467

0, 0, 0, 0},

1468

{"named-commands", 'G',

1469

1470

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

1471

0, 0},

1472

{"no-named-commands", 'g',

1473

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

1474

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

1475

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

1476

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

1477

{"local-infile", OPT_LOCAL_INFILE, N_("Enable/disable LOAD DATA LOCAL INFILE."),

1478

(char**) &opt_local_infile,

1479

(char**) &opt_local_infile, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},

1480

{"no-beep", 'b', N_("Turn off beep on error."), (char**) &opt_nobeep,

1481

(char**) &opt_nobeep, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1482

{"host", 'h', N_("Connect to host."), (char**) &current_host,

1483

(char**) &current_host, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1484

{"line-numbers", OPT_LINE_NUMBERS, N_("Write line numbers for errors."),

1485

(char**) &line_numbers, (char**) &line_numbers, 0, GET_BOOL,

1486

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

1487

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

1488

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

1489

{"unbuffered", 'n', N_("Flush buffer after each query."), (char**) &unbuffered,

1490

(char**) &unbuffered, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1491

{"column-names", OPT_COLUMN_NAMES, N_("Write column names in results."),

1492

(char**) &column_names, (char**) &column_names, 0, GET_BOOL,

1493

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

1494

{"skip-column-names", 'N',

1495

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

1496

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

1497

{"set-variable", 'O',

1498

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

1499

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

1500

{"sigint-ignore", OPT_SIGINT_IGNORE, N_("Ignore SIGINT (CTRL-C)"),

1501

(char**) &opt_sigint_ignore, (char**) &opt_sigint_ignore, 0, GET_BOOL,

1502

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

1503

{"one-database", 'o',

1504

N_("Only update the default database. This is useful for skipping updates to other database in the update log."),

1505

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

1506

{"pager", OPT_PAGER,

1507

1508

0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

1509

{"no-pager", OPT_NOPAGER,

1510

N_("Disable pager and print to stdout. See interactive help (\\h) also. WARNING: option deprecated; use --disable-pager instead."),

1511

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

1512

{"password", 'P',

1513

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

1514

0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

1515

{"port", 'p', N_("Port number to use for connection or 0 for default to, in order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, ")

1516

N_("built-in default") " (" STRINGIFY_ARG(DRIZZLE_PORT) ").",

1517

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

1518

{"prompt", OPT_PROMPT, N_("Set the drizzle prompt to this value."),

1519

(char**) &current_prompt, (char**) &current_prompt, 0, GET_STR_ALLOC,

1520

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

1521

{"quick", 'q',

1522

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

1523

(char**) &quick, (char**) &quick, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1524

{"raw", 'r', N_("Write fields without conversion. Used with --batch."),

1525

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

1526

0, 0, 0},

1527

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

1528

(char**) &opt_reconnect, (char**) &opt_reconnect, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},

1529

{"shutdown", OPT_SHUTDOWN, N_("Shutdown the server."),

1530

(char**) &opt_shutdown, (char**) &opt_shutdown, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1531

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

1532

0, 0},

1533

{"socket", 'S', N_("Socket file to use for connection."),

1534

(char**) &opt_drizzle_unix_port, (char**) &opt_drizzle_unix_port, 0, GET_STR_ALLOC,

1535

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

1536

{"table", 't', N_("Output in table format."), (char**) &output_tables,

1537

(char**) &output_tables, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1538

{"tee", OPT_TEE,

1539

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

1540

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

1541

{"no-tee", OPT_NOTEE, N_("Disable outfile. See interactive help (\\h) also. WARNING: option deprecated; use --disable-tee instead"), 0, 0, 0, GET_NO_ARG,

1542

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

1543

{"user", 'u', N_("User for login if not current user."), (char**) &current_user,

1544

(char**) &current_user, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1545

{"safe-updates", 'U', N_("Only allow UPDATE and DELETE that uses keys."),

1546

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

1547

0, 0, 0, 0},

1548

{"i-am-a-dummy", 'U', N_("Synonym for option --safe-updates, -U."),

1549

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

1550

0, 0, 0, 0},

1551

{"verbose", 'v', N_("Write more. (-v -v -v gives the table output format)."), 0,

1552

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

1553

{"version", 'V', N_("Output version information and exit."), 0, 0, 0,

1554

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

1555

{"wait", 'w', N_("Wait and retry if connection is down."), 0, 0, 0, GET_NO_ARG,

1556

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

1557

{"connect_timeout", OPT_CONNECT_TIMEOUT,

1558

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

1559

(char**) &opt_connect_timeout,

1560

(char**) &opt_connect_timeout, 0, GET_UINT32, REQUIRED_ARG, 0, 0, 3600*12, 0,

1561

0, 0},

1562

{"max_input_line", OPT_MAX_INPUT_LINE,

1563

N_("Max length of input line"),

1564

(char**) &opt_max_input_line, (char**) &opt_max_input_line, 0,

1565

GET_UINT32, REQUIRED_ARG, 16 *1024L*1024L, 4096,

1566

(int64_t) 2*1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},

1567

{"select_limit", OPT_SELECT_LIMIT,

1568

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

1569

(char**) &select_limit,

1570

(char**) &select_limit, 0, GET_UINT32, REQUIRED_ARG, 1000L, 1, ULONG_MAX,

1571

0, 1, 0},

1572

{"max_join_size", OPT_MAX_JOIN_SIZE,

1573

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

1574

(char**) &max_join_size,

1575

(char**) &max_join_size, 0, GET_UINT32, REQUIRED_ARG, 1000000L, 1, ULONG_MAX,

1576

0, 1, 0},

1577

{"secure-auth", OPT_SECURE_AUTH, N_("Refuse client connecting to server if it uses old (pre-4.1.1) protocol"), (char**) &opt_secure_auth,

1578

(char**) &opt_secure_auth, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1579

{"show-warnings", OPT_SHOW_WARNINGS, N_("Show warnings after every statement."),

1580

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

1581

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

1582

{"show-progress-size", OPT_SHOW_PROGRESS_SIZE, N_("Number of lines before each import progress report."),

1583

(char**) &show_progress_size, (char**) &show_progress_size, 0, GET_UINT32, REQUIRED_ARG,

1584

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

1585

{"ping", OPT_PING, N_("Ping the server to check if it's alive."),

1586

(char**) &opt_ping, (char**) &opt_ping, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1587

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

1588

};

1589

1590

1591

static void usage(int version)

1592

{

1593

const char* readline= "readline";

1594

1595

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

1596

my_progname, VER.c_str(), drizzle_version(),

1597

HOST_VENDOR, HOST_OS, HOST_CPU,

1598

readline, rl_library_version);

1599

1600

if (version)

1601

return;

1602

1603

"This software comes with ABSOLUTELY NO WARRANTY. "

1604

"This is free software,\n"

1605

"and you are welcome to modify and redistribute it "

1606

"under the GPL license\n"));

1607

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

1608

my_print_help(my_long_options);

1609

print_defaults("drizzle", load_default_groups);

1610

my_print_variables(my_long_options);

1611

}

1612

1613

1614

extern "C" bool

1615

get_one_option(int optid, const struct my_option *, char *argument)

1616

{

1617

char *endchar= NULL;

1618

uint64_t temp_drizzle_port= 0;

1619

1620

switch(optid) {

1621

case OPT_DEFAULT_CHARSET:

1622

default_charset_used= 1;

1623

break;

1624

case OPT_DELIMITER:

1625

if (argument == disabled_my_option)

1626

{

1627

strcpy(delimiter, DEFAULT_DELIMITER);

1628

}

1629

else

1630

{

1631

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

1632

if (!strstr(argument, "\\"))

1633

{

1634

strncpy(delimiter, argument, sizeof(delimiter) - 1);

1635

}

1636

else

1637

{

1638

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

1639

INFO_ERROR,0,0);

1640

return false;

1641

}

1642

}

1643

delimiter_length= (uint32_t)strlen(delimiter);

1644

delimiter_str= delimiter;

1645

break;

1646

case OPT_TEE:

1647

if (argument == disabled_my_option)

1648

{

1649

if (opt_outfile)

1650

end_tee();

1651

}

1652

else

1653

init_tee(argument);

1654

break;

1655

case OPT_NOTEE:

1656

printf(_("WARNING: option deprecated; use --disable-tee instead.\n"));

1657

if (opt_outfile)

1658

end_tee();

1659

break;

1660

case OPT_PAGER:

1661

if (argument == disabled_my_option)

1662

opt_nopager= 1;

1663

else

1664

{

1665

opt_nopager= 0;

1666

if (argument && strlen(argument))

1667

{

1668

default_pager_set= 1;

1669

strncpy(pager, argument, sizeof(pager) - 1);

1670

strcpy(default_pager, pager);

1671

}

1672

else if (default_pager_set)

1673

strcpy(pager, default_pager);

1674

else

1675

opt_nopager= 1;

1676

}

1677

break;

1678

case OPT_NOPAGER:

1679

printf(_("WARNING: option deprecated; use --disable-pager instead.\n"));

1680

opt_nopager= 1;

1681

break;

1682

case OPT_SERVER_ARG:

1683

printf(_("WARNING: --server-arg option not supported in this configuration.\n"));

1684

break;

1685

case 'A':

1686

opt_rehash= 0;

1687

break;

1688

case 'N':

1689

column_names= 0;

1690

break;

1691

case 'e':

1692

status.batch= 1;

1693

status.add_to_history= 0;

1694

if (status.line_buff == NULL)

1695

status.line_buff= new(std::nothrow) LineBuffer(opt_max_input_line,NULL);

1696

if (status.line_buff == NULL)

1697

{

1698

my_end(0);

1699

exit(1);

1700

}

1701

status.line_buff->addString(argument);

1702

break;

1703

case 'o':

1704

if (argument == disabled_my_option)

1705

one_database= 0;

1706

else

1707

one_database= skip_updates= 1;

1708

break;

1709

case 'p':

1710

temp_drizzle_port= (uint64_t) strtoul(argument, &endchar, 10);

1711

/* if there is an alpha character this is not a valid port */

1712

if (strlen(endchar) != 0)

1713

{

1714

put_info(_("Non-integer value supplied for port. If you are trying to enter a password please use --password instead."), INFO_ERROR, 0, 0);

1715

return false;

1716

}

1717

/* If the port number is > 65535 it is not a valid port

1718

This also helps with potential data loss casting unsigned long to a

1719

uint32_t. */

1720

if ((temp_drizzle_port == 0) || (temp_drizzle_port > 65535))

1721

{

1722

put_info(_("Value supplied for port is not valid."), INFO_ERROR, 0, 0);

1723

return false;

1724

}

1725

else

1726

{

1727

opt_drizzle_port= (uint32_t) temp_drizzle_port;

1728

}

1729

break;

1730

case 'P':

1731

/* Don't require password */

1732

if (argument == disabled_my_option)

1733

{

1734

argument= (char*) "";

1735

}

1736

if (argument)

1737

{

1738

char *start= argument;

1739

free(opt_password);

1740

opt_password= strdup(argument);

1741

while (*argument)

1742

{

1743

/* Overwriting password with 'x' */

1744

*argument++= 'x';

1745

}

1746

if (*start)

1747

{

1748

start[1]= 0;

1749

}

1750

tty_password= 0;

1751

}

1752

else

1753

{

1754

tty_password= 1;

1755

}

1756

break;

1757

case 's':

1758

if (argument == disabled_my_option)

1759

opt_silent= 0;

1760

else

1761

opt_silent++;

1762

break;

1763

case 'v':

1764

if (argument == disabled_my_option)

1765

verbose= 0;

1766

else

1767

verbose++;

1768

break;

1769

case 'B':

1770

status.batch= 1;

1771

status.add_to_history= 0;

1772

set_if_bigger(opt_silent,1); // more silent

1773

break;

1774

case 'V':

1775

usage(1);

1776

exit(0);

1777

case 'I':

1778

case '?':

1779

usage(0);

1780

exit(0);

1781

}

1782

return 0;

1783

}

1784

1785

1786

static int get_options(int argc, char **argv)

1899

1787

{

1900

1788

char *tmp, *pagpoint;

1901

1789

int ho_error;

1902

1790

1903

1791

tmp= (char *) getenv("DRIZZLE_HOST");

1904

1792

if (tmp)

1905

current_host.assign(tmp);

1793

current_host= strdup(tmp);

1906

1794

1907

1795

pagpoint= getenv("PAGER");

1908

1796

if (!((char*) (pagpoint)))

1909

1797

{

1910

pager.assign("stdout");

1798

strcpy(pager, "stdout");

1911

1799

opt_nopager= 1;

1912

1800

}

1913

1801

else

1914

{

1915

pager.assign(pagpoint);

1916

}

1917

default_pager.assign(pager);

1918

1919

1920

1921

if (status.getBatch()) /* disable pager and outfile in this case */

1922

{

1923

default_pager.assign("stdout");

1924

pager.assign("stdout");

1802

strcpy(pager, pagpoint);

1803

strcpy(default_pager, pager);

1804

1805

if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))

1806

exit(ho_error);

1807

1808

if (status.batch) /* disable pager and outfile in this case */

1809

{

1810

strcpy(default_pager, "stdout");

1811

strcpy(pager, "stdout");

1925

1812

opt_nopager= 1;

1926

1813

default_pager_set= 0;

1927

1814

opt_outfile= 0;

1929

1816

connect_flag= DRIZZLE_CAPABILITIES_NONE; /* Not in interactive mode */

1930

1817

}

1931

1818

1819

if (argc > 1)

1820

{

1821

usage(0);

1822

exit(1);

1823

}

1824

if (argc == 1)

1825

{

1826

skip_updates= 0;

1827

free(current_db);

1828

current_db= strdup(*argv);

1829

}

1932

1830

if (tty_password)

1933

1831

opt_password= client_get_tty_password(NULL);

1832

if (debug_info_flag)

1833

my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;

1834

if (debug_check_flag)

1835

my_end_arg= MY_CHECK_ERROR;

1934

1836

return(0);

1935

1837

}

1936

1838

1940

1842

char in_string=0;

1941

1843

uint32_t line_number=0;

1942

1844

bool ml_comment= 0;

1943

Commands *com;

1944

status.setExitStatus(1);

1845

COMMANDS *com;

1846

status.exit_status=1;

1945

1847

1946

1848

for (;;)

1947

1849

{

1948

1850

if (!interactive)

1949

1851

{

1950

if (status.getLineBuff())

1951

line= status.getLineBuff()->readline();

1852

if (status.line_buff)

1853

line= status.line_buff->readline();

1952

1854

else

1953

1855

line= 0;

1954

1856

1959

1861

fprintf(stderr, _("Processing line: %"PRIu32"\n"), line_number);

1960

1862

}

1961

1863

if (!glob_buffer->empty())

1962

status.setQueryStartLine(line_number);

1864

status.query_start_line= line_number;

1963

1865

}

1964

1866

else

1965

1867

{

1966

string prompt(ml_comment

1967

? " /*> "

1968

: glob_buffer->empty()

1969

? construct_prompt()

1970

: not in_string

1971

? " -> "

1972

: in_string == '\''

1973

? " '> "

1974

: in_string == '`'

1975

? " `> "

1976

: " \"> ");

1868

const char *prompt= (const char*) (ml_comment ? " /*> " :

1869

(glob_buffer->empty())

1870

? construct_prompt()

1871

: !in_string ? " -> " :

1872

in_string == '\'' ?

1873

" '> " : (in_string == '`' ?

1874

" `> " :

1875

" \"> "));

1977

1876

if (opt_outfile && glob_buffer->empty())

1978

1877

fflush(OUTFILE);

1979

1878

1980

1879

if (opt_outfile)

1981

fputs(prompt.c_str(), OUTFILE);

1982

line= readline(prompt.c_str());

1880

fputs(prompt, OUTFILE);

1881

line= readline(prompt);

1983

1882

1984

1883

When Ctrl+d or Ctrl+z is pressed, the line may be NULL on some OS

1985

1884

which may cause coredump.

1990

1889

// End of file

1991

1890

if (!line)

1992

1891

{

1993

status.setExitStatus(0);

1892

status.exit_status=0;

1994

1893

break;

1995

1894

}

1996

1895

2006

1905

// If buffer was emptied

2007

1906

if (glob_buffer->empty())

2008

1907

in_string=0;

2009

if (interactive && status.getAddToHistory() && not_in_history(line))

1908

if (interactive && status.add_to_history && not_in_history(line))

2010

1909

add_history(line);

2011

1910

continue;

2012

1911

}

2015

1914

}

2016

1915

/* if in batch mode, send last query even if it doesn't end with \g or go */

2017

1916

2018

if (!interactive && !status.getExitStatus())

1917

if (!interactive && !status.exit_status)

2019

1918

{

2020

1919

remove_cntrl(glob_buffer);

2021

1920

if (!glob_buffer->empty())

2022

1921

{

2023

status.setExitStatus(1);

1922

status.exit_status=1;

2024

1923

if (com_go(glob_buffer,line) <= 0)

2025

status.setExitStatus(0);

1924

status.exit_status=0;

2026

1925

}

2027

1926

}

2028

1927

2029

return status.getExitStatus();

1928

return status.exit_status;

2030

1929

}

2031

1930

2032

1931

2033

static Commands *find_command(const char *name,char cmd_char)

1932

static COMMANDS *find_command(const char *name,char cmd_char)

2034

1933

{

2035

1934

uint32_t len;

2036

1935

const char *end;

2042

1941

}

2043

1942

else

2044

1943

{

2045

while (isspace(*name))

1944

while (my_isspace(charset_info,*name))

2046

1945

name++;

2047

1946

2048

1947

If there is an \\g in the row or if the row has a delimiter but

2051

1950

2052

1951

if (strstr(name, "\\g") || (strstr(name, delimiter) &&

2053

1952

!(strlen(name) >= 9 &&

2054

!strcmp(name, "delimiter"))))

2055

return(NULL);

1953

!my_strnncoll(charset_info,

1954

(unsigned char*) name, 9,

1955

(const unsigned char*) "delimiter",

1956

9))))

1957

return((COMMANDS *) 0);

2056

1958

if ((end=strcont(name," \t")))

2057

1959

{

2058

1960

len=(uint32_t) (end - name);

2059

while (isspace(*end))

1961

while (my_isspace(charset_info,*end))

2060

1962

end++;

2061

1963

if (!*end)

2062

1964

end=0; // no arguments to function

2065

1967

len=(uint32_t) strlen(name);

2066

1968

}

2067

1969

2068

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

1970

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

2069

1971

{

2070

1972

if (commands[i].func &&

2071

((name && !strncmp(name, commands[i].getName(), len)

2072

&& !commands[i].getName()[len] && (!end || (end && commands[i].getTakesParams()))) || (!name && commands[i].getCmdChar() == cmd_char)))

1973

((name && !my_strnncoll(charset_info,(const unsigned char*)name,len, (const unsigned char*)commands[i].name,len) && !commands[i].name[len] && (!end || (end && commands[i].takes_params))) || (!name && commands[i].cmd_char == cmd_char)))

2073

1974

{

2074

1975

return(&commands[i]);

2075

1976

}

2076

1977

}

2077

return(NULL);

1978

return((COMMANDS *) 0);

2078

1979

}

2079

1980

2080

1981

2083

1984

{

2084

1985

unsigned char inchar;

2085

1986

char *pos, *out;

2086

Commands *com;

1987

COMMANDS *com;

2087

1988

bool need_space= 0;

2088

1989

bool ss_comment= 0;

2089

1990

2090

1991

2091

1992

if (!line[0] && (buffer->empty()))

2092

1993

return(0);

2093

if (status.getAddToHistory() && line[0] && not_in_history(line))

1994

if (status.add_to_history && line[0] && not_in_history(line))

2094

1995

add_history(line);

2095

1996

char *end_of_line=line+(uint32_t) strlen(line);

2096

1997

2099

2000

if (!preserve_comments)

2100

2001

{

2101

2002

// Skip spaces at the beggining of a statement

2102

if (isspace(inchar) && (out == line) &&

2003

if (my_isspace(charset_info,inchar) && (out == line) &&

2103

2004

(buffer->empty()))

2104

2005

continue;

2105

2006

}

2106

2007

2107

2008

// Accept multi-byte characters as-is

2108

if (not drizzled::utf8::is_single(*pos))

2009

int length;

2010

if (use_mb(charset_info) &&

2011

(length= my_ismbchar(charset_info, pos, end_of_line)))

2109

2012

{

2110

int length;

2111

if ((length= drizzled::utf8::sequence_length(*pos)))

2013

if (!*ml_comment || preserve_comments)

2112

2014

{

2113

if (!*ml_comment || preserve_comments)

2114

{

2115

while (length--)

2116

*out++ = *pos++;

2117

pos--;

2118

}

2119

else

2120

pos+= length - 1;

2121

continue;

2015

while (length--)

2016

*out++ = *pos++;

2017

pos--;

2122

2018

}

2019

else

2020

pos+= length - 1;

2021

continue;

2123

2022

}

2124

2023

if (!*ml_comment && inchar == '\\' &&

2125

2024

!(*in_string && (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES)))

2145

2044

2146

2045

if ((*com->func)(buffer,pos-1) > 0)

2147

2046

return(1); // Quit

2148

if (com->getTakesParams())

2047

if (com->takes_params)

2149

2048

{

2150

2049

if (ss_comment)

2151

2050

{

2188

2087

}

2189

2088

else if (!*ml_comment && !*in_string &&

2190

2089

(end_of_line - pos) >= 10 &&

2191

!strncmp(pos, "delimiter ", 10))

2090

!my_strnncoll(charset_info, (unsigned char*) pos, 10,

2091

(const unsigned char*) "delimiter ", 10))

2192

2092

{

2193

2093

// Flush previously accepted characters

2194

2094

if (out != line)

2225

2125

2226

2126

if (preserve_comments)

2227

2127

{

2228

while (isspace(*pos))

2128

while (my_isspace(charset_info, *pos))

2229

2129

*out++= *pos++;

2230

2130

}

2231

2131

// Flush previously accepted characters

2238

2138

if (preserve_comments && ((*pos == '#') ||

2239

2139

((*pos == '-') &&

2240

2140

(pos[1] == '-') &&

2241

isspace(pos[2]))))

2141

my_isspace(charset_info, pos[2]))))

2242

2142

{

2243

2143

// Add trailing single line comments to this statement

2244

2144

buffer->append(pos);

2265

2165

&& (inchar == '#'

2266

2166

|| (inchar == '-'

2267

2167

&& pos[1] == '-'

2268

&& isspace(pos[2])))))

2168

&& my_isspace(charset_info,pos[2])))))

2269

2169

{

2270

2170

// Flush previously accepted characters

2271

2171

if (out != line)

2331

2231

*in_string= (char) inchar;

2332

2232

if (!*ml_comment || preserve_comments)

2333

2233

{

2334

if (need_space && !isspace((char)inchar))

2234

if (need_space && !my_isspace(charset_info, (char)inchar))

2335

2235

*out++= ' ';

2336

2236

need_space= 0;

2337

2237

*out++= (char) inchar;

2342

2242

{

2343

2243

*out++='\n';

2344

2244

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

2245

if ((!*ml_comment || preserve_comments))

2352

2246

buffer->append(line, length);

2353

2247

}

2452

2346

2453

2347

/* Tell the completer that we want a crack first. */

2454

2348

rl_attempted_completion_function= (rl_completion_func_t*)&mysql_completion;

2455

rl_completion_entry_function= (drizzle_compentry_func_t*)&no_completion;

2349

rl_completion_entry_function= (rl_compentry_func_t*)&no_completion;

2456

2350

}

2457

2351

2458

2352

2464

2358

2465

2359

char **mysql_completion (const char *text, int, int)

2466

2360

{

2467

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

2361

if (!status.batch && !quick)

2468

2362

return rl_completion_matches(text, new_command_generator);

2469

2363

else

2470

2364

return (char**) 0;

2533

2427

2534

2428

static void build_completion_hash(bool rehash, bool write_info)

2535

2429

{

2536

Commands *cmd=commands;

2430

COMMANDS *cmd=commands;

2537

2431

drizzle_return_t ret;

2538

2432

drizzle_result_st databases,tables,fields;

2539

2433

drizzle_row_t database_row,table_row;

2540

2434

drizzle_column_st *sql_field;

2541

2435

string tmp_str, tmp_str_lower;

2542

2436

2543

if (status.getBatch() || quick || current_db.empty())

2437

if (status.batch || quick || !current_db)

2544

2438

return; // We don't need completion in batches

2545

2439

if (!rehash)

2546

2440

return;

2548

2442

completion_map.clear();

2549

2443

2550

2444

/* hash this file's known subset of SQL commands */

2551

while (cmd->getName()) {

2552

tmp_str= cmd->getName();

2445

while (cmd->name) {

2446

tmp_str= cmd->name;

2553

2447

tmp_str_lower= lower_string(tmp_str);

2554

2448

completion_map[tmp_str_lower]= tmp_str;

2555

2449

cmd++;

2593

2487

{

2594

2488

if (drizzle_result_row_count(&tables) > 0 && !opt_silent && write_info)

2595

2489

{

2596

tee_fprintf(stdout,

2597

_("Reading table information for completion of "

2598

"table and column names\n"

2599

"You can turn off this feature to get a quicker "

2600

"startup with -A\n\n"));

2490

tee_fprintf(stdout, _("\

2491

Reading table information for completion of table and column names\n \

2492

You can turn off this feature to get a quicker startup with -A\n\n"));

2601

2493

}

2602

2494

while ((table_row=drizzle_row_next(&tables)))

2603

2495

{

2623

2515

{

2624

2516

string query;

2625

2517

2626

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

2518

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

2627

2519

query.append(table_row[0]);

2628

query.append("`");

2520

query.append("'");

2629

2521

2630

2522

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

2631

2523

&ret) != NULL)

2655

2547

2656

2548

/* for gnu readline */

2657

2549

2550

#ifndef HAVE_INDEX

2551

extern "C" {

2552

extern char *index(const char *,int c),*rindex(const char *,int);

2553

2554

char *index(const char *s,int c)

2555

{

2556

for (;;)

2557

{

2558

if (*s == (char) c) return (char*) s;

2559

if (!*s++) return NULL;

2560

}

2561

}

2562

2563

char *rindex(const char *s,int c)

2564

{

2565

2566

2567

t = NULL;

2568

do if (*s == (char) c) t = (char*) s; while (*s++);

2569

return (char*) t;

2570

}

2571

}

2572

#endif

2573

2658

2574

2659

2575

static int reconnect(void)

2660

2576

{

2675

2591

drizzle_return_t ret;

2676

2592

drizzle_result_st res;

2677

2593

2678

current_db.erase();

2679

current_db= "";

2594

free(current_db);

2595

current_db= NULL;

2680

2596

/* In case of error below current_db will be NULL */

2681

2597

if (drizzle_query_str(&con, &res, "SELECT DATABASE()", &ret) != NULL)

2682

2598

{

2685

2601

{

2686

2602

drizzle_row_t row= drizzle_row_next(&res);

2687

2603

if (row[0])

2688

current_db.assign(row[0]);

2604

current_db= strdup(row[0]);

2689

2605

drizzle_result_free(&res);

2690

2606

}

2691

2607

}

2695

2611

The different commands

2696

2612

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

2697

2613

2698

int drizzleclient_real_query_for_lazy(const char *buf, size_t length,

2614

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2699

2615

drizzle_result_st *result,

2700

2616

uint32_t *error_code)

2701

2617

{

2734

2650

return 0;

2735

2651

2736

2652

if (drizzle_con_error(&con)[0])

2737

{

2738

int ret= put_error(&con, result);

2739

drizzle_result_free(result);

2740

return ret;

2741

}

2653

return put_error(&con, result);

2742

2654

return 0;

2743

2655

}

2744

2656

2747

2659

{

2748

2660

2749

2661

char buff[32], *end;

2750

std::vector<char> output_buff;

2751

output_buff.resize(512);

2752

2662

2753

2663

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

2754

2664

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

}

2761

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

2762

{

2763

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

2764

end+= strlen(commands[i].getName());

2765

for (j= (int)strlen(commands[i].getName()); j < 10; j++)

2665

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

2666

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

2667

{

2668

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

2669

end+= strlen(commands[i].name);

2670

for (j= (int)strlen(commands[i].name); j < 10; j++)

2766

2671

end= strcpy(end, " ")+1;

2767

2672

if (commands[i].func)

2768

2673

tee_fprintf(stdout, "%s(\\%c) %s\n", buff,

2769

commands[i].getCmdChar(), _(commands[i].getDoc()));

2674

commands[i].cmd_char, _(commands[i].doc));

2770

2675

}

2771

2676

tee_fprintf(stdout, "\n");

2772

2677

buffer->clear();

2777

2682

static int

2778

2683

com_clear(string *buffer, const char *)

2779

2684

{

2780

if (status.getAddToHistory())

2685

if (status.add_to_history)

2781

2686

fix_history(buffer);

2782

2687

buffer->clear();

2783

2688

return 0;

2810

2715

if (buffer->empty())

2811

2716

{

2812

2717

// Ignore empty quries

2813

if (status.getBatch())

2718

if (status.batch)

2814

2719

return 0;

2815

2720

return put_info(_("No query specified\n"),INFO_ERROR,0,0);

2816

2721

2835

2740

executing_query= 1;

2836

2741

error= drizzleclient_real_query_for_lazy(buffer->c_str(),buffer->length(),&result, &error_code);

2837

2742

2838

if (status.getAddToHistory())

2743

if (status.add_to_history)

2839

2744

{

2840

2745

buffer->append(vertical ? "\\G" : delimiter);

2841

2746

/* Append final command onto history */

2956

2861

if (show_warnings == 1 && (warnings >= 1 || error))

2957

2862

print_warnings(error_code);

2958

2863

2959

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

2864

if (!error && !status.batch &&

2960

2865

drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)

2961

2866

{

2962

2867

get_current_db();

2971

2876

{

2972

2877

if (!opt_nopager)

2973

2878

{

2974

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

2879

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

2975

2880

{

2976

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

2881

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

2977

2882

PAGER= stdout;

2978

2883

}

2979

2884

}

2995

2900

end_tee();

2996

2901

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

2997

2902

{

2998

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

2903

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

2999

2904

return;

3000

2905

}

3001

2906

OUTFILE = new_outfile;

3002

outfile.assign(file_name);

3003

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

2907

strncpy(outfile, file_name, FN_REFLEN-1);

2908

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

3004

2909

opt_outfile= 1;

3005

2910

3006

2911

return;

3041

2946

case DRIZZLE_COLUMN_TYPE_LONGLONG: return "LONGLONG";

3042

2947

case DRIZZLE_COLUMN_TYPE_NULL: return "NULL";

3043

2948

case DRIZZLE_COLUMN_TYPE_TIMESTAMP: return "TIMESTAMP";

2949

case DRIZZLE_COLUMN_TYPE_TINY: return "TINY";

2950

case DRIZZLE_COLUMN_TYPE_VIRTUAL: return "VIRTUAL";

3044

2951

default: return "?-unknown-?";

3045

2952

}

3046

2953

}

3084

2991

3085

2992

while ((field = drizzle_column_next(result)))

3086

2993

{

3087

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

2994

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

3088

2995

"Catalog: `%s`\n"

3089

2996

"Database: `%s`\n"

3090

2997

"Table: `%s`\n"

3091

2998

"Org_table: `%s`\n"

3092

"Type: UTF-8\n"

2999

"Type: %s\n"

3093

3000

"Collation: %s (%u)\n"

3094

3001

"Length: %lu\n"

3095

3002

"Max_length: %lu\n"

3096

3003

"Decimals: %u\n"

3097

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

3004

"Flags: %s\n\n",

3098

3005

++i,

3099

3006

drizzle_column_name(field), drizzle_column_catalog(field),

3100

3007

drizzle_column_db(field), drizzle_column_table(field),

3101

3008

drizzle_column_orig_table(field),

3102

3009

fieldtype2str(drizzle_column_type(field)),

3010

get_charset_name(drizzle_column_charset(field)),

3103

3011

drizzle_column_charset(field), drizzle_column_size(field),

3104

3012

drizzle_column_max_size(field), drizzle_column_decimals(field),

3105

3013

fieldflags2str(drizzle_column_flags(field)));

3107

3015

tee_puts("", PAGER);

3108

3016

}

3109

3017

3018

3110

3019

static void

3111

3020

print_table_data(drizzle_result_st *result)

3112

3021

{

3113

3022

drizzle_row_t cur;

3114

3023

drizzle_return_t ret;

3115

3024

drizzle_column_st *field;

3116

std::vector<bool> num_flag;

3025

bool *num_flag;

3117

3026

string separator;

3118

3027

3119

3028

separator.reserve(256);

3120

3029

3121

num_flag.resize(drizzle_result_column_count(result));

3030

num_flag=(bool*) malloc(sizeof(bool)*drizzle_result_column_count(result));

3122

3031

if (column_types_flag)

3123

3032

{

3124

3033

print_field_types(result);

3138

3047

/* Check if the max_byte value is really the maximum in terms

3139

3048

of visual length since multibyte characters can affect the

3140

3049

length of the separator. */

3141

length= drizzled::utf8::char_length(drizzle_column_name(field));

3050

length= charset_info->cset->numcells(charset_info,

3051

drizzle_column_name(field),

3052

drizzle_column_name(field) +

3053

name_length);

3142

3054

3143

3055

if (name_length == drizzle_column_max_size(field))

3144

3056

{

3176

3088

for (uint32_t off=0; (field = drizzle_column_next(result)) ; off++)

3177

3089

{

3178

3090

uint32_t name_length= (uint32_t) strlen(drizzle_column_name(field));

3179

uint32_t numcells= drizzled::utf8::char_length(drizzle_column_name(field));

3091

uint32_t numcells= charset_info->cset->numcells(charset_info,

3092

drizzle_column_name(field),

3093

drizzle_column_name(field) +

3094

name_length);

3180

3095

uint32_t display_length= drizzle_column_max_size(field) + name_length -

3181

3096

numcells;

3182

3097

tee_fprintf(PAGER, " %-*s |",(int) min(display_length,

3239

3154

We need to find how much screen real-estate we will occupy to know how

3240

3155

many extra padding-characters we should send with the printing function.

3241

3156

3242

visible_length= drizzled::utf8::char_length(buffer);

3157

visible_length= charset_info->cset->numcells(charset_info, buffer, buffer + data_length);

3243

3158

extra_padding= data_length - visible_length;

3244

3159

3245

3160

if (field_max_length > MAX_COLUMN_LENGTH)

3259

3174

drizzle_row_free(result, cur);

3260

3175

}

3261

3176

tee_puts(separator.c_str(), PAGER);

3177

free(num_flag);

3262

3178

}

3263

3179

3264

3180

/**

3406

3322

drizzle_row_t cur;

3407

3323

uint64_t num_rows;

3408

3324

uint32_t new_code= 0;

3409

FILE *out;

3410

3325

3411

3326

/* Get the warnings */

3412

3327

query= "show warnings";

3432

3347

}

3433

3348

3434

3349

/* Print the warnings */

3435

if (status.getBatch())

3436

{

3437

out= stderr;

3438

}

3439

else

3440

{

3441

init_pager();

3442

out= PAGER;

3443

}

3350

init_pager();

3444

3351

3445

3352

{

3446

tee_fprintf(out, "%s (Code %s): %s\n", cur[0], cur[1], cur[2]);

3353

tee_fprintf(PAGER, "%s (Code %s): %s\n", cur[0], cur[1], cur[2]);

3447

3354

} while ((cur= drizzle_row_next(&result)));

3448

3449

if (not status.getBatch())

3450

end_pager();

3355

end_pager();

3451

3356

3452

3357

end:

3453

3358

drizzle_result_free(&result);

3466

3371

else for (const char *end=pos+length ; pos != end ; pos++)

3467

3372

{

3468

3373

int l;

3469

if ((l = drizzled::utf8::sequence_length(*pos)))

3374

if (use_mb(charset_info) &&

3375

(l = my_ismbchar(charset_info, pos, end)))

3470

3376

{

3471

3377

while (l--)

3472

3378

tee_putc(*pos++, PAGER);

3543

3449

char file_name[FN_REFLEN], *end;

3544

3450

const char *param;

3545

3451

3546

if (status.getBatch())

3452

if (status.batch)

3547

3453

return 0;

3548

while (isspace(*line))

3454

while (my_isspace(charset_info,*line))

3549

3455

line++;

3550

if (!(param =strchr(line, ' '))) // if outfile wasn't given, use the default

3456

if (!(param = strchr(line, ' '))) // if outfile wasn't given, use the default

3551

3457

{

3552

if (outfile.empty())

3458

if (!strlen(outfile))

3553

3459

{

3554

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

3460

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

3555

3461

return 0;

3556

3462

}

3557

3463

else if (opt_outfile)

3558

3464

{

3559

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

3465

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

3560

3466

return 0;

3561

3467

}

3562

3468

else

3563

param= outfile.c_str(); //resume using the old outfile

3469

param = outfile; //resume using the old outfile

3564

3470

}

3565

3471

3566

/* @TODO: Replace this with string methods */

3567

3472

/* eliminate the spaces before the parameters */

3568

while (isspace(*param))

3473

while (my_isspace(charset_info,*param))

3569

3474

param++;

3570

3475

strncpy(file_name, param, sizeof(file_name) - 1);

3571

3476

end= file_name + strlen(file_name);

3572

3477

/* remove end space from command line */

3573

while (end > file_name && (isspace(end[-1]) ||

3574

iscntrl(end[-1])))

3478

while (end > file_name && (my_isspace(charset_info,end[-1]) ||

3479

my_iscntrl(charset_info,end[-1])))

3575

3480

end--;

3576

3481

end[0]= 0;

3577

3482

if (end == file_name)

3578

3483

{

3579

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

3484

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

3580

3485

return 0;

3581

3486

}

3582

3487

init_tee(file_name);

3589

3494

{

3590

3495

if (opt_outfile)

3591

3496

end_tee();

3592

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

3497

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

3593

3498

return 0;

3594

3499

}

3595

3500

3600

3505

static int

3601

3506

com_pager(string *, const char *line)

3602

3507

{

3508

char pager_name[FN_REFLEN], *end;

3603

3509

const char *param;

3604

3510

3605

if (status.getBatch())

3511

if (status.batch)

3606

3512

return 0;

3607

3513

/* Skip spaces in front of the pager command */

3608

while (isspace(*line))

3514

while (my_isspace(charset_info, *line))

3609

3515

line++;

3610

3516

/* Skip the pager command */

3611

3517

param= strchr(line, ' ');

3612

3518

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

3613

while (param && isspace(*param))

3519

while (param && my_isspace(charset_info, *param))

3614

3520

param++;

3615

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

3521

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

3616

3522

{

3617

3523

if (!default_pager_set)

3618

3524

{

3619

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

3525

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

3620

3526

opt_nopager=1;

3621

pager.assign("stdout");

3527

strcpy(pager, "stdout");

3622

3528

PAGER= stdout;

3623

3529

return 0;

3624

3530

}

3625

pager.assign(default_pager);

3531

strcpy(pager, default_pager);

3626

3532

}

3627

3533

else

3628

3534

{

3629

string pager_name(param);

3630

string::iterator end= pager_name.end();

3631

while (end > pager_name.begin() &&

3632

(isspace(*(end-1)) || iscntrl(*(end-1))))

3633

--end;

3634

pager_name.erase(end, pager_name.end());

3635

pager.assign(pager_name);

3636

default_pager.assign(pager_name);

3535

end= strncpy(pager_name, param, sizeof(pager_name)-1);

3536

end+= strlen(pager_name);

3537

while (end > pager_name && (my_isspace(charset_info,end[-1]) ||

3538

my_iscntrl(charset_info,end[-1])))

3539

end--;

3540

end[0]=0;

3541

strcpy(pager, pager_name);

3542

strcpy(default_pager, pager_name);

3637

3543

}

3638

3544

opt_nopager=0;

3639

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

3545

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

3640

3546

return 0;

3641

3547

}

3642

3548

3644

3550

static int

3645

3551

com_nopager(string *, const char *)

3646

3552

{

3647

pager.assign("stdout");

3553

strcpy(pager, "stdout");

3648

3554

opt_nopager=1;

3649

3555

PAGER= stdout;

3650

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

3556

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

3651

3557

return 0;

3652

3558

}

3653

3559

3657

3563

com_quit(string *, const char *)

3658

3564

{

3659

3565

/* let the screen auto close on a normal shutdown */

3660

status.setExitStatus(0);

3566

status.exit_status=0;

3661

3567

return 1;

3662

3568

}

3663

3569

3705

3611

tmp= get_arg(buff, 0);

3706

3612

if (tmp && *tmp)

3707

3613

{

3708

current_db.erase();

3709

current_db.assign(tmp);

3614

free(current_db);

3615

current_db= strdup(tmp);

3710

3616

tmp= get_arg(buff, 1);

3711

3617

if (tmp)

3712

3618

{

3713

current_host.erase();

3619

free(current_host);

3714

3620

current_host=strdup(tmp);

3715

3621

}

3716

3622

}

3725

3631

}

3726

3632

else

3727

3633

opt_rehash= 0;

3728

error=sql_connect(current_host, current_db, current_user, opt_password,0);

3634

error=sql_connect(current_host,current_db,current_user,opt_password,0);

3729

3635

opt_rehash= save_rehash;

3730

3636

3731

3637

if (connected)

3732

3638

{

3733

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

3639

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

3734

3640

put_info(buff,INFO_INFO,0,0);

3735

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

3736

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

3641

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

3642

current_db ? current_db : "*** NONE ***");

3737

3643

put_info(buff,INFO_INFO,0,0);

3738

3644

}

3739

3645

return error;

3746

3652

const char *param;

3747

3653

LineBuffer *line_buff;

3748

3654

int error;

3749

Status old_status;

3655

STATUS old_status;

3750

3656

FILE *sql_file;

3751

3657

3752

3658

/* Skip space from file name */

3753

while (isspace(*line))

3659

while (my_isspace(charset_info,*line))

3754

3660

line++;

3755

3661

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

3756

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

3662

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

3757

3663

INFO_ERROR, 0,0);

3758

while (isspace(*param))

3664

while (my_isspace(charset_info,*param))

3759

3665

param++;

3760

3666

end= strncpy(source_name,param,sizeof(source_name)-1);

3761

3667

end+= strlen(source_name);

3762

while (end > source_name && (isspace(end[-1]) ||

3763

iscntrl(end[-1])))

3668

while (end > source_name && (my_isspace(charset_info,end[-1]) ||

3669

my_iscntrl(charset_info,end[-1])))

3764

3670

end--;

3765

3671

end[0]=0;

3766

3672

unpack_filename(source_name,source_name);

3767

3673

/* open file name */

3768

3674

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

3769

3675

{

3770

3676

char buff[FN_REFLEN+60];

3771

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

3677

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

3772

3678

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

3773

3679

}

3774

3680

3776

3682

if (line_buff == NULL)

3777

3683

{

3778

3684

fclose(sql_file);

3779

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

3685

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

3780

3686

}

3781

3687

3782

3688

/* Save old status */

3784

3690

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

3785

3691

3786

3692

// Run in batch mode

3787

status.setBatch(old_status.getBatch());

3788

status.setLineBuff(line_buff);

3789

status.setFileName(source_name);

3693

status.batch=old_status.batch;

3694

status.line_buff=line_buff;

3695

status.file_name=source_name;

3790

3696

// Empty command buffer

3791

3697

assert(glob_buffer!=NULL);

3792

3698

glob_buffer->clear();

3794

3700

// Continue as before

3795

3701

status=old_status;

3796

3702

fclose(sql_file);

3797

delete status.getLineBuff();

3798

line_buff=0;

3799

status.setLineBuff(0);

3703

delete status.line_buff;

3704

line_buff= status.line_buff= 0;

3800

3705

return error;

3801

3706

}

3802

3707

3812

3717

3813

3718

if (!tmp || !*tmp)

3814

3719

{

3815

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

3720

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

3816

3721

INFO_ERROR, 0, 0);

3817

3722

return 0;

3818

3723

}

3820

3725

{

3821

3726

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

3822

3727

{

3823

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

3728

put_info("DELIMITER cannot contain a backslash character",

3824

3729

INFO_ERROR, 0, 0);

3825

3730

return 0;

3826

3731

}

3845

3750

tmp= get_arg(buff, 0);

3846

3751

if (!tmp || !*tmp)

3847

3752

{

3848

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

3753

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

3849

3754

return 0;

3850

3755

}

3851

3756

3855

3760

3856

3761

get_current_db();

3857

3762

3858

if (current_db.empty() || strcmp(current_db.c_str(),tmp))

3763

if (!current_db || strcmp(current_db,tmp))

3859

3764

{

3860

3765

if (one_database)

3861

3766

{

3907

3812

else

3908

3813

drizzle_result_free(&result);

3909

3814

}

3910

current_db.erase();

3911

current_db.assign(tmp);

3815

free(current_db);

3816

current_db= strdup(tmp);

3912

3817

if (select_db > 1)

3913

3818

build_completion_hash(opt_rehash, 1);

3914

3819

}

3915

3820

3916

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

3821

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

3917

3822

return 0;

3918

3823

}

3919

3824

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

3825

static int

3959

3826

com_warnings(string *, const char *)

3960

3827

{

3961

3828

show_warnings = 1;

3962

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

3829

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

3963

3830

return 0;

3964

3831

}

3965

3832

3967

3834

com_nowarnings(string *, const char *)

3968

3835

{

3969

3836

show_warnings = 0;

3970

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

3837

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

3971

3838

return 0;

3972

3839

}

3973

3840

3997

3864

else

3998

3865

{

3999

3866

/* skip leading white spaces */

4000

while (isspace(*ptr))

3867

while (my_isspace(charset_info, *ptr))

4001

3868

ptr++;

4002

3869

if (*ptr == '\\') // short command was used

4003

3870

ptr+= 2;

4004

3871

else

4005

while (*ptr &&!isspace(*ptr)) // skip command

3872

while (*ptr &&!my_isspace(charset_info, *ptr)) // skip command

4006

3873

ptr++;

4007

3874

}

4008

3875

if (!*ptr)

4009

3876

return NULL;

4010

while (isspace(*ptr))

3877

while (my_isspace(charset_info, *ptr))

4011

3878

ptr++;

4012

3879

if (*ptr == '\'' || *ptr == '\"' || *ptr == '`')

4013

3880

{

4034

3901

4035

3902

4036

3903

static int

4037

sql_connect(const string &host, const string &database, const string &user, const string &password,

3904

sql_connect(char *host,char *database,char *user,char *password,

4038

3905

uint32_t silent)

4039

3906

{

4040

3907

drizzle_return_t ret;

3908

4041

3909

if (connected)

4042

3910

{

4043

3911

connected= 0;

4045

3913

drizzle_free(&drizzle);

4046

3914

}

4047

3915

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)

3916

if (drizzle_con_add_tcp(&drizzle, &con, host, opt_drizzle_port, user,

3917

password, database, DRIZZLE_CON_NONE) == NULL)

4059

3918

{

4060

3919

(void) put_error(&con, NULL);

4061

3920

(void) fflush(stdout);

4094

3953

return -1; // Retryable

4095

3954

}

4096

3955

connected=1;

4097

3956

/* XXX hmm?

3957

drizzle.reconnect= debug_info_flag; // We want to know if this happens

3958

4098

3959

build_completion_hash(opt_rehash, 1);

4099

3960

return 0;

4100

3961

}

4111

3972

drizzle_return_t ret;

4112

3973

4113

3974

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

4118

3975

usage(1); /* Print version */

4119

3976

if (connected)

4120

3977

{

4121

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

3978

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

4122

3979

4123

3980

Don't remove "limit 1",

4124

3981

it is protection againts SQL_SELECT_LIMIT=0

4130

3987

drizzle_row_t cur=drizzle_row_next(&result);

4131

3988

if (cur)

4132

3989

{

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

3990

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

3991

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

4135

3992

}

4136

3993

drizzle_result_free(&result);

4137

3994

}

4138

3995

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

4139

3996

drizzle_result_free(&result);

4140

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

3997

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

4141

3998

}

4142

3999

else

4143

4000

{

4144

4001

vidattr(A_BOLD);

4145

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

4002

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

4146

4003

vidattr(A_NORMAL);

4147

4004

return 0;

4148

4005

}

4149

4006

if (skip_updates)

4150

4007

{

4151

4008

vidattr(A_BOLD);

4152

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

4009

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

4153

4010

vidattr(A_NORMAL);

4154

4011

}

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

4012

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

4013

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

4014

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

4015

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

4016

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

4017

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

4162

4018

/* XXX need to save this from result

4163

4019

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

4164

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

4020

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

4165

4021

4166

4022

4167

if (drizzle_con_uds(&con))

4168

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

4023

if (strcmp(drizzle_con_uds(&con), ""))

4024

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

4169

4025

else

4170

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

4026

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

4171

4027

4172

4028

if (safe_updates)

4173

4029

{

4174

4030

vidattr(A_BOLD);

4175

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

4031

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

4176

4032

vidattr(A_NORMAL);

4177

tee_fprintf(stdout, _("\

4033

tee_fprintf(stdout, "\

4178

4034

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

4179

4035

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

4180

4036

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

4037

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

4182

4038

select_limit, max_join_size);

4183

4039

}

4184

4040

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

4231

4087

FILE *file= (info_type == INFO_ERROR ? stderr : stdout);

4232

4088

static int inited=0;

4233

4089

4234

if (status.getBatch())

4090

if (status.batch)

4235

4091

{

4236

4092

if (info_type == INFO_ERROR)

4237

4093

{

4238

4094

(void) fflush(file);

4239

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

4095

fprintf(file,"ERROR");

4240

4096

if (error)

4241

4097

{

4242

4098

if (sqlstate)

4244

4100

else

4245

4101

(void) fprintf(file," %d",error);

4246

4102

}

4247

if (status.getQueryStartLine() && line_numbers)

4103

if (status.query_start_line && line_numbers)

4248

4104

{

4249

(void) fprintf(file," at line %"PRIu32,status.getQueryStartLine());

4250

if (status.getFileName())

4251

(void) fprintf(file," in file: '%s'", status.getFileName());

4105

(void) fprintf(file," at line %"PRIu32,status.query_start_line);

4106

if (status.file_name)

4107

(void) fprintf(file," in file: '%s'", status.file_name);

4252

4108

}

4253

4109

(void) fprintf(file,": %s\n",str);

4254

4110

(void) fflush(file);

4279

4135

if (error)

4280

4136

{

4281

4137

if (sqlstate)

4282

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

4138

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

4283

4139

else

4284

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

4140

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

4285

4141

}

4286

4142

else

4287

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

4143

tee_puts("ERROR: ", file);

4288

4144

}

4289

4145

else

4290

4146

vidattr(A_BOLD);

4323

4179

{

4324

4180

const char *start= buffer->c_str();

4325

4181

const char *end= start + (buffer->length());

4326

while (start < end && !isgraph(end[-1]))

4182

while (start < end && !my_isgraph(charset_info,end[-1]))

4327

4183

end--;

4328

4184

uint32_t pos_to_truncate= (end-start);

4329

4185

if (buffer->length() > pos_to_truncate)

4417

4273

tmp_buff_str << tmp;

4418

4274

4419

4275

if (tmp > 1)

4420

tmp_buff_str << _(" hours ");

4276

tmp_buff_str << " hours ";

4421

4277

else

4422

tmp_buff_str << _(" hour ");

4278

tmp_buff_str << " hour ";

4423

4279

}

4424

4280

if (sec >= 60.0)

4425

4281

{

4426

4282

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

4427

4283

sec-=60.0*tmp;

4428

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

4284

tmp_buff_str << tmp << " min ";

4429

4285

}

4430

4286

if (part_second)

4431

4287

tmp_buff_str.precision(2);

4432

4288

else

4433

4289

tmp_buff_str.precision(0);

4434

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

4290

tmp_buff_str << sec << " sec";

4435

4291

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

4436

4292

}

4437

4293

4462

4318

struct tm *t = localtime(&lclock);

4463

4319

4464

4320

/* parse thru the settings for the prompt */

4465

string::iterator c= current_prompt.begin();

4466

while (c != current_prompt.end())

4321

for (char *c= current_prompt; *c; (void)*c++)

4467

4322

{

4468

4323

if (*c != PROMPT_CHAR)

4469

4324

{

4470

processed_prompt->push_back(*c);

4325

processed_prompt->append(c, 1);

4471

4326

}

4472

4327

else

4473

4328

{

4478

4333

switch (*++c) {

4479

4334

case '\0':

4480

4335

// stop it from going beyond if ends with %

4481

--c;

4336

c--;

4482

4337

break;

4483

4338

case 'c':

4484

4339

add_int_to_prompt(++prompt_counter);

4490

4345

processed_prompt->append("not_connected");

4491

4346

break;

4492

4347

case 'd':

4493

processed_prompt->append(not current_db.empty() ? current_db : "(none)");

4348

processed_prompt->append(current_db ? current_db : "(none)");

4494

4349

break;

4495

4350

case 'h':

4496

4351

{

4497

const char *prompt= connected ? drizzle_con_host(&con) : "not_connected";

4352

const char *prompt;

4353

prompt= connected ? drizzle_con_host(&con) : "not_connected";

4498

4354

if (strstr(prompt, "Localhost"))

4499

4355

processed_prompt->append("localhost");

4500

4356

else

4513

4369

break;

4514

4370

}

4515

4371

4516

if (drizzle_con_uds(&con))

4372

if (strcmp(drizzle_con_uds(&con), ""))

4517

4373

{

4518

4374

const char *pos=strrchr(drizzle_con_uds(&con),'/');

4519

4375

processed_prompt->append(pos ? pos+1 : drizzle_con_uds(&con));

4526

4382

if (!full_username)

4527

4383

init_username();

4528

4384

processed_prompt->append(full_username ? full_username :

4529

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

4385

(current_user ? current_user : "(unknown)"));

4530

4386

break;

4531

4387

case 'u':

4532

4388

if (!full_username)

4533

4389

init_username();

4534

4390

processed_prompt->append(part_username ? part_username :

4535

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

4391

(current_user ? current_user : "(unknown)"));

4536

4392

break;

4537

4393

case PROMPT_CHAR:

4538

4394

{

4614

4470

processed_prompt->append(delimiter_str);

4615

4471

break;

4616

4472

default:

4617

processed_prompt->push_back(*c);

4473

processed_prompt->append(c, 1);

4618

4474

}

4619

4475

}

4620

++c;

4621

4476

}

4622

4477

return processed_prompt->c_str();

4623

4478

}

4652

4507

{

4653

4508

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

4654

4509

if (ptr == NULL)

4655

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

4510

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

4656

4511

default_prompt);

4657

4512

prompt_counter = 0;

4658

4513

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

4659

4514

if (tmpptr == NULL)

4660

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

4515

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

4661

4516

else

4662

4517

{

4663

current_prompt.erase();

4518

free(current_prompt);

4664

4519

current_prompt= tmpptr;

4665

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

4520

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

4666

4521

}

4667

4522

return 0;

4668

4523

}

Older »