mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-16 20:12:31 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/storage/maria/ma_rt_index.c
unknown f094eff1d9 Injecting more "const" declarations into code which does not change 
pointed data.
I ran gcc -Wcast-qual on storage/maria, this identified un-needed casts,
a couple of functions which said they had a const parameter though
they changed the pointed content! This is fixed here. Some suspicious
places receive a comment.
The original intention of running -Wcast-qual was to find what code
changes R-tree keys: I added const words, but hidden casts
like those of int2store (casts target to (uint16*)) removed const
checking; -Wcast-qual helped find those hidden casts.
Log handler does not change the content pointed by LEX_STRING::str it
receives, so we now use a struct which has a const inside, to emphasize
this and be able to pass "const uchar*" buffers to log handler
without fear of their content being changed by it.
One-line fix for a merge glitch (when merging from MyISAM).


include/m_string.h:
  As Maria's log handler uses LEX_STRING but never changes the content
  pointed by LEX_STRING::str, and assigns uchar* into this member most
  of the time, we introduce a new struct LEX_CUSTRING
  (C const U unsigned) for the log handler.
include/my_global.h:
  In macros which read pointed content: use const pointers so that
  gcc -Wcast-qual does not warn about casting a const pointer to non-const.
include/my_handler.h:
  In macros which read pointed content: use const pointers so that
  gcc -Wcast-qual does not warn about casting a const pointer to non-const.
  ha_find_null() does not change *a.
include/my_sys.h:
  insert_dynamic() does not change *element.
include/myisampack.h:
  In macros which read pointed content: use const pointers so that
  gcc -Wcast-qual does not warn about casting a const pointer to non-const.
mysys/array.c:
  insert_dynamic() does not change *element
mysys/my_handler.c:
  ha_find_null() does not change *a
storage/maria/ma_bitmap.c:
  Log handler receives const strings now
storage/maria/ma_blockrec.c:
  Log handler receives const strings now.
  _ma_apply_undo_row_delete/update() do change *header.
storage/maria/ma_blockrec.h:
  correct prototype
storage/maria/ma_check.c:
  Log handler receives const strings now. Un-needed casts
storage/maria/ma_checkpoint.c:
  Log handler receives const strings now
storage/maria/ma_checksum.c:
  unneeded cast
storage/maria/ma_commit.c:
  Log handler receives const strings now
storage/maria/ma_create.c:
  Log handler receives const strings now
storage/maria/ma_dbug.c:
  fixing warning of gcc -Wcast-qual
storage/maria/ma_delete.c:
  Log handler receives const strings now
storage/maria/ma_delete_all.c:
  Log handler receives const strings now
storage/maria/ma_delete_table.c:
  Log handler receives const strings now
storage/maria/ma_dynrec.c:
  fixing some warnings of gcc -Wcast-qual. Unneeded casts removed.
  Comment about function which lies.
storage/maria/ma_ft_parser.c:
  fix for warnings of gcc -Wcast-qual, removing unneeded casts
storage/maria/ma_ft_update.c:
  less casts, comment
storage/maria/ma_key.c:
  less casts, stay const (warnings of gcc -Wcast-qual)
storage/maria/ma_key_recover.c:
  Log handler receives const strings now
storage/maria/ma_loghandler.c:
  Log handler receives const strings now
storage/maria/ma_loghandler.h:
  Log handler receives const strings now
storage/maria/ma_loghandler_lsn.h:
  In macros which read pointed content: use const pointers so that
  gcc -Wcast-qual does not warn about casting a const pointer to non-const.
storage/maria/ma_page.c:
  Log handler receives const strings now; more const
storage/maria/ma_recovery.c:
  Log handler receives const strings now
storage/maria/ma_rename.c:
  Log handler receives const strings now
storage/maria/ma_rt_index.c:
  more const, to emphasize that functions don't change pointed content.
  best_key= NULL was forgotten during merge from MyISAM a few days ago,
  was causing a Valgrind warning
storage/maria/ma_rt_index.h:
  new proto
storage/maria/ma_rt_key.c:
  more const
storage/maria/ma_rt_key.h:
  new proto
storage/maria/ma_rt_mbr.c:
  more const for functions which deserve it
storage/maria/ma_rt_mbr.h:
  new prototype
storage/maria/ma_rt_split.c:
  make const what is not changed.
storage/maria/ma_search.c:
  un-needed casts, more const
storage/maria/ma_sp_key.c:
  more const
storage/maria/ma_unique.c:
  un-needed casts.
storage/maria/ma_write.c:
  Log handler receives const strings now
storage/maria/maria_def.h:
  some more const
storage/maria/unittest/ma_test_loghandler-t.c:
  Log handler receives const strings now
storage/maria/unittest/ma_test_loghandler_first_lsn-t.c:
  Log handler receives const strings now
