~drizzle-trunk/drizzle/development : revision 969

192

193

struct st_connection

194

{

195

DRIZZLE drizzle;

195

drizzle_st *drizzle;

196

drizzle_con_st con;

196

197

/* Used when creating views and sp, to avoid implicit commit */

197

DRIZZLE *util_drizzle;

198

drizzle_con_st *util_con;

198

199

char *name;

199

200

};

200

201

struct st_connection connections[128];

351

352

union

352

353

{

353

354

uint32_t errnum;

354

char sqlstate[SQLSTATE_LENGTH+1]; /* \0 terminated string */

355

char sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE+1]; /* \0 terminated string */

355

356

} code;

356

357

};

357

358

444

445

void handle_no_error(struct st_command*);

445

446

447

#define do_send_query(cn,q,q_len,flags) drizzleclient_send_query(&cn->drizzle, q, q_len)

448

449

448

void do_eval(string *query_eval, const char *query,

450

449

const char *query_end, bool pass_through_escape_chars)

451

450

{

559

558

560

559

*/

561

560

562

static void show_query(DRIZZLE *drizzle, const char* query)

561

static void show_query(drizzle_con_st *con, const char* query)

563

562

{

564

DRIZZLE_RES* res;

565

566

567

if (!drizzle)

563

drizzle_result_st res;

564

drizzle_return_t ret;

565

566

if (!con)

568

567

return;

569

568

570

if (drizzleclient_query(drizzle, query))

569

if (drizzle_query_str(con, &res, query, &ret) == NULL ||

570

ret != DRIZZLE_RETURN_OK)

571

{

572

log_msg("Error running query '%s': %d %s",

573

query, drizzleclient_errno(drizzle), drizzleclient_error(drizzle));

572

if (ret == DRIZZLE_RETURN_ERROR_CODE)

573

{

574

log_msg("Error running query '%s': %d %s",

575

query, drizzle_result_error_code(&res),

576

drizzle_result_error(&res));

577

drizzle_result_free(&res);

578

}

579

else

580

{

581

log_msg("Error running query '%s': %d %s",

582

query, ret, drizzle_con_error(con));

583

}

574

584

return;

575

585

}

576

586

577

if ((res= drizzleclient_store_result(drizzle)) == NULL)

587

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

588

drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)

578

589

{

579

590

/* No result set returned */

591

drizzle_result_free(&res);

580

592

return;

581

593

}

582

594

583

595

{

584

DRIZZLE_ROW row;

596

drizzle_row_t row;

585

597

unsigned int i;

586

598

unsigned int row_num= 0;

587

unsigned int num_fields= drizzleclient_num_fields(res);

588

const DRIZZLE_FIELD *fields= drizzleclient_fetch_fields(res);

599

unsigned int num_fields= drizzle_result_column_count(&res);

600

drizzle_column_st *column;

589

601

590

602

fprintf(stderr, "=== %s ===\n", query);

591

while ((row= drizzleclient_fetch_row(res)))

603

while ((row= drizzle_row_next(&res)))

592

604

{

593

uint32_t *lengths= drizzleclient_fetch_lengths(res);

605

size_t *lengths= drizzle_row_field_sizes(&res);

594

606

row_num++;

595

607

596

608

fprintf(stderr, "---- %d. ----\n", row_num);

609

drizzle_column_seek(&res, 0);

597

610

for(i= 0; i < num_fields; i++)

598

611

{

612

column= drizzle_column_next(&res);

599

613

fprintf(stderr, "%s\t%.*s\n",

600

fields[i].name,

614

drizzle_column_name(column),

601

615

(int)lengths[i], row[i] ? row[i] : "NULL");

602

616

}

603

617

}

605

619

fprintf(stderr, "=");

606

620

fprintf(stderr, "\n\n");

607

621

}

608

drizzleclient_free_result(res);

622

drizzle_result_free(&res);

609

623

610

624

return;

611

625

}

624

638

625

639

*/

626

640

627

static void show_warnings_before_error(DRIZZLE *drizzle)

641

static void show_warnings_before_error(drizzle_con_st *con)

628

642

{

629

DRIZZLE_RES* res;

643

drizzle_result_st res;

644

drizzle_return_t ret;

630

645

const char* query= "SHOW WARNINGS";

631

646

632

633

if (!drizzle)

647

if (!con)

634

648

return;

635

649

636

if (drizzleclient_query(drizzle, query))

650

if (drizzle_query_str(con, &res, query, &ret) == NULL ||

651

ret != DRIZZLE_RETURN_OK)

637

652

{

638

log_msg("Error running query '%s': %d %s",

639

query, drizzleclient_errno(drizzle), drizzleclient_error(drizzle));

653

if (ret == DRIZZLE_RETURN_ERROR_CODE)

654

{

655

log_msg("Error running query '%s': %d %s",

656

query, drizzle_result_error_code(&res),

657

drizzle_result_error(&res));

658

drizzle_result_free(&res);

659

}

660

else

661

{

662

log_msg("Error running query '%s': %d %s",

663

query, ret, drizzle_con_error(con));

664

}

640

665

return;

641

666

}

642

667

643

if ((res= drizzleclient_store_result(drizzle)) == NULL)

668

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

669

drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)

644

670

{

645

671

/* No result set returned */

672

drizzle_result_free(&res);

646

673

return;

647

674

}

648

675

649

if (drizzleclient_num_rows(res) <= 1)

676

if (drizzle_result_row_count(&res) <= 1)

650

677

{

651

678

/* Don't display the last row, it's "last error" */

652

679

}

653

680

else

654

681

{

655

DRIZZLE_ROW row;

682

drizzle_row_t row;

656

683

unsigned int row_num= 0;

657

unsigned int num_fields= drizzleclient_num_fields(res);

684

unsigned int num_fields= drizzle_result_column_count(&res);

658

685

659

686

fprintf(stderr, "\nWarnings from just before the error:\n");

660

while ((row= drizzleclient_fetch_row(res)))

687

while ((row= drizzle_row_next(&res)))

661

688

{

662

689

uint32_t i;

663

uint32_t *lengths= drizzleclient_fetch_lengths(res);

690

size_t *lengths= drizzle_row_field_sizes(&res);

664

691

665

if (++row_num >= drizzleclient_num_rows(res))

692

if (++row_num >= drizzle_result_row_count(&res))

666

693

{

667

694

/* Don't display the last row, it's "last error" */

668

695

break;

676

703

fprintf(stderr, "\n");

677

704

}

678

705

}

679

drizzleclient_free_result(res);

706

drizzle_result_free(&res);

680

707

681

708

return;

682

709

}

