~drizzle-trunk/drizzle/development : revision 840.1.21

217

218

static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;

219

220

int drizzle_real_query_for_lazy(const char *buf, int length);

221

int drizzle_store_result_for_lazy(DRIZZLE_RES **result);

220

int drizzleclient_real_query_for_lazy(const char *buf, int length);

221

int drizzleclient_store_result_for_lazy(DRIZZLE_RES **result);

222

223

224

void tee_fprintf(FILE *file, const char *fmt, ...);

1156

1157

sprintf(output_buff,

1158

_("Your Drizzle connection id is %u\nServer version: %s\n"),

1159

drizzle_thread_id(&drizzle),

1159

drizzleclient_thread_id(&drizzle),

1160

server_version_string(&drizzle));

1161

put_info(output_buff, INFO_INFO, 0, 0);

1162

1207

1208

void drizzle_end(int sig)

1209

{

1210

drizzle_close(&drizzle);

1210

drizzleclient_close(&drizzle);

1211

if (!status.batch && !quick && histfile)

1212

{

1213

/* write-history */

1259

goto err;

1260

}

1261

1262

kill_drizzle= drizzle_create(kill_drizzle);

1263

if (!drizzle_connect(kill_drizzle,current_host, current_user, opt_password,

1262

kill_drizzle= drizzleclient_create(kill_drizzle);

1263

if (!drizzleclient_connect(kill_drizzle,current_host, current_user, opt_password,

1264

"", opt_drizzle_port, opt_drizzle_unix_port,0))

1265

{

1266

goto err;

1267

}

1268

1269

/* kill_buffer is always big enough because max length of %lu is 15 */

1270

sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u", drizzle_thread_id(&drizzle));

1271

drizzle_real_query(kill_drizzle, kill_buffer, strlen(kill_buffer));

1272

drizzle_close(kill_drizzle);

1270

sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u", drizzleclient_thread_id(&drizzle));

1271

drizzleclient_real_query(kill_drizzle, kill_buffer, strlen(kill_buffer));

1272

drizzleclient_close(kill_drizzle);

1273

tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));

1274

1275

interrupted_query= 1;

1471

const char* readline= "readline";

1472

1473

printf(_("%s Ver %s Distrib %s, for %s (%s) using %s %s\n"),

1474

my_progname, VER, drizzle_get_client_info(),

1474

my_progname, VER, drizzleclient_get_client_info(),

1475

SYSTEM_TYPE, MACHINE_TYPE,

1476

readline, rl_library_version);

1477

1668

{

1669

char *tmp, *pagpoint;

1670

int ho_error;

1671

const DRIZZLE_PARAMETERS *drizzle_params= drizzle_get_parameters();

1671

const DRIZZLE_PARAMETERS *drizzle_params= drizzleclient_get_parameters();

1672

1673

tmp= (char *) getenv("DRIZZLE_HOST");

1674

if (tmp)

2369

/* hash Drizzle functions (to be implemented) */

2370

2371

/* hash all database names */

2372

if (drizzle_query(&drizzle,"show databases") == 0)

2372

if (drizzleclient_query(&drizzle,"show databases") == 0)

2373

{

2374

if (!(databases = drizzle_store_result(&drizzle)))

2375

put_info(drizzle_error(&drizzle),INFO_INFO,0,0);

2374

if (!(databases = drizzleclient_store_result(&drizzle)))

2375

put_info(drizzleclient_error(&drizzle),INFO_INFO,0,0);

2376

else

2377

{

2378

while ((database_row=drizzle_fetch_row(databases)))

2378

while ((database_row=drizzleclient_fetch_row(databases)))

2379

{

2380

char *str=strdup_root(&hash_mem_root, (char*) database_row[0]);

2381

if (str)

2382

add_word(&ht,(char*) str);

2383

}

2384

drizzle_free_result(databases);

2384

drizzleclient_free_result(databases);

2385

}

2386

}

2387

/* hash all table names */

2388

if (drizzle_query(&drizzle,"show tables")==0)

2388

if (drizzleclient_query(&drizzle,"show tables")==0)

2389

{

2390

if (!(tables = drizzle_store_result(&drizzle)))

2391

put_info(drizzle_error(&drizzle),INFO_INFO,0,0);

2390

if (!(tables = drizzleclient_store_result(&drizzle)))

2391

put_info(drizzleclient_error(&drizzle),INFO_INFO,0,0);

2392

else

2393

{

2394

if (drizzle_num_rows(tables) > 0 && !opt_silent && write_info)

2394

if (drizzleclient_num_rows(tables) > 0 && !opt_silent && write_info)

2395

{

2396

tee_fprintf(stdout, _("\

2397

Reading table information for completion of table and column names\n \

2398

You can turn off this feature to get a quicker startup with -A\n\n"));

2399

}

2400

while ((table_row=drizzle_fetch_row(tables)))

2400

while ((table_row=drizzleclient_fetch_row(tables)))

2401

{

2402

char *str=strdup_root(&hash_mem_root, (char*) table_row[0]);

2403

if (str &&

2412

{

2413

return;

2414

}

2415

drizzle_data_seek(tables,0);

2415

drizzleclient_data_seek(tables,0);

2416

if (!(field_names= (char ***) alloc_root(&hash_mem_root,sizeof(char **) *

2417

(uint) (drizzle_num_rows(tables)+1))))

2417

(uint) (drizzleclient_num_rows(tables)+1))))

2418

{

2419

drizzle_free_result(tables);

2419

drizzleclient_free_result(tables);

2420

return;

2421

}

2422

i=0;

2423

while ((table_row=drizzle_fetch_row(tables)))

2423

while ((table_row=drizzleclient_fetch_row(tables)))

2424

{

2425

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

2425

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

2426

{

2427

num_fields=drizzle_num_fields(fields);

2427

num_fields=drizzleclient_num_fields(fields);

2428

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

2429

sizeof(char *) *

2430

(num_fields*2+1))))

2431

{

2432

drizzle_free_result(fields);

2432

drizzleclient_free_result(fields);

2433

break;

2434

}

2435

field_names[i][num_fields*2]= '\0';

2436

j=0;

2437

while ((sql_field=drizzle_fetch_field(fields)))

2437

while ((sql_field=drizzleclient_fetch_field(fields)))

2438

{

2439

sprintf(buf,"%.64s.%.64s",table_row[0],sql_field->name);

2440

field_names[i][j] = strdup_root(&hash_mem_root,buf);

2446

add_word(&ht,field_names[i][num_fields+j]);

2447

j++;

2448

}

2449

drizzle_free_result(fields);

2449

drizzleclient_free_result(fields);

2450

}

2451

else

2452

field_names[i]= 0;

2453

2454

i++;

2455

}

2456

drizzle_free_result(tables);

2456

drizzleclient_free_result(tables);

2457

field_names[i]=0; // End pointer

2458

return;

2459

}

2508

free(current_db);

2509

current_db= NULL;

2510

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

2511

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

2512

(res= drizzle_use_result(&drizzle)))

