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

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

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

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
20 21 22 23
 *
 * Written by:
 *   Sasha Pachev <sasha@mysql.com>
 *   Matt Wagner  <matt@mysql.com>
24
 *   Monty
25
 *   Jani
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!

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

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
45
#define MTEST_VERSION "1.27"
46

47
#include <my_global.h>
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi 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>
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
53
#include <mysqld_error.h>
54 55
#include <m_ctype.h>
#include <my_dir.h>
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
56
#include <hash.h>
57 58
#include <stdio.h>
#include <stdlib.h>
59
#include <my_getopt.h>
60 61 62 63
#include <stdarg.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
64
#include <violite.h>
65

66
#define MAX_QUERY  65536
67
#define PAD_SIZE	128
68 69
#define MAX_CONS   1024
#define MAX_INCLUDE_DEPTH 16
70
#define LAZY_GUESS_BUF_SIZE 8192
71 72
#define INIT_Q_LINES	  1024
#define MIN_VAR_ALLOC	  32
73
#define BLOCK_STACK_DEPTH  32
74
#define MAX_EXPECTED_ERRORS 10
75 76
#define QUERY_SEND  1
#define QUERY_REAP  2
77 78 79 80
#ifndef MYSQL_MANAGER_PORT
#define MYSQL_MANAGER_PORT 23546
#endif

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
81 82 83 84 85 86 87
/*
  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
88
#define MAX_CON_TRIES	5
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
89

90
#define SLAVE_POLL_INTERVAL 300000 /* 0.3 of a sec */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
91

92

93
enum {OPT_MANAGER_USER=256,OPT_MANAGER_HOST,OPT_MANAGER_PASSWD,
94
      OPT_MANAGER_PORT,OPT_MANAGER_WAIT_TIMEOUT, OPT_SKIP_SAFEMALLOC};
95

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

109
static char **default_argv;
110 111
static const char *load_default_groups[]= { "mysqltest","client",0 };

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
112 113 114 115 116
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];
117
static int  *block_ok_stack_end;
118

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
119
static int *cur_block, *block_stack_end;
120 121 122 123
static int block_stack[BLOCK_STACK_DEPTH];


static int block_ok_stack[BLOCK_STACK_DEPTH];
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
124
static uint global_expected_errno[MAX_EXPECTED_ERRORS], global_expected_errors;
125 126 127

DYNAMIC_ARRAY q_lines;

128
typedef struct
129 130 131 132 133
{
  char file[FN_REFLEN];
  ulong pos;
} MASTER_POS ;

134 135 136 137 138 139
struct connection
{
  MYSQL mysql;
  char *name;
};

140 141 142 143
typedef struct
{
  int read_lines,current_line;
} PARSER;
144

145 146
MYSQL_RES *last_result=0;

147
PARSER parser;
148
MASTER_POS master_pos;
149
int *block_ok; /* set to 0 if the current block should not be executed */
150
int false_block_depth = 0;
151 152
/* if set, all results are concated and compared against this file */
const char *result_file = 0;
153

154
typedef struct
155
{
156
  char *name;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
157
  int name_len;
158
  char *str_val;
159 160 161 162
  int str_val_len;
  int int_val;
  int alloced_len;
  int int_dirty; /* do not update string if int is updated until first read */
163
  int alloced;
164 165 166 167
} VAR;

VAR var_reg[10];
/*Perl/shell-like variable registers */
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
168
HASH var_hash;
169 170
my_bool disable_query_log=0, disable_result_log=0, disable_warnings=0;
my_bool disable_info= 1;			/* By default off */
171

172 173 174
struct connection cons[MAX_CONS];
struct connection* cur_con, *next_con, *cons_end;

175 176 177
  /* Add new commands before Q_UNKNOWN !*/

enum enum_commands {
178
Q_CONNECTION=1,     Q_QUERY,
179
Q_CONNECT,	    Q_SLEEP, Q_REAL_SLEEP, 
180 181 182 183 184 185
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,
186 187 188
Q_SYNC_WITH_MASTER,
Q_SYNC_SLAVE_WITH_MASTER,
Q_ERROR,
189 190 191 192
Q_SEND,		    Q_REAP,
Q_DIRTY_CLOSE,	    Q_REPLACE,
Q_PING,		    Q_EVAL,
Q_RPL_PROBE,	    Q_ENABLE_RPL_PARSE,
193
Q_DISABLE_RPL_PARSE, Q_EVAL_RESULT,
194
Q_ENABLE_QUERY_LOG, Q_DISABLE_QUERY_LOG,
195
Q_ENABLE_RESULT_LOG, Q_DISABLE_RESULT_LOG,
196
Q_SERVER_START, Q_SERVER_STOP,Q_REQUIRE_MANAGER,
197
Q_WAIT_FOR_SLAVE_TO_STOP,
198
Q_REQUIRE_VERSION,
199 200
Q_ENABLE_WARNINGS, Q_DISABLE_WARNINGS,
Q_ENABLE_INFO, Q_DISABLE_INFO,
201 202
Q_UNKNOWN,			       /* Unknown command.   */
Q_COMMENT,			       /* Comments, ignored. */
203 204 205
Q_COMMENT_WITH_COMMAND
};

206
/* this should really be called command */
207
struct st_query
208
{
209
  char *query, *query_buf,*first_argument,*end;
210
  int first_word_len;
211
  my_bool abort_on_error, require_file;
212
  uint expected_errno[MAX_EXPECTED_ERRORS];
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
213
  uint expected_errors;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
214
  char record_file[FN_REFLEN];
215
  enum enum_commands type;
216 217
};

218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
const char *command_names[]=
{
  "connection",
  "query",
  "connect",
  "sleep",
  "real_sleep",
  "inc",
  "dec",
  "source",
  "disconnect",
  "let",
  "echo",
  "while",
  "end",
  "system",
  "result",
  "require",
  "save_master_pos",
  "sync_with_master",
238
  "sync_slave_with_master",
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
  "error",
  "send",
  "reap",
  "dirty_close",
  "replace_result",
  "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",
258
  "require_version",
259 260 261 262
  "enable_warnings",
  "disable_warnings",
  "enable_info",
  "diable_info",
jcole@tetra.spaceapes.com's avatar
jcole@tetra.spaceapes.com committed
263
  0
264 265 266 267 268
};

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

269
DYNAMIC_STRING ds_res;
270
static void die(const char *fmt, ...);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
271 272
static void init_var_hash();
static byte* get_var_key(const byte* rec, uint* len,
273
			 my_bool __attribute__((unused)) t);
274
static VAR* var_init(VAR* v, const char *name, int name_len, const char *val,
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
275 276 277
		     int val_len);

static void var_free(void* v);
278

279 280
int dyn_string_cmp(DYNAMIC_STRING* ds, const char *fname);
void reject_dump(const char *record_file, char *buf, int size);
281

282
int close_connection(struct st_query* q);
283 284
VAR* var_get(const char *var_name, const char** var_name_end, my_bool raw,
	     my_bool ignore_not_existing);
285 286
int eval_expr(VAR* v, const char *p, const char** p_end);
static int read_server_arguments(const char *name);
287

288 289 290 291 292 293
/* Definitions for replace */

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. */
294
  uint	array_allocs,max_count,length,max_length;
295 296 297 298 299 300
} 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,
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
301
		     uint *max_length, const char *from);
302
void free_replace();
303 304 305 306
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);
307 308 309
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);
310 311 312 313

struct st_replace *glob_replace;
static char *out_buff;
static uint out_length;
314
static int eval_result = 0;
315

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
316
/* Disable functions that only exist in MySQL 4.0 */
317 318 319 320
#if MYSQL_VERSION_ID < 40000 || defined(EMBEDDED_LIBRARY)
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; }
321
my_bool mysql_rpl_probe(MYSQL *mysql __attribute__((unused))) { return 1; }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
322 323
#endif

324 325 326 327 328 329 330 331 332 333 334 335 336
#define MAX_SERVER_ARGS 20

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

static const char *embedded_server_groups[] = {
  "server",
  "embedded",
  "mysqltest_SERVER",
  NullS
};


337 338 339 340 341 342
static void do_eval(DYNAMIC_STRING* query_eval, const char* query)
{
  const char* p;
  register char c;
  register int escaped = 0;
  VAR* v;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
343

344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
  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;
372
    }
373
  }
374
}
375

376

377 378
static void close_cons()
{
379
  DBUG_ENTER("close_cons");
380 381
  if (last_result)
    mysql_free_result(last_result);
382 383 384 385 386 387 388 389
  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;
}

390

391 392
static void close_files()
{
393 394
  DBUG_ENTER("close_files");
  for (; cur_file != file_stack ; cur_file--)
395
  {
396
    if (*cur_file != stdin && *cur_file)
397
      my_fclose(*cur_file,MYF(0));
398 399
  }
  DBUG_VOID_RETURN;
400 401
}

402

