MySQL 5.1: mysql/src/5.1-dbg/client/mysqlslap.c File Reference

mysql/src/5.1-dbg/client/mysqlslap.c File Reference

#include "client_priv.h"
#include <my_sys.h>
#include <m_string.h>
#include <mysql.h>
#include <mysqld_error.h>
#include <my_dir.h>
#include <signal.h>
#include <stdarg.h>
#include <sslopt-vars.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
#include <sslopt-longopts.h>
#include <help_start.h>
#include <help_end.h>
#include <sslopt-case.h>

Include dependency graph for mysqlslap.c:

Go to the source code of this file.


Classes
struct	statement
struct	stats
struct	thread_context
struct	conclusions
Defines
#define	SHOW_VERSION "0.9"
#define	HUGE_STRING_LENGTH 8096
#define	RAND_STRING_SIZE 126
#define	MYSLAPLOCK "/myslaplock.lck"
#define	MYSLAPLOCK_DIR "/tmp"
#define	ALPHANUMERICS_SIZE (sizeof(ALPHANUMERICS)-1)
Typedefs
typedef statement	statement
typedef stats	stats
typedef thread_context	thread_context
typedef conclusions	conclusions
Functions
static int	get_options (int argc, char **argv)
void	print_conclusions (conclusions *con)
void	print_conclusions_csv (conclusions *con)
void	generate_stats (conclusions con, statement eng, stats *sptr)
uint	parse_comma (const char string, uint *range)
uint	parse_delimiter (const char script, statement *stmt, char delm)
static int	drop_schema (MYSQL mysql, const char db)
uint	get_random_string (char *buf)
static statement *	build_table_string (void)
static statement *	build_insert_string (void)
static statement *	build_query_string (void)
static int	create_schema (MYSQL mysql, const char db, statement stmt, statement engine_stmt)
static int	run_scheduler (stats sptr, statement stmts, uint concur, ulonglong limit)
int	run_task (thread_context *con)
void	statement_cleanup (statement *stmt)
static long int	timedif (struct timeval a, struct timeval b)
int	main (int argc, char **argv)
static void	print_version (void)
static void	usage (void)
static my_bool	get_one_option (int optid, const struct my_option opt __attribute__((unused)), char argument)
static int	run_query (MYSQL mysql, const char query, int len)
Variables
static char **	defaults_argv
static char *	host = NULL
static char *	opt_password = NULL
static char *	user = NULL
static char *	user_supplied_query = NULL
static char *	default_engine = NULL
static char *	opt_mysql_unix_port = NULL
const char *	delimiter = "\n"
const char *	create_schema_string = "mysqlslap"
const char *	lock_directory
char	lock_file_str [FN_REFLEN]
static my_bool	opt_preserve
static my_bool	opt_only_print = FALSE
static my_bool	opt_slave
static my_bool	opt_compress = FALSE
static my_bool	tty_password = FALSE
static my_bool	opt_silent = FALSE
static my_bool	auto_generate_sql = FALSE
static unsigned long	connect_flags = CLIENT_MULTI_RESULTS
static int	verbose
static int	num_int_cols
static int	num_char_cols
static int	delimiter_length
static int	iterations
static char *	default_charset = (char*) MYSQL_DEFAULT_CHARSET_NAME
static ulonglong	actual_queries = 0
static ulonglong	num_of_query
const char *	concurrency_str = NULL
static char *	create_string
uint *	concurrency
const char *	default_dbug_option = "d:t:o,/tmp/mysqlslap.trace"
const char *	opt_csv_str
File	csv_file
static uint	opt_protocol = 0
static uint	opt_mysql_port = 0
static uint	opt_use_threads
static const char *	load_default_groups [] = { "mysqlslap","client",0 }
static statement *	create_statements = NULL
static statement *	engine_statements = NULL
static statement *	query_statements = NULL
static const char	ALPHANUMERICS []
static struct my_option	my_long_options []

Define Documentation

#define ALPHANUMERICS_SIZE (sizeof(ALPHANUMERICS)-1)

Definition at line 219 of file mysqlslap.c.

Referenced by get_random_string().

#define HUGE_STRING_LENGTH 8096

Definition at line 75 of file mysqlslap.c.

