Huge pull

23 files changed, 682 insertions, 307 deletions

diff --git a/BitKeeper/etc/logging_ok b/BitKeeper/etc/logging_ok
index 61c80f8b878..d336e692172 100644
--- a/BitKeeper/etc/logging_ok
+++ b/BitKeeper/etc/logging_ok
@@ -18,6 +18,9 @@ heikki@donna.mysql.fi
 heikki@hundin.mysql.fi
 heikki@rescue.
 heikki@work.mysql.com
+hf@bison.(none)
+hf@bisonxp.(none)
+hf@genie.(none)
 jani@dsl-jkl1657.dial.inet.fi
 jani@hynda.(none)
 jani@hynda.mysql.fi
diff --git a/include/mysql.h b/include/mysql.h
index 64b118ca8b1..7f277c15775 100644
--- a/include/mysql.h
+++ b/include/mysql.h
@@ -108,6 +108,9 @@ typedef struct st_mysql_data {
   unsigned int fields;
   MYSQL_ROWS *data;
   MEM_ROOT alloc;
+#ifdef EMBEDDED_LIBRARY
+  MYSQL_ROWS **prev_ptr;
+#endif
 } MYSQL_DATA;
 
 struct st_mysql_options {
@@ -137,13 +140,20 @@ struct st_mysql_options {
    a read that is replication-aware
  */
   my_bool no_master_reads;
+#ifdef EMBEDDED_LIBRARY
+  my_bool separate_thread;
+#endif
 };
 
 enum mysql_option { MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_COMPRESS,
 		    MYSQL_OPT_NAMED_PIPE, MYSQL_INIT_COMMAND,
 		    MYSQL_READ_DEFAULT_FILE, MYSQL_READ_DEFAULT_GROUP,
 		    MYSQL_SET_CHARSET_DIR, MYSQL_SET_CHARSET_NAME,
-		    MYSQL_OPT_LOCAL_INFILE};
+		    MYSQL_OPT_LOCAL_INFILE,
+#ifdef EMBEDDED_LIBRARY
+                    MYSQL_OPT_USE_RESULT
+#endif
+};
 
 enum mysql_status { MYSQL_STATUS_READY,MYSQL_STATUS_GET_RESULT,
 		    MYSQL_STATUS_USE_RESULT};
