← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/transaction_services.cc

  • 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.cc
315
315
  }
316
316
}
317
317
 
318
 
void TransactionServices::registerResourceForStatement(Session::reference session,
 
318
void TransactionServices::registerResourceForStatement(Session& session,
319
319
                                                       plugin::MonitoredInTransaction *monitored,
320
320
                                                       plugin::TransactionalStorageEngine *engine)
321
321
{
347
347
  trans->no_2pc|= true;
348
348
}
349
349
 
350
 
void TransactionServices::registerResourceForStatement(Session::reference session,
 
350
void TransactionServices::registerResourceForStatement(Session& session,
351
351
                                                       plugin::MonitoredInTransaction *monitored,
352
352
                                                       plugin::TransactionalStorageEngine *engine,
353
353
                                                       plugin::XaResourceManager *resource_manager)
381
381
  trans->no_2pc|= false;
382
382
}
383
383
 
384
 
void TransactionServices::registerResourceForTransaction(Session::reference session,
 
384
void TransactionServices::registerResourceForTransaction(Session& session,
385
385
                                                         plugin::MonitoredInTransaction *monitored,
386
386
                                                         plugin::TransactionalStorageEngine *engine)
387
387
{
410
410
    registerResourceForStatement(session, monitored, engine);
411
411
}
412
412
 
413
 
void TransactionServices::registerResourceForTransaction(Session::reference session,
 
413
void TransactionServices::registerResourceForTransaction(Session& session,
414
414
                                                         plugin::MonitoredInTransaction *monitored,
415
415
                                                         plugin::TransactionalStorageEngine *engine,
416
416
                                                         plugin::XaResourceManager *resource_manager)
455
455
  my_session->setXaId(xa_id);
456
456
}
457
457
 
458
 
uint64_t TransactionServices::getCurrentTransactionId(Session::reference session)
 
458
uint64_t TransactionServices::getCurrentTransactionId(Session& session)
459
459
{
460
460
  if (session.getXaId() == 0)
461
461
  {
465
465
  return session.getXaId();
466
466
}
467
467
 
468
 
int TransactionServices::commitTransaction(Session::reference session,
 
468
int TransactionServices::commitTransaction(Session& session,
469
469
                                           bool normal_transaction)
470
470
{
471
471
  int error= 0, cookie= 0;
558
558
  @note
559
559
  This function does not care about global read lock. A caller should.
560
560
*/
561
 
int TransactionServices::commitPhaseOne(Session::reference session,
 
561
int TransactionServices::commitPhaseOne(Session& session,
562
562
                                        bool normal_transaction)
563
563
{
564
564
  int error=0;
625
625
  return error;
626
626
}
627
627
 
628
 
int TransactionServices::rollbackTransaction(Session::reference session,
 
628
int TransactionServices::rollbackTransaction(Session& session,
629
629
                                             bool normal_transaction)
630
630
{
631
631
  int error= 0;
718
718
  return error;
719
719
}
720
720
 
721
 
int TransactionServices::autocommitOrRollback(Session::reference session,
 
721
int TransactionServices::autocommitOrRollback(Session& session,
722
722
                                              int error)
723
723
{
724
724
  /* One GPB Statement message per SQL statement */
770
770
  }
771
771
};
772
772
 
773
 
int TransactionServices::rollbackToSavepoint(Session::reference session,
 
773
int TransactionServices::rollbackToSavepoint(Session& session,
774
774
                                             NamedSavepoint &sv)
775
775
{
776
776
  int error= 0;
900
900
  section "4.33.4 SQL-statements and transaction states",
901
901
  NamedSavepoint is *not* transaction-initiating SQL-statement
902
902
*/
903
 
int TransactionServices::setSavepoint(Session::reference session,
 
903
int TransactionServices::setSavepoint(Session& session,
904
904
                                      NamedSavepoint &sv)
905
905
{
906
906
  int error= 0;
952
952
  return error;
953
953
}
954
954
 
955
 
int TransactionServices::releaseSavepoint(Session::reference session,
 
955
int TransactionServices::releaseSavepoint(Session& session,
956
956
                                          NamedSavepoint &sv)
957
957
{
958
958
  int error= 0;
987
987
  return replication_services.isActive();
988
988
}
989
989
 
990
 
message::Transaction *TransactionServices::getActiveTransactionMessage(Session::reference session,
 
990
message::Transaction *TransactionServices::getActiveTransactionMessage(Session& session,
991
991
                                                                       bool should_inc_trx_id)
992
992
{
993
993
  message::Transaction *transaction= session.getTransactionMessage();
1007
1007
}
1008
1008
 
1009
1009
void TransactionServices::initTransactionMessage(message::Transaction &transaction,
1010
 
                                                 Session::reference session,
 
1010
                                                 Session& session,
1011
1011
                                                 bool should_inc_trx_id)
1012
1012
{
1013
1013
  message::TransactionContext *trx= transaction.mutable_transaction_context();
1032
1032
}
1033
1033
 
1034
1034
void TransactionServices::finalizeTransactionMessage(message::Transaction &transaction,
1035
 
                                                     Session::const_reference session)
 
1035
                                                     const Session& session)
1036
1036
{
1037
1037
  message::TransactionContext *trx= transaction.mutable_transaction_context();
1038
1038
  trx->set_end_timestamp(session.getCurrentTimestamp());
1039
1039
}
1040
1040
 
1041
1041
void TransactionServices::cleanupTransactionMessage(message::Transaction *transaction,
1042
 
                                                    Session::reference session)
 
1042
                                                    Session& session)
1043
1043
{
1044
1044
  delete transaction;
1045
1045
  session.setStatementMessage(NULL);
1047
1047
  session.setXaId(0);
1048
1048
}
1049
1049
 
1050
 
int TransactionServices::commitTransactionMessage(Session::reference session)
 
1050
int TransactionServices::commitTransactionMessage(Session& session)
1051
1051
{
1052
1052
  ReplicationServices &replication_services= ReplicationServices::singleton();
1053
1053
  if (! replication_services.isActive())
1093
1093
 
1094
1094
void TransactionServices::initStatementMessage(message::Statement &statement,
1095
1095
                                               message::Statement::Type type,
1096
 
                                               Session::const_reference session)
 
1096
                                               const Session& session)
1097
1097
{
1098
1098
  statement.set_type(type);
1099
1099
  statement.set_start_timestamp(session.getCurrentTimestamp());
1103
1103
}
1104
1104
 
1105
1105
void TransactionServices::finalizeStatementMessage(message::Statement &statement,
1106
 
                                                   Session::reference session)
 
1106
                                                   Session& session)
1107
1107
{
1108
1108
  statement.set_end_timestamp(session.getCurrentTimestamp());
1109
1109
  session.setStatementMessage(NULL);
1110
1110
}
1111
1111
 
1112
 
void TransactionServices::rollbackTransactionMessage(Session::reference session)
 
1112
void TransactionServices::rollbackTransactionMessage(Session& session)
1113
1113
{
1114
1114
  ReplicationServices &replication_services= ReplicationServices::singleton();
1115
1115
  if (! replication_services.isActive())
1165
1165
  cleanupTransactionMessage(transaction, session);
1166
1166
}
1167
1167
 
1168
 
void TransactionServices::rollbackStatementMessage(Session::reference session)
 
1168
void TransactionServices::rollbackStatementMessage(Session& session)
1169
1169
{
1170
1170
  ReplicationServices &replication_services= ReplicationServices::singleton();
1171
1171
  if (! replication_services.isActive())
1231
1231
  }
1232
1232
}
1233
1233
 
1234
 
message::Transaction *TransactionServices::segmentTransactionMessage(Session::reference session,
 
1234
message::Transaction *TransactionServices::segmentTransactionMessage(Session& session,
1235
1235
                                                                     message::Transaction *transaction)
1236
1236
{
1237
1237
  uint64_t trx_id= transaction->transaction_context().transaction_id();
1249
1249
  return transaction;
1250
1250
}
1251
1251
 
1252
 
message::Statement &TransactionServices::getInsertStatement(Session::reference session,
 
1252
message::Statement &TransactionServices::getInsertStatement(Session& session,
1253
1253
                                                            Table &table,
1254
1254
                                                            uint32_t *next_segment_id)
1255
1255
{
1340
1340
}
1341
1341
 
1342
1342
void TransactionServices::setInsertHeader(message::Statement &statement,
1343
 
                                          Session::const_reference session,
 
1343
                                          const Session& session,
1344
1344
                                          Table &table)
1345
1345
{
1346
1346
  initStatementMessage(statement, message::Statement::INSERT, session);
1377
1377
  }
1378
1378
}
1379
1379
 
1380
 
bool TransactionServices::insertRecord(Session::reference session,
 
1380
bool TransactionServices::insertRecord(Session& session,
1381
1381
                                       Table &table)
1382
1382
{
1383
1383
  ReplicationServices &replication_services= ReplicationServices::singleton();
1436
1436
  return false;
1437
1437
}
1438
1438
 
1439
 
message::Statement &TransactionServices::getUpdateStatement(Session::reference session,
 
1439
message::Statement &TransactionServices::getUpdateStatement(Session& session,
1440
1440
                                                            Table &table,
1441
1441
                                                            const unsigned char *old_record, 
1442
1442
                                                            const unsigned char *new_record,
1529
1529
}
1530
1530
 
1531
1531
void TransactionServices::setUpdateHeader(message::Statement &statement,
1532
 
                                          Session::const_reference session,
 
1532
                                          const Session& session,
1533
1533
                                          Table &table,
1534
1534
                                          const unsigned char *old_record, 
1535
1535
                                          const unsigned char *new_record)
1583
1583
  }
1584
1584
}
1585
1585
 
1586
 
void TransactionServices::updateRecord(Session::reference session,
 
1586
void TransactionServices::updateRecord(Session& session,
1587
1587
                                       Table &table, 
1588
1588
                                       const unsigned char *old_record, 
1589
1589
                                       const unsigned char *new_record)
1714
1714
  return isUpdated;
1715
1715
}  
1716
1716
 
1717
 
message::Statement &TransactionServices::getDeleteStatement(Session::reference session,
 
1717
message::Statement &TransactionServices::getDeleteStatement(Session& session,
1718
1718
                                                            Table &table,
1719
1719
                                                            uint32_t *next_segment_id)
1720
1720
{
1805
1805
}
1806
1806
 
1807
1807
void TransactionServices::setDeleteHeader(message::Statement &statement,
1808
 
                                          Session::const_reference session,
 
1808
                                          const Session& session,
1809
1809
                                          Table &table)
1810
1810
{
1811
1811
  initStatementMessage(statement, message::Statement::DELETE, session);
1846
1846
  }
1847
1847
}
1848
1848
 
1849
 
void TransactionServices::deleteRecord(Session::reference session,
 
1849
void TransactionServices::deleteRecord(Session& session,
1850
1850
                                       Table &table,
1851
1851
                                       bool use_update_record)
1852
1852
{
1906
1906
  }
1907
1907
}
1908
1908
 
1909
 
void TransactionServices::createTable(Session::reference session,
 
1909
void TransactionServices::createTable(Session& session,
1910
1910
                                      const message::Table &table)
1911
1911
{
1912
1912
  ReplicationServices &replication_services= ReplicationServices::singleton();
1939
1939
 
1940
1940
}
1941
1941
 
1942
 
void TransactionServices::createSchema(Session::reference session,
 
1942
void TransactionServices::createSchema(Session& session,
1943
1943
                                       const message::Schema &schema)
1944
1944
{
1945
1945
  ReplicationServices &replication_services= ReplicationServices::singleton();
1972
1972
 
1973
1973
}
1974
1974
 
1975
 
void TransactionServices::dropSchema(Session::reference session,
1976
 
                                     identifier::Schema::const_reference identifier,
 
1975
void TransactionServices::dropSchema(Session& session,
 
1976
                                     const identifier::Schema& identifier,
1977
1977
                                     message::schema::const_reference schema)
1978
1978
{
1979
1979
  ReplicationServices &replication_services= ReplicationServices::singleton();
2005
2005
  cleanupTransactionMessage(transaction, session);
2006
2006
}
2007
2007
 
2008
 
void TransactionServices::alterSchema(Session::reference session,
 
2008
void TransactionServices::alterSchema(Session& session,
2009
2009
                                      const message::Schema &old_schema,
2010
2010
                                      const message::Schema &new_schema)
2011
2011
{
2042
2042
  cleanupTransactionMessage(transaction, session);
2043
2043
}
2044
2044
 
2045
 
void TransactionServices::dropTable(Session::reference session,
2046
 
                                    identifier::Table::const_reference identifier,
 
2045
void TransactionServices::dropTable(Session& session,
 
2046
                                    const identifier::Table& identifier,
2047
2047
                                    message::table::const_reference table,
2048
2048
                                    bool if_exists)
2049
2049
{
2081
2081
  cleanupTransactionMessage(transaction, session);
2082
2082
}
2083
2083
 
2084
 
void TransactionServices::truncateTable(Session::reference session,
 
2084
void TransactionServices::truncateTable(Session& session,
2085
2085
                                        Table &table)
2086
2086
{
2087
2087
  ReplicationServices &replication_services= ReplicationServices::singleton();
2121
2121
  cleanupTransactionMessage(transaction, session);
2122
2122
}
2123
2123
 
2124
 
void TransactionServices::rawStatement(Session::reference session,
 
2124
void TransactionServices::rawStatement(Session& session,
2125
2125
                                       const string &query,
2126
2126
                                       const string &schema)
2127
2127
{
2145
2145
  cleanupTransactionMessage(transaction, session);
2146
2146
}
2147
2147
 
2148
 
int TransactionServices::sendEvent(Session::reference session,
 
2148
int TransactionServices::sendEvent(Session& session,
2149
2149
                                   const message::Event &event)
2150
2150
{
2151
2151
  ReplicationServices &replication_services= ReplicationServices::singleton();
2171
2171
  return static_cast<int>(result);
2172
2172
}
2173
2173
 
2174
 
bool TransactionServices::sendStartupEvent(Session::reference session)
 
2174
bool TransactionServices::sendStartupEvent(Session& session)
2175
2175
{
2176
2176
  message::Event event;
2177
2177
  event.set_type(message::Event::STARTUP);
2180
2180
  return true;
2181
2181
}
2182
2182
 
2183
 
bool TransactionServices::sendShutdownEvent(Session::reference session)
 
2183
bool TransactionServices::sendShutdownEvent(Session& session)
2184
2184
{
2185
2185
  message::Event event;
2186
2186
  event.set_type(message::Event::SHUTDOWN);