~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzle.cc

  • Committer: Lee Bieber
  • Date: 2011-01-10 20:12:43 UTC
  • mfrom: (2069.1.3 build)
  • Revision ID: kalebral@gmail.com-20110110201243-j7xse6v4ptaipc92
Merge Gustaf - Use constrained_check<> classes on kernel sysvars 
Merge Andrew - fix bug 645004: libuuid configure error message needs changing
Merge Stewart - fix bug 698315: innobase tests fail with --repeat=2

Show diffs side-by-side

added added

removed removed

Lines of Context:
34
34
 *
35
35
 **/
36
36
 
37
 
#include <config.h>
 
37
#include "config.h"
38
38
#include <libdrizzle/drizzle_client.h>
39
39
 
40
 
#include "server_detect.h"
41
 
#include "get_password.h"
 
40
#include "client/get_password.h"
42
41
 
43
 
#include <boost/date_time/posix_time/posix_time.hpp>
 
42
#if TIME_WITH_SYS_TIME
 
43
# include <sys/time.h>
 
44
# include <time.h>
 
45
#else
 
46
# if HAVE_SYS_TIME_H
 
47
#  include <sys/time.h>
 
48
# else
 
49
#  include <time.h>
 
50
# endif
 
51
#endif
44
52
 
45
53
#include <cerrno>
46
54
#include <string>
54
62
#include <stdarg.h>
55
63
#include <math.h>
56
64
#include <memory>
57
 
#include <client/linebuffer.h>
 
65
#include "client/linebuffer.h"
58
66
#include <signal.h>
59
67
#include <sys/ioctl.h>
60
68
#include <drizzled/configmake.h>
61
 
#include <drizzled/utf8/utf8.h>
 
69
#include "drizzled/utf8/utf8.h"
62
70
#include <cstdlib>
63
71
 
64
72
#if defined(HAVE_CURSES_H) && defined(HAVE_TERM_H)
152
160
#endif
153
161
#include <boost/program_options.hpp>
154
162
#include <boost/scoped_ptr.hpp>
155
 
#include <drizzled/program_options/config_file.h>
 
163
#include "drizzled/program_options/config_file.h"
156
164
 
157
165
using namespace std;
158
166
namespace po=boost::program_options;
308
316
static uint32_t select_limit;
309
317
static uint32_t max_join_size;
310
318
static uint32_t opt_connect_timeout= 0;
311
 
static ServerDetect::server_type server_type= ServerDetect::SERVER_UNKNOWN_FOUND;
312
319
std::string current_db,
313
320
  delimiter_str,  
314
321
  current_host,
318
325
  current_password,
319
326
  opt_password,
320
327
  opt_protocol;
321
 
 
322
 
static const char* get_day_name(int day_of_week)
323
 
{
324
 
  switch(day_of_week)
325
 
  {
326
 
  case 0:
327
 
    return _("Sun");
328
 
  case 1:
329
 
    return _("Mon");
330
 
  case 2:
331
 
    return _("Tue");
332
 
  case 3:
333
 
    return _("Wed");
334
 
  case 4:
335
 
    return _("Thu");
336
 
  case 5:
337
 
    return _("Fri");
338
 
  case 6:
339
 
    return _("Sat");
340
 
  }
341
 
 
342
 
  return NULL;
343
 
}
344
 
 
345
 
static const char* get_month_name(int month)
346
 
{
347
 
  switch(month)
348
 
  {
349
 
  case 0:
350
 
    return _("Jan");
351
 
  case 1:
352
 
    return _("Feb");
353
 
  case 2:
354
 
    return _("Mar");
355
 
  case 3:
356
 
    return _("Apr");
357
 
  case 4:
358
 
    return _("May");
359
 
  case 5:
360
 
    return _("Jun");
361
 
  case 6:
362
 
    return _("Jul");
363
 
  case 7:
364
 
    return _("Aug");
365
 
  case 8:
366
 
    return _("Sep");
367
 
  case 9:
368
 
    return _("Oct");
369
 
  case 10:
370
 
    return _("Nov");
371
 
  case 11:
372
 
    return _("Dec");
373
 
  }
374
 
 
375
 
  return NULL;
376
 
}
377
 
 
 
328
// TODO: Need to i18n these
 
