~drizzle-trunk/drizzle/development

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

1345

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

1346

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

1347

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

1348

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

1349

("skip-column-names,N",

1350

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

1351

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

1352

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

1353

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

1354

_("Output in table format."))

1355

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

1356

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

1357

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

1358

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

1359

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

1360

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

1361

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

1362

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

1363

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

1364

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

1365

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

1366

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

1367

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

1368

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

1369

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

1370

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

1371

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

1372

;

1373

1374

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

1375

drizzle_options.add_options()

1376

("disable-auto-rehash,A",

1377

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

1378

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

1379

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

1380

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

1381

_("Database to use."))

1382

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

1383

_("(not used)"))

1384

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

1385

_("Delimiter to be used."))

1386

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

1387

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

1388

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

1389

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

1390

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

1391

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

1392

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

1393

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

1394

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

1395

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

1396

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

1397

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

1398

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

1399

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

1400

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

1401

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

1402

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

1403

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

1404

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

1405

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

1406

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

1407

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

1408

_("Shutdown the server"))

1409

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

1410

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

1411

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

1412

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

1413

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

1414

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

1415

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

1416

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

1417

_("Max length of input line"))

1418

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

1419

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

1420

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

1421

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

1422

;

1423

1424

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

1425

client_options.add_options()

1426

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

1427

_("Connect to host"))

1428

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

1429

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

1430

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

1431

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

1432

#ifdef DRIZZLE_ADMIN_TOOL

1433

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

1434

#else

1435

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

1436

#endif

1437

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

1438

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

1439

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

1440

;

1441

1442

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

1443

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

1444

1445

std::string system_config_dir_drizzle(SYSCONFDIR);

1446

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

1447

1448

std::string system_config_dir_client(SYSCONFDIR);

1449

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

1450

1451

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

1452

1453

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

1454

{

1455

char *homedir;

1456

homedir= getenv("HOME");

1457

if (homedir != NULL)

1458

user_config_dir.replace(0, 1, homedir);

1459

}

1460

1461

po::variables_map vm;

1462

1463

po::positional_options_description p;

1464

p.add("database", 1);

1465

1466

// Disable allow_guessing

1467

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

1468

1469

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

1470

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

1471

vm);

1472

1473

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

1474

{

1475

std::string user_config_dir_drizzle(user_config_dir);

1476

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

1477

1478

std::string user_config_dir_client(user_config_dir);

1479

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

1480

1481

ifstream user_drizzle_ifs(user_config_dir_drizzle.c_str());

1482

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

1483

1484

ifstream user_client_ifs(user_config_dir_client.c_str());

1485

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

1486

1487

ifstream system_drizzle_ifs(system_config_dir_drizzle.c_str());

1488

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

1489

1490

ifstream system_client_ifs(system_config_dir_client.c_str());

1491

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

1492

}

1493

1494

po::notify(vm);

1495

1496

#ifdef DRIZZLE_ADMIN_TOOL

1497

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1498

getenv("DRIZZLE_PS1") :

1499

"drizzleadmin> ");

1500

#else

1153

bindtextdomain("drizzle", LOCALEDIR);

1154

textdomain("drizzle");

1155

#endif

1156

1157

MY_INIT(argv[0]);

1158

delimiter_str= delimiter;

1501

1159

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1502

1160

getenv("DRIZZLE_PS1") :

1503

1161

"drizzle> ");

1504

#endif

1162

1505

1163

if (default_prompt == NULL)

1506

1164

{

1507

1165

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

1508

1166

"prompt. Aborting.\n"));

1509

1167

exit(ENOMEM);

1510

1168

}

1511

1512

if (current_prompt.empty())

1513

current_prompt= strdup(default_prompt);

1514

1515

if (current_prompt.empty())

1169

current_prompt= strdup(default_prompt);

1170

if (current_prompt == NULL)

1516

1171

{

1517

1172

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

1518

1173

"prompt. Aborting.\n"));

1523

1178

1524

1179

prompt_counter=0;

1525

1180

1526

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

1527

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

1181

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

1182

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

1528

1183

{

1529

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

1184

char *tmp=getenv("PAGER");

1530

1185

if (tmp && strlen(tmp))

1531

1186

{

1532

1187

default_pager_set= 1;

1533

default_pager.assign(tmp);

1188

strcpy(default_pager, tmp);

1534

1189

}

1535

1190

}

1536

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

1191

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

1537

1192

{

1538

status.setBatch(1); opt_silent=1;

1193

status.batch=1; opt_silent=1;

1194

ignore_errors=0;

1539

1195

}

1540

1196

else

1541

status.setAddToHistory(1);

1542

status.setExitStatus(1);

1197

status.add_to_history=1;

1198

status.exit_status=1;

1543

1199

1544

1200

{

1545

1201

1555

1211

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

1556

1212

}

1557

1213

1558

/* Inverted Booleans */

1559

1560

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

1561

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

1562

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

1563

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

1564

1565

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

1566

if (vm.count("shutdown"))

1567

{

1568

opt_rehash= false;

1569

opt_shutdown= true;

1570

}

1571

1572

if (vm.count("delimiter"))

1573

{

1574

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

1575

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

1576

{

1577

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

1578

}

1579

else

1580

{

1581

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

1582

INFO_ERROR,0,0);

1583

exit(-1);

1584

}

1585

1586

delimiter_length= (uint32_t)strlen(delimiter);

1587

}

1588

if (vm.count("tee"))

1589

{

1590

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

1591

{

1592

if (opt_outfile)

1593

end_tee();

1594

}

1595

else

1596

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

1597

}

1598

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

1599

{

1600

if (opt_outfile)

1601

end_tee();

1602

}

1603

if (vm.count("pager"))

1604

{

1605

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

1606

opt_nopager= 1;

1607

else

1608

{

1609

opt_nopager= 0;

1610

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

1611

{

1612

default_pager_set= 1;

1613

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

1614

default_pager.assign(pager);

1615

}

1616

else if (default_pager_set)

1617

pager.assign(default_pager);

1618

else

1619

opt_nopager= 1;

1620

}

1621

}

1622

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

1623

{

1624

opt_nopager= 1;

1625

}

1626

1627

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

1628

opt_rehash= 0;

1629

1630

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

1631

column_names= 0;

1632

1633

if (vm.count("execute"))

1634

{

1635

status.setBatch(1);

1636

status.setAddToHistory(1);

1637

if (status.getLineBuff() == NULL)

1638

status.setLineBuff(opt_max_input_line,NULL);

1639

if (status.getLineBuff() == NULL)

1640

{

1641

exit(1);

1642

}

1643

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

1644

}

1645

1646

if (one_database)

1647

skip_updates= true;

1648

1649

if (vm.count("protocol"))

1650

{

1651

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

1652

opt_protocol.begin(), ::tolower);

1653

1654

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

1655

use_drizzle_protocol=false;

1656

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

1657

use_drizzle_protocol=true;

1658

else

1659

{

1660

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

1661

exit(-1);

1662

}

1663

}

1664

1665

if (vm.count("port"))

1666

{

1667

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

1668

1669

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

1670

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

1671

uint32_t. */

1672

if (opt_drizzle_port > 65535)

1673

{

1674

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

1675

exit(-1);

1676

}

1677

}

1678

1679

if (vm.count("password"))

1680

{

1681

if (!opt_password.empty())

1682

opt_password.erase();

1683

if (current_password == PASSWORD_SENTINEL)

1684

{

1685

opt_password= "";

1686

}

1687

else

1688

{

1689

opt_password= current_password;

1690

tty_password= false;

1691

}

1692

}

1693

else

1694

{

1695

tty_password= true;

1696

}

1697

1698

1699

if (!opt_verbose.empty())

1700

{

1701

verbose= opt_verbose.length();

1702

}

1703

1704

if (vm.count("batch"))

1705

{

1706

status.setBatch(1);

1707

status.setAddToHistory(0);

1708

if (opt_silent < 1)

1709

{

1710

opt_silent= 1;

1711

}

1712

}

1713

if (vm.count("silent"))

1714

{

1715

opt_silent= 2;

1716

}

1717

1718

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

1719

{

1720

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

1721

drizzle_version(), VERSION,

1722

HOST_VENDOR, HOST_OS, HOST_CPU,

1723

rl_library_version);

1724

if (vm.count("version"))

1725

exit(0);

1726

1727

"This software comes with ABSOLUTELY NO WARRANTY. "

1728

"This is free software,\n"

1729

"and you are welcome to modify and redistribute it "

1730

