Reviewing new pushed code

- CHAR() now returns binary string as default
- CHAR(X*65536+Y*256+Z) is now equal to CHAR(X,Y,Z) independent of the character set for CHAR()
- Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
  (Some old systems returns ETIME and it's safer to test for both values
   than to try to write a wrapper for each old system)
- Fixed new introduced bug in NOT BETWEEN X and X
- Ensure we call commit_by_xid or rollback_by_xid for all engines, even if one engine has failed
- Use octet2hex() for all conversion of string to hex
- Simplify and optimize code


client/mysqldump.c:
  Simple optimizations of new code
  Indentation fixes
client/mysqltest.c:
  Removed not needed variable
include/mysql_com.h:
  Made octec2hex() more usable
mysql-test/r/ctype_utf8.result:
  CHAR() now returns binary string as default
mysql-test/r/func_str.result:
  CHAR() now returns binary string as default
mysql-test/r/range.result:
  Added test to verify new introduced bug in NOT BETWEEN X and X
mysql-test/r/user_var-binlog.result:
  CHAR() now returns binary string as default
mysql-test/r/view.result:
  More tests of view rename
mysql-test/t/ctype_utf8.test:
  CHAR() now returns binary string as default
mysql-test/t/func_str.test:
  CHAR() now returns binary string as default
mysql-test/t/range.test:
  Added test to verify new introduced bug in NOT BETWEEN X and X
mysql-test/t/view.test:
  More tests of view rename
mysys/mf_keycache.c:
  Indentation changes
  Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
mysys/my_os2cond.c:
  Fix to MySQL coding style
  Optimized functions
mysys/thr_lock.c:
  Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
mysys/thr_mutex.c:
  Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
server-tools/instance-manager/instance.cc:
  Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
server-tools/instance-manager/thread_registry.cc:
  Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
sql/ha_federated.cc:
  Use octet2hex()
sql/ha_ndbcluster.cc:
  Removed not used variable
sql/handler.cc:
  Simplify code
  Use *NONE* instead of 'none' for not existing storage engine
  Ensure we call commit_by_xid or rollback_by_xid for all engines, even if one engine has failed
sql/item.h:
  Remove not needed test for *ref.  (If ref is set, it should never point at 0)
sql/item_func.cc:
  Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
  Simplify code
  More comments
  Require that last argument to find_and_check_access() is given
  (Made code shorter and faster)
sql/item_strfunc.cc:
  Changed CHAR() to return result in binary collation
  CHAR(X*65536+Y*256+Z) is now equal to CHAR(X,Y,Z) independent of the character set for CHAR()
  
  Bar will shortly add the following syntax:
  CHAR(.... USING character_set)
  and ensure that
  CONVERT(CHAR(....) USING utf8) cuts not legal utf8 strings
  Use ocet2hex()
sql/item_strfunc.h:
  CHAR() now returns a binary string
sql/log_event.cc:
  Use octet2hex()
  Simplify code
sql/parse_file.cc:
  Indentation fixes
  Use for() instead of while()
sql/password.c:
  Make octet2hex() more generally usable by returning pointer to end 0
sql/slave.cc:
  Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
sql/sql_base.cc:
  Indentation fixes
sql/sql_insert.cc:
  Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
sql/sql_manager.cc:
  Test for both ETIMEDOUT and ETIME from pthread_cond_timedwait()
sql/sql_parse.cc:
  Don't check thd->db when checking for function privileges
sql/sql_prepare.cc:
  Fixed wrong merge
sql/sql_select.cc:
  Fixed new bug for NOT BETWEEN X and X
sql/sql_show.cc:
  Removed not used variable
sql/sql_table.cc:
  Indentation fixed
  Removed DBUG_PRINT that is obvious from context
sql/sql_view.cc:
  Simplify code
sql/unireg.cc:
  Use octet2hex()

4 files changed, 76 insertions, 99 deletions

