~drizzle-trunk/drizzle/development

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

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

 

 

 

#include "ha_archive.h"

 

/*

  First, if you want to understand storage engines you should look at 

#define ARM ".ARM"               // Meta file (deprecated)

 

/*

*/

#define DATA_BUFFER_SIZE 2       // Size of the data used in the data file

#define ARCHIVE_CHECK_HEADER 254 // The number we use to determine corruption

                                       MEM_ROOT *mem_root);

int archive_discover(handlerton *hton, THD* thd, const char *db, 

                     const char *name,

                     size_t *frmlen);

 

 

/*

  Number of rows that will force a bulk insert.

/*

  Used for hash table that tracks open tables.

*/

{

  *length=share->table_name_length;

}

 

 

    void *

 

  RETURN

*/

 

int archive_db_init(void *p)

{

  handlerton *archive_hton;

 

  archive_hton= (handlerton *)p;

  archive_hton->state= SHOW_OPTION_YES;

  archive_hton->create= archive_create_handler;

  archive_hton->flags= HTON_NO_FLAGS;

  archive_hton->discover= archive_discover;

  if (hash_init(&archive_open_tables, system_charset_info, 32, 0, 0,

                (hash_get_key) archive_get_key, 0, 0))

  {

  }

  else

  {

  }

error:

}

 

/*

    void

 

  RETURN

*/

 

{

  hash_free(&archive_open_tables);

 

  return 0;

}

 

  /* The size of the offset value we will use for position() */

  ref_length= sizeof(my_off_t);

}

 

                     const char *name,

                     size_t *frmlen)

{

  azio_stream frm_stream;

  char az_file[FN_REFLEN];

  char *frm_ptr;

  if (stat(az_file, &file_stat))

    goto err;

 

  {

    if (errno == EROFS || errno == EACCES)

  }

 

  if (frm_stream.frm_length == 0)

  azclose(&frm_stream);

 

  *frmlen= frm_stream.frm_length;

 

err:

  my_errno= 0;

}

 

/*

*/

int ha_archive::read_data_header(azio_stream *file_to_read)

{

  if (azread_init(file_to_read) == -1)

 

  if (file_to_read->version >= 3)

 

}

 

 

*/

ARCHIVE_SHARE *ha_archive::get_share(const char *table_name, int *rc)

{

 

  pthread_mutex_lock(&archive_mutex);

  length=(uint) strlen(table_name);

 

  if (!(share=(ARCHIVE_SHARE*) hash_search(&archive_open_tables,

                                           length)))

  {

    char *tmp_name;

    if (!my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),

                          &share, sizeof(*share),

                          &tmp_name, length+1,

    {

      pthread_mutex_unlock(&archive_mutex);

      *rc= HA_ERR_OUT_OF_MEM;

    }

 

    share->use_count= 0;

    share->table_name_length= length;

    share->table_name= tmp_name;

    fn_format(share->data_file_name, table_name, "",

              ARZ, MY_REPLACE_EXT | MY_UNPACK_FILENAME);

    /*

      We will use this lock for rows.

    */

    

    /*

      We read the meta file, but do not mark it dirty. Since we are not

      anything but reading... open it for write and we will generate null

      compression writes).

    */

                 AZ_METHOD_BLOCK)))

    {

      free(share);

      pthread_mutex_unlock(&archive_mutex);

      *rc= HA_ERR_CRASHED_ON_REPAIR;

    }

    stats.auto_increment_value= archive_tmp.auto_increment + 1;

    share->rows_recorded= (ha_rows)archive_tmp.rows;

    }

    azclose(&archive_tmp);

 

    thr_lock_init(&share->lock);

  }

  share->use_count++;

  if (share->crashed)

    *rc= HA_ERR_CRASHED_ON_USAGE;

  pthread_mutex_unlock(&archive_mutex);

 

}

 

 

int ha_archive::free_share()

{

  int rc= 0;

 

  pthread_mutex_lock(&archive_mutex);

  if (!--share->use_count)

  {

    thr_lock_delete(&share->lock);

    /* 

      We need to make sure we don't reset the crashed state.

      If we open a crashed file, wee need to close it as crashed unless

      Since we will close the data down after this, we go on and count

      the flush on close;

    */

    {

      if (azclose(&(share->archive_write)))

        rc= 1;

    }

  }

  pthread_mutex_unlock(&archive_mutex);

 

}

 

int ha_archive::init_archive_writer()

{

  /* 

    It is expensive to open and close the data files and since you can't have

    a gzip file that can be both read and written we keep a writer open

    that is shared amoung all open tables.

  */

  if (!(azopen(&(share->archive_write), share->data_file_name, 

  {

  }

 

}

 

 

*/

int ha_archive::init_archive_reader()

{

  /* 

    It is expensive to open and close the data files and since you can't have

    a gzip file that can be both read and written we keep a writer open

    that is shared amoung all open tables.

  */

  {

    az_method method;

 

    switch (archive_use_aio)

    {

      method= AZ_METHOD_BLOCK;

      break;

      method= AZ_METHOD_AIO;

      break;

    default:

      method= AZ_METHOD_BLOCK;

    }

                 method)))

    {

    }

  }

 

}

 

 

*/

static const char *ha_archive_exts[] = {

  ARZ,

};

 

const char **ha_archive::bas_ext() const

  Init out lock.

  We open the file we will read from.

*/

{

  int rc= 0;

  share= get_share(name, &rc);

 

  if (rc == HA_ERR_CRASHED_ON_USAGE && !(open_options & HA_OPEN_FOR_REPAIR))

  {

    /* purecov: begin inspected */

    free_share();

    /* purecov: end */    

  }

  else if (rc == HA_ERR_OUT_OF_MEM)

  {

  }

 

 

  record_buffer= create_record_buffer(table->s->reclength + 

                                      ARCHIVE_ROW_HEADER_SIZE);

  if (!record_buffer)

  {

    free_share();

  }

 

  thr_lock_data_init(&share->lock, &lock, NULL);

 

  if (rc == HA_ERR_CRASHED_ON_USAGE && open_options & HA_OPEN_FOR_REPAIR)

  {

  }

  else

}

 

 

int ha_archive::close(void)

{

  int rc= 0;

 

  destroy_record_buffer(record_buffer);

 

  /* First close stream */

  {

    if (azclose(&archive))

      rc= 1;

  /* then also close share */

  rc|= free_share();

 

}

 

 

  of creation.

*/

 

                       HA_CREATE_INFO *create_info)

{

  char name_buff[FN_REFLEN];

  azio_stream create_stream;            /* Archive file we are working with */

  File frm_file;                   /* File handler for readers */

  struct stat file_stat;

 

  stats.auto_increment_value= create_info->auto_increment_value;