1766 lines
58 KiB
C++
1766 lines
58 KiB
C++
/* Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License, version 2.0,
|
|
as published by the Free Software Foundation.
|
|
|
|
This program is also distributed with certain software (including
|
|
but not limited to OpenSSL) that is licensed under separate terms,
|
|
as designated in a particular file or component or in included license
|
|
documentation. The authors of MySQL hereby grant you an additional
|
|
permission to link the program and your derivative works with the
|
|
separately licensed software that they have included with MySQL.
|
|
|
|
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, version 2.0, 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
/* key handling functions */
|
|
|
|
#include "my_config.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "m_ctype.h"
|
|
#include "my_byteorder.h"
|
|
#include "my_compiler.h"
|
|
#include "my_dbug.h"
|
|
#include "my_inttypes.h"
|
|
#include "my_macros.h"
|
|
#include "storage/myisam/fulltext.h"
|
|
#include "storage/myisam/myisamdef.h"
|
|
|
|
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
|
|
uchar *key, uchar *keypos,
|
|
uint *return_key_length);
|
|
|
|
/* Check index */
|
|
|
|
int _mi_check_index(MI_INFO *info, int inx) {
|
|
if (inx == -1) /* Use last index */
|
|
inx = info->lastinx;
|
|
if (inx < 0) {
|
|
set_my_errno(HA_ERR_WRONG_INDEX);
|
|
return -1;
|
|
}
|
|
if (!mi_is_key_active(info->s->state.key_map, inx)) {
|
|
set_my_errno(info->s->state.state.records ? HA_ERR_WRONG_INDEX
|
|
: HA_ERR_END_OF_FILE);
|
|
return -1;
|
|
}
|
|
if (info->lastinx != inx) /* Index changed */
|
|
{
|
|
info->lastinx = inx;
|
|
info->page_changed = 1;
|
|
info->update = ((info->update & (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED)) |
|
|
HA_STATE_NEXT_FOUND | HA_STATE_PREV_FOUND);
|
|
}
|
|
if (info->opt_flag & WRITE_CACHE_USED && flush_io_cache(&info->rec_cache))
|
|
return (-1);
|
|
return (inx);
|
|
} /* mi_check_index */
|
|
|
|
/*
|
|
** Search after row by a key
|
|
** Position to row is stored in info->lastpos
|
|
** Return: -1 if not found
|
|
** 1 if one should continue search on higher level
|
|
*/
|
|
|
|
int _mi_search(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, uint key_len,
|
|
uint nextflag, my_off_t pos) {
|
|
bool last_key;
|
|
int error, flag;
|
|
uint nod_flag;
|
|
uchar *keypos, *maxpos;
|
|
uchar lastkey[MI_MAX_KEY_BUFF], *buff;
|
|
DBUG_TRACE;
|
|
DBUG_PRINT("enter", ("pos: %lu nextflag: %u lastpos: %lu", (ulong)pos,
|
|
nextflag, (ulong)info->lastpos));
|
|
DBUG_EXECUTE("key", _mi_print_key(DBUG_FILE, keyinfo->seg, key, key_len););
|
|
|
|
if (pos == HA_OFFSET_ERROR) {
|
|
set_my_errno(HA_ERR_KEY_NOT_FOUND); /* Didn't find key */
|
|
info->lastpos = HA_OFFSET_ERROR;
|
|
if (!(nextflag & (SEARCH_SMALLER | SEARCH_BIGGER | SEARCH_LAST)))
|
|
return -1; /* Not found ; return error */
|
|
return 1; /* Search at upper levels */
|
|
}
|
|
|
|
if (!(buff = _mi_fetch_keypage(info, keyinfo, pos, DFLT_INIT_HITS, info->buff,
|
|
!(nextflag & SEARCH_SAVE_BUFF))))
|
|
goto err;
|
|
DBUG_DUMP("page", buff, mi_getint(buff));
|
|
|
|
flag = (*keyinfo->bin_search)(info, keyinfo, buff, key, key_len, nextflag,
|
|
&keypos, lastkey, &last_key);
|
|
if (flag == MI_FOUND_WRONG_KEY) return -1;
|
|
nod_flag = mi_test_if_nod(buff);
|
|
maxpos = buff + mi_getint(buff) - 1;
|
|
|
|
if (flag) {
|
|
if ((error = _mi_search(info, keyinfo, key, key_len, nextflag,
|
|
_mi_kpos(nod_flag, keypos))) <= 0)
|
|
return error;
|
|
|
|
if (flag > 0) {
|
|
if (nextflag & (SEARCH_SMALLER | SEARCH_LAST) &&
|
|
keypos == buff + 2 + nod_flag)
|
|
return 1; /* Bigger than key */
|
|
} else if (nextflag & SEARCH_BIGGER && keypos >= maxpos)
|
|
return 1; /* Smaller than key */
|
|
} else {
|
|
if ((nextflag & SEARCH_FIND) && nod_flag &&
|
|
((keyinfo->flag & (HA_NOSAME | HA_NULL_PART)) != HA_NOSAME ||
|
|
key_len != USE_WHOLE_KEY)) {
|
|
if ((error = _mi_search(info, keyinfo, key, key_len, SEARCH_FIND,
|
|
_mi_kpos(nod_flag, keypos))) >= 0 ||
|
|
my_errno() != HA_ERR_KEY_NOT_FOUND)
|
|
return error;
|
|
info->last_keypage = HA_OFFSET_ERROR; /* Buffer not in mem */
|
|
}
|
|
}
|
|
if (pos != info->last_keypage) {
|
|
uchar *old_buff = buff;
|
|
if (!(buff = _mi_fetch_keypage(info, keyinfo, pos, DFLT_INIT_HITS,
|
|
info->buff, !(nextflag & SEARCH_SAVE_BUFF))))
|
|
goto err;
|
|
keypos = buff + (keypos - old_buff);
|
|
maxpos = buff + (maxpos - old_buff);
|
|
}
|
|
|
|
if ((nextflag & (SEARCH_SMALLER | SEARCH_LAST)) && flag != 0) {
|
|
uint not_used[2];
|
|
if (_mi_get_prev_key(info, keyinfo, buff, info->lastkey, keypos,
|
|
&info->lastkey_length))
|
|
goto err;
|
|
if (!(nextflag & SEARCH_SMALLER) &&
|
|
ha_key_cmp(keyinfo->seg, info->lastkey, key, key_len, SEARCH_FIND,
|
|
not_used)) {
|
|
set_my_errno(HA_ERR_KEY_NOT_FOUND); /* Didn't find key */
|
|
goto err;
|
|
}
|
|
} else {
|
|
info->lastkey_length =
|
|
(*keyinfo->get_key)(keyinfo, nod_flag, &keypos, lastkey);
|
|
if (!info->lastkey_length) goto err;
|
|
memcpy(info->lastkey, lastkey, info->lastkey_length);
|
|
}
|
|
info->lastpos = _mi_dpos(info, 0, info->lastkey + info->lastkey_length);
|
|
/* Save position for a possible read next / previous */
|
|
info->int_keypos = info->buff + (keypos - buff);
|
|
info->int_maxpos = info->buff + (maxpos - buff);
|
|
info->int_nod_flag = nod_flag;
|
|
info->int_keytree_version = keyinfo->version;
|
|
info->last_search_keypage = info->last_keypage;
|
|
info->page_changed = 0;
|
|
info->buff_used = (info->buff != buff); /* If we have to reread buff */
|
|
|
|
DBUG_PRINT("exit", ("found key at %lu", (ulong)info->lastpos));
|
|
return 0;
|
|
|
|
err:
|
|
DBUG_PRINT("exit", ("Error: %d", my_errno()));
|
|
info->lastpos = HA_OFFSET_ERROR;
|
|
info->page_changed = 1;
|
|
return -1;
|
|
} /* _mi_search */
|
|
|
|
/* Search after key in page-block */
|
|
/* If packed key puts smaller or identical key in buff */
|
|
/* ret_pos point to where find or bigger key starts */
|
|
/* ARGSUSED */
|
|
|
|
int _mi_bin_search(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key,
|
|
uint key_len, uint comp_flag, uchar **ret_pos,
|
|
uchar *buff MY_ATTRIBUTE((unused)), bool *last_key) {
|
|
int start, mid, end, save_end;
|
|
int flag = 0;
|
|
uint totlength, nod_flag, not_used[2];
|
|
DBUG_TRACE;
|
|
|
|
totlength = keyinfo->keylength + (nod_flag = mi_test_if_nod(page));
|
|
start = 0;
|
|
mid = 1;
|
|
save_end = end = (int)((mi_getint(page) - 2 - nod_flag) / totlength - 1);
|
|
DBUG_PRINT("test", ("mi_getint: %d end: %d", mi_getint(page), end));
|
|
page += 2 + nod_flag;
|
|
|
|
while (start != end) {
|
|
mid = (start + end) / 2;
|
|
if ((flag = ha_key_cmp(keyinfo->seg, page + (uint)mid * totlength, key,
|
|
key_len, comp_flag, not_used)) >= 0)
|
|
end = mid;
|
|
else
|
|
start = mid + 1;
|
|
}
|
|
if (mid != start)
|
|
flag = ha_key_cmp(keyinfo->seg, page + (uint)start * totlength, key,
|
|
key_len, comp_flag, not_used);
|
|
if (flag < 0) start++; /* point at next, bigger key */
|
|
*ret_pos = page + (uint)start * totlength;
|
|
*last_key = end == save_end;
|
|
DBUG_PRINT("exit", ("flag: %d keypos: %d", flag, start));
|
|
return flag;
|
|
} /* _mi_bin_search */
|
|
|
|
/*
|
|
Locate a packed key in a key page.
|
|
|
|
SYNOPSIS
|
|
_mi_seq_search()
|
|
info Open table information.
|
|
keyinfo Key definition information.
|
|
page Key page (beginning).
|
|
key Search key.
|
|
key_len Length to use from search key or USE_WHOLE_KEY
|
|
comp_flag Search flags like SEARCH_SAME etc.
|
|
ret_pos RETURN Position in key page behind this key.
|
|
buff RETURN Copy of previous or identical unpacked key.
|
|
last_key RETURN If key is last in page.
|
|
|
|
DESCRIPTION
|
|
Used instead of _mi_bin_search() when key is packed.
|
|
Puts smaller or identical key in buff.
|
|
Key is searched sequentially.
|
|
|
|
RETURN
|
|
> 0 Key in 'buff' is smaller than search key.
|
|
0 Key in 'buff' is identical to search key.
|
|
< 0 Not found.
|
|
*/
|
|
|
|
int _mi_seq_search(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key,
|
|
uint key_len, uint comp_flag, uchar **ret_pos, uchar *buff,
|
|
bool *last_key) {
|
|
int flag = 0;
|
|
uint nod_flag, length = 0, not_used[2];
|
|
uchar t_buff[MI_MAX_KEY_BUFF];
|
|
DBUG_TRACE;
|
|
|
|
const uchar *end = page + mi_getint(page);
|
|
nod_flag = mi_test_if_nod(page);
|
|
page += 2 + nod_flag;
|
|
*ret_pos = page;
|
|
t_buff[0] = 0; /* Avoid bugs */
|
|
while (page < end) {
|
|
length = (*keyinfo->get_key)(keyinfo, nod_flag, &page, t_buff);
|
|
if (length == 0 || page > end) {
|
|
mi_print_error(info->s, HA_ERR_CRASHED);
|
|
set_my_errno(HA_ERR_CRASHED);
|
|
DBUG_PRINT("error", ("Found wrong key: length: %u page: %p end: %p",
|
|
length, page, end));
|
|
return MI_FOUND_WRONG_KEY;
|
|
}
|
|
if ((flag = ha_key_cmp(keyinfo->seg, t_buff, key, key_len, comp_flag,
|
|
not_used)) >= 0)
|
|
break;
|
|
#ifdef EXTRA_DEBUG
|
|
DBUG_PRINT("loop",
|
|
("page: 0x%lx key: '%s' flag: %d", (long)page, t_buff, flag));
|
|
#endif
|
|
memcpy(buff, t_buff, length);
|
|
*ret_pos = page;
|
|
}
|
|
if (flag == 0) memcpy(buff, t_buff, length); /* Result is first key */
|
|
*last_key = page == end;
|
|
DBUG_PRINT("exit", ("flag: %d ret_pos: %p", flag, *ret_pos));
|
|
return flag;
|
|
} /* _mi_seq_search */
|
|
|
|
int _mi_prefix_search(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
|
|
uchar *key, uint key_len, uint nextflag, uchar **ret_pos,
|
|
uchar *buff, bool *last_key) {
|
|
/*
|
|
my_flag is raw comparison result to be changed according to
|
|
SEARCH_NO_FIND,SEARCH_LAST and HA_REVERSE_SORT flags.
|
|
flag is the value returned by ha_key_cmp and as treated as final
|
|
*/
|
|
int flag = 0, my_flag = -1;
|
|
uint nod_flag, length = 0, len, matched, cmplen, kseg_len;
|
|
uint prefix_len = 0, suffix_len;
|
|
int key_len_skip, seg_len_pack = 0, key_len_left;
|
|
const uchar *kseg, *vseg;
|
|
const uchar *sort_order = keyinfo->seg->charset->sort_order;
|
|
uchar tt_buff[MI_MAX_KEY_BUFF + 2], *t_buff = tt_buff + 2;
|
|
const uchar *saved_from = NULL;
|
|
uchar *saved_to = NULL;
|
|
const uchar *saved_vseg = nullptr;
|
|
uint saved_length = 0, saved_prefix_len = 0;
|
|
uint length_pack;
|
|
DBUG_TRACE;
|
|
|
|
t_buff[0] = 0; /* Avoid bugs */
|
|
const uchar *end = page + mi_getint(page);
|
|
nod_flag = mi_test_if_nod(page);
|
|
page += 2 + nod_flag;
|
|
*ret_pos = page;
|
|
kseg = key;
|
|
|
|
kseg_len = get_key_pack_length(&kseg, &length_pack);
|
|
key_len_skip = length_pack + kseg_len;
|
|
key_len_left = (int)key_len - (int)key_len_skip;
|
|
/* If key_len is 0, then lenght_pack is 1, then key_len_left is -1. */
|
|
cmplen = (key_len_left >= 0) ? kseg_len : key_len - length_pack;
|
|
DBUG_PRINT("info", ("key: '%.*s'", kseg_len, kseg));
|
|
|
|
/*
|
|
Keys are compressed the following way:
|
|
|
|
If the max length of first key segment <= 127 bytes the prefix is
|
|
1 byte else it's 2 byte
|
|
|
|
(prefix) length The high bit is set if this is a prefix for the prev key.
|
|
[suffix length] Packed length of suffix if the previous was a prefix.
|
|
(suffix) data Key data bytes (past the common prefix or whole segment).
|
|
[next-key-seg] Next key segments (([packed length], data), ...)
|
|
pointer Reference to the data file (last_keyseg->length).
|
|
*/
|
|
|
|
matched = 0; /* how many char's from prefix were alredy matched */
|
|
len = 0; /* length of previous key unpacked */
|
|
|
|
while (page < end) {
|
|
uint packed = *page & 128;
|
|
|
|
vseg = page;
|
|
if (keyinfo->seg->length >= 127) {
|
|
suffix_len = mi_uint2korr(vseg) & 32767;
|
|
vseg += 2;
|
|
} else
|
|
suffix_len = *vseg++ & 127;
|
|
|
|
if (packed) {
|
|
if (suffix_len == 0) {
|
|
/* == 0x80 or 0x8000, same key, prefix length == old key length. */
|
|
prefix_len = len;
|
|
} else {
|
|
/* > 0x80 or 0x8000, this is prefix lgt, packed suffix lgt follows. */
|
|
prefix_len = suffix_len;
|
|
suffix_len = get_key_length(&vseg);
|
|
}
|
|
} else {
|
|
/* Not packed. No prefix used from last key. */
|
|
prefix_len = 0;
|
|
}
|
|
|
|
len = prefix_len + suffix_len;
|
|
seg_len_pack = get_pack_length(len);
|
|
t_buff = tt_buff + 3 - seg_len_pack;
|
|
store_key_length(t_buff, len);
|
|
|
|
if (prefix_len > saved_prefix_len)
|
|
memcpy(t_buff + seg_len_pack + saved_prefix_len, saved_vseg,
|
|
prefix_len - saved_prefix_len);
|
|
saved_vseg = vseg;
|
|
saved_prefix_len = prefix_len;
|
|
|
|
DBUG_PRINT("loop", ("page: '%.*s%.*s'", prefix_len, t_buff + seg_len_pack,
|
|
suffix_len, vseg));
|
|
{
|
|
const uchar *from = vseg + suffix_len;
|
|
HA_KEYSEG *keyseg;
|
|
uint l;
|
|
|
|
for (keyseg = keyinfo->seg + 1; keyseg->type; keyseg++) {
|
|
if (keyseg->flag & HA_NULL_PART) {
|
|
if (!(*from++)) continue;
|
|
}
|
|
if (keyseg->flag &
|
|
(HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK)) {
|
|
l = get_key_length(&from);
|
|
} else
|
|
l = keyseg->length;
|
|
|
|
from += l;
|
|
}
|
|
from += keyseg->length;
|
|
page = const_cast<uchar *>(from) + nod_flag;
|
|
length = (uint)(from - vseg);
|
|
}
|
|
|
|
if (page > end) {
|
|
mi_print_error(info->s, HA_ERR_CRASHED);
|
|
set_my_errno(HA_ERR_CRASHED);
|
|
DBUG_PRINT("error", ("Found wrong key: length: %u page: %p end: %p",
|
|
length, page, end));
|
|
return MI_FOUND_WRONG_KEY;
|
|
}
|
|
|
|
if (matched >= prefix_len) {
|
|
/* We have to compare. But we can still skip part of the key */
|
|
uint left;
|
|
const uchar *k = kseg + prefix_len;
|
|
|
|
/*
|
|
If prefix_len > cmplen then we are in the end-space comparison
|
|
phase. Do not try to acces the key any more ==> left= 0.
|
|
*/
|
|
left =
|
|
((len <= cmplen) ? suffix_len
|
|
: ((prefix_len < cmplen) ? cmplen - prefix_len : 0));
|
|
|
|
matched = prefix_len + left;
|
|
|
|
if (sort_order) {
|
|
for (my_flag = 0; left; left--)
|
|
if ((my_flag = (int)sort_order[*vseg++] - (int)sort_order[*k++]))
|
|
break;
|
|
} else {
|
|
for (my_flag = 0; left; left--)
|
|
if ((my_flag = (int)*vseg++ - (int)*k++)) break;
|
|
}
|
|
|
|
if (my_flag > 0) /* mismatch */
|
|
break;
|
|
if (my_flag == 0) /* match */
|
|
{
|
|
/*
|
|
** len cmplen seg_left_len more_segs
|
|
** < matched=len; continue search
|
|
** > = prefix ? found : (matched=len;
|
|
*continue search)
|
|
** > < - ok, found
|
|
** = < - ok, found
|
|
** = = - ok, found
|
|
** = = + next seg
|
|
*/
|
|
if (len < cmplen) {
|
|
if ((keyinfo->seg->type != HA_KEYTYPE_TEXT &&
|
|
keyinfo->seg->type != HA_KEYTYPE_VARTEXT1 &&
|
|
keyinfo->seg->type != HA_KEYTYPE_VARTEXT2))
|
|
my_flag = -1;
|
|
else {
|
|
/* We have to compare k and vseg as if they were space extended */
|
|
const uchar *k_end = k + (cmplen - len);
|
|
for (; k < k_end && *k == ' '; k++)
|
|
;
|
|
if (k == k_end) goto cmp_rest; /* should never happen */
|
|
if (*k < (uchar)' ') {
|
|
my_flag = 1; /* Compared string is smaller */
|
|
break;
|
|
}
|
|
my_flag = -1; /* Continue searching */
|
|
}
|
|
} else if (len > cmplen) {
|
|
const uchar *vseg_end;
|
|
if ((nextflag & SEARCH_PREFIX) && key_len_left == 0) goto fix_flag;
|
|
|
|
/* We have to compare k and vseg as if they were space extended */
|
|
for (vseg_end = vseg + (len - cmplen);
|
|
vseg < vseg_end && *vseg == (uchar)' '; vseg++, matched++)
|
|
;
|
|
DBUG_ASSERT(vseg < vseg_end);
|
|
|
|
if (*vseg > (uchar)' ') {
|
|
my_flag = 1; /* Compared string is smaller */
|
|
break;
|
|
}
|
|
my_flag = -1; /* Continue searching */
|
|
} else {
|
|
cmp_rest:
|
|
if (key_len_left > 0) {
|
|
uint not_used[2];
|
|
if ((flag = ha_key_cmp(keyinfo->seg + 1, vseg, k, key_len_left,
|
|
nextflag, not_used)) >= 0)
|
|
break;
|
|
} else {
|
|
/*
|
|
at this line flag==-1 if the following lines were already
|
|
visited and 0 otherwise, i.e. flag <=0 here always !!!
|
|
*/
|
|
fix_flag:
|
|
DBUG_ASSERT(flag <= 0);
|
|
if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST))
|
|
flag = (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
|
|
if (flag >= 0) break;
|
|
}
|
|
}
|
|
}
|
|
matched -= left;
|
|
}
|
|
/* else (matched < prefix_len) ---> do nothing. */
|
|
|
|
memcpy(buff, t_buff, saved_length = seg_len_pack + prefix_len);
|
|
saved_to = buff + saved_length;
|
|
saved_from = saved_vseg;
|
|
saved_length = length;
|
|
*ret_pos = page;
|
|
}
|
|
if (my_flag)
|
|
flag = (keyinfo->seg->flag & HA_REVERSE_SORT) ? -my_flag : my_flag;
|
|
if (flag == 0) {
|
|
memcpy(buff, t_buff, saved_length = seg_len_pack + prefix_len);
|
|
saved_to = buff + saved_length;
|
|
saved_from = saved_vseg;
|
|
saved_length = length;
|
|
}
|
|
if (saved_length) memcpy(saved_to, saved_from, saved_length);
|
|
|
|
*last_key = page == end;
|
|
|
|
DBUG_PRINT("exit", ("flag: %d ret_pos: %p", flag, *ret_pos));
|
|
return flag;
|
|
} /* _mi_prefix_search */
|
|
|
|
/* Get pos to a key_block */
|
|
|
|
my_off_t _mi_kpos(uint nod_flag, uchar *after_key) {
|
|
after_key -= nod_flag;
|
|
switch (nod_flag) {
|
|
#if SIZEOF_OFF_T > 4
|
|
case 7:
|
|
return mi_uint7korr(after_key) * MI_MIN_KEY_BLOCK_LENGTH;
|
|
case 6:
|
|
return mi_uint6korr(after_key) * MI_MIN_KEY_BLOCK_LENGTH;
|
|
case 5:
|
|
return mi_uint5korr(after_key) * MI_MIN_KEY_BLOCK_LENGTH;
|
|
#else
|
|
case 7:
|
|
after_key++;
|
|
case 6:
|
|
after_key++;
|
|
case 5:
|
|
after_key++;
|
|
#endif
|
|
case 4:
|
|
return ((my_off_t)mi_uint4korr(after_key)) * MI_MIN_KEY_BLOCK_LENGTH;
|
|
case 3:
|
|
return ((my_off_t)mi_uint3korr(after_key)) * MI_MIN_KEY_BLOCK_LENGTH;
|
|
case 2:
|
|
return (my_off_t)(mi_uint2korr(after_key) * MI_MIN_KEY_BLOCK_LENGTH);
|
|
case 1:
|
|
return (uint)(*after_key) * MI_MIN_KEY_BLOCK_LENGTH;
|
|
case 0: /* At leaf page */
|
|
default: /* Impossible */
|
|
return (HA_OFFSET_ERROR);
|
|
}
|
|
} /* _kpos */
|
|
|
|
/* Save pos to a key_block */
|
|
|
|
void _mi_kpointer(MI_INFO *info, uchar *buff, my_off_t pos) {
|
|
pos /= MI_MIN_KEY_BLOCK_LENGTH;
|
|
switch (info->s->base.key_reflength) {
|
|
#if SIZEOF_OFF_T > 4
|
|
case 7:
|
|
mi_int7store(buff, pos);
|
|
break;
|
|
case 6:
|
|
mi_int6store(buff, pos);
|
|
break;
|
|
case 5:
|
|
mi_int5store(buff, pos);
|
|
break;
|
|
#else
|
|
case 7:
|
|
*buff++ = 0;
|
|
/* fall trough */
|
|
case 6:
|
|
*buff++ = 0;
|
|
/* fall trough */
|
|
case 5:
|
|
*buff++ = 0;
|
|
/* fall trough */
|
|
#endif
|
|
case 4:
|
|
mi_int4store(buff, pos);
|
|
break;
|
|
case 3:
|
|
mi_int3store(buff, pos);
|
|
break;
|
|
case 2:
|
|
mi_int2store(buff, (uint)pos);
|
|
break;
|
|
case 1:
|
|
buff[0] = (uchar)pos;
|
|
break;
|
|
default:
|
|
abort(); /* impossible */
|
|
}
|
|
} /* _mi_kpointer */
|
|
|
|
/* Calc pos to a data-record from a key */
|
|
|
|
my_off_t _mi_dpos(MI_INFO *info, uint nod_flag, const uchar *after_key) {
|
|
my_off_t pos;
|
|
after_key -= (nod_flag + info->s->rec_reflength);
|
|
switch (info->s->rec_reflength) {
|
|
#if SIZEOF_OFF_T > 4
|
|
case 8:
|
|
pos = (my_off_t)mi_uint8korr(after_key);
|
|
break;
|
|
case 7:
|
|
pos = (my_off_t)mi_uint7korr(after_key);
|
|
break;
|
|
case 6:
|
|
pos = (my_off_t)mi_uint6korr(after_key);
|
|
break;
|
|
case 5:
|
|
pos = (my_off_t)mi_uint5korr(after_key);
|
|
break;
|
|
#else
|
|
case 8:
|
|
pos = (my_off_t)mi_uint4korr(after_key + 4);
|
|
break;
|
|
case 7:
|
|
pos = (my_off_t)mi_uint4korr(after_key + 3);
|
|
break;
|
|
case 6:
|
|
pos = (my_off_t)mi_uint4korr(after_key + 2);
|
|
break;
|
|
case 5:
|
|
pos = (my_off_t)mi_uint4korr(after_key + 1);
|
|
break;
|
|
#endif
|
|
case 4:
|
|
pos = (my_off_t)mi_uint4korr(after_key);
|
|
break;
|
|
case 3:
|
|
pos = (my_off_t)mi_uint3korr(after_key);
|
|
break;
|
|
case 2:
|
|
pos = (my_off_t)mi_uint2korr(after_key);
|
|
break;
|
|
default:
|
|
pos = 0L; /* Shut compiler up */
|
|
}
|
|
return (info->s->options &
|
|
(HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD))
|
|
? pos
|
|
: pos * info->s->base.pack_reclength;
|
|
}
|
|
|
|
/* Calc position from a record pointer ( in delete link chain ) */
|
|
|
|
my_off_t _mi_rec_pos(MYISAM_SHARE *s, uchar *ptr) {
|
|
my_off_t pos;
|
|
switch (s->rec_reflength) {
|
|
#if SIZEOF_OFF_T > 4
|
|
case 8:
|
|
pos = (my_off_t)mi_uint8korr(ptr);
|
|
if (pos == HA_OFFSET_ERROR) return HA_OFFSET_ERROR; /* end of list */
|
|
break;
|
|
case 7:
|
|
pos = (my_off_t)mi_uint7korr(ptr);
|
|
if (pos == (((my_off_t)1) << 56) - 1)
|
|
return HA_OFFSET_ERROR; /* end of list */
|
|
break;
|
|
case 6:
|
|
pos = (my_off_t)mi_uint6korr(ptr);
|
|
if (pos == (((my_off_t)1) << 48) - 1)
|
|
return HA_OFFSET_ERROR; /* end of list */
|
|
break;
|
|
case 5:
|
|
pos = (my_off_t)mi_uint5korr(ptr);
|
|
if (pos == (((my_off_t)1) << 40) - 1)
|
|
return HA_OFFSET_ERROR; /* end of list */
|
|
break;
|
|
#else
|
|
case 8:
|
|
case 7:
|
|
case 6:
|
|
case 5:
|
|
ptr += (s->rec_reflength - 4);
|
|
/* fall through */
|
|
#endif
|
|
case 4:
|
|
pos = (my_off_t)mi_uint4korr(ptr);
|
|
if (pos == (my_off_t)(uint32)~0L) return HA_OFFSET_ERROR;
|
|
break;
|
|
case 3:
|
|
pos = (my_off_t)mi_uint3korr(ptr);
|
|
if (pos == (my_off_t)(1 << 24) - 1) return HA_OFFSET_ERROR;
|
|
break;
|
|
case 2:
|
|
pos = (my_off_t)mi_uint2korr(ptr);
|
|
if (pos == (my_off_t)(1 << 16) - 1) return HA_OFFSET_ERROR;
|
|
break;
|
|
default:
|
|
abort(); /* Impossible */
|
|
}
|
|
return ((s->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD))
|
|
? pos
|
|
: pos * s->base.pack_reclength);
|
|
}
|
|
|
|
/* save position to record */
|
|
|
|
void _mi_dpointer(MI_INFO *info, uchar *buff, my_off_t pos) {
|
|
if (!(info->s->options &
|
|
(HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
|
|
pos != HA_OFFSET_ERROR)
|
|
pos /= info->s->base.pack_reclength;
|
|
|
|
switch (info->s->rec_reflength) {
|
|
#if SIZEOF_OFF_T > 4
|
|
case 8:
|
|
mi_int8store(buff, pos);
|
|
break;
|
|
case 7:
|
|
mi_int7store(buff, pos);
|
|
break;
|
|
case 6:
|
|
mi_int6store(buff, pos);
|
|
break;
|
|
case 5:
|
|
mi_int5store(buff, pos);
|
|
break;
|
|
#else
|
|
case 8:
|
|
*buff++ = 0;
|
|
/* fall trough */
|
|
case 7:
|
|
*buff++ = 0;
|
|
/* fall trough */
|
|
case 6:
|
|
*buff++ = 0;
|
|
/* fall trough */
|
|
case 5:
|
|
*buff++ = 0;
|
|
/* fall trough */
|
|
#endif
|
|
case 4:
|
|
mi_int4store(buff, pos);
|
|
break;
|
|
case 3:
|
|
mi_int3store(buff, pos);
|
|
break;
|
|
case 2:
|
|
mi_int2store(buff, (uint)pos);
|
|
break;
|
|
default:
|
|
abort(); /* Impossible */
|
|
}
|
|
} /* _mi_dpointer */
|
|
|
|
/* Get key from key-block */
|
|
/* page points at previous key; its advanced to point at next key */
|
|
/* key should contain previous key */
|
|
/* Returns length of found key + pointers */
|
|
/* nod_flag is a flag if we are on nod */
|
|
|
|
/* same as _mi_get_key but used with fixed length keys */
|
|
|
|
uint _mi_get_static_key(MI_KEYDEF *keyinfo, uint nod_flag, uchar **page,
|
|
uchar *key) {
|
|
memcpy((uchar *)key, (uchar *)*page, (size_t)(keyinfo->keylength + nod_flag));
|
|
*page += keyinfo->keylength + nod_flag;
|
|
return (keyinfo->keylength);
|
|
} /* _mi_get_static_key */
|
|
|
|
/*
|
|
get key witch is packed against previous key or key with a NULL column.
|
|
|
|
SYNOPSIS
|
|
_mi_get_pack_key()
|
|
keyinfo key definition information.
|
|
nod_flag If nod: Length of node pointer, else zero.
|
|
page_pos RETURN position in key page behind this key.
|
|
key IN/OUT in: prev key, out: unpacked key.
|
|
|
|
RETURN
|
|
key_length + length of data pointer
|
|
*/
|
|
|
|
uint _mi_get_pack_key(MI_KEYDEF *keyinfo, uint nod_flag, uchar **page_pos,
|
|
uchar *key) {
|
|
HA_KEYSEG *keyseg;
|
|
uchar *start_key, *page = *page_pos;
|
|
uint length;
|
|
|
|
start_key = key;
|
|
for (keyseg = keyinfo->seg; keyseg->type; keyseg++) {
|
|
if (keyseg->flag & HA_PACK_KEY) {
|
|
/* key with length, packed to previous key */
|
|
uchar *start = key;
|
|
uint packed = *page & 128, tot_length, rest_length;
|
|
if (keyseg->length >= 127) {
|
|
length = mi_uint2korr(page) & 32767;
|
|
page += 2;
|
|
} else
|
|
length = *page++ & 127;
|
|
|
|
if (packed) {
|
|
if (length > (uint)keyseg->length) {
|
|
mi_print_error(keyinfo->share, HA_ERR_CRASHED);
|
|
set_my_errno(HA_ERR_CRASHED);
|
|
return 0; /* Error */
|
|
}
|
|
if (length == 0) /* Same key */
|
|
{
|
|
if (keyseg->flag & HA_NULL_PART) *key++ = 1; /* Can't be NULL */
|
|
length = get_key_length(pointer_cast<const uchar **>(&key));
|
|
key += length; /* Same diff_key as prev */
|
|
if (length > keyseg->length) {
|
|
DBUG_PRINT("error",
|
|
("Found too long null packed key: %u of %u at %p",
|
|
length, keyseg->length, *page_pos));
|
|
DBUG_DUMP("key", *page_pos, 16);
|
|
mi_print_error(keyinfo->share, HA_ERR_CRASHED);
|
|
set_my_errno(HA_ERR_CRASHED);
|
|
return 0;
|
|
}
|
|
continue;
|
|
}
|
|
if (keyseg->flag & HA_NULL_PART) {
|
|
key++; /* Skip null marker*/
|
|
start++;
|
|
}
|
|
|
|
rest_length = get_key_length(pointer_cast<const uchar **>(&page));
|
|
tot_length = rest_length + length;
|
|
|
|
/* If the stored length has changed, we must move the key */
|
|
if (tot_length >= 255 && *start != 255) {
|
|
/* length prefix changed from a length of one to a length of 3 */
|
|
memmove(key + 3, key + 1, length);
|
|
*key = 255;
|
|
mi_int2store(key + 1, tot_length);
|
|
key += 3 + length;
|
|
} else if (tot_length < 255 && *start == 255) {
|
|
memmove(key + 1, key + 3, length);
|
|
*key = tot_length;
|
|
key += 1 + length;
|
|
} else {
|
|
store_key_length_inc(key, tot_length);
|
|
key += length;
|
|
}
|
|
memcpy(key, page, rest_length);
|
|
page += rest_length;
|
|
key += rest_length;
|
|
continue;
|
|
} else {
|
|
if (keyseg->flag & HA_NULL_PART) {
|
|
if (!length--) /* Null part */
|
|
{
|
|
*key++ = 0;
|
|
continue;
|
|
}
|
|
*key++ = 1; /* Not null */
|
|
}
|
|
}
|
|
if (length > (uint)keyseg->length) {
|
|
DBUG_PRINT("error", ("Found too long packed key: %u of %u at %p",
|
|
length, keyseg->length, *page_pos));
|
|
DBUG_DUMP("key", *page_pos, 16);
|
|
mi_print_error(keyinfo->share, HA_ERR_CRASHED);
|
|
set_my_errno(HA_ERR_CRASHED);
|
|
return 0; /* Error */
|
|
}
|
|
store_key_length_inc(key, length);
|
|
} else {
|
|
if (keyseg->flag & HA_NULL_PART) {
|
|
if (!(*key++ = *page++)) continue;
|
|
}
|
|
if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK)) {
|
|
const uchar *tmp = page;
|
|
length = get_key_length(&tmp);
|
|
length += (uint)(tmp - page);
|
|
} else
|
|
length = keyseg->length;
|
|
}
|
|
memcpy((uchar *)key, (uchar *)page, (size_t)length);
|
|
key += length;
|
|
page += length;
|
|
}
|
|
length = keyseg->length + nod_flag;
|
|
memmove((uchar *)key, (uchar *)page, length);
|
|
*page_pos = page + length;
|
|
return ((uint)(key - start_key) + keyseg->length);
|
|
} /* _mi_get_pack_key */
|
|
|
|
/* key that is packed relatively to previous */
|
|
|
|
uint _mi_get_binary_pack_key(MI_KEYDEF *keyinfo, uint nod_flag,
|
|
uchar **page_pos, uchar *key) {
|
|
HA_KEYSEG *keyseg;
|
|
uchar *start_key, *page, *page_end, *from, *from_end;
|
|
uint length, tmp;
|
|
DBUG_TRACE;
|
|
|
|
page = *page_pos;
|
|
page_end = page + MI_MAX_KEY_BUFF + 1;
|
|
start_key = key;
|
|
|
|
/*
|
|
Keys are compressed the following way:
|
|
|
|
prefix length Packed length of prefix common with prev key (1 or 3 bytes)
|
|
for each key segment:
|
|
[is null] Null indicator if can be null (1 byte, zero means null)
|
|
[length] Packed length if varlength (1 or 3 bytes)
|
|
key segment 'length' bytes of key segment value
|
|
pointer Reference to the data file (last_keyseg->length).
|
|
|
|
get_key_length() is a macro. It gets the prefix length from 'page'
|
|
and puts it into 'length'. It increments 'page' by 1 or 3, depending
|
|
on the packed length of the prefix length.
|
|
*/
|
|
length = get_key_length(pointer_cast<const uchar **>(&page));
|
|
if (length) {
|
|
if (length > keyinfo->maxlength) {
|
|
DBUG_PRINT("error", ("Found too long binary packed key: %u of %u at %p",
|
|
length, keyinfo->maxlength, *page_pos));
|
|
DBUG_DUMP("key", *page_pos, 16);
|
|
goto crashed; /* Wrong key */
|
|
}
|
|
/* Key is packed against prev key, take prefix from prev key. */
|
|
from = key;
|
|
from_end = key + length;
|
|
} else {
|
|
/* Key is not packed against prev key, take all from page buffer. */
|
|
from = page;
|
|
from_end = page_end;
|
|
}
|
|
|
|
/*
|
|
The trouble is that key can be split in two parts:
|
|
The first part (prefix) is in from .. from_end - 1.
|
|
The second part starts at page.
|
|
The split can be at every byte position. So we need to check for
|
|
the end of the first part before using every byte.
|
|
*/
|
|
for (keyseg = keyinfo->seg; keyseg->type; keyseg++) {
|
|
if (keyseg->flag & HA_NULL_PART) {
|
|
/* If prefix is used up, switch to rest. */
|
|
if (from == from_end) {
|
|
from = page;
|
|
from_end = page_end;
|
|
}
|
|
if (!(*key++ = *from++)) continue; /* Null part */
|
|
}
|
|
if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK)) {
|
|
/* If prefix is used up, switch to rest. */
|
|
if (from == from_end) {
|
|
from = page;
|
|
from_end = page_end;
|
|
}
|
|
/* Get length of dynamic length key part */
|
|
if ((length = (*key++ = *from++)) == 255) {
|
|
/* If prefix is used up, switch to rest. */
|
|
if (from == from_end) {
|
|
from = page;
|
|
from_end = page_end;
|
|
}
|
|
length = (uint)((*key++ = *from++)) << 8;
|
|
/* If prefix is used up, switch to rest. */
|
|
if (from == from_end) {
|
|
from = page;
|
|
from_end = page_end;
|
|
}
|
|
length += (uint)((*key++ = *from++));
|
|
}
|
|
if (length > keyseg->length) goto crashed;
|
|
} else
|
|
length = keyseg->length;
|
|
|
|
if ((tmp = (uint)(from_end - from)) <= length) {
|
|
key += tmp; /* Use old key */
|
|
length -= tmp;
|
|
from = page;
|
|
from_end = page_end;
|
|
}
|
|
DBUG_PRINT("info", ("key: %p from: %p length: %u", key, from, length));
|
|
memmove((uchar *)key, (uchar *)from, (size_t)length);
|
|
key += length;
|
|
from += length;
|
|
}
|
|
/*
|
|
Last segment (type == 0) contains length of data pointer.
|
|
If we have mixed key blocks with data pointer and key block pointer,
|
|
we have to copy both.
|
|
*/
|
|
length = keyseg->length + nod_flag;
|
|
if ((tmp = (uint)(from_end - from)) <= length) {
|
|
/* Remaining length is less or equal max possible length. */
|
|
memcpy(key + tmp, page, length - tmp); /* Get last part of key */
|
|
*page_pos = page + length - tmp;
|
|
} else {
|
|
/*
|
|
Remaining length is greater than max possible length.
|
|
This can happen only if we switched to the new key bytes already.
|
|
'page_end' is calculated with MI_MAX_KEY_BUFF. So it can be far
|
|
behind the real end of the key.
|
|
*/
|
|
if (from_end != page_end) {
|
|
DBUG_PRINT("error", ("Error when unpacking key"));
|
|
goto crashed; /* Error */
|
|
}
|
|
/* Copy data pointer and, if appropriate, key block pointer. */
|
|
memcpy((uchar *)key, (uchar *)from, (size_t)length);
|
|
*page_pos = from + length;
|
|
}
|
|
return (uint)(key - start_key) + keyseg->length;
|
|
|
|
crashed:
|
|
mi_print_error(keyinfo->share, HA_ERR_CRASHED);
|
|
set_my_errno(HA_ERR_CRASHED);
|
|
return 0;
|
|
}
|
|
|
|
/* Get key at position without knowledge of previous key */
|
|
/* Returns pointer to next key */
|
|
|
|
uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key,
|
|
uchar *keypos, uint *return_key_length) {
|
|
uint nod_flag;
|
|
DBUG_TRACE;
|
|
|
|
nod_flag = mi_test_if_nod(page);
|
|
if (!(keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY))) {
|
|
memmove((uchar *)key, (uchar *)keypos, keyinfo->keylength + nod_flag);
|
|
return keypos + keyinfo->keylength + nod_flag;
|
|
} else {
|
|
page += 2 + nod_flag;
|
|
key[0] = 0; /* safety */
|
|
while (page <= keypos) {
|
|
*return_key_length = (*keyinfo->get_key)(keyinfo, nod_flag, &page, key);
|
|
if (*return_key_length == 0) {
|
|
mi_print_error(info->s, HA_ERR_CRASHED);
|
|
set_my_errno(HA_ERR_CRASHED);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
DBUG_PRINT("exit", ("page: %p length: %u", page, *return_key_length));
|
|
return page;
|
|
} /* _mi_get_key */
|
|
|
|
/* Get key at position without knowledge of previous key */
|
|
/* Returns 0 if ok */
|
|
|
|
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
|
|
uchar *key, uchar *keypos,
|
|
uint *return_key_length) {
|
|
uint nod_flag;
|
|
DBUG_TRACE;
|
|
|
|
nod_flag = mi_test_if_nod(page);
|
|
if (!(keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY))) {
|
|
*return_key_length = keyinfo->keylength;
|
|
memmove((uchar *)key, (uchar *)keypos - *return_key_length - nod_flag,
|
|
*return_key_length);
|
|
return 0;
|
|
} else {
|
|
page += 2 + nod_flag;
|
|
key[0] = 0; /* safety */
|
|
while (page < keypos) {
|
|
*return_key_length = (*keyinfo->get_key)(keyinfo, nod_flag, &page, key);
|
|
if (*return_key_length == 0) {
|
|
mi_print_error(info->s, HA_ERR_CRASHED);
|
|
set_my_errno(HA_ERR_CRASHED);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
} /* _mi_get_key */
|
|
|
|
/* Get last key from key-page */
|
|
/* Return pointer to where key starts */
|
|
|
|
uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
|
|
uchar *lastkey, uchar *endpos,
|
|
uint *return_key_length) {
|
|
uint nod_flag;
|
|
uchar *lastpos;
|
|
DBUG_TRACE;
|
|
DBUG_PRINT("enter", ("page: %p endpos: %p", page, endpos));
|
|
|
|
nod_flag = mi_test_if_nod(page);
|
|
if (!(keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY))) {
|
|
lastpos = endpos - keyinfo->keylength - nod_flag;
|
|
*return_key_length = keyinfo->keylength;
|
|
if (lastpos > page)
|
|
memmove((uchar *)lastkey, (uchar *)lastpos,
|
|
keyinfo->keylength + nod_flag);
|
|
} else {
|
|
lastpos = (page += 2 + nod_flag);
|
|
lastkey[0] = 0;
|
|
while (page < endpos) {
|
|
lastpos = page;
|
|
*return_key_length =
|
|
(*keyinfo->get_key)(keyinfo, nod_flag, &page, lastkey);
|
|
if (*return_key_length == 0) {
|
|
DBUG_PRINT("error", ("Couldn't find last key: page: %p", page));
|
|
mi_print_error(info->s, HA_ERR_CRASHED);
|
|
set_my_errno(HA_ERR_CRASHED);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
DBUG_PRINT("exit", ("lastpos: %p length: %u", lastpos, *return_key_length));
|
|
return lastpos;
|
|
} /* _mi_get_last_key */
|
|
|
|
/* Calculate length of key */
|
|
|
|
uint _mi_keylength(MI_KEYDEF *keyinfo, const uchar *key) {
|
|
HA_KEYSEG *keyseg;
|
|
const uchar *start;
|
|
|
|
if (!(keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
|
|
return (keyinfo->keylength);
|
|
|
|
start = key;
|
|
for (keyseg = keyinfo->seg; keyseg->type; keyseg++) {
|
|
if (keyseg->flag & HA_NULL_PART)
|
|
if (!*key++) continue;
|
|
if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART)) {
|
|
uint length = get_key_length(&key);
|
|
key += length;
|
|
} else
|
|
key += keyseg->length;
|
|
}
|
|
return ((uint)(key - start) + keyseg->length);
|
|
} /* _mi_keylength */
|
|
|
|
/*
|
|
Calculate length of part key.
|
|
|
|
Used in mi_rkey() to find the key found for the key-part that was used.
|
|
This is needed in case of multi-byte character sets where we may search
|
|
after '0xDF' but find 'ss'
|
|
*/
|
|
|
|
uint _mi_keylength_part(MI_KEYDEF *keyinfo, const uchar *key, HA_KEYSEG *end) {
|
|
HA_KEYSEG *keyseg;
|
|
const uchar *start = key;
|
|
|
|
for (keyseg = keyinfo->seg; keyseg != end; keyseg++) {
|
|
if (keyseg->flag & HA_NULL_PART)
|
|
if (!*key++) continue;
|
|
if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART)) {
|
|
uint length = get_key_length(&key);
|
|
key += length;
|
|
} else
|
|
key += keyseg->length;
|
|
}
|
|
return (uint)(key - start);
|
|
}
|
|
|
|
/* Move a key */
|
|
|
|
uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, const uchar *from) {
|
|
size_t length = _mi_keylength(keyinfo, from);
|
|
memcpy(to, from, length);
|
|
return to + length;
|
|
}
|
|
|
|
/* Find next/previous record with same key */
|
|
/* This can't be used when database is touched after last read */
|
|
|
|
int _mi_search_next(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
|
|
uint key_length, uint nextflag, my_off_t pos) {
|
|
int error;
|
|
uint nod_flag;
|
|
uchar lastkey[MI_MAX_KEY_BUFF];
|
|
DBUG_TRACE;
|
|
DBUG_PRINT("enter", ("nextflag: %u lastpos: %lu int_keypos: %p", nextflag,
|
|
(ulong)info->lastpos, info->int_keypos));
|
|
DBUG_EXECUTE("key", _mi_print_key(DBUG_FILE, keyinfo->seg, key, key_length););
|
|
|
|
/* Force full read if we are at last key or if we are not on a leaf
|
|
and the key tree has changed since we used it last time
|
|
Note that even if the key tree has changed since last read, we can use
|
|
the last read data from the leaf if we haven't used the buffer for
|
|
something else.
|
|
*/
|
|
|
|
if (((nextflag & SEARCH_BIGGER) && info->int_keypos >= info->int_maxpos) ||
|
|
info->page_changed ||
|
|
(info->int_keytree_version != keyinfo->version &&
|
|
(info->int_nod_flag || info->buff_used)))
|
|
return _mi_search(info, keyinfo, key, USE_WHOLE_KEY,
|
|
nextflag | SEARCH_SAVE_BUFF, pos);
|
|
|
|
if (info->buff_used) {
|
|
if (!_mi_fetch_keypage(info, keyinfo, info->last_search_keypage,
|
|
DFLT_INIT_HITS, info->buff, 0))
|
|
return -1;
|
|
info->buff_used = 0;
|
|
}
|
|
|
|
/* Last used buffer is in info->buff */
|
|
nod_flag = mi_test_if_nod(info->buff);
|
|
|
|
if (nextflag & SEARCH_BIGGER) /* Next key */
|
|
{
|
|
my_off_t tmp_pos = _mi_kpos(nod_flag, info->int_keypos);
|
|
if (tmp_pos != HA_OFFSET_ERROR) {
|
|
if ((error = _mi_search(info, keyinfo, key, USE_WHOLE_KEY,
|
|
nextflag | SEARCH_SAVE_BUFF, tmp_pos)) <= 0)
|
|
return error;
|
|
}
|
|
memcpy(lastkey, key, key_length);
|
|
if (!(info->lastkey_length = (*keyinfo->get_key)(
|
|
keyinfo, nod_flag, &info->int_keypos, lastkey)))
|
|
return -1;
|
|
} else /* Previous key */
|
|
{
|
|
uint length;
|
|
/* Find start of previous key */
|
|
info->int_keypos = _mi_get_last_key(info, keyinfo, info->buff, lastkey,
|
|
info->int_keypos, &length);
|
|
if (!info->int_keypos) return -1;
|
|
if (info->int_keypos == info->buff + 2)
|
|
return _mi_search(info, keyinfo, key, USE_WHOLE_KEY,
|
|
nextflag | SEARCH_SAVE_BUFF, pos);
|
|
if ((error = _mi_search(info, keyinfo, key, USE_WHOLE_KEY,
|
|
nextflag | SEARCH_SAVE_BUFF,
|
|
_mi_kpos(nod_flag, info->int_keypos))) <= 0)
|
|
return error;
|
|
|
|
/* QQ: We should be able to optimize away the following call */
|
|
if (!_mi_get_last_key(info, keyinfo, info->buff, lastkey, info->int_keypos,
|
|
&info->lastkey_length))
|
|
return -1;
|
|
}
|
|
memcpy(info->lastkey, lastkey, info->lastkey_length);
|
|
info->lastpos = _mi_dpos(info, 0, info->lastkey + info->lastkey_length);
|
|
DBUG_PRINT("exit", ("found key at %lu", (ulong)info->lastpos));
|
|
return 0;
|
|
} /* _mi_search_next */
|
|
|
|
/* Search after position for the first row in an index */
|
|
/* This is stored in info->lastpos */
|
|
|
|
int _mi_search_first(MI_INFO *info, MI_KEYDEF *keyinfo, my_off_t pos) {
|
|
uint nod_flag;
|
|
uchar *page;
|
|
DBUG_TRACE;
|
|
|
|
if (pos == HA_OFFSET_ERROR) {
|
|
set_my_errno(HA_ERR_KEY_NOT_FOUND);
|
|
info->lastpos = HA_OFFSET_ERROR;
|
|
return -1;
|
|
}
|
|
|
|
do {
|
|
if (!_mi_fetch_keypage(info, keyinfo, pos, DFLT_INIT_HITS, info->buff, 0)) {
|
|
info->lastpos = HA_OFFSET_ERROR;
|
|
return -1;
|
|
}
|
|
nod_flag = mi_test_if_nod(info->buff);
|
|
page = info->buff + 2 + nod_flag;
|
|
} while ((pos = _mi_kpos(nod_flag, page)) != HA_OFFSET_ERROR);
|
|
|
|
if (!(info->lastkey_length =
|
|
(*keyinfo->get_key)(keyinfo, nod_flag, &page, info->lastkey)))
|
|
return -1; /* Crashed */
|
|
|
|
info->int_keypos = page;
|
|
info->int_maxpos = info->buff + mi_getint(info->buff) - 1;
|
|
info->int_nod_flag = nod_flag;
|
|
info->int_keytree_version = keyinfo->version;
|
|
info->last_search_keypage = info->last_keypage;
|
|
info->page_changed = info->buff_used = 0;
|
|
info->lastpos = _mi_dpos(info, 0, info->lastkey + info->lastkey_length);
|
|
|
|
DBUG_PRINT("exit", ("found key at %lu", (ulong)info->lastpos));
|
|
return 0;
|
|
} /* _mi_search_first */
|
|
|
|
/* Search after position for the last row in an index */
|
|
/* This is stored in info->lastpos */
|
|
|
|
int _mi_search_last(MI_INFO *info, MI_KEYDEF *keyinfo, my_off_t pos) {
|
|
uint nod_flag;
|
|
uchar *buff, *page;
|
|
DBUG_TRACE;
|
|
|
|
if (pos == HA_OFFSET_ERROR) {
|
|
set_my_errno(HA_ERR_KEY_NOT_FOUND); /* Didn't find key */
|
|
info->lastpos = HA_OFFSET_ERROR;
|
|
return -1;
|
|
}
|
|
|
|
buff = info->buff;
|
|
do {
|
|
if (!_mi_fetch_keypage(info, keyinfo, pos, DFLT_INIT_HITS, buff, 0)) {
|
|
info->lastpos = HA_OFFSET_ERROR;
|
|
return -1;
|
|
}
|
|
page = buff + mi_getint(buff);
|
|
nod_flag = mi_test_if_nod(buff);
|
|
} while ((pos = _mi_kpos(nod_flag, page)) != HA_OFFSET_ERROR);
|
|
|
|
if (!_mi_get_last_key(info, keyinfo, buff, info->lastkey, page,
|
|
&info->lastkey_length))
|
|
return -1;
|
|
info->lastpos = _mi_dpos(info, 0, info->lastkey + info->lastkey_length);
|
|
info->int_keypos = info->int_maxpos = page;
|
|
info->int_nod_flag = nod_flag;
|
|
info->int_keytree_version = keyinfo->version;
|
|
info->last_search_keypage = info->last_keypage;
|
|
info->page_changed = info->buff_used = 0;
|
|
|
|
DBUG_PRINT("exit", ("found key at %lu", (ulong)info->lastpos));
|
|
return 0;
|
|
} /* _mi_search_last */
|
|
|
|
/****************************************************************************
|
|
**
|
|
** Functions to store and pack a key in a page
|
|
**
|
|
** mi_calc_xx_key_length takes the following arguments:
|
|
** nod_flag If nod: Length of nod-pointer
|
|
** next_key Position to pos after the new key in buffer
|
|
** org_key Key that was before the next key in buffer
|
|
** prev_key Last key before current key
|
|
** key Key that will be stored
|
|
** s_temp Information how next key will be packed
|
|
****************************************************************************/
|
|
|
|
/* Static length key */
|
|
|
|
int _mi_calc_static_key_length(MI_KEYDEF *keyinfo, uint nod_flag,
|
|
const uchar *next_pos MY_ATTRIBUTE((unused)),
|
|
uchar *org_key MY_ATTRIBUTE((unused)),
|
|
uchar *prev_key MY_ATTRIBUTE((unused)),
|
|
const uchar *key, MI_KEY_PARAM *s_temp) {
|
|
s_temp->key = key;
|
|
return (int)(s_temp->totlength = keyinfo->keylength + nod_flag);
|
|
}
|
|
|
|
/* Variable length key */
|
|
|
|
int _mi_calc_var_key_length(MI_KEYDEF *keyinfo, uint nod_flag,
|
|
const uchar *next_pos MY_ATTRIBUTE((unused)),
|
|
uchar *org_key MY_ATTRIBUTE((unused)),
|
|
uchar *prev_key MY_ATTRIBUTE((unused)),
|
|
const uchar *key, MI_KEY_PARAM *s_temp) {
|
|
s_temp->key = key;
|
|
return (int)(s_temp->totlength = _mi_keylength(keyinfo, key) + nod_flag);
|
|
}
|
|
|
|
/*
|
|
length of key with a variable length first segment which is prefix
|
|
compressed (myisamchk reports 'packed + stripped')
|
|
|
|
Keys are compressed the following way:
|
|
|
|
If the max length of first key segment <= 127 bytes the prefix is
|
|
1 byte else it's 2 byte
|
|
|
|
prefix byte(s) The high bit is set if this is a prefix for the prev key
|
|
length Packed length if the previous was a prefix byte
|
|
[length] data bytes ('length' bytes)
|
|
next-key-seg Next key segments
|
|
|
|
If the first segment can have NULL:
|
|
The length is 0 for NULLS and 1+length for not null columns.
|
|
|
|
*/
|
|
|
|
int _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo, uint nod_flag,
|
|
const uchar *next_key, uchar *org_key,
|
|
uchar *prev_key, const uchar *key,
|
|
MI_KEY_PARAM *s_temp) {
|
|
HA_KEYSEG *keyseg;
|
|
int length;
|
|
uint key_length, ref_length, org_key_length = 0, length_pack, new_key_length,
|
|
diff_flag, pack_marker;
|
|
const uchar *start, *end, *key_end;
|
|
const uchar *sort_order;
|
|
bool same_length;
|
|
|
|
length_pack = s_temp->ref_length = s_temp->n_ref_length = s_temp->n_length =
|
|
0;
|
|
same_length = 0;
|
|
keyseg = keyinfo->seg;
|
|
key_length = _mi_keylength(keyinfo, key) + nod_flag;
|
|
|
|
sort_order = 0;
|
|
if ((keyinfo->flag & HA_FULLTEXT) &&
|
|
((keyseg->type == HA_KEYTYPE_TEXT) ||
|
|
(keyseg->type == HA_KEYTYPE_VARTEXT1) ||
|
|
(keyseg->type == HA_KEYTYPE_VARTEXT2)) &&
|
|
!use_strnxfrm(keyseg->charset))
|
|
sort_order = keyseg->charset->sort_order;
|
|
|
|
/* diff flag contains how many bytes is needed to pack key */
|
|
if (keyseg->length >= 127) {
|
|
diff_flag = 2;
|
|
pack_marker = 32768;
|
|
} else {
|
|
diff_flag = 1;
|
|
pack_marker = 128;
|
|
}
|
|
s_temp->pack_marker = pack_marker;
|
|
|
|
/* Handle the case that the first part have NULL values */
|
|
if (keyseg->flag & HA_NULL_PART) {
|
|
if (!*key++) {
|
|
s_temp->key = key;
|
|
s_temp->key_length = 0;
|
|
s_temp->totlength = key_length - 1 + diff_flag;
|
|
s_temp->next_key_pos = 0; /* No next key */
|
|
return (s_temp->totlength);
|
|
}
|
|
s_temp->store_not_null = 1;
|
|
key_length--; /* We don't store NULL */
|
|
if (prev_key && !*prev_key++)
|
|
org_key = prev_key = 0; /* Can't pack against prev */
|
|
else if (org_key)
|
|
org_key++; /* Skip NULL */
|
|
} else
|
|
s_temp->store_not_null = 0;
|
|
s_temp->prev_key = org_key;
|
|
|
|
/* The key part will start with a packed length */
|
|
|
|
new_key_length = get_key_pack_length(&key, &length_pack);
|
|
end = key_end = key + new_key_length;
|
|
start = key;
|
|
|
|
/* Calc how many characters are identical between this and the prev. key */
|
|
if (prev_key) {
|
|
org_key_length = get_key_length(pointer_cast<const uchar **>(&prev_key));
|
|
s_temp->prev_key = prev_key; /* Pointer at data */
|
|
/* Don't use key-pack if length == 0 */
|
|
if (new_key_length && new_key_length == org_key_length)
|
|
same_length = 1;
|
|
else if (new_key_length > org_key_length)
|
|
end = key + org_key_length;
|
|
|
|
if (sort_order) /* SerG */
|
|
{
|
|
while (key < end && sort_order[*key] == sort_order[*prev_key]) {
|
|
key++;
|
|
prev_key++;
|
|
}
|
|
} else {
|
|
while (key < end && *key == *prev_key) {
|
|
key++;
|
|
prev_key++;
|
|
}
|
|
}
|
|
}
|
|
|
|
s_temp->key = key;
|
|
s_temp->key_length = (uint)(key_end - key);
|
|
|
|
if (same_length && key == key_end) {
|
|
/* identical variable length key */
|
|
s_temp->ref_length = pack_marker;
|
|
length = (int)key_length - (int)(key_end - start) - length_pack;
|
|
length += diff_flag;
|
|
if (next_key) { /* Can't combine with next */
|
|
s_temp->n_length = *next_key; /* Needed by _mi_store_key */
|
|
next_key = 0;
|
|
}
|
|
} else {
|
|
if (start != key) { /* Starts as prev key */
|
|
ref_length = (uint)(key - start);
|
|
s_temp->ref_length = ref_length + pack_marker;
|
|
length = (int)(key_length - ref_length);
|
|
|
|
length -= length_pack;
|
|
length += diff_flag;
|
|
length +=
|
|
((new_key_length - ref_length) >= 255) ? 3 : 1; /* Rest_of_key */
|
|
} else {
|
|
s_temp->key_length += s_temp->store_not_null; /* If null */
|
|
length = key_length - length_pack + diff_flag;
|
|
}
|
|
}
|
|
s_temp->totlength = (uint)length;
|
|
s_temp->prev_length = 0;
|
|
DBUG_PRINT("test", ("tot_length: %u length: %d uniq_key_length: %u",
|
|
key_length, length, s_temp->key_length));
|
|
|
|
/* If something after that hasn't length=0, test if we can combine */
|
|
if ((s_temp->next_key_pos = const_cast<uchar *>(next_key))) {
|
|
uint packed, n_length;
|
|
|
|
packed = *next_key & 128;
|
|
if (diff_flag == 2) {
|
|
n_length = mi_uint2korr(next_key) & 32767; /* Length of next key */
|
|
next_key += 2;
|
|
} else
|
|
n_length = *next_key++ & 127;
|
|
if (!packed) n_length -= s_temp->store_not_null;
|
|
|
|
if (n_length || packed) /* Don't pack 0 length keys */
|
|
{
|
|
uint next_length_pack, new_ref_length = s_temp->ref_length;
|
|
|
|
if (packed) {
|
|
/* If first key and next key is packed (only on delete) */
|
|
if (!prev_key && org_key) {
|
|
org_key_length =
|
|
get_key_length(pointer_cast<const uchar **>(&org_key));
|
|
key = start;
|
|
if (sort_order) /* SerG */
|
|
{
|
|
while (key < end && sort_order[*key] == sort_order[*org_key]) {
|
|
key++;
|
|
org_key++;
|
|
}
|
|
} else {
|
|
while (key < end && *key == *org_key) {
|
|
key++;
|
|
org_key++;
|
|
}
|
|
}
|
|
if ((new_ref_length = (uint)(key - start)))
|
|
new_ref_length += pack_marker;
|
|
}
|
|
|
|
if (!n_length) {
|
|
/*
|
|
We put a different key between two identical variable length keys
|
|
Extend next key to have same prefix as this key
|
|
*/
|
|
if (new_ref_length) /* prefix of previus key */
|
|
{ /* make next key longer */
|
|
s_temp->part_of_prev_key = new_ref_length;
|
|
s_temp->prev_length =
|
|
org_key_length - (new_ref_length - pack_marker);
|
|
s_temp->n_ref_length = s_temp->part_of_prev_key;
|
|
s_temp->n_length = s_temp->prev_length;
|
|
n_length = get_pack_length(s_temp->prev_length);
|
|
s_temp->prev_key += (new_ref_length - pack_marker);
|
|
length += s_temp->prev_length + n_length;
|
|
} else { /* Can't use prev key */
|
|
s_temp->part_of_prev_key = 0;
|
|
s_temp->prev_length = org_key_length;
|
|
s_temp->n_ref_length = s_temp->n_length = org_key_length;
|
|
length += org_key_length;
|
|
}
|
|
return (int)length;
|
|
}
|
|
|
|
ref_length = n_length;
|
|
/* Get information about not packed key suffix */
|
|
n_length = get_key_pack_length(&next_key, &next_length_pack);
|
|
|
|
/* Test if new keys has fewer characters that match the previous key */
|
|
if (!new_ref_length) { /* Can't use prev key */
|
|
s_temp->part_of_prev_key = 0;
|
|
s_temp->prev_length = ref_length;
|
|
s_temp->n_ref_length = s_temp->n_length = n_length + ref_length;
|
|
return (int)length + ref_length - next_length_pack;
|
|
}
|
|
if (ref_length + pack_marker > new_ref_length) {
|
|
uint new_pack_length = new_ref_length - pack_marker;
|
|
/* We must copy characters from the original key to the next key */
|
|
s_temp->part_of_prev_key = new_ref_length;
|
|
s_temp->prev_length = ref_length - new_pack_length;
|
|
s_temp->n_ref_length = s_temp->n_length =
|
|
n_length + s_temp->prev_length;
|
|
s_temp->prev_key += new_pack_length;
|
|
length -= (next_length_pack - get_pack_length(s_temp->n_length));
|
|
return (int)length + s_temp->prev_length;
|
|
}
|
|
} else {
|
|
/* Next key wasn't a prefix of previous key */
|
|
ref_length = 0;
|
|
next_length_pack = 0;
|
|
}
|
|
DBUG_PRINT("test", ("length: %d next_key: %p", length, next_key));
|
|
|
|
{
|
|
uint tmp_length;
|
|
key = (start += ref_length);
|
|
if (key + n_length < key_end) /* Normalize length based */
|
|
key_end = key + n_length;
|
|
if (sort_order) /* SerG */
|
|
{
|
|
while (key < key_end && sort_order[*key] == sort_order[*next_key]) {
|
|
key++;
|
|
next_key++;
|
|
}
|
|
} else {
|
|
while (key < key_end && *key == *next_key) {
|
|
key++;
|
|
next_key++;
|
|
}
|
|
}
|
|
if (!(tmp_length = (uint)(key - start))) { /* Key can't be re-packed */
|
|
s_temp->next_key_pos = 0;
|
|
return length;
|
|
}
|
|
ref_length += tmp_length;
|
|
n_length -= tmp_length;
|
|
length -= tmp_length + next_length_pack; /* We gained these chars */
|
|
}
|
|
if (n_length == 0 && ref_length == new_key_length) {
|
|
s_temp->n_ref_length = pack_marker; /* Same as prev key */
|
|
} else {
|
|
s_temp->n_ref_length = ref_length | pack_marker;
|
|
length += get_pack_length(n_length);
|
|
s_temp->n_length = n_length;
|
|
}
|
|
}
|
|
}
|
|
return length;
|
|
}
|
|
|
|
/* Length of key which is prefix compressed */
|
|
|
|
int _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo, uint nod_flag,
|
|
const uchar *next_key, uchar *org_key,
|
|
uchar *prev_key, const uchar *key,
|
|
MI_KEY_PARAM *s_temp) {
|
|
uint length, key_length, ref_length;
|
|
|
|
s_temp->totlength = key_length = _mi_keylength(keyinfo, key) + nod_flag;
|
|
s_temp->key = key;
|
|
s_temp->prev_key = org_key;
|
|
if (prev_key) /* If not first key in block */
|
|
{
|
|
/* pack key against previous key */
|
|
/*
|
|
As keys may be identical when running a sort in myisamchk, we
|
|
have to guard against the case where keys may be identical
|
|
*/
|
|
const uchar *end;
|
|
end = key + key_length;
|
|
for (; *key == *prev_key && key < end; key++, prev_key++)
|
|
;
|
|
s_temp->ref_length = ref_length = (uint)(key - s_temp->key);
|
|
length = key_length - ref_length + get_pack_length(ref_length);
|
|
} else {
|
|
/* No previous key */
|
|
s_temp->ref_length = ref_length = 0;
|
|
length = key_length + 1;
|
|
}
|
|
if ((s_temp->next_key_pos =
|
|
const_cast<uchar *>(next_key))) /* If another key after */
|
|
{
|
|
/* pack key against next key */
|
|
uint next_length_pack;
|
|
uint next_length = get_key_pack_length(&next_key, &next_length_pack);
|
|
|
|
/* If first key and next key is packed (only on delete) */
|
|
if (!prev_key && org_key && next_length) {
|
|
const uchar *end;
|
|
for (key = s_temp->key, end = key + next_length;
|
|
*key == *org_key && key < end; key++, org_key++)
|
|
;
|
|
ref_length = (uint)(key - s_temp->key);
|
|
}
|
|
|
|
if (next_length > ref_length) {
|
|
/* We put a key with different case between two keys with the same prefix
|
|
Extend next key to have same prefix as
|
|
this key */
|
|
s_temp->n_ref_length = ref_length;
|
|
s_temp->prev_length = next_length - ref_length;
|
|
s_temp->prev_key += ref_length;
|
|
return (int)(length + s_temp->prev_length - next_length_pack +
|
|
get_pack_length(ref_length));
|
|
}
|
|
/* Check how many characters are identical to next key */
|
|
key = s_temp->key + next_length;
|
|
while (*key++ == *next_key++)
|
|
;
|
|
if ((ref_length = (uint)(key - s_temp->key) - 1) == next_length) {
|
|
s_temp->next_key_pos = 0;
|
|
return length; /* can't pack next key */
|
|
}
|
|
s_temp->prev_length = 0;
|
|
s_temp->n_ref_length = ref_length;
|
|
return (int)(length - (ref_length - next_length) - next_length_pack +
|
|
get_pack_length(ref_length));
|
|
}
|
|
return (int)length;
|
|
}
|
|
|
|
/*
|
|
** store a key packed with _mi_calc_xxx_key_length in page-buffert
|
|
*/
|
|
|
|
/* store key without compression */
|
|
|
|
void _mi_store_static_key(MI_KEYDEF *keyinfo MY_ATTRIBUTE((unused)),
|
|
uchar *key_pos, MI_KEY_PARAM *s_temp) {
|
|
memcpy(key_pos, s_temp->key, (size_t)s_temp->totlength);
|
|
}
|
|
|
|
/* store variable length key with prefix compression */
|
|
|
|
#define store_pack_length(test, pos, length) \
|
|
{ \
|
|
if (test) { \
|
|
*((pos)++) = (uchar)(length); \
|
|
} else { \
|
|
*((pos)++) = (uchar)((length) >> 8); \
|
|
*((pos)++) = (uchar)(length); \
|
|
} \
|
|
}
|
|
|
|
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo MY_ATTRIBUTE((unused)),
|
|
uchar *key_pos, MI_KEY_PARAM *s_temp) {
|
|
uint length;
|
|
uchar *start;
|
|
|
|
start = key_pos;
|
|
|
|
if (s_temp->ref_length) {
|
|
/* Packed against previous key */
|
|
store_pack_length(s_temp->pack_marker == 128, key_pos, s_temp->ref_length);
|
|
/* If not same key after */
|
|
if (s_temp->ref_length != s_temp->pack_marker)
|
|
store_key_length_inc(key_pos, s_temp->key_length);
|
|
} else {
|
|
/* Not packed against previous key */
|
|
store_pack_length(s_temp->pack_marker == 128, key_pos, s_temp->key_length);
|
|
}
|
|
memmove(key_pos, s_temp->key,
|
|
(length = s_temp->totlength - (uint)(key_pos - start)));
|
|
|
|
if (!s_temp->next_key_pos) /* No following key */
|
|
return;
|
|
key_pos += length;
|
|
|
|
if (s_temp->prev_length) {
|
|
/* Extend next key because new key didn't have same prefix as prev key */
|
|
if (s_temp->part_of_prev_key) {
|
|
store_pack_length(s_temp->pack_marker == 128, key_pos,
|
|
s_temp->part_of_prev_key);
|
|
store_key_length_inc(key_pos, s_temp->n_length);
|
|
} else {
|
|
s_temp->n_length += s_temp->store_not_null;
|
|
store_pack_length(s_temp->pack_marker == 128, key_pos, s_temp->n_length);
|
|
}
|
|
memcpy(key_pos, s_temp->prev_key, s_temp->prev_length);
|
|
} else if (s_temp->n_ref_length) {
|
|
store_pack_length(s_temp->pack_marker == 128, key_pos,
|
|
s_temp->n_ref_length);
|
|
if (s_temp->n_ref_length == s_temp->pack_marker) return; /* Identical key */
|
|
store_key_length(key_pos, s_temp->n_length);
|
|
} else {
|
|
s_temp->n_length += s_temp->store_not_null;
|
|
store_pack_length(s_temp->pack_marker == 128, key_pos, s_temp->n_length);
|
|
}
|
|
}
|
|
|
|
/* variable length key with prefix compression */
|
|
|
|
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo MY_ATTRIBUTE((unused)),
|
|
uchar *key_pos, MI_KEY_PARAM *s_temp) {
|
|
store_key_length_inc(key_pos, s_temp->ref_length);
|
|
memcpy((char *)key_pos,
|
|
pointer_cast<const char *>(s_temp->key) + s_temp->ref_length,
|
|
(size_t)s_temp->totlength - s_temp->ref_length);
|
|
|
|
if (s_temp->next_key_pos) {
|
|
key_pos += (uint)(s_temp->totlength - s_temp->ref_length);
|
|
store_key_length_inc(key_pos, s_temp->n_ref_length);
|
|
if (s_temp->prev_length) /* If we must extend key */
|
|
{
|
|
memcpy(key_pos, s_temp->prev_key, s_temp->prev_length);
|
|
}
|
|
}
|
|
}
|