403 404 405 406
static void free_used_memory()
{
  uint i;
  DBUG_ENTER("free_used_memory");
407
#ifndef EMBEDDED_LIBRARY
408 409
  if (manager)
    mysql_manager_close(manager);
410
#endif
411 412
  close_cons();
  close_files();
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
413
  hash_free(&var_hash);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
414

415 416 417
  for (i=0 ; i < q_lines.elements ; i++)
  {
    struct st_query **q= dynamic_element(&q_lines, i, struct st_query**);
418
    my_free((gptr) (*q)->query_buf,MYF(MY_ALLOW_ZERO_PTR));
419 420
    my_free((gptr) (*q),MYF(0));
  }
421
  for (i=0; i < 10; i++)
422
    {
423
      if (var_reg[i].alloced_len)
424 425
	my_free(var_reg[i].str_val, MYF(MY_WME));
    }
426 427
  while (embedded_server_arg_count > 1)
    my_free(embedded_server_args[--embedded_server_arg_count],MYF(0));
428 429
  delete_dynamic(&q_lines);
  dynstr_free(&ds_res);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
430
  free_replace();
431 432
  my_free(pass,MYF(MY_ALLOW_ZERO_PTR));
  free_defaults(default_argv);
433
  mysql_server_end();
434 435
  my_end(MY_CHECK_ERROR);
  DBUG_VOID_RETURN;
436 437 438 439 440
}

static void die(const char* fmt, ...)
{
  va_list args;
441
  DBUG_ENTER("die");
442
  va_start(args, fmt);
443 444 445 446 447
  if (fmt)
  {
    fprintf(stderr, "%s: ", my_progname);
    vfprintf(stderr, fmt, args);
    fprintf(stderr, "\n");
448
    fflush(stderr);
449
  }
450
  va_end(args);
451
  free_used_memory();
452 453 454
  exit(1);
}

455 456
/* Note that we will get some memory leaks when calling this! */

457 458
static void abort_not_supported_test()
{
459
  DBUG_ENTER("abort_not_supported_test");
460 461 462
  fprintf(stderr, "This test is not supported by this installation\n");
  if (!silent)
    printf("skipped\n");
463
  free_used_memory();
464 465 466 467 468 469
  exit(2);
}

static void verbose_msg(const char* fmt, ...)
{
  va_list args;
470 471 472
  DBUG_ENTER("verbose_msg");
  if (!verbose)
    DBUG_VOID_RETURN;
473 474 475

  va_start(args, fmt);

476
  fprintf(stderr, "%s: At line %u: ", my_progname, start_lineno);
477 478 479
  vfprintf(stderr, fmt, args);
  fprintf(stderr, "\n");
  va_end(args);
480
  DBUG_VOID_RETURN;
481 482
}

483

484 485 486 487 488
void init_parser()
{
  parser.current_line = parser.read_lines = 0;
  memset(&var_reg,0, sizeof(var_reg));
}
489 490 491

int hex_val(int c)
{
492
  if (my_isdigit(system_charset_info,c))
493
    return c - '0';
494
  else if ((c = my_tolower(system_charset_info,c)) >= 'a' && c <= 'f')
495 496 497 498 499
    return c - 'a' + 10;
  else
    return -1;
}

500
int dyn_string_cmp(DYNAMIC_STRING* ds, const char* fname)
501 502
{
  MY_STAT stat_info;
503 504
  char *tmp, *res_ptr;
  char eval_file[FN_REFLEN];
505
  int res;
506
  uint res_len;
507
  int fd;
508
  DYNAMIC_STRING res_ds;
509 510
  DBUG_ENTER("dyn_string_cmp");

511 512 513 514 515 516 517 518 519
  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)))
520
    die(NullS);
521
  if (!eval_result && stat_info.st_size != ds->length)
522
    DBUG_RETURN(2);
523
  if (!(tmp = (char*) my_malloc(stat_info.st_size + 1, MYF(MY_WME))))
524
    die(NullS);
525 526

  if ((fd = my_open(eval_file, O_RDONLY, MYF(MY_WME))) < 0)
527
    die(NullS);
528
  if (my_read(fd, (byte*)tmp, stat_info.st_size, MYF(MY_WME|MY_NABP)))
529
    die(NullS);
530 531 532 533 534 535
  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;
536
    if ((res_len = res_ds.length) != ds->length)
537 538 539 540 541 542 543 544 545 546
    {
      res = 2;
      goto err;
    }
  }
  else
  {
    res_ptr = tmp;
    res_len = stat_info.st_size;
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
547

548
  res = (memcmp(res_ptr, ds->str, res_len)) ?  1 : 0;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
549

550 551 552 553
err:
  if (res && eval_result)
    str_to_file(fn_format(eval_file, fname, "", ".eval",2), res_ptr,
		res_len);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
554

555 556
  my_free((gptr) tmp, MYF(0));
  my_close(fd, MYF(MY_WME));
557
  dynstr_free(&res_ds);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
558

559
  DBUG_RETURN(res);
560 561
}

562
static int check_result(DYNAMIC_STRING* ds, const char* fname,
563
			my_bool require_option)
564 565
{
  int error = 0;
566 567 568 569
  int res=dyn_string_cmp(ds, fname);

  if (res && require_option)
    abort_not_supported_test();
570
  switch (res) {
571 572 573 574 575 576 577 578 579 580 581 582 583 584
  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)
585
    reject_dump(fname, ds->str, ds->length);
586 587 588
  return error;
}

589 590
VAR* var_get(const char* var_name, const char** var_name_end, my_bool raw,
	     my_bool ignore_not_existing)
591 592 593
{
  int digit;
  VAR* v;
594 595 596 597
  DBUG_ENTER("var_get");
  DBUG_PRINT("enter",("var_name: %s",var_name));

  if (*var_name != '$')
598
    goto err;
599
  digit = *++var_name - '0';
600 601
  if (!(digit < 10 && digit >= 0))
  {
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
602 603
    const char* save_var_name = var_name, *end;
    end = (var_name_end) ? *var_name_end : 0;
604
    while (my_isvar(system_charset_info,*var_name) && var_name != end)
605
      ++var_name;
606 607 608 609
    if (var_name == save_var_name)
    {
      if (ignore_not_existing)
	DBUG_RETURN(0);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
610
      die("Empty variable");
611
    }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
612

613
    if (!(v = (VAR*) hash_search(&var_hash, save_var_name,
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
614
			       var_name - save_var_name)))
615 616 617 618 619 620 621 622
    {
      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 */
623
  }
624
  else
625
    v = var_reg + digit;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
626

627 628 629 630
  if (!raw && v->int_dirty)
  {
    sprintf(v->str_val, "%d", v->int_val);
    v->int_dirty = 0;
631
    v->str_val_len = strlen(v->str_val);
632
  }
633
  if (var_name_end)
634
    *var_name_end = var_name  ;
635
  DBUG_RETURN(v);
636 637
err:
  if (var_name_end)
638 639
    *var_name_end = 0;
  die("Unsupported variable name: %s", var_name);
640
  DBUG_RETURN(0);
641 642
}

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
643 644 645
static VAR* var_obtain(char* name, int len)
{
  VAR* v;
646
  if ((v = (VAR*)hash_search(&var_hash, name, len)))
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
647
    return v;
648
  v = var_init(0, name, len, "", 0);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
649 650 651 652
  hash_insert(&var_hash, (byte*)v);
  return v;
}

653 654 655 656 657
int var_set(char* var_name, char* var_name_end, char* var_val,
	    char* var_val_end)
{
  int digit;
  VAR* v;
658
  if (*var_name++ != '$')
659 660 661 662 663 664
    {
      --var_name;
      *var_name_end = 0;
      die("Variable name in %s does not start with '$'", var_name);
    }
  digit = *var_name - '0';
665
  if (!(digit < 10 && digit >= 0))
666
    {
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
667
      v = var_obtain(var_name, var_name_end - var_name);
668
    }
669
  else
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
670
   v = var_reg + digit;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
671

672
  return eval_expr(v, var_val, (const char**)&var_val_end);
673 674
}

675 676
int open_file(const char* name)
{
677 678 679 680 681 682 683 684
  char buff[FN_REFLEN];
  if (!test_if_hard_path(name))
  {
    strxmov(buff, opt_basedir, name, NullS);
    name=buff;
  }
  fn_format(buff,name,"","",4);

685
  if (*cur_file && cur_file == file_stack_end)
686
    die("Source directives are nesting too deep");
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
687
  if (!(*(cur_file+1) = my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
688 689
    die(NullS);
  cur_file++;
690
  *++lineno=1;
691

692 693 694
  return 0;
}

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

696
/* ugly long name, but we are following the convention */
697
int do_wait_for_slave_to_stop(struct st_query* q __attribute__((unused)))
698 699 700 701 702 703 704 705
{
  MYSQL* mysql = &cur_con->mysql;
  for (;;)
  {
    MYSQL_RES* res;
    MYSQL_ROW row;
    int done;
    LINT_INIT(res);
706

707 708 709 710 711 712 713 714 715 716 717 718 719
    if (mysql_query(mysql,"show status like 'Slave_running'")
	|| !(res=mysql_store_result(mysql)))
      die("Query failed while probing slave for stop: %s",
	  mysql_error(mysql));
    if (!(row=mysql_fetch_row(res)) || !row[1])
    {
      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;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
720
    my_sleep(SLAVE_POLL_INTERVAL);
721 722 723 724
  }
  return 0;
}

725
int do_require_manager(struct st_query* a __attribute__((unused)))
726 727 728 729 730 731
{
  if (!manager)
    abort_not_supported_test();
  return 0;
}

732
#ifndef EMBEDDED_LIBRARY
733 734 735 736 737 738 739 740 741 742 743 744 745 746
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;
747 748 749 750
  if (!manager)
  {
    die("Manager is not initialized, manager commands are not possible");
  }
751 752 753 754
  com_p=strmov(com_buf,op);
  com_p=strmov(com_p,"_exec ");
  if (!*p)
    die("Missing server name in server_%s\n",op);
755
  while (*p && !my_isspace(system_charset_info,*p))
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
  {
   *com_p++=*p++;
  }
  *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;
}
774
#endif
775

776 777 778 779 780 781 782 783
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);
784

785 786 787
  if (!*p)
    die("Missing version argument in require_version\n");
  ver_arg = p;
788
  while (*p && !my_isspace(system_charset_info,*p))
789 790 791
    p++;
  *p = 0;
  ver_arg_len = p - ver_arg;
792

793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
  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;
}

812
int do_source(struct st_query* q)
813
{
814
  char* p=q->first_argument, *name;
815
  if (!*p)
816 817
    die("Missing file name in source\n");
  name = p;
818
  while (*p && !my_isspace(system_charset_info,*p))
819 820
    p++;
  *p = 0;
821

822 823 824
  return open_file(name);
}

825 826 827 828 829 830 831
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);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
832

