WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).

HEAP: Copies the key count to a backup variable and sets the key count to zero.
That way, no HEAP function will ever try to touch any index.
Re-enabling is done by copying back the backup variable.
To avoid memory leak at table close, disable deletes all index trees.
Re-enabling must be done with empty indexes and data anyway. Otherwise,
the indexes would need to be repaired, wich HEAP is not capable of.
MyISAM: Only the key_map is cleared and set.
Re-enabling must be done with empty indexes and data. Otherwise, repair needs
to be done which will enable all keys persistently.
The former implementation disabled only non-unique keys and maked this persistent.
The new implementation additionally can disable all keys, but only without
making this persistent. Re-enabling all keys can be done without repair,
if data file and indexes are empty.


heap/heapdef.h:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Pulled hp_clear_keys() out of hp_clear().
heap/hp_clear.c:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Pulled hp_clear_keys() out of hp_clear().
  Added the new functions for disabling and enabling keys and to ask for the key state.
include/heap.h:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Added a new HP_SHARE element to save the key count while keys are disabled.
  Added declarations for the new functions.
myisam/mi_open.c:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Added the new functions for disabling and enabling keys and to ask for the key state.
myisam/myisamdef.h:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Added declarations for the new functions.
sql/ha_heap.cc:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Pulled set_keys_for_scanning() out of open().
  Added the new functions for disabling and enabling keys and to ask for the key state.
sql/ha_heap.h:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Added declarations for the new functions.
sql/ha_myisam.cc:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Extended disable_indexes() for all keys and no save.
  The argument is now 'mode' as it must handle different cases.
  Extended enable_indexes() for no save.
  The new feature needs the new argument 'mode' with the same semantics as in disable_indexes().
  Added indexes_are_disabled() to ask for the key state.
  Extended the existing call to enable_indexes() by the new argument.
sql/ha_myisam.h:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Modified the declarations of dis-/enable_indexes() for the new argument.
  Added the declaration of the new function to ask for the key state.
sql/handler.h:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Added declarations for the operation modes for the key switching functions.
  Modified the declarations of dis-/enable_indexes() for the new argument.
  Added the declaration of the new function to ask for the key state.
sql/sql_select.cc:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  In create_myisam_from_heap() take notice of disabled keys
  and disable them in the new table before copying the data.
sql/sql_table.cc:
  WL#1687 - Optimize UNION DISTINCT ... UNION ALL (again).
  Modified the calls of dis-/enable_indexes() for the new argument.

1 files changed, 130 insertions, 30 deletions

diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc
index b9d6cec38aa..1b24633953d 100644
--- a/sql/ha_myisam.cc
+++ b/sql/ha_myisam.cc
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+/* Copyright (C) 2000,2004 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -810,47 +810,146 @@ int ha_myisam::preload_keys(THD* thd, HA_CHECK_OPT *check_opt)
   }
 }
 
+
 /*
-  disable indexes, making it persistent if requested
+  Disable indexes, making it persistent if requested.
+
   SYNOPSIS
-    disable_indexes(all, save)
-    all         disable all indexes
-                if not set only non-unique indexes will be disabled
-                [all=1 is NOT IMPLEMENTED YET]
-    save        save the disabled state, so that it will persist
-                between queries/threads/reboots
-                [save=0 is NOT IMPLEMENTED YET]
+    disable_indexes()
+    mode        mode of operation:
+                HA_KEY_SWITCH_NONUNIQ      disable all non-unique keys
+                HA_KEY_SWITCH_ALL          disable all keys
+                HA_KEY_SWITCH_NONUNIQ_SAVE dis. non-uni. and make persistent
+                HA_KEY_SWITCH_ALL_SAVE     dis. all keys and make persistent
+
+  IMPLEMENTATION
+    HA_KEY_SWITCH_NONUNIQ       is not implemented.
+    HA_KEY_SWITCH_ALL_SAVE      is not implemented.
+
+  RETURN
+    0  ok
+    HA_ERR_WRONG_COMMAND  mode not implemented.
 */
-int ha_myisam::disable_indexes(bool all, bool save)
+
+int ha_myisam::disable_indexes(uint mode)
 {
-  mi_extra(file, HA_EXTRA_NO_KEYS, 0);
-  info(HA_STATUS_CONST);                        // Read new key info
-  return 0;
+  int error;
+
+  if (mode == HA_KEY_SWITCH_ALL)
+  {
+    /* call a storage engine function to switch the key map */
+    error= mi_disable_indexes(file);
+  }
+  else if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE)
+  {
+    mi_extra(file, HA_EXTRA_NO_KEYS, 0);
+    info(HA_STATUS_CONST);                        // Read new key info
+    error= 0;
+  }
+  else
+  {
+    /* mode not implemented */
+    error= HA_ERR_WRONG_COMMAND;
+  }
+  return error;
 }
 
