~drizzle-trunk/drizzle/development : revision 2318.4.6

471

void free_replace_column();

472

473

/* For replace */

474

void do_get_replace(struct st_command *command);

474

void do_get_replace(st_command* command);

475

void free_replace();

476

477

/* For replace_regex */

478

void do_get_replace_regex(struct st_command *command);

478

void do_get_replace_regex(st_command* command);

479

480

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

481

int len);

766

};

767

768

769

static void check_command_args(struct st_command *command,

769

static void check_command_args(st_command* command,

770

const char *arguments,

771

const struct command_arg *args,

772

int num_args, const char delimiter_arg)

839

}

840

841

842

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

842

static void handle_command_error(st_command* command, uint32_t error)

843

{

844

if (error != 0)

845

{

1593

}

1594

1595

1596

static void strip_parentheses(struct st_command *command)

1596

static void strip_parentheses(st_command* command)

1597

{

1598

if (strip_surrounding(command->first_argument, '(', ')'))

1599

die("%.*s - argument list started with '%c' must be ended with '%c'",

1905

1906

*/

1907

1908

static void var_set_query_get_value(struct st_command *command, VAR *var)

1908

static void var_set_query_get_value(st_command* command, VAR *var)

1909

{

1910

long row_no;

1911

int col_no= -1;

2127

2128

*/

2129

2130

static void do_source(struct st_command *command)

2130

static void do_source(st_command* command)

2131

{

2132

string ds_filename;

2133

const struct command_arg source_args[] = {

2221

drizzletest commmand(s) like "remove_file" for that

2222

*/

2223

2224

static void do_exec(struct st_command *command)

2224

static void do_exec(st_command* command)

2225

{

2226

int error;

2227

char buf[512];

2323

2324

*/

2325

2326

static int do_modify_var(struct st_command *command,

2326

static int do_modify_var(st_command* command,

2327

enum enum_operator op)

2328

{

2329

const char *p= command->first_argument;

2364

2365

*/

2366

2367

static void do_system(struct st_command *command)

2367

static void do_system(st_command* command)

2368

{

2369

string ds_cmd;

2370

2401

Remove the file <file_name>

2402

*/

2403

2404

static void do_remove_file(struct st_command *command)

2404

static void do_remove_file(st_command* command)

2405

{

2406

int error;

2407

string ds_filename;

2431

NOTE! Will fail if <to_file> exists

2432

*/

2433

2434

static void do_copy_file(struct st_command *command)

2434

static void do_copy_file(st_command* command)

2435

{

2436

int error;

2437

string ds_from_file;

2464

2465

*/

2466

2467

static void do_chmod_file(struct st_command *command)

2467

static void do_chmod_file(st_command* command)

2468

{

2469

long mode= 0;

2470

string ds_mode;

2500

Check if file <file_name> exists

2501

*/

2502

2503

static void do_file_exist(struct st_command *command)

2503

static void do_file_exist(st_command* command)

2504

{

2505

int error;

2506

string ds_filename;

2529

Create the directory <dir_name>

2530

*/

2531

2532

static void do_mkdir(struct st_command *command)

2532

static void do_mkdir(st_command* command)

2533

{

2534

string ds_dirname;

2535

int error;

2556

Remove the empty directory <dir_name>

2557

*/

2558

2559

static void do_rmdir(struct st_command *command)

2559

static void do_rmdir(st_command* command)

2560

{

2561

int error;

2562

string ds_dirname;

2641

}

2642

2643

2644

static void do_write_file_command(struct st_command *command, bool append)

2644

static void do_write_file_command(st_command* command, bool append)

2645

{

2646

string ds_content;

2647

string ds_filename;

2702

2703

*/

2704

2705

static void do_write_file(struct st_command *command)

2705

static void do_write_file(st_command* command)

2706

{

2707

do_write_file_command(command, false);

2708

}

2733

2734

*/

2735

2736

static void do_append_file(struct st_command *command)

2736

static void do_append_file(st_command* command)

2737

{

2738

do_write_file_command(command, true);

2739

}

2751

2752

*/

2753

2754

static void do_cat_file(struct st_command *command)

2754

static void do_cat_file(st_command* command)

2755

{

2756

static string ds_filename;

2757

const struct command_arg cat_file_args[] = {

2783

2784

*/

2785

2786

static void do_diff_files(struct st_command *command)

2786

static void do_diff_files(st_command* command)

2787

{

2788

int error= 0;

2789

string ds_filename;

2836

2837

*/

2838

2839

static void do_send_quit(struct st_command *command)

2839

static void do_send_quit(st_command* command)

2840

{

2841

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

2842

st_connection *con;

2901

Default <delimiter> is EOF

2902

*/

2903

2904

static void do_perl(struct st_command *command)

2904

static void do_perl(st_command* command)

2905

{

2906

int error;

2907

int fd;

2981

Print "Some text" plus $<var_name> to result file

2982

*/

2983

2984

static int do_echo(struct st_command *command)

2984

static void do_echo(st_command* command)

2985

{

2986

string ds_echo;

2987

2990

ds_res.append(ds_echo.c_str(), ds_echo.length());

2991

ds_res.append("\n");

2992

command->last_argument= command->end;

2993

return(0);

2994

2993

}

2995

2994

2996

2995

2997

static void

2998

do_wait_for_slave_to_stop(struct st_command *)

2996

static void do_wait_for_slave_to_stop()

2999

2997

{

3000

2998

static int SLAVE_POLL_INTERVAL= 300000;

3001

2999

drizzle_con_st *con= &cur_con->con;

3043

3041

return;

3044

3042

}

3045

3043

3046

3047

3044

static void do_sync_with_master2(long offset)

3048

3045

{

3049

3046

drizzle_result_st res;

3103

3100

return;

3104

3101

}

3105

3102

3106

3107

static void do_sync_with_master(struct st_command *command)

3103

static void do_sync_with_master(st_command* command)

3108

3104

{

3109

3105

long offset= 0;

3110

3106

char *p= command->first_argument;

3127

3123

when ndb binlog is on, this call will wait until last updated epoch

3128

3124

(locally in the drizzled) has been received into the binlog

3129

3125

*/

3130

static int do_save_master_pos()

3126

static void do_save_master_pos()

3131

3127

{

3132

3128

drizzle_result_st res;

3133

3129

drizzle_return_t ret;

3157

3153

strncpy(master_pos.file, row[0], sizeof(master_pos.file)-1);

3158

3154

master_pos.pos = strtoul(row[1], (char**) 0, 10);

3159

3155

drizzle_result_free(&res);

3160

return(0);

3161

3156

}

3162

3157

3163

3158

3180

3175

Program will die if error detected

3181

3176

*/

3182

3177

3183

static void do_let(struct st_command *command)

3178

static void do_let(st_command* command)

3184

3179

{

3185

3180

char *p= command->first_argument;

3186

3181

char *var_name, *var_name_end;

3238

3233

used for cpu-independent delays.

3239

3234

*/

3240

3235

3241

static int do_sleep(struct st_command *command, bool real_sleep)

3236

static void do_sleep(st_command* command, bool real_sleep)

3242

3237

{

3243

bool error= false;

3244

3238

char *p= command->first_argument;

3245

3239

char *sleep_start, *sleep_end= command->end;

3246

3240

double sleep_val= 0;

3256

3250

command->query,command->first_argument);

3257

3251

string buff_str(sleep_start, sleep_end-sleep_start);

3258

3252

istringstream buff(buff_str);

3259

error= (buff >> sleep_val).fail();

3260

if (error)

3261

die("Invalid argument to %.*s \"%s\"", command->first_word_len,

3262

command->query, command->first_argument);

3253

buff >> sleep_val;

3254

if (buff.fail())

3255

die("Invalid argument to %.*s \"%s\"", command->first_word_len, command->query, command->first_argument);

3263

3256

3264

3257

/* Fixed sleep time selected by --sleep option */

3265

3258

if (opt_sleep >= 0 && !real_sleep)

3268

3261

if (sleep_val)

3269

3262

usleep(sleep_val * 1000000);

3270

3263

command->last_argument= sleep_end;

3271

return 0;

3272

3264

}

3273

3265

3274

3266

3275

static void do_get_file_name(st_command *command, string &dest)

3267

static void do_get_file_name(st_command* command, string &dest)

3276

3268

{

3277

3269

char *p= command->first_argument;

3278

3270

if (!*p)

3293

3285

}

3294

3286

3295

3287

3296

static void do_set_charset(struct st_command *command)

3288

static void do_set_charset(st_command* command)

3297

3289

{

3298

3290

char *charset_name= command->first_argument;

3299

3291

char *p;

3316

3308

{

3317

3309

drizzle_result_st res;

3318

3310

drizzle_return_t ret;

3319

drizzle_row_t row;

3320

3311

drizzle_con_st *con= &cur_con->con;

3321

3312

3322

3313

global_error_names.clear();

3323

3314

3324

const std::string ds_query("select error_name, error_code "

3325

"from data_dictionary.errors");

3315

const std::string ds_query("select error_name, error_code from data_dictionary.errors");

3326

3316

if (drizzle_query_str(con, &res, ds_query.c_str(), &ret) == NULL ||

3327

3317

ret != DRIZZLE_RETURN_OK)

3328

3318

{

3329

3319

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3330

3320

{

3331

die("Error running query '%s': %d %s", ds_query.c_str(),

3332

drizzle_result_error_code(&res), drizzle_result_error(&res));

3333

drizzle_result_free(&res);

3321

die("Error running query '%s': %d %s", ds_query.c_str(), drizzle_result_error_code(&res), drizzle_result_error(&res));

3334

3322

}

3335

3323

else

3336

3324

{

3337

die("Error running query '%s': %d %s", ds_query.c_str(), ret,

3338

drizzle_con_error(con));

3325

die("Error running query '%s': %d %s", ds_query.c_str(), ret, drizzle_con_error(con));

3339

3326

}

3340

3327

}

3341

3328

if (drizzle_result_column_count(&res) == 0 ||

3345

3332

die("Query '%s' didn't return a result set", ds_query.c_str());

3346

3333

}

3347

3334

3348

while ((row= drizzle_row_next(&res)) && row[0])

3335

while (drizzle_row_t row= drizzle_row_next(&res))

3349

3336

{

3337

if (not row[0])

3338

break;

3350

3339

/*

3351

3340

Concatenate all fields in the first row with tab in between

3352

3341

and assign that string to the $variable

3378

3367

return 0;

3379

3368

}

3380

3369

3381

static void do_get_errcodes(struct st_command *command)

3370

static void do_get_errcodes(st_command* command)

3382

3371

{

3383

3372

struct st_match_err *to= saved_expected_errors.err;

3384

3373

char *p= command->first_argument;

3489

3478

*/

3490

3479

3491

3480

static char *get_string(char **to_ptr, char **from_ptr,

3492

struct st_command *command)

3481

st_command* command)

3493

3482

{

3494

3483

char c, sep;

3495

3484

char *to= *to_ptr, *from= *from_ptr, *start=to;

3582

3571

}

3583

3572

3584

3573

3585

static int select_connection(struct st_command *command)

3574

static int select_connection(st_command* command)

3586

3575

{

3587

3576

char *name;

3588

3577

char *p= command->first_argument;

3600

3589

}

3601

3590

3602

3591

3603

static void do_close_connection(struct st_command *command)

3592

static void do_close_connection(st_command* command)

3604

3593

{

3605

3594

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

3606

3595

st_connection *con;

3725

3714

3726

3715

*/

3727

3716

3728

static int connect_n_handle_errors(struct st_command *command,

3717

static int connect_n_handle_errors(st_command* command,

3729

3718

drizzle_con_st *con, const char* host,

3730

3719

const char* user, const char* pass,

3731

3720

const char* db, int port, const char* sock)

3808

3797

3809

3798

*/

3810

3799

3811

static void do_connect(struct st_command *command)

3800

static void do_connect(st_command* command)

3812

3801

{

3813

3802

uint32_t con_port= opt_port;

3814

3803

const char *con_options;

3928

3917

}

3929

3918

3930

3919

3931

static int do_done(struct st_command *command)

3920

static int do_done(st_command* command)

3932

3921

{

3933

3922

/* Check if empty block stack */

3934

3923

if (cur_block == block_stack)

4370

4359

suspicious things and generate warnings.

4371

4360

*/

4372

4361

4373

static void scan_command_for_warnings(struct st_command *command)

4362

static void scan_command_for_warnings(st_command* command)

4374

4363

{

4375

4364

const char *ptr= command->query;

4376

4365

4861

4850

*/

4862

4851

4863

4852

static void run_query_normal(st_connection *cn,

4864

struct st_command *command,

4853

st_command* command,

4865

4854

int flags, char *query, int query_len,

4866

4855

string *ds, string *ds_warnings)

4867

4856

{

5016

5005

immediately.

5017

5006

*/

5018

5007

5019

void handle_error(struct st_command *command,

5008

void handle_error(st_command* command,

5020

5009

unsigned int err_errno, const char *err_error,

5021

5010

const char *err_sqlstate, string *ds)

5022

5011

{

5108

5097

error - function will not return

5109

5098

*/

5110

5099

5111

void handle_no_error(struct st_command *command)

5100

void handle_no_error(st_command* command)

5112

5101

{

5113

5102

5114

5103

5145

5134

*/

5146

5135

5147

5136

static void run_query(st_connection *cn,

5148

struct st_command *command,

5137

st_command* command,

5149

5138

int flags)

5150

5139

{

5151

5140

string *ds= NULL;

5384

5373

{

5385

5374

try

5386

5375

{

5387

struct st_command *command;

5376

st_command* command;

5388

5377

bool q_send_flag= 0, abort_flag= 0;

5389

5378

uint32_t command_executed= 0, last_command_executed= 0;

5390

5379

string save_file("");

5738

5727

case Q_SOURCE: do_source(command); break;

5739

5728

case Q_SLEEP: do_sleep(command, 0); break;

5740

5729

case Q_REAL_SLEEP: do_sleep(command, 1); break;

5741

case Q_WAIT_FOR_SLAVE_TO_STOP: do_wait_for_slave_to_stop(command); break;

5730

case Q_WAIT_FOR_SLAVE_TO_STOP: do_wait_for_slave_to_stop(); break;

5742

5731

case Q_INC: do_modify_var(command, DO_INC); break;

5743

5732

case Q_DEC: do_modify_var(command, DO_DEC); break;

5744

5733

case Q_ECHO: do_echo(command); command_executed++; break;

6120

6109

variable is replaced.

6121

6110

*/

6122

6111

6123

void do_get_replace_column(struct st_command *command)

6112

void do_get_replace_column(st_command* command)

6124

6113

{

6125

6114

char *from= command->first_argument;

6126

6115

char *buff, *start;

6217

6206

free(str);

6218

6207

}

6219

6208

6220

void do_get_replace(st_command *command)

6209

void do_get_replace(st_command* command)

6221

6210

{

6222

6211

char *from= command->first_argument;

6223

6212

if (!*from)

6535

6524

case-sensitive

6536

6525

6537

6526

*/

6538

void do_get_replace_regex(struct st_command *command)

6527

void do_get_replace_regex(st_command* command)

6539

6528

{

6540

6529

char *expr= command->first_argument;

6541

6530

glob_replace_regex.reset(new st_replace_regex(expr));