~drizzle-trunk/drizzle/development : revision 3.1.1

573

574

field_count= min(mysql_num_fields(result), MAX_RES_FIELDS);

575

576

bzero((char*) buffer, sizeof(buffer));

577

bzero((char*) length, sizeof(length));

578

bzero((char*) is_null, sizeof(is_null));

576

memset((char*) buffer, 0, sizeof(buffer));

577

memset((char*) length, 0, sizeof(length));

578

memset((char*) is_null, 0, sizeof(is_null));

579

580

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

581

{

741

if (table)

742

fprintf(stdout, "\n table :`%s`\t(expected: `%s`)",

743

field->table, table);

744

if (org_table)

744

if (org_table)

745

fprintf(stdout, "\n org_table:`%s`\t(expected: `%s`)",

746

field->org_table, org_table);

747

fprintf(stdout, "\n database :`%s`\t(expected: `%s`)", field->db, db);

1373

const char **cur_query;

1374

1375

myheader("test_prepare_insert_update");

1376

1377

for (cur_query= testcase; *cur_query; cur_query++)

1378

{

1379

char query[MAX_TEST_QUERY_LENGTH];

1599

1600

verify_param_count(stmt, 7);

1601

1602

bzero((char*) my_bind, sizeof(my_bind));

1602

memset((char*) my_bind, 0, sizeof(my_bind));

1603

1604

/* tinyint */

1605

my_bind[0].buffer_type= MYSQL_TYPE_TINY;

1775

1776

verify_param_count(stmt, 3);

1777

1778

/* Always bzero bind array because there can be internal members */

1779

bzero((char*) my_bind, sizeof(my_bind));

1778

/* Always clear bind array because there can be internal members */

1779

memset((char*) my_bind, 0, sizeof(my_bind));

1780

1781

/* tinyint */

1782

my_bind[0].buffer_type= MYSQL_TYPE_TINY;

1854

1855

verify_param_count(stmt, 2);

1856

1857

/* Always bzero all members of bind parameter */

1858

bzero((char*) my_bind, sizeof(my_bind));

1857

/* Always clear all members of bind parameter */

1858

memset((char*) my_bind, 0, sizeof(my_bind));

1859

1860

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

1861

my_bind[0].is_null= &is_null[0];

1960

rc= mysql_query(mysql, "INSERT INTO test_ps_nulls values (1), (null)");

1961

myquery(rc);

1962

1963

/* Always bzero all members of bind parameter */

1964

bzero((char*) &in_bind, sizeof(in_bind));

1965

bzero((char*) &out_bind, sizeof(out_bind));

1963

/* Always clear all members of bind parameter */

1964

memset((char*) &in_bind, 0, sizeof(in_bind));

1965

memset((char*) &out_bind, sizeof(out_bind));

1966

1967

in_bind.buffer_type= MYSQL_TYPE_LONG;

1968

in_bind.is_null= &in_is_null;

2037

myquery(rc);

2038

2039

/* fetch */

2040

bzero((char*) my_bind, sizeof(my_bind));

2040

memset((char*) my_bind, 0, sizeof(my_bind));

2041

for (i= 0; i < (int) array_elements(my_bind); i++)

2042

{

2043

my_bind[i].buffer_type= MYSQL_TYPE_LONG;

2272

2273

verify_param_count(stmt, 2);

2274

2275

/* Always bzero all members of bind parameter */

2276

bzero((char*) my_bind, sizeof(my_bind));

2275

/* Always clear all members of bind parameter */

2276

memset((char*) my_bind, 0, sizeof(my_bind));

2277

2278

/* string data */

2279

nData= 10;

2334

2335

verify_param_count(stmt, 2);

2336

2337

/* Always bzero all members of bind parameter */

2338

bzero((char*) my_bind, sizeof(my_bind));

2337

/* Always clear all members of bind parameter */

2338

memset((char*) my_bind, 0, sizeof(my_bind));

2339

2340

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

2341

my_bind[0].buffer= (void *)&int_data;

2526

break;

2527

}

2528

2529

bzero((char*) p_bind, sizeof(p_bind));

2529

memset((char*) p_bind, 0, sizeof(p_bind));

2530

p_bind[0].buffer_type= MYSQL_TYPE_LONG;

2531

p_bind[0].buffer= (void *)&p_int_data;

2532

p_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;

2541

strmov(p_str_data, "hh");

2542

p_str_length= strlen(p_str_data);

2543

2544

bzero((char*) r_bind, sizeof(r_bind));

2544

memset((char*) r_bind, 0, sizeof(r_bind));

2545

r_bind[0].buffer_type= MYSQL_TYPE_LONG;

2546

r_bind[0].buffer= (void *)&r_int_data;

2547

r_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;

2679

2680

verify_param_count(stmt, 1);

2681

2682

/* Always bzero all members of bind parameter */

2683

bzero((char*) my_bind, sizeof(my_bind));

2682

/* Always clear all members of bind parameter */

2683

memset((char*) my_bind, 0, sizeof(my_bind));

2684

2685

strmov(szData, (char *)"abc");

2686

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

2764

2765

verify_param_count(stmt, 1);

2766

2767

/* Always bzero all members of bind parameter */

2768

bzero((char*) my_bind, sizeof(my_bind));

2767

/* Always clear all members of bind parameter */

2768

memset((char*) my_bind, 0, sizeof(my_bind));

2769

2770

strmov(szData, (char *)"abc");

2771

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

2853

2854

verify_param_count(stmt, 4);

2855

2856

/* Always bzero all members of bind parameter */

2857

bzero((char*) my_bind, sizeof(my_bind));

2856

/* Always clear all members of bind parameter */

2857

memset((char*) my_bind, 0, sizeof(my_bind));

2858

2859

num= 22;

2860

isnull= 0;

3034

3035

verify_param_count(stmt, 2);

3036

3037

/* Always bzero all members of bind parameter */

3038

bzero((char*) my_bind, sizeof(my_bind));

3037

/* Always clear all members of bind parameter */

3038

memset((char*) my_bind, 0, sizeof(my_bind));

3039

3040

nData= 1;

3041

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

3107

3108

verify_param_count(stmt, 3);

3109

3110

/* Always bzero all members of bind parameter */

3111

bzero((char*) my_bind, sizeof(my_bind));

3110

/* Always clear all members of bind parameter */

3111

memset((char*) my_bind, 0, sizeof(my_bind));

3112

3113

my_bind[0].buffer= (void *)&int_data;

3114

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

3189

3190

verify_param_count(stmt, 2);

3191

3192

/* Always bzero all members of bind parameter */

3193

bzero((char*) my_bind, sizeof(my_bind));

3192

/* Always clear all members of bind parameter */

3193

memset((char*) my_bind, 0, sizeof(my_bind));

3194

3195

my_bind[0].buffer= (void *)&length;

3196

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

3282

3283

verify_param_count(stmt, 2);

3284

3285

/* Always bzero all members of bind parameter */

3286

bzero((char*) my_bind, sizeof(my_bind));

3285

/* Always clear all members of bind parameter */

3286

memset((char*) my_bind, 0, sizeof(my_bind));

3287

3288

my_bind[0].buffer= data; /* string data */

3289

my_bind[0].buffer_length= sizeof(data);

3375

DIE_UNLESS(field->max_length == max_blob_length);

3376

3377

/* Fetch results into a data buffer that is smaller than data */

3378

bzero((char*) my_bind, sizeof(*my_bind));

3378

memset((char*) my_bind, 0, sizeof(*my_bind));

3379

my_bind[0].buffer_type= MYSQL_TYPE_BLOB;

3380

my_bind[0].buffer= (void *) &data; /* this buffer won't be altered */

3381

my_bind[0].buffer_length= 16;

3391

DIE_UNLESS(blob_length == max_blob_length);

3392

3393

/* Fetch all data */

3394

bzero((char*) (my_bind+1), sizeof(*my_bind));

3394

memset((char*) (my_bind+1), 0, sizeof(*my_bind));

3395

my_bind[1].buffer_type= MYSQL_TYPE_BLOB;

3396

my_bind[1].buffer= (void *) &data; /* this buffer won't be altered */

3397

my_bind[1].buffer_length= sizeof(data);

3398

my_bind[1].length= &blob_length;

3399

bzero(data, sizeof(data));

3399

memset(data, 0, sizeof(data));

3400

mysql_stmt_fetch_column(stmt, my_bind+1, 0, 0);

3401

DIE_UNLESS(strlen(data) == max_blob_length);

3402

3439

3440

verify_param_count(stmt, 2);

3441

3442

/* Always bzero all members of bind parameter */

3443

bzero((char*) my_bind, sizeof(my_bind));

3442

/* Always clear all members of bind parameter */

3443

memset((char*) my_bind, 0, sizeof(my_bind));

3444

3445

my_bind[0].buffer= (void *)&length;

3446

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

3529

3530

verify_param_count(stmt, 2);

3531

3532

/* Always bzero all members of bind parameter */

3533

bzero((char*) my_bind, sizeof(my_bind));

3532

/* Always memset all members of bind parameter */

3533

memset((char*) my_bind, 0, sizeof(my_bind));

3534

3535

nData= 1;

3536

strmov(szData, "MySQL");

3603

3604

verify_param_count(stmt, 2);

3605

3606

/* Always bzero all members of bind parameter */

3607

bzero((char*) my_bind, sizeof(my_bind));

3606

/* Always memset all members of bind parameter */

3607

memset((char*) my_bind, 0, sizeof(my_bind));

3608

3609

/* string data */

3610

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

3633

verify_param_count(stmt, 2);

3634

nData= 100;

3635

3636

/* Always bzero all members of bind parameter */

3637

bzero((char*) my_bind, sizeof(my_bind));

3636

/* Always clear all members of bind parameter */

3637

memset((char*) my_bind, 0, sizeof(my_bind));

3638

3639

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

3640

my_bind[0].buffer= szData;

3754

3755

/* fetch */

3756

3757

bzero((char*) my_bind, sizeof(my_bind));

3757

memset((char*) my_bind, 0, sizeof(my_bind));

3758

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

3759

my_bind[0].buffer= (void *) &nData; /* integer data */

3760

my_bind[0].is_null= &is_null[0];

3847

rc= mysql_commit(mysql);

3848

myquery(rc);

3849

3850

bzero((char*) my_bind, sizeof(my_bind));

3850

memset((char*) my_bind, 0, sizeof(my_bind));

3851

for (i= 0; i < (int) array_elements(my_bind); i++)

3852

{

3853

my_bind[i].length= &length[i];

3966

rc= mysql_commit(mysql);

3967

myquery(rc);

3968

3969

bzero((char*) my_bind, sizeof(my_bind));

3969

memset((char*) my_bind, 0, sizeof(my_bind));

3970

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

3971

my_bind[0].buffer= (void *) t_data;

3972

my_bind[0].buffer_length= sizeof(t_data);

4086

4087

verify_param_count(stmt, 7);

4088

4089

/* Always bzero all members of bind parameter */

4090

bzero((char*) my_bind, sizeof(my_bind));

4089

/* Always clear all members of bind parameter */

4090

memset((char*) my_bind, 0, sizeof(my_bind));

4091

4092

for (i= 0; i < (int) array_elements(my_bind); i++)

4093

{

4260

rc= mysql_commit(mysql);

4261

myquery(rc);

4262

4263

bzero((char*) my_bind, sizeof(my_bind));

4263

memset((char*) my_bind, 0, sizeof(my_bind));

4264

for (i= 0; i < array_elements(my_bind); i++)

4265

{

4266

my_bind[i].is_null= &is_null[i];

4588

4589

verify_param_count(stmt, 6);

4590

4591

/* Always bzero all members of bind parameter */

4592

bzero((char*) my_bind, sizeof(my_bind));

4591

/* Always clear all members of bind parameter */

4592

memset((char*) my_bind, 0, sizeof(my_bind));

4593

4594

/*tinyint*/

4595

my_bind[0].buffer_type= MYSQL_TYPE_TINY;

4777

verify_param_count(stmt, 2);

4778

4779

/*

4780

We need to bzero bind structure because mysql_stmt_bind_param checks all

4780

We need to clear bind structure because mysql_stmt_bind_param checks all

4781

its members.

4782

*/

4783

bzero((char*) my_bind, sizeof(my_bind));

4783

memset((char*) my_bind, 0, sizeof(my_bind));

4784

4785

/* tinyint */

4786

my_bind[0].buffer_type= MYSQL_TYPE_TINY;

4999

mysql_close(lmysql);

5000

5001

/*

5002

We need to bzero bind structure because mysql_stmt_bind_param checks all

5002

We need to clear bind structure because mysql_stmt_bind_param checks all

5003

its members.

5004

*/

5005

bzero((char*) my_bind, sizeof(my_bind));

5005

memset((char*) my_bind, sizeof(my_bind));

5006

5007

my_bind[0].buffer= (void *)&count;

5008

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

5052

check_stmt(stmt1);

5053

5054

/*

5055

We need to bzero bind structure because mysql_stmt_bind_param checks all

5055

We need to clear bind structure because mysql_stmt_bind_param checks all

5056

its members.

5057

*/

5058

bzero((char*) get_bind, sizeof(get_bind));

5058

memset((char*) get_bind, 0, sizeof(get_bind));

5059

5060

get_bind[0].buffer_type= MYSQL_TYPE_STRING;

5061

get_bind[0].buffer= (void *)var;

5086

stmt= mysql_simple_prepare(mysql, "set max_error_count= ?");

5087

check_stmt(stmt);

5088

5089

bzero((char*) set_bind, sizeof(set_bind));

5089

memset((char*) set_bind, 0, sizeof(set_bind));

5090

5091

set_bind[0].buffer_type= MYSQL_TYPE_LONG;

5092

set_bind[0].buffer= (void *)&set_count;

5461

verify_param_count(stmt, 1);

5462

5463

/*

5464

We need to bzero bind structure because mysql_stmt_bind_param checks all

5464

We need to clear bind structure because mysql_stmt_bind_param checks all

5465

its members.

5466

*/

5467

bzero((char*) my_bind, sizeof(my_bind));

5467

memset((char*) my_bind, 0, sizeof(my_bind));

5468

5469

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

5470

my_bind[0].buffer= (void *)&id;

5622

/* Bind the data for the parameters */

5623

5624

/*

5625

We need to bzero bind structure because mysql_stmt_bind_param checks all

5625

We need to clear bind structure because mysql_stmt_bind_param checks all

5626

its members.

5627

*/

5628

bzero((char*) my_bind, sizeof(my_bind));

5628

memset((char*) my_bind, 0, sizeof(my_bind));

5629

5630

/* INTEGER PART */

5631

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

5749

verify_param_count(stmt, 1);

5750

5751

/*

5752

We need to bzero bind structure because mysql_stmt_bind_param checks all

5752

We need to clear bind structure because mysql_stmt_bind_param checks all

5753

its members.

5754

*/

5755

bzero((char*) my_bind, sizeof(my_bind));

5755

memset((char*) my_bind, 0, sizeof(my_bind));

5756

5757

is_null= 0;

5758

my_bind[0].buffer_type= MYSQL_TYPE_SHORT;

5995

myquery(rc);

5996

5997

/* fetch */

5998

bzero((char*) my_bind, sizeof(my_bind));

5998

memset((char*) my_bind, 0, sizeof(my_bind));

5999

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

6000

my_bind[0].buffer= (void *) &nData; /* integer data */

6001

my_bind[0].length= &length;

6179

myquery(rc);

6180

6181

/*

6182

We need to bzero bind structure because mysql_stmt_bind_param checks all

6182

We need to clear bind structure because mysql_stmt_bind_param checks all

6183

its members.

6184

*/

6185

bzero((char*) my_bind, sizeof(my_bind));

6185

memset((char*) my_bind, 0, sizeof(my_bind));

6186

6187

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

6188

my_bind[0].buffer= (void *) &nData; /* integer data */

6273

6274

/* fetch */

6275

/*

6276

We need to bzero bind structure because mysql_stmt_bind_param checks all

6276

We need to clear bind structure because mysql_stmt_bind_param checks all

6277

its members.

6278

*/

6279

bzero((char*) my_bind, sizeof(my_bind));

6279

memset((char*) my_bind, 0, sizeof(my_bind));

6280

6281

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

6282

my_bind[0].buffer= (void *) &id;

6378

verify_param_count(stmt, 4);

6379

6380

/*

6381

We need to bzero bind structure because mysql_stmt_bind_param checks all

6381

We need to clear bind structure because mysql_stmt_bind_param checks all

6382

its members.

6383

*/

6384

bzero((char*) my_bind, sizeof(my_bind));

6384

memset((char*) my_bind, 0, sizeof(my_bind));

6385

6386

my_bind[0].buffer_type= MYSQL_TYPE_TIMESTAMP;

6387

my_bind[1].buffer_type= MYSQL_TYPE_TIME;

6635

check_stmt(stmt);

6636

6637

/*

6638

We need to bzero bind structure because mysql_stmt_bind_param checks all

6638

We need to clear bind structure because mysql_stmt_bind_param checks all

6639

its members.

6640

*/

6641

bzero((char*) my_bind, sizeof(my_bind));

6641

memset((char*) my_bind, 0, sizeof(my_bind));

6642

6643

my_bind[0].length= &length;

6644

my_bind[0].is_null= 0;

6708

rc= mysql_stmt_execute(stmt);

6709

check_execute(stmt, rc);

6710

6711

bzero(buffer, sizeof(buffer)); /* Avoid overruns in printf() */

6711

memset(buffer, 0, sizeof(buffer)); /* Avoid overruns in printf() */

6712

6713

bzero((char*) my_bind, sizeof(my_bind));

6713

memset((char*) my_bind, 0, sizeof(my_bind));

6714

my_bind[0].length= &length;

6715

my_bind[0].is_null= &is_null;

6716

my_bind[0].buffer_length= 1;

6899

fprintf(stdout, "\n total rows : %d", rc);

6900

DIE_UNLESS(rc == 1);

6901

6902

bzero((char*) my_bind, sizeof(MYSQL_BIND));

6902

memset((char*) my_bind, 0, sizeof(MYSQL_BIND));

6903

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

6904

my_bind[0].buffer= (void *)str[0];

6905

my_bind[0].buffer_length= sizeof(str[0]);

6969

rc= mysql_stmt_execute(stmt);

6970

check_execute(stmt, rc);

6971

6972

bzero((char*) my_bind, sizeof(my_bind));

6972

memset((char*) my_bind, 0, sizeof(my_bind));

6973

my_bind[0].buffer_type= MYSQL_TYPE_SHORT;

6974

my_bind[0].buffer= (void *)&short_value;

6975

my_bind[0].is_unsigned= TRUE;

7057

rc= mysql_stmt_execute(stmt);

7058

check_execute(stmt, rc);

7059

7060

bzero((char*) my_bind, sizeof(my_bind));

7060

memset((char*) my_bind, 0, sizeof(my_bind));

7061

my_bind[0].buffer_type= MYSQL_TYPE_SHORT;

7062

my_bind[0].buffer= (void *)&short_value;

7063

my_bind[0].length= &s_length;

7144

rc= mysql_stmt_execute(stmt);

7145

check_execute(stmt, rc);

7146

7147

bzero((char*) my_bind, sizeof(my_bind));

7147

memset((char*) my_bind, 0, sizeof(my_bind));

7148

my_bind[0].buffer_type= MYSQL_TYPE_SHORT;

7149

my_bind[0].buffer= (void *)&short_value;

7150

my_bind[0].length= &s_length;

7252

rc= mysql_stmt_execute(stmt);

7253

check_execute(stmt, rc);

7254

7255

bzero((char*) my_bind, sizeof(my_bind));

7255

memset((char*) my_bind, 0, sizeof(my_bind));

7256

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

7257

my_bind[0].buffer= table_type;

7258

my_bind[0].length= &type_length;

7564

rc= mysql_stmt_execute(stmt);

7565

check_execute(stmt, rc);

7566

7567

bzero((char*) my_bind, sizeof(my_bind));

7567

memset((char*) my_bind, 0, sizeof(my_bind));

7568

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

7569

my_bind[0].buffer= data_dir;

7570

my_bind[0].buffer_length= FN_REFLEN;

7649

check_stmt(stmt);

7650

7651

/*

7652

We need to bzero bind structure because mysql_stmt_bind_param checks all

7652

We need to clear bind structure because mysql_stmt_bind_param checks all

7653

its members.

7654

*/

7655

bzero((char*) my_bind, sizeof(my_bind));

7655

memset((char*) my_bind, 0, sizeof(my_bind));

7656

7657

my_bind[0].buffer_type= MYSQL_TYPE_NEWDECIMAL;

7658

my_bind[0].buffer= (void *)data;

7848

}

7849

else

7850

{

7851

verify_prepare_field(result, 6, "key_len", "", MYSQL_TYPE_VAR_STRING, "",

7851

verify_prepare_field(result, 6, "key_len", "", MYSQL_TYPE_VAR_STRING, "",

7852

"", "", 320, 0);

7853

}

7854

8087

check_stmt(stmt);

8088

8089

/*

8090

We need to bzero bind structure because mysql_stmt_bind_param checks all

8090

We need to clear bind structure because mysql_stmt_bind_param checks all

8091

its members.

8092

*/

8093

bzero((char*) my_bind, sizeof(my_bind));

8093

memset((char*) my_bind, 0, sizeof(my_bind));

8094

8095

my_bind[0].buffer_type= MYSQL_TYPE_SHORT;

8096

my_bind[0].buffer= (void *)&id;

8237

myquery(rc);

8238

8239

/*

8240

We need to bzero bind structure because mysql_stmt_bind_param checks all

8240

We need to clear bind structure because mysql_stmt_bind_param checks all

8241

its members.

8242

*/

8243

bzero((char*) my_bind, sizeof(my_bind));

8243

memset((char*) my_bind, 0, sizeof(my_bind));

8244

8245

my_bind[0].buffer= (void *)&i;

8246

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

8314

stmt= mysql_simple_prepare(mysql, "select * from t1");

8315

check_stmt(stmt);

8316

8317

bzero((char*) my_bind, sizeof(my_bind));

8317

memset((char*) my_bind, 0, sizeof(my_bind));

8318

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

8319

my_bind[0].buffer= (void *)&c1;

8320

8410

stmt= mysql_simple_prepare(mysql, "select * from t1");

8411

check_stmt(stmt);

8412

8413

bzero((char*) my_bind, sizeof(my_bind));

8413

memset((char*) my_bind, 0, sizeof(my_bind));

8414

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

8415

my_bind[0].buffer= (void *)data;

8416

my_bind[0].buffer_length= 11;

8497

stmt= mysql_simple_prepare(mysql, "select * from t1 order by c2 desc");

8498

check_stmt(stmt);

8499

8500

bzero((char*) my_bind, sizeof(my_bind));

8500

memset((char*) my_bind, 0, sizeof(my_bind));

8501

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

8502

my_bind[0].buffer= (void *)&bc1;

8503

my_bind[0].buffer_length= 0;

8779

stmt= mysql_simple_prepare(mysql, "select * from test_free_result");

8780

check_stmt(stmt);

8781

8782

bzero((char*) my_bind, sizeof(my_bind));

8782

memset((char*) my_bind, 0, sizeof(my_bind));

8783

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

8784

my_bind[0].buffer= (void *)&bc1;

8785

my_bind[0].length= &bl1;

8859

stmt= mysql_simple_prepare(mysql, "select * from test_free_result");

8860

check_stmt(stmt);

8861

8862

bzero((char*) my_bind, sizeof(my_bind));

8862

memset((char*) my_bind, 0, sizeof(my_bind));

8863

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

8864

my_bind[0].buffer= (void *)&bc1;

8865

my_bind[0].buffer_length= 0;

8952

fprintf(stdout, "\n total parameters: %ld", mysql_stmt_param_count(stmt));

8953

8954

/*

8955

We need to bzero bind structure because mysql_stmt_bind_param checks all

8955

We need to clear bind structure because mysql_stmt_bind_param checks all

8956

its members.

8957

*/

8958

bzero((char*) my_bind, sizeof(my_bind));

8958

memset((char*) my_bind, 0, sizeof(my_bind));

8959

8960

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

8961

my_bind[0].buffer= (void *)c1;

9095

length= (long)(strmov(strts, "2003-07-12 21:07:46") - strts);

9096

9097

/*

9098

We need to bzero bind structure because mysql_stmt_bind_param checks all

9098

We need to clear bind structure because mysql_stmt_bind_param checks all

9099

its members.

9100

*/

9101

bzero((char*) my_bind, sizeof(my_bind));

9101

memset((char*) my_bind, 0, sizeof(my_bind));

9102

9103

my_bind[0].buffer_type= MYSQL_TYPE_TIMESTAMP;

9104

my_bind[0].buffer= (void *)&ts;

9198

verify_param_count(stmt, 3);

9199

9200

/*

9201

We need to bzero bind structure because mysql_stmt_bind_param checks all

9201

We need to clear bind structure because mysql_stmt_bind_param checks all

9202

its members.

9203

*/

9204

bzero((char*) my_bind, sizeof(my_bind));

9204

memset((char*) my_bind, 0, sizeof(my_bind));

9205

9206

my_bind[0].buffer= (void *)int_data;

9207

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

9676

rc= mysql_stmt_execute(stmt);

9677

check_execute(stmt, rc);

9678

9679

bzero((char*) &buffer, sizeof(buffer));

9679

memset((char*) &buffer, 0, sizeof(buffer));

9680

buffer.buffer_type= MYSQL_TYPE_LONGLONG;

9681

buffer.buffer_length= sizeof(lii);

9682

buffer.buffer= (void *)&lii;

9994

myheader("test_multi");

9995

9996

/*

9997

We need to bzero bind structure because mysql_stmt_bind_param checks all

9997

We need to clear bind structure because mysql_stmt_bind_param checks all

9998

its members.

9999

*/

10000

bzero((char*) my_bind, sizeof(my_bind));

10000

memset((char*) my_bind, 0, sizeof(my_bind));

10001

10002

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

10003

my_bind[0].buffer= (void *)&param;

10144

check_stmt(stmt_insert);

10145

10146

/* bind parameters */

10147

bzero((char*) my_bind, sizeof(my_bind));

10147

memset((char*) my_bind, 0, sizeof(my_bind));

10148

10149

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

10150

my_bind[0].buffer= (void *)&my_val;

10190

stmt= mysql_simple_prepare(mysql, query);

10191

check_stmt(stmt);

10192

/*

10193

We need to bzero bind structure because mysql_stmt_bind_param checks all

10193

We need to clear bind structure because mysql_stmt_bind_param checks all

10194

its members.

10195

*/

10196

bzero((char*) my_bind, sizeof(my_bind));

10196

memset((char*) my_bind, 0, sizeof(my_bind));

10197

10198

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

10199

my_bind[0].buffer= (void *)&my_val;

10325

rc= mysql_real_query(mysql, stmt_text, strlen(stmt_text));

10326

myquery(rc);

10327

10328

bzero((char*) bind_array, sizeof(bind_array));

10328

memset((char*) bind_array, 0, sizeof(bind_array));

10329

10330

for (my_bind= bind_array; my_bind < bind_end; my_bind++)

10331

my_bind->error= &my_bind->error_value;

10534

10535

verify_param_count(stmt, 2);

10536

10537

bzero((char*) my_bind, sizeof(my_bind));

10537

memset((char*) my_bind, 0, sizeof(my_bind));

10538

10539

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

10540

my_bind[0].buffer= (void *)str_data;

10705

check_stmt(stmt);

10706

10707

/*

10708

We need to bzero bind structure because mysql_stmt_bind_param checks all

10708

We need to clear bind structure because mysql_stmt_bind_param checks all

10709

its members.

10710

*/

10711

bzero((char*) my_bind, sizeof(my_bind));

10711

memset((char*) my_bind, 0, sizeof(my_bind));

10712

10713

/* bind parameters */

10714

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

10775

rc= mysql_real_query(mysql, stmt_text, strlen(stmt_text));

10776

myquery(rc);

10777

10778

bzero((char*) bind_array, sizeof(bind_array));

10778

memset((char*) bind_array, 0, sizeof(bind_array));

10779

10780

bind_array[0].buffer_type= MYSQL_TYPE_STRING;

10781

bind_array[0].buffer= (void *) koi8;

10959

check_execute(stmt, rc);

10960

10961

/* Bind input buffers */

10962

bzero((char*) my_bind, sizeof(my_bind));

10962

memset((char*) my_bind, 0, sizeof(my_bind));

10963

10964

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

10965

my_bind[0].buffer= (void *) concat_arg0;

11026

check_execute(stmt, rc);

11027

11028

/* Bind input buffers */

11029

bzero((char*) my_bind, sizeof(my_bind));

11030

bzero((char*) &time_in, sizeof(time_in));

11031

bzero((char*) &time_out, sizeof(time_out));

11032

bzero((char*) &datetime_in, sizeof(datetime_in));

11033

bzero((char*) &datetime_out, sizeof(datetime_out));

11029

memset((char*) my_bind, 0, sizeof(my_bind));

11030

memset((char*) &time_in, 0, sizeof(time_in));

11031

memset((char*) &time_out, 0, sizeof(time_out));

11032

memset((char*) &datetime_in, 0, sizeof(datetime_in));

11033

memset((char*) &datetime_out, 0, sizeof(datetime_out));

11034

11035

my_bind[0].buffer_type= MYSQL_TYPE_TIME;

11036

my_bind[0].buffer= (void *) &time_in;

11108

check_execute(stmt, rc);

11109

11110

/* Bind input buffers */

11111

bzero((char*) my_bind, sizeof(my_bind));

11111

memset((char*) my_bind, 0, sizeof(my_bind));

11112

11113

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

11114

my_bind[0].buffer= (void *) &res;

11177

check_execute(stmt, rc);

11178

11179

/* Bind output buffers */

11180

bzero((char*) my_bind, sizeof(my_bind));

11181

bzero((char*) &time_canonical, sizeof(time_canonical));

11182

bzero((char*) &time_out, sizeof(time_out));

11183

bzero((char*) &date_canonical, sizeof(date_canonical));

11184

bzero((char*) &date_out, sizeof(date_out));

11185

bzero((char*) &datetime_canonical, sizeof(datetime_canonical));

11186

bzero((char*) &datetime_out, sizeof(datetime_out));

11180

memset((char*) my_bind, 0, sizeof(my_bind));

11181

memset((char*) &time_canonical, 0, sizeof(time_canonical));

11182

memset((char*) &time_out, 0, sizeof(time_out));

11183

memset((char*) &date_canonical, 0, sizeof(date_canonical));

11184

memset((char*) &date_out, 0, sizeof(date_out));

11185

memset((char*) &datetime_canonical, 0, sizeof(datetime_canonical));

11186

memset((char*) &datetime_out, 0, sizeof(datetime_out));

11187

11188

my_bind[0].buffer_type= MYSQL_TYPE_TIME;

11189

my_bind[0].buffer= (void *) &time_out;

11286

check_execute(stmt, rc);

11287

11288

strmov(str_data, "TEST");

11289

bzero((char*) my_bind, sizeof(my_bind));

11289

memset((char*) my_bind, 0, sizeof(my_bind));

11290

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

11291

my_bind[0].buffer= (char *)&str_data;

11292

my_bind[0].buffer_length= 50;

11407

" AENAME,T0001.DEPENDVARS AS DEPENDVARS,T0001.INACTIVE AS "

11408

" INACTIVE from LTDX T0001 where (T0001.SRTF2 = 0)");

11409

myquery(rc);

11410

bzero((char*) my_bind, sizeof(my_bind));

11410

memset((char*) my_bind, 0, sizeof(my_bind));

11411

for (i=0; i < 8; i++) {

11412

strmov(parms[i], "1");

11413

my_bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;

11457

myquery(rc);

11458

rc= mysql_query(mysql, "CREATE VIEW vt1 AS SELECT a FROM t1");

11459

myquery(rc);

11460

bzero((char*) my_bind, sizeof(my_bind));

11460

memset((char*) my_bind, 0, sizeof(my_bind));

11461

for (i= 0; i < 2; i++) {

11462

sprintf((char *)&parms[i], "%d", i);

11463

my_bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;

11524

rc= mysql_stmt_prepare(select_stmt, query, strlen(query));

11525

check_execute(select_stmt, rc);

11526

11527

bzero((char*) my_bind, sizeof(my_bind));

11527

memset((char*) my_bind, 0, sizeof(my_bind));

11528

my_bind[0].buffer_type = MYSQL_TYPE_LONG;

11529

my_bind[0].buffer = (char *)&my_val;

11530

my_bind[0].length = &my_length;

11631

" F7F8 AS F7F8, F6N4 AS F6N4, F5C8 AS F5C8, F9D8 AS F9D8"

11632

" from t1 T0001");

11633

11634

bzero((char*) my_bind, sizeof(my_bind));

11634

memset((char*) my_bind, 0, sizeof(my_bind));

11635

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

11636

{

11637

l[i]= 20;

11700

check_execute(stmt, rc);

11701

11702

/* Bind output buffers */

11703

bzero((char*) my_bind, sizeof(my_bind));

11703

memset((char*) my_bind, 0, sizeof(my_bind));

11704

11705

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

11706

my_bind[0].buffer= &c1;

11746

check_execute(stmt, rc);

11747

11748

/* Bind input buffers */

11749

bzero((char*) my_bind, sizeof(my_bind));

11750

bzero((char*) tm, sizeof(tm));

11749

memset((char*) my_bind, 0, sizeof(my_bind));

11750

memset((char*) tm, 0, sizeof(tm));

11751

11752

my_bind[0].buffer_type= MYSQL_TYPE_DATE;

11753

my_bind[0].buffer= &tm[0];

11797

Ascii 97 is 'a', which gets mapped to Ascii 65 'A' unless internal

11798

statement id hash in the server uses binary collation.

11799

*/

11800

#define NUM_OF_USED_STMT 97

11800

#define NUM_OF_USED_STMT 97

11801

MYSQL_STMT *stmt_list[NUM_OF_USED_STMT];

11802

MYSQL_STMT **stmt;

11803

MYSQL_BIND my_bind[1];

11807

11808

myheader("test_bug5399");

11809

11810

bzero((char*) my_bind, sizeof(my_bind));

11810

memset((char*) my_bind, 0, sizeof(my_bind));

11811

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

11812

my_bind[0].buffer= &no;

11813

11967

param_str_length= strlen(param_str);

11968

11969

/* setup bind array */

11970

bzero((char*) my_bind, MAX_PARAM_COUNT * sizeof(MYSQL_BIND));

11970

memset((char*) my_bind, 0, MAX_PARAM_COUNT * sizeof(MYSQL_BIND));

11971

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

11972

{

11973

my_bind[i].buffer_type= MYSQL_TYPE_FLOAT;

12094

rc= mysql_stmt_execute(stmt);

12095

check_execute(stmt, rc);

12096

12097

bzero((char*) my_bind, sizeof(my_bind));

12097

memset((char*) my_bind, 0, sizeof(my_bind));

12098

my_bind[0].buffer_type = MYSQL_TYPE_STRING;

12099

my_bind[0].buffer = &buffer;

12100

my_bind[0].buffer_length = sizeof(buffer);

12143

rc= mysql_stmt_execute(stmt);

12144

check_execute(stmt, rc);

12145

12146

bzero((char*) my_bind, sizeof(my_bind));

12146

memset((char*) my_bind, 0, sizeof(my_bind));

12147

my_bind[0].buffer_type = MYSQL_TYPE_STRING;

12148

my_bind[0].buffer = &buffer;

12149

my_bind[0].buffer_length = sizeof(buffer);

12211

check_execute(stmt, rc);

12212

12213

b= 1;

12214

bzero((char*) my_bind, sizeof(my_bind));

12214

memset((char*) my_bind, 0, sizeof(my_bind));

12215

my_bind[0].buffer= &b;

12216

my_bind[0].buffer_type= MYSQL_TYPE_SHORT;

12217

12414

12415

/* Bind and fetch the data */

12416

12417

bzero((char*) my_bind, sizeof(my_bind));

12417

memset((char*) my_bind, 0, sizeof(my_bind));

12418

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

12419

{

12420

my_bind[i].buffer_type= MYSQL_TYPE_STRING;

12469

check_stmt(stmt);

12470

verify_param_count(stmt, 6);

12471

12472

bzero((char*) my_bind, sizeof(my_bind));

12472

memset((char*) my_bind, 0, sizeof(my_bind));

12473

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

12474

{

12475

my_bind[i].buffer_type= MYSQL_TYPE_DATETIME;

12600

rc= mysql_stmt_execute(stmt);

12601

check_execute(stmt, rc);

12602

12603

bzero((char*) my_bind, sizeof(my_bind));

12603

memset((char*) my_bind, 0, sizeof(my_bind));

12604

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

12605

my_bind[0].buffer= f;

12606

my_bind[0].buffer_length= sizeof(f);

12667

rc= mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));

12668

check_execute(stmt, rc);

12669

12670

bzero((char*) my_bind, sizeof(my_bind));

12670

memset((char*) my_bind, 0, sizeof(my_bind));

12671

my_bind[0].buffer= buff;

12672

my_bind[0].length= &length;

12673

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

12730

rc= mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));

12731

check_execute(stmt, rc);

12732

12733

bzero((char*) &my_bind, sizeof(MYSQL_BIND));

12733

memset((char*) &my_bind, 0, sizeof(MYSQL_BIND));

12734

my_bind.buffer_type= MYSQL_TYPE_LONG;

12735

my_bind.buffer= (void *)&Data; /* this buffer won't be altered */

12736

my_bind.length= &length;

12760

while(!(rc= mysql_stmt_fetch(stmt)))

12761

if (!opt_silent)

12762

printf("fetched result after seek:%ld\n", Data);

12763

12764

DIE_UNLESS(rc == MYSQL_NO_DATA);

12765

12766

stmt_text= "DROP TABLE t1";

12828

12829

/*************** Fill in the bind structure and bind it **************/

12830

bind_array= malloc(sizeof(MYSQL_BIND) * bind_count);

12831

bzero((char*) bind_array, sizeof(MYSQL_BIND) * bind_count);

12831

memset((char*) bind_array, 0, sizeof(MYSQL_BIND) * bind_count);

12832

for (my_bind= bind_array; my_bind < bind_array + bind_count; my_bind++)

12833

my_bind->error= &my_bind->error_value;

12834

my_bind= bind_array;

13033

rc= mysql_stmt_execute(stmt);

13034

check_execute(stmt, rc);

13035

13036

bzero((char*) &my_bind, sizeof(my_bind));

13036

memset((char*) &my_bind, 0, sizeof(my_bind));

13037

13038

my_bind.buffer= (void*) &buf;

13039

my_bind.buffer_type= MYSQL_TYPE_TINY;

13108

rc= mysql_real_query(mysql, stmt_text, strlen(stmt_text));

13109

myquery(rc);

13110

13111

bzero((char*) my_bind, sizeof(my_bind));

13111

memset((char*) my_bind, 0, sizeof(my_bind));

13112

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

13113

{

13114

stmt[i]= mysql_stmt_init(mysql);

13351

DIE_UNLESS(memcmp(out, TEST_BUG8378_OUT, len) == 0);

13352

13353

sprintf(buf, "SELECT '%s'", out);

13354

13355

rc=mysql_real_query(lmysql, buf, strlen(buf));

13356

myquery(rc);

13357

13497

rc= mysql_stmt_execute(stmt);

13498

check_execute(stmt, rc);

13499

13500

bzero((char*) my_bind, sizeof(my_bind));

13500

memset((char*) my_bind, 0, sizeof(my_bind));

13501

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

13502

my_bind[0].buffer= (char*) a;

13503

my_bind[0].buffer_length= sizeof(a);

13547

13548

stmt= open_cursor("select name from t1 where id=2");

13549

13550

bzero((char*) my_bind, sizeof(my_bind));

13550

memset((char*) my_bind, 0, sizeof(my_bind));

13551

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

13552

my_bind[0].buffer= (char*) a;

13553

my_bind[0].buffer_length= sizeof(a);

13705

rc= mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));

13706

check_execute(stmt, rc);

13707

13708

bzero((char*) my_bind, sizeof(my_bind));

13708

memset((char*) my_bind, 0, sizeof(my_bind));

13709

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

13710

my_bind[0].buffer= (void*) &a;

13711

my_bind[0].buffer_length= sizeof(a);

13761

mysql_stmt_prepare(stmt, query, strlen(query));

13762

mysql_stmt_execute(stmt);

13763

13764

bzero((char*) my_bind, sizeof(my_bind));

13764

memset((char*) my_bind, 0, sizeof(my_bind));

13765

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

13766

{

13767

my_bind[i].buffer_type= MYSQL_TYPE_STRING;

13819

rc= mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));

13820

check_execute(stmt, rc);

13821

13822

bzero((char*) my_bind, sizeof(my_bind));

13822

memset((char*) my_bind, 0, sizeof(my_bind));

13823

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

13824

my_bind[0].buffer= (void*) a;

13825

my_bind[0].buffer_length= sizeof(a);

13929

rc= mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));

13930

check_execute(stmt, rc);

13931

13932

bzero((char*) my_bind, sizeof(my_bind));

13932

memset((char*) my_bind, 0, sizeof(my_bind));

13933

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

13934

my_bind[0].buffer= (void*) a;

13935

my_bind[0].buffer_length= sizeof(a);

13978

stmt_text= "insert into t1 (id, name) values (?, ?)";

13979

rc= mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));

