~drizzle-trunk/drizzle/development

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

1347

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

1348

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

1349

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

1350

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

1351

("skip-column-names,N",

1352

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

1353

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

1354

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

1355

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

1356

_("Output in table format."))

1357

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

1358

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

1359

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

1360

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

1361

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

1362

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

1363

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

1364

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

1365

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

1366

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

1367

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

1368

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

1369

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

1370

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

1371

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

1372

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

1373

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

1374

;

1375

1376

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

1377

drizzle_options.add_options()

1378

("disable-auto-rehash,A",

1379

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

1380

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

1381

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

1382

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

1383

_("Database to use."))

1384

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

1385

_("(not used)"))

1386

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

1387

_("Delimiter to be used."))

1388

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

1389

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

1390

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

1391

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

1392

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

1393

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

1394

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

1395

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

1396

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

1397

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

1398

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

1399

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

1400

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

1401

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

1402

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

1403

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

1404

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

1405

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

1406

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

1407

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

1408

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

1409

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

1410

_("Shutdown the server"))

1411

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

1412

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

1413

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

1414

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

1415

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

1416

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

1417

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

1418

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

1419

_("Max length of input line"))

1420

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

1421

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

1422

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

1423

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

1424

;

1425

1426

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

1427

client_options.add_options()

1428

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

1429

_("Connect to host"))

1430

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

1431

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

1432

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

1433

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

1434

#ifdef DRIZZLE_ADMIN_TOOL

1435

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

1436

#else

1437

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

1438

#endif

1439

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

1440

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

1441

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

1442

;

1443

1444

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

1445

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

1446

1447

std::string system_config_dir_drizzle(SYSCONFDIR);

1448

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

1449

1450

std::string system_config_dir_client(SYSCONFDIR);

1451

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

1452

1453

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

1454

1455

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

1456

{

1457

char *homedir;

1458

homedir= getenv("HOME");

1459

if (homedir != NULL)

1460

user_config_dir.replace(0, 1, homedir);

1461

}

1462

1463

po::variables_map vm;

1464

1465

po::positional_options_description p;

1466

p.add("database", 1);

1467

1468

// Disable allow_guessing

1469

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

1470

1471

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

1472

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

1473

vm);

1474

1475

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

1476

{

1477

std::string user_config_dir_drizzle(user_config_dir);

1478

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

1479

1480

std::string user_config_dir_client(user_config_dir);

1481

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

1482

1483

ifstream user_drizzle_ifs(user_config_dir_drizzle.c_str());

1484

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

1485

1486

ifstream user_client_ifs(user_config_dir_client.c_str());

1487

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

1488

1489

ifstream system_drizzle_ifs(system_config_dir_drizzle.c_str());

1490

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

1491

1492

ifstream system_client_ifs(system_config_dir_client.c_str());

1493

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

1494

}

1495

1496

po::notify(vm);

1497

1498

#ifdef DRIZZLE_ADMIN_TOOL

1499

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1500

getenv("DRIZZLE_PS1") :

1501

"drizzleadmin> ");

1502

#else

1150

bindtextdomain("drizzle", LOCALEDIR);

1151

textdomain("drizzle");

1152

#endif

1153

1154

MY_INIT(argv[0]);

1155

delimiter_str= delimiter;

1503

1156

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1504

1157

getenv("DRIZZLE_PS1") :

1505

1158

"drizzle> ");

1506

#endif

1159

1507

1160

if (default_prompt == NULL)

1508

1161

{

1509

1162

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

1510

1163

"prompt. Aborting.\n"));

1511

1164

exit(ENOMEM);

1512

1165

}

1513

1514

if (current_prompt.empty())

1515

current_prompt= strdup(default_prompt);

1516

1517

if (current_prompt.empty())

1166

current_prompt= strdup(default_prompt);

1167

if (current_prompt == NULL)

1518

1168

{

1519

1169

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

1520

1170

"prompt. Aborting.\n"));

1525

1175

1526

1176

prompt_counter=0;

1527

1177

1528

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

1529

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

1178

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

1179

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

1530

1180

{

1531

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

1181

char *tmp=getenv("PAGER");

1532

1182

if (tmp && strlen(tmp))

1533

1183

{

1534

1184

default_pager_set= 1;

1535

default_pager.assign(tmp);

1185

strcpy(default_pager, tmp);

1536

1186

}

1537

1187

}

1538

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

1188

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

1539

1189

{

1540

status.setBatch(1); opt_silent=1;

1190

status.batch=1; opt_silent=1;

1191

ignore_errors=0;

1541

1192

}

1542

1193

else

1543

status.setAddToHistory(1);

1544

status.setExitStatus(1);

1194

status.add_to_history=1;

1195

status.exit_status=1;

1545

1196

1546

1197

{

1547

1198

1557

1208

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

1558

1209

}

1559

1210

1560

/* Inverted Booleans */

1561

1562

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

1563

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

1564

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

1565

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

1566

1567

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

1568

if (vm.count("shutdown"))

1569

{

1570

opt_rehash= false;

1571

opt_shutdown= true;

1572

}

1573

1574

if (vm.count("delimiter"))

1575

{

1576

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

1577

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

1578

{

1579

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

1580

}

1581

else

1582

{

1583

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

1584

INFO_ERROR,0,0);

1585

exit(-1);

1586

}

1587

1588

delimiter_length= (uint32_t)strlen(delimiter);

1589

}

1590

if (vm.count("tee"))

1591

{

1592

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

1593

{

1594

if (opt_outfile)

1595

end_tee();

1596

}

1597

else

1598

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

1599

}

1600

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

1601

{

1602

if (opt_outfile)

1603

end_tee();

1604

}

1605

if (vm.count("pager"))

1606

{

1607

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

1608

opt_nopager= 1;

1609

else

1610

{

1611

opt_nopager= 0;

1612

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

1613

{

1614

default_pager_set= 1;

1615

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

1616

default_pager.assign(pager);

1617

}

1618

else if (default_pager_set)

1619

pager.assign(default_pager);

1620

else

1621

opt_nopager= 1;

1622

}

1623

}

1624

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

1625

{

1626

opt_nopager= 1;

1627

}

1628

1629

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

1630

opt_rehash= 0;

1631

1632

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

1633

column_names= 0;

1634

1635

if (vm.count("execute"))

1636

{

1637

status.setBatch(1);

1638

status.setAddToHistory(1);

1639

if (status.getLineBuff() == NULL)

1640

status.setLineBuff(opt_max_input_line,NULL);

1641

if (status.getLineBuff() == NULL)

1642

{

1643

exit(1);

1644

}

1645

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

1646

}

1647

1648

if (one_database)

1649

skip_updates= true;

1650

1651

if (vm.count("protocol"))

1652

{

1653

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

1654

opt_protocol.begin(), ::tolower);

1655

1656

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

1657

use_drizzle_protocol=false;

1658

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

1659

use_drizzle_protocol=true;

1660

else

1661

{

1662

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

1663

exit(-1);

1664

}

1665

}

1666

1667

if (vm.count("port"))

1668

{

1669

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

1670

1671

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

1672

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

1673

uint32_t. */

1674

if (opt_drizzle_port > 65535)

1675

{

1676

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

1677

exit(-1);

1678

}

1679

}

1680

1681

if (vm.count("password"))

1682

{

1683

if (!opt_password.empty())

1684

opt_password.erase();

1685

if (current_password == PASSWORD_SENTINEL)

1686

{

1687

opt_password= "";

1688

}

1689

else

1690

{

1691

opt_password= current_password;

1692

tty_password= false;

1693

}

1694

}

1695

else

1696

{

1697

tty_password= true;

1698

}

1699

1700

1701

if (!opt_verbose.empty())

1702

{

1703

verbose= opt_verbose.length();

1704

}

1705

1706

if (vm.count("batch"))

1707

{

1708

status.setBatch(1);

1709

status.setAddToHistory(0);

1710

if (opt_silent < 1)

1711

{

1712

opt_silent= 1;

1713

}

1714

}

1715

if (vm.count("silent"))

1716

{

1717

opt_silent= 2;

1718

}

1719

1720

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

1721

{

1722

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

1723

drizzle_version(), VERSION,

1724

HOST_VENDOR, HOST_OS, HOST_CPU,

1725

rl_library_version);

1726

if (vm.count("version"))

1727

exit(0);

1728

1729

"This software comes with ABSOLUTELY NO WARRANTY. "

1730

"This is free software,\n"

1731

"and you are welcome to modify and redistribute it "

1732

"under the GPL license\n"));

1733

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

1734

cout << long_options;

1735

exit(0);

1736

}

1737

1738

1739

if (process_options())

1740

{

1211

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

1212

defaults_argv=argv;

1213

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

1214

{

1215

internal::free_defaults(defaults_argv);

1216

internal::my_end();

1741

1217

exit(1);

1742

1218

}

1743

1219

1744

1220

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

1745

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

1221

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

1222

opt_silent))

1746

1223

{

1747

1224

quick= 1; // Avoid history

1748

status.setExitStatus(1);

1225

status.exit_status= 1;

1749

1226

drizzle_end(-1);

1750

1227

}

1751

1228

1753

1230

if (execute_commands(&command_error) != false)

1754

1231

{

1755

1232

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

1233

internal::free_defaults(defaults_argv);

1234

internal::my_end();

1756

1235

exit(command_error);

1757

1236

}

1758

1237

1759

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

1238

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

1760

1239

{

1761

status.setLineBuff(opt_max_input_line, stdin);

1762

if (status.getLineBuff() == NULL)

1240

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

1241

if (status.line_buff == NULL)

1763

1242

{

1243

internal::free_defaults(defaults_argv);

1244

internal::my_end();

1764

1245

exit(1);

1765

1246

}

1766

1247

}

1767

1248

1768

if (!status.getBatch())

1249

if (!status.batch)

1769

1250

ignore_errors=1; // Don't abort monitor

1770

1251

1771

1252

if (opt_sigint_ignore)

1780

1261

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

1781

1262

window_resize(0);

1782

1263

#endif

1783

std::vector<char> output_buff;

1784

output_buff.resize(512);

1785

1786

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

1787

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

1788

delimiter);

1789

1790

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

1264

1265

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

1266

INFO_INFO,0,0);

1791

1267

1792

1268

glob_buffer= new string();

1793

1269

glob_buffer->reserve(512);

1794

1270

1795

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

1796

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

1797

drizzle_con_thread_id(&con),

1798

opt_protocol.c_str(),

1799

server_version_string(&con));

1800

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

1801

1802

1803

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

1804

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

1271

ostringstream output_buff;

1272

output_buff << _("Your Drizzle connection id is ");

1273

output_buff << drizzle_con_thread_id(&con);

1274

output_buff << "\n";

1275

output_buff << _("Server version: ");

1276