@@ -156,13 +166,19 @@ enum mysql_status { MYSQL_STATUS_READY,MYSQL_STATUS_GET_RESULT,
 enum mysql_rpl_type { MYSQL_RPL_MASTER, MYSQL_RPL_SLAVE,
 		      MYSQL_RPL_ADMIN };
 
+struct st_mysql_res;
 
 typedef struct st_mysql
 {
   NET		net;			/* Communication parameters */
   gptr		connector_fd;		/* ConnectorFd for SSL */
-  char		*host,*user,*passwd,*unix_socket,*server_version,*host_info,
-		*info,*db;
+#ifndef _0EMBEDDED_LIBRARY
+  char		*host,*user,*passwd,*unix_socket,*server_version,*host_info,*info;
+#endif
+#ifdef EMBEDDED_LIBRARY
+  struct st_mysql_res *result;
+#endif
+  char          *db;
   struct charset_info_st *charset;
   MYSQL_FIELD	*fields;
   MEM_ROOT	field_alloc;
@@ -201,6 +217,9 @@ typedef struct st_mysql
 
 
 typedef struct st_mysql_res {
+#ifdef EMBEDDED_LIBRARY
+  const char    *query_str;
+#endif
   my_ulonglong row_count;
   MYSQL_FIELD	*fields;
   MYSQL_DATA	*data;
diff --git a/include/violite.h b/include/violite.h
index f4f40dcb64b..6f525a362ea 100644
--- a/include/violite.h
+++ b/include/violite.h
@@ -31,8 +31,13 @@
 extern "C" {
 #endif /* __cplusplus */
 
-enum enum_vio_type { VIO_CLOSED, VIO_TYPE_TCPIP, VIO_TYPE_SOCKET,
-		     VIO_TYPE_NAMEDPIPE, VIO_TYPE_SSL};
+enum enum_vio_type { 
+  VIO_CLOSED, VIO_TYPE_TCPIP, VIO_TYPE_SOCKET,
+		     VIO_TYPE_NAMEDPIPE, VIO_TYPE_SSL
+#ifdef EMBEDDED_LIBRARY
+  ,VIO_SHARED_MEMORY, VIO_BUFFER
+#endif
+};
 
 #ifndef __WIN__
 #define HANDLE void *
diff --git a/libmysqld/embedded_priv.h b/libmysqld/embedded_priv.h
index e17b72e84d8..20f74c3ae2f 100644
--- a/libmysqld/embedded_priv.h
+++ b/libmysqld/embedded_priv.h
@@ -28,4 +28,7 @@ extern void end_embedded_connection(NET * net);
 extern void lib_connection_phase(NET *net, int phase);
 extern bool lib_dispatch_command(enum enum_server_command command, NET *net,
 				 const char *arg, ulong length);
+extern void init_embedded_mysql(MYSQL *mysql, int client_flag, char *db);
+extern void *create_embedded_thd(Vio *vio, unsigned char *buff, int client_flag, char *db);
+extern NET *get_mysql_net(MYSQL *mysql);
 C_MODE_END
diff --git a/libmysqld/lib_sql.cc b/libmysqld/lib_sql.cc
index 42ad0021542..3354bc1ea44 100644
--- a/libmysqld/lib_sql.cc
+++ b/libmysqld/lib_sql.cc
@@ -53,7 +53,7 @@ bool lib_dispatch_command(enum enum_server_command command, NET *net,
   return dispatch_command(command, thd, (char *) arg, length + 1);
 }
 
-
+#ifdef _DUMMY
 void lib_connection_phase(NET * net, int phase)
 {
   THD * thd;
@@ -82,7 +82,7 @@ void start_embedded_conn1(NET * net)
   Vio * v  = net->vio;
   if (!v)
   {
-    v = vio_new(0,VIO_CLOSED,0);
+    v = vio_new(0,VIO_BUFFER,0);
     net->vio = v;
   }
   if (v)
@@ -112,9 +112,6 @@ void start_embedded_conn1(NET * net)
   check_connections1(thd);
 }
 
-
-
-
 static int
 check_connections1(THD *thd)
 {
@@ -210,6 +207,9 @@ check_connections2(THD * thd)
   thd->password=test(passwd[0]);
   return 0;
 }
+#else
+C_MODE_END
+#endif /* _DUMMY */
 
 static bool check_user(THD *thd,enum_server_command command, const char *user,
 		       const char *passwd, const char *db, bool check_count)
@@ -593,7 +593,7 @@ void STDCALL mysql_thread_end()
 
 void start_embedded_connection(NET * net)
 {
-  start_embedded_conn1(net);
+//  start_embedded_conn1(net);
 }
 
 void end_embedded_connection(NET * net)
@@ -603,3 +603,384 @@ void end_embedded_connection(NET * net)
 }
 
 } /* extern "C" */
+
+NET *get_mysql_net(MYSQL *mysql)
+{
+  return &((THD *)mysql->net.vio->dest_thd)->net;
+}
+
+void init_embedded_mysql(MYSQL *mysql, int client_flag, char *db)
+{
+  THD *thd = (THD *)mysql->net.vio->dest_thd;
+  mysql->reconnect= 1;			/* Reconnect as default */
+  mysql->server_status= SERVER_STATUS_AUTOCOMMIT;
+
+  mysql->protocol_version= ::protocol_version;
+  mysql->thread_id= thd->thread_id;
+  strmake(mysql->scramble_buff, thd->scramble, 8);
+  mysql->server_capabilities= CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB |
+	               CLIENT_TRANSACTIONS;
+  mysql->server_language= MY_CHARSET_CURRENT;
+  mysql->server_status= thd->server_status;
+  mysql->client_flag= client_flag | mysql->options.client_flag;
+  mysql->db= db;
+  thd->mysql= mysql;
+}
+
+static int embedded_thd_net_init(NET *net, unsigned char *buff)
+{
+  net->buff = buff;
+  if (net_buffer_length > max_allowed_packet)
+    max_allowed_packet= net_buffer_length;
+  net->buff_end= net->buff+(net->max_packet=net_buffer_length);
+  net->vio= NULL;
+  net->no_send_ok= 0;
+  net->error=0; net->return_errno=0; net->return_status=0;
+  net->timeout=(uint) net_read_timeout;		/* Timeout for read */
+  net->pkt_nr= net->compress_pkt_nr=0;
+  net->write_pos= net->read_pos = net->buff;
+  net->last_error[0]= 0;
+  net->compress= 0; 
+  net->reading_or_writing= 0;
+  net->where_b = net->remain_in_buf= 0;
+  net->last_errno= 0;
+  net->query_cache_query= 0;
+  return 0;
+}
+
+void *create_embedded_thd(Vio *vio, unsigned char *buff, int client_flag, char *db)
+{
+  THD * thd= new THD;
+  embedded_thd_net_init(&thd->net, buff);
+
+  /* if (protocol_version>9) */
+  thd->net.return_errno=1;
+  thd->thread_id= thread_id++;
+
+  if (thd->store_globals())
+  {
+    fprintf(stderr,"store_globals failed.\n");
+    return NULL;
+  }
+
+  thd->mysys_var= my_thread_var;
+  thd->dbug_thread_id= my_thread_id();
+  thd->thread_stack= (char*) &thd;
+
+  if (thd->max_join_size == HA_POS_ERROR)
+    thd->options |= OPTION_BIG_SELECTS;
+
+  thd->proc_info=0;				// Remove 'login'
+  thd->command=COM_SLEEP;
+  thd->version=refresh_version;
+  thd->set_time();
+  init_sql_alloc(&thd->mem_root,8192,8192);
+  thd->client_capabilities= client_flag;
+  thd->max_packet_length= max_allowed_packet;
+  thd->net.vio = vio;
+
+  if (thd->client_capabilities & CLIENT_INTERACTIVE)
+    thd->inactive_timeout= net_interactive_timeout;
+  if (thd->client_capabilities & CLIENT_TRANSACTIONS)
+    thd->net.return_status= &thd->server_status;
+
+  thd->db= db;
+  thd->db_length= db ? strip_sp(db) : 0;
+  thd->db_access= DB_ACLS;
+  thd->master_access= ~NO_ACCESS;
+
+  return thd;
+}
+
+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,
+				      MYF(MY_WME | MY_ZEROFILL))))
+    goto err;
+
+  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->net,ER_OUT_OF_RESOURCES);	/* purecov: inspected */
+  return 1;					/* purecov: inspected */
+}
+
+/* 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)
+{
+  List_iterator_fast<Item> li(items);
+  Item                     *item;
+  String                   *packet= &thd->packet;
+  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;
+  int                      n_fields= items.elements;
+  uchar                    *cp;
+  MYSQL_FIELD              *mysql_fields= mysql->result->fields;
+  MYSQL_ROW                cur_field, end_field;
+  ulong                    len;
+
+
+  DBUG_ENTER("send_data");
+
+  if (unit->offset_limit_cnt)
+  {						// using limit offset,count
+    unit->offset_limit_cnt--;
+    DBUG_RETURN(0);
+  }
+
+  thd->packet.length(0);
+  while ((item=li++))
+  {
+    if (item->send(thd, packet))
+    {
+      packet->free();
+      my_error(ER_OUT_OF_RESOURCES, MYF(0));
+      DBUG_RETURN(1);
+    }
+  }
+
+  result->rows++;
+  if (!(cur= (MYSQL_ROWS *)alloc_root(alloc, sizeof(MYSQL_ROWS))) ||
+      !(cur->data= (MYSQL_ROW)alloc_root(alloc, 
+					 (n_fields + 1) * sizeof(char *) + packet->length())))
+  {
+    my_error(ER_OUT_OF_RESOURCES,MYF(0));
+    DBUG_RETURN(1);
+  }
+
+  *result->prev_ptr= cur;
+  result->prev_ptr= &cur->next;
+  to= (char*) (cur->data+n_fields+1);
+  cp= (uchar *)packet->ptr();
+  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);
+}
+
+bool do_command(THD *thd)
+{
+  MYSQL *mysql= thd->mysql;
+
+  char *packet;
+  uint old_timeout;
+  ulong packet_length;
+  NET *net;
+  enum enum_server_command command;
+  DBUG_ENTER("do_command");
+
+  net= &thd->net;
+  thd->current_tablenr=0;
+
+  packet=0;
+  old_timeout=net->timeout;
+  net->timeout=(uint) thd->inactive_timeout;	// Wait max for 8 hours
+  net->last_error[0]=0;				// Clear error message
+  net->last_errno=0;
+
+  net_new_transaction(net);
+  if ((packet_length=my_net_read(net)) == packet_error)
+  {
+     DBUG_PRINT("info",("Got error reading command from socket %s",
+			vio_description(net->vio) ));
+    return TRUE;
+  }
+  else
+  {
+    packet=(char*) net->read_pos;
+    command = (enum enum_server_command) (uchar) packet[0];
+    DBUG_PRINT("info",("Command on %s = %d (%s)",
+		       vio_description(net->vio), command,
+		       command_name[command]));
+  }
+  net->timeout=old_timeout;			// Timeout for writing
+  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
+}
+
+void
+send_ok(NET *net,ha_rows affected_rows,ulonglong id,const char *message)
+{
+  if (net->no_send_ok)				// hack for re-parsing queries
+    return;
+
+  DBUG_ENTER("send_ok");
+  MYSQL *mysql= current_thd->mysql;
+  mysql->affected_rows= affected_rows;
+  mysql->insert_id= id;
+  if (net->return_status)
+    mysql->server_status= *net->return_status;
+  if (message)
+  {
+    strmake(net->last_error, message, sizeof(net->last_error));
+    mysql->info= net->last_error;
+  }
+  DBUG_VOID_RETURN;
+}
+
+int embedded_send_row(THD *thd, int n_fields, 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))) ||
+      !(cur->data= 
+	(MYSQL_ROW)alloc_root(alloc, 
+			      (n_fields + 1) * sizeof(char *) + data_len)))
+  {
+    my_error(ER_OUT_OF_RESOURCES,MYF(0));
+    DBUG_RETURN(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);
+}
+
diff --git a/libmysqld/lib_vio.c b/libmysqld/lib_vio.c
index 29a70b7acbb..3ea73b0ccc2 100644
--- a/libmysqld/lib_vio.c
+++ b/libmysqld/lib_vio.c
@@ -42,14 +42,7 @@
 
 struct st_vio
 {
-  my_socket		sd;		/* my_socket - real or imaginary */
-  HANDLE hPipe;
-  my_bool		localhost;	/* Are we from localhost? */
-  int			fcntl_mode;	/* Buffered fcntl(sd,F_GETFL) */
-  struct sockaddr_in	local;		/* Local internet address */
-  struct sockaddr_in	remote;		/* Remote internet address */
   enum enum_vio_type	type;		/* Type of connection */
