~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2006 MySQL 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

   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#ifdef USE_PRAGMA_IMPLEMENTATION

#pragma implementation				// gcc: Class implementation

#endif

#define MYSQL_SERVER 1

#include <drizzled/mysql_priv.h>

#include <mystrings/m_ctype.h>

#include <mysys/my_bit.h>

#include <myisampack.h>

#include "ha_myisam.h"

#include <stdarg.h>

#include "myisamdef.h"

#include <drizzled/drizzled_error_messages.h>

ulong myisam_recover_options= HA_RECOVER_NONE;

/* bits in myisam_recover_options */

const char *myisam_recover_names[] =

{ "DEFAULT", "BACKUP", "FORCE", "QUICK", NullS};

TYPELIB myisam_recover_typelib= {array_elements(myisam_recover_names)-1,"",

				 myisam_recover_names, NULL};

const char *myisam_stats_method_names[] = {"nulls_unequal", "nulls_equal",

                                           "nulls_ignored", NullS};

TYPELIB myisam_stats_method_typelib= {

  array_elements(myisam_stats_method_names) - 1, "",

  myisam_stats_method_names, NULL};

/*****************************************************************************

** MyISAM tables

*****************************************************************************/

static handler *myisam_create_handler(handlerton *hton,

                                      TABLE_SHARE *table, 

                                      MEM_ROOT *mem_root)

{

  return new (mem_root) ha_myisam(hton, table);

}

// collect errors printed by mi_check routines

static void mi_check_print_msg(MI_CHECK *param,	const char* msg_type,

			       const char *fmt, va_list args)

{

  THD* thd = (THD*)param->thd;

  Protocol *protocol= thd->protocol;

  uint length, msg_length;

  char msgbuf[MI_MAX_MSG_BUF];

  char name[NAME_LEN*2+2];

  msg_length= vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);

  msgbuf[sizeof(msgbuf) - 1] = 0; // healthy paranoia

  if (!thd->vio_ok())

  {

    sql_print_error(msgbuf);

    return;

  }

  if (param->testflag & (T_CREATE_MISSING_KEYS | T_SAFE_REPAIR |

			 T_AUTO_REPAIR))

  {

    my_message(ER_NOT_KEYFILE,msgbuf,MYF(MY_WME));

    return;

  }

  length=(uint) (strxmov(name, param->db_name,".",param->table_name,NullS) -

		 name);

  /*

    TODO: switch from protocol to push_warning here. The main reason we didn't

    it yet is parallel repair. Due to following trace:

    mi_check_print_msg/push_warning/sql_alloc/my_pthread_getspecific_ptr.

    Also we likely need to lock mutex here (in both cases with protocol and

    push_warning).

  */

  protocol->prepare_for_resend();

  protocol->store(name, length, system_charset_info);

  protocol->store(param->op_name, system_charset_info);

  protocol->store(msg_type, system_charset_info);

  protocol->store(msgbuf, msg_length, system_charset_info);

  if (protocol->write())

    sql_print_error("Failed on my_net_write, writing to stderr instead: %s\n",

		    msgbuf);

  return;

}

/*

  Convert TABLE object to MyISAM key and column definition

  SYNOPSIS

    table2myisam()

      table_arg   in     TABLE object.

      keydef_out  out    MyISAM key definition.

      recinfo_out out    MyISAM column definition.

      records_out out    Number of fields.

  DESCRIPTION

    This function will allocate and initialize MyISAM key and column

    definition for further use in mi_create or for a check for underlying

    table conformance in merge engine.

    The caller needs to free *recinfo_out after use. Since *recinfo_out

    and *keydef_out are allocated with a my_multi_malloc, *keydef_out

    is freed automatically when *recinfo_out is freed.

  RETURN VALUE

    0  OK

    !0 error code

*/

int table2myisam(TABLE *table_arg, MI_KEYDEF **keydef_out,

                 MI_COLUMNDEF **recinfo_out, uint *records_out)

