← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/archive/ha_archive.cc

Merged in plugin-registration.  handlerton now == StorageEngine.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/archive/ha_archive.cc
103
103
#define ARN ".ARN"               // Files used during an optimize call
104
104
 
105
105
 
106
 
/* Static declarations for handerton */
107
 
static handler *archive_create_handler(handlerton *hton,
108
 
                                       TABLE_SHARE *table,
109
 
                                       MEM_ROOT *mem_root);
110
106
 
111
107
static bool archive_use_aio= false;
112
108
 
120
116
*/
121
117
#define ARCHIVE_ROW_HEADER_SIZE 4
122
118
 
123
 
static handler *archive_create_handler(handlerton *hton,
124
 
                                       TABLE_SHARE *table,
125
 
                                       MEM_ROOT *mem_root)
 
119
class ArchiveEngine : public StorageEngine
126
120
{
127
 
  return new (mem_root) ha_archive(hton, table);
128
 
}
 
121
  virtual handler *create(TABLE_SHARE *table,
 
122
                          MEM_ROOT *mem_root)
 
123
  {
 
124
    return new (mem_root) ha_archive(this, table);
 
125
  }
 
126
};
129
127
 
130
128
/*
131
129
  Used for hash table that tracks open tables.
151
149
 
152
150
int archive_db_init(void *p)
153
151
{
154
 
  handlerton *archive_hton;
155
 
 
156
 
  archive_hton= (handlerton *)p;
157
 
  archive_hton->state= SHOW_OPTION_YES;
158
 
  archive_hton->create= archive_create_handler;
159
 
  archive_hton->flags= HTON_NO_FLAGS;
 
152
  StorageEngine **engine= static_cast<StorageEngine **>(p);
 
153
 
 
154
  ArchiveEngine *archive_engine= new ArchiveEngine();
 
155
  archive_engine->state= SHOW_OPTION_YES;
 
156
  archive_engine->flags= HTON_NO_FLAGS;
 
157
 
 
158
  *engine= archive_engine;
160
159
 
161
160
  /* When the engine starts up set the first version */
162
161
  global_version= 1;
163
162
 
164
163
  if (pthread_mutex_init(&archive_mutex, MY_MUTEX_INIT_FAST))
165
 
    goto error;
 
164
    return true;
166
165
  if (hash_init(&archive_open_tables, system_charset_info, 32, 0, 0,
167
166
                (hash_get_key) archive_get_key, 0, 0))
168
167
  {
172
171
  {
173
172
    return(false);
174
173
  }
175
 
error:
176
174
  return(true);
177
175
}
178
176
 
187
185
    false       OK
188
186
*/
189
187
 
190
 
int archive_db_done(void *)
 
188
int archive_db_done(void *p)
191
189
{
 
190
  ArchiveEngine *archive_engine= static_cast<ArchiveEngine *>(p);
 
191
  delete archive_engine;
 
192
 
192
193
  hash_free(&archive_open_tables);
193
194
  pthread_mutex_destroy(&archive_mutex);
194
195
 
196
197
}
197
198
 
198
199
 
199
 
ha_archive::ha_archive(handlerton *hton, TABLE_SHARE *table_arg)
200
 
  :handler(hton, table_arg), delayed_insert(0), bulk_insert(0)
 
200
ha_archive::ha_archive(StorageEngine *engine_arg, TABLE_SHARE *table_arg)
 
201
  :handler(engine_arg, table_arg), delayed_insert(0), bulk_insert(0)
201
202
{
202
203
  /* Set our original buffer from pre-allocated memory */
203
204
  buffer.set((char *)byte_buffer, IO_SIZE, system_charset_info);