-int ha_myisam::enable_indexes()
+
+/*
+  Enable indexes, making it persistent if requested.
+
+  SYNOPSIS
+    enable_indexes()
+    mode        mode of operation:
+                HA_KEY_SWITCH_NONUNIQ      enable all non-unique keys
+                HA_KEY_SWITCH_ALL          enable all keys
+                HA_KEY_SWITCH_NONUNIQ_SAVE en. non-uni. and make persistent
+                HA_KEY_SWITCH_ALL_SAVE     en. all keys and make persistent
+
+  DESCRIPTION
+    Enable indexes, which might have been disabled by disable_index() before.
+    The modes without _SAVE work only if both data and indexes are empty,
+    since the MyISAM repair would enable them persistently.
+    To be sure in these cases, call handler::delete_all_rows() before.
+
+  IMPLEMENTATION
+    HA_KEY_SWITCH_NONUNIQ       is not implemented.
+    HA_KEY_SWITCH_ALL_SAVE      is not implemented.
+
+  RETURN
+    0  ok
+    !=0  Error, among others:
+    HA_ERR_CRASHED  data or index is non-empty. Delete all rows and retry.
+    HA_ERR_WRONG_COMMAND  mode not implemented.
+*/
+
+int ha_myisam::enable_indexes(uint mode)
 {
+  int error;
+
   if (file->s->state.key_map == set_bits(ulonglong, file->s->base.keys))
+  {
+    /* All indexes are enabled already. */
     return 0;
+  }
 
-  int error=0;
-  THD *thd=current_thd;
-  MI_CHECK param;
-  const char *save_proc_info=thd->proc_info;
-  thd->proc_info="Creating index";
-  myisamchk_init(&param);
-  param.op_name = (char*) "recreating_index";
-  param.testflag = (T_SILENT | T_REP_BY_SORT | T_QUICK |
-                    T_CREATE_MISSING_KEYS);
-  param.myf_rw&= ~MY_WAIT_IF_FULL;
-  param.sort_buffer_length=  thd->variables.myisam_sort_buff_size;
-  param.tmpdir=&mysql_tmpdir_list;
-  error=repair(thd,param,0) != HA_ADMIN_OK;
-  info(HA_STATUS_CONST);
-  thd->proc_info=save_proc_info;
+  if (mode == HA_KEY_SWITCH_ALL)
+  {
+    error= mi_enable_indexes(file);
+    /*
+       Do not try to repair on error,
+       as this could make the enabled state persistent,
+       but mode==HA_KEY_SWITCH_ALL forbids it.
+    */
+  }
+  else if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE)
+  {
+    THD *thd=current_thd;
+    MI_CHECK param;
+    const char *save_proc_info=thd->proc_info;
+    thd->proc_info="Creating index";
+    myisamchk_init(&param);
+    param.op_name = (char*) "recreating_index";
+    param.testflag = (T_SILENT | T_REP_BY_SORT | T_QUICK |
+                      T_CREATE_MISSING_KEYS);
+    param.myf_rw&= ~MY_WAIT_IF_FULL;
+    param.sort_buffer_length=  thd->variables.myisam_sort_buff_size;
+    param.tmpdir=&mysql_tmpdir_list;
+    error=repair(thd,param,0) != HA_ADMIN_OK;
+    info(HA_STATUS_CONST);
+    thd->proc_info=save_proc_info;
+  }
+  else
+  {
+    /* mode not implemented */
+    error= HA_ERR_WRONG_COMMAND;
+  }
   return error;
 }
 
+
+/*
+  Test if indexes are disabled.
+
+
+  SYNOPSIS
+    indexes_are_disabled()
+      no parameters
+
+
+  RETURN
+    0  indexes are not disabled
+    1  all indexes are disabled
+   [2  non-unique indexes are disabled - NOT YET IMPLEMENTED]
+*/
+
+int ha_myisam::indexes_are_disabled(void)
+{
+  
+  return mi_indexes_are_disabled(file);
+}
+
+
 /*
   prepare for a many-rows insert operation
   e.g. - disable indexes (if they can be recreated fast) or
@@ -898,7 +997,8 @@ int ha_myisam::end_bulk_insert()
 {
   mi_end_bulk_insert(file);
   int err=mi_extra(file, HA_EXTRA_NO_CACHE, 0);
-  return err ? err : can_enable_indexes ? enable_indexes() : 0;
+  return err ? err : can_enable_indexes ?
+                     enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE) : 0;
 }