{

  uint i, j, recpos, minpos, fieldpos, temp_length, length;

  enum ha_base_keytype type= HA_KEYTYPE_BINARY;

  uchar *record;

  KEY *pos;

  MI_KEYDEF *keydef;

  MI_COLUMNDEF *recinfo, *recinfo_pos;

  HA_KEYSEG *keyseg;

  TABLE_SHARE *share= table_arg->s;

  uint options= share->db_options_in_use;

  if (!(my_multi_malloc(MYF(MY_WME),

          recinfo_out, (share->fields * 2 + 2) * sizeof(MI_COLUMNDEF),

          keydef_out, share->keys * sizeof(MI_KEYDEF),

          &keyseg,

          (share->key_parts + share->keys) * sizeof(HA_KEYSEG),

          NullS)))

    return(HA_ERR_OUT_OF_MEM); /* purecov: inspected */

  keydef= *keydef_out;

  recinfo= *recinfo_out;

  pos= table_arg->key_info;

  for (i= 0; i < share->keys; i++, pos++)

  {

    keydef[i].flag= ((uint16_t) pos->flags & (HA_NOSAME));

    keydef[i].key_alg= HA_KEY_ALG_BTREE;

    keydef[i].block_length= pos->block_size;

    keydef[i].seg= keyseg;

    keydef[i].keysegs= pos->key_parts;

    for (j= 0; j < pos->key_parts; j++)

    {

      Field *field= pos->key_part[j].field;

      type= field->key_type();

      keydef[i].seg[j].flag= pos->key_part[j].key_part_flag;

      if (options & HA_OPTION_PACK_KEYS ||

          (pos->flags & (HA_PACK_KEY | HA_BINARY_PACK_KEY |

                         HA_SPACE_PACK_USED)))

      {

        if (pos->key_part[j].length > 8 &&

            (type == HA_KEYTYPE_TEXT ||

             type == HA_KEYTYPE_NUM ||

             (type == HA_KEYTYPE_BINARY && !field->zero_pack())))

        {

          /* No blobs here */

          if (j == 0)

            keydef[i].flag|= HA_PACK_KEY;

          if ((((int) (pos->key_part[j].length - field->decimals())) >= 4))

            keydef[i].seg[j].flag|= HA_SPACE_PACK;

        }

        else if (j == 0 && (!(pos->flags & HA_NOSAME) || pos->key_length > 16))

          keydef[i].flag|= HA_BINARY_PACK_KEY;

      }

      keydef[i].seg[j].type= (int) type;

      keydef[i].seg[j].start= pos->key_part[j].offset;

      keydef[i].seg[j].length= pos->key_part[j].length;

      keydef[i].seg[j].bit_start= keydef[i].seg[j].bit_end=

        keydef[i].seg[j].bit_length= 0;

      keydef[i].seg[j].bit_pos= 0;

      keydef[i].seg[j].language= field->charset()->number;

      if (field->null_ptr)

      {

        keydef[i].seg[j].null_bit= field->null_bit;

        keydef[i].seg[j].null_pos= (uint) (field->null_ptr-

                                           (uchar*) table_arg->record[0]);

      }

      else

      {

        keydef[i].seg[j].null_bit= 0;

        keydef[i].seg[j].null_pos= 0;

      }

      if (field->type() == DRIZZLE_TYPE_BLOB)

      {

        keydef[i].seg[j].flag|= HA_BLOB_PART;

        /* save number of bytes used to pack length */

        keydef[i].seg[j].bit_start= (uint) (field->pack_length() -

                                            share->blob_ptr_size);

      }

    }

    keyseg+= pos->key_parts;

  }

  if (table_arg->found_next_number_field)

    keydef[share->next_number_index].flag|= HA_AUTO_KEY;

  record= table_arg->record[0];

  recpos= 0;

  recinfo_pos= recinfo;

  while (recpos < (uint) share->reclength)

  {

    Field **field, *found= 0;

    minpos= share->reclength;

    length= 0;

    for (field= table_arg->field; *field; field++)

    {

      if ((fieldpos= (*field)->offset(record)) >= recpos &&

          fieldpos <= minpos)

      {

        /* skip null fields */

        if (!(temp_length= (*field)->pack_length_in_rec()))

          continue; /* Skip null-fields */

        if (! found || fieldpos < minpos ||

            (fieldpos == minpos && temp_length < length))

        {

          minpos= fieldpos;

          found= *field;

          length= temp_length;

        }

      }

    }

    if (recpos != minpos)

    { // Reserved space (Null bits?)

      memset((char*) recinfo_pos, 0, sizeof(*recinfo_pos));

      recinfo_pos->type= (int) FIELD_NORMAL;

      recinfo_pos++->length= (uint16_t) (minpos - recpos);

    }

    if (!found)

      break;

    if (found->flags & BLOB_FLAG)

      recinfo_pos->type= (int) FIELD_BLOB;

    else if (found->type() == DRIZZLE_TYPE_VARCHAR)

      recinfo_pos->type= FIELD_VARCHAR;

    else if (!(options & HA_OPTION_PACK_RECORD))

      recinfo_pos->type= (int) FIELD_NORMAL;

    else if (found->zero_pack())

      recinfo_pos->type= (int) FIELD_SKIP_ZERO;

    else

      recinfo_pos->type= (int) ((length <= 3) ?  FIELD_NORMAL : FIELD_SKIP_PRESPACE);

    if (found->null_ptr)

    {

      recinfo_pos->null_bit= found->null_bit;

      recinfo_pos->null_pos= (uint) (found->null_ptr -

                                     (uchar*) table_arg->record[0]);

    }

    else

    {

      recinfo_pos->null_bit= 0;

      recinfo_pos->null_pos= 0;

    }

    (recinfo_pos++)->length= (uint16_t) length;

    recpos= minpos + length;

  }

  *records_out= (uint) (recinfo_pos - recinfo);

  return(0);

}

