~drizzle-trunk/drizzle/development : revision 928.1.3

212

static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;

213

214

int drizzleclient_real_query_for_lazy(const char *buf, int length,

215

drizzle_result_st *result);

215

drizzle_result_st *result,

216

uint32_t *error_code);

216

217

int drizzleclient_store_result_for_lazy(drizzle_result_st **result);

217

218

219

1007

1008

static void print_table_data(drizzle_result_st *result);

1008

1009

static void print_tab_data(drizzle_result_st *result);

1009

1010

static void print_table_data_vertically(drizzle_result_st *result);

1010

static void print_warnings(void);

1011

static void print_warnings(uint32_t error_code);

1011

1012

static uint32_t start_timer(void);

1012

1013

static void end_timer(uint32_t start_time,char *buff);

1013

1014

static void drizzle_end_timer(uint32_t start_time,char *buff);

2462

2463

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

2463

2464

2465

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2465

drizzle_result_st *result)

2466

drizzle_result_st *result,

2467

uint32_t *error_code)

2466

2468

{

2467

2469

drizzle_return_t ret;

2468

2470

2475

2477

return 0;

2476

2478

}

2477

2479

error= put_error(&con, result);

2478

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

2480

2481

if (ret == DRIZZLE_RETURN_ERROR_CODE)

2482

{

2483

*error_code= drizzle_result_error_code(result);

2484

drizzle_result_free(result);

2485

}

2486

2487

if (ret != DRIZZLE_RETURN_SERVER_GONE || retry > 1 ||

2479

2488

!opt_reconnect)

2480

2489

{

2481

2490

return error;

2482

2491

}

2492

2483

2493

if (reconnect())

2484

2494

return error;

2485

2495

}

2541

2551

{

2542

2552

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

2543

2553

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

2544

drizzle_result_st result;

2545

uint32_t timer, warnings= 0;

2546

uint32_t error= 0;

2554

drizzle_result_st result;

2555

drizzle_return_t ret;

2556

uint32_t timer, warnings= 0;

2557

uint32_t error= 0;

2558

uint32_t error_code= 0;

2547

2559

int err= 0;

2548

2560

2549

2561

interrupted_query= 0;

2577

2589

2578

2590

timer=start_timer();

2579

2591

executing_query= 1;

2580

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

2592

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

2581

2593

2582

2594

if (status.add_to_history)

2583

2595

{

2597

2609

2598

2610

if (quick)

2599

2611

{

2600

/* look at old src to see what we should do here. buffer columns? */

2601

moo;

2602

if (drizzle_result_column_count(&result))

2612

if (drizzle_column_buffer(&result) != DRIZZLE_RETURN_OK)

2603

2613

{

2604

2614

error= put_error(&con, &result);

2605

2615

goto end;

2618

2628

time_buff[0]= '\0';

2619

2629

2620

2630

/* Every branch must truncate buff . */

2621

if (result)

2631

if (drizzle_result_column_count(&result) > 0)

2622

2632

{

2623

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

2633

if (!quick && drizzle_result_row_count(&result) == 0 &&

2634

!column_types_flag)

2624

2635

{

2625

2636

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

2626

2637

}

2628

2639

{

2629

2640

init_pager();

2630

2641

if (vertical || (auto_vertical_output &&

2631

(terminal_width < get_result_width(result))))

2632

print_table_data_vertically(result);

2642

(terminal_width < get_result_width(&result))))

2643

print_table_data_vertically(&result);

2633

2644

else if (opt_silent && verbose <= 2 && !output_tables)

2634

print_tab_data(result);

2645

print_tab_data(&result);

2635

2646

else

2636

print_table_data(result);

2647

print_table_data(&result);

2637

2648

sprintf(buff,

2638

2649

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

2639

(long) drizzleclient_num_rows(result)),

2640

(long) drizzleclient_num_rows(result));

2650

(long) drizzle_result_row_count(&result)),

2651

(long) drizzle_result_row_count(&result));

2641

2652

end_pager();

2642

if (drizzleclient_errno(&drizzle))

2643

error= put_error(&drizzle);

2653

if (drizzle_result_error_code(&result))

2654

error= put_error(&con, &result);

2644

2655

}

