WL#4443:

Mattias Jonsson · Mattias Jonsson · commit 0503c5dcd6e0 · 2012-05-29T19:39:36.000+02:00
Replaced check for partitioned handler with
HA_OPEN_NO_PSI_CALL, to avoid using
psi for partitions.

Changed using read_partitions to lock_partitions for pruning
of start_stmt.

Now sets m_partitions_to_reset also in ::extra() calls.

Use is_query_tables_locked() in prune_partitions() instead
of checking get_lock_type().
diff --git a/include/my_base.h b/include/my_base.h
@@ -48,6 +48,11 @@
 #define HA_OPEN_COPY			256     /* Open copy (for repair) */
 /* Internal temp table, used for temporary results */
 #define HA_OPEN_INTERNAL_TABLE          512
+/**
+  Don't connect any share_psi to the handler, since it is a partition.
+  It would not be used, since partitions don't call unbind_psi()/rebind_psi().
+*/
+#define HA_OPEN_NO_PSI_CALL             1024    /* Don't call/connect PSI */
 
 /* The following is parameter to ha_rkey() how to use key */
 
diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc
@@ -1464,7 +1464,8 @@ int ha_partition::prepare_new_partition(TABLE *tbl,
     goto error_create;
   }
   DBUG_PRINT("info", ("partition %s created", part_name));
-  if ((error= file->ha_open(tbl, part_name, m_mode, m_open_test_lock)))
+  if ((error= file->ha_open(tbl, part_name, m_mode,
+                            m_open_test_lock | HA_OPEN_NO_PSI_CALL)))
     goto error_open;
   DBUG_PRINT("info", ("partition %s opened", part_name));
   /*
@@ -3115,7 +3116,8 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
    {
       create_partition_name(name_buff, name, name_buffer_ptr, NORMAL_PART_NAME,
                             FALSE);
-      if ((error= (*file)->ha_open(table, name_buff, mode, test_if_locked)))
+      if ((error= (*file)->ha_open(table, name_buff, mode,
+                                   test_if_locked | HA_OPEN_NO_PSI_CALL)))
         goto err_handler;
       if (m_file == file)
         m_num_locks= (*file)->lock_count();
@@ -3274,7 +3276,8 @@ handler *ha_partition::clone(const char *name, MEM_ROOT *mem_root)
     goto err;
 
   if (new_handler->ha_open(table, name,
-                           table->db_stat, HA_OPEN_IGNORE_IF_LOCKED))
+                           table->db_stat,
+                           HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_NO_PSI_CALL))
     goto err;
 
   DBUG_RETURN((handler*) new_handler);
@@ -3384,14 +3387,8 @@ int ha_partition::external_lock(THD *thd, int lock_type)
   if (lock_type == F_UNLCK)
     used_partitions= &m_locked_partitions;
   else
-  {
-    /*
-      Only clear this when a new lock is taken or start_stmt is called,
-      leave it as is after unlocking to be able to prune ::reset() calls.
-    */
-    DBUG_ASSERT(bitmap_is_clear_all(&m_partitions_to_reset));
     used_partitions= &(m_part_info->lock_partitions);
-  }
+
   first_used_partition= bitmap_get_first_set(used_partitions);
 
   for (i= first_used_partition;
@@ -3414,7 +3411,8 @@ int ha_partition::external_lock(THD *thd, int lock_type)
   }
   else
   {
-    bitmap_copy(&m_partitions_to_reset, used_partitions);
+    /* Add touched partitions to be included in reset(). */
+    bitmap_union(&m_partitions_to_reset, used_partitions);
   }
 
   if (m_added_file && m_added_file[0])
@@ -3437,7 +3435,6 @@ int ha_partition::external_lock(THD *thd, int lock_type)
     (void) m_file[j]->ha_external_lock(thd, F_UNLCK);
   }
   bitmap_clear_all(&m_locked_partitions);
-  bitmap_clear_all(&m_partitions_to_reset);
   DBUG_RETURN(error);
 }
 
@@ -3538,14 +3535,13 @@ int ha_partition::start_stmt(THD *thd, thr_lock_type lock_type)
                                &m_locked_partitions));
   DBUG_ENTER("ha_partition::start_stmt");
 
-  /* Needed to clear all bits from the LOCK TABLES statement. */
-  bitmap_clear_all(&m_partitions_to_reset);
-  for (i= bitmap_get_first_set(&(m_part_info->read_partitions));
+  for (i= bitmap_get_first_set(&(m_part_info->lock_partitions));
        i < m_tot_parts;
-       i= bitmap_get_next_set(&m_part_info->read_partitions, i))
+       i= bitmap_get_next_set(&m_part_info->lock_partitions, i))
   {
     if ((error= m_file[i]->start_stmt(thd, lock_type)))
       break;
+    /* Add partition to be called in reset(). */
     bitmap_set_bit(&m_partitions_to_reset, i);
   }
   DBUG_RETURN(error);
