Merge janus.mylan:/usr/home/serg/Abk/mysql-5.1

into  janus.mylan:/usr/home/serg/Abk/mysql-maria


include/my_sys.h:
  Auto merged
mysql-test/lib/mtr_cases.pl:
  Auto merged
mysql-test/lib/mtr_misc.pl:
  Auto merged
mysql-test/mysql-test-run.pl:
  Auto merged
mysql-test/r/ps_2myisam.result:
  Auto merged
mysql-test/r/ps_3innodb.result:
  Auto merged
mysql-test/r/ps_4heap.result:
  Auto merged
mysql-test/r/ps_5merge.result:
  Auto merged
mysql-test/r/query_cache.result:
  Auto merged
mysql-test/r/subselect.result:
  Auto merged
mysql-test/r/view.result:
  Auto merged
mysql-test/suite/binlog/r/binlog_unsafe.result:
  Auto merged
mysql-test/suite/binlog/t/binlog_unsafe.test:
  Auto merged
mysql-test/suite/ndb/r/ps_7ndb.result:
  Auto merged
mysql-test/suite/rpl/r/rpl_switch_stm_row_mixed.result:
  Auto merged
mysql-test/suite/rpl/t/rpl_insert.test:
  Auto merged
mysql-test/suite/rpl/t/rpl_switch_stm_row_mixed.test:
  Auto merged
mysql-test/t/disabled.def:
  Auto merged
mysql-test/t/query_cache.test:
  Auto merged
mysql-test/t/subselect.test:
  Auto merged
mysql-test/t/view.test:
  Auto merged
sql/field.h:
  Auto merged
sql/filesort.cc:
  Auto merged
sql/ha_partition.cc:
  Auto merged
sql/handler.cc:
  Auto merged
sql/item_func.cc:
  Auto merged
sql/item_strfunc.h:
  Auto merged
sql/log.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/opt_range.cc:
  Auto merged
sql/set_var.cc:
  Auto merged
sql/set_var.h:
  Auto merged
sql/slave.cc:
  Auto merged
sql/slave.h:
  Auto merged
sql/sp_head.cc:
  Auto merged
sql/sql_class.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_delete.cc:
  Auto merged
sql/sql_insert.cc:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_show.cc:
  Auto merged
sql/sql_table.cc:
  Auto merged
sql/sql_union.cc:
  Auto merged
sql/sql_update.cc:
  Auto merged
sql/sql_yacc.yy:
  Auto merged
sql/unireg.cc:
  Auto merged
sql/share/errmsg.txt:
  Auto merged
storage/myisam/ft_boolean_search.c:
  Auto merged
storage/myisam/ha_myisam.cc:
  Auto merged
storage/myisam/sort.c:
  Auto merged
sql/log_event_old.h:
  SCCS merged
BitKeeper/triggers/post-commit:
  merged
client/mysqldump.c:
  merged
configure.in:
  merged
client/mysqltest.c:
  merged
include/Makefile.am:
  merged
include/atomic/nolock.h:
  merged
mysql-test/lib/mtr_report.pl:
  merged
sql/handler.h:
  merged
sql/mysqld.cc:
  merged
sql/sql_select.cc:
  merged

1 files changed, 332 insertions, 5 deletions

diff --git a/sql/handler.cc b/sql/handler.cc
index 6489041eaf1..421708e5958 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -1477,7 +1477,7 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
     DBUG_RETURN(ENOENT);
 
   path= check_lowercase_names(file, path, tmp_path);
-  if ((error= file->delete_table(path)) && generate_warning)
+  if ((error= file->ha_delete_table(path)) && generate_warning)
   {
     /*
       Because file->print_error() use my_error() to generate the error message
@@ -1496,8 +1496,7 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
     dummy_share.table_name.length= strlen(alias);
     dummy_table.alias= alias;
 
-    file->table_share= &dummy_share;
-    file->table= &dummy_table;
+    file->change_table_ptr(&dummy_table, &dummy_share);
 
     thd->push_internal_handler(&ha_delete_table_error_handler);
     file->print_error(error, 0);
@@ -2506,6 +2505,12 @@ int handler::ha_check(THD *thd, HA_CHECK_OPT *check_opt)
 }
 
 
+/**
+  Repair table: public interface.
+
+  @sa handler::repair()
+*/
+
 int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
 {
   int result;
@@ -2516,6 +2521,328 @@ int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
 
 
 /**
+  Bulk update row: public interface.
+
+  @sa handler::bulk_update_row()
+*/
+
+int
+handler::ha_bulk_update_row(const uchar *old_data, uchar *new_data,
+                            uint *dup_key_found)
+{
+  return bulk_update_row(old_data, new_data, dup_key_found);
+}
+
+
+/**
+  Delete all rows: public interface.
+
+  @sa handler::delete_all_rows()
+*/
+
+int
+handler::ha_delete_all_rows()
+{
+  return delete_all_rows();
+}
+
+
+/**
+  Reset auto increment: public interface.
+
+  @sa handler::reset_auto_increment()
+*/
+
+int
+handler::ha_reset_auto_increment(ulonglong value)
+{
+  return reset_auto_increment(value);
+}
+
+
+/**
+  Backup table: public interface.
+
+  @sa handler::backup()
+*/
+
+int
+handler::ha_backup(THD* thd, HA_CHECK_OPT* check_opt)
+{
+  return backup(thd, check_opt);
+}
+
+
+/**
+  Restore table: public interface.
+
+  @sa handler::restore()
+*/
+
+int
+handler::ha_restore(THD* thd, HA_CHECK_OPT* check_opt)
+{
+  return restore(thd, check_opt);
+}
+
+
+/**
+  Optimize table: public interface.
+
+  @sa handler::optimize()
+*/
+
+int
+handler::ha_optimize(THD* thd, HA_CHECK_OPT* check_opt)
+{
+  return optimize(thd, check_opt);
+}
+
+
+/**
+  Analyze table: public interface.
+
+  @sa handler::analyze()
+*/
+
+int
+handler::ha_analyze(THD* thd, HA_CHECK_OPT* check_opt)
+{
+  return analyze(thd, check_opt);
+}
+
+
+/**
+  Check and repair table: public interface.
+
+  @sa handler::check_and_repair()
+*/
+
+bool
+handler::ha_check_and_repair(THD *thd)
+{
+  return check_and_repair(thd);
+}
+
+
+/**
+  Disable indexes: public interface.
+
+  @sa handler::disable_indexes()
+*/
+
+int
+handler::ha_disable_indexes(uint mode)
+{
+  return disable_indexes(mode);
+}
+
+
+/**
+  Enable indexes: public interface.
+
+  @sa handler::enable_indexes()
+*/
+
+int
+handler::ha_enable_indexes(uint mode)
+{
+  return enable_indexes(mode);
+}
+
+
+/**
+  Discard or import tablespace: public interface.
+
+  @sa handler::discard_or_import_tablespace()
+*/
+
+int
+handler::ha_discard_or_import_tablespace(my_bool discard)
+{
+  return discard_or_import_tablespace(discard);
+}
+
+
+/**
+  Prepare for alter: public interface.
+
+  Called to prepare an *online* ALTER.
+
+  @sa handler::prepare_for_alter()
+*/
+
+void
+handler::ha_prepare_for_alter()
+{
+  prepare_for_alter();
+}
+
+
+/**
+  Rename table: public interface.
+
+  @sa handler::rename_table()
+*/
+
+int
+handler::ha_rename_table(const char *from, const char *to)
+{
+  return rename_table(from, to);
+}
+
+
+/**
+  Delete table: public interface.
+
+  @sa handler::delete_table()
+*/
+
+int
+handler::ha_delete_table(const char *name)
+{
+  return delete_table(name);
+}
+
+
+/**
+  Drop table in the engine: public interface.
+
+  @sa handler::drop_table()
+*/
+
+void
+handler::ha_drop_table(const char *name)
+{
+  return drop_table(name);
+}
+
+
+/**
+  Create a table in the engine: public interface.
+
+  @sa handler::create()
+*/
+
+int
+handler::ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info)
+{
+  return create(name, form, info);
+}
+
+
+/**
+  Create handler files for CREATE TABLE: public interface.
+
+  @sa handler::create_handler_files()
+*/
+
+int
+handler::ha_create_handler_files(const char *name, const char *old_name,
+                        int action_flag, HA_CREATE_INFO *info)
+{
+  return create_handler_files(name, old_name, action_flag, info);
+}
+
+
+/**
+  Change partitions: public interface.
+
+  @sa handler::change_partitions()
+*/
+
+int
+handler::ha_change_partitions(HA_CREATE_INFO *create_info,
+                     const char *path,
+                     ulonglong *copied,
+                     ulonglong *deleted,
+                     const uchar *pack_frm_data,
+                     size_t pack_frm_len)
+{
+  return change_partitions(create_info, path, copied, deleted,
+                           pack_frm_data, pack_frm_len);
+}
+
+
+/**
+  Drop partitions: public interface.
+
+  @sa handler::drop_partitions()
+*/
+
+int
+handler::ha_drop_partitions(const char *path)
+{
+  return drop_partitions(path);
+}
+
+
+/**
+  Rename partitions: public interface.
+
+  @sa handler::rename_partitions()
+*/
+
+int
+handler::ha_rename_partitions(const char *path)
+{
+  return rename_partitions(path);
+}
+
+
+/**
+  Optimize partitions: public interface.
+
+  @sa handler::optimize_partitions()
+*/
+
+int
+handler::ha_optimize_partitions(THD *thd)
+{
+  return optimize_partitions(thd);
+}
+
+
+/**
+  Analyze partitions: public interface.
+
+  @sa handler::analyze_partitions()
+*/
+
+int
+handler::ha_analyze_partitions(THD *thd)
+{
+  return analyze_partitions(thd);
+}
+
+
+/**
+  Check partitions: public interface.
+
+  @sa handler::check_partitions()
+*/
+
+int
+handler::ha_check_partitions(THD *thd)
+{
+  return check_partitions(thd);
+}
+
+
+/**
+  Repair partitions: public interface.
+
+  @sa handler::repair_partitions()
+*/
+
+int
+handler::ha_repair_partitions(THD *thd)
+{
+  return repair_partitions(thd);
+}
+
+
+/**
   Tell the storage engine that it is allowed to "disable transaction" in the
   handler. It is a hint that ACID is not required - it is used in NDB for
   ALTER TABLE, for example, when data are copied to temporary table.
@@ -2655,7 +2982,7 @@ int ha_create_table(THD *thd, const char *path,
 
   name= check_lowercase_names(table.file, share.path.str, name_buff);
 
-  error= table.file->create(name, &table, create_info);
+  error= table.file->ha_create(name, &table, create_info);
   VOID(closefrm(&table, 0));
   if (error)
   {
@@ -2726,7 +3053,7 @@ int ha_create_table_from_engine(THD* thd, const char *db, const char *name)
   create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
 
   check_lowercase_names(table.file, path, path);
-  error=table.file->create(path,&table,&create_info);
+  error=table.file->ha_create(path, &table, &create_info);
   VOID(closefrm(&table, 1));
 
   DBUG_RETURN(error != 0);