← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/mysqltest.c

Merged in changes. 
Edited a the comment test case so deal with our version bump.

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/mysqltest.c
1
 
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 MySQL
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
 
1
/* Copyright (C) 2000 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
20
15
 
21
16
/*
22
 
  drizzletest
 
17
  mysqltest
23
18
 
24
19
  Tool used for executing a .test file
25
20
 
26
 
  See the "DRIZZLE Test framework manual" for more information
27
 
  http://dev.mysql.com/doc/drizzletest/en/index.html
 
21
  See the "MySQL Test framework manual" for more information
 
22
  http://dev.mysql.com/doc/mysqltest/en/index.html
28
23
 
29
24
  Please keep the test framework tools identical in all versions!
30
25
 
39
34
#define MTEST_VERSION "3.3"
40
35
 
41
36
#include "client_priv.h"
42
 
 
43
 
#include <queue>
44
 
#include <map>
45
 
#include <string>
46
 
#include <sstream>
47
 
#include <iostream>
48
 
#include <vector>
49
 
#include <algorithm>
 
37
#include <mysql_version.h>
 
38
#include <mysqld_error.h>
 
39
#include <m_ctype.h>
 
40
#include <my_dir.h>
 
41
#include <hash.h>
 
42
#include <stdarg.h>
 
43
#include <violite.h>
 
44
#include "my_regex.h" /* Our own version of regex */
50
45
#ifdef HAVE_SYS_WAIT_H
51
46
#include <sys/wait.h>
52
47
#endif
53
 
#include <cassert>
54
 
#include <sys/stat.h>
55
 
#include <sys/types.h>
56
 
#include <fcntl.h>
57
 
 
58
 
#include PCRE_HEADER
59
 
 
60
 
#include <stdarg.h>
61
 
 
62
 
#include "errname.h"
63
 
 
64
 
/* Added this for string translation. */
65
 
#include "drizzled/gettext.h"
66
 
#include "drizzled/hash.h"
67
 
#include "drizzled/my_time.h"
68
 
#include "drizzled/charset.h"
69
 
 
70
 
#ifndef DRIZZLE_RETURN_SERVER_GONE
71
 
#define DRIZZLE_RETURN_HANDSHAKE_FAILED DRIZZLE_RETURN_ERROR_CODE
72
 
#endif
73
 
 
74
 
using namespace std;
75
 
 
76
 
extern "C"
77
 
{
78
 
  unsigned char *get_var_key(const unsigned char* var, size_t *len, bool);
79
 
  bool get_one_option(int optid, const struct my_option *, char *argument);
80
 
}
 
48
 
 
49
 
81
50
 
82
51
#define MAX_VAR_NAME_LENGTH    256
83
52
#define MAX_COLUMNS            256
 
53
#define MAX_EMBEDDED_SERVER_ARGS 64
84
54
#define MAX_DELIMITER_LENGTH 16
 
55
 
85
56
/* Flags controlling send and reap */
86
57
#define QUERY_SEND_FLAG  1
87
58
#define QUERY_REAP_FLAG  2
88
59
 
89
 
ErrorCodes global_error_names;
90
 
 
91
60
enum {
 
61
  OPT_SKIP_SAFEMALLOC=OPT_MAX_CLIENT_OPTION,
92
62
  OPT_PS_PROTOCOL, OPT_SP_PROTOCOL, OPT_CURSOR_PROTOCOL, OPT_VIEW_PROTOCOL,
93
 
  OPT_MAX_CONNECT_RETRIES, OPT_MARK_PROGRESS, OPT_LOG_DIR, OPT_TAIL_LINES,
94
 
  OPT_TESTDIR
 
63
  OPT_MAX_CONNECT_RETRIES, OPT_MARK_PROGRESS, OPT_LOG_DIR, OPT_TAIL_LINES
95
64
};
96
65
 
97
66
static int record= 0, opt_sleep= -1;
98
 
static char *opt_db= NULL, *opt_pass= NULL;
99
 
const char *opt_user= NULL, *opt_host= NULL, *unix_sock= NULL,
100
 
           *opt_basedir= "./";
 
67
static char *opt_db= 0, *opt_pass= 0;
 
68
const char *opt_user= 0, *opt_host= 0, *unix_sock= 0, *opt_basedir= "./";
101
69
const char *opt_logdir= "";
102
 
const char *opt_include= NULL, *opt_charsets_dir;
103
 
const char *opt_testdir= NULL;
104
 
static uint32_t opt_port= 0;
 
70
const char *opt_include= 0, *opt_charsets_dir;
 
71
static int opt_port= 0;
105
72
static int opt_max_connect_retries;
106
 
static bool silent= false, verbose= false;
107
 
static bool tty_password= false;
108
 
static bool opt_mark_progress= false;
109
 
static bool parsing_disabled= false;
110
 
static bool display_result_vertically= false,
111
 
  display_metadata= false, display_result_sorted= false;
112
 
static bool disable_query_log= false, disable_result_log= false;
113
 
static bool disable_warnings= false;
114
 
static bool disable_info= true;
115
 
static bool abort_on_error= true;
116
 
static bool server_initialized= false;
117
 
static bool is_windows= false;
 
73
static my_bool opt_compress= 0, silent= 0, verbose= 0;
 
74
static my_bool debug_info_flag= 0, debug_check_flag= 0;
 
75
static my_bool tty_password= 0;
 
76
static my_bool opt_mark_progress= 0;
 
77
static my_bool ps_protocol= 0, ps_protocol_enabled= 0;
 
78
static my_bool sp_protocol= 0, sp_protocol_enabled= 0;
 
79
static my_bool view_protocol= 0, view_protocol_enabled= 0;
 
80
static my_bool cursor_protocol= 0, cursor_protocol_enabled= 0;
 
81
static my_bool parsing_disabled= 0;
 
82
static my_bool display_result_vertically= FALSE,
 
83
  display_metadata= FALSE, display_result_sorted= FALSE;
 
84
static my_bool disable_query_log= 0, disable_result_log= 0;
 
85
static my_bool disable_warnings= 0;
 
86
static my_bool disable_info= 1;
 
87
static my_bool abort_on_error= 1;
 
88
static my_bool server_initialized= 0;
 
89
static my_bool is_windows= 0;
118
90
static char **default_argv;
119
 
static const char *load_default_groups[]= { "drizzletest", "client", 0 };
 
91
static const char *load_default_groups[]= { "mysqltest", "client", 0 };
120
92
static char line_buffer[MAX_DELIMITER_LENGTH], *line_buffer_pos= line_buffer;
121
93
 
122
 
static uint32_t start_lineno= 0; /* Start line of current command */
 
94
static uint start_lineno= 0; /* Start line of current command */
 
95
static uint my_end_arg= 0;
123
96
 
124
97
/* Number of lines of the result to include in failure report */
125
 
static uint32_t opt_tail_lines= 0;
 
98
static uint opt_tail_lines= 0;
126
99
 
127
100
static char delimiter[MAX_DELIMITER_LENGTH]= ";";
128
 
static uint32_t delimiter_length= 1;
 
101
static uint delimiter_length= 1;
129
102
 
130
103
static char TMPDIR[FN_REFLEN];
131
104
 
139
112
struct st_block
140
113
{
141
114
  int             line; /* Start line of block */
142
 
  bool         ok;   /* Should block be executed */
 
115
  my_bool         ok;   /* Should block be executed */
143
116
  enum block_cmd  cmd;  /* Command owning the block */
144
117
};
145
118
 
151
124
{
152
125
  FILE* file;
153
126
  const char *file_name;
154
 
  uint32_t lineno; /* Current line in file */
 
127
  uint lineno; /* Current line in file */
155
128
};
156
129
 
157
130
static struct st_test_file file_stack[16];
159
132
static struct st_test_file* file_stack_end;
160
133
 
161
134
 
162
 
static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci; /* Default charset */
 
135
static CHARSET_INFO *charset_info= &my_charset_latin1; /* Default charset */
 
136
 
 
137
static const char *embedded_server_groups[]=
 
138
{
 
139
  "server",
 
140
  "embedded",
 
141
  "mysqltest_SERVER",
 
142
  NullS
 
143
};
 
144
 
 
145
static int embedded_server_arg_count=0;
 
146
static char *embedded_server_args[MAX_EMBEDDED_SERVER_ARGS];
163
147
 
164
148
/*
165
149
  Timer related variables
166
150
  See the timer_output() definition for details
167
151
*/
168
152
static char *timer_file = NULL;
169
 
static uint64_t timer_start;
 
153
static ulonglong timer_start;
170
154
static void timer_output(void);
171
 
static uint64_t timer_now(void);
172
 
 
173
 
static uint64_t progress_start= 0;
174
 
 
175
 
vector<struct st_command*> q_lines;
176
 
 
177
 
typedef struct {
 
155
static ulonglong timer_now(void);
 
156
 
 
157
static ulonglong progress_start= 0;
 
158
 
 
159
/* Precompiled re's */
 
160
static my_regex_t ps_re;     /* the query can be run using PS protocol */
 
161
static my_regex_t sp_re;     /* the query can be run as a SP */
 
162
static my_regex_t view_re;   /* the query can be run as a view*/
 
163
 
 
164
static void init_re(void);
 
165
static int match_re(my_regex_t *, char *);
 
166
static void free_re(void);
 
167
 
 
168
DYNAMIC_ARRAY q_lines;
 
169
 
 
170
struct
 
171
{
178
172
  int read_lines,current_line;
179
 
} parser_st;
180
 
parser_st parser;
 
173
} parser;
181
174
 
182
 
typedef struct
 
175
struct
183
176
{
184
177
  char file[FN_REFLEN];
185
 
  uint32_t pos;
186
 
} master_pos_st;
187
 
 
188
 
master_pos_st master_pos;
 
178
  ulong pos;
 
179
} master_pos;
189
180
 
190
181
/* if set, all results are concated and compared against this file */
191
 
const char *result_file_name= NULL;
 
182
const char *result_file_name= 0;
192
183
 
193
184
typedef struct st_var
194
185
{
206
197
/*Perl/shell-like variable registers */
207
198
VAR var_reg[10];
208
199
 
209
 
 
210
 
drizzled::hash_map<string, VAR *> var_hash;
 
200
HASH var_hash;
211
201
 
212
202
struct st_connection
213
203
{
214
 
  drizzle_st *drizzle;
215
 
  drizzle_con_st con;
 
204
  MYSQL mysql;
216
205
  /* Used when creating views and sp, to avoid implicit commit */
217
 
  drizzle_con_st *util_con;
 
206
  MYSQL* util_mysql;
218
207
  char *name;
 
208
  MYSQL_STMT* stmt;
 
209
 
 
210
#ifdef EMBEDDED_LIBRARY
 
211
  const char *cur_query;
 
212
  int cur_query_len;
 
213
  pthread_mutex_t mutex;
 
214
  pthread_cond_t cond;
 
215
  int query_done;
 
216
#endif /*EMBEDDED_LIBRARY*/
219
217
};
220
218
struct st_connection connections[128];
221
219
struct st_connection* cur_con= NULL, *next_con, *connections_end;
222
220
 
223
221
/*
224
 
  List of commands in drizzletest
 
222
  List of commands in mysqltest
225
223
  Must match the "command_names" array
226
224
  Add new commands before Q_UNKNOWN!
227
225
*/
228
226
enum enum_commands {
229
227
  Q_CONNECTION=1,     Q_QUERY,
230
 
  Q_CONNECT,      Q_SLEEP, Q_REAL_SLEEP,
231
 
  Q_INC,        Q_DEC,
232
 
  Q_SOURCE,      Q_DISCONNECT,
233
 
  Q_LET,        Q_ECHO,
234
 
  Q_WHILE,      Q_END_BLOCK,
235
 
  Q_SYSTEM,      Q_RESULT,
236
 
  Q_REQUIRE,      Q_SAVE_MASTER_POS,
 
228
  Q_CONNECT,        Q_SLEEP, Q_REAL_SLEEP,
 
229
  Q_INC,                    Q_DEC,
 
230
  Q_SOURCE,         Q_DISCONNECT,
 
231
  Q_LET,                    Q_ECHO,
 
232
  Q_WHILE,          Q_END_BLOCK,
 
233
  Q_SYSTEM,         Q_RESULT,
 
234
  Q_REQUIRE,        Q_SAVE_MASTER_POS,
237
235
  Q_SYNC_WITH_MASTER,
238
236
  Q_SYNC_SLAVE_WITH_MASTER,
239
237
  Q_ERROR,
240
 
  Q_SEND,        Q_REAP,
241
 
  Q_DIRTY_CLOSE,      Q_REPLACE, Q_REPLACE_COLUMN,
242
 
  Q_PING,        Q_EVAL,
 
238
  Q_SEND,                   Q_REAP,
 
239
  Q_DIRTY_CLOSE,            Q_REPLACE, Q_REPLACE_COLUMN,
 
240
  Q_PING,                   Q_EVAL,
243
241
  Q_EVAL_RESULT,
244
242
  Q_ENABLE_QUERY_LOG, Q_DISABLE_QUERY_LOG,
245
243
  Q_ENABLE_RESULT_LOG, Q_DISABLE_RESULT_LOG,
252
250
  Q_DISPLAY_VERTICAL_RESULTS, Q_DISPLAY_HORIZONTAL_RESULTS,
253
251
  Q_QUERY_VERTICAL, Q_QUERY_HORIZONTAL, Q_SORTED_RESULT,
254
252
  Q_START_TIMER, Q_END_TIMER,
255
 
  Q_CHARACTER_SET,
 
253
  Q_CHARACTER_SET, Q_DISABLE_PS_PROTOCOL, Q_ENABLE_PS_PROTOCOL,
256
254
  Q_DISABLE_RECONNECT, Q_ENABLE_RECONNECT,
257
255
  Q_IF,
258
256
  Q_DISABLE_PARSING, Q_ENABLE_PARSING,
261
259
  Q_CHMOD_FILE, Q_APPEND_FILE, Q_CAT_FILE, Q_DIFF_FILES,
262
260
  Q_SEND_QUIT, Q_CHANGE_USER, Q_MKDIR, Q_RMDIR,
263
261
 
264
 
  Q_UNKNOWN,             /* Unknown command.   */
265
 
  Q_COMMENT,             /* Comments, ignored. */
 
262
  Q_UNKNOWN,                           /* Unknown command.   */
 
263
  Q_COMMENT,                           /* Comments, ignored. */
266
264
  Q_COMMENT_WITH_COMMAND
267
265
};
268
266
 
322
320
  "start_timer",
323
321
  "end_timer",
324
322
  "character_set",
 
323
  "disable_ps_protocol",
 
324
  "enable_ps_protocol",
325
325
  "disable_reconnect",
326
326
  "enable_reconnect",
327
327
  "if",
334
334
  "copy_file",
335
335
  "perl",
336
336
  "die",
337
 
 
 
337
               
338
338
  /* Don't execute any more commands, compare result */
339
339
  "exit",
340
340
  "skip",
370
370
  enum match_err_type type;
371
371
  union
372
372
  {
373
 
    uint32_t errnum;
374
 
    char sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE+1];  /* \0 terminated string */
 
373
    uint errnum;
 
374
    char sqlstate[SQLSTATE_LENGTH+1];  /* \0 terminated string */
375
375
  } code;
376
376
};
377
377
 
378
378
struct st_expected_errors
379
379
{
380
380
  struct st_match_err err[10];
381
 
  uint32_t count;
 
381
  uint count;
382
382
};
383
383
static struct st_expected_errors saved_expected_errors;
384
384
 
386
386
{
387
387
  char *query, *query_buf,*first_argument,*last_argument,*end;
388
388
  int first_word_len, query_len;
389
 
  bool abort_on_error;
390
 
  st_expected_errors expected_errors;
391
 
  string require_file;
 
389
  my_bool abort_on_error;
 
390
  struct st_expected_errors expected_errors;
 
391
  char require_file[FN_REFLEN];
392
392
  enum enum_commands type;
393
 
 
394
 
  st_command()
395
 
    : query(NULL), query_buf(NULL), first_argument(NULL), last_argument(NULL),
396
 
      end(NULL), first_word_len(0), query_len(0), abort_on_error(false),
397
 
      require_file(""), type(Q_CONNECTION)
398
 
  {
399
 
    memset(&expected_errors, 0, sizeof(st_expected_errors));
400
 
  }
401
 
 
402
 
  ~st_command()
403
 
  {
404
 
    if (query_buf != NULL)
405
 
    {
406
 
      free(query_buf);
407
 
    }
408
 
  }
409
393
};
410
394
 
411
395
TYPELIB command_typelib= {array_elements(command_names),"",
412
 
                          command_names, 0};
 
396
                          command_names, 0};
413
397
 
414
 
string ds_res, ds_progress, ds_warning_messages;
 
398
DYNAMIC_STRING ds_res, ds_progress, ds_warning_messages;
415
399
 
416
400
char builtin_echo[FN_REFLEN];
417
401
 
418
402
void die(const char *fmt, ...)
419
 
  __attribute__((format(printf, 1, 2)));
 
403
  ATTRIBUTE_FORMAT(printf, 1, 2);
420
404
void abort_not_supported_test(const char *fmt, ...)
421
 
  __attribute__((format(printf, 1, 2)));
 
405
  ATTRIBUTE_FORMAT(printf, 1, 2);
422
406
void verbose_msg(const char *fmt, ...)
423
 
  __attribute__((format(printf, 1, 2)));
 
407
  ATTRIBUTE_FORMAT(printf, 1, 2);
424
408
void warning_msg(const char *fmt, ...)
425
 
  __attribute__((format(printf, 1, 2)));
 
409
  ATTRIBUTE_FORMAT(printf, 1, 2);
426
410
void log_msg(const char *fmt, ...)
427
 
  __attribute__((format(printf, 1, 2)));
 
411
  ATTRIBUTE_FORMAT(printf, 1, 2);
428
412
 
429
413
VAR* var_from_env(const char *, const char *);
430
414
VAR* var_init(VAR* v, const char *name, int name_len, const char *val,
431
415
              int val_len);
432
 
void var_free(pair<string, VAR*> v);
 
416
void var_free(void* v);
433
417
VAR* var_get(const char *var_name, const char** var_name_end,
434
 
             bool raw, bool ignore_not_existing);
 
418
             my_bool raw, my_bool ignore_not_existing);
435
419
void eval_expr(VAR* v, const char *p, const char** p_end);
436
 
bool match_delimiter(int c, const char *delim, uint32_t length);
 
420
my_bool match_delimiter(int c, const char *delim, uint length);
437
421
void dump_result_to_reject_file(char *buf, int size);
438
 
void dump_result_to_log_file(const char *buf, int size);
439
 
void dump_warning_messages(void);
440
 
void dump_progress(void);
 
422
void dump_result_to_log_file(char *buf, int size);
 
423
void dump_warning_messages();
 
424
void dump_progress();
441
425
 
442
 
void do_eval(string *query_eval, const char *query,
443
 
             const char *query_end, bool pass_through_escape_chars);
444
 
void str_to_file(const char *fname, const char *str, int size);
445
 
void str_to_file2(const char *fname, const char *str, int size, bool append);
 
426
void do_eval(DYNAMIC_STRING *query_eval, const char *query,
 
427
             const char *query_end, my_bool pass_through_escape_chars);
 
428
void str_to_file(const char *fname, char *str, int size);
 
429
void str_to_file2(const char *fname, char *str, int size, my_bool append);
446
430
 
447
431
/* For replace_column */
448
432
static char *replace_column[MAX_COLUMNS];
449
 
static uint32_t max_replace_column= 0;
 
433
static uint max_replace_column= 0;
450
434
void do_get_replace_column(struct st_command*);
451
 
void free_replace_column(void);
 
435
void free_replace_column();
452
436
 
453
437
/* For replace */
454
438
void do_get_replace(struct st_command *command);
455
 
void free_replace(void);
 
439
void free_replace();
456
440
 
457
441
/* For replace_regex */
458
442
void do_get_replace_regex(struct st_command *command);
459
 
void free_replace_regex(void);
460
 
 
461
 
 
462
 
void free_all_replace(void);
463
 
 
464
 
 
465
 
void free_all_replace(void){
 
443
void free_replace_regex();
 
444
 
 
445
 
 
446
void free_all_replace(){
466
447
  free_replace();
467
448
  free_replace_regex();
468
449
  free_replace_column();
469
450
}
470
451
 
471
 
void replace_append_mem(string *ds, const char *val,
472
 
                        int len);
473
 
void replace_append(string *ds, const char *val);
474
 
void replace_append_uint(string *ds, uint32_t val);
475
 
void append_sorted(string* ds, string* ds_input);
 
452
void replace_dynstr_append_mem(DYNAMIC_STRING *ds, const char *val,
 
453
                               int len);
 
454
void replace_dynstr_append(DYNAMIC_STRING *ds, const char *val);
 
455
void replace_dynstr_append_uint(DYNAMIC_STRING *ds, uint val);
 
456
void dynstr_append_sorted(DYNAMIC_STRING* ds, DYNAMIC_STRING* ds_input);
476
457
 
477
458
void handle_error(struct st_command*,
478
459
                  unsigned int err_errno, const char *err_error,
479
 
                  const char *err_sqlstate, string *ds);
 
460
                  const char *err_sqlstate, DYNAMIC_STRING *ds);
480
461
void handle_no_error(struct st_command*);
481
462
 
482
 
 
483
 
void do_eval(string *query_eval, const char *query,
484
 
             const char *query_end, bool pass_through_escape_chars)
 
463
#ifdef EMBEDDED_LIBRARY
 
464
 
 
465
/* attributes of the query thread */
 
466
pthread_attr_t cn_thd_attrib;
 
467
 
 
468
/*
 
469
  send_one_query executes query in separate thread, which is
 
470
  necessary in embedded library to run 'send' in proper way.
 
471
  This implementation doesn't handle errors returned
 
472
  by mysql_send_query. It's technically possible, though
 
473
  I don't see where it is needed.
 
474
*/
 
475
pthread_handler_t send_one_query(void *arg)
 
476
{
 
477
  struct st_connection *cn= (struct st_connection*)arg;
 
478
 
 
479
  mysql_thread_init();
 
480
  VOID(mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len));
 
481
 
 
482
  mysql_thread_end();
 
483
  pthread_mutex_lock(&cn->mutex);
 
484
  cn->query_done= 1;
 
485
  VOID(pthread_cond_signal(&cn->cond));
 
486
  pthread_mutex_unlock(&cn->mutex);
 
487
  pthread_exit(0);
 
488
  return 0;
 
489
}
 
490
 
 
491
static int do_send_query(struct st_connection *cn, const char *q, int q_len,
 
492
                         int flags)
 
493
{
 
494
  pthread_t tid;
 
495
 
 
496
  if (flags & QUERY_REAP_FLAG)
 
497
    return mysql_send_query(&cn->mysql, q, q_len);
 
498
 
 
499
  if (pthread_mutex_init(&cn->mutex, NULL) ||
 
500
      pthread_cond_init(&cn->cond, NULL))
 
501
    die("Error in the thread library");
 
502
 
 
503
  cn->cur_query= q;
 
504
  cn->cur_query_len= q_len;
 
505
  cn->query_done= 0;
 
506
  if (pthread_create(&tid, &cn_thd_attrib, send_one_query, (void*)cn))
 
507
    die("Cannot start new thread for query");
 
508
 
 
509
  return 0;
 
510
}
 
511
 
 
512
static void wait_query_thread_end(struct st_connection *con)
 
513
{
 
514
  if (!con->query_done)
 
515
  {
 
516
    pthread_mutex_lock(&con->mutex);
 
517
    while (!con->query_done)
 
518
      pthread_cond_wait(&con->cond, &con->mutex);
 
519
    pthread_mutex_unlock(&con->mutex);
 
520
  }
 
521
}
 
522
 
 
523
#else /*EMBEDDED_LIBRARY*/
 
524
 
 
525
#define do_send_query(cn,q,q_len,flags) mysql_send_query(&cn->mysql, q, q_len)
 
526
 
 
527
#endif /*EMBEDDED_LIBRARY*/
 
528
 
 
529
void do_eval(DYNAMIC_STRING *query_eval, const char *query,
 
530
             const char *query_end, my_bool pass_through_escape_chars)
485
531
{
486
532
  const char *p;
487
533
  register char c, next_c;
488
534
  register int escaped = 0;
489
535
  VAR *v;
490
 
 
 
536
  DBUG_ENTER("do_eval");
491
537
 
492
538
  for (p= query; (c= *p) && p < query_end; ++p)
493
539
  {
495
541
    case '$':
496
542
      if (escaped)
497
543
      {
498
 
        escaped= 0;
499
 
        query_eval->append(p, 1);
 
544
        escaped= 0;
 
545
        dynstr_append_mem(query_eval, p, 1);
500
546
      }
501
547
      else
502
548
      {
503
 
        if (!(v= var_get(p, &p, 0, 0)))
504
 
          die("Bad variable in eval");
505
 
        query_eval->append(v->str_val, v->str_val_len);
 
549
        if (!(v= var_get(p, &p, 0, 0)))
 
550
          die("Bad variable in eval");
 
551
        dynstr_append_mem(query_eval, v->str_val, v->str_val_len);
506
552
      }
507
553
      break;
508
554
    case '\\':
509
555
      next_c= *(p+1);
510
556
      if (escaped)
511
557
      {
512
 
        escaped= 0;
513
 
        query_eval->append(p, 1);
 
558
        escaped= 0;
 
559
        dynstr_append_mem(query_eval, p, 1);
514
560
      }
515
561
      else if (next_c == '\\' || next_c == '$' || next_c == '"')
516
562
      {
517
563
        /* Set escaped only if next char is \, " or $ */
518
 
        escaped= 1;
 
564
        escaped= 1;
519
565
 
520
566
        if (pass_through_escape_chars)
521
567
        {
522
568
          /* The escape char should be added to the output string. */
523
 
          query_eval->append(p, 1);
 
569
          dynstr_append_mem(query_eval, p, 1);
524
570
        }
525
571
      }
526
572
      else
527
 
        query_eval->append(p, 1);
 
573
        dynstr_append_mem(query_eval, p, 1);
528
574
      break;
529
575
    default:
530
576
      escaped= 0;
531
 
      query_eval->append(p, 1);
 
577
      dynstr_append_mem(query_eval, p, 1);
532
578
      break;
533
579
    }
534
580
  }
535
 
  return;
536
 
}
537
 
 
538
 
 
539
 
/*
540
 
  Concatenates any number of strings, escapes any OS quote in the result then
541
 
  surround the whole affair in another set of quotes which is finally appended
542
 
  to specified string.  This function is especially useful when
543
 
  building strings to be executed with the system() function.
544
 
 
545
 
  @param str string which will have addtional strings appended.
546
 
  @param append string to be appended.
547
 
  @param ... Optional. Additional string(s) to be appended.
548
 
 
549
 
  @note The final argument in the list must be NULL even if no additional
550
 
  options are passed.
551
 
*/
552
 
 
553
 
static void append_os_quoted(string *str, const char *append, ...)
554
 
{
555
 
  const char *quote_str= "\'";
556
 
  const uint32_t  quote_len= 1;
557
 
 
558
 
  va_list dirty_text;
559
 
 
560
 
  str->append(quote_str, quote_len); /* Leading quote */
561
 
  va_start(dirty_text, append);
562
 
  while (append != NULL)
563
 
  {
564
 
    const char  *cur_pos= append;
565
 
    const char *next_pos= cur_pos;
566
 
 
567
 
    /* Search for quote in each string and replace with escaped quote */
568
 
    while((next_pos= strrchr(cur_pos, quote_str[0])) != NULL)
569
 
    {
570
 
      str->append(cur_pos, next_pos - cur_pos);
571
 
      str->append("\\", 1);
572
 
      str->append(quote_str, quote_len);
573
 
      cur_pos= next_pos + 1;
574
 
    }
575
 
    str->append(cur_pos);
576
 
    append= va_arg(dirty_text, char *);
577
 
  }
578
 
  va_end(dirty_text);
579
 
  str->append(quote_str, quote_len); /* Trailing quote */
 
581
  DBUG_VOID_RETURN;
580
582
}
581
583
 
582
584
 
588
590
 
589
591
  SYNOPSIS
590
592
  show_query
591
 
  drizzle - connection to use
 
593
  mysql - connection to use
592
594
  query - query to run
593
595
 
594
596
*/
595
597
 
596
 
static void show_query(drizzle_con_st *con, const char* query)
 
598
static void show_query(MYSQL* mysql, const char* query)
597
599
{
598
 
  drizzle_result_st res;
599
 
  drizzle_return_t ret;
600
 
 
601
 
  if (!con)
602
 
    return;
603
 
 
604
 
  if (drizzle_query_str(con, &res, query, &ret) == NULL ||
605
 
      ret != DRIZZLE_RETURN_OK)
 
600
  MYSQL_RES* res;
 
601
  DBUG_ENTER("show_query");
 
602
 
 
603
  if (!mysql)
 
604
    DBUG_VOID_RETURN;
 
605
 
 
606
  if (mysql_query(mysql, query))
606
607
  {
607
 
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
608
 
    {
609
 
      log_msg("Error running query '%s': %d %s",
610
 
              query, drizzle_result_error_code(&res),
611
 
              drizzle_result_error(&res));
612
 
      drizzle_result_free(&res);
613
 
    }
614
 
    else
615
 
    {
616
 
      log_msg("Error running query '%s': %d %s",
617
 
              query, ret, drizzle_con_error(con));
618
 
    }
619
 
    return;
 
608
    log_msg("Error running query '%s': %d %s",
 
609
            query, mysql_errno(mysql), mysql_error(mysql));
 
610
    DBUG_VOID_RETURN;
620
611
  }
621
612
 
622
 
  if (drizzle_result_column_count(&res) == 0 ||
623
 
      drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)
 
613
  if ((res= mysql_store_result(mysql)) == NULL)
624
614
  {
625
615
    /* No result set returned */
626
 
    drizzle_result_free(&res);
627
 
    return;
 
616
    DBUG_VOID_RETURN;
628
617
  }
629
618
 
630
619
  {
631
 
    drizzle_row_t row;
 
620
    MYSQL_ROW row;
632
621
    unsigned int i;
633
622
    unsigned int row_num= 0;
634
 
    unsigned int num_fields= drizzle_result_column_count(&res);
635
 
    drizzle_column_st *column;
 
623
    unsigned int num_fields= mysql_num_fields(res);
 
624
    MYSQL_FIELD *fields= mysql_fetch_fields(res);
636
625
 
637
626
    fprintf(stderr, "=== %s ===\n", query);
638
 
    while ((row= drizzle_row_next(&res)))
 
627
    while ((row= mysql_fetch_row(res)))
639
628
    {
640
 
      size_t *lengths= drizzle_row_field_sizes(&res);
 
629
      unsigned long *lengths= mysql_fetch_lengths(res);
641
630
      row_num++;
642
631
 
643
632
      fprintf(stderr, "---- %d. ----\n", row_num);
644
 
      drizzle_column_seek(&res, 0);
645
633
      for(i= 0; i < num_fields; i++)
646
634
      {
647
 
        column= drizzle_column_next(&res);
648
635
        fprintf(stderr, "%s\t%.*s\n",
649
 
                drizzle_column_name(column),
 
636
                fields[i].name,
650
637
                (int)lengths[i], row[i] ? row[i] : "NULL");
651
638
      }
652
639
    }
654
641
      fprintf(stderr, "=");
655
642
    fprintf(stderr, "\n\n");
656
643
  }
657
 
  drizzle_result_free(&res);
 
644
  mysql_free_result(res);
658
645
 
659
 
  return;
 
646
  DBUG_VOID_RETURN;
660
647
}
661
648
 
662
649
 
669
656
 
670
657
  SYNOPSIS
671
658
  show_warnings_before_error
672
 
  drizzle - connection to use
 
659
  mysql - connection to use
673
660
 
674
661
*/
675
662
 
676
 
static void show_warnings_before_error(drizzle_con_st *con)
 
663
static void show_warnings_before_error(MYSQL* mysql)
677
664
{
678
 
  drizzle_result_st res;
679
 
  drizzle_return_t ret;
 
665
  MYSQL_RES* res;
680
666
  const char* query= "SHOW WARNINGS";
681
 
 
682
 
  if (!con)
683
 
    return;
684
 
 
685
 
  if (drizzle_query_str(con, &res, query, &ret) == NULL ||
686
 
      ret != DRIZZLE_RETURN_OK)
 
667
  DBUG_ENTER("show_warnings_before_error");
 
668
 
 
669
  if (!mysql)
 
670
    DBUG_VOID_RETURN;
 
671
 
 
672
  if (mysql_query(mysql, query))
687
673
  {
688
 
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
689
 
    {
690
 
      log_msg("Error running query '%s': %d %s",
691
 
              query, drizzle_result_error_code(&res),
692
 
              drizzle_result_error(&res));
693
 
      drizzle_result_free(&res);
694
 
    }
695
 
    else
696
 
    {
697
 
      log_msg("Error running query '%s': %d %s",
698
 
              query, ret, drizzle_con_error(con));
699
 
    }
700
 
    return;
 
674
    log_msg("Error running query '%s': %d %s",
 
675
            query, mysql_errno(mysql), mysql_error(mysql));
 
676
    DBUG_VOID_RETURN;
701
677
  }
702
678
 
703
 
  if (drizzle_result_column_count(&res) == 0 ||
704
 
      drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)
 
679
  if ((res= mysql_store_result(mysql)) == NULL)
705
680
  {
706
681
    /* No result set returned */
707
 
    drizzle_result_free(&res);
708
 
    return;
 
682
    DBUG_VOID_RETURN;
709
683
  }
710
684
 
711
 
  if (drizzle_result_row_count(&res) <= 1)
 
685
  if (mysql_num_rows(res) <= 1)
712
686
  {
713
687
    /* Don't display the last row, it's "last error" */
714
688
  }
715
689
  else
716
690
  {
717
 
    drizzle_row_t row;
 
691
    MYSQL_ROW row;
718
692
    unsigned int row_num= 0;
719
 
    unsigned int num_fields= drizzle_result_column_count(&res);
 
693
    unsigned int num_fields= mysql_num_fields(res);
720
694
 
721
695
    fprintf(stderr, "\nWarnings from just before the error:\n");
722
 
    while ((row= drizzle_row_next(&res)))
 
696
    while ((row= mysql_fetch_row(res)))
723
697
    {
724
 
      uint32_t i;
725
 
      size_t *lengths= drizzle_row_field_sizes(&res);
 
698
      unsigned int i;
 
699
      unsigned long *lengths= mysql_fetch_lengths(res);
726
700
 
727
 
      if (++row_num >= drizzle_result_row_count(&res))
 
701
      if (++row_num >= mysql_num_rows(res))
728
702
      {
729
703
        /* Don't display the last row, it's "last error" */
730
704
        break;
738
712
      fprintf(stderr, "\n");
739
713
    }
740
714
  }
741
 
  drizzle_result_free(&res);
 
715
  mysql_free_result(res);
742
716
 
743
 
  return;
 
717
  DBUG_VOID_RETURN;
744
718
}
745
719
 
746
720
 
753
727
struct command_arg {
754
728
  const char *argname;       /* Name of argument   */
755
729
  enum arg_type type;        /* Type of argument   */
756
 
  bool required;          /* Argument required  */
757
 
  string *ds;        /* Storage for argument */
 
730
  my_bool required;          /* Argument required  */
 
731
  DYNAMIC_STRING *ds;        /* Storage for argument */
758
732
  const char *description;   /* Description of the argument */
759
733
};
760
734
 
761
735
 
762
 
static void check_command_args(struct st_command *command,
763
 
                               const char *arguments,
764
 
                               const struct command_arg *args,
765
 
                               int num_args, const char delimiter_arg)
 
736
void check_command_args(struct st_command *command,
 
737
                        const char *arguments,
 
738
                        const struct command_arg *args,
 
739
                        int num_args, const char delimiter_arg)
766
740
{
767
741
  int i;
768
742
  const char *ptr= arguments;
769
743
  const char *start;
 
744
  DBUG_ENTER("check_command_args");
 
745
  DBUG_PRINT("enter", ("num_args: %d", num_args));
770
746
 
771
747
  for (i= 0; i < num_args; i++)
772
748
  {
773
749
    const struct command_arg *arg= &args[i];
774
 
    arg->ds->clear();
775
750
 
776
751
    switch (arg->type) {
777
752
      /* A string */
785
760
        ptr++;
786
761
      if (ptr > start)
787
762
      {
788
 
        do_eval(arg->ds, start, ptr, false);
 
763
        init_dynamic_string(arg->ds, 0, ptr-start, 32);
 
764
        do_eval(arg->ds, start, ptr, FALSE);
789
765
      }
790
766
      else
791
767
      {
792
768
        /* Empty string */
793
 
        arg->ds->erase();
 
769
        init_dynamic_string(arg->ds, "", 0, 0);
794
770
      }
795
771
      command->last_argument= (char*)ptr;
796
772
 
797
773
      /* Step past the delimiter */
798
774
      if (*ptr && *ptr == delimiter_arg)
799
775
        ptr++;
 
776
      DBUG_PRINT("info", ("val: %s", arg->ds->str));
800
777
      break;
801
778
 
802
779
      /* Rest of line */
803
780
    case ARG_REST:
804
781
      start= ptr;
805
 
      do_eval(arg->ds, start, command->end, false);
 
782
      init_dynamic_string(arg->ds, 0, command->query_len, 256);
 
783
      do_eval(arg->ds, start, command->end, FALSE);
806
784
      command->last_argument= command->end;
 
785
      DBUG_PRINT("info", ("val: %s", arg->ds->str));
807
786
      break;
808
787
 
809
788
    default:
810
 
      assert("Unknown argument type");
 
789
      DBUG_ASSERT("Unknown argument type");
811
790
      break;
812
791
    }
813
792
 
814
793
    /* Check required arg */
815
 
    if (arg->ds->length() == 0 && arg->required)
 
794
    if (arg->ds->length == 0 && arg->required)
816
795
      die("Missing required argument '%s' to command '%.*s'", arg->argname,
817
796
          command->first_word_len, command->query);
818
797
 
826
805
          ptr, command->first_word_len, command->query);
827
806
    ptr++;
828
807
  }
829
 
  return;
 
808
  DBUG_VOID_RETURN;
830
809
}
831
810
 
832
811
 
833
 
static void handle_command_error(struct st_command *command, uint32_t error)
 
812
void handle_command_error(struct st_command *command, uint error)
834
813
{
835
 
 
 
814
  DBUG_ENTER("handle_command_error");
 
815
  DBUG_PRINT("enter", ("error: %d", error));
836
816
  if (error != 0)
837
817
  {
838
 
    uint32_t i;
 
818
    uint i;
839
819
 
840
820
    if (command->abort_on_error)
841
821
      die("command \"%.*s\" failed with error %d",
842
822
          command->first_word_len, command->query, error);
843
823
    for (i= 0; i < command->expected_errors.count; i++)
844
824
    {
 
825
      DBUG_PRINT("info", ("expected error: %d",
 
826
                          command->expected_errors.err[i].code.errnum));
845
827
      if ((command->expected_errors.err[i].type == ERR_ERRNO) &&
846
828
          (command->expected_errors.err[i].code.errnum == error))
847
829
      {
848
 
        return;
 
830
        DBUG_PRINT("info", ("command \"%.*s\" failed with expected error: %d",
 
831
                            command->first_word_len, command->query, error));
 
832
        DBUG_VOID_RETURN;
849
833
      }
850
834
    }
851
835
    die("command \"%.*s\" failed with wrong error: %d",
859
843
        command->first_word_len, command->query,
860
844
        command->expected_errors.err[0].code.errnum);
861
845
  }
862
 
  return;
 
846
  DBUG_VOID_RETURN;
863
847
}
864
848
 
865
849
 
866
 
static void close_connections(void)
 
850
void close_connections()
867
851
{
 
852
  DBUG_ENTER("close_connections");
868
853
  for (--next_con; next_con >= connections; --next_con)
869
854
  {
870
 
    if (next_con->drizzle != NULL)
871
 
    {
872
 
      drizzle_free(next_con->drizzle);
873
 
      next_con->drizzle= NULL;
874
 
    }
875
 
    free(next_con->name);
876
 
  }
877
 
  return;
878
 
}
879
 
 
880
 
 
881
 
static void close_files(void)
882
 
{
883
 
 
 
855
    if (next_con->stmt)
 
856
      mysql_stmt_close(next_con->stmt);
 
857
    next_con->stmt= 0;
 
858
    mysql_close(&next_con->mysql);
 
859
    if (next_con->util_mysql)
 
860
      mysql_close(next_con->util_mysql);
 
861
    my_free(next_con->name, MYF(MY_ALLOW_ZERO_PTR));
 
862
  }
 
863
  DBUG_VOID_RETURN;
 
864
}
 
865
 
 
866
 
 
867
void close_statements()
 
868
{
 
869
  struct st_connection *con;
 
870
  DBUG_ENTER("close_statements");
 
871
  for (con= connections; con < next_con; con++)
 
872
  {
 
873
    if (con->stmt)
 
874
      mysql_stmt_close(con->stmt);
 
875
    con->stmt= 0;
 
876
  }
 
877
  DBUG_VOID_RETURN;
 
878
}
 
879
 
 
880
 
 
881
void close_files()
 
882
{
 
883
  DBUG_ENTER("close_files");
884
884
  for (; cur_file >= file_stack; cur_file--)
885
885
  {
886
886
    if (cur_file->file && cur_file->file != stdin)
887
887
    {
888
 
      fclose(cur_file->file);
 
888
      DBUG_PRINT("info", ("closing file: %s", cur_file->file_name));
 
889
      my_fclose(cur_file->file, MYF(0));
889
890
    }
890
 
    free((unsigned char*) cur_file->file_name);
 
891
    my_free((uchar*) cur_file->file_name, MYF(MY_ALLOW_ZERO_PTR));
891
892
    cur_file->file_name= 0;
892
893
  }
893
 
  return;
 
894
  DBUG_VOID_RETURN;
894
895
}
895
896
 
896
897
 
897
 
static void free_used_memory(void)
 
898
void free_used_memory()
898
899
{
899
 
  uint32_t i;
900
 
 
 
900
  uint i;
 
901
  DBUG_ENTER("free_used_memory");
901
902
 
902
903
  close_connections();
903
904
  close_files();
904
 
  for_each(var_hash.begin(), var_hash.end(), var_free);
905
 
  var_hash.clear();
 
905
  hash_free(&var_hash);
906
906
 
907
 
  vector<st_command *>::iterator iter;
908
 
  for (iter= q_lines.begin() ; iter < q_lines.end() ; iter++)
 
907
  for (i= 0 ; i < q_lines.elements ; i++)
909
908
  {
910
 
    struct st_command * q_line= *iter;
911
 
    delete q_line;
 
909
    struct st_command **q= dynamic_element(&q_lines, i, struct st_command**);
 
910
    my_free((*q)->query_buf,MYF(MY_ALLOW_ZERO_PTR));
 
911
    my_free((*q),MYF(0));
912
912
  }
913
 
 
914
913
  for (i= 0; i < 10; i++)
915
914
  {
916
915
    if (var_reg[i].alloced_len)
917
 
      free(var_reg[i].str_val);
 
916
      my_free(var_reg[i].str_val, MYF(MY_WME));
918
917
  }
919
 
 
 
918
  while (embedded_server_arg_count > 1)
 
919
    my_free(embedded_server_args[--embedded_server_arg_count],MYF(0));
 
920
  delete_dynamic(&q_lines);
 
921
  dynstr_free(&ds_res);
 
922
  dynstr_free(&ds_progress);
 
923
  dynstr_free(&ds_warning_messages);
920
924
  free_all_replace();
921
 
  free(opt_pass);
 
925
  my_free(opt_pass,MYF(MY_ALLOW_ZERO_PTR));
922
926
  free_defaults(default_argv);
923
 
 
 
927
  free_re();
 
928
 
 
929
  /* Only call mysql_server_end if mysql_server_init has been called */
 
930
  if (server_initialized)
 
931
    mysql_server_end();
 
932
 
 
933
  /* Don't use DBUG after mysql_server_end() */
924
934
  return;
925
935
}
926
936
 
928
938
static void cleanup_and_exit(int exit_code)
929
939
{
930
940
  free_used_memory();
931
 
  my_end();
 
941
  my_end(my_end_arg);
932
942
 
933
943
  if (!silent) {
934
944
    switch (exit_code) {
940
950
      break;
941
951
    case 62:
942
952
      printf("skipped\n");
943
 
      break;
 
953
    break;
944
954
    default:
945
955
      printf("unknown exit code: %d\n", exit_code);
946
 
      assert(0);
 
956
      DBUG_ASSERT(0);
947
957
    }
948
958
  }
949
959
 
954
964
{
955
965
  static int dying= 0;
956
966
  va_list args;
 
967
  DBUG_ENTER("die");
 
968
  DBUG_PRINT("enter", ("start_lineno: %d", start_lineno));
957
969
 
958
970
  /*
959
971
    Protect against dying twice
965
977
  dying= 1;
966
978
 
967
979
  /* Print the error message */
968
 
  fprintf(stderr, "drizzletest: ");
 
980
  fprintf(stderr, "mysqltest: ");
969
981
  if (cur_file && cur_file != file_stack)
970
982
    fprintf(stderr, "In included file \"%s\": ",
971
983
            cur_file->file_name);
983
995
  fflush(stderr);
984
996
 
985
997
  /* Show results from queries just before failure */
986
 
  if (ds_res.length() && opt_tail_lines)
 
998
  if (ds_res.length && opt_tail_lines)
987
999
  {
988
1000
    int tail_lines= opt_tail_lines;
989
 
    const char* show_from= ds_res.c_str() + ds_res.length() - 1;
990
 
    while(show_from > ds_res.c_str() && tail_lines > 0 )
 
1001
    char* show_from= ds_res.str + ds_res.length - 1;
 
1002
    while(show_from > ds_res.str && tail_lines > 0 )
991
1003
    {
992
1004
      show_from--;
993
1005
      if (*show_from == '\n')
994
1006
        tail_lines--;
995
1007
    }
996
1008
    fprintf(stderr, "\nThe result from queries just before the failure was:\n");
997
 
    if (show_from > ds_res.c_str())
 
1009
    if (show_from > ds_res.str)
998
1010
      fprintf(stderr, "< snip >");
999
1011
    fprintf(stderr, "%s", show_from);
1000
1012
    fflush(stderr);
1001
1013
  }
1002
1014
 
1003
1015
  /* Dump the result that has been accumulated so far to .log file */
1004
 
  if (result_file_name && ds_res.length())
1005
 
    dump_result_to_log_file(ds_res.c_str(), ds_res.length());
 
1016
  if (result_file_name && ds_res.length)
 
1017
    dump_result_to_log_file(ds_res.str, ds_res.length);
1006
1018
 
1007
1019
  /* Dump warning messages */
1008
 
  if (result_file_name && ds_warning_messages.length())
 
1020
  if (result_file_name && ds_warning_messages.length)
1009
1021
    dump_warning_messages();
1010
1022
 
1011
1023
  /*
1013
1025
    been produced prior to the error
1014
1026
  */
1015
1027
  if (cur_con)
1016
 
    show_warnings_before_error(&cur_con->con);
 
1028
    show_warnings_before_error(&cur_con->mysql);
1017
1029
 
1018
1030
  cleanup_and_exit(1);
1019
1031
}
1023
1035
{
1024
1036
  va_list args;
1025
1037
  struct st_test_file* err_file= cur_file;
1026
 
 
 
1038
  DBUG_ENTER("abort_not_supported_test");
1027
1039
 
1028
1040
  /* Print include filestack */
1029
1041
  fprintf(stderr, "The test '%s' is not supported by this installation\n",
1052
1064
}
1053
1065
 
1054
1066
 
 
1067
void abort_not_in_this_version()
 
1068
{
 
1069
  die("Not available in this version of mysqltest");
 
1070
}
 
1071
 
 
1072
 
 
1073
void deprecated(struct st_command *command)
 
1074
{
 
1075
  die("'%.*s'has been deprecated",
 
1076
      command->first_word_len, command->query);
 
1077
}
 
1078
 
 
1079
 
1055
1080
void verbose_msg(const char *fmt, ...)
1056
1081
{
1057
1082
  va_list args;
1058
 
 
 
1083
  DBUG_ENTER("verbose_msg");
1059
1084
  if (!verbose)
1060
 
    return;
 
1085
    DBUG_VOID_RETURN;
1061
1086
 
1062
1087
  va_start(args, fmt);
1063
 
  fprintf(stderr, "drizzletest: ");
 
1088
  fprintf(stderr, "mysqltest: ");
1064
1089
  if (cur_file && cur_file != file_stack)
1065
1090
    fprintf(stderr, "In included file \"%s\": ",
1066
1091
            cur_file->file_name);
1070
1095
  fprintf(stderr, "\n");
1071
1096
  va_end(args);
1072
1097
 
1073
 
  return;
 
1098
  DBUG_VOID_RETURN;
1074
1099
}
1075
1100
 
1076
1101
 
1079
1104
  va_list args;
1080
1105
  char buff[512];
1081
1106
  size_t len;
1082
 
 
 
1107
  DBUG_ENTER("warning_msg");
1083
1108
 
1084
1109
  va_start(args, fmt);
1085
 
  ds_warning_messages.append("drizzletest: ");
 
1110
  dynstr_append(&ds_warning_messages, "mysqltest: ");
1086
1111
  if (start_lineno != 0)
1087
1112
  {
1088
 
    ds_warning_messages.append("Warning detected ");
 
1113
    dynstr_append(&ds_warning_messages, "Warning detected ");
1089
1114
    if (cur_file && cur_file != file_stack)
1090
1115
    {
1091
 
      len= snprintf(buff, sizeof(buff), "in included file %s ",
1092
 
                    cur_file->file_name);
1093
 
      ds_warning_messages.append(buff, len);
 
1116
      len= my_snprintf(buff, sizeof(buff), "in included file %s ",
 
1117
                       cur_file->file_name);
 
1118
      dynstr_append_mem(&ds_warning_messages,
 
1119
                        buff, len);
1094
1120
    }
1095
 
    len= snprintf(buff, sizeof(buff), "at line %d: ",
1096
 
                  start_lineno);
1097
 
    ds_warning_messages.append(buff, len);
 
1121
    len= my_snprintf(buff, sizeof(buff), "at line %d: ",
 
1122
                     start_lineno);
 
1123
    dynstr_append_mem(&ds_warning_messages,
 
1124
                      buff, len);
1098
1125
  }
1099
1126
 
1100
 
  len= vsnprintf(buff, sizeof(buff), fmt, args);
1101
 
  ds_warning_messages.append(buff, len);
 
1127
  len= my_vsnprintf(buff, sizeof(buff), fmt, args);
 
1128
  dynstr_append_mem(&ds_warning_messages, buff, len);
1102
1129
 
1103
 
  ds_warning_messages.append("\n");
 
1130
  dynstr_append(&ds_warning_messages, "\n");
1104
1131
  va_end(args);
1105
1132
 
1106
 
  return;
 
1133
  DBUG_VOID_RETURN;
1107
1134
}
1108
1135
 
1109
1136
 
1112
1139
  va_list args;
1113
1140
  char buff[1024];
1114
1141
  size_t len;
1115
 
 
 
1142
  DBUG_ENTER("log_msg");
1116
1143
 
1117
1144
  va_start(args, fmt);
1118
 
  len= vsnprintf(buff, sizeof(buff)-1, fmt, args);
 
1145
  len= my_vsnprintf(buff, sizeof(buff)-1, fmt, args);
1119
1146
  va_end(args);
1120
1147
 
1121
 
  ds_res.append(buff, len);
1122
 
  ds_res.append("\n");
 
1148
  dynstr_append_mem(&ds_res, buff, len);
 
1149
  dynstr_append(&ds_res, "\n");
1123
1150
 
1124
 
  return;
 
1151
  DBUG_VOID_RETURN;
1125
1152
}
1126
1153
 
1127
1154
 
1135
1162
 
1136
1163
*/
1137
1164
 
1138
 
static void cat_file(string* ds, const char* filename)
 
1165
void cat_file(DYNAMIC_STRING* ds, const char* filename)
1139
1166
{
1140
1167
  int fd;
1141
 
  uint32_t len;
 
1168
  uint len;
1142
1169
  char buff[512];
1143
1170
 
1144
1171
  if ((fd= my_open(filename, O_RDONLY, MYF(0))) < 0)
1145
1172
    die("Failed to open file '%s'", filename);
1146
 
  while((len= my_read(fd, (unsigned char*)&buff,
 
1173
  while((len= my_read(fd, (uchar*)&buff,
1147
1174
                      sizeof(buff), MYF(0))) > 0)
1148
1175
  {
1149
1176
    char *p= buff, *start= buff;
1155
1182
        /* Add fake newline instead of cr and output the line */
1156
1183
        *p= '\n';
1157
1184
        p++; /* Step past the "fake" newline */
1158
 
        ds->append(start, p-start);
 
1185
        dynstr_append_mem(ds, start, p-start);
1159
1186
        p++; /* Step past the "fake" newline */
1160
1187
        start= p;
1161
1188
      }
1162
1189
      else
1163
1190
        p++;
1164
1191
    }
1165
 
    /* Output any chars that might be left */
1166
 
    ds->append(start, p-start);
 
1192
    /* Output any chars that migh be left */
 
1193
    dynstr_append_mem(ds, start, p-start);
1167
1194
  }
1168
1195
  my_close(fd, MYF(0));
1169
1196
}
1175
1202
  SYNOPSIS
1176
1203
  run_command
1177
1204
  cmd - command to execute(should be properly quoted
1178
 
  result - pointer to string where to store the result
 
1205
  ds_res- pointer to dynamic string where to store the result
1179
1206
 
1180
1207
*/
1181
1208
 
1182
 
static int run_command(const char * cmd, string * result)
 
1209
static int run_command(char* cmd,
 
1210
                       DYNAMIC_STRING *ds_res)
1183
1211
{
1184
 
  assert(result!=NULL);
1185
1212
  char buf[512]= {0};
1186
1213
  FILE *res_file;
1187
1214
  int error;
1191
1218
 
1192
1219
  while (fgets(buf, sizeof(buf), res_file))
1193
1220
  {
1194
 
    /* Save the output of this command in the supplied string */
1195
 
    result->append(buf);
 
1221
    DBUG_PRINT("info", ("buf: %s", buf));
 
1222
    if(ds_res)
 
1223
    {
 
1224
      /* Save the output of this command in the supplied string */
 
1225
      dynstr_append(ds_res, buf);
 
1226
    }
 
1227
    else
 
1228
    {
 
1229
      /* Print it directly on screen */
 
1230
      fprintf(stdout, "%s", buf);
 
1231
    }
1196
1232
  }
1197
1233
 
1198
1234
  error= pclose(res_file);
1206
1242
  SYNOPSIS
1207
1243
  run_tool
1208
1244
  tool_path - the name of the tool to run
1209
 
  result - pointer to dynamic string where to store the result
 
1245
  ds_res - pointer to dynamic string where to store the result
1210
1246
  ... - variable number of arguments that will be properly
1211
 
  quoted and appended after the tool's name
 
1247
        quoted and appended after the tool's name
1212
1248
 
1213
1249
*/
1214
1250
 
1215
 
static int run_tool(const char *tool_path, string * result, ...)
 
1251
static int run_tool(const char *tool_path, DYNAMIC_STRING *ds_res, ...)
1216
1252
{
1217
1253
  int ret;
1218
1254
  const char* arg;
1219
1255
  va_list args;
1220
 
  string ds_cmdline;
1221
 
 
1222
 
 
1223
 
  append_os_quoted(&ds_cmdline, tool_path, NULL);
1224
 
  ds_cmdline.append(" ");
1225
 
 
1226
 
  va_start(args, result);
 
1256
  DYNAMIC_STRING ds_cmdline;
 
1257
 
 
1258
  DBUG_ENTER("run_tool");
 
1259
  DBUG_PRINT("enter", ("tool_path: %s", tool_path));
 
1260
 
 
1261
  if (init_dynamic_string(&ds_cmdline, "", FN_REFLEN, FN_REFLEN))
 
1262
    die("Out of memory");
 
1263
 
 
1264
  dynstr_append_os_quoted(&ds_cmdline, tool_path, NullS);
 
1265
  dynstr_append(&ds_cmdline, " ");
 
1266
 
 
1267
  va_start(args, ds_res);
1227
1268
 
1228
1269
  while ((arg= va_arg(args, char *)))
1229
1270
  {
1230
1271
    /* Options should be os quoted */
1231
1272
    if (strncmp(arg, "--", 2) == 0)
1232
 
      append_os_quoted(&ds_cmdline, arg, NULL);
 
1273
      dynstr_append_os_quoted(&ds_cmdline, arg, NullS);
1233
1274
    else
1234
 
      ds_cmdline.append(arg);
1235
 
    ds_cmdline.append(" ");
 
1275
      dynstr_append(&ds_cmdline, arg);
 
1276
    dynstr_append(&ds_cmdline, " ");
1236
1277
  }
1237
1278
 
1238
1279
  va_end(args);
1239
1280
 
1240
 
  ret= run_command(ds_cmdline.c_str(), result);
1241
 
  return(ret);
 
1281
  DBUG_PRINT("info", ("Running: %s", ds_cmdline.str));
 
1282
  ret= run_command(ds_cmdline.str, ds_res);
 
1283
  DBUG_PRINT("exit", ("ret: %d", ret));
 
1284
  dynstr_free(&ds_cmdline);
 
1285
  DBUG_RETURN(ret);
1242
1286
}
1243
1287
 
1244
1288
 
1255
1299
 
1256
1300
*/
1257
1301
 
1258
 
static void show_diff(string* ds,
1259
 
                      const char* filename1, const char* filename2)
 
1302
void show_diff(DYNAMIC_STRING* ds,
 
1303
               const char* filename1, const char* filename2)
1260
1304
{
1261
1305
 
1262
 
  string ds_tmp;
 
1306
  DYNAMIC_STRING ds_tmp;
 
1307
 
 
1308
  if (init_dynamic_string(&ds_tmp, "", 256, 256))
 
1309
    die("Out of memory");
1263
1310
 
1264
1311
  /* First try with unified diff */
1265
1312
  if (run_tool("diff",
1270
1317
               "2>&1",
1271
1318
               NULL) > 1) /* Most "diff" tools return >1 if error */
1272
1319
  {
 
1320
    dynstr_set(&ds_tmp, "");
1273
1321
 
1274
1322
    /* Fallback to context diff with "diff -c" */
1275
1323
    if (run_tool("diff",
1284
1332
        Fallback to dump both files to result file and inform
1285
1333
        about installing "diff"
1286
1334
      */
1287
 
      ds_tmp.clear();
1288
 
 
1289
 
      ds_tmp.append(
1290
 
                    "\n"
1291
 
                    "The two files differ but it was not possible to execute 'diff' in\n"
1292
 
                    "order to show only the difference, tried both 'diff -u' or 'diff -c'.\n"
1293
 
                    "Instead the whole content of the two files was shown for you to diff manually. ;)\n\n"
1294
 
                    "To get a better report you should install 'diff' on your system, which you\n"
1295
 
                    "for example can get from http://www.gnu.org/software/diffutils/diffutils.html\n"
1296
 
                    "\n");
1297
 
 
1298
 
      ds_tmp.append(" --- ");
1299
 
      ds_tmp.append(filename1);
1300
 
      ds_tmp.append(" >>>\n");
 
1335
      dynstr_set(&ds_tmp, "");
 
1336
 
 
1337
      dynstr_append(&ds_tmp,
 
1338
"\n"
 
1339
"The two files differ but it was not possible to execute 'diff' in\n"
 
1340
"order to show only the difference, tried both 'diff -u' or 'diff -c'.\n"
 
1341
"Instead the whole content of the two files was shown for you to diff manually. ;)\n\n"
 
1342
"To get a better report you should install 'diff' on your system, which you\n"
 
1343
"for example can get from http://www.gnu.org/software/diffutils/diffutils.html\n"
 
1344
"\n");
 
1345
 
 
1346
      dynstr_append(&ds_tmp, " --- ");
 
1347
      dynstr_append(&ds_tmp, filename1);
 
1348
      dynstr_append(&ds_tmp, " >>>\n");
1301
1349
      cat_file(&ds_tmp, filename1);
1302
 
      ds_tmp.append("<<<\n --- ");
1303
 
      ds_tmp.append(filename1);
1304
 
      ds_tmp.append(" >>>\n");
 
1350
      dynstr_append(&ds_tmp, "<<<\n --- ");
 
1351
      dynstr_append(&ds_tmp, filename1);
 
1352
      dynstr_append(&ds_tmp, " >>>\n");
1305
1353
      cat_file(&ds_tmp, filename2);
1306
 
      ds_tmp.append("<<<<\n");
 
1354
      dynstr_append(&ds_tmp, "<<<<\n");
1307
1355
    }
1308
1356
  }
1309
1357
 
1310
1358
  if (ds)
1311
1359
  {
1312
1360
    /* Add the diff to output */
1313
 
    ds->append(ds_tmp.c_str(), ds_tmp.length());
 
1361
    dynstr_append_mem(ds, ds_tmp.str, ds_tmp.length);
1314
1362
  }
1315
1363
  else
1316
1364
  {
1317
1365
    /* Print diff directly to stdout */
1318
 
    fprintf(stderr, "%s\n", ds_tmp.c_str());
 
1366
    fprintf(stderr, "%s\n", ds_tmp.str);
1319
1367
  }
 
1368
 
 
1369
  dynstr_free(&ds_tmp);
1320
1370
 
1321
1371
}
1322
1372
 
1323
1373
 
1324
1374
enum compare_files_result_enum {
1325
 
  RESULT_OK= 0,
1326
 
  RESULT_CONTENT_MISMATCH= 1,
1327
 
  RESULT_LENGTH_MISMATCH= 2
 
1375
   RESULT_OK= 0,
 
1376
   RESULT_CONTENT_MISMATCH= 1,
 
1377
   RESULT_LENGTH_MISMATCH= 2
1328
1378
};
1329
1379
 
1330
1380
/*
1341
1391
 
1342
1392
*/
1343
1393
 
1344
 
static int compare_files2(int fd, const char* filename2)
 
1394
int compare_files2(File fd, const char* filename2)
1345
1395
{
1346
1396
  int error= RESULT_OK;
1347
 
  int fd2;
1348
 
  uint32_t len, len2;
 
1397
  File fd2;
 
1398
  uint len, len2;
1349
1399
  char buff[512], buff2[512];
1350
 
  const char *fname= filename2;
1351
 
  string tmpfile;
1352
1400
 
1353
 
  if ((fd2= my_open(fname, O_RDONLY, MYF(0))) < 0)
 
1401
  if ((fd2= my_open(filename2, O_RDONLY, MYF(0))) < 0)
1354
1402
  {
1355
1403
    my_close(fd, MYF(0));
1356
 
    if (opt_testdir != NULL)
1357
 
    {
1358
 
      tmpfile= opt_testdir;
1359
 
      if (tmpfile[tmpfile.length()] != '/')
1360
 
        tmpfile.append("/");
1361
 
      tmpfile.append(filename2);
1362
 
      fname= tmpfile.c_str();
1363
 
    }
1364
 
    if ((fd2= my_open(fname, O_RDONLY, MYF(0))) < 0)
1365
 
    {
1366
 
      my_close(fd, MYF(0));
1367
 
    
1368
 
      die("Failed to open second file: '%s'", fname);
1369
 
    }
 
1404
    die("Failed to open second file: '%s'", filename2);
1370
1405
  }
1371
 
  while((len= my_read(fd, (unsigned char*)&buff,
 
1406
  while((len= my_read(fd, (uchar*)&buff,
1372
1407
                      sizeof(buff), MYF(0))) > 0)
1373
1408
  {
1374
 
    if ((len2= my_read(fd2, (unsigned char*)&buff2,
 
1409
    if ((len2= my_read(fd2, (uchar*)&buff2,
1375
1410
                       sizeof(buff2), MYF(0))) < len)
1376
1411
    {
1377
1412
      /* File 2 was smaller */
1391
1426
      break;
1392
1427
    }
1393
1428
  }
1394
 
  if (!error && my_read(fd2, (unsigned char*)&buff2,
 
1429
  if (!error && my_read(fd2, (uchar*)&buff2,
1395
1430
                        sizeof(buff2), MYF(0)) > 0)
1396
1431
  {
1397
1432
    /* File 1 was smaller */
1417
1452
 
1418
1453
*/
1419
1454
 
1420
 
static int compare_files(const char* filename1, const char* filename2)
 
1455
int compare_files(const char* filename1, const char* filename2)
1421
1456
{
1422
 
  int fd;
 
1457
  File fd;
1423
1458
  int error;
1424
1459
 
1425
1460
  if ((fd= my_open(filename1, O_RDONLY, MYF(0))) < 0)
1437
1472
  Compare content of the string in ds to content of file fname
1438
1473
 
1439
1474
  SYNOPSIS
1440
 
  string_cmp
 
1475
  dyn_string_cmp
1441
1476
  ds - Dynamic string containing the string o be compared
1442
1477
  fname - Name of file to compare with
1443
1478
 
1445
1480
  See 'compare_files2'
1446
1481
*/
1447
1482
 
1448
 
static int string_cmp(string* ds, const char *fname)
 
1483
int dyn_string_cmp(DYNAMIC_STRING* ds, const char *fname)
1449
1484
{
1450
1485
  int error;
1451
 
  int fd;
 
1486
  File fd;
1452
1487
  char temp_file_path[FN_REFLEN];
1453
1488
 
 
1489
  DBUG_ENTER("dyn_string_cmp");
 
1490
  DBUG_PRINT("enter", ("fname: %s", fname));
 
1491
 
1454
1492
  if ((fd= create_temp_file(temp_file_path, NULL,
1455
 
                            "tmp", MYF(MY_WME))) < 0)
 
1493
                            "tmp", O_CREAT | O_SHARE | O_RDWR,
 
1494
                            MYF(MY_WME))) < 0)
1456
1495
    die("Failed to create temporary file for ds");
1457
1496
 
1458
1497
  /* Write ds to temporary file and set file pos to beginning*/
1459
 
  if (my_write(fd, (unsigned char *) ds->c_str(), ds->length(),
 
1498
  if (my_write(fd, (uchar *) ds->str, ds->length,
1460
1499
               MYF(MY_FNABP | MY_WME)) ||
1461
 
      lseek(fd, 0, SEEK_SET) == MY_FILEPOS_ERROR)
 
1500
      my_seek(fd, 0, SEEK_SET, MYF(0)) == MY_FILEPOS_ERROR)
1462
1501
  {
1463
1502
    my_close(fd, MYF(0));
1464
1503
    /* Remove the temporary file */
1472
1511
  /* Remove the temporary file */
1473
1512
  my_delete(temp_file_path, MYF(0));
1474
1513
 
1475
 
  return(error);
 
1514
  DBUG_RETURN(error);
1476
1515
}
1477
1516
 
1478
1517
 
1488
1527
 
1489
1528
*/
1490
1529
 
1491
 
static void check_result(string* ds)
 
1530
void check_result(DYNAMIC_STRING* ds)
1492
1531
{
1493
1532
  const char* mess= "Result content mismatch\n";
1494
1533
 
1495
 
 
1496
 
  assert(result_file_name);
 
1534
  DBUG_ENTER("check_result");
 
1535
  DBUG_ASSERT(result_file_name);
 
1536
  DBUG_PRINT("enter", ("result_file_name: %s", result_file_name));
1497
1537
 
1498
1538
  if (access(result_file_name, F_OK) != 0)
1499
1539
    die("The specified result file does not exist: '%s'", result_file_name);
1500
1540
 
1501
 
  switch (string_cmp(ds, result_file_name)) {
 
1541
  switch (dyn_string_cmp(ds, result_file_name)) {
1502
1542
  case RESULT_OK:
1503
1543
    break; /* ok */
1504
1544
  case RESULT_LENGTH_MISMATCH:
1526
1566
      fn_format(reject_file, result_file_name, opt_logdir,
1527
1567
                ".reject", MY_REPLACE_DIR | MY_REPLACE_EXT);
1528
1568
    }
1529
 
    str_to_file(reject_file, ds->c_str(), ds->length());
 
1569
    str_to_file(reject_file, ds->str, ds->length);
1530
1570
 
1531
 
    ds->erase(); /* Don't create a .log file */
 
1571
    dynstr_set(ds, NULL); /* Don't create a .log file */
1532
1572
 
1533
1573
    show_diff(NULL, result_file_name, reject_file);
1534
 
    die("%s",mess);
 
1574
    die(mess);
1535
1575
    break;
1536
1576
  }
1537
1577
  default: /* impossible */
1538
1578
    die("Unknown error code from dyn_string_cmp()");
1539
1579
  }
1540
1580
 
1541
 
  return;
 
1581
  DBUG_VOID_RETURN;
1542
1582
}
1543
1583
 
1544
1584
 
1557
1597
 
1558
1598
*/
1559
1599
 
1560
 
static void check_require(string* ds, const string &fname)
 
1600
void check_require(DYNAMIC_STRING* ds, const char *fname)
1561
1601
{
1562
 
 
1563
 
 
1564
 
  if (string_cmp(ds, fname.c_str()))
 
1602
  DBUG_ENTER("check_require");
 
1603
 
 
1604
  if (dyn_string_cmp(ds, fname))
1565
1605
  {
1566
1606
    char reason[FN_REFLEN];
1567
 
    fn_format(reason, fname.c_str(), "", "", MY_REPLACE_EXT | MY_REPLACE_DIR);
 
1607
    fn_format(reason, fname, "", "", MY_REPLACE_EXT | MY_REPLACE_DIR);
1568
1608
    abort_not_supported_test("Test requires: '%s'", reason);
1569
1609
  }
1570
 
  return;
 
1610
  DBUG_VOID_RETURN;
1571
1611
}
1572
1612
 
1573
1613
 
1574
1614
/*
1575
 
  Remove surrounding chars from string
 
1615
   Remove surrounding chars from string
1576
1616
 
1577
 
  Return 1 if first character is found but not last
 
1617
   Return 1 if first character is found but not last
1578
1618
*/
1579
1619
static int strip_surrounding(char* str, char c1, char c2)
1580
1620
{
1589
1629
    *ptr= ' ';
1590
1630
 
1591
1631
    /* Last non space charecter should be c2 */
1592
 
    ptr= strchr(str, '\0')-1;
 
1632
    ptr= strend(str)-1;
1593
1633
    while(*ptr && my_isspace(charset_info, *ptr))
1594
1634
      ptr--;
1595
1635
    if (*ptr == c2)
1610
1650
static void strip_parentheses(struct st_command *command)
1611
1651
{
1612
1652
  if (strip_surrounding(command->first_argument, '(', ')'))
1613
 
    die("%.*s - argument list started with '%c' must be ended with '%c'",
1614
 
        command->first_word_len, command->query, '(', ')');
1615
 
}
1616
 
 
 
1653
      die("%.*s - argument list started with '%c' must be ended with '%c'",
 
1654
          command->first_word_len, command->query, '(', ')');
 
1655
}
 
1656
 
 
1657
 
 
1658
static uchar *get_var_key(const uchar* var, size_t *len,
 
1659
                          my_bool __attribute__((unused)) t)
 
1660
{
 
1661
  register char* key;
 
1662
  key = ((VAR*)var)->name;
 
1663
  *len = ((VAR*)var)->name_len;
 
1664
  return (uchar*)key;
 
1665
}
1617
1666
 
1618
1667
 
1619
1668
VAR *var_init(VAR *v, const char *name, int name_len, const char *val,
1626
1675
  if (!val_len && val)
1627
1676
    val_len = strlen(val) ;
1628
1677
  val_alloc_len = val_len + 16; /* room to grow */
1629
 
  if (!(tmp_var=v) && !(tmp_var = (VAR*)malloc(sizeof(*tmp_var)
1630
 
                                               + name_len+1)))
 
1678
  if (!(tmp_var=v) && !(tmp_var = (VAR*)my_malloc(sizeof(*tmp_var)
 
1679
                                                  + name_len+1, MYF(MY_WME))))
1631
1680
    die("Out of memory");
1632
1681
 
1633
1682
  tmp_var->name = (name) ? (char*) tmp_var + sizeof(*tmp_var) : 0;
1634
1683
  tmp_var->alloced = (v == 0);
1635
1684
 
1636
 
  if (!(tmp_var->str_val = (char *)malloc(val_alloc_len+1)))
 
1685
  if (!(tmp_var->str_val = my_malloc(val_alloc_len+1, MYF(MY_WME))))
1637
1686
    die("Out of memory");
1638
1687
 
1639
1688
  memcpy(tmp_var->name, name, name_len);
1652
1701
}
1653
1702
 
1654
1703
 
1655
 
void var_free(pair<string, VAR *> v)
 
1704
void var_free(void *v)
1656
1705
{
1657
 
  free(v.second->str_val);
1658
 
  free(v.second->env_s);
1659
 
  if (v.second->alloced)
1660
 
    free(v.second);
 
1706
  my_free(((VAR*) v)->str_val, MYF(MY_WME));
 
1707
  my_free(((VAR*) v)->env_s, MYF(MY_WME|MY_ALLOW_ZERO_PTR));
 
1708
  if (((VAR*)v)->alloced)
 
1709
    my_free(v, MYF(MY_WME));
1661
1710
}
1662
1711
 
1663
1712
 
1669
1718
    tmp = def_val;
1670
1719
 
1671
1720
  v = var_init(0, name, strlen(name), tmp, strlen(tmp));
1672
 
  string var_name(name);
1673
 
  var_hash.insert(make_pair(var_name, v));
 
1721
  my_hash_insert(&var_hash, (uchar*)v);
1674
1722
  return v;
1675
1723
}
1676
1724
 
1677
1725
 
1678
 
VAR* var_get(const char *var_name, const char **var_name_end, bool raw,
1679
 
             bool ignore_not_existing)
 
1726
VAR* var_get(const char *var_name, const char **var_name_end, my_bool raw,
 
1727
             my_bool ignore_not_existing)
1680
1728
{
1681
1729
  int digit;
1682
1730
  VAR *v;
 
1731
  DBUG_ENTER("var_get");
 
1732
  DBUG_PRINT("enter", ("var_name: %s",var_name));
1683
1733
 
1684
1734
  if (*var_name != '$')
1685
1735
    goto err;
1687
1737
  if (digit < 0 || digit >= 10)
1688
1738
  {
1689
1739
    const char *save_var_name = var_name, *end;
1690
 
    uint32_t length;
 
1740
    uint length;
1691
1741
    end = (var_name_end) ? *var_name_end : 0;
1692
1742
    while (my_isvar(charset_info,*var_name) && var_name != end)
1693
1743
      var_name++;
1694
1744
    if (var_name == save_var_name)
1695
1745
    {
1696
1746
      if (ignore_not_existing)
1697
 
        return(0);
 
1747
        DBUG_RETURN(0);
1698
1748
      die("Empty variable");
1699
1749
    }
1700
 
    length= (uint32_t) (var_name - save_var_name);
 
1750
    length= (uint) (var_name - save_var_name);
1701
1751
    if (length >= MAX_VAR_NAME_LENGTH)
1702
1752
      die("Too long variable name: %s", save_var_name);
1703
1753
 
1704
 
    string save_var_name_str(save_var_name, length);
1705
 
    drizzled::hash_map<string, VAR*>::iterator iter=
1706
 
      var_hash.find(save_var_name_str);
1707
 
    if (iter == var_hash.end())
 
1754
    if (!(v = (VAR*) hash_search(&var_hash, (const uchar*) save_var_name,
 
1755
                                            length)))
1708
1756
    {
1709
1757
      char buff[MAX_VAR_NAME_LENGTH+1];
1710
 
      strncpy(buff, save_var_name, length);
1711
 
      buff[length]= '\0';
 
1758
      strmake(buff, save_var_name, length);
1712
1759
      v= var_from_env(buff, "");
1713
1760
    }
1714
 
    else
1715
 
    {
1716
 
      v= (*iter).second;
1717
 
    }
1718
 
    var_name--;  /* Point at last character */
 
1761
    var_name--; /* Point at last character */
1719
1762
  }
1720
1763
  else
1721
1764
    v = var_reg + digit;
1728
1771
  }
1729
1772
  if (var_name_end)
1730
1773
    *var_name_end = var_name  ;
1731
 
  return(v);
 
1774
  DBUG_RETURN(v);
1732
1775
err:
1733
1776
  if (var_name_end)
1734
1777
    *var_name_end = 0;
1735
1778
  die("Unsupported variable name: %s", var_name);
1736
 
  return(0);
 
1779
  DBUG_RETURN(0);
1737
1780
}
1738
1781
 
1739
1782
 
1740
 
static VAR *var_obtain(const char *name, int len)
 
1783
VAR *var_obtain(const char *name, int len)
1741
1784
{
1742
 
  string var_name(name, len);
1743
 
  drizzled::hash_map<string, VAR*>::iterator iter=
1744
 
    var_hash.find(var_name);
1745
 
  if (iter != var_hash.end())
1746
 
    return (*iter).second;
1747
 
  VAR *v = var_init(0, name, len, "", 0);
1748
 
  var_hash.insert(make_pair(var_name, v));
 
1785
  VAR* v;
 
1786
  if ((v = (VAR*)hash_search(&var_hash, (const uchar *) name, len)))
 
1787
    return v;
 
1788
  v = var_init(0, name, len, "", 0);
 
1789
  my_hash_insert(&var_hash, (uchar*)v);
1749
1790
  return v;
1750
1791
}
1751
1792
 
1756
1797
  environment variable will be updated
1757
1798
*/
1758
1799
 
1759
 
static void var_set(const char *var_name, const char *var_name_end,
1760
 
                    const char *var_val, const char *var_val_end)
 
1800
void var_set(const char *var_name, const char *var_name_end,
 
1801
             const char *var_val, const char *var_val_end)
1761
1802
{
1762
1803
  int digit, env_var= 0;
1763
1804
  VAR *v;
 
1805
  DBUG_ENTER("var_set");
 
1806
  DBUG_PRINT("enter", ("var_name: '%.*s' = '%.*s' (length: %d)",
 
1807
                       (int) (var_name_end - var_name), var_name,
 
1808
                       (int) (var_val_end - var_val), var_val,
 
1809
                       (int) (var_val_end - var_val)));
1764
1810
 
1765
1811
  if (*var_name != '$')
1766
1812
    env_var= 1;
1770
1816
  digit= *var_name - '0';
1771
1817
  if (!(digit < 10 && digit >= 0))
1772
1818
  {
1773
 
    v= var_obtain(var_name, (uint32_t) (var_name_end - var_name));
 
1819
    v= var_obtain(var_name, (uint) (var_name_end - var_name));
1774
1820
  }
1775
1821
  else
1776
1822
    v= var_reg + digit;
1786
1832
      v->int_dirty= 0;
1787
1833
      v->str_val_len= strlen(v->str_val);
1788
1834
    }
1789
 
    snprintf(buf, sizeof(buf), "%.*s=%.*s",
1790
 
             v->name_len, v->name,
1791
 
             v->str_val_len, v->str_val);
1792
 
    if (!(v->env_s= strdup(buf)))
 
1835
    my_snprintf(buf, sizeof(buf), "%.*s=%.*s",
 
1836
                v->name_len, v->name,
 
1837
                v->str_val_len, v->str_val);
 
1838
    if (!(v->env_s= my_strdup(buf, MYF(MY_WME))))
1793
1839
      die("Out of memory");
1794
1840
    putenv(v->env_s);
1795
 
    free(old_env_s);
 
1841
    my_free(old_env_s, MYF(MY_ALLOW_ZERO_PTR));
1796
1842
  }
1797
 
  return;
 
1843
  DBUG_VOID_RETURN;
1798
1844
}
1799
1845
 
1800
1846
 
1801
 
static void var_set_string(const char* name, const char* value)
 
1847
void var_set_string(const char* name, const char* value)
1802
1848
{
1803
1849
  var_set(name, name + strlen(name), value, value + strlen(value));
1804
1850
}
1805
1851
 
1806
1852
 
1807
 
static void var_set_int(const char* name, int value)
 
1853
void var_set_int(const char* name, int value)
1808
1854
{
1809
1855
  char buf[21];
1810
 
  snprintf(buf, sizeof(buf), "%d", value);
 
1856
  my_snprintf(buf, sizeof(buf), "%d", value);
1811
1857
  var_set_string(name, buf);
1812
1858
}
1813
1859
 
1814
1860
 
1815
1861
/*
1816
1862
  Store an integer (typically the returncode of the last SQL)
1817
 
  statement in the drizzletest builtin variable $drizzleclient_errno
 
1863
  statement in the mysqltest builtin variable $mysql_errno
1818
1864
*/
1819
1865
 
1820
 
static void var_set_errno(int sql_errno)
 
1866
void var_set_errno(int sql_errno)
1821
1867
{
1822
 
  var_set_int("$drizzleclient_errno", sql_errno);
 
1868
  var_set_int("$mysql_errno", sql_errno);
1823
1869
}
1824
1870
 
1825
1871
 
1826
1872
/*
1827
 
  Update $drizzleclient_get_server_version variable with version
 
1873
  Update $mysql_get_server_version variable with version
1828
1874
  of the currently connected server
1829
1875
*/
1830
1876
 
1831
 
static void var_set_drizzleclient_get_server_version(drizzle_con_st *con)
 
1877
void var_set_mysql_get_server_version(MYSQL* mysql)
1832
1878
{
1833
 
  var_set_int("$drizzle_con_server_version", drizzle_con_server_version_number(con));
 
1879
  var_set_int("$mysql_get_server_version", mysql_get_server_version(mysql));
1834
1880
}
1835
1881
 
1836
1882
 
1839
1885
 
1840
1886
  SYNOPSIS
1841
1887
  var_query_set()
1842
 
  var          variable to set from query
 
1888
  var           variable to set from query
1843
1889
  query       start of query string to execute
1844
1890
  query_end   end of the query string to execute
1845
1891
 
1857
1903
 
1858
1904
*/
1859
1905
 
1860
 
static void var_query_set(VAR *var, const char *query, const char** query_end)
 
1906
void var_query_set(VAR *var, const char *query, const char** query_end)
1861
1907
{
1862
 
  const char *end = (char*)((query_end && *query_end) ?
1863
 
                            *query_end : query + strlen(query));
1864
 
  drizzle_result_st res;
1865
 
  drizzle_return_t ret;
1866
 
  drizzle_row_t row;
1867
 
  drizzle_con_st *con= &cur_con->con;
1868
 
  string ds_query;
1869
 
 
 
1908
  char *end = (char*)((query_end && *query_end) ?
 
1909
                      *query_end : query + strlen(query));
 
1910
  MYSQL_RES *res;
 
1911
  MYSQL_ROW row;
 
1912
  MYSQL* mysql = &cur_con->mysql;
 
1913
  DYNAMIC_STRING ds_query;
 
1914
  DBUG_ENTER("var_query_set");
1870
1915
 
1871
1916
  while (end > query && *end != '`')
1872
1917
    --end;
1875
1920
  ++query;
1876
1921
 
1877
1922
  /* Eval the query, thus replacing all environment variables */
1878
 
  do_eval(&ds_query, query, end, false);
1879
 
 
1880
 
  if (drizzle_query(con, &res, ds_query.c_str(), ds_query.length(),
1881
 
                    &ret) == NULL ||
1882
 
      ret != DRIZZLE_RETURN_OK)
1883
 
  {
1884
 
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
1885
 
    {
1886
 
      die("Error running query '%s': %d %s", ds_query.c_str(),
1887
 
          drizzle_result_error_code(&res), drizzle_result_error(&res));
1888
 
      drizzle_result_free(&res);
1889
 
    }
1890
 
    else
1891
 
    {
1892
 
      die("Error running query '%s': %d %s", ds_query.c_str(), ret,
1893
 
          drizzle_con_error(con));
1894
 
    }
1895
 
  }
1896
 
  if (drizzle_result_column_count(&res) == 0 ||
1897
 
      drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)
1898
 
    die("Query '%s' didn't return a result set", ds_query.c_str());
1899
 
 
1900
 
  if ((row= drizzle_row_next(&res)) && row[0])
 
1923
  init_dynamic_string(&ds_query, 0, (end - query) + 32, 256);
 
1924
  do_eval(&ds_query, query, end, FALSE);
 
1925
 
 
1926
  if (mysql_real_query(mysql, ds_query.str, ds_query.length))
 
1927
    die("Error running query '%s': %d %s", ds_query.str,
 
1928
        mysql_errno(mysql), mysql_error(mysql));
 
1929
  if (!(res= mysql_store_result(mysql)))
 
1930
    die("Query '%s' didn't return a result set", ds_query.str);
 
1931
  dynstr_free(&ds_query);
 
1932
 
 
1933
  if ((row= mysql_fetch_row(res)) && row[0])
1901
1934
  {
1902
1935
    /*
1903
1936
      Concatenate all fields in the first row with tab in between
1904
1937
      and assign that string to the $variable
1905
1938
    */
1906
 
    string result;
1907
 
    uint32_t i;
1908
 
    size_t *lengths;
 
1939
    DYNAMIC_STRING result;
 
1940
    uint i;
 
1941
    ulong *lengths;
1909
1942
 
1910
 
    lengths= drizzle_row_field_sizes(&res);
1911
 
    for (i= 0; i < drizzle_result_column_count(&res); i++)
 
1943
    init_dynamic_string(&result, "", 512, 512);
 
1944
    lengths= mysql_fetch_lengths(res);
 
1945
    for (i= 0; i < mysql_num_fields(res); i++)
1912
1946
    {
1913
1947
      if (row[i])
1914
1948
      {
1915
1949
        /* Add column to tab separated string */
1916
 
        result.append(row[i], lengths[i]);
 
1950
        dynstr_append_mem(&result, row[i], lengths[i]);
1917
1951
      }
1918
 
      result.append("\t", 1);
 
1952
      dynstr_append_mem(&result, "\t", 1);
1919
1953
    }
1920
 
    end= result.c_str() + result.length()-1;
1921
 
    eval_expr(var, result.c_str(), (const char**) &end);
 
1954
    end= result.str + result.length-1;
 
1955
    eval_expr(var, result.str, (const char**) &end);
 
1956
    dynstr_free(&result);
1922
1957
  }
1923
1958
  else
1924
1959
    eval_expr(var, "", 0);
1925
1960
 
1926
 
  drizzle_result_free(&res);
1927
 
  return;
 
1961
  mysql_free_result(res);
 
1962
  DBUG_VOID_RETURN;
1928
1963
}
1929
1964
 
1930
1965
 
1944
1979
 
1945
1980
  <query to run> -    The query that should be sent to the server
1946
1981
  <column name> -     Name of the column that holds the field be compared
1947
 
  against the expected value
 
1982
                      against the expected value
1948
1983
  <row no> -          Number of the row that holds the field to be
1949
 
  compared against the expected value
 
1984
                      compared against the expected value
1950
1985
 
1951
1986
*/
1952
1987
 
1953
 
static void var_set_query_get_value(struct st_command *command, VAR *var)
 
1988
void var_set_query_get_value(struct st_command *command, VAR *var)
1954
1989
{
1955
1990
  long row_no;
1956
1991
  int col_no= -1;
1957
 
  drizzle_result_st res;
1958
 
  drizzle_return_t ret;
1959
 
  drizzle_con_st *con= &cur_con->con;
 
1992
  MYSQL_RES* res;
 
1993
  MYSQL* mysql= &cur_con->mysql;
1960
1994
 
1961
 
  string ds_query;
1962
 
  string ds_col;
1963
 
  string ds_row;
 
1995
  static DYNAMIC_STRING ds_query;
 
1996
  static DYNAMIC_STRING ds_col;
 
1997
  static DYNAMIC_STRING ds_row;
1964
1998
  const struct command_arg query_get_value_args[] = {
1965
 
    {"query", ARG_STRING, true, &ds_query, "Query to run"},
1966
 
    {"column name", ARG_STRING, true, &ds_col, "Name of column"},
1967
 
    {"row number", ARG_STRING, true, &ds_row, "Number for row"}
 
1999
    "query", ARG_STRING, TRUE, &ds_query, "Query to run",
 
2000
    "column name", ARG_STRING, TRUE, &ds_col, "Name of column",
 
2001
    "row number", ARG_STRING, TRUE, &ds_row, "Number for row"
1968
2002
  };
1969
2003
 
1970
 
 
 
2004
  DBUG_ENTER("var_set_query_get_value");
1971
2005
 
1972
2006
  strip_parentheses(command);
 
2007
  DBUG_PRINT("info", ("query: %s", command->query));
1973
2008
  check_command_args(command, command->first_argument, query_get_value_args,
1974
2009
                     sizeof(query_get_value_args)/sizeof(struct command_arg),
1975
2010
                     ',');
1976
2011
 
 
2012
  DBUG_PRINT("info", ("query: %s", ds_query.str));
 
2013
  DBUG_PRINT("info", ("col: %s", ds_col.str));
 
2014
 
1977
2015
  /* Convert row number to int */
1978
 
  row_no= atoi(ds_row.c_str());
1979
 
  
1980
 
  istringstream buff(ds_row);
1981
 
  if ((buff >> row_no).fail())
1982
 
    die("Invalid row number: '%s'", ds_row.c_str());
 
2016
  if (!str2int(ds_row.str, 10, (long) 0, (long) INT_MAX, &row_no))
 
2017
    die("Invalid row number: '%s'", ds_row.str);
 
2018
  DBUG_PRINT("info", ("row: %s, row_no: %ld", ds_row.str, row_no));
 
2019
  dynstr_free(&ds_row);
1983
2020
 
1984
2021
  /* Remove any surrounding "'s from the query - if there is any */
1985
 
  // (Don't get me started on this)
1986
 
  char * unstripped_query= strdup(ds_query.c_str());
1987
 
  if (strip_surrounding(unstripped_query, '"', '"'))
1988
 
    die("Mismatched \"'s around query '%s'", ds_query.c_str());
1989
 
  ds_query.clear();
1990
 
  ds_query.append(unstripped_query);
 
2022
  if (strip_surrounding(ds_query.str, '"', '"'))
 
2023
    die("Mismatched \"'s around query '%s'", ds_query.str);
1991
2024
 
1992
2025
  /* Run the query */
1993
 
  if (drizzle_query(con, &res, ds_query.c_str(), ds_query.length(),
1994
 
                    &ret) == NULL ||
1995
 
      ret != DRIZZLE_RETURN_OK)
1996
 
  {
1997
 
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
1998
 
    {
1999
 
      die("Error running query '%s': %d %s", ds_query.c_str(),
2000
 
          drizzle_result_error_code(&res), drizzle_result_error(&res));
2001
 
      drizzle_result_free(&res);
2002
 
    }
2003
 
    else
2004
 
    {
2005
 
      die("Error running query '%s': %d %s", ds_query.c_str(), ret,
2006
 
          drizzle_con_error(con));
2007
 
    }
2008
 
  }
2009
 
  if (drizzle_result_column_count(&res) == 0 ||
2010
 
      drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)
2011
 
    die("Query '%s' didn't return a result set", ds_query.c_str());
 
2026
  if (mysql_real_query(mysql, ds_query.str, ds_query.length))
 
2027
    die("Error running query '%s': %d %s", ds_query.str,
 
2028
        mysql_errno(mysql), mysql_error(mysql));
 
2029
  if (!(res= mysql_store_result(mysql)))
 
2030
    die("Query '%s' didn't return a result set", ds_query.str);
2012
2031
 
2013
2032
  {
2014
2033
    /* Find column number from the given column name */
2015
 
    uint32_t i;
2016
 
    uint32_t num_fields= drizzle_result_column_count(&res);
2017
 
    drizzle_column_st *column;
 
2034
    uint i;
 
2035
    uint num_fields= mysql_num_fields(res);
 
2036
    MYSQL_FIELD *fields= mysql_fetch_fields(res);
2018
2037
 
2019
2038
    for (i= 0; i < num_fields; i++)
2020
2039
    {
2021
 
      column= drizzle_column_next(&res);
2022
 
      if (strcmp(drizzle_column_name(column), ds_col.c_str()) == 0 &&
2023
 
          strlen(drizzle_column_name(column)) == ds_col.length())
 
2040
      if (strcmp(fields[i].name, ds_col.str) == 0 &&
 
2041
          strlen(fields[i].name) == ds_col.length)
2024
2042
      {
2025
2043
        col_no= i;
2026
2044
        break;
2028
2046
    }
2029
2047
    if (col_no == -1)
2030
2048
    {
2031
 
      drizzle_result_free(&res);
 
2049
      mysql_free_result(res);
2032
2050
      die("Could not find column '%s' in the result of '%s'",
2033
 
          ds_col.c_str(), ds_query.c_str());
 
2051
          ds_col.str, ds_query.str);
2034
2052
    }
 
2053
    DBUG_PRINT("info", ("Found column %d with name '%s'",
 
2054
                        i, fields[i].name));
2035
2055
  }
 
2056
  dynstr_free(&ds_col);
2036
2057
 
2037
2058
  {
2038
2059
    /* Get the value */
2039
 
    drizzle_row_t row;
 
2060
    MYSQL_ROW row;
2040
2061
    long rows= 0;
2041
2062
    const char* value= "No such row";
2042
2063
 
2043
 
    while ((row= drizzle_row_next(&res)))
 
2064
    while ((row= mysql_fetch_row(res)))
2044
2065
    {
2045
2066
      if (++rows == row_no)
2046
2067
      {
2047
2068
 
 
2069
        DBUG_PRINT("info", ("At row %ld, column %d is '%s'",
 
2070
                            row_no, col_no, row[col_no]));
2048
2071
        /* Found the row to get */
2049
2072
        if (row[col_no])
2050
2073
          value= row[col_no];
2056
2079
    }
2057
2080
    eval_expr(var, value, 0);
2058
2081
  }
2059
 
  drizzle_result_free(&res);
 
2082
  dynstr_free(&ds_query);
 
2083
  mysql_free_result(res);
2060
2084
 
2061
 
  return;
 
2085
  DBUG_VOID_RETURN;
2062
2086
}
2063
2087
 
2064
2088
 
2065
 
static void var_copy(VAR *dest, VAR *src)
 
2089
void var_copy(VAR *dest, VAR *src)
2066
2090
{
2067
2091
  dest->int_val= src->int_val;
2068
2092
  dest->int_dirty= src->int_dirty;
2069
2093
 
2070
2094
  /* Alloc/realloc data for str_val in dest */
2071
 
  if (dest->alloced_len < src->alloced_len)
2072
 
  {
2073
 
    char *tmpptr= (char *)realloc(dest->str_val, src->alloced_len);
2074
 
    if (tmpptr == NULL)
2075
 
      die("Out of memory");
2076
 
    dest->str_val= tmpptr;
2077
 
  }
 
2095
  if (dest->alloced_len < src->alloced_len &&
 
2096
      !(dest->str_val= dest->str_val
 
2097
        ? my_realloc(dest->str_val, src->alloced_len, MYF(MY_WME))
 
2098
        : my_malloc(src->alloced_len, MYF(MY_WME))))
 
2099
    die("Out of memory");
2078
2100
  else
2079
2101
    dest->alloced_len= src->alloced_len;
2080
2102
 
2087
2109
 
2088
2110
void eval_expr(VAR *v, const char *p, const char **p_end)
2089
2111
{
 
2112
 
 
2113
  DBUG_ENTER("eval_expr");
 
2114
  DBUG_PRINT("enter", ("p: '%s'", p));
 
2115
 
2090
2116
  if (*p == '$')
2091
2117
  {
2092
2118
    VAR *vp;
2093
2119
    if ((vp= var_get(p, p_end, 0, 0)))
2094
2120
      var_copy(v, vp);
2095
 
    return;
 
2121
    DBUG_VOID_RETURN;
2096
2122
  }
2097
2123
 
2098
2124
  if (*p == '`')
2099
2125
  {
2100
2126
    var_query_set(v, p, p_end);
2101
 
    return;
 
2127
    DBUG_VOID_RETURN;
2102
2128
  }
2103
2129
 
2104
2130
  {
2107
2133
    const size_t len= strlen(get_value_str);
2108
2134
    if (strncmp(p, get_value_str, len)==0)
2109
2135
    {
2110
 
      st_command command;
 
2136
      struct st_command command;
 
2137
      memset(&command, 0, sizeof(command));
2111
2138
      command.query= (char*)p;
2112
2139
      command.first_word_len= len;
2113
2140
      command.first_argument= command.query + len;
2114
2141
      command.end= (char*)*p_end;
2115
2142
      var_set_query_get_value(&command, v);
2116
 
      return;
 
2143
      DBUG_VOID_RETURN;
2117
2144
    }
2118
2145
  }
2119
2146
 
2125
2152
      static int MIN_VAR_ALLOC= 32;
2126
2153
      v->alloced_len = (new_val_len < MIN_VAR_ALLOC - 1) ?
2127
2154
        MIN_VAR_ALLOC : new_val_len + 1;
2128
 
      char *tmpptr= (char *)realloc(v->str_val, v->alloced_len+1);
2129
 
      if (tmpptr == NULL)
 
2155
      if (!(v->str_val =
 
2156
            v->str_val ? my_realloc(v->str_val, v->alloced_len+1,
 
2157
                                    MYF(MY_WME)) :
 
2158
            my_malloc(v->alloced_len+1, MYF(MY_WME))))
2130
2159
        die("Out of memory");
2131
 
      v->str_val= tmpptr;
2132
2160
    }
2133
2161
    v->str_val_len = new_val_len;
2134
2162
    memcpy(v->str_val, p, new_val_len);
2135
2163
    v->str_val[new_val_len] = 0;
2136
2164
    v->int_val=atoi(p);
 
2165
    DBUG_PRINT("info", ("atoi on '%s', returns: %d", p, v->int_val));
2137
2166
    v->int_dirty=0;
2138
2167
  }
2139
 
  return;
 
2168
  DBUG_VOID_RETURN;
2140
2169
}
2141
2170
 
2142
2171
 
2143
 
static int open_file(const char *name)
 
2172
int open_file(const char *name)
2144
2173
{
2145
2174
  char buff[FN_REFLEN];
2146
 
 
 
2175
  DBUG_ENTER("open_file");
 
2176
  DBUG_PRINT("enter", ("name: %s", name));
2147
2177
  if (!test_if_hard_path(name))
2148
2178
  {
2149
 
    sprintf(buff,"%s%s",opt_basedir,name);
 
2179
    strxmov(buff, opt_basedir, name, NullS);
2150
2180
    name=buff;
2151
2181
  }
2152
2182
  fn_format(buff, name, "", "", MY_UNPACK_FILENAME);
2154
2184
  if (cur_file == file_stack_end)
2155
2185
    die("Source directives are nesting too deep");
2156
2186
  cur_file++;
2157
 
  if (!(cur_file->file= fopen(buff, "r")))
 
2187
  if (!(cur_file->file = my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(0))))
2158
2188
  {
2159
2189
    cur_file--;
2160
2190
    die("Could not open '%s' for reading", buff);
2161
2191
  }
2162
 
  if (!(cur_file->file_name= strdup(buff)))
2163
 
    die("Out of memory");
 
2192
  cur_file->file_name= my_strdup(buff, MYF(MY_FAE));
2164
2193
  cur_file->lineno=1;
2165
 
  return(0);
 
2194
  DBUG_RETURN(0);
2166
2195
}
2167
2196
 
2168
2197
 
2171
2200
 
2172
2201
  SYNOPSIS
2173
2202
  do_source()
2174
 
  query  called command
 
2203
  query called command
2175
2204
 
2176
2205
  DESCRIPTION
2177
2206
  source <file_name>
2180
2209
 
2181
2210
*/
2182
2211
 
2183
 
static void do_source(struct st_command *command)
 
2212
void do_source(struct st_command *command)
2184
2213
{
2185
 
  string ds_filename;
 
2214
  static DYNAMIC_STRING ds_filename;
2186
2215
  const struct command_arg source_args[] = {
2187
 
    { "filename", ARG_STRING, true, &ds_filename, "File to source" }
 
2216
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to source" }
2188
2217
  };
2189
 
 
 
2218
  DBUG_ENTER("do_source");
2190
2219
 
2191
2220
  check_command_args(command, command->first_argument, source_args,
2192
2221
                     sizeof(source_args)/sizeof(struct command_arg),
2200
2229
    ; /* Do nothing */
2201
2230
  else
2202
2231
  {
2203
 
    if (opt_testdir != NULL)
2204
 
    {
2205
 
      string testdir(opt_testdir);
2206
 
      if (testdir[testdir.length()] != '/')
2207
 
        testdir.append("/");
2208
 
      testdir.append(ds_filename);
2209
 
      ds_filename.swap(testdir);
2210
 
    }
2211
 
    open_file(ds_filename.c_str());
 
2232
    DBUG_PRINT("info", ("sourcing file: %s", ds_filename.str));
 
2233
    open_file(ds_filename.str);
2212
2234
  }
2213
2235
 
 
2236
  dynstr_free(&ds_filename);
2214
2237
  return;
2215
2238
}
2216
2239
 
2217
2240
 
 
2241
FILE* my_popen(DYNAMIC_STRING *ds_cmd, const char *mode)
 
2242
{
 
2243
  return popen(ds_cmd->str, mode);
 
2244
}
 
2245
 
 
2246
 
2218
2247
static void init_builtin_echo(void)
2219
2248
{
2220
2249
  builtin_echo[0]= 0;
2226
2255
  Replace a substring
2227
2256
 
2228
2257
  SYNOPSIS
2229
 
  replace
2230
 
  ds_str      The string to search and perform the replace in
2231
 
  search_str  The string to search for
2232
 
  search_len  Length of the string to search for
2233
 
  replace_str The string to replace with
2234
 
  replace_len Length of the string to replace with
 
2258
    replace
 
2259
    ds_str      The string to search and perform the replace in
 
2260
    search_str  The string to search for
 
2261
    search_len  Length of the string to search for
 
2262
    replace_str The string to replace with
 
2263
    replace_len Length of the string to replace with
2235
2264
 
2236
2265
  RETURN
2237
 
  0 String replaced
2238
 
  1 Could not find search_str in str
 
2266
    0 String replaced
 
2267
    1 Could not find search_str in str
2239
2268
*/
2240
2269
 
2241
 
static int replace(string *ds_str,
2242
 
                   const char *search_str, uint32_t search_len,
2243
 
                   const char *replace_str, uint32_t replace_len)
 
2270
static int replace(DYNAMIC_STRING *ds_str,
 
2271
                   const char *search_str, ulong search_len,
 
2272
                   const char *replace_str, ulong replace_len)
2244
2273
{
2245
 
  string ds_tmp;
2246
 
  const char *start= strstr(ds_str->c_str(), search_str);
 
2274
  DYNAMIC_STRING ds_tmp;
 
2275
  const char *start= strstr(ds_str->str, search_str);
2247
2276
  if (!start)
2248
2277
    return 1;
2249
 
  ds_tmp.append(ds_str->c_str(), start - ds_str->c_str());
2250
 
  ds_tmp.append(replace_str, replace_len);
2251
 
  ds_tmp.append(start + search_len);
2252
 
  *ds_str= ds_tmp;
 
2278
  init_dynamic_string(&ds_tmp, "",
 
2279
                      ds_str->length + replace_len, 256);
 
2280
  dynstr_append_mem(&ds_tmp, ds_str->str, start - ds_str->str);
 
2281
  dynstr_append_mem(&ds_tmp, replace_str, replace_len);
 
2282
  dynstr_append(&ds_tmp, start + search_len);
 
2283
  dynstr_set(ds_str, ds_tmp.str);
 
2284
  dynstr_free(&ds_tmp);
2253
2285
  return 0;
2254
2286
}
2255
2287
 
2259
2291
 
2260
2292
  SYNOPSIS
2261
2293
  do_exec()
2262
 
  query  called command
 
2294
  query called command
2263
2295
 
2264
2296
  DESCRIPTION
2265
2297
  exec <command>
2270
2302
  It can thus be used to execute a command that shall fail.
2271
2303
 
2272
2304
  NOTE
2273
 
  Although drizzletest is executed from cygwin shell, the command will be
 
2305
  Although mysqltest is executed from cygwin shell, the command will be
2274
2306
  executed in "cmd.exe". Thus commands like "rm" etc can NOT be used, use
2275
 
  drizzletest commmand(s) like "remove_file" for that
 
2307
  mysqltest commmand(s) like "remove_file" for that
2276
2308
*/
2277
2309
 
2278
 
static void do_exec(struct st_command *command)
 
2310
void do_exec(struct st_command *command)
2279
2311
{
2280
2312
  int error;
2281
2313
  char buf[512];
2282
2314
  FILE *res_file;
2283
2315
  char *cmd= command->first_argument;
2284
 
  string ds_cmd;
 
2316
  DYNAMIC_STRING ds_cmd;
 
2317
  DBUG_ENTER("do_exec");
 
2318
  DBUG_PRINT("enter", ("cmd: '%s'", cmd));
2285
2319
 
2286
2320
  /* Skip leading space */
2287
2321
  while (*cmd && my_isspace(charset_info, *cmd))
2290
2324
    die("Missing argument in exec");
2291
2325
  command->last_argument= command->end;
2292
2326
 
 
2327
  init_dynamic_string(&ds_cmd, 0, command->query_len+256, 256);
2293
2328
  /* Eval the command, thus replacing all environment variables */
2294
2329
  do_eval(&ds_cmd, cmd, command->end, !is_windows);
2295
2330
 
2300
2335
    replace(&ds_cmd, "echo", 4, builtin_echo, strlen(builtin_echo));
2301
2336
  }
2302
2337
 
2303
 
  if (!(res_file= popen(ds_cmd.c_str(), "r")) && command->abort_on_error)
 
2338
  DBUG_PRINT("info", ("Executing '%s' as '%s'",
 
2339
                      command->first_argument, ds_cmd.str));
 
2340
 
 
2341
  if (!(res_file= my_popen(&ds_cmd, "r")) && command->abort_on_error)
2304
2342
  {
 
2343
    dynstr_free(&ds_cmd);
2305
2344
    die("popen(\"%s\", \"r\") failed", command->first_argument);
2306
2345
  }
2307
2346
 
2310
2349
    if (disable_result_log)
2311
2350
    {
2312
2351
      buf[strlen(buf)-1]=0;
 
2352
      DBUG_PRINT("exec_result",("%s", buf));
2313
2353
    }
2314
2354
    else
2315
2355
    {
2316
 
      replace_append(&ds_res, buf);
 
2356
      replace_dynstr_append(&ds_res, buf);
2317
2357
    }
2318
2358
  }
2319
2359
  error= pclose(res_file);
2320
2360
  if (error > 0)
2321
2361
  {
2322
 
    uint32_t status= WEXITSTATUS(error), i;
2323
 
    bool ok= 0;
 
2362
    uint status= WEXITSTATUS(error), i;
 
2363
    my_bool ok= 0;
2324
2364
 
2325
2365
    if (command->abort_on_error)
2326
2366
    {
2327
2367
      log_msg("exec of '%s' failed, error: %d, status: %d, errno: %d",
2328
 
              ds_cmd.c_str(), error, status, errno);
 
2368
              ds_cmd.str, error, status, errno);
 
2369
      dynstr_free(&ds_cmd);
2329
2370
      die("command \"%s\" failed", command->first_argument);
2330
2371
    }
2331
2372
 
 
2373
    DBUG_PRINT("info",
 
2374
               ("error: %d, status: %d", error, status));
2332
2375
    for (i= 0; i < command->expected_errors.count; i++)
2333
2376
    {
 
2377
      DBUG_PRINT("info", ("expected error: %d",
 
2378
                          command->expected_errors.err[i].code.errnum));
2334
2379
      if ((command->expected_errors.err[i].type == ERR_ERRNO) &&
2335
2380
          (command->expected_errors.err[i].code.errnum == status))
2336
2381
      {
2337
2382
        ok= 1;
 
2383
        DBUG_PRINT("info", ("command \"%s\" failed with expected error: %d",
 
2384
                            command->first_argument, status));
2338
2385
      }
2339
2386
    }
2340
2387
    if (!ok)
2341
2388
    {
 
2389
      dynstr_free(&ds_cmd);
2342
2390
      die("command \"%s\" failed with wrong error: %d",
2343
2391
          command->first_argument, status);
2344
2392
    }
2348
2396
  {
2349
2397
    /* Error code we wanted was != 0, i.e. not an expected success */
2350
2398
    log_msg("exec of '%s failed, error: %d, errno: %d",
2351
 
            ds_cmd.c_str(), error, errno);
 
2399
            ds_cmd.str, error, errno);
 
2400
    dynstr_free(&ds_cmd);
2352
2401
    die("command \"%s\" succeeded - should have failed with errno %d...",
2353
2402
        command->first_argument, command->expected_errors.err[0].code.errnum);
2354
2403
  }
2355
2404
 
2356
 
  return;
 
2405
  dynstr_free(&ds_cmd);
 
2406
  DBUG_VOID_RETURN;
2357
2407
}
2358
2408
 
2359
2409
enum enum_operator
2368
2418
 
2369
2419
  SYNOPSIS
2370
2420
  do_modify_var()
2371
 
  query  called command
 
2421
  query called command
2372
2422
  operator    operation to perform on the var
2373
2423
 
2374
2424
  DESCRIPTION
2377
2427
 
2378
2428
*/
2379
2429
 
2380
 
static int do_modify_var(struct st_command *command,
2381
 
                         enum enum_operator op)
 
2430
int do_modify_var(struct st_command *command,
 
2431
                  enum enum_operator operator)
2382
2432
{
2383
2433
  const char *p= command->first_argument;
2384
2434
  VAR* v;
2388
2438
    die("The argument to %.*s must be a variable (start with $)",
2389
2439
        command->first_word_len, command->query);
2390
2440
  v= var_get(p, &p, 1, 0);
2391
 
  switch (op) {
 
2441
  switch (operator) {
2392
2442
  case DO_DEC:
2393
2443
    v->int_val--;
2394
2444
    break;
2406
2456
 
2407
2457
 
2408
2458
/*
 
2459
  Wrapper for 'system' function
 
2460
 
 
2461
  NOTE
 
2462
  If mysqltest is executed from cygwin shell, the command will be
 
2463
  executed in the "windows command interpreter" cmd.exe and we prepend "sh"
 
2464
  to make it be executed by cygwins "bash". Thus commands like "rm",
 
2465
  "mkdir" as well as shellscripts can executed by "system" in Windows.
 
2466
 
 
2467
*/
 
2468
 
 
2469
int my_system(DYNAMIC_STRING* ds_cmd)
 
2470
{
 
2471
  return system(ds_cmd->str);
 
2472
}
 
2473
 
 
2474
 
 
2475
/*
2409
2476
  SYNOPSIS
2410
2477
  do_system
2411
 
  command  called command
 
2478
  command       called command
2412
2479
 
2413
2480
  DESCRIPTION
2414
2481
  system <command>
2418
2485
 
2419
2486
*/
2420
2487
 
2421
 
static void do_system(struct st_command *command)
 
2488
void do_system(struct st_command *command)
2422
2489
{
2423
 
  string ds_cmd;
2424
 
 
 
2490
  DYNAMIC_STRING ds_cmd;
 
2491
  DBUG_ENTER("do_system");
2425
2492
 
2426
2493
  if (strlen(command->first_argument) == 0)
2427
2494
    die("Missing arguments to system, nothing to do!");
2428
2495
 
 
2496
  init_dynamic_string(&ds_cmd, 0, command->query_len + 64, 256);
 
2497
 
2429
2498
  /* Eval the system command, thus replacing all environment variables */
2430
2499
  do_eval(&ds_cmd, command->first_argument, command->end, !is_windows);
2431
2500
 
2432
 
  if (system(ds_cmd.c_str()))
 
2501
  DBUG_PRINT("info", ("running system command '%s' as '%s'",
 
2502
                      command->first_argument, ds_cmd.str));
 
2503
  if (my_system(&ds_cmd))
2433
2504
  {
2434
2505
    if (command->abort_on_error)
2435
2506
      die("system command '%s' failed", command->first_argument);
2436
2507
 
2437
2508
    /* If ! abort_on_error, log message and continue */
2438
 
    ds_res.append("system command '");
2439
 
    replace_append(&ds_res, command->first_argument);
2440
 
    ds_res.append("' failed\n");
 
2509
    dynstr_append(&ds_res, "system command '");
 
2510
    replace_dynstr_append(&ds_res, command->first_argument);
 
2511
    dynstr_append(&ds_res, "' failed\n");
2441
2512
  }
2442
2513
 
2443
2514
  command->last_argument= command->end;
2444
 
  return;
 
2515
  dynstr_free(&ds_cmd);
 
2516
  DBUG_VOID_RETURN;
2445
2517
}
2446
2518
 
2447
2519
 
2448
2520
/*
2449
2521
  SYNOPSIS
2450
2522
  do_remove_file
2451
 
  command  called command
 
2523
  command       called command
2452
2524
 
2453
2525
  DESCRIPTION
2454
2526
  remove_file <file_name>
2455
2527
  Remove the file <file_name>
2456
2528
*/
2457
2529
 
2458
 
static void do_remove_file(struct st_command *command)
 
2530
void do_remove_file(struct st_command *command)
2459
2531
{
2460
2532
  int error;
2461
 
  string ds_filename;
 
2533
  static DYNAMIC_STRING ds_filename;
2462
2534
  const struct command_arg rm_args[] = {
2463
 
    { "filename", ARG_STRING, true, &ds_filename, "File to delete" }
 
2535
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to delete" }
2464
2536
  };
2465
 
 
 
2537
  DBUG_ENTER("do_remove_file");
2466
2538
 
2467
2539
  check_command_args(command, command->first_argument,
2468
2540
                     rm_args, sizeof(rm_args)/sizeof(struct command_arg),
2469
2541
                     ' ');
2470
2542
 
2471
 
  error= my_delete(ds_filename.c_str(), MYF(0)) != 0;
 
2543
  DBUG_PRINT("info", ("removing file: %s", ds_filename.str));
 
2544
  error= my_delete(ds_filename.str, MYF(0)) != 0;
2472
2545
  handle_command_error(command, error);
2473
 
  return;
 
2546
  dynstr_free(&ds_filename);
 
2547
  DBUG_VOID_RETURN;
2474
2548
}
2475
2549
 
2476
2550
 
2477
2551
/*
2478
2552
  SYNOPSIS
2479
2553
  do_copy_file
2480
 
  command  command handle
 
2554
  command       command handle
2481
2555
 
2482
2556
  DESCRIPTION
2483
2557
  copy_file <from_file> <to_file>
2486
2560
  NOTE! Will fail if <to_file> exists
2487
2561
*/
2488
2562
 
2489
 
static void do_copy_file(struct st_command *command)
 
2563
void do_copy_file(struct st_command *command)
2490
2564
{
2491
2565
  int error;
2492
 
  string ds_from_file;
2493
 
  string ds_to_file;
 
2566
  static DYNAMIC_STRING ds_from_file;
 
2567
  static DYNAMIC_STRING ds_to_file;
2494
2568
  const struct command_arg copy_file_args[] = {
2495
 
    { "from_file", ARG_STRING, true, &ds_from_file, "Filename to copy from" },
2496
 
    { "to_file", ARG_STRING, true, &ds_to_file, "Filename to copy to" }
 
2569
    { "from_file", ARG_STRING, TRUE, &ds_from_file, "Filename to copy from" },
 
2570
    { "to_file", ARG_STRING, TRUE, &ds_to_file, "Filename to copy to" }
2497
2571
  };
2498
 
 
 
2572
  DBUG_ENTER("do_copy_file");
2499
2573
 
2500
2574
  check_command_args(command, command->first_argument,
2501
2575
                     copy_file_args,
2502
2576
                     sizeof(copy_file_args)/sizeof(struct command_arg),
2503
2577
                     ' ');
2504
2578
 
2505
 
  error= (my_copy(ds_from_file.c_str(), ds_to_file.c_str(),
 
2579
  DBUG_PRINT("info", ("Copy %s to %s", ds_from_file.str, ds_to_file.str));
 
2580
  error= (my_copy(ds_from_file.str, ds_to_file.str,
2506
2581
                  MYF(MY_DONT_OVERWRITE_FILE)) != 0);
2507
2582
  handle_command_error(command, error);
2508
 
  return;
 
2583
  dynstr_free(&ds_from_file);
 
2584
  dynstr_free(&ds_to_file);
 
2585
  DBUG_VOID_RETURN;
2509
2586
}
2510
2587
 
2511
2588
 
2512
2589
/*
2513
2590
  SYNOPSIS
2514
2591
  do_chmod_file
2515
 
  command  command handle
 
2592
  command       command handle
2516
2593
 
2517
2594
  DESCRIPTION
2518
2595
  chmod <octal> <file_name>
2520
2597
 
2521
2598
*/
2522
2599
 
2523
 
static void do_chmod_file(struct st_command *command)
 
2600
void do_chmod_file(struct st_command *command)
2524
2601
{
2525
2602
  long mode= 0;
2526
 
  string ds_mode;
2527
 
  string ds_file;
 
2603
  static DYNAMIC_STRING ds_mode;
 
2604
  static DYNAMIC_STRING ds_file;
2528
2605
  const struct command_arg chmod_file_args[] = {
2529
 
    { "mode", ARG_STRING, true, &ds_mode, "Mode of file(octal) ex. 0660"},
2530
 
    { "filename", ARG_STRING, true, &ds_file, "Filename of file to modify" }
 
2606
    { "mode", ARG_STRING, TRUE, &ds_mode, "Mode of file(octal) ex. 0660"}, 
 
2607
    { "filename", ARG_STRING, TRUE, &ds_file, "Filename of file to modify" }
2531
2608
  };
2532
 
 
 
2609
  DBUG_ENTER("do_chmod_file");
2533
2610
 
2534
2611
  check_command_args(command, command->first_argument,
2535
2612
                     chmod_file_args,
2537
2614
                     ' ');
2538
2615
 
2539
2616
  /* Parse what mode to set */
2540
 
  istringstream buff(ds_mode);
2541
 
  if (ds_mode.length() != 4 ||
2542
 
      (buff >> oct >> mode).fail())
 
2617
  if (ds_mode.length != 4 ||
 
2618
      str2int(ds_mode.str, 8, 0, INT_MAX, &mode) == NullS)
2543
2619
    die("You must write a 4 digit octal number for mode");
2544
2620
 
2545
 
  handle_command_error(command, chmod(ds_file.c_str(), mode));
2546
 
  return;
 
2621
  DBUG_PRINT("info", ("chmod %o %s", (uint)mode, ds_file.str));
 
2622
  handle_command_error(command, chmod(ds_file.str, mode));
 
2623
  dynstr_free(&ds_mode);
 
2624
  dynstr_free(&ds_file);
 
2625
  DBUG_VOID_RETURN;
2547
2626
}
2548
2627
 
2549
2628
 
2550
2629
/*
2551
2630
  SYNOPSIS
2552
2631
  do_file_exists
2553
 
  command  called command
 
2632
  command       called command
2554
2633
 
2555
2634
  DESCRIPTION
2556
2635
  fiile_exist <file_name>
2557
2636
  Check if file <file_name> exists
2558
2637
*/
2559
2638
 
2560
 
static void do_file_exist(struct st_command *command)
 
2639
void do_file_exist(struct st_command *command)
2561
2640
{
2562
2641
  int error;
2563
 
  string ds_filename;
 
2642
  static DYNAMIC_STRING ds_filename;
2564
2643
  const struct command_arg file_exist_args[] = {
2565
 
    { "filename", ARG_STRING, true, &ds_filename, "File to check if it exist" }
 
2644
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to check if it exist" }
2566
2645
  };
2567
 
 
 
2646
  DBUG_ENTER("do_file_exist");
2568
2647
 
2569
2648
  check_command_args(command, command->first_argument,
2570
2649
                     file_exist_args,
2571
2650
                     sizeof(file_exist_args)/sizeof(struct command_arg),
2572
2651
                     ' ');
2573
2652
 
2574
 
  error= (access(ds_filename.c_str(), F_OK) != 0);
 
2653
  DBUG_PRINT("info", ("Checking for existence of file: %s", ds_filename.str));
 
2654
  error= (access(ds_filename.str, F_OK) != 0);
2575
2655
  handle_command_error(command, error);
2576
 
  return;
 
2656
  dynstr_free(&ds_filename);
 
2657
  DBUG_VOID_RETURN;
2577
2658
}
2578
2659
 
2579
2660
 
2580
2661
/*
2581
2662
  SYNOPSIS
2582
2663
  do_mkdir
2583
 
  command  called command
 
2664
  command       called command
2584
2665
 
2585
2666
  DESCRIPTION
2586
2667
  mkdir <dir_name>
2587
2668
  Create the directory <dir_name>
2588
2669
*/
2589
2670
 
2590
 
static void do_mkdir(struct st_command *command)
 
2671
void do_mkdir(struct st_command *command)
2591
2672
{
2592
 
  string ds_dirname;
2593
2673
  int error;
 
2674
  static DYNAMIC_STRING ds_dirname;
2594
2675
  const struct command_arg mkdir_args[] = {
2595
 
    {"dirname", ARG_STRING, true, &ds_dirname, "Directory to create"}
 
2676
    "dirname", ARG_STRING, TRUE, &ds_dirname, "Directory to create"
2596
2677
  };
2597
 
 
 
2678
  DBUG_ENTER("do_mkdir");
2598
2679
 
2599
2680
  check_command_args(command, command->first_argument,
2600
2681
                     mkdir_args, sizeof(mkdir_args)/sizeof(struct command_arg),
2601
2682
                     ' ');
2602
2683
 
2603
 
  error= mkdir(ds_dirname.c_str(), (0777 & my_umask_dir)) != 0;
 
2684
  DBUG_PRINT("info", ("creating directory: %s", ds_dirname.str));
 
2685
  error= my_mkdir(ds_dirname.str, 0777, MYF(0)) != 0;
2604
2686
  handle_command_error(command, error);
2605
 
  return;
 
2687
  dynstr_free(&ds_dirname);
 
2688
  DBUG_VOID_RETURN;
2606
2689
}
2607
2690
 
2608
2691
/*
2609
2692
  SYNOPSIS
2610
2693
  do_rmdir
2611
 
  command  called command
 
2694
  command       called command
2612
2695
 
2613
2696
  DESCRIPTION
2614
2697
  rmdir <dir_name>
2615
2698
  Remove the empty directory <dir_name>
2616
2699
*/
2617
2700
 
2618
 
static void do_rmdir(struct st_command *command)
 
2701
void do_rmdir(struct st_command *command)
2619
2702
{
2620
2703
  int error;
2621
 
  string ds_dirname;
 
2704
  static DYNAMIC_STRING ds_dirname;
2622
2705
  const struct command_arg rmdir_args[] = {
2623
 
    {"dirname", ARG_STRING, true, &ds_dirname, "Directory to remove"}
 
2706
    "dirname", ARG_STRING, TRUE, &ds_dirname, "Directory to remove"
2624
2707
  };
2625
 
 
 
2708
  DBUG_ENTER("do_rmdir");
2626
2709
 
2627
2710
  check_command_args(command, command->first_argument,
2628
2711
                     rmdir_args, sizeof(rmdir_args)/sizeof(struct command_arg),
2629
2712
                     ' ');
2630
2713
 
2631
 
  error= rmdir(ds_dirname.c_str()) != 0;
 
2714
  DBUG_PRINT("info", ("removing directory: %s", ds_dirname.str));
 
2715
  error= rmdir(ds_dirname.str) != 0;
2632
2716
  handle_command_error(command, error);
2633
 
  return;
 
2717
  dynstr_free(&ds_dirname);
 
2718
  DBUG_VOID_RETURN;
2634
2719
}
2635
2720
 
2636
2721
 
2644
2729
  happen for any tests in the test suite.
2645
2730
*/
2646
2731
 
2647
 
static int my_getc(FILE *file)
 
2732
int my_getc(FILE *file)
2648
2733
{
2649
2734
  if (line_buffer_pos == line_buffer)
2650
2735
    return fgetc(file);
2652
2737
}
2653
2738
 
2654
2739
 
2655
 
static void my_ungetc(int c)
 
2740
void my_ungetc(int c)
2656
2741
{
2657
2742
  *line_buffer_pos++= (char) c;
2658
2743
}
2659
2744
 
2660
2745
 
2661
 
static void read_until_delimiter(string *ds,
2662
 
                                 string *ds_delimiter)
 
2746
void read_until_delimiter(DYNAMIC_STRING *ds,
 
2747
                          DYNAMIC_STRING *ds_delimiter)
2663
2748
{
2664
2749
  char c;
 
2750
  DBUG_ENTER("read_until_delimiter");
 
2751
  DBUG_PRINT("enter", ("delimiter: %s, length: %u",
 
2752
                       ds_delimiter->str, (uint) ds_delimiter->length));
2665
2753
 
2666
 
  if (ds_delimiter->length() > MAX_DELIMITER_LENGTH)
 
2754
  if (ds_delimiter->length > MAX_DELIMITER_LENGTH)
2667
2755
    die("Max delimiter length(%d) exceeded", MAX_DELIMITER_LENGTH);
2668
2756
 
2669
2757
  /* Read from file until delimiter is found */
2690
2778
 
2691
2779
    if (feof(cur_file->file))
2692
2780
      die("End of file encountered before '%s' delimiter was found",
2693
 
          ds_delimiter->c_str());
 
2781
          ds_delimiter->str);
2694
2782
 
2695
 
    if (match_delimiter(c, ds_delimiter->c_str(), ds_delimiter->length()))
 
2783
    if (match_delimiter(c, ds_delimiter->str, ds_delimiter->length))
 
2784
    {
 
2785
      DBUG_PRINT("exit", ("Found delimiter '%s'", ds_delimiter->str));
2696
2786
      break;
2697
 
 
2698
 
    ds->push_back(c);
 
2787
    }
 
2788
    dynstr_append_mem(ds, (const char*)&c, 1);
2699
2789
  }
2700
 
  return;
 
2790
  DBUG_PRINT("exit", ("ds: %s", ds->str));
 
2791
  DBUG_VOID_RETURN;
2701
2792
}
2702
2793
 
2703
2794
 
2704
 
static void do_write_file_command(struct st_command *command, bool append)
 
2795
void do_write_file_command(struct st_command *command, my_bool append)
2705
2796
{
2706
 
  string ds_content;
2707
 
  string ds_filename;
2708
 
  string ds_delimiter;
 
2797
  static DYNAMIC_STRING ds_content;
 
2798
  static DYNAMIC_STRING ds_filename;
 
2799
  static DYNAMIC_STRING ds_delimiter;
2709
2800
  const struct command_arg write_file_args[] = {
2710
 
    { "filename", ARG_STRING, true, &ds_filename, "File to write to" },
2711
 
    { "delimiter", ARG_STRING, false, &ds_delimiter, "Delimiter to read until" }
 
2801
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to write to" },
 
2802
    { "delimiter", ARG_STRING, FALSE, &ds_delimiter, "Delimiter to read until" }
2712
2803
  };
2713
 
 
 
2804
  DBUG_ENTER("do_write_file");
2714
2805
 
2715
2806
  check_command_args(command,
2716
2807
                     command->first_argument,
2719
2810
                     ' ');
2720
2811
 
2721
2812
  /* If no delimiter was provided, use EOF */
2722
 
  if (ds_delimiter.length() == 0)
2723
 
    ds_delimiter.append("EOF");
 
2813
  if (ds_delimiter.length == 0)
 
2814
    dynstr_set(&ds_delimiter, "EOF");
2724
2815
 
2725
 
  if (!append && access(ds_filename.c_str(), F_OK) == 0)
 
2816
  if (!append && access(ds_filename.str, F_OK) == 0)
2726
2817
  {
2727
2818
    /* The file should not be overwritten */
2728
 
    die("File already exist: '%s'", ds_filename.c_str());
 
2819
    die("File already exist: '%s'", ds_filename.str);
2729
2820
  }
2730
2821
 
 
2822
  init_dynamic_string(&ds_content, "", 1024, 1024);
2731
2823
  read_until_delimiter(&ds_content, &ds_delimiter);
2732
 
  str_to_file2(ds_filename.c_str(), ds_content.c_str(),
2733
 
               ds_content.length(), append);
2734
 
  return;
 
2824
  DBUG_PRINT("info", ("Writing to file: %s", ds_filename.str));
 
2825
  str_to_file2(ds_filename.str, ds_content.str, ds_content.length, append);
 
2826
  dynstr_free(&ds_content);
 
2827
  dynstr_free(&ds_filename);
 
2828
  dynstr_free(&ds_delimiter);
 
2829
  DBUG_VOID_RETURN;
2735
2830
}
2736
2831
 
2737
2832
 
2738
2833
/*
2739
2834
  SYNOPSIS
2740
2835
  do_write_file
2741
 
  command  called command
 
2836
  command       called command
2742
2837
 
2743
2838
  DESCRIPTION
2744
2839
  write_file <file_name> [<delimiter>];
2762
2857
 
2763
2858
*/
2764
2859
 
2765
 
static void do_write_file(struct st_command *command)
 
2860
void do_write_file(struct st_command *command)
2766
2861
{
2767
 
  do_write_file_command(command, false);
 
2862
  do_write_file_command(command, FALSE);
2768
2863
}
2769
2864
 
2770
2865
 
2771
2866
/*
2772
2867
  SYNOPSIS
2773
2868
  do_append_file
2774
 
  command  called command
 
2869
  command       called command
2775
2870
 
2776
2871
  DESCRIPTION
2777
2872
  append_file <file_name> [<delimiter>];
2793
2888
 
2794
2889
*/
2795
2890
 
2796
 
static void do_append_file(struct st_command *command)
 
2891
void do_append_file(struct st_command *command)
2797
2892
{
2798
 
  do_write_file_command(command, true);
 
2893
  do_write_file_command(command, TRUE);
2799
2894
}
2800
2895
 
2801
2896
 
2802
2897
/*
2803
2898
  SYNOPSIS
2804
2899
  do_cat_file
2805
 
  command  called command
 
2900
  command       called command
2806
2901
 
2807
2902
  DESCRIPTION
2808
2903
  cat_file <file_name>;
2811
2906
 
2812
2907
*/
2813
2908
 
2814
 
static void do_cat_file(struct st_command *command)
 
2909
void do_cat_file(struct st_command *command)
2815
2910
{
2816
 
  static string ds_filename;
 
2911
  static DYNAMIC_STRING ds_filename;
2817
2912
  const struct command_arg cat_file_args[] = {
2818
 
    { "filename", ARG_STRING, true, &ds_filename, "File to read from" }
 
2913
    { "filename", ARG_STRING, TRUE, &ds_filename, "File to read from" }
2819
2914
  };
2820
 
 
 
2915
  DBUG_ENTER("do_cat_file");
2821
2916
 
2822
2917
  check_command_args(command,
2823
2918
                     command->first_argument,
2825
2920
                     sizeof(cat_file_args)/sizeof(struct command_arg),
2826
2921
                     ' ');
2827
2922
 
2828
 
  cat_file(&ds_res, ds_filename.c_str());
2829
 
 
2830
 
  return;
 
2923
  DBUG_PRINT("info", ("Reading from, file: %s", ds_filename.str));
 
2924
 
 
2925
  cat_file(&ds_res, ds_filename.str);
 
2926
 
 
2927
  dynstr_free(&ds_filename);
 
2928
  DBUG_VOID_RETURN;
2831
2929
}
2832
2930
 
2833
2931
 
2834
2932
/*
2835
2933
  SYNOPSIS
2836
2934
  do_diff_files
2837
 
  command  called command
 
2935
  command       called command
2838
2936
 
2839
2937
  DESCRIPTION
2840
2938
  diff_files <file1> <file2>;
2843
2941
 
2844
2942
*/
2845
2943
 
2846
 
static void do_diff_files(struct st_command *command)
 
2944
void do_diff_files(struct st_command *command)
2847
2945
{
2848
2946
  int error= 0;
2849
 
  string ds_filename;
2850
 
  string ds_filename2;
 
2947
  static DYNAMIC_STRING ds_filename;
 
2948
  static DYNAMIC_STRING ds_filename2;
2851
2949
  const struct command_arg diff_file_args[] = {
2852
 
    { "file1", ARG_STRING, true, &ds_filename, "First file to diff" },
2853
 
    { "file2", ARG_STRING, true, &ds_filename2, "Second file to diff" }
 
2950
    { "file1", ARG_STRING, TRUE, &ds_filename, "First file to diff" },
 
2951
    { "file2", ARG_STRING, TRUE, &ds_filename2, "Second file to diff" }
2854
2952
  };
2855
 
 
 
2953
  DBUG_ENTER("do_diff_files");
2856
2954
 
2857
2955
  check_command_args(command,
2858
2956
                     command->first_argument,
2860
2958
                     sizeof(diff_file_args)/sizeof(struct command_arg),
2861
2959
                     ' ');
2862
2960
 
2863
 
  if ((error= compare_files(ds_filename.c_str(), ds_filename2.c_str())))
 
2961
  if ((error= compare_files(ds_filename.str, ds_filename2.str)))
2864
2962
  {
2865
2963
    /* Compare of the two files failed, append them to output
2866
2964
       so the failure can be analyzed
2867
2965
    */
2868
 
    show_diff(&ds_res, ds_filename.c_str(), ds_filename2.c_str());
 
2966
    show_diff(&ds_res, ds_filename.str, ds_filename2.str);
2869
2967
  }
2870
2968
 
 
2969
  dynstr_free(&ds_filename);
 
2970
  dynstr_free(&ds_filename2);
2871
2971
  handle_command_error(command, error);
2872
 
  return;
 
2972
  DBUG_VOID_RETURN;
2873
2973
}
2874
2974
 
2875
2975
 
2876
 
static struct st_connection * find_connection_by_name(const char *name)
 
2976
struct st_connection * find_connection_by_name(const char *name)
2877
2977
{
2878
2978
  struct st_connection *con;
2879
2979
  for (con= connections; con < next_con; con++)
2890
2990
/*
2891
2991
  SYNOPSIS
2892
2992
  do_send_quit
2893
 
  command  called command
 
2993
  command       called command
2894
2994
 
2895
2995
  DESCRIPTION
2896
2996
  Sends a simple quit command to the server for the named connection.
2897
2997
 
2898
2998
*/
2899
2999
 
2900
 
static void do_send_quit(struct st_command *command)
 
3000
void do_send_quit(struct st_command *command)
2901
3001
{
2902
3002
  char *p= command->first_argument, *name;
2903
3003
  struct st_connection *con;
2904
 
  drizzle_result_st result;
2905
 
  drizzle_return_t ret;
 
3004
 
 
3005
  DBUG_ENTER("do_send_quit");
 
3006
  DBUG_PRINT("enter",("name: '%s'",p));
2906
3007
 
2907
3008
  if (!*p)
2908
3009
    die("Missing connection name in send_quit");
2917
3018
  if (!(con= find_connection_by_name(name)))
2918
3019
    die("connection '%s' not found in connection pool", name);
2919
3020
 
2920
 
  if (drizzle_quit(&con->con,&result, &ret))
2921
 
    drizzle_result_free(&result);
 
3021
  simple_command(&con->mysql,COM_QUIT,0,0,1);
2922
3022
 
2923
 
  return;
 
3023
  DBUG_VOID_RETURN;
2924
3024
}
2925
3025
 
2926
3026
 
2940
3040
 
2941
3041
*/
2942
3042
 
2943
 
static void do_change_user(struct st_command *)
 
3043
void do_change_user(struct st_command *command)
2944
3044
{
2945
 
  assert(0);
 
3045
  MYSQL *mysql = &cur_con->mysql;
 
3046
  /* static keyword to make the NetWare compiler happy. */
 
3047
  static DYNAMIC_STRING ds_user, ds_passwd, ds_db;
 
3048
  const struct command_arg change_user_args[] = {
 
3049
    { "user", ARG_STRING, FALSE, &ds_user, "User to connect as" },
 
3050
    { "password", ARG_STRING, FALSE, &ds_passwd, "Password used when connecting" },
 
3051
    { "database", ARG_STRING, FALSE, &ds_db, "Database to select after connect" },
 
3052
  };
 
3053
 
 
3054
  DBUG_ENTER("do_change_user");
 
3055
 
 
3056
  check_command_args(command, command->first_argument,
 
3057
                     change_user_args,
 
3058
                     sizeof(change_user_args)/sizeof(struct command_arg),
 
3059
                     ',');
 
3060
 
 
3061
  if (cur_con->stmt)
 
3062
  {
 
3063
    mysql_stmt_close(cur_con->stmt);
 
3064
    cur_con->stmt= NULL;
 
3065
  }
 
3066
 
 
3067
  if (!ds_user.length)
 
3068
    dynstr_set(&ds_user, mysql->user);
 
3069
 
 
3070
  if (!ds_passwd.length)
 
3071
    dynstr_set(&ds_passwd, mysql->passwd);
 
3072
 
 
3073
  if (!ds_db.length)
 
3074
    dynstr_set(&ds_db, mysql->db);
 
3075
 
 
3076
  DBUG_PRINT("info",("connection: '%s' user: '%s' password: '%s' database: '%s'",
 
3077
                      cur_con->name, ds_user.str, ds_passwd.str, ds_db.str));
 
3078
 
 
3079
  if (mysql_change_user(mysql, ds_user.str, ds_passwd.str, ds_db.str))
 
3080
    die("change user failed: %s", mysql_error(mysql));
 
3081
 
 
3082
  dynstr_free(&ds_user);
 
3083
  dynstr_free(&ds_passwd);
 
3084
  dynstr_free(&ds_db);
 
3085
 
 
3086
  DBUG_VOID_RETURN;
2946
3087
}
2947
3088
 
 
3089
 
2948
3090
/*
2949
3091
  SYNOPSIS
2950
3092
  do_perl
2951
 
  command  command handle
 
3093
  command       command handle
2952
3094
 
2953
3095
  DESCRIPTION
2954
3096
  perl [<delimiter>];
2964
3106
  Default <delimiter> is EOF
2965
3107
*/
2966
3108
 
2967
 
static void do_perl(struct st_command *command)
 
3109
void do_perl(struct st_command *command)
2968
3110
{
2969
3111
  int error;
2970
 
  int fd;
 
3112
  File fd;
2971
3113
  FILE *res_file;
2972
3114
  char buf[FN_REFLEN];
2973
3115
  char temp_file_path[FN_REFLEN];
2974
 
  string ds_script;
2975
 
  string ds_delimiter;
 
3116
  static DYNAMIC_STRING ds_script;
 
3117
  static DYNAMIC_STRING ds_delimiter;
2976
3118
  const struct command_arg perl_args[] = {
2977
 
    { "delimiter", ARG_STRING, false, &ds_delimiter, "Delimiter to read until" }
 
3119
    { "delimiter", ARG_STRING, FALSE, &ds_delimiter, "Delimiter to read until" }
2978
3120
  };
2979
 
 
 
3121
  DBUG_ENTER("do_perl");
2980
3122
 
2981
3123
  check_command_args(command,
2982
3124
                     command->first_argument,
2985
3127
                     ' ');
2986
3128
 
2987
3129
  /* If no delimiter was provided, use EOF */
2988
 
  if (ds_delimiter.length() == 0)
2989
 
    ds_delimiter.append("EOF");
 
3130
  if (ds_delimiter.length == 0)
 
3131
    dynstr_set(&ds_delimiter, "EOF");
2990
3132
 
 
3133
  init_dynamic_string(&ds_script, "", 1024, 1024);
2991
3134
  read_until_delimiter(&ds_script, &ds_delimiter);
2992
3135
 
 
3136
  DBUG_PRINT("info", ("Executing perl: %s", ds_script.str));
 
3137
 
2993
3138
  /* Create temporary file name */
2994
3139
  if ((fd= create_temp_file(temp_file_path, getenv("MYSQLTEST_VARDIR"),
2995
 
                            "tmp", MYF(MY_WME))) < 0)
 
3140
                            "tmp", O_CREAT | O_SHARE | O_RDWR,
 
3141
                            MYF(MY_WME))) < 0)
2996
3142
    die("Failed to create temporary file for perl command");
2997
3143
  my_close(fd, MYF(0));
2998
3144
 
2999
 
  str_to_file(temp_file_path, ds_script.c_str(), ds_script.length());
 
3145
  str_to_file(temp_file_path, ds_script.str, ds_script.length);
3000
3146
 
3001
3147
  /* Format the "perl <filename>" command */
3002
 
  snprintf(buf, sizeof(buf), "perl %s", temp_file_path);
 
3148
  my_snprintf(buf, sizeof(buf), "perl %s", temp_file_path);
3003
3149
 
3004
3150
  if (!(res_file= popen(buf, "r")) && command->abort_on_error)
3005
3151
    die("popen(\"%s\", \"r\") failed", buf);
3007
3153
  while (fgets(buf, sizeof(buf), res_file))
3008
3154
  {
3009
3155
    if (disable_result_log)
 
3156
    {
3010
3157
      buf[strlen(buf)-1]=0;
 
3158
      DBUG_PRINT("exec_result",("%s", buf));
 
3159
    }
3011
3160
    else
3012
 
      replace_append(&ds_res, buf);
 
3161
    {
 
3162
      replace_dynstr_append(&ds_res, buf);
 
3163
    }
3013
3164
  }
3014
3165
  error= pclose(res_file);
3015
3166
 
3017
3168
  my_delete(temp_file_path, MYF(0));
3018
3169
 
3019
3170
  handle_command_error(command, WEXITSTATUS(error));
3020
 
  return;
 
3171
  dynstr_free(&ds_script);
 
3172
  dynstr_free(&ds_delimiter);
 
3173
  DBUG_VOID_RETURN;
3021
3174
}
3022
3175
 
3023
3176
 
3024
3177
/*
3025
3178
  Print the content between echo and <delimiter> to result file.
3026
3179
  Evaluate all variables in the string before printing, allow
3027
 
  for variable names to be escaped using        \
 
3180
  for variable names to be escaped using \
3028
3181
 
3029
3182
  SYNOPSIS
3030
3183
  do_echo()
3045
3198
  Print "Some text" plus $<var_name> to result file
3046
3199
*/
3047
3200
 
3048
 
static int do_echo(struct st_command *command)
 
3201
int do_echo(struct st_command *command)
3049
3202
{
3050
 
  string ds_echo;
3051
 
 
3052
 
 
3053
 
  do_eval(&ds_echo, command->first_argument, command->end, false);
3054
 
  ds_res.append(ds_echo.c_str(), ds_echo.length());
3055
 
  ds_res.append("\n");
 
3203
  DYNAMIC_STRING ds_echo;
 
3204
  DBUG_ENTER("do_echo");
 
3205
 
 
3206
  init_dynamic_string(&ds_echo, "", command->query_len, 256);
 
3207
  do_eval(&ds_echo, command->first_argument, command->end, FALSE);
 
3208
  dynstr_append_mem(&ds_res, ds_echo.str, ds_echo.length);
 
3209
  dynstr_append_mem(&ds_res, "\n", 1);
 
3210
  dynstr_free(&ds_echo);
3056
3211
  command->last_argument= command->end;
3057
 
  return(0);
 
3212
  DBUG_RETURN(0);
3058
3213
}
3059
3214
 
3060
3215
 
3061
 
static void
3062
 
do_wait_for_slave_to_stop(struct st_command *)
 
3216
void do_wait_for_slave_to_stop(struct st_command *c __attribute__((unused)))
3063
3217
{
3064
3218
  static int SLAVE_POLL_INTERVAL= 300000;
3065
 
  drizzle_con_st *con= &cur_con->con;
 
3219
  MYSQL* mysql = &cur_con->mysql;
3066
3220
  for (;;)
3067
3221
  {
3068
 
    drizzle_result_st res;
3069
 
    drizzle_return_t ret;
3070
 
    drizzle_row_t row;
 
3222
    MYSQL_RES *res= NULL;
 
3223
    MYSQL_ROW row;
3071
3224
    int done;
3072
3225
 
3073
 
    if (drizzle_query_str(con,&res,"show status like 'Slave_running'",
3074
 
                          &ret) == NULL || ret != DRIZZLE_RETURN_OK)
3075
 
    {
3076
 
      if (ret == DRIZZLE_RETURN_ERROR_CODE)
3077
 
      {
3078
 
        die("Query failed while probing slave for stop: %s",
3079
 
            drizzle_result_error(&res));
3080
 
        drizzle_result_free(&res);
3081
 
      }
3082
 
      else
3083
 
      {
3084
 
        die("Query failed while probing slave for stop: %s",
3085
 
            drizzle_con_error(con));
3086
 
      }
3087
 
    }
3088
 
 
3089
 
    if (drizzle_result_column_count(&res) == 0 ||
3090
 
        drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)
3091
 
    {
 
3226
    if (mysql_query(mysql,"show status like 'Slave_running'") ||
 
3227
        !(res=mysql_store_result(mysql)))
3092
3228
      die("Query failed while probing slave for stop: %s",
3093
 
          drizzle_con_error(con));
3094
 
    }
3095
 
 
3096
 
    if (!(row=drizzle_row_next(&res)) || !row[1])
 
3229
          mysql_error(mysql));
 
3230
    if (!(row=mysql_fetch_row(res)) || !row[1])
3097
3231
    {
3098
 
      drizzle_result_free(&res);
 
3232
      mysql_free_result(res);
3099
3233
      die("Strange result from query while probing slave for stop");
3100
3234
    }
3101
3235
    done = !strcmp(row[1],"OFF");
3102
 
    drizzle_result_free(&res);
 
3236
    mysql_free_result(res);
3103
3237
    if (done)
3104
3238
      break;
3105
 
    usleep(SLAVE_POLL_INTERVAL);
 
3239
    my_sleep(SLAVE_POLL_INTERVAL);
3106
3240
  }
3107
3241
  return;
3108
3242
}
3109
3243
 
3110
3244
 
3111
 
static void do_sync_with_master2(long offset)
 
3245
void do_sync_with_master2(long offset)
3112
3246
{
3113
 
  drizzle_result_st res;
3114
 
  drizzle_return_t ret;
3115
 
  drizzle_row_t row;
3116
 
  drizzle_con_st *con= &cur_con->con;
 
3247
  MYSQL_RES *res;
 
3248
  MYSQL_ROW row;
 
3249
  MYSQL *mysql= &cur_con->mysql;
3117
3250
  char query_buf[FN_REFLEN+128];
3118
3251
  int tries= 0;
3119
3252
 
3121
3254
    die("Calling 'sync_with_master' without calling 'save_master_pos'");
3122
3255
 
3123
3256
  sprintf(query_buf, "select master_pos_wait('%s', %ld)", master_pos.file,
3124
 
          master_pos.pos + offset);
 
3257
          master_pos.pos + offset);
3125
3258
 
3126
3259
wait_for_position:
3127
3260
 
3128
 
  if (drizzle_query_str(con, &res, query_buf, &ret) == NULL ||
3129
 
      ret != DRIZZLE_RETURN_OK)
3130
 
  {
3131
 
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
3132
 
    {
3133
 
      die("failed in '%s': %d: %s", query_buf, drizzle_result_error_code(&res),
3134
 
           drizzle_result_error(&res));
3135
 
      drizzle_result_free(&res);
3136
 
    }
3137
 
    else
3138
 
      die("failed in '%s': %d: %s", query_buf, ret, drizzle_con_error(con));
3139
 
  }
3140
 
 
3141
 
  if (drizzle_result_column_count(&res) == 0 ||
3142
 
      drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)
3143
 
    die("drizzle_result_buffer() returned NULL for '%s'", query_buf);
3144
 
 
3145
 
  if (!(row= drizzle_row_next(&res)))
3146
 
  {
3147
 
    drizzle_result_free(&res);
 
3261
  if (mysql_query(mysql, query_buf))
 
3262
    die("failed in '%s': %d: %s", query_buf, mysql_errno(mysql),
 
3263
        mysql_error(mysql));
 
3264
 
 
3265
  if (!(res= mysql_store_result(mysql)))
 
3266
    die("mysql_store_result() returned NULL for '%s'", query_buf);
 
3267
  if (!(row= mysql_fetch_row(res)))
 
3268
  {
 
3269
    mysql_free_result(res);
3148
3270
    die("empty result in %s", query_buf);
3149
3271
  }
3150
3272
  if (!row[0])
3153
3275
      It may be that the slave SQL thread has not started yet, though START
3154
3276
      SLAVE has been issued ?
3155
3277
    */
3156
 
    drizzle_result_free(&res);
 
3278
    mysql_free_result(res);
3157
3279
    if (tries++ == 30)
3158
3280
    {
3159
 
      show_query(con, "SHOW MASTER STATUS");
3160
 
      show_query(con, "SHOW SLAVE STATUS");
 
3281
      show_query(mysql, "SHOW MASTER STATUS");
 
3282
      show_query(mysql, "SHOW SLAVE STATUS");
3161
3283
      die("could not sync with master ('%s' returned NULL)", query_buf);
3162
3284
    }
3163
3285
    sleep(1); /* So at most we will wait 30 seconds and make 31 tries */
3164
3286
    goto wait_for_position;
3165
3287
  }
3166
 
  drizzle_result_free(&res);
 
3288
  mysql_free_result(res);
3167
3289
  return;
3168
3290
}
3169
3291
 
3170
3292
 
3171
 
static void do_sync_with_master(struct st_command *command)
 
3293
void do_sync_with_master(struct st_command *command)
3172
3294
{
3173
3295
  long offset= 0;
3174
3296
  char *p= command->first_argument;
3189
3311
 
3190
3312
/*
3191
3313
  when ndb binlog is on, this call will wait until last updated epoch
3192
 
  (locally in the drizzled) has been received into the binlog
 
3314
  (locally in the mysqld) has been received into the binlog
3193
3315
*/
3194
 
static int do_save_master_pos(void)
 
3316
int do_save_master_pos()
3195
3317
{
3196
 
  drizzle_result_st res;
3197
 
  drizzle_return_t ret;
3198
 
  drizzle_row_t row;
3199
 
  drizzle_con_st *con= &cur_con->con;
 
3318
  MYSQL_RES *res;
 
3319
  MYSQL_ROW row;
 
3320
  MYSQL *mysql = &cur_con->mysql;
3200
3321
  const char *query;
3201
 
 
3202
 
 
3203
 
  if (drizzle_query_str(con, &res, query= "show master status", &ret) == NULL ||
3204
 
      ret != DRIZZLE_RETURN_OK)
 
3322
  DBUG_ENTER("do_save_master_pos");
 
3323
 
 
3324
#ifdef HAVE_NDB_BINLOG
 
3325
  /*
 
3326
    Wait for ndb binlog to be up-to-date with all changes
 
3327
    done on the local mysql server
 
3328
  */
3205
3329
  {
3206
 
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
 
3330
    ulong have_ndbcluster;
 
3331
    if (mysql_query(mysql, query= "show variables like 'have_ndbcluster'"))
 
3332
      die("'%s' failed: %d %s", query,
 
3333
          mysql_errno(mysql), mysql_error(mysql));
 
3334
    if (!(res= mysql_store_result(mysql)))
 
3335
      die("mysql_store_result() returned NULL for '%s'", query);
 
3336
    if (!(row= mysql_fetch_row(res)))
 
3337
      die("Query '%s' returned empty result", query);
 
3338
 
 
3339
    have_ndbcluster= strcmp("YES", row[1]) == 0;
 
3340
    mysql_free_result(res);
 
3341
 
 
3342
    if (have_ndbcluster)
3207
3343
    {
3208
 
      die("failed in '%s': %d: %s", query, drizzle_result_error_code(&res),
3209
 
           drizzle_result_error(&res));
3210
 
      drizzle_result_free(&res);
 
3344
      ulonglong start_epoch= 0, handled_epoch= 0,
 
3345
        latest_epoch=0, latest_trans_epoch=0,
 
3346
        latest_handled_binlog_epoch= 0, latest_received_binlog_epoch= 0,
 
3347
        latest_applied_binlog_epoch= 0;
 
3348
      int count= 0;
 
3349
      int do_continue= 1;
 
3350
      while (do_continue)
 
3351
      {
 
3352
        const char binlog[]= "binlog";
 
3353
        const char latest_epoch_str[]=
 
3354
          "latest_epoch=";
 
3355
        const char latest_trans_epoch_str[]=
 
3356
          "latest_trans_epoch=";
 
3357
        const char latest_received_binlog_epoch_str[]=
 
3358
          "latest_received_binlog_epoch";
 
3359
        const char latest_handled_binlog_epoch_str[]=
 
3360
          "latest_handled_binlog_epoch=";
 
3361
        const char latest_applied_binlog_epoch_str[]=
 
3362
          "latest_applied_binlog_epoch=";
 
3363
        if (count)
 
3364
          sleep(1);
 
3365
        if (mysql_query(mysql, query= "show engine ndb status"))
 
3366
          die("failed in '%s': %d %s", query,
 
3367
              mysql_errno(mysql), mysql_error(mysql));
 
3368
        if (!(res= mysql_store_result(mysql)))
 
3369
          die("mysql_store_result() returned NULL for '%s'", query);
 
3370
        while ((row= mysql_fetch_row(res)))
 
3371
        {
 
3372
          if (strcmp(row[1], binlog) == 0)
 
3373
          {
 
3374
            const char *status= row[2];
 
3375
 
 
3376
            /* latest_epoch */
 
3377
            while (*status && strncmp(status, latest_epoch_str,
 
3378
                                      sizeof(latest_epoch_str)-1))
 
3379
              status++;
 
3380
            if (*status)
 
3381
            {
 
3382
              status+= sizeof(latest_epoch_str)-1;
 
3383
              latest_epoch= strtoull(status, (char**) 0, 10);
 
3384
            }
 
3385
            else
 
3386
              die("result does not contain '%s' in '%s'",
 
3387
                  latest_epoch_str, query);
 
3388
            /* latest_trans_epoch */
 
3389
            while (*status && strncmp(status, latest_trans_epoch_str,
 
3390
                                      sizeof(latest_trans_epoch_str)-1))
 
3391
              status++;
 
3392
            if (*status)
 
3393
            {
 
3394
              status+= sizeof(latest_trans_epoch_str)-1;
 
3395
              latest_trans_epoch= strtoull(status, (char**) 0, 10);
 
3396
            }
 
3397
            else
 
3398
              die("result does not contain '%s' in '%s'",
 
3399
                  latest_trans_epoch_str, query);
 
3400
            /* latest_received_binlog_epoch */
 
3401
            while (*status &&
 
3402
                   strncmp(status, latest_received_binlog_epoch_str,
 
3403
                           sizeof(latest_received_binlog_epoch_str)-1))
 
3404
              status++;
 
3405
            if (*status)
 
3406
            {
 
3407
              status+= sizeof(latest_received_binlog_epoch_str)-1;
 
3408
              latest_received_binlog_epoch= strtoull(status, (char**) 0, 10);
 
3409
            }
 
3410
            else
 
3411
              die("result does not contain '%s' in '%s'",
 
3412
                  latest_received_binlog_epoch_str, query);
 
3413
            /* latest_handled_binlog */
 
3414
            while (*status &&
 
3415
                   strncmp(status, latest_handled_binlog_epoch_str,
 
3416
                           sizeof(latest_handled_binlog_epoch_str)-1))
 
3417
              status++;
 
3418
            if (*status)
 
3419
            {
 
3420
              status+= sizeof(latest_handled_binlog_epoch_str)-1;
 
3421
              latest_handled_binlog_epoch= strtoull(status, (char**) 0, 10);
 
3422
            }
 
3423
            else
 
3424
              die("result does not contain '%s' in '%s'",
 
3425
                  latest_handled_binlog_epoch_str, query);
 
3426
            /* latest_applied_binlog_epoch */
 
3427
            while (*status &&
 
3428
                   strncmp(status, latest_applied_binlog_epoch_str,
 
3429
                           sizeof(latest_applied_binlog_epoch_str)-1))
 
3430
              status++;
 
3431
            if (*status)
 
3432
            {
 
3433
              status+= sizeof(latest_applied_binlog_epoch_str)-1;
 
3434
              latest_applied_binlog_epoch= strtoull(status, (char**) 0, 10);
 
3435
            }
 
3436
            else
 
3437
              die("result does not contain '%s' in '%s'",
 
3438
                  latest_applied_binlog_epoch_str, query);
 
3439
            if (count == 0)
 
3440
              start_epoch= latest_trans_epoch;
 
3441
            break;
 
3442
          }
 
3443
        }
 
3444
        if (!row)
 
3445
          die("result does not contain '%s' in '%s'",
 
3446
              binlog, query);
 
3447
        if (latest_handled_binlog_epoch > handled_epoch)
 
3448
          count= 0;
 
3449
        handled_epoch= latest_handled_binlog_epoch;
 
3450
        count++;
 
3451
        if (latest_handled_binlog_epoch >= start_epoch)
 
3452
          do_continue= 0;
 
3453
        else if (count > 30)
 
3454
        {
 
3455
          break;
 
3456
        }
 
3457
        mysql_free_result(res);
 
3458
      }
3211
3459
    }
3212
 
    else
3213
 
      die("failed in '%s': %d: %s", query, ret, drizzle_con_error(con));
3214
3460
  }
 
3461
#endif
 
3462
  if (mysql_query(mysql, query= "show master status"))
 
3463
    die("failed in 'show master status': %d %s",
 
3464
        mysql_errno(mysql), mysql_error(mysql));
3215
3465
 
3216
 
  if (drizzle_result_column_count(&res) == 0 ||
3217
 
      drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)
3218
 
    die("drizzleclient_store_result() retuned NULL for '%s'", query);
3219
 
  if (!(row = drizzle_row_next(&res)))
 
3466
  if (!(res = mysql_store_result(mysql)))
 
3467
    die("mysql_store_result() retuned NULL for '%s'", query);
 
3468
  if (!(row = mysql_fetch_row(res)))
3220
3469
    die("empty result in show master status");
3221
 
  strncpy(master_pos.file, row[0], sizeof(master_pos.file)-1);
 
3470
  strnmov(master_pos.file, row[0], sizeof(master_pos.file)-1);
3222
3471
  master_pos.pos = strtoul(row[1], (char**) 0, 10);
3223
 
  drizzle_result_free(&res);
3224
 
  return(0);
 
3472
  mysql_free_result(res);
 
3473
  DBUG_RETURN(0);
3225
3474
}
3226
3475
 
3227
3476
 
3230
3479
 
3231
3480
  SYNOPSIS
3232
3481
  do_let()
3233
 
  query  called command
 
3482
  query called command
3234
3483
 
3235
3484
  DESCRIPTION
3236
3485
  let $<var_name>=<var_val><delimiter>
3244
3493
  Program will die if error detected
3245
3494
*/
3246
3495
 
3247
 
static void do_let(struct st_command *command)
 
3496
void do_let(struct st_command *command)
3248
3497
{
3249
3498
  char *p= command->first_argument;
3250
3499
  char *var_name, *var_name_end;
3251
 
  string let_rhs_expr;
 
3500
  DYNAMIC_STRING let_rhs_expr;
 
3501
  DBUG_ENTER("do_let");
3252
3502
 
 
3503
  init_dynamic_string(&let_rhs_expr, "", 512, 2048);
3253
3504
 
3254
3505
  /* Find <var_name> */
3255
3506
  if (!*p)
3270
3521
  while (*p && my_isspace(charset_info,*p))
3271
3522
    p++;
3272
3523
 
3273
 
  do_eval(&let_rhs_expr, p, command->end, false);
 
3524
  do_eval(&let_rhs_expr, p, command->end, FALSE);
3274
3525
 
3275
3526
  command->last_argument= command->end;
3276
3527
  /* Assign var_val to var_name */
3277
 
  var_set(var_name, var_name_end, let_rhs_expr.c_str(),
3278
 
          (let_rhs_expr.c_str() + let_rhs_expr.length()));
3279
 
  return;
 
3528
  var_set(var_name, var_name_end, let_rhs_expr.str,
 
3529
          (let_rhs_expr.str + let_rhs_expr.length));
 
3530
  dynstr_free(&let_rhs_expr);
 
3531
  DBUG_VOID_RETURN;
3280
3532
}
3281
3533
 
3282
3534
 
3285
3537
 
3286
3538
  SYNOPSIS
3287
3539
  do_sleep()
3288
 
  q         called command
 
3540
  q            called command
3289
3541
  real_sleep   use the value from opt_sleep as number of seconds to sleep
3290
 
  if real_sleep is false
 
3542
               if real_sleep is false
3291
3543
 
3292
3544
  DESCRIPTION
3293
3545
  sleep <seconds>
3302
3554
  used for cpu-independent delays.
3303
3555
*/
3304
3556
 
3305
 
static int do_sleep(struct st_command *command, bool real_sleep)
 
3557
int do_sleep(struct st_command *command, my_bool real_sleep)
3306
3558
{
3307
 
  bool error= false;
 
3559
  int error= 0;
3308
3560
  char *p= command->first_argument;
3309
3561
  char *sleep_start, *sleep_end= command->end;
3310
3562
  double sleep_val;
3318
3570
  if (!my_isdigit(charset_info, *sleep_start))
3319
3571
    die("Invalid argument to %.*s \"%s\"", command->first_word_len,
3320
3572
        command->query,command->first_argument);
3321
 
  string buff_str(sleep_start, sleep_end-sleep_start);
3322
 
  istringstream buff(buff_str);
3323
 
  error= (buff >> sleep_val).fail();
 
3573
  sleep_val= my_strtod(sleep_start, &sleep_end, &error);
3324
3574
  if (error)
3325
3575
    die("Invalid argument to %.*s \"%s\"", command->first_word_len,
3326
3576
        command->query, command->first_argument);
3329
3579
  if (opt_sleep >= 0 && !real_sleep)
3330
3580
    sleep_val= opt_sleep;
3331
3581
 
 
3582
  DBUG_PRINT("info", ("sleep_val: %f", sleep_val));
3332
3583
  if (sleep_val)
3333
 
    usleep((uint32_t) (sleep_val * 1000000L));
 
3584
    my_sleep((ulong) (sleep_val * 1000000L));
3334
3585
  command->last_argument= sleep_end;
3335
3586
  return 0;
3336
3587
}
3337
3588
 
3338
3589
 
3339
 
static void do_get_file_name(struct st_command *command, string &dest)
 
3590
void do_get_file_name(struct st_command *command,
 
3591
                      char* dest, uint dest_max_len)
3340
3592
{
3341
3593
  char *p= command->first_argument, *name;
3342
3594
  if (!*p)
3347
3599
  if (*p)
3348
3600
    *p++= 0;
3349
3601
  command->last_argument= p;
3350
 
  if (opt_testdir != NULL)
3351
 
  {
3352
 
    dest= opt_testdir;
3353
 
    if (dest[dest.length()] != '/')
3354
 
      dest.append("/");
3355
 
  }
3356
 
  dest.append(name);
 
3602
  strmake(dest, name, dest_max_len - 1);
3357
3603
}
3358
3604
 
3359
3605
 
3360
 
static void do_set_charset(struct st_command *command)
 
3606
void do_set_charset(struct st_command *command)
3361
3607
{
3362
3608
  char *charset_name= command->first_argument;
3363
3609
  char *p;
3371
3617
  if(*p)
3372
3618
    *p++= 0;
3373
3619
  command->last_argument= p;
3374
 
  charset_info= get_charset_by_csname(charset_name, MY_CS_PRIMARY);
 
3620
  charset_info= get_charset_by_csname(charset_name,MY_CS_PRIMARY,MYF(MY_WME));
3375
3621
  if (!charset_info)
3376
3622
    abort_not_supported_test("Test requires charset '%s'", charset_name);
3377
3623
}
3378
3624
 
3379
 
static uint32_t get_errcode_from_name(char *error_name, char *error_end)
3380
 
{
3381
 
  size_t err_name_len= error_end - error_name;
3382
 
  string error_name_s(error_name, err_name_len);
3383
 
 
3384
 
  uint32_t code= global_error_names.getErrorCode(error_name_s);
3385
 
 
3386
 
  if (!code)
3387
 
    die("Unknown SQL error name '%s'", error_name_s.c_str());
3388
 
 
3389
 
  return(code);
3390
 
}
3391
 
 
3392
 
static void do_get_errcodes(struct st_command *command)
 
3625
 
 
3626
#if MYSQL_VERSION_ID >= 50000
 
3627
/* List of error names to error codes, available from 5.0 */
 
3628
typedef struct
 
3629
{
 
3630
  const char *name;
 
3631
  uint        code;
 
3632
} st_error;
 
3633
 
 
3634
static st_error global_error_names[] =
 
3635
{
 
3636
#include <mysqld_ername.h>
 
3637
  { 0, 0 }
 
3638
};
 
3639
 
 
3640
uint get_errcode_from_name(char *error_name, char *error_end)
 
3641
{
 
3642
  /* SQL error as string */
 
3643
  st_error *e= global_error_names;
 
3644
 
 
3645
  DBUG_ENTER("get_errcode_from_name");
 
3646
  DBUG_PRINT("enter", ("error_name: %s", error_name));
 
3647
 
 
3648
  /* Loop through the array of known error names */
 
3649
  for (; e->name; e++)
 
3650
  {
 
3651
    /*
 
3652
      If we get a match, we need to check the length of the name we
 
3653
      matched against in case it was longer than what we are checking
 
3654
      (as in ER_WRONG_VALUE vs. ER_WRONG_VALUE_COUNT).
 
3655
    */
 
3656
    if (!strncmp(error_name, e->name, (int) (error_end - error_name)) &&
 
3657
        (uint) strlen(e->name) == (uint) (error_end - error_name))
 
3658
    {
 
3659
      DBUG_RETURN(e->code);
 
3660
    }
 
3661
  }
 
3662
  if (!e->name)
 
3663
    die("Unknown SQL error name '%s'", error_name);
 
3664
  DBUG_RETURN(0);
 
3665
}
 
3666
#else
 
3667
uint get_errcode_from_name(char *error_name __attribute__((unused)),
 
3668
                           char *error_end __attribute__((unused)))
 
3669
{
 
3670
  abort_not_in_this_version();
 
3671
  return 0; /* Never reached */
 
3672
}
 
3673
#endif
 
3674
 
 
3675
 
 
3676
 
 
3677
void do_get_errcodes(struct st_command *command)
3393
3678
{
3394
3679
  struct st_match_err *to= saved_expected_errors.err;
3395
3680
  char *p= command->first_argument;
3396
 
  uint32_t count= 0;
3397
 
 
3398
 
 
 
3681
  uint count= 0;
 
3682
 
 
3683
  DBUG_ENTER("do_get_errcodes");
3399
3684
 
3400
3685
  if (!*p)
3401
3686
    die("Missing argument(s) to 'error'");
3419
3704
 
3420
3705
      /*
3421
3706
        SQLSTATE string
3422
 
        - Must be DRIZZLE_MAX_SQLSTATE_SIZE long
 
3707
        - Must be SQLSTATE_LENGTH long
3423
3708
        - May contain only digits[0-9] and _uppercase_ letters
3424
3709
      */
3425
3710
      p++; /* Step past the S */
3426
 
      if ((end - p) != DRIZZLE_MAX_SQLSTATE_SIZE)
3427
 
        die("The sqlstate must be exactly %d chars long", DRIZZLE_MAX_SQLSTATE_SIZE);
 
3711
      if ((end - p) != SQLSTATE_LENGTH)
 
3712
        die("The sqlstate must be exactly %d chars long", SQLSTATE_LENGTH);
3428
3713
 
3429
3714
      /* Check sqlstate string validity */
3430
3715
      while (*p && p < end)
3432
3717
        if (my_isdigit(charset_info, *p) || my_isupper(charset_info, *p))
3433
3718
          *to_ptr++= *p++;
3434
3719
        else
3435
 
          die("The sqlstate may only consist of digits[0-9] "   \
 
3720
          die("The sqlstate may only consist of digits[0-9] " \
3436
3721
              "and _uppercase_ letters");
3437
3722
      }
3438
3723
 
3439
3724
      *to_ptr= 0;
3440
3725
      to->type= ERR_SQLSTATE;
 
3726
      DBUG_PRINT("info", ("ERR_SQLSTATE: %s", to->code.sqlstate));
3441
3727
    }
3442
3728
    else if (*p == 's')
3443
3729
    {
3447
3733
    {
3448
3734
      /* Error name string */
3449
3735
 
 
3736
      DBUG_PRINT("info", ("Error name: %s", p));
3450
3737
      to->code.errnum= get_errcode_from_name(p, end);
3451
3738
      to->type= ERR_ERRNO;
 
3739
      DBUG_PRINT("info", ("ERR_ERRNO: %d", to->code.errnum));
3452
3740
    }
3453
3741
    else if (*p == 'e')
3454
3742
    {
3462
3750
      while (*p && p != end)
3463
3751
      {
3464
3752
        if (!my_isdigit(charset_info, *p))
3465
 
          die("Invalid argument to error: '%s' - "              \
 
3753
          die("Invalid argument to error: '%s' - "\
3466
3754
              "the errno may only consist of digits[0-9]",
3467
3755
              command->first_argument);
3468
3756
        p++;
3469
3757
      }
3470
3758
 
3471
3759
      /* Convert the sting to int */
3472
 
      istringstream buff(start);
3473
 
      if ((buff >> val).fail())
3474
 
        die("Invalid argument to error: '%s'", command->first_argument);
 
3760
      if (!str2int(start, 10, (long) INT_MIN, (long) INT_MAX, &val))
 
3761
        die("Invalid argument to error: '%s'", command->first_argument);
3475
3762
 
3476
 
      to->code.errnum= (uint32_t) val;
 
3763
      to->code.errnum= (uint) val;
3477
3764
      to->type= ERR_ERRNO;
 
3765
      DBUG_PRINT("info", ("ERR_ERRNO: %d", to->code.errnum));
3478
3766
    }
3479
3767
    to++;
3480
3768
    count++;
3498
3786
  command->last_argument= p;
3499
3787
  to->type= ERR_EMPTY;                        /* End of data */
3500
3788
 
 
3789
  DBUG_PRINT("info", ("Expected errors: %d", count));
3501
3790
  saved_expected_errors.count= count;
3502
 
  return;
 
3791
  DBUG_VOID_RETURN;
3503
3792
}
3504
3793
 
3505
3794
 
3510
3799
  If string is a '$variable', return the value of the variable.
3511
3800
*/
3512
3801
 
3513
 
static char *get_string(char **to_ptr, char **from_ptr,
3514
 
                        struct st_command *command)
 
3802
char *get_string(char **to_ptr, char **from_ptr,
 
3803
                 struct st_command *command)
3515
3804
{
3516
3805
  char c, sep;
3517
3806
  char *to= *to_ptr, *from= *from_ptr, *start=to;
3518
 
 
 
3807
  DBUG_ENTER("get_string");
3519
3808
 
3520
3809
  /* Find separator */
3521
3810
  if (*from == '"' || *from == '\'')
3522
3811
    sep= *from++;
3523
3812
  else
3524
 
    sep=' ';        /* Separated with space */
 
3813
    sep=' ';                            /* Separated with space */
3525
3814
 
3526
3815
  for ( ; (c=*from) ; from++)
3527
3816
  {
3528
3817
    if (c == '\\' && from[1])
3529
 
    {          /* Escaped character */
 
3818
    {                                   /* Escaped character */
3530
3819
      /* We can't translate \0 -> ASCII 0 as replace can't handle ASCII 0 */
3531
3820
      switch (*++from) {
3532
3821
      case 'n':
3533
 
        *to++= '\n';
3534
 
        break;
 
3822
        *to++= '\n';
 
3823
        break;
3535
3824
      case 't':
3536
 
        *to++= '\t';
3537
 
        break;
 
3825
        *to++= '\t';
 
3826
        break;
3538
3827
      case 'r':
3539
 
        *to++ = '\r';
3540
 
        break;
 
3828
        *to++ = '\r';
 
3829
        break;
3541
3830
      case 'b':
3542
 
        *to++ = '\b';
3543
 
        break;
3544
 
      case 'Z':        /* ^Z must be escaped on Win32 */
3545
 
        *to++='\032';
3546
 
        break;
 
3831
        *to++ = '\b';
 
3832
        break;
 
3833
      case 'Z':                         /* ^Z must be escaped on Win32 */
 
3834
        *to++='\032';
 
3835
        break;
3547
3836
      default:
3548
 
        *to++ = *from;
3549
 
        break;
 
3837
        *to++ = *from;
 
3838
        break;
3550
3839
      }
3551
3840
    }
3552
3841
    else if (c == sep)
3553
3842
    {
3554
3843
      if (c == ' ' || c != *++from)
3555
 
        break;        /* Found end of string */
3556
 
      *to++=c;        /* Copy duplicated separator */
 
3844
        break;                          /* Found end of string */
 
3845
      *to++=c;                          /* Copy duplicated separator */
3557
3846
    }
3558
3847
    else
3559
3848
      *to++=c;
3561
3850
  if (*from != ' ' && *from)
3562
3851
    die("Wrong string argument in %s", command->query);
3563
3852
 
3564
 
  while (my_isspace(charset_info,*from))  /* Point to next string */
 
3853
  while (my_isspace(charset_info,*from))        /* Point to next string */
3565
3854
    from++;
3566
3855
 
3567
 
  *to =0;        /* End of string marker */
3568
 
  *to_ptr= to+1;      /* Store pointer to end */
 
3856
  *to =0;                               /* End of string marker */
 
3857
  *to_ptr= to+1;                        /* Store pointer to end */
3569
3858
  *from_ptr= from;
3570
3859
 
3571
3860
  /* Check if this was a variable */
3574
3863
    const char *end= to;
3575
3864
    VAR *var=var_get(start, &end, 0, 1);
3576
3865
    if (var && to == (char*) end+1)
3577
 
      return(var->str_val);  /* return found variable value */
 
3866
    {
 
3867
      DBUG_PRINT("info",("var: '%s' -> '%s'", start, var->str_val));
 
3868
      DBUG_RETURN(var->str_val);        /* return found variable value */
 
3869
    }
3578
3870
  }
3579
 
  return(start);
3580
 
}
3581
 
 
3582
 
 
3583
 
static void set_reconnect(drizzle_con_st *con, int val)
3584
 
{
3585
 
  (void) con;
3586
 
  (void) val;
3587
 
/* XXX
3588
 
  bool reconnect= val;
3589
 
 
3590
 
  drizzleclient_options(drizzle, DRIZZLE_OPT_RECONNECT, (char *)&reconnect);
3591
 
*/
3592
 
}
3593
 
 
3594
 
 
3595
 
static int select_connection_name(const char *name)
3596
 
{
 
3871
  DBUG_RETURN(start);
 
3872
}
 
3873
 
 
3874
 
 
3875
void set_reconnect(MYSQL* mysql, int val)
 
3876
{
 
3877
  my_bool reconnect= val;
 
3878
  DBUG_ENTER("set_reconnect");
 
3879
  DBUG_PRINT("info", ("val: %d", val));
 
3880
#if MYSQL_VERSION_ID < 50000
 
3881
  mysql->reconnect= reconnect;
 
3882
#else
 
3883
  mysql_options(mysql, MYSQL_OPT_RECONNECT, (char *)&reconnect);
 
3884
#endif
 
3885
  DBUG_VOID_RETURN;
 
3886
}
 
3887
 
 
3888
 
 
3889
int select_connection_name(const char *name)
 
3890
{
 
3891
  DBUG_ENTER("select_connection_name");
 
3892
  DBUG_PRINT("enter",("name: '%s'", name));
 
3893
 
3597
3894
  if (!(cur_con= find_connection_by_name(name)))
3598
3895
    die("connection '%s' not found in connection pool", name);
3599
3896
 
3600
 
  /* Update $drizzleclient_get_server_version to that of current connection */
3601
 
  var_set_drizzleclient_get_server_version(&cur_con->con);
 
3897
  /* Update $mysql_get_server_version to that of current connection */
 
3898
  var_set_mysql_get_server_version(&cur_con->mysql);
3602
3899
 
3603
 
  return(0);
 
3900
  DBUG_RETURN(0);
3604
3901
}
3605
3902
 
3606
3903
 
3607
 
static int select_connection(struct st_command *command)
 
3904
int select_connection(struct st_command *command)
3608
3905
{
3609
3906
  char *name;
3610
3907
  char *p= command->first_argument;
3611
 
 
 
3908
  DBUG_ENTER("select_connection");
3612
3909
 
3613
3910
  if (!*p)
3614
3911
    die("Missing connection name in connect");
3618
3915
  if (*p)
3619
3916
    *p++= 0;
3620
3917
  command->last_argument= p;
3621
 
  return(select_connection_name(name));
 
3918
  DBUG_RETURN(select_connection_name(name));
3622
3919
}
3623
3920
 
3624
3921
 
3625
 
static void do_close_connection(struct st_command *command)
 
3922
void do_close_connection(struct st_command *command)
3626
3923
{
3627
3924
  char *p= command->first_argument, *name;
3628
3925
  struct st_connection *con;
3629
3926
 
 
3927
  DBUG_ENTER("close_connection");
 
3928
  DBUG_PRINT("enter",("name: '%s'",p));
 
3929
 
3630
3930
  if (!*p)
3631
3931
    die("Missing connection name in disconnect");
3632
3932
  name= p;
3640
3940
  if (!(con= find_connection_by_name(name)))
3641
3941
    die("connection '%s' not found in connection pool", name);
3642
3942
 
3643
 
  if (con->drizzle != NULL)
 
3943
  DBUG_PRINT("info", ("Closing connection %s", con->name));
 
3944
#ifndef EMBEDDED_LIBRARY
 
3945
  if (command->type == Q_DIRTY_CLOSE)
3644
3946
  {
3645
 
    drizzle_free(con->drizzle);
3646
 
    con->drizzle= NULL;
 
3947
    if (con->mysql.net.vio)
 
3948
    {
 
3949
      vio_delete(con->mysql.net.vio);
 
3950
      con->mysql.net.vio = 0;
 
3951
    }
3647
3952
  }
3648
 
  free(con->name);
 
3953
#else
 
3954
  /*
 
3955
    As query could be still executed in a separate theread
 
3956
    we need to check if the query's thread was finished and probably wait
 
3957
    (embedded-server specific)
 
3958
  */
 
3959
  wait_query_thread_end(con);
 
3960
#endif /*EMBEDDED_LIBRARY*/
 
3961
  if (con->stmt)
 
3962
    mysql_stmt_close(con->stmt);
 
3963
  con->stmt= 0;
 
3964
 
 
3965
  mysql_close(&con->mysql);
 
3966
 
 
3967
  if (con->util_mysql)
 
3968
    mysql_close(con->util_mysql);
 
3969
  con->util_mysql= 0;
 
3970
 
 
3971
  my_free(con->name, MYF(0));
3649
3972
 
3650
3973
  /*
3651
3974
    When the connection is closed set name to "-closed_connection-"
3652
3975
    to make it possible to reuse the connection name.
3653
3976
  */
3654
 
  if (!(con->name = strdup("-closed_connection-")))
 
3977
  if (!(con->name = my_strdup("-closed_connection-", MYF(MY_WME))))
3655
3978
    die("Out of memory");
3656
3979
 
3657
 
  return;
 
3980
  DBUG_VOID_RETURN;
3658
3981
}
3659
3982
 
3660
3983
 
3683
4006
 
3684
4007
*/
3685
4008
 
3686
 
static void safe_connect(drizzle_con_st *con, const char *name,
3687
 
                         const char *host, const char *user, const char *pass,
3688
 
                         const char *db, int port)
 
4009
void safe_connect(MYSQL* mysql, const char *name, const char *host,
 
4010
                  const char *user, const char *pass, const char *db,
 
4011
                  int port)
3689
4012
{
3690
4013
  int failed_attempts= 0;
3691
 
  static uint32_t connection_retry_sleep= 100000; /* Microseconds */
3692
 
  drizzle_return_t ret;
 
4014
  static ulong connection_retry_sleep= 100000; /* Microseconds */
3693
4015
 
3694
 
  drizzle_con_set_tcp(con, host, port);
3695
 
  drizzle_con_set_auth(con, user, pass);
3696
 
  drizzle_con_set_db(con, db);
3697
 
  while((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)
 
4016
  DBUG_ENTER("safe_connect");
 
4017
  while(!mysql_real_connect(mysql, host, user, pass, db, port, NULL,
 
4018
                            CLIENT_MULTI_STATEMENTS | CLIENT_REMEMBER_OPTIONS))
3698
4019
  {
3699
4020
    /*
3700
4021
      Connect failed
3704
4025
      on protocol/connection type
3705
4026
    */
3706
4027
 
3707
 
    if ((ret == DRIZZLE_RETURN_GETADDRINFO ||
3708
 
         ret == DRIZZLE_RETURN_COULD_NOT_CONNECT) &&
 
4028
    if ((mysql_errno(mysql) == CR_CONN_HOST_ERROR ||
 
4029
         mysql_errno(mysql) == CR_CONNECTION_ERROR) &&
3709
4030
        failed_attempts < opt_max_connect_retries)
3710
4031
    {
3711
4032
      verbose_msg("Connect attempt %d/%d failed: %d: %s", failed_attempts,
3712
 
                  opt_max_connect_retries, ret, drizzle_con_error(con));
3713
 
      usleep(connection_retry_sleep);
 
4033
                  opt_max_connect_retries, mysql_errno(mysql),
 
4034
                  mysql_error(mysql));
 
4035
      my_sleep(connection_retry_sleep);
3714
4036
    }
3715
4037
    else
3716
4038
    {
3717
4039
      if (failed_attempts > 0)
3718
4040
        die("Could not open connection '%s' after %d attempts: %d %s", name,
3719
 
            failed_attempts, ret, drizzle_con_error(con));
 
4041
            failed_attempts, mysql_errno(mysql), mysql_error(mysql));
3720
4042
      else
3721
 
        die("Could not open connection '%s': %d %s", name, ret,
3722
 
            drizzle_con_error(con));
 
4043
        die("Could not open connection '%s': %d %s", name,
 
4044
            mysql_errno(mysql), mysql_error(mysql));
3723
4045
    }
3724
4046
    failed_attempts++;
3725
4047
  }
3726
 
  return;
 
4048
  DBUG_VOID_RETURN;
3727
4049
}
3728
4050
 
3729
4051
 
3750
4072
 
3751
4073
*/
3752
4074
 
3753
 
static int connect_n_handle_errors(struct st_command *command,
3754
 
                                   drizzle_con_st *con, const char* host,
3755
 
                                   const char* user, const char* pass,
3756
 
                                   const char* db, int port, const char* sock)
 
4075
int connect_n_handle_errors(struct st_command *command,
 
4076
                            MYSQL* con, const char* host,
 
4077
                            const char* user, const char* pass,
 
4078
                            const char* db, int port, const char* sock)
3757
4079
{
3758
 
  drizzle_return_t ret;
 
4080
  DYNAMIC_STRING *ds;
 
4081
 
 
4082
  ds= &ds_res;
3759
4083
 
3760
4084
  /* Only log if an error is expected */
3761
4085
  if (!command->abort_on_error &&
3764
4088
    /*
3765
4089
      Log the connect to result log
3766
4090
    */
3767
 
    ds_res.append("connect(");
3768
 
    replace_append(&ds_res, host);
3769
 
    ds_res.append(",");
3770
 
    replace_append(&ds_res, user);
3771
 
    ds_res.append(",");
3772
 
    replace_append(&ds_res, pass);
3773
 
    ds_res.append(",");
 
4091
    dynstr_append_mem(ds, "connect(", 8);
 
4092
    replace_dynstr_append(ds, host);
 
4093
    dynstr_append_mem(ds, ",", 1);
 
4094
    replace_dynstr_append(ds, user);
 
4095
    dynstr_append_mem(ds, ",", 1);
 
4096
    replace_dynstr_append(ds, pass);
 
4097
    dynstr_append_mem(ds, ",", 1);
3774
4098
    if (db)
3775
 
      replace_append(&ds_res, db);
3776
 
    ds_res.append(",");
3777
 
    replace_append_uint(&ds_res, port);
3778
 
    ds_res.append(",");
 
4099
      replace_dynstr_append(ds, db);
 
4100
    dynstr_append_mem(ds, ",", 1);
 
4101
    replace_dynstr_append_uint(ds, port);
 
4102
    dynstr_append_mem(ds, ",", 1);
3779
4103
    if (sock)
3780
 
      replace_append(&ds_res, sock);
3781
 
    ds_res.append(")");
3782
 
    ds_res.append(delimiter);
3783
 
    ds_res.append("\n");
 
4104
      replace_dynstr_append(ds, sock);
 
4105
    dynstr_append_mem(ds, ")", 1);
 
4106
    dynstr_append_mem(ds, delimiter, delimiter_length);
 
4107
    dynstr_append_mem(ds, "\n", 1);
3784
4108
  }
3785
 
  drizzle_con_set_tcp(con, host, port);
3786
 
  drizzle_con_set_auth(con, user, pass);
3787
 
  drizzle_con_set_db(con, db);
3788
 
  if ((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)
 
4109
  if (!mysql_real_connect(con, host, user, pass, db, port, 0,
 
4110
                          CLIENT_MULTI_STATEMENTS))
3789
4111
  {
3790
 
    if (ret == DRIZZLE_RETURN_HANDSHAKE_FAILED)
3791
 
    {
3792
 
      var_set_errno(drizzle_con_error_code(con));
3793
 
      handle_error(command, drizzle_con_error_code(con), drizzle_con_error(con),
3794
 
                   drizzle_con_sqlstate(con), &ds_res);
3795
 
    }
3796
 
    else
3797
 
    {
3798
 
      var_set_errno(ret);
3799
 
      handle_error(command, ret, drizzle_con_error(con), "", &ds_res);
3800
 
    }
3801
 
 
 
4112
    var_set_errno(mysql_errno(con));
 
4113
    handle_error(command, mysql_errno(con), mysql_error(con),
 
4114
                 mysql_sqlstate(con), ds);
3802
4115
    return 0; /* Not connected */
3803
4116
  }
3804
4117
 
3809
4122
 
3810
4123
 
3811
4124
/*
3812
 
  Open a new connection to DRIZZLE Server with the parameters
 
4125
  Open a new connection to MySQL Server with the parameters
3813
4126
  specified. Make the new connection the current connection.
3814
4127
 
3815
4128
  SYNOPSIS
3816
4129
  do_connect()
3817
 
  q         called command
 
4130
  q            called command
3818
4131
 
3819
4132
  DESCRIPTION
3820
4133
  connect(<name>,<host>,<user>,[<pass>,[<db>,[<port>,<sock>[<opts>]]]]);
3828
4141
  <port> - server port
3829
4142
  <sock> - server socket
3830
4143
  <opts> - options to use for the connection
3831
 
  * SSL - use SSL if available
3832
 
  * COMPRESS - use compression if available
3833
 
 
3834
 
  */
3835
 
 
3836
 
static void do_connect(struct st_command *command)
 
4144
   * SSL - use SSL if available
 
4145
   * COMPRESS - use compression if available
 
4146
 
 
4147
*/
 
4148
 
 
4149
void do_connect(struct st_command *command)
3837
4150
{
3838
4151
  int con_port= opt_port;
3839
 
  const char *con_options;
3840
 
  bool con_ssl= 0, con_compress= 0;
 
4152
  char *con_options;
 
4153
  my_bool con_ssl= 0, con_compress= 0;
3841
4154
  struct st_connection* con_slot;
3842
4155
 
3843
 
  string ds_connection_name;
3844
 
  string ds_host;
3845
 
  string ds_user;
3846
 
  string ds_password;
3847
 
  string ds_database;
3848
 
  string ds_port;
3849
 
  string ds_sock;
3850
 
  string ds_options;
 
4156
  static DYNAMIC_STRING ds_connection_name;
 
4157
  static DYNAMIC_STRING ds_host;
 
4158
  static DYNAMIC_STRING ds_user;
 
4159
  static DYNAMIC_STRING ds_password;
 
4160
  static DYNAMIC_STRING ds_database;
 
4161
  static DYNAMIC_STRING ds_port;
 
4162
  static DYNAMIC_STRING ds_sock;
 
4163
  static DYNAMIC_STRING ds_options;
3851
4164
  const struct command_arg connect_args[] = {
3852
 
    { "connection name", ARG_STRING, true, &ds_connection_name, "Name of the connection" },
3853
 
    { "host", ARG_STRING, true, &ds_host, "Host to connect to" },
3854
 
    { "user", ARG_STRING, false, &ds_user, "User to connect as" },
3855
 
    { "passsword", ARG_STRING, false, &ds_password, "Password used when connecting" },
3856
 
    { "database", ARG_STRING, false, &ds_database, "Database to select after connect" },
3857
 
    { "port", ARG_STRING, false, &ds_port, "Port to connect to" },
3858
 
    { "socket", ARG_STRING, false, &ds_sock, "Socket to connect with" },
3859
 
    { "options", ARG_STRING, false, &ds_options, "Options to use while connecting" }
 
4165
    { "connection name", ARG_STRING, TRUE, &ds_connection_name, "Name of the connection" },
 
4166
    { "host", ARG_STRING, TRUE, &ds_host, "Host to connect to" },
 
4167
    { "user", ARG_STRING, FALSE, &ds_user, "User to connect as" },
 
4168
    { "passsword", ARG_STRING, FALSE, &ds_password, "Password used when connecting" },
 
4169
    { "database", ARG_STRING, FALSE, &ds_database, "Database to select after connect" },
 
4170
    { "port", ARG_STRING, FALSE, &ds_port, "Port to connect to" },
 
4171
    { "socket", ARG_STRING, FALSE, &ds_sock, "Socket to connect with" },
 
4172
    { "options", ARG_STRING, FALSE, &ds_options, "Options to use while connecting" }
3860
4173
  };
3861
4174
 
 
4175
  DBUG_ENTER("do_connect");
 
4176
  DBUG_PRINT("enter",("connect: %s", command->first_argument));
3862
4177
 
3863
4178
  strip_parentheses(command);
3864
4179
  check_command_args(command, command->first_argument, connect_args,
3866
4181
                     ',');
3867
4182
 
3868
4183
  /* Port */
3869
 
  if (ds_port.length())
 
4184
  if (ds_port.length)
3870
4185
  {
3871
 
    con_port= atoi(ds_port.c_str());
 
4186
    con_port= atoi(ds_port.str);
3872
4187
    if (con_port == 0)
3873
 
      die("Illegal argument for port: '%s'", ds_port.c_str());
 
4188
      die("Illegal argument for port: '%s'", ds_port.str);
3874
4189
  }
3875
4190
 
3876
4191
  /* Sock */
3877
 
  if (!ds_sock.empty())
 
4192
  if (ds_sock.length)
3878
4193
  {
3879
4194
    /*
3880
4195
      If the socket is specified just as a name without path
3881
4196
      append tmpdir in front
3882
4197
    */
3883
 
    if (*ds_sock.c_str() != FN_LIBCHAR)
 
4198
    if (*ds_sock.str != FN_LIBCHAR)
3884
4199
    {
3885
4200
      char buff[FN_REFLEN];
3886
 
      fn_format(buff, ds_sock.c_str(), TMPDIR, "", 0);
3887
 
      ds_sock.clear();
3888
 
      ds_sock.append(buff);
 
4201
      fn_format(buff, ds_sock.str, TMPDIR, "", 0);
 
4202
      dynstr_set(&ds_sock, buff);
3889
4203
    }
3890
4204
  }
 
4205
  else
 
4206
  {
 
4207
    /* No socket specified, use default */
 
4208
    dynstr_set(&ds_sock, unix_sock);
 
4209
  }
 
4210
  DBUG_PRINT("info", ("socket: %s", ds_sock.str));
 
4211
 
3891
4212
 
3892
4213
  /* Options */
3893
 
  con_options= ds_options.c_str();
 
4214
  con_options= ds_options.str;
3894
4215
  while (*con_options)
3895
4216
  {
3896
 
    const char* end;
 
4217
    char* end;
3897
4218
    /* Step past any spaces in beginning of option*/
3898
4219
    while (*con_options && my_isspace(charset_info, *con_options))
3899
 
      con_options++;
 
4220
     con_options++;
3900
4221
    /* Find end of this option */
3901
4222
    end= con_options;
3902
4223
    while (*end && !my_isspace(charset_info, *end))
3906
4227
    else if (!strncmp(con_options, "COMPRESS", 8))
3907
4228
      con_compress= 1;
3908
4229
    else
3909
 
      die("Illegal option to connect: %.*s",
 
4230
      die("Illegal option to connect: %.*s", 
3910
4231
          (int) (end - con_options), con_options);
3911
4232
    /* Process next option */
3912
4233
    con_options= end;
3913
4234
  }
3914
4235
 
3915
 
  if (find_connection_by_name(ds_connection_name.c_str()))
3916
 
    die("Connection %s already exists", ds_connection_name.c_str());
3917
 
 
 
4236
  if (find_connection_by_name(ds_connection_name.str))
 
4237
    die("Connection %s already exists", ds_connection_name.str);
 
4238
    
3918
4239
  if (next_con != connections_end)
3919
 
  {
3920
4240
    con_slot= next_con;
3921
 
  }
3922
4241
  else
3923
4242
  {
3924
4243
    if (!(con_slot= find_connection_by_name("-closed_connection-")))
3926
4245
          (int) (sizeof(connections)/sizeof(struct st_connection)));
3927
4246
  }
3928
4247
 
3929
 
  if ((con_slot->drizzle= drizzle_create(NULL)) == NULL)
3930
 
    die("Failed on drizzle_create()");
3931
 
  if (!drizzle_con_create(con_slot->drizzle, &con_slot->con))
3932
 
    die("Failed on drizzle_con_create()");
 
4248
#ifdef EMBEDDED_LIBRARY
 
4249
  con_slot->query_done= 1;
 
4250
#endif
 
4251
  if (!mysql_init(&con_slot->mysql))
 
4252
    die("Failed on mysql_init()");
 
4253
  if (opt_compress || con_compress)
 
4254
    mysql_options(&con_slot->mysql, MYSQL_OPT_COMPRESS, NullS);
 
4255
  mysql_options(&con_slot->mysql, MYSQL_OPT_LOCAL_INFILE, 0);
 
4256
  mysql_options(&con_slot->mysql, MYSQL_SET_CHARSET_NAME,
 
4257
                charset_info->csname);
 
4258
  int opt_protocol= MYSQL_PROTOCOL_TCP;
 
4259
  mysql_options(&con_slot->mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
 
4260
  if (opt_charsets_dir)
 
4261
    mysql_options(&con_slot->mysql, MYSQL_SET_CHARSET_DIR,
 
4262
                  opt_charsets_dir);
3933
4263
 
3934
4264
  /* Use default db name */
3935
 
  if (ds_database.length() == 0)
3936
 
    ds_database.append(opt_db);
 
4265
  if (ds_database.length == 0)
 
4266
    dynstr_set(&ds_database, opt_db);
3937
4267
 
3938
4268
  /* Special database to allow one to connect without a database name */
3939
 
  if (ds_database.length() && !strcmp(ds_database.c_str(),"*NO-ONE*"))
3940
 
    ds_database.clear();
 
4269
  if (ds_database.length && !strcmp(ds_database.str,"*NO-ONE*"))
 
4270
    dynstr_set(&ds_database, "");
3941
4271
 
3942
 
  if (connect_n_handle_errors(command, &con_slot->con,
3943
 
                              ds_host.c_str(),ds_user.c_str(),
3944
 
                              ds_password.c_str(), ds_database.c_str(),
3945
 
                              con_port, ds_sock.c_str()))
 
4272
  if (connect_n_handle_errors(command, &con_slot->mysql,
 
4273
                              ds_host.str,ds_user.str,
 
4274
                              ds_password.str, ds_database.str,
 
4275
                              con_port, ds_sock.str))
3946
4276
  {
3947
 
    if (!(con_slot->name= strdup(ds_connection_name.c_str())))
 
4277
    DBUG_PRINT("info", ("Inserting connection %s in connection pool",
 
4278
                        ds_connection_name.str));
 
4279
    if (!(con_slot->name= my_strdup(ds_connection_name.str, MYF(MY_WME))))
3948
4280
      die("Out of memory");
3949
4281
    cur_con= con_slot;
3950
 
 
 
4282
    
3951
4283
    if (con_slot == next_con)
3952
4284
      next_con++; /* if we used the next_con slot, advance the pointer */
3953
4285
  }
3954
4286
 
3955
 
  /* Update $drizzleclient_get_server_version to that of current connection */
3956
 
  var_set_drizzleclient_get_server_version(&cur_con->con);
 
4287
  /* Update $mysql_get_server_version to that of current connection */
 
4288
  var_set_mysql_get_server_version(&cur_con->mysql);
3957
4289
 
3958
 
  return;
 
4290
  dynstr_free(&ds_connection_name);
 
4291
  dynstr_free(&ds_host);
 
4292
  dynstr_free(&ds_user);
 
4293
  dynstr_free(&ds_password);
 
4294
  dynstr_free(&ds_database);
 
4295
  dynstr_free(&ds_port);
 
4296
  dynstr_free(&ds_sock);
 
4297
  dynstr_free(&ds_options);
 
4298
  DBUG_VOID_RETURN;
3959
4299
}
3960
4300
 
3961
4301
 
3962
 
static int do_done(struct st_command *command)
 
4302
int do_done(struct st_command *command)
3963
4303
{
3964
4304
  /* Check if empty block stack */
3965
4305
  if (cur_block == block_stack)
3992
4332
  SYNOPSIS
3993
4333
  do_block()
3994
4334
  cmd        Type of block
3995
 
  q         called command
 
4335
  q            called command
3996
4336
 
3997
4337
  DESCRIPTION
3998
4338
  if ([!]<expr>)
4012
4352
 
4013
4353
*/
4014
4354
 
4015
 
static void do_block(enum block_cmd cmd, struct st_command* command)
 
4355
void do_block(enum block_cmd cmd, struct st_command* command)
4016
4356
{
4017
4357
  char *p= command->first_argument;
4018
4358
  const char *expr_start, *expr_end;
4019
4359
  VAR v;
4020
4360
  const char *cmd_name= (cmd == cmd_while ? "while" : "if");
4021
 
  bool not_expr= false;
 
4361
  my_bool not_expr= FALSE;
 
4362
  DBUG_ENTER("do_block");
 
4363
  DBUG_PRINT("enter", ("%s", cmd_name));
4022
4364
 
4023
4365
  /* Check stack overflow */
4024
4366
  if (cur_block == block_stack_end)
4033
4375
    /* Inner block should be ignored too */
4034
4376
    cur_block++;
4035
4377
    cur_block->cmd= cmd;
4036
 
    cur_block->ok= false;
4037
 
    return;
 
4378
    cur_block->ok= FALSE;
 
4379
    DBUG_VOID_RETURN;
4038
4380
  }
4039
4381
 
4040
4382
  /* Parse and evaluate test expression */
4045
4387
  /* Check for !<expr> */
4046
4388
  if (*expr_start == '!')
4047
4389
  {
4048
 
    not_expr= true;
 
4390
    not_expr= TRUE;
4049
4391
    expr_start++; /* Step past the '!' */
4050
4392
  }
4051
4393
  /* Find ending ')' */
4065
4407
  /* Define inner block */
4066
4408
  cur_block++;
4067
4409
  cur_block->cmd= cmd;
4068
 
  cur_block->ok= (v.int_val ? true : false);
 
4410
  cur_block->ok= (v.int_val ? TRUE : FALSE);
4069
4411
 
4070
4412
  if (not_expr)
4071
4413
    cur_block->ok = !cur_block->ok;
4072
4414
 
4073
 
  free(v.str_val);
4074
 
  free(v.env_s);
 
4415
  DBUG_PRINT("info", ("OK: %d", cur_block->ok));
4075
4416
 
4076
 
  return;
 
4417
  var_free(&v);
 
4418
  DBUG_VOID_RETURN;
4077
4419
}
4078
4420
 
4079
4421
 
4080
 
static void do_delimiter(struct st_command* command)
 
4422
void do_delimiter(struct st_command* command)
4081
4423
{
4082
4424
  char* p= command->first_argument;
 
4425
  DBUG_ENTER("do_delimiter");
 
4426
  DBUG_PRINT("enter", ("first_argument: %s", command->first_argument));
4083
4427
 
4084
4428
  while (*p && my_isspace(charset_info, *p))
4085
4429
    p++;
4087
4431
  if (!(*p))
4088
4432
    die("Can't set empty delimiter");
4089
4433
 
4090
 
  strncpy(delimiter, p, sizeof(delimiter) - 1);
 
4434
  strmake(delimiter, p, sizeof(delimiter) - 1);
4091
4435
  delimiter_length= strlen(delimiter);
4092
4436
 
 
4437
  DBUG_PRINT("exit", ("delimiter: %s", delimiter));
4093
4438
  command->last_argument= p + delimiter_length;
4094
 
  return;
 
4439
  DBUG_VOID_RETURN;
4095
4440
}
4096
4441
 
4097
4442
 
4098
 
bool match_delimiter(int c, const char *delim, uint32_t length)
 
4443
my_bool match_delimiter(int c, const char *delim, uint length)
4099
4444
{
4100
 
  uint32_t i;
 
4445
  uint i;
4101
4446
  char tmp[MAX_DELIMITER_LENGTH];
4102
4447
 
4103
4448
  if (c != *delim)
4104
4449
    return 0;
4105
4450
 
4106
4451
  for (i= 1; i < length &&
4107
 
         (c= my_getc(cur_file->file)) == *(delim + i);
 
4452
         (c= my_getc(cur_file->file)) == *(delim + i);
4108
4453
       i++)
4109
4454
    tmp[i]= c;
4110
4455
 
4111
4456
  if (i == length)
4112
 
    return 1;          /* Found delimiter */
 
4457
    return 1;                                   /* Found delimiter */
4113
4458
 
4114
4459
  /* didn't find delimiter, push back things that we read */
4115
4460
  my_ungetc(c);
4119
4464
}
4120
4465
 
4121
4466
 
4122
 
static bool end_of_query(int c)
 
4467
my_bool end_of_query(int c)
4123
4468
{
4124
4469
  return match_delimiter(c, delimiter, delimiter_length);
4125
4470
}
4149
4494
 
4150
4495
*/
4151
4496
 
4152
 
 
4153
 
static int my_strnncoll_simple(const CHARSET_INFO * const  cs, const unsigned char *s, size_t slen,
4154
 
                               const unsigned char *t, size_t tlen,
4155
 
                               bool t_is_prefix)
4156
 
{
4157
 
  size_t len = ( slen > tlen ) ? tlen : slen;
4158
 
  unsigned char *map= cs->sort_order;
4159
 
  if (t_is_prefix && slen > tlen)
4160
 
    slen=tlen;
4161
 
  while (len--)
4162
 
  {
4163
 
    if (map[*s++] != map[*t++])
4164
 
      return ((int) map[s[-1]] - (int) map[t[-1]]);
4165
 
  }
4166
 
  /*
4167
 
    We can't use (slen - tlen) here as the result may be outside of the
4168
 
    precision of a signed int
4169
 
  */
4170
 
  return slen > tlen ? 1 : slen < tlen ? -1 : 0 ;
4171
 
}
4172
 
 
4173
 
static int read_line(char *buf, int size)
 
4497
int read_line(char *buf, int size)
4174
4498
{
4175
4499
  char c, last_quote= 0;
4176
4500
  char *p= buf, *buf_end= buf + size - 1;
4177
4501
  int skip_char= 0;
4178
4502
  enum {R_NORMAL, R_Q, R_SLASH_IN_Q,
4179
4503
        R_COMMENT, R_LINE_START} state= R_LINE_START;
4180
 
 
 
4504
  DBUG_ENTER("read_line");
4181
4505
 
4182
4506
  start_lineno= cur_file->lineno;
 
4507
  DBUG_PRINT("info", ("Starting to read at lineno: %d", start_lineno));
4183
4508
  for (; p < buf_end ;)
4184
4509
  {
4185
4510
    skip_char= 0;
4189
4514
  found_eof:
4190
4515
      if (cur_file->file != stdin)
4191
4516
      {
4192
 
        fclose(cur_file->file);
 
4517
        my_fclose(cur_file->file, MYF(0));
4193
4518
        cur_file->file= 0;
4194
4519
      }
4195
 
      free((unsigned char*) cur_file->file_name);
 
4520
      my_free((uchar*) cur_file->file_name, MYF(MY_ALLOW_ZERO_PTR));
4196
4521
      cur_file->file_name= 0;
4197
4522
      if (cur_file == file_stack)
4198
4523
      {
4203
4528
          die("Missing end of block");
4204
4529
 
4205
4530
        *p= 0;
4206
 
        return(1);
 
4531
        DBUG_PRINT("info", ("end of file at line %d", cur_file->lineno));
 
4532
        DBUG_RETURN(1);
4207
4533
      }
4208
4534
      cur_file--;
4209
4535
      start_lineno= cur_file->lineno;
4224
4550
    case R_NORMAL:
4225
4551
      if (end_of_query(c))
4226
4552
      {
4227
 
        *p= 0;
4228
 
        return(0);
 
4553
        *p= 0;
 
4554
        DBUG_PRINT("exit", ("Found delimiter '%s' at line %d",
 
4555
                            delimiter, cur_file->lineno));
 
4556
        DBUG_RETURN(0);
4229
4557
      }
4230
4558
      else if ((c == '{' &&
4231
 
                (!my_strnncoll_simple(charset_info, (const unsigned char*) "while", 5,
4232
 
                                      (unsigned char*) buf, min((ptrdiff_t)5, p - buf), 0) ||
4233
 
                 !my_strnncoll_simple(charset_info, (const unsigned char*) "if", 2,
4234
 
                                      (unsigned char*) buf, min((ptrdiff_t)2, p - buf), 0))))
 
4559
                (!my_strnncoll_simple(charset_info, (const uchar*) "while", 5,
 
4560
                                      (uchar*) buf, min(5, p - buf), 0) ||
 
4561
                 !my_strnncoll_simple(charset_info, (const uchar*) "if", 2,
 
4562
                                      (uchar*) buf, min(2, p - buf), 0))))
4235
4563
      {
4236
4564
        /* Only if and while commands can be terminated by { */
4237
4565
        *p++= c;
4238
 
        *p= 0;
4239
 
        return(0);
 
4566
        *p= 0;
 
4567
        DBUG_PRINT("exit", ("Found '{' indicating start of block at line %d",
 
4568
                            cur_file->lineno));
 
4569
        DBUG_RETURN(0);
4240
4570
      }
4241
4571
      else if (c == '\'' || c == '"' || c == '`')
4242
4572
      {
4243
4573
        last_quote= c;
4244
 
        state= R_Q;
 
4574
        state= R_Q;
4245
4575
      }
4246
4576
      break;
4247
4577
 
4249
4579
      if (c == '\n')
4250
4580
      {
4251
4581
        /* Comments are terminated by newline */
4252
 
        *p= 0;
4253
 
        return(0);
 
4582
        *p= 0;
 
4583
        DBUG_PRINT("exit", ("Found newline in comment at line: %d",
 
4584
                            cur_file->lineno));
 
4585
        DBUG_RETURN(0);
4254
4586
      }
4255
4587
      break;
4256
4588
 
4258
4590
      if (c == '#' || c == '-')
4259
4591
      {
4260
4592
        /* A # or - in the first position of the line - this is a comment */
4261
 
        state = R_COMMENT;
 
4593
        state = R_COMMENT;
4262
4594
      }
4263
4595
      else if (my_isspace(charset_info, c))
4264
4596
      {
4265
4597
        /* Skip all space at begining of line */
4266
 
        if (c == '\n')
 
4598
        if (c == '\n')
4267
4599
        {
4268
4600
          /* Query hasn't started yet */
4269
 
          start_lineno= cur_file->lineno;
 
4601
          start_lineno= cur_file->lineno;
 
4602
          DBUG_PRINT("info", ("Query hasn't started yet, start_lineno: %d",
 
4603
                              start_lineno));
4270
4604
        }
4271
 
        skip_char= 1;
 
4605
        skip_char= 1;
4272
4606
      }
4273
4607
      else if (end_of_query(c))
4274
4608
      {
4275
 
        *p= 0;
4276
 
        return(0);
 
4609
        *p= 0;
 
4610
        DBUG_PRINT("exit", ("Found delimiter '%s' at line: %d",
 
4611
                            delimiter, cur_file->lineno));
 
4612
        DBUG_RETURN(0);
4277
4613
      }
4278
4614
      else if (c == '}')
4279
4615
      {
4280
4616
        /* A "}" need to be by itself in the begining of a line to terminate */
4281
4617
        *p++= c;
4282
 
        *p= 0;
4283
 
        return(0);
 
4618
        *p= 0;
 
4619
        DBUG_PRINT("exit", ("Found '}' in begining of a line at line: %d",
 
4620
                            cur_file->lineno));
 
4621
        DBUG_RETURN(0);
4284
4622
      }
4285
4623
      else if (c == '\'' || c == '"' || c == '`')
4286
4624
      {
4287
4625
        last_quote= c;
4288
 
        state= R_Q;
 
4626
        state= R_Q;
4289
4627
      }
4290
4628
      else
4291
 
        state= R_NORMAL;
 
4629
        state= R_NORMAL;
4292
4630
      break;
4293
4631
 
4294
4632
    case R_Q:
4295
4633
      if (c == last_quote)
4296
 
        state= R_NORMAL;
 
4634
        state= R_NORMAL;
4297
4635
      else if (c == '\\')
4298
 
        state= R_SLASH_IN_Q;
 
4636
        state= R_SLASH_IN_Q;
4299
4637
      break;
4300
4638
 
4301
4639
    case R_SLASH_IN_Q:
4308
4646
    {
4309
4647
      /* Could be a multibyte character */
4310
4648
      /* This code is based on the code in "sql_load.cc" */
 
4649
#ifdef USE_MB
4311
4650
      int charlen = my_mbcharlen(charset_info, c);
4312
4651
      /* We give up if multibyte character is started but not */
4313
4652
      /* completed before we pass buf_end */
4314
4653
      if ((charlen > 1) && (p + charlen) <= buf_end)
4315
4654
      {
4316
 
        int i;
4317
 
        char* mb_start = p;
4318
 
 
4319
 
        *p++ = c;
4320
 
 
4321
 
        for (i= 1; i < charlen; i++)
4322
 
        {
4323
 
          if (feof(cur_file->file))
4324
 
            goto found_eof;
4325
 
          c= my_getc(cur_file->file);
4326
 
          *p++ = c;
4327
 
        }
4328
 
        if (! my_ismbchar(charset_info, mb_start, p))
4329
 
        {
4330
 
          /* It was not a multiline char, push back the characters */
4331
 
          /* We leave first 'c', i.e. pretend it was a normal char */
4332
 
          while (p > mb_start)
4333
 
            my_ungetc(*--p);
4334
 
        }
 
4655
        int i;
 
4656
        char* mb_start = p;
 
4657
 
 
4658
        *p++ = c;
 
4659
 
 
4660
        for (i= 1; i < charlen; i++)
 
4661
        {
 
4662
          if (feof(cur_file->file))
 
4663
            goto found_eof;
 
4664
          c= my_getc(cur_file->file);
 
4665
          *p++ = c;
 
4666
        }
 
4667
        if (! my_ismbchar(charset_info, mb_start, p))
 
4668
        {
 
4669
          /* It was not a multiline char, push back the characters */
 
4670
          /* We leave first 'c', i.e. pretend it was a normal char */
 
4671
          while (p > mb_start)
 
4672
            my_ungetc(*--p);
 
4673
        }
4335
4674
      }
4336
4675
      else
4337
 
        *p++= c;
 
4676
#endif
 
4677
        *p++= c;
4338
4678
    }
4339
4679
  }
4340
 
  die("The input buffer is too small for this query.x\n"        \
 
4680
  die("The input buffer is too small for this query.x\n" \
4341
4681
      "check your query or increase MAX_QUERY and recompile");
4342
 
  return(0);
 
4682
  DBUG_RETURN(0);
4343
4683
}
4344
4684
 
4345
4685
 
4354
4694
 
4355
4695
*/
4356
4696
 
4357
 
static void convert_to_format_v1(char* query)
 
4697
void convert_to_format_v1(char* query)
4358
4698
{
4359
4699
  int last_c_was_quote= 0;
4360
4700
  char *p= query, *to= query;
4361
 
  char *end= strchr(query, '\0');
 
4701
  char *end= strend(query);
4362
4702
  char last_c;
4363
4703
 
4364
4704
  while (p <= end)
4397
4737
 
4398
4738
/*
4399
4739
  Check a command that is about to be sent (or should have been
4400
 
  sent if parsing was enabled) to DRIZZLE server for
 
4740
  sent if parsing was enabled) to mysql server for
4401
4741
  suspicious things and generate warnings.
4402
4742
*/
4403
4743
 
4404
 
static void scan_command_for_warnings(struct st_command *command)
 
4744
void scan_command_for_warnings(struct st_command *command)
4405
4745
{
4406
4746
  const char *ptr= command->query;
 
4747
  DBUG_ENTER("scan_command_for_warnings");
 
4748
  DBUG_PRINT("enter", ("query: %s", command->query));
4407
4749
 
4408
4750
  while(*ptr)
4409
4751
  {
4410
4752
    /*
4411
4753
      Look for query's that lines that start with a -- comment
4412
 
      and has a drizzletest command
 
4754
      and has a mysqltest command
4413
4755
    */
4414
4756
    if (ptr[0] == '\n' &&
4415
4757
        ptr[1] && ptr[1] == '-' &&
4416
4758
        ptr[2] && ptr[2] == '-' &&
4417
4759
        ptr[3])
4418
4760
    {
4419
 
      uint32_t type;
 
4761
      uint type;
4420
4762
      char save;
4421
4763
      char *end, *start= (char*)ptr+3;
4422
4764
      /* Skip leading spaces */
4428
4770
        end++;
4429
4771
      save= *end;
4430
4772
      *end= 0;
 
4773
      DBUG_PRINT("info", ("Checking '%s'", start));
4431
4774
      type= find_type(start, &command_typelib, 1+2);
4432
4775
      if (type)
4433
 
        warning_msg("Embedded drizzletest command '--%s' detected in "
 
4776
        warning_msg("Embedded mysqltest command '--%s' detected in "
4434
4777
                    "query '%s' was this intentional? ",
4435
4778
                    start, command->query);
4436
4779
      *end= save;
4438
4781
 
4439
4782
    ptr++;
4440
4783
  }
4441
 
  return;
 
4784
  DBUG_VOID_RETURN;
4442
4785
}
4443
4786
 
4444
4787
/*
4447
4790
  switching between different delimiters
4448
4791
*/
4449
4792
 
4450
 
static void check_eol_junk_line(const char *line)
 
4793
void check_eol_junk_line(const char *line)
4451
4794
{
4452
4795
  const char *p= line;
 
4796
  DBUG_ENTER("check_eol_junk_line");
 
4797
  DBUG_PRINT("enter", ("line: %s", line));
4453
4798
 
4454
4799
  /* Check for extra delimiter */
4455
4800
  if (*p && !strncmp(p, delimiter, delimiter_length))
4462
4807
      die("Missing delimiter");
4463
4808
    die("End of line junk detected: \"%s\"", p);
4464
4809
  }
4465
 
  return;
 
4810
  DBUG_VOID_RETURN;
4466
4811
}
4467
4812
 
4468
 
static void check_eol_junk(const char *eol)
 
4813
void check_eol_junk(const char *eol)
4469
4814
{
4470
4815
  const char *p= eol;
 
4816
  DBUG_ENTER("check_eol_junk");
 
4817
  DBUG_PRINT("enter", ("eol: %s", eol));
4471
4818
 
4472
4819
  /* Skip past all spacing chars and comments */
4473
4820
  while (*p && (my_isspace(charset_info, *p) || *p == '#' || *p == '\n'))
4490
4837
 
4491
4838
  check_eol_junk_line(p);
4492
4839
 
4493
 
  return;
 
4840
  DBUG_VOID_RETURN;
4494
4841
}
4495
4842
 
4496
4843
 
4499
4846
  Create a command from a set of lines
4500
4847
 
4501
4848
  SYNOPSIS
4502
 
  read_command()
4503
 
  command_ptr pointer where to return the new query
 
4849
    read_command()
 
4850
    command_ptr pointer where to return the new query
4504
4851
 
4505
4852
  DESCRIPTION
4506
 
  Converts lines returned by read_line into a command, this involves
4507
 
  parsing the first word in the read line to find the command type.
 
4853
    Converts lines returned by read_line into a command, this involves
 
4854
    parsing the first word in the read line to find the command type.
4508
4855
 
4509
4856
  A -- comment may contain a valid query as the first word after the
4510
4857
  comment start. Thus it's always checked to see if that is the case.
4515
4862
#define MAX_QUERY (256*1024*2) /* 256K -- a test in sp-big is >128K */
4516
4863
static char read_command_buf[MAX_QUERY];
4517
4864
 
4518
 
static int read_command(struct st_command** command_ptr)
 
4865
int read_command(struct st_command** command_ptr)
4519
4866
{
4520
4867
  char *p= read_command_buf;
4521
4868
  struct st_command* command;
4522
 
 
 
4869
  DBUG_ENTER("read_command");
4523
4870
 
4524
4871
  if (parser.current_line < parser.read_lines)
4525
4872
  {
4526
 
    *command_ptr= q_lines[parser.current_line];
4527
 
    return(0);
 
4873
    get_dynamic(&q_lines, (uchar*) command_ptr, parser.current_line) ;
 
4874
    DBUG_RETURN(0);
4528
4875
  }
4529
 
  if (!(*command_ptr= command= new st_command))
4530
 
    die("command construction failed");
4531
 
  q_lines.push_back(command);
 
4876
  if (!(*command_ptr= command=
 
4877
        (struct st_command*) my_malloc(sizeof(*command),
 
4878
                                       MYF(MY_WME|MY_ZEROFILL))) ||
 
4879
      insert_dynamic(&q_lines, (uchar*) &command))
 
4880
    die(NullS);
4532
4881
  command->type= Q_UNKNOWN;
4533
4882
 
4534
4883
  read_command_buf[0]= 0;
4535
4884
  if (read_line(read_command_buf, sizeof(read_command_buf)))
4536
4885
  {
4537
4886
    check_eol_junk(read_command_buf);
4538
 
    return(1);
 
4887
    DBUG_RETURN(1);
4539
4888
  }
4540
4889
 
4541
4890
  convert_to_format_v1(read_command_buf);
4542
4891
 
 
4892
  DBUG_PRINT("info", ("query: %s", read_command_buf));
4543
4893
  if (*p == '#')
4544
4894
  {
4545
4895
    command->type= Q_COMMENT;
4554
4904
  while (*p && my_isspace(charset_info, *p))
4555
4905
    p++;
4556
4906
 
4557
 
  if (!(command->query_buf= command->query= strdup(p)))
 
4907
  if (!(command->query_buf= command->query= my_strdup(p, MYF(MY_WME))))
4558
4908
    die("Out of memory");
4559
4909
 
4560
4910
  /* Calculate first word length(the command), terminated by space or ( */
4561
4911
  p= command->query;
4562
4912
  while (*p && !my_isspace(charset_info, *p) && *p != '(')
4563
4913
    p++;
4564
 
  command->first_word_len= (uint32_t) (p - command->query);
 
4914
  command->first_word_len= (uint) (p - command->query);
 
4915
  DBUG_PRINT("info", ("first_word: %.*s",
 
4916
                      command->first_word_len, command->query));
4565
4917
 
4566
4918
  /* Skip spaces between command and first argument */
4567
4919
  while (*p && my_isspace(charset_info, *p))
4568
4920
    p++;
4569
4921
  command->first_argument= p;
4570
4922
 
4571
 
  command->end= strchr(command->query, '\0');
 
4923
  command->end= strend(command->query);
4572
4924
  command->query_len= (command->end - command->query);
4573
4925
  parser.read_lines++;
4574
 
  return(0);
 
4926
  DBUG_RETURN(0);
4575
4927
}
4576
4928
 
4577
4929
 
4579
4931
{
4580
4932
  {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,
4581
4933
   0, 0, 0, 0, 0, 0},
4582
 
  {"basedir", 'b', "Basedir for tests.", (char**) &opt_basedir,
4583
 
   (char**) &opt_basedir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4934
  {"basedir", 'b', "Basedir for tests.", (uchar**) &opt_basedir,
 
4935
   (uchar**) &opt_basedir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4584
4936
  {"character-sets-dir", OPT_CHARSETS_DIR,
4585
 
   "Directory where character sets are.", (char**) &opt_charsets_dir,
4586
 
   (char**) &opt_charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4587
 
  {"database", 'D', "Database to use.", (char**) &opt_db, (char**) &opt_db, 0,
4588
 
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4589
 
  {"host", 'h', "Connect to host.", (char**) &opt_host, (char**) &opt_host, 0,
4590
 
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4591
 
  {"include", 'i', "Include SQL before each test case.", (char**) &opt_include,
4592
 
   (char**) &opt_include, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4593
 
  {"testdir", OPT_TESTDIR, "Path to use to search for test files",
4594
 
   (char**) &opt_testdir,
4595
 
   (char**) &opt_testdir, 0,GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4596
 
  {"logdir", OPT_LOG_DIR, "Directory for log files", (char**) &opt_logdir,
4597
 
   (char**) &opt_logdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4937
   "Directory where character sets are.", (uchar**) &opt_charsets_dir,
 
4938
   (uchar**) &opt_charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4939
  {"compress", 'C', "Use the compressed server/client protocol.",
 
4940
   (uchar**) &opt_compress, (uchar**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
 
4941
   0, 0, 0},
 
4942
  {"cursor-protocol", OPT_CURSOR_PROTOCOL, "Use cursors for prepared statements.",
 
4943
   (uchar**) &cursor_protocol, (uchar**) &cursor_protocol, 0,
 
4944
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
4945
  {"database", 'D', "Database to use.", (uchar**) &opt_db, (uchar**) &opt_db, 0,
 
4946
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4947
#ifdef DBUG_OFF
 
4948
  {"debug", '#', "This is a non-debug version. Catch this and exit",
 
4949
   0,0, 0, GET_DISABLED, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
4950
#else
 
4951
  {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
 
4952
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
4953
#endif
 
4954
  {"debug-check", OPT_DEBUG_CHECK, "Check memory and open file usage at exit.",
 
4955
   (uchar**) &debug_check_flag, (uchar**) &debug_check_flag, 0,
 
4956
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
4957
  {"debug-info", OPT_DEBUG_INFO, "Print some debug info at exit.",
 
4958
   (uchar**) &debug_info_flag, (uchar**) &debug_info_flag,
 
4959
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
4960
  {"host", 'h', "Connect to host.", (uchar**) &opt_host, (uchar**) &opt_host, 0,
 
4961
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4962
  {"include", 'i', "Include SQL before each test case.", (uchar**) &opt_include,
 
4963
   (uchar**) &opt_include, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4964
  {"logdir", OPT_LOG_DIR, "Directory for log files", (uchar**) &opt_logdir,
 
4965
   (uchar**) &opt_logdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4598
4966
  {"mark-progress", OPT_MARK_PROGRESS,
4599
4967
   "Write linenumber and elapsed time to <testname>.progress ",
4600
 
   (char**) &opt_mark_progress, (char**) &opt_mark_progress, 0,
 
4968
   (uchar**) &opt_mark_progress, (uchar**) &opt_mark_progress, 0,
4601
4969
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4602
4970
  {"max-connect-retries", OPT_MAX_CONNECT_RETRIES,
4603
4971
   "Max number of connection attempts when connecting to server",
4604
 
   (char**) &opt_max_connect_retries, (char**) &opt_max_connect_retries, 0,
 
4972
   (uchar**) &opt_max_connect_retries, (uchar**) &opt_max_connect_retries, 0,
4605
4973
   GET_INT, REQUIRED_ARG, 500, 1, 10000, 0, 0, 0},
4606
 
  {"password", 'P', "Password to use when connecting to server.",
 
4974
  {"password", 'p', "Password to use when connecting to server.",
4607
4975
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
4608
 
  {"port", 'p', "Port number to use for connection or 0 for default to, in "
4609
 
   "order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, "
4610
 
   "built-in default (" STRINGIFY_ARG(DRIZZLE_PORT) ").",
4611
 
   0, 0, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4612
 
  {"quiet", 's', "Suppress all normal output.", (char**) &silent,
4613
 
   (char**) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
4976
  {"port", 'P', "Port number to use for connection or 0 for default to, in "
 
4977
   "order of preference, my.cnf, $MYSQL_TCP_PORT, "
 
4978
#if MYSQL_PORT_DEFAULT == 0
 
4979
   "/etc/services, "
 
4980
#endif
 
4981
   "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",
 
4982
   (uchar**) &opt_port,
 
4983
   (uchar**) &opt_port, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4984
  {"protocol", OPT_MYSQL_PROTOCOL,
 
4985
    "The protocol of connection (tcp,socket,pipe,memory).",
 
4986
    0, 0, 0, GET_STR,  REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4987
  {"ps-protocol", OPT_PS_PROTOCOL, "Use prepared statements protocol for communication",
 
4988
   (uchar**) &ps_protocol, (uchar**) &ps_protocol, 0,
 
4989
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
4990
  {"quiet", 's', "Suppress all normal output.", (uchar**) &silent,
 
4991
   (uchar**) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4614
4992
  {"record", 'r', "Record output of test_file into result file.",
4615
4993
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
4616
4994
  {"result-file", 'R', "Read/Store result from/in this file.",
4617
 
   (char**) &result_file_name, (char**) &result_file_name, 0,
 
4995
   (uchar**) &result_file_name, (uchar**) &result_file_name, 0,
4618
4996
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4997
  {"server-arg", 'A', "Send option value to embedded server as a parameter.",
 
4998
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
4999
  {"server-file", 'F', "Read embedded server arguments from file.",
 
5000
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4619
5001
  {"silent", 's', "Suppress all normal output. Synonym for --quiet.",
4620
 
   (char**) &silent, (char**) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
5002
   (uchar**) &silent, (uchar**) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4621
5003
  {"sleep", 'T', "Sleep always this many seconds on sleep commands.",
4622
 
   (char**) &opt_sleep, (char**) &opt_sleep, 0, GET_INT, REQUIRED_ARG, -1, -1, 0,
4623
 
   0, 0, 0},
 
5004
   (uchar**) &opt_sleep, (uchar**) &opt_sleep, 0, GET_INT, REQUIRED_ARG, -1, -1, 0,
 
5005
   0, 0, 0},
 
5006
  {"socket", 'S', "Socket file to use for connection.",
 
5007
   (uchar**) &unix_sock, (uchar**) &unix_sock, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
 
5008
   0, 0, 0},
 
5009
  {"sp-protocol", OPT_SP_PROTOCOL, "Use stored procedures for select",
 
5010
   (uchar**) &sp_protocol, (uchar**) &sp_protocol, 0,
 
5011
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4624
5012
  {"tail-lines", OPT_TAIL_LINES,
4625
5013
   "Number of lines of the resul to include in a failure report",
4626
 
   (char**) &opt_tail_lines, (char**) &opt_tail_lines, 0,
 
5014
   (uchar**) &opt_tail_lines, (uchar**) &opt_tail_lines, 0,
4627
5015
   GET_INT, REQUIRED_ARG, 0, 0, 10000, 0, 0, 0},
4628
5016
  {"test-file", 'x', "Read test from/in this file (default stdin).",
4629
5017
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4631
5019
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4632
5020
  {"tmpdir", 't', "Temporary directory where sockets are put.",
4633
5021
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4634
 
  {"user", 'u', "User for login.", (char**) &opt_user, (char**) &opt_user, 0,
 
5022
  {"user", 'u', "User for login.", (uchar**) &opt_user, (uchar**) &opt_user, 0,
4635
5023
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4636
 
  {"verbose", 'v', "Write more.", (char**) &verbose, (char**) &verbose, 0,
 
5024
  {"verbose", 'v', "Write more.", (uchar**) &verbose, (uchar**) &verbose, 0,
4637
5025
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4638
5026
  {"version", 'V', "Output version information and exit.",
4639
5027
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
5028
  {"view-protocol", OPT_VIEW_PROTOCOL, "Use views for select",
 
5029
   (uchar**) &view_protocol, (uchar**) &view_protocol, 0,
 
5030
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4640
5031
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
4641
5032
};
4642
5033
 
4643
5034
 
4644
 
static void print_version(void)
 
5035
#include <help_start.h>
 
5036
 
 
5037
void print_version(void)
4645
5038
{
4646
 
  printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n",my_progname,MTEST_VERSION,
4647
 
         drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);
 
5039
  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,MTEST_VERSION,
 
5040
         MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
4648
5041
}
4649
5042
 
4650
 
static void usage(void)
 
5043
void usage()
4651
5044
{
4652
5045
  print_version();
4653
5046
  printf("MySQL AB, by Sasha, Matt, Monty & Jani\n");
4654
 
  printf("Drizzle version modified by Brian, Jay, Monty Taylor, PatG and Stewart\n");
4655
5047
  printf("This software comes with ABSOLUTELY NO WARRANTY\n\n");
4656
 
  printf("Runs a test against the DRIZZLE server and compares output with a results file.\n\n");
 
5048
  printf("Runs a test against the mysql server and compares output with a results file.\n\n");
4657
5049
  printf("Usage: %s [OPTIONS] [database] < test_file\n", my_progname);
4658
5050
  my_print_help(my_long_options);
4659
5051
  printf("  --no-defaults       Don't read default options from any options file.\n");
4660
5052
  my_print_variables(my_long_options);
4661
5053
}
4662
5054
 
4663
 
bool get_one_option(int optid, const struct my_option *, char *argument)
4664
 
{
4665
 
  char *endchar= NULL;
4666
 
  uint64_t temp_drizzle_port= 0;
4667
 
 
 
5055
#include <help_end.h>
 
5056
 
 
5057
 
 
5058
/*
 
5059
  Read arguments for embedded server and put them into
 
5060
  embedded_server_args[]
 
5061
*/
 
5062
 
 
5063
void read_embedded_server_arguments(const char *name)
 
5064
{
 
5065
  char argument[1024],buff[FN_REFLEN], *str=0;
 
5066
  FILE *file;
 
5067
 
 
5068
  if (!test_if_hard_path(name))
 
5069
  {
 
5070
    strxmov(buff, opt_basedir, name, NullS);
 
5071
    name=buff;
 
5072
  }
 
5073
  fn_format(buff, name, "", "", MY_UNPACK_FILENAME);
 
5074
 
 
5075
  if (!embedded_server_arg_count)
 
5076
  {
 
5077
    embedded_server_arg_count=1;
 
5078
    embedded_server_args[0]= (char*) "";                /* Progname */
 
5079
  }
 
5080
  if (!(file=my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(MY_WME))))
 
5081
    die("Failed to open file '%s'", buff);
 
5082
 
 
5083
  while (embedded_server_arg_count < MAX_EMBEDDED_SERVER_ARGS &&
 
5084
         (str=fgets(argument,sizeof(argument), file)))
 
5085
  {
 
5086
    *(strend(str)-1)=0;                         /* Remove end newline */
 
5087
    if (!(embedded_server_args[embedded_server_arg_count]=
 
5088
          (char*) my_strdup(str,MYF(MY_WME))))
 
5089
    {
 
5090
      my_fclose(file,MYF(0));
 
5091
      die("Out of memory");
 
5092
 
 
5093
    }
 
5094
    embedded_server_arg_count++;
 
5095
  }
 
5096
  my_fclose(file,MYF(0));
 
5097
  if (str)
 
5098
    die("Too many arguments in option file: %s",name);
 
5099
 
 
5100
  return;
 
5101
}
 
5102
 
 
5103
 
 
5104
static my_bool
 
5105
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
 
5106
               char *argument)
 
5107
{
4668
5108
  switch(optid) {
 
5109
  case '#':
 
5110
#ifndef DBUG_OFF
 
5111
    DBUG_PUSH(argument ? argument : "d:t:S:i:O,/tmp/mysqltest.trace");
 
5112
    debug_check_flag= 1;
 
5113
#endif
 
5114
    break;
4669
5115
  case 'r':
4670
5116
    record = 1;
4671
5117
    break;
4674
5120
    char buff[FN_REFLEN];
4675
5121
    if (!test_if_hard_path(argument))
4676
5122
    {
4677
 
      sprintf(buff,"%s%s",opt_basedir,argument);
 
5123
      strxmov(buff, opt_basedir, argument, NullS);
4678
5124
      argument= buff;
4679
5125
    }
4680
5126
    fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
4681
 
    assert(cur_file == file_stack && cur_file->file == 0);
4682
 
    if (!(cur_file->file= fopen(buff, "r")))
 
5127
    DBUG_ASSERT(cur_file == file_stack && cur_file->file == 0);
 
5128
    if (!(cur_file->file=
 
5129
          my_fopen(buff, O_RDONLY | FILE_BINARY, MYF(0))))
4683
5130
      die("Could not open '%s' for reading: errno = %d", buff, errno);
4684
 
    if (!(cur_file->file_name= strdup(buff)))
4685
 
      die("Out of memory");
 
5131
    cur_file->file_name= my_strdup(buff, MYF(MY_FAE));
4686
5132
    cur_file->lineno= 1;
4687
5133
    break;
4688
5134
  }
4691
5137
    static char buff[FN_REFLEN];
4692
5138
    if (!test_if_hard_path(argument))
4693
5139
    {
4694
 
      sprintf(buff,"%s%s",opt_basedir,argument);
 
5140
      strxmov(buff, opt_basedir, argument, NullS);
4695
5141
      argument= buff;
4696
5142
    }
4697
5143
    fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
4698
5144
    timer_file= buff;
4699
 
    unlink(timer_file);       /* Ignore error, may not exist */
 
5145
    unlink(timer_file);      /* Ignore error, may not exist */
4700
5146
    break;
4701
5147
  }
4702
5148
  case 'p':
4703
 
    temp_drizzle_port= (uint64_t) strtoul(argument, &endchar, 10);
4704
 
    /* if there is an alpha character this is not a valid port */
4705
 
    if (strlen(endchar) != 0)
4706
 
    {
4707
 
      fprintf(stderr, _("Non-integer value supplied for port.  If you are trying to enter a password please use --password instead.\n"));
4708
 
      exit(1);
4709
 
    }
4710
 
    /* If the port number is > 65535 it is not a valid port
4711
 
       This also helps with potential data loss casting unsigned long to a
4712
 
       uint32_t. */
4713
 
    if ((temp_drizzle_port == 0) || (temp_drizzle_port > 65535))
4714
 
    {
4715
 
      fprintf(stderr, _("Value supplied for port is not valid.\n"));
4716
 
      exit(1);
4717
 
    }
4718
 
    else
4719
 
    {
4720
 
      opt_port= (uint32_t) temp_drizzle_port;
4721
 
    }
4722
 
    break;
4723
 
  case 'P':
4724
5149
    if (argument)
4725
5150
    {
4726
 
      if (opt_pass)
4727
 
        free(opt_pass);
4728
 
      opt_pass = strdup(argument);
4729
 
      if (opt_pass == NULL)
4730
 
        die("Out of memory");
4731
 
      while (*argument)
4732
 
      {
4733
 
        /* Overwriting password with 'x' */
4734
 
        *argument++= 'x';
4735
 
      }
 
5151
      my_free(opt_pass, MYF(MY_ALLOW_ZERO_PTR));
 
5152
      opt_pass= my_strdup(argument, MYF(MY_FAE));
 
5153
      while (*argument) *argument++= 'x';               /* Destroy argument */
4736
5154
      tty_password= 0;
4737
5155
    }
4738
5156
    else
4739
5157
      tty_password= 1;
4740
5158
    break;
4741
5159
  case 't':
4742
 
    strncpy(TMPDIR, argument, sizeof(TMPDIR));
 
5160
    strnmov(TMPDIR, argument, sizeof(TMPDIR));
 
5161
    break;
 
5162
  case 'A':
 
5163
    if (!embedded_server_arg_count)
 
5164
    {
 
5165
      embedded_server_arg_count=1;
 
5166
      embedded_server_args[0]= (char*) "";
 
5167
    }
 
5168
    if (embedded_server_arg_count == MAX_EMBEDDED_SERVER_ARGS-1 ||
 
5169
        !(embedded_server_args[embedded_server_arg_count++]=
 
5170
          my_strdup(argument, MYF(MY_FAE))))
 
5171
    {
 
5172
      die("Can't use server argument");
 
5173
    }
 
5174
    break;
 
5175
  case 'F':
 
5176
    read_embedded_server_arguments(argument);
4743
5177
    break;
4744
5178
  case 'V':
4745
5179
    print_version();
4752
5186
}
4753
5187
 
4754
5188
 
4755
 
static int parse_args(int argc, char **argv)
 
5189
int parse_args(int argc, char **argv)
4756
5190
{
4757
 
  load_defaults("drizzle",load_default_groups,&argc,&argv);
 
5191
  load_defaults("my",load_default_groups,&argc,&argv);
4758
5192
  default_argv= argv;
4759
5193
 
4760
5194
  if ((handle_options(&argc, &argv, my_long_options, get_one_option)))
4768
5202
  if (argc == 1)
4769
5203
    opt_db= *argv;
4770
5204
  if (tty_password)
4771
 
    opt_pass= client_get_tty_password(NULL);          /* purify tested */
 
5205
    opt_pass= get_tty_password(NullS);          /* purify tested */
 
5206
  if (debug_info_flag)
 
5207
    my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;
 
5208
  if (debug_check_flag)
 
5209
    my_end_arg= MY_CHECK_ERROR;
4772
5210
 
4773
5211
  return 0;
4774
5212
}
4784
5222
  append - append to file instead of overwriting old file
4785
5223
*/
4786
5224
 
4787
 
void str_to_file2(const char *fname, const char *str, int size, bool append)
 
5225
void str_to_file2(const char *fname, char *str, int size, my_bool append)
4788
5226
{
4789
5227
  int fd;
4790
5228
  char buff[FN_REFLEN];
4791
5229
  int flags= O_WRONLY | O_CREAT;
4792
5230
  if (!test_if_hard_path(fname))
4793
5231
  {
4794
 
    sprintf(buff,"%s%s",opt_basedir,fname);
 
5232
    strxmov(buff, opt_basedir, fname, NullS);
4795
5233
    fname= buff;
4796
5234
  }
4797
5235
  fn_format(buff, fname, "", "", MY_UNPACK_FILENAME);
4801
5239
  if ((fd= my_open(buff, flags,
4802
5240
                   MYF(MY_WME | MY_FFNF))) < 0)
4803
5241
    die("Could not open '%s' for writing: errno = %d", buff, errno);
4804
 
  if (append && lseek(fd, 0, SEEK_END) == MY_FILEPOS_ERROR)
 
5242
  if (append && my_seek(fd, 0, SEEK_END, MYF(0)) == MY_FILEPOS_ERROR)
4805
5243
    die("Could not find end of file '%s': errno = %d", buff, errno);
4806
 
  if (my_write(fd, (unsigned char*)str, size, MYF(MY_WME|MY_FNABP)))
 
5244
  if (my_write(fd, (uchar*)str, size, MYF(MY_WME|MY_FNABP)))
4807
5245
    die("write failed");
4808
5246
  my_close(fd, MYF(0));
4809
5247
}
4818
5256
  size - size of content witten to file
4819
5257
*/
4820
5258
 
4821
 
void str_to_file(const char *fname, const char *str, int size)
 
5259
void str_to_file(const char *fname, char *str, int size)
4822
5260
{
4823
 
  str_to_file2(fname, str, size, false);
 
5261
  str_to_file2(fname, str, size, FALSE);
4824
5262
}
4825
5263
 
4826
5264
 
4827
 
void dump_result_to_log_file(const char *buf, int size)
 
5265
void dump_result_to_log_file(char *buf, int size)
4828
5266
{
4829
5267
  char log_file[FN_REFLEN];
4830
5268
  str_to_file(fn_format(log_file, result_file_name, opt_logdir, ".log",
4842
5280
                        opt_logdir, ".progress",
4843
5281
                        *opt_logdir ? MY_REPLACE_DIR | MY_REPLACE_EXT :
4844
5282
                        MY_REPLACE_EXT),
4845
 
              ds_progress.c_str(), ds_progress.length());
 
5283
              ds_progress.str, ds_progress.length);
4846
5284
}
4847
5285
 
4848
5286
void dump_warning_messages(void)
4852
5290
  str_to_file(fn_format(warn_file, result_file_name, opt_logdir, ".warnings",
4853
5291
                        *opt_logdir ? MY_REPLACE_DIR | MY_REPLACE_EXT :
4854
5292
                        MY_REPLACE_EXT),
4855
 
              ds_warning_messages.c_str(), ds_warning_messages.length());
4856
 
}
4857
 
 
 
5293
              ds_warning_messages.str, ds_warning_messages.length);
 
5294
}
 
5295
 
 
5296
void check_regerr(my_regex_t* r, int err)
 
5297
{
 
5298
  char err_buf[1024];
 
5299
 
 
5300
  if (err)
 
5301
  {
 
5302
    my_regerror(err,r,err_buf,sizeof(err_buf));
 
5303
    die("Regex error: %s\n", err_buf);
 
5304
  }
 
5305
}
4858
5306
 
4859
5307
/*
4860
5308
  Append the result for one field to the dynamic string ds
4861
5309
*/
4862
5310
 
4863
 
static void append_field(string *ds, uint32_t col_idx, drizzle_column_st *column,
4864
 
                         const char* val, uint64_t len, bool is_null)
 
5311
void append_field(DYNAMIC_STRING *ds, uint col_idx, MYSQL_FIELD* field,
 
5312
                  const char* val, ulonglong len, my_bool is_null)
4865
5313
{
4866
5314
  if (col_idx < max_replace_column && replace_column[col_idx])
4867
5315
  {
4877
5325
  if (!display_result_vertically)
4878
5326
  {
4879
5327
    if (col_idx)
4880
 
      ds->append("\t");
4881
 
    replace_append_mem(ds, val, (int)len);
 
5328
      dynstr_append_mem(ds, "\t", 1);
 
5329
    replace_dynstr_append_mem(ds, val, (int)len);
4882
5330
  }
4883
5331
  else
4884
5332
  {
4885
 
    ds->append(drizzle_column_name(column));
4886
 
    ds->append("\t");
4887
 
    replace_append_mem(ds, val, (int)len);
4888
 
    ds->append("\n");
 
5333
    dynstr_append(ds, field->name);
 
5334
    dynstr_append_mem(ds, "\t", 1);
 
5335
    replace_dynstr_append_mem(ds, val, (int)len);
 
5336
    dynstr_append_mem(ds, "\n", 1);
4889
5337
  }
4890
5338
}
4891
5339
 
4895
5343
  Values may be converted with 'replace_column'
4896
5344
*/
4897
5345
 
4898
 
static void append_result(string *ds, drizzle_result_st *res)
 
5346
void append_result(DYNAMIC_STRING *ds, MYSQL_RES *res)
4899
5347
{
4900
 
  drizzle_row_t row;
4901
 
  uint32_t num_fields= drizzle_result_column_count(res);
4902
 
  drizzle_column_st *column;
4903
 
  size_t *lengths;
 
5348
  MYSQL_ROW row;
 
5349
  uint num_fields= mysql_num_fields(res);
 
5350
  MYSQL_FIELD *fields= mysql_fetch_fields(res);
 
5351
  ulong *lengths;
4904
5352
 
4905
 
  while ((row = drizzle_row_next(res)))
 
5353
  while ((row = mysql_fetch_row(res)))
4906
5354
  {
4907
 
    uint32_t i;
4908
 
    lengths = drizzle_row_field_sizes(res);
4909
 
    drizzle_column_seek(res, 0);
 
5355
    uint i;
 
5356
    lengths = mysql_fetch_lengths(res);
4910
5357
    for (i = 0; i < num_fields; i++)
4911
 
    {
4912
 
      column= drizzle_column_next(res);
4913
 
      append_field(ds, i, column,
 
5358
      append_field(ds, i, &fields[i],
4914
5359
                   (const char*)row[i], lengths[i], !row[i]);
4915
 
    }
4916
 
    if (!display_result_vertically)
4917
 
      ds->append("\n");
4918
 
 
4919
 
  }
 
5360
    if (!display_result_vertically)
 
5361
      dynstr_append_mem(ds, "\n", 1);
 
5362
  }
 
5363
}
 
5364
 
 
5365
 
 
5366
/*
 
5367
  Append all results from ps execution to the dynamic string separated
 
5368
  with '\t'. Values may be converted with 'replace_column'
 
5369
*/
 
5370
 
 
5371
void append_stmt_result(DYNAMIC_STRING *ds, MYSQL_STMT *stmt,
 
5372
                        MYSQL_FIELD *fields, uint num_fields)
 
5373
{
 
5374
  MYSQL_BIND *my_bind;
 
5375
  my_bool *is_null;
 
5376
  ulong *length;
 
5377
  uint i;
 
5378
 
 
5379
  /* Allocate array with bind structs, lengths and NULL flags */
 
5380
  my_bind= (MYSQL_BIND*) my_malloc(num_fields * sizeof(MYSQL_BIND),
 
5381
                                MYF(MY_WME | MY_FAE | MY_ZEROFILL));
 
5382
  length= (ulong*) my_malloc(num_fields * sizeof(ulong),
 
5383
                             MYF(MY_WME | MY_FAE));
 
5384
  is_null= (my_bool*) my_malloc(num_fields * sizeof(my_bool),
 
5385
                                MYF(MY_WME | MY_FAE));
 
5386
 
 
5387
  /* Allocate data for the result of each field */
 
5388
  for (i= 0; i < num_fields; i++)
 
5389
  {
 
5390
    uint max_length= fields[i].max_length + 1;
 
5391
    my_bind[i].buffer_type= MYSQL_TYPE_STRING;
 
5392
    my_bind[i].buffer= (char *)my_malloc(max_length, MYF(MY_WME | MY_FAE));
 
5393
    my_bind[i].buffer_length= max_length;
 
5394
    my_bind[i].is_null= &is_null[i];
 
5395
    my_bind[i].length= &length[i];
 
5396
 
 
5397
    DBUG_PRINT("bind", ("col[%d]: buffer_type: %d, buffer_length: %lu",
 
5398
                        i, my_bind[i].buffer_type, my_bind[i].buffer_length));
 
5399
  }
 
5400
 
 
5401
  if (mysql_stmt_bind_result(stmt, my_bind))
 
5402
    die("mysql_stmt_bind_result failed: %d: %s",
 
5403
        mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
 
5404
 
 
5405
  while (mysql_stmt_fetch(stmt) == 0)
 
5406
  {
 
5407
    for (i= 0; i < num_fields; i++)
 
5408
      append_field(ds, i, &fields[i], (const char *) my_bind[i].buffer,
 
5409
                   *my_bind[i].length, *my_bind[i].is_null);
 
5410
    if (!display_result_vertically)
 
5411
      dynstr_append_mem(ds, "\n", 1);
 
5412
  }
 
5413
 
 
5414
  if (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
 
5415
    die("fetch didn't end with MYSQL_NO_DATA from statement: %d %s",
 
5416
        mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
 
5417
 
 
5418
  for (i= 0; i < num_fields; i++)
 
5419
  {
 
5420
    /* Free data for output */
 
5421
    my_free(my_bind[i].buffer, MYF(MY_WME | MY_FAE));
 
5422
  }
 
5423
  /* Free array with bind structs, lengths and NULL flags */
 
5424
  my_free(my_bind    , MYF(MY_WME | MY_FAE));
 
5425
  my_free(length  , MYF(MY_WME | MY_FAE));
 
5426
  my_free(is_null , MYF(MY_WME | MY_FAE));
4920
5427
}
4921
5428
 
4922
5429
 
4924
5431
  Append metadata for fields to output
4925
5432
*/
4926
5433
 
4927
 
static void append_metadata(string *ds, drizzle_result_st *res)
 
5434
void append_metadata(DYNAMIC_STRING *ds,
 
5435
                     MYSQL_FIELD *field,
 
5436
                     uint num_fields)
4928
5437
{
4929
 
  drizzle_column_st *column;
4930
 
  ds->append("Catalog\tDatabase\tTable\tTable_alias\tColumn\t"
4931
 
             "Column_alias\tType\tLength\tMax length\tIs_null\t"
4932
 
             "Flags\tDecimals\tCharsetnr\n");
 
5438
  MYSQL_FIELD *field_end;
 
5439
  dynstr_append(ds,"Catalog\tDatabase\tTable\tTable_alias\tColumn\t"
 
5440
                "Column_alias\tType\tLength\tMax length\tIs_null\t"
 
5441
                "Flags\tDecimals\tCharsetnr\n");
4933
5442
 
4934
 
  drizzle_column_seek(res, 0);
4935
 
  while ((column= drizzle_column_next(res)))
 
5443
  for (field_end= field+num_fields ;
 
5444
       field < field_end ;
 
5445
       field++)
4936
5446
  {
4937
 
    ds->append(drizzle_column_catalog(column),
4938
 
               strlen(drizzle_column_catalog(column)));
4939
 
    ds->append("\t", 1);
4940
 
    ds->append(drizzle_column_db(column), strlen(drizzle_column_db(column)));
4941
 
    ds->append("\t", 1);
4942
 
    ds->append(drizzle_column_orig_table(column),
4943
 
               strlen(drizzle_column_orig_table(column)));
4944
 
    ds->append("\t", 1);
4945
 
    ds->append(drizzle_column_table(column),
4946
 
               strlen(drizzle_column_table(column)));
4947
 
    ds->append("\t", 1);
4948
 
    ds->append(drizzle_column_orig_name(column),
4949
 
               strlen(drizzle_column_orig_name(column)));
4950
 
    ds->append("\t", 1);
4951
 
    ds->append(drizzle_column_name(column),
4952
 
               strlen(drizzle_column_name(column)));
4953
 
    ds->append("\t", 1);
4954
 
    replace_append_uint(ds, drizzle_column_type_drizzle(column));
4955
 
    ds->append("\t", 1);
4956
 
    replace_append_uint(ds, drizzle_column_size(column));
4957
 
    ds->append("\t", 1);
4958
 
    replace_append_uint(ds, drizzle_column_max_size(column));
4959
 
    ds->append("\t", 1);
4960
 
    ds->append((char*) ((drizzle_column_flags(column) & DRIZZLE_COLUMN_FLAGS_NOT_NULL) ? "N" : "Y"), 1);
4961
 
    ds->append("\t", 1);
4962
 
    replace_append_uint(ds, drizzle_column_flags(column));
4963
 
    ds->append("\t", 1);
4964
 
    replace_append_uint(ds, drizzle_column_decimals(column));
4965
 
    ds->append("\t", 1);
4966
 
    replace_append_uint(ds, drizzle_column_charset(column));
4967
 
    ds->append("\n", 1);
 
5447
    dynstr_append_mem(ds, field->catalog,
 
5448
                      field->catalog_length);
 
5449
    dynstr_append_mem(ds, "\t", 1);
 
5450
    dynstr_append_mem(ds, field->db, field->db_length);
 
5451
    dynstr_append_mem(ds, "\t", 1);
 
5452
    dynstr_append_mem(ds, field->org_table,
 
5453
                      field->org_table_length);
 
5454
    dynstr_append_mem(ds, "\t", 1);
 
5455
    dynstr_append_mem(ds, field->table,
 
5456
                      field->table_length);
 
5457
    dynstr_append_mem(ds, "\t", 1);
 
5458
    dynstr_append_mem(ds, field->org_name,
 
5459
                      field->org_name_length);
 
5460
    dynstr_append_mem(ds, "\t", 1);
 
5461
    dynstr_append_mem(ds, field->name, field->name_length);
 
5462
    dynstr_append_mem(ds, "\t", 1);
 
5463
    replace_dynstr_append_uint(ds, field->type);
 
5464
    dynstr_append_mem(ds, "\t", 1);
 
5465
    replace_dynstr_append_uint(ds, field->length);
 
5466
    dynstr_append_mem(ds, "\t", 1);
 
5467
    replace_dynstr_append_uint(ds, field->max_length);
 
5468
    dynstr_append_mem(ds, "\t", 1);
 
5469
    dynstr_append_mem(ds, (char*) (IS_NOT_NULL(field->flags) ?
 
5470
                                   "N" : "Y"), 1);
 
5471
    dynstr_append_mem(ds, "\t", 1);
 
5472
    replace_dynstr_append_uint(ds, field->flags);
 
5473
    dynstr_append_mem(ds, "\t", 1);
 
5474
    replace_dynstr_append_uint(ds, field->decimals);
 
5475
    dynstr_append_mem(ds, "\t", 1);
 
5476
    replace_dynstr_append_uint(ds, field->charsetnr);
 
5477
    dynstr_append_mem(ds, "\n", 1);
4968
5478
  }
4969
5479
}
4970
5480
 
4973
5483
  Append affected row count and other info to output
4974
5484
*/
4975
5485
 
4976
 
static void append_info(string *ds, uint64_t affected_rows,
4977
 
                        const char *info)
 
5486
void append_info(DYNAMIC_STRING *ds, ulonglong affected_rows,
 
5487
                 const char *info)
4978
5488
{
4979
 
  ostringstream buf;
4980
 
  buf << "affected rows: " << affected_rows << endl;
4981
 
  ds->append(buf.str());
4982
 
  if (info && strcmp(info, ""))
 
5489
  char buf[40], buff2[21];
 
5490
  sprintf(buf,"affected rows: %s\n", llstr(affected_rows, buff2));
 
5491
  dynstr_append(ds, buf);
 
5492
  if (info)
4983
5493
  {
4984
 
    ds->append("info: ");
4985
 
    ds->append(info);
4986
 
    ds->append("\n", 1);
 
5494
    dynstr_append(ds, "info: ");
 
5495
    dynstr_append(ds, info);
 
5496
    dynstr_append_mem(ds, "\n", 1);
4987
5497
  }
4988
5498
}
4989
5499
 
4992
5502
  Display the table headings with the names tab separated
4993
5503
*/
4994
5504
 
4995
 
static void append_table_headings(string *ds, drizzle_result_st *res)
 
5505
void append_table_headings(DYNAMIC_STRING *ds,
 
5506
                           MYSQL_FIELD *field,
 
5507
                           uint num_fields)
4996
5508
{
4997
 
  uint32_t col_idx= 0;
4998
 
  drizzle_column_st *column;
4999
 
  drizzle_column_seek(res, 0);
5000
 
  while ((column= drizzle_column_next(res)))
 
5509
  uint col_idx;
 
5510
  for (col_idx= 0; col_idx < num_fields; col_idx++)
5001
5511
  {
5002
5512
    if (col_idx)
5003
 
      ds->append("\t", 1);
5004
 
    replace_append(ds, drizzle_column_name(column));
5005
 
    col_idx++;
 
5513
      dynstr_append_mem(ds, "\t", 1);
 
5514
    replace_dynstr_append(ds, field[col_idx].name);
5006
5515
  }
5007
 
  ds->append("\n", 1);
 
5516
  dynstr_append_mem(ds, "\n", 1);
5008
5517
}
5009
5518
 
5010
5519
/*
5014
5523
  Number of warnings appended to ds
5015
5524
*/
5016
5525
 
5017
 
static int append_warnings(string *ds, drizzle_con_st *con,
5018
 
                           drizzle_result_st *res)
 
5526
int append_warnings(DYNAMIC_STRING *ds, MYSQL* mysql)
5019
5527
{
5020
 
  uint32_t count;
5021
 
  drizzle_result_st warn_res;
5022
 
  drizzle_return_t ret;
5023
 
 
5024
 
 
5025
 
  if (!(count= drizzle_result_warning_count(res)))
5026
 
    return(0);
5027
 
 
5028
 
  if (drizzle_query_str(con, &warn_res, "SHOW WARNINGS", &ret) == NULL ||
5029
 
      ret != DRIZZLE_RETURN_OK)
5030
 
  {
5031
 
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
5032
 
      die("Error running query \"SHOW WARNINGS\": %s", drizzle_result_error(&warn_res));
5033
 
    else
5034
 
      die("Error running query \"SHOW WARNINGS\": %s", drizzle_con_error(con));
5035
 
  }
5036
 
 
5037
 
  if (drizzle_result_column_count(&warn_res) == 0 ||
5038
 
      drizzle_result_buffer(&warn_res) != DRIZZLE_RETURN_OK)
5039
 
    die("Warning count is %u but didn't get any warnings", count);
5040
 
 
5041
 
  append_result(ds, &warn_res);
5042
 
  drizzle_result_free(&warn_res);
5043
 
 
5044
 
  return(count);
 
5528
  uint count;
 
5529
  MYSQL_RES *warn_res;
 
5530
  DBUG_ENTER("append_warnings");
 
5531
 
 
5532
  if (!(count= mysql_warning_count(mysql)))
 
5533
    DBUG_RETURN(0);
 
5534
 
 
5535
  /*
 
5536
    If one day we will support execution of multi-statements
 
5537
    through PS API we should not issue SHOW WARNINGS until
 
5538
    we have not read all results...
 
5539
  */
 
5540
  DBUG_ASSERT(!mysql_more_results(mysql));
 
5541
 
 
5542
  if (mysql_real_query(mysql, "SHOW WARNINGS", 13))
 
5543
    die("Error running query \"SHOW WARNINGS\": %s", mysql_error(mysql));
 
5544
 
 
5545
  if (!(warn_res= mysql_store_result(mysql)))
 
5546
    die("Warning count is %u but didn't get any warnings",
 
5547
        count);
 
5548
 
 
5549
  append_result(ds, warn_res);
 
5550
  mysql_free_result(warn_res);
 
5551
 
 
5552
  DBUG_PRINT("warnings", ("%s", ds->str));
 
5553
 
 
5554
  DBUG_RETURN(count);
5045
5555
}
5046
5556
 
5047
5557
 
5048
5558
/*
5049
 
  Run query using DRIZZLE C API
 
5559
  Run query using MySQL C API
5050
5560
 
5051
5561
  SYNOPSIS
5052
 
  run_query_normal()
5053
 
  drizzle  DRIZZLE handle
5054
 
  command  current command pointer
5055
 
  flags  flags indicating if we should SEND and/or REAP
5056
 
  query  query string to execute
5057
 
  query_len  length query string to execute
5058
 
  ds    output buffer where to store result form query
 
5562
    run_query_normal()
 
5563
    mysql       mysql handle
 
5564
    command     current command pointer
 
5565
    flags       flags indicating if we should SEND and/or REAP
 
5566
    query       query string to execute
 
5567
    query_len   length query string to execute
 
5568
    ds          output buffer where to store result form query
5059
5569
*/
5060
5570
 
5061
 
static void run_query_normal(struct st_connection *cn,
5062
 
                             struct st_command *command,
5063
 
                             int flags, char *query, int query_len,
5064
 
                             string *ds, string *ds_warnings)
 
5571
void run_query_normal(struct st_connection *cn, struct st_command *command,
 
5572
                      int flags, char *query, int query_len,
 
5573
                      DYNAMIC_STRING *ds, DYNAMIC_STRING *ds_warnings)
5065
5574
{
5066
 
  drizzle_result_st res;
5067
 
  drizzle_return_t ret;
5068
 
  drizzle_con_st *con= &cn->con;
5069
 
  int err= 0;
5070
 
 
5071
 
  drizzle_con_add_options(con, DRIZZLE_CON_NO_RESULT_READ);
 
5575
  MYSQL_RES *res= 0;
 
5576
  MYSQL *mysql= &cn->mysql;
 
5577
  int err= 0, counter= 0;
 
5578
  DBUG_ENTER("run_query_normal");
 
5579
  DBUG_PRINT("enter",("flags: %d", flags));
 
5580
  DBUG_PRINT("enter", ("query: '%-.60s'", query));
5072
5581
 
5073
5582
  if (flags & QUERY_SEND_FLAG)
5074
5583
  {
5075
5584
    /*
5076
 
     * Send the query
5077
 
     */
5078
 
 
5079
 
    (void) drizzle_query(con, &res, query, query_len, &ret);
5080
 
    if (ret != DRIZZLE_RETURN_OK)
 
5585
      Send the query
 
5586
    */
 
5587
    if (do_send_query(cn, query, query_len, flags))
5081
5588
    {
5082
 
      if (ret == DRIZZLE_RETURN_ERROR_CODE ||
5083
 
          ret == DRIZZLE_RETURN_HANDSHAKE_FAILED)
5084
 
      {
5085
 
        err= drizzle_result_error_code(&res);
5086
 
        handle_error(command, err, drizzle_result_error(&res),
5087
 
                     drizzle_result_sqlstate(&res), ds);
5088
 
        if (ret == DRIZZLE_RETURN_ERROR_CODE)
5089
 
          drizzle_result_free(&res);
5090
 
      }
5091
 
      else
5092
 
      {
5093
 
        handle_error(command, ret, drizzle_con_error(con), "", ds);
5094
 
        err= ret;
5095
 
      }
 
5589
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
 
5590
                   mysql_sqlstate(mysql), ds);
5096
5591
      goto end;
5097
5592
    }
5098
5593
  }
 
5594
#ifdef EMBEDDED_LIBRARY
 
5595
  /*
 
5596
    Here we handle 'reap' command, so we need to check if the
 
5597
    query's thread was finished and probably wait
 
5598
  */
 
5599
  else if (flags & QUERY_REAP_FLAG)
 
5600
    wait_query_thread_end(cn);
 
5601
#endif /*EMBEDDED_LIBRARY*/
5099
5602
  if (!(flags & QUERY_REAP_FLAG))
5100
 
    return;
 
5603
    DBUG_VOID_RETURN;
5101
5604
 
 
5605
  do
5102
5606
  {
5103
5607
    /*
5104
 
     * Read the result packet
5105
 
     */
5106
 
    if (drizzle_result_read(con, &res, &ret) == NULL ||
5107
 
        ret != DRIZZLE_RETURN_OK)
 
5608
      When  on first result set, call mysql_read_query_result to retrieve
 
5609
      answer to the query sent earlier
 
5610
    */
 
5611
    if ((counter==0) && mysql_read_query_result(mysql))
5108
5612
    {
5109
 
      if (ret == DRIZZLE_RETURN_ERROR_CODE)
5110
 
      {
5111
 
        handle_error(command, drizzle_result_error_code(&res),
5112
 
                     drizzle_result_error(&res), drizzle_result_sqlstate(&res),
5113
 
                     ds);
5114
 
      }
5115
 
      else
5116
 
        handle_error(command, ret, drizzle_con_error(con), "", ds);
5117
 
      drizzle_result_free(&res);
5118
 
      err= ret;
 
5613
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
 
5614
                   mysql_sqlstate(mysql), ds);
5119
5615
      goto end;
 
5616
 
5120
5617
    }
5121
5618
 
5122
5619
    /*
5123
5620
      Store the result of the query if it will return any fields
5124
5621
    */
5125
 
    if (drizzle_result_column_count(&res) &&
5126
 
        (ret= drizzle_result_buffer(&res)) != DRIZZLE_RETURN_OK)
 
5622
    if (mysql_field_count(mysql) && ((res= mysql_store_result(mysql)) == 0))
5127
5623
    {
5128
 
      if (ret == DRIZZLE_RETURN_ERROR_CODE)
5129
 
      {
5130
 
        handle_error(command, drizzle_result_error_code(&res),
5131
 
                     drizzle_result_error(&res), drizzle_result_sqlstate(&res),
5132
 
                     ds);
5133
 
      }
5134
 
      else
5135
 
        handle_error(command, ret, drizzle_con_error(con), "", ds);
5136
 
      drizzle_result_free(&res);
5137
 
      err= ret;
 
5624
      handle_error(command, mysql_errno(mysql), mysql_error(mysql),
 
5625
                   mysql_sqlstate(mysql), ds);
5138
5626
      goto end;
5139
5627
    }
5140
5628
 
5141
5629
    if (!disable_result_log)
5142
5630
    {
5143
 
      uint64_t affected_rows= 0;    /* Ok to be undef if 'disable_info' is set */
 
5631
      ulonglong affected_rows= 0;    /* Ok to be undef if 'disable_info' is set */
5144
5632
 
5145
 
      if (drizzle_result_column_count(&res))
 
5633
      if (res)
5146
5634
      {
5147
 
        if (display_metadata)
5148
 
          append_metadata(ds, &res);
5149
 
 
5150
 
        if (!display_result_vertically)
5151
 
          append_table_headings(ds, &res);
5152
 
 
5153
 
        append_result(ds, &res);
 
5635
        MYSQL_FIELD *fields= mysql_fetch_fields(res);
 
5636
        uint num_fields= mysql_num_fields(res);
 
5637
 
 
5638
        if (display_metadata)
 
5639
          append_metadata(ds, fields, num_fields);
 
5640
 
 
5641
        if (!display_result_vertically)
 
5642
          append_table_headings(ds, fields, num_fields);
 
5643
 
 
5644
        append_result(ds, res);
5154
5645
      }
5155
5646
 
5156
5647
      /*
5157
 
        Need to call drizzle_result_affected_rows() before the "new"
 
5648
        Need to call mysql_affected_rows() before the "new"
5158
5649
        query to find the warnings
5159
5650
      */
5160
5651
      if (!disable_info)
5161
 
        affected_rows= drizzle_result_affected_rows(&res);
 
5652
        affected_rows= mysql_affected_rows(mysql);
5162
5653
 
5163
5654
      /*
5164
5655
        Add all warnings to the result. We can't do this if we are in
5165
5656
        the middle of processing results from multi-statement, because
5166
5657
        this will break protocol.
5167
5658
      */
5168
 
      if (!disable_warnings)
 
5659
      if (!disable_warnings && !mysql_more_results(mysql))
5169
5660
      {
5170
 
        drizzle_con_remove_options(con, DRIZZLE_CON_NO_RESULT_READ);
5171
 
        if (append_warnings(ds_warnings, con, &res) || ds_warnings->length())
5172
 
        {
5173
 
          ds->append("Warnings:\n", 10);
5174
 
          ds->append(ds_warnings->c_str(), ds_warnings->length());
5175
 
        }
 
5661
        if (append_warnings(ds_warnings, mysql) || ds_warnings->length)
 
5662
        {
 
5663
          dynstr_append_mem(ds, "Warnings:\n", 10);
 
5664
          dynstr_append_mem(ds, ds_warnings->str, ds_warnings->length);
 
5665
        }
5176
5666
      }
5177
5667
 
5178
5668
      if (!disable_info)
5179
 
        append_info(ds, affected_rows, drizzle_result_info(&res));
 
5669
        append_info(ds, affected_rows, mysql_info(mysql));
5180
5670
    }
5181
5671
 
5182
 
    drizzle_result_free(&res);
 
5672
    if (res)
 
5673
    {
 
5674
      mysql_free_result(res);
 
5675
      res= 0;
 
5676
    }
 
5677
    counter++;
 
5678
  } while (!(err= mysql_next_result(mysql)));
 
5679
  if (err > 0)
 
5680
  {
 
5681
    /* We got an error from mysql_next_result, maybe expected */
 
5682
    handle_error(command, mysql_errno(mysql), mysql_error(mysql),
 
5683
                 mysql_sqlstate(mysql), ds);
 
5684
    goto end;
5183
5685
  }
 
5686
  DBUG_ASSERT(err == -1); /* Successful and there are no more results */
5184
5687
 
5185
5688
  /* If we come here the query is both executed and read successfully */
5186
5689
  handle_no_error(command);
5188
5691
end:
5189
5692
 
5190
5693
  /*
5191
 
    We save the return code (drizzleclient_errno(drizzle)) from the last call sent
5192
 
    to the server into the drizzletest builtin variable $drizzleclient_errno. This
 
5694
    We save the return code (mysql_errno(mysql)) from the last call sent
 
5695
    to the server into the mysqltest builtin variable $mysql_errno. This
5193
5696
    variable then can be used from the test case itself.
5194
5697
  */
5195
 
  drizzle_con_remove_options(con, DRIZZLE_CON_NO_RESULT_READ);
5196
 
  var_set_errno(err);
5197
 
  return;
 
5698
  var_set_errno(mysql_errno(mysql));
 
5699
  DBUG_VOID_RETURN;
5198
5700
}
5199
5701
 
5200
5702
 
5210
5712
  ds    - dynamic string which is used for output buffer
5211
5713
 
5212
5714
  NOTE
5213
 
  If there is an unexpected error this function will abort drizzletest
5214
 
  immediately.
 
5715
    If there is an unexpected error this function will abort mysqltest
 
5716
    immediately.
5215
5717
*/
5216
5718
 
5217
5719
void handle_error(struct st_command *command,
5218
5720
                  unsigned int err_errno, const char *err_error,
5219
 
                  const char *err_sqlstate, string *ds)
 
5721
                  const char *err_sqlstate, DYNAMIC_STRING *ds)
5220
5722
{
5221
 
  uint32_t i;
5222
 
 
5223
 
 
5224
 
  if (! command->require_file.empty())
 
5723
  uint i;
 
5724
 
 
5725
  DBUG_ENTER("handle_error");
 
5726
 
 
5727
  if (command->require_file[0])
5225
5728
  {
5226
5729
    /*
5227
5730
      The query after a "--require" failed. This is fine as long the server
5228
5731
      returned a valid reponse. Don't allow 2013 or 2006 to trigger an
5229
5732
      abort_not_supported_test
5230
5733
    */
5231
 
    if (err_errno == DRIZZLE_RETURN_SERVER_GONE)
 
5734
    if (err_errno == CR_SERVER_LOST ||
 
5735
        err_errno == CR_SERVER_GONE_ERROR)
5232
5736
      die("require query '%s' failed: %d: %s", command->query,
5233
5737
          err_errno, err_error);
5234
5738
 
5240
5744
  if (command->abort_on_error)
5241
5745
    die("query '%s' failed: %d: %s", command->query, err_errno, err_error);
5242
5746
 
5243
 
  for (i= 0 ; (uint32_t) i < command->expected_errors.count ; i++)
 
5747
  DBUG_PRINT("info", ("expected_errors.count: %d",
 
5748
                      command->expected_errors.count));
 
5749
  for (i= 0 ; (uint) i < command->expected_errors.count ; i++)
5244
5750
  {
5245
5751
    if (((command->expected_errors.err[i].type == ERR_ERRNO) &&
5246
5752
         (command->expected_errors.err[i].code.errnum == err_errno)) ||
5247
5753
        ((command->expected_errors.err[i].type == ERR_SQLSTATE) &&
5248
5754
         (strncmp(command->expected_errors.err[i].code.sqlstate,
5249
 
                  err_sqlstate, DRIZZLE_MAX_SQLSTATE_SIZE) == 0)))
 
5755
                  err_sqlstate, SQLSTATE_LENGTH) == 0)))
5250
5756
    {
5251
5757
      if (!disable_result_log)
5252
5758
      {
5253
5759
        if (command->expected_errors.count == 1)
5254
5760
        {
5255
5761
          /* Only log error if there is one possible error */
5256
 
          ds->append("ERROR ", 6);
5257
 
          replace_append(ds, err_sqlstate);
5258
 
          ds->append(": ", 2);
5259
 
          replace_append(ds, err_error);
5260
 
          ds->append("\n",1);
 
5762
          dynstr_append_mem(ds, "ERROR ", 6);
 
5763
          replace_dynstr_append(ds, err_sqlstate);
 
5764
          dynstr_append_mem(ds, ": ", 2);
 
5765
          replace_dynstr_append(ds, err_error);
 
5766
          dynstr_append_mem(ds,"\n",1);
5261
5767
        }
5262
5768
        /* Don't log error if we may not get an error */
5263
5769
        else if (command->expected_errors.err[0].type == ERR_SQLSTATE ||
5264
5770
                 (command->expected_errors.err[0].type == ERR_ERRNO &&
5265
5771
                  command->expected_errors.err[0].code.errnum != 0))
5266
 
          ds->append("Got one of the listed errors\n");
 
5772
          dynstr_append(ds,"Got one of the listed errors\n");
5267
5773
      }
5268
5774
      /* OK */
5269
 
      return;
 
5775
      DBUG_VOID_RETURN;
5270
5776
    }
5271
5777
  }
5272
5778
 
 
5779
  DBUG_PRINT("info",("i: %d  expected_errors: %d", i,
 
5780
                     command->expected_errors.count));
 
5781
 
5273
5782
  if (!disable_result_log)
5274
5783
  {
5275
 
    ds->append("ERROR ",6);
5276
 
    replace_append(ds, err_sqlstate);
5277
 
    ds->append(": ", 2);
5278
 
    replace_append(ds, err_error);
5279
 
    ds->append("\n", 1);
 
5784
    dynstr_append_mem(ds, "ERROR ",6);
 
5785
    replace_dynstr_append(ds, err_sqlstate);
 
5786
    dynstr_append_mem(ds, ": ", 2);
 
5787
    replace_dynstr_append(ds, err_error);
 
5788
    dynstr_append_mem(ds, "\n", 1);
5280
5789
  }
5281
5790
 
5282
5791
  if (i)
5288
5797
    else
5289
5798
      die("query '%s' failed with wrong sqlstate %s: '%s', instead of %s...",
5290
5799
          command->query, err_sqlstate, err_error,
5291
 
          command->expected_errors.err[0].code.sqlstate);
 
5800
          command->expected_errors.err[0].code.sqlstate);
5292
5801
  }
5293
5802
 
5294
 
  return;
 
5803
  DBUG_VOID_RETURN;
5295
5804
}
5296
5805
 
5297
5806
 
5308
5817
 
5309
5818
void handle_no_error(struct st_command *command)
5310
5819
{
5311
 
 
 
5820
  DBUG_ENTER("handle_no_error");
5312
5821
 
5313
5822
  if (command->expected_errors.err[0].type == ERR_ERRNO &&
5314
5823
      command->expected_errors.err[0].code.errnum != 0)
5325
5834
        command->query, command->expected_errors.err[0].code.sqlstate);
5326
5835
  }
5327
5836
 
5328
 
  return;
5329
 
}
 
5837
  DBUG_VOID_RETURN;
 
5838
}
 
5839
 
 
5840
 
 
5841
/*
 
5842
  Run query using prepared statement C API
 
5843
 
 
5844
  SYNPOSIS
 
5845
  run_query_stmt
 
5846
  mysql - mysql handle
 
5847
  command - currrent command pointer
 
5848
  query - query string to execute
 
5849
  query_len - length query string to execute
 
5850
  ds - output buffer where to store result form query
 
5851
 
 
5852
  RETURN VALUE
 
5853
  error - function will not return
 
5854
*/
 
5855
 
 
5856
void run_query_stmt(MYSQL *mysql, struct st_command *command,
 
5857
                    char *query, int query_len, DYNAMIC_STRING *ds,
 
5858
                    DYNAMIC_STRING *ds_warnings)
 
5859
{
 
5860
  MYSQL_RES *res= NULL;     /* Note that here 'res' is meta data result set */
 
5861
  MYSQL_STMT *stmt;
 
5862
  DYNAMIC_STRING ds_prepare_warnings;
 
5863
  DYNAMIC_STRING ds_execute_warnings;
 
5864
  DBUG_ENTER("run_query_stmt");
 
5865
  DBUG_PRINT("query", ("'%-.60s'", query));
 
5866
 
 
5867
  /*
 
5868
    Init a new stmt if it's not already one created for this connection
 
5869
  */
 
5870
  if(!(stmt= cur_con->stmt))
 
5871
  {
 
5872
    if (!(stmt= mysql_stmt_init(mysql)))
 
5873
      die("unable to init stmt structure");
 
5874
    cur_con->stmt= stmt;
 
5875
  }
 
5876
 
 
5877
  /* Init dynamic strings for warnings */
 
5878
  if (!disable_warnings)
 
5879
  {
 
5880
    init_dynamic_string(&ds_prepare_warnings, NULL, 0, 256);
 
5881
    init_dynamic_string(&ds_execute_warnings, NULL, 0, 256);
 
5882
  }
 
5883
 
 
5884
  /*
 
5885
    Prepare the query
 
5886
  */
 
5887
  if (mysql_stmt_prepare(stmt, query, query_len))
 
5888
  {
 
5889
    handle_error(command,  mysql_stmt_errno(stmt),
 
5890
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
 
5891
    goto end;
 
5892
  }
 
5893
 
 
5894
  /*
 
5895
    Get the warnings from mysql_stmt_prepare and keep them in a
 
5896
    separate string
 
5897
  */
 
5898
  if (!disable_warnings)
 
5899
    append_warnings(&ds_prepare_warnings, mysql);
 
5900
 
 
5901
  /*
 
5902
    No need to call mysql_stmt_bind_param() because we have no
 
5903
    parameter markers.
 
5904
  */
 
5905
 
 
5906
#if MYSQL_VERSION_ID >= 50000
 
5907
  if (cursor_protocol_enabled)
 
5908
  {
 
5909
    /*
 
5910
      Use cursor when retrieving result
 
5911
    */
 
5912
    ulong type= CURSOR_TYPE_READ_ONLY;
 
5913
    if (mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type))
 
5914
      die("mysql_stmt_attr_set(STMT_ATTR_CURSOR_TYPE) failed': %d %s",
 
5915
          mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
 
5916
  }
 
5917
#endif
 
5918
 
 
5919
  /*
 
5920
    Execute the query
 
5921
  */
 
5922
  if (mysql_stmt_execute(stmt))
 
5923
  {
 
5924
    handle_error(command, mysql_stmt_errno(stmt),
 
5925
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
 
5926
    goto end;
 
5927
  }
 
5928
 
 
5929
  /*
 
5930
    When running in cursor_protocol get the warnings from execute here
 
5931
    and keep them in a separate string for later.
 
5932
  */
 
5933
  if (cursor_protocol_enabled && !disable_warnings)
 
5934
    append_warnings(&ds_execute_warnings, mysql);
 
5935
 
 
5936
  /*
 
5937
    We instruct that we want to update the "max_length" field in
 
5938
    mysql_stmt_store_result(), this is our only way to know how much
 
5939
    buffer to allocate for result data
 
5940
  */
 
5941
  {
 
5942
    my_bool one= 1;
 
5943
    if (mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &one))
 
5944
      die("mysql_stmt_attr_set(STMT_ATTR_UPDATE_MAX_LENGTH) failed': %d %s",
 
5945
          mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
 
5946
  }
 
5947
 
 
5948
  /*
 
5949
    If we got here the statement succeeded and was expected to do so,
 
5950
    get data. Note that this can still give errors found during execution!
 
5951
    Store the result of the query if if will return any fields
 
5952
  */
 
5953
  if (mysql_stmt_field_count(stmt) && mysql_stmt_store_result(stmt))
 
5954
  {
 
5955
    handle_error(command, mysql_stmt_errno(stmt),
 
5956
                 mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
 
5957
    goto end;
 
5958
  }
 
5959
 
 
5960
  /* If we got here the statement was both executed and read successfully */
 
5961
  handle_no_error(command);
 
5962
  if (!disable_result_log)
 
5963
  {
 
5964
    /*
 
5965
      Not all statements creates a result set. If there is one we can
 
5966
      now create another normal result set that contains the meta
 
5967
      data. This set can be handled almost like any other non prepared
 
5968
      statement result set.
 
5969
    */
 
5970
    if ((res= mysql_stmt_result_metadata(stmt)) != NULL)
 
5971
    {
 
5972
      /* Take the column count from meta info */
 
5973
      MYSQL_FIELD *fields= mysql_fetch_fields(res);
 
5974
      uint num_fields= mysql_num_fields(res);
 
5975
 
 
5976
      if (display_metadata)
 
5977
        append_metadata(ds, fields, num_fields);
 
5978
 
 
5979
      if (!display_result_vertically)
 
5980
        append_table_headings(ds, fields, num_fields);
 
5981
 
 
5982
      append_stmt_result(ds, stmt, fields, num_fields);
 
5983
 
 
5984
      mysql_free_result(res);     /* Free normal result set with meta data */
 
5985
 
 
5986
      /* Clear prepare warnings */
 
5987
      dynstr_set(&ds_prepare_warnings, NULL);
 
5988
    }
 
5989
    else
 
5990
    {
 
5991
      /*
 
5992
        This is a query without resultset
 
5993
      */
 
5994
    }
 
5995
 
 
5996
    if (!disable_warnings)
 
5997
    {
 
5998
      /* Get the warnings from execute */
 
5999
 
 
6000
      /* Append warnings to ds - if there are any */
 
6001
      if (append_warnings(&ds_execute_warnings, mysql) ||
 
6002
          ds_execute_warnings.length ||
 
6003
          ds_prepare_warnings.length ||
 
6004
          ds_warnings->length)
 
6005
      {
 
6006
        dynstr_append_mem(ds, "Warnings:\n", 10);
 
6007
        if (ds_warnings->length)
 
6008
          dynstr_append_mem(ds, ds_warnings->str,
 
6009
                            ds_warnings->length);
 
6010
        if (ds_prepare_warnings.length)
 
6011
          dynstr_append_mem(ds, ds_prepare_warnings.str,
 
6012
                            ds_prepare_warnings.length);
 
6013
        if (ds_execute_warnings.length)
 
6014
          dynstr_append_mem(ds, ds_execute_warnings.str,
 
6015
                            ds_execute_warnings.length);
 
6016
      }
 
6017
    }
 
6018
 
 
6019
    if (!disable_info)
 
6020
      append_info(ds, mysql_affected_rows(mysql), mysql_info(mysql));
 
6021
 
 
6022
  }
 
6023
 
 
6024
end:
 
6025
  if (!disable_warnings)
 
6026
  {
 
6027
    dynstr_free(&ds_prepare_warnings);
 
6028
    dynstr_free(&ds_execute_warnings);
 
6029
  }
 
6030
 
 
6031
 
 
6032
  /* Close the statement if - no reconnect, need new prepare */
 
6033
  if (mysql->reconnect)
 
6034
  {
 
6035
    mysql_stmt_close(stmt);
 
6036
    cur_con->stmt= NULL;
 
6037
  }
 
6038
 
 
6039
  /*
 
6040
    We save the return code (mysql_stmt_errno(stmt)) from the last call sent
 
6041
    to the server into the mysqltest builtin variable $mysql_errno. This
 
6042
    variable then can be used from the test case itself.
 
6043
  */
 
6044
 
 
6045
  var_set_errno(mysql_stmt_errno(stmt));
 
6046
 
 
6047
  DBUG_VOID_RETURN;
 
6048
}
 
6049
 
 
6050
 
 
6051
 
 
6052
/*
 
6053
  Create a util connection if one does not already exists
 
6054
  and use that to run the query
 
6055
  This is done to avoid implict commit when creating/dropping objects such
 
6056
  as view, sp etc.
 
6057
*/
 
6058
 
 
6059
int util_query(MYSQL* org_mysql, const char* query){
 
6060
 
 
6061
  MYSQL* mysql;
 
6062
  DBUG_ENTER("util_query");
 
6063
 
 
6064
  if(!(mysql= cur_con->util_mysql))
 
6065
  {
 
6066
    int opt_protocol= MYSQL_PROTOCOL_TCP;
 
6067
    DBUG_PRINT("info", ("Creating util_mysql"));
 
6068
    if (!(mysql= mysql_init(mysql)))
 
6069
      die("Failed in mysql_init()");
 
6070
    mysql_options(mysql, MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
 
6071
 
 
6072
    /* enable local infile, in non-binary builds often disabled by default */
 
6073
    mysql_options(mysql, MYSQL_OPT_LOCAL_INFILE, 0);
 
6074
    safe_connect(mysql, "util", org_mysql->host, org_mysql->user,
 
6075
                 org_mysql->passwd, org_mysql->db, org_mysql->port);
 
6076
 
 
6077
    cur_con->util_mysql= mysql;
 
6078
  }
 
6079
 
 
6080
  return mysql_query(mysql, query);
 
6081
}
 
6082
 
5330
6083
 
5331
6084
 
5332
6085
/*
5333
6086
  Run query
5334
6087
 
5335
6088
  SYNPOSIS
5336
 
  run_query()
5337
 
  drizzle  DRIZZLE handle
5338
 
  command  currrent command pointer
 
6089
    run_query()
 
6090
     mysql      mysql handle
 
6091
     command    currrent command pointer
5339
6092
 
5340
6093
  flags control the phased/stages of query execution to be performed
5341
6094
  if QUERY_SEND_FLAG bit is on, the query will be sent. If QUERY_REAP_FLAG
5342
6095
  is on the result will be read - for regular query, both bits must be on
5343
6096
*/
5344
6097
 
5345
 
static void run_query(struct st_connection *cn,
5346
 
                      struct st_command *command,
5347
 
                      int flags)
 
6098
void run_query(struct st_connection *cn, struct st_command *command, int flags)
5348
6099
{
5349
 
  string *ds= NULL;
5350
 
  string *save_ds= NULL;
5351
 
  string ds_result;
5352
 
  string ds_sorted;
5353
 
  string ds_warnings;
5354
 
  string eval_query;
 
6100
  MYSQL *mysql= &cn->mysql;
 
6101
  DYNAMIC_STRING *ds;
 
6102
  DYNAMIC_STRING *save_ds= NULL;
 
6103
  DYNAMIC_STRING ds_result;
 
6104
  DYNAMIC_STRING ds_sorted;
 
6105
  DYNAMIC_STRING ds_warnings;
 
6106
  DYNAMIC_STRING eval_query;
5355
6107
  char *query;
5356
6108
  int query_len;
 
6109
  my_bool view_created= 0, sp_created= 0;
 
6110
  my_bool complete_query= ((flags & QUERY_SEND_FLAG) &&
 
6111
                           (flags & QUERY_REAP_FLAG));
 
6112
  DBUG_ENTER("run_query");
5357
6113
 
 
6114
  init_dynamic_string(&ds_warnings, NULL, 0, 256);
5358
6115
 
5359
6116
  /* Scan for warning before sending to server */
5360
6117
  scan_command_for_warnings(command);
5364
6121
  */
5365
6122
  if (command->type == Q_EVAL)
5366
6123
  {
5367
 
    do_eval(&eval_query, command->query, command->end, false);
5368
 
    query = strdup(eval_query.c_str());
5369
 
    query_len = eval_query.length();
 
6124
    init_dynamic_string(&eval_query, "", command->query_len+256, 1024);
 
6125
    do_eval(&eval_query, command->query, command->end, FALSE);
 
6126
    query = eval_query.str;
 
6127
    query_len = eval_query.length;
5370
6128
  }
5371
6129
  else
5372
6130
  {
5380
6138
    Create a temporary dynamic string to contain the output from
5381
6139
    this query.
5382
6140
  */
5383
 
  if (! command->require_file.empty())
 
6141
  if (command->require_file[0])
5384
6142
  {
 
6143
    init_dynamic_string(&ds_result, "", 1024, 1024);
5385
6144
    ds= &ds_result;
5386
6145
  }
5387
6146
  else
5388
 
  {
5389
6147
    ds= &ds_res;
5390
 
  }
 
6148
 
5391
6149
  /*
5392
6150
    Log the query into the output buffer
5393
6151
  */
5394
6152
  if (!disable_query_log && (flags & QUERY_SEND_FLAG))
5395
6153
  {
5396
 
    replace_append_mem(ds, query, query_len);
5397
 
    ds->append(delimiter, delimiter_length);
5398
 
    ds->append("\n");
 
6154
    replace_dynstr_append_mem(ds, query, query_len);
 
6155
    dynstr_append_mem(ds, delimiter, delimiter_length);
 
6156
    dynstr_append_mem(ds, "\n", 1);
 
6157
  }
 
6158
 
 
6159
  if (view_protocol_enabled &&
 
6160
      complete_query &&
 
6161
      match_re(&view_re, query))
 
6162
  {
 
6163
    /*
 
6164
      Create the query as a view.
 
6165
      Use replace since view can exist from a failed mysqltest run
 
6166
    */
 
6167
    DYNAMIC_STRING query_str;
 
6168
    init_dynamic_string(&query_str,
 
6169
                        "CREATE OR REPLACE VIEW mysqltest_tmp_v AS ",
 
6170
                        query_len+64, 256);
 
6171
    dynstr_append_mem(&query_str, query, query_len);
 
6172
    if (util_query(mysql, query_str.str))
 
6173
    {
 
6174
      /*
 
6175
        Failed to create the view, this is not fatal
 
6176
        just run the query the normal way
 
6177
      */
 
6178
      DBUG_PRINT("view_create_error",
 
6179
                 ("Failed to create view '%s': %d: %s", query_str.str,
 
6180
                  mysql_errno(mysql), mysql_error(mysql)));
 
6181
 
 
6182
      /* Log error to create view */
 
6183
      verbose_msg("Failed to create view '%s' %d: %s", query_str.str,
 
6184
                  mysql_errno(mysql), mysql_error(mysql));
 
6185
    }
 
6186
    else
 
6187
    {
 
6188
      /*
 
6189
        Yes, it was possible to create this query as a view
 
6190
      */
 
6191
      view_created= 1;
 
6192
      query= (char*)"SELECT * FROM mysqltest_tmp_v";
 
6193
      query_len = strlen(query);
 
6194
 
 
6195
      /*
 
6196
        Collect warnings from create of the view that should otherwise
 
6197
        have been produced when the SELECT was executed
 
6198
      */
 
6199
      append_warnings(&ds_warnings, cur_con->util_mysql);
 
6200
    }
 
6201
 
 
6202
    dynstr_free(&query_str);
 
6203
 
 
6204
  }
 
6205
 
 
6206
  if (sp_protocol_enabled &&
 
6207
      complete_query &&
 
6208
      match_re(&sp_re, query))
 
6209
  {
 
6210
    /*
 
6211
      Create the query as a stored procedure
 
6212
      Drop first since sp can exist from a failed mysqltest run
 
6213
    */
 
6214
    DYNAMIC_STRING query_str;
 
6215
    init_dynamic_string(&query_str,
 
6216
                        "DROP PROCEDURE IF EXISTS mysqltest_tmp_sp;",
 
6217
                        query_len+64, 256);
 
6218
    util_query(mysql, query_str.str);
 
6219
    dynstr_set(&query_str, "CREATE PROCEDURE mysqltest_tmp_sp()\n");
 
6220
    dynstr_append_mem(&query_str, query, query_len);
 
6221
    if (util_query(mysql, query_str.str))
 
6222
    {
 
6223
      /*
 
6224
        Failed to create the stored procedure for this query,
 
6225
        this is not fatal just run the query the normal way
 
6226
      */
 
6227
      DBUG_PRINT("sp_create_error",
 
6228
                 ("Failed to create sp '%s': %d: %s", query_str.str,
 
6229
                  mysql_errno(mysql), mysql_error(mysql)));
 
6230
 
 
6231
      /* Log error to create sp */
 
6232
      verbose_msg("Failed to create sp '%s' %d: %s", query_str.str,
 
6233
                  mysql_errno(mysql), mysql_error(mysql));
 
6234
 
 
6235
    }
 
6236
    else
 
6237
    {
 
6238
      sp_created= 1;
 
6239
 
 
6240
      query= (char*)"CALL mysqltest_tmp_sp()";
 
6241
      query_len = strlen(query);
 
6242
    }
 
6243
    dynstr_free(&query_str);
5399
6244
  }
5400
6245
 
5401
6246
  if (display_result_sorted)
5402
6247
  {
5403
6248
    /*
5404
 
      Collect the query output in a separate string
5405
 
      that can be sorted before it's added to the
5406
 
      global result string
 
6249
       Collect the query output in a separate string
 
6250
       that can be sorted before it's added to the
 
6251
       global result string
5407
6252
    */
 
6253
    init_dynamic_string(&ds_sorted, "", 1024, 1024);
5408
6254
    save_ds= ds; /* Remember original ds */
5409
6255
    ds= &ds_sorted;
5410
6256
  }
5411
6257
 
5412
6258
  /*
 
6259
    Find out how to run this query
 
6260
 
5413
6261
    Always run with normal C API if it's not a complete
5414
6262
    SEND + REAP
 
6263
 
 
6264
    If it is a '?' in the query it may be a SQL level prepared
 
6265
    statement already and we can't do it twice
5415
6266
  */
5416
 
  run_query_normal(cn, command, flags, query, query_len,
5417
 
                   ds, &ds_warnings);
 
6267
  if (ps_protocol_enabled &&
 
6268
      complete_query &&
 
6269
      match_re(&ps_re, query))
 
6270
    run_query_stmt(mysql, command, query, query_len, ds, &ds_warnings);
 
6271
  else
 
6272
    run_query_normal(cn, command, flags, query, query_len,
 
6273
                     ds, &ds_warnings);
5418
6274
 
5419
6275
  if (display_result_sorted)
5420
6276
  {
5421
6277
    /* Sort the result set and append it to result */
5422
 
    append_sorted(save_ds, &ds_sorted);
 
6278
    dynstr_append_sorted(save_ds, &ds_sorted);
5423
6279
    ds= save_ds;
5424
 
  }
5425
 
 
5426
 
  if (! command->require_file.empty())
 
6280
    dynstr_free(&ds_sorted);
 
6281
  }
 
6282
 
 
6283
  if (sp_created)
 
6284
  {
 
6285
    if (util_query(mysql, "DROP PROCEDURE mysqltest_tmp_sp "))
 
6286
      die("Failed to drop sp: %d: %s", mysql_errno(mysql), mysql_error(mysql));
 
6287
  }
 
6288
 
 
6289
  if (view_created)
 
6290
  {
 
6291
    if (util_query(mysql, "DROP VIEW mysqltest_tmp_v "))
 
6292
      die("Failed to drop view: %d: %s",
 
6293
          mysql_errno(mysql), mysql_error(mysql));
 
6294
  }
 
6295
 
 
6296
  if (command->require_file[0])
5427
6297
  {
5428
6298
    /* A result file was specified for _this_ query
5429
6299
       and the output should be checked against an already
5432
6302
    check_require(ds, command->require_file);
5433
6303
  }
5434
6304
 
5435
 
  return;
5436
 
}
5437
 
 
5438
 
 
5439
 
/****************************************************************************/
5440
 
 
5441
 
static void get_command_type(struct st_command* command)
 
6305
  dynstr_free(&ds_warnings);
 
6306
  if (ds == &ds_result)
 
6307
    dynstr_free(&ds_result);
 
6308
  if (command->type == Q_EVAL)
 
6309
    dynstr_free(&eval_query);
 
6310
  DBUG_VOID_RETURN;
 
6311
}
 
6312
 
 
6313
/****************************************************************************/
 
6314
/*
 
6315
  Functions to detect different SQL statements
 
6316
*/
 
6317
 
 
6318
char *re_eprint(int err)
 
6319
{
 
6320
  static char epbuf[100];
 
6321
  size_t len= my_regerror(REG_ITOA|err, (my_regex_t *)NULL,
 
6322
                          epbuf, sizeof(epbuf));
 
6323
  assert(len <= sizeof(epbuf));
 
6324
  return(epbuf);
 
6325
}
 
6326
 
 
6327
void init_re_comp(my_regex_t *re, const char* str)
 
6328
{
 
6329
  int err= my_regcomp(re, str, (REG_EXTENDED | REG_ICASE | REG_NOSUB),
 
6330
                      &my_charset_latin1);
 
6331
  if (err)
 
6332
  {
 
6333
    char erbuf[100];
 
6334
    int len= my_regerror(err, re, erbuf, sizeof(erbuf));
 
6335
    die("error %s, %d/%d `%s'\n",
 
6336
        re_eprint(err), len, (int)sizeof(erbuf), erbuf);
 
6337
  }
 
6338
}
 
6339
 
 
6340
void init_re(void)
 
6341
{
 
6342
  /*
 
6343
    Filter for queries that can be run using the
 
6344
    MySQL Prepared Statements C API
 
6345
  */
 
6346
  const char *ps_re_str =
 
6347
    "^("
 
6348
    "[[:space:]]*REPLACE[[:space:]]|"
 
6349
    "[[:space:]]*INSERT[[:space:]]|"
 
6350
    "[[:space:]]*UPDATE[[:space:]]|"
 
6351
    "[[:space:]]*DELETE[[:space:]]|"
 
6352
    "[[:space:]]*SELECT[[:space:]]|"
 
6353
    "[[:space:]]*CREATE[[:space:]]+TABLE[[:space:]]|"
 
6354
    "[[:space:]]*DO[[:space:]]|"
 
6355
    "[[:space:]]*SET[[:space:]]+OPTION[[:space:]]|"
 
6356
    "[[:space:]]*DELETE[[:space:]]+MULTI[[:space:]]|"
 
6357
    "[[:space:]]*UPDATE[[:space:]]+MULTI[[:space:]]|"
 
6358
    "[[:space:]]*INSERT[[:space:]]+SELECT[[:space:]])";
 
6359
 
 
6360
  /*
 
6361
    Filter for queries that can be run using the
 
6362
    Stored procedures
 
6363
  */
 
6364
  const char *sp_re_str =ps_re_str;
 
6365
 
 
6366
  /*
 
6367
    Filter for queries that can be run as views
 
6368
  */
 
6369
  const char *view_re_str =
 
6370
    "^("
 
6371
    "[[:space:]]*SELECT[[:space:]])";
 
6372
 
 
6373
  init_re_comp(&ps_re, ps_re_str);
 
6374
  init_re_comp(&sp_re, sp_re_str);
 
6375
  init_re_comp(&view_re, view_re_str);
 
6376
}
 
6377
 
 
6378
 
 
6379
int match_re(my_regex_t *re, char *str)
 
6380
{
 
6381
  int err= my_regexec(re, str, (size_t)0, NULL, 0);
 
6382
 
 
6383
  if (err == 0)
 
6384
    return 1;
 
6385
  else if (err == REG_NOMATCH)
 
6386
    return 0;
 
6387
 
 
6388
  {
 
6389
    char erbuf[100];
 
6390
    int len= my_regerror(err, re, erbuf, sizeof(erbuf));
 
6391
    die("error %s, %d/%d `%s'\n",
 
6392
        re_eprint(err), len, (int)sizeof(erbuf), erbuf);
 
6393
  }
 
6394
  return 0;
 
6395
}
 
6396
 
 
6397
void free_re(void)
 
6398
{
 
6399
  my_regfree(&ps_re);
 
6400
  my_regfree(&sp_re);
 
6401
  my_regfree(&view_re);
 
6402
  my_regex_end();
 
6403
}
 
6404
 
 
6405
/****************************************************************************/
 
6406
 
 
6407
void get_command_type(struct st_command* command)
5442
6408
{
5443
6409
  char save;
5444
 
  uint32_t type;
5445
 
 
 
6410
  uint type;
 
6411
  DBUG_ENTER("get_command_type");
5446
6412
 
5447
6413
  if (*command->query == '}')
5448
6414
  {
5449
6415
    command->type = Q_END_BLOCK;
5450
 
    return;
 
6416
    DBUG_VOID_RETURN;
5451
6417
  }
5452
6418
 
5453
6419
  save= command->query[command->first_word_len];
5456
6422
  command->query[command->first_word_len]= save;
5457
6423
  if (type > 0)
5458
6424
  {
5459
 
    command->type=(enum enum_commands) type;    /* Found command */
 
6425
    command->type=(enum enum_commands) type;            /* Found command */
5460
6426
 
5461
6427
    /*
5462
6428
      Look for case where "query" was explicitly specified to
5470
6436
  }
5471
6437
  else
5472
6438
  {
5473
 
    /* No drizzletest command matched */
 
6439
    /* No mysqltest command matched */
5474
6440
 
5475
6441
    if (command->type != Q_COMMENT_WITH_COMMAND)
5476
6442
    {
5477
 
      /* A query that will sent to drizzled */
 
6443
      /* A query that will sent to mysqld */
5478
6444
      command->type= Q_QUERY;
5479
6445
    }
5480
6446
    else
5481
6447
    {
5482
 
      /* -- comment that didn't contain a drizzletest command */
 
6448
      /* -- comment that didn't contain a mysqltest command */
5483
6449
      command->type= Q_COMMENT;
5484
 
      warning_msg("Suspicious command '--%s' detected, was this intentional? " \
 
6450
      warning_msg("Suspicious command '--%s' detected, was this intentional? "\
5485
6451
                  "Use # instead of -- to avoid this warning",
5486
6452
                  command->query);
5487
6453
 
5507
6473
  /* Set expected error on command */
5508
6474
  memcpy(&command->expected_errors, &saved_expected_errors,
5509
6475
         sizeof(saved_expected_errors));
 
6476
  DBUG_PRINT("info", ("There are %d expected errors",
 
6477
                      command->expected_errors.count));
5510
6478
  command->abort_on_error= (command->expected_errors.count == 0 &&
5511
6479
                            abort_on_error);
5512
6480
 
5513
 
  return;
 
6481
  DBUG_VOID_RETURN;
5514
6482
}
5515
6483
 
5516
6484
 
5524
6492
 
5525
6493
*/
5526
6494
 
5527
 
static void mark_progress(struct st_command*, int line)
 
6495
void mark_progress(struct st_command* command __attribute__((unused)),
 
6496
                   int line)
5528
6497
{
5529
 
  uint64_t timer= timer_now();
 
6498
  char buf[32], *end;
 
6499
  ulonglong timer= timer_now();
5530
6500
  if (!progress_start)
5531
6501
    progress_start= timer;
5532
6502
  timer-= progress_start;
5533
6503
 
5534
 
  ostringstream buf;
5535
6504
  /* Milliseconds since start */
5536
 
  buf << timer << "\t";
 
6505
  end= longlong2str(timer, buf, 10);
 
6506
  dynstr_append_mem(&ds_progress, buf, (int)(end-buf));
 
6507
  dynstr_append_mem(&ds_progress, "\t", 1);
5537
6508
 
5538
6509
  /* Parser line number */
5539
 
  buf << line << "\t";
 
6510
  end= int10_to_str(line, buf, 10);
 
6511
  dynstr_append_mem(&ds_progress, buf, (int)(end-buf));
 
6512
  dynstr_append_mem(&ds_progress, "\t", 1);
5540
6513
 
5541
6514
  /* Filename */
5542
 
  buf << cur_file->file_name << ":";
 
6515
  dynstr_append(&ds_progress, cur_file->file_name);
 
6516
  dynstr_append_mem(&ds_progress, ":", 1);
5543
6517
 
5544
6518
  /* Line in file */
5545
 
  buf << cur_file->lineno << endl;
5546
 
 
5547
 
  ds_progress.append(buf.str());
 
6519
  end= int10_to_str(cur_file->lineno, buf, 10);
 
6520
  dynstr_append_mem(&ds_progress, buf, (int)(end-buf));
 
6521
 
 
6522
 
 
6523
  dynstr_append_mem(&ds_progress, "\n", 1);
5548
6524
 
5549
6525
}
5550
6526
 
5552
6528
int main(int argc, char **argv)
5553
6529
{
5554
6530
  struct st_command *command;
5555
 
  bool q_send_flag= 0, abort_flag= 0;
5556
 
  uint32_t command_executed= 0, last_command_executed= 0;
5557
 
  string save_file("");
 
6531
  my_bool q_send_flag= 0, abort_flag= 0;
 
6532
  uint command_executed= 0, last_command_executed= 0;
 
6533
  char save_file[FN_REFLEN];
5558
6534
  struct stat res_info;
5559
6535
  MY_INIT(argv[0]);
5560
6536
 
 
6537
  save_file[0]= 0;
5561
6538
  TMPDIR[0]= 0;
5562
6539
 
5563
6540
  /* Init expected errors */
5569
6546
    (sizeof(connections)/sizeof(struct st_connection)) - 1;
5570
6547
  next_con= connections + 1;
5571
6548
 
 
6549
#ifdef EMBEDDED_LIBRARY
 
6550
  /* set appropriate stack for the 'query' threads */
 
6551
  (void) pthread_attr_init(&cn_thd_attrib);
 
6552
  pthread_attr_setstacksize(&cn_thd_attrib, DEFAULT_THREAD_STACK);
 
6553
#endif /*EMBEDDED_LIBRARY*/
 
6554
 
5572
6555
  /* Init file stack */
5573
6556
  memset(file_stack, 0, sizeof(file_stack));
5574
6557
  file_stack_end=
5580
6563
  block_stack_end=
5581
6564
    block_stack + (sizeof(block_stack)/sizeof(struct st_block)) - 1;
5582
6565
  cur_block= block_stack;
5583
 
  cur_block->ok= true; /* Outer block should always be executed */
 
6566
  cur_block->ok= TRUE; /* Outer block should always be executed */
5584
6567
  cur_block->cmd= cmd_none;
5585
6568
 
5586
 
  var_set_string("$DRIZZLE_SERVER_VERSION", drizzle_version());
 
6569
  my_init_dynamic_array(&q_lines, sizeof(struct st_command*), 1024, 1024);
 
6570
 
 
6571
  if (hash_init(&var_hash, charset_info,
 
6572
                1024, 0, 0, get_var_key, var_free, MYF(0)))
 
6573
    die("Variable hash initialization failed");
 
6574
 
 
6575
  var_set_string("$MYSQL_SERVER_VERSION", MYSQL_SERVER_VERSION);
5587
6576
 
5588
6577
  memset(&master_pos, 0, sizeof(master_pos));
5589
6578
 
5592
6581
 
5593
6582
  init_builtin_echo();
5594
6583
 
5595
 
  ds_res.reserve(65536);
5596
 
  ds_progress.reserve(2048);
5597
 
  ds_warning_messages.reserve(2048);
5598
 
 
 
6584
  init_dynamic_string(&ds_res, "", 65536, 65536);
 
6585
  init_dynamic_string(&ds_progress, "", 0, 2048);
 
6586
  init_dynamic_string(&ds_warning_messages, "", 0, 2048);
5599
6587
  parse_args(argc, argv);
5600
6588
 
 
6589
  var_set_int("$PS_PROTOCOL", ps_protocol);
 
6590
  var_set_int("$SP_PROTOCOL", sp_protocol);
 
6591
  var_set_int("$VIEW_PROTOCOL", view_protocol);
 
6592
  var_set_int("$CURSOR_PROTOCOL", cursor_protocol);
 
6593
 
 
6594
  DBUG_PRINT("info",("result_file: '%s'",
 
6595
                     result_file_name ? result_file_name : ""));
 
6596
  if (mysql_server_init(embedded_server_arg_count,
 
6597
                        embedded_server_args,
 
6598
                        (char**) embedded_server_groups))
 
6599
    die("Can't initialize MySQL server");
5601
6600
  server_initialized= 1;
5602
6601
  if (cur_file == file_stack && cur_file->file == 0)
5603
6602
  {
5604
6603
    cur_file->file= stdin;
5605
 
    cur_file->file_name= strdup("<stdin>");
5606
 
    if (cur_file->file_name == NULL)
5607
 
      die("Out of memory");
 
6604
    cur_file->file_name= my_strdup("<stdin>", MYF(MY_WME));
5608
6605
    cur_file->lineno= 1;
5609
6606
  }
 
6607
  init_re();
 
6608
  ps_protocol_enabled= ps_protocol;
 
6609
  sp_protocol_enabled= sp_protocol;
 
6610
  view_protocol_enabled= view_protocol;
 
6611
  cursor_protocol_enabled= cursor_protocol;
 
6612
  /* Cursor protcol implies ps protocol */
 
6613
  if (cursor_protocol_enabled)
 
6614
    ps_protocol_enabled= 1;
 
6615
 
5610
6616
  cur_con= connections;
5611
 
  if ((cur_con->drizzle= drizzle_create(NULL)) == NULL)
5612
 
    die("Failed in drizzle_create()");
5613
 
  if (!( drizzle_con_create(cur_con->drizzle, &cur_con->con)))
5614
 
    die("Failed in drizzle_con_create()");
5615
 
 
5616
 
  if (!(cur_con->name = strdup("default")))
 
6617
  if (!( mysql_init(&cur_con->mysql)))
 
6618
    die("Failed in mysql_init()");
 
6619
  if (opt_compress)
 
6620
    mysql_options(&cur_con->mysql,MYSQL_OPT_COMPRESS,NullS);
 
6621
  mysql_options(&cur_con->mysql, MYSQL_OPT_LOCAL_INFILE, 0);
 
6622
  mysql_options(&cur_con->mysql, MYSQL_SET_CHARSET_NAME,
 
6623
                charset_info->csname);
 
6624
  int opt_protocol= MYSQL_PROTOCOL_TCP;
 
6625
  mysql_options(&cur_con->mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
 
6626
  if (opt_charsets_dir)
 
6627
    mysql_options(&cur_con->mysql, MYSQL_SET_CHARSET_DIR,
 
6628
                  opt_charsets_dir);
 
6629
 
 
6630
#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
 
6631
 
 
6632
  if (opt_use_ssl)
 
6633
  {
 
6634
    mysql_ssl_set(&cur_con->mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
 
6635
                  opt_ssl_capath, opt_ssl_cipher);
 
6636
#if MYSQL_VERSION_ID >= 50000
 
6637
    /* Turn on ssl_verify_server_cert only if host is "localhost" */
 
6638
    opt_ssl_verify_server_cert= opt_host && !strcmp(opt_host, "localhost");
 
6639
    mysql_options(&cur_con->mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
 
6640
                  &opt_ssl_verify_server_cert);
 
6641
#endif
 
6642
  }
 
6643
#endif
 
6644
 
 
6645
  if (!(cur_con->name = my_strdup("default", MYF(MY_WME))))
5617
6646
    die("Out of memory");
5618
6647
 
5619
 
  safe_connect(&cur_con->con, cur_con->name, opt_host, opt_user, opt_pass,
 
6648
  safe_connect(&cur_con->mysql, cur_con->name, opt_host, opt_user, opt_pass,
5620
6649
               opt_db, opt_port);
5621
6650
 
5622
6651
  /* Use all time until exit if no explicit 'start_timer' */
5623
6652
  timer_start= timer_now();
5624
6653
 
5625
6654
  /*
5626
 
    Initialize $drizzleclient_errno with -1, so we can
 
6655
    Initialize $mysql_errno with -1, so we can
5627
6656
    - distinguish it from valid values ( >= 0 ) and
5628
6657
    - detect if there was never a command sent to the server
5629
6658
  */
5630
6659
  var_set_errno(-1);
5631
6660
 
5632
 
  /* Update $drizzleclient_get_server_version to that of current connection */
5633
 
  var_set_drizzleclient_get_server_version(&cur_con->con);
 
6661
  /* Update $mysql_get_server_version to that of current connection */
 
6662
  var_set_mysql_get_server_version(&cur_con->mysql);
5634
6663
 
5635
6664
  if (opt_include)
5636
6665
  {
5659
6688
      case Q_CONNECT:
5660
6689
        do_connect(command);
5661
6690
        break;
5662
 
      case Q_CONNECTION:
5663
 
        select_connection(command);
5664
 
        break;
 
6691
      case Q_CONNECTION: select_connection(command); break;
5665
6692
      case Q_DISCONNECT:
5666
6693
      case Q_DIRTY_CLOSE:
5667
 
        do_close_connection(command); break;
 
6694
        do_close_connection(command); break;
5668
6695
      case Q_ENABLE_QUERY_LOG:   disable_query_log=0; break;
5669
6696
      case Q_DISABLE_QUERY_LOG:  disable_query_log=1; break;
5670
6697
      case Q_ENABLE_ABORT_ON_ERROR:  abort_on_error=1; break;
5700
6727
      case Q_PERL: do_perl(command); break;
5701
6728
      case Q_DELIMITER:
5702
6729
        do_delimiter(command);
5703
 
        break;
 
6730
        break;
5704
6731
      case Q_DISPLAY_VERTICAL_RESULTS:
5705
 
        display_result_vertically= true;
 
6732
        display_result_vertically= TRUE;
5706
6733
        break;
5707
6734
      case Q_DISPLAY_HORIZONTAL_RESULTS:
5708
 
        display_result_vertically= false;
 
6735
        display_result_vertically= FALSE;
5709
6736
        break;
5710
6737
      case Q_SORTED_RESULT:
5711
6738
        /*
5712
6739
          Turn on sorting of result set, will be reset after next
5713
6740
          command
5714
6741
        */
5715
 
        display_result_sorted= true;
 
6742
        display_result_sorted= TRUE;
5716
6743
        break;
5717
6744
      case Q_LET: do_let(command); break;
5718
6745
      case Q_EVAL_RESULT:
5720
6747
      case Q_EVAL:
5721
6748
      case Q_QUERY_VERTICAL:
5722
6749
      case Q_QUERY_HORIZONTAL:
5723
 
        if (command->query == command->query_buf)
 
6750
        if (command->query == command->query_buf)
5724
6751
        {
5725
6752
          /* Skip the first part of command, i.e query_xxx */
5726
 
          command->query= command->first_argument;
 
6753
          command->query= command->first_argument;
5727
6754
          command->first_word_len= 0;
5728
6755
        }
5729
 
        /* fall through */
 
6756
        /* fall through */
5730
6757
      case Q_QUERY:
5731
6758
      case Q_REAP:
5732
6759
      {
5733
 
        bool old_display_result_vertically= display_result_vertically;
 
6760
        my_bool old_display_result_vertically= display_result_vertically;
5734
6761
        /* Default is full query, both reap and send  */
5735
6762
        int flags= QUERY_REAP_FLAG | QUERY_SEND_FLAG;
5736
6763
 
5748
6775
        /* Check for special property for this query */
5749
6776
        display_result_vertically|= (command->type == Q_QUERY_VERTICAL);
5750
6777
 
5751
 
        if (! save_file.empty())
5752
 
        {
5753
 
          command->require_file= save_file;
5754
 
          save_file.clear();
5755
 
        }
5756
 
        run_query(cur_con, command, flags);
5757
 
        command_executed++;
 
6778
        if (save_file[0])
 
6779
        {
 
6780
          strmake(command->require_file, save_file, sizeof(save_file) - 1);
 
6781
          save_file[0]= 0;
 
6782
        }
 
6783
        run_query(cur_con, command, flags);
 
6784
        command_executed++;
5758
6785
        command->last_argument= command->end;
5759
6786
 
5760
6787
        /* Restore settings */
5761
 
        display_result_vertically= old_display_result_vertically;
 
6788
        display_result_vertically= old_display_result_vertically;
5762
6789
 
5763
 
        break;
 
6790
        break;
5764
6791
      }
5765
6792
      case Q_SEND:
5766
6793
        if (!*command->first_argument)
5774
6801
        }
5775
6802
 
5776
6803
        /* Remove "send" if this is first iteration */
5777
 
        if (command->query == command->query_buf)
5778
 
          command->query= command->first_argument;
 
6804
        if (command->query == command->query_buf)
 
6805
          command->query= command->first_argument;
5779
6806
 
5780
 
        /*
5781
 
          run_query() can execute a query partially, depending on the flags.
5782
 
          QUERY_SEND_FLAG flag without QUERY_REAP_FLAG tells it to just send
 
6807
        /*
 
6808
          run_query() can execute a query partially, depending on the flags.
 
6809
          QUERY_SEND_FLAG flag without QUERY_REAP_FLAG tells it to just send
5783
6810
          the query and read the result some time later when reap instruction
5784
 
          is given on this connection.
 
6811
          is given on this connection.
5785
6812
        */
5786
 
        run_query(cur_con, command, QUERY_SEND_FLAG);
5787
 
        command_executed++;
 
6813
        run_query(cur_con, command, QUERY_SEND_FLAG);
 
6814
        command_executed++;
5788
6815
        command->last_argument= command->end;
5789
 
        break;
 
6816
        break;
5790
6817
      case Q_REQUIRE:
5791
 
        do_get_file_name(command, save_file);
5792
 
        break;
 
6818
        do_get_file_name(command, save_file, sizeof(save_file));
 
6819
        break;
5793
6820
      case Q_ERROR:
5794
6821
        do_get_errcodes(command);
5795
 
        break;
 
6822
        break;
5796
6823
      case Q_REPLACE:
5797
 
        do_get_replace(command);
5798
 
        break;
 
6824
        do_get_replace(command);
 
6825
        break;
5799
6826
      case Q_REPLACE_REGEX:
5800
6827
        do_get_replace_regex(command);
5801
6828
        break;
5802
6829
      case Q_REPLACE_COLUMN:
5803
 
        do_get_replace_column(command);
5804
 
        break;
 
6830
        do_get_replace_column(command);
 
6831
        break;
5805
6832
      case Q_SAVE_MASTER_POS: do_save_master_pos(); break;
5806
6833
      case Q_SYNC_WITH_MASTER: do_sync_with_master(command); break;
5807
6834
      case Q_SYNC_SLAVE_WITH_MASTER:
5808
6835
      {
5809
 
        do_save_master_pos();
5810
 
        if (*command->first_argument)
5811
 
          select_connection(command);
5812
 
        else
5813
 
          select_connection_name("slave");
5814
 
        do_sync_with_master2(0);
5815
 
        break;
 
6836
        do_save_master_pos();
 
6837
        if (*command->first_argument)
 
6838
          select_connection(command);
 
6839
        else
 
6840
          select_connection_name("slave");
 
6841
        do_sync_with_master2(0);
 
6842
        break;
5816
6843
      }
5817
 
      case Q_COMMENT:        /* Ignore row */
 
6844
      case Q_COMMENT:                           /* Ignore row */
5818
6845
        command->last_argument= command->end;
5819
 
        break;
 
6846
        break;
5820
6847
      case Q_PING:
5821
 
        {
5822
 
          drizzle_result_st result;
5823
 
          drizzle_return_t ret;
5824
 
          (void) drizzle_ping(&cur_con->con, &result, &ret);
5825
 
          if (ret == DRIZZLE_RETURN_OK || ret == DRIZZLE_RETURN_ERROR_CODE)
5826
 
            drizzle_result_free(&result);
5827
 
        }
5828
 
        break;
 
6848
        (void) mysql_ping(&cur_con->mysql);
 
6849
        break;
5829
6850
      case Q_EXEC:
5830
 
        do_exec(command);
5831
 
        command_executed++;
5832
 
        break;
 
6851
        do_exec(command);
 
6852
        command_executed++;
 
6853
        break;
5833
6854
      case Q_START_TIMER:
5834
 
        /* Overwrite possible earlier start of timer */
5835
 
        timer_start= timer_now();
5836
 
        break;
 
6855
        /* Overwrite possible earlier start of timer */
 
6856
        timer_start= timer_now();
 
6857
        break;
5837
6858
      case Q_END_TIMER:
5838
 
        /* End timer before ending drizzletest */
5839
 
        timer_output();
5840
 
        break;
 
6859
        /* End timer before ending mysqltest */
 
6860
        timer_output();
 
6861
        break;
5841
6862
      case Q_CHARACTER_SET:
5842
 
        do_set_charset(command);
 
6863
        do_set_charset(command);
 
6864
        break;
 
6865
      case Q_DISABLE_PS_PROTOCOL:
 
6866
        ps_protocol_enabled= 0;
 
6867
        /* Close any open statements */
 
6868
        close_statements();
 
6869
        break;
 
6870
      case Q_ENABLE_PS_PROTOCOL:
 
6871
        ps_protocol_enabled= ps_protocol;
5843
6872
        break;
5844
6873
      case Q_DISABLE_RECONNECT:
5845
 
        set_reconnect(&cur_con->con, 0);
 
6874
        set_reconnect(&cur_con->mysql, 0);
5846
6875
        break;
5847
6876
      case Q_ENABLE_RECONNECT:
5848
 
        set_reconnect(&cur_con->con, 1);
 
6877
        set_reconnect(&cur_con->mysql, 1);
 
6878
        /* Close any open statements - no reconnect, need new prepare */
 
6879
        close_statements();
5849
6880
        break;
5850
6881
      case Q_DISABLE_PARSING:
5851
6882
        if (parsing_disabled == 0)
5917
6948
      free_all_replace();
5918
6949
 
5919
6950
      /* Also reset "sorted_result" */
5920
 
      display_result_sorted= false;
 
6951
      display_result_sorted= FALSE;
5921
6952
    }
5922
6953
    last_command_executed= command_executed;
5923
6954
 
5936
6967
    Time to compare result or save it to record file.
5937
6968
    The entire output from test is now kept in ds_res.
5938
6969
  */
5939
 
  if (ds_res.length())
 
6970
  if (ds_res.length)
5940
6971
  {
5941
6972
    if (result_file_name)
5942
6973
    {
5944
6975
 
5945
6976
      if (record)
5946
6977
      {
5947
 
        /* Recording - dump the output from test to result file */
5948
 
        str_to_file(result_file_name, ds_res.c_str(), ds_res.length());
 
6978
        /* Recording - dump the output from test to result file */
 
6979
        str_to_file(result_file_name, ds_res.str, ds_res.length);
5949
6980
      }
5950
6981
      else
5951
6982
      {
5952
 
        /* Check that the output from test is equal to result file
5953
 
           - detect missing result file
5954
 
           - detect zero size result file
 
6983
        /* Check that the output from test is equal to result file
 
6984
           - detect missing result file
 
6985
           - detect zero size result file
5955
6986
        */
5956
 
        check_result(&ds_res);
 
6987
        check_result(&ds_res);
5957
6988
      }
5958
6989
    }
5959
6990
    else
5960
6991
    {
5961
6992
      /* No result_file_name specified to compare with, print to stdout */
5962
 
      printf("%s", ds_res.c_str());
 
6993
      printf("%s", ds_res.str);
5963
6994
    }
5964
6995
  }
5965
6996
  else
5984
7015
    dump_progress();
5985
7016
 
5986
7017
  /* Dump warning messages */
5987
 
  if (result_file_name && ds_warning_messages.length())
 
7018
  if (result_file_name && ds_warning_messages.length)
5988
7019
    dump_warning_messages();
5989
7020
 
5990
7021
  timer_output();
6002
7033
  before executing any commands. The time we measure is
6003
7034
 
6004
7035
  - If no explicit 'start_timer' or 'end_timer' is given in the
6005
 
  test case, the timer measure how long we execute in drizzletest.
 
7036
  test case, the timer measure how long we execute in mysqltest.
6006
7037
 
6007
7038
  - If only 'start_timer' is given we measure how long we execute
6008
 
  from that point until we terminate drizzletest.
 
7039
  from that point until we terminate mysqltest.
6009
7040
 
6010
7041
  - If only 'end_timer' is given we measure how long we execute
6011
 
  from that we enter drizzletest to the 'end_timer' is command is
 
7042
  from that we enter mysqltest to the 'end_timer' is command is
6012
7043
  executed.
6013
7044
 
6014
7045
  - If both 'start_timer' and 'end_timer' are given we measure
6019
7050
{
6020
7051
  if (timer_file)
6021
7052
  {
6022
 
    ostringstream buf;
6023
 
    uint64_t timer= timer_now() - timer_start;
6024
 
    buf << timer;
6025
 
    str_to_file(timer_file,buf.str().c_str(), buf.str().size() );
 
7053
    char buf[32], *end;
 
7054
    ulonglong timer= timer_now() - timer_start;
 
7055
    end= longlong2str(timer, buf, 10);
 
7056
    str_to_file(timer_file,buf, (int) (end-buf));
6026
7057
    /* Timer has been written to the file, don't use it anymore */
6027
7058
    timer_file= 0;
6028
7059
  }
6029
7060
}
6030
7061
 
6031
7062
 
6032
 
uint64_t timer_now(void)
 
7063
ulonglong timer_now(void)
6033
7064
{
6034
7065
  return my_micro_time() / 1000;
6035
7066
}
6047
7078
{
6048
7079
  char *from= command->first_argument;
6049
7080
  char *buff, *start;
6050
 
 
 
7081
  DBUG_ENTER("get_replace_columns");
6051
7082
 
6052
7083
  free_replace_column();
6053
7084
  if (!*from)
6054
7085
    die("Missing argument in %s", command->query);
6055
7086
 
6056
7087
  /* Allocate a buffer for results */
6057
 
  start= buff= (char *)malloc(strlen(from)+1);
 
7088
  start= buff= my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
6058
7089
  while (*from)
6059
7090
  {
6060
7091
    char *to;
6061
 
    uint32_t column_number;
 
7092
    uint column_number;
6062
7093
 
6063
7094
    to= get_string(&buff, &from, command);
6064
7095
    if (!(column_number= atoi(to)) || column_number > MAX_COLUMNS)
6066
7097
    if (!*from)
6067
7098
      die("Wrong number of arguments to replace_column in '%s'", command->query);
6068
7099
    to= get_string(&buff, &from, command);
6069
 
    free(replace_column[column_number-1]);
6070
 
    replace_column[column_number-1]= strdup(to);
6071
 
    if (replace_column[column_number-1] == NULL)
6072
 
      die("Out of memory");
 
7100
    my_free(replace_column[column_number-1], MY_ALLOW_ZERO_PTR);
 
7101
    replace_column[column_number-1]= my_strdup(to, MYF(MY_WME | MY_FAE));
6073
7102
    set_if_bigger(max_replace_column, column_number);
6074
7103
  }
6075
 
  free(start);
 
7104
  my_free(start, MYF(0));
6076
7105
  command->last_argument= command->end;
6077
7106
}
6078
7107
 
6079
7108
 
6080
7109
void free_replace_column()
6081
7110
{
6082
 
  uint32_t i;
 
7111
  uint i;
6083
7112
  for (i=0 ; i < max_replace_column ; i++)
6084
7113
  {
6085
7114
    if (replace_column[i])
6086
7115
    {
6087
 
      free(replace_column[i]);
 
7116
      my_free(replace_column[i], 0);
6088
7117
      replace_column[i]= 0;
6089
7118
    }
6090
7119
  }
6099
7128
 
6100
7129
/* Definitions for replace result */
6101
7130
 
6102
 
typedef struct st_pointer_array {    /* when using array-strings */
6103
 
  TYPELIB typelib;        /* Pointer to strings */
6104
 
  unsigned char  *str;          /* Strings is here */
6105
 
  uint8_t *flag;          /* Flag about each var. */
6106
 
  uint32_t  array_allocs,max_count,length,max_length;
 
7131
typedef struct st_pointer_array {               /* when using array-strings */
 
7132
  TYPELIB typelib;                              /* Pointer to strings */
 
7133
  uchar *str;                                   /* Strings is here */
 
7134
  int7  *flag;                                  /* Flag about each var. */
 
7135
  uint  array_allocs,max_count,length,max_length;
6107
7136
} POINTER_ARRAY;
6108
7137
 
6109
7138
struct st_replace;
6110
 
struct st_replace *init_replace(char * *from, char * *to, uint32_t count,
6111
 
                                char * word_end_chars);
 
7139
struct st_replace *init_replace(char * *from, char * *to, uint count,
 
7140
                                char * word_end_chars);
6112
7141
int insert_pointer_name(POINTER_ARRAY *pa,char * name);
6113
 
void replace_strings_append(struct st_replace *rep, string* ds,
 
7142
void replace_strings_append(struct st_replace *rep, DYNAMIC_STRING* ds,
6114
7143
                            const char *from, int len);
6115
7144
void free_pointer_array(POINTER_ARRAY *pa);
6116
7145
 
6117
 
struct st_replace *glob_replace= NULL;
 
7146
struct st_replace *glob_replace;
6118
7147
 
6119
7148
/*
6120
7149
  Get arguments for replace. The syntax is:
6126
7155
 
6127
7156
void do_get_replace(struct st_command *command)
6128
7157
{
6129
 
  uint32_t i;
 
7158
  uint i;
6130
7159
  char *from= command->first_argument;
6131
7160
  char *buff, *start;
6132
7161
  char word_end_chars[256], *pos;
6133
7162
  POINTER_ARRAY to_array, from_array;
6134
 
 
 
7163
  DBUG_ENTER("get_replace");
6135
7164
 
6136
7165
  free_replace();
6137
7166
 
6138
 
  memset(&to_array, 0, sizeof(to_array));
6139
 
  memset(&from_array, 0, sizeof(from_array));
 
7167
  bzero((char*) &to_array,sizeof(to_array));
 
7168
  bzero((char*) &from_array,sizeof(from_array));
6140
7169
  if (!*from)
6141
7170
    die("Missing argument in %s", command->query);
6142
 
  start= buff= (char *)malloc(strlen(from)+1);
 
7171
  start= buff= my_malloc(strlen(from)+1,MYF(MY_WME | MY_FAE));
6143
7172
  while (*from)
6144
7173
  {
6145
7174
    char *to= buff;
6154
7183
  for (i= 1,pos= word_end_chars ; i < 256 ; i++)
6155
7184
    if (my_isspace(charset_info,i))
6156
7185
      *pos++= i;
6157
 
  *pos=0;          /* End pointer */
 
7186
  *pos=0;                                       /* End pointer */
6158
7187
  if (!(glob_replace= init_replace((char**) from_array.typelib.type_names,
6159
 
                                   (char**) to_array.typelib.type_names,
6160
 
                                   (uint32_t) from_array.typelib.count,
6161
 
                                   word_end_chars)))
 
7188
                                  (char**) to_array.typelib.type_names,
 
7189
                                  (uint) from_array.typelib.count,
 
7190
                                  word_end_chars)))
6162
7191
    die("Can't initialize replace from '%s'", command->query);
6163
7192
  free_pointer_array(&from_array);
6164
7193
  free_pointer_array(&to_array);
6165
 
  free(start);
 
7194
  my_free(start, MYF(0));
6166
7195
  command->last_argument= command->end;
6167
 
  return;
 
7196
  DBUG_VOID_RETURN;
6168
7197
}
6169
7198
 
6170
7199
 
6171
7200
void free_replace()
6172
7201
{
6173
 
 
 
7202
  DBUG_ENTER("free_replace");
6174
7203
  if (glob_replace)
6175
7204
  {
6176
 
    free(glob_replace);
 
7205
    my_free(glob_replace,MYF(0));
6177
7206
    glob_replace=0;
6178
7207
  }
6179
 
  return;
 
7208
  DBUG_VOID_RETURN;
6180
7209
}
6181
7210
 
6182
7211
 
6183
7212
typedef struct st_replace {
6184
 
  bool found;
 
7213
  my_bool found;
6185
7214
  struct st_replace *next[256];
6186
7215
} REPLACE;
6187
7216
 
6188
7217
typedef struct st_replace_found {
6189
 
  bool found;
 
7218
  my_bool found;
6190
7219
  char *replace_string;
6191
 
  uint32_t to_offset;
 
7220
  uint to_offset;
6192
7221
  int from_offset;
6193
7222
} REPLACE_STRING;
6194
7223
 
6195
7224
 
6196
 
void replace_strings_append(REPLACE *rep, string* ds,
6197
 
                            const char *str, int len)
 
7225
void replace_strings_append(REPLACE *rep, DYNAMIC_STRING* ds,
 
7226
                            const char *str,
 
7227
                            int len __attribute__((unused)))
6198
7228
{
6199
7229
  register REPLACE *rep_pos;
6200
7230
  register REPLACE_STRING *rep_str;
6201
7231
  const char *start, *from;
6202
 
 
 
7232
  DBUG_ENTER("replace_strings_append");
6203
7233
 
6204
7234
  start= from= str;
6205
7235
  rep_pos=rep+1;
6206
7236
  for (;;)
6207
7237
  {
6208
7238
    /* Loop through states */
 
7239
    DBUG_PRINT("info", ("Looping through states"));
6209
7240
    while (!rep_pos->found)
6210
 
      rep_pos= rep_pos->next[(unsigned char) *from++];
 
7241
      rep_pos= rep_pos->next[(uchar) *from++];
6211
7242
 
6212
7243
    /* Does this state contain a string to be replaced */
6213
7244
    if (!(rep_str = ((REPLACE_STRING*) rep_pos))->replace_string)
6214
7245
    {
6215
7246
      /* No match found */
6216
 
      ds->append(start, from - start - 1);
6217
 
      return;
 
7247
      dynstr_append_mem(ds, start, from - start - 1);
 
7248
      DBUG_PRINT("exit", ("Found no more string to replace, appended: %s", start));
 
7249
      DBUG_VOID_RETURN;
6218
7250
    }
6219
7251
 
 
7252
    /* Found a string that needs to be replaced */
 
7253
    DBUG_PRINT("info", ("found: %d, to_offset: %d, from_offset: %d, string: %s",
 
7254
                        rep_str->found, rep_str->to_offset,
 
7255
                        rep_str->from_offset, rep_str->replace_string));
 
7256
 
6220
7257
    /* Append part of original string before replace string */
6221
 
    ds->append(start, (from - rep_str->to_offset) - start);
 
7258
    dynstr_append_mem(ds, start, (from - rep_str->to_offset) - start);
6222
7259
 
6223
7260
    /* Append replace string */
6224
 
    ds->append(rep_str->replace_string,
6225
 
               strlen(rep_str->replace_string));
 
7261
    dynstr_append_mem(ds, rep_str->replace_string,
 
7262
                      strlen(rep_str->replace_string));
6226
7263
 
6227
7264
    if (!*(from-=rep_str->from_offset) && rep_pos->found != 2)
6228
 
      return;
6229
 
 
6230
 
    assert(from <= str+len);
 
7265
    {
 
7266
      /* End of from string */
 
7267
      DBUG_PRINT("exit", ("Found end of from string"));
 
7268
      DBUG_VOID_RETURN;
 
7269
    }
 
7270
    DBUG_ASSERT(from <= str+len);
6231
7271
    start= from;
6232
7272
    rep_pos=rep;
6233
7273
  }
6246
7286
  char* pattern; /* Pattern to be replaced */
6247
7287
  char* replace; /* String or expression to replace the pattern with */
6248
7288
  int icase; /* true if the match is case insensitive */
6249
 
  int global; /* true if the match should be global -- 
6250
 
                 i.e. repeat the matching until the end of the string */
6251
7289
};
6252
7290
 
6253
7291
struct st_replace_regex
6271
7309
struct st_replace_regex *glob_replace_regex= 0;
6272
7310
 
6273
7311
int reg_replace(char** buf_p, int* buf_len_p, char *pattern, char *replace,
6274
 
                char *string, int icase, int global);
 
7312
                char *string, int icase);
6275
7313
 
6276
7314
 
6277
7315
 
6310
7348
  Returns: st_replace_regex struct with pairs of substitutions
6311
7349
*/
6312
7350
 
6313
 
static struct st_replace_regex* init_replace_regex(char* expr)
 
7351
struct st_replace_regex* init_replace_regex(char* expr)
6314
7352
{
6315
7353
  struct st_replace_regex* res;
6316
7354
  char* buf,*expr_end;
6317
7355
  char* p;
6318
7356
  char* buf_p;
6319
 
  uint32_t expr_len= strlen(expr);
 
7357
  uint expr_len= strlen(expr);
6320
7358
  char last_c = 0;
6321
7359
  struct st_regex reg;
6322
7360
 
6323
 
  res=(st_replace_regex*)malloc(sizeof(*res)+expr_len);
6324
 
  if (!res)
6325
 
    return NULL;
 
7361
  /* my_malloc() will die on fail with MY_FAE */
 
7362
  res=(struct st_replace_regex*)my_malloc(
 
7363
                                          sizeof(*res)+expr_len ,MYF(MY_FAE+MY_WME));
6326
7364
  my_init_dynamic_array(&res->regex_arr,sizeof(struct st_regex),128,128);
6327
7365
 
6328
7366
  buf= (char*)res + sizeof(*res);
6333
7371
  /* for each regexp substitution statement */
6334
7372
  while (p < expr_end)
6335
7373
  {
6336
 
    memset(&reg, 0, sizeof(reg));
 
7374
    bzero(&reg,sizeof(reg));
6337
7375
    /* find the start of the statement */
6338
7376
    while (p < expr_end)
6339
7377
    {
6372
7410
 
6373
7411
    /* Check if we should do matching case insensitive */
6374
7412
    if (p < expr_end && *p == 'i')
6375
 
    {
6376
 
      p++;
6377
7413
      reg.icase= 1;
6378
 
    }
6379
 
 
6380
 
    /* Check if we should do matching globally */
6381
 
    if (p < expr_end && *p == 'g')
6382
 
    {
6383
 
      p++;
6384
 
      reg.global= 1;
6385
 
    }
6386
7414
 
6387
7415
    /* done parsing the statement, now place it in regex_arr */
6388
 
    if (insert_dynamic(&res->regex_arr,(unsigned char*) &reg))
 
7416
    if (insert_dynamic(&res->regex_arr,(uchar*) &reg))
6389
7417
      die("Out of memory");
6390
7418
  }
6391
7419
  res->odd_buf_len= res->even_buf_len= 8192;
6392
 
  res->even_buf= (char*)malloc(res->even_buf_len);
6393
 
  res->odd_buf= (char*)malloc(res->odd_buf_len);
 
7420
  res->even_buf= (char*)my_malloc(res->even_buf_len,MYF(MY_WME+MY_FAE));
 
7421
  res->odd_buf= (char*)my_malloc(res->odd_buf_len,MYF(MY_WME+MY_FAE));
6394
7422
  res->buf= res->even_buf;
6395
7423
 
6396
7424
  return res;
6397
7425
 
6398
7426
err:
6399
 
  free(res);
 
7427
  my_free(res,0);
6400
7428
  die("Error parsing replace_regex \"%s\"", expr);
6401
7429
  return 0;
6402
7430
}
6420
7448
  in one pass
6421
7449
*/
6422
7450
 
6423
 
static int multi_reg_replace(struct st_replace_regex* r,char* val)
 
7451
int multi_reg_replace(struct st_replace_regex* r,char* val)
6424
7452
{
6425
 
  uint32_t i;
 
7453
  uint i;
6426
7454
  char* in_buf, *out_buf;
6427
7455
  int* buf_len_p;
6428
7456
 
6437
7465
    struct st_regex re;
6438
7466
    char* save_out_buf= out_buf;
6439
7467
 
6440
 
    get_dynamic(&r->regex_arr,(unsigned char*)&re,i);
 
7468
    get_dynamic(&r->regex_arr,(uchar*)&re,i);
6441
7469
 
6442
7470
    if (!reg_replace(&out_buf, buf_len_p, re.pattern, re.replace,
6443
 
                     in_buf, re.icase, re.global))
 
7471
                     in_buf, re.icase))
6444
7472
    {
6445
7473
      /* if the buffer has been reallocated, make adjustements */
6446
7474
      if (save_out_buf != out_buf)
6455
7483
      if (in_buf == val)
6456
7484
        in_buf= r->odd_buf;
6457
7485
 
6458
 
      std::swap(in_buf,out_buf);
 
7486
      swap_variables(char*,in_buf,out_buf);
6459
7487
 
6460
7488
      buf_len_p= (out_buf == r->even_buf) ? &r->even_buf_len :
6461
7489
        &r->odd_buf_len;
6488
7516
  if (glob_replace_regex)
6489
7517
  {
6490
7518
    delete_dynamic(&glob_replace_regex->regex_arr);
6491
 
    free(glob_replace_regex->even_buf);
6492
 
    free(glob_replace_regex->odd_buf);
6493
 
    free(glob_replace_regex);
 
7519
    my_free(glob_replace_regex->even_buf,MYF(MY_ALLOW_ZERO_PTR));
 
7520
    my_free(glob_replace_regex->odd_buf,MYF(MY_ALLOW_ZERO_PTR));
 
7521
    my_free(glob_replace_regex,MYF(0));
6494
7522
    glob_replace_regex=0;
6495
7523
  }
6496
7524
}
6498
7526
 
6499
7527
 
6500
7528
/*
 
7529
  auxiluary macro used by reg_replace
 
7530
  makes sure the result buffer has sufficient length
 
7531
*/
 
7532
#define SECURE_REG_BUF   if (buf_len < need_buf_len)                    \
 
7533
  {                                                                     \
 
7534
    int off= res_p - buf;                                               \
 
7535
    buf= (char*)my_realloc(buf,need_buf_len,MYF(MY_WME+MY_FAE));        \
 
7536
    res_p= buf + off;                                                   \
 
7537
    buf_len= need_buf_len;                                              \
 
7538
  }                                                                     \
 
7539
                                                                        \
 
7540
/*
6501
7541
  Performs a regex substitution
6502
7542
 
6503
7543
  IN:
6510
7550
  icase - flag, if set to 1 the match is case insensitive
6511
7551
*/
6512
7552
int reg_replace(char** buf_p, int* buf_len_p, char *pattern,
6513
 
                char *replace, char *in_string, int icase, int global)
 
7553
                char *replace, char *string, int icase)
6514
7554
{
6515
 
  const char *error= NULL;
6516
 
  int erroffset;
6517
 
  int ovector[3];
6518
 
  pcre *re= pcre_compile(pattern,
6519
 
                         icase ? PCRE_CASELESS | PCRE_MULTILINE : PCRE_MULTILINE,
6520
 
                         &error, &erroffset, NULL);
6521
 
  if (re == NULL)
 
7555
  my_regex_t r;
 
7556
  my_regmatch_t *subs;
 
7557
  char *replace_end;
 
7558
  char *buf= *buf_p;
 
7559
  int len;
 
7560
  int buf_len, need_buf_len;
 
7561
  int cflags= REG_EXTENDED;
 
7562
  int err_code;
 
7563
  char *res_p,*str_p,*str_end;
 
7564
 
 
7565
  buf_len= *buf_len_p;
 
7566
  len= strlen(string);
 
7567
  str_end= string + len;
 
7568
 
 
7569
  /* start with a buffer of a reasonable size that hopefully will not
 
7570
     need to be reallocated
 
7571
  */
 
7572
  need_buf_len= len * 2 + 1;
 
7573
  res_p= buf;
 
7574
 
 
7575
  SECURE_REG_BUF
 
7576
 
 
7577
  if (icase)
 
7578
    cflags|= REG_ICASE;
 
7579
 
 
7580
  if ((err_code= my_regcomp(&r,pattern,cflags,&my_charset_latin1)))
 
7581
  {
 
7582
    check_regerr(&r,err_code);
6522
7583
    return 1;
6523
 
 
6524
 
  if (! global)
6525
 
  {
6526
 
 
6527
 
    int rc= pcre_exec(re, NULL, in_string, (int)strlen(in_string),
6528
 
                      0, 0, ovector, 3);
6529
 
    if (rc < 0)
6530
 
    {
6531
 
      pcre_free(re);
6532
 
      return 1;
6533
 
    }
6534
 
 
6535
 
    char *substring_to_replace= in_string + ovector[0];
6536
 
    int substring_length= ovector[1] - ovector[0];
6537
 
    *buf_len_p= strlen(in_string) - substring_length + strlen(replace);
6538
 
    char * new_buf = (char *)malloc(*buf_len_p+1);
6539
 
    if (new_buf == NULL)
6540
 
    {
6541
 
      pcre_free(re);
6542
 
      return 1;
6543
 
    }
6544
 
 
6545
 
    memset(new_buf, 0, *buf_len_p+1);
6546
 
    strncpy(new_buf, in_string, substring_to_replace-in_string);
6547
 
    strncpy(new_buf+(substring_to_replace-in_string), replace, strlen(replace));
6548
 
    strncpy(new_buf+(substring_to_replace-in_string)+strlen(replace),
6549
 
            substring_to_replace + substring_length,
6550
 
            strlen(in_string)
6551
 
              - substring_length
6552
 
              - (substring_to_replace-in_string));
6553
 
    *buf_p= new_buf;
6554
 
 
6555
 
    pcre_free(re);
6556
 
    return 0;
6557
 
  }
6558
 
  else
6559
 
  {
6560
 
    /* Repeatedly replace the string with the matched regex */
6561
 
    string subject(in_string);
6562
 
    size_t replace_length= strlen(replace);
6563
 
    size_t current_position= 0;
6564
 
    int rc= 0;
6565
 
    while(0 >= (rc= pcre_exec(re, NULL, subject.c_str() + current_position, subject.length() - current_position,
6566
 
                      0, 0, ovector, 3)))
6567
 
    {
6568
 
      current_position= static_cast<size_t>(ovector[0]);
6569
 
      replace_length= static_cast<size_t>(ovector[1] - ovector[0]);
6570
 
      subject.replace(current_position, replace_length, replace, replace_length);
6571
 
    }
6572
 
 
6573
 
    char *new_buf = (char *) malloc(subject.length() + 1);
6574
 
    if (new_buf == NULL)
6575
 
    {
6576
 
      pcre_free(re);
6577
 
      return 1;
6578
 
    }
6579
 
    memset(new_buf, 0, subject.length() + 1);
6580
 
    strncpy(new_buf, subject.c_str(), subject.length());
6581
 
    *buf_len_p= subject.length() + 1;
6582
 
    *buf_p= new_buf;
6583
 
          
6584
 
    pcre_free(re);
6585
 
    return 0;
6586
 
  }
 
7584
  }
 
7585
 
 
7586
  subs= (my_regmatch_t*)my_malloc(sizeof(my_regmatch_t) * (r.re_nsub+1),
 
7587
                                  MYF(MY_WME+MY_FAE));
 
7588
 
 
7589
  *res_p= 0;
 
7590
  str_p= string;
 
7591
  replace_end= replace + strlen(replace);
 
7592
 
 
7593
  /* for each pattern match instance perform a replacement */
 
7594
  while (!err_code)
 
7595
  {
 
7596
    /* find the match */
 
7597
    err_code= my_regexec(&r,str_p, r.re_nsub+1, subs,
 
7598
                         (str_p == string) ? REG_NOTBOL : 0);
 
7599
 
 
7600
    /* if regular expression error (eg. bad syntax, or out of memory) */
 
7601
    if (err_code && err_code != REG_NOMATCH)
 
7602
    {
 
7603
      check_regerr(&r,err_code);
 
7604
      my_regfree(&r);
 
7605
      return 1;
 
7606
    }
 
7607
 
 
7608
    /* if match found */
 
7609
    if (!err_code)
 
7610
    {
 
7611
      char* expr_p= replace;
 
7612
      int c;
 
7613
 
 
7614
      /*
 
7615
        we need at least what we have so far in the buffer + the part
 
7616
        before this match
 
7617
      */
 
7618
      need_buf_len= (res_p - buf) + (int) subs[0].rm_so;
 
7619
 
 
7620
      /* on this pass, calculate the memory for the result buffer */
 
7621
      while (expr_p < replace_end)
 
7622
      {
 
7623
        int back_ref_num= -1;
 
7624
        c= *expr_p;
 
7625
 
 
7626
        if (c == '\\' && expr_p + 1 < replace_end)
 
7627
        {
 
7628
          back_ref_num= (int) (expr_p[1] - '0');
 
7629
        }
 
7630
 
 
7631
        /* found a valid back_ref (eg. \1)*/
 
7632
        if (back_ref_num >= 0 && back_ref_num <= (int)r.re_nsub)
 
7633
        {
 
7634
          regoff_t start_off, end_off;
 
7635
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
 
7636
              (end_off=subs[back_ref_num].rm_eo) > -1)
 
7637
          {
 
7638
            need_buf_len += (int) (end_off - start_off);
 
7639
          }
 
7640
          expr_p += 2;
 
7641
        }
 
7642
        else
 
7643
        {
 
7644
          expr_p++;
 
7645
          need_buf_len++;
 
7646
        }
 
7647
      }
 
7648
      need_buf_len++;
 
7649
      /*
 
7650
        now that we know the size of the buffer,
 
7651
        make sure it is big enough
 
7652
      */
 
7653
      SECURE_REG_BUF
 
7654
 
 
7655
        /* copy the pre-match part */
 
7656
        if (subs[0].rm_so)
 
7657
        {
 
7658
          memcpy(res_p, str_p, (size_t) subs[0].rm_so);
 
7659
          res_p+= subs[0].rm_so;
 
7660
        }
 
7661
 
 
7662
      expr_p= replace;
 
7663
 
 
7664
      /* copy the match and expand back_refs */
 
7665
      while (expr_p < replace_end)
 
7666
      {
 
7667
        int back_ref_num= -1;
 
7668
        c= *expr_p;
 
7669
 
 
7670
        if (c == '\\' && expr_p + 1 < replace_end)
 
7671
        {
 
7672
          back_ref_num= expr_p[1] - '0';
 
7673
        }
 
7674
 
 
7675
        if (back_ref_num >= 0 && back_ref_num <= (int)r.re_nsub)
 
7676
        {
 
7677
          regoff_t start_off, end_off;
 
7678
          if ((start_off=subs[back_ref_num].rm_so) > -1 &&
 
7679
              (end_off=subs[back_ref_num].rm_eo) > -1)
 
7680
          {
 
7681
            int block_len= (int) (end_off - start_off);
 
7682
            memcpy(res_p,str_p + start_off, block_len);
 
7683
            res_p += block_len;
 
7684
          }
 
7685
          expr_p += 2;
 
7686
        }
 
7687
        else
 
7688
        {
 
7689
          *res_p++ = *expr_p++;
 
7690
        }
 
7691
      }
 
7692
 
 
7693
      /* handle the post-match part */
 
7694
      if (subs[0].rm_so == subs[0].rm_eo)
 
7695
      {
 
7696
        if (str_p + subs[0].rm_so >= str_end)
 
7697
          break;
 
7698
        str_p += subs[0].rm_eo ;
 
7699
        *res_p++ = *str_p++;
 
7700
      }
 
7701
      else
 
7702
      {
 
7703
        str_p += subs[0].rm_eo;
 
7704
      }
 
7705
    }
 
7706
    else /* no match this time, just copy the string as is */
 
7707
    {
 
7708
      int left_in_str= str_end-str_p;
 
7709
      need_buf_len= (res_p-buf) + left_in_str;
 
7710
      SECURE_REG_BUF
 
7711
        memcpy(res_p,str_p,left_in_str);
 
7712
      res_p += left_in_str;
 
7713
      str_p= str_end;
 
7714
    }
 
7715
  }
 
7716
  my_free(subs, MYF(0));
 
7717
  my_regfree(&r);
 
7718
  *res_p= 0;
 
7719
  *buf_p= buf;
 
7720
  *buf_len_p= buf_len;
 
7721
  return 0;
6587
7722
}
6588
7723
 
6589
7724
 
6590
7725
#ifndef WORD_BIT
6591
 
#define WORD_BIT (8*sizeof(uint32_t))
 
7726
#define WORD_BIT (8*sizeof(uint))
6592
7727
#endif
6593
7728
 
6594
7729
#define SET_MALLOC_HUNC 64
6595
7730
#define LAST_CHAR_CODE 259
6596
7731
 
6597
7732
typedef struct st_rep_set {
6598
 
  uint32_t  *bits;        /* Pointer to used sets */
6599
 
  short next[LAST_CHAR_CODE];    /* Pointer to next sets */
6600
 
  uint32_t  found_len;      /* Best match to date */
6601
 
  int  found_offset;
6602
 
  uint32_t  table_offset;
6603
 
  uint32_t  size_of_bits;      /* For convinience */
 
7733
  uint  *bits;                          /* Pointer to used sets */
 
7734
  short next[LAST_CHAR_CODE];           /* Pointer to next sets */
 
7735
  uint  found_len;                      /* Best match to date */
 
7736
  int   found_offset;
 
7737
  uint  table_offset;
 
7738
  uint  size_of_bits;                   /* For convinience */
6604
7739
} REP_SET;
6605
7740
 
6606
7741
typedef struct st_rep_sets {
6607
 
  uint32_t    count;      /* Number of sets */
6608
 
  uint32_t    extra;      /* Extra sets in buffer */
6609
 
  uint32_t    invisible;    /* Sets not chown */
6610
 
  uint32_t    size_of_bits;
6611
 
  REP_SET  *set,*set_buffer;
6612
 
  uint32_t    *bit_buffer;
 
7742
  uint          count;                  /* Number of sets */
 
7743
  uint          extra;                  /* Extra sets in buffer */
 
7744
  uint          invisible;              /* Sets not chown */
 
7745
  uint          size_of_bits;
 
7746
  REP_SET       *set,*set_buffer;
 
7747
  uint          *bit_buffer;
6613
7748
} REP_SETS;
6614
7749
 
6615
7750
typedef struct st_found_set {
6616
 
  uint32_t table_offset;
 
7751
  uint table_offset;
6617
7752
  int found_offset;
6618
7753
} FOUND_SET;
6619
7754
 
6620
7755
typedef struct st_follow {
6621
7756
  int chr;
6622
 
  uint32_t table_offset;
6623
 
  uint32_t len;
 
7757
  uint table_offset;
 
7758
  uint len;
6624
7759
} FOLLOWS;
6625
7760
 
6626
7761
 
6627
 
int init_sets(REP_SETS *sets,uint32_t states);
 
7762
int init_sets(REP_SETS *sets,uint states);
6628
7763
REP_SET *make_new_set(REP_SETS *sets);
6629
7764
void make_sets_invisible(REP_SETS *sets);
6630
7765
void free_last_set(REP_SETS *sets);
6631
7766
void free_sets(REP_SETS *sets);
6632
 
void internal_set_bit(REP_SET *set, uint32_t bit);
6633
 
void internal_clear_bit(REP_SET *set, uint32_t bit);
 
7767
void internal_set_bit(REP_SET *set, uint bit);
 
7768
void internal_clear_bit(REP_SET *set, uint bit);
6634
7769
void or_bits(REP_SET *to,REP_SET *from);
6635
7770
void copy_bits(REP_SET *to,REP_SET *from);
6636
7771
int cmp_bits(REP_SET *set1,REP_SET *set2);
6637
 
int get_next_bit(REP_SET *set,uint32_t lastpos);
 
7772
int get_next_bit(REP_SET *set,uint lastpos);
6638
7773
int find_set(REP_SETS *sets,REP_SET *find);
6639
 
int find_found(FOUND_SET *found_set,uint32_t table_offset,
 
7774
int find_found(FOUND_SET *found_set,uint table_offset,
6640
7775
               int found_offset);
6641
 
uint32_t start_at_word(char * pos);
6642
 
uint32_t end_of_word(char * pos);
6643
 
 
6644
 
static uint32_t found_sets=0;
6645
 
 
6646
 
 
6647
 
static uint32_t replace_len(char * str)
 
7776
uint start_at_word(char * pos);
 
7777
uint end_of_word(char * pos);
 
7778
 
 
7779
static uint found_sets=0;
 
7780
 
 
7781
 
 
7782
uint replace_len(char * str)
6648
7783
{
6649
 
  uint32_t len=0;
 
7784
  uint len=0;
6650
7785
  while (*str)
6651
7786
  {
6652
7787
    if (str[0] == '\\' && str[1])
6659
7794
 
6660
7795
/* Init a replace structure for further calls */
6661
7796
 
6662
 
REPLACE *init_replace(char * *from, char * *to,uint32_t count,
6663
 
                      char * word_end_chars)
 
7797
REPLACE *init_replace(char * *from, char * *to,uint count,
 
7798
                      char * word_end_chars)
6664
7799
{
6665
7800
  static const int SPACE_CHAR= 256;
6666
7801
  static const int START_OF_LINE= 257;
6667
7802
  static const int END_OF_LINE= 258;
6668
7803
 
6669
 
  uint32_t i,j,states,set_nr,len,result_len,max_length,found_end,bits_set,bit_nr;
 
7804
  uint i,j,states,set_nr,len,result_len,max_length,found_end,bits_set,bit_nr;
6670
7805
  int used_sets,chr,default_state;
6671
7806
  char used_chars[LAST_CHAR_CODE],is_word_end[256];
6672
7807
  char * pos, *to_pos, **to_array;
6676
7811
  REPLACE *replace;
6677
7812
  FOUND_SET *found_set;
6678
7813
  REPLACE_STRING *rep_str;
6679
 
 
 
7814
  DBUG_ENTER("init_replace");
6680
7815
 
6681
7816
  /* Count number of states */
6682
7817
  for (i=result_len=max_length=0 , states=2 ; i < count ; i++)
6685
7820
    if (!len)
6686
7821
    {
6687
7822
      errno=EINVAL;
6688
 
      return(0);
 
7823
      DBUG_RETURN(0);
6689
7824
    }
6690
7825
    states+=len+1;
6691
 
    result_len+=(uint32_t) strlen(to[i])+1;
 
7826
    result_len+=(uint) strlen(to[i])+1;
6692
7827
    if (len > max_length)
6693
7828
      max_length=len;
6694
7829
  }
6695
 
  memset(is_word_end, 0, sizeof(is_word_end));
 
7830
  bzero((char*) is_word_end,sizeof(is_word_end));
6696
7831
  for (i=0 ; word_end_chars[i] ; i++)
6697
 
    is_word_end[(unsigned char) word_end_chars[i]]=1;
 
7832
    is_word_end[(uchar) word_end_chars[i]]=1;
6698
7833
 
6699
7834
  if (init_sets(&sets,states))
6700
 
    return(0);
 
7835
    DBUG_RETURN(0);
6701
7836
  found_sets=0;
6702
 
  if (!(found_set= (FOUND_SET*) malloc(sizeof(FOUND_SET)*max_length*count)))
6703
 
                                
 
7837
  if (!(found_set= (FOUND_SET*) my_malloc(sizeof(FOUND_SET)*max_length*count,
 
7838
                                          MYF(MY_WME))))
6704
7839
  {
6705
7840
    free_sets(&sets);
6706
 
    return(0);
 
7841
    DBUG_RETURN(0);
6707
7842
  }
6708
 
  make_new_set(&sets);      /* Set starting set */
6709
 
  make_sets_invisible(&sets);      /* Hide previus sets */
 
7843
  VOID(make_new_set(&sets));                    /* Set starting set */
 
7844
  make_sets_invisible(&sets);                   /* Hide previus sets */
6710
7845
  used_sets=-1;
6711
 
  word_states=make_new_set(&sets);    /* Start of new word */
6712
 
  start_states=make_new_set(&sets);    /* This is first state */
6713
 
  if (!(follow=(FOLLOWS*) malloc((states+2)*sizeof(FOLLOWS))))
 
7846
  word_states=make_new_set(&sets);              /* Start of new word */
 
7847
  start_states=make_new_set(&sets);             /* This is first state */
 
7848
  if (!(follow=(FOLLOWS*) my_malloc((states+2)*sizeof(FOLLOWS),MYF(MY_WME))))
6714
7849
  {
6715
7850
    free_sets(&sets);
6716
 
    free(found_set);
6717
 
    return(0);
 
7851
    my_free(found_set,MYF(0));
 
7852
    DBUG_RETURN(0);
6718
7853
  }
6719
7854
 
6720
7855
  /* Init follow_ptr[] */
6725
7860
      internal_set_bit(start_states,states+1);
6726
7861
      if (!from[i][2])
6727
7862
      {
6728
 
        start_states->table_offset=i;
6729
 
        start_states->found_offset=1;
 
7863
        start_states->table_offset=i;
 
7864
        start_states->found_offset=1;
6730
7865
      }
6731
7866
    }
6732
7867
    else if (from[i][0] == '\\' && from[i][1] == '$')
6733
7868
    {
6734
7869
      internal_set_bit(start_states,states);
6735
7870
      internal_set_bit(word_states,states);
6736
 
      if (!from[i][2] && start_states->table_offset == UINT32_MAX)
 
7871
      if (!from[i][2] && start_states->table_offset == (uint) ~0)
6737
7872
      {
6738
 
        start_states->table_offset=i;
6739
 
        start_states->found_offset=0;
 
7873
        start_states->table_offset=i;
 
7874
        start_states->found_offset=0;
6740
7875
      }
6741
7876
    }
6742
7877
    else
6743
7878
    {
6744
7879
      internal_set_bit(word_states,states);
6745
7880
      if (from[i][0] == '\\' && (from[i][1] == 'b' && from[i][2]))
6746
 
        internal_set_bit(start_states,states+1);
 
7881
        internal_set_bit(start_states,states+1);
6747
7882
      else
6748
 
        internal_set_bit(start_states,states);
 
7883
        internal_set_bit(start_states,states);
6749
7884
    }
6750
7885
    for (pos=from[i], len=0; *pos ; pos++)
6751
7886
    {
6752
7887
      if (*pos == '\\' && *(pos+1))
6753
7888
      {
6754
 
        pos++;
6755
 
        switch (*pos) {
6756
 
        case 'b':
6757
 
          follow_ptr->chr = SPACE_CHAR;
6758
 
          break;
6759
 
        case '^':
6760
 
          follow_ptr->chr = START_OF_LINE;
6761
 
          break;
6762
 
        case '$':
6763
 
          follow_ptr->chr = END_OF_LINE;
6764
 
          break;
6765
 
        case 'r':
6766
 
          follow_ptr->chr = '\r';
6767
 
          break;
6768
 
        case 't':
6769
 
          follow_ptr->chr = '\t';
6770
 
          break;
6771
 
        case 'v':
6772
 
          follow_ptr->chr = '\v';
6773
 
          break;
6774
 
        default:
6775
 
          follow_ptr->chr = (unsigned char) *pos;
6776
 
          break;
6777
 
        }
 
7889
        pos++;
 
7890
        switch (*pos) {
 
7891
        case 'b':
 
7892
          follow_ptr->chr = SPACE_CHAR;
 
7893
          break;
 
7894
        case '^':
 
7895
          follow_ptr->chr = START_OF_LINE;
 
7896
          break;
 
7897
        case '$':
 
7898
          follow_ptr->chr = END_OF_LINE;
 
7899
          break;
 
7900
        case 'r':
 
7901
          follow_ptr->chr = '\r';
 
7902
          break;
 
7903
        case 't':
 
7904
          follow_ptr->chr = '\t';
 
7905
          break;
 
7906
        case 'v':
 
7907
          follow_ptr->chr = '\v';
 
7908
          break;
 
7909
        default:
 
7910
          follow_ptr->chr = (uchar) *pos;
 
7911
          break;
 
7912
        }
6778
7913
      }
6779
7914
      else
6780
 
        follow_ptr->chr= (unsigned char) *pos;
 
7915
        follow_ptr->chr= (uchar) *pos;
6781
7916
      follow_ptr->table_offset=i;
6782
7917
      follow_ptr->len= ++len;
6783
7918
      follow_ptr++;
6786
7921
    follow_ptr->table_offset=i;
6787
7922
    follow_ptr->len=len;
6788
7923
    follow_ptr++;
6789
 
    states+=(uint32_t) len+1;
 
7924
    states+=(uint) len+1;
6790
7925
  }
6791
7926
 
6792
7927
 
6793
7928
  for (set_nr=0,pos=0 ; set_nr < sets.count ; set_nr++)
6794
7929
  {
6795
7930
    set=sets.set+set_nr;
6796
 
    default_state= 0;        /* Start from beginning */
 
7931
    default_state= 0;                           /* Start from beginning */
6797
7932
 
6798
7933
    /* If end of found-string not found or start-set with current set */
6799
7934
 
6800
 
    for (i= UINT32_MAX; (i=get_next_bit(set,i)) ;)
 
7935
    for (i= (uint) ~0; (i=get_next_bit(set,i)) ;)
6801
7936
    {
6802
7937
      if (!follow[i].chr)
6803
7938
      {
6804
 
        if (! default_state)
6805
 
          default_state= find_found(found_set,set->table_offset,
6806
 
                                    set->found_offset+1);
 
7939
        if (! default_state)
 
7940
          default_state= find_found(found_set,set->table_offset,
 
7941
                                    set->found_offset+1);
6807
7942
      }
6808
7943
    }
6809
 
    copy_bits(sets.set+used_sets,set);    /* Save set for changes */
 
7944
    copy_bits(sets.set+used_sets,set);          /* Save set for changes */
6810
7945
    if (!default_state)
6811
 
      or_bits(sets.set+used_sets,sets.set);  /* Can restart from start */
 
7946
      or_bits(sets.set+used_sets,sets.set);     /* Can restart from start */
6812
7947
 
6813
7948
    /* Find all chars that follows current sets */
6814
 
    memset(used_chars, 0, sizeof(used_chars));
6815
 
    for (i= UINT32_MAX; (i=get_next_bit(sets.set+used_sets,i)) ;)
 
7949
    bzero((char*) used_chars,sizeof(used_chars));
 
7950
    for (i= (uint) ~0; (i=get_next_bit(sets.set+used_sets,i)) ;)
6816
7951
    {
6817
7952
      used_chars[follow[i].chr]=1;
6818
7953
      if ((follow[i].chr == SPACE_CHAR && !follow[i+1].chr &&
6819
 
           follow[i].len > 1) || follow[i].chr == END_OF_LINE)
6820
 
        used_chars[0]=1;
 
7954
           follow[i].len > 1) || follow[i].chr == END_OF_LINE)
 
7955
        used_chars[0]=1;
6821
7956
    }
6822
7957
 
6823
7958
    /* Mark word_chars used if \b is in state */
6824
7959
    if (used_chars[SPACE_CHAR])
6825
7960
      for (pos= word_end_chars ; *pos ; pos++)
6826
 
        used_chars[(int) (unsigned char) *pos] = 1;
 
7961
        used_chars[(int) (uchar) *pos] = 1;
6827
7962
 
6828
7963
    /* Handle other used characters */
6829
7964
    for (chr= 0 ; chr < 256 ; chr++)
6830
7965
    {
6831
7966
      if (! used_chars[chr])
6832
 
        set->next[chr]= chr ? default_state : -1;
 
7967
        set->next[chr]= chr ? default_state : -1;
6833
7968
      else
6834
7969
      {
6835
 
        new_set=make_new_set(&sets);
6836
 
        set=sets.set+set_nr;      /* if realloc */
6837
 
        new_set->table_offset=set->table_offset;
6838
 
        new_set->found_len=set->found_len;
6839
 
        new_set->found_offset=set->found_offset+1;
6840
 
        found_end=0;
 
7970
        new_set=make_new_set(&sets);
 
7971
        set=sets.set+set_nr;                    /* if realloc */
 
7972
        new_set->table_offset=set->table_offset;
 
7973
        new_set->found_len=set->found_len;
 
7974
        new_set->found_offset=set->found_offset+1;
 
7975
        found_end=0;
6841
7976
 
6842
 
        for (i= UINT32_MAX ; (i=get_next_bit(sets.set+used_sets,i)) ; )
6843
 
        {
6844
 
          if (!follow[i].chr || follow[i].chr == chr ||
6845
 
              (follow[i].chr == SPACE_CHAR &&
6846
 
               (is_word_end[chr] ||
6847
 
                (!chr && follow[i].len > 1 && ! follow[i+1].chr))) ||
6848
 
              (follow[i].chr == END_OF_LINE && ! chr))
6849
 
          {
6850
 
            if ((! chr || (follow[i].chr && !follow[i+1].chr)) &&
6851
 
                follow[i].len > found_end)
6852
 
              found_end=follow[i].len;
6853
 
            if (chr && follow[i].chr)
6854
 
              internal_set_bit(new_set,i+1);    /* To next set */
6855
 
            else
6856
 
              internal_set_bit(new_set,i);
6857
 
          }
6858
 
        }
6859
 
        if (found_end)
6860
 
        {
6861
 
          new_set->found_len=0;      /* Set for testing if first */
6862
 
          bits_set=0;
6863
 
          for (i= UINT32_MAX; (i=get_next_bit(new_set,i)) ;)
6864
 
          {
6865
 
            if ((follow[i].chr == SPACE_CHAR ||
6866
 
                 follow[i].chr == END_OF_LINE) && ! chr)
6867
 
              bit_nr=i+1;
6868
 
            else
6869
 
              bit_nr=i;
6870
 
            if (follow[bit_nr-1].len < found_end ||
6871
 
                (new_set->found_len &&
6872
 
                 (chr == 0 || !follow[bit_nr].chr)))
6873
 
              internal_clear_bit(new_set,i);
6874
 
            else
6875
 
            {
6876
 
              if (chr == 0 || !follow[bit_nr].chr)
6877
 
              {          /* best match  */
6878
 
                new_set->table_offset=follow[bit_nr].table_offset;
6879
 
                if (chr || (follow[i].chr == SPACE_CHAR ||
6880
 
                            follow[i].chr == END_OF_LINE))
6881
 
                  new_set->found_offset=found_end;  /* New match */
6882
 
                new_set->found_len=found_end;
6883
 
              }
6884
 
              bits_set++;
6885
 
            }
6886
 
          }
6887
 
          if (bits_set == 1)
6888
 
          {
6889
 
            set->next[chr] = find_found(found_set,
6890
 
                                        new_set->table_offset,
6891
 
                                        new_set->found_offset);
6892
 
            free_last_set(&sets);
6893
 
          }
6894
 
          else
6895
 
            set->next[chr] = find_set(&sets,new_set);
6896
 
        }
6897
 
        else
6898
 
          set->next[chr] = find_set(&sets,new_set);
 
7977
        for (i= (uint) ~0 ; (i=get_next_bit(sets.set+used_sets,i)) ; )
 
7978
        {
 
7979
          if (!follow[i].chr || follow[i].chr == chr ||
 
7980
              (follow[i].chr == SPACE_CHAR &&
 
7981
               (is_word_end[chr] ||
 
7982
                (!chr && follow[i].len > 1 && ! follow[i+1].chr))) ||
 
7983
              (follow[i].chr == END_OF_LINE && ! chr))
 
7984
          {
 
7985
            if ((! chr || (follow[i].chr && !follow[i+1].chr)) &&
 
7986
                follow[i].len > found_end)
 
7987
              found_end=follow[i].len;
 
7988
            if (chr && follow[i].chr)
 
7989
              internal_set_bit(new_set,i+1);            /* To next set */
 
7990
            else
 
7991
              internal_set_bit(new_set,i);
 
7992
          }
 
7993
        }
 
7994
        if (found_end)
 
7995
        {
 
7996
          new_set->found_len=0;                 /* Set for testing if first */
 
7997
          bits_set=0;
 
7998
          for (i= (uint) ~0; (i=get_next_bit(new_set,i)) ;)
 
7999
          {
 
8000
            if ((follow[i].chr == SPACE_CHAR ||
 
8001
                 follow[i].chr == END_OF_LINE) && ! chr)
 
8002
              bit_nr=i+1;
 
8003
            else
 
8004
              bit_nr=i;
 
8005
            if (follow[bit_nr-1].len < found_end ||
 
8006
                (new_set->found_len &&
 
8007
                 (chr == 0 || !follow[bit_nr].chr)))
 
8008
              internal_clear_bit(new_set,i);
 
8009
            else
 
8010
            {
 
8011
              if (chr == 0 || !follow[bit_nr].chr)
 
8012
              {                                 /* best match  */
 
8013
                new_set->table_offset=follow[bit_nr].table_offset;
 
8014
                if (chr || (follow[i].chr == SPACE_CHAR ||
 
8015
                            follow[i].chr == END_OF_LINE))
 
8016
                  new_set->found_offset=found_end;      /* New match */
 
8017
                new_set->found_len=found_end;
 
8018
              }
 
8019
              bits_set++;
 
8020
            }
 
8021
          }
 
8022
          if (bits_set == 1)
 
8023
          {
 
8024
            set->next[chr] = find_found(found_set,
 
8025
                                        new_set->table_offset,
 
8026
                                        new_set->found_offset);
 
8027
            free_last_set(&sets);
 
8028
          }
 
8029
          else
 
8030
            set->next[chr] = find_set(&sets,new_set);
 
8031
        }
 
8032
        else
 
8033
          set->next[chr] = find_set(&sets,new_set);
6899
8034
      }
6900
8035
    }
6901
8036
  }
6902
8037
 
6903
8038
  /* Alloc replace structure for the replace-state-machine */
6904
8039
 
6905
 
  if ((replace=(REPLACE*) malloc(sizeof(REPLACE)*(sets.count)+
6906
 
                                 sizeof(REPLACE_STRING)*(found_sets+1)+
6907
 
                                 sizeof(char *)*count+result_len)))
 
8040
  if ((replace=(REPLACE*) my_malloc(sizeof(REPLACE)*(sets.count)+
 
8041
                                    sizeof(REPLACE_STRING)*(found_sets+1)+
 
8042
                                    sizeof(char *)*count+result_len,
 
8043
                                    MYF(MY_WME | MY_ZEROFILL))))
6908
8044
  {
6909
 
    memset(replace, 0, sizeof(REPLACE)*(sets.count)+
6910
 
                       sizeof(REPLACE_STRING)*(found_sets+1)+
6911
 
                       sizeof(char *)*count+result_len);
6912
8045
    rep_str=(REPLACE_STRING*) (replace+sets.count);
6913
8046
    to_array= (char **) (rep_str+found_sets+1);
6914
8047
    to_pos=(char *) (to_array+count);
6915
8048
    for (i=0 ; i < count ; i++)
6916
8049
    {
6917
8050
      to_array[i]=to_pos;
6918
 
      to_pos=strcpy(to_pos,to[i])+strlen(to[i])+1;
 
8051
      to_pos=strmov(to_pos,to[i])+1;
6919
8052
    }
6920
8053
    rep_str[0].found=1;
6921
8054
    rep_str[0].replace_string=0;
6922
8055
    for (i=1 ; i <= found_sets ; i++)
6923
8056
    {
6924
8057
      pos=from[found_set[i-1].table_offset];
6925
 
      rep_str[i].found= !memcmp(pos, "\\^", 3) ? 2 : 1;
 
8058
      rep_str[i].found= !bcmp((const uchar*) pos,
 
8059
                              (const uchar*) "\\^", 3) ? 2 : 1;
6926
8060
      rep_str[i].replace_string=to_array[found_set[i-1].table_offset];
6927
8061
      rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos);
6928
8062
      rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+
6929
 
        end_of_word(pos);
 
8063
        end_of_word(pos);
6930
8064
    }
6931
8065
    for (i=0 ; i < sets.count ; i++)
6932
8066
    {
6933
8067
      for (j=0 ; j < 256 ; j++)
6934
 
        if (sets.set[i].next[j] >= 0)
6935
 
          replace[i].next[j]=replace+sets.set[i].next[j];
6936
 
        else
6937
 
          replace[i].next[j]=(REPLACE*) (rep_str+(-sets.set[i].next[j]-1));
 
8068
        if (sets.set[i].next[j] >= 0)
 
8069
          replace[i].next[j]=replace+sets.set[i].next[j];
 
8070
        else
 
8071
          replace[i].next[j]=(REPLACE*) (rep_str+(-sets.set[i].next[j]-1));
6938
8072
    }
6939
8073
  }
6940
 
  free(follow);
 
8074
  my_free(follow,MYF(0));
6941
8075
  free_sets(&sets);
6942
 
  free(found_set);
6943
 
  return(replace);
 
8076
  my_free(found_set,MYF(0));
 
8077
  DBUG_PRINT("exit",("Replace table has %d states",sets.count));
 
8078
  DBUG_RETURN(replace);
6944
8079
}
6945
8080
 
6946
8081
 
6947
 
int init_sets(REP_SETS *sets,uint32_t states)
 
8082
int init_sets(REP_SETS *sets,uint states)
6948
8083
{
6949
 
  memset(sets, 0, sizeof(*sets));
 
8084
  bzero((char*) sets,sizeof(*sets));
6950
8085
  sets->size_of_bits=((states+7)/8);
6951
 
  if (!(sets->set_buffer=(REP_SET*) malloc(sizeof(REP_SET)*SET_MALLOC_HUNC)))
 
8086
  if (!(sets->set_buffer=(REP_SET*) my_malloc(sizeof(REP_SET)*SET_MALLOC_HUNC,
 
8087
                                              MYF(MY_WME))))
6952
8088
    return 1;
6953
 
  if (!(sets->bit_buffer=(uint*) malloc(sizeof(uint32_t)*sets->size_of_bits*
6954
 
                                        SET_MALLOC_HUNC)))
 
8089
  if (!(sets->bit_buffer=(uint*) my_malloc(sizeof(uint)*sets->size_of_bits*
 
8090
                                           SET_MALLOC_HUNC,MYF(MY_WME))))
6955
8091
  {
6956
 
    free(sets->set);
 
8092
    my_free(sets->set,MYF(0));
6957
8093
    return 1;
6958
8094
  }
6959
8095
  return 0;
6970
8106
 
6971
8107
REP_SET *make_new_set(REP_SETS *sets)
6972
8108
{
6973
 
  uint32_t i,count,*bit_buffer;
 
8109
  uint i,count,*bit_buffer;
6974
8110
  REP_SET *set;
6975
8111
  if (sets->extra)
6976
8112
  {
6977
8113
    sets->extra--;
6978
8114
    set=sets->set+ sets->count++;
6979
 
    memset(set->bits, 0, sizeof(uint32_t)*sets->size_of_bits);
6980
 
    memset(&set->next[0], 0, sizeof(set->next[0])*LAST_CHAR_CODE);
 
8115
    bzero((char*) set->bits,sizeof(uint)*sets->size_of_bits);
 
8116
    bzero((char*) &set->next[0],sizeof(set->next[0])*LAST_CHAR_CODE);
6981
8117
    set->found_offset=0;
6982
8118
    set->found_len=0;
6983
 
    set->table_offset= UINT32_MAX;
 
8119
    set->table_offset= (uint) ~0;
6984
8120
    set->size_of_bits=sets->size_of_bits;
6985
8121
    return set;
6986
8122
  }
6987
8123
  count=sets->count+sets->invisible+SET_MALLOC_HUNC;
6988
 
  if (!(set=(REP_SET*) realloc((unsigned char*) sets->set_buffer,
6989
 
                                  sizeof(REP_SET)*count)))
 
8124
  if (!(set=(REP_SET*) my_realloc((uchar*) sets->set_buffer,
 
8125
                                  sizeof(REP_SET)*count,
 
8126
                                  MYF(MY_WME))))
6990
8127
    return 0;
6991
8128
  sets->set_buffer=set;
6992
8129
  sets->set=set+sets->invisible;
6993
 
  if (!(bit_buffer=(uint*) realloc((unsigned char*) sets->bit_buffer,
6994
 
                                   (sizeof(uint32_t)*sets->size_of_bits)*count)))
 
8130
  if (!(bit_buffer=(uint*) my_realloc((uchar*) sets->bit_buffer,
 
8131
                                      (sizeof(uint)*sets->size_of_bits)*count,
 
8132
                                      MYF(MY_WME))))
6995
8133
    return 0;
6996
8134
  sets->bit_buffer=bit_buffer;
6997
8135
  for (i=0 ; i < count ; i++)
7012
8150
 
7013
8151
void free_sets(REP_SETS *sets)
7014
8152
{
7015
 
  free(sets->set_buffer);
7016
 
  free(sets->bit_buffer);
 
8153
  my_free(sets->set_buffer,MYF(0));
 
8154
  my_free(sets->bit_buffer,MYF(0));
7017
8155
  return;
7018
8156
}
7019
8157
 
7020
 
void internal_set_bit(REP_SET *set, uint32_t bit)
 
8158
void internal_set_bit(REP_SET *set, uint bit)
7021
8159
{
7022
8160
  set->bits[bit / WORD_BIT] |= 1 << (bit % WORD_BIT);
7023
8161
  return;
7024
8162
}
7025
8163
 
7026
 
void internal_clear_bit(REP_SET *set, uint32_t bit)
 
8164
void internal_clear_bit(REP_SET *set, uint bit)
7027
8165
{
7028
8166
  set->bits[bit / WORD_BIT] &= ~ (1 << (bit % WORD_BIT));
7029
8167
  return;
7032
8170
 
7033
8171
void or_bits(REP_SET *to,REP_SET *from)
7034
8172
{
7035
 
  register uint32_t i;
 
8173
  register uint i;
7036
8174
  for (i=0 ; i < to->size_of_bits ; i++)
7037
8175
    to->bits[i]|=from->bits[i];
7038
8176
  return;
7040
8178
 
7041
8179
void copy_bits(REP_SET *to,REP_SET *from)
7042
8180
{
7043
 
  memcpy(to->bits,from->bits,
7044
 
         (size_t) (sizeof(uint32_t) * to->size_of_bits));
 
8181
  memcpy((uchar*) to->bits,(uchar*) from->bits,
 
8182
         (size_t) (sizeof(uint) * to->size_of_bits));
7045
8183
}
7046
8184
 
7047
8185
int cmp_bits(REP_SET *set1,REP_SET *set2)
7048
8186
{
7049
 
  return memcmp(set1->bits,set2->bits, sizeof(uint32_t) * set1->size_of_bits);
 
8187
  return bcmp((uchar*) set1->bits,(uchar*) set2->bits,
 
8188
              sizeof(uint) * set1->size_of_bits);
7050
8189
}
7051
8190
 
7052
8191
 
7053
8192
/* Get next set bit from set. */
7054
8193
 
7055
 
int get_next_bit(REP_SET *set,uint32_t lastpos)
 
8194
int get_next_bit(REP_SET *set,uint lastpos)
7056
8195
{
7057
 
  uint32_t pos,*start,*end,bits;
 
8196
  uint pos,*start,*end,bits;
7058
8197
 
7059
8198
  start=set->bits+ ((lastpos+1) / WORD_BIT);
7060
8199
  end=set->bits + set->size_of_bits;
7064
8203
    bits=start[0];
7065
8204
  if (!bits)
7066
8205
    return 0;
7067
 
  pos=(uint32_t) (start-set->bits)*WORD_BIT;
 
8206
  pos=(uint) (start-set->bits)*WORD_BIT;
7068
8207
  while (! (bits & 1))
7069
8208
  {
7070
8209
    bits>>=1;
7079
8218
 
7080
8219
int find_set(REP_SETS *sets,REP_SET *find)
7081
8220
{
7082
 
  uint32_t i;
 
8221
  uint i;
7083
8222
  for (i=0 ; i < sets->count-1 ; i++)
7084
8223
  {
7085
8224
    if (!cmp_bits(sets->set+i,find))
7088
8227
      return i;
7089
8228
    }
7090
8229
  }
7091
 
  return i;        /* return new postion */
 
8230
  return i;                             /* return new postion */
7092
8231
}
7093
8232
 
7094
8233
/* find if there is a found_set with same table_offset & found_offset
7098
8237
   set->next[] == -1 is reserved for end without replaces.
7099
8238
*/
7100
8239
 
7101
 
int find_found(FOUND_SET *found_set,uint32_t table_offset, int found_offset)
 
8240
int find_found(FOUND_SET *found_set,uint table_offset, int found_offset)
7102
8241
{
7103
8242
  int i;
7104
 
  for (i=0 ; (uint32_t) i < found_sets ; i++)
 
8243
  for (i=0 ; (uint) i < found_sets ; i++)
7105
8244
    if (found_set[i].table_offset == table_offset &&
7106
 
        found_set[i].found_offset == found_offset)
 
8245
        found_set[i].found_offset == found_offset)
7107
8246
      return -i-2;
7108
8247
  found_set[i].table_offset=table_offset;
7109
8248
  found_set[i].found_offset=found_offset;
7110
8249
  found_sets++;
7111
 
  return -i-2;        /* return new postion */
 
8250
  return -i-2;                          /* return new postion */
7112
8251
}
7113
8252
 
7114
8253
/* Return 1 if regexp starts with \b or ends with \b*/
7115
8254
 
7116
 
uint32_t start_at_word(char * pos)
 
8255
uint start_at_word(char * pos)
7117
8256
{
7118
 
  return (((!memcmp(pos, "\\b",2) && pos[2]) ||
7119
 
           !memcmp(pos, "\\^", 2)) ? 1 : 0);
 
8257
  return (((!bcmp((const uchar*) pos, (const uchar*) "\\b",2) && pos[2]) ||
 
8258
           !bcmp((const uchar*) pos, (const uchar*) "\\^", 2)) ? 1 : 0);
7120
8259
}
7121
8260
 
7122
 
uint32_t end_of_word(char * pos)
 
8261
uint end_of_word(char * pos)
7123
8262
{
7124
 
  char * end= strchr(pos, '\0');
7125
 
  return ((end > pos+2 && !memcmp(end-2, "\\b", 2)) ||
7126
 
          (end >= pos+2 && !memcmp(end-2, "\\$",2))) ? 1 : 0;
 
8263
  char * end=strend(pos);
 
8264
  return ((end > pos+2 && !bcmp((const uchar*) end-2,
 
8265
                                (const uchar*) "\\b", 2)) ||
 
8266
          (end >= pos+2 && !bcmp((const uchar*) end-2,
 
8267
                                (const uchar*) "\\$",2))) ? 1 : 0;
7127
8268
}
7128
8269
 
7129
8270
/****************************************************************************
7130
8271
 * Handle replacement of strings
7131
8272
 ****************************************************************************/
7132
8273
 
7133
 
#define PC_MALLOC    256  /* Bytes for pointers */
7134
 
#define PS_MALLOC    512  /* Bytes for data */
 
8274
#define PC_MALLOC               256     /* Bytes for pointers */
 
8275
#define PS_MALLOC               512     /* Bytes for data */
7135
8276
 
7136
8277
int insert_pointer_name(POINTER_ARRAY *pa,char * name)
7137
8278
{
7138
 
  uint32_t i,length,old_count;
7139
 
  unsigned char *new_pos;
 
8279
  uint i,length,old_count;
 
8280
  uchar *new_pos;
7140
8281
  const char **new_array;
7141
 
 
 
8282
  DBUG_ENTER("insert_pointer_name");
7142
8283
 
7143
8284
  if (! pa->typelib.count)
7144
8285
  {
7145
8286
    if (!(pa->typelib.type_names=(const char **)
7146
 
          malloc(((PC_MALLOC-MALLOC_OVERHEAD)/
7147
 
                     (sizeof(char *)+sizeof(*pa->flag))*
7148
 
                     (sizeof(char *)+sizeof(*pa->flag))))))
7149
 
      return(-1);
7150
 
    if (!(pa->str= (unsigned char*) malloc(PS_MALLOC-MALLOC_OVERHEAD)))
 
8287
          my_malloc(((PC_MALLOC-MALLOC_OVERHEAD)/
 
8288
                     (sizeof(char *)+sizeof(*pa->flag))*
 
8289
                     (sizeof(char *)+sizeof(*pa->flag))),MYF(MY_WME))))
 
8290
      DBUG_RETURN(-1);
 
8291
    if (!(pa->str= (uchar*) my_malloc((uint) (PS_MALLOC-MALLOC_OVERHEAD),
 
8292
                                     MYF(MY_WME))))
7151
8293
    {
7152
 
      free((char*) pa->typelib.type_names);
7153
 
      return (-1);
 
8294
      my_free((char*) pa->typelib.type_names,MYF(0));
 
8295
      DBUG_RETURN (-1);
7154
8296
    }
7155
 
    pa->max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(unsigned char*)+
7156
 
                                               sizeof(*pa->flag));
7157
 
    pa->flag= (uint8_t*) (pa->typelib.type_names+pa->max_count);
 
8297
    pa->max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(uchar*)+
 
8298
                                               sizeof(*pa->flag));
 
8299
    pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
7158
8300
    pa->length=0;
7159
8301
    pa->max_length=PS_MALLOC-MALLOC_OVERHEAD;
7160
8302
    pa->array_allocs=1;
7161
8303
  }
7162
 
  length=(uint32_t) strlen(name)+1;
 
8304
  length=(uint) strlen(name)+1;
7163
8305
  if (pa->length+length >= pa->max_length)
7164
8306
  {
7165
 
    if (!(new_pos= (unsigned char*)realloc((unsigned char*)pa->str,
7166
 
                                           (size_t)(pa->max_length+PS_MALLOC))))
7167
 
      return(1);
 
8307
    if (!(new_pos= (uchar*) my_realloc((uchar*) pa->str,
 
8308
                                      (uint) (pa->max_length+PS_MALLOC),
 
8309
                                      MYF(MY_WME))))
 
8310
      DBUG_RETURN(1);
7168
8311
    if (new_pos != pa->str)
7169
8312
    {
7170
 
      ptrdiff_t diff= PTR_BYTE_DIFF(new_pos,pa->str);
 
8313
      my_ptrdiff_t diff=PTR_BYTE_DIFF(new_pos,pa->str);
7171
8314
      for (i=0 ; i < pa->typelib.count ; i++)
7172
 
        pa->typelib.type_names[i]= ADD_TO_PTR(pa->typelib.type_names[i],diff,
7173
 
                                              char*);
 
8315
        pa->typelib.type_names[i]= ADD_TO_PTR(pa->typelib.type_names[i],diff,
 
8316
                                              char*);
7174
8317
      pa->str=new_pos;
7175
8318
    }
7176
8319
    pa->max_length+=PS_MALLOC;
7177
8320
  }
7178
8321
  if (pa->typelib.count >= pa->max_count-1)
7179
8322
  {
7180
 
    size_t len;
 
8323
    int len;
7181
8324
    pa->array_allocs++;
7182
8325
    len=(PC_MALLOC*pa->array_allocs - MALLOC_OVERHEAD);
7183
 
    if (!(new_array=
7184
 
         (const char **)realloc((unsigned char*) pa->typelib.type_names,
7185
 
                                 len/
7186
 
                                  (sizeof(unsigned char*)+sizeof(*pa->flag))*
7187
 
                                  (sizeof(unsigned char*)+sizeof(*pa->flag)))))
7188
 
      return(1);
 
8326
    if (!(new_array=(const char **) my_realloc((uchar*) pa->typelib.type_names,
 
8327
                                               (uint) len/
 
8328
                                               (sizeof(uchar*)+sizeof(*pa->flag))*
 
8329
                                               (sizeof(uchar*)+sizeof(*pa->flag)),
 
8330
                                               MYF(MY_WME))))
 
8331
      DBUG_RETURN(1);
7189
8332
    pa->typelib.type_names=new_array;
7190
8333
    old_count=pa->max_count;
7191
 
    pa->max_count=len/(sizeof(unsigned char*) + sizeof(*pa->flag));
7192
 
    pa->flag= (uint8_t*) (pa->typelib.type_names+pa->max_count);
7193
 
    memcpy(pa->flag, pa->typelib.type_names+old_count,
7194
 
           old_count*sizeof(*pa->flag));
 
8334
    pa->max_count=len/(sizeof(uchar*) + sizeof(*pa->flag));
 
8335
    pa->flag= (int7*) (pa->typelib.type_names+pa->max_count);
 
8336
    memcpy((uchar*) pa->flag,(char *) (pa->typelib.type_names+old_count),
 
8337
           old_count*sizeof(*pa->flag));
7195
8338
  }
7196
 
  pa->flag[pa->typelib.count]=0;      /* Reset flag */
 
8339
  pa->flag[pa->typelib.count]=0;                        /* Reset flag */
7197
8340
  pa->typelib.type_names[pa->typelib.count++]= (char*) pa->str+pa->length;
7198
 
  pa->typelib.type_names[pa->typelib.count]= NULL;  /* Put end-mark */
7199
 
  strcpy((char*) pa->str+pa->length,name);
 
8341
  pa->typelib.type_names[pa->typelib.count]= NullS;     /* Put end-mark */
 
8342
  VOID(strmov((char*) pa->str+pa->length,name));
7200
8343
  pa->length+=length;
7201
 
  return(0);
 
8344
  DBUG_RETURN(0);
7202
8345
} /* insert_pointer_name */
7203
8346
 
7204
8347
 
7209
8352
  if (pa->typelib.count)
7210
8353
  {
7211
8354
    pa->typelib.count=0;
7212
 
    free((char*) pa->typelib.type_names);
 
8355
    my_free((char*) pa->typelib.type_names,MYF(0));
7213
8356
    pa->typelib.type_names=0;
7214
 
    free(pa->str);
 
8357
    my_free(pa->str,MYF(0));
7215
8358
  }
7216
8359
} /* free_pointer_array */
7217
8360
 
7219
8362
/* Functions that uses replace and replace_regex */
7220
8363
 
7221
8364
/* Append the string to ds, with optional replace */
7222
 
void replace_append_mem(string *ds,
7223
 
                        const char *val, int len)
 
8365
void replace_dynstr_append_mem(DYNAMIC_STRING *ds,
 
8366
                               const char *val, int len)
7224
8367
{
7225
 
  char *v= strdup(val);
7226
 
 
7227
8368
  if (glob_replace_regex)
7228
8369
  {
7229
8370
    /* Regex replace */
7230
 
    if (!multi_reg_replace(glob_replace_regex, v))
 
8371
    if (!multi_reg_replace(glob_replace_regex, (char*)val))
7231
8372
    {
7232
 
      v= glob_replace_regex->buf;
7233
 
      len= strlen(v);
 
8373
      val= glob_replace_regex->buf;
 
8374
      len= strlen(val);
7234
8375
    }
7235
8376
  }
7236
8377
 
7237
8378
  if (glob_replace)
7238
8379
  {
7239
8380
    /* Normal replace */
7240
 
    replace_strings_append(glob_replace, ds, v, len);
 
8381
    replace_strings_append(glob_replace, ds, val, len);
7241
8382
  }
7242
8383
  else
7243
 
  {
7244
 
    ds->append(v, len);
7245
 
  }
 
8384
    dynstr_append_mem(ds, val, len);
7246
8385
}
7247
8386
 
7248
8387
 
7249
8388
/* Append zero-terminated string to ds, with optional replace */
7250
 
void replace_append(string *ds, const char *val)
 
8389
void replace_dynstr_append(DYNAMIC_STRING *ds, const char *val)
7251
8390
{
7252
 
  replace_append_mem(ds, val, strlen(val));
 
8391
  replace_dynstr_append_mem(ds, val, strlen(val));
7253
8392
}
7254
8393
 
7255
 
/* Append uint32_t to ds, with optional replace */
7256
 
void replace_append_uint(string *ds, uint32_t val)
 
8394
/* Append uint to ds, with optional replace */
 
8395
void replace_dynstr_append_uint(DYNAMIC_STRING *ds, uint val)
7257
8396
{
7258
 
  ostringstream buff;
7259
 
  buff << val;
7260
 
  replace_append_mem(ds, buff.str().c_str(), buff.str().size());
7261
 
 
 
8397
  char buff[22]; /* This should be enough for any int */
 
8398
  char *end= longlong10_to_str(val, buff, 10);
 
8399
  replace_dynstr_append_mem(ds, buff, end - buff);
7262
8400
}
7263
8401
 
7264
8402
 
7275
8413
 
7276
8414
*/
7277
8415
 
7278
 
 
7279
 
void append_sorted(string* ds, string *ds_input)
7280
 
{
7281
 
  priority_queue<string, vector<string>, greater<string> > lines;
7282
 
 
7283
 
  if (ds_input->empty())
7284
 
    return;  /* No input */
7285
 
 
7286
 
  unsigned long eol_pos= 0;
7287
 
 
7288
 
  eol_pos= ds_input->find_first_of('\n', 0);
7289
 
  if (eol_pos == string::npos)
7290
 
    return; // We should have at least one header here
7291
 
 
7292
 
  ds->append(ds_input->substr(0, eol_pos+1));
7293
 
 
7294
 
  unsigned long start_pos= eol_pos+1;
 
8416
static int comp_lines(const char **a, const char **b)
 
8417
{
 
8418
  return (strcmp(*a,*b));
 
8419
}
 
8420
 
 
8421
void dynstr_append_sorted(DYNAMIC_STRING* ds, DYNAMIC_STRING *ds_input)
 
8422
{
 
8423
  unsigned i;
 
8424
  char *start= ds_input->str;
 
8425
  DYNAMIC_ARRAY lines;
 
8426
  DBUG_ENTER("dynstr_append_sorted");
 
8427
 
 
8428
  if (!*start)
 
8429
    DBUG_VOID_RETURN;  /* No input */
 
8430
 
 
8431
  my_init_dynamic_array(&lines, sizeof(const char*), 32, 32);
 
8432
 
 
8433
  /* First line is result header, skip past it */
 
8434
  while (*start && *start != '\n')
 
8435
    start++;
 
8436
  start++; /* Skip past \n */
 
8437
  dynstr_append_mem(ds, ds_input->str, start - ds_input->str);
7295
8438
 
7296
8439
  /* Insert line(s) in array */
7297
 
  do {
 
8440
  while (*start)
 
8441
  {
 
8442
    char* line_end= (char*)start;
7298
8443
 
7299
 
    eol_pos= ds_input->find_first_of('\n', start_pos);
7300
8444
    /* Find end of line */
7301
 
    lines.push(ds_input->substr(start_pos, eol_pos-start_pos+1));
7302
 
    start_pos= eol_pos+1;
7303
 
 
7304
 
  } while ( eol_pos != string::npos);
 
8445
    while (*line_end && *line_end != '\n')
 
8446
      line_end++;
 
8447
    *line_end= 0;
 
8448
 
 
8449
    /* Insert pointer to the line in array */
 
8450
    if (insert_dynamic(&lines, (uchar*) &start))
 
8451
      die("Out of memory inserting lines to sort");
 
8452
 
 
8453
    start= line_end+1;
 
8454
  }
 
8455
 
 
8456
  /* Sort array */
 
8457
  qsort(lines.buffer, lines.elements,
 
8458
        sizeof(char**), (qsort_cmp)comp_lines);
7305
8459
 
7306
8460
  /* Create new result */
7307
 
  while (!lines.empty()) {
7308
 
    ds->append(lines.top());
7309
 
    lines.pop();
 
8461
  for (i= 0; i < lines.elements ; i++)
 
8462
  {
 
8463
    const char **line= dynamic_element(&lines, i, const char**);
 
8464
    dynstr_append(ds, *line);
 
8465
    dynstr_append(ds, "\n");
7310
8466
  }
7311
8467
 
7312
 
  return;
 
8468
  delete_dynamic(&lines);
 
8469
  DBUG_VOID_RETURN;
7313
8470
}