mysqltest.c 88.3 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB
2

unknown's avatar
unknown committed
3 4 5 6
   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
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
7

unknown's avatar
unknown committed
8 9 10 11
   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.
12

unknown's avatar
unknown committed
13 14 15 16 17
   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 */

/* mysqltest test tool
18 19
 * See the manual for more information
 * TODO: document better how mysqltest works
unknown's avatar
unknown committed
20 21 22 23
 *
 * Written by:
 *   Sasha Pachev <sasha@mysql.com>
 *   Matt Wagner  <matt@mysql.com>
24
 *   Monty
25
 *   Jani
unknown's avatar
unknown committed
26 27
 **/

28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
/**********************************************************************
  TODO:

- Do comparison line by line, instead of doing a full comparison of
  the text file.  This will save space as we don't need to keep many
  results in memory.  It will also make it possible to do simple
  'comparison' fixes like accepting the result even if a float differed
  in the last decimals.

- Don't buffer lines from the test that you don't expect to need
  again.

- Change 'read_line' to be faster by using the readline.cc code;
  We can do better than calling feof() for each character!

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

45
#define MTEST_VERSION "2.1"
46

unknown's avatar
unknown committed
47
#include <my_global.h>
unknown's avatar
unknown committed
48
#include <mysql_embed.h>
49 50 51 52
#include <my_sys.h>
#include <m_string.h>
#include <mysql.h>
#include <mysql_version.h>
unknown's avatar
unknown committed
53
#include <mysqld_error.h>
54 55
#include <m_ctype.h>
#include <my_dir.h>
unknown's avatar
unknown committed
56
#include <hash.h>
57
#include <my_getopt.h>
unknown's avatar
unknown committed
58 59
#include <stdarg.h>
#include <sys/stat.h>
unknown's avatar
unknown committed
60
#include <violite.h>
unknown's avatar
unknown committed
61

62 63
#define MAX_QUERY	65536
#define MAX_COLUMNS	256
64
#define PAD_SIZE	128
65
#define MAX_CONS	128
unknown's avatar
unknown committed
66
#define MAX_INCLUDE_DEPTH 16
unknown's avatar
unknown committed
67
#define LAZY_GUESS_BUF_SIZE 8192
68 69
#define INIT_Q_LINES	  1024
#define MIN_VAR_ALLOC	  32
70
#define BLOCK_STACK_DEPTH  32
71
#define MAX_EXPECTED_ERRORS 10
unknown's avatar
unknown committed
72 73
#define QUERY_SEND  1
#define QUERY_REAP  2
74 75 76
#ifndef MYSQL_MANAGER_PORT
#define MYSQL_MANAGER_PORT 23546
#endif
77
#define MAX_SERVER_ARGS 20
78

unknown's avatar
unknown committed
79 80 81 82 83 84 85
/*
  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
*/
#define CON_RETRY_SLEEP 2
86
#define MAX_CON_TRIES	5
unknown's avatar
unknown committed
87

88
#define SLAVE_POLL_INTERVAL 300000 /* 0.3 of a sec */
89 90
#define DEFAULT_DELIMITER ";"
#define MAX_DELIMITER 16
91

92
enum {OPT_MANAGER_USER=256,OPT_MANAGER_HOST,OPT_MANAGER_PASSWD,
unknown's avatar
unknown committed
93 94 95
      OPT_MANAGER_PORT,OPT_MANAGER_WAIT_TIMEOUT, OPT_SKIP_SAFEMALLOC,
      OPT_SSL_SSL, OPT_SSL_KEY, OPT_SSL_CERT, OPT_SSL_CA, OPT_SSL_CAPATH,
      OPT_SSL_CIPHER};
unknown's avatar
unknown committed
96

97
static int record = 0, opt_sleep=0;
unknown's avatar
unknown committed
98
static char *db = 0, *pass=0;
99
const char* user = 0, *host = 0, *unix_sock = 0, *opt_basedir="./";
100 101
static int port = 0;
static my_bool opt_big_test= 0, opt_compress= 0, silent= 0, verbose = 0,
102
	       tty_password= 0;
103
static uint start_lineno, *lineno;
104
const char* manager_user="root",*manager_host=0;
105 106 107 108
char *manager_pass=0;
int manager_port=MYSQL_MANAGER_PORT;
int manager_wait_timeout=3;
MYSQL_MANAGER* manager=0;
109

110
static char **default_argv;
unknown's avatar
unknown committed
111 112
static const char *load_default_groups[]= { "mysqltest","client",0 };

unknown's avatar
unknown committed
113 114 115 116 117
static FILE* file_stack[MAX_INCLUDE_DEPTH];
static FILE** cur_file;
static FILE** file_stack_end;
static uint lineno_stack[MAX_INCLUDE_DEPTH];
static char TMPDIR[FN_REFLEN];
118 119
static char delimiter[MAX_DELIMITER]= DEFAULT_DELIMITER;
static uint delimiter_length= 1;
unknown's avatar
unknown committed
120

unknown's avatar
unknown committed
121
static int *cur_block, *block_stack_end;
122 123 124
static int block_stack[BLOCK_STACK_DEPTH];

static int block_ok_stack[BLOCK_STACK_DEPTH];
unknown's avatar
unknown committed
125
static uint global_expected_errno[MAX_EXPECTED_ERRORS], global_expected_errors;
unknown's avatar
unknown committed
126
static CHARSET_INFO *charset_info= &my_charset_latin1;
127

128 129 130
static int embedded_server_arg_count=0;
static char *embedded_server_args[MAX_SERVER_ARGS];

131 132
static my_bool display_result_vertically= FALSE;

133 134 135 136 137 138 139
static const char *embedded_server_groups[] = {
  "server",
  "embedded",
  "mysqltest_SERVER",
  NullS
};

140 141
DYNAMIC_ARRAY q_lines;

unknown's avatar
unknown committed
142 143
#include "sslopt-vars.h"

144
typedef struct
unknown's avatar
unknown committed
145 146 147 148 149
{
  char file[FN_REFLEN];
  ulong pos;
} MASTER_POS ;

unknown's avatar
unknown committed
150 151 152 153 154 155
struct connection
{
  MYSQL mysql;
  char *name;
};

unknown's avatar
unknown committed
156 157 158 159
typedef struct
{
  int read_lines,current_line;
} PARSER;
160

161 162
MYSQL_RES *last_result=0;

163
PARSER parser;
unknown's avatar
unknown committed
164
MASTER_POS master_pos;
unknown's avatar
unknown committed
165
int *block_ok; /* set to 0 if the current block should not be executed */
166
int false_block_depth = 0;
unknown's avatar
unknown committed
167 168
/* if set, all results are concated and compared against this file */
const char *result_file = 0;
169

170
typedef struct
171
{
unknown's avatar
unknown committed
172
  char *name;
unknown's avatar
unknown committed
173
  int name_len;
unknown's avatar
unknown committed
174
  char *str_val;
175 176 177 178
  int str_val_len;
  int int_val;
  int alloced_len;
  int int_dirty; /* do not update string if int is updated until first read */
unknown's avatar
unknown committed
179
  int alloced;
180 181 182 183
} VAR;

VAR var_reg[10];
/*Perl/shell-like variable registers */
unknown's avatar
unknown committed
184
HASH var_hash;
185 186
my_bool disable_query_log=0, disable_result_log=0, disable_warnings=0;
my_bool disable_info= 1;			/* By default off */
187

unknown's avatar
unknown committed
188 189 190
struct connection cons[MAX_CONS];
struct connection* cur_con, *next_con, *cons_end;

unknown's avatar
unknown committed
191 192 193
  /* Add new commands before Q_UNKNOWN !*/

enum enum_commands {
194
Q_CONNECTION=1,     Q_QUERY,
195
Q_CONNECT,	    Q_SLEEP, Q_REAL_SLEEP, 
196 197 198 199 200 201
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,
202 203 204
Q_SYNC_WITH_MASTER,
Q_SYNC_SLAVE_WITH_MASTER,
Q_ERROR,
205
Q_SEND,		    Q_REAP,
206
Q_DIRTY_CLOSE,	    Q_REPLACE, Q_REPLACE_COLUMN,
207 208
Q_PING,		    Q_EVAL,
Q_RPL_PROBE,	    Q_ENABLE_RPL_PARSE,
209
Q_DISABLE_RPL_PARSE, Q_EVAL_RESULT,
unknown's avatar
unknown committed
210
Q_ENABLE_QUERY_LOG, Q_DISABLE_QUERY_LOG,
unknown's avatar
unknown committed
211
Q_ENABLE_RESULT_LOG, Q_DISABLE_RESULT_LOG,
212
Q_SERVER_START, Q_SERVER_STOP,Q_REQUIRE_MANAGER,
213
Q_WAIT_FOR_SLAVE_TO_STOP,
214
Q_REQUIRE_VERSION,
215 216
Q_ENABLE_WARNINGS, Q_DISABLE_WARNINGS,
Q_ENABLE_INFO, Q_DISABLE_INFO,
217
Q_EXEC, Q_DELIMITER,
218 219
Q_DISPLAY_VERTICAL_RESULTS, Q_DISPLAY_HORIZONTAL_RESULTS,
Q_QUERY_VERTICAL, Q_QUERY_HORIZONTAL,
220

221 222
Q_UNKNOWN,			       /* Unknown command.   */
Q_COMMENT,			       /* Comments, ignored. */
unknown's avatar
unknown committed
223 224 225
Q_COMMENT_WITH_COMMAND
};

226
/* this should really be called command */
227
struct st_query
unknown's avatar
unknown committed
228
{
229
  char *query, *query_buf,*first_argument,*end;
unknown's avatar
unknown committed
230
  int first_word_len;
231
  my_bool abort_on_error, require_file;
232
  uint expected_errno[MAX_EXPECTED_ERRORS];
unknown's avatar
unknown committed
233
  uint expected_errors;
unknown's avatar
unknown committed
234
  char record_file[FN_REFLEN];
unknown's avatar
unknown committed
235
  enum enum_commands type;
unknown's avatar
unknown committed
236 237
};

238 239 240 241 242
const char *command_names[]=
{
  "connection",
  "query",
  "connect",
unknown's avatar
unknown committed
243 244 245 246 247 248 249
  /* the difference between sleep and real_sleep is that sleep will use
     the delay from command line (--sleep) if there is one.
     real_sleep always uses delay from it's 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
   */
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
  "sleep",
  "real_sleep",
  "inc",
  "dec",
  "source",
  "disconnect",
  "let",
  "echo",
  "while",
  "end",
  "system",
  "result",
  "require",
  "save_master_pos",
  "sync_with_master",
265
  "sync_slave_with_master",
266 267 268 269 270
  "error",
  "send",
  "reap",
  "dirty_close",
  "replace_result",
271
  "replace_column",
272 273 274 275 276 277 278 279 280 281 282 283 284 285
  "ping",
  "eval",
  "rpl_probe",
  "enable_rpl_parse",
  "disable_rpl_parse",
  "eval_result",
  "enable_query_log",
  "disable_query_log",
  "enable_result_log",
  "disable_result_log",
  "server_start",
  "server_stop",
  "require_manager",
  "wait_for_slave_to_stop",
286
  "require_version",
287 288 289
  "enable_warnings",
  "disable_warnings",
  "enable_info",
290
  "disable_info",
291
  "exec",
292
  "delimiter",
293
  "vertical_results",
294
  "horizontal_results",
295
  "query_vertical",
296
  "query_horizontal",
unknown's avatar
unknown committed
297
  0
298 299 300 301 302
};

TYPELIB command_typelib= {array_elements(command_names),"",
			  command_names};

303
DYNAMIC_STRING ds_res;
unknown's avatar
unknown committed
304
static void die(const char *fmt, ...);
unknown's avatar
unknown committed
305 306
static void init_var_hash();
static byte* get_var_key(const byte* rec, uint* len,
unknown's avatar
unknown committed
307
			 my_bool __attribute__((unused)) t);
unknown's avatar
unknown committed
308
static VAR* var_init(VAR* v, const char *name, int name_len, const char *val,
unknown's avatar
unknown committed
309 310 311
		     int val_len);

static void var_free(void* v);
312

unknown's avatar
unknown committed
313 314
int dyn_string_cmp(DYNAMIC_STRING* ds, const char *fname);
void reject_dump(const char *record_file, char *buf, int size);
unknown's avatar
unknown committed
315

316
int close_connection(struct st_query* q);
317 318
VAR* var_get(const char *var_name, const char** var_name_end, my_bool raw,
	     my_bool ignore_not_existing);
unknown's avatar
unknown committed
319 320
int eval_expr(VAR* v, const char *p, const char** p_end);
static int read_server_arguments(const char *name);
321

322
/* Definitions for replace result */
unknown's avatar
unknown committed
323 324 325 326 327

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. */
328
  uint	array_allocs,max_count,length,max_length;
unknown's avatar
unknown committed
329 330 331 332 333 334
} POINTER_ARRAY;

struct st_replace;
struct st_replace *init_replace(my_string *from, my_string *to, uint count,
				my_string word_end_chars);
uint replace_strings(struct st_replace *rep, my_string *start,
unknown's avatar
unknown committed
335
		     uint *max_length, const char *from);
336
void free_replace();
unknown's avatar
unknown committed
337 338 339 340
static int insert_pointer_name(reg1 POINTER_ARRAY *pa,my_string name);
void free_pointer_array(POINTER_ARRAY *pa);
static int initialize_replace_buffer(void);
static void free_replace_buffer(void);
unknown's avatar
unknown committed
341 342 343
static void do_eval(DYNAMIC_STRING* query_eval, const char *query);
void str_to_file(const char *fname, char *str, int size);
int do_server_op(struct st_query* q,const char *op);
unknown's avatar
unknown committed
344 345 346 347

struct st_replace *glob_replace;
static char *out_buff;
static uint out_length;
348
static int eval_result = 0;
unknown's avatar
unknown committed
349

350 351 352 353 354 355 356
/* For column replace */
char *replace_column[MAX_COLUMNS];
uint max_replace_column= 0;

static void get_replace_column(struct st_query *q);
static void free_replace_column();

unknown's avatar
unknown committed
357
/* Disable functions that only exist in MySQL 4.0 */
unknown's avatar
SCRUM  
unknown committed
358
#if MYSQL_VERSION_ID < 40000
unknown's avatar
unknown committed
359 360 361
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; }
362
my_bool mysql_rpl_probe(MYSQL *mysql __attribute__((unused))) { return 1; }
unknown's avatar
unknown committed
363
#endif
364 365
static void replace_dynstr_append_mem(DYNAMIC_STRING *ds, const char *val,
				      int len);
366