802

829

803

830

static void close_connections(void)

804

831

{

805

806

832

for (--next_con; next_con >= connections; --next_con)

807

833

{

808

drizzleclient_close(&next_con->drizzle);

809

if (next_con->util_drizzle)

810

drizzleclient_close(next_con->util_drizzle);

834

if (next_con->drizzle != NULL)

835

{

836

drizzle_free(next_con->drizzle);

837

next_con->drizzle= NULL;

838

}

811

839

free(next_con->name);

812

840

}

813

841

return;

954

982

been produced prior to the error

955

983

*/

956

984

if (cur_con)

957

show_warnings_before_error(&cur_con->drizzle);

985

show_warnings_before_error(&cur_con->con);

958

986

959

987

cleanup_and_exit(1);

960

988

}

1770

1798

of the currently connected server

1771

1799

*/

1772

1800

1773

static void var_set_drizzleclient_get_server_version(DRIZZLE *drizzle)

1801

static void var_set_drizzleclient_get_server_version(drizzle_con_st *con)

1774

1802

{

1775

var_set_int("$drizzleclient_get_server_version", drizzleclient_get_server_version(drizzle));

1803

var_set_int("$drizzle_con_server_version", drizzle_con_server_version_number(con));

1776

1804

}

1777

1805

1778

1806

1803

1831

{

1804

1832

const char *end = (char*)((query_end && *query_end) ?

1805

1833

*query_end : query + strlen(query));

1806

DRIZZLE_RES *res;

1807

DRIZZLE_ROW row;

1808

DRIZZLE *drizzle= &cur_con->drizzle;

1834

drizzle_result_st res;

1835

drizzle_return_t ret;

1836

drizzle_row_t row;

1837

drizzle_con_st *con= &cur_con->con;

1809

1838

string ds_query;

1810

1839

1811

1840

1818

1847

/* Eval the query, thus replacing all environment variables */

1819

1848

do_eval(&ds_query, query, end, false);

1820

1849

1821

if (drizzleclient_real_query(drizzle, ds_query.c_str(), ds_query.length()))

1822

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

1823

drizzleclient_errno(drizzle), drizzleclient_error(drizzle));

1824

if (!(res= drizzleclient_store_result(drizzle)))

1850

if (drizzle_query(con, &res, ds_query.c_str(), ds_query.length(),

1851

&ret) == NULL ||

1852

ret != DRIZZLE_RETURN_OK)

1853

{

1854

if (ret == DRIZZLE_RETURN_ERROR_CODE)

1855

{

1856

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

1857

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

1858

drizzle_result_free(&res);

1859

}

1860

else

1861

{

1862

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

1863

drizzle_con_error(con));

1864

}

1865

}

1866

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

1867

drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)

1825

1868

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

1826

1869

1827

if ((row= drizzleclient_fetch_row(res)) && row[0])

1870

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

1828

1871

{

1829

1872

/*

1830

1873

Concatenate all fields in the first row with tab in between

1832

1875

*/

1833

1876

string result;

1834

1877

uint32_t i;

1835

uint32_t *lengths;

1878

size_t *lengths;

1836

1879

1837

lengths= drizzleclient_fetch_lengths(res);

1838

for (i= 0; i < drizzleclient_num_fields(res); i++)

1880

lengths= drizzle_row_field_sizes(&res);

1881

for (i= 0; i < drizzle_result_column_count(&res); i++)

1839

1882

{

1840

1883

if (row[i])

1841

1884

{

1850

1893

else

1851

1894

eval_expr(var, "", 0);

1852

1895

1853

drizzleclient_free_result(res);

1896

drizzle_result_free(&res);

1854

1897

return;

1855

1898

}

1856

1899

1881

1924

{

1882

1925

long row_no;

1883

1926

int col_no= -1;

1884

DRIZZLE_RES* res;

1885

DRIZZLE *drizzle= &cur_con->drizzle;

1927

drizzle_result_st res;

1928

drizzle_return_t ret;

1929

drizzle_con_st *con= &cur_con->con;

1886

1930

1887

1931

string ds_query;

1888

1932

string ds_col;

1913

1957

ds_query.append(unstripped_query);

1914

1958

1915

1959

/* Run the query */

1916

if (drizzleclient_real_query(drizzle, ds_query.c_str(), ds_query.length()))

1917

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

1918

drizzleclient_errno(drizzle), drizzleclient_error(drizzle));

1919

if (!(res= drizzleclient_store_result(drizzle)))

1960

if (drizzle_query(con, &res, ds_query.c_str(), ds_query.length(),

1961

&ret) == NULL ||

1962

ret != DRIZZLE_RETURN_OK)

1963

{

1964

if (ret == DRIZZLE_RETURN_ERROR_CODE)

1965

{

1966

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

1967

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

1968

drizzle_result_free(&res);

1969

}

1970

else

1971

{

1972

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

1973

drizzle_con_error(con));

1974

}

1975

}

1976

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

1977

drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)

1920

1978

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

1921

1979

1922

1980

