~drizzle-trunk/drizzle/development

"Number of BLOB columns to create table with if specifying --auto-generate-sql. Example --number-blob-cols=3:1024/2048 would give you 3 blobs with a random size between 1024 and 2048. ",

620

(char**) &num_blob_cols_opt, (char**) &num_blob_cols_opt, 0, GET_STR, REQUIRED_ARG,

621

0, 0, 0, 0, 0, 0},

622

{"number-char-cols", 'x',

623

"Number of VARCHAR columns to create in table if specifying --auto-generate-sql.",

624

(char**) &num_char_cols_opt, (char**) &num_char_cols_opt, 0, GET_STR, REQUIRED_ARG,

625

0, 0, 0, 0, 0, 0},

626

{"number-int-cols", 'y',

627

"Number of INT columns to create in table if specifying --auto-generate-sql.",

628

(char**) &num_int_cols_opt, (char**) &num_int_cols_opt, 0, GET_STR, REQUIRED_ARG,

629

0, 0, 0, 0, 0, 0},

630

{"number-of-queries", OPT_DRIZZLE_NUMBER_OF_QUERY,

631

"Limit each client to this number of queries (this is not exact).",

632

(char**) &num_of_query, (char**) &num_of_query, 0,

633

GET_ULL, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

634

{"only-print", OPT_DRIZZLE_ONLY_PRINT,

635

"This causes drizzleslap to not connect to the databases, but instead print "

636

"out what it would have done instead.",

637

(char**) &opt_only_print, (char**) &opt_only_print, 0, GET_BOOL, NO_ARG,

638

0, 0, 0, 0, 0, 0},

620

(char**) &opt_label, (char**) &opt_label, 0,

621

GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

622

{"number-blob-cols", OPT_SLAP_BLOB_COL,

623

"Number of BLOB columns to create table with if specifying --auto-generate-sql. Example --number-blob-cols=3:1024/2048 would give you 3 blobs with a random size between 1024 and 2048. ",

624

(char**) &num_blob_cols_opt, (char**) &num_blob_cols_opt, 0, GET_STR, REQUIRED_ARG,

625

0, 0, 0, 0, 0, 0},

626

{"number-char-cols", 'x',

627

"Number of VARCHAR columns to create in table if specifying --auto-generate-sql.",

628

(char**) &num_char_cols_opt, (char**) &num_char_cols_opt, 0, GET_STR, REQUIRED_ARG,

629

0, 0, 0, 0, 0, 0},

630

{"number-int-cols", 'y',

631

"Number of INT columns to create in table if specifying --auto-generate-sql.",

632

(char**) &num_int_cols_opt, (char**) &num_int_cols_opt, 0, GET_STR, REQUIRED_ARG,

633

0, 0, 0, 0, 0, 0},

634

{"number-of-queries", OPT_MYSQL_NUMBER_OF_QUERY,

635

"Limit each client to this number of queries (this is not exact).",

636

(char**) &num_of_query, (char**) &num_of_query, 0,

637

GET_ULL, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

638

{"only-print", OPT_MYSQL_ONLY_PRINT,

639

"This causes mysqlslap to not connect to the databases, but instead print "

640

"out what it would have done instead.",

641

(char**) &opt_only_print, (char**) &opt_only_print, 0, GET_BOOL, NO_ARG,

642

0, 0, 0, 0, 0, 0},

639

643

{"password", 'p',

640

"Password to use when connecting to server. If password is not given it's "

641

"asked from the tty.", 0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

642

{"port", 'P', "Port number to use for connection.", (char**) &opt_drizzle_port,

643

(char**) &opt_drizzle_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0,

644

0},

644

"Password to use when connecting to server. If password is not given it's "

645

"asked from the tty.", 0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

646

{"port", 'P', "Port number to use for connection.", (char**) &opt_mysql_port,

647

(char**) &opt_mysql_port, 0, GET_UINT, REQUIRED_ARG, MYSQL_PORT, 0, 0, 0, 0,

648

0},

645

649

{"post-query", OPT_SLAP_POST_QUERY,

646

"Query to run or file containing query to execute after tests have completed.",

647

(char**) &user_supplied_post_statements,

648

(char**) &user_supplied_post_statements,

649

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

650

"Query to run or file containing query to execute after tests have completed.",

651

(char**) &user_supplied_post_statements,

652

(char**) &user_supplied_post_statements,

653

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

650

654

{"post-system", OPT_SLAP_POST_SYSTEM,

651

"system() string to execute after tests have completed.",

652

(char**) &post_system,

653

(char**) &post_system,

654

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

655

{"pre-query", OPT_SLAP_PRE_QUERY,

656

"Query to run or file containing query to execute before running tests.",

657

(char**) &user_supplied_pre_statements,

658

(char**) &user_supplied_pre_statements,

659

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

660

{"pre-system", OPT_SLAP_PRE_SYSTEM,

661

"system() string to execute before running tests.",

662

(char**) &pre_system,

663

(char**) &pre_system,

664

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

665

{"protocol", OPT_DRIZZLE_PROTOCOL,

666

"The protocol of connection (tcp,socket,pipe,memory).",

667

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

655

"system() string to execute after tests have completed.",

656

(char**) &post_system,

657

(char**) &post_system,

658

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

659

{"pre-query", OPT_SLAP_PRE_QUERY,

660

"Query to run or file containing query to execute before running tests.",

661

(char**) &user_supplied_pre_statements,

662

(char**) &user_supplied_pre_statements,

663

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

664

{"pre-system", OPT_SLAP_PRE_SYSTEM,

665

"system() string to execute before running tests.",

666

(char**) &pre_system,

667

(char**) &pre_system,

668

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

669

{"protocol", OPT_MYSQL_PROTOCOL,

670

"The protocol of connection (tcp,socket,pipe,memory).",

671

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

668

672

{"query", 'q', "Query to run or file containing query to run.",

669

(char**) &user_supplied_query, (char**) &user_supplied_query,

670

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

671

{"set-random-seed", OPT_SLAP_SET_RANDOM_SEED,

672

"Seed for random number generator (srandom(3))",

673

(char**)&opt_set_random_seed,

674

(char**)&opt_set_random_seed,0,

675

GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

673

(char**) &user_supplied_query, (char**) &user_supplied_query,

674

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

675

{"set-random-seed", OPT_SLAP_SET_RANDOM_SEED,

676

"Seed for random number generator (srandom(3))",

677

(char**)&opt_set_random_seed,

678

(char**)&opt_set_random_seed,0,

679

GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

680

#ifdef HAVE_SMEM

681

{"shared-memory-base-name", OPT_SHARED_MEMORY_BASE_NAME,

682

"Base name of shared memory.", (char**) &shared_memory_base_name,

683

(char**) &shared_memory_base_name, 0, GET_STR_ALLOC, REQUIRED_ARG,

684

0, 0, 0, 0, 0, 0},

685

#endif

676

686

{"silent", 's', "Run program in silent mode - no output.",

677

(char**) &opt_silent, (char**) &opt_silent, 0, GET_BOOL, NO_ARG,

678

0, 0, 0, 0, 0, 0},

687

(char**) &opt_silent, (char**) &opt_silent, 0, GET_BOOL, NO_ARG,

688

0, 0, 0, 0, 0, 0},

679

689

{"socket", 'S', "Socket file to use for connection.",

680

(char**) &opt_drizzle_unix_port, (char**) &opt_drizzle_unix_port, 0, GET_STR,

681

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

682

{"timer-length", OPT_SLAP_TIMER_LENGTH,

683

"Require drizzleslap to run each specific test a certain amount of time in seconds.",

684

(char**) &opt_timer_length, (char**) &opt_timer_length, 0, GET_UINT,

685

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

690

(char**) &opt_mysql_unix_port, (char**) &opt_mysql_unix_port, 0, GET_STR,

691

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

692

{"timer-length", OPT_SLAP_TIMER_LENGTH,

693

"Require mysqlslap to run each specific test a certain amount of time in seconds.",

694

(char**) &opt_timer_length, (char**) &opt_timer_length, 0, GET_UINT,

695

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

686

696

#ifndef DONT_ALLOW_USER_CHANGE

687

697

{"user", 'u', "User for login if not current user.", (char**) &user,

688

(char**) &user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

698

(char**) &user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

689

699

#endif

690

700

{"verbose", 'v',

691

"More verbose output; you can use this multiple times to get even more "

692

"verbose output.", (char**) &verbose, (char**) &verbose, 0,

693

GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

701

"More verbose output; you can use this multiple times to get even more "

702

"verbose output.", (char**) &verbose, (char**) &verbose, 0,

703

GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

694

704

{"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,

695

NO_ARG, 0, 0, 0, 0, 0, 0},

705

NO_ARG, 0, 0, 0, 0, 0, 0},

696

706

{0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}

697

707

};

698

708

699

709

710

#include <help_start.h>

711

700

712

static void print_version(void)

701

713

{

702

714

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

703

drizzle_get_client_info(),SYSTEM_TYPE,MACHINE_TYPE);

715

MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);

704

716

}

705

717

706

718

707

719

static void usage(void)

708

720

{

709

721

print_version();

710

722

711

723

puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\

712

724

\nand you are welcome to modify and redistribute it under the GPL \

713

725

license\n");

717

729

my_print_help(my_long_options);

718

730

}

719

731

732

#include <help_end.h>

733

720

734

static bool

721

735

get_one_option(int optid, const struct my_option *opt __attribute__((unused)),

722

736

char *argument)

730

744

if (argument)

731

745

{

732

746

char *start= argument;

733

free(opt_password);

747

my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));

734

748

opt_password= my_strdup(argument,MYF(MY_FAE));

735

while (*argument) *argument++= 'x'; /* Destroy argument */

749

while (*argument) *argument++= 'x'; /* Destroy argument */

736

750

if (*start)

737

start[1]= 0; /* Cut length of argument */

751

start[1]= 0; /* Cut length of argument */

738

752

tty_password= 0;

739

753

}

740

754

else

745

759

exit(0);

746

760

break;

747

761

case '?':

748

case 'I': /* Info */

762

case 'I': /* Info */

749

763

usage();

750

764

exit(0);

751

765

}

777

791

char buf[HUGE_STRING_LENGTH];

778

792

unsigned int col_count;

779

793

statement *ptr;

780

string table_string;

781

782

table_string.reserve(HUGE_STRING_LENGTH);

783

784

table_string= "CREATE TABLE `t1` (";

794

DYNAMIC_STRING table_string;

795

796

init_dynamic_string(&table_string, "", HUGE_STRING_LENGTH, HUGE_STRING_LENGTH);

797

798

dynstr_append(&table_string, "CREATE TABLE `t1` (");

785

799

786

800

if (auto_generate_sql_autoincrement)

787

801

{

788

table_string.append("id serial");

802

dynstr_append(&table_string, "id serial");

789

803

790

804

if (num_int_cols || num_char_cols)

791

table_string.append(",");

805

dynstr_append(&table_string, ",");

792

806

}

793

807

794

808

if (auto_generate_sql_guid_primary)

795

809

{

796

table_string.append("id varchar(128) primary key");

810

dynstr_append(&table_string, "id varchar(128) primary key");

797

811

798

812

if (num_int_cols || num_char_cols || auto_generate_sql_guid_primary)

799

table_string.append(",");

813

dynstr_append(&table_string, ",");

800

814

}

801

815

802

816

if (auto_generate_sql_secondary_indexes)

806

820

for (count= 0; count < auto_generate_sql_secondary_indexes; count++)

807

821

{

808

822

if (count) /* Except for the first pass we add a comma */

809

table_string.append(",");

823

dynstr_append(&table_string, ",");

810

824

811

if (snprintf(buf, HUGE_STRING_LENGTH, "id%d varchar(32) unique key", count)

825

if (snprintf(buf, HUGE_STRING_LENGTH, "id%d varchar(32) unique key", count)

812

826

> HUGE_STRING_LENGTH)

813

827

{

814

828

fprintf(stderr, "Memory Allocation error in create table\n");

815

829

exit(1);

816

830

}

817

table_string.append(buf);

831

dynstr_append(&table_string, buf);

818

832

}

819

833

820

834

if (num_int_cols || num_char_cols)

821

table_string.append(",");

835

dynstr_append(&table_string, ",");

822

836

}

823

837

824

838

if (num_int_cols)

826

840

{

827

841

if (num_int_cols_index)

828

842

{

829

if (snprintf(buf, HUGE_STRING_LENGTH, "intcol%d INT, INDEX(intcol%d)",

843

if (snprintf(buf, HUGE_STRING_LENGTH, "intcol%d INT(32), INDEX(intcol%d)",

830

844

col_count, col_count) > HUGE_STRING_LENGTH)

831

845

{

832

846

fprintf(stderr, "Memory Allocation error in create table\n");

835

849

}

836

850

else

837

851

{

838

if (snprintf(buf, HUGE_STRING_LENGTH, "intcol%d INT ", col_count)

852

if (snprintf(buf, HUGE_STRING_LENGTH, "intcol%d INT(32) ", col_count)

839

853

> HUGE_STRING_LENGTH)

840

854

{

841

855

fprintf(stderr, "Memory Allocation error in create table\n");

842

856

exit(1);

843

857

}

844

858

}

845

table_string.append(buf);

859

dynstr_append(&table_string, buf);

846

860

847

861

if (col_count < num_int_cols || num_char_cols > 0)

848

table_string.append(",");

862

dynstr_append(&table_string, ",");

849

863

}

850

864

851

865

if (num_char_cols)

853

867

{

854

868

if (num_char_cols_index)

855

869

{

856

if (snprintf(buf, HUGE_STRING_LENGTH,

857

"charcol%d VARCHAR(128), INDEX(charcol%d) ",

870

if (snprintf(buf, HUGE_STRING_LENGTH,

871

"charcol%d VARCHAR(128), INDEX(charcol%d) ",

858

872

col_count, col_count) > HUGE_STRING_LENGTH)

859

873

{

860

874

fprintf(stderr, "Memory Allocation error in creating table\n");

863

877

}

864

878

else

865

879

{

866

if (snprintf(buf, HUGE_STRING_LENGTH, "charcol%d VARCHAR(128)",

880

if (snprintf(buf, HUGE_STRING_LENGTH, "charcol%d VARCHAR(128)",

867

881

col_count) > HUGE_STRING_LENGTH)

868

882

{

869

883

fprintf(stderr, "Memory Allocation error in creating table\n");

870

884

exit(1);

871

885

}

872

886

}

873

table_string.append(buf);

887

dynstr_append(&table_string, buf);

874

888

875

889

if (col_count < num_char_cols || num_blob_cols > 0)

876

table_string.append(",");

890

dynstr_append(&table_string, ",");

877

891

}

878

892

879

893

if (num_blob_cols)

880

894

for (col_count= 1; col_count <= num_blob_cols; col_count++)

881

895

{

882

if (snprintf(buf, HUGE_STRING_LENGTH, "blobcol%d blob",

896

if (snprintf(buf, HUGE_STRING_LENGTH, "blobcol%d blob",

883

897

col_count) > HUGE_STRING_LENGTH)

884

898

{

885

899

fprintf(stderr, "Memory Allocation error in creating table\n");

886

900

exit(1);

887

901

}

888

table_string.append(buf);

902

dynstr_append(&table_string, buf);

889

903

890

904

if (col_count < num_blob_cols)

891

table_string.append(",");

905

dynstr_append(&table_string, ",");

892

906

}

893

907

894

table_string.append(")");

895

ptr= (statement *)my_malloc(sizeof(statement),

908

dynstr_append(&table_string, ")");

909

ptr= (statement *)my_malloc(sizeof(statement),

896

910

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

897

ptr->string = (char *)my_malloc(table_string.length()+1,

911

ptr->string = (char *)my_malloc(table_string.length+1,

898

912

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

899

ptr->length= table_string.length()+1;

913

ptr->length= table_string.length+1;

900

914

ptr->type= CREATE_TABLE_TYPE;

901

my_stpcpy(ptr->string, table_string.c_str());

915

strmov(ptr->string, table_string.str);

916

dynstr_free(&table_string);

902

917

return(ptr);

903

918

}

904

919

914

929

char buf[HUGE_STRING_LENGTH];

915

930

unsigned int col_count;

916

931

statement *ptr;

917

string update_string;

918

919

update_string.reserve(HUGE_STRING_LENGTH);

920

921

update_string= "UPDATE t1 SET ";

932

DYNAMIC_STRING update_string;

933

934

935

init_dynamic_string(&update_string, "", HUGE_STRING_LENGTH, HUGE_STRING_LENGTH);

936

937

dynstr_append(&update_string, "UPDATE t1 SET ");

922

938

923

939

if (num_int_cols)

924

940

for (col_count= 1; col_count <= num_int_cols; col_count++)

925

941

{

926

if (snprintf(buf, HUGE_STRING_LENGTH, "intcol%d = %ld", col_count,

942

if (snprintf(buf, HUGE_STRING_LENGTH, "intcol%d = %ld", col_count,

927

943

random()) > HUGE_STRING_LENGTH)

928

944

{

929

945

fprintf(stderr, "Memory Allocation error in creating update\n");

930

946

exit(1);

931

947

}

932

update_string.append(buf);

948

dynstr_append(&update_string, buf);

933

949

934

950

if (col_count < num_int_cols || num_char_cols > 0)

935

update_string.append(",", 1);

951

dynstr_append_mem(&update_string, ",", 1);

936

952

}

937

953

938

954

if (num_char_cols)

941

957

char rand_buffer[RAND_STRING_SIZE];

942

958

int buf_len= get_random_string(rand_buffer, RAND_STRING_SIZE);

943

959

944

if (snprintf(buf, HUGE_STRING_LENGTH, "charcol%d = '%.*s'", col_count,

945

buf_len, rand_buffer)

960

if (snprintf(buf, HUGE_STRING_LENGTH, "charcol%d = '%.*s'", col_count,

961

buf_len, rand_buffer)

946

962

> HUGE_STRING_LENGTH)

947

963

{

948

964

fprintf(stderr, "Memory Allocation error in creating update\n");

949

965

exit(1);

950

966

}

951

update_string.append(buf);

967

dynstr_append(&update_string, buf);

952

968

953

969

if (col_count < num_char_cols)

954

update_string.append(",", 1);

970

dynstr_append_mem(&update_string, ",", 1);

955

971

}

956

972

957

973

if (auto_generate_sql_autoincrement || auto_generate_sql_guid_primary)

958

update_string.append(" WHERE id = ");

959

960

961

ptr= (statement *)my_malloc(sizeof(statement),

974

dynstr_append(&update_string, " WHERE id = ");

975

976

977

ptr= (statement *)my_malloc(sizeof(statement),

962

978

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

963

979

964

ptr->string= (char *)my_malloc(update_string.length() + 1,

965

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

966

ptr->length= update_string.length()+1;

980

ptr->string= (char *)my_malloc(update_string.length + 1,

981

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

982

ptr->length= update_string.length+1;

967

983

if (auto_generate_sql_autoincrement || auto_generate_sql_guid_primary)

968

984

ptr->type= UPDATE_TYPE_REQUIRES_PREFIX ;

969

985

else

970

986

ptr->type= UPDATE_TYPE;

971

my_stpcpy(ptr->string, update_string.c_str());

987

strmov(ptr->string, update_string.str);

988

dynstr_free(&update_string);

972

989

return(ptr);

973

990

}

974

991

985

1002

char buf[HUGE_STRING_LENGTH];

986

1003

unsigned int col_count;

987

1004

statement *ptr;

988

string insert_string;

989

990

insert_string.reserve(HUGE_STRING_LENGTH);

991

992

insert_string= "INSERT INTO t1 VALUES (";

1005

DYNAMIC_STRING insert_string;

1006

1007

1008

init_dynamic_string(&insert_string, "", HUGE_STRING_LENGTH, HUGE_STRING_LENGTH);

1009

1010

dynstr_append(&insert_string, "INSERT INTO t1 VALUES (");

993

1011

994

1012

if (auto_generate_sql_autoincrement)

995

1013

{

996

insert_string.append("NULL");

1014

dynstr_append(&insert_string, "NULL");

997

1015

998

1016

if (num_int_cols || num_char_cols)

999

insert_string.append(",");

1017

dynstr_append(&insert_string, ",");

1000

1018

}

1001

1019

1002

1020

if (auto_generate_sql_guid_primary)

1003

1021

{

1004

insert_string.append("uuid()");

1022

dynstr_append(&insert_string, "uuid()");

1005

1023

1006

1024

if (num_int_cols || num_char_cols)

1007

insert_string.append(",");

1025

dynstr_append(&insert_string, ",");

1008

1026

}

1009

1027

1010

1028

if (auto_generate_sql_secondary_indexes)

1014

1032

for (count= 0; count < auto_generate_sql_secondary_indexes; count++)

1015

1033

{

1016

1034

if (count) /* Except for the first pass we add a comma */

1017

insert_string.append(",");

1035

dynstr_append(&insert_string, ",");

1018

1036

1019

insert_string.append("uuid()");

1037

dynstr_append(&insert_string, "uuid()");

1020

1038

}

1021

1039

1022

1040

if (num_int_cols || num_char_cols)

1023

insert_string.append(",");

1041

dynstr_append(&insert_string, ",");

1024

1042

}

1025

1043

1026

1044

if (num_int_cols)

1031

1049

fprintf(stderr, "Memory Allocation error in creating insert\n");

1032

1050

exit(1);

1033

1051

}

1034

insert_string.append(buf);

1052

dynstr_append(&insert_string, buf);

1035

1053

1036

1054

if (col_count < num_int_cols || num_char_cols > 0)

1037

insert_string.append(",");

1055

dynstr_append_mem(&insert_string, ",", 1);

1038

1056

}

1039

1057

1040

1058

if (num_char_cols)

1041

1059

for (col_count= 1; col_count <= num_char_cols; col_count++)

1042

1060

{

1043

1061

int buf_len= get_random_string(buf, RAND_STRING_SIZE);

1044

insert_string.append("'", 1);

1045

insert_string.append(buf, buf_len);

1046

insert_string.append("'", 1);

1062

dynstr_append_mem(&insert_string, "'", 1);

1063

dynstr_append_mem(&insert_string, buf, buf_len);

1064

dynstr_append_mem(&insert_string, "'", 1);

1047

1065

1048

1066

if (col_count < num_char_cols || num_blob_cols > 0)

1049

insert_string.append(",", 1);

1067

dynstr_append_mem(&insert_string, ",", 1);

1050

1068

}

1051

1069

1052

1070

if (num_blob_cols)

1056

1074

if (num_blob_cols_size > HUGE_STRING_LENGTH)

1057

1075

{

1058

1076

blob_ptr= (char *)my_malloc(sizeof(char)*num_blob_cols_size,

1059

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1077

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1060

1078

if (!blob_ptr)

1061

1079

{

1062

1080

fprintf(stderr, "Memory Allocation error in creating select\n");

1074

1092

unsigned int size;

1075

1093

unsigned int difference= num_blob_cols_size - num_blob_cols_size_min;

1076

1094

1077

size= difference ? (num_blob_cols_size_min + (random() % difference)) :

1078

num_blob_cols_size;

1095

size= difference ? (num_blob_cols_size_min + (random() % difference)) :

1096

num_blob_cols_size;

1079

1097

1080

1098

buf_len= get_random_string(blob_ptr, size);

1081

1099

1082

insert_string.append("'", 1);

1083

insert_string.append(blob_ptr, buf_len);

1084

insert_string.append("'", 1);

1100

dynstr_append_mem(&insert_string, "'", 1);

1101

dynstr_append_mem(&insert_string, blob_ptr, buf_len);

1102

dynstr_append_mem(&insert_string, "'", 1);

1085

1103

1086

1104

if (col_count < num_blob_cols)

1087

insert_string.append(",", 1);

1105

dynstr_append_mem(&insert_string, ",", 1);

1088

1106

}

1089

1107

1090

1108

if (num_blob_cols_size > HUGE_STRING_LENGTH)

1091

free(blob_ptr);

1109

my_free(blob_ptr, MYF(0));

1092

1110

}

1093

1111

1094

insert_string.append(")", 1);

1112

dynstr_append_mem(&insert_string, ")", 1);

1095

1113

1096

1114

if (!(ptr= (statement *)my_malloc(sizeof(statement), MYF(MY_ZEROFILL|MY_FAE|MY_WME))))

1097

1115

{

1098

1116

fprintf(stderr, "Memory Allocation error in creating select\n");

1099

1117

exit(1);

1100

1118

}

1101

if (!(ptr->string= (char *)my_malloc(insert_string.length() + 1, MYF(MY_ZEROFILL|MY_FAE|MY_WME))))

1119

if (!(ptr->string= (char *)my_malloc(insert_string.length + 1, MYF(MY_ZEROFILL|MY_FAE|MY_WME))))

1102

1120

{

1103

1121

fprintf(stderr, "Memory Allocation error in creating select\n");

1104

1122

exit(1);

1105

1123

}

1106

ptr->length= insert_string.length()+1;

1124

ptr->length= insert_string.length+1;

1107

1125

ptr->type= INSERT_TYPE;

1108

my_stpcpy(ptr->string, insert_string.c_str());

1126

strmov(ptr->string, insert_string.str);

1127

dynstr_free(&insert_string);

1128

1109

1129

return(ptr);

1110

1130

}

1111

1131

1122

1142

char buf[HUGE_STRING_LENGTH];

1123

1143

unsigned int col_count;

1124

1144

statement *ptr;

1125

string query_string;

1126

1127

query_string.reserve(HUGE_STRING_LENGTH);

1128

1129

query_string.append("SELECT ", 7);

1145

static DYNAMIC_STRING query_string;

1146

1147

1148

init_dynamic_string(&query_string, "", HUGE_STRING_LENGTH, HUGE_STRING_LENGTH);

1149

1150

dynstr_append_mem(&query_string, "SELECT ", 7);

1130

1151

if (auto_generate_selected_columns_opt)

1131

1152

{

1132

query_string.append(auto_generate_selected_columns_opt);

1153

dynstr_append(&query_string, auto_generate_selected_columns_opt);

1133

1154

}

1134

1155

else

1135

1156

{

1136

1157

for (col_count= 1; col_count <= num_int_cols; col_count++)

1137

1158

{

1138

if (snprintf(buf, HUGE_STRING_LENGTH, "intcol%d", col_count)

1159

if (snprintf(buf, HUGE_STRING_LENGTH, "intcol%d", col_count)

1139

1160

> HUGE_STRING_LENGTH)

1140

1161

{

1141

1162

fprintf(stderr, "Memory Allocation error in creating select\n");

1142

1163

exit(1);

1143

1164

}

1144

query_string.append(buf);

1165

dynstr_append(&query_string, buf);

1145

1166

1146

1167

if (col_count < num_int_cols || num_char_cols > 0)

1147

query_string.append(",", 1);

1168

dynstr_append_mem(&query_string, ",", 1);

1148

1169

1149

1170

}

1150

1171

for (col_count= 1; col_count <= num_char_cols; col_count++)

1155

1176

fprintf(stderr, "Memory Allocation error in creating select\n");

1156

1177

exit(1);

1157

1178

}

1158

query_string.append(buf);

1179

dynstr_append(&query_string, buf);

1159

1180

1160

1181

if (col_count < num_char_cols || num_blob_cols > 0)

1161

query_string.append(",", 1);

1182

dynstr_append_mem(&query_string, ",", 1);

1162

1183

1163

1184

}

1164

1185

for (col_count= 1; col_count <= num_blob_cols; col_count++)

1169

1190

fprintf(stderr, "Memory Allocation error in creating select\n");

1170

1191

exit(1);

1171

1192

}

1172

query_string.append(buf);

1193

dynstr_append(&query_string, buf);

1173

1194

1174

1195

if (col_count < num_blob_cols)

1175

query_string.append(",", 1);

1196

dynstr_append_mem(&query_string, ",", 1);

1176

1197

}

1177

1198

}

1178

query_string.append(" FROM t1");

1199

dynstr_append(&query_string, " FROM t1");

1179

1200

1180

if ((key) &&

1201

if ((key) &&

1181

1202

(auto_generate_sql_autoincrement || auto_generate_sql_guid_primary))

1182

query_string.append(" WHERE id = ");

1203

dynstr_append(&query_string, " WHERE id = ");

1183

1204

1184

1205

ptr= (statement *)my_malloc(sizeof(statement),

1185

1206

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1186

ptr->string= (char *)my_malloc(query_string.length() + 1,

1187

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1188

ptr->length= query_string.length()+1;

1189

if ((key) &&

1207

ptr->string= (char *)my_malloc(query_string.length + 1,

1208

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1209

ptr->length= query_string.length+1;

1210

if ((key) &&

1190

1211

(auto_generate_sql_autoincrement || auto_generate_sql_guid_primary))

1191

1212

ptr->type= SELECT_TYPE_REQUIRES_PREFIX;

1192

1213

else

1193

1214

ptr->type= SELECT_TYPE;

1194

my_stpcpy(ptr->string, query_string.c_str());

1215

strmov(ptr->string, query_string.str);

1216

dynstr_free(&query_string);

1195

1217

return(ptr);

1196

1218

}

1197

1219

1221

1243

1222

1244

if (auto_generate_sql && (create_string || user_supplied_query))

1223

1245

{

1224

fprintf(stderr,

1225

"%s: Can't use --auto-generate-sql when create and query strings are specified!\n",

1226

my_progname);

1227

exit(1);

1246

fprintf(stderr,

1247

"%s: Can't use --auto-generate-sql when create and query strings are specified!\n",

1248

my_progname);

1249

exit(1);

1228

1250

}

1229

1251

1230

if (auto_generate_sql && auto_generate_sql_guid_primary &&

1252

if (auto_generate_sql && auto_generate_sql_guid_primary &&

1231

1253

auto_generate_sql_autoincrement)

1232

1254

{

1233

fprintf(stderr,

1234

"%s: Either auto-generate-sql-guid-primary or auto-generate-sql-add-autoincrement can be used!\n",

1235

my_progname);

1236

exit(1);

1255

fprintf(stderr,

1256

"%s: Either auto-generate-sql-guid-primary or auto-generate-sql-add-autoincrement can be used!\n",

1257

my_progname);

1258

exit(1);

1237

1259

}

1238

1260

1239

1261

if (auto_generate_sql && num_of_query && auto_actual_queries)

1240

1262

{

1241

fprintf(stderr,

1242

"%s: Either auto-generate-sql-execute-number or number-of-queries can be used!\n",

1243

my_progname);

1244

exit(1);

1263

fprintf(stderr,

1264

"%s: Either auto-generate-sql-execute-number or number-of-queries can be used!\n",

1265

my_progname);

1266

exit(1);

1245

1267

}

1246

1268

1247

1269

parse_comma(concurrency_str ? concurrency_str : "1", &concurrency);

1249

1271

if (opt_csv_str)

1250

1272

{

1251

1273

opt_silent= true;

1252

1274

1253

1275

if (opt_csv_str[0] == '-')

1254

1276

{

1255

1277

csv_file= fileno(stdout);

1321

1343

1322

1344

if (auto_generate_sql)

1323

1345

{

1324

uint64_t x= 0;

1346

unsigned long long x= 0;

1325

1347

statement *ptr_statement;

1326

1348

1327

1349

if (verbose >= 2)

1328

1350

printf("Building Create Statements for Auto\n");

1329

1351

1330

1352

create_statements= build_table_string();

1331

1332

Pre-populate table

1353

1354

Pre-populate table

1333

1355

1334

for (ptr_statement= create_statements, x= 0;

1335

x < auto_generate_sql_unique_write_number;

1356

for (ptr_statement= create_statements, x= 0;

1357

x < auto_generate_sql_unique_write_number;

1336

1358

x++, ptr_statement= ptr_statement->next)

1337

1359

{

1338

1360

ptr_statement->next= build_insert_string();

1344

1366

if (!opt_auto_generate_sql_type)

1345

1367

opt_auto_generate_sql_type= "mixed";

1346

1368

1347

query_statements_count=

1369

query_statements_count=

1348

1370

parse_option(opt_auto_generate_sql_type, &query_options, ',');

1349

1371

1350

1372

query_statements= (statement **)my_malloc(sizeof(statement *) * query_statements_count,

1359

1381

printf("Generating SELECT Statements for Auto\n");

1360

1382

1361

1383

query_statements[sql_type_count]= build_select_string(false);

1362

for (ptr_statement= query_statements[sql_type_count], x= 0;

1363

x < auto_generate_sql_unique_query_number;

1384

for (ptr_statement= query_statements[sql_type_count], x= 0;

1385

x < auto_generate_sql_unique_query_number;

1364

1386

x++, ptr_statement= ptr_statement->next)

1365

1387

{

1366

1388

ptr_statement->next= build_select_string(false);

1381

1403

}

1382

1404

1383

1405

query_statements[sql_type_count]= build_select_string(true);

1384

for (ptr_statement= query_statements[sql_type_count], x= 0;

1385

x < auto_generate_sql_unique_query_number;

1406

for (ptr_statement= query_statements[sql_type_count], x= 0;

1407

x < auto_generate_sql_unique_query_number;

1386

1408

x++, ptr_statement= ptr_statement->next)

1387

1409

{

1388

1410

ptr_statement->next= build_select_string(true);

1391

1413

else if (sql_type->string[0] == 'w')

1392

1414

{

1393

1415

1394

We generate a number of strings in case the engine is

1416

We generate a number of strings in case the engine is

1395

1417

Archive (since strings which were identical one after another

1396

1418

would be too easily optimized).

1397

1419

1398

1420

if (verbose >= 2)

1399

1421

printf("Generating INSERT Statements for Auto\n");

1400

1422

query_statements[sql_type_count]= build_insert_string();

1401

for (ptr_statement= query_statements[sql_type_count], x= 0;

1402

x < auto_generate_sql_unique_query_number;

1423

for (ptr_statement= query_statements[sql_type_count], x= 0;

1424

x < auto_generate_sql_unique_query_number;

1403

1425

x++, ptr_statement= ptr_statement->next)

1404

1426

{

1405

1427

ptr_statement->next= build_insert_string();

1417

1439

}

1418

1440

1419

1441

query_statements[sql_type_count]= build_update_string();

1420

for (ptr_statement= query_statements[sql_type_count], x= 0;

1421

x < auto_generate_sql_unique_query_number;

1442

for (ptr_statement= query_statements[sql_type_count], x= 0;

1443

x < auto_generate_sql_unique_query_number;

1422

1444

x++, ptr_statement= ptr_statement->next)

1423

1445

{

1424

1446

ptr_statement->next= build_update_string();

1429

1451

int coin= 0;

1430

1452

1431

1453

query_statements[sql_type_count]= build_insert_string();

1432

1454

1433

1455

This logic should be extended to do a more mixed load,

1434

1456

at the moment it results in "every other".

1435

1457

1436

for (ptr_statement= query_statements[sql_type_count], x= 0;

1437

x < auto_generate_sql_unique_query_number;

1458

for (ptr_statement= query_statements[sql_type_count], x= 0;

1459

x < auto_generate_sql_unique_query_number;

1438

1460

x++, ptr_statement= ptr_statement->next)

1439

1461

{

1440

1462

if (coin)

1457

1479

if (create_string && !stat(create_string, &sbuf))

1458

1480

{

1459

1481

File data_file;

1460

if (!S_ISREG(sbuf.st_mode))

1482

if (!MY_S_ISREG(sbuf.st_mode))

1461

1483

{

1462

1484

fprintf(stderr,"%s: Create file was not a regular file\n",

1463

1485

my_progname);

1469

1491

exit(1);

1470

1492

}

1471

1493

tmp_string= (char *)my_malloc(sbuf.st_size + 1,

1472

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1473

my_read(data_file, (unsigned char*) tmp_string, sbuf.st_size, MYF(0));

1494

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1495

my_read(data_file, (uchar*) tmp_string, sbuf.st_size, MYF(0));

1474

1496

tmp_string[sbuf.st_size]= '\0';

1475

1497

my_close(data_file,MYF(0));

1476

1498

parse_delimiter(tmp_string, &create_statements, delimiter[0]);

1477

free(tmp_string);

1499

my_free(tmp_string, MYF(0));

1478

1500

}

1479

1501

else if (create_string)

1480

1502

{

1481

parse_delimiter(create_string, &create_statements, delimiter[0]);

1503

parse_delimiter(create_string, &create_statements, delimiter[0]);

1482

1504

}

1483

1505

1484

1506

/* Set this up till we fully support options on user generated queries */

1485

1507

if (user_supplied_query)

1486

1508

{

1487

query_statements_count=

1509

query_statements_count=

1488

1510

parse_option("default", &query_options, ',');

1489

1511

1490

1512

query_statements= (statement **)my_malloc(sizeof(statement *),

1494

1516

if (user_supplied_query && !stat(user_supplied_query, &sbuf))

1495

1517

{

1496

1518

File data_file;

1497

if (!S_ISREG(sbuf.st_mode))

1519

if (!MY_S_ISREG(sbuf.st_mode))

1498

1520

{

1499

1521

fprintf(stderr,"%s: User query supplied file was not a regular file\n",

1500

1522

my_progname);

1507

1529

}

1508

1530

tmp_string= (char *)my_malloc(sbuf.st_size + 1,

1509

1531

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1510

my_read(data_file, (unsigned char*) tmp_string, sbuf.st_size, MYF(0));

1532

my_read(data_file, (uchar*) tmp_string, sbuf.st_size, MYF(0));

1511

1533

tmp_string[sbuf.st_size]= '\0';

1512

1534

my_close(data_file,MYF(0));

1513

1535

if (user_supplied_query)

1514

1536

actual_queries= parse_delimiter(tmp_string, &query_statements[0],

1515

1537

delimiter[0]);

1516

free(tmp_string);

1517

}

1538

my_free(tmp_string, MYF(0));

1539

}

1518

1540

else if (user_supplied_query)

1519

1541

{

1520

1542

actual_queries= parse_delimiter(user_supplied_query, &query_statements[0],

1526

1548

&& !stat(user_supplied_pre_statements, &sbuf))

1527

1549

{

1528

1550

File data_file;

1529

if (!S_ISREG(sbuf.st_mode))

1551

if (!MY_S_ISREG(sbuf.st_mode))

1530

1552

{

1531

1553

fprintf(stderr,"%s: User query supplied file was not a regular file\n",

1532

1554

my_progname);

1539

1561

}

1540

1562

tmp_string= (char *)my_malloc(sbuf.st_size + 1,

1541

1563

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1542

my_read(data_file, (unsigned char*) tmp_string, sbuf.st_size, MYF(0));

1564

my_read(data_file, (uchar*) tmp_string, sbuf.st_size, MYF(0));

1543

1565

tmp_string[sbuf.st_size]= '\0';

1544

1566

my_close(data_file,MYF(0));

1545

1567

if (user_supplied_pre_statements)

1546

1568

(void)parse_delimiter(tmp_string, &pre_statements,

1547

1569

delimiter[0]);

1548

free(tmp_string);

1549

}

1570

my_free(tmp_string, MYF(0));

1571

}

1550

1572

else if (user_supplied_pre_statements)

1551

1573

{

1552

1574

(void)parse_delimiter(user_supplied_pre_statements,

1558

1580

&& !stat(user_supplied_post_statements, &sbuf))

1559

1581

{

1560

1582

File data_file;

1561

if (!S_ISREG(sbuf.st_mode))

1583

if (!MY_S_ISREG(sbuf.st_mode))

1562

1584

{

1563

1585

fprintf(stderr,"%s: User query supplied file was not a regular file\n",

1564

1586

my_progname);

1571

1593

}

1572

1594

tmp_string= (char *)my_malloc(sbuf.st_size + 1,

1573

1595

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1574

my_read(data_file, (unsigned char*) tmp_string, sbuf.st_size, MYF(0));

1596

my_read(data_file, (uchar*) tmp_string, sbuf.st_size, MYF(0));

1575

1597

tmp_string[sbuf.st_size]= '\0';

1576

1598

my_close(data_file,MYF(0));

1577

1599

if (user_supplied_post_statements)

1578

1600

(void)parse_delimiter(tmp_string, &post_statements,

1579

1601

delimiter[0]);

1580

free(tmp_string);

1581

}

1602

my_free(tmp_string, MYF(0));

1603

}

1582

1604

else if (user_supplied_post_statements)

1583

1605

{

1584

1606

(void)parse_delimiter(user_supplied_post_statements, &post_statements,

1592

1614

parse_option(default_engine, &engine_options, ',');

1593

1615

1594

1616

if (tty_password)

1595

opt_password= get_tty_password(NULL);

1617

opt_password= get_tty_password(NullS);

1596

1618

return(0);

1597

1619

}

1598

1620

1599

1621

1600

static int run_query(DRIZZLE *drizzle, const char *query, int len)

1622

static int run_query(MYSQL *mysql, const char *query, int len)

1601

1623

{

1602

1624

if (opt_only_print)

1603

1625

{

1607

1629

1608

1630

if (verbose >= 3)

1609

1631

printf("%.*s;\n", len, query);

1610

return drizzle_real_query(drizzle, query, len);

1632

return mysql_real_query(mysql, query, len);

1611

1633

}

1612

1634

1613

1635

1614

1636

static int

1615

generate_primary_key_list(DRIZZLE *drizzle, option_string *engine_stmt)

1637

generate_primary_key_list(MYSQL *mysql, option_string *engine_stmt)

1616

1638

{

1617

DRIZZLE_RES *result;

1618

DRIZZLE_ROW row;

1619

uint64_t counter;

1620

1621

1622

1623

Blackhole is a special case, this allows us to test the upper end

1639

MYSQL_RES *result;

1640

MYSQL_ROW row;

1641

unsigned long long counter;

1642

1643

1644

1645

Blackhole is a special case, this allows us to test the upper end

1624

1646

of the server during load runs.

1625

1647

1626

if (opt_only_print || (engine_stmt &&

1648

if (opt_only_print || (engine_stmt &&

1627

1649

strstr(engine_stmt->string, "blackhole")))

1628

1650

{

1629

1651

primary_keys_number_of= 1;

1630

primary_keys= (char **)my_malloc((uint)(sizeof(char *) *

1631

primary_keys_number_of),

1632

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1652

primary_keys= (char **)my_malloc((uint)(sizeof(char *) *

1653

primary_keys_number_of),

1654

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1633

1655

/* Yes, we strdup a const string to simplify the interface */

1634

primary_keys[0]= my_strdup("796c4422-1d94-102a-9d6d-00e0812d", MYF(0));

1656

primary_keys[0]= my_strdup("796c4422-1d94-102a-9d6d-00e0812d", MYF(0));

1635

1657

}

1636

1658

else

1637

1659

{

1638

if (run_query(drizzle, "SELECT id from t1", strlen("SELECT id from t1")))

1660

if (run_query(mysql, "SELECT id from t1", strlen("SELECT id from t1")))

1639

1661

{

1640

1662

fprintf(stderr,"%s: Cannot select GUID primary keys. (%s)\n", my_progname,

1641

drizzle_error(drizzle));

1663

mysql_error(mysql));

1642

1664

exit(1);

1643

1665

}

1644

1666

1645

result= drizzle_store_result(drizzle);

1646

primary_keys_number_of= drizzle_num_rows(result);

1667

result= mysql_store_result(mysql);

1668

primary_keys_number_of= mysql_num_rows(result);

1647

1669

1648

1670

/* So why check this? Blackhole :) */

1649

1671

if (primary_keys_number_of)

1651

1673

1652

1674

We create the structure and loop and create the items.

1653

1675

1654

primary_keys= (char **)my_malloc((uint)(sizeof(char *) *

1655

primary_keys_number_of),

1676

primary_keys= (char **)my_malloc((uint)(sizeof(char *) *

1677

primary_keys_number_of),

1656

1678

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

1657

row= drizzle_fetch_row(result);

1658

for (counter= 0; counter < primary_keys_number_of;

1659

counter++, row= drizzle_fetch_row(result))

1679

row= mysql_fetch_row(result);

1680

for (counter= 0; counter < primary_keys_number_of;

1681

counter++, row= mysql_fetch_row(result))

1660

1682

primary_keys[counter]= my_strdup(row[0], MYF(0));

1661

1683

}

1662

1684

1663

drizzle_free_result(result);

1685

mysql_free_result(result);

1664

1686

}

1665

1687

1666

1688

return(0);

1669

1691

static int

1670

1692

drop_primary_key_list(void)

1671

1693

{

1672

uint64_t counter;

1694

unsigned long long counter;

1673

1695

1674

1696

if (primary_keys_number_of)

1675

1697

{

1676

1698

for (counter= 0; counter < primary_keys_number_of; counter++)

1677

free(primary_keys[counter]);

1699

my_free(primary_keys[counter], MYF(0));

1678

1700

1679

free(primary_keys);

1701

my_free(primary_keys, MYF(0));

1680

1702

}

1681

1703

1682

1704

return 0;

1683

1705

}

1684

1706

1685

1707

static int

1686

create_schema(DRIZZLE *drizzle, const char *db, statement *stmt,

1708

create_schema(MYSQL *mysql, const char *db, statement *stmt,

1687

1709

option_string *engine_stmt, stats *sptr)

1688

1710

{

1689

1711

char query[HUGE_STRING_LENGTH];

1701

1723

if (verbose >= 2)

1702

1724

printf("Loading Pre-data\n");

1703

1725

1704

if (run_query(drizzle, query, len))

1726

if (run_query(mysql, query, len))

1705

1727

{

1706

1728

fprintf(stderr,"%s: Cannot create schema %s : %s\n", my_progname, db,

1707

drizzle_error(drizzle));

1729

mysql_error(mysql));

1708

1730

exit(1);

1709

1731

}

1710

1732

else

1721

1743

if (verbose >= 3)

1722

1744

printf("%s;\n", query);

1723

1745

1724

if (drizzle_select_db(drizzle, db))

1746

if (mysql_select_db(mysql, db))

1725

1747

{

1726

1748

fprintf(stderr,"%s: Cannot select schema '%s': %s\n",my_progname, db,

1727

drizzle_error(drizzle));

1749

mysql_error(mysql));

1728

1750

exit(1);

1729

1751

}

1730

1752

sptr->create_count++;

1734

1756

{

1735

1757

len= snprintf(query, HUGE_STRING_LENGTH, "set storage_engine=`%s`",

1736

1758

engine_stmt->string);

1737

if (run_query(drizzle, query, len))

1759

if (run_query(mysql, query, len))

1738

1760

{

1739

1761

fprintf(stderr,"%s: Cannot set default engine: %s\n", my_progname,

1740

drizzle_error(drizzle));

1762

mysql_error(mysql));

1741

1763

exit(1);

1742

1764

}

1743

1765

sptr->create_count++;

1756

1778

{

1757

1779

char buffer[HUGE_STRING_LENGTH];

1758

1780

1759

snprintf(buffer, HUGE_STRING_LENGTH, "%s %s", ptr->string,

1781

snprintf(buffer, HUGE_STRING_LENGTH, "%s %s", ptr->string,

1760

1782

engine_stmt->option);

1761

if (run_query(drizzle, buffer, strlen(buffer)))

1783

if (run_query(mysql, buffer, strlen(buffer)))

1762

1784

{

1763

1785

fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",

1764

my_progname, (uint)ptr->length, ptr->string, drizzle_error(drizzle));

1786

my_progname, (uint)ptr->length, ptr->string, mysql_error(mysql));

1765

1787

if (!opt_ignore_sql_errors)

1766

1788

exit(1);

1767

1789

}

1769

1791

}

1770

1792

else

1771

1793

{

1772

if (run_query(drizzle, ptr->string, ptr->length))

1794

if (run_query(mysql, ptr->string, ptr->length))

1773

1795

{

1774

1796

fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",

1775

my_progname, (uint)ptr->length, ptr->string, drizzle_error(drizzle));

1797

my_progname, (uint)ptr->length, ptr->string, mysql_error(mysql));

1776

1798

if (!opt_ignore_sql_errors)

1777

1799

exit(1);

1778

1800

}

1795

1817

}

1796

1818

1797

1819

static int

1798

drop_schema(DRIZZLE *drizzle, const char *db)

1820

drop_schema(MYSQL *mysql, const char *db)

1799

1821

{

1800

1822

char query[HUGE_STRING_LENGTH];

1801

1823

int len;

1802

1824

1803

1825

len= snprintf(query, HUGE_STRING_LENGTH, "DROP SCHEMA IF EXISTS `%s`", db);

1804

1826

1805

if (run_query(drizzle, query, len))

1827

if (run_query(mysql, query, len))

1806

1828

{

1807

1829

fprintf(stderr,"%s: Cannot drop database '%s' ERROR : %s\n",

1808

my_progname, db, drizzle_error(drizzle));

1830

my_progname, db, mysql_error(mysql));

1809

1831

exit(1);

1810

1832

}

1811

1833

1815

1837

}

1816

1838

1817

1839

static int

1818

run_statements(DRIZZLE *drizzle, statement *stmt)

1840

run_statements(MYSQL *mysql, statement *stmt)

1819

1841

{

1820

1842

statement *ptr;

1821

DRIZZLE_RES *result;

1843

MYSQL_RES *result;

1822

1844

1823

1845

1824

1846

for (ptr= stmt; ptr && ptr->length; ptr= ptr->next)

1825

1847

{

1826

if (run_query(drizzle, ptr->string, ptr->length))

1848

if (run_query(mysql, ptr->string, ptr->length))

1827

1849

{

1828

1850

fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",

1829

my_progname, (uint)ptr->length, ptr->string, drizzle_error(drizzle));

1851

my_progname, (uint)ptr->length, ptr->string, mysql_error(mysql));

1830

1852

exit(1);

1831

1853

}

1832

1854

if (!opt_only_print)

1833

1855

{

1834

if (drizzle_field_count(drizzle))

1856

if (mysql_field_count(mysql))

1835

1857

{

1836

result= drizzle_store_result(drizzle);

1837

drizzle_free_result(result);

1858

result= mysql_store_result(mysql);

1859

mysql_free_result(result);

1838

1860

}

1839

1861

}

1840

1862

}

1857

1879

1858

1880

pthread_attr_init(&attr);

1859

1881

pthread_attr_setdetachstate(&attr,

1860

PTHREAD_CREATE_DETACHED);

1882

PTHREAD_CREATE_DETACHED);

1861

1883

1862

1884

pthread_mutex_lock(&counter_mutex);

1863

1885

thread_counter= 0;

1868

1890

1869

1891

real_concurrency= 0;

1870

1892

1871

for (y= 0, sql_type= query_options;

1872

y < query_statements_count;

1893

for (y= 0, sql_type= query_options;

1894

y < query_statements_count;

1873

1895

y++, sql_type= sql_type->next)

1874

1896

{

1875

1897

unsigned int options_loop= 1;

1876

1898

1877

1899

if (sql_type->option)

1878

1900

{

1879

options_loop= strtol(sql_type->option,

1901

options_loop= strtol(sql_type->option,

1880

1902

(char **)NULL, 10);

1881

1903

options_loop= options_loop ? options_loop : 1;

1882

1904

}

1890

1912

1891

1913

real_concurrency++;

1892

1914

/* now you create the thread */

1893

if (pthread_create(&mainthread, &attr, run_task,

1915

if (pthread_create(&mainthread, &attr, run_task,

1894

1916

(void *)con) != 0)

1895

1917

{

1896

1918

fprintf(stderr,"%s: Could not create thread\n", my_progname);

1900

1922

}

1901

1923

}

1902

1924

1903

1904

The timer_thread belongs to all threads so it too obeys the wakeup

1925

1926

The timer_thread belongs to all threads so it too obeys the wakeup

1905

1927

call that run tasks obey.

1906

1928

1907

1929

if (opt_timer_length)

1910

1932

timer_alarm= true;

1911

1933

pthread_mutex_unlock(&timer_alarm_mutex);

1912

1934

1913

if (pthread_create(&mainthread, &attr, timer_thread,

1935

if (pthread_create(&mainthread, &attr, timer_thread,

1914

1936

(void *)&opt_timer_length) != 0)

1915

1937

{

1916

1938

fprintf(stderr,"%s: Could not create timer thread\n", my_progname);

1959

1981

struct timespec abstime;

1960

1982

1961

1983

1962

1963

We lock around the initial call in case were we in a loop. This

1984

1985

if (mysql_thread_init())

1986

{

1987

fprintf(stderr,"%s: mysql_thread_init() failed.\n",

1988

my_progname);

1989

exit(1);

1990

}

1991

1992

1993

We lock around the initial call in case were we in a loop. This

1964

1994

also keeps the value properly syncronized across call threads.

1965

1995

1966

1996

pthread_mutex_lock(&sleeper_mutex);

1980

2010

timer_alarm= false;

1981

2011

pthread_mutex_unlock(&timer_alarm_mutex);

1982

2012

2013

mysql_thread_end();

1983

2014

return(0);

1984

2015

}

1985

2016

1988

2019

uint64_t counter= 0, queries;

1989

2020

uint64_t detach_counter;

1990

2021

unsigned int commit_counter;

1991

DRIZZLE drizzle;

1992

DRIZZLE_RES *result;

1993

DRIZZLE_ROW row;

2022

MYSQL mysql;

2023

MYSQL_RES *result;

2024

MYSQL_ROW row;

1994

2025

statement *ptr;

1995

2026

thread_context *con= (thread_context *)p;

1996

2027

2028

if (mysql_thread_init())

2029

{

2030

fprintf(stderr,"%s: mysql_thread_init() failed.\n",

2031

my_progname);

2032

exit(1);

2033

}

2034

1997

2035

pthread_mutex_lock(&sleeper_mutex);

1998

2036

while (master_wakeup)

1999

2037

{

2001

2039

}

2002

2040

pthread_mutex_unlock(&sleeper_mutex);

2003

2041

2004

slap_connect(&drizzle, true);

2042

slap_connect(&mysql, true);

2005

2043

2006

2044

if (verbose >= 3)

2007

2045

printf("connected!\n");

2009

2047

2010

2048

commit_counter= 0;

2011

2049

if (commit_rate)

2012

run_query(&drizzle, "SET AUTOCOMMIT=0", strlen("SET AUTOCOMMIT=0"));

2050

run_query(&mysql, "SET AUTOCOMMIT=0", strlen("SET AUTOCOMMIT=0"));

2013

2051

2014

2052

limit_not_met:

2015

for (ptr= con->stmt, detach_counter= 0;

2016

ptr && ptr->length;

2017

ptr= ptr->next, detach_counter++)

2018

{

2019

if (!opt_only_print && detach_rate && !(detach_counter % detach_rate))

2020

{

2021

slap_close(&drizzle);

2022

slap_connect(&drizzle, true);

2023

}

2024

2025

2026

We have to execute differently based on query type. This should become a function.

2027

2028

if ((ptr->type == UPDATE_TYPE_REQUIRES_PREFIX) ||

2029

(ptr->type == SELECT_TYPE_REQUIRES_PREFIX))

2030

{

2031

int length;

2032

unsigned int key_val;

2033

char *key;

2034

char buffer[HUGE_STRING_LENGTH];

2035

2036

2037

This should only happen if some sort of new engine was

2038

implemented that didn't properly handle UPDATEs.

2039

2040

Just in case someone runs this under an experimental engine we don't

2041

want a crash so the if() is placed here.

2053

for (ptr= con->stmt, detach_counter= 0;

2054

ptr && ptr->length;

2055

ptr= ptr->next, detach_counter++)

2056

{

2057

if (!opt_only_print && detach_rate && !(detach_counter % detach_rate))

2058

{

2059

slap_close(&mysql);

2060

slap_connect(&mysql, true);

2061

}

2062

2063

2064

We have to execute differently based on query type. This should become a function.

2042

2065

2043

assert(primary_keys_number_of);

2044

if (primary_keys_number_of)

2045

{

2046

key_val= (unsigned int)(random() % primary_keys_number_of);

2047

key= primary_keys[key_val];

2048

2049

assert(key);

2050

2051

length= snprintf(buffer, HUGE_STRING_LENGTH, "%.*s '%s'",

2052

(int)ptr->length, ptr->string, key);

2053

2054

if (run_query(&drizzle, buffer, length))

2066

if ((ptr->type == UPDATE_TYPE_REQUIRES_PREFIX) ||

2067

(ptr->type == SELECT_TYPE_REQUIRES_PREFIX))

2068

{

2069

int length;

2070

unsigned int key_val;

2071

char *key;

2072

char buffer[HUGE_STRING_LENGTH];

2073

2074

2075

This should only happen if some sort of new engine was

2076

implemented that didn't properly handle UPDATEs.

2077

2078

Just in case someone runs this under an experimental engine we don't

2079

want a crash so the if() is placed here.

2080

2081

assert(primary_keys_number_of);

2082

if (primary_keys_number_of)

2083

{

2084

key_val= (unsigned int)(random() % primary_keys_number_of);

2085

key= primary_keys[key_val];

2086

2087

assert(key);

2088

2089

length= snprintf(buffer, HUGE_STRING_LENGTH, "%.*s '%s'",

2090

(int)ptr->length, ptr->string, key);

2091

2092

if (run_query(&mysql, buffer, length))

2093

{

2094

fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",

2095

my_progname, (uint)length, buffer, mysql_error(&mysql));

2096

exit(1);

2097

}

2098

}

2099

}

2100

else

2101

{

2102

if (run_query(&mysql, ptr->string, ptr->length))

2055

2103

{

2056

2104

fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",

2057

my_progname, (uint)length, buffer, drizzle_error(&drizzle));

2105

my_progname, (uint)ptr->length, ptr->string, mysql_error(&mysql));

2058

2106

exit(1);

2059

2107

}

2060

2108

}

2061

}

2062

else

2063

{

2064

if (run_query(&drizzle, ptr->string, ptr->length))

2065

{

2066

fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",

2067

my_progname, (uint)ptr->length, ptr->string, drizzle_error(&drizzle));

2068

exit(1);

2069

}

2070

}

2071

2109

2072

if (!opt_only_print)

2073

{

2074

2110

if (!opt_only_print)

2075

2111

{

2076

if (drizzle_field_count(&drizzle))

2112

2077

2113

{

2078

result= drizzle_store_result(&drizzle);

2079

while ((row = drizzle_fetch_row(result)))

2080

counter++;

2081

drizzle_free_result(result);

2082

}

2083

} while(drizzle_next_result(&drizzle) == 0);

2084

}

2085

queries++;

2086

2087

if (commit_rate && (++commit_counter == commit_rate))

2088

{

2089

commit_counter= 0;

2090

run_query(&drizzle, "COMMIT", strlen("COMMIT"));

2091

}

2092

2093

/* If the timer is set, and the alarm is not active then end */

2094

if (opt_timer_length && timer_alarm == false)

2095

goto end;

2096

2097

/* If limit has been reached, and we are not in a timer_alarm just end */

2098

if (con->limit && queries == con->limit && timer_alarm == false)

2099

goto end;

2100

}

2101

2102

if (opt_timer_length && timer_alarm == true)

2103

goto limit_not_met;

2104

2105

if (con->limit && queries < con->limit)

2106

goto limit_not_met;

2114

if (mysql_field_count(&mysql))

2115

{

2116

result= mysql_store_result(&mysql);

2117

while ((row = mysql_fetch_row(result)))

2118

counter++;

2119

mysql_free_result(result);

2120

}

2121

} while(mysql_next_result(&mysql) == 0);

2122

}

2123

queries++;

2124

2125

if (commit_rate && (++commit_counter == commit_rate))

2126

{

2127

commit_counter= 0;

2128

run_query(&mysql, "COMMIT", strlen("COMMIT"));

2129

}

2130

2131

/* If the timer is set, and the alarm is not active then end */

2132

if (opt_timer_length && timer_alarm == false)

2133

goto end;

2134

2135

/* If limit has been reached, and we are not in a timer_alarm just end */

2136

if (con->limit && queries == con->limit && timer_alarm == false)

2137

goto end;

2138

}

2139

2140

if (opt_timer_length && timer_alarm == true)

2141

goto limit_not_met;

2142

2143

if (con->limit && queries < con->limit)

2144

goto limit_not_met;

2107

2145

2108

2146

2109

2147

end:

2110

2148

if (commit_rate)

2111

run_query(&drizzle, "COMMIT", strlen("COMMIT"));

2149

run_query(&mysql, "COMMIT", strlen("COMMIT"));

2112

2150

2113

slap_close(&drizzle);

2151

slap_close(&mysql);

2114

2152

2115

2153

pthread_mutex_lock(&counter_mutex);

2116

2154

thread_counter--;

2117

2155

pthread_cond_signal(&count_threshhold);

2118

2156

pthread_mutex_unlock(&counter_mutex);

2119

2157

2120

free(con);

2158

my_free(con, MYF(0));

2121

2159

2160

mysql_thread_end();

2122

2161

return(0);

2123

2162

}

2124

2163

2149

2188

char buffer[HUGE_STRING_LENGTH];

2150

2189

char *buffer_ptr;

2151

2190

2152

memset(buffer, 0, HUGE_STRING_LENGTH);

2191

bzero(buffer, HUGE_STRING_LENGTH);

2153

2192

2154

string= strchr(begin_ptr, delm);

2193

string= strchr(begin_ptr, delm);

2155

2194

2156

2195

if (string)

2157

2196

{

2210

2249

2211

2250

for (tmp= *sptr= (statement *)my_malloc(sizeof(statement),

2212

2251

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

2213

(retstr= strchr(ptr, delm));

2252

(retstr= strchr(ptr, delm));

2214

2253

tmp->next= (statement *)my_malloc(sizeof(statement),

2215

2254

MYF(MY_ZEROFILL|MY_FAE|MY_WME)),

2216

tmp= tmp->next)

2255

tmp= tmp->next)

2217

2256

{

2218

2257

count++;

2219

2258

tmp->string= my_strndup(ptr, (uint)(retstr - ptr), MYF(MY_FAE));

2225

2264

2226

2265

if (ptr != script+length)

2227

2266

{

2228

tmp->string= my_strndup(ptr, (uint)((script + length) - ptr),

2229

MYF(MY_FAE));

2267

tmp->string= my_strndup(ptr, (uint)((script + length) - ptr),

2268

MYF(MY_FAE));

2230

2269

tmp->length= (size_t)((script + length) - ptr);

2231

2270

count++;

2232

2271

}

2250

2289

2251

2290

for (;*ptr; ptr++)

2252

2291

if (*ptr == ',') count++;

2253

2292

2254

2293

/* One extra spot for the NULL */

2255

nptr= *range= (uint *)my_malloc(sizeof(uint) * (count + 1),

2294

nptr= *range= (uint *)my_malloc(sizeof(uint) * (count + 1),

2256

2295

MYF(MY_ZEROFILL|MY_FAE|MY_WME));

2257

2296

2258

2297

ptr= (char *)string;

2272

2311

{

2273

2312

printf("Benchmark\n");

2274

2313

if (con->engine)

2275

printf("\tRunning for engine %s\n", con->engine);

2314

printf("\tRunning for engine %s\n", con->engine);

2276

2315

if (opt_label || opt_auto_generate_sql_type)

2277

2316

{

2278

2317

const char *ptr= opt_auto_generate_sql_type ? opt_auto_generate_sql_type : "query";

2286

2325

con->min_timing / 1000, con->min_timing % 1000);

2287

2326

printf("\tMaximum number of seconds to run all queries: %ld.%03ld seconds\n",

2288

2327

con->max_timing / 1000, con->max_timing % 1000);

2289

printf("\tTotal time for tests: %ld.%03ld seconds\n",

2328

printf("\tTotal time for tests: %ld.%03ld seconds\n",

2290

2329

con->sum_of_time / 1000, con->sum_of_time % 1000);

2291

2330

printf("\tStandard Deviation: %ld.%03ld\n", con->std_dev / 1000, con->std_dev % 1000);

2292

printf("\tNumber of queries in create queries: %"PRIu64"\n", con->create_count);

2293

printf("\tNumber of clients running queries: %u/%u\n",

2331

printf("\tNumber of queries in create queries: %llu\n", con->create_count);

2332

printf("\tNumber of clients running queries: %u/%u\n",

2294

2333

con->users, con->real_users);

2295

2334

printf("\tNumber of times test was run: %u\n", iterations);

2296

printf("\tAverage number of queries per client: %"PRIu64"\n", con->avg_rows);

2335

printf("\tAverage number of queries per client: %llu\n", con->avg_rows);

2297

2336

printf("\n");

2298

2337

}

2299

2338

2305

2344

char label_buffer[HUGE_STRING_LENGTH];

2306

2345

size_t string_len;

2307

2346

2308

memset(label_buffer, 0, HUGE_STRING_LENGTH);

2347

bzero(label_buffer, HUGE_STRING_LENGTH);

2309

2348

2310

2349

if (opt_label)

2311

2350

{

2318

2357

else

2319

2358

label_buffer[x]= opt_label[x] ;

2320

2359

}

2321

}

2360

}

2322

2361

else if (opt_auto_generate_sql_type)

2323

2362

{

2324

2363

string_len= strlen(opt_auto_generate_sql_type);

2334

2373

else

2335

2374

snprintf(label_buffer, HUGE_STRING_LENGTH, "query");

2336

2375

2337

snprintf(buffer, HUGE_STRING_LENGTH,

2338

"%s,%s,%ld.%03ld,%ld.%03ld,%ld.%03ld,%ld.%03ld,%ld.%03ld,"

2339

"%u,%u,%u,%"PRIu64"\n",

2376

snprintf(buffer, HUGE_STRING_LENGTH,

2377

"%s,%s,%ld.%03ld,%ld.%03ld,%ld.%03ld,%ld.%03ld,%ld.%03ld,%u,%u,%u,%llu\n",

2340

2378

con->engine ? con->engine : "", /* Storage engine we ran against */

2341

2379

label_buffer, /* Load type */

2342

2380

con->avg_timing / 1000, con->avg_timing % 1000, /* Time to load */

2348

2386

con->users, /* Children used max_timing */

2349

2387

con->real_users, /* Children used max_timing */

2350

2388

con->avg_rows /* Queries run */

2351

);

2352

my_write(csv_file, (unsigned char*) buffer, (uint)strlen(buffer), MYF(0));

2389

);

2390

my_write(csv_file, (uchar*) buffer, (uint)strlen(buffer), MYF(0));

2353

2391

}

2354

2392

2355

2393

void

2358

2396

stats *ptr;

2359

2397

unsigned int x;

2360

2398

2361

con->min_timing= sptr->timing;

2399

con->min_timing= sptr->timing;

2362

2400

con->max_timing= sptr->timing;

2363

2401

con->min_rows= sptr->rows;

2364

2402

con->max_rows= sptr->rows;

2365

2403

2366

2404

/* At the moment we assume uniform */

2367

2405

con->users= sptr->users;

2368

2406

con->real_users= sptr->real_users;

2369

2407

con->avg_rows= sptr->rows;

2370

2408

2371

2409

/* With no next, we know it is the last element that was malloced */

2372

2410

for (ptr= sptr, x= 0; x < iterations; ptr++, x++)

2373

2411

{

2389

2427

standard_deviation(con, sptr);

2390

2428

2391

2429

/* Now we do the create time operations */

2392

con->create_min_timing= sptr->create_timing;

2430

con->create_min_timing= sptr->create_timing;

2393

2431

con->create_max_timing= sptr->create_timing;

2394

2432

2395

2433

/* At the moment we assume uniform */

2396

2434

con->create_count= sptr->create_count;

2397

2435

2398

2436

/* With no next, we know it is the last element that was malloced */

2399

2437

for (ptr= sptr, x= 0; x < iterations; ptr++, x++)

2400

2438

{

2419

2457

{

2420

2458

nptr= ptr->next;

2421

2459

if (ptr->string)

2422

free(ptr->string);

2460

my_free(ptr->string, MYF(0));

2423

2461

if (ptr->option)

2424

free(ptr->option);

2425

free(ptr);

2462

my_free(ptr->option, MYF(0));

2463

my_free(ptr, MYF(0));

2426

2464

}

2427

2465

}

2428

2466

2437

2475

{

2438

2476

nptr= ptr->next;

2439

2477

if (ptr->string)

2440

free(ptr->string);

2441

free(ptr);

2478

my_free(ptr->string, MYF(0));

2479

my_free(ptr, MYF(0));

2442

2480

}

2443

2481

}

2444

2482

2445

void

2446

slap_close(DRIZZLE *drizzle)

2483

void

2484

slap_close(MYSQL *mysql)

2447

2485

{

2448

if (opt_only_print)

2486

if (opt_only_print)

2449

2487

return;

2450

2488

2451

drizzle_close(drizzle);

2489

mysql_close(mysql);

2452

2490

}

2453

2491

2454

void

2455

slap_connect(DRIZZLE *drizzle, bool connect_to_schema)

2492

void

2493

slap_connect(MYSQL *mysql, bool connect_to_schema)

2456

2494

{

2457

2495

/* Connect to server */

2458

static uint32_t connection_retry_sleep= 100000; /* Microseconds */

2496

static ulong connection_retry_sleep= 100000; /* Microseconds */

2459

2497

int x, connect_error= 1;

2460

2498

2461

if (opt_only_print)

2499

if (opt_only_print)

2462

2500

return;

2463

2501

2464

2502

if (opt_delayed_start)

2465

2503

my_sleep(random()%opt_delayed_start);

2466

2504

2467

drizzle_create(drizzle);

2505

mysql_init(mysql);

2468

2506

2469

2507

if (opt_compress)

2470

drizzle_options(drizzle,DRIZZLE_OPT_COMPRESS,NULL);

2508

mysql_options(mysql,MYSQL_OPT_COMPRESS,NullS);

2509

/* We always do opt_protocol to TCP/IP */

2510

mysql_options(mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);

2511

mysql_options(mysql, MYSQL_SET_CHARSET_NAME, default_charset);

2471

2512

2472

2513

for (x= 0; x < 10; x++)

2473

2514

{

2474

2515

2475

2516

2476

if (drizzle_connect(drizzle, host, user, opt_password,

2477

connect_to_schema ? create_schema_string : NULL,

2478

opt_drizzle_port,

2479

opt_drizzle_unix_port,

2480

connect_flags))

2517

if (mysql_real_connect(mysql, host, user, opt_password,

2518

connect_to_schema ? create_schema_string : NULL,

2519

opt_mysql_port,

2520

opt_mysql_unix_port,

2521

connect_flags))

2481

2522

{

2482

2523

/* Connect suceeded */

2483

2524

connect_error= 0;

2488

2529

if (connect_error)

2489

2530

{

2490

2531

fprintf(stderr,"%s: Error when connecting to server: %d %s\n",

2491

my_progname, drizzle_errno(drizzle), drizzle_error(drizzle));

2532

my_progname, mysql_errno(mysql), mysql_error(mysql));

2492

2533

exit(1);

2493

2534

}

2494

2535

2495

2536

return;

2496

2537

}

2497

2538

2498

void

2539

void

2499

2540

standard_deviation (conclusions *con, stats *sptr)

2500

2541

{

2501

2542

unsigned int x;

2502

2543

long int sum_of_squares;

2503

double the_catch;

2544

double catch;

2504

2545

stats *ptr;

2505

2546

2506

2547

if (iterations == 1 || iterations == 0)

2517

2558

sum_of_squares+= deviation*deviation;

2518

2559

}

2519

2560

2520

the_catch= sqrt((double)(sum_of_squares/(iterations -1)));

2521

con->std_dev= (long int)the_catch;

2561

catch= sqrt((double)(sum_of_squares/(iterations -1)));

2562

con->std_dev= (long int)catch;

2522

2563

}

Older »