diff --git a/mysys/mf_keycache.c b/mysys/mf_keycache.c
index 69410e9faaa..3b5e277b56d 100644
--- a/mysys/mf_keycache.c
+++ b/mysys/mf_keycache.c
@@ -2750,9 +2750,12 @@ static int keycache_pthread_cond_wait(pthread_cond_t *cond,
   gettimeofday(&now, &tz);
   /* Prepare timeout value */
   timeout.tv_sec= now.tv_sec + KEYCACHE_TIMEOUT;
-  timeout.tv_nsec= now.tv_usec * 1000; /* timeval uses microseconds.         */
-                                        /* timespec uses nanoseconds.         */
-                                        /* 1 nanosecond = 1000 micro seconds. */
+ /*
+   timeval uses microseconds.
+   timespec uses nanoseconds.
+   1 nanosecond = 1000 micro seconds
+ */
+  timeout.tv_nsec= now.tv_usec * 1000;
   KEYCACHE_THREAD_TRACE_END("started waiting");
 #if defined(KEYCACHE_DEBUG)
   cnt++;
@@ -2762,17 +2765,15 @@ static int keycache_pthread_cond_wait(pthread_cond_t *cond,
 #endif
   rc= pthread_cond_timedwait(cond, mutex, &timeout);
   KEYCACHE_THREAD_TRACE_BEGIN("finished waiting");
-#if defined(KEYCACHE_DEBUG)
-  if (rc == ETIMEDOUT)
+  if (rc == ETIMEDOUT || rc == ETIME)
   {
+#if defined(KEYCACHE_DEBUG)
     fprintf(keycache_debug_log,"aborted by keycache timeout\n");
     fclose(keycache_debug_log);
     abort();
-  }
 #endif
-
-  if (rc == ETIMEDOUT)
     keycache_dump();
+  }
 
 #if defined(KEYCACHE_DEBUG)
   KEYCACHE_DBUG_ASSERT(rc != ETIMEDOUT);
diff --git a/mysys/my_os2cond.c b/mysys/my_os2cond.c
index 83a03d62046..bf3e85c26a9 100644
--- a/mysys/my_os2cond.c
+++ b/mysys/my_os2cond.c
@@ -22,7 +22,7 @@
 ** The following is a simple implementation of posix conditions
 *****************************************************************************/
 
-#undef SAFE_MUTEX			/* Avoid safe_mutex redefinitions */
+#undef SAFE_MUTEX                       /* Avoid safe_mutex redefinitions */
 #include "mysys_priv.h"
 #if defined(THREAD) && defined(OS2)
 #include <m_string.h>
@@ -31,134 +31,109 @@
 
 int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
 {
-   APIRET	   rc = 0;
-   HEV		   event;
-   cond->waiting=0;
-   /* Warp3 FP29 or Warp4 FP4 or better required */
-   rc = DosCreateEventSem( NULL, &cond->semaphore, 0x0800, 0);
-   if (rc)
-      return ENOMEM;
-
+  cond->waiting= 0;
+  /* Warp3 FP29 or Warp4 FP4 or better required */
+  if (DosCreateEventSem(NULL, &cond->semaphore, 0x0800, 0))
+    return ENOMEM;
   return 0;
 }
 
 int pthread_cond_destroy(pthread_cond_t *cond)
 {
-   APIRET   rc;
-
-   do {
-      rc = DosCloseEventSem(cond->semaphore);
-      if (rc == 301) DosPostEventSem(cond->semaphore);
-   } while (rc == 301);
-   if (rc)
-      return EINVAL;
-
-	return 0;
+  for (;;)
+  {
+    APIRET rc;
+    if ((rc= DosCloseEventSem(cond->semaphore)) != 301)
+      return rc ? EINVAL : 0;
+    DosPostEventSem(cond->semaphore);
+  }
 }
 
 
 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 {
-   APIRET   rc;
-   int	    rval;
-
-   rval = 0;
-   cond->waiting++;
-
-   if (mutex) pthread_mutex_unlock(mutex);
-
-   rc = DosWaitEventSem(cond->semaphore,SEM_INDEFINITE_WAIT);
-   if (rc != 0)
-      rval = EINVAL;
-
-   if (mutex) pthread_mutex_lock(mutex);
-
-   cond->waiting--;
-
-   return rval;
+  int rval= 0;
+  cond->waiting++;
+  if (mutex)
+    pthread_mutex_unlock(mutex);
+  if (DosWaitEventSem(cond->semaphore, SEM_INDEFINITE_WAIT))
+    rval= EINVAL;
+  if (mutex)
+    pthread_mutex_lock(mutex);
+  cond->waiting--;
+  return rval;
 }
 
 int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
-			   struct timespec *abstime)
+                           struct timespec *abstime)
 {
   struct timeb curtime;
   int result;
   long timeout;
-   APIRET   rc;
-   int	    rval;
-
-   _ftime(&curtime);
-   timeout= ((long) (abstime->ts_sec - curtime.time)*1000L +
-		    (long)((abstime->ts_nsec/1000) - curtime.millitm)/1000L);
-   if (timeout < 0)				/* Some safety */
-      timeout = 0L;
+  int rval= 0;
 
-   rval = 0;
-   cond->waiting++;
+  _ftime(&curtime);
+  timeout= ((long) (abstime->ts_sec - curtime.time) * 1000L +
+            (long) ((abstime->ts_nsec / 1000) - curtime.millitm) / 1000L);
+  if (timeout < 0)                              /* Some safety */
+    timeout= 0L;
 
-   if (mutex) pthread_mutex_unlock(mutex);
+  cond->waiting++;
 
-   rc = DosWaitEventSem(cond->semaphore, timeout);
-   if (rc != 0)
-      rval= ETIMEDOUT;
+  if (mutex)
+    pthread_mutex_unlock(mutex);
+  if (DosWaitEventSem(cond->semaphore, timeout) != 0)
+    rval= ETIMEDOUT;
+  if (mutex)
+    pthread_mutex_lock(mutex);
 
-   if (mutex) pthread_mutex_lock(mutex);
+  cond->waiting--;
 
-   cond->waiting--;
-
-   return rval;
+  return rval;
 }
 
 
 int pthread_cond_signal(pthread_cond_t *cond)
 {
-   APIRET   rc;
-
-   /* Bring the next thread off the condition queue: */
-   rc = DosPostEventSem(cond->semaphore);
-   return 0;
+  /* Bring the next thread off the condition queue: */
+  DosPostEventSem(cond->semaphore);
+  return 0;
 }
 
 
 int pthread_cond_broadcast(pthread_cond_t *cond)
 {
-   int	    i;
-   APIRET   rc;
-
-		/*
-		 * Enter a loop to bring all threads off the
-		 * condition queue:
-		 */
-   i = cond->waiting;
-   while (i--) rc = DosPostEventSem(cond->semaphore);
-
-   return 0 ;
+  int i;
+  /* Enter a loop to bring all threads off the condition queue */
+  for (i= cond->waiting; i--;)
+    DosPostEventSem(cond->semaphore);
+  return 0;
 }
 
 
 int pthread_attr_init(pthread_attr_t *connect_att)
 {
-  connect_att->dwStackSize	= 0;
-  connect_att->dwCreatingFlag	= 0;
-  connect_att->priority		= 0;
+  connect_att->dwStackSize= 0;
+  connect_att->dwCreatingFlag= 0;
+  connect_att->priority= 0;
   return 0;
 }
 