2645

2656

}

2646

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

2657

else if (drizzle_result_affected_rows(&result) == ~(uint64_t) 0)

2647

2658

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

2648

2659

else

2649

2660

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

2650

2661

"Query OK, %ld rows affected",

2651

(long) drizzleclient_affected_rows(&drizzle)),

2652

(long) drizzleclient_affected_rows(&drizzle));

2662

(long) drizzle_result_affected_rows(&result)),

2663

(long) drizzle_result_affected_rows(&result));

2653

2664

2654

2665

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

2655

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

2666

if ((warnings= drizzle_result_warning_count(&result)))

2656

2667

{

2657

2668

*pos++= ',';

2658

2669

*pos++= ' ';

2663

2674

}

2664

2675

strcpy(pos, time_buff);

2665

2676

put_info(buff,INFO_RESULT,0,0);

2666

if (drizzleclient_info(&drizzle))

2667

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

2677

if (strcmp(drizzle_result_info(&result), ""))

2678

put_info(drizzle_result_info(&result),INFO_RESULT,0,0);

2668

2679

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

2669

2680

2670

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

2671

error= put_error(&drizzle);

2672

else if (unbuffered)

2681

if (unbuffered)

2673

2682

fflush(stdout);

2674

drizzleclient_free_result(result);

2675

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

2683

drizzle_result_free(&result);

2684

2685

if (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS)

2686

{

2687

if (drizzle_result_read(&con, &result, &ret) == NULL ||

2688

ret != DRIZZLE_RETURN_OK)

2689

{

2690

if (ret == DRIZZLE_RETURN_ERROR_CODE)

2691

{

2692

error_code= drizzle_result_error_code(&result);

2693

drizzle_result_free(&result);

2694

}

2695

2696

error= put_error(&con, NULL);

2697

goto end;

2698

}

2699

}

2700

2701

} while (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS);

2676

2702

if (err >= 1)

2677

error= put_error(&drizzle);

2703

error= put_error(&con, NULL);

2678

2704

2679

2705

end:

2680

2706

2681

2707

/* Show warnings if any or error occured */

2682

2708

if (show_warnings == 1 && (warnings >= 1 || error))

2683

print_warnings();

2709

print_warnings(error_code);

2684

2710

2685

2711

if (!error && !status.batch &&

2686

(drizzle.server_status & SERVER_STATUS_DB_DROPPED))

2712

drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)

2713

{

2687

2714

get_current_db();

2715

}

2688

2716

2689

2717

executing_query= 0;

2690

2718

return error; /* New command follows */

2752

2780

}

2753

2781

2754

2782

2755

static const char *fieldtype2str(enum enum_field_types type)

2783

static const char *fieldtype2str(drizzle_column_type_t type)

2756

2784

{

2757

2785

switch (type) {

2758

case DRIZZLE_TYPE_BLOB: return "BLOB";

2759

case DRIZZLE_TYPE_DATE: return "DATE";

2760

case DRIZZLE_TYPE_DATETIME: return "DATETIME";

2761

case DRIZZLE_TYPE_NEWDECIMAL: return "DECIMAL";

2762

case DRIZZLE_TYPE_DOUBLE: return "DOUBLE";

2763

case DRIZZLE_TYPE_ENUM: return "ENUM";

2764

case DRIZZLE_TYPE_LONG: return "LONG";

2765

case DRIZZLE_TYPE_LONGLONG: return "LONGLONG";

2766

case DRIZZLE_TYPE_NULL: return "NULL";

2767

case DRIZZLE_TYPE_TIMESTAMP: return "TIMESTAMP";

2768

case DRIZZLE_TYPE_TINY: return "TINY";

2769

case DRIZZLE_TYPE_VIRTUAL: return "VIRTUAL";

2786

case DRIZZLE_COLUMN_TYPE_BLOB: return "BLOB";

2787

case DRIZZLE_COLUMN_TYPE_DATE: return "DATE";

2788

case DRIZZLE_COLUMN_TYPE_DATETIME: return "DATETIME";

2789

case DRIZZLE_COLUMN_TYPE_NEWDECIMAL: return "DECIMAL";

2790

case DRIZZLE_COLUMN_TYPE_DOUBLE: return "DOUBLE";

2791

case DRIZZLE_COLUMN_TYPE_ENUM: return "ENUM";

2792

case DRIZZLE_COLUMN_TYPE_LONG: return "LONG";

2793

case DRIZZLE_COLUMN_TYPE_LONGLONG: return "LONGLONG";

2794

case DRIZZLE_COLUMN_TYPE_NULL: return "NULL";

2795

case DRIZZLE_COLUMN_TYPE_TIMESTAMP: return "TIMESTAMP";

2796

case DRIZZLE_COLUMN_TYPE_TINY: return "TINY";

2797

case DRIZZLE_COLUMN_TYPE_VIRTUAL: return "VIRTUAL";

2770

2798

default: return "?-unknown-?";

2771

2799

}

2772

2800

}

