Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

The world's most popular open source database

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().

{
  char       buf[RAND_STRING_SIZE];
  int        col_count;
  statement *ptr;
  DYNAMIC_STRING insert_string;
  DBUG_ENTER("build_insert_string");

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

  dynstr_append_mem(&insert_string, "INSERT INTO t1 VALUES (", 23);
  for (col_count= 1; col_count <= num_int_cols; col_count++)
  {
    sprintf(buf, "%ld", random());
    dynstr_append(&insert_string, buf);

    if (col_count < num_int_cols || num_char_cols > 0)
      dynstr_append_mem(&insert_string, ",", 1);
  }
  for (col_count= 1; col_count <= num_char_cols; col_count++)
  {
    int buf_len= get_random_string(buf);
    dynstr_append_mem(&insert_string, "'", 1);
    dynstr_append_mem(&insert_string, buf, buf_len);
    dynstr_append_mem(&insert_string, "'", 1);

    if (col_count < num_char_cols)
      dynstr_append_mem(&insert_string, ",", 1);
  }
  dynstr_append_mem(&insert_string, ")", 1);

  ptr= (statement *)my_malloc(sizeof(statement), MYF(MY_ZEROFILL));
  ptr->string= (char *)my_malloc(insert_string.length+1, MYF(MY_WME));
  ptr->length= insert_string.length+1;
  strmov(ptr->string, insert_string.str);
  DBUG_PRINT("info", ("generated_insert_data %s", ptr->string));
  dynstr_free(&insert_string);
  DBUG_RETURN(ptr);
}

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().

{
  char       buf[512];
  int        col_count;
  statement *ptr;
  static DYNAMIC_STRING query_string;
  DBUG_ENTER("build_query_string");

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

  dynstr_append_mem(&query_string, "SELECT ", 7);
  for (col_count= 1; col_count <= num_int_cols; col_count++)
  {
    sprintf(buf, "intcol%d", col_count);
    dynstr_append(&query_string, buf);

    if (col_count < num_int_cols || num_char_cols > 0)
      dynstr_append_mem(&query_string, ",", 1);

  }
  for (col_count= 1; col_count <= num_char_cols; col_count++)
  {
    sprintf(buf, "charcol%d", col_count);
    dynstr_append(&query_string, buf);

    if (col_count < num_char_cols)
      dynstr_append_mem(&query_string, ",", 1);

  }
  dynstr_append_mem(&query_string, " FROM t1", 8);
  ptr= (statement *)my_malloc(sizeof(statement), MYF(MY_ZEROFILL));
  ptr->string= (char *)my_malloc(query_string.length+1, MYF(MY_WME));
  ptr->length= query_string.length+1;
  strmov(ptr->string, query_string.str);
  DBUG_PRINT("info", ("user_supplied_query %s", ptr->string));
  dynstr_free(&query_string);
  DBUG_RETURN(ptr);
}

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().

{
  char       buf[512];
  int        col_count;
  statement *ptr;
  DYNAMIC_STRING table_string;
  DBUG_ENTER("build_table_string");

  DBUG_PRINT("info", ("num int cols %d num char cols %d",
                      num_int_cols, num_char_cols));

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

  dynstr_append(&table_string, "CREATE TABLE `t1` (");
  for (col_count= 1; col_count <= num_int_cols; col_count++)
  {
    sprintf(buf, "intcol%d INT(32)", col_count); 
    dynstr_append(&table_string, buf);

    if (col_count < num_int_cols || num_char_cols > 0)
      dynstr_append(&table_string, ",");
  }
  for (col_count= 1; col_count <= num_char_cols; col_count++)
  {
    sprintf(buf, "charcol%d VARCHAR(128)", col_count);
    dynstr_append(&table_string, buf);

    if (col_count < num_char_cols)
      dynstr_append(&table_string, ",");
  }
  dynstr_append(&table_string, ")");
  ptr= (statement *)my_malloc(sizeof(statement), MYF(MY_ZEROFILL));
  ptr->string = (char *)my_malloc(table_string.length+1, MYF(MY_WME));
  ptr->length= table_string.length+1;
  strmov(ptr->string, table_string.str);
  DBUG_PRINT("info", ("create_string %s", ptr->string));
  dynstr_free(&table_string);
  DBUG_RETURN(ptr);
}

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().