"under the GPL license\n"));

1731

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

1732

cout << long_options;

1733

exit(0);

1734

}

1735

1736

1737

if (process_options())

1738

{

1214

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

1215

defaults_argv=argv;

1216

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

1217

{

1218

free_defaults(defaults_argv);

1219

my_end(0);

1739

1220

exit(1);

1740

1221

}

1741

1222

1742

1223

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

1743

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

1224

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

1225

opt_silent))

1744

1226

{

1745

1227

quick= 1; // Avoid history

1746

status.setExitStatus(1);

1228

status.exit_status= 1;

1747

1229

drizzle_end(-1);

1748

1230

}

1749

1231

1751

1233

if (execute_commands(&command_error) != false)

1752

1234

{

1753

1235

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

1236

free_defaults(defaults_argv);

1237

my_end(0);

1754

1238

exit(command_error);

1755

1239

}

1756

1240

1757

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

1241

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

1758

1242

{

1759

status.setLineBuff(opt_max_input_line, stdin);

1760

if (status.getLineBuff() == NULL)

1243

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

1244

if (status.line_buff == NULL)

1761

1245

{

1246

free_defaults(defaults_argv);

1247

my_end(0);

1762

1248

exit(1);

1763

1249

}

1764

1250

}

1765

1251

1766

if (!status.getBatch())

1252

if (!status.batch)

1767

1253

ignore_errors=1; // Don't abort monitor

1768

1254

1769

1255

if (opt_sigint_ignore)

1778

1264

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

1779

1265

window_resize(0);

1780

1266

#endif

1781

std::vector<char> output_buff;

1782

output_buff.resize(512);

1783

1784

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

1785

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

1786

delimiter);

1787

1788

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

1267

1268

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

1269

INFO_INFO,0,0);

1789

1270

1790

1271

glob_buffer= new string();

1791

1272

glob_buffer->reserve(512);

1792

1273

1793

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

1794

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

1274

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

1275

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

1276

1277

sprintf(output_buff,

1278

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

1795

1279

drizzle_con_thread_id(&con),

1796

opt_protocol.c_str(),

1797

1280

server_version_string(&con));

1798

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

1799

1800

1801

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

1802

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

1281

put_info(output_buff, INFO_INFO, 0, 0);

1282

1283

initialize_readline(current_prompt);

1284

if (!status.batch && !quick)

1803

1285

{

1804

1286

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

1805

1287

if (getenv("DRIZZLE_HISTFILE"))

1835

1317

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

1836

1318

}

1837

1319

}

1320

sprintf(buff, "%s",

1321

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

1838

1322

1839

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

1840

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

1841

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

1323

put_info(buff,INFO_INFO,0,0);

1324

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

1842

1325

if (opt_outfile)

1843

1326

end_tee();

1844

1327

drizzle_end(0);

1845

}

1846

1328

1847

catch(exception &err)

1848

{

1849

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

1850

}

1851

1329

return(0); // Keep compiler happy

1852

1330

}

1853

1331

1855

1333

{

1856

1334

drizzle_con_free(&con);

1857

1335

drizzle_free(&drizzle);

1858

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

1336

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

1859

1337

{

1860

1338

/* write-history */

1861

1339

if (verbose)

1862

1340

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

1863

1341

if (!write_history(histfile_tmp))

1864

rename(histfile_tmp, histfile);

1342

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

1865

1343

}

1866

delete status.getLineBuff();

1867

status.setLineBuff(0);

1344

batch_readline_end(status.line_buff);

1868

1345

1869

1346

if (sig >= 0)

1870

1347

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

1871

delete glob_buffer;

1872

delete processed_prompt;

1873

opt_password.erase();

1348

if (glob_buffer)

1349

delete glob_buffer;

1350

if (processed_prompt)

1351

delete processed_prompt;

1352

free(opt_password);

1353

free(opt_drizzle_unix_port);

1874

1354

free(histfile);

1875

1355

free(histfile_tmp);

1876

current_db.erase();

1877

current_host.erase();

1878

current_user.erase();

1356

free(current_db);

1357

free(current_host);

1358

free(current_user);

1879

1359

free(full_username);

1880

1360

free(part_username);

1881

1361

free(default_prompt);

1882

current_prompt.erase();

1883

exit(status.getExitStatus());

1362

free(current_prompt);

1363

free_defaults(defaults_argv);

1364

my_end(my_end_arg);

1365

exit(status.exit_status);

1884

1366

}

1885

1367

1886

1368

1893

1375

void handle_sigint(int sig)

1894

1376

{

1895

1377

char kill_buffer[40];

1896

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

1378

drizzle_con_st kill_drizzle;

1897

1379

drizzle_result_st res;

1898

1380

drizzle_return_t ret;

1899

1381

1902

1384

goto err;

1903

1385

}

1904

1386

1905

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

1906

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

1907

use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)

1387

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

1388

opt_drizzle_port, current_user, opt_password, NULL,

1389

DRIZZLE_CON_NONE) == NULL)

1908

1390

{

1909

1391

goto err;

1910

1392

}

1913

1395

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

1914

1396

drizzle_con_thread_id(&con));

1915

1397

1916

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

1398

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

1917

1399

drizzle_result_free(&res);

1918

1400

1919

drizzle_con_free(kill_drizzle.get());

1401

drizzle_con_free(&kill_drizzle);

1920

1402

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

1921

1403

1922

1404

interrupted_query= 1;

1938

1420

}

1939

1421

#endif

1940

1422

1941

1942

1943

static int process_options(void)

1423

static struct my_option my_long_options[] =

1424

{

1425

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

1426

0, 0, 0, 0, 0},

1427

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

1428

0, 0, 0, 0, 0},

1429

{"auto-rehash", OPT_AUTO_REHASH,

1430

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

1431

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

1432

0, 0},

1433

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

1434

N_("No automatic rehashing. One has to use 'rehash' to get table and field completion. This gives a quicker start of drizzle_st and disables rehashing on reconnect. WARNING: options deprecated; use --disable-auto-rehash instead."),

1435

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

1436

{"auto-vertical-output", OPT_AUTO_VERTICAL_OUTPUT,

1437

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

1438

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

1439

{"batch", 'B',

1440

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

1441

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

1442

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

1443

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

1444

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

1445

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

1446

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

1447

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

1448

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

1449

0, 0, 0},

1450

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

1451

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

1452

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

1453

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

1454

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

1455

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

1456

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

1457

{"default-character-set", OPT_DEFAULT_CHARSET,

1458

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

1459

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

1460

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

1461

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

1462

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

1463

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

1464

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

1465

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

1466

0},

1467

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

1468

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

1469

0, 0, 0, 0},

1470

{"named-commands", 'G',

1471

N_("Enable named commands. Named commands mean this program's internal commands; see drizzle> help . When enabled, the named commands can be used from any line of the query, otherwise only from the first line, before an enter. Disable with --disable-named-commands. This option is disabled by default."),

1472

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

1473

0, 0},

1474

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

1475

N_("Named commands are disabled. Use \\* form only, or use named commands only in the beginning of a line ending with a semicolon (;) Since version 10.9 the client now starts with this option ENABLED by default! Disable with '-G'. Long format commands still work from the first line. WARNING: option deprecated; use --disable-named-commands instead."),

1476

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

1477

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

1478

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

1479

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

1480

(char**) &opt_local_infile,

1481

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

1482

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

1483

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

1484

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

1485

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

1486

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

1487

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

1488

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

1489

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

1490

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

1491

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

1492

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

1493

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

1494

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

1495

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

1496

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

1497

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

1498

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

1499