Referenced by create_schema(), drop_schema(), and print_conclusions_csv().

#define MYSLAPLOCK "/myslaplock.lck"

Definition at line 96 of file mysqlslap.c.

Referenced by get_options().

#define MYSLAPLOCK_DIR "/tmp"

Definition at line 97 of file mysqlslap.c.

Referenced by get_options().

#define RAND_STRING_SIZE 126

Definition at line 76 of file mysqlslap.c.

Referenced by build_insert_string(), and get_random_string().

#define SHOW_VERSION "0.9"

Definition at line 73 of file mysqlslap.c.

Typedef Documentation

typedef struct conclusions conclusions

Definition at line 180 of file mysqlslap.c.

typedef struct statement statement

Definition at line 156 of file mysqlslap.c.

typedef struct stats stats

Definition at line 164 of file mysqlslap.c.

typedef struct thread_context thread_context

Definition at line 172 of file mysqlslap.c.

Function Documentation

static statement * build_insert_string ( void ) [static]

Definition at line 655 of file mysqlslap.c.

References buf, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, dynstr_append(), dynstr_append_mem(), dynstr_free(), get_random_string(), init_dynamic_string(), statement::length, st_dynamic_string::length, my_malloc(), MY_WME, MY_ZEROFILL, MYF, num_char_cols, num_int_cols, RAND_STRING_SIZE, st_dynamic_string::str, statement::string, and strmov().

Referenced by get_options().

00656 {
00657   char       buf[RAND_STRING_SIZE];
00658   int        col_count;
00659   statement *ptr;
00660   DYNAMIC_STRING insert_string;
00661   DBUG_ENTER("build_insert_string");
00662 
00663   init_dynamic_string(&insert_string, "", 1024, 1024);
00664 
00665   dynstr_append_mem(&insert_string, "INSERT INTO t1 VALUES (", 23);
00666   for (col_count= 1; col_count <= num_int_cols; col_count++)
00667   {
00668     sprintf(buf, "%ld", random());
00669     dynstr_append(&insert_string, buf);
00670 
00671     if (col_count < num_int_cols || num_char_cols > 0)
00672       dynstr_append_mem(&insert_string, ",", 1);
00673   }
00674   for (col_count= 1; col_count <= num_char_cols; col_count++)
00675   {
00676     int buf_len= get_random_string(buf);
00677     dynstr_append_mem(&insert_string, "'", 1);
00678     dynstr_append_mem(&insert_string, buf, buf_len);
00679     dynstr_append_mem(&insert_string, "'", 1);
00680 
00681     if (col_count < num_char_cols)
00682       dynstr_append_mem(&insert_string, ",", 1);
00683   }
00684   dynstr_append_mem(&insert_string, ")", 1);
00685 
00686   ptr= (statement *)my_malloc(sizeof(statement), MYF(MY_ZEROFILL));
00687   ptr->string= (char *)my_malloc(insert_string.length+1, MYF(MY_WME));
00688   ptr->length= insert_string.length+1;
00689   strmov(ptr->string, insert_string.str);
00690   DBUG_PRINT("info", ("generated_insert_data %s", ptr->string));
00691   dynstr_free(&insert_string);
00692   DBUG_RETURN(ptr);
00693 }

Here is the call graph for this function:

Here is the caller graph for this function:

static statement * build_query_string ( void ) [static]

Definition at line 703 of file mysqlslap.c.

References buf, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, dynstr_append(), dynstr_append_mem(), dynstr_free(), init_dynamic_string(), statement::length, st_dynamic_string::length, my_malloc(), MY_WME, MY_ZEROFILL, MYF, num_char_cols, num_int_cols, st_dynamic_string::str, statement::string, and strmov().

Referenced by get_options().

