mysqltest.c 219 KB
Newer Older
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1
/* Copyright (C) 2000 MySQL AB
2

3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
5
   the Free Software Foundation; version 2 of the License.
6

7 8 9 10
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
11

12 13 14 15
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

16 17
/*
  mysqltest
18

19
  Tool used for executing a .test file
20

21 22
  See the "MySQL Test framework manual" for more information
  http://dev.mysql.com/doc/mysqltest/en/index.html
23

24 25
  Please keep the test framework tools identical in all versions!

26 27 28 29 30
  Written by:
  Sasha Pachev <sasha@mysql.com>
  Matt Wagner  <matt@mysql.com>
  Monty
  Jani
31
  Holyfoot
32
*/
33

34
#define MTEST_VERSION "3.2"
35

36
#include <my_global.h>
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
37
#include <mysql_embed.h>
38 39 40 41
#include <my_sys.h>
#include <m_string.h>
#include <mysql.h>
#include <mysql_version.h>
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
42
#include <mysqld_error.h>
43
#include <errmsg.h>
44 45
#include <m_ctype.h>
#include <my_dir.h>
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
46
#include <hash.h>
47
#include <my_getopt.h>
48
#include <stdarg.h>
49
#include <violite.h>
50
#include "my_regex.h" /* Our own version of regex */
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
51
#ifdef HAVE_SYS_WAIT_H
52
#include <sys/wait.h>
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
53
#endif
54

msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
55
#ifndef WEXITSTATUS
kent@mysql.com's avatar
kent@mysql.com committed
56 57 58 59 60
# ifdef __WIN__
#  define WEXITSTATUS(stat_val) (stat_val)
# else
#  define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
# endif
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
61
#endif
62

63 64 65 66 67
/* Use cygwin for --exec and --system before 5.0 */
#if MYSQL_VERSION_ID < 50000
#define USE_CYGWIN
#endif

68 69 70 71 72 73 74 75 76 77 78 79 80 81
#define MAX_VAR_NAME_LENGTH    256
#define MAX_COLUMNS            256
#define MAX_EMBEDDED_SERVER_ARGS 64
#define MAX_DELIMITER_LENGTH 16

/* Flags controlling send and reap */
#define QUERY_SEND_FLAG  1
#define QUERY_REAP_FLAG  2

enum {
  OPT_SKIP_SAFEMALLOC=256, OPT_SSL_SSL, OPT_SSL_KEY, OPT_SSL_CERT,
  OPT_SSL_CA, OPT_SSL_CAPATH, OPT_SSL_CIPHER, OPT_PS_PROTOCOL,
  OPT_SP_PROTOCOL, OPT_CURSOR_PROTOCOL, OPT_VIEW_PROTOCOL,
  OPT_SSL_VERIFY_SERVER_CERT, OPT_MAX_CONNECT_RETRIES,
82
  OPT_MARK_PROGRESS, OPT_CHARSETS_DIR, OPT_LOG_DIR, OPT_TAIL_LINES
83
};
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
84

85
static int record= 0, opt_sleep= -1;
86 87
static char *opt_db= 0, *opt_pass= 0;
const char *opt_user= 0, *opt_host= 0, *unix_sock= 0, *opt_basedir= "./";
88
const char *opt_logdir= "";
89
const char *opt_include= 0, *opt_charsets_dir;
90
static int opt_port= 0;
91 92 93 94 95 96 97 98 99
static int opt_max_connect_retries;
static my_bool opt_compress= 0, silent= 0, verbose= 0;
static my_bool tty_password= 0;
static my_bool opt_mark_progress= 0;
static my_bool ps_protocol= 0, ps_protocol_enabled= 0;
static my_bool sp_protocol= 0, sp_protocol_enabled= 0;
static my_bool view_protocol= 0, view_protocol_enabled= 0;
static my_bool cursor_protocol= 0, cursor_protocol_enabled= 0;
static my_bool parsing_disabled= 0;
100 101
static my_bool display_result_vertically= FALSE,
  display_metadata= FALSE, display_result_sorted= FALSE;
102
static my_bool disable_query_log= 0, disable_result_log= 0;
103
static my_bool disable_warnings= 0;
104 105
static my_bool disable_info= 1;
static my_bool abort_on_error= 1;
106
static my_bool server_initialized= 0;
107
static my_bool is_windows= 0;
108 109 110
static char **default_argv;
static const char *load_default_groups[]= { "mysqltest", "client", 0 };
static char line_buffer[MAX_DELIMITER_LENGTH], *line_buffer_pos= line_buffer;
111

112
static uint start_lineno= 0; /* Start line of current command */
113

114 115 116
/* Number of lines of the result to include in failure report */
static uint opt_tail_lines= 0;

117 118 119 120 121 122 123 124 125 126
static char delimiter[MAX_DELIMITER_LENGTH]= ";";
static uint delimiter_length= 1;

static char TMPDIR[FN_REFLEN];

/* Block stack */
enum block_cmd {
  cmd_none,
  cmd_if,
  cmd_while
127 128
};

129
struct st_block
130
{
131 132 133 134
  int             line; /* Start line of block */
  my_bool         ok;   /* Should block be executed */
  enum block_cmd  cmd;  /* Command owning the block */
};
135

136 137
static struct st_block block_stack[32];
static struct st_block *cur_block, *block_stack_end;
138

139 140
/* Open file stack */
struct st_test_file
141 142 143
{
  FILE* file;
  const char *file_name;
144 145
  uint lineno; /* Current line in file */
};
146

147 148 149
static struct st_test_file file_stack[16];
static struct st_test_file* cur_file;
static struct st_test_file* file_stack_end;
150

151

kent@mysql.com's avatar
kent@mysql.com committed
152
static CHARSET_INFO *charset_info= &my_charset_latin1; /* Default charset */
153

154 155 156 157 158 159 160
static const char *embedded_server_groups[]=
{
  "server",
  "embedded",
  "mysqltest_SERVER",
  NullS
};
161

162 163
static int embedded_server_arg_count=0;
static char *embedded_server_args[MAX_EMBEDDED_SERVER_ARGS];
164

165 166 167 168
/*
  Timer related variables
  See the timer_output() definition for details
*/
kent@mysql.com's avatar
kent@mysql.com committed
169 170 171 172 173
static char *timer_file = NULL;
static ulonglong timer_start;
static void timer_output(void);
static ulonglong timer_now(void);

174
static ulonglong progress_start= 0;
175

176 177 178 179 180 181 182 183
/* Precompiled re's */
static my_regex_t ps_re;     /* the query can be run using PS protocol */
static my_regex_t sp_re;     /* the query can be run as a SP */
static my_regex_t view_re;   /* the query can be run as a view*/

static void init_re(void);
static int match_re(my_regex_t *, char *);
static void free_re(void);
184

185 186
DYNAMIC_ARRAY q_lines;

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
187 188
#include "sslopt-vars.h"

189
struct
190 191
{
  int read_lines,current_line;
192
} parser;
193

194 195 196 197 198
struct
{
  char file[FN_REFLEN];
  ulong pos;
} master_pos;
199

200
/* if set, all results are concated and compared against this file */
201
const char *result_file_name= 0;
202

203
typedef struct st_var
204
{
205
  char *name;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
206
  int name_len;
207
  char *str_val;
208 209 210 211
  int str_val_len;
  int int_val;
  int alloced_len;
  int int_dirty; /* do not update string if int is updated until first read */
212
  int alloced;
213
  char *env_s;
214 215 216
} VAR;

/*Perl/shell-like variable registers */
217
VAR var_reg[10];
218

219
HASH var_hash;
220

221 222 223 224 225 226 227
struct st_connection
{
  MYSQL mysql;
  /* Used when creating views and sp, to avoid implicit commit */
  MYSQL* util_mysql;
  char *name;
  MYSQL_STMT* stmt;
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
228

229
#ifdef EMBEDDED_LIBRARY
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
230 231 232 233 234
  const char *cur_query;
  int cur_query_len;
  pthread_mutex_t mutex;
  pthread_cond_t cond;
  int query_done;
235
#endif /*EMBEDDED_LIBRARY*/
236 237
};
struct st_connection connections[128];
238
struct st_connection* cur_con= NULL, *next_con, *connections_end;
239

240 241 242 243 244
/*
  List of commands in mysqltest
  Must match the "command_names" array
  Add new commands before Q_UNKNOWN!
*/
245
enum enum_commands {
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
  Q_CONNECTION=1,     Q_QUERY,
  Q_CONNECT,	    Q_SLEEP, Q_REAL_SLEEP,
  Q_INC,		    Q_DEC,
  Q_SOURCE,	    Q_DISCONNECT,
  Q_LET,		    Q_ECHO,
  Q_WHILE,	    Q_END_BLOCK,
  Q_SYSTEM,	    Q_RESULT,
  Q_REQUIRE,	    Q_SAVE_MASTER_POS,
  Q_SYNC_WITH_MASTER,
  Q_SYNC_SLAVE_WITH_MASTER,
  Q_ERROR,
  Q_SEND,		    Q_REAP,
  Q_DIRTY_CLOSE,	    Q_REPLACE, Q_REPLACE_COLUMN,
  Q_PING,		    Q_EVAL,
  Q_RPL_PROBE,	    Q_ENABLE_RPL_PARSE,
  Q_DISABLE_RPL_PARSE, Q_EVAL_RESULT,
  Q_ENABLE_QUERY_LOG, Q_DISABLE_QUERY_LOG,
  Q_ENABLE_RESULT_LOG, Q_DISABLE_RESULT_LOG,
  Q_WAIT_FOR_SLAVE_TO_STOP,
  Q_ENABLE_WARNINGS, Q_DISABLE_WARNINGS,
  Q_ENABLE_INFO, Q_DISABLE_INFO,
  Q_ENABLE_METADATA, Q_DISABLE_METADATA,
  Q_EXEC, Q_DELIMITER,
  Q_DISABLE_ABORT_ON_ERROR, Q_ENABLE_ABORT_ON_ERROR,
  Q_DISPLAY_VERTICAL_RESULTS, Q_DISPLAY_HORIZONTAL_RESULTS,
271
  Q_QUERY_VERTICAL, Q_QUERY_HORIZONTAL, Q_SORTED_RESULT,
272 273 274 275 276 277
  Q_START_TIMER, Q_END_TIMER,
  Q_CHARACTER_SET, Q_DISABLE_PS_PROTOCOL, Q_ENABLE_PS_PROTOCOL,
  Q_DISABLE_RECONNECT, Q_ENABLE_RECONNECT,
  Q_IF,
  Q_DISABLE_PARSING, Q_ENABLE_PARSING,
  Q_REPLACE_REGEX, Q_REMOVE_FILE, Q_FILE_EXIST,
278
  Q_WRITE_FILE, Q_COPY_FILE, Q_PERL, Q_DIE, Q_EXIT, Q_SKIP,
279
  Q_CHMOD_FILE, Q_APPEND_FILE, Q_CAT_FILE, Q_DIFF_FILES,
280
  Q_SEND_QUIT,
281 282 283 284

  Q_UNKNOWN,			       /* Unknown command.   */
  Q_COMMENT,			       /* Comments, ignored. */
  Q_COMMENT_WITH_COMMAND
285 286
};

287

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
const char *command_names[]=
{
  "connection",
  "query",
  "connect",
  "sleep",
  "real_sleep",
  "inc",
  "dec",
  "source",
  "disconnect",
  "let",
  "echo",
  "while",
  "end",
  "system",
  "result",
  "require",
  "save_master_pos",
  "sync_with_master",
308
  "sync_slave_with_master",
309 310 311 312 313
  "error",
  "send",
  "reap",
  "dirty_close",
  "replace_result",
314
  "replace_column",
315 316 317 318 319 320
  "ping",
  "eval",
  "rpl_probe",
  "enable_rpl_parse",
  "disable_rpl_parse",
  "eval_result",
321
  /* Enable/disable that the _query_ is logged to result file */
322 323
  "enable_query_log",
  "disable_query_log",
324
  /* Enable/disable that the _result_ from a query is logged to result file */
325 326 327
  "enable_result_log",
  "disable_result_log",
  "wait_for_slave_to_stop",
328 329 330
  "enable_warnings",
  "disable_warnings",
  "enable_info",
331
  "disable_info",
332 333
  "enable_metadata",
  "disable_metadata",
334
  "exec",
335
  "delimiter",
336 337
  "disable_abort_on_error",
  "enable_abort_on_error",
338
  "vertical_results",
339
  "horizontal_results",
340
  "query_vertical",
341
  "query_horizontal",
342
  "sorted_result",
kent@mysql.com's avatar
kent@mysql.com committed
343 344
  "start_timer",
  "end_timer",
kent@mysql.com's avatar
kent@mysql.com committed
345
  "character_set",
346 347
  "disable_ps_protocol",
  "enable_ps_protocol",
348 349
  "disable_reconnect",
  "enable_reconnect",
350
  "if",
351 352 353 354 355 356 357 358 359
  "disable_parsing",
  "enable_parsing",
  "replace_regex",
  "remove_file",
  "file_exists",
  "write_file",
  "copy_file",
  "perl",
  "die",
360
               
361 362
  /* Don't execute any more commands, compare result */
  "exit",
363
  "skip",
364
  "chmod",
365
  "append_file",
366
  "cat_file",
367
  "diff_files",
368
  "send_quit",
jcole@tetra.spaceapes.com's avatar
jcole@tetra.spaceapes.com committed
369
  0
370 371
};

372 373 374 375 376 377 378 379 380

/*
  The list of error codes to --error are stored in an internal array of
  structs. This struct can hold numeric SQL error codes, error names or
  SQLSTATE codes as strings. The element next to the last active element
  in the list is set to type ERR_EMPTY. When an SQL statement returns an
  error, we use this list to check if this is an expected error.
*/
enum match_err_type
381
{
382 383 384 385
  ERR_EMPTY= 0,
  ERR_ERRNO,
  ERR_SQLSTATE
};
386

387 388 389 390 391 392 393 394 395
struct st_match_err
{
  enum match_err_type type;
  union
  {
    uint errnum;
    char sqlstate[SQLSTATE_LENGTH+1];  /* \0 terminated string */
  } code;
};
396

397 398 399 400 401 402
struct st_expected_errors
{
  struct st_match_err err[10];
  uint count;
};
static struct st_expected_errors saved_expected_errors;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
403

404 405 406 407
struct st_command
{
  char *query, *query_buf,*first_argument,*last_argument,*end;
  int first_word_len, query_len;
408
  my_bool abort_on_error;
409
  struct st_expected_errors expected_errors;
410
  char require_file[FN_REFLEN];
411 412
  enum enum_commands type;
};
413

414 415
TYPELIB command_typelib= {array_elements(command_names),"",
			  command_names, 0};
416

417
DYNAMIC_STRING ds_res, ds_progress, ds_warning_messages;
418

419 420
char builtin_echo[FN_REFLEN];

421
void die(const char *fmt, ...)
422
  ATTRIBUTE_FORMAT(printf, 1, 2);
423
void abort_not_supported_test(const char *fmt, ...)
424
  ATTRIBUTE_FORMAT(printf, 1, 2);
425
void verbose_msg(const char *fmt, ...)
426
  ATTRIBUTE_FORMAT(printf, 1, 2);
427
void warning_msg(const char *fmt, ...)
428
  ATTRIBUTE_FORMAT(printf, 1, 2);
429 430
void log_msg(const char *fmt, ...)
  ATTRIBUTE_FORMAT(printf, 1, 2);
431 432 433 434 435 436 437 438 439

VAR* var_from_env(const char *, const char *);
VAR* var_init(VAR* v, const char *name, int name_len, const char *val,
              int val_len);
void var_free(void* v);
VAR* var_get(const char *var_name, const char** var_name_end,
             my_bool raw, my_bool ignore_not_existing);
void eval_expr(VAR* v, const char *p, const char** p_end);
my_bool match_delimiter(int c, const char *delim, uint length);
440 441 442 443
void dump_result_to_reject_file(char *buf, int size);
void dump_result_to_log_file(char *buf, int size);
void dump_warning_messages();
void dump_progress();
444 445 446 447

void do_eval(DYNAMIC_STRING *query_eval, const char *query,
             const char *query_end, my_bool pass_through_escape_chars);
void str_to_file(const char *fname, char *str, int size);
448
void str_to_file2(const char *fname, char *str, int size, my_bool append);
449

450 451 452 453
#ifdef __WIN__
void free_tmp_sh_file();
void free_win_path_patterns();
#endif
454 455


456 457 458 459 460 461 462 463
/* For replace_column */
static char *replace_column[MAX_COLUMNS];
static uint max_replace_column= 0;
void do_get_replace_column(struct st_command*);
void free_replace_column();

/* For replace */
void do_get_replace(struct st_command *command);
464
void free_replace();
465

466 467 468 469
/* For replace_regex */
void do_get_replace_regex(struct st_command *command);
void free_replace_regex();

470

471 472 473 474 475
void free_all_replace(){
  free_replace();
  free_replace_regex();
  free_replace_column();
}
476 477


monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
478
/* Disable functions that only exist in MySQL 4.0 */
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
479
#if MYSQL_VERSION_ID < 40000
480 481 482
void mysql_enable_rpl_parse(MYSQL* mysql __attribute__((unused))) {}
void mysql_disable_rpl_parse(MYSQL* mysql __attribute__((unused))) {}
int mysql_rpl_parse_enabled(MYSQL* mysql __attribute__((unused))) { return 1; }
483
my_bool mysql_rpl_probe(MYSQL *mysql __attribute__((unused))) { return 1; }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
484
#endif
485 486 487 488
void replace_dynstr_append_mem(DYNAMIC_STRING *ds, const char *val,
                               int len);
void replace_dynstr_append(DYNAMIC_STRING *ds, const char *val);
void replace_dynstr_append_uint(DYNAMIC_STRING *ds, uint val);
489
void dynstr_append_sorted(DYNAMIC_STRING* ds, DYNAMIC_STRING* ds_input);
490 491 492 493 494 495

void handle_error(struct st_command*,
                  unsigned int err_errno, const char *err_error,
                  const char *err_sqlstate, DYNAMIC_STRING *ds);
void handle_no_error(struct st_command*);

496
#ifdef EMBEDDED_LIBRARY
497 498 499 500

/* attributes of the query thread */
pthread_attr_t cn_thd_attrib;

501
/*
502
  send_one_query executes query in separate thread, which is
503 504 505
  necessary in embedded library to run 'send' in proper way.
  This implementation doesn't handle errors returned
  by mysql_send_query. It's technically possible, though
506
  I don't see where it is needed.
507
*/
508
pthread_handler_t send_one_query(void *arg)
509
{
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
510
  struct st_connection *cn= (struct st_connection*)arg;
511 512 513 514 515 516 517 518 519 520 521 522 523

  mysql_thread_init();
  VOID(mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len));

  mysql_thread_end();
  pthread_mutex_lock(&cn->mutex);
  cn->query_done= 1;
  VOID(pthread_cond_signal(&cn->cond));
  pthread_mutex_unlock(&cn->mutex);
  pthread_exit(0);
  return 0;
}

holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
524
static int do_send_query(struct st_connection *cn, const char *q, int q_len,
525 526 527 528
                         int flags)
{
  pthread_t tid;

529
  if (flags & QUERY_REAP_FLAG)
530 531 532 533 534
    return mysql_send_query(&cn->mysql, q, q_len);

  if (pthread_mutex_init(&cn->mutex, NULL) ||
      pthread_cond_init(&cn->cond, NULL))
    die("Error in the thread library");
535

536 537 538
  cn->cur_query= q;
  cn->cur_query_len= q_len;
  cn->query_done= 0;
539
  if (pthread_create(&tid, &cn_thd_attrib, send_one_query, (void*)cn))
540 541 542 543 544 545 546 547 548 549
    die("Cannot start new thread for query");

  return 0;
}

#else /*EMBEDDED_LIBRARY*/

#define do_send_query(cn,q,q_len,flags) mysql_send_query(&cn->mysql, q, q_len)

#endif /*EMBEDDED_LIBRARY*/
550 551 552

void do_eval(DYNAMIC_STRING *query_eval, const char *query,
             const char *query_end, my_bool pass_through_escape_chars)
553
{
554
  const char *p;
555
  register char c, next_c;
556
  register int escaped = 0;
557
  VAR *v;
monty@mysql.com's avatar
monty@mysql.com committed
558
  DBUG_ENTER("do_eval");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
559

560
  for (p= query; (c= *p) && p < query_end; ++p)
561 562 563 564 565
  {
    switch(c) {
    case '$':
      if (escaped)
      {
566
	escaped= 0;
567 568 569 570
	dynstr_append_mem(query_eval, p, 1);
      }
      else
      {
571
	if (!(v= var_get(p, &p, 0, 0)))
572 573 574 575 576
	  die("Bad variable in eval");
	dynstr_append_mem(query_eval, v->str_val, v->str_val_len);
      }
      break;
    case '\\':
577
      next_c= *(p+1);
578 579
      if (escaped)
      {
580
	escaped= 0;
581 582
	dynstr_append_mem(query_eval, p, 1);
      }
583 584 585 586 587 588 589 590 591 592 593
      else if (next_c == '\\' || next_c == '$' || next_c == '"')
      {
        /* Set escaped only if next char is \, " or $ */
	escaped= 1;

        if (pass_through_escape_chars)
        {
          /* The escape char should be added to the output string. */
          dynstr_append_mem(query_eval, p, 1);
        }
      }
594
      else
595
	dynstr_append_mem(query_eval, p, 1);
596 597
      break;
    default:
598
      escaped= 0;
599 600
      dynstr_append_mem(query_eval, p, 1);
      break;
601
    }
602
  }
monty@mysql.com's avatar
monty@mysql.com committed
603
  DBUG_VOID_RETURN;
604
}
605

606

607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
/*
  Show any warnings just before the error. Since the last error
  is added to the warning stack, only print @@warning_count-1 warnings.

  NOTE! This function should be safe to call when an error
  has occured and this any further errors will be ignored(although logged)

  SYNOPSIS
  show_warnings_before_error
  mysql - connection to use

*/

static void show_warnings_before_error(MYSQL* mysql)
{
  MYSQL_RES* res;
  const char* query= "SHOW WARNINGS";
  DBUG_ENTER("show_warnings_before_error");

  if (!mysql)
    DBUG_VOID_RETURN;

  if (mysql_query(mysql, query))
  {
    log_msg("Error running query '%s': %d %s",
            query, mysql_errno(mysql), mysql_error(mysql));
    DBUG_VOID_RETURN;
  }

  if ((res= mysql_store_result(mysql)) == NULL)
  {
    /* No result set returned */
    DBUG_VOID_RETURN;
  }

  if (mysql_num_rows(res) <= 1)
  {
    /* Don't display the last row, it's "last error" */
  }
  else
  {
    MYSQL_ROW row;
    unsigned int row_num= 0;
    unsigned int num_fields= mysql_num_fields(res);

    fprintf(stderr, "\nWarnings from just before the error:\n");
    while ((row= mysql_fetch_row(res)))
    {
      unsigned int i;
      unsigned long *lengths= mysql_fetch_lengths(res);

      if (++row_num >= mysql_num_rows(res))
      {
        /* Don't display the last row, it's "last error" */
        break;
      }

      for(i= 0; i < num_fields; i++)
      {
        fprintf(stderr, "%.*s ", lengths[i],
                row[i] ? row[i] : "NULL");
      }
      fprintf(stderr, "\n");
    }
  }
  mysql_free_result(res);

  DBUG_VOID_RETURN;
}


678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
enum arg_type
{
  ARG_STRING,
  ARG_REST
};

struct command_arg {
  const char *argname;       /* Name of argument   */
  enum arg_type type;        /* Type of argument   */
  my_bool required;          /* Argument required  */
  DYNAMIC_STRING *ds;        /* Storage for argument */
  const char *description;   /* Description of the argument */
};


void check_command_args(struct st_command *command,
                        const char *arguments,
                        const struct command_arg *args,
                        int num_args, const char delimiter_arg)
{
  int i;
  const char *ptr= arguments;
  const char *start;
  DBUG_ENTER("check_command_args");
  DBUG_PRINT("enter", ("num_args: %d", num_args));
703

704 705 706 707
  for (i= 0; i < num_args; i++)
  {
    const struct command_arg *arg= &args[i];

708
    switch (arg->type) {
709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
      /* A string */
    case ARG_STRING:
      /* Skip leading spaces */
      while (*ptr && *ptr == ' ')
        ptr++;
      start= ptr;
      /* Find end of arg, terminated by "delimiter_arg" */
      while (*ptr && *ptr != delimiter_arg)
        ptr++;
      if (ptr > start)
      {
        init_dynamic_string(arg->ds, 0, ptr-start, 32);
        do_eval(arg->ds, start, ptr, FALSE);
      }
      else
      {
        /* Empty string */
        init_dynamic_string(arg->ds, "", 0, 0);
      }
      command->last_argument= (char*)ptr;

      /* Step past the delimiter */
      if (*ptr && *ptr == delimiter_arg)
        ptr++;
      DBUG_PRINT("info", ("val: %s", arg->ds->str));
      break;

      /* Rest of line */
    case ARG_REST:
      start= ptr;
      init_dynamic_string(arg->ds, 0, command->query_len, 256);
      do_eval(arg->ds, start, command->end, FALSE);
      command->last_argument= command->end;
      DBUG_PRINT("info", ("val: %s", arg->ds->str));
      break;

    default:
      DBUG_ASSERT("Unknown argument type");
      break;
    }

    /* Check required arg */
    if (arg->ds->length == 0 && arg->required)
      die("Missing required argument '%s' to command '%.*s'", arg->argname,
          command->first_word_len, command->query);

  }
  DBUG_VOID_RETURN;
}


void handle_command_error(struct st_command *command, uint error)
{
  DBUG_ENTER("handle_command_error");
  DBUG_PRINT("enter", ("error: %d", error));
  if (error != 0)
  {
    uint i;

    if (command->abort_on_error)
      die("command \"%.*s\" failed with error %d",
          command->first_word_len, command->query, error);
    for (i= 0; i < command->expected_errors.count; i++)
    {
      DBUG_PRINT("info", ("expected error: %d",
                          command->expected_errors.err[i].code.errnum));
      if ((command->expected_errors.err[i].type == ERR_ERRNO) &&
          (command->expected_errors.err[i].code.errnum == error))
      {
        DBUG_PRINT("info", ("command \"%.*s\" failed with expected error: %d",
                            command->first_word_len, command->query, error));
        DBUG_VOID_RETURN;
      }
    }
    die("command \"%.*s\" failed with wrong error: %d",
        command->first_word_len, command->query, error);
  }
  else if (command->expected_errors.err[0].type == ERR_ERRNO &&
           command->expected_errors.err[0].code.errnum != 0)
  {
    /* Error code we wanted was != 0, i.e. not an expected success */
    die("command \"%.*s\" succeeded - should have failed with errno %d...",
        command->first_word_len, command->query,
        command->expected_errors.err[0].code.errnum);
  }
  DBUG_VOID_RETURN;
}


void close_connections()
799
{
800 801
  DBUG_ENTER("close_connections");
  for (--next_con; next_con >= connections; --next_con)
802
  {
803 804 805
    if (next_con->stmt)
      mysql_stmt_close(next_con->stmt);
    next_con->stmt= 0;
806
    mysql_close(&next_con->mysql);
807 808
    if (next_con->util_mysql)
      mysql_close(next_con->util_mysql);
809 810 811 812 813
    my_free(next_con->name, MYF(MY_ALLOW_ZERO_PTR));
  }
  DBUG_VOID_RETURN;
}

814

815 816 817 818 819 820 821 822 823 824 825 826 827 828
void close_statements()
{
  struct st_connection *con;
  DBUG_ENTER("close_statements");
  for (con= connections; con < next_con; con++)
  {
    if (con->stmt)
      mysql_stmt_close(con->stmt);
    con->stmt= 0;
  }
  DBUG_VOID_RETURN;
}


829
void close_files()
830
{
831
  DBUG_ENTER("close_files");
832
  for (; cur_file >= file_stack; cur_file--)
833
  {
834
    if (cur_file->file && cur_file->file != stdin)
835 836
    {
      DBUG_PRINT("info", ("closing file: %s", cur_file->file_name));
837
      my_fclose(cur_file->file, MYF(0));
838
    }
839 840
    my_free((gptr)cur_file->file_name, MYF(MY_ALLOW_ZERO_PTR));
    cur_file->file_name= 0;
841 842
  }
  DBUG_VOID_RETURN;
843 844
}

845

846
void free_used_memory()
847 848 849
{
  uint i;
  DBUG_ENTER("free_used_memory");
850 851

  close_connections();
852
  close_files();
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
853
  hash_free(&var_hash);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
854

855
  for (i= 0 ; i < q_lines.elements ; i++)
856
  {
857
    struct st_command **q= dynamic_element(&q_lines, i, struct st_command**);
858
    my_free((gptr) (*q)->query_buf,MYF(MY_ALLOW_ZERO_PTR));
859 860
    my_free((gptr) (*q),MYF(0));
  }
861
  for (i= 0; i < 10; i++)
862 863 864 865
  {
    if (var_reg[i].alloced_len)
      my_free(var_reg[i].str_val, MYF(MY_WME));
  }
866 867
  while (embedded_server_arg_count > 1)
    my_free(embedded_server_args[--embedded_server_arg_count],MYF(0));
868 869
  delete_dynamic(&q_lines);
  dynstr_free(&ds_res);
870
  dynstr_free(&ds_progress);
871
  dynstr_free(&ds_warning_messages);
872
  free_all_replace();
873
  my_free(opt_pass,MYF(MY_ALLOW_ZERO_PTR));
874
  free_defaults(default_argv);
875 876 877 878 879
  free_re();
#ifdef __WIN__
  free_tmp_sh_file();
  free_win_path_patterns();
#endif
880 881 882 883 884 885 886

  /* Only call mysql_server_end if mysql_server_init has been called */
  if (server_initialized)
    mysql_server_end();

  /* Don't use DBUG after mysql_server_end() */
  return;
887 888
}

889

890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916
static void cleanup_and_exit(int exit_code)
{
  free_used_memory();
  my_end(MY_CHECK_ERROR);

  if (!silent)
  {
    switch (exit_code)
    {
    case 1:
      printf("not ok\n");
      break;
    case 0:
      printf("ok\n");
      break;
    case 62:
      printf("skipped\n");
    break;
    default:
      printf("unknown exit code: %d\n", exit_code);
      DBUG_ASSERT(0);
    }
  }

  exit(exit_code);
}

917
void die(const char *fmt, ...)
918
{
919
  static int dying= 0;
920
  va_list args;
921
  DBUG_ENTER("die");
922 923
  DBUG_PRINT("enter", ("start_lineno: %d", start_lineno));

924 925 926 927 928 929 930
  /*
    Protect against dying twice
    first time 'die' is called, try to write log files
    second time, just exit
  */
  if (dying)
    cleanup_and_exit(1);
931
  dying= 1;
932

933
  /* Print the error message */
934 935 936 937 938 939
  fprintf(stderr, "mysqltest: ");
  if (cur_file && cur_file != file_stack)
    fprintf(stderr, "In included file \"%s\": ",
            cur_file->file_name);
  if (start_lineno > 0)
    fprintf(stderr, "At line %u: ", start_lineno);
940 941
  if (fmt)
  {
942
    va_start(args, fmt);
943
    vfprintf(stderr, fmt, args);
944
    va_end(args);
945
  }
946 947 948 949
  else
    fprintf(stderr, "unknown error");
  fprintf(stderr, "\n");
  fflush(stderr);
950

951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
  /* Show results from queries just before failure */
  if (ds_res.length && opt_tail_lines)
  {
    int tail_lines= opt_tail_lines;
    char* show_from= ds_res.str + ds_res.length - 1;
    while(show_from > ds_res.str && tail_lines > 0 )
    {
      show_from--;
      if (*show_from == '\n')
        tail_lines--;
    }
    fprintf(stderr, "\nThe result from queries just before the failure was:\n");
    if (show_from > ds_res.str)
      fprintf(stderr, "< snip >");
    fprintf(stderr, "%s", show_from);
    fflush(stderr);
  }

969
  /* Dump the result that has been accumulated so far to .log file */
970 971
  if (result_file_name && ds_res.length)
    dump_result_to_log_file(ds_res.str, ds_res.length);
972

973
  /* Dump warning messages */
974 975
  if (result_file_name && ds_warning_messages.length)
    dump_warning_messages();
976

977 978 979 980 981 982 983
  /*
    Help debugging by displaying any warnings that might have
    been produced prior to the error
  */
  if (cur_con)
    show_warnings_before_error(&cur_con->mysql);

984
  cleanup_and_exit(1);
985 986
}

987

988
void abort_not_supported_test(const char *fmt, ...)
989
{
990 991
  va_list args;
  struct st_test_file* err_file= cur_file;
992
  DBUG_ENTER("abort_not_supported_test");
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016

  /* Print include filestack */
  fprintf(stderr, "The test '%s' is not supported by this installation\n",
          file_stack->file_name);
  fprintf(stderr, "Detected in file %s at line %d\n",
          err_file->file_name, err_file->lineno);
  while (err_file != file_stack)
  {
    err_file--;
    fprintf(stderr, "included from %s at line %d\n",
            err_file->file_name, err_file->lineno);
  }

  /* Print error message */
  va_start(args, fmt);
  if (fmt)
  {
    fprintf(stderr, "reason: ");
    vfprintf(stderr, fmt, args);
    fprintf(stderr, "\n");
    fflush(stderr);
  }
  va_end(args);

1017
  cleanup_and_exit(62);
1018 1019
}

1020 1021 1022

void abort_not_in_this_version()
{
1023
  die("Not available in this version of mysqltest");
1024 1025 1026 1027
}


void verbose_msg(const char *fmt, ...)
1028 1029
{
  va_list args;
1030 1031 1032
  DBUG_ENTER("verbose_msg");
  if (!verbose)
    DBUG_VOID_RETURN;
1033 1034

  va_start(args, fmt);
1035
  fprintf(stderr, "mysqltest: ");
1036 1037 1038
  if (cur_file && cur_file != file_stack)
    fprintf(stderr, "In included file \"%s\": ",
            cur_file->file_name);
1039
  if (start_lineno != 0)
1040
    fprintf(stderr, "At line %u: ", start_lineno);
1041 1042 1043
  vfprintf(stderr, fmt, args);
  fprintf(stderr, "\n");
  va_end(args);
1044

1045
  DBUG_VOID_RETURN;
1046 1047
}

1048