{"set-variable", 'O',

1500

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

1501

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

1502

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

1503

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

1504

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

1505

{"one-database", 'o',

1506

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

1507

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

1508

{"pager", OPT_PAGER,

1509

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

1510

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

1511

{"no-pager", OPT_NOPAGER,

1512

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

1513

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

1514

{"password", 'P',

1515

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

1516

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

1517

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

1518

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

1519

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

1520

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

1521

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

1522

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

1523

{"quick", 'q',

1524

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

1525

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

1526

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

1527

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

1528

0, 0, 0},

1529

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

1530

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

1531

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

1532

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

1533

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

1534

0, 0},

1535

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

1536

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

1537

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

1538

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

1539

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

1540

{"tee", OPT_TEE,

1541

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

1542

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

1543

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

1544

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

1545

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

1546

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

1547

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

1548

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

1549

0, 0, 0, 0},

1550

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

1551

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

1552

0, 0, 0, 0},

1553

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

1554

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

1555

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

1556

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

1557

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

1558

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

1559

{"connect_timeout", OPT_CONNECT_TIMEOUT,

1560

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

1561

(char**) &opt_connect_timeout,

1562

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

1563

0, 0},

1564

{"max_input_line", OPT_MAX_INPUT_LINE,

1565

N_("Max length of input line"),

1566

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

1567

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

1568

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

1569

{"select_limit", OPT_SELECT_LIMIT,

1570

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

1571

(char**) &select_limit,

1572

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

1573

0, 1, 0},

1574

{"max_join_size", OPT_MAX_JOIN_SIZE,

1575

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

1576

(char**) &max_join_size,

1577

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

1578

0, 1, 0},

1579

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

1580

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

1581

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

1582

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

1583

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

1584

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

1585

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

1586

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

1587

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

1588

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

1589

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

1590

};

1591

1592

1593

static void usage(int version)

1594

{

1595

const char* readline= "readline";

1596

1597

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

1598

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

1599

HOST_VENDOR, HOST_OS, HOST_CPU,

1600

readline, rl_library_version);

1601

1602

if (version)

1603

return;

1604

1605

"This software comes with ABSOLUTELY NO WARRANTY. "

1606

"This is free software,\n"

1607

"and you are welcome to modify and redistribute it "

1608

"under the GPL license\n"));

1609

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

1610

my_print_help(my_long_options);

1611

print_defaults("drizzle", load_default_groups);

1612

my_print_variables(my_long_options);

1613

}

1614

1615

1616

extern "C" bool

1617

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

1618

{

1619

char *endchar= NULL;

1620

uint64_t temp_drizzle_port= 0;

1621

1622

switch(optid) {

1623

case OPT_DEFAULT_CHARSET:

1624

default_charset_used= 1;

1625

break;

1626

case OPT_DELIMITER:

1627

if (argument == disabled_my_option)

1628

{

1629

strcpy(delimiter, DEFAULT_DELIMITER);

1630

}

1631

else

1632

{

1633

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

1634

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

1635

{

1636

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

1637

}

1638

else

1639

{

1640

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

1641

INFO_ERROR,0,0);

1642

return false;

1643

}

1644

}

1645

delimiter_length= (uint32_t)strlen(delimiter);

1646

delimiter_str= delimiter;

1647

break;

1648

case OPT_TEE:

1649

if (argument == disabled_my_option)

1650

{

1651

if (opt_outfile)

1652

end_tee();

1653

}

1654

else

1655

init_tee(argument);

1656

break;

1657

case OPT_NOTEE:

1658

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

1659

if (opt_outfile)

1660

end_tee();

1661

break;

1662

case OPT_PAGER:

1663

if (argument == disabled_my_option)

1664

opt_nopager= 1;

1665

else

1666

{

1667

opt_nopager= 0;

1668

if (argument && strlen(argument))

1669

{

1670

default_pager_set= 1;

1671

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

1672

strcpy(default_pager, pager);

1673

}

1674

else if (default_pager_set)

1675

strcpy(pager, default_pager);

1676

else

1677

opt_nopager= 1;

1678

}

1679

break;

1680

case OPT_NOPAGER:

1681

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

1682

opt_nopager= 1;

1683

break;

1684

case OPT_SERVER_ARG:

1685

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

1686

break;

1687

case 'A':

1688

opt_rehash= 0;

1689

break;

1690

case 'N':

1691

column_names= 0;

1692

break;

1693

case 'e':

1694

status.batch= 1;

1695

status.add_to_history= 0;

1696

if (!status.line_buff)

1697

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

1698

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

1699

return 1;

1700

break;

1701

case 'o':

1702

if (argument == disabled_my_option)

1703

one_database= 0;

1704

else

1705

one_database= skip_updates= 1;

1706

break;

1707

case 'p':

1708

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

1709

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

1710

if (strlen(endchar) != 0)

1711

{

1712

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

1713

return false;

1714

}

1715

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

1716

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

1717

uint32_t. */

1718

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

1719

{

1720

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

1721

return false;

1722

}

1723

else

1724

{

1725

opt_drizzle_port= (uint32_t) temp_drizzle_port;

1726

}

1727

break;

1728

case 'P':

1729

/* Don't require password */

1730

if (argument == disabled_my_option)

1731

{

1732

argument= (char*) "";

1733

}

1734

if (argument)

1735

{

1736

char *start= argument;

1737

free(opt_password);

1738

opt_password= strdup(argument);

1739

while (*argument)

1740

{

1741

/* Overwriting password with 'x' */

1742

*argument++= 'x';

1743

}

1744

if (*start)

1745

{

1746

start[1]= 0;

1747

}

1748

tty_password= 0;

1749

}

1750

else

1751

{

1752

tty_password= 1;

1753

}

1754

break;

1755

case 's':

1756

if (argument == disabled_my_option)

1757

opt_silent= 0;

1758

else

1759

opt_silent++;

1760

break;

1761

case 'v':

1762

if (argument == disabled_my_option)

1763

verbose= 0;

1764

else

1765

verbose++;

1766

break;

1767

case 'B':

1768

status.batch= 1;

1769

status.add_to_history= 0;

1770

set_if_bigger(opt_silent,1); // more silent

1771

break;

1772

case 'V':

1773

usage(1);

1774

exit(0);

1775

case 'I':

1776

case '?':

1777

usage(0);

1778

exit(0);

1779

}

1780

return 0;

1781

}

1782

1783

1784

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

1944

1785

{

1945

1786

char *tmp, *pagpoint;

1946

1787

int ho_error;

1947

1788

1948

1789

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

1949

1790

if (tmp)

1950

current_host.assign(tmp);

1791

current_host= strdup(tmp);

1951

1792

1952

1793

pagpoint= getenv("PAGER");

1953

1794

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

1954

1795

{

1955

pager.assign("stdout");

1796

strcpy(pager, "stdout");

1956

1797

opt_nopager= 1;

1957

1798

}

1958

1799

else

1959

{

1960

pager.assign(pagpoint);

1961

}

1962

default_pager.assign(pager);

1963

1964

1965

1966

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

1967

{

1968

default_pager.assign("stdout");

1969

pager.assign("stdout");

1800

strcpy(pager, pagpoint);

1801

strcpy(default_pager, pager);

1802

1803

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

1804

exit(ho_error);

1805

1806

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

1807

{

1808

strcpy(default_pager, "stdout");

1809

strcpy(pager, "stdout");

1970

1810

opt_nopager= 1;

1971

1811

default_pager_set= 0;

1972

1812

opt_outfile= 0;

1974

1814

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

1975

1815

}

1976

1816

1817

if (argc > 1)

1818

{

1819

usage(0);

1820

exit(1);

1821

}

1822

if (argc == 1)

1823

{

1824

skip_updates= 0;

1825

free(current_db);

1826

current_db= strdup(*argv);

1827

}

1977

1828

if (tty_password)

1978

1829

opt_password= client_get_tty_password(NULL);

1830

if (debug_info_flag)

1831

my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;

1832

if (debug_check_flag)

1833

my_end_arg= MY_CHECK_ERROR;

1979

1834

return(0);

1980

1835

}

1981

1836

1985

1840

char in_string=0;

1986

1841

uint32_t line_number=0;

1987

1842

bool ml_comment= 0;

1988

Commands *com;

1989

status.setExitStatus(1);

1843

COMMANDS *com;

1844

status.exit_status=1;

1990

1845

1991

1846

for (;;)

1992

1847

{

1993

1848

if (!interactive)

1994

1849

{

1995

if (status.getLineBuff())

1996

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

1997

else

1998

line= 0;

1999

1850

line=batch_readline(status.line_buff);

1851

1852

Skip UTF8 Byte Order Marker (BOM) 0xEFBBBF.

1853

Editors like "notepad" put this marker in

1854

the very beginning of a text file when

1855

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

1856

1857

if (!line_number &&

1858

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

1859

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

1860

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

1861

line+= 3;

2000

1862

line_number++;

2001

1863

if (show_progress_size > 0)

2002

1864

{

2004

1866

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

2005

1867

}

2006

1868

if (!glob_buffer->empty())

2007

status.setQueryStartLine(line_number);

1869

status.query_start_line=line_number;

2008

1870

}

2009

1871

else

2010

1872

{

2011

string prompt(ml_comment

2012

? " /*> "

2013

: glob_buffer->empty()

2014

? construct_prompt()

2015

: not in_string

2016

? " -> "

2017

: in_string == '\''

2018

? " '> "

2019

: in_string == '`'

2020

? " `> "

2021

: " \"> ");

1873

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

1874

(glob_buffer->empty())

1875

? construct_prompt()

1876

: !in_string ? " -> " :

1877

in_string == '\'' ?

1878

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

1879

" `> " :

1880

" \"> "));

2022

1881

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

2023

1882

fflush(OUTFILE);

2024

1883

2025

1884

if (opt_outfile)

2026

fputs(prompt.c_str(), OUTFILE);

2027

line= readline(prompt.c_str());

1885

fputs(prompt, OUTFILE);

1886

line= readline(prompt);

2028

1887

2029

1888

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

2030

1889

which may cause coredump.

2035

1894

// End of file

2036

1895

if (!line)

2037

1896

{

2038

status.setExitStatus(0);

1897

status.exit_status=0;

2039

1898

break;

2040

1899

}

2041

1900

2051

1910

// If buffer was emptied

2052

1911

if (glob_buffer->empty())

2053

1912

in_string=0;

2054

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

1913

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

2055

1914

add_history(line);

2056

1915

continue;

2057

1916

}

2060

1919

}