329
static const char *day_names[]= {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
 
330
static const char *month_names[]= {"Jan","Feb","Mar","Apr","May","Jun","Jul",
 
331
                                  "Aug","Sep","Oct","Nov","Dec"};
378
332
/* @TODO: Remove this */
379
333
#define FN_REFLEN 512
380
334
 
430
384
static void add_int_to_prompt(int toadd);
431
385
static int get_result_width(drizzle_result_st *res);
432
386
static int get_field_disp_length(drizzle_column_st * field);
433
 
static const char * strcont(const char *str, const char *set);
 
387
static const char * strcont(register const char *str, register const char *set);
434
388
 
435
389
/* A class which contains information on the commands this program
436
390
   can understand. */
1167
1121
static void print_tab_data(drizzle_result_st *result);
1168
1122
static void print_table_data_vertically(drizzle_result_st *result);
1169
1123
static void print_warnings(uint32_t error_code);
1170
 
static boost::posix_time::ptime start_timer(void);
1171
 
static void end_timer(boost::posix_time::ptime, string &buff);
1172
 
static void drizzle_end_timer(boost::posix_time::ptime, string &buff);
1173
 
static void nice_time(boost::posix_time::time_duration duration, string &buff);
 
1124
static uint32_t start_timer(void);
 
1125
static void end_timer(uint32_t start_time,char *buff);
 
1126
static void drizzle_end_timer(uint32_t start_time,char *buff);
 
1127
static void nice_time(double sec,char *buff,bool part_second);
1174
1128
extern "C" void drizzle_end(int sig);
1175
1129
extern "C" void handle_sigint(int sig);
1176
1130
#if defined(HAVE_TERMIOS_H) && defined(GWINSZ_IN_SYS_IOCTL)
1326
1280
# if defined(HAVE_LOCALE_H)
1327
1281
  setlocale(LC_ALL, "");
1328
1282
# endif
1329
 
  bindtextdomain("drizzle7", LOCALEDIR);
1330
 
  textdomain("drizzle7");
 
1283
  bindtextdomain("drizzle", LOCALEDIR);
 
1284
  textdomain("drizzle");
1331
1285
#endif
1332
1286
 
1333
 
  po::options_description commandline_options(_("Options used only in command line"));
 
1287
  po::options_description commandline_options(N_("Options used only in command line"));
1334
1288
  commandline_options.add_options()
1335
 
  ("help,?",_("Displays this help and exit."))
1336
 
  ("batch,B",_("Don't use history file. Disable interactive behavior. (Enables --silent)"))
 
1289
  ("help,?",N_("Displays this help and exit."))
 
1290
  ("batch,B",N_("Don't use history file. Disable interactive behavior. (Enables --silent)"))
1337
1291
  ("column-type-info", po::value<bool>(&column_types_flag)->default_value(false)->zero_tokens(),
1338
 
  _("Display column type information."))
 
1292
  N_("Display column type information."))
1339
1293
  ("comments,c", po::value<bool>(&preserve_comments)->default_value(false)->zero_tokens(),
1340
 
  _("Preserve comments. Send comments to the server. The default is --skip-comments (discard comments), enable with --comments"))
 
1294
  N_("Preserve comments. Send comments to the server. The default is --skip-comments (discard comments), enable with --comments"))
1341
1295
  ("vertical,E", po::value<bool>(&vertical)->default_value(false)->zero_tokens(),
1342
 
  _("Print the output of a query (rows) vertically."))
 
1296
  N_("Print the output of a query (rows) vertically."))
1343
1297
  ("force,f", po::value<bool>(&ignore_errors)->default_value(false)->zero_tokens(),
1344
 
  _("Continue even if we get an sql error."))
 
1298
  N_("Continue even if we get an sql error."))
1345
1299
  ("named-commands,G", po::value<bool>(&named_cmds)->default_value(false)->zero_tokens(),
1346
 
  _("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."))
 
1300
  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."))
1347
1301
  ("no-beep,b", po::value<bool>(&opt_nobeep)->default_value(false)->zero_tokens(),
1348
 
  _("Turn off beep on error."))
1349
 
  ("disable-line-numbers", _("Do not write line numbers for errors."))
1350
 
  ("disable-column-names", _("Do not write column names in results."))
 
1302
  N_("Turn off beep on error."))
 
1303
  ("disable-line-numbers", N_("Do not write line numbers for errors."))
 
1304
  ("disable-column-names", N_("Do not write column names in results."))
1351
1305
  ("skip-column-names,N", 
1352
 
  _("Don't write column names in results. WARNING: -N is deprecated, use long version of this options instead."))
 