-  char			desc[30];	/* String description */
   void *dest_thd;
   char *packets, **last_packet;
   char *where_in_packet, *end_of_packet;
@@ -57,6 +50,7 @@ struct st_vio
   MEM_ROOT root;
 };
 
+
 /* Initialize the communication buffer */
 
 Vio *vio_new(my_socket sd, enum enum_vio_type type, my_bool localhost)
@@ -69,6 +63,7 @@ Vio *vio_new(my_socket sd, enum enum_vio_type type, my_bool localhost)
     init_alloc_root(&vio->root, 8192, 8192);
     vio->root.min_malloc = sizeof(char *) + 4;
     vio->last_packet = &vio->packets;
+    vio->type = type;
   }
   DBUG_RETURN(vio);
 }
@@ -219,4 +214,22 @@ my_bool vio_poll_read(Vio *vio,uint timeout)
   return 0;
 }
 
+int create_vio(NET *net, int separate_thread)
+{
+  Vio * v  = net->vio;
+  if (!v)
+  {
+    v = vio_new(0, separate_thread ? VIO_SHARED_MEMORY : VIO_BUFFER, 0);
+    net->vio = v;
+  }
+  return !v;
+}
+
+void set_thd(Vio *v, void *thd)
+{
+  if (v)
+  {
+    v -> dest_thd = thd;
+  } 
+}
 #endif /* HAVE_VIO */
diff --git a/libmysqld/libmysqld.c b/libmysqld/libmysqld.c
index 6328a205a7b..2e2ef58e4da 100644
--- a/libmysqld/libmysqld.c
+++ b/libmysqld/libmysqld.c
@@ -68,7 +68,8 @@ static MYSQL_DATA *read_rows (MYSQL *mysql,MYSQL_FIELD *fields,
 static int read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row,
 			ulong *lengths);
 static void end_server(MYSQL *mysql);
-static void read_user_name(char *name);
+/*static void read_user_name(char *name);
+*/
 static void append_wild(char *to,char *end,const char *wild);
 static int send_file_to_server(MYSQL *mysql,const char *filename);
 static ulong mysql_sub_escape_string(CHARSET_INFO *charset_info, char *to,
@@ -238,8 +239,7 @@ simple_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
 
   result = lib_dispatch_command(command, net, arg,length);
   if (!skipp_check)
-    result= ((mysql->packet_length=net_safe_read(mysql)) == packet_error ?
-	     1 : 0);
+    result= mysql->net.last_errno ? -1 : 0;
  end:
   return result;
 }
@@ -261,6 +261,8 @@ struct passwd *getpwuid(uid_t);
 char* getlogin(void);
 #endif
 
+#ifdef _DUMMY
+
 #if !defined(MSDOS) && ! defined(VMS) && !defined(__WIN__)
 static void read_user_name(char *name)
 {
@@ -307,6 +309,7 @@ static void read_user_name(char *name)
 }
 
 #endif
+#endif /*_DUMMY */
 
 #ifdef __WIN__
 static my_bool is_NT(void)
@@ -391,7 +394,7 @@ end_server(MYSQL *mysql)
     end_embedded_connection(&mysql->net);
     mysql->net.vio= 0;          /* Marker */
   }
-  net_end(&mysql->net);
+  mysql->net.buff = NULL;
   free_old_query(mysql);
   DBUG_VOID_RETURN;
 }
@@ -787,6 +790,53 @@ mysql_connect(MYSQL *mysql,const char *host,
 }
 
 
+int create_vio(NET *net, int separate_thread);
+void set_thd(Vio *vio, void *thd);
+
+/************/
+
+static inline int mysql_init_charset(MYSQL *mysql)
+{
+  char charset_name_buff[16], *charset_name;
+
+  if ((charset_name=mysql->options.charset_name))
+  {
+    const char *save=charsets_dir;
+    if (mysql->options.charset_dir)
+      charsets_dir=mysql->options.charset_dir;
+    mysql->charset=get_charset_by_name(mysql->options.charset_name,
+                                       MYF(MY_WME));
+    charsets_dir=save;
+  }
+  else if (mysql->server_language)
+  {
+    charset_name=charset_name_buff;
+    sprintf(charset_name,"%d",mysql->server_language);	/* In case of errors */
+    mysql->charset=get_charset((uint8) mysql->server_language, MYF(MY_WME));
+  }
+  else
+    mysql->charset=default_charset_info;
+
+  if (!mysql->charset)
+  {
+    mysql->net.last_errno=CR_CANT_READ_CHARSET;
+    if (mysql->options.charset_dir)
+      sprintf(mysql->net.last_error,ER(mysql->net.last_errno),
+              charset_name ? charset_name : "unknown",
+              mysql->options.charset_dir);
+    else
+    {
+      char cs_dir_name[FN_REFLEN];
+      get_charsets_dir(cs_dir_name);
+      sprintf(mysql->net.last_error,ER(mysql->net.last_errno),
+              charset_name ? charset_name : "unknown",
+              cs_dir_name);
+    }
+    return mysql->net.last_errno;
+  }
+  return 0;
+}
+
 /*
 ** Note that the mysql argument must be initialized with mysql_init()
 ** before calling mysql_real_connect !
@@ -794,20 +844,18 @@ mysql_connect(MYSQL *mysql,const char *host,
 
 MYSQL * STDCALL
 mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
-		   const char *passwd, const char *db,
+		   const char *passwd __attribute__((unused)), const char *db,
 		   uint port, const char *unix_socket,uint client_flag)
 {
-  char		buff[100],charset_name_buff[16],*end,*host_info, *charset_name;
-  uint		pkt_length;
   ulong		max_allowed_packet;
   NET		*net= &mysql->net;
+  char          *db_name;
   DBUG_ENTER("mysql_real_connect");
   DBUG_PRINT("enter",("host: %s  db: %s  user: %s",
 		      host ? host : "(Null)",
 		      db ? db : "(Null)",
 		      user ? user : "(Null)"));
 
-  net->vio = 0;				/* If something goes wrong */
   /* use default options */
   if (mysql->options.my_cnf_file || mysql->options.my_cnf_group)
   {
@@ -820,22 +868,14 @@ mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
     mysql->options.my_cnf_file=mysql->options.my_cnf_group=0;
   }
 
-  /* Some empty-string-tests are done because of ODBC */
-  if (!host || !host[0])
-    host=mysql->options.host;
-  if (!user || !user[0])
-    user=mysql->options.user;
-  if (!passwd)
-  {
-    passwd=mysql->options.password;
-  }
   if (!db || !db[0])
     db=mysql->options.db;
+
   port=0;
   unix_socket=0;
-  mysql->reconnect=1;			/* Reconnect as default */
-  mysql->server_status=SERVER_STATUS_AUTOCOMMIT;
-  host_info=(char*) ER(CR_EMBEDDED_CONNECTION);
+  db_name = db ? my_strdup(db,MYF(MY_WME)) : NULL;
+
+  create_vio(net, mysql->options.separate_thread);
   if (my_net_init(net, net->vio))
   {
     vio_delete(net->vio);
@@ -844,145 +884,29 @@ mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
     goto error;
   }
 
-  /* Get version info */
-  mysql->protocol_version= PROTOCOL_VERSION;	/* Assume this */
-  start_embedded_connection(net);
+  set_thd(net->vio, create_embedded_thd(net->vio, net->buff, client_flag, db_name));
+  
+  init_embedded_mysql(mysql, client_flag, db_name);
 