/*

  Check for underlying table conformance

  SYNOPSIS

    check_definition()

      t1_keyinfo       in    First table key definition

      t1_recinfo       in    First table record definition

      t1_keys          in    Number of keys in first table

      t1_recs          in    Number of records in first table

      t2_keyinfo       in    Second table key definition

      t2_recinfo       in    Second table record definition

      t2_keys          in    Number of keys in second table

      t2_recs          in    Number of records in second table

      strict           in    Strict check switch

  DESCRIPTION

    This function compares two MyISAM definitions. By intention it was done

    to compare merge table definition against underlying table definition.

    It may also be used to compare dot-frm and MYI definitions of MyISAM

    table as well to compare different MyISAM table definitions.

    For merge table it is not required that number of keys in merge table

    must exactly match number of keys in underlying table. When calling this

    function for underlying table conformance check, 'strict' flag must be

    set to false, and converted merge definition must be passed as t1_*.

    Otherwise 'strict' flag must be set to 1 and it is not required to pass

    converted dot-frm definition as t1_*.

  RETURN VALUE

    0 - Equal definitions.

    1 - Different definitions.

  TODO

    - compare FULLTEXT keys;

    - compare SPATIAL keys;

    - compare FIELD_SKIP_ZERO which is converted to FIELD_NORMAL correctly

      (should be corretly detected in table2myisam).

*/

int check_definition(MI_KEYDEF *t1_keyinfo, MI_COLUMNDEF *t1_recinfo,

                     uint t1_keys, uint t1_recs,

                     MI_KEYDEF *t2_keyinfo, MI_COLUMNDEF *t2_recinfo,

                     uint t2_keys, uint t2_recs, bool strict)