1306
  N_("Don't write column names in results. WARNING: -N is deprecated, use long version of this options instead."))
1353
1307
  ("set-variable,O", po::value<string>(),
1354
 
  _("Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value."))
 
1308
  N_("Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value."))
1355
1309
  ("table,t", po::value<bool>(&output_tables)->default_value(false)->zero_tokens(),
1356
 
  _("Output in table format.")) 
 
1310
  N_("Output in table format.")) 
1357
1311
  ("safe-updates,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),
1358
 
  _("Only allow UPDATE and DELETE that uses keys."))
 
1312
  N_("Only allow UPDATE and DELETE that uses keys."))
1359
1313
  ("i-am-a-dummy,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),
1360
 
  _("Synonym for option --safe-updates, -U."))
 
1314
  N_("Synonym for option --safe-updates, -U."))
1361
1315
  ("verbose,v", po::value<string>(&opt_verbose)->default_value(""),
1362
 
  _("-v vvv implies that verbose= 3, Used to specify verbose"))
1363
 
  ("version,V", _("Output version information and exit."))
 
1316
  N_("-v vvv implies that verbose= 3, Used to specify verbose"))
 
1317
  ("version,V", N_("Output version information and exit."))
1364
1318
  ("secure-auth", po::value<bool>(&opt_secure_auth)->default_value(false)->zero_tokens(),
1365
 
  _("Refuse client connecting to server if it uses old (pre-4.1.1) protocol"))
 
1319
  N_("Refuse client connecting to server if it uses old (pre-4.1.1) protocol"))
1366
1320
  ("show-warnings", po::value<bool>(&show_warnings)->default_value(false)->zero_tokens(),
1367
 
  _("Show warnings after every statement."))
 
1321
  N_("Show warnings after every statement."))
1368
1322
  ("show-progress-size", po::value<uint32_t>(&show_progress_size)->default_value(0),
1369
 
  _("Number of lines before each import progress report."))
 
1323
  N_("Number of lines before each import progress report."))
1370
1324
  ("ping", po::value<bool>(&opt_ping)->default_value(false)->zero_tokens(),
1371
 
  _("Ping the server to check if it's alive."))
 
1325
  N_("Ping the server to check if it's alive."))
1372
1326
  ("no-defaults", po::value<bool>()->default_value(false)->zero_tokens(),
1373
 
  _("Configuration file defaults are not used if no-defaults is set"))
 
1327
  N_("Configuration file defaults are not used if no-defaults is set"))
1374
1328
  ;
1375
1329
 
1376
 
  po::options_description drizzle_options(_("Options specific to the drizzle client"));
 
1330
  po::options_description drizzle_options(N_("Options specific to the drizzle client"));
1377
1331
  drizzle_options.add_options()
1378
1332
  ("disable-auto-rehash,A",
1379
 
  _("Disable automatic rehashing. One doesn't need to use 'rehash' to get table and field completion, but startup and reconnecting may take a longer time."))
 
1333
  N_("Disable automatic rehashing. One doesn't need to use 'rehash' to get table and field completion, but startup and reconnecting may take a longer time."))
1380
1334
  ("auto-vertical-output", po::value<bool>(&auto_vertical_output)->default_value(false)->zero_tokens(),
1381
 
  _("Automatically switch to vertical output mode if the result is wider than the terminal width."))
 
1335
  N_("Automatically switch to vertical output mode if the result is wider than the terminal width."))
1382
1336
  ("database,D", po::value<string>(&current_db)->default_value(""),
1383
 
  _("Database to use."))
 
1337
  N_("Database to use."))
1384
1338
  ("default-character-set",po::value<string>(),
1385
 
  _("(not used)"))
 
1339
  N_("(not used)"))
1386
1340
  ("delimiter", po::value<string>(&delimiter_str)->default_value(";"),
1387
 
  _("Delimiter to be used."))
 
1341
  N_("Delimiter to be used."))
1388
1342
  ("execute,e", po::value<string>(),
1389
 
  _("Execute command and quit. (Disables --force and history file)"))
 
1343
  N_("Execute command and quit. (Disables --force and history file)"))
1390
1344
  ("local-infile", po::value<bool>(&opt_local_infile)->default_value(false)->zero_tokens(),
1391
 
  _("Enable LOAD DATA LOCAL INFILE."))
 
1345
  N_("Enable LOAD DATA LOCAL INFILE."))
