← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/transaction_services.cc

  • Committer: Olaf van der Spek
  • Date: 2011-03-24 00:03:05 UTC
  • mto: This revision was merged to the branch mainline in revision 2251.
  • Revision ID: olafvdspek@gmail.com-20110324000305-p9tdkxd15wjhagjb
Remove const_reference and reference from identifier::User

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();
1009
1009
}
1010
1010
 
1011
1011
void TransactionServices::initTransactionMessage(message::Transaction &transaction,
1012
 
                                                 Session::reference session,
 
1012
                                                 Session& session,
1013
1013
                                                 bool should_inc_trx_id)
1014
1014
{
1015
1015
  message::TransactionContext *trx= transaction.mutable_transaction_context();
1034
1034
}
1035
1035
 
1036
1036
void TransactionServices::finalizeTransactionMessage(message::Transaction &transaction,
1037
 
                                                     Session::const_reference session)
 
1037
                                                     const Session& session)
1038
1038
{
1039
1039
  message::TransactionContext *trx= transaction.mutable_transaction_context();
1040
1040
  trx->set_end_timestamp(session.getCurrentTimestamp());
1041
1041
}
1042
1042
 
1043
1043
void TransactionServices::cleanupTransactionMessage(message::Transaction *transaction,
1044
 
                                                    Session::reference session)
 
1044
                                                    Session& session)
1045
1045
{
1046
1046
  delete transaction;
1047
1047
  session.setStatementMessage(NULL);
1049
1049
  session.setXaId(0);
1050
1050
}
1051
1051
 
1052
 
int TransactionServices::commitTransactionMessage(Session::reference session)
 
1052
int TransactionServices::commitTransactionMessage(Session& session)
1053
1053
{
1054
1054
  ReplicationServices &replication_services= ReplicationServices::singleton();
1055
1055
  if (! replication_services.isActive())
1095
1095
 
1096
1096
void TransactionServices::initStatementMessage(message::Statement &statement,
1097
1097
                                               message::Statement::Type type,
1098
 
                                               Session::const_reference session)
 
1098
                                               const Session& session)
1099
1099
{
1100
1100
  statement.set_type(type);
1101
1101
  statement.set_start_timestamp(session.getCurrentTimestamp());
1105
1105
}
1106
1106
 
1107
1107
void TransactionServices::finalizeStatementMessage(message::Statement &statement,
1108
 
                                                   Session::reference session)
 
1108
                                                   Session& session)
1109
1109
{
1110
1110
  statement.set_end_timestamp(session.getCurrentTimestamp());
1111
1111
  session.setStatementMessage(NULL);
1112
1112
}
1113
1113
 
1114
 
void TransactionServices::rollbackTransactionMessage(Session::reference session)
 
1114
void TransactionServices::rollbackTransactionMessage(Session& session)
1115
1115
{
1116
1116
  ReplicationServices &replication_services= ReplicationServices::singleton();
1117
1117
  if (! replication_services.isActive())
1167
1167
  cleanupTransactionMessage(transaction, session);
1168
1168
}
1169
1169
 
1170
 
void TransactionServices::rollbackStatementMessage(Session::reference session)
 
1170
void TransactionServices::rollbackStatementMessage(Session& session)
1171
1171
{
1172
1172
  ReplicationServices &replication_services= ReplicationServices::singleton();
1173
1173
  if (! replication_services.isActive())
1233
1233
  }
1234
1234
}
1235
1235
 
1236
 
