~drizzle-trunk/drizzle/development

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

1800

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

1802

1801

{

1803

1802

return(&commands[i]);

1804

1803

}

1810

1809

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

1811

1810

bool *ml_comment)

1812

1811

{

1813

unsigned char inchar;

1812

uchar inchar;

1814

1813

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

1815

1814

COMMANDS *com;

1816

1815

bool need_space= 0;

1823

1822

add_history(line);

1824

1823

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

1825

1824

1826

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

1825

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

1827

1826

{

1828

1827

if (!preserve_comments)

1829

1828

{

1855

1854

{

1856

1855

// Found possbile one character command like \c

1857

1856

1858

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

1857

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

1859

1858

break; // readline adds one '\'

1860

1859

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

1861

1860

{ // Don't allow commands in string

1863

1862

*out++= (char) inchar;

1864

1863

continue;

1865

1864

}

1866

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

1865

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

1867

1866

{

1868

1867

// Flush previously accepted characters

1869

1868

if (out != line)

1912

1911

}

1913

1912

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

1914

1913

(end_of_line - pos) >= 10 &&

1915

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

1916

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

1914

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

1915

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

1917

1916

{

1918

1917

// Flush previously accepted characters

1919

1918

if (out != line)

2078

2077

2079

2078

2080

2079

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

2081

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

2080

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

2082

2081

2083

2082

2084

2083

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

2191

2190

return (char**) 0;

2192

2191

}

2193

2192

2194

extern "C"

2195

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

2193

2194

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

2196

2195

{

2197

2196

static int textlen;

2198

2197

char *ptr;

2211

2210

2212

2211

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

2213

2212

if (!b)

2214

return NULL;

2213

return NullS;

2215

2214

e = b->pData;

2216

2215

}

2217

2216

2238

2237

}

2239

2238

}

2240

2239

}

2241

ptr= NULL;

2240

ptr= NullS;

2242

2241

while (e && !ptr)

2243

2242

{ /* find valid entry in bucket */

2244

2243

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

2267

2266

if (ptr)

2268

2267

return ptr;

2269

2268

}

2270

return NULL;

2269

return NullS;

2271

2270

}

2272

2271

2273

2272

2358

2357

i=0;

2359

2358

while ((table_row=drizzle_fetch_row(tables)))

2360

2359

{

2361

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

2360

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

2362

2361

{

2363

2362

num_fields=drizzle_num_fields(fields);

2364

2363

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

2405

2404

for (;;)

2406

2405

{

2407

2406

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

2408

if (!*s++) return NULL;

2407

if (!*s++) return NullS;

2409

2408

}

2410

2409

}

2411

2410

2413

2412

{

2414

2413

2415

2414

2416

t = NULL;

2415

t = NullS;

2417

2416

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

2418

2417

return (char*) t;

2419

2418

}

2441

2440

{

2442

2441

DRIZZLE_RES *res;

2443

2442

2444

free(current_db);

2443

my_free(current_db, MYF(MY_ALLOW_ZERO_PTR));

2445

2444

current_db= NULL;

2446

2445

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

2447

2446

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

2498

2497

2499

2498

static int com_server_help(string *buffer,

2500

2499

const char *line __attribute__((unused)),

2501

const char *help_arg)

2500

char *help_arg)

2502

2501

{

2503

2502

DRIZZLE_ROW cur;

2504

2503

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

2505

string cmd_buf;

2504

char cmd_buf[100];

2506

2505

DRIZZLE_RES *result;

2507

2506

int error;

2508

2507

2509

cmd_buf.reserve(100);

2510

2508

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

2511

2509

{

2512

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

2510

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

2513

2511

if(--end_arg)

2514

2512

{

2515

2513

while (my_isspace(charset_info,*end_arg))

2516

2514

end_arg--;

2515

*++end_arg= '\0';

2517

2516

}

2518

cmd_buf.append("help '");

2519

cmd_buf.append(help_arg, end_arg-help_arg);

2520

cmd_buf.append("'");

2521

2522

server_cmd= cmd_buf.c_str();

2517

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

2518

server_cmd= cmd_buf;

2523

2519

}

2524

2520

2525

2521

if (!connected && reconnect())

2595

2591

const char *line __attribute__((unused)))

2596

2592

{

2597

2593

2598

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

2599

char buff[32], *end;

2594

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

2600

2595

if (help_arg)

2601

2596

{

2602

2597

while (my_isspace(charset_info,*help_arg))

2609

2604

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

2610

2605

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

2611

2606

{

2612

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

2607

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

2613

2608

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

2614

end= my_stpcpy(end, " ");

2609

end= stpcpy(end, " ");

2615

2610

if (commands[i].func)

2616

2611

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

2617

2612

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

2724

2719

{

2725

2720

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

2726

2721

{

2727

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

2722

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

2728

2723

}

2729

2724

else

2730

2725

{

2746

2741

}

2747

2742

}

2748

2743

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

2749

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

2744

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

2750

2745

else

2751

2746

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

2752

2747

"Query OK, %ld rows affected",

2759

2754

*pos++= ',';

2760

2755

*pos++= ' ';

2761

2756

pos=int10_to_str(warnings, pos, 10);

2762

pos=my_stpcpy(pos, " warning");

2757

pos=stpcpy(pos, " warning");

2763

2758

if (warnings != 1)

2764

2759

*pos++= 's';

2765

2760

}

2766

my_stpcpy(pos, time_buff);

2761

stpcpy(pos, time_buff);

2767

2762

put_info(buff,INFO_RESULT,0,0);

2768

2763

if (drizzle_info(&drizzle))

2769

2764

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

2865

2860

case DRIZZLE_TYPE_LONG: return "LONG";

2866

2861

case DRIZZLE_TYPE_LONGLONG: return "LONGLONG";

2867

2862

case DRIZZLE_TYPE_NULL: return "NULL";

2863

case DRIZZLE_TYPE_SHORT: return "SHORT";

2868

2864

case DRIZZLE_TYPE_TIME: return "TIME";

2869

2865

case DRIZZLE_TYPE_TIMESTAMP: return "TIMESTAMP";

2870

2866

case DRIZZLE_TYPE_TINY: return "TINY";

2871

case DRIZZLE_TYPE_VIRTUAL: return "VIRTUAL";

2872

2867

default: return "?-unknown-?";

2873

2868

}

2874

2869

}

2878

2873

char *s=buf;

2879

2874

*s=0;

2880

2875

#define ff2s_check_flag(X) \

2881

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

2876

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

2882

2877

ff2s_check_flag(NOT_NULL);

2883

2878

ff2s_check_flag(PRI_KEY);

2884

2879

ff2s_check_flag(UNIQUE_KEY);

3047

3042

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

3048

3043

}