{

1923

1981

/* Find column number from the given column name */

1924

1982

uint32_t i;

1925

uint32_t num_fields= drizzleclient_num_fields(res);

1926

const DRIZZLE_FIELD *fields= drizzleclient_fetch_fields(res);

1983

uint32_t num_fields= drizzle_result_column_count(&res);

1984

drizzle_column_st *column;

1927

1985

1928

1986

for (i= 0; i < num_fields; i++)

1929

1987

{

1930

if (strcmp(fields[i].name, ds_col.c_str()) == 0 &&

1931

strlen(fields[i].name) == ds_col.length())

1988

column= drizzle_column_next(&res);

1989

if (strcmp(drizzle_column_name(column), ds_col.c_str()) == 0 &&

1990

strlen(drizzle_column_name(column)) == ds_col.length())

1932

1991

{

1933

1992

col_no= i;

1934

1993

break;

1936

1995

}

1937

1996

if (col_no == -1)

1938

1997

{

1939

drizzleclient_free_result(res);

1998

drizzle_result_free(&res);

1940

1999

die("Could not find column '%s' in the result of '%s'",

1941

2000

ds_col.c_str(), ds_query.c_str());

1942

2001

}

1944

2003

1945

2004

{

1946

2005

/* Get the value */

1947

DRIZZLE_ROW row;

2006

drizzle_row_t row;

1948

2007

long rows= 0;

1949

2008

const char* value= "No such row";

1950

2009

1951

while ((row= drizzleclient_fetch_row(res)))

2010

while ((row= drizzle_row_next(&res)))

1952

2011

{

1953

2012

if (++rows == row_no)

1954

2013

{

1964

2023

}

1965

2024

eval_expr(var, value, 0);

1966

2025

}

1967

drizzleclient_free_result(res);

2026

drizzle_result_free(&res);

1968

2027

1969

2028

return;

1970

2029

}

2809

2868

{

2810

2869

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

2811

2870

struct st_connection *con;

2871

drizzle_result_st result;

2872

drizzle_return_t ret;

2812

2873

2813

2874

if (!*p)

2814

2875

die("Missing connection name in send_quit");

2823

2884

if (!(con= find_connection_by_name(name)))

2824

2885

die("connection '%s' not found in connection pool", name);

2825

2886

2826

simple_command(&con->drizzle,COM_QUIT,0,0,1);

2887

if (drizzle_quit(&con->con,&result, &ret))

2888

drizzle_result_free(&result);

2827

2889

2828

2890

return;

2829

2891

}

2968

3030

do_wait_for_slave_to_stop(struct st_command *)

2969

3031

{

2970

3032

static int SLAVE_POLL_INTERVAL= 300000;

2971

DRIZZLE *drizzle= &cur_con->drizzle;

3033

drizzle_con_st *con= &cur_con->con;

2972

3034

for (;;)

2973

3035

{

2974

DRIZZLE_RES *res= NULL;

2975

DRIZZLE_ROW row;

3036

drizzle_result_st res;

3037

drizzle_return_t ret;

3038

drizzle_row_t row;

2976

3039

int done;

2977

3040

2978

if (drizzleclient_query(drizzle,"show status like 'Slave_running'") ||

2979

!(res=drizzleclient_store_result(drizzle)))

3041

if (drizzle_query_str(con,&res,"show status like 'Slave_running'",

3042

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

3043

{

3044

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3045

{

3046

die("Query failed while probing slave for stop: %s",

3047

drizzle_result_error(&res));

3048

drizzle_result_free(&res);

3049

}

3050

else

3051

{

3052

die("Query failed while probing slave for stop: %s",

3053

drizzle_con_error(con));

3054

}

3055

}

3056

3057

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

3058

drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)

3059

{

2980

3060

die("Query failed while probing slave for stop: %s",

2981

drizzleclient_error(drizzle));

2982

if (!(row=drizzleclient_fetch_row(res)) || !row[1])

3061

drizzle_con_error(con));

3062

}

3063

3064

if (!(row=drizzle_row_next(&res)) || !row[1])

2983

3065

{

2984

drizzleclient_free_result(res);

3066

drizzle_result_free(&res);

2985

3067

die("Strange result from query while probing slave for stop");

2986

3068

}

2987

3069

done = !strcmp(row[1],"OFF");

2988

drizzleclient_free_result(res);

3070

drizzle_result_free(&res);

2989

3071

if (done)

2990

3072

break;

2991

3073

usleep(SLAVE_POLL_INTERVAL);

2996

3078

2997

3079

static void do_sync_with_master2(long offset)

2998

3080

{

2999

DRIZZLE_RES *res;

3000

DRIZZLE_ROW row;

3001

DRIZZLE *drizzle= &cur_con->drizzle;

3081

drizzle_result_st res;

3082

drizzle_return_t ret;

3083

drizzle_row_t row;

3084

drizzle_con_st *con= &cur_con->con;

3002

3085

char query_buf[FN_REFLEN+128];

3003

3086

int tries= 0;

3004

3087

3010

3093

3011

3094

wait_for_position:

3012

3095

3013

if (drizzleclient_query(drizzle, query_buf))

3014

die("failed in '%s': %d: %s", query_buf, drizzleclient_errno(drizzle),

3015

drizzleclient_error(drizzle));

3016

3017

if (!(res= drizzleclient_store_result(drizzle)))

3018

die("drizzleclient_store_result() returned NULL for '%s'", query_buf);

3019

if (!(row= drizzleclient_fetch_row(res)))

3020

{

3021

drizzleclient_free_result(res);

3096

if (drizzle_query_str(con, &res, query_buf, &ret) == NULL ||

3097

ret != DRIZZLE_RETURN_OK)

3098

{

3099

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3100

{

3101

die("failed in '%s': %d: %s", query_buf, drizzle_result_error_code(&res),

3102

drizzle_result_error(&res));

3103

drizzle_result_free(&res);

3104

}

3105

else

3106

die("failed in '%s': %d: %s", query_buf, ret, drizzle_con_error(con));

3107

}

3108

3109

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

3110

drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)

3111

die("drizzle_result_buffer() returned NULL for '%s'", query_buf);

3112

3113

if (!(row= drizzle_row_next(&res)))

3114

{

3115

drizzle_result_free(&res);

3022

3116

die("empty result in %s", query_buf);

3023

3117

}

3024

3118

if (!row[0])

3027

3121

It may be that the slave SQL thread has not started yet, though START

3028

3122

SLAVE has been issued ?

3029

3123

*/

3030

drizzleclient_free_result(res);

3124

drizzle_result_free(&res);

3031

3125

if (tries++ == 30)

3032

3126

{

3033

show_query(drizzle, "SHOW MASTER STATUS");

3034

show_query(drizzle, "SHOW SLAVE STATUS");

3127

show_query(con, "SHOW MASTER STATUS");

3128

show_query(con, "SHOW SLAVE STATUS");

3035

3129

die("could not sync with master ('%s' returned NULL)", query_buf);

3036

3130

}

3037

3131

sleep(1); /* So at most we will wait 30 seconds and make 31 tries */

3038

3132

goto wait_for_position;

3039

3133

}

3040

drizzleclient_free_result(res);

3134

drizzle_result_free(&res);

3041

3135

return;

3042

3136

}

3043

3137

3067

3161

*/

3068

3162

static int do_save_master_pos(void)

3069

3163

{

3070

DRIZZLE_RES *res;

3071

DRIZZLE_ROW row;

3072

DRIZZLE *drizzle= &cur_con->drizzle;

3164

drizzle_result_st res;

3165

drizzle_return_t ret;

3166

drizzle_row_t row;

3167

drizzle_con_st *con= &cur_con->con;

3073

3168

const char *query;

3074

3169

3075

3170

3076

if (drizzleclient_query(drizzle, query= "show master status"))

3077

die("failed in 'show master status': %d %s",

3078

drizzleclient_errno(drizzle), drizzleclient_error(drizzle));

3171

if (drizzle_query_str(con, &res, query= "show master status", &ret) == NULL ||

3172

ret != DRIZZLE_RETURN_OK)

3173

{

3174

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3175

{

3176

die("failed in '%s': %d: %s", query, drizzle_result_error_code(&res),

3177

drizzle_result_error(&res));

3178

drizzle_result_free(&res);

3179

}

3180

else

3181

die("failed in '%s': %d: %s", query, ret, drizzle_con_error(con));

3182

}

3079

3183

3080

if (!(res = drizzleclient_store_result(drizzle)))

3184

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

3185

drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)

3081

3186

die("drizzleclient_store_result() retuned NULL for '%s'", query);

3082

if (!(row = drizzleclient_fetch_row(res)))

3187

if (!(row = drizzle_row_next(&res)))

3083

3188

die("empty result in show master status");

3084

3189

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

3085

3190

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

3086

drizzleclient_free_result(res);

3191

drizzle_result_free(&res);

3087

3192

return(0);

3088

3193

}

3089

3194

3286

3391

3287

3392

/*

3288

3393

SQLSTATE string

3289

- Must be SQLSTATE_LENGTH long

3394

- Must be DRIZZLE_MAX_SQLSTATE_SIZE long

3290

3395

- May contain only digits[0-9] and _uppercase_ letters

3291

3396

*/

3292

3397

p++; /* Step past the S */

3293

if ((end - p) != SQLSTATE_LENGTH)

3294

die("The sqlstate must be exactly %d chars long", SQLSTATE_LENGTH);

3398

if ((end - p) != DRIZZLE_MAX_SQLSTATE_SIZE)

3399

die("The sqlstate must be exactly %d chars long", DRIZZLE_MAX_SQLSTATE_SIZE);

3295

3400

3296

3401

/* Check sqlstate string validity */

3297

3402

while (*p && p < end)

3446

3551

}

3447

3552

3448

3553

3449

static void set_reconnect(DRIZZLE *drizzle, int val)

3554

static void set_reconnect(drizzle_con_st *con, int val)

3450

3555

{

3556

(void) con;

3557

(void) val;

3558

/* XXX

3451

3559

bool reconnect= val;

3452

3560

3453

3561

drizzleclient_options(drizzle, DRIZZLE_OPT_RECONNECT, (char *)&reconnect);

3454

3455

return;

3562

*/

3456

3563

}

3457

3564

3458

3565

3462

3569

die("connection '%s' not found in connection pool", name);

3463

3570

3464

3571

/* Update $drizzleclient_get_server_version to that of current connection */

3465

var_set_drizzleclient_get_server_version(&cur_con->drizzle);

3572

var_set_drizzleclient_get_server_version(&cur_con->con);

3466

3573

3467

3574

return(0);

3468

3575

}

