Intermediate commit of client library (cleanups + fixes of 3 items from

flaws list)
TODO: 
 * verify that no sequence of API calls produces SIGSEGV.
 That is, verify that mysql_stmt_init  -> mysql_stmt_fetch is OK,
 or mysql_stmt_prepare -> mysql_stmt_fetch_column is OK and sets
 meaningful error.
 * remove alloc_stmt_fields call
 * revise stmt->state codes and statement states.
 * there are other items in prepared statements 'to fix' document.

Done:
 - cleanups and comments
 - revision of prepared statement error codes.
 - mysql_stmt_prepare is now can always be called (that is, you can reprepare
   a statement)
 - new implementation of mysql_stmt_close and fetch cancellation


include/errmsg.h:
  - CR_NOT_ALL_PARAMS_BOUND - this error code wasn't used until now. 
    Apparently it was added in advance, but then interface of
    mysql_stmt_bind_param changed. Now it's not possible to bind only some
    parameters - either all or none of parameters are bound.
    This error code  is renamed to CR_PARAMS_NOT_BOUND
  - CR_FETCH_CANCELLED - error code set on server side when fetch from 
    MYSQL_RES or MYSQL_STMT (in blocking mode) was cancelled because of
    intercepting call to mysql_stmt_close
  - CR_NO_DATA - this is proposed error code to return from 
    mysql_stmt_fetch_column if no row was fetched (by any type of fetch).
    We always can fall back to CR_COMMANDS_OUT_OF_SYNC though.
    Need reviewer's opinion on this one.
include/mysql.h:
  - added unbuffered_fetch_owner member to MYSQL to point to MYSQL_RES 
    or MYSQL_STMT which is used to fetch result at the moment.
    This is to be able to set CR_FETCH_CANCELLED error without fantoms.
  - added unbuffered_fetch_cancelled boolean variable to MYSQL_STMT and 
    MYSQL_RES structures
  - rename PREP_STMT_STATE -> enum enum_mysql_stmt_state
  - members of MYSQL_STMT ordered by size.
  - removed members of MYSQL_STMT: current_row, result_buffered,
    last_fetched_column, last_fetched_buffer, query
  - renamed members of MYSQL_STMT: param_buffers -> bind_param_done, 
    res_buffers -> bind_result_done
  - now mysql_stmt_fetch calls stmt->read_row_func to read row either from 
    buffer or from network.
include/sql_common.h:
  declaration for flush_use_result
libmysql/client_settings.h:
  stmt_close declaration removed
libmysql/errmsg.c:
  Error messages for changed and added error codes.
libmysql/libmysql.c:
  Many changes:
  - some unused variables removed
  - cleanups
  - better error reporting
  - some function calls commented
  - alloc_stmt_fields is now called right after execute, to not read
    mysql->fields of some other statement
  - new implementation of mysql_stmt_fetch - this is also with cursor
    fetch in mind (to implement cursor fetch I'll just need to write
    special read_row function for it, so this change will be local)
  - implementation of fetch cancellation, including complete rewrite of
    mysql_stmt_close
  - now mysql_stmt_free_result doesn't free results of other statements.
sql-common/client.c:
  - implementation of flush_use_result
  - implementation of fetch cancellation
  - changed behaviour of mysql_close in regard to mysql_stmt_close - now 
    mysql_close just set stmt->mysql to 0

include/errmsg.h

@@ -67,7 +67,7 @@ extern const char *client_errors[];	/* Error messages */
 /* new 4.1 error codes */
 #define CR_NULL_POINTER		2028
 #define CR_NO_PREPARE_STMT	2029
-#define CR_NOT_ALL_PARAMS_BOUND	2030
+#define CR_PARAMS_NOT_BOUND	2030
 #define CR_DATA_TRUNCATED	2031
 #define CR_NO_PARAMETERS_EXISTS 2032
 #define CR_INVALID_PARAMETER_NO 2033
@@ -87,3 +87,5 @@ extern const char *client_errors[];	/* Error messages */
 #define CR_CONN_UNKNOW_PROTOCOL 		2046
 #define CR_INVALID_CONN_HANDLE			2047
 #define CR_SECURE_AUTH                          2048
+#define CR_FETCH_CANCELLED                      2049
+#define CR_NO_DATA                              2050

include/mysql.h

@@ -256,6 +256,11 @@ typedef struct st_mysql
   LIST  *stmts;                     /* list of all statements */
   const struct st_mysql_methods *methods;
   void *thd;