{
  char query[HUGE_STRING_LENGTH];
  statement *ptr;
  int len;
  DBUG_ENTER("create_schema");

  len= snprintf(query, HUGE_STRING_LENGTH, "CREATE SCHEMA `%s`", db);
  DBUG_PRINT("info", ("query %s", query)); 

  if (run_query(mysql, query, len))
  {
    fprintf(stderr,"%s: Cannot create schema %s : %s\n", my_progname, db,
            mysql_error(mysql));
    exit(1);
  }

  if (opt_only_print)
  {
    printf("use %s;\n", db);
  }
  else
  {
    if (verbose >= 2)
      printf("%s;\n", query);
    if (mysql_select_db(mysql,  db))
    {
      fprintf(stderr,"%s: Cannot select schema '%s': %s\n",my_progname, db,
              mysql_error(mysql));
      exit(1);
    }
  }

  if (engine_stmt)
  {
    len= snprintf(query, HUGE_STRING_LENGTH, "set storage_engine=`%s`",
                  engine_stmt->string);
    if (run_query(mysql, query, len))
    {
      fprintf(stderr,"%s: Cannot set default engine: %s\n", my_progname,
              mysql_error(mysql));
      exit(1);
    }
  }

  for (ptr= stmt; ptr && ptr->length; ptr= ptr->next)
  {
    if (run_query(mysql, ptr->string, ptr->length))
    {
      fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
              my_progname, (uint)ptr->length, ptr->string, mysql_error(mysql));
      exit(1);
    }
  }

  DBUG_RETURN(0);
}

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().

{
  char query[HUGE_STRING_LENGTH];
  int len;
  DBUG_ENTER("drop_schema");
  len= snprintf(query, HUGE_STRING_LENGTH, "DROP SCHEMA IF EXISTS `%s`", db);

  if (run_query(mysql, query, len))
  {
    fprintf(stderr,"%s: Cannot drop database '%s' ERROR : %s\n",
            my_progname, db, mysql_error(mysql));
    exit(1);
  }



  DBUG_RETURN(0);
}

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().

{
  stats *ptr;
  int x;

  con->min_timing= sptr->timing; 
  con->max_timing= sptr->timing;
  con->min_rows= sptr->rows;
  con->max_rows= sptr->rows;
  
  /* At the moment we assume uniform */
  con->users= sptr->users;
  con->avg_rows= sptr->rows;
  
  /* With no next, we know it is the last element that was malloced */
  for (ptr= sptr, x= 0; x < iterations; ptr++, x++)
  {
    con->avg_timing+= ptr->timing;

    if (ptr->timing > con->max_timing)
      con->max_timing= ptr->timing;
    if (ptr->timing < con->min_timing)
      con->min_timing= ptr->timing;
  }
  con->avg_timing= con->avg_timing/iterations;

  if (eng && eng->string)
    con->engine= eng->string;
  else
    con->engine= NULL;
}

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.

{
  DBUG_ENTER("get_one_option");
  switch(optid) {
#ifdef __NETWARE__
  case OPT_AUTO_CLOSE:
    setscreenmode(SCR_AUTOCLOSE_ON_EXIT);
    break;
#endif
  case 'v':
    verbose++;
    break;
  case 'p':
    if (argument)
    {
      char *start= argument;
      my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
      opt_password= my_strdup(argument,MYF(MY_FAE));
      while (*argument) *argument++= 'x';               /* Destroy argument */
      if (*start)
        start[1]= 0;                            /* Cut length of argument */
      tty_password= 0;
    }
    else
      tty_password= 1;
    break;
  case 'W':
#ifdef __WIN__
    opt_protocol= MYSQL_PROTOCOL_PIPE;
#endif
    break;
  case OPT_MYSQL_PROTOCOL:
    {
      if ((opt_protocol= find_type(argument, &sql_protocol_typelib,0)) <= 0)
      {
        fprintf(stderr, "Unknown option to protocol: %s\n", argument);
        exit(1);
      }
      break;
    }
  case '#':
    DBUG_PUSH(argument ? argument : default_dbug_option);
    break;
#include <sslopt-case.h>
  case 'V':
    print_version();
    exit(0);
    break;
  case '?':
  case 'I':                                     /* Info */
    usage();
    exit(0);
  }
  DBUG_RETURN(0);
}

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.