-  if ((pkt_length=net_safe_read(mysql)) == packet_error)
+  if (mysql_init_charset(mysql))
     goto error;
 
-  /* Check if version of protocoll matches current one */
-
-  mysql->protocol_version= net->read_pos[0];
-  DBUG_DUMP("packet",(char*) net->read_pos,10);
-  DBUG_PRINT("info",("mysql protocol version %d, server=%d",
-		     PROTOCOL_VERSION, mysql->protocol_version));
-  if (mysql->protocol_version != PROTOCOL_VERSION &&
-      mysql->protocol_version != PROTOCOL_VERSION-1)
-  {
-    net->last_errno= CR_VERSION_ERROR;
-    sprintf(net->last_error, ER(CR_VERSION_ERROR), mysql->protocol_version,
-	    PROTOCOL_VERSION);
-    goto error;
-  }
-  end=strend((char*) net->read_pos+1);
-  mysql->thread_id=uint4korr(end+1);
-  end+=5;
-  strmake(mysql->scramble_buff,end,8);
-  end+=9;
-  if (pkt_length >= (uint) (end+1 - (char*) net->read_pos))
-    mysql->server_capabilities=uint2korr(end);
-  if (pkt_length >= (uint) (end+18 - (char*) net->read_pos))
-  {
-    /* New protocol with 16 bytes to describe server characteristics */
-    mysql->server_language=end[2];
-    mysql->server_status=uint2korr(end+3);
-  }
-
-  /* Set character set */
-  if ((charset_name=mysql->options.charset_name))
-  {
-    const char *save=charsets_dir;
-    if (mysql->options.charset_dir)
-      charsets_dir=mysql->options.charset_dir;
-    mysql->charset=get_charset_by_name(mysql->options.charset_name,
-                                       MYF(MY_WME));
-    charsets_dir=save;
-  }
-  else if (mysql->server_language)
-  {
-    charset_name=charset_name_buff;
-    sprintf(charset_name,"%d",mysql->server_language);	/* In case of errors */
-    mysql->charset=get_charset((uint8) mysql->server_language, MYF(MY_WME));
-  }
-  else
-    mysql->charset=default_charset_info;
-
-  if (!mysql->charset)
-  {
-    net->last_errno=CR_CANT_READ_CHARSET;
-    if (mysql->options.charset_dir)
-      sprintf(net->last_error,ER(net->last_errno),
-              charset_name ? charset_name : "unknown",
-              mysql->options.charset_dir);
-    else
-    {
-      char cs_dir_name[FN_REFLEN];
-      get_charsets_dir(cs_dir_name);
-      sprintf(net->last_error,ER(net->last_errno),
-              charset_name ? charset_name : "unknown",
-              cs_dir_name);
-    }
-    goto error;
-  }
-
-  /* Save connection information */
-  if (!user) user="";
-  if (!passwd) passwd="";
-  host=LOCAL_HOST;
-  if (!my_multi_malloc(MYF(0),
-		       &mysql->host_info, (uint) strlen(host_info)+1,
-		       &mysql->host,      (uint) strlen(host)+1,
-		       &mysql->unix_socket,unix_socket ?
-		       (uint) strlen(unix_socket)+1 : (uint) 1,
-		       &mysql->server_version,
-		       (uint) (end - (char*) net->read_pos),
-		       NullS) ||
-      !(mysql->user=my_strdup(user,MYF(0))) ||
-      !(mysql->passwd=my_strdup(passwd,MYF(0))))
-  {
-    strmov(net->last_error, ER(net->last_errno=CR_OUT_OF_MEMORY));
-    goto error;
-  }
-  strmov(mysql->host_info,host_info);
-  strmov(mysql->host,host);
-  if (unix_socket)
-    strmov(mysql->unix_socket,unix_socket);
-  else
-    mysql->unix_socket=0;
-  strmov(mysql->server_version,(char*) net->read_pos+1);
-  mysql->port=port;
-  mysql->client_flag=client_flag | mysql->options.client_flag;
-  DBUG_PRINT("info",("Server version = '%s'  capabilites: %ld  status: %d",
-		     mysql->server_version,mysql->server_capabilities,
-		     mysql->server_status));
-
   /* Send client information for access check */
   client_flag|=CLIENT_CAPABILITIES;
   client_flag&= ~CLIENT_COMPRESS;
   if (db)
     client_flag|=CLIENT_CONNECT_WITH_DB;
-  int2store(buff,client_flag);
-  mysql->client_flag=client_flag;
-
   max_allowed_packet=net->max_packet_size;
-  int3store(buff+2,max_allowed_packet);
-  if (user && user[0])
-    strmake(buff+5,user,32);
-  else
-    read_user_name((char*) buff+5);
-#ifdef _CUSTOMCONFIG_
-#include "_cust_libmysql.h";
-#endif
-  DBUG_PRINT("info",("user: %s",buff+5));
-  end=scramble(strend(buff+5)+1, mysql->scramble_buff, passwd,
-	       (my_bool) (mysql->protocol_version == 9));
 
   if (db)
   {
-    end=strmov(end+1,db);
     mysql->db=my_strdup(db,MYF(MY_WME));
     db=0;
   }
-  if (my_net_write(net,buff,(ulong) (end-buff)) || net_flush(net))
-    goto error;
 
-  lib_connection_phase(net,2);
-
-  if( net_safe_read(mysql) == packet_error)
-    goto error;
-  if (db && mysql_select_db(mysql,db))
-    goto error;
+/****
+  net->timeout=net_read_timeout;
+*/
   if (mysql->options.init_command)
   {
     my_bool reconnect=mysql->reconnect;
@@ -1125,6 +1049,15 @@ mysql_query(MYSQL *mysql, const char *query)
 int STDCALL
 mysql_send_query(MYSQL* mysql, const char* query, ulong length)
 {
+  if (mysql->options.separate_thread)
+  {
+    return -1;
+  }
+
+  mysql->result= NULL;
+
+  free_old_query(mysql);			/* Free old result */
+
   return simple_command(mysql, COM_QUERY, query, length, 1);
 }
 
@@ -1132,49 +1065,19 @@ mysql_send_query(MYSQL* mysql, const char* query, ulong length)
 my_bool STDCALL
 mysql_read_query_result(MYSQL *mysql)
 {
-  uchar *pos;
-  ulong field_count;
-  MYSQL_DATA *fields;
-  uint length;
-  DBUG_ENTER("mysql_read_query_result");
+  NET *net= get_mysql_net(mysql);
 
-  if ((length=net_safe_read(mysql)) == packet_error)
-    DBUG_RETURN(1);
-  free_old_query(mysql);			/* Free old result */
-get_info:
-  pos=(uchar*) mysql->net.read_pos;
-  if ((field_count= net_field_length(&pos)) == 0)
-  {
-    mysql->affected_rows= net_field_length_ll(&pos);
-    mysql->insert_id=	  net_field_length_ll(&pos);
-    mysql->server_status=uint2korr(pos); pos+=2;
-    mysql->warning_count=uint2korr(pos); pos+=2;
-    if (pos < mysql->net.read_pos+length && net_field_length(&pos))
-      mysql->info=(char*) pos;
-    DBUG_RETURN(0);
-  }
-  if (field_count == NULL_LENGTH)		/* LOAD DATA LOCAL INFILE */
+  if (net->last_errno)
+    return -1;
+
+  if (mysql->field_count)
   {
-    int error=send_file_to_server(mysql,(char*) pos);
-    if ((length=net_safe_read(mysql)) == packet_error || error)
-      DBUG_RETURN(1);
-    goto get_info;				/* Get info packet */
+    mysql->status=MYSQL_STATUS_GET_RESULT;
+    mysql->affected_rows= mysql->result->row_count= mysql->result->data->rows;
+    mysql->result->data_cursor= mysql->result->data->data;
   }
-  if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT))
-    mysql->server_status|= SERVER_STATUS_IN_TRANS;
 
