database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-30 16:24:05 +03:00
Code Activity

PART I: Keys support for MyMERGE tables

Browse Source 
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 ')
This commit is contained in:
serg@infomag.ape.relarn.ru
2000-08-14 15:27:19 +04:00
parent 807460bbce
commit 5886090182
27 changed files with 519 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
Makefile.am Executable file → Normal file
View File

0
acconfig.h Executable file → Normal file
View File

6
include/myisammrg.h
View File

@ -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);

0
include/mysql_version.h.in Executable file → Normal file
View File

3
include/queues.h
View File

@ -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);

30
myisam/mi_rkey.c
View File

@ -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);
}

4
myisam/mi_rnext.c
View File

@ -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 */

4
myisam/mi_rprev.c
View File

@ -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 */

5
myisammrg/Makefile.am
View File

@ -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 \

3
myisammrg/mymrgdef.h
View File

@ -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);

1
myisammrg/myrg_open.c
View File

@ -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:

52
myisammrg/myrg_queue.c Normal file
View File

@ -0,0 +1,52 @@
/* 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;
}
}

49
myisammrg/myrg_rfirst.c Normal file
View File

@ -0,0 +1,49 @@
/* 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);
}

89
myisammrg/myrg_rkey.c Normal file
View File

@ -0,0 +1,89 @@
/* 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
*/

50
myisammrg/myrg_rlast.c Normal file
View File

@ -0,0 +1,50 @@
/* 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);
}

75
myisammrg/myrg_rnext.c Normal file
View File

@ -0,0 +1,75 @@
/* 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);
}

76
myisammrg/myrg_rprev.c Normal file
View File

@ -0,0 +1,76 @@
/* 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);
}

2
myisammrg/myrg_rrnd.c
View File

@ -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,

0
mysys/COPYING.LIB Executable file → Normal file
View File

18
mysys/queues.c
View File

@ -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");

38
sql/ha_myisammrg.cc
View File

@ -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;

12
sql/ha_myisammrg.h
View File

@ -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);

0
sql/item_uniq.cc Executable file → Normal file
View File

0
sql/item_uniq.h Executable file → Normal file
View File

0
sql/share/Makefile.am Executable file → Normal file
View File

0
strings/ChangeLog Executable file → Normal file
View File

0
support-files/Makefile.am Executable file → Normal file
View File