13980

check_execute(stmt, rc);

13981

bzero((char*) my_bind, sizeof(my_bind));

13981

memset((char*) my_bind, 0, sizeof(my_bind));

13982

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

13983

my_bind[0].buffer= (void*) &id_val;

13984

my_bind[1].buffer_type= MYSQL_TYPE_STRING;

14000

mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);

14001

stmt1= mysql_stmt_init(mysql);

14002

mysql_stmt_attr_set(stmt1, STMT_ATTR_CURSOR_TYPE, (const void*) &type);

14003

bzero((char*) my_bind, sizeof(my_bind));

14003

memset((char*) my_bind, 0, sizeof(my_bind));

14004

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

14005

my_bind[0].buffer= (void*) a;

14006

my_bind[0].buffer_length= sizeof(a);

14073

type= (ulong) CURSOR_TYPE_READ_ONLY;

14074

mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);

14075

14076

bzero((char*) bind_in, sizeof(bind_in));

14077

bzero((char*) bind_out, sizeof(bind_out));

14078

bzero((char*) &hired, sizeof(hired));

14076

memset((char*) bind_in, 0, sizeof(bind_in));

14077

memset((char*) bind_out, 0, sizeof(bind_out));

14078

memset((char*) &hired, 0, sizeof(hired));

14079

