← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/blackhole/ha_blackhole.cc

Remove dead memset call.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/blackhole/ha_blackhole.cc
42
42
 
43
43
 
44
44
static const char *ha_blackhole_exts[] = {
 
45
  BLACKHOLE_EXT,
45
46
  NULL
46
47
};
47
48
 
52
53
 
53
54
public:
54
55
  BlackholeEngine(const string &name_arg)
55
 
   : drizzled::plugin::StorageEngine(name_arg, HTON_FILE_BASED |
 
56
   : drizzled::plugin::StorageEngine(name_arg,
56
57
                                     HTON_NULL_IN_KEY |
57
58
                                     HTON_CAN_INDEX_BLOBS |
58
59
                                     HTON_SKIP_STORE_LOCK |
67
68
    pthread_mutex_destroy(&blackhole_mutex);
68
69
  }
69
70
 
70
 
  virtual Cursor *create(TableShare &table,
71
 
                         drizzled::memory::Root *mem_root)
 
71
  virtual Cursor *create(TableShare &table)
72
72
  {
73
 
    return new (mem_root) ha_blackhole(*this, table);
 
73
    return new ha_blackhole(*this, table);
74
74
  }
75
75
 
76
76
  const char **bas_ext() const {
79
79
 
80
80
  int doCreateTable(Session&,
81
81
                    Table&,
82
 
                    drizzled::TableIdentifier &identifier,
 
82
                    const drizzled::TableIdentifier &identifier,
83
83
                    drizzled::message::Table&);
84
84
 
85
 
  int doDropTable(Session&, TableIdentifier &identifier);
 
85
  int doDropTable(Session&, const drizzled::TableIdentifier &identifier);
86
86
 
87
87
  BlackholeShare *findOpenTable(const string table_name);
88
88
  void addOpenTable(const string &table_name, BlackholeShare *);
89
89
  void deleteOpenTable(const string &table_name);
90
90
 
91
91
  int doGetTableDefinition(Session& session,
92
 
                           TableIdentifier &identifier,
 
92
                           const drizzled::TableIdentifier &identifier,
93
93
                           drizzled::message::Table &table_message);
94
94
 
95
95
  void doGetTableNames(drizzled::CachedDirectory &directory,
96
 
                       SchemaIdentifier &,
 
96
                       const SchemaIdentifier &,
97
97
                       set<string>& set_of_names)
98
98
  {
99
99
    drizzled::CachedDirectory::Entries entries= directory.getEntries();
116
116
        char uname[NAME_LEN + 1];
117
117
        uint32_t file_name_len;
118
118
 
119
 
        file_name_len= filename_to_tablename(filename->c_str(), uname, sizeof(uname));
 
119
        file_name_len= TableIdentifier::filename_to_tablename(filename->c_str(), uname, sizeof(uname));
120
120
        // TODO: Remove need for memory copy here
121
121
        uname[file_name_len - sizeof(BLACKHOLE_EXT) + 1]= '\0'; // Subtract ending, place NULL
122
122
        set_of_names.insert(uname);
138
138
            HA_KEYREAD_ONLY);
139
139
  }
140
140
 
141
 
  bool doDoesTableExist(Session& session, TableIdentifier &identifier);
142
 
  int doRenameTable(Session&, TableIdentifier &from, TableIdentifier &to);
 
141
  bool doDoesTableExist(Session& session, const drizzled::TableIdentifier &identifier);
 
142
  int doRenameTable(Session&, const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to);
143
143
  void doGetTableIdentifiers(drizzled::CachedDirectory &directory,
144
 
                             drizzled::SchemaIdentifier &schema_identifier,
 
144
                             const drizzled::SchemaIdentifier &schema_identifier,
145
145
                             drizzled::TableIdentifiers &set_of_identifiers);
146
146
};
147
147
 
148
148
 