2511

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

2512

(res= drizzleclient_use_result(&drizzle)))

2513

{

2514

DRIZZLE_ROW row= drizzle_fetch_row(res);

2514

DRIZZLE_ROW row= drizzleclient_fetch_row(res);

2515

if (row[0])

2516

current_db= strdup(row[0]);

2517

drizzle_free_result(res);

2517

drizzleclient_free_result(res);

2518

}

2519

}

2520

2522

The different commands

2523

***************************************************************************/

2524

2525

int drizzle_real_query_for_lazy(const char *buf, int length)

2525

int drizzleclient_real_query_for_lazy(const char *buf, int length)

2526

{

2527

for (uint retry=0;; retry++)

2528

{

2529

int error;

2530

if (!drizzle_real_query(&drizzle,buf,length))

2530

if (!drizzleclient_real_query(&drizzle,buf,length))

2531

return 0;

2532

error= put_error(&drizzle);

2533

if (drizzle_errno(&drizzle) != CR_SERVER_GONE_ERROR || retry > 1 ||

2533

if (drizzleclient_errno(&drizzle) != CR_SERVER_GONE_ERROR || retry > 1 ||

2534

!opt_reconnect)

2535

return error;

2536

if (reconnect())

2538

}

2539

}

2540

2541

int drizzle_store_result_for_lazy(DRIZZLE_RES **result)

2541

int drizzleclient_store_result_for_lazy(DRIZZLE_RES **result)

2542

{

2543

if ((*result=drizzle_store_result(&drizzle)))

2543

if ((*result=drizzleclient_store_result(&drizzle)))

2544

return 0;

2545

2546

if (drizzle_error(&drizzle)[0])

2546

if (drizzleclient_error(&drizzle)[0])

2547

return put_error(&drizzle);

2548

return 0;

2549

}

2630

2631

timer=start_timer();

2632

executing_query= 1;

2633

error= drizzle_real_query_for_lazy(buffer->c_str(),buffer->length());

2633

error= drizzleclient_real_query_for_lazy(buffer->c_str(),buffer->length());

2634

2635

if (status.add_to_history)

2636

{

2650

2651

if (quick)

2652

{

2653

if (!(result=drizzle_use_result(&drizzle)) && drizzle_field_count(&drizzle))

2653

if (!(result=drizzleclient_use_result(&drizzle)) && drizzleclient_field_count(&drizzle))

2654

{

2655

error= put_error(&drizzle);

2656

goto end;

2658

}

2659

else

2660

{

2661

error= drizzle_store_result_for_lazy(&result);

2661

error= drizzleclient_store_result_for_lazy(&result);

2662

if (error)

2663

goto end;

2664

}

2671

/* Every branch must truncate buff . */

2672

if (result)

2673

{

2674

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

2674

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

2675

{

2676

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

2677

}

2687

print_table_data(result);

2688

sprintf(buff,

2689

ngettext("%ld row in set","%ld rows in set",

2690

(long) drizzle_num_rows(result)),

2691

(long) drizzle_num_rows(result));

2690

(long) drizzleclient_num_rows(result)),

2691

(long) drizzleclient_num_rows(result));

2692

end_pager();

2693

if (drizzle_errno(&drizzle))

2693

if (drizzleclient_errno(&drizzle))

2694

error= put_error(&drizzle);

2695

}

2696

}

