SCRUM

embedded-related changes


include/mysql_com.h:
  net_flush emptification
libmysqld/lib_sql.cc:
  Some Protocol:: methods implemented
sql/convert.cc:
  changes to use convert in embedded library
sql/field.cc:
  set_key_image changed
sql/item.cc:
  obsolete functions removed
sql/item.h:
  embedded-related changes in Protocol class
sql/log.cc:
  there's no ports in embedded library
sql/mysqld.cc:
  some debug stuff
sql/protocol.cc:
  embedded-related changes
sql/protocol.h:
  embedded-related changes
sql/sql_cache.cc:
  comment added
sql/sql_class.cc:
  no need to do special embedded select_send::send_row
sql/sql_class.h:
  embedded-related changes
sql/sql_parse.cc:
  comments added debugging stuff deleted
sql/sql_show.cc:
  non-protocol sending removed

include/mysql_com.h

@@ -227,7 +227,12 @@ void	my_net_local_init(NET *net);
 void	net_end(NET *net);
 void	net_clear(NET *net);
 my_bool net_realloc(NET *net, unsigned long length);
+#ifndef EMBEDDED_LIBRARY
 my_bool	net_flush(NET *net);
+#else
+#define net_flush(A) (0)
+#endif
+
 my_bool	my_net_write(NET *net,const char *packet,unsigned long len);
 my_bool	net_write_command(NET *net,unsigned char command,
 			  const char *header, unsigned long head_len,

libmysqld/lib_sql.cc

@@ -345,81 +345,6 @@ void *create_embedded_thd(int client_flag, char *db)
 
 C_MODE_END
 
-bool send_fields(THD *thd, List<Item> &list, uint flag)
-{
-  List_iterator_fast<Item> it(list);
-  Item                     *item;
-  MEM_ROOT                 *alloc;
-  MYSQL_FIELD              *field, *client_field;
-  unsigned int             field_count= list.elements;
-  MYSQL                    *mysql= thd->mysql;
-  
-  if (!(mysql->result=(MYSQL_RES*) my_malloc(sizeof(MYSQL_RES)+
-				      sizeof(ulong) * (field_count + 1),
-				      MYF(MY_WME | MY_ZEROFILL))))
-    goto err;
-  mysql->result->lengths= (ulong *)(mysql->result + 1);
-
-  mysql->field_count=field_count;
-  alloc= &mysql->field_alloc;
-  field= (MYSQL_FIELD *)alloc_root(alloc, sizeof(MYSQL_FIELD)*list.elements);
-  if (!field)
-    goto err;
-
-  client_field= field;
-  while ((item= it++))
-  {
-    Send_field server_field;
-    item->make_field(&server_field);
-
-    client_field->table=  strdup_root(alloc, server_field.table_name);
-    client_field->name=   strdup_root(alloc,server_field.col_name);
-    client_field->length= server_field.length;
-    client_field->type=   server_field.type;
-    client_field->flags= server_field.flags;
-    client_field->decimals= server_field.decimals;
-
-    if (INTERNAL_NUM_FIELD(client_field))
-      client_field->flags|= NUM_FLAG;
-
-    if (flag & 2)
-    {
-      char buff[80];
-      String tmp(buff, sizeof(buff), default_charset_info), *res;
-
-      if (!(res=item->val_str(&tmp)))
-	client_field->def= strdup_root(alloc, "");
-      else
-	client_field->def= strdup_root(alloc, tmp.ptr());
-    }
-    else
-      client_field->def=0;
-    client_field->max_length= 0;
-    ++client_field;
-  }
-  mysql->result->fields = field;
-
-  if (!(mysql->result->data= (MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
-				       MYF(MY_WME | MY_ZEROFILL))))
-    goto err;
-
-  init_alloc_root(&mysql->result->data->alloc,8192,0);	/* Assume rowlength < 8192 */
-  mysql->result->data->alloc.min_malloc=sizeof(MYSQL_ROWS);
-  mysql->result->data->rows=0;
-  mysql->result->data->fields=field_count;
-  mysql->result->field_count=field_count;
-  mysql->result->data->prev_ptr= &mysql->result->data->data;
-
-  mysql->result->field_alloc=	mysql->field_alloc;
-  mysql->result->current_field=0;
-  mysql->result->current_row=0;
-
-  return 0;
- err:
-  send_error(thd, ER_OUT_OF_RESOURCES);	/* purecov: inspected */
-  return 1;					/* purecov: inspected */
-}
-
 bool Protocol::send_fields(List<Item> *list, uint flag)
 {
   List_iterator_fast<Item> it(*list);
@@ -429,6 +354,7 @@ bool Protocol::send_fields(List<Item> *list, uint flag)
   
   DBUG_ENTER("send_fields");
 
+  field_count= list->elements;
   if (!(mysql->result=(MYSQL_RES*) my_malloc(sizeof(MYSQL_RES)+
 				      sizeof(ulong) * (field_count + 1),
 				      MYF(MY_WME | MY_ZEROFILL))))
@@ -495,90 +421,15 @@ bool Protocol::send_fields(List<Item> *list, uint flag)
   DBUG_RETURN(1);				/* purecov: inspected */
 }
 
-bool Protocol::write()
+bool Protocol::send_records_num(List<Item> *list, ulonglong records)
 {
-  *next_field= 0;
   return false;
 }
 
-
-/* Get the length of next field. Change parameter to point at fieldstart */
-static ulong
-net_field_length(uchar **packet)
-{
-  reg1 uchar *pos= *packet;
-  if (*pos < 251)
-  {
-    (*packet)++;
-    return (ulong) *pos;
-  }
-  if (*pos == 251)
-  {
-    (*packet)++;
-    return NULL_LENGTH;
-  }
-  if (*pos == 252)
-  {
-    (*packet)+=3;
-    return (ulong) uint2korr(pos+1);
-  }
-  if (*pos == 253)
-  {
-    (*packet)+=4;
-    return (ulong) uint3korr(pos+1);
-  }
-  (*packet)+=9;					/* Must be 254 when here */
-  return (ulong) uint4korr(pos+1);
-}
-
-
-bool select_send::send_data(List<Item> &items)
+bool Protocol::write()
 {
-  List_iterator_fast<Item> li(items);
-  Item                     *item;
-  MYSQL_ROWS               *cur;
-  int                      n_fields= items.elements;
-  ulong                    len;
-  CONVERT                  *convert= thd->variables.convert_set;
-  CHARSET_INFO             *charset_info= thd->packet.charset();
-  MYSQL_DATA               *result= thd->mysql->result->data;
-  MEM_ROOT                 *alloc= &result->alloc;
-  MYSQL_ROW                cur_field;
-  MYSQL_FIELD              *mysql_fields= thd->mysql->result->fields;
-
-  DBUG_ENTER("send_data");
-
-  if (unit->offset_limit_cnt)
-  {						// using limit offset,count
-    unit->offset_limit_cnt--;
-    DBUG_RETURN(0);
-  }
-
-  result->rows++;
-  if (!(cur= (MYSQL_ROWS *)alloc_root(alloc, sizeof(MYSQL_ROWS)+(n_fields + 1) * sizeof(char *))))
-  {
-    my_error(ER_OUT_OF_RESOURCES,MYF(0));
-    DBUG_RETURN(1);
-  }
-  cur->data= (MYSQL_ROW)(((char *)cur) + sizeof(MYSQL_ROWS));
-
-  *result->prev_ptr= cur;
-  result->prev_ptr= &cur->next;
-  cur_field=cur->data;
-  for (item=li++; item; item=li++, cur_field++, mysql_fields++)
-  {
-    if (item->embedded_send(convert, charset_info, alloc, cur_field, &len))
-    {
-      my_error(ER_OUT_OF_RESOURCES,MYF(0));
-      DBUG_RETURN(1);
-    }
-    if (mysql_fields->max_length < len)
-      mysql_fields->max_length=len;
-  }
-
-  *cur_field= 0;
-
-  DBUG_RETURN(0);
+  *next_field= 0;
+  return false;
 }
 
 void
@@ -598,86 +449,8 @@ send_ok(THD *thd,ha_rows affected_rows,ulonglong id,const char *message)
 void
 send_eof(THD *thd, bool no_flush)
 {
-/*  static char eof_buff[1]= { (char) 254 };
-  NET *net= &thd->net;
-  DBUG_ENTER("send_eof");
-  if (net->vio != 0)
-  {
-    if (!no_flush && (thd->client_capabilities & CLIENT_PROTOCOL_41))
-    {
-      char buff[5];
-      uint tmp= min(thd->total_warn_count, 65535);
-      buff[0]=254;
-      int2store(buff+1, tmp);
-      int2store(buff+3, 0);			// No flags yet
-      VOID(my_net_write(net,buff,5));
-      VOID(net_flush(net));
-    }
-    else
-    {
-      VOID(my_net_write(net,eof_buff,1));
-      if (!no_flush)
-	VOID(net_flush(net));
-    }
-  }
-  DBUG_VOID_RETURN;
-*/
 }
 
-#ifdef DUMMY
-int embedded_send_row(THD *thd, int n_fields, const char *data, int data_len)
-{
-  MYSQL                    *mysql= thd->mysql;
-  MYSQL_DATA               *result= mysql->result->data;
-  MYSQL_ROWS               **prev_ptr= &mysql->result->data->data;
-  MYSQL_ROWS               *cur;
-  MEM_ROOT                 *alloc= &mysql->result->data->alloc;
-  char                     *to;
-  uchar                    *cp;
-  MYSQL_FIELD              *mysql_fields= mysql->result->fields;
-  MYSQL_ROW                cur_field, end_field;
-  ulong                    len;
-
-  DBUG_ENTER("embedded_send_row");
-
-  result->rows++;
-  if (!(cur= (MYSQL_ROWS *)alloc_root(alloc, sizeof(MYSQL_ROWS) + (n_fields + 1) * sizeof(MYSQL_ROW) + data_len)))
-  {
-    my_error(ER_OUT_OF_RESOURCES,MYF(0));
-    DBUG_RETURN(1);
-  }
-  cur->data= (MYSQL_ROW)(cur + 1);
-
-  *result->prev_ptr= cur;
-  result->prev_ptr= &cur->next;
-  to= (char*) (cur->data+n_fields+1);
-  cp= (uchar *)data;
-  end_field= cur->data + n_fields;
-  
-  for (cur_field=cur->data; cur_field<end_field; cur_field++, mysql_fields++)
-  {
-    if ((len= (ulong) net_field_length(&cp)) == NULL_LENGTH)
-    {
-      *cur_field = 0;
-    }
-    else
-    {
-      *cur_field= to;
-      memcpy(to,(char*) cp,len);
-      to[len]=0;
-      to+=len+1;
-      cp+=len;
-      if (mysql_fields->max_length < len)
-	mysql_fields->max_length=len;
-    }
-  }
-
-  *cur_field= to;
-
-  DBUG_RETURN(0);
-}
-#endif
-
 uint STDCALL mysql_warning_count(MYSQL *mysql)
 {
   return ((THD *)mysql->thd)->total_warn_count;
@@ -688,11 +461,10 @@ void Protocol_simple::prepare_for_resend()
   MYSQL_ROWS               *cur;
   ulong                    len;
   MYSQL_DATA               *result= thd->mysql->result->data;
-  MEM_ROOT                 *alloc= &result->alloc;
-  MYSQL_FIELD              *mysql_fields= thd->mysql->result->fields;
 
   DBUG_ENTER("send_data");
 
+  alloc= &result->alloc;
   result->rows++;
   if (!(cur= (MYSQL_ROWS *)alloc_root(alloc, sizeof(MYSQL_ROWS)+(field_count + 1) * sizeof(char *))))
   {
@@ -704,26 +476,44 @@ void Protocol_simple::prepare_for_resend()
   *result->prev_ptr= cur;
   result->prev_ptr= &cur->next;
   next_field=cur->data;
+  next_mysql_field= thd->mysql->result->fields;
 
   DBUG_VOID_RETURN;
 }
 
+bool Protocol_simple::store_null()
+{
+  *(next_field++)= NULL;
+  ++next_mysql_field;
+  return false;
+}
+
 bool Protocol::net_store_data(const char *from, uint length)
 {
-  MYSQL_FIELD *mysql_fields= thd->mysql->result->fields;
-  if (!length)
-  {
-    *next_field= NULL;
-  }
-  else
-  {
   if (!(*next_field=alloc_root(alloc, length + 1)))
     return true;
   memcpy(*next_field, from, length);
   (*next_field)[length]= 0;
-  }
+  if (next_mysql_field->max_length < length)
+    next_mysql_field->max_length=length;
+  ++next_field;
+  ++next_mysql_field;
+
+  return false;
+}
+
+/* The same as Protocol::net_store_data but does the converstion
+*/
+bool Protocol::convert_str(const char *from, uint length)
+{
+  if (!(*next_field=alloc_root(alloc, length + 1)))
+    return true;
+  convert->store_dest(*next_field, from, length);
+  (*next_field)[length]= 0;
+  if (next_mysql_field->max_length < length)
+    next_mysql_field->max_length=length;
   ++next_field;
-  if (mysql_fields->max_length < length)
-    mysql_fields->max_length=length;
+  ++next_mysql_field;
+
   return false;
 }

sql/convert.cc

@@ -457,18 +457,6 @@ bool CONVERT::store(String *packet,const char *from,uint length)
     return 1;
   char *to=(char*) net_store_length((char*) packet->ptr()+packet_length,
 				    (ulonglong)length);
-
-  for (const char *end=from+length ; from != end ; from++)
-    *to++= to_map[(uchar) *from];
-  packet->length((uint) (to-packet->ptr()));
+  packet->length((uint) (store_dest(to, from, length)-packet->ptr()));
   return 0;
 }
-
-#ifdef EMBEDDED_LIBRARY
-void CONVERT::convert_back(char *dest, const char *source, uint length) const
-{
-  for (char *end= dest+length; dest < end; dest++, source++)
-    *dest= to_map[*source];
-}
-#endif
-

sql/field.cc

@@ -4589,7 +4589,7 @@ void Field_geom::get_key_image(char *buff,uint length,CHARSET_INFO *cs, imagetyp
 
 void Field_geom::set_key_image(char *buff,uint length,CHARSET_INFO *cs)
 {
-  Field_blob::set_key_image(buff, length);
+  Field_blob::set_key_image(buff, length, cs);
 }
 
 void Field_geom::sql_type(String &res) const

sql/item.cc

@@ -1006,64 +1006,6 @@ bool Item_field::send(Protocol *protocol, String *buffer)
   return protocol->store(result_field);
 }
 
-#ifdef EMBEDDED_LIBRARY
-bool Item::embedded_send(const CONVERT *convert, CHARSET_INFO *charset, MEM_ROOT *alloc, 
-			 char **result, ulong *length)
-{
-  char buff[MAX_FIELD_WIDTH];
-  String s(buff, sizeof(buff), charset), *value;
-  if (!(value=val_str(&s)))
-  {
-    *result= NULL;
-    *length= 0;
-    return false;
-  }
-  if (!(*result=alloc_root(alloc, value->length() + 1)))
-    return true;
-  *length= value->length();
-  if (convert)
-    convert->convert_back(*result, value->ptr(), *length);
-  else
-    memcpy(*result, value->ptr(), *length);
-  (*result)[*length]= 0;
-  return false;
-}
-
-bool Item_null::embedded_send(const CONVERT *convert, CHARSET_INFO *charset, MEM_ROOT *alloc, 
-			     char **result, ulong *length)
-{
-  *result= NULL;
-  *length= 0;
-  return false;
-}
-
-bool Item_field::embedded_send(const CONVERT *convert, CHARSET_INFO *charset, MEM_ROOT *alloc, 
-			       char **result, ulong *length)
-{
-  if (result_field->is_null())
-  {
-    *result= NULL;
-    *length= 0;
-    return false;
-  }
-
-  char buff[MAX_FIELD_WIDTH];
-  String tmp(buff,sizeof(buff),default_charset_info);
-  result_field->val_str(&tmp,&tmp);
-
-  if (!(*result=alloc_root(alloc, tmp.length() + 1)))
-    return true;
-  *length= tmp.length();
-  if (convert)
-    convert->convert_back(*result, tmp.ptr(), *length);
-  else
-    memcpy(*result, tmp.ptr(), *length);
-  (*result)[*length]= 0;
-  return false;
-}
-
-#endif
-
 /*
   This is used for HAVING clause
   Find field in select list having the same name

sql/item.h

@@ -19,7 +19,6 @@
 #pragma interface			/* gcc class implementation */
 #endif
 
-class CONVERT;
 class Protocol;
 struct st_table_list;
 void item_init(void);			/* Init item functions */
@@ -64,10 +63,6 @@ class Item {
   virtual int save_safe_in_field(Field *field)
   { return save_in_field(field, 1); }
   virtual bool send(Protocol *protocol, String *str);
-#ifdef EMBEDDED_LIBRARY
-  virtual bool embedded_send(const CONVERT *convert, CHARSET_INFO *charset, MEM_ROOT *alloc, 
-			     char **result, ulong *length);
-#endif
   virtual bool eq(const Item *, bool binary_cmp) const;
   virtual Item_result result_type () const { return REAL_RESULT; }
   virtual enum_field_types field_type() const;
@@ -155,10 +150,6 @@ class Item_field :public Item_ident
   longlong val_int_result();
   String *str_result(String* tmp);
   bool send(Protocol *protocol, String *str_arg);
-#ifdef EMBEDDED_LIBRARY
-  bool embedded_send(const CONVERT *convert, CHARSET_INFO *charset, MEM_ROOT *alloc, 
-		     char **result, ulong *length);
-#endif
   bool fix_fields(THD *, struct st_table_list *, Item **);
   void make_field(Send_field *tmp_field);
   int save_in_field(Field *field,bool no_conversions);
@@ -192,10 +183,6 @@ class Item_null :public Item
   int save_in_field(Field *field, bool no_conversions);
   int save_safe_in_field(Field *field);
   bool send(Protocol *protocol, String *str);
-#ifdef EMBEDDED_LIBRARY
-  bool embedded_send(const CONVERT *convert, CHARSET_INFO *charset, MEM_ROOT *alloc, 
-		     char **result, ulong *length);
-#endif
   enum Item_result result_type () const { return STRING_RESULT; }
   enum_field_types field_type() const   { return MYSQL_TYPE_NULL; }
   bool fix_fields(THD *thd, struct st_table_list *list, Item **item)
@@ -499,11 +486,6 @@ class Item_ref :public Item_ident
     return (null_value=(*ref)->get_date(ltime,fuzzydate));
   }
   bool send(Protocol *prot, String *tmp){ return (*ref)->send(prot, tmp); }
-#ifdef EMBEDDED_LIBRARY
-  bool embedded_send(const CONVERT *convert, CHARSET_INFO *charset, MEM_ROOT *alloc, 
-		     char **result, ulong *length)
-    { return (*ref)->embedded_send(convert, charset, alloc, result, length); }
-#endif
   void make_field(Send_field *field)	{ (*ref)->make_field(field); }
   bool fix_fields(THD *, struct st_table_list *, Item **);
   int save_in_field(Field *field, bool no_conversions)

sql/log.cc

@@ -23,7 +23,6 @@
 #endif
 
 #include "mysql_priv.h"
-#include <mysql.h>
 #include "sql_acl.h"
 #include "sql_repl.h"
 
@@ -203,7 +202,9 @@ bool MYSQL_LOG::open(const char *log_name, enum_log_type log_type_arg,
   case LOG_NORMAL:
   {
     char *end;
-#ifdef __NT__
+#ifdef EMBEDDED_LIBRARY
+    sprintf(buff, "%s, Version: %s, embedded library\n", my_progname, server_version);
+#elif __NT__
     sprintf(buff, "%s, Version: %s, started with:\nTCP Port: %d, Named Pipe: %s\n", my_progname, server_version, mysql_port, mysql_unix_port);
 #else
     sprintf(buff, "%s, Version: %s, started with:\nTcp port: %d  Unix socket: %s\n", my_progname,server_version,mysql_port,mysql_unix_port);

sql/protocol.cc

@@ -41,6 +41,10 @@ bool Protocol::net_store_data(const char *from, uint length)
   return 0;
 }
 
+inline bool Protocol::convert_str(const char *from, uint length)
+{
+  convert->store(packet, from, length);
+}
 #endif
 
 
@@ -56,7 +60,7 @@ void send_error(THD *thd, uint sql_errno, const char *err)
 		      err ? err : net->last_error[0] ?
 		      net->last_error : "NULL"));
 