833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853
  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])
    eval_expr(v, row[0], 0);
  else
    eval_expr(v, "", 0);

  mysql_free_result(res);
  return 0;
}
854

855 856 857 858 859
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 &&
860
      !(dest->str_val=my_realloc(dest->str_val,src->alloced_len+1,
861 862 863
				 MYF(MY_WME))))
    die("Out of memory");
  dest->str_val_len=src->str_val_len;
864
  memcpy(dest->str_val,src->str_val,src->str_val_len+1);
865 866
}

867
int eval_expr(VAR* v, const char* p, const char** p_end)
868 869
{
  VAR* vp;
870
  if (*p == '$')
871 872
  {
    if ((vp = var_get(p,p_end,0,0)))
873
    {
874 875
      var_copy(v, vp);
      return 0;
876
    }
877
  }
878
  else if (*p == '`')
879 880 881
  {
    return var_query_set(v, p, p_end);
  }
882 883
  else
    {
884 885 886 887
      int new_val_len = (p_end && *p_end) ?
	 (int) (*p_end - p) : (int) strlen(p);
      if (new_val_len + 1 >= v->alloced_len)
      {
888
	v->alloced_len = (new_val_len < MIN_VAR_ALLOC - 1) ?
889 890
	  MIN_VAR_ALLOC : new_val_len + 1;
	if (!(v->str_val =
891
	      v->str_val ? my_realloc(v->str_val, v->alloced_len+1,
892
				      MYF(MY_WME)) :
893
	      my_malloc(v->alloced_len+1, MYF(MY_WME))))
894 895 896 897 898
	  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;
899 900
      v->int_val=atoi(p);
      v->int_dirty=0;
901 902
      return 0;
    }
903

904
  if (p_end)
905 906 907 908 909
    *p_end = 0;
  die("Invalid expr: %s", p);
  return 1;
}

910
int do_inc(struct st_query* q)
911
{
912
  char* p=q->first_argument;
913
  VAR* v;
914
  v = var_get(p, 0, 1, 0);
915 916 917 918 919
  v->int_val++;
  v->int_dirty = 1;
  return 0;
}

920
int do_dec(struct st_query* q)
921
{
922
  char* p=q->first_argument;
923
  VAR* v;
924
  v = var_get(p, 0, 1, 0);
925 926 927 928 929
  v->int_val--;
  v->int_dirty = 1;
  return 0;
}

930
int do_system(struct st_query* q)
931
{
932
  char* p=q->first_argument;
933
  VAR v;
934
  var_init(&v, 0, 0, 0, 0);
935
  eval_expr(&v, p, 0); /* NULL terminated */
936
  if (v.str_val_len)
937 938
    {
      char expr_buf[512];
939
      if ((uint)v.str_val_len > sizeof(expr_buf) - 1)
940 941 942
	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;
943
      DBUG_PRINT("info", ("running system command '%s'", expr_buf));
944
      if (system(expr_buf) && q->abort_on_error)
945 946
	die("system command '%s' failed", expr_buf);
    }
947
  var_free(&v);
948 949
  return 0;
}
950

951
int do_echo(struct st_query* q)
952
{
953
  char* p=q->first_argument;
954
  VAR v;
955
  var_init(&v,0,0,0,0);
956
  eval_expr(&v, p, 0); /* NULL terminated */
957 958 959 960 961
  if (v.str_val_len)
  {
    fflush(stdout);
    write(1, v.str_val, v.str_val_len);
  }
962
  write(1, "\n", 1);
963
  var_free(&v);
964 965 966
  return 0;
}

967

968
int do_sync_with_master2(const char* p)
969 970 971 972 973
{
  MYSQL_RES* res;
  MYSQL_ROW row;
  MYSQL* mysql = &cur_con->mysql;
  char query_buf[FN_REFLEN+128];
974
  int offset = 0;
975 976
  int rpl_parse;

977 978 979 980
  if (!master_pos.file[0])
  {
    die("Line %u: Calling 'sync_with_master' without calling 'save_master_pos'", start_lineno);
  }
981 982
  rpl_parse = mysql_rpl_parse_enabled(mysql);
  mysql_disable_rpl_parse(mysql);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
983

984
  if (*p)
985
    offset = atoi(p);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
986

987
  sprintf(query_buf, "select master_pos_wait('%s', %ld)", master_pos.file,
988
	  master_pos.pos + offset);
989 990
  if (mysql_query(mysql, query_buf))
    die("line %u: failed in %s: %d: %s", start_lineno, query_buf,
991 992
	mysql_errno(mysql), mysql_error(mysql));

993
  if (!(last_result = res = mysql_store_result(mysql)))
994 995
    die("line %u: mysql_store_result() returned NULL for '%s'", start_lineno,
	query_buf);
996
  if (!(row = mysql_fetch_row(res)))
997
    die("line %u: empty result in %s", start_lineno, query_buf);
998
  if (!row[0])
999
    die("Error on slave while syncing with master");
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1000 1001
  mysql_free_result(res);
  last_result=0;
1002
  if (rpl_parse)
1003
    mysql_enable_rpl_parse(mysql);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1004

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1005 1006 1007 1008 1009 1010 1011
#ifndef TO_BE_REMOVED
  /*
    We need this because wait_for_pos() only waits for the relay log,
    which doesn't guarantee that the slave has executed the statement.
  */
  my_sleep(2*1000000L);
#endif
1012 1013 1014
  return 0;
}

1015 1016 1017 1018
int do_sync_with_master(struct st_query* q)
{
  return do_sync_with_master2(q->first_argument);
}
1019

1020 1021 1022 1023 1024
int do_save_master_pos()
{
  MYSQL_RES* res;
  MYSQL_ROW row;
  MYSQL* mysql = &cur_con->mysql;
1025
  const char *query;
1026 1027 1028 1029
  int rpl_parse;

  rpl_parse = mysql_rpl_parse_enabled(mysql);
  mysql_disable_rpl_parse(mysql);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1030

1031
  if (mysql_query(mysql, query= "show master status"))
1032 1033 1034
    die("At line %u: failed in show master status: %d: %s", start_lineno,
	mysql_errno(mysql), mysql_error(mysql));

1035
  if (!(last_result =res = mysql_store_result(mysql)))
1036 1037
    die("line %u: mysql_store_result() retuned NULL for '%s'", start_lineno,
	query);
1038
  if (!(row = mysql_fetch_row(res)))
1039
    die("line %u: empty result in show master status", start_lineno);
1040 1041
  strnmov(master_pos.file, row[0], sizeof(master_pos.file)-1);
  master_pos.pos = strtoul(row[1], (char**) 0, 10);
1042
  mysql_free_result(res); last_result=0;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1043

1044
  if (rpl_parse)
1045
    mysql_enable_rpl_parse(mysql);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1046

1047 1048 1049 1050
  return 0;
}


1051
int do_let(struct st_query* q)
1052
{
1053 1054
  char* p=q->first_argument;
  char *var_name, *var_name_end, *var_val_start;
1055
  if (!*p)
1056 1057
    die("Missing variable name in let\n");
  var_name = p;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1058
  while (*p && (*p != '=' || my_isspace(system_charset_info,*p)))
1059 1060
    p++;
  var_name_end = p;
1061
  if (*p == '=') p++;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1062
  while (*p && my_isspace(system_charset_info,*p))
1063 1064
    p++;
  var_val_start = p;
1065
  return var_set(var_name, var_name_end, var_val_start, q->end);
1066 1067
}

1068
int do_rpl_probe(struct st_query* q __attribute__((unused)))
1069
{
1070
  DBUG_ENTER("do_rpl_probe");
1071
  if (mysql_rpl_probe(&cur_con->mysql))
1072 1073
    die("Failed in mysql_rpl_probe(): '%s'", mysql_error(&cur_con->mysql));
  DBUG_RETURN(0);
1074 1075
}

1076
int do_enable_rpl_parse(struct st_query* q __attribute__((unused)))
1077 1078 1079 1080 1081
{
  mysql_enable_rpl_parse(&cur_con->mysql);
  return 0;
}

1082
int do_disable_rpl_parse(struct st_query* q __attribute__((unused)))
1083 1084 1085 1086 1087 1088
{
  mysql_disable_rpl_parse(&cur_con->mysql);
  return 0;
}


1089
int do_sleep(struct st_query* q, my_bool real_sleep)
1090
{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1091 1092
  char *p=q->first_argument;
  while (*p && my_isspace(system_charset_info,*p))
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1093
    p++;
1094 1095
  if (!*p)
    die("Missing argument in sleep\n");
1096
  if (opt_sleep && !real_sleep)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1097
    my_sleep(opt_sleep * 1000000L);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1098
  else
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1099
    my_sleep((ulong) (atof(p) * 1000000L));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1100
  return 0;
1101 1102
}

1103
static void get_file_name(char *filename, struct st_query* q)
1104
{
1105
  char* p=q->first_argument;
1106 1107
  strnmov(filename, p, FN_REFLEN);
  /* Remove end space */
1108
  while (p > filename && my_isspace(system_charset_info,p[-1]))
1109 1110 1111 1112
    p--;
  p[0]=0;
}

1113

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1114
static uint get_ints(uint *to,struct st_query* q)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1115 1116
{
  char* p=q->first_argument;
1117
  long val;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1118
  uint count=0;
1119 1120
  DBUG_ENTER("get_ints");

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1121 1122
  if (!*p)
    die("Missing argument in %s\n", q->query);
1123 1124 1125

  for (; (p=str2int(p,10,(long) INT_MIN, (long) INT_MAX, &val)) ; p++)
  {
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1126
    count++;
1127 1128 1129 1130 1131
    *to++= (uint) val;
    if (*p != ',')
      break;
  }
  *to++=0;					/* End of data */
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1132
  DBUG_RETURN(count);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1133 1134
}

1135 1136 1137
/*
  Get a string;  Return ptr to end of string
  Strings may be surrounded by " or '
1138 1139

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


1143 1144
static char *get_string(char **to_ptr, char **from_ptr,
			struct st_query* q)
1145 1146
{
  reg1 char c,sep;
1147
  char *to= *to_ptr, *from= *from_ptr, *start=to;
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
  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);

1194
  while (my_isspace(system_charset_info,*from))	/* Point to next string */
1195 1196
    from++;

1197 1198
  *to =0;				/* End of string marker */
  *to_ptr= to+1;			/* Store pointer to end */
1199
  *from_ptr= from;
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212

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


/*
  Get arguments for replace. The syntax is:
  replace from to [from to ...]
  Where each argument may be quoted with ' or "
1220 1221
  A argument may also be a variable, in which case the value of the
  variable is replaced.
1222 1223 1224 1225 1226 1227
*/

static void get_replace(struct st_query *q)
{
  uint i;
  char *from=q->first_argument;
1228
  char *buff,*start;
1229 1230 1231 1232
  char word_end_chars[256],*pos;
  POINTER_ARRAY to_array,from_array;
  DBUG_ENTER("get_replace");

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1233
  free_replace();
1234

1235 1236 1237 1238
  bzero((char*) &to_array,sizeof(to_array));
  bzero((char*) &from_array,sizeof(from_array));
  if (!*from)
    die("Missing argument in %s\n", q->query);
1239
  start=buff=my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
1240 1241 1242
  while (*from)
  {
    char *to=buff;
1243
    to=get_string(&buff, &from, q);
1244
    if (!*from)
1245
      die("Wrong number of arguments to replace in %s\n", q->query);
1246
    insert_pointer_name(&from_array,to);
1247
    to=get_string(&buff, &from, q);
1248 1249 1250
    insert_pointer_name(&to_array,to);
  }
  for (i=1,pos=word_end_chars ; i < 256 ; i++)
1251
    if (my_isspace(system_charset_info,i))
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1252
      *pos++= i;
1253
  *pos=0;					/* End pointer */
1254 1255 1256 1257 1258 1259 1260 1261
  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);
1262
  my_free(start, MYF(0));
1263
  DBUG_VOID_RETURN;
1264 1265 1266 1267
}