hired.year= 1965;

14080

hired.month= 1;

14081

hired.day= 1;

14144

type= (ulong) CURSOR_TYPE_READ_ONLY;

14145

mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (const void*) &type);

14146

14147

bzero((char*) my_bind, sizeof(my_bind));

14147

memset((char*) my_bind, 0, sizeof(my_bind));

14148

strmov(buf[0], "pcint502_MY2");

14149

strmov(buf[1], "*");

14150

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

14409

rc= mysql_query(mysql, "alter table t1 engine=InnoDB");

14410

myquery(rc);

14411

14412

bzero(my_bind, sizeof(my_bind));

14412

memset(my_bind, 0, sizeof(my_bind));

14413

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

14414

my_bind[0].buffer= (void*) id_buf;

14415

my_bind[0].buffer_length= sizeof(id_buf);

14532

stmt1= open_cursor("SELECT empno, firstname, midinit, lastname,"

14533

"workdept, salary, bonus FROM t1");

14534

14535

bzero(my_bind, sizeof(my_bind));

14535

memset(my_bind, 0, sizeof(my_bind));

14536

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

14537

my_bind[0].buffer= (void*) &empno;

14538

14615

MYSQL_BIND my_bind[2]; */

14616

int rc;

14617

/* char workdept[20];

14618

ulong workdept_len;

14618

ulong workdept_len;

14619

uint32 empno; */