1392
1346
  ("unbuffered,n", po::value<bool>(&unbuffered)->default_value(false)->zero_tokens(),
1393
 
  _("Flush buffer after each query."))
 
1347
  N_("Flush buffer after each query."))
1394
1348
  ("sigint-ignore", po::value<bool>(&opt_sigint_ignore)->default_value(false)->zero_tokens(),
1395
 
  _("Ignore SIGINT (CTRL-C)"))
 
1349
  N_("Ignore SIGINT (CTRL-C)"))
1396
1350
  ("one-database,o", po::value<bool>(&one_database)->default_value(false)->zero_tokens(),
1397
 
  _("Only update the default database. This is useful for skipping updates to other database in the update log."))
 
1351
  N_("Only update the default database. This is useful for skipping updates to other database in the update log."))
1398
1352
  ("pager", po::value<string>(),
1399
 
  _("Pager to use to display results. If you don't supply an option the default pager is taken from your ENV variable PAGER. Valid pagers are less, more, cat [> filename], etc. See interactive help (\\h) also. This option does not work in batch mode. Disable with --disable-pager. This option is disabled by default."))
 
1353
  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."))
1400
1354
  ("disable-pager", po::value<bool>(&opt_nopager)->default_value(false)->zero_tokens(),
1401
 
  _("Disable pager and print to stdout. See interactive help (\\h) also."))
 
1355
  N_("Disable pager and print to stdout. See interactive help (\\h) also."))
1402
1356
  ("prompt", po::value<string>(&current_prompt)->default_value(""),  
1403
 
  _("Set the drizzle prompt to this value."))
 
1357
  N_("Set the drizzle prompt to this value."))
1404
1358
  ("quick,q", po::value<bool>(&quick)->default_value(false)->zero_tokens(),
1405
 
  _("Don't cache result, print it row by row. This may slow down the server if the output is suspended. Doesn't use history file."))
 
1359
  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."))
1406
1360
  ("raw,r", po::value<bool>(&opt_raw_data)->default_value(false)->zero_tokens(),
1407
 
  _("Write fields without conversion. Used with --batch.")) 
1408
 
  ("disable-reconnect", _("Do not reconnect if the connection is lost."))
 
1361
  N_("Write fields without conversion. Used with --batch.")) 
 
1362
  ("disable-reconnect", N_("Do not reconnect if the connection is lost."))
1409
1363
  ("shutdown", po::value<bool>()->zero_tokens(),
1410
 
  _("Shutdown the server"))
1411
 
  ("silent,s", _("Be more silent. Print results with a tab as separator, each row on new line."))
 
1364
  N_("Shutdown the server"))
 
1365
  ("silent,s", N_("Be more silent. Print results with a tab as separator, each row on new line."))
1412
1366
  ("tee", po::value<string>(),
1413
 
  _("Append everything into outfile. See interactive help (\\h) also. Does not work in batch mode. Disable with --disable-tee. This option is disabled by default."))
 
1367
  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."))
1414
1368
  ("disable-tee", po::value<bool>()->default_value(false)->zero_tokens(), 
1415
 
  _("Disable outfile. See interactive help (\\h) also."))
 
1369
  N_("Disable outfile. See interactive help (\\h) also."))
1416
1370
  ("connect-timeout", po::value<uint32_t>(&opt_connect_timeout)->default_value(0)->notifier(&check_timeout_value),
1417
 
  _("Number of seconds before connection timeout."))
 
1371
  N_("Number of seconds before connection timeout."))
1418
1372
  ("max-input-line", po::value<uint32_t>(&opt_max_input_line)->default_value(16*1024L*1024L)->notifier(&check_max_input_line),
1419
 
  _("Max length of input line"))
 
1373
  N_("Max length of input line"))
1420
1374
  ("select-limit", po::value<uint32_t>(&select_limit)->default_value(1000L),
1421
 
  _("Automatic limit for SELECT when using --safe-updates"))
 
1375
  N_("Automatic limit for SELECT when using --safe-updates"))
1422
1376
  ("max-join-size", po::value<uint32_t>(&max_join_size)->default_value(1000000L),
1423
 
  _("Automatic limit for rows in a join when using --safe-updates"))
 
1377
  N_("Automatic limit for rows in a join when using --safe-updates"))
1424
1378
  ;
1425
1379
 
1426
 
  po::options_description client_options(_("Options specific to the client"));
 
1380
  po::options_description client_options(N_("Options specific to the client"));