-#ifndef EMBEDDED_LIBRARY
+#ifndef EMBEDDED_LIBRARY  /* TODO query cache in embedded library*/
   query_cache_abort(net);
 #endif
   thd->query_error=  1; // needed to catch query errors during replication
@@ -577,6 +581,15 @@ bool Protocol::send_fields(List<Item> *list, uint flag)
   DBUG_RETURN(1);				/* purecov: inspected */
 }
 
+bool Protocol::send_records_num(List<Item> *list, ulonglong records)
+{
+  char *pos;
+  char buff[20];
+  pos=net_store_length(buff, (uint) list->elements);
+  pos=net_store_length(pos, records);
+  return my_net_write(&thd->net, buff,(uint) (pos-buff));
+}
+
 bool Protocol::write()
 {
   DBUG_ENTER("Protocol::write");
@@ -652,7 +665,6 @@ void Protocol_simple::prepare_for_resend()
   field_pos= 0;
 #endif
 }
-#endif
 
 bool Protocol_simple::store_null()
 {
@@ -663,6 +675,7 @@ bool Protocol_simple::store_null()
   buff[0]= (char)251;
   return packet->append(buff, sizeof(buff), PACKET_BUFFET_EXTRA_ALLOC);
 }
+#endif
 
 bool Protocol_simple::store(const char *from, uint length)
 {
@@ -674,7 +687,7 @@ bool Protocol_simple::store(const char *from, uint length)
   field_pos++;
 #endif
   if (convert)
-    return convert->store(packet, from, length);
+    return convert_str(from, length);
   return net_store_data(from, length);
 }
 
