~drizzle-trunk/drizzle/development

/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2008 MySQL

 *

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

 *

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

 *

 *  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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

/*

  drizzletest

  Tool used for executing a .test file

  See the "DRIZZLE Test framework manual" for more information

  http://dev.mysql.com/doc/drizzletest/en/index.html

  Please keep the test framework tools identical in all versions!

  Written by:

  Sasha Pachev <sasha@mysql.com>

  Matt Wagner  <matt@mysql.com>

  Monty

  Jani

  Holyfoot

*/

#define MTEST_VERSION "3.3"

#include <config.h>

#include "client_priv.h"

#include <queue>

#include <map>

#include <string>

#include <vector>

#include <pcrecpp.h>

#include <mysys/hash.h>

#include <stdarg.h>

#include "errname.h"

using namespace std;

#define MAX_VAR_NAME_LENGTH    256

#define MAX_COLUMNS            256

#define MAX_EMBEDDED_SERVER_ARGS 64

#define MAX_DELIMITER_LENGTH 16

/* Flags controlling send and reap */

#define QUERY_SEND_FLAG  1

#define QUERY_REAP_FLAG  2

enum {

  OPT_PS_PROTOCOL, OPT_SP_PROTOCOL, OPT_CURSOR_PROTOCOL, OPT_VIEW_PROTOCOL,

  OPT_MAX_CONNECT_RETRIES, OPT_MARK_PROGRESS, OPT_LOG_DIR, OPT_TAIL_LINES

};

static int record= 0, opt_sleep= -1;

static char *opt_db= 0, *opt_pass= 0;

const char *opt_user= 0, *opt_host= 0, *unix_sock= 0, *opt_basedir= "./";

const char *opt_logdir= "";

const char *opt_include= 0, *opt_charsets_dir;

static int opt_port= 0;

static int opt_max_connect_retries;

static bool opt_compress= 0, silent= 0, verbose= 0;

static bool debug_info_flag= 0, debug_check_flag= 0;

static bool tty_password= 0;

static bool opt_mark_progress= 0;

static bool parsing_disabled= 0;

static bool display_result_vertically= false,

  display_metadata= false, display_result_sorted= false;

static bool disable_query_log= 0, disable_result_log= 0;

static bool disable_warnings= 0;

static bool disable_info= 1;

static bool abort_on_error= 1;

static bool server_initialized= 0;

static bool is_windows= 0;

static char **default_argv;

static const char *load_default_groups[]= { "drizzletest", "client", 0 };

static char line_buffer[MAX_DELIMITER_LENGTH], *line_buffer_pos= line_buffer;

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

static uint my_end_arg= 0;

/* Number of lines of the result to include in failure report */

static uint opt_tail_lines= 0;

static char delimiter[MAX_DELIMITER_LENGTH]= ";";

static uint delimiter_length= 1;

static char TMPDIR[FN_REFLEN];

/* Block stack */

enum block_cmd {

  cmd_none,

  cmd_if,

  cmd_while

};

struct st_block

{

  int             line; /* Start line of block */

  bool         ok;   /* Should block be executed */

  enum block_cmd  cmd;  /* Command owning the block */

};

static struct st_block block_stack[32];

static struct st_block *cur_block, *block_stack_end;

/* Open file stack */

struct st_test_file

{

  FILE* file;

  const char *file_name;

  uint lineno; /* Current line in file */

};

static struct st_test_file file_stack[16];

static struct st_test_file* cur_file;

static struct st_test_file* file_stack_end;

static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci; /* Default charset */

static int embedded_server_arg_count=0;

static char *embedded_server_args[MAX_EMBEDDED_SERVER_ARGS];

/*

  Timer related variables

  See the timer_output() definition for details

*/

static char *timer_file = NULL;

static uint64_t timer_start;

static void timer_output(void);

static uint64_t timer_now(void);

static uint64_t progress_start= 0;

vector<struct st_command*> q_lines;