1427
1381
  client_options.add_options()
1428
1382
  ("host,h", po::value<string>(&current_host)->default_value("localhost"),
1429
 
  _("Connect to host"))
 
1383
  N_("Connect to host"))
1430
1384
  ("password,P", po::value<string>(&current_password)->default_value(PASSWORD_SENTINEL),
1431
 
  _("Password to use when connecting to server. If password is not given it's asked from the tty."))
 
1385
  N_("Password to use when connecting to server. If password is not given it's asked from the tty."))
1432
1386
  ("port,p", po::value<uint32_t>()->default_value(0),
1433
 
  _("Port number to use for connection or 0 for default to, in order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, built-in default"))
 
1387
  N_("Port number to use for connection or 0 for default to, in order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, built-in default"))
1434
1388
#ifdef DRIZZLE_ADMIN_TOOL
1435
1389
  ("user,u", po::value<string>(&current_user)->default_value("root"),
1436
1390
#else
1437
1391
  ("user,u", po::value<string>(&current_user)->default_value(""),
1438
1392
#endif
1439
 
  _("User for login if not current user."))
 
1393
  N_("User for login if not current user."))
1440
1394
  ("protocol",po::value<string>(&opt_protocol)->default_value("mysql"),
1441
 
  _("The protocol of connection (mysql or drizzle)."))
 
1395
  N_("The protocol of connection (mysql or drizzle)."))
1442
1396
  ;
1443
1397
 
1444
 
  po::options_description long_options(_("Allowed Options"));
 
1398
  po::options_description long_options(N_("Allowed Options"));
1445
1399
  long_options.add(commandline_options).add(drizzle_options).add(client_options);
1446
1400
 
1447
1401
  std::string system_config_dir_drizzle(SYSCONFDIR); 
1510
1464
                      "prompt. Aborting.\n"));
1511
1465
    exit(ENOMEM);
1512
1466
  }
1513
 
 
1514
 
  if (current_prompt.empty())
1515
 
    current_prompt= strdup(default_prompt);
1516
 
 
 
1467
  current_prompt= strdup(default_prompt);
1517
1468
  if (current_prompt.empty())
1518
1469
  {
1519
1470
    fprintf(stderr, _("Memory allocation error while constructing initial "
2762
2713
static int
2763
2714
com_help(string *buffer, const char *)
2764
2715
{
2765
 
  int i, j;
 
2716
  register int i, j;
2766
2717
  char buff[32], *end;
2767
2718
  std::vector<char> output_buff;
2768
2719
  output_buff.resize(512);
2811
2762
com_go(string *buffer, const char *)
2812
2763
{
2813
2764
  char          buff[200]; /* about 110 chars used so far */
 
2765
  char          time_buff[52+3+1]; /* time max + space&parens + NUL */
2814
2766
  drizzle_result_st result;
2815
2767
  drizzle_return_t ret;
2816
 
  uint32_t      warnings= 0;
2817
 
  boost::posix_time::ptime timer;
 
2768
  uint32_t      timer, warnings= 0;
2818
2769
  uint32_t      error= 0;
2819
2770
  uint32_t      error_code= 0;
2820
2771
  int           err= 0;
2883
2834
        goto end;
2884
2835
    }
2885
2836
 
2886
 
    string time_buff("");
2887
2837
    if (verbose >= 3 || !opt_silent)
2888
2838
      drizzle_end_timer(timer,time_buff);
 
2839
    else
 
2840
      time_buff[0]= '\0';
2889
2841
 
2890
2842
    /* Every branch must truncate  buff . */
2891
2843
    if (drizzle_result_column_count(&result) > 0)
2936
2888
      if (warnings != 1)
2937
2889
        *pos++= 's';
2938
2890
    }
2939
 
    strcpy(pos, time_buff.c_str());
 
2891
    strcpy(pos, time_buff);
2940
2892
    put_info(buff,INFO_RESULT,0,0);
2941
2893
    if (strcmp(drizzle_result_info(&result), ""))
2942
2894
      put_info(drizzle_result_info(&result),INFO_RESULT,0,0);
3130
3082
  drizzle_return_t ret;
3131
3083
  drizzle_column_st *field;
3132
3084
  std::vector<bool> num_flag;
3133
 
  std::vector<bool> boolean_flag;
3134
 
  std::vector<bool> ansi_boolean_flag;
3135
3085
  string separator;
3136
3086
 
3137
3087
  separator.reserve(256);
3138
3088
 
3139
3089
  num_flag.resize(drizzle_result_column_count(result));
3140
 
  boolean_flag.resize(drizzle_result_column_count(result));
3141
 
  ansi_boolean_flag.resize(drizzle_result_column_count(result));
3142
3090
  if (column_types_flag)
3143
3091
  {
3144
3092
    print_field_types(result);
3181
3129
      // Room for "NULL"
3182
3130
      length=4;
3183
3131
    }
3184
 
    if ((length < 5) and 
3185
 
      (server_type == ServerDetect::SERVER_DRIZZLE_FOUND) and
3186
 
      (drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_TINY) and
3187
 
      (drizzle_column_type(field) & DRIZZLE_COLUMN_FLAGS_UNSIGNED))
3188
 
    {
3189
 
      // Room for "FALSE"
3190
 
      length= 5;
3191
 
    }
3192
3132
    drizzle_column_set_max_size(field, length);
3193
3133
 
3194
3134
    for (x=0; x< (length+2); x++)
3212
3152
                  drizzle_column_name(field));
3213
3153
      num_flag[off]= ((drizzle_column_type(field) <= DRIZZLE_COLUMN_TYPE_LONGLONG) ||
3214
3154
                      (drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_NEWDECIMAL));
3215
 
      if ((server_type == ServerDetect::SERVER_DRIZZLE_FOUND) and
3216
 
        (drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_TINY))
3217
 
      {
3218
 
        if ((drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_UNSIGNED))
3219
 
        {
3220
 
          ansi_boolean_flag[off]= true;
3221
 
        }
3222
 
        else
3223
 
        {
3224
 
          ansi_boolean_flag[off]= false;
3225
 
        }
3226
 
        boolean_flag[off]= true;
3227
 
        num_flag[off]= false;
3228
 
      }
3229
 
      else
3230
 
      {
3231
 
        boolean_flag[off]= false;
3232
 
      }
3233
3155
    }
3234
3156
    (void) tee_fputs("\n", PAGER);
3235
3157
    tee_puts((char*) separator.c_str(), PAGER);
3268
3190
        buffer= "NULL";
3269
3191
        data_length= 4;
3270
3192
      }