14620

const char *stmt_text;

14621

14704

" from (t1 left join t2 on t2.deptno = t1.workdept) "

14705

" where t1.empno = ?) "

14706

"order by 1");

14707

bzero(my_bind, sizeof(my_bind));

14707

memset(my_bind, 0, sizeof(my_bind));

14708

14709

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

14710

my_bind[0].buffer= &empno;

15606

DIE_UNLESS(res == 0);

15607

rc= mysql_query(mysql, "drop table t2");

15608

myquery(rc);

15609

15610

rc= mysql_query(mysql, "insert into t1 select null,'d'");

15611

myquery(rc);

15612

res= mysql_insert_id(mysql);

16685

16686

16687

/*

16688

Bug #29692 Single row inserts can incorrectly report a huge number of

16688

Bug #29692 Single row inserts can incorrectly report a huge number of

16689

row insertions

16690

*/

16691

17795

case 'T':

17796

{

17797

struct my_tests_st *fptr;

17798

17799

printf("All possible test names:\n\n");

17800

for (fptr= my_tests; fptr->name; fptr++)

17801

printf("%s\n", fptr->name);

17874

if (!argc)

17875

{

17876

for (fptr= my_tests; fptr->name; fptr++)

17877

(*fptr->function)();

17877

(*fptr->function)();

17878

}

17879

else

17880

{