{

  uint i, j;

  if ((strict ? t1_keys != t2_keys : t1_keys > t2_keys))

  {

    return(1);

  }

  if (t1_recs != t2_recs)

  {

    return(1);

  }

  for (i= 0; i < t1_keys; i++)

  {

    HA_KEYSEG *t1_keysegs= t1_keyinfo[i].seg;

    HA_KEYSEG *t2_keysegs= t2_keyinfo[i].seg;

    if (t1_keyinfo[i].keysegs != t2_keyinfo[i].keysegs ||

        t1_keyinfo[i].key_alg != t2_keyinfo[i].key_alg)

    {

      return(1);

    }

    for (j=  t1_keyinfo[i].keysegs; j--;)

    {

      uint8_t t1_keysegs_j__type= t1_keysegs[j].type;

      /*

        Table migration from 4.1 to 5.1. In 5.1 a *TEXT key part is

        always HA_KEYTYPE_VARTEXT2. In 4.1 we had only the equivalent of

        HA_KEYTYPE_VARTEXT1. Since we treat both the same on MyISAM

        level, we can ignore a mismatch between these types.

      */

      if ((t1_keysegs[j].flag & HA_BLOB_PART) &&

          (t2_keysegs[j].flag & HA_BLOB_PART))

      {

        if ((t1_keysegs_j__type == HA_KEYTYPE_VARTEXT2) &&

            (t2_keysegs[j].type == HA_KEYTYPE_VARTEXT1))

          t1_keysegs_j__type= HA_KEYTYPE_VARTEXT1; /* purecov: tested */

        else if ((t1_keysegs_j__type == HA_KEYTYPE_VARBINARY2) &&

                 (t2_keysegs[j].type == HA_KEYTYPE_VARBINARY1))

          t1_keysegs_j__type= HA_KEYTYPE_VARBINARY1; /* purecov: inspected */

      }

      if (t1_keysegs_j__type != t2_keysegs[j].type ||

          t1_keysegs[j].language != t2_keysegs[j].language ||

          t1_keysegs[j].null_bit != t2_keysegs[j].null_bit ||

          t1_keysegs[j].length != t2_keysegs[j].length)

      {

        return(1);

      }

    }

  }

  for (i= 0; i < t1_recs; i++)

  {

    MI_COLUMNDEF *t1_rec= &t1_recinfo[i];

    MI_COLUMNDEF *t2_rec= &t2_recinfo[i];

    /*

      FIELD_SKIP_ZERO can be changed to FIELD_NORMAL in mi_create,

      see NOTE1 in mi_create.c

    */

    if ((t1_rec->type != t2_rec->type &&

         !(t1_rec->type == (int) FIELD_SKIP_ZERO &&

           t1_rec->length == 1 &&

           t2_rec->type == (int) FIELD_NORMAL)) ||

        t1_rec->length != t2_rec->length ||

        t1_rec->null_bit != t2_rec->null_bit)

    {

      return(1);

    }

  }

  return(0);

}

extern "C" {

volatile int *killed_ptr(MI_CHECK *param)

{

  /* In theory Unsafe conversion, but should be ok for now */

  return (int*) &(((THD *)(param->thd))->killed);

}

void mi_check_print_error(MI_CHECK *param, const char *fmt,...)

{

  param->error_printed|=1;

  param->out_flag|= O_DATA_LOST;

  va_list args;

  va_start(args, fmt);

  mi_check_print_msg(param, "error", fmt, args);

  va_end(args);

}

void mi_check_print_info(MI_CHECK *param, const char *fmt,...)

{

  va_list args;

  va_start(args, fmt);

  mi_check_print_msg(param, "info", fmt, args);

  va_end(args);

}

void mi_check_print_warning(MI_CHECK *param, const char *fmt,...)

{

  param->warning_printed=1;

  param->out_flag|= O_DATA_LOST;

  va_list args;

  va_start(args, fmt);

  mi_check_print_msg(param, "warning", fmt, args);

  va_end(args);

}

/**

  Report list of threads (and queries) accessing a table, thread_id of a

  thread that detected corruption, ource file name and line number where

  this corruption was detected, optional extra information (string).

  This function is intended to be used when table corruption is detected.

  @param[in] file      MI_INFO object.

  @param[in] message   Optional error message.

  @param[in] sfile     Name of source file.

  @param[in] sline     Line number in source file.

  @return void

*/

void _mi_report_crashed(MI_INFO *file, const char *message,

                        const char *sfile, uint sline)

{

  THD *cur_thd;

  LIST *element;

  char buf[1024];

  pthread_mutex_lock(&file->s->intern_lock);

  if ((cur_thd= (THD*) file->in_use.data))

    sql_print_error("Got an error from thread_id=%lu, %s:%d", cur_thd->thread_id,

                    sfile, sline);

  else

    sql_print_error("Got an error from unknown thread, %s:%d", sfile, sline);

  if (message)

    sql_print_error("%s", message);

  for (element= file->s->in_use; element; element= list_rest(element))

  {

    THD *thd= (THD*) element->data;

    sql_print_error("%s", thd ? thd_security_context(thd, buf, sizeof(buf), 0)

                              : "Unknown thread accessing table");

  }

  pthread_mutex_unlock(&file->s->intern_lock);

}

}

