fixed QC invaluidation and processing with view (BUG#8050) (BUG#8054)

mysql-test/r/view_query_cache.result

+drop table if exists t1,t2,v1,v2,v3;
+drop view if exists t1,t2,v1,v2,v3;
 set GLOBAL query_cache_size=1355776;
 flush status;
 create table t1 (a int, b int);
@@ -98,4 +100,27 @@ Qcache_hits	1
 drop view v1;
 set query_cache_type=default;
 drop table t1;
+create table t1 (a int);
+insert into t1 values (1), (2), (3);
+create view v1 as select a from t1 where a > 1;
+select * from v1;
+a
+2
+3
+alter view v1 as select a from t1 where a > 2;
+select * from v1;
+a
+3
+drop view v1;
+select * from v1;
+ERROR 42S02: Table 'test.v1' doesn't exist
+drop table t1;
+create table t1 (a int, primary key (a), b int);
+create table t2 (a int, primary key (a), b int);
+insert into t2 values (1000, 2000);
+create view v3 (a,b) as select t1.a as a, t2.a as b from t1, t2;
+select * from v3;
+a	b
+drop view v3;
+drop table t1, t2;
 set GLOBAL query_cache_size=default;

mysql-test/t/view_query_cache.test

@@ -2,6 +2,11 @@
 #
 # QUERY CACHE options for VIEWs
 #
+--disable_warnings
+drop table if exists t1,t2,v1,v2,v3;
+drop view if exists t1,t2,v1,v2,v3;
+--enable_warnings
+
 set GLOBAL query_cache_size=1355776;
 flush status;
 create table t1 (a int, b int);
@@ -53,6 +58,30 @@ drop view v1;
 set query_cache_type=default;
 
 drop table t1;
-set GLOBAL query_cache_size=default;
 
+#
+# invalidation of view
+#
+create table t1 (a int);
+insert into t1 values (1), (2), (3);
+create view v1 as select a from t1 where a > 1;
+select * from v1;
+alter view v1 as select a from t1 where a > 2;
+select * from v1;
+drop view v1;
+-- error 1146
+select * from v1;
+drop table t1;
+
+#
+# join view with QC
+#
+create table t1 (a int, primary key (a), b int);
+create table t2 (a int, primary key (a), b int);
+insert into t2 values (1000, 2000);
+create view v3 (a,b) as select t1.a as a, t2.a as b from t1, t2;
+select * from v3;
+drop view v3;
+drop table t1, t2;
 
+set GLOBAL query_cache_size=default;

sql/sql_cache.cc

@@ -311,7 +311,7 @@ TODO list:
 #include "emb_qcache.h"
 #endif
 
-#if defined(EXTRA_DEBUG) && !defined(DBUG_OFF)
+#if !defined(DBUG_OFF) && !defined(DBUG_OFF)
 #define MUTEX_LOCK(M) { DBUG_PRINT("lock", ("mutex lock 0x%lx", (ulong)(M))); \
   pthread_mutex_lock(M);}
 #define MUTEX_UNLOCK(M) {DBUG_PRINT("lock", ("mutex unlock 0x%lx",\
@@ -2089,43 +2089,55 @@ void Query_cache::invalidate_table(Query_cache_block *table_block)
   }
 }
 