output_buff << server_version_string(&con) << "\n";

1277

put_info(output_buff.str().c_str(), INFO_INFO, 0, 0);

1278

1279

initialize_readline(current_prompt);

1280

if (!status.batch && !quick)

1805

1281

{

1806

1282

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

1807

1283

if (getenv("DRIZZLE_HISTFILE"))

1808

1284

histfile= strdup(getenv("DRIZZLE_HISTFILE"));

1809

1285

else if (getenv("HOME"))

1810

1286

{

1811

histfile=(char*) malloc(strlen(getenv("HOME")) + strlen("/.drizzle_history") + 2);

1287

size_t histfile_size = strlen(getenv("HOME")) +

1288

strlen("/.drizzle_history") + 2;

1289

histfile=(char*) malloc(histfile_size);

1812

1290

if (histfile)

1813

sprintf(histfile,"%s/.drizzle_history",getenv("HOME"));

1291

snprintf(histfile, histfile_size, "%s/.drizzle_history",getenv("HOME"));

1814

1292

char link_name[FN_REFLEN];

1815

1293

ssize_t sym_link_size= readlink(histfile,link_name,FN_REFLEN-1);

1816

1294

if (sym_link_size >= 0)

1829

1307

if (verbose)

1830

1308

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

1831

1309

read_history(histfile);

1832

if (!(histfile_tmp= (char*) malloc((uint32_t) strlen(histfile) + 5)))

1310

size_t histfile_tmp_size = strlen(histfile) + 5;

1311

if (!(histfile_tmp= (char*) malloc(histfile_tmp_size)))

1833

1312

{

1834

1313

fprintf(stderr, _("Couldn't allocate memory for temp histfile!\n"));

1835

1314

exit(1);

1836

1315

}

1837

sprintf(histfile_tmp, "%s.TMP", histfile);

1316

snprintf(histfile_tmp, histfile_tmp_size, "%s.TMP", histfile);

1838

1317

}

1839

1318

}

1840

1319

1841

1320

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

1842

1321

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

1843

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

1322

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

1844

1323

if (opt_outfile)

1845

1324

end_tee();

1846

1325

drizzle_end(0);

1847

}

1848

1326

1849

catch(exception &err)

1850

{

1851

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

1852

}

1853

1327

return(0); // Keep compiler happy

1854

1328

}

1855

1329

1857

1331

{

1858

1332

drizzle_con_free(&con);

1859

1333

drizzle_free(&drizzle);

1860

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

1334

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

1861

1335

{

1862

1336

/* write-history */

1863

1337

if (verbose)

1864

1338

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

1865

1339

if (!write_history(histfile_tmp))

1866

rename(histfile_tmp, histfile);

1340

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

1867

1341

}

1868

delete status.getLineBuff();

1869

status.setLineBuff(0);

1342

delete status.line_buff;

1343

status.line_buff= 0;

1870

1344

1871

1345

if (sig >= 0)

1872

1346

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

1873

delete glob_buffer;

1874

delete processed_prompt;

1875

opt_password.erase();

1347

if (glob_buffer)

1348

delete glob_buffer;

1349

if (processed_prompt)

1350

delete processed_prompt;

1351

free(opt_password);

1876

1352

free(histfile);

1877

1353

free(histfile_tmp);

1878

current_db.erase();

1879

current_host.erase();

1880

current_user.erase();

1354

free(current_db);

1355

free(current_host);

1356

free(current_user);

1881

1357

free(full_username);

1882

1358

free(part_username);

1883

1359

free(default_prompt);

1884

current_prompt.erase();

1885

exit(status.getExitStatus());

1360

free(current_prompt);

1361

internal::free_defaults(defaults_argv);

1362

internal::my_end();

1363

exit(status.exit_status);

1886

1364

}

1887

1365

1888

1366

1895

1373

void handle_sigint(int sig)

1896

1374

{

1897

1375

char kill_buffer[40];

1898

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

1376

drizzle_con_st kill_drizzle;

1899

1377

drizzle_result_st res;

1900

1378

drizzle_return_t ret;

1901

1379

1904

1382

goto err;

1905

1383

}

1906

1384

1907

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

1908

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

1909

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

opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE) == NULL)

1910

1388

{

1911

1389

goto err;

1912

1390

}

1913

1391

1914

1392

/* kill_buffer is always big enough because max length of %lu is 15 */

1915

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

1916

drizzle_con_thread_id(&con));

1393

snprintf(kill_buffer, sizeof(kill_buffer), "KILL /*!50000 QUERY */ %u",

1394

drizzle_con_thread_id(&con));

1917

1395

1918

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

1396

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

1919

1397

drizzle_result_free(&res);

1920

1398

1921

drizzle_con_free(kill_drizzle.get());

1399

drizzle_con_free(&kill_drizzle);

1922

1400

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

1923

1401

1924

1402

interrupted_query= 1;

1940

1418

}

1941

1419

#endif

1942

1420

1943

1944

1945

static int process_options(void)

1421

static struct 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

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

1449

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

1450

{"default-character-set", OPT_DEFAULT_CHARSET,

1451

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

1452

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

1453

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

1454

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

1455

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

1456

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

1457

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

1458

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

1459

0},

1460

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

1461

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

1462

0, 0, 0, 0},

1463

{"named-commands", 'G',

1464

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. Disable with --disable-named-commands. This option is disabled by default."),

1465

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

1466

0, 0},

1467

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

1468

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

1469

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

1470

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

1471

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

1472

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

1473

(char**) &opt_local_infile,

1474

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

1475

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

1476

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

1477

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

1478

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

1479

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

1480

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

1481

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

1482

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

1483

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

1484

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

1485

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

1486

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

1487

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

1488

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

1489

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

1490

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

1491

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

1492

{"set-variable", 'O',

1493

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

1494

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

1495

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

1496

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

1497

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

1498

{"one-database", 'o',

1499

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

1500

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

1501

{"pager", OPT_PAGER,

1502

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

1503

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

1504

{"no-pager", OPT_NOPAGER,

1505

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

1506

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

1507

{"password", 'P',

1508

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

1509

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

1510

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

1511

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

1512

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

1513

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

1514

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

1515

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

1516

{"quick", 'q',

1517

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

1518

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

1519

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

1520

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

1521

0, 0, 0},

1522

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

1523

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

1524

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

1525

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

1526

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

1527

0, 0},

1528

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

1529

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

1530

{"tee", OPT_TEE,

1531

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

1532

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

1533

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

1534

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

1535

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

1536

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

1537

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

1538

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

1539

0, 0, 0, 0},

1540

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

1541

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

1542

0, 0, 0, 0},

1543

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

1544

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

1545

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

1546

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

1547

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

1548

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

1549

{"connect_timeout", OPT_CONNECT_TIMEOUT,

1550

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

1551

(char**) &opt_connect_timeout,

1552

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

1553

0, 0},

1554

{"max_input_line", OPT_MAX_INPUT_LINE,

1555

N_("Max length of input line"),

1556

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

1557

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

1558

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

1559

{"select_limit", OPT_SELECT_LIMIT,

1560

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

1561

(char**) &select_limit,

1562

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

1563

0, 1, 0},

1564

{"max_join_size", OPT_MAX_JOIN_SIZE,

1565

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

1566

(char**) &max_join_size,

1567

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

1568

0, 1, 0},

1569

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

1570

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

1571

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

1572

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

1573

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

1574

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

1575

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

1576

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

1577

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

1578

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

1579

{"mysql", 'm', N_("Use MySQL Protocol."),

1580

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

1581

0, 0, 0},

1582

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

1583

};

1584

1585

1586

static void usage(int version)

1587

{

1588

const char* readline= "readline";

1589

1590

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

1591

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

1592

HOST_VENDOR, HOST_OS, HOST_CPU,

1593

readline, rl_library_version);

1594

1595

if (version)

1596

return;

1597

1598

"This software comes with ABSOLUTELY NO WARRANTY. "

1599

"This is free software,\n"

1600

"and you are welcome to modify and redistribute it "

1601

"under the GPL license\n"));

1602

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

1603

my_print_help(my_long_options);

1604

internal::print_defaults("drizzle", load_default_groups);

1605

my_print_variables(my_long_options);

1606

}

1607

1608

1609

static int get_one_option(int optid, const struct option *, char *argument)

1610

{

1611

char *endchar= NULL;

1612

uint64_t temp_drizzle_port= 0;

1613

1614

switch(optid) {

1615

case OPT_DEFAULT_CHARSET:

1616

default_charset_used= 1;

1617

break;

1618

case OPT_DELIMITER:

1619

if (argument == disabled_my_option)

1620

{

1621

strcpy(delimiter, DEFAULT_DELIMITER);

1622

}

1623

else

1624

{

1625

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

1626

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

1627

{

1628

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

1629

}

1630

else

1631

{

1632

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

1633

INFO_ERROR,0,0);

1634

return EXIT_ARGUMENT_INVALID;

1635

}

1636

}

1637

delimiter_length= (uint32_t)strlen(delimiter);

1638

delimiter_str= delimiter;

1639

break;

1640

case OPT_TEE:

1641

if (argument == disabled_my_option)

1642

{

1643

if (opt_outfile)

1644

end_tee();

1645

}

1646

else

1647

init_tee(argument);

1648

break;

1649

case OPT_NOTEE:

1650

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

1651

if (opt_outfile)

1652

end_tee();

1653

break;

1654

case OPT_PAGER:

1655

if (argument == disabled_my_option)

1656

opt_nopager= 1;

1657

else

1658

{

1659

opt_nopager= 0;

1660

if (argument && strlen(argument))

1661

{

1662

default_pager_set= 1;

1663

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

1664

strcpy(default_pager, pager);

1665

}

1666

else if (default_pager_set)

1667

strcpy(pager, default_pager);

1668

else

1669

opt_nopager= 1;

1670

}

1671

break;

1672

case OPT_NOPAGER:

1673

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

1674

opt_nopager= 1;

1675

break;

1676

case OPT_SERVER_ARG:

1677

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

1678

break;

1679

case 'A':

1680

opt_rehash= 0;

1681

break;

1682

case 'N':

1683

column_names= 0;

1684

break;

1685

case 'e':

1686

status.batch= 1;

1687

status.add_to_history= 0;

1688

if (status.line_buff == NULL)

1689

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

1690

if (status.line_buff == NULL)

1691

{

1692

internal::my_end();

1693

exit(1);

1694

}

1695

status.line_buff->addString(argument);

1696

break;

1697

case 'o':

1698

if (argument == disabled_my_option)

1699

one_database= 0;

1700

else

1701

one_database= skip_updates= 1;

1702

break;

1703

case 'p':

1704

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

1705

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

1706

if (strlen(endchar) != 0)

1707

{

1708

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

1709

return EXIT_ARGUMENT_INVALID;

1710

}

1711

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

1712

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

1713

uint32_t. */

1714

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

1715

{

1716

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

1717

return EXIT_ARGUMENT_INVALID;

1718

}

1719

else

1720

{

1721

opt_drizzle_port= (uint32_t) temp_drizzle_port;

1722

}

1723

break;

1724

case 'P':

1725

/* Don't require password */

1726

if (argument == disabled_my_option)

1727

{

1728

argument= (char*) "";

1729

}

1730

if (argument)

1731

{

1732

char *start= argument;

1733

free(opt_password);

1734

opt_password= strdup(argument);

1735

while (*argument)

1736

{

1737

/* Overwriting password with 'x' */

1738

*argument++= 'x';

1739

}

1740

if (*start)

1741

{

1742

start[1]= 0;

1743

}

1744

tty_password= 0;

1745

}

1746

else

1747

{

1748

tty_password= 1;

1749

}

1750

break;

1751

case 's':

1752

if (argument == disabled_my_option)

1753

opt_silent= 0;

1754

else

1755

opt_silent++;

1756

break;

1757

case 'v':

1758

if (argument == disabled_my_option)

1759

verbose= 0;

1760

else

1761

verbose++;

1762

break;

1763

case 'B':

1764

status.batch= 1;

1765

status.add_to_history= 0;

1766

set_if_bigger(opt_silent,1); // more silent

1767

break;

1768

case 'V':

1769

usage(1);

1770

exit(0);

1771

case 'I':

1772

case '?':

1773

usage(0);

1774

exit(0);

1775

}