-int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack)
+int pthread_attr_setstacksize(pthread_attr_t *connect_att, DWORD stack)
 {
-  connect_att->dwStackSize=stack;
+  connect_att->dwStackSize= stack;
   return 0;
 }
 
-int pthread_attr_setprio(pthread_attr_t *connect_att,int priority)
+int pthread_attr_setprio(pthread_attr_t *connect_att, int priority)
 {
-  connect_att->priority=priority;
+  connect_att->priority= priority;
   return 0;
 }
 
 int pthread_attr_destroy(pthread_attr_t *connect_att)
 {
-  bzero((gptr) connect_att,sizeof(*connect_att));
+  bzero((gptr) connect_att, sizeof(*connect_att));
   return 0;
 }
 
@@ -166,22 +141,22 @@ int pthread_attr_destroy(pthread_attr_t *connect_att)
 ** Fix localtime_r() to be a bit safer
 ****************************************************************************/
 
-struct tm *localtime_r(const time_t *timep,struct tm *tmp)
+struct tm *localtime_r(const time_t *timep, struct tm *tmp)
 {
-  if (*timep == (time_t) -1)			/* This will crash win32 */
+  if (*timep == (time_t) - 1)                   /* This will crash win32 */
   {
-    bzero(tmp,sizeof(*tmp));
+    bzero(tmp, sizeof(*tmp));
   }
   else
   {
-    struct tm *res=localtime(timep);
-    if (!res)					/* Wrong date */
+    struct tm *res= localtime(timep);
+    if (!res)                                   /* Wrong date */
     {
-      bzero(tmp,sizeof(*tmp));			/* Keep things safe */
+      bzero(tmp, sizeof(*tmp));                 /* Keep things safe */
       return 0;
     }
     *tmp= *res;
   }
   return tmp;
 }
-#endif /* __WIN__ */
+#endif                                          /* __WIN__ */
diff --git a/mysys/thr_lock.c b/mysys/thr_lock.c
index 41266d61b0a..f5a8b618949 100644
--- a/mysys/thr_lock.c
+++ b/mysys/thr_lock.c
@@ -408,9 +408,10 @@ wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
     set_timespec(wait_timeout, table_lock_wait_timeout);
   while (!thread_var->abort || in_wait_list)
   {
-    int rc= can_deadlock ? pthread_cond_timedwait(cond, &data->lock->mutex,
-                                                  &wait_timeout) :
-                           pthread_cond_wait(cond, &data->lock->mutex);
+    int rc= (can_deadlock ?
+             pthread_cond_timedwait(cond, &data->lock->mutex,
+                                    &wait_timeout) :
+             pthread_cond_wait(cond, &data->lock->mutex));
     /*
       We must break the wait if one of the following occurs:
       - the connection has been aborted (!thread_var->abort), but
@@ -426,7 +427,7 @@ wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
     */
     if (data->cond == 0)
       break;
-    if (rc == ETIMEDOUT)
+    if (rc == ETIMEDOUT || rc == ETIME)
     {
       result= THR_LOCK_WAIT_TIMEOUT;
       break;
diff --git a/mysys/thr_mutex.c b/mysys/thr_mutex.c
index 2facb4e18cf..3326068d164 100644
--- a/mysys/thr_mutex.c
+++ b/mysys/thr_mutex.c
@@ -239,7 +239,7 @@ int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
   pthread_mutex_unlock(&mp->global);
   error=pthread_cond_timedwait(cond,&mp->mutex,abstime);
 #ifdef EXTRA_DEBUG
-  if (error && (error != EINTR && error != ETIMEDOUT))
+  if (error && (error != EINTR && error != ETIMEDOUT && error != ETIME))
   {
     fprintf(stderr,"safe_mutex: Got error: %d (%d) when doing a safe_mutex_timedwait at %s, line %d\n", error, errno, file, line);
   }