3049

3044

tee_puts(separator.c_str(), PAGER);

3050

free(num_flag);

3045

my_free(num_flag, MYF(MY_ALLOW_ZERO_PTR));

3051

3046

}

3052

3047

3053

3048

/**

3285

3280

static int

3286

3281

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

3287

3282

{

3288

char file_name[FN_REFLEN], *end;

3289

const char *param;

3283

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

3290

3284

3291

3285

if (status.batch)

3292

3286

return 0;

3345

3339

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

3346

3340

const char *line __attribute__((unused)))

3347

3341

{

3348

char pager_name[FN_REFLEN], *end;

3349

const char *param;

3342

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

3350

3343

3351

3344

if (status.batch)

3352

3345

return 0;

3364

3357

{

3365

3358

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

3366

3359

opt_nopager=1;

3367

my_stpcpy(pager, "stdout");

3360

stpcpy(pager, "stdout");

3368

3361

PAGER= stdout;

3369

3362

return 0;

3370

3363

}

3371

my_stpcpy(pager, default_pager);

3364

stpcpy(pager, default_pager);

3372

3365

}

3373

3366

else

3374

3367

{

3377

3370

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

3378

3371

end--;

3379

3372

end[0]=0;

3380

my_stpcpy(pager, pager_name);

3381

my_stpcpy(default_pager, pager_name);

3373

stpcpy(pager, pager_name);

3374

stpcpy(default_pager, pager_name);

3382

3375

}

3383

3376

opt_nopager=0;

3384

3377

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

3390

3383

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

3391

3384

const char *line __attribute__((unused)))

3392

3385

{

3393

my_stpcpy(pager, "stdout");

3386

stpcpy(pager, "stdout");

3394

3387

opt_nopager=1;

3395

3388

PAGER= stdout;

3396

3389

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

3453

3446

tmp= get_arg(buff, 0);

3454

3447

if (tmp && *tmp)

3455

3448

{

3456

free(current_db);

3449

my_free(current_db, MYF(MY_ALLOW_ZERO_PTR));

3457

3450

current_db= strdup(tmp);

3458

3451

tmp= get_arg(buff, 1);

3459

3452

if (tmp)

3460

3453

{

3461

free(current_host);

3454

my_free(current_host,MYF(MY_ALLOW_ZERO_PTR));

3462

3455

current_host=strdup(tmp);

3463

3456

}

3464

3457

}

3490

3483

3491

3484

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

3492

3485

{

3493

char source_name[FN_REFLEN], *end;

3494

const char *param;

3486

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

3495

3487

LINE_BUFFER *line_buff;

3496

3488

int error;

3497

3489

STATUS old_status;

3512

3504

end[0]=0;

3513

3505

unpack_filename(source_name,source_name);

3514

3506

/* open file name */