-/*
-  Store all used tables
 
-  SYNOPSIS
-    register_all_tables()
-    block		Store tables in this block
-    tables_used		List if used tables
-    tables_arg		Not used ?
-*/
-
-my_bool Query_cache::register_all_tables(Query_cache_block *block,
-					 TABLE_LIST *tables_used,
-					 TABLE_COUNTER_TYPE tables_arg)
+TABLE_COUNTER_TYPE
+Query_cache::register_tables_from_list(TABLE_LIST *tables_used,
+                                       TABLE_COUNTER_TYPE counter,
+                                       Query_cache_block_table *block_table)
 {
   TABLE_COUNTER_TYPE n;
-  DBUG_PRINT("qcache", ("register tables block 0x%lx, n %d, header %x",
-		      (ulong) block, (int) tables_arg,
-		      (int) ALIGN_SIZE(sizeof(Query_cache_block))));
-
-  Query_cache_block_table *block_table = block->table(0);
-
-  for (n= 0;
+  DBUG_ENTER("Query_cache::register_tables_from_list");
+  for (n= counter;
        tables_used;
        tables_used= tables_used->next_global, n++, block_table++)
+  {
+    block_table->n= n;
+    if (tables_used->view)
+    {
+      char key[MAX_DBKEY_LENGTH];
+      uint key_length;
+      DBUG_PRINT("qcache", ("view %s, db %s",
+                            tables_used->view_name.str,
+                            tables_used->view_db.str));
+      key_length= (uint) (strmov(strmov(key, tables_used->view_db.str) + 1,
+                                 tables_used->view_name.str) - key) + 1;
+      insert_table(key_length, key, block_table,
+                   tables_used->view_db.length + 1,
+                   HA_CACHE_TBL_NONTRANSACT);
+      {
+        TABLE_COUNTER_TYPE inc= register_tables_from_list(tables_used->ancestor,
+                                                          n + 1,
+                                                          block_table + 1);
+        if (!inc)
+          DBUG_RETURN(0);
+        n+= inc;
+        block_table+= inc;
+      }
+    }
+    else
     {
       DBUG_PRINT("qcache",
                  ("table %s, db %s, openinfo at 0x%lx, keylen %u, key at 0x%lx",
-		tables_used->table_name, tables_used->db,
+                  tables_used->table->s->table_name,
+                  tables_used->table->s->table_cache_key,
                   (ulong) tables_used->table,
                   tables_used->table->s->key_length,
                   (ulong) tables_used->table->s->table_cache_key));
-    block_table->n= n;
       if (!insert_table(tables_used->table->s->key_length,
                         tables_used->table->s->table_cache_key, block_table,
                         tables_used->db_length,
                         tables_used->table->file->table_cache_type()))
-      break;
+        DBUG_RETURN(0);
 
       if (tables_used->table->s->db_type == DB_TYPE_MRG_MYISAM)
       {
@@ -2143,13 +2155,39 @@ my_bool Query_cache::register_all_tables(Query_cache_block *block,
           if (!insert_table(key_length, key, block_table,
                             db_length,
                             tables_used->table->file->table_cache_type()))
-	  goto err;
+            DBUG_RETURN(0);
+        }
       }
     }
   }
+  DBUG_RETURN(n - counter);
+}
+
+/*
+  Store all used tables
+
+  SYNOPSIS
+    register_all_tables()
+    block		Store tables in this block
+    tables_used		List if used tables
+    tables_arg		Not used ?
+*/
+
+my_bool Query_cache::register_all_tables(Query_cache_block *block,
+					 TABLE_LIST *tables_used,
+					 TABLE_COUNTER_TYPE tables_arg)
+{
+  TABLE_COUNTER_TYPE n;
+  DBUG_PRINT("qcache", ("register tables block 0x%lx, n %d, header %x",
+		      (ulong) block, (int) tables_arg,
+		      (int) ALIGN_SIZE(sizeof(Query_cache_block))));
+
+  Query_cache_block_table *block_table = block->table(0);
+
+  n= register_tables_from_list(tables_used, 0, block_table);
 
 err:
-  if (tables_used)
+  if (n)
   {
     DBUG_PRINT("qcache", ("failed at table %d", (int) n));
     /* Unlink the tables we allocated above */
@@ -2158,7 +2196,7 @@ err:
 	 tmp++)
       unlink_table(tmp);
   }
-  return (tables_used == 0);
+  return (n);
 }
 
 /*
@@ -2635,36 +2673,49 @@ void Query_cache::double_linked_list_join(Query_cache_block *head_tail,
 *****************************************************************************/
 
 /*
-  If query is cacheable return number tables in query
-  (query without tables are not cached)
+  Collect information about table types, check that tables are cachable and
+  count them
+
+  SYNOPSIS
+    process_and_count_tables()
+    tables_used     table list for processing
+    tables_type     pointer to variable for table types collection
+
+  RETURN
+    0   error
+    >0  number of tables
 */
 