2061

1920

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

2062

1921

2063

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

1922

if (!interactive && !status.exit_status)

2064

1923

{

2065

1924

remove_cntrl(glob_buffer);

2066

1925

if (!glob_buffer->empty())

2067

1926

{

2068

status.setExitStatus(1);

1927

status.exit_status=1;

2069

1928

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

2070

status.setExitStatus(0);

1929

status.exit_status=0;

2071

1930

}

2072

1931

}

2073

1932

2074

return status.getExitStatus();

1933

return status.exit_status;

2075

1934

}

2076

1935

2077

1936

2078

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

1937

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

2079

1938

{

2080

1939

uint32_t len;

2081

1940

const char *end;

2087

1946

}

2088

1947

else

2089

1948

{

2090

while (isspace(*name))

1949

while (my_isspace(charset_info,*name))

2091

1950

name++;

2092

1951

2093

1952

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

2096

1955

2097

1956

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

2098

1957

!(strlen(name) >= 9 &&

2099

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

2100

return(NULL);

1958

!my_strnncoll(charset_info,

1959

(unsigned char*) name, 9,

1960

(const unsigned char*) "delimiter",

1961

9))))

1962

return((COMMANDS *) 0);

2101

1963

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

2102

1964

{

2103

1965

len=(uint32_t) (end - name);

2104

while (isspace(*end))

1966

while (my_isspace(charset_info,*end))

2105

1967

end++;

2106

1968

if (!*end)

2107

1969

end=0; // no arguments to function

2110

1972

len=(uint32_t) strlen(name);

2111

1973

}

2112

1974

2113

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

1975

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

2114

1976

{

2115

1977

if (commands[i].func &&

2116

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

2117

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

1978

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

2118

1979

{

2119

1980

return(&commands[i]);

2120

1981

}

2121

1982

}

2122

return(NULL);

1983

return((COMMANDS *) 0);

2123

1984

}

2124

1985

2125

1986

2127

1988

bool *ml_comment)

2128

1989

{

2129

1990

unsigned char inchar;

2130

char *pos, *out;

2131

Commands *com;

1991

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

1992

COMMANDS *com;

2132

1993

bool need_space= 0;

2133

1994

bool ss_comment= 0;

2134

1995

2135

1996

2136

1997

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

2137

1998

return(0);

2138

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

1999

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

2139

2000

add_history(line);

2140

2001

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

2141

2002

2144

2005

if (!preserve_comments)

2145

2006

{

2146

2007

// Skip spaces at the beggining of a statement

2147

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

2008

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

2148

2009

(buffer->empty()))

2149

2010

continue;

2150

2011

}

2151

2012

2152

2013

// Accept multi-byte characters as-is

2153

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

2014

int length;

2015

if (use_mb(charset_info) &&

2016

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

2154

2017

{

2155

int length;

2156

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

2018

if (!*ml_comment || preserve_comments)

2157

2019

{

2158

if (!*ml_comment || preserve_comments)

2159

{

2160

while (length--)

2161

*out++ = *pos++;

2162

pos--;

2163

}

2164

else

2165

pos+= length - 1;

2166

continue;

2020

while (length--)

2021

*out++ = *pos++;

2022

pos--;

2167

2023

}

2024

else

2025

pos+= length - 1;

2026

continue;

2168

2027

}

2169

2028

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

2170

2029

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

2190

2049

2191

2050

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

2192

2051

return(1); // Quit

2193

if (com->getTakesParams())

2052

if (com->takes_params)

2194

2053

{

2195

2054

if (ss_comment)

2196

2055

{

2219

2078

}

2220

2079

else

2221

2080

{

2222

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

2223

buff.push_back('\'');

2224

buff.push_back(inchar);

2225

buff.push_back('\'');

2226

buff.push_back('.');

2227

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

2081

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

2082

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

2228

2083

return(1);

2229

2084

*out++='\\';

2230

2085

*out++=(char) inchar;

2233

2088

}

2234

2089

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

2235

2090

(end_of_line - pos) >= 10 &&

2236

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

2091

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

2092

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

2237

2093

{

2238

2094

// Flush previously accepted characters

2239

2095

if (out != line)

2270

2126

2271

2127

if (preserve_comments)

2272

2128

{

2273

while (isspace(*pos))

2129

while (my_isspace(charset_info, *pos))

2274

2130

*out++= *pos++;

2275

2131

}

2276

2132

// Flush previously accepted characters

2283

2139

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

2284

2140

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

2285

2141

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

2286

isspace(pos[2]))))

2142

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

2287

2143

