~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

const char *query= "SELECT (SELECT SUM(a+b) FROM t2 where t1.b=t2.b GROUP BY t1.a LIMIT 1) as scalar_s, exists (select 1 from t2 where t2.a/2=t1.a) as exists_s, a in (select a+3 from t2) as in_s, (a-1, b-1) in (select a, b from t2) as in_row_s FROM t1, (select a x, b y from t2) tt WHERE x=a";

9437

9438

myheader("test_subqueries");

9439

9440

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");

9441

myquery(rc);

9442

9443

rc= mysql_query(mysql, "CREATE TABLE t1 (a int , b int);");

9444

myquery(rc);

9445

9446

rc= mysql_query(mysql,

9447

"insert into t1 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5);");

9448

myquery(rc);

9449

9450

rc= mysql_query(mysql, "create table t2 select * from t1;");

9451

myquery(rc);

9452

9453

stmt= mysql_simple_prepare(mysql, query);

9454

check_stmt(stmt);

9455

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

9456

{

9457

rc= mysql_stmt_execute(stmt);

9458

check_execute(stmt, rc);

9459

rc= my_process_stmt_result(stmt);

9460

DIE_UNLESS(rc == 5);

9461

}

9462

mysql_stmt_close(stmt);

9463

9464

rc= mysql_query(mysql, "DROP TABLE t1, t2");

9465

myquery(rc);

9466

}

9467

9468

9469

static void test_bad_union()

9470

{

9471

MYSQL_STMT *stmt;

9472

const char *query= "SELECT 1, 2 union SELECT 1";

9473

9474

myheader("test_bad_union");

9475

9476

stmt= mysql_simple_prepare(mysql, query);

9477

DIE_UNLESS(stmt == 0);

9478

myerror(NULL);

9479

}

9480

9481

9482

static void test_distinct()

9483

{

9484

MYSQL_STMT *stmt;

9485

int rc, i;

9486

const char *query=

9487

"SELECT 2+count(distinct b), group_concat(a) FROM t1 group by a";

9488

9489

myheader("test_distinct");

9490

9491

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

9492

myquery(rc);

9493

9494

rc= mysql_query(mysql, "CREATE TABLE t1 (a int , b int);");

9495

myquery(rc);

9496

9497

rc= mysql_query(mysql,

9498

"insert into t1 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), \

9499

(1, 10), (2, 20), (3, 30), (4, 40), (5, 50);");

9500

myquery(rc);

9501

9502

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

9503

{

9504

stmt= mysql_simple_prepare(mysql, query);

9505

check_stmt(stmt);

9506

rc= mysql_stmt_execute(stmt);

9507

check_execute(stmt, rc);

9508

rc= my_process_stmt_result(stmt);

9509

DIE_UNLESS(rc == 5);

9510

mysql_stmt_close(stmt);

9511

}

9512

9513

rc= mysql_query(mysql, "DROP TABLE t1");

9514

myquery(rc);

9515

}

9516

9517

9518

9519

Test for bug#2248 "mysql_fetch without prior mysql_stmt_execute hangs"

9520

9521

9522

static void test_bug2248()

9523

{

9524

MYSQL_STMT *stmt;

9525

int rc;

9526

const char *query1= "SELECT DATABASE()";

9527

const char *query2= "INSERT INTO test_bug2248 VALUES (10)";

9528

9529

myheader("test_bug2248");

9530

9531

rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bug2248");

9532

myquery(rc);

9533

9534

rc= mysql_query(mysql, "CREATE TABLE test_bug2248 (id int)");

9535

myquery(rc);

9536

9537

stmt= mysql_simple_prepare(mysql, query1);

9538

check_stmt(stmt);

9539

9540

/* This should not hang */

9541

rc= mysql_stmt_fetch(stmt);

9542

check_execute_r(stmt, rc);

9543

9544

/* And this too */

9545

rc= mysql_stmt_store_result(stmt);

9546

check_execute_r(stmt, rc);

9547

9548

mysql_stmt_close(stmt);

9549

9550

stmt= mysql_simple_prepare(mysql, query2);

9551

check_stmt(stmt);

9552

9553

rc= mysql_stmt_execute(stmt);

9554

check_execute(stmt, rc);

9555

9556

/* This too should not hang but should return proper error */

9557

rc= mysql_stmt_fetch(stmt);

9558

DIE_UNLESS(rc == 1);

9559

9560

/* This too should not hang but should not bark */

9561

rc= mysql_stmt_store_result(stmt);

9562

check_execute(stmt, rc);

9563

9564

/* This should return proper error */

9565

rc= mysql_stmt_fetch(stmt);

9566

check_execute_r(stmt, rc);

9567

DIE_UNLESS(rc == 1);

9568

9569

mysql_stmt_close(stmt);

9570

9571

rc= mysql_query(mysql, "DROP TABLE test_bug2248");

9572

myquery(rc);

9573

}

9574

9575

9576

static void test_subqueries_ref()

9577

{

9578

MYSQL_STMT *stmt;

9579

int rc, i;

9580

const char *query= "SELECT a as ccc from t1 outr where a+1=(SELECT 1+outr.a from t1 where outr.a+1=a+1 and a=1)";

9581

9582

myheader("test_subqueries_ref");

9583

9584

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

9585

myquery(rc);

9586

9587

rc= mysql_query(mysql, "CREATE TABLE t1 (a int);");

9588

myquery(rc);

9589

9590

rc= mysql_query(mysql,

9591

"insert into t1 values (1), (2), (3), (4), (5);");

9592

myquery(rc);

9593

9594

stmt= mysql_simple_prepare(mysql, query);

9595

check_stmt(stmt);

9596

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

9597

{

9598

rc= mysql_stmt_execute(stmt);

9599

check_execute(stmt, rc);

9600

rc= my_process_stmt_result(stmt);

9601

DIE_UNLESS(rc == 1);

9602

}

9603

mysql_stmt_close(stmt);

9604

9605

rc= mysql_query(mysql, "DROP TABLE t1");

9606

myquery(rc);

9607

}

9608

9609

9610

static void test_union()

9611

{

9612

MYSQL_STMT *stmt;

9613

int rc;

9614

9615

myheader("test_union");

9616

9617

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");

9618

myquery(rc);

9619

9620

rc= mysql_query(mysql,

9621

"CREATE TABLE t1 "

9622

"(id INTEGER NOT NULL PRIMARY KEY, "

9623

" name VARCHAR(20) NOT NULL)");

9624

myquery(rc);

9625

rc= mysql_query(mysql,

9626

"INSERT INTO t1 (id, name) VALUES "

9627

"(2, 'Ja'), (3, 'Ede'), "

9628

"(4, 'Haag'), (5, 'Kabul'), "

9629

"(6, 'Almere'), (7, 'Utrecht'), "

9630

"(8, 'Qandahar'), (9, 'Amsterdam'), "

9631

"(10, 'Amersfoort'), (11, 'Constantine')");

9632

myquery(rc);

9633

rc= mysql_query(mysql,

9634

"CREATE TABLE t2 "

9635

"(id INTEGER NOT NULL PRIMARY KEY, "

9636

" name VARCHAR(20) NOT NULL)");

9637

myquery(rc);

9638

rc= mysql_query(mysql,

9639

"INSERT INTO t2 (id, name) VALUES "

9640

"(4, 'Guam'), (5, 'Aruba'), "

9641

"(6, 'Angola'), (7, 'Albania'), "

9642

"(8, 'Anguilla'), (9, 'Argentina'), "

9643

"(10, 'Azerbaijan'), (11, 'Afghanistan'), "

9644

"(12, 'Burkina Faso'), (13, 'Faroe Islands')");

9645

myquery(rc);

9646

9647

stmt= mysql_simple_prepare(mysql,

9648

"SELECT t1.name FROM t1 UNION "

9649

"SELECT t2.name FROM t2");

9650

check_stmt(stmt);

9651

9652

rc= mysql_stmt_execute(stmt);

9653

check_execute(stmt, rc);

9654

rc= my_process_stmt_result(stmt);

9655

DIE_UNLESS(rc == 20);

9656

mysql_stmt_close(stmt);

9657

9658

rc= mysql_query(mysql, "DROP TABLE t1, t2");

9659

myquery(rc);

9660

}

9661

9662

9663

static void test_bug3117()

9664

{

9665

MYSQL_STMT *stmt;

9666

MYSQL_BIND buffer;

9667

longlong lii;

9668

ulong length;

9669

my_bool is_null;

9670

int rc;

9671

9672

myheader("test_bug3117");

9673

9674

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

9675

myquery(rc);

9676

9677

rc= mysql_query(mysql, "CREATE TABLE t1 (id int auto_increment primary key)");

9678

myquery(rc);

9679

9680

stmt= mysql_simple_prepare(mysql, "SELECT LAST_INSERT_ID()");

9681

check_stmt(stmt);

9682

9683

rc= mysql_query(mysql, "INSERT INTO t1 VALUES (NULL)");

9684

myquery(rc);

9685

9686

rc= mysql_stmt_execute(stmt);

9687

check_execute(stmt, rc);

9688

9689

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

9690

buffer.buffer_type= MYSQL_TYPE_LONGLONG;

9691

buffer.buffer_length= sizeof(lii);

9692

buffer.buffer= (void *)&lii;

9693

buffer.length= &length;

9694

buffer.is_null= &is_null;

9695

9696

rc= mysql_stmt_bind_result(stmt, &buffer);

9697

check_execute(stmt, rc);

9698

9699

rc= mysql_stmt_store_result(stmt);

9700

check_execute(stmt, rc);

9701

9702

rc= mysql_stmt_fetch(stmt);

9703

check_execute(stmt, rc);

9704

9705

DIE_UNLESS(is_null == 0 && lii == 1);

9706

if (!opt_silent)

9707

fprintf(stdout, "\n\tLAST_INSERT_ID()= 1 ok\n");

9708

9709

rc= mysql_query(mysql, "INSERT INTO t1 VALUES (NULL)");

9710

myquery(rc);

9711

9712

rc= mysql_stmt_execute(stmt);

9713

check_execute(stmt, rc);

9714

9715

rc= mysql_stmt_fetch(stmt);

9716

check_execute(stmt, rc);

9717

9718

DIE_UNLESS(is_null == 0 && lii == 2);

9719

if (!opt_silent)

9720

fprintf(stdout, "\tLAST_INSERT_ID()= 2 ok\n");

9721

9722

mysql_stmt_close(stmt);

9723

9724

rc= mysql_query(mysql, "DROP TABLE t1");

9725

myquery(rc);

9726

}

9727

9728

9729

static void test_join()

9730

{

9731

MYSQL_STMT *stmt;

9732

int rc, i, j;

9733

const char *query[]= {"SELECT * FROM t2 join t1 on (t1.a=t2.a)",

9734

"SELECT * FROM t2 natural join t1",

9735

"SELECT * FROM t2 join t1 using(a)",

9736

"SELECT * FROM t2 left join t1 on(t1.a=t2.a)",

9737

"SELECT * FROM t2 natural left join t1",

9738

"SELECT * FROM t2 left join t1 using(a)",

9739

"SELECT * FROM t2 right join t1 on(t1.a=t2.a)",

9740

"SELECT * FROM t2 natural right join t1",

9741

"SELECT * FROM t2 right join t1 using(a)"};

9742

9743

myheader("test_join");

9744

9745

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");

9746

myquery(rc);

9747

9748

rc= mysql_query(mysql, "CREATE TABLE t1 (a int , b int);");

9749

myquery(rc);

9750

9751

rc= mysql_query(mysql,

9752

"insert into t1 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5);");

9753

myquery(rc);

9754

9755

rc= mysql_query(mysql, "CREATE TABLE t2 (a int , c int);");

9756

myquery(rc);

9757

9758

rc= mysql_query(mysql,

9759

"insert into t2 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5);");

9760

myquery(rc);

9761

9762

for (j= 0; j < 9; j++)

9763

{

9764

stmt= mysql_simple_prepare(mysql, query[j]);

9765

check_stmt(stmt);

9766

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

9767

{

9768

rc= mysql_stmt_execute(stmt);

9769

check_execute(stmt, rc);

9770

rc= my_process_stmt_result(stmt);

9771

DIE_UNLESS(rc == 5);

9772

}

9773

mysql_stmt_close(stmt);

9774

}

9775

9776

rc= mysql_query(mysql, "DROP TABLE t1, t2");

9777

myquery(rc);

9778

}

9779

9780

9781

static void test_selecttmp()

9782

{

9783

MYSQL_STMT *stmt;

9784

int rc, i;

9785

const char *query= "select a, (select count(distinct t1.b) as sum from t1, t2 where t1.a=t2.a and t2.b > 0 and t1.a <= t3.b group by t1.a order by sum limit 1) from t3";

9786

9787

myheader("test_select_tmp");

9788

9789

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2, t3");

9790

myquery(rc);

9791

9792

rc= mysql_query(mysql, "CREATE TABLE t1 (a int , b int);");

9793

myquery(rc);

9794

9795

rc= mysql_query(mysql, "create table t2 (a int, b int);");

9796

myquery(rc);

9797

9798

rc= mysql_query(mysql, "create table t3 (a int, b int);");

9799

myquery(rc);

9800

9801

rc= mysql_query(mysql,

9802

"insert into t1 values (0, 100), (1, 2), (1, 3), (2, 2), (2, 7), \

9803

(2, -1), (3, 10);");

9804

myquery(rc);

9805

rc= mysql_query(mysql,

9806

"insert into t2 values (0, 0), (1, 1), (2, 1), (3, 1), (4, 1);");

9807

myquery(rc);

9808

rc= mysql_query(mysql,

9809

"insert into t3 values (3, 3), (2, 2), (1, 1);");

9810

myquery(rc);

9811

9812

stmt= mysql_simple_prepare(mysql, query);

9813

check_stmt(stmt);

9814

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

9815

{

9816

rc= mysql_stmt_execute(stmt);

9817

check_execute(stmt, rc);

9818

rc= my_process_stmt_result(stmt);

9819

DIE_UNLESS(rc == 3);

9820

}

9821

mysql_stmt_close(stmt);

9822

9823

rc= mysql_query(mysql, "DROP TABLE t1, t2, t3");

9824

myquery(rc);

9825

}

9826

9827

9828

static void test_create_drop()

9829

{

9830

MYSQL_STMT *stmt_create, *stmt_drop, *stmt_select, *stmt_create_select;

9831

char *query;

9832

int rc, i;

9833

myheader("test_table_manipulation");

9834

9835

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");

9836

myquery(rc);

9837

9838

rc= mysql_query(mysql, "create table t2 (a int);");

9839

myquery(rc);

9840

9841

rc= mysql_query(mysql, "create table t1 (a int);");

9842

myquery(rc);

9843

9844

rc= mysql_query(mysql, "insert into t2 values (3), (2), (1);");

9845

myquery(rc);

9846

9847

query= (char*)"create table t1 (a int)";

9848

stmt_create= mysql_simple_prepare(mysql, query);

9849

check_stmt(stmt_create);

9850

9851

query= (char*)"drop table t1";

9852

stmt_drop= mysql_simple_prepare(mysql, query);

9853

check_stmt(stmt_drop);

9854

9855

query= (char*)"select a in (select a from t2) from t1";

9856

stmt_select= mysql_simple_prepare(mysql, query);

9857

check_stmt(stmt_select);

9858

9859

rc= mysql_query(mysql, "DROP TABLE t1");

9860

myquery(rc);

9861

9862

query= (char*)"create table t1 select a from t2";

9863

stmt_create_select= mysql_simple_prepare(mysql, query);

9864

check_stmt(stmt_create_select);

9865

9866

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

9867

{

9868

rc= mysql_stmt_execute(stmt_create);

9869

check_execute(stmt_create, rc);

9870

if (!opt_silent)

9871

fprintf(stdout, "created %i\n", i);

9872

9873

rc= mysql_stmt_execute(stmt_select);

9874

check_execute(stmt_select, rc);

9875

rc= my_process_stmt_result(stmt_select);

9876

DIE_UNLESS(rc == 0);

9877

9878

rc= mysql_stmt_execute(stmt_drop);

9879

check_execute(stmt_drop, rc);

9880

if (!opt_silent)

9881

fprintf(stdout, "dropped %i\n", i);

9882

9883

rc= mysql_stmt_execute(stmt_create_select);

9884

check_execute(stmt_create, rc);

9885

if (!opt_silent)

9886

fprintf(stdout, "created select %i\n", i);

9887

9888

rc= mysql_stmt_execute(stmt_select);

9889

check_execute(stmt_select, rc);

9890

rc= my_process_stmt_result(stmt_select);

9891

DIE_UNLESS(rc == 3);

9892

9893

rc= mysql_stmt_execute(stmt_drop);

9894

check_execute(stmt_drop, rc);

9895

if (!opt_silent)

9896

fprintf(stdout, "dropped %i\n", i);

9897

}

9898

9899

mysql_stmt_close(stmt_create);

9900

mysql_stmt_close(stmt_drop);

9901

mysql_stmt_close(stmt_select);

9902

mysql_stmt_close(stmt_create_select);

9903

9904

rc= mysql_query(mysql, "DROP TABLE t2");

9905

myquery(rc);

9906

}

9907

9908

9909

static void test_rename()

9910

{

9911

MYSQL_STMT *stmt;

9912

const char *query= "rename table t1 to t2, t3 to t4";

9913

int rc;

9914

myheader("test_table_rename");

9915

9916

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2, t3, t4");

9917

myquery(rc);

9918

9919

stmt= mysql_simple_prepare(mysql, query);

9920

check_stmt(stmt);

9921

9922

rc= mysql_query(mysql, "create table t1 (a int)");

9923

myquery(rc);

9924

9925

rc= mysql_stmt_execute(stmt);

9926

check_execute_r(stmt, rc);

9927

if (!opt_silent)

9928

fprintf(stdout, "rename without t3\n");

9929

9930

rc= mysql_query(mysql, "create table t3 (a int)");

9931

myquery(rc);

9932

9933

rc= mysql_stmt_execute(stmt);

9934

check_execute(stmt, rc);

9935

if (!opt_silent)

9936

fprintf(stdout, "rename with t3\n");

9937

9938

rc= mysql_stmt_execute(stmt);

9939

check_execute_r(stmt, rc);

9940

if (!opt_silent)

9941

fprintf(stdout, "rename renamed\n");

9942

9943

rc= mysql_query(mysql, "rename table t2 to t1, t4 to t3");

9944

myquery(rc);

9945

9946

rc= mysql_stmt_execute(stmt);

9947

check_execute(stmt, rc);

9948

if (!opt_silent)

9949

fprintf(stdout, "rename reverted\n");

9950

9951

mysql_stmt_close(stmt);

9952

9953

rc= mysql_query(mysql, "DROP TABLE t2, t4");

9954

myquery(rc);

9955

}

9956

9957

9958

static void test_do_set()

9959

{

9960

MYSQL_STMT *stmt_do, *stmt_set;

9961

char *query;

9962

int rc, i;

9963

myheader("test_do_set");

9964

9965

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

9966

myquery(rc);

9967

9968

rc= mysql_query(mysql, "create table t1 (a int)");

9969

myquery(rc);

9970

9971

query= (char*)"do @var:=(1 in (select * from t1))";

9972

stmt_do= mysql_simple_prepare(mysql, query);

9973

check_stmt(stmt_do);

9974

9975

query= (char*)"set @var=(1 in (select * from t1))";

9976

stmt_set= mysql_simple_prepare(mysql, query);

9977

check_stmt(stmt_set);

9978

9979

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

9980

{

9981

rc= mysql_stmt_execute(stmt_do);

9982

check_execute(stmt_do, rc);

9983

if (!opt_silent)

9984

fprintf(stdout, "do %i\n", i);

9985

rc= mysql_stmt_execute(stmt_set);

9986

check_execute(stmt_set, rc);

9987

if (!opt_silent)

9988

fprintf(stdout, "set %i\n", i);

9989

}

9990

9991

mysql_stmt_close(stmt_do);

9992

mysql_stmt_close(stmt_set);

9993

}

9994

9995

9996

static void test_multi()

9997

{

9998

MYSQL_STMT *stmt_delete, *stmt_update, *stmt_select1, *stmt_select2;

9999

char *query;

10000

MYSQL_BIND my_bind[1];

10001

int rc, i;

10002

int32 param= 1;

10003

ulong length= 1;

10004

myheader("test_multi");

10005

10006

10007

We need to bzero bind structure because mysql_stmt_bind_param checks all

10008

its members.

10009

10010

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

10011

10012

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

10013

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

10014

my_bind[0].length= &length;

10015

10016

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");

10017

myquery(rc);

10018

10019

rc= mysql_query(mysql, "create table t1 (a int, b int)");

10020

myquery(rc);

10021

10022

rc= mysql_query(mysql, "create table t2 (a int, b int)");

10023

myquery(rc);

10024

10025

rc= mysql_query(mysql, "insert into t1 values (3, 3), (2, 2), (1, 1)");

10026

myquery(rc);

10027

10028

rc= mysql_query(mysql, "insert into t2 values (3, 3), (2, 2), (1, 1)");

10029

myquery(rc);

10030

10031

query= (char*)"delete t1, t2 from t1, t2 where t1.a=t2.a and t1.b=10";

10032

stmt_delete= mysql_simple_prepare(mysql, query);

10033

check_stmt(stmt_delete);

10034

10035

query= (char*)"update t1, t2 set t1.b=10, t2.b=10 where t1.a=t2.a and t1.b=?";

10036

stmt_update= mysql_simple_prepare(mysql, query);

10037

check_stmt(stmt_update);

10038

10039

query= (char*)"select * from t1";

10040

stmt_select1= mysql_simple_prepare(mysql, query);

10041

check_stmt(stmt_select1);

10042

10043

query= (char*)"select * from t2";

10044

stmt_select2= mysql_simple_prepare(mysql, query);

10045

check_stmt(stmt_select2);

10046

10047

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

10048

{

10049

rc= mysql_stmt_bind_param(stmt_update, my_bind);

10050

check_execute(stmt_update, rc);

10051

10052

rc= mysql_stmt_execute(stmt_update);

10053

check_execute(stmt_update, rc);

10054

if (!opt_silent)

10055

fprintf(stdout, "update %ld\n", (long) param);

10056

10057

rc= mysql_stmt_execute(stmt_delete);

10058

check_execute(stmt_delete, rc);

10059

if (!opt_silent)

10060

fprintf(stdout, "delete %ld\n", (long) param);

10061

10062

rc= mysql_stmt_execute(stmt_select1);

10063

check_execute(stmt_select1, rc);

10064

rc= my_process_stmt_result(stmt_select1);

10065

DIE_UNLESS(rc == 3-param);

10066

10067

rc= mysql_stmt_execute(stmt_select2);

10068

check_execute(stmt_select2, rc);

10069

rc= my_process_stmt_result(stmt_select2);

10070

DIE_UNLESS(rc == 3-param);

10071

10072

param++;

10073

}

10074

10075

mysql_stmt_close(stmt_delete);

10076

mysql_stmt_close(stmt_update);

10077

mysql_stmt_close(stmt_select1);

10078

mysql_stmt_close(stmt_select2);

10079

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

10080

myquery(rc);

10081

}

10082

10083

10084

static void test_insert_select()

10085

{

10086

MYSQL_STMT *stmt_insert, *stmt_select;

10087

char *query;

10088

int rc;

10089

uint i;

10090

myheader("test_insert_select");

10091

10092

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2");

10093

myquery(rc);

10094

10095

rc= mysql_query(mysql, "create table t1 (a int)");

10096

myquery(rc);

10097

10098

rc= mysql_query(mysql, "create table t2 (a int)");

10099

myquery(rc);

10100

10101

rc= mysql_query(mysql, "insert into t2 values (1)");

10102

myquery(rc);

10103

10104

query= (char*)"insert into t1 select a from t2";

10105

stmt_insert= mysql_simple_prepare(mysql, query);

10106

check_stmt(stmt_insert);

10107

10108

query= (char*)"select * from t1";

10109

stmt_select= mysql_simple_prepare(mysql, query);

10110

check_stmt(stmt_select);

10111

10112

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

10113

{

10114

rc= mysql_stmt_execute(stmt_insert);

10115

check_execute(stmt_insert, rc);

10116

if (!opt_silent)

10117

fprintf(stdout, "insert %u\n", i);

10118

10119

rc= mysql_stmt_execute(stmt_select);

10120

check_execute(stmt_select, rc);

10121

rc= my_process_stmt_result(stmt_select);

10122

DIE_UNLESS(rc == (int)(i+1));

10123

}

10124

10125

mysql_stmt_close(stmt_insert);

10126

mysql_stmt_close(stmt_select);

10127

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

10128

myquery(rc);

10129

}

10130

10131

10132

static void test_bind_nagative()

10133

{

10134

MYSQL_STMT *stmt_insert;

10135

char *query;

10136

int rc;

10137

MYSQL_BIND my_bind[1];

10138

int32 my_val= 0;

10139

ulong my_length= 0L;

10140

my_bool my_null= FALSE;

10141

myheader("test_insert_select");

10142

10143

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

10144

myquery(rc);

10145

10146

rc= mysql_query(mysql, "create temporary table t1 (c1 int unsigned)");

10147

myquery(rc);

10148

10149

rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1), (-1)");

10150

myquery(rc);

10151

10152

query= (char*)"INSERT INTO t1 VALUES (?)";

10153

stmt_insert= mysql_simple_prepare(mysql, query);

10154

check_stmt(stmt_insert);

10155

10156

/* bind parameters */

10157

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

10158

10159

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

10160

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

10161

my_bind[0].length= &my_length;

10162

my_bind[0].is_null= (char*)&my_null;

10163

10164

rc= mysql_stmt_bind_param(stmt_insert, my_bind);

10165

check_execute(stmt_insert, rc);

10166

10167

my_val= -1;

10168

rc= mysql_stmt_execute(stmt_insert);

10169

check_execute(stmt_insert, rc);

10170

10171

mysql_stmt_close(stmt_insert);

10172

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

10173

myquery(rc);

10174

}

10175

10176

10177

static void test_derived()

10178

{

10179

MYSQL_STMT *stmt;

10180

int rc, i;

10181

MYSQL_BIND my_bind[1];

10182

int32 my_val= 0;

10183

ulong my_length= 0L;

10184

my_bool my_null= FALSE;

10185

const char *query=

10186

"select count(1) from (select f.id from t1 f where f.id=?) as x";

10187

10188

myheader("test_derived");

10189

10190

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

10191

myquery(rc);

10192

10193

rc= mysql_query(mysql, "create table t1 (id int(8), primary key (id)) \

10194

ENGINE=InnoDB DEFAULT CHARSET=utf8");

10195

myquery(rc);

10196

10197

rc= mysql_query(mysql, "insert into t1 values (1)");

10198

myquery(rc);

10199

10200

stmt= mysql_simple_prepare(mysql, query);

10201

check_stmt(stmt);

10202

10203

We need to bzero bind structure because mysql_stmt_bind_param checks all

10204

its members.

10205

10206

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

10207

10208

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

10209

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

10210

my_bind[0].length= &my_length;

10211

my_bind[0].is_null= (char*)&my_null;

10212

my_val= 1;

10213

rc= mysql_stmt_bind_param(stmt, my_bind);

10214

check_execute(stmt, rc);

10215

10216

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

10217

{

10218

rc= mysql_stmt_execute(stmt);

10219

check_execute(stmt, rc);

10220

rc= my_process_stmt_result(stmt);

10221

DIE_UNLESS(rc == 1);

10222

}

10223

mysql_stmt_close(stmt);

10224

10225

rc= mysql_query(mysql, "DROP TABLE t1");

10226

myquery(rc);

10227

}

10228

10229

10230

static void test_xjoin()

10231

{

10232

MYSQL_STMT *stmt;

10233

int rc, i;

10234

const char *query=

10235

"select t.id, p1.value, n1.value, p2.value, n2.value from t3 t LEFT JOIN t1 p1 ON (p1.id=t.param1_id) LEFT JOIN t2 p2 ON (p2.id=t.param2_id) LEFT JOIN t4 n1 ON (n1.id=p1.name_id) LEFT JOIN t4 n2 ON (n2.id=p2.name_id) where t.id=1";

10236

10237

myheader("test_xjoin");

10238

10239

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, t2, t3, t4");

10240

myquery(rc);

10241

10242

rc= mysql_query(mysql, "create table t3 (id int(8), param1_id int(8), param2_id int(8)) ENGINE=InnoDB DEFAULT CHARSET=utf8");

10243

myquery(rc);

10244

10245

rc= mysql_query(mysql, "create table t1 ( id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8");

10246

myquery(rc);

10247

10248

rc= mysql_query(mysql, "create table t2 (id int(8), name_id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8;");

10249

myquery(rc);

10250

10251

rc= mysql_query(mysql, "create table t4(id int(8), value varchar(10)) ENGINE=InnoDB DEFAULT CHARSET=utf8");

10252

myquery(rc);

10253

10254

rc= mysql_query(mysql, "insert into t3 values (1, 1, 1), (2, 2, null)");

10255

myquery(rc);

10256

10257

rc= mysql_query(mysql, "insert into t1 values (1, 1, 'aaa'), (2, null, 'bbb')");

10258

myquery(rc);

10259

10260

rc= mysql_query(mysql, "insert into t2 values (1, 2, 'ccc')");

10261

myquery(rc);

10262

10263

rc= mysql_query(mysql, "insert into t4 values (1, 'Name1'), (2, null)");

10264

myquery(rc);

10265

10266

stmt= mysql_simple_prepare(mysql, query);

10267

check_stmt(stmt);

10268

10269

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

10270

{

10271

rc= mysql_stmt_execute(stmt);

10272

check_execute(stmt, rc);

10273

rc= my_process_stmt_result(stmt);

10274

DIE_UNLESS(rc == 1);

10275

}

10276

mysql_stmt_close(stmt);

10277

10278

rc= mysql_query(mysql, "DROP TABLE t1, t2, t3, t4");

10279

myquery(rc);

10280

}

10281

10282

10283

static void test_bug3035()

10284

{

10285

MYSQL_STMT *stmt;

10286

int rc;

10287

MYSQL_BIND bind_array[12], *my_bind= bind_array, *bind_end= my_bind + 12;

10288

int8 int8_val;

10289

uint8 uint8_val;

10290

int16 int16_val;

10291

uint16 uint16_val;

10292

int32 int32_val;

10293

uint32 uint32_val;

10294

longlong int64_val;

10295

ulonglong uint64_val;

10296

double double_val, udouble_val, double_tmp;

10297

char longlong_as_string[22], ulonglong_as_string[22];

10298

10299

/* mins and maxes */

10300

const int8 int8_min= -128;

10301

const int8 int8_max= 127;

10302

const uint8 uint8_min= 0;

10303

const uint8 uint8_max= 255;

10304

10305

const int16 int16_min= -32768;

10306

const int16 int16_max= 32767;

10307

const uint16 uint16_min= 0;

10308

const uint16 uint16_max= 65535;

10309

10310

const int32 int32_max= 2147483647L;

10311

const int32 int32_min= -int32_max - 1;

10312

const uint32 uint32_min= 0;

10313

const uint32 uint32_max= 4294967295U;

10314

10315

/* it might not work okay everyplace */

10316

const longlong int64_max= LL(9223372036854775807);

10317

const longlong int64_min= -int64_max - 1;

10318

10319

const ulonglong uint64_min= 0U;

10320

const ulonglong uint64_max= ULL(18446744073709551615);

10321

10322

const char *stmt_text;

10323

10324

myheader("test_bug3035");

10325

10326

stmt_text= "DROP TABLE IF EXISTS t1";

10327

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

10328

myquery(rc);

10329

10330

stmt_text= "CREATE TABLE t1 (i8 TINYINT, ui8 TINYINT UNSIGNED, "

10331

"i16 SMALLINT, ui16 SMALLINT UNSIGNED, "

10332

"i32 INT, ui32 INT UNSIGNED, "

10333

"i64 BIGINT, ui64 BIGINT UNSIGNED, "

10334

"id INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT)";

10335

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

10336

myquery(rc);

10337

10338

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

10339

10340

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

10341

my_bind->error= &my_bind->error_value;

10342

10343

bind_array[0].buffer_type= MYSQL_TYPE_TINY;

10344

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

10345

10346

bind_array[1].buffer_type= MYSQL_TYPE_TINY;

10347

bind_array[1].buffer= (void *) &uint8_val;

10348

bind_array[1].is_unsigned= 1;

10349

10350

bind_array[2].buffer_type= MYSQL_TYPE_SHORT;

10351

bind_array[2].buffer= (void *) &int16_val;

10352

10353

bind_array[3].buffer_type= MYSQL_TYPE_SHORT;

10354

bind_array[3].buffer= (void *) &uint16_val;

10355

bind_array[3].is_unsigned= 1;

10356

10357

bind_array[4].buffer_type= MYSQL_TYPE_LONG;

10358

bind_array[4].buffer= (void *) &int32_val;

10359

10360

bind_array[5].buffer_type= MYSQL_TYPE_LONG;

10361

bind_array[5].buffer= (void *) &uint32_val;

10362

bind_array[5].is_unsigned= 1;

10363

10364

bind_array[6].buffer_type= MYSQL_TYPE_LONGLONG;

10365

bind_array[6].buffer= (void *) &int64_val;

10366

10367

bind_array[7].buffer_type= MYSQL_TYPE_LONGLONG;

10368

bind_array[7].buffer= (void *) &uint64_val;

10369

bind_array[7].is_unsigned= 1;

10370

10371

stmt= mysql_stmt_init(mysql);

10372

check_stmt(stmt);

10373

10374

stmt_text= "INSERT INTO t1 (i8, ui8, i16, ui16, i32, ui32, i64, ui64) "

10375

"VALUES (?, ?, ?, ?, ?, ?, ?, ?)";

10376

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

10377

check_execute(stmt, rc);

10378

10379

mysql_stmt_bind_param(stmt, bind_array);

10380

10381

int8_val= int8_min;

10382

uint8_val= uint8_min;

10383

int16_val= int16_min;

10384

uint16_val= uint16_min;

10385

int32_val= int32_min;

10386

uint32_val= uint32_min;

10387

int64_val= int64_min;

10388

uint64_val= uint64_min;

10389

10390

rc= mysql_stmt_execute(stmt);

10391

check_execute(stmt, rc);

10392

10393

int8_val= int8_max;

10394

uint8_val= uint8_max;

10395

int16_val= int16_max;

10396

uint16_val= uint16_max;

10397

int32_val= int32_max;

10398

uint32_val= uint32_max;

10399

int64_val= int64_max;

10400

uint64_val= uint64_max;

10401

10402

rc= mysql_stmt_execute(stmt);

10403

check_execute(stmt, rc);

10404

10405

stmt_text= "SELECT i8, ui8, i16, ui16, i32, ui32, i64, ui64, ui64, "

10406

"cast(ui64 as signed), ui64, cast(ui64 as signed)"

10407

"FROM t1 ORDER BY id ASC";

10408

10409

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

10410

check_execute(stmt, rc);

10411

10412

rc= mysql_stmt_execute(stmt);

10413

check_execute(stmt, rc);

10414

10415

bind_array[8].buffer_type= MYSQL_TYPE_DOUBLE;

10416

bind_array[8].buffer= (void *) &udouble_val;

10417

10418

bind_array[9].buffer_type= MYSQL_TYPE_DOUBLE;

10419

bind_array[9].buffer= (void *) &double_val;

10420

10421

bind_array[10].buffer_type= MYSQL_TYPE_STRING;

10422

bind_array[10].buffer= (void *) &ulonglong_as_string;

10423

bind_array[10].buffer_length= sizeof(ulonglong_as_string);

10424

10425

bind_array[11].buffer_type= MYSQL_TYPE_STRING;

10426

bind_array[11].buffer= (void *) &longlong_as_string;

10427

bind_array[11].buffer_length= sizeof(longlong_as_string);

10428

10429

mysql_stmt_bind_result(stmt, bind_array);

10430

10431

rc= mysql_stmt_fetch(stmt);

10432

check_execute(stmt, rc);

10433

10434

DIE_UNLESS(int8_val == int8_min);

10435

DIE_UNLESS(uint8_val == uint8_min);

10436

DIE_UNLESS(int16_val == int16_min);

10437

DIE_UNLESS(uint16_val == uint16_min);

10438

DIE_UNLESS(int32_val == int32_min);

10439

DIE_UNLESS(uint32_val == uint32_min);

10440

DIE_UNLESS(int64_val == int64_min);

10441

DIE_UNLESS(uint64_val == uint64_min);

10442

DIE_UNLESS(double_val == (longlong) uint64_min);

10443

double_tmp= ulonglong2double(uint64_val);

10444

DIE_UNLESS(cmp_double(&udouble_val, &double_tmp));

10445

DIE_UNLESS(!strcmp(longlong_as_string, "0"));

10446

DIE_UNLESS(!strcmp(ulonglong_as_string, "0"));

10447

10448

rc= mysql_stmt_fetch(stmt);

10449

10450

if (!opt_silent)

10451

{

10452

printf("Truncation mask: ");

10453

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

10454

printf("%d", (int) my_bind->error_value);

10455

printf("\n");

10456

}

10457

DIE_UNLESS(rc == MYSQL_DATA_TRUNCATED || rc == 0);

10458

10459

DIE_UNLESS(int8_val == int8_max);

10460

DIE_UNLESS(uint8_val == uint8_max);

10461

DIE_UNLESS(int16_val == int16_max);

10462

DIE_UNLESS(uint16_val == uint16_max);

10463

DIE_UNLESS(int32_val == int32_max);

10464

DIE_UNLESS(uint32_val == uint32_max);

10465

DIE_UNLESS(int64_val == int64_max);

10466

DIE_UNLESS(uint64_val == uint64_max);

10467

DIE_UNLESS(double_val == (longlong) uint64_val);

10468

double_tmp= ulonglong2double(uint64_val);

10469

DIE_UNLESS(cmp_double(&udouble_val, &double_tmp));

10470

DIE_UNLESS(!strcmp(longlong_as_string, "-1"));

10471

DIE_UNLESS(!strcmp(ulonglong_as_string, "18446744073709551615"));

10472

10473

rc= mysql_stmt_fetch(stmt);

10474

DIE_UNLESS(rc == MYSQL_NO_DATA);

10475

10476

mysql_stmt_close(stmt);

10477

10478

stmt_text= "DROP TABLE t1";

10479

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

10480

}

10481

10482

10483

static void test_union2()

10484

{

10485

MYSQL_STMT *stmt;

10486

int rc, i;

10487

10488

myheader("test_union2");

10489

10490

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

10491

myquery(rc);

10492

10493

rc= mysql_query(mysql, "CREATE TABLE t1(col1 INT, \

10494

col2 VARCHAR(40), \

10495

col3 SMALLINT, \

10496

col4 TIMESTAMP)");

10497

myquery(rc);

10498

10499

stmt= mysql_simple_prepare(mysql,

10500

"select col1 FROM t1 where col1=1 union distinct "

10501

"select col1 FROM t1 where col1=2");

10502

check_stmt(stmt);

10503

10504

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

10505

{

10506

rc= mysql_stmt_execute(stmt);

10507

check_execute(stmt, rc);

10508

rc= my_process_stmt_result(stmt);

10509

DIE_UNLESS(rc == 0);

10510

}

10511

10512

mysql_stmt_close(stmt);

10513

10514

rc= mysql_query(mysql, "DROP TABLE t1");

10515

myquery(rc);

10516

}

10517

10518

10519

10520

This tests for various mysql_stmt_send_long_data bugs described in #1664

10521

10522

10523

static void test_bug1664()

10524

{

10525

MYSQL_STMT *stmt;

10526

int rc, int_data;

10527

const char *data;

10528

const char *str_data= "Simple string";

10529

MYSQL_BIND my_bind[2];

10530

const char *query= "INSERT INTO test_long_data(col2, col1) VALUES(?, ?)";

10531

10532

myheader("test_bug1664");

10533

10534

rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_long_data");

10535

myquery(rc);

10536

10537

rc= mysql_query(mysql, "CREATE TABLE test_long_data(col1 int, col2 long varchar)");

10538

myquery(rc);

10539

10540

stmt= mysql_stmt_init(mysql);

10541

check_stmt(stmt);

10542

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

10543

check_execute(stmt, rc);

10544

10545

verify_param_count(stmt, 2);

10546

10547

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

10548

10549

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

10550

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

10551

my_bind[0].buffer_length= strlen(str_data);

10552

10553

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

10554

my_bind[1].buffer_type= MYSQL_TYPE_LONG;

10555

10556

rc= mysql_stmt_bind_param(stmt, my_bind);

10557

check_execute(stmt, rc);

10558

10559

int_data= 1;

10560

10561

10562

Let us supply empty long_data. This should work and should

10563

not break following execution.

10564

10565

data= "";

10566

rc= mysql_stmt_send_long_data(stmt, 0, data, strlen(data));

10567

check_execute(stmt, rc);

10568

10569

rc= mysql_stmt_execute(stmt);

10570

check_execute(stmt, rc);

10571

10572

verify_col_data("test_long_data", "col1", "1");

10573

verify_col_data("test_long_data", "col2", "");

10574

10575

rc= mysql_query(mysql, "DELETE FROM test_long_data");

10576

myquery(rc);

10577

10578

/* This should pass OK */

10579

data= (char *)"Data";

10580

rc= mysql_stmt_send_long_data(stmt, 0, data, strlen(data));

10581

check_execute(stmt, rc);

10582

10583

rc= mysql_stmt_execute(stmt);

10584

check_execute(stmt, rc);

10585

10586

verify_col_data("test_long_data", "col1", "1");

10587

verify_col_data("test_long_data", "col2", "Data");

10588

10589

/* clean up */

10590

rc= mysql_query(mysql, "DELETE FROM test_long_data");

10591

myquery(rc);

10592

10593

10594

Now we are changing int parameter and don't do anything

10595

with first parameter. Second mysql_stmt_execute() should run

10596

OK treating this first parameter as string parameter.

10597

10598

10599

int_data= 2;

10600

/* execute */

10601

rc= mysql_stmt_execute(stmt);

10602

check_execute(stmt, rc);

10603

10604

verify_col_data("test_long_data", "col1", "2");

10605

verify_col_data("test_long_data", "col2", str_data);

10606

10607

/* clean up */

10608

rc= mysql_query(mysql, "DELETE FROM test_long_data");

10609

myquery(rc);

10610

10611

10612

Now we are sending other long data. It should not be

10613

concatened to previous.

10614

10615

10616

data= (char *)"SomeOtherData";

10617

rc= mysql_stmt_send_long_data(stmt, 0, data, strlen(data));

10618

check_execute(stmt, rc);

10619

10620

rc= mysql_stmt_execute(stmt);

10621

check_execute(stmt, rc);

10622

10623

verify_col_data("test_long_data", "col1", "2");

10624

verify_col_data("test_long_data", "col2", "SomeOtherData");

10625

10626

mysql_stmt_close(stmt);

10627

10628

/* clean up */

10629

rc= mysql_query(mysql, "DELETE FROM test_long_data");

10630

myquery(rc);

10631

10632

/* Now let us test how mysql_stmt_reset works. */

10633

stmt= mysql_stmt_init(mysql);

10634

check_stmt(stmt);

10635

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

10636

check_execute(stmt, rc);

10637

rc= mysql_stmt_bind_param(stmt, my_bind);

10638

check_execute(stmt, rc);

10639

10640

data= (char *)"SomeData";

10641

rc= mysql_stmt_send_long_data(stmt, 0, data, strlen(data));

10642

check_execute(stmt, rc);

10643

10644

rc= mysql_stmt_reset(stmt);

10645

check_execute(stmt, rc);

10646

10647

rc= mysql_stmt_execute(stmt);

10648

check_execute(stmt, rc);

10649

10650

verify_col_data("test_long_data", "col1", "2");

10651

verify_col_data("test_long_data", "col2", str_data);

10652

10653

mysql_stmt_close(stmt);

10654

10655

/* Final clean up */

10656

rc= mysql_query(mysql, "DROP TABLE test_long_data");

10657

myquery(rc);

10658

}

10659

10660

10661

static void test_order_param()

10662

{

10663

MYSQL_STMT *stmt;

10664

int rc;

10665

10666

myheader("test_order_param");

10667

10668

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

10669

myquery(rc);

10670

10671

rc= mysql_query(mysql, "CREATE TABLE t1(a INT, b char(10))");

10672

myquery(rc);

10673

10674

stmt= mysql_simple_prepare(mysql,

10675

"select sum(a) + 200, 1 from t1 "

10676

" union distinct "

10677

"select sum(a) + 200, 1 from t1 group by b ");

10678

check_stmt(stmt);

10679

mysql_stmt_close(stmt);

10680

10681

stmt= mysql_simple_prepare(mysql,

10682

"select sum(a) + 200, ? from t1 group by b "

10683

" union distinct "

10684

"select sum(a) + 200, 1 from t1 group by b ");

10685

check_stmt(stmt);

10686

mysql_stmt_close(stmt);

10687

10688

stmt= mysql_simple_prepare(mysql,

10689

"select sum(a) + 200, ? from t1 "

10690

" union distinct "

10691

"select sum(a) + 200, 1 from t1 group by b ");

10692

check_stmt(stmt);

10693

mysql_stmt_close(stmt);

10694

10695

rc= mysql_query(mysql, "DROP TABLE t1");

10696

myquery(rc);

10697

}

10698

10699

10700

static void test_union_param()

10701

{

10702

MYSQL_STMT *stmt;

10703

char *query;

10704

int rc, i;

10705

MYSQL_BIND my_bind[2];

10706

char my_val[4];

10707

ulong my_length= 3L;

10708

my_bool my_null= FALSE;

10709

myheader("test_union_param");

10710

10711

strmov(my_val, "abc");

10712

10713

query= (char*)"select ? as my_col union distinct select ?";

10714

stmt= mysql_simple_prepare(mysql, query);

10715

check_stmt(stmt);

10716

10717

10718

We need to bzero bind structure because mysql_stmt_bind_param checks all

10719

its members.

10720

10721

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

10722

10723

/* bind parameters */

10724

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

10725

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

10726

my_bind[0].buffer_length= 4;

10727

my_bind[0].length= &my_length;

10728

my_bind[0].is_null= (char*)&my_null;

10729

my_bind[1].buffer_type= MYSQL_TYPE_STRING;

10730

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

10731

my_bind[1].buffer_length= 4;

10732

my_bind[1].length= &my_length;

10733

my_bind[1].is_null= (char*)&my_null;

10734

10735

rc= mysql_stmt_bind_param(stmt, my_bind);

10736

check_execute(stmt, rc);

10737

10738

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

10739

{

10740

rc= mysql_stmt_execute(stmt);

10741

check_execute(stmt, rc);

10742

rc= my_process_stmt_result(stmt);

10743

DIE_UNLESS(rc == 1);

10744

}

10745

10746

mysql_stmt_close(stmt);

10747

}

10748

10749

10750

static void test_ps_i18n()

10751

{

10752

MYSQL_STMT *stmt;

10753

int rc;

10754

const char *stmt_text;

10755

MYSQL_BIND bind_array[2];

10756

10757

/* Represented as numbers to keep UTF8 tools from clobbering them. */

10758

const char *koi8= "\xee\xd5\x2c\x20\xda\xc1\x20\xd2\xd9\xc2\xc1\xcc\xcb\xd5";

10759

const char *cp1251= "\xcd\xf3\x2c\x20\xe7\xe0\x20\xf0\xfb\xe1\xe0\xeb\xea\xf3";

10760

char buf1[16], buf2[16];

10761

ulong buf1_len, buf2_len;

10762

10763

10764

myheader("test_ps_i18n");

10765

10766

stmt_text= "DROP TABLE IF EXISTS t1";

10767

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

10768

myquery(rc);

10769

10770

10771

Create table with binary columns, set session character set to cp1251,

10772

client character set to koi8, and make sure that there is conversion

10773

on insert and no conversion on select

10774

10775

10776

stmt_text= "CREATE TABLE t1 (c1 VARBINARY(255), c2 VARBINARY(255))";

10777

10778

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

10779

myquery(rc);

10780

10781

stmt_text= "SET CHARACTER_SET_CLIENT=koi8r, "

10782

"CHARACTER_SET_CONNECTION=cp1251, "

10783

"CHARACTER_SET_RESULTS=koi8r";

10784

10785

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

10786

myquery(rc);

10787

10788

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

10789

10790

bind_array[0].buffer_type= MYSQL_TYPE_STRING;

10791

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

10792

bind_array[0].buffer_length= strlen(koi8);

10793

10794

bind_array[1].buffer_type= MYSQL_TYPE_STRING;

10795

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

10796

bind_array[1].buffer_length= strlen(koi8);

10797

10798

stmt= mysql_stmt_init(mysql);

10799

check_stmt(stmt);

10800

10801

stmt_text= "INSERT INTO t1 (c1, c2) VALUES (?, ?)";

10802

10803

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

10804

check_execute(stmt, rc);

10805

10806

mysql_stmt_bind_param(stmt, bind_array);

10807

10808

mysql_stmt_send_long_data(stmt, 0, koi8, strlen(koi8));

10809

10810

rc= mysql_stmt_execute(stmt);

10811

check_execute(stmt, rc);

10812

10813

stmt_text= "SELECT c1, c2 FROM t1";

10814

10815

/* c1 and c2 are binary so no conversion will be done on select */

10816

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

10817

check_execute(stmt, rc);

10818

10819

rc= mysql_stmt_execute(stmt);

10820

check_execute(stmt, rc);

10821

10822

bind_array[0].buffer= buf1;

10823

bind_array[0].buffer_length= sizeof(buf1);

10824

bind_array[0].length= &buf1_len;

10825

10826

bind_array[1].buffer= buf2;

10827

bind_array[1].buffer_length= sizeof(buf2);

10828

bind_array[1].length= &buf2_len;

10829

10830

mysql_stmt_bind_result(stmt, bind_array);

10831

10832

rc= mysql_stmt_fetch(stmt);

10833

check_execute(stmt, rc);

10834

10835

DIE_UNLESS(buf1_len == strlen(cp1251));

10836

DIE_UNLESS(buf2_len == strlen(cp1251));

10837

DIE_UNLESS(!memcmp(buf1, cp1251, buf1_len));

10838

DIE_UNLESS(!memcmp(buf2, cp1251, buf1_len));

10839

10840

rc= mysql_stmt_fetch(stmt);

10841

DIE_UNLESS(rc == MYSQL_NO_DATA);

10842

10843

stmt_text= "DROP TABLE IF EXISTS t1";

10844

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

10845

myquery(rc);

10846

10847

10848

Now create table with two cp1251 columns, set client character

10849

set to koi8 and supply columns of one row as string and another as

10850

binary data. Binary data must not be converted on insert, and both

10851

columns must be converted to client character set on select.

10852

10853

10854

stmt_text= "CREATE TABLE t1 (c1 VARCHAR(255) CHARACTER SET cp1251, "

10855

"c2 VARCHAR(255) CHARACTER SET cp1251)";

10856

10857

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

10858

myquery(rc);

10859

10860

stmt_text= "INSERT INTO t1 (c1, c2) VALUES (?, ?)";

10861

10862

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

10863

check_execute(stmt, rc);

10864

10865

/* this data must be converted */

10866

bind_array[0].buffer_type= MYSQL_TYPE_STRING;

10867

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

10868

bind_array[0].buffer_length= strlen(koi8);

10869

10870

bind_array[1].buffer_type= MYSQL_TYPE_STRING;

10871

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

10872

bind_array[1].buffer_length= strlen(koi8);

10873

10874

mysql_stmt_bind_param(stmt, bind_array);

10875

10876

mysql_stmt_send_long_data(stmt, 0, koi8, strlen(koi8));

10877

10878

rc= mysql_stmt_execute(stmt);

10879

check_execute(stmt, rc);

10880

10881

/* this data must not be converted */

10882

bind_array[0].buffer_type= MYSQL_TYPE_BLOB;

10883

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

10884

bind_array[0].buffer_length= strlen(cp1251);

10885

10886

bind_array[1].buffer_type= MYSQL_TYPE_BLOB;

10887

bind_array[1].buffer= (void *) cp1251;

10888

bind_array[1].buffer_length= strlen(cp1251);

10889

10890

mysql_stmt_bind_param(stmt, bind_array);

10891

10892

mysql_stmt_send_long_data(stmt, 0, cp1251, strlen(cp1251));

10893

10894

rc= mysql_stmt_execute(stmt);

10895

check_execute(stmt, rc);

10896

10897

/* Fetch data and verify that rows are in koi8 */

10898

10899

stmt_text= "SELECT c1, c2 FROM t1";

10900

10901

/* c1 and c2 are binary so no conversion will be done on select */

10902

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

10903

check_execute(stmt, rc);

10904

10905

rc= mysql_stmt_execute(stmt);

10906

check_execute(stmt, rc);

10907

10908

bind_array[0].buffer= buf1;

10909

bind_array[0].buffer_length= sizeof(buf1);

10910

bind_array[0].length= &buf1_len;

10911

10912

bind_array[1].buffer= buf2;

10913

bind_array[1].buffer_length= sizeof(buf2);

10914

bind_array[1].length= &buf2_len;

10915

10916

mysql_stmt_bind_result(stmt, bind_array);

10917

10918

while ((rc= mysql_stmt_fetch(stmt)) == 0)

10919

{

10920

DIE_UNLESS(buf1_len == strlen(koi8));

10921

DIE_UNLESS(buf2_len == strlen(koi8));

10922

DIE_UNLESS(!memcmp(buf1, koi8, buf1_len));

10923

DIE_UNLESS(!memcmp(buf2, koi8, buf1_len));

10924

}

10925

DIE_UNLESS(rc == MYSQL_NO_DATA);

10926

mysql_stmt_close(stmt);

10927

10928

stmt_text= "DROP TABLE t1";

10929

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

10930

myquery(rc);

10931

stmt_text= "SET NAMES DEFAULT";

10932

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

10933

myquery(rc);

10934

}

10935

10936

10937

static void test_bug3796()

10938

{

10939

MYSQL_STMT *stmt;

10940

MYSQL_BIND my_bind[1];

10941

const char *concat_arg0= "concat_with_";

10942

enum { OUT_BUFF_SIZE= 30 };

10943

char out_buff[OUT_BUFF_SIZE];

10944

char canonical_buff[OUT_BUFF_SIZE];

10945

ulong out_length;

10946

const char *stmt_text;

10947

int rc;

10948

10949

myheader("test_bug3796");

10950

10951

/* Create and fill test table */

10952

stmt_text= "DROP TABLE IF EXISTS t1";

10953

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

10954

myquery(rc);

10955

10956

stmt_text= "CREATE TABLE t1 (a INT, b VARCHAR(30))";

10957

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

10958

myquery(rc);

10959

10960

stmt_text= "INSERT INTO t1 VALUES(1, 'ONE'), (2, 'TWO')";

10961

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

10962

myquery(rc);

10963

10964

/* Create statement handle and prepare it with select */

10965

stmt= mysql_stmt_init(mysql);

10966

stmt_text= "SELECT concat(?, b) FROM t1";

10967

10968

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

10969

check_execute(stmt, rc);

10970

10971

/* Bind input buffers */

10972

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

10973

10974

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

10975

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

10976

my_bind[0].buffer_length= strlen(concat_arg0);

10977

10978

mysql_stmt_bind_param(stmt, my_bind);

10979

10980

/* Execute the select statement */

10981

rc= mysql_stmt_execute(stmt);

10982

check_execute(stmt, rc);

10983

10984

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

10985

my_bind[0].buffer_length= OUT_BUFF_SIZE;

10986

my_bind[0].length= &out_length;

10987

10988

mysql_stmt_bind_result(stmt, my_bind);

10989

10990

rc= mysql_stmt_fetch(stmt);

10991

if (!opt_silent)

10992

printf("Concat result: '%s'\n", out_buff);

10993

check_execute(stmt, rc);

10994

strmov(canonical_buff, concat_arg0);

10995

strcat(canonical_buff, "ONE");

10996

DIE_UNLESS(strlen(canonical_buff) == out_length &&

10997

strncmp(out_buff, canonical_buff, out_length) == 0);

10998

10999

rc= mysql_stmt_fetch(stmt);

11000

check_execute(stmt, rc);

11001

strmov(canonical_buff + strlen(concat_arg0), "TWO");

11002

DIE_UNLESS(strlen(canonical_buff) == out_length &&

11003

strncmp(out_buff, canonical_buff, out_length) == 0);

11004

if (!opt_silent)

11005

printf("Concat result: '%s'\n", out_buff);

11006

11007

rc= mysql_stmt_fetch(stmt);

11008

DIE_UNLESS(rc == MYSQL_NO_DATA);

11009

11010

mysql_stmt_close(stmt);

11011

11012

stmt_text= "DROP TABLE IF EXISTS t1";

11013

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

11014

myquery(rc);

11015

}

11016

11017

11018

static void test_bug4026()

11019

{

11020

MYSQL_STMT *stmt;

11021

MYSQL_BIND my_bind[2];

11022

MYSQL_TIME time_in, time_out;

11023

MYSQL_TIME datetime_in, datetime_out;

11024

const char *stmt_text;

11025

int rc;

11026

11027

myheader("test_bug4026");

11028

11029

/* Check that microseconds are inserted and selected successfully */

11030

11031

/* Create a statement handle and prepare it with select */

11032

stmt= mysql_stmt_init(mysql);

11033

stmt_text= "SELECT ?, ?";

11034

11035

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

11036

check_execute(stmt, rc);

11037

11038

/* Bind input buffers */

11039

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

11040

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

11041

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

11042

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

11043

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

11044

11045

my_bind[0].buffer_type= MYSQL_TYPE_TIME;

11046

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

11047

my_bind[1].buffer_type= MYSQL_TYPE_DATETIME;

11048

my_bind[1].buffer= (void *) &datetime_in;

11049

11050

time_in.hour= 23;

11051

time_in.minute= 59;

11052

time_in.second= 59;

11053

time_in.second_part= 123456;

11054

11055

This is not necessary, just to make DIE_UNLESS below work: this field

11056

is filled in when time is received from server

11057

11058

time_in.time_type= MYSQL_TIMESTAMP_TIME;

11059

11060

datetime_in= time_in;

11061

datetime_in.year= 2003;

11062

datetime_in.month= 12;

11063

datetime_in.day= 31;

11064

datetime_in.time_type= MYSQL_TIMESTAMP_DATETIME;

11065

11066

mysql_stmt_bind_param(stmt, my_bind);

11067

11068

/* Execute the select statement */

11069

rc= mysql_stmt_execute(stmt);

11070

check_execute(stmt, rc);

11071

11072

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

11073

my_bind[1].buffer= (void *) &datetime_out;

11074

11075

mysql_stmt_bind_result(stmt, my_bind);

11076

11077

rc= mysql_stmt_fetch(stmt);

11078

DIE_UNLESS(rc == 0);

11079

if (!opt_silent)

11080

{

11081

printf("%d:%d:%d.%lu\n", time_out.hour, time_out.minute, time_out.second,

11082

time_out.second_part);

11083

printf("%d-%d-%d %d:%d:%d.%lu\n", datetime_out.year, datetime_out.month,

11084

datetime_out.day, datetime_out.hour,

11085

datetime_out.minute, datetime_out.second,

11086

datetime_out.second_part);

11087

}

11088

DIE_UNLESS(memcmp(&time_in, &time_out, sizeof(time_in)) == 0);

11089

DIE_UNLESS(memcmp(&datetime_in, &datetime_out, sizeof(datetime_in)) == 0);

11090

mysql_stmt_close(stmt);

11091

}

11092

11093

11094

static void test_bug4079()

11095

{

11096

MYSQL_STMT *stmt;

11097

MYSQL_BIND my_bind[1];

11098

const char *stmt_text;

11099

uint32 res;

11100

int rc;

11101

11102

myheader("test_bug4079");

11103

11104

/* Create and fill table */

11105

mysql_query(mysql, "DROP TABLE IF EXISTS t1");

11106

mysql_query(mysql, "CREATE TABLE t1 (a int)");

11107

mysql_query(mysql, "INSERT INTO t1 VALUES (1), (2)");

11108

11109

/* Prepare erroneous statement */

11110

stmt= mysql_stmt_init(mysql);

11111

stmt_text= "SELECT 1 < (SELECT a FROM t1)";

11112

11113

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

11114

check_execute(stmt, rc);

11115

11116

/* Execute the select statement */

11117

rc= mysql_stmt_execute(stmt);

11118

check_execute(stmt, rc);

11119

11120

/* Bind input buffers */

11121

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

11122

11123

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

11124

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

11125

11126

mysql_stmt_bind_result(stmt, my_bind);

11127

11128

rc= mysql_stmt_fetch(stmt);

11129

DIE_UNLESS(rc != 0 && rc != MYSQL_NO_DATA);

11130

if (!opt_silent)

11131

printf("Got error from mysql_stmt_fetch (as expected):\n%s\n",

11132

mysql_stmt_error(stmt));

11133

/* buggy version of libmysql hanged up here */

11134

mysql_stmt_close(stmt);

11135

}

11136

11137

11138

static void test_bug4236()

11139

{

11140

MYSQL_STMT *stmt;

11141

const char *stmt_text;

11142

int rc;

11143

MYSQL_STMT backup;

11144

11145

myheader("test_bug4236");

11146

11147

stmt= mysql_stmt_init(mysql);

11148

11149

/* mysql_stmt_execute() of statement with statement id= 0 crashed server */

11150

stmt_text= "SELECT 1";

11151

/* We need to prepare statement to pass by possible check in libmysql */

11152

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

11153

check_execute(stmt, rc);

11154

/* Hack to check that server works OK if statement wasn't found */

11155

backup.stmt_id= stmt->stmt_id;

11156

stmt->stmt_id= 0;

11157

rc= mysql_stmt_execute(stmt);

11158

DIE_UNLESS(rc);

11159

/* Restore original statement id to be able to reprepare it */

11160

stmt->stmt_id= backup.stmt_id;

11161

11162

mysql_stmt_close(stmt);

11163

}

11164

11165

11166

static void test_bug4030()

11167

{

11168

MYSQL_STMT *stmt;

11169

MYSQL_BIND my_bind[3];

11170

MYSQL_TIME time_canonical, time_out;

11171

MYSQL_TIME date_canonical, date_out;

11172

MYSQL_TIME datetime_canonical, datetime_out;

11173

const char *stmt_text;

11174

int rc;

11175

11176

myheader("test_bug4030");

11177

11178

/* Check that microseconds are inserted and selected successfully */

11179

11180

/* Execute a query with time values in prepared mode */

11181

stmt= mysql_stmt_init(mysql);

11182

stmt_text= "SELECT '23:59:59.123456', '2003-12-31', "

11183

"'2003-12-31 23:59:59.123456'";

11184

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

11185

check_execute(stmt, rc);

11186

rc= mysql_stmt_execute(stmt);

11187

check_execute(stmt, rc);

11188

11189

/* Bind output buffers */

11190

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

11191

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

11192

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

11193

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

11194

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

11195

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

11196

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

11197

11198

my_bind[0].buffer_type= MYSQL_TYPE_TIME;

11199

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

11200

my_bind[1].buffer_type= MYSQL_TYPE_DATE;

11201

my_bind[1].buffer= (void *) &date_out;

11202

my_bind[2].buffer_type= MYSQL_TYPE_DATETIME;

11203

my_bind[2].buffer= (void *) &datetime_out;

11204

11205

time_canonical.hour= 23;

11206

time_canonical.minute= 59;

11207

time_canonical.second= 59;

11208

time_canonical.second_part= 123456;

11209

time_canonical.time_type= MYSQL_TIMESTAMP_TIME;

11210

11211

date_canonical.year= 2003;

11212

date_canonical.month= 12;

11213

date_canonical.day= 31;

11214

date_canonical.time_type= MYSQL_TIMESTAMP_DATE;

11215

11216

datetime_canonical= time_canonical;

11217

datetime_canonical.year= 2003;

11218

datetime_canonical.month= 12;

11219

datetime_canonical.day= 31;

11220

datetime_canonical.time_type= MYSQL_TIMESTAMP_DATETIME;

11221

11222

mysql_stmt_bind_result(stmt, my_bind);

11223

11224

rc= mysql_stmt_fetch(stmt);

11225

DIE_UNLESS(rc == 0);

11226

if (!opt_silent)

11227

{

11228

printf("%d:%d:%d.%lu\n", time_out.hour, time_out.minute, time_out.second,

11229

time_out.second_part);

11230

printf("%d-%d-%d\n", date_out.year, date_out.month, date_out.day);

11231

printf("%d-%d-%d %d:%d:%d.%lu\n", datetime_out.year, datetime_out.month,

11232

datetime_out.day, datetime_out.hour,

11233

datetime_out.minute, datetime_out.second,

11234

datetime_out.second_part);

11235

}

11236

DIE_UNLESS(memcmp(&time_canonical, &time_out, sizeof(time_out)) == 0);

11237

DIE_UNLESS(memcmp(&date_canonical, &date_out, sizeof(date_out)) == 0);

11238

DIE_UNLESS(memcmp(&datetime_canonical, &datetime_out, sizeof(datetime_out)) == 0);

11239

mysql_stmt_close(stmt);

11240

}

11241

11242

static void test_view()

11243

{

11244

MYSQL_STMT *stmt;

11245

int rc, i;

11246

MYSQL_BIND my_bind[1];

11247

char str_data[50];

11248

ulong length = 0L;

11249

long is_null = 0L;

11250

const char *query=

11251

"SELECT COUNT(*) FROM v1 WHERE SERVERNAME=?";

11252

11253

myheader("test_view");

11254

11255

rc = mysql_query(mysql, "DROP TABLE IF EXISTS t1,t2,t3,v1");

11256

myquery(rc);

11257

11258

rc = mysql_query(mysql, "DROP VIEW IF EXISTS v1,t1,t2,t3");

11259

myquery(rc);

11260

rc= mysql_query(mysql,"CREATE TABLE t1 ("

11261

" SERVERGRP varchar(20) NOT NULL default '', "

11262

" DBINSTANCE varchar(20) NOT NULL default '', "

11263

" PRIMARY KEY (SERVERGRP)) "

11264

" CHARSET=latin1 collate=latin1_bin");

11265

myquery(rc);

11266

rc= mysql_query(mysql,"CREATE TABLE t2 ("

11267

" SERVERNAME varchar(20) NOT NULL, "

11268

" SERVERGRP varchar(20) NOT NULL, "

11269

" PRIMARY KEY (SERVERNAME)) "

11270

" CHARSET=latin1 COLLATE latin1_bin");

11271

myquery(rc);

11272

rc= mysql_query(mysql,

11273

"CREATE TABLE t3 ("

11274

" SERVERGRP varchar(20) BINARY NOT NULL, "

11275

" TABNAME varchar(30) NOT NULL, MAPSTATE char(1) NOT NULL, "

11276

" ACTSTATE char(1) NOT NULL , "

11277

" LOCAL_NAME varchar(30) NOT NULL, "

11278

" CHG_DATE varchar(8) NOT NULL default '00000000', "

11279

" CHG_TIME varchar(6) NOT NULL default '000000', "

11280

" MXUSER varchar(12) NOT NULL default '', "

11281

" PRIMARY KEY (SERVERGRP, TABNAME, MAPSTATE, ACTSTATE, "

11282

" LOCAL_NAME)) CHARSET=latin1 COLLATE latin1_bin");

11283

myquery(rc);

11284

rc= mysql_query(mysql,"CREATE VIEW v1 AS select sql_no_cache"

11285

" T0001.SERVERNAME AS SERVERNAME, T0003.TABNAME AS"

11286

" TABNAME,T0003.LOCAL_NAME AS LOCAL_NAME,T0002.DBINSTANCE AS"

11287

" DBINSTANCE from t2 T0001 join t1 T0002 join t3 T0003 where"

11288

" ((T0002.SERVERGRP = T0001.SERVERGRP) and"

11289

" (T0002.SERVERGRP = T0003.SERVERGRP)"

11290

" and (T0003.MAPSTATE = _latin1'A') and"

11291

" (T0003.ACTSTATE = _latin1' '))");

11292

myquery(rc);

11293

11294

stmt= mysql_stmt_init(mysql);

11295

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

11296

check_execute(stmt, rc);

11297

11298

strmov(str_data, "TEST");

11299

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

11300

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

11301

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

11302

my_bind[0].buffer_length= 50;

11303

my_bind[0].length= &length;

11304

length= 4;

11305

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

11306

rc= mysql_stmt_bind_param(stmt, my_bind);

11307

check_execute(stmt,rc);

11308

11309

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

11310

{

11311

rc= mysql_stmt_execute(stmt);

11312

check_execute(stmt, rc);

11313

rc= my_process_stmt_result(stmt);

11314

DIE_UNLESS(1 == rc);

11315

}

11316

mysql_stmt_close(stmt);

11317

11318

rc= mysql_query(mysql, "DROP TABLE t1,t2,t3");

11319

myquery(rc);

11320

rc= mysql_query(mysql, "DROP VIEW v1");

11321

myquery(rc);

11322

}

11323

11324

11325

static void test_view_where()

11326

{

11327

MYSQL_STMT *stmt;

11328

int rc, i;

11329

const char *query=

11330

"select v1.c,v2.c from v1, v2";

11331

11332

myheader("test_view_where");

11333

11334

rc = mysql_query(mysql, "DROP TABLE IF EXISTS t1,v1,v2");

11335

myquery(rc);

11336

11337

rc = mysql_query(mysql, "DROP VIEW IF EXISTS v1,v2,t1");

11338

myquery(rc);

11339

rc= mysql_query(mysql,"CREATE TABLE t1 (a int, b int)");

11340

myquery(rc);

11341

rc= mysql_query(mysql,"insert into t1 values (1,2), (1,3), (2,4), (2,5), (3,10)");

11342

myquery(rc);

11343

rc= mysql_query(mysql,"create view v1 (c) as select b from t1 where a<3");

11344

myquery(rc);

11345

rc= mysql_query(mysql,"create view v2 (c) as select b from t1 where a>=3");

11346

myquery(rc);

11347

11348

stmt= mysql_stmt_init(mysql);

11349

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

11350

check_execute(stmt, rc);

11351

11352

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

11353

{

11354

rc= mysql_stmt_execute(stmt);

11355

check_execute(stmt, rc);

11356

rc= my_process_stmt_result(stmt);

11357

DIE_UNLESS(4 == rc);

11358

}

11359

mysql_stmt_close(stmt);

11360

11361

rc= mysql_query(mysql, "DROP TABLE t1");

11362

myquery(rc);

11363

rc= mysql_query(mysql, "DROP VIEW v1, v2");

11364

myquery(rc);

11365

}

11366

11367

11368

static void test_view_2where()

11369

{

11370

MYSQL_STMT *stmt;

11371

int rc, i;

11372

MYSQL_BIND my_bind[8];

11373

char parms[8][100];

11374

ulong length[8];

11375

const char *query=

11376

"select relid, report, handle, log_group, username, variant, type, "

11377

"version, erfdat, erftime, erfname, aedat, aetime, aename, dependvars, "

11378

"inactive from V_LTDX where mandt = ? and relid = ? and report = ? and "

11379

"handle = ? and log_group = ? and username in ( ? , ? ) and type = ?";

11380

11381

myheader("test_view_2where");

11382

11383

rc= mysql_query(mysql, "DROP TABLE IF EXISTS LTDX");

11384

myquery(rc);

11385

rc= mysql_query(mysql, "DROP VIEW IF EXISTS V_LTDX");

11386

myquery(rc);

11387

rc= mysql_query(mysql,

11388

"CREATE TABLE LTDX (MANDT char(3) NOT NULL default '000', "

11389

" RELID char(2) NOT NULL, REPORT varchar(40) NOT NULL,"

11390

" HANDLE varchar(4) NOT NULL, LOG_GROUP varchar(4) NOT NULL,"

11391

" USERNAME varchar(12) NOT NULL,"

11392

" VARIANT varchar(12) NOT NULL,"

11393

" TYPE char(1) NOT NULL, SRTF2 int(11) NOT NULL,"

11394

" VERSION varchar(6) NOT NULL default '000000',"

11395

" ERFDAT varchar(8) NOT NULL default '00000000',"

11396

" ERFTIME varchar(6) NOT NULL default '000000',"

11397

" ERFNAME varchar(12) NOT NULL,"

11398

" AEDAT varchar(8) NOT NULL default '00000000',"

11399

" AETIME varchar(6) NOT NULL default '000000',"

11400

" AENAME varchar(12) NOT NULL,"

11401

" DEPENDVARS varchar(10) NOT NULL,"

11402

" INACTIVE char(1) NOT NULL, CLUSTR smallint(6) NOT NULL,"

11403

" CLUSTD blob,"

11404

" PRIMARY KEY (MANDT, RELID, REPORT, HANDLE, LOG_GROUP, "

11405

"USERNAME, VARIANT, TYPE, SRTF2))"

11406

" CHARSET=latin1 COLLATE latin1_bin");

11407

myquery(rc);

11408

rc= mysql_query(mysql,

11409

"CREATE VIEW V_LTDX AS select T0001.MANDT AS "

11410

" MANDT,T0001.RELID AS RELID,T0001.REPORT AS "

11411

" REPORT,T0001.HANDLE AS HANDLE,T0001.LOG_GROUP AS "

11412

" LOG_GROUP,T0001.USERNAME AS USERNAME,T0001.VARIANT AS "

11413

" VARIANT,T0001.TYPE AS TYPE,T0001.VERSION AS "

11414

" VERSION,T0001.ERFDAT AS ERFDAT,T0001.ERFTIME AS "

11415

" ERFTIME,T0001.ERFNAME AS ERFNAME,T0001.AEDAT AS "

11416

" AEDAT,T0001.AETIME AS AETIME,T0001.AENAME AS "

11417

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

11418

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

11419

myquery(rc);

11420

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

11421

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

11422

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

11423

my_bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;

11424

my_bind[i].buffer = (char *)&parms[i];

11425

my_bind[i].buffer_length = 100;

11426

my_bind[i].is_null = 0;

11427

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

11428

length[i] = 1;

11429

}

11430

stmt= mysql_stmt_init(mysql);

11431

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

11432

check_execute(stmt, rc);

11433

11434

rc= mysql_stmt_bind_param(stmt, my_bind);

11435

check_execute(stmt,rc);

11436

11437

rc= mysql_stmt_execute(stmt);

11438

check_execute(stmt, rc);

11439

rc= my_process_stmt_result(stmt);

11440

DIE_UNLESS(0 == rc);

11441

11442

mysql_stmt_close(stmt);

11443

11444

rc= mysql_query(mysql, "DROP VIEW V_LTDX");

11445

myquery(rc);

11446

rc= mysql_query(mysql, "DROP TABLE LTDX");

11447

myquery(rc);

11448

}

11449

11450

11451

static void test_view_star()

11452

{

11453

MYSQL_STMT *stmt;

11454

int rc, i;

11455

MYSQL_BIND my_bind[8];

11456

char parms[8][100];

11457

ulong length[8];

11458

const char *query= "SELECT * FROM vt1 WHERE a IN (?,?)";

11459

11460

myheader("test_view_star");

11461

11462

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, vt1");

11463

myquery(rc);

11464

rc= mysql_query(mysql, "DROP VIEW IF EXISTS t1, vt1");

11465

myquery(rc);

11466

rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");

11467

myquery(rc);

11468

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

11469

myquery(rc);

11470

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

11471

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

11472

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

11473

my_bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;

11474

my_bind[i].buffer = (char *)&parms[i];

11475

my_bind[i].buffer_length = 100;

11476

my_bind[i].is_null = 0;

11477

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

11478

length[i] = 1;

11479

}

11480

11481

stmt= mysql_stmt_init(mysql);

11482

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

11483

check_execute(stmt, rc);

11484

11485

rc= mysql_stmt_bind_param(stmt, my_bind);

11486

check_execute(stmt,rc);

11487

11488

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

11489

{

11490

rc= mysql_stmt_execute(stmt);

11491

check_execute(stmt, rc);

11492

rc= my_process_stmt_result(stmt);

11493

DIE_UNLESS(0 == rc);

11494

}

11495

11496

mysql_stmt_close(stmt);

11497

11498

rc= mysql_query(mysql, "DROP TABLE t1");

11499

myquery(rc);

11500

rc= mysql_query(mysql, "DROP VIEW vt1");

11501

myquery(rc);

11502

}

11503

11504

11505

static void test_view_insert()

11506

{

11507

MYSQL_STMT *insert_stmt, *select_stmt;

11508

int rc, i;

11509

MYSQL_BIND my_bind[1];

11510

int my_val = 0;

11511

ulong my_length = 0L;

11512

long my_null = 0L;

11513

const char *query=

11514

"insert into v1 values (?)";

11515

11516

myheader("test_view_insert");

11517

11518

rc = mysql_query(mysql, "DROP TABLE IF EXISTS t1,v1");

11519

myquery(rc);

11520

rc = mysql_query(mysql, "DROP VIEW IF EXISTS t1,v1");

11521

myquery(rc);

11522

11523

rc= mysql_query(mysql,"create table t1 (a int, primary key (a))");

11524

myquery(rc);

11525

11526

rc= mysql_query(mysql, "create view v1 as select a from t1 where a>=1");

11527

myquery(rc);

11528

11529

insert_stmt= mysql_stmt_init(mysql);

11530

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

11531

check_execute(insert_stmt, rc);

11532

query= "select * from t1";

11533

select_stmt= mysql_stmt_init(mysql);

11534

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

11535

check_execute(select_stmt, rc);

11536

11537

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

11538

my_bind[0].buffer_type = MYSQL_TYPE_LONG;

11539

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

11540

my_bind[0].length = &my_length;

11541

my_bind[0].is_null = (char*)&my_null;

11542

rc= mysql_stmt_bind_param(insert_stmt, my_bind);

11543

check_execute(insert_stmt, rc);

11544

11545

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

11546

{

11547

int rowcount= 0;

11548

my_val= i;

11549

11550

rc= mysql_stmt_execute(insert_stmt);

11551

check_execute(insert_stmt, rc);

11552

11553

rc= mysql_stmt_execute(select_stmt);

11554

check_execute(select_stmt, rc);

11555

rowcount= (int)my_process_stmt_result(select_stmt);

11556

DIE_UNLESS((i+1) == rowcount);

11557

}

11558

mysql_stmt_close(insert_stmt);

11559

mysql_stmt_close(select_stmt);

11560

11561

rc= mysql_query(mysql, "DROP VIEW v1");

11562

myquery(rc);

11563

rc= mysql_query(mysql, "DROP TABLE t1");

11564

myquery(rc);

11565

}

11566

11567

11568

static void test_left_join_view()

11569

{

11570

MYSQL_STMT *stmt;

11571

int rc, i;

11572

const char *query=

11573

"select t1.a, v1.x from t1 left join v1 on (t1.a= v1.x);";

11574

11575

myheader("test_left_join_view");

11576

11577

rc = mysql_query(mysql, "DROP TABLE IF EXISTS t1,v1");

11578

myquery(rc);

11579

11580

rc = mysql_query(mysql, "DROP VIEW IF EXISTS v1,t1");

11581

myquery(rc);

11582

rc= mysql_query(mysql,"CREATE TABLE t1 (a int)");

11583

myquery(rc);

11584

rc= mysql_query(mysql,"insert into t1 values (1), (2), (3)");

11585

myquery(rc);

11586

rc= mysql_query(mysql,"create view v1 (x) as select a from t1 where a > 1");

11587

myquery(rc);

11588

stmt= mysql_stmt_init(mysql);

11589

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

11590

check_execute(stmt, rc);

11591

11592

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

11593

{

11594

rc= mysql_stmt_execute(stmt);

11595

check_execute(stmt, rc);

11596

rc= my_process_stmt_result(stmt);

11597

DIE_UNLESS(3 == rc);

11598

}

11599

mysql_stmt_close(stmt);

11600

11601

rc= mysql_query(mysql, "DROP VIEW v1");

11602

myquery(rc);

11603

rc= mysql_query(mysql, "DROP TABLE t1");

11604

myquery(rc);

11605

}

11606

11607

11608

static void test_view_insert_fields()

11609

{

11610

MYSQL_STMT *stmt;

11611

char parm[11][1000];

11612

ulong l[11];

11613

int rc, i;

11614

MYSQL_BIND my_bind[11];

11615

const char *query= "INSERT INTO `v1` ( `K1C4` ,`K2C4` ,`K3C4` ,`K4N4` ,`F1C4` ,`F2I4` ,`F3N5` ,`F7F8` ,`F6N4` ,`F5C8` ,`F9D8` ) VALUES( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? )";

11616

11617

myheader("test_view_insert_fields");

11618

11619

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, v1");

11620

myquery(rc);

11621

rc= mysql_query(mysql, "DROP VIEW IF EXISTS t1, v1");

11622

myquery(rc);

11623

rc= mysql_query(mysql,

11624

"CREATE TABLE t1 (K1C4 varchar(4) NOT NULL,"

11625

"K2C4 varchar(4) NOT NULL, K3C4 varchar(4) NOT NULL,"

11626

"K4N4 varchar(4) NOT NULL default '0000',"

11627

"F1C4 varchar(4) NOT NULL, F2I4 int(11) NOT NULL,"

11628

"F3N5 varchar(5) NOT NULL default '00000',"

11629

"F4I4 int(11) NOT NULL default '0', F5C8 varchar(8) NOT NULL,"

11630

"F6N4 varchar(4) NOT NULL default '0000',"

11631

"F7F8 double NOT NULL default '0',"

11632

"F8F8 double NOT NULL default '0',"

11633

"F9D8 decimal(8,2) NOT NULL default '0.00',"

11634

"PRIMARY KEY (K1C4,K2C4,K3C4,K4N4)) "

11635

"CHARSET=latin1 COLLATE latin1_bin");

11636

myquery(rc);

11637

rc= mysql_query(mysql,

11638

"CREATE VIEW v1 AS select sql_no_cache "

11639

" K1C4 AS K1C4, K2C4 AS K2C4, K3C4 AS K3C4, K4N4 AS K4N4, "

11640

" F1C4 AS F1C4, F2I4 AS F2I4, F3N5 AS F3N5,"

11641

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

11642

" from t1 T0001");

11643

11644

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

11645

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

11646

{

11647

l[i]= 20;

11648

my_bind[i].buffer_type= MYSQL_TYPE_STRING;

11649

my_bind[i].is_null= 0;

11650

my_bind[i].buffer= (char *)&parm[i];

11651

11652

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

11653

my_bind[i].buffer_length= 2;

11654

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

11655

}

11656

stmt= mysql_stmt_init(mysql);

11657

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

11658

check_execute(stmt, rc);

11659

rc= mysql_stmt_bind_param(stmt, my_bind);

11660

check_execute(stmt, rc);

11661

11662

rc= mysql_stmt_execute(stmt);

11663

check_execute(stmt, rc);

11664

mysql_stmt_close(stmt);

11665

11666

query= "select * from t1";

11667

stmt= mysql_stmt_init(mysql);

11668

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

11669

check_execute(stmt, rc);

11670

rc= mysql_stmt_execute(stmt);

11671

check_execute(stmt, rc);

11672

rc= my_process_stmt_result(stmt);

11673

DIE_UNLESS(1 == rc);

11674

11675

mysql_stmt_close(stmt);

11676

rc= mysql_query(mysql, "DROP VIEW v1");

11677

myquery(rc);

11678

rc= mysql_query(mysql, "DROP TABLE t1");

11679

myquery(rc);

11680

11681

}

11682

11683

static void test_bug5126()

11684

{

11685

MYSQL_STMT *stmt;

11686

MYSQL_BIND my_bind[2];

11687

int32 c1, c2;

11688

const char *stmt_text;

11689

int rc;

11690

11691

myheader("test_bug5126");

11692

11693

stmt_text= "DROP TABLE IF EXISTS t1";

11694

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

11695

myquery(rc);

11696

11697

stmt_text= "CREATE TABLE t1 (a mediumint, b int)";

11698

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

11699

myquery(rc);

11700

11701

stmt_text= "INSERT INTO t1 VALUES (8386608, 1)";

11702

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

11703

myquery(rc);

11704

11705

stmt= mysql_stmt_init(mysql);

11706

stmt_text= "SELECT a, b FROM t1";

11707

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

11708

check_execute(stmt, rc);

11709

rc= mysql_stmt_execute(stmt);

11710

check_execute(stmt, rc);

11711

11712

/* Bind output buffers */

11713

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

11714

11715

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

11716

my_bind[0].buffer= &c1;

11717

my_bind[1].buffer_type= MYSQL_TYPE_LONG;

11718

my_bind[1].buffer= &c2;

11719

11720

mysql_stmt_bind_result(stmt, my_bind);

11721

11722

rc= mysql_stmt_fetch(stmt);

11723

DIE_UNLESS(rc == 0);

11724

DIE_UNLESS(c1 == 8386608 && c2 == 1);

11725

if (!opt_silent)

11726

printf("%ld, %ld\n", (long) c1, (long) c2);

11727

mysql_stmt_close(stmt);

11728

}

11729

11730

11731

static void test_bug4231()

11732

{

11733

MYSQL_STMT *stmt;

11734

MYSQL_BIND my_bind[2];

11735

MYSQL_TIME tm[2];

11736

const char *stmt_text;

11737

int rc;

11738

11739

myheader("test_bug4231");

11740

11741

stmt_text= "DROP TABLE IF EXISTS t1";

11742

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

11743

myquery(rc);

11744

11745

stmt_text= "CREATE TABLE t1 (a int)";

11746

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

11747

myquery(rc);

11748

11749

stmt_text= "INSERT INTO t1 VALUES (1)";

11750

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

11751

myquery(rc);

11752

11753

stmt= mysql_stmt_init(mysql);

11754

stmt_text= "SELECT a FROM t1 WHERE ? = ?";

11755

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

11756

check_execute(stmt, rc);

11757

11758

/* Bind input buffers */

11759

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

11760

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

11761

11762

my_bind[0].buffer_type= MYSQL_TYPE_DATE;

11763

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

11764

my_bind[1].buffer_type= MYSQL_TYPE_DATE;

11765

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

11766

11767

mysql_stmt_bind_param(stmt, my_bind);

11768

check_execute(stmt, rc);

11769

11770

11771

First set server-side params to some non-zero non-equal values:

11772

then we will check that they are not used when client sends

11773

new (zero) times.

11774

11775

tm[0].time_type = MYSQL_TIMESTAMP_DATE;

11776

tm[0].year = 2000;

11777

tm[0].month = 1;

11778

tm[0].day = 1;

11779

tm[1]= tm[0];

11780

--tm[1].year; /* tm[0] != tm[1] */

11781

11782

rc= mysql_stmt_execute(stmt);

11783

check_execute(stmt, rc);

11784

11785

rc= mysql_stmt_fetch(stmt);

11786

11787

/* binds are unequal, no rows should be returned */

11788

DIE_UNLESS(rc == MYSQL_NO_DATA);

11789

11790

/* Set one of the dates to zero */

11791

tm[0].year= tm[0].month= tm[0].day= 0;

11792

tm[1]= tm[0];

11793

mysql_stmt_execute(stmt);

11794

rc= mysql_stmt_fetch(stmt);

11795

DIE_UNLESS(rc == 0);

11796

11797

mysql_stmt_close(stmt);

11798

stmt_text= "DROP TABLE t1";

11799

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

11800

myquery(rc);

11801

}

11802

11803

11804

static void test_bug5399()

11805

{

11806

11807

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

11808

statement id hash in the server uses binary collation.

11809

11810

#define NUM_OF_USED_STMT 97

11811

MYSQL_STMT *stmt_list[NUM_OF_USED_STMT];

11812

MYSQL_STMT **stmt;

11813

MYSQL_BIND my_bind[1];

11814

char buff[600];

11815

int rc;

11816

int32 no;

11817

11818

myheader("test_bug5399");

11819

11820

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

11821

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

11822

my_bind[0].buffer= &no;

11823

11824

for (stmt= stmt_list; stmt != stmt_list + NUM_OF_USED_STMT; ++stmt)

11825

{

11826

sprintf(buff, "select %d", (int) (stmt - stmt_list));

11827

*stmt= mysql_stmt_init(mysql);

11828

rc= mysql_stmt_prepare(*stmt, buff, strlen(buff));

11829

check_execute(*stmt, rc);

11830

mysql_stmt_bind_result(*stmt, my_bind);

11831

}

11832

if (!opt_silent)

11833

printf("%d statements prepared.\n", NUM_OF_USED_STMT);

11834

11835

for (stmt= stmt_list; stmt != stmt_list + NUM_OF_USED_STMT; ++stmt)

11836

{

11837

rc= mysql_stmt_execute(*stmt);

11838

check_execute(*stmt, rc);

11839

rc= mysql_stmt_store_result(*stmt);

11840

check_execute(*stmt, rc);

11841

rc= mysql_stmt_fetch(*stmt);

11842

DIE_UNLESS(rc == 0);

11843

DIE_UNLESS((int32) (stmt - stmt_list) == no);

11844

}

11845

11846

for (stmt= stmt_list; stmt != stmt_list + NUM_OF_USED_STMT; ++stmt)

11847

mysql_stmt_close(*stmt);

11848

#undef NUM_OF_USED_STMT

11849

}

11850

11851

11852

static void test_bug5194()

11853

{

11854

MYSQL_STMT *stmt;

11855

MYSQL_BIND *my_bind;

11856

char *query;

11857

char *param_str;

11858

int param_str_length;

11859

const char *stmt_text;

11860

int rc;

11861

float float_array[250] =

11862

{

11863

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11864

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11865

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11866

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11867

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11868

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11869

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11870

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11871

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11872

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11873

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11874

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11875

0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

11876

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11877

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11878

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11879

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11880

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11881

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11882

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11883

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11884

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11885

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11886

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25,

11887

0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25

11888

};

11889

float *fa_ptr= float_array;

11890

/* Number of columns per row */

11891

const int COLUMN_COUNT= sizeof(float_array)/sizeof(*float_array);

11892

/* Number of rows per bulk insert to start with */

11893

const int MIN_ROWS_PER_INSERT= 262;

11894

/* Max number of rows per bulk insert to end with */

11895

const int MAX_ROWS_PER_INSERT= 300;

11896

const int MAX_PARAM_COUNT= COLUMN_COUNT*MAX_ROWS_PER_INSERT;

11897

const char *query_template= "insert into t1 values %s";

11898

const int CHARS_PER_PARAM= 5; /* space needed to place ", ?" in the query */

11899

const int uint16_max= 65535;

11900

int nrows, i;

11901

11902

myheader("test_bug5194");

11903

11904

stmt_text= "drop table if exists t1";

11905

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

11906

11907

stmt_text= "create table if not exists t1"

11908

"(c1 float, c2 float, c3 float, c4 float, c5 float, c6 float, "

11909

"c7 float, c8 float, c9 float, c10 float, c11 float, c12 float, "

11910

"c13 float, c14 float, c15 float, c16 float, c17 float, c18 float, "

11911

"c19 float, c20 float, c21 float, c22 float, c23 float, c24 float, "

11912

"c25 float, c26 float, c27 float, c28 float, c29 float, c30 float, "

11913

"c31 float, c32 float, c33 float, c34 float, c35 float, c36 float, "

11914

"c37 float, c38 float, c39 float, c40 float, c41 float, c42 float, "

11915

"c43 float, c44 float, c45 float, c46 float, c47 float, c48 float, "

11916

"c49 float, c50 float, c51 float, c52 float, c53 float, c54 float, "

11917

"c55 float, c56 float, c57 float, c58 float, c59 float, c60 float, "

11918

"c61 float, c62 float, c63 float, c64 float, c65 float, c66 float, "

11919

"c67 float, c68 float, c69 float, c70 float, c71 float, c72 float, "

11920

"c73 float, c74 float, c75 float, c76 float, c77 float, c78 float, "

11921

"c79 float, c80 float, c81 float, c82 float, c83 float, c84 float, "

11922

"c85 float, c86 float, c87 float, c88 float, c89 float, c90 float, "

11923

"c91 float, c92 float, c93 float, c94 float, c95 float, c96 float, "

11924

"c97 float, c98 float, c99 float, c100 float, c101 float, c102 float, "

11925

"c103 float, c104 float, c105 float, c106 float, c107 float, c108 float, "

11926

"c109 float, c110 float, c111 float, c112 float, c113 float, c114 float, "

11927

"c115 float, c116 float, c117 float, c118 float, c119 float, c120 float, "

11928

"c121 float, c122 float, c123 float, c124 float, c125 float, c126 float, "

11929

"c127 float, c128 float, c129 float, c130 float, c131 float, c132 float, "

11930

"c133 float, c134 float, c135 float, c136 float, c137 float, c138 float, "

11931

"c139 float, c140 float, c141 float, c142 float, c143 float, c144 float, "

11932

"c145 float, c146 float, c147 float, c148 float, c149 float, c150 float, "

11933

"c151 float, c152 float, c153 float, c154 float, c155 float, c156 float, "

11934

"c157 float, c158 float, c159 float, c160 float, c161 float, c162 float, "

11935

"c163 float, c164 float, c165 float, c166 float, c167 float, c168 float, "

11936

"c169 float, c170 float, c171 float, c172 float, c173 float, c174 float, "

11937

"c175 float, c176 float, c177 float, c178 float, c179 float, c180 float, "

11938

"c181 float, c182 float, c183 float, c184 float, c185 float, c186 float, "

11939

"c187 float, c188 float, c189 float, c190 float, c191 float, c192 float, "

11940

"c193 float, c194 float, c195 float, c196 float, c197 float, c198 float, "

11941

"c199 float, c200 float, c201 float, c202 float, c203 float, c204 float, "

11942

"c205 float, c206 float, c207 float, c208 float, c209 float, c210 float, "

11943

"c211 float, c212 float, c213 float, c214 float, c215 float, c216 float, "

11944

"c217 float, c218 float, c219 float, c220 float, c221 float, c222 float, "

11945

"c223 float, c224 float, c225 float, c226 float, c227 float, c228 float, "

11946

"c229 float, c230 float, c231 float, c232 float, c233 float, c234 float, "

11947

"c235 float, c236 float, c237 float, c238 float, c239 float, c240 float, "

11948

"c241 float, c242 float, c243 float, c244 float, c245 float, c246 float, "

11949

"c247 float, c248 float, c249 float, c250 float)";

11950

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

11951

myquery(rc);

11952

11953

my_bind= (MYSQL_BIND*) malloc(MAX_PARAM_COUNT * sizeof(MYSQL_BIND));

11954

query= (char*) malloc(strlen(query_template) +

11955

MAX_PARAM_COUNT * CHARS_PER_PARAM + 1);

11956

param_str= (char*) malloc(COLUMN_COUNT * CHARS_PER_PARAM);

11957

11958

if (my_bind == 0 || query == 0 || param_str == 0)

11959

{

11960

fprintf(stderr, "Can't allocate enough memory for query structs\n");

11961

if (my_bind)

11962

free(my_bind);

11963

if (query)

11964

free(query);

11965

if (param_str)

11966

free(param_str);

11967

return;

11968

}

11969

11970

stmt= mysql_stmt_init(mysql);

11971

11972

/* setup a template for one row of parameters */

11973

sprintf(param_str, "(");

11974

for (i= 1; i < COLUMN_COUNT; ++i)

11975

strcat(param_str, "?, ");

11976

strcat(param_str, "?)");

11977

param_str_length= strlen(param_str);

11978

11979

/* setup bind array */

11980

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

11981

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

11982

{

11983

my_bind[i].buffer_type= MYSQL_TYPE_FLOAT;

11984

my_bind[i].buffer= fa_ptr;

11985

if (++fa_ptr == float_array + COLUMN_COUNT)

11986

fa_ptr= float_array;

11987

}

11988

11989

11990

Test each number of rows per bulk insert, so that we can see where

11991

MySQL fails.

11992

11993

for (nrows= MIN_ROWS_PER_INSERT; nrows <= MAX_ROWS_PER_INSERT; ++nrows)

11994

{

11995

char *query_ptr;

11996

/* Create statement text for current number of rows */

11997

sprintf(query, query_template, param_str);

11998

query_ptr= query + strlen(query);

11999

for (i= 1; i < nrows; ++i)

12000

{

12001

memcpy(query_ptr, ", ", 2);

12002

query_ptr+= 2;

12003

memcpy(query_ptr, param_str, param_str_length);

12004

query_ptr+= param_str_length;

12005

}

12006

*query_ptr= '\0';

12007

12008

rc= mysql_stmt_prepare(stmt, query, query_ptr - query);

12009

if (rc && nrows * COLUMN_COUNT > uint16_max)

12010

{

12011

if (!opt_silent)

12012

printf("Failed to prepare a statement with %d placeholders "

12013

"(as expected).\n", nrows * COLUMN_COUNT);

12014

break;

12015

}

12016

else

12017

check_execute(stmt, rc);

12018

12019

if (!opt_silent)

12020

printf("Insert: query length= %d, row count= %d, param count= %lu\n",

12021

(int) strlen(query), nrows, mysql_stmt_param_count(stmt));

12022

12023

/* bind the parameter array and execute the query */

12024

rc= mysql_stmt_bind_param(stmt, my_bind);

12025

check_execute(stmt, rc);

12026

12027

rc= mysql_stmt_execute(stmt);

12028

check_execute(stmt, rc);

12029

mysql_stmt_reset(stmt);

12030

}

12031

12032

mysql_stmt_close(stmt);

12033

free(my_bind);

12034

free(query);

12035

free(param_str);

12036

stmt_text= "drop table t1";

12037

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

12038

myquery(rc);

12039

}

12040

12041

12042

static void test_bug5315()

12043

{

12044

MYSQL_STMT *stmt;

12045

const char *stmt_text;

12046

int rc;

12047

12048

myheader("test_bug5315");

12049

12050

stmt_text= "SELECT 1";

12051

stmt= mysql_stmt_init(mysql);

12052

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

12053

DIE_UNLESS(rc == 0);

12054

if (!opt_silent)

12055

printf("Excuting mysql_change_user\n");

12056

mysql_change_user(mysql, opt_user, opt_password, current_db);

12057

if (!opt_silent)

12058

printf("Excuting mysql_stmt_execute\n");

12059

rc= mysql_stmt_execute(stmt);

12060

DIE_UNLESS(rc != 0);

12061

if (rc)

12062

{

12063

if (!opt_silent)

12064

printf("Got error (as expected): '%s'\n", mysql_stmt_error(stmt));

12065

}

12066

/* check that connection is OK */

12067

if (!opt_silent)

12068

printf("Excuting mysql_stmt_close\n");

12069

mysql_stmt_close(stmt);

12070

if (!opt_silent)

12071

printf("Excuting mysql_stmt_init\n");

12072

stmt= mysql_stmt_init(mysql);

12073

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

12074

DIE_UNLESS(rc == 0);

12075

rc= mysql_stmt_execute(stmt);

12076

DIE_UNLESS(rc == 0);

12077

mysql_stmt_close(stmt);

12078

}

12079

12080

12081

static void test_bug6049()

12082

{

12083

MYSQL_STMT *stmt;

12084

MYSQL_BIND my_bind[1];

12085

MYSQL_RES *res;

12086

MYSQL_ROW row;

12087

const char *stmt_text;

12088

char buffer[30];

12089

ulong length;

12090

int rc;

12091

12092

myheader("test_bug6049");

12093

12094

stmt_text= "SELECT MAKETIME(-25, 12, 12)";

12095

12096

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

12097

myquery(rc);

12098

res= mysql_store_result(mysql);

12099

row= mysql_fetch_row(res);

12100

12101

stmt= mysql_stmt_init(mysql);

12102

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

12103

check_execute(stmt, rc);

12104

rc= mysql_stmt_execute(stmt);

12105

check_execute(stmt, rc);

12106

12107

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

12108

my_bind[0].buffer_type = MYSQL_TYPE_STRING;

12109

my_bind[0].buffer = &buffer;

12110

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

12111

my_bind[0].length = &length;

12112

12113

mysql_stmt_bind_result(stmt, my_bind);

12114

rc= mysql_stmt_fetch(stmt);

12115

DIE_UNLESS(rc == 0);

12116

12117

if (!opt_silent)

12118

{

12119

printf("Result from query: %s\n", row[0]);

12120

printf("Result from prepared statement: %s\n", (char*) buffer);

12121

}

12122

12123

DIE_UNLESS(strcmp(row[0], (char*) buffer) == 0);

12124

12125

mysql_free_result(res);

12126

mysql_stmt_close(stmt);

12127

}

12128

12129

12130

static void test_bug6058()

12131

{

12132

MYSQL_STMT *stmt;

12133

MYSQL_BIND my_bind[1];

12134

MYSQL_RES *res;

12135

MYSQL_ROW row;

12136

const char *stmt_text;

12137

char buffer[30];

12138

ulong length;

12139

int rc;

12140

12141

myheader("test_bug6058");

12142

12143

rc= mysql_query(mysql, "SET SQL_MODE=''");

12144

myquery(rc);

12145

12146

stmt_text= "SELECT CAST('0000-00-00' AS DATE)";

12147

12148

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

12149

myquery(rc);

12150

res= mysql_store_result(mysql);

12151

row= mysql_fetch_row(res);

12152

12153

stmt= mysql_stmt_init(mysql);

12154

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

12155

check_execute(stmt, rc);

12156

rc= mysql_stmt_execute(stmt);

12157

check_execute(stmt, rc);

12158

12159

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

12160

my_bind[0].buffer_type = MYSQL_TYPE_STRING;

12161

my_bind[0].buffer = &buffer;

12162

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

12163

my_bind[0].length = &length;

12164

12165

mysql_stmt_bind_result(stmt, my_bind);

12166

rc= mysql_stmt_fetch(stmt);

12167

DIE_UNLESS(rc == 0);

12168

12169

if (!opt_silent)

12170

{

12171

printf("Result from query: %s\n", row[0]);

12172

printf("Result from prepared statement: %s\n", buffer);

12173

}

12174

12175

DIE_UNLESS(strcmp(row[0], buffer) == 0);

12176

12177

mysql_free_result(res);

12178

mysql_stmt_close(stmt);

12179

}

12180

12181

12182

static void test_bug6059()

12183

{

12184

MYSQL_STMT *stmt;

12185

const char *stmt_text;

12186

12187

myheader("test_bug6059");

12188

12189

stmt_text= "SELECT 'foo' INTO OUTFILE 'x.3'";

12190

12191

stmt= mysql_stmt_init(mysql);

12192

(void) mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));

12193

DIE_UNLESS(mysql_stmt_field_count(stmt) == 0);

12194

mysql_stmt_close(stmt);

12195

}

12196

12197

12198

static void test_bug6046()

12199

{

12200

MYSQL_STMT *stmt;

12201

const char *stmt_text;

12202

int rc;

12203

short b= 1;

12204

MYSQL_BIND my_bind[1];

12205

12206

myheader("test_bug6046");

12207

12208

stmt_text= "DROP TABLE IF EXISTS t1";

12209

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

12210

myquery(rc);

12211

stmt_text= "CREATE TABLE t1 (a int, b int)";

12212

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

12213

myquery(rc);

12214

stmt_text= "INSERT INTO t1 VALUES (1,1),(2,2),(3,1),(4,2)";

12215

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

12216

myquery(rc);

12217

12218

stmt= mysql_stmt_init(mysql);

12219

12220

stmt_text= "SELECT t1.a FROM t1 NATURAL JOIN t1 as X1 "

12221

"WHERE t1.b > ? ORDER BY t1.a";

12222

12223

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

12224

check_execute(stmt, rc);

12225

12226

b= 1;

12227

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

12228

my_bind[0].buffer= &b;

12229

my_bind[0].buffer_type= MYSQL_TYPE_SHORT;

12230

12231

mysql_stmt_bind_param(stmt, my_bind);

12232

12233

rc= mysql_stmt_execute(stmt);

12234

check_execute(stmt, rc);

12235

mysql_stmt_store_result(stmt);

12236

12237

rc= mysql_stmt_execute(stmt);

12238

check_execute(stmt, rc);

12239

12240

mysql_stmt_close(stmt);

12241

}

12242

12243

12244

12245

static void test_basic_cursors()

12246

{

12247

const char *basic_tables[]=

12248

{

12249

"DROP TABLE IF EXISTS t1, t2",

12250

12251

"CREATE TABLE t1 "

12252

"(id INTEGER NOT NULL PRIMARY KEY, "

12253

" name VARCHAR(20) NOT NULL)",

12254

12255

"INSERT INTO t1 (id, name) VALUES "

12256

" (2, 'Ja'), (3, 'Ede'), "

12257

" (4, 'Haag'), (5, 'Kabul'), "

12258

" (6, 'Almere'), (7, 'Utrecht'), "

12259

" (8, 'Qandahar'), (9, 'Amsterdam'), "

12260

" (10, 'Amersfoort'), (11, 'Constantine')",

12261

12262

"CREATE TABLE t2 "

12263

"(id INTEGER NOT NULL PRIMARY KEY, "

12264

" name VARCHAR(20) NOT NULL)",

12265

12266

"INSERT INTO t2 (id, name) VALUES "

12267

" (4, 'Guam'), (5, 'Aruba'), "

12268

" (6, 'Angola'), (7, 'Albania'), "

12269

" (8, 'Anguilla'), (9, 'Argentina'), "

12270

" (10, 'Azerbaijan'), (11, 'Afghanistan'), "

12271

" (12, 'Burkina Faso'), (13, 'Faroe Islands')"

12272

};

12273

const char *queries[]=

12274

{

12275

"SELECT * FROM t1",

12276

"SELECT * FROM t2"

12277

};

12278

12279

DBUG_ENTER("test_basic_cursors");

12280

myheader("test_basic_cursors");

12281

12282

fill_tables(basic_tables, sizeof(basic_tables)/sizeof(*basic_tables));

12283

12284

fetch_n(queries, sizeof(queries)/sizeof(*queries), USE_ROW_BY_ROW_FETCH);

12285

fetch_n(queries, sizeof(queries)/sizeof(*queries), USE_STORE_RESULT);

12286

DBUG_VOID_RETURN;

12287

}

12288

12289

12290

static void test_cursors_with_union()

12291

{

12292

const char *queries[]=

12293

{

12294

"SELECT t1.name FROM t1 UNION SELECT t2.name FROM t2",

12295

"SELECT t1.id FROM t1 WHERE t1.id < 5"

12296

};

12297

myheader("test_cursors_with_union");

12298

fetch_n(queries, sizeof(queries)/sizeof(*queries), USE_ROW_BY_ROW_FETCH);

12299

fetch_n(queries, sizeof(queries)/sizeof(*queries), USE_STORE_RESULT);

12300

}

12301

12302

12303

static void test_cursors_with_procedure()

12304

{

12305

const char *queries[]=

12306

{

12307

"SELECT * FROM t1 procedure analyse()"

12308

};

12309

myheader("test_cursors_with_procedure");

12310

fetch_n(queries, sizeof(queries)/sizeof(*queries), USE_ROW_BY_ROW_FETCH);

12311

fetch_n(queries, sizeof(queries)/sizeof(*queries), USE_STORE_RESULT);

12312

}

12313

12314

12315

12316

Altough mysql_create_db(), mysql_rm_db() are deprecated since 4.0 they

12317

should not crash server and should not hang in case of errors.

12318

12319

Since those functions can't be seen in modern API (unless client library

12320

was compiled with USE_OLD_FUNCTIONS define) we use simple_command() macro.

12321

12322

static void test_bug6081()

12323

{

12324

int rc;

12325

myheader("test_bug6081");

12326

12327

rc= simple_command(mysql, COM_DROP_DB, (uchar*) current_db,

12328

(ulong)strlen(current_db), 0);

12329

if (rc == 0 && mysql_errno(mysql) != ER_UNKNOWN_COM_ERROR)

12330

{

12331

myerror(NULL); /* purecov: inspected */

12332

die(__FILE__, __LINE__, "COM_DROP_DB failed"); /* purecov: inspected */

12333

}

12334

rc= simple_command(mysql, COM_DROP_DB, (uchar*) current_db,

12335

(ulong)strlen(current_db), 0);

12336

myquery_r(rc);

12337

rc= simple_command(mysql, COM_CREATE_DB, (uchar*) current_db,

12338

(ulong)strlen(current_db), 0);

12339

if (rc == 0 && mysql_errno(mysql) != ER_UNKNOWN_COM_ERROR)

12340

{

12341

myerror(NULL); /* purecov: inspected */

12342

die(__FILE__, __LINE__, "COM_CREATE_DB failed"); /* purecov: inspected */

12343

}

12344

rc= simple_command(mysql, COM_CREATE_DB, (uchar*) current_db,

12345

(ulong)strlen(current_db), 0);

12346

myquery_r(rc);

12347

rc= mysql_select_db(mysql, current_db);

12348

myquery(rc);

12349

}

12350

12351

12352

static void test_bug6096()

12353

{

12354

MYSQL_STMT *stmt;

12355

MYSQL_RES *query_result, *stmt_metadata;

12356

const char *stmt_text;

12357

MYSQL_BIND my_bind[12];

12358

MYSQL_FIELD *query_field_list, *stmt_field_list;

12359

ulong query_field_count, stmt_field_count;

12360

int rc;

12361

my_bool update_max_length= TRUE;

12362

uint i;

12363

12364

myheader("test_bug6096");

12365

12366

stmt_text= "drop table if exists t1";

12367

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

12368

myquery(rc);

12369

12370

mysql_query(mysql, "set sql_mode=''");

12371

stmt_text= "create table t1 (c_tinyint tinyint, c_smallint smallint, "

12372

" c_mediumint mediumint, c_int int, "

12373

" c_bigint bigint, c_float float, "

12374

" c_double double, c_varchar varchar(20), "

12375

" c_char char(20), c_time time, c_date date, "

12376

" c_datetime datetime)";

12377

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

12378

myquery(rc);

12379

stmt_text= "insert into t1 values (-100, -20000, 30000000, 4, 8, 1.0, "

12380

"2.0, 'abc', 'def', now(), now(), now())";

12381

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

12382

myquery(rc);

12383

12384

stmt_text= "select * from t1";

12385

12386

/* Run select in prepared and non-prepared mode and compare metadata */

12387

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

12388

myquery(rc);

12389

query_result= mysql_store_result(mysql);

12390

query_field_list= mysql_fetch_fields(query_result);

12391

query_field_count= mysql_num_fields(query_result);

12392

12393

stmt= mysql_stmt_init(mysql);

12394

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

12395

check_execute(stmt, rc);

12396

rc= mysql_stmt_execute(stmt);

12397

check_execute(stmt, rc);

12398

mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH,

12399

(void*) &update_max_length);

12400

mysql_stmt_store_result(stmt);

12401

stmt_metadata= mysql_stmt_result_metadata(stmt);

12402

stmt_field_list= mysql_fetch_fields(stmt_metadata);

12403

stmt_field_count= mysql_num_fields(stmt_metadata);

12404

DIE_UNLESS(stmt_field_count == query_field_count);

12405

12406

/* Print out and check the metadata */

12407

12408

if (!opt_silent)

12409

{

12410

printf(" ------------------------------------------------------------\n");

12411

printf(" | Metadata \n");

12412

printf(" ------------------------------------------------------------\n");

12413

printf(" | Query | Prepared statement \n");

12414

printf(" ------------------------------------------------------------\n");

12415

printf(" field name | length | max_length | length | max_length\n");

12416

printf(" ------------------------------------------------------------\n");

12417

12418

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

12419

{

12420

MYSQL_FIELD *f1= &query_field_list[i], *f2= &stmt_field_list[i];

12421

printf(" %-11s | %9lu | %10lu | %9lu | %10lu \n",

12422

f1->name, f1->length, f1->max_length, f2->length, f2->max_length);

12423

DIE_UNLESS(f1->length == f2->length);

12424

}

12425

printf(" ---------------------------------------------------------------\n");

12426

}

12427

12428

/* Bind and fetch the data */

12429

12430

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

12431

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

12432

{

12433

my_bind[i].buffer_type= MYSQL_TYPE_STRING;

12434

my_bind[i].buffer_length= stmt_field_list[i].max_length + 1;

12435

my_bind[i].buffer= malloc(my_bind[i].buffer_length);

12436

}

12437

mysql_stmt_bind_result(stmt, my_bind);

12438

rc= mysql_stmt_fetch(stmt);

12439

check_execute(stmt, rc);

12440

rc= mysql_stmt_fetch(stmt);

12441

DIE_UNLESS(rc == MYSQL_NO_DATA);

12442

12443

/* Clean up */

12444

12445

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

12446

free(my_bind[i].buffer);

12447

mysql_stmt_close(stmt);

12448

mysql_free_result(query_result);

12449

mysql_free_result(stmt_metadata);

12450

stmt_text= "drop table t1";

12451

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

12452

myquery(rc);

12453

}

12454

12455

12456

12457

Test of basic checks that are performed in server for components

12458

of MYSQL_TIME parameters.

12459

12460

12461

static void test_datetime_ranges()

12462

{

12463

const char *stmt_text;

12464

int rc, i;

12465

MYSQL_STMT *stmt;

12466

MYSQL_BIND my_bind[6];

12467

MYSQL_TIME tm[6];

12468

12469

myheader("test_datetime_ranges");

12470

12471

stmt_text= "drop table if exists t1";

12472

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

12473

myquery(rc);

12474

12475

stmt_text= "create table t1 (year datetime, month datetime, day datetime, "

12476

"hour datetime, min datetime, sec datetime)";

12477

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

12478

myquery(rc);

12479

12480

stmt= mysql_simple_prepare(mysql,

12481

"INSERT INTO t1 VALUES (?, ?, ?, ?, ?, ?)");

12482

check_stmt(stmt);

12483

verify_param_count(stmt, 6);

12484

12485

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

12486

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

12487

{

12488

my_bind[i].buffer_type= MYSQL_TYPE_DATETIME;

12489

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

12490

}

12491

rc= mysql_stmt_bind_param(stmt, my_bind);

12492

check_execute(stmt, rc);

12493

12494

tm[0].year= 2004; tm[0].month= 11; tm[0].day= 10;

12495

tm[0].hour= 12; tm[0].minute= 30; tm[0].second= 30;

12496

tm[0].second_part= 0; tm[0].neg= 0;

12497

12498

tm[5]= tm[4]= tm[3]= tm[2]= tm[1]= tm[0];

12499

tm[0].year= 10000; tm[1].month= 13; tm[2].day= 32;

12500

tm[3].hour= 24; tm[4].minute= 60; tm[5].second= 60;

12501

12502

rc= mysql_stmt_execute(stmt);

12503

check_execute(stmt, rc);

12504

DIE_UNLESS(mysql_warning_count(mysql) != 6);

12505

12506

verify_col_data("t1", "year", "0000-00-00 00:00:00");

12507

verify_col_data("t1", "month", "0000-00-00 00:00:00");

12508

verify_col_data("t1", "day", "0000-00-00 00:00:00");

12509

verify_col_data("t1", "hour", "0000-00-00 00:00:00");

12510

verify_col_data("t1", "min", "0000-00-00 00:00:00");

12511

verify_col_data("t1", "sec", "0000-00-00 00:00:00");

12512

12513

mysql_stmt_close(stmt);

12514

12515

stmt_text= "delete from t1";

12516

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

12517

myquery(rc);

12518

12519

stmt= mysql_simple_prepare(mysql, "INSERT INTO t1 (year, month, day) "

12520

"VALUES (?, ?, ?)");

12521

check_stmt(stmt);

12522

verify_param_count(stmt, 3);

12523

12524

12525

We reuse contents of bind and tm arrays left from previous part of test.

12526

12527

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

12528

my_bind[i].buffer_type= MYSQL_TYPE_DATE;

12529

12530

rc= mysql_stmt_bind_param(stmt, my_bind);

12531

check_execute(stmt, rc);

12532

12533

rc= mysql_stmt_execute(stmt);

12534

check_execute(stmt, rc);

12535

DIE_UNLESS(mysql_warning_count(mysql) != 3);

12536

12537

verify_col_data("t1", "year", "0000-00-00 00:00:00");

12538

verify_col_data("t1", "month", "0000-00-00 00:00:00");

12539

verify_col_data("t1", "day", "0000-00-00 00:00:00");

12540

12541

mysql_stmt_close(stmt);

12542

12543

stmt_text= "drop table t1";

12544

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

12545

myquery(rc);

12546

12547

stmt_text= "create table t1 (day_ovfl time, day time, hour time, min time, sec time)";

12548

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

12549

myquery(rc);

12550

12551

stmt= mysql_simple_prepare(mysql,

12552

"INSERT INTO t1 VALUES (?, ?, ?, ?, ?)");

12553

check_stmt(stmt);

12554

verify_param_count(stmt, 5);

12555

12556

12557

Again we reuse what we can from previous part of test.

12558

12559

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

12560

my_bind[i].buffer_type= MYSQL_TYPE_TIME;

12561

12562

rc= mysql_stmt_bind_param(stmt, my_bind);

12563

check_execute(stmt, rc);

12564

12565

tm[0].year= 0; tm[0].month= 0; tm[0].day= 10;

12566

tm[0].hour= 12; tm[0].minute= 30; tm[0].second= 30;

12567

tm[0].second_part= 0; tm[0].neg= 0;

12568

12569

tm[4]= tm[3]= tm[2]= tm[1]= tm[0];

12570

tm[0].day= 35; tm[1].day= 34; tm[2].hour= 30; tm[3].minute= 60; tm[4].second= 60;

12571

12572

rc= mysql_stmt_execute(stmt);

12573

check_execute(stmt, rc);

12574

DIE_UNLESS(mysql_warning_count(mysql) == 2);

12575

12576

verify_col_data("t1", "day_ovfl", "838:59:59");

12577

verify_col_data("t1", "day", "828:30:30");

12578

verify_col_data("t1", "hour", "270:30:30");

12579

verify_col_data("t1", "min", "00:00:00");

12580

verify_col_data("t1", "sec", "00:00:00");

12581

12582

mysql_stmt_close(stmt);

12583

12584

stmt_text= "drop table t1";

12585

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

12586

myquery(rc);

12587

}

12588

12589

12590

static void test_bug4172()

12591

{

12592

MYSQL_STMT *stmt;

12593

MYSQL_BIND my_bind[3];

12594

const char *stmt_text;

12595

MYSQL_RES *res;

12596

MYSQL_ROW row;

12597

int rc;

12598

char f[100], d[100], e[100];

12599

ulong f_len, d_len, e_len;

12600

12601

myheader("test_bug4172");

12602

12603

mysql_query(mysql, "DROP TABLE IF EXISTS t1");

12604

mysql_query(mysql, "CREATE TABLE t1 (f float, d double, e decimal(10,4))");

12605

mysql_query(mysql, "INSERT INTO t1 VALUES (12345.1234, 123456.123456, "

12606

"123456.1234)");

12607

12608

stmt= mysql_stmt_init(mysql);

12609

stmt_text= "SELECT f, d, e FROM t1";

12610

12611

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

12612

check_execute(stmt, rc);

12613

rc= mysql_stmt_execute(stmt);

12614

check_execute(stmt, rc);

12615

12616

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

12617

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

12618

my_bind[0].buffer= f;

12619

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

12620

my_bind[0].length= &f_len;

12621

my_bind[1].buffer_type= MYSQL_TYPE_STRING;

12622

my_bind[1].buffer= d;

12623

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

12624

my_bind[1].length= &d_len;

12625

my_bind[2].buffer_type= MYSQL_TYPE_STRING;

12626

my_bind[2].buffer= e;

12627

my_bind[2].buffer_length= sizeof(e);

12628

my_bind[2].length= &e_len;

12629

12630

mysql_stmt_bind_result(stmt, my_bind);

12631

12632

mysql_stmt_store_result(stmt);

12633

rc= mysql_stmt_fetch(stmt);

12634

check_execute(stmt, rc);

12635

12636

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

12637

myquery(rc);

12638

res= mysql_store_result(mysql);

12639

row= mysql_fetch_row(res);

12640

12641

if (!opt_silent)

12642

{

12643

printf("Binary protocol: float=%s, double=%s, decimal(10,4)=%s\n",

12644

f, d, e);

12645

printf("Text protocol: float=%s, double=%s, decimal(10,4)=%s\n",

12646

row[0], row[1], row[2]);

12647

}

12648

DIE_UNLESS(!strcmp(f, row[0]) && !strcmp(d, row[1]) && !strcmp(e, row[2]));

12649

12650

mysql_free_result(res);

12651

mysql_stmt_close(stmt);

12652

}

12653

12654

12655

static void test_conversion()

12656

{

12657

MYSQL_STMT *stmt;

12658

const char *stmt_text;

12659

int rc;

12660

MYSQL_BIND my_bind[1];

12661

char buff[4];

12662

ulong length;

12663

12664

myheader("test_conversion");

12665

12666

stmt_text= "DROP TABLE IF EXISTS t1";

12667

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

12668

myquery(rc);

12669

stmt_text= "CREATE TABLE t1 (a TEXT) DEFAULT CHARSET latin1";

12670

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

12671

myquery(rc);

12672

stmt_text= "SET character_set_connection=utf8, character_set_client=utf8, "

12673

" character_set_results=latin1";

12674

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

12675

myquery(rc);

12676

12677

stmt= mysql_stmt_init(mysql);

12678

12679

stmt_text= "INSERT INTO t1 (a) VALUES (?)";

12680

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

12681

check_execute(stmt, rc);

12682

12683

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

12684

my_bind[0].buffer= buff;

12685

my_bind[0].length= &length;

12686

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

12687

12688

mysql_stmt_bind_param(stmt, my_bind);

12689

12690

buff[0]= (uchar) 0xC3;

12691

buff[1]= (uchar) 0xA0;

12692

length= 2;

12693

12694

rc= mysql_stmt_execute(stmt);

12695

check_execute(stmt, rc);

12696

12697

stmt_text= "SELECT a FROM t1";

12698

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

12699

check_execute(stmt, rc);

12700

rc= mysql_stmt_execute(stmt);

12701

check_execute(stmt, rc);

12702

12703

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

12704

mysql_stmt_bind_result(stmt, my_bind);

12705

12706

rc= mysql_stmt_fetch(stmt);

12707

DIE_UNLESS(rc == 0);

12708

DIE_UNLESS(length == 1);

12709

DIE_UNLESS((uchar) buff[0] == 0xE0);

12710

rc= mysql_stmt_fetch(stmt);

12711

DIE_UNLESS(rc == MYSQL_NO_DATA);

12712

12713

mysql_stmt_close(stmt);

12714

stmt_text= "DROP TABLE t1";

12715

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

12716

myquery(rc);

12717

stmt_text= "SET NAMES DEFAULT";

12718

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

12719

myquery(rc);

12720

}

12721

12722

static void test_rewind(void)

12723

{

12724

MYSQL_STMT *stmt;

12725

MYSQL_BIND my_bind;

12726

int rc = 0;

12727

const char *stmt_text;

12728

long unsigned int length=4, Data=0;

12729

my_bool isnull=0;

12730

12731

myheader("test_rewind");

12732

12733

stmt_text= "CREATE TABLE t1 (a int)";

12734

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

12735

myquery(rc);

12736

stmt_text= "INSERT INTO t1 VALUES(2),(3),(4)";

12737

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

12738

myquery(rc);

12739

12740

stmt= mysql_stmt_init(mysql);

12741

12742

stmt_text= "SELECT * FROM t1";

12743

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

12744

check_execute(stmt, rc);

12745

12746

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

12747

my_bind.buffer_type= MYSQL_TYPE_LONG;

12748

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

12749

my_bind.length= &length;

12750

my_bind.is_null= &isnull;

12751

12752

rc= mysql_stmt_execute(stmt);

12753

check_execute(stmt, rc);

12754

12755

rc= mysql_stmt_store_result(stmt);

12756

DIE_UNLESS(rc == 0);

12757

12758

rc= mysql_stmt_bind_result(stmt, &my_bind);

12759

DIE_UNLESS(rc == 0);

12760

12761

/* retreive all result sets till we are at the end */

12762

while(!mysql_stmt_fetch(stmt))

12763

if (!opt_silent)

12764

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

12765

12766

DIE_UNLESS(rc != MYSQL_NO_DATA);

12767

12768

/* seek to the first row */

12769

mysql_stmt_data_seek(stmt, 0);

12770

12771

/* now we should be able to fetch the results again */

12772

/* but mysql_stmt_fetch returns MYSQL_NO_DATA */

12773

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

12774

if (!opt_silent)

12775

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

12776

12777

DIE_UNLESS(rc == MYSQL_NO_DATA);

12778

12779

stmt_text= "DROP TABLE t1";

12780

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

12781

myquery(rc);

12782

rc= mysql_stmt_free_result(stmt);

12783

rc= mysql_stmt_close(stmt);

12784

}

12785

12786

12787

static void test_truncation()

12788

{

12789

MYSQL_STMT *stmt;

12790

const char *stmt_text;

12791

int rc;

12792

uint bind_count;

12793

MYSQL_BIND *bind_array, *my_bind;

12794

12795

myheader("test_truncation");

12796

12797

/* Prepare the test table */

12798

rc= mysql_query(mysql, "drop table if exists t1");

12799

myquery(rc);

12800

12801

stmt_text= "create table t1 ("

12802

"i8 tinyint, ui8 tinyint unsigned, "

12803

"i16 smallint, i16_1 smallint, "

12804

"ui16 smallint unsigned, i32 int, i32_1 int, "

12805

"d double, d_1 double, ch char(30), ch_1 char(30), "

12806

"tx text, tx_1 text, ch_2 char(30) "

12807

")";

12808

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

12809

myquery(rc);

12810

stmt_text= "insert into t1 VALUES ("

12811

"-10, " /* i8 */

12812

"200, " /* ui8 */

12813

"32000, " /* i16 */

12814

"-32767, " /* i16_1 */

12815

"64000, " /* ui16 */

12816

"1073741824, " /* i32 */

12817

"1073741825, " /* i32_1 */

12818

"123.456, " /* d */

12819

"-12345678910, " /* d_1 */

12820

"'111111111111111111111111111111',"/* ch */

12821

"'abcdef', " /* ch_1 */

12822

"'12345 ', " /* tx */

12823

"'12345.67 ', " /* tx_1 */

12824

"'12345.67abc'" /* ch_2 */

12825

")";

12826

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

12827

myquery(rc);

12828

12829

stmt_text= "select i8 c1, i8 c2, ui8 c3, i16_1 c4, ui16 c5, "

12830

" i16 c6, ui16 c7, i32 c8, i32_1 c9, i32_1 c10, "

12831

" d c11, d_1 c12, d_1 c13, ch c14, ch_1 c15, tx c16, "

12832

" tx_1 c17, ch_2 c18 "

12833

"from t1";

12834

12835

stmt= mysql_stmt_init(mysql);

12836

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

12837

check_execute(stmt, rc);

12838

rc= mysql_stmt_execute(stmt);

12839

check_execute(stmt, rc);

12840

bind_count= (uint) mysql_stmt_field_count(stmt);

12841

12842

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

12843

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

12844

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

12845

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

12846

my_bind->error= &my_bind->error_value;

12847

my_bind= bind_array;

12848

12849

my_bind->buffer= malloc(sizeof(uint8));

12850

my_bind->buffer_type= MYSQL_TYPE_TINY;

12851

my_bind->is_unsigned= TRUE;

12852

12853

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12854

my_bind->buffer= malloc(sizeof(uint32));

12855

my_bind->buffer_type= MYSQL_TYPE_LONG;

12856

my_bind->is_unsigned= TRUE;

12857

12858

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12859

my_bind->buffer= malloc(sizeof(int8));

12860

my_bind->buffer_type= MYSQL_TYPE_TINY;

12861

12862

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12863

my_bind->buffer= malloc(sizeof(uint16));

12864

my_bind->buffer_type= MYSQL_TYPE_SHORT;

12865

my_bind->is_unsigned= TRUE;

12866

12867

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12868

my_bind->buffer= malloc(sizeof(int16));

12869

my_bind->buffer_type= MYSQL_TYPE_SHORT;

12870

12871

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12872

my_bind->buffer= malloc(sizeof(uint16));

12873

my_bind->buffer_type= MYSQL_TYPE_SHORT;

12874

my_bind->is_unsigned= TRUE;

12875

12876

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12877

my_bind->buffer= malloc(sizeof(int8));

12878

my_bind->buffer_type= MYSQL_TYPE_TINY;

12879

my_bind->is_unsigned= TRUE;

12880

12881

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12882

my_bind->buffer= malloc(sizeof(float));

12883

my_bind->buffer_type= MYSQL_TYPE_FLOAT;

12884

12885

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12886

my_bind->buffer= malloc(sizeof(float));

12887

my_bind->buffer_type= MYSQL_TYPE_FLOAT;

12888

12889

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12890

my_bind->buffer= malloc(sizeof(double));

12891

my_bind->buffer_type= MYSQL_TYPE_DOUBLE;

12892

12893

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12894

my_bind->buffer= malloc(sizeof(longlong));

12895

my_bind->buffer_type= MYSQL_TYPE_LONGLONG;

12896

12897

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12898

my_bind->buffer= malloc(sizeof(ulonglong));

12899

my_bind->buffer_type= MYSQL_TYPE_LONGLONG;

12900

my_bind->is_unsigned= TRUE;

12901

12902

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12903

my_bind->buffer= malloc(sizeof(longlong));

12904

my_bind->buffer_type= MYSQL_TYPE_LONGLONG;

12905

12906

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12907

my_bind->buffer= malloc(sizeof(longlong));

12908

my_bind->buffer_type= MYSQL_TYPE_LONGLONG;

12909

12910

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12911

my_bind->buffer= malloc(sizeof(longlong));

12912

my_bind->buffer_type= MYSQL_TYPE_LONGLONG;

12913

12914

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12915

my_bind->buffer= malloc(sizeof(longlong));

12916

my_bind->buffer_type= MYSQL_TYPE_LONGLONG;

12917

12918

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12919

my_bind->buffer= malloc(sizeof(double));

12920

my_bind->buffer_type= MYSQL_TYPE_DOUBLE;

12921

12922

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12923

my_bind->buffer= malloc(sizeof(double));

12924

my_bind->buffer_type= MYSQL_TYPE_DOUBLE;

12925

12926

rc= mysql_stmt_bind_result(stmt, bind_array);

12927

check_execute(stmt, rc);

12928

rc= mysql_stmt_fetch(stmt);

12929

DIE_UNLESS(rc == MYSQL_DATA_TRUNCATED);

12930

12931

/*************** Verify truncation results ***************************/

12932

my_bind= bind_array;

12933

12934

/* signed tiny -> tiny */

12935

DIE_UNLESS(*my_bind->error && * (int8*) my_bind->buffer == -10);

12936

12937

/* signed tiny -> uint32 */

12938

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12939

DIE_UNLESS(*my_bind->error && * (int32*) my_bind->buffer == -10);

12940

12941

/* unsigned tiny -> tiny */

12942

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12943

DIE_UNLESS(*my_bind->error && * (uint8*) my_bind->buffer == 200);

12944

12945

/* short -> ushort */

12946

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12947

DIE_UNLESS(*my_bind->error && * (int16*) my_bind->buffer == -32767);

12948

12949

/* ushort -> short */

12950

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12951

DIE_UNLESS(*my_bind->error && * (uint16*) my_bind->buffer == 64000);

12952

12953

/* short -> ushort (no truncation, data is in the range of target type) */

12954

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12955

DIE_UNLESS(! *my_bind->error && * (uint16*) my_bind->buffer == 32000);

12956

12957

/* ushort -> utiny */

12958

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12959

DIE_UNLESS(*my_bind->error && * (int8*) my_bind->buffer == 0);

12960

12961

/* int -> float: no truncation, the number is a power of two */

12962

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12963

DIE_UNLESS(! *my_bind->error && * (float*) my_bind->buffer == 1073741824);

12964

12965

/* int -> float: truncation, not enough bits in float */

12966

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12967

DIE_UNLESS(*my_bind->error);

12968

12969

/* int -> double: no truncation */

12970

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12971

DIE_UNLESS(! *my_bind->error && * (double*) my_bind->buffer == 1073741825);

12972

12973

/* double -> longlong: fractional part is lost */

12974

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12975

12976

/* double -> ulonglong, negative fp number to unsigned integer */

12977

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12978

/* Value in the buffer is not defined: don't test it */

12979

DIE_UNLESS(*my_bind->error);

12980

12981

/* double -> longlong, negative fp number to signed integer: no loss */

12982

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12983

DIE_UNLESS(! *my_bind->error && * (longlong*) my_bind->buffer == LL(-12345678910));

12984

12985

/* big numeric string -> number */

12986

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12987

DIE_UNLESS(*my_bind->error);

12988

12989

/* junk string -> number */

12990

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12991

DIE_UNLESS(*my_bind->error && *(longlong*) my_bind->buffer == 0);

12992

12993

/* string with trailing spaces -> number */

12994

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12995

DIE_UNLESS(! *my_bind->error && *(longlong*) my_bind->buffer == 12345);

12996

12997

/* string with trailing spaces -> double */

12998

DIE_UNLESS(my_bind++ < bind_array + bind_count);

12999

DIE_UNLESS(! *my_bind->error && *(double*) my_bind->buffer == 12345.67);

13000

13001

/* string with trailing junk -> double */

13002

DIE_UNLESS(my_bind++ < bind_array + bind_count);

13003

13004

XXX: There must be a truncation error: but it's not the way the server

13005

behaves, so let's leave it for now.

13006

13007

DIE_UNLESS(*(double*) my_bind->buffer == 12345.67);

13008

13009

TODO: string -> double, double -> time, double -> string (truncation

13010

errors are not supported here yet)

13011

longlong -> time/date/datetime

13012

date -> time, date -> timestamp, date -> number

13013

time -> string, time -> date, time -> timestamp,

13014

number -> date string -> date

13015

13016

/*************** Cleanup *********************************************/

13017

13018

mysql_stmt_close(stmt);

13019

13020

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

13021

free(my_bind->buffer);

13022

free(bind_array);

13023

13024

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

13025

myquery(rc);

13026

}

13027

13028

static void test_truncation_option()

13029

{

13030

MYSQL_STMT *stmt;

13031

const char *stmt_text;

13032

int rc;

13033

uint8 buf;

13034

my_bool option= 0;

13035

my_bool error;

13036

MYSQL_BIND my_bind;

13037

13038

myheader("test_truncation_option");

13039

13040

/* Prepare the test table */

13041

stmt_text= "select -1";

13042

13043

stmt= mysql_stmt_init(mysql);

13044

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

13045

check_execute(stmt, rc);

13046

rc= mysql_stmt_execute(stmt);

13047

check_execute(stmt, rc);

13048

13049

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

13050

13051

my_bind.buffer= (void*) &buf;

13052

my_bind.buffer_type= MYSQL_TYPE_TINY;

13053

my_bind.is_unsigned= TRUE;

13054

my_bind.error= &error;

13055

13056

rc= mysql_stmt_bind_result(stmt, &my_bind);

13057

check_execute(stmt, rc);

13058

rc= mysql_stmt_fetch(stmt);

13059

DIE_UNLESS(rc == MYSQL_DATA_TRUNCATED);

13060

DIE_UNLESS(error);

13061

rc= mysql_options(mysql, MYSQL_REPORT_DATA_TRUNCATION, (char*) &option);

13062

myquery(rc);

13063

/* need to rebind for the new setting to take effect */

13064

rc= mysql_stmt_bind_result(stmt, &my_bind);

13065

check_execute(stmt, rc);

13066

rc= mysql_stmt_execute(stmt);

13067

check_execute(stmt, rc);

13068

rc= mysql_stmt_fetch(stmt);

13069

check_execute(stmt, rc);

13070

/* The only change is rc - error pointers are still filled in */

13071

DIE_UNLESS(error == 1);

13072

/* restore back the defaults */

13073

option= 1;

13074

mysql_options(mysql, MYSQL_REPORT_DATA_TRUNCATION, (char*) &option);

13075

13076

mysql_stmt_close(stmt);

13077

}

13078

13079

13080

/* Bug#6761 - mysql_list_fields doesn't work */

13081

13082

static void test_bug6761(void)

13083

{

13084

const char *stmt_text;

13085

MYSQL_RES *res;

13086

int rc;

13087

myheader("test_bug6761");

13088

13089

stmt_text= "CREATE TABLE t1 (a int, b char(255), c decimal)";

13090

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

13091

myquery(rc);

13092

13093

res= mysql_list_fields(mysql, "t1", "%");

13094

DIE_UNLESS(res && mysql_num_fields(res) == 3);

13095

mysql_free_result(res);

13096

13097

stmt_text= "DROP TABLE t1";

13098

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

13099

myquery(rc);

13100

}

13101

13102

13103

/* Bug#8330 - mysql_stmt_execute crashes (libmysql) */

13104

13105

static void test_bug8330()

13106

{

13107

const char *stmt_text;

13108

MYSQL_STMT *stmt[2];

13109

int i, rc;

13110

const char *query= "select a,b from t1 where a=?";

13111

MYSQL_BIND my_bind[2];

13112

long lval[2];

13113

13114

myheader("test_bug8330");

13115

13116

stmt_text= "drop table if exists t1";

13117

/* in case some previos test failed */

13118

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

13119

myquery(rc);

13120

stmt_text= "create table t1 (a int, b int)";

13121

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

13122

myquery(rc);

13123

13124

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

13125

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

13126

{

13127

stmt[i]= mysql_stmt_init(mysql);

13128

rc= mysql_stmt_prepare(stmt[i], query, strlen(query));

13129

check_execute(stmt[i], rc);

13130

13131

my_bind[i].buffer_type= MYSQL_TYPE_LONG;

13132

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

13133

my_bind[i].is_null= 0;

13134

mysql_stmt_bind_param(stmt[i], &my_bind[i]);

13135

}

13136

13137

rc= mysql_stmt_execute(stmt[0]);

13138

check_execute(stmt[0], rc);

13139

13140

rc= mysql_stmt_execute(stmt[1]);

13141

DIE_UNLESS(rc && mysql_stmt_errno(stmt[1]) == CR_COMMANDS_OUT_OF_SYNC);

13142

rc= mysql_stmt_execute(stmt[0]);

13143

check_execute(stmt[0], rc);

13144

13145

mysql_stmt_close(stmt[0]);

13146

mysql_stmt_close(stmt[1]);

13147

13148

stmt_text= "drop table t1";

13149

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

13150

myquery(rc);

13151

}

13152

13153

13154

/* Bug#7990 - mysql_stmt_close doesn't reset mysql->net.last_error */

13155

13156

static void test_bug7990()

13157

{

13158

MYSQL_STMT *stmt;

13159

int rc;

13160

myheader("test_bug7990");

13161

13162

stmt= mysql_stmt_init(mysql);

13163

rc= mysql_stmt_prepare(stmt, "foo", 3);

13164

13165

XXX: the fact that we store errno both in STMT and in

13166

MYSQL is not documented and is subject to change in 5.0

13167

13168

DIE_UNLESS(rc && mysql_stmt_errno(stmt) && mysql_errno(mysql));

13169

mysql_stmt_close(stmt);

13170

DIE_UNLESS(!mysql_errno(mysql));

13171

}

13172

13173

13174

Bug #15518 - Reusing a stmt that has failed during prepare

13175

does not clear error

13176

13177

13178

static void test_bug15518()

13179

{

13180

MYSQL_STMT *stmt;

13181

MYSQL* mysql1;

13182

int rc;

13183

myheader("test_bug15518");

13184

13185

mysql1= mysql_client_init(NULL);

13186

13187

if (!mysql_real_connect(mysql1, opt_host, opt_user, opt_password,

13188

opt_db ? opt_db : "test", opt_port, opt_unix_socket,

13189

CLIENT_MULTI_STATEMENTS))

13190

{

13191

fprintf(stderr, "Failed to connect to the database\n");

13192

DIE_UNLESS(0);

13193

}

13194

13195

stmt= mysql_stmt_init(mysql1);

13196

13197

13198

The prepare of foo should fail with errno 1064 since

13199

it's not a valid query

13200

13201

rc= mysql_stmt_prepare(stmt, "foo", 3);

13202

if (!opt_silent)

13203

fprintf(stdout, "rc: %d, mysql_stmt_errno: %d, mysql_errno: %d\n",

13204

rc, mysql_stmt_errno(stmt), mysql_errno(mysql1));

13205

DIE_UNLESS(rc && mysql_stmt_errno(stmt) && mysql_errno(mysql1));

13206

13207

13208

Use the same stmt and reprepare with another query that

13209

suceeds

13210

13211

rc= mysql_stmt_prepare(stmt, "SHOW STATUS", 12);

13212

if (!opt_silent)

13213

fprintf(stdout, "rc: %d, mysql_stmt_errno: %d, mysql_errno: %d\n",

13214

rc, mysql_stmt_errno(stmt), mysql_errno(mysql1));

13215

DIE_UNLESS(!rc || mysql_stmt_errno(stmt) || mysql_errno(mysql1));

13216

13217

mysql_stmt_close(stmt);

13218

DIE_UNLESS(!mysql_errno(mysql1));

13219

13220

13221

part2, when connection to server has been closed

13222

after first prepare

13223

13224

stmt= mysql_stmt_init(mysql1);

13225

rc= mysql_stmt_prepare(stmt, "foo", 3);

13226

if (!opt_silent)

13227

fprintf(stdout, "rc: %d, mysql_stmt_errno: %d, mysql_errno: %d\n",

13228

rc, mysql_stmt_errno(stmt), mysql_errno(mysql1));

13229

DIE_UNLESS(rc && mysql_stmt_errno(stmt) && mysql_errno(mysql1));

13230

13231

/* Close connection to server */

13232

mysql_close(mysql1);

13233

13234

13235

Use the same stmt and reprepare with another query that

13236

suceeds. The prepare should fail with error 2013 since

13237

connection to server has been closed.

13238

13239

rc= mysql_stmt_prepare(stmt, "SHOW STATUS", 12);

13240

if (!opt_silent)

13241

fprintf(stdout, "rc: %d, mysql_stmt_errno: %d\n",

13242

rc, mysql_stmt_errno(stmt));

13243

DIE_UNLESS(rc && mysql_stmt_errno(stmt));

13244

13245

mysql_stmt_close(stmt);

13246

}

13247

13248

13249

static void disable_general_log()

13250

{

13251

int rc;

13252

rc= mysql_query(mysql, "set @@global.general_log=off");

13253

myquery(rc);

13254

}

13255

13256

13257

static void enable_general_log(int truncate)

13258

{

13259

int rc;

13260

13261

rc= mysql_query(mysql, "set @save_global_general_log=@@global.general_log");

13262

myquery(rc);

13263

13264

rc= mysql_query(mysql, "set @@global.general_log=on");

13265

myquery(rc);

13266

13267

if (truncate)

13268

{

13269

rc= mysql_query(mysql, "truncate mysql.general_log");

13270

myquery(rc);

13271

}

13272

}

13273

13274

13275

static void restore_general_log()

13276

{

13277

int rc;

13278

rc= mysql_query(mysql, "set @@global.general_log=@save_global_general_log");

13279

myquery(rc);

13280

}

13281

13282

13283

static void test_view_sp_list_fields()

13284

{

13285

int rc;

13286

MYSQL_RES *res;

13287

13288

myheader("test_view_sp_list_fields");

13289

13290

rc= mysql_query(mysql, "DROP FUNCTION IF EXISTS f1");

13291

myquery(rc);

13292

rc= mysql_query(mysql, "DROP TABLE IF EXISTS v1, t1, t2");

13293

myquery(rc);

13294

rc= mysql_query(mysql, "DROP VIEW IF EXISTS v1, t1, t2");

13295

myquery(rc);

13296

rc= mysql_query(mysql, "create function f1 () returns int return 5");

13297

myquery(rc);

13298

rc= mysql_query(mysql, "create table t1 (s1 char,s2 char)");

13299

myquery(rc);

13300

rc= mysql_query(mysql, "create table t2 (s1 int);");

13301

myquery(rc);

13302

rc= mysql_query(mysql, "create view v1 as select s2,sum(s1) - \

13303

count(s2) as vx from t1 group by s2 having sum(s1) - count(s2) < (select f1() \

13304

from t2);");

13305

myquery(rc);

13306

res= mysql_list_fields(mysql, "v1", NullS);

13307

DIE_UNLESS(res != 0 && mysql_num_fields(res) != 0);

13308

rc= mysql_query(mysql, "DROP FUNCTION f1");

13309

myquery(rc);

13310

rc= mysql_query(mysql, "DROP VIEW v1");

13311

myquery(rc);

13312

rc= mysql_query(mysql, "DROP TABLE t1, t2");

13313

mysql_free_result(res);

13314

myquery(rc);

13315

13316

}

13317

13318

13319

13320

Test mysql_real_escape_string() with gbk charset

13321

13322

The important part is that 0x27 (') is the second-byte in a invalid

13323

two-byte GBK character here. But 0xbf5c is a valid GBK character, so

13324

it needs to be escaped as 0x5cbf27

13325

13326

#define TEST_BUG8378_IN "\xef\xbb\xbf\x27\xbf\x10"

13327

#define TEST_BUG8378_OUT "\xef\xbb\x5c\xbf\x5c\x27\x5c\xbf\x10"

13328

13329

static void test_bug8378()

13330

{

13331

#if defined(HAVE_CHARSET_gbk) && !defined(EMBEDDED_LIBRARY)

13332

MYSQL *lmysql;

13333

char out[9]; /* strlen(TEST_BUG8378)*2+1 */

13334

char buf[256];

13335

int len, rc;

13336

13337

myheader("test_bug8378");

13338

13339

if (!opt_silent)

13340

fprintf(stdout, "\n Establishing a test connection ...");

13341

if (!(lmysql= mysql_client_init(NULL)))

13342

{

13343

myerror("mysql_client_init() failed");

13344

exit(1);

13345

}

13346

if (mysql_options(lmysql, MYSQL_SET_CHARSET_NAME, "gbk"))

13347

{

13348

myerror("mysql_options() failed");

13349

exit(1);

13350

}

13351

if (!(mysql_real_connect(lmysql, opt_host, opt_user,

13352

opt_password, current_db, opt_port,

13353

opt_unix_socket, 0)))

13354

{

13355

myerror("connection failed");

13356

exit(1);

13357

}

13358

if (!opt_silent)

13359

fprintf(stdout, "OK");

13360

13361

rc= mysql_query(lmysql, "SET SQL_MODE=''");

13362

myquery(rc);

13363

13364

len= mysql_real_escape_string(lmysql, out, TEST_BUG8378_IN, 4);

13365

13366

/* No escaping should have actually happened. */

13367

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

13368

13369

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

13370

13371

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

13372

myquery(rc);

13373

13374

mysql_close(lmysql);

13375

#endif

13376

}

13377

13378

13379

static void test_bug8722()

13380

{

13381

MYSQL_STMT *stmt;

13382

int rc;

13383

const char *stmt_text;

13384

13385

myheader("test_bug8722");

13386

/* Prepare test data */

13387

stmt_text= "drop table if exists t1, v1";

13388

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

13389

myquery(rc);

13390

stmt_text= "CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10),"

13391

" c4 varchar(10), c5 varchar(10), c6 varchar(10),"

13392

" c7 varchar(10), c8 varchar(10), c9 varchar(10),"

13393

"c10 varchar(10))";

13394

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

13395

myquery(rc);

13396

stmt_text= "INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)";

13397

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

13398

myquery(rc);

13399

stmt_text= "CREATE VIEW v1 AS SELECT * FROM t1";

13400

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

13401

myquery(rc);

13402

/* Note: if you uncomment following block everything works fine */

13403

13404

rc= mysql_query(mysql, "sellect * from v1");

13405

myquery(rc);

13406

mysql_free_result(mysql_store_result(mysql));

13407

13408

13409

stmt= mysql_stmt_init(mysql);

13410

stmt_text= "select * from v1";

13411

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

13412

check_execute(stmt, rc);

13413

mysql_stmt_close(stmt);

13414

stmt_text= "drop table if exists t1, v1";

13415

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

13416

myquery(rc);

13417

}

13418

13419

13420

MYSQL_STMT *open_cursor(const char *query)

13421

{

13422

int rc;

13423

const ulong type= (ulong)CURSOR_TYPE_READ_ONLY;

13424

13425

MYSQL_STMT *stmt= mysql_stmt_init(mysql);

13426

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

13427

check_execute(stmt, rc);

13428

13429

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

13430

return stmt;

13431

}

13432

13433

13434

static void test_bug8880()

13435

{

13436

MYSQL_STMT *stmt_list[2], **stmt;

13437

MYSQL_STMT **stmt_list_end= (MYSQL_STMT**) stmt_list + 2;

13438

int rc;

13439

13440

myheader("test_bug8880");

13441

13442

mysql_query(mysql, "drop table if exists t1");

13443

mysql_query(mysql, "create table t1 (a int not null primary key, b int)");

13444

rc= mysql_query(mysql, "insert into t1 values (1,1)");

13445

myquery(rc); /* one check is enough */

13446

13447

when inserting 2 rows everything works well

13448

mysql_query(mysql, "INSERT INTO t1 VALUES (1,1),(2,2)");

13449

13450

for (stmt= stmt_list; stmt < stmt_list_end; stmt++)

13451

*stmt= open_cursor("select a from t1");

13452

for (stmt= stmt_list; stmt < stmt_list_end; stmt++)

13453

{

13454

rc= mysql_stmt_execute(*stmt);

13455

check_execute(*stmt, rc);

13456

}

13457

for (stmt= stmt_list; stmt < stmt_list_end; stmt++)

13458

mysql_stmt_close(*stmt);

13459

}

13460

13461

13462

static void test_bug9159()

13463

{

13464

MYSQL_STMT *stmt;

13465

int rc;

13466

const char *stmt_text= "select a, b from t1";

13467

const unsigned long type= CURSOR_TYPE_READ_ONLY;

13468

13469

myheader("test_bug9159");

13470

13471

mysql_query(mysql, "drop table if exists t1");

13472

mysql_query(mysql, "create table t1 (a int not null primary key, b int)");

13473

rc= mysql_query(mysql, "insert into t1 values (1,1)");

13474

myquery(rc);

13475

13476

stmt= mysql_stmt_init(mysql);

13477

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

13478

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

13479

13480

mysql_stmt_execute(stmt);

13481

mysql_stmt_close(stmt);

13482

rc= mysql_query(mysql, "drop table if exists t1");

13483

myquery(rc);

13484

}

13485

13486

13487

/* Crash when opening a cursor to a query with DISTICNT and no key */

13488

13489

static void test_bug9520()

13490

{

13491

MYSQL_STMT *stmt;

13492

MYSQL_BIND my_bind[1];

13493

char a[6];

13494

ulong a_len;

13495

int rc, row_count= 0;

13496

13497

myheader("test_bug9520");

13498

13499

mysql_query(mysql, "drop table if exists t1");

13500

mysql_query(mysql, "create table t1 (a char(5), b char(5), c char(5),"

13501

" primary key (a, b, c))");

13502

rc= mysql_query(mysql, "insert into t1 values ('x', 'y', 'z'), "

13503

" ('a', 'b', 'c'), ('k', 'l', 'm')");

13504

myquery(rc);

13505

13506

stmt= open_cursor("select distinct b from t1");

13507

13508

13509

Not crashes with:

13510

stmt= open_cursor("select distinct a from t1");

13511

13512

13513

rc= mysql_stmt_execute(stmt);

13514

check_execute(stmt, rc);

13515

13516

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

13517

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

13518

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

13519

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

13520

my_bind[0].length= &a_len;

13521

13522

mysql_stmt_bind_result(stmt, my_bind);

13523

13524

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

13525

row_count++;

13526

13527

DIE_UNLESS(rc == MYSQL_NO_DATA);

13528

13529

if (!opt_silent)

13530

printf("Fetched %d rows\n", row_count);

13531

DBUG_ASSERT(row_count == 3);

13532

13533

mysql_stmt_close(stmt);

13534

13535

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

13536

myquery(rc);

13537

}

13538

13539

13540

13541

We can't have more than one cursor open for a prepared statement.

13542

Test re-executions of a PS with cursor; mysql_stmt_reset must close

13543

the cursor attached to the statement, if there is one.

13544

13545

13546

static void test_bug9478()

13547

{

13548

MYSQL_STMT *stmt;

13549

MYSQL_BIND my_bind[1];

13550

char a[6];

13551

ulong a_len;

13552

int rc, i;

13553

DBUG_ENTER("test_bug9478");

13554

13555

myheader("test_bug9478");

13556

13557

mysql_query(mysql, "drop table if exists t1");

13558

mysql_query(mysql, "create table t1 (id integer not null primary key, "

13559

" name varchar(20) not null)");

13560

rc= mysql_query(mysql, "insert into t1 (id, name) values "

13561

" (1, 'aaa'), (2, 'bbb'), (3, 'ccc')");

13562

myquery(rc);

13563

13564

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

13565

13566

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

13567

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

13568

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

13569

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

13570

my_bind[0].length= &a_len;

13571

mysql_stmt_bind_result(stmt, my_bind);

13572

13573

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

13574

{

13575

rc= mysql_stmt_execute(stmt);

13576

check_execute(stmt, rc);

13577

rc= mysql_stmt_fetch(stmt);

13578

check_execute(stmt, rc);

13579

if (!opt_silent && i == 0)

13580

printf("Fetched row: %s\n", a);

13581

13582

13583

The query above is a one-row result set. Therefore, there is no

13584

cursor associated with it, as the server won't bother with opening

13585

a cursor for a one-row result set. The first row was read from the

13586

server in the fetch above. But there is eof packet pending in the

13587

network. mysql_stmt_execute will flush the packet and successfully

13588

execute the statement.

13589

13590

13591

rc= mysql_stmt_execute(stmt);

13592

check_execute(stmt, rc);

13593

13594

rc= mysql_stmt_fetch(stmt);

13595

check_execute(stmt, rc);

13596

if (!opt_silent && i == 0)

13597

printf("Fetched row: %s\n", a);

13598

rc= mysql_stmt_fetch(stmt);

13599

DIE_UNLESS(rc == MYSQL_NO_DATA);

13600

13601

{

13602

char buff[8];

13603

/* Fill in the fetch packet */

13604

int4store(buff, stmt->stmt_id);

13605

buff[4]= 1; /* prefetch rows */

13606

rc= ((*mysql->methods->advanced_command)(mysql, COM_STMT_FETCH,

13607

(uchar*) buff,

13608

sizeof(buff), 0,0,1,NULL) ||

13609

(*mysql->methods->read_query_result)(mysql));

13610

DIE_UNLESS(rc);

13611

if (!opt_silent && i == 0)

13612

printf("Got error (as expected): %s\n", mysql_error(mysql));

13613

}

13614

13615

rc= mysql_stmt_execute(stmt);

13616

check_execute(stmt, rc);

13617

13618

rc= mysql_stmt_fetch(stmt);

13619

check_execute(stmt, rc);

13620

if (!opt_silent && i == 0)

13621

printf("Fetched row: %s\n", a);

13622

13623

rc= mysql_stmt_reset(stmt);

13624

check_execute(stmt, rc);

13625

rc= mysql_stmt_fetch(stmt);

13626

DIE_UNLESS(rc && mysql_stmt_errno(stmt));

13627

if (!opt_silent && i == 0)

13628

printf("Got error (as expected): %s\n", mysql_stmt_error(stmt));

13629

}

13630

rc= mysql_stmt_close(stmt);

13631

DIE_UNLESS(rc == 0);

13632

13633

/* Test the case with a server side cursor */

13634

stmt= open_cursor("select name from t1");

13635

13636

mysql_stmt_bind_result(stmt, my_bind);

13637

13638

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

13639

{

13640

DBUG_PRINT("loop",("i: %d", i));

13641

rc= mysql_stmt_execute(stmt);

13642

check_execute(stmt, rc);

13643

rc= mysql_stmt_fetch(stmt);

13644

check_execute(stmt, rc);

13645

if (!opt_silent && i == 0)

13646

printf("Fetched row: %s\n", a);

13647

rc= mysql_stmt_execute(stmt);

13648

check_execute(stmt, rc);

13649

13650

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

13651

{

13652

if (!opt_silent && i == 0)

13653

printf("Fetched row: %s\n", a);

13654

}

13655

DIE_UNLESS(rc == MYSQL_NO_DATA);

13656

13657

rc= mysql_stmt_execute(stmt);

13658

check_execute(stmt, rc);

13659

13660

rc= mysql_stmt_fetch(stmt);

13661

check_execute(stmt, rc);

13662

if (!opt_silent && i == 0)

13663

printf("Fetched row: %s\n", a);

13664

13665

rc= mysql_stmt_reset(stmt);

13666

check_execute(stmt, rc);

13667

rc= mysql_stmt_fetch(stmt);

13668

DIE_UNLESS(rc && mysql_stmt_errno(stmt));

13669

if (!opt_silent && i == 0)

13670

printf("Got error (as expected): %s\n", mysql_stmt_error(stmt));

13671

}

13672

13673

rc= mysql_stmt_close(stmt);

13674

DIE_UNLESS(rc == 0);

13675

13676

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

13677

myquery(rc);

13678

DBUG_VOID_RETURN;

13679

}

13680

13681

13682

13683

Error message is returned for unsupported features.

13684

Test also cursors with non-default PREFETCH_ROWS

13685

13686

13687

static void test_bug9643()

13688

{

13689

MYSQL_STMT *stmt;

13690

MYSQL_BIND my_bind[1];

13691

int32 a;

13692

int rc;

13693

const char *stmt_text;

13694

int num_rows= 0;

13695

ulong type;

13696

ulong prefetch_rows= 5;

13697

13698

myheader("test_bug9643");

13699

13700

mysql_query(mysql, "drop table if exists t1");

13701

mysql_query(mysql, "create table t1 (id integer not null primary key)");

13702

rc= mysql_query(mysql, "insert into t1 (id) values "

13703

" (1), (2), (3), (4), (5), (6), (7), (8), (9)");

13704

myquery(rc);

13705

13706

stmt= mysql_stmt_init(mysql);

13707

/* Not implemented in 5.0 */

13708

type= (ulong) CURSOR_TYPE_SCROLLABLE;

13709

rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);

13710

DIE_UNLESS(rc);

13711

if (! opt_silent)

13712

printf("Got error (as expected): %s\n", mysql_stmt_error(stmt));

13713

13714

type= (ulong) CURSOR_TYPE_READ_ONLY;

13715

rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);

13716

check_execute(stmt, rc);

13717

rc= mysql_stmt_attr_set(stmt, STMT_ATTR_PREFETCH_ROWS,

13718

(void*) &prefetch_rows);

13719

check_execute(stmt, rc);

13720

stmt_text= "select * from t1";

13721

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

13722

check_execute(stmt, rc);

13723

13724

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

13725

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

13726

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

13727

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

13728

mysql_stmt_bind_result(stmt, my_bind);

13729

13730

rc= mysql_stmt_execute(stmt);

13731

check_execute(stmt, rc);

13732

13733

while ((rc= mysql_stmt_fetch(stmt)) == 0)

13734

++num_rows;

13735

DIE_UNLESS(num_rows == 9);

13736

13737

rc= mysql_stmt_close(stmt);

13738

DIE_UNLESS(rc == 0);

13739

13740

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

13741

myquery(rc);

13742

}

13743

13744

13745

Bug#11111: fetch from view returns wrong data

13746

13747

13748

static void test_bug11111()

13749

{

13750

MYSQL_STMT *stmt;

13751

MYSQL_BIND my_bind[2];

13752

char buf[2][20];

13753

ulong len[2];

13754

int i;

13755

int rc;

13756

const char *query= "SELECT DISTINCT f1,ff2 FROM v1";

13757

13758

myheader("test_bug11111");

13759

13760

rc= mysql_query(mysql, "drop table if exists t1, t2, v1");

13761

myquery(rc);

13762

rc= mysql_query(mysql, "drop view if exists t1, t2, v1");

13763

myquery(rc);

13764

rc= mysql_query(mysql, "create table t1 (f1 int, f2 int)");

13765

myquery(rc);

13766

rc= mysql_query(mysql, "create table t2 (ff1 int, ff2 int)");

13767

myquery(rc);

13768

rc= mysql_query(mysql, "create view v1 as select * from t1, t2 where f1=ff1");

13769

myquery(rc);

13770

rc= mysql_query(mysql, "insert into t1 values (1,1), (2,2), (3,3)");

13771

myquery(rc);

13772

rc= mysql_query(mysql, "insert into t2 values (1,1), (2,2), (3,3)");

13773

myquery(rc);

13774

13775

stmt= mysql_stmt_init(mysql);

13776

13777

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

13778

mysql_stmt_execute(stmt);

13779

13780

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

13781

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

13782

{

13783

my_bind[i].buffer_type= MYSQL_TYPE_STRING;

13784

my_bind[i].buffer= (uchar* *)&buf[i];

13785

my_bind[i].buffer_length= 20;

13786

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

13787

}

13788

13789

rc= mysql_stmt_bind_result(stmt, my_bind);

13790

check_execute(stmt, rc);

13791

13792

rc= mysql_stmt_fetch(stmt);

13793

check_execute(stmt, rc);

13794

if (!opt_silent)

13795

printf("return: %s", buf[1]);

13796

DIE_UNLESS(!strcmp(buf[1],"1"));

13797

mysql_stmt_close(stmt);

13798

rc= mysql_query(mysql, "drop view v1");

13799

myquery(rc);

13800

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

13801

myquery(rc);

13802

}

13803

13804

13805

Check that proper cleanups are done for prepared statement when

13806

fetching thorugh a cursor.

13807

13808

13809

static void test_bug10729()

13810

{

13811

MYSQL_STMT *stmt;

13812

MYSQL_BIND my_bind[1];

13813

char a[21];

13814

int rc;

13815

const char *stmt_text;

13816

int i= 0;

13817

const char *name_array[3]= { "aaa", "bbb", "ccc" };

13818

ulong type;

13819

13820

myheader("test_bug10729");

13821

13822

mysql_query(mysql, "drop table if exists t1");

13823

mysql_query(mysql, "create table t1 (id integer not null primary key,"

13824

"name VARCHAR(20) NOT NULL)");

13825

rc= mysql_query(mysql, "insert into t1 (id, name) values "

13826

"(1, 'aaa'), (2, 'bbb'), (3, 'ccc')");

13827

myquery(rc);

13828

13829

stmt= mysql_stmt_init(mysql);

13830

13831

type= (ulong) CURSOR_TYPE_READ_ONLY;

13832

rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);

13833

check_execute(stmt, rc);

13834

stmt_text= "select name from t1";

13835

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

13836

check_execute(stmt, rc);

13837

13838

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

13839

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

13840

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

13841

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

13842

mysql_stmt_bind_result(stmt, my_bind);

13843

13844

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

13845

{

13846

int row_no= 0;

13847

rc= mysql_stmt_execute(stmt);

13848

check_execute(stmt, rc);

13849

while ((rc= mysql_stmt_fetch(stmt)) == 0)

13850

{

13851

DIE_UNLESS(strcmp(a, name_array[row_no]) == 0);

13852

if (!opt_silent)

13853

printf("%d: %s\n", row_no, a);

13854

++row_no;

13855

}

13856

DIE_UNLESS(rc == MYSQL_NO_DATA);

13857

}

13858

rc= mysql_stmt_close(stmt);

13859

DIE_UNLESS(rc == 0);

13860

13861

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

13862

myquery(rc);

13863

}

13864

13865

13866

13867

Check that mysql_next_result works properly in case when one of

13868

the statements used in a multi-statement query is erroneous

13869

13870

13871

static void test_bug9992()

13872

{

13873

MYSQL *mysql1;

13874

MYSQL_RES* res ;

13875

int rc;

13876

13877

myheader("test_bug9992");

13878

13879

if (!opt_silent)

13880

printf("Establishing a connection with option CLIENT_MULTI_STATEMENTS..\n");

13881

13882

mysql1= mysql_client_init(NULL);

13883

13884

if (!mysql_real_connect(mysql1, opt_host, opt_user, opt_password,

13885

opt_db ? opt_db : "test", opt_port, opt_unix_socket,

13886

CLIENT_MULTI_STATEMENTS))

13887

{

13888

fprintf(stderr, "Failed to connect to the database\n");

13889

DIE_UNLESS(0);

13890

}

13891

13892

13893

/* Sic: SHOW DATABASE is incorrect syntax. */

13894

rc= mysql_query(mysql1, "SHOW TABLES; SHOW DATABASE; SELECT 1;");

13895

13896

if (rc)

13897

{

13898

fprintf(stderr, "[%d] %s\n", mysql_errno(mysql1), mysql_error(mysql1));

13899

DIE_UNLESS(0);

13900

}

13901

13902

if (!opt_silent)

13903

printf("Testing mysql_store_result/mysql_next_result..\n");

13904

13905

res= mysql_store_result(mysql1);

13906

DIE_UNLESS(res);

13907

mysql_free_result(res);

13908

rc= mysql_next_result(mysql1);

13909

DIE_UNLESS(rc == 1); /* Got errors, as expected */

13910

13911

if (!opt_silent)

13912

fprintf(stdout, "Got error, as expected:\n [%d] %s\n",

13913

mysql_errno(mysql1), mysql_error(mysql1));

13914

13915

mysql_close(mysql1);

13916

}

13917

13918

/* Bug#10736: cursors and subqueries, memroot management */

13919

13920

static void test_bug10736()

13921

{

13922

MYSQL_STMT *stmt;

13923

MYSQL_BIND my_bind[1];

13924

char a[21];

13925

int rc;

13926

const char *stmt_text;

13927

int i= 0;

13928

ulong type;

13929

13930

myheader("test_bug10736");

13931

13932

mysql_query(mysql, "drop table if exists t1");

13933

mysql_query(mysql, "create table t1 (id integer not null primary key,"

13934

"name VARCHAR(20) NOT NULL)");

13935

rc= mysql_query(mysql, "insert into t1 (id, name) values "

13936

"(1, 'aaa'), (2, 'bbb'), (3, 'ccc')");

13937

myquery(rc);

13938

13939

stmt= mysql_stmt_init(mysql);

13940

13941

type= (ulong) CURSOR_TYPE_READ_ONLY;

13942

rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);

13943

check_execute(stmt, rc);

13944

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

13945

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

13946

check_execute(stmt, rc);

13947

13948

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

13949

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

13950

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

13951

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

13952

mysql_stmt_bind_result(stmt, my_bind);

13953

13954

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

13955

{

13956

int row_no= 0;

13957

rc= mysql_stmt_execute(stmt);

13958

check_execute(stmt, rc);

13959

while ((rc= mysql_stmt_fetch(stmt)) == 0)

13960

{

13961

if (!opt_silent)

13962

printf("%d: %s\n", row_no, a);

13963

++row_no;

13964

}

13965

DIE_UNLESS(rc == MYSQL_NO_DATA);

13966

}

13967

rc= mysql_stmt_close(stmt);

13968

DIE_UNLESS(rc == 0);

13969

13970

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

13971

myquery(rc);

13972

}

13973

13974

/* Bug#10794: cursors, packets out of order */

13975

13976

static void test_bug10794()

13977

{

13978

MYSQL_STMT *stmt, *stmt1;

13979

MYSQL_BIND my_bind[2];

13980

char a[21];

13981

int id_val;

13982

ulong a_len;

13983

int rc;

13984

const char *stmt_text;

13985

int i= 0;

13986

ulong type;

13987

13988

myheader("test_bug10794");

13989

13990

mysql_query(mysql, "drop table if exists t1");

13991

mysql_query(mysql, "create table t1 (id integer not null primary key,"

13992

"name varchar(20) not null)");

13993

stmt= mysql_stmt_init(mysql);

13994

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

13995

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

13996

check_execute(stmt, rc);

13997

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

13998

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

13999

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

14000

my_bind[1].buffer_type= MYSQL_TYPE_STRING;

14001

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

14002

my_bind[1].length= &a_len;

14003

rc= mysql_stmt_bind_param(stmt, my_bind);

14004

check_execute(stmt, rc);

14005

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

14006

{

14007

id_val= (i+1)*10;

14008

sprintf(a, "a%d", i);

14009

a_len= strlen(a); /* safety against broken sprintf */

14010

rc= mysql_stmt_execute(stmt);

14011

check_execute(stmt, rc);

14012

}

14013

stmt_text= "select name from t1";

14014

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

14015

type= (ulong) CURSOR_TYPE_READ_ONLY;

14016

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

14017

stmt1= mysql_stmt_init(mysql);

14018

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

14019

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

14020

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

14021

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

14022

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

14023

my_bind[0].length= &a_len;

14024

rc= mysql_stmt_bind_result(stmt, my_bind);

14025

check_execute(stmt, rc);

14026

rc= mysql_stmt_execute(stmt);

14027

check_execute(stmt, rc);

14028

rc= mysql_stmt_fetch(stmt);

14029

check_execute(stmt, rc);

14030

if (!opt_silent)

14031

printf("Fetched row from stmt: %s\n", a);

14032

/* Don't optimize: an attribute of the original test case */

14033

mysql_stmt_free_result(stmt);

14034

mysql_stmt_reset(stmt);

14035

stmt_text= "select name from t1 where id=10";

14036

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

14037

check_execute(stmt1, rc);

14038

rc= mysql_stmt_bind_result(stmt1, my_bind);

14039

check_execute(stmt1, rc);

14040

rc= mysql_stmt_execute(stmt1);

14041

while (1)

14042

{

14043

rc= mysql_stmt_fetch(stmt1);

14044

if (rc == MYSQL_NO_DATA)

14045

{

14046

if (!opt_silent)

14047

printf("End of data in stmt1\n");

14048

break;

14049

}

14050

check_execute(stmt1, rc);

14051

if (!opt_silent)

14052

printf("Fetched row from stmt1: %s\n", a);

14053

}

14054

mysql_stmt_close(stmt);

14055

mysql_stmt_close(stmt1);

14056

14057

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

14058

myquery(rc);

14059

}

14060

14061

14062

/* Bug#11172: cursors, crash on a fetch from a datetime column */

14063

14064

static void test_bug11172()

14065

{

14066

MYSQL_STMT *stmt;

14067

MYSQL_BIND bind_in[1], bind_out[2];

14068

MYSQL_TIME hired;

14069

int rc;

14070

const char *stmt_text;

14071

int i= 0, id;

14072

ulong type;

14073

14074

myheader("test_bug11172");

14075

14076

mysql_query(mysql, "drop table if exists t1");

14077

mysql_query(mysql, "create table t1 (id integer not null primary key,"

14078

"hired date not null)");

14079

rc= mysql_query(mysql,

14080

"insert into t1 (id, hired) values (1, '1933-08-24'), "

14081

"(2, '1965-01-01'), (3, '1949-08-17'), (4, '1945-07-07'), "

14082

"(5, '1941-05-15'), (6, '1978-09-15'), (7, '1936-03-28')");

14083

myquery(rc);

14084

stmt= mysql_stmt_init(mysql);

14085

stmt_text= "SELECT id, hired FROM t1 WHERE hired=?";

14086

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

14087

check_execute(stmt, rc);

14088

14089

type= (ulong) CURSOR_TYPE_READ_ONLY;

14090

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

14091

14092

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

14093

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

14094

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

14095

hired.year= 1965;

14096

hired.month= 1;

14097

hired.day= 1;

14098

bind_in[0].buffer_type= MYSQL_TYPE_DATE;

14099

bind_in[0].buffer= (void*) &hired;

14100

bind_in[0].buffer_length= sizeof(hired);

14101

bind_out[0].buffer_type= MYSQL_TYPE_LONG;

14102

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

14103

bind_out[1]= bind_in[0];

14104

14105

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

14106

{

14107

rc= mysql_stmt_bind_param(stmt, bind_in);

14108

check_execute(stmt, rc);

14109

rc= mysql_stmt_bind_result(stmt, bind_out);

14110

check_execute(stmt, rc);

14111

rc= mysql_stmt_execute(stmt);

14112

check_execute(stmt, rc);

14113

while ((rc= mysql_stmt_fetch(stmt)) == 0)

14114

{

14115

if (!opt_silent)

14116

printf("fetched data %d:%d-%d-%d\n", id,

14117

hired.year, hired.month, hired.day);

14118

}

14119

DIE_UNLESS(rc == MYSQL_NO_DATA);

14120

if (!mysql_stmt_free_result(stmt))

14121

mysql_stmt_reset(stmt);

14122

}

14123

mysql_stmt_close(stmt);

14124

mysql_rollback(mysql);

14125

mysql_rollback(mysql);

14126

14127

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

14128

myquery(rc);

14129

}

14130

14131

14132

/* Bug#11656: cursors, crash on a fetch from a query with distinct. */

14133

14134

static void test_bug11656()

14135

{

14136

MYSQL_STMT *stmt;

14137

MYSQL_BIND my_bind[2];

14138

int rc;

14139

const char *stmt_text;

14140

char buf[2][20];

14141

int i= 0;

14142

ulong type;

14143

14144

myheader("test_bug11656");

14145

14146

mysql_query(mysql, "drop table if exists t1");

14147

14148

rc= mysql_query(mysql, "create table t1 ("

14149

"server varchar(40) not null, "

14150

"test_kind varchar(1) not null, "

14151

"test_id varchar(30) not null , "

14152

"primary key (server,test_kind,test_id))");

14153

myquery(rc);

14154

14155

stmt_text= "select distinct test_kind, test_id from t1 "

14156

"where server in (?, ?)";

14157

stmt= mysql_stmt_init(mysql);

14158

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

14159

check_execute(stmt, rc);

14160

type= (ulong) CURSOR_TYPE_READ_ONLY;

14161

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

14162

14163

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

14164

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

14165

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

14166

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

14167

{

14168

my_bind[i].buffer_type= MYSQL_TYPE_STRING;

14169

my_bind[i].buffer= (uchar* *)&buf[i];

14170

my_bind[i].buffer_length= strlen(buf[i]);

14171

}

14172

mysql_stmt_bind_param(stmt, my_bind);

14173

14174

rc= mysql_stmt_execute(stmt);

14175

check_execute(stmt, rc);

14176

14177

rc= mysql_stmt_fetch(stmt);

14178

DIE_UNLESS(rc == MYSQL_NO_DATA);

14179

14180

mysql_stmt_close(stmt);

14181

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

14182

myquery(rc);

14183

}

14184

14185

14186

14187

Check that the server signals when NO_BACKSLASH_ESCAPES mode is in effect,

14188

and mysql_real_escape_string() does the right thing as a result.

14189

14190

14191

static void test_bug10214()

14192

{

14193

int len;

14194

char out[8];

14195

14196

myheader("test_bug10214");

14197

14198

DIE_UNLESS(!(mysql->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES));

14199

14200

len= mysql_real_escape_string(mysql, out, "a'b\\c", 5);

14201

DIE_UNLESS(memcmp(out, "a\\'b\\\\c", len) == 0);

14202

14203

mysql_query(mysql, "set sql_mode='NO_BACKSLASH_ESCAPES'");

14204

DIE_UNLESS(mysql->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES);

14205

14206

len= mysql_real_escape_string(mysql, out, "a'b\\c", 5);

14207

DIE_UNLESS(memcmp(out, "a''b\\c", len) == 0);

14208

14209

mysql_query(mysql, "set sql_mode=''");

14210

}

14211

14212

static void test_client_character_set()

14213

{

14214

MY_CHARSET_INFO cs;

14215

char *csname= (char*) "utf8";

14216

char *csdefault= (char*)mysql_character_set_name(mysql);

14217

int rc;

14218

14219

myheader("test_client_character_set");

14220

14221

rc= mysql_set_character_set(mysql, csname);

14222

DIE_UNLESS(rc == 0);

14223

14224

mysql_get_character_set_info(mysql, &cs);

14225

DIE_UNLESS(!strcmp(cs.csname, "utf8"));

14226

DIE_UNLESS(!strcmp(cs.name, "utf8_general_ci"));

14227

/* Restore the default character set */

14228

rc= mysql_set_character_set(mysql, csdefault);

14229

myquery(rc);

14230

}

14231

14232

/* Test correct max length for MEDIUMTEXT and LONGTEXT columns */

14233

14234

static void test_bug9735()

14235

{

14236

MYSQL_RES *res;

14237

int rc;

14238

14239

myheader("test_bug9735");

14240

14241

rc= mysql_query(mysql, "drop table if exists t1");

14242

myquery(rc);

14243

rc= mysql_query(mysql, "create table t1 (a mediumtext, b longtext) "

14244

"character set latin1");

14245

myquery(rc);

14246

rc= mysql_query(mysql, "select * from t1");

14247

myquery(rc);

14248

res= mysql_store_result(mysql);

14249

verify_prepare_field(res, 0, "a", "a", MYSQL_TYPE_BLOB,

14250

"t1", "t1", current_db, (1U << 24)-1, 0);

14251

verify_prepare_field(res, 1, "b", "b", MYSQL_TYPE_BLOB,

14252

"t1", "t1", current_db, ~0U, 0);

14253

mysql_free_result(res);

14254

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

14255

myquery(rc);

14256

}

14257

14258

14259

/* Bug#11183 "mysql_stmt_reset() doesn't reset information about error" */

14260

14261

static void test_bug11183()

14262

{

14263

int rc;

14264

MYSQL_STMT *stmt;

14265

char bug_statement[]= "insert into t1 values (1)";

14266

14267

myheader("test_bug11183");

14268

14269

mysql_query(mysql, "drop table t1 if exists");

14270

mysql_query(mysql, "create table t1 (a int)");

14271

14272

stmt= mysql_stmt_init(mysql);

14273

DIE_UNLESS(stmt != 0);

14274

14275

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

14276

check_execute(stmt, rc);

14277

14278

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

14279

myquery(rc);

14280

14281

/* Trying to execute statement that should fail on execute stage */

14282

rc= mysql_stmt_execute(stmt);

14283

DIE_UNLESS(rc);

14284

14285

mysql_stmt_reset(stmt);

14286

DIE_UNLESS(mysql_stmt_errno(stmt) == 0);

14287

14288

mysql_query(mysql, "create table t1 (a int)");

14289

14290

/* Trying to execute statement that should pass ok */

14291

if (mysql_stmt_execute(stmt))

14292

{

14293

mysql_stmt_reset(stmt);

14294

DIE_UNLESS(mysql_stmt_errno(stmt) == 0);

14295

}

14296

14297

mysql_stmt_close(stmt);

14298

14299

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

14300

myquery(rc);

14301

}

14302

14303

static void test_bug11037()

14304

{

14305

MYSQL_STMT *stmt;

14306

int rc;

14307

const char *stmt_text;

14308

14309

myheader("test_bug11037");

14310

14311

mysql_query(mysql, "drop table if exists t1");

14312

14313

rc= mysql_query(mysql, "create table t1 (id int not null)");

14314

myquery(rc);

14315

14316

rc= mysql_query(mysql, "insert into t1 values (1)");

14317

myquery(rc);

14318

14319

stmt_text= "select id FROM t1";

14320

stmt= mysql_stmt_init(mysql);

14321

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

14322

14323

/* expected error */

14324

rc = mysql_stmt_fetch(stmt);

14325

DIE_UNLESS(rc==1);

14326

if (!opt_silent)

14327

fprintf(stdout, "Got error, as expected:\n [%d] %s\n",

14328

mysql_stmt_errno(stmt), mysql_stmt_error(stmt));

14329

14330

rc= mysql_stmt_execute(stmt);

14331

check_execute(stmt, rc);

14332

14333

rc= mysql_stmt_fetch(stmt);

14334

DIE_UNLESS(rc==0);

14335

14336

rc= mysql_stmt_fetch(stmt);

14337

DIE_UNLESS(rc==MYSQL_NO_DATA);

14338

14339

rc= mysql_stmt_fetch(stmt);

14340

DIE_UNLESS(rc==MYSQL_NO_DATA);

14341

14342

mysql_stmt_close(stmt);

14343

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

14344

myquery(rc);

14345

}

14346

14347

/* Bug#10760: cursors, crash in a fetch after rollback. */

14348

14349

static void test_bug10760()

14350

{

14351

MYSQL_STMT *stmt;

14352

MYSQL_BIND my_bind[1];

14353

int rc;

14354

const char *stmt_text;

14355

char id_buf[20];

14356

ulong id_len;

14357

int i= 0;

14358

ulong type;

14359

14360

myheader("test_bug10760");

14361

14362

mysql_query(mysql, "drop table if exists t1, t2");

14363

14364

/* create tables */

14365

rc= mysql_query(mysql, "create table t1 (id integer not null primary key)"

14366

" engine=MyISAM");

14367

myquery(rc);

14368

for (; i < 42; ++i)

14369

{

14370

char buf[100];

14371

sprintf(buf, "insert into t1 (id) values (%d)", i+1);

14372

rc= mysql_query(mysql, buf);

14373

myquery(rc);

14374

}

14375

mysql_autocommit(mysql, FALSE);

14376

/* create statement */

14377

stmt= mysql_stmt_init(mysql);

14378

type= (ulong) CURSOR_TYPE_READ_ONLY;

14379

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

14380

14381

14382

1: check that a deadlock within the same connection

14383

is resolved and an error is returned. The deadlock is modelled

14384

as follows:

14385

con1: open cursor for select * from t1;

14386

con1: insert into t1 (id) values (1)

14387

14388

stmt_text= "select id from t1 order by 1";

14389

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

14390

check_execute(stmt, rc);

14391

rc= mysql_stmt_execute(stmt);

14392

check_execute(stmt, rc);

14393

rc= mysql_query(mysql, "update t1 set id=id+100");

14394

14395

If cursors are not materialized, the update will return an error;

14396

we mainly test that it won't deadlock.

14397

14398

if (rc && !opt_silent)

14399

printf("Got error (as expected): %s\n", mysql_error(mysql));

14400

14401

2: check that MyISAM tables used in cursors survive

14402

COMMIT/ROLLBACK.

14403

14404

rc= mysql_rollback(mysql); /* should not close the cursor */

14405

myquery(rc);

14406

rc= mysql_stmt_fetch(stmt);

14407

check_execute(stmt, rc);

14408

14409

14410

3: check that cursors to InnoDB tables are closed (for now) by

14411

COMMIT/ROLLBACK.

14412

14413

if (! have_innodb)

14414

{

14415

if (!opt_silent)

14416

printf("Testing that cursors are closed at COMMIT/ROLLBACK requires "

14417

"InnoDB.\n");

14418

}

14419

else

14420

{

14421

stmt_text= "select id from t1 order by 1";

14422

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

14423

check_execute(stmt, rc);

14424

14425

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

14426

myquery(rc);

14427

14428

bzero(my_bind, sizeof(my_bind));

14429

my_bind[0].buffer_type= MYSQL_TYPE_STRING;

14430

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

14431

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

14432

my_bind[0].length= &id_len;

14433

check_execute(stmt, rc);

14434

mysql_stmt_bind_result(stmt, my_bind);

14435

14436

rc= mysql_stmt_execute(stmt);

14437

rc= mysql_stmt_fetch(stmt);

14438

DIE_UNLESS(rc == 0);

14439

if (!opt_silent)

14440

printf("Fetched row %s\n", id_buf);

14441

rc= mysql_rollback(mysql); /* should close the cursor */

14442

myquery(rc);

14443

#if 0

14444

rc= mysql_stmt_fetch(stmt);

14445

DIE_UNLESS(rc);

14446

if (!opt_silent)

14447

printf("Got error (as expected): %s\n", mysql_error(mysql));

14448

#endif

14449

}

14450

14451

mysql_stmt_close(stmt);

14452

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

14453

myquery(rc);

14454

mysql_autocommit(mysql, TRUE); /* restore default */

14455

}

14456

14457

static void test_bug12001()

14458

{

14459

MYSQL *mysql_local;

14460

MYSQL_RES *result;

14461

const char *query= "DROP TABLE IF EXISTS test_table;"

14462

"CREATE TABLE test_table(id INT);"

14463

"INSERT INTO test_table VALUES(10);"

14464

"UPDATE test_table SET id=20 WHERE id=10;"

14465

"SELECT * FROM test_table;"

14466

"INSERT INTO non_existent_table VALUES(11);";

14467

int rc, res;

14468

14469

myheader("test_bug12001");

14470

14471

if (!(mysql_local= mysql_client_init(NULL)))

14472

{

14473

fprintf(stdout, "\n mysql_client_init() failed");

14474

exit(1);

14475

}

14476

14477

/* Create connection that supports multi statements */

14478

if (!mysql_real_connect(mysql_local, opt_host, opt_user,

14479

opt_password, current_db, opt_port,

14480

opt_unix_socket, CLIENT_MULTI_STATEMENTS |

14481

CLIENT_MULTI_RESULTS))

14482

{

14483

fprintf(stdout, "\n mysql_real_connect() failed");

14484

exit(1);

14485

}

14486

14487

rc= mysql_query(mysql_local, query);

14488

myquery(rc);

14489

14490

14491

{

14492

if (mysql_field_count(mysql_local) &&

14493

(result= mysql_use_result(mysql_local)))

14494

{

14495

mysql_free_result(result);

14496

}

14497

}

14498

while (!(res= mysql_next_result(mysql_local)));

14499

14500

rc= mysql_query(mysql_local, "DROP TABLE IF EXISTS test_table");

14501

myquery(rc);

14502

14503

mysql_close(mysql_local);

14504

DIE_UNLESS(res==1);

14505

}

14506

14507

14508

/* Bug#11909: wrong metadata if fetching from two cursors */

14509

14510

static void test_bug11909()

14511

{

14512

MYSQL_STMT *stmt1, *stmt2;

14513

MYSQL_BIND my_bind[7];

14514

int rc;

14515

char firstname[20], midinit[20], lastname[20], workdept[20];

14516

ulong firstname_len, midinit_len, lastname_len, workdept_len;

14517

uint32 empno;

14518

double salary;

14519

float bonus;

14520

const char *stmt_text;

14521

14522

myheader("test_bug11909");

14523

14524

stmt_text= "drop table if exists t1";

14525

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

14526

myquery(rc);

14527

14528

stmt_text= "create table t1 ("

14529

" empno int(11) not null, firstname varchar(20) not null,"

14530

" midinit varchar(20) not null, lastname varchar(20) not null,"

14531

" workdept varchar(6) not null, salary double not null,"

14532

" bonus float not null, primary key (empno)"

14533

") default charset=latin1 collate=latin1_bin";

14534

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

14535

myquery(rc);

14536

14537

stmt_text= "insert into t1 values "

14538

"(10, 'CHRISTINE', 'I', 'HAAS', 'A00', 52750, 1000), "

14539

"(20, 'MICHAEL', 'L', 'THOMPSON', 'B01', 41250, 800),"

14540

"(30, 'SALLY', 'A', 'KWAN', 'C01', 38250, 800),"

14541

"(50, 'JOHN', 'B', 'GEYER', 'E01', 40175, 800), "

14542

"(60, 'IRVING', 'F', 'STERN', 'D11', 32250, 500)";

14543

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

14544

myquery(rc);

14545

14546

/* ****** Begin of trace ****** */

14547

14548

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

14549

"workdept, salary, bonus FROM t1");

14550

14551

bzero(my_bind, sizeof(my_bind));

14552

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

14553

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

14554

14555

my_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;

14556

my_bind[1].buffer= (void*) firstname;

14557

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

14558

my_bind[1].length= &firstname_len;

14559

14560

my_bind[2].buffer_type= MYSQL_TYPE_VAR_STRING;

14561

my_bind[2].buffer= (void*) midinit;

14562

my_bind[2].buffer_length= sizeof(midinit);

14563

my_bind[2].length= &midinit_len;

14564

14565

my_bind[3].buffer_type= MYSQL_TYPE_VAR_STRING;

14566

my_bind[3].buffer= (void*) lastname;

14567

my_bind[3].buffer_length= sizeof(lastname);

14568

my_bind[3].length= &lastname_len;

14569

14570

my_bind[4].buffer_type= MYSQL_TYPE_VAR_STRING;

14571

my_bind[4].buffer= (void*) workdept;

14572

my_bind[4].buffer_length= sizeof(workdept);

14573

my_bind[4].length= &workdept_len;

14574

14575

my_bind[5].buffer_type= MYSQL_TYPE_DOUBLE;

14576

my_bind[5].buffer= (void*) &salary;

14577

14578

my_bind[6].buffer_type= MYSQL_TYPE_FLOAT;

14579

my_bind[6].buffer= (void*) &bonus;

14580

rc= mysql_stmt_bind_result(stmt1, my_bind);

14581

check_execute(stmt1, rc);

14582

14583

rc= mysql_stmt_execute(stmt1);

14584

check_execute(stmt1, rc);

14585

14586

rc= mysql_stmt_fetch(stmt1);

14587

DIE_UNLESS(rc == 0);

14588

DIE_UNLESS(empno == 10);

14589

DIE_UNLESS(strcmp(firstname, "CHRISTINE") == 0);

14590

DIE_UNLESS(strcmp(midinit, "I") == 0);

14591

DIE_UNLESS(strcmp(lastname, "HAAS") == 0);

14592

DIE_UNLESS(strcmp(workdept, "A00") == 0);

14593

DIE_UNLESS(salary == (double) 52750.0);

14594

DIE_UNLESS(bonus == (float) 1000.0);

14595

14596

stmt2= open_cursor("SELECT empno, firstname FROM t1");

14597

rc= mysql_stmt_bind_result(stmt2, my_bind);

14598

check_execute(stmt2, rc);

14599

14600

rc= mysql_stmt_execute(stmt2);

14601

check_execute(stmt2, rc);

14602

14603

rc= mysql_stmt_fetch(stmt2);

14604

DIE_UNLESS(rc == 0);

14605

14606

DIE_UNLESS(empno == 10);

14607

DIE_UNLESS(strcmp(firstname, "CHRISTINE") == 0);

14608

14609

rc= mysql_stmt_reset(stmt2);

14610

check_execute(stmt2, rc);

14611

14612

/* ERROR: next statement should return 0 */

14613

14614

rc= mysql_stmt_fetch(stmt1);

14615

DIE_UNLESS(rc == 0);

14616

14617

mysql_stmt_close(stmt1);

14618

mysql_stmt_close(stmt2);

14619

rc= mysql_rollback(mysql);

14620

myquery(rc);

14621

14622

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

14623

myquery(rc);

14624

}

14625

14626

/* Cursors: opening a cursor to a compilicated query with ORDER BY */

14627

14628

static void test_bug11901()

14629

{

14630

MYSQL_STMT *stmt;

14631

MYSQL_BIND my_bind[2];

14632

int rc;

14633

char workdept[20];

14634

ulong workdept_len;

14635

uint32 empno;

14636

const char *stmt_text;

14637

14638

myheader("test_bug11901");

14639

14640

stmt_text= "drop table if exists t1, t2";

14641

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

14642

myquery(rc);

14643

14644

stmt_text= "create table t1 ("

14645

" empno int(11) not null, firstname varchar(20) not null,"

14646

" midinit varchar(20) not null, lastname varchar(20) not null,"

14647

" workdept varchar(6) not null, salary double not null,"

14648

" bonus float not null, primary key (empno), "

14649

" unique key (workdept, empno) "

14650

") default charset=latin1 collate=latin1_bin";

14651

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

14652

myquery(rc);

14653

14654

stmt_text= "insert into t1 values "

14655

"(10, 'CHRISTINE', 'I', 'HAAS', 'A00', 52750, 1000),"

14656

"(20, 'MICHAEL', 'L', 'THOMPSON', 'B01', 41250, 800), "

14657

"(30, 'SALLY', 'A', 'KWAN', 'C01', 38250, 800), "

14658

"(50, 'JOHN', 'B', 'GEYER', 'E01', 40175, 800), "

14659

"(60, 'IRVING', 'F', 'STERN', 'D11', 32250, 500), "

14660

"(70, 'EVA', 'D', 'PULASKI', 'D21', 36170, 700), "

14661

"(90, 'EILEEN', 'W', 'HENDERSON', 'E11', 29750, 600), "

14662

"(100, 'THEODORE', 'Q', 'SPENSER', 'E21', 26150, 500), "

14663

"(110, 'VINCENZO', 'G', 'LUCCHESSI', 'A00', 46500, 900), "

14664

"(120, 'SEAN', '', 'O\\'CONNELL', 'A00', 29250, 600), "

14665

"(130, 'DOLORES', 'M', 'QUINTANA', 'C01', 23800, 500), "

14666

"(140, 'HEATHER', 'A', 'NICHOLLS', 'C01', 28420, 600), "

14667

"(150, 'BRUCE', '', 'ADAMSON', 'D11', 25280, 500), "

14668

"(160, 'ELIZABETH', 'R', 'PIANKA', 'D11', 22250, 400), "

14669

"(170, 'MASATOSHI', 'J', 'YOSHIMURA', 'D11', 24680, 500), "

14670

"(180, 'MARILYN', 'S', 'SCOUTTEN', 'D11', 21340, 500), "

14671

"(190, 'JAMES', 'H', 'WALKER', 'D11', 20450, 400), "

14672

"(200, 'DAVID', '', 'BROWN', 'D11', 27740, 600), "

14673

"(210, 'WILLIAM', 'T', 'JONES', 'D11', 18270, 400), "

14674

"(220, 'JENNIFER', 'K', 'LUTZ', 'D11', 29840, 600), "

14675

"(230, 'JAMES', 'J', 'JEFFERSON', 'D21', 22180, 400), "

14676

"(240, 'SALVATORE', 'M', 'MARINO', 'D21', 28760, 600), "

14677

"(250, 'DANIEL', 'S', 'SMITH', 'D21', 19180, 400), "

14678

"(260, 'SYBIL', 'P', 'JOHNSON', 'D21', 17250, 300), "

14679

"(270, 'MARIA', 'L', 'PEREZ', 'D21', 27380, 500), "

14680

"(280, 'ETHEL', 'R', 'SCHNEIDER', 'E11', 26250, 500), "

14681

"(290, 'JOHN', 'R', 'PARKER', 'E11', 15340, 300), "

14682

"(300, 'PHILIP', 'X', 'SMITH', 'E11', 17750, 400), "

14683

"(310, 'MAUDE', 'F', 'SETRIGHT', 'E11', 15900, 300), "

14684

"(320, 'RAMLAL', 'V', 'MEHTA', 'E21', 19950, 400), "

14685

"(330, 'WING', '', 'LEE', 'E21', 25370, 500), "

14686

"(340, 'JASON', 'R', 'GOUNOT', 'E21', 23840, 500)";

14687

14688

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

14689

myquery(rc);

14690

14691

stmt_text= "create table t2 ("

14692

" deptno varchar(6) not null, deptname varchar(20) not null,"

14693

" mgrno int(11) not null, location varchar(20) not null,"

14694

" admrdept varchar(6) not null, refcntd int(11) not null,"

14695

" refcntu int(11) not null, primary key (deptno)"

14696

") default charset=latin1 collate=latin1_bin";

14697

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

14698

myquery(rc);

14699

14700

stmt_text= "insert into t2 values "

14701

"('A00', 'SPIFFY COMPUTER SERV', 10, '', 'A00', 0, 0), "

14702

"('B01', 'PLANNING', 20, '', 'A00', 0, 0), "

14703

"('C01', 'INFORMATION CENTER', 30, '', 'A00', 0, 0), "

14704

"('D01', 'DEVELOPMENT CENTER', 0, '', 'A00', 0, 0),"

14705

"('D11', 'MANUFACTURING SYSTEM', 60, '', 'D01', 0, 0), "

14706

"('D21', 'ADMINISTRATION SYSTE', 70, '', 'D01', 0, 0), "

14707

"('E01', 'SUPPORT SERVICES', 50, '', 'A00', 0, 0), "

14708

"('E11', 'OPERATIONS', 90, '', 'E01', 0, 0), "

14709

"('E21', 'SOFTWARE SUPPORT', 100,'', 'E01', 0, 0)";

14710

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

14711

myquery(rc);

14712

14713

/* ****** Begin of trace ****** */

14714

14715

stmt= open_cursor("select t1.empno, t1.workdept "

14716

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

14717

"where t2.deptno in "

14718

" (select t2.deptno "

14719

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

14720

" where t1.empno = ?) "

14721

"order by 1");

14722

bzero(my_bind, sizeof(my_bind));

14723

14724

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

14725

my_bind[0].buffer= &empno;

14726

rc= mysql_stmt_bind_param(stmt, my_bind);

14727

check_execute(stmt, rc);

14728

14729

my_bind[1].buffer_type= MYSQL_TYPE_VAR_STRING;

14730

my_bind[1].buffer= (void*) workdept;

14731

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

14732

my_bind[1].length= &workdept_len;

14733

14734

rc= mysql_stmt_bind_result(stmt, my_bind);

14735

check_execute(stmt, rc);

14736

14737

empno= 10;

14738

/* ERROR: next statement causes a server crash */

14739

rc= mysql_stmt_execute(stmt);

14740

check_execute(stmt, rc);

14741

14742

mysql_stmt_close(stmt);

14743

14744

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

14745

myquery(rc);

14746

}

14747

14748

/* Bug#11904: mysql_stmt_attr_set CURSOR_TYPE_READ_ONLY grouping wrong result */

14749

14750

static void test_bug11904()

14751

{

14752

MYSQL_STMT *stmt1;

14753

int rc;

14754

const char *stmt_text;

14755

const ulong type= (ulong)CURSOR_TYPE_READ_ONLY;

14756

MYSQL_BIND my_bind[2];

14757

int country_id=0;

14758

char row_data[11]= {0};

14759

14760

myheader("test_bug11904");

14761

14762

/* create tables */

14763

rc= mysql_query(mysql, "DROP TABLE IF EXISTS bug11904b");

14764

myquery(rc);

14765

rc= mysql_query(mysql, "CREATE TABLE bug11904b (id int, name char(10), primary key(id, name))");

14766

myquery(rc);

14767

14768

rc= mysql_query(mysql, "INSERT INTO bug11904b VALUES (1, 'sofia'), (1,'plovdiv'),"

14769

" (1,'varna'), (2,'LA'), (2,'new york'), (3,'heidelberg'),"

14770

" (3,'berlin'), (3, 'frankfurt')");

14771

14772

myquery(rc);

14773

mysql_commit(mysql);

14774

/* create statement */

14775

stmt1= mysql_stmt_init(mysql);

14776

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

14777

14778

stmt_text= "SELECT id, MIN(name) FROM bug11904b GROUP BY id";

14779

14780

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

14781

check_execute(stmt1, rc);

14782

14783

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

14784

my_bind[0].buffer_type= MYSQL_TYPE_LONG;

14785

my_bind[0].buffer=& country_id;

14786

my_bind[0].buffer_length= 0;

14787

my_bind[0].length= 0;

14788

14789

my_bind[1].buffer_type= MYSQL_TYPE_STRING;

14790

my_bind[1].buffer=& row_data;

14791

my_bind[1].buffer_length= sizeof(row_data) - 1;

14792

my_bind[1].length= 0;

14793

14794

rc= mysql_stmt_bind_result(stmt1, my_bind);

14795

check_execute(stmt1, rc);

14796

14797

rc= mysql_stmt_execute(stmt1);

14798

check_execute(stmt1, rc);

14799

14800

rc= mysql_stmt_fetch(stmt1);

14801

check_execute(stmt1, rc);

14802

DIE_UNLESS(country_id == 1);

14803

DIE_UNLESS(memcmp(row_data, "plovdiv", 7) == 0);

14804

14805

rc= mysql_stmt_fetch(stmt1);

14806

check_execute(stmt1, rc);

14807

DIE_UNLESS(country_id == 2);

14808

DIE_UNLESS(memcmp(row_data, "LA", 2) == 0);

14809

14810

rc= mysql_stmt_fetch(stmt1);

14811

check_execute(stmt1, rc);

14812

DIE_UNLESS(country_id == 3);

14813

DIE_UNLESS(memcmp(row_data, "berlin", 6) == 0);

14814

14815

rc= mysql_stmt_close(stmt1);

14816

check_execute(stmt1, rc);

14817

14818

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

14819

myquery(rc);

14820

}

14821

14822

14823

/* Bug#12243: multiple cursors, crash in a fetch after commit. */

14824

14825

static void test_bug12243()

14826

{

14827

MYSQL_STMT *stmt1, *stmt2;

14828

int rc;

14829

const char *stmt_text;

14830

ulong type;

14831

14832

myheader("test_bug12243");

14833

14834

if (! have_innodb)

14835

{

14836

if (!opt_silent)

14837

printf("This test requires InnoDB.\n");

14838

return;

14839

}

14840

14841

/* create tables */

14842

mysql_query(mysql, "drop table if exists t1");

14843

mysql_query(mysql, "create table t1 (a int) engine=InnoDB");

14844

rc= mysql_query(mysql, "insert into t1 (a) values (1), (2)");

14845

myquery(rc);

14846

mysql_autocommit(mysql, FALSE);

14847

/* create statement */

14848

stmt1= mysql_stmt_init(mysql);

14849

stmt2= mysql_stmt_init(mysql);

14850

type= (ulong) CURSOR_TYPE_READ_ONLY;

14851

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

14852

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

14853

14854

stmt_text= "select a from t1";

14855

14856

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

14857

check_execute(stmt1, rc);

14858

rc= mysql_stmt_execute(stmt1);

14859

check_execute(stmt1, rc);

14860

rc= mysql_stmt_fetch(stmt1);

14861

check_execute(stmt1, rc);

14862

14863

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

14864

check_execute(stmt2, rc);

14865

rc= mysql_stmt_execute(stmt2);

14866

check_execute(stmt2, rc);

14867

rc= mysql_stmt_fetch(stmt2);

14868

check_execute(stmt2, rc);

14869

14870

rc= mysql_stmt_close(stmt1);

14871

check_execute(stmt1, rc);

14872

rc= mysql_commit(mysql);

14873

myquery(rc);

14874

rc= mysql_stmt_fetch(stmt2);

14875

check_execute(stmt2, rc);

14876

14877

mysql_stmt_close(stmt2);

14878

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

14879

myquery(rc);

14880

mysql_autocommit(mysql, TRUE); /* restore default */

14881

}

14882

14883

14884

14885

Bug#11718: query with function, join and order by returns wrong type

14886

14887

14888

static void test_bug11718()

14889

{

14890

MYSQL_RES *res;

14891

int rc;

14892

const char *query= "select str_to_date(concat(f3),'%Y%m%d') from t1,t2 "

14893

"where f1=f2 order by f1";

14894

14895

myheader("test_bug11718");

14896

14897

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

14898

myquery(rc);

14899

rc= mysql_query(mysql, "create table t1 (f1 int)");

14900

myquery(rc);

14901

rc= mysql_query(mysql, "create table t2 (f2 int, f3 numeric(8))");

14902

myquery(rc);

14903

rc= mysql_query(mysql, "insert into t1 values (1), (2)");

14904

myquery(rc);

14905

rc= mysql_query(mysql, "insert into t2 values (1,20050101), (2,20050202)");

14906

myquery(rc);

14907

rc= mysql_query(mysql, query);

14908

myquery(rc);

14909

res = mysql_store_result(mysql);

14910

14911

if (!opt_silent)

14912

printf("return type: %s", (res->fields[0].type == MYSQL_TYPE_DATE)?"DATE":

14913

"not DATE");

14914

DIE_UNLESS(res->fields[0].type == MYSQL_TYPE_DATE);

14915

mysql_free_result(res);

14916

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

14917

myquery(rc);

14918

}

14919

14920

14921

14922

Bug #12925: Bad handling of maximum values in getopt

14923

14924

static void test_bug12925()

14925

{

14926

myheader("test_bug12925");

14927

if (opt_getopt_ll_test)

14928

DIE_UNLESS(opt_getopt_ll_test == LL(25600*1024*1024));

14929

}

14930

14931

14932

14933

Bug#14210 "Simple query with > operator on large table gives server

14934

crash"

14935

14936

14937

static void test_bug14210()

14938

{

14939

MYSQL_STMT *stmt;

14940

int rc, i;

14941

const char *stmt_text;

14942

ulong type;

14943

14944

myheader("test_bug14210");

14945

14946

mysql_query(mysql, "drop table if exists t1");

14947

14948

To trigger the problem the table must be InnoDB, although the problem

14949

itself is not InnoDB related. In case the table is MyISAM this test

14950

is harmless.

14951

14952

mysql_query(mysql, "create table t1 (a varchar(255)) engine=InnoDB");

14953

rc= mysql_query(mysql, "insert into t1 (a) values (repeat('a', 256))");

14954

myquery(rc);

14955

rc= mysql_query(mysql, "set @@session.max_heap_table_size=16384");

14956

/* Create a big enough table (more than max_heap_table_size) */

14957

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

14958

{

14959

rc= mysql_query(mysql, "insert into t1 (a) select a from t1");

14960

myquery(rc);

14961

}

14962

/* create statement */

14963

stmt= mysql_stmt_init(mysql);

14964

type= (ulong) CURSOR_TYPE_READ_ONLY;

14965

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

14966

14967

stmt_text= "select a from t1";

14968

14969

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

14970

check_execute(stmt, rc);

14971

rc= mysql_stmt_execute(stmt);

14972

while ((rc= mysql_stmt_fetch(stmt)) == 0)

14973

;

14974

DIE_UNLESS(rc == MYSQL_NO_DATA);

14975

14976

rc= mysql_stmt_close(stmt);

14977

14978

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

14979

myquery(rc);

14980

rc= mysql_query(mysql, "set @@session.max_heap_table_size=default");

14981

myquery(rc);

14982

}

14983

14984

/* Bug#13488: wrong column metadata when fetching from cursor */

14985

14986

static void test_bug13488()

14987

{

14988

MYSQL_BIND my_bind[3];

14989

MYSQL_STMT *stmt1;

14990

int rc, f1, f2, f3, i;

14991

const ulong type= CURSOR_TYPE_READ_ONLY;

14992

const char *query= "select * from t1 left join t2 on f1=f2 where f1=1";

14993

14994

myheader("test_bug13488");

14995

14996

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

14997

myquery(rc);

14998

rc= mysql_query(mysql, "create table t1 (f1 int not null primary key)");

14999

myquery(rc);

15000

rc= mysql_query(mysql, "create table t2 (f2 int not null primary key, "

15001

"f3 int not null)");

15002

myquery(rc);

15003

rc= mysql_query(mysql, "insert into t1 values (1), (2)");

15004

myquery(rc);

15005

rc= mysql_query(mysql, "insert into t2 values (1,2), (2,4)");

15006

myquery(rc);

15007

15008

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

15009

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

15010

{

15011

my_bind[i].buffer_type= MYSQL_TYPE_LONG;

15012

my_bind[i].buffer_length= 4;

15013

my_bind[i].length= 0;

15014

}

15015

my_bind[0].buffer=&f1;

15016

my_bind[1].buffer=&f2;

15017

my_bind[2].buffer=&f3;

15018

15019

stmt1= mysql_stmt_init(mysql);

15020

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

15021

check_execute(stmt1, rc);

15022

15023

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

15024

check_execute(stmt1, rc);

15025

15026

rc= mysql_stmt_execute(stmt1);

15027

check_execute(stmt1, rc);

15028

15029

rc= mysql_stmt_bind_result(stmt1, my_bind);

15030

check_execute(stmt1, rc);

15031

15032

rc= mysql_stmt_fetch(stmt1);

15033

check_execute(stmt1, rc);

15034

15035

rc= mysql_stmt_free_result(stmt1);

15036

check_execute(stmt1, rc);

15037

15038

rc= mysql_stmt_reset(stmt1);

15039

check_execute(stmt1, rc);

15040

15041

rc= mysql_stmt_close(stmt1);

15042

check_execute(stmt1, rc);

15043

15044

if (!opt_silent)

15045

printf("data is: %s", (f1 == 1 && f2 == 1 && f3 == 2)?"OK":

15046

"wrong");

15047

DIE_UNLESS(f1 == 1 && f2 == 1 && f3 == 2);

15048

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

15049

myquery(rc);

15050

}

15051

15052

15053

Bug#13524: warnings of a previous command are not reset when fetching

15054

from a cursor.

15055

15056

15057

static void test_bug13524()

15058

{

15059

MYSQL_STMT *stmt;

15060

int rc;

15061

unsigned int warning_count;

15062

const ulong type= CURSOR_TYPE_READ_ONLY;

15063

const char *query= "select * from t1";

15064

15065

myheader("test_bug13524");

15066

15067

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

15068

myquery(rc);

15069

rc= mysql_query(mysql, "create table t1 (a int not null primary key)");

15070

myquery(rc);

15071

rc= mysql_query(mysql, "insert into t1 values (1), (2), (3), (4)");

15072

myquery(rc);

15073

15074

stmt= mysql_stmt_init(mysql);

15075

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

15076

check_execute(stmt, rc);

15077

15078

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

15079

check_execute(stmt, rc);

15080

15081

rc= mysql_stmt_execute(stmt);

15082

check_execute(stmt, rc);

15083

15084

rc= mysql_stmt_fetch(stmt);

15085

check_execute(stmt, rc);

15086

15087

warning_count= mysql_warning_count(mysql);

15088

DIE_UNLESS(warning_count == 0);

15089

15090

/* Check that DROP TABLE produced a warning (no such table) */

15091

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

15092

myquery(rc);

15093

warning_count= mysql_warning_count(mysql);

15094

DIE_UNLESS(warning_count == 1);

15095

15096

15097

Check that fetch from a cursor cleared the warning from the previous

15098

command.

15099

15100

rc= mysql_stmt_fetch(stmt);

15101

check_execute(stmt, rc);

15102

warning_count= mysql_warning_count(mysql);

15103

DIE_UNLESS(warning_count == 0);

15104

15105

/* Cleanup */

15106

mysql_stmt_close(stmt);

15107

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

15108

myquery(rc);

15109

}

15110

15111

15112

Bug#14845 "mysql_stmt_fetch returns MYSQL_NO_DATA when COUNT(*) is 0"

15113

15114

15115

static void test_bug14845()

15116

{

15117

MYSQL_STMT *stmt;

15118

int rc;

15119

const ulong type= CURSOR_TYPE_READ_ONLY;

15120

const char *query= "select count(*) from t1 where 1 = 0";

15121

15122

myheader("test_bug14845");

15123

15124

rc= mysql_query(mysql, "drop table if exists t1");

15125

myquery(rc);

15126

rc= mysql_query(mysql, "create table t1 (id int(11) default null, "

15127

"name varchar(20) default null)"

15128

"engine=MyISAM DEFAULT CHARSET=utf8");

15129

myquery(rc);

15130

rc= mysql_query(mysql, "insert into t1 values (1,'abc'),(2,'def')");

15131

myquery(rc);

15132

15133

stmt= mysql_stmt_init(mysql);

15134

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

15135

check_execute(stmt, rc);

15136

15137

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

15138

check_execute(stmt, rc);

15139

15140

rc= mysql_stmt_execute(stmt);

15141

check_execute(stmt, rc);

15142

15143

rc= mysql_stmt_fetch(stmt);

15144

DIE_UNLESS(rc == 0);

15145

15146

rc= mysql_stmt_fetch(stmt);

15147

DIE_UNLESS(rc == MYSQL_NO_DATA);

15148

15149

/* Cleanup */

15150

mysql_stmt_close(stmt);

15151

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

15152

myquery(rc);

15153

}

15154

15155

15156

15157

Bug #15510: mysql_warning_count returns 0 after mysql_stmt_fetch which

15158

should warn

15159

15160

static void test_bug15510()

15161

{

15162

MYSQL_STMT *stmt;

15163

int rc;

15164

const char *query= "select 1 from dual where 1/0";

15165

15166

myheader("test_bug15510");

15167

15168

rc= mysql_query(mysql, "set @@sql_mode='ERROR_FOR_DIVISION_BY_ZERO'");

15169

myquery(rc);

15170

15171

stmt= mysql_stmt_init(mysql);

15172

15173

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

15174

check_execute(stmt, rc);

15175

15176

rc= mysql_stmt_execute(stmt);

15177

check_execute(stmt, rc);

15178

15179

rc= mysql_stmt_fetch(stmt);

15180

DIE_UNLESS(mysql_warning_count(mysql));

15181

15182

/* Cleanup */

15183

mysql_stmt_close(stmt);

15184

rc= mysql_query(mysql, "set @@sql_mode=''");

15185

myquery(rc);

15186

}

15187

15188

15189

/* Test MYSQL_OPT_RECONNECT, Bug#15719 */

15190

15191

static void test_opt_reconnect()

15192

{

15193

MYSQL *lmysql;

15194

my_bool my_true= TRUE;

15195

15196

myheader("test_opt_reconnect");

15197

15198

if (!(lmysql= mysql_client_init(NULL)))

15199

{

15200

myerror("mysql_client_init() failed");

15201

exit(1);

15202

}

15203

15204

if (!opt_silent)

15205

fprintf(stdout, "reconnect before mysql_options: %d\n", lmysql->reconnect);

15206

DIE_UNLESS(lmysql->reconnect == 0);

15207

15208

if (mysql_options(lmysql, MYSQL_OPT_RECONNECT, &my_true))

15209

{

15210

myerror("mysql_options failed: unknown option MYSQL_OPT_RECONNECT\n");

15211

DIE_UNLESS(0);

15212

}

15213

15214

/* reconnect should be 1 */

15215

if (!opt_silent)

15216

fprintf(stdout, "reconnect after mysql_options: %d\n", lmysql->reconnect);

15217

DIE_UNLESS(lmysql->reconnect == 1);

15218

15219

if (!(mysql_real_connect(lmysql, opt_host, opt_user,

15220

opt_password, current_db, opt_port,

15221

opt_unix_socket, 0)))

15222

{

15223

myerror("connection failed");

15224

DIE_UNLESS(0);

15225

}

15226

15227

/* reconnect should still be 1 */

15228

if (!opt_silent)

15229

fprintf(stdout, "reconnect after mysql_real_connect: %d\n",

15230

lmysql->reconnect);

15231

DIE_UNLESS(lmysql->reconnect == 1);

15232

15233

mysql_close(lmysql);

15234

15235

if (!(lmysql= mysql_client_init(NULL)))

15236

{

15237

myerror("mysql_client_init() failed");

15238

DIE_UNLESS(0);

15239

}

15240

15241

if (!opt_silent)

15242

fprintf(stdout, "reconnect before mysql_real_connect: %d\n", lmysql->reconnect);

15243

DIE_UNLESS(lmysql->reconnect == 0);

15244

15245

if (!(mysql_real_connect(lmysql, opt_host, opt_user,

15246

opt_password, current_db, opt_port,

15247

opt_unix_socket, 0)))

15248

{

15249

myerror("connection failed");

15250

DIE_UNLESS(0);

15251

}

15252

15253

/* reconnect should still be 0 */

15254

if (!opt_silent)

15255

fprintf(stdout, "reconnect after mysql_real_connect: %d\n",

15256

lmysql->reconnect);

15257

DIE_UNLESS(lmysql->reconnect == 0);

15258

15259

mysql_close(lmysql);

15260

}

15261

15262

15263

#ifndef EMBEDDED_LIBRARY

15264

15265

static void test_bug12744()

15266

{

15267

MYSQL_STMT *prep_stmt = NULL;

15268

MYSQL *lmysql;

15269

int rc;

15270

myheader("test_bug12744");

15271

15272

lmysql= mysql_client_init(NULL);

15273

DIE_UNLESS(lmysql);

15274

15275

if (!mysql_real_connect(lmysql, opt_host, opt_user, opt_password,

15276

current_db, opt_port, opt_unix_socket, 0))

15277

{

15278

fprintf(stderr, "Failed to connect to the database\n");

15279

DIE_UNLESS(0);

15280

}

15281

15282

prep_stmt= mysql_stmt_init(lmysql);

15283

rc= mysql_stmt_prepare(prep_stmt, "SELECT 1", 8);

15284

DIE_UNLESS(rc == 0);

15285

15286

mysql_close(lmysql);

15287

15288

rc= mysql_stmt_execute(prep_stmt);

15289

DIE_UNLESS(rc);

15290

rc= mysql_stmt_reset(prep_stmt);

15291

DIE_UNLESS(rc);

15292

rc= mysql_stmt_close(prep_stmt);

15293

DIE_UNLESS(rc == 0);

15294

}

15295

15296

#endif /* EMBEDDED_LIBRARY */

15297

15298

/* Bug #16143: mysql_stmt_sqlstate returns an empty string instead of '00000' */

15299

15300

static void test_bug16143()

15301

{

15302

MYSQL_STMT *stmt;

15303

myheader("test_bug16143");

15304

15305

stmt= mysql_stmt_init(mysql);

15306

/* Check mysql_stmt_sqlstate return "no error" */

15307

DIE_UNLESS(strcmp(mysql_stmt_sqlstate(stmt), "00000") == 0);

15308

15309

mysql_stmt_close(stmt);

15310

}

15311

15312

15313

/* Bug #16144: mysql_stmt_attr_get type error */

15314

15315

static void test_bug16144()

15316

{

15317

const my_bool flag_orig= (my_bool) 0xde;

15318

my_bool flag= flag_orig;

15319

MYSQL_STMT *stmt;

15320

myheader("test_bug16144");

15321

15322

/* Check that attr_get returns correct data on little and big endian CPUs */

15323

stmt= mysql_stmt_init(mysql);

15324

mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (const void*) &flag);

15325

mysql_stmt_attr_get(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &flag);

15326

DIE_UNLESS(flag == flag_orig);

15327

15328

mysql_stmt_close(stmt);

15329

}

15330

15331

15332

Bug #15613: "libmysqlclient API function mysql_stmt_prepare returns wrong

15333

field length"

15334

15335

15336

static void test_bug15613()

15337

{

15338

MYSQL_STMT *stmt;

15339

const char *stmt_text;

15340

MYSQL_RES *metadata;

15341

MYSQL_FIELD *field;

15342

int rc;

15343

myheader("test_bug15613");

15344

15345

/* I. Prepare the table */

15346

rc= mysql_query(mysql, "set names latin1");

15347

myquery(rc);

15348

mysql_query(mysql, "drop table if exists t1");

15349

rc= mysql_query(mysql,

15350

"create table t1 (t text character set utf8, "

15351

"tt tinytext character set utf8, "

15352

"mt mediumtext character set utf8, "

15353

"lt longtext character set utf8, "

15354

"vl varchar(255) character set latin1,"

15355

"vb varchar(255) character set binary,"

15356

"vu varchar(255) character set utf8)");

15357

myquery(rc);

15358

15359

stmt= mysql_stmt_init(mysql);

15360

15361

/* II. Check SELECT metadata */

15362

stmt_text= ("select t, tt, mt, lt, vl, vb, vu from t1");

15363

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

15364

metadata= mysql_stmt_result_metadata(stmt);

15365

field= mysql_fetch_fields(metadata);

15366

if (!opt_silent)

15367

{

15368

printf("Field lengths (client character set is latin1):\n"

15369

"text character set utf8:\t\t%lu\n"

15370

"tinytext character set utf8:\t\t%lu\n"

15371

"mediumtext character set utf8:\t\t%lu\n"

15372

"longtext character set utf8:\t\t%lu\n"

15373

"varchar(255) character set latin1:\t%lu\n"

15374

"varchar(255) character set binary:\t%lu\n"

15375

"varchar(255) character set utf8:\t%lu\n",

15376

field[0].length, field[1].length, field[2].length, field[3].length,

15377

field[4].length, field[5].length, field[6].length);

15378

}

15379

DIE_UNLESS(field[0].length == 65535);

15380

DIE_UNLESS(field[1].length == 255);

15381

DIE_UNLESS(field[2].length == 16777215);

15382

DIE_UNLESS(field[3].length == 4294967295UL);

15383

DIE_UNLESS(field[4].length == 255);

15384

DIE_UNLESS(field[5].length == 255);

15385

DIE_UNLESS(field[6].length == 255);

15386

mysql_free_result(metadata);

15387

mysql_stmt_free_result(stmt);

15388

15389

/* III. Cleanup */

15390

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

15391

myquery(rc);

15392

rc= mysql_query(mysql, "set names default");

15393

myquery(rc);

15394

mysql_stmt_close(stmt);

15395

}

15396

15397

15398

Bug#17667: An attacker has the opportunity to bypass query logging.

15399

15400

Note! Also tests Bug#21813, where prepared statements are used to

15401

run queries

15402

15403

static void test_bug17667()

15404

{

15405

int rc;

15406

MYSQL_STMT *stmt;

15407

enum query_type { QT_NORMAL, QT_PREPARED};

15408

struct buffer_and_length {

15409

enum query_type qt;

15410

const char *buffer;

15411

const uint length;

15412

} statements[]= {

15413

{ QT_NORMAL, "drop table if exists bug17667", 29 },

15414

{ QT_NORMAL, "create table bug17667 (c varchar(20))", 37 },

15415

{ QT_NORMAL, "insert into bug17667 (c) values ('regular') /* NUL=\0 with comment */", 68 },

15416

{ QT_PREPARED,

15417

"insert into bug17667 (c) values ('prepared') /* NUL=\0 with comment */", 69, },

15418

{ QT_NORMAL, "insert into bug17667 (c) values ('NUL=\0 in value')", 50 },

15419

{ QT_NORMAL, "insert into bug17667 (c) values ('5 NULs=\0\0\0\0\0')", 48 },

15420

{ QT_PREPARED, "insert into bug17667 (c) values ('6 NULs=\0\0\0\0\0\0')", 50 },

15421

{ QT_NORMAL, "/* NUL=\0 with comment */ insert into bug17667 (c) values ('encore')", 67 },

15422

{ QT_NORMAL, "drop table bug17667", 19 },

15423

{ QT_NORMAL, NULL, 0 } };

15424

15425

struct buffer_and_length *statement_cursor;

15426

FILE *log_file;

15427

char *master_log_filename;

15428

15429

myheader("test_bug17667");

15430

15431

master_log_filename = (char *) malloc(strlen(opt_vardir) + strlen("/log/master.log") + 1);

15432

strxmov(master_log_filename, opt_vardir, "/log/master.log", NullS);

15433

if (!opt_silent)

15434

printf("Opening '%s'\n", master_log_filename);

15435

log_file= my_fopen(master_log_filename, (int) (O_RDONLY | O_BINARY), MYF(0));

15436

free(master_log_filename);

15437

15438

if (log_file == NULL)

15439

{

15440

if (!opt_silent)

15441

{

15442

printf("Could not find the log file, VARDIR/log/master.log, so "

15443

"test_bug17667 is not run.\n"

15444

"Run test from the mysql-test/mysql-test-run* program to set up "

15445

"correct environment for this test.\n\n");

15446

}

15447

return;

15448

}

15449

15450

enable_general_log(1);

15451

15452

for (statement_cursor= statements; statement_cursor->buffer != NULL;

15453

statement_cursor++)

15454

{

15455

if (statement_cursor->qt == QT_NORMAL)

15456

{

15457

/* Run statement as normal query */

15458

rc= mysql_real_query(mysql, statement_cursor->buffer,

15459

statement_cursor->length);

15460

myquery(rc);

15461

}

15462

else if (statement_cursor->qt == QT_PREPARED)

15463

{

15464

15465

Run as prepared statement

15466

15467

NOTE! All these queries should be in the log twice,

15468

one time for prepare and one time for execute

15469

15470

stmt= mysql_stmt_init(mysql);

15471

15472

rc= mysql_stmt_prepare(stmt, statement_cursor->buffer,

15473

statement_cursor->length);

15474

check_execute(stmt, rc);

15475

15476

rc= mysql_stmt_execute(stmt);

15477

check_execute(stmt, rc);

15478

15479

mysql_stmt_close(stmt);

15480

}

15481

else

15482

{

15483

DIE_UNLESS(0==1);

15484

}

15485

}

15486

15487

/* Make sure the server has written the logs to disk before reading it */

15488

rc= mysql_query(mysql, "flush logs");

15489

myquery(rc);

15490

15491

for (statement_cursor= statements; statement_cursor->buffer != NULL;

15492

statement_cursor++)

15493

{

15494

int expected_hits= 1, hits= 0;

15495

char line_buffer[MAX_TEST_QUERY_LENGTH*2];

15496

/* more than enough room for the query and some marginalia. */

15497

15498

/* Prepared statments always occurs twice in log */

15499

if (statement_cursor->qt == QT_PREPARED)

15500

expected_hits++;

15501

15502

/* Loop until we found expected number of log entries */

15503

do {

15504

/* Loop until statement is found in log */

15505

do {

15506

memset(line_buffer, '/', MAX_TEST_QUERY_LENGTH*2);

15507

15508

if(fgets(line_buffer, MAX_TEST_QUERY_LENGTH*2, log_file) == NULL)

15509

{

15510

/* If fgets returned NULL, it indicates either error or EOF */

15511

if (feof(log_file))

15512

DIE("Found EOF before all statements where found");

15513

15514

fprintf(stderr, "Got error %d while reading from file\n",

15515

ferror(log_file));

15516

DIE("Read error");

15517

}

15518

15519

} while (my_memmem(line_buffer, MAX_TEST_QUERY_LENGTH*2,

15520

statement_cursor->buffer,

15521

statement_cursor->length) == NULL);

15522

hits++;

15523

} while (hits < expected_hits);

15524

15525

if (!opt_silent)

15526

printf("Found statement starting with \"%s\"\n",

15527

statement_cursor->buffer);

15528

}

15529

15530

restore_general_log();

15531

15532

if (!opt_silent)

15533

printf("success. All queries found intact in the log.\n");

15534

15535

my_fclose(log_file, MYF(0));

15536

}

15537

15538

15539

15540

Bug#14169: type of group_concat() result changed to blob if tmp_table was

15541

used

15542

15543

static void test_bug14169()

15544

{

15545

MYSQL_STMT *stmt;

15546

const char *stmt_text;

15547

MYSQL_RES *res;

15548

MYSQL_FIELD *field;

15549

int rc;

15550

15551

myheader("test_bug14169");

15552

15553

rc= mysql_query(mysql, "drop table if exists t1");

15554

myquery(rc);

15555

rc= mysql_query(mysql, "set session group_concat_max_len=1024");

15556

myquery(rc);

15557

rc= mysql_query(mysql, "create table t1 (f1 int unsigned, f2 varchar(255))");

15558

myquery(rc);

15559

rc= mysql_query(mysql, "insert into t1 values (1,repeat('a',255)),"

15560

"(2,repeat('b',255))");

15561

myquery(rc);

15562

stmt= mysql_stmt_init(mysql);

15563

stmt_text= "select f2,group_concat(f1) from t1 group by f2";

15564

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

15565

myquery(rc);

15566

res= mysql_stmt_result_metadata(stmt);

15567

field= mysql_fetch_fields(res);

15568

if (!opt_silent)

15569

printf("GROUP_CONCAT() result type %i", field[1].type);

15570

DIE_UNLESS(field[1].type == MYSQL_TYPE_BLOB);

15571

mysql_free_result(res);

15572

mysql_stmt_free_result(stmt);

15573

mysql_stmt_close(stmt);

15574

15575

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

15576

myquery(rc);

15577

}

15578

15579

15580

Test that mysql_insert_id() behaves as documented in our manual

15581

15582

static void test_mysql_insert_id()

15583

{

15584

my_ulonglong res;

15585

int rc;

15586

15587

myheader("test_mysql_insert_id");

15588

15589

rc= mysql_query(mysql, "drop table if exists t1");

15590

myquery(rc);

15591

/* table without auto_increment column */

15592

rc= mysql_query(mysql, "create table t1 (f1 int, f2 varchar(255), key(f1))");

15593

myquery(rc);

15594

rc= mysql_query(mysql, "insert into t1 values (1,'a')");

15595

myquery(rc);

15596

res= mysql_insert_id(mysql);

15597

DIE_UNLESS(res == 0);

15598

rc= mysql_query(mysql, "insert into t1 values (null,'b')");

15599

myquery(rc);

15600

res= mysql_insert_id(mysql);

15601

DIE_UNLESS(res == 0);

15602

rc= mysql_query(mysql, "insert into t1 select 5,'c'");

15603

myquery(rc);

15604

res= mysql_insert_id(mysql);

15605

DIE_UNLESS(res == 0);

15606

15607

15608

Test for bug #34889: mysql_client_test::test_mysql_insert_id test fails

15609

sporadically

15610

15611

rc= mysql_query(mysql, "create table t2 (f1 int not null primary key auto_increment, f2 varchar(255))");

15612

myquery(rc);

15613

rc= mysql_query(mysql, "insert into t2 values (null,'b')");

15614

myquery(rc);

15615

rc= mysql_query(mysql, "insert into t1 select 5,'c'");

15616

myquery(rc);

15617

res= mysql_insert_id(mysql);

15618

DIE_UNLESS(res == 0);

15619

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

15620

myquery(rc);

15621

15622

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

15623

myquery(rc);

15624

res= mysql_insert_id(mysql);

15625

DIE_UNLESS(res == 0);

15626

rc= mysql_query(mysql, "insert into t1 values (null,last_insert_id(300))");

15627

myquery(rc);

15628

res= mysql_insert_id(mysql);

15629

DIE_UNLESS(res == 300);

15630

rc= mysql_query(mysql, "insert into t1 select null,last_insert_id(400)");

15631

myquery(rc);

15632

res= mysql_insert_id(mysql);

15633

15634

Behaviour change: old code used to return 0; but 400 is consistent

15635

with INSERT VALUES, and the manual's section of mysql_insert_id() does not

15636

say INSERT SELECT should be different.

15637

15638

DIE_UNLESS(res == 400);

15639

15640

/* table with auto_increment column */

15641

rc= mysql_query(mysql, "create table t2 (f1 int not null primary key auto_increment, f2 varchar(255))");

15642

myquery(rc);

15643

rc= mysql_query(mysql, "insert into t2 values (1,'a')");

15644

myquery(rc);

15645

res= mysql_insert_id(mysql);

15646

DIE_UNLESS(res == 1);

15647

/* this should not influence next INSERT if it doesn't have auto_inc */

15648

rc= mysql_query(mysql, "insert into t1 values (10,'e')");

15649

myquery(rc);

15650

res= mysql_insert_id(mysql);

15651

DIE_UNLESS(res == 0);

15652

15653

rc= mysql_query(mysql, "insert into t2 values (null,'b')");

15654

myquery(rc);

15655

res= mysql_insert_id(mysql);

15656

DIE_UNLESS(res == 2);

15657

rc= mysql_query(mysql, "insert into t2 select 5,'c'");

15658

myquery(rc);

15659

res= mysql_insert_id(mysql);

15660

15661

Manual says that for multirow insert this should have been 5, but does not

15662

say for INSERT SELECT. This is a behaviour change: old code used to return

15663

0. We try to be consistent with INSERT VALUES.

15664

15665

DIE_UNLESS(res == 5);

15666

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

15667

myquery(rc);

15668

res= mysql_insert_id(mysql);

15669

DIE_UNLESS(res == 6);

15670

/* with more than one row */

15671

rc= mysql_query(mysql, "insert into t2 values (10,'a'),(11,'b')");

15672

myquery(rc);

15673

res= mysql_insert_id(mysql);

15674

DIE_UNLESS(res == 11);

15675

rc= mysql_query(mysql, "insert into t2 select 12,'a' union select 13,'b'");

15676

myquery(rc);

15677

res= mysql_insert_id(mysql);

15678

15679

Manual says that for multirow insert this should have been 13, but does

15680

not say for INSERT SELECT. This is a behaviour change: old code used to

15681

return 0. We try to be consistent with INSERT VALUES.

15682

15683

DIE_UNLESS(res == 13);

15684

rc= mysql_query(mysql, "insert into t2 values (null,'a'),(null,'b')");

15685

myquery(rc);

15686

res= mysql_insert_id(mysql);

15687

DIE_UNLESS(res == 14);

15688

rc= mysql_query(mysql, "insert into t2 select null,'a' union select null,'b'");

15689

myquery(rc);

15690

res= mysql_insert_id(mysql);

15691

DIE_UNLESS(res == 16);

15692

rc= mysql_query(mysql, "insert into t2 select 12,'a' union select 13,'b'");

15693

myquery_r(rc);

15694

rc= mysql_query(mysql, "insert ignore into t2 select 12,'a' union select 13,'b'");

15695

myquery(rc);

15696

res= mysql_insert_id(mysql);

15697

DIE_UNLESS(res == 0);

15698

rc= mysql_query(mysql, "insert into t2 values (12,'a'),(13,'b')");

15699

myquery_r(rc);

15700

res= mysql_insert_id(mysql);

15701

DIE_UNLESS(res == 0);

15702

rc= mysql_query(mysql, "insert ignore into t2 values (12,'a'),(13,'b')");

15703

myquery(rc);

15704

res= mysql_insert_id(mysql);

15705

DIE_UNLESS(res == 0);

15706

/* mixing autogenerated and explicit values */

15707

rc= mysql_query(mysql, "insert into t2 values (null,'e'),(12,'a'),(13,'b')");

15708

myquery_r(rc);

15709

rc= mysql_query(mysql, "insert into t2 values (null,'e'),(12,'a'),(13,'b'),(25,'g')");

15710

myquery_r(rc);

15711

rc= mysql_query(mysql, "insert into t2 values (null,last_insert_id(300))");

15712

myquery(rc);

15713

res= mysql_insert_id(mysql);

15714

15715

according to the manual, this might be 20 or 300, but it looks like

15716

auto_increment column takes priority over last_insert_id().

15717

15718

DIE_UNLESS(res == 20);

15719

/* If first autogenerated number fails and 2nd works: */

15720

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

15721

myquery(rc);

15722

rc= mysql_query(mysql, "create table t2 (f1 int not null primary key "

15723

"auto_increment, f2 varchar(255), unique (f2))");

15724

myquery(rc);

15725

rc= mysql_query(mysql, "insert into t2 values (null,'e')");

15726

res= mysql_insert_id(mysql);

15727

DIE_UNLESS(res == 1);

15728

rc= mysql_query(mysql, "insert ignore into t2 values (null,'e'),(null,'a'),(null,'e')");

15729

myquery(rc);

15730

res= mysql_insert_id(mysql);

15731

DIE_UNLESS(res == 2);

15732

/* If autogenerated fails and explicit works: */

15733

rc= mysql_query(mysql, "insert ignore into t2 values (null,'e'),(12,'c'),(null,'d')");

15734

myquery(rc);

15735

res= mysql_insert_id(mysql);

15736

15737

Behaviour change: old code returned 3 (first autogenerated, even if it

15738

fails); we now return first successful autogenerated.

15739

15740

DIE_UNLESS(res == 13);

15741

/* UPDATE may update mysql_insert_id() if it uses LAST_INSERT_ID(#) */

15742

rc= mysql_query(mysql, "update t2 set f1=14 where f1=12");

15743

myquery(rc);

15744

res= mysql_insert_id(mysql);

15745

DIE_UNLESS(res == 0);

15746

rc= mysql_query(mysql, "update t2 set f1=0 where f1=14");

15747

myquery(rc);

15748

res= mysql_insert_id(mysql);

15749

DIE_UNLESS(res == 0);

15750

rc= mysql_query(mysql, "update t2 set f2=last_insert_id(372) where f1=0");

15751

myquery(rc);

15752

res= mysql_insert_id(mysql);

15753

DIE_UNLESS(res == 372);

15754

/* check that LAST_INSERT_ID() does not update mysql_insert_id(): */

15755

rc= mysql_query(mysql, "insert into t2 values (null,'g')");

15756

myquery(rc);

15757

res= mysql_insert_id(mysql);

15758

DIE_UNLESS(res == 15);

15759

rc= mysql_query(mysql, "update t2 set f2=(@li:=last_insert_id()) where f1=15");

15760

myquery(rc);

15761

res= mysql_insert_id(mysql);

15762

DIE_UNLESS(res == 0);

15763

15764

Behaviour change: now if ON DUPLICATE KEY UPDATE updates a row,

15765

mysql_insert_id() returns the id of the row, instead of not being

15766

affected.

15767

15768

rc= mysql_query(mysql, "insert into t2 values (null,@li) on duplicate key "

15769

"update f2=concat('we updated ',f2)");

15770

myquery(rc);

15771

res= mysql_insert_id(mysql);

15772

DIE_UNLESS(res == 15);

15773

15774

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

15775

myquery(rc);

15776

}

15777

15778

15779

Bug#20152: mysql_stmt_execute() writes to MYSQL_TYPE_DATE buffer

15780

15781

15782

static void test_bug20152()

15783

{

15784

MYSQL_BIND my_bind[1];

15785

MYSQL_STMT *stmt;

15786

MYSQL_TIME tm;

15787

int rc;

15788

const char *query= "INSERT INTO t1 (f1) VALUES (?)";

15789

15790

myheader("test_bug20152");

15791

15792

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

15793

my_bind[0].buffer_type= MYSQL_TYPE_DATE;

15794

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

15795

15796

tm.year = 2006;

15797

tm.month = 6;

15798

tm.day = 18;

15799

tm.hour = 14;

15800

tm.minute = 9;

15801

tm.second = 42;

15802

15803

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

15804

myquery(rc);

15805

rc= mysql_query(mysql, "CREATE TABLE t1 (f1 DATE)");

15806

myquery(rc);

15807

15808

stmt= mysql_stmt_init(mysql);

15809

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

15810

check_execute(stmt, rc);

15811

rc= mysql_stmt_bind_param(stmt, my_bind);

15812

check_execute(stmt, rc);

15813

rc= mysql_stmt_execute(stmt);

15814

check_execute(stmt, rc);

15815

rc= mysql_stmt_close(stmt);

15816

check_execute(stmt, rc);

15817

rc= mysql_query(mysql, "DROP TABLE t1");

15818

myquery(rc);

15819

15820

if (tm.hour == 14 && tm.minute == 9 && tm.second == 42) {

15821

if (!opt_silent)

15822

printf("OK!");

15823

} else {

15824

printf("[14:09:42] != [%02d:%02d:%02d]\n", tm.hour, tm.minute, tm.second);

15825

DIE_UNLESS(0==1);

15826

}

15827

}

15828

15829

/* Bug#15752 "Lost connection to MySQL server when calling a SP from C API" */

15830

15831

static void test_bug15752()

15832

{

15833

MYSQL mysql_local;

15834

int rc, i;

15835

const int ITERATION_COUNT= 100;

15836

const char *query= "CALL p1()";

15837

15838

myheader("test_bug15752");

15839

15840

rc= mysql_query(mysql, "drop procedure if exists p1");

15841

myquery(rc);

15842

rc= mysql_query(mysql, "create procedure p1() select 1");

15843

myquery(rc);

15844

15845

mysql_client_init(&mysql_local);

15846

if (! mysql_real_connect(&mysql_local, opt_host, opt_user,

15847

opt_password, current_db, opt_port,

15848

opt_unix_socket,

15849

CLIENT_MULTI_STATEMENTS|CLIENT_MULTI_RESULTS))

15850

{

15851

printf("Unable connect to MySQL server: %s\n", mysql_error(&mysql_local));

15852

DIE_UNLESS(0);

15853

}

15854

rc= mysql_real_query(&mysql_local, query, strlen(query));

15855

myquery(rc);

15856

mysql_free_result(mysql_store_result(&mysql_local));

15857

15858

rc= mysql_real_query(&mysql_local, query, strlen(query));

15859

DIE_UNLESS(rc && mysql_errno(&mysql_local) == CR_COMMANDS_OUT_OF_SYNC);

15860

15861

if (! opt_silent)

15862

printf("Got error (as expected): %s\n", mysql_error(&mysql_local));

15863

15864

/* Check some other commands too */

15865

15866

DIE_UNLESS(mysql_next_result(&mysql_local) == 0);

15867

mysql_free_result(mysql_store_result(&mysql_local));

15868

DIE_UNLESS(mysql_next_result(&mysql_local) == -1);

15869

15870

/* The second problem is not reproducible: add the test case */

15871

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

15872

{

15873

if (mysql_real_query(&mysql_local, query, strlen(query)))

15874

{

15875

printf("\ni=%d %s failed: %s\n", i, query, mysql_error(&mysql_local));

15876

break;

15877

}

15878

mysql_free_result(mysql_store_result(&mysql_local));

15879

DIE_UNLESS(mysql_next_result(&mysql_local) == 0);

15880

mysql_free_result(mysql_store_result(&mysql_local));

15881

DIE_UNLESS(mysql_next_result(&mysql_local) == -1);

15882

15883

}

15884

mysql_close(&mysql_local);

15885

rc= mysql_query(mysql, "drop procedure p1");

15886

myquery(rc);

15887

}

15888

15889

15890

Bug#21206: memory corruption when too many cursors are opened at once

15891

15892

Memory corruption happens when more than 1024 cursors are open

15893

simultaneously.

15894

15895

static void test_bug21206()

15896

{

15897

const size_t cursor_count= 1025;

15898

15899

const char *create_table[]=

15900

{

15901

"DROP TABLE IF EXISTS t1",

15902

"CREATE TABLE t1 (i INT)",

15903

"INSERT INTO t1 VALUES (1), (2), (3)"

15904

};

15905

const char *query= "SELECT * FROM t1";

15906

15907

Stmt_fetch *fetch_array=

15908

(Stmt_fetch*) calloc(cursor_count, sizeof(Stmt_fetch));

15909

15910

Stmt_fetch *fetch;

15911

15912

DBUG_ENTER("test_bug21206");

15913

myheader("test_bug21206");

15914

15915

fill_tables(create_table, sizeof(create_table) / sizeof(*create_table));

15916

15917

for (fetch= fetch_array; fetch < fetch_array + cursor_count; ++fetch)

15918

{

15919

/* Init will exit(1) in case of error */

15920

stmt_fetch_init(fetch, fetch - fetch_array, query);

15921

}

15922

15923

for (fetch= fetch_array; fetch < fetch_array + cursor_count; ++fetch)

15924

stmt_fetch_close(fetch);

15925

15926

free(fetch_array);

15927

15928

DBUG_VOID_RETURN;

15929

}

15930

15931

15932

Ensure we execute the status code while testing

15933

15934

15935

static void test_status()

15936

{

15937

const char *status;

15938

DBUG_ENTER("test_status");

15939

myheader("test_status");

15940

15941

if (!(status= mysql_stat(mysql)))

15942

{

15943

myerror("mysql_stat failed"); /* purecov: inspected */

15944

die(__FILE__, __LINE__, "mysql_stat failed"); /* purecov: inspected */

15945

}

15946

DBUG_VOID_RETURN;

15947

}

15948

15949

15950

Bug#21726: Incorrect result with multiple invocations of

15951

LAST_INSERT_ID

15952

15953

Test that client gets updated value of insert_id on UPDATE that uses

15954

LAST_INSERT_ID(expr).

15955

select_query added to test for bug

15956

#26921 Problem in mysql_insert_id() Embedded C API function

15957

15958

static void test_bug21726()

15959

{

15960

const char *create_table[]=

15961

{

15962

"DROP TABLE IF EXISTS t1",

15963

"CREATE TABLE t1 (i INT)",

15964

"INSERT INTO t1 VALUES (1)",

15965

};

15966

const char *update_query= "UPDATE t1 SET i= LAST_INSERT_ID(i + 1)";

15967

int rc;

15968

my_ulonglong insert_id;

15969

const char *select_query= "SELECT * FROM t1";

15970

MYSQL_RES *result;

15971

15972

DBUG_ENTER("test_bug21726");

15973

myheader("test_bug21726");

15974

15975

fill_tables(create_table, sizeof(create_table) / sizeof(*create_table));

15976

15977

rc= mysql_query(mysql, update_query);

15978

myquery(rc);

15979

insert_id= mysql_insert_id(mysql);

15980

DIE_UNLESS(insert_id == 2);

15981

15982

rc= mysql_query(mysql, update_query);

15983

myquery(rc);

15984

insert_id= mysql_insert_id(mysql);

15985

DIE_UNLESS(insert_id == 3);

15986

15987

rc= mysql_query(mysql, select_query);

15988

myquery(rc);

15989

insert_id= mysql_insert_id(mysql);

15990

DIE_UNLESS(insert_id == 3);

15991

result= mysql_store_result(mysql);

15992

mysql_free_result(result);

15993

15994

DBUG_VOID_RETURN;

15995

}

15996

15997

15998

15999

BUG#23383: mysql_affected_rows() returns different values than

16000

mysql_stmt_affected_rows()

16001

16002

Test that both mysql_affected_rows() and mysql_stmt_affected_rows()

16003

return -1 on error, 0 when no rows were affected, and (positive) row

16004

count when some rows were affected.

16005

16006

static void test_bug23383()

16007

{

16008

const char *insert_query= "INSERT INTO t1 VALUES (1), (2)";

16009

const char *update_query= "UPDATE t1 SET i= 4 WHERE i = 3";

16010

MYSQL_STMT *stmt;

16011

my_ulonglong row_count;

16012

int rc;

16013

16014

DBUG_ENTER("test_bug23383");

16015

myheader("test_bug23383");

16016

16017

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

16018

myquery(rc);

16019

16020

rc= mysql_query(mysql, "CREATE TABLE t1 (i INT UNIQUE)");

16021

myquery(rc);

16022

16023

rc= mysql_query(mysql, insert_query);

16024

myquery(rc);

16025

row_count= mysql_affected_rows(mysql);

16026

DIE_UNLESS(row_count == 2);

16027

16028

rc= mysql_query(mysql, insert_query);

16029

DIE_UNLESS(rc != 0);

16030

row_count= mysql_affected_rows(mysql);

16031

DIE_UNLESS(row_count == (my_ulonglong)-1);

16032

16033

rc= mysql_query(mysql, update_query);

16034

myquery(rc);

16035

row_count= mysql_affected_rows(mysql);

16036

DIE_UNLESS(row_count == 0);

16037

16038

rc= mysql_query(mysql, "DELETE FROM t1");

16039

myquery(rc);

16040

16041

stmt= mysql_stmt_init(mysql);

16042

DIE_UNLESS(stmt != 0);

16043

16044

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

16045

check_execute(stmt, rc);

16046

16047

rc= mysql_stmt_execute(stmt);

16048

check_execute(stmt, rc);

16049

row_count= mysql_stmt_affected_rows(stmt);

16050

DIE_UNLESS(row_count == 2);

16051

16052

rc= mysql_stmt_execute(stmt);

16053

DIE_UNLESS(rc != 0);

16054

row_count= mysql_stmt_affected_rows(stmt);

16055

DIE_UNLESS(row_count == (my_ulonglong)-1);

16056

16057

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

16058

check_execute(stmt, rc);

16059

16060

rc= mysql_stmt_execute(stmt);

16061

check_execute(stmt, rc);

16062

row_count= mysql_stmt_affected_rows(stmt);

16063

DIE_UNLESS(row_count == 0);

16064

16065

rc= mysql_stmt_close(stmt);

16066

check_execute(stmt, rc);

16067

16068

rc= mysql_query(mysql, "DROP TABLE t1");

16069

myquery(rc);

16070

16071

DBUG_VOID_RETURN;

16072

}

16073

16074

16075

16076

BUG#21635: MYSQL_FIELD struct's member strings seem to misbehave for

16077

expression cols

16078

16079

Check that for MIN(), MAX(), COUNT() only MYSQL_FIELD::name is set

16080

to either expression or its alias, and db, org_table, table,

16081

org_name fields are empty strings.

16082

16083

static void test_bug21635()

16084

{

16085

const char *expr[]=

16086

{

16087

"MIN(i)", "MIN(i)",

16088

"MIN(i) AS A1", "A1",

16089

"MAX(i)", "MAX(i)",

16090

"MAX(i) AS A2", "A2",

16091

"COUNT(i)", "COUNT(i)",

16092

"COUNT(i) AS A3", "A3",

16093

};

16094

char query[MAX_TEST_QUERY_LENGTH];

16095

char *query_end;

16096

MYSQL_RES *result;

16097

MYSQL_FIELD *field;

16098

unsigned int field_count, i, j;

16099

int rc;

16100

16101

DBUG_ENTER("test_bug21635");

16102

myheader("test_bug21635");

16103

16104

query_end= strxmov(query, "SELECT ", NullS);

16105

for (i= 0; i < sizeof(expr) / sizeof(*expr) / 2; ++i)

16106

query_end= strxmov(query_end, expr[i * 2], ", ", NullS);

16107

query_end= strxmov(query_end - 2, " FROM t1 GROUP BY i", NullS);

16108

DIE_UNLESS(query_end - query < MAX_TEST_QUERY_LENGTH);

16109

16110

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

16111

myquery(rc);

16112

rc= mysql_query(mysql, "CREATE TABLE t1 (i INT)");

16113

myquery(rc);

16114

16115

We need this loop to ensure correct behavior with both constant and

16116

non-constant tables.

16117

16118

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

16119

{

16120

rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1)");

16121

myquery(rc);

16122

16123

rc= mysql_real_query(mysql, query, query_end - query);

16124

myquery(rc);

16125

16126

result= mysql_use_result(mysql);

16127

DIE_UNLESS(result);

16128

16129

field_count= mysql_field_count(mysql);

16130

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

16131

{

16132

field= mysql_fetch_field_direct(result, i);

16133

if (!opt_silent)

16134

if (!opt_silent)

16135

printf("%s -> %s ... ", expr[i * 2], field->name);

16136

fflush(stdout);

16137

DIE_UNLESS(field->db[0] == 0 && field->org_table[0] == 0 &&

16138

field->table[0] == 0 && field->org_name[0] == 0);

16139

DIE_UNLESS(strcmp(field->name, expr[i * 2 + 1]) == 0);

16140

if (!opt_silent)

16141

if (!opt_silent)

16142

puts("OK");

16143

}

16144

16145

mysql_free_result(result);

16146

}

16147

rc= mysql_query(mysql, "DROP TABLE t1");

16148

myquery(rc);

16149

16150

DBUG_VOID_RETURN;

16151

}

16152

16153

16154

Bug#24179 "select b into $var" fails with --cursor_protocol"

16155

The failure is correct, check that the returned message is meaningful.

16156

16157

16158

static void test_bug24179()

16159

{

16160

int rc;

16161

MYSQL_STMT *stmt;

16162

16163

DBUG_ENTER("test_bug24179");

16164

myheader("test_bug24179");

16165

16166

stmt= open_cursor("select 1 into @a");

16167

rc= mysql_stmt_execute(stmt);

16168

DIE_UNLESS(rc);

16169

if (!opt_silent)

16170

{

16171

printf("Got error (as expected): %d %s\n",

16172

mysql_stmt_errno(stmt),

16173

mysql_stmt_error(stmt));

16174

}

16175

DIE_UNLESS(mysql_stmt_errno(stmt) == 1323);

16176

mysql_stmt_close(stmt);

16177

16178

DBUG_VOID_RETURN;

16179

}

16180

16181

16182

/**

16183

Bug#32265 Server returns different metadata if prepared statement is used

16184

16185

16186

static void test_bug32265()

16187

{

16188

int rc;

16189

MYSQL_STMT *stmt;

16190

MYSQL_FIELD *field;

16191

MYSQL_RES *metadata;

16192

16193

DBUG_ENTER("test_bug32265");

16194

myheader("test_bug32265");

16195

16196

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

16197

myquery(rc);

16198

rc= mysql_query(mysql, "CREATE TABLE t1 (a INTEGER)");

16199

myquery(rc);

16200

rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1)");

16201

myquery(rc);

16202

rc= mysql_query(mysql, "CREATE VIEW v1 AS SELECT * FROM t1");

16203

myquery(rc);

16204

16205

stmt= open_cursor("SELECT * FROM t1");

16206

rc= mysql_stmt_execute(stmt);

16207

check_execute(stmt, rc);

16208

16209

metadata= mysql_stmt_result_metadata(stmt);

16210

field= mysql_fetch_field(metadata);

16211

DIE_UNLESS(field);

16212

DIE_UNLESS(strcmp(field->table, "t1") == 0);

16213

DIE_UNLESS(strcmp(field->org_table, "t1") == 0);

16214

DIE_UNLESS(strcmp(field->db, "client_test_db") == 0);

16215

mysql_free_result(metadata);

16216

mysql_stmt_close(stmt);

16217

16218

stmt= open_cursor("SELECT a '' FROM t1 ``");

16219

rc= mysql_stmt_execute(stmt);

16220

check_execute(stmt, rc);

16221

16222

metadata= mysql_stmt_result_metadata(stmt);

16223

field= mysql_fetch_field(metadata);

16224

DIE_UNLESS(strcmp(field->table, "") == 0);

16225

DIE_UNLESS(strcmp(field->org_table, "t1") == 0);

16226

DIE_UNLESS(strcmp(field->db, "client_test_db") == 0);

16227

mysql_free_result(metadata);

16228

mysql_stmt_close(stmt);

16229

16230

stmt= open_cursor("SELECT a '' FROM t1 ``");

16231

rc= mysql_stmt_execute(stmt);

16232

check_execute(stmt, rc);

16233

16234

metadata= mysql_stmt_result_metadata(stmt);

16235

field= mysql_fetch_field(metadata);

16236

DIE_UNLESS(strcmp(field->table, "") == 0);

16237

DIE_UNLESS(strcmp(field->org_table, "t1") == 0);

16238

DIE_UNLESS(strcmp(field->db, "client_test_db") == 0);

16239

mysql_free_result(metadata);

16240

mysql_stmt_close(stmt);

16241

16242

stmt= open_cursor("SELECT * FROM v1");

16243

rc= mysql_stmt_execute(stmt);

16244

check_execute(stmt, rc);

16245

16246

metadata= mysql_stmt_result_metadata(stmt);

16247

field= mysql_fetch_field(metadata);

16248

DIE_UNLESS(strcmp(field->table, "v1") == 0);

16249

DIE_UNLESS(strcmp(field->org_table, "v1") == 0);

16250

DIE_UNLESS(strcmp(field->db, "client_test_db") == 0);

16251

mysql_free_result(metadata);

16252

mysql_stmt_close(stmt);

16253

16254

stmt= open_cursor("SELECT * FROM v1 /* SIC */ GROUP BY 1");

16255

rc= mysql_stmt_execute(stmt);

16256

check_execute(stmt, rc);

16257

16258

metadata= mysql_stmt_result_metadata(stmt);

16259

field= mysql_fetch_field(metadata);

16260

DIE_UNLESS(strcmp(field->table, "v1") == 0);

16261

DIE_UNLESS(strcmp(field->org_table, "v1") == 0);

16262

DIE_UNLESS(strcmp(field->db, "client_test_db") == 0);

16263

mysql_free_result(metadata);

16264

mysql_stmt_close(stmt);

16265

16266

rc= mysql_query(mysql, "DROP VIEW v1");

16267

myquery(rc);

16268

rc= mysql_query(mysql, "DROP TABLE t1");

16269

myquery(rc);

16270

16271

DBUG_VOID_RETURN;

16272

}

16273

16274

16275

Bug#28075 "COM_DEBUG crashes mysqld"

16276

16277

16278

static void test_bug28075()

16279

{

16280

int rc;

16281

16282

DBUG_ENTER("test_bug28075");

16283

myheader("test_bug28075");

16284

16285

rc= mysql_dump_debug_info(mysql);

16286

DIE_UNLESS(rc == 0);

16287

16288

rc= mysql_ping(mysql);

16289

DIE_UNLESS(rc == 0);

16290

16291

DBUG_VOID_RETURN;

16292

}

16293

16294

16295

16296

Bug#27876 (SF with cyrillic variable name fails during execution (regression))

16297

16298

16299

static void test_bug27876()

16300

{

16301

int rc;

16302

MYSQL_RES *result;

16303

16304

uchar utf8_func[] =

16305

{

16306

0xd1, 0x84, 0xd1, 0x83, 0xd0, 0xbd, 0xd0, 0xba,

16307

0xd1, 0x86, 0xd0, 0xb8, 0xd0, 0xb9, 0xd0, 0xba,

16308

0xd0, 0xb0,

16309

0x00

16310

};

16311

16312

uchar utf8_param[] =

16313

{

16314

0xd0, 0xbf, 0xd0, 0xb0, 0xd1, 0x80, 0xd0, 0xb0,

16315

0xd0, 0xbc, 0xd0, 0xb5, 0xd1, 0x82, 0xd1, 0x8a,

16316

0xd1, 0x80, 0x5f, 0xd0, 0xb2, 0xd0, 0xb5, 0xd1,

16317

0x80, 0xd1, 0x81, 0xd0, 0xb8, 0xd1, 0x8f,

16318

0x00

16319

};

16320

16321

char query[500];

16322

16323

DBUG_ENTER("test_bug27876");

16324

myheader("test_bug27876");

16325

16326

rc= mysql_query(mysql, "set names utf8");

16327

myquery(rc);

16328

16329

rc= mysql_query(mysql, "select version()");

16330

myquery(rc);

16331

result= mysql_store_result(mysql);

16332

mytest(result);

16333

mysql_free_result(result);

16334

16335

sprintf(query, "DROP FUNCTION IF EXISTS %s", (char*) utf8_func);

16336

rc= mysql_query(mysql, query);

16337

myquery(rc);

16338

16339

sprintf(query,

16340

"CREATE FUNCTION %s( %s VARCHAR(25))"

16341

" RETURNS VARCHAR(25) DETERMINISTIC RETURN %s",

16342

(char*) utf8_func, (char*) utf8_param, (char*) utf8_param);

16343

rc= mysql_query(mysql, query);

16344

myquery(rc);

16345

sprintf(query, "SELECT %s(VERSION())", (char*) utf8_func);

16346

rc= mysql_query(mysql, query);

16347

myquery(rc);

16348

result= mysql_store_result(mysql);

16349

mytest(result);

16350

mysql_free_result(result);

16351

16352

sprintf(query, "DROP FUNCTION %s", (char*) utf8_func);

16353

rc= mysql_query(mysql, query);

16354

myquery(rc);

16355

16356

rc= mysql_query(mysql, "set names default");

16357

myquery(rc);

16358

}

16359

16360

16361

16362

Bug#28505: mysql_affected_rows() returns wrong value if CLIENT_FOUND_ROWS

16363

flag is set.

16364

16365

16366

static void test_bug28505()

16367

{

16368

my_ulonglong res;

16369

16370

myquery(mysql_query(mysql, "drop table if exists t1"));

16371

myquery(mysql_query(mysql, "create table t1(f1 int primary key)"));

16372

myquery(mysql_query(mysql, "insert into t1 values(1)"));

16373

myquery(mysql_query(mysql,

16374

"insert into t1 values(1) on duplicate key update f1=1"));

16375

res= mysql_affected_rows(mysql);

16376

DIE_UNLESS(!res);

16377

myquery(mysql_query(mysql, "drop table t1"));

16378

}

16379

16380

16381

16382

Bug#28934: server crash when receiving malformed com_execute packets

16383

16384

16385

static void test_bug28934()

16386

{

16387

my_bool error= 0;

16388

MYSQL_BIND bind[5];

16389

MYSQL_STMT *stmt;

16390

int cnt;

16391

16392

myquery(mysql_query(mysql, "drop table if exists t1"));

16393

myquery(mysql_query(mysql, "create table t1(id int)"));

16394

16395

myquery(mysql_query(mysql, "insert into t1 values(1),(2),(3),(4),(5)"));

16396

stmt= mysql_simple_prepare(mysql,"select * from t1 where id in(?,?,?,?,?)");

16397

check_stmt(stmt);

16398

16399

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

16400

for (cnt= 0; cnt < 5; cnt++)

16401

{

16402

bind[cnt].buffer_type= MYSQL_TYPE_LONG;

16403

bind[cnt].buffer= (char*)&cnt;

16404

bind[cnt].buffer_length= 0;

16405

}

16406

myquery(mysql_stmt_bind_param(stmt, bind));

16407

16408

stmt->param_count=2;

16409

error= mysql_stmt_execute(stmt);

16410

DIE_UNLESS(error != 0);

16411

myerror(NULL);

16412

mysql_stmt_close(stmt);

16413

16414

myquery(mysql_query(mysql, "drop table t1"));

16415

}

16416

16417

16418

Test mysql_change_user() C API and COM_CHANGE_USER

16419

16420

16421

static void test_change_user()

16422

{

16423

char buff[256];

16424

const char *user_pw= "mysqltest_pw";

16425

const char *user_no_pw= "mysqltest_no_pw";

16426

const char *pw= "password";

16427

const char *db= "mysqltest_user_test_database";

16428

int rc;

16429

16430

DBUG_ENTER("test_change_user");

16431

myheader("test_change_user");

16432

16433

/* Prepare environment */

16434

sprintf(buff, "drop database if exists %s", db);

16435

rc= mysql_query(mysql, buff);

16436

myquery(rc);

16437

16438

sprintf(buff, "create database %s", db);

16439

rc= mysql_query(mysql, buff);

16440

myquery(rc);

16441

16442

sprintf(buff,

16443

"grant select on %s.* to %s@'%%' identified by '%s'",

16444

db,

16445

user_pw,

16446

pw);

16447

rc= mysql_query(mysql, buff);

16448

myquery(rc);

16449

16450

sprintf(buff,

16451

"grant select on %s.* to %s@'localhost' identified by '%s'",

16452

db,

16453

user_pw,

16454

pw);

16455

rc= mysql_query(mysql, buff);

16456

myquery(rc);

16457

16458

sprintf(buff,

16459

"grant select on %s.* to %s@'%%'",

16460

db,

16461

user_no_pw);

16462

rc= mysql_query(mysql, buff);

16463

myquery(rc);

16464

16465

sprintf(buff,

16466

"grant select on %s.* to %s@'localhost'",

16467

db,

16468

user_no_pw);

16469

rc= mysql_query(mysql, buff);

16470

myquery(rc);

16471

16472

16473

/* Try some combinations */

16474

rc= mysql_change_user(mysql, NULL, NULL, NULL);

16475

DIE_UNLESS(rc);

16476

if (! opt_silent)

16477

printf("Got error (as expected): %s\n", mysql_error(mysql));

16478

16479

16480

rc= mysql_change_user(mysql, "", NULL, NULL);

16481

DIE_UNLESS(rc);

16482

if (! opt_silent)

16483

printf("Got error (as expected): %s\n", mysql_error(mysql));

16484

16485

rc= mysql_change_user(mysql, "", "", NULL);

16486

DIE_UNLESS(rc);

16487

if (! opt_silent)

16488

printf("Got error (as expected): %s\n", mysql_error(mysql));

16489

16490

rc= mysql_change_user(mysql, "", "", "");

16491

DIE_UNLESS(rc);

16492

if (! opt_silent)

16493

printf("Got error (as expected): %s\n", mysql_error(mysql));

16494

16495

rc= mysql_change_user(mysql, NULL, "", "");

16496

DIE_UNLESS(rc);

16497

if (! opt_silent)

16498

printf("Got error (as expected): %s\n", mysql_error(mysql));

16499

16500

16501

rc= mysql_change_user(mysql, NULL, NULL, "");

16502

DIE_UNLESS(rc);

16503

if (! opt_silent)

16504

printf("Got error (as expected): %s\n", mysql_error(mysql));

16505

16506

rc= mysql_change_user(mysql, "", NULL, "");

16507

DIE_UNLESS(rc);

16508

if (! opt_silent)

16509

printf("Got error (as expected): %s\n", mysql_error(mysql));

16510

16511

rc= mysql_change_user(mysql, user_pw, NULL, "");

16512

DIE_UNLESS(rc);

16513

if (! opt_silent)

16514

printf("Got error (as expected): %s\n", mysql_error(mysql));

16515

16516

rc= mysql_change_user(mysql, user_pw, "", "");

16517

DIE_UNLESS(rc);

16518

if (! opt_silent)

16519

printf("Got error (as expected): %s\n", mysql_error(mysql));

16520

16521

rc= mysql_change_user(mysql, user_pw, "", NULL);

16522

DIE_UNLESS(rc);

16523

if (! opt_silent)

16524

printf("Got error (as expected): %s\n", mysql_error(mysql));

16525

16526

rc= mysql_change_user(mysql, user_pw, NULL, NULL);

16527

DIE_UNLESS(rc);

16528

if (! opt_silent)

16529

printf("Got error (as expected): %s\n", mysql_error(mysql));

16530

16531

rc= mysql_change_user(mysql, user_pw, "", db);

16532

DIE_UNLESS(rc);

16533

if (! opt_silent)

16534

printf("Got error (as expected): %s\n", mysql_error(mysql));

16535

16536

rc= mysql_change_user(mysql, user_pw, NULL, db);

16537

DIE_UNLESS(rc);

16538

if (! opt_silent)

16539

printf("Got error (as expected): %s\n", mysql_error(mysql));

16540

16541

rc= mysql_change_user(mysql, user_pw, pw, db);

16542

myquery(rc);

16543

16544

rc= mysql_change_user(mysql, user_pw, pw, NULL);

16545

myquery(rc);

16546

16547

rc= mysql_change_user(mysql, user_pw, pw, "");

16548

myquery(rc);

16549

16550

rc= mysql_change_user(mysql, user_no_pw, pw, db);

16551

DIE_UNLESS(rc);

16552

if (! opt_silent)

16553

printf("Got error (as expected): %s\n", mysql_error(mysql));

16554

16555

rc= mysql_change_user(mysql, user_no_pw, pw, "");

16556

DIE_UNLESS(rc);

16557

if (! opt_silent)

16558

printf("Got error (as expected): %s\n", mysql_error(mysql));

16559

16560

rc= mysql_change_user(mysql, user_no_pw, pw, NULL);

16561

DIE_UNLESS(rc);

16562

if (! opt_silent)

16563

printf("Got error (as expected): %s\n", mysql_error(mysql));

16564

16565

rc= mysql_change_user(mysql, user_no_pw, "", NULL);

16566

myquery(rc);

16567

16568

rc= mysql_change_user(mysql, user_no_pw, "", "");

16569

myquery(rc);

16570

16571

rc= mysql_change_user(mysql, user_no_pw, "", db);

16572

myquery(rc);

16573

16574

rc= mysql_change_user(mysql, user_no_pw, NULL, db);

16575

myquery(rc);

16576

16577

rc= mysql_change_user(mysql, "", pw, db);

16578

DIE_UNLESS(rc);

16579

if (! opt_silent)

16580

printf("Got error (as expected): %s\n", mysql_error(mysql));

16581

16582

rc= mysql_change_user(mysql, "", pw, "");

16583

DIE_UNLESS(rc);

16584

if (! opt_silent)

16585

printf("Got error (as expected): %s\n", mysql_error(mysql));

16586

16587

rc= mysql_change_user(mysql, "", pw, NULL);

16588

DIE_UNLESS(rc);

16589

if (! opt_silent)

16590

printf("Got error (as expected): %s\n", mysql_error(mysql));

16591

16592

rc= mysql_change_user(mysql, NULL, pw, NULL);

16593

DIE_UNLESS(rc);

16594

if (! opt_silent)

16595

printf("Got error (as expected): %s\n", mysql_error(mysql));

16596

16597

rc= mysql_change_user(mysql, NULL, NULL, db);

16598

DIE_UNLESS(rc);

16599

if (! opt_silent)

16600

printf("Got error (as expected): %s\n", mysql_error(mysql));

16601

16602

rc= mysql_change_user(mysql, NULL, "", db);

16603

DIE_UNLESS(rc);

16604

if (! opt_silent)

16605

printf("Got error (as expected): %s\n", mysql_error(mysql));

16606

16607

rc= mysql_change_user(mysql, "", "", db);

16608

DIE_UNLESS(rc);

16609

if (! opt_silent)

16610

printf("Got error (as expected): %s\n", mysql_error(mysql));

16611

16612

/* Cleanup the environment */

16613

16614

mysql_change_user(mysql, opt_user, opt_password, current_db);

16615

16616

sprintf(buff, "drop database %s", db);

16617

rc= mysql_query(mysql, buff);

16618

myquery(rc);

16619

16620

sprintf(buff, "drop user %s@'%%'", user_pw);

16621

rc= mysql_query(mysql, buff);

16622

myquery(rc);

16623

16624

sprintf(buff, "drop user %s@'%%'", user_no_pw);

16625

rc= mysql_query(mysql, buff);

16626

myquery(rc);

16627

16628

sprintf(buff, "drop user %s@'localhost'", user_pw);

16629

rc= mysql_query(mysql, buff);

16630

myquery(rc);

16631

16632

sprintf(buff, "drop user %s@'localhost'", user_no_pw);

16633

rc= mysql_query(mysql, buff);

16634

myquery(rc);

16635

16636

DBUG_VOID_RETURN;

16637

}

16638

16639

16640

Bug#27592 (stack overrun when storing datetime value using prepared statements)

16641

16642

16643

static void test_bug27592()

16644

{

16645

const int NUM_ITERATIONS= 40;

16646

int i;

16647

int rc;

16648

MYSQL_STMT *stmt= NULL;

16649

MYSQL_BIND bind[1];

16650

MYSQL_TIME time_val;

16651

16652

DBUG_ENTER("test_bug27592");

16653

myheader("test_bug27592");

16654

16655

mysql_query(mysql, "DROP TABLE IF EXISTS t1");

16656

mysql_query(mysql, "CREATE TABLE t1(c2 DATETIME)");

16657

16658

stmt= mysql_simple_prepare(mysql, "INSERT INTO t1 VALUES (?)");

16659

DIE_UNLESS(stmt);

16660

16661

memset(bind, 0, sizeof(bind));

16662

16663

bind[0].buffer_type= MYSQL_TYPE_DATETIME;

16664

bind[0].buffer= (char *) &time_val;

16665

bind[0].length= NULL;

16666

16667

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

16668

{

16669

time_val.year= 2007;

16670

time_val.month= 6;

16671

time_val.day= 7;

16672

time_val.hour= 18;

16673

time_val.minute= 41;

16674

time_val.second= 3;

16675

16676

time_val.second_part=0;

16677

time_val.neg=0;

16678

16679

rc= mysql_stmt_bind_param(stmt, bind);

16680

check_execute(stmt, rc);

16681

16682

rc= mysql_stmt_execute(stmt);

16683

check_execute(stmt, rc);

16684

}

16685

16686

mysql_stmt_close(stmt);

16687

16688

DBUG_VOID_RETURN;

16689

}

16690

16691

16692

Bug#29687 mysql_stmt_store_result memory leak in libmysqld

16693

16694

16695

static void test_bug29687()

16696

{

16697

const int NUM_ITERATIONS= 40;

16698

int i;

16699

int rc;

16700

MYSQL_STMT *stmt= NULL;

16701

16702

DBUG_ENTER("test_bug29687");

16703

myheader("test_bug29687");

16704

16705

stmt= mysql_simple_prepare(mysql, "SELECT 1 FROM dual WHERE 0=2");

16706

DIE_UNLESS(stmt);

16707

16708

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

16709

{

16710

rc= mysql_stmt_execute(stmt);

16711

check_execute(stmt, rc);

16712

mysql_stmt_store_result(stmt);

16713

while (mysql_stmt_fetch(stmt)==0);

16714

mysql_stmt_free_result(stmt);

16715

}

16716

16717

mysql_stmt_close(stmt);

16718

DBUG_VOID_RETURN;

16719

}

16720

16721

16722

16723

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

16724

row insertions

16725

16726

16727

static void test_bug29692()

16728

{

16729

MYSQL* conn;

16730

16731

if (!(conn= mysql_client_init(NULL)))

16732

{

16733

myerror("test_bug29692 init failed");

16734

exit(1);

16735

}

16736

16737

if (!(mysql_real_connect(conn, opt_host, opt_user,

16738

opt_password, opt_db ? opt_db:"test", opt_port,

16739

opt_unix_socket, CLIENT_FOUND_ROWS)))

16740

{

16741

myerror("test_bug29692 connection failed");

16742

mysql_close(mysql);

16743

exit(1);

16744

}

16745

myquery(mysql_query(conn, "drop table if exists t1"));

16746

myquery(mysql_query(conn, "create table t1(f1 int)"));

16747

myquery(mysql_query(conn, "insert into t1 values(1)"));

16748

DIE_UNLESS(1 == mysql_affected_rows(conn));

16749

myquery(mysql_query(conn, "drop table t1"));

16750

mysql_close(conn);

16751

}

16752

16753

/**

16754

Bug#29306 Truncated data in MS Access with decimal (3,1) columns in a VIEW

16755

16756

16757

static void test_bug29306()

16758

{

16759

MYSQL_FIELD *field;

16760

int rc;

16761

MYSQL_RES *res;

16762

16763

DBUG_ENTER("test_bug29306");

16764

myheader("test_bug29306");

16765

16766

rc= mysql_query(mysql, "DROP TABLE IF EXISTS tab17557");

16767

myquery(rc);

16768

rc= mysql_query(mysql, "DROP VIEW IF EXISTS view17557");

16769

myquery(rc);

16770

rc= mysql_query(mysql, "CREATE TABLE tab17557 (dd decimal (3,1))");

16771

myquery(rc);

16772

rc= mysql_query(mysql, "CREATE VIEW view17557 as SELECT dd FROM tab17557");

16773

myquery(rc);

16774

rc= mysql_query(mysql, "INSERT INTO tab17557 VALUES (7.6)");

16775

myquery(rc);

16776

16777

/* Checking the view */

16778

res= mysql_list_fields(mysql, "view17557", NULL);

16779

while ((field= mysql_fetch_field(res)))

16780

{

16781

if (! opt_silent)

16782

{

16783

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

16784

printf("field table %s\n", field->table);

16785

printf("field decimals %d\n", field->decimals);

16786

if (field->decimals < 1)

16787

printf("Error! No decimals! \n");

16788

printf("\n\n");

16789

}

16790

DIE_UNLESS(field->decimals == 1);

16791

}

16792

mysql_free_result(res);

16793

16794

rc= mysql_query(mysql, "DROP TABLE tab17557");

16795

myquery(rc);

16796

rc= mysql_query(mysql, "DROP VIEW view17557");

16797

myquery(rc);

16798

16799

DBUG_VOID_RETURN;

16800

}

16801

16802

Bug#30472: libmysql doesn't reset charset, insert_id after succ.

16803

mysql_change_user() call row insertions.

16804

16805

16806

static void bug30472_retrieve_charset_info(MYSQL *con,

16807

char *character_set_name,

16808

char *character_set_client,

16809

char *character_set_results,

16810

char *collation_connection)

16811

{

16812

MYSQL_RES *rs;

16813

MYSQL_ROW row;

16814

16815

/* Get the cached client character set name. */

16816

16817

strcpy(character_set_name, mysql_character_set_name(con));

16818

16819

/* Retrieve server character set information. */

16820

16821

DIE_IF(mysql_query(con, "SHOW VARIABLES LIKE 'character_set_client'"));

16822

DIE_UNLESS(rs= mysql_store_result(con));

16823

DIE_UNLESS(row= mysql_fetch_row(rs));

16824

strcpy(character_set_client, row[1]);

16825

mysql_free_result(rs);

16826

16827

DIE_IF(mysql_query(con, "SHOW VARIABLES LIKE 'character_set_results'"));

16828

DIE_UNLESS(rs= mysql_store_result(con));

16829

DIE_UNLESS(row= mysql_fetch_row(rs));

16830

strcpy(character_set_results, row[1]);

16831

mysql_free_result(rs);

16832

16833

DIE_IF(mysql_query(con, "SHOW VARIABLES LIKE 'collation_connection'"));

16834

DIE_UNLESS(rs= mysql_store_result(con));

16835

DIE_UNLESS(row= mysql_fetch_row(rs));

16836

strcpy(collation_connection, row[1]);

16837

mysql_free_result(rs);

16838

}

16839

16840

static void test_bug30472()

16841

{

16842

MYSQL con;

16843

16844

char character_set_name_1[MY_CS_NAME_SIZE];

16845

char character_set_client_1[MY_CS_NAME_SIZE];

16846

char character_set_results_1[MY_CS_NAME_SIZE];

16847

char collation_connnection_1[MY_CS_NAME_SIZE];

16848

16849

char character_set_name_2[MY_CS_NAME_SIZE];

16850

char character_set_client_2[MY_CS_NAME_SIZE];

16851

char character_set_results_2[MY_CS_NAME_SIZE];

16852

char collation_connnection_2[MY_CS_NAME_SIZE];

16853

16854

char character_set_name_3[MY_CS_NAME_SIZE];

16855

char character_set_client_3[MY_CS_NAME_SIZE];

16856

char character_set_results_3[MY_CS_NAME_SIZE];

16857

char collation_connnection_3[MY_CS_NAME_SIZE];

16858

16859

char character_set_name_4[MY_CS_NAME_SIZE];

16860

char character_set_client_4[MY_CS_NAME_SIZE];

16861

char character_set_results_4[MY_CS_NAME_SIZE];

16862

char collation_connnection_4[MY_CS_NAME_SIZE];

16863

16864

/* Create a new connection. */

16865

16866

DIE_UNLESS(mysql_client_init(&con));

16867

16868

DIE_UNLESS(mysql_real_connect(&con,

16869

opt_host,

16870

opt_user,

16871

opt_password,

16872

opt_db ? opt_db : "test",

16873

opt_port,

16874

opt_unix_socket,

16875

CLIENT_FOUND_ROWS));

16876

16877

/* Retrieve character set information. */

16878

16879

bug30472_retrieve_charset_info(&con,

16880

character_set_name_1,

16881

character_set_client_1,

16882

character_set_results_1,

16883

collation_connnection_1);

16884

16885

/* Switch client character set. */

16886

16887

DIE_IF(mysql_set_character_set(&con, "utf8"));

16888

16889

/* Retrieve character set information. */

16890

16891

bug30472_retrieve_charset_info(&con,

16892

character_set_name_2,

16893

character_set_client_2,

16894

character_set_results_2,

16895

collation_connnection_2);

16896

16897

16898

Check that

16899

1) character set has been switched and

16900

2) new character set is different from the original one.

16901

16902

16903

DIE_UNLESS(strcmp(character_set_name_2, "utf8") == 0);

16904

DIE_UNLESS(strcmp(character_set_client_2, "utf8") == 0);

16905

DIE_UNLESS(strcmp(character_set_results_2, "utf8") == 0);

16906

DIE_UNLESS(strcmp(collation_connnection_2, "utf8_general_ci") == 0);

16907

16908

DIE_UNLESS(strcmp(character_set_name_1, character_set_name_2) != 0);

16909

DIE_UNLESS(strcmp(character_set_client_1, character_set_client_2) != 0);

16910

DIE_UNLESS(strcmp(character_set_results_1, character_set_results_2) != 0);

16911

DIE_UNLESS(strcmp(collation_connnection_1, collation_connnection_2) != 0);

16912

16913

/* Call mysql_change_user() with the same username, password, database. */

16914

16915

DIE_IF(mysql_change_user(&con,

16916

opt_user,

16917

opt_password,

16918

opt_db ? opt_db : "test"));

16919

16920

/* Retrieve character set information. */

16921

16922

bug30472_retrieve_charset_info(&con,

16923

character_set_name_3,

16924

character_set_client_3,

16925

character_set_results_3,

16926

collation_connnection_3);

16927

16928

/* Check that character set information has been reset. */

16929

16930

DIE_UNLESS(strcmp(character_set_name_1, character_set_name_3) == 0);

16931

DIE_UNLESS(strcmp(character_set_client_1, character_set_client_3) == 0);

16932

DIE_UNLESS(strcmp(character_set_results_1, character_set_results_3) == 0);

16933

DIE_UNLESS(strcmp(collation_connnection_1, collation_connnection_3) == 0);

16934

16935

/* Change connection-default character set in the client. */

16936

16937

mysql_options(&con, MYSQL_SET_CHARSET_NAME, "utf8");

16938

16939

16940

Call mysql_change_user() in order to check that new connection will

16941

have UTF8 character set on the client and on the server.

16942

16943

16944

DIE_IF(mysql_change_user(&con,

16945

opt_user,

16946

opt_password,

16947

opt_db ? opt_db : "test"));

16948

16949

/* Retrieve character set information. */

16950

16951

bug30472_retrieve_charset_info(&con,

16952

character_set_name_4,

16953

character_set_client_4,

16954

character_set_results_4,

16955

collation_connnection_4);

16956

16957

/* Check that we have UTF8 on the server and on the client. */

16958

16959

DIE_UNLESS(strcmp(character_set_name_4, "utf8") == 0);

16960

DIE_UNLESS(strcmp(character_set_client_4, "utf8") == 0);

16961

DIE_UNLESS(strcmp(character_set_results_4, "utf8") == 0);

16962

DIE_UNLESS(strcmp(collation_connnection_4, "utf8_general_ci") == 0);

16963

16964

/* That's it. Cleanup. */

16965

16966

mysql_close(&con);

16967

}

16968

16969

static void bug20023_change_user(MYSQL *con)

16970

{

16971

DIE_IF(mysql_change_user(con,

16972

opt_user,

16973

opt_password,

16974

opt_db ? opt_db : "test"));

16975

}

16976

16977

static my_bool query_str_variable(MYSQL *con,

16978

const char *var_name,

16979

char *str,

16980

size_t len)

16981

{

16982

MYSQL_RES *rs;

16983

MYSQL_ROW row;

16984

16985

char query_buffer[MAX_TEST_QUERY_LENGTH];

16986

16987

my_bool is_null;

16988

16989

my_snprintf(query_buffer, sizeof (query_buffer),

16990

"SELECT %s", var_name);

16991

16992

DIE_IF(mysql_query(con, query_buffer));

16993

DIE_UNLESS(rs= mysql_store_result(con));

16994

DIE_UNLESS(row= mysql_fetch_row(rs));

16995

16996

is_null= row[0] == NULL;

16997

16998

if (!is_null)

16999

my_snprintf(str, len, "%s", row[0]);

17000

17001

mysql_free_result(rs);

17002

17003

return is_null;

17004

}

17005

17006

static my_bool query_int_variable(MYSQL *con,

17007

const char *var_name,

17008

int *var_value)

17009

{

17010

char str[32];

17011

my_bool is_null= query_str_variable(con, var_name, str, sizeof(str));

17012

17013

if (!is_null)

17014

*var_value= atoi(str);

17015

17016

return is_null;

17017

}

17018

17019

static void test_bug20023()

17020

{

17021

MYSQL con;

17022

17023

int sql_big_selects_orig= 0;

17024

17025

Type of max_join_size is ha_rows, which might be ulong or off_t

17026

depending on the platform or configure options. Preserve the string

17027

to avoid type overflow pitfalls.

17028

17029

char max_join_size_orig[32];

17030

17031

int sql_big_selects_2= 0;

17032

int sql_big_selects_3= 0;

17033

int sql_big_selects_4= 0;

17034

int sql_big_selects_5= 0;

17035

17036

char query_buffer[MAX_TEST_QUERY_LENGTH];

17037

17038

/* Create a new connection. */

17039

17040

DIE_UNLESS(mysql_client_init(&con));

17041

17042

DIE_UNLESS(mysql_real_connect(&con,

17043

opt_host,

17044

opt_user,

17045

opt_password,

17046

opt_db ? opt_db : "test",

17047

opt_port,

17048

opt_unix_socket,

17049

CLIENT_FOUND_ROWS));

17050

17051

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

17052

Remember original SQL_BIG_SELECTS, MAX_JOIN_SIZE values.

17053

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

17054

17055

query_int_variable(&con,

17056

"@@session.sql_big_selects",

17057

&sql_big_selects_orig);

17058

17059

query_str_variable(&con,

17060

"@@global.max_join_size",

17061

max_join_size_orig,

17062

sizeof(max_join_size_orig));

17063

17064

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

17065

Test that COM_CHANGE_USER resets the SQL_BIG_SELECTS to the initial value.

17066

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

17067

17068

/* Issue COM_CHANGE_USER. */

17069

17070

bug20023_change_user(&con);

17071

17072

/* Query SQL_BIG_SELECTS. */

17073

17074

query_int_variable(&con,

17075

"@@session.sql_big_selects",

17076

&sql_big_selects_2);

17077

17078

/* Check that SQL_BIG_SELECTS is reset properly. */

17079

17080

DIE_UNLESS(sql_big_selects_orig == sql_big_selects_2);

17081

17082

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

17083

Test that if MAX_JOIN_SIZE set to non-default value,

17084

SQL_BIG_SELECTS will be 0.

17085

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

17086

17087

/* Set MAX_JOIN_SIZE to some non-default value. */

17088

17089

DIE_IF(mysql_query(&con, "SET @@global.max_join_size = 10000"));

17090

DIE_IF(mysql_query(&con, "SET @@session.max_join_size = default"));

17091

17092

/* Issue COM_CHANGE_USER. */

17093

17094

bug20023_change_user(&con);

17095

17096

/* Query SQL_BIG_SELECTS. */

17097

17098

query_int_variable(&con,

17099

"@@session.sql_big_selects",

17100

&sql_big_selects_3);

17101

17102

/* Check that SQL_BIG_SELECTS is 0. */

17103

17104

DIE_UNLESS(sql_big_selects_3 == 0);

17105

17106

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

17107

Test that if MAX_JOIN_SIZE set to default value,

17108

SQL_BIG_SELECTS will be 1.

17109

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

17110

17111

/* Set MAX_JOIN_SIZE to the default value (-1). */

17112

17113

DIE_IF(mysql_query(&con, "SET @@global.max_join_size = -1"));

17114

DIE_IF(mysql_query(&con, "SET @@session.max_join_size = default"));

17115

17116

/* Issue COM_CHANGE_USER. */

17117

17118

bug20023_change_user(&con);

17119

17120

/* Query SQL_BIG_SELECTS. */

17121

17122

query_int_variable(&con,

17123

"@@session.sql_big_selects",

17124

&sql_big_selects_4);

17125

17126

/* Check that SQL_BIG_SELECTS is 1. */

17127

17128

DIE_UNLESS(sql_big_selects_4 == 1);

17129

17130

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

17131

Restore MAX_JOIN_SIZE.

17132

Check that SQL_BIG_SELECTS will be the original one.

17133

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

17134

17135

/* Restore MAX_JOIN_SIZE. */

17136

17137

my_snprintf(query_buffer,

17138

sizeof (query_buffer),

17139

"SET @@global.max_join_size = %s",

17140

max_join_size_orig);

17141

17142

DIE_IF(mysql_query(&con, query_buffer));

17143

17144

DIE_IF(mysql_query(&con, "SET @@global.max_join_size = -1"));

17145

DIE_IF(mysql_query(&con, "SET @@session.max_join_size = default"));

17146

17147

/* Issue COM_CHANGE_USER. */

17148

17149

bug20023_change_user(&con);

17150

17151

/* Query SQL_BIG_SELECTS. */

17152

17153

query_int_variable(&con,

17154

"@@session.sql_big_selects",

17155

&sql_big_selects_5);

17156

17157

/* Check that SQL_BIG_SELECTS is 1. */

17158

17159

DIE_UNLESS(sql_big_selects_5 == sql_big_selects_orig);

17160

17161

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

17162

That's it. Cleanup.

17163

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

17164

17165

mysql_close(&con);

17166

}

17167

17168

static void bug31418_impl()

17169

{

17170

MYSQL con;

17171

17172

my_bool is_null;

17173

int rc= 0;

17174

17175

/* Create a new connection. */

17176

17177

DIE_UNLESS(mysql_client_init(&con));

17178

17179

DIE_UNLESS(mysql_real_connect(&con,

17180

opt_host,

17181

opt_user,

17182

opt_password,

17183

opt_db ? opt_db : "test",

17184

opt_port,

17185

opt_unix_socket,

17186

CLIENT_FOUND_ROWS));

17187

17188

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

17189

Check that lock is free:

17190

- IS_FREE_LOCK() should return 1;

17191

- IS_USED_LOCK() should return NULL;

17192

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

17193

17194

is_null= query_int_variable(&con,

17195

"IS_FREE_LOCK('bug31418')",

17196

&rc);

17197

DIE_UNLESS(!is_null && rc);

17198

17199

is_null= query_int_variable(&con,

17200

"IS_USED_LOCK('bug31418')",

17201

&rc);

17202

DIE_UNLESS(is_null);

17203

17204

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

17205

Acquire lock and check the lock status (the lock must be in use):

17206

- IS_FREE_LOCK() should return 0;

17207

- IS_USED_LOCK() should return non-zero thread id;

17208

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

17209

17210

query_int_variable(&con, "GET_LOCK('bug31418', 1)", &rc);

17211

DIE_UNLESS(rc);

17212

17213

is_null= query_int_variable(&con,

17214

"IS_FREE_LOCK('bug31418')",

17215

&rc);

17216

DIE_UNLESS(!is_null && !rc);

17217

17218

is_null= query_int_variable(&con,

17219

"IS_USED_LOCK('bug31418')",

17220

&rc);

17221

DIE_UNLESS(!is_null && rc);

17222

17223

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

17224

Issue COM_CHANGE_USER command and check the lock status

17225

(the lock must be free):

17226

- IS_FREE_LOCK() should return 1;

17227

- IS_USED_LOCK() should return NULL;

17228

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

17229

17230

bug20023_change_user(&con);

17231

17232

is_null= query_int_variable(&con,

17233

"IS_FREE_LOCK('bug31418')",

17234

&rc);

17235

DIE_UNLESS(!is_null && rc);

17236

17237

is_null= query_int_variable(&con,

17238

"IS_USED_LOCK('bug31418')",

17239

&rc);

17240

DIE_UNLESS(is_null);

17241

17242

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

17243

That's it. Cleanup.

17244

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

17245

17246

mysql_close(&con);

17247

}

17248

17249

static void test_bug31418()

17250

{

17251

/* Run test case for BUG#31418 for three different connections. */

17252

17253

bug31418_impl();

17254

17255

bug31418_impl();

17256

17257

bug31418_impl();

17258

}

17259

17260

17261

17262

/**

17263

Bug#31669 Buffer overflow in mysql_change_user()

17264

17265

17266

#define LARGE_BUFFER_SIZE 2048

17267

17268

static void test_bug31669()

17269

{

17270

int rc;

17271

static char buff[LARGE_BUFFER_SIZE+1];

17272

#ifndef EMBEDDED_LIBRARY

17273

static char user[USERNAME_CHAR_LENGTH+1];

17274

static char db[NAME_CHAR_LEN+1];

17275

static char query[LARGE_BUFFER_SIZE*2];

17276

#endif

17277

17278

DBUG_ENTER("test_bug31669");

17279

myheader("test_bug31669");

17280

17281

rc= mysql_change_user(mysql, NULL, NULL, NULL);

17282

DIE_UNLESS(rc);

17283

17284

rc= mysql_change_user(mysql, "", "", "");

17285

DIE_UNLESS(rc);

17286

17287

memset(buff, 'a', sizeof(buff));

17288

17289

rc= mysql_change_user(mysql, buff, buff, buff);

17290

DIE_UNLESS(rc);

17291

17292

rc = mysql_change_user(mysql, opt_user, opt_password, current_db);

17293

DIE_UNLESS(!rc);

17294

17295

#ifndef EMBEDDED_LIBRARY

17296

memset(db, 'a', sizeof(db));

17297

db[NAME_CHAR_LEN]= 0;

17298

strxmov(query, "CREATE DATABASE IF NOT EXISTS ", db, NullS);

17299

rc= mysql_query(mysql, query);

17300

myquery(rc);

17301

17302

memset(user, 'b', sizeof(user));

17303

user[USERNAME_CHAR_LENGTH]= 0;

17304

memset(buff, 'c', sizeof(buff));

17305

buff[LARGE_BUFFER_SIZE]= 0;

17306

strxmov(query, "GRANT ALL PRIVILEGES ON *.* TO '", user, "'@'%' IDENTIFIED BY "

17307

"'", buff, "' WITH GRANT OPTION", NullS);

17308

rc= mysql_query(mysql, query);

17309

myquery(rc);

17310

17311

strxmov(query, "GRANT ALL PRIVILEGES ON *.* TO '", user, "'@'localhost' IDENTIFIED BY "

17312

"'", buff, "' WITH GRANT OPTION", NullS);

17313

rc= mysql_query(mysql, query);

17314

myquery(rc);

17315

17316

rc= mysql_query(mysql, "FLUSH PRIVILEGES");

17317

myquery(rc);

17318

17319

rc= mysql_change_user(mysql, user, buff, db);

17320

DIE_UNLESS(!rc);

17321

17322

user[USERNAME_CHAR_LENGTH-1]= 'a';

17323

rc= mysql_change_user(mysql, user, buff, db);

17324

DIE_UNLESS(rc);

17325

17326

user[USERNAME_CHAR_LENGTH-1]= 'b';

17327

buff[LARGE_BUFFER_SIZE-1]= 'd';

17328

rc= mysql_change_user(mysql, user, buff, db);

17329

DIE_UNLESS(rc);

17330

17331

buff[LARGE_BUFFER_SIZE-1]= 'c';

17332

db[NAME_CHAR_LEN-1]= 'e';

17333

rc= mysql_change_user(mysql, user, buff, db);

17334

DIE_UNLESS(rc);

17335

17336

db[NAME_CHAR_LEN-1]= 'a';

17337

rc= mysql_change_user(mysql, user, buff, db);

17338

DIE_UNLESS(!rc);

17339

17340

rc= mysql_change_user(mysql, user + 1, buff + 1, db + 1);

17341

DIE_UNLESS(rc);

17342

17343

rc = mysql_change_user(mysql, opt_user, opt_password, current_db);

17344

DIE_UNLESS(!rc);

17345

17346

strxmov(query, "DROP DATABASE ", db, NullS);

17347

rc= mysql_query(mysql, query);

17348

myquery(rc);

17349

17350

strxmov(query, "DELETE FROM mysql.user WHERE User='", user, "'", NullS);

17351

rc= mysql_query(mysql, query);

17352

myquery(rc);

17353

DIE_UNLESS(mysql_affected_rows(mysql) == 2);

17354

#endif

17355

17356

DBUG_VOID_RETURN;

17357

}

17358

17359

17360

/**

17361

Bug#28386 the general log is incomplete

17362

17363

17364

static void test_bug28386()

17365

{

17366

int rc;

17367

MYSQL_STMT *stmt;

17368

MYSQL_RES *result;

17369

MYSQL_ROW row;

17370

MYSQL_BIND bind;

17371

const char hello[]= "hello world!";

17372

17373

DBUG_ENTER("test_bug28386");

17374

myheader("test_bug28386");

17375

17376

rc= mysql_query(mysql, "select @@global.log_output");

17377

myquery(rc);

17378

17379

result= mysql_store_result(mysql);

17380

DIE_UNLESS(result);

17381

17382

row= mysql_fetch_row(result);

17383

if (! strstr(row[0], "TABLE"))

17384

{

17385

mysql_free_result(result);

17386

if (! opt_silent)

17387

printf("Skipping the test since logging to tables is not enabled\n");

17388

/* Log output is not to tables */

17389

return;

17390

}

17391

mysql_free_result(result);

17392

17393

enable_general_log(1);

17394

17395

stmt= mysql_simple_prepare(mysql, "SELECT ?");

17396

check_stmt(stmt);

17397

17398

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

17399

17400

bind.buffer_type= MYSQL_TYPE_STRING;

17401

bind.buffer= (void *) hello;

17402

bind.buffer_length= sizeof(hello);

17403

17404

mysql_stmt_bind_param(stmt, &bind);

17405

mysql_stmt_send_long_data(stmt, 0, hello, sizeof(hello));

17406

17407

rc= mysql_stmt_execute(stmt);

17408

check_execute(stmt, rc);

17409

17410

rc= my_process_stmt_result(stmt);

17411

DIE_UNLESS(rc == 1);

17412

17413

rc= mysql_stmt_reset(stmt);

17414

check_execute(stmt, rc);

17415

17416

rc= mysql_stmt_close(stmt);

17417

DIE_UNLESS(!rc);

17418

17419

rc= mysql_query(mysql, "select * from mysql.general_log where "

17420

"command_type='Close stmt' or "

17421

"command_type='Reset stmt' or "

17422

"command_type='Long Data'");

17423

myquery(rc);

17424

17425

result= mysql_store_result(mysql);

17426

mytest(result);

17427

17428

DIE_UNLESS(mysql_num_rows(result) == 3);

17429

17430

mysql_free_result(result);

17431

17432

restore_general_log();

17433

17434

DBUG_VOID_RETURN;

17435

}

17436

17437

static void test_wl4166_1()

17438

{

17439

MYSQL_STMT *stmt;

17440

int int_data;

17441

char str_data[50];

17442

char tiny_data;

17443

short small_data;

17444

longlong big_data;

17445

float real_data;

17446

double double_data;

17447

ulong length[7];

17448

my_bool is_null[7];

17449

MYSQL_BIND my_bind[7];

17450

int rc;

17451

int i;

17452

17453

myheader("test_wl4166_1");

17454

17455

rc= mysql_query(mysql, "DROP TABLE IF EXISTS table_4166");

17456

myquery(rc);

17457

17458

rc= mysql_query(mysql, "CREATE TABLE table_4166(col1 tinyint NOT NULL, "

17459

"col2 varchar(15), col3 int, "

17460

"col4 smallint, col5 bigint, "

17461

"col6 float, col7 double, "

17462

"colX varchar(10) default NULL)");

17463

myquery(rc);

17464

17465

stmt= mysql_simple_prepare(mysql,

17466

"INSERT INTO table_4166(col1, col2, col3, col4, col5, col6, col7) "

17467

"VALUES(?, ?, ?, ?, ?, ?, ?)");

17468

check_stmt(stmt);

17469

17470

verify_param_count(stmt, 7);

17471

17472

bzero(my_bind, sizeof(my_bind));

17473

/* tinyint */

17474

my_bind[0].buffer_type= MYSQL_TYPE_TINY;

17475

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

17476

/* string */

17477

my_bind[1].buffer_type= MYSQL_TYPE_STRING;

17478

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

17479

my_bind[1].buffer_length= 1000; /* Max string length */

17480

/* integer */

17481

my_bind[2].buffer_type= MYSQL_TYPE_LONG;

17482

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

17483

/* short */

17484

my_bind[3].buffer_type= MYSQL_TYPE_SHORT;

17485

my_bind[3].buffer= (void *)&small_data;

17486

/* bigint */

17487

my_bind[4].buffer_type= MYSQL_TYPE_LONGLONG;

17488

my_bind[4].buffer= (void *)&big_data;

17489

/* float */

17490

my_bind[5].buffer_type= MYSQL_TYPE_FLOAT;

17491

my_bind[5].buffer= (void *)&real_data;

17492

/* double */

17493

my_bind[6].buffer_type= MYSQL_TYPE_DOUBLE;

17494

my_bind[6].buffer= (void *)&double_data;

17495

17496

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

17497

{

17498

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

17499

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

17500

is_null[i]= 0;

17501

}

17502

17503

rc= mysql_stmt_bind_param(stmt, my_bind);

17504

check_execute(stmt, rc);

17505

17506

int_data= 320;

17507

small_data= 1867;

17508

big_data= 1000;

17509

real_data= 2;

17510

double_data= 6578.001;

17511

17512

/* now, execute the prepared statement to insert 10 records.. */

17513

for (tiny_data= 0; tiny_data < 10; tiny_data++)

17514

{

17515

length[1]= my_sprintf(str_data, (str_data, "MySQL%d", int_data));

17516

rc= mysql_stmt_execute(stmt);

17517

check_execute(stmt, rc);

17518

int_data += 25;

17519

small_data += 10;

17520

big_data += 100;

17521

real_data += 1;

17522

double_data += 10.09;

17523

}

17524

17525

/* force a re-prepare with some DDL */

17526

17527

rc= mysql_query(mysql,

17528

"ALTER TABLE table_4166 change colX colX varchar(20) default NULL");

17529

myquery(rc);

17530

17531

17532

execute the prepared statement again,

17533

without changing the types of parameters already bound.

17534

17535

17536

for (tiny_data= 50; tiny_data < 60; tiny_data++)

17537

{

17538

length[1]= my_sprintf(str_data, (str_data, "MySQL%d", int_data));

17539

rc= mysql_stmt_execute(stmt);

17540

check_execute(stmt, rc);

17541

int_data += 25;

17542

small_data += 10;

17543

big_data += 100;

17544

real_data += 1;

17545

double_data += 10.09;

17546

}

17547

17548

mysql_stmt_close(stmt);

17549

17550

rc= mysql_query(mysql, "DROP TABLE table_4166");

17551

myquery(rc);

17552

}

17553

17554

17555

static void test_wl4166_2()

17556

{

17557

MYSQL_STMT *stmt;

17558

int c_int;

17559

MYSQL_TIME d_date;

17560

MYSQL_BIND bind_out[2];

17561

int rc;

17562

17563

myheader("test_wl4166_2");

17564

17565

rc= mysql_query(mysql, "SET SQL_MODE=''");

17566

myquery(rc);

17567

17568

rc= mysql_query(mysql, "drop table if exists t1");

17569

myquery(rc);

17570

rc= mysql_query(mysql, "create table t1 (c_int int, d_date date)");

17571

myquery(rc);

17572

rc= mysql_query(mysql,

17573

"insert into t1 (c_int, d_date) values (42, '1948-05-15')");

17574

myquery(rc);

17575

17576

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

17577

check_stmt(stmt);

17578

17579

bzero(bind_out, sizeof(bind_out));

17580

bind_out[0].buffer_type= MYSQL_TYPE_LONG;

17581

bind_out[0].buffer= (void*) &c_int;

17582

17583

bind_out[1].buffer_type= MYSQL_TYPE_DATE;

17584

bind_out[1].buffer= (void*) &d_date;

17585

17586

rc= mysql_stmt_bind_result(stmt, bind_out);

17587

check_execute(stmt, rc);

17588

17589

/* int -> varchar transition */

17590

17591

rc= mysql_query(mysql,

17592

"alter table t1 change column c_int c_int varchar(11)");

17593

myquery(rc);

17594

17595

rc= mysql_stmt_execute(stmt);

17596

check_execute(stmt, rc);

17597

17598

rc= mysql_stmt_fetch(stmt);

17599

check_execute(stmt, rc);

17600

17601

DIE_UNLESS(c_int == 42);

17602

DIE_UNLESS(d_date.year == 1948);

17603

DIE_UNLESS(d_date.month == 5);

17604

DIE_UNLESS(d_date.day == 15);

17605

17606

rc= mysql_stmt_fetch(stmt);

17607

DIE_UNLESS(rc == MYSQL_NO_DATA);

17608

17609

/* varchar to int retrieval with truncation */

17610

17611

rc= mysql_query(mysql, "update t1 set c_int='abcde'");

17612

myquery(rc);

17613

17614

rc= mysql_stmt_execute(stmt);

17615

check_execute(stmt, rc);

17616

17617

rc= mysql_stmt_fetch(stmt);

17618

check_execute_r(stmt, rc);

17619

17620

DIE_UNLESS(c_int == 0);

17621

17622

rc= mysql_stmt_fetch(stmt);

17623

DIE_UNLESS(rc == MYSQL_NO_DATA);

17624

17625

/* alter table and increase the number of columns */

17626

rc= mysql_query(mysql, "alter table t1 add column d_int int");

17627

myquery(rc);

17628

17629

rc= mysql_stmt_execute(stmt);

17630

check_execute_r(stmt, rc);

17631

17632

rc= mysql_stmt_reset(stmt);

17633

check_execute(stmt, rc);

17634

17635

/* decrease the number of columns */

17636

rc= mysql_query(mysql, "alter table t1 drop d_date, drop d_int");

17637

myquery(rc);

17638

17639

rc= mysql_stmt_execute(stmt);

17640

check_execute_r(stmt, rc);

17641

17642

mysql_stmt_close(stmt);

17643

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

17644

myquery(rc);

17645

17646

}

17647

17648

/**

17649

Bug#38486 Crash when using cursor protocol

17650

17651

17652

static void test_bug38486(void)

17653

{

17654

MYSQL_STMT *stmt;

17655

const char *stmt_text;

17656

unsigned long type= CURSOR_TYPE_READ_ONLY;

17657

17658

DBUG_ENTER("test_bug38486");

17659

myheader("test_bug38486");

17660

17661

stmt= mysql_stmt_init(mysql);

17662

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

17663

stmt_text= "CREATE TABLE t1 (a INT)";

17664

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

17665

mysql_stmt_execute(stmt);

17666

mysql_stmt_close(stmt);

17667

17668

stmt= mysql_stmt_init(mysql);

17669

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

17670

stmt_text= "INSERT INTO t1 VALUES (1)";

17671

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

17672

mysql_stmt_execute(stmt);

17673

mysql_stmt_close(stmt);

17674

17675

DBUG_VOID_RETURN;

17676

}

17677

17678

static void test_bug40365(void)

17679

{

17680

uint rc, i;

17681

MYSQL_STMT *stmt= 0;

17682

MYSQL_BIND my_bind[2];

17683

my_bool is_null[2]= {0};

17684

MYSQL_TIME tm[2];

17685

17686

DBUG_ENTER("test_bug40365");

17687

17688

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

17689

myquery(rc);

17690

rc= mysql_query(mysql, "CREATE TABLE t1(c1 DATETIME, \

17691

c2 DATE)");

17692

myquery(rc);

17693

17694

stmt= mysql_simple_prepare(mysql, "INSERT INTO t1 VALUES(?, ?)");

17695

check_stmt(stmt);

17696

verify_param_count(stmt, 2);

17697

17698

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

17699

my_bind[0].buffer_type= MYSQL_TYPE_DATETIME;

17700

my_bind[1].buffer_type= MYSQL_TYPE_DATE;

17701

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

17702

{

17703

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

17704

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

17705

}

17706

17707

rc= mysql_stmt_bind_param(stmt, my_bind);

17708

check_execute(stmt, rc);

17709

17710

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

17711

{

17712

tm[i].neg= 0;

17713

tm[i].second_part= 0;

17714

tm[i].year= 2009;

17715

tm[i].month= 2;

17716

tm[i].day= 29;

17717

tm[i].hour= 0;

17718

tm[i].minute= 0;

17719

tm[i].second= 0;

17720

}

17721

rc= mysql_stmt_execute(stmt);

17722

check_execute(stmt, rc);

17723

17724

rc= mysql_commit(mysql);

17725

myquery(rc);

17726

mysql_stmt_close(stmt);

17727

17728

stmt= mysql_simple_prepare(mysql, "SELECT * FROM t1");

17729

check_stmt(stmt);

17730

17731

rc= mysql_stmt_bind_result(stmt, my_bind);

17732

check_execute(stmt, rc);

17733

17734

rc= mysql_stmt_execute(stmt);

17735

check_execute(stmt, rc);

17736

17737

rc= mysql_stmt_store_result(stmt);

17738

check_execute(stmt, rc);

17739

17740

rc= mysql_stmt_fetch(stmt);

17741

check_execute(stmt, rc);

17742

17743

if (!opt_silent)

17744

fprintf(stdout, "\n");

17745

17746

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

17747

{

17748

if (!opt_silent)

17749

fprintf(stdout, "\ntime[%d]: %02d-%02d-%02d ",

17750

i, tm[i].year, tm[i].month, tm[i].day);

17751

DIE_UNLESS(tm[i].year == 0);

17752

DIE_UNLESS(tm[i].month == 0);

17753

DIE_UNLESS(tm[i].day == 0);

17754

}

17755

mysql_stmt_close(stmt);

17756

17757

DBUG_VOID_RETURN;

17758

}

17759

17760

17761

/**

17762

Subtest for Bug#43560. Verifies that a loss of connection on the server side

17763

is handled well by the mysql_stmt_execute() call, i.e., no SIGSEGV due to

17764

a vio socket that is cleared upon closed connection.

17765

17766

Assumes the presence of the close_conn_after_stmt_execute debug feature in

17767

the server. Verifies that it is connected to a debug server before proceeding

17768

with the test.

17769

17770

static void test_bug43560(void)

17771

{

17772

MYSQL* conn;

17773

uint rc;

17774

MYSQL_STMT *stmt= 0;

17775

MYSQL_BIND bind;

17776

my_bool is_null= 0;

17777

char buffer[256];

17778

const uint BUFSIZE= sizeof(buffer);

17779

const char* values[] = {"eins", "zwei", "drei", "viele", NULL};

17780

const char insert_str[] = "INSERT INTO t1 (c2) VALUES (?)";

17781

unsigned long length;

17782

17783

DBUG_ENTER("test_bug43560");

17784

myheader("test_bug43560");

17785

17786

/* Make sure we only run against a debug server. */

17787

if (!strstr(mysql->server_version, "debug"))

17788

{

17789

fprintf(stdout, "Skipping test_bug43560: server not DEBUG version\n");

17790

DBUG_VOID_RETURN;

17791

}

17792

17793

17794

Set up a separate connection for this test to avoid messing up the

17795

general MYSQL object used in other subtests. Use TCP protocol to avoid

17796

problems with the buffer semantics of AF_UNIX, and turn off auto reconnect.

17797

17798

conn= client_connect(0, MYSQL_PROTOCOL_TCP, 0);

17799

17800

rc= mysql_query(conn, "DROP TABLE IF EXISTS t1");

17801

myquery(rc);

17802

rc= mysql_query(conn,

17803

"CREATE TABLE t1 (c1 INT PRIMARY KEY AUTO_INCREMENT, c2 CHAR(10))");

17804

myquery(rc);

17805

17806

stmt= mysql_stmt_init(conn);

17807

check_stmt(stmt);

17808

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

17809

check_execute(stmt, rc);

17810

17811

bind.buffer_type= MYSQL_TYPE_STRING;

17812

bind.buffer_length= BUFSIZE;

17813

bind.buffer= buffer;

17814

bind.is_null= &is_null;

17815

bind.length= &length;

17816

rc= mysql_stmt_bind_param(stmt, &bind);

17817

check_execute(stmt, rc);

17818

17819

/* First execute; should succeed. */

17820

strncpy(buffer, values[0], BUFSIZE);

17821

length= strlen(buffer);

17822

rc= mysql_stmt_execute(stmt);

17823

check_execute(stmt, rc);

17824

17825

17826

Set up the server to close this session's server-side socket after

17827

next execution of prep statement.

17828

17829

rc= mysql_query(conn,"SET SESSION debug='+d,close_conn_after_stmt_execute'");

17830

myquery(rc);

17831

17832

/* Second execute; should fail due to socket closed during execution. */

17833

strncpy(buffer, values[1], BUFSIZE);

17834

length= strlen(buffer);

17835

rc= mysql_stmt_execute(stmt);

17836

DIE_UNLESS(rc && mysql_stmt_errno(stmt) == CR_SERVER_LOST);

17837

17838

17839

Third execute; should fail (connection already closed), or SIGSEGV in

17840

case of a Bug#43560 type regression in which case the whole test fails.

17841

17842

strncpy(buffer, values[2], BUFSIZE);

17843

length= strlen(buffer);

17844

rc= mysql_stmt_execute(stmt);

17845

DIE_UNLESS(rc && mysql_stmt_errno(stmt) == CR_SERVER_LOST);

17846

17847

client_disconnect(conn, 0);

17848

rc= mysql_query(mysql, "DROP TABLE t1");

17849

myquery(rc);

17850

17851

DBUG_VOID_RETURN;

17852

}

17853

17854

17855

/**

17856

Bug#36326: nested transaction and select

17857

17858

17859

#ifdef HAVE_QUERY_CACHE

17860

17861

static void test_bug36326()

17862

{

17863

int rc;

17864

17865

DBUG_ENTER("test_bug36326");

17866

myheader("test_bug36326");

17867

17868

rc= mysql_autocommit(mysql, TRUE);

17869

myquery(rc);

17870

rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");

17871

myquery(rc);

17872

rc= mysql_query(mysql, "CREATE TABLE t1 (a INTEGER)");

17873

myquery(rc);

17874

rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1)");

17875

myquery(rc);

17876

rc= mysql_query(mysql, "SET GLOBAL query_cache_type = 1");

17877

myquery(rc);

17878

rc= mysql_query(mysql, "SET GLOBAL query_cache_size = 1048576");

17879

myquery(rc);

17880

DIE_UNLESS(!(mysql->server_status & SERVER_STATUS_IN_TRANS));

17881

DIE_UNLESS(mysql->server_status & SERVER_STATUS_AUTOCOMMIT);

17882

rc= mysql_query(mysql, "BEGIN");

17883

myquery(rc);

17884

DIE_UNLESS(mysql->server_status & SERVER_STATUS_IN_TRANS);

17885

rc= mysql_query(mysql, "SELECT * FROM t1");

17886

myquery(rc);

17887

rc= my_process_result(mysql);

17888

DIE_UNLESS(rc == 1);

17889

rc= mysql_rollback(mysql);

17890

myquery(rc);

17891

rc= mysql_query(mysql, "ROLLBACK");

17892

myquery(rc);

17893

DIE_UNLESS(!(mysql->server_status & SERVER_STATUS_IN_TRANS));

17894

rc= mysql_query(mysql, "SELECT * FROM t1");

17895

myquery(rc);

17896

DIE_UNLESS(!(mysql->server_status & SERVER_STATUS_IN_TRANS));

17897

rc= my_process_result(mysql);

17898

DIE_UNLESS(rc == 1);

17899

rc= mysql_query(mysql, "DROP TABLE t1");

17900

myquery(rc);

17901

rc= mysql_query(mysql, "SET GLOBAL query_cache_size = 0");

17902

myquery(rc);

17903

17904

DBUG_VOID_RETURN;

17905

}

17906

17907

#endif

17908

17909

/**

17910

Bug#41078: With CURSOR_TYPE_READ_ONLY mysql_stmt_fetch() returns short

17911

string value.

17912

17913

17914

static void test_bug41078(void)

17915

{

17916

uint rc;

17917

MYSQL_STMT *stmt= 0;

17918

MYSQL_BIND param, result;

17919

ulong cursor_type= CURSOR_TYPE_READ_ONLY;

17920

ulong len;

17921

char str[64];

17922

const char param_str[]= "abcdefghijklmn";

17923

my_bool is_null, error;

17924

17925

DBUG_ENTER("test_bug41078");

17926

17927

rc= mysql_query(mysql, "SET NAMES UTF8");

17928

myquery(rc);

17929

17930

stmt= mysql_simple_prepare(mysql, "SELECT ?");

17931

check_stmt(stmt);

17932

verify_param_count(stmt, 1);

17933

17934

rc= mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, &cursor_type);

17935

check_execute(stmt, rc);

17936

17937

bzero(&param, sizeof(param));

17938

param.buffer_type= MYSQL_TYPE_STRING;

17939

param.buffer= (void *) param_str;

17940

len= sizeof(param_str) - 1;

17941

param.length= &len;

17942

17943

rc= mysql_stmt_bind_param(stmt, &param);

17944

check_execute(stmt, rc);

17945

17946

rc= mysql_stmt_execute(stmt);

17947

check_execute(stmt, rc);

17948

17949

bzero(&result, sizeof(result));

17950

result.buffer_type= MYSQL_TYPE_STRING;

17951

result.buffer= str;

17952

result.buffer_length= sizeof(str);

17953

result.is_null= &is_null;

17954

result.length= &len;

17955

result.error= &error;

17956

17957

rc= mysql_stmt_bind_result(stmt, &result);

17958

check_execute(stmt, rc);

17959

17960

rc= mysql_stmt_store_result(stmt);

17961

check_execute(stmt, rc);

17962

17963

rc= mysql_stmt_fetch(stmt);

17964

check_execute(stmt, rc);

17965

17966

DIE_UNLESS(len == sizeof(param_str) - 1 && !strcmp(str, param_str));

17967

17968

mysql_stmt_close(stmt);

17969

17970

DBUG_VOID_RETURN;

17971

}

17972

17973

/**

17974

Bug#45010: invalid memory reads during parsing some strange statements

17975

17976

static void test_bug45010()

17977

{

17978

int rc;

17979

const char query1[]= "select a.\x80",

17980

query2[]= "describe `table\xef";

17981

17982

DBUG_ENTER("test_bug45010");

17983

myheader("test_bug45010");

17984

17985

rc= mysql_query(mysql, "set names utf8");

17986

myquery(rc);

17987

17988

/* \x80 (-128) could be used as a index of ident_map. */

17989

rc= mysql_real_query(mysql, query1, sizeof(query1) - 1);

17990

DIE_UNLESS(rc);

17991

17992

/* \xef (-17) could be used to skip 3 bytes past the buffer end. */

17993

rc= mysql_real_query(mysql, query2, sizeof(query2) - 1);

17994

DIE_UNLESS(rc);

17995

17996

rc= mysql_query(mysql, "set names default");

17997

myquery(rc);

17998

17999

DBUG_VOID_RETURN;

18000

}

18001

18002

/**

18003

Bug#44495: Prepared Statement:

18004

CALL p(<x>) - `thd->protocol == &thd->protocol_text' failed

18005

18006

18007

static void test_bug44495()

18008

{

18009

int rc;

18010

MYSQL con;

18011

MYSQL_STMT *stmt;

18012

18013

DBUG_ENTER("test_bug44495");

18014

myheader("test_44495");

18015

18016

rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");

18017

myquery(rc);

18018

18019

rc= mysql_query(mysql, "CREATE PROCEDURE p1(IN arg VARCHAR(25))"

18020

" BEGIN SET @stmt = CONCAT('SELECT \"', arg, '\"');"

18021

" PREPARE ps1 FROM @stmt;"

18022

" EXECUTE ps1;"

18023

" DROP PREPARE ps1;"

18024

"END;");

18025

myquery(rc);

18026

18027

DIE_UNLESS(mysql_client_init(&con));

18028

18029

DIE_UNLESS(mysql_real_connect(&con, opt_host, opt_user, opt_password,

18030

current_db, opt_port, opt_unix_socket,

18031

CLIENT_MULTI_RESULTS));

18032

18033

stmt= mysql_simple_prepare(&con, "CALL p1('abc')");

18034

check_stmt(stmt);

18035

18036

rc= mysql_stmt_execute(stmt);

18037

check_execute(stmt, rc);

18038

18039

rc= my_process_stmt_result(stmt);

18040

DIE_UNLESS(rc == 1);

18041

18042

mysql_stmt_close(stmt);

18043

18044

mysql_close(&con);

18045

18046

rc= mysql_query(mysql, "DROP PROCEDURE p1");

18047

myquery(rc);

18048

18049

DBUG_VOID_RETURN;

18050

}

18051

18052

18053

Read and parse arguments and MySQL options from my.cnf

18054

18055

18056

static const char *client_test_load_default_groups[]= { "client", 0 };

18057

static char **defaults_argv;

18058

18059

static struct my_option client_test_long_options[] =

18060

{

18061

{"basedir", 'b', "Basedir for tests.", (uchar**) &opt_basedir,

18062

(uchar**) &opt_basedir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

18063

{"count", 't', "Number of times test to be executed", (uchar **) &opt_count,

18064

(uchar **) &opt_count, 0, GET_UINT, REQUIRED_ARG, 1, 0, 0, 0, 0, 0},

18065

{"database", 'D', "Database to use", (uchar **) &opt_db, (uchar **) &opt_db,

18066

0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

18067

{"debug", '#', "Output debug log", (uchar**) &default_dbug_option,

18068

(uchar**) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

18069

{"help", '?', "Display this help and exit", 0, 0, 0, GET_NO_ARG, NO_ARG, 0,

18070

0, 0, 0, 0, 0},

18071

{"host", 'h', "Connect to host", (uchar **) &opt_host, (uchar **) &opt_host,

18072

0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

18073

{"password", 'p',

18074

"Password to use when connecting to server. If password is not given it's asked from the tty.",

18075

0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

18076

{"port", 'P', "Port number to use for connection or 0 for default to, in "

18077

"order of preference, my.cnf, $MYSQL_TCP_PORT, "

18078

#if MYSQL_PORT_DEFAULT == 0

18079

"/etc/services, "

18080

#endif

18081

"built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",

18082

(uchar **) &opt_port,

18083

(uchar **) &opt_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

18084

{"server-arg", 'A', "Send embedded server this as a parameter.",

18085

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

18086

{"show-tests", 'T', "Show all tests' names", 0, 0, 0, GET_NO_ARG, NO_ARG,

18087

0, 0, 0, 0, 0, 0},

18088

{"silent", 's', "Be more silent", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0,

18089

0},

18090

#ifdef HAVE_SMEM

18091

{"shared-memory-base-name", 'm', "Base name of shared memory.",

18092

(uchar**) &shared_memory_base_name, (uchar**)&shared_memory_base_name, 0,

18093

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

18094

#endif

18095

{"socket", 'S', "Socket file to use for connection",

18096

(uchar **) &opt_unix_socket, (uchar **) &opt_unix_socket, 0, GET_STR,

18097

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

18098

{"testcase", 'c',

18099

"May disable some code when runs as mysql-test-run testcase.",

18100

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

18101

#ifndef DONT_ALLOW_USER_CHANGE

18102

{"user", 'u', "User for login if not current user", (uchar **) &opt_user,

18103

(uchar **) &opt_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

18104

#endif

18105

{"vardir", 'v', "Data dir for tests.", (uchar**) &opt_vardir,

18106

(uchar**) &opt_vardir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

18107

{"getopt-ll-test", 'g', "Option for testing bug in getopt library",

18108

(uchar **) &opt_getopt_ll_test, (uchar **) &opt_getopt_ll_test, 0,

18109

GET_LL, REQUIRED_ARG, 0, 0, LONGLONG_MAX, 0, 0, 0},

18110

{ 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}

18111

};

18112

18113

18114

static void usage(void)

18115

{

18116

/* show the usage string when the user asks for this */

18117

putc('\n', stdout);

18118

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

18119

my_progname, VER, MYSQL_SERVER_VERSION, SYSTEM_TYPE, MACHINE_TYPE);

18120

puts("By Monty, Venu, Kent and others\n");

18121

printf("\

18122

18123

This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\

18124

and you are welcome to modify and redistribute it under the GPL license\n");

18125

printf("Usage: %s [OPTIONS] [TESTNAME1 TESTNAME2...]\n", my_progname);

18126

my_print_help(client_test_long_options);

18127

print_defaults("my", client_test_load_default_groups);

18128

my_print_variables(client_test_long_options);

18129

}

18130

18131

18132

static struct my_tests_st my_tests[]= {

18133

{ "disable_general_log", disable_general_log },

18134

{ "test_view_sp_list_fields", test_view_sp_list_fields },

18135

{ "client_query", client_query },

18136

{ "test_prepare_insert_update", test_prepare_insert_update},

18137

#if NOT_YET_WORKING

18138

{ "test_drop_temp", test_drop_temp },

18139

#endif

18140

{ "test_fetch_seek", test_fetch_seek },

18141

{ "test_fetch_nobuffs", test_fetch_nobuffs },

18142

{ "test_open_direct", test_open_direct },

18143

{ "test_fetch_null", test_fetch_null },

18144

{ "test_ps_null_param", test_ps_null_param },

18145

{ "test_fetch_date", test_fetch_date },

18146

{ "test_fetch_str", test_fetch_str },

18147

{ "test_fetch_long", test_fetch_long },

18148

{ "test_fetch_short", test_fetch_short },

18149

{ "test_fetch_tiny", test_fetch_tiny },

18150

{ "test_fetch_bigint", test_fetch_bigint },

18151

{ "test_fetch_float", test_fetch_float },

18152

{ "test_fetch_double", test_fetch_double },

18153

{ "test_bind_result_ext", test_bind_result_ext },

18154

{ "test_bind_result_ext1", test_bind_result_ext1 },

18155

{ "test_select_direct", test_select_direct },

18156

{ "test_select_prepare", test_select_prepare },

18157

{ "test_select", test_select },

18158

{ "test_select_version", test_select_version },

18159

{ "test_ps_conj_select", test_ps_conj_select },

18160

{ "test_select_show_table", test_select_show_table },

18161

{ "test_func_fields", test_func_fields },

18162

{ "test_long_data", test_long_data },

18163

{ "test_insert", test_insert },

18164

{ "test_set_variable", test_set_variable },

18165

{ "test_select_show", test_select_show },

18166

{ "test_prepare_noparam", test_prepare_noparam },

18167

{ "test_bind_result", test_bind_result },

18168

{ "test_prepare_simple", test_prepare_simple },

18169

{ "test_prepare", test_prepare },

18170

{ "test_null", test_null },

18171

{ "test_debug_example", test_debug_example },

18172

{ "test_update", test_update },

18173

{ "test_simple_update", test_simple_update },

18174

{ "test_simple_delete", test_simple_delete },

18175

{ "test_double_compare", test_double_compare },

18176

{ "client_store_result", client_store_result },

18177

{ "client_use_result", client_use_result },

18178

{ "test_tran_bdb", test_tran_bdb },

18179

{ "test_tran_innodb", test_tran_innodb },

18180

{ "test_prepare_ext", test_prepare_ext },

18181

{ "test_prepare_syntax", test_prepare_syntax },

18182

{ "test_field_names", test_field_names },

18183

{ "test_field_flags", test_field_flags },

18184

{ "test_long_data_str", test_long_data_str },

18185

{ "test_long_data_str1", test_long_data_str1 },

18186

{ "test_long_data_bin", test_long_data_bin },

18187

{ "test_warnings", test_warnings },

18188

{ "test_errors", test_errors },

18189

{ "test_prepare_resultset", test_prepare_resultset },

18190

{ "test_stmt_close", test_stmt_close },

18191

{ "test_prepare_field_result", test_prepare_field_result },

18192

{ "test_multi_stmt", test_multi_stmt },

18193

{ "test_multi_statements", test_multi_statements },

18194

{ "test_prepare_multi_statements", test_prepare_multi_statements },

18195

{ "test_store_result", test_store_result },

18196

{ "test_store_result1", test_store_result1 },

18197

{ "test_store_result2", test_store_result2 },

18198

{ "test_subselect", test_subselect },

18199

{ "test_date", test_date },

18200

{ "test_date_date", test_date_date },

18201

{ "test_date_time", test_date_time },

18202

{ "test_date_ts", test_date_ts },

18203

{ "test_date_dt", test_date_dt },

18204

{ "test_prepare_alter", test_prepare_alter },

18205

{ "test_manual_sample", test_manual_sample },

18206

{ "test_pure_coverage", test_pure_coverage },

18207

{ "test_buffers", test_buffers },

18208

{ "test_ushort_bug", test_ushort_bug },

18209

{ "test_sshort_bug", test_sshort_bug },

18210

{ "test_stiny_bug", test_stiny_bug },

18211

{ "test_field_misc", test_field_misc },

18212

{ "test_set_option", test_set_option },

18213

#ifndef EMBEDDED_LIBRARY

18214

{ "test_prepare_grant", test_prepare_grant },

18215

#endif

18216

{ "test_frm_bug", test_frm_bug },

18217

{ "test_explain_bug", test_explain_bug },

18218

{ "test_decimal_bug", test_decimal_bug },

18219

{ "test_nstmts", test_nstmts },

18220

{ "test_logs;", test_logs },

18221

{ "test_cuted_rows", test_cuted_rows },

18222

{ "test_fetch_offset", test_fetch_offset },

18223

{ "test_fetch_column", test_fetch_column },

18224

{ "test_mem_overun", test_mem_overun },

18225

{ "test_list_fields", test_list_fields },

18226

{ "test_free_result", test_free_result },

18227

{ "test_free_store_result", test_free_store_result },

18228

{ "test_sqlmode", test_sqlmode },

18229

{ "test_ts", test_ts },

18230

{ "test_bug1115", test_bug1115 },

18231

{ "test_bug1180", test_bug1180 },

18232

{ "test_bug1500", test_bug1500 },

18233

{ "test_bug1644", test_bug1644 },

18234

{ "test_bug1946", test_bug1946 },

18235

{ "test_bug2248", test_bug2248 },

18236

{ "test_parse_error_and_bad_length", test_parse_error_and_bad_length },

18237

{ "test_bug2247", test_bug2247 },

18238

{ "test_subqueries", test_subqueries },

18239

{ "test_bad_union", test_bad_union },

18240

{ "test_distinct", test_distinct },

18241

{ "test_subqueries_ref", test_subqueries_ref },

18242

{ "test_union", test_union },

18243

{ "test_bug3117", test_bug3117 },

18244

{ "test_join", test_join },

18245

{ "test_selecttmp", test_selecttmp },

18246

{ "test_create_drop", test_create_drop },

18247

{ "test_rename", test_rename },

18248

{ "test_do_set", test_do_set },

18249

{ "test_multi", test_multi },

18250

{ "test_insert_select", test_insert_select },

18251

{ "test_bind_nagative", test_bind_nagative },

18252

{ "test_derived", test_derived },

18253

{ "test_xjoin", test_xjoin },

18254

{ "test_bug3035", test_bug3035 },

18255

{ "test_union2", test_union2 },

18256

{ "test_bug1664", test_bug1664 },

18257

{ "test_union_param", test_union_param },

18258

{ "test_order_param", test_order_param },

18259

{ "test_ps_i18n", test_ps_i18n },

18260

{ "test_bug3796", test_bug3796 },

18261

{ "test_bug4026", test_bug4026 },

18262

{ "test_bug4079", test_bug4079 },

18263

{ "test_bug4236", test_bug4236 },

18264

{ "test_bug4030", test_bug4030 },

18265

{ "test_bug5126", test_bug5126 },

18266

{ "test_bug4231", test_bug4231 },

18267

{ "test_bug5399", test_bug5399 },

18268

{ "test_bug5194", test_bug5194 },

18269

{ "test_bug5315", test_bug5315 },

18270

{ "test_bug6049", test_bug6049 },

18271

{ "test_bug6058", test_bug6058 },

18272

{ "test_bug6059", test_bug6059 },

18273

{ "test_bug6046", test_bug6046 },

18274

{ "test_bug6081", test_bug6081 },

18275

{ "test_bug6096", test_bug6096 },

18276

{ "test_datetime_ranges", test_datetime_ranges },

18277

{ "test_bug4172", test_bug4172 },

18278

{ "test_conversion", test_conversion },

18279

{ "test_rewind", test_rewind },

18280

{ "test_bug6761", test_bug6761 },

18281

{ "test_view", test_view },

18282

{ "test_view_where", test_view_where },

18283

{ "test_view_2where", test_view_2where },

18284

{ "test_view_star", test_view_star },

18285

{ "test_view_insert", test_view_insert },

18286

{ "test_left_join_view", test_left_join_view },

18287

{ "test_view_insert_fields", test_view_insert_fields },

18288

{ "test_basic_cursors", test_basic_cursors },

18289

{ "test_cursors_with_union", test_cursors_with_union },

18290

{ "test_cursors_with_procedure", test_cursors_with_procedure },

18291

{ "test_truncation", test_truncation },

18292

{ "test_truncation_option", test_truncation_option },

18293

{ "test_client_character_set", test_client_character_set },

18294

{ "test_bug8330", test_bug8330 },

18295

{ "test_bug7990", test_bug7990 },

18296

{ "test_bug8378", test_bug8378 },

18297

{ "test_bug8722", test_bug8722 },

18298

{ "test_bug8880", test_bug8880 },

18299

{ "test_bug9159", test_bug9159 },

18300

{ "test_bug9520", test_bug9520 },

18301

{ "test_bug9478", test_bug9478 },

18302

{ "test_bug9643", test_bug9643 },

18303

{ "test_bug10729", test_bug10729 },

18304

{ "test_bug11111", test_bug11111 },

18305

{ "test_bug9992", test_bug9992 },

18306

{ "test_bug10736", test_bug10736 },

18307

{ "test_bug10794", test_bug10794 },

18308

{ "test_bug11172", test_bug11172 },

18309

{ "test_bug11656", test_bug11656 },

18310

{ "test_bug10214", test_bug10214 },

18311

{ "test_bug9735", test_bug9735 },

18312

{ "test_bug11183", test_bug11183 },

18313

{ "test_bug11037", test_bug11037 },

18314

{ "test_bug10760", test_bug10760 },

18315

{ "test_bug12001", test_bug12001 },

18316

{ "test_bug11718", test_bug11718 },

18317

{ "test_bug12925", test_bug12925 },

18318

{ "test_bug11909", test_bug11909 },

18319

{ "test_bug11901", test_bug11901 },

18320

{ "test_bug11904", test_bug11904 },

18321

{ "test_bug12243", test_bug12243 },

18322

{ "test_bug14210", test_bug14210 },

18323

{ "test_bug13488", test_bug13488 },

18324

{ "test_bug13524", test_bug13524 },

18325

{ "test_bug14845", test_bug14845 },

18326

{ "test_opt_reconnect", test_opt_reconnect },

18327

{ "test_bug15510", test_bug15510},

18328

#ifndef EMBEDDED_LIBRARY

18329

{ "test_bug12744", test_bug12744 },

18330

#endif

18331

{ "test_bug16143", test_bug16143 },

18332

{ "test_bug16144", test_bug16144 },

18333

{ "test_bug15613", test_bug15613 },

18334

{ "test_bug20152", test_bug20152 },

18335

{ "test_bug14169", test_bug14169 },

18336

{ "test_bug17667", test_bug17667 },

18337

{ "test_bug15752", test_bug15752 },

18338

{ "test_mysql_insert_id", test_mysql_insert_id },

18339

{ "test_bug19671", test_bug19671 },

18340

{ "test_bug21206", test_bug21206 },

18341

{ "test_bug21726", test_bug21726 },

18342

{ "test_bug15518", test_bug15518 },

18343

{ "test_bug23383", test_bug23383 },

18344

{ "test_bug32265", test_bug32265 },

18345

{ "test_bug21635", test_bug21635 },

18346

{ "test_status", test_status },

18347

{ "test_bug24179", test_bug24179 },

18348

{ "test_ps_query_cache", test_ps_query_cache },

18349

{ "test_bug28075", test_bug28075 },

18350

{ "test_bug27876", test_bug27876 },

18351

{ "test_bug28505", test_bug28505 },

18352

{ "test_bug28934", test_bug28934 },

18353

{ "test_bug27592", test_bug27592 },

18354

{ "test_bug29687", test_bug29687 },

18355

{ "test_bug29692", test_bug29692 },

18356

{ "test_bug29306", test_bug29306 },

18357

{ "test_change_user", test_change_user },

18358

{ "test_bug30472", test_bug30472 },

18359

{ "test_bug20023", test_bug20023 },

18360

{ "test_bug45010", test_bug45010 },

18361

{ "test_bug31418", test_bug31418 },

18362

{ "test_bug31669", test_bug31669 },

18363

{ "test_bug28386", test_bug28386 },

18364

{ "test_wl4166_1", test_wl4166_1 },

18365

{ "test_wl4166_2", test_wl4166_2 },

18366

{ "test_bug38486", test_bug38486 },

18367

{ "test_bug40365", test_bug40365 },

18368

{ "test_bug43560", test_bug43560 },

18369

#ifdef HAVE_QUERY_CACHE

18370

{ "test_bug36326", test_bug36326 },

18371

#endif

18372

{ "test_bug41078", test_bug41078 },

18373

{ "test_bug44495", test_bug44495 },

18374

{ 0, 0 }

18375

};

18376

18377

18378

static my_bool

18379

get_one_option(int optid, const struct my_option *opt __attribute__((unused)),

18380

char *argument)

18381

{

18382

switch (optid) {

18383

case '#':

18384

DBUG_PUSH(argument ? argument : default_dbug_option);

18385

break;

18386

case 'c':

18387

opt_testcase = 1;

18388

break;

18389

case 'p':

18390

if (argument)

18391

{

18392

char *start=argument;

18393

my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));

18394

opt_password= my_strdup(argument, MYF(MY_FAE));

18395

while (*argument) *argument++= 'x'; /* Destroy argument */

18396

if (*start)

18397

start[1]=0;

18398

}

18399

else

18400

tty_password= 1;

18401

break;

18402

case 's':

18403

if (argument == disabled_my_option)

18404

opt_silent= 0;

18405

else

18406

opt_silent++;

18407

break;

18408

case 'A':

18409

18410

When the embedded server is being tested, the test suite needs to be

18411

able to pass command-line arguments to the embedded server so it can

18412

locate the language files and data directory. The test suite

18413

(mysql-test-run) never uses config files, just command-line options.

18414

18415

if (!embedded_server_arg_count)

18416

{

18417

embedded_server_arg_count= 1;

18418

embedded_server_args[0]= (char*) "";

18419

}

18420

if (embedded_server_arg_count == MAX_SERVER_ARGS-1 ||

18421

!(embedded_server_args[embedded_server_arg_count++]=

18422

my_strdup(argument, MYF(MY_FAE))))

18423

{

18424

DIE("Can't use server argument");

18425

}

18426

break;

18427

case 'T':

18428

{

18429

struct my_tests_st *fptr;

18430

18431

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

18432

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

18433

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

18434

exit(0);

18435

break;

18436

}

18437

case '?':

18438

case 'I': /* Info */

18439

usage();

18440

exit(0);

18441

break;

18442

}

18443

return 0;

18444

}

18445

18446

static void get_options(int *argc, char ***argv)

18447

{

18448

int ho_error;

18449

18450

if ((ho_error= handle_options(argc, argv, client_test_long_options,

18451

get_one_option)))

18452

exit(ho_error);

18453

18454

if (tty_password)

18455

opt_password= get_tty_password(NullS);

18456

return;

18457

}

18458

18459

18460

Print the test output on successful execution before exiting

18461

18462

18463

static void print_test_output()

18464

{

18465

if (opt_silent < 3)

18466

{

18467

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

18468

fprintf(stdout, "All '%d' tests were successful (in '%d' iterations)",

18469

test_count-1, opt_count);

18470

fprintf(stdout, "\n Total execution time: %g SECS", total_time);

18471

if (opt_count > 1)

18472

fprintf(stdout, " (Avg: %g SECS)", total_time/opt_count);

18473

18474

fprintf(stdout, "\n\n!!! SUCCESS !!!\n");

18475

}

18476

}

18477

18478

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

18479

main routine

18480

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

18481

18482

18483

int main(int argc, char **argv)

18484

{

18485

struct my_tests_st *fptr;

18486

18487

MY_INIT(argv[0]);

18488

18489

load_defaults("my", client_test_load_default_groups, &argc, &argv);

18490

defaults_argv= argv;

18491

get_options(&argc, &argv);

18492

18493

if (mysql_server_init(embedded_server_arg_count,

18494

embedded_server_args,

18495

(char**) embedded_server_groups))

18496

DIE("Can't initialize MySQL server");

18497

18498

/* connect to server with no flags, default protocol, auto reconnect true */

18499

mysql= client_connect(0, MYSQL_PROTOCOL_DEFAULT, 1);

18500

18501

total_time= 0;

18502

for (iter_count= 1; iter_count <= opt_count; iter_count++)

18503

{

18504

/* Start of tests */

18505

test_count= 1;

18506

start_time= time((time_t *)0);

18507

if (!argc)

18508

{

18509

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

18510

(*fptr->function)();

18511

}

18512

else

18513

{

18514

for ( ; *argv ; argv++)

18515

{

18516

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

18517

{

18518

if (!strcmp(fptr->name, *argv))

18519

{

18520

(*fptr->function)();

18521

break;

18522

}

18523

}

18524

if (!fptr->name)

18525

{

18526

fprintf(stderr, "\n\nGiven test not found: '%s'\n", *argv);

18527

fprintf(stderr, "See legal test names with %s -T\n\nAborting!\n",

18528

my_progname);

18529

client_disconnect(mysql, 1);

18530

free_defaults(defaults_argv);

18531

exit(1);

18532

}

18533

}

18534

}

18535

18536

end_time= time((time_t *)0);

18537

total_time+= difftime(end_time, start_time);

18538

18539

/* End of tests */

18540

}

18541

18542

client_disconnect(mysql, 1); /* disconnect from server */

18543

18544

free_defaults(defaults_argv);

18545

print_test_output();

18546

18547

while (embedded_server_arg_count > 1)

18548

my_free(embedded_server_args[--embedded_server_arg_count],MYF(0));

18549

18550

mysql_server_end();

18551

18552

my_end(0);

18553

18554

exit(0);

18555

}

Older »