3504

3611

if (!(con= find_connection_by_name(name)))

3505

3612

die("connection '%s' not found in connection pool", name);

3506

3613

3507

if (command->type == Q_DIRTY_CLOSE)

3614

if (con->drizzle != NULL)

3508

3615

{

3509

if (con->drizzle.net.vio)

3510

{

3511

drizzleclient_net_close(&(con->drizzle.net));

3512

}

3616

drizzle_free(con->drizzle);

3617

con->drizzle= NULL;

3513

3618

}

3514

3515

drizzleclient_close(&con->drizzle);

3516

3517

if (con->util_drizzle)

3518

drizzleclient_close(con->util_drizzle);

3519

con->util_drizzle= 0;

3520

3521

3619

free(con->name);

3522

3620

3523

3621

/*

3556

3654

3557

3655

*/

3558

3656

3559

static void safe_connect(DRIZZLE *drizzle, const char *name, const char *host,

3560

const char *user, const char *pass, const char *db,

3561

int port)

3657

static void safe_connect(drizzle_con_st *con, const char *name,

3658

const char *host, const char *user, const char *pass,

3659

const char *db, int port)

3562

3660

{

3563

3661

int failed_attempts= 0;

3564

3662

static uint32_t connection_retry_sleep= 100000; /* Microseconds */

3565

3566

3567

while(!drizzleclient_connect(drizzle, host, user, pass, db, port, NULL,

3568

CLIENT_MULTI_STATEMENTS | CLIENT_REMEMBER_OPTIONS))

3663

drizzle_return_t ret;

3664

3665

drizzle_con_set_tcp(con, host, port);

3666

drizzle_con_set_auth(con, user, pass);

3667

drizzle_con_set_db(con, db);

3668

while((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)

3569

3669

{

3570

3670

/*

3571

3671

Connect failed

3575

3675

on protocol/connection type

3576

3676

*/

3577

3677

3578

if ((drizzleclient_errno(drizzle) == CR_CONN_HOST_ERROR ||

3579

drizzleclient_errno(drizzle) == CR_CONNECTION_ERROR) &&

3678

if ((ret == DRIZZLE_RETURN_GETADDRINFO ||

3679

ret == DRIZZLE_RETURN_COULD_NOT_CONNECT) &&

3580

3680

failed_attempts < opt_max_connect_retries)

3581

3681

{

3582

3682

verbose_msg("Connect attempt %d/%d failed: %d: %s", failed_attempts,

3583

opt_max_connect_retries, drizzleclient_errno(drizzle),

3584

drizzleclient_error(drizzle));

3683

opt_max_connect_retries, ret, drizzle_con_error(con));

3585

3684

usleep(connection_retry_sleep);

3586

3685

}

3587

3686

else

3588

3687

{

3589

3688

if (failed_attempts > 0)

3590

3689

die("Could not open connection '%s' after %d attempts: %d %s", name,

3591

failed_attempts, drizzleclient_errno(drizzle), drizzleclient_error(drizzle));

3690

failed_attempts, ret, drizzle_con_error(con));

3592

3691

else

3593

die("Could not open connection '%s': %d %s", name,

3594

drizzleclient_errno(drizzle), drizzleclient_error(drizzle));

3692

die("Could not open connection '%s': %d %s", name, ret,

3693

drizzle_con_error(con));

3595

3694

}

3596

3695

failed_attempts++;

3597

3696

}

3623

3722

*/

3624

3723

3625

3724

static int connect_n_handle_errors(struct st_command *command,

3626

DRIZZLE *con, const char* host,

3725

drizzle_con_st *con, const char* host,

3627

3726

const char* user, const char* pass,

3628

3727

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

3629

3728

{

3729

drizzle_return_t ret;

3630

3730

3631

3731

/* Only log if an error is expected */

3632

3732

if (!command->abort_on_error &&

3653

3753

ds_res.append(delimiter);

3654

3754

ds_res.append("\n");

3655

3755

}

3656

if (!drizzleclient_connect(con, host, user, pass, db, port, 0,

3657

CLIENT_MULTI_STATEMENTS))

3756

drizzle_con_set_tcp(con, host, port);

3757

drizzle_con_set_auth(con, user, pass);

3758

drizzle_con_set_db(con, db);

3759

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

3658

3760

{

3659

var_set_errno(drizzleclient_errno(con));

3660

handle_error(command, drizzleclient_errno(con), drizzleclient_error(con),

3661

drizzleclient_sqlstate(con), &ds_res);

3761

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3762

{

3763

var_set_errno(drizzle_con_error_code(con));

3764

handle_error(command, drizzle_con_error_code(con), drizzle_con_error(con),

3765

drizzle_con_sqlstate(con), &ds_res);

3766

}

3767

else

3768

{

3769

var_set_errno(ret);

3770

handle_error(command, ret, drizzle_con_error(con), "", &ds_res);

3771

}

3772

3662

3773

return 0; /* Not connected */

3663

3774

}

3664

3775

3786

3897

(int) (sizeof(connections)/sizeof(struct st_connection)));

3787

3898

}

3788

3899

3789

if (!drizzleclient_create(&con_slot->drizzle))

3790

die("Failed on drizzleclient_create()");

3791

if (opt_compress || con_compress)

3792

drizzleclient_options(&con_slot->drizzle, DRIZZLE_OPT_COMPRESS, NULL);

3793

3900

if ((con_slot->drizzle= drizzle_create(NULL)) == NULL)

3901

die("Failed on drizzle_create()");

3902

if (!drizzle_con_create(con_slot->drizzle, &con_slot->con))

3903

die("Failed on drizzle_con_create()");

3794

3904

3795

3905

/* Use default db name */

3796

3906

if (ds_database.length() == 0)

3800

3910

if (ds_database.length() && !strcmp(ds_database.c_str(),"*NO-ONE*"))

3801

3911

ds_database.clear();

3802

3912

3803

if (connect_n_handle_errors(command, &con_slot->drizzle,

3913

if (connect_n_handle_errors(command, &con_slot->con,

3804

3914

ds_host.c_str(),ds_user.c_str(),

3805

3915

ds_password.c_str(), ds_database.c_str(),

3806

3916

con_port, ds_sock.c_str()))

3814

3924

}

3815

3925

3816

3926

/* Update $drizzleclient_get_server_version to that of current connection */

3817

var_set_drizzleclient_get_server_version(&cur_con->drizzle);

3927

var_set_drizzleclient_get_server_version(&cur_con->con);

3818

3928

3819

3929

return;

3820

3930

}

4499

4609

static void print_version(void)

4500

4610

{

4501

4611

printf("%s Ver %s Distrib %s, for %s (%s)\n",my_progname,MTEST_VERSION,

4502

drizzleclient_get_client_info(),SYSTEM_TYPE,MACHINE_TYPE);

4612

drizzle_version(),SYSTEM_TYPE,MACHINE_TYPE);

4503

4613

}