1776

return 0;

1777

}

1778

1779

1780

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

1946

1781

{

1947

1782

char *tmp, *pagpoint;

1948

1783

int ho_error;

1949

1784

1950

1785

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

1951

1786

if (tmp)

1952

current_host.assign(tmp);

1787

current_host= strdup(tmp);

1953

1788

1954

1789

pagpoint= getenv("PAGER");

1955

1790

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

1956

1791

{

1957

pager.assign("stdout");

1792

strcpy(pager, "stdout");

1958

1793

opt_nopager= 1;

1959

1794

}

1960

1795

else

1961

{

1962

pager.assign(pagpoint);

1963

}

1964

default_pager.assign(pager);

1965

1966

1967

1968

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

1969

{

1970

default_pager.assign("stdout");

1971

pager.assign("stdout");

1796

strcpy(pager, pagpoint);

1797

strcpy(default_pager, pager);

1798

1799

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

1800

exit(ho_error);

1801

1802

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

1803

{

1804

strcpy(default_pager, "stdout");

1805

strcpy(pager, "stdout");

1972

1806

opt_nopager= 1;

1973

1807

default_pager_set= 0;

1974

1808

opt_outfile= 0;

1976

1810

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

1977

1811

}

1978

1812

1813

if (argc > 1)

1814

{

1815

usage(0);

1816

exit(1);

1817

}

1818

if (argc == 1)

1819

{

1820

skip_updates= 0;

1821

free(current_db);

1822

current_db= strdup(*argv);

1823

}

1979

1824

if (tty_password)

1980

1825

opt_password= client_get_tty_password(NULL);

1826

1981

1827

return(0);

1982

1828

}

1983

1829

1987

1833

char in_string=0;

1988

1834

uint32_t line_number=0;

1989

1835

bool ml_comment= 0;

1990

Commands *com;

1991

status.setExitStatus(1);

1836

COMMANDS *com;

1837

status.exit_status=1;

1992

1838

1993

1839

for (;;)

1994

1840

{

1995

1841

if (!interactive)

1996

1842

{

1997

if (status.getLineBuff())

1998

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

1843

if (status.line_buff)

1844

line= status.line_buff->readline();

1999

1845

else

2000

1846

line= 0;

2001

1847

2006

1852

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

2007

1853

}

2008

1854

if (!glob_buffer->empty())

2009

status.setQueryStartLine(line_number);

1855

status.query_start_line= line_number;

2010

1856

}

2011

1857

else

2012

1858

{

2013

string prompt(ml_comment

2014

? " /*> "

2015

: glob_buffer->empty()

2016

? construct_prompt()

2017

: not in_string

2018

? " -> "

2019

: in_string == '\''

2020

? " '> "

2021

: in_string == '`'

2022

? " `> "

2023

: " \"> ");

1859

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

1860

(glob_buffer->empty())

1861

? construct_prompt()

1862

: !in_string ? " -> " :

1863

in_string == '\'' ?

1864

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

1865

" `> " :

1866

" \"> "));

2024

1867

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

2025

1868

fflush(OUTFILE);

2026

1869

2027

1870

if (opt_outfile)

2028

fputs(prompt.c_str(), OUTFILE);

2029

line= readline(prompt.c_str());

1871

fputs(prompt, OUTFILE);

1872

line= readline(prompt);

2030

1873

2031

1874

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

2032

1875

which may cause coredump.

2037

1880

// End of file

2038

1881

if (!line)

2039

1882

{

2040

status.setExitStatus(0);

1883

status.exit_status=0;

2041

1884

break;

2042

1885

}

2043

1886

2053

1896

// If buffer was emptied

2054

1897

if (glob_buffer->empty())

2055

1898

in_string=0;

2056

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

1899

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

2057

1900

add_history(line);

2058

1901

continue;

2059

1902

}

2062

1905

}

2063

1906

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

2064

1907

2065

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

1908

if (!interactive && !status.exit_status)

2066

1909

{

2067

1910

remove_cntrl(glob_buffer);

2068

1911

if (!glob_buffer->empty())

2069

1912

{

2070

status.setExitStatus(1);

1913

status.exit_status=1;

2071

1914

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

2072

status.setExitStatus(0);

1915

status.exit_status=0;

2073

1916

}

2074

1917

}

2075

1918

2076

return status.getExitStatus();

1919

return status.exit_status;

2077

1920

}

2078

1921

2079

1922

2080

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

1923

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

2081

1924

{

2082

1925

uint32_t len;

2083

1926

const char *end;

2089

1932

}

2090

1933

else

2091

1934

{

2092

while (isspace(*name))

1935

while (my_isspace(charset_info,*name))

2093

1936

name++;

2094

1937

2095

1938

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

2098

1941

2099

1942

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

2100

1943

!(strlen(name) >= 9 &&

2101

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

2102

return(NULL);

1944

!my_strnncoll(charset_info,

1945

(unsigned char*) name, 9,

1946

(const unsigned char*) "delimiter",

1947

9))))

1948

return((COMMANDS *) 0);

2103

1949

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

2104

1950

{

2105

1951

len=(uint32_t) (end - name);

2106

while (isspace(*end))

1952

while (my_isspace(charset_info,*end))

2107

1953

end++;

2108

1954

if (!*end)

2109

1955

end=0; // no arguments to function

2112

1958

len=(uint32_t) strlen(name);

2113

1959

}

2114

1960

2115

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

1961

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

2116

1962

{

2117

1963

if (commands[i].func &&

2118

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

2119

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

1964

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

2120

1965

{

2121

1966

return(&commands[i]);

2122

1967

}

2123

1968

}

2124

return(NULL);

1969

return((COMMANDS *) 0);

2125

1970

}

2126

1971

2127

1972

2128

1973

static bool add_line(string *buffer, char *line, char *in_string,

2129

bool *ml_comment)

1974

bool *ml_comment)

2130

1975

{

2131

1976

unsigned char inchar;

2132

1977

char *pos, *out;

2133

Commands *com;

1978

COMMANDS *com;

2134

1979

bool need_space= 0;

2135

1980

bool ss_comment= 0;

2136

1981

2137

1982

2138

1983

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

2139

1984

return(0);

2140

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

1985

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

2141

1986

add_history(line);

2142

1987

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

2143

1988

2146

1991

if (!preserve_comments)

2147

1992

{

2148

1993

// Skip spaces at the beggining of a statement

2149

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

1994

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

2150

1995

(buffer->empty()))

2151

1996

continue;

2152

1997

}

2153

1998

2154

1999

// Accept multi-byte characters as-is

2155

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

2000

int length;

2001

if (use_mb(charset_info) &&

2002

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

2156

2003

{

2157

int length;

2158

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

2004

if (!*ml_comment || preserve_comments)

2159

2005

{

2160

if (!*ml_comment || preserve_comments)

2161

{

2162

while (length--)

2163

*out++ = *pos++;

2164

pos--;

2165

}

2166

else

2167

pos+= length - 1;

2168

continue;

2006

while (length--)

2007

*out++ = *pos++;

2008

pos--;

2169

2009

}

2010

else

2011

pos+= length - 1;

2012

continue;

2170

2013

}

2171

2014

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

2172

2015

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

2192

2035

2193

2036

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

2194

2037

return(1); // Quit

2195

if (com->getTakesParams())

2038

if (com->takes_params)

2196

2039

{

2197

2040

if (ss_comment)

2198

2041

{

2235

2078

}

2236

2079

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

2237

2080

(end_of_line - pos) >= 10 &&

2238

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

2081

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

2082

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

2239

2083

{

2240

2084

// Flush previously accepted characters

2241

2085

if (out != line)

2272

2116

2273

2117

if (preserve_comments)

2274

2118

{

2275

while (isspace(*pos))

2119

while (my_isspace(charset_info, *pos))

2276

2120

*out++= *pos++;

2277

2121

}

2278

2122

// Flush previously accepted characters

2285

2129

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

2286

2130

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

2287

2131

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

2288

isspace(pos[2]))))

2132

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

2289

2133