{
  int ho_error;
  char *tmp_string;
  MY_STAT sbuf;  /* Stat information for the data file */

  DBUG_ENTER("get_options");
  if ((ho_error= handle_options(argc, argv, my_long_options, get_one_option)))
    exit(ho_error);

  if (!user)
    user= (char *)"root";

  if (create_string || auto_generate_sql)
  {
    if (verbose >= 1)
      fprintf(stderr, "Turning off preserve-schema!\n");
    opt_preserve= FALSE;
  }

  if (auto_generate_sql && (create_string || user_supplied_query))
  {
      fprintf(stderr,
              "%s: Can't use --auto-generate-sql when create and query strings are specified!\n",
              my_progname);
      exit(1);
  }

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

  if (lock_directory)
    snprintf(lock_file_str, FN_REFLEN, "%s/%s", lock_directory, MYSLAPLOCK);
  else
    snprintf(lock_file_str, FN_REFLEN, "%s/%s", MYSLAPLOCK_DIR, MYSLAPLOCK);

  if (opt_csv_str)
  {
    opt_silent= TRUE;
    
    if (opt_csv_str[0] == '-')
    {
      csv_file= fileno(stdout);
    }
    else
    {
      if ((csv_file= my_open(opt_csv_str, O_CREAT|O_WRONLY|O_APPEND, MYF(0)))
          == -1)
      {
        fprintf(stderr,"%s: Could not open csv file: %sn\n",
                my_progname, opt_csv_str);
        exit(1);
      }
    }
  }

  if (opt_only_print)
    opt_silent= TRUE;

  if (auto_generate_sql)
  {
      create_statements= build_table_string();
      query_statements= build_insert_string();
      DBUG_PRINT("info", ("auto-generated insert is %s", query_statements->string));
      query_statements->next= build_query_string();
      DBUG_PRINT("info", ("auto-generated is %s", query_statements->next->string));
      if (verbose >= 1)
      {
        fprintf(stderr, "auto-generated insert is:\n");
        fprintf(stderr,  "%s\n", query_statements->string);
        fprintf(stderr, "auto-generated is:\n");
        fprintf(stderr,  "%s\n", query_statements->next->string);
      }

  }
  else
  {
    if (create_string && my_stat(create_string, &sbuf, MYF(0)))
    {
      File data_file;
      if (!MY_S_ISREG(sbuf.st_mode))
      {
        fprintf(stderr,"%s: Create file was not a regular file\n",
                my_progname);
        exit(1);
      }
      if ((data_file= my_open(create_string, O_RDWR, MYF(0))) == -1)
      {
        fprintf(stderr,"%s: Could not open create file\n", my_progname);
        exit(1);
      }
      tmp_string= (char *)my_malloc(sbuf.st_size+1, MYF(MY_WME));
      my_read(data_file, tmp_string, sbuf.st_size, MYF(0));
      tmp_string[sbuf.st_size]= '\0';
      my_close(data_file,MYF(0));
      parse_delimiter(tmp_string, &create_statements, delimiter[0]);
      my_free(tmp_string, MYF(0));
    }
    else if (create_string)
    {
        parse_delimiter(create_string, &create_statements, delimiter[0]);
    }

    if (user_supplied_query && my_stat(user_supplied_query, &sbuf, MYF(0)))
    {
      File data_file;
      if (!MY_S_ISREG(sbuf.st_mode))
      {
        fprintf(stderr,"%s: User query supplied file was not a regular file\n",
                my_progname);
        exit(1);
      }
      if ((data_file= my_open(user_supplied_query, O_RDWR, MYF(0))) == -1)
      {
        fprintf(stderr,"%s: Could not open query supplied file\n", my_progname);
        exit(1);
      }
      tmp_string= (char *)my_malloc(sbuf.st_size+1, MYF(MY_WME));
      my_read(data_file, tmp_string, sbuf.st_size, MYF(0));
      tmp_string[sbuf.st_size]= '\0';
      my_close(data_file,MYF(0));
      if (user_supplied_query)
        actual_queries= parse_delimiter(tmp_string, &query_statements,
                                        delimiter[0]);
      my_free(tmp_string, MYF(0));
    } 
    else if (user_supplied_query)
    {
        actual_queries= parse_delimiter(user_supplied_query, &query_statements,
                                        delimiter[0]);
    }
  }

  if (default_engine)
    parse_delimiter(default_engine, &engine_statements, ',');

  if (tty_password)
    opt_password= get_tty_password(NullS);
  DBUG_RETURN(0);
}

Here is the call graph for this function:

uint get_random_string

(

char *

buf

)

Definition at line 588 of file mysqlslap.c.

References ALPHANUMERICS, ALPHANUMERICS_SIZE, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, RAND_STRING_SIZE, and x.

Referenced by build_insert_string().

{
  char *buf_ptr= buf;
  int x;
  DBUG_ENTER("get_random_string");
  for (x= RAND_STRING_SIZE; x > 0; x--)
    *buf_ptr++= ALPHANUMERICS[random() % ALPHANUMERICS_SIZE];
  DBUG_PRINT("info", ("random string: '%*s'", buf_ptr - buf, buf));
  DBUG_RETURN(buf_ptr - buf);
}

Here is the caller graph for this function:

int main	(	int	argc,
		char **	argv
	)

Definition at line 245 of file mysqlslap.c.