{

2288

2144

// Add trailing single line comments to this statement

2289

2145

buffer->append(pos);

2310

2166

&& (inchar == '#'

2311

2167

|| (inchar == '-'

2312

2168

&& pos[1] == '-'

2313

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

2169

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

2314

2170

{

2315

2171

// Flush previously accepted characters

2316

2172

if (out != line)

2376

2232

*in_string= (char) inchar;

2377

2233

if (!*ml_comment || preserve_comments)

2378

2234

{

2379

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

2235

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

2380

2236

*out++= ' ';

2381

2237

need_space= 0;

2382

2238

*out++= (char) inchar;

2387

2243

{

2388

2244

*out++='\n';

2389

2245

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

2390

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

2391

{

2392

status.setExitStatus(1);

2393

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

2394

return 1;

2395

}

2396

2246

if ((!*ml_comment || preserve_comments))

2397

2247

buffer->append(line, length);

2398

2248

}

2497

2347

2498

2348

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

2499

2349

rl_attempted_completion_function= (rl_completion_func_t*)&mysql_completion;

2500

rl_completion_entry_function= (drizzle_compentry_func_t*)&no_completion;

2350

rl_completion_entry_function= (rl_compentry_func_t*)&no_completion;

2501

2351

}

2502

2352

2503

2353

2509

2359

2510

2360

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

2511

2361

{

2512

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

2362

if (!status.batch && !quick)

2513

2363

return rl_completion_matches(text, new_command_generator);

2514

2364

else

2515

2365

return (char**) 0;

2578

2428

2579

2429

static void build_completion_hash(bool rehash, bool write_info)

2580

2430

{

2581

Commands *cmd=commands;

2431

COMMANDS *cmd=commands;

2582

2432

drizzle_return_t ret;

2583

2433

drizzle_result_st databases,tables,fields;

2584

2434

drizzle_row_t database_row,table_row;

2435

drizzle_column_st *sql_field;

2585

2436

string tmp_str, tmp_str_lower;

2586

std::string query;

2587

2437

2588

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

2438

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

2589

2439

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

2590

2440

if (!rehash)

2591

2441

return;

2593

2443

completion_map.clear();

2594

2444

2595

2445

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

2596

while (cmd->getName()) {

2597

tmp_str= cmd->getName();

2446

while (cmd->name) {

2447

tmp_str= cmd->name;

2598

2448

tmp_str_lower= lower_string(tmp_str);

2599

2449

completion_map[tmp_str_lower]= tmp_str;

2600

2450

cmd++;

2603

2453

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

2604

2454

2605

2455

/* hash all database names */

2606

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

2456

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

2607

2457

{

2608

2458

if (ret == DRIZZLE_RETURN_OK)

2609

2459

{

2623

2473

drizzle_result_free(&databases);

2624

2474

}

2625

2475

2626

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

2627

query.append(current_db);

2628

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

2629

2630

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

2631

&ret) != NULL)

2476

/* hash all table names */

2477

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

2632

2478

{

2633

if (ret == DRIZZLE_RETURN_OK &&

2634

drizzle_result_buffer(&fields) == DRIZZLE_RETURN_OK)

2479

if (ret != DRIZZLE_RETURN_OK)

2480

{

2481

drizzle_result_free(&tables);

2482

return;

2483

}

2484

2485

if (drizzle_result_buffer(&tables) != DRIZZLE_RETURN_OK)

2486

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

2487

else

2635

2488

{

2636

2489

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

2637

2490

{

2638

tee_fprintf(stdout,

2639

_("Reading table information for completion of "

2640

"table and column names\n"

2641

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

2642

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

2491

tee_fprintf(stdout, _("\

2492

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

2493

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

2643

2494

}

2644

2645

std::string table_name;

2646

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

2495

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

2647

2496

{

2648

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

2649

{

2650

tmp_str= table_row[0];

2651

tmp_str_lower= lower_string(tmp_str);

2652

completion_map[tmp_str_lower]= tmp_str;

2653

table_name= table_row[0];

2654

}

2655

2497

tmp_str= table_row[0];

2656

tmp_str.append(".");

2657

tmp_str.append(table_row[1]);

2658

tmp_str_lower= lower_string(tmp_str);

2659

completion_map[tmp_str_lower]= tmp_str;

2660

2661

tmp_str= table_row[1];

2662

tmp_str_lower= lower_string(tmp_str);

2663

completion_map[tmp_str_lower]= tmp_str;

2664

}

2665

}

2666

}

2667

drizzle_result_free(&fields);

2498

tmp_str_lower= lower_string(tmp_str);

2499

completion_map[tmp_str_lower]= tmp_str;

2500

}

2501

}

2502

}

2503

else

2504

return;

2505

2506

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

2507

if (drizzle_result_row_count(&tables) == 0)

2508

{

2509

drizzle_result_free(&tables);

2510

return;

2511

}

2512

2513

drizzle_row_seek(&tables, 0);

2514

2515

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

2516

{

2517

string query;

2518

2519

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

2520

query.append(table_row[0]);

2521

query.append("'");

2522

2523

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

2524

&ret) != NULL)

2525

{

2526

if (ret == DRIZZLE_RETURN_OK &&

2527

drizzle_result_buffer(&fields) == DRIZZLE_RETURN_OK)

2528

{

2529

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

2530

{

2531

tmp_str=table_row[0];

2532

tmp_str.append(".");

2533

tmp_str.append(drizzle_column_name(sql_field));

2534

tmp_str_lower= lower_string(tmp_str);

2535

completion_map[tmp_str_lower]= tmp_str;

2536

2537

tmp_str=drizzle_column_name(sql_field);

2538

tmp_str_lower= lower_string(tmp_str);

2539

completion_map[tmp_str_lower]= tmp_str;

2540

}

2541

}

2542

drizzle_result_free(&fields);

2543

}

2544

}

2545

drizzle_result_free(&tables);

2668

2546

completion_iter= completion_map.begin();

2669

2547

}

2670

2548

2671

2549

/* for gnu readline */

2672

2550

2551

#ifndef HAVE_INDEX

2552

extern "C" {

2553

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

2554

2555

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

2556

{

2557

for (;;)

2558

{

2559

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

2560

if (!*s++) return NULL;

2561

}

2562

}

2563

2564

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

2565

{

2566

2567

2568

t = NULL;

2569

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

2570

return (char*) t;

2571

}

2572

}

2573

#endif

2574

2673

2575

2674

2576

static int reconnect(void)

2675

2577

{

2578

/* purecov: begin tested */

2676

2579

if (opt_reconnect)

2677

2580

{

2678

2581

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

2679

2582

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

2680

if (opt_rehash && connected)

2583

if (opt_rehash)

2681

2584

com_rehash(NULL, NULL);

2682

2585

}

2683

if (! connected)

2586

if (!connected)

2684

2587

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

2588

/* purecov: end */

2685

2589

return 0;

2686

2590

}

2687

2591

2690

2594

drizzle_return_t ret;

2691

2595

drizzle_result_st res;

2692

2596

2693

current_db.erase();

2694

current_db= "";

2597

free(current_db);

2598

current_db= NULL;

2695

2599

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

2696

2600

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

2697

2601

{

2700

2604

{

2701

2605

drizzle_row_t row= drizzle_row_next(&res);

2702

2606

if (row[0])

2703

current_db.assign(row[0]);

2704

drizzle_result_free(&res);

2607

current_db= strdup(row[0]);

2705

2608

}

2609

drizzle_result_free(&res);

2706

2610

}

2707

2611

}

2708

2612

2710

2614

The different commands

2711

2615

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

2712

2616

2713

int drizzleclient_real_query_for_lazy(const char *buf, size_t length,

2617

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2714

2618

drizzle_result_st *result,

2715

2619

uint32_t *error_code)

2716

2620

{

2749

2653

return 0;

2750

2654

2751

2655

if (drizzle_con_error(&con)[0])

2752

{

2753

int ret= put_error(&con, result);

2754

drizzle_result_free(result);

2755

return ret;

2756

}

2656

return put_error(&con, result);

2757

2657

return 0;

2758

2658

}

2759

2659

2762

2662

{

2763

2663

2764

2664

char buff[32], *end;

2765

std::vector<char> output_buff;

2766

output_buff.resize(512);

2767

2665

2768

2666

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

2769

2667

if (!named_cmds)

2770

{

2771

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

2772

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

2773

delimiter);

2774

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

2775

}

2776

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

2777

{

2778

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

2779

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

2780

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

2668

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

2669

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

2670

{

2671

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

2672

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

2673

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

2781

2674

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

2782

2675

if (commands[i].func)

2783

2676

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

2784

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

2677

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

2785

2678

}

2786

2679

tee_fprintf(stdout, "\n");

2787

2680

buffer->clear();

2792

2685

static int

2793

2686

com_clear(string *buffer, const char *)

2794

2687

{

2795

if (status.getAddToHistory())

2688

if (status.add_to_history)

2796

2689

fix_history(buffer);

2797

2690

buffer->clear();

2798

2691

return 0;

2809

2702

com_go(string *buffer, const char *)

2810

2703

{

2811

2704

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

2705

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

2812

2706

drizzle_result_st result;

2813

2707

drizzle_return_t ret;

2814

uint32_t warnings= 0;

2815

boost::posix_time::ptime timer;

2708

uint32_t timer, warnings= 0;

2816

2709

uint32_t error= 0;

2817

2710

uint32_t error_code= 0;

2818

2711

int err= 0;

2825

2718

if (buffer->empty())

2826

2719

{

2827

2720

// Ignore empty quries

2828

if (status.getBatch())

2721

if (status.batch)

2829

2722

return 0;

2830

2723

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

2831

2724

2850

2743

executing_query= 1;

2851

2744

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

2852

2745

2853

if (status.getAddToHistory())

2746

if (status.add_to_history)

2854

2747

{

2855

2748

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

2856

2749

/* Append final command onto history */

2881

2774

goto end;

2882

2775

}

2883

2776

2884

string time_buff("");

2885

2777

if (verbose >= 3 || !opt_silent)

2886

2778

drizzle_end_timer(timer,time_buff);

2779

else

2780

time_buff[0]= '\0';

2887

2781

2888

2782

/* Every branch must truncate buff . */

2889

2783

if (drizzle_result_column_count(&result) > 0)

2934

2828

if (warnings != 1)

2935

2829

*pos++= 's';

2936

2830

}

2937

strcpy(pos, time_buff.c_str());

2831

strcpy(pos, time_buff);

2938

2832

put_info(buff,INFO_RESULT,0,0);

2939

2833

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

2940

2834

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

2970

2864

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

2971

2865

print_warnings(error_code);

2972

2866

2973

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

2867

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

2974

2868

drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)

2975

2869

{

2976

2870

get_current_db();

2985

2879

{

2986

2880

if (!opt_nopager)

2987

2881

{

2988

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

2882

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

2989

2883

{

2990

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

2884

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

2991

2885

PAGER= stdout;

2992

2886

}

2993

2887

}

3009

2903

end_tee();

3010

2904

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

3011

2905

{

3012

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

2906

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

3013

2907

return;

3014

2908

}

3015

2909

OUTFILE = new_outfile;

3016

outfile.assign(file_name);

3017

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

2910

strncpy(outfile, file_name, FN_REFLEN-1);

2911

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

3018

2912

opt_outfile= 1;

3019

2913

3020

2914

return;

3055

2949

case DRIZZLE_COLUMN_TYPE_LONGLONG: return "LONGLONG";

3056

2950

case DRIZZLE_COLUMN_TYPE_NULL: return "NULL";

3057

2951

case DRIZZLE_COLUMN_TYPE_TIMESTAMP: return "TIMESTAMP";

2952

case DRIZZLE_COLUMN_TYPE_TINY: return "TINY";

2953

case DRIZZLE_COLUMN_TYPE_VIRTUAL: return "VIRTUAL";

3058

2954

default: return "?-unknown-?";

3059

2955

}

3060

2956

}

3098

2994

3099

2995

while ((field = drizzle_column_next(result)))

3100

2996

{

3101

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

2997

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

3102

2998

"Catalog: `%s`\n"

3103

"Schema: `%s`\n"

2999

"Database: `%s`\n"

3104

3000

"Table: `%s`\n"

3105

3001

"Org_table: `%s`\n"

3106

"Type: UTF-8\n"

3002

"Type: %s\n"

3107

3003

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

3108

3004

"Length: %lu\n"

3109

3005

"Max_length: %lu\n"

3110

3006

"Decimals: %u\n"

3111

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

3007

"Flags: %s\n\n",

3112

3008

++i,

3113

3009

drizzle_column_name(field), drizzle_column_catalog(field),

3114

3010

drizzle_column_db(field), drizzle_column_table(field),

3115

3011

drizzle_column_orig_table(field),

3116

3012

fieldtype2str(drizzle_column_type(field)),

3013

get_charset_name(drizzle_column_charset(field)),

3117

3014

drizzle_column_charset(field), drizzle_column_size(field),

3118

3015

drizzle_column_max_size(field), drizzle_column_decimals(field),

3119

3016

fieldflags2str(drizzle_column_flags(field)));

3121

3018

tee_puts("", PAGER);

3122

3019

}

3123

3020

3021

3124

3022

static void

3125

3023

print_table_data(drizzle_result_st *result)

3126

3024

{

3127

3025

drizzle_row_t cur;

3128

3026

drizzle_return_t ret;

3129

3027

drizzle_column_st *field;

3130

std::vector<bool> num_flag;

3028

bool *num_flag;

3131

3029

string separator;

3132

3030

3133

3031

separator.reserve(256);

3134

3032

3135

num_flag.resize(drizzle_result_column_count(result));

3033

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

3136

3034

if (column_types_flag)

3137

3035

{

3138

3036

print_field_types(result);

3152

3050

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

3153

3051

of visual length since multibyte characters can affect the

3154

3052

length of the separator. */

3155

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

3053

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

3054

drizzle_column_name(field),

3055

drizzle_column_name(field) +

3056

name_length);

3156

3057

3157

3058

if (name_length == drizzle_column_max_size(field))

3158

3059

{

3190

3091

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

3191

3092

{

3192

3093

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

3193

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

3094

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

3095

drizzle_column_name(field),

3096

drizzle_column_name(field) +

3097

name_length);

3194

3098

uint32_t display_length= drizzle_column_max_size(field) + name_length -

3195

3099

numcells;

3196

3100

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

3253

3157

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

3254

3158

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

3255

3159

3256

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

3160

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

3257

3161

extra_padding= data_length - visible_length;

3258

3162

3259

3163

if (field_max_length > MAX_COLUMN_LENGTH)

3273

3177

drizzle_row_free(result, cur);

3274

3178

}

3275

3179

tee_puts(separator.c_str(), PAGER);

3180

free(num_flag);

3276

3181

}

3277

3182

3278

3183

/**

3420

3325

drizzle_row_t cur;

3421

3326

uint64_t num_rows;

3422

3327

uint32_t new_code= 0;

3423

FILE *out;

3424

3328

3425

3329

/* Get the warnings */

3426

3330

query= "show warnings";

3446

3350

}

3447

3351

3448

3352

/* Print the warnings */

3449

if (status.getBatch())

3450

{

3451

out= stderr;

3452

}

3453

else

3454

{

3455

init_pager();

3456

out= PAGER;

3457

}

3353

init_pager();

3458

3354

3459

3355

{

3460

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

3356

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

3461

3357

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

3462

3463

if (not status.getBatch())

3464

end_pager();

3358

end_pager();

3465

3359

3466

3360

end:

3467

3361

drizzle_result_free(&result);

3480

3374

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

3481

3375

{

3482

3376

int l;

3483

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

3377

if (use_mb(charset_info) &&

3378

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

3484

3379

{

3485

3380

while (l--)

3486

3381

tee_putc(*pos++, PAGER);

3557

3452

char file_name[FN_REFLEN], *end;

3558

3453

const char *param;

3559

3454

3560

if (status.getBatch())

3455

if (status.batch)

3561

3456

return 0;

3562

while (isspace(*line))

3457

while (my_isspace(charset_info,*line))

3563

3458

line++;

3564

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

3459

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

3565

3460

{

3566

if (outfile.empty())

3461

if (!strlen(outfile))

3567

3462

{

3568

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

3463

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

3569

3464

return 0;

3570

3465

}

3571

3466

else if (opt_outfile)

3572

3467

{

3573

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

3468

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

3574

3469

return 0;

3575

3470

}

3576

3471

else

3577

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

3472

param = outfile; //resume using the old outfile

3578

3473

}

3579

3474

3580

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

3581

3475

/* eliminate the spaces before the parameters */

3582

while (isspace(*param))

3476

while (my_isspace(charset_info,*param))

3583

3477

param++;

3584

3478

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

3585

3479

end= file_name + strlen(file_name);

3586

3480

/* remove end space from command line */

3587

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

3588

iscntrl(end[-1])))

3481

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

3482

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

3589

3483

end--;

3590

3484

end[0]= 0;

3591

3485

if (end == file_name)

3592

3486

{

3593

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

3487

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

3594

3488

return 0;

3595

3489

}

3596

3490

init_tee(file_name);

3603

3497

{

3604

3498

if (opt_outfile)

3605

3499

end_tee();

3606

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

3500

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

3607

3501

return 0;

3608

3502

}

3609

3503

3614

3508

static int

3615

3509

com_pager(string *, const char *line)

3616

3510

{

3511

char pager_name[FN_REFLEN], *end;

3617

3512

const char *param;

3618

3513

3619

if (status.getBatch())

3514

if (status.batch)

3620

3515

return 0;

3621

3516

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

3622

while (isspace(*line))

3517

while (my_isspace(charset_info, *line))

3623

3518

line++;

3624

3519

/* Skip the pager command */

3625

3520

param= strchr(line, ' ');

3626

3521

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

3627

while (param && isspace(*param))

3522

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

3628

3523

param++;

3629

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

3524

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

3630

3525

{

3631

3526

if (!default_pager_set)

3632

3527

{

3633

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

3528

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

3634

3529

opt_nopager=1;

3635

pager.assign("stdout");

3530

strcpy(pager, "stdout");

3636

3531

PAGER= stdout;

3637

3532

return 0;

3638

3533

}

3639

pager.assign(default_pager);

3534

strcpy(pager, default_pager);

3640

3535

}

3641

3536

else

3642

3537

{

3643

string pager_name(param);

3644

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

3645

while (end > pager_name.begin() &&

3646

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

3647

--end;

3648

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

3649

pager.assign(pager_name);

3650

default_pager.assign(pager_name);

3538

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

3539

end+= strlen(pager_name);

3540

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

3541

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

3542

end--;

3543

end[0]=0;

3544

strcpy(pager, pager_name);

3545

strcpy(default_pager, pager_name);

3651

3546

}

3652

3547

opt_nopager=0;

3653

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

3548

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

3654

3549

return 0;

3655

3550

}

3656

3551

3658

3553

static int

3659

3554

com_nopager(string *, const char *)

3660

3555

{

3661

pager.assign("stdout");

3556

strcpy(pager, "stdout");

3662

3557

opt_nopager=1;

3663

3558

PAGER= stdout;

3664

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

3559

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

3665

3560

return 0;

3666

3561

}

3667

3562

3671

3566

com_quit(string *, const char *)

3672

3567

{

3673

3568

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

3674

status.setExitStatus(0);

3569

status.exit_status=0;

3675

3570

return 1;

3676

3571

}

3677

3572

3719

3614

tmp= get_arg(buff, 0);

3720

3615

if (tmp && *tmp)

3721

3616

{

3722

current_db.erase();

3723

current_db.assign(tmp);

3617

free(current_db);

3618

current_db= strdup(tmp);

3724

3619

tmp= get_arg(buff, 1);

3725

3620

if (tmp)

3726

3621

{

3727

current_host.erase();

3622

free(current_host);

3728

3623

current_host=strdup(tmp);

3729

3624

}

3730

3625

}

3731

3626

else

3732

3627

{

3733

3628

/* Quick re-connect */

3734

opt_rehash= 0;

3629

opt_rehash= 0; /* purecov: tested */

3735

3630

}

3736

3631

// command used

3737

3632

assert(buffer!=NULL);

3739

3634

}

3740

3635

else

3741

3636

opt_rehash= 0;

3742

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

3637

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

3743

3638

opt_rehash= save_rehash;

3744

3639

3745

3640

if (connected)

3746

3641

{

3747

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

3642

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

3748

3643

put_info(buff,INFO_INFO,0,0);

3749

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

3750

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

3644

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

3645

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

3751

3646

put_info(buff,INFO_INFO,0,0);

3752

3647

}

3753

3648

return error;

3758

3653

{

3759

3654

char source_name[FN_REFLEN], *end;

3760

3655

const char *param;

3761

LineBuffer *line_buff;

3656

LINE_BUFFER *line_buff;

3762

3657

int error;

3763

Status old_status;

3658

STATUS old_status;

3764

3659

FILE *sql_file;

3765

3660

3766

3661

/* Skip space from file name */

3767

while (isspace(*line))

3662

while (my_isspace(charset_info,*line))

3768

3663

line++;

3769

3664

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

3770

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

3665

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

3771

3666

INFO_ERROR, 0,0);

3772

while (isspace(*param))

3667

while (my_isspace(charset_info,*param))

3773

3668

param++;

3774

3669

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

3775

3670

end+= strlen(source_name);

3776

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

3777

iscntrl(end[-1])))

3671

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

3672

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

3778

3673

end--;

3779

3674

end[0]=0;

3780

3675

unpack_filename(source_name,source_name);

3781

3676

/* open file name */

3782

3677

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

3783

3678

{

3784

3679

char buff[FN_REFLEN+60];

3785

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

3680

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

3786

3681

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

3787

3682

}

3788

3683

3789

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

3790

if (line_buff == NULL)

3684

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

3791

3685

{

3792

3686

fclose(sql_file);

3793

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

3687

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

3794

3688

}

3795

3689

3796

3690

/* Save old status */

3798

3692

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

3799

3693

3800

3694

// Run in batch mode

3801

status.setBatch(old_status.getBatch());

3802

status.setLineBuff(line_buff);

3803

status.setFileName(source_name);

3695

status.batch=old_status.batch;

3696

status.line_buff=line_buff;

3697

status.file_name=source_name;

3804

3698

// Empty command buffer

3805

3699

assert(glob_buffer!=NULL);

3806

3700

glob_buffer->clear();

3808

3702

// Continue as before

3809

3703

status=old_status;

3810

3704

fclose(sql_file);

3811

delete status.getLineBuff();

3812

line_buff=0;

3813

status.setLineBuff(0);

3705

batch_readline_end(line_buff);

3814

3706

return error;

3815

3707

}

3816

3708

3826

3718

3827

3719

if (!tmp || !*tmp)

3828

3720

{

3829

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

3721

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

3830

3722

INFO_ERROR, 0, 0);

3831

3723

return 0;

3832

3724

}

3834

3726

{

3835

3727

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

3836

3728

{

3837

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

3729

put_info("DELIMITER cannot contain a backslash character",

3838

3730

INFO_ERROR, 0, 0);

3839

3731

return 0;

3840

3732

}

3859

3751

tmp= get_arg(buff, 0);

3860

3752

if (!tmp || !*tmp)

3861

3753

{

3862

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

3754

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

3863

3755

return 0;

3864

3756

}

3865

3757

3869

3761

3870

3762

get_current_db();

3871

3763

3872

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

3764

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

3873

3765

{

3874

3766

if (one_database)

3875

3767

{

3921

3813

else

3922

3814

drizzle_result_free(&result);

3923

3815

}

3924

current_db.erase();

3925

current_db.assign(tmp);

3816

free(current_db);

3817

current_db= strdup(tmp);

3926

3818

if (select_db > 1)

3927

3819

build_completion_hash(opt_rehash, 1);

3928

3820

}

3929

3821

3930

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

3822

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

3931

3823

return 0;

3932

3824

}

3933

3825

3934

static int com_shutdown(string *, const char *)

3935

{

3936

drizzle_result_st result;

3937

drizzle_return_t ret;

3938

3939

if (verbose)

3940

{

3941

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

3942

if (opt_drizzle_port > 0)

3943

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

3944

printf("... ");

3945

}

3946

3947

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

3948

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

3949

{

3950

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3951

{

3952

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

3953

drizzle_result_error(&result));

3954

drizzle_result_free(&result);

3955

}

3956

else

3957

{

3958

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

3959

drizzle_con_error(&con));

3960

}

3961

return false;

3962

}

3963

3964

drizzle_result_free(&result);

3965

3966

if (verbose)

3967

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

3968

3969

return false;

3970

}