typedef struct {

  int read_lines,current_line;

} parser_st;

parser_st parser;

typedef struct

{

  char file[FN_REFLEN];

  uint32_t pos;

} master_pos_st;

master_pos_st master_pos;

/* if set, all results are concated and compared against this file */

const char *result_file_name= 0;

typedef struct st_var

{

  char *name;

  int name_len;

  char *str_val;

  int str_val_len;

  int int_val;

  int alloced_len;

  int int_dirty; /* do not update string if int is updated until first read */

  int alloced;

  char *env_s;

} VAR;

/*Perl/shell-like variable registers */

VAR var_reg[10];

HASH var_hash;

struct st_connection

{

  DRIZZLE drizzle;

  /* Used when creating views and sp, to avoid implicit commit */

  DRIZZLE *util_drizzle;

  char *name;

};

struct st_connection connections[128];

struct st_connection* cur_con= NULL, *next_con, *connections_end;

/*

  List of commands in drizzletest

  Must match the "command_names" array

  Add new commands before Q_UNKNOWN!

*/

enum enum_commands {

  Q_CONNECTION=1,     Q_QUERY,

  Q_CONNECT,      Q_SLEEP, Q_REAL_SLEEP,

  Q_INC,        Q_DEC,

  Q_SOURCE,      Q_DISCONNECT,

  Q_LET,        Q_ECHO,

  Q_WHILE,      Q_END_BLOCK,

  Q_SYSTEM,      Q_RESULT,

  Q_REQUIRE,      Q_SAVE_MASTER_POS,

  Q_SYNC_WITH_MASTER,

  Q_SYNC_SLAVE_WITH_MASTER,

  Q_ERROR,

  Q_SEND,        Q_REAP,

  Q_DIRTY_CLOSE,      Q_REPLACE, Q_REPLACE_COLUMN,

  Q_PING,        Q_EVAL,

  Q_EVAL_RESULT,

  Q_ENABLE_QUERY_LOG, Q_DISABLE_QUERY_LOG,

  Q_ENABLE_RESULT_LOG, Q_DISABLE_RESULT_LOG,

  Q_WAIT_FOR_SLAVE_TO_STOP,

  Q_ENABLE_WARNINGS, Q_DISABLE_WARNINGS,

  Q_ENABLE_INFO, Q_DISABLE_INFO,

  Q_ENABLE_METADATA, Q_DISABLE_METADATA,

  Q_EXEC, Q_DELIMITER,

  Q_DISABLE_ABORT_ON_ERROR, Q_ENABLE_ABORT_ON_ERROR,

  Q_DISPLAY_VERTICAL_RESULTS, Q_DISPLAY_HORIZONTAL_RESULTS,

  Q_QUERY_VERTICAL, Q_QUERY_HORIZONTAL, Q_SORTED_RESULT,

  Q_START_TIMER, Q_END_TIMER,

  Q_CHARACTER_SET,

  Q_DISABLE_RECONNECT, Q_ENABLE_RECONNECT,

  Q_IF,

  Q_DISABLE_PARSING, Q_ENABLE_PARSING,

  Q_REPLACE_REGEX, Q_REMOVE_FILE, Q_FILE_EXIST,

  Q_WRITE_FILE, Q_COPY_FILE, Q_PERL, Q_DIE, Q_EXIT, Q_SKIP,

  Q_CHMOD_FILE, Q_APPEND_FILE, Q_CAT_FILE, Q_DIFF_FILES,

  Q_SEND_QUIT, Q_CHANGE_USER, Q_MKDIR, Q_RMDIR,

  Q_UNKNOWN,             /* Unknown command.   */

  Q_COMMENT,             /* Comments, ignored. */