+  /*
+    Points to boolean flag in MYSQL_RES  or MYSQL_STMT. We set this flag 
+    from mysql_stmt_close if close had to cancel result set of this object.
+  */
+  my_bool *unbuffered_fetch_owner;
 } MYSQL;
 
 typedef struct st_mysql_res {
@@ -270,6 +275,8 @@ typedef struct st_mysql_res {
   MYSQL_ROW	row;			/* If unbuffered read */
   MYSQL_ROW	current_row;		/* buffer to current row */
   my_bool	eof;			/* Used by mysql_fetch_row */
+  /* mysql_stmt_close() had to cancel this result */
+  my_bool       unbuffered_fetch_cancelled;  
   const struct st_mysql_methods *methods;
 } MYSQL_RES;
 
@@ -479,7 +486,11 @@ my_bool         STDCALL mysql_read_query_result(MYSQL *mysql);
 */
 
 /* statement state */
-enum PREP_STMT_STATE { MY_ST_UNKNOWN, MY_ST_PREPARE, MY_ST_EXECUTE };
+enum enum_mysql_stmt_state
+{
+  MYSQL_STMT_INIT_DONE= 1, MYSQL_STMT_PREPARE_DONE, MYSQL_STMT_EXECUTE_DONE,
+  MYSQL_STMT_FETCH_DONE
+};
 
 /* 
   client TIME structure to handle TIME, DATE and TIMESTAMP directly in 
@@ -525,31 +536,34 @@ typedef struct st_mysql_bind
 /* statement handler */
 typedef struct st_mysql_stmt
 {
-  MYSQL		 *mysql;	       /* connection handle */
-  MYSQL_BIND	 *params;	       /* input parameters */
-  MYSQL_RES	 *result;	       /* resultset */
-  MYSQL_BIND	 *bind;	               /* row binding */
-  MYSQL_FIELD	 *fields;	       /* prepare meta info */
+  MEM_ROOT       mem_root;             /* root allocations */
   LIST           list;                 /* list to keep track of all stmts */
-  unsigned char  *current_row;         /* unbuffered row */
-  unsigned char  *last_fetched_buffer; /* last fetched column buffer */
-  char		 *query;	       /* query buffer */
-  MEM_ROOT	 mem_root;	       /* root allocations */
-  my_ulonglong   last_fetched_column;  /* last fetched column */
+  MYSQL          *mysql;               /* connection handle */
+  MYSQL_BIND     *params;              /* input parameters */
+  MYSQL_BIND     *bind;                /* output parameters */
+  MYSQL_FIELD    *fields;              /* result set metadata */
+  MYSQL_RES      *result;              /* cached result set */
   /* copy of mysql->affected_rows after statement execution */
   my_ulonglong   affected_rows;
+  /*
+    mysql_stmt_fetch() calls this function to fetch one row (it's different
+    for buffered, unbuffered and cursor fetch).
+  */
+  int            (*read_row_func)(struct st_mysql_stmt *stmt, 
+                                  unsigned char **row);
   unsigned long	 stmt_id;	       /* Id for prepared statement */
   unsigned int	 last_errno;	       /* error code */
-  unsigned int   param_count;	       /* parameters count */
-  unsigned int   field_count;	       /* fields count */
-  enum PREP_STMT_STATE state;	       /* statement state */
+  unsigned int   param_count;          /* inpute parameters count */
+  unsigned int   field_count;          /* number of columns in result set */
+  enum enum_mysql_stmt_state state;    /* statement state */
   char		 last_error[MYSQL_ERRMSG_SIZE]; /* error message */
   char		 sqlstate[SQLSTATE_LENGTH+1];
-  my_bool        long_alloced;	       /* flag to indicate long alloced */
-  my_bool	 send_types_to_server; /* Types sent to server */
-  my_bool        param_buffers;        /* param bound buffers */
-  my_bool        res_buffers;          /* output bound buffers */
-  my_bool        result_buffered;      /* Results buffered */
+  /* Types of input parameters should be sent to server */
+  my_bool        send_types_to_server;
+  my_bool        bind_param_done;      /* input buffers were supplied */
+  my_bool        bind_result_done;     /* output buffers were supplied */
+  /* mysql_stmt_close() had to cancel this result */
+  my_bool       unbuffered_fetch_cancelled;  
 } MYSQL_STMT;
 
 

include/sql_common.h

@@ -25,6 +25,7 @@ extern "C" {
 MYSQL_FIELD *unpack_fields(MYSQL_DATA *data,MEM_ROOT *alloc,uint fields,
 			   my_bool default_value, uint server_capabilities);
 void free_rows(MYSQL_DATA *cur);
+void flush_use_result(MYSQL *mysql);
 my_bool mysql_autenticate(MYSQL *mysql, const char *passwd);
 void free_old_query(MYSQL *mysql);
 void end_server(MYSQL *mysql);

libmysql/client_settings.h

@@ -22,7 +22,6 @@ extern my_string	mysql_unix_port;
 			     CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION)
 
 sig_handler pipe_sig_handler(int sig __attribute__((unused)));
-my_bool stmt_close(MYSQL_STMT *stmt, my_bool skip_free);
 void read_user_name(char *name);
 my_bool send_file_to_server(MYSQL *mysql, const char *filename);
 

libmysql/errmsg.c

@@ -54,7 +54,7 @@ const char *client_errors[]=
   "Malformed packet",
   "Invalid use of null pointer",
   "Statement not prepared",
-  "Not all parameters data supplied",
+  "Parameters data was not supplied",
   "Data truncated",
   "No parameters exists in the statement",
   "Invalid parameter number",
@@ -72,7 +72,9 @@ const char *client_errors[]=
   "Can't open shared memory. Can't send the request event to server (%lu)",
   "Wrong or unknown protocol",
   "Invalid connection handle",
-  "Connection using old (pre 4.1.1) authentication protocol refused (client option 'secure_auth' enabled)"
+  "Connection using old (pre 4.1.1) authentication protocol refused (client option 'secure_auth' enabled)",
+  "Row retrieval was cancelled by mysql_stmt_close() call",
+  "Attempt to read column without prior row fetch"
 };
 
 /* Start of code added by Roberto M. Serqueira - martinsc@uol.com.br - 05.24.2001 */
