Merge mysql.com:/home/pz/mysql/mysql-4.1-root

into mysql.com:/home/pz/mysql/mysql-4.1

.bzrignore

@@ -580,3 +580,4 @@ vio/test-sslclient
 vio/test-sslserver
 vio/viotest-ssl
 libmysqld/protocol.cc
+test_xml

include/my_xml.h

@@ -34,6 +34,7 @@ typedef struct xml_stack_st
   const char *beg;
   const char *cur;
   const char *end;
+  void *user_data;
   int  (*enter)(struct xml_stack_st *st,const char *val, uint len);
   int  (*value)(struct xml_stack_st *st,const char *val, uint len);
   int  (*leave)(struct xml_stack_st *st,const char *val, uint len);
@@ -46,6 +47,7 @@ int        my_xml_parse(MY_XML_PARSER *st,const char *str, uint len);
 void       my_xml_set_value_handler(MY_XML_PARSER *st, int (*)(MY_XML_PARSER *, const char *, uint len));
 void       my_xml_set_enter_handler(MY_XML_PARSER *st, int (*)(MY_XML_PARSER *, const char *, uint len));
 void       my_xml_set_leave_handler(MY_XML_PARSER *st, int (*)(MY_XML_PARSER *, const char *, uint len));
+void       my_xml_set_user_data(MY_XML_PARSER *st, void *);
 
 uint       my_xml_error_pos(MY_XML_PARSER *st);
 uint       my_xml_error_lineno(MY_XML_PARSER *st);

include/mysql.h

@@ -510,7 +510,7 @@ MYSQL_RES *STDCALL mysql_prepare_result(MYSQL_STMT *stmt);
 #define MYSQL_STATUS_ERROR 2
 #define MYSQL_NO_DATA   100
 #define MYSQL_NEED_DATA  99 
-#define MYSQL_LONG_DATA_END 0xFF
+#define MYSQL_NULL_DATA (-1)
 
 #define mysql_reload(mysql) mysql_refresh((mysql),REFRESH_GRANT)
 

libmysql/Makefile.shared

@@ -58,7 +58,7 @@ mysysobjects1 =		my_init.lo my_static.lo my_malloc.lo my_realloc.lo \
 			mf_loadpath.lo my_pthread.lo my_thr_init.lo \
 			thr_mutex.lo mulalloc.lo string.lo default.lo \
 			my_compress.lo array.lo my_once.lo list.lo my_net.lo \
-                        charset.lo hash.lo mf_iocache.lo \
+                        charset.lo xml.lo hash.lo mf_iocache.lo \
                         mf_iocache2.lo my_seek.lo \
 			my_pread.lo mf_cache.lo my_vsnprintf.lo md5.lo sha1.lo\
 			my_getopt.lo my_gethostbyname.lo my_port.lo

libmysql/libmysql.c

@@ -1739,6 +1739,7 @@ static void mysql_once_init()
 
 #define strdup_if_not_null(A) (A) == 0 ? 0 : my_strdup((A),MYF(MY_WME))
 
+#ifdef HAVE_OPENSSL
 my_bool STDCALL
 mysql_ssl_set(MYSQL *mysql __attribute__((unused)) ,
 	      const char *key __attribute__((unused)),
@@ -1747,15 +1748,14 @@ mysql_ssl_set(MYSQL *mysql __attribute__((unused)) ,
 	      const char *capath __attribute__((unused)),
 	      const char *cipher __attribute__((unused)))
 {
-#ifdef HAVE_OPENSSL
   mysql->options.ssl_key=    strdup_if_not_null(key);
   mysql->options.ssl_cert=   strdup_if_not_null(cert);
   mysql->options.ssl_ca=     strdup_if_not_null(ca);
   mysql->options.ssl_capath= strdup_if_not_null(capath);
   mysql->options.ssl_cipher= strdup_if_not_null(cipher);
-#endif
   return 0;
 }
+#endif
 
 
 /**************************************************************************
@@ -1763,10 +1763,10 @@ mysql_ssl_set(MYSQL *mysql __attribute__((unused)) ,
   NB! Errors are not reported until you do mysql_real_connect.
 **************************************************************************/
 
+#ifdef HAVE_OPENSLL
 static void
 mysql_ssl_free(MYSQL *mysql __attribute__((unused)))
 {
-#ifdef HAVE_OPENSLL
   my_free(mysql->options.ssl_key, MYF(MY_ALLOW_ZERO_PTR));
   my_free(mysql->options.ssl_cert, MYF(MY_ALLOW_ZERO_PTR));
   my_free(mysql->options.ssl_ca, MYF(MY_ALLOW_ZERO_PTR));
@@ -1780,8 +1780,8 @@ mysql_ssl_free(MYSQL *mysql __attribute__((unused)))
   mysql->options.ssl_cipher= 0;
   mysql->options.use_ssl = FALSE;
   mysql->connector_fd = 0;
-#endif /* HAVE_OPENSLL */
 }
+#endif /* HAVE_OPENSLL */
 
 /**************************************************************************
   Connect to sql server
@@ -3824,12 +3824,13 @@ static my_bool my_realloc_str(NET *net, ulong length)
     1	error
 */
 
-static my_bool read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt)
+static my_bool read_prepare_result(MYSQL_STMT *stmt)
 {
   uchar *pos;
   uint field_count;
+  ulong length, param_count;
   MYSQL_DATA *fields_data;
-  ulong length;
+  MYSQL *mysql= stmt->mysql;
   DBUG_ENTER("read_prepare_result");
 
   mysql= mysql->last_used_con;
@@ -3837,9 +3838,9 @@ static my_bool read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt)
     DBUG_RETURN(1);
 
   pos=(uchar*) mysql->net.read_pos;
-  stmt->stmt_id=    uint4korr(pos); pos+=4;
-  field_count=      uint2korr(pos); pos+=2;
-  stmt->param_count=uint2korr(pos); pos+=2;
+  stmt->stmt_id= uint4korr(pos); pos+=4;
+  field_count=   uint2korr(pos); pos+=2;
+  param_count=   uint2korr(pos); pos+=2;
 
   if (field_count != 0)
   {
@@ -3862,9 +3863,10 @@ static my_bool read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt)
     set_stmt_error(stmt, CR_OUT_OF_MEMORY);
     DBUG_RETURN(0);
   }
-  stmt->bind=		(stmt->params + stmt->param_count);
-  stmt->field_count=	(uint) field_count;
-  mysql->status=	MYSQL_STATUS_READY;
+  stmt->bind=		       (stmt->params + stmt->param_count);
+  stmt->field_count=	 (uint) field_count;
+  stmt->param_count=   (ulong) param_count;
+  stmt->mysql->status= MYSQL_STATUS_READY;
   DBUG_RETURN(0);
 }
 