4504

4614

4505

4615

static void usage(void)

4685

4795

if (argc == 1)

4686

4796

opt_db= *argv;

4687

4797

if (tty_password)

4688

opt_pass= drizzleclient_get_tty_password(NULL); /* purify tested */

4798

opt_pass= client_get_tty_password(NULL); /* purify tested */

4689

4799

if (debug_info_flag)

4690

4800

my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;

4691

4801

if (debug_check_flag)

4781

4891

Append the result for one field to the dynamic string ds

4782

4892

*/

4783

4893

4784

static void append_field(string *ds, uint32_t col_idx, const DRIZZLE_FIELD* field,

4894

static void append_field(string *ds, uint32_t col_idx, drizzle_column_st *column,

4785

4895

const char* val, uint64_t len, bool is_null)

4786

4896

{

4787

4897

if (col_idx < max_replace_column && replace_column[col_idx])

4803

4913

}

4804

4914

else

4805

4915

{

4806

ds->append(field->name);

4916

ds->append(drizzle_column_name(column));

4807

4917

ds->append("\t");

4808

4918

replace_append_mem(ds, val, (int)len);

4809

4919

ds->append("\n");

4816

4926

Values may be converted with 'replace_column'

4817

4927

*/

4818

4928

4819

static void append_result(string *ds, DRIZZLE_RES *res)

4929

static void append_result(string *ds, drizzle_result_st *res)

4820

4930

{

4821

DRIZZLE_ROW row;

4822

uint32_t num_fields= drizzleclient_num_fields(res);

4823

const DRIZZLE_FIELD *fields= drizzleclient_fetch_fields(res);

4824

uint32_t *lengths;

4931

drizzle_row_t row;

4932

uint32_t num_fields= drizzle_result_column_count(res);

4933

drizzle_column_st *column;

4934

size_t *lengths;

4825

4935

4826

while ((row = drizzleclient_fetch_row(res)))

4936

while ((row = drizzle_row_next(res)))

4827

4937

{

4828

4938

uint32_t i;

4829

lengths = drizzleclient_fetch_lengths(res);

4939

lengths = drizzle_row_field_sizes(res);

4940

drizzle_column_seek(res, 0);

4830

4941

for (i = 0; i < num_fields; i++)

4831

append_field(ds, i, &fields[i],

4942

{

4943

column= drizzle_column_next(res);

4944

append_field(ds, i, column,

4832

4945

(const char*)row[i], lengths[i], !row[i]);

4946

}

4833

4947

if (!display_result_vertically)

4834

4948

ds->append("\n");

4835

4949

4841

4955

Append metadata for fields to output

4842

4956

*/

4843

4957

4844

static void append_metadata(string *ds,

4845

const DRIZZLE_FIELD *field,

4846

uint32_t num_fields)

4958

static void append_metadata(string *ds, drizzle_result_st *res)

4847

4959

{

4848

const DRIZZLE_FIELD *field_end;

4960

drizzle_column_st *column;

4849

4961

ds->append("Catalog\tDatabase\tTable\tTable_alias\tColumn\t"

4850

4962

"Column_alias\tType\tLength\tMax length\tIs_null\t"

4851

4963

"Flags\tDecimals\tCharsetnr\n");

4852

4964

4853

for (field_end= field+num_fields ;

4854

field < field_end ;

4855

field++)

4965

drizzle_column_seek(res, 0);

4966

while ((column= drizzle_column_next(res)))

4856

4967

{

4857

ds->append(field->catalog,

4858

field->catalog_length);

4859

ds->append("\t", 1);

4860

ds->append(field->db, field->db_length);

4861

ds->append("\t", 1);

4862

ds->append(field->org_table,

4863

field->org_table_length);

4864

ds->append("\t", 1);

4865

ds->append(field->table,

4866

field->table_length);

4867

ds->append("\t", 1);

4868

ds->append(field->org_name,

4869

field->org_name_length);

4870

ds->append("\t", 1);

4871

ds->append(field->name, field->name_length);

4872

ds->append("\t", 1);

4873

replace_append_uint(ds, field->type);

4874

ds->append("\t", 1);

4875

replace_append_uint(ds, field->length);

4876

ds->append("\t", 1);

4877

replace_append_uint(ds, field->max_length);

4878

ds->append("\t", 1);

4879

ds->append((char*) ((field->flags & NOT_NULL_FLAG) ?

4880

"N" : "Y"), 1);

4881

ds->append("\t", 1);

4882

replace_append_uint(ds, field->flags);

4883

ds->append("\t", 1);

4884

replace_append_uint(ds, field->decimals);

4885

ds->append("\t", 1);

4886

replace_append_uint(ds, field->charsetnr);

4968

ds->append(drizzle_column_catalog(column),

4969

strlen(drizzle_column_catalog(column)));

4970

ds->append("\t", 1);

4971

ds->append(drizzle_column_db(column), strlen(drizzle_column_db(column)));

4972

ds->append("\t", 1);

4973

ds->append(drizzle_column_orig_table(column),

4974

strlen(drizzle_column_orig_table(column)));

4975

ds->append("\t", 1);

4976

ds->append(drizzle_column_table(column),

4977

strlen(drizzle_column_table(column)));

4978

ds->append("\t", 1);

4979

ds->append(drizzle_column_orig_name(column),

4980

strlen(drizzle_column_orig_name(column)));

4981

ds->append("\t", 1);

4982

ds->append(drizzle_column_name(column),

4983

strlen(drizzle_column_name(column)));

4984

ds->append("\t", 1);

4985

replace_append_uint(ds, drizzle_column_type_drizzle(column));

4986

ds->append("\t", 1);

4987

replace_append_uint(ds, drizzle_column_size(column));

4988

ds->append("\t", 1);

4989

replace_append_uint(ds, drizzle_column_max_size(column));

4990

ds->append("\t", 1);

4991

ds->append((char*) ((drizzle_column_flags(column) & DRIZZLE_COLUMN_FLAGS_NOT_NULL) ? "N" : "Y"), 1);

4992

ds->append("\t", 1);

4993

replace_append_uint(ds, drizzle_column_flags(column));

4994

ds->append("\t", 1);

4995

replace_append_uint(ds, drizzle_column_decimals(column));

4996

ds->append("\t", 1);

4997

replace_append_uint(ds, drizzle_column_charset(column));

4887

4998

ds->append("\n", 1);

4888

4999

}

4889

5000

}

4899

5010

char buf[40], buff2[21];

4900

5011

sprintf(buf,"affected rows: %s\n", llstr(affected_rows, buff2));

4901

5012

ds->append(buf);

4902

if (info)

5013

if (info && strcmp(info, ""))

4903

5014

{

4904

5015

ds->append("info: ");

4905

5016

ds->append(info);

4912

5023

Display the table headings with the names tab separated

4913

5024

*/

4914

5025

4915

static void append_table_headings(string *ds,

4916

const DRIZZLE_FIELD *field,

4917

uint32_t num_fields)

5026

static void append_table_headings(string *ds, drizzle_result_st *res)

4918

5027

{

4919

uint32_t col_idx;

4920

for (col_idx= 0; col_idx < num_fields; col_idx++)

5028

uint32_t col_idx= 0;

5029

drizzle_column_st *column;

5030

drizzle_column_seek(res, 0);

5031

while ((column= drizzle_column_next(res)))

4921

5032

{

4922

5033

if (col_idx)

4923

5034

ds->append("\t", 1);

4924

replace_append(ds, field[col_idx].name);

5035

replace_append(ds, drizzle_column_name(column));

5036

col_idx++;

4925

5037

}

4926

5038

ds->append("\n", 1);

4927

5039

}

4933

5045

Number of warnings appended to ds

4934

5046

*/

4935

5047

4936

static int append_warnings(string *ds, DRIZZLE *drizzle)

5048

static int append_warnings(string *ds, drizzle_con_st *con,

5049

drizzle_result_st *res)

4937

5050

{

4938

5051

uint32_t count;

4939

DRIZZLE_RES *warn_res;

4940

4941

4942

if (!(count= drizzleclient_warning_count(drizzle)))

5052

drizzle_result_st warn_res;

5053

drizzle_return_t ret;

5054

5055

5056

if (!(count= drizzle_result_warning_count(res)))

4943

5057

return(0);

4944

5058

4945

/*

4946

If one day we will support execution of multi-statements

4947

through PS API we should not issue SHOW WARNINGS until

4948

we have not read all results...

4949

*/

4950

assert(!drizzleclient_more_results(drizzle));

4951

4952

if (drizzleclient_real_query(drizzle, "SHOW WARNINGS", 13))

4953

die("Error running query \"SHOW WARNINGS\": %s", drizzleclient_error(drizzle));

4954

4955

if (!(warn_res= drizzleclient_store_result(drizzle)))

4956

die("Warning count is %u but didn't get any warnings",

4957

count);

4958

4959

append_result(ds, warn_res);

5059

if (drizzle_query_str(con, &warn_res, "SHOW WARNINGS", &ret) == NULL ||

5060

ret != DRIZZLE_RETURN_OK)

5061

{

5062

if (ret == DRIZZLE_RETURN_ERROR_CODE)

5063

die("Error running query \"SHOW WARNINGS\": %s", drizzle_result_error(&warn_res));

5064

else

5065

die("Error running query \"SHOW WARNINGS\": %s", drizzle_con_error(con));

5066

}

5067

5068

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

5069

drizzle_result_buffer(&warn_res) != DRIZZLE_RETURN_OK)

5070

die("Warning count is %u but didn't get any warnings", count);

5071

5072

append_result(ds, &warn_res);

5073

drizzle_result_free(&warn_res);

4960

5074

4961

5075

return(count);

4962

5076

}

4980

5094

int flags, char *query, int query_len,

4981

5095

string *ds, string *ds_warnings)

4982

5096

{

4983

DRIZZLE_RES *res= 0;

4984

DRIZZLE *drizzle= &cn->drizzle;

4985

int err= 0, counter= 0;

5097

drizzle_result_st res;

5098

drizzle_return_t ret;

5099

drizzle_con_st *con= &cn->con;

5100

int err= 0;

5101

5102

drizzle_con_add_options(con, DRIZZLE_CON_NO_RESULT_READ);

4986

5103

4987

5104

if (flags & QUERY_SEND_FLAG)

4988

5105

{

4989

5106

/*

4990

5107

* Send the query

4991

5108

*/

4992

if (do_send_query(cn, query, query_len, flags))

5109

5110

(void) drizzle_query(con, &res, query, query_len, &ret);

5111

if (ret != DRIZZLE_RETURN_OK)

4993

5112

{

4994

handle_error(command, drizzleclient_errno(drizzle), drizzleclient_error(drizzle),

4995

drizzleclient_sqlstate(drizzle), ds);

5113

if (ret == DRIZZLE_RETURN_ERROR_CODE)

5114

{

5115

err= drizzle_result_error_code(&res);

5116

handle_error(command, err, drizzle_result_error(&res),

5117

drizzle_result_sqlstate(&res), ds);

5118

drizzle_result_free(&res);

5119

}

5120

else

5121

{

5122

handle_error(command, ret, drizzle_con_error(con), "", ds);

5123

err= ret;

5124

}

4996

5125

goto end;

4997

5126

}

4998

5127

}

4999

5128

if (!(flags & QUERY_REAP_FLAG))

5000

5129

return;

5001

5130

5002

do

5003

5131

{

5004

5132

/*

5005

When on first result set, call drizzleclient_read_query_result to retrieve

5006

answer to the query sent earlier

5007

*/

5008

if ((counter==0) && drizzleclient_read_query_result(drizzle))

5133

* Read the result packet

5134

*/

5135

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

5136

ret != DRIZZLE_RETURN_OK)

5009

5137

{

5010

handle_error(command, drizzleclient_errno(drizzle), drizzleclient_error(drizzle),

5011

drizzleclient_sqlstate(drizzle), ds);

5138

if (ret == DRIZZLE_RETURN_ERROR_CODE)

5139

{

5140

handle_error(command, drizzle_result_error_code(&res),

5141

drizzle_result_error(&res), drizzle_result_sqlstate(&res),

5142

ds);

5143

}

5144

else

5145

handle_error(command, ret, drizzle_con_error(con), "", ds);

5146

drizzle_result_free(&res);

5147

err= ret;

5012

5148

goto end;

5013

5014

5149

}

5015

5150

5016

5151

/*

5017

5152

Store the result of the query if it will return any fields

5018

5153

*/

5019

if (drizzleclient_field_count(drizzle) && ((res= drizzleclient_store_result(drizzle)) == 0))

5154

if (drizzle_result_column_count(&res) &&

5155

(ret= drizzle_result_buffer(&res)) != DRIZZLE_RETURN_OK)

5020

5156

{

5021

handle_error(command, drizzleclient_errno(drizzle), drizzleclient_error(drizzle),

5022

drizzleclient_sqlstate(drizzle), ds);

5157

if (ret == DRIZZLE_RETURN_ERROR_CODE)

5158

{

5159

handle_error(command, drizzle_result_error_code(&res),

5160

drizzle_result_error(&res), drizzle_result_sqlstate(&res),

5161

ds);

5162

}

5163

else

5164

handle_error(command, ret, drizzle_con_error(con), "", ds);

5165

drizzle_result_free(&res);

5166

err= ret;

5023

5167

goto end;

5024

5168

}

5025

5169

5027

5171

{

5028

5172

uint64_t affected_rows= 0; /* Ok to be undef if 'disable_info' is set */

5029

5173

5030

if (res)

5174

if (drizzle_result_column_count(&res))

5031

5175

{

5032

const DRIZZLE_FIELD *fields= drizzleclient_fetch_fields(res);

5033

uint32_t num_fields= drizzleclient_num_fields(res);

5034

5035

5176

if (display_metadata)

5036

append_metadata(ds, fields, num_fields);

5177

append_metadata(ds, &res);

5037

5178

5038

5179

if (!display_result_vertically)

5039

append_table_headings(ds, fields, num_fields);

5180

append_table_headings(ds, &res);

5040

5181

5041

append_result(ds, res);

5182

append_result(ds, &res);

5042

5183

}

5043

5184

5044

5185

/*

5046

5187

query to find the warnings

5047

5188

*/

5048

5189

if (!disable_info)

5049

affected_rows= drizzleclient_affected_rows(drizzle);

5190

affected_rows= drizzle_result_affected_rows(&res);

5050

5191

5051

5192

/*

5052

5193

Add all warnings to the result. We can't do this if we are in

5053

5194

the middle of processing results from multi-statement, because

5054

5195

this will break protocol.

5055

5196

*/

5056

if (!disable_warnings && !drizzleclient_more_results(drizzle))

5197

if (!disable_warnings)

5057

5198

{

5058

if (append_warnings(ds_warnings, drizzle) || ds_warnings->length())

5199

drizzle_con_remove_options(con, DRIZZLE_CON_NO_RESULT_READ);

5200

if (append_warnings(ds_warnings, con, &res) || ds_warnings->length())

5059

5201

{

5060

5202

ds->append("Warnings:\n", 10);

5061

5203

ds->append(ds_warnings->c_str(), ds_warnings->length());

5063

5205

}

5064

5206

5065

5207

if (!disable_info)

5066

append_info(ds, affected_rows, drizzleclient_info(drizzle));

5208

append_info(ds, affected_rows, drizzle_result_info(&res));

5067

5209

}

5068

5210

5069

if (res)

5070

{

5071

drizzleclient_free_result(res);

5072

res= 0;

5073

}

5074

counter++;

5075

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

5076

if (err > 0)

5077

{

5078

/* We got an error from drizzleclient_next_result, maybe expected */

5079

handle_error(command, drizzleclient_errno(drizzle), drizzleclient_error(drizzle),

5080

drizzleclient_sqlstate(drizzle), ds);

5081

goto end;

5211

drizzle_result_free(&res);

5082

5212

}

5083

assert(err == -1); /* Successful and there are no more results */

5084

5213

5085

5214

/* If we come here the query is both executed and read successfully */

5086

5215

handle_no_error(command);

5092

5221

to the server into the drizzletest builtin variable $drizzleclient_errno. This

5093

5222

variable then can be used from the test case itself.

5094

5223

*/

5095

var_set_errno(drizzleclient_errno(drizzle));

5224

drizzle_con_remove_options(con, DRIZZLE_CON_NO_RESULT_READ);

5225

var_set_errno(err);

5096

5226

return;

5097

5227

}

5098

5228

5127

5257

returned a valid reponse. Don't allow 2013 or 2006 to trigger an

5128

5258

abort_not_supported_test

5129

5259

*/

5130

if (err_errno == CR_SERVER_LOST ||

5131

err_errno == CR_SERVER_GONE_ERROR)

5260

if (err_errno == DRIZZLE_RETURN_SERVER_GONE)

5132

5261

die("require query '%s' failed: %d: %s", command->query,

5133

5262

err_errno, err_error);

5134

5263

5146

5275

(command->expected_errors.err[i].code.errnum == err_errno)) ||

5147

5276

((command->expected_errors.err[i].type == ERR_SQLSTATE) &&

5148

5277

(strncmp(command->expected_errors.err[i].code.sqlstate,

5149

err_sqlstate, SQLSTATE_LENGTH) == 0)))

5278

err_sqlstate, DRIZZLE_MAX_SQLSTATE_SIZE) == 0)))

