--- mysql-6.0-orig/client/mysql.cc	2008-01-10 20:35:49.000000000 +0100
+++ mysql-6.0/client/mysql.cc	2008-01-22 17:17:56.000000000 +0100
@@ -186,6 +186,13 @@
 static char *shared_memory_base_name=0;
 #endif
 static uint opt_protocol=0;
+#ifdef HAVE_READLINE
+/* maximum tables we'll allow for table context completion */
+#define MAX_TC_TABLE_CNT 20
+static uint tc_count=0;
+static char *tc_tableList[MAX_TC_TABLE_CNT];
+#endif
+
 static CHARSET_INFO *charset_info= &my_charset_latin1;
 
 #include "sslopt-vars.h"
@@ -336,6 +343,10 @@
 extern "C" int read_history(const char *command);
 extern "C" int write_history(const char *command);
 extern "C" HIST_ENTRY *history_get(int num);
+static char* tc_add_prefix(const char *original, const char* prefix);
+static int tc_maybe_change_context(const char *token);
+static char *tc_frob_tablename(const char *t_name);
+static int tc_get_table_context(const char *data, char** t_array);
 extern "C" int history_length;
 static int not_in_history(const char *line);
 static void initialize_readline (char *name);
@@ -1659,6 +1670,7 @@
 
 static void initialize_readline (char *name)
 {
+
   /* Allow conditional parsing of the ~/.inputrc file. */
   rl_readline_name = name;
 
@@ -1672,6 +1684,7 @@
 #endif
   rl_attempted_completion_function= (CPPFunction*)&new_mysql_completion;
   rl_completion_entry_function= &no_completion;
+
 #else
   rl_attempted_completion_function= (CPPFunction*)&new_mysql_completion;
   rl_completion_entry_function= &no_completion;
@@ -1689,12 +1702,22 @@
                              int start __attribute__((unused)),
                              int end __attribute__((unused)))
 {
+  uint i;
+
   if (!status.batch && !quick)
+  {
+    /* clear old table context if we have it */
+    for (i=0; i<tc_count; i++) {
+      my_free(tc_tableList[i],MYF(MY_ALLOW_ZERO_PTR));
+    }
+    /* try to get table context */
+    tc_count = tc_get_table_context(rl_line_buffer, tc_tableList);
 #if defined(USE_NEW_READLINE_INTERFACE)
     return rl_completion_matches(text, new_command_generator);
 #else
     return completion_matches((char *)text, (CPFunction *)new_command_generator);
 #endif
+  }
   else
     return (char**) 0;
 }
