~drizzle-trunk/drizzle/development

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

1302

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

1303

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

1304

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

1305

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

1306

("skip-column-names,N",

1307

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

1308

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

1309

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

1310

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

1311

N_("Output in table format."))

1312

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

1313

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

1314

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

1315

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

1316

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

1317

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

1318

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

1319

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

1320

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

1321

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

1322

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

1323

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

1324

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

1325

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

1326

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

1327

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

1328

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

1329

;

1330

1331

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

1332

drizzle_options.add_options()

1333

("disable-auto-rehash,A",

1334

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

1335

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

1336

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

1337

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

1338

N_("Database to use."))

1339

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

1340

N_("(not used)"))

1341

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

1342

N_("Delimiter to be used."))

1343

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

1344

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

1345

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

1346

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

1347

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

1348

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

1349

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

1350

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

1351

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

1352

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

1353

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

1354

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

1355

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

1356

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

1357

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

1358

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

1359

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

1360

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

1361

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

1362

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

1363

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

1364

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

1365

N_("Shutdown the server"))

1366

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

1367

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

1368

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

1369

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

1370

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

1371

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

1372

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

1373

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

1374

N_("Max length of input line"))

1375

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

1376

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

1377

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

1378

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

1379

;

1380

1381

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

1382

client_options.add_options()

1383

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

1384

N_("Connect to host"))

1385

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

1386

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

1387

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

1388

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

1389

#ifdef DRIZZLE_ADMIN_TOOL

1390

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

1391

#else

1392

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

1393

#endif

1394

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

1395

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

1396

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

1397

;

1398

1399

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

1400

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

1401

1402

std::string system_config_dir_drizzle(SYSCONFDIR);

1403

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

1404

1405

std::string system_config_dir_client(SYSCONFDIR);

1406

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

1407

1408

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

1409

1410

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

1411

{

1412

char *homedir;

1413

homedir= getenv("HOME");

1414

if (homedir != NULL)

1415

user_config_dir.replace(0, 1, homedir);

1416

}

1417

1418

po::variables_map vm;

1419

1420

po::positional_options_description p;

1421

p.add("database", 1);

1422

1423

// Disable allow_guessing

1424

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

1425

1426

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

1427

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

1428

vm);

1429

1430

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

1431

{

1432

std::string user_config_dir_drizzle(user_config_dir);

1433

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

1434

1435

std::string user_config_dir_client(user_config_dir);

1436

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

1437

1438

ifstream user_drizzle_ifs(user_config_dir_drizzle.c_str());

1439

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

1440

1441

ifstream user_client_ifs(user_config_dir_client.c_str());

1442

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

1443

1444

ifstream system_drizzle_ifs(system_config_dir_drizzle.c_str());

1445

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

1446

1447

ifstream system_client_ifs(system_config_dir_client.c_str());

1448

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

1449

}

1450

1451

po::notify(vm);

1452

1453

#ifdef DRIZZLE_ADMIN_TOOL

1454

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1455

getenv("DRIZZLE_PS1") :

1456

"drizzleadmin> ");

1457

#else

1157

MY_INIT(argv[0]);

1158

delimiter_str= delimiter;

1458

1159

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1459

1160

getenv("DRIZZLE_PS1") :

1460

1161

"drizzle> ");

1461

#endif

1162

1462

1163

if (default_prompt == NULL)

1463

1164

{

1464

1165

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

1466

1167

exit(ENOMEM);

1467

1168

}

1468

1169

current_prompt= strdup(default_prompt);

1469

if (current_prompt.empty())

1170

if (current_prompt == NULL)

1470

1171

{

1471

1172

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

1472

1173

"prompt. Aborting.\n"));

1477

1178

1478

1179

prompt_counter=0;

1479

1180

1480

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

1481

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

1181

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

1182

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

1482

1183

{

1483

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

1184

char *tmp=getenv("PAGER");

1484

1185

if (tmp && strlen(tmp))

1485

1186

{

1486

1187

default_pager_set= 1;

1487

default_pager.assign(tmp);

1188

strcpy(default_pager, tmp);

1488

1189

}

1489

1190

}

1490

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

1191

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

1491

1192

{

1492

status.setBatch(1); opt_silent=1;

1193

status.batch=1; opt_silent=1;

1493

1194

ignore_errors=0;

1494

1195

}

1495

1196

else

1496

status.setAddToHistory(1);

1497

status.setExitStatus(1);

1197

status.add_to_history=1;

1198

status.exit_status=1;

1498

1199

1499

1200

{

1500

1201

1510

1211

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

1511

1212

}

1512

1213

1513

/* Inverted Booleans */

1514

1515

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

1516

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

1517

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

1518

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

1519

1520

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

1521

if (vm.count("shutdown"))

1522

{

1523

opt_rehash= false;

1524

opt_shutdown= true;

1525

}

1526

1527

if (vm.count("delimiter"))

1528

{

1529

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

1530

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

1531

{

1532

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

1533

}

1534

else

1535

{

1536

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

1537

INFO_ERROR,0,0);

1538

exit(-1);

1539

}

1540

1541

delimiter_length= (uint32_t)strlen(delimiter);

1542

}

1543

if (vm.count("tee"))

1544

{

1545

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

1546

{

1547

if (opt_outfile)

1548

end_tee();

1549

}

1550

else

1551

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

1552

}

1553

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

1554

{

1555

if (opt_outfile)

1556

end_tee();

1557

}

1558

if (vm.count("pager"))

1559

{

1560

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

1561

opt_nopager= 1;

1562

else

1563

{

1564

opt_nopager= 0;

1565

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

1566

{

1567

default_pager_set= 1;

1568

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

1569

default_pager.assign(pager);

1570

}

1571

else if (default_pager_set)

1572

pager.assign(default_pager);

1573

else

1574

opt_nopager= 1;

1575

}

1576

}

1577

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

1578

{

1579

opt_nopager= 1;

1580

}

1581

1582

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

1583

opt_rehash= 0;

1584

1585

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

1586

column_names= 0;

1587

1588

if (vm.count("execute"))

1589

{

1590

status.setBatch(1);

1591

status.setAddToHistory(1);

1592

if (status.getLineBuff() == NULL)

1593

status.setLineBuff(opt_max_input_line,NULL);

1594

if (status.getLineBuff() == NULL)

1595

{

1596

exit(1);

1597

}

1598

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

1599

}

1600

1601

if (one_database)

1602

skip_updates= true;

1603

1604

if (vm.count("protocol"))

1605

{

1606

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

1607

opt_protocol.begin(), ::tolower);

1608

1609

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

1610

use_drizzle_protocol=false;

1611

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

1612

use_drizzle_protocol=true;

1613

else

1614

{

1615

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

1616

exit(-1);

1617

}

1618

}

1619

1620

if (vm.count("port"))

1621

{

1622

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

1623

1624

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

1625

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

1626

uint32_t. */

1627

if (opt_drizzle_port > 65535)

1628

{

1629

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

1630

exit(-1);

1631

}

1632

}

1633

1634

if (vm.count("password"))

1635

{

1636

if (!opt_password.empty())

1637

opt_password.erase();

1638

if (current_password == PASSWORD_SENTINEL)

1639

{

1640

opt_password= "";

1641

}

1642

else

1643

{

1644

opt_password= current_password;

1645

tty_password= false;

1646

}

1647

}

1648

else

1649

{

1650

tty_password= true;

1651

}

1652

1653

1654

if (!opt_verbose.empty())

1655

{

1656

verbose= opt_verbose.length();

1657

}

1658

1659

if (vm.count("batch"))

1660

{

1661

status.setBatch(1);

1662

status.setAddToHistory(0);

1663

if (opt_silent < 1)

1664

{

1665

opt_silent= 1;

1666

}

1667

}

1668

if (vm.count("silent"))

1669

{

1670

opt_silent++;

1671

}