00704 {
00705   char       buf[512];
00706   int        col_count;
00707   statement *ptr;
00708   static DYNAMIC_STRING query_string;
00709   DBUG_ENTER("build_query_string");
00710 
00711   init_dynamic_string(&query_string, "", 1024, 1024);
00712 
00713   dynstr_append_mem(&query_string, "SELECT ", 7);
00714   for (col_count= 1; col_count <= num_int_cols; col_count++)
00715   {
00716     sprintf(buf, "intcol%d", col_count);
00717     dynstr_append(&query_string, buf);
00718 
00719     if (col_count < num_int_cols || num_char_cols > 0)
00720       dynstr_append_mem(&query_string, ",", 1);
00721 
00722   }
00723   for (col_count= 1; col_count <= num_char_cols; col_count++)
00724   {
00725     sprintf(buf, "charcol%d", col_count);
00726     dynstr_append(&query_string, buf);
00727 
00728     if (col_count < num_char_cols)
00729       dynstr_append_mem(&query_string, ",", 1);
00730 
00731   }
00732   dynstr_append_mem(&query_string, " FROM t1", 8);
00733   ptr= (statement *)my_malloc(sizeof(statement), MYF(MY_ZEROFILL));
00734   ptr->string= (char *)my_malloc(query_string.length+1, MYF(MY_WME));
00735   ptr->length= query_string.length+1;
00736   strmov(ptr->string, query_string.str);
00737   DBUG_PRINT("info", ("user_supplied_query %s", ptr->string));
00738   dynstr_free(&query_string);
00739   DBUG_RETURN(ptr);
00740 }

Here is the call graph for this function:

Here is the caller graph for this function:

static statement * build_table_string ( void ) [static]

Definition at line 607 of file mysqlslap.c.

References buf, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, dynstr_append(), dynstr_free(), init_dynamic_string(), statement::length, st_dynamic_string::length, my_malloc(), MY_WME, MY_ZEROFILL, MYF, num_char_cols, num_int_cols, st_dynamic_string::str, statement::string, and strmov().

Referenced by get_options().

