~drizzle-trunk/drizzle/development

((name && !my_strnncoll(charset_info,(const uchar*)name,len, (const uchar*)commands[i].name,len) && !commands[i].name[len] && (!end || (end && commands[i].takes_params))) || (!name && commands[i].cmd_char == cmd_char)))

1868

((name && !my_strnncoll(charset_info,(const unsigned char*)name,len, (const unsigned char*)commands[i].name,len) && !commands[i].name[len] && (!end || (end && commands[i].takes_params))) || (!name && commands[i].cmd_char == cmd_char)))

1809

1869

{

1810

1870

return(&commands[i]);

1811

1871

}

1817

1877

static bool add_line(string *buffer, char *line, char *in_string,

1818

1878

bool *ml_comment)

1819

1879

{

1820

uchar inchar;

1880

unsigned char inchar;

1821

1881

char buff[80], *pos, *out;

1822

1882

COMMANDS *com;

1823

1883

bool need_space= 0;

1830

1890

add_history(line);

1831

1891

char *end_of_line=line+(uint) strlen(line);

1832

1892

1833

for (pos=out=line ; (inchar= (uchar) *pos) ; pos++)

1893

for (pos=out=line ; (inchar= (unsigned char) *pos) ; pos++)

1834

1894

{

1835

1895

if (!preserve_comments)

1836

1896

{

1862

1922

{

1863

1923

// Found possbile one character command like \c

1864

1924

1865

if (!(inchar = (uchar) *++pos))

1925

if (!(inchar = (unsigned char) *++pos))

1866

1926

break; // readline adds one '\'

1867

1927

if (*in_string || inchar == 'N') // \N is short for NULL

1868

1928

{ // Don't allow commands in string

1870

1930

*out++= (char) inchar;

1871

1931

continue;

1872

1932

}

1873

if ((com=find_command(NullS,(char) inchar)))

1933

if ((com=find_command(NULL,(char) inchar)))

1874

1934

{

1875

1935

// Flush previously accepted characters

1876

1936

if (out != line)

1919

1979

}

1920

1980

else if (!*ml_comment && !*in_string &&

1921

1981

(end_of_line - pos) >= 10 &&

1922

!my_strnncoll(charset_info, (uchar*) pos, 10,

1923

(const uchar*) "delimiter ", 10))

1982

!my_strnncoll(charset_info, (unsigned char*) pos, 10,

1983

(const unsigned char*) "delimiter ", 10))

1924

1984

{

1925

1985

// Flush previously accepted characters

1926

1986

if (out != line)

2085

2145

2086

2146

2087

2147

static char **mysql_completion (const char *text, int start, int end);

2088

static char *new_command_generator(const char *text, int);

2148

extern "C" char *new_command_generator(const char *text, int);

2089

2149

2090

2150

2091

2151

Tell the GNU Readline library how to complete. We want to try to complete

2092

2152

on command names if this is the first word in the line, or on filenames

2093

2153

if not.

2094

2154

2095

static char *no_completion(const char * a __attribute__((unused)),

2096

int b __attribute__((unused)))

2155

static char *no_completion(const char *, int)

2097

2156

{

2098

2157

/* No filename completion */

2099

2158

return 0;

2188

2247

entire line in case we want to do some simple parsing. Return the

2189

2248

array of matches, or NULL if there aren't any.

2190

2249

2191

char **mysql_completion (const char *text,

2192

int start __attribute__((unused)),

2193

int end __attribute__((unused)))

2250

char **mysql_completion (const char *text, int, int)

2194

2251

{

2195

2252

if (!status.batch && !quick)

2196

2253

return rl_completion_matches(text, new_command_generator);

2198

2255

return (char**) 0;

2199

2256

}

2200

2257

2201

2202

static char *new_command_generator(const char *text,int state)

2258

extern "C"

2259

char *new_command_generator(const char *text,int state)

2203

2260

{

2204

2261

static int textlen;

2205

2262

char *ptr;

2218

2275

2219

2276

b = find_all_matches(&ht,text,(uint) strlen(text),&len);

2220

2277

if (!b)

2221

return NullS;

2278

return NULL;

2222

2279

e = b->pData;

2223

2280

}

2224

2281

2245

2302

}

2246

2303

}

2247

2304

}

2248

ptr= NullS;

2305

ptr= NULL;

2249

2306

while (e && !ptr)

2250

2307

{ /* find valid entry in bucket */

2251

2308

if ((uint) strlen(e->str) == b->nKeyLength)

2274

2331

if (ptr)

2275

2332

return ptr;

2276

2333

}

2277

return NullS;

2334

return NULL;

2278

2335

}

2279

2336

2280

2337

2365

2422

i=0;

2366

2423

while ((table_row=drizzle_fetch_row(tables)))

2367

2424

{

2368

if ((fields=drizzle_list_fields(&drizzle,(const char*) table_row[0],NullS)))

2425

if ((fields=drizzle_list_fields(&drizzle,(const char*) table_row[0],NULL)))

2369

2426

{

2370

2427

num_fields=drizzle_num_fields(fields);

2371

2428

if (!(field_names[i] = (char **) alloc_root(&hash_mem_root,

2412

2469

for (;;)

2413

2470

{

2414

2471

if (*s == (char) c) return (char*) s;

2415

if (!*s++) return NullS;

2472

if (!*s++) return NULL;

2416

2473

}

2417

2474

}

2418

2475

2420

2477

{

2421

2478

2422

2479

2423

t = NullS;

2480

t = NULL;

2424

2481

do if (*s == (char) c) t = (char*) s; while (*s++);

2425

2482

return (char*) t;

2426

2483

}

2448

2505

{

2449

2506

DRIZZLE_RES *res;

2450

2507

2451

my_free(current_db, MYF(MY_ALLOW_ZERO_PTR));

2508

free(current_db);

2452

2509

current_db= NULL;

2453

2510

/* In case of error below current_db will be NULL */

2454

2511

if (!drizzle_query(&drizzle, "SELECT DATABASE()") &&

2503

2560

}

2504

2561

2505

2562

2506

static int com_server_help(string *buffer,

2507

const char *line __attribute__((unused)),

2508

char *help_arg)

2563

static int com_server_help(string *buffer, const char *, const char *help_arg)

2509

2564

{

2510

2565

DRIZZLE_ROW cur;

2511

2566

const char *server_cmd= buffer->c_str();

2512

char cmd_buf[100];

2567

string cmd_buf;

2513

2568

DRIZZLE_RES *result;

2514

2569

int error;

2515

2570

2571

cmd_buf.reserve(100);

2516

2572

if (help_arg[0] != '\'')

2517

2573

{

2518

char *end_arg= strend(help_arg);

2574

const char *end_arg= strchr(help_arg, '\0');

2519

2575

if(--end_arg)

2520

2576

{

2521

2577

while (my_isspace(charset_info,*end_arg))

2522

2578

end_arg--;

2523

*++end_arg= '\0';

2524

2579

}

2525

(void) strxnmov(cmd_buf, sizeof(cmd_buf), "help '", help_arg, "'", NullS);

2526

server_cmd= cmd_buf;

2580

cmd_buf.append("help '");

2581

cmd_buf.append(help_arg, end_arg-help_arg);

2582

cmd_buf.append("'");

2583

2584

server_cmd= cmd_buf.c_str();

2527

2585

}

2528

2586

2529

2587

if (!connected && reconnect())

2595

2653

}

2596

2654

2597

2655

static int

2598

com_help(string *buffer __attribute__((unused)),

2599

const char *line __attribute__((unused)))

2656

com_help(string *buffer, const char *line)

2600

2657

{

2601

2658

2602

char * help_arg= strchr(line,' '), buff[32], *end;

2659

const char *help_arg= strchr(line,' ');

2660

char buff[32], *end;

2603

2661

if (help_arg)

2604

2662

{

2605

2663

while (my_isspace(charset_info,*help_arg))

2612

2670

put_info(_("Note that all text commands must be first on line and end with ';'"),INFO_INFO,0,0);

2613

2671

for (i = 0; commands[i].name; i++)

2614

2672

{

2615

end= stpcpy(buff, commands[i].name);

2673

end= strcpy(buff, commands[i].name);

2674

end+= strlen(commands[i].name);

2616

2675

for (j= (int)strlen(commands[i].name); j < 10; j++)

2617

end= stpcpy(end, " ");

2676

end= strcpy(end, " ")+1;

2618

2677

if (commands[i].func)

2619

2678

tee_fprintf(stdout, "%s(\\%c) %s\n", buff,

2620

2679

commands[i].cmd_char, _(commands[i].doc));

2626

2685

2627

2686

2628

2687

static int

2629

com_clear(string *buffer,

2630

const char *line __attribute__((unused)))

2688

com_clear(string *buffer, const char *)

2631

2689

{

2632

2690

if (status.add_to_history)

2633

2691

fix_history(buffer);

2635

2693

return 0;

2636

2694

}

2637

2695

2638

static int

2639

com_charset(string *buffer __attribute__((unused)),

2640

const char *line)

2641

{

2642

char buff[256], *param;

2643

const CHARSET_INFO * new_cs;

2644

strmake(buff, line, sizeof(buff) - 1);

2645

param= get_arg(buff, 0);

2646

if (!param || !*param)

2647

{

2648

return put_info(_("Usage: \\C char_setname | charset charset_name"),

2649

INFO_ERROR, 0, 0);

2650

}

2651

new_cs= get_charset_by_csname(param, MY_CS_PRIMARY, MYF(MY_WME));

2652

if (new_cs)

2653

{

2654

charset_info= new_cs;

2655

drizzle_set_character_set(&drizzle, charset_info->csname);

2656

default_charset= (char *)charset_info->csname;

2657

default_charset_used= 1;

2658

put_info(_("Charset changed"), INFO_INFO,0,0);

2659

}

2660

else put_info(_("Charset is not found"), INFO_INFO,0,0);

2661

return 0;

2662

}

2663

2696

2664

2697

2665

2698

Execute command

2668

2701

1 if fatal error

2669

2702

2670

2703

static int

2671

com_go(string *buffer,

2672

const char *line __attribute__((unused)))

2704

com_go(string *buffer, const char *)

2673

2705

{

2674

2706

char buff[200]; /* about 110 chars used so far */

2675

2707

char time_buff[52+3+1]; /* time max + space&parens + NUL */

2752

2784

{

2753

2785

if (!drizzle_num_rows(result) && ! quick && !column_types_flag)

2754

2786

{

2755

stpcpy(buff, _("Empty set"));

2787

strcpy(buff, _("Empty set"));

2756

2788

}

2757

2789

else

2758

2790

{

2774

2806

}

2775

2807

}

2776

2808

else if (drizzle_affected_rows(&drizzle) == ~(uint64_t) 0)

2777

stpcpy(buff,_("Query OK"));

2809

strcpy(buff,_("Query OK"));

2778

2810

else

2779

2811

sprintf(buff, ngettext("Query OK, %ld row affected",

2780

2812

"Query OK, %ld rows affected",

2781

2813

(long) drizzle_affected_rows(&drizzle)),

2782

2814

(long) drizzle_affected_rows(&drizzle));

2783

2815

2784

pos=strend(buff);

2816

pos= strchr(buff, '\0');

2785

2817

if ((warnings= drizzle_warning_count(&drizzle)))

2786

2818

{

2787

2819

*pos++= ',';

2788

2820

*pos++= ' ';

2789

pos=int10_to_str(warnings, pos, 10);

2790

pos=stpcpy(pos, " warning");

2821

pos= int10_to_str(warnings, pos, 10);

2822

pos= strcpy(pos, " warning")+8;

2791

2823

if (warnings != 1)

2792

2824

*pos++= 's';

2793

2825

}

2794

stpcpy(pos, time_buff);

2826

strcpy(pos, time_buff);

2795

2827

put_info(buff,INFO_RESULT,0,0);

2796

2828

if (drizzle_info(&drizzle))

2797

2829

put_info(drizzle_info(&drizzle),INFO_RESULT,0,0);

2853

2885

return;

2854

2886

}

2855

2887

OUTFILE = new_outfile;

2856

strmake(outfile, file_name, FN_REFLEN-1);

2888

strncpy(outfile, file_name, FN_REFLEN-1);

2857

2889

tee_fprintf(stdout, "Logging to file '%s'\n", file_name);

2858

2890

opt_outfile= 1;

2859

2891

return;

2885

2917

{

2886

2918

switch (type) {

2887

2919

case DRIZZLE_TYPE_BLOB: return "BLOB";

2888

case DRIZZLE_TYPE_NEWDATE: return "DATE";

2920

case DRIZZLE_TYPE_DATE: return "DATE";

2889

2921

case DRIZZLE_TYPE_DATETIME: return "DATETIME";

2890

2922

case DRIZZLE_TYPE_NEWDECIMAL: return "DECIMAL";

2891

2923

case DRIZZLE_TYPE_DOUBLE: return "DOUBLE";

2893

2925

case DRIZZLE_TYPE_LONG: return "LONG";

2894

2926

case DRIZZLE_TYPE_LONGLONG: return "LONGLONG";

2895

2927

case DRIZZLE_TYPE_NULL: return "NULL";

2896

case DRIZZLE_TYPE_SHORT: return "SHORT";

2897

2928

case DRIZZLE_TYPE_TIME: return "TIME";

2898

2929

case DRIZZLE_TYPE_TIMESTAMP: return "TIMESTAMP";

2899

2930

case DRIZZLE_TYPE_TINY: return "TINY";

2931

case DRIZZLE_TYPE_VIRTUAL: return "VIRTUAL";

2900

2932

default: return "?-unknown-?";

2901

2933

}

2902

2934

}

2906

2938

char *s=buf;

2907

2939

*s=0;

2908

2940

#define ff2s_check_flag(X) \

2909

if (f & X ## _FLAG) { s=stpcpy(s, # X " "); f &= ~ X ## _FLAG; }

2941

if (f & X ## _FLAG) { s=strcpy(s, # X " ")+strlen(# X " "); \

2942

f &= ~ X ## _FLAG; }

2910

2943

ff2s_check_flag(NOT_NULL);

2911

2944

ff2s_check_flag(PRI_KEY);

2912

2945

ff2s_check_flag(UNIQUE_KEY);

2968

3001

DRIZZLE_FIELD *field;

2969

3002

bool *num_flag;

2970

3003

string separator;

2971

3004

2972

3005

separator.reserve(256);

2973

3006

2974

num_flag=(bool*) my_malloc(sizeof(bool)*drizzle_num_fields(result),

2975

MYF(MY_WME));

3007

num_flag=(bool*) malloc(sizeof(bool)*drizzle_num_fields(result));

2976

3008

if (column_types_flag)

2977

3009

{

2978

3010

print_field_types(result);

2988

3020

length=max(length,field->length);

2989

3021

else

2990

3022

length=max(length,field->max_length);

2991

if (length < 4 && !IS_NOT_NULL(field->flags))

3023

if (length < 4 && !(field->flags & NOT_NULL_FLAG))

2992

3024

// Room for "NULL"

2993

3025

length=4;

2994

3026

field->max_length=length;

3013

3045

tee_fprintf(PAGER, " %-*s |",(int) min(display_length,

3014

3046

MAX_COLUMN_LENGTH),

3015

3047

field->name);

3016

num_flag[off]= IS_NUM(field->type);

3048

num_flag[off]= ((field->type <= DRIZZLE_TYPE_LONGLONG) ||

3049

(field->type == DRIZZLE_TYPE_NEWDECIMAL));

3017

3050

}

3018

3051

(void) tee_fputs("\n", PAGER);

3019

3052

tee_puts((char*) separator.c_str(), PAGER);

3074

3107

(void) tee_fputs("\n", PAGER);

3075

3108

}

3076

3109

tee_puts(separator.c_str(), PAGER);

3077

my_free(num_flag, MYF(MY_ALLOW_ZERO_PTR));

3110

free(num_flag);

3078

3111

}

3079

3112

3080

3113

/**

3095

3128

3096

3129

static int get_field_disp_length(DRIZZLE_FIELD *field)

3097

3130

{

3098

uint length= column_names ? field->name_length : 0;

3131

uint32_t length= column_names ? field->name_length : 0;

3099

3132

3100

3133

if (quick)

3101

3134

length= max(length, field->length);

3102

3135

else

3103

3136

length= max(length, field->max_length);

3104

3137

3105

if (length < 4 && !IS_NOT_NULL(field->flags))

3138

if (length < 4 && !(field->flags & NOT_NULL_FLAG))

3106

3139

length= 4; /* Room for "NULL" */

3107

3140

3108

3141

return length;

3204

3237

DRIZZLE_RES *result;

3205

3238

DRIZZLE_ROW cur;

3206

3239

uint64_t num_rows;

3207

3240

3208

3241

/* Save current error before calling "show warnings" */

3209

3242

uint error= drizzle_errno(&drizzle);

3210

3243

3310

3343

}

3311

3344

3312

3345

static int

3313

com_tee(string *buffer __attribute__((unused)), const char *line )

3346

com_tee(string *, const char *line )

3314

3347

{

3315

char file_name[FN_REFLEN], *end, *param;

3348

char file_name[FN_REFLEN], *end;

3349

const char *param;

3316

3350

3317

3351

if (status.batch)

3318

3352

return 0;

3337

3371

/* eliminate the spaces before the parameters */

3338

3372

while (my_isspace(charset_info,*param))

3339

3373

param++;

3340

end= strmake(file_name, param, sizeof(file_name) - 1);

3374

strncpy(file_name, param, sizeof(file_name) - 1);

3375

end= file_name + strlen(file_name);

3341

3376

/* remove end space from command line */

3342

3377

while (end > file_name && (my_isspace(charset_info,end[-1]) ||

3343

3378

my_iscntrl(charset_info,end[-1])))

3354

3389

3355

3390

3356

3391

static int

3357

com_notee(string *buffer __attribute__((unused)),

3358

const char *line __attribute__((unused)))

3392

com_notee(string *, const char *)

3359

3393

{

3360

3394

if (opt_outfile)

3361

3395

end_tee();

3368

3402

3369

3403

3370

3404

static int

3371

com_pager(string *buffer __attribute__((unused)),

3372

const char *line __attribute__((unused)))

3405

com_pager(string *, const char *line)

3373

3406

{

3374

char pager_name[FN_REFLEN], *end, *param;

3407

char pager_name[FN_REFLEN], *end;

3408

const char *param;

3375

3409

3376

3410

if (status.batch)

3377

3411

return 0;

3389

3423

{

3390

3424

tee_fprintf(stdout, "Default pager wasn't set, using stdout.\n");

3391

3425

opt_nopager=1;

3392

stpcpy(pager, "stdout");

3426

strcpy(pager, "stdout");

3393

3427

PAGER= stdout;

3394

3428

return 0;

3395

3429

}

3396

stpcpy(pager, default_pager);

3430

strcpy(pager, default_pager);

3397

3431

}

3398

3432

else

3399

3433

{

3400

end= strmake(pager_name, param, sizeof(pager_name)-1);

3434

end= strncpy(pager_name, param, sizeof(pager_name)-1);

3435

end+= strlen(pager_name);

3401

3436

while (end > pager_name && (my_isspace(charset_info,end[-1]) ||

3402

3437

my_iscntrl(charset_info,end[-1])))

3403

3438

end--;

3404

3439

end[0]=0;

3405

stpcpy(pager, pager_name);

3406

stpcpy(default_pager, pager_name);

3440

strcpy(pager, pager_name);

3441

strcpy(default_pager, pager_name);

3407

3442

}

3408

3443

opt_nopager=0;

3409

3444

tee_fprintf(stdout, "PAGER set to '%s'\n", pager);

3412

3447

3413

3448

3414

3449

static int

3415

com_nopager(string *buffer __attribute__((unused)),

3416

const char *line __attribute__((unused)))

3450

com_nopager(string *, const char *)

3417

3451

{

3418

stpcpy(pager, "stdout");

3452

strcpy(pager, "stdout");

3419

3453

opt_nopager=1;

3420

3454

PAGER= stdout;

3421

3455

tee_fprintf(stdout, "PAGER set to stdout\n");

3425

3459

/* If arg is given, exit without errors. This happens on command 'quit' */

3426

3460

3427

3461

static int

3428

com_quit(string *buffer __attribute__((unused)),

3429

const char *line __attribute__((unused)))

3462

com_quit(string *, const char *)

3430

3463

{

3431

3464

/* let the screen auto close on a normal shutdown */

3432

3465

status.exit_status=0;

3434

3467

}

3435

3468

3436

3469

static int

3437

com_rehash(string *buffer __attribute__((unused)),

3438

const char *line __attribute__((unused)))

3470

com_rehash(string *, const char *)

3439

3471

{

3440

3472

build_completion_hash(1, 0);

3441

3473

return 0;

3444

3476

3445

3477

3446

3478

static int

3447

com_print(string *buffer,const char *line __attribute__((unused)))

3479

com_print(string *buffer,const char *)

3448

3480

{

3449

3481

tee_puts("--------------", stdout);

3450

3482

(void) tee_fputs(buffer->c_str(), stdout);

3471

3503

Two null bytes are needed in the end of buff to allow

3472

3504

get_arg to find end of string the second time it's called.

3473

3505

3474

tmp= strmake(buff, line, sizeof(buff)-2);

3506

tmp= strncpy(buff, line, sizeof(buff)-2);

3475

3507

#ifdef EXTRA_DEBUG

3476

3508

tmp[1]= 0;

3477

3509

#endif

3478

3510

tmp= get_arg(buff, 0);

3479

3511

if (tmp && *tmp)

3480

3512

{

3481

my_free(current_db, MYF(MY_ALLOW_ZERO_PTR));

3513

free(current_db);

3482

3514

current_db= strdup(tmp);

3483

3515

tmp= get_arg(buff, 1);

3484

3516

if (tmp)

3485

3517

{

3486

my_free(current_host,MYF(MY_ALLOW_ZERO_PTR));

3518

free(current_host);

3487

3519

current_host=strdup(tmp);

3488

3520

}

3489

3521

}

3513

3545

}

3514

3546

3515

3547

3516

static int com_source(string *buffer __attribute__((unused)), const char *line)

3548

static int com_source(string *, const char *line)

3517

3549

{

3518

char source_name[FN_REFLEN], *end, *param;

3550

char source_name[FN_REFLEN], *end;

3551

const char *param;

3519

3552

LINE_BUFFER *line_buff;

3520

3553

int error;

3521

3554

STATUS old_status;

3529

3562

INFO_ERROR, 0,0);

3530

3563

while (my_isspace(charset_info,*param))

3531

3564

param++;

3532

end=strmake(source_name,param,sizeof(source_name)-1);

3565

end= strncpy(source_name,param,sizeof(source_name)-1);

3566

end+= strlen(source_name);

3533

3567

while (end > source_name && (my_isspace(charset_info,end[-1]) ||

3534

3568

my_iscntrl(charset_info,end[-1])))

3535

3569

end--;

3536

3570

end[0]=0;

3537

3571

unpack_filename(source_name,source_name);

3538

3572

/* open file name */

3539

if (!(sql_file = my_fopen(source_name, O_RDONLY | O_BINARY,MYF(0))))

3573

if (!(sql_file = my_fopen(source_name, O_RDONLY,MYF(0))))

3540

3574

{

3541

3575

char buff[FN_REFLEN+60];

3542

3576

sprintf(buff,"Failed to open file '%s', error: %d", source_name,errno);

3571

3605

3572

3606

/* ARGSUSED */

3573

3607

static int

3574

com_delimiter(string *buffer __attribute__((unused)), const char *line)

3608

com_delimiter(string *, const char *line)

3575

3609

{

3576

3610

char buff[256], *tmp;

3577

3611

3578

strmake(buff, line, sizeof(buff) - 1);

3612

strncpy(buff, line, sizeof(buff) - 1);

3579

3613

tmp= get_arg(buff, 0);

3580

3614

3581

3615

if (!tmp || !*tmp)

3593

3627

return 0;

3594

3628

}

3595

3629

}

3596

strmake(delimiter, tmp, sizeof(delimiter) - 1);

3630

strncpy(delimiter, tmp, sizeof(delimiter) - 1);

3597

3631

delimiter_length= (int)strlen(delimiter);

3598

3632

delimiter_str= delimiter;

3599

3633

return 0;

3601

3635

3602

3636

/* ARGSUSED */

3603

3637

static int

3604

com_use(string *buffer __attribute__((unused)), const char *line)

3638

com_use(string *, const char *line)

3605

3639

{

3606

3640

char *tmp, buff[FN_REFLEN + 1];

3607

3641

int select_db;

3608

3642

3609

3643

memset(buff, 0, sizeof(buff));

3610

strmake(buff, line, sizeof(buff) - 1);

3644

strncpy(buff, line, sizeof(buff) - 1);

3611

3645

tmp= get_arg(buff, 0);

3612

3646

if (!tmp || !*tmp)

3613

3647

{

3662

3696

if (drizzle_select_db(&drizzle,tmp))

3663

3697

return put_error(&drizzle);

3664

3698

}

3665

my_free(current_db,MYF(MY_ALLOW_ZERO_PTR));

3699

free(current_db);

3666

3700

current_db= strdup(tmp);

3667

3701

if (select_db > 1)

3668

3702

build_completion_hash(opt_rehash, 1);

3673

3707

}

3674

3708

3675

3709

static int

3676

com_warnings(string *buffer __attribute__((unused)),

3677

const char *line __attribute__((unused)))

3710

com_warnings(string *, const char *)

3678

3711

{

3679

3712

show_warnings = 1;

3680

3713

put_info("Show warnings enabled.",INFO_INFO, 0, 0);

3682

3715

}

3683

3716

3684

3717

static int

3685

com_nowarnings(string *buffer __attribute__((unused)),

3686

const char *line __attribute__((unused)))

3718

com_nowarnings(string *, const char *)

3687

3719

{

3688

3720

show_warnings = 0;

3689

3721

put_info("Show warnings disabled.",INFO_INFO, 0, 0);

3725

3757

ptr++;

3726

3758

}

3727

3759

if (!*ptr)

3728

return NullS;

3760

return NULL;

3729

3761

while (my_isspace(charset_info, *ptr))

3730

3762

ptr++;

3731

3763

if (*ptr == '\'' || *ptr == '\"' || *ptr == '`')

3739

3771

if (*ptr == '\\' && ptr[1]) // escaped character

3740

3772

{

3741

3773

// Remove the backslash

3742

stpcpy(ptr, ptr+1);

3774

strcpy(ptr, ptr+1);

3743

3775

}

3744

3776

else if ((!quoted && *ptr == ' ') || (quoted && *ptr == qtype))

3745

3777

{

3748

3780

}

3749

3781

}

3750

3782

valid_arg= ptr != start;

3751

return valid_arg ? start : NullS;

3783

return valid_arg ? start : NULL;

3752

3784

}

3753

3785

3754

3786

3769

3801

(char*) &timeout);

3770

3802

}

3771

3803

if (opt_compress)

3772

drizzle_options(&drizzle,DRIZZLE_OPT_COMPRESS,NullS);

3804

drizzle_options(&drizzle,DRIZZLE_OPT_COMPRESS,NULL);

3773

3805

if (opt_secure_auth)

3774

3806

drizzle_options(&drizzle, DRIZZLE_SECURE_AUTH, (char *) &opt_secure_auth);

3775

3807

if (using_opt_local_infile)

3776

3808

drizzle_options(&drizzle,DRIZZLE_OPT_LOCAL_INFILE, (char*) &opt_local_infile);

3777

drizzle_options(&drizzle,DRIZZLE_OPT_PROTOCOL,(char*)&opt_protocol);

3778

3809

if (safe_updates)

3779

3810

{

3780

3811

char init_command[100];

3781

3812

sprintf(init_command,

3782

3813

"SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%"PRIu32

3783

",SQL_MAX_JOIN_SIZE=%"PRIu32,

3814

",MAX_JOIN_SIZE=%"PRIu32,

3784

3815

select_limit, max_join_size);

3785

3816

drizzle_options(&drizzle, DRIZZLE_INIT_COMMAND, init_command);

3786

3817

}

3787

if (default_charset_used)

3788

drizzle_options(&drizzle, DRIZZLE_SET_CHARSET_NAME, default_charset);

3789

3818

if (!drizzle_connect(&drizzle, host, user, password,

3790

3819

database, opt_drizzle_port, opt_drizzle_unix_port,

3791

3820

connect_flag | CLIENT_MULTI_STATEMENTS))

3808

3837

3809

3838

3810

3839

static int

3811

com_status(string *buffer __attribute__((unused)),

3812

const char *line __attribute__((unused)))

3840

com_status(string *, const char *)

3813

3841

{

3814

3842

char buff[40];

3815

3843

uint64_t id;

3873

3901

}

3874

3902

drizzle_free_result(result);

3875

3903

}

3876

else

3877

{

3878

/* Probably pre-4.1 server */

3879

tee_fprintf(stdout, "Client characterset:\t%s\n", charset_info->csname);

3880

tee_fprintf(stdout, "Server characterset:\t%s\n", drizzle.charset->csname);

3881

}

3882

3904

3883

3905

if (strstr(drizzle_get_host_info(&drizzle),"TCP/IP") || ! drizzle.unix_socket)

3884

3906

tee_fprintf(stdout, "TCP port:\t\t%d\n", drizzle.port);

3906

3928

static const char *

3907

3929

server_version_string(DRIZZLE *con)

3908

3930

{

3909

static char buf[MAX_SERVER_VERSION_LENGTH] = "";

3931

static string buf("");

3932

static bool server_version_string_reserved= false;

3910

3933

3934

if (!server_version_string_reserved)

3935

{

3936

buf.reserve(MAX_SERVER_VERSION_LENGTH);

3937

server_version_string_reserved= true;

3938

}

3911

3939

/* Only one thread calls this, so no synchronization is needed */

3912

3940

if (buf[0] == '\0')

3913

3941

{

3914

char *bufp = buf;

3915

3942

DRIZZLE_RES *result;

3916

3943

3917

bufp= stpncpy(buf, drizzle_get_server_info(con), sizeof buf);

3944

buf.append(drizzle_get_server_info(con));

3918

3945

3919

3946

/* "limit 1" is protection against SQL_SELECT_LIMIT=0 */

3920

3947

if (!drizzle_query(con, "select @@version_comment limit 1") &&

3923

3950

DRIZZLE_ROW cur = drizzle_fetch_row(result);

3924

3951

if (cur && cur[0])

3925

3952

{

3926

bufp = strxnmov(bufp, sizeof buf - (bufp - buf), " ", cur[0], NullS);

3953

buf.append(" ");

3954

buf.append(cur[0]);

3927

3955

}

3928

3956

drizzle_free_result(result);

3929

3957

}

3930

3931

/* str*nmov doesn't guarantee NUL-termination */

3932

if (bufp == buf + sizeof buf)

3933

buf[sizeof buf - 1] = '\0';

3934

3958

}

3935

3959

3936

return buf;

3960

return buf.c_str();

3937

3961

}

3938

3962

3939

3963

static int

4096

4120

if (sec >= 3600.0*24)

4097

4121

{

4098

4122

tmp=(uint32_t) floor(sec/(3600.0*24));

4099

sec-=3600.0*24*tmp;

4100

buff=int10_to_str((long) tmp, buff, 10);

4101

buff=stpcpy(buff,tmp > 1 ? " days " : " day ");

4123

sec-= 3600.0*24*tmp;

4124

buff= int10_to_str((long) tmp, buff, 10);

4125

4126

if (tmp > 1)

4127

buff= strcpy(buff," days ")+6;

4128

else

4129

buff= strcpy(buff," day ")+5;

4130

4102

4131

}

4103

4132

if (sec >= 3600.0)

4104

4133

{

4105

4134

tmp=(uint32_t) floor(sec/3600.0);

4106

4135

sec-=3600.0*tmp;

4107

4136

buff=int10_to_str((long) tmp, buff, 10);

4108

buff=stpcpy(buff,tmp > 1 ? " hours " : " hour ");

4137

4138

if (tmp > 1)

4139

buff= strcpy(buff, " hours ")+7;

4140

else

4141

buff= strcpy(buff, " hour ")+6;

4109

4142

}

4110

4143

if (sec >= 60.0)

4111

4144

{

4112

4145

tmp=(uint32_t) floor(sec/60.0);

4113

4146

sec-=60.0*tmp;

4114

4147

buff=int10_to_str((long) tmp, buff, 10);

4115

buff=stpcpy(buff," min ");

4148

buff= strcpy(buff," min ")+5;

4116

4149

}

4117

4150

if (part_second)

4118

4151

sprintf(buff,"%.2f sec",sec);

4133

4166

buff[0]=' ';

4134

4167

buff[1]='(';

4135

4168

end_timer(start_time,buff+2);

4136

stpcpy(strend(buff),")");

4169

strcpy(strchr(buff, '\0'),")");

4137

4170

}

4138

4171

4139

4172

static const char * construct_prompt()

4226

4259

break;

4227

4260

case PROMPT_CHAR:

4228

4261

{

4229

char c= PROMPT_CHAR;

4230

processed_prompt->append(&c, 1);

4262

processed_prompt->append(PROMPT_CHAR, 1);

4231

4263

}

4232

4264

break;

4233

4265

case 'n':

4234

4266

{

4235

char c= '\n';

4236

processed_prompt->append(&c, 1);

4267

processed_prompt->append('\n', 1);

4237

4268

}

4238

4269

break;

4239

4270

case ' ':

4240

4271

case '_':

4241

4272

{

4242

char c= ' ';

4243

processed_prompt->append(&c, 1);

4273

processed_prompt->append(' ', 1);

4244

4274

}

4245

4275

break;

4246

4276

case 'R':

4324

4354

4325

4355

static void init_username()

4326

4356

{

4327

my_free(full_username,MYF(MY_ALLOW_ZERO_PTR));

4328

my_free(part_username,MYF(MY_ALLOW_ZERO_PTR));

4357

free(full_username);

4358

free(part_username);

4329

4359

4330

4360

DRIZZLE_RES *result;

4331

4361

if (!drizzle_query(&drizzle,"select USER()") &&

4338

4368

}

4339

4369

}

4340

4370

4341

static int com_prompt(string *buffer __attribute__((unused)),

4342

const char *line)

4371

static int com_prompt(string *, const char *line)

4343

4372

{

4344

char *ptr=strchr(line, ' ');

4345

prompt_counter = 0;

4346

my_free(current_prompt, MYF(MY_ALLOW_ZERO_PTR));

4347

current_prompt= strdup(ptr ? ptr+1 : default_prompt);

4348

if (!ptr)

4373

const char *ptr=strchr(line, ' ');

4374

if (ptr == NULL)

4349

4375

tee_fprintf(stdout, "Returning to default PROMPT of %s\n",

4350

4376

default_prompt);

4377

prompt_counter = 0;

4378

char * tmpptr= strdup(ptr ? ptr+1 : default_prompt);

4379

if (tmpptr == NULL)

4380

tee_fprintf(stdout, "Memory allocation error. Not changing prompt\n");

4351

4381

else

4382

{

4383

free(current_prompt);

4384

current_prompt= tmpptr;

4352

4385

tee_fprintf(stdout, "PROMPT set to '%s'\n", current_prompt);

4386

}

4353

4387

return 0;

4354

4388

}

4355

4389

4356

4390

4357

4391

strcont(str, set) if str contanies any character in the string set.

4358

The result is the position of the first found character in str, or NullS

4392

The result is the position of the first found character in str, or NULL

4359

4393

if there isn't anything found.

4360

4394

4361

4395

Older »