~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

1154

MY_INIT(argv[0]);

1155

delimiter_str= delimiter;

1458

1156

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1459

1157

getenv("DRIZZLE_PS1") :

1460

1158

"drizzle> ");

1461

#endif

1159

1462

1160

if (default_prompt == NULL)

1463

1161

{

1464

1162

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

1466

1164

exit(ENOMEM);

1467

1165

}

1468

1166

current_prompt= strdup(default_prompt);

1469

if (current_prompt.empty())

1167

if (current_prompt == NULL)

1470

1168

{

1471

1169

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

1472

1170

"prompt. Aborting.\n"));

1477

1175

1478

1176

prompt_counter=0;

1479

1177

1480

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

1481

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

1482

1180

{

1483

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

1181

char *tmp=getenv("PAGER");

1484

1182

if (tmp && strlen(tmp))

1485

1183

{

1486

1184

default_pager_set= 1;

1487

default_pager.assign(tmp);

1185

strcpy(default_pager, tmp);

1488

1186

}

1489

1187

}

1490

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

1188

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

1491

1189

{

1492

status.setBatch(1); opt_silent=1;

1190

status.batch=1; opt_silent=1;

1493

1191

ignore_errors=0;

1494

1192

}

1495

1193

else

1496

status.setAddToHistory(1);

1497

status.setExitStatus(1);

1194

status.add_to_history=1;

1195

status.exit_status=1;

1498

1196

1499

1197

{

1500

1198

1510

1208

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

1511

1209

}

1512

1210

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

{

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

1694

1217

exit(1);

1695

1218

}

1696

1219

1697

1220

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

1698

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

1221

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

1222

opt_silent))

1699

1223

{

1700

1224

quick= 1; // Avoid history

1701

status.setExitStatus(1);

1225

status.exit_status= 1;

1702

1226

drizzle_end(-1);

1703

1227

}

1704

1228

1706

1230

if (execute_commands(&command_error) != false)

1707

1231

{

1708

1232

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

1233

internal::free_defaults(defaults_argv);

1234

internal::my_end();

1709

1235

exit(command_error);

1710

1236

}

1711

1237

1712

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

1238

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

1713

1239

{

1714

status.setLineBuff(opt_max_input_line, stdin);

1715

if (status.getLineBuff() == NULL)

1240

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

1241

if (status.line_buff == NULL)

1716

1242

{

1243

internal::free_defaults(defaults_argv);

1244

internal::my_end();

1717

1245

exit(1);

1718

1246

}

1719

1247

}

1720

1248

1721

if (!status.getBatch())

1249

if (!status.batch)

1722

1250

ignore_errors=1; // Don't abort monitor

1723

1251

1724

1252

if (opt_sigint_ignore)

1733

1261

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

1734

1262

window_resize(0);

1735

1263

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

1264

1265

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

1266

INFO_INFO,0,0);

1744

1267

1745

1268

glob_buffer= new string();

1746

1269

glob_buffer->reserve(512);

1747

1270

1748

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

1749

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

1750

drizzle_con_thread_id(&con),

1751

opt_protocol.c_str(),

1752

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)

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)

1758

1281

{

1759

1282

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

1760

1283

if (getenv("DRIZZLE_HISTFILE"))

1761

1284

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

1762

1285

else if (getenv("HOME"))

1763

1286

{

1764

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

1765

1290

if (histfile)

1766

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

1291

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

1767

1292

char link_name[FN_REFLEN];

1768

1293

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

1769

1294

if (sym_link_size >= 0)

1782

1307

if (verbose)

1783

1308

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

1784

1309

read_history(histfile);

1785

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

1786

1312

{

1787

1313

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

1788

1314

exit(1);

1789

1315

}

1790

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

1316

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

1791

1317

}

1792

1318

}

1793

1319

1794

1320

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

1795

1321

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

1796

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

1322

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

1797

1323

if (opt_outfile)

1798

1324

end_tee();

1799

1325

drizzle_end(0);

1800

}

1801

1326

1802

catch(exception &err)

1803

{

1804

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

1805

}

1806

1327

return(0); // Keep compiler happy

1807

1328

}

1808

1329

1810

1331

{

1811

1332

drizzle_con_free(&con);

1812

1333

drizzle_free(&drizzle);

1813

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

1334

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

1814

1335

{

1815

1336

/* write-history */

1816

1337

if (verbose)

1817

1338

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

1818

1339

if (!write_history(histfile_tmp))

1819

rename(histfile_tmp, histfile);

1340

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

1820

1341

}

1821

delete status.getLineBuff();

1822

status.setLineBuff(0);

1342

delete status.line_buff;

1343

status.line_buff= 0;

1823

1344

1824

1345

if (sig >= 0)

1825

1346

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

1826

delete glob_buffer;

1827

delete processed_prompt;

1828

opt_password.erase();

1347

if (glob_buffer)

1348

delete glob_buffer;

1349

if (processed_prompt)

1350

delete processed_prompt;

1351

free(opt_password);

1829

1352

free(histfile);

1830

1353

free(histfile_tmp);

1831

current_db.erase();

1832

current_host.erase();

1833

current_user.erase();

1354

free(current_db);

1355

free(current_host);

1356

free(current_user);

1834

1357

free(full_username);

1835

1358

free(part_username);

1836

1359

free(default_prompt);

1837

current_prompt.erase();

1838

exit(status.getExitStatus());

1360

free(current_prompt);

1361

internal::free_defaults(defaults_argv);

1362

internal::my_end();

1363

exit(status.exit_status);

1839

1364

}

1840

1365

1841

1366

1848

1373

void handle_sigint(int sig)

1849

1374