149
149
void BlackholeEngine::doGetTableIdentifiers(drizzled::CachedDirectory &directory,
150
 
                                            drizzled::SchemaIdentifier &schema_identifier,
 
150
                                            const drizzled::SchemaIdentifier &schema_identifier,
151
151
                                            drizzled::TableIdentifiers &set_of_identifiers)
152
152
{
153
153
  drizzled::CachedDirectory::Entries entries= directory.getEntries();
170
170
      char uname[NAME_LEN + 1];
171
171
      uint32_t file_name_len;
172
172
 
173
 
      file_name_len= filename_to_tablename(filename->c_str(), uname, sizeof(uname));
 
173
      file_name_len= TableIdentifier::filename_to_tablename(filename->c_str(), uname, sizeof(uname));
174
174
      // TODO: Remove need for memory copy here
175
175
      uname[file_name_len - sizeof(BLACKHOLE_EXT) + 1]= '\0'; // Subtract ending, place NULL
176
176
 
179
179
  }
180
180
}
181
181
 
182
 
int BlackholeEngine::doRenameTable(Session&, TableIdentifier &from, TableIdentifier &to)
 
182
int BlackholeEngine::doRenameTable(Session&, const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to)
183
183
{
184
184
  int error= 0;
185
185
 
232
232
  if (!(share= get_share(name)))
233
233
    return(HA_ERR_OUT_OF_MEM);
234
234
 
235
 
  thr_lock_data_init(&share->lock, &lock, NULL);
236
 
  return(0);
 
235
  lock.init(&share->lock);
 
236
  return 0;
237
237
}
238
238
 
239
239
int ha_blackhole::close(void)
244
244
 
245
245
int BlackholeEngine::doCreateTable(Session&,
246
246
                                   Table&,
247
 
                                   drizzled::TableIdentifier &identifier,
 
247
                                   const drizzled::TableIdentifier &identifier,
248
248
                                   drizzled::message::Table& proto)
249
249
{
250
250
  string serialized_proto;
270
270
 
271
271
 
272
272
int BlackholeEngine::doDropTable(Session&,
273
 
                                 TableIdentifier &identifier)
 
273
                                 const drizzled::TableIdentifier &identifier)
274
274
{
275
275
  string new_path(identifier.getPath());
276
276
 
288
288
 
289
289
 
290
290
bool BlackholeEngine::doDoesTableExist(Session&,
291
 
                                       TableIdentifier &identifier)
 
291
                                       const drizzled::TableIdentifier &identifier)
292
292
{
293
293
  string proto_path(identifier.getPath());
294
294
  proto_path.append(BLACKHOLE_EXT);
303
303
 
304
304
 
305
305
int BlackholeEngine::doGetTableDefinition(Session&,
306
 
                                          TableIdentifier &identifier,
 
306
                                          const drizzled::TableIdentifier &identifier,
307
307
                                          drizzled::message::Table &table_proto)
308
308
{
309
309
  string new_path;
348
348
  return("BTREE");
349
349
}
350
350
 
351
 
int ha_blackhole::write_row(unsigned char *)
 
351
int ha_blackhole::doInsertRecord(unsigned char *)
352
352
{
353
353
  return(table->next_number_field ? update_auto_increment() : 0);
354
354
}
355
355
 
356
 
int ha_blackhole::rnd_init(bool)
 
356
int ha_blackhole::doStartTableScan(bool)
357
357
{
358
358
  return(0);
359
359
}
476
476
 
477
477
BlackholeShare::~BlackholeShare()
478
478
{
479
 
  thr_lock_delete(&lock);
 
479
  lock.deinit();
480
480
}
481
481
 
482
482
 
483
483
static drizzled::plugin::StorageEngine *blackhole_engine= NULL;
484
484
 
485
 
static int blackhole_init(drizzled::plugin::Context &context)
 
485
static int blackhole_init(drizzled::module::Context &context)
486
486
{
487
487
 
488
488
  blackhole_engine= new BlackholeEngine("BLACKHOLE");