3271
 
      else if (boolean_flag[off])
3272
 
      {
3273
 
        if (strncmp(cur[off],"1", 1) == 0)
3274
 
        {
3275
 
          if (ansi_boolean_flag[off])
3276
 
          {
3277
 
            buffer= "YES";
3278
 
            data_length= 3;
3279
 
          }
3280
 
          else
3281
 
          {
3282
 
            buffer= "TRUE";
3283
 
            data_length= 4;
3284
 
          }
3285
 
        }
3286
 
        else
3287
 
        {
3288
 
          if (ansi_boolean_flag[off])
3289
 
          {
3290
 
            buffer= "NO";
3291
 
            data_length= 2;
3292
 
          }
3293
 
          else
3294
 
          {
3295
 
            buffer= "FALSE";
3296
 
            data_length= 5;
3297
 
          }
3298
 
        }
3299
 
      }
3300
3193
      else
3301
3194
      {
3302
3195
        buffer= cur[off];
3570
3463
  drizzle_return_t ret;
3571
3464
  drizzle_column_st *field;
3572
3465
  size_t *lengths;
3573
 
  std::vector<bool> boolean_flag;
3574
 
  std::vector<bool> ansi_boolean_flag;
3575
 
 
3576
 
  boolean_flag.resize(drizzle_result_column_count(result));
3577
 
  ansi_boolean_flag.resize(drizzle_result_column_count(result));
3578
 
 
3579
 
  int first=0;
3580
 
  for (uint32_t off= 0; (field = drizzle_column_next(result)); off++)
 
3466
 
 
3467
  if (opt_silent < 2 && column_names)
3581
3468
  {
3582
 
    if (opt_silent < 2 && column_names)
 
3469
    int first=0;
 
3470
    while ((field = drizzle_column_next(result)))
3583
3471
    {
3584
3472
      if (first++)
3585
3473
        (void) tee_fputs("\t", PAGER);
3586
3474
      (void) tee_fputs(drizzle_column_name(field), PAGER);
3587
3475
    }
3588
 
    if ((server_type == ServerDetect::SERVER_DRIZZLE_FOUND) and
3589
 
      (drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_TINY))
3590
 
    {
3591
 
      if ((drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_UNSIGNED))
3592
 
      {
3593
 
        ansi_boolean_flag[off]= true;
3594
 
      }
3595
 
      else
3596
 
      {
3597
 
        ansi_boolean_flag[off]= false;
3598
 
      }
3599
 
      boolean_flag[off]= true;
3600
 
    }
3601
 
    else
3602
 
    {
3603
 
      boolean_flag[off]= false;
3604
 
    }
3605
 
  }
3606
 
  if (opt_silent < 2 && column_names)
3607
 
  {
3608
3476
    (void) tee_fputs("\n", PAGER);
3609
3477
  }
3610
3478
  while (1)
3625
3493
      break;
3626
3494
 
3627
3495
    lengths= drizzle_row_field_sizes(result);
3628
 
    drizzle_column_seek(result, 0);
3629
 
    for (uint32_t off=0 ; off < drizzle_result_column_count(result); off++)
 
3496
    safe_put_field(cur[0],lengths[0]);
 
3497
    for (uint32_t off=1 ; off < drizzle_result_column_count(result); off++)
3630
3498
    {
3631
 
      if (off != 0)
3632
 
        (void) tee_fputs("\t", PAGER);
3633
 
      if (boolean_flag[off])
3634
 
      {
3635
 
        if (strncmp(cur[off],"1", 1) == 0)
3636
 
        {
3637
 
          if (ansi_boolean_flag[off])
3638
 
          {
3639
 
            safe_put_field("YES", 3);
3640
 
          }
3641
 
          else
3642
 
          {
3643
 
            safe_put_field("TRUE", 4);
3644
 
          }
3645
 
        }
3646
 
        else
3647
 
        {
3648
 
          if (ansi_boolean_flag[off])
3649
 
          {
3650
 
            safe_put_field("NO", 2);
3651
 
          }
3652
 
          else
3653
 
          {
3654
 
            safe_put_field("FALSE", 5);
3655
 
          }
3656
 
        }
3657
 
      }
3658
 
      else
3659
 
      {
3660
 
        safe_put_field(cur[off], lengths[off]);
3661
 
      }
 
3499
      (void) tee_fputs("\t", PAGER);
 
3500
      safe_put_field(cur[off], lengths[off]);
3662
3501
    }
3663
3502
    (void) tee_fputs("\n", PAGER);
3664
3503
    if (quick)
4223
4062
  }