@@ -110,7 +112,7 @@ const char *client_errors[]=
   "Malformed packet",
   "Invalid use of null pointer",
   "Statement not prepared",
-  "Not all parameters data supplied",
+  "Parameters data was not supplied",
   "Data truncated",
   "No parameters exists in the statement",
   "Invalid parameter number",
@@ -128,7 +130,9 @@ const char *client_errors[]=
   "Can't open shared memory. Can't send the request event to server (%lu)",
   "Wrong or unknown protocol",
   "Invalid connection handle",
-  "Connection using old (pre 4.1.1) authentication protocol refused (client option 'secure_auth' enabled)"
+  "Connection using old (pre 4.1.1) authentication protocol refused (client option 'secure_auth' enabled)",
+  "Row retrieval was cancelled by mysql_stmt_close() call",
+  "Attempt to read column without prior row fetch"
 };
 
 #else /* ENGLISH */
@@ -182,7 +186,9 @@ const char *client_errors[]=
   "Can't open shared memory. Can't send the request event to server (%lu)",
   "Wrong or unknown protocol",
   "Invalid connection handle",
-  "Connection using old (pre 4.1.1) authentication protocol refused (client option 'secure_auth' enabled)"
+  "Connection using old (pre 4.1.1) authentication protocol refused (client option 'secure_auth' enabled)",
+  "Row retrieval was cancelled by mysql_stmt_close() call",
+  "Attempt to read column without prior row fetch"
 };
 #endif
 

sql-common/client.c

@@ -712,6 +712,34 @@ void set_mysql_error(MYSQL *mysql, int errcode, const char *sqlstate)
   net->last_errno= errcode;
   strmov(net->last_error, ER(errcode));
   strmov(net->sqlstate, sqlstate);
+
+  DBUG_VOID_RETURN;
+}
+
+/*
+  Flush result set sent from server
+*/
+
+void flush_use_result(MYSQL *mysql)
+{
+  /* Clear the current execution status */
+  DBUG_PRINT("warning",("Not all packets read, clearing them"));
+  for (;;)
+  {
+    ulong pkt_len;
+    if ((pkt_len=net_safe_read(mysql)) == packet_error)
+      break;
+    if (pkt_len <= 8 && mysql->net.read_pos[0] == 254)
+    {
+      if (protocol_41(mysql))
+      {
+        char *pos= (char*) mysql->net.read_pos;
+        mysql->warning_count=uint2korr(pos); pos+=2;
+        mysql->server_status=uint2korr(pos); pos+=2;
+      }
+      break;                            /* End of data */
+    }
+  }
 }
 
 