{

1850

1375

char kill_buffer[40];

1851

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

1376

drizzle_con_st kill_drizzle;

1852

1377

drizzle_result_st res;

1853

1378

drizzle_return_t ret;

1854

1379

1857

1382

goto err;

1858

1383

}

1859

1384

1860

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

1861

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

1862

use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)

1385

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

1386

opt_drizzle_port, current_user, opt_password, NULL,

1387

opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE) == NULL)

1863

1388

{

1864

1389

goto err;

1865

1390

}

1866

1391

1867

1392

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

1868

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

1869

drizzle_con_thread_id(&con));

1393

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

1394

drizzle_con_thread_id(&con));

1870

1395

1871

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

1396

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

1872

1397

drizzle_result_free(&res);

1873

1398

1874

drizzle_con_free(kill_drizzle.get());

1399

drizzle_con_free(&kill_drizzle);

1875

1400

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

1876

1401

1877

1402

interrupted_query= 1;

1893

1418

}

1894

1419

#endif

1895

1420

1896

1897

1898

static int process_options(void)

1421

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

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

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)

1899

1781

{

1900

1782

char *tmp, *pagpoint;

1901

1783

int ho_error;

1902

1784

1903

1785

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

1904

1786

if (tmp)

1905

current_host.assign(tmp);

1787

current_host= strdup(tmp);

1906

1788

1907

1789

pagpoint= getenv("PAGER");

1908

1790

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

1909

1791

{

1910

pager.assign("stdout");

1792

strcpy(pager, "stdout");

1911

1793

opt_nopager= 1;

1912

1794

}

1913

1795

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

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

1925

1806

opt_nopager= 1;

1926

1807

default_pager_set= 0;

1927

1808

opt_outfile= 0;

1929

1810

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

1930

1811

}

1931

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

}

1932

1824

if (tty_password)

1933

1825

opt_password= client_get_tty_password(NULL);

1826

1934

1827

return(0);

1935

1828

}

1936

1829

1940

1833

char in_string=0;

1941

1834

uint32_t line_number=0;

1942

1835

bool ml_comment= 0;

1943

Commands *com;

1944

status.setExitStatus(1);

1836

COMMANDS *com;

1837

status.exit_status=1;

1945

1838

1946

1839

for (;;)

1947

1840

{

1948

1841

if (!interactive)

1949

1842

{

1950

if (status.getLineBuff())

1951

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

1843

if (status.line_buff)

1844

line= status.line_buff->readline();

1952

1845

else

1953

1846

line= 0;

1954

1847

1959

1852

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

1960

1853

}

1961

1854

if (!glob_buffer->empty())

1962

status.setQueryStartLine(line_number);

1855

status.query_start_line= line_number;

1963

1856

}

1964

1857

else

1965

1858

{

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

: " \"> ");

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

" \"> "));

1977

1867

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

1978

1868

fflush(OUTFILE);

1979

1869

1980

1870

if (opt_outfile)

1981

fputs(prompt.c_str(), OUTFILE);

1982

line= readline(prompt.c_str());

1871

fputs(prompt, OUTFILE);

1872

line= readline(prompt);

1983

1873

1984

1874

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

1985

1875

which may cause coredump.

1990

1880

// End of file

1991

1881

if (!line)

1992

1882

{

1993

status.setExitStatus(0);

1883

status.exit_status=0;

1994

1884

break;

1995

1885

}

1996

1886

2006

1896

// If buffer was emptied

2007

1897

if (glob_buffer->empty())

2008

1898

in_string=0;

2009

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

1899

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

2010

1900

add_history(line);

2011

1901

continue;

2012

1902

}

2015

1905

}

2016

1906

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

2017

1907

2018

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

1908

if (!interactive && !status.exit_status)

2019

1909

{

2020

1910

remove_cntrl(glob_buffer);

2021

1911

if (!glob_buffer->empty())

2022

1912

{

2023

status.setExitStatus(1);

1913

status.exit_status=1;

2024

1914

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

2025

status.setExitStatus(0);

1915

status.exit_status=0;

2026

1916

}

2027

1917

}

2028

1918

2029

return status.getExitStatus();

1919

return status.exit_status;

2030

1920

}

2031

1921

2032

1922

2033

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

1923

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

2034

1924

{

2035

1925

uint32_t len;

2036

1926

const char *end;

2042

1932

}

2043

1933

else

2044

1934

{

2045

while (isspace(*name))

1935

while (my_isspace(charset_info,*name))

2046

1936

name++;

2047

1937

2048

1938

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

2051

1941

2052

1942

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

2053

1943

!(strlen(name) >= 9 &&

2054

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

2055

return(NULL);

1944

!my_strnncoll(charset_info,

1945

(unsigned char*) name, 9,

1946

(const unsigned char*) "delimiter",

1947

9))))

1948

return((COMMANDS *) 0);

2056

1949

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

2057

1950

{

2058

1951

len=(uint32_t) (end - name);

2059

while (isspace(*end))

1952

while (my_isspace(charset_info,*end))

2060

1953

end++;

2061

1954

if (!*end)

2062

1955

end=0; // no arguments to function

2065

1958

len=(uint32_t) strlen(name);

2066

1959

}

2067

1960

2068

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

1961

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

2069

1962

{

2070

1963

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

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

2073

1965

{

2074

1966

return(&commands[i]);

2075

1967

}

2076

1968

}

2077

return(NULL);

1969

return((COMMANDS *) 0);

2078

1970

}

2079

1971

2080

1972

2081

1973

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

2082

bool *ml_comment)

1974

bool *ml_comment)

2083

1975