2776

2804

char *s=buf;

2777

2805

*s=0;

2778

2806

#define ff2s_check_flag(X) \

2779

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

2780

f &= ~ X ## _FLAG; }

2807

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

2808

f &= ~ DRIZZLE_COLUMN_FLAGS_ ## X; }

2781

2809

ff2s_check_flag(NOT_NULL);

2782

2810

ff2s_check_flag(PRI_KEY);

2783

2811

ff2s_check_flag(UNIQUE_KEY);

2808

2836

drizzle_column_st *field;

2809

2837

uint32_t i=0;

2810

2838

2811

while ((field = drizzleclient_fetch_field(result)))

2839

while ((field = drizzle_column_next(result)))

2812

2840

{

2813

2841

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

2814

2842

"Catalog: `%s`\n"

2822

2850

"Decimals: %u\n"

2823

2851

"Flags: %s\n\n",

2824

2852

++i,

2825

field->name, field->catalog, field->db, field->table,

2826

field->org_table, fieldtype2str(field->type),

2827

get_charset_name(field->charsetnr), field->charsetnr,

2828

field->length, field->max_length, field->decimals,

2829

fieldflags2str(field->flags));

2853

drizzle_column_name(field), drizzle_column_catalog(field),

2854

drizzle_column_db(field), drizzle_column_table(field),

2855

drizzle_column_orig_table(field),

2856

fieldtype2str(drizzle_column_type(field)),

2857

get_charset_name(drizzle_column_charset(field)),

2858

drizzle_column_charset(field), drizzle_column_size(field),

2859

drizzle_column_max_size(field), drizzle_column_decimals(field),

2860

fieldflags2str(drizzle_column_flags(field)));

2830

2861

}

2831

2862

tee_puts("", PAGER);

2832

2863

}

2835

2866

static void

2836

2867

print_table_data(drizzle_result_st *result)

2837

2868

{

2838

drizzle_row_t cur;

2839

drizzle_column_st *field;

2840

bool *num_flag;

2869

drizzle_row_t cur;

2870

drizzle_return_t ret;

2871

drizzle_column_st *field;

2872

bool *num_flag;

2841

2873

string separator;

2842

2874

2843

2875

separator.reserve(256);

2844

2876

2845

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

2877

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

2846

2878

if (column_types_flag)

2847

2879

{

2848

2880

print_field_types(result);

2849

if (!drizzleclient_num_rows(result))

2881

if (!drizzle_result_row_count(result))

2850

2882

return;

2851

drizzleclient_field_seek(result,0);

2883

drizzle_column_seek(result,0);

2852

2884

}

2853

2885

separator.append("+");

2854

while ((field = drizzleclient_fetch_field(result)))

2886

while ((field = drizzle_column_next(result)))

2855

2887

{

2856

2888

uint32_t x, length= 0;

2857

2889

2858

2890

if (column_names)

2859

2891

{

2892

uint32_t name_length= strlen(drizzle_column_name(field));

2893

2860

2894

/* Check if the max_byte value is really the maximum in terms

2861

2895

of visual length since multibyte characters can affect the

2862

2896

length of the separator. */

2863

2897

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

2864

field->name,

2865

field->name+field->name_length);

2898

drizzle_column_name(field),

2899

drizzle_column_name(field) +

2900

name_length);

2866

2901

2867

if (field->name_length == field->max_length)

2902

if (name_length == drizzle_column_max_size(field))

2868

2903

{

2869

if (length < field->max_length)

2870

field->max_length= length;

2904

if (length < drizzle_column_max_size(field))

2905

drizzle_column_set_max_size(field, length);

2871

2906

}

2872

2907

else

2873

2908

{

2874

length= field->name_length;

2909

length= name_length;

2875

2910

}

2876

2911

}

