bk commit into 4.1 tree (1.1476)

Below is the list of changes that have just been committed into a local
4.1 repository of hf. When hf does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://www.mysql.com/doc/I/n/Installing_source_tree.html

ChangeSet
  1.1476 03/02/28 10:11:26 hf@xxxxxxxxxxxxxxxxx +2 -0
  SCRUM
  Protocol_cursor class

  sql/protocol.h
    1.5 03/02/28 10:11:22 hf@xxxxxxxxxxxxxxxxx +27 -4
    Protocol_cursor definition

  sql/protocol.cc
    1.48 03/02/28 10:11:22 hf@xxxxxxxxxxxxxxxxx +146 -0
    Protocol_cursor class implementation

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User: hf
# Host: deer.mysql.r18.ru
# Root: /home/hf/work/mysql-4.1.w1

--- 1.47/sql/protocol.cc        Wed Feb 26 14:08:02 2003
+++ 1.48/sql/protocol.cc        Fri Feb 28 10:11:22 2003
@@ -25,6 +25,7 @@
 
 #include "mysql_priv.h"
 #include <stdarg.h>
+#include <mysql.h>
 
 #ifndef EMBEDDED_LIBRARY
 bool Protocol::net_store_data(const char *from, uint length)
@@ -1086,3 +1087,148 @@
   buff[0]=(char) length;                       // Length is stored first
   return packet->append(buff, length+1, PACKET_BUFFET_EXTRA_ALLOC);
 }
+
+bool Protocol_cursor::send_fields(List<Item> *list, uint flag)
+{
+  List_iterator_fast<Item> it(*list);
+  Item                     *item;
+  MYSQL_FIELD              *field, *client_field;
+  
+  DBUG_ENTER("send_fields");
+  if (prepare_for_send(list))
+      return FALSE;
+
+  fields= (MYSQL_FIELD *)alloc_root(alloc, sizeof(MYSQL_FIELD) * field_count);
+  if (!fields)
+    goto err;
+
+  client_field= fields;
+  while ((item= it++))
+  {
+    Send_field server_field;
+    item->make_field(&server_field);
+
+    client_field->db=    strdup_root(alloc, server_field.db_name);
+    client_field->table=  strdup_root(alloc, server_field.table_name);
+    client_field->name=   strdup_root(alloc, server_field.col_name);
+    client_field->org_table= strdup_root(alloc, server_field.org_table_name);
+    client_field->org_name=  strdup_root(alloc, server_field.org_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;
+    client_field->db_length=           strlen(client_field->db);
+    client_field->table_length=                strlen(client_field->table);
+    client_field->name_length=         strlen(client_field->name);
+    client_field->org_name_length=     strlen(client_field->org_name);
+    client_field->org_table_length=    strlen(client_field->org_table);
+    client_field->charsetnr=           server_field.charsetnr;
+    
+    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;
+  }
+
+  DBUG_RETURN(FALSE);
+ err:
+  send_error(thd, ER_OUT_OF_RESOURCES);        /* purecov: inspected */
+  DBUG_RETURN(TRUE);                           /* purecov: inspected */
+}
+
+
+/* Get the length of next field. Change parameter to point at fieldstart */
+static ulong net_field_length(const char **packet)
+{
+  reg1 const uchar *pos= (uchar *)*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 Protocol_cursor::write()
+{
+  const char *cp= packet->ptr();
+  const char *end_pos= packet->ptr() + packet->length();
+  ulong len;
+  ulong data_len= 0;
+  MYSQL_FIELD *cur_field= fields;
+  MYSQL_FIELD *fields_end= fields + field_count;
+  MYSQL_ROWS *new_record;
+  char **data= 0;
+  char *to;
+
+  new_record= (MYSQL_ROWS *)alloc_root(alloc, 
+       sizeof(MYSQL_ROWS) + (field_count + 1)*sizeof(char *) + 
packet->length());
+  if (!new_record)
+    goto err;
+  data= (char **)(new_record + 1);
+  new_record->data= data;
+
+  to= (char *)(fields + field_count + 1);
+
+  for(; cur_field < fields_end; ++cur_field, ++data)
+  {
+    if ((len= (ulong)net_field_length(&cp)))
+    {
+      *data= 0;
+    }
+    else
+    {
+      if (len > (ulong)(end_pos - cp))
+      {
+// TODO error signal      send_error(thd, CR_MALFORMED_PACKET);
+       return TRUE;
+      }
+      memcpy(to,(char*) cp,len);
+      to[len]=0;
+      to+=len+1;
+      cp+=len;
+      if (cur_field->max_length < len)
+       cur_field->max_length=len;
+    }
+  }
+
+  *prev_record= new_record;
+  prev_record= &new_record->next;
+  new_record->next= NULL;
+  ++row_count;
+  return FALSE;
+ err:
+// TODO error signal      send_error(thd, ER_OUT_OF_RESOURCES);
+  return TRUE;
+}
+
+

--- 1.4/sql/protocol.h  Mon Jan 20 18:47:02 2003
+++ 1.5/sql/protocol.h  Fri Feb 28 10:11:22 2003
@@ -23,9 +23,9 @@
 class CONVERT;
 class i_string;
 class THD;
-#ifdef EMBEDDED_LIBRARY
 typedef struct st_mysql_field MYSQL_FIELD;
-#endif
+typedef struct st_mysql_rows MYSQL_ROWS;
+
 class Protocol
 {
 protected:
@@ -49,13 +49,13 @@
   Protocol() {}
   Protocol(THD *thd) { init(thd); }
   void init(THD* thd);
-  bool send_fields(List<Item> *list, uint flag);
+  virtual 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; }
   inline void free() { packet->free(); }
-  bool write();
+  virtual bool write();
   inline  bool store(uint32 from)
   { return store_long((longlong) from); }
   inline  bool store(longlong from)
@@ -130,6 +130,29 @@
   virtual bool store(double from, uint32 decimals, String *buffer);
   virtual bool store(Field *field);
 };
+
+class Protocol_cursor :public Protocol_simple
+{
+public:
+  MEM_ROOT *alloc;
+  MYSQL_FIELD *fields;
+  MYSQL_ROWS *data;
+  MYSQL_ROWS **prev_record;
+  ulong row_count;
+
+  Protocol_cursor() {}
+  Protocol_cursor(THD *thd, MEM_ROOT *ini_alloc) :Protocol_simple(thd), 
alloc(ini_alloc) {}
+  bool prepare_for_send(List<Item> *item_list) 
+  {
+    fields= NULL;
+    data= NULL;
+    prev_record= &data;
+    return Protocol_simple::prepare_for_send(item_list);
+  }
+  bool send_fields(List<Item> *list, uint flag);
+  bool write();
+};
+
 
 void send_warning(THD *thd, uint sql_errno, const char *err=0);
 void net_printf(THD *thd,uint sql_errno, ...);

---------------------------------------------------------------------
Before posting, please check:
   http://www.mysql.com/manual.php   (the manual)
   http://lists.mysql.com/           (the list archive)

To request this thread, e-mail internals-thread7219@xxxxxxxxxxxxxxx
To unsubscribe, e-mail <internals-unsubscribe@xxxxxxxxxxxxxxx>