1672

1673

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

1674

{

1675

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

1676

drizzle_version(), VERSION,

1677

HOST_VENDOR, HOST_OS, HOST_CPU,

1678

rl_library_version);

1679

if (vm.count("version"))

1680

exit(0);

1681

1682

"This software comes with ABSOLUTELY NO WARRANTY. "

1683

"This is free software,\n"

1684

"and you are welcome to modify and redistribute it "

1685

"under the GPL license\n"));

1686

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

1687

cout << long_options;

1688

exit(0);

1689

}

1690

1691

1692

if (process_options())

1693

{

1214

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

1215

defaults_argv=argv;

1216

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

1217

{

1218

free_defaults(defaults_argv);

1219

my_end(0);

1694

1220

exit(1);

1695

1221

}

1696

1222

1697

1223

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

1698

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

1224

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

1225

opt_silent))

1699

1226

{

1700

1227

quick= 1; // Avoid history

1701

status.setExitStatus(1);

1228

status.exit_status= 1;

1702

1229

drizzle_end(-1);

1703

1230

}

1704

1231

1706

1233

if (execute_commands(&command_error) != false)

1707

1234

{

1708

1235

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

1236

free_defaults(defaults_argv);

1237

my_end(0);

1709

1238

exit(command_error);

1710

1239

}

1711

1240

1712

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

1241

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

1713

1242

{

1714

status.setLineBuff(opt_max_input_line, stdin);

1715

if (status.getLineBuff() == NULL)

1243

status.line_buff =batch_readline_init(opt_max_input_line+512, stdin);

1244

if (status.line_buff == NULL)

1716

1245

{

1246

free_defaults(defaults_argv);

1247

my_end(0);

1717

1248

exit(1);

1718

1249

}

1719

1250

}

1720

1251

1721

if (!status.getBatch())

1252

if (!status.batch)

1722

1253

ignore_errors=1; // Don't abort monitor

1723

1254

1724

1255

if (opt_sigint_ignore)

1733

1264

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

1734

1265

window_resize(0);

1735

1266

#endif

1736

std::vector<char> output_buff;

1737

output_buff.resize(512);

1738

1739

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

1740

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

1741

delimiter);

1742

1743

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

1267

1268

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

1269

INFO_INFO,0,0);

1744

1270

1745

1271

glob_buffer= new string();

1746

1272

glob_buffer->reserve(512);

1747

1273

1748

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

1749

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

1274

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

1275

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

1276

1277

sprintf(output_buff,

1278

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

1750

1279

drizzle_con_thread_id(&con),

1751

opt_protocol.c_str(),

1752

1280

server_version_string(&con));

1753

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

1754

1755

1756

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

1757

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

1281

put_info(output_buff, INFO_INFO, 0, 0);

1282

1283

initialize_readline(current_prompt);

1284

if (!status.batch && !quick)

1758

1285

{

1759

1286

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

1760

1287

if (getenv("DRIZZLE_HISTFILE"))

1790

1317

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

1791

1318

}

1792

1319

}

1320

sprintf(buff, "%s",

1321

_("Type 'help;' or '\\h' for help. Type '\\c' to clear the buffer.\n"));

1793

1322

1794

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

1795

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

1796

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

1323

put_info(buff,INFO_INFO,0,0);

1324

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

1797

1325

if (opt_outfile)

1798

1326

end_tee();

1799

1327

drizzle_end(0);

1800

}

1801

1328

1802

catch(exception &err)

1803

{

1804

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

1805

}

1806

1329

return(0); // Keep compiler happy

1807

1330

}

1808

1331

1810

1333

{

1811

1334

drizzle_con_free(&con);

1812

1335

drizzle_free(&drizzle);

1813

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

1336

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

1814

1337

{

1815

1338

/* write-history */

1816

1339

if (verbose)

1817

1340

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

1818

1341

if (!write_history(histfile_tmp))

1819

rename(histfile_tmp, histfile);

1342

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

1820

1343

}

1821

delete status.getLineBuff();

1822

status.setLineBuff(0);

1344

batch_readline_end(status.line_buff);

1823

1345

1824

1346

if (sig >= 0)

1825

1347

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

1826

delete glob_buffer;

1827

delete processed_prompt;

1828

opt_password.erase();

1348

if (glob_buffer)

1349

delete glob_buffer;

1350

if (processed_prompt)

1351

delete processed_prompt;

1352

free(opt_password);

1353

free(opt_drizzle_unix_port);

1829

1354

free(histfile);

1830

1355

free(histfile_tmp);

1831

current_db.erase();

1832

current_host.erase();

1833

current_user.erase();

1356

free(current_db);

1357

free(current_host);

1358

free(current_user);

1834

1359

free(full_username);

1835

1360

free(part_username);

1836

1361

free(default_prompt);

1837

current_prompt.erase();

1838

exit(status.getExitStatus());

1362

free(current_prompt);

1363

free_defaults(defaults_argv);

1364

my_end(my_end_arg);

1365

exit(status.exit_status);

1839

1366

}

1840

1367

1841

1368

1848

1375

void handle_sigint(int sig)

1849

1376

{

1850

1377

char kill_buffer[40];

1851

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

1378

drizzle_con_st kill_drizzle;

1852

1379

drizzle_result_st res;

1853

1380

drizzle_return_t ret;

1854

1381

1857

1384

goto err;

1858

1385

}

1859

1386

1860

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

1861

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

1862

use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)

1387

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

1388

opt_drizzle_port, current_user, opt_password, NULL,

1389

DRIZZLE_CON_NONE) == NULL)

1863

1390

{

1864

1391

goto err;

1865

1392

}

1868

1395

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

1869

1396

drizzle_con_thread_id(&con));

1870

1397

1871

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

1398

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

1872

1399

drizzle_result_free(&res);

1873

1400

1874

drizzle_con_free(kill_drizzle.get());

1401

drizzle_con_free(&kill_drizzle);

1875

1402

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

1876

1403

1877

1404

interrupted_query= 1;

1893

1420

}

1894

1421

#endif

1895

1422

1896

1897

1898

static int process_options(void)

1423

static struct my_option my_long_options[] =

1424

{

1425

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

1426

0, 0, 0, 0, 0},

1427

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

1428

0, 0, 0, 0, 0},

1429

{"auto-rehash", OPT_AUTO_REHASH,

1430

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

1431

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

1432

0, 0},

1433

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

1434

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

1435

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

1436

{"auto-vertical-output", OPT_AUTO_VERTICAL_OUTPUT,

1437

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

1438

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

1439

{"batch", 'B',

1440

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

1441

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

1442

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

1443

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

1444

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

1445

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

1446

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

1447

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

1448

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

1449

0, 0, 0},

1450

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

1451

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

1452

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

1453

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

1454

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

1455

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

1456

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

1457

{"default-character-set", OPT_DEFAULT_CHARSET,

1458

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

1459

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

1460

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

1461

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

1462

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

1463

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

1464

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

1465

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

1466

0},

1467

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

1468

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

1469

0, 0, 0, 0},

1470

{"named-commands", 'G',

1471

1472

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

1473

0, 0},

1474

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

1475

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

1476

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

1477

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

1478

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

1479

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

1480

(char**) &opt_local_infile,

1481

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

1482

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

1483

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

1484

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

1485

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

1486

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

1487

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

1488

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

1489

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

1490

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

1491

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

1492

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

1493

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

1494

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

1495

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

1496

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

1497

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

1498

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

1499