00608 {
00609   char       buf[512];
00610   int        col_count;
00611   statement *ptr;
00612   DYNAMIC_STRING table_string;
00613   DBUG_ENTER("build_table_string");
00614 
00615   DBUG_PRINT("info", ("num int cols %d num char cols %d",
00616                       num_int_cols, num_char_cols));
00617 
00618   init_dynamic_string(&table_string, "", 1024, 1024);
00619 
00620   dynstr_append(&table_string, "CREATE TABLE `t1` (");
00621   for (col_count= 1; col_count <= num_int_cols; col_count++)
00622   {
00623     sprintf(buf, "intcol%d INT(32)", col_count); 
00624     dynstr_append(&table_string, buf);
00625 
00626     if (col_count < num_int_cols || num_char_cols > 0)
00627       dynstr_append(&table_string, ",");
00628   }
00629   for (col_count= 1; col_count <= num_char_cols; col_count++)
00630   {
00631     sprintf(buf, "charcol%d VARCHAR(128)", col_count);
00632     dynstr_append(&table_string, buf);
00633 
00634     if (col_count < num_char_cols)
00635       dynstr_append(&table_string, ",");
00636   }
00637   dynstr_append(&table_string, ")");
00638   ptr= (statement *)my_malloc(sizeof(statement), MYF(MY_ZEROFILL));
00639   ptr->string = (char *)my_malloc(table_string.length+1, MYF(MY_WME));
00640   ptr->length= table_string.length+1;
00641   strmov(ptr->string, table_string.str);
00642   DBUG_PRINT("info", ("create_string %s", ptr->string));
00643   dynstr_free(&table_string);
00644   DBUG_RETURN(ptr);
00645 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int create_schema	(	MYSQL *	mysql,
		const char *	db,
		statement *	stmt,
		statement *	engine_stmt
	)			`[static]`

Definition at line 900 of file mysqlslap.c.

References DBUG_ENTER, DBUG_PRINT, exit, HUGE_STRING_LENGTH, statement::length, my_progname, mysql, mysql_error(), mysql_select_db(), statement::next, opt_only_print, run_query(), statement::string, and verbose.

Referenced by main().

00902 {
00903   char query[HUGE_STRING_LENGTH];
00904   statement *ptr;
00905   int len;
00906   DBUG_ENTER("create_schema");
00907 
00908   len= snprintf(query, HUGE_STRING_LENGTH, "CREATE SCHEMA `%s`", db);
00909   DBUG_PRINT("info", ("query %s", query)); 
00910 
00911   if (run_query(mysql, query, len))
00912   {
00913     fprintf(stderr,"%s: Cannot create schema %s : %s\n", my_progname, db,
00914             mysql_error(mysql));
00915     exit(1);
00916   }
00917 
00918   if (opt_only_print)
00919   {
00920     printf("use %s;\n", db);
00921   }
00922   else
00923   {
00924     if (verbose >= 2)
00925       printf("%s;\n", query);
00926     if (mysql_select_db(mysql,  db))
00927     {
00928       fprintf(stderr,"%s: Cannot select schema '%s': %s\n",my_progname, db,
00929               mysql_error(mysql));
00930       exit(1);
00931     }
00932   }
00933 
00934   if (engine_stmt)
00935   {
00936     len= snprintf(query, HUGE_STRING_LENGTH, "set storage_engine=`%s`",
00937                   engine_stmt->string);
00938     if (run_query(mysql, query, len))
00939     {
00940       fprintf(stderr,"%s: Cannot set default engine: %s\n", my_progname,
00941               mysql_error(mysql));
00942       exit(1);
00943     }
00944   }
00945 
00946   for (ptr= stmt; ptr && ptr->length; ptr= ptr->next)
00947   {
00948     if (run_query(mysql, ptr->string, ptr->length))
00949     {
00950       fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
00951               my_progname, (uint)ptr->length, ptr->string, mysql_error(mysql));
00952       exit(1);
00953     }
00954   }
00955 
00956   DBUG_RETURN(0);
00957 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int drop_schema	(	MYSQL *	mysql,
		const char *	db
	)			`[static]`

Definition at line 960 of file mysqlslap.c.

References DBUG_ENTER, DBUG_RETURN, exit, HUGE_STRING_LENGTH, my_progname, mysql, mysql_error(), and run_query().

Referenced by main().

00961 {
00962   char query[HUGE_STRING_LENGTH];
00963   int len;
00964   DBUG_ENTER("drop_schema");
00965   len= snprintf(query, HUGE_STRING_LENGTH, "DROP SCHEMA IF EXISTS `%s`", db);
00966 
00967   if (run_query(mysql, query, len))
00968   {
00969     fprintf(stderr,"%s: Cannot drop database '%s' ERROR : %s\n",
00970             my_progname, db, mysql_error(mysql));
00971     exit(1);
00972   }
00973 
00974 
00975 
00976   DBUG_RETURN(0);
00977 }

Here is the call graph for this function:

Here is the caller graph for this function:

void generate_stats	(	conclusions *	con,
		statement *	eng,
		stats *	sptr
	)

Definition at line 1312 of file mysqlslap.c.

References conclusions::avg_rows, conclusions::avg_timing, conclusions::engine, iterations, conclusions::max_rows, conclusions::max_timing, conclusions::min_rows, conclusions::min_timing, NULL, stats::rows, statement::string, stats::timing, stats::users, conclusions::users, and x.

Referenced by main().

01313 {
01314   stats *ptr;
01315   int x;
01316 
01317   con->min_timing= sptr->timing; 
01318   con->max_timing= sptr->timing;
01319   con->min_rows= sptr->rows;
01320   con->max_rows= sptr->rows;
01321   
01322   /* At the moment we assume uniform */
01323   con->users= sptr->users;
01324   con->avg_rows= sptr->rows;
01325   
01326   /* With no next, we know it is the last element that was malloced */
01327   for (ptr= sptr, x= 0; x < iterations; ptr++, x++)
01328   {
01329     con->avg_timing+= ptr->timing;
01330 
01331     if (ptr->timing > con->max_timing)
01332       con->max_timing= ptr->timing;
01333     if (ptr->timing < con->min_timing)
01334       con->min_timing= ptr->timing;
01335   }
01336   con->avg_timing= con->avg_timing/iterations;
01337 
01338   if (eng && eng->string)
01339     con->engine= eng->string;
01340   else
01341     con->engine= NULL;
01342 }

Here is the caller graph for this function:

static my_bool get_one_option	(	int	optid,
		const struct my_option *opt	__attribute__((unused)),
		char *	argument
	)			`[static]`

Definition at line 529 of file mysqlslap.c.

References DBUG_ENTER, DBUG_PUSH, DBUG_RETURN, default_dbug_option, exit, find_type(), MY_ALLOW_ZERO_PTR, MY_FAE, my_free, my_strdup(), MYF, MYSQL_PROTOCOL_PIPE, OPT_AUTO_CLOSE, OPT_MYSQL_PROTOCOL, opt_password, opt_protocol, print_version(), sql_protocol_typelib, start(), tty_password, usage(), and verbose.

00531 {
00532   DBUG_ENTER("get_one_option");
00533   switch(optid) {
00534 #ifdef __NETWARE__
00535   case OPT_AUTO_CLOSE:
00536     setscreenmode(SCR_AUTOCLOSE_ON_EXIT);
00537     break;
00538 #endif
00539   case 'v':
00540     verbose++;
00541     break;
00542   case 'p':
00543     if (argument)
00544     {
00545       char *start= argument;
00546       my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
00547       opt_password= my_strdup(argument,MYF(MY_FAE));
00548       while (*argument) *argument++= 'x';               /* Destroy argument */
00549       if (*start)
00550         start[1]= 0;                            /* Cut length of argument */
00551       tty_password= 0;
00552     }
00553     else
00554       tty_password= 1;
00555     break;
00556   case 'W':
00557 #ifdef __WIN__
00558     opt_protocol= MYSQL_PROTOCOL_PIPE;
00559 #endif
00560     break;
00561   case OPT_MYSQL_PROTOCOL:
00562     {
00563       if ((opt_protocol= find_type(argument, &sql_protocol_typelib,0)) <= 0)
00564       {
00565         fprintf(stderr, "Unknown option to protocol: %s\n", argument);
00566         exit(1);
00567       }
00568       break;
00569     }
00570   case '#':
00571     DBUG_PUSH(argument ? argument : default_dbug_option);
00572     break;
00573 #include <sslopt-case.h>
00574   case 'V':
00575     print_version();
00576     exit(0);
00577     break;
00578   case '?':
00579   case 'I':                                     /* Info */
00580     usage();
00581     exit(0);
00582   }
00583   DBUG_RETURN(0);
00584 }

Here is the call graph for this function:

static int get_options	(	int *	argc,
		char ***	argv
	)			`[static]`

Definition at line 743 of file mysqlslap.c.

References actual_queries, auto_generate_sql, build_insert_string(), build_query_string(), build_table_string(), concurrency, concurrency_str, create_statements, create_string, csv_file, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, default_engine, delimiter, engine_statements, exit, FALSE, FN_REFLEN, get_one_option(), get_tty_password(), handle_options(), lock_directory, lock_file_str, my_close(), my_free, my_long_options, my_malloc(), my_open(), my_progname, my_read, MY_S_ISREG, my_stat(), MY_STAT, MY_WME, MYF, MYSLAPLOCK, MYSLAPLOCK_DIR, statement::next, NullS, opt_csv_str, opt_only_print, opt_password, opt_preserve, opt_silent, parse_comma(), parse_delimiter(), query_statements, statement::string, TRUE, tty_password, user, user_supplied_query, and verbose.

00744 {
00745   int ho_error;
00746   char *tmp_string;
00747   MY_STAT sbuf;  /* Stat information for the data file */
00748 
00749   DBUG_ENTER("get_options");
00750   if ((ho_error= handle_options(argc, argv, my_long_options, get_one_option)))
00751     exit(ho_error);
00752 
00753   if (!user)
00754     user= (char *)"root";
00755 
00756   if (create_string || auto_generate_sql)
00757   {
00758     if (verbose >= 1)
00759       fprintf(stderr, "Turning off preserve-schema!\n");
00760     opt_preserve= FALSE;
00761   }
00762 
00763   if (auto_generate_sql && (create_string || user_supplied_query))
00764   {
00765       fprintf(stderr,
00766               "%s: Can't use --auto-generate-sql when create and query strings are specified!\n",
00767               my_progname);
00768       exit(1);
00769   }
00770 
00771   parse_comma(concurrency_str ? concurrency_str : "1", &concurrency);
00772 
00773   if (lock_directory)
00774     snprintf(lock_file_str, FN_REFLEN, "%s/%s", lock_directory, MYSLAPLOCK);
00775   else
00776     snprintf(lock_file_str, FN_REFLEN, "%s/%s", MYSLAPLOCK_DIR, MYSLAPLOCK);
00777 
00778   if (opt_csv_str)
00779   {
00780     opt_silent= TRUE;
00781     
00782     if (opt_csv_str[0] == '-')
00783     {
00784       csv_file= fileno(stdout);
00785     }
00786     else
00787     {
00788       if ((csv_file= my_open(opt_csv_str, O_CREAT|O_WRONLY|O_APPEND, MYF(0)))
00789           == -1)
00790       {
00791         fprintf(stderr,"%s: Could not open csv file: %sn\n",
00792                 my_progname, opt_csv_str);
00793         exit(1);
00794       }
00795     }
00796   }
00797 
00798   if (opt_only_print)
00799     opt_silent= TRUE;
00800 
00801   if (auto_generate_sql)
00802   {
00803       create_statements= build_table_string();
00804       query_statements= build_insert_string();
00805       DBUG_PRINT("info", ("auto-generated insert is %s", query_statements->string));
00806       query_statements->next= build_query_string();
00807       DBUG_PRINT("info", ("auto-generated is %s", query_statements->next->string));
00808       if (verbose >= 1)
00809       {
00810         fprintf(stderr, "auto-generated insert is:\n");
00811         fprintf(stderr,  "%s\n", query_statements->string);
00812         fprintf(stderr, "auto-generated is:\n");
00813         fprintf(stderr,  "%s\n", query_statements->next->string);
00814       }
00815 
00816   }
00817   else
00818   {
00819     if (create_string && my_stat(create_string, &sbuf, MYF(0)))
00820     {
00821       File data_file;
00822       if (!MY_S_ISREG(sbuf.st_mode))
00823       {
00824         fprintf(stderr,"%s: Create file was not a regular file\n",
00825                 my_progname);
00826         exit(1);
00827       }
00828       if ((data_file= my_open(create_string, O_RDWR, MYF(0))) == -1)
00829       {
00830         fprintf(stderr,"%s: Could not open create file\n", my_progname);
00831         exit(1);
00832       }
00833       tmp_string= (char *)my_malloc(sbuf.st_size+1, MYF(MY_WME));
00834       my_read(data_file, tmp_string, sbuf.st_size, MYF(0));
00835       tmp_string[sbuf.st_size]= '\0';
00836       my_close(data_file,MYF(0));
00837       parse_delimiter(tmp_string, &create_statements, delimiter[0]);
00838       my_free(tmp_string, MYF(0));
00839     }
00840     else if (create_string)
00841     {
00842         parse_delimiter(create_string, &create_statements, delimiter[0]);
00843     }
00844 
00845     if (user_supplied_query && my_stat(user_supplied_query, &sbuf, MYF(0)))
00846     {
00847       File data_file;
00848       if (!MY_S_ISREG(sbuf.st_mode))
00849       {
00850         fprintf(stderr,"%s: User query supplied file was not a regular file\n",
00851                 my_progname);
00852         exit(1);
00853       }
00854       if ((data_file= my_open(user_supplied_query, O_RDWR, MYF(0))) == -1)
00855       {
00856         fprintf(stderr,"%s: Could not open query supplied file\n", my_progname);
00857         exit(1);
00858       }
00859       tmp_string= (char *)my_malloc(sbuf.st_size+1, MYF(MY_WME));
00860       my_read(data_file, tmp_string, sbuf.st_size, MYF(0));
00861       tmp_string[sbuf.st_size]= '\0';
00862       my_close(data_file,MYF(0));
00863       if (user_supplied_query)
00864         actual_queries= parse_delimiter(tmp_string, &query_statements,
00865                                         delimiter[0]);
00866       my_free(tmp_string, MYF(0));
00867     } 
00868     else if (user_supplied_query)
00869     {
00870         actual_queries= parse_delimiter(user_supplied_query, &query_statements,
00871                                         delimiter[0]);
00872     }
00873   }
00874 
00875   if (default_engine)
00876     parse_delimiter(default_engine, &engine_statements, ',');
00877 
00878   if (tty_password)
00879     opt_password= get_tty_password(NullS);
00880   DBUG_RETURN(0);
00881 }

Here is the call graph for this function:

mysql/src/5.1-dbg/client/mysqlslap.c File Reference

Classes

Defines

Typedefs

Functions

Variables

Define Documentation

Typedef Documentation

Function Documentation