2697

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

2697

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

2698

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

2699

else

2700

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

2701

"Query OK, %ld rows affected",

2702

(long) drizzle_affected_rows(&drizzle)),

2703

(long) drizzle_affected_rows(&drizzle));

2702

(long) drizzleclient_affected_rows(&drizzle)),

2703

(long) drizzleclient_affected_rows(&drizzle));

2704

2705

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

2706

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

2706

if ((warnings= drizzleclient_warning_count(&drizzle)))

2707

{

2708

*pos++= ',';

2709

*pos++= ' ';

2714

}

2715

strcpy(pos, time_buff);

2716

put_info(buff,INFO_RESULT,0,0);

2717

if (drizzle_info(&drizzle))

2718

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

2717

if (drizzleclient_info(&drizzle))

2718

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

2719

put_info("",INFO_RESULT,0,0); // Empty row

2720

2721

if (result && !drizzle_eof(result)) /* Something wrong when using quick */

2721

if (result && !drizzleclient_eof(result)) /* Something wrong when using quick */

2722

error= put_error(&drizzle);

2723

else if (unbuffered)

2724

fflush(stdout);

2725

drizzle_free_result(result);

2726

} while (!(err= drizzle_next_result(&drizzle)));

2725

drizzleclient_free_result(result);

2726

} while (!(err= drizzleclient_next_result(&drizzle)));

2727

if (err >= 1)

2728

error= put_error(&drizzle);

2729

2859

DRIZZLE_FIELD *field;

2860

uint i=0;

2861

2862

while ((field = drizzle_fetch_field(result)))

2862

while ((field = drizzleclient_fetch_field(result)))

2863