-  mysql->extra_info= net_field_length_ll(&pos); /* Maybe number of rec */
-  if (!(fields=read_rows(mysql,(MYSQL_FIELD*) 0,5)))
-    DBUG_RETURN(1);
-  if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,
-				    (uint) field_count,0,
-				    (my_bool) test(mysql->server_capabilities &
-						   CLIENT_LONG_FLAG))))
-    DBUG_RETURN(1);
-  mysql->status=MYSQL_STATUS_GET_RESULT;
-  mysql->field_count=field_count;
-  mysql->warning_count= 0;
-  DBUG_RETURN(0);
+  return 0;
 }
 
 /****************************************************************************
@@ -1284,8 +1187,18 @@ mysql_real_query(MYSQL *mysql, const char *query, ulong length)
   DBUG_ENTER("mysql_real_query");
   DBUG_PRINT("enter",("handle: %lx",mysql));
   DBUG_PRINT("query",("Query = \"%s\"",query));
+/*  if (mysql->options.separate_thread)
+  {
+    DBUG_RETURN(0);
+  }
+
+  mysql->result= NULL;
+
+  free_old_query(mysql);
+*/
   if (mysql_send_query(mysql, query, length))
     DBUG_RETURN(-1);
+
   DBUG_RETURN(mysql_read_query_result(mysql));
 }
 
@@ -1350,48 +1263,29 @@ send_file_to_server(MYSQL *mysql, const char *filename)
 ** Alloc result struct for buffered results. All rows are read to buffer.
 ** mysql_data_seek may be used.
 **************************************************************************/
-
 MYSQL_RES * STDCALL
 mysql_store_result(MYSQL *mysql)
 {
-  MYSQL_RES *result;
-  DBUG_ENTER("mysql_store_result");
+  MYSQL_RES *result= mysql->result;
+  if (!result)
+    return 0;
 
-  if (!mysql->fields)
-    DBUG_RETURN(0);
-  if (mysql->status != MYSQL_STATUS_GET_RESULT)
-  {
-    strmov(mysql->net.last_error,
-	   ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
-    DBUG_RETURN(0);
-  }
-  mysql->status=MYSQL_STATUS_READY;		/* server is ready */
-  if (!(result=(MYSQL_RES*) my_malloc(sizeof(MYSQL_RES)+
-				      sizeof(ulong)*mysql->field_count,
-				      MYF(MY_WME | MY_ZEROFILL))))
-  {
-    mysql->net.last_errno=CR_OUT_OF_MEMORY;
-    strmov(mysql->net.last_error, ER(mysql->net.last_errno));
-    DBUG_RETURN(0);
-  }
-  result->eof=1;				/* Marker for buffered */
-  result->lengths=(ulong*) (result+1);
-  if (!(result->data=read_rows(mysql,mysql->fields,mysql->field_count)))
-  {
-    my_free((gptr) result,MYF(0));
-    DBUG_RETURN(0);
-  }
+  mysql->result= NULL;
+  *result->data->prev_ptr= 0;
+  result->eof= 1;
+  result->lengths= (ulong*)(result + 1);
   mysql->affected_rows= result->row_count= result->data->rows;
-  result->data_cursor=	result->data->data;
-  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 */
-  mysql->fields=0;				/* fields is now in result */
-  DBUG_RETURN(result);				/* Data fetched */
+  result->data_cursor=  result->data->data;
+
+  mysql->status=MYSQL_STATUS_READY;		/* server is ready */
+  return result;
 }
 
+void _0dummy()
+{
+  send_file_to_server(NULL, NULL);
+  net_field_length_ll(NULL);
+}
 
 /**************************************************************************
 ** Alloc struct for use with unbuffered reads. Data is fetched by domand
@@ -1406,40 +1300,12 @@ mysql_store_result(MYSQL *mysql)
 MYSQL_RES * STDCALL
 mysql_use_result(MYSQL *mysql)
 {
-  MYSQL_RES *result;
   DBUG_ENTER("mysql_use_result");
-
-  if (!mysql->fields)
-    DBUG_RETURN(0);
-  if (mysql->status != MYSQL_STATUS_GET_RESULT)
-  {
-    strmov(mysql->net.last_error,
-	   ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
+  if (mysql->options.separate_thread)
     DBUG_RETURN(0);
-  }
-  if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+
-				      sizeof(ulong)*mysql->field_count,
-				      MYF(MY_WME | MY_ZEROFILL))))
-    DBUG_RETURN(0);
-  result->lengths=(ulong*) (result+1);
-  if (!(result->row=(MYSQL_ROW)
-	my_malloc(sizeof(result->row[0])*(mysql->field_count+1), MYF(MY_WME))))
-  {					/* Ptrs: to one row */
-    my_free((gptr) result,MYF(0));
-    DBUG_RETURN(0);
-  }
-  result->fields=	mysql->fields;
-  result->field_alloc=	mysql->field_alloc;
-  result->field_count=	mysql->field_count;
-  result->current_field=0;
-  result->handle=	mysql;
-  result->current_row=	0;
-  mysql->fields=0;			/* fields is now in result */
-  mysql->status=MYSQL_STATUS_USE_RESULT;
-  DBUG_RETURN(result);			/* Data is read to be fetched */
-}
-
 
+  DBUG_RETURN(mysql_store_result(mysql));
+}
 
 /**************************************************************************
 ** Return next field of the query results
@@ -1788,6 +1654,9 @@ mysql_options(MYSQL *mysql,enum mysql_option option, const char *arg)
   case MYSQL_OPT_COMPRESS:
     mysql->options.compress=1;			/* Remember for connect */
     break;
+  case MYSQL_OPT_USE_RESULT:
+    mysql->options.separate_thread=1;		/* Use separate thread for query execution*/
+    break;
   case MYSQL_OPT_NAMED_PIPE:
     mysql->options.named_pipe=1;		/* Force named pipe */
     break;
@@ -1877,12 +1746,12 @@ my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql)
 
 uint STDCALL mysql_errno(MYSQL *mysql)
 {
-  return (mysql)->net.last_errno;
+  return get_mysql_net(mysql)->last_errno;
 }
 
 const char * STDCALL mysql_error(MYSQL *mysql)
 {
-  return (mysql)->net.last_error;
+  return get_mysql_net(mysql)->last_error;
 }
 
 uint STDCALL mysql_warning_count(MYSQL *mysql)
diff --git a/sql/field.cc b/sql/field.cc
index 336bc9d7cc2..ba84de07afb 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -4475,7 +4475,7 @@ void Field_blob::set_key_image(char *buff,uint length)
 
 void Field_geom::get_key_image(char *buff,uint length, imagetype type)
 {
-  length-=HA_KEY_BLOB_LENGTH;
+/*  length-=HA_KEY_BLOB_LENGTH;
   ulong blob_length=get_length(ptr);
   char *blob;
   get_ptr(&blob);
@@ -4490,12 +4490,19 @@ void Field_geom::get_key_image(char *buff,uint length, imagetype type)
   float8store(buff+16, mbr.ymin);
   float8store(buff+24, mbr.ymax);
   return;
+*/
+  Field_blob::get_key_image(buff, length, type);
 }
 
 void Field_geom::set_key_image(char *buff,uint length)
 {
+  Field_blob::set_key_image(buff, length);
 }
 