{"set-variable", 'O',

1500

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

1501

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

1502

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

1503

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

1504

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

1505

{"one-database", 'o',

1506

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

1507

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

1508

{"pager", OPT_PAGER,

1509

1510

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

1511

{"no-pager", OPT_NOPAGER,

1512

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

1513

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

1514

{"password", 'P',

1515

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

1516

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

1517

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

1518

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

1519

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

1520

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

1521

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

1522

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

1523

{"quick", 'q',

1524

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

1525

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

1526

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

1527

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

1528

0, 0, 0},

1529

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

1530

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

1531

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

1532

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

1533

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

1534

0, 0},

1535

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

1536

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

1537

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

1538

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

1539

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

1540

{"tee", OPT_TEE,

1541

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

1542

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

1543

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

1544

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

1545

#ifndef DONT_ALLOW_USER_CHANGE

1546

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

1547

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

1548

#endif

1549

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

1550

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

1551

0, 0, 0, 0},

1552

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

1553

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

1554

0, 0, 0, 0},

1555

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

1556

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

1557

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

1558

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

1559

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

1560

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

1561

{"connect_timeout", OPT_CONNECT_TIMEOUT,

1562

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

1563

(char**) &opt_connect_timeout,

1564

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

1565

0, 0},

1566

{"max_input_line", OPT_MAX_INPUT_LINE,

1567

N_("Max length of input line"),

1568

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

1569

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

1570

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

1571

{"select_limit", OPT_SELECT_LIMIT,

1572

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

1573

(char**) &select_limit,

1574

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

1575

0, 1, 0},

1576

{"max_join_size", OPT_MAX_JOIN_SIZE,

1577

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

1578

(char**) &max_join_size,

1579

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

1580

0, 1, 0},

1581

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

1582

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

1583

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

1584

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

1585

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

1586

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

1587

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

1588

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

1589

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

1590

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

1591

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

1592

};

1593

1594

1595

static void usage(int version)

1596

{

1597

const char* readline= "readline";

1598

1599

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

1600

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

1601

SYSTEM_TYPE, MACHINE_TYPE,

1602

readline, rl_library_version);

1603

1604

if (version)

1605

return;

1606

1607

"This software comes with ABSOLUTELY NO WARRANTY. "

1608

"This is free software,\n"

1609

"and you are welcome to modify and redistribute it "

1610

"under the GPL license\n"));

1611

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

1612

my_print_help(my_long_options);

1613

print_defaults("drizzle", load_default_groups);

1614

my_print_variables(my_long_options);

1615

}

1616

1617

1618

extern "C" bool

1619

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

1620

{

1621

char *endchar= NULL;

1622

uint64_t temp_drizzle_port= 0;

1623

1624

switch(optid) {

1625

case OPT_DEFAULT_CHARSET:

1626

default_charset_used= 1;

1627

break;

1628

case OPT_DELIMITER:

1629

if (argument == disabled_my_option)

1630

{

1631

strcpy(delimiter, DEFAULT_DELIMITER);

1632

}

1633

else

1634

{

1635

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

1636

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

1637

{

1638

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

1639

}

1640

else

1641

{

1642

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

1643

INFO_ERROR,0,0);

1644

return false;

1645

}

1646

}

1647

delimiter_length= (uint32_t)strlen(delimiter);

1648

delimiter_str= delimiter;

1649

break;

1650

case OPT_TEE:

1651

if (argument == disabled_my_option)

1652

{

1653

if (opt_outfile)

1654

end_tee();

1655

}

1656

else

1657

init_tee(argument);

1658

break;

1659

case OPT_NOTEE:

1660

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

1661

if (opt_outfile)

1662

end_tee();

1663

break;

1664

case OPT_PAGER:

1665

if (argument == disabled_my_option)

1666

opt_nopager= 1;

1667

else

1668

{

1669

opt_nopager= 0;

1670

if (argument && strlen(argument))

1671

{

1672

default_pager_set= 1;

1673

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

1674

strcpy(default_pager, pager);

1675

}

1676

else if (default_pager_set)

1677

strcpy(pager, default_pager);

1678

else

1679

opt_nopager= 1;

1680

}

1681

break;

1682

case OPT_NOPAGER:

1683

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

1684

opt_nopager= 1;

1685

break;

1686

case OPT_SERVER_ARG:

1687

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

1688

break;

1689

case 'A':

1690

opt_rehash= 0;

1691

break;

1692

case 'N':

1693

column_names= 0;

1694

break;

1695

case 'e':

1696

status.batch= 1;

1697

status.add_to_history= 0;

1698

if (!status.line_buff)

1699

ignore_errors= 0; // do it for the first -e only

1700

if (!(status.line_buff= batch_readline_command(status.line_buff, argument)))

1701

return 1;

1702

break;

1703

case 'o':

1704

if (argument == disabled_my_option)

1705

one_database= 0;

1706

else

1707

one_database= skip_updates= 1;

1708

break;

1709

case 'p':

1710

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

1711

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

1712

if (strlen(endchar) != 0)

1713

{

1714

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

1715

return false;

1716

}

1717

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

1718

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

1719

uint32_t. */

1720

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

1721

{

1722

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

1723

return false;

1724

}

1725

else

1726

{

1727

opt_drizzle_port= (uint32_t) temp_drizzle_port;

1728

}

1729

break;

1730

case 'P':

1731

/* Don't require password */

1732

if (argument == disabled_my_option)

1733

{

1734

argument= (char*) "";

1735

}

1736

if (argument)

1737

{

1738

char *start= argument;

1739

free(opt_password);

1740

opt_password= strdup(argument);

1741

while (*argument)

1742

{

1743

/* Overwriting password with 'x' */

1744

*argument++= 'x';

1745

}

1746

if (*start)

1747

{

1748

start[1]= 0;

1749

}

1750

tty_password= 0;

1751

}

1752

else

1753

{

1754

tty_password= 1;

1755

}

1756

break;

1757

case 's':

1758

if (argument == disabled_my_option)

1759

opt_silent= 0;

1760

else

1761

opt_silent++;

1762

break;

1763

case 'v':

1764

if (argument == disabled_my_option)

1765

verbose= 0;

1766

else

1767

verbose++;

1768

break;

1769

case 'B':

1770

status.batch= 1;

1771

status.add_to_history= 0;

1772

set_if_bigger(opt_silent,1); // more silent

1773

break;

1774

case 'V':

1775

usage(1);

1776

exit(0);

1777

case 'I':

1778

case '?':

1779

usage(0);

1780

exit(0);

1781

}

1782

return 0;

1783

}

1784

1785

1786

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

1899

1787