4224
4063
  connected=1;
4225
4064
 
4226
 
  ServerDetect server_detect(&con);
4227
 
  server_type= server_detect.getServerType();
4228
 
 
4229
4065
  build_completion_hash(opt_rehash, 1);
4230
4066
  return 0;
4231
4067
}
4506
4342
}
4507
4343
 
4508
4344
#include <sys/times.h>
 
4345
#ifdef _SC_CLK_TCK        // For mit-pthreads
 
4346
#undef CLOCKS_PER_SEC
 
4347
#define CLOCKS_PER_SEC (sysconf(_SC_CLK_TCK))
 
4348
#endif
4509
4349
 
4510
 
static boost::posix_time::ptime start_timer(void)
 
4350
static uint32_t start_timer(void)
4511
4351
{
4512
 
  return boost::posix_time::microsec_clock::universal_time();
 
4352
  struct tms tms_tmp;
 
4353
  return times(&tms_tmp);
4513
4354
}
4514
4355
 
4515
 
static void nice_time(boost::posix_time::time_duration duration, string &buff)
 
4356
 
 
4357
/**
 
4358
   Write as many as 52+1 bytes to buff, in the form of a legible
 
4359
   duration of time.
 
4360
 
 
4361
   len("4294967296 days, 23 hours, 59 minutes, 60.00 seconds")  ->  52
 
4362
*/
 