message::Transaction *TransactionServices::segmentTransactionMessage(Session::reference session,
 
1236
message::Transaction *TransactionServices::segmentTransactionMessage(Session& session,
1237
1237
                                                                     message::Transaction *transaction)
1238
1238
{
1239
1239
  uint64_t trx_id= transaction->transaction_context().transaction_id();
1251
1251
  return transaction;
1252
1252
}
1253
1253
 
1254
 
message::Statement &TransactionServices::getInsertStatement(Session::reference session,
 
1254
message::Statement &TransactionServices::getInsertStatement(Session& session,
1255
1255
                                                            Table &table,
1256
1256
                                                            uint32_t *next_segment_id)
1257
1257
{
1342
1342
}
1343
1343
 
1344
1344
void TransactionServices::setInsertHeader(message::Statement &statement,
1345
 
                                          Session::const_reference session,
 
1345
                                          const Session& session,
1346
1346
                                          Table &table)
1347
1347
{
1348
1348
  initStatementMessage(statement, message::Statement::INSERT, session);
1379
1379
  }
1380
1380
}
1381
1381
 
1382
 
bool TransactionServices::insertRecord(Session::reference session,
 
1382
bool TransactionServices::insertRecord(Session& session,
1383
1383
                                       Table &table)
1384
1384
{
1385
1385
  ReplicationServices &replication_services= ReplicationServices::singleton();
1438
1438
  return false;
1439
1439
}
1440
1440
 
1441
 
message::Statement &TransactionServices::getUpdateStatement(Session::reference session,
 
1441
message::Statement &TransactionServices::getUpdateStatement(Session& session,
1442
1442
                                                            Table &table,
1443
1443
                                                            const unsigned char *old_record, 
1444
1444
                                                            const unsigned char *new_record,
1531
1531
}
1532
1532
 
1533
1533
void TransactionServices::setUpdateHeader(message::Statement &statement,
1534
 
                                          Session::const_reference session,
 
1534
                                          const Session& session,
1535
1535
                                          Table &table,
1536
1536
                                          const unsigned char *old_record, 
1537
1537
                                          const unsigned char *new_record)
1585
1585
  }
1586
1586
}
1587
1587
 
1588
 
void TransactionServices::updateRecord(Session::reference session,
 
1588
void TransactionServices::updateRecord(Session& session,
1589
1589
                                       Table &table, 
1590
1590
                                       const unsigned char *old_record, 
1591
1591
                                       const unsigned char *new_record)
1716
1716
  return isUpdated;
1717
1717
}  
1718
1718
 
1719
 
message::Statement &TransactionServices::getDeleteStatement(Session::reference session,
 
1719
message::Statement &TransactionServices::getDeleteStatement(Session& session,
1720
1720
                                                            Table &table,
1721
1721
                                                            uint32_t *next_segment_id)
1722
1722
{
1807
1807
}
1808
1808
 
1809
1809
void TransactionServices::setDeleteHeader(message::Statement &statement,
1810
 
                                          Session::const_reference session,
 
1810
                                          const Session& session,
1811
1811
                                          Table &table)
1812
1812
{
1813
1813
  initStatementMessage(statement, message::Statement::DELETE, session);
1848
1848
  }
1849
1849
}
1850
1850
 
1851
 
void TransactionServices::deleteRecord(Session::reference session,
 
1851
void TransactionServices::deleteRecord(Session& session,
1852
1852
                                       Table &table,
1853
1853
                                       bool use_update_record)
1854
1854
{
1908
1908
  }
1909
1909
}
1910
1910
 
1911
 
void TransactionServices::createTable(Session::reference session,
 
1911
void TransactionServices::createTable(Session& session,
1912
1912
                                      const message::Table &table)
1913
1913
{
1914
1914
  ReplicationServices &replication_services= ReplicationServices::singleton();
1941
1941
 
1942
1942
}
1943
1943
 
1944
 
void TransactionServices::createSchema(Session::reference session,
 
1944
void TransactionServices::createSchema(Session& session,
1945
1945
                                       const message::Schema &schema)
1946
1946
{
1947
1947
  ReplicationServices &replication_services= ReplicationServices::singleton();
1974
1974
 
1975
1975
}
1976
1976
 
1977
 
void TransactionServices::dropSchema(Session::reference session,
 
1977
void TransactionServices::dropSchema(Session& session,
1978
1978
                                     const identifier::Schema& identifier,
1979
1979
                                     message::schema::const_reference schema)
1980
1980
{
2007
2007
  cleanupTransactionMessage(transaction, session);
2008
2008
}
2009
2009
 
2010
 
void TransactionServices::alterSchema(Session::reference session,
 
2010
void TransactionServices::alterSchema(Session& session,
2011
2011
                                      const message::Schema &old_schema,
2012
2012
                                      const message::Schema &new_schema)
2013
2013
{
2044
2044
  cleanupTransactionMessage(transaction, session);
2045
2045
}
2046
2046
 
2047
 
void TransactionServices::dropTable(Session::reference session,
 
2047
void TransactionServices::dropTable(Session& session,
2048
2048
                                    const identifier::Table& identifier,
2049
2049
                                    message::table::const_reference table,
2050
2050
                                    bool if_exists)
2083
2083
  cleanupTransactionMessage(transaction, session);
2084
2084
}
2085
2085
 
2086
 
void TransactionServices::truncateTable(Session::reference session,
 
2086
void TransactionServices::truncateTable(Session& session,
2087
2087
                                        Table &table)
2088
2088
{
2089
2089
  ReplicationServices &replication_services= ReplicationServices::singleton();
2123
2123
  cleanupTransactionMessage(transaction, session);
2124
2124
}
2125
2125
 
2126
 
void TransactionServices::rawStatement(Session::reference session,
 
2126
void TransactionServices::rawStatement(Session& session,
2127
2127
                                       const string &query,
2128
2128
                                       const string &schema)
2129
2129
{
2147
2147
  cleanupTransactionMessage(transaction, session);
2148
2148
}
2149
2149
 
2150
 
int TransactionServices::sendEvent(Session::reference session,
 
2150
int TransactionServices::sendEvent(Session& session,
2151
2151
                                   const message::Event &event)
2152
2152
{
2153
2153
  ReplicationServices &replication_services= ReplicationServices::singleton();
2173
2173
  return static_cast<int>(result);
2174
2174
}
2175
2175
 
2176
 
bool TransactionServices::sendStartupEvent(Session::reference session)
 
2176
bool TransactionServices::sendStartupEvent(Session& session)
2177
2177
{
2178
2178
  message::Event event;
2179
2179
  event.set_type(message::Event::STARTUP);
2182
2182
  return true;
2183
2183
}
2184
2184
 
2185
 
bool TransactionServices::sendShutdownEvent(Session::reference session)
 
2185
bool TransactionServices::sendShutdownEvent(Session& session)
2186
2186
{
2187
2187
  message::Event event;
2188
2188
  event.set_type(message::Event::SHUTDOWN);