An improvement of the fix for the bug #2231: string column,

INDEX+LIKE, don't take the ESCAPE character. (ver. 2)

3 files changed, 21 insertions, 15 deletions

diff --git a/mysql-test/r/func_like.result b/mysql-test/r/func_like.result
index 0f94348a5f8..b196b50f53b 100644
--- a/mysql-test/r/func_like.result
+++ b/mysql-test/r/func_like.result
@@ -42,4 +42,7 @@ insert into t1 values ('a'), ('a\\b');
 select * from t1 where a like 'a\\%' escape '#';
 a
 a\b
+select * from t1 where a like 'a\\%' escape '#' and a like 'a\\\\b';
+a
+a\b
 drop table t1;
diff --git a/mysql-test/t/func_like.test b/mysql-test/t/func_like.test
index 1e14c70a76a..6d6ee8f86a3 100644
--- a/mysql-test/t/func_like.test
+++ b/mysql-test/t/func_like.test
@@ -29,4 +29,5 @@ drop table t1;
 create table t1 (a varchar(10), key(a));
 insert into t1 values ('a'), ('a\\b');
 select * from t1 where a like 'a\\%' escape '#';
+select * from t1 where a like 'a\\%' escape '#' and a like 'a\\\\b';
 drop table t1;
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index c918635b61f..bed1b52a79a 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -290,7 +290,7 @@ typedef struct st_qsel_param {
   char min_key[MAX_KEY_LENGTH+MAX_FIELD_WIDTH],
     max_key[MAX_KEY_LENGTH+MAX_FIELD_WIDTH];
   bool quick;				// Don't calulate possible keys
-  char escape;
+  COND *cond;
 } PARAM;
 
 static SEL_TREE * get_mm_parts(PARAM *param,Field *field,
@@ -638,9 +638,6 @@ int SQL_SELECT::test_quick_select(THD *thd, key_map keys_to_use,
     param.table=head;
     param.keys=0;
     param.mem_root= &alloc;
-    if (cond->type() == Item::FUNC_ITEM &&
-        ((Item_func*)cond)->functype() == Item_func::LIKE_FUNC)
-      param.escape= ((Item_func_like*)cond)->escape;
     param.thd->no_errors=1;			// Don't warn about NULL
     init_sql_alloc(&alloc, param.thd->variables.range_alloc_block_size, 0);
     if (!(param.key_parts = (KEY_PART*) alloc_root(&alloc,
@@ -821,6 +818,8 @@ static SEL_TREE *get_mm_tree(PARAM *param,COND *cond)
   if (cond_func->select_optimize() == Item_func::OPTIMIZE_NONE)
     DBUG_RETURN(0);				// Can't be calculated
 
+  param->cond= cond;
+
   if (cond_func->functype() == Item_func::BETWEEN)
   {
     if (cond_func->arguments()[0]->type() == Item::FIELD_ITEM)
@@ -997,23 +996,26 @@ get_mm_leaf(PARAM *param, Field *field, KEY_PART *key_part,
     if (maybe_null)
       max_str[0]= min_str[0]=0;
     if (field->binary())
-      like_error=like_range(res->ptr(),res->length(),param->escape,field_length,
-			    min_str+offset,max_str+offset,(char) 255,
-			    &min_length,&max_length);
+      like_error=like_range(res->ptr(), res->length(),
+			    ((Item_func_like*)(param->cond))->escape,
+			    field_length, min_str + offset, max_str + offset,
+			    (char) 255, &min_length, &max_length);
     else
     {
 #ifdef USE_STRCOLL
       if (use_strcoll(default_charset_info))
-        like_error= my_like_range(default_charset_info,
-                                  res->ptr(),res->length(),param->escape,
-                                  field_length, min_str+maybe_null,
-                                  max_str+maybe_null,&min_length,&max_length);
+        like_error= my_like_range(default_charset_info, res->ptr(),
+				  res->length(),
+				  ((Item_func_like*)(param->cond))->escape,
+                                  field_length, min_str + maybe_null,
+                                  max_str + maybe_null, &min_length,
+				  &max_length);
       else
 #endif
-        like_error=like_range(res->ptr(),res->length(),param->escape,
-			      field_length,
-                              min_str+offset,max_str+offset,
-                              max_sort_char,&min_length,&max_length);
+        like_error=like_range(res->ptr(), res->length(),
+			      ((Item_func_like*)(param->cond))->escape,
+			      field_length, min_str + offset, max_str + offset,
+                              max_sort_char, &min_length, &max_length);
     }
     if (like_error)				// Can't optimize with LIKE
       DBUG_RETURN(0);