~drizzle-trunk/drizzle/development

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

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

 * 

 *  Copyright (C) 2010 Vijay Samuel

 *  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 "MySQL Test framework manual" for more information

  http://dev.mysql.com/doc/mysqltest/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/get_password.h>

#include <libdrizzle-2.0/libdrizzle.hpp>

#include <queue>

#include <map>

#include <string>

#include <sstream>

#include <fstream>

#include <iostream>

#include <vector>

#include <algorithm>

#ifdef HAVE_SYS_WAIT_H

#include <sys/wait.h>

#endif

#include <cassert>

#include <sys/stat.h>

#include <sys/types.h>

#include <fcntl.h>

#include <boost/array.hpp>

#include <boost/foreach.hpp>

#include <boost/program_options.hpp>

#include <boost/smart_ptr.hpp>

#include PCRE_HEADER

#include <stdarg.h>

#include <boost/unordered_map.hpp>

/* Added this for string translation. */

#include <drizzled/gettext.h>

#include <drizzled/definitions.h>

#include <drizzled/internal/my_sys.h>

#include <drizzled/type/time.h>

#include <drizzled/charset.h>

#include <drizzled/typelib.h>

#include <drizzled/configmake.h>

#include <drizzled/util/find_ptr.h>

#define PTR_BYTE_DIFF(A,B) (ptrdiff_t) (reinterpret_cast<const unsigned char*>(A) - reinterpret_cast<const unsigned char*>(B))

namespace po= boost::program_options;

using namespace std;

using namespace drizzled;

unsigned char *get_var_key(const unsigned char* var, size_t *len, bool);

int get_one_option(int optid, const struct option *, char *argument);

#define MAX_VAR_NAME_LENGTH    256

#define MAX_COLUMNS            256

#define MAX_DELIMITER_LENGTH 16

/* Flags controlling send and reap */

#define QUERY_SEND_FLAG  1

#define QUERY_REAP_FLAG  2

typedef boost::unordered_map<std::string, uint32_t> ErrorCodes;

ErrorCodes global_error_names;

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,

  OPT_TESTDIR

};

static int record= 0, opt_sleep= -1;

static char *opt_pass= NULL;

const char *unix_sock= NULL;

static uint32_t opt_port= 0;

static uint32_t opt_max_connect_retries;

static bool silent= false, verbose= false;

static bool opt_mark_progress= false;

static bool parsing_disabled= false;

static bool display_result_vertically= false,

  display_metadata= false, display_result_sorted= false;

static bool disable_query_log= false, disable_result_log= false;

static bool disable_warnings= false;

static bool disable_info= true;

static bool abort_on_error= true;

static bool server_initialized= false;

static bool is_windows= false;

static bool use_drizzle_protocol= false;

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

static void free_all_replace();

std::string opt_basedir,

  opt_charsets_dir,

  opt_db,

  opt_host,

  opt_include,

  opt_testdir,

  opt_logdir,

  password,

  opt_password,

  result_file_name,

  opt_user,

  opt_protocol;

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

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

static uint32_t opt_tail_lines= 0;

static char delimiter[MAX_DELIMITER_LENGTH]= ";";

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

  uint32_t lineno; /* Current line in file */

};

static boost::array<st_test_file, 16> file_stack;

static st_test_file* cur_file;

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

/*

  Timer related variables

  See the timer_output() definition for details

*/

static char *timer_file = NULL;

static uint64_t timer_start;

static void timer_output();

static uint64_t timer_now();

static uint64_t progress_start= 0;

vector<struct st_command*> q_lines;

struct parser_st

{

  int read_lines;

  int current_line;

} parser;

struct master_pos_st

{

  char file[FN_REFLEN];

  uint32_t pos;

};

master_pos_st master_pos;

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

class VAR

{

public:

  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;

};

/*Perl/shell-like variable registers */

boost::array<VAR, 10> var_reg;

typedef boost::unordered_map<string, VAR *> var_hash_t;

var_hash_t var_hash;

class st_connection

{

public:

  st_connection() : con(drizzle)