367 368 369 370 371 372
static void do_eval(DYNAMIC_STRING* query_eval, const char* query)
{
  const char* p;
  register char c;
  register int escaped = 0;
  VAR* v;
unknown's avatar
unknown committed
373

374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
  for (p= query; (c = *p); ++p)
  {
    switch(c) {
    case '$':
      if (escaped)
      {
	escaped = 0;
	dynstr_append_mem(query_eval, p, 1);
      }
      else
      {
	if (!(v = var_get(p, &p, 0, 0)))
	  die("Bad variable in eval");
	dynstr_append_mem(query_eval, v->str_val, v->str_val_len);
      }
      break;
    case '\\':
      if (escaped)
      {
	escaped = 0;
	dynstr_append_mem(query_eval, p, 1);
      }
      else
	escaped = 1;
      break;
    default:
      dynstr_append_mem(query_eval, p, 1);
      break;
402
    }
403
  }
404
}
unknown's avatar
unknown committed
405

406

407 408
static void close_cons()
{
409
  DBUG_ENTER("close_cons");
410 411
  if (last_result)
    mysql_free_result(last_result);
412 413 414 415 416 417 418 419
  for (--next_con; next_con >= cons; --next_con)
  {
    mysql_close(&next_con->mysql);
    my_free(next_con->name, MYF(MY_ALLOW_ZERO_PTR));
  }
  DBUG_VOID_RETURN;
}

420

421 422
static void close_files()
{
unknown's avatar
unknown committed
423 424
  DBUG_ENTER("close_files");
  for (; cur_file != file_stack ; cur_file--)
425
  {
426
    if (*cur_file != stdin && *cur_file)
427
      my_fclose(*cur_file,MYF(0));
unknown's avatar
unknown committed
428 429
  }
  DBUG_VOID_RETURN;
430 431
}

432

433 434 435 436
static void free_used_memory()
{
  uint i;
  DBUG_ENTER("free_used_memory");
437
#ifndef EMBEDDED_LIBRARY
438 439
  if (manager)
    mysql_manager_close(manager);
440
#endif
441 442
  close_cons();
  close_files();
unknown's avatar
unknown committed
443
  hash_free(&var_hash);
unknown's avatar
unknown committed
444

445 446 447
  for (i=0 ; i < q_lines.elements ; i++)
  {
    struct st_query **q= dynamic_element(&q_lines, i, struct st_query**);
448
    my_free((gptr) (*q)->query_buf,MYF(MY_ALLOW_ZERO_PTR));
449 450
    my_free((gptr) (*q),MYF(0));
  }
451
  for (i=0; i < 10; i++)
unknown's avatar
unknown committed
452 453 454 455
  {
    if (var_reg[i].alloced_len)
      my_free(var_reg[i].str_val, MYF(MY_WME));
  }
456 457
  while (embedded_server_arg_count > 1)
    my_free(embedded_server_args[--embedded_server_arg_count],MYF(0));
458 459
  delete_dynamic(&q_lines);
  dynstr_free(&ds_res);
unknown's avatar
unknown committed
460
  free_replace();
461
  free_replace_column();
462 463
  my_free(pass,MYF(MY_ALLOW_ZERO_PTR));
  free_defaults(default_argv);
unknown's avatar
unknown committed
464
  mysql_server_end();
465 466
  my_end(MY_CHECK_ERROR);
  DBUG_VOID_RETURN;
467 468 469 470 471
}

static void die(const char* fmt, ...)
{
  va_list args;
472
  DBUG_ENTER("die");
473
  va_start(args, fmt);
474 475 476 477 478
  if (fmt)
  {
    fprintf(stderr, "%s: ", my_progname);
    vfprintf(stderr, fmt, args);
    fprintf(stderr, "\n");
unknown's avatar
unknown committed
479
    fflush(stderr);
480
  }
481
  va_end(args);
482
  free_used_memory();
483 484 485
  exit(1);
}

486 487
/* Note that we will get some memory leaks when calling this! */

488 489
static void abort_not_supported_test()
{
490
  DBUG_ENTER("abort_not_supported_test");
491 492 493
  fprintf(stderr, "This test is not supported by this installation\n");
  if (!silent)
    printf("skipped\n");
494
  free_used_memory();
495 496 497 498 499 500
  exit(2);
}

static void verbose_msg(const char* fmt, ...)
{
  va_list args;
501 502 503
  DBUG_ENTER("verbose_msg");
  if (!verbose)
    DBUG_VOID_RETURN;
504 505 506

  va_start(args, fmt);

507
  fprintf(stderr, "%s: At line %u: ", my_progname, start_lineno);
508 509 510
  vfprintf(stderr, fmt, args);
  fprintf(stderr, "\n");
  va_end(args);
511
  DBUG_VOID_RETURN;
512 513
}

unknown's avatar
unknown committed
514

515 516 517 518 519
void init_parser()
{
  parser.current_line = parser.read_lines = 0;
  memset(&var_reg,0, sizeof(var_reg));
}
unknown's avatar
unknown committed
520 521


522
int dyn_string_cmp(DYNAMIC_STRING* ds, const char* fname)
unknown's avatar
unknown committed
523 524
{
  MY_STAT stat_info;
525 526
  char *tmp, *res_ptr;
  char eval_file[FN_REFLEN];
unknown's avatar
unknown committed
527
  int res;
528
  uint res_len;
unknown's avatar
unknown committed
529
  int fd;
530
  DYNAMIC_STRING res_ds;
531 532
  DBUG_ENTER("dyn_string_cmp");

533 534 535 536 537 538 539 540 541
  if (!test_if_hard_path(fname))
  {
    strxmov(eval_file, opt_basedir, fname, NullS);
    fn_format(eval_file, eval_file,"","",4);
  }
  else
    fn_format(eval_file, fname,"","",4);

  if (!my_stat(eval_file, &stat_info, MYF(MY_WME)))
542
    die(NullS);
543 544 545 546
  if (!eval_result && (uint) stat_info.st_size != ds->length)
  {
    DBUG_PRINT("info",("Size differs:  result size: %u  file size: %u",
		       ds->length, stat_info.st_size));
547
    DBUG_RETURN(2);
548
  }
549
  if (!(tmp = (char*) my_malloc(stat_info.st_size + 1, MYF(MY_WME))))
550
    die(NullS);
551 552

  if ((fd = my_open(eval_file, O_RDONLY, MYF(MY_WME))) < 0)
553
    die(NullS);
554
  if (my_read(fd, (byte*)tmp, stat_info.st_size, MYF(MY_WME|MY_NABP)))
555
    die(NullS);
556 557 558 559 560 561
  tmp[stat_info.st_size] = 0;
  init_dynamic_string(&res_ds, "", 0, 65536);
  if (eval_result)
  {
    do_eval(&res_ds, tmp);
    res_ptr = res_ds.str;
562
    if ((res_len = res_ds.length) != ds->length)
563 564 565 566 567 568 569 570 571 572
    {
      res = 2;
      goto err;
    }
  }
  else
  {
    res_ptr = tmp;
    res_len = stat_info.st_size;
  }
unknown's avatar
unknown committed
573

574
  res = (memcmp(res_ptr, ds->str, res_len)) ?  1 : 0;
unknown's avatar
unknown committed
575

576 577 578 579
err:
  if (res && eval_result)
    str_to_file(fn_format(eval_file, fname, "", ".eval",2), res_ptr,
		res_len);
unknown's avatar
unknown committed
580

581 582
  my_free((gptr) tmp, MYF(0));
  my_close(fd, MYF(MY_WME));
583
  dynstr_free(&res_ds);
unknown's avatar
unknown committed
584

585
  DBUG_RETURN(res);
unknown's avatar
unknown committed
586 587
}

588
static int check_result(DYNAMIC_STRING* ds, const char* fname,
589
			my_bool require_option)
unknown's avatar
unknown committed
590 591
{
  int error = 0;
592 593 594 595
  int res=dyn_string_cmp(ds, fname);

  if (res && require_option)
    abort_not_supported_test();
596
  switch (res) {
597 598 599 600 601 602 603 604 605 606 607 608 609 610
  case 0:
    break; /* ok */
  case 2:
    verbose_msg("Result length mismatch");
    error = 1;
    break;
  case 1:
    verbose_msg("Result content mismatch");
    error = 1;
    break;
  default: /* impossible */
    die("Unknown error code from dyn_string_cmp()");
  }
  if (error)
611
    reject_dump(fname, ds->str, ds->length);
unknown's avatar
unknown committed
612 613 614
  return error;
}

615 616
VAR* var_get(const char* var_name, const char** var_name_end, my_bool raw,
	     my_bool ignore_not_existing)
617 618 619
{
  int digit;
  VAR* v;
620 621 622 623
  DBUG_ENTER("var_get");
  DBUG_PRINT("enter",("var_name: %s",var_name));

  if (*var_name != '$')
624
    goto err;
625
  digit = *++var_name - '0';
626 627
  if (!(digit < 10 && digit >= 0))
  {
unknown's avatar
unknown committed
628 629
    const char* save_var_name = var_name, *end;
    end = (var_name_end) ? *var_name_end : 0;
630
    while (my_isvar(charset_info,*var_name) && var_name != end)
631
      ++var_name;
632 633 634 635
    if (var_name == save_var_name)
    {
      if (ignore_not_existing)
	DBUG_RETURN(0);
unknown's avatar
unknown committed
636
      die("Empty variable");
637
    }
unknown's avatar
unknown committed
638

639
    if (!(v = (VAR*) hash_search(&var_hash, save_var_name,
unknown's avatar
unknown committed
640
			       var_name - save_var_name)))
641 642 643 644 645 646 647 648
    {
      if (ignore_not_existing)
	DBUG_RETURN(0);
      if (end)
	*(char*) end = 0;
      die("Variable '%s' used uninitialized", save_var_name);
    }
    --var_name;					/* Point at last character */
649
  }
650
  else
651
    v = var_reg + digit;
unknown's avatar
unknown committed
652

653 654 655 656
  if (!raw && v->int_dirty)
  {
    sprintf(v->str_val, "%d", v->int_val);
    v->int_dirty = 0;
657
    v->str_val_len = strlen(v->str_val);
658
  }
659
  if (var_name_end)
660
    *var_name_end = var_name  ;
661
  DBUG_RETURN(v);
662 663
err:
  if (var_name_end)
664 665
    *var_name_end = 0;
  die("Unsupported variable name: %s", var_name);
666
  DBUG_RETURN(0);
667 668
}

unknown's avatar
unknown committed
669 670 671
static VAR* var_obtain(char* name, int len)
{
  VAR* v;
672
  if ((v = (VAR*)hash_search(&var_hash, name, len)))
unknown's avatar
unknown committed
673
    return v;
674
  v = var_init(0, name, len, "", 0);
unknown's avatar
SCRUM  
unknown committed
675
  my_hash_insert(&var_hash, (byte*)v);
unknown's avatar
unknown committed
676 677 678
  return v;
}

679 680 681 682 683
int var_set(char* var_name, char* var_name_end, char* var_val,
	    char* var_val_end)
{
  int digit;
  VAR* v;
684
  if (*var_name++ != '$')
685 686 687 688 689 690
    {
      --var_name;
      *var_name_end = 0;
      die("Variable name in %s does not start with '$'", var_name);
    }
  digit = *var_name - '0';
691
  if (!(digit < 10 && digit >= 0))
692
    {
unknown's avatar
unknown committed
693
      v = var_obtain(var_name, var_name_end - var_name);
694
    }
695
  else
unknown's avatar
unknown committed
696
   v = var_reg + digit;
unknown's avatar
unknown committed
697

698
  return eval_expr(v, var_val, (const char**)&var_val_end);
699 700
}

