← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/transaction_services.h

Merge refactored command line using for innodb

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/transaction_services.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
5
 
 *  Copyright (C) 2010 Jay Pipes <jaypipes@gmail.com>
 
4
 *  Copyright (C) 2008 Sun Microsystems
 
5
 *  Copyright (c) 2010 Jay Pipes <jaypipes@gmail.com>
6
6
 *
7
7
 *  This program is free software; you can redistribute it and/or modify
8
8
 *  it under the terms of the GNU General Public License as published by
25
25
#ifndef DRIZZLED_TRANSACTION_SERVICES_H
26
26
#define DRIZZLED_TRANSACTION_SERVICES_H
27
27
 
28
 
#include <drizzled/atomics.h>
29
 
#include <drizzled/message/transaction.pb.h>
30
 
#include <drizzled/identifier/table.h>
31
 
#include <drizzled/identifier/schema.h>
32
 
#include <drizzled/message/schema.h>
33
 
#include <drizzled/session.h>
34
 
 
35
 
#include <drizzled/visibility.h>
 
28
#include "drizzled/atomics.h"
 
29
#include "drizzled/message/transaction.pb.h"
36
30
 
37
31
namespace drizzled
38
32
{
42
36
{
43
37
  class MonitoredInTransaction;
44
38
  class XaResourceManager;
45
 
  class XaStorageEngine;
46
39
  class TransactionalStorageEngine;
47
40
}
48
41
 
49
42
class Session;
50
43
class NamedSavepoint;
51
 
class Field;
52
44
 
53
45
/**
54
46
 * This is a class which manages the XA transaction processing
55
47
 * in the server
56
48
 */
57
 
class DRIZZLED_API TransactionServices
 
49
class TransactionServices
58
50
{
59
51
public:
60
52
  static const size_t DEFAULT_RECORD_SIZE= 100;
61
 
  
62
 
  TransactionServices();
 
53
  typedef uint64_t TransactionId;
 
54
  /**
 
55
   * Constructor
 
56
   */
 
57
  TransactionServices()
 
58
  {
 
59
    /**
 
60
     * @todo set transaction ID to the last one from an applier...
 
61
     */
 
62
    current_transaction_id= 0;
 
63
  }
63
64
 
64
65
  /**
65
66
   * Singleton method
76
77
   * Transaction and Statement messages, false otherwise.
77
78
   */
78
79
  bool shouldConstructMessages();
79
 
 
 
80
  /**
 
81
   * Method which returns the active Transaction message
 
82
   * for the supplied Session.  If one is not found, a new Transaction
 
83
   * message is allocated, initialized, and returned.
 
84
   *
 
85
   * @param The session processing the transaction
 
86
   */
 
87
  message::Transaction *getActiveTransactionMessage(Session *in_session);
 
88
  /** 
 
89
   * Method which attaches a transaction context
 
90
   * the supplied transaction based on the supplied Session's
 
91
   * transaction information.  This method also ensure the
 
92
   * transaction message is attached properly to the Session object
 
93
   *
 
94
   * @param The transaction message to initialize
 
95
   * @param The Session processing this transaction
 
96
   */
 
97
  void initTransactionMessage(message::Transaction &in_transaction, Session *in_session);
 
98
  /** 
 
99
   * Helper method which finalizes data members for the 
 
100
   * supplied transaction's context.
 
101
   *
 
102
   * @param The transaction message to finalize 
 
103
   * @param The Session processing this transaction
 
104
   */
 
105
  void finalizeTransactionMessage(message::Transaction &in_transaction, Session *in_session);
 
106
  /**
 
107
   * Helper method which deletes transaction memory and
 
108
   * unsets Session's transaction and statement messages.
 
109
   */
 
110
  void cleanupTransactionMessage(message::Transaction *in_transaction,
 
111
                                 Session *in_session);
 
112
  /**
 
113
   * Helper method which initializes a Statement message
 
114
   *
 
115
   * @param The statement to initialize
 
116
   * @param The type of the statement
 
117
   * @param The session processing this statement
 
118
   */
 
119
  void initStatementMessage(message::Statement &statement,
 
120
                            message::Statement::Type in_type,
 
121
                            Session *in_session);
80
122
  /**
81
123
   * Finalizes a Statement message and sets the Session's statement
82
124
   * message to NULL.
83
125
   *
84
 
   * @param statement The statement to initialize
85
 
   * @param session The Session object processing this statement
 
126
   * @param The statement to initialize
 
127
   * @param The session processing this statement
86
128
   */
87
129
  void finalizeStatementMessage(message::Statement &statement,
88
 
                                Session::reference session);
89
 
 
 
130
                                Session *in_session);
 
131
  /** Helper method which returns an initialized Statement message for methods
 
132
   * doing insertion of data.
 
133
   *
 
134
   * @param[in] Pointer to the Session doing the processing
 
135
   * @param[in] Pointer to the Table object being inserted into
 
136
   */
 
137
  message::Statement &getInsertStatement(Session *in_session,
 
138
                                         Table *in_table);
 
139
 
 
140
  /**
 
141
   * Helper method which initializes the header message for
 
142
   * insert operations.
 
143
   *
 
144
   * @param[inout] Statement message container to modify
 
145
   * @param[in] Pointer to the Session doing the processing
 
146
   * @param[in] Pointer to the Table being inserted into
 
147
   */
 
148
  void setInsertHeader(message::Statement &statement,
 
149
                       Session *in_session,
 
150
                       Table *in_table);
 
151
  /**
 
152
   * Helper method which returns an initialized Statement
 
153
   * message for methods doing updates of data.
 
154
   *
 
155
   * @param[in] Pointer to the Session doing the processing
 
156
   * @param[in] Pointer to the Table object being updated
 
157
   * @param[in] Pointer to the old data in the record
 
158
   * @param[in] Pointer to the new data in the record
 
159
   */
 
160
  message::Statement &getUpdateStatement(Session *in_session,
 
161
                                         Table *in_table,
 
162
                                         const unsigned char *old_record, 
 
163
                                         const unsigned char *new_record);
 
164
  /**
 
165
   * Helper method which initializes the header message for
 
166
   * update operations.
 
167
   *
 
168
   * @param[inout] Statement message container to modify
 
169
   * @param[in] Pointer to the Session doing the processing
 
170
   * @param[in] Pointer to the Table being updated
 
171
   * @param[in] Pointer to the old data in the record
 
172
   * @param[in] Pointer to the new data in the record
 
173
   */
 
174
  void setUpdateHeader(message::Statement &statement,
 
175
                       Session *in_session,
 
176
                       Table *in_table,
 
177
                       const unsigned char *old_record, 
 
178
                       const unsigned char *new_record);
 
179
  /**
 
180
   * Helper method which returns an initialized Statement
 
181
   * message for methods doing deletion of data.
 
182
   *
 
183
   * @param[in] Pointer to the Session doing the processing
 
184
   * @param[in] Pointer to the Table object being deleted from
 
185
   */
 
186
  message::Statement &getDeleteStatement(Session *in_session,
 
187
                                         Table *in_table);
 
188
 
 
189
  /**
 
190
   * Helper method which initializes the header message for
 
191
   * insert operations.
 
192
   *
 
193
   * @param[inout] Statement message container to modify
 
194
   * @param[in] Pointer to the Session doing the processing
 
195
   * @param[in] Pointer to the Table being deleted from
 
196
   */
 
197
  void setDeleteHeader(message::Statement &statement,
 
198
                       Session *in_session,
 
199
                       Table *in_table);
 
200
  /** 
 
201
   * Commits a normal transaction (see above) and pushes the transaction
 
202
   * message out to the replicators.
 
203
   *
 
204
   * @param Pointer to the Session committing the transaction
 
205
   */
 
206
  int commitTransactionMessage(Session *in_session);
 
207
  /** 
 
208
   * Marks the current active transaction message as being rolled back and
 
209
   * pushes the transaction message out to replicators.
 
210
   *
 
211
   * @param Pointer to the Session committing the transaction
 
212
   */
 
213
  void rollbackTransactionMessage(Session *in_session);
90
214
  /**
91
215
   * Creates a new InsertRecord GPB message and pushes it to
92
216
   * replicators.
93
217
   *
94
 
   * @param session Session object which has inserted a record
95
 
   * @param table Table object containing insert information
 
218
   * @param Pointer to the Session which has inserted a record
 
219
   * @param Pointer to the Table containing insert information
96
220
   *
97
221
   * Grr, returning "true" here on error because of the cursor
98
222
   * reversed bool return crap...fix that.
99
223
   */
100
 
  bool insertRecord(Session::reference session, Table &in_table);
101
 
 
 
224
  bool insertRecord(Session *in_session, Table *in_table);
102
225
  /**
103
226
   * Creates a new UpdateRecord GPB message and pushes it to
104
227
   * replicators.
105
228
   *
106
 
   * @param session Session object which has updated a record
107
 
   * @param table Table object containing update information
108
 
   * @param old_record Pointer to the raw bytes representing the old record/row
109
 
   * @param new_record Pointer to the raw bytes representing the new record/row 
 
229
   * @param Pointer to the Session which has updated a record
 
230
   * @param Pointer to the Table containing update information
 
231
   * @param Pointer to the raw bytes representing the old record/row
 
232
   * @param Pointer to the raw bytes representing the new record/row 
110
233
   */
111
 
  void updateRecord(Session::reference session, 
112
 
                    Table &table, 
 
234
  void updateRecord(Session *in_session, 
 
235
                    Table *in_table, 
113
236
                    const unsigned char *old_record, 
114
237
                    const unsigned char *new_record);
115
 
 
116
238
  /**
117
239
   * Creates a new DeleteRecord GPB message and pushes it to
118
240
   * replicators.
119
241
   *
120
 
   * @param session Session object which has deleted a record
121
 
   * @param table Table object containing delete information
122
 
   * @param use_update_record If true, uses the values from the update row instead
 
242
   * @param Pointer to the Session which has deleted a record
 
243
   * @param Pointer to the Table containing delete information
123
244
   */
124
 
  void deleteRecord(Session::reference session,
125
 
                    Table &table,
126
 
                    bool use_update_record= false);
127
 
 
 
245
  void deleteRecord(Session *in_session, Table *in_table);
128
246
  /**
129
247
   * Creates a CreateSchema Statement GPB message and adds it
130
248
   * to the Session's active Transaction GPB message for pushing
131
249
   * out to the replicator streams.
132
250
   *
133
 
   * @param[in] session Session object which issued the statement
134
 
   * @param[in] schema message::Schema message describing new schema
 
251
   * @param[in] Pointer to the Session which issued the statement
 
252
   * @param[in] message::Schema message describing new schema
135
253
   */
136
 
  void createSchema(Session::reference session, const message::Schema &schema);
137
 
 
 
254
  void createSchema(Session *in_session, const message::Schema &schema);
138
255
  /**
139
256
   * Creates a DropSchema Statement GPB message and adds it
140
257
   * to the Session's active Transaction GPB message for pushing
141
258
   * out to the replicator streams.
142
259
   *
143
 
   * @param[in] session Session object which issued the statement
144
 
   * @param[in] identifier Identifier for the schema to drop
145
 
   */
146
 
  void dropSchema(Session::reference session,
147
 
                  identifier::Schema::const_reference identifier,
148
 
                  message::schema::const_reference schema);
149
 
 
150
 
  /**
151
 
   * Creates an AlterSchema Statement GPB message and adds it
152
 
   * to the Session's active Transaction GPB message for pushing
153
 
   * out to the replicator streams.
154
 
   *
155
 
   * @param[in] session Session object which issued the statement
156
 
   * @param[in] old_schema Original schema definition
157
 
   * @param[in] new_schema New schema definition
158
 
   */
159
 
  void alterSchema(Session::reference session,
160
 
                   const message::Schema &old_schema,
161
 
                   const message::Schema &new_schema);
162
 
 
 
260
   * @param[in] Pointer to the Session which issued the statement
 
261
   * @param[in] message::Schema message describing new schema
 
262
   */
 
263
  void dropSchema(Session *in_session, const std::string &schema_name);
163
264
  /**
164
265
   * Creates a CreateTable Statement GPB message and adds it
165
266
   * to the Session's active Transaction GPB message for pushing
166
267
   * out to the replicator streams.
167
268
   *
168
 
   * @param[in] session Session object which issued the statement
169
 
   * @param[in] table message::Table message describing new schema
 
269
   * @param[in] Pointer to the Session which issued the statement
 
270
   * @param[in] message::Table message describing new schema
170
271
   */
171
 
  void createTable(Session::reference session, const message::Table &table);
172
 
 
 
272
  void createTable(Session *in_session, const message::Table &table);
173
273
  /**
174
274
   * Creates a DropTable Statement GPB message and adds it
175
275
   * to the Session's active Transaction GPB message for pushing
176
276
   * out to the replicator streams.
177
277
   *
178
 
   * @param[in] session Session object which issued the statement
179
 
   * @param[in] table Identifier for the table being dropped
180
 
   * @param[in] if_exists Did the user specify an IF EXISTS clause?
 
278
   * @param[in] Pointer to the Session which issued the statement
 
279
   * @param[in] The schema of the table being dropped
 
280
   * @param[in] The table name of the table being dropped
 
281
   * @param[in] Did the user specify an IF EXISTS clause?
181
282
   */
182
 
  void dropTable(Session::reference session,
183
 
                 identifier::Table::const_reference identifier,
184
 
                 message::table::const_reference table,
185
 
                 bool if_exists);
186
 
 
 
283
  void dropTable(Session *in_session,
 
284
                     const std::string &schema_name,
 
285
                     const std::string &table_name,
 
286
                     bool if_exists);
187
287
  /**
188
288
   * Creates a TruncateTable Statement GPB message and adds it
189
289
   * to the Session's active Transaction GPB message for pushing
190
290
   * out to the replicator streams.
191
291
   *
192
 
   * @param[in] session Session object which issued the statement
193
 
   * @param[in] table The Table being truncated
 
292
   * @param[in] Pointer to the Session which issued the statement
 
293
   * @param[in] The Table being truncated
194
294
   */
195
 
  void truncateTable(Session::reference session, Table &table);
196
 
 
 
295
  void truncateTable(Session *in_session, Table *in_table);
197
296
  /**
198
297
   * Creates a new RawSql GPB message and pushes it to 
199
298
   * replicators.
203
302
   * on the I_S, etc.  Not sure what to do with administrative
204
303
   * commands like CHECK TABLE, though..
205
304
   *
206
 
   * @param session Session object which issued the statement
207
 
   * @param query Query string
 
305
   * @param Pointer to the Session which issued the statement
 
306
   * @param Query string
208
307
   */
209
 
  void rawStatement(Session::reference session, const std::string &query);
210
 
 
 
308
  void rawStatement(Session *in_session, const std::string &query);
211
309
  /* transactions: interface to plugin::StorageEngine functions */
212
 
  int rollbackTransaction(Session::reference session, bool all);
213
 
 
214
 
  /**
215
 
   * Commit the current transaction.
216
 
   *
217
 
   * @retval 0 ok
218
 
   * @retval 1 transaction was rolled back
219
 
   * @retval 2 error during commit, data may be inconsistent
220
 
   *
221
 
   * @todo
222
 
   * Since we don't support nested statement transactions in 5.0,
223
 
   * we can't commit or rollback stmt transactions while we are inside
224
 
   * stored functions or triggers. So we simply do nothing now.
225
 
   * This should be fixed in later ( >= 5.1) releases.
226
 
   */
227
 
  int commitTransaction(Session::reference session, bool all);
228
 
 
229
 
  /**
230
 
   * This is used to commit or rollback a single statement depending on
231
 
   * the value of error.
232
 
   *
233
 
   * @note
234
 
   * Note that if the autocommit is on, then the following call inside
235
 
   * InnoDB will commit or rollback the whole transaction (= the statement). The
236
 
   * autocommit mechanism built into InnoDB is based on counting locks, but if
237
 
   * the user has used LOCK TABLES then that mechanism does not know to do the
238
 
   * commit.
239
 
   */
240
 
  int autocommitOrRollback(Session::reference session, int error);
 
310
  int commitPhaseOne(Session *session, bool all);
 
311
  int rollbackTransaction(Session *session, bool all);
 
312
 
 
313
  /* transactions: these functions never call plugin::StorageEngine functions directly */
 
314
  int commitTransaction(Session *session, bool all);
 
315
  int autocommitOrRollback(Session *session, int error);
241
316
 
242
317
  /* savepoints */
243
 
  int rollbackToSavepoint(Session::reference session, NamedSavepoint &sv);
244
 
  int setSavepoint(Session::reference session, NamedSavepoint &sv);
245
 
  int releaseSavepoint(Session::reference session, NamedSavepoint &sv);
 
318
  int rollbackToSavepoint(Session *session, NamedSavepoint &sv);
 
319
  int setSavepoint(Session *session, NamedSavepoint &sv);
 
320
  int releaseSavepoint(Session *session, NamedSavepoint &sv);
246
321
 
247
322
  /**
248
323
   * Marks a storage engine as participating in a statement
258
333
   * per statement, and therefore should not need to be idempotent.
259
334
   * Put in assert()s to test this.
260
335
   *
261
 
   * @param[in] session Session object
262
 
   * @param[in] monitored Descriptor for the resource which will be participating
263
 
   * @param[in] engine Pointer to the TransactionalStorageEngine resource
 
336
   * @param[in] Session pointer
 
337
   * @param[in] Descriptor for the resource which will be participating
 
338
   * @param[in] Pointer to the TransactionalStorageEngine resource
264
339
   */
265
 
  void registerResourceForStatement(Session::reference session,
 
340
  void registerResourceForStatement(Session *session,
266
341
                                    plugin::MonitoredInTransaction *monitored,
267
342
                                    plugin::TransactionalStorageEngine *engine);
268
343
 
280
355
   * per statement, and therefore should not need to be idempotent.
281
356
   * Put in assert()s to test this.
282
357
   *
283
 
   * @param[in] session Session object
284
 
   * @param[in] monitored Descriptor for the resource which will be participating
285
 
   * @param[in] engine Pointer to the TransactionalStorageEngine resource
286
 
   * @param[in] resource_manager Pointer to the XaResourceManager resource manager
 
358
   * @param[in] Session pointer
 
359
   * @param[in] Descriptor for the resource which will be participating
 
360
   * @param[in] Pointer to the TransactionalStorageEngine resource
 
361
   * @param[in] Pointer to the XaResourceManager resource manager
287
362
   */
288
 
  void registerResourceForStatement(Session::reference session,
 
363
  void registerResourceForStatement(Session *session,
289
364
                                    plugin::MonitoredInTransaction *monitored,
290
365
                                    plugin::TransactionalStorageEngine *engine,
291
366
                                    plugin::XaResourceManager *resource_manager);
314
389
   * time when this method is called except from the
315
390
   * TransactionServices::registerResourceForStatement method.
316
391
   */
317
 
  void registerResourceForTransaction(Session::reference session,
 
392
  void registerResourceForTransaction(Session *session,
318
393
                                      plugin::MonitoredInTransaction *monitored,
319
394
                                      plugin::TransactionalStorageEngine *engine);
320
 
 
321
 
  void registerResourceForTransaction(Session::reference session,
 
395
  void registerResourceForTransaction(Session *session,
322
396
                                      plugin::MonitoredInTransaction *monitored,
323
397
                                      plugin::TransactionalStorageEngine *engine,
324
398
                                      plugin::XaResourceManager *resource_manager);
325
 
 
326
 
  void allocateNewTransactionId();
327
 
 
328
 
  /**************
329
 
   * Events API
330
 
   **************/
331
 
 
332
 
  /**
333
 
   * Send server startup event.
334
 
   *
335
 
   * @param session Session object
336
 
   *
337
 
   * @retval true Success
338
 
   * @retval false Failure
339
 
   */
340
 
  bool sendStartupEvent(Session::reference session);
341
 
 
342
 
  /**
343
 
   * Send server shutdown event.
344
 
   *
345
 
   * @param session Session object
346
 
   *
347
 
   * @retval true Success
348
 
   * @retval false Failure
349
 
   */
350
 
  bool sendShutdownEvent(Session::reference session);
351
 
 
 
399
  TransactionId getNextTransactionId()
 
400
  {
 
401
    return current_transaction_id.increment();
 
402
  }
 
403
  TransactionId getCurrentTransactionId()
 
404
  {
 
405
    return current_transaction_id;
 
406
  }
 
407
  /**
 
408
   * DEBUG ONLY.  See plugin::TransactionLog::truncate()
 
409
   */
 
410
  void resetTransactionId()
 
411
  {
 
412
    current_transaction_id= 0;
 
413
  }
352
414
private:
353
 
 
354
 
  /**
355
 
   * Method which returns the active Transaction message
356
 
   * for the supplied Session.  If one is not found, a new Transaction
357
 
   * message is allocated, initialized, and returned. It is possible that
358
 
   * we may want to NOT increment the transaction id for a new Transaction
359
 
   * object (e.g., splitting up Transactions into smaller chunks). The
360
 
   * should_inc_trx_id flag controls if we do this.
361
 
   *
362
 
   * @param session The Session object processing the transaction
363
 
   * @param should_inc_trx_id If true, increments the transaction id for a new trx
364
 
   */
365
 
  message::Transaction *getActiveTransactionMessage(Session::reference session,
366
 
                                                    bool should_inc_trx_id= true);
367
 
 
368
 
  /** 
369
 
   * Method which attaches a transaction context
370
 
   * the supplied transaction based on the supplied Session's
371
 
   * transaction information.  This method also ensure the
372
 
   * transaction message is attached properly to the Session object
373
 
   *
374
 
   * @param transaction The transaction message to initialize
375
 
   * @param session The Session object processing this transaction
376
 
   * @param should_inc_trx_id If true, increments the transaction id for a new trx
377
 
   */
378
 
  void initTransactionMessage(message::Transaction &transaction,
379
 
                              Session::reference session,
380
 
                              bool should_inc_trx_id);
381
 
  
382
 
  /**
383
 
   * Helper method which initializes a Statement message
384
 
   *
385
 
   * @param statement The statement to initialize
386
 
   * @param type The type of the statement
387
 
   * @param session The Session object processing this statement
388
 
   */
389
 
  void initStatementMessage(message::Statement &statement,
390
 
                            message::Statement::Type type,
391
 
                            Session::const_reference session);
392
 
 
393
 
  /** 
394
 
   * Helper method which finalizes data members for the 
395
 
   * supplied transaction's context.
396
 
   *
397
 
   * @param transaction The transaction message to finalize 
398
 
   * @param session The Session object processing this transaction
399
 
   */
400
 
  void finalizeTransactionMessage(message::Transaction &transaction,
401
 
                                  Session::const_reference session);
402
 
 
403
 
  /**
404
 
   * Helper method which deletes transaction memory and
405
 
   * unsets Session's transaction and statement messages.
406
 
   */
407
 
  void cleanupTransactionMessage(message::Transaction *transaction,
408
 
                                 Session::reference session);
409
 
  
410
 
  /** Helper method which returns an initialized Statement message for methods
411
 
   * doing insertion of data.
412
 
   *
413
 
   * @param[in] session Session object doing the processing
414
 
   * @param[in] table Table object being inserted into
415
 
   * @param[out] next_segment_id The next Statement segment id to be used
416
 
   */
417
 
  message::Statement &getInsertStatement(Session::reference session,
418
 
                                         Table &table,
419
 
                                         uint32_t *next_segment_id);
420
 
  
421
 
  /**
422
 
   * Helper method which initializes the header message for
423
 
   * insert operations.
424
 
   *
425
 
   * @param[in,out] statement Statement message container to modify
426
 
   * @param[in] session Session object doing the processing
427
 
   * @param[in] table Table object being inserted into
428
 
   */
429
 
  void setInsertHeader(message::Statement &statement,
430
 
                       Session::const_reference session,
431
 
                       Table &table);
432
 
  /**
433
 
   * Helper method which returns an initialized Statement
434
 
   * message for methods doing updates of data.
435
 
   *
436
 
   * @param[in] session Session object doing the processing
437
 
   * @param[in] table Table object being updated
438
 
   * @param[in] old_record Pointer to the old data in the record
439
 
   * @param[in] new_record Pointer to the new data in the record
440
 
   * @param[out] next_segment_id The next Statement segment id to be used
441
 
   */
442
 
  message::Statement &getUpdateStatement(Session::reference session,
443
 
                                         Table &table,
444
 
                                         const unsigned char *old_record, 
445
 
                                         const unsigned char *new_record,
446
 
                                         uint32_t *next_segment_id);
447
 
  /**
448
 
   * Helper method which initializes the header message for
449
 
   * update operations.
450
 
   *
451
 
   * @param[in,out] statement Statement message container to modify
452
 
   * @param[in] session Session object doing the processing
453
 
   * @param[in] table Table object being updated
454
 
   * @param[in] old_record Pointer to the old data in the record
455
 
   * @param[in] new_record Pointer to the new data in the record
456
 
   */
457
 
  void setUpdateHeader(message::Statement &statement,
458
 
                       Session::const_reference session,
459
 
                       Table &table,
460
 
                       const unsigned char *old_record, 
461
 
                       const unsigned char *new_record);
462
 
 
463
 
  /**
464
 
   * Helper method which returns an initialized Statement
465
 
   * message for methods doing deletion of data.
466
 
   *
467
 
   * @param[in] session Session object doing the processing
468
 
   * @param[in] table Table object being deleted from
469
 
   * @param[out] next_segment_id The next Statement segment id to be used
470
 
   */
471
 
  message::Statement &getDeleteStatement(Session::reference session,
472
 
                                         Table &table,
473
 
                                         uint32_t *next_segment_id);
474
 
  
475
 
  /**
476
 
   * Helper method which initializes the header message for
477
 
   * insert operations.
478
 
   *
479
 
   * @param[in,out] statement Statement message container to modify
480
 
   * @param[in] session Session object doing the processing
481
 
   * @param[in] table Table object being deleted from
482
 
   */
483
 
  void setDeleteHeader(message::Statement &statement,
484
 
                       Session::const_reference session,
485
 
                       Table &table);
486
 
 
487
 
  /** 
488
 
   * Commits a normal transaction (see above) and pushes the transaction
489
 
   * message out to the replicators.
490
 
   *
491
 
   * @param session Session object committing the transaction
492
 
   */
493
 
  int commitTransactionMessage(Session::reference session);
494
 
 
495
 
  /** 
496
 
   * Marks the current active transaction message as being rolled back and
497
 
   * pushes the transaction message out to replicators.
498
 
   *
499
 
   * @param session Session object committing the transaction
500
 
   */
501
 
  void rollbackTransactionMessage(Session::reference session);
502
 
 
503
 
  /**
504
 
   * Rolls back the current statement, deleting the last Statement out of
505
 
   * the current Transaction message.
506
 
   *
507
 
   * @param session Session object committing the transaction
508
 
   *
509
 
   * @note This depends on having clear statement boundaries (i.e., one
510
 
   * Statement message per actual SQL statement).
511
 
   */
512
 
  void rollbackStatementMessage(Session::reference session);
513
 
 
514
 
  /**
515
 
   * Checks if a field has been updated 
516
 
   *
517
 
   * @param current_field Pointer to the field to check if it is updated 
518
 
   * @param table Table object containing update information
519
 
   * @param old_record Pointer to the raw bytes representing the old record/row
520
 
   * @param new_record Pointer to the raw bytes representing the new record/row
521
 
   */
522
 
  bool isFieldUpdated(Field *current_field,
523
 
                      Table &table,
524
 
                      const unsigned char *old_record,
525
 
                      const unsigned char *new_record);
526
 
 
527
 
  /**
528
 
   * Create a Transaction that contains event information and send it off.
529
 
   *
530
 
   * This differs from other uses of Transaction in that we don't use the
531
 
   * message associated with Session. We create a totally new message and
532
 
   * use it.
533
 
   *
534
 
   * @param session Session object
535
 
   * @param event Event message to send
536
 
   *
537
 
   * @note Used by the public Events API.
538
 
   *
539
 
   * @returns Non-zero on error
540
 
   */
541
 
  int sendEvent(Session::reference session, const message::Event &event);
542
 
 
543
 
  /**
544
 
   * Makes a given Transaction message segmented.
545
 
   *
546
 
   * The given Transaction message will have its segment information set
547
 
   * appropriately and a new Transaction message, containing the same
548
 
   * transaction ID as the supplied Transaction, and is created.
549
 
   *
550
 
   * @param session Session object
551
 
   * @param transaction Transaction message to segment.
552
 
   *
553
 
   * @returns Returns a pointer to a new Transaction message ready for use.
554
 
   */
555
 
  message::Transaction *segmentTransactionMessage(Session::reference session,
556
 
                                                  message::Transaction *transaction);
557
 
 
558
 
  int commitPhaseOne(Session::reference session, bool all);
559
 
 
560
 
  uint64_t getCurrentTransactionId(Session::reference session);
561
 
 
562
 
  plugin::XaStorageEngine *xa_storage_engine;
 
415
  atomic<TransactionId> current_transaction_id;
563
416
};
564
417
 
565
418
} /* namespace drizzled */