References actual_queries, auto_generate_sql, bzero, concurrency, connect_flags, create_schema(), create_schema_string, create_statements, default_charset, defaults_argv, delimiter, delimiter_length, drop_schema(), engine_statements, exit, free_defaults(), generate_stats(), get_options(), host, iterations, load_default_groups, load_defaults(), lock_file_str, MY_ALLOW_ZERO_PTR, my_delete(), my_end(), my_free, MY_INIT, my_malloc(), my_progname, MY_ZEROFILL, MYF, mysql, mysql_close(), mysql_error(), mysql_init(), MYSQL_OPT_COMPRESS, MYSQL_OPT_PROTOCOL, mysql_options(), mysql_real_connect(), MYSQL_SET_CHARSET_NAME, MYSQL_SHARED_MEMORY_BASE_NAME, mysql_ssl_set(), statement::next, NULL, NullS, num_of_query, opt_compress, opt_csv_str, opt_mysql_port, opt_mysql_unix_port, opt_only_print, opt_password, opt_preserve, opt_protocol, opt_silent, opt_use_threads, print_conclusions(), print_conclusions_csv(), query_statements, run_scheduler(), statement_cleanup(), strlen(), user, and x.

{
  MYSQL mysql;
  int x;
  unsigned long long client_limit;
  statement *eptr;

#ifdef __WIN__
  opt_use_threads= 1;
#endif

  MY_INIT(argv[0]);

  load_defaults("my",load_default_groups,&argc,&argv);
  defaults_argv=argv;
  if (get_options(&argc,&argv))
  {
    free_defaults(defaults_argv);
    my_end(0);
    exit(1);
  }

  /* Seed the random number generator if we will be using it. */
  if (auto_generate_sql)
    srandom((uint)time(NULL));

  /* globals? Yes, so we only have to run strlen once */
  delimiter_length= strlen(delimiter);

  if (argc > 2)
  {
    fprintf(stderr,"%s: Too many arguments\n",my_progname);
    free_defaults(defaults_argv);
    my_end(0);
    exit(1);
  }
  mysql_init(&mysql);
  if (opt_compress)
    mysql_options(&mysql,MYSQL_OPT_COMPRESS,NullS);
#ifdef HAVE_OPENSSL
  if (opt_use_ssl)
    mysql_ssl_set(&mysql, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
                  opt_ssl_capath, opt_ssl_cipher);
#endif
  if (opt_protocol)
    mysql_options(&mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
#ifdef HAVE_SMEM
  if (shared_memory_base_name)
    mysql_options(&mysql,MYSQL_SHARED_MEMORY_BASE_NAME,shared_memory_base_name);
#endif
  mysql_options(&mysql, MYSQL_SET_CHARSET_NAME, default_charset);

  if (!opt_only_print) 
  {
    if (!(mysql_real_connect(&mysql, host, user, opt_password,
                             NULL, opt_mysql_port,
                             opt_mysql_unix_port, connect_flags)))
    {
      fprintf(stderr,"%s: Error when connecting to server: %s\n",
              my_progname,mysql_error(&mysql));
      free_defaults(defaults_argv);
      my_end(0);
      exit(1);
    }
  }

  /* Main iterations loop */
  eptr= engine_statements;
  do
  {
    /* For the final stage we run whatever queries we were asked to run */
    uint *current;
    conclusions conclusion;

    for (current= concurrency; current && *current; current++)
    {
      stats *head_sptr;
      stats *sptr;

      head_sptr= (stats *)my_malloc(sizeof(stats) * iterations, MYF(MY_ZEROFILL));

      bzero(&conclusion, sizeof(conclusions));

      if (num_of_query)
        client_limit=  num_of_query / *current;
      else
        client_limit= actual_queries;

      for (x= 0, sptr= head_sptr; x < iterations; x++, sptr++)
      {
        /*
          We might not want to load any data, such as when we are calling
          a stored_procedure that doesn't use data, or we know we already have
          data in the table.
        */
        if (!opt_preserve)
          drop_schema(&mysql, create_schema_string);
        /* First we create */
        if (create_statements)
          create_schema(&mysql, create_schema_string, create_statements, eptr);

        run_scheduler(sptr, query_statements, *current, client_limit); 
      }

      generate_stats(&conclusion, eptr, head_sptr);

      if (!opt_silent)
        print_conclusions(&conclusion);
      if (opt_csv_str)
        print_conclusions_csv(&conclusion);

      my_free((byte *)head_sptr, MYF(0));
    }

    if (!opt_preserve)
      drop_schema(&mysql, create_schema_string);
  } while (eptr ? (eptr= eptr->next) : 0);

  if (!opt_only_print) 
    mysql_close(&mysql); /* Close & free connection */


  /* Remove lock file */
  my_delete(lock_file_str, MYF(0));

  /* now free all the strings we created */
  if (opt_password)
    my_free(opt_password, MYF(0));

  my_free((byte *)concurrency, MYF(0));

  statement_cleanup(create_statements);
  statement_cleanup(engine_statements);
  statement_cleanup(query_statements);

#ifdef HAVE_SMEM
  if (shared_memory_base_name)
    my_free(shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
#endif
  free_defaults(defaults_argv);
  my_end(0);

  return 0;
}

Here is the call graph for this function:

uint parse_comma	(	const char *	string,
		uint **	range
	)

Definition at line 1253 of file mysqlslap.c.

References atoi(), count, my_malloc(), MY_ZEROFILL, MYF, strchr(), and x.

Referenced by get_options().

{
  uint count= 1,x; /* We know that there is always one */
  char *retstr;
  char *ptr= (char *)string;
  uint *nptr;

  for (;*ptr; ptr++)
    if (*ptr == ',') count++;
  
  /* One extra spot for the NULL */
  nptr= *range= (uint *)my_malloc(sizeof(uint) * (count + 1), MYF(MY_ZEROFILL));

  ptr= (char *)string;
  x= 0;
  while ((retstr= strchr(ptr,',')))
  {
    nptr[x++]= atoi(ptr);
    ptr+= retstr - ptr + 1;
  }
  nptr[x++]= atoi(ptr);

  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint parse_delimiter	(	const char *	script,
		statement **	stmt,
		char	delm
	)

Definition at line 1213 of file mysqlslap.c.

References count, DBUG_PRINT, statement::length, MY_FAE, my_malloc(), my_strndup(), MY_ZEROFILL, MYF, statement::next, strchr(), statement::string, and strlen().

Referenced by get_options().

{
  char *retstr;
  char *ptr= (char *)script;
  statement **sptr= stmt;
  statement *tmp;
  uint length= strlen(script);
  uint count= 0; /* We know that there is always one */

  DBUG_PRINT("info", ("Parsing %s\n", script));

  for (tmp= *sptr= (statement *)my_malloc(sizeof(statement), MYF(MY_ZEROFILL));
       (retstr= strchr(ptr, delm)); 
       tmp->next=  (statement *)my_malloc(sizeof(statement), MYF(MY_ZEROFILL)),
       tmp= tmp->next)
  {
    count++;
    tmp->string= my_strndup(ptr, (size_t)(retstr - ptr), MYF(MY_FAE));
    tmp->length= (size_t)(retstr - ptr);
    DBUG_PRINT("info", (" Creating : %.*s\n", (uint)tmp->length, tmp->string));
    ptr+= retstr - ptr + 1;
    if (isspace(*ptr))
      ptr++;
    count++;
  }

  if (ptr != script+length)
  {
    tmp->string= my_strndup(ptr, (size_t)((script + length) - ptr), 
                                       MYF(MY_FAE));
    tmp->length= (size_t)((script + length) - ptr);
    DBUG_PRINT("info", (" Creating : %.*s\n", (uint)tmp->length, tmp->string));
    count++;
  }

  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_conclusions

(

conclusions *

con

)

Definition at line 1279 of file mysqlslap.c.

References conclusions::avg_rows, conclusions::avg_timing, conclusions::engine, conclusions::max_timing, conclusions::min_timing, and conclusions::users.

Referenced by main().

{
  printf("Benchmark\n");
  if (con->engine)
    printf("\tRunning for engine %s\n", con->engine);
  printf("\tAverage number of seconds to run all queries: %ld.%03ld seconds\n",
                    con->avg_timing / 1000, con->avg_timing % 1000);
  printf("\tMinimum number of seconds to run all queries: %ld.%03ld seconds\n",
                    con->min_timing / 1000, con->min_timing % 1000);
  printf("\tMaximum number of seconds to run all queries: %ld.%03ld seconds\n",
                    con->max_timing / 1000, con->max_timing % 1000);
  printf("\tNumber of clients running queries: %d\n", con->users);
  printf("\tAverage number of queries per client: %llu\n", con->avg_rows); 
  printf("\n");
}

Here is the caller graph for this function:

void print_conclusions_csv

(

conclusions *

con

)

Definition at line 1296 of file mysqlslap.c.

References conclusions::avg_rows, conclusions::avg_timing, buffer, csv_file, conclusions::engine, HUGE_STRING_LENGTH, conclusions::max_timing, conclusions::min_timing, my_write, MYF, strlen(), and conclusions::users.

Referenced by main().

{
  char buffer[HUGE_STRING_LENGTH];
  snprintf(buffer, HUGE_STRING_LENGTH, 
           "%s,query,%ld.%03ld,%ld.%03ld,%ld.%03ld,%d,%llu\n",
           con->engine ? con->engine : "", /* Storage engine we ran against */
           con->avg_timing / 1000, con->avg_timing % 1000, /* Time to load */
           con->min_timing / 1000, con->min_timing % 1000, /* Min time */
           con->max_timing / 1000, con->max_timing % 1000, /* Max time */
           con->users, /* Children used */
           con->avg_rows  /* Queries run */
          );
  my_write(csv_file, buffer, strlen(buffer), MYF(0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void print_version

(

void

)

[static]

Definition at line 506 of file mysqlslap.c.

References MACHINE_TYPE, my_progname, MYSQL_SERVER_VERSION, SHOW_VERSION, and SYSTEM_TYPE.

{
  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,SHOW_VERSION,
         MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
}

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

Definition at line 884 of file mysqlslap.c.

References mysql, mysql_real_query(), opt_only_print, and verbose.

Referenced by create_schema(), drop_schema(), main(), and run_task().

{
  if (opt_only_print)
  {
    printf("%.*s;\n", len, query);
    return 0;
  }

  if (verbose >= 2)
    printf("%.*s;\n", len, query);
  return mysql_real_query(mysql, query, len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int run_scheduler	(	stats *	sptr,
		statement *	stmts,
		uint	concur,
		ulonglong	limit
	)			[static]

Definition at line 980 of file mysqlslap.c.

References concurrency, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, exit, F_TO_EOF, F_UNLCK, F_WRLCK, lock_file(), lock_file_str, my_close(), my_lock(), my_open(), my_progname, MYF, NULL, opt_slave, opt_use_threads, stats::rows, run_task(), status, statement::string, timedif(), stats::timing, stats::users, verbose, and x.

Referenced by main().

{
  uint x;
  File lock_file;
  struct timeval start_time, end_time;
  thread_context con;
  DBUG_ENTER("run_scheduler");

  con.stmt= stmts;
  con.limit= limit;
  con.thread= opt_use_threads ? 1 :0;

  lock_file= my_open(lock_file_str, O_CREAT|O_WRONLY|O_TRUNC, MYF(0));

  if (!opt_slave)
    if (my_lock(lock_file, F_WRLCK, 0, F_TO_EOF, MYF(0)))
    {
      fprintf(stderr,"%s: Could not get lockfile\n",
              my_progname);
      exit(0);
    }

#ifdef HAVE_LIBPTHREAD
  if (opt_use_threads)
  {
    pthread_t mainthread;            /* Thread descriptor */
    pthread_attr_t attr;          /* Thread attributes */

    for (x= 0; x < concur; x++)
    {
      pthread_attr_init(&attr);
      pthread_attr_setdetachstate(&attr,
                                   PTHREAD_CREATE_DETACHED);

      /* now create the thread */
      if (pthread_create(&mainthread, &attr, (void *)run_task, 
                         (void *)&con) != 0)
      {
        fprintf(stderr,"%s: Could not create thread\n",
                my_progname);
        exit(0);
      }
    }
  }
#endif
#if !(defined(__WIN__) || defined(__NETWARE__))
#ifdef HAVE_LIBPTHREAD
  else
#endif
  {
    fflush(NULL);
    for (x= 0; x < concur; x++)
    {
      int pid;
      DBUG_PRINT("info", ("x %d concurrency %d", x, concurrency));
      pid= fork();
      switch(pid)
      {
      case 0:
        /* child */
        DBUG_PRINT("info", ("fork returned 0, calling task(\"%s\"), pid %d gid %d",
                            stmts ? stmts->string : "", pid, getgid()));
        if (verbose >= 2)
          fprintf(stderr,
                  "%s: fork returned 0, calling task pid %d gid %d\n",
                  my_progname, pid, getgid());
        run_task(&con);
        exit(0);
        break;
      case -1:
        /* error */
        DBUG_PRINT("info",
                   ("fork returned -1, failing pid %d gid %d", pid, getgid()));
        fprintf(stderr,
                "%s: Failed on fork: -1, max procs per parent exceeded.\n",
                my_progname);
        /*exit(1);*/
        goto WAIT;
      default:
        /* parent, forked */
        DBUG_PRINT("info", ("default, break: pid %d gid %d", pid, getgid()));
        if (verbose >= 2)
          fprintf(stderr,"%s: fork returned %d, gid %d\n",
                  my_progname, pid, getgid());
        break;
      }
    }
  }
#endif

  /* Lets release use some clients! */
  if (!opt_slave)
    my_lock(lock_file, F_UNLCK, 0, F_TO_EOF, MYF(0));

  gettimeofday(&start_time, NULL);

  /*
    We look to grab a write lock at this point. Once we get it we know that
    all clients have completed their work.
  */
  if (opt_use_threads)
  {
    if (my_lock(lock_file, F_WRLCK, 0, F_TO_EOF, MYF(0)))
    {
      fprintf(stderr,"%s: Could not get lockfile\n",
              my_progname);
      exit(0);
    }
    my_lock(lock_file, F_UNLCK, 0, F_TO_EOF, MYF(0));
  }
#ifndef __WIN__
  else
  {
WAIT:
    while (x--)
    {
      int status, pid;
      pid= wait(&status);
      DBUG_PRINT("info", ("Parent: child %d status %d", pid, status));
      if (status != 0)
        printf("%s: Child %d died with the status %d\n",
               my_progname, pid, status);
    }
  }
#endif
  gettimeofday(&end_time, NULL);

  my_close(lock_file, MYF(0));

  sptr->timing= timedif(end_time, start_time);
  sptr->users= concur;
  sptr->rows= limit;

  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int run_task

(

thread_context *

con

)

Definition at line 1118 of file mysqlslap.c.

References connect_flags, counter, create_schema_string, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, F_RDLCK, F_TO_EOF, F_UNLCK, host, statement::length, thread_context::limit, lock_file(), lock_file_str, my_close(), my_lock(), my_open(), my_progname, my_sleep(), my_thread_end(), MYF, mysql, mysql_close(), mysql_errno(), mysql_error(), mysql_fetch_row(), mysql_field_count(), mysql_free_result(), mysql_init(), mysql_real_connect(), mysql_store_result(), mysql_thread_init(), statement::next, NULL, opt_mysql_port, opt_mysql_unix_port, opt_only_print, opt_password, queries, run_query(), thread_context::stmt, statement::string, thread_context::thread, user, and verbose.

Referenced by run_scheduler().

{
  ulonglong counter= 0, queries;
  File lock_file= -1;
  MYSQL *mysql;
  MYSQL_RES *result;
  MYSQL_ROW row;
  statement *ptr;

  DBUG_ENTER("run_task");
  DBUG_PRINT("info", ("task script \"%s\"", con->stmt ? con->stmt->string : ""));

  if (!(mysql= mysql_init(NULL)))
    goto end;

  if (con->thread && mysql_thread_init())
    goto end;

  DBUG_PRINT("info", ("trying to connect to host %s as user %s", host, user));
  lock_file= my_open(lock_file_str, O_RDWR, MYF(0));
  my_lock(lock_file, F_RDLCK, 0, F_TO_EOF, MYF(0));
  if (!opt_only_print)
  {
    /* Connect to server */
    static ulong connection_retry_sleep= 100000; /* Microseconds */
    int i, connect_error= 1;
    for (i= 0; i < 10; i++)
    {
      if (mysql_real_connect(mysql, host, user, opt_password,
                             create_schema_string,
                             opt_mysql_port,
                             opt_mysql_unix_port,
                             connect_flags))
      {
        /* Connect suceeded */
        connect_error= 0;
        break;
      }
      my_sleep(connection_retry_sleep);
    }
    if (connect_error)
    {
      fprintf(stderr,"%s: Error when connecting to server: %d %s\n",
              my_progname, mysql_errno(mysql), mysql_error(mysql));
      goto end;
    }
  }
  DBUG_PRINT("info", ("connected."));
  if (verbose >= 3)
    fprintf(stderr, "connected!\n");
  queries= 0;

limit_not_met:
    for (ptr= con->stmt; ptr && ptr->length; ptr= ptr->next)
    {
      if (run_query(mysql, ptr->string, ptr->length))
      {
        fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
                my_progname, (uint)ptr->length, ptr->string, mysql_error(mysql));
        goto end;
      }
      if (mysql_field_count(mysql))
      {
        result= mysql_store_result(mysql);
        while ((row = mysql_fetch_row(result)))
          counter++;
        mysql_free_result(result);
      }
      queries++;

      if (con->limit && queries == con->limit)
        goto end;
    }

    if (!con->stmt && con->limit && queries < con->limit)
      goto limit_not_met;

end:

  if (lock_file != -1)
  {
    my_lock(lock_file, F_UNLCK, 0, F_TO_EOF, MYF(0));
    my_close(lock_file, MYF(0));
  }

  if (!opt_only_print) 
    mysql_close(mysql);

  if (con->thread)
    my_thread_end();
  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void statement_cleanup

(

statement *

stmt

)

Definition at line 1345 of file mysqlslap.c.

References my_free, MYF, statement::next, and statement::string.

Referenced by main().

{
  statement *ptr, *nptr;
  if (!stmt)
    return;

  for (ptr= stmt; ptr; ptr= nptr)
  {
    nptr= ptr->next;
    if (ptr->string)
      my_free(ptr->string, MYF(0)); 
    my_free((byte *)ptr, MYF(0));
  }
}

Here is the caller graph for this function:

static long int timedif	(	struct timeval	a,
		struct timeval	b
	)			[static]

Definition at line 222 of file mysqlslap.c.

Referenced by run_scheduler().

{
    register int us, s;
 
    us = a.tv_usec - b.tv_usec;
    us /= 1000;
    s = a.tv_sec - b.tv_sec;
    s *= 1000;
    return s + us;
}

Here is the caller graph for this function:

static void usage

(

void

)

[static]

Definition at line 513 of file mysqlslap.c.

References load_default_groups, my_long_options, my_print_help(), my_progname, print_defaults(), and print_version().

{
  print_version();
  puts("Copyright (C) 2005 MySQL AB");
  puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\
       \nand you are welcome to modify and redistribute it under the GPL \
       license\n");
  puts("Run a query multiple times against the server\n");
  printf("Usage: %s [OPTIONS]\n",my_progname);
  print_defaults("my",load_default_groups);
  my_print_help(my_long_options);
}

Here is the call graph for this function:

---

Variable Documentation

ulonglong actual_queries = 0 [static]

Definition at line 138 of file mysqlslap.c.

Referenced by get_options(), and main().

const char ALPHANUMERICS[] [static]

Initial value:

  "0123456789ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstuvwxyz"

Definition at line 216 of file mysqlslap.c.

Referenced by get_random_string().

my_bool auto_generate_sql = FALSE [static]

Definition at line 131 of file mysqlslap.c.

Referenced by get_options(), and main().

uint* concurrency

Definition at line 142 of file mysqlslap.c.

const char* concurrency_str = NULL

Definition at line 140 of file mysqlslap.c.

Referenced by get_options().

unsigned long connect_flags = CLIENT_MULTI_RESULTS [static]

Definition at line 133 of file mysqlslap.c.

Referenced by main(), and run_task().

const char* create_schema_string = "mysqlslap"

Definition at line 118 of file mysqlslap.c.

Referenced by main(), and run_task().

statement* create_statements = NULL [static]

Definition at line 194 of file mysqlslap.c.

Referenced by get_options(), and main().

char* create_string [static]

Definition at line 141 of file mysqlslap.c.

Referenced by db_load_routine(), and get_options().

File csv_file

Definition at line 146 of file mysqlslap.c.

Referenced by get_options(), and print_conclusions_csv().

char* default_charset = (char*) MYSQL_DEFAULT_CHARSET_NAME [static]

Definition at line 137 of file mysqlslap.c.

const char* default_dbug_option = "d:t:o,/tmp/mysqlslap.trace"

Definition at line 144 of file mysqlslap.c.

char * default_engine = NULL [static]

Definition at line 113 of file mysqlslap.c.

Referenced by get_options().

char** defaults_argv [static]

Definition at line 109 of file mysqlslap.c.

const char* delimiter = "\n"

Definition at line 116 of file mysqlslap.c.

int delimiter_length [static]

Definition at line 135 of file mysqlslap.c.

statement * engine_statements = NULL [static]

Definition at line 195 of file mysqlslap.c.

Referenced by get_options(), and main().

char* host = NULL [static]

Definition at line 111 of file mysqlslap.c.

int iterations [static]

Definition at line 136 of file mysqlslap.c.

Referenced by generate_stats(), and main().

const char* load_default_groups[] = { "mysqlslap","client",0 } [static]

Definition at line 154 of file mysqlslap.c.

const char* lock_directory

Definition at line 120 of file mysqlslap.c.

Referenced by get_options().

char lock_file_str[FN_REFLEN]

Definition at line 121 of file mysqlslap.c.

Referenced by get_options(), main(), run_scheduler(), and run_task().

struct my_option my_long_options[] [static]

Definition at line 391 of file mysqlslap.c.

int num_char_cols [static]

Definition at line 135 of file mysqlslap.c.

Referenced by build_insert_string(), build_query_string(), and build_table_string().

int num_int_cols [static]

Definition at line 135 of file mysqlslap.c.

Referenced by build_insert_string(), build_query_string(), and build_table_string().

ulonglong num_of_query [static]

Definition at line 139 of file mysqlslap.c.

Referenced by main().

my_bool opt_compress = FALSE [static]

Definition at line 129 of file mysqlslap.c.

const char* opt_csv_str

Definition at line 145 of file mysqlslap.c.

Referenced by get_options(), and main().

uint opt_mysql_port = 0 [static]

Definition at line 151 of file mysqlslap.c.

char * opt_mysql_unix_port = NULL [static]

Definition at line 114 of file mysqlslap.c.

my_bool opt_only_print = FALSE [static]

Definition at line 125 of file mysqlslap.c.

Referenced by create_schema(), get_options(), main(), run_query(), and run_task().

char * opt_password = NULL [static]

Definition at line 111 of file mysqlslap.c.

my_bool opt_preserve [static]

Definition at line 123 of file mysqlslap.c.

Referenced by get_options(), and main().

uint opt_protocol = 0 [static]

Definition at line 148 of file mysqlslap.c.

my_bool opt_silent = FALSE [static]

Definition at line 130 of file mysqlslap.c.

my_bool opt_slave [static]

Definition at line 127 of file mysqlslap.c.

Referenced by run_scheduler().

uint opt_use_threads [static]

Definition at line 152 of file mysqlslap.c.

statement * query_statements = NULL [static]

Definition at line 196 of file mysqlslap.c.

Referenced by get_options(), and main().

my_bool tty_password = FALSE [static]

Definition at line 129 of file mysqlslap.c.

char * user = NULL [static]

Definition at line 111 of file mysqlslap.c.

char * user_supplied_query = NULL [static]

Definition at line 112 of file mysqlslap.c.

Referenced by get_options().

int verbose [static]

Definition at line 135 of file mysqlslap.c.

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.