unknown's avatar
unknown committed
701 702
int open_file(const char* name)
{
703 704 705 706 707 708 709 710
  char buff[FN_REFLEN];
  if (!test_if_hard_path(name))
  {
    strxmov(buff, opt_basedir, name, NullS);
    name=buff;
  }
  fn_format(buff,name,"","",4);

711
  if (*cur_file && cur_file == file_stack_end)
unknown's avatar
unknown committed
712
    die("Source directives are nesting too deep");
unknown's avatar
unknown committed
713
  if (!(*(cur_file+1) = my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
714 715
    die(NullS);
  cur_file++;
716
  *++lineno=1;
717

unknown's avatar
unknown committed
718 719 720
  return 0;
}

unknown's avatar
unknown committed
721

722
/* ugly long name, but we are following the convention */
unknown's avatar
unknown committed
723
int do_wait_for_slave_to_stop(struct st_query* q __attribute__((unused)))
724 725 726 727
{
  MYSQL* mysql = &cur_con->mysql;
  for (;;)
  {
unknown's avatar
unknown committed
728
    MYSQL_RES *res;
729 730 731
    MYSQL_ROW row;
    int done;
    LINT_INIT(res);
732

unknown's avatar
unknown committed
733 734
    if (mysql_query(mysql,"show status like 'Slave_running'") ||
	!(res=mysql_store_result(mysql)))
735 736 737 738 739 740 741 742 743 744 745
      die("Query failed while probing slave for stop: %s",
	  mysql_error(mysql));
    if (!(row=mysql_fetch_row(res)) || !row[1])
    {
      mysql_free_result(res);
      die("Strange result from query while probing slave for stop");
    }
    done = !strcmp(row[1],"OFF");
    mysql_free_result(res);
    if (done)
      break;
unknown's avatar
unknown committed
746
    my_sleep(SLAVE_POLL_INTERVAL);
747 748 749 750
  }
  return 0;
}

unknown's avatar
unknown committed
751
int do_require_manager(struct st_query* a __attribute__((unused)))
752 753 754 755 756 757
{
  if (!manager)
    abort_not_supported_test();
  return 0;
}

758
#ifndef EMBEDDED_LIBRARY
759 760 761 762 763 764 765 766 767 768 769 770 771 772
int do_server_start(struct st_query* q)
{
  return do_server_op(q,"start");
}

int do_server_stop(struct st_query* q)
{
  return do_server_op(q,"stop");
}

int do_server_op(struct st_query* q,const char* op)
{
  char* p=q->first_argument;
  char com_buf[256],*com_p;
773 774 775 776
  if (!manager)
  {
    die("Manager is not initialized, manager commands are not possible");
  }
777 778 779 780
  com_p=strmov(com_buf,op);
  com_p=strmov(com_p,"_exec ");
  if (!*p)
    die("Missing server name in server_%s\n",op);
781
  while (*p && !my_isspace(charset_info,*p))
unknown's avatar
unknown committed
782
   *com_p++= *p++;
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
  *com_p++=' ';
  com_p=int10_to_str(manager_wait_timeout,com_p,10);
  *com_p++ = '\n';
  *com_p=0;
  if (mysql_manager_command(manager,com_buf,(int)(com_p-com_buf)))
    die("Error in command: %s(%d)",manager->last_error,manager->last_errno);
  while (!manager->eof)
  {
    if (mysql_manager_fetch_line(manager,com_buf,sizeof(com_buf)))
      die("Error fetching result line: %s(%d)", manager->last_error,
	  manager->last_errno);
  }

  return 0;
}
798
#endif
799

800 801 802 803 804 805 806 807
int do_require_version(struct st_query* q)
{
  MYSQL* mysql = &cur_con->mysql;
  MYSQL_RES* res;
  MYSQL_ROW row;
  char* p=q->first_argument, *ver_arg;
  uint ver_arg_len,ver_len;
  LINT_INIT(res);
808

809 810 811
  if (!*p)
    die("Missing version argument in require_version\n");
  ver_arg = p;
812
  while (*p && !my_isspace(charset_info,*p))
813 814 815
    p++;
  *p = 0;
  ver_arg_len = p - ver_arg;
816

817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
  if (mysql_query(mysql, "select version()") ||
      !(res=mysql_store_result(mysql)))
    die("Query failed while check server version: %s",
	mysql_error(mysql));
  if (!(row=mysql_fetch_row(res)) || !row[0])
  {
    mysql_free_result(res);
    die("Strange result from query while checking version");
  }
  ver_len = strlen(row[0]);
  if (ver_len < ver_arg_len || memcmp(row[0],ver_arg,ver_arg_len))
  {
    mysql_free_result(res);
    abort_not_supported_test();
  }
  mysql_free_result(res);
  return 0;
}

836
int do_source(struct st_query* q)
unknown's avatar
unknown committed
837
{
838
  char* p=q->first_argument, *name;
839
  if (!*p)
unknown's avatar
unknown committed
840 841
    die("Missing file name in source\n");
  name = p;
842
  while (*p && !my_isspace(charset_info,*p))
unknown's avatar
unknown committed
843 844
    p++;
  *p = 0;
845

unknown's avatar
unknown committed
846 847 848
  return open_file(name);
}

849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873
/*
  Execute given command.

  SYNOPSIS
    do_exec()
    q	called command

  DESCRIPTION
    If one uses --exec command [args] command in .test file
    we will execute the command and record its output.

  RETURN VALUES
    0	ok
    1	error
*/

int do_exec(struct st_query* q)
{
  int error= 0;
  DYNAMIC_STRING *ds;
  DYNAMIC_STRING ds_tmp;
  char buf[1024];
  FILE *res_file;
  char *cmd= q->first_argument;

unknown's avatar
unknown committed
874
  while (*cmd && my_isspace(charset_info, *cmd))
875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
    cmd++;
  if (!*cmd)
    die("Missing argument in exec\n");

  if (q->record_file[0])
  {
    init_dynamic_string(&ds_tmp, "", 16384, 65536);
    ds= &ds_tmp;
  }
  else
    ds= &ds_res;

  if (!(res_file= popen(cmd, "r")) && q->abort_on_error)
    die("popen() failed\n");
  while (fgets(buf, sizeof(buf), res_file))
890
    replace_dynstr_append_mem(ds, buf, strlen(buf));
891
  pclose(res_file);
892 893 894 895
  
  if (glob_replace)
    free_replace();

896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
  if (record)
  {
    if (!q->record_file[0] && !result_file)
      die("At line %u: Missing result file", start_lineno);
    if (!result_file)
      str_to_file(q->record_file, ds->str, ds->length);
  }
  else if (q->record_file[0])
  {
    error= check_result(ds, q->record_file, q->require_file);
  }
  if (ds == &ds_tmp)
    dynstr_free(&ds_tmp);
  
  return error;
}

913 914 915 916 917 918 919
int var_query_set(VAR* v, const char* p, const char** p_end)
{
  char* end = (char*)((p_end && *p_end) ? *p_end : p + strlen(p));
  MYSQL_RES *res;
  MYSQL_ROW row;
  MYSQL* mysql = &cur_con->mysql;
  LINT_INIT(res);
unknown's avatar
unknown committed
920

921 922 923 924 925 926 927 928 929 930 931 932 933 934
  while (end > p && *end != '`')
    --end;
  if (p == end)
    die("Syntax error in query, missing '`'");
  ++p;

  if (mysql_real_query(mysql, p, (int)(end - p)) ||
      !(res = mysql_store_result(mysql)))
  {
    *end = 0;
    die("Error running query '%s': %s", p, mysql_error(mysql));
  }

  if ((row = mysql_fetch_row(res)) && row[0])
935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956
  {
    /*
      Concatenate all row results with tab in between to allow us to work
      with results from many columns (for example from SHOW VARIABLES)
    */
    DYNAMIC_STRING result;
    uint i;
    ulong *lengths;
    char *end;

    init_dynamic_string(&result, "", 16384, 65536);
    lengths= mysql_fetch_lengths(res);
    for (i=0; i < mysql_num_fields(res); i++)
    {
      if (row[0])
	dynstr_append_mem(&result, row[i], lengths[i]);
      dynstr_append_mem(&result, "\t", 1);
    }
    end= result.str + result.length-1;
    eval_expr(v, result.str, (const char**) &end);
    dynstr_free(&result);
  }
957 958 959 960 961 962
  else
    eval_expr(v, "", 0);

  mysql_free_result(res);
  return 0;
}
963

unknown's avatar
unknown committed
964 965 966 967 968
void var_copy(VAR* dest, VAR* src)
{
  dest->int_val=src->int_val;
  dest->int_dirty=src->int_dirty;
  if (dest->alloced_len < src->alloced_len &&
969
      !(dest->str_val=my_realloc(dest->str_val,src->alloced_len+1,
unknown's avatar
unknown committed
970 971 972
				 MYF(MY_WME))))
    die("Out of memory");
  dest->str_val_len=src->str_val_len;
973
  memcpy(dest->str_val,src->str_val,src->str_val_len+1);
unknown's avatar
unknown committed
974 975
}

976
int eval_expr(VAR* v, const char* p, const char** p_end)
977 978
{
  VAR* vp;
979
  if (*p == '$')
980 981
  {
    if ((vp = var_get(p,p_end,0,0)))
982
    {
983 984
      var_copy(v, vp);
      return 0;
unknown's avatar
unknown committed
985
    }
986
  }
987
  else if (*p == '`')
988 989 990
  {
    return var_query_set(v, p, p_end);
  }
unknown's avatar
unknown committed
991 992
  else
    {
993 994 995 996
      int new_val_len = (p_end && *p_end) ?
	 (int) (*p_end - p) : (int) strlen(p);
      if (new_val_len + 1 >= v->alloced_len)
      {
997
	v->alloced_len = (new_val_len < MIN_VAR_ALLOC - 1) ?
998 999
	  MIN_VAR_ALLOC : new_val_len + 1;
	if (!(v->str_val =
1000
	      v->str_val ? my_realloc(v->str_val, v->alloced_len+1,
1001
				      MYF(MY_WME)) :
1002
	      my_malloc(v->alloced_len+1, MYF(MY_WME))))
1003 1004 1005 1006 1007
	  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;
unknown's avatar
unknown committed
1008 1009
      v->int_val=atoi(p);
      v->int_dirty=0;
1010 1011
      return 0;
    }
1012

1013 1014 1015 1016
  die("Invalid expr: %s", p);
  return 1;
}

1017
int do_inc(struct st_query* q)
1018
{
1019
  char* p=q->first_argument;
1020
  VAR* v;
1021
  v = var_get(p, 0, 1, 0);
1022 1023 1024 1025 1026
  v->int_val++;
  v->int_dirty = 1;
  return 0;
}

1027
int do_dec(struct st_query* q)
1028
{
1029
  char* p=q->first_argument;
1030
  VAR* v;
1031
  v = var_get(p, 0, 1, 0);
1032 1033 1034 1035 1036
  v->int_val--;
  v->int_dirty = 1;
  return 0;
}

1037
int do_system(struct st_query* q)
unknown's avatar
unknown committed
1038
{
1039
  char* p=q->first_argument;
unknown's avatar
unknown committed
1040
  VAR v;
1041
  var_init(&v, 0, 0, 0, 0);
unknown's avatar
unknown committed
1042
  eval_expr(&v, p, 0); /* NULL terminated */
unknown's avatar
unknown committed
1043
  if (v.str_val_len)
unknown's avatar
unknown committed
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
  {
    char expr_buf[512];
    if ((uint)v.str_val_len > sizeof(expr_buf) - 1)
      v.str_val_len = sizeof(expr_buf) - 1;
    memcpy(expr_buf, v.str_val, v.str_val_len);
    expr_buf[v.str_val_len] = 0;
    DBUG_PRINT("info", ("running system command '%s'", expr_buf));
    if (system(expr_buf) && q->abort_on_error)
      die("system command '%s' failed", expr_buf);
  }
unknown's avatar
unknown committed
1054
  var_free(&v);
unknown's avatar
unknown committed
1055 1056
  return 0;
}
1057

1058
int do_echo(struct st_query* q)
1059
{
1060
  char* p=q->first_argument;
1061
  VAR v;
1062
  var_init(&v,0,0,0,0);
1063
  eval_expr(&v, p, 0); /* NULL terminated */
unknown's avatar
unknown committed
1064 1065 1066 1067 1068
  if (v.str_val_len)
  {
    fflush(stdout);
    write(1, v.str_val, v.str_val_len);
  }
1069
  write(1, "\n", 1);
unknown's avatar
unknown committed
1070
  var_free(&v);
1071 1072 1073
  return 0;
}

1074

1075
int do_sync_with_master2(const char* p)
unknown's avatar
unknown committed
1076 1077 1078 1079 1080
{
  MYSQL_RES* res;
  MYSQL_ROW row;
  MYSQL* mysql = &cur_con->mysql;
  char query_buf[FN_REFLEN+128];
1081
  int offset = 0;
1082 1083
  int rpl_parse;

1084 1085 1086 1087
  if (!master_pos.file[0])
  {
    die("Line %u: Calling 'sync_with_master' without calling 'save_master_pos'", start_lineno);
  }
1088 1089
  rpl_parse = mysql_rpl_parse_enabled(mysql);
  mysql_disable_rpl_parse(mysql);
unknown's avatar
unknown committed
1090

1091
  if (*p)
1092
    offset = atoi(p);
unknown's avatar
unknown committed
1093

unknown's avatar
unknown committed
1094
  sprintf(query_buf, "select master_pos_wait('%s', %ld)", master_pos.file,
1095
	  master_pos.pos + offset);
1096 1097
  if (mysql_query(mysql, query_buf))
    die("line %u: failed in %s: %d: %s", start_lineno, query_buf,
unknown's avatar
unknown committed
1098 1099
	mysql_errno(mysql), mysql_error(mysql));

1100
  if (!(last_result = res = mysql_store_result(mysql)))
1101 1102
    die("line %u: mysql_store_result() returned NULL for '%s'", start_lineno,
	query_buf);
1103
  if (!(row = mysql_fetch_row(res)))
unknown's avatar
unknown committed
1104
    die("line %u: empty result in %s", start_lineno, query_buf);
1105
  if (!row[0])
1106 1107
    die("line %u: could not sync with master ('%s' returned NULL)", 
        start_lineno, query_buf);
unknown's avatar
unknown committed
1108 1109
  mysql_free_result(res);
  last_result=0;
1110
  if (rpl_parse)
1111
    mysql_enable_rpl_parse(mysql);
unknown's avatar
unknown committed
1112

unknown's avatar
unknown committed
1113 1114 1115
  return 0;
}

1116 1117 1118 1119
int do_sync_with_master(struct st_query* q)
{
  return do_sync_with_master2(q->first_argument);
}
1120

unknown's avatar
unknown committed
1121 1122 1123 1124 1125
int do_save_master_pos()
{
  MYSQL_RES* res;
  MYSQL_ROW row;
  MYSQL* mysql = &cur_con->mysql;
1126
  const char *query;
1127 1128 1129 1130
  int rpl_parse;

  rpl_parse = mysql_rpl_parse_enabled(mysql);
  mysql_disable_rpl_parse(mysql);
unknown's avatar
unknown committed
1131

1132
  if (mysql_query(mysql, query= "show master status"))
unknown's avatar
unknown committed
1133 1134 1135
    die("At line %u: failed in show master status: %d: %s", start_lineno,
	mysql_errno(mysql), mysql_error(mysql));

1136
  if (!(last_result =res = mysql_store_result(mysql)))
1137 1138
    die("line %u: mysql_store_result() retuned NULL for '%s'", start_lineno,
	query);
1139
  if (!(row = mysql_fetch_row(res)))
unknown's avatar
unknown committed
1140
    die("line %u: empty result in show master status", start_lineno);
1141 1142
  strnmov(master_pos.file, row[0], sizeof(master_pos.file)-1);
  master_pos.pos = strtoul(row[1], (char**) 0, 10);
1143
  mysql_free_result(res); last_result=0;
unknown's avatar
unknown committed
1144

1145
  if (rpl_parse)
1146
    mysql_enable_rpl_parse(mysql);
unknown's avatar
unknown committed
1147

unknown's avatar
unknown committed
1148 1149 1150 1151
  return 0;
}


1152
int do_let(struct st_query* q)
1153
{
1154 1155
  char* p=q->first_argument;
  char *var_name, *var_name_end, *var_val_start;
1156
  if (!*p)
1157 1158
    die("Missing variable name in let\n");
  var_name = p;
1159
  while (*p && (*p != '=' || my_isspace(charset_info,*p)))
1160 1161
    p++;
  var_name_end = p;
1162
  if (*p == '=') p++;
1163
  while (*p && my_isspace(charset_info,*p))
1164 1165
    p++;
  var_val_start = p;
1166
  return var_set(var_name, var_name_end, var_val_start, q->end);
1167 1168
}

unknown's avatar
unknown committed
1169
int do_rpl_probe(struct st_query* q __attribute__((unused)))
1170
{
unknown's avatar
unknown committed
1171
  DBUG_ENTER("do_rpl_probe");
1172
  if (mysql_rpl_probe(&cur_con->mysql))
unknown's avatar
unknown committed
1173 1174
    die("Failed in mysql_rpl_probe(): '%s'", mysql_error(&cur_con->mysql));
  DBUG_RETURN(0);
1175 1176
}

unknown's avatar
unknown committed
1177
int do_enable_rpl_parse(struct st_query* q __attribute__((unused)))
1178 1179 1180 1181 1182
{
  mysql_enable_rpl_parse(&cur_con->mysql);
  return 0;
}

unknown's avatar
unknown committed
1183
int do_disable_rpl_parse(struct st_query* q __attribute__((unused)))
1184 1185 1186 1187 1188 1189
{
  mysql_disable_rpl_parse(&cur_con->mysql);
  return 0;
}


1190
int do_sleep(struct st_query* q, my_bool real_sleep)
unknown's avatar
unknown committed
1191
{
unknown's avatar
unknown committed
1192
  char *p=q->first_argument;
1193
  while (*p && my_isspace(charset_info,*p))
unknown's avatar
unknown committed
1194
    p++;
1195 1196
  if (!*p)
    die("Missing argument in sleep\n");
1197
  if (opt_sleep && !real_sleep)
unknown's avatar
unknown committed
1198
    my_sleep(opt_sleep * 1000000L);
unknown's avatar
unknown committed
1199
  else
unknown's avatar
unknown committed
1200
    my_sleep((ulong) (atof(p) * 1000000L));
unknown's avatar
unknown committed
1201
  return 0;
unknown's avatar
unknown committed
1202 1203
}

1204
static void get_file_name(char *filename, struct st_query* q)
1205
{
1206
  char* p=q->first_argument;
1207 1208
  strnmov(filename, p, FN_REFLEN);
  /* Remove end space */
1209
  while (p > filename && my_isspace(charset_info,p[-1]))
1210 1211 1212 1213
    p--;
  p[0]=0;
}

unknown's avatar
unknown committed
1214

unknown's avatar
unknown committed
1215
static uint get_ints(uint *to,struct st_query* q)
unknown's avatar
unknown committed
1216 1217
{
  char* p=q->first_argument;
1218
  long val;
unknown's avatar
unknown committed
1219
  uint count=0;
1220 1221
  DBUG_ENTER("get_ints");

unknown's avatar
unknown committed
1222 1223
  if (!*p)
    die("Missing argument in %s\n", q->query);
1224 1225 1226

  for (; (p=str2int(p,10,(long) INT_MIN, (long) INT_MAX, &val)) ; p++)
  {
unknown's avatar
unknown committed
1227
    count++;
1228 1229 1230 1231 1232
    *to++= (uint) val;
    if (*p != ',')
      break;
  }
  *to++=0;					/* End of data */
unknown's avatar
unknown committed
1233
  DBUG_RETURN(count);
unknown's avatar
unknown committed
1234 1235
}

unknown's avatar
unknown committed
1236 1237 1238
/*
  Get a string;  Return ptr to end of string
  Strings may be surrounded by " or '
1239 1240

  If string is a '$variable', return the value of the variable.
unknown's avatar
unknown committed
1241 1242 1243
*/


1244 1245
static char *get_string(char **to_ptr, char **from_ptr,
			struct st_query* q)
unknown's avatar
unknown committed
1246 1247
{
  reg1 char c,sep;
1248
  char *to= *to_ptr, *from= *from_ptr, *start=to;
unknown's avatar
unknown committed
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
  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\n", q->query);

1295
  while (my_isspace(charset_info,*from))	/* Point to next string */
unknown's avatar
unknown committed
1296 1297
    from++;

1298 1299
  *to =0;				/* End of string marker */
  *to_ptr= to+1;			/* Store pointer to end */
unknown's avatar
unknown committed
1300
  *from_ptr= from;
1301 1302 1303 1304 1305 1306 1307 1308

  /* 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)
    {
1309
      DBUG_PRINT("info",("var: '%s' -> '%s'", start, var->str_val));
1310 1311 1312 1313
      DBUG_RETURN(var->str_val);	/* return found variable value */
    }
  }
  DBUG_RETURN(start);
unknown's avatar
unknown committed
1314 1315 1316 1317 1318 1319 1320
}


/*
  Get arguments for replace. The syntax is:
  replace from to [from to ...]
  Where each argument may be quoted with ' or "
1321 1322
  A argument may also be a variable, in which case the value of the
  variable is replaced.
unknown's avatar
unknown committed
1323 1324 1325 1326 1327 1328
*/

static void get_replace(struct st_query *q)
{
  uint i;
  char *from=q->first_argument;
1329
  char *buff,*start;
unknown's avatar
unknown committed
1330 1331 1332 1333
  char word_end_chars[256],*pos;
  POINTER_ARRAY to_array,from_array;
  DBUG_ENTER("get_replace");

unknown's avatar
unknown committed
1334
  free_replace();
1335

unknown's avatar
unknown committed
1336 1337 1338 1339
  bzero((char*) &to_array,sizeof(to_array));
  bzero((char*) &from_array,sizeof(from_array));
  if (!*from)
    die("Missing argument in %s\n", q->query);
1340
  start=buff=my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
unknown's avatar
unknown committed
1341 1342 1343
  while (*from)
  {
    char *to=buff;
1344
    to=get_string(&buff, &from, q);
unknown's avatar
unknown committed
1345
    if (!*from)
1346
      die("Wrong number of arguments to replace in %s\n", q->query);
unknown's avatar
unknown committed
1347
    insert_pointer_name(&from_array,to);
1348
    to=get_string(&buff, &from, q);
unknown's avatar
unknown committed
1349 1350 1351
    insert_pointer_name(&to_array,to);
  }
  for (i=1,pos=word_end_chars ; i < 256 ; i++)
1352
    if (my_isspace(charset_info,i))
unknown's avatar
unknown committed
1353
      *pos++= i;
1354
  *pos=0;					/* End pointer */
unknown's avatar
unknown committed
1355 1356 1357 1358 1359 1360 1361 1362
  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)) ||
      initialize_replace_buffer())
    die("Can't initialize replace from %s\n", q->query);
  free_pointer_array(&from_array);
  free_pointer_array(&to_array);