+void Field_geom::sql_type(String &res) const
+{
+  res.set("geometry", 8U, default_charset_info);
+}
 
 int Field_blob::key_cmp(const byte *key_ptr, uint max_key_length)
 {
@@ -5144,6 +5151,7 @@ uint32 calc_pack_length(enum_field_types type,uint32 length)
   case FIELD_TYPE_BLOB:		return 2+portable_sizeof_char_ptr;
   case FIELD_TYPE_MEDIUM_BLOB:	return 3+portable_sizeof_char_ptr;
   case FIELD_TYPE_LONG_BLOB:	return 4+portable_sizeof_char_ptr;
+  case FIELD_TYPE_GEOMETRY:	return 2+portable_sizeof_char_ptr;
   case FIELD_TYPE_SET:
   case FIELD_TYPE_ENUM: abort(); return 0;	// This shouldn't happen
   default: return 0;
@@ -5191,15 +5199,15 @@ Field *make_field(char *ptr, uint32 field_length,
 				      f_packtype(pack_flag),
 				      field_length);
 
+    if (f_is_geom(pack_flag))
+      return new Field_geom(ptr,null_pos,null_bit,
+			    unireg_check, field_name, table,
+			    pack_length,f_is_binary(pack_flag) != 0);
     if (f_is_blob(pack_flag))
       return new Field_blob(ptr,null_pos,null_bit,
 			    unireg_check, field_name, table,
 			    pack_length,f_is_binary(pack_flag) != 0,
 			    default_charset_info);
-    if (f_is_geom(pack_flag))
-      return new Field_geom(ptr,null_pos,null_bit,
-			    unireg_check, field_name, table,
-			    pack_length,f_is_binary(pack_flag) != 0);
 
     if (interval)
     {
diff --git a/sql/field.h b/sql/field.h
index d8cfba14e02..127b3a069cb 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -950,6 +950,8 @@ public:
      :Field_blob(len_arg, maybe_null_arg, field_name_arg,
                  table_arg, binary_arg, default_charset_info) {}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_VARBINARY; }
+  enum_field_types type() const { return FIELD_TYPE_GEOMETRY;}
+  void sql_type(String &str) const;
 
   void get_key_image(char *buff,uint length, imagetype type);
   void set_key_image(char *buff,uint length);
diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc
index 4aae044148b..a26c2e02db8 100644
--- a/sql/ha_myisam.cc
+++ b/sql/ha_myisam.cc
@@ -79,7 +79,7 @@ static void mi_check_print_msg(MI_CHECK *param,	const char* msg_type,
   net_store_data(packet, msg_type);
 
   net_store_data(packet, msgbuf);
-  if (my_net_write(&thd->net, (char*)thd->packet.ptr(), thd->packet.length()))
+  if (SEND_ROW(thd, &thd->net, 4, (char*)thd->packet.ptr(), thd->packet.length()))
     sql_print_error("Failed on my_net_write, writing to stderr instead: %s\n",
 		    msgbuf);
   return;
@@ -1093,7 +1093,7 @@ int ha_myisam::create(const char *name, register TABLE *table,
 	keydef[i].flag|=HA_AUTO_KEY;
 	found_auto_increment=1;
       }
-      if (field->type() == FIELD_TYPE_BLOB)
+      if ((field->type() == FIELD_TYPE_BLOB) || (field->type() == FIELD_TYPE_GEOMETRY))
       {
 	keydef[i].seg[j].flag|=HA_BLOB_PART;
 	/* save number of bytes used to pack length */
diff --git a/sql/item.cc b/sql/item.cc
index f1e25fb4d97..394833b396a 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -444,6 +444,9 @@ bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
 	cause error ER_NON_UNIQ_ERROR in find_field_in_tables.
       */
       SELECT_LEX *last= 0;
+#ifdef EMBEDDED_LIBRARY
+      thd->net.last_errno= 0;
+#endif
       for (SELECT_LEX *sl= thd->lex.select->outer_select();
 	   sl && !tmp;
 	   sl= sl->outer_select())
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index 2ef95bb8746..2b85b3e794b 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -1367,10 +1367,15 @@ String *Item_func_database::val_str(String *str)
 String *Item_func_user::val_str(String *str)
 {
   THD *thd=current_thd;
+#ifdef EMBEDDED_LIBRARY
+  if (str->copy("localuser@localhost", (uint)strlen("localuser@localhost")))
+    return &empty_string;
+#else
   if (str->copy((const char*) thd->user,(uint) strlen(thd->user)) ||
       str->append('@') ||
       str->append(thd->host ? thd->host : thd->ip ? thd->ip : ""))
     return &empty_string;
+#endif
   return str;
 }
 
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 8e691c8f96c..8077d600643 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -861,3 +861,13 @@ inline void mark_as_null_row(TABLE *table)
   table->status|=STATUS_NULL_ROW;
   bfill(table->null_flags,table->null_bytes,255);
 }
+
+#ifdef EMBEDDED_LIBRARY
+  int embedded_send_row(THD *thd, int n_fields, char *data, int data_len);
+#define SEND_ROW(thd, net, n_fields, data, data_len)\
+  embedded_send_row(thd, n_fields, data, data_len)
+#else
+#define SEND_ROW(thd, net, n_fields, data, data_len)\
+  my_net_write(net, data, data_len)
+#endif
+
diff --git a/sql/net_pkg.cc b/sql/net_pkg.cc
index 9f91db95052..353733c596e 100644
--- a/sql/net_pkg.cc
+++ b/sql/net_pkg.cc
@@ -47,6 +47,12 @@ void send_error(THD *thd, uint sql_errno, const char *err)
       }
     }
   }
+
+#ifdef EMBEDDED_LIBRARY
+  net->last_errno= sql_errno;
+  strmake(net->last_error, err, sizeof(net->last_error)-1);
+#else
+
   if (net->vio == 0)
   {
     if (thd->bootstrap)
@@ -69,6 +75,7 @@ void send_error(THD *thd, uint sql_errno, const char *err)
     set_if_smaller(length,MYSQL_ERRMSG_SIZE-1);
   }
   VOID(net_write_command(net,(uchar) 255, "", 0, (char*) err,length));
+#endif  /* EMBEDDED_LIBRARY*/
   thd->fatal_error=0;			// Error message is given
   thd->net.report_error= 0;
   DBUG_VOID_RETURN;
@@ -158,6 +165,7 @@ net_printf(THD *thd, uint errcode, ...)
     length=sizeof(net->last_error)-1;		/* purecov: inspected */
   va_end(args);
 
+#ifndef EMBEDDED_LIBRARY
   if (net->vio == 0)
   {
     if (thd->bootstrap)
@@ -175,6 +183,10 @@ net_printf(THD *thd, uint errcode, ...)
   if (offset)
     int2store(text_pos-2, errcode);
   VOID(net_real_write(net,(char*) net->buff,length+head_length+1+offset));
+#else
+  net->last_errno= errcode;
+  strmake(net->last_error, text_pos, length);
+#endif
   thd->fatal_error=0;			// Error message is given
   DBUG_VOID_RETURN;
 }
@@ -205,6 +217,7 @@ net_printf(THD *thd, uint errcode, ...)
 
    If net->no_send_ok return without sending packet
 */    
+#ifndef EMBEDDED_LIBRARY
 
 void
 send_ok(THD *thd, ha_rows affected_rows, ulonglong id, const char *message)
@@ -240,6 +253,7 @@ send_ok(THD *thd, ha_rows affected_rows, ulonglong id, const char *message)
   DBUG_VOID_RETURN;
 }
 