{

2290

2134

// Add trailing single line comments to this statement

2291

2135

buffer->append(pos);

2312

2156

&& (inchar == '#'

2313

2157

|| (inchar == '-'

2314

2158

&& pos[1] == '-'

2315

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

2159

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

2316

2160

{

2317

2161

// Flush previously accepted characters

2318

2162

if (out != line)

2378

2222

*in_string= (char) inchar;

2379

2223

if (!*ml_comment || preserve_comments)

2380

2224

{

2381

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

2225

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

2382

2226

*out++= ' ';

2383

2227

need_space= 0;

2384

2228

*out++= (char) inchar;

2389

2233

{

2390

2234

*out++='\n';

2391

2235

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

2392

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

2393

{

2394

status.setExitStatus(1);

2395

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

2396

return 1;

2397

}

2398

2236

if ((!*ml_comment || preserve_comments))

2399

2237

buffer->append(line, length);

2400

2238

}

2402

2240

}

2403

2241

2404

2242

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

2405

Interface to Readline Completion

2406

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

2243

Interface to Readline Completion

2244

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

2407

2245

2408

2246

2409

2247

static char **mysql_completion (const char *text, int start, int end);

2511

2349

2512

2350

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

2513

2351

{

2514

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

2352

if (!status.batch && !quick)

2515

2353

return rl_completion_matches(text, new_command_generator);

2516

2354

else

2517

2355

return (char**) 0;

2580

2418

2581

2419

static void build_completion_hash(bool rehash, bool write_info)

2582

2420

{

2583

Commands *cmd=commands;

2421

COMMANDS *cmd=commands;

2584

2422

drizzle_return_t ret;

2585

2423

drizzle_result_st databases,tables,fields;

2586

2424

drizzle_row_t database_row,table_row;

2425

drizzle_column_st *sql_field;

2587

2426

string tmp_str, tmp_str_lower;

2588

std::string query;

2589

2427

2590

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

2428

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

2591

2429

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

2592

2430

if (!rehash)

2593

2431

return;

2595

2433

completion_map.clear();

2596

2434

2597

2435

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

2598

while (cmd->getName()) {

2599

tmp_str= cmd->getName();

2436

while (cmd->name) {

2437

tmp_str= cmd->name;

2600

2438

tmp_str_lower= lower_string(tmp_str);

2601

2439

completion_map[tmp_str_lower]= tmp_str;

2602

2440

cmd++;

2605

2443

/* hash Drizzle functions (to be implemented) */

2606

2444

2607

2445

/* hash all database names */

2608

if (drizzle_query_str(&con, &databases, "select schema_name from information_schema.schemata", &ret) != NULL)

2446

if (drizzle_query_str(&con, &databases, "show databases", &ret) != NULL)

2609

2447

{

2610

2448

if (ret == DRIZZLE_RETURN_OK)

2611

2449

{

2625

2463

drizzle_result_free(&databases);

2626

2464

}

2627

2465

2628

query= "select table_name, column_name from information_schema.columns where table_schema='";

2629

query.append(current_db);

2630

query.append("' order by table_name");

2631

2632

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

2633

&ret) != NULL)

2466

/* hash all table names */

2467

if (drizzle_query_str(&con, &tables, "show tables", &ret) != NULL)

2634

2468

{

2635

if (ret == DRIZZLE_RETURN_OK &&

2636

drizzle_result_buffer(&fields) == DRIZZLE_RETURN_OK)

2469

if (ret != DRIZZLE_RETURN_OK)

2470

{

2471

drizzle_result_free(&tables);

2472

return;

2473

}

2474

2475

if (drizzle_result_buffer(&tables) != DRIZZLE_RETURN_OK)

2476

put_info(drizzle_error(&drizzle),INFO_INFO,0,0);

2477

else

2637

2478

{

2638

2479

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

2639

2480

{

2640

tee_fprintf(stdout,

2641

_("Reading table information for completion of "

2642

"table and column names\n"

2643

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

2644

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

2481

tee_fprintf(stdout, _("\

2482

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

2483

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

2645

2484

}

2646

2647

std::string table_name;

2648

while ((table_row=drizzle_row_next(&fields)))

2485

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

2649

2486

{

2650

if (table_name.compare(table_row[0]) != 0)

2651

{

2652

tmp_str= table_row[0];

2653

tmp_str_lower= lower_string(tmp_str);

2654

completion_map[tmp_str_lower]= tmp_str;

2655

table_name= table_row[0];

2656

}

2657

2487

tmp_str= table_row[0];

2658

tmp_str.append(".");

2659

tmp_str.append(table_row[1]);

2660

tmp_str_lower= lower_string(tmp_str);

2661

completion_map[tmp_str_lower]= tmp_str;

2662

2663

tmp_str= table_row[1];

2664

tmp_str_lower= lower_string(tmp_str);

2665

completion_map[tmp_str_lower]= tmp_str;

2666

}

2667

}

2668

}

2669

drizzle_result_free(&fields);

2488

tmp_str_lower= lower_string(tmp_str);

2489

completion_map[tmp_str_lower]= tmp_str;

2490

}

2491

}

2492

}

2493

else

2494

return;

2495

2496

/* hash all field names, both with the table prefix and without it */

2497

if (drizzle_result_row_count(&tables) == 0)

2498

{

2499

drizzle_result_free(&tables);

2500

return;

2501

}

2502

2503

drizzle_row_seek(&tables, 0);

2504

2505

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

2506

{

2507

string query;

2508

2509

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

2510

query.append(table_row[0]);

2511

query.append("'");

2512

2513

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

2514

&ret) != NULL)

2515

{

2516

if (ret == DRIZZLE_RETURN_OK &&

2517

drizzle_result_buffer(&fields) == DRIZZLE_RETURN_OK)

2518

{

2519

while ((sql_field=drizzle_column_next(&fields)))

2520

{

2521

tmp_str=table_row[0];

2522

tmp_str.append(".");

2523

tmp_str.append(drizzle_column_name(sql_field));

2524

tmp_str_lower= lower_string(tmp_str);

2525

completion_map[tmp_str_lower]= tmp_str;

2526

2527

tmp_str=drizzle_column_name(sql_field);

2528

tmp_str_lower= lower_string(tmp_str);

2529

completion_map[tmp_str_lower]= tmp_str;

2530

}

2531

}

2532

drizzle_result_free(&fields);

2533

}

2534

}

2535

drizzle_result_free(&tables);

2670

2536

completion_iter= completion_map.begin();

2671

2537

}

2672

2538

2692

2558

drizzle_return_t ret;

2693

2559

drizzle_result_st res;

2694

2560

2695

current_db.erase();

2696

current_db= "";

2561

free(current_db);

2562

current_db= NULL;

2697

2563

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

2698

2564

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

2699

2565

{

2702

2568

{

2703

2569

drizzle_row_t row= drizzle_row_next(&res);

2704

2570

if (row[0])

2705

current_db.assign(row[0]);

2571

current_db= strdup(row[0]);

2706

2572

drizzle_result_free(&res);

2707

2573

}

2708

2574

}

2709

2575

}

2710

2576

2711

2577

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

2712

The different commands

2713

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

2578

The different commands

2579

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

2714

2580

2715

int drizzleclient_real_query_for_lazy(const char *buf, size_t length,

2581

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2716

2582

drizzle_result_st *result,

2717

2583

uint32_t *error_code)

2718

2584

{

2752

2618

2753

2619

if (drizzle_con_error(&con)[0])

2754

2620

{

2755

int ret= put_error(&con, result);

2621

int ret = put_error(&con, result);

2756

2622

drizzle_result_free(result);

2757

2623

return ret;

2758

2624

}

2762

2628

static int

2763

2629

com_help(string *buffer, const char *)

2764

2630

{

2765

int i, j;

2631

2766

2632

char buff[32], *end;

2767

std::vector<char> output_buff;

2768

output_buff.resize(512);

2769

2633

2770

2634

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

2771

2635

if (!named_cmds)

2772

{

2773

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

2774

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

2775

delimiter);

2776

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

2777

}

2778

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

2779

{

2780

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

2781

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

2782

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

2636

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

2637

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

2638

{

2639

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

2640

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

2641

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

2783

2642

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

2784

2643

if (commands[i].func)

2785

2644

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

2786

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

2645

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

2787

2646

}

2788

2647

tee_fprintf(stdout, "\n");

2789

2648

buffer->clear();

2794

2653

static int

2795

2654

com_clear(string *buffer, const char *)

2796

2655

{

2797

if (status.getAddToHistory())

2656

if (status.add_to_history)

2798

2657

fix_history(buffer);

2799

2658

buffer->clear();

2800

2659

return 0;

2803

2662

2804

2663

2805

2664

Execute command

2806

Returns: 0 if ok

2807

-1 if not fatal error

2808

1 if fatal error

2665

Returns: 0 if ok

2666

-1 if not fatal error

2667

1 if fatal error

2809

2668

2810

2669

static int

2811

2670

com_go(string *buffer, const char *)

2812

2671

{

2813

2672

char buff[200]; /* about 110 chars used so far */

2673

char time_buff[52+3+1]; /* time max + space&parens + NUL */

2814

2674

drizzle_result_st result;

2815

2675

drizzle_return_t ret;

2816

uint32_t warnings= 0;

2817

boost::posix_time::ptime timer;

2676

uint32_t timer, warnings= 0;

2818

2677

uint32_t error= 0;

2819

2678

uint32_t error_code= 0;

2820

2679

int err= 0;

2827

2686

if (buffer->empty())

2828

2687

{

2829

2688

// Ignore empty quries

2830

if (status.getBatch())

2689

if (status.batch)

2831

2690

return 0;

2832

2691

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

2833

2692

2852

2711

executing_query= 1;

2853

2712

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

2854

2713

2855

if (status.getAddToHistory())

2714

if (status.add_to_history)

2856

2715

{

2857

2716

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

2858

2717

/* Append final command onto history */

2883

2742

goto end;

2884

2743

}

2885

2744

2886

string time_buff("");

2887

2745

if (verbose >= 3 || !opt_silent)

2888

2746

drizzle_end_timer(timer,time_buff);

2747

else

2748

time_buff[0]= '\0';

2889

2749

2890

2750

/* Every branch must truncate buff . */

2891

2751

if (drizzle_result_column_count(&result) > 0)

2905

2765

print_tab_data(&result);

2906

2766

else

2907

2767

print_table_data(&result);

2908

sprintf(buff,

2909

ngettext("%ld row in set","%ld rows in set",

2910

(long) drizzle_result_row_count(&result)),

2911

(long) drizzle_result_row_count(&result));

2768

snprintf(buff, sizeof(buff),

2769

ngettext("%ld row in set","%ld rows in set",

2770

(long) drizzle_result_row_count(&result)),

2771

(long) drizzle_result_row_count(&result));

2912

2772

end_pager();

2913

2773

if (drizzle_result_error_code(&result))

2914

2774

error= put_error(&con, &result);

2917

2777

else if (drizzle_result_affected_rows(&result) == ~(uint64_t) 0)

2918

2778

strcpy(buff,_("Query OK"));

2919

2779

else

2920

sprintf(buff, ngettext("Query OK, %ld row affected",

2921

"Query OK, %ld rows affected",

2922

(long) drizzle_result_affected_rows(&result)),

2923

(long) drizzle_result_affected_rows(&result));

2780

snprintf(buff, sizeof(buff), ngettext("Query OK, %ld row affected",

2781

"Query OK, %ld rows affected",

2782

(long) drizzle_result_affected_rows(&result)),

2783

(long) drizzle_result_affected_rows(&result));

2924

2784

2925

2785

pos= strchr(buff, '\0');

2926

2786

if ((warnings= drizzle_result_warning_count(&result)))

2929

2789

*pos++= ' ';

2930

2790

char warnings_buff[20];

2931

2791

memset(warnings_buff,0,20);

2932

sprintf(warnings_buff, "%d", warnings);

2792

snprintf(warnings_buff, sizeof(warnings_buff), "%d", warnings);

2933

2793

strcpy(pos, warnings_buff);

2934

2794

pos+= strlen(warnings_buff);

2935

2795

pos= strcpy(pos, " warning")+8;

2936

2796

if (warnings != 1)

2937

2797

*pos++= 's';

2938

2798

}

2939

strcpy(pos, time_buff.c_str());

2799

strcpy(pos, time_buff);

2940

2800

put_info(buff,INFO_RESULT,0,0);

2941

2801

if (strcmp(drizzle_result_info(&result), ""))

2942

2802

put_info(drizzle_result_info(&result),INFO_RESULT,0,0);

2972

2832

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

2973

2833

print_warnings(error_code);

2974

2834

2975

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

2835

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

2976

2836

drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)

2977

2837

{

2978

2838

get_current_db();

2987

2847

{

2988

2848

if (!opt_nopager)

2989

2849

{

2990

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

2850

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

2991

2851

{

2992

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

2852

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

2993

2853

PAGER= stdout;

2994

2854

}

2995

2855

}

3011

2871

end_tee();

3012

2872

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

3013

2873

{

3014

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

2874

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

3015

2875

return;

3016

2876

}

3017

2877

OUTFILE = new_outfile;

3018

outfile.assign(file_name);

3019

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

2878

strncpy(outfile, file_name, FN_REFLEN-1);

2879

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

3020

2880

opt_outfile= 1;

3021

2881

3022

2882

return;

3047

2907

static const char *fieldtype2str(drizzle_column_type_t type)

3048

2908

{

3049

2909

switch (type) {

3050

case DRIZZLE_COLUMN_TYPE_BLOB: return "BLOB";

3051

case DRIZZLE_COLUMN_TYPE_DATE: return "DATE";

3052

case DRIZZLE_COLUMN_TYPE_DATETIME: return "DATETIME";

3053

case DRIZZLE_COLUMN_TYPE_NEWDECIMAL: return "DECIMAL";

3054

case DRIZZLE_COLUMN_TYPE_DOUBLE: return "DOUBLE";

3055

case DRIZZLE_COLUMN_TYPE_ENUM: return "ENUM";

3056

case DRIZZLE_COLUMN_TYPE_LONG: return "LONG";

3057

case DRIZZLE_COLUMN_TYPE_LONGLONG: return "LONGLONG";

3058

case DRIZZLE_COLUMN_TYPE_NULL: return "NULL";

3059

case DRIZZLE_COLUMN_TYPE_TIMESTAMP: return "TIMESTAMP";

3060

default: return "?-unknown-?";

2910

case DRIZZLE_COLUMN_TYPE_BLOB: return "BLOB";

2911

case DRIZZLE_COLUMN_TYPE_DATE: return "DATE";

2912

case DRIZZLE_COLUMN_TYPE_DATETIME: return "DATETIME";

2913

case DRIZZLE_COLUMN_TYPE_NEWDECIMAL: return "DECIMAL";

2914

case DRIZZLE_COLUMN_TYPE_DOUBLE: return "DOUBLE";

2915

case DRIZZLE_COLUMN_TYPE_ENUM: return "ENUM";

2916

case DRIZZLE_COLUMN_TYPE_LONG: return "LONG";

2917

case DRIZZLE_COLUMN_TYPE_LONGLONG: return "LONGLONG";

2918

case DRIZZLE_COLUMN_TYPE_NULL: return "NULL";

2919

case DRIZZLE_COLUMN_TYPE_TIMESTAMP: return "TIMESTAMP";

2920

default: return "?-unknown-?";

3061

2921

}

3062

2922

}

3063

2923

3067

2927

*s=0;

3068

2928

#define ff2s_check_flag(X) \

3069

2929

if (f & DRIZZLE_COLUMN_FLAGS_ ## X) { s=strcpy(s, # X " ")+strlen(# X " "); \

3070

f &= ~ DRIZZLE_COLUMN_FLAGS_ ## X; }

2930

f &= ~ DRIZZLE_COLUMN_FLAGS_ ## X; }

3071

2931

ff2s_check_flag(NOT_NULL);

3072

2932

ff2s_check_flag(PRI_KEY);

3073

2933

ff2s_check_flag(UNIQUE_KEY);

3088

2948

ff2s_check_flag(ON_UPDATE_NOW);

3089

2949

#undef ff2s_check_flag

3090

2950

if (f)

3091

sprintf(s, " unknows=0x%04x", f);

2951

snprintf(s, sizeof(buf), " unknows=0x%04x", f);

3092

2952

return buf;

3093

2953

}

3094

2954

3100

2960

3101

2961

while ((field = drizzle_column_next(result)))

3102

2962

{

3103

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

2963

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

3104

2964

"Catalog: `%s`\n"

3105

"Schema: `%s`\n"

2965

"Database: `%s`\n"

3106

2966

"Table: `%s`\n"

3107

2967

"Org_table: `%s`\n"

3108

"Type: UTF-8\n"

2968

"Type: %s\n"

3109

2969

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

3110

2970

"Length: %lu\n"

3111

2971

"Max_length: %lu\n"

3112

2972

"Decimals: %u\n"

3113

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

2973

"Flags: %s\n\n",

3114

2974

++i,

3115

2975

drizzle_column_name(field), drizzle_column_catalog(field),

3116

2976

drizzle_column_db(field), drizzle_column_table(field),

3117

2977

drizzle_column_orig_table(field),

3118

2978

fieldtype2str(drizzle_column_type(field)),

2979

get_charset_name(drizzle_column_charset(field)),

3119

2980

drizzle_column_charset(field), drizzle_column_size(field),

3120

2981

drizzle_column_max_size(field), drizzle_column_decimals(field),

3121

2982

fieldflags2str(drizzle_column_flags(field)));

3123

2984

tee_puts("", PAGER);

3124

2985

}

3125

2986

2987

3126

2988

static void

3127

2989

print_table_data(drizzle_result_st *result)

3128

2990

{

3129

2991

drizzle_row_t cur;

3130

2992

drizzle_return_t ret;

3131

2993

drizzle_column_st *field;

3132

std::vector<bool> num_flag;

3133

std::vector<bool> boolean_flag;

3134

std::vector<bool> ansi_boolean_flag;

2994

bool *num_flag;

3135

2995

string separator;

3136

2996

3137

2997

separator.reserve(256);

3138

2998

3139

num_flag.resize(drizzle_result_column_count(result));

3140

boolean_flag.resize(drizzle_result_column_count(result));

3141

ansi_boolean_flag.resize(drizzle_result_column_count(result));

2999

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

3142

3000

if (column_types_flag)

3143

3001

{

3144

3002

print_field_types(result);

3156

3014

uint32_t name_length= strlen(drizzle_column_name(field));

3157

3015

3158

3016

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

3159

of visual length since multibyte characters can affect the

3160

length of the separator. */

3161

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

3017

of visual length since multibyte characters can affect the

3018

length of the separator. */

3019

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

3020

drizzle_column_name(field),

3021

drizzle_column_name(field) +

3022

name_length);

3162

3023

3163

3024

if (name_length == drizzle_column_max_size(field))

3164

3025

{

3170

3031

length= name_length;

3171

3032

}

3172

3033

}

3173

3034

3174

3035

if (quick)

3175

3036

length=max(length,drizzle_column_size(field));

3176

3037

else

3181

3042

// Room for "NULL"

3182

3043

length=4;

3183

3044

}

3184

if ((length < 5) and

3185

(server_type == ServerDetect::SERVER_DRIZZLE_FOUND) and

3186

(drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_TINY) and

3187

(drizzle_column_type(field) & DRIZZLE_COLUMN_FLAGS_UNSIGNED))

3188

{

3189

// Room for "FALSE"

3190

length= 5;

3191

}

3192

3045

drizzle_column_set_max_size(field, length);

3193

3046

3194

3047

for (x=0; x< (length+2); x++)

3204

3057

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

3205

3058

{

3206

3059

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

3207

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

3060

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

3061

drizzle_column_name(field),

3062

drizzle_column_name(field) +

3063

name_length);

3208

3064

uint32_t display_length= drizzle_column_max_size(field) + name_length -

3209

numcells;

3065

numcells;

3210

3066

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

3211

3067

MAX_COLUMN_LENGTH),

3212

3068

drizzle_column_name(field));

3213

3069

num_flag[off]= ((drizzle_column_type(field) <= DRIZZLE_COLUMN_TYPE_LONGLONG) ||

3214

3070

(drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_NEWDECIMAL));

3215

if ((server_type == ServerDetect::SERVER_DRIZZLE_FOUND) and

3216

(drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_TINY))

3217

{

3218

if ((drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_UNSIGNED))

3219

{

3220

ansi_boolean_flag[off]= true;

3221

}

3222

else

3223

{

3224

ansi_boolean_flag[off]= false;

3225

}

3226

boolean_flag[off]= true;

3227

num_flag[off]= false;

3228

}

3229

else

3230

{

3231

boolean_flag[off]= false;

3232

}

3233

3071

}

3234

3072

(void) tee_fputs("\n", PAGER);

3235

3073

tee_puts((char*) separator.c_str(), PAGER);

3268

3106

buffer= "NULL";

3269

3107

data_length= 4;

3270

3108

}

3271

else if (boolean_flag[off])

3272

{

3273

if (strncmp(cur[off],"1", 1) == 0)

3274

{

3275

if (ansi_boolean_flag[off])

3276

{

3277

buffer= "YES";

3278

data_length= 3;

3279

}

3280

else

3281

{

3282

buffer= "TRUE";

3283

data_length= 4;

3284

}

3285

}

3286

else

3287

{

3288

if (ansi_boolean_flag[off])

3289

{

3290

buffer= "NO";

3291

data_length= 2;

3292

}

3293

else

3294

{

3295

buffer= "FALSE";

3296

data_length= 5;

3297

}

3298

}

3299

}

3300

3109

else

3301

3110

{

3302

3111

buffer= cur[off];

3314

3123

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

3315

3124

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

3316

3125

3317

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

3126

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

3318

3127

extra_padding= data_length - visible_length;

3319

3128

3320

3129

if (field_max_length > MAX_COLUMN_LENGTH)

3334

3143

drizzle_row_free(result, cur);

3335

3144

}

3336

3145

tee_puts(separator.c_str(), PAGER);

3146

free(num_flag);

3337

3147

}

3338

3148

3339

3149

/**

3340

Return the length of a field after it would be rendered into text.

3341

3342

This doesn't know or care about multibyte characters. Assume we're

3343

using such a charset. We can't know that all of the upcoming rows

3344

for this column will have bytes that each render into some fraction

3345

of a character. It's at least possible that a row has bytes that

3346

all render into one character each, and so the maximum length is

3347

still the number of bytes. (Assumption 1: This can't be better

3348

because we can never know the number of characters that the DB is

3349

going to send -- only the number of bytes. 2: Chars <= Bytes.)

3350

3351

@param field Pointer to a field to be inspected

3352

3353

@returns number of character positions to be used, at most

3150

Return the length of a field after it would be rendered into text.

3151

3152

This doesn't know or care about multibyte characters. Assume we're

3153

using such a charset. We can't know that all of the upcoming rows

3154

for this column will have bytes that each render into some fraction

3155

of a character. It's at least possible that a row has bytes that

3156

all render into one character each, and so the maximum length is

3157

still the number of bytes. (Assumption 1: This can't be better

3158

because we can never know the number of characters that the DB is

3159

going to send -- only the number of bytes. 2: Chars <= Bytes.)

3160

3161

@param field Pointer to a field to be inspected

3162

3163

@returns number of character positions to be used, at most

3354

3164

3355

3165

static int get_field_disp_length(drizzle_column_st *field)

3356

3166

{

3362

3172

length= max(length, (uint32_t)drizzle_column_max_size(field));

3363

3173

3364

3174

if (length < 4 &&

3365

!(drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_NOT_NULL))

3175

!(drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_NOT_NULL))

3366

3176

{

3367

3177

length= 4; /* Room for "NULL" */

3368

3178

}

3371

3181

}