ha_myisam::ha_myisam(handlerton *hton, TABLE_SHARE *table_arg)

  :handler(hton, table_arg), file(0),

  int_table_flags(HA_NULL_IN_KEY | HA_CAN_FULLTEXT | HA_CAN_SQL_HANDLER |

                  HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE |

                  HA_DUPLICATE_POS | HA_CAN_INDEX_BLOBS | HA_AUTO_PART_KEY |

                  HA_FILE_BASED | HA_CAN_GEOMETRY | HA_NO_TRANSACTIONS |

                  HA_CAN_INSERT_DELAYED | HA_CAN_BIT_FIELD | HA_CAN_RTREEKEYS |

                  HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT |

                  HA_NEED_READ_RANGE_BUFFER | HA_MRR_CANT_SORT),

   can_enable_indexes(1)

{}

handler *ha_myisam::clone(MEM_ROOT *mem_root)

{

  ha_myisam *new_handler= static_cast <ha_myisam *>(handler::clone(mem_root));

  if (new_handler)

    new_handler->file->state= file->state;

  return new_handler;

}

static const char *ha_myisam_exts[] = {

  ".MYI",

  ".MYD",

  NullS

};

const char **ha_myisam::bas_ext() const

{

  return ha_myisam_exts;

}

const char *ha_myisam::index_type(uint key_number __attribute__((unused)))

{

  return "BTREE";

}

/* Name is here without an extension */

int ha_myisam::open(const char *name, int mode, uint test_if_locked)

{

  MI_KEYDEF *keyinfo;

  MI_COLUMNDEF *recinfo= 0;

  uint recs;

  uint i;

  /*

    If the user wants to have memory mapped data files, add an

    open_flag. Do not memory map temporary tables because they are

    expected to be inserted and thus extended a lot. Memory mapping is

    efficient for files that keep their size, but very inefficient for

    growing files. Using an open_flag instead of calling mi_extra(...

    HA_EXTRA_MMAP ...) after mi_open() has the advantage that the

    mapping is not repeated for every open, but just done on the initial

    open, when the MyISAM share is created. Everytime the server

    requires to open a new instance of a table it calls this method. We

    will always supply HA_OPEN_MMAP for a permanent table. However, the

    MyISAM storage engine will ignore this flag if this is a secondary

    open of a table that is in use by other threads already (if the

    MyISAM share exists already).

  */

  if (!(file=mi_open(name, mode, test_if_locked | HA_OPEN_FROM_SQL_LAYER)))

    return (my_errno ? my_errno : -1);

  if (!table->s->tmp_table) /* No need to perform a check for tmp table */

  {

    if ((my_errno= table2myisam(table, &keyinfo, &recinfo, &recs)))

    {

      /* purecov: begin inspected */

      goto err;

      /* purecov: end */

    }

    if (check_definition(keyinfo, recinfo, table->s->keys, recs,

                         file->s->keyinfo, file->s->rec,

                         file->s->base.keys, file->s->base.fields, true))

    {

      /* purecov: begin inspected */

      my_errno= HA_ERR_CRASHED;

      goto err;

      /* purecov: end */

    }

  }

  if (test_if_locked & (HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_TMP_TABLE))

    VOID(mi_extra(file, HA_EXTRA_NO_WAIT_LOCK, 0));

  info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);

  if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))

    VOID(mi_extra(file, HA_EXTRA_WAIT_LOCK, 0));

  if (!table->s->db_record_offset)

    int_table_flags|=HA_REC_NOT_IN_SEQ;

  if (file->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))

    int_table_flags|=HA_HAS_CHECKSUM;

  keys_with_parts.clear_all();

  for (i= 0; i < table->s->keys; i++)

  {

    table->key_info[i].block_size= file->s->keyinfo[i].block_length;

    KEY_PART_INFO *kp= table->key_info[i].key_part;

    KEY_PART_INFO *kp_end= kp + table->key_info[i].key_parts;

    for (; kp != kp_end; kp++)

    {

      if (!kp->field->part_of_key.is_set(i))

      {

        keys_with_parts.set_bit(i);

        break;

      }

    }

  }

  my_errno= 0;

  goto end;

 err:

  this->close();

 end:

  /*

    Both recinfo and keydef are allocated by my_multi_malloc(), thus only

    recinfo must be freed.

  */

  if (recinfo)

    my_free((uchar*) recinfo, MYF(0));

  return my_errno;

}

int ha_myisam::close(void)

{

  MI_INFO *tmp=file;

  file=0;

  return mi_close(tmp);

}

int ha_myisam::write_row(uchar *buf)