+#endif /* EMBEDDED_LIBRARY */
 
 /*
   Send eof (= end of result set) to the client
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index 5f8cf42c2bf..1941d84cc1e 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -2635,8 +2635,12 @@ ulong get_table_grant(THD *thd, TABLE_LIST *table)
   GRANT_TABLE *grant_table;
 
   rw_rdlock(&LOCK_grant);
+#ifdef EMBEDDED_LIBRARY
+  grant_table= NULL;
+#else
   grant_table = table_hash_search(thd->host,thd->ip,db,user,
 				       table->real_name,0);
+#endif
   table->grant.grant_table=grant_table; // Remember for column test
   table->grant.version=grant_version;
   if (grant_table)
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 8deae314484..3773eca43e1 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -195,7 +195,6 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *wild)
   DBUG_RETURN(open_list);
 }
 
-
 /*
   Send name and type of result to client converted to a given char set
 
@@ -216,6 +215,8 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *wild)
     1	Error  (Note that in this case the error is not sent to the client)
 */
 
+#ifndef EMBEDDED_LIBRARY
+
 bool
 send_convert_fields(THD *thd,List<Item> &list,CONVERT *convert,uint flag)
 {
@@ -439,6 +440,7 @@ err:
   DBUG_RETURN(1);				/* purecov: inspected */
 }
 
+#endif /* EMBEDDED_LIBRARY */
 
 /*****************************************************************************
  *	 Functions to free open table cache
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 648e05c1610..763484dbba8 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -448,6 +448,8 @@ bool select_send::send_fields(List<Item> &list,uint flag)
 }
 
 
+#ifndef EMBEDDED_LIBRARY
+
 /* Send data to client. Returns 0 if ok */
 
 bool select_send::send_data(List<Item> &items)
@@ -482,6 +484,7 @@ bool select_send::send_data(List<Item> &items)
   else
     DBUG_RETURN(1);
 }
+#endif /* EMBEDDED_LIBRARY */
 
 bool select_send::send_eof()
 {
diff --git a/sql/sql_class.h b/sql/sql_class.h
index e9a4109a4c1..3983405e039 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -335,6 +335,10 @@ class select_result;
 #define THD_SENTRY_MAGIC 0xfeedd1ff
 #define THD_SENTRY_GONE  0xdeadbeef
 
+#ifdef EMBEDDED_LIBRARY
+typedef struct st_mysql;
+#endif
+
 #define THD_CHECK_SENTRY(thd) DBUG_ASSERT(thd->dbug_sentry == THD_SENTRY_MAGIC)
 
 struct system_variables
@@ -393,6 +397,9 @@ public:
   struct  rand_struct rand;		// used for authentication
   struct  system_variables variables;	// Changeable local variables
   pthread_mutex_t LOCK_delete;		// Locked before thd is deleted
+#ifdef EMBEDDED_LIBRARY
+  struct st_mysql  *mysql;
+#endif
 
   char	  *query;			// Points to the current query,
   /*
diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
index ea15f2e5417..7867db37d6d 100644
--- a/sql/sql_handler.cc
+++ b/sql/sql_handler.cc
@@ -233,7 +233,7 @@ int mysql_ha_read(THD *thd, TABLE_LIST *tables,
             goto err;
           }
         }
-        my_net_write(&thd->net, (char*)packet->ptr(), packet->length());
+	SEND_ROW(thd, &thd->net, list.elements, (char*)packet->ptr(), packet->length());
       }
     }
     num_rows++;
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 7902e66043d..595df6b7b7d 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -839,8 +839,9 @@ err:
 }
 
 
-	/* Execute one command from socket (query or simple command) */
+#ifndef EMBEDDED_LIBRARY
 
+	/* Execute one command from socket (query or simple command) */
 bool do_command(THD *thd)
 {
   char *packet;
@@ -879,6 +880,7 @@ bool do_command(THD *thd)
   DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
 }
 
+#endif  /* EMBEDDED_LIBRARY */
 
 bool dispatch_command(enum enum_server_command command, THD *thd,
 		      char* packet, uint packet_length)
@@ -3195,7 +3197,6 @@ bool add_field_to_list(char *field_name, enum_field_types type,
   case FIELD_TYPE_STRING:
   case FIELD_TYPE_VAR_STRING:
   case FIELD_TYPE_NULL:
-  case FIELD_TYPE_GEOMETRY:
     break;
   case FIELD_TYPE_DECIMAL:
     if (!length)
@@ -3208,6 +3209,7 @@ bool add_field_to_list(char *field_name, enum_field_types type,
   case FIELD_TYPE_TINY_BLOB:
   case FIELD_TYPE_LONG_BLOB:
   case FIELD_TYPE_MEDIUM_BLOB:
+  case FIELD_TYPE_GEOMETRY:
     if (default_value)				// Allow empty as default value
     {
       String str,*res;
@@ -3343,7 +3345,7 @@ bool add_field_to_list(char *field_name, enum_field_types type,
 
   if (new_field->length >= MAX_FIELD_WIDTH ||
       (!new_field->length && !(new_field->flags & BLOB_FLAG) &&
-       type != FIELD_TYPE_STRING && type != FIELD_TYPE_VAR_STRING))
+       type != FIELD_TYPE_STRING && type != FIELD_TYPE_VAR_STRING && type != FIELD_TYPE_GEOMETRY))
   {
     net_printf(thd,ER_TOO_BIG_FIELDLENGTH,field_name,
 	       MAX_FIELD_WIDTH-1);		/* purecov: inspected */
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 35703e57d82..f850134190d 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -5288,6 +5288,9 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
   {
     Item *item= *group->item;
     item->save_org_in_field(group->field);
+#ifdef EMBEDDED_LIBRARY
+    join->thd->net.last_errno= 0;
+#endif
     /* Store in the used key if the field was 0 */
     if (item->maybe_null)
       group->buff[-1]=item->null_value ? 1 : 0;
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 827067c27d7..81a039b637e 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -52,8 +52,6 @@ extern struct st_VioSSLAcceptorFd * ssl_acceptor_fd;
 ** Send list of databases
 ** A database is a directory in the mysql_data_home directory
 ****************************************************************************/
-
-
 int
 mysqld_show_dbs(THD *thd,const char *wild)
 {
@@ -87,8 +85,8 @@ mysqld_show_dbs(THD *thd,const char *wild)
     {
       packet->length(0);
       net_store_data(packet, thd->variables.convert_set, file_name);
-      if (my_net_write(&thd->net, (char*) packet->ptr(),
-		       packet->length()))
+      if (SEND_ROW(thd, &thd->net, field_list.elements, 
+			    (char *)packet.ptr(), packet.length()))
 	DBUG_RETURN(-1);
     }
   }
@@ -127,7 +125,8 @@ int mysqld_show_open_tables(THD *thd,const char *wild)
     net_store_data(packet,convert, open_list->table);
     net_store_data(packet,open_list->in_use);
     net_store_data(packet,open_list->locked);
-    if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
+    if (SEND_ROW(thd, &thd->net, field_list.elements, 
+			  (char *)packet.ptr(), packet.length()))
     {
       DBUG_RETURN(-1);
     }
@@ -169,7 +168,8 @@ int mysqld_show_tables(THD *thd,const char *db,const char *wild)
   {
     packet->length(0);
     net_store_data(packet, thd->variables.convert_set, file_name);
-    if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
+    if (SEND_ROW(thd, &thd->net, field_list.elements, 
+			  (char *)packet.ptr(), packet.length()))
       DBUG_RETURN(-1);
   }
   send_eof(thd);
@@ -635,9 +635,9 @@ int mysqld_extend_show_tables(THD *thd,const char *db,const char *wild)
       }
       close_thread_tables(thd,0);
     }
-    if (my_net_write(&thd->net,(char*) packet->ptr(),
-                     packet->length()))
-      DBUG_RETURN(-1);
+    if (SEND_ROW(thd, &thd->net, field_list.elements, 
+		 (char *)thd->packet.ptr(), thd->packet.length()))
+	DBUG_RETURN(-1);
   }
   send_eof(thd);
   DBUG_RETURN(0);
@@ -647,7 +647,6 @@ int mysqld_extend_show_tables(THD *thd,const char *db,const char *wild)
 /***************************************************************************
 ** List all columns in a table_list->real_name
 ***************************************************************************/
-
 int
 mysqld_show_fields(THD *thd, TABLE_LIST *table_list,const char *wild,
 		   bool verbose)
@@ -750,8 +749,8 @@ mysqld_show_fields(THD *thd, TABLE_LIST *table_list,const char *wild,
 	if (verbose)
 	{
 	  /* Add grant options & comments */
-	  col_access= get_column_grant(thd,table_list,field) & COL_ACLS;
 	  end=tmp;
+	  col_access= get_column_grant(thd,table_list,field) & COL_ACLS;
 	  for (uint bitnr=0; col_access ; col_access>>=1,bitnr++)
 	  {
 	    if (col_access & 1)
@@ -763,8 +762,9 @@ mysqld_show_fields(THD *thd, TABLE_LIST *table_list,const char *wild,
 	  net_store_data(packet,convert, tmp+1,end == tmp ? 0 : (uint) (end-tmp-1));
 	  net_store_data(packet, field->comment.str,field->comment.length);
 	}
-        if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
-          DBUG_RETURN(1);
+	if (SEND_ROW(thd, &thd->net, field_list.elements, 
+		     (char *)thd->packet.ptr(), thd->packet.length()))
+	  DBUG_RETURN(-1);
       }
     }
   }
@@ -833,8 +833,9 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list)
     int3store(p, create_len);
 
     // now we are in business :-)
-    if (my_net_write(&thd->net, (char*)packet->ptr(), packet->length()))
-      DBUG_RETURN(1);
+    if (SEND_ROW(thd, &thd->net, field_list.elements, 
+			  (char *)thd->packet.ptr(), thd->packet.length()))
+      DBUG_RETURN(-1);
   }
   send_eof(thd);
   DBUG_RETURN(0);
