PART I: Keys support for MyMERGE tables

myisammrg/             |
Makefile.am            |
mymrgdef.h             |   support for keys
myrg_open.c            |          &
myrg_queue.c           |   bugfixes
myrg_rfirst.c          |
myrg_rkey.c            |
myrg_rlast.c           |
myrg_rnext.c           |
myrg_rprev.c           |
myrg_rrnd.c            |

include/myisammrg.h    | rkey/rnext/etc prototyped

sql/                   |
ha_myisammrg.cc        | support for keys
ha_myisammrg.h         |

myisam/                |
mi_rkey.c              | buf==NULL extension, _mi_rkey()
mi_rnext.c             |
mi_rprev.c             |

include/queues.h       | reinit_queue() - same as init_queue, but w/o malloc
mysys/queues.c         |

PART II: Miscellaneous

myisam/common_words    | deleted (looks like I checked it in by mistake)

some files (like acconfig.h, Makefile.am, COPYING.LIB, etc)
                       | Change mode to -rw-r--r-- (by `chmod a-x ')



include/queues.h:
  Initial, from cvs
myisammrg/Makefile.am:
  Initial, from cvs
myisammrg/mymrgdef.h:
  Initial, from cvs
myisammrg/myrg_open.c:
  Initial, from cvs
mysys/queues.c:
  Initial, from cvs
BitKeeper/deleted/.del-common_words:
  ***MISSING WEAVE***
Makefile.am:
  Change mode to -rw-r--r--
include/mysql_version.h.in:
  Change mode to -rw-r--r--
libmysql/acconfig.h:
  ***MISSING WEAVE***
mysys/COPYING.LIB:
  Change mode to -rw-r--r--
sql/item_uniq.cc:
  Change mode to -rw-r--r--
sql/item_uniq.h:
  Change mode to -rw-r--r--
sql/share/Makefile.am:
  Change mode to -rw-r--r--
strings/ChangeLog:
  Change mode to -rw-r--r--
support-files/Makefile.am:
  Change mode to -rw-r--r--
myisam/mi_rkey.c:
  looks like rkey/rnext for MyMERGE is working
myisam/mi_rnext.c:
  looks like rkey/rnext for MyMERGE is working
myisammrg/myrg_queue.c:
  looks like rkey/rnext for MyMERGE is working
myisammrg/myrg_rkey.c:
  looks like rkey/rnext for MyMERGE is working
myisammrg/myrg_rnext.c:
  probably, works
myisammrg/myrg_rprev.c:
  probably, works
include/myisammrg.h:
  rkey/rnext/etc prototyped
myisam/mi_rprev.c:
  buf==NULL, extension
sql/ha_myisammrg.cc:
  support for keys
sql/ha_myisammrg.h:
  support for keys
myisammrg/myrg_rrnd.c:
  ORDER BY didn't work
acconfig.h:
  Change mode to -rw-r--r--

include/myisammrg.h

@@ -30,6 +30,8 @@ extern "C" {
 #include <myisam.h>
 #endif
 
+#include <queues.h>
+
 #define MYRG_NAME_EXT	".MRG"
 
 	/* Param to/from myrg_info */
@@ -60,6 +62,7 @@ typedef struct st_myrg_info
   uint	 tables,options,reclength;
   my_bool cache_in_use;
   LIST	open_list;
+  QUEUE     by_key;
 } MYRG_INFO;
 
 
@@ -70,6 +73,9 @@ extern int myrg_delete(MYRG_INFO *file,const byte *buff);
 extern MYRG_INFO *myrg_open(const char *name,int mode,int wait_if_locked);
 extern int myrg_panic(enum ha_panic_function function);
 extern int myrg_rfirst(MYRG_INFO *file,byte *buf,int inx);
+extern int myrg_rlast(MYRG_INFO *file,byte *buf,int inx);
+extern int myrg_rnext(MYRG_INFO *file,byte *buf,int inx);
+extern int myrg_rprev(MYRG_INFO *file,byte *buf,int inx);
 extern int myrg_rkey(MYRG_INFO *file,byte *buf,int inx,const byte *key,
 		       uint key_len, enum ha_rkey_function search_flag);
 extern int myrg_rrnd(MYRG_INFO *file,byte *buf,ulonglong pos);

include/queues.h

@@ -46,6 +46,9 @@ typedef struct st_queue {
 int init_queue(QUEUE *queue,uint max_elements,uint offset_to_key,
 	       pbool max_at_top, int (*compare)(void *,byte *, byte *),
 	       void *first_cmp_arg);
+int reinit_queue(QUEUE *queue,uint max_elements,uint offset_to_key,
+                 pbool max_at_top, int (*compare)(void *,byte *, byte *),
+                 void *first_cmp_arg);
 void delete_queue(QUEUE *queue);
 void queue_insert(QUEUE *queue,byte *element);
 byte *queue_remove(QUEUE *queue,uint idx);

myisam/mi_rkey.c

@@ -22,13 +22,13 @@
 	/* Read a record using key */
 	/* Ordinary search_flag is 0 ; Give error if no record with key */
 
-int mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
-	    enum ha_rkey_function search_flag)
+int _mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
+	     enum ha_rkey_function search_flag, bool raw_key)
 {
   uchar *key_buff;
   MYISAM_SHARE *share=info->s;
   uint pack_key_length;
-  DBUG_ENTER("mi_rkey");
+  DBUG_ENTER("_mi_rkey");
   DBUG_PRINT("enter",("base: %lx  inx: %d  search_flag: %d",
 		      info,inx,search_flag));
 
@@ -36,6 +36,9 @@ int mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
     DBUG_RETURN(my_errno);
 
   info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
+
+  if (raw_key)
+  {
   if (key_len == 0)
     key_len=USE_WHOLE_KEY;
   key_buff=info->lastkey+info->s->base.max_key_length;
@@ -43,6 +46,14 @@ int mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
   info->last_rkey_length=pack_key_length;
   DBUG_EXECUTE("key",_mi_print_key(DBUG_FILE,share->keyinfo[inx].seg,
 				   key_buff,pack_key_length););
+  }
+  else
+  {
+    /* key is already packed! */
+    key_buff=info->lastkey+info->s->base.max_key_length;
+    info->last_rkey_length=pack_key_length=key_len;
+    bmove(key_buff,key,key_len);
+  }
 
   if (_mi_readinfo(info,F_RDLCK,1))
     goto err;
@@ -69,6 +80,9 @@ int mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
   if (share->concurrent_insert)
     rw_unlock(&share->key_root_lock[inx]);
 
+  if (!buf)
+    DBUG_RETURN(info->lastpos==HA_OFFSET_ERROR ? my_errno : 0);
+
   if (!(*info->read_record)(info,info->lastpos,buf))
   {
     info->update|= HA_STATE_AKTIV;		/* Record is read */
@@ -86,4 +100,12 @@ int mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
     info->update|=HA_STATE_NEXT_FOUND;		/* Previous gives last row */
 err:
   DBUG_RETURN(my_errno);
-} /* mi_rkey */
+} /* _mi_rkey */
+
+/* shouldn't forget to do it inline sometime */
+int mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
+            enum ha_rkey_function search_flag)
+{
+  return _mi_rkey(info,buf,inx,key,key_len,search_flag,TRUE);
+}
+

myisam/mi_rnext.c

@@ -74,6 +74,10 @@ int mi_rnext(MI_INFO *info, byte *buf, int inx)
     if (my_errno == HA_ERR_KEY_NOT_FOUND)
       my_errno=HA_ERR_END_OF_FILE;
   }
+  else if (!buf)
+  {
+    DBUG_RETURN(info->lastpos==HA_OFFSET_ERROR ? my_errno : 0);
+  }
   else if (!(*info->read_record)(info,info->lastpos,buf))
   {
     info->update|= HA_STATE_AKTIV;		/* Record is read */

myisam/mi_rprev.c

@@ -73,6 +73,10 @@ int mi_rprev(MI_INFO *info, byte *buf, int inx)
     if (my_errno == HA_ERR_KEY_NOT_FOUND)
       my_errno=HA_ERR_END_OF_FILE;
   }
+  else if (!buf)
+  {
+    DBUG_RETURN(info->lastpos==HA_OFFSET_ERROR ? my_errno : 0);
+  }
   else if (!(*info->read_record)(info,info->lastpos,buf))
   {
     info->update|= HA_STATE_AKTIV;		/* Record is read */

myisammrg/Makefile.am

@@ -19,8 +19,9 @@ pkglib_LIBRARIES =	libmyisammrg.a
 noinst_HEADERS =	mymrgdef.h
 libmyisammrg_a_SOURCES = myrg_open.c myrg_extra.c myrg_info.c myrg_locking.c \
 			myrg_rrnd.c myrg_update.c myrg_delete.c myrg_rsame.c \
-			myrg_panic.c myrg_close.c myrg_create.c myrg_static.c
-
+			myrg_panic.c myrg_close.c myrg_create.c myrg_static.c \
+			myrg_rkey.c myrg_rfirst.c myrg_rlast.c myrg_rnext.c \
+			myrg_rprev.c myrg_queue.c
 OMIT_DEPENDENCIES =	pthread.h stdio.h __stdio.h stdlib.h __stdlib.h math.h\
 			__math.h time.h __time.h unistd.h __unistd.h types.h \
 			xtypes.h ac-types.h posix.h string.h __string.h \

myisammrg/mymrgdef.h

@@ -27,3 +27,6 @@ extern LIST *myrg_open_list;
 #ifdef THREAD
 extern pthread_mutex_t THR_LOCK_open;
 #endif
+
+int _myrg_init_queue(MYRG_INFO *info,int inx,enum ha_rkey_function search_flag);
+

myisammrg/myrg_open.c

@@ -119,6 +119,7 @@ int handle_locking;
   pthread_mutex_lock(&THR_LOCK_open);
   myrg_open_list=list_add(myrg_open_list,&m_info->open_list);
   pthread_mutex_unlock(&THR_LOCK_open);
+  m_info->by_key.root=0;
   DBUG_RETURN(m_info);
 
 err:

myisammrg/myrg_queue.c

+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+/* Read record based on a key */
+
+#include "mymrgdef.h"
+
+static int queue_key_cmp(void *keyseg, byte *a, byte *b)
+{
+  MI_INFO *aa=((MYRG_TABLE *)a)->table;
+  MI_INFO *bb=((MYRG_TABLE *)b)->table;
+  uint not_used;
+
+  return (_mi_key_cmp((MI_KEYSEG *)keyseg, aa->lastkey, bb->lastkey,
+                      USE_WHOLE_KEY, SEARCH_FIND, &not_used));
+} /* queue_key_cmp */
+
+int _myrg_init_queue(MYRG_INFO *info,int inx,enum ha_rkey_function search_flag)
+{
+  QUEUE *q=&(info->by_key);
+
+  if (!q->root)
+  {
+    if (init_queue(q,info->tables, 0,
+                   (myisam_read_vec[search_flag]==SEARCH_SMALLER),
+                   queue_key_cmp,
+                   info->open_tables->table->s->keyinfo[inx].seg))
+      return my_errno;
+  }
+  else
+  {
+    if (reinit_queue(q,info->tables, 0,
+                     (myisam_read_vec[search_flag]==SEARCH_SMALLER),
+                     queue_key_cmp,
+                     info->open_tables->table->s->keyinfo[inx].seg))
+      return my_errno;
+  }
+}
+

myisammrg/myrg_rfirst.c

+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include "mymrgdef.h"
+
+	/*  Read first row through  a specfic key */
+
+int myrg_rfirst(MYRG_INFO *info, byte *buf, int inx)
+{
+  MYRG_TABLE *table;
+  MI_INFO *mi;
+  int err;
+
+  if (_myrg_init_queue(info,inx,HA_READ_KEY_OR_NEXT))
+    return my_errno;
+
+  for (table=info->open_tables ; table < info->end_table ; table++)
+  {
+    err=mi_rfirst(table->table,NULL,inx);
+    info->last_used_table=table;
+
+    if (err == HA_ERR_END_OF_FILE)
+      continue;
+    if (err)
+      return err;
+
+    /* adding to queue */
+    queue_insert(&(info->by_key),(byte *)table);
+  }
+
+  if (!info->by_key.elements)
+    return HA_ERR_END_OF_FILE;
+
+  mi=(info->current_table=(MYRG_TABLE *)queue_top(&(info->by_key)))->table;
+  return mi_rrnd(mi,buf,mi->lastpos);
+}

myisammrg/myrg_rkey.c

+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+/* Read record based on a key */
+
+#include "mymrgdef.h"
+
+/* todo: we could store some additional info to speedup lookups:
+         column (key, keyseg) can be constant per table
+         it can also be increasing (table1.val > table2.val > ...),
+         or decreasing, <=, >=, etc.
+                                                                   SerG
+*/
+
+int myrg_rkey(MYRG_INFO *info,byte *record,int inx, const byte *key,
+            uint key_len, enum ha_rkey_function search_flag)
+{
+  uchar *key_buff;
+  uint pack_key_length;
+  MYRG_TABLE *table;
+  MI_INFO *mi;
+  int err;
+  byte *buf=((search_flag == HA_READ_KEY_EXACT)?record:0);
+
+  if (_myrg_init_queue(info,inx,search_flag))
+    return my_errno;
+
+  for (table=info->open_tables ; table < info->end_table ; table++)
+  {
+    mi=table->table;
+
+    if (table == info->open_tables)
+    {
+      err=mi_rkey(mi,buf,inx,key,key_len,search_flag);
+      key_buff=mi->lastkey+mi->s->base.max_key_length;
+      pack_key_length=mi->last_rkey_length;
+    }
+    else
+    {
+      err=_mi_rkey(mi,buf,inx,key_buff,pack_key_length,search_flag,FALSE);
+    }
+    info->last_used_table=table;
+
+    if (err == HA_ERR_KEY_NOT_FOUND)
+      continue;
+    if (err)
+      return err;
+
+    /* adding to queue */
+    queue_insert(&(info->by_key),(byte *)table);
+
+    /* if looking for KEY_EXACT, return first matched now */
+    if (buf)
+    {
+      info->current_table=table;
+      return 0;
+    }
+  }
+
+  if (!info->by_key.elements)
+    return HA_ERR_KEY_NOT_FOUND;
+
+  mi=(info->current_table=(MYRG_TABLE *)queue_top(&(info->by_key)))->table;
+  return mi_rrnd(mi,record,mi->lastpos);
+}
+
+/*
+ *    HA_READ_KEY_EXACT   => SEARCH_BIGGER
+ *    HA_READ_KEY_OR_NEXT => SEARCH_BIGGER
+ *    HA_READ_AFTER_KEY   => SEARCH_BIGGER
+ *    HA_READ_PREFIX      => SEARCH_BIGGER
+ *    HA_READ_KEY_OR_PREV => SEARCH_SMALLER
+ *    HA_READ_BEFORE_KEY  => SEARCH_SMALLER
+ *    HA_READ_PREFIX_LAST => SEARCH_SMALLER
+ */
+

myisammrg/myrg_rlast.c

+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include "mymrgdef.h"
+
+	/* Read last row with the same key as the previous read. */
+
+int myrg_rlast(MYRG_INFO *info, byte *buf, int inx)
+{
+  MYRG_TABLE *table;
+  MI_INFO *mi;
+  int err;
+
+  if (_myrg_init_queue(info,inx,HA_READ_KEY_OR_PREV))
+    return my_errno;
+
+  for (table=info->open_tables ; table < info->end_table ; table++)
+  {
+    err=mi_rlast(table->table,NULL,inx);
+    info->last_used_table=table;
+
+    if (err == HA_ERR_END_OF_FILE)
+      continue;
+    if (err)
+      return err;
+
+    /* adding to queue */
+    queue_insert(&(info->by_key),(byte *)table);
+  }
+
+  if (!info->by_key.elements)
+    return HA_ERR_END_OF_FILE;
+
+  mi=(info->current_table=(MYRG_TABLE *)queue_top(&(info->by_key)))->table;
+  return mi_rrnd(mi,buf,mi->lastpos);
+}
+

myisammrg/myrg_rnext.c

+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include "mymrgdef.h"
+
+	/*
+	   Read next row with the same key as previous read
+	*/
+
+int myrg_rnext(MYRG_INFO *info, byte *buf, int inx)
+{
+  MYRG_TABLE *table;
+  MI_INFO *mi;
+  uchar *key_buff;
+  uint pack_key_length;
+  int err;
+
+  /* at first, do rnext for the table found before */
+  err=mi_rnext(info->current_table->table,NULL,inx);
+  if (err == HA_ERR_END_OF_FILE)
+  {
+    queue_remove(&(info->by_key),0);
+    if (!info->by_key.elements)
+      return HA_ERR_END_OF_FILE;
+  }
+  else if (err)
+    return err;
+  else
+  {
+    /* Found here, adding to queue */
+    queue_top(&(info->by_key))=(byte *)(info->current_table);
+    queue_replaced(&(info->by_key));
+  }
+
+  /* next, let's finish myrg_rkey's initial scan */
+  table=info->last_used_table+1;
+  if (table < info->end_table)
+  {
+    mi=info->last_used_table->table;
+    key_buff=mi->lastkey+mi->s->base.max_key_length;
+    pack_key_length=mi->last_rkey_length;
+    for (; table < info->end_table ; table++)
+    {
+      mi=table->table;
+      err=_mi_rkey(mi,NULL,inx,key_buff,pack_key_length,HA_READ_KEY_OR_NEXT,FALSE);
+      info->last_used_table=table;
+
+      if (err == HA_ERR_KEY_NOT_FOUND)
+        continue;
+      if (err)
+        return err;
+
+      /* Found here, adding to queue */
+      queue_insert(&(info->by_key),(byte *)table);
+    }
+  }
+
+  /* now, mymerge's read_next is as simple as one queue_top */
+  mi=(info->current_table=(MYRG_TABLE *)queue_top(&(info->by_key)))->table;
+  return mi_rrnd(mi,buf,mi->lastpos);
+}
+

myisammrg/myrg_rprev.c

+/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include "mymrgdef.h"
+
+	/*
+	   Read previous row with the same key as previous read
+	*/
+
+int myrg_rprev(MYRG_INFO *info, byte *buf, int inx)
+{
+  MYRG_TABLE *table;
+  MI_INFO *mi;
+  uchar *key_buff;
+  uint pack_key_length;
+  int err;
+
+  /* at first, do rnext for the table found before */
+  err=mi_rprev(info->current_table->table,NULL,inx);
+  if (err == HA_ERR_END_OF_FILE)
+  {
+    queue_remove(&(info->by_key),0);
+    if (!info->by_key.elements)
+      return HA_ERR_END_OF_FILE;
+  }
+  else if (err)
+    return err;
+  else
+  {
+    /* Found here, adding to queue */
+    queue_top(&(info->by_key))=(byte *)(info->current_table);
+    queue_replaced(&(info->by_key));
+  }
+
+  /* next, let's finish myrg_rkey's initial scan */
+  table=info->last_used_table+1;
+  if (table < info->end_table)
+  {
+    mi=info->last_used_table->table;
+    key_buff=mi->lastkey+mi->s->base.max_key_length;
+    pack_key_length=mi->last_rkey_length;
+    for (; table < info->end_table ; table++)
+    {
+      mi=table->table;
+      err=_mi_rkey(mi,NULL,inx,key_buff,pack_key_length,HA_READ_KEY_OR_PREV,FALSE);
+      info->last_used_table=table;
+
+      if (err == HA_ERR_KEY_NOT_FOUND)
+        continue;
+      if (err)
+        return err;
+
+      /* Found here, adding to queue */
+      queue_insert(&(info->by_key),(byte *)table);
+    }
+  }
+
+  /* now, mymerge's read_prev is as simple as one queue_top */
+  mi=(info->current_table=(MYRG_TABLE *)queue_top(&(info->by_key)))->table;
+  return mi_rrnd(mi,buf,mi->lastpos);
+}
+
+

myisammrg/myrg_rrnd.c

@@ -81,7 +81,7 @@ int myrg_rrnd(MYRG_INFO *info,byte *buf,ulonglong filepos)
     }
   }
   info->current_table=find_table(info->open_tables,
-				 info->last_used_table,filepos);
+				 info->end_table-1,filepos);
   isam_info=info->current_table->table;
   isam_info->update&= HA_STATE_CHANGED;
   return ((*isam_info->s->read_rnd)(isam_info,(byte*) buf,

mysys/queues.c

@@ -21,6 +21,7 @@
 */
 
 #include "mysys_priv.h"
+#include "mysys_err.h"
 #include <queues.h>
 
 
@@ -43,6 +44,23 @@ int init_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
   DBUG_RETURN(0);
 }
 
+int reinit_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
+               pbool max_at_top, int (*compare) (void *, byte *, byte *),
+               void *first_cmp_arg)
+{
+  DBUG_ENTER("reinit_queue");
+  if (queue->max_elements < max_elements)
+    /* It's real easy to do realloc here, just don't want to bother */
+    DBUG_RETURN(my_errno=EE_OUTOFMEMORY);
+
+  queue->elements=0;
+  queue->compare=compare;
+  queue->first_cmp_arg=first_cmp_arg;
+  queue->offset_to_key=offset_to_key;
+  queue->max_at_top= max_at_top ? (-1 ^ 1) : 0;
+  DBUG_RETURN(0);
+}
+
 void delete_queue(QUEUE *queue)
 {
   DBUG_ENTER("delete_queue");

sql/ha_myisammrg.cc

@@ -86,33 +86,57 @@ int ha_myisammrg::delete_row(const byte * buf)
 int ha_myisammrg::index_read(byte * buf, const byte * key,
 			  uint key_len, enum ha_rkey_function find_flag)
 {
-  return (my_errno=HA_ERR_WRONG_COMMAND);
+//  return (my_errno=HA_ERR_WRONG_COMMAND);
+  statistic_increment(ha_read_key_count,&LOCK_status);
+  int error=myrg_rkey(file,buf,active_index, key, key_len, find_flag);
+  table->status=error ? STATUS_NOT_FOUND: 0;
+  return error;
 }
 
 int ha_myisammrg::index_read_idx(byte * buf, uint index, const byte * key,
 				 uint key_len, enum ha_rkey_function find_flag)
 {
-  return (my_errno=HA_ERR_WRONG_COMMAND);
+//  return (my_errno=HA_ERR_WRONG_COMMAND);
+  statistic_increment(ha_read_key_count,&LOCK_status);
+  int error=myrg_rkey(file,buf,index, key, key_len, find_flag);
+  table->status=error ? STATUS_NOT_FOUND: 0;
+  return error;
 }
 
 int ha_myisammrg::index_next(byte * buf)
 {
-  return (my_errno=HA_ERR_WRONG_COMMAND);
+//  return (my_errno=HA_ERR_WRONG_COMMAND);
+  statistic_increment(ha_read_next_count,&LOCK_status);
+  int error=myrg_rnext(file,buf,active_index);
+  table->status=error ? STATUS_NOT_FOUND: 0;
+  return error;
 }
 
 int ha_myisammrg::index_prev(byte * buf)
 {
-  return (my_errno=HA_ERR_WRONG_COMMAND);
+// return (my_errno=HA_ERR_WRONG_COMMAND);
+  statistic_increment(ha_read_prev_count,&LOCK_status);
+  int error=myrg_rprev(file,buf, active_index);
+  table->status=error ? STATUS_NOT_FOUND: 0;
+  return error;
 }
 
 int ha_myisammrg::index_first(byte * buf)
 {
-  return (my_errno=HA_ERR_WRONG_COMMAND);
+//  return (my_errno=HA_ERR_WRONG_COMMAND);
+  statistic_increment(ha_read_first_count,&LOCK_status);
+  int error=myrg_rfirst(file, buf, active_index);
+  table->status=error ? STATUS_NOT_FOUND: 0;
+  return error;
 }
 
 int ha_myisammrg::index_last(byte * buf)
 {
-  return (my_errno=HA_ERR_WRONG_COMMAND);
+//  return (my_errno=HA_ERR_WRONG_COMMAND);
+  statistic_increment(ha_read_last_count,&LOCK_status);
+  int error=myrg_rlast(file, buf, active_index);
+  table->status=error ? STATUS_NOT_FOUND: 0;
+  return error;
 }
 
 int ha_myisammrg::rnd_init(bool scan)
@@ -151,7 +175,7 @@ void ha_myisammrg::info(uint flag)
   deleted = (ha_rows) info.deleted;
   data_file_length=info.data_file_length;
   errkey  = info.errkey;
-  table->keys_in_use=0;				// No keys yet
+  table->keys_in_use=(((key_map) 1) << table->keys)- (key_map) 1;
   table->db_options_in_use    = info.options;
   mean_rec_length=info.reclength;
   block_size=0;

sql/ha_myisammrg.h

@@ -32,11 +32,15 @@ class ha_myisammrg: public handler
   ~ha_myisammrg() {}
   const char *table_type() const { return "MRG_MyISAM"; }
   const char **bas_ext() const;
-  ulong option_flag() const { return HA_READ_RND_SAME+HA_KEYPOS_TO_RNDPOS+HA_REC_NOT_IN_SEQ;}
+  ulong option_flag() const { return HA_REC_NOT_IN_SEQ+HA_READ_NEXT+
+                                     HA_READ_PREV+HA_READ_RND_SAME+HA_HAVE_KEY_READ_ONLY+
+		                     HA_KEYPOS_TO_RNDPOS+HA_READ_ORDER+
+		                     HA_LASTKEY_ORDER+HA_READ_NOT_EXACT_KEY+
+		                     HA_LONGLONG_KEYS+HA_NULL_KEY+HA_BLOB_KEY; }
   uint max_record_length() const { return HA_MAX_REC_LENGTH; }
-  uint max_keys()          const { return 0; }
-  uint max_key_parts()     const { return 0; }
-  uint max_key_length()    const { return 0; }
+  uint max_keys()          const { return 1; }
+  uint max_key_parts()     const { return MAX_REF_PARTS; }
+  uint max_key_length()    const { return MAX_KEY_LENGTH; }
 
   int open(const char *name, int mode, int test_if_locked);
   int close(void);