@@ -757,7 +770,7 @@ bool Protocol_simple::store(Field *field)
   String tmp(buff,sizeof(buff),default_charset_info);
   field->val_str(&tmp,&tmp);
   if (convert)
-    return convert->store(packet, tmp.ptr(), tmp.length());
+    return convert_str(tmp.ptr(), tmp.length());
   return net_store_data(tmp.ptr(), tmp.length());
 }
 
@@ -863,7 +876,7 @@ bool Protocol_prep::store(const char *from,uint length)
 #endif
   field_pos++;
   if (convert)
-    return convert->store(packet, from, length);
+    return convert_str(from, length);
   return net_store_data(from, length);
 }
 

sql/protocol.h

@@ -23,7 +23,9 @@
 class CONVERT;
 class i_string;
 class THD;
-
+#ifdef EMBEDDED_LIBRARY
+typedef struct st_mysql_field MYSQL_FIELD;
+#endif
 class Protocol
 {
 protected:
@@ -35,11 +37,12 @@ class Protocol
 #endif
   uint field_count;
   bool net_store_data(const char *from, uint length);
+  bool convert_str(const char *from, uint length);
 #ifdef EMBEDDED_LIBRARY
   char **next_field;
+  MYSQL_FIELD *next_mysql_field;
   MEM_ROOT *alloc;
 #endif
-
 public:
   CONVERT *convert;
 
@@ -47,6 +50,7 @@ class Protocol
   Protocol(THD *thd) { init(thd); }
   void init(THD* thd);
   bool send_fields(List<Item> *list, uint flag);
+  bool send_records_num(List<Item> *list, ulonglong records);
   bool store(I_List<i_string> *str_list);
   bool store(const char *from);
   String *storage_packet() { return packet; }

sql/sql_cache.cc

@@ -1022,7 +1022,7 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length)
 			ALIGN_SIZE(sizeof(Query_cache_result))));
 
     Query_cache_result *result = result_block->result();