5150

5279

{

5151

5280

if (!disable_result_log)

5152

5281

{

5495

5624

1024, 0, 0, get_var_key, var_free, MYF(0)))

5496

5625

die("Variable hash initialization failed");

5497

5626

5498

var_set_string("$DRIZZLE_SERVER_VERSION", drizzleclient_get_client_info());

5627

var_set_string("$DRIZZLE_SERVER_VERSION", drizzle_version());

5499

5628

5500

5629

memset(&master_pos, 0, sizeof(master_pos));

5501

5630

5520

5649

cur_file->lineno= 1;

5521

5650

}

5522

5651

cur_con= connections;

5523

if (!( drizzleclient_create(&cur_con->drizzle)))

5524

die("Failed in drizzleclient_create()");

5525

if (opt_compress)

5526

drizzleclient_options(&cur_con->drizzle,DRIZZLE_OPT_COMPRESS,NULL);

5652

if ((cur_con->drizzle= drizzle_create(NULL)) == NULL)

5653

die("Failed in drizzle_create()");

5654

if (!( drizzle_con_create(cur_con->drizzle, &cur_con->con)))

5655

die("Failed in drizzle_con_create()");

5527

5656

5528

5657

if (!(cur_con->name = strdup("default")))

5529

5658

die("Out of memory");