2877

2912

2878

2913

if (quick)

2879

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

2914

length=max(length,drizzle_column_size(field));

2880

2915

else

2881

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

2882

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

2916

length=max(length,(uint32_t)drizzle_column_max_size(field));

2917

if (length < 4 &&

2918

!(drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_NOT_NULL))

2919

{

2883

2920

// Room for "NULL"

2884

2921

length=4;

2885

field->max_length=length;

2922

}

2923

drizzle_column_set_max_size(field, length);

2886

2924

2887

2925

for (x=0; x< (length+2); x++)

2888

2926

separator.append("-");

2892

2930

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

2893

2931

if (column_names)

2894

2932

{

2895

drizzleclient_field_seek(result,0);

2933

drizzle_column_seek(result,0);

2896

2934

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

2897

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

2935

for (uint32_t off=0; (field = drizzle_column_next(result)) ; off++)

2898

2936

{

2899

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

2937

uint32_t name_length= (uint32_t) strlen(drizzle_column_name(field));

2900

2938

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

2901

field->name,

2902

field->name + name_length);

2903

uint32_t display_length= field->max_length + name_length - numcells;

2939

drizzle_column_name(field),

2940

drizzle_column_name(field) +

2941

name_length);

2942

uint32_t display_length= drizzle_column_max_size(field) + name_length -

2943

numcells;

2904

2944

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

2905

2945

MAX_COLUMN_LENGTH),

2906

field->name);

2907

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

2908

(field->type == DRIZZLE_TYPE_NEWDECIMAL));

2946

drizzle_column_name(field));

2947

num_flag[off]= ((drizzle_column_type(field) <= DRIZZLE_COLUMN_TYPE_LONGLONG) ||

2948

(drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_NEWDECIMAL));

2909

2949

}

2910

2950

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

2911

2951

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

2912

2952

}

2913

2953

2914

while ((cur= drizzleclient_fetch_row(result)))

2954

while (1)

2915

2955