1363
  my_free(start, MYF(0));
1364
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1365 1366 1367 1368
}

void free_replace()
{
1369
  DBUG_ENTER("free_replace");
unknown's avatar
unknown committed
1370 1371 1372 1373 1374 1375
  if (glob_replace)
  {
    my_free((char*) glob_replace,MYF(0));
    glob_replace=0;
    free_replace_buffer();
  }
1376
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1377 1378
}

1379
int select_connection(char *p)
unknown's avatar
unknown committed
1380
{
1381
  char* name;
unknown's avatar
unknown committed
1382
  struct connection *con;
1383 1384 1385
  DBUG_ENTER("select_connection");
  DBUG_PRINT("enter",("name: '%s'",p));

1386
  if (!*p)
unknown's avatar
unknown committed
1387 1388
    die("Missing connection name in connect\n");
  name = p;
1389
  while (*p && !my_isspace(charset_info,*p))
unknown's avatar
unknown committed
1390 1391
    p++;
  *p = 0;
1392

1393 1394
  for (con = cons; con < next_con; con++)
  {
1395
    if (!strcmp(con->name, name))
1396 1397 1398 1399 1400
    {
      cur_con = con;
      DBUG_RETURN(0);
    }
  }
unknown's avatar
unknown committed
1401
  die("connection '%s' not found in connection pool", name);
1402
  DBUG_RETURN(1);				/* Never reached */
unknown's avatar
unknown committed
1403 1404
}

1405
int close_connection(struct st_query* q)
1406
{
1407
  char* p=q->first_argument, *name;
1408
  struct connection *con;
1409 1410 1411
  DBUG_ENTER("close_connection");
  DBUG_PRINT("enter",("name: '%s'",p));

1412
  if (!*p)
1413 1414
    die("Missing connection name in connect\n");
  name = p;
1415
  while (*p && !my_isspace(charset_info,*p))
1416 1417
    p++;
  *p = 0;
1418

unknown's avatar
unknown committed
1419
  for (con = cons; con < next_con; con++)
1420
  {
1421
    if (!strcmp(con->name, name))
1422
    {
1423
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1424 1425 1426
      if (q->type == Q_DIRTY_CLOSE)
      {
	if (con->mysql.net.vio)
unknown's avatar
unknown committed
1427
	{
unknown's avatar
unknown committed
1428 1429
	  vio_delete(con->mysql.net.vio);
	  con->mysql.net.vio = 0;
unknown's avatar
unknown committed
1430
	}
unknown's avatar
unknown committed
1431
      }
1432
#endif
1433 1434 1435 1436
      mysql_close(&con->mysql);
      DBUG_RETURN(0);
    }
  }
1437
  die("connection '%s' not found in connection pool", name);
1438
  DBUG_RETURN(1);				/* Never reached */
1439 1440
}

unknown's avatar
unknown committed
1441

1442 1443
/*
   This one now is a hack - we may want to improve in in the
unknown's avatar
unknown committed
1444 1445 1446
   future to handle quotes. For now we assume that anything that is not
   a comma, a space or ) belongs to the argument. space is a chopper, comma or
   ) are delimiters/terminators
1447
*/
1448

unknown's avatar
unknown committed
1449 1450
char* safe_get_param(char* str, char** arg, const char* msg)
{
1451
  DBUG_ENTER("safe_get_param");
1452
  while (*str && my_isspace(charset_info,*str))
unknown's avatar
unknown committed
1453
    str++;
unknown's avatar
unknown committed
1454
  *arg = str;
unknown's avatar
unknown committed
1455 1456
  for (; *str && *str != ',' && *str != ')' ; str++)
  {
1457
    if (my_isspace(charset_info,*str))
unknown's avatar
unknown committed
1458
      *str = 0;
unknown's avatar
unknown committed
1459
  }
1460
  if (!*str)
unknown's avatar
unknown committed
1461
    die(msg);
1462

unknown's avatar
unknown committed
1463
  *str++ = 0;
1464
  DBUG_RETURN(str);
unknown's avatar
unknown committed
1465 1466
}

1467
#ifndef EMBEDDED_LIBRARY
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
void init_manager()
{
  if (!(manager=mysql_manager_init(0)))
    die("Failed in mysql_manager_init()");
  if (!mysql_manager_connect(manager,manager_host,manager_user,
			     manager_pass,manager_port))
    die("Could not connect to MySQL manager: %s(%d)",manager->last_error,
	manager->last_errno);

}
1478
#endif
1479

unknown's avatar
unknown committed
1480 1481 1482 1483 1484 1485 1486 1487
int safe_connect(MYSQL* con, const char* host, const char* user,
		 const char* pass,
		 const char* db, int port, const char* sock)
{
  int con_error = 1;
  int i;
  for (i = 0; i < MAX_CON_TRIES; ++i)
  {
1488 1489
    if (mysql_real_connect(con, host,user, pass, db, port, sock,
			   CLIENT_MULTI_STATEMENTS))
unknown's avatar
unknown committed
1490 1491 1492 1493 1494 1495 1496 1497 1498
    {
      con_error = 0;
      break;
    }
    sleep(CON_RETRY_SLEEP);
  }
  return con_error;
}

1499 1500

int do_connect(struct st_query* q)
unknown's avatar
unknown committed
1501 1502 1503
{
  char* con_name, *con_user,*con_pass, *con_host, *con_port_str,
    *con_db, *con_sock;
1504
  char* p=q->first_argument;
1505
  char buff[FN_REFLEN];
unknown's avatar
unknown committed
1506
  int con_port;
1507
  int free_con_sock = 0;
unknown's avatar
unknown committed
1508

1509 1510
  DBUG_ENTER("do_connect");
  DBUG_PRINT("enter",("connect: %s",p));
unknown's avatar
unknown committed
1511

1512
  if (*p != '(')
1513
    die("Syntax error in connect - expected '(' found '%c'", *p);
unknown's avatar
unknown committed
1514 1515 1516 1517 1518 1519
  p++;
  p = safe_get_param(p, &con_name, "missing connection name");
  p = safe_get_param(p, &con_host, "missing connection host");
  p = safe_get_param(p, &con_user, "missing connection user");
  p = safe_get_param(p, &con_pass, "missing connection password");
  p = safe_get_param(p, &con_db, "missing connection db");
unknown's avatar
unknown committed
1520 1521 1522 1523 1524 1525 1526
  if (!*p || *p == ';')				/* Default port and sock */
  {
    con_port=port;
    con_sock=(char*) unix_sock;
  }
  else
  {
1527
    VAR* var_port, *var_sock;
unknown's avatar
unknown committed
1528
    p = safe_get_param(p, &con_port_str, "missing connection port");
1529 1530
    if (*con_port_str == '$')
    {
1531
      if (!(var_port = var_get(con_port_str, 0, 0, 0)))
1532 1533 1534 1535
	die("Unknown variable '%s'", con_port_str+1);
      con_port = var_port->int_val;
    }
    else
1536
      con_port=atoi(con_port_str);
unknown's avatar
unknown committed
1537
    p = safe_get_param(p, &con_sock, "missing connection socket");
1538 1539
    if (*con_sock == '$')
    {
1540
      if (!(var_sock = var_get(con_sock, 0, 0, 0)))
1541 1542 1543 1544 1545 1546 1547
	die("Unknown variable '%s'", con_sock+1);
      if (!(con_sock = (char*)my_malloc(var_sock->str_val_len+1, MYF(0))))
	die("Out of memory");
      free_con_sock = 1;
      memcpy(con_sock, var_sock->str_val, var_sock->str_val_len);
      con_sock[var_sock->str_val_len] = 0;
    }
unknown's avatar
unknown committed
1548
  }
unknown's avatar
unknown committed
1549

1550
  if (next_con == cons_end)
unknown's avatar
unknown committed
1551
    die("Connection limit exhausted - increase MAX_CONS in mysqltest.c");
unknown's avatar
unknown committed
1552

1553
  if (!mysql_init(&next_con->mysql))
unknown's avatar
unknown committed
1554
    die("Failed on mysql_init()");
unknown's avatar
unknown committed
1555 1556
  if (opt_compress)
    mysql_options(&next_con->mysql,MYSQL_OPT_COMPRESS,NullS);
1557 1558
  mysql_options(&next_con->mysql, MYSQL_OPT_LOCAL_INFILE, 0);

unknown's avatar
unknown committed
1559 1560 1561 1562 1563
#ifdef HAVE_OPENSSL
  if (opt_use_ssl)
    mysql_ssl_set(&next_con->mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
		  opt_ssl_capath, opt_ssl_cipher);
#endif
1564
  if (con_sock && !free_con_sock && *con_sock && *con_sock != FN_LIBCHAR)
1565
    con_sock=fn_format(buff, con_sock, TMPDIR, "",0);
unknown's avatar
unknown committed
1566 1567
  if (!con_db[0])
    con_db=db;
1568
  /* Special database to allow one to connect without a database name */
unknown's avatar
unknown committed
1569
  if (con_db && !strcmp(con_db,"*NO-ONE*"))
1570
    con_db=0;
unknown's avatar
unknown committed
1571 1572 1573
  if ((safe_connect(&next_con->mysql, con_host,
		    con_user, con_pass,
		    con_db, con_port, con_sock ? con_sock: 0)))
unknown's avatar
unknown committed
1574 1575 1576
    die("Could not open connection '%s': %s", con_name,
	mysql_error(&next_con->mysql));

1577
  if (!(next_con->name = my_strdup(con_name, MYF(MY_WME))))
1578
    die(NullS);
unknown's avatar
unknown committed
1579
  cur_con = next_con++;
1580 1581
  if (free_con_sock)
    my_free(con_sock, MYF(MY_WME));
1582
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1583 1584
}