{

2864

tee_fprintf(PAGER, "Field %3u: `%s`\n"

2865

"Catalog: `%s`\n"

2893

2894

separator.reserve(256);

2895

2896

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

2896

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

2897

if (column_types_flag)

2898

{

2899

print_field_types(result);

2900

if (!drizzle_num_rows(result))

2900

if (!drizzleclient_num_rows(result))

2901

return;

2902

drizzle_field_seek(result,0);

2902

drizzleclient_field_seek(result,0);

2903

}

2904

separator.append("+");

2905

while ((field = drizzle_fetch_field(result)))

2905

while ((field = drizzleclient_fetch_field(result)))

2906

{

2907

uint32_t x, length= 0;

2908

2943

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

2944

if (column_names)

2945

{

2946

drizzle_field_seek(result,0);

2946

drizzleclient_field_seek(result,0);

2947

(void) tee_fputs("|", PAGER);

2948

for (uint off=0; (field = drizzle_fetch_field(result)) ; off++)

2948

for (uint off=0; (field = drizzleclient_fetch_field(result)) ; off++)

2949

{

2950

uint name_length= (uint) strlen(field->name);

2951

uint numcells= charset_info->cset->numcells(charset_info,

2962

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

2963

}

2964

2965

while ((cur= drizzle_fetch_row(result)))

2965

while ((cur= drizzleclient_fetch_row(result)))

2966

{

2967

if (interrupted_query)

2968

break;

2969

uint32_t *lengths= drizzle_fetch_lengths(result);

2969

uint32_t *lengths= drizzleclient_fetch_lengths(result);

2970

(void) tee_fputs("| ", PAGER);

2971

drizzle_field_seek(result, 0);

2972

for (uint off= 0; off < drizzle_num_fields(result); off++)

2971

drizzleclient_field_seek(result, 0);

2972

for (uint off= 0; off < drizzleclient_num_fields(result); off++)

2973

{

2974

const char *buffer;

2975

uint data_length;

2988

data_length= (uint) lengths[off];

2989

}

2990

2991

field= drizzle_fetch_field(result);

2991

field= drizzleclient_fetch_field(result);

2992

field_max_length= field->max_length;

2993

2994

/*

3065

DRIZZLE_FIELD *field;

3066

DRIZZLE_FIELD_OFFSET offset;

3067

3068

offset= drizzle_field_tell(result);

3068

offset= drizzleclient_field_tell(result);

3069

assert(offset == 0);

3070

3071

while ((field= drizzle_fetch_field(result)) != NULL)

3071

while ((field= drizzleclient_fetch_field(result)) != NULL)

3072

len+= get_field_disp_length(field) + 3; /* plus bar, space, & final space */

3073

3074

(void) drizzle_field_seek(result, offset);

3074

(void) drizzleclient_field_seek(result, offset);

3075

3076

return len + 1; /* plus final bar. */

3077

}

3113

uint max_length=0;

3114

DRIZZLE_FIELD *field;

3115

3116

while ((field = drizzle_fetch_field(result)))

3116

while ((field = drizzleclient_fetch_field(result)))

3117

{

3118

uint length= field->name_length;

3119

if (length > max_length)

3121

field->max_length=length;

3122

}

3123

3124

drizzle_field_seek(result,0);

3125

for (uint row_count=1; (cur= drizzle_fetch_row(result)); row_count++)

3124

drizzleclient_field_seek(result,0);

3125

for (uint row_count=1; (cur= drizzleclient_fetch_row(result)); row_count++)

3126

{

3127

if (interrupted_query)

3128

break;

3129

drizzle_field_seek(result,0);

3129

drizzleclient_field_seek(result,0);

3130

tee_fprintf(PAGER,

3131

"*************************** %d. row ***************************\n", row_count);

3132

for (uint off=0; off < drizzle_num_fields(result); off++)

3132

for (uint off=0; off < drizzleclient_num_fields(result); off++)

3133

{

3134

field= drizzle_fetch_field(result);

3134

field= drizzleclient_fetch_field(result);

3135

tee_fprintf(PAGER, "%*s: ",(int) max_length,field->name);

3136

tee_fprintf(PAGER, "%s\n",cur[off] ? (char*) cur[off] : "NULL");

3137

}

3149

uint64_t num_rows;

3150

3151

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

3152

uint error= drizzle_errno(&drizzle);

3152

uint error= drizzleclient_errno(&drizzle);

3153

3154

/* Get the warnings */

3155

query= "show warnings";

3156

drizzle_real_query_for_lazy(query, strlen(query));

3157

drizzle_store_result_for_lazy(&result);

3156

drizzleclient_real_query_for_lazy(query, strlen(query));

3157

drizzleclient_store_result_for_lazy(&result);

3158

3159

/* Bail out when no warnings */

3160

if (!(num_rows= drizzle_num_rows(result)))

3160

if (!(num_rows= drizzleclient_num_rows(result)))

3161

goto end;

3162

3163

cur= drizzle_fetch_row(result);

3163

cur= drizzleclient_fetch_row(result);

3164

3165

/*

3166

Don't print a duplicate of the current error. It is possible for SHOW

3176

do

3177

{

3178

tee_fprintf(PAGER, "%s (Code %s): %s\n", cur[0], cur[1], cur[2]);

3179

} while ((cur= drizzle_fetch_row(result)));

3179

} while ((cur= drizzleclient_fetch_row(result)));

3180

end_pager();

3181

3182

end:

3183

drizzle_free_result(result);

3183

drizzleclient_free_result(result);

3184

}

3185

3186

3231

if (opt_silent < 2 && column_names)

3232

{

3233

int first=0;

3234

while ((field = drizzle_fetch_field(result)))

3234

while ((field = drizzleclient_fetch_field(result)))

3235

{

3236

if (first++)

3237

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

3239

}

3240

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

3241

}

3242

while ((cur = drizzle_fetch_row(result)))

3242

while ((cur = drizzleclient_fetch_row(result)))

3243

{

3244

lengths= drizzle_fetch_lengths(result);

3244

lengths= drizzleclient_fetch_lengths(result);

3245

safe_put_field(cur[0],lengths[0]);

3246

for (uint off=1 ; off < drizzle_num_fields(result); off++)

3246

for (uint off=1 ; off < drizzleclient_num_fields(result); off++)

3247

{

3248

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

3249

safe_put_field(cur[off], lengths[off]);

3445

3446

if (connected)

3447

{

3448

sprintf(buff,"Connection id: %u",drizzle_thread_id(&drizzle));

3448

sprintf(buff,"Connection id: %u",drizzleclient_thread_id(&drizzle));

3449

put_info(buff,INFO_INFO,0,0);

3450

sprintf(buff,"Current database: %.128s\n",

3451

current_db ? current_db : "*** NONE ***");

3570

if (one_database)

3571

{

3572

skip_updates= 1;

3573

select_db= 0; // don't do drizzle_select_db()

3573

select_db= 0; // don't do drizzleclient_select_db()

3574

}

3575

else

3576

select_db= 2; // do drizzle_select_db() and build_completion_hash()

3576

select_db= 2; // do drizzleclient_select_db() and build_completion_hash()

3577

}

3578

else

3579

{

3580

/*

3581

USE to the current db specified.

3582

We do need to send drizzle_select_db() to make server

3582

We do need to send drizzleclient_select_db() to make server

3583

update database level privileges, which might

3584

change since last USE (see bug#10979).

3585

For performance purposes, we'll skip rebuilding of completion hash.

3586

*/

3587

skip_updates= 0;

3588

select_db= 1; // do only drizzle_select_db(), without completion

3588

select_db= 1; // do only drizzleclient_select_db(), without completion

3589

}

3590

3591

if (select_db)

3596

*/

3597

if (!connected && reconnect())

3598

return opt_reconnect ? -1 : 1; // Fatal error

3599

if (drizzle_select_db(&drizzle,tmp))

3599

if (drizzleclient_select_db(&drizzle,tmp))

3600

{

3601

if (drizzle_errno(&drizzle) != CR_SERVER_GONE_ERROR)

3601

if (drizzleclient_errno(&drizzle) != CR_SERVER_GONE_ERROR)

3602

return put_error(&drizzle);

3603

3604

if (reconnect())

3605

return opt_reconnect ? -1 : 1; // Fatal error

3606

if (drizzle_select_db(&drizzle,tmp))

3606

if (drizzleclient_select_db(&drizzle,tmp))

3607

return put_error(&drizzle);

3608

}

3609

free(current_db);

3701

if (connected)

3702

{

3703

connected= 0;

3704

drizzle_close(&drizzle);

3704

drizzleclient_close(&drizzle);

3705

}

3706

drizzle_create(&drizzle);

3706

drizzleclient_create(&drizzle);

3707

if (opt_connect_timeout)

3708

{

3709

uint timeout=opt_connect_timeout;

3710

drizzle_options(&drizzle,DRIZZLE_OPT_CONNECT_TIMEOUT,

3710

drizzleclient_options(&drizzle,DRIZZLE_OPT_CONNECT_TIMEOUT,

3711

(char*) &timeout);

3712

}

3713

if (opt_compress)

3714

drizzle_options(&drizzle,DRIZZLE_OPT_COMPRESS,NULL);

3714

drizzleclient_options(&drizzle,DRIZZLE_OPT_COMPRESS,NULL);

3715

if (opt_secure_auth)

3716

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

3716

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

3717

if (using_opt_local_infile)

3718

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

3718

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

3719

if (safe_updates)

3720

{

3721

char init_command[100];

3723

"SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%"PRIu32

3724

",MAX_JOIN_SIZE=%"PRIu32,

3725

select_limit, max_join_size);

3726

drizzle_options(&drizzle, DRIZZLE_INIT_COMMAND, init_command);

3726

drizzleclient_options(&drizzle, DRIZZLE_INIT_COMMAND, init_command);

3727

}

3728

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

3728

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

3729

database, opt_drizzle_port, opt_drizzle_unix_port,

3730

connect_flag | CLIENT_MULTI_STATEMENTS))

3731

{

3732

if (!silent ||

3733

(drizzle_errno(&drizzle) != CR_CONN_HOST_ERROR &&

3734

drizzle_errno(&drizzle) != CR_CONNECTION_ERROR))

3733

(drizzleclient_errno(&drizzle) != CR_CONN_HOST_ERROR &&

3734

drizzleclient_errno(&drizzle) != CR_CONNECTION_ERROR))

3735

{

3736

(void) put_error(&drizzle);

3737

(void) fflush(stdout);

3757

usage(1); /* Print version */

3758

if (connected)

3759

{

3760

tee_fprintf(stdout, "\nConnection id:\t\t%lu\n",drizzle_thread_id(&drizzle));

3760

tee_fprintf(stdout, "\nConnection id:\t\t%lu\n",drizzleclient_thread_id(&drizzle));

3761

/*

3762

Don't remove "limit 1",

3763

it is protection againts SQL_SELECT_LIMIT=0

3764

*/

3765

if (!drizzle_query(&drizzle,"select DATABASE(), USER() limit 1") &&

3766

(result=drizzle_use_result(&drizzle)))

3765

if (!drizzleclient_query(&drizzle,"select DATABASE(), USER() limit 1") &&

3766

(result=drizzleclient_use_result(&drizzle)))

3767

{

3768

DRIZZLE_ROW cur=drizzle_fetch_row(result);

3768

DRIZZLE_ROW cur=drizzleclient_fetch_row(result);

3769

if (cur)

3770

{

3771

tee_fprintf(stdout, "Current database:\t%s\n", cur[0] ? cur[0] : "");

3772

tee_fprintf(stdout, "Current user:\t\t%s\n", cur[1]);

3773

}

3774

drizzle_free_result(result);

3774

drizzleclient_free_result(result);

3775

}

3776

tee_puts("SSL:\t\t\tNot in use", stdout);

3777

}

3792

tee_fprintf(stdout, "Using outfile:\t\t'%s'\n", opt_outfile ? outfile : "");

3793

tee_fprintf(stdout, "Using delimiter:\t%s\n", delimiter);

3794

tee_fprintf(stdout, "Server version:\t\t%s\n", server_version_string(&drizzle));

3795

tee_fprintf(stdout, "Protocol version:\t%d\n", drizzle_get_proto_info(&drizzle));

3796

tee_fprintf(stdout, "Connection:\t\t%s\n", drizzle_get_host_info(&drizzle));

3797

if ((id= drizzle_insert_id(&drizzle)))

3795

tee_fprintf(stdout, "Protocol version:\t%d\n", drizzleclient_get_proto_info(&drizzle));

3796

tee_fprintf(stdout, "Connection:\t\t%s\n", drizzleclient_get_host_info(&drizzle));

3797

if ((id= drizzleclient_insert_id(&drizzle)))

3798

tee_fprintf(stdout, "Insert id:\t\t%s\n", llstr(id, buff));

3799

3800

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

3801

if (!drizzle_query(&drizzle,"select @@character_set_client, @@character_set_connection, @@character_set_server, @@character_set_database limit 1") &&

3802

(result=drizzle_use_result(&drizzle)))

3801

if (!drizzleclient_query(&drizzle,"select @@character_set_client, @@character_set_connection, @@character_set_server, @@character_set_database limit 1") &&

3802

(result=drizzleclient_use_result(&drizzle)))

3803

{

3804

DRIZZLE_ROW cur=drizzle_fetch_row(result);

3804

DRIZZLE_ROW cur=drizzleclient_fetch_row(result);

3805

if (cur)

3806

{

3807

tee_fprintf(stdout, "Server characterset:\t%s\n", cur[2] ? cur[2] : "");

3809

tee_fprintf(stdout, "Client characterset:\t%s\n", cur[0] ? cur[0] : "");

3810

tee_fprintf(stdout, "Conn. characterset:\t%s\n", cur[1] ? cur[1] : "");

3811

}

3812

drizzle_free_result(result);

3812

drizzleclient_free_result(result);

3813

}

3814

3815

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

3815

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

3816

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

3817

else

3818

tee_fprintf(stdout, "UNIX socket:\t\t%s\n", drizzle.unix_socket);

3851

{

3852

DRIZZLE_RES *result;

3853

3854

buf.append(drizzle_get_server_info(con));

3854

buf.append(drizzleclient_get_server_info(con));

3855

3856

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

3857

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

3858

(result = drizzle_use_result(con)))

3857

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

3858

(result = drizzleclient_use_result(con)))

3859

{

3860

DRIZZLE_ROW cur = drizzle_fetch_row(result);

3860

DRIZZLE_ROW cur = drizzleclient_fetch_row(result);

3861

if (cur && cur[0])

3862

{

3863

buf.append(" ");

3864

buf.append(cur[0]);

3865

}

3866

drizzle_free_result(result);

3866

drizzleclient_free_result(result);

3867

}

3868

}

3869

3945

static int

3946

put_error(DRIZZLE *con)

3947

{

3948

return put_info(drizzle_error(con), INFO_ERROR, drizzle_errno(con),

3949

drizzle_sqlstate(con));

3948

return put_info(drizzleclient_error(con), INFO_ERROR, drizzleclient_errno(con),

3949

drizzleclient_sqlstate(con));

3950

}

3951

3952

4111

break;

4112

case 'v':

4113

if (connected)

4114

processed_prompt->append(drizzle_get_server_info(&drizzle));

4114

processed_prompt->append(drizzleclient_get_server_info(&drizzle));

4115

else

4116

processed_prompt->append("not_connected");

4117

break;

4121

case 'h':

4122

{

4123

const char *prompt;

4124

prompt= connected ? drizzle_get_host_info(&drizzle) : "not_connected";

4124

prompt= connected ? drizzleclient_get_host_info(&drizzle) : "not_connected";

4125

if (strstr(prompt, "Localhost"))

4126

processed_prompt->append("localhost");

4127

else

4140

break;

4141

}

4142

4143

const char *host_info = drizzle_get_host_info(&drizzle);

4143

const char *host_info = drizzleclient_get_host_info(&drizzle);

4144

if (strstr(host_info, "memory"))

4145

{

4146

processed_prompt->append(drizzle.host);

4268

free(part_username);

4269

4270

DRIZZLE_RES *result;

4271

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

4272

(result=drizzle_use_result(&drizzle)))

4271

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

4272

(result=drizzleclient_use_result(&drizzle)))

4273

{

4274

DRIZZLE_ROW cur=drizzle_fetch_row(result);

4274

DRIZZLE_ROW cur=drizzleclient_fetch_row(result);

4275

full_username= strdup(cur[0]);

4276

part_username= strdup(strtok(cur[0],"@"));

4277

(void) drizzle_fetch_row(result); // Read eof

4277

(void) drizzleclient_fetch_row(result); // Read eof

4278

}

4279

}

4280