{

2916

if (interrupted_query)

2956

if (quick)

2957

{

2958

cur= drizzle_row_buffer(result, &ret);

2959

if (ret != DRIZZLE_RETURN_OK)

2960

{

2961

(void)put_error(&con, result);

2962

break;

2963

}

2964

}

2965

else

2966

cur= drizzle_row_next(result);

2967

2968

if (cur == NULL || interrupted_query)

2917

2969

break;

2918

uint32_t *lengths= drizzleclient_fetch_lengths(result);

2970

2971

size_t *lengths= drizzle_row_field_sizes(result);

2919

2972

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

2920

drizzleclient_field_seek(result, 0);

2921

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

2973

drizzle_column_seek(result, 0);

2974

for (uint32_t off= 0; off < drizzle_result_column_count(result); off++)

2922

2975

{

2923

2976

const char *buffer;

2924

2977

uint32_t data_length;

2933

2986

}

2934

2987

else

2935

2988

{

2936

buffer= cur[off];

2989

buffer= (char *)cur[off];

2937

2990

data_length= (uint32_t) lengths[off];

2938

2991

}

2939

2992

2940

field= drizzleclient_fetch_field(result);

2941

field_max_length= field->max_length;

2993

field= drizzle_column_next(result);

2994

field_max_length= drizzle_column_max_size(field);

2942

2995

2943

2996

/*

2944

2997

How many text cells on the screen will this string span? If it contains

2964

3017

tee_fputs(" | ", PAGER);

2965

3018

}

2966

3019

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

3020

if (quick)

3021

drizzle_row_free(result, cur);

2967

3022

}

2968

3023

tee_puts(separator.c_str(), PAGER);

2969

3024

free(num_flag);

2987

3042

*/

2988

3043

static int get_field_disp_length(drizzle_column_st *field)

2989

3044

{

2990

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

3045

uint32_t length= column_names ? strlen(drizzle_column_name(field)) : 0;

2991

3046

2992

3047

if (quick)

2993

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

3048

length= max(length, drizzle_column_size(field));

2994

3049

else

2995

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

3050

length= max(length, (uint32_t)drizzle_column_max_size(field));

2996

3051

2997

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

3052

if (length < 4 &&

3053

!(drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_NOT_NULL))

3054

{

2998

3055

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

3056

}

2999

3057

3000

3058

return length;

3001

3059

}

3012

3070

{

3013

3071

unsigned int len= 0;

3014

3072

drizzle_column_st *field;

3015

drizzle_column_st_OFFSET offset;

3073

uint16_t offset;

3016

3074

3017

offset= drizzleclient_field_tell(result);

3075

offset= drizzle_column_current(result);

3018

3076

assert(offset == 0);

3019

3077

3020

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

3078

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

3021

3079

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

3022

3080

3023

(void) drizzleclient_field_seek(result, offset);

3081

(void) drizzle_column_seek(result, offset);

3024

3082

3025

3083

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

3026

3084

}

3058

3116

static void

3059

3117

print_table_data_vertically(drizzle_result_st *result)

3060

3118

{

3061

drizzle_row_t cur;

3062

uint32_t max_length=0;

3063

drizzle_column_st *field;

3119

drizzle_row_t cur;

3120

drizzle_return_t ret;

3121

uint32_t max_length=0;

3122

drizzle_column_st *field;

3064

3123

3065

while ((field = drizzleclient_fetch_field(result)))

3124

while ((field = drizzle_column_next(result)))

3066

3125

{

3067

uint32_t length= field->name_length;

3126

uint32_t length= strlen(drizzle_column_name(field));

3068

3127

if (length > max_length)

3069

3128

max_length= length;

3070

field->max_length=length;

3129

drizzle_column_set_max_size(field, length);

3071

3130

}

3072

3131

3073

drizzleclient_field_seek(result,0);

3074

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

3132

for (uint32_t row_count=1;; row_count++)

3075

3133

{

3076

if (interrupted_query)

3134

if (quick)

3135

{

3136

cur= drizzle_row_buffer(result, &ret);

3137

if (ret != DRIZZLE_RETURN_OK)

3138

{

3139

(void)put_error(&con, result);

3140

break;

3141

}

3142

}

3143

else

3144

cur= drizzle_row_next(result);

3145

3146

if (cur == NULL || interrupted_query)

3077

3147

break;

3078

drizzleclient_field_seek(result,0);

3148

drizzle_column_seek(result,0);

3079

3149

tee_fprintf(PAGER,

3080

3150

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

3081

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

3151

for (uint32_t off=0; off < drizzle_result_column_count(result); off++)

3082

3152

{

3083

field= drizzleclient_fetch_field(result);

3084

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

3153

field= drizzle_column_next(result);

3154

tee_fprintf(PAGER, "%*s: ",(int) max_length,drizzle_column_name(field));

3085

3155

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

3086

3156

}

3157

if (quick)

3158

drizzle_row_free(result, cur);

3087

3159

}

3088

3160

}

3089

3161

3090

3162

3091

3163

/* print_warnings should be called right after executing a statement */

3092

3164

3093

static void print_warnings()

3165

static void print_warnings(uint32_t error_code)

3094

3166

{

3095

const char *query;

3096

drizzle_result_st *result;

3097

drizzle_row_t cur;

3167

const char *query;

3168

drizzle_result_st result;

3169

drizzle_row_t cur;

3098

3170

uint64_t num_rows;

3099

3100

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

3101

uint32_t error= drizzleclient_errno(&drizzle);

3171

uint32_t new_code= 0;

3102

3172

3103

3173

/* Get the warnings */

3104

3174

query= "show warnings";

3105

drizzleclient_real_query_for_lazy(query, strlen(query),&result);

3175

drizzleclient_real_query_for_lazy(query, strlen(query),&result,&new_code);

3106

3176

drizzleclient_store_result_for_lazy(&result);

3107

3177

3108

3178

/* Bail out when no warnings */

3109

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

3179

if (!(num_rows= drizzle_result_row_count(&result)))

3110

3180

goto end;

3111

3181

3112

cur= drizzleclient_fetch_row(result);

3182

cur= drizzle_row_next(&result);

3113

3183

3114

3184

/*

3115

3185

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

3117

3187

messages. To be safe, skip printing the duplicate only if it is the only

3118

3188

warning.

3119

3189

*/

3120

if (!cur || (num_rows == 1 && error == (uint32_t) strtoul(cur[1], NULL, 10)))

3190

if (!cur || (num_rows == 1 &&

3191

error_code == (uint32_t) strtoul((char *)cur[1], NULL, 10)))

3192

{

3121

3193

goto end;

3194

}

3122

3195

3123

3196

/* Print the warnings */

3124

3197

init_pager();

3125

3198

do

3126

3199

{

3127

3200

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

3128

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

3201

} while ((cur= drizzle_row_next(&result)));

3129

3202

end_pager();

3130

3203

3131

3204

end:

3132

drizzleclient_free_result(result);

3205

drizzle_result_free(&result);

3133

3206

}

3134

3207

3135

3208

3173

3246

static void

3174

3247

print_tab_data(drizzle_result_st *result)

3175

3248

{

3176

drizzle_row_t cur;

3177

drizzle_column_st *field;

3178

uint32_t *lengths;

3249

drizzle_row_t cur;

3250

drizzle_return_t ret;

3251

drizzle_column_st *field;

3252

size_t *lengths;

3179

3253

3180

3254

if (opt_silent < 2 && column_names)

3181

3255

{

3182

3256

int first=0;

3183

while ((field = drizzleclient_fetch_field(result)))

3257

while ((field = drizzle_column_next(result)))

3184

3258

{

3185

3259

if (first++)

3186

3260

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

3187

(void) tee_fputs(field->name, PAGER);

3261

(void) tee_fputs(drizzle_column_name(field), PAGER);

3188

3262

}

3189

3263

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

3190

3264

}

3191

while ((cur = drizzleclient_fetch_row(result)))

3265

while (1)

3192

3266

{

3193

lengths= drizzleclient_fetch_lengths(result);

3194

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

3195

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

3267

if (quick)

3268

{

3269

cur= drizzle_row_buffer(result, &ret);

3270

if (ret != DRIZZLE_RETURN_OK)

3271

{

3272

(void)put_error(&con, result);

3273

break;

3274

}

3275

}

3276

else

3277

cur= drizzle_row_next(result);

3278

3279

if (cur == NULL)

3280

break;

3281

3282

lengths= drizzle_row_field_sizes(result);

3283

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

3284

for (uint32_t off=1 ; off < drizzle_result_column_count(result); off++)

3196

3285

{

3197

3286

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

3198

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

3287

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

3199

3288

}

3200

3289

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

3290

if (quick)

3291

drizzle_row_free(result, cur);

3201

3292

}

3202

3293

}

3203

3294

3394

3485

3395

3486

if (connected)

3396

3487

{

3397

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

3488

sprintf(buff,"Connection id: %u",drizzle_con_thread_id(&con));

3398

3489

put_info(buff,INFO_INFO,0,0);

3399

3490

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

3400

3491

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

3498

3589

{

3499

3590

char *tmp, buff[FN_REFLEN + 1];

3500

3591

int select_db;

3592

drizzle_result_st result;

3593

drizzle_return_t ret;

3501

3594

3502

3595

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

3503

3596

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

3545

3638

*/

3546

3639

if (!connected && reconnect())

3547

3640

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

3548

if (drizzleclient_select_db(&drizzle,tmp))

3641

for (bool try_again= true; ; try_again= false)

3549

3642

{

3550

if (drizzleclient_errno(&drizzle) != CR_SERVER_GONE_ERROR)

3551

return put_error(&drizzle);

3552

3553

if (reconnect())

3554

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

3555

if (drizzleclient_select_db(&drizzle,tmp))

3556

return put_error(&drizzle);

3643

if (drizzle_select_db(&con,&result,tmp,&ret) == NULL ||

3644

ret != DRIZZLE_RETURN_OK)

3645

{

3646

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3647

{

3648

int error= put_error(&con, &result);

3649

drizzle_result_free(&result);

3650

return error;

3651

}

3652

3653

if (ret != DRIZZLE_RETURN_SERVER_GONE || !try_again)

3654

return put_error(&con, NULL);

3655

3656

if (reconnect())

3657

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

3658

}

3557

3659

}

3558

3660

free(current_db);

3559

3661

current_db= strdup(tmp);

3647

3749

sql_connect(char *host,char *database,char *user,char *password,

3648

3750

uint32_t silent)

3649

3751

{

3752

drizzle_return_t ret;

3753

3650

3754

if (connected)

3651

3755

{

3652

3756

connected= 0;

3653

drizzleclient_close(&drizzle);

3654

}

3655

drizzleclient_create(&drizzle);

3757

drizzle_con_free(&con);

3758

drizzle_free(&drizzle);

3759

}

3760

drizzle_create(&drizzle);

3761

if (drizzle_con_add_tcp(&drizzle, &con, host, opt_drizzle_port, user,

3762

password, database, DRIZZLE_CON_NONE) == NULL)

3763

{

3764

(void) put_error(&con, NULL);

3765

(void) fflush(stdout);

3766

return 1;

3767

}

3768

3769

/* XXX add this back in

3656

3770

if (opt_connect_timeout)

3657

3771

{

3658

3772

uint32_t timeout=opt_connect_timeout;

3659

3773

drizzleclient_options(&drizzle,DRIZZLE_OPT_CONNECT_TIMEOUT,

3660

3774

(char*) &timeout);

3661

3775

}

3662

if (opt_compress)

3663

drizzleclient_options(&drizzle,DRIZZLE_OPT_COMPRESS,NULL);

3664

if (opt_secure_auth)

3665

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

3776

*/

3777

3778

/* XXX Do we need this?

3666

3779

if (safe_updates)

3667

3780

{

3668

3781

char init_command[100];

3672

3785

select_limit, max_join_size);

3673

3786

drizzleclient_options(&drizzle, DRIZZLE_INIT_COMMAND, init_command);

3674

3787

}

3675

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

3676

database, opt_drizzle_port, opt_drizzle_unix_port,

3677

connect_flag | DRIZZLE_CAPABILITIES_MULTI_STATEMENTS))

3788

*/

3789

if ((ret= drizzle_con_connect(&con)) != DRIZZLE_RETURN_OK)

3678

3790

{

3679

if (!silent ||

3680

(drizzleclient_errno(&drizzle) != CR_CONN_HOST_ERROR &&

3681

drizzleclient_errno(&drizzle) != CR_CONNECTION_ERROR))

3791

if (!silent || (ret != DRIZZLE_RETURN_GETADDRINFO &&

3792

ret != DRIZZLE_RETURN_COULD_NOT_CONNECT))

3682

3793

{

3683

(void) put_error(&drizzle);

3794

(void) put_error(&con, NULL);

3684

3795

(void) fflush(stdout);

3685

3796

return ignore_errors ? -1 : 1; // Abort

3686

3797

}

3687

3798

return -1; // Retryable

3688

3799

}

3689

3800

connected=1;

3801

/* XXX hmm?

3690

3802

drizzle.reconnect= debug_info_flag; // We want to know if this happens

3803

*/

3691

3804

build_completion_hash(opt_rehash, 1);

3692

3805

return 0;

3693

3806

}

3696

3809

static int

3697

3810

com_status(string *, const char *)

3698

3811

{

3812

/*

3699

3813

char buff[40];

3700

3814

uint64_t id;

3701

drizzle_result_st *result;

3815

*/

3816

drizzle_result_st result;

3817

drizzle_return_t ret;

3702

3818

3703

3819

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

3704

3820

usage(1); /* Print version */

3705

3821

if (connected)

3706

3822

{

3707

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

3823

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

3708

3824

/*

3709

3825

Don't remove "limit 1",

3710

3826

it is protection againts SQL_SELECT_LIMIT=0

3711

3827

*/

3712

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

3713

(result=drizzleclient_use_result(&drizzle)))

3828

if (drizzle_query_str(&con,&result,"select DATABASE(), USER() limit 1",

3829

&ret) != NULL && ret == DRIZZLE_RETURN_OK &&

3830

drizzle_result_buffer(&result) == DRIZZLE_RETURN_OK)

3714

3831

{

3715

drizzle_row_t cur=drizzleclient_fetch_row(result);

3832

drizzle_row_t cur=drizzle_row_next(&result);

3716

3833

if (cur)

3717

3834

{

3718

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

3835

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

3719

3836

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

3720

3837

}

3721

drizzleclient_free_result(result);

3838

drizzle_result_free(&result);

3722

3839

}

3723

3840

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

3724

3841

}

3739

3856

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

3740

3857

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

3741

3858

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

3742

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

3743

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

3859

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

3860

tee_fprintf(stdout, "Connection:\t\t%s\n", drizzle_con_host(&con));

3861

/* XXX need to save this from result

3744

3862

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

3745

3863

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

3746

3747

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

3748

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

3749

(result=drizzleclient_use_result(&drizzle)))

3750

{

3751

drizzle_row_t cur=drizzleclient_fetch_row(result);

3752

if (cur)

3753

{

3754

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

3755

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

3756

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

3757

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

3758

}

3759

drizzleclient_free_result(result);

3760

}

3761

3762

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

3763

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

3864

*/

3865

3866

if (strcmp(drizzle_con_uds(&con), ""))

3867

tee_fprintf(stdout, "UNIX socket:\t\t%s\n", drizzle_con_uds(&con));

3764

3868

else

3765

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

3766

if (drizzle.net.compress)

3767

tee_fprintf(stdout, "Protocol:\t\tCompressed\n");

3869

tee_fprintf(stdout, "TCP port:\t\t%d\n", drizzle_con_port(&con));

3768

3870

3769

3871

if (safe_updates)

3770

3872

{

3797

3899

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

3798

3900

{

3799

3901

drizzle_result_st result;

3902

drizzle_return_t ret;

3800

3903

3801

3904

buf.append(drizzle_con_server_version(con));

3802

3905

3810

3913

if (cur && cur[0])

3811

3914

{

3812

3915

buf.append(" ");

3813

buf.append(cur[0]);

3916

buf.append((char *)cur[0]);

3814

3917

}

3815

3918

drizzle_result_free(&result);

3816

3919

}

4060

4163

break;

4061

4164

case 'v':

4062

4165

if (connected)

4063

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

4166

processed_prompt->append(drizzle_con_server_version(&con));

4064

4167

else

4065

4168

processed_prompt->append("not_connected");

4066

4169

break;

4070

4173

case 'h':

4071

4174

{

4072

4175

const char *prompt;

4073

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

4176

prompt= connected ? drizzle_con_host(&con) : "not_connected";

4074

4177

if (strstr(prompt, "Localhost"))

4075

4178

processed_prompt->append("localhost");

4076

4179

else

4089

4192

break;

4090

4193

}

4091

4194

4092

const char *host_info = drizzleclient_get_host_info(&drizzle);

4093

if (strstr(host_info, "memory"))

4195

if (strcmp(drizzle_con_uds(&con), ""))

4094

4196

{

4095

processed_prompt->append(drizzle.host);

4197

char *pos=strrchr(drizzle_con_uds(&con),'/');

4198

processed_prompt->append(pos ? pos+1 : drizzle_con_uds(&con));

4096

4199

}

4097

else if (strstr(host_info,"TCP/IP") ||

4098

!drizzle.unix_socket)

4099

add_int_to_prompt(drizzle.port);

4100

4200

else

4101

{

4102

char *pos=strrchr(drizzle.unix_socket,'/');

4103

processed_prompt->append(pos ? pos+1 : drizzle.unix_socket);

4104

}

4201

add_int_to_prompt(drizzle_con_port(&con));

4105

4202

}

4106

4203

break;

4107

4204

case 'U':

4213

4310

4214

4311

static void init_username()

4215

4312

{

4313

/* XXX need this?

4216

4314

free(full_username);

4217

4315

free(part_username);

4218

4316

4225

4323

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

4226

4324

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

4227

4325

}

4326

*/

4228

4327

}

4229

4328

4230

4329

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