  Q_COMMENT_WITH_COMMAND

};

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

  "sync_slave_with_master",

  "error",

  "send",

  "reap",

  "dirty_close",

  "replace_result",

  "replace_column",

  "ping",

  "eval",

  "eval_result",

  /* Enable/disable that the _query_ is logged to result file */

  "enable_query_log",

  "disable_query_log",

  /* Enable/disable that the _result_ from a query is logged to result file */

  "enable_result_log",

  "disable_result_log",

  "wait_for_slave_to_stop",

  "enable_warnings",

  "disable_warnings",

  "enable_info",

  "disable_info",

  "enable_metadata",

  "disable_metadata",

  "exec",

  "delimiter",

  "disable_abort_on_error",

  "enable_abort_on_error",

  "vertical_results",

  "horizontal_results",

  "query_vertical",

  "query_horizontal",

  "sorted_result",

  "start_timer",

  "end_timer",

  "character_set",

  "disable_reconnect",

  "enable_reconnect",

  "if",

  "disable_parsing",

  "enable_parsing",

  "replace_regex",

  "remove_file",

  "file_exists",

  "write_file",

  "copy_file",

  "perl",

  "die",

  /* Don't execute any more commands, compare result */

  "exit",

  "skip",

  "chmod",

  "append_file",

  "cat_file",

  "diff_files",

  "send_quit",

  "change_user",

  "mkdir",

  "rmdir",

  0

};

/*

  The list of error codes to --error are stored in an internal array of

  structs. This struct can hold numeric SQL error codes, error names or

  SQLSTATE codes as strings. The element next to the last active element

  in the list is set to type ERR_EMPTY. When an SQL statement returns an

  error, we use this list to check if this is an expected error.

*/

enum match_err_type

{

  ERR_EMPTY= 0,

  ERR_ERRNO,

  ERR_SQLSTATE

};

struct st_match_err

{

  enum match_err_type type;

  union

  {

    uint errnum;

    char sqlstate[SQLSTATE_LENGTH+1];  /* \0 terminated string */

  } code;

};

struct st_expected_errors

{

  struct st_match_err err[10];

  uint count;

};

static struct st_expected_errors saved_expected_errors;

struct st_command

{

  char *query, *query_buf,*first_argument,*last_argument,*end;

  int first_word_len, query_len;

  bool abort_on_error;

  struct st_expected_errors expected_errors;

  char require_file[FN_REFLEN];

  enum enum_commands type;

};

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

                          command_names, 0};

string ds_res, ds_progress, ds_warning_messages;

char builtin_echo[FN_REFLEN];

void die(const char *fmt, ...)

  __attribute__((format(printf, 1, 2)));

void abort_not_supported_test(const char *fmt, ...)

  __attribute__((format(printf, 1, 2)));

void verbose_msg(const char *fmt, ...)

  __attribute__((format(printf, 1, 2)));

void warning_msg(const char *fmt, ...)

  __attribute__((format(printf, 1, 2)));

void log_msg(const char *fmt, ...)

  __attribute__((format(printf, 1, 2)));

VAR* var_from_env(const char *, const char *);

VAR* var_init(VAR* v, const char *name, int name_len, const char *val,

              int val_len);

void var_free(void* v);

VAR* var_get(const char *var_name, const char** var_name_end,

             bool raw, bool ignore_not_existing);

void eval_expr(VAR* v, const char *p, const char** p_end);

bool match_delimiter(int c, const char *delim, uint length);

void dump_result_to_reject_file(char *buf, int size);

void dump_result_to_log_file(const char *buf, int size);

void dump_warning_messages(void);

void dump_progress(void);

void do_eval(string *query_eval, const char *query,

             const char *query_end, bool pass_through_escape_chars);

void str_to_file(const char *fname, const char *str, int size);

void str_to_file2(const char *fname, const char *str, int size, bool append);

/* For replace_column */

static char *replace_column[MAX_COLUMNS];

static uint max_replace_column= 0;

void do_get_replace_column(struct st_command*);

void free_replace_column(void);

/* For replace */

void do_get_replace(struct st_command *command);

void free_replace(void);