  {

    drizzle_con_add_options(*this, use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);

  }

  operator drizzle::connection_c&()

  {

    return con;

  }

  operator drizzle_con_st*()

  {

    return con;

  }

  drizzle::drizzle_c drizzle;

  drizzle::connection_c con;

};

typedef map<string, st_connection*> connections_t;

connections_t g_connections;

st_connection* cur_con= NULL;

/*

  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

  {

    uint32_t errnum;

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

  } code;

};

struct st_expected_errors

{

  struct st_match_err err[10];

  uint32_t count;

};

static st_expected_errors saved_expected_errors;

class st_command

{

public:

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

  int first_word_len, query_len;

  bool abort_on_error;

  st_expected_errors expected_errors;

  string require_file;

  enum_commands type;

  st_command()

    : query(NULL), query_buf(NULL), first_argument(NULL), last_argument(NULL),

      end(NULL), first_word_len(0), query_len(0), abort_on_error(false),

      require_file(""), type(Q_CONNECTION)

  {

    memset(&expected_errors, 0, sizeof(st_expected_errors));

  }

  ~st_command()

  {

    free(query_buf);

  }

};

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

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, uint32_t 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 dump_progress();

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 uint32_t max_replace_column= 0;

void do_get_replace_column(st_command*);

void free_replace_column();

/* For replace */

void do_get_replace(st_command* command);

void free_replace();

/* For replace_regex */

void do_get_replace_regex(st_command* command);

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, uint32_t val);

void append_sorted(string& ds, const string& ds_input);

void handle_error(st_command*,

                  unsigned int err_errno, const char *err_error,

                  const char *err_sqlstate, string *ds);

void handle_no_error(st_command*);

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

             const char *query_end, bool pass_through_escape_chars)

{

  char c, next_c;

  int escaped = 0;

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

  {

    switch(c) 

    {

    case '$':

      if (escaped)

      {

        escaped= 0;

        query_eval->append(p, 1);

      }

      else

      {

        VAR* v= var_get(p, &p, 0, 0);

        if (not v)

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

    }

  }

}

/*

  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.

*/

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

{

  const char *quote_str= "\'";

  const uint32_t  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 int dt_query_log(drizzle::connection_c& con, drizzle::result_c& res, const std::string& query)

{

  if (drizzle_return_t ret= con.query(res, query))

  {

    if (ret == DRIZZLE_RETURN_ERROR_CODE)

    {

      log_msg("Error running query '%s': %d %s", query.c_str(), res.error_code(), res.error());

    }

    else

    {

      log_msg("Error running query '%s': %d %s", query.c_str(), ret, con.error());

    }

    return 1;

  }

  return res.column_count() == 0;

}

static void show_query(drizzle::connection_c& con, const char* query)

{

  drizzle::result_c res;

  if (dt_query_log(con, res, query))

    return;

  unsigned int row_num= 0;

  unsigned int num_fields= res.column_count();

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

  while (drizzle_row_t row= res.row_next())

  {

    size_t *lengths= res.row_field_sizes();

    row_num++;

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

    res.column_seek(0);

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

    {

      drizzle_column_st* column= res.column_next();

      fprintf(stderr, "%s\t%.*s\n", drizzle_column_name(column), (int)lengths[i], row[i] ? row[i] : "NULL");

    }

  }

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

    fprintf(stderr, "=");

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

}

/*

  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::connection_c& con)

{

  drizzle::result_c res;

  if (dt_query_log(con, res, "show warnings"))

    return;

  if (res.row_count() >= 2) /* Don't display the last row, it's "last error" */

  {

    unsigned int row_num= 0;

    unsigned int num_fields= res.column_count();

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

    while (drizzle_row_t row= res.row_next())

    {

      size_t *lengths= res.row_field_sizes();

      if (++row_num >= res.row_count())

      {

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

        break;

      }

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

      {

        fprintf(stderr, "%.*s ", (int)lengths[i], row[i] ? row[i] : "NULL");

      }

      fprintf(stderr, "\n");

    }