3372

3182

3373

3183

/**

3374

For a new result, return the max number of characters that any

3375

upcoming row may return.

3376

3377

@param result Pointer to the result to judge

3378

3379

@returns The max number of characters in any row of this result

3184

For a new result, return the max number of characters that any

3185

upcoming row may return.

3186

3187

@param result Pointer to the result to judge

3188

3189

@returns The max number of characters in any row of this result

3380

3190

3381

3191

static int get_result_width(drizzle_result_st *result)

3382

3192

{

3481

3291

drizzle_row_t cur;

3482

3292

uint64_t num_rows;

3483

3293

uint32_t new_code= 0;

3484

FILE *out;

3485

3294

3486

3295

/* Get the warnings */

3487

3296

query= "show warnings";

3501

3310

warning.

3502

3311

3503

3312

if (!cur || (num_rows == 1 &&

3504

error_code == (uint32_t) strtoul(cur[1], NULL, 10)))

3313

error_code == (uint32_t) strtoul(cur[1], NULL, 10)))

3505

3314

{

3506

3315

goto end;

3507

3316

}

3508

3317

3509

3318

/* Print the warnings */

3510

if (status.getBatch())

3511

{

3512

out= stderr;

3513

}

3514

else

3515

{

3516

init_pager();

3517

out= PAGER;

3518

}