/* For replace_regex */

void do_get_replace_regex(struct st_command *command);

void free_replace_regex(void);

void free_all_replace(void);

void free_all_replace(void){

  free_replace();

  free_replace_regex();

  free_replace_column();

}

void replace_append_mem(string *ds, const char *val,

                        int len);

void replace_append(string *ds, const char *val);

void replace_append_uint(string *ds, uint val);

void append_sorted(string* ds, string* ds_input);

void handle_error(struct st_command*,

                  unsigned int err_errno, const char *err_error,

                  const char *err_sqlstate, string *ds);

void handle_no_error(struct st_command*);

#define do_send_query(cn,q,q_len,flags) drizzle_send_query(&cn->drizzle, q, q_len)

void do_eval(string *query_eval, const char *query,

             const char *query_end, bool pass_through_escape_chars)

{

  const char *p;

  register char c, next_c;

  register int escaped = 0;

  VAR *v;

  for (p= query; (c= *p) && p < query_end; ++p)

  {

    switch(c) {

    case '$':

      if (escaped)

      {

        escaped= 0;

        query_eval->append(p, 1);

      }

      else

      {

        if (!(v= var_get(p, &p, 0, 0)))

          die("Bad variable in eval");

        query_eval->append(v->str_val, v->str_val_len);

      }

      break;

    case '\\':

      next_c= *(p+1);

      if (escaped)

      {

        escaped= 0;

        query_eval->append(p, 1);

      }

      else if (next_c == '\\' || next_c == '$' || next_c == '"')

      {

        /* Set escaped only if next char is \, " or $ */

        escaped= 1;

        if (pass_through_escape_chars)

        {

          /* The escape char should be added to the output string. */

          query_eval->append(p, 1);

        }

      }

      else

        query_eval->append(p, 1);

      break;

    default:

      escaped= 0;

      query_eval->append(p, 1);

      break;

    }

  }

  return;

}

/*

  Concatenates any number of strings, escapes any OS quote in the result then

  surround the whole affair in another set of quotes which is finally appended

  to specified string.  This function is especially useful when

  building strings to be executed with the system() function.

  @param str string which will have addtional strings appended.

  @param append string to be appended.

  @param ... Optional. Additional string(s) to be appended.

  @note The final argument in the list must be NULL even if no additional

  options are passed.

*/

void append_os_quoted(string *str, const char *append, ...)

{

  const char *quote_str= "\'";

  const uint  quote_len= 1;

  va_list dirty_text;

  str->append(quote_str, quote_len); /* Leading quote */

  va_start(dirty_text, append);

  while (append != NULL)

  {

    const char  *cur_pos= append;

    const char *next_pos= cur_pos;

    /* Search for quote in each string and replace with escaped quote */

    while((next_pos= strrchr(cur_pos, quote_str[0])) != NULL)

    {

      str->append(cur_pos, next_pos - cur_pos);

      str->append("\\", 1);

      str->append(quote_str, quote_len);

      cur_pos= next_pos + 1;

    }

    str->append(cur_pos);

    append= va_arg(dirty_text, char *);

  }

  va_end(dirty_text);

  str->append(quote_str, quote_len); /* Trailing quote */

}

/*

  Run query and dump the result to stdout in vertical format

  NOTE! This function should be safe to call when an error

  has occured and thus any further errors will be ignored(although logged)

  SYNOPSIS

  show_query

  drizzle - connection to use

  query - query to run

*/

static void show_query(DRIZZLE *drizzle, const char* query)