-TABLE_COUNTER_TYPE Query_cache::is_cacheable(THD *thd, uint32 query_len,
-					     char *query,
-					     LEX *lex,
-					     TABLE_LIST *tables_used,
+static TABLE_COUNTER_TYPE process_and_count_tables(TABLE_LIST *tables_used,
                                                    uint8 *tables_type)
 {
+  DBUG_ENTER("process_and_count_tables");
   TABLE_COUNTER_TYPE table_count = 0;
-  DBUG_ENTER("Query_cache::is_cacheable");
-
-  if (lex->sql_command == SQLCOM_SELECT &&
-      (thd->variables.query_cache_type == 1 ||
-       (thd->variables.query_cache_type == 2 && (lex->select_lex.options &
-						 OPTION_TO_QUERY_CACHE))) &&
-      lex->safe_to_cache_query)
+  for (; tables_used; tables_used= tables_used->next_global)
   {
-    DBUG_PRINT("qcache", ("options %lx %lx, type %u",
-			OPTION_TO_QUERY_CACHE,
-			lex->select_lex.options,
-			(int) thd->variables.query_cache_type));
 
-    for (; tables_used; tables_used= tables_used->next_global)
+    if (tables_used->view)
+    {
+      DBUG_PRINT("qcache", ("view %s, db %s",
+                            tables_used->view_name.str,
+                            tables_used->view_db.str));
+      table_count++;
+      *tables_type|= HA_CACHE_TBL_NONTRANSACT;
+      {
+        TABLE_COUNTER_TYPE subcount;
+        if (!(subcount= process_and_count_tables(tables_used->ancestor,
+                                                 tables_type)))
+          DBUG_RETURN(0);
+        table_count+= subcount;
+      }
+    }
+    else
     {
       table_count++;
       DBUG_PRINT("qcache", ("table %s, db %s, type %u",
-			  tables_used->table_name,
-			  tables_used->db, tables_used->table->s->db_type));
+                            tables_used->table->s->table_name,
+                            tables_used->table->s->table_cache_key,
+                            tables_used->table->s->db_type));
       *tables_type|= tables_used->table->file->table_cache_type();
 
       /*
@@ -2674,12 +2725,13 @@ TABLE_COUNTER_TYPE Query_cache::is_cacheable(THD *thd, uint32 query_len,
       if (tables_used->table->s->tmp_table != NO_TMP_TABLE ||
           (*tables_type & HA_CACHE_TBL_NOCACHE) ||
           (tables_used->db_length == 5 &&
-	   my_strnncoll(table_alias_charset, (uchar*)tables_used->db, 6,
+           my_strnncoll(table_alias_charset,
+                        (uchar*)tables_used->table->s->table_cache_key, 6,
                         (uchar*)"mysql",6) == 0))
       {
         DBUG_PRINT("qcache",
                    ("select not cacheable: temporary, system or \
-other non-cacheable table(s)"));
+                    other non-cacheable table(s)"));
         DBUG_RETURN(0);
       }
       if (tables_used->table->s->db_type == DB_TYPE_MRG_MYISAM)
@@ -2689,6 +2741,38 @@ other non-cacheable table(s)"));
         table_count+= (file->end_table - file->open_tables);
       }
     }
+  }
+  DBUG_RETURN(table_count);
+}
+
+
+/*
+  If query is cacheable return number tables in query
+  (query without tables are not cached)
+*/
+
+TABLE_COUNTER_TYPE Query_cache::is_cacheable(THD *thd, uint32 query_len,
+					     char *query,
+					     LEX *lex,
+					     TABLE_LIST *tables_used,
+					     uint8 *tables_type)
+{
+  TABLE_COUNTER_TYPE table_count;
+  DBUG_ENTER("Query_cache::is_cacheable");
+
+  if (lex->sql_command == SQLCOM_SELECT &&
+      (thd->variables.query_cache_type == 1 ||
+       (thd->variables.query_cache_type == 2 && (lex->select_lex.options &
+						 OPTION_TO_QUERY_CACHE))) &&
+      lex->safe_to_cache_query)
+  {
+    DBUG_PRINT("qcache", ("options %lx %lx, type %u",
+			OPTION_TO_QUERY_CACHE,
+			lex->select_lex.options,
+			(int) thd->variables.query_cache_type));
+
+    if (!(table_count= process_and_count_tables(tables_used, tables_type)))
+      DBUG_RETURN(0);
 
     if ((thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) &&
 	((*tables_type)&HA_CACHE_TBL_TRANSACT))
@@ -2729,7 +2813,8 @@ my_bool Query_cache::ask_handler_allowance(THD *thd,
   for (; tables_used; tables_used= tables_used->next_global)
   {
     TABLE *table= tables_used->table;
-    if (!ha_caching_allowed(thd, table->s->table_cache_key,
+    if (table &&
+        !ha_caching_allowed(thd, table->s->table_cache_key,
                          table->s->key_length,
                          table->file->table_cache_type()))
     {

sql/sql_cache.h

@@ -277,6 +277,10 @@ protected:
   void invalidate_table(TABLE *table);
   void invalidate_table(byte *key, uint32  key_length);
   void invalidate_table(Query_cache_block *table_block);
+  TABLE_COUNTER_TYPE
+    register_tables_from_list(TABLE_LIST *tables_used,
+                              TABLE_COUNTER_TYPE counter,
+                              Query_cache_block_table *block_table);
   my_bool register_all_tables(Query_cache_block *block,
 			      TABLE_LIST *tables_used,
 			      TABLE_COUNTER_TYPE tables);

sql/sql_view.cc

@@ -305,6 +305,8 @@ bool mysql_create_view(THD *thd,
   VOID(pthread_mutex_lock(&LOCK_open));
   res= mysql_register_view(thd, view, mode);
   VOID(pthread_mutex_unlock(&LOCK_open));
+  if (view->revision != 1)
+    query_cache_invalidate3(thd, view, 0);
   start_waiting_global_read_lock(thd);
   if (res)
     goto err;
@@ -912,6 +914,7 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode)
     }
     if (my_delete(path, MYF(MY_WME)))
       goto err;
+    query_cache_invalidate3(thd, view, 0);
     VOID(pthread_mutex_unlock(&LOCK_open));
   }
   send_ok(thd);