1585

1586
int do_done(struct st_query* q)
1587 1588
{
  q->type = Q_END_BLOCK;
1589
  if (cur_block == block_stack)
1590
    die("Stray '}' - end of block before beginning");
1591 1592
  if (*block_ok--)
  {
1593
    parser.current_line = *--cur_block;
1594
  }
1595
  else
unknown's avatar
unknown committed
1596
  {
1597 1598
    ++parser.current_line;
    --cur_block;
unknown's avatar
unknown committed
1599
  }
1600 1601 1602
  return 0;
}

1603
int do_while(struct st_query* q)
1604
{
1605
  char* p=q->first_argument;
1606
  const char* expr_start, *expr_end;
1607
  VAR v;
1608
  if (cur_block == block_stack_end)
1609
    die("Nesting too deeply");
1610
  if (!*block_ok)
1611 1612 1613 1614 1615 1616
  {
    ++false_block_depth;
    *++block_ok = 0;
    *cur_block++ = parser.current_line++;
    return 0;
  }
unknown's avatar
unknown committed
1617

1618
  expr_start = strchr(p, '(');
1619
  if (!expr_start)
1620 1621
    die("missing '(' in while");
  expr_end = strrchr(expr_start, ')');
1622
  if (!expr_end)
1623
    die("missing ')' in while");
unknown's avatar
unknown committed
1624
  var_init(&v,0,0,0,0);
1625
  eval_expr(&v, ++expr_start, &expr_end);
1626
  *cur_block++ = parser.current_line++;
1627
  if (!v.int_val)
1628 1629 1630 1631
  {
    *++block_ok = 0;
    false_block_depth++;
  }
1632 1633
  else
    *++block_ok = 1;
unknown's avatar
unknown committed
1634
  var_free(&v);
1635
  return 0;
1636 1637
}

unknown's avatar
unknown committed
1638

1639 1640
my_bool end_of_query(int c, char* p)
{
unknown's avatar
unknown committed
1641
  uint i, j;
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
  int tmp[MAX_DELIMITER]= {0};

  for (i= 0; c == *(delimiter + i) && i < delimiter_length;
       i++, c= fgetc(*cur_file))
    tmp[i]= c;
  tmp[i]= c;

  for (j= i; j > 0 && i != delimiter_length; j--)
    ungetc(tmp[j], *cur_file);
  if (i == delimiter_length)
  {
unknown's avatar
unknown committed
1653
    ungetc(tmp[i], *cur_file);
1654 1655 1656 1657 1658 1659 1660
    *p= 0;
    return 1;
  }
  return 0;
}


unknown's avatar
unknown committed
1661 1662 1663
int read_line(char* buf, int size)
{
  int c;
1664 1665
  char* p= buf, *buf_end= buf + size - 1;
  int no_save= 0;
unknown's avatar
unknown committed
1666 1667
  enum {R_NORMAL, R_Q1, R_ESC_Q_Q1, R_ESC_Q_Q2,
	R_ESC_SLASH_Q1, R_ESC_SLASH_Q2,
1668
	R_Q2, R_COMMENT, R_LINE_START} state= R_LINE_START;
1669

1670
  start_lineno= *lineno;
1671 1672
  for (; p < buf_end ;)
  {
1673 1674
    no_save= 0;
    c= fgetc(*cur_file);
1675
    if (feof(*cur_file))
unknown's avatar
unknown committed
1676
    {
1677
      if ((*cur_file) != stdin)
1678
	my_fclose(*cur_file, MYF(0));
unknown's avatar
unknown committed
1679 1680
      cur_file--;
      lineno--;
1681 1682
      if (cur_file == file_stack)
	return 1;
unknown's avatar
unknown committed
1683
      continue;
1684
    }
1685

1686 1687
    switch(state) {
    case R_NORMAL:
1688
      /*  Only accept '{' in the beginning of a line */
1689
      if (end_of_query(c, p))
1690 1691 1692 1693 1694 1695
	return 0;
      else if (c == '\'')
	state = R_Q1;
      else if (c == '"')
	state = R_Q2;
      else if (c == '\n')
1696
      {
1697
	state = R_LINE_START;
1698 1699
	(*lineno)++;
      }
1700 1701 1702 1703
      break;
    case R_COMMENT:
      if (c == '\n')
      {
1704
	*p= 0;
1705
	(*lineno)++;
1706 1707 1708 1709 1710 1711 1712 1713
	return 0;
      }
      break;
    case R_LINE_START:
      if (c == '#' || c == '-')
      {
	state = R_COMMENT;
      }
1714
      else if (my_isspace(charset_info, c))
1715 1716 1717
      {
	if (c == '\n')
	  start_lineno= ++*lineno;		/* Query hasn't started yet */
1718
	no_save= 1;
1719
      }
1720 1721
      else if (c == '}')
      {
1722 1723
	*buf++= '}';
	*buf= 0;
1724 1725
	return 0;
      }
1726
      else if (end_of_query(c, p) || c == '{')
1727
      {
1728
	*p= 0;
1729 1730
	return 0;
      }
unknown's avatar
unknown committed
1731
      else if (c == '\'')
1732
	state= R_Q1;
unknown's avatar
unknown committed
1733
      else if (c == '"')
1734
	state= R_Q2;
1735
      else
1736
	state= R_NORMAL;
1737
      break;
1738

1739 1740
    case R_Q1:
      if (c == '\'')
1741
	state= R_ESC_Q_Q1;
1742
      else if (c == '\\')
1743
	state= R_ESC_SLASH_Q1;
1744 1745
      break;
    case R_ESC_Q_Q1:
1746
      if (end_of_query(c, p))
1747 1748
	return 0;
      if (c != '\'')
1749
	state= R_NORMAL;
1750
      else
1751
	state= R_Q1;
1752 1753
      break;
    case R_ESC_SLASH_Q1:
1754
      state= R_Q1;
1755
      break;
unknown's avatar
unknown committed
1756

1757 1758
    case R_Q2:
      if (c == '"')
1759
	state= R_ESC_Q_Q2;
1760
      else if (c == '\\')
1761
	state= R_ESC_SLASH_Q2;
1762 1763
      break;
    case R_ESC_Q_Q2:
1764
      if (end_of_query(c, p))
1765 1766
	return 0;
      if (c != '"')
1767
	state= R_NORMAL;
1768
      else
1769
	state= R_Q2;
1770 1771
      break;
    case R_ESC_SLASH_Q2:
1772
      state= R_Q2;
1773
      break;
unknown's avatar
unknown committed
1774
    }
1775 1776

    if (!no_save)
1777
      *p++= c;
1778
  }
1779
  *p= 0;					/* Always end with \0 */
1780
  return feof(*cur_file);
unknown's avatar
unknown committed
1781 1782
}

1783 1784
static char read_query_buf[MAX_QUERY];

1785
int read_query(struct st_query** q_ptr)
unknown's avatar
unknown committed
1786
{
1787
  char *p = read_query_buf, * p1 ;
unknown's avatar
unknown committed
1788
  int expected_errno;
1789
  struct st_query* q;
1790

1791 1792
  if (parser.current_line < parser.read_lines)
  {
1793
    get_dynamic(&q_lines, (gptr) q_ptr, parser.current_line) ;
1794 1795
    return 0;
  }
1796
  if (!(*q_ptr= q= (struct st_query*) my_malloc(sizeof(*q), MYF(MY_WME))) ||
unknown's avatar
unknown committed
1797 1798
      insert_dynamic(&q_lines, (gptr) &q))
    die(NullS);
1799

1800 1801 1802
  q->record_file[0]= 0;
  q->require_file= 0;
  q->first_word_len= 0;
1803 1804
  memcpy((gptr) q->expected_errno, (gptr) global_expected_errno,
	 sizeof(global_expected_errno));
1805 1806 1807
  q->expected_errors= global_expected_errors;
  q->abort_on_error= global_expected_errno[0] == 0;
  bzero((gptr) global_expected_errno, sizeof(global_expected_errno));
unknown's avatar
unknown committed
1808 1809
  global_expected_errors=0;

1810
  q->type = Q_UNKNOWN;
1811
  q->query_buf= q->query= 0;
1812
  if (read_line(read_query_buf, sizeof(read_query_buf)))
unknown's avatar
unknown committed
1813
    return 1;
1814 1815 1816 1817 1818 1819 1820

  if (*p == '#')
  {
    q->type = Q_COMMENT;
  }
  else if (p[0] == '-' && p[1] == '-')
  {
1821 1822
    q->type= Q_COMMENT_WITH_COMMAND;
    p+= 2;					/* To calculate first word */
1823 1824 1825 1826
  }
  else
  {
    if (*p == '!')
unknown's avatar
unknown committed
1827
    {
1828
      q->abort_on_error= 0;
1829 1830 1831
      p++;
      if (*p == '$')
      {
1832
	expected_errno= 0;
1833
	p++;
1834
	for (; my_isdigit(charset_info, *p); p++)
1835
	  expected_errno = expected_errno * 10 + *p - '0';
1836 1837
	q->expected_errno[0] = expected_errno;
	q->expected_errno[1] = 0;
unknown's avatar
unknown committed
1838
	q->expected_errors=1;
1839
      }
unknown's avatar
unknown committed
1840 1841
    }

1842
    while (*p && my_isspace(charset_info, *p))
unknown's avatar
unknown committed
1843
      p++ ;
1844
    if (*p == '@')
unknown's avatar
unknown committed
1845 1846 1847
    {
      p++;
      p1 = q->record_file;
1848
      while (!my_isspace(charset_info, *p) &&
unknown's avatar
unknown committed
1849
	     p1 < q->record_file + sizeof(q->record_file) - 1)
unknown's avatar
unknown committed
1850
	*p1++ = *p++;
1851
      *p1 = 0;
unknown's avatar
unknown committed
1852
    }
1853
  }
1854
  while (*p && my_isspace(charset_info, *p))
unknown's avatar
unknown committed
1855
    p++;
1856
  if (!(q->query_buf= q->query= my_strdup(p, MYF(MY_WME))))
1857 1858 1859
    die(NullS);

  /* Calculate first word and first argument */
1860 1861 1862
  for (p= q->query; *p && !my_isspace(charset_info, *p) ; p++) ;
  q->first_word_len= (uint) (p - q->query);
  while (*p && my_isspace(charset_info, *p))
unknown's avatar
unknown committed
1863
    p++;
1864 1865
  q->first_argument= p;
  q->end= strend(q->query);
1866
  parser.read_lines++;
unknown's avatar
unknown committed
1867 1868 1869
  return 0;
}

1870 1871 1872