@@ -3908,13 +3910,13 @@ mysql_prepare(MYSQL  *mysql, const char *query, ulong length)
   }
 
   init_alloc_root(&stmt->mem_root,8192,0);
-  if (read_prepare_result(mysql, stmt))
+  stmt->mysql= mysql;
+  if (read_prepare_result(stmt))
   {
     stmt_close(stmt, 1);
     DBUG_RETURN(0);
   }
   stmt->state= MY_ST_PREPARE;
-  stmt->mysql= mysql;
   mysql->stmts= list_add(mysql->stmts, &stmt->list);
   stmt->list.data= stmt;
   DBUG_PRINT("info", ("Parameter count: %ld", stmt->param_count));
@@ -3925,18 +3927,41 @@ mysql_prepare(MYSQL  *mysql, const char *query, ulong length)
 /*
   Returns prepared meta information in the form of resultset
   to client.
+TODO : Return param information also
 */
 
+MYSQL_RES *prepare_result(MYSQL_FIELD *fields, unsigned long count)
+{
+  MYSQL_RES *result;
+  
+  if (!count || !fields)
+    return 0;
+
+  if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+
+				      sizeof(ulong)*count,
+				      MYF(MY_WME | MY_ZEROFILL))))
+    return 0;
+
+  result->eof=1;	/* Marker for buffered */
+  result->fields=	fields;
+  result->field_count=	count;
+  return result;
+}
+
 MYSQL_RES * STDCALL
 mysql_prepare_result(MYSQL_STMT *stmt)
 {
   MYSQL_RES *result;
   DBUG_ENTER("mysql_prepare_result");
-
-  if (!stmt->fields)
+  
+  if (!stmt->field_count || !stmt->fields)
     DBUG_RETURN(0);
-  result= &stmt->tmp_result;
-  bzero((char*) result, sizeof(MYSQL_RES));
+  
+  if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+
+				      sizeof(ulong)*stmt->field_count,
+				      MYF(MY_WME | MY_ZEROFILL))))
+    return 0;
+
   result->eof=1;	/* Marker for buffered */
   result->fields=	stmt->fields;
   result->field_count=	stmt->field_count;
@@ -4088,12 +4113,13 @@ static my_bool store_param(MYSQL_STMT *stmt, MYSQL_BIND *param)
   DBUG_ENTER("store_param");
   DBUG_PRINT("enter",("type: %d, buffer:%lx, length: %d", param->buffer_type,
     param->buffer ? param->buffer : "0", *param->length));
-
-  if (param->is_null || param->buffer_type == MYSQL_TYPE_NULL)
+  
+  if (param->is_null || param->buffer_type == MYSQL_TYPE_NULL ||
+      *param->length == MYSQL_NULL_DATA)
     store_param_null(net, param);
   else
   {
-    /* Allocate for worst case (long string) */
+    /* Allocate for worst case (long string) */  
     if ((my_realloc_str(net, 9 + *param->length)))
       DBUG_RETURN(1);
     (*param->store_param_func)(net, param);
@@ -4101,7 +4127,6 @@ static my_bool store_param(MYSQL_STMT *stmt, MYSQL_BIND *param)
   DBUG_RETURN(0);
 }
 
-
 /*
   Send the prepare query to server for execution
 */
@@ -4125,13 +4150,6 @@ static my_bool execute(MYSQL_STMT * stmt, char *packet, ulong length)
   }
   stmt->state= MY_ST_EXECUTE;
   mysql_free_result(stmt->result);
-#if USED_IN_FETCH
-  if (stmt->res_buffers) /* Result buffers exists, cache results */
-  {
-    mysql_free_result(stmt->result);
-    stmt->result= mysql_store_result(mysql);
-  }
-  #endif
   DBUG_RETURN(0);
 }
 
@@ -4420,21 +4438,21 @@ static void fetch_result_tinyint(MYSQL_BIND *param, uchar **row)
 
 static void fetch_result_short(MYSQL_BIND *param, uchar **row)
 {
-  short value= *(short *)row;
-  int2store(param->buffer, value);
+  short value= (short)**row;
+  int2store(param->buffer, value); 
   *row+=2;
 }
 
 static void fetch_result_int32(MYSQL_BIND *param, uchar **row)
 {
-  int32 value= *(int32 *)row;
+  int32 value= (int32)**row;
   int4store(param->buffer, value);
   *row+=4;
 }
 
 static void fetch_result_int64(MYSQL_BIND *param, uchar **row)
 {
-  longlong value= *(longlong *)row;
+  longlong value= (longlong)**row;
   int8store(param->buffer, value);
   *row+=8;
 }
@@ -4443,7 +4461,7 @@ static void fetch_result_float(MYSQL_BIND *param, uchar **row)
 {
   float value;
   float4get(value,*row);
-  float4store(param->buffer, *row);
+  float4store(param->buffer, value);
   *row+=4;
 }
 
@@ -4459,6 +4477,7 @@ static void fetch_result_str(MYSQL_BIND *param, uchar **row)
 {
   ulong length= net_field_length(row);
   memcpy(param->buffer, (char *)*row, length);
+  *(param->buffer+length)= '\0'; /* do we need this for all cases.. I doubt */
   *param->length= length;
   *row+=length;
 }
@@ -4537,41 +4556,46 @@ my_bool STDCALL mysql_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *bind)
   Fetch row data to bind buffers
 */
 