storage/maria/unittest/ma_test_loghandler_max_lsn-t.c:
  Log handler receives const strings now
storage/maria/unittest/ma_test_loghandler_multigroup-t.c:
  Log handler receives const strings now
storage/maria/unittest/ma_test_loghandler_multithread-t.c:
  Log handler receives const strings now
storage/maria/unittest/ma_test_loghandler_noflush-t.c:
  Log handler receives const strings now
storage/maria/unittest/ma_test_loghandler_nologs-t.c:
  Log handler receives const strings now
storage/maria/unittest/ma_test_loghandler_pagecache-t.c:
  Log handler receives const strings now
storage/maria/unittest/ma_test_loghandler_purge-t.c:
  Log handler receives const strings now
2008-04-03 15:40:25 +02:00

1211 lines
34 KiB
C
Raw Blame History

/* Copyright (C) 2006 MySQL AB & Ramil Kalimullin & 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; version 2 of the License.
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 "maria_def.h"
#include "trnman.h"
#include "ma_key_recover.h"
#ifdef HAVE_RTREE_KEYS
#include "ma_rt_index.h"
#include "ma_rt_key.h"
#include "ma_rt_mbr.h"
#define REINSERT_BUFFER_INC 10
#define PICK_BY_AREA
/*#define PICK_BY_PERIMETER*/
typedef struct st_page_level
{
uint level;
my_off_t offs;
} stPageLevel;
typedef struct st_page_list
{
ulong n_pages;
ulong m_pages;
stPageLevel *pages;
} stPageList;
/*
Find next key in r-tree according to search_flag recursively
NOTES
Used in maria_rtree_find_first() and maria_rtree_find_next()
RETURN
-1 Error
0 Found
1 Not found
*/
static int maria_rtree_find_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint search_flag,
uint nod_cmp_flag, my_off_t page, int level)
{
MARIA_SHARE *share= info->s;
uint nod_flag;
int res;
uchar *page_buf, *k, *last;
int k_len;
uint *saved_key= (uint*) (info->maria_rtree_recursion_state) + level;
if (!(page_buf= (uchar*) my_alloca((uint)keyinfo->block_length)))
{
my_errno= HA_ERR_OUT_OF_MEM;
return -1;
}
if (!_ma_fetch_keypage(info, keyinfo, page, PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, page_buf, 0, 0))
goto err1;
nod_flag= _ma_test_if_nod(share, page_buf);
k_len= keyinfo->keylength - share->base.rec_reflength;
if (info->maria_rtree_recursion_depth >= level)
{
k= page_buf + *saved_key;
}
else
{
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
}
last= rt_PAGE_END(share, page_buf);
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag))
{
if (nod_flag)
{
/* this is an internal node in the tree */
if (!(res= maria_rtree_key_cmp(keyinfo->seg,
info->first_mbr_key, k,
info->last_rkey_length, nod_cmp_flag)))
{
switch ((res= maria_rtree_find_req(info, keyinfo, search_flag,
nod_cmp_flag,
_ma_kpos(nod_flag, k),
level + 1)))
{
case 0: /* found - exit from recursion */
*saved_key= k - page_buf;
goto ok;
case 1: /* not found - continue searching */
info->maria_rtree_recursion_depth= level;
break;
default: /* error */
case -1:
goto err1;
}
}
}
else
{
/* this is a leaf */
if (!maria_rtree_key_cmp(keyinfo->seg, info->first_mbr_key,
k, info->last_rkey_length, search_flag))
{
uchar *after_key= (uchar*) rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag);
info->cur_row.lastpos= _ma_dpos(info, 0, after_key);
info->lastkey_length= k_len + share->base.rec_reflength;
memcpy(info->lastkey, k, info->lastkey_length);
info->maria_rtree_recursion_depth= level;
*saved_key= last - page_buf;
if (after_key < last)
{
info->int_keypos= info->buff;
info->int_maxpos= info->buff + (last - after_key);
memcpy(info->buff, after_key, last - after_key);
info->keyread_buff_used= 0;
}
else
{
info->keyread_buff_used= 1;
}
res= 0;
goto ok;
}
}
}
info->cur_row.lastpos= HA_OFFSET_ERROR;
my_errno= HA_ERR_KEY_NOT_FOUND;
res= 1;
ok:
my_afree((uchar*)page_buf);
return res;
err1:
my_afree((uchar*)page_buf);
info->cur_row.lastpos= HA_OFFSET_ERROR;
return -1;
}
/*
Find first key in r-tree according to search_flag condition
SYNOPSIS
maria_rtree_find_first()
info Handler to MARIA file
uint keynr Key number to use
key Key to search for
key_length Length of 'key'
search_flag Bitmap of flags how to do the search
RETURN
-1 Error
0 Found
1 Not found
*/
int maria_rtree_find_first(MARIA_HA *info, uint keynr, uchar *key,
uint key_length, uint search_flag)
{
my_off_t root;
uint nod_cmp_flag;
MARIA_KEYDEF *keyinfo= info->s->keyinfo + keynr;
if ((root= info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
/*
Save searched key, include data pointer.
The data pointer is required if the search_flag contains MBR_DATA.
(minimum bounding rectangle)
*/
memcpy(info->first_mbr_key, key, keyinfo->keylength);
info->last_rkey_length= key_length;
info->maria_rtree_recursion_depth= -1;
info->keyread_buff_used= 1;
nod_cmp_flag= ((search_flag & (MBR_EQUAL | MBR_WITHIN)) ?
MBR_WITHIN : MBR_INTERSECT);
return maria_rtree_find_req(info, keyinfo, search_flag, nod_cmp_flag, root,
0);
}
/*
Find next key in r-tree according to search_flag condition
SYNOPSIS
maria_rtree_find_next()
info Handler to MARIA file
uint keynr Key number to use
search_flag Bitmap of flags how to do the search
RETURN
-1 Error
0 Found
1 Not found
*/
int maria_rtree_find_next(MARIA_HA *info, uint keynr, uint search_flag)
{
my_off_t root;
uint nod_cmp_flag;
MARIA_KEYDEF *keyinfo= info->s->keyinfo + keynr;
if (info->update & HA_STATE_DELETED)
return maria_rtree_find_first(info, keynr, info->lastkey,
info->lastkey_length,
search_flag);
if (!info->keyread_buff_used)
{
uchar *key= info->int_keypos;
while (key < info->int_maxpos)
{
if (!maria_rtree_key_cmp(keyinfo->seg,
info->first_mbr_key, key,
info->last_rkey_length, search_flag))
{
uchar *after_key= key + keyinfo->keylength;
info->cur_row.lastpos= _ma_dpos(info, 0, after_key);
memcpy(info->lastkey, key, info->lastkey_length);
if (after_key < info->int_maxpos)
info->int_keypos= after_key;
else
info->keyread_buff_used= 1;
return 0;
}
key+= keyinfo->keylength;
}
}
if ((root= info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
nod_cmp_flag= ((search_flag & (MBR_EQUAL | MBR_WITHIN)) ?
MBR_WITHIN : MBR_INTERSECT);
return maria_rtree_find_req(info, keyinfo, search_flag, nod_cmp_flag, root, 0);
}
/*
Get next key in r-tree recursively
NOTES
Used in maria_rtree_get_first() and maria_rtree_get_next()
RETURN
-1 Error
0 Found
1 Not found
*/
static int maria_rtree_get_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint key_length, my_off_t page, int level)
{
MARIA_SHARE *share= info->s;
uchar *page_buf, *last, *k;
uint nod_flag, k_len;
int res;
uint *saved_key= (uint*) (info->maria_rtree_recursion_state) + level;
if (!(page_buf= (uchar*) my_alloca((uint)keyinfo->block_length)))
return -1;
if (!_ma_fetch_keypage(info, keyinfo, page, PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, page_buf, 0, 0))
goto err1;
nod_flag= _ma_test_if_nod(share, page_buf);
k_len= keyinfo->keylength - share->base.rec_reflength;
if(info->maria_rtree_recursion_depth >= level)
{
k= page_buf + *saved_key;
if (!nod_flag)
{
/* Only leaf pages contain data references. */
/* Need to check next key with data reference. */
k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag);
}
}
else
{
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
}
last= rt_PAGE_END(share, page_buf);
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag))
{
if (nod_flag)
{
/* this is an internal node in the tree */
switch ((res= maria_rtree_get_req(info, keyinfo, key_length,
_ma_kpos(nod_flag, k), level + 1)))
{
case 0: /* found - exit from recursion */
*saved_key= k - page_buf;
goto ok;
case 1: /* not found - continue searching */
info->maria_rtree_recursion_depth= level;
break;
default:
case -1: /* error */
goto err1;
}
}
else
{
/* this is a leaf */
uchar *after_key= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag);
info->cur_row.lastpos= _ma_dpos(info, 0, after_key);
info->lastkey_length= k_len + share->base.rec_reflength;
memcpy(info->lastkey, k, info->lastkey_length);
info->maria_rtree_recursion_depth= level;
*saved_key= k - page_buf;
if (after_key < last)
{
info->int_keypos= (uchar*) saved_key;
memcpy(info->buff, page_buf, keyinfo->block_length);
info->int_maxpos= rt_PAGE_END(share, info->buff);
info->keyread_buff_used= 0;
}
else
{
info->keyread_buff_used= 1;
}
res= 0;
goto ok;
}
}
info->cur_row.lastpos= HA_OFFSET_ERROR;
my_errno= HA_ERR_KEY_NOT_FOUND;
res= 1;
ok:
my_afree((uchar*)page_buf);
return res;
err1:
my_afree((uchar*)page_buf);
info->cur_row.lastpos= HA_OFFSET_ERROR;
return -1;
}
/*
Get first key in r-tree
RETURN
-1 Error
0 Found
1 Not found
*/
int maria_rtree_get_first(MARIA_HA *info, uint keynr, uint key_length)
{
my_off_t root;
MARIA_KEYDEF *keyinfo= info->s->keyinfo + keynr;
if ((root= info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
info->maria_rtree_recursion_depth= -1;
info->keyread_buff_used= 1;
return maria_rtree_get_req(info, &keyinfo[keynr], key_length, root, 0);
}
/*
Get next key in r-tree
RETURN
-1 Error
0 Found
1 Not found
*/
int maria_rtree_get_next(MARIA_HA *info, uint keynr, uint key_length)
{
my_off_t root;
MARIA_KEYDEF *keyinfo= info->s->keyinfo + keynr;
if (!info->keyread_buff_used)
{
uint k_len= keyinfo->keylength - info->s->base.rec_reflength;
/* rt_PAGE_NEXT_KEY(info->int_keypos) */
uchar *key= info->buff + *(int*)info->int_keypos + k_len +
info->s->base.rec_reflength;
/* rt_PAGE_NEXT_KEY(key) */
uchar *after_key= key + k_len + info->s->base.rec_reflength;
info->cur_row.lastpos= _ma_dpos(info, 0, after_key);
info->lastkey_length= k_len + info->s->base.rec_reflength;
memcpy(info->lastkey, key, k_len + info->s->base.rec_reflength);
*(int*)info->int_keypos= key - info->buff;
if (after_key >= info->int_maxpos)
{
info->keyread_buff_used= 1;
}
return 0;
}
else
{
if ((root= info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
return maria_rtree_get_req(info, &keyinfo[keynr], key_length, root, 0);
}
}
/*
Choose non-leaf better key for insertion
*/
#ifdef PICK_BY_PERIMETER
static const uchar *maria_rtree_pick_key(const MARIA_HA *info,
const MARIA_KEYDEF *keyinfo,
const uchar *key,
uint key_length, const uchar *page_buf,
uint nod_flag)
{
double increase;
double best_incr;
double perimeter;
double best_perimeter;
uchar *best_key= NULL;
uchar *k= rt_PAGE_FIRST_KEY(page_buf, nod_flag);
uchar *last= rt_PAGE_END(info, page_buf);
LINT_INIT(best_perimeter);
LINT_INIT(best_key);
LINT_INIT(best_incr);
for (; k < last; k= rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
{
if ((increase= maria_rtree_perimeter_increase(keyinfo->seg, k, key, key_length,
&perimeter)) == -1)
return NULL;
if ((increase < best_incr)||
(increase == best_incr && perimeter < best_perimeter))
{
best_key= k;
best_perimeter= perimeter;
best_incr= increase;
}
}
return best_key;
}
#endif /*PICK_BY_PERIMETER*/
#ifdef PICK_BY_AREA
static const uchar *maria_rtree_pick_key(const MARIA_HA *info,
const MARIA_KEYDEF *keyinfo,
const uchar *key,
uint key_length, const uchar *page_buf,
uint nod_flag)
{
MARIA_SHARE *share= info->s;
double increase;
double best_incr= DBL_MAX;
double area;
double best_area;
const uchar *best_key= NULL;
const uchar *k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
const uchar *last= rt_PAGE_END(share, page_buf);
LINT_INIT(best_area);
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, key_length, nod_flag))
{
/* The following is safe as -1.0 is an exact number */
if ((increase= maria_rtree_area_increase(keyinfo->seg, k, key, key_length,
&area)) == -1.0)
return NULL;
/* The following should be safe, even if we compare doubles */
if (!best_key || increase < best_incr ||
((increase == best_incr) && (area < best_area)))
{
best_key= k;
best_area= area;
best_incr= increase;
}
}
return best_key;
}
#endif /*PICK_BY_AREA*/
/*
Go down and insert key into tree
RETURN
-1 Error
0 Child was not split
1 Child was split
*/
static int maria_rtree_insert_req(MARIA_HA *info,
const MARIA_KEYDEF *keyinfo,
const uchar *key,
uint key_length, my_off_t page,
my_off_t *new_page,
int ins_level, int level)
{
uint nod_flag;
int res;
uchar *page_buf, *k;
MARIA_PINNED_PAGE *page_link;
DBUG_ENTER("maria_rtree_insert_req");
if (!(page_buf= (uchar*) my_alloca((uint)keyinfo->block_length +
HA_MAX_KEY_BUFF)))
{
my_errno= HA_ERR_OUT_OF_MEM;
DBUG_RETURN(-1); /* purecov: inspected */
}
if (!_ma_fetch_keypage(info, keyinfo, page, PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, page_buf, 0, &page_link))
goto err1;
nod_flag= _ma_test_if_nod(info->s, page_buf);
DBUG_PRINT("rtree", ("page: %lu level: %d ins_level: %d nod_flag: %u",
(ulong) page, level, ins_level, nod_flag));
if ((ins_level == -1 && nod_flag) || /* key: go down to leaf */
(ins_level > -1 && ins_level > level)) /* branch: go down to ins_level */
{
if ((k= (uchar *)maria_rtree_pick_key(info, keyinfo, key, key_length,
page_buf, nod_flag)) == NULL)
goto err1;
/* k is now a pointer inside the page_buf buffer */
switch ((res= maria_rtree_insert_req(info, keyinfo, key, key_length,
_ma_kpos(nod_flag, k), new_page,
ins_level, level + 1)))
{
case 0: /* child was not split */
{
maria_rtree_combine_rect(keyinfo->seg, k, key, k, key_length);
page_link->changed= 1;
if (_ma_write_keypage(info, keyinfo, page,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, page_buf))
goto err1;
goto ok;
}
case 1: /* child was split */
{
uchar *new_key= page_buf + keyinfo->block_length + nod_flag;
/* set proper MBR for key */
if (maria_rtree_set_key_mbr(info, keyinfo, k, key_length,
_ma_kpos(nod_flag, k)))
goto err1;
/* add new key for new page */
_ma_kpointer(info, new_key - nod_flag, *new_page);
if (maria_rtree_set_key_mbr(info, keyinfo, new_key, key_length,
*new_page))
goto err1;
res= maria_rtree_add_key(info, keyinfo, new_key, key_length,
page_buf, new_page);
page_link->changed= 1;
if (_ma_write_keypage(info, keyinfo, page,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, page_buf))
goto err1;
goto ok;
}
default:
case -1: /* error */
{
goto err1;
}
}
}
else
{
res= maria_rtree_add_key(info, keyinfo, key, key_length, page_buf,
new_page);
page_link->changed= 1;
if (_ma_write_keypage(info, keyinfo, page, PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, page_buf))
goto err1;
}
ok:
my_afree(page_buf);
DBUG_RETURN(res);
err1:
my_afree(page_buf);
DBUG_RETURN(-1); /* purecov: inspected */
}
/*
Insert key into the tree
RETURN
-1 Error
0 Root was not split
1 Root was split
*/
int maria_rtree_insert_level(MARIA_HA *info, uint keynr,
const uchar *key,
uint key_length, int ins_level)
{
my_off_t old_root;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= share->keyinfo + keynr;
int res;
my_off_t new_page;
MARIA_PINNED_PAGE *page_link;
DBUG_ENTER("maria_rtree_insert_level");
if ((old_root= share->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
MARIA_PINNED_PAGE tmp_page_link;
page_link= &tmp_page_link;
if ((old_root= _ma_new(info, DFLT_INIT_HITS, &page_link)) ==
HA_OFFSET_ERROR)
DBUG_RETURN(-1);
info->keyread_buff_used= 1;
bzero(info->buff, share->block_size);
_ma_store_keynr(share, info->buff, keynr);
_ma_store_page_used(share, info->buff, share->keypage_header);
res= maria_rtree_add_key(info, keyinfo, key, key_length, info->buff,
NULL);
if (_ma_write_keypage(info, keyinfo, old_root,
page_link->write_lock,
DFLT_INIT_HITS, info->buff))
DBUG_RETURN(1);
share->state.key_root[keynr]= old_root;
DBUG_RETURN(res);
}
switch ((res= maria_rtree_insert_req(info, keyinfo, key, key_length,
old_root, &new_page, ins_level, 0)))
{
case 0: /* root was not split */
{
break;
}
case 1: /* root was split, grow a new root */
{
uchar *new_root_buf, *new_key;
my_off_t new_root;
uint nod_flag= share->base.key_reflength;
MARIA_PINNED_PAGE tmp_page_link;
page_link= &tmp_page_link;
DBUG_PRINT("rtree", ("root was split, grow a new root"));
if (!(new_root_buf= (uchar*) my_alloca((uint)keyinfo->block_length +
HA_MAX_KEY_BUFF)))
{
my_errno= HA_ERR_OUT_OF_MEM;
DBUG_RETURN(-1); /* purecov: inspected */
}
bzero(new_root_buf, share->block_size);
if (nod_flag)
_ma_store_keypage_flag(share, new_root_buf, KEYPAGE_FLAG_ISNOD);
_ma_store_keynr(share, new_root_buf, keynr);
_ma_store_page_used(share, new_root_buf, share->keypage_header);
if ((new_root= _ma_new(info, DFLT_INIT_HITS, &page_link)) ==
HA_OFFSET_ERROR)
goto err1;
new_key= new_root_buf + keyinfo->block_length + nod_flag;
_ma_kpointer(info, new_key - nod_flag, old_root);
if (maria_rtree_set_key_mbr(info, keyinfo, new_key, key_length,
old_root))
goto err1;
if (maria_rtree_add_key(info, keyinfo, new_key, key_length, new_root_buf,
NULL)
== -1)
goto err1;
_ma_kpointer(info, new_key - nod_flag, new_page);
if (maria_rtree_set_key_mbr(info, keyinfo, new_key, key_length,
new_page))
goto err1;
if (maria_rtree_add_key(info, keyinfo, new_key, key_length, new_root_buf,
NULL)
== -1)
goto err1;
if (_ma_write_keypage(info, keyinfo, new_root, page_link->write_lock,
DFLT_INIT_HITS, new_root_buf))
goto err1;
share->state.key_root[keynr]= new_root;
DBUG_PRINT("rtree", ("new root page: %lu level: %d nod_flag: %u",
(ulong) new_root, 0,
_ma_test_if_nod(share, new_root_buf)));
my_afree((uchar*)new_root_buf);
break;
err1:
my_afree((uchar*)new_root_buf);
DBUG_RETURN(-1); /* purecov: inspected */
}
default:
case -1: /* error */
{
break;
}
}
DBUG_RETURN(res);
}
/*
Insert key into the tree - interface function
RETURN
-1 Error
0 OK
*/
int maria_rtree_insert(MARIA_HA *info, uint keynr,
uchar *key, uint key_length)
{
int res;
DBUG_ENTER("maria_rtree_insert");
res= - (!key_length ||
(maria_rtree_insert_level(info, keynr, key, key_length, -1) == -1));
_ma_fast_unlock_key_del(info);
/** @todo RECOVERY use a real LSN */
_ma_unpin_all_pages_and_finalize_row(info, LSN_IMPOSSIBLE);
DBUG_RETURN(res);
}
/*
Fill reinsert page buffer
RETURN
-1 Error
0 OK
*/
static int maria_rtree_fill_reinsert_list(stPageList *ReinsertList, my_off_t page,
int level)
{
DBUG_ENTER("maria_rtree_fill_reinsert_list");
DBUG_PRINT("rtree", ("page: %lu level: %d", (ulong) page, level));
if (ReinsertList->n_pages == ReinsertList->m_pages)
{
ReinsertList->m_pages += REINSERT_BUFFER_INC;
if (!(ReinsertList->pages= (stPageLevel*)my_realloc((uchar*)ReinsertList->pages,
ReinsertList->m_pages * sizeof(stPageLevel), MYF(MY_ALLOW_ZERO_PTR))))
goto err1;
}
/* save page to ReinsertList */
ReinsertList->pages[ReinsertList->n_pages].offs= page;
ReinsertList->pages[ReinsertList->n_pages].level= level;
ReinsertList->n_pages++;
DBUG_RETURN(0);
err1:
DBUG_RETURN(-1); /* purecov: inspected */
}
/*
Go down and delete key from the tree
RETURN
-1 Error
0 Deleted
1 Not found
2 Empty leaf
*/
static int maria_rtree_delete_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
const uchar *key,
uint key_length, my_off_t page,
uint *page_size,
stPageList *ReinsertList, int level)
{
ulong i;
uint nod_flag;
int res;
uchar *page_buf, *last, *k;
MARIA_PINNED_PAGE *page_link;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_rtree_delete_req");
if (!(page_buf= (uchar*) my_alloca((uint)keyinfo->block_length)))
{
my_errno= HA_ERR_OUT_OF_MEM;
DBUG_RETURN(-1); /* purecov: inspected */
}
if (!_ma_fetch_keypage(info, keyinfo, page, PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, page_buf, 0, &page_link))
goto err1;
nod_flag= _ma_test_if_nod(share, page_buf);
DBUG_PRINT("rtree", ("page: %lu level: %d nod_flag: %u",
(ulong) page, level, nod_flag));
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
last= rt_PAGE_END(share, page_buf);
for (i= 0;
k < last;
k= rt_PAGE_NEXT_KEY(share, k, key_length, nod_flag), i++)
{
if (nod_flag)
{
/* not leaf */
if (!maria_rtree_key_cmp(keyinfo->seg, key, k, key_length, MBR_WITHIN))
{
switch ((res= maria_rtree_delete_req(info, keyinfo, key, key_length,
_ma_kpos(nod_flag, k), page_size, ReinsertList, level + 1)))
{
case 0: /* deleted */
{
/* test page filling */
if (*page_size + key_length >=
rt_PAGE_MIN_SIZE(keyinfo->block_length))
{
/* OK */
/* Calculate a new key value (MBR) for the shrinked block. */
if (maria_rtree_set_key_mbr(info, keyinfo, k, key_length,
_ma_kpos(nod_flag, k)))
goto err1;
page_link->changed= 1;
if (_ma_write_keypage(info, keyinfo, page,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, page_buf))
goto err1;
}
else
{
/*
Too small: delete key & add it descendant to reinsert list.
Store position and level of the block so that it can be
accessed later for inserting the remaining keys.
*/
DBUG_PRINT("rtree", ("too small. move block to reinsert list"));
if (maria_rtree_fill_reinsert_list(ReinsertList,
_ma_kpos(nod_flag, k),
level + 1))
goto err1;
/*
Delete the key that references the block. This makes the
block disappear from the index. Hence we need to insert
its remaining keys later. Note: if the block is a branch
block, we do not only remove this block, but the whole
subtree. So we need to re-insert its keys on the same
level later to reintegrate the subtrees.
*/
maria_rtree_delete_key(info, page_buf, k, key_length, nod_flag);
page_link->changed= 1;
if (_ma_write_keypage(info, keyinfo, page,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, page_buf))
goto err1;
*page_size= _ma_get_page_used(share, page_buf);
}
goto ok;
}
case 1: /* not found - continue searching */
{
break;
}
case 2: /* vacuous case: last key in the leaf */
{
maria_rtree_delete_key(info, page_buf, k, key_length, nod_flag);
page_link->changed= 1;
if (_ma_write_keypage(info, keyinfo, page,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, page_buf))
goto err1;
*page_size= _ma_get_page_used(share, page_buf);
res= 0;
goto ok;
}
default: /* error */
case -1:
{
goto err1;
}
}
}
}
else
{
/* leaf */
if (!maria_rtree_key_cmp(keyinfo->seg, key, k, key_length,
MBR_EQUAL | MBR_DATA))
{
page_link->changed= 1;
maria_rtree_delete_key(info, page_buf, k, key_length, nod_flag);
*page_size= _ma_get_page_used(share, page_buf);
if (*page_size == info->s->keypage_header)
{
/* last key in the leaf */
res= 2;
if (_ma_dispose(info, page, 0))
goto err1;
}
else
{
res= 0;
if (_ma_write_keypage(info, keyinfo, page,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, page_buf))
goto err1;
}
goto ok;
}
}
}
res= 1;
ok:
my_afree((uchar*)page_buf);
DBUG_RETURN(res);
err1:
my_afree((uchar*)page_buf);
DBUG_RETURN(-1); /* purecov: inspected */
}
/*
Delete key - interface function
RETURN
-1 Error
0 Deleted
*/
int maria_rtree_delete(MARIA_HA *info, uint keynr,
uchar *key, uint key_length)
{
MARIA_SHARE *share= info->s;
uint page_size;
stPageList ReinsertList;
my_off_t old_root;
MARIA_KEYDEF *keyinfo= info->s->keyinfo + keynr;
MARIA_PINNED_PAGE *page_link, *root_page_link;
int res;
DBUG_ENTER("maria_rtree_delete");
if ((old_root= share->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
DBUG_RETURN(-1); /* purecov: inspected */
}
DBUG_PRINT("rtree", ("starting deletion at root page: %lu",
(ulong) old_root));
ReinsertList.pages= NULL;
ReinsertList.n_pages= 0;
ReinsertList.m_pages= 0;
switch (maria_rtree_delete_req(info, keyinfo, key, key_length, old_root,
&page_size, &ReinsertList, 0)) {
case 2: /* empty */
{
share->state.key_root[keynr]= HA_OFFSET_ERROR;
res= 0;
goto err;
}
case 0: /* deleted */
{
uint nod_flag;
ulong i;
for (i= 0; i < ReinsertList.n_pages; ++i)
{
uchar *page_buf, *k, *last;
if (!(page_buf= (uchar*) my_alloca((uint)keyinfo->block_length)))
{
my_errno= HA_ERR_OUT_OF_MEM;
goto err1;
}
if (!_ma_fetch_keypage(info, keyinfo, ReinsertList.pages[i].offs,
PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, page_buf, 0, &page_link))
goto err1;
nod_flag= _ma_test_if_nod(share, page_buf);
DBUG_PRINT("rtree", ("reinserting keys from "
"page: %lu level: %d nod_flag: %u",
(ulong) ReinsertList.pages[i].offs,
ReinsertList.pages[i].level, nod_flag));
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
last= rt_PAGE_END(share, page_buf);
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, key_length, nod_flag))
{
if ((res=
maria_rtree_insert_level(info, keynr, k, key_length,
ReinsertList.pages[i].level)) == -1)
{
my_afree(page_buf);
goto err1;
}
if (res)
{
ulong j;
DBUG_PRINT("rtree", ("root has been split, adjust levels"));
for (j= i; j < ReinsertList.n_pages; j++)
{
ReinsertList.pages[j].level++;
DBUG_PRINT("rtree", ("keys from page: %lu now level: %d",
(ulong) ReinsertList.pages[i].offs,
ReinsertList.pages[i].level));
}
}
}
res= 0;
my_afree(page_buf);
page_link->changed= 1;
if (_ma_dispose(info, ReinsertList.pages[i].offs, 0))
goto err1;
}
if (ReinsertList.pages)
my_free((uchar*) ReinsertList.pages, MYF(0));
/* check for redundant root (not leaf, 1 child) and eliminate */
if ((old_root= share->state.key_root[keynr]) == HA_OFFSET_ERROR)
goto err1;
if (!_ma_fetch_keypage(info, keyinfo, old_root,
PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, info->buff, 0, &root_page_link))
goto err1;
nod_flag= _ma_test_if_nod(share, info->buff);
page_size= _ma_get_page_used(share, info->buff);
if (nod_flag && (page_size == share->keypage_header + key_length +
nod_flag))
{
my_off_t new_root= _ma_kpos(nod_flag,
rt_PAGE_FIRST_KEY(share, info->buff,
nod_flag));
root_page_link->changed= 1;
if (_ma_dispose(info, old_root, 0))
goto err1;
share->state.key_root[keynr]= new_root;
}
info->update= HA_STATE_DELETED;
res= 0;
goto err;
err1:
res= -1;
goto err; /* purecov: inspected */
}
case 1: /* not found */
{
my_errno= HA_ERR_KEY_NOT_FOUND;
res= -1;
goto err; /* purecov: inspected */
}
default:
case -1: /* error */
res= -1;
goto err; /* purecov: inspected */
}
err:
_ma_fast_unlock_key_del(info);
/** @todo RECOVERY use a real LSN */
_ma_unpin_all_pages_and_finalize_row(info, LSN_IMPOSSIBLE);
DBUG_RETURN(res);
}
/*
Estimate number of suitable keys in the tree
RETURN
estimated value
*/
ha_rows maria_rtree_estimate(MARIA_HA *info, uint keynr, uchar *key,
uint key_length, uint flag)
{
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= share->keyinfo + keynr;
my_off_t root;
uint i= 0;
uint nod_flag, k_len;
uchar *page_buf, *k, *last;
double area= 0;
ha_rows res= 0;
if (flag & MBR_DISJOINT)
return info->state->records;
if ((root= share->state.key_root[keynr]) == HA_OFFSET_ERROR)
return HA_POS_ERROR;
if (!(page_buf= (uchar*) my_alloca((uint)keyinfo->block_length)))
return HA_POS_ERROR;
if (!_ma_fetch_keypage(info, keyinfo, root, PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, page_buf, 0, 0))
goto err1;
nod_flag= _ma_test_if_nod(share, page_buf);
k_len= keyinfo->keylength - share->base.rec_reflength;
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
last= rt_PAGE_END(share, page_buf);
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag), i++)
{
if (nod_flag)
{
double k_area= maria_rtree_rect_volume(keyinfo->seg, k, key_length);
/* The following should be safe, even if we compare doubles */
if (k_area == 0)
{
if (flag & (MBR_CONTAIN | MBR_INTERSECT))
{
area += 1;
}
else if (flag & (MBR_WITHIN | MBR_EQUAL))
{
if (!maria_rtree_key_cmp(keyinfo->seg, key, k, key_length,
MBR_WITHIN))
area += 1;
}
else
goto err1;
}
else
{
if (flag & (MBR_CONTAIN | MBR_INTERSECT))
{
area+= maria_rtree_overlapping_area(keyinfo->seg, key, k,
key_length) / k_area;
}
else if (flag & (MBR_WITHIN | MBR_EQUAL))
{
if (!maria_rtree_key_cmp(keyinfo->seg, key, k, key_length,
MBR_WITHIN))
area+= (maria_rtree_rect_volume(keyinfo->seg, key, key_length) /
k_area);
}
else
goto err1;
}
}
else
{
if (!maria_rtree_key_cmp(keyinfo->seg, key, k, key_length, flag))
++res;
}
}
if (nod_flag)
{
if (i)
res= (ha_rows) (area / i * info->state->records);
else
res= HA_POS_ERROR;
}
my_afree((uchar*)page_buf);
return res;
err1:
my_afree(page_buf);
return HA_POS_ERROR;
}
#endif /*HAVE_RTREE_KEYS*/
Reference in a new issue View git blame Copy permalink