static struct my_option my_long_options[] =
{
1873
  {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
1874 1875 1876
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  {"database", 'D', "Database to use.", (gptr*) &db, (gptr*) &db, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1877
  {"basedir", 'b', "Basedir for tests.", (gptr*) &opt_basedir,
1878
   (gptr*) &opt_basedir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1879
  {"big-test", 'B', "Define BIG_TEST to 1.", (gptr*) &opt_big_test,
1880
   (gptr*) &opt_big_test, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
1881
  {"compress", 'C', "Use the compressed server/client protocol.",
1882 1883 1884 1885 1886 1887
   (gptr*) &opt_compress, (gptr*) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
   0, 0, 0},
  {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,
   0, 0, 0, 0, 0, 0},
  {"host", 'h', "Connect to host.", (gptr*) &host, (gptr*) &host, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1888
  {"manager-user", OPT_MANAGER_USER, "Undocumented: Used for debugging.",
1889 1890
   (gptr*) &manager_user, (gptr*) &manager_user, 0, GET_STR, REQUIRED_ARG, 0,
   0, 0, 0, 0, 0},
1891
  {"manager-host", OPT_MANAGER_HOST, "Undocumented: Used for debugging.",
1892 1893
   (gptr*) &manager_host, (gptr*) &manager_host, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
1894
  {"manager-password", OPT_MANAGER_PASSWD, "Undocumented: Used for debugging.",
1895
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1896
  {"manager-port", OPT_MANAGER_PORT, "Undocumented: Used for debugging.",
1897 1898 1899
   (gptr*) &manager_port, (gptr*) &manager_port, 0, GET_INT, REQUIRED_ARG,
   MYSQL_MANAGER_PORT, 0, 0, 0, 0, 0},
  {"manager-wait-timeout", OPT_MANAGER_WAIT_TIMEOUT,
1900
   "Undocumented: Used for debugging.", (gptr*) &manager_wait_timeout,
1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912
   (gptr*) &manager_wait_timeout, 0, GET_INT, REQUIRED_ARG, 3, 0, 0, 0, 0, 0},
  {"password", 'p', "Password to use when connecting to server.",
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  {"port", 'P', "Port number to use for connection.", (gptr*) &port,
   (gptr*) &port, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"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.",
   (gptr*) &result_file, (gptr*) &result_file, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
1913
  {"server-arg", 'A', "Send enbedded server this as a paramenter.",
1914
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1915
  {"server-file", 'F', "Read embedded server arguments from file.",
1916 1917 1918
   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},
1919
  {"skip-safemalloc", OPT_SKIP_SAFEMALLOC,
1920
   "Don't use the memory allocation checking.", 0, 0, 0, GET_NO_ARG, NO_ARG,
1921
   0, 0, 0, 0, 0, 0},
1922
  {"sleep", 'T', "Sleep always this many seconds on sleep commands.",
1923 1924 1925 1926 1927
   (gptr*) &opt_sleep, (gptr*) &opt_sleep, 0, GET_INT, REQUIRED_ARG, 0, 0, 0,
   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},
unknown's avatar
unknown committed
1928
#include "sslopt-longopts.h"
1929 1930
  {"test-file", 'x', "Read test from/in this file (default stdin).",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1931
  {"tmpdir", 't', "Temporary directory where sockets are put.",
1932 1933 1934 1935 1936 1937 1938 1939
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"user", 'u', "User for login.", (gptr*) &user, (gptr*) &user, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"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},
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
unknown's avatar
unknown committed
1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
};

static void print_version(void)
{
  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,MTEST_VERSION,
	 MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
}

void usage()
{
  print_version();
1951
  printf("MySQL AB, by Sasha, Matt, Monty & Jani\n");
unknown's avatar
unknown committed
1952 1953 1954
  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);
1955
  my_print_help(my_long_options);
unknown's avatar
unknown committed
1956
  printf("  --no-defaults       Don't read default options from any options file.\n");
1957
  my_print_variables(my_long_options);
unknown's avatar
unknown committed
1958 1959
}

1960 1961 1962 1963 1964

static my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
{
1965
  switch(optid) {
1966
  case '#':
unknown's avatar
unknown committed
1967
#ifndef DBUG_OFF
1968
    DBUG_PUSH(argument ? argument : "d:t:S:i:O,/tmp/mysqltest.trace");
unknown's avatar
unknown committed
1969
#endif
1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
    break;
  case 'r':
    record = 1;
    break;
  case (int)OPT_MANAGER_PASSWD:
    my_free(manager_pass,MYF(MY_ALLOW_ZERO_PTR));
    manager_pass=my_strdup(argument, MYF(MY_FAE));
    while (*argument) *argument++= 'x';		/* Destroy argument */
    break;
  case 'x':
    {
      char buff[FN_REFLEN];
      if (!test_if_hard_path(argument))
      {
	strxmov(buff, opt_basedir, argument, NullS);
	argument= buff;
      }
      fn_format(buff, argument, "", "", 4);
unknown's avatar
unknown committed
1988
      if (!(*++cur_file = my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
	die("Could not open %s: errno = %d", argument, errno);
      break;
    }
  case 'p':
    if (argument)
    {
      my_free(pass, MYF(MY_ALLOW_ZERO_PTR));
      pass= my_strdup(argument, MYF(MY_FAE));
      while (*argument) *argument++= 'x';		/* Destroy argument */
    }
    else
      tty_password= 1;
    break;
unknown's avatar
unknown committed
2002
#include <sslopt-case.h>
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023
  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*) "";
    }
    embedded_server_args[embedded_server_arg_count++]=
      my_strdup(argument, MYF(MY_FAE));
    if (embedded_server_arg_count == MAX_SERVER_ARGS ||
	!embedded_server_args[embedded_server_arg_count-1])
    {
      die("Can't use server argument");
    }
    break;
  case 'F':
    if (read_server_arguments(argument))
      die(NullS);
    break;
2024 2025 2026 2027 2028
  case OPT_SKIP_SAFEMALLOC:
#ifdef SAFEMALLOC
    sf_malloc_quick=1;
#endif
    break;
2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
  case 'V':
    print_version();
    exit(0);
  case '?':
    usage();
    exit(1);
  }
  return 0;
}


unknown's avatar
unknown committed
2040 2041 2042
int parse_args(int argc, char **argv)
{
  load_defaults("my",load_default_groups,&argc,&argv);
2043
  default_argv= argv;
2044

unknown's avatar
unknown committed
2045
  if ((handle_options(&argc, &argv, my_long_options, get_one_option)))
unknown's avatar
unknown committed
2046
    exit(1);
unknown's avatar
unknown committed
2047 2048 2049 2050 2051 2052 2053

  if (argc > 1)
  {
    usage();
    exit(1);
  }
  if (argc == 1)
2054
    db= *argv;
unknown's avatar
unknown committed
2055 2056 2057 2058 2059 2060
  if (tty_password)
    pass=get_tty_password(NullS);

  return 0;
}

unknown's avatar
unknown committed
2061
char* safe_str_append(char* buf, const char* str, int size)
unknown's avatar
unknown committed
2062 2063
{
  int i,c ;
2064
  for (i = 0; (c = *str++) &&  i < size - 1; i++)
unknown's avatar
unknown committed
2065 2066 2067 2068 2069
    *buf++ = c;
  *buf = 0;
  return buf;
}

unknown's avatar
unknown committed
2070 2071 2072
void str_to_file(const char* fname, char* str, int size)
{
  int fd;
2073 2074 2075 2076 2077 2078 2079
  char buff[FN_REFLEN];
  if (!test_if_hard_path(fname))
  {
    strxmov(buff, opt_basedir, fname, NullS);
    fname=buff;
  }
  fn_format(buff,fname,"","",4);
unknown's avatar
unknown committed
2080

2081
  if ((fd = my_open(buff, O_WRONLY | O_CREAT | O_TRUNC,
2082
		    MYF(MY_WME | MY_FFNF))) < 0)
2083
    die("Could not open %s: errno = %d", buff, errno);
2084
  if (my_write(fd, (byte*)str, size, MYF(MY_WME|MY_FNABP)))
unknown's avatar
unknown committed
2085 2086 2087 2088 2089
    die("write failed");
  my_close(fd, MYF(0));
}

void reject_dump(const char* record_file, char* buf, int size)
unknown's avatar
unknown committed
2090
{
unknown's avatar
unknown committed
2091
  char reject_file[FN_REFLEN];
unknown's avatar
unknown committed
2092
  str_to_file(fn_format(reject_file, record_file,"",".reject",2), buf, size);
unknown's avatar
unknown committed
2093 2094
}

2095 2096 2097

/* Append the string to ds, with optional replace */

unknown's avatar
unknown committed
2098 2099
static void replace_dynstr_append_mem(DYNAMIC_STRING *ds, const char *val,
				      int len)
2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110
{
  if (glob_replace)
  {
    len=(int) replace_strings(glob_replace, &out_buff, &out_length, val);
    if (len == -1)
      die("Out of memory in replace\n");
    val=out_buff;
  }
  dynstr_append_mem(ds, val, len);
}

2111

2112 2113
/*
  Append all results to the dynamic string separated with '\t'
2114
  Values may be converted with 'replace_column'
2115 2116 2117 2118 2119
*/

static void append_result(DYNAMIC_STRING *ds, MYSQL_RES *res)
{
  MYSQL_ROW row;
2120
  uint num_fields= mysql_num_fields(res);
2121
  MYSQL_FIELD *fields= !display_result_vertically ? 0 : mysql_fetch_fields(res);
2122 2123 2124
  unsigned long *lengths;
  while ((row = mysql_fetch_row(res)))
  {
2125
    uint i;
2126 2127 2128 2129 2130
    lengths = mysql_fetch_lengths(res);
    for (i = 0; i < num_fields; i++)
    {
      const char *val= row[i];
      ulonglong len= lengths[i];
2131 2132 2133 2134 2135 2136

      if (i < max_replace_column && replace_column[i])
      {
	val= replace_column[i];
	len= strlen(val);
      }
2137 2138
      if (!val)
      {
2139 2140
	val= "NULL";
	len= 4;
2141
      }
2142 2143 2144 2145 2146 2147 2148 2149 2150
      if (!display_result_vertically)
      {
	if (i)
	  dynstr_append_mem(ds, "\t", 1);
	replace_dynstr_append_mem(ds, val, len);
      }
      else
      {
	dynstr_append(ds, fields[i].name);
2151
	dynstr_append_mem(ds, "\t", 1);
2152 2153 2154
	replace_dynstr_append_mem(ds, val, len);
	dynstr_append_mem(ds, "\n", 1);
      }
2155
    }
2156 2157
    if (!display_result_vertically)
      dynstr_append_mem(ds, "\n", 1);
2158
  }
2159
  free_replace_column();
2160 2161
}

2162

2163
/*
2164
* flags control the phased/stages of query execution to be performed
2165 2166 2167
* if QUERY_SEND bit is on, the query will be sent. If QUERY_REAP is on
* the result will be read - for regular query, both bits must be on
*/
2168

unknown's avatar
unknown committed
2169
int run_query(MYSQL* mysql, struct st_query* q, int flags)
unknown's avatar
unknown committed
2170
{
2171 2172
  MYSQL_RES* res= 0;
  int i, error= 0, err= 0, counter= 0;
2173 2174
  DYNAMIC_STRING *ds;
  DYNAMIC_STRING ds_tmp;
2175
  DYNAMIC_STRING eval_query;
2176
  char* query;
2177
  int query_len, got_error_on_send= 0;
2178
  DBUG_ENTER("run_query");
unknown's avatar
unknown committed
2179
  
unknown's avatar
unknown committed
2180 2181 2182 2183 2184
  if (q->type != Q_EVAL)
  {
    query = q->query;
    query_len = strlen(query);
  }
2185
  else
unknown's avatar
unknown committed
2186 2187 2188 2189 2190 2191
  {
    init_dynamic_string(&eval_query, "", 16384, 65536);
    do_eval(&eval_query, q->query);
    query = eval_query.str;
    query_len = eval_query.length;
  }
unknown's avatar
unknown committed
2192
  DBUG_PRINT("enter", ("query: '%-.60s'", query));
unknown's avatar
unknown committed
2193

unknown's avatar
unknown committed
2194
  if (q->record_file[0])
2195
  {
2196
    init_dynamic_string(&ds_tmp, "", 16384, 65536);
2197 2198
    ds = &ds_tmp;
  }
2199 2200
  else
    ds= &ds_res;
unknown's avatar
unknown committed
2201

2202 2203 2204 2205 2206 2207 2208
  if (flags & QUERY_SEND)
  {
    got_error_on_send= mysql_send_query(mysql, query, query_len);
    if (got_error_on_send && !q->expected_errno[0])
      die("At line %u: unable to send query '%s' (mysql_errno=%d , errno=%d)",
	  start_lineno, query, mysql_errno(mysql), errno);
  }
unknown's avatar
unknown committed
2209

2210
  do
2211
  {
2212
    if ((flags & QUERY_SEND) && !disable_query_log && !counter)
2213
    {
2214
      replace_dynstr_append_mem(ds,query, query_len);
2215 2216
      dynstr_append_mem(ds, delimiter, delimiter_length);
      dynstr_append_mem(ds, "\n", 1);
2217
    }
2218 2219 2220
    if (!(flags & QUERY_REAP))
      DBUG_RETURN(0);

2221 2222 2223 2224
    if (got_error_on_send ||
	(!counter && (*mysql->methods->read_query_result)(mysql)) ||
	 (!(last_result= res= mysql_store_result(mysql)) &&
	  mysql_field_count(mysql)))
unknown's avatar
unknown committed
2225
    {
2226
      if (q->require_file)
2227
      {
2228 2229 2230 2231 2232 2233 2234 2235
	abort_not_supported_test();
      }
      if (q->abort_on_error)
	die("At line %u: query '%s' failed: %d: %s", start_lineno, query,
	    mysql_errno(mysql), mysql_error(mysql));
      else
      {
	for (i=0 ; (uint) i < q->expected_errors ; i++)
unknown's avatar
unknown committed
2236
	{
2237
	  if ((q->expected_errno[i] == mysql_errno(mysql)))
unknown's avatar
unknown committed
2238
	  {
2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253
	    if (i == 0 && q->expected_errors == 1)
	    {
	      /* Only log error if there is one possible error */
	      dynstr_append_mem(ds,"ERROR ",6);
	      replace_dynstr_append_mem(ds, mysql_sqlstate(mysql),
					strlen(mysql_sqlstate(mysql)));
	      dynstr_append_mem(ds, ": ", 2);
	      replace_dynstr_append_mem(ds,mysql_error(mysql),
					strlen(mysql_error(mysql)));
	      dynstr_append_mem(ds,"\n",1);
	    }
	    /* Don't log error if we may not get an error */
	    else if (q->expected_errno[0] != 0)
	      dynstr_append(ds,"Got one of the listed errors\n");
	    goto end;				/* Ok */
unknown's avatar
unknown committed
2254
	  }
unknown's avatar
unknown committed
2255
	}
2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
	DBUG_PRINT("info",("i: %d  expected_errors: %d", i, q->expected_errors));
	dynstr_append_mem(ds, "ERROR ",6);
	replace_dynstr_append_mem(ds, mysql_sqlstate(mysql),
				  strlen(mysql_sqlstate(mysql)));
	dynstr_append_mem(ds,": ",2);
	replace_dynstr_append_mem(ds, mysql_error(mysql),
				  strlen(mysql_error(mysql)));
	dynstr_append_mem(ds,"\n",1);
	if (i)
	{
	  verbose_msg("query '%s' failed with wrong errno %d instead of %d...",
		      q->query, mysql_errno(mysql), q->expected_errno[0]);
	  error= 1;
	  goto end;
	}
	verbose_msg("query '%s' failed: %d: %s", q->query, mysql_errno(mysql),
		    mysql_error(mysql));
	/*
	  if we do not abort on error, failure to run the query does
	  not fail the whole test case
	*/
2277 2278
	goto end;
      }
2279 2280 2281 2282 2283 2284
      /*{
	verbose_msg("failed in mysql_store_result for query '%s' (%d)", query,
	mysql_errno(mysql));
	error = 1;
	goto end;
	}*/
unknown's avatar
unknown committed
2285
    }
2286 2287 2288

    if (q->expected_errno[0])
    {
unknown's avatar
unknown committed
2289
      error = 1;
2290 2291
      verbose_msg("query '%s' succeeded - should have failed with errno %d...",
		  q->query, q->expected_errno[0]);
unknown's avatar
unknown committed
2292
      goto end;
2293
    }
2294

2295
    if (!disable_result_log)
2296
    {
2297
      if (res)
2298
      {
2299

2300
	if (!display_result_vertically)
2301
	{
2302 2303 2304 2305 2306 2307 2308 2309 2310
	  int num_fields= mysql_num_fields(res);
	  MYSQL_FIELD *fields= mysql_fetch_fields(res);
	  for (i = 0; i < num_fields; i++)
	  {
	    if (i)
	      dynstr_append_mem(ds, "\t", 1);
	    dynstr_append(ds, fields[i].name);
	  }
	  dynstr_append_mem(ds, "\n", 1);
2311 2312
	}
	append_result(ds, res);
2313
      }
unknown's avatar
unknown committed
2314

2315 2316
      /* Add all warnings to the result */
      if (!disable_warnings && mysql_warning_count(mysql))
2317
      {
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332
	MYSQL_RES *warn_res=0;
	uint count= mysql_warning_count(mysql);
	if (!mysql_real_query(mysql, "SHOW WARNINGS", 13))
	{
	  warn_res= mysql_store_result(mysql);
	}
	if (!warn_res)
	  verbose_msg("Warning count is %u but didn't get any warnings\n",
		      count);
	else
	{
	  dynstr_append_mem(ds, "Warnings:\n", 10);
	  append_result(ds, warn_res);
	  mysql_free_result(warn_res);
	}
2333
      }
unknown's avatar
unknown committed
2334
      if (!disable_info)
2335
      {
unknown's avatar
unknown committed
2336 2337 2338 2339 2340 2341 2342 2343 2344
	char buf[40];
	sprintf(buf,"affected rows: %ld\n",mysql_affected_rows(mysql));
	dynstr_append(ds, buf);
	if (mysql_info(mysql))
	{
	  dynstr_append(ds, "info: ");
	  dynstr_append(ds, mysql_info(mysql));
	  dynstr_append_mem(ds, "\n", 1);
	}
2345
      }
2346
    }
2347

2348 2349
    if (glob_replace)
      free_replace();
2350

2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
    if (record)
    {
      if (!q->record_file[0] && !result_file)
	die("At line %u: Missing result file", start_lineno);
      if (!result_file)
	str_to_file(q->record_file, ds->str, ds->length);
    }
    else if (q->record_file[0])
    {
      error = check_result(ds, q->record_file, q->require_file);
    }
    if (res)
      mysql_free_result(res);
    last_result= 0;
    counter++;
  } while (!(err= mysql_next_result(mysql)));
  if (err >= 1)
    mysql_error(mysql);
2369

2370
end:
2371
  last_result=0;
2372 2373
  if (ds == &ds_tmp)
    dynstr_free(&ds_tmp);
2374
  if (q->type == Q_EVAL)
2375
    dynstr_free(&eval_query);
2376
  DBUG_RETURN(error);
unknown's avatar
unknown committed
2377 2378 2379
}


2380
void get_query_type(struct st_query* q)
2381
{
2382 2383
  char save;
  uint type;
2384
  if (*q->query == '}')
2385 2386 2387 2388 2389 2390 2391
  {
    q->type = Q_END_BLOCK;
    return;
  }
  if (q->type != Q_COMMENT_WITH_COMMAND)
    q->type = Q_QUERY;

2392 2393
  save=q->query[q->first_word_len];
  q->query[q->first_word_len]=0;
2394
  type=find_type(q->query, &command_typelib, 1+2);
2395
  q->query[q->first_word_len]=save;
2396
  if (type > 0)
unknown's avatar
unknown committed
2397
    q->type=(enum enum_commands) type;		/* Found command */
2398
}
unknown's avatar
unknown committed
2399

unknown's avatar
unknown committed
2400
static byte *get_var_key(const byte* var, uint* len,
unknown's avatar
unknown committed
2401
			 my_bool __attribute__((unused)) t)
unknown's avatar
unknown committed
2402 2403 2404 2405 2406 2407 2408
{
  register char* key;
  key = ((VAR*)var)->name;
  *len = ((VAR*)var)->name_len;
  return (byte*)key;
}

unknown's avatar
unknown committed
2409
static VAR *var_init(VAR *v, const char *name, int name_len, const char *val,
unknown's avatar
unknown committed
2410 2411 2412
		     int val_len)
{
  int val_alloc_len;
unknown's avatar
unknown committed
2413
  VAR *tmp_var;
2414
  if (!name_len && name)
unknown's avatar
unknown committed
2415
    name_len = strlen(name);
2416
  if (!val_len && val)
unknown's avatar
unknown committed
2417 2418
    val_len = strlen(val) ;
  val_alloc_len = val_len + 16; /* room to grow */
2419
  if (!(tmp_var=v) && !(tmp_var = (VAR*)my_malloc(sizeof(*tmp_var)
2420
						 + name_len, MYF(MY_WME))))
unknown's avatar
unknown committed
2421
    die("Out of memory");
unknown's avatar
unknown committed
2422

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

2426
  if (!(tmp_var->str_val = my_malloc(val_alloc_len+1, MYF(MY_WME))))
2427
    die("Out of memory");
unknown's avatar
unknown committed
2428

unknown's avatar
unknown committed
2429
  memcpy(tmp_var->name, name, name_len);
2430 2431 2432 2433 2434
  if (val)
  {
    memcpy(tmp_var->str_val, val, val_len);
    tmp_var->str_val[val_len]=0;
  }
unknown's avatar
unknown committed
2435 2436 2437
  tmp_var->name_len = name_len;
  tmp_var->str_val_len = val_len;
  tmp_var->alloced_len = val_alloc_len;
2438
  tmp_var->int_val = (val) ? atoi(val) : 0;
unknown's avatar
unknown committed
2439 2440 2441 2442
  tmp_var->int_dirty = 0;
  return tmp_var;
}

unknown's avatar
unknown committed
2443
static void var_free(void *v)
unknown's avatar
unknown committed
2444
{
unknown's avatar
unknown committed
2445
  my_free(((VAR*) v)->str_val, MYF(MY_WME));
unknown's avatar
unknown committed
2446 2447
  if (((VAR*)v)->alloced)
   my_free((char*) v, MYF(MY_WME));
unknown's avatar
unknown committed
2448 2449 2450
}


unknown's avatar
unknown committed
2451
static void var_from_env(const char *name, const char *def_val)
unknown's avatar
unknown committed
2452
{
unknown's avatar
unknown committed
2453 2454
  const char *tmp;
  VAR *v;
2455
  if (!(tmp = getenv(name)))
unknown's avatar
unknown committed
2456
    tmp = def_val;
unknown's avatar
unknown committed
2457

2458
  v = var_init(0, name, 0, tmp, 0);
unknown's avatar
SCRUM  
unknown committed
2459
  my_hash_insert(&var_hash, (byte*)v);
2460
}
unknown's avatar
unknown committed
2461

2462

unknown's avatar
unknown committed
2463
static void init_var_hash(MYSQL *mysql)
unknown's avatar
unknown committed
2464
{
unknown's avatar
unknown committed
2465
  VAR *v;
2466
  DBUG_ENTER("init_var_hash");
2467
  if (hash_init(&var_hash, charset_info, 
unknown's avatar
unknown committed
2468
                1024, 0, 0, get_var_key, var_free, MYF(0)))
unknown's avatar
unknown committed
2469 2470 2471
    die("Variable hash initialization failed");
  var_from_env("MASTER_MYPORT", "9306");
  var_from_env("SLAVE_MYPORT", "9307");
2472
  var_from_env("MYSQL_TEST_DIR", "/tmp");
2473
  var_from_env("BIG_TEST", opt_big_test ? "1" : "0");
unknown's avatar
unknown committed
2474
  v= var_init(0,"MAX_TABLES", 0, (sizeof(ulong) == 4) ? "31" : "62",0);
unknown's avatar
SCRUM  
unknown committed
2475
  my_hash_insert(&var_hash, (byte*) v);
unknown's avatar
unknown committed
2476
  v= var_init(0,"SERVER_VERSION", 0, mysql_get_server_info(mysql), 0);
unknown's avatar
SCRUM  
unknown committed
2477
  my_hash_insert(&var_hash, (byte*) v);
unknown's avatar
unknown committed
2478
  
2479
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2480
}
2481

2482

unknown's avatar
unknown committed
2483
int main(int argc, char **argv)
unknown's avatar
unknown committed
2484 2485
{
  int error = 0;
unknown's avatar
unknown committed
2486
  struct st_query *q;
unknown's avatar
unknown committed
2487
  my_bool require_file=0, q_send_flag=0;
2488
  char save_file[FN_REFLEN];
2489
  MY_INIT(argv[0]);
2490
  {
unknown's avatar
unknown committed
2491 2492
  DBUG_ENTER("main");
  DBUG_PROCESS(argv[0]);
2493

2494
  save_file[0]=0;
2495
  TMPDIR[0]=0;
unknown's avatar
unknown committed
2496 2497 2498 2499
  memset(cons, 0, sizeof(cons));
  cons_end = cons + MAX_CONS;
  next_con = cons + 1;
  cur_con = cons;
unknown's avatar
unknown committed
2500

unknown's avatar
unknown committed
2501
  memset(file_stack, 0, sizeof(file_stack));
unknown's avatar
unknown committed
2502
  memset(&master_pos, 0, sizeof(master_pos));
unknown's avatar
unknown committed
2503 2504
  file_stack_end = file_stack + MAX_INCLUDE_DEPTH;
  cur_file = file_stack;
2505
  lineno   = lineno_stack;
2506
  my_init_dynamic_array(&q_lines, sizeof(struct st_query*), INIT_Q_LINES,
2507 2508 2509
		     INIT_Q_LINES);
  memset(block_stack, 0, sizeof(block_stack));
  block_stack_end = block_stack + BLOCK_STACK_DEPTH;
2510
  memset(block_ok_stack, 0, sizeof(block_stack));
2511
  cur_block = block_stack;
2512 2513
  block_ok = block_ok_stack;
  *block_ok = 1;
2514
  init_dynamic_string(&ds_res, "", 0, 65536);
unknown's avatar
unknown committed
2515
  parse_args(argc, argv);
2516 2517 2518
  if (mysql_server_init(embedded_server_arg_count,
			embedded_server_args,
			(char**) embedded_server_groups))
unknown's avatar
unknown committed
2519 2520 2521
    die("Can't initialize MySQL server");
  if (cur_file == file_stack)
    *++cur_file = stdin;
2522
  *lineno=1;
2523 2524 2525
#ifndef EMBEDDED_LIBRARY
  if (manager_host)
    init_manager();
2526
#endif
2527
  if (!( mysql_init(&cur_con->mysql)))
unknown's avatar
unknown committed
2528
    die("Failed in mysql_init()");
unknown's avatar
unknown committed
2529 2530
  if (opt_compress)
    mysql_options(&cur_con->mysql,MYSQL_OPT_COMPRESS,NullS);
2531
  mysql_options(&cur_con->mysql, MYSQL_OPT_LOCAL_INFILE, 0);
unknown's avatar
unknown committed
2532 2533 2534 2535 2536
#ifdef HAVE_OPENSSL
  if (opt_use_ssl)
    mysql_ssl_set(&cur_con->mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
		  opt_ssl_capath, opt_ssl_cipher);
#endif
2537

unknown's avatar
unknown committed
2538
  if (!(cur_con->name = my_strdup("default", MYF(MY_WME))))
unknown's avatar
unknown committed
2539
    die("Out of memory");
unknown's avatar
unknown committed
2540

unknown's avatar
unknown committed
2541
  if (safe_connect(&cur_con->mysql, host, user, pass, db, port, unix_sock))
unknown's avatar
unknown committed
2542 2543
    die("Failed in mysql_real_connect(): %s", mysql_error(&cur_con->mysql));

unknown's avatar
unknown committed
2544 2545
  init_var_hash(&cur_con->mysql);

2546
  while (!read_query(&q))
2547 2548 2549 2550
  {
    int current_line_inc = 1, processed = 0;
    if (q->type == Q_UNKNOWN || q->type == Q_COMMENT_WITH_COMMAND)
      get_query_type(q);
2551
    if (*block_ok)
unknown's avatar
unknown committed
2552
    {
2553 2554 2555
      processed = 1;
      switch (q->type) {
      case Q_CONNECT: do_connect(q); break;
2556
      case Q_CONNECTION: select_connection(q->first_argument); break;
unknown's avatar
unknown committed
2557
      case Q_DISCONNECT:
2558
      case Q_DIRTY_CLOSE:
unknown's avatar
unknown committed
2559
	close_connection(q); break;
2560
      case Q_RPL_PROBE: do_rpl_probe(q); break;
2561
      case Q_ENABLE_RPL_PARSE:	 do_enable_rpl_parse(q); break;
unknown's avatar
unknown committed
2562
      case Q_DISABLE_RPL_PARSE:  do_disable_rpl_parse(q); break;
2563
      case Q_ENABLE_QUERY_LOG:	 disable_query_log=0; break;
unknown's avatar
unknown committed
2564 2565 2566
      case Q_DISABLE_QUERY_LOG:  disable_query_log=1; break;
      case Q_ENABLE_RESULT_LOG:  disable_result_log=0; break;
      case Q_DISABLE_RESULT_LOG: disable_result_log=1; break;
2567 2568 2569 2570
      case Q_ENABLE_WARNINGS:    disable_warnings=0; break;
      case Q_DISABLE_WARNINGS:   disable_warnings=1; break;
      case Q_ENABLE_INFO:    	 disable_info=0; break;
      case Q_DISABLE_INFO:   	 disable_info=1; break;
2571
      case Q_SOURCE: do_source(q); break;
2572 2573
      case Q_SLEEP: do_sleep(q, 0); break;
      case Q_REAL_SLEEP: do_sleep(q, 1); break;
2574
      case Q_REQUIRE_VERSION: do_require_version(q); break;
2575
      case Q_WAIT_FOR_SLAVE_TO_STOP: do_wait_for_slave_to_stop(q); break;
2576
      case Q_REQUIRE_MANAGER: do_require_manager(q); break;
2577
#ifndef EMBEDDED_LIBRARY
2578 2579
      case Q_SERVER_START: do_server_start(q); break;
      case Q_SERVER_STOP: do_server_stop(q); break;
2580
#endif
2581 2582 2583 2584
      case Q_INC: do_inc(q); break;
      case Q_DEC: do_dec(q); break;
      case Q_ECHO: do_echo(q); break;
      case Q_SYSTEM: do_system(q); break;
2585 2586 2587 2588
      case Q_DELIMITER:
	strmake(delimiter, q->first_argument, sizeof(delimiter) - 1);
	delimiter_length= strlen(delimiter);
	break;
2589
      case Q_DISPLAY_VERTICAL_RESULTS: display_result_vertically= TRUE; break;
2590
      case Q_DISPLAY_HORIZONTAL_RESULTS: 
2591
	display_result_vertically= FALSE; break;
2592
      case Q_LET: do_let(q); break;
2593
      case Q_EVAL_RESULT: eval_result = 1; break;
2594
      case Q_EVAL:
2595
	if (q->query == q->query_buf)
unknown's avatar
unknown committed
2596
	  q->query= q->first_argument;
2597
	/* fall through */
2598
      case Q_QUERY_VERTICAL:
2599
      case Q_QUERY_HORIZONTAL:
2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613
      {
	my_bool old_display_result_vertically= display_result_vertically;
	if (!q->query[q->first_word_len])
	{
	  /* This happens when we use 'query_..' on it's own line */
	  q_send_flag=1;
	  break;
	}
	/* fix up query pointer if this is * first iteration for this line */
	if (q->query == q->query_buf)
	  q->query += q->first_word_len + 1;
	switch(q->type)
	{
	case Q_QUERY_VERTICAL: display_result_vertically= TRUE; break;
2614
	case Q_QUERY_HORIZONTAL: display_result_vertically= FALSE; break;
2615 2616 2617 2618 2619
	}
	error |= run_query(&cur_con->mysql, q, QUERY_REAP|QUERY_SEND);
	display_result_vertically= old_display_result_vertically;
	break;
      }
2620
      case Q_QUERY:
2621
      case Q_REAP:
2622
      {
2623 2624 2625 2626 2627
	/*
	  We read the result always regardless of the mode for both full
	  query and read-result only (reap)
	*/
	int flags = QUERY_REAP;
2628
	if (q->type != Q_REAP) /* for a full query, enable the send stage */
unknown's avatar
unknown committed
2629
	  flags |= QUERY_SEND;
unknown's avatar
unknown committed
2630 2631 2632 2633 2634
	if (q_send_flag)
	{
	  flags= QUERY_SEND;
	  q_send_flag=0;
	}
2635
	if (save_file[0])
2636
	{
2637 2638 2639
	  strmov(q->record_file,save_file);
	  q->require_file=require_file;
	  save_file[0]=0;
2640
	}
unknown's avatar
unknown committed
2641
	error |= run_query(&cur_con->mysql, q, flags);
unknown's avatar
unknown committed
2642
	break;
2643
      }
unknown's avatar
unknown committed
2644
      case Q_SEND:
unknown's avatar
unknown committed
2645 2646 2647 2648 2649 2650 2651 2652
	if (!q->query[q->first_word_len])
	{
	  /* This happens when we use 'send' on it's own line */
	  q_send_flag=1;
	  break;
	}
	/* fix up query pointer if this is * first iteration for this line */
	if (q->query == q->query_buf)
2653
	  q->query += q->first_word_len;
2654 2655 2656 2657 2658
	/*
	  run_query() can execute a query partially, depending on the flags
	  QUERY_SEND flag without QUERY_REAP tells it to just send the
	  query and read the result some time later when reap instruction
	  is given on this connection.
2659
	 */
2660
	error |= run_query(&cur_con->mysql, q, QUERY_SEND);
unknown's avatar
unknown committed
2661
	break;
2662 2663 2664 2665
      case Q_RESULT:
	get_file_name(save_file,q);
	require_file=0;
	break;
unknown's avatar
unknown committed
2666
      case Q_ERROR:
unknown's avatar
unknown committed
2667
	global_expected_errors=get_ints(global_expected_errno,q);
unknown's avatar
unknown committed
2668
	break;
2669 2670 2671 2672
      case Q_REQUIRE:
	get_file_name(save_file,q);
	require_file=1;
	break;
unknown's avatar
unknown committed
2673 2674 2675
      case Q_REPLACE:
	get_replace(q);
	break;
2676 2677 2678
      case Q_REPLACE_COLUMN:
	get_replace_column(q);
	break;
2679 2680
      case Q_SAVE_MASTER_POS: do_save_master_pos(); break;
      case Q_SYNC_WITH_MASTER: do_sync_with_master(q); break;
2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693
      case Q_SYNC_SLAVE_WITH_MASTER:
      {
	do_save_master_pos();
	if (*q->first_argument)
	  select_connection(q->first_argument);
	else
	{
	  char buf[] = "slave";
	  select_connection(buf);
	}
	do_sync_with_master2("");
	break;
      }
2694
      case Q_COMMENT:				/* Ignore row */
2695
      case Q_COMMENT_WITH_COMMAND:
2696
	break;
2697 2698 2699
      case Q_PING:
	(void) mysql_ping(&cur_con->mysql);
	break;
2700 2701 2702
      case Q_EXEC: 
	(void) do_exec(q);
	break;
2703 2704 2705
      default: processed = 0; break;
      }
    }
2706

2707 2708 2709
    if (!processed)
    {
      current_line_inc = 0;
unknown's avatar
unknown committed
2710
      switch (q->type) {
2711 2712 2713 2714
      case Q_WHILE: do_while(q); break;
      case Q_END_BLOCK: do_done(q); break;
      default: current_line_inc = 1; break;
      }
unknown's avatar
unknown committed
2715 2716
    }

2717 2718 2719
    parser.current_line += current_line_inc;
  }

2720
  if (result_file && ds_res.length)
2721
  {
2722
    if (!record)
2723 2724
      error |= check_result(&ds_res, result_file, q->require_file);
    else
2725
      str_to_file(result_file, ds_res.str, ds_res.length);
2726
  }
2727
  dynstr_free(&ds_res);
2728

unknown's avatar
unknown committed
2729 2730
  if (!silent)
  {
2731
    if (error)
unknown's avatar
unknown committed
2732 2733 2734 2735
      printf("not ok\n");
    else
      printf("ok\n");
  }
2736

2737
  free_used_memory();
2738 2739
  exit(error ? 1 : 0);
  return error ? 1 : 0;				/* Keep compiler happy */
2740
  }
unknown's avatar
unknown committed
2741
}
unknown's avatar
unknown committed
2742

2743

2744 2745 2746 2747 2748 2749
/*
  Read arguments for embedded server and put them into
  embedded_server_args_count and embedded_server_args[]
*/


unknown's avatar
unknown committed
2750
static int read_server_arguments(const char *name)
2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
{
  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,"","",4);

  if (!embedded_server_arg_count)
  {
    embedded_server_arg_count=1;
    embedded_server_args[0]= (char*) "";		/* Progname */
  }
unknown's avatar
unknown committed
2767
  if (!(file=my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788
    return 1;
  while (embedded_server_arg_count < MAX_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));
      return 1;
    }
    embedded_server_arg_count++;
  }
  my_fclose(file,MYF(0));
  if (str)
  {
    fprintf(stderr,"Too many arguments in option file: %s\n",name);
    return 1;
  }
  return 0;
}
unknown's avatar
unknown committed
2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802

/****************************************************************************
* Handle replacement of strings
****************************************************************************/

#define PC_MALLOC		256	/* Bytes for pointers */
#define PS_MALLOC		512	/* Bytes for data */

#define SPACE_CHAR	256
#define START_OF_LINE	257
#define END_OF_LINE	258
#define LAST_CHAR_CODE	259

typedef struct st_replace {
2803
  bool	 found;
unknown's avatar
unknown committed
2804 2805 2806 2807 2808 2809 2810 2811 2812 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 2842 2843 2844 2845 2846 2847 2848 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 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908
  struct st_replace *next[256];
} REPLACE;

typedef struct st_replace_found {
  bool found;
  char *replace_string;
  uint to_offset;
  int from_offset;
} REPLACE_STRING;

#ifndef WORD_BIT
#define WORD_BIT (8*sizeof(uint))
#endif


static int insert_pointer_name(reg1 POINTER_ARRAY *pa,my_string name)
{
  uint i,length,old_count;
  byte *new_pos;
  const char **new_array;
  DBUG_ENTER("insert_pointer_name");

  if (! pa->typelib.count)
  {
    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))))
    {
      my_free((gptr) pa->typelib.type_names,MYF(0));
      DBUG_RETURN (-1);
    }
    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;
  }
  length=(uint) strlen(name)+1;
  if (pa->length+length >= pa->max_length)
  {
    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)
    {
      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;
    }
    pa->max_length+=PS_MALLOC;
  }
  if (pa->typelib.count >= pa->max_count-1)
  {
    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));
  }
  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 */


	/* free pointer array */

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 */


	/* Code for replace rutines */

#define SET_MALLOC_HUNC 64

typedef struct st_rep_set {
2909 2910
  uint	*bits;				/* Pointer to used sets */
  short next[LAST_CHAR_CODE];		/* Pointer to next sets */
unknown's avatar
unknown committed
2911 2912
  uint	found_len;			/* Best match to date */
  int	found_offset;
2913 2914
  uint	table_offset;
  uint	size_of_bits;			/* For convinience */
unknown's avatar
unknown committed
2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 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 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444
} 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;


static int init_sets(REP_SETS *sets,uint states);
static REP_SET *make_new_set(REP_SETS *sets);
static void make_sets_invisible(REP_SETS *sets);
static void free_last_set(REP_SETS *sets);
static void free_sets(REP_SETS *sets);
static void set_bit(REP_SET *set, uint bit);
static void clear_bit(REP_SET *set, uint bit);
static void or_bits(REP_SET *to,REP_SET *from);
static void copy_bits(REP_SET *to,REP_SET *from);
static int cmp_bits(REP_SET *set1,REP_SET *set2);
static int get_next_bit(REP_SET *set,uint lastpos);
static int find_set(REP_SETS *sets,REP_SET *find);
static int find_found(FOUND_SET *found_set,uint table_offset,
			  int found_offset);
static uint start_at_word(my_string pos);
static uint end_of_word(my_string pos);
static uint replace_len(my_string pos);

static uint found_sets=0;


	/* Init a replace structure for further calls */

REPLACE *init_replace(my_string *from, my_string *to,uint count,
		      my_string word_end_chars)
{
  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);
  }

	/* Init follow_ptr[] */
  for (i=0, states=1, follow_ptr=follow+1 ; i < count ; i++)
  {
    if (from[i][0] == '\\' && from[i][1] == '^')
    {
      set_bit(start_states,states+1);
      if (!from[i][2])
      {
	start_states->table_offset=i;
	start_states->found_offset=1;
      }
    }
    else if (from[i][0] == '\\' && from[i][1] == '$')
    {
      set_bit(start_states,states);
      set_bit(word_states,states);
      if (!from[i][2] && start_states->table_offset == (uint) ~0)
      {
	start_states->table_offset=i;
	start_states->found_offset=0;
      }
    }
    else
    {
      set_bit(word_states,states);
      if (from[i][0] == '\\' && (from[i][1] == 'b' && from[i][2]))
	set_bit(start_states,states+1);
      else
	set_bit(start_states,states);
    }
    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)
	      set_bit(new_set,i+1);		/* To next set */
	    else
	      set_bit(new_set,i);
	  }
	}
	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)))
	      clear_bit(new_set,i);
	    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);
      }
    }
  }

	/* Alloc replace structure for the replace-state-machine */

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