-#ifndef EMBEDDED_LIBRARY
+#ifndef EMBEDDED_LIBRARY   /* TODO query cache in embedded library*/
     if (net_real_write(&thd->net, result->data(),
 		       result_block->used -
 		       result_block->headers_len() -

sql/sql_class.cc

@@ -516,9 +516,6 @@ bool select_send::send_fields(List<Item> &list,uint flag)
   return thd->protocol->send_fields(&list,flag);
 }
 
-
-#ifndef EMBEDDED_LIBRARY
-
 /* Send data to client. Returns 0 if ok */
 
 bool select_send::send_data(List<Item> &items)
@@ -551,7 +548,6 @@ bool select_send::send_data(List<Item> &items)
     DBUG_RETURN(protocol->write());
   DBUG_RETURN(1);
 }
-#endif /* EMBEDDED_LIBRARY */
 
 bool select_send::send_eof()
 {

sql/sql_class.h

@@ -177,10 +177,13 @@ class CONVERT
   {
     convert_array(from_map, (uchar*) a,length);
   }
+  char *store_dest(char *to, const char *from, uint length)
+  {
+    for (const char *end=from+length ; from != end ; from++)
+      *to++= to_map[(uchar) *from];
+    return to;
+  }
   bool store(String *, const char *,uint);
-#ifdef EMBEDDED_LIBRARY
-  void convert_back(char *dest, const char *source, uint length) const;
-#endif
   inline uint number() { return numb; }
 };
 