@@ -1703,44 +1726,88 @@
 {
   static int textlen;
   char *ptr;
-  static Bucket *b;
+  static Bucket *b[MAX_TC_TABLE_CNT], *b_tmp;
   static entry *e;
-  static uint i;
+  static uint i, bi, b_cnt= 0;
+  char *tc_text,*p;
 
   if (!state)
+  {
+    /* always clear buckets when state=0 */
+    for (i= 0; i<b_cnt; i++)
+      b[i]= 0;
+    bi= 0;
+    b_cnt= 0;
     textlen=(uint) strlen(text);
+  }
 
-  if (textlen>0)
+  if (textlen>0 || tc_count>0)
   {						/* lookup in the hash */
     if (!state)
     {
       uint len;
 
-      b = find_all_matches(&ht,text,(uint) strlen(text),&len);
-      if (!b)
+      /* use table context if we have it, and there isn't one specified in text */
+      if (tc_count && !strstr(text, "."))
+      {
+        for (i=0; i<tc_count; i++) {
+
+          tc_text= tc_add_prefix(text, tc_tableList[i]);
+          if (tc_text)
+          {
+            b_tmp= find_all_matches(&ht,tc_text,(uint) strlen(tc_text),&len);
+            if (b_tmp)
+              b[b_cnt++]= b_tmp;
+
+            my_free(tc_text,MYF(MY_ALLOW_ZERO_PTR));
+          }
+
+        }
+      }
+      else {
+        /* no or explicit context */
+        b[0]= find_all_matches(&ht,text,(uint) strlen(text),&len);
+        if (b[0])
+          b_cnt= 1;
+      }
+
+      if (!b_cnt)
 	return NullS;
-      e = b->pData;
+      e= b[0]->pData;
     }
 
     if (e)
     {
+      /* possibly strip the table context prefix */
+      if (tc_count && (p= strchr(e->str, '.')))
+        ptr= strdup(++p);
+      else
       ptr= strdup(e->str);
-      e = e->pNext;
+
+      e= e->pNext;
+
+      /* if we have context, be sure to check each context's bucket entry */
+      if (!e && (bi < (b_cnt-1)))
+        e= b[++bi]->pData;
+
       return ptr;
     }
+
   }
   else
   { /* traverse the entire hash, ugly but works */
 
     if (!state)
     {
+      
       /* find the first used bucket */
       for (i=0 ; i < ht.nTableSize ; i++)
       {
 	if (ht.arBuckets[i])
 	{
-	  b = ht.arBuckets[i];
-	  e = b->pData;
+          b[0] = ht.arBuckets[i];
+          e = b[0]->pData;
+          b_cnt=1;
 	  break;
 	}
       }
@@ -1748,27 +1815,27 @@
     ptr= NullS;
     while (e && !ptr)
     {					/* find valid entry in bucket */
-      if ((uint) strlen(e->str) == b->nKeyLength)
+      if ((uint) strlen(e->str) == b[0]->nKeyLength)
 	ptr = strdup(e->str);
       /* find the next used entry */
       e = e->pNext;
       if (!e)
       { /* find the next used bucket */
-	b = b->pNext;
-	if (!b)
+        b[0] = b[0]->pNext;
+        if (!b[0])
 	{
 	  for (i++ ; i<ht.nTableSize; i++)
 	  {
 	    if (ht.arBuckets[i])
 	    {
-	      b = ht.arBuckets[i];
-	      e = b->pData;
+              b[0] = ht.arBuckets[i];
+              e = b[0]->pData;
 	      break;
 	    }
 	  }
 	}
 	else
-	  e = b->pData;
+          e = b[0]->pData;
       }
     }
     if (ptr)
@@ -1777,9 +1844,139 @@
   return NullS;
 }
 
+/* table context routines for completion */
+#define TC_KEY_PAIR_COUNT 3
 
-/* Build up the completion hash */
+const char *tc_table_key_pairs[TC_KEY_PAIR_COUNT][2] = { { "FROM", "WHERE" },
+                                                         { "UPDATE", "SET" },
+                                                         { "INTO", "SET" }
+                                                       };
+
+
+/* prefix original with the table prefix in prefix. always allocates a new
+  string */
+static char* tc_add_prefix(const char *original, const char* prefix)
+{
+
+  char *tc_text;
+
+  if (!original && !prefix)
+    return NULL;
+
+  if (prefix)
+  {
+    tc_text = (char*)my_malloc((uint) strlen(prefix)+
+                               (uint) strlen(original)+1,
+                               MYF(MY_WME));
+    strcpy(tc_text, prefix);
+    if (original)
+      strcat(tc_text,original);
+  }
+  else
+    tc_text = strdup(original);
+
+  return tc_text;
+
+}
 
+
+/* run through key_pairs and see if this token causes us to change context
+   0 = no change
+   1 = entering table context
+   2 = leaving table context
+*/
+static int tc_maybe_change_context(const char *token)
+{
+  int i;
+  for (i=0; i<TC_KEY_PAIR_COUNT; i++) {
+    if (strcasecmp(token, tc_table_key_pairs[i][0]) == 0) {
+      return 1;
+    }
+    else if (strcasecmp(token, tc_table_key_pairs[i][1]) == 0) {
+      return 2;
+    }
+  }
+  return 0;
+}
+
+
+/* return newly alloc'd string from the possible table name t_name, or NULL */
+static char *tc_frob_tablename(const char *t_name)
+{
+  const char *c= t_name;
+  /* we allocate enough for the whole tName plus '.' plus \0, but may not use
+     all of it */
+  char *new_name= (char*)my_malloc((uint)strlen(t_name)+2,MYF(MY_WME));
+  char *w= new_name;
+  memset(new_name, 0, strlen(t_name)+1);
+  while (*c != '\0') {
+    if (isalnum(*c) || *c == '_') {
+      *w++ = *c;
+    }
+    *c++;
+  }
+  *w++ = '.';
+  *w= '\0';
+  return new_name;
+}
+
+
+/* fill tArray with up to MAX_TC_TABLE_CNT table names from the SQL statement
+  in data */
+static int tc_get_table_context(const char *data, char** t_array)
+{
+
+  uint num_found= 0, i= 0, ended= 0;
+  uint table_context= 0, context_change= 0;
+  char *datacopy = strdup(data);
+  char *token, *saveptr, *t_name;
+  char delim[] = " ";
+
+  token = strtok_r(datacopy, delim, &saveptr);
+  while (token) {
+
+    context_change = tc_maybe_change_context(token);
+    if (context_change == 2) {
+      /* leaving context, no more table names */
+      ended= 1;
+      break;
+    }
+    else if (context_change == 1) {
+      /* switching to table name context */
+      table_context= 1;
+    }
+    else {
+      if (table_context) {
+        t_name = tc_frob_tablename(token);
+        if (t_name && (num_found < MAX_TC_TABLE_CNT)) {
+          /* we have a match */
+          t_array[num_found++]= t_name;
+        }
+      }
+    }
+
+    if (num_found == MAX_TC_TABLE_CNT)
+      break;
+
+    token = strtok_r(NULL, delim, &saveptr);
+  }
+
+  free(datacopy);
+
+  /* if we never ended, we don't have full context yet */
+  if (!ended)
+  {
+    for (i=0; i<num_found; i++)
+      my_free(t_array[i], MYF(MY_ALLOW_ZERO_PTR));
+    num_found= 0;
+  }
+
+  return num_found;
+
+}
+
+
+/* Build up the completion hash */
 static void build_completion_hash(bool rehash, bool write_info)
 {
   COMMANDS *cmd=commands;