5530

5659

5531

safe_connect(&cur_con->drizzle, cur_con->name, opt_host, opt_user, opt_pass,

5660

safe_connect(&cur_con->con, cur_con->name, opt_host, opt_user, opt_pass,

5532

5661

opt_db, opt_port);

5533

5662

5534

5663

/* Use all time until exit if no explicit 'start_timer' */

5542

5671

var_set_errno(-1);

5543

5672

5544

5673

/* Update $drizzleclient_get_server_version to that of current connection */

5545

var_set_drizzleclient_get_server_version(&cur_con->drizzle);

5674

var_set_drizzleclient_get_server_version(&cur_con->con);

5546

5675

5547

5676

if (opt_include)

5548

5677

{

5730

5859

command->last_argument= command->end;

5731

5860

break;

5732

5861

case Q_PING:

5733

(void) drizzleclient_ping(&cur_con->drizzle);

5862

{

5863

drizzle_result_st result;

5864

drizzle_return_t ret;

5865

(void) drizzle_ping(&cur_con->con, &result, &ret);

5866

if (ret == DRIZZLE_RETURN_OK || ret == DRIZZLE_RETURN_ERROR_CODE)

5867

drizzle_result_free(&result);

5868

}

5734

5869

break;

5735

5870

case Q_EXEC:

5736

5871

do_exec(command);

5748

5883

do_set_charset(command);

5749

5884

break;

5750

5885

case Q_DISABLE_RECONNECT:

5751

set_reconnect(&cur_con->drizzle, 0);

5886

set_reconnect(&cur_con->con, 0);

5752

5887

break;

5753

5888

case Q_ENABLE_RECONNECT:

5754

set_reconnect(&cur_con->drizzle, 1);

5889

set_reconnect(&cur_con->con, 1);

5755

5890

break;

5756

5891

case Q_DISABLE_PARSING:

5757

5892

if (parsing_disabled == 0)

6020

6155

const char *from, int len);

6021

6156

void free_pointer_array(POINTER_ARRAY *pa);

6022

6157

6023

struct st_replace *glob_replace;

6158

struct st_replace *glob_replace= NULL;

6024

6159

6025

6160

/*

6026

6161

Get arguments for replace. The syntax is: