~drizzle-trunk/drizzle/development : revision 893

97

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

98

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

99

100

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

101

static uint my_end_arg= 0;

100

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

101

static uint32_t my_end_arg= 0;

102

103

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

104

static uint opt_tail_lines= 0;

104

static uint32_t opt_tail_lines= 0;

105

106

static char delimiter[MAX_DELIMITER_LENGTH]= ";";

107

static uint delimiter_length= 1;

107

static uint32_t delimiter_length= 1;

108

109

static char TMPDIR[FN_REFLEN];

110

130

{

131

FILE* file;

132

const char *file_name;

133

uint lineno; /* Current line in file */

133

uint32_t lineno; /* Current line in file */

134

};

135

136

static struct st_test_file file_stack[16];

350

enum match_err_type type;

351

union

352

{

353

uint errnum;

353

uint32_t errnum;

354

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

355

} code;

356

};

358

struct st_expected_errors

359

{

360

struct st_match_err err[10];

361

uint count;

361

uint32_t count;

362

};

363

static struct st_expected_errors saved_expected_errors;

364

397

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

398

bool raw, bool ignore_not_existing);

399

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

400

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

400

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

401

void dump_result_to_reject_file(char *buf, int size);

402

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

403

void dump_warning_messages(void);

410

411

/* For replace_column */

412

static char *replace_column[MAX_COLUMNS];

413

static uint max_replace_column= 0;

413

static uint32_t max_replace_column= 0;

414

void do_get_replace_column(struct st_command*);

415

void free_replace_column(void);

416

435

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

436

int len);

437

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

438

void replace_append_uint(string *ds, uint val);

438

void replace_append_uint(string *ds, uint32_t val);

439

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

440

441

void handle_error(struct st_command*,

519

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

520

{

521

const char *quote_str= "\'";

522

const uint quote_len= 1;

522

const uint32_t quote_len= 1;

523

524

va_list dirty_text;

525

767

}

768

769

770

static void handle_command_error(struct st_command *command, uint error)

770

static void handle_command_error(struct st_command *command, uint32_t error)

771

{

772

773

if (error != 0)

774

{

775

uint i;

775

uint32_t i;

776

777

if (command->abort_on_error)

778

die("command \"%.*s\" failed with error %d",

832

833

static void free_used_memory(void)

834

{

835

uint i;

835

uint32_t i;

836

837

838

close_connections();

1079

static void cat_file(string* ds, const char* filename)

1080

{

1081

int fd;

1082

uint len;

1082

uint32_t len;

1083

char buff[512];

1084

1085

if ((fd= my_open(filename, O_RDONLY, MYF(0))) < 0)

1286

{

1287

int error= RESULT_OK;

1288

File fd2;

1289

uint len, len2;

1289

uint32_t len, len2;

1290

char buff[512], buff2[512];

1291

const char *fname= filename2;

1292

string tmpfile;

1637

if (digit < 0 || digit >= 10)

1638

{

1639

const char *save_var_name = var_name, *end;

1640

uint length;

1640

uint32_t length;

1641

end = (var_name_end) ? *var_name_end : 0;

1642

while (my_isvar(charset_info,*var_name) && var_name != end)

1643

var_name++;

1921

1922

{

1923

/* Find column number from the given column name */

1924

uint i;

1925

uint num_fields= drizzleclient_num_fields(res);

1924

uint32_t i;

1925

uint32_t num_fields= drizzleclient_num_fields(res);

1926

const DRIZZLE_FIELD *fields= drizzleclient_fetch_fields(res);

1927

1928

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

2228

error= pclose(res_file);

2229

if (error > 0)

2230

{

2231

uint status= WEXITSTATUS(error), i;

2231

uint32_t status= WEXITSTATUS(error), i;

2232

bool ok= 0;

2233

2234

if (command->abort_on_error)

3229

3230

3231

static void do_get_file_name(struct st_command *command,

3232

char* dest, uint dest_max_len)

3232

char* dest, uint32_t dest_max_len)

3233

{

3234

char *p= command->first_argument, *name;

3235

if (!*p)

3263

abort_not_supported_test("Test requires charset '%s'", charset_name);

3264

}

3265

3266

static uint get_errcode_from_name(char *error_name, char *error_end)

3266

static uint32_t get_errcode_from_name(char *error_name, char *error_end)

3267

{

3268

/* SQL error as string */

3269

st_error *e= global_error_names;

3291

{

3292

struct st_match_err *to= saved_expected_errors.err;

3293

char *p= command->first_argument;

3294

uint count= 0;

3294

uint32_t count= 0;

3295

3296

3297

3985

}

3986

3987

3988

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

3988

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

3989

{

3990

uint i;

3990

uint32_t i;

3991

char tmp[MAX_DELIMITER_LENGTH];

3992

3993

if (c != *delim)

4287

ptr[2] && ptr[2] == '-' &&

4288

ptr[3])

4289

{

4290

uint type;

4290

uint32_t type;

4291

char save;

4292

char *end, *start= (char*)ptr+3;

4293

/* Skip leading spaces */

4813

Append the result for one field to the dynamic string ds

4814

*/

4815

4816

static void append_field(string *ds, uint col_idx, const DRIZZLE_FIELD* field,

4816

static void append_field(string *ds, uint32_t col_idx, const DRIZZLE_FIELD* field,

4817

const char* val, uint64_t len, bool is_null)

4818

{

4819

if (col_idx < max_replace_column && replace_column[col_idx])

4875

4876

static void append_metadata(string *ds,

4877

const DRIZZLE_FIELD *field,

4878

uint num_fields)

4878

uint32_t num_fields)

4879

{

4880

const DRIZZLE_FIELD *field_end;

4881

ds->append("Catalog\tDatabase\tTable\tTable_alias\tColumn\t"

4946

4947

static void append_table_headings(string *ds,

4948

const DRIZZLE_FIELD *field,

4949

uint num_fields)

4949

uint32_t num_fields)

4950

{

4951

uint col_idx;

4951

uint32_t col_idx;

4952

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

4953

{

4954

if (col_idx)

4967

4968

static int append_warnings(string *ds, DRIZZLE *drizzle)

4969

{

4970

uint count;

4970

uint32_t count;

4971

DRIZZLE_RES *warn_res;

4972

4973

5062

if (res)

5063

{

5064

const DRIZZLE_FIELD *fields= drizzleclient_fetch_fields(res);

5065

uint num_fields= drizzleclient_num_fields(res);

5065

uint32_t num_fields= drizzleclient_num_fields(res);

5066

5067

if (display_metadata)

5068

append_metadata(ds, fields, num_fields);

5149

unsigned int err_errno, const char *err_error,

5150

const char *err_sqlstate, string *ds)

5151

{

5152

uint i;

5152

uint32_t i;

5153

5154

5155

if (command->require_file[0])

5373

static void get_command_type(struct st_command* command)

5374

{

5375

char save;

5376

uint type;

5376

uint32_t type;

5377

5378

5379

if (*command->query == '}')

5492

{

5493

struct st_command *command;

5494

bool q_send_flag= 0, abort_flag= 0;

5495

uint command_executed= 0, last_command_executed= 0;

5495

uint32_t command_executed= 0, last_command_executed= 0;

5496

char save_file[FN_REFLEN];

5497

struct stat res_info;

5498

MY_INIT(argv[0]);

5997

while (*from)

5998

{

5999

char *to;

6000

uint column_number;

6000

uint32_t column_number;

6001

6002

to= get_string(&buff, &from, command);

6003

if (!(column_number= atoi(to)) || column_number > MAX_COLUMNS)

6018

6019

void free_replace_column()

6020

{

6021

uint i;

6021

uint32_t i;

6022

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

6023

{

6024

if (replace_column[i])

6042

TYPELIB typelib; /* Pointer to strings */

6043

unsigned char *str; /* Strings is here */

6044

uint8_t *flag; /* Flag about each var. */

6045

uint array_allocs,max_count,length,max_length;

6045

uint32_t array_allocs,max_count,length,max_length;

6046

} POINTER_ARRAY;

6047

6048

struct st_replace;

6049

struct st_replace *init_replace(char * *from, char * *to, uint count,

6049

struct st_replace *init_replace(char * *from, char * *to, uint32_t count,

6050

char * word_end_chars);

6051

int insert_pointer_name(POINTER_ARRAY *pa,char * name);

6052

void replace_strings_append(struct st_replace *rep, string* ds,

6065

6066

void do_get_replace(struct st_command *command)

6067

{

6068

uint i;

6068

uint32_t i;

6069

char *from= command->first_argument;

6070

char *buff, *start;

6071

char word_end_chars[256], *pos;

6127

typedef struct st_replace_found {

6128

bool found;

6129

char *replace_string;

6130

uint to_offset;

6130

uint32_t to_offset;

6131

int from_offset;

6132

} REPLACE_STRING;

6133

6253

char* buf,*expr_end;

6254

char* p;

6255

char* buf_p;

6256

uint expr_len= strlen(expr);

6256

uint32_t expr_len= strlen(expr);

6257

char last_c = 0;

6258

struct st_regex reg;

6259

6349

6350

static int multi_reg_replace(struct st_replace_regex* r,char* val)

6351

{

6352

uint i;

6352

uint32_t i;

6353

char* in_buf, *out_buf;

6354

int* buf_len_p;

6355

6490

#define LAST_CHAR_CODE 259

6491

6492

typedef struct st_rep_set {

6493

uint *bits; /* Pointer to used sets */

6493

uint32_t *bits; /* Pointer to used sets */

6494

short next[LAST_CHAR_CODE]; /* Pointer to next sets */

6495

uint found_len; /* Best match to date */

6495

uint32_t found_len; /* Best match to date */

6496

int found_offset;

6497

uint table_offset;

6498

uint size_of_bits; /* For convinience */

6497

uint32_t table_offset;

6498

uint32_t size_of_bits; /* For convinience */

6499

} REP_SET;

6500

6501

typedef struct st_rep_sets {

6502

uint count; /* Number of sets */

6503

uint extra; /* Extra sets in buffer */

6504

uint invisible; /* Sets not chown */

6505

uint size_of_bits;

6502

uint32_t count; /* Number of sets */

6503

uint32_t extra; /* Extra sets in buffer */

6504

uint32_t invisible; /* Sets not chown */

6505

uint32_t size_of_bits;

6506

REP_SET *set,*set_buffer;

6507

uint *bit_buffer;

6507

uint32_t *bit_buffer;

6508

} REP_SETS;

6509

6510

typedef struct st_found_set {

6511

uint table_offset;

6511

uint32_t table_offset;

6512

int found_offset;

6513

} FOUND_SET;

6514

6515

typedef struct st_follow {

6516

int chr;

6517

uint table_offset;

6518

uint len;

6517

uint32_t table_offset;

6518

uint32_t len;

6519

} FOLLOWS;

6520

6521

6522

int init_sets(REP_SETS *sets,uint states);

6522

int init_sets(REP_SETS *sets,uint32_t states);

6523

REP_SET *make_new_set(REP_SETS *sets);

6524

void make_sets_invisible(REP_SETS *sets);

6525

void free_last_set(REP_SETS *sets);

6526

void free_sets(REP_SETS *sets);

6527

void internal_set_bit(REP_SET *set, uint bit);

6528

void internal_clear_bit(REP_SET *set, uint bit);

6527

void internal_set_bit(REP_SET *set, uint32_t bit);

6528

void internal_clear_bit(REP_SET *set, uint32_t bit);

6529

void or_bits(REP_SET *to,REP_SET *from);

6530

void copy_bits(REP_SET *to,REP_SET *from);

6531

int cmp_bits(REP_SET *set1,REP_SET *set2);

6532

int get_next_bit(REP_SET *set,uint lastpos);

6532

int get_next_bit(REP_SET *set,uint32_t lastpos);

6533

int find_set(REP_SETS *sets,REP_SET *find);

6534

int find_found(FOUND_SET *found_set,uint table_offset,

6534

int find_found(FOUND_SET *found_set,uint32_t table_offset,

6535

int found_offset);

6536

uint start_at_word(char * pos);

6537

uint end_of_word(char * pos);

6538

6539

static uint found_sets=0;

6540

6541

6542

static uint replace_len(char * str)

6536

uint32_t start_at_word(char * pos);

6537

uint32_t end_of_word(char * pos);

6538

6539

static uint32_t found_sets=0;

6540

6541

6542

static uint32_t replace_len(char * str)

6543

{

6544

uint len=0;

6544

uint32_t len=0;

6545

while (*str)

6546

{

6547

if (str[0] == '\\' && str[1])

6554

6555

/* Init a replace structure for further calls */

6556

6557

REPLACE *init_replace(char * *from, char * *to,uint count,

6557

REPLACE *init_replace(char * *from, char * *to,uint32_t count,

6558

char * word_end_chars)

6559

{

6560

static const int SPACE_CHAR= 256;

6561

static const int START_OF_LINE= 257;

6562

static const int END_OF_LINE= 258;

6563

6564

uint i,j,states,set_nr,len,result_len,max_length,found_end,bits_set,bit_nr;

6564

uint32_t i,j,states,set_nr,len,result_len,max_length,found_end,bits_set,bit_nr;

6565

int used_sets,chr,default_state;

6566

char used_chars[LAST_CHAR_CODE],is_word_end[256];

6567

char * pos, *to_pos, **to_array;

6839

}

6840

6841

6842

int init_sets(REP_SETS *sets,uint states)

6842

int init_sets(REP_SETS *sets,uint32_t states)

6843

{

6844

memset(sets, 0, sizeof(*sets));

6845

sets->size_of_bits=((states+7)/8);

6865

6866

REP_SET *make_new_set(REP_SETS *sets)

6867

{

6868

uint i,count,*bit_buffer;

6868

uint32_t i,count,*bit_buffer;

6869

REP_SET *set;

6870

if (sets->extra)

6871

{

6912

return;

6913

}

6914

6915

void internal_set_bit(REP_SET *set, uint bit)

6915

void internal_set_bit(REP_SET *set, uint32_t bit)

6916

{

6917

set->bits[bit / WORD_BIT] |= 1 << (bit % WORD_BIT);

6918

return;

6919

}

6920

6921

void internal_clear_bit(REP_SET *set, uint bit)

6921

void internal_clear_bit(REP_SET *set, uint32_t bit)

6922

{

6923

set->bits[bit / WORD_BIT] &= ~ (1 << (bit % WORD_BIT));

6924

return;

6927

6928

void or_bits(REP_SET *to,REP_SET *from)

6929

{

6930

register uint i;

6930

register uint32_t i;

6931

for (i=0 ; i < to->size_of_bits ; i++)

6932

to->bits[i]|=from->bits[i];

6933

return;

6947

6948

/* Get next set bit from set. */

6949

6950

int get_next_bit(REP_SET *set,uint lastpos)

6950

int get_next_bit(REP_SET *set,uint32_t lastpos)

6951

{

6952

uint pos,*start,*end,bits;

6952

uint32_t pos,*start,*end,bits;

6953

6954

start=set->bits+ ((lastpos+1) / WORD_BIT);

6955

end=set->bits + set->size_of_bits;

6974

6975

int find_set(REP_SETS *sets,REP_SET *find)

6976

{

6977

uint i;

6977

uint32_t i;

6978

for (i=0 ; i < sets->count-1 ; i++)

6979

{

6980

if (!cmp_bits(sets->set+i,find))

6993

set->next[] == -1 is reserved for end without replaces.

6994

*/

6995

6996

int find_found(FOUND_SET *found_set,uint table_offset, int found_offset)

6996

int find_found(FOUND_SET *found_set,uint32_t table_offset, int found_offset)

6997

{

6998

int i;

6999

for (i=0 ; (uint) i < found_sets ; i++)

7008

7009

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

7010

7011

uint start_at_word(char * pos)

7011

uint32_t start_at_word(char * pos)

7012

{

7013

return (((!memcmp(pos, "\\b",2) && pos[2]) ||

7014

!memcmp(pos, "\\^", 2)) ? 1 : 0);

7015

}

7016

7017

uint end_of_word(char * pos)

7017

uint32_t end_of_word(char * pos)

7018

{

7019

char * end= strchr(pos, '\0');

7020

return ((end > pos+2 && !memcmp(end-2, "\\b", 2)) ||

7030

7031

int insert_pointer_name(POINTER_ARRAY *pa,char * name)

7032

{

7033

uint i,length,old_count;

7033

uint32_t i,length,old_count;

7034

unsigned char *new_pos;

7035

const char **new_array;

7036

7147

replace_append_mem(ds, val, strlen(val));

7148

}

7149

7150

/* Append uint to ds, with optional replace */

7151

void replace_append_uint(string *ds, uint val)

7150

/* Append uint32_t to ds, with optional replace */

7151

void replace_append_uint(string *ds, uint32_t val)

7152

{

7153

char buff[22]; /* This should be enough for any int */

7154

char *end= int64_t10_to_str(val, buff, 10);