@@ -6523,40 +6519,34 @@ int ha_partition::extra(enum ha_extra_function operation)
 }
 
 
-/*
+/**
   Special extra call to reset extra parameters
 
-  SYNOPSIS
-    reset()
-
-  RETURN VALUE
-    >0                   Error code
-    0                    Success
+  @return Operation status.
+    @retval >0 Error code
+    @retval 0  Success
 
-  DESCRIPTION
-    Called at end of each statement to reset buffers
+  @note Called at end of each statement to reset buffers.
+  To avoid excessive calls, the m_partitions_to_reset bitmap keep records
+  of which partitions that have been used in external_lock() or start_stmt()
+  and is needed to be called.
 */
 
 int ha_partition::reset(void)
 {
   int result= 0;
+  int tmp;
+  uint i;
   DBUG_ENTER("ha_partition::reset");
 
-  /* May not have m_part_info set (in case of failed open or prune). */
-  if (m_part_info && m_part_info->bitmaps_are_initialized)
+  for (i= bitmap_get_first_set(&m_partitions_to_reset);
+       i < m_tot_parts;
+       i= bitmap_get_next_set(&m_partitions_to_reset, i))
   {
-    int tmp;
-    uint i;
-
-    for (i= bitmap_get_first_set(&m_partitions_to_reset);
-         i < m_tot_parts;
-         i= bitmap_get_next_set(&m_partitions_to_reset, i))
-    {
-      if ((tmp= m_file[i]->ha_reset()))
-        result= tmp;
-    }
-    bitmap_clear_all(&m_partitions_to_reset);
+    if ((tmp= m_file[i]->ha_reset()))
+      result= tmp;
   }
+  bitmap_clear_all(&m_partitions_to_reset);
   DBUG_RETURN(result);
 }
 
@@ -6603,6 +6593,9 @@ void ha_partition::prepare_extra_cache(uint cachesize)
   m_extra_cache_size= cachesize;
   if (m_part_spec.start_part != NO_CURRENT_PART_ID)
   {
+    DBUG_ASSERT(bitmap_is_set(&m_partitions_to_reset,
+                              m_part_spec.start_part));
+    bitmap_set_bit(&m_partitions_to_reset, m_part_spec.start_part);
     late_extra_cache(m_part_spec.start_part);
   }
   DBUG_VOID_RETURN;
@@ -6669,6 +6662,8 @@ int ha_partition::loop_extra(enum ha_extra_function operation)
     if ((tmp= m_file[i]->extra(operation)))
       result= tmp;
   }
+  /* Add all used partitions to be called in reset(). */
+  bitmap_union(&m_partitions_to_reset, &m_part_info->lock_partitions);
   DBUG_RETURN(result);
 }
 
diff --git a/sql/handler.cc b/sql/handler.cc
@@ -2359,11 +2359,9 @@ int handler::ha_open(TABLE *table_arg, const char *name, int mode,
     /*
       Do not call this for partitions handlers, since it may take too much
       resources.
-      If a table is partitioned it's main handler will be ha_partition and
-      its partitions handlers will be the normal handlers, like ha_innobase.
       So only use the m_psi on table level, not for individual partitions.
     */
-    if (ht == table->file->ht)
+    if (test_if_locked & HA_OPEN_NO_PSI_CALL)
     {
       PSI_table_share *share_psi= ha_table_share_psi(table_share);
       m_psi= PSI_TABLE_CALL(open_table)(share_psi, this);
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
@@ -3237,12 +3237,13 @@ bool prune_partitions(THD *thd, TABLE *table, Item *pprune_cond)
                    &prune_param.part_info->lock_partitions);
   /*
     If not yet locked, also prune partitions to lock if not UPDATEing
-    partition key fields.
+    partition key fields. This will also prune lock_partitions if we are under
+    LOCK TABLES, so prune away calls to start_stmt().
     TODO: enhance this prune locking to also allow pruning of
     'UPDATE t SET part_key = const WHERE cond_is_prunable' so it adds
     a lock for part_key partition.
   */
-  if (table->file->get_lock_type() == F_UNLCK &&
+  if (!thd->lex->is_query_tables_locked() &&
       !partition_key_modified(table, table->write_set))
   {
     bitmap_copy(&prune_param.part_info->lock_partitions,
