Commit c54e1855 authored by tsmith@ramayana.hindu.god's avatar tsmith@ramayana.hindu.god
Browse files

Merge ramayana.hindu.god:/home/tsmith/m/bk/50 

into  ramayana.hindu.god:/home/tsmith/m/bk/maint/50
parents 0b007174 9732efe7

heap/hp_delete.c

+0 −3
Original line number Diff line number Diff line
@@ -72,10 +72,7 @@ int hp_rb_delete_key(HP_INFO *info, register HP_KEYDEF *keyinfo, 
  int res;



  if (flag) 

  {

    info->last_pos= NULL; /* For heap_rnext/heap_rprev */

    info->lastkey_len= 0;

  }



  custom_arg.keyseg= keyinfo->seg;

  custom_arg.key_length= hp_rb_make_key(keyinfo, info->recbuf, record, recpos);

heap/hp_rfirst.c

+11 −0
Original line number Diff line number Diff line
@@ -35,6 +35,17 @@ int heap_rfirst(HP_INFO *info, byte *record, int inx) 
	     sizeof(byte*));

      info->current_ptr = pos;

      memcpy(record, pos, (size_t)share->reclength);

      /*

        If we're performing index_first on a table that was taken from

        table cache, info->lastkey_len is initialized to previous query.

        Thus we set info->lastkey_len to proper value for subsequent

        heap_rnext() calls.

        This is needed for DELETE queries only, otherwise this variable is

        not used.

        Note that the same workaround may be needed for heap_rlast(), but

        for now heap_rlast() is never used for DELETE queries.

      */

      info->lastkey_len= 0;

      info->update = HA_STATE_AKTIV;

    }

    else

heap/hp_rnext.c

+29 −0
Original line number Diff line number Diff line
@@ -33,11 +33,40 @@ int heap_rnext(HP_INFO *info, byte *record) 
    heap_rb_param custom_arg;



    if (info->last_pos)

    {

      /*

        We enter this branch for non-DELETE queries after heap_rkey()

        or heap_rfirst(). As last key position (info->last_pos) is available,

        we only need to climb the tree using tree_search_next().

      */

      pos = tree_search_next(&keyinfo->rb_tree, &info->last_pos,

                             offsetof(TREE_ELEMENT, left),

                             offsetof(TREE_ELEMENT, right));

    }

    else if (!info->lastkey_len)

    {

      /*

        We enter this branch only for DELETE queries after heap_rfirst(). E.g.

        DELETE FROM t1 WHERE a<10. As last key position is not available

        (last key is removed by heap_delete()), we must restart search as it

        is done in heap_rfirst().



        It should be safe to handle this situation without this branch. That is

        branch below should find smallest element in a tree as lastkey_len is

        zero. tree_search_edge() is a kind of optimisation here as it should be

        faster than tree_search_key().

      */

      pos= tree_search_edge(&keyinfo->rb_tree, info->parents,

                            &info->last_pos, offsetof(TREE_ELEMENT, left));

    }

    else

    {

      /*

        We enter this branch only for DELETE queries after heap_rkey(). E.g.

        DELETE FROM t1 WHERE a=10. As last key position is not available

        (last key is removed by heap_delete()), we must restart search as it

        is done in heap_rkey().

      */

      custom_arg.keyseg = keyinfo->seg;

      custom_arg.key_length = info->lastkey_len;

      custom_arg.search_flag = SEARCH_SAME | SEARCH_FIND;

include/config-win.h

+3 −0
Original line number Diff line number Diff line
@@ -19,6 +19,9 @@ 
/* We have to do this define before including windows.h to get the AWE API

functions */

#define _WIN32_WINNT     0x0500

#else

/* Get NT 4.0 functions */

#define _WIN32_WINNT     0x0400

#endif



#if defined(_MSC_VER) && _MSC_VER >= 1400

include/my_pthread.h

+5 −4
Original line number Diff line number Diff line
@@ -116,6 +116,7 @@ struct timespec { 


void win_pthread_init(void);

int win_pthread_setspecific(void *A,void *B,uint length);

int win_pthread_mutex_trylock(pthread_mutex_t *mutex);

int pthread_create(pthread_t *,pthread_attr_t *,pthread_handler,void *);

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
@@ -176,7 +177,7 @@ extern int pthread_mutex_destroy (pthread_mutex_t *); 
#else

#define pthread_mutex_init(A,B)  (InitializeCriticalSection(A),0)

#define pthread_mutex_lock(A)	 (EnterCriticalSection(A),0)

#define pthread_mutex_trylock(A) (WaitForSingleObject((A), 0) == WAIT_TIMEOUT)

#define pthread_mutex_trylock(A) win_pthread_mutex_trylock((A))

#define pthread_mutex_unlock(A)  LeaveCriticalSection(A)

#define pthread_mutex_destroy(A) DeleteCriticalSection(A)

#define my_pthread_setprio(A,B)  SetThreadPriority(GetCurrentThread(), (B))
@@ -574,7 +575,7 @@ typedef struct st_safe_mutex_info_t 


int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr,

                    const char *file, uint line);

int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line);

int safe_mutex_lock(safe_mutex_t *mp, my_bool try_lock, const char *file, uint line);

int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line);

int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line);

int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,
@@ -597,12 +598,12 @@ void safe_mutex_end(FILE *file); 
#undef pthread_cond_timedwait

#undef pthread_mutex_trylock

#define pthread_mutex_init(A,B) safe_mutex_init((A),(B),__FILE__,__LINE__)

#define pthread_mutex_lock(A) safe_mutex_lock((A),__FILE__,__LINE__)

#define pthread_mutex_lock(A) safe_mutex_lock((A), FALSE, __FILE__, __LINE__)

#define pthread_mutex_unlock(A) safe_mutex_unlock((A),__FILE__,__LINE__)

#define pthread_mutex_destroy(A) safe_mutex_destroy((A),__FILE__,__LINE__)

#define pthread_cond_wait(A,B) safe_cond_wait((A),(B),__FILE__,__LINE__)

#define pthread_cond_timedwait(A,B,C) safe_cond_timedwait((A),(B),(C),__FILE__,__LINE__)

#define pthread_mutex_trylock(A) pthread_mutex_lock(A)

#define pthread_mutex_trylock(A) safe_mutex_lock((A), TRUE, __FILE__, __LINE__)

#define pthread_mutex_t safe_mutex_t

#define safe_mutex_assert_owner(mp) \

          DBUG_ASSERT((mp)->count > 0 && \