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

mysql-test/r/view_query_cache.result:
  Fixed test to be environment independ
  Invalidation of view checked
  Join view with QC checked
mysql-test/t/view_query_cache.test:
  Fixed test to be environment independ
  Invalidation of view checked
  Join view with QC checked
sql/sql_cache.cc:
  support of VIEW added to QC
sql/sql_cache.h:
  support of VIEW added to QC
sql/sql_view.cc:
  invalidation of QC added to altering/droping VIEW commands

3 files changed, 164 insertions, 72 deletions

diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc
index f4345f8ce28..fdd55e75e95 100644
--- a/sql/sql_cache.cc
+++ b/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,6 +2089,80 @@ void Query_cache::invalidate_table(Query_cache_block *table_block)
   }
 }
 
+
+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_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->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));
+      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()))
+        DBUG_RETURN(0);
+
+      if (tables_used->table->s->db_type == DB_TYPE_MRG_MYISAM)
+      {
+        ha_myisammrg *handler = (ha_myisammrg *) tables_used->table->file;
+        MYRG_INFO *file = handler->myrg_info();
+        for (MYRG_TABLE *table = file->open_tables;
+             table != file->end_table ;
+             table++)
+        {
+          char key[MAX_DBKEY_LENGTH];
+          uint32 db_length;
+          uint key_length= filename_2_table_key(key, table->table->filename,
+                                                &db_length);
+          (++block_table)->n= ++n;
+          if (!insert_table(key_length, key, block_table,
+                            db_length,
+                            tables_used->table->file->table_cache_type()))
+            DBUG_RETURN(0);
+        }
+      }
+    }
+  }
+  DBUG_RETURN(n - counter);
+}
+
 /*
   Store all used tables
 
@@ -2110,46 +2184,10 @@ my_bool Query_cache::register_all_tables(Query_cache_block *block,
 
   Query_cache_block_table *block_table = block->table(0);
 
-  for (n= 0;
-       tables_used;
-       tables_used= tables_used->next_global, n++, block_table++)
-  {
-    DBUG_PRINT("qcache",
-	       ("table %s, db %s, openinfo at 0x%lx, keylen %u, key at 0x%lx",
-		tables_used->table_name, tables_used->db,
-		(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;
-
-    if (tables_used->table->s->db_type == DB_TYPE_MRG_MYISAM)
-    {
-      ha_myisammrg *handler = (ha_myisammrg *) tables_used->table->file;
-      MYRG_INFO *file = handler->myrg_info();
-      for (MYRG_TABLE *table = file->open_tables;
-	   table != file->end_table ;
-	   table++)
-      {
-	char key[MAX_DBKEY_LENGTH];
-	uint32 db_length;
-	uint key_length= filename_2_table_key(key, table->table->filename,
-					      &db_length);
-	(++block_table)->n= ++n;
-	if (!insert_table(key_length, key, block_table,
-			  db_length,
-			  tables_used->table->file->table_cache_type()))
-	  goto err;
-      }
-    }
-  }
+  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,6 +2673,80 @@ void Query_cache::double_linked_list_join(Query_cache_block *head_tail,
 *****************************************************************************/
 
 /*
+  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
+*/
+
+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;
+  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->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();
+
+      /*
+        table_alias_charset used here because it depends of
+        lower_case_table_names variable
+      */
+      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->table->s->table_cache_key, 6,
+                        (uchar*)"mysql",6) == 0))
+      {
+        DBUG_PRINT("qcache",
+                   ("select not cacheable: temporary, system or \
+                    other non-cacheable table(s)"));
+        DBUG_RETURN(0);
+      }
+      if (tables_used->table->s->db_type == DB_TYPE_MRG_MYISAM)
+      {
+        ha_myisammrg *handler = (ha_myisammrg *)tables_used->table->file;
+        MYRG_INFO *file = handler->myrg_info();
+        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)
 */
@@ -2645,7 +2757,7 @@ TABLE_COUNTER_TYPE Query_cache::is_cacheable(THD *thd, uint32 query_len,
 					     TABLE_LIST *tables_used,
 					     uint8 *tables_type)
 {
-  TABLE_COUNTER_TYPE table_count = 0;
+  TABLE_COUNTER_TYPE table_count;
   DBUG_ENTER("Query_cache::is_cacheable");
 
   if (lex->sql_command == SQLCOM_SELECT &&
@@ -2659,36 +2771,8 @@ TABLE_COUNTER_TYPE Query_cache::is_cacheable(THD *thd, uint32 query_len,
 			lex->select_lex.options,
 			(int) thd->variables.query_cache_type));
 
-    for (; tables_used; tables_used= tables_used->next_global)
-    {
-      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_type|= tables_used->table->file->table_cache_type();
-
-      /*
-	table_alias_charset used here because it depends of
-	lower_case_table_names variable
-      */
-      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,
-			(uchar*)"mysql",6) == 0))
-      {
-	DBUG_PRINT("qcache", 
-		   ("select not cacheable: temporary, system or \
-other non-cacheable table(s)"));
-	DBUG_RETURN(0);
-      }
-      if (tables_used->table->s->db_type == DB_TYPE_MRG_MYISAM)
-      {
-	ha_myisammrg *handler = (ha_myisammrg *)tables_used->table->file;
-	MYRG_INFO *file = handler->myrg_info();
-	table_count+= (file->end_table - file->open_tables);
-      }
-    }
+    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()))
     {
diff --git a/sql/sql_cache.h b/sql/sql_cache.h
index 93d89aeae4f..704b36eea11 100644
--- a/sql/sql_cache.h
+++ b/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);
diff --git a/sql/sql_view.cc b/sql/sql_view.cc
index e2c4b1289fd..01c71599a8e 100644
--- a/sql/sql_view.cc
+++ b/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);