@@ -752,26 +780,16 @@ mysql_free_result(MYSQL_RES *result)
   DBUG_PRINT("enter",("mysql_res: %lx",result));
   if (result)
   {
-    if (result->handle && result->handle->status == MYSQL_STATUS_USE_RESULT)
+    MYSQL *mysql= result->handle;
+    if (mysql)
     {
-      DBUG_PRINT("warning",("Not all rows in set where read; Ignoring rows"));
-      for (;;)
+      if (mysql->unbuffered_fetch_owner == &result->unbuffered_fetch_cancelled)
+        mysql->unbuffered_fetch_owner= 0;
+      if (mysql->status == MYSQL_STATUS_USE_RESULT)
       {
-	ulong pkt_len;
-	if ((pkt_len=net_safe_read(result->handle)) == packet_error)
-	  break;
-	if (pkt_len <= 8 && result->handle->net.read_pos[0] == 254)
-	{
-	  if (protocol_41(result->handle))
-	  {
-	    char *pos= (char*) result->handle->net.read_pos;
-	    result->handle->warning_count=uint2korr(pos); pos+=2;
-	    result->handle->server_status=uint2korr(pos); pos+=2;
-	  }
-	  break;				/* End of data */
-	}
+        flush_use_result(mysql);
+        mysql->status=MYSQL_STATUS_READY;
       }
-      result->handle->status=MYSQL_STATUS_READY;
     }
     free_rows(result->data);
     if (result->fields)
@@ -2177,12 +2195,13 @@ void STDCALL mysql_close(MYSQL *mysql)
 #ifdef MYSQL_CLIENT
     if (mysql->stmts)
     {
-      /* Free any open prepared statements */
-      LIST *element, *next_element;
-      for (element= mysql->stmts; element; element= next_element)
+      /* Reset connection handle in all prepared statements. */
+      LIST *element;
+      for (element= mysql->stmts; element; element= element->next)
       {
-        next_element= element->next;
-        stmt_close((MYSQL_STMT *)element->data, 1);
+        MYSQL_STMT *stmt= (MYSQL_STMT *) element->data;
+        stmt->mysql= 0;
+        /* No need to call list_delete for statement here */
       }
       mysql->stmts= 0;
     }
@@ -2372,9 +2391,10 @@ MYSQL_RES * STDCALL mysql_store_result(MYSQL *mysql)
   result->fields=	mysql->fields;
   result->field_alloc=	mysql->field_alloc;
   result->field_count=	mysql->field_count;
-  result->current_field=0;
-  result->current_row=0;			/* Must do a fetch first */
+  /* The rest of result members is bzeroed in malloc */
   mysql->fields=0;				/* fields is now in result */
+  /* just in case this was mistakenly called after mysql_stmt_execute() */
+  mysql->unbuffered_fetch_owner= 0;
   DBUG_RETURN(result);				/* Data fetched */
 }
 
@@ -2423,6 +2443,7 @@ static MYSQL_RES * cli_use_result(MYSQL *mysql)
   result->current_row=	0;
   mysql->fields=0;			/* fields is now in result */
   mysql->status=MYSQL_STATUS_USE_RESULT;
+  mysql->unbuffered_fetch_owner= &result->unbuffered_fetch_cancelled;
   DBUG_RETURN(result);			/* Data is read to be fetched */
 }
 
@@ -2439,19 +2460,30 @@ mysql_fetch_row(MYSQL_RES *res)
   {						/* Unbufferred fetch */
     if (!res->eof)
     {
-      if (!(read_one_row(res->handle,res->field_count,res->row, res->lengths)))
+      MYSQL *mysql= res->handle;
+      if (mysql->status != MYSQL_STATUS_USE_RESULT)
       {
-	res->row_count++;
-	DBUG_RETURN(res->current_row=res->row);
+        set_mysql_error(mysql,
+                        res->unbuffered_fetch_cancelled ? 
+                        CR_FETCH_CANCELLED : CR_COMMANDS_OUT_OF_SYNC,
+                        unknown_sqlstate);
       }
-      else
+      else if (!(read_one_row(mysql, res->field_count, res->row, res->lengths)))
       {
-	DBUG_PRINT("info",("end of data"));
-	res->eof=1;
-	res->handle->status=MYSQL_STATUS_READY;
-	/* Don't clear handle in mysql_free_results */
-	res->handle=0;
+	res->row_count++;
+	DBUG_RETURN(res->current_row=res->row);
       }
+      DBUG_PRINT("info",("end of data"));
+      res->eof=1;
+      mysql->status=MYSQL_STATUS_READY;
+      /*
+        Reset only if owner points to us: there is a chance that somebody
+        started new query after mysql_stmt_close():
+      */
+      if (mysql->unbuffered_fetch_owner == &res->unbuffered_fetch_cancelled)
+        mysql->unbuffered_fetch_owner= 0;
+      /* Don't clear handle in mysql_free_result */
+      res->handle=0;
     }
     DBUG_RETURN((MYSQL_ROW) NULL);
   }