1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
void warning_msg(const char *fmt, ...)
{
  va_list args;
  char buff[512];
  size_t len;
  DBUG_ENTER("warning_msg");

  va_start(args, fmt);
  dynstr_append(&ds_warning_messages, "mysqltest: ");
  if (start_lineno != 0)
  {
1060 1061 1062 1063 1064 1065 1066 1067 1068
    dynstr_append(&ds_warning_messages, "Warning detected ");
    if (cur_file && cur_file != file_stack)
    {
      len= my_snprintf(buff, sizeof(buff), "in included file %s ",
                       cur_file->file_name);
      dynstr_append_mem(&ds_warning_messages,
                        buff, len);
    }
    len= my_snprintf(buff, sizeof(buff), "at line %d: ",
1069 1070 1071 1072
                     start_lineno);
    dynstr_append_mem(&ds_warning_messages,
                      buff, len);
  }
1073 1074

  len= my_vsnprintf(buff, sizeof(buff), fmt, args);
1075
  dynstr_append_mem(&ds_warning_messages, buff, len);
1076

1077 1078 1079 1080 1081 1082 1083
  dynstr_append(&ds_warning_messages, "\n");
  va_end(args);

  DBUG_VOID_RETURN;
}


1084 1085 1086
void log_msg(const char *fmt, ...)
{
  va_list args;
msvensson@shellback.(none)'s avatar
msvensson@shellback.(none) committed
1087
  char buff[1024];
1088 1089 1090 1091
  size_t len;
  DBUG_ENTER("log_msg");

  va_start(args, fmt);
1092
  len= my_vsnprintf(buff, sizeof(buff)-1, fmt, args);
1093 1094 1095 1096 1097 1098 1099 1100 1101
  va_end(args);

  dynstr_append_mem(&ds_res, buff, len);
  dynstr_append(&ds_res, "\n");

  DBUG_VOID_RETURN;
}


1102
/*
1103 1104 1105 1106 1107 1108 1109
  Read a file and append it to ds

  SYNOPSIS
  cat_file
  ds - pointer to dynamic string where to add the files content
  filename - name of the file to read

1110
*/
1111

1112
void cat_file(DYNAMIC_STRING* ds, const char* filename)
1113 1114
{
  int fd;
1115 1116
  uint len;
  char buff[512];
1117

1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
  if ((fd= my_open(filename, O_RDONLY, MYF(0))) < 0)
    die("Failed to open file %s", filename);
  while((len= my_read(fd, (byte*)&buff,
                      sizeof(buff), MYF(0))) > 0)
  {
    char *p= buff, *start= buff;
    while (p < buff+len)
    {
      /* Convert cr/lf to lf */
      if (*p == '\r' && *(p+1) && *(p+1)== '\n')
      {
        /* Add fake newline instead of cr and output the line */
        *p= '\n';
        p++; /* Step past the "fake" newline */
        dynstr_append_mem(ds, start, p-start);
        p++; /* Step past the "fake" newline */
        start= p;
      }
      else
        p++;
    }
    /* Output any chars that migh be left */
    dynstr_append_mem(ds, start, p-start);
  }
  my_close(fd, MYF(0));
}


/*
  Run the specified command with popen

  SYNOPSIS
  run_command
  cmd - command to execute(should be properly quoted
  ds_res- pointer to dynamic string where to store the result

*/

static int run_command(char* cmd,
                       DYNAMIC_STRING *ds_res)
{
  char buf[512]= {0};
  FILE *res_file;
  int error;

  if (!(res_file= popen(cmd, "r")))
    die("popen(\"%s\", \"r\") failed", cmd);

  while (fgets(buf, sizeof(buf), res_file))
1167
  {
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
    DBUG_PRINT("info", ("buf: %s", buf));
    if(ds_res)
    {
      /* Save the output of this command in the supplied string */
      dynstr_append(ds_res, buf);
    }
    else
    {
      /* Print it directly on screen */
      fprintf(stdout, "%s", buf);
    }
1179 1180
  }

1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
  error= pclose(res_file);
  return WEXITSTATUS(error);
}


/*
  Run the specified tool with variable number of arguments

  SYNOPSIS
  run_tool
  tool_path - the name of the tool to run
  ds_res - pointer to dynamic string where to store the result
  ... - variable number of arguments that will be properly
        quoted and appended after the tool's name

*/

static int run_tool(const char *tool_path, DYNAMIC_STRING *ds_res, ...)
{
  int ret;
  const char* arg;
  va_list args;
  DYNAMIC_STRING ds_cmdline;

  DBUG_ENTER("run_tool");
  DBUG_PRINT("enter", ("tool_path: %s", tool_path));

  if (init_dynamic_string(&ds_cmdline, IF_WIN("\"", ""), FN_REFLEN, FN_REFLEN))
    die("Out of memory");

  dynstr_append_os_quoted(&ds_cmdline, tool_path, NullS);
  dynstr_append(&ds_cmdline, " ");

  va_start(args, ds_res);

  while ((arg= va_arg(args, char *)))
1217
  {
1218 1219 1220 1221 1222 1223
    /* Options should be os quoted */
    if (strncmp(arg, "--", 2) == 0)
      dynstr_append_os_quoted(&ds_cmdline, arg, NullS);
    else
      dynstr_append(&ds_cmdline, arg);
    dynstr_append(&ds_cmdline, " ");
1224
  }
1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259

  va_end(args);

#ifdef __WIN__
  dynstr_append(&ds_cmdline, "\"");
#endif

  DBUG_PRINT("info", ("Running: %s", ds_cmdline.str));
  ret= run_command(ds_cmdline.str, ds_res);
  DBUG_PRINT("exit", ("ret: %d", ret));
  dynstr_free(&ds_cmdline);
  DBUG_RETURN(ret);
}


/*
  Show the diff of two files using the systems builtin diff
  command. If no such diff command exist, just dump the content
  of the two files and inform about how to get "diff"

  SYNOPSIS
  show_diff
  ds - pointer to dynamic string where to add the diff(may be NULL)
  filename1 - name of first file
  filename2 - name of second file

*/

void show_diff(DYNAMIC_STRING* ds,
               const char* filename1, const char* filename2)
{

  DYNAMIC_STRING ds_tmp;

  if (init_dynamic_string(&ds_tmp, "", 256, 256))
1260
    die("Out of memory");
1261

1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
  /* First try with unified diff */
  if (run_tool("diff",
               &ds_tmp, /* Get output from diff in ds_tmp */
               "-u",
               filename1,
               filename2,
               "2>&1",
               NULL) > 1) /* Most "diff" tools return >1 if error */
  {
    dynstr_set(&ds_tmp, "");

    /* Fallback to context diff with "diff -c" */
    if (run_tool("diff",
                 &ds_tmp, /* Get output from diff in ds_tmp */
                 "-c",
                 filename1,
                 filename2,
                 "2>&1",
                 NULL) > 1) /* Most "diff" tools return >1 if error */
1281
    {
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
      /*
        Fallback to dump both files to result file and inform
        about installing "diff"
      */
      dynstr_set(&ds_tmp, "");

      dynstr_append(&ds_tmp,
"\n"
"The two files differ but it was not possible to execute 'diff' in\n"
"order to show only the difference, tried both 'diff -u' or 'diff -c'.\n"
"Instead the whole content of the two files was shown for you to diff manually. ;)\n\n"
"To get a better report you should install 'diff' on your system, which you\n"
"for example can get from http://www.gnu.org/software/diffutils/diffutils.html\n"
#ifdef __WIN__
"or http://gnuwin32.sourceforge.net/packages/diffutils.htm\n"
#endif
"\n");

      dynstr_append(&ds_tmp, " --- ");
      dynstr_append(&ds_tmp, filename1);
      dynstr_append(&ds_tmp, " >>>\n");
      cat_file(&ds_tmp, filename1);
      dynstr_append(&ds_tmp, "<<<\n --- ");
      dynstr_append(&ds_tmp, filename1);
      dynstr_append(&ds_tmp, " >>>\n");
      cat_file(&ds_tmp, filename2);
      dynstr_append(&ds_tmp, "<<<<\n");
1309 1310
    }
  }
1311 1312 1313 1314 1315 1316

  if (ds)
  {
    /* Add the diff to output */
    dynstr_append_mem(ds, ds_tmp.str, ds_tmp.length);
  }
1317 1318
  else
  {
1319
    /* Print diff directly to stdout */
1320
    fprintf(stderr, "%s\n", ds_tmp.str);
1321
  }
1322 1323
 
  dynstr_free(&ds_tmp);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1324

1325
}
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1326 1327


1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
enum compare_files_result_enum {
   RESULT_OK= 0,
   RESULT_CONTENT_MISMATCH= 1,
   RESULT_LENGTH_MISMATCH= 2
};

/*
  Compare two files, given a fd to the first file and
  name of the second file

  SYNOPSIS
  compare_files2
  fd - Open file descriptor of the first file
  filename2 - Name of second file

  RETURN VALUES
  According to the values in "compare_files_result_enum"

*/

int compare_files2(File fd, const char* filename2)
{
  int error= RESULT_OK;
  File fd2;
  uint len, len2;
  char buff[512], buff2[512];
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1354

1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
  if ((fd2= my_open(filename2, O_RDONLY, MYF(0))) < 0)
  {
    my_close(fd, MYF(0));
    die("Failed to open second file: %s", filename2);
  }
  while((len= my_read(fd, (byte*)&buff,
                      sizeof(buff), MYF(0))) > 0)
  {
    if ((len2= my_read(fd2, (byte*)&buff2,
                       sizeof(buff2), MYF(0))) < len)
    {
      /* File 2 was smaller */
      error= RESULT_LENGTH_MISMATCH;
      break;
    }
    if (len2 > len)
    {
      /* File 1 was smaller */
      error= RESULT_LENGTH_MISMATCH;
      break;
    }
    if ((memcmp(buff, buff2, len)))
    {
      /* Content of this part differed */
      error= RESULT_CONTENT_MISMATCH;
      break;
    }
  }
  if (!error && my_read(fd2, (byte*)&buff2,
                        sizeof(buff2), MYF(0)) > 0)
  {
    /* File 1 was smaller */
    error= RESULT_LENGTH_MISMATCH;
  }

  my_close(fd2, MYF(0));

  return error;
}


/*
  Compare two files, given their filenames

  SYNOPSIS
  compare_files
  filename1 - Name of first file
  filename2 - Name of second file

  RETURN VALUES
  See 'compare_files2'

*/

int compare_files(const char* filename1, const char* filename2)
{
  File fd;
  int error;

  if ((fd= my_open(filename1, O_RDONLY, MYF(0))) < 0)
    die("Failed to open first file: %s", filename1);

  error= compare_files2(fd, filename2);

  my_close(fd, MYF(0));

  return error;
}


/*
  Compare content of the string in ds to content of file fname

  SYNOPSIS
  dyn_string_cmp
  ds - Dynamic string containing the string o be compared
  fname - Name of file to compare with

  RETURN VALUES
  See 'compare_files2'
*/

int dyn_string_cmp(DYNAMIC_STRING* ds, const char *fname)
{
  int error;
  File fd;
  char ds_temp_file_path[FN_REFLEN];

  DBUG_ENTER("dyn_string_cmp");
  DBUG_PRINT("enter", ("fname: %s", fname));

  if ((fd= create_temp_file(ds_temp_file_path, NULL,
                            "tmp", O_CREAT | O_SHARE | O_RDWR,
                            MYF(MY_WME))) < 0)
    die("Failed to create temporary file for ds");

  /* Write ds to temporary file and set file pos to beginning*/
  if (my_write(fd, ds->str, ds->length,
               MYF(MY_FNABP | MY_WME)) ||
      my_seek(fd, 0, SEEK_SET, MYF(0)) == MY_FILEPOS_ERROR)
  {
    my_close(fd, MYF(0));
    /* Remove the temporary file */
    my_delete(ds_temp_file_path, MYF(0));
    die("Failed to write to '%s'", ds_temp_file_path);
  }

  error= compare_files2(fd, fname);

  my_close(fd, MYF(0));
  /* Remove the temporary file */
  my_delete(ds_temp_file_path, MYF(0));

  DBUG_RETURN(error);
1469 1470
}

1471 1472

/*
1473
  Check the content of ds against result file
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483

  SYNOPSIS
  check_result
  ds - content to be checked

  RETURN VALUES
  error - the function will not return

*/

1484
void check_result(DYNAMIC_STRING* ds)
1485
{
1486 1487
  const char* mess= "Result content mismatch\n";

1488
  DBUG_ENTER("check_result");
1489
  DBUG_ASSERT(result_file_name);
1490
  DBUG_PRINT("enter", ("result_file_name: %s", result_file_name));
1491

1492
  switch (dyn_string_cmp(ds, result_file_name))
1493
  {
1494
  case RESULT_OK:
1495
    break; /* ok */
1496
  case RESULT_LENGTH_MISMATCH:
1497 1498
    mess= "Result length mismatch\n";
    /* Fallthrough */
1499
  case RESULT_CONTENT_MISMATCH:
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
  {
    /* Result mismatched, dump results to .reject file and then show the diff */
    char reject_file[FN_REFLEN];
    fn_format(reject_file, result_file_name, "", ".reject",
              MY_REPLACE_EXT);
    DBUG_PRINT("enter", ("reject_file_name: %s", reject_file));
    str_to_file(reject_file, ds->str, ds->length);

    dynstr_set(ds, NULL); /* Don't create a .log file */

    show_diff(NULL, result_file_name, reject_file);
    die(mess);
1512
    break;
1513
  }
1514 1515 1516
  default: /* impossible */
    die("Unknown error code from dyn_string_cmp()");
  }
1517 1518 1519 1520 1521

  DBUG_VOID_RETURN;
}


1522 1523 1524 1525 1526 1527
/*
  Check the content of ds against a require file
  If match fails, abort the test with special error code
  indicating that test is not supported

  SYNOPSIS
1528
  check_require
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550
  ds - content to be checked
  fname - name of file to check against

  RETURN VALUES
  error - the function will not return

*/

void check_require(DYNAMIC_STRING* ds, const char *fname)
{
  DBUG_ENTER("check_require");

  if (dyn_string_cmp(ds, fname))
  {
    char reason[FN_REFLEN];
    fn_format(reason, fname, "", "", MY_REPLACE_EXT | MY_REPLACE_DIR);
    abort_not_supported_test("Test requires: '%s'", reason);
  }
  DBUG_VOID_RETURN;
}


1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594
/*
   Remove surrounding chars from string

   Return 1 if first character is found but not last
*/
static int strip_surrounding(char* str, char c1, char c2)
{
  char* ptr= str;

  /* Check if the first non space character is c1 */
  while(*ptr && my_isspace(charset_info, *ptr))
    ptr++;
  if (*ptr == c1)
  {
    /* Replace it with a space */
    *ptr= ' ';

    /* Last non space charecter should be c2 */
    ptr= strend(str)-1;
    while(*ptr && my_isspace(charset_info, *ptr))
      ptr--;
    if (*ptr == c2)
    {
      /* Replace it with \0 */
      *ptr= 0;
    }
    else
    {
      /* Mismatch detected */
      return 1;
    }
  }
  return 0;
}


static void strip_parentheses(struct st_command *command)
{
  if (strip_surrounding(command->first_argument, '(', ')'))
      die("%.*s - argument list started with '%c' must be ended with '%c'",
          command->first_word_len, command->query, '(', ')');
}


1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658
static byte *get_var_key(const byte* var, uint* len,
                  my_bool __attribute__((unused)) t)
{
  register char* key;
  key = ((VAR*)var)->name;
  *len = ((VAR*)var)->name_len;
  return (byte*)key;
}


VAR *var_init(VAR *v, const char *name, int name_len, const char *val,
              int val_len)
{
  int val_alloc_len;
  VAR *tmp_var;
  if (!name_len && name)
    name_len = strlen(name);
  if (!val_len && val)
    val_len = strlen(val) ;
  val_alloc_len = val_len + 16; /* room to grow */
  if (!(tmp_var=v) && !(tmp_var = (VAR*)my_malloc(sizeof(*tmp_var)
                                                  + name_len+1, MYF(MY_WME))))
    die("Out of memory");

  tmp_var->name = (name) ? (char*) tmp_var + sizeof(*tmp_var) : 0;
  tmp_var->alloced = (v == 0);

  if (!(tmp_var->str_val = my_malloc(val_alloc_len+1, MYF(MY_WME))))
    die("Out of memory");

  memcpy(tmp_var->name, name, name_len);
  if (val)
  {
    memcpy(tmp_var->str_val, val, val_len);
    tmp_var->str_val[val_len]= 0;
  }
  tmp_var->name_len = name_len;
  tmp_var->str_val_len = val_len;
  tmp_var->alloced_len = val_alloc_len;
  tmp_var->int_val = (val) ? atoi(val) : 0;
  tmp_var->int_dirty = 0;
  tmp_var->env_s = 0;
  return tmp_var;
}


void var_free(void *v)
{
  my_free(((VAR*) v)->str_val, MYF(MY_WME));
  if (((VAR*)v)->alloced)
    my_free((char*) v, MYF(MY_WME));
}


VAR* var_from_env(const char *name, const char *def_val)
{
  const char *tmp;
  VAR *v;
  if (!(tmp = getenv(name)))
    tmp = def_val;

  v = var_init(0, name, strlen(name), tmp, strlen(tmp));
  my_hash_insert(&var_hash, (byte*)v);
  return v;
1659 1660
}

1661

1662
VAR* var_get(const char *var_name, const char **var_name_end, my_bool raw,
1663
	     my_bool ignore_not_existing)
1664 1665
{
  int digit;
1666
  VAR *v;
1667
  DBUG_ENTER("var_get");
1668
  DBUG_PRINT("enter", ("var_name: %s",var_name));
1669 1670

  if (*var_name != '$')
1671
    goto err;
1672
  digit = *++var_name - '0';
serg@serg.mylan's avatar
serg@serg.mylan committed
1673
  if (digit < 0 || digit >= 10)
1674
  {
1675
    const char *save_var_name = var_name, *end;
1676
    uint length;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1677
    end = (var_name_end) ? *var_name_end : 0;
1678
    while (my_isvar(charset_info,*var_name) && var_name != end)
1679
      var_name++;
1680 1681 1682 1683
    if (var_name == save_var_name)
    {
      if (ignore_not_existing)
	DBUG_RETURN(0);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1684
      die("Empty variable");
1685
    }
1686
    length= (uint) (var_name - save_var_name);
1687
    if (length >= MAX_VAR_NAME_LENGTH)
1688
      die("Too long variable name: %s", save_var_name);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1689

1690
    if (!(v = (VAR*) hash_search(&var_hash, save_var_name, length)))
1691
    {
1692
      char buff[MAX_VAR_NAME_LENGTH+1];
serg@serg.mylan's avatar
serg@serg.mylan committed
1693
      strmake(buff, save_var_name, length);
1694
      v= var_from_env(buff, "");
1695
    }
1696
    var_name--;	/* Point at last character */
1697
  }
1698
  else
1699
    v = var_reg + digit;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1700

1701 1702 1703 1704
  if (!raw && v->int_dirty)
  {
    sprintf(v->str_val, "%d", v->int_val);
    v->int_dirty = 0;
1705
    v->str_val_len = strlen(v->str_val);
1706
  }
1707
  if (var_name_end)
1708
    *var_name_end = var_name  ;
1709
  DBUG_RETURN(v);
1710 1711
err:
  if (var_name_end)
1712 1713
    *var_name_end = 0;
  die("Unsupported variable name: %s", var_name);
1714
  DBUG_RETURN(0);
1715 1716
}

1717 1718

VAR *var_obtain(const char *name, int len)
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1719 1720
{
  VAR* v;
1721
  if ((v = (VAR*)hash_search(&var_hash, name, len)))
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1722
    return v;
1723
  v = var_init(0, name, len, "", 0);
hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
1724
  my_hash_insert(&var_hash, (byte*)v);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1725 1726 1727
  return v;
}

1728 1729 1730 1731 1732 1733 1734 1735 1736

/*
  - if variable starts with a $ it is regarded as a local test varable
  - if not it is treated as a environment variable, and the corresponding
  environment variable will be updated
*/

void var_set(const char *var_name, const char *var_name_end,
             const char *var_val, const char *var_val_end)
1737
{
1738 1739
  int digit, env_var= 0;
  VAR *v;
1740 1741 1742 1743 1744 1745
  DBUG_ENTER("var_set");
  DBUG_PRINT("enter", ("var_name: '%.*s' = '%.*s' (length: %d)",
                       (int) (var_name_end - var_name), var_name,
                       (int) (var_val_end - var_val), var_val,
                       (int) (var_val_end - var_val)));

1746 1747 1748 1749 1750 1751 1752
  if (*var_name != '$')
    env_var= 1;
  else
    var_name++;

  digit= *var_name - '0';
  if (!(digit < 10 && digit >= 0))
1753
  {
1754
    v= var_obtain(var_name, (uint) (var_name_end - var_name));
1755
  }
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
  else
    v= var_reg + digit;

  eval_expr(v, var_val, (const char**) &var_val_end);

  if (env_var)
  {
    char buf[1024], *old_env_s= v->env_s;
    if (v->int_dirty)
    {
      sprintf(v->str_val, "%d", v->int_val);
      v->int_dirty= 0;
      v->str_val_len= strlen(v->str_val);
    }
1770 1771 1772
    my_snprintf(buf, sizeof(buf), "%.*s=%.*s",
                v->name_len, v->name,
                v->str_val_len, v->str_val);
1773 1774 1775 1776 1777 1778 1779 1780
    if (!(v->env_s= my_strdup(buf, MYF(MY_WME))))
      die("Out of memory");
    putenv(v->env_s);
    my_free((gptr)old_env_s, MYF(MY_ALLOW_ZERO_PTR));
  }
  DBUG_VOID_RETURN;
}

1781 1782 1783 1784 1785 1786 1787 1788 1789 1790

void var_set_string(const char* name, const char* value)
{
  var_set(name, name + strlen(name), value, value + strlen(value));
}


void var_set_int(const char* name, int value)
{
  char buf[21];
1791
  my_snprintf(buf, sizeof(buf), "%d", value);
1792 1793 1794 1795
  var_set_string(name, buf);
}


1796 1797
/*
  Store an integer (typically the returncode of the last SQL)
1798
  statement in the mysqltest builtin variable $mysql_errno
1799 1800 1801 1802
*/

void var_set_errno(int sql_errno)
{
1803
  var_set_int("$mysql_errno", sql_errno);
1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830
}

/*
  Set variable from the result of a query

  SYNOPSIS
  var_query_set()
  var	        variable to set from query
  query       start of query string to execute
  query_end   end of the query string to execute


  DESCRIPTION
  let @<var_name> = `<query>`

  Execute the query and assign the first row of result to var as
  a tab separated strings

  Also assign each column of the result set to
  variable "$<var_name>_<column_name>"
  Thus the tab separated output can be read from $<var_name> and
  and each individual column can be read as $<var_name>_<col_name>

*/

void var_query_set(VAR *var, const char *query, const char** query_end)
{
1831
  char *end = (char*)((query_end && *query_end) ?
1832 1833 1834 1835
		      *query_end : query + strlen(query));
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL* mysql = &cur_con->mysql;
1836
  DYNAMIC_STRING ds_query;
1837 1838 1839 1840 1841 1842 1843 1844 1845
  DBUG_ENTER("var_query_set");
  LINT_INIT(res);

  while (end > query && *end != '`')
    --end;
  if (query == end)
    die("Syntax error in query, missing '`'");
  ++query;

1846 1847 1848 1849
  /* Eval the query, thus replacing all environment variables */
  init_dynamic_string(&ds_query, 0, (end - query) + 32, 256);
  do_eval(&ds_query, query, end, FALSE);

1850
  if (mysql_real_query(mysql, ds_query.str, ds_query.length))
1851
    die("Error running query '%s': %d %s", ds_query.str,
1852
	mysql_errno(mysql), mysql_error(mysql));
1853 1854
  if (!(res= mysql_store_result(mysql)))
    die("Query '%s' didn't return a result set", ds_query.str);
1855
  dynstr_free(&ds_query);
1856

1857
  if ((row= mysql_fetch_row(res)) && row[0])
1858
  {
1859
    /*
1860 1861
      Concatenate all fields in the first row with tab in between
      and assign that string to the $variable
1862 1863 1864 1865 1866
    */
    DYNAMIC_STRING result;
    uint i;
    ulong *lengths;

1867
    init_dynamic_string(&result, "", 512, 512);
1868
    lengths= mysql_fetch_lengths(res);
1869
    for (i= 0; i < mysql_num_fields(res); i++)
1870
    {
1871
      if (row[i])
1872 1873 1874 1875 1876 1877 1878 1879 1880
      {
        /* Add column to tab separated string */
	dynstr_append_mem(&result, row[i], lengths[i]);
      }
      dynstr_append_mem(&result, "\t", 1);
    }
    end= result.str + result.length-1;
    eval_expr(var, result.str, (const char**) &end);
    dynstr_free(&result);
1881
  }
1882
  else
1883 1884 1885 1886 1887 1888 1889
    eval_expr(var, "", 0);

  mysql_free_result(res);
  DBUG_VOID_RETURN;
}


1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913
/*
  Set variable from the result of a field in a query

  This function is useful when checking for a certain value
  in the output from a query that can't be restricted to only
  return some values. A very good example of that is most SHOW
  commands.

  SYNOPSIS
  var_set_query_get_value()

  DESCRIPTION
  let $variable= query_get_value(<query to run>,<column name>,<row no>);

  <query to run> -    The query that should be sent to the server
  <column name> -     Name of the column that holds the field be compared
                      against the expected value
  <row no> -          Number of the row that holds the field to be
                      compared against the expected value

*/

void var_set_query_get_value(struct st_command *command, VAR *var)
{
1914
  long row_no;
1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
  int col_no= -1;
  MYSQL_RES* res;
  MYSQL* mysql= &cur_con->mysql;

  static DYNAMIC_STRING ds_query;
  static DYNAMIC_STRING ds_col;
  static DYNAMIC_STRING ds_row;
  const struct command_arg query_get_value_args[] = {
    "query", ARG_STRING, TRUE, &ds_query, "Query to run",
    "column name", ARG_STRING, TRUE, &ds_col, "Name of column",
    "row number", ARG_STRING, TRUE, &ds_row, "Number for row",
  };

  DBUG_ENTER("var_set_query_get_value");
1929
  LINT_INIT(res);
1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985

  strip_parentheses(command);
  DBUG_PRINT("info", ("query: %s", command->query));
  check_command_args(command, command->first_argument, query_get_value_args,
                     sizeof(query_get_value_args)/sizeof(struct command_arg),
                     ',');

  DBUG_PRINT("info", ("query: %s", ds_query.str));
  DBUG_PRINT("info", ("col: %s", ds_col.str));

  /* Convert row number to int */
  if (!str2int(ds_row.str, 10, (long) 0, (long) INT_MAX, &row_no))
    die("Invalid row number: '%s'", ds_row.str);
  DBUG_PRINT("info", ("row: %s, row_no: %ld", ds_row.str, row_no));
  dynstr_free(&ds_row);

  /* Remove any surrounding "'s from the query - if there is any */
  if (strip_surrounding(ds_query.str, '"', '"'))
    die("Mismatched \"'s around query '%s'", ds_query.str);

  /* Run the query */
  if (mysql_real_query(mysql, ds_query.str, ds_query.length))
    die("Error running query '%s': %d %s", ds_query.str,
	mysql_errno(mysql), mysql_error(mysql));
  if (!(res= mysql_store_result(mysql)))
    die("Query '%s' didn't return a result set", ds_query.str);

  {
    /* Find column number from the given column name */
    uint i;
    uint num_fields= mysql_num_fields(res);
    MYSQL_FIELD *fields= mysql_fetch_fields(res);

    for (i= 0; i < num_fields; i++)
    {
      if (strcmp(fields[i].name, ds_col.str) == 0 &&
          strlen(fields[i].name) == ds_col.length)
      {
        col_no= i;
        break;
      }
    }
    if (col_no == -1)
    {
      mysql_free_result(res);
      die("Could not find column '%s' in the result of '%s'",
          ds_col.str, ds_query.str);
    }
    DBUG_PRINT("info", ("Found column %d with name '%s'",
                        i, fields[i].name));
  }
  dynstr_free(&ds_col);

  {
    /* Get the value */
    MYSQL_ROW row;
1986
    long rows= 0;
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013
    const char* value= "No such row";

    while ((row= mysql_fetch_row(res)))
    {
      if (++rows == row_no)
      {

        DBUG_PRINT("info", ("At row %ld, column %d is '%s'",
                            row_no, col_no, row[col_no]));
        /* Found the row to get */
        if (row[col_no])
          value= row[col_no];
        else
          value= "NULL";

        break;
      }
    }
    eval_expr(var, value, 0);
  }
  dynstr_free(&ds_query);
  mysql_free_result(res);

  DBUG_VOID_RETURN;
}


2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036
void var_copy(VAR *dest, VAR *src)
{
  dest->int_val= src->int_val;
  dest->int_dirty= src->int_dirty;

  /* Alloc/realloc data for str_val in dest */
  if (dest->alloced_len < src->alloced_len &&
      !(dest->str_val= dest->str_val
        ? my_realloc(dest->str_val, src->alloced_len, MYF(MY_WME))
        : my_malloc(src->alloced_len, MYF(MY_WME))))
    die("Out of memory");
  else
    dest->alloced_len= src->alloced_len;

  /* Copy str_val data to dest */
  dest->str_val_len= src->str_val_len;
  if (src->str_val_len)
    memcpy(dest->str_val, src->str_val, src->str_val_len);
}


void eval_expr(VAR *v, const char *p, const char **p_end)
{
2037 2038 2039 2040

  DBUG_ENTER("eval_expr");
  DBUG_PRINT("enter", ("p: '%s'", p));

2041 2042
  if (*p == '$')
  {
2043
    VAR *vp;
2044 2045
    if ((vp= var_get(p, p_end, 0, 0)))
      var_copy(v, vp);
2046
    DBUG_VOID_RETURN;
2047
  }
2048 2049

  if (*p == '`')
2050 2051
  {
    var_query_set(v, p, p_end);
2052
    DBUG_VOID_RETURN;
2053
  }
2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071

  {
    /* Check if this is a "let $var= query_get_value()" */
    const char* get_value_str= "query_get_value";
    const size_t len= strlen(get_value_str);
    if (strncmp(p, get_value_str, len)==0)
    {
      struct st_command command;
      memset(&command, 0, sizeof(command));
      command.query= (char*)p;
      command.first_word_len= len;
      command.first_argument= command.query + len;
      command.end= (char*)*p_end;
      var_set_query_get_value(&command, v);
      DBUG_VOID_RETURN;
    }
  }

2072 2073 2074 2075 2076
  {
    int new_val_len = (p_end && *p_end) ?
      (int) (*p_end - p) : (int) strlen(p);
    if (new_val_len + 1 >= v->alloced_len)
    {
2077
      static int MIN_VAR_ALLOC= 32;
2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
      v->alloced_len = (new_val_len < MIN_VAR_ALLOC - 1) ?
        MIN_VAR_ALLOC : new_val_len + 1;
      if (!(v->str_val =
            v->str_val ? my_realloc(v->str_val, v->alloced_len+1,
                                    MYF(MY_WME)) :
            my_malloc(v->alloced_len+1, MYF(MY_WME))))
        die("Out of memory");
    }
    v->str_val_len = new_val_len;
    memcpy(v->str_val, p, new_val_len);
    v->str_val[new_val_len] = 0;
    v->int_val=atoi(p);
2090
    DBUG_PRINT("info", ("atoi on '%s', returns: %d", p, v->int_val));
2091 2092
    v->int_dirty=0;
  }
2093
  DBUG_VOID_RETURN;
2094 2095
}

2096

2097
int open_file(const char *name)
2098
{
joerg@mysql.com's avatar
joerg@mysql.com committed
2099
  char buff[FN_REFLEN];
2100 2101
  DBUG_ENTER("open_file");
  DBUG_PRINT("enter", ("name: %s", name));
2102 2103 2104 2105 2106
  if (!test_if_hard_path(name))
  {
    strxmov(buff, opt_basedir, name, NullS);
    name=buff;
  }
2107
  fn_format(buff, name, "", "", MY_UNPACK_FILENAME);
2108

2109
  if (cur_file == file_stack_end)
2110
    die("Source directives are nesting too deep");
2111
  cur_file++;
2112 2113 2114
  if (!(cur_file->file = my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(0))))
  {
    cur_file--;
2115
    die("Could not open file %s", buff);
2116 2117
  }
  cur_file->file_name= my_strdup(buff, MYF(MY_FAE));
2118
  cur_file->lineno=1;
2119
  DBUG_RETURN(0);
2120
}
2121

2122 2123

/*
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134
  Source and execute the given file

  SYNOPSIS
  do_source()
  query	called command

  DESCRIPTION
  source <file_name>

  Open the file <file_name> and execute it

2135 2136
*/