3319

init_pager();

3519

3320

3520

3321

{

3521

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

3322

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

3522

3323

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

3523

3524

if (not status.getBatch())

3525

end_pager();

3324

end_pager();

3526

3325

3527

3326

end:

3528

3327

drizzle_result_free(&result);

3541

3340

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

3542

3341

{

3543

3342

int l;

3544

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

3343

if (use_mb(charset_info) &&

3344

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

3545

3345

{

3546

3346

while (l--)

3547

3347

tee_putc(*pos++, PAGER);

3570

3370

drizzle_return_t ret;

3571

3371

drizzle_column_st *field;

3572

3372

size_t *lengths;

3573

std::vector<bool> boolean_flag;

3574

std::vector<bool> ansi_boolean_flag;

3575

3576

boolean_flag.resize(drizzle_result_column_count(result));

3577

ansi_boolean_flag.resize(drizzle_result_column_count(result));

3578

3579

int first=0;

3580

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

3373

3374

if (opt_silent < 2 && column_names)

3581

3375

{

3582

if (opt_silent < 2 && column_names)

3376

int first=0;

3377

while ((field = drizzle_column_next(result)))

3583

3378

{

3584

3379

if (first++)

3585

3380

(void) tee_fputs("\t", PAGER);

3586

3381

(void) tee_fputs(drizzle_column_name(field), PAGER);

3587

3382

}

3588

if ((server_type == ServerDetect::SERVER_DRIZZLE_FOUND) and

3589

(drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_TINY))

3590

{

3591

if ((drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_UNSIGNED))

3592

{

3593

ansi_boolean_flag[off]= true;

3594

}

3595

else

3596

{

3597

ansi_boolean_flag[off]= false;

3598

}

3599

boolean_flag[off]= true;

3600

}

3601

else

3602

{

3603

boolean_flag[off]= false;

3604

}

3605

}

3606

if (opt_silent < 2 && column_names)

3607

{

3608

3383

(void) tee_fputs("\n", PAGER);

3609

3384

}

3610

3385

while (1)

3625

3400

break;

3626

3401

3627

3402

lengths= drizzle_row_field_sizes(result);

3628

drizzle_column_seek(result, 0);

3629

for (uint32_t off=0 ; off < drizzle_result_column_count(result); off++)

3403

safe_put_field(cur[0],lengths[0]);

3404

for (uint32_t off=1 ; off < drizzle_result_column_count(result); off++)

3630

3405

{

3631

if (off != 0)

3632

(void) tee_fputs("\t", PAGER);

3633

if (boolean_flag[off])

3634

{

3635

if (strncmp(cur[off],"1", 1) == 0)

3636

{

3637

if (ansi_boolean_flag[off])

3638

{

3639

safe_put_field("YES", 3);

3640

}

3641

else

3642

{

3643

safe_put_field("TRUE", 4);

3644

}

3645

}

3646

else

3647

{

3648

if (ansi_boolean_flag[off])

3649

{

3650

safe_put_field("NO", 2);

3651

}

3652

else

3653

{

3654

safe_put_field("FALSE", 5);

3655

}

3656

}

3657

}

3658

else

3659

{

3660

safe_put_field(cur[off], lengths[off]);

3661

}

3406

(void) tee_fputs("\t", PAGER);

3407

safe_put_field(cur[off], lengths[off]);

3662

3408

}

3663

3409

(void) tee_fputs("\n", PAGER);

3664

3410

if (quick)

3672

3418

char file_name[FN_REFLEN], *end;

3673

3419

const char *param;

3674

3420

3675

if (status.getBatch())

3421

if (status.batch)

3676

3422

return 0;

3677

while (isspace(*line))

3423

while (my_isspace(charset_info,*line))

3678

3424

line++;

3679

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

3425

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

3680

3426

{

3681

if (outfile.empty())

3427

if (!strlen(outfile))

3682

3428

{

3683

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

3429

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

3684

3430

return 0;

3685

3431

}

3686

3432

else if (opt_outfile)

3687

3433

{

3688

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

3434

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

3689

3435

return 0;

3690

3436

}

3691

3437

else

3692

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

3438

param = outfile; //resume using the old outfile

3693

3439

}

3694

3440

3695

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

3696

3441

/* eliminate the spaces before the parameters */

3697

while (isspace(*param))

3442

while (my_isspace(charset_info,*param))

3698

3443

param++;

3699

3444

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

3700

3445

end= file_name + strlen(file_name);

3701

3446

/* remove end space from command line */

3702

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

3703

iscntrl(end[-1])))

3447

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

3448

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

3704

3449

end--;

3705

3450

end[0]= 0;

3706

3451

if (end == file_name)

3707

3452

{

3708

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

3453

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

3709

3454

return 0;

3710

3455

}

3711

3456

init_tee(file_name);

3718

3463

{

3719

3464

if (opt_outfile)

3720

3465

end_tee();

3721

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

3466

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

3722

3467

return 0;

3723

3468

}

3724

3469

3729

3474

static int

3730

3475

com_pager(string *, const char *line)

3731

3476

{

3477

char pager_name[FN_REFLEN], *end;

3732

3478

const char *param;

3733

3479

3734

if (status.getBatch())

3480

if (status.batch)

3735

3481

return 0;

3736

3482

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

3737

while (isspace(*line))

3483

while (my_isspace(charset_info, *line))

3738

3484

line++;

3739

3485

/* Skip the pager command */

3740

3486

param= strchr(line, ' ');

3741

3487

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

3742

while (param && isspace(*param))

3488

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

3743

3489

param++;

3744

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

3490

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

3745

3491

{

3746

3492

if (!default_pager_set)

3747

3493

{

3748

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

3494

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

3749

3495

opt_nopager=1;

3750

pager.assign("stdout");

3496

strcpy(pager, "stdout");

3751

3497

PAGER= stdout;

3752

3498

return 0;

3753

3499

}

3754

pager.assign(default_pager);

3500

strcpy(pager, default_pager);

3755

3501

}

3756

3502

else

3757

3503

{

3758

string pager_name(param);

3759

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

3760

while (end > pager_name.begin() &&

3761

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

3762

--end;

3763

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

3764

pager.assign(pager_name);

3765

default_pager.assign(pager_name);

3504

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

3505

end+= strlen(pager_name);

3506

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

3507

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

3508

end--;

3509

end[0]=0;

3510

strcpy(pager, pager_name);

3511

strcpy(default_pager, pager_name);

3766

3512

}

3767

3513

opt_nopager=0;

3768

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

3514

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

3769

3515

return 0;

3770

3516

}

3771

3517

3773

3519

static int

3774

3520

com_nopager(string *, const char *)

3775

3521

{

3776

pager.assign("stdout");

3522

strcpy(pager, "stdout");

3777

3523

opt_nopager=1;

3778

3524

PAGER= stdout;

3779

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

3525

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

3780

3526

return 0;

3781

3527

}

3782

3528

3786

3532

com_quit(string *, const char *)

3787

3533

{

3788

3534

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

3789

status.setExitStatus(0);

3535

status.exit_status=0;

3790

3536

return 1;

3791

3537

}

3792

3538

3834

3580

tmp= get_arg(buff, 0);

3835

3581

if (tmp && *tmp)

3836

3582

{

3837

current_db.erase();

3838

current_db.assign(tmp);

3583

free(current_db);

3584

current_db= strdup(tmp);

3839

3585

tmp= get_arg(buff, 1);

3840

3586

if (tmp)

3841

3587

{

3842

current_host.erase();

3588

free(current_host);

3843

3589

current_host=strdup(tmp);

3844

3590

}

3845

3591

}

3854

3600

}

3855

3601

else

3856

3602

opt_rehash= 0;

3857

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

3603

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

3858

3604

opt_rehash= save_rehash;

3859

3605

3860

3606

if (connected)

3861

3607

{

3862

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

3608

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

3863

3609

put_info(buff,INFO_INFO,0,0);

3864

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

3865

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

3610

snprintf(buff, sizeof(buff), "Current database: %.128s\n",

3611

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

3866

3612

put_info(buff,INFO_INFO,0,0);

3867

3613

}

3868

3614

return error;

3875

3621

const char *param;

3876

3622

LineBuffer *line_buff;

3877

3623

int error;

3878

Status old_status;

3624

STATUS old_status;

3879

3625

FILE *sql_file;

3880

3626

3881

3627

/* Skip space from file name */

3882

while (isspace(*line))

3628

while (my_isspace(charset_info,*line))

3883

3629

line++;

3884

3630

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

3885

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

3631

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

3886

3632

INFO_ERROR, 0,0);

3887

while (isspace(*param))

3633

while (my_isspace(charset_info,*param))

3888

3634

param++;

3889

3635

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

3890

3636

end+= strlen(source_name);

3891

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

3892

iscntrl(end[-1])))