4363
static void nice_time(double sec,char *buff,bool part_second)
4516
4364
{
 
4365
  uint32_t tmp;
4517
4366
  ostringstream tmp_buff_str;
4518
4367
 
4519
 
  if (duration.hours() > 0)
4520
 
  {
4521
 
    tmp_buff_str << duration.hours();
4522
 
    if (duration.hours() > 1)
 
4368
  if (sec >= 3600.0*24)
 
4369
  {
 
4370
    tmp=(uint32_t) floor(sec/(3600.0*24));
 
4371
    sec-= 3600.0*24*tmp;
 
4372
    tmp_buff_str << tmp;
 
4373
 
 
4374
    if (tmp > 1)
 
4375
      tmp_buff_str << " days ";
 
4376
    else
 
4377
      tmp_buff_str << " day ";
 
4378
 
 
4379
  }
 
4380
  if (sec >= 3600.0)
 
4381
  {
 
4382
    tmp=(uint32_t) floor(sec/3600.0);
 
4383
    sec-=3600.0*tmp;
 
4384
    tmp_buff_str << tmp;
 
4385
 
 
4386
    if (tmp > 1)
4523
4387
      tmp_buff_str << _(" hours ");
4524
4388
    else
4525
4389
      tmp_buff_str << _(" hour ");
4526
4390
  }
4527
 
  if (duration.hours() > 0 || duration.minutes() > 0)
 
4391
  if (sec >= 60.0)
4528
4392
  {
4529
 
    tmp_buff_str << duration.minutes() << _(" min ");
 
4393
    tmp=(uint32_t) floor(sec/60.0);
 
4394
    sec-=60.0*tmp;
 
4395
    tmp_buff_str << tmp << _(" min ");
4530
4396
  }
4531
 
 
4532
 
  tmp_buff_str.precision(duration.num_fractional_digits());
4533
 
 
4534
 
  double seconds= duration.fractional_seconds();
4535
 
 
4536
 
  seconds/= pow(10.0,duration.num_fractional_digits());
4537
 
 
4538
 
  seconds+= duration.seconds();
4539
 
  tmp_buff_str << seconds << _(" sec");
4540
 
 
4541
 
  buff.append(tmp_buff_str.str());
4542
 
}
4543
 
 
4544
 
static void end_timer(boost::posix_time::ptime start_time, string &buff)
4545
 
{
4546
 
  boost::posix_time::ptime end_time= start_timer();
4547
 
  boost::posix_time::time_period duration(start_time, end_time);
4548
 
 
4549
 
  nice_time(duration.length(), buff);
4550
 
}
4551
 
 
4552
 
 
4553
 
static void drizzle_end_timer(boost::posix_time::ptime start_time, string &buff)
4554
 
{
4555
 
  buff.append(" (");
4556
 
  end_timer(start_time,buff);
4557
 
  buff.append(")");
 
4397
  if (part_second)
 
4398
    tmp_buff_str.precision(2);
 
4399
  else
 
4400
    tmp_buff_str.precision(0);
 
4401
  tmp_buff_str << sec << _(" sec");
 
4402
  strcpy(buff, tmp_buff_str.str().c_str());
 
4403
}
 
4404
 
 
4405
 
 
4406
static void end_timer(uint32_t start_time,char *buff)
 
4407
{
 
4408
  nice_time((double) (start_timer() - start_time) /
 
4409
            CLOCKS_PER_SEC,buff,1);
 
4410
}
 
4411
 
 
4412
 
 
4413
static void drizzle_end_timer(uint32_t start_time,char *buff)
 
4414
{
 
4415
  buff[0]=' ';
 
4416
  buff[1]='(';
 
4417
  end_timer(start_time,buff+2);
 
4418
  strcpy(strchr(buff, '\0'),")");
4558
4419
}
4559
4420
 
4560
4421
static const char * construct_prompt()
4693
4554
        add_int_to_prompt(t->tm_sec);
4694
4555
        break;
4695
4556
      case 'w':
4696
 
        processed_prompt->append(get_day_name(t->tm_wday));
 
4557
        processed_prompt->append(day_names[t->tm_wday]);
4697
4558
        break;
4698
4559
      case 'P':
4699
4560
        processed_prompt->append(t->tm_hour < 12 ? "am" : "pm");
4702
4563
        add_int_to_prompt(t->tm_mon+1);
4703
4564
        break;
4704
4565
      case 'O':
4705
 
        processed_prompt->append(get_month_name(t->tm_mon));
 
4566
        processed_prompt->append(month_names[t->tm_mon]);
4706
4567
        break;
4707
4568
      case '\'':
4708
4569
        processed_prompt->append("'");
4779
4640
    if there isn't anything found.
4780
4641
*/
4781
4642
 
4782
 
static const char * strcont(const char *str, const char *set)
 
4643
static const char * strcont(register const char *str, register const char *set)
4783
4644
{
4784
 
  const char * start = (const char *) set;
 
4645
  register const char * start = (const char *) set;
4785
4646
 
4786
4647
  while (*str)
4787
4648
  {