{

2084

1976

unsigned char inchar;

2085

1977

char *pos, *out;

2086

Commands *com;

1978

COMMANDS *com;

2087

1979

bool need_space= 0;

2088

1980

bool ss_comment= 0;

2089

1981

2090

1982

2091

1983

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

2092

1984

return(0);

2093

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

1985

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

2094

1986

add_history(line);

2095

1987

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

2096

1988

2099

1991

if (!preserve_comments)

2100

1992

{

2101

1993

// Skip spaces at the beggining of a statement

2102

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

1994

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

2103

1995

(buffer->empty()))

2104

1996

continue;

2105

1997

}

2106

1998

2107

1999

// Accept multi-byte characters as-is

2108

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

2109

2003

{

2110

int length;

2111

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

2004

if (!*ml_comment || preserve_comments)

2112

2005

{

2113

if (!*ml_comment || preserve_comments)

2114

{

2115

while (length--)

2116

*out++ = *pos++;

2117

pos--;

2118

}

2119

else

2120

pos+= length - 1;

2121

continue;

2006

while (length--)

2007

*out++ = *pos++;

2008

pos--;

2122

2009

}

2010

else

2011

pos+= length - 1;

2012

continue;

2123

2013

}

2124

2014

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

2125

2015

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

2145

2035

2146

2036

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

2147

2037

return(1); // Quit

2148

if (com->getTakesParams())

2038

if (com->takes_params)

2149

2039

{

2150

2040

if (ss_comment)

2151

2041

{

2188

2078

}

2189

2079

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

2190

2080

(end_of_line - pos) >= 10 &&

2191

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

2081

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

2082

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

2192

2083

{

2193

2084

// Flush previously accepted characters

2194

2085

if (out != line)

2225

2116

2226

2117

if (preserve_comments)

2227

2118

{

2228

while (isspace(*pos))

2119

while (my_isspace(charset_info, *pos))

2229

2120

*out++= *pos++;

2230

2121

}

2231

2122

// Flush previously accepted characters

2238

2129

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

2239

2130

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

2240

2131

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

2241

isspace(pos[2]))))

2132

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

2242

2133