3971

3972

3826

static int

3973

3827

com_warnings(string *, const char *)

3974

3828

{

3975

3829

show_warnings = 1;

3976

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

3830

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

3977

3831

return 0;

3978

3832

}

3979

3833

3981

3835

com_nowarnings(string *, const char *)

3982

3836

{

3983

3837

show_warnings = 0;

3984

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

3838

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

3985

3839

return 0;

3986

3840

}

3987

3841

4011

3865

else

4012

3866

{

4013

3867

/* skip leading white spaces */

4014

while (isspace(*ptr))

3868

while (my_isspace(charset_info, *ptr))

4015

3869

ptr++;

4016

3870

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

4017

3871

ptr+= 2;

4018

3872

else

4019

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

3873

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

4020

3874

ptr++;

4021

3875

}

4022

3876

if (!*ptr)

4023

3877

return NULL;

4024

while (isspace(*ptr))

3878

while (my_isspace(charset_info, *ptr))

4025

3879

ptr++;

4026

3880

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

4027

3881

{

4048

3902

4049

3903

4050

3904

static int

4051

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

3905

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

3906

uint32_t silent)

4052

3907

{

4053

3908

drizzle_return_t ret;

3909

4054

3910

if (connected)

4055

3911

{

4056

3912

connected= 0;

4058

3914

drizzle_free(&drizzle);

4059

3915

}

4060

3916

drizzle_create(&drizzle);

4061

4062

#ifdef DRIZZLE_ADMIN_TOOL

4063

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

4064

#else

4065

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

4066

#endif

4067

4068

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

4069

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

4070

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

4071

options) == NULL)