{

1900

1788

char *tmp, *pagpoint;

1901

1789

int ho_error;

1902

1790

1903

1791

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

1904

1792

if (tmp)

1905

current_host.assign(tmp);

1793

current_host= strdup(tmp);

1906

1794

1907

1795

pagpoint= getenv("PAGER");

1908

1796

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

1909

1797

{

1910

pager.assign("stdout");

1798

strcpy(pager, "stdout");

1911

1799

opt_nopager= 1;

1912

1800

}

1913

1801

else

1914

{

1915

pager.assign(pagpoint);

1916

}

1917

default_pager.assign(pager);

1918

1919

1920

1921

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

1922

{

1923

default_pager.assign("stdout");

1924

pager.assign("stdout");

1802

strcpy(pager, pagpoint);

1803

strcpy(default_pager, pager);

1804

1805

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

1806

exit(ho_error);

1807

1808

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

1809

{

1810

strcpy(default_pager, "stdout");

1811

strcpy(pager, "stdout");

1925

1812

opt_nopager= 1;

1926

1813

default_pager_set= 0;

1927

1814

opt_outfile= 0;

1929

1816

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

1930

1817

}

1931

1818

1819

if (argc > 1)

1820

{

1821

usage(0);

1822

exit(1);

1823

}

1824

if (argc == 1)

1825

{

1826

skip_updates= 0;

1827

free(current_db);

1828

current_db= strdup(*argv);

1829

}

1932

1830

if (tty_password)

1933

1831

opt_password= client_get_tty_password(NULL);

1832

if (debug_info_flag)

1833

my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;

1834

if (debug_check_flag)

1835

my_end_arg= MY_CHECK_ERROR;

1934

1836

return(0);

1935

1837

}

1936

1838

1940

1842

char in_string=0;

1941

1843

uint32_t line_number=0;

1942

1844

bool ml_comment= 0;

1943

Commands *com;

1944

status.setExitStatus(1);

1845

COMMANDS *com;

1846

status.exit_status=1;

1945

1847

1946

1848

for (;;)

1947

1849

{

1948

1850

if (!interactive)

1949

1851

{

1950

if (status.getLineBuff())

1951

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

1952

else

1953

line= 0;

1954

1852

line=batch_readline(status.line_buff);

1853

1854

Skip UTF8 Byte Order Marker (BOM) 0xEFBBBF.

1855

Editors like "notepad" put this marker in

1856

the very beginning of a text file when

1857

you save the file using "Unicode UTF-8" format.

1858

1859

if (!line_number &&

1860

(unsigned char) line[0] == 0xEF &&

1861

(unsigned char) line[1] == 0xBB &&

1862

(unsigned char) line[2] == 0xBF)

1863

line+= 3;

1955

1864

line_number++;

1956

1865

if (show_progress_size > 0)

1957

1866

{

1959

1868

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

1960

1869

}

1961

1870

if (!glob_buffer->empty())

1962

status.setQueryStartLine(line_number);

1871

status.query_start_line=line_number;

1963

1872

}

1964

1873

else

1965

1874

{

1966

string prompt(ml_comment

1967

? " /*> "

1968

: glob_buffer->empty()

1969

? construct_prompt()

1970

: not in_string

1971

? " -> "

1972

: in_string == '\''

1973

? " '> "

1974

: in_string == '`'

1975

? " `> "

1976

: " \"> ");

1875

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

1876

(glob_buffer->empty())

1877

? construct_prompt()

1878

: !in_string ? " -> " :

1879

in_string == '\'' ?

1880

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

1881

" `> " :

1882

" \"> "));

1977

1883

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

1978

1884

fflush(OUTFILE);

1979

1885

1980

1886

if (opt_outfile)

1981

fputs(prompt.c_str(), OUTFILE);

1982

line= readline(prompt.c_str());

1887

fputs(prompt, OUTFILE);

1888

line= readline(prompt);

1983

1889

1984

1890

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

1985

1891

which may cause coredump.

1990

1896

// End of file

1991

1897

if (!line)

1992

1898

{

1993

status.setExitStatus(0);

1899

status.exit_status=0;

1994

1900

break;

1995

1901

}

1996

1902

2006

1912

// If buffer was emptied

2007

1913

if (glob_buffer->empty())

2008

1914

in_string=0;

2009

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

1915

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

2010

1916

add_history(line);

2011

1917

continue;

2012

1918

}

2015

1921

}

2016

1922

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

2017

1923

2018

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

1924

if (!interactive && !status.exit_status)

2019

1925

{

2020

1926

remove_cntrl(glob_buffer);

2021

1927

if (!glob_buffer->empty())

2022

1928

{

2023

status.setExitStatus(1);

1929

status.exit_status=1;

2024

1930

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

2025

status.setExitStatus(0);

1931

status.exit_status=0;

2026

1932

}

2027

1933

}

2028

1934

2029

return status.getExitStatus();

1935

return status.exit_status;

2030

1936

}

2031

1937

2032

1938

2033

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

1939

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

2034

1940

{

2035

1941

uint32_t len;

2036

1942

const char *end;

2042

1948

}

2043

1949

else

2044

1950

{

2045

while (isspace(*name))

1951

while (my_isspace(charset_info,*name))

2046

1952

name++;

2047

1953

2048

1954

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

2051

1957

2052

1958

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

2053

1959

!(strlen(name) >= 9 &&

2054

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

2055

return(NULL);

1960

!my_strnncoll(charset_info,

1961

(unsigned char*) name, 9,

1962

(const unsigned char*) "delimiter",

1963

9))))

1964

return((COMMANDS *) 0);

2056

1965

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

2057

1966

{

2058

1967

len=(uint32_t) (end - name);

2059

while (isspace(*end))

1968

while (my_isspace(charset_info,*end))

2060

1969

end++;

2061

1970

if (!*end)

2062

1971

end=0; // no arguments to function

2065

1974

len=(uint32_t) strlen(name);

2066

1975

}

2067

1976

2068

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

1977

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

2069

1978

{

2070

1979

if (commands[i].func &&

2071

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

2072

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

1980

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

2073

1981

{

2074

1982

return(&commands[i]);

2075

1983

}

2076

1984

}

2077

return(NULL);

1985

return((COMMANDS *) 0);

2078

1986

}

2079

1987

2080

1988

2082

1990

bool *ml_comment)

2083

1991

{

2084

1992

unsigned char inchar;

2085

char *pos, *out;

2086

Commands *com;

1993

char buff[80], *pos, *out;

1994

COMMANDS *com;

2087

1995

bool need_space= 0;

2088

1996

bool ss_comment= 0;

2089

1997

2090

1998

2091

1999

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

2092

2000

return(0);

2093

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

2001

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

2094

2002

add_history(line);

2095

2003

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

2096

2004

2099

2007

if (!preserve_comments)

2100

2008

{

2101

2009

// Skip spaces at the beggining of a statement

2102

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

2010

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

2103

2011

(buffer->empty()))

2104

2012

continue;

2105

2013

}

2106

2014

2015

#ifdef USE_MB

2107

2016

// Accept multi-byte characters as-is

2108

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

2017

int length;

2018