2137
void do_source(struct st_command *command)
2138
{
2139
  static DYNAMIC_STRING ds_filename;
2140 2141 2142 2143
  const struct command_arg source_args[] = {
    "filename", ARG_STRING, TRUE, &ds_filename, "File to source"
  };
  DBUG_ENTER("do_source");
2144

2145 2146 2147
  check_command_args(command, command->first_argument, source_args,
                     sizeof(source_args)/sizeof(struct command_arg),
                     ' ');
2148

2149 2150 2151 2152 2153 2154 2155
  /*
    If this file has already been sourced, don't source it again.
    It's already available in the q_lines cache.
  */
  if (parser.current_line < (parser.read_lines - 1))
    ; /* Do nothing */
  else
2156
  {
2157 2158
    DBUG_PRINT("info", ("sourcing file: %s", ds_filename.str));
    open_file(ds_filename.str);
2159
  }
2160 2161 2162

  dynstr_free(&ds_filename);
  return;
2163 2164
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2165

2166 2167 2168
#if defined __WIN__

#ifdef USE_CYGWIN
2169
/* Variables used for temporary sh files used for emulating Unix on Windows */
2170
char tmp_sh_name[64], tmp_sh_cmd[70];
2171
#endif
2172 2173

void init_tmp_sh_file()
2174
{
2175
#ifdef USE_CYGWIN
2176 2177 2178 2179
  /* Format a name for the tmp sh file that is unique for this process */
  my_snprintf(tmp_sh_name, sizeof(tmp_sh_name), "tmp_%d.sh", getpid());
  /* Format the command to execute in order to run the script */
  my_snprintf(tmp_sh_cmd, sizeof(tmp_sh_cmd), "sh %s", tmp_sh_name);
2180
#endif
2181
}
2182

2183

2184
void free_tmp_sh_file()
2185
{
2186
#ifdef USE_CYGWIN
2187
  my_delete(tmp_sh_name, MYF(0));
2188
#endif
2189
}
2190
#endif
2191

2192

2193
FILE* my_popen(DYNAMIC_STRING *ds_cmd, const char *mode)
2194
{
2195
#if defined __WIN__ && defined USE_CYGWIN
2196 2197 2198 2199 2200 2201
  /* Dump the command into a sh script file and execute with popen */
  str_to_file(tmp_sh_name, ds_cmd->str, ds_cmd->length);
  return popen(tmp_sh_cmd, mode);
#else
  return popen(ds_cmd->str, mode);
#endif
2202 2203
}

2204

2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262
static void init_builtin_echo(void)
{
#ifdef __WIN__

  /* Look for "echo.exe" in same dir as mysqltest was started from */
  dirname_part(builtin_echo, my_progname);
  fn_format(builtin_echo, ".\\echo.exe",
            builtin_echo, "", MYF(MY_REPLACE_DIR));

  /* Make sure echo.exe exists */
  if (access(builtin_echo, F_OK) != 0)
    builtin_echo[0]= 0;
  return;

#else

  builtin_echo[0]= 0;
  return;

#endif
}


/*
  Replace a substring

  SYNOPSIS
    replace
    ds_str      The string to search and perform the replace in
    search_str  The string to search for
    search_len  Length of the string to search for
    replace_str The string to replace with
    replace_len Length of the string to replace with

  RETURN
    0 String replaced
    1 Could not find search_str in str
*/

static int replace(DYNAMIC_STRING *ds_str,
                   const char *search_str, ulong search_len,
                   const char *replace_str, ulong replace_len)
{
  DYNAMIC_STRING ds_tmp;
  const char *start= strstr(ds_str->str, search_str);
  if (!start)
    return 1;
  init_dynamic_string(&ds_tmp, "",
                      ds_str->length + replace_len, 256);
  dynstr_append_mem(&ds_tmp, ds_str->str, start - ds_str->str);
  dynstr_append_mem(&ds_tmp, replace_str, replace_len);
  dynstr_append(&ds_tmp, start + search_len);
  dynstr_set(ds_str, ds_tmp.str);
  dynstr_free(&ds_tmp);
  return 0;
}


2263 2264 2265 2266
/*
  Execute given command.

  SYNOPSIS
2267 2268
  do_exec()
  query	called command
2269 2270

  DESCRIPTION
2271
  exec <command>
2272

2273 2274 2275 2276
  Execute the text between exec and end of line in a subprocess.
  The error code returned from the subprocess is checked against the
  expected error array, previously set with the --error command.
  It can thus be used to execute a command that shall fail.
2277

2278 2279 2280
  NOTE
  Although mysqltest is executed from cygwin shell, the command will be
  executed in "cmd.exe". Thus commands like "rm" etc can NOT be used, use
2281
  mysqltest commmand(s) like "remove_file" for that
2282 2283
*/

2284
void do_exec(struct st_command *command)
2285
{
kent@mysql.com's avatar
kent@mysql.com committed
2286
  int error;
2287
  char buf[512];
2288
  FILE *res_file;
2289 2290
  char *cmd= command->first_argument;
  DYNAMIC_STRING ds_cmd;
monty@mysql.com's avatar
monty@mysql.com committed
2291
  DBUG_ENTER("do_exec");
2292
  DBUG_PRINT("enter", ("cmd: '%s'", cmd));
2293

2294
  /* Skip leading space */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2295
  while (*cmd && my_isspace(charset_info, *cmd))
2296 2297
    cmd++;
  if (!*cmd)
2298
    die("Missing argument in exec");
2299 2300 2301 2302
  command->last_argument= command->end;

  init_dynamic_string(&ds_cmd, 0, command->query_len+256, 256);
  /* Eval the command, thus replacing all environment variables */
2303
  do_eval(&ds_cmd, cmd, command->end, !is_windows);
2304

2305 2306 2307 2308 2309 2310 2311
  /* Check if echo should be replaced with "builtin" echo */
  if (builtin_echo[0] && strncmp(cmd, "echo", 4) == 0)
  {
    /* Replace echo with our "builtin" echo */
    replace(&ds_cmd, "echo", 4, builtin_echo, strlen(builtin_echo));
  }

2312
#ifdef __WIN__
2313
#ifndef USE_CYGWIN
2314 2315 2316 2317 2318 2319
  /* Replace /dev/null with NUL */
  while(replace(&ds_cmd, "/dev/null", 9, "NUL", 3) == 0)
    ;
  /* Replace "closed stdout" with non existing output fd */
  while(replace(&ds_cmd, ">&-", 3, ">&4", 3) == 0)
    ;
2320
#endif
2321 2322
#endif

2323
  DBUG_PRINT("info", ("Executing '%s' as '%s'",
2324
                      command->first_argument, ds_cmd.str));
monty@mysql.com's avatar
monty@mysql.com committed
2325

2326 2327
  if (!(res_file= my_popen(&ds_cmd, "r")) && command->abort_on_error)
    die("popen(\"%s\", \"r\") failed", command->first_argument);
monty@mysql.com's avatar
monty@mysql.com committed
2328

2329
  while (fgets(buf, sizeof(buf), res_file))
2330
  {
2331
    if (disable_result_log)
2332 2333 2334 2335
    {
      buf[strlen(buf)-1]=0;
      DBUG_PRINT("exec_result",("%s", buf));
    }
2336
    else
2337
    {
2338
      replace_dynstr_append(&ds_res, buf);
2339
    }
kent@mysql.com's avatar
kent@mysql.com committed
2340 2341
  }
  error= pclose(res_file);
2342
  if (error > 0)
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2343
  {
monty@mishka.local's avatar
monty@mishka.local committed
2344 2345 2346
    uint status= WEXITSTATUS(error), i;
    my_bool ok= 0;

2347
    if (command->abort_on_error)
2348
    {
msvensson@shellback.(none)'s avatar
msvensson@shellback.(none) committed
2349
      log_msg("exec of '%s' failed, error: %d, status: %d, errno: %d",
2350
              ds_cmd.str, error, status, errno);
2351
      die("command \"%s\" failed", command->first_argument);
2352
    }
monty@mishka.local's avatar
monty@mishka.local committed
2353 2354 2355

    DBUG_PRINT("info",
               ("error: %d, status: %d", error, status));
2356
    for (i= 0; i < command->expected_errors.count; i++)
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2357
    {
monty@mishka.local's avatar
monty@mishka.local committed
2358
      DBUG_PRINT("info", ("expected error: %d",
2359 2360 2361
                          command->expected_errors.err[i].code.errnum));
      if ((command->expected_errors.err[i].type == ERR_ERRNO) &&
          (command->expected_errors.err[i].code.errnum == status))
2362
      {
monty@mishka.local's avatar
monty@mishka.local committed
2363
        ok= 1;
2364
        DBUG_PRINT("info", ("command \"%s\" failed with expected error: %d",
2365
                            command->first_argument, status));
2366
      }
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2367
    }
monty@mishka.local's avatar
monty@mishka.local committed
2368
    if (!ok)
2369
      die("command \"%s\" failed with wrong error: %d",
2370
          command->first_argument, status);
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2371
  }
2372 2373
  else if (command->expected_errors.err[0].type == ERR_ERRNO &&
           command->expected_errors.err[0].code.errnum != 0)
msvensson@neptunus.(none)[msvensson]'s avatar
patch  
msvensson@neptunus.(none)[msvensson] committed
2374 2375
  {
    /* Error code we wanted was != 0, i.e. not an expected success */
2376 2377
    log_msg("exec of '%s failed, error: %d, errno: %d",
            ds_cmd.str, error, errno);
2378
    die("command \"%s\" succeeded - should have failed with errno %d...",
2379
        command->first_argument, command->expected_errors.err[0].code.errnum);
2380
  }
2381

2382 2383
  dynstr_free(&ds_cmd);
  DBUG_VOID_RETURN;
2384 2385
}

2386
enum enum_operator
2387
{
2388 2389 2390
  DO_DEC,
  DO_INC
};
2391

2392

2393
/*
2394
  Decrease or increase the value of a variable
2395 2396

  SYNOPSIS
2397 2398 2399
  do_modify_var()
  query	called command
  operator    operation to perform on the var
2400 2401

  DESCRIPTION
2402 2403
  dec $var_name
  inc $var_name
2404

2405 2406
*/

2407
int do_modify_var(struct st_command *command,
2408
                  enum enum_operator operator)
2409
{
2410
  const char *p= command->first_argument;
2411
  VAR* v;
2412
  if (!*p)
2413
    die("Missing argument to %.*s", command->first_word_len, command->query);
2414
  if (*p != '$')
2415 2416
    die("The argument to %.*s must be a variable (start with $)",
        command->first_word_len, command->query);
2417
  v= var_get(p, &p, 1, 0);
2418
  switch (operator) {
2419 2420 2421 2422 2423 2424 2425
  case DO_DEC:
    v->int_val--;
    break;
  case DO_INC:
    v->int_val++;
    break;
  default:
2426
    die("Invalid operator to do_modify_var");
2427 2428 2429
    break;
  }
  v->int_dirty= 1;
2430
  command->last_argument= (char*)++p;
2431 2432 2433
  return 0;
}

2434

2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
/*
  Wrapper for 'system' function

  NOTE
  If mysqltest is executed from cygwin shell, the command will be
  executed in the "windows command interpreter" cmd.exe and we prepend "sh"
  to make it be executed by cygwins "bash". Thus commands like "rm",
  "mkdir" as well as shellscripts can executed by "system" in Windows.

*/

int my_system(DYNAMIC_STRING* ds_cmd)
2447
{
2448
#if defined __WIN__ && defined USE_CYGWIN
2449 2450 2451 2452 2453 2454
  /* Dump the command into a sh script file and execute with system */
  str_to_file(tmp_sh_name, ds_cmd->str, ds_cmd->length);
  return system(tmp_sh_cmd);
#else
  return system(ds_cmd->str);
#endif
2455
}
2456

2457 2458 2459

/*
  SYNOPSIS
2460 2461
  do_system
  command	called command
2462 2463

  DESCRIPTION
2464
  system <command>
2465

2466 2467
  Eval the query to expand any $variables in the command.
  Execute the command with the "system" command.
2468 2469 2470

*/

2471
void do_system(struct st_command *command)
2472
{
2473 2474
  DYNAMIC_STRING ds_cmd;
  DBUG_ENTER("do_system");
2475

2476 2477
  if (strlen(command->first_argument) == 0)
    die("Missing arguments to system, nothing to do!");
2478

2479
  init_dynamic_string(&ds_cmd, 0, command->query_len + 64, 256);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2480

2481
  /* Eval the system command, thus replacing all environment variables */
2482 2483 2484
  do_eval(&ds_cmd, command->first_argument, command->end, !is_windows);

#ifdef __WIN__
2485
#ifndef USE_CYGWIN
2486 2487 2488 2489
   /* Replace /dev/null with NUL */
   while(replace(&ds_cmd, "/dev/null", 9, "NUL", 3) == 0)
     ;
#endif
2490
#endif
2491

2492

2493 2494 2495
  DBUG_PRINT("info", ("running system command '%s' as '%s'",
                      command->first_argument, ds_cmd.str));
  if (my_system(&ds_cmd))
2496
  {
2497 2498
    if (command->abort_on_error)
      die("system command '%s' failed", command->first_argument);
2499

2500 2501 2502 2503
    /* If ! abort_on_error, log message and continue */
    dynstr_append(&ds_res, "system command '");
    replace_dynstr_append(&ds_res, command->first_argument);
    dynstr_append(&ds_res, "' failed\n");
2504
  }
2505

2506 2507 2508 2509
  command->last_argument= command->end;
  dynstr_free(&ds_cmd);
  DBUG_VOID_RETURN;
}
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2510

2511

2512 2513 2514 2515
/*
  SYNOPSIS
  do_remove_file
  command	called command
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2516

2517 2518 2519 2520
  DESCRIPTION
  remove_file <file_name>
  Remove the file <file_name>
*/
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2521

2522 2523 2524
void do_remove_file(struct st_command *command)
{
  int error;
2525
  static DYNAMIC_STRING ds_filename;
2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539
  const struct command_arg rm_args[] = {
    "filename", ARG_STRING, TRUE, &ds_filename, "File to delete"
  };
  DBUG_ENTER("do_remove_file");

  check_command_args(command, command->first_argument,
                     rm_args, sizeof(rm_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("removing file: %s", ds_filename.str));
  error= my_delete(ds_filename.str, MYF(0)) != 0;
  handle_command_error(command, error);
  dynstr_free(&ds_filename);
  DBUG_VOID_RETURN;
2540 2541 2542
}


2543 2544
/*
  SYNOPSIS
2545 2546
  do_copy_file
  command	command handle
2547 2548

  DESCRIPTION
2549 2550
  copy_file <from_file> <to_file>
  Copy <from_file> to <to_file>
2551

2552 2553
  NOTE! Will fail if <to_file> exists
*/
2554

2555
void do_copy_file(struct st_command *command)
2556
{
2557
  int error;
2558 2559
  static DYNAMIC_STRING ds_from_file;
  static DYNAMIC_STRING ds_to_file;
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
  const struct command_arg copy_file_args[] = {
    "from_file", ARG_STRING, TRUE, &ds_from_file, "Filename to copy from",
    "to_file", ARG_STRING, TRUE, &ds_to_file, "Filename to copy to"
  };
  DBUG_ENTER("do_copy_file");

  check_command_args(command, command->first_argument,
                     copy_file_args,
                     sizeof(copy_file_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("Copy %s to %s", ds_from_file.str, ds_to_file.str));
  error= (my_copy(ds_from_file.str, ds_to_file.str,
                  MYF(MY_DONT_OVERWRITE_FILE)) != 0);
  handle_command_error(command, error);
  dynstr_free(&ds_from_file);
  dynstr_free(&ds_to_file);
  DBUG_VOID_RETURN;
2578 2579
}

2580

2581 2582 2583 2584 2585 2586
/*
  SYNOPSIS
  do_chmod_file
  command	command handle

  DESCRIPTION
2587 2588
  chmod_file <octal> <file_name>
  Change file permission of <file_name>
2589 2590 2591 2592 2593

*/

void do_chmod_file(struct st_command *command)
{
2594
  long mode= 0;
2595 2596
  static DYNAMIC_STRING ds_mode;
  static DYNAMIC_STRING ds_file;
2597
  const struct command_arg chmod_file_args[] = {
2598 2599
    "mode", ARG_STRING, TRUE, &ds_mode, "Mode of file(octal) ex. 0660",
    "filename", ARG_STRING, TRUE, &ds_file, "Filename of file to modify"
2600 2601 2602 2603 2604 2605 2606 2607 2608
  };
  DBUG_ENTER("do_chmod_file");

  check_command_args(command, command->first_argument,
                     chmod_file_args,
                     sizeof(chmod_file_args)/sizeof(struct command_arg),
                     ' ');

  /* Parse what mode to set */
2609 2610
  if (ds_mode.length != 4 ||
      str2int(ds_mode.str, 8, 0, INT_MAX, &mode) == NullS)
2611 2612
    die("You must write a 4 digit octal number for mode");

2613
  DBUG_PRINT("info", ("chmod %o %s", (uint)mode, ds_file.str));
2614 2615 2616 2617 2618 2619 2620
  handle_command_error(command, chmod(ds_file.str, mode));
  dynstr_free(&ds_mode);
  dynstr_free(&ds_file);
  DBUG_VOID_RETURN;
}


2621
/*
2622 2623 2624 2625 2626 2627 2628
  SYNOPSIS
  do_file_exists
  command	called command

  DESCRIPTION
  fiile_exist <file_name>
  Check if file <file_name> exists
2629 2630
*/

2631
void do_file_exist(struct st_command *command)
2632
{
2633
  int error;
2634
  static DYNAMIC_STRING ds_filename;
2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
  const struct command_arg file_exist_args[] = {
    "filename", ARG_STRING, TRUE, &ds_filename, "File to check if it exist"
  };
  DBUG_ENTER("do_file_exist");

  check_command_args(command, command->first_argument,
                     file_exist_args,
                     sizeof(file_exist_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("Checking for existence of file: %s", ds_filename.str));
  error= (access(ds_filename.str, F_OK) != 0);
  handle_command_error(command, error);
  dynstr_free(&ds_filename);
  DBUG_VOID_RETURN;
2650 2651
}

2652

2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663
/*
  Read characters from line buffer or file. This is needed to allow
  my_ungetc() to buffer MAX_DELIMITER_LENGTH characters for a file

  NOTE:
  This works as long as one doesn't change files (with 'source file_name')
  when there is things pushed into the buffer.  This should however not
  happen for any tests in the test suite.
*/

int my_getc(FILE *file)
2664
{
2665 2666 2667
  if (line_buffer_pos == line_buffer)
    return fgetc(file);
  return *--line_buffer_pos;
2668 2669
}

2670

2671
void my_ungetc(int c)
2672
{
2673
  *line_buffer_pos++= (char) c;
2674 2675
}

2676

2677 2678
void read_until_delimiter(DYNAMIC_STRING *ds,
                          DYNAMIC_STRING *ds_delimiter)
2679
{
2680
  char c;
2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708
  DBUG_ENTER("read_until_delimiter");
  DBUG_PRINT("enter", ("delimiter: %s, length: %d",
                       ds_delimiter->str, ds_delimiter->length));

  if (ds_delimiter->length > MAX_DELIMITER_LENGTH)
    die("Max delimiter length(%d) exceeded", MAX_DELIMITER_LENGTH);

  /* Read from file until delimiter is found */
  while (1)
  {
    c= my_getc(cur_file->file);

    if (c == '\n')
      cur_file->lineno++;

    if (feof(cur_file->file))
      die("End of file encountered before '%s' delimiter was found",
          ds_delimiter->str);

    if (match_delimiter(c, ds_delimiter->str, ds_delimiter->length))
    {
      DBUG_PRINT("exit", ("Found delimiter '%s'", ds_delimiter->str));
      break;
    }
    dynstr_append_mem(ds, (const char*)&c, 1);
  }
  DBUG_PRINT("exit", ("ds: %s", ds->str));
  DBUG_VOID_RETURN;
2709 2710 2711
}


2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732
void do_write_file_command(struct st_command *command, my_bool append)
{
  static DYNAMIC_STRING ds_content;
  static DYNAMIC_STRING ds_filename;
  static DYNAMIC_STRING ds_delimiter;
  const struct command_arg write_file_args[] = {
    "filename", ARG_STRING, TRUE, &ds_filename, "File to write to",
    "delimiter", ARG_STRING, FALSE, &ds_delimiter, "Delimiter to read until"
  };
  DBUG_ENTER("do_write_file");

  check_command_args(command,
                     command->first_argument,
                     write_file_args,
                     sizeof(write_file_args)/sizeof(struct command_arg),
                     ' ');

  /* If no delimiter was provided, use EOF */
  if (ds_delimiter.length == 0)
    dynstr_set(&ds_delimiter, "EOF");

2733 2734 2735 2736 2737 2738
  if (!append && access(ds_filename.str, F_OK) == 0)
  {
    /* The file should not be overwritten */
    die("File already exist: '%s'", ds_filename.str);
  }

2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749
  init_dynamic_string(&ds_content, "", 1024, 1024);
  read_until_delimiter(&ds_content, &ds_delimiter);
  DBUG_PRINT("info", ("Writing to file: %s", ds_filename.str));
  str_to_file2(ds_filename.str, ds_content.str, ds_content.length, append);
  dynstr_free(&ds_content);
  dynstr_free(&ds_filename);
  dynstr_free(&ds_delimiter);
  DBUG_VOID_RETURN;
}


2750 2751
/*
  SYNOPSIS
2752 2753
  do_write_file
  command	called command
2754 2755

  DESCRIPTION
2756 2757 2758 2759 2760
  write_file <file_name> [<delimiter>];
  <what to write line 1>
  <...>
  < what to write line n>
  EOF
paul@snake-hub.snake.net's avatar
paul@snake-hub.snake.net committed
2761

2762 2763 2764 2765 2766
  --write_file <file_name>;
  <what to write line 1>
  <...>
  < what to write line n>
  EOF
2767

2768 2769
  Write everything between the "write_file" command and 'delimiter'
  to "file_name"
2770

2771
  NOTE! Will fail if <file_name> exists
2772

2773
  Default <delimiter> is EOF
2774

2775
*/
2776

2777
void do_write_file(struct st_command *command)
2778
{
2779 2780
  do_write_file_command(command, FALSE);
}
2781 2782


2783 2784 2785 2786
/*
  SYNOPSIS
  do_append_file
  command	called command
2787

2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810
  DESCRIPTION
  append_file <file_name> [<delimiter>];
  <what to write line 1>
  <...>
  < what to write line n>
  EOF

  --append_file <file_name>;
  <what to write line 1>
  <...>
  < what to write line n>
  EOF

  Append everything between the "append_file" command
  and 'delimiter' to "file_name"

  Default <delimiter> is EOF

*/

void do_append_file(struct st_command *command)
{
  do_write_file_command(command, TRUE);
2811 2812
}

kent@mysql.com's avatar
kent@mysql.com committed
2813

2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841
/*
  SYNOPSIS
  do_cat_file
  command	called command

  DESCRIPTION
  cat_file <file_name>;

  Print the given file to result log

*/

void do_cat_file(struct st_command *command)
{
  static DYNAMIC_STRING ds_filename;
  const struct command_arg cat_file_args[] = {
    "filename", ARG_STRING, TRUE, &ds_filename, "File to read from"
  };
  DBUG_ENTER("do_cat_file");

  check_command_args(command,
                     command->first_argument,
                     cat_file_args,
                     sizeof(cat_file_args)/sizeof(struct command_arg),
                     ' ');

  DBUG_PRINT("info", ("Reading from, file: %s", ds_filename.str));

2842 2843
  cat_file(&ds_res, ds_filename.str);

2844 2845 2846 2847 2848
  dynstr_free(&ds_filename);
  DBUG_VOID_RETURN;
}


2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877
/*
  SYNOPSIS
  do_diff_files
  command	called command

  DESCRIPTION
  diff_files <file1> <file2>;

  Fails if the two files differ.

*/

void do_diff_files(struct st_command *command)
{
  int error= 0;
  static DYNAMIC_STRING ds_filename;
  static DYNAMIC_STRING ds_filename2;
  const struct command_arg diff_file_args[] = {
    "file1", ARG_STRING, TRUE, &ds_filename, "First file to diff",
    "file2", ARG_STRING, TRUE, &ds_filename2, "Second file to diff"
  };
  DBUG_ENTER("do_diff_files");

  check_command_args(command,
                     command->first_argument,
                     diff_file_args,
                     sizeof(diff_file_args)/sizeof(struct command_arg),
                     ' ');

2878
  if ((error= compare_files(ds_filename.str, ds_filename2.str)))
2879
  {
2880 2881 2882 2883
    /* Compare of the two files failed, append them to output
       so the failure can be analyzed
    */
    show_diff(&ds_res, ds_filename.str, ds_filename2.str);
2884 2885 2886 2887 2888 2889 2890 2891
  }

  dynstr_free(&ds_filename);
  dynstr_free(&ds_filename2);
  handle_command_error(command, error);
  DBUG_VOID_RETURN;
}

2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933
  /*
    SYNOPSIS
    do_send_quit
    command	called command

    DESCRIPTION
    Sends a simple quit command to the server for the named connection.

  */

void do_send_quit(struct st_command *command)
{
  char *p= command->first_argument, *name;
  struct st_connection *con;

  DBUG_ENTER("do_send_quit");
  DBUG_PRINT("enter",("name: '%s'",p));

  if (!*p)
    die("Missing connection name in do_send_quit");
  name= p;
  while (*p && !my_isspace(charset_info,*p))
    p++;

  if (*p)
    *p++= 0;
  command->last_argument= p;

  /* Loop through connection pool for connection to close */
  for (con= connections; con < next_con; con++)
  {
    DBUG_PRINT("info", ("con->name: %s", con->name));
    if (!strcmp(con->name, name))
    {
      simple_command(&con->mysql,COM_QUIT,NullS,0,1);
      DBUG_VOID_RETURN;
    }
  }
  die("connection '%s' not found in connection pool", name);
}


2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944
/*
  SYNOPSIS
  do_perl
  command	command handle

  DESCRIPTION
  perl [<delimiter>];
  <perlscript line 1>
  <...>
  <perlscript line n>
  EOF
2945

2946 2947 2948 2949 2950 2951 2952 2953
  Execute everything after "perl" until <delimiter> as perl.
  Useful for doing more advanced things
  but still being able to execute it on all platforms.

  Default <delimiter> is EOF
*/

void do_perl(struct st_command *command)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
2954
{
2955 2956 2957
  int error;
  char buf[FN_REFLEN];
  FILE *res_file;
2958 2959
  static DYNAMIC_STRING ds_script;
  static DYNAMIC_STRING ds_delimiter;
2960 2961 2962 2963
  const struct command_arg perl_args[] = {
    "delimiter", ARG_STRING, FALSE, &ds_delimiter, "Delimiter to read until"
  };
  DBUG_ENTER("do_perl");
2964

2965 2966 2967 2968 2969
  check_command_args(command,
                     command->first_argument,
                     perl_args,
                     sizeof(perl_args)/sizeof(struct command_arg),
                     ' ');
2970

2971 2972 2973
  /* If no delimiter was provided, use EOF */
  if (ds_delimiter.length == 0)
    dynstr_set(&ds_delimiter, "EOF");
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
2974

2975 2976
  init_dynamic_string(&ds_script, "", 1024, 1024);
  read_until_delimiter(&ds_script, &ds_delimiter);
2977

2978
  DBUG_PRINT("info", ("Executing perl: %s", ds_script.str));
2979

2980 2981 2982 2983
  /* Format a name for a tmp .pl file that is unique for this process */
  my_snprintf(buf, sizeof(buf), "%s/tmp/tmp_%d.pl",
              getenv("MYSQLTEST_VARDIR"), getpid());
  str_to_file(buf, ds_script.str, ds_script.length);
2984

2985 2986 2987
  /* Format the perl <filename> command */
  my_snprintf(buf, sizeof(buf), "perl %s/tmp/tmp_%d.pl",
              getenv("MYSQLTEST_VARDIR"), getpid());
2988

2989 2990
  if (!(res_file= popen(buf, "r")) && command->abort_on_error)
    die("popen(\"%s\", \"r\") failed", buf);
2991

2992
  while (fgets(buf, sizeof(buf), res_file))
2993
  {
2994
    if (disable_result_log)
2995
    {
2996 2997
      buf[strlen(buf)-1]=0;
      DBUG_PRINT("exec_result",("%s", buf));
2998 2999
    }
    else
3000
    {
3001
      replace_dynstr_append(&ds_res, buf);
3002 3003
    }
  }
3004 3005 3006 3007 3008
  error= pclose(res_file);
  handle_command_error(command, WEXITSTATUS(error));
  dynstr_free(&ds_script);
  dynstr_free(&ds_delimiter);
  DBUG_VOID_RETURN;
3009 3010 3011 3012
}


/*
3013 3014 3015
  Print the content between echo and <delimiter> to result file.
  Evaluate all variables in the string before printing, allow
  for variable names to be escaped using \
3016

3017 3018 3019
  SYNOPSIS
  do_echo()
  command  called command
3020

3021 3022 3023
  DESCRIPTION
  echo text
  Print the text after echo until end of command to result file
3024

3025 3026
  echo $<var_name>
  Print the content of the variable <var_name> to result file
3027

3028 3029 3030 3031 3032 3033 3034 3035 3036
  echo Some text $<var_name>
  Print "Some text" plus the content of the variable <var_name> to
  result file

  echo Some text \$<var_name>
  Print "Some text" plus $<var_name> to result file
*/

int do_echo(struct st_command *command)
3037
{
3038
  DYNAMIC_STRING ds_echo;
3039
  DBUG_ENTER("do_echo");
3040 3041 3042 3043 3044 3045 3046

  init_dynamic_string(&ds_echo, "", command->query_len, 256);
  do_eval(&ds_echo, command->first_argument, command->end, FALSE);
  dynstr_append_mem(&ds_res, ds_echo.str, ds_echo.length);
  dynstr_append_mem(&ds_res, "\n", 1);
  dynstr_free(&ds_echo);
  command->last_argument= command->end;
3047
  DBUG_RETURN(0);
3048 3049
}

3050

3051
void do_wait_for_slave_to_stop(struct st_command *c __attribute__((unused)))
3052
{
3053 3054 3055
  static int SLAVE_POLL_INTERVAL= 300000;
  MYSQL* mysql = &cur_con->mysql;
  for (;;)
3056
  {
3057 3058 3059 3060 3061 3062 3063 3064 3065 3066
    MYSQL_RES *res;
    MYSQL_ROW row;
    int done;
    LINT_INIT(res);

    if (mysql_query(mysql,"show status like 'Slave_running'") ||
	!(res=mysql_store_result(mysql)))
      die("Query failed while probing slave for stop: %s",
	  mysql_error(mysql));
    if (!(row=mysql_fetch_row(res)) || !row[1])
3067
    {
3068 3069
      mysql_free_result(res);
      die("Strange result from query while probing slave for stop");
3070
    }
3071 3072 3073 3074 3075
    done = !strcmp(row[1],"OFF");
    mysql_free_result(res);
    if (done)
      break;
    my_sleep(SLAVE_POLL_INTERVAL);
3076
  }
3077
  return;
3078 3079
}

3080

3081
void do_sync_with_master2(long offset)
3082
{
3083 3084 3085 3086 3087 3088
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL *mysql= &cur_con->mysql;
  char query_buf[FN_REFLEN+128];
  int tries= 0;
  int rpl_parse;
3089

3090 3091 3092 3093
  if (!master_pos.file[0])
    die("Calling 'sync_with_master' without calling 'save_master_pos'");
  rpl_parse= mysql_rpl_parse_enabled(mysql);
  mysql_disable_rpl_parse(mysql);
3094

3095 3096
  sprintf(query_buf, "select master_pos_wait('%s', %ld)", master_pos.file,
	  master_pos.pos + offset);
3097

3098
wait_for_position:
3099

3100 3101 3102
  if (mysql_query(mysql, query_buf))
    die("failed in '%s': %d: %s", query_buf, mysql_errno(mysql),
        mysql_error(mysql));
3103

3104 3105 3106 3107 3108
  if (!(res= mysql_store_result(mysql)))
    die("mysql_store_result() returned NULL for '%s'", query_buf);
  if (!(row= mysql_fetch_row(res)))
    die("empty result in %s", query_buf);
  if (!row[0])
3109
  {
3110 3111 3112 3113 3114 3115 3116 3117 3118
    /*
      It may be that the slave SQL thread has not started yet, though START
      SLAVE has been issued ?
    */
    if (tries++ == 30)
      die("could not sync with master ('%s' returned NULL)", query_buf);
    sleep(1); /* So at most we will wait 30 seconds and make 31 tries */
    mysql_free_result(res);
    goto wait_for_position;
3119
  }
3120 3121 3122
  mysql_free_result(res);
  if (rpl_parse)
    mysql_enable_rpl_parse(mysql);
3123

3124 3125
  return;
}
3126

3127

3128
void do_sync_with_master(struct st_command *command)
3129
{
3130 3131 3132 3133
  long offset= 0;
  char *p= command->first_argument;
  const char *offset_start= p;
  if (*offset_start)
3134
  {
3135 3136
    for (; my_isdigit(charset_info, *p); p++)
      offset = offset * 10 + *p - '0';
3137

3138 3139 3140 3141 3142 3143
    if(*p && !my_isspace(charset_info, *p))
      die("Invalid integer argument \"%s\"", offset_start);
    command->last_argument= p;
  }
  do_sync_with_master2(offset);
  return;
3144 3145
}

3146 3147 3148 3149 3150 3151

/*
  when ndb binlog is on, this call will wait until last updated epoch
  (locally in the mysqld) has been received into the binlog
*/
int do_save_master_pos()
3152
{
3153 3154 3155 3156 3157
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL *mysql = &cur_con->mysql;
  const char *query;
  int rpl_parse;
3158

3159 3160
  rpl_parse = mysql_rpl_parse_enabled(mysql);
  mysql_disable_rpl_parse(mysql);
3161

3162 3163 3164 3165 3166
#ifdef HAVE_NDB_BINLOG
  /*
    Wait for ndb binlog to be up-to-date with all changes
    done on the local mysql server
  */
3167
  {
3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180
    ulong have_ndbcluster;
    if (mysql_query(mysql, query= "show variables like 'have_ndbcluster'"))
      die("'%s' failed: %d %s", query,
          mysql_errno(mysql), mysql_error(mysql));
    if (!(res= mysql_store_result(mysql)))
      die("mysql_store_result() returned NULL for '%s'", query);
    if (!(row= mysql_fetch_row(res)))
      die("Query '%s' returned empty result", query);

    have_ndbcluster= strcmp("YES", row[1]) == 0;
    mysql_free_result(res);

    if (have_ndbcluster)
3181
    {
3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296
      ulonglong start_epoch= 0, applied_epoch= 0,
	latest_epoch=0, latest_trans_epoch=0,
	latest_handled_binlog_epoch= 0, latest_received_binlog_epoch= 0,
	latest_applied_binlog_epoch= 0;
      int count= 0;
      int do_continue= 1;
      while (do_continue)
      {
        const char binlog[]= "binlog";
	const char latest_epoch_str[]=
          "latest_epoch=";
        const char latest_trans_epoch_str[]=
          "latest_trans_epoch=";
	const char latest_received_binlog_epoch_str[]=
	  "latest_received_binlog_epoch";
        const char latest_handled_binlog_epoch_str[]=
          "latest_handled_binlog_epoch=";
        const char latest_applied_binlog_epoch_str[]=
          "latest_applied_binlog_epoch=";
        if (count)
          sleep(1);
        if (mysql_query(mysql, query= "show engine ndb status"))
          die("failed in '%s': %d %s", query,
              mysql_errno(mysql), mysql_error(mysql));
        if (!(res= mysql_store_result(mysql)))
          die("mysql_store_result() returned NULL for '%s'", query);
        while ((row= mysql_fetch_row(res)))
        {
          if (strcmp(row[1], binlog) == 0)
          {
            const char *status= row[2];

	    /* latest_epoch */
	    while (*status && strncmp(status, latest_epoch_str,
				      sizeof(latest_epoch_str)-1))
	      status++;
	    if (*status)
            {
	      status+= sizeof(latest_epoch_str)-1;
	      latest_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_epoch_str, query);
	    /* latest_trans_epoch */
	    while (*status && strncmp(status, latest_trans_epoch_str,
				      sizeof(latest_trans_epoch_str)-1))
	      status++;
	    if (*status)
	    {
	      status+= sizeof(latest_trans_epoch_str)-1;
	      latest_trans_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_trans_epoch_str, query);
	    /* latest_received_binlog_epoch */
	    while (*status &&
		   strncmp(status, latest_received_binlog_epoch_str,
			   sizeof(latest_received_binlog_epoch_str)-1))
	      status++;
	    if (*status)
	    {
	      status+= sizeof(latest_received_binlog_epoch_str)-1;
	      latest_received_binlog_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_received_binlog_epoch_str, query);
	    /* latest_handled_binlog */
	    while (*status &&
		   strncmp(status, latest_handled_binlog_epoch_str,
			   sizeof(latest_handled_binlog_epoch_str)-1))
	      status++;
	    if (*status)
	    {
	      status+= sizeof(latest_handled_binlog_epoch_str)-1;
	      latest_handled_binlog_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_handled_binlog_epoch_str, query);
	    /* latest_applied_binlog_epoch */
	    while (*status &&
		   strncmp(status, latest_applied_binlog_epoch_str,
			   sizeof(latest_applied_binlog_epoch_str)-1))
	      status++;
	    if (*status)
	    {
	      status+= sizeof(latest_applied_binlog_epoch_str)-1;
	      latest_applied_binlog_epoch= strtoull(status, (char**) 0, 10);
	    }
	    else
	      die("result does not contain '%s' in '%s'",
		  latest_applied_binlog_epoch_str, query);
	    if (count == 0)
	      start_epoch= latest_trans_epoch;
	    break;
	  }
	}
	if (!row)
	  die("result does not contain '%s' in '%s'",
	      binlog, query);
	if (latest_applied_binlog_epoch > applied_epoch)
	  count= 0;
	applied_epoch= latest_applied_binlog_epoch;
	count++;
	if (latest_handled_binlog_epoch >= start_epoch)
          do_continue= 0;
        else if (count > 30)
	{
	  break;
        }
        mysql_free_result(res);
      }
3297 3298
    }
  }
3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315
#endif
  if (mysql_query(mysql, query= "show master status"))
    die("failed in 'show master status': %d %s",
	mysql_errno(mysql), mysql_error(mysql));

  if (!(res = mysql_store_result(mysql)))
    die("mysql_store_result() retuned NULL for '%s'", query);
  if (!(row = mysql_fetch_row(res)))
    die("empty result in show master status");
  strnmov(master_pos.file, row[0], sizeof(master_pos.file)-1);
  master_pos.pos = strtoul(row[1], (char**) 0, 10);
  mysql_free_result(res);

  if (rpl_parse)
    mysql_enable_rpl_parse(mysql);

  return 0;
3316 3317
}

3318

3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338
/*
  Assign the variable <var_name> with <var_val>

  SYNOPSIS
  do_let()
  query	called command

  DESCRIPTION
  let $<var_name>=<var_val><delimiter>

  <var_name>  - is the string string found between the $ and =
  <var_val>   - is the content between the = and <delimiter>, it may span
  multiple line and contain any characters except <delimiter>
  <delimiter> - is a string containing of one or more chars, default is ;

  RETURN VALUES
  Program will die if error detected
*/

void do_let(struct st_command *command)
3339
{
3340 3341 3342 3343
  char *p= command->first_argument;
  char *var_name, *var_name_end;
  DYNAMIC_STRING let_rhs_expr;
  DBUG_ENTER("do_let");
3344

3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360
  init_dynamic_string(&let_rhs_expr, "", 512, 2048);

  /* Find <var_name> */
  if (!*p)
    die("Missing arguments to let");
  var_name= p;
  while (*p && (*p != '=') && !my_isspace(charset_info,*p))
    p++;
  var_name_end= p;
  if (var_name == var_name_end ||
      (var_name+1 == var_name_end && *var_name == '$'))
    die("Missing variable name in let");
  while (my_isspace(charset_info,*p))
    p++;
  if (*p++ != '=')
    die("Missing assignment operator in let");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3361

3362 3363 3364
  /* Find start of <var_val> */
  while (*p && my_isspace(charset_info,*p))
    p++;
3365

3366
  do_eval(&let_rhs_expr, p, command->end, FALSE);
3367

3368 3369 3370 3371 3372 3373
  command->last_argument= command->end;
  /* Assign var_val to var_name */
  var_set(var_name, var_name_end, let_rhs_expr.str,
          (let_rhs_expr.str + let_rhs_expr.length));
  dynstr_free(&let_rhs_expr);
  DBUG_VOID_RETURN;
3374 3375
}

3376

3377
int do_rpl_probe(struct st_command *command __attribute__((unused)))
3378
{
3379 3380 3381 3382 3383
  DBUG_ENTER("do_rpl_probe");
  if (mysql_rpl_probe(&cur_con->mysql))
    die("Failed in mysql_rpl_probe(): '%s'", mysql_error(&cur_con->mysql));
  DBUG_RETURN(0);
}
3384

3385 3386 3387 3388

int do_enable_rpl_parse(struct st_command *command __attribute__((unused)))
{
  mysql_enable_rpl_parse(&cur_con->mysql);
3389 3390 3391
  return 0;
}

3392

3393
int do_disable_rpl_parse(struct st_command *command __attribute__((unused)))
3394
{
3395 3396 3397
  mysql_disable_rpl_parse(&cur_con->mysql);
  return 0;
}
3398 3399


3400 3401
/*
  Sleep the number of specified seconds
3402

3403 3404 3405 3406 3407
  SYNOPSIS
  do_sleep()
  q	       called command
  real_sleep   use the value from opt_sleep as number of seconds to sleep
               if real_sleep is false
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3408

3409 3410 3411
  DESCRIPTION
  sleep <seconds>
  real_sleep <seconds>
3412

3413 3414 3415 3416 3417 3418 3419 3420
  The difference between the sleep and real_sleep commands is that sleep
  uses the delay from the --sleep command-line option if there is one.
  (If the --sleep option is not given, the sleep command uses the delay
  specified by its argument.) The real_sleep command always uses the
  delay specified by its argument.  The logic is that sometimes delays are
  cpu-dependent, and --sleep can be used to set this delay.  real_sleep is
  used for cpu-independent delays.
*/
3421

3422 3423 3424 3425 3426 3427
int do_sleep(struct st_command *command, my_bool real_sleep)
{
  int error= 0;
  char *p= command->first_argument;
  char *sleep_start, *sleep_end= command->end;
  double sleep_val;
3428

3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441
  while (my_isspace(charset_info, *p))
    p++;
  if (!*p)
    die("Missing argument to %.*s", command->first_word_len, command->query);
  sleep_start= p;
  /* Check that arg starts with a digit, not handled by my_strtod */
  if (!my_isdigit(charset_info, *sleep_start))
    die("Invalid argument to %.*s \"%s\"", command->first_word_len,
        command->query,command->first_argument);
  sleep_val= my_strtod(sleep_start, &sleep_end, &error);
  if (error)
    die("Invalid argument to %.*s \"%s\"", command->first_word_len,
        command->query, command->first_argument);
3442

3443 3444 3445 3446 3447 3448 3449 3450
  /* Fixed sleep time selected by --sleep option */
  if (opt_sleep >= 0 && !real_sleep)
    sleep_val= opt_sleep;

  DBUG_PRINT("info", ("sleep_val: %f", sleep_val));
  if (sleep_val)
    my_sleep((ulong) (sleep_val * 1000000L));
  command->last_argument= sleep_end;
3451
  return 0;
3452 3453
}

3454

3455 3456
void do_get_file_name(struct st_command *command,
                      char* dest, uint dest_max_len)
3457
{
3458 3459 3460 3461 3462 3463 3464 3465 3466
  char *p= command->first_argument, *name;
  if (!*p)
    die("Missing file name argument");
  name= p;
  while (*p && !my_isspace(charset_info,*p))
    p++;
  if (*p)
    *p++= 0;
  command->last_argument= p;
3467
  strmake(dest, name, dest_max_len);
3468 3469
}

3470 3471

void do_set_charset(struct st_command *command)
3472
{
3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487
  char *charset_name= command->first_argument;
  char *p;

  if (!charset_name || !*charset_name)
    die("Missing charset name in 'character_set'");
  /* Remove end space */
  p= charset_name;
  while (*p && !my_isspace(charset_info,*p))
    p++;
  if(*p)
    *p++= 0;
  command->last_argument= p;
  charset_info= get_charset_by_csname(charset_name,MY_CS_PRIMARY,MYF(MY_WME));
  if (!charset_info)
    abort_not_supported_test("Test requires charset '%s'", charset_name);
3488 3489 3490
}


3491 3492 3493
#if MYSQL_VERSION_ID >= 50000
/* List of error names to error codes, available from 5.0 */
typedef struct
3494
{
3495
  const char *name;
3496
  uint        code;
3497
} st_error;
3498

3499 3500 3501 3502 3503
static st_error global_error_names[] =
{
#include <mysqld_ername.h>
  { 0, 0 }
};
3504

3505 3506 3507 3508
uint get_errcode_from_name(char *error_name, char *error_end)
{
  /* SQL error as string */
  st_error *e= global_error_names;
3509 3510

  DBUG_ENTER("get_errcode_from_name");
3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
  DBUG_PRINT("enter", ("error_name: %s", error_name));

  /* Loop through the array of known error names */
  for (; e->name; e++)
  {
    /*
      If we get a match, we need to check the length of the name we
      matched against in case it was longer than what we are checking
      (as in ER_WRONG_VALUE vs. ER_WRONG_VALUE_COUNT).
    */
    if (!strncmp(error_name, e->name, (int) (error_end - error_name)) &&
        (uint) strlen(e->name) == (uint) (error_end - error_name))
    {
3524
      DBUG_RETURN(e->code);
3525 3526 3527 3528
    }
  }
  if (!e->name)
    die("Unknown SQL error name '%s'", error_name);
3529 3530
  DBUG_RETURN(0);
}
3531
#else
3532 3533 3534
uint get_errcode_from_name(char *error_name __attribute__((unused)),
                           char *error_end __attribute__((unused)))
{
3535
  abort_not_in_this_version();
3536
  return 0; /* Never reached */
3537
}
3538 3539
#endif

3540 3541


3542 3543 3544 3545 3546
void do_get_errcodes(struct st_command *command)
{
  struct st_match_err *to= saved_expected_errors.err;
  char *p= command->first_argument;
  uint count= 0;
3547

3548
  DBUG_ENTER("do_get_errcodes");
3549

3550 3551
  if (!*p)
    die("Missing argument(s) to 'error'");
3552

3553 3554 3555
  do
  {
    char *end;
3556

3557 3558 3559
    /* Skip leading spaces */
    while (*p && *p == ' ')
      p++;
3560

3561 3562 3563 3564
    /* Find end */
    end= p;
    while (*end && *end != ',' && *end != ' ')
      end++;
3565

3566
    if (*p == 'S')
3567
    {
3568 3569
      char *to_ptr= to->code.sqlstate;

3570 3571 3572 3573 3574 3575
      /*
        SQLSTATE string
        - Must be SQLSTATE_LENGTH long
        - May contain only digits[0-9] and _uppercase_ letters
      */
      p++; /* Step past the S */
3576
      if ((end - p) != SQLSTATE_LENGTH)
3577
        die("The sqlstate must be exactly %d chars long", SQLSTATE_LENGTH);
3578

3579
      /* Check sqlstate string validity */
3580
      while (*p && p < end)
3581
      {
3582 3583 3584 3585 3586
        if (my_isdigit(charset_info, *p) || my_isupper(charset_info, *p))
          *to_ptr++= *p++;
        else
          die("The sqlstate may only consist of digits[0-9] " \
              "and _uppercase_ letters");
3587
      }
3588

3589 3590
      *to_ptr= 0;
      to->type= ERR_SQLSTATE;
3591
      DBUG_PRINT("info", ("ERR_SQLSTATE: %s", to->code.sqlstate));
3592 3593 3594 3595
    }
    else if (*p == 's')
    {
      die("The sqlstate definition must start with an uppercase S");
3596
    }
3597 3598 3599
    else if (*p == 'E')
    {
      /* Error name string */
3600

3601 3602 3603 3604 3605 3606
      DBUG_PRINT("info", ("Error name: %s", p));
      to->code.errnum= get_errcode_from_name(p, end);
      to->type= ERR_ERRNO;
      DBUG_PRINT("info", ("ERR_ERRNO: %d", to->code.errnum));
    }
    else if (*p == 'e')
kent@mysql.com's avatar
kent@mysql.com committed
3607
    {
3608 3609 3610 3611 3612 3613 3614 3615
      die("The error name definition must start with an uppercase E");
    }
    else
    {
      long val;
      char *start= p;
      /* Check that the string passed to str2int only contain digits */
      while (*p && p != end)
kent@mysql.com's avatar
kent@mysql.com committed
3616
      {
3617 3618 3619 3620 3621 3622
        if (!my_isdigit(charset_info, *p))
          die("Invalid argument to error: '%s' - "\
              "the errno may only consist of digits[0-9]",
              command->first_argument);
        p++;
      }
kent@mysql.com's avatar
kent@mysql.com committed
3623

3624 3625 3626
      /* Convert the sting to int */
      if (!str2int(start, 10, (long) INT_MIN, (long) INT_MAX, &val))
	die("Invalid argument to error: '%s'", command->first_argument);
kent@mysql.com's avatar
kent@mysql.com committed
3627

3628 3629 3630
      to->code.errnum= (uint) val;
      to->type= ERR_ERRNO;
      DBUG_PRINT("info", ("ERR_ERRNO: %d", to->code.errnum));
kent@mysql.com's avatar
kent@mysql.com committed
3631
    }
3632 3633
    to++;
    count++;
3634

3635 3636 3637
    if (count >= (sizeof(saved_expected_errors.err) /
                  sizeof(struct st_match_err)))
      die("Too many errorcodes specified");
3638

3639 3640
    /* Set pointer to the end of the last error code */
    p= end;
3641

3642 3643 3644
    /* Find next ',' */
    while (*p && *p != ',')
      p++;
3645

3646 3647
    if (*p)
      p++; /* Step past ',' */
3648

3649
  } while (*p);
3650

3651 3652
  command->last_argument= p;
  to->type= ERR_EMPTY;                        /* End of data */
monty@mysql.com's avatar
monty@mysql.com committed
3653

3654 3655 3656 3657
  DBUG_PRINT("info", ("Expected errors: %d", count));
  saved_expected_errors.count= count;
  DBUG_VOID_RETURN;
}
3658 3659


3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741
/*
  Get a string;  Return ptr to end of string
  Strings may be surrounded by " or '

  If string is a '$variable', return the value of the variable.
*/

char *get_string(char **to_ptr, char **from_ptr,
                 struct st_command *command)
{
  char c, sep;
  char *to= *to_ptr, *from= *from_ptr, *start=to;
  DBUG_ENTER("get_string");

  /* Find separator */
  if (*from == '"' || *from == '\'')
    sep= *from++;
  else
    sep=' ';				/* Separated with space */

  for ( ; (c=*from) ; from++)
  {
    if (c == '\\' && from[1])
    {					/* Escaped character */
      /* We can't translate \0 -> ASCII 0 as replace can't handle ASCII 0 */
      switch (*++from) {
      case 'n':
	*to++= '\n';
	break;
      case 't':
	*to++= '\t';
	break;
      case 'r':
	*to++ = '\r';
	break;
      case 'b':
	*to++ = '\b';
	break;
      case 'Z':				/* ^Z must be escaped on Win32 */
	*to++='\032';
	break;
      default:
	*to++ = *from;
	break;
      }
    }
    else if (c == sep)
    {
      if (c == ' ' || c != *++from)
	break;				/* Found end of string */
      *to++=c;				/* Copy duplicated separator */
    }
    else
      *to++=c;
  }
  if (*from != ' ' && *from)
    die("Wrong string argument in %s", command->query);

  while (my_isspace(charset_info,*from))	/* Point to next string */
    from++;

  *to =0;				/* End of string marker */
  *to_ptr= to+1;			/* Store pointer to end */
  *from_ptr= from;

  /* Check if this was a variable */
  if (*start == '$')
  {
    const char *end= to;
    VAR *var=var_get(start, &end, 0, 1);
    if (var && to == (char*) end+1)
    {
      DBUG_PRINT("info",("var: '%s' -> '%s'", start, var->str_val));
      DBUG_RETURN(var->str_val);	/* return found variable value */
    }
  }
  DBUG_RETURN(start);
}


void set_reconnect(MYSQL* mysql, int val)
{
3742
  my_bool reconnect= val;
3743 3744
  DBUG_ENTER("set_reconnect");
  DBUG_PRINT("info", ("val: %d", val));
3745
#if MYSQL_VERSION_ID < 50000
3746
  mysql->reconnect= reconnect;
3747 3748 3749
#else
  mysql_options(mysql, MYSQL_OPT_RECONNECT, (char *)&reconnect);
#endif
3750
  DBUG_VOID_RETURN;
3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831
}


struct st_connection * find_connection_by_name(const char *name)
{
  struct st_connection *con;
  for (con= connections; con < next_con; con++)
  {
    if (!strcmp(con->name, name))
    {
      return con;
    }
  }
  return 0; /* Connection not found */
}


int select_connection_name(const char *name)
{
  DBUG_ENTER("select_connection2");
  DBUG_PRINT("enter",("name: '%s'", name));

  if (!(cur_con= find_connection_by_name(name)))
    die("connection '%s' not found in connection pool", name);
  DBUG_RETURN(0);
}


int select_connection(struct st_command *command)
{
  char *name;
  char *p= command->first_argument;
  DBUG_ENTER("select_connection");

  if (!*p)
    die("Missing connection name in connect");
  name= p;
  while (*p && !my_isspace(charset_info,*p))
    p++;
  if (*p)
    *p++= 0;
  command->last_argument= p;
  return select_connection_name(name);
}


void do_close_connection(struct st_command *command)
{
  char *p= command->first_argument, *name;
  struct st_connection *con;

  DBUG_ENTER("close_connection");
  DBUG_PRINT("enter",("name: '%s'",p));

  if (!*p)
    die("Missing connection name in disconnect");
  name= p;
  while (*p && !my_isspace(charset_info,*p))
    p++;

  if (*p)
    *p++= 0;
  command->last_argument= p;

  /* Loop through connection pool for connection to close */
  for (con= connections; con < next_con; con++)
  {
    DBUG_PRINT("info", ("con->name: %s", con->name));
    if (!strcmp(con->name, name))
    {
      DBUG_PRINT("info", ("Closing connection %s", con->name));
#ifndef EMBEDDED_LIBRARY
      if (command->type == Q_DIRTY_CLOSE)
      {
	if (con->mysql.net.vio)
	{
	  vio_delete(con->mysql.net.vio);
	  con->mysql.net.vio = 0;
	}
      }
#endif
3832 3833 3834 3835
      if (next_con->stmt)
        mysql_stmt_close(next_con->stmt);
      next_con->stmt= 0;

3836 3837 3838 3839 3840 3841 3842
      mysql_close(&con->mysql);
      if (con->util_mysql)
	mysql_close(con->util_mysql);
      con->util_mysql= 0;
      my_free(con->name, MYF(0));

      /*
3843
        When the connection is closed set name to "-closed_connection-"
3844 3845
        to make it possible to reuse the connection name.
      */
3846
      if (!(con->name = my_strdup("-closed_connection-", MYF(MY_WME))))
3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895
        die("Out of memory");

      DBUG_VOID_RETURN;
    }
  }
  die("connection '%s' not found in connection pool", name);
}


/*
  Connect to a server doing several retries if needed.

  SYNOPSIS
  safe_connect()
  con               - connection structure to be used
  host, user, pass, - connection parameters
  db, port, sock

  NOTE

  Sometimes in a test the client starts before
  the server - to solve the problem, we try again
  after some sleep if connection fails the first
  time

  This function will try to connect to the given server
  "opt_max_connect_retries" times and sleep "connection_retry_sleep"
  seconds between attempts before finally giving up.
  This helps in situation when the client starts
  before the server (which happens sometimes).
  It will only ignore connection errors during these retries.

*/

void safe_connect(MYSQL* mysql, const char *name, const char *host,
                  const char *user, const char *pass, const char *db,
                  int port, const char *sock)
{
  int failed_attempts= 0;
  static ulong connection_retry_sleep= 100000; /* Microseconds */

  DBUG_ENTER("safe_connect");
  while(!mysql_real_connect(mysql, host,user, pass, db, port, sock,
                            CLIENT_MULTI_STATEMENTS | CLIENT_REMEMBER_OPTIONS))
  {
    /*
      Connect failed

      Only allow retry if this was an error indicating the server
3896 3897
      could not be contacted. Error code differs depending
      on protocol/connection type
3898 3899
    */

3900 3901
    if ((mysql_errno(mysql) == CR_CONN_HOST_ERROR ||
         mysql_errno(mysql) == CR_CONNECTION_ERROR) &&
3902
        failed_attempts < opt_max_connect_retries)
3903 3904 3905 3906
    {
      verbose_msg("Connect attempt %d/%d failed: %d: %s", failed_attempts,
                  opt_max_connect_retries, mysql_errno(mysql),
                  mysql_error(mysql));
3907
      my_sleep(connection_retry_sleep);
3908
    }
3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020
    else
    {
      if (failed_attempts > 0)
        die("Could not open connection '%s' after %d attempts: %d %s", name,
            failed_attempts, mysql_errno(mysql), mysql_error(mysql));
      else
        die("Could not open connection '%s': %d %s", name,
            mysql_errno(mysql), mysql_error(mysql));
    }
    failed_attempts++;
  }
  DBUG_VOID_RETURN;
}


/*
  Connect to a server and handle connection errors in case they occur.

  SYNOPSIS
  connect_n_handle_errors()
  q                 - context of connect "query" (command)
  con               - connection structure to be used
  host, user, pass, - connection parameters
  db, port, sock

  DESCRIPTION
  This function will try to establish a connection to server and handle
  possible errors in the same manner as if "connect" was usual SQL-statement
  (If error is expected it will ignore it once it occurs and log the
  "statement" to the query log).
  Unlike safe_connect() it won't do several attempts.

  RETURN VALUES
  1 - Connected
  0 - Not connected

*/

int connect_n_handle_errors(struct st_command *command,
                            MYSQL* con, const char* host,
                            const char* user, const char* pass,
                            const char* db, int port, const char* sock)
{
  DYNAMIC_STRING *ds;

  ds= &ds_res;

  /* Only log if an error is expected */
  if (!command->abort_on_error &&
      !disable_query_log)
  {
    /*
      Log the connect to result log
    */
    dynstr_append_mem(ds, "connect(", 8);
    replace_dynstr_append(ds, host);
    dynstr_append_mem(ds, ",", 1);
    replace_dynstr_append(ds, user);
    dynstr_append_mem(ds, ",", 1);
    replace_dynstr_append(ds, pass);
    dynstr_append_mem(ds, ",", 1);
    if (db)
      replace_dynstr_append(ds, db);
    dynstr_append_mem(ds, ",", 1);
    replace_dynstr_append_uint(ds, port);
    dynstr_append_mem(ds, ",", 1);
    if (sock)
      replace_dynstr_append(ds, sock);
    dynstr_append_mem(ds, ")", 1);
    dynstr_append_mem(ds, delimiter, delimiter_length);
    dynstr_append_mem(ds, "\n", 1);
  }
  if (!mysql_real_connect(con, host, user, pass, db, port, sock ? sock: 0,
                          CLIENT_MULTI_STATEMENTS))
  {
    handle_error(command, mysql_errno(con), mysql_error(con),
		 mysql_sqlstate(con), ds);
    return 0; /* Not connected */
  }

  handle_no_error(command);
  return 1; /* Connected */
}


/*
  Open a new connection to MySQL Server with the parameters
  specified. Make the new connection the current connection.

  SYNOPSIS
  do_connect()
  q	       called command

  DESCRIPTION
  connect(<name>,<host>,<user>,[<pass>,[<db>,[<port>,<sock>[<opts>]]]]);
  connect <name>,<host>,<user>,[<pass>,[<db>,[<port>,<sock>[<opts>]]]];

  <name> - name of the new connection
  <host> - hostname of server
  <user> - user to connect as
  <pass> - password used when connecting
  <db>   - initial db when connected
  <port> - server port
  <sock> - server socket
  <opts> - options to use for the connection
   * SSL - use SSL if available
   * COMPRESS - use compression if available

*/

void do_connect(struct st_command *command)
{
4021
  int con_port= opt_port;
4022 4023
  char *con_options;
  bool con_ssl= 0, con_compress= 0;
4024
  struct st_connection* con_slot;
4025

4026 4027 4028 4029 4030 4031 4032 4033
  static DYNAMIC_STRING ds_connection_name;
  static DYNAMIC_STRING ds_host;
  static DYNAMIC_STRING ds_user;
  static DYNAMIC_STRING ds_password;
  static DYNAMIC_STRING ds_database;
  static DYNAMIC_STRING ds_port;
  static DYNAMIC_STRING ds_sock;
  static DYNAMIC_STRING ds_options;
4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051
  const struct command_arg connect_args[] = {
    "connection name", ARG_STRING, TRUE, &ds_connection_name,
    "Name of the connection",
    "host", ARG_STRING, TRUE, &ds_host, "Host to connect to",
    "user", ARG_STRING, FALSE, &ds_user, "User to connect as",
    "passsword", ARG_STRING, FALSE, &ds_password,
    "Password used when connecting",
    "database", ARG_STRING, FALSE, &ds_database,
    "Dtabase to select after connect",
    "port", ARG_STRING, FALSE, &ds_port, "Port to connect to",
    "socket", ARG_STRING, FALSE, &ds_sock, "Socket to connect with",
    "options", ARG_STRING, FALSE, &ds_options,
    "Options to use while connecting"
  };

  DBUG_ENTER("do_connect");
  DBUG_PRINT("enter",("connect: %s", command->first_argument));

4052
  strip_parentheses(command);
4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090
  check_command_args(command, command->first_argument, connect_args,
                     sizeof(connect_args)/sizeof(struct command_arg),
                     ',');

  /* Port */
  if (ds_port.length)
  {
    con_port= atoi(ds_port.str);
    if (con_port == 0)
      die("Illegal argument for port: '%s'", ds_port.str);
  }

  /* Sock */
  if (ds_sock.length)
  {
    /*
      If the socket is specified just as a name without path
      append tmpdir in front
    */
    if (*ds_sock.str != FN_LIBCHAR)
    {
      char buff[FN_REFLEN];
      fn_format(buff, ds_sock.str, TMPDIR, "", 0);
      dynstr_set(&ds_sock, buff);
    }
  }
  else
  {
    /* No socket specified, use default */
    dynstr_set(&ds_sock, unix_sock);
  }
  DBUG_PRINT("info", ("socket: %s", ds_sock.str));


  /* Options */
  con_options= ds_options.str;
  while (*con_options)
  {
4091 4092 4093 4094 4095 4096
    char* end;
    /* Step past any spaces in beginning of option*/
    while (*con_options && my_isspace(charset_info, *con_options))
     con_options++;
    /* Find end of this option */
    end= con_options;
4097 4098 4099 4100 4101 4102 4103
    while (*end && !my_isspace(charset_info, *end))
      end++;
    if (!strncmp(con_options, "SSL", 3))
      con_ssl= 1;
    else if (!strncmp(con_options, "COMPRESS", 8))
      con_compress= 1;
    else
4104 4105
      die("Illegal option to connect: %.*s", 
          (int) (end - con_options), con_options);
4106 4107 4108 4109 4110 4111
    /* Process next option */
    con_options= end;
  }

  if (find_connection_by_name(ds_connection_name.str))
    die("Connection %s already exists", ds_connection_name.str);
4112 4113 4114 4115
    
  if (next_con != connections_end)
    con_slot= next_con;
  else
4116
  {
4117
    if (!(con_slot= find_connection_by_name("-closed_connection-")))
4118 4119 4120
      die("Connection limit exhausted, you can have max %d connections",
          (int) (sizeof(connections)/sizeof(struct st_connection)));
  }
4121

4122
  if (!mysql_init(&con_slot->mysql))
4123 4124
    die("Failed on mysql_init()");
  if (opt_compress || con_compress)
4125 4126 4127
    mysql_options(&con_slot->mysql, MYSQL_OPT_COMPRESS, NullS);
  mysql_options(&con_slot->mysql, MYSQL_OPT_LOCAL_INFILE, 0);
  mysql_options(&con_slot->mysql, MYSQL_SET_CHARSET_NAME,
4128 4129
                charset_info->csname);
  if (opt_charsets_dir)
4130
    mysql_options(&con_slot->mysql, MYSQL_SET_CHARSET_DIR,
4131
                  opt_charsets_dir);
4132 4133 4134 4135

#ifdef HAVE_OPENSSL
  if (opt_use_ssl || con_ssl)
  {
4136
    mysql_ssl_set(&con_slot->mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
4137 4138 4139
		  opt_ssl_capath, opt_ssl_cipher);
#if MYSQL_VERSION_ID >= 50000
    /* Turn on ssl_verify_server_cert only if host is "localhost" */
4140
    opt_ssl_verify_server_cert= !strcmp(ds_host.str, "localhost");
4141
    mysql_options(&con_slot->mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
4142 4143 4144 4145 4146 4147 4148
                  &opt_ssl_verify_server_cert);
#endif
  }
#endif

  /* Use default db name */
  if (ds_database.length == 0)
4149
    dynstr_set(&ds_database, opt_db);
4150 4151 4152 4153 4154

  /* Special database to allow one to connect without a database name */
  if (ds_database.length && !strcmp(ds_database.str,"*NO-ONE*"))
    dynstr_set(&ds_database, "");

4155
  if (connect_n_handle_errors(command, &con_slot->mysql,
4156 4157 4158 4159 4160 4161
                              ds_host.str,ds_user.str,
                              ds_password.str, ds_database.str,
                              con_port, ds_sock.str))
  {
    DBUG_PRINT("info", ("Inserting connection %s in connection pool",
                        ds_connection_name.str));
4162
    if (!(con_slot->name= my_strdup(ds_connection_name.str, MYF(MY_WME))))
4163
      die("Out of memory");
4164 4165 4166 4167
    cur_con= con_slot;
    
    if (con_slot == next_con)
      next_con++; /* if we used the next_con slot, advance the pointer */
4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387
  }

  dynstr_free(&ds_connection_name);
  dynstr_free(&ds_host);
  dynstr_free(&ds_user);
  dynstr_free(&ds_password);
  dynstr_free(&ds_database);
  dynstr_free(&ds_port);
  dynstr_free(&ds_sock);
  dynstr_free(&ds_options);
  DBUG_VOID_RETURN;
}


int do_done(struct st_command *command)
{
  /* Check if empty block stack */
  if (cur_block == block_stack)
  {
    if (*command->query != '}')
      die("Stray 'end' command - end of block before beginning");
    die("Stray '}' - end of block before beginning");
  }

  /* Test if inner block has been executed */
  if (cur_block->ok && cur_block->cmd == cmd_while)
  {
    /* Pop block from stack, re-execute outer block */
    cur_block--;
    parser.current_line = cur_block->line;
  }
  else
  {
    /* Pop block from stack, goto next line */
    cur_block--;
    parser.current_line++;
  }
  return 0;
}


/*
  Process start of a "if" or "while" statement

  SYNOPSIS
  do_block()
  cmd        Type of block
  q	       called command

  DESCRIPTION
  if ([!]<expr>)
  {
  <block statements>
  }

  while ([!]<expr>)
  {
  <block statements>
  }

  Evaluates the <expr> and if it evaluates to
  greater than zero executes the following code block.
  A '!' can be used before the <expr> to indicate it should
  be executed if it evaluates to zero.

*/

void do_block(enum block_cmd cmd, struct st_command* command)
{
  char *p= command->first_argument;
  const char *expr_start, *expr_end;
  VAR v;
  const char *cmd_name= (cmd == cmd_while ? "while" : "if");
  my_bool not_expr= FALSE;
  DBUG_ENTER("do_block");
  DBUG_PRINT("enter", ("%s", cmd_name));

  /* Check stack overflow */
  if (cur_block == block_stack_end)
    die("Nesting too deeply");

  /* Set way to find outer block again, increase line counter */
  cur_block->line= parser.current_line++;

  /* If this block is ignored */
  if (!cur_block->ok)
  {
    /* Inner block should be ignored too */
    cur_block++;
    cur_block->cmd= cmd;
    cur_block->ok= FALSE;
    DBUG_VOID_RETURN;
  }

  /* Parse and evaluate test expression */
  expr_start= strchr(p, '(');
  if (!expr_start++)
    die("missing '(' in %s", cmd_name);

  /* Check for !<expr> */
  if (*expr_start == '!')
  {
    not_expr= TRUE;
    expr_start++; /* Step past the '!' */
  }
  /* Find ending ')' */
  expr_end= strrchr(expr_start, ')');
  if (!expr_end)
    die("missing ')' in %s", cmd_name);
  p= (char*)expr_end+1;

  while (*p && my_isspace(charset_info, *p))
    p++;
  if (*p && *p != '{')
    die("Missing '{' after %s. Found \"%s\"", cmd_name, p);

  var_init(&v,0,0,0,0);
  eval_expr(&v, expr_start, &expr_end);

  /* Define inner block */
  cur_block++;
  cur_block->cmd= cmd;
  cur_block->ok= (v.int_val ? TRUE : FALSE);

  if (not_expr)
    cur_block->ok = !cur_block->ok;

  DBUG_PRINT("info", ("OK: %d", cur_block->ok));

  var_free(&v);
  DBUG_VOID_RETURN;
}


void do_delimiter(struct st_command* command)
{
  char* p= command->first_argument;
  DBUG_ENTER("do_delimiter");
  DBUG_PRINT("enter", ("first_argument: %s", command->first_argument));

  while (*p && my_isspace(charset_info, *p))
    p++;

  if (!(*p))
    die("Can't set empty delimiter");

  strmake(delimiter, p, sizeof(delimiter) - 1);
  delimiter_length= strlen(delimiter);

  DBUG_PRINT("exit", ("delimiter: %s", delimiter));
  command->last_argument= p + delimiter_length;
  DBUG_VOID_RETURN;
}


my_bool match_delimiter(int c, const char *delim, uint length)
{
  uint i;
  char tmp[MAX_DELIMITER_LENGTH];

  if (c != *delim)
    return 0;

  for (i= 1; i < length &&
	 (c= my_getc(cur_file->file)) == *(delim + i);
       i++)
    tmp[i]= c;

  if (i == length)
    return 1;					/* Found delimiter */

  /* didn't find delimiter, push back things that we read */
  my_ungetc(c);
  while (i > 1)
    my_ungetc(tmp[--i]);
  return 0;
}


my_bool end_of_query(int c)
{
  return match_delimiter(c, delimiter, delimiter_length);
}


/*
  Read one "line" from the file

  SYNOPSIS
  read_line
  buf     buffer for the read line
  size    size of the buffer i.e max size to read

  DESCRIPTION
  This function actually reads several lines and adds them to the
  buffer buf. It continues to read until it finds what it believes
  is a complete query.

  Normally that means it will read lines until it reaches the
  "delimiter" that marks end of query. Default delimiter is ';'
  The function should be smart enough not to detect delimiter's
  found inside strings surrounded with '"' and '\'' escaped strings.

  If the first line in a query starts with '#' or '-' this line is treated
  as a comment. A comment is always terminated when end of line '\n' is
  reached.

*/

int read_line(char *buf, int size)
{
  char c, last_quote;
  char *p= buf, *buf_end= buf + size - 1;
  int skip_char= 0;
  enum {R_NORMAL, R_Q, R_SLASH_IN_Q,
        R_COMMENT, R_LINE_START} state= R_LINE_START;
  DBUG_ENTER("read_line");
  LINT_INIT(last_quote);

  start_lineno= cur_file->lineno;
4388
  DBUG_PRINT("info", ("Starting to read at lineno: %d", start_lineno));
4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411
  for (; p < buf_end ;)
  {
    skip_char= 0;
    c= my_getc(cur_file->file);
    if (feof(cur_file->file))
    {
  found_eof:
      if (cur_file->file != stdin)
      {
	my_fclose(cur_file->file, MYF(0));
        cur_file->file= 0;
      }
      my_free((gptr)cur_file->file_name, MYF(MY_ALLOW_ZERO_PTR));
      cur_file->file_name= 0;
      if (cur_file == file_stack)
      {
        /* We're back at the first file, check if
           all { have matching }
        */
        if (cur_block != block_stack)
          die("Missing end of block");

        *p= 0;
4412
        DBUG_PRINT("info", ("end of file at line %d", cur_file->lineno));
4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434
        DBUG_RETURN(1);
      }
      cur_file--;
      start_lineno= cur_file->lineno;
      continue;
    }

    if (c == '\n')
    {
      /* Line counting is independent of state */
      cur_file->lineno++;

      /* Convert cr/lf to lf */
      if (p != buf && *(p-1) == '\r')
        p--;
    }

    switch(state) {
    case R_NORMAL:
      if (end_of_query(c))
      {
	*p= 0;
4435 4436
        DBUG_PRINT("exit", ("Found delimiter '%s' at line %d",
                            delimiter, cur_file->lineno));
4437 4438 4439
	DBUG_RETURN(0);
      }
      else if ((c == '{' &&
4440 4441 4442 4443
                (!my_strnncoll_simple(charset_info, (const uchar*) "while", 5,
                                      (uchar*) buf, min(5, p - buf), 0) ||
                 !my_strnncoll_simple(charset_info, (const uchar*) "if", 2,
                                      (uchar*) buf, min(2, p - buf), 0))))
4444 4445 4446 4447
      {
        /* Only if and while commands can be terminated by { */
        *p++= c;
	*p= 0;
4448 4449
        DBUG_PRINT("exit", ("Found '{' indicating start of block at line %d",
                            cur_file->lineno));
4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463
	DBUG_RETURN(0);
      }
      else if (c == '\'' || c == '"' || c == '`')
      {
        last_quote= c;
	state= R_Q;
      }
      break;

    case R_COMMENT:
      if (c == '\n')
      {
        /* Comments are terminated by newline */
	*p= 0;
4464 4465
        DBUG_PRINT("exit", ("Found newline in comment at line: %d",
                            cur_file->lineno));
4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479
	DBUG_RETURN(0);
      }
      break;

    case R_LINE_START:
      if (c == '#' || c == '-')
      {
        /* A # or - in the first position of the line - this is a comment */
	state = R_COMMENT;
      }
      else if (my_isspace(charset_info, c))
      {
        /* Skip all space at begining of line */
	if (c == '\n')
4480 4481 4482 4483 4484 4485
        {
          /* Query hasn't started yet */
	  start_lineno= cur_file->lineno;
          DBUG_PRINT("info", ("Query hasn't started yet, start_lineno: %d",
                              start_lineno));
        }
4486 4487 4488 4489 4490
	skip_char= 1;
      }
      else if (end_of_query(c))
      {
	*p= 0;
4491 4492
        DBUG_PRINT("exit", ("Found delimiter '%s' at line: %d",
                            delimiter, cur_file->lineno));
4493 4494 4495 4496 4497 4498 4499
	DBUG_RETURN(0);
      }
      else if (c == '}')
      {
        /* A "}" need to be by itself in the begining of a line to terminate */
        *p++= c;
	*p= 0;
4500 4501
        DBUG_PRINT("exit", ("Found '}' in begining of a line at line: %d",
                            cur_file->lineno));
4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580
	DBUG_RETURN(0);
      }
      else if (c == '\'' || c == '"' || c == '`')
      {
        last_quote= c;
	state= R_Q;
      }
      else
	state= R_NORMAL;
      break;

    case R_Q:
      if (c == last_quote)
	state= R_NORMAL;
      else if (c == '\\')
	state= R_SLASH_IN_Q;
      break;

    case R_SLASH_IN_Q:
      state= R_Q;
      break;

    }

    if (!skip_char)
    {
      /* Could be a multibyte character */
      /* This code is based on the code in "sql_load.cc" */
#ifdef USE_MB
      int charlen = my_mbcharlen(charset_info, c);
      /* We give up if multibyte character is started but not */
      /* completed before we pass buf_end */
      if ((charlen > 1) && (p + charlen) <= buf_end)
      {
	int i;
	char* mb_start = p;

	*p++ = c;

	for (i= 1; i < charlen; i++)
	{
	  if (feof(cur_file->file))
	    goto found_eof;
	  c= my_getc(cur_file->file);
	  *p++ = c;
	}
	if (! my_ismbchar(charset_info, mb_start, p))
	{
	  /* It was not a multiline char, push back the characters */
	  /* We leave first 'c', i.e. pretend it was a normal char */
	  while (p > mb_start)
	    my_ungetc(*--p);
	}
      }
      else
#endif
	*p++= c;
    }
  }
  die("The input buffer is too small for this query.x\n" \
      "check your query or increase MAX_QUERY and recompile");
  DBUG_RETURN(0);
}


/*
  Convert the read query to result format version 1

  That is: After newline, all spaces need to be skipped
  unless the previous char was a quote

  This is due to an old bug that has now been fixed, but the
  version 1 output format is preserved by using this function

*/

void convert_to_format_v1(char* query)
{
  int last_c_was_quote= 0;
4581
  char *p= query, *to= query;
4582 4583 4584 4585 4586 4587 4588
  char *end= strend(query);
  char last_c;

  while (p <= end)
  {
    if (*p == '\n' && !last_c_was_quote)
    {
4589
      *to++ = *p++; /* Save the newline */
4590 4591 4592 4593 4594 4595 4596 4597 4598 4599

      /* Skip any spaces on next line */
      while (*p && my_isspace(charset_info, *p))
        p++;

      last_c_was_quote= 0;
    }
    else if (*p == '\'' || *p == '"' || *p == '`')
    {
      last_c= *p;
4600
      *to++ = *p++;
4601 4602 4603

      /* Copy anything until the next quote of same type */
      while (*p && *p != last_c)
4604
        *to++ = *p++;
4605

4606
      *to++ = *p++;
4607 4608 4609 4610 4611

      last_c_was_quote= 1;
    }
    else
    {
4612
      *to++ = *p++;
4613 4614 4615 4616 4617 4618
      last_c_was_quote= 0;
    }
  }
}


4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662
/*
  Check a command that is about to be sent (or should have been
  sent if parsing was enabled) to mysql server for
  suspicious things and generate warnings.
*/

void scan_command_for_warnings(struct st_command *command)
{
  const char *ptr= command->query;
  DBUG_ENTER("scan_command_for_warnings");
  DBUG_PRINT("enter", ("query: %s", command->query));

  while(*ptr)
  {
    /*
      Look for query's that lines that start with a -- comment
      and has a mysqltest command
    */
    if (ptr[0] == '\n' &&
        ptr[1] && ptr[1] == '-' &&
        ptr[2] && ptr[2] == '-' &&
        ptr[3])
    {
      uint type;
      char save;
      char *end, *start= (char*)ptr+3;
      /* Skip leading spaces */
      while (*start && my_isspace(charset_info, *start))
        start++;
      end= start;
      /* Find end of command(next space) */
      while (*end && !my_isspace(charset_info, *end))
        end++;
      save= *end;
      *end= 0;
      DBUG_PRINT("info", ("Checking '%s'", start));
      type= find_type(start, &command_typelib, 1+2);
      if (type)
        warning_msg("Embedded mysqltest command '--%s' detected in "
                    "query '%s' was this intentional? ",
                    start, command->query);
      *end= save;
    }

4663
    ptr++;
4664 4665 4666 4667
  }
  DBUG_VOID_RETURN;
}

4668 4669
/*
  Check for unexpected "junk" after the end of query
4670 4671
  This is normally caused by missing delimiters or when
  switching between different delimiters
4672 4673
*/

4674
void check_eol_junk_line(const char *line)
4675
{
4676 4677 4678
  const char *p= line;
  DBUG_ENTER("check_eol_junk_line");
  DBUG_PRINT("enter", ("line: %s", line));
4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693

  /* Check for extra delimiter */
  if (*p && !strncmp(p, delimiter, delimiter_length))
    die("Extra delimiter \"%s\" found", delimiter);

  /* Allow trailing # comment */
  if (*p && *p != '#')
  {
    if (*p == '\n')
      die("Missing delimiter");
    die("End of line junk detected: \"%s\"", p);
  }
  DBUG_VOID_RETURN;
}

4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723
void check_eol_junk(const char *eol)
{
  const char *p= eol;
  DBUG_ENTER("check_eol_junk");
  DBUG_PRINT("enter", ("eol: %s", eol));

  /* Skip past all spacing chars and comments */
  while (*p && (my_isspace(charset_info, *p) || *p == '#' || *p == '\n'))
  {
    /* Skip past comments started with # and ended with newline */
    if (*p && *p == '#')
    {
      p++;
      while (*p && *p != '\n')
        p++;
    }

    /* Check this line */
    if (*p && *p == '\n')
      check_eol_junk_line(p);

    if (*p)
      p++;
  }

  check_eol_junk_line(p);

  DBUG_VOID_RETURN;
}

4724 4725 4726 4727 4728 4729


/*
  Create a command from a set of lines

  SYNOPSIS
4730 4731
    read_command()
    command_ptr pointer where to return the new query
4732 4733

  DESCRIPTION
4734 4735
    Converts lines returned by read_line into a command, this involves
    parsing the first word in the read line to find the command type.
4736 4737 4738 4739 4740 4741 4742

  A -- comment may contain a valid query as the first word after the
  comment start. Thus it's always checked to see if that is the case.
  The advantage with this approach is to be able to execute commands
  terminated by new line '\n' regardless how many "delimiter" it contain.
*/

4743
#define MAX_QUERY (256*1024*2) /* 256K -- a test in sp-big is >128K */
4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757
static char read_command_buf[MAX_QUERY];

int read_command(struct st_command** command_ptr)
{
  char *p= read_command_buf;
  struct st_command* command;
  DBUG_ENTER("read_command");

  if (parser.current_line < parser.read_lines)
  {
    get_dynamic(&q_lines, (gptr) command_ptr, parser.current_line) ;
    DBUG_RETURN(0);
  }
  if (!(*command_ptr= command=
4758 4759
        (struct st_command*) my_malloc(sizeof(*command),
                                       MYF(MY_WME|MY_ZEROFILL))) ||
4760
      insert_dynamic(&q_lines, (gptr) &command))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4761
    die(NullS);
4762
  command->type= Q_UNKNOWN;
4763

4764 4765
  read_command_buf[0]= 0;
  if (read_line(read_command_buf, sizeof(read_command_buf)))
monty@mysql.com's avatar
monty@mysql.com committed
4766
  {
4767
    check_eol_junk(read_command_buf);
monty@mysql.com's avatar
monty@mysql.com committed
4768
    DBUG_RETURN(1);
monty@mysql.com's avatar
monty@mysql.com committed
4769
  }
4770 4771 4772 4773

  convert_to_format_v1(read_command_buf);

  DBUG_PRINT("info", ("query: %s", read_command_buf));
4774 4775
  if (*p == '#')
  {
4776
    command->type= Q_COMMENT;
4777
  }
4778
  else if (p[0] == '-' && p[1] == '-')
4779
  {
4780
    command->type= Q_COMMENT_WITH_COMMAND;
4781
    p+= 2; /* Skip past -- */
4782
  }
4783

4784
  /* Skip leading spaces */
4785
  while (*p && my_isspace(charset_info, *p))
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4786
    p++;
4787 4788

  if (!(command->query_buf= command->query= my_strdup(p, MYF(MY_WME))))
4789
    die("Out of memory");
4790 4791

  /* Calculate first word and first argument */
4792 4793
  for (p= command->query; *p && !my_isspace(charset_info, *p) ; p++) ;
  command->first_word_len= (uint) (p - command->query);
4794 4795

  /* Skip spaces between command and first argument */
4796
  while (*p && my_isspace(charset_info, *p))
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4797
    p++;
4798
  command->first_argument= p;
4799

4800 4801
  command->end= strend(command->query);
  command->query_len= (command->end - command->query);
4802
  parser.read_lines++;
monty@mysql.com's avatar
monty@mysql.com committed
4803
  DBUG_RETURN(0);
4804 4805
}

4806 4807 4808

static struct my_option my_long_options[] =
{
4809 4810
  {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,
   0, 0, 0, 0, 0, 0},
4811
  {"basedir", 'b', "Basedir for tests.", (gptr*) &opt_basedir,
4812
   (gptr*) &opt_basedir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4813 4814 4815
  {"character-sets-dir", OPT_CHARSETS_DIR,
   "Directory where character sets are.", (gptr*) &opt_charsets_dir,
   (gptr*) &opt_charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4816
  {"compress", 'C', "Use the compressed server/client protocol.",
4817 4818
   (gptr*) &opt_compress, (gptr*) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
   0, 0, 0},
4819 4820 4821
  {"cursor-protocol", OPT_CURSOR_PROTOCOL, "Use cursors for prepared statements.",
   (gptr*) &cursor_protocol, (gptr*) &cursor_protocol, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4822
  {"database", 'D', "Database to use.", (gptr*) &opt_db, (gptr*) &opt_db, 0,
4823 4824 4825 4826 4827 4828 4829 4830
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#ifdef DBUG_OFF
  {"debug", '#', "This is a non-debug version. Catch this and exit",
   0,0, 0, GET_DISABLED, OPT_ARG, 0, 0, 0, 0, 0, 0},
#else
  {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
4831
  {"host", 'h', "Connect to host.", (gptr*) &opt_host, (gptr*) &opt_host, 0,
4832
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4833 4834
  {"include", 'i', "Include SQL before each test case.", (gptr*) &opt_include,
   (gptr*) &opt_include, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
msvensson@pilot.blaudden's avatar
msvensson@pilot.blaudden committed
4835
  {"logdir", OPT_LOG_DIR, "Directory for log files", (gptr*) &opt_logdir,
4836
   (gptr*) &opt_logdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4837 4838 4839 4840 4841 4842 4843 4844
  {"mark-progress", OPT_MARK_PROGRESS,
   "Write linenumber and elapsed time to <testname>.progress ",
   (gptr*) &opt_mark_progress, (gptr*) &opt_mark_progress, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"max-connect-retries", OPT_MAX_CONNECT_RETRIES,
   "Max number of connection attempts when connecting to server",
   (gptr*) &opt_max_connect_retries, (gptr*) &opt_max_connect_retries, 0,
   GET_INT, REQUIRED_ARG, 500, 1, 10000, 0, 0, 0},
4845 4846
  {"password", 'p', "Password to use when connecting to server.",
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
4847 4848
  {"port", 'P', "Port number to use for connection.", (gptr*) &opt_port,
   (gptr*) &opt_port, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4849 4850 4851
  {"ps-protocol", OPT_PS_PROTOCOL, "Use prepared statements protocol for communication",
   (gptr*) &ps_protocol, (gptr*) &ps_protocol, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4852 4853 4854 4855 4856
  {"quiet", 's', "Suppress all normal output.", (gptr*) &silent,
   (gptr*) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"record", 'r', "Record output of test_file into result file.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"result-file", 'R', "Read/Store result from/in this file.",
4857 4858
   (gptr*) &result_file_name, (gptr*) &result_file_name, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
paul@snake-hub.snake.net's avatar
paul@snake-hub.snake.net committed
4859
  {"server-arg", 'A', "Send option value to embedded server as a parameter.",
4860
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4861
  {"server-file", 'F', "Read embedded server arguments from file.",
4862 4863 4864
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"silent", 's', "Suppress all normal output. Synonym for --quiet.",
   (gptr*) &silent, (gptr*) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4865
  {"skip-safemalloc", OPT_SKIP_SAFEMALLOC,
4866
   "Don't use the memory allocation checking.", 0, 0, 0, GET_NO_ARG, NO_ARG,
4867
   0, 0, 0, 0, 0, 0},
4868
  {"sleep", 'T', "Sleep always this many seconds on sleep commands.",
4869
   (gptr*) &opt_sleep, (gptr*) &opt_sleep, 0, GET_INT, REQUIRED_ARG, -1, 0, 0,
4870 4871 4872 4873
   0, 0, 0},
  {"socket", 'S', "Socket file to use for connection.",
   (gptr*) &unix_sock, (gptr*) &unix_sock, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
   0, 0, 0},
4874 4875 4876
  {"sp-protocol", OPT_SP_PROTOCOL, "Use stored procedures for select",
   (gptr*) &sp_protocol, (gptr*) &sp_protocol, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4877 4878 4879 4880
  {"tail-lines", OPT_TAIL_LINES,
   "Number of lines of the resul to include in a failure report",
   (gptr*) &opt_tail_lines, (gptr*) &opt_tail_lines, 0,
   GET_INT, REQUIRED_ARG, 0, 0, 10000, 0, 0, 0},
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
4881
#include "sslopt-longopts.h"
4882 4883
  {"test-file", 'x', "Read test from/in this file (default stdin).",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
kent@mysql.com's avatar
kent@mysql.com committed
4884 4885
  {"timer-file", 'm', "File where the timing in micro seconds is stored.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4886
  {"tmpdir", 't', "Temporary directory where sockets are put.",
4887
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4888 4889
  {"user", 'u', "User for login.", (gptr*) &opt_user, (gptr*) &opt_user, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4890 4891 4892 4893
  {"verbose", 'v', "Write more.", (gptr*) &verbose, (gptr*) &verbose, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"version", 'V', "Output version information and exit.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
4894 4895 4896
  {"view-protocol", OPT_VIEW_PROTOCOL, "Use views for select",
   (gptr*) &view_protocol, (gptr*) &view_protocol, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4897
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
4898 4899
};

4900 4901 4902

#include <help_start.h>

4903
void print_version(void)
4904 4905 4906 4907 4908
{
  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,MTEST_VERSION,
	 MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
}

4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966
void usage()
{
  print_version();
  printf("MySQL AB, by Sasha, Matt, Monty & Jani\n");
  printf("This software comes with ABSOLUTELY NO WARRANTY\n\n");
  printf("Runs a test against the mysql server and compares output with a results file.\n\n");
  printf("Usage: %s [OPTIONS] [database] < test_file\n", my_progname);
  my_print_help(my_long_options);
  printf("  --no-defaults       Don't read default options from any options file.\n");
  my_print_variables(my_long_options);
}

#include <help_end.h>


/*
  Read arguments for embedded server and put them into
  embedded_server_args[]
*/

void read_embedded_server_arguments(const char *name)
{
  char argument[1024],buff[FN_REFLEN], *str=0;
  FILE *file;

  if (!test_if_hard_path(name))
  {
    strxmov(buff, opt_basedir, name, NullS);
    name=buff;
  }
  fn_format(buff, name, "", "", MY_UNPACK_FILENAME);

  if (!embedded_server_arg_count)
  {
    embedded_server_arg_count=1;
    embedded_server_args[0]= (char*) "";		/* Progname */
  }
  if (!(file=my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
    die("Failed to open file %s", buff);

  while (embedded_server_arg_count < MAX_EMBEDDED_SERVER_ARGS &&
	 (str=fgets(argument,sizeof(argument), file)))
  {
    *(strend(str)-1)=0;				/* Remove end newline */
    if (!(embedded_server_args[embedded_server_arg_count]=
	  (char*) my_strdup(str,MYF(MY_WME))))
    {
      my_fclose(file,MYF(0));
      die("Out of memory");

    }
    embedded_server_arg_count++;
  }
  my_fclose(file,MYF(0));
  if (str)
    die("Too many arguments in option file: %s",name);

  return;
4967 4968
}

4969 4970 4971 4972 4973

static my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
{
4974
  switch(optid) {
4975
  case '#':
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4976
#ifndef DBUG_OFF
4977
    DBUG_PUSH(argument ? argument : "d:t:S:i:O,/tmp/mysqltest.trace");
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4978
#endif
4979 4980 4981 4982 4983
    break;
  case 'r':
    record = 1;
    break;
  case 'x':
4984 4985 4986
  {
    char buff[FN_REFLEN];
    if (!test_if_hard_path(argument))
4987
    {
4988 4989
      strxmov(buff, opt_basedir, argument, NullS);
      argument= buff;
4990
    }
4991 4992 4993 4994 4995 4996 4997 4998 4999
    fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
    DBUG_ASSERT(cur_file == file_stack && cur_file->file == 0);
    if (!(cur_file->file=
          my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(0))))
      die("Could not open %s: errno = %d", buff, errno);
    cur_file->file_name= my_strdup(buff, MYF(MY_FAE));
    cur_file->lineno= 1;
    break;
  }
kent@mysql.com's avatar
kent@mysql.com committed
5000
  case 'm':
5001 5002 5003
  {
    static char buff[FN_REFLEN];
    if (!test_if_hard_path(argument))
kent@mysql.com's avatar
kent@mysql.com committed
5004
    {
5005 5006
      strxmov(buff, opt_basedir, argument, NullS);
      argument= buff;
kent@mysql.com's avatar
kent@mysql.com committed
5007
    }
5008 5009 5010 5011 5012
    fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
    timer_file= buff;
    unlink(timer_file);	     /* Ignore error, may not exist */
    break;
  }
5013 5014 5015
  case 'p':
    if (argument)
    {
5016 5017
      my_free(opt_pass, MYF(MY_ALLOW_ZERO_PTR));
      opt_pass= my_strdup(argument, MYF(MY_FAE));
5018
      while (*argument) *argument++= 'x';		/* Destroy argument */
5019
      tty_password= 0;
5020 5021 5022 5023
    }
    else
      tty_password= 1;
    break;
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
5024
#include <sslopt-case.h>
5025 5026 5027 5028 5029 5030 5031 5032 5033
  case 't':
    strnmov(TMPDIR, argument, sizeof(TMPDIR));
    break;
  case 'A':
    if (!embedded_server_arg_count)
    {
      embedded_server_arg_count=1;
      embedded_server_args[0]= (char*) "";
    }
5034
    if (embedded_server_arg_count == MAX_EMBEDDED_SERVER_ARGS-1 ||
5035 5036
        !(embedded_server_args[embedded_server_arg_count++]=
          my_strdup(argument, MYF(MY_FAE))))
5037 5038 5039 5040 5041
    {
      die("Can't use server argument");
    }
    break;
  case 'F':
5042
    read_embedded_server_arguments(argument);
5043
    break;
5044 5045 5046 5047 5048
  case OPT_SKIP_SAFEMALLOC:
#ifdef SAFEMALLOC
    sf_malloc_quick=1;
#endif
    break;
5049 5050 5051 5052 5053
  case 'V':
    print_version();
    exit(0);
  case '?':
    usage();
5054
    exit(0);
5055 5056 5057 5058 5059
  }
  return 0;
}


5060 5061 5062
int parse_args(int argc, char **argv)
{
  load_defaults("my",load_default_groups,&argc,&argv);
5063
  default_argv= argv;
5064

5065
  if ((handle_options(&argc, &argv, my_long_options, get_one_option)))
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5066
    exit(1);
5067 5068 5069 5070 5071 5072 5073

  if (argc > 1)
  {
    usage();
    exit(1);
  }
  if (argc == 1)
5074
    opt_db= *argv;
5075
  if (tty_password)
5076
    opt_pass= get_tty_password(NullS);          /* purify tested */
5077 5078 5079 5080

  return 0;
}

5081 5082 5083 5084
/*
  Write the content of str into file

  SYNOPSIS
5085
  str_to_file2
5086 5087 5088
  fname - name of file to truncate/create and write to
  str - content to write to file
  size - size of content witten to file
5089
  append - append to file instead of overwriting old file
5090
*/
5091

5092
void str_to_file2(const char *fname, char *str, int size, my_bool append)
5093 5094
{
  int fd;
5095
  char buff[FN_REFLEN];
5096
  int flags= O_WRONLY | O_CREAT;
5097 5098 5099
  if (!test_if_hard_path(fname))
  {
    strxmov(buff, opt_basedir, fname, NullS);
5100
    fname= buff;
5101
  }
5102 5103
  fn_format(buff, fname, "", "", MY_UNPACK_FILENAME);

5104 5105 5106
  if (!append)
    flags|= O_TRUNC;
  if ((fd= my_open(buff, flags,
5107
                   MYF(MY_WME | MY_FFNF))) < 0)
5108
    die("Could not open %s: errno = %d", buff, errno);
5109 5110
  if (append && my_seek(fd, 0, SEEK_END, MYF(0)) == MY_FILEPOS_ERROR)
    die("Could not find end of file %s: errno = %d", buff, errno);
5111
  if (my_write(fd, (byte*)str, size, MYF(MY_WME|MY_FNABP)))
5112 5113 5114 5115
    die("write failed");
  my_close(fd, MYF(0));
}

5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130
/*
  Write the content of str into file

  SYNOPSIS
  str_to_file
  fname - name of file to truncate/create and write to
  str - content to write to file
  size - size of content witten to file
*/

void str_to_file(const char *fname, char *str, int size)
{
  str_to_file2(fname, str, size, FALSE);
}

5131

5132
void dump_result_to_log_file(char *buf, int size)
5133 5134
{
  char log_file[FN_REFLEN];
5135 5136
  str_to_file(fn_format(log_file, result_file_name, opt_logdir, ".log",
                        *opt_logdir ? MY_REPLACE_DIR | MY_REPLACE_EXT :
5137 5138
                        MY_REPLACE_EXT),
              buf, size);
5139 5140
  fprintf(stderr, "\nMore results from queries before failure can be found in %s\n",
          log_file);
5141
}
5142

5143
void dump_progress(void)
5144
{
5145 5146 5147 5148
  char progress_file[FN_REFLEN];
  str_to_file(fn_format(progress_file, result_file_name,
                        opt_logdir, ".progress",
                        *opt_logdir ? MY_REPLACE_DIR | MY_REPLACE_EXT :
5149 5150 5151
                        MY_REPLACE_EXT),
              ds_progress.str, ds_progress.length);
}
5152

5153
void dump_warning_messages(void)
5154 5155 5156
{
  char warn_file[FN_REFLEN];

5157 5158
  str_to_file(fn_format(warn_file, result_file_name, opt_logdir, ".warnings",
                        *opt_logdir ? MY_REPLACE_DIR | MY_REPLACE_EXT :
5159 5160 5161 5162
                        MY_REPLACE_EXT),
              ds_warning_messages.str, ds_warning_messages.length);
}

5163
void check_regerr(my_regex_t* r, int err)
5164
{
5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192
  char err_buf[1024];

  if (err)
  {
    my_regerror(err,r,err_buf,sizeof(err_buf));
    die("Regex error: %s\n", err_buf);
  }
}


#ifdef __WIN__

DYNAMIC_ARRAY patterns;

/*
  init_win_path_patterns

  DESCRIPTION
  Setup string patterns that will be used to detect filenames that
  needs to be converted from Win to Unix format

*/

void init_win_path_patterns()
{
  /* List of string patterns to match in order to find paths */
  const char* paths[] = { "$MYSQL_TEST_DIR",
                          "$MYSQL_TMP_DIR",
5193 5194
                          "$MYSQLTEST_VARDIR",
                          "./test/" };
5195
  int num_paths= sizeof(paths)/sizeof(char*);
5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214
  int i;
  char* p;

  DBUG_ENTER("init_win_path_patterns");

  my_init_dynamic_array(&patterns, sizeof(const char*), 16, 16);

  /* Loop through all paths in the array */
  for (i= 0; i < num_paths; i++)
  {
    VAR* v;
    if (*(paths[i]) == '$')
    {
      v= var_get(paths[i], 0, 0, 0);
      p= my_strdup(v->str_val, MYF(MY_FAE));
    }
    else
      p= my_strdup(paths[i], MYF(MY_FAE));

5215 5216 5217 5218 5219 5220 5221
    /* Don't insert zero length strings in patterns array */
    if (strlen(p) == 0)
    {
      my_free(p, MYF(0));
      continue;
    }

5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270
    if (insert_dynamic(&patterns, (gptr) &p))
      die(NullS);

    DBUG_PRINT("info", ("p: %s", p));
    while (*p)
    {
      if (*p == '/')
        *p='\\';
      p++;
    }
  }
  DBUG_VOID_RETURN;
}

void free_win_path_patterns()
{
  uint i= 0;
  for (i=0 ; i < patterns.elements ; i++)
  {
    const char** pattern= dynamic_element(&patterns, i, const char**);
    my_free((gptr) *pattern, MYF(0));
  }
  delete_dynamic(&patterns);
}

/*
  fix_win_paths

  DESCRIPTION
  Search the string 'val' for the patterns that are known to be
  strings that contain filenames. Convert all \ to / in the
  filenames that are found.

  Ex:
  val = 'Error "c:\mysql\mysql-test\var\test\t1.frm" didn't exist'
  => $MYSQL_TEST_DIR is found by strstr
  => all \ from c:\mysql\m... until next space is converted into /
*/

void fix_win_paths(const char *val, int len)
{
  uint i;
  char *p;

  DBUG_ENTER("fix_win_paths");
  for (i= 0; i < patterns.elements; i++)
  {
    const char** pattern= dynamic_element(&patterns, i, const char**);
    DBUG_PRINT("info", ("pattern: %s", *pattern));
5271

5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334
    /* Search for the path in string */
    while ((p= strstr(val, *pattern)))
    {
      DBUG_PRINT("info", ("Found %s in val p: %s", *pattern, p));

      while (*p && !my_isspace(charset_info, *p))
      {
        if (*p == '\\')
          *p= '/';
        p++;
      }
      DBUG_PRINT("info", ("Converted \\ to /, p: %s", p));
    }
  }
  DBUG_PRINT("exit", (" val: %s, len: %d", val, len));
  DBUG_VOID_RETURN;
}
#endif



/*
  Append the result for one field to the dynamic string ds
*/

void append_field(DYNAMIC_STRING *ds, uint col_idx, MYSQL_FIELD* field,
                  const char* val, ulonglong len, bool is_null)
{
  if (col_idx < max_replace_column && replace_column[col_idx])
  {
    val= replace_column[col_idx];
    len= strlen(val);
  }
  else if (is_null)
  {
    val= "NULL";
    len= 4;
  }
#ifdef __WIN__
  else if ((field->type == MYSQL_TYPE_DOUBLE ||
            field->type == MYSQL_TYPE_FLOAT ) &&
           field->decimals >= 31)
  {
    /* Convert 1.2e+018 to 1.2e+18 and 1.2e-018 to 1.2e-18 */
    char *start= strchr(val, 'e');
    if (start && strlen(start) >= 5 &&
        (start[1] == '-' || start[1] == '+') && start[2] == '0')
    {
      start+=2; /* Now points at first '0' */
      /* Move all chars after the first '0' one step left */
      memmove(start, start + 1, strlen(start));
      len--;
    }
  }
#endif

  if (!display_result_vertically)
  {
    if (col_idx)
      dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_mem(ds, val, (int)len);
  }
  else
5335
  {
5336 5337 5338 5339
    dynstr_append(ds, field->name);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_mem(ds, val, (int)len);
    dynstr_append_mem(ds, "\n", 1);
5340 5341 5342
  }
}

5343

5344 5345
/*
  Append all results to the dynamic string separated with '\t'
5346
  Values may be converted with 'replace_column'
5347 5348
*/

5349
void append_result(DYNAMIC_STRING *ds, MYSQL_RES *res)
5350 5351
{
  MYSQL_ROW row;
5352
  uint num_fields= mysql_num_fields(res);
5353 5354 5355
  MYSQL_FIELD *fields= mysql_fetch_fields(res);
  ulong *lengths;

5356 5357
  while ((row = mysql_fetch_row(res)))
  {
5358
    uint i;
5359 5360
    lengths = mysql_fetch_lengths(res);
    for (i = 0; i < num_fields; i++)
5361 5362
      append_field(ds, i, &fields[i],
                   (const char*)row[i], lengths[i], !row[i]);
5363 5364
    if (!display_result_vertically)
      dynstr_append_mem(ds, "\n", 1);
5365 5366 5367
  }
}

5368

5369
/*
5370 5371
  Append all results from ps execution to the dynamic string separated
  with '\t'. Values may be converted with 'replace_column'
5372
*/
5373

5374 5375
void append_stmt_result(DYNAMIC_STRING *ds, MYSQL_STMT *stmt,
                        MYSQL_FIELD *fields, uint num_fields)
5376
{
5377
  MYSQL_BIND *my_bind;
5378 5379 5380
  my_bool *is_null;
  ulong *length;
  uint i;
5381

5382
  /* Allocate array with bind structs, lengths and NULL flags */
5383
  my_bind= (MYSQL_BIND*) my_malloc(num_fields * sizeof(MYSQL_BIND),
5384 5385 5386 5387 5388
				MYF(MY_WME | MY_FAE | MY_ZEROFILL));
  length= (ulong*) my_malloc(num_fields * sizeof(ulong),
			     MYF(MY_WME | MY_FAE));
  is_null= (my_bool*) my_malloc(num_fields * sizeof(my_bool),
				MYF(MY_WME | MY_FAE));
5389

5390 5391 5392 5393
  /* Allocate data for the result of each field */
  for (i= 0; i < num_fields; i++)
  {
    uint max_length= fields[i].max_length + 1;
5394 5395 5396 5397 5398
    my_bind[i].buffer_type= MYSQL_TYPE_STRING;
    my_bind[i].buffer= (char *)my_malloc(max_length, MYF(MY_WME | MY_FAE));
    my_bind[i].buffer_length= max_length;
    my_bind[i].is_null= &is_null[i];
    my_bind[i].length= &length[i];
5399

5400
    DBUG_PRINT("bind", ("col[%d]: buffer_type: %d, buffer_length: %lu",
5401
			i, my_bind[i].buffer_type, my_bind[i].buffer_length));
5402
  }
5403

5404
  if (mysql_stmt_bind_result(stmt, my_bind))
5405 5406 5407 5408 5409 5410
    die("mysql_stmt_bind_result failed: %d: %s",
	mysql_stmt_errno(stmt), mysql_stmt_error(stmt));

  while (mysql_stmt_fetch(stmt) == 0)
  {
    for (i= 0; i < num_fields; i++)
5411 5412
      append_field(ds, i, &fields[i], (const char *) my_bind[i].buffer,
                   *my_bind[i].length, *my_bind[i].is_null);
5413 5414 5415 5416 5417 5418 5419
    if (!display_result_vertically)
      dynstr_append_mem(ds, "\n", 1);
  }

  if (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
    die("fetch didn't end with MYSQL_NO_DATA from statement: %d %s",
	mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
5420

5421 5422 5423
  for (i= 0; i < num_fields; i++)
  {
    /* Free data for output */
5424
    my_free((gptr)my_bind[i].buffer, MYF(MY_WME | MY_FAE));
5425 5426
  }
  /* Free array with bind structs, lengths and NULL flags */
5427
  my_free((gptr)my_bind    , MYF(MY_WME | MY_FAE));
5428 5429
  my_free((gptr)length  , MYF(MY_WME | MY_FAE));
  my_free((gptr)is_null , MYF(MY_WME | MY_FAE));
5430 5431 5432
}


5433 5434 5435 5436 5437 5438 5439
/*
  Append metadata for fields to output
*/

void append_metadata(DYNAMIC_STRING *ds,
                     MYSQL_FIELD *field,
                     uint num_fields)
5440
{
5441 5442 5443 5444 5445 5446 5447 5448
  MYSQL_FIELD *field_end;
  dynstr_append(ds,"Catalog\tDatabase\tTable\tTable_alias\tColumn\t"
                "Column_alias\tType\tLength\tMax length\tIs_null\t"
                "Flags\tDecimals\tCharsetnr\n");

  for (field_end= field+num_fields ;
       field < field_end ;
       field++)
5449
  {
5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480
    dynstr_append_mem(ds, field->catalog,
                      field->catalog_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->db, field->db_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->org_table,
                      field->org_table_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->table,
                      field->table_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->org_name,
                      field->org_name_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, field->name, field->name_length);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->type);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->length);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->max_length);
    dynstr_append_mem(ds, "\t", 1);
    dynstr_append_mem(ds, (char*) (IS_NOT_NULL(field->flags) ?
                                   "N" : "Y"), 1);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->flags);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->decimals);
    dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append_uint(ds, field->charsetnr);
    dynstr_append_mem(ds, "\n", 1);
5481
  }
5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495
}


/*
  Append affected row count and other info to output
*/

void append_info(DYNAMIC_STRING *ds, ulonglong affected_rows,
                 const char *info)
{
  char buf[40], buff2[21];
  sprintf(buf,"affected rows: %s\n", llstr(affected_rows, buff2));
  dynstr_append(ds, buf);
  if (info)
5496
  {
5497 5498 5499
    dynstr_append(ds, "info: ");
    dynstr_append(ds, info);
    dynstr_append_mem(ds, "\n", 1);
5500
  }
5501 5502
}

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5503

5504 5505 5506 5507 5508 5509 5510 5511 5512 5513
/*
  Display the table headings with the names tab separated
*/

void append_table_headings(DYNAMIC_STRING *ds,
                           MYSQL_FIELD *field,
                           uint num_fields)
{
  uint col_idx;
  for (col_idx= 0; col_idx < num_fields; col_idx++)
5514
  {
5515 5516 5517
    if (col_idx)
      dynstr_append_mem(ds, "\t", 1);
    replace_dynstr_append(ds, field[col_idx].name);
5518
  }
5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533
  dynstr_append_mem(ds, "\n", 1);
}

/*
  Fetch warnings from server and append to ds

  RETURN VALUE
  Number of warnings appended to ds
*/

int append_warnings(DYNAMIC_STRING *ds, MYSQL* mysql)
{
  uint count;
  MYSQL_RES *warn_res;
  DBUG_ENTER("append_warnings");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5534

5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563
  if (!(count= mysql_warning_count(mysql)))
    DBUG_RETURN(0);

  /*
    If one day we will support execution of multi-statements
    through PS API we should not issue SHOW WARNINGS until
    we have not read all results...
  */
  DBUG_ASSERT(!mysql_more_results(mysql));

  if (mysql_real_query(mysql, "SHOW WARNINGS", 13))
    die("Error running query \"SHOW WARNINGS\": %s", mysql_error(mysql));

  if (!(warn_res= mysql_store_result(mysql)))
    die("Warning count is %u but didn't get any warnings",
	count);

  append_result(ds, warn_res);
  mysql_free_result(warn_res);

  DBUG_PRINT("warnings", ("%s", ds->str));

  DBUG_RETURN(count);
}


/*
  Run query using MySQL C API

5564 5565 5566 5567 5568 5569 5570 5571
  SYNOPSIS
    run_query_normal()
    mysql	mysql handle
    command	current command pointer
    flags	flags indicating if we should SEND and/or REAP
    query	query string to execute
    query_len	length query string to execute
    ds		output buffer where to store result form query
5572 5573
*/

holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
5574
void run_query_normal(struct st_connection *cn, struct st_command *command,
5575 5576 5577 5578
                      int flags, char *query, int query_len,
                      DYNAMIC_STRING *ds, DYNAMIC_STRING *ds_warnings)
{
  MYSQL_RES *res= 0;
5579
  MYSQL *mysql= &cn->mysql;
5580 5581 5582 5583 5584 5585
  int err= 0, counter= 0;
  DBUG_ENTER("run_query_normal");
  DBUG_PRINT("enter",("flags: %d", flags));
  DBUG_PRINT("enter", ("query: '%-.60s'", query));

  if (flags & QUERY_SEND_FLAG)
5586
  {
5587 5588 5589
    /*
      Send the query
    */
5590
    if (do_send_query(cn, query, query_len, flags))
5591 5592 5593 5594 5595
    {
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		   mysql_sqlstate(mysql), ds);
      goto end;
    }
5596
  }
5597 5598 5599 5600 5601
#ifdef EMBEDDED_LIBRARY
  /*
   Here we handle 'reap' command, so we need to check if the
   query's thread was finished and probably wait
  */
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
5602
  else if (flags & QUERY_REAP_FLAG)
5603 5604
  {
    pthread_mutex_lock(&cn->mutex);
5605
    while (!cn->query_done)
5606 5607 5608 5609
      pthread_cond_wait(&cn->cond, &cn->mutex);
    pthread_mutex_unlock(&cn->mutex);
  }
#endif /*EMBEDDED_LIBRARY*/
5610 5611 5612
  if (!(flags & QUERY_REAP_FLAG))
    DBUG_VOID_RETURN;

5613
  do
5614
  {
5615 5616 5617 5618 5619
    /*
      When  on first result set, call mysql_read_query_result to retrieve
      answer to the query sent earlier
    */
    if ((counter==0) && mysql_read_query_result(mysql))
5620
    {
5621 5622
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		   mysql_sqlstate(mysql), ds);
5623 5624
      goto end;

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
5625
    }
5626

5627
    /*
5628
      Store the result of the query if it will return any fields
5629
    */
5630
    if (mysql_field_count(mysql) && ((res= mysql_store_result(mysql)) == 0))
5631
    {
5632 5633
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		   mysql_sqlstate(mysql), ds);
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
5634
      goto end;
5635
    }
5636

5637
    if (!disable_result_log)
5638
    {
5639
      ulonglong affected_rows;    /* Ok to be undef if 'disable_info' is set */
monty@mysql.com's avatar
monty@mysql.com committed
5640
      LINT_INIT(affected_rows);
kent@mysql.com's avatar
kent@mysql.com committed
5641

5642
      if (res)
5643
      {
5644
	MYSQL_FIELD *fields= mysql_fetch_fields(res);
5645
	uint num_fields= mysql_num_fields(res);
5646

5647
	if (display_metadata)
5648
          append_metadata(ds, fields, num_fields);
5649

5650
	if (!display_result_vertically)
5651 5652
	  append_table_headings(ds, fields, num_fields);

5653
	append_result(ds, res);
5654
      }
5655

kent@mysql.com's avatar
kent@mysql.com committed
5656
      /*
5657
        Need to call mysql_affected_rows() before the "new"
kent@mysql.com's avatar
kent@mysql.com committed
5658 5659 5660
        query to find the warnings
      */
      if (!disable_info)
5661
        affected_rows= mysql_affected_rows(mysql);
kent@mysql.com's avatar
kent@mysql.com committed
5662

5663 5664 5665 5666 5667 5668
      /*
        Add all warnings to the result. We can't do this if we are in
        the middle of processing results from multi-statement, because
        this will break protocol.
      */
      if (!disable_warnings && !mysql_more_results(mysql))
5669
      {
5670
	if (append_warnings(ds_warnings, mysql) || ds_warnings->length)
5671 5672
	{
	  dynstr_append_mem(ds, "Warnings:\n", 10);
5673
	  dynstr_append_mem(ds, ds_warnings->str, ds_warnings->length);
5674
	}
5675
      }
5676

vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
5677
      if (!disable_info)
5678
	append_info(ds, affected_rows, mysql_info(mysql));
5679
    }
5680

5681
    if (res)
5682
    {
5683
      mysql_free_result(res);
5684 5685
      res= 0;
    }
5686 5687
    counter++;
  } while (!(err= mysql_next_result(mysql)));
5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698
  if (err > 0)
  {
    /* We got an error from mysql_next_result, maybe expected */
    handle_error(command, mysql_errno(mysql), mysql_error(mysql),
		 mysql_sqlstate(mysql), ds);
    goto end;
  }
  DBUG_ASSERT(err == -1); /* Successful and there are no more results */

  /* If we come here the query is both executed and read successfully */
  handle_no_error(command);
5699

5700
end:
5701 5702 5703 5704 5705 5706

  /*
    We save the return code (mysql_errno(mysql)) from the last call sent
    to the server into the mysqltest builtin variable $mysql_errno. This
    variable then can be used from the test case itself.
  */
5707
  var_set_errno(mysql_errno(mysql));
5708
  DBUG_VOID_RETURN;
5709 5710 5711
}


5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738
/*
  Handle errors which occurred during execution

  SYNOPSIS
  handle_error()
  q     - query context
  err_errno - error number
  err_error - error message
  err_sqlstate - sql state
  ds    - dynamic string which is used for output buffer

  NOTE
  If there is an unexpected error this function will abort mysqltest
  immediately.

  RETURN VALUE
  error - function will not return
*/

void handle_error(struct st_command *command,
                  unsigned int err_errno, const char *err_error,
                  const char *err_sqlstate, DYNAMIC_STRING *ds)
{
  uint i;

  DBUG_ENTER("handle_error");

5739
  if (command->require_file[0])
5740 5741 5742 5743 5744 5745 5746 5747
  {
    /*
      The query after a "--require" failed. This is fine as long the server
      returned a valid reponse. Don't allow 2013 or 2006 to trigger an
      abort_not_supported_test
    */
    if (err_errno == CR_SERVER_LOST ||
        err_errno == CR_SERVER_GONE_ERROR)
5748 5749
      die("require query '%s' failed: %d: %s", command->query,
          err_errno, err_error);
5750 5751

    /* Abort the run of this test, pass the failed query as reason */
5752
    abort_not_supported_test("Query '%s' failed, required functionality " \
5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765
                             "not supported", command->query);
  }

  if (command->abort_on_error)
    die("query '%s' failed: %d: %s", command->query, err_errno, err_error);

  DBUG_PRINT("info", ("expected_errors.count: %d",
                      command->expected_errors.count));
  for (i= 0 ; (uint) i < command->expected_errors.count ; i++)
  {
    if (((command->expected_errors.err[i].type == ERR_ERRNO) &&
         (command->expected_errors.err[i].code.errnum == err_errno)) ||
        ((command->expected_errors.err[i].type == ERR_SQLSTATE) &&
5766 5767
         (strncmp(command->expected_errors.err[i].code.sqlstate,
                  err_sqlstate, SQLSTATE_LENGTH) == 0)))
5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791
    {
      if (!disable_result_log)
      {
        if (command->expected_errors.count == 1)
        {
          /* Only log error if there is one possible error */
          dynstr_append_mem(ds, "ERROR ", 6);
          replace_dynstr_append(ds, err_sqlstate);
          dynstr_append_mem(ds, ": ", 2);
          replace_dynstr_append(ds, err_error);
          dynstr_append_mem(ds,"\n",1);
        }
        /* Don't log error if we may not get an error */
        else if (command->expected_errors.err[0].type == ERR_SQLSTATE ||
                 (command->expected_errors.err[0].type == ERR_ERRNO &&
                  command->expected_errors.err[0].code.errnum != 0))
          dynstr_append(ds,"Got one of the listed errors\n");
      }
      /* OK */
      DBUG_VOID_RETURN;
    }
  }

  DBUG_PRINT("info",("i: %d  expected_errors: %d", i,
5792
                     command->expected_errors.count));
5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817

  if (!disable_result_log)
  {
    dynstr_append_mem(ds, "ERROR ",6);
    replace_dynstr_append(ds, err_sqlstate);
    dynstr_append_mem(ds, ": ", 2);
    replace_dynstr_append(ds, err_error);
    dynstr_append_mem(ds, "\n", 1);
  }

  if (i)
  {
    if (command->expected_errors.err[0].type == ERR_ERRNO)
      die("query '%s' failed with wrong errno %d: '%s', instead of %d...",
          command->query, err_errno, err_error,
          command->expected_errors.err[0].code.errnum);
    else
      die("query '%s' failed with wrong sqlstate %s: '%s', instead of %s...",
          command->query, err_sqlstate, err_error,
	  command->expected_errors.err[0].code.sqlstate);
  }

  DBUG_VOID_RETURN;
}

5818 5819

/*
5820 5821 5822 5823 5824 5825 5826 5827
  Handle absence of errors after execution

  SYNOPSIS
  handle_no_error()
  q - context of query

  RETURN VALUE
  error - function will not return
5828 5829
*/

5830
void handle_no_error(struct st_command *command)
5831
{
5832
  DBUG_ENTER("handle_no_error");
5833

5834 5835
  if (command->expected_errors.err[0].type == ERR_ERRNO &&
      command->expected_errors.err[0].code.errnum != 0)
5836
  {
5837 5838 5839
    /* Error code we wanted was != 0, i.e. not an expected success */
    die("query '%s' succeeded - should have failed with errno %d...",
        command->query, command->expected_errors.err[0].code.errnum);
5840
  }
5841 5842
  else if (command->expected_errors.err[0].type == ERR_SQLSTATE &&
           strcmp(command->expected_errors.err[0].code.sqlstate,"00000") != 0)
5843
  {
5844 5845 5846
    /* SQLSTATE we wanted was != "00000", i.e. not an expected success */
    die("query '%s' succeeded - should have failed with sqlstate %s...",
        command->query, command->expected_errors.err[0].code.sqlstate);
5847
  }
5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876

  DBUG_VOID_RETURN;
}


/*
  Run query using prepared statement C API

  SYNPOSIS
  run_query_stmt
  mysql - mysql handle
  command - currrent command pointer
  query - query string to execute
  query_len - length query string to execute
  ds - output buffer where to store result form query

  RETURN VALUE
  error - function will not return
*/

void run_query_stmt(MYSQL *mysql, struct st_command *command,
                    char *query, int query_len, DYNAMIC_STRING *ds,
                    DYNAMIC_STRING *ds_warnings)
{
  MYSQL_RES *res= NULL;     /* Note that here 'res' is meta data result set */
  MYSQL_STMT *stmt;
  DYNAMIC_STRING ds_prepare_warnings;
  DYNAMIC_STRING ds_execute_warnings;
  DBUG_ENTER("run_query_stmt");
5877 5878
  DBUG_PRINT("query", ("'%-.60s'", query));

5879 5880 5881 5882
  /*
    Init a new stmt if it's not already one created for this connection
  */
  if(!(stmt= cur_con->stmt))
5883
  {
5884 5885 5886
    if (!(stmt= mysql_stmt_init(mysql)))
      die("unable to init stmt structure");
    cur_con->stmt= stmt;
5887 5888
  }

5889 5890
  /* Init dynamic strings for warnings */
  if (!disable_warnings)
5891
  {
5892 5893
    init_dynamic_string(&ds_prepare_warnings, NULL, 0, 256);
    init_dynamic_string(&ds_execute_warnings, NULL, 0, 256);
5894 5895 5896
  }

  /*
5897
    Prepare the query
5898
  */
5899
  if (mysql_stmt_prepare(stmt, query, query_len))
5900
  {
5901 5902 5903
    handle_error(command,  mysql_stmt_errno(stmt),
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
    goto end;
5904 5905
  }

5906 5907 5908 5909 5910 5911
  /*
    Get the warnings from mysql_stmt_prepare and keep them in a
    separate string
  */
  if (!disable_warnings)
    append_warnings(&ds_prepare_warnings, mysql);
5912 5913

  /*
5914
    No need to call mysql_stmt_bind_param() because we have no
5915 5916 5917
    parameter markers.
  */

5918 5919
#if MYSQL_VERSION_ID >= 50000
  if (cursor_protocol_enabled)
5920
  {
5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938
    /*
      Use cursor when retrieving result
    */
    ulong type= CURSOR_TYPE_READ_ONLY;
    if (mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type))
      die("mysql_stmt_attr_set(STMT_ATTR_CURSOR_TYPE) failed': %d %s",
          mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
  }
#endif

  /*
    Execute the query
  */
  if (mysql_stmt_execute(stmt))
  {
    handle_error(command, mysql_stmt_errno(stmt),
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
    goto end;
5939 5940
  }

5941 5942 5943 5944 5945 5946 5947
  /*
    When running in cursor_protocol get the warnings from execute here
    and keep them in a separate string for later.
  */
  if (cursor_protocol_enabled && !disable_warnings)
    append_warnings(&ds_execute_warnings, mysql);

5948 5949
  /*
    We instruct that we want to update the "max_length" field in
5950 5951
    mysql_stmt_store_result(), this is our only way to know how much
    buffer to allocate for result data
5952 5953 5954
  */
  {
    my_bool one= 1;
5955 5956 5957
    if (mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &one))
      die("mysql_stmt_attr_set(STMT_ATTR_UPDATE_MAX_LENGTH) failed': %d %s",
          mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
5958 5959 5960 5961 5962
  }

  /*
    If we got here the statement succeeded and was expected to do so,
    get data. Note that this can still give errors found during execution!
5963
    Store the result of the query if if will return any fields
5964
  */
5965
  if (mysql_stmt_field_count(stmt) && mysql_stmt_store_result(stmt))
5966
  {
5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982
    handle_error(command, mysql_stmt_errno(stmt),
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
    goto end;
  }

  /* If we got here the statement was both executed and read successfully */
  handle_no_error(command);
  if (!disable_result_log)
  {
    /*
      Not all statements creates a result set. If there is one we can
      now create another normal result set that contains the meta
      data. This set can be handled almost like any other non prepared
      statement result set.
    */
    if ((res= mysql_stmt_result_metadata(stmt)) != NULL)
5983
    {
5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999
      /* Take the column count from meta info */
      MYSQL_FIELD *fields= mysql_fetch_fields(res);
      uint num_fields= mysql_num_fields(res);

      if (display_metadata)
        append_metadata(ds, fields, num_fields);

      if (!display_result_vertically)
        append_table_headings(ds, fields, num_fields);

      append_stmt_result(ds, stmt, fields, num_fields);

      mysql_free_result(res);     /* Free normal result set with meta data */

      /* Clear prepare warnings */
      dynstr_set(&ds_prepare_warnings, NULL);
6000 6001 6002
    }
    else
    {
6003 6004 6005
      /*
	This is a query without resultset
      */
6006
    }
6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033

    if (!disable_warnings)
    {
      /* Get the warnings from execute */

      /* Append warnings to ds - if there are any */
      if (append_warnings(&ds_execute_warnings, mysql) ||
          ds_execute_warnings.length ||
          ds_prepare_warnings.length ||
          ds_warnings->length)
      {
        dynstr_append_mem(ds, "Warnings:\n", 10);
	if (ds_warnings->length)
	  dynstr_append_mem(ds, ds_warnings->str,
			    ds_warnings->length);
	if (ds_prepare_warnings.length)
	  dynstr_append_mem(ds, ds_prepare_warnings.str,
			    ds_prepare_warnings.length);
	if (ds_execute_warnings.length)
	  dynstr_append_mem(ds, ds_execute_warnings.str,
			    ds_execute_warnings.length);
      }
    }

    if (!disable_info)
      append_info(ds, mysql_affected_rows(mysql), mysql_info(mysql));

6034 6035
  }

6036 6037
end:
  if (!disable_warnings)
6038
  {
6039 6040
    dynstr_free(&ds_prepare_warnings);
    dynstr_free(&ds_execute_warnings);
6041 6042
  }

6043 6044 6045 6046 6047 6048 6049 6050

  /* Close the statement if - no reconnect, need new prepare */
  if (mysql->reconnect)
  {
    mysql_stmt_close(stmt);
    cur_con->stmt= NULL;
  }

6051
  /*
6052 6053 6054
    We save the return code (mysql_stmt_errno(stmt)) from the last call sent
    to the server into the mysqltest builtin variable $mysql_errno. This
    variable then can be used from the test case itself.
6055
  */
6056 6057

  var_set_errno(mysql_stmt_errno(stmt));
6058

6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076
  DBUG_VOID_RETURN;
}



/*
  Create a util connection if one does not already exists
  and use that to run the query
  This is done to avoid implict commit when creating/dropping objects such
  as view, sp etc.
*/

int util_query(MYSQL* org_mysql, const char* query){

  MYSQL* mysql;
  DBUG_ENTER("util_query");

  if(!(mysql= cur_con->util_mysql))
6077
  {
6078 6079 6080
    DBUG_PRINT("info", ("Creating util_mysql"));
    if (!(mysql= mysql_init(mysql)))
      die("Failed in mysql_init()");
6081

6082 6083 6084
    safe_connect(mysql, "util", org_mysql->host, org_mysql->user,
                 org_mysql->passwd, org_mysql->db, org_mysql->port,
                 org_mysql->unix_socket);
6085

6086 6087
    cur_con->util_mysql= mysql;
  }
6088

6089 6090
  return mysql_query(mysql, query);
}
6091 6092 6093



6094 6095
/*
  Run query
6096

6097 6098 6099 6100 6101
  SYNPOSIS
    run_query()
     mysql	mysql handle
     command	currrent command pointer

6102 6103 6104 6105
  flags control the phased/stages of query execution to be performed
  if QUERY_SEND_FLAG bit is on, the query will be sent. If QUERY_REAP_FLAG
  is on the result will be read - for regular query, both bits must be on
*/
6106

holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
6107
void run_query(struct st_connection *cn, struct st_command *command, int flags)
6108
{
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
6109
  MYSQL *mysql= &cn->mysql;
6110
  DYNAMIC_STRING *ds;
6111
  DYNAMIC_STRING *save_ds= NULL;
6112
  DYNAMIC_STRING ds_result;
6113
  DYNAMIC_STRING ds_sorted;
6114 6115 6116 6117 6118 6119 6120
  DYNAMIC_STRING ds_warnings;
  DYNAMIC_STRING eval_query;
  char *query;
  int query_len;
  my_bool view_created= 0, sp_created= 0;
  my_bool complete_query= ((flags & QUERY_SEND_FLAG) &&
                           (flags & QUERY_REAP_FLAG));
6121
  DBUG_ENTER("run_query");
6122

6123
  init_dynamic_string(&ds_warnings, NULL, 0, 256);
6124

6125
  /* Scan for warning before sending to server */
6126 6127
  scan_command_for_warnings(command);

6128 6129 6130 6131
  /*
    Evaluate query if this is an eval command
  */
  if (command->type == Q_EVAL)
6132
  {
6133 6134 6135 6136
    init_dynamic_string(&eval_query, "", command->query_len+256, 1024);
    do_eval(&eval_query, command->query, command->end, FALSE);
    query = eval_query.str;
    query_len = eval_query.length;
6137
  }
6138
  else
6139
  {
6140 6141
    query = command->query;
    query_len = strlen(query);
6142 6143
  }

6144
  /*
6145
    When command->require_file is set the output of _this_ query
6146 6147 6148 6149
    should be compared with an already existing file
    Create a temporary dynamic string to contain the output from
    this query.
  */
6150
  if (command->require_file[0])
6151 6152 6153 6154 6155 6156
  {
    init_dynamic_string(&ds_result, "", 1024, 1024);
    ds= &ds_result;
  }
  else
    ds= &ds_res;
6157

6158 6159 6160 6161 6162 6163 6164 6165 6166
  /*
    Log the query into the output buffer
  */
  if (!disable_query_log && (flags & QUERY_SEND_FLAG))
  {
    replace_dynstr_append_mem(ds, query, query_len);
    dynstr_append_mem(ds, delimiter, delimiter_length);
    dynstr_append_mem(ds, "\n", 1);
  }
6167

6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189
  if (view_protocol_enabled &&
      complete_query &&
      match_re(&view_re, query))
  {
    /*
      Create the query as a view.
      Use replace since view can exist from a failed mysqltest run
    */
    DYNAMIC_STRING query_str;
    init_dynamic_string(&query_str,
			"CREATE OR REPLACE VIEW mysqltest_tmp_v AS ",
			query_len+64, 256);
    dynstr_append_mem(&query_str, query, query_len);
    if (util_query(mysql, query_str.str))
    {
      /*
	Failed to create the view, this is not fatal
	just run the query the normal way
      */
      DBUG_PRINT("view_create_error",
		 ("Failed to create view '%s': %d: %s", query_str.str,
		  mysql_errno(mysql), mysql_error(mysql)));
6190

6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202
      /* Log error to create view */
      verbose_msg("Failed to create view '%s' %d: %s", query_str.str,
		  mysql_errno(mysql), mysql_error(mysql));
    }
    else
    {
      /*
	Yes, it was possible to create this query as a view
      */
      view_created= 1;
      query= (char*)"SELECT * FROM mysqltest_tmp_v";
      query_len = strlen(query);
6203

6204 6205 6206 6207 6208 6209
      /*
        Collect warnings from create of the view that should otherwise
        have been produced when the SELECT was executed
      */
      append_warnings(&ds_warnings, cur_con->util_mysql);
    }
6210

6211
    dynstr_free(&query_str);
6212 6213 6214

  }

6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238
  if (sp_protocol_enabled &&
      complete_query &&
      match_re(&sp_re, query))
  {
    /*
      Create the query as a stored procedure
      Drop first since sp can exist from a failed mysqltest run
    */
    DYNAMIC_STRING query_str;
    init_dynamic_string(&query_str,
			"DROP PROCEDURE IF EXISTS mysqltest_tmp_sp;",
			query_len+64, 256);
    util_query(mysql, query_str.str);
    dynstr_set(&query_str, "CREATE PROCEDURE mysqltest_tmp_sp()\n");
    dynstr_append_mem(&query_str, query, query_len);
    if (util_query(mysql, query_str.str))
    {
      /*
	Failed to create the stored procedure for this query,
	this is not fatal just run the query the normal way
      */
      DBUG_PRINT("sp_create_error",
		 ("Failed to create sp '%s': %d: %s", query_str.str,
		  mysql_errno(mysql), mysql_error(mysql)));
6239

6240 6241 6242
      /* Log error to create sp */
      verbose_msg("Failed to create sp '%s' %d: %s", query_str.str,
		  mysql_errno(mysql), mysql_error(mysql));
6243

6244 6245
    }
    else
6246
    {
6247 6248 6249 6250
      sp_created= 1;

      query= (char*)"CALL mysqltest_tmp_sp()";
      query_len = strlen(query);
6251
    }
6252
    dynstr_free(&query_str);
6253 6254
  }

6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266
  if (display_result_sorted)
  {
    /*
       Collect the query output in a separate string
       that can be sorted before it's added to the
       global result string
    */
    init_dynamic_string(&ds_sorted, "", 1024, 1024);
    save_ds= ds; /* Remember original ds */
    ds= &ds_sorted;
  }

6267 6268 6269 6270 6271
  /*
    Find out how to run this query

    Always run with normal C API if it's not a complete
    SEND + REAP
6272

6273 6274 6275 6276 6277 6278 6279 6280
    If it is a '?' in the query it may be a SQL level prepared
    statement already and we can't do it twice
  */
  if (ps_protocol_enabled &&
      complete_query &&
      match_re(&ps_re, query))
    run_query_stmt(mysql, command, query, query_len, ds, &ds_warnings);
  else
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
6281
    run_query_normal(cn, command, flags, query, query_len,
6282 6283
		     ds, &ds_warnings);

6284 6285 6286 6287 6288 6289 6290 6291
  if (display_result_sorted)
  {
    /* Sort the result set and append it to result */
    dynstr_append_sorted(save_ds, &ds_sorted);
    ds= save_ds;
    dynstr_free(&ds_sorted);
  }

6292
  if (sp_created)
6293
  {
6294 6295
    if (util_query(mysql, "DROP PROCEDURE mysqltest_tmp_sp "))
      die("Failed to drop sp: %d: %s", mysql_errno(mysql), mysql_error(mysql));
6296 6297
  }

6298 6299 6300 6301 6302 6303 6304
  if (view_created)
  {
    if (util_query(mysql, "DROP VIEW mysqltest_tmp_v "))
      die("Failed to drop view: %d: %s",
	  mysql_errno(mysql), mysql_error(mysql));
  }

6305
  if (command->require_file[0])
6306
  {
6307 6308 6309 6310 6311
    /* A result file was specified for _this_ query
       and the output should be checked against an already
       existing file which has been specified using --require or --result
    */
    check_require(ds, command->require_file);
6312 6313
  }

6314 6315 6316 6317 6318
  dynstr_free(&ds_warnings);
  if (ds == &ds_result)
    dynstr_free(&ds_result);
  if (command->type == Q_EVAL)
    dynstr_free(&eval_query);
6319
  DBUG_VOID_RETURN;
6320 6321
}

6322
/****************************************************************************/
6323
/*
6324
  Functions to detect different SQL statements
6325 6326
*/

6327
char *re_eprint(int err)
6328
{
6329 6330 6331 6332 6333 6334
  static char epbuf[100];
  size_t len= my_regerror(REG_ITOA|err, (my_regex_t *)NULL,
			  epbuf, sizeof(epbuf));
  assert(len <= sizeof(epbuf));
  return(epbuf);
}
6335

6336 6337 6338 6339 6340
void init_re_comp(my_regex_t *re, const char* str)
{
  int err= my_regcomp(re, str, (REG_EXTENDED | REG_ICASE | REG_NOSUB),
                      &my_charset_latin1);
  if (err)
6341
  {
6342 6343 6344 6345
    char erbuf[100];
    int len= my_regerror(err, re, erbuf, sizeof(erbuf));
    die("error %s, %d/%d `%s'\n",
	re_eprint(err), len, (int)sizeof(erbuf), erbuf);
6346 6347 6348
  }
}

6349
void init_re(void)
6350
{
6351 6352 6353 6354
  /*
    Filter for queries that can be run using the
    MySQL Prepared Statements C API
  */
6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368
  const char *ps_re_str =
    "^("
    "[[:space:]]*REPLACE[[:space:]]|"
    "[[:space:]]*INSERT[[:space:]]|"
    "[[:space:]]*UPDATE[[:space:]]|"
    "[[:space:]]*DELETE[[:space:]]|"
    "[[:space:]]*SELECT[[:space:]]|"
    "[[:space:]]*CREATE[[:space:]]+TABLE[[:space:]]|"
    "[[:space:]]*DO[[:space:]]|"
    "[[:space:]]*SET[[:space:]]+OPTION[[:space:]]|"
    "[[:space:]]*DELETE[[:space:]]+MULTI[[:space:]]|"
    "[[:space:]]*UPDATE[[:space:]]+MULTI[[:space:]]|"
    "[[:space:]]*INSERT[[:space:]]+SELECT[[:space:]])";

6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384
  /*
    Filter for queries that can be run using the
    Stored procedures
  */
  const char *sp_re_str =ps_re_str;

  /*
    Filter for queries that can be run as views
  */
  const char *view_re_str =
    "^("
    "[[:space:]]*SELECT[[:space:]])";

  init_re_comp(&ps_re, ps_re_str);
  init_re_comp(&sp_re, sp_re_str);
  init_re_comp(&view_re, view_re_str);
6385 6386 6387
}


6388
int match_re(my_regex_t *re, char *str)
6389
{
6390
  int err= my_regexec(re, str, (size_t)0, NULL, 0);
6391 6392 6393 6394 6395

  if (err == 0)
    return 1;
  else if (err == REG_NOMATCH)
    return 0;
6396

6397 6398
  {
    char erbuf[100];
6399 6400 6401
    int len= my_regerror(err, re, erbuf, sizeof(erbuf));
    die("error %s, %d/%d `%s'\n",
	re_eprint(err), len, (int)sizeof(erbuf), erbuf);
6402
  }
6403
  return 0;
6404 6405
}

6406
void free_re(void)
6407
{
kent@mysql.com's avatar
kent@mysql.com committed
6408
  my_regfree(&ps_re);
6409 6410 6411
  my_regfree(&sp_re);
  my_regfree(&view_re);
  my_regex_end();
6412 6413 6414 6415
}

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

6416
void get_command_type(struct st_command* command)
6417
{
6418 6419
  char save;
  uint type;
6420
  DBUG_ENTER("get_command_type");
monty@mysql.com's avatar
monty@mysql.com committed
6421

6422
  if (*command->query == '}')
6423
  {
6424
    command->type = Q_END_BLOCK;
monty@mysql.com's avatar
monty@mysql.com committed
6425
    DBUG_VOID_RETURN;
6426 6427
  }

6428 6429 6430 6431
  save= command->query[command->first_word_len];
  command->query[command->first_word_len]= 0;
  type= find_type(command->query, &command_typelib, 1+2);
  command->query[command->first_word_len]= save;
6432
  if (type > 0)
6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445
  {
    command->type=(enum enum_commands) type;		/* Found command */

    /*
      Look for case where "query" was explicitly specified to
      force command being sent to server
    */
    if (type == Q_QUERY)
    {
      /* Skip the "query" part */
      command->query= command->first_argument;
    }
  }
6446
  else
6447
  {
6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479
    /* No mysqltest command matched */

    if (command->type != Q_COMMENT_WITH_COMMAND)
    {
      /* A query that will sent to mysqld */
      command->type= Q_QUERY;
    }
    else
    {
      /* -- comment that didn't contain a mysqltest command */
      command->type= Q_COMMENT;
      warning_msg("Suspicious command '--%s' detected, was this intentional? "\
                  "Use # instead of -- to avoid this warning",
                  command->query);

      if (command->first_word_len &&
          strcmp(command->query + command->first_word_len - 1, delimiter) == 0)
      {
        /*
          Detect comment with command using extra delimiter
          Ex --disable_query_log;
          ^ Extra delimiter causing the command
          to be skipped
        */
        save= command->query[command->first_word_len-1];
        command->query[command->first_word_len-1]= 0;
        if (find_type(command->query, &command_typelib, 1+2) > 0)
          die("Extra delimiter \";\" found");
        command->query[command->first_word_len-1]= save;

      }
    }
6480
  }
6481 6482 6483 6484 6485 6486 6487 6488 6489

  /* Set expected error on command */
  memcpy(&command->expected_errors, &saved_expected_errors,
         sizeof(saved_expected_errors));
  DBUG_PRINT("info", ("There are %d expected errors",
                      command->expected_errors.count));
  command->abort_on_error= (command->expected_errors.count == 0 &&
                            abort_on_error);

monty@mysql.com's avatar
monty@mysql.com committed
6490
  DBUG_VOID_RETURN;
6491
}
6492

monty@mysql.com's avatar
monty@mysql.com committed
6493

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6494

6495 6496 6497
/*
  Record how many milliseconds it took to execute the test file
  up until the current line and save it in the dynamic string ds_progress.
6498

6499 6500
  The ds_progress will be dumped to <test_name>.progress when
  test run completes
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6501

6502
*/
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
6503

6504 6505
void mark_progress(struct st_command* command __attribute__((unused)),
                   int line)
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
6506
{
6507 6508 6509 6510 6511
  char buf[32], *end;
  ulonglong timer= timer_now();
  if (!progress_start)
    progress_start= timer;
  timer-= progress_start;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
6512

6513 6514 6515 6516
  /* Milliseconds since start */
  end= longlong2str(timer, buf, 10);
  dynstr_append_mem(&ds_progress, buf, (int)(end-buf));
  dynstr_append_mem(&ds_progress, "\t", 1);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
6517

6518 6519 6520 6521
  /* Parser line number */
  end= int10_to_str(line, buf, 10);
  dynstr_append_mem(&ds_progress, buf, (int)(end-buf));
  dynstr_append_mem(&ds_progress, "\t", 1);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6522

6523 6524 6525
  /* Filename */
  dynstr_append(&ds_progress, cur_file->file_name);
  dynstr_append_mem(&ds_progress, ":", 1);
6526

6527 6528 6529 6530 6531 6532
  /* Line in file */
  end= int10_to_str(cur_file->lineno, buf, 10);
  dynstr_append_mem(&ds_progress, buf, (int)(end-buf));


  dynstr_append_mem(&ds_progress, "\n", 1);
6533

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
6534
}
6535

6536

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6537
int main(int argc, char **argv)
6538
{
6539
  struct st_command *command;
6540
  my_bool q_send_flag= 0, abort_flag= 0;
6541
  uint command_executed= 0, last_command_executed= 0;
6542
  char save_file[FN_REFLEN];
6543
  MY_STAT res_info;
6544 6545
  MY_INIT(argv[0]);

6546 6547 6548
  save_file[0]= 0;
  TMPDIR[0]= 0;

6549 6550 6551
  /* Init expected errors */
  memset(&saved_expected_errors, 0, sizeof(saved_expected_errors));

6552 6553 6554 6555 6556 6557
  /* Init connections */
  memset(connections, 0, sizeof(connections));
  connections_end= connections +
    (sizeof(connections)/sizeof(struct st_connection)) - 1;
  next_con= connections + 1;

6558 6559 6560 6561 6562 6563
#ifdef EMBEDDED_LIBRARY
  /* set appropriate stack for the 'query' threads */
  (void) pthread_attr_init(&cn_thd_attrib);
  pthread_attr_setstacksize(&cn_thd_attrib, DEFAULT_THREAD_STACK);
#endif /*EMBEDDED_LIBRARY*/

6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578
  /* Init file stack */
  memset(file_stack, 0, sizeof(file_stack));
  file_stack_end=
    file_stack + (sizeof(file_stack)/sizeof(struct st_test_file)) - 1;
  cur_file= file_stack;

  /* Init block stack */
  memset(block_stack, 0, sizeof(block_stack));
  block_stack_end=
    block_stack + (sizeof(block_stack)/sizeof(struct st_block)) - 1;
  cur_block= block_stack;
  cur_block->ok= TRUE; /* Outer block should always be executed */
  cur_block->cmd= cmd_none;

  my_init_dynamic_array(&q_lines, sizeof(struct st_command*), 1024, 1024);
kent@mysql.com's avatar
kent@mysql.com committed
6579

6580 6581 6582
  if (hash_init(&var_hash, charset_info,
                1024, 0, 0, get_var_key, var_free, MYF(0)))
    die("Variable hash initialization failed");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6583

6584 6585
  var_set_string("$MYSQL_SERVER_VERSION", MYSQL_SERVER_VERSION);

6586
  memset(&master_pos, 0, sizeof(master_pos));
6587

6588 6589 6590
  parser.current_line= parser.read_lines= 0;
  memset(&var_reg, 0, sizeof(var_reg));

6591
  init_builtin_echo();
6592
#ifdef __WIN__
6593
#ifndef USE_CYGWIN
6594
  is_windows= 1;
6595
#endif
6596 6597 6598
  init_tmp_sh_file();
  init_win_path_patterns();
#endif
6599

6600 6601
  init_dynamic_string(&ds_res, "", 65536, 65536);
  init_dynamic_string(&ds_progress, "", 0, 2048);
6602
  init_dynamic_string(&ds_warning_messages, "", 0, 2048);
6603
  parse_args(argc, argv);
6604

6605 6606 6607 6608 6609
  var_set_int("$PS_PROTOCOL", ps_protocol);
  var_set_int("$SP_PROTOCOL", sp_protocol);
  var_set_int("$VIEW_PROTOCOL", view_protocol);
  var_set_int("$CURSOR_PROTOCOL", cursor_protocol);

6610 6611
  DBUG_PRINT("info",("result_file: '%s'",
                     result_file_name ? result_file_name : ""));
6612 6613 6614
  if (mysql_server_init(embedded_server_arg_count,
			embedded_server_args,
			(char**) embedded_server_groups))
6615
    die("Can't initialize MySQL server");
6616
  server_initialized= 1;
6617
  if (cur_file == file_stack && cur_file->file == 0)
6618
  {
6619 6620
    cur_file->file= stdin;
    cur_file->file_name= my_strdup("<stdin>", MYF(MY_WME));
6621
    cur_file->lineno= 1;
6622
  }
6623 6624 6625 6626 6627 6628 6629
  init_re();
  ps_protocol_enabled= ps_protocol;
  sp_protocol_enabled= sp_protocol;
  view_protocol_enabled= view_protocol;
  cursor_protocol_enabled= cursor_protocol;
  /* Cursor protcol implies ps protocol */
  if (cursor_protocol_enabled)
6630
    ps_protocol_enabled= 1;
6631

6632
  cur_con= connections;
6633
  if (!( mysql_init(&cur_con->mysql)))
6634
    die("Failed in mysql_init()");
6635 6636
  if (opt_compress)
    mysql_options(&cur_con->mysql,MYSQL_OPT_COMPRESS,NullS);
6637
  mysql_options(&cur_con->mysql, MYSQL_OPT_LOCAL_INFILE, 0);
6638 6639 6640 6641 6642
  mysql_options(&cur_con->mysql, MYSQL_SET_CHARSET_NAME,
                charset_info->csname);
  if (opt_charsets_dir)
    mysql_options(&cur_con->mysql, MYSQL_SET_CHARSET_DIR,
                  opt_charsets_dir);
bar@mysql.com's avatar
bar@mysql.com committed
6643

gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
6644
#ifdef HAVE_OPENSSL
6645

gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
6646
  if (opt_use_ssl)
6647
  {
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
6648 6649
    mysql_ssl_set(&cur_con->mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
		  opt_ssl_capath, opt_ssl_cipher);
6650
#if MYSQL_VERSION_ID >= 50000
6651 6652
    /* Turn on ssl_verify_server_cert only if host is "localhost" */
    opt_ssl_verify_server_cert= opt_host && !strcmp(opt_host, "localhost");
6653 6654 6655 6656
    mysql_options(&cur_con->mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
                  &opt_ssl_verify_server_cert);
#endif
  }
gluh@gluh.mysql.r18.ru's avatar
gluh@gluh.mysql.r18.ru committed
6657
#endif
6658

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6659
  if (!(cur_con->name = my_strdup("default", MYF(MY_WME))))
6660
    die("Out of memory");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6661

6662 6663
  safe_connect(&cur_con->mysql, cur_con->name, opt_host, opt_user, opt_pass,
               opt_db, opt_port, unix_sock);
6664

6665 6666
  /* Use all time until exit if no explicit 'start_timer' */
  timer_start= timer_now();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
6667

6668 6669 6670 6671 6672
  /*
    Initialize $mysql_errno with -1, so we can
    - distinguish it from valid values ( >= 0 ) and
    - detect if there was never a command sent to the server
  */
6673 6674
  var_set_errno(-1);

6675 6676 6677 6678 6679
  if (opt_include)
  {
    open_file(opt_include);
  }

6680
  while (!read_command(&command) && !abort_flag)
6681 6682
  {
    int current_line_inc = 1, processed = 0;
6683 6684
    if (command->type == Q_UNKNOWN || command->type == Q_COMMENT_WITH_COMMAND)
      get_command_type(command);
6685 6686 6687 6688 6689 6690 6691 6692 6693

    if (parsing_disabled &&
        command->type != Q_ENABLE_PARSING &&
        command->type != Q_DISABLE_PARSING)
    {
      command->type= Q_COMMENT;
      scan_command_for_warnings(command);
    }

6694
    if (cur_block->ok)
6695
    {
6696
      command->last_argument= command->first_argument;
6697
      processed = 1;
6698 6699 6700 6701 6702
      switch (command->type) {
      case Q_CONNECT:
        do_connect(command);
        break;
      case Q_CONNECTION: select_connection(command); break;
6703
      case Q_DISCONNECT:
6704
      case Q_DIRTY_CLOSE:
6705 6706 6707 6708
	do_close_connection(command); break;
      case Q_RPL_PROBE: do_rpl_probe(command); break;
      case Q_ENABLE_RPL_PARSE:	 do_enable_rpl_parse(command); break;
      case Q_DISABLE_RPL_PARSE:  do_disable_rpl_parse(command); break;
6709
      case Q_ENABLE_QUERY_LOG:   disable_query_log=0; break;
6710
      case Q_DISABLE_QUERY_LOG:  disable_query_log=1; break;
6711 6712
      case Q_ENABLE_ABORT_ON_ERROR:  abort_on_error=1; break;
      case Q_DISABLE_ABORT_ON_ERROR: abort_on_error=0; break;
6713 6714
      case Q_ENABLE_RESULT_LOG:  disable_result_log=0; break;
      case Q_DISABLE_RESULT_LOG: disable_result_log=1; break;
6715 6716
      case Q_ENABLE_WARNINGS:    disable_warnings=0; break;
      case Q_DISABLE_WARNINGS:   disable_warnings=1; break;
6717 6718
      case Q_ENABLE_INFO:        disable_info=0; break;
      case Q_DISABLE_INFO:       disable_info=1; break;
6719
      case Q_ENABLE_METADATA:    display_metadata=1; break;
6720
      case Q_DISABLE_METADATA:   display_metadata=0; break;
6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731
      case Q_SOURCE: do_source(command); break;
      case Q_SLEEP: do_sleep(command, 0); break;
      case Q_REAL_SLEEP: do_sleep(command, 1); break;
      case Q_WAIT_FOR_SLAVE_TO_STOP: do_wait_for_slave_to_stop(command); break;
      case Q_INC: do_modify_var(command, DO_INC); break;
      case Q_DEC: do_modify_var(command, DO_DEC); break;
      case Q_ECHO: do_echo(command); command_executed++; break;
      case Q_SYSTEM: do_system(command); break;
      case Q_REMOVE_FILE: do_remove_file(command); break;
      case Q_FILE_EXIST: do_file_exist(command); break;
      case Q_WRITE_FILE: do_write_file(command); break;
6732
      case Q_APPEND_FILE: do_append_file(command); break;
6733
      case Q_DIFF_FILES: do_diff_files(command); break;
6734
      case Q_SEND_QUIT: do_send_quit(command); break;
6735
      case Q_CAT_FILE: do_cat_file(command); break;
6736
      case Q_COPY_FILE: do_copy_file(command); break;
6737
      case Q_CHMOD_FILE: do_chmod_file(command); break;
6738
      case Q_PERL: do_perl(command); break;
6739
      case Q_DELIMITER:
6740
        do_delimiter(command);
6741
	break;
6742 6743 6744 6745 6746 6747
      case Q_DISPLAY_VERTICAL_RESULTS:
        display_result_vertically= TRUE;
        break;
      case Q_DISPLAY_HORIZONTAL_RESULTS:
	display_result_vertically= FALSE;
        break;
6748
      case Q_SORTED_RESULT:
6749 6750 6751 6752 6753 6754
        /*
          Turn on sorting of result set, will be reset after next
          command
        */
	display_result_sorted= TRUE;
        break;
6755
      case Q_LET: do_let(command); break;
6756
      case Q_EVAL_RESULT:
6757
        die("'eval_result' command  is deprecated");
6758
      case Q_EVAL:
6759 6760
      case Q_QUERY_VERTICAL:
      case Q_QUERY_HORIZONTAL:
6761
	if (command->query == command->query_buf)
monty@mysql.com's avatar
monty@mysql.com committed
6762
        {
6763
          /* Skip the first part of command, i.e query_xxx */
6764 6765
	  command->query= command->first_argument;
          command->first_word_len= 0;
monty@mysql.com's avatar
monty@mysql.com committed
6766
        }
6767
	/* fall through */
6768
      case Q_QUERY:
6769
      case Q_REAP:
6770
      {
6771 6772 6773 6774
	my_bool old_display_result_vertically= display_result_vertically;
        /* Default is full query, both reap and send  */
        int flags= QUERY_REAP_FLAG | QUERY_SEND_FLAG;

6775 6776 6777 6778 6779 6780 6781 6782 6783 6784
        if (q_send_flag)
        {
          /* Last command was an empty 'send' */
          flags= QUERY_SEND_FLAG;
          q_send_flag= 0;
        }
        else if (command->type == Q_REAP)
        {
          flags= QUERY_REAP_FLAG;
        }
6785 6786

        /* Check for special property for this query */
6787
        display_result_vertically|= (command->type == Q_QUERY_VERTICAL);
6788

6789
	if (save_file[0])
6790
	{
6791 6792
	  strmake(command->require_file, save_file, sizeof(save_file));
	  save_file[0]= 0;
6793
	}
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
6794
	run_query(cur_con, command, flags);
6795 6796
	command_executed++;
        command->last_argument= command->end;
6797 6798 6799 6800

        /* Restore settings */
	display_result_vertically= old_display_result_vertically;

6801
	break;
6802
      }
6803
      case Q_SEND:
6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817
        if (!*command->first_argument)
        {
          /*
            This is a send without arguments, it indicates that _next_ query
            should be send only
          */
          q_send_flag= 1;
          break;
        }

        /* Remove "send" if this is first iteration */
	if (command->query == command->query_buf)
	  command->query= command->first_argument;

6818
	/*
6819 6820 6821
	  run_query() can execute a query partially, depending on the flags.
	  QUERY_SEND_FLAG flag without QUERY_REAP_FLAG tells it to just send
          the query and read the result some time later when reap instruction
6822
	  is given on this connection.
6823
        */
6824
	run_query(cur_con, command, QUERY_SEND_FLAG);
6825 6826
	command_executed++;
        command->last_argument= command->end;
6827
	break;
6828 6829
      case Q_REQUIRE:
	do_get_file_name(command, save_file, sizeof(save_file));
6830
	break;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
6831
      case Q_ERROR:
6832
        do_get_errcodes(command);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
6833
	break;
6834
      case Q_REPLACE:
6835
	do_get_replace(command);
6836
	break;
6837 6838 6839
      case Q_REPLACE_REGEX:
        do_get_replace_regex(command);
        break;
6840
      case Q_REPLACE_COLUMN:
6841
	do_get_replace_column(command);
6842
	break;
6843
      case Q_SAVE_MASTER_POS: do_save_master_pos(); break;
6844
      case Q_SYNC_WITH_MASTER: do_sync_with_master(command); break;
6845 6846 6847
      case Q_SYNC_SLAVE_WITH_MASTER:
      {
	do_save_master_pos();
6848 6849
	if (*command->first_argument)
	  select_connection(command);
6850
	else
6851 6852
	  select_connection_name("slave");
	do_sync_with_master2(0);
6853 6854
	break;
      }
6855
      case Q_COMMENT:				/* Ignore row */
6856
        command->last_argument= command->end;
6857
	break;
6858 6859 6860
      case Q_PING:
	(void) mysql_ping(&cur_con->mysql);
	break;
6861
      case Q_EXEC:
6862 6863
	do_exec(command);
	command_executed++;
6864
	break;
kent@mysql.com's avatar
kent@mysql.com committed
6865 6866 6867 6868 6869 6870 6871 6872
      case Q_START_TIMER:
	/* Overwrite possible earlier start of timer */
	timer_start= timer_now();
	break;
      case Q_END_TIMER:
	/* End timer before ending mysqltest */
	timer_output();
	break;
6873
      case Q_CHARACTER_SET:
6874
	do_set_charset(command);
kent@mysql.com's avatar
kent@mysql.com committed
6875
	break;
6876 6877
      case Q_DISABLE_PS_PROTOCOL:
        ps_protocol_enabled= 0;
6878 6879
        /* Close any open statements */
        close_statements();
6880 6881 6882 6883
        break;
      case Q_ENABLE_PS_PROTOCOL:
        ps_protocol_enabled= ps_protocol;
        break;
6884
      case Q_DISABLE_RECONNECT:
6885
        set_reconnect(&cur_con->mysql, 0);
6886 6887
        break;
      case Q_ENABLE_RECONNECT:
6888
        set_reconnect(&cur_con->mysql, 1);
6889 6890
        /* Close any open statements - no reconnect, need new prepare */
        close_statements();
6891 6892 6893 6894 6895 6896
        break;
      case Q_DISABLE_PARSING:
        if (parsing_disabled == 0)
          parsing_disabled= 1;
        else
          die("Parsing is already disabled");
6897
        break;
6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908
      case Q_ENABLE_PARSING:
        /*
          Ensure we don't get parsing_disabled < 0 as this would accidentally
          disable code we don't want to have disabled
        */
        if (parsing_disabled == 1)
          parsing_disabled= 0;
        else
          die("Parsing is already enabled");
        break;
      case Q_DIE:
6909
        /* Abort test with error code and error message */
6910 6911
        die("%s", command->first_argument);
        break;
6912 6913 6914 6915
      case Q_EXIT:
        /* Stop processing any more commands */
        abort_flag= 1;
        break;
6916 6917 6918
      case Q_SKIP:
        abort_not_supported_test("%s", command->first_argument);
        break;
6919

6920 6921 6922 6923
      case Q_RESULT:
        die("result, deprecated command");
        break;

6924 6925
      default:
        processed= 0;
6926
        break;
6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942
      }
    }

    if (!processed)
    {
      current_line_inc= 0;
      switch (command->type) {
      case Q_WHILE: do_block(cmd_while, command); break;
      case Q_IF: do_block(cmd_if, command); break;
      case Q_END_BLOCK: do_done(command); break;
      default: current_line_inc = 1; break;
      }
    }
    else
      check_eol_junk(command->last_argument);

6943 6944
    if (command->type != Q_ERROR &&
        command->type != Q_COMMENT)
6945 6946
    {
      /*
6947
        As soon as any non "error" command or comment has been executed,
6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959
        the array with expected errors should be cleared
      */
      memset(&saved_expected_errors, 0, sizeof(saved_expected_errors));
    }

    if (command_executed != last_command_executed)
    {
      /*
        As soon as any command has been executed,
        the replace structures should be cleared
      */
      free_all_replace();
6960

6961
      /* Also reset "sorted_result" */
6962
      display_result_sorted= FALSE;
6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982
    }
    last_command_executed= command_executed;

    parser.current_line += current_line_inc;
    if ( opt_mark_progress )
      mark_progress(command, parser.current_line);
  }

  start_lineno= 0;

  if (parsing_disabled)
    die("Test ended with parsing disabled");

  /*
    The whole test has been executed _sucessfully_.
    Time to compare result or save it to record file.
    The entire output from test is now kept in ds_res.
  */
  if (ds_res.length)
  {
6983
    if (result_file_name)
6984
    {
6985 6986
      /* A result file has been specified */

6987 6988
      if (record)
      {
6989 6990
	/* Recording - dump the output from test to result file */
	str_to_file(result_file_name, ds_res.str, ds_res.length);
6991 6992 6993 6994 6995 6996 6997
      }
      else
      {
	/* Check that the output from test is equal to result file
	   - detect missing result file
	   - detect zero size result file
        */
6998
	check_result(&ds_res);
6999 7000 7001 7002
      }
    }
    else
    {
7003
      /* No result_file_name specified to compare with, print to stdout */
7004 7005 7006 7007 7008 7009 7010 7011
      printf("%s", ds_res.str);
    }
  }
  else
  {
    die("The test didn't produce any output");
  }

7012 7013
  if (!command_executed &&
      result_file_name && my_stat(result_file_name, &res_info, 0))
7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024
  {
    /*
      my_stat() successful on result file. Check if we have not run a
      single query, but we do have a result file that contains data.
      Note that we don't care, if my_stat() fails. For example, for a
      non-existing or non-readable file, we assume it's fine to have
      no query output from the test file, e.g. regarded as no error.
    */
    die("No queries executed but result file found!");
  }

7025 7026
  if ( opt_mark_progress && result_file_name )
    dump_progress();
7027 7028

  /* Dump warning messages */
7029 7030
  if (result_file_name && ds_warning_messages.length)
    dump_warning_messages();
7031 7032 7033

  timer_output();
  /* Yes, if we got this far the test has suceeded! Sakila smiles */
7034 7035
  cleanup_and_exit(0);
  return 0; /* Keep compiler happy too */
7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209
}


/*
  A primitive timer that give results in milliseconds if the
  --timer-file=<filename> is given. The timer result is written
  to that file when the result is available. To not confuse
  mysql-test-run with an old obsolete result, we remove the file
  before executing any commands. The time we measure is

  - If no explicit 'start_timer' or 'end_timer' is given in the
  test case, the timer measure how long we execute in mysqltest.

  - If only 'start_timer' is given we measure how long we execute
  from that point until we terminate mysqltest.

  - If only 'end_timer' is given we measure how long we execute
  from that we enter mysqltest to the 'end_timer' is command is
  executed.

  - If both 'start_timer' and 'end_timer' are given we measure
  the time between executing the two commands.
*/

void timer_output(void)
{
  if (timer_file)
  {
    char buf[32], *end;
    ulonglong timer= timer_now() - timer_start;
    end= longlong2str(timer, buf, 10);
    str_to_file(timer_file,buf, (int) (end-buf));
    /* Timer has been written to the file, don't use it anymore */
    timer_file= 0;
  }
}


ulonglong timer_now(void)
{
  return my_getsystime() / 10000;
}


/*
  Get arguments for replace_columns. The syntax is:
  replace-column column_number to_string [column_number to_string ...]
  Where each argument may be quoted with ' or "
  A argument may also be a variable, in which case the value of the
  variable is replaced.
*/

void do_get_replace_column(struct st_command *command)
{
  char *from= command->first_argument;
  char *buff, *start;
  DBUG_ENTER("get_replace_columns");

  free_replace_column();
  if (!*from)
    die("Missing argument in %s", command->query);

  /* Allocate a buffer for results */
  start= buff= my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
  while (*from)
  {
    char *to;
    uint column_number;

    to= get_string(&buff, &from, command);
    if (!(column_number= atoi(to)) || column_number > MAX_COLUMNS)
      die("Wrong column number to replace_column in '%s'", command->query);
    if (!*from)
      die("Wrong number of arguments to replace_column in '%s'", command->query);
    to= get_string(&buff, &from, command);
    my_free(replace_column[column_number-1], MY_ALLOW_ZERO_PTR);
    replace_column[column_number-1]= my_strdup(to, MYF(MY_WME | MY_FAE));
    set_if_bigger(max_replace_column, column_number);
  }
  my_free(start, MYF(0));
  command->last_argument= command->end;
}


void free_replace_column()
{
  uint i;
  for (i=0 ; i < max_replace_column ; i++)
  {
    if (replace_column[i])
    {
      my_free(replace_column[i], 0);
      replace_column[i]= 0;
    }
  }
  max_replace_column= 0;
}


/****************************************************************************/
/*
  Replace functions
*/

/* Definitions for replace result */

typedef struct st_pointer_array {		/* when using array-strings */
  TYPELIB typelib;				/* Pointer to strings */
  byte	*str;					/* Strings is here */
  int7	*flag;					/* Flag about each var. */
  uint	array_allocs,max_count,length,max_length;
} POINTER_ARRAY;

struct st_replace;
struct st_replace *init_replace(my_string *from, my_string *to, uint count,
				my_string word_end_chars);
int insert_pointer_name(reg1 POINTER_ARRAY *pa,my_string name);
void replace_strings_append(struct st_replace *rep, DYNAMIC_STRING* ds,
                            const char *from, int len);
void free_pointer_array(POINTER_ARRAY *pa);

struct st_replace *glob_replace;

/*
  Get arguments for replace. The syntax is:
  replace from to [from to ...]
  Where each argument may be quoted with ' or "
  A argument may also be a variable, in which case the value of the
  variable is replaced.
*/

void do_get_replace(struct st_command *command)
{
  uint i;
  char *from= command->first_argument;
  char *buff, *start;
  char word_end_chars[256], *pos;
  POINTER_ARRAY to_array, from_array;
  DBUG_ENTER("get_replace");

  free_replace();

  bzero((char*) &to_array,sizeof(to_array));
  bzero((char*) &from_array,sizeof(from_array));
  if (!*from)
    die("Missing argument in %s", command->query);
  start= buff= my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
  while (*from)
  {
    char *to= buff;
    to= get_string(&buff, &from, command);
    if (!*from)
      die("Wrong number of arguments to replace_result in '%s'",
          command->query);
    insert_pointer_name(&from_array,to);
    to= get_string(&buff, &from, command);
    insert_pointer_name(&to_array,to);
  }
  for (i= 1,pos= word_end_chars ; i < 256 ; i++)
    if (my_isspace(charset_info,i))
      *pos++= i;
  *pos=0;					/* End pointer */
  if (!(glob_replace= init_replace((char**) from_array.typelib.type_names,
				  (char**) to_array.typelib.type_names,
				  (uint) from_array.typelib.count,
				  word_end_chars)))
    die("Can't initialize replace from '%s'", command->query);
  free_pointer_array(&from_array);
  free_pointer_array(&to_array);
  my_free(start, MYF(0));
  command->last_argument= command->end;
  DBUG_VOID_RETURN;
}

7210

7211 7212 7213 7214 7215 7216 7217 7218 7219 7220
void free_replace()
{
  DBUG_ENTER("free_replace");
  if (glob_replace)
  {
    my_free((char*) glob_replace,MYF(0));
    glob_replace=0;
  }
  DBUG_VOID_RETURN;
}
7221

7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236

typedef struct st_replace {
  bool	 found;
  struct st_replace *next[256];
} REPLACE;

typedef struct st_replace_found {
  bool found;
  char *replace_string;
  uint to_offset;
  int from_offset;
} REPLACE_STRING;


void replace_strings_append(REPLACE *rep, DYNAMIC_STRING* ds,
7237 7238
                            const char *str,
                            int len __attribute__((unused)))
7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255
{
  reg1 REPLACE *rep_pos;
  reg2 REPLACE_STRING *rep_str;
  const char *start, *from;
  DBUG_ENTER("replace_strings_append");

  start= from= str;
  rep_pos=rep+1;
  for (;;)
  {
    /* Loop through states */
    DBUG_PRINT("info", ("Looping through states"));
    while (!rep_pos->found)
      rep_pos= rep_pos->next[(uchar) *from++];

    /* Does this state contain a string to be replaced */
    if (!(rep_str = ((REPLACE_STRING*) rep_pos))->replace_string)
7256
    {
7257 7258 7259 7260
      /* No match found */
      dynstr_append_mem(ds, start, from - start - 1);
      DBUG_PRINT("exit", ("Found no more string to replace, appended: %s", start));
      DBUG_VOID_RETURN;
7261 7262
    }

7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275
    /* Found a string that needs to be replaced */
    DBUG_PRINT("info", ("found: %d, to_offset: %d, from_offset: %d, string: %s",
                        rep_str->found, rep_str->to_offset,
                        rep_str->from_offset, rep_str->replace_string));

    /* Append part of original string before replace string */
    dynstr_append_mem(ds, start, (from - rep_str->to_offset) - start);

    /* Append replace string */
    dynstr_append_mem(ds, rep_str->replace_string,
                      strlen(rep_str->replace_string));

    if (!*(from-=rep_str->from_offset) && rep_pos->found != 2)
7276
    {
7277 7278 7279
      /* End of from string */
      DBUG_PRINT("exit", ("Found end of from string"));
      DBUG_VOID_RETURN;
7280
    }
7281 7282 7283
    DBUG_ASSERT(from <= str+len);
    start= from;
    rep_pos=rep;
7284
  }
7285
}
7286

7287

7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383
/*
  Regex replace  functions
*/


/* Stores regex substitutions */

struct st_regex
{
  char* pattern; /* Pattern to be replaced */
  char* replace; /* String or expression to replace the pattern with */
  int icase; /* true if the match is case insensitive */
};

struct st_replace_regex
{
  DYNAMIC_ARRAY regex_arr; /* stores a list of st_regex subsitutions */

  /*
    Temporary storage areas for substitutions. To reduce unnessary copying
    and memory freeing/allocation, we pre-allocate two buffers, and alternate
    their use, one for input/one for output, the roles changing on the next
    st_regex substition. At the end of substitutions  buf points to the
    one containing the final result.
  */
  char* buf;
  char* even_buf;
  char* odd_buf;
  int even_buf_len;
  int odd_buf_len;
};

struct st_replace_regex *glob_replace_regex= 0;

int reg_replace(char** buf_p, int* buf_len_p, char *pattern, char *replace,
                char *string, int icase);



/*
  Finds the next (non-escaped) '/' in the expression.
  (If the character '/' is needed, it can be escaped using '\'.)
*/

#define PARSE_REGEX_ARG                         \
  while (p < expr_end)                          \
  {                                             \
    char c= *p;                                 \
    if (c == '/')                               \
    {                                           \
      if (last_c == '\\')                       \
      {                                         \
        buf_p[-1]= '/';                         \
      }                                         \
      else                                      \
      {                                         \
        *buf_p++ = 0;                           \
        break;                                  \
      }                                         \
    }                                           \
    else                                        \
      *buf_p++ = c;                             \
                                                \
    last_c= c;                                  \
    p++;                                        \
  }                                             \
                                                \
/*
  Initializes the regular substitution expression to be used in the
  result output of test.

  Returns: st_replace_regex struct with pairs of substitutions
*/

struct st_replace_regex* init_replace_regex(char* expr)
{
  struct st_replace_regex* res;
  char* buf,*expr_end;
  char* p;
  char* buf_p;
  uint expr_len= strlen(expr);
  char last_c = 0;
  struct st_regex reg;

  /* my_malloc() will die on fail with MY_FAE */
  res=(struct st_replace_regex*)my_malloc(
                                          sizeof(*res)+expr_len ,MYF(MY_FAE+MY_WME));
  my_init_dynamic_array(&res->regex_arr,sizeof(struct st_regex),128,128);

  buf= (char*)res + sizeof(*res);
  expr_end= expr + expr_len;
  p= expr;
  buf_p= buf;

  /* for each regexp substitution statement */
  while (p < expr_end)
7384
  {
7385 7386 7387
    bzero(&reg,sizeof(reg));
    /* find the start of the statement */
    while (p < expr_end)
7388
    {
7389 7390 7391
      if (*p == '/')
        break;
      p++;
7392
    }
7393 7394

    if (p == expr_end || ++p == expr_end)
7395
    {
7396 7397 7398 7399
      if (res->regex_arr.elements)
        break;
      else
        goto err;
7400
    }
7401 7402
    /* we found the start */
    reg.pattern= buf_p;
7403

7404 7405
    /* Find first argument -- pattern string to be removed */
    PARSE_REGEX_ARG
7406

7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428
      if (p == expr_end || ++p == expr_end)
        goto err;

    /* buf_p now points to the replacement pattern terminated with \0 */
    reg.replace= buf_p;

    /* Find second argument -- replace string to replace pattern */
    PARSE_REGEX_ARG

      if (p == expr_end)
        goto err;

    /* skip the ending '/' in the statement */
    p++;

    /* Check if we should do matching case insensitive */
    if (p < expr_end && *p == 'i')
      reg.icase= 1;

    /* done parsing the statement, now place it in regex_arr */
    if (insert_dynamic(&res->regex_arr,(gptr) &reg))
      die("Out of memory");
7429
  }
7430 7431 7432 7433 7434 7435
  res->odd_buf_len= res->even_buf_len= 8192;
  res->even_buf= (char*)my_malloc(res->even_buf_len,MYF(MY_WME+MY_FAE));
  res->odd_buf= (char*)my_malloc(res->odd_buf_len,MYF(MY_WME+MY_FAE));
  res->buf= res->even_buf;

  return res;
7436

7437 7438 7439 7440 7441
err:
  my_free((gptr)res,0);
  die("Error parsing replace_regex \"%s\"", expr);
  return 0;
}
7442

7443
/*
7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459
  Execute all substitutions on val.

  Returns: true if substituition was made, false otherwise
  Side-effect: Sets r->buf to be the buffer with all substitutions done.

  IN:
  struct st_replace_regex* r
  char* val
  Out:
  struct st_replace_regex* r
  r->buf points at the resulting buffer
  r->even_buf and r->odd_buf might have been reallocated
  r->even_buf_len and r->odd_buf_len might have been changed

  TODO:  at some point figure out if there is a way to do everything
  in one pass
7460 7461
*/

7462
int multi_reg_replace(struct st_replace_regex* r,char* val)
7463
{
7464 7465 7466
  uint i;
  char* in_buf, *out_buf;
  int* buf_len_p;
7467

7468 7469 7470 7471
  in_buf= val;
  out_buf= r->even_buf;
  buf_len_p= &r->even_buf_len;
  r->buf= 0;
7472

7473 7474
  /* For each substitution, do the replace */
  for (i= 0; i < r->regex_arr.elements; i++)
7475
  {
7476 7477 7478 7479 7480 7481 7482
    struct st_regex re;
    char* save_out_buf= out_buf;

    get_dynamic(&r->regex_arr,(gptr)&re,i);

    if (!reg_replace(&out_buf, buf_len_p, re.pattern, re.replace,
                     in_buf, re.icase))
7483
    {
7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500
      /* if the buffer has been reallocated, make adjustements */
      if (save_out_buf != out_buf)
      {
        if (save_out_buf == r->even_buf)
          r->even_buf= out_buf;
        else
          r->odd_buf= out_buf;
      }

      r->buf= out_buf;
      if (in_buf == val)
        in_buf= r->odd_buf;

      swap_variables(char*,in_buf,out_buf);

      buf_len_p= (out_buf == r->even_buf) ? &r->even_buf_len :
        &r->odd_buf_len;
7501 7502
    }
  }
7503 7504

  return (r->buf == 0);
7505
}
7506

7507 7508 7509 7510 7511 7512 7513 7514 7515 7516
/*
  Parse the regular expression to be used in all result files
  from now on.

  The syntax is --replace_regex /from/to/i /from/to/i ...
  i means case-insensitive match. If omitted, the match is
  case-sensitive

*/
void do_get_replace_regex(struct st_command *command)
kent@mysql.com's avatar
kent@mysql.com committed
7517
{
7518 7519 7520 7521 7522
  char *expr= command->first_argument;
  free_replace_regex();
  if (!(glob_replace_regex=init_replace_regex(expr)))
    die("Could not init replace_regex");
  command->last_argument= command->end;
kent@mysql.com's avatar
kent@mysql.com committed
7523 7524
}

7525
void free_replace_regex()
kent@mysql.com's avatar
kent@mysql.com committed
7526
{
7527 7528 7529 7530 7531 7532 7533 7534
  if (glob_replace_regex)
  {
    delete_dynamic(&glob_replace_regex->regex_arr);
    my_free(glob_replace_regex->even_buf,MYF(MY_ALLOW_ZERO_PTR));
    my_free(glob_replace_regex->odd_buf,MYF(MY_ALLOW_ZERO_PTR));
    my_free((char*) glob_replace_regex,MYF(0));
    glob_replace_regex=0;
  }
kent@mysql.com's avatar
kent@mysql.com committed
7535 7536
}

7537 7538


7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552
/*
  auxiluary macro used by reg_replace
  makes sure the result buffer has sufficient length
*/
#define SECURE_REG_BUF   if (buf_len < need_buf_len)                    \
  {                                                                     \
    int off= res_p - buf;                                               \
    buf= (char*)my_realloc(buf,need_buf_len,MYF(MY_WME+MY_FAE));        \
    res_p= buf + off;                                                   \
    buf_len= need_buf_len;                                              \
  }                                                                     \
                                                                        \
/*
  Performs a regex substitution
7553

7554
  IN:
7555

7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567
  buf_p - result buffer pointer. Will change if reallocated
  buf_len_p - result buffer length. Will change if the buffer is reallocated
  pattern - regexp pattern to match
  replace - replacement expression
  string - the string to perform substituions in
  icase - flag, if set to 1 the match is case insensitive
*/
int reg_replace(char** buf_p, int* buf_len_p, char *pattern,
                char *replace, char *string, int icase)
{
  my_regex_t r;
  my_regmatch_t *subs;
7568
  char *replace_end;
7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584
  char *buf= *buf_p;
  int len;
  int buf_len, need_buf_len;
  int cflags= REG_EXTENDED;
  int err_code;
  char *res_p,*str_p,*str_end;

  buf_len= *buf_len_p;
  len= strlen(string);
  str_end= string + len;

  /* start with a buffer of a reasonable size that hopefully will not
     need to be reallocated
  */
  need_buf_len= len * 2 + 1;
  res_p= buf;
7585

7586
  SECURE_REG_BUF
7587

7588 7589
  if (icase)
    cflags|= REG_ICASE;
7590

7591 7592 7593 7594 7595
  if ((err_code= my_regcomp(&r,pattern,cflags,&my_charset_latin1)))
  {
    check_regerr(&r,err_code);
    return 1;
  }
7596

7597 7598
  subs= (my_regmatch_t*)my_malloc(sizeof(my_regmatch_t) * (r.re_nsub+1),
                                  MYF(MY_WME+MY_FAE));
7599

7600 7601 7602
  *res_p= 0;
  str_p= string;
  replace_end= replace + strlen(replace);
7603

7604 7605
  /* for each pattern match instance perform a replacement */
  while (!err_code)
7606
  {
7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628
    /* find the match */
    err_code= my_regexec(&r,str_p, r.re_nsub+1, subs,
                         (str_p == string) ? REG_NOTBOL : 0);

    /* if regular expression error (eg. bad syntax, or out of memory) */
    if (err_code && err_code != REG_NOMATCH)
    {
      check_regerr(&r,err_code);
      my_regfree(&r);
      return 1;
    }

    /* if match found */
    if (!err_code)
    {
      char* expr_p= replace;
      int c;

      /*
        we need at least what we have so far in the buffer + the part
        before this match
      */
7629
      need_buf_len= (res_p - buf) + (int) subs[0].rm_so;
7630 7631 7632 7633 7634 7635 7636 7637 7638

      /* on this pass, calculate the memory for the result buffer */
      while (expr_p < replace_end)
      {
        int back_ref_num= -1;
        c= *expr_p;

        if (c == '\\' && expr_p + 1 < replace_end)
        {
7639
          back_ref_num= (int) (expr_p[1] - '0');
7640 7641 7642 7643 7644
        }

        /* found a valid back_ref (eg. \1)*/
        if (back_ref_num >= 0 && back_ref_num <= (int)r.re_nsub)
        {
7645
          regoff_t start_off, end_off;
7646 7647 7648
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
              (end_off=subs[back_ref_num].rm_eo) > -1)
          {
7649
            need_buf_len += (int) (end_off - start_off);
7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668
          }
          expr_p += 2;
        }
        else
        {
          expr_p++;
          need_buf_len++;
        }
      }
      need_buf_len++;
      /*
        now that we know the size of the buffer,
        make sure it is big enough
      */
      SECURE_REG_BUF

        /* copy the pre-match part */
        if (subs[0].rm_so)
        {
7669
          memcpy(res_p, str_p, (size_t) subs[0].rm_so);
7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687
          res_p+= subs[0].rm_so;
        }

      expr_p= replace;

      /* copy the match and expand back_refs */
      while (expr_p < replace_end)
      {
        int back_ref_num= -1;
        c= *expr_p;

        if (c == '\\' && expr_p + 1 < replace_end)
        {
          back_ref_num= expr_p[1] - '0';
        }

        if (back_ref_num >= 0 && back_ref_num <= (int)r.re_nsub)
        {
7688
          regoff_t start_off, end_off;
7689 7690 7691
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
              (end_off=subs[back_ref_num].rm_eo) > -1)
          {
7692
            int block_len= (int) (end_off - start_off);
7693 7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716 7717 7718 7719 7720 7721 7722 7723 7724 7725
            memcpy(res_p,str_p + start_off, block_len);
            res_p += block_len;
          }
          expr_p += 2;
        }
        else
        {
          *res_p++ = *expr_p++;
        }
      }

      /* handle the post-match part */
      if (subs[0].rm_so == subs[0].rm_eo)
      {
        if (str_p + subs[0].rm_so >= str_end)
          break;
        str_p += subs[0].rm_eo ;
        *res_p++ = *str_p++;
      }
      else
      {
        str_p += subs[0].rm_eo;
      }
    }
    else /* no match this time, just copy the string as is */
    {
      int left_in_str= str_end-str_p;
      need_buf_len= (res_p-buf) + left_in_str;
      SECURE_REG_BUF
        memcpy(res_p,str_p,left_in_str);
      res_p += left_in_str;
      str_p= str_end;
    }
7726
  }
7727 7728 7729 7730 7731 7732 7733
  my_free((gptr)subs, MYF(0));
  my_regfree(&r);
  *res_p= 0;
  *buf_p= buf;
  *buf_len_p= buf_len;
  return 0;
}
7734 7735


7736 7737 7738
#ifndef WORD_BIT
#define WORD_BIT (8*sizeof(uint))
#endif
7739 7740

#define SET_MALLOC_HUNC 64
7741
#define LAST_CHAR_CODE 259
7742 7743

typedef struct st_rep_set {
7744 7745
  uint	*bits;				/* Pointer to used sets */
  short next[LAST_CHAR_CODE];		/* Pointer to next sets */
7746 7747
  uint	found_len;			/* Best match to date */
  int	found_offset;
7748 7749
  uint	table_offset;
  uint	size_of_bits;			/* For convinience */
7750 7751 7752 7753 7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772
} REP_SET;

typedef struct st_rep_sets {
  uint		count;			/* Number of sets */
  uint		extra;			/* Extra sets in buffer */
  uint		invisible;		/* Sets not chown */
  uint		size_of_bits;
  REP_SET	*set,*set_buffer;
  uint		*bit_buffer;
} REP_SETS;

typedef struct st_found_set {
  uint table_offset;
  int found_offset;
} FOUND_SET;

typedef struct st_follow {
  int chr;
  uint table_offset;
  uint len;
} FOLLOWS;


7773 7774 7775 7776 7777 7778 7779 7780 7781 7782 7783 7784 7785 7786 7787 7788
int init_sets(REP_SETS *sets,uint states);
REP_SET *make_new_set(REP_SETS *sets);
void make_sets_invisible(REP_SETS *sets);
void free_last_set(REP_SETS *sets);
void free_sets(REP_SETS *sets);
void internal_set_bit(REP_SET *set, uint bit);
void internal_clear_bit(REP_SET *set, uint bit);
void or_bits(REP_SET *to,REP_SET *from);
void copy_bits(REP_SET *to,REP_SET *from);
int cmp_bits(REP_SET *set1,REP_SET *set2);
int get_next_bit(REP_SET *set,uint lastpos);
int find_set(REP_SETS *sets,REP_SET *find);
int find_found(FOUND_SET *found_set,uint table_offset,
               int found_offset);
uint start_at_word(my_string pos);
uint end_of_word(my_string pos);
7789 7790 7791 7792

static uint found_sets=0;


7793 7794 7795 7796 7797 7798 7799 7800 7801 7802 7803 7804 7805 7806
uint replace_len(my_string str)
{
  uint len=0;
  while (*str)
  {
    if (str[0] == '\\' && str[1])
      str++;
    str++;
    len++;
  }
  return len;
}

/* Init a replace structure for further calls */
7807 7808 7809 7810

REPLACE *init_replace(my_string *from, my_string *to,uint count,
		      my_string word_end_chars)
{
7811 7812 7813 7814
  static const int SPACE_CHAR= 256;
  static const int START_OF_LINE= 257;
  static const int END_OF_LINE= 258;

7815 7816 7817 7818 7819 7820 7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836 7837 7838 7839 7840 7841 7842 7843 7844 7845 7846 7847 7848 7849 7850 7851 7852 7853 7854 7855 7856 7857 7858 7859 7860 7861 7862 7863 7864 7865 7866
  uint i,j,states,set_nr,len,result_len,max_length,found_end,bits_set,bit_nr;
  int used_sets,chr,default_state;
  char used_chars[LAST_CHAR_CODE],is_word_end[256];
  my_string pos,to_pos,*to_array;
  REP_SETS sets;
  REP_SET *set,*start_states,*word_states,*new_set;
  FOLLOWS *follow,*follow_ptr;
  REPLACE *replace;
  FOUND_SET *found_set;
  REPLACE_STRING *rep_str;
  DBUG_ENTER("init_replace");

  /* Count number of states */
  for (i=result_len=max_length=0 , states=2 ; i < count ; i++)
  {
    len=replace_len(from[i]);
    if (!len)
    {
      errno=EINVAL;
      my_message(0,"No to-string for last from-string",MYF(ME_BELL));
      DBUG_RETURN(0);
    }
    states+=len+1;
    result_len+=(uint) strlen(to[i])+1;
    if (len > max_length)
      max_length=len;
  }
  bzero((char*) is_word_end,sizeof(is_word_end));
  for (i=0 ; word_end_chars[i] ; i++)
    is_word_end[(uchar) word_end_chars[i]]=1;

  if (init_sets(&sets,states))
    DBUG_RETURN(0);
  found_sets=0;
  if (!(found_set= (FOUND_SET*) my_malloc(sizeof(FOUND_SET)*max_length*count,
					  MYF(MY_WME))))
  {
    free_sets(&sets);
    DBUG_RETURN(0);
  }
  VOID(make_new_set(&sets));			/* Set starting set */
  make_sets_invisible(&sets);			/* Hide previus sets */
  used_sets=-1;
  word_states=make_new_set(&sets);		/* Start of new word */
  start_states=make_new_set(&sets);		/* This is first state */
  if (!(follow=(FOLLOWS*) my_malloc((states+2)*sizeof(FOLLOWS),MYF(MY_WME))))
  {
    free_sets(&sets);
    my_free((gptr) found_set,MYF(0));
    DBUG_RETURN(0);
  }

7867
  /* Init follow_ptr[] */
7868 7869 7870 7871
  for (i=0, states=1, follow_ptr=follow+1 ; i < count ; i++)
  {
    if (from[i][0] == '\\' && from[i][1] == '^')
    {
7872
      internal_set_bit(start_states,states+1);
7873 7874 7875 7876 7877 7878 7879 7880
      if (!from[i][2])
      {
	start_states->table_offset=i;
	start_states->found_offset=1;
      }
    }
    else if (from[i][0] == '\\' && from[i][1] == '$')
    {
7881 7882
      internal_set_bit(start_states,states);
      internal_set_bit(word_states,states);
7883 7884 7885 7886 7887 7888 7889 7890
      if (!from[i][2] && start_states->table_offset == (uint) ~0)
      {
	start_states->table_offset=i;
	start_states->found_offset=0;
      }
    }
    else
    {
7891
      internal_set_bit(word_states,states);
7892
      if (from[i][0] == '\\' && (from[i][1] == 'b' && from[i][2]))
7893
	internal_set_bit(start_states,states+1);
7894
      else
7895
	internal_set_bit(start_states,states);
7896 7897 7898 7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000
    }
    for (pos=from[i], len=0; *pos ; pos++)
    {
      if (*pos == '\\' && *(pos+1))
      {
	pos++;
	switch (*pos) {
	case 'b':
	  follow_ptr->chr = SPACE_CHAR;
	  break;
	case '^':
	  follow_ptr->chr = START_OF_LINE;
	  break;
	case '$':
	  follow_ptr->chr = END_OF_LINE;
	  break;
	case 'r':
	  follow_ptr->chr = '\r';
	  break;
	case 't':
	  follow_ptr->chr = '\t';
	  break;
	case 'v':
	  follow_ptr->chr = '\v';
	  break;
	default:
	  follow_ptr->chr = (uchar) *pos;
	  break;
	}
      }
      else
	follow_ptr->chr= (uchar) *pos;
      follow_ptr->table_offset=i;
      follow_ptr->len= ++len;
      follow_ptr++;
    }
    follow_ptr->chr=0;
    follow_ptr->table_offset=i;
    follow_ptr->len=len;
    follow_ptr++;
    states+=(uint) len+1;
  }


  for (set_nr=0,pos=0 ; set_nr < sets.count ; set_nr++)
  {
    set=sets.set+set_nr;
    default_state= 0;				/* Start from beginning */

    /* If end of found-string not found or start-set with current set */

    for (i= (uint) ~0; (i=get_next_bit(set,i)) ;)
    {
      if (!follow[i].chr)
      {
	if (! default_state)
	  default_state= find_found(found_set,set->table_offset,
				    set->found_offset+1);
      }
    }
    copy_bits(sets.set+used_sets,set);		/* Save set for changes */
    if (!default_state)
      or_bits(sets.set+used_sets,sets.set);	/* Can restart from start */

    /* Find all chars that follows current sets */
    bzero((char*) used_chars,sizeof(used_chars));
    for (i= (uint) ~0; (i=get_next_bit(sets.set+used_sets,i)) ;)
    {
      used_chars[follow[i].chr]=1;
      if ((follow[i].chr == SPACE_CHAR && !follow[i+1].chr &&
	   follow[i].len > 1) || follow[i].chr == END_OF_LINE)
	used_chars[0]=1;
    }

    /* Mark word_chars used if \b is in state */
    if (used_chars[SPACE_CHAR])
      for (pos= word_end_chars ; *pos ; pos++)
	used_chars[(int) (uchar) *pos] = 1;

    /* Handle other used characters */
    for (chr= 0 ; chr < 256 ; chr++)
    {
      if (! used_chars[chr])
	set->next[chr]= chr ? default_state : -1;
      else
      {
	new_set=make_new_set(&sets);
	set=sets.set+set_nr;			/* if realloc */
	new_set->table_offset=set->table_offset;
	new_set->found_len=set->found_len;
	new_set->found_offset=set->found_offset+1;
	found_end=0;

	for (i= (uint) ~0 ; (i=get_next_bit(sets.set+used_sets,i)) ; )
	{
	  if (!follow[i].chr || follow[i].chr == chr ||
	      (follow[i].chr == SPACE_CHAR &&
	       (is_word_end[chr] ||
		(!chr && follow[i].len > 1 && ! follow[i+1].chr))) ||
	      (follow[i].chr == END_OF_LINE && ! chr))
	  {
	    if ((! chr || (follow[i].chr && !follow[i+1].chr)) &&
		follow[i].len > found_end)
	      found_end=follow[i].len;
	    if (chr && follow[i].chr)
8001
	      internal_set_bit(new_set,i+1);		/* To next set */
8002
	    else
8003
	      internal_set_bit(new_set,i);
8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019
	  }
	}
	if (found_end)
	{
	  new_set->found_len=0;			/* Set for testing if first */
	  bits_set=0;
	  for (i= (uint) ~0; (i=get_next_bit(new_set,i)) ;)
	  {
	    if ((follow[i].chr == SPACE_CHAR ||
		 follow[i].chr == END_OF_LINE) && ! chr)
	      bit_nr=i+1;
	    else
	      bit_nr=i;
	    if (follow[bit_nr-1].len < found_end ||
		(new_set->found_len &&
		 (chr == 0 || !follow[bit_nr].chr)))
8020
	      internal_clear_bit(new_set,i);
8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049
	    else
	    {
	      if (chr == 0 || !follow[bit_nr].chr)
	      {					/* best match  */
		new_set->table_offset=follow[bit_nr].table_offset;
		if (chr || (follow[i].chr == SPACE_CHAR ||
			    follow[i].chr == END_OF_LINE))
		  new_set->found_offset=found_end;	/* New match */
		new_set->found_len=found_end;
	      }
	      bits_set++;
	    }
	  }
	  if (bits_set == 1)
	  {
	    set->next[chr] = find_found(found_set,
					new_set->table_offset,
					new_set->found_offset);
	    free_last_set(&sets);
	  }
	  else
	    set->next[chr] = find_set(&sets,new_set);
	}
	else
	  set->next[chr] = find_set(&sets,new_set);
      }
    }
  }

8050
  /* Alloc replace structure for the replace-state-machine */
8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083 8084 8085 8086 8087 8088 8089 8090 8091 8092

  if ((replace=(REPLACE*) my_malloc(sizeof(REPLACE)*(sets.count)+
				    sizeof(REPLACE_STRING)*(found_sets+1)+
				    sizeof(my_string)*count+result_len,
				    MYF(MY_WME | MY_ZEROFILL))))
  {
    rep_str=(REPLACE_STRING*) (replace+sets.count);
    to_array=(my_string*) (rep_str+found_sets+1);
    to_pos=(my_string) (to_array+count);
    for (i=0 ; i < count ; i++)
    {
      to_array[i]=to_pos;
      to_pos=strmov(to_pos,to[i])+1;
    }
    rep_str[0].found=1;
    rep_str[0].replace_string=0;
    for (i=1 ; i <= found_sets ; i++)
    {
      pos=from[found_set[i-1].table_offset];
      rep_str[i].found= !bcmp(pos,"\\^",3) ? 2 : 1;
      rep_str[i].replace_string=to_array[found_set[i-1].table_offset];
      rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos);
      rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+
	end_of_word(pos);
    }
    for (i=0 ; i < sets.count ; i++)
    {
      for (j=0 ; j < 256 ; j++)
	if (sets.set[i].next[j] >= 0)
	  replace[i].next[j]=replace+sets.set[i].next[j];
	else
	  replace[i].next[j]=(REPLACE*) (rep_str+(-sets.set[i].next[j]-1));
    }
  }
  my_free((gptr) follow,MYF(0));
  free_sets(&sets);
  my_free((gptr) found_set,MYF(0));
  DBUG_PRINT("exit",("Replace table has %d states",sets.count));
  DBUG_RETURN(replace);
}


8093
int init_sets(REP_SETS *sets,uint states)
8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108
{
  bzero((char*) sets,sizeof(*sets));
  sets->size_of_bits=((states+7)/8);
  if (!(sets->set_buffer=(REP_SET*) my_malloc(sizeof(REP_SET)*SET_MALLOC_HUNC,
					      MYF(MY_WME))))
    return 1;
  if (!(sets->bit_buffer=(uint*) my_malloc(sizeof(uint)*sets->size_of_bits*
					   SET_MALLOC_HUNC,MYF(MY_WME))))
  {
    my_free((gptr) sets->set,MYF(0));
    return 1;
  }
  return 0;
}

8109
/* Make help sets invisible for nicer codeing */
8110

8111
void make_sets_invisible(REP_SETS *sets)
8112 8113 8114 8115 8116 8117
{
  sets->invisible=sets->count;
  sets->set+=sets->count;
  sets->count=0;
}

8118
REP_SET *make_new_set(REP_SETS *sets)
8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135
{
  uint i,count,*bit_buffer;
  REP_SET *set;
  if (sets->extra)
  {
    sets->extra--;
    set=sets->set+ sets->count++;
    bzero((char*) set->bits,sizeof(uint)*sets->size_of_bits);
    bzero((char*) &set->next[0],sizeof(set->next[0])*LAST_CHAR_CODE);
    set->found_offset=0;
    set->found_len=0;
    set->table_offset= (uint) ~0;
    set->size_of_bits=sets->size_of_bits;
    return set;
  }
  count=sets->count+sets->invisible+SET_MALLOC_HUNC;
  if (!(set=(REP_SET*) my_realloc((gptr) sets->set_buffer,
8136
                                  sizeof(REP_SET)*count,
8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154
				  MYF(MY_WME))))
    return 0;
  sets->set_buffer=set;
  sets->set=set+sets->invisible;
  if (!(bit_buffer=(uint*) my_realloc((gptr) sets->bit_buffer,
				      (sizeof(uint)*sets->size_of_bits)*count,
				      MYF(MY_WME))))
    return 0;
  sets->bit_buffer=bit_buffer;
  for (i=0 ; i < count ; i++)
  {
    sets->set_buffer[i].bits=bit_buffer;
    bit_buffer+=sets->size_of_bits;
  }
  sets->extra=SET_MALLOC_HUNC;
  return make_new_set(sets);
}

8155
void free_last_set(REP_SETS *sets)
8156 8157 8158 8159 8160 8161
{
  sets->count--;
  sets->extra++;
  return;
}

8162
void free_sets(REP_SETS *sets)
8163 8164 8165 8166 8167 8168
{
  my_free((gptr)sets->set_buffer,MYF(0));
  my_free((gptr)sets->bit_buffer,MYF(0));
  return;
}

8169
void internal_set_bit(REP_SET *set, uint bit)
8170 8171 8172 8173 8174
{
  set->bits[bit / WORD_BIT] |= 1 << (bit % WORD_BIT);
  return;
}

8175
void internal_clear_bit(REP_SET *set, uint bit)
8176 8177 8178 8179 8180 8181
{
  set->bits[bit / WORD_BIT] &= ~ (1 << (bit % WORD_BIT));
  return;
}


8182
void or_bits(REP_SET *to,REP_SET *from)
8183 8184 8185 8186 8187 8188 8189
{
  reg1 uint i;
  for (i=0 ; i < to->size_of_bits ; i++)
    to->bits[i]|=from->bits[i];
  return;
}

8190
void copy_bits(REP_SET *to,REP_SET *from)
8191 8192 8193 8194 8195
{
  memcpy((byte*) to->bits,(byte*) from->bits,
	 (size_t) (sizeof(uint) * to->size_of_bits));
}

8196
int cmp_bits(REP_SET *set1,REP_SET *set2)
8197 8198 8199 8200 8201 8202
{
  return bcmp((byte*) set1->bits,(byte*) set2->bits,
	      sizeof(uint) * set1->size_of_bits);
}


8203
/* Get next set bit from set. */
8204

8205
int get_next_bit(REP_SET *set,uint lastpos)
8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225
{
  uint pos,*start,*end,bits;

  start=set->bits+ ((lastpos+1) / WORD_BIT);
  end=set->bits + set->size_of_bits;
  bits=start[0] & ~((1 << ((lastpos+1) % WORD_BIT)) -1);

  while (! bits && ++start < end)
    bits=start[0];
  if (!bits)
    return 0;
  pos=(uint) (start-set->bits)*WORD_BIT;
  while (! (bits & 1))
  {
    bits>>=1;
    pos++;
  }
  return pos;
}

8226 8227 8228
/* find if there is a same set in sets. If there is, use it and
   free given set, else put in given set in sets and return its
   position */
8229

8230
int find_set(REP_SETS *sets,REP_SET *find)
8231 8232 8233 8234 8235 8236 8237 8238 8239 8240 8241 8242 8243
{
  uint i;
  for (i=0 ; i < sets->count-1 ; i++)
  {
    if (!cmp_bits(sets->set+i,find))
    {
      free_last_set(sets);
      return i;
    }
  }
  return i;				/* return new postion */
}

8244 8245 8246 8247 8248 8249
/* find if there is a found_set with same table_offset & found_offset
   If there is return offset to it, else add new offset and return pos.
   Pos returned is -offset-2 in found_set_structure because it is
   saved in set->next and set->next[] >= 0 points to next set and
   set->next[] == -1 is reserved for end without replaces.
*/
8250

8251
int find_found(FOUND_SET *found_set,uint table_offset, int found_offset)
8252 8253 8254 8255 8256 8257 8258 8259 8260 8261 8262 8263
{
  int i;
  for (i=0 ; (uint) i < found_sets ; i++)
    if (found_set[i].table_offset == table_offset &&
	found_set[i].found_offset == found_offset)
      return -i-2;
  found_set[i].table_offset=table_offset;
  found_set[i].found_offset=found_offset;
  found_sets++;
  return -i-2;				/* return new postion */
}

8264
/* Return 1 if regexp starts with \b or ends with \b*/
8265

8266
uint start_at_word(my_string pos)
8267 8268 8269 8270
{
  return (((!bcmp(pos,"\\b",2) && pos[2]) || !bcmp(pos,"\\^",2)) ? 1 : 0);
}

8271
uint end_of_word(my_string pos)
8272 8273 8274 8275
{
  my_string end=strend(pos);
  return ((end > pos+2 && !bcmp(end-2,"\\b",2)) ||
	  (end >= pos+2 && !bcmp(end-2,"\\$",2))) ?
8276
    1 : 0;
8277 8278
}

8279 8280 8281
/****************************************************************************
 * Handle replacement of strings
 ****************************************************************************/
8282

8283 8284
#define PC_MALLOC		256	/* Bytes for pointers */
#define PS_MALLOC		512	/* Bytes for data */
8285

8286
int insert_pointer_name(reg1 POINTER_ARRAY *pa,my_string name)
8287
{
8288 8289 8290 8291
  uint i,length,old_count;
  byte *new_pos;
  const char **new_array;
  DBUG_ENTER("insert_pointer_name");
8292

8293
  if (! pa->typelib.count)
8294
  {
8295 8296 8297 8298 8299 8300 8301
    if (!(pa->typelib.type_names=(const char **)
	  my_malloc(((PC_MALLOC-MALLOC_OVERHEAD)/
		     (sizeof(my_string)+sizeof(*pa->flag))*
		     (sizeof(my_string)+sizeof(*pa->flag))),MYF(MY_WME))))
      DBUG_RETURN(-1);
    if (!(pa->str= (byte*) my_malloc((uint) (PS_MALLOC-MALLOC_OVERHEAD),
				     MYF(MY_WME))))
8302
    {
8303 8304
      my_free((gptr) pa->typelib.type_names,MYF(0));
      DBUG_RETURN (-1);
8305
    }
8306 8307 8308 8309 8310 8311
    pa->max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(byte*)+
					       sizeof(*pa->flag));
    pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
    pa->length=0;
    pa->max_length=PS_MALLOC-MALLOC_OVERHEAD;
    pa->array_allocs=1;
8312
  }
8313 8314
  length=(uint) strlen(name)+1;
  if (pa->length+length >= pa->max_length)
8315
  {
8316 8317 8318 8319 8320
    if (!(new_pos= (byte*) my_realloc((gptr) pa->str,
				      (uint) (pa->max_length+PS_MALLOC),
				      MYF(MY_WME))))
      DBUG_RETURN(1);
    if (new_pos != pa->str)
8321
    {
8322 8323 8324 8325 8326
      my_ptrdiff_t diff=PTR_BYTE_DIFF(new_pos,pa->str);
      for (i=0 ; i < pa->typelib.count ; i++)
	pa->typelib.type_names[i]= ADD_TO_PTR(pa->typelib.type_names[i],diff,
					      char*);
      pa->str=new_pos;
8327
    }
8328
    pa->max_length+=PS_MALLOC;
8329
  }
8330
  if (pa->typelib.count >= pa->max_count-1)
8331
  {
8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344 8345 8346
    int len;
    pa->array_allocs++;
    len=(PC_MALLOC*pa->array_allocs - MALLOC_OVERHEAD);
    if (!(new_array=(const char **) my_realloc((gptr) pa->typelib.type_names,
					       (uint) len/
                                               (sizeof(byte*)+sizeof(*pa->flag))*
                                               (sizeof(byte*)+sizeof(*pa->flag)),
                                               MYF(MY_WME))))
      DBUG_RETURN(1);
    pa->typelib.type_names=new_array;
    old_count=pa->max_count;
    pa->max_count=len/(sizeof(byte*) + sizeof(*pa->flag));
    pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
    memcpy((byte*) pa->flag,(my_string) (pa->typelib.type_names+old_count),
	   old_count*sizeof(*pa->flag));
8347
  }
8348 8349 8350 8351 8352 8353 8354
  pa->flag[pa->typelib.count]=0;			/* Reset flag */
  pa->typelib.type_names[pa->typelib.count++]= pa->str+pa->length;
  pa->typelib.type_names[pa->typelib.count]= NullS;	/* Put end-mark */
  VOID(strmov(pa->str+pa->length,name));
  pa->length+=length;
  DBUG_RETURN(0);
} /* insert_pointer_name */
monty@mysql.com's avatar
monty@mysql.com committed
8355 8356


8357
/* free pointer array */
monty@mysql.com's avatar
monty@mysql.com committed
8358

8359 8360 8361 8362 8363 8364 8365 8366 8367 8368
void free_pointer_array(POINTER_ARRAY *pa)
{
  if (pa->typelib.count)
  {
    pa->typelib.count=0;
    my_free((gptr) pa->typelib.type_names,MYF(0));
    pa->typelib.type_names=0;
    my_free((gptr) pa->str,MYF(0));
  }
} /* free_pointer_array */
monty@mysql.com's avatar
monty@mysql.com committed
8369 8370


8371
/* Functions that uses replace and replace_regex */
monty@mysql.com's avatar
monty@mysql.com committed
8372

8373 8374 8375
/* Append the string to ds, with optional replace */
void replace_dynstr_append_mem(DYNAMIC_STRING *ds,
                               const char *val, int len)
monty@mysql.com's avatar
monty@mysql.com committed
8376
{
8377 8378 8379
#ifdef __WIN__
  fix_win_paths(val, len);
#endif
monty@mysql.com's avatar
monty@mysql.com committed
8380

8381
  if (glob_replace_regex)
monty@mysql.com's avatar
monty@mysql.com committed
8382
  {
8383 8384
    /* Regex replace */
    if (!multi_reg_replace(glob_replace_regex, (char*)val))
monty@mysql.com's avatar
monty@mysql.com committed
8385
    {
8386 8387
      val= glob_replace_regex->buf;
      len= strlen(val);
monty@mysql.com's avatar
monty@mysql.com committed
8388 8389 8390
    }
  }

8391 8392 8393 8394 8395 8396 8397 8398
  if (glob_replace)
  {
    /* Normal replace */
    replace_strings_append(glob_replace, ds, val, len);
  }
  else
    dynstr_append_mem(ds, val, len);
}
monty@mysql.com's avatar
monty@mysql.com committed
8399 8400


8401 8402
/* Append zero-terminated string to ds, with optional replace */
void replace_dynstr_append(DYNAMIC_STRING *ds, const char *val)
monty@mysql.com's avatar
monty@mysql.com committed
8403
{
8404 8405
  replace_dynstr_append_mem(ds, val, strlen(val));
}
8406

8407 8408 8409 8410 8411 8412
/* Append uint to ds, with optional replace */
void replace_dynstr_append_uint(DYNAMIC_STRING *ds, uint val)
{
  char buff[22]; /* This should be enough for any int */
  char *end= longlong10_to_str(val, buff, 10);
  replace_dynstr_append_mem(ds, buff, end - buff);
monty@mysql.com's avatar
monty@mysql.com committed
8413
}
8414 8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425 8426 8427 8428 8429 8430 8431 8432 8433 8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473 8474 8475 8476 8477 8478 8479 8480 8481 8482 8483



/*
  Build a list of pointer to each line in ds_input, sort
  the list and use the sorted list to append the strings
  sorted to the output ds

  SYNOPSIS
  dynstr_append_sorted
  ds - string where the sorted output will be appended
  ds_input - string to be sorted

*/

static int comp_lines(const char **a, const char **b)
{
  return (strcmp(*a,*b));
}

void dynstr_append_sorted(DYNAMIC_STRING* ds, DYNAMIC_STRING *ds_input)
{
  unsigned i;
  char *start= ds_input->str;
  DYNAMIC_ARRAY lines;
  DBUG_ENTER("dynstr_append_sorted");

  if (!*start)
    DBUG_VOID_RETURN;  /* No input */

  my_init_dynamic_array(&lines, sizeof(const char*), 32, 32);

  /* First line is result header, skip past it */
  while (*start && *start != '\n')
    start++;
  start++; /* Skip past \n */
  dynstr_append_mem(ds, ds_input->str, start - ds_input->str);

  /* Insert line(s) in array */
  while (*start)
  {
    char* line_end= (char*)start;

    /* Find end of line */
    while (*line_end && *line_end != '\n')
      line_end++;
    *line_end= 0;

    /* Insert pointer to the line in array */
    if (insert_dynamic(&lines, (gptr) &start))
      die("Out of memory inserting lines to sort");

    start= line_end+1;
  }

  /* Sort array */
  qsort(lines.buffer, lines.elements,
        sizeof(char**), (qsort_cmp)comp_lines);

  /* Create new result */
  for (i= 0; i < lines.elements ; i++)
  {
    const char **line= dynamic_element(&lines, i, const char**);
    dynstr_append(ds, *line);
    dynstr_append(ds, "\n");
  }

  delete_dynamic(&lines);
  DBUG_VOID_RETURN;
}