3917

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

3918

password, database, DRIZZLE_CON_NONE) == NULL)

4072

3919

{

4073

3920

(void) put_error(&con, NULL);

4074

3921

(void) fflush(stdout);

4097

3944

4098

3945

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

4099

3946

{

4100

4101

if (opt_silent < 2)

3947

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

3948

ret != DRIZZLE_RETURN_COULD_NOT_CONNECT))

4102

3949

{

4103

3950

(void) put_error(&con, NULL);

4104

3951

(void) fflush(stdout);

4107

3954

return -1; // Retryable

4108

3955

}

4109

3956

connected=1;

4110

3957

/* XXX hmm?

3958

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

3959

4111

3960

build_completion_hash(opt_rehash, 1);

4112

3961

return 0;

4113

3962

}

4124

3973

drizzle_return_t ret;

4125

3974

4126

3975

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

4127

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

4128

drizzle_version(), VERSION,

4129

HOST_VENDOR, HOST_OS, HOST_CPU,

4130

rl_library_version);

4131

3976

usage(1); /* Print version */

4132

3977

if (connected)

4133

3978

{

4134

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

3979

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

4135

3980

4136

3981

Don't remove "limit 1",

4137

3982

it is protection againts SQL_SELECT_LIMIT=0

4143

3988

drizzle_row_t cur=drizzle_row_next(&result);

4144

3989

if (cur)

4145

3990

{

4146

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

4147

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

3991

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

3992

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

4148

3993

}

4149

3994

drizzle_result_free(&result);

4150

3995

}

4151

3996

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

4152

3997

drizzle_result_free(&result);

4153

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

3998

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

4154

3999

}

4155

4000

else

4156

4001

{

4157

4002

vidattr(A_BOLD);

4158

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

4003

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

4159

4004

vidattr(A_NORMAL);

4160

4005

return 0;

4161

4006

}