-static my_bool
-stmt_fetch_row(MYSQL_STMT *stmt, uchar **row)
+static void
+stmt_fetch_row(MYSQL_STMT *stmt, uchar *row)
 {
   MYSQL_BIND  *bind, *end;
-  uchar *null_ptr= (uchar*) *row, bit;
-
-  row+= (stmt->field_count+9)/8;
-  bit= 4;					/* First 2 bits are reserved */
-
+  MYSQL_FIELD *field;
+  uchar *null_ptr, bit;
+  
+  null_ptr= row; 
+  row+= (stmt->field_count+9)/8; /* skip null bits */
+  bit= 4; /* first 2 bits are reserved */
+  
   /* Copy complete row to application buffers */
-  for (bind= stmt->bind, end= (MYSQL_BIND *) bind + stmt->field_count;
-       bind < end;
-       bind++)
-  {
+  for (bind= stmt->bind, end= (MYSQL_BIND *) bind + stmt->field_count, 
+       field= stmt->fields;
+       bind < end && field;
+       bind++, field++)
+  {         
     if (*null_ptr & bit)
-      bind->is_null= 1;
+      *bind->length= MYSQL_NULL_DATA;
     else
-    {
-      bind->is_null= 0;
-      (*bind->fetch_result)(bind, row);
-    }
+      /* TODO: Add conversion routines code here */
+      (*bind->fetch_result)(bind, &row);
     if (! (bit<<=1) & 255)
     {
-      bit=1;					/* To next byte */
+      bit= 1;					/* To next byte */
       null_ptr++;
     }
   }
-  return 0;
 }
 
 static int read_binary_data(MYSQL *mysql)
-{
+{  
+  /* TODO : Changes needed based on logic of use_result/store_result 
+            Currently by default it is use_result. In case of 
+            store_result, the data packet must point to already 
+            read data.
+   */
   if (packet_error == net_safe_read(mysql))
     return -1;
-  if (mysql->net.read_pos[0])
+  if (mysql->net.read_pos[0] == 254)
     return 1;				/* End of data */
   return 0;
 }
@@ -4584,29 +4608,24 @@ static int read_binary_data(MYSQL *mysql)
 int STDCALL mysql_fetch(MYSQL_STMT *stmt)
 {
   MYSQL *mysql= stmt->mysql;
+  int   res;
   DBUG_ENTER("mysql_fetch");
 
-  if (stmt->res_buffers)
+  if (!(res= read_binary_data(mysql)))
   {
-    int res;
-    if (!(res= read_binary_data(mysql)))
-    {
-      if (stmt->res_buffers)
-	      DBUG_RETURN((int) stmt_fetch_row(stmt,(uchar **) &mysql->net.read_pos+1));
-      DBUG_RETURN(0);
-    }
-    DBUG_PRINT("info", ("end of data"));
-    mysql->status= MYSQL_STATUS_READY;
-
-    if (res < 0)				/* Network error */
-    {
-	   set_stmt_errmsg(stmt,(char *)mysql->net.last_error,
-		                mysql->net.last_errno);
-	   DBUG_RETURN(MYSQL_STATUS_ERROR);
-    }
-    DBUG_RETURN(MYSQL_NO_DATA); /* no more data */
+    if (stmt->res_buffers)
+      stmt_fetch_row(stmt, mysql->net.read_pos+1);
+    DBUG_RETURN(0);
+  }
+  mysql->status= MYSQL_STATUS_READY;
+  if (res < 0)				/* Network error */
+  {
+	  set_stmt_errmsg(stmt,(char *)mysql->net.last_error,
+	                  mysql->net.last_errno);
+	  DBUG_RETURN(MYSQL_STATUS_ERROR);
   }
-  DBUG_RETURN(0); //?? do we need to set MYSQL_STATUS_READY ?
+  DBUG_PRINT("info", ("end of data"));    
+  DBUG_RETURN(MYSQL_NO_DATA); /* no more data */
 }
 
 

mysys/charset.c

@@ -19,7 +19,9 @@
 #include <m_ctype.h>
 #include <m_string.h>
 #include <my_dir.h>
+#include <my_xml.h>
 
+#define MY_CHARSET_INDEX "Index.xml"
 
 const char *charsets_dir = NULL;
 static int charset_initialized=0;
@@ -85,53 +87,166 @@ char *get_charsets_dir(char *buf)
 }
 
 
-static my_bool read_charset_index(myf myflags)
+#define MAX_BUF 1024*16
+
+
+static void mstr(char *str,const char *src,uint l1,uint l2)
 {
-  struct simpleconfig_buf_st fb;
-  char buf[MAX_LINE], num_buf[MAX_LINE];
-    
-  strmov(get_charsets_dir(buf), "Index");
+  l1 = l1<l2 ? l1 : l2;
+  memcpy(str,src,l1);
+  str[l1]='\0';
+}
 
-  if ((fb.f = my_fopen(buf, O_RDONLY, myflags)) == NULL)
-    return TRUE;
-  fb.buf[0] = '\0';
-  fb.p = fb.buf;
 
+struct my_cs_file_section_st
+{
+  int        state;
+  const char *str;
+};
+
+#define _CS_MISC	1
+#define _CS_ID		2
+#define _CS_NAME	3
+#define _CS_FAMILY	4
+#define _CS_ORDER	5
+#define _CS_COLNAME	6
+#define _CS_FLAG	7
+#define _CS_CHARSET	8
+#define _CS_COLLATION	9
+
+static struct my_cs_file_section_st sec[] =
+{
+  {_CS_MISC,		"xml"},
+  {_CS_MISC,		"xml.version"},
+  {_CS_MISC,		"xml.encoding"},
+  {_CS_MISC,		"charsets"},
+  {_CS_MISC,		"charsets.max-id"},
+  {_CS_MISC,		"charsets.description"},
+  {_CS_CHARSET,		"charsets.charset"},
+  {_CS_NAME,		"charsets.charset.name"},
+  {_CS_FAMILY,		"charsets.charset.family"},
+  {_CS_MISC,		"charsets.charset.alias"},
+  {_CS_COLLATION,	"charsets.charset.collation"},
+  {_CS_COLNAME,		"charsets.charset.collation.name"},
+  {_CS_ID,		"charsets.charset.collation.id"},
+  {_CS_ORDER,		"charsets.charset.collation.order"},
+  {_CS_FLAG,		"charsets.charset.collation.flag"},
+  {0,	NULL}
+};
+
+static struct my_cs_file_section_st * cs_file_sec(const char *attr, uint len)
+{
+  struct my_cs_file_section_st *s;
+  for (s=sec; s->str; s++)
+    if (!strncmp(attr,s->str,len))
+      return s;
+  return NULL;
+}
+
+struct my_cs_file_info 
+{
+  CHARSET_INFO cs;
+  myf myflags;
+};
+
+static int cs_enter(MY_XML_PARSER *st,const char *attr, uint len)
+{
+  struct my_cs_file_info *i = (struct my_cs_file_info *)st->user_data;
+  struct my_cs_file_section_st *s = cs_file_sec(attr,len);
   
-  while (!get_word(&fb, buf) && !get_word(&fb, num_buf))
+  if ( s && (s->state == _CS_CHARSET))
   {
-    uint csnum;
-    uint length;
-    CHARSET_INFO *cs;
+    bzero(&i->cs,sizeof(i->cs));
+  }
+  return MY_XML_OK;
+}
 
-    if (!(csnum = atoi(num_buf)))
-    {
-      /* corrupt Index file */
-      my_fclose(fb.f,myflags);
-      return TRUE;
-    }
-    
-    if (all_charsets[csnum])
-      continue;
-    
-    if (!(cs=(CHARSET_INFO*) my_once_alloc(sizeof(cs[0]),myflags)))
-    {
-      my_fclose(fb.f,myflags);
-      return TRUE;
-    }
-    bzero(cs,sizeof(cs[0]));
-    
-    if (!(cs->name= (char*)my_once_alloc(length=(uint)strlen(buf)+1,myflags)))
+static int cs_leave(MY_XML_PARSER *st,const char *attr, uint len)
+{
+  struct my_cs_file_info *i = (struct my_cs_file_info *)st->user_data;
+  struct my_cs_file_section_st *s = cs_file_sec(attr,len);
+  
+  if (s && (s->state == _CS_COLLATION) && !all_charsets[i->cs.number])
+  {
+    if (!(all_charsets[i->cs.number]=
+         (CHARSET_INFO*) my_once_alloc(sizeof(CHARSET_INFO),i->myflags)))
     {
-      my_fclose(fb.f,myflags);
-      return TRUE;
+      return MY_XML_ERROR;
     }
-    memcpy((char*)cs->name,buf,length);
-    cs->number=csnum;
-    all_charsets[csnum]=cs;
+    all_charsets[i->cs.number][0]=i->cs;
+  }
+  return MY_XML_OK;
+}
+
+static int cs_value(MY_XML_PARSER *st,const char *attr, uint len)
+{
+  struct my_cs_file_info *i = (struct my_cs_file_info *)st->user_data;
+  struct my_cs_file_section_st *s;
+  int    state = (s=cs_file_sec(st->attr,strlen(st->attr))) ? s->state : 0;
+  
+  if(0)
+  {
+    char   str[256];
+    mstr(str,attr,len,sizeof(str)-1);
+    printf("VALUE %d %s='%s'\n",state,st->attr,str);
+  }
+  
+  switch (state)
+  {
+    case _CS_ID:
+      i->cs.number = my_strntoul(my_charset_latin1,attr,len,(char**)NULL,0);
+      break;
+    case _CS_COLNAME:
+      if ((i->cs.name = (char*) my_once_alloc(len+1,i->myflags)))
+      {
+        memcpy((char*)i->cs.name,attr,len);
+        ((char*)(i->cs.name))[len]='\0';
+      }
+      break;
   }
-  my_fclose(fb.f,myflags);
+  return MY_XML_OK;
+}
 
+static my_bool read_charset_index(myf myflags)
+{
+  char *buf;
+  int  fd;
+  uint len;
+  MY_XML_PARSER p;
+  struct my_cs_file_info i;
+  
+  if (! (buf = (char *)my_malloc(MAX_BUF,myflags)))
+    return FALSE;
+  
+  strmov(get_charsets_dir(buf),MY_CHARSET_INDEX);
+  
+  if ((fd=my_open(buf,O_RDONLY,myflags)) < 0)
+  {
+    my_free(buf,myflags);
+    return TRUE;
+  }
+  
+  len=read(fd,buf,MAX_BUF);
+  my_xml_parser_create(&p);
+  my_close(fd,myflags);
+  
+  my_xml_set_enter_handler(&p,cs_enter);
+  my_xml_set_value_handler(&p,cs_value);
+  my_xml_set_leave_handler(&p,cs_leave);
+  my_xml_set_user_data(&p,(void*)&i);
+  
+  if (MY_XML_OK!=my_xml_parse(&p,buf,len))
+  {
+  /*
+    printf("ERROR at line %d pos %d '%s'\n",
+      my_xml_error_lineno(&p)+1,
+      my_xml_error_pos(&p),
+      my_xml_error_string(&p));
+  */
+  }
+  
+  my_xml_parser_free(&p);
+  
   return FALSE;
 }
 
@@ -472,7 +587,7 @@ CHARSET_INFO *get_charset(uint cs_number, myf flags)
   if (!cs && (flags & MY_WME))
   {
     char index_file[FN_REFLEN], cs_string[23];
-    strmov(get_charsets_dir(index_file), "Index");
+    strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
     cs_string[0]='#';
     int10_to_str(cs_number, cs_string+1, 10);
     my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_string, index_file);
@@ -505,7 +620,7 @@ CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags)
   if (!cs && (flags & MY_WME))
   {
     char index_file[FN_REFLEN];
-    strmov(get_charsets_dir(index_file), "Index");
+    strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
     my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_name, index_file);
   }
 

