Commit 7a44896f authored by unknown's avatar unknown
Browse files

Merge bk@192.168.21.1:mysql-5.0-opt 

into  mysql.com:/home/hf/work/w3475/my50-w3475
parents 3cf49a3d cc19246f

client/mysqltest.c

+82 −8
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
 *   Matt Wagner  <matt@mysql.com>

 *   Monty

 *   Jani

 *   Holyfoot

 **/



/**********************************************************************
@@ -243,6 +244,12 @@ struct connection 
  MYSQL* util_mysql;

  char *name;

  MYSQL_STMT* stmt;



  const char *cur_query;

  int cur_query_len;

  pthread_mutex_t mutex;

  pthread_cond_t cond;

  int query_done;

};



typedef struct
@@ -480,6 +487,58 @@ static void handle_error(const char *query, struct st_query *q, 
			 const char *err_sqlstate, DYNAMIC_STRING *ds);

static void handle_no_error(struct st_query *q);





#ifdef EMBEDDED_LIBRARY

/*

  send_one_query executes query in separate thread what is

  necessary in embedded library to run 'send' in proper way.

  This implementation doesn't handle errors returned

  by mysql_send_query. It's technically possible, though

  i don't see where it is needed.

*/

pthread_handler_t send_one_query(void *arg)

{

  struct connection *cn= (struct connection*)arg;



  mysql_thread_init();

  VOID(mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len));



  mysql_thread_end();

  pthread_mutex_lock(&cn->mutex);

  cn->query_done= 1;

  VOID(pthread_cond_signal(&cn->cond));

  pthread_mutex_unlock(&cn->mutex);

  pthread_exit(0);

  return 0;

}



static int do_send_query(struct connection *cn, const char *q, int q_len,

                         int flags)

{

  pthread_t tid;



  if (flags & QUERY_REAP)

    return mysql_send_query(&cn->mysql, q, q_len);



  if (pthread_mutex_init(&cn->mutex, NULL) ||

      pthread_cond_init(&cn->cond, NULL))

    die("Error in the thread library");



  cn->cur_query= q;

  cn->cur_query_len= q_len;

  cn->query_done= 0;

  if (pthread_create(&tid, NULL, send_one_query, (void*)cn))

    die("Cannot start new thread for query");



  return 0;

}



#else /*EMBEDDED_LIBRARY*/



#define do_send_query(cn,q,q_len,flags) mysql_send_query(&cn->mysql, q, q_len)



#endif /*EMBEDDED_LIBRARY*/



static void do_eval(DYNAMIC_STRING* query_eval, const char *query,

                    my_bool pass_through_escape_chars)

{
@@ -3578,7 +3637,6 @@ static int append_warnings(DYNAMIC_STRING *ds, MYSQL* mysql) 
}







/*

  Run query using MySQL C API
@@ -3595,11 +3653,12 @@ static int append_warnings(DYNAMIC_STRING *ds, MYSQL* mysql) 
  error - function will not return

*/