{

  DRIZZLE_RES* res;

  if (!drizzle)

    return;

  if (drizzle_query(drizzle, query))

  {

    log_msg("Error running query '%s': %d %s",

            query, drizzle_errno(drizzle), drizzle_error(drizzle));

    return;

  }

  if ((res= drizzle_store_result(drizzle)) == NULL)

  {

    /* No result set returned */

    return;

  }

  {

    DRIZZLE_ROW row;

    unsigned int i;

    unsigned int row_num= 0;

    unsigned int num_fields= drizzle_num_fields(res);

    const DRIZZLE_FIELD *fields= drizzle_fetch_fields(res);

    fprintf(stderr, "=== %s ===\n", query);

    while ((row= drizzle_fetch_row(res)))

    {

      uint32_t *lengths= drizzle_fetch_lengths(res);

      row_num++;

      fprintf(stderr, "---- %d. ----\n", row_num);

      for(i= 0; i < num_fields; i++)

      {

        fprintf(stderr, "%s\t%.*s\n",

                fields[i].name,

                (int)lengths[i], row[i] ? row[i] : "NULL");

      }

    }

    for (i= 0; i < strlen(query)+8; i++)

      fprintf(stderr, "=");

    fprintf(stderr, "\n\n");

  }

  drizzle_free_result(res);

  return;

}

/*

  Show any warnings just before the error. Since the last error

  is added to the warning stack, only print @@warning_count-1 warnings.

  NOTE! This function should be safe to call when an error

  has occured and this any further errors will be ignored(although logged)

  SYNOPSIS

  show_warnings_before_error

  drizzle - connection to use

*/

static void show_warnings_before_error(DRIZZLE *drizzle)

{

  DRIZZLE_RES* res;

  const char* query= "SHOW WARNINGS";

  if (!drizzle)

    return;

  if (drizzle_query(drizzle, query))

  {

    log_msg("Error running query '%s': %d %s",

            query, drizzle_errno(drizzle), drizzle_error(drizzle));

    return;

  }

  if ((res= drizzle_store_result(drizzle)) == NULL)

  {

    /* No result set returned */

    return;

  }

  if (drizzle_num_rows(res) <= 1)

  {

    /* Don't display the last row, it's "last error" */

  }

  else

  {

    DRIZZLE_ROW row;

    unsigned int row_num= 0;

    unsigned int num_fields= drizzle_num_fields(res);

    fprintf(stderr, "\nWarnings from just before the error:\n");

    while ((row= drizzle_fetch_row(res)))

    {

      uint32_t i;

      uint32_t *lengths= drizzle_fetch_lengths(res);

      if (++row_num >= drizzle_num_rows(res))

      {

        /* Don't display the last row, it's "last error" */

        break;

      }

      for(i= 0; i < num_fields; i++)

      {

        fprintf(stderr, "%.*s ", (int)lengths[i],

                row[i] ? row[i] : "NULL");

      }

      fprintf(stderr, "\n");

    }

  }

  drizzle_free_result(res);

  return;

}

enum arg_type

{

  ARG_STRING,

  ARG_REST

};

struct command_arg {

  const char *argname;       /* Name of argument   */

  enum arg_type type;        /* Type of argument   */

  bool required;          /* Argument required  */

  string *ds;        /* Storage for argument */

  const char *description;   /* Description of the argument */

};

static void check_command_args(struct st_command *command,

                               const char *arguments,

                               const struct command_arg *args,

                               int num_args, const char delimiter_arg)

{

  int i;

  const char *ptr= arguments;

  const char *start;

  for (i= 0; i < num_args; i++)

  {

    const struct command_arg *arg= &args[i];

    switch (arg->type) {

      /* A string */

    case ARG_STRING:

      /* Skip leading spaces */

      while (*ptr && *ptr == ' ')

        ptr++;

      start= ptr;

      /* Find end of arg, terminated by "delimiter_arg" */

      while (*ptr && *ptr != delimiter_arg)

        ptr++;

      if (ptr > start)

      {

        do_eval(arg->ds, start, ptr, false);

      }

      else

      {

        /* Empty string */

        arg->ds->erase();

      }

      command->last_argument= (char*)ptr;

      /* Step past the delimiter */

      if (*ptr && *ptr == delimiter_arg)

        ptr++;

      break;

      /* Rest of line */