4162

4007

if (skip_updates)

4163

4008

{

4164

4009

vidattr(A_BOLD);

4165

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

4010

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

4166

4011

vidattr(A_NORMAL);

4167

4012

}

4168

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

4169

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

4170

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

4171

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

4172

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

4173

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

4174

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

4013

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

4014

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

4015

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

4016

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

4017

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

4018

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

4175

4019

/* XXX need to save this from result

4176

4020

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

4177

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

4021

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

4178

4022

4179

4023

4180

if (drizzle_con_uds(&con))

4181

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

4024

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

4025

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

4182

4026

else

4183

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

4027

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

4184

4028

4185

4029

if (safe_updates)

4186

4030

{

4187

4031

vidattr(A_BOLD);

4188

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

4032

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

4189

4033

vidattr(A_NORMAL);

4190

tee_fprintf(stdout, _("\

4034

tee_fprintf(stdout, "\

4191

4035

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

4192

4036

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

4193

4037

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

4194

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

4038

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

4195

4039

select_limit, max_join_size);

4196

4040

}

4197

4041

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

4244

4088

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

4245

4089

static int inited=0;

4246

4090

4247

if (status.getBatch())

4091

if (status.batch)

4248

4092

{

4249

4093

if (info_type == INFO_ERROR)

4250

4094

{

4251

4095

(void) fflush(file);

4252

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

4096

fprintf(file,"ERROR");

4253

4097

if (error)

4254

4098

{

4255

4099

if (sqlstate)

4257

4101

else

4258

4102

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

4259

4103

}

4260

if (status.getQueryStartLine() && line_numbers)

4104

if (status.query_start_line && line_numbers)

4261

4105

{

4262

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

4263

if (status.getFileName())

4264

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

4106

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

4107

if (status.file_name)

4108

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

4265

4109

}

4266

4110

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

4267

4111

(void) fflush(file);

4292

4136

if (error)

4293

4137

{

4294

4138

if (sqlstate)

4295

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

4139

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

4296

4140

else

4297

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

4141

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

4298

4142

}

4299

4143

else

4300

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

4144

tee_puts("ERROR: ", file);

4301

4145

}

4302

4146

else

4303

4147

vidattr(A_BOLD);

4336

4180

{

4337

4181

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

4338

4182

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

4339

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

4183

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

4340

4184

end--;

4341

4185

uint32_t pos_to_truncate= (end-start);

4342

4186

if (buffer->length() > pos_to_truncate)

4388

4232

}

4389

4233

4390

4234

#include <sys/times.h>

4235

#ifdef _SC_CLK_TCK // For mit-pthreads

4236

#undef CLOCKS_PER_SEC

4237

#define CLOCKS_PER_SEC (sysconf(_SC_CLK_TCK))

4238

#endif

4391

4239

4392

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

4240

static uint32_t start_timer(void)

4393

4241

{

4394

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

4242

struct tms tms_tmp;

4243

return times(&tms_tmp);

4395

4244

}

4396

4245

4397

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

4246

4247

/**

4248

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

4249

duration of time.

4250

4251

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

4252

4253

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

4398

4254

{

4255

uint32_t tmp;

4399

4256

ostringstream tmp_buff_str;

4400

4257

4401

if (duration.hours() > 0)

4402

{

4403

tmp_buff_str << duration.hours();

4404

if (duration.hours() > 1)

4405

tmp_buff_str << _(" hours ");

4406

else

4407

tmp_buff_str << _(" hour ");

4408

}

4409

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

4410

{

4411

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

4412

}

4413

4414

tmp_buff_str.precision(duration.num_fractional_digits());

4415

4416

double seconds= duration.fractional_seconds();

4417

4418

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

4419

4420

seconds+= duration.seconds();

4421

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

4422

4423

buff.append(tmp_buff_str.str());

4424

}

4425

4426

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

4427

{

4428

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

4429

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

4430

4431

nice_time(duration.length(), buff);

4432

}

4433

4434

4435

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

4436

{

4437

buff.append(" (");

4438

end_timer(start_time,buff);

4439

buff.append(")");

4258

if (sec >= 3600.0*24)

4259

{

4260

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

4261

sec-= 3600.0*24*tmp;

4262

tmp_buff_str << tmp;

4263

4264

if (tmp > 1)

4265

tmp_buff_str << " days ";

4266

else

4267

tmp_buff_str << " day ";

4268

4269

}

4270

if (sec >= 3600.0)

4271

{

4272

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

4273

sec-=3600.0*tmp;

4274

tmp_buff_str << tmp;

4275

4276

if (tmp > 1)

4277

tmp_buff_str << " hours ";

4278

else

4279

tmp_buff_str << " hour ";

4280

}

4281

if (sec >= 60.0)

4282

{

4283

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

4284

sec-=60.0*tmp;

4285

tmp_buff_str << tmp << " min ";

4286

}

4287

if (part_second)

4288

tmp_buff_str.precision(2);

4289

else

4290

tmp_buff_str.precision(0);

4291

tmp_buff_str << sec << " sec";

4292

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

4293

}

4294

4295

4296

static void end_timer(uint32_t start_time,char *buff)

4297

{

4298

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

4299

CLOCKS_PER_SEC,buff,1);

4300

}

4301

4302

4303

static void drizzle_end_timer(uint32_t start_time,char *buff)

4304

{

4305

buff[0]=' ';

4306

buff[1]='(';

4307

end_timer(start_time,buff+2);

4308

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

4440

4309

}

4441

4310

4442

4311

static const char * construct_prompt()

4450

4319

struct tm *t = localtime(&lclock);

4451

4320

4452

4321

/* parse thru the settings for the prompt */

4453

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

4454

while (c != current_prompt.end())

4322

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

4455

4323

{

4456

4324

if (*c != PROMPT_CHAR)

4457

4325

{

4458

processed_prompt->push_back(*c);

4326

processed_prompt->append(c, 1);

4459

4327

}

4460

4328

else

4461

4329

{

4466

4334

switch (*++c) {

4467

4335

case '\0':

4468

4336

// stop it from going beyond if ends with %

4469

--c;

4337

c--;

4470

4338

break;

4471

4339

case 'c':

4472

4340

add_int_to_prompt(++prompt_counter);

4478

4346

processed_prompt->append("not_connected");

4479

4347

break;

4480

4348

case 'd':

4481

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

4349

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

4482

4350

break;

4483

4351

case 'h':

4484

4352

{

4485

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

4353

const char *prompt;

4354

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

4486

4355

if (strstr(prompt, "Localhost"))

4487

4356

processed_prompt->append("localhost");

4488

4357

else

4501

4370

break;

4502

4371

}

4503

4372

4504

if (drizzle_con_uds(&con))

4373

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

4505

4374

{

4506

4375

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

4507

4376

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

4514

4383

if (!full_username)

4515

4384

init_username();

4516

4385

processed_prompt->append(full_username ? full_username :

4517

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

4386

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

4518

4387

break;

4519

4388

case 'u':

4520

4389

if (!full_username)

4521

4390

init_username();

4522

4391

processed_prompt->append(part_username ? part_username :

4523

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

4392

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

4524

4393

break;

4525

4394

case PROMPT_CHAR:

4526

4395

{

4575

4444

add_int_to_prompt(t->tm_sec);

4576

4445

break;

4577

4446

case 'w':

4578

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

4447

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

4579

4448

break;

4580

4449

case 'P':

4581

4450

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

4584

4453

add_int_to_prompt(t->tm_mon+1);

4585

4454

break;

4586

4455

case 'O':

4587

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

4456

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

4588

4457

break;

4589

4458

case '\'':

4590

4459

processed_prompt->append("'");

4602

4471

processed_prompt->append(delimiter_str);

4603

4472

break;

4604

4473

default:

4605

processed_prompt->push_back(*c);

4474

processed_prompt->append(c, 1);

4606

4475

}

4607

4476

}

4608

++c;

4609

4477

}

4610

4478

return processed_prompt->c_str();

4611

4479

}

4640

4508

{

4641

4509

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

4642

4510

if (ptr == NULL)

4643

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

4511

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

4644

4512

default_prompt);

4645

4513

prompt_counter = 0;

4646

4514

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

4647

4515

if (tmpptr == NULL)

4648

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

4516

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

4649

4517

else

4650

4518

{

4651

current_prompt.erase();

4519

free(current_prompt);

4652

4520

current_prompt= tmpptr;

4653

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

4521

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

4654

4522

}

4655

4523

return 0;

4656

4524

}

Older »