void free_replace()
{
1268
  DBUG_ENTER("free_replace");
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1269 1270 1271 1272 1273 1274
  if (glob_replace)
  {
    my_free((char*) glob_replace,MYF(0));
    glob_replace=0;
    free_replace_buffer();
  }
1275
  DBUG_VOID_RETURN;
1276 1277
}

1278
int select_connection(char *p)
1279
{
1280
  char* name;
1281
  struct connection *con;
1282 1283 1284
  DBUG_ENTER("select_connection");
  DBUG_PRINT("enter",("name: '%s'",p));

1285
  if (!*p)
1286 1287
    die("Missing connection name in connect\n");
  name = p;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1288
  while (*p && !my_isspace(system_charset_info,*p))
1289 1290
    p++;
  *p = 0;
1291

1292 1293
  for (con = cons; con < next_con; con++)
  {
1294
    if (!strcmp(con->name, name))
1295 1296 1297 1298 1299
    {
      cur_con = con;
      DBUG_RETURN(0);
    }
  }
1300
  die("connection '%s' not found in connection pool", name);
1301
  DBUG_RETURN(1);				/* Never reached */
1302 1303
}

1304
int close_connection(struct st_query* q)
1305
{
1306
  char* p=q->first_argument, *name;
1307
  struct connection *con;
1308 1309 1310
  DBUG_ENTER("close_connection");
  DBUG_PRINT("enter",("name: '%s'",p));

1311
  if (!*p)
1312 1313
    die("Missing connection name in connect\n");
  name = p;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1314
  while (*p && !my_isspace(system_charset_info,*p))
1315 1316
    p++;
  *p = 0;
1317

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1318
  for (con = cons; con < next_con; con++)
1319
  {
1320
    if (!strcmp(con->name, name))
1321
    {
1322
#ifndef EMBEDDED_LIBRARY
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1323 1324 1325
      if (q->type == Q_DIRTY_CLOSE)
      {
	if (con->mysql.net.vio)
1326
	{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1327 1328
	  vio_delete(con->mysql.net.vio);
	  con->mysql.net.vio = 0;
1329
	}
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1330
      }
1331
#endif
1332 1333 1334 1335
      mysql_close(&con->mysql);
      DBUG_RETURN(0);
    }
  }
1336
  die("connection '%s' not found in connection pool", name);
1337
  DBUG_RETURN(1);				/* Never reached */
1338 1339
}

1340

1341 1342
/*
   This one now is a hack - we may want to improve in in the
1343 1344 1345
   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
1346
*/
1347

1348 1349
char* safe_get_param(char* str, char** arg, const char* msg)
{
1350
  DBUG_ENTER("safe_get_param");
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1351 1352
  while (*str && my_isspace(system_charset_info,*str))
    str++;
1353
  *arg = str;
1354 1355
  for (; *str && *str != ',' && *str != ')' ; str++)
  {
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1356 1357
    if (my_isspace(system_charset_info,*str))
      *str = 0;
1358
  }
1359
  if (!*str)
1360
    die(msg);
1361

1362
  *str++ = 0;
1363
  DBUG_RETURN(str);
1364 1365
}

1366
#ifndef EMBEDDED_LIBRARY
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
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);

}
1377
#endif
1378

1379 1380 1381 1382 1383 1384 1385 1386
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)
  {
1387
    if (mysql_real_connect(con, host,user, pass, db, port, sock, 0))
1388 1389 1390 1391 1392 1393 1394 1395 1396
    {
      con_error = 0;
      break;
    }
    sleep(CON_RETRY_SLEEP);
  }
  return con_error;
}

1397 1398