if (use_mb(charset_info) &&

2019

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

2109

2020

{

2110

int length;

2111

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

2021

if (!*ml_comment || preserve_comments)

2112

2022

{

2113

if (!*ml_comment || preserve_comments)

2114

{

2115

while (length--)

2116

*out++ = *pos++;

2117

pos--;

2118

}

2119

else

2120

pos+= length - 1;

2121

continue;

2023

while (length--)

2024

*out++ = *pos++;

2025

pos--;

2122

2026

}

2027

else

2028

pos+= length - 1;

2029

continue;

2123

2030

}

2124

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

2125

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

2031

#endif

2032

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

2033

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

2126

2034

{

2127

2035

// Found possbile one character command like \c

2128

2036

2145

2053

2146

2054

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

2147

2055

return(1); // Quit

2148

if (com->getTakesParams())

2056

if (com->takes_params)

2149

2057

{

2150

2058

if (ss_comment)

2151

2059

{

2174

2082

}

2175

2083

else

2176

2084

{

2177

string buff(_("Unknown command: "));

2178

buff.push_back('\'');

2179

buff.push_back(inchar);

2180

buff.push_back('\'');

2181

buff.push_back('.');

2182

if (put_info(buff.c_str(),INFO_ERROR,0,0) > 0)

2085

sprintf(buff,_("Unknown command '\\%c'."),inchar);

2086

if (put_info(buff,INFO_ERROR,0,0) > 0)

2183

2087

return(1);

2184

2088

*out++='\\';

2185

2089

*out++=(char) inchar;

2188

2092

}

2189

2093

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

2190

2094

(end_of_line - pos) >= 10 &&

2191

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

2095

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

2096

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

2192

2097

{

2193

2098

// Flush previously accepted characters

2194

2099

if (out != line)

2225

2130

2226

2131

if (preserve_comments)

2227

2132

{

2228

while (isspace(*pos))

2133

while (my_isspace(charset_info, *pos))

2229

2134

*out++= *pos++;

2230

2135

}

2231

2136

// Flush previously accepted characters

2238

2143

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

2239

2144

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

2240

2145

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

2241

isspace(pos[2]))))

2146

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

2242

2147

{

2243

2148

// Add trailing single line comments to this statement

2244

2149

buffer->append(pos);

2265

2170

&& (inchar == '#'

2266

2171

|| (inchar == '-'

2267

2172

&& pos[1] == '-'

2268

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

2173

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

2269

2174

{

2270

2175

// Flush previously accepted characters

2271

2176

if (out != line)

2331

2236

*in_string= (char) inchar;

2332

2237

if (!*ml_comment || preserve_comments)

2333

2238

{

2334

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

2239

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

2335

2240

*out++= ' ';

2336

2241

need_space= 0;

2337

2242

*out++= (char) inchar;

2342

2247

{

2343

2248

*out++='\n';

2344

2249

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

2345

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

2346

{

2347

status.setExitStatus(1);

2348

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

2349

return 1;

2350

}

2351

2250

if ((!*ml_comment || preserve_comments))

2352

2251

buffer->append(line, length);

2353

2252

}

2452

2351

2453

2352

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

2454

2353

rl_attempted_completion_function= (rl_completion_func_t*)&mysql_completion;

2455

rl_completion_entry_function= (drizzle_compentry_func_t*)&no_completion;

2354

rl_completion_entry_function= (rl_compentry_func_t*)&no_completion;

2456

2355

}

2457

2356

2458

2357

2464

2363

2465

2364

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

2466

2365

{

2467

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

2366

if (!status.batch && !quick)

2468

2367

return rl_completion_matches(text, new_command_generator);

2469

2368

else

2470

2369

return (char**) 0;

2533

2432

2534

2433

static void build_completion_hash(bool rehash, bool write_info)

2535

2434

{

2536

Commands *cmd=commands;

2435

COMMANDS *cmd=commands;

2537

2436

drizzle_return_t ret;

2538

2437

drizzle_result_st databases,tables,fields;

2539

2438

drizzle_row_t database_row,table_row;

2540

2439

drizzle_column_st *sql_field;

2541

2440

string tmp_str, tmp_str_lower;

2542

2441

2543

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

2442

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

2544

2443

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

2545

2444

if (!rehash)

2546

2445

return;

2548

2447

completion_map.clear();

2549

2448

2550

2449

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

2551

while (cmd->getName()) {

2552

tmp_str= cmd->getName();

2450

while (cmd->name) {

2451

tmp_str= cmd->name;

2553

2452

tmp_str_lower= lower_string(tmp_str);

2554

2453

completion_map[tmp_str_lower]= tmp_str;

2555

2454

cmd++;

2593

2492

{

2594

2493

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

2595

2494

{

2596

tee_fprintf(stdout,

2597

_("Reading table information for completion of "

2598

"table and column names\n"

2599

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

2600

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

2495

tee_fprintf(stdout, _("\

2496

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

2497

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

2601

2498

}

2602

2499

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

2603

2500

{

2623

2520

{

2624

2521

string query;

2625

2522

2626

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

2523

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

2627

2524

query.append(table_row[0]);

2628

query.append("`");

2525

query.append("'");

2629

2526

2630

2527

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

2631

2528

&ret) != NULL)

2655

2552

2656

2553

/* for gnu readline */

2657

2554

2555

#ifndef HAVE_INDEX

2556

extern "C" {

2557

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

2558

2559

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

2560

{

2561

for (;;)

2562

{

2563

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

2564

if (!*s++) return NULL;

2565

}

2566

}

2567

2568

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

2569

{

2570

2571

2572

t = NULL;

2573

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

2574

return (char*) t;

2575

}

2576

}

2577

#endif

2578

2658

2579

2659

2580

static int reconnect(void)

2660

2581

{

2582

/* purecov: begin tested */

2661

2583

if (opt_reconnect)

2662

2584

{

2663

2585

put_info(_("No connection. Trying to reconnect..."),INFO_INFO,0,0);

2664

2586

(void) com_connect((string *)0, 0);

2665

if (opt_rehash && connected)

2587

if (opt_rehash)

2666

2588

com_rehash(NULL, NULL);

2667

2589

}

2668

if (! connected)

2590

if (!connected)

2669

2591

return put_info(_("Can't connect to the server\n"),INFO_ERROR,0,0);

2592

/* purecov: end */

2670

2593

return 0;

2671

2594

}

2672

2595

2675

2598

drizzle_return_t ret;

2676

2599

drizzle_result_st res;

2677

2600

2678

current_db.erase();

2679

current_db= "";

2601

free(current_db);

2602

current_db= NULL;

2680

2603

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

2681

2604

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

2682

2605

{

2685

2608

{

2686

2609

drizzle_row_t row= drizzle_row_next(&res);

2687

2610

if (row[0])

2688

current_db.assign(row[0]);

2689

drizzle_result_free(&res);

2611

current_db= strdup(row[0]);

2690

2612

}

2613

drizzle_result_free(&res);

2691

2614

}

2692

2615

}

2693

2616

2695

2618

The different commands

2696

2619

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

2697

2620

2698

int drizzleclient_real_query_for_lazy(const char *buf, size_t length,

2621

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2699

2622

drizzle_result_st *result,

2700

2623

uint32_t *error_code)

2701

2624

{

2734

2657

return 0;

2735

2658

2736

2659

if (drizzle_con_error(&con)[0])

2737

{

2738

int ret= put_error(&con, result);

2739

drizzle_result_free(result);

2740

return ret;

2741

}

2660

return put_error(&con, result);

2742

2661

return 0;

2743

2662

}

2744

2663

2747

2666

{

2748

2667

2749

2668

char buff[32], *end;

2750

std::vector<char> output_buff;

2751

output_buff.resize(512);

2752

2669

2753

2670

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

2754

2671

if (!named_cmds)

2755

{

2756

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

2757

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

2758

delimiter);

2759

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

2760

}

2761

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

2762

{

2763

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

2764

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

2765

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

2672

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

2673

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

2674

{

2675

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

2676

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

2677

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

2766

2678

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

2767

2679

if (commands[i].func)

2768

2680

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

2769

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

2681

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

2770

2682

}

2771

2683

tee_fprintf(stdout, "\n");

2772

2684

buffer->clear();

2777

2689

static int

2778

2690

com_clear(string *buffer, const char *)

2779

2691

{

2780

if (status.getAddToHistory())

2692

if (status.add_to_history)

2781

2693

fix_history(buffer);

2782

2694

buffer->clear();

2783

2695

return 0;

2810

2722

if (buffer->empty())

2811

2723

{

2812

2724

// Ignore empty quries

2813

if (status.getBatch())

2725

if (status.batch)

2814

2726

return 0;

2815

2727

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

2816

2728

2835

2747

executing_query= 1;

2836

2748

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

2837

2749

2838

if (status.getAddToHistory())

2750

if (status.add_to_history)

2839

2751

{

2840

2752

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

2841

2753

/* Append final command onto history */

2956

2868

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

2957

2869

print_warnings(error_code);

2958

2870

2959

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

2871

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

2960

2872

drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)

2961

2873

{

2962

2874

get_current_db();

2971

2883

{

2972

2884

if (!opt_nopager)

2973

2885

{

2974

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

2886

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

2975

2887

{

2976

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

2888

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

2977

2889

PAGER= stdout;

2978

2890

}

2979

2891

}

2995

2907

end_tee();

2996

2908

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

2997

2909

{

2998

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

2910

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

2999

2911

return;

3000

2912

}

3001

2913

OUTFILE = new_outfile;

3002

outfile.assign(file_name);

3003

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

2914

strncpy(outfile, file_name, FN_REFLEN-1);

2915

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

3004

2916

opt_outfile= 1;

3005

2917

3006

2918

return;

3041

2953

case DRIZZLE_COLUMN_TYPE_LONGLONG: return "LONGLONG";

3042

2954

case DRIZZLE_COLUMN_TYPE_NULL: return "NULL";

3043

2955

case DRIZZLE_COLUMN_TYPE_TIMESTAMP: return "TIMESTAMP";

2956

case DRIZZLE_COLUMN_TYPE_TINY: return "TINY";

2957

case DRIZZLE_COLUMN_TYPE_VIRTUAL: return "VIRTUAL";

3044

2958

default: return "?-unknown-?";

3045

2959

}

3046

2960

}

3084

2998

3085

2999

while ((field = drizzle_column_next(result)))

3086

3000

{

3087

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

3001

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

3088

3002

"Catalog: `%s`\n"

3089

3003

"Database: `%s`\n"

3090

3004

"Table: `%s`\n"

3091

3005

"Org_table: `%s`\n"

3092

"Type: UTF-8\n"

3006

"Type: %s\n"

3093

3007

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

3094

3008

"Length: %lu\n"

3095

3009

"Max_length: %lu\n"

3096

3010

"Decimals: %u\n"

3097

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

3011

"Flags: %s\n\n",

3098

3012

++i,

3099

3013

drizzle_column_name(field), drizzle_column_catalog(field),

3100

3014

drizzle_column_db(field), drizzle_column_table(field),

3101

3015

drizzle_column_orig_table(field),

3102

3016

fieldtype2str(drizzle_column_type(field)),

3017

get_charset_name(drizzle_column_charset(field)),

3103

3018

drizzle_column_charset(field), drizzle_column_size(field),

3104

3019

drizzle_column_max_size(field), drizzle_column_decimals(field),

3105

3020

fieldflags2str(drizzle_column_flags(field)));

3107

3022

tee_puts("", PAGER);

3108

3023

}

3109

3024

3025

3110

3026

static void

3111

3027

print_table_data(drizzle_result_st *result)

3112

3028

{

3113

3029

drizzle_row_t cur;

3114

3030

drizzle_return_t ret;

3115

3031

drizzle_column_st *field;

3116

std::vector<bool> num_flag;

3032

bool *num_flag;

3117

3033

string separator;

3118

3034

3119

3035

separator.reserve(256);

3120

3036

3121

num_flag.resize(drizzle_result_column_count(result));

3037

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

3122

3038

if (column_types_flag)

3123

3039

{

3124

3040

print_field_types(result);

3138

3054

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

3139

3055

of visual length since multibyte characters can affect the

3140

3056

length of the separator. */

3141

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

3057

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

3058

drizzle_column_name(field),

3059

drizzle_column_name(field) +

3060

name_length);

3142

3061

3143

3062

if (name_length == drizzle_column_max_size(field))

3144

3063

{

3176

3095

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

3177

3096

{

3178

3097

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

3179

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

3098

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

3099

drizzle_column_name(field),

3100

drizzle_column_name(field) +

3101

name_length);

3180

3102

uint32_t display_length= drizzle_column_max_size(field) + name_length -

3181

3103

numcells;

3182

3104

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

3239

3161

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

3240

3162

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

3241

3163

3242

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

3164

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

3243

3165

extra_padding= data_length - visible_length;

3244

3166

3245

3167

if (field_max_length > MAX_COLUMN_LENGTH)

3259

3181

drizzle_row_free(result, cur);

3260

3182

}

3261

3183

tee_puts(separator.c_str(), PAGER);

3184

free(num_flag);

3262

3185

}

3263

3186

3264

3187

/**

3406

3329

drizzle_row_t cur;

3407

3330

uint64_t num_rows;

3408

3331

uint32_t new_code= 0;

3409

FILE *out;

3410

3332

3411

3333

/* Get the warnings */

3412

3334

query= "show warnings";

3432

3354

}

3433

3355

3434

3356

/* Print the warnings */

3435

if (status.getBatch())

3436

{

3437

out= stderr;

3438

}

3439

else

3440

{

3441

init_pager();

3442

out= PAGER;

3443

}

3357

init_pager();

3444

3358

3445

3359

{

3446

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

3360

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

3447

3361

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

3448

3449

if (not status.getBatch())

3450

end_pager();

3362

end_pager();

3451

3363

3452

3364

end:

3453

3365

drizzle_result_free(&result);

3464

3376

if (opt_raw_data)

3465

3377

tee_fputs(pos, PAGER);

3466

3378

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

3467

{

3468

int l;

3469

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

3470

{

3471

while (l--)

3472

tee_putc(*pos++, PAGER);

3473

pos--;

3474

continue;

3475

}

3476

if (!*pos)

3477

tee_fputs("\\0", PAGER); // This makes everything hard

3478

else if (*pos == '\t')

3479

tee_fputs("\\t", PAGER); // This would destroy tab format

3480

else if (*pos == '\n')

3481

tee_fputs("\\n", PAGER); // This too

3482

else if (*pos == '\\')

3483

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

3484

else

3485

tee_putc(*pos, PAGER);

3486

}

3379

{

3380

#ifdef USE_MB

3381

int l;

3382

if (use_mb(charset_info) &&

3383

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

3384

{

3385

while (l--)

3386

tee_putc(*pos++, PAGER);

3387

pos--;

3388

continue;

3389

}

3390

#endif

3391

if (!*pos)

3392

tee_fputs("\\0", PAGER); // This makes everything hard

3393

else if (*pos == '\t')

3394

tee_fputs("\\t", PAGER); // This would destroy tab format

3395

else if (*pos == '\n')

3396

tee_fputs("\\n", PAGER); // This too

3397

else if (*pos == '\\')

3398

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

3399

else

3400

tee_putc(*pos, PAGER);

3401

}

3487

3402

}

3488

3403

}

3489

3404

3543

3458

char file_name[FN_REFLEN], *end;

3544

3459

const char *param;

3545

3460

3546

if (status.getBatch())

3461

if (status.batch)

3547

3462

return 0;

3548

while (isspace(*line))

3463

while (my_isspace(charset_info,*line))

3549

3464

line++;

3550

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

3465

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

3551

3466

{

3552

if (outfile.empty())

3467

if (!strlen(outfile))

3553

3468

{

3554

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

3469

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

3555

3470

return 0;

3556

3471

}

3557

3472

else if (opt_outfile)

3558

3473

{

3559

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

3474

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

3560

3475

return 0;

3561

3476

}

3562

3477

else

3563

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

3478

param = outfile; //resume using the old outfile

3564

3479

}

3565

3480

3566

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

3567

3481

/* eliminate the spaces before the parameters */

3568

while (isspace(*param))

3482

while (my_isspace(charset_info,*param))

3569

3483

param++;

3570

3484

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

3571

3485

end= file_name + strlen(file_name);

3572

3486

/* remove end space from command line */

3573

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

3574

iscntrl(end[-1])))

3487

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

3488

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

3575

3489

end--;

3576

3490

end[0]= 0;

3577

3491

if (end == file_name)

3578

3492

{

3579

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

3493

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

3580

3494

return 0;

3581

3495

}

3582

3496

init_tee(file_name);

3589

3503

{

3590

3504

if (opt_outfile)

3591

3505

end_tee();

3592

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

3506

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

3593

3507

return 0;

3594

3508

}

3595

3509

3600

3514

static int

3601

3515

com_pager(string *, const char *line)

3602

3516

{

3517

char pager_name[FN_REFLEN], *end;

3603

3518

const char *param;

3604

3519

3605

if (status.getBatch())

3520

if (status.batch)

3606

3521

return 0;

3607

3522

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

3608

while (isspace(*line))

3523

while (my_isspace(charset_info, *line))

3609

3524

line++;

3610

3525

/* Skip the pager command */

3611

3526

param= strchr(line, ' ');

3612

3527

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

3613

while (param && isspace(*param))

3528

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

3614

3529

param++;

3615

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

3530

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

3616

3531

{

3617

3532

if (!default_pager_set)

3618

3533

{

3619

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

3534

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

3620

3535

opt_nopager=1;

3621

pager.assign("stdout");

3536

strcpy(pager, "stdout");

3622

3537

PAGER= stdout;

3623

3538

return 0;

3624

3539

}

3625

pager.assign(default_pager);

3540

strcpy(pager, default_pager);

3626

3541

}

3627

3542

else

3628

3543

{

3629

string pager_name(param);

3630

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

3631

while (end > pager_name.begin() &&

3632

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

3633

--end;

3634

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

3635

pager.assign(pager_name);

3636

default_pager.assign(pager_name);

3544

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

3545

end+= strlen(pager_name);

3546

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

3547

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

3548

end--;

3549

end[0]=0;

3550

strcpy(pager, pager_name);

3551

strcpy(default_pager, pager_name);

3637

3552

}

3638

3553

opt_nopager=0;

3639

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

3554

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

3640

3555

return 0;

3641

3556

}

3642

3557

3644

3559

static int

3645

3560

com_nopager(string *, const char *)

3646

3561

{

3647

pager.assign("stdout");

3562

strcpy(pager, "stdout");

3648

3563

opt_nopager=1;

3649

3564

PAGER= stdout;

3650

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

3565

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

3651

3566

return 0;

3652

3567

}

3653

3568

3657

3572

com_quit(string *, const char *)

3658

3573

{

3659

3574

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

3660

status.setExitStatus(0);

3575

status.exit_status=0;

3661

3576

return 1;

3662

3577

}

3663

3578

3705

3620

tmp= get_arg(buff, 0);

3706

3621

if (tmp && *tmp)

3707

3622

{

3708

current_db.erase();

3709

current_db.assign(tmp);

3623

free(current_db);

3624

current_db= strdup(tmp);

3710

3625

tmp= get_arg(buff, 1);

3711

3626

if (tmp)

3712

3627

{

3713

current_host.erase();

3628

free(current_host);

3714

3629

current_host=strdup(tmp);

3715

3630

}

3716

3631

}

3717

3632

else

3718

3633

{

3719

3634

/* Quick re-connect */

3720

opt_rehash= 0;

3635

opt_rehash= 0; /* purecov: tested */

3721

3636

}

3722

3637

// command used

3723

3638

assert(buffer!=NULL);

3725

3640

}

3726

3641

else

3727

3642

opt_rehash= 0;

3728

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

3643

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

3729

3644

opt_rehash= save_rehash;

3730

3645

3731

3646

if (connected)

3732

3647

{

3733

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

3648

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

3734

3649

put_info(buff,INFO_INFO,0,0);

3735

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

3736

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

3650

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

3651

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

3737

3652

put_info(buff,INFO_INFO,0,0);

3738

3653

}

3739

3654

return error;

3744

3659

{

3745

3660

char source_name[FN_REFLEN], *end;

3746

3661

const char *param;

3747

LineBuffer *line_buff;

3662

LINE_BUFFER *line_buff;

3748

3663

int error;

3749

Status old_status;

3664

STATUS old_status;

3750

3665

FILE *sql_file;

3751

3666

3752

3667

/* Skip space from file name */

3753

while (isspace(*line))

3668

while (my_isspace(charset_info,*line))

3754

3669

line++;

3755

3670

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

3756

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

3671

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

3757

3672

INFO_ERROR, 0,0);

3758

while (isspace(*param))

3673

while (my_isspace(charset_info,*param))

3759

3674

param++;

3760

3675

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

3761

3676

end+= strlen(source_name);

3762

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

3763

iscntrl(end[-1])))

3677

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

3678

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

3764

3679

end--;

3765

3680

end[0]=0;

3766

3681

unpack_filename(source_name,source_name);

3767

3682

/* open file name */

3768

3683

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

3769

3684

{

3770

3685

char buff[FN_REFLEN+60];

3771

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

3686

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

3772

3687

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

3773

3688

}

3774

3689

3775

line_buff= new(std::nothrow) LineBuffer(opt_max_input_line,sql_file);

3776

if (line_buff == NULL)

3690

if (!(line_buff=batch_readline_init(opt_max_input_line+512,sql_file)))

3777

3691

{

3778

3692

fclose(sql_file);

3779

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

3693

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

3780

3694

}

3781

3695

3782

3696

/* Save old status */

3784

3698

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

3785

3699

3786

3700

// Run in batch mode

3787

status.setBatch(old_status.getBatch());

3788

status.setLineBuff(line_buff);

3789

status.setFileName(source_name);

3701

status.batch=old_status.batch;

3702

status.line_buff=line_buff;

3703

status.file_name=source_name;

3790

3704

// Empty command buffer

3791

3705

assert(glob_buffer!=NULL);

3792

3706

glob_buffer->clear();

3794

3708

// Continue as before

3795

3709

status=old_status;

3796

3710

fclose(sql_file);

3797

delete status.getLineBuff();

3798

line_buff=0;

3799

status.setLineBuff(0);

3711

batch_readline_end(line_buff);

3800

3712

return error;

3801

3713

}

3802

3714

3812

3724

3813

3725

if (!tmp || !*tmp)

3814

3726

{

3815

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

3727

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

3816

3728

INFO_ERROR, 0, 0);

3817

3729

return 0;

3818

3730

}

3820

3732

{

3821

3733

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

3822

3734

{

3823

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

3735

put_info("DELIMITER cannot contain a backslash character",

3824

3736

INFO_ERROR, 0, 0);

3825

3737

return 0;

3826

3738

}

3845

3757

tmp= get_arg(buff, 0);

3846

3758

if (!tmp || !*tmp)

3847

3759

{

3848

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

3760

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

3849

3761

return 0;

3850

3762

}

3851

3763

3855

3767

3856

3768

get_current_db();

3857

3769

3858

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

3770

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

3859

3771

{

3860

3772

if (one_database)

3861

3773

{

3907

3819

else

3908

3820

drizzle_result_free(&result);

3909

3821

}

3910

current_db.erase();

3911

current_db.assign(tmp);

3822

free(current_db);

3823

current_db= strdup(tmp);

3912

3824

if (select_db > 1)

3913

3825

build_completion_hash(opt_rehash, 1);

3914

3826

}

3915

3827

3916

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

3828

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

3917

3829

return 0;

3918

3830

}

3919

3831

3920

static int com_shutdown(string *, const char *)

3921

{

3922

drizzle_result_st result;

3923

drizzle_return_t ret;

3924

3925

if (verbose)

3926

{

3927

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

3928

if (opt_drizzle_port > 0)

3929

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

3930

printf("... ");

3931

}

3932

3933

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

3934

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

3935

{

3936

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3937

{

3938

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

3939

drizzle_result_error(&result));

3940

drizzle_result_free(&result);

3941

}

3942

else

3943

{

3944

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

3945

drizzle_con_error(&con));

3946

}

3947

return false;

3948

}

3949

3950

drizzle_result_free(&result);

3951

3952

if (verbose)

3953

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

3954

3955

return false;

3956

}

3957

3958

3832

static int

3959

3833

com_warnings(string *, const char *)

3960

3834

{

3961

3835

show_warnings = 1;

3962

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

3836

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

3963

3837

return 0;

3964

3838

}

3965

3839

3967

3841

com_nowarnings(string *, const char *)

3968

3842

{

3969

3843

show_warnings = 0;

3970

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

3844

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

3971

3845

return 0;

3972

3846

}

3973

3847

3997

3871

else

3998

3872

{

3999

3873

/* skip leading white spaces */

4000

while (isspace(*ptr))

3874

while (my_isspace(charset_info, *ptr))

4001

3875

ptr++;

4002

3876

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

4003

3877

ptr+= 2;

4004

3878

else

4005

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

3879

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

4006

3880

ptr++;

4007

3881

}

4008

3882

if (!*ptr)

4009

3883

return NULL;

4010

while (isspace(*ptr))

3884

while (my_isspace(charset_info, *ptr))

4011

3885

ptr++;

4012

3886

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

4013

3887

{

4034

3908

4035

3909

4036

3910

static int

4037

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

3911

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

4038

3912

uint32_t silent)

4039

3913

{

4040

3914

drizzle_return_t ret;

3915

4041

3916

if (connected)

4042

3917

{

4043

3918

connected= 0;

4045

3920

drizzle_free(&drizzle);

4046

3921

}

4047

3922

drizzle_create(&drizzle);

4048

4049

#ifdef DRIZZLE_ADMIN_TOOL

4050

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

4051

#else

4052

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

4053

#endif

4054

4055

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

4056

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

4057

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

4058

options) == NULL)

3923

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

3924

password, database, DRIZZLE_CON_NONE) == NULL)

4059

3925

{

4060

3926

(void) put_error(&con, NULL);

4061

3927

(void) fflush(stdout);

4094

3960

return -1; // Retryable

4095

3961

}

4096

3962

connected=1;

4097

3963

/* XXX hmm?

3964

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

3965

4098

3966

build_completion_hash(opt_rehash, 1);

4099

3967

return 0;

4100

3968

}

4111

3979

drizzle_return_t ret;

4112

3980

4113

3981

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

4114

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

4115

drizzle_version(), VERSION,

4116

HOST_VENDOR, HOST_OS, HOST_CPU,

4117

rl_library_version);

4118

3982

usage(1); /* Print version */

4119

3983

if (connected)

4120

3984

{

4121

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

3985

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

4122

3986

4123

3987

Don't remove "limit 1",

4124

3988

it is protection againts SQL_SELECT_LIMIT=0

4130

3994

drizzle_row_t cur=drizzle_row_next(&result);

4131

3995

if (cur)

4132

3996

{

4133

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

4134

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

3997

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

3998

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

4135

3999

}

4136

4000

drizzle_result_free(&result);

4137

4001

}

4138

4002

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

4139

4003

drizzle_result_free(&result);

4140

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

4004

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

4141

4005

}

4142

4006

else

4143

4007

{

4144

4008

vidattr(A_BOLD);

4145

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

4009

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

4146

4010

vidattr(A_NORMAL);

4147

4011

return 0;

4148

4012

}

4149

4013

if (skip_updates)

4150

4014

{

4151

4015

vidattr(A_BOLD);

4152

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

4016

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

4153

4017

vidattr(A_NORMAL);

4154

4018

}

4155

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

4156

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

4157

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

4158

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

4159

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

4160

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

4161

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

4019

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

4020

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

4021

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

4022

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

4023

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

4024

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

4162

4025

/* XXX need to save this from result

4163

4026

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

4164

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

4027

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

4165

4028

4166

4029

4167

if (drizzle_con_uds(&con))

4168

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

4030

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

4031

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

4169

4032

else

4170

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

4033

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

4171

4034

4172

4035

if (safe_updates)

4173

4036

{

4174

4037

vidattr(A_BOLD);

4175

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

4038

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

4176

4039

vidattr(A_NORMAL);

4177

tee_fprintf(stdout, _("\

4040

tee_fprintf(stdout, "\

4178

4041

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

4179

4042

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

4180

4043

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

4181

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

4044

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

4182

4045

select_limit, max_join_size);

4183

4046

}

4184

4047

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

4231

4094

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

4232

4095

static int inited=0;

4233

4096

4234

if (status.getBatch())

4097

if (status.batch)

4235

4098

{

4236

4099

if (info_type == INFO_ERROR)

4237

4100

{

4238

4101

(void) fflush(file);

4239

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

4102

fprintf(file,"ERROR");

4240

4103

if (error)

4241

4104

{

4242

4105

if (sqlstate)

4244

4107

else

4245

4108

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

4246

4109

}

4247

if (status.getQueryStartLine() && line_numbers)

4110

if (status.query_start_line && line_numbers)

4248

4111

{

4249

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

4250

if (status.getFileName())

4251

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

4112

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

4113

if (status.file_name)

4114

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

4252

4115

}

4253

4116

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

4254

4117

(void) fflush(file);

4279

4142

if (error)

4280

4143

{

4281

4144

if (sqlstate)

4282

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

4145

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

4283

4146

else

4284

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

4147

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

4285

4148

}

4286

4149

else

4287

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

4150

tee_puts("ERROR: ", file);

4288

4151

}

4289

4152

else

4290

4153

vidattr(A_BOLD);

4323

4186

{

4324

4187

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

4325

4188

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

4326

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

4189

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

4327

4190

end--;

4328

4191

uint32_t pos_to_truncate= (end-start);

4329

4192

if (buffer->length() > pos_to_truncate)

4417

4280

tmp_buff_str << tmp;

4418

4281

4419

4282

if (tmp > 1)

4420

tmp_buff_str << _(" hours ");

4283

tmp_buff_str << " hours ";

4421

4284

else

4422

tmp_buff_str << _(" hour ");

4285

tmp_buff_str << " hour ";

4423

4286

}

4424

4287

if (sec >= 60.0)

4425

4288

{

4426

4289

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

4427

4290

sec-=60.0*tmp;

4428

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

4291

tmp_buff_str << tmp << " min ";

4429

4292

}

4430

4293

if (part_second)

4431

4294

tmp_buff_str.precision(2);

4432

4295

else

4433

4296

tmp_buff_str.precision(0);

4434

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

4297

tmp_buff_str << sec << " sec";

4435

4298

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

4436

4299

}

4437

4300

4462

4325

struct tm *t = localtime(&lclock);

4463

4326

4464

4327

/* parse thru the settings for the prompt */

4465

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

4466

while (c != current_prompt.end())

4328

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

4467

4329

{

4468

4330

if (*c != PROMPT_CHAR)

4469

4331

{

4470

processed_prompt->push_back(*c);

4332

processed_prompt->append(c, 1);

4471

4333

}

4472

4334

else

4473

4335

{

4478

4340

switch (*++c) {

4479

4341

case '\0':

4480

4342

// stop it from going beyond if ends with %

4481

--c;

4343

c--;

4482

4344

break;

4483

4345

case 'c':

4484

4346

add_int_to_prompt(++prompt_counter);

4490

4352

processed_prompt->append("not_connected");

4491

4353

break;

4492

4354

case 'd':

4493

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

4355

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

4494

4356

break;

4495

4357

case 'h':

4496

4358

{

4497

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

4359

const char *prompt;

4360

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

4498

4361

if (strstr(prompt, "Localhost"))

4499

4362

processed_prompt->append("localhost");

4500

4363

else

4513

4376

break;

4514

4377

}

4515

4378

4516

if (drizzle_con_uds(&con))

4379

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

4517

4380

{

4518

4381

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

4519

4382

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

4526

4389

if (!full_username)

4527

4390

init_username();

4528

4391

processed_prompt->append(full_username ? full_username :

4529

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

4392

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

4530

4393

break;

4531

4394

case 'u':

4532

4395

if (!full_username)

4533

4396

init_username();

4534

4397

processed_prompt->append(part_username ? part_username :

4535

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

4398

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

4536

4399

break;

4537

4400

case PROMPT_CHAR:

4538

4401

{

4614

4477

processed_prompt->append(delimiter_str);

4615

4478

break;

4616

4479

default:

4617

processed_prompt->push_back(*c);

4480

processed_prompt->append(c, 1);

4618

4481

}

4619

4482

}

4620

++c;

4621

4483

}

4622

4484

return processed_prompt->c_str();

4623

4485

}

4652

4514

{

4653

4515

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

4654

4516

if (ptr == NULL)

4655

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

4517

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

4656

4518

default_prompt);

4657

4519

prompt_counter = 0;

4658

4520

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

4659

4521

if (tmpptr == NULL)

4660

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

4522

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

4661

4523

else

4662

4524

{

4663

current_prompt.erase();

4525

free(current_prompt);

4664

4526

current_prompt= tmpptr;

4665

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

4527

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

4666

4528

}

4667

4529

return 0;

4668

4530

}

Older »