static int init_sets(REP_SETS *sets,uint states)
{
  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;
}

	/* Make help sets invisible for nicer codeing */

static void make_sets_invisible(REP_SETS *sets)
{
  sets->invisible=sets->count;
  sets->set+=sets->count;
  sets->count=0;
}

static REP_SET *make_new_set(REP_SETS *sets)
{
  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,
				   sizeof(REP_SET)*count,
				  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);
}

static void free_last_set(REP_SETS *sets)
{
  sets->count--;
  sets->extra++;
  return;
}

static void free_sets(REP_SETS *sets)
{
  my_free((gptr)sets->set_buffer,MYF(0));
  my_free((gptr)sets->bit_buffer,MYF(0));
  return;
}

static void set_bit(REP_SET *set, uint bit)
{
  set->bits[bit / WORD_BIT] |= 1 << (bit % WORD_BIT);
  return;
}

static void clear_bit(REP_SET *set, uint bit)
{
  set->bits[bit / WORD_BIT] &= ~ (1 << (bit % WORD_BIT));
  return;
}


static void or_bits(REP_SET *to,REP_SET *from)
{
  reg1 uint i;
  for (i=0 ; i < to->size_of_bits ; i++)
    to->bits[i]|=from->bits[i];
  return;
}

static void copy_bits(REP_SET *to,REP_SET *from)
{
  memcpy((byte*) to->bits,(byte*) from->bits,
	 (size_t) (sizeof(uint) * to->size_of_bits));
}