sql/sql_parse.cc

@@ -857,7 +857,6 @@ extern "C" pthread_handler_decl(handle_bootstrap,arg)
 		 TRANS_MEM_ROOT_BLOCK_SIZE, TRANS_MEM_ROOT_PREALLOC);
   while (fgets(buff, thd->net.max_packet, file))
   {
-    printf("%s", buff);
     uint length=(uint) strlen(buff);
     while (length && (my_isspace(system_charset_info, buff[length-1]) ||
            buff[length-1] == ';'))
@@ -940,9 +939,7 @@ int mysql_table_dump(THD* thd, char* db, char* tbl_name, int fd)
     my_error(ER_GET_ERRNO, MYF(0));
     goto err;
   }
-#ifndef EMBEDDED_LIBRARY
   net_flush(&thd->net);
-#endif
   if ((error = table->file->dump(thd,fd)))
     my_error(ER_GET_ERRNO, MYF(0));
 
@@ -3239,7 +3236,7 @@ mysql_parse(THD *thd, char *inBuf, uint length)
 	else
 	{
 	  mysql_execute_command(thd);
-#ifndef EMBEDDED_LIBRARY
+#ifndef EMBEDDED_LIBRARY  /* TODO query cache in embedded library*/
 	  query_cache_end_of_result(&thd->net);
 #endif
 	}
