← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/transaction_services.h

  • Committer: Brian Aker
  • Date: 2011-03-24 23:14:46 UTC
  • mfrom: (2246.4.12 foreach)
  • Revision ID: brian@tangent.org-20110324231446-7q1gydkglys73nft
Merge in XTF

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/transaction_services.h
84
84
   * @param session The Session object processing this statement
85
85
   */
86
86
  void finalizeStatementMessage(message::Statement &statement,
87
 
                                Session::reference session);
 
87
                                Session& session);
88
88
 
89
89
  /**
90
90
   * Creates a new InsertRecord GPB message and pushes it to
96
96
   * Grr, returning "true" here on error because of the cursor
97
97
   * reversed bool return crap...fix that.
98
98
   */
99
 
  bool insertRecord(Session::reference session, Table &in_table);
 
99
  bool insertRecord(Session& session, Table &in_table);
100
100
 
101
101
  /**
102
102
   * Creates a new UpdateRecord GPB message and pushes it to
107
107
   * @param old_record Pointer to the raw bytes representing the old record/row
108
108
   * @param new_record Pointer to the raw bytes representing the new record/row 
109
109
   */
110
 
  void updateRecord(Session::reference session, 
 
110
  void updateRecord(Session& session, 
111
111
                    Table &table, 
112
112
                    const unsigned char *old_record, 
113
113
                    const unsigned char *new_record);
120
120
   * @param table Table object containing delete information
121
121
   * @param use_update_record If true, uses the values from the update row instead
122
122
   */
123
 
  void deleteRecord(Session::reference session,
 
123
  void deleteRecord(Session& session,
124
124
                    Table &table,
125
125
                    bool use_update_record= false);
126
126
 
132
132
   * @param[in] session Session object which issued the statement
133
133
   * @param[in] schema message::Schema message describing new schema
134
134
   */
135
 
  void createSchema(Session::reference session, const message::Schema &schema);
 
135
  void createSchema(Session& session, const message::Schema &schema);
136
136
 
137
137
  /**
138
138
   * Creates a DropSchema Statement GPB message and adds it
142
142
   * @param[in] session Session object which issued the statement
143
143
   * @param[in] identifier Identifier for the schema to drop
144
144
   */
145
 
  void dropSchema(Session::reference session,
146
 
                  identifier::Schema::const_reference identifier,
 
145
  void dropSchema(Session& session,
 
146
                  const identifier::Schema& identifier,
147
147
                  message::schema::const_reference schema);
148
148
 
149
149
  /**
155
155
   * @param[in] old_schema Original schema definition
156
156
   * @param[in] new_schema New schema definition
157
157
   */
158
 
  void alterSchema(Session::reference session,
 
158
  void alterSchema(Session& session,
159
159
                   const message::Schema &old_schema,
160
160
                   const message::Schema &new_schema);
161
161
 
167
167
   * @param[in] session Session object which issued the statement
168
168
   * @param[in] table message::Table message describing new schema
169
169
   */
170
 
  void createTable(Session::reference session, const message::Table &table);
 
170
  void createTable(Session& session, const message::Table &table);
171
171
 
172
172
  /**
173
173
   * Creates a DropTable Statement GPB message and adds it
178
178
   * @param[in] table Identifier for the table being dropped
179
179
   * @param[in] if_exists Did the user specify an IF EXISTS clause?
180
180
   */
181
 
  void dropTable(Session::reference session,
182
 
                 identifier::Table::const_reference identifier,
 
181
  void dropTable(Session& session,
 
182
                 const identifier::Table& identifier,
183
183
                 message::table::const_reference table,
184
184
                 bool if_exists);
185
185
 
191
191
   * @param[in] session Session object which issued the statement
192
192
   * @param[in] table The Table being truncated
193
193
   */
194
 
  void truncateTable(Session::reference session, Table &table);
 
194
  void truncateTable(Session& session, Table &table);
195
195
 
196
196
  /**
197
197
   * Creates a new RawSql GPB message and pushes it to 
206
206
   * @param query Query string
207
207
   * @param schema Schema for the table affected by the raw SQL.
208
208
   */
209
 
  void rawStatement(Session::reference session,
 
209
  void rawStatement(Session& session,
210
210
                    const std::string &query,
211
211
                    const std::string &schema);
212
212
 
213
 
  void rawStatement(Session::reference session, const std::string &query)
 
213
  void rawStatement(Session& session, const std::string &query)
214
214
  {
215
215
    rawStatement(session, query, "");
216
216
  }
217
217
 
218
218
  /* transactions: interface to plugin::StorageEngine functions */
219
 
  int rollbackTransaction(Session::reference session, bool all);
 
219
  int rollbackTransaction(Session& session, bool all);
220
220
 
221
221
  /**
222
222
   * Commit the current transaction.
231
231
   * stored functions or triggers. So we simply do nothing now.
232
232
   * This should be fixed in later ( >= 5.1) releases.
233
233
   */
234
 
  int commitTransaction(Session::reference session, bool all);
 
234
  int commitTransaction(Session& session, bool all);
235
235
 
236
236
  /**
237
237
   * This is used to commit or rollback a single statement depending on
244
244
   * the user has used LOCK TABLES then that mechanism does not know to do the
245
245
   * commit.
246
246
   */
247
 
  int autocommitOrRollback(Session::reference session, int error);
 
247
  int autocommitOrRollback(Session& session, int error);
248
248
 
249
249
  /* savepoints */
250
 
  int rollbackToSavepoint(Session::reference session, NamedSavepoint &sv);
251
 
  int setSavepoint(Session::reference session, NamedSavepoint &sv);
252
 
  int releaseSavepoint(Session::reference session, NamedSavepoint &sv);
 
250
  int rollbackToSavepoint(Session& session, NamedSavepoint &sv);
 
251
  int setSavepoint(Session& session, NamedSavepoint &sv);
 
252
  int releaseSavepoint(Session& session, NamedSavepoint &sv);
253
253
 
254
254
  /**
255
255
   * Marks a storage engine as participating in a statement
269
269
   * @param[in] monitored Descriptor for the resource which will be participating
270
270
   * @param[in] engine Pointer to the TransactionalStorageEngine resource
271
271
   */
272
 
  void registerResourceForStatement(Session::reference session,
 
272
  void registerResourceForStatement(Session& session,
273
273
                                    plugin::MonitoredInTransaction *monitored,
274
274
                                    plugin::TransactionalStorageEngine *engine);
275
275
 
292
292
   * @param[in] engine Pointer to the TransactionalStorageEngine resource
293
293
   * @param[in] resource_manager Pointer to the XaResourceManager resource manager
294
294
   */
295
 
  void registerResourceForStatement(Session::reference session,
 
295
  void registerResourceForStatement(Session& session,
296
296
                                    plugin::MonitoredInTransaction *monitored,
297
297
                                    plugin::TransactionalStorageEngine *engine,
298
298
                                    plugin::XaResourceManager *resource_manager);
321
321
   * time when this method is called except from the
322
322
   * TransactionServices::registerResourceForStatement method.
323
323
   */
324
 
  void registerResourceForTransaction(Session::reference session,
 
324
  void registerResourceForTransaction(Session& session,
325
325
                                      plugin::MonitoredInTransaction *monitored,
326
326
                                      plugin::TransactionalStorageEngine *engine);
327
327
 
328
 
  void registerResourceForTransaction(Session::reference session,
 
328
  void registerResourceForTransaction(Session& session,
329
329
                                      plugin::MonitoredInTransaction *monitored,
330
330
                                      plugin::TransactionalStorageEngine *engine,
331
331
                                      plugin::XaResourceManager *resource_manager);
344
344
   * @retval true Success
345
345
   * @retval false Failure
346
346
   */
347
 
  bool sendStartupEvent(Session::reference session);
 
347
  bool sendStartupEvent(Session& session);
348
348
 
349
349
  /**
350
350
   * Send server shutdown event.
354
354
   * @retval true Success
355
355
   * @retval false Failure
356
356
   */
357
 
  bool sendShutdownEvent(Session::reference session);
 
357
  bool sendShutdownEvent(Session& session);
358
358
 
359
359
private:
360
360
 
369
369
   * @param session The Session object processing the transaction
370
370
   * @param should_inc_trx_id If true, increments the transaction id for a new trx
371
371
   */
372
 
  message::Transaction *getActiveTransactionMessage(Session::reference session,
 
372
  message::Transaction *getActiveTransactionMessage(Session& session,
373
373
                                                    bool should_inc_trx_id= true);
374
374
 
375
375
  /** 
383
383
   * @param should_inc_trx_id If true, increments the transaction id for a new trx
384
384
   */
385
385
  void initTransactionMessage(message::Transaction &transaction,
386
 
                              Session::reference session,
 
386
                              Session& session,
387
387
                              bool should_inc_trx_id);
388
388
  
389
389
  /**
395
395
   */
396
396
  void initStatementMessage(message::Statement &statement,
397
397
                            message::Statement::Type type,
398
 
                            Session::const_reference session);
 
398
                            const Session& session);
399
399
 
400
400
  /** 
401
401
   * Helper method which finalizes data members for the 
405
405
   * @param session The Session object processing this transaction
406
406
   */
407
407
  void finalizeTransactionMessage(message::Transaction &transaction,
408
 
                                  Session::const_reference session);
 
408
                                  const Session& session);
409
409
 
410
410
  /**
411
411
   * Helper method which deletes transaction memory and
412
412
   * unsets Session's transaction and statement messages.
413
413
   */
414
414
  void cleanupTransactionMessage(message::Transaction *transaction,
415
 
                                 Session::reference session);
 
415
                                 Session& session);
416
416
  
417
417
  /** Helper method which returns an initialized Statement message for methods
418
418
   * doing insertion of data.
421
421
   * @param[in] table Table object being inserted into
422
422
   * @param[out] next_segment_id The next Statement segment id to be used
423
423
   */
424
 
  message::Statement &getInsertStatement(Session::reference session,
 
424
  message::Statement &getInsertStatement(Session& session,
425
425
                                         Table &table,
426
426
                                         uint32_t *next_segment_id);
427
427
  
434
434
   * @param[in] table Table object being inserted into
435
435
   */
436
436
  void setInsertHeader(message::Statement &statement,
437
 
                       Session::const_reference session,
 
437
                       const Session& session,
438
438
                       Table &table);
439
439
  /**
440
440
   * Helper method which returns an initialized Statement
446
446
   * @param[in] new_record Pointer to the new data in the record
447
447
   * @param[out] next_segment_id The next Statement segment id to be used
448
448
   */
449
 
  message::Statement &getUpdateStatement(Session::reference session,
 
449
  message::Statement &getUpdateStatement(Session& session,
450
450
                                         Table &table,
451
451
                                         const unsigned char *old_record, 
452
452
                                         const unsigned char *new_record,
462
462
   * @param[in] new_record Pointer to the new data in the record
463
463
   */
464
464
  void setUpdateHeader(message::Statement &statement,
465
 
                       Session::const_reference session,
 
465
                       const Session& session,
466
466
                       Table &table,
467
467
                       const unsigned char *old_record, 
468
468
                       const unsigned char *new_record);
475
475
   * @param[in] table Table object being deleted from
476
476
   * @param[out] next_segment_id The next Statement segment id to be used
477
477
   */
478
 
  message::Statement &getDeleteStatement(Session::reference session,
 
478
  message::Statement &getDeleteStatement(Session& session,
479
479
                                         Table &table,
480
480
                                         uint32_t *next_segment_id);
481
481
  
488
488
   * @param[in] table Table object being deleted from
489
489
   */
490
490
  void setDeleteHeader(message::Statement &statement,
491
 
                       Session::const_reference session,
 
491
                       const Session& session,
492
492
                       Table &table);
493
493
 
494
494
  /** 
497
497
   *
498
498
   * @param session Session object committing the transaction
499
499
   */
500
 
  int commitTransactionMessage(Session::reference session);
 
500
  int commitTransactionMessage(Session& session);
501
501
 
502
502
  /** 
503
503
   * Marks the current active transaction message as being rolled back and
505
505
   *
506
506
   * @param session Session object committing the transaction
507
507
   */
508
 
  void rollbackTransactionMessage(Session::reference session);
 
508
  void rollbackTransactionMessage(Session& session);
509
509
 
510
510
  /**
511
511
   * Rolls back the current statement, deleting the last Statement out of
516
516
   * @note This depends on having clear statement boundaries (i.e., one
517
517
   * Statement message per actual SQL statement).
518
518
   */
519
 
  void rollbackStatementMessage(Session::reference session);
 
519
  void rollbackStatementMessage(Session& session);
520
520
 
521
521
  /**
522
522
   * Checks if a field has been updated 
545
545
   *
546
546
   * @returns Non-zero on error
547
547
   */
548
 
  int sendEvent(Session::reference session, const message::Event &event);
 
548
  int sendEvent(Session& session, const message::Event &event);
549
549
 
550
550
  /**
551
551
   * Makes a given Transaction message segmented.
559
559
   *
560
560
   * @returns Returns a pointer to a new Transaction message ready for use.
561
561
   */
562
 
  message::Transaction *segmentTransactionMessage(Session::reference session,
 
562
  message::Transaction *segmentTransactionMessage(Session& session,
563
563
                                                  message::Transaction *transaction);
564
564
 
565
 
  int commitPhaseOne(Session::reference session, bool all);
 
565
  int commitPhaseOne(Session& session, bool all);
566
566
 
567
 
  uint64_t getCurrentTransactionId(Session::reference session);
 
567
  uint64_t getCurrentTransactionId(Session& session);
568
568
 
569
569
  plugin::XaStorageEngine *xa_storage_engine;
570
570
};