int mi_rkey(MI_INFO * info, byte * buf, int inx, const byte * key, uint key_len, enum ha_rkey_function search_flag) { uchar *key_buff; MYISAM_SHARE *share = info->s; uint pack_key_length; DBUG_ENTER("mi_rkey"); DBUG_PRINT("enter", ("base: %lx inx: %d search_flag: %d", info, inx, search_flag)); if ((inx = _mi_check_index(info, inx)) < 0) DBUG_RETURN(my_errno); info->update &= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED); if (!info->use_packed_key) { if (key_len == 0) key_len = USE_WHOLE_KEY; key_buff = info->lastkey + info->s->base.max_key_length; pack_key_length = _mi_pack_key(info, (uint) inx, key_buff, (uchar *) key, 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 {
int mi_rprev(MI_INFO * info, byte * buf, int inx) { int error , changed; register uint flag; MYISAM_SHARE *share = info->s; DBUG_ENTER("mi_rprev"); if ((inx = _mi_check_index(info, inx)) < 0) DBUG_RETURN(my_errno); flag = SEARCH_SMALLER; /* Read previous */ if (info->lastpos == HA_OFFSET_ERROR && info->update & HA_STATE_NEXT_FOUND) flag = 0; /* Read last */ if (_mi_readinfo(info, F_RDLCK, 1)) DBUG_RETURN(my_errno); changed = _mi_test_if_changed(info); if (share->concurrent_insert) rw_rdlock(&share->key_root_lock[inx]); if (!flag) error = _mi_search_last(info, share->keyinfo + inx, share->state.key_root[inx]); else if (!changed) error = _mi_search_next(info, share->keyinfo + inx, info->lastkey, info->lastkey_length, flag, share->state.key_root[inx]); else error = _mi_search(info, share->keyinfo + inx, info->lastkey, info->lastkey_length, flag, share->state.key_root[inx]); if (!error) { while (info->lastpos >= info->state->data_file_length) { /* * Skip rows that are inserted by other threads since * we got a lock */ if ((error = _mi_search_next(info, share->keyinfo + inx, info->lastkey, info->lastkey_length, SEARCH_SMALLER, share->state.key_root[inx]))) break; } } if (share->concurrent_insert) rw_unlock(&share->key_root_lock[inx]); info->update &= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED); info->update |= HA_STATE_PREV_FOUND; if (error) { 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 */ DBUG_RETURN(0); } DBUG_RETURN(my_errno); } /* mi_rprev */
int mi_rkey(MI_INFO *info, uchar *buf, int inx, const uchar *key, key_part_map keypart_map, enum ha_rkey_function search_flag) { uchar *key_buff; MYISAM_SHARE *share=info->s; MI_KEYDEF *keyinfo; HA_KEYSEG *last_used_keyseg; uint pack_key_length, use_key_length, nextflag; ICP_RESULT res= ICP_NO_MATCH; DBUG_ENTER("mi_rkey"); DBUG_PRINT("enter", ("base: 0x%lx buf: 0x%lx inx: %d search_flag: %d", (long) info, (long) buf, inx, search_flag)); if ((inx = _mi_check_index(info,inx)) < 0) DBUG_RETURN(my_errno); info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED); info->last_key_func= search_flag; keyinfo= share->keyinfo + inx; if (info->once_flags & USE_PACKED_KEYS) { info->once_flags&= ~USE_PACKED_KEYS; /* Reset flag */ /* key is already packed!; This happens when we are using a MERGE TABLE In this key 'key_part_map' is the length of the key ! */ key_buff=info->lastkey+info->s->base.max_key_length; pack_key_length= keypart_map; bmove(key_buff, key, pack_key_length); last_used_keyseg= info->s->keyinfo[inx].seg + info->last_used_keyseg; } else { DBUG_ASSERT(keypart_map); /* Save the packed key for later use in the second buffer of lastkey. */ key_buff=info->lastkey+info->s->base.max_key_length; pack_key_length=_mi_pack_key(info,(uint) inx, key_buff, (uchar*) key, keypart_map, &last_used_keyseg); /* Save packed_key_length for use by the MERGE engine. */ info->pack_key_length= pack_key_length; info->last_used_keyseg= (uint16) (last_used_keyseg - info->s->keyinfo[inx].seg); DBUG_EXECUTE("key",_mi_print_key(DBUG_FILE, keyinfo->seg, key_buff, pack_key_length);); }
int mi_rnext(MI_INFO *info, uchar *buf, int inx) { int error,changed; uint flag; uint update_mask= HA_STATE_NEXT_FOUND; DBUG_ENTER("mi_rnext"); if ((inx = _mi_check_index(info,inx)) < 0) DBUG_RETURN(my_errno); flag=SEARCH_BIGGER; /* Read next */ if (info->lastpos == HA_OFFSET_ERROR && info->update & HA_STATE_PREV_FOUND) flag=0; /* Read first */ if (fast_mi_readinfo(info)) DBUG_RETURN(my_errno); if (info->s->concurrent_insert) mysql_rwlock_rdlock(&info->s->key_root_lock[inx]); changed=_mi_test_if_changed(info); if (!flag) { switch(info->s->keyinfo[inx].key_alg){ #ifdef HAVE_RTREE_KEYS case HA_KEY_ALG_RTREE: error=rtree_get_first(info,inx,info->lastkey_length); break; #endif case HA_KEY_ALG_BTREE: default: error=_mi_search_first(info,info->s->keyinfo+inx, info->s->state.key_root[inx]); break; } /* "search first" failed. This means we have no pivot for "search next", or in other words MI_INFO::lastkey is likely uninitialized. Normally SQL layer would never request "search next" if "search first" failed. But HANDLER may do anything. As mi_rnext() without preceeding mi_rkey()/mi_rfirst() equals to mi_rfirst(), we must restore original state as if failing mi_rfirst() was not called. */ if (error) update_mask|= HA_STATE_PREV_FOUND; } else { switch (info->s->keyinfo[inx].key_alg) { #ifdef HAVE_RTREE_KEYS case HA_KEY_ALG_RTREE: /* Note that rtree doesn't support that the table may be changed since last call, so we do need to skip rows inserted by other threads like in btree */ error= rtree_get_next(info,inx,info->lastkey_length); break; #endif case HA_KEY_ALG_BTREE: default: if (!changed) error= _mi_search_next(info,info->s->keyinfo+inx,info->lastkey, info->lastkey_length,flag, info->s->state.key_root[inx]); else error= _mi_search(info,info->s->keyinfo+inx,info->lastkey, USE_WHOLE_KEY,flag, info->s->state.key_root[inx]); } } if (info->s->concurrent_insert) { if (!error) { while (info->lastpos >= info->state->data_file_length) { /* Skip rows inserted by other threads since we got a lock */ if ((error=_mi_search_next(info,info->s->keyinfo+inx, info->lastkey, info->lastkey_length, SEARCH_BIGGER, info->s->state.key_root[inx]))) break; } } mysql_rwlock_unlock(&info->s->key_root_lock[inx]); } /* Don't clear if database-changed */ info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED); info->update|= update_mask; if (error) { 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 */ DBUG_RETURN(0); } DBUG_PRINT("error",("Got error: %d, errno: %d",error, my_errno)); DBUG_RETURN(my_errno); } /* mi_rnext */
ha_rows mi_records_in_range(MI_INFO *info, int inx, key_range *min_key, key_range *max_key) { ha_rows start_pos,end_pos,res; DBUG_ENTER("mi_records_in_range"); if ((inx = _mi_check_index(info,inx)) < 0) DBUG_RETURN(HA_POS_ERROR); if (fast_mi_readinfo(info)) DBUG_RETURN(HA_POS_ERROR); info->update&= (HA_STATE_CHANGED+HA_STATE_ROW_CHANGED); if (info->s->concurrent_insert) rw_rdlock(&info->s->key_root_lock[inx]); switch(info->s->keyinfo[inx].key_alg){ #ifdef HAVE_RTREE_KEYS case HA_KEY_ALG_RTREE: { uchar * key_buff; uint start_key_len; /* The problem is that the optimizer doesn't support RTree keys properly at the moment. Hope this will be fixed some day. But now NULL in the min_key means that we didn't make the task for the RTree key and expect BTree functionality from it. As it's not able to handle such request we return the error. */ if (!min_key) { res= HA_POS_ERROR; break; } key_buff= info->lastkey+info->s->base.max_key_length; start_key_len= _mi_pack_key(info,inx, key_buff, (uchar*) min_key->key, min_key->keypart_map, (HA_KEYSEG**) 0); res= rtree_estimate(info, inx, key_buff, start_key_len, myisam_read_vec[min_key->flag]); res= res ? res : 1; /* Don't return 0 */ break; } #endif case HA_KEY_ALG_BTREE: default: start_pos= (min_key ? _mi_record_pos(info, min_key->key, min_key->keypart_map, min_key->flag) : (ha_rows) 0); end_pos= (max_key ? _mi_record_pos(info, max_key->key, max_key->keypart_map, max_key->flag) : info->state->records + (ha_rows) 1); res= (end_pos < start_pos ? (ha_rows) 0 : (end_pos == start_pos ? (ha_rows) 1 : end_pos-start_pos)); if (start_pos == HA_POS_ERROR || end_pos == HA_POS_ERROR) res=HA_POS_ERROR; } if (info->s->concurrent_insert) rw_unlock(&info->s->key_root_lock[inx]); fast_mi_writeinfo(info); DBUG_PRINT("info",("records: %ld",(ulong) (res))); DBUG_RETURN(res); }
int mi_rnext(MI_INFO *info, byte *buf, int inx) { int error,changed; uint flag; DBUG_ENTER("mi_rnext"); if ((inx = _mi_check_index(info,inx)) < 0) DBUG_RETURN(my_errno); flag=SEARCH_BIGGER; /* Read next */ if (info->lastpos == HA_OFFSET_ERROR && info->update & HA_STATE_PREV_FOUND) flag=0; /* Read first */ if (fast_mi_readinfo(info)) DBUG_RETURN(my_errno); if (info->s->concurrent_insert) rw_rdlock(&info->s->key_root_lock[inx]); changed=_mi_test_if_changed(info); if (!flag) { switch(info->s->keyinfo[inx].key_alg){ #ifdef HAVE_RTREE_KEYS case HA_KEY_ALG_RTREE: error=rtree_get_first(info,inx,info->lastkey_length); break; #endif case HA_KEY_ALG_BTREE: default: error=_mi_search_first(info,info->s->keyinfo+inx, info->s->state.key_root[inx]); break; } } else { switch (info->s->keyinfo[inx].key_alg) { #ifdef HAVE_RTREE_KEYS case HA_KEY_ALG_RTREE: /* Note that rtree doesn't support that the table may be changed since last call, so we do need to skip rows inserted by other threads like in btree */ error= rtree_get_next(info,inx,info->lastkey_length); break; #endif case HA_KEY_ALG_BTREE: default: if (!changed) error= _mi_search_next(info,info->s->keyinfo+inx,info->lastkey, info->lastkey_length,flag, info->s->state.key_root[inx]); else error= _mi_search(info,info->s->keyinfo+inx,info->lastkey, USE_WHOLE_KEY,flag, info->s->state.key_root[inx]); } } if (info->s->concurrent_insert) { if (!error) { while (info->lastpos >= info->state->data_file_length) { /* Skip rows inserted by other threads since we got a lock */ if ((error=_mi_search_next(info,info->s->keyinfo+inx, info->lastkey, info->lastkey_length, SEARCH_BIGGER, info->s->state.key_root[inx]))) break; } } rw_unlock(&info->s->key_root_lock[inx]); } /* Don't clear if database-changed */ info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED); info->update|= HA_STATE_NEXT_FOUND; if (error) { 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 */ DBUG_RETURN(0); } DBUG_PRINT("error",("Got error: %d, errno: %d",error, my_errno)); DBUG_RETURN(my_errno); } /* mi_rnext */
int mi_rprev(MI_INFO *info, uchar *buf, int inx) { int error,changed; register uint flag; MYISAM_SHARE *share=info->s; DBUG_ENTER("mi_rprev"); if ((inx = _mi_check_index(info,inx)) < 0) DBUG_RETURN(my_errno); flag=SEARCH_SMALLER; /* Read previous */ if (info->lastpos == HA_OFFSET_ERROR && info->update & HA_STATE_NEXT_FOUND) flag=0; /* Read last */ if (fast_mi_readinfo(info)) DBUG_RETURN(my_errno); changed=_mi_test_if_changed(info); if (share->concurrent_insert) mysql_rwlock_rdlock(&share->key_root_lock[inx]); if (!flag) error=_mi_search_last(info, share->keyinfo+inx, share->state.key_root[inx]); else if (!changed) error=_mi_search_next(info,share->keyinfo+inx,info->lastkey, info->lastkey_length,flag, share->state.key_root[inx]); else error=_mi_search(info,share->keyinfo+inx,info->lastkey, USE_WHOLE_KEY, flag, share->state.key_root[inx]); if (!error) { int res= 0; while ((share->concurrent_insert && info->lastpos >= info->state->data_file_length) || (info->index_cond_func && !(res= mi_check_index_cond(info, inx, buf)))) { /* Skip rows that are either inserted by other threads since we got a lock or do not match pushed index conditions */ if ((error=_mi_search_next(info,share->keyinfo+inx,info->lastkey, info->lastkey_length, SEARCH_SMALLER, share->state.key_root[inx]))) break; } if (!error && res == 2) { if (share->concurrent_insert) mysql_rwlock_unlock(&share->key_root_lock[inx]); info->lastpos= HA_OFFSET_ERROR; DBUG_RETURN(my_errno= HA_ERR_END_OF_FILE); } } if (share->concurrent_insert) { if (!error) { while (info->lastpos >= info->state->data_file_length) { /* Skip rows that are inserted by other threads since we got a lock */ if ((error=_mi_search_next(info,share->keyinfo+inx,info->lastkey, info->lastkey_length, SEARCH_SMALLER, share->state.key_root[inx]))) break; } } mysql_rwlock_unlock(&share->key_root_lock[inx]); } info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED); info->update|= HA_STATE_PREV_FOUND; if (error) { 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 */ DBUG_RETURN(0); } DBUG_RETURN(my_errno); } /* mi_rprev */