3637

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

3638

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

3893

3639

end--;

3894

3640

end[0]=0;

3895

3641

internal::unpack_filename(source_name,source_name);

3896

3642

/* open file name */

3897

3643

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

3898

3644

{

3899

3645

char buff[FN_REFLEN+60];

3900

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

3646

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

3901

3647

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

3902

3648

}

3903

3649

3905

3651

if (line_buff == NULL)

3906

3652

{

3907

3653

fclose(sql_file);

3908

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

3654

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

3909

3655

}

3910

3656

3911

3657

/* Save old status */

3913

3659

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

3914

3660

3915

3661

// Run in batch mode

3916

status.setBatch(old_status.getBatch());

3917

status.setLineBuff(line_buff);

3918

status.setFileName(source_name);

3662

status.batch=old_status.batch;

3663

status.line_buff=line_buff;

3664

status.file_name=source_name;

3919

3665

// Empty command buffer

3920

3666

assert(glob_buffer!=NULL);

3921

3667

glob_buffer->clear();

3923

3669

// Continue as before

3924

3670

status=old_status;

3925

3671

fclose(sql_file);

3926

delete status.getLineBuff();

3927

line_buff=0;

3928

status.setLineBuff(0);

3672

delete status.line_buff;

3673

line_buff= status.line_buff= 0;

3929

3674

return error;

3930

3675

}

3931

3676

3941

3686

3942

3687

if (!tmp || !*tmp)

3943

3688

{

3944

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

3689

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

3945

3690

INFO_ERROR, 0, 0);

3946

3691

return 0;

3947

3692

}

3949

3694

{

3950

3695

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

3951

3696

{

3952

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

3697

put_info("DELIMITER cannot contain a backslash character",

3953

3698

INFO_ERROR, 0, 0);

3954

3699

return 0;

3955

3700

}

3974

3719

tmp= get_arg(buff, 0);

3975

3720

if (!tmp || !*tmp)

3976

3721

{

3977

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

3722

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

3978

3723

return 0;

3979

3724

}

3980

3725

3984

3729

3985

3730

get_current_db();

3986

3731

3987

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

3732

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

3988

3733

{

3989

3734

if (one_database)

3990

3735

{

4036

3781

else

4037

3782

drizzle_result_free(&result);

4038

3783

}

4039

current_db.erase();

4040

current_db.assign(tmp);

3784

free(current_db);

3785

current_db= strdup(tmp);

4041

3786

if (select_db > 1)

4042

3787

build_completion_hash(opt_rehash, 1);

4043

3788

}

4044

3789

4045

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

3790

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

4046

3791

return 0;

4047

3792

}

4048

3793

4049

static int com_shutdown(string *, const char *)

4050

{

4051

drizzle_result_st result;

4052

drizzle_return_t ret;

4053

4054

if (verbose)

4055

{

4056

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

4057

if (opt_drizzle_port > 0)

4058

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

4059

printf("... ");

4060

}

4061

4062

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

4063

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

4064

{

4065

if (ret == DRIZZLE_RETURN_ERROR_CODE)

4066

{

4067

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

4068

drizzle_result_error(&result));

4069

drizzle_result_free(&result);

4070

}

4071

else

4072

{

4073

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

4074

drizzle_con_error(&con));

4075

}

4076

return false;

4077

}

4078

4079

drizzle_result_free(&result);

4080

4081

if (verbose)

4082

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

4083

4084

return false;

4085

}

4086

4087

3794

static int

4088

3795

com_warnings(string *, const char *)

4089

3796

{

4090

3797

show_warnings = 1;

4091

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

3798

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

4092

3799

return 0;

4093

3800

}

4094

3801

4096

3803

com_nowarnings(string *, const char *)

4097

3804

{

4098

3805

show_warnings = 0;

4099

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

3806

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

4100

3807

return 0;

4101

3808

}

4102

3809

4126

3833

else

4127

3834

{

4128

3835

/* skip leading white spaces */

4129

while (isspace(*ptr))

3836

while (my_isspace(charset_info, *ptr))

4130

3837

ptr++;

4131

3838

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

4132

3839

ptr+= 2;

4133

3840

else

4134

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

3841

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

4135

3842

ptr++;

4136

3843

}

4137

3844

if (!*ptr)

4138

3845

return NULL;

4139

while (isspace(*ptr))

3846

while (my_isspace(charset_info, *ptr))

4140

3847

ptr++;

4141

3848

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

4142

3849

{

4163

3870

4164

3871

4165

3872

static int

4166

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

3873

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

3874

uint32_t silent)

4167

3875

{

4168

3876

drizzle_return_t ret;

3877

4169

3878

if (connected)

4170

3879

{

4171

3880

connected= 0;

4173

3882

drizzle_free(&drizzle);

4174

3883

}

4175

3884

drizzle_create(&drizzle);

4176

4177

#ifdef DRIZZLE_ADMIN_TOOL

4178

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

4179

#else

4180

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

4181

#endif

4182

4183

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

4184

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

4185

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

4186

options) == NULL)

3885

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

3886

password, database, opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE) == NULL)

4187

3887

{

4188

3888

(void) put_error(&con, NULL);

4189

3889

(void) fflush(stdout);

4190

3890

return 1;

4191

3891

}

4192

3892

4193

/* XXX add this back in

4194

if (opt_connect_timeout)

4195

{

3893

/* XXX add this back in

3894

if (opt_connect_timeout)

3895

{

4196

3896

uint32_t timeout=opt_connect_timeout;

4197

3897

drizzleclient_options(&drizzle,DRIZZLE_OPT_CONNECT_TIMEOUT,

4198

(char*) &timeout);

4199

}

4200

3898

(char*) &timeout);

3899

}

3900

4201

3901

4202

/* XXX Do we need this?

4203

if (safe_updates)

4204

{

3902

/* XXX Do we need this?

3903

if (safe_updates)

3904

{

4205

3905

char init_command[100];

4206

3906

sprintf(init_command,

4207

"SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%"PRIu32

4208

",MAX_JOIN_SIZE=%"PRIu32,

4209

select_limit, max_join_size);

3907

"SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%"PRIu32

3908

",MAX_JOIN_SIZE=%"PRIu32,

3909

select_limit, max_join_size);

4210

3910

drizzleclient_options(&drizzle, DRIZZLE_INIT_COMMAND, init_command);

4211

}

4212

3911

}

3912

4213

3913

if ((ret= drizzle_con_connect(&con)) != DRIZZLE_RETURN_OK)

4214

3914

{

4215

4216

if (opt_silent < 2)

3915

if (!silent || (ret != DRIZZLE_RETURN_GETADDRINFO &&

3916

ret != DRIZZLE_RETURN_COULD_NOT_CONNECT))

4217

3917

{

4218

3918

(void) put_error(&con, NULL);

4219

3919

(void) fflush(stdout);

4223

3923

}

4224

3924

connected=1;

4225

3925

4226

ServerDetect server_detect(&con);

4227

server_type= server_detect.getServerType();

4228

4229

3926

build_completion_hash(opt_rehash, 1);

4230

3927

return 0;

4231

3928

}

4234

3931

static int

4235

3932

com_status(string *, const char *)

4236

3933

{

4237

4238

char buff[40];

4239

uint64_t id;

4240

3934

3935

char buff[40];

3936

uint64_t id;

3937

4241

3938

drizzle_result_st result;

4242

3939

drizzle_return_t ret;

4243

3940

4244

3941

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

4245

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

4246

drizzle_version(), VERSION,

4247

HOST_VENDOR, HOST_OS, HOST_CPU,

4248

rl_library_version);

4249

3942

usage(1); /* Print version */

4250

3943

if (connected)

4251

3944

{

4252

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

3945

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

4253

3946

4254

3947

Don't remove "limit 1",

4255

3948

it is protection againts SQL_SELECT_LIMIT=0

4261

3954

drizzle_row_t cur=drizzle_row_next(&result);

4262

3955

if (cur)

4263

3956

{

4264

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

4265

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

3957

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

3958

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

4266

3959

}

4267

3960

drizzle_result_free(&result);

4268

3961

}

4269

3962

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

4270

3963

drizzle_result_free(&result);

4271

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

3964

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

4272

3965

}

4273

3966

else

4274

3967

{

4275

3968

vidattr(A_BOLD);

4276

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

3969

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

4277

3970

vidattr(A_NORMAL);

4278

3971

return 0;

4279

3972

}

4280

3973

if (skip_updates)

4281

3974

{

4282

3975

vidattr(A_BOLD);

4283

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

3976

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

4284

3977

vidattr(A_NORMAL);

4285

3978

}

4286

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

4287

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

4288

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

4289

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

4290

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

4291

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

4292

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

4293