static void run_query_normal(MYSQL *mysql, struct st_query *command,

static void run_query_normal(struct connection *cn, struct st_query *command,

			     int flags, char *query, int query_len,

			     DYNAMIC_STRING *ds, DYNAMIC_STRING *ds_warnings)

{

  MYSQL_RES *res= 0;

  MYSQL *mysql= &cn->mysql;

  int err= 0, counter= 0;

  DBUG_ENTER("run_query_normal");

  DBUG_PRINT("enter",("flags: %d", flags));
@@ -3610,13 +3669,26 @@ static void run_query_normal(MYSQL *mysql, struct st_query *command, 
    /*

       Send the query

     */

    if (mysql_send_query(mysql, query, query_len))

    if (do_send_query(cn, query, query_len, flags))

    {

      handle_error(query, command, mysql_errno(mysql), mysql_error(mysql),

		   mysql_sqlstate(mysql), ds);

      goto end;

    }

  }

#ifdef EMBEDDED_LIBRARY

  /*

   Here we handle 'reap' command, so we need to check if the

   query's thread was finished and probably wait

  */

  else if (flags & QUERY_REAP)

  {

    pthread_mutex_lock(&cn->mutex);

    while (!cn->query_done)

      pthread_cond_wait(&cn->cond, &cn->mutex);

    pthread_mutex_unlock(&cn->mutex);

  }

#endif /*EMBEDDED_LIBRARY*/



  if (!(flags & QUERY_REAP))

    DBUG_VOID_RETURN;
@@ -4102,8 +4174,10 @@ static int util_query(MYSQL* org_mysql, const char* query){ 


*/



static void run_query(MYSQL *mysql, struct st_query *command, int flags)

static void run_query(struct connection *cn, struct st_query *command,

                      int flags)

{

  MYSQL *mysql= &cn->mysql;

  DYNAMIC_STRING *ds;

  DYNAMIC_STRING ds_result;

  DYNAMIC_STRING ds_warnings;
@@ -4256,7 +4330,7 @@ static void run_query(MYSQL *mysql, struct st_query *command, int flags) 
      match_re(&ps_re, query))

    run_query_stmt(mysql, command, query, query_len, ds, &ds_warnings);

  else

    run_query_normal(mysql, command, flags, query, query_len,

    run_query_normal(cn, command, flags, query, query_len,

		     ds, &ds_warnings);



  if (sp_created)
@@ -4740,7 +4814,7 @@ int main(int argc, char **argv) 
	  q->require_file=require_file;

	  save_file[0]=0;

	}

	run_query(&cur_con->mysql, q, QUERY_REAP|QUERY_SEND);

	run_query(cur_con, q, QUERY_REAP|QUERY_SEND);

	display_result_vertically= old_display_result_vertically;

        q->last_argument= q->end;

        query_executed= 1;
@@ -4775,7 +4849,7 @@ int main(int argc, char **argv) 
        {

          q->query= q->first_argument;

        }

	run_query(&cur_con->mysql, q, flags);

	run_query(cur_con, q, flags);

	query_executed= 1;

        q->last_argument= q->end;

	break;
@@ -4796,7 +4870,7 @@ int main(int argc, char **argv) 
	  query and read the result some time later when reap instruction

	  is given on this connection.

	 */

	run_query(&cur_con->mysql, q, QUERY_SEND);

	run_query(cur_con, q, QUERY_SEND);

	query_executed= 1;

        q->last_argument= q->end;

	break;

libmysql/libmysql.c

+0 −8
Original line number Diff line number Diff line
@@ -4769,14 +4769,6 @@ int STDCALL mysql_stmt_store_result(MYSQL_STMT *stmt) 
    DBUG_RETURN(1);

  }



  if (result->data)

  {

    free_root(&result->alloc, MYF(MY_KEEP_PREALLOC));

    result->data= NULL;

    result->rows= 0;

    stmt->data_cursor= NULL;

  }



  if (stmt->update_max_length && !stmt->bind_result_done)

  {

    /*

mysql-test/t/bdb-deadlock.test

+0 −8
Original line number Diff line number Diff line 
# This test doesn't work with the embedded version as this code

# assumes that one query is running while we are doing queries on

# a second connection.

# This would work if mysqltest run would be threaded and handle each

# connection in a separate thread.

#



-- source include/not_embedded.inc

-- source include/have_bdb.inc



connect (con1,localhost,root,,);

mysql-test/t/flush.test

+0 −8
Original line number Diff line number Diff line 
# This test doesn't work with the embedded version as this code

# assumes that one query is running while we are doing queries on

# a second connection.

# This would work if mysqltest run would be threaded and handle each

# connection in a separate thread.

#

-- source include/not_embedded.inc



connect (con1,localhost,root,,);

connect (con2,localhost,root,,);

connection con1;

mysql-test/t/flush_block_commit.test

+0 −3
Original line number Diff line number Diff line
@@ -3,9 +3,6 @@ 
# We verify that we did not introduce a deadlock.

# This is intended to mimick how mysqldump and innobackup work.



# This test doesn't work with the embedded server

-- source include/not_embedded.inc



# And it requires InnoDB

-- source include/have_innodb.inc