~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.h

• browse files at revision 1300.4.7
• compare with another revision
• compare with revision 1300.4.7
• download diff
• download tarball
• view history from revision 1300.4.7

Show diffs side-by-side

added

removed

drizzled/plugin/storage_engine.h

31

31

#include "drizzled/table_identifier.h"

32

32

#include "drizzled/cached_directory.h"

33

33

 

 

34

#include "drizzled/hash.h"

 

35

 

34

36

#include <bitset>

35

37

#include <string>

36

38

#include <vector>

41

43

 

42

44

class TableList;

43

45

class Session;

44

 

class XID;

45

46

class Cursor;

46

47

typedef struct st_hash HASH;

47

48

 

119

120

namespace plugin

120

121

{

121

122

 

 

123

typedef hash_map<std::string, StorageEngine *> EngineMap;

 

124

typedef std::vector<StorageEngine *> EngineVector;

 

125

 

122

126

extern const std::string UNKNOWN_STRING;

123

127

extern const std::string DEFAULT_DEFINITION_FILE_EXT;

124

128

 

130

134

  usually StorageEngine instance is defined statically in ha_xxx.cc as

131

135

 

132

136

  static StorageEngine { ... } xxx_engine;

133

 

 

134

 

  savepoint_*, prepare, recover, and *_by_xid pointers can be 0.

135

137

*/

136

138

class StorageEngine : public Plugin

137

139

{

139

141

  typedef uint64_t Table_flags;

140

142

 

141

143

private:

142

 

 

143

 

  /*

144

 

    Name used for storage engine.

145

 

  */

146

 

  const bool two_phase_commit;

147

144

  bool enabled;

148

145

 

149

146

  const std::bitset<HTON_BIT_SIZE> flags; /* global Cursor flags */

150

147

 

151

 

  void setTransactionReadWrite(Session& session);

 

148

  virtual void setTransactionReadWrite(Session& session);

152

149

 

153

150

protected:

154

151

  std::string table_definition_ext;

183

180

  ProtoCache proto_cache;

184

181

  pthread_mutex_t proto_cache_mutex;

185

182

 

186

 

  /**

187

 

   * Implementing classes should override these to provide savepoint

188

 

   * functionality.

189

 

   */

190

 

  virtual int savepoint_set_hook(Session *, NamedSavepoint &) { return 0; }

191

 

 

192

 

  virtual int savepoint_rollback_hook(Session *, NamedSavepoint &) { return 0; }

193

 

 

194

 

  virtual int savepoint_release_hook(Session *, NamedSavepoint &) { return 0; }

195

 

 

196

183

public:

197

184

 

198

185

  StorageEngine(const std::string name_arg,

199

 

                const std::bitset<HTON_BIT_SIZE> &flags_arg= HTON_NO_FLAGS,

200

 

                bool support_2pc= false);

 

186

                const std::bitset<HTON_BIT_SIZE> &flags_arg= HTON_NO_FLAGS);

201

187

 

202

188

  virtual ~StorageEngine();

203

189

 

241

227

  inline uint32_t getSlot (void) const { return slot; }

242

228

  inline void setSlot (uint32_t value) { slot= value; }

243

229

 

244

 

  bool has_2pc()

245

 

  {

246

 

    return two_phase_commit;

247

 

  }

248

 

 

249

230

 

250

231

  bool is_enabled() const

251

232

  {

281

262

  {

282

263

    return 0;

283

264

  }

284

 

  /*

285

 

    'all' is true if it's a real commit, that makes persistent changes

286

 

    'all' is false if it's not in fact a commit but an end of the

287

 

    statement that is part of the transaction.

288

 

    NOTE 'all' is also false in auto-commit mode where 'end of statement'

289

 

    and 'real commit' mean the same event.

290

 

  */

291

 

  virtual int  commit(Session *, bool)

292

 

  {

293

 

    return 0;

294

 

  }

295

 

 

296

 

  virtual int  rollback(Session *, bool)

297

 

  {

298

 

    return 0;

299

 

  }

300

 

 

301

 

  /*

302

 

    The void * points to an uninitialized storage area of requested size

303

 

    (see savepoint_offset description)

304

 

  */

305

 

  int savepoint_set(Session *session, NamedSavepoint &sp)

306

 

  {

307

 

    return savepoint_set_hook(session, sp);

308

 

  }

309

 

 

310

 

  /*

311

 

    The void * points to a storage area, that was earlier passed

312

 

    to the savepoint_set call

313

 

  */

314

 

  int savepoint_rollback(Session *session, NamedSavepoint &sp)

315

 

  {

316

 

     return savepoint_rollback_hook(session, sp);

317

 

  }

318

 

 

319

 

  int savepoint_release(Session *session, NamedSavepoint &sp)

320

 

  {

321

 

    return savepoint_release_hook(session, sp);

322

 

  }

323

 

 

324

 

  virtual int  prepare(Session *, bool) { return 0; }

325

 

  virtual int  recover(XID *, uint32_t) { return 0; }

326

 

  virtual int  commit_by_xid(XID *) { return 0; }

327

 

  virtual int  rollback_by_xid(XID *) { return 0; }

328

265

  virtual Cursor *create(TableShare &, memory::Root *)= 0;

329

266

  /* args: path */

330

267

  virtual void drop_database(char*) { }

335

272

    return false;

336

273

  }

337

274

 

338

 

  virtual int release_temporary_latches(Session *) { return false; }

339

 

 

340

275

  /**

341

276

    If frm_error() is called then we will use this to find out what file

342

277

    extentions exist for the storage engine. This is also used by the default

397

332

                                           std::string find_str);

398

333

  static void closeConnection(Session* session);

399

334

  static void dropDatabase(char* path);

400

 

  static int commitOrRollbackByXID(XID *xid, bool commit);

401

 

  static int releaseTemporaryLatches(Session *session);

402

335

  static bool flushLogs(plugin::StorageEngine *db_type);

403

 

  static int recover(HASH *commit_list);

404

 

  static int startConsistentSnapshot(Session *session);

405

336

  static int dropTable(Session& session,

406

337

                       TableIdentifier &identifier,

407

338

                       bool generate_warning);

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1