int do_connect(struct st_query* q)
1399 1400 1401
{
  char* con_name, *con_user,*con_pass, *con_host, *con_port_str,
    *con_db, *con_sock;
1402
  char* p=q->first_argument;
1403
  char buff[FN_REFLEN];
1404
  int con_port;
1405
  int con_error;
1406
  int free_con_sock = 0;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1407

1408 1409
  DBUG_ENTER("do_connect");
  DBUG_PRINT("enter",("connect: %s",p));
1410

1411
  if (*p != '(')
1412
    die("Syntax error in connect - expected '(' found '%c'", *p);
1413 1414 1415 1416 1417 1418
  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");
1419 1420 1421 1422 1423 1424 1425
  if (!*p || *p == ';')				/* Default port and sock */
  {
    con_port=port;
    con_sock=(char*) unix_sock;
  }
  else
  {
1426
    VAR* var_port, *var_sock;
1427
    p = safe_get_param(p, &con_port_str, "missing connection port");
1428 1429
    if (*con_port_str == '$')
    {
1430
      if (!(var_port = var_get(con_port_str, 0, 0, 0)))
1431 1432 1433 1434
	die("Unknown variable '%s'", con_port_str+1);
      con_port = var_port->int_val;
    }
    else
1435
      con_port=atoi(con_port_str);
1436
    p = safe_get_param(p, &con_sock, "missing connection socket");
1437 1438
    if (*con_sock == '$')
    {
1439
      if (!(var_sock = var_get(con_sock, 0, 0, 0)))
1440 1441 1442 1443 1444 1445 1446
	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;
    }
1447
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1448

1449
  if (next_con == cons_end)
jcole@tetra.spaceapes.com's avatar
jcole@tetra.spaceapes.com committed
1450
    die("Connection limit exhausted - increase MAX_CONS in mysqltest.c");
1451

1452
  if (!mysql_init(&next_con->mysql))
1453
    die("Failed on mysql_init()");
1454 1455
  if (opt_compress)
    mysql_options(&next_con->mysql,MYSQL_OPT_COMPRESS,NullS);
1456 1457
  mysql_options(&next_con->mysql, MYSQL_OPT_LOCAL_INFILE, 0);

1458
  if (con_sock && !free_con_sock && *con_sock && *con_sock != FN_LIBCHAR)
1459
    con_sock=fn_format(buff, con_sock, TMPDIR, "",0);
1460 1461
  if (!con_db[0])
    con_db=db;
1462
  /* Special database to allow one to connect without a database name */
1463
  if (con_db && !strcmp(con_db,"*NO-ONE*"))
1464
    con_db=0;
1465 1466 1467
  if ((con_error = safe_connect(&next_con->mysql, con_host,
				con_user, con_pass,
				con_db, con_port, con_sock ? con_sock: 0)))
1468 1469 1470
    die("Could not open connection '%s': %s", con_name,
	mysql_error(&next_con->mysql));

1471
  if (!(next_con->name = my_strdup(con_name, MYF(MY_WME))))
1472
    die(NullS);
1473
  cur_con = next_con++;
1474 1475
  if (free_con_sock)
    my_free(con_sock, MYF(MY_WME));
1476
  DBUG_RETURN(0);
1477 1478
}

1479

1480
int do_done(struct st_query* q)
1481 1482
{
  q->type = Q_END_BLOCK;
1483
  if (cur_block == block_stack)
1484
    die("Stray '}' - end of block before beginning");
1485 1486
  if (*block_ok--)
  {
1487
    parser.current_line = *--cur_block;
1488
  }
1489
  else
1490
  {
1491 1492
    ++parser.current_line;
    --cur_block;
1493
  }
1494 1495 1496
  return 0;
}

1497
int do_while(struct st_query* q)
1498
{
1499
  char* p=q->first_argument;
1500
  const char* expr_start, *expr_end;
1501
  VAR v;
1502
  if (cur_block == block_stack_end)
1503
    die("Nesting too deeply");
1504
  if (!*block_ok)
1505 1506 1507 1508 1509 1510
  {
    ++false_block_depth;
    *++block_ok = 0;
    *cur_block++ = parser.current_line++;
    return 0;
  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1511

1512
  expr_start = strchr(p, '(');
1513
  if (!expr_start)
1514 1515
    die("missing '(' in while");
  expr_end = strrchr(expr_start, ')');
1516
  if (!expr_end)
1517
    die("missing ')' in while");
1518
  var_init(&v,0,0,0,0);
1519
  eval_expr(&v, ++expr_start, &expr_end);
1520
  *cur_block++ = parser.current_line++;
1521
  if (!v.int_val)
1522 1523 1524 1525
  {
    *++block_ok = 0;
    false_block_depth++;
  }
1526 1527
  else
    *++block_ok = 1;
1528
  var_free(&v);
1529
  return 0;
1530 1531
}

1532 1533 1534 1535 1536 1537 1538 1539

int safe_copy_unescape(char* dest, char* src, int size)
{
  register char* p_dest = dest, *p_src = src;
  register int c, val;
  enum { ST_NORMAL, ST_ESCAPED, ST_HEX2} state = ST_NORMAL ;

  size--; /* just to make life easier */
1540

1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
  for (; p_dest - size < dest && p_src - size < src &&
       (c = *p_src) != '\n' && c; ++p_src)
  {
    switch(state) {
    case ST_NORMAL:
      if (c == '\\')
	state = ST_ESCAPED;
      else
	*p_dest++ = c;
      break;
    case ST_ESCAPED:
      if ((val = hex_val(c)) > 0)
      {
	*p_dest = val;
	state = ST_HEX2;
      }
      else
      {
	state = ST_NORMAL;
	*p_dest++ = c;
      }
      break;
    case ST_HEX2:
      if ((val = hex_val(c)) > 0)
      {
	*p_dest = (*p_dest << 4) + val;
	p_dest++;
      }
      else
	*p_dest++ = c;
1571

1572 1573
      state = ST_NORMAL;
      break;
1574

1575
    }
1576
  }
1577 1578 1579 1580 1581

  *p_dest = 0;
  return (p_dest - dest);
}

1582

1583 1584 1585
int read_line(char* buf, int size)
{
  int c;
1586
  char* p = buf, *buf_end = buf + size-1;
1587 1588 1589 1590
  int no_save = 0;
  enum {R_NORMAL, R_Q1, R_ESC_Q_Q1, R_ESC_Q_Q2,
	R_ESC_SLASH_Q1, R_ESC_SLASH_Q2,
	R_Q2, R_COMMENT, R_LINE_START} state = R_LINE_START;
1591

1592
  start_lineno= *lineno;
1593 1594 1595 1596 1597
  for (; p < buf_end ;)
  {
    no_save = 0;
    c = fgetc(*cur_file);
    if (feof(*cur_file))
1598
    {
1599 1600
      if ((*cur_file) != stdin)
	my_fclose(*cur_file,MYF(0));
1601 1602
      cur_file--;
      lineno--;
1603 1604
      if (cur_file == file_stack)
	return 1;
1605
      continue;
1606
    }
1607

1608 1609
    switch(state) {
    case R_NORMAL:
1610 1611
      /*  Only accept '{' in the beginning of a line */
      if (c == ';')
1612 1613 1614 1615 1616 1617 1618 1619 1620
      {
	*p = 0;
	return 0;
      }
      else if (c == '\'')
	state = R_Q1;
      else if (c == '"')
	state = R_Q2;
      else if (c == '\n')
1621
      {
1622
	state = R_LINE_START;
1623 1624
	(*lineno)++;
      }
1625 1626 1627 1628 1629
      break;
    case R_COMMENT:
      if (c == '\n')
      {
	*p=0;
1630
	(*lineno)++;
1631 1632 1633 1634 1635 1636 1637 1638
	return 0;
      }
      break;
    case R_LINE_START:
      if (c == '#' || c == '-')
      {
	state = R_COMMENT;
      }
1639
      else if (my_isspace(system_charset_info,c))
1640 1641 1642
      {
	if (c == '\n')
	  start_lineno= ++*lineno;		/* Query hasn't started yet */
1643
	no_save = 1;
1644
      }
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655
      else if (c == '}')
      {
	*buf++ = '}';
	*buf = 0;
	return 0;
      }
      else if (c == ';' || c == '{')
      {
	*p = 0;
	return 0;
      }
1656 1657 1658 1659
      else if (c == '\'')
	state = R_Q1;
      else if (c == '"')
	state = R_Q2;
1660 1661 1662
      else
	state = R_NORMAL;
      break;
1663

1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
    case R_Q1:
      if (c == '\'')
	state = R_ESC_Q_Q1;
      else if (c == '\\')
	state = R_ESC_SLASH_Q1;
      break;
    case R_ESC_Q_Q1:
      if (c == ';')
      {
	*p = 0;
	return 0;
      }
      if (c != '\'')
	state = R_NORMAL;
1678 1679
      else
	state = R_Q1;
1680 1681 1682 1683
      break;
    case R_ESC_SLASH_Q1:
      state = R_Q1;
      break;
1684

1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
    case R_Q2:
      if (c == '"')
	state = R_ESC_Q_Q2;
      else if (c == '\\')
	state = R_ESC_SLASH_Q2;
      break;
    case R_ESC_Q_Q2:
      if (c == ';')
      {
	*p = 0;
	return 0;
      }
      if (c != '"')
	state = R_NORMAL;
1699 1700
      else
	state = R_Q2;
1701 1702 1703 1704
      break;
    case R_ESC_SLASH_Q2:
      state = R_Q2;
      break;
1705
    }
1706 1707 1708 1709 1710

    if (!no_save)
      *p++ = c;
  }
  *p=0;						/* Always end with \0 */
1711
  return feof(*cur_file);
1712 1713
}

1714 1715
static char read_query_buf[MAX_QUERY];

1716
int read_query(struct st_query** q_ptr)
1717
{
1718
  char *p = read_query_buf, * p1 ;
1719
  int expected_errno;
1720
  struct st_query* q;
1721

1722 1723
  if (parser.current_line < parser.read_lines)
  {
1724
    get_dynamic(&q_lines, (gptr) q_ptr, parser.current_line) ;
1725 1726
    return 0;
  }
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
1727 1728 1729
  if (!(*q_ptr=q=(struct st_query*) my_malloc(sizeof(*q), MYF(MY_WME))) ||
      insert_dynamic(&q_lines, (gptr) &q))
    die(NullS);
1730

1731
  q->record_file[0] = 0;
1732
  q->require_file=0;
1733
  q->first_word_len = 0;
1734 1735
  memcpy((gptr) q->expected_errno, (gptr) global_expected_errno,
	 sizeof(global_expected_errno));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1736
  q->expected_errors=global_expected_errors;
1737 1738
  q->abort_on_error = global_expected_errno[0] == 0;
  bzero((gptr) global_expected_errno,sizeof(global_expected_errno));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1739 1740
  global_expected_errors=0;

1741
  q->type = Q_UNKNOWN;
1742
  q->query_buf=q->query=0;
1743
  if (read_line(read_query_buf, sizeof(read_query_buf)))
1744
    return 1;
1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757

  if (*p == '#')
  {
    q->type = Q_COMMENT;
  }
  else if (p[0] == '-' && p[1] == '-')
  {
    q->type = Q_COMMENT_WITH_COMMAND;
    p+=2;					/* To calculate first word */
  }
  else
  {
    if (*p == '!')
1758
    {
1759 1760 1761 1762 1763 1764
      q->abort_on_error = 0;
      p++;
      if (*p == '$')
      {
	expected_errno = 0;
	p++;
1765
	for (;my_isdigit(system_charset_info,*p);p++)
1766
	  expected_errno = expected_errno * 10 + *p - '0';
1767 1768
	q->expected_errno[0] = expected_errno;
	q->expected_errno[1] = 0;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1769
	q->expected_errors=1;
1770
      }
1771 1772
    }

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1773 1774
    while (*p && my_isspace(system_charset_info,*p))
      p++ ;
1775
    if (*p == '@')
1776 1777 1778
    {
      p++;
      p1 = q->record_file;
1779
      while (!my_isspace(system_charset_info,*p) &&
1780
	     p1 < q->record_file + sizeof(q->record_file) - 1)
1781
	*p1++ = *p++;
1782
      *p1 = 0;
1783
    }
1784
  }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1785 1786
  while (*p && my_isspace(system_charset_info,*p))
    p++;
1787
  if (!(q->query_buf=q->query=my_strdup(p,MYF(MY_WME))))
1788 1789 1790
    die(NullS);

  /* Calculate first word and first argument */
1791
  for (p=q->query; *p && !my_isspace(system_charset_info,*p) ; p++) ;
1792
  q->first_word_len = (uint) (p - q->query);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1793 1794
  while (*p && my_isspace(system_charset_info,*p))
    p++;
1795
  q->first_argument=p;
1796
  q->end = strend(q->query);
1797
  parser.read_lines++;
1798 1799 1800
  return 0;
}

1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849

static struct my_option my_long_options[] =
{
  {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'",
   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},
  {"basedir", 'b', "Basedir for tests", (gptr*) &opt_basedir,
   (gptr*) &opt_basedir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"big-test", 'B', "Define BIG_TEST to 1", (gptr*) &opt_big_test,
   (gptr*) &opt_big_test, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"compress", 'C', "Use the compressed server/client protocol",
   (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},
  {"manager-user", OPT_MANAGER_USER, "Undocumented: Used for debugging",
   (gptr*) &manager_user, (gptr*) &manager_user, 0, GET_STR, REQUIRED_ARG, 0,
   0, 0, 0, 0, 0},
  {"manager-host", OPT_MANAGER_HOST, "Undocumented: Used for debugging",
   (gptr*) &manager_host, (gptr*) &manager_host, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
  {"manager-password", OPT_MANAGER_PASSWD, "Undocumented: Used for debugging",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"manager-port", OPT_MANAGER_PORT, "Undocumented: Used for debugging",
   (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,
   "Undocumented: Used for debugging", (gptr*) &manager_wait_timeout,
   (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},
  {"server-arg", 'A', "Send enbedded server this as a paramenter",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"server-file", 'F', "Read embedded server arguments from file",
   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},
1850 1851 1852
  {"skip-safemalloc", OPT_SKIP_SAFEMALLOC,
   "Don't use the memory allocation checking", 0, 0, 0, GET_NO_ARG, NO_ARG,
   0, 0, 0, 0, 0, 0},
1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869
  {"sleep", 'T', "Sleep always this many seconds on sleep commands",
   (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},
  {"test-file", 'x', "Read test from/in this file (default stdin).",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"tmpdir", 't', "Temporary directory where sockets are put",
   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}
1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881
};


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();
1882
  printf("MySQL AB, by Sasha, Matt, Monty & Jani\n");
1883 1884 1885
  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);
1886
  my_print_help(my_long_options);
jani@hynda.(none)'s avatar
jani@hynda.(none) committed
1887
  printf("  --no-defaults       Don't read default options from any options file.\n");
1888
  my_print_variables(my_long_options);
1889 1890
}

1891 1892 1893 1894 1895

static my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
{
1896
  switch(optid) {
1897
  case '#':
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1898
#ifndef DBUG_OFF
1899
    DBUG_PUSH(argument ? argument : "d:t:S:i:O,/tmp/mysqltest.trace");
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1900
#endif
1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
    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);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1919
      if (!(*++cur_file = my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953
	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;
  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;
1954 1955 1956 1957 1958
  case OPT_SKIP_SAFEMALLOC:
#ifdef SAFEMALLOC
    sf_malloc_quick=1;
#endif
    break;
1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
  case 'V':
    print_version();
    exit(0);
  case '?':
    usage();
    exit(1);
  }
  return 0;
}


1970 1971
int parse_args(int argc, char **argv)
{
1972
  int ho_error;
1973 1974

  load_defaults("my",load_default_groups,&argc,&argv);
1975
  default_argv= argv;
1976

1977
  if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1978
    exit(1);
1979 1980 1981 1982 1983 1984 1985

  if (argc > 1)
  {
    usage();
    exit(1);
  }
  if (argc == 1)
1986
    db= *argv;
1987 1988 1989 1990 1991 1992
  if (tty_password)
    pass=get_tty_password(NullS);

  return 0;
}

1993
char* safe_str_append(char* buf, const char* str, int size)
1994 1995
{
  int i,c ;
1996
  for (i = 0; (c = *str++) &&  i < size - 1; i++)
1997 1998 1999 2000 2001
    *buf++ = c;
  *buf = 0;
  return buf;
}

2002 2003 2004
void str_to_file(const char* fname, char* str, int size)
{
  int fd;
2005 2006 2007 2008 2009 2010 2011
  char buff[FN_REFLEN];
  if (!test_if_hard_path(fname))
  {
    strxmov(buff, opt_basedir, fname, NullS);
    fname=buff;
  }
  fn_format(buff,fname,"","",4);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2012

2013
  if ((fd = my_open(buff, O_WRONLY | O_CREAT | O_TRUNC,
2014
		    MYF(MY_WME | MY_FFNF))) < 0)
2015
    die("Could not open %s: errno = %d", buff, errno);
2016
  if (my_write(fd, (byte*)str, size, MYF(MY_WME|MY_FNABP)))
2017 2018 2019 2020 2021
    die("write failed");
  my_close(fd, MYF(0));
}

void reject_dump(const char* record_file, char* buf, int size)
2022
{
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
2023
  char reject_file[FN_REFLEN];
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
2024
  str_to_file(fn_format(reject_file, record_file,"",".reject",2), buf, size);
2025 2026
}

2027 2028 2029

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

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2030 2031
static void replace_dynstr_append_mem(DYNAMIC_STRING *ds, const char *val,
				      int len)
2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042
{
  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);
}

2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072
/*
  Append all results to the dynamic string separated with '\t'
*/

static void append_result(DYNAMIC_STRING *ds, MYSQL_RES *res)
{
  MYSQL_ROW row;
  int num_fields= mysql_num_fields(res);
  unsigned long *lengths;
  while ((row = mysql_fetch_row(res)))
  {
    int i;
    lengths = mysql_fetch_lengths(res);
    for (i = 0; i < num_fields; i++)
    {
      const char *val= row[i];
      ulonglong len= lengths[i];
      if (!val)
      {
	val = "NULL";
	len = 4;
      }
      if (i)
	dynstr_append_mem(ds, "\t", 1);
      replace_dynstr_append_mem(ds, val, len);
    }
    dynstr_append_mem(ds, "\n", 1);
  }
}

2073

2074
/*
2075
* flags control the phased/stages of query execution to be performed
2076 2077 2078
* 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
*/
2079

2080
int run_query(MYSQL* mysql, struct st_query* q, int flags)
2081 2082
{
  MYSQL_RES* res = 0;
2083
  int i, error = 0;
2084 2085
  DYNAMIC_STRING *ds;
  DYNAMIC_STRING ds_tmp;
2086 2087 2088
  DYNAMIC_STRING eval_query;
  char* query;
  int query_len;
2089
  DBUG_ENTER("run_query");
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2090
  
2091 2092 2093 2094 2095
  if (q->type != Q_EVAL)
  {
    query = q->query;
    query_len = strlen(query);
  }
2096
  else
2097 2098 2099 2100 2101 2102
  {
    init_dynamic_string(&eval_query, "", 16384, 65536);
    do_eval(&eval_query, q->query);
    query = eval_query.str;
    query_len = eval_query.length;
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2103
  DBUG_PRINT("enter", ("query: '%-.60s'", query));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2104

2105
  if (q->record_file[0])
2106
  {
2107
    init_dynamic_string(&ds_tmp, "", 16384, 65536);
2108 2109
    ds = &ds_tmp;
  }
2110 2111
  else
    ds= &ds_res;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2112

2113
  if ((flags & QUERY_SEND) && mysql_send_query(mysql, query, query_len))
2114 2115 2116
    die("At line %u: unable to send query '%s'(mysql_errno=%d,errno=%d)",
	start_lineno, query,
	mysql_errno(mysql), errno);
2117 2118
  if ((flags & QUERY_SEND) && !disable_query_log)
  {
2119
    replace_dynstr_append_mem(ds,query, query_len);
2120 2121
    dynstr_append_mem(ds,";\n",2);
  }
2122 2123
  if (!(flags & QUERY_REAP))
    DBUG_RETURN(0);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2124

serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
2125
  if (mysql_read_query_result(mysql) ||
2126 2127
      (!(last_result = res = mysql_store_result(mysql)) &&
       mysql_field_count(mysql)))
2128 2129
  {
    if (q->require_file)
2130
    {
2131
      abort_not_supported_test();
2132
    }
2133
    if (q->abort_on_error)
2134
      die("At line %u: query '%s' failed: %d: %s", start_lineno, query,
2135
	  mysql_errno(mysql), mysql_error(mysql));
2136
    else
2137
    {
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2138
      for (i=0 ; (uint) i < q->expected_errors ; i++)
2139 2140
      {
	if ((q->expected_errno[i] == mysql_errno(mysql)))
2141
	{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2142
	  if (i == 0 && q->expected_errors == 1)
2143 2144
	  {
	    /* Only log error if there is one possible error */
2145 2146
	    replace_dynstr_append_mem(ds,mysql_error(mysql),
				      strlen(mysql_error(mysql)));
2147 2148
	    dynstr_append_mem(ds,"\n",1);
	  }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2149 2150
	  /* Don't log error if we may not get an error */
	  else if (q->expected_errno[0] != 0)
2151
	    dynstr_append(ds,"Got one of the listed errors\n");
2152
	  goto end;				/* Ok */
2153
	}
2154 2155
      }
      if (i)
2156
      {
2157 2158
	replace_dynstr_append_mem(ds, mysql_error(mysql),
				  strlen(mysql_error(mysql)));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2159
	dynstr_append_mem(ds,"\n",1);
2160 2161 2162
	verbose_msg("query '%s' failed with wrong errno %d instead of %d...",
		    q->query, mysql_errno(mysql), q->expected_errno[0]);
	error=1;
2163 2164
	goto end;
      }
2165 2166
      replace_dynstr_append_mem(ds,mysql_error(mysql),
				strlen(mysql_error(mysql)));
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2167
      dynstr_append_mem(ds,"\n",1);
2168
      verbose_msg("query '%s' failed: %d: %s", q->query, mysql_errno(mysql),
2169
		  mysql_error(mysql));
2170
      /*
2171 2172
	if we do not abort on error, failure to run the query does
	not fail the whole test case
2173
      */
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2174 2175
      goto end;
    }
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
2176 2177
    /*{
      verbose_msg("failed in mysql_store_result for query '%s' (%d)", query,
2178
      mysql_errno(mysql));
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
2179 2180
      error = 1;
      goto end;
2181
      }*/
2182 2183
  }

2184
  if (q->expected_errno[0])
2185 2186
  {
    error = 1;
2187 2188
    verbose_msg("query '%s' succeeded - should have failed with errno %d...",
		q->query, q->expected_errno[0]);
2189 2190
    goto end;
  }
2191

2192
  if (!disable_result_log)
2193
  {
2194
    if (res)
2195
    {
2196 2197 2198 2199 2200 2201 2202 2203 2204 2205
      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);
      append_result(ds, res);
2206
    }
2207

2208 2209
    /* Add all warnings to the result */
    if (!disable_warnings && mysql_warning_count(mysql))
2210
    {
2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
      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);
      }
2226
    }
2227
    if (!disable_info && mysql_info(mysql))
2228
    {
2229 2230 2231
      dynstr_append(ds, "info: ");
      dynstr_append(ds, mysql_info(mysql));
      dynstr_append_mem(ds, "\n", 1);
2232 2233
    }
  }
2234

2235 2236 2237
  if (glob_replace)
    free_replace();

2238 2239 2240
  if (record)
  {
    if (!q->record_file[0] && !result_file)
2241
      die("At line %u: Missing result file", start_lineno);
2242
    if (!result_file)
2243
      str_to_file(q->record_file, ds->str, ds->length);
2244 2245 2246 2247 2248
  }
  else if (q->record_file[0])
  {
    error = check_result(ds, q->record_file, q->require_file);
  }
2249

2250
end:
2251 2252
  if (res)
    mysql_free_result(res);
2253
  last_result=0;
2254 2255
  if (ds == &ds_tmp)
    dynstr_free(&ds_tmp);
2256
  if (q->type == Q_EVAL)
2257
    dynstr_free(&eval_query);
2258
  DBUG_RETURN(error);
2259 2260 2261
}


2262
void get_query_type(struct st_query* q)
2263
{
2264 2265
  char save;
  uint type;
2266
  if (*q->query == '}')
2267 2268 2269 2270 2271 2272 2273
  {
    q->type = Q_END_BLOCK;
    return;
  }
  if (q->type != Q_COMMENT_WITH_COMMAND)
    q->type = Q_QUERY;

2274 2275
  save=q->query[q->first_word_len];
  q->query[q->first_word_len]=0;
2276
  type=find_type(q->query, &command_typelib, 1+2);
2277
  q->query[q->first_word_len]=save;
2278
  if (type > 0)
2279
    q->type=(enum enum_commands) type;		/* Found command */
2280
}
2281

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2282
static byte* get_var_key(const byte* var, uint* len,
2283
			 my_bool __attribute__((unused)) t)
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2284 2285 2286 2287 2288 2289 2290
{
  register char* key;
  key = ((VAR*)var)->name;
  *len = ((VAR*)var)->name_len;
  return (byte*)key;
}

2291
static VAR* var_init(VAR* v, const char* name, int name_len, const char* val,
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2292 2293 2294 2295
		     int val_len)
{
  int val_alloc_len;
  VAR* tmp_var;
2296
  if (!name_len && name)
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2297
    name_len = strlen(name);
2298
  if (!val_len && val)
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2299 2300
    val_len = strlen(val) ;
  val_alloc_len = val_len + 16; /* room to grow */
2301
  if (!(tmp_var=v) && !(tmp_var = (VAR*)my_malloc(sizeof(*tmp_var)
2302
						 + name_len, MYF(MY_WME))))
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2303
    die("Out of memory");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2304

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

2308
  if (!(tmp_var->str_val = my_malloc(val_alloc_len+1, MYF(MY_WME))))
2309
    die("Out of memory");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2310

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2311
  memcpy(tmp_var->name, name, name_len);
2312 2313 2314 2315 2316
  if (val)
  {
    memcpy(tmp_var->str_val, val, val_len);
    tmp_var->str_val[val_len]=0;
  }
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2317 2318 2319
  tmp_var->name_len = name_len;
  tmp_var->str_val_len = val_len;
  tmp_var->alloced_len = val_alloc_len;
2320
  tmp_var->int_val = (val) ? atoi(val) : 0;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2321 2322 2323 2324 2325 2326
  tmp_var->int_dirty = 0;
  return tmp_var;
}

static void var_free(void* v)
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2327
  my_free(((VAR*) v)->str_val, MYF(MY_WME));
2328 2329
  if (((VAR*)v)->alloced)
   my_free((char*) v, MYF(MY_WME));
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2330 2331 2332 2333 2334 2335 2336
}


static void var_from_env(const char* name, const char* def_val)
{
  const char* tmp;
  VAR* v;
2337
  if (!(tmp = getenv(name)))
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2338
    tmp = def_val;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2339

2340
  v = var_init(0, name, 0, tmp, 0);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2341
  hash_insert(&var_hash, (byte*)v);
2342
}
2343

2344

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2345 2346
static void init_var_hash()
{
2347
  VAR* v;
2348
  DBUG_ENTER("init_var_hash");
2349 2350
  if (hash_init(&var_hash, system_charset_info, 
                1024, 0, 0, get_var_key, var_free, MYF(0)))
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2351 2352 2353
    die("Variable hash initialization failed");
  var_from_env("MASTER_MYPORT", "9306");
  var_from_env("SLAVE_MYPORT", "9307");
2354
  var_from_env("MYSQL_TEST_DIR", "/tmp");
2355
  var_from_env("BIG_TEST", opt_big_test ? "1" : "0");
2356 2357
  v=var_init(0,"MAX_TABLES", 0, (sizeof(ulong) == 4) ? "31" : "63",0);
  hash_insert(&var_hash, (byte*)v);
2358
  DBUG_VOID_RETURN;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2359
}
2360

2361

2362 2363 2364
int main(int argc, char** argv)
{
  int error = 0;
2365
  struct st_query* q;
2366
  my_bool require_file=0, q_send_flag=0;
2367
  char save_file[FN_REFLEN];
2368
  MY_INIT(argv[0]);
2369 2370 2371
  {
  DBUG_ENTER("main");
  DBUG_PROCESS(argv[0]);
2372

2373
  save_file[0]=0;
2374
  TMPDIR[0]=0;
2375 2376 2377 2378
  memset(cons, 0, sizeof(cons));
  cons_end = cons + MAX_CONS;
  next_con = cons + 1;
  cur_con = cons;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2379

2380
  memset(file_stack, 0, sizeof(file_stack));
2381
  memset(&master_pos, 0, sizeof(master_pos));
2382 2383
  file_stack_end = file_stack + MAX_INCLUDE_DEPTH;
  cur_file = file_stack;
2384
  lineno   = lineno_stack;
2385
  my_init_dynamic_array(&q_lines, sizeof(struct st_query*), INIT_Q_LINES,
2386 2387 2388
		     INIT_Q_LINES);
  memset(block_stack, 0, sizeof(block_stack));
  block_stack_end = block_stack + BLOCK_STACK_DEPTH;
2389 2390
  memset(block_ok_stack, 0, sizeof(block_stack));
  block_ok_stack_end = block_ok_stack + BLOCK_STACK_DEPTH;
2391
  cur_block = block_stack;
2392 2393
  block_ok = block_ok_stack;
  *block_ok = 1;
2394
  init_dynamic_string(&ds_res, "", 0, 65536);
2395
  parse_args(argc, argv);
2396 2397 2398
  if (mysql_server_init(embedded_server_arg_count,
			embedded_server_args,
			(char**) embedded_server_groups))
2399
    die("Can't initialize MySQL server");
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2400
  init_var_hash();
2401 2402
  if (cur_file == file_stack)
    *++cur_file = stdin;
2403
  *lineno=1;
2404 2405 2406
#ifndef EMBEDDED_LIBRARY
  if (manager_host)
    init_manager();
2407
#endif
2408
  if (!( mysql_init(&cur_con->mysql)))
2409
    die("Failed in mysql_init()");
2410 2411
  if (opt_compress)
    mysql_options(&cur_con->mysql,MYSQL_OPT_COMPRESS,NullS);
2412 2413
  mysql_options(&cur_con->mysql, MYSQL_OPT_LOCAL_INFILE, 0);

2414
  cur_con->name = my_strdup("default", MYF(MY_WME));
2415
  if (!cur_con->name)
2416
    die("Out of memory");
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2417

2418 2419
  if (safe_connect(&cur_con->mysql, host,
			 user, pass, db, port, unix_sock))
2420 2421
    die("Failed in mysql_real_connect(): %s", mysql_error(&cur_con->mysql));

2422
  while (!read_query(&q))
2423 2424 2425 2426
  {
    int current_line_inc = 1, processed = 0;
    if (q->type == Q_UNKNOWN || q->type == Q_COMMENT_WITH_COMMAND)
      get_query_type(q);
2427
    if (*block_ok)
2428
    {
2429 2430 2431
      processed = 1;
      switch (q->type) {
      case Q_CONNECT: do_connect(q); break;
2432
      case Q_CONNECTION: select_connection(q->first_argument); break;
2433
      case Q_DISCONNECT:
2434
      case Q_DIRTY_CLOSE:
2435
	close_connection(q); break;
2436
      case Q_RPL_PROBE: do_rpl_probe(q); break;
2437
      case Q_ENABLE_RPL_PARSE:	 do_enable_rpl_parse(q); break;
2438
      case Q_DISABLE_RPL_PARSE:  do_disable_rpl_parse(q); break;
2439
      case Q_ENABLE_QUERY_LOG:	 disable_query_log=0; break;
2440 2441 2442
      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;
2443 2444 2445 2446
      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;
2447
      case Q_SOURCE: do_source(q); break;
2448 2449
      case Q_SLEEP: do_sleep(q, 0); break;
      case Q_REAL_SLEEP: do_sleep(q, 1); break;
2450
      case Q_REQUIRE_VERSION: do_require_version(q); break;
2451
      case Q_WAIT_FOR_SLAVE_TO_STOP: do_wait_for_slave_to_stop(q); break;
2452
      case Q_REQUIRE_MANAGER: do_require_manager(q); break;
2453
#ifndef EMBEDDED_LIBRARY
2454 2455
      case Q_SERVER_START: do_server_start(q); break;
      case Q_SERVER_STOP: do_server_stop(q); break;
2456
#endif
2457 2458 2459 2460 2461
      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;
      case Q_LET: do_let(q); break;
2462
      case Q_EVAL_RESULT: eval_result = 1; break;
2463
      case Q_EVAL:
2464
	if (q->query == q->query_buf)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2465
	  q->query= q->first_argument;
2466
	/* fall through */
2467
      case Q_QUERY:
2468
      case Q_REAP:
2469
      {
2470 2471 2472 2473 2474
	/*
	  We read the result always regardless of the mode for both full
	  query and read-result only (reap)
	*/
	int flags = QUERY_REAP;
2475
	if (q->type != Q_REAP) /* for a full query, enable the send stage */
2476
	  flags |= QUERY_SEND;
2477 2478 2479 2480 2481
	if (q_send_flag)
	{
	  flags= QUERY_SEND;
	  q_send_flag=0;
	}
2482
	if (save_file[0])
2483
	{
2484 2485 2486
	  strmov(q->record_file,save_file);
	  q->require_file=require_file;
	  save_file[0]=0;
2487
	}
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
2488
	error |= run_query(&cur_con->mysql, q, flags);
2489
	break;
2490
      }
2491
      case Q_SEND:
2492 2493 2494 2495 2496 2497 2498 2499
	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)
2500
	  q->query += q->first_word_len;
2501 2502 2503 2504 2505
	/*
	  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.
2506
	 */
2507
	error |= run_query(&cur_con->mysql, q, QUERY_SEND);
2508
	break;
2509 2510 2511 2512
      case Q_RESULT:
	get_file_name(save_file,q);
	require_file=0;
	break;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
2513
      case Q_ERROR:
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2514
	global_expected_errors=get_ints(global_expected_errno,q);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
2515
	break;
2516 2517 2518 2519
      case Q_REQUIRE:
	get_file_name(save_file,q);
	require_file=1;
	break;
2520 2521 2522
      case Q_REPLACE:
	get_replace(q);
	break;
2523 2524
      case Q_SAVE_MASTER_POS: do_save_master_pos(); break;
      case Q_SYNC_WITH_MASTER: do_sync_with_master(q); break;
2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537
      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;
      }
2538
      case Q_COMMENT:				/* Ignore row */
2539
      case Q_COMMENT_WITH_COMMAND:
2540 2541 2542
      case Q_PING:
	(void) mysql_ping(&cur_con->mysql);
	break;
2543 2544 2545
      default: processed = 0; break;
      }
    }
2546

2547 2548 2549
    if (!processed)
    {
      current_line_inc = 0;
2550
      switch (q->type) {
2551 2552 2553 2554
      case Q_WHILE: do_while(q); break;
      case Q_END_BLOCK: do_done(q); break;
      default: current_line_inc = 1; break;
      }
2555 2556
    }

2557 2558 2559
    parser.current_line += current_line_inc;
  }

2560
  if (result_file && ds_res.length)
2561
  {
2562
    if (!record)
2563 2564
      error |= check_result(&ds_res, result_file, q->require_file);
    else
2565
      str_to_file(result_file, ds_res.str, ds_res.length);
2566
  }
2567
  dynstr_free(&ds_res);
2568

2569
  if (!silent) {
2570
    if (error)
2571 2572 2573 2574
      printf("not ok\n");
    else
      printf("ok\n");
  }
2575

2576
  free_used_memory();
2577 2578
  exit(error ? 1 : 0);
  return error ? 1 : 0;				/* Keep compiler happy */
2579
  }
2580
}
2581