@@ -3249,7 +3246,7 @@ mysql_parse(THD *thd, char *inBuf, uint length)
     {
       DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
 			 thd->fatal_error));
-#ifndef EMBEDDED_LIBRARY
+#ifndef EMBEDDED_LIBRARY   /* TODO query cache in embedded library*/
       query_cache_abort(&thd->net);
 #endif
     }

sql/sql_show.cc

@@ -687,15 +687,8 @@ mysqld_show_fields(THD *thd, TABLE_LIST *table_list,const char *wild,
     field_list.push_back(new Item_empty_string("Comment",255));
   }
         // Send first number of fields and records
-#ifndef EMBEDDED_LIBRARY
-  {
-    char *pos;
-    pos=net_store_length(tmp, (uint) field_list.elements);
-    pos=net_store_length(pos,(ulonglong) file->records);
-    (void) my_net_write(&thd->net,tmp,(uint) (pos-tmp));
-  }
-#endif
-  if (protocol->send_fields(&field_list,0))
+  if (protocol->send_records_num(&field_list, (ulonglong)file->records) ||
+      protocol->send_fields(&field_list,0))
     DBUG_RETURN(1);
   restore_record(table,2);      // Get empty record
 
@@ -963,9 +956,7 @@ mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)
   restore_record(table,2);              // Get empty record
   if (thd->protocol->send_fields(&field_list,2))
     DBUG_VOID_RETURN;
-#ifndef EMBEDDED_LIBRARY
   VOID(net_flush(&thd->net));
-#endif
   DBUG_VOID_RETURN;
 }
 
@@ -982,7 +973,6 @@ mysqld_dump_create_info(THD *thd, TABLE *table, int fd)
   if (store_create_info(thd, table, packet))
     DBUG_RETURN(-1);
 
-#ifndef EMBEDDED_LIBRARY
   if (protocol->convert)
     protocol->convert->convert((char*) packet->ptr(), packet->length());
   if (fd < 0)
@@ -997,7 +987,6 @@ mysqld_dump_create_info(THD *thd, TABLE *table, int fd)
 		 MYF(MY_WME)))
       DBUG_RETURN(-1);
   }
-#endif
   DBUG_RETURN(0);
 }