{

2243

2134

// Add trailing single line comments to this statement

2244

2135

buffer->append(pos);

2265

2156

&& (inchar == '#'

2266

2157

|| (inchar == '-'

2267

2158

&& pos[1] == '-'

2268

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

2159

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

2269

2160

{

2270

2161

// Flush previously accepted characters

2271

2162

if (out != line)

2331

2222

*in_string= (char) inchar;

2332

2223

if (!*ml_comment || preserve_comments)

2333

2224

{

2334

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

2225

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

2335

2226

*out++= ' ';

2336

2227

need_space= 0;

2337

2228

*out++= (char) inchar;

2342

2233

{

2343

2234

*out++='\n';

2344

2235

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

2236

if ((!*ml_comment || preserve_comments))

2352

2237

buffer->append(line, length);

2353

2238

}

2355

2240

}

2356

2241

2357

2242

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

2358

Interface to Readline Completion

2359

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

2243

Interface to Readline Completion

2244

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

2360

2245

2361

2246

2362

2247

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

2464

2349

2465

2350

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

2466

2351

{

2467

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

2352

if (!status.batch && !quick)

2468

2353

return rl_completion_matches(text, new_command_generator);

2469

2354

else

2470

2355

return (char**) 0;

2533

2418

2534

2419

static void build_completion_hash(bool rehash, bool write_info)

2535

2420

{

2536

Commands *cmd=commands;

2421

COMMANDS *cmd=commands;

2537

2422

drizzle_return_t ret;

2538

2423

drizzle_result_st databases,tables,fields;

2539

2424

drizzle_row_t database_row,table_row;

2540

2425

drizzle_column_st *sql_field;

2541

2426

string tmp_str, tmp_str_lower;

2542

2427

2543

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

2428

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

2544

2429

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

2545

2430

if (!rehash)

2546

2431

return;

2548

2433

completion_map.clear();

2549

2434

2550

2435

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

2551

while (cmd->getName()) {

2552

tmp_str= cmd->getName();

2436

while (cmd->name) {

2437

tmp_str= cmd->name;

2553

2438

tmp_str_lower= lower_string(tmp_str);

2554

2439

completion_map[tmp_str_lower]= tmp_str;

2555

2440

cmd++;

2593

2478

{

2594

2479

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

2595

2480

{

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

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

2601

2484

}

2602

2485

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

2603

2486

{

2623

2506

{

2624

2507

string query;

2625

2508

2626

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

2509

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

2627

2510

query.append(table_row[0]);

2628

query.append("`");

2629

2511

query.append("'");

2512

2630

2513

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

2631

2514

&ret) != NULL)

2632

2515

{

2675

2558

drizzle_return_t ret;

2676

2559

drizzle_result_st res;

2677

2560

2678

current_db.erase();

2679

current_db= "";

2561

free(current_db);

2562

current_db= NULL;

2680

2563

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

2681

2564

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

2682

2565

{

2685

2568

{

2686

2569

drizzle_row_t row= drizzle_row_next(&res);

2687

2570

if (row[0])

2688

current_db.assign(row[0]);

2571

current_db= strdup(row[0]);

2689

2572

drizzle_result_free(&res);

2690

2573

}

2691

2574

}

2692

2575

}

2693

2576

2694

2577

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

2695

The different commands

2696

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

2578

The different commands

2579

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

2697

2580

2698

int drizzleclient_real_query_for_lazy(const char *buf, size_t length,

2581

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2699

2582

drizzle_result_st *result,

2700

2583

uint32_t *error_code)

2701

2584

{

2735

2618

2736

2619

if (drizzle_con_error(&con)[0])

2737

2620

{

2738

int ret= put_error(&con, result);

2621

int ret = put_error(&con, result);

2739

2622

drizzle_result_free(result);

2740

2623

return ret;

2741

2624

}

2747

2630

{

2748

2631

2749

2632

char buff[32], *end;

2750

std::vector<char> output_buff;

2751

output_buff.resize(512);

2752

2633

2753

2634

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

2754

2635

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

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

2766

2642

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

2767

2643

if (commands[i].func)

2768

2644

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

2769

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

2645

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

2770

2646

}

2771

2647

tee_fprintf(stdout, "\n");

2772

2648

buffer->clear();

2777

2653

static int

2778

2654

com_clear(string *buffer, const char *)

2779

2655

{

2780

if (status.getAddToHistory())

2656

if (status.add_to_history)

2781

2657

fix_history(buffer);

2782

2658

buffer->clear();

2783

2659

return 0;

2786

2662

2787

2663

2788

2664

Execute command

2789

Returns: 0 if ok

2790

-1 if not fatal error

2791

1 if fatal error

2665

Returns: 0 if ok

2666

-1 if not fatal error

2667

1 if fatal error

2792

2668

2793

2669

static int

2794

2670

com_go(string *buffer, const char *)

2810

2686

if (buffer->empty())

2811

2687

{

2812

2688

// Ignore empty quries

2813

if (status.getBatch())

2689

if (status.batch)

2814

2690

return 0;

2815

2691

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

2816

2692

2835

2711

executing_query= 1;

2836

2712

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

2837

2713

2838

if (status.getAddToHistory())

2714

if (status.add_to_history)

2839

2715

{

2840

2716

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

2841

2717

/* Append final command onto history */

2889

2765

print_tab_data(&result);

2890

2766

else

2891

2767

print_table_data(&result);

2892

sprintf(buff,

2893

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

2894

(long) drizzle_result_row_count(&result)),

2895

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

2896

2772

end_pager();

2897

2773

if (drizzle_result_error_code(&result))

2898

2774

error= put_error(&con, &result);

2901

2777

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

2902

2778

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

2903

2779

else

2904

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

2905

"Query OK, %ld rows affected",

2906

(long) drizzle_result_affected_rows(&result)),

2907

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

2908

2784

2909

2785

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

2910

2786

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

2913

2789

*pos++= ' ';

2914

2790

char warnings_buff[20];

2915

2791

memset(warnings_buff,0,20);

2916

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

2792

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

2917

2793

strcpy(pos, warnings_buff);

2918

2794

pos+= strlen(warnings_buff);

2919

2795

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

2956

2832

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

2957

2833

print_warnings(error_code);

2958

2834

2959

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

2835

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

2960

2836

drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)

2961

2837

{

2962

2838

get_current_db();

2971

2847

{

2972

2848

if (!opt_nopager)

2973

2849

{

2974

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

2850

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

2975

2851

{

2976

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

2852

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

2977

2853

PAGER= stdout;

2978

2854

}

2979

2855

}

2995

2871

end_tee();

2996

2872

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

2997

2873

{

2998

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

2874

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

2999

2875

return;

3000

2876

}

3001

2877

OUTFILE = new_outfile;

3002

outfile.assign(file_name);

3003

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

3004

2880

opt_outfile= 1;

3005

2881

3006

2882

return;

3031

2907

static const char *fieldtype2str(drizzle_column_type_t type)

3032

2908

{

3033

2909

switch (type) {

3034

case DRIZZLE_COLUMN_TYPE_BLOB: return "BLOB";

3035

case DRIZZLE_COLUMN_TYPE_DATE: return "DATE";

3036

case DRIZZLE_COLUMN_TYPE_DATETIME: return "DATETIME";

3037

case DRIZZLE_COLUMN_TYPE_NEWDECIMAL: return "DECIMAL";

3038

case DRIZZLE_COLUMN_TYPE_DOUBLE: return "DOUBLE";

3039

case DRIZZLE_COLUMN_TYPE_ENUM: return "ENUM";

3040

case DRIZZLE_COLUMN_TYPE_LONG: return "LONG";

3041

case DRIZZLE_COLUMN_TYPE_LONGLONG: return "LONGLONG";

3042

case DRIZZLE_COLUMN_TYPE_NULL: return "NULL";

3043

case DRIZZLE_COLUMN_TYPE_TIMESTAMP: return "TIMESTAMP";

3044

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-?";

3045

2921

}

3046

2922

}

3047

2923

3051

2927

*s=0;

3052

2928

#define ff2s_check_flag(X) \

3053

2929

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

3054

f &= ~ DRIZZLE_COLUMN_FLAGS_ ## X; }

2930

f &= ~ DRIZZLE_COLUMN_FLAGS_ ## X; }

3055

2931

ff2s_check_flag(NOT_NULL);

3056

2932

ff2s_check_flag(PRI_KEY);

3057

2933

ff2s_check_flag(UNIQUE_KEY);

3072

2948

ff2s_check_flag(ON_UPDATE_NOW);

3073

2949

#undef ff2s_check_flag

3074

2950

if (f)

3075

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

2951

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

3076

2952

return buf;

3077

2953

}

3078

2954

3084

2960

3085

2961

while ((field = drizzle_column_next(result)))

3086

2962

{

3087

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

2963

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

3088

2964

"Catalog: `%s`\n"

3089

2965

"Database: `%s`\n"

3090

2966

"Table: `%s`\n"

3091

2967

"Org_table: `%s`\n"

3092

"Type: UTF-8\n"

2968

"Type: %s\n"

3093

2969

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

3094

2970

"Length: %lu\n"

3095

2971

"Max_length: %lu\n"

3096

2972

"Decimals: %u\n"

3097

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

2973

"Flags: %s\n\n",

3098

2974

++i,

3099

2975

drizzle_column_name(field), drizzle_column_catalog(field),

3100

2976

drizzle_column_db(field), drizzle_column_table(field),

3101

2977

drizzle_column_orig_table(field),

3102

2978

fieldtype2str(drizzle_column_type(field)),

2979

get_charset_name(drizzle_column_charset(field)),

3103

2980

drizzle_column_charset(field), drizzle_column_size(field),

3104

2981

drizzle_column_max_size(field), drizzle_column_decimals(field),

3105

2982

fieldflags2str(drizzle_column_flags(field)));

3107

2984

tee_puts("", PAGER);

3108

2985

}

3109

2986

2987

3110

2988

static void

3111

2989

print_table_data(drizzle_result_st *result)

3112

2990

{

3113

2991

drizzle_row_t cur;

3114

2992

drizzle_return_t ret;

3115

2993

drizzle_column_st *field;

3116

std::vector<bool> num_flag;

2994

bool *num_flag;

3117

2995

string separator;

3118

2996

3119

2997

separator.reserve(256);

3120

2998

3121

num_flag.resize(drizzle_result_column_count(result));

2999

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

3122

3000

if (column_types_flag)

3123

3001

{

3124

3002

print_field_types(result);

3136

3014

uint32_t name_length= strlen(drizzle_column_name(field));

3137

3015

3138

3016

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

3139

of visual length since multibyte characters can affect the

3140

length of the separator. */

3141

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

3142

3023

3143

3024

if (name_length == drizzle_column_max_size(field))

3144

3025

{

3150

3031

length= name_length;

3151

3032

}

3152

3033

}

3153

3034

3154

3035

if (quick)

3155

3036

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

3156

3037

else

3176

3057

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

3177

3058

{

3178

3059

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

3179

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

3180

3064

uint32_t display_length= drizzle_column_max_size(field) + name_length -

3181

numcells;

3065

numcells;

3182

3066

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

3183

3067

MAX_COLUMN_LENGTH),

3184

3068

drizzle_column_name(field));

3239

3123

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

3240

3124

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

3241

3125

3242

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

3126

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

3243

3127

extra_padding= data_length - visible_length;

3244

3128

3245

3129

if (field_max_length > MAX_COLUMN_LENGTH)

3259

3143

drizzle_row_free(result, cur);

3260

3144

}

3261

3145

tee_puts(separator.c_str(), PAGER);

3146

free(num_flag);

3262

3147

}

3263

3148

3264

3149

/**

3265

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

3266

3267

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

3268

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

3269

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

3270

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

3271

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

3272

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

3273

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

3274

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

3275

3276

@param field Pointer to a field to be inspected

3277

3278

@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

3279

3164

3280

3165

static int get_field_disp_length(drizzle_column_st *field)

3281

3166

{

3287

3172

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

3288

3173

3289

3174

if (length < 4 &&

3290

!(drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_NOT_NULL))

3175

!(drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_NOT_NULL))

3291

3176

{

3292

3177

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

3293

3178

}

3296

3181

}

3297

3182

3298

3183

/**

3299

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

3300

upcoming row may return.

3301

3302

@param result Pointer to the result to judge

3303

3304

@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

3305

3190

3306

3191

static int get_result_width(drizzle_result_st *result)

3307

3192

{

3406

3291

drizzle_row_t cur;

3407

3292

uint64_t num_rows;

3408

3293

uint32_t new_code= 0;

3409

FILE *out;

3410

3294

3411

3295

/* Get the warnings */

3412

3296

query= "show warnings";

3426

3310

warning.

3427

3311

3428

3312

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

3429

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

3313

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

3430

3314

{

3431

3315

goto end;

3432

3316

}

3433

3317

3434

3318

/* Print the warnings */

3435

if (status.getBatch())

3436

{

3437

out= stderr;

3438

}

3439

else

3440

{

3441

init_pager();

3442

out= PAGER;

3443

}

3319

init_pager();

3444

3320

3445

3321

{

3446

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

3447

3323

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

3448

3449

if (not status.getBatch())

3450

end_pager();

3324

end_pager();

3451

3325

3452

3326

end:

3453

3327

drizzle_result_free(&result);

3466

3340

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

3467

3341

{

3468

3342

int l;

3469

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

3343

if (use_mb(charset_info) &&

3344

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

3470

3345

{

3471

3346

while (l--)

3472

3347

tee_putc(*pos++, PAGER);

3543

3418

char file_name[FN_REFLEN], *end;

3544

3419

const char *param;

3545

3420

3546

if (status.getBatch())

3421

if (status.batch)

3547

3422

return 0;

3548

while (isspace(*line))

3423

while (my_isspace(charset_info,*line))

3549

3424

line++;

3550

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

3551

3426

{

3552

if (outfile.empty())

3427

if (!strlen(outfile))

3553

3428

{

3554

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

3429

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

3555

3430

return 0;

3556

3431

}

3557

3432

else if (opt_outfile)

3558

3433

{

3559

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

3434

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

3560

3435

return 0;

3561

3436

}

3562

3437

else

3563

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

3438

param = outfile; //resume using the old outfile

3564

3439

}

3565

3440

3566

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

3567

3441

/* eliminate the spaces before the parameters */

3568

while (isspace(*param))

3442

while (my_isspace(charset_info,*param))

3569

3443

param++;

3570

3444

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

3571

3445

end= file_name + strlen(file_name);

3572

3446

/* remove end space from command line */

3573

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

3574

iscntrl(end[-1])))

3447

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

3448

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

3575

3449

end--;

3576

3450

end[0]= 0;

3577

3451

if (end == file_name)

3578

3452

{

3579

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

3453

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

3580

3454

return 0;

3581

3455

}

3582

3456

init_tee(file_name);

3589

3463

{

3590

3464

if (opt_outfile)

3591

3465

end_tee();

3592

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

3466

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

3593

3467

return 0;

3594

3468

}

3595

3469

3600

3474

static int

3601

3475

com_pager(string *, const char *line)

3602

3476

{

3477

char pager_name[FN_REFLEN], *end;

3603

3478

const char *param;

3604

3479

3605

if (status.getBatch())

3480

if (status.batch)

3606

3481

return 0;

3607

3482

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

3608

while (isspace(*line))

3483

while (my_isspace(charset_info, *line))

3609

3484

line++;

3610

3485

/* Skip the pager command */

3611

3486

param= strchr(line, ' ');

3612

3487

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

3613

while (param && isspace(*param))

3488

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

3614

3489

param++;

3615

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

3616

3491

{

3617

3492

if (!default_pager_set)

3618

3493

{

3619

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

3494

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

3620

3495

opt_nopager=1;

3621

pager.assign("stdout");

3496

strcpy(pager, "stdout");

3622

3497

PAGER= stdout;

3623

3498

return 0;

3624

3499

}

3625

pager.assign(default_pager);

3500

strcpy(pager, default_pager);

3626

3501

}

3627

3502

else

3628

3503

{

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

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

3637

3512

}

3638

3513

opt_nopager=0;

3639

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

3514

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

3640

3515

return 0;

3641

3516

}

3642

3517

3644

3519

static int

3645

3520

com_nopager(string *, const char *)

3646

3521

{

3647

pager.assign("stdout");

3522

strcpy(pager, "stdout");

3648

3523

opt_nopager=1;

3649

3524

PAGER= stdout;

3650

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

3525

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

3651

3526

return 0;

3652

3527

}

3653

3528

3657

3532

com_quit(string *, const char *)

3658

3533

{

3659

3534

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

3660

status.setExitStatus(0);

3535

status.exit_status=0;

3661

3536

return 1;

3662

3537

}

3663

3538

3705

3580

tmp= get_arg(buff, 0);

3706

3581

if (tmp && *tmp)

3707

3582

{

3708

current_db.erase();

3709

current_db.assign(tmp);

3583

free(current_db);

3584

current_db= strdup(tmp);

3710

3585

tmp= get_arg(buff, 1);

3711

3586

if (tmp)

3712

3587

{

3713

current_host.erase();

3588

free(current_host);

3714

3589

current_host=strdup(tmp);

3715

3590

}

3716

3591

}

3725

3600

}

3726

3601

else

3727

3602

opt_rehash= 0;

3728

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

3603

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

3729

3604

opt_rehash= save_rehash;

3730

3605

3731

3606

if (connected)

3732

3607

{

3733

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

3608

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

3734

3609

put_info(buff,INFO_INFO,0,0);

3735

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

3736

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

3610

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

3611

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

3737

3612

put_info(buff,INFO_INFO,0,0);

3738

3613

}

3739

3614

return error;

3746

3621

const char *param;

3747

3622

LineBuffer *line_buff;

3748

3623

int error;

3749

Status old_status;

3624

STATUS old_status;

3750

3625

FILE *sql_file;

3751

3626

3752

3627

/* Skip space from file name */

3753

while (isspace(*line))

3628

while (my_isspace(charset_info,*line))

3754

3629

line++;

3755

3630

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

3756

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

3631

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

3757

3632

INFO_ERROR, 0,0);

3758

while (isspace(*param))

3633

while (my_isspace(charset_info,*param))

3759

3634

param++;

3760

3635

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

3761

3636

end+= strlen(source_name);

3762

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

3763

iscntrl(end[-1])))

3637

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

3638

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

3764

3639

end--;

3765

3640

end[0]=0;

3766

3641

internal::unpack_filename(source_name,source_name);

3767

3642

/* open file name */

3768

3643

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

3769

3644

{

3770

3645

char buff[FN_REFLEN+60];

3771

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

3772

3647

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

3773

3648

}

3774

3649

3776

3651

if (line_buff == NULL)

3777

3652

{

3778

3653

fclose(sql_file);

3779

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

3654

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

3780

3655

}

3781

3656

3782

3657

/* Save old status */

3784

3659

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

3785

3660

3786

3661

// Run in batch mode

3787

status.setBatch(old_status.getBatch());

3788

status.setLineBuff(line_buff);

3789

status.setFileName(source_name);

3662

status.batch=old_status.batch;

3663

status.line_buff=line_buff;

3664

status.file_name=source_name;

3790

3665

// Empty command buffer

3791

3666

assert(glob_buffer!=NULL);

3792

3667

glob_buffer->clear();

3794

3669

// Continue as before

3795

3670

status=old_status;

3796

3671

fclose(sql_file);

3797

delete status.getLineBuff();

3798

line_buff=0;

3799

status.setLineBuff(0);

3672

delete status.line_buff;

3673

line_buff= status.line_buff= 0;

3800

3674

return error;

3801

3675

}

3802

3676

3812

3686

3813

3687

if (!tmp || !*tmp)

3814

3688

{

3815

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

3816

3690

INFO_ERROR, 0, 0);

3817

3691

return 0;

3818

3692

}

3820

3694

{

3821

3695

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

3822

3696

{

3823

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

3697

put_info("DELIMITER cannot contain a backslash character",

3824

3698

INFO_ERROR, 0, 0);

3825

3699

return 0;

3826

3700

}

3845

3719

tmp= get_arg(buff, 0);

3846

3720

if (!tmp || !*tmp)

3847

3721

{

3848

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

3722

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

3849

3723

return 0;

3850

3724

}

3851

3725

3855

3729

3856

3730

get_current_db();

3857

3731

3858

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

3732

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

3859

3733

{

3860

3734

if (one_database)

3861

3735

{

3907

3781

else

3908

3782

drizzle_result_free(&result);

3909

3783

}

3910

current_db.erase();

3911

current_db.assign(tmp);

3784

free(current_db);

3785

current_db= strdup(tmp);

3912

3786

if (select_db > 1)

3913

3787

build_completion_hash(opt_rehash, 1);

3914

3788

}

3915

3789

3916

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

3790

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

3917

3791

return 0;

3918

3792

}

3919

3793

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

3794

static int

3959

3795

com_warnings(string *, const char *)

3960

3796

{

3961

3797

show_warnings = 1;

3962

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

3798

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

3963

3799

return 0;

3964

3800

}

3965

3801

3967

3803

com_nowarnings(string *, const char *)

3968

3804

{

3969

3805

show_warnings = 0;

3970

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

3806

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

3971

3807

return 0;

3972

3808

}

3973

3809

3997

3833

else

3998

3834

{

3999

3835

/* skip leading white spaces */

4000

while (isspace(*ptr))

3836

while (my_isspace(charset_info, *ptr))

4001

3837

ptr++;

4002

3838

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

4003

3839

ptr+= 2;

4004

3840

else

4005

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

3841

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

4006

3842

ptr++;

4007

3843

}

4008

3844

if (!*ptr)

4009

3845

return NULL;

4010

while (isspace(*ptr))

3846

while (my_isspace(charset_info, *ptr))

4011

3847

ptr++;

4012

3848

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

4013

3849

{

4034

3870

4035

3871

4036

3872

static int

4037

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

4038

uint32_t silent)

3873

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

3874

uint32_t silent)

4039

3875

{

4040

3876

drizzle_return_t ret;

3877

4041

3878

if (connected)

4042

3879

{

4043

3880

connected= 0;

4045

3882

drizzle_free(&drizzle);

4046

3883

}

4047

3884

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)

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)

4059

3887

{

4060

3888

(void) put_error(&con, NULL);

4061

3889

(void) fflush(stdout);

4062

3890

return 1;

4063

3891

}

4064

3892

4065

/* XXX add this back in

4066

if (opt_connect_timeout)

4067

{

3893

/* XXX add this back in

3894

if (opt_connect_timeout)

3895

{

4068

3896

uint32_t timeout=opt_connect_timeout;

4069

3897

drizzleclient_options(&drizzle,DRIZZLE_OPT_CONNECT_TIMEOUT,

4070

(char*) &timeout);

4071

}

4072

3898

(char*) &timeout);

3899

}

3900

4073

3901

4074

/* XXX Do we need this?

4075

if (safe_updates)

4076

{

3902

/* XXX Do we need this?

3903

if (safe_updates)

3904

{

4077

3905

char init_command[100];

4078

3906

sprintf(init_command,

4079

"SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%"PRIu32

4080

",MAX_JOIN_SIZE=%"PRIu32,

4081

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

4082

3910

drizzleclient_options(&drizzle, DRIZZLE_INIT_COMMAND, init_command);

4083

}

4084

3911

}

3912

4085

3913

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

4086

3914

{

4087

3915

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

4103

3931

static int

4104

3932

com_status(string *, const char *)

4105

3933

{

4106

4107

char buff[40];

4108

uint64_t id;

4109

3934

3935

char buff[40];

3936

uint64_t id;

3937

4110

3938

drizzle_result_st result;

4111

3939

drizzle_return_t ret;

4112

3940

4113

3941

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

3942

usage(1); /* Print version */

4119

3943

if (connected)

4120

3944

{

4121

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

4122

3946

4123

3947

Don't remove "limit 1",

4124

3948

it is protection againts SQL_SELECT_LIMIT=0

4130

3954

drizzle_row_t cur=drizzle_row_next(&result);

4131

3955

if (cur)

4132

3956

{

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

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

4135

3959

}

4136

3960

drizzle_result_free(&result);

4137

3961

}

4138

3962

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

4139

3963

drizzle_result_free(&result);

4140

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

3964

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

4141

3965

}

4142

3966

else

4143

3967

{

4144

3968

vidattr(A_BOLD);

4145

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

3969

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

4146

3970

vidattr(A_NORMAL);

4147

3971

return 0;

4148

3972

}

4149

3973

if (skip_updates)

4150

3974

{

4151

3975

vidattr(A_BOLD);

4152

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

3976

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

4153

3977

vidattr(A_NORMAL);

4154

3978

}

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

4162

/* XXX need to save this from result

4163

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

4164

3987

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

4165

3988

4166

3989

4167

3990

if (drizzle_con_uds(&con))

4168

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

4169

3992

else

4170

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

4171

3994

4172

3995

if (safe_updates)

4173

3996

{

4174

3997

vidattr(A_BOLD);

4175

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

4176

3999

vidattr(A_NORMAL);

4177

tee_fprintf(stdout, _("\

4178

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

4179

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

4180

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

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

4182

4005

select_limit, max_join_size);

4183

4006

}

4184

4007

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

4231

4054

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

4232

4055

static int inited=0;

4233

4056

4234

if (status.getBatch())

4057

if (status.batch)

4235

4058

{

4236

4059

if (info_type == INFO_ERROR)

4237

4060

{

4238

4061

(void) fflush(file);

4239

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

4062

fprintf(file,"ERROR");

4240

4063

if (error)

4241

4064

{

4242

4065

if (sqlstate)

4244

4067

else

4245

4068

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

4246

4069

}

4247

if (status.getQueryStartLine() && line_numbers)

4070

if (status.query_start_line && line_numbers)

4248

4071

{

4249

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

4250

if (status.getFileName())

4251

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

4252

4075

}

4253

4076

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

4254

4077

(void) fflush(file);

4279

4102

if (error)

4280

4103

{

4281

4104

if (sqlstate)

4282

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

4105

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

4283

4106

else

4284

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

4107

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

4285

4108

}

4286

4109

else

4287

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

4110

tee_puts("ERROR: ", file);

4288

4111

}

4289

4112

else

4290

4113

vidattr(A_BOLD);

4313

4136

4314

4137

return put_info(error, INFO_ERROR,

4315

4138

res == NULL ? drizzle_con_error_code(local_con) :

4316

drizzle_result_error_code(res),

4139

drizzle_result_error_code(res),

4317

4140

res == NULL ? drizzle_con_sqlstate(local_con) :

4318

drizzle_result_sqlstate(res));

4141

drizzle_result_sqlstate(res));

4319

4142

}

4320

4143

4321

4144

4323

4146

{

4324

4147

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

4325

4148

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

4326

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

4149

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

4327

4150

end--;

4328

4151

uint32_t pos_to_truncate= (end-start);

4329

4152

if (buffer->length() > pos_to_truncate)

4388

4211

4389

4212

4390

4213

/**

4391

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

4392

duration of time.

4214

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

4215

duration of time.

4393

4216

4394

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

4217

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

4395

4218

4396

4219

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

4397

4220

{

4417

4240

tmp_buff_str << tmp;

4418

4241

4419

4242

if (tmp > 1)

4420

tmp_buff_str << _(" hours ");

4243

tmp_buff_str << " hours ";

4421

4244

else

4422

tmp_buff_str << _(" hour ");

4245

tmp_buff_str << " hour ";

4423

4246

}

4424

4247

if (sec >= 60.0)

4425

4248

{

4426

4249

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

4427

4250

sec-=60.0*tmp;

4428

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

4251

tmp_buff_str << tmp << " min ";

4429

4252

}

4430

4253

if (part_second)

4431

4254

tmp_buff_str.precision(2);

4432

4255

else

4433

4256

tmp_buff_str.precision(0);

4434

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

4257

tmp_buff_str << sec << " sec";

4435

4258

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

4436

4259

}

4437

4260

4462

4285

struct tm *t = localtime(&lclock);

4463

4286

4464

4287

/* parse thru the settings for the prompt */

4465

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

4466

while (c != current_prompt.end())

4288

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

4467

4289

{

4468

4290

if (*c != PROMPT_CHAR)

4469

4291

{

4470

processed_prompt->push_back(*c);

4292

processed_prompt->append(c, 1);

4471

4293

}

4472

4294

else

4473

4295

{

4478

4300

switch (*++c) {

4479

4301

case '\0':

4480

4302

// stop it from going beyond if ends with %

4481

--c;

4303

c--;

4482

4304

break;

4483

4305

case 'c':

4484

4306

add_int_to_prompt(++prompt_counter);

4490

4312

processed_prompt->append("not_connected");

4491

4313

break;

4492

4314

case 'd':

4493

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

4315

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

4494

4316

break;

4495

4317

case 'h':

4496

{

4497

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

4498

if (strstr(prompt, "Localhost"))

4499

processed_prompt->append("localhost");

4500

else

4501

4318

{

4502

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

4503

if (end != NULL)

4504

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;

4505

4330

}

4506

break;

4507

}

4508

4331

case 'p':

4509

{

4510

if (!connected)

4511

4332

{

4512

processed_prompt->append("not_connected");

4513

break;

4514

}

4333

if (!connected)

4334

{

4335

processed_prompt->append("not_connected");

4336

break;

4337

}

4515

4338

4516

if (drizzle_con_uds(&con))

4517

{

4518

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

4519

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

4520

4346

}

4521

else

4522

add_int_to_prompt(drizzle_con_port(&con));

4523

}

4524

break;

4347

break;

4525

4348

case 'U':

4526

4349

if (!full_username)

4527

4350

init_username();

4528

4351

processed_prompt->append(full_username ? full_username :

4529

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

4352

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

4530

4353

break;

4531

4354

case 'u':

4532

4355

if (!full_username)

4533

4356

init_username();

4534

4357

processed_prompt->append(part_username ? part_username :

4535

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

4358

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

4536

4359

break;

4537

4360

case PROMPT_CHAR:

4538

4361

{

4614

4437

processed_prompt->append(delimiter_str);

4615

4438

break;

4616

4439

default:

4617

processed_prompt->push_back(*c);

4440

processed_prompt->append(c, 1);

4618

4441

}

4619

4442

}

4620

++c;

4621

4443

}

4622

4444

return processed_prompt->c_str();

4623

4445

}

4632

4454

4633

4455

static void init_username()

4634

4456

{

4635

/* XXX need this?

4636

free(full_username);

4637

free(part_username);

4457

/* XXX need this?

4458

free(full_username);

4459

free(part_username);

4638

4460

4639

drizzle_result_st *result;

4640

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

4641

(result=drizzleclient_use_result(&drizzle)))

4642

{

4461

drizzle_result_st *result;

4462

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

4463

(result=drizzleclient_use_result(&drizzle)))

4464

{

4643

4465

drizzle_row_t cur=drizzleclient_fetch_row(result);

4644

4466

full_username= strdup(cur[0]);

4645

4467

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

4646

4468

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

4647

}

4648

4469

}

4470

4649

4471

}

4650

4472

4651

4473

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

4652

4474

{

4653

4475

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

4654

4476

if (ptr == NULL)

4655

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

4477

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

4656

4478

default_prompt);

4657

4479

prompt_counter = 0;

4658

4480

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

4659

4481

if (tmpptr == NULL)

4660

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

4482

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

4661

4483

else

4662

4484

{

4663

current_prompt.erase();

4485

free(current_prompt);

4664

4486

current_prompt= tmpptr;

4665

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

4487

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

4666

4488

}

4667

4489

return 0;

4668

4490

}

4669

4491

4670

4492

4671

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

4672

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

4673

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.

4674

4496

4675

4497

4676

4498

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

Older »