2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604
/*
  Read arguments for embedded server and put them into
  embedded_server_args_count and embedded_server_args[]
*/


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

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

  if (!embedded_server_arg_count)
  {
    embedded_server_arg_count=1;
    embedded_server_args[0]= (char*) "";		/* Progname */
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2605
  if (!(file=my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626
    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;
}
2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640

/****************************************************************************
* 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 {
2641
  bool	 found;
2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746
  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 {
2747 2748
  uint	*bits;				/* Pointer to used sets */
  short next[LAST_CHAR_CODE];		/* Pointer to next sets */
2749 2750
  uint	found_len;			/* Best match to date */
  int	found_offset;
2751 2752
  uint	table_offset;
  uint	size_of_bits;			/* For convinience */
2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 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 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 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
} 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 */

3283
uint replace_strings(REPLACE *rep, my_string *start,uint *max_length,
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3284
		     const char *from)
3285 3286 3287
{
  reg1 REPLACE *rep_pos;
  reg2 REPLACE_STRING *rep_str;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3288
  my_string to,end,pos,new_str;
3289 3290 3291

  end=(to= *start) + *max_length-1;
  rep_pos=rep+1;
3292
  for (;;)
3293 3294 3295 3296 3297 3298 3299
  {
    while (!rep_pos->found)
    {
      rep_pos= rep_pos->next[(uchar) *from];
      if (to == end)
      {
	(*max_length)+=8192;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3300
	if (!(new_str=my_realloc(*start,*max_length,MYF(MY_WME))))
3301
	  return (uint) -1;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3302 3303
	to=new_str+(to - *start);
	end=(*start=new_str)+ *max_length-1;
3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314
      }
      *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;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3315
	if (!(new_str=my_realloc(*start,*max_length,MYF(MY_WME))))
3316
	  return (uint) -1;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
3317 3318
	to=new_str+(to - *start);
	end=(*start=new_str)+ *max_length-1;
3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339
      }
      *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));
}