static int cmp_bits(REP_SET *set1,REP_SET *set2)
{
  return bcmp((byte*) set1->bits,(byte*) set2->bits,
	      sizeof(uint) * set1->size_of_bits);
}


	/* Get next set bit from set. */

static int get_next_bit(REP_SET *set,uint lastpos)
{
  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;
}

	/* 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 it's
	   position */

static int find_set(REP_SETS *sets,REP_SET *find)
{
  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 */
}

	/* 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's is
	   saved in set->next and set->next[] >= 0 points to next set and
	   set->next[] == -1 is reserved for end without replaces.
	   */

static int find_found(FOUND_SET *found_set,uint table_offset, int found_offset)
{
  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 */
}

	/* Return 1 if regexp starts with \b or ends with \b*/

static uint start_at_word(my_string pos)
{
  return (((!bcmp(pos,"\\b",2) && pos[2]) || !bcmp(pos,"\\^",2)) ? 1 : 0);
}

static uint end_of_word(my_string pos)
{
  my_string end=strend(pos);
  return ((end > pos+2 && !bcmp(end-2,"\\b",2)) ||
	  (end >= pos+2 && !bcmp(end-2,"\\$",2))) ?
	    1 : 0;
}


static uint replace_len(my_string str)
{
  uint len=0;
  while (*str)
  {
    if (str[0] == '\\' && str[1])
      str++;
    str++;
    len++;
  }
  return len;
}


	/* Replace strings;  Return length of result string */

3445
uint replace_strings(REPLACE *rep, my_string *start,uint *max_length,
unknown's avatar
unknown committed
3446
		     const char *from)
unknown's avatar
unknown committed
3447 3448 3449
{
  reg1 REPLACE *rep_pos;
  reg2 REPLACE_STRING *rep_str;
unknown's avatar
unknown committed
3450
  my_string to,end,pos,new_str;
unknown's avatar
unknown committed
3451 3452 3453

  end=(to= *start) + *max_length-1;
  rep_pos=rep+1;
3454
  for (;;)
unknown's avatar
unknown committed
3455 3456 3457 3458 3459 3460 3461
  {
    while (!rep_pos->found)
    {
      rep_pos= rep_pos->next[(uchar) *from];
      if (to == end)
      {
	(*max_length)+=8192;
unknown's avatar
unknown committed
3462
	if (!(new_str=my_realloc(*start,*max_length,MYF(MY_WME))))
unknown's avatar
unknown committed
3463
	  return (uint) -1;
unknown's avatar
unknown committed
3464 3465
	to=new_str+(to - *start);
	end=(*start=new_str)+ *max_length-1;
unknown's avatar
unknown committed
3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476
      }
      *to++= *from++;
    }
    if (!(rep_str = ((REPLACE_STRING*) rep_pos))->replace_string)
      return (uint) (to - *start)-1;
    to-=rep_str->to_offset;
    for (pos=rep_str->replace_string; *pos ; pos++)
    {
      if (to == end)
      {
	(*max_length)*=2;
unknown's avatar
unknown committed
3477
	if (!(new_str=my_realloc(*start,*max_length,MYF(MY_WME))))
unknown's avatar
unknown committed
3478
	  return (uint) -1;
unknown's avatar
unknown committed
3479 3480
	to=new_str+(to - *start);
	end=(*start=new_str)+ *max_length-1;
unknown's avatar
unknown committed
3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501
      }
      *to++= *pos;
    }
    if (!*(from-=rep_str->from_offset) && rep_pos->found != 2)
      return (uint) (to - *start);
    rep_pos=rep;
  }
}

static int initialize_replace_buffer(void)
{
  out_length=8192;
  if (!(out_buff=my_malloc(out_length,MYF(MY_WME))))
    return(1);
  return 0;
}

static void free_replace_buffer(void)
{
  my_free(out_buff,MYF(MY_WME));
}
3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558


/****************************************************************************
 Replace results for a column
*****************************************************************************/

static 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;
}

/*
  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.
*/

static void get_replace_column(struct st_query *q)
{
  char *from=q->first_argument;
  char *buff,*start;
  DBUG_ENTER("get_replace_columns");

  free_replace_column();
  if (!*from)
    die("Missing argument in %s\n", q->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, q);
    if (!(column_number= atoi(to)) || column_number > MAX_COLUMNS)
      die("Wrong column number to replace_columns in %s\n", q->query);
    if (!*from)
      die("Wrong number of arguments to replace in %s\n", q->query);
    to= get_string(&buff, &from, q);
    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));
}