/* XXX need to save this from result

4294

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

3979

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

3980

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

3981

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

3982

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

3983

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

3984

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

3985

/* XXX need to save this from result

3986

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

4295

3987

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

4296

3988

4297

3989

4298

3990

if (drizzle_con_uds(&con))

4299

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

3991

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

4300

3992

else

4301

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

3993

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

4302

3994

4303

3995

if (safe_updates)

4304

3996

{

4305

3997

vidattr(A_BOLD);

4306

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

3998

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

4307

3999

vidattr(A_NORMAL);

4308

tee_fprintf(stdout, _("\

4309

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

4310

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

4311

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

4312

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

4000

tee_fprintf(stdout, "\

4001

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

4002

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

4003

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

4004

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

4313

4005

select_limit, max_join_size);

4314

4006

}

4315

4007

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

4362

4054

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

4363

4055

static int inited=0;

4364

4056

4365

if (status.getBatch())

4057

if (status.batch)

4366

4058

{

4367

4059

if (info_type == INFO_ERROR)

4368

4060

{

4369

4061

(void) fflush(file);

4370

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

4062

fprintf(file,"ERROR");

4371

4063

if (error)

4372

4064

{

4373

4065

if (sqlstate)

4375

4067

else

4376

4068

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

4377

4069

}

4378

if (status.getQueryStartLine() && line_numbers)

4070

if (status.query_start_line && line_numbers)

4379

4071

{

4380

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

4381

if (status.getFileName())

4382

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

4072

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

4073

if (status.file_name)

4074

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

4383

4075

}

4384

4076

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

4385

4077

(void) fflush(file);

4410

4102

if (error)

4411

4103

{

4412

4104

if (sqlstate)

4413

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

4105

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

4414

4106

else

4415

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

4107

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

4416

4108

}

4417

4109

else

4418

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

4110

tee_puts("ERROR: ", file);

4419

4111

}

4420

4112

else

4421

4113

vidattr(A_BOLD);

4444

4136

4445

4137

return put_info(error, INFO_ERROR,

4446

4138

res == NULL ? drizzle_con_error_code(local_con) :

4447

drizzle_result_error_code(res),

4139

drizzle_result_error_code(res),

4448

4140

res == NULL ? drizzle_con_sqlstate(local_con) :

4449

drizzle_result_sqlstate(res));

4141

drizzle_result_sqlstate(res));

4450

4142

}

4451

4143

4452

4144

4454

4146

{

4455

4147

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

4456

4148

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

4457

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

4149

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

4458

4150

end--;

4459

4151

uint32_t pos_to_truncate= (end-start);

4460

4152

if (buffer->length() > pos_to_truncate)

4506

4198

}

4507

4199

4508

4200

#include <sys/times.h>

4201

#ifdef _SC_CLK_TCK // For mit-pthreads

4202

#undef CLOCKS_PER_SEC

4203

#define CLOCKS_PER_SEC (sysconf(_SC_CLK_TCK))

4204

#endif

4509

4205

4510

static boost::posix_time::ptime start_timer(void)

4206

static uint32_t start_timer(void)

4511

4207

{

4512

return boost::posix_time::microsec_clock::universal_time();

4208

struct tms tms_tmp;

4209

return times(&tms_tmp);

4513

4210

}

4514

4211

4515

static void nice_time(boost::posix_time::time_duration duration, string &buff)

4212

4213

/**

4214

Write as many as 52+1 bytes to buff, in the form of a legible

4215

duration of time.

4216

4217

len("4294967296 days, 23 hours, 59 minutes, 60.00 seconds") -> 52

4218

4219

static void nice_time(double sec,char *buff,bool part_second)

4516

4220

{

4221

uint32_t tmp;

4517

4222

ostringstream tmp_buff_str;

4518

4223

4519

if (duration.hours() > 0)

4520

{

4521

tmp_buff_str << duration.hours();

4522

if (duration.hours() > 1)

4523

tmp_buff_str << _(" hours ");

4524

else

4525

tmp_buff_str << _(" hour ");

4526

}

4527

if (duration.hours() > 0 || duration.minutes() > 0)

4528

{

4529

tmp_buff_str << duration.minutes() << _(" min ");

4530

}

4531

4532

tmp_buff_str.precision(duration.num_fractional_digits());

4533

4534

double seconds= duration.fractional_seconds();

4535

4536

seconds/= pow(10.0,duration.num_fractional_digits());

4537

4538

seconds+= duration.seconds();

4539

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

4540

4541

buff.append(tmp_buff_str.str());

4542

}

4543

4544

static void end_timer(boost::posix_time::ptime start_time, string &buff)

4545

{

4546

boost::posix_time::ptime end_time= start_timer();

4547

boost::posix_time::time_period duration(start_time, end_time);

4548

4549

nice_time(duration.length(), buff);

4550

}

4551

4552

4553

static void drizzle_end_timer(boost::posix_time::ptime start_time, string &buff)

4554

{

4555

buff.append(" (");

4556

end_timer(start_time,buff);

4557

buff.append(")");

4224

if (sec >= 3600.0*24)

4225

{

4226

tmp=(uint32_t) floor(sec/(3600.0*24));

4227

sec-= 3600.0*24*tmp;

4228

tmp_buff_str << tmp;

4229

4230

if (tmp > 1)

4231

tmp_buff_str << " days ";

4232

else

4233

tmp_buff_str << " day ";

4234

4235

}

4236

if (sec >= 3600.0)

4237

{

4238

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

4239

sec-=3600.0*tmp;

4240

tmp_buff_str << tmp;

4241

4242

if (tmp > 1)

4243

tmp_buff_str << " hours ";

4244

else

4245

tmp_buff_str << " hour ";

4246

}

4247

if (sec >= 60.0)

4248

{

4249

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

4250

sec-=60.0*tmp;

4251

tmp_buff_str << tmp << " min ";

4252

}

4253

if (part_second)

4254

tmp_buff_str.precision(2);

4255

else

4256

tmp_buff_str.precision(0);

4257

tmp_buff_str << sec << " sec";

4258

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

4259

}

4260

4261

4262

static void end_timer(uint32_t start_time,char *buff)

4263

{

4264

nice_time((double) (start_timer() - start_time) /

4265

CLOCKS_PER_SEC,buff,1);

4266

}

4267

4268

4269

static void drizzle_end_timer(uint32_t start_time,char *buff)

4270

{

4271

buff[0]=' ';

4272

buff[1]='(';

4273

end_timer(start_time,buff+2);

4274

strcpy(strchr(buff, '\0'),")");

4558

4275

}

4559

4276

4560

4277

static const char * construct_prompt()

4568

4285

struct tm *t = localtime(&lclock);

4569

4286

4570

4287

/* parse thru the settings for the prompt */

4571

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

4572

while (c != current_prompt.end())

4288

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

4573

4289

{

4574

4290

if (*c != PROMPT_CHAR)

4575

4291

{

4576

processed_prompt->push_back(*c);

4292

processed_prompt->append(c, 1);

4577

4293

}

4578

4294

else

4579

4295

{

4584

4300

switch (*++c) {

4585

4301

case '\0':

4586

4302

// stop it from going beyond if ends with %

4587

--c;

4303

c--;

4588

4304

break;

4589

4305

case 'c':

4590

4306

add_int_to_prompt(++prompt_counter);

4596

4312

processed_prompt->append("not_connected");

4597

4313

break;

4598

4314

case 'd':

4599

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

4315

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

4600

4316

break;

4601

4317

case 'h':

4602

{

4603

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

4604

if (strstr(prompt, "Localhost"))

4605

processed_prompt->append("localhost");

4606

else

4607

4318

{

4608

const char *end=strrchr(prompt,' ');

4609

if (end != NULL)

4610

processed_prompt->append(prompt, (end-prompt));

4319

const char *prompt;

4320

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

4321

if (strstr(prompt, "Localhost"))

4322

processed_prompt->append("localhost");

4323

else

4324

{

4325

const char *end=strrchr(prompt,' ');

4326

if (end != NULL)

4327

processed_prompt->append(prompt, (end-prompt));

4328

}

4329

break;

4611

4330

}

4612

break;

4613

}

4614

4331

case 'p':

4615

{

4616

if (!connected)

4617

4332

{

4618

processed_prompt->append("not_connected");

4619

break;

4620

}

4333

if (!connected)

4334

{

4335

processed_prompt->append("not_connected");

4336

break;

4337

}

4621

4338

4622

if (drizzle_con_uds(&con))

4623

{

4624

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

4625

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

4339

if (drizzle_con_uds(&con))

4340

{

4341

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

4342

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

4343

}

4344

else

4345

add_int_to_prompt(drizzle_con_port(&con));

4626

4346

}

4627

else

4628

add_int_to_prompt(drizzle_con_port(&con));

4629

}

4630

break;

4347

break;

4631

4348

case 'U':

4632

4349

if (!full_username)

4633

4350

init_username();

4634

4351

processed_prompt->append(full_username ? full_username :

4635

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

4352

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

4636

4353

break;

4637

4354

case 'u':

4638

4355

if (!full_username)

4639

4356

init_username();

4640

4357

processed_prompt->append(part_username ? part_username :

4641

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

4358

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

4642

4359

break;

4643

4360

case PROMPT_CHAR:

4644

4361

{

4693

4410

add_int_to_prompt(t->tm_sec);

4694

4411

break;

4695

4412

case 'w':

4696

processed_prompt->append(get_day_name(t->tm_wday));

4413

processed_prompt->append(day_names[t->tm_wday]);

4697

4414

break;

4698

4415

case 'P':

4699

4416

processed_prompt->append(t->tm_hour < 12 ? "am" : "pm");

4702

4419

add_int_to_prompt(t->tm_mon+1);

4703

4420

break;

4704

4421

case 'O':

4705

processed_prompt->append(get_month_name(t->tm_mon));

4422

processed_prompt->append(month_names[t->tm_mon]);

4706

4423

break;

4707

4424

case '\'':

4708

4425

processed_prompt->append("'");

4720

4437

processed_prompt->append(delimiter_str);

4721

4438

break;

4722

4439

default:

4723

processed_prompt->push_back(*c);

4440

processed_prompt->append(c, 1);

4724

4441

}

4725

4442

}

4726

++c;

4727

4443

}

4728

4444

return processed_prompt->c_str();

4729

4445

}

4738

4454

4739

4455

static void init_username()

4740

4456

{

4741

/* XXX need this?

4742

free(full_username);

4743

free(part_username);

4457

/* XXX need this?

4458

free(full_username);

4459

free(part_username);

4744

4460

4745

drizzle_result_st *result;

4746

if (!drizzleclient_query(&drizzle,"select USER()") &&

4747

(result=drizzleclient_use_result(&drizzle)))

4748

{

4461

drizzle_result_st *result;

4462

if (!drizzleclient_query(&drizzle,"select USER()") &&

4463

(result=drizzleclient_use_result(&drizzle)))

4464

{

4749

4465

drizzle_row_t cur=drizzleclient_fetch_row(result);

4750

4466

full_username= strdup(cur[0]);

4751

4467

part_username= strdup(strtok(cur[0],"@"));

4752

4468

(void) drizzleclient_fetch_row(result); // Read eof

4753

}

4754

4469

}

4470

4755

4471

}

4756

4472

4757

4473

static int com_prompt(string *, const char *line)

4758

4474

{

4759

4475

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

4760

4476

if (ptr == NULL)

4761

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

4477

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

4762

4478

default_prompt);

4763

4479

prompt_counter = 0;

4764

4480

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

4765

4481

if (tmpptr == NULL)

4766

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

4482

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

4767

4483

else

4768

4484

{

4769

current_prompt.erase();

4485

free(current_prompt);

4770

4486

current_prompt= tmpptr;

4771

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

4487

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

4772

4488

}

4773

4489

return 0;

4774

4490

}

4775

4491

4776

4492

4777

strcont(str, set) if str contanies any character in the string set.

4778

The result is the position of the first found character in str, or NULL

4779

if there isn't anything found.

4493

strcont(str, set) if str contanies any character in the string set.

4494

The result is the position of the first found character in str, or NULL

4495

if there isn't anything found.

4780

4496

4781

4497

4782

static const char * strcont(const char *str, const char *set)

4498

static const char * strcont(register const char *str, register const char *set)

4783

4499

{

4784

const char * start = (const char *) set;

4500

4785

4501

4786

4502

while (*str)

4787

4503

{

Older »