mysys/xml.c

@@ -342,6 +342,11 @@ void my_xml_set_leave_handler(MY_XML_PARSER *p, int (*action)(MY_XML_PARSER *p,
   p->leave=action;
 }
 
+void my_xml_set_user_data(MY_XML_PARSER *p, void *user_data)
+{
+  p->user_data=user_data;
+}
+
 const char *my_xml_error_string(MY_XML_PARSER *p)
 {
   return p->errstr;

sql/field.cc

@@ -2599,7 +2599,7 @@ String *Field_double::val_str(String *val_buffer,
 
 bool Field_double::send_binary(Protocol *protocol)
 {
-  return protocol->store((float) Field_double::val_real(), dec, (String*) 0);
+  return protocol->store((double) Field_double::val_real(), dec, (String*) 0);
 }
 
 
@@ -3169,7 +3169,7 @@ bool Field_time::send_binary(Protocol *protocol)
   Field_time::get_time(&tm);
   tm.day= tm.hour/3600;				// Move hours to days
   tm.hour-= tm.day*3600;
-  return protocol->store(&tm);
+  return protocol->store_time(&tm);
 }
 
 
@@ -3254,6 +3254,13 @@ int Field_year::store(longlong nr)
   return 0;
 }
 
+bool Field_year::send_binary(Protocol *protocol)
+{
+  ulonglong tmp= Field_year::val_int();
+  TIME tm;
+  tm.year= (uint32) tmp;
+  return protocol->store_date(&tm);
+}
 
 double Field_year::val_real(void)
 {
@@ -3371,6 +3378,16 @@ int Field_date::store(longlong nr)
   return error;
 }
 
+bool Field_date::send_binary(Protocol *protocol)
+{
+  longlong tmp= Field_date::val_int();
+  TIME tm;
+  tm.year= (uint32) tmp/10000L % 10000;
+  tm.month= (uint32) tmp/100 % 100;
+  tm.day= (uint32) tmp % 100;
+  return protocol->store_date(&tm);
+}
+
 
 double Field_date::val_real(void)
 {
@@ -3544,7 +3561,12 @@ void Field_newdate::store_time(TIME *ltime,timestamp_type type)
   int3store(ptr,tmp);
 }
 
-
+bool Field_newdate::send_binary(Protocol *protocol)
+{
+  TIME tm;
+  Field_newdate::get_date(&tm,0);
+  return protocol->store_date(&tm);
+}
 
 double Field_newdate::val_real(void)
 {
@@ -3705,6 +3727,13 @@ void Field_datetime::store_time(TIME *ltime,timestamp_type type)
     longlongstore(ptr,tmp);
 }
 
+bool Field_datetime::send_binary(Protocol *protocol)
+{
+  TIME tm;
+  Field_datetime::get_date(&tm, 1);
+  return protocol->store(&tm);
+}
+
 
 double Field_datetime::val_real(void)
 {

sql/field.h

@@ -166,7 +166,7 @@ public:
       ptr-=row_offset;
       return tmp;
     }
-  bool send_binary(Protocol *protocol);
+  virtual bool send_binary(Protocol *protocol);
   virtual char *pack(char* to, const char *from, uint max_length=~(uint) 0)
   {
     uint32 length=pack_length();
@@ -792,7 +792,6 @@ public:
   double val_real(void);
   longlong val_int(void);
   String *val_str(String*,String *);
-  bool send_binary(Protocol *protocol);
   int cmp(const char *,const char*);
   void sort_string(char *buff,uint length);
   void sql_type(String &str) const;
@@ -833,7 +832,6 @@ public:
   double val_real(void);
   longlong val_int(void);
   String *val_str(String*,String *);
-  bool send_binary(Protocol *protocol);
   int cmp(const char *,const char*);
   void sort_string(char *buff,uint length);
   void get_key_image(char *buff,uint length, CHARSET_INFO *cs, imagetype type);
@@ -876,7 +874,6 @@ public:
   double val_real(void);
   longlong val_int(void);
   String *val_str(String*,String *);
-  bool send_binary(Protocol *protocol);
   int cmp(const char *,const char*);
   int cmp(const char *a, uint32 a_length, const char *b, uint32 b_length);
   int cmp_offset(uint offset);
@@ -982,7 +979,6 @@ public:
   double val_real(void);
   longlong val_int(void);
   String *val_str(String*,String *);
-  bool send_binary(Protocol *protocol);
   int cmp(const char *,const char*);
   void sort_string(char *buff,uint length);
   uint32 pack_length() const { return (uint32) packlength; }

sql/protocol.cc

@@ -616,7 +616,7 @@ bool Protocol_simple::store_null()
   field_pos++;
 #endif
   char buff[1];
-  buff[0]= 251;
+  buff[0]= (char)251;
   return packet->append(buff, sizeof(buff), PACKET_BUFFET_EXTRA_ALLOC);
 }
 
@@ -774,13 +774,27 @@ bool Protocol_simple::store_time(TIME *tm)
 
 /****************************************************************************
   Functions to handle the binary protocol used with prepared statements
+
+  Data format:
+
+   [ok:1]                            <-- reserved ok packet
+   [null_field:(field_count+7+2)/8]  <-- reserved to send null data. The size is
+                                         calculated using:
+                                         bit_fields= (field_count+7+2)/8; 
+                                         2 bits are reserved
+   [[length]data]                    <-- data field (the length applies only for 
+                                         string/binary/time/timestamp fields and 
+                                         rest of them are not sent as they have 
+                                         the default length that client understands
+                                         based on the field type
+   [..]..[[length]data]              <-- data
 ****************************************************************************/
 
 bool Protocol_prep::prepare_for_send(List<Item> *item_list)
 {
-  field_count=item_list->elements;
-  bit_fields= (field_count+3)/8;
-  if (packet->alloc(bit_fields))
+  field_count= item_list->elements;
+  bit_fields= (field_count+9)/8;
+  if (packet->alloc(bit_fields+1))
     return 1;
   /* prepare_for_resend will be called after this one */
   return 0;
@@ -789,9 +803,8 @@ bool Protocol_prep::prepare_for_send(List<Item> *item_list)
 
 void Protocol_prep::prepare_for_resend()
 {
-  packet->length(bit_fields);
-  bzero((char*) packet->ptr()+1, bit_fields-1);
-  packet[0]=1;					// Marker for ok packet
+  packet->length(bit_fields+1);
+  bzero((char*) packet->ptr(), 1+bit_fields);
   field_pos=0;
 }
 
@@ -813,7 +826,7 @@ bool Protocol_prep::store(const char *from,uint length)
 
 bool Protocol_prep::store_null()
 {
-  uint offset=(field_pos+2)/8, bit= (1 << ((field_pos+2) & 7));
+  uint offset= (field_pos+2)/8+1, bit= (1 << ((field_pos+2) & 7));
   /* Room for this as it's allocated in prepare_for_send */
   char *to= (char*) packet->ptr()+offset;
   *to= (char) ((uchar) *to | (uchar) bit);
@@ -926,6 +939,7 @@ bool Protocol_prep::store(TIME *tm)
 {
 #ifndef DEBUG_OFF
   DBUG_ASSERT(field_types == 0 ||
+        field_types[field_pos] == MYSQL_TYPE_YEAR ||
 	      field_types[field_pos] == MYSQL_TYPE_DATETIME ||
 	      field_types[field_pos] == MYSQL_TYPE_DATE ||
 	      field_types[field_pos] == MYSQL_TYPE_TIMESTAMP);
@@ -987,3 +1001,10 @@ bool Protocol_prep::store_time(TIME *tm)
   buff[0]=(char) length;			// Length is stored first
   return packet->append(buff, length+1, PACKET_BUFFET_EXTRA_ALLOC);
 }
+
+#if 0
+bool Protocol_prep::send_fields(List<Item> *list, uint flag) 
+{
+  return prepare_for_send(list);
+};
+#endif

sql/share/Makefile.am

@@ -7,7 +7,7 @@ dist-hook:
 	done; \
 	sleep 1 ; touch $(srcdir)/*/errmsg.sys
 	$(INSTALL_DATA) $(srcdir)/charsets/README $(distdir)/charsets
-	$(INSTALL_DATA) $(srcdir)/charsets/Index $(distdir)/charsets
+	$(INSTALL_DATA) $(srcdir)/charsets/Index.xml $(distdir)/charsets
 
 all: @AVAILABLE_LANGUAGES_ERRORS@
 
@@ -25,7 +25,7 @@ install-data-local:
 	done
 	$(mkinstalldirs) $(DESTDIR)$(pkgdatadir)/charsets
 	$(INSTALL_DATA) $(srcdir)/charsets/README $(DESTDIR)$(pkgdatadir)/charsets/README
-	$(INSTALL_DATA) $(srcdir)/charsets/Index $(DESTDIR)$(pkgdatadir)/charsets/Index
+	$(INSTALL_DATA) $(srcdir)/charsets/Index.xml $(DESTDIR)$(pkgdatadir)/charsets/Index.xml
 	$(INSTALL_DATA) $(srcdir)/charsets/*.conf $(DESTDIR)$(pkgdatadir)/charsets
 
 fix_errors:

sql/share/charsets/Index.xml

+<?xml version='1.0' encoding="utf-8"?>
+
+<charsets max-id=63>
+
+<description>
+This file lists all of the available character sets.
+To make maintaining easier please:
+ - keep records sorted by collation number.
+ - change charset-list.max-id when adding a new collation.
+</description>
+
+<charset name="big5">
+  <family>Traditional Chinese</family>
+  <alias>big-5</alias>
+  <alias>bigfive</alias>
+  <alias>big-five</alias>
+  <alias>cn-big5</alias>
+  <alias>csbig5</alias>
+  <collation name="big5"	id="1"	order="Chinese"	flag="primary"/>
+</charset>
+
+<charset name="latin2">
+  <family>Central European</family>
+  <alias>csisolatin2</alias>
+  <alias>iso-8859-2</alias>
+  <alias>iso-ir-101</alias>
+  <alias>iso_8859-2</alias>
+  <alias>iso_8859-2:1987</alias>
+  <alias>l2</alias>
+  <collation name="czech" 	id="2"	order="Czech"/>
+  <collation name="latin2"	id="9"	flag="primary">
+    <order>Hungarian</order>
+    <order>Polish</order>
+    <order>Romanian</order>
+    <order>Croatian</order>
+    <order>Slovak</order>
+    <order>Slovenian</order>
+    <order>Sorbian</order>
+  </collation>
+  <collation name="hungarian"	id="21"	order="Hungarian"/>
+  <collation name="croat"	id="27"	order="Croatian"/>
+</charset>
+
+<charset name="dec8">
+  <family>Western</family>
+  <collation name="dec8"	id="3"	flag="primary">
+    <order>Dutch</order>
+    <order>English</order>
+    <order>French</order>
+    <order>German Duden</order>
+    <order>Italian</order>
+    <order>Latin</order>
+    <order>Pogtuguese</order>
+    <order>Spanish</order>
+  </collation>
+</charset>
+
+<charset name="pclatin1">
+  <family>Western</family>
+  <alias>850</alias>
+  <alias>cp850</alias>
+  <alias>cspc850multilingual</alias>
+  <alias>ibm850</alias>
+  <collation name="dos"	id="4"	flag="primary">
+    <order>Dutch</order>
+    <order>English</order>
+    <order>French</order>
+    <order>German Duden</order>
+    <order>Italian</order>
+    <order>Latin</order>
+    <order>Pogtuguese</order>
+    <order>Spanish</order>
+  </collation>
+</charset>
+
+<charset name="latin1">
+  <family>Western</family>
+  <alias>csisolatin1</alias>
+  <alias>csisolatin1</alias>
+  <alias>iso-8859-1</alias>
+  <alias>iso-ir-100</alias>
+  <alias>iso_8859-1</alias>
+  <alias>iso_8859-1:1987</alias>
+  <alias>l1</alias>
+  <alias>latin1</alias>
+  <collation name="german1"		id="5"	order="German Duden"/>
+  <collation name="latin1"		id="8"	order="Finnish, Swedish"	flag="primary"/>
+  <collation name="danish"		id="15"	order="Danish"/>
+  <collation name="latin1_de"		id="31"	order="German DIN"/>
+  <collation name="latin1_bin"		id="47"	order="Binary"/>
+  <collation name="latin1_ci_as"	id="48">
+    <order>Dutch</order>
+    <order>English</order>
+    <order>French</order>
+    <order>German Duden</order>
+    <order>Italian</order>
+    <order>Latin</order>
+    <order>Pogtuguese</order>
+    <order>Spanish</order>
+  </collation>
+  <collation name="latin1_cs_as"	id="49">
+    <order>Dutch</order>
+    <order>English</order>
+    <order>French</order>
+    <order>German Duden</order>
+    <order>Italian</order>
+    <order>Latin</order>
+    <order>Pogtuguese</order>
+    <order>Spanish</order>
+  </collation>
+</charset>
+
+<charset name="hp8">
+  <family>Western</family>
+  <alias>hproman8</alias>
+  <collation name="hp8"		id="6"	flag="primary">
+    <order>Dutch</order>
+    <order>English</order>
+    <order>French</order>
+    <order>German Duden</order>
+    <order>Italian</order>
+    <order>Latin</order>
+    <order>Pogtuguese</order>
+    <order>Spanish</order>
+  </collation>
+</charset>
+
+<charset name="koi8_ru">
+  <family>Cyrillic</family>
+  <alias>koi8-ru</alias>
+  <alias>cskoi8r</alias>
+  <collation name="koi8_ru"	id="7"	order="Russian"	flag="primary"/>
+</charset>
+
+<charset name="swe7">
+  <family>Western</family>
+  <alias>iso-646-se</alias>
+  <collation name="swe7"	id="10"	order="Swedish"	flag="primary"/>
+</charset>
+
+<charset name="ascii">
+  <family>Western</family>
+  <alias>us</alias>
+  <alias>us-ascii</alias>
+  <alias>csascii</alias>
+  <alias>iso-ir-6</alias>
+  <alias>iso646-us</alias>
+  <collation name="usa7"	id="11"	order="Egnlish"	flag="primary"/>
+</charset>
+
+<charset name="ujis">
+  <family>Japanese</family>
+  <alias>euc-jp</alias>
+  <collation name="ujis"	id="12"	order="Japanese"	flag="primary"/>
+</charset>
+
+<charset name="sjis">
+  <family>Japanese</family>
+  <alias>s-jis</alias>
+  <alias>shift-jis</alias>
+  <alias>x-sjis</alias>
+  <collation name="sjis" 	id="13"	order="Japanese"	flag="primary"/>
+</charset>
+
+<charset name="cp1251">
+  <family>Cyrillic</family>
+  <alias>windows-1251</alias>
+  <alias>ms-cyr</alias>
+  <alias>ms-cyrillic</alias>
+  <collation name="cp1251"	id="14"	flag="primary">
+    <order>Belarusian</order>
+    <order>Bulgarian</order>
+    <order>Macedonian</order>
+    <order>Russian</order>
+    <order>Serbian</order>
+    <order>Mongolian</order>
+    <order>Ukrainian</order>
+  </collation>
+  <collation name="win1251ukr" 		id="23"	order="<Depreciated>"/>
+  <collation name="cp1251_bin"		id="50"	order="Binary"/>
+  <collation name="cp1251_ci_as"	id="51">
+    <order>Belarusian</order>
+    <order>Bulgarian</order>
+    <order>Macedonian</order>
+    <order>Russian</order>
+    <order>Serbian</order>
+    <order>Mongolian</order>
+    <order>Ukrainian</order>
+  </collation>
+  <collation name="cp1251_cs_as"	id="52">
+    <order>Belarusian</order>
+    <order>Bulgarian</order>
+    <order>Macedonian</order>
+    <order>Russian</order>
+    <order>Serbian</order>
+    <order>Mongolian</order>
+    <order>Ukrainian</order>
+  </collation>
+</charset>
+
+<charset name="hebrew">
+  <family>Hebrew</family>
+  <alias>csisolatinhebrew</alias>
+  <alias>iso-8859-8</alias>
+  <alias>iso-ir-138</alias>
+  <collation name="hebrew"	id="16"	order="Hebrew"	flag="primary"/>
+</charset>
+
+<charset name="tis620">
+  <family>Thai</family>
+  <alias>tis-620</alias>
+  <collation name="tis620"	id="18"	order="Thai"	flag="primary"/>
+</charset>
+
+<charset name="euc_kr">
+  <family>Korean</family>
+  <alias>euckr</alias>
+  <alias>euc-kr</alias>
+  <collation name="euc_kr"	id="19"	order="Korean"	flag="primary"/>
+</charset>
+
+<charset name="latin7">
+  <family>Baltic</family>
+  <alias>BalticRim</alias>
+  <alias>iso-8859-13</alias>
+  <alias>l7</alias>
+  <collation name="estonia"	id="20"	order="Estonian"	flag="primary"/>
+  <collation name="latvian"	id="41"	order="Latvian"/>
+  <collation name="latvian1"	id="42"	order="Latvian"/>
+</charset>
+
+<charset name="koi8_ukr">
+  <family>Cyrillic</family>
+  <alias>koi8-u</alias>
+  <collation name="koi8_ukr"	id="22"	order="Ukranian"	flag="primary"/>
+</charset>
+
+<charset name="gb2312">
+  <family>Simplified Chinese</family>
+  <alias>chinese</alias>
+  <alias>iso-ir-58</alias>
+  <collation name="gb2312"	id="24"	order="Chinese"	flag="primary"/>
+</charset>
+
+<charset name="greek">
+  <family>Greek</family>
+  <alias>csisolatingreek</alias>
+  <alias>ecma-118</alias>
+  <alias>greek8</alias>
+  <alias>iso-8859-7</alias>
+  <alias>iso-ir-126</alias>
+  <collation name="greek" 	id="25"	order="Greek"	flag="primary"/>
+</charset>
+
+<charset name="cp1250">
+  <family>Central European</family>
+  <alias>ms-ce</alias>
+  <alias>windows-1250</alias>
+  <collation name="win1250"	id="26"	flag="primary">
+    <order>Hungarian</order>
+    <order>Polish</order>
+    <order>Romanian</order>
+    <order>Croatian</order>
+    <order>Slovak</order>
+    <order>Slovenian</order>
+    <order>Sorbian</order>
+  </collation>
+  <collation name="win1250ch"	id="34"	order="Czech"/>
+</charset>
+
+<charset name="gbk">
+  <family>East Asian</family>
+  <alias>cp936</alias>
+  <collation name="gbk"		id="28"	order="Chinese"	flag="primary"/>
+</charset>
+
+<charset name="cp1257">
+  <family>Baltic</family>
+  <alias>WinBaltRim</alias>
+  <alias>windows-1257</alias>
+  <collation name="cp1257"		id="29"	order="<Depreciated>"/>
+  <collation name="cp1257_bin"		id="58"	order="Binary"/>
+  <collation name="cp1257_ci_ai"	id="59"	flag="primary">
+    <order>Latvian</order>
+    <order>Lithuanian</order>
+  </collation>
+  <collation name="cp1257_ci_as"	id="60">
+    <order>Latvian</order>
+    <order>Lithuanian</order>
+  </collation>
+  <collation name="cp1257_cs_as"	id="61">
+    <order>Latvian</order>
+    <order>Lithuanian</order>
+  </collation>
+</charset>
+
+<charset name="latin5">
+  <family>South Asian</family>
+  <alias>csisolatin5</alias>
+  <alias>iso-8859-9</alias>
+  <alias>iso-ir-148</alias>
+  <alias>l5</alias>
+  <alias>latin5</alias>
+  <alias>turkish</alias>
+  <collation name="latin5"	id="30"	order="Turkish"	flag="primary"/>
+</charset>
+
+<charset name="armscii8">
+  <family>South Asian</family>
+  <alias>armscii-8</alias>
+  <collation name="armscii8"	id="32"	order="Armenian"	flag="primary"/>
+</charset>
+
+<charset name="utf8">
+  <family>Unicode</family>
+  <alias>utf-8</alias>
+  <collation name="utf8"	id="33"	flag="primary"/>
+</charset>
+
+<charset name="ucs2">
+  <family>Unicode</family>
+  <collation name="ucs2"	id="35"	flag="primary"/>
+</charset>
+
+<charset name="cp866">
+  <family>Cyrillic</family>
+  <alias>866</alias>
+  <alias>csibm866</alias>
+  <alias>ibm866</alias>
+  <collation name="cp866"	id="36"	order="Russian"	flag="primary"/>
+</charset>
+
+<charset name="keybcs2">
+  <family>Central European</family>
+  <collation name="keybcs2"	id="37"	order="Czech"	flag="primary"/>
+</charset>
+
+<charset name="MacCE">
+  <family>Central European</family>
+  <alias>MacCentralEurope</alias>
+  <collation name="macce"	id="38"	flag="primary">
+    <order>Hungarian</order>
+    <order>Polish</order>
+    <order>Romanian</order>
+    <order>Croatian</order>
+    <order>Slovak</order>
+    <order>Slovenian</order>
+    <order>Sorbian</order>
+  </collation>
+  <collation name="macce_bin"	id="43"	order="Binary"/>
+  <collation name="macce_ci_ai"	id="44">
+    <order>Hungarian</order>
+    <order>Polish</order>
+    <order>Romanian</order>
+    <order>Croatian</order>
+    <order>Slovak</order>
+    <order>Slovenian</order>
+    <order>Sorbian</order>
+  </collation>
+  <collation name="macce_ci_as"	id="45">
+    <order>Hungarian</order>
+    <order>Polish</order>
+    <order>Romanian</order>
+    <order>Croatian</order>
+    <order>Slovak</order>
+    <order>Slovenian</order>
+    <order>Sorbian</order>
+  </collation>
+  <collation name="macce_cs_as"	id="46">
+    <order>Hungarian</order>
+    <order>Polish</order>
+    <order>Romanian</order>
+    <order>Croatian</order>
+    <order>Slovak</order>
+    <order>Slovenian</order>
+    <order>Sorbian</order>
+  </collation>
+</charset>
+
+<charset name="MacRoman">
+  <family>Western</family>
+  <alias>Mac</alias>
+  <alias>Macintosh</alias>
+  <alias>csmacintosh</alias>
+  <collation name="macroman"		id="39"	flag="primary">
+    <order>Dutch</order>
+    <order>English</order>
+    <order>French</order>
+    <order>German Duden</order>
+    <order>Italian</order>
+    <order>Latin</order>
+    <order>Pogtuguese</order>
+    <order>Spanish</order>
+  </collation>
+  <collation name="macroman_bin"	id="53"	order="Binary"/>
+  <collation name="macroman_ci_as"	id="54">
+    <order>Dutch</order>
+    <order>English</order>
+    <order>French</order>
+    <order>German Duden</order>
+    <order>Italian</order>
+    <order>Latin</order>
+    <order>Pogtuguese</order>
+    <order>Spanish</order>
+  </collation>
+  <collation name="macroman_ci_ai"	id="55">
+    <order>Dutch</order>
+    <order>English</order>
+    <order>French</order>
+    <order>German Duden</order>
+    <order>Italian</order>
+    <order>Latin</order>
+    <order>Pogtuguese</order>
+    <order>Spanish</order>
+  </collation>
+  <collation name="macroman_cs_as"	id="56">
+    <order>Dutch</order>
+    <order>English</order>
+    <order>French</order>
+    <order>German Duden</order>
+    <order>Italian</order>
+    <order>Latin</order>
+    <order>Pogtuguese</order>
+    <order>Spanish</order>
+  </collation>
+</charset>
+
+<charset name="pclatin2">
+  <family>Central European</family>
+  <alias>852</alias>
+  <alias>cp852</alias>
+  <alias>ibm852</alias>
+  <collation name="pclatin2"	id="40"	flag="primary">
+    <order>Hungarian</order>
+    <order>Polish</order>
+    <order>Romanian</order>
+    <order>Croatian</order>
+    <order>Slovak</order>
+    <order>Slovenian</order>
+    <order>Sorbian</order>
+  </collation>
+</charset>
+
+<charset name="cp1256">
+  <family>Arabic</family>
+  <alias>ms-arab</alias>
+  <alias>windows-1256</alias>
+  <collation name="cp1256"	id="57"	order="Arabic"	flag="primary"/>
+</charset>
+
+<charset name="binary">
+  <collation name="binary"	id="63"	order="Binary"	flag="primary"/>
+</charset>
+
+</charsets>

sql/sql_prepare.cc

@@ -440,10 +440,9 @@ static bool mysql_test_upd_fields(PREP_STMT *stmt, TABLE_LIST *table_list,
 				  COND *conds)
 {
   THD *thd= stmt->thd;
-  TABLE *table;
   DBUG_ENTER("mysql_test_upd_fields");
 
-  if (!(table = open_ltable(thd,table_list,table_list->lock_type)))
+  if (open_and_lock_tables(thd, table_list))
     DBUG_RETURN(1);
 
   if (setup_tables(table_list) || setup_fields(thd,table_list,fields,1,0,0) || 
@@ -477,13 +476,12 @@ static bool mysql_test_select_fields(PREP_STMT *stmt, TABLE_LIST *tables,
 				     COND *conds, ORDER *order, ORDER *group,
 				     Item *having)
 {
-  TABLE *table;
   bool hidden_group_fields;
   THD *thd= stmt->thd;
   List<Item>  all_fields(fields);
   DBUG_ENTER("mysql_test_select_fields");
 
-  if (!(table = open_ltable(thd,tables,TL_READ)))
+  if (open_and_lock_tables(thd, tables))
     DBUG_RETURN(1);
   
   thd->used_tables=0;	// Updated by setup_fields
@@ -512,7 +510,7 @@ static bool mysql_test_select_fields(PREP_STMT *stmt, TABLE_LIST *tables,
      sending any info on where clause.
   */
   if (send_prep_stmt(stmt, fields.elements) ||
-      thd->protocol_prep.send_fields(&fields,0) ||
+      thd->protocol_simple.send_fields(&fields,0) ||
       send_item_params(stmt))
     DBUG_RETURN(1);
   DBUG_RETURN(0);  
@@ -626,14 +624,17 @@ static bool parse_prepare_query(PREP_STMT *stmt,
 /*
   Initialize parameter items in statement
 */
-static bool init_param_items(THD *thd, PREP_STMT *stmt)
+
+static bool init_param_items( PREP_STMT *stmt)
 {
+  List<Item> &params= stmt->thd->lex.param_list;
   Item_param **to;
+  
   if (!(stmt->param= to= (Item_param **)
         my_malloc(sizeof(Item_param *)*(stmt->param_count+1), 
                   MYF(MY_WME))))
     return 1;
-  List_iterator<Item> param_iterator(thd->lex.param_list);
+  List_iterator<Item> param_iterator(params);
   while ((*(to++) = (Item_param *)param_iterator++));
   return 0;
 }
@@ -659,29 +660,32 @@ bool mysql_stmt_prepare(THD *thd, char *packet, uint packet_length)
   DBUG_ENTER("mysql_stmt_prepare");
 
   bzero((char*) &stmt, sizeof(stmt));
-  stmt.thd= thd;
+  
   stmt.stmt_id= ++thd->current_stmt_id;
   init_sql_alloc(&stmt.mem_root, 8192, 8192);
+  
+  stmt.thd= thd;
+  stmt.thd->mem_root= stmt.mem_root;
 
-  thd->mem_root= stmt.mem_root;
-  if (alloc_query(thd, packet, packet_length))
+  if (alloc_query(stmt.thd, packet, packet_length))
     goto err;
+
   if (parse_prepare_query(&stmt, thd->query, thd->query_length))
     goto err;
 
   if (!(specialflag & SPECIAL_NO_PRIOR))
     my_pthread_setprio(pthread_self(),WAIT_PRIOR);
   
-  if (init_param_items(thd, &stmt))
+  if (init_param_items(&stmt))
     goto err;
   
-  stmt.mem_root= thd->mem_root;  
+  stmt.mem_root= stmt.thd->mem_root;  
   tree_insert(&thd->prepared_statements, (void *)&stmt, 0, (void *)0);
   thd->mem_root= thd_root; // restore main mem_root
   DBUG_RETURN(0);
 
 err:
-  stmt.mem_root= thd->mem_root;
+  stmt.mem_root= stmt.thd->mem_root;  
   free_prep_stmt(&stmt, free_free, (void*) 0);
   thd->mem_root = thd_root;	// restore main mem_root
   DBUG_RETURN(1);
@@ -727,9 +731,9 @@ void mysql_stmt_execute(THD *thd, char *packet)
     mysql_delete(), mysql_update() and mysql_select() to not to 
     have re-check on setup_* and other things ..
   */  
-  thd->protocol= &thd->protocol_prep;		// Switch to binary protocol
+  stmt->thd->protocol= &thd->protocol_prep;		// Switch to binary protocol
   mysql_execute_command(stmt->thd);
-  thd->protocol= &thd->protocol_simple;		// Use normal protocol
+  stmt->thd->protocol= &thd->protocol_simple;		// Use normal protocol
 
   if (!(specialflag & SPECIAL_NO_PRIOR))
     my_pthread_setprio(pthread_self(), WAIT_PRIOR);