@@ -956,8 +957,9 @@ mysqld_show_keys(THD *thd, TABLE_LIST *table_list)
       net_store_data(packet,convert,table->file->index_type(i));
       /* Comment */
       net_store_data(packet,convert,"");
-      if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
-        DBUG_RETURN(1); /* purecov: inspected */
+      if (SEND_ROW(thd, &thd->net, field_list.elements, 
+			    (char *)thd->packet.ptr(), thd->packet.length()))
+	DBUG_RETURN(-1);
     }
   }
   send_eof(thd);
@@ -1384,8 +1386,9 @@ void mysqld_list_processes(THD *thd,const char *user, bool verbose)
       net_store_data(packet,convert,thd_info->query);
     else
       net_store_null(packet);
-    if (my_net_write(&thd->net,(char*) packet->ptr(),packet->length()))
-      break; /* purecov: inspected */
+    if (SEND_ROW(thd, &thd->net, field_list.elements, 
+			  (char *)thd->packet.ptr(), thd->packet.length()))
+      break;
   }
   send_eof(thd);
   DBUG_VOID_RETURN;
@@ -1685,8 +1688,9 @@ int mysqld_show(THD *thd, const char *wild, show_var_st *variables,
 	net_store_data(&packet2, "");		// Safety
 	break;
       }
-      if (my_net_write(&thd->net, (char*) packet2.ptr(),packet2.length()))
-        goto err;                               /* purecov: inspected */
+      if (SEND_ROW(thd, &thd->net, field_list.elements, 
+		   (char *)packet2.ptr(), packet2.length()))
+	goto err;
     }
   }
   pthread_mutex_unlock(&LOCK_status);
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index a71f555cdd7..ccb7b5e5a9a 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -397,6 +397,16 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
       sql_field->unireg_check=Field::BLOB_FIELD;
       blob_columns++;
       break;
+    case FIELD_TYPE_GEOMETRY:
+      sql_field->pack_flag=FIELDFLAG_GEOM |
+	pack_length_to_packflag(sql_field->pack_length -
+				portable_sizeof_char_ptr);
+      if (sql_field->flags & BINARY_FLAG)
+	sql_field->pack_flag|=FIELDFLAG_BINARY;
+      sql_field->length=8;			// Unireg field length
+      sql_field->unireg_check=Field::BLOB_FIELD;
+      blob_columns++;
+      break;
     case FIELD_TYPE_VAR_STRING:
     case FIELD_TYPE_STRING:
       sql_field->pack_flag=0;
@@ -1007,8 +1017,7 @@ static int send_check_errmsg(THD* thd, TABLE_LIST* table,
   net_store_data(packet, "error");
   net_store_data(packet, errmsg);
   thd->net.last_error[0]=0;
-  if (my_net_write(&thd->net, (char*) thd->packet.ptr(),
-		   packet->length()))
+  if (SEND_ROW(thd, &thd->net, 4, (char*) thd->packet.ptr(), packet->length()))
     return -1;
   return 1;
 }
@@ -1178,6 +1187,9 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
 
     thd->open_options|= extra_open_options;
     table->table = open_ltable(thd, table, lock_type);
+#ifdef EMBEDDED_LIBRARY
+    thd->net.last_errno= 0;  // these errors shouldn't get client
+#endif
     thd->open_options&= ~extra_open_options;
     packet->length(0);
     if (prepare_func)
@@ -1199,7 +1211,7 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
 	err_msg=ER(ER_CHECK_NO_SUCH_TABLE);
       net_store_data(packet, err_msg);
       thd->net.last_error[0]=0;
-      if (my_net_write(&thd->net, (char*) thd->packet.ptr(),
+      if (SEND_ROW(thd, &thd->net, field_list.elements, (char*) thd->packet.ptr(),
 		       packet->length()))
 	goto err;
       continue;
@@ -1214,7 +1226,7 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
       net_store_data(packet, buff);
       close_thread_tables(thd);
       table->table=0;				// For query cache
-      if (my_net_write(&thd->net, (char*) thd->packet.ptr(),
+      if (SEND_ROW(thd, &thd->net, field_list.elements, (char*) thd->packet.ptr(),
 		       packet->length()))
 	goto err;
       continue;
@@ -1243,6 +1255,9 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
     }
 
     int result_code = (table->table->file->*operator_func)(thd, check_opt);
+#ifdef EMBEDDED_LIBRARY
+    thd->net.last_errno= 0;  // these errors shouldn't get client
+#endif
     packet->length(0);
     net_store_data(packet, table_name);
     net_store_data(packet, operator_name);
@@ -1298,8 +1313,8 @@ static int mysql_admin_table(THD* thd, TABLE_LIST* tables,
     }
     close_thread_tables(thd);
     table->table=0;				// For query cache
-    if (my_net_write(&thd->net, (char*) packet->ptr(),
-		     packet->length()))
+    if (SEND_ROW(thd, &thd->net, field_list.elements, 
+			  (char *)thd->packet.ptr(), thd->packet.length()))
       goto err;
   }