3515

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

3507

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

3516

3508

{

3517

3509

char buff[FN_REFLEN+60];

3518

3510

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

3638

3630

if (drizzle_select_db(&drizzle,tmp))

3639

3631

return put_error(&drizzle);

3640

3632

}

3641

free(current_db);

3633

my_free(current_db,MYF(MY_ALLOW_ZERO_PTR));

3642

3634

current_db= strdup(tmp);

3643

3635

if (select_db > 1)

3644

3636

build_completion_hash(opt_rehash, 1);

3701

3693

ptr++;

3702

3694

}

3703

3695

if (!*ptr)

3704

return NULL;

3696

return NullS;

3705

3697

while (my_isspace(charset_info, *ptr))

3706

3698

ptr++;

3707

3699

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

3715

3707

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

3716

3708

{

3717

3709

// Remove the backslash

3718

my_stpcpy(ptr, ptr+1);

3710

stpcpy(ptr, ptr+1);

3719

3711

}

3720

3712

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

3721

3713

{

3724

3716

}

3725

3717

}

3726

3718

valid_arg= ptr != start;

3727

return valid_arg ? start : NULL;

3719

return valid_arg ? start : NullS;

3728

3720

}

3729

3721

3730

3722

3745

3737

(char*) &timeout);

3746

3738

}

3747

3739

if (opt_compress)

3748

drizzle_options(&drizzle,DRIZZLE_OPT_COMPRESS,NULL);

3740

drizzle_options(&drizzle,DRIZZLE_OPT_COMPRESS,NullS);

3749

3741

if (opt_secure_auth)

3750

3742

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

3751

3743

if (using_opt_local_infile)

3873

3865

static const char *

3874

3866

server_version_string(DRIZZLE *con)

3875

3867

{

3876

static string buf("");

3877

static bool server_version_string_reserved= false;

3868

static char buf[MAX_SERVER_VERSION_LENGTH] = "";

3878

3869

3879

if (!server_version_string_reserved)

3880

{

3881

buf.reserve(MAX_SERVER_VERSION_LENGTH);

3882

server_version_string_reserved= true;

3883

}

3884

3870

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

3885

3871

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

3886

3872

{

3873

char *bufp = buf;

3887

3874

DRIZZLE_RES *result;

3888

3875

3889

buf.append(drizzle_get_server_info(con));

3876

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

3890

3877

3891

3878

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

3892

3879

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

3895

3882

DRIZZLE_ROW cur = drizzle_fetch_row(result);

3896

3883

if (cur && cur[0])

3897

3884

{

3898

buf.append(" ");

3899

buf.append(cur[0]);

3885

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

3900

3886

}

3901

3887

drizzle_free_result(result);

3902

3888

}

3889

3890

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

3891

if (bufp == buf + sizeof buf)

3892

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

3903

3893

}

3904

3894

3905

return buf.c_str();

3895

return buf;

3906

3896

}

3907

3897

3908

3898

static int

4067

4057

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

4068

4058

sec-=3600.0*24*tmp;

4069

4059

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

4070

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

4060

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

4071

4061

}

4072

4062

if (sec >= 3600.0)

4073

4063

{

4074

4064

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

4075

4065

sec-=3600.0*tmp;

4076

4066

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

4077

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

4067

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

4078

4068

}

4079

4069

if (sec >= 60.0)

4080

4070

{

4081

4071

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

4082

4072

sec-=60.0*tmp;

4083

4073

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

4084

buff=my_stpcpy(buff," min ");

4074

buff=stpcpy(buff," min ");

4085

4075

}

4086

4076

if (part_second)

4087

4077

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

4102

4092

buff[0]=' ';

4103

4093

buff[1]='(';

4104

4094

end_timer(start_time,buff+2);

4105

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

4095

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

4106

4096

}

4107

4097

4108

4098

static const char * construct_prompt()

4293

4283

4294

4284

static void init_username()

4295

4285

{

4296

free(full_username);

4297

free(part_username);

4286

my_free(full_username,MYF(MY_ALLOW_ZERO_PTR));

4287

my_free(part_username,MYF(MY_ALLOW_ZERO_PTR));

4298

4288

4299

4289

DRIZZLE_RES *result;

4300

4290

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

4310

4300

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

4311

4301

const char *line)

4312

4302

{

4313

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

4303

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

4314

4304

prompt_counter = 0;

4315

free(current_prompt);

4305

my_free(current_prompt, MYF(MY_ALLOW_ZERO_PTR));

4316

4306

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

4317

4307

if (!ptr)

4318

4308

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

4324

4314

4325

4315

4326

4316

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

4327

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

4317

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

4328

4318

if there isn't anything found.

4329

4319

4330

4320

Older »