{

  ha_statistic_increment(&SSV::ha_write_count);

  /* If we have a timestamp column, update it to the current time */

  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)

    table->timestamp_field->set_time();

  /*

    If we have an auto_increment column and we are writing a changed row

    or a new row, then update the auto_increment value in the record.

  */

  if (table->next_number_field && buf == table->record[0])

  {

    int error;

    if ((error= update_auto_increment()))

      return error;

  }

  return mi_write(file,buf);

}

int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt)

{

  if (!file) return HA_ADMIN_INTERNAL_ERROR;

  int error;

  MI_CHECK param;

  MYISAM_SHARE* share = file->s;

  const char *old_proc_info=thd->proc_info;

  thd_proc_info(thd, "Checking table");

  myisamchk_init(&param);

  param.thd = thd;

  param.op_name =   "check";

  param.db_name=    table->s->db.str;

  param.table_name= table->alias;

  param.testflag = check_opt->flags | T_CHECK | T_SILENT;

  param.stats_method= (enum_mi_stats_method)thd->variables.myisam_stats_method;

  if (!(table->db_stat & HA_READ_ONLY))

    param.testflag|= T_STATISTICS;

  param.using_global_keycache = 1;

  if (!mi_is_crashed(file) &&

      (((param.testflag & T_CHECK_ONLY_CHANGED) &&

	!(share->state.changed & (STATE_CHANGED | STATE_CRASHED |

				  STATE_CRASHED_ON_REPAIR)) &&

	share->state.open_count == 0) ||

       ((param.testflag & T_FAST) && (share->state.open_count ==

				      (uint) (share->global_changed ? 1 : 0)))))

    return HA_ADMIN_ALREADY_DONE;

  error = chk_status(&param, file);		// Not fatal

  error = chk_size(&param, file);

  if (!error)

    error |= chk_del(&param, file, param.testflag);

  if (!error)

    error = chk_key(&param, file);

  if (!error)

  {

    if ((!(param.testflag & T_QUICK) &&

	 ((share->options &

	   (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ||

	  (param.testflag & (T_EXTEND | T_MEDIUM)))) ||

	mi_is_crashed(file))

    {

      uint old_testflag=param.testflag;

      param.testflag|=T_MEDIUM;

      if (!(error= init_io_cache(&param.read_cache, file->dfile,

                                 my_default_record_cache_size, READ_CACHE,

                                 share->pack.header_length, 1, MYF(MY_WME))))

      {

        error= chk_data_link(&param, file, param.testflag & T_EXTEND);

        end_io_cache(&(param.read_cache));

      }

      param.testflag= old_testflag;

    }

  }

  if (!error)

  {

    if ((share->state.changed & (STATE_CHANGED |

				 STATE_CRASHED_ON_REPAIR |

				 STATE_CRASHED | STATE_NOT_ANALYZED)) ||

	(param.testflag & T_STATISTICS) ||

	mi_is_crashed(file))

    {

      file->update|=HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;

      pthread_mutex_lock(&share->intern_lock);

      share->state.changed&= ~(STATE_CHANGED | STATE_CRASHED |

			       STATE_CRASHED_ON_REPAIR);

      if (!(table->db_stat & HA_READ_ONLY))

	error=update_state_info(&param,file,UPDATE_TIME | UPDATE_OPEN_COUNT |

				UPDATE_STAT);

      pthread_mutex_unlock(&share->intern_lock);

      info(HA_STATUS_NO_LOCK | HA_STATUS_TIME | HA_STATUS_VARIABLE |

	   HA_STATUS_CONST);

    }

  }

  else if (!mi_is_crashed(file) && !thd->killed)

  {

    mi_mark_crashed(file);

    file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;

  }

  thd_proc_info(thd, old_proc_info);

  return error ? HA_ADMIN_CORRUPT : HA_ADMIN_OK;

}

/*

  analyze the key distribution in the table

  As the table may be only locked for read, we have to take into account that

  two threads may do an analyze at the same time!

*/

int ha_myisam::analyze(THD *thd,

                       HA_CHECK_OPT* check_opt __attribute__((unused)))

{

  int error=0;

  MI_CHECK param;

  MYISAM_SHARE* share = file->s;

  myisamchk_init(&param);

  param.thd = thd;

  param.op_name=    "analyze";