InfiniSQL  v0.1.2-alpha
Massive Scale Transaction Processing
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
SubTransaction Class Reference

create Subtransaction object More...

#include <SubTransaction.h>

Collaboration diagram for SubTransaction:
Collaboration graph
[legend]

Public Member Functions

 SubTransaction (Topology::addressStruct &taAddrarg, int64_t transactionidarg, int64_t domainidarg, class Engine *enginePtrarg)
 
virtual ~SubTransaction ()
 

Private Member Functions

void processTransactionMessage (class Message *msgrcvarg)
 handle incoming MessageTransaction variant More...
 
void commitRollbackUnlock (vector< rowOrField_s > *rowOrFields, enginecmd_e cmd)
 commit, rollback, or unlock items More...
 
void processRowLockQueue (int64_t tableid, int64_t rowid)
 operate on transactions waiting for locked row More...
 
void drainRowLockQueue (int64_t tableid, int64_t rowid)
 drain queue of transactions waiting for locked row More...
 
void processIndexLockQueue (int64_t tableid, int64_t fieldid, fieldValue_s *val)
 operate on transactions waiting for locked unique index entry More...
 
void drainIndexLockQueue (int64_t tableid, int64_t fieldid, fieldValue_s *val)
 drain queue of transactions waiting for locked unique index entry More...
 
int64_t newrow (int64_t tableid, std::string row)
 create new row More...
 
locktype_e uniqueIndex (int64_t tableid, int64_t fieldid, int64_t rowid, int64_t engineid, fieldValue_s *val)
 new unique index entry More...
 
int64_t updaterow (int64_t tableid, int64_t rowid, std::string *row)
 
int64_t deleterow (int64_t tableid, int64_t rowid)
 delete row More...
 
int64_t deleterow (int64_t tableid, int64_t rowid, int64_t forward_rowid, int64_t forward_engineid)
 delete row part of row replacement (UPDATEing fieldid 0) More...
 
void indexSearch (int64_t tableid, int64_t fieldid, searchParams_s *searchParameters, vector< nonLockingIndexEntry_s > *indexHits)
 
void selectrows (int64_t tableid, vector< int64_t > *rowids, locktype_e locktype, int64_t pendingcmdid, vector< returnRow_s > *returnRows)
 return rows More...
 
void searchReturn1 (int64_t tableid, int64_t fieldid, locktype_e locktype, searchParams_s &searchParams, vector< returnRow_s > &returnRows)
 search index for and return matching rows More...
 
void replyTransaction (void *data)
 reply to calling TransactionAgent More...
 
void replyTransaction (class MessageTransaction &sndRef, class MessageTransaction &rcvRef)
 reply to calling TransactionAgent More...
 

Private Attributes

int64_t subtransactionid
 
Topology::addressStruct taAddr
 
int64_t transactionid
 
int64_t domainid
 
class Message * msgrcv
 
class Engine * enginePtr
 
class Schema * schemaPtr
 

Friends

class Engine
 

Detailed Description

create Subtransaction object

Parameters
taAddrargaddress of TransactionAgent associated with Transaction
transactionidargrelated transactionid
domainidargdomainid
enginePtrargEngine (partition)

Definition at line 47 of file SubTransaction.h.

Constructor & Destructor Documentation

SubTransaction::SubTransaction ( Topology::addressStruct &  taAddrarg,
int64_t  transactionidarg,
int64_t  domainidarg,
class Engine *  enginePtrarg 
)

Definition at line 33 of file SubTransaction.cc.

References domainid, Engine::domainidsToSchemata, enginePtr, Engine::getnextsubtransactionid(), schemaPtr, subtransactionid, and Engine::SubTransactions.

35  :
36  taAddr(taAddrarg), transactionid(transactionidarg), domainid(domainidarg),
37  enginePtr(enginePtrarg)
38 {
39  subtransactionid = enginePtr->getnextsubtransactionid();
40  enginePtr->SubTransactions[subtransactionid] = this;
41  schemaPtr = enginePtr->domainidsToSchemata[domainid];
42 }

Here is the call graph for this function:

SubTransaction::~SubTransaction ( )
virtual

Definition at line 44 of file SubTransaction.cc.

References enginePtr, subtransactionid, and Engine::SubTransactions.

45 {
46  enginePtr->SubTransactions.erase(subtransactionid);
47 }

Member Function Documentation

void SubTransaction::commitRollbackUnlock ( vector< rowOrField_s > *  rowOrFields,
enginecmd_e  cmd 
)
private

commit, rollback, or unlock items

Parameters
rowOrFieldslist of rows and unique index entries
cmdcommit, rollback or unlock

Definition at line 1722 of file SubTransaction.cc.

References BOOL, fieldInput_u::boolean, CHAR, fieldInput_u::character, CHARX, COMMITCMD, Index::commitRollback(), Table::commitRollbackUnlock(), rowOrField_s::fieldid, Table::fields, Index::fieldtype, rowOrField_s::fieldVal, FLOAT, fieldInput_u::floating, INT, fieldInput_u::integer, rowOrField_s::isrow, logfile, rowOrField_s::rowid, schemaPtr, fieldValue_s::str, subtransactionid, rowOrField_s::tableid, Schema::tables, UINT, fieldInput_u::uinteger, fieldValue_s::value, and VARCHAR.

1724 {
1725  // remember to process lock queue after each item
1726  for (size_t n=0; n<rowOrFields->size(); n++)
1727  {
1728  rowOrField_s &rowOrFieldRef = rowOrFields->at(n);
1729  class Table &tableRef = *schemaPtr->tables[rowOrFieldRef.tableid];
1730 
1731  if (rowOrFieldRef.isrow==true)
1732  {
1733  tableRef.commitRollbackUnlock(rowOrFieldRef.rowid, subtransactionid,
1734  COMMITCMD);
1735  }
1736  else
1737  {
1738  class Index &indexRef = tableRef.fields[rowOrFieldRef.fieldid].index;
1739 
1740  switch (indexRef.fieldtype)
1741  {
1742  case INT:
1743  indexRef.commitRollback(rowOrFieldRef.fieldVal.value.integer,
1744  subtransactionid, cmd);
1745 
1746  case UINT:
1747  indexRef.commitRollback(rowOrFieldRef.fieldVal.value.uinteger,
1748  subtransactionid, cmd);
1749 
1750  case BOOL:
1751  indexRef.commitRollback(rowOrFieldRef.fieldVal.value.boolean,
1752  subtransactionid, cmd);
1753 
1754  case FLOAT:
1755  indexRef.commitRollback(rowOrFieldRef.fieldVal.value.floating,
1756  subtransactionid, cmd);
1757 
1758  case CHAR:
1759  indexRef.commitRollback(rowOrFieldRef.fieldVal.value.character,
1760  subtransactionid, cmd);
1761 
1762  case CHARX:
1763  indexRef.commitRollback(rowOrFieldRef.fieldVal.str,
1764  subtransactionid, cmd);
1765 
1766  case VARCHAR:
1767  indexRef.commitRollback(rowOrFieldRef.fieldVal.str,
1768  subtransactionid, cmd);
1769  break;
1770 
1771  default:
1772  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1773  __LINE__);
1774  }
1775  }
1776  }
1777 }

Here is the call graph for this function:

int64_t SubTransaction::deleterow ( int64_t  tableid,
int64_t  rowid 
)
private

delete row

Parameters
tableidtableid
rowidrowid
Returns

Definition at line 2298 of file SubTransaction.cc.

References Table::deleterow(), schemaPtr, subtransactionid, and Schema::tables.

Referenced by processTransactionMessage().

2299 {
2300  class Table &tableRef = *schemaPtr->tables[tableid];
2301  return tableRef.deleterow(rowid, subtransactionid);
2302 }

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t SubTransaction::deleterow ( int64_t  tableid,
int64_t  rowid,
int64_t  forward_rowid,
int64_t  forward_engineid 
)
private

delete row part of row replacement (UPDATEing fieldid 0)

Parameters
tableidtableid
rowidrowid
forward_rowidnew rowid
forward_engineidnew engineid
Returns

Definition at line 2304 of file SubTransaction.cc.

References Table::deleterow(), schemaPtr, subtransactionid, and Schema::tables.

2307 {
2308  class Table &tableRef = *schemaPtr->tables[tableid];
2309  return tableRef.deleterow(rowid, subtransactionid, forward_rowid,
2310  forward_engineid);
2311 }

Here is the call graph for this function:

void SubTransaction::drainIndexLockQueue ( int64_t  tableid,
int64_t  fieldid,
fieldValue_s *  val 
)
private

drain queue of transactions waiting for locked unique index entry

when index entry cannot be re-locked

Parameters
tableidtableid
fieldidfieldid
valfield value

Definition at line 2171 of file SubTransaction.cc.

References BOOL, fieldInput_u::boolean, Index::boolLockQueue, CHAR, fieldInput_u::character, Index::charLockQueue, CHARX, MessageTransaction::transaction_s::engineinstance, enginePtr, lockQueueIndexEntry::entry, MessageSubtransactionCmd::subtransaction_s::fieldid, Index::fieldtype, MessageSubtransactionCmd::fieldVal, FLOAT, fieldInput_u::floating, Index::floatLockQueue, INT, fieldInput_u::integer, Index::intLockQueue, MessageSubtransactionCmd::subtransaction_s::locktype, logfile, Message::messageStruct, MessageSubtransactionCmd::MessageSubtransactionCmd(), Engine::partitionid, PAYLOADSUBTRANSACTION, Message::message_s::payloadtype, lockQueueIndexEntry::pendingcmdid, PENDINGTOINDEXNOLOCK, replyTransaction(), schemaPtr, fieldValue_s::str, Index::stringLockQueue, lockingIndexEntry::subtransactionid, MessageTransaction::transaction_s::subtransactionid, Engine::SubTransactions, MessageSubtransactionCmd::subtransactionStruct, MessageSubtransactionCmd::subtransaction_s::tableid, Schema::tables, lockQueueIndexEntry::tacmdentrypoint, MessageTransaction::transaction_s::transaction_pendingcmdid, MessageTransaction::transaction_s::transaction_tacmdentrypoint, transactionid, MessageTransaction::transaction_s::transactionid, MessageTransaction::transactionStruct, UINT, fieldInput_u::uinteger, Index::uintLockQueue, fieldValue_s::value, and VARCHAR.

Referenced by processTransactionMessage().

2173 {
2174  class Index &indexRef = schemaPtr->tables[tableid]->fields[fieldid].index;
2175  std::queue<lockQueueIndexEntry> *lockQueuePtr=NULL;
2176 
2177  switch (indexRef.fieldtype)
2178  {
2179  case INT:
2180  if (indexRef.intLockQueue->count(val->value.integer))
2181  {
2182  lockQueuePtr = &indexRef.intLockQueue->at(val->value.integer);
2183  }
2184 
2185  break;
2186 
2187  case UINT:
2188  if (indexRef.uintLockQueue->count(val->value.uinteger))
2189  {
2190  lockQueuePtr = &indexRef.uintLockQueue->at(val->value.uinteger);
2191  }
2192 
2193  break;
2194 
2195  case BOOL:
2196  if (indexRef.boolLockQueue->count(val->value.boolean))
2197  {
2198  lockQueuePtr = &indexRef.boolLockQueue->at(val->value.boolean);
2199  }
2200 
2201  break;
2202 
2203  case FLOAT:
2204  if (indexRef.floatLockQueue->count(val->value.floating))
2205  {
2206  lockQueuePtr = &indexRef.floatLockQueue->at(val->value.floating);
2207  }
2208 
2209  break;
2210 
2211  case CHAR:
2212  if (indexRef.charLockQueue->count(val->value.character))
2213  {
2214  lockQueuePtr = &indexRef.charLockQueue->at(val->value.character);
2215  }
2216 
2217  break;
2218 
2219  case CHARX:
2220  if (indexRef.stringLockQueue->count(val->str))
2221  {
2222  lockQueuePtr = &indexRef.stringLockQueue->at(val->str);
2223  }
2224 
2225  break;
2226 
2227  case VARCHAR:
2228  if (indexRef.stringLockQueue->count(val->str))
2229  {
2230  lockQueuePtr = &indexRef.stringLockQueue->at(val->str);
2231  }
2232 
2233  break;
2234 
2235  default:
2236  fprintf(logfile, "anomaly: %i %s %i\n", indexRef.fieldtype, __FILE__,
2237  __LINE__);
2238  }
2239 
2240  if (lockQueuePtr==NULL)
2241  {
2242  return;
2243  }
2244 
2245  std::queue<lockQueueIndexEntry> &lockQueueRef = *lockQueuePtr;
2246 
2247  while (!lockQueueRef.empty())
2248  {
2249  lockQueueIndexEntry &entry = lockQueueRef.front();
2250 
2251  if (enginePtr->SubTransactions.count(entry.entry.subtransactionid))
2252  {
2253  class SubTransaction &subTransactionRef =
2254  *enginePtr->SubTransactions[entry.entry.subtransactionid];
2255  //reply
2256  class MessageSubtransactionCmd *subtransactionCmdPtr =
2257  new MessageSubtransactionCmd();
2258  subtransactionCmdPtr->subtransactionStruct.locktype =
2259  PENDINGTOINDEXNOLOCK;
2260  subtransactionCmdPtr->subtransactionStruct.tableid = tableid;
2261  subtransactionCmdPtr->subtransactionStruct.fieldid = fieldid;
2262  subtransactionCmdPtr->fieldVal = *val;
2263 
2264  // ok gotta fake msgrcv for replyTransaction
2265  // THIS HAS TO BE BUGGY 1/19/2013, fix when testing
2266  class MessageSubtransactionCmd rcv;
2267  rcv.transactionStruct.transactionid =
2268  subTransactionRef.transactionid;
2269  rcv.transactionStruct.subtransactionid =
2270  entry.entry.subtransactionid;
2271  rcv.transactionStruct.engineinstance = enginePtr->partitionid;
2272  rcv.transactionStruct.transaction_tacmdentrypoint =
2273  entry.tacmdentrypoint;
2274  rcv.transactionStruct.transaction_pendingcmdid = entry.pendingcmdid;
2275  rcv.messageStruct.payloadtype = PAYLOADSUBTRANSACTION;
2276  subTransactionRef.replyTransaction(*subtransactionCmdPtr, rcv);
2277  }
2278 
2279  lockQueueRef.pop();
2280  }
2281 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SubTransaction::drainRowLockQueue ( int64_t  tableid,
int64_t  rowid 
)
private

drain queue of transactions waiting for locked row

used when row cannot be re-locked, such as when deleted

Parameters
tableidtableid
rowid

Definition at line 1898 of file SubTransaction.cc.

References MessageTransaction::transaction_s::engineinstance, enginePtr, Table::lockQueue, Message::messageStruct, MessageSubtransactionCmd::MessageSubtransactionCmd(), Engine::partitionid, PAYLOADSUBTRANSACTION, Message::message_s::payloadtype, lockQueueRowEntry::pendingcmdid, PENDINGTONOLOCK, replyTransaction(), MessageSubtransactionCmd::returnRows, schemaPtr, lockQueueRowEntry::subtransactionid, MessageTransaction::transaction_s::subtransactionid, Engine::SubTransactions, Schema::tables, lockQueueRowEntry::tacmdentrypoint, MessageTransaction::transaction_s::transaction_pendingcmdid, MessageTransaction::transaction_s::transaction_tacmdentrypoint, transactionid, MessageTransaction::transaction_s::transactionid, and MessageTransaction::transactionStruct.

Referenced by processTransactionMessage().

1899 {
1900  class Table &tableRef = *schemaPtr->tables[tableid];
1901  std::queue<lockQueueRowEntry> &qRef = tableRef.lockQueue[rowid];
1902 
1903  while (!qRef.empty())
1904  {
1905  lockQueueRowEntry &entry = qRef.front();
1906 
1907  if (enginePtr->SubTransactions.count(entry.subtransactionid))
1908  {
1909  class SubTransaction &subTransactionRef =
1910  *enginePtr->SubTransactions[entry.subtransactionid];
1911 
1912  class MessageSubtransactionCmd *subtransactionCmdPtr =
1913  new MessageSubtransactionCmd();
1914  subtransactionCmdPtr->returnRows[0].locktype = PENDINGTONOLOCK;
1915  subtransactionCmdPtr->returnRows[0].rowid = rowid;
1916  // ok gotta fake msgrcv for replyTransaction
1917  class MessageSubtransactionCmd rcv;
1918  rcv.transactionStruct.transactionid =
1919  subTransactionRef.transactionid;
1920  rcv.transactionStruct.subtransactionid = entry.subtransactionid;
1921  rcv.transactionStruct.engineinstance = enginePtr->partitionid;
1922  rcv.transactionStruct.transaction_tacmdentrypoint =
1923  entry.tacmdentrypoint;
1924  rcv.transactionStruct.transaction_pendingcmdid = entry.pendingcmdid;
1925  rcv.messageStruct.payloadtype = PAYLOADSUBTRANSACTION;
1926 
1927  subTransactionRef.replyTransaction(*subtransactionCmdPtr, rcv);
1928  }
1929 
1930  qRef.pop();
1931  }
1932 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SubTransaction::indexSearch ( int64_t  tableid,
int64_t  fieldid,
searchParams_s *  searchParameters,
vector< nonLockingIndexEntry_s > *  indexHits 
)
private

Definition at line 981 of file SubTransaction.cc.

References Index::between(), BOOL, CHAR, CHARX, Index::comparison(), Index::fieldtype, FLOAT, Index::getall(), Index::getequal(), Index::getin(), Index::getnotequal(), Index::getnotin(), Index::getnotnulls(), Index::getnulls(), INT, Index::like(), logfile, Index::notbetween(), Index::notlike(), searchParams_s::op, OPERATOR_BETWEEN, OPERATOR_EQ, OPERATOR_GT, OPERATOR_GTE, OPERATOR_IN, OPERATOR_ISNOTNULL, OPERATOR_ISNULL, OPERATOR_LIKE, OPERATOR_LT, OPERATOR_LTE, OPERATOR_NE, OPERATOR_NOTBETWEEN, OPERATOR_NOTIN, OPERATOR_NOTLIKE, OPERATOR_REGEX, OPERATOR_SELECTALL, Index::regex(), searchParams_s::regexString, schemaPtr, Schema::tables, UINT, searchParams_s::values, and VARCHAR.

Referenced by processTransactionMessage(), and searchReturn1().

984 {
985  class Index &indexRef = schemaPtr->tables[tableid]->fields[fieldid].index;
986  // for the various operation types, also field types. 11 ops, 7 field types
987 
988  switch (searchParameters->op)
989  {
990  case OPERATOR_EQ:
991  {
992  switch (indexRef.fieldtype)
993  {
994  case INT:
995  {
996  indexRef.getequal(searchParameters->values[0].value.integer,
997  indexHits);
998  }
999  break;
1000 
1001  case UINT:
1002  {
1003  indexRef.getequal(searchParameters->values[0].value.uinteger,
1004  indexHits);
1005  }
1006  break;
1007 
1008  case BOOL:
1009  {
1010  indexRef.getequal(searchParameters->values[0].value.boolean,
1011  indexHits);
1012  }
1013  break;
1014 
1015  case FLOAT:
1016  {
1017  indexRef.getequal(searchParameters->values[0].value.floating,
1018  indexHits);
1019  }
1020  break;
1021 
1022  case CHAR:
1023  {
1024  indexRef.getequal(searchParameters->values[0].value.character,
1025  indexHits);
1026  }
1027  break;
1028 
1029  case CHARX:
1030  {
1031  indexRef.getequal(searchParameters->values[0].str,
1032  indexHits);
1033  }
1034  break;
1035 
1036  case VARCHAR:
1037  {
1038  indexRef.getequal(searchParameters->values[0].str,
1039  indexHits);
1040  }
1041  break;
1042 
1043  default:
1044  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1045  __LINE__);
1046  }
1047 
1048  }
1049  break;
1050 
1051  case OPERATOR_NE:
1052  {
1053  switch (indexRef.fieldtype)
1054  {
1055  case INT:
1056  {
1057  indexRef.getnotequal(searchParameters->values[0].value.integer,
1058  indexHits);
1059  }
1060  break;
1061 
1062  case UINT:
1063  {
1064  indexRef.getnotequal(searchParameters->values[0].value.uinteger,
1065  indexHits);
1066  }
1067  break;
1068 
1069  case BOOL:
1070  {
1071  indexRef.getnotequal(searchParameters->values[0].value.boolean,
1072  indexHits);
1073  }
1074  break;
1075 
1076  case FLOAT:
1077  {
1078  indexRef.getnotequal(searchParameters->values[0].value.floating,
1079  indexHits);
1080  }
1081  break;
1082 
1083  case CHAR:
1084  {
1085  indexRef.getnotequal(searchParameters->values[0].value.character,
1086  indexHits);
1087  }
1088  break;
1089 
1090  case CHARX:
1091  {
1092  indexRef.getnotequal(searchParameters->values[0].str,
1093  indexHits);
1094  }
1095  break;
1096 
1097  case VARCHAR:
1098  {
1099  indexRef.getnotequal(searchParameters->values[0].str,
1100  indexHits);
1101  }
1102  break;
1103 
1104  default:
1105  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1106  __LINE__);
1107  }
1108  }
1109  break;
1110 
1111  case OPERATOR_GT:
1112  {
1113  switch (indexRef.fieldtype)
1114  {
1115  case INT:
1116  {
1117  indexRef.comparison(searchParameters->values[0].value.integer,
1118  searchParameters->op, indexHits);
1119  }
1120  break;
1121 
1122  case UINT:
1123  {
1124  indexRef.comparison(searchParameters->values[0].value.uinteger,
1125  searchParameters->op, indexHits);
1126  }
1127  break;
1128 
1129  case BOOL:
1130  {
1131  indexRef.comparison(searchParameters->values[0].value.boolean,
1132  searchParameters->op, indexHits);
1133  }
1134  break;
1135 
1136  case FLOAT:
1137  {
1138  indexRef.comparison(searchParameters->values[0].value.floating,
1139  searchParameters->op, indexHits);
1140  }
1141  break;
1142 
1143  case CHAR:
1144  {
1145  indexRef.comparison(searchParameters->values[0].value.character,
1146  searchParameters->op, indexHits);
1147  }
1148  break;
1149 
1150  case CHARX:
1151  {
1152  indexRef.comparison(&searchParameters->values[0].str,
1153  searchParameters->op, indexHits);
1154  }
1155  break;
1156 
1157  case VARCHAR:
1158  {
1159  indexRef.comparison(&searchParameters->values[0].str,
1160  searchParameters->op, indexHits);
1161  }
1162  break;
1163 
1164  default:
1165  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1166  __LINE__);
1167  }
1168 
1169  }
1170  break;
1171 
1172  case OPERATOR_LT:
1173  {
1174  switch (indexRef.fieldtype)
1175  {
1176  case INT:
1177  {
1178  indexRef.comparison(searchParameters->values[0].value.integer,
1179  searchParameters->op, indexHits);
1180  }
1181  break;
1182 
1183  case UINT:
1184  {
1185  indexRef.comparison(searchParameters->values[0].value.uinteger,
1186  searchParameters->op, indexHits);
1187  }
1188  break;
1189 
1190  case BOOL:
1191  {
1192  indexRef.comparison(searchParameters->values[0].value.boolean,
1193  searchParameters->op, indexHits);
1194  }
1195  break;
1196 
1197  case FLOAT:
1198  {
1199  indexRef.comparison(searchParameters->values[0].value.floating,
1200  searchParameters->op, indexHits);
1201  }
1202  break;
1203 
1204  case CHAR:
1205  {
1206  indexRef.comparison(searchParameters->values[0].value.character,
1207  searchParameters->op, indexHits);
1208  }
1209  break;
1210 
1211  case CHARX:
1212  {
1213  indexRef.comparison(&searchParameters->values[0].str,
1214  searchParameters->op, indexHits);
1215  }
1216  break;
1217 
1218  case VARCHAR:
1219  {
1220  indexRef.comparison(&searchParameters->values[0].str,
1221  searchParameters->op, indexHits);
1222  }
1223  break;
1224 
1225  default:
1226  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1227  __LINE__);
1228  }
1229 
1230  }
1231  break;
1232 
1233  case OPERATOR_GTE:
1234  {
1235  switch (indexRef.fieldtype)
1236  {
1237  case INT:
1238  {
1239  indexRef.comparison(searchParameters->values[0].value.integer,
1240  searchParameters->op, indexHits);
1241  }
1242  break;
1243 
1244  case UINT:
1245  {
1246  indexRef.comparison(searchParameters->values[0].value.uinteger,
1247  searchParameters->op, indexHits);
1248  }
1249  break;
1250 
1251  case BOOL:
1252  {
1253  indexRef.comparison(searchParameters->values[0].value.boolean,
1254  searchParameters->op, indexHits);
1255  }
1256  break;
1257 
1258  case FLOAT:
1259  {
1260  indexRef.comparison(searchParameters->values[0].value.floating,
1261  searchParameters->op, indexHits);
1262  }
1263  break;
1264 
1265  case CHAR:
1266  {
1267  indexRef.comparison(searchParameters->values[0].value.character,
1268  searchParameters->op, indexHits);
1269  }
1270  break;
1271 
1272  case CHARX:
1273  {
1274  indexRef.comparison(&searchParameters->values[0].str,
1275  searchParameters->op, indexHits);
1276  }
1277  break;
1278 
1279  case VARCHAR:
1280  {
1281  indexRef.comparison(&searchParameters->values[0].str,
1282  searchParameters->op, indexHits);
1283  }
1284  break;
1285 
1286  default:
1287  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1288  __LINE__);
1289  }
1290 
1291  }
1292  break;
1293 
1294  case OPERATOR_LTE:
1295  {
1296  switch (indexRef.fieldtype)
1297  {
1298  case INT:
1299  {
1300  indexRef.comparison(searchParameters->values[0].value.integer,
1301  searchParameters->op, indexHits);
1302  }
1303  break;
1304 
1305  case UINT:
1306  {
1307  indexRef.comparison(searchParameters->values[0].value.uinteger,
1308  searchParameters->op, indexHits);
1309  }
1310  break;
1311 
1312  case BOOL:
1313  {
1314  indexRef.comparison(searchParameters->values[0].value.boolean,
1315  searchParameters->op, indexHits);
1316  }
1317  break;
1318 
1319  case FLOAT:
1320  {
1321  indexRef.comparison(searchParameters->values[0].value.floating,
1322  searchParameters->op, indexHits);
1323  }
1324  break;
1325 
1326  case CHAR:
1327  {
1328  indexRef.comparison(searchParameters->values[0].value.character,
1329  searchParameters->op, indexHits);
1330  }
1331  break;
1332 
1333  case CHARX:
1334  {
1335  indexRef.comparison(&searchParameters->values[0].str,
1336  searchParameters->op, indexHits);
1337  }
1338  break;
1339 
1340  case VARCHAR:
1341  {
1342  indexRef.comparison(&searchParameters->values[0].str,
1343  searchParameters->op, indexHits);
1344  }
1345  break;
1346 
1347  default:
1348  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1349  __LINE__);
1350  }
1351 
1352  }
1353  break;
1354 
1355  case OPERATOR_IN:
1356  {
1357  switch (indexRef.fieldtype)
1358  {
1359  case INT:
1360  {
1361  vector<int64_t> v(searchParameters->values.size());
1362 
1363  for (size_t n=0; n < searchParameters->values.size(); n++)
1364  {
1365  v[n] = searchParameters->values[n].value.integer;
1366  }
1367 
1368  indexRef.getin(&v, indexHits);
1369  }
1370  break;
1371 
1372  case UINT:
1373  {
1374  vector<uint64_t> v(searchParameters->values.size());
1375 
1376  for (size_t n=0; n < searchParameters->values.size(); n++)
1377  {
1378  v[n] = searchParameters->values[n].value.uinteger;
1379  }
1380 
1381  indexRef.getin(&v, indexHits);
1382  }
1383  break;
1384 
1385  case BOOL:
1386  {
1387  vector<bool> v(searchParameters->values.size());
1388 
1389  for (size_t n=0; n < searchParameters->values.size(); n++)
1390  {
1391  v[n] = searchParameters->values[n].value.boolean;
1392  }
1393 
1394  indexRef.getin(&v, indexHits);
1395  }
1396  break;
1397 
1398  case FLOAT:
1399  {
1400  vector<long double> v(searchParameters->values.size());
1401 
1402  for (size_t n=0; n < searchParameters->values.size(); n++)
1403  {
1404  v[n] = searchParameters->values[n].value.floating;
1405  }
1406 
1407  indexRef.getin(&v, indexHits);
1408  }
1409  break;
1410 
1411  case CHAR:
1412  {
1413  vector<char> v(searchParameters->values.size());
1414 
1415  for (size_t n=0; n < searchParameters->values.size(); n++)
1416  {
1417  v[n] = searchParameters->values[n].value.character;
1418  }
1419 
1420  indexRef.getin(&v, indexHits);
1421  }
1422  break;
1423 
1424  case CHARX:
1425  {
1426  vector<string> v(searchParameters->values.size());
1427 
1428  for (size_t n=0; n < searchParameters->values.size(); n++)
1429  {
1430  v[n] = searchParameters->values[n].str;
1431  }
1432 
1433  indexRef.getin(&v, indexHits);
1434  }
1435  break;
1436 
1437  case VARCHAR:
1438  {
1439  vector<string> v(searchParameters->values.size());
1440 
1441  for (size_t n=0; n < searchParameters->values.size(); n++)
1442  {
1443  v[n] = searchParameters->values[n].str;
1444  }
1445 
1446  indexRef.getin(&v, indexHits);
1447  }
1448  break;
1449 
1450  default:
1451  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1452  __LINE__);
1453  }
1454  }
1455  break;
1456 
1457  case OPERATOR_NOTIN:
1458  {
1459  switch (indexRef.fieldtype)
1460  {
1461  case INT:
1462  {
1463  vector<int64_t> v(searchParameters->values.size());
1464 
1465  for (size_t n=0; n < searchParameters->values.size(); n++)
1466  {
1467  v[n] = searchParameters->values[n].value.integer;
1468  }
1469 
1470  indexRef.getnotin(v, indexHits);
1471  }
1472  break;
1473 
1474  case UINT:
1475  {
1476  vector<uint64_t> v(searchParameters->values.size());
1477 
1478  for (size_t n=0; n < searchParameters->values.size(); n++)
1479  {
1480  v[n] = searchParameters->values[n].value.uinteger;
1481  }
1482 
1483  indexRef.getnotin(v, indexHits);
1484  }
1485  break;
1486 
1487  case BOOL:
1488  {
1489  vector<bool> v(searchParameters->values.size());
1490 
1491  for (size_t n=0; n < searchParameters->values.size(); n++)
1492  {
1493  v[n] = searchParameters->values[n].value.boolean;
1494  }
1495 
1496  indexRef.getnotin(v, indexHits);
1497  }
1498  break;
1499 
1500  case FLOAT:
1501  {
1502  vector<long double> v(searchParameters->values.size());
1503 
1504  for (size_t n=0; n < searchParameters->values.size(); n++)
1505  {
1506  v[n] = searchParameters->values[n].value.floating;
1507  }
1508 
1509  indexRef.getnotin(v, indexHits);
1510  }
1511  break;
1512 
1513  case CHAR:
1514  {
1515  vector<char> v(searchParameters->values.size());
1516 
1517  for (size_t n=0; n < searchParameters->values.size(); n++)
1518  {
1519  v[n] = searchParameters->values[n].value.character;
1520  }
1521 
1522  indexRef.getnotin(v, indexHits);
1523  }
1524  break;
1525 
1526  case CHARX:
1527  {
1528  vector<string> v(searchParameters->values.size());
1529 
1530  for (size_t n=0; n < searchParameters->values.size(); n++)
1531  {
1532  v[n] = searchParameters->values[n].str;
1533  }
1534 
1535  indexRef.getnotin(v, indexHits);
1536  }
1537  break;
1538 
1539  case VARCHAR:
1540  {
1541  vector<string> v(searchParameters->values.size());
1542 
1543  for (size_t n=0; n < searchParameters->values.size(); n++)
1544  {
1545  v[n] = searchParameters->values[n].str;
1546  }
1547 
1548  indexRef.getnotin(v, indexHits);
1549  }
1550  break;
1551 
1552  default:
1553  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1554  __LINE__);
1555  }
1556  }
1557  break;
1558 
1559  case OPERATOR_BETWEEN:
1560  {
1561  switch (indexRef.fieldtype)
1562  {
1563  case INT:
1564  {
1565  indexRef.between(searchParameters->values[0].value.integer,
1566  searchParameters->values[1].value.integer,
1567  indexHits);
1568  }
1569  break;
1570 
1571  case UINT:
1572  {
1573  indexRef.between(searchParameters->values[0].value.uinteger,
1574  searchParameters->values[1].value.uinteger,
1575  indexHits);
1576  }
1577  break;
1578 
1579  case BOOL:
1580  {
1581  indexRef.between(searchParameters->values[0].value.boolean,
1582  searchParameters->values[1].value.boolean,
1583  indexHits);
1584  }
1585  break;
1586 
1587  case FLOAT:
1588  {
1589  indexRef.between(searchParameters->values[0].value.floating,
1590  searchParameters->values[1].value.floating,
1591  indexHits);
1592  }
1593  break;
1594 
1595  case CHAR:
1596  {
1597  indexRef.between(searchParameters->values[0].value.character,
1598  searchParameters->values[1].value.character,
1599  indexHits);
1600  }
1601  break;
1602 
1603  case CHARX:
1604  {
1605  indexRef.between(searchParameters->values[0].str,
1606  searchParameters->values[1].str,
1607  indexHits);
1608  }
1609  break;
1610 
1611  case VARCHAR:
1612  {
1613  indexRef.between(searchParameters->values[0].str,
1614  searchParameters->values[1].str, indexHits);
1615  }
1616  break;
1617 
1618  default:
1619  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1620  __LINE__);
1621  }
1622 
1623  }
1624  break;
1625 
1626  case OPERATOR_NOTBETWEEN:
1627  {
1628  switch (indexRef.fieldtype)
1629  {
1630  case INT:
1631  {
1632  indexRef.notbetween(searchParameters->values[0].value.integer,
1633  searchParameters->values[1].value.integer,
1634  indexHits);
1635  }
1636  break;
1637 
1638  case UINT:
1639  {
1640  indexRef.notbetween(searchParameters->values[0].value.uinteger,
1641  searchParameters->values[1].value.uinteger,
1642  indexHits);
1643  }
1644  break;
1645 
1646  case BOOL:
1647  {
1648  indexRef.notbetween(searchParameters->values[0].value.boolean,
1649  searchParameters->values[1].value.boolean,
1650  indexHits);
1651  }
1652  break;
1653 
1654  case FLOAT:
1655  {
1656  indexRef.notbetween(searchParameters->values[0].value.floating,
1657  searchParameters->values[1].value.floating,
1658  indexHits);
1659  }
1660  break;
1661 
1662  case CHAR:
1663  {
1664  indexRef.notbetween(searchParameters->values[0].value.character,
1665  searchParameters->values[1].value.character,
1666  indexHits);
1667  }
1668  break;
1669 
1670  case CHARX:
1671  {
1672  indexRef.notbetween(&searchParameters->values[0].str,
1673  &searchParameters->values[1].str, indexHits);
1674  }
1675  break;
1676 
1677  case VARCHAR:
1678  {
1679  indexRef.notbetween(&searchParameters->values[0].str,
1680  &searchParameters->values[1].str, indexHits);
1681  }
1682  break;
1683 
1684  default:
1685  fprintf(logfile, "anomaly %i %s %i\n", indexRef.fieldtype, __FILE__,
1686  __LINE__);
1687  }
1688 
1689  }
1690  break;
1691 
1692  case OPERATOR_ISNULL:
1693  indexRef.getnulls(indexHits);
1694  break;
1695 
1696  case OPERATOR_ISNOTNULL:
1697  indexRef.getnotnulls(indexHits);
1698  break;
1699 
1700  case OPERATOR_SELECTALL: // combination of nulls and not nulls
1701  indexRef.getall(indexHits);
1702  break;
1703 
1704  case OPERATOR_REGEX:
1705  indexRef.regex(&searchParameters->regexString, indexHits);
1706  break;
1707 
1708  case OPERATOR_LIKE:
1709  indexRef.like(searchParameters->values[0].str, indexHits);
1710  break;
1711 
1712  case OPERATOR_NOTLIKE:
1713  indexRef.notlike(searchParameters->values[0].str, indexHits);
1714  break;
1715 
1716  default:
1717  fprintf(logfile, "anomaly %i %s %i\n", searchParameters->op, __FILE__,
1718  __LINE__);
1719  }
1720 }

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t SubTransaction::newrow ( int64_t  tableid,
std::string  row 
)
private

create new row

Parameters
tableidtableid
rowrow string
Returns

Definition at line 2283 of file SubTransaction.cc.

References Table::getnextrowid(), Table::newrow(), schemaPtr, subtransactionid, and Schema::tables.

Referenced by processTransactionMessage().

2284 {
2285  class Table &tableRef = *schemaPtr->tables[tableid];
2286  int64_t newrowid = tableRef.getnextrowid();
2287  tableRef.newrow(newrowid, subtransactionid, row);
2288 
2289  return newrowid;
2290 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SubTransaction::processIndexLockQueue ( int64_t  tableid,
int64_t  fieldid,
fieldValue_s *  val 
)
private

operate on transactions waiting for locked unique index entry

Parameters
tableidtableid
fieldidfieldid
valfield value

Definition at line 1934 of file SubTransaction.cc.

Referenced by processTransactionMessage().

1936 {
1937  return;
1938  // class Index &indexRef = schemaPtr->tables[tableid]->fields[fieldid].index;
1939  // std::queue<lockQueueIndexEntry> *lockQueuePtr = NULL;
1940 
1941  // switch (indexRef.fieldtype)
1942  // {
1943  // case INT:
1944  // if (indexRef.intLockQueue->count(val->value.integer))
1945  // {
1946  // lockQueuePtr = &indexRef.intLockQueue->at(val->value.integer);
1947  // }
1948 
1949  // break;
1950 
1951  // case UINT:
1952  // if (indexRef.uintLockQueue->count(val->value.uinteger))
1953  // {
1954  // lockQueuePtr = &indexRef.uintLockQueue->at(val->value.uinteger);
1955  // }
1956 
1957  // break;
1958 
1959  // case BOOL:
1960  // if (indexRef.boolLockQueue->count(val->value.boolean))
1961  // {
1962  // lockQueuePtr = &indexRef.boolLockQueue->at(val->value.boolean);
1963  // }
1964 
1965  // break;
1966 
1967  // case FLOAT:
1968  // if (indexRef.floatLockQueue->count(val->value.floating))
1969  // {
1970  // lockQueuePtr = &indexRef.floatLockQueue->at(val->value.floating);
1971  // }
1972 
1973  // break;
1974 
1975  // case CHAR:
1976  // if (indexRef.charLockQueue->count(val->value.character))
1977  // {
1978  // lockQueuePtr = &indexRef.charLockQueue->at(val->value.character);
1979  // }
1980 
1981  // break;
1982 
1983  // case CHARX:
1984  // if (indexRef.stringLockQueue->count(val->str))
1985  // {
1986  // lockQueuePtr = &indexRef.stringLockQueue->at(val->str);
1987  // }
1988 
1989  // break;
1990 
1991  // case VARCHAR:
1992  // if (indexRef.stringLockQueue->count(val->str))
1993  // {
1994  // lockQueuePtr = &indexRef.stringLockQueue->at(val->str);
1995  // }
1996 
1997  // break;
1998 
1999  // default:
2000  // fprintf(logfile, "anomaly: %i %s %i\n", indexRef.fieldtype, __FILE__,
2001  // __LINE__);
2002  // }
2003 
2004  // if (lockQueuePtr==NULL)
2005  // {
2006  // return;
2007  // }
2008 
2009  // std::queue<lockQueueIndexEntry> &lockQueueRef = *lockQueuePtr;
2010 
2011  // while (!lockQueueRef.empty())
2012  // {
2013  // lockQueueIndexEntry &entry = lockQueueRef.front();
2014 
2015  // if (enginePtr->SubTransactions.count(entry.entry.subtransactionid))
2016  // {
2017  // class SubTransaction &subTransactionRef =
2018  // *enginePtr->SubTransactions[entry.entry.subtransactionid];
2019 
2020  // // do stuff
2021  // switch (indexRef.fieldtype)
2022  // {
2023  // case INT:
2024  // if (indexRef.indexmaptype==unorderedint)
2025  // {
2026  // indexRef.unorderedIntIndex->at(val->value.integer) = entry.entry;
2027  // }
2028  // else if (indexRef.indexmaptype==uniqueint)
2029  // {
2030  // indexRef.uniqueIntIndex->at(val->value.integer) = entry.entry;
2031  // }
2032  // else
2033  // {
2034  // fprintf(logfile, "anomaly: %i %s %i\n", indexRef.indexmaptype,
2035  // __FILE__, __LINE__);
2036  // }
2037 
2038  // case UINT:
2039  // if (indexRef.indexmaptype==unordereduint)
2040  // {
2041  // indexRef.unorderedUintIndex->at(val->value.uinteger) = entry.entry;
2042  // }
2043  // else if (indexRef.indexmaptype==uniqueuint)
2044  // {
2045  // indexRef.uniqueUintIndex->at(val->value.uinteger) = entry.entry;
2046  // }
2047  // else
2048  // {
2049  // fprintf(logfile, "anomaly: %i %s %i\n", indexRef.indexmaptype,
2050  // __FILE__, __LINE__);
2051  // }
2052 
2053  // break;
2054 
2055  // case BOOL:
2056  // if (indexRef.indexmaptype==unorderedbool)
2057  // {
2058  // indexRef.unorderedBoolIndex->at(val->value.boolean) = entry.entry;
2059  // }
2060  // else if (indexRef.indexmaptype==uniquebool)
2061  // {
2062  // indexRef.uniqueBoolIndex->at(val->value.boolean) = entry.entry;
2063  // }
2064  // else
2065  // {
2066  // fprintf(logfile, "anomaly: %i %s %i\n", indexRef.indexmaptype,
2067  // __FILE__, __LINE__);
2068  // }
2069 
2070  // break;
2071 
2072  // case FLOAT:
2073  // if (indexRef.indexmaptype==unorderedfloat)
2074  // {
2075  // indexRef.unorderedFloatIndex->at(val->value.floating) = entry.entry;
2076  // }
2077  // else if (indexRef.indexmaptype==uniquefloat)
2078  // {
2079  // indexRef.uniqueFloatIndex->at(val->value.floating) = entry.entry;
2080  // }
2081  // else
2082  // {
2083  // fprintf(logfile, "anomaly: %i %s %i\n", indexRef.indexmaptype,
2084  // __FILE__, __LINE__);
2085  // }
2086 
2087  // break;
2088 
2089  // case CHAR:
2090  // if (indexRef.indexmaptype==unorderedchar)
2091  // {
2092  // indexRef.unorderedCharIndex->at(val->value.character) = entry.entry;
2093  // }
2094  // else if (indexRef.indexmaptype==uniquechar)
2095  // {
2096  // indexRef.uniqueCharIndex->at(val->value.character) = entry.entry;
2097  // }
2098  // else
2099  // {
2100  // fprintf(logfile, "anomaly: %i %s %i\n", indexRef.indexmaptype,
2101  // __FILE__, __LINE__);
2102  // }
2103 
2104  // break;
2105 
2106  // case CHARX:
2107  // if (indexRef.indexmaptype==unorderedcharx)
2108  // {
2109  // indexRef.unorderedStringIndex->at(val->str) = entry.entry;
2110  // }
2111  // else if (indexRef.indexmaptype==uniquecharx)
2112  // {
2113  // indexRef.uniqueStringIndex->at(val->str) = entry.entry;
2114  // }
2115  // else
2116  // {
2117  // fprintf(logfile, "anomaly: %i %s %i\n", indexRef.indexmaptype,
2118  // __FILE__, __LINE__);
2119  // }
2120 
2121  // break;
2122 
2123  // case VARCHAR:
2124  // if (indexRef.indexmaptype==unorderedvarchar)
2125  // {
2126  // indexRef.unorderedStringIndex->at(val->str) = entry.entry;
2127  // }
2128  // else if (indexRef.indexmaptype==uniquevarchar)
2129  // {
2130  // indexRef.uniqueStringIndex->at(val->str) = entry.entry;
2131  // }
2132  // else
2133  // {
2134  // fprintf(logfile, "anomaly: %i %s %i\n", indexRef.indexmaptype,
2135  // __FILE__, __LINE__);
2136  // }
2137 
2138  // break;
2139 
2140  // default:
2141  // fprintf(logfile, "anomaly: %i %s %i\n", indexRef.fieldtype, __FILE__,
2142  // __LINE__);
2143  // }
2144 
2145  // //reply
2146  // class MessageSubtransactionCmd *subtransactionCmdPtr =
2147  // new MessageSubtransactionCmd();
2148  // subtransactionCmdPtr->subtransactionStruct.locktype = PENDINGTOINDEXLOCK;
2149  // subtransactionCmdPtr->subtransactionStruct.tableid = tableid;
2150  // subtransactionCmdPtr->subtransactionStruct.fieldid = fieldid;
2151  // subtransactionCmdPtr->fieldVal = *val;
2152 
2153  // // ok gotta fake msgrcv for replyTransaction
2154  // class MessageSubtransactionCmd rcv;
2155  // rcv.transactionStruct.transactionid = subTransactionRef.transactionid;
2156  // rcv.transactionStruct.subtransactionid = entry.entry.subtransactionid;
2157  // rcv.transactionStruct.engineinstance = enginePtr->partitionid;
2158  // rcv.transactionStruct.transaction_tacmdentrypoint = entry.tacmdentrypoint;
2159  // rcv.transactionStruct.transaction_pendingcmdid = entry.pendingcmdid;
2160  // rcv.messageStruct.payloadtype = PAYLOADSUBTRANSACTION;
2161 
2162  // subTransactionRef.replyTransaction(*subtransactionCmdPtr, rcv);
2163 
2164  // lockQueueRef.pop();
2165  // }
2166 
2167  // lockQueueRef.pop();
2168  // }
2169 }

Here is the caller graph for this function:

void SubTransaction::processRowLockQueue ( int64_t  tableid,
int64_t  rowid 
)
private

operate on transactions waiting for locked row

Parameters
tableidtableid
rowidrowid

Definition at line 1819 of file SubTransaction.cc.

Referenced by processTransactionMessage().

1820 {
1821  return;
1822  // class Table &tableRef = *schemaPtr->tables[tableid];
1823  // std::queue<lockQueueRowEntry> &qRef = tableRef.lockQueue[rowid];
1824  // // subtransactionCmd *subtransactionCmdPtr;
1825  // class MessageSubtransactionCmd *subtransactionCmdPtr;
1826 
1827  // bool readlockedflag=false;
1828 
1829  // while (!qRef.empty()) // remember to return when a WRITELOCK is processed
1830  // {
1831  // lockQueueRowEntry &entry = qRef.front();
1832 
1833  // if (enginePtr->SubTransactions.count(entry.subtransactionid))
1834  // {
1835  // // oh yeah gotta lock the row, but don't know how to stage the
1836  // // row itself
1837  // if (entry.locktype==WRITELOCK)
1838  // {
1839  // setwritelock(&tableRef.rows[rowid]->flags);
1840  // tableRef.rows[rowid]->writelockHolder = entry.subtransactionid;
1841 
1842  // subtransactionCmdPtr = new class MessageSubtransactionCmd();
1843  // returnRow_s returnRow= {};
1844  // returnRow.rowid=rowid;
1845  // returnRow.locktype=PENDINGTOWRITELOCK;
1846  // subtransactionCmdPtr->returnRows.push_back(returnRow);
1847  // }
1848  // else if (entry.locktype==READLOCK)
1849  // {
1850  // if (readlockedflag==false)
1851  // {
1852  // setreadlock(&tableRef.rows[rowid]->flags);
1853  // tableRef.rows[rowid]->readlockHolders =
1854  // new boost::unordered_set<int64_t>;
1855  // readlockedflag=true;
1856  // }
1857 
1858  // tableRef.rows[rowid]->readlockHolders->insert(entry.subtransactionid);
1859 
1860  // subtransactionCmdPtr = new class MessageSubtransactionCmd();
1861  // subtransactionCmdPtr->returnRows[0].locktype = PENDINGTOREADLOCK;
1862  // subtransactionCmdPtr->returnRows[0].rowid = rowid;
1863  // subtransactionCmdPtr->returnRows[0].row = tableRef.rows[rowid]->row;
1864  // }
1865  // else
1866  // {
1867  // qRef.pop();
1868  // fprintf(logfile, "anomaly: %i %s %i\n", entry.locktype, __FILE__,
1869  // __LINE__);
1870  // continue;
1871  // }
1872 
1873  // // ok gotta fake msgrcv for replyTransaction
1874  // class SubTransaction &subTransactionRef =
1875  // *enginePtr->SubTransactions[entry.subtransactionid];
1876  // class MessageSubtransactionCmd rcv;
1877  // rcv.transactionStruct.transactionid = subTransactionRef.transactionid;
1878  // rcv.transactionStruct.subtransactionid = entry.subtransactionid;
1879  // rcv.transactionStruct.engineinstance = enginePtr->partitionid;
1880  // rcv.transactionStruct.transaction_tacmdentrypoint = entry.tacmdentrypoint;
1881  // rcv.transactionStruct.transaction_pendingcmdid = entry.pendingcmdid;
1882  // rcv.messageStruct.payloadtype = PAYLOADSUBTRANSACTION;
1883 
1884  // subTransactionRef.replyTransaction(*subtransactionCmdPtr, rcv);
1885 
1886  // // there can only be 1 lock holder if it's a WRITELOCK
1887  // if (entry.locktype==WRITELOCK)
1888  // {
1889  // qRef.pop();
1890  // return;
1891  // }
1892  // }
1893 
1894  // qRef.pop();
1895  // }
1896 }

Here is the caller graph for this function:

void SubTransaction::processTransactionMessage ( class Message *  msgrcvarg)
private

handle incoming MessageTransaction variant

Parameters
msgrcvargreceived MessageTransaction variant

Definition at line 49 of file SubTransaction.cc.

References BOOL, fieldInput_u::boolean, CHAR, fieldInput_u::character, CHARX, COMMITCMD, Index::commitRollback(), Table::commitRollbackUnlock(), rowOrField_s::deleteindexentry, Index::deleteNonuniqueEntry(), Index::deleteNullEntry(), deleterow(), DELETEROW, Index::deleteUniqueEntry(), drainIndexLockQueue(), drainRowLockQueue(), rowOrField_s::engineid, MessageSubtransactionCmd::subtransaction_s::engineid, rowOrField_s::fieldid, MessageSubtransactionCmd::subtransaction_s::fieldid, Table::fields, Index::fieldtype, rowOrField_s::fieldVal, MessageSubtransactionCmd::fieldVal, FLOAT, fieldInput_u::floating, MessageSubtransactionCmd::subtransaction_s::forward_engineid, MessageSubtransactionCmd::subtransaction_s::forward_rowid, MessageSubtransactionCmd::indexHits, indexSearch(), INDEXSEARCH, Index::insertNonuniqueEntry(), Index::insertNullEntry(), INT, fieldInput_u::integer, rowOrField_s::isnotaddunique, fieldValue_s::isnull, rowOrField_s::isreplace, rowOrField_s::isrow, Index::isunique, MessageSubtransactionCmd::subtransaction_s::locktype, logfile, Message::messageStruct, msgrcv, rowOrField_s::newengineid, newrow(), NEWROW, rowOrField_s::newrowid, PAYLOADCOMMITROLLBACK, PAYLOADSUBTRANSACTION, Message::message_s::payloadtype, processIndexLockQueue(), processRowLockQueue(), REPLACEDELETEROW, Index::replaceNonunique(), Index::replaceNull(), Index::replaceUnique(), replyTransaction(), MessageSubtransactionCmd::returnRows, REVERTCMD, MessageCommitRollback::rofs, ROLLBACKCMD, MessageSubtransactionCmd::row, rowOrField_s::rowid, MessageSubtransactionCmd::subtransaction_s::rowid, MessageSubtransactionCmd::rowids, Table::rows, schemaPtr, MessageSubtransactionCmd::searchParameters, searchReturn1(), SEARCHRETURN1, selectrows(), SELECTROWS, MessageSubtransactionCmd::subtransaction_s::status, fieldValue_s::str, subtransactionid, MessageSubtransactionCmd::subtransactionStruct, rowOrField_s::tableid, MessageSubtransactionCmd::subtransaction_s::tableid, Schema::tables, MessageTransaction::transaction_s::transaction_enginecmd, MessageTransaction::transaction_s::transaction_pendingcmdid, MessageTransaction::transactionStruct, UINT, fieldInput_u::uinteger, uniqueIndex(), UNIQUEINDEX, updaterow(), UPDATEROW, fieldValue_s::value, VARCHAR, and WRITELOCK.

Referenced by Engine::Engine().

50 {
51  msgrcv = msgrcvarg;
52 
53  switch (msgrcv->messageStruct.payloadtype)
54  {
55  case PAYLOADSUBTRANSACTION:
56  {
57  class MessageSubtransactionCmd &subtransactionCmdRef =
58  *((class MessageSubtransactionCmd *)msgrcv);
59  class MessageSubtransactionCmd *msg = new class MessageSubtransactionCmd;
60  class MessageSubtransactionCmd &msgref = *msg;
61 
62  switch ((enginecmd_e) subtransactionCmdRef.transactionStruct.transaction_enginecmd)
63  {
64  case NEWROW:
65  {
66  msgref.subtransactionStruct.rowid =
67  newrow(subtransactionCmdRef.subtransactionStruct.tableid,
68  subtransactionCmdRef.row);
69  msgref.subtransactionStruct.locktype = WRITELOCK;
70  }
71  break;
72 
73  case UNIQUEINDEX:
74  {
75  msgref.subtransactionStruct.locktype =
76  uniqueIndex(subtransactionCmdRef.subtransactionStruct.tableid,
77  subtransactionCmdRef.subtransactionStruct.fieldid,
78  subtransactionCmdRef.subtransactionStruct.rowid,
79  subtransactionCmdRef.subtransactionStruct.engineid,
80  &subtransactionCmdRef.fieldVal);
81  msgref.subtransactionStruct.tableid =
82  subtransactionCmdRef.subtransactionStruct.tableid;
83  msgref.subtransactionStruct.fieldid =
84  subtransactionCmdRef.subtransactionStruct.fieldid;
85  msgref.fieldVal = subtransactionCmdRef.fieldVal;
86  }
87  break;
88 
89  case UPDATEROW:
90  {
91  msgref.subtransactionStruct.status =
92  updaterow(subtransactionCmdRef.subtransactionStruct.tableid,
93  subtransactionCmdRef.subtransactionStruct.rowid,
94  &subtransactionCmdRef.row);
95  msgref.subtransactionStruct.locktype=WRITELOCK;
96  }
97  break;
98 
99  case DELETEROW:
100  {
101  msgref.subtransactionStruct.rowid =
102  subtransactionCmdRef.subtransactionStruct.rowid;
103  msgref.subtransactionStruct.tableid =
104  subtransactionCmdRef.subtransactionStruct.tableid;
105  msgref.subtransactionStruct.engineid =
106  subtransactionCmdRef.subtransactionStruct.engineid;
107  msgref.subtransactionStruct.status =
108  deleterow(subtransactionCmdRef.subtransactionStruct.tableid,
109  subtransactionCmdRef.subtransactionStruct.rowid);
110  }
111  break;
112 
113  case REPLACEDELETEROW:
114  {
115  msgref.subtransactionStruct.status =
116  deleterow(subtransactionCmdRef.subtransactionStruct.tableid,
117  subtransactionCmdRef.subtransactionStruct.rowid,
118  subtransactionCmdRef.subtransactionStruct.forward_rowid,
119  subtransactionCmdRef.subtransactionStruct.forward_engineid);
120  msgref.subtransactionStruct.locktype=WRITELOCK;
121  }
122  break;
123 
124  case INDEXSEARCH:
125  {
126  indexSearch(subtransactionCmdRef.subtransactionStruct.tableid,
127  subtransactionCmdRef.subtransactionStruct.fieldid,
128  &subtransactionCmdRef.searchParameters,
129  &msgref.indexHits);
130  }
131  break;
132 
133  case SELECTROWS:
134  {
135  selectrows(subtransactionCmdRef.subtransactionStruct.tableid,
136  &subtransactionCmdRef.rowids,
137  subtransactionCmdRef.subtransactionStruct.locktype,
138  subtransactionCmdRef.transactionStruct.transaction_pendingcmdid,
139  &msgref.returnRows);
140  }
141  break;
142 
143  case SEARCHRETURN1:
144  searchReturn1(subtransactionCmdRef.subtransactionStruct.tableid,
145  subtransactionCmdRef.subtransactionStruct.fieldid,
146  subtransactionCmdRef.subtransactionStruct.locktype,
147  subtransactionCmdRef.searchParameters,
148  msgref.returnRows);
149  break;
150 
151  default:
152  fprintf(logfile, "anomaly: %i %s %i\n",
153  subtransactionCmdRef.transactionStruct.transaction_enginecmd,
154  __FILE__, __LINE__);
155  }
156 
157  replyTransaction((void *)msg);
158  }
159  break;
160 
161  case PAYLOADCOMMITROLLBACK:
162  {
163  class MessageCommitRollback &subtransactionCmdRef =
164  *((class MessageCommitRollback *)msgrcv);
165  class Table *tablePtr;
166  class Index *indexPtr;
167 
168  for (size_t n=0; n<subtransactionCmdRef.rofs.size(); n++)
169  {
170  rowOrField_s &rowFieldRef = subtransactionCmdRef.rofs[n];
171 
172  if (!schemaPtr->tables.count(rowFieldRef.tableid))
173  {
174  printf("%s %i anomaly, barfing, tableid %i\n", __FILE__,
175  __LINE__, rowFieldRef.tableid);
176  abort();
177  }
178 
179  tablePtr = schemaPtr->tables[rowFieldRef.tableid];
180 
181  if (rowFieldRef.isrow==true)
182  {
183  tablePtr->commitRollbackUnlock(rowFieldRef.rowid,
184  subtransactionid,
185  (enginecmd_e) subtransactionCmdRef.transactionStruct.transaction_enginecmd);
186 
187  // drain lock queue if: sueccessful delete & commit, or insert &
188  // rollback is a non-existent row sufficient to infer?
189  // For now, yes,
190  // but later, maybe not, if there's some other flag. Figure it
191  // out at
192  // that point.
193  if (tablePtr->rows.count(rowFieldRef.rowid) &&
194  (enginecmd_e)subtransactionCmdRef.transactionStruct.transaction_enginecmd !=
195  REVERTCMD)
196  {
197  processRowLockQueue(rowFieldRef.tableid,
198  rowFieldRef.rowid);
199  }
200  else
201  {
202  drainRowLockQueue(rowFieldRef.tableid,
203  rowFieldRef.rowid);
204  }
205  }
206  else if (rowFieldRef.isnotaddunique==false)
207  {
208  indexPtr = &tablePtr->fields[rowFieldRef.fieldid].index;
209 
210  if (rowFieldRef.fieldVal.isnull==true)
211  {
212  printf("%s %i INSERTNULLENTRY unique index\n", __FILE__,
213  __LINE__);
214  indexPtr->insertNullEntry(rowFieldRef.rowid,
215  rowFieldRef.engineid);
216  }
217  else
218  {
219 
220  switch (indexPtr->fieldtype)
221  {
222  case INT:
223  indexPtr->commitRollback(rowFieldRef.fieldVal.value.integer,
224  subtransactionid,
225  (enginecmd_e) subtransactionCmdRef.transactionStruct.transaction_enginecmd);
226  break;
227 
228  case UINT:
229  indexPtr->commitRollback(rowFieldRef.fieldVal.value.uinteger,
230  subtransactionid,
231  (enginecmd_e) subtransactionCmdRef.transactionStruct.transaction_enginecmd);
232  break;
233 
234  case BOOL:
235  indexPtr->commitRollback(rowFieldRef.fieldVal.value.boolean,
236  subtransactionid,
237  (enginecmd_e) subtransactionCmdRef.transactionStruct.transaction_enginecmd);
238  break;
239 
240  case FLOAT:
241  indexPtr->commitRollback(rowFieldRef.fieldVal.value.floating,
242  subtransactionid,
243  (enginecmd_e) subtransactionCmdRef.transactionStruct.transaction_enginecmd);
244  break;
245 
246  case CHAR:
247  indexPtr->commitRollback(rowFieldRef.fieldVal.value.character,
248  subtransactionid,
249  (enginecmd_e) subtransactionCmdRef.transactionStruct.transaction_enginecmd);
250  break;
251 
252  case CHARX:
253  indexPtr->commitRollback(rowFieldRef.fieldVal.str,
254  subtransactionid,
255  (enginecmd_e) subtransactionCmdRef.transactionStruct.transaction_enginecmd);
256  break;
257 
258  case VARCHAR:
259  indexPtr->commitRollback(rowFieldRef.fieldVal.str,
260  subtransactionid,
261  (enginecmd_e) subtransactionCmdRef.transactionStruct.transaction_enginecmd);
262  break;
263 
264  default:
265  fprintf(logfile, "anomaly: %i %s %i\n",
266  indexPtr->fieldtype, __FILE__, __LINE__);
267  }
268  }
269 
270  if ((enginecmd_e)subtransactionCmdRef.transactionStruct.transaction_enginecmd == COMMITCMD)
271  {
272  drainIndexLockQueue(rowFieldRef.tableid, rowFieldRef.fieldid,
273  &rowFieldRef.fieldVal);
274  }
275  else if ((enginecmd_e)subtransactionCmdRef.transactionStruct.transaction_enginecmd == ROLLBACKCMD)
276  {
277  processIndexLockQueue(rowFieldRef.tableid,
278  rowFieldRef.fieldid,
279  &rowFieldRef.fieldVal);
280  }
281  }
282  else // is not addunique index
283  {
284  // possibilities are: add null, delete null,
285  // add nonunique, delete nonunique, delete unique, replace
286  indexPtr = &tablePtr->fields[rowFieldRef.fieldid].index;
287 
288  if (rowFieldRef.isreplace==true)
289  {
290  if (rowFieldRef.fieldVal.isnull==true)
291  {
292  indexPtr->replaceNull(rowFieldRef.rowid,
293  rowFieldRef.engineid,
294  rowFieldRef.newrowid,
295  rowFieldRef.engineid);
296  }
297  else
298  {
299  switch (indexPtr->fieldtype)
300  {
301  case INT:
302  if (indexPtr->isunique==true)
303  {
304  indexPtr->replaceUnique(rowFieldRef.newrowid,
305  rowFieldRef.newengineid,
306  rowFieldRef.fieldVal.value.integer);
307  }
308  else
309  {
310  indexPtr->replaceNonunique(rowFieldRef.rowid,
311  rowFieldRef.engineid,
312  rowFieldRef.newrowid,
313  rowFieldRef.newengineid,
314  rowFieldRef.fieldVal.value.integer);
315  }
316 
317  break;
318 
319  case UINT:
320  if (indexPtr->isunique==true)
321  {
322  indexPtr->replaceUnique(rowFieldRef.newrowid,
323  rowFieldRef.newengineid,
324  rowFieldRef.fieldVal.value.uinteger);
325  }
326  else
327  {
328  indexPtr->replaceNonunique(rowFieldRef.rowid,
329  rowFieldRef.engineid,
330  rowFieldRef.newrowid,
331  rowFieldRef.newengineid,
332  rowFieldRef.fieldVal.value.uinteger);
333  }
334 
335  break;
336 
337  case BOOL:
338  if (indexPtr->isunique==true)
339  {
340  indexPtr->replaceUnique(rowFieldRef.newrowid,
341  rowFieldRef.newengineid,
342  rowFieldRef.fieldVal.value.boolean);
343  }
344  else
345  {
346  indexPtr->replaceNonunique(rowFieldRef.rowid,
347  rowFieldRef.engineid,
348  rowFieldRef.newrowid,
349  rowFieldRef.newengineid,
350  rowFieldRef.fieldVal.value.boolean);
351  }
352 
353  break;
354 
355  case FLOAT:
356  if (indexPtr->isunique==true)
357  {
358  indexPtr->replaceUnique(rowFieldRef.newrowid,
359  rowFieldRef.newengineid,
360  rowFieldRef.fieldVal.value.floating);
361  }
362  else
363  {
364  indexPtr->replaceNonunique(rowFieldRef.rowid,
365  rowFieldRef.engineid,
366  rowFieldRef.newrowid,
367  rowFieldRef.newengineid,
368  rowFieldRef.fieldVal.value.floating);
369  }
370 
371  break;
372 
373  case CHAR:
374  if (indexPtr->isunique==true)
375  {
376  indexPtr->replaceUnique(rowFieldRef.newrowid,
377  rowFieldRef.newengineid,
378  rowFieldRef.fieldVal.value.character);
379  }
380  else
381  {
382  indexPtr->replaceNonunique(rowFieldRef.rowid,
383  rowFieldRef.engineid,
384  rowFieldRef.newrowid,
385  rowFieldRef.newengineid,
386  rowFieldRef.fieldVal.value.character);
387  }
388 
389  break;
390 
391  case CHARX:
392  if (indexPtr->isunique==true)
393  {
394  indexPtr->replaceUnique(rowFieldRef.newrowid,
395  rowFieldRef.newengineid,
396  rowFieldRef.fieldVal.str);
397  }
398  else
399  {
400  indexPtr->replaceNonunique(rowFieldRef.rowid,
401  rowFieldRef.engineid,
402  rowFieldRef.newrowid,
403  rowFieldRef.newengineid,
404  rowFieldRef.fieldVal.str);
405  }
406 
407  break;
408 
409  case VARCHAR:
410  if (indexPtr->isunique==true)
411  {
412  indexPtr->replaceUnique(rowFieldRef.newrowid,
413  rowFieldRef.newengineid,
414  rowFieldRef.fieldVal.str);
415  }
416  else
417  {
418  indexPtr->replaceNonunique(rowFieldRef.rowid,
419  rowFieldRef.engineid,
420  rowFieldRef.newrowid,
421  rowFieldRef.newengineid,
422  rowFieldRef.fieldVal.str);
423  }
424 
425  break;
426 
427  default:
428  fprintf(logfile, "anomaly: %i %s %i\n",
429  indexPtr->fieldtype, __FILE__, __LINE__);
430  }
431  }
432 
433  continue;
434  }
435 
436  if (rowFieldRef.fieldVal.isnull==true)
437  {
438  if (rowFieldRef.deleteindexentry==true)
439  {
440  indexPtr->deleteNullEntry(rowFieldRef.rowid,
441  rowFieldRef.engineid);
442  }
443  else
444  {
445  indexPtr->insertNullEntry(rowFieldRef.rowid,
446  rowFieldRef.engineid);
447  }
448 
449  continue;
450  }
451 
452  switch (indexPtr->fieldtype)
453  {
454  case INT:
455  if (indexPtr->isunique==true) // delete unique
456  {
457  indexPtr->deleteUniqueEntry(rowFieldRef.fieldVal.value.integer);
458  // process lock queue
459  processIndexLockQueue(rowFieldRef.tableid,
460  rowFieldRef.fieldid,
461  &rowFieldRef.fieldVal);
462  }
463  else if (rowFieldRef.deleteindexentry==true) // delete non-unique
464  {
465  indexPtr->deleteNonuniqueEntry(rowFieldRef.fieldVal.value.integer, rowFieldRef.rowid, rowFieldRef.engineid);
466  }
467  else // add non-unique
468  {
469  indexPtr->insertNonuniqueEntry(rowFieldRef.fieldVal.value.integer, rowFieldRef.rowid, rowFieldRef.engineid);
470  }
471 
472  break;
473 
474  case UINT:
475  if (indexPtr->isunique==true) // delete unique
476  {
477  indexPtr->deleteUniqueEntry(rowFieldRef.fieldVal.value.
478  uinteger);
479  // process lock queue
480  processIndexLockQueue(rowFieldRef.tableid,
481  rowFieldRef.fieldid,
482  &rowFieldRef.fieldVal);
483  }
484  else if (rowFieldRef.deleteindexentry==true) // delete non-unique
485  {
486  indexPtr->deleteNonuniqueEntry(rowFieldRef.fieldVal.value.uinteger, rowFieldRef.rowid, rowFieldRef.engineid);
487  }
488  else // add non-unique
489  {
490  indexPtr->insertNonuniqueEntry(rowFieldRef.fieldVal.value.uinteger, rowFieldRef.rowid, rowFieldRef.engineid);
491  }
492 
493  break;
494 
495  case BOOL:
496  if (indexPtr->isunique==true) // delete unique
497  {
498  indexPtr->deleteUniqueEntry(rowFieldRef.fieldVal.value.boolean);
499  // process lock queue
500  processIndexLockQueue(rowFieldRef.tableid,
501  rowFieldRef.fieldid,
502  &rowFieldRef.fieldVal);
503  }
504  else if (rowFieldRef.deleteindexentry==true) // delete non-unique
505  {
506  indexPtr->deleteNonuniqueEntry(rowFieldRef.fieldVal.value.boolean, rowFieldRef.rowid, rowFieldRef.engineid);
507  }
508  else // add non-unique
509  {
510  indexPtr->insertNonuniqueEntry(rowFieldRef.fieldVal.value.boolean, rowFieldRef.rowid, rowFieldRef.engineid);
511  }
512 
513  break;
514 
515  case FLOAT:
516  if (indexPtr->isunique==true) // delete unique
517  {
518  indexPtr->deleteUniqueEntry(rowFieldRef.fieldVal.value.
519  floating);
520  // process lock queue
521  processIndexLockQueue(rowFieldRef.tableid,
522  rowFieldRef.fieldid,
523  &rowFieldRef.fieldVal);
524  }
525  else if (rowFieldRef.deleteindexentry==true) // delete non-unique
526  {
527  indexPtr->deleteNonuniqueEntry(rowFieldRef.fieldVal.value.floating, rowFieldRef.rowid, rowFieldRef.engineid);
528  }
529  else // add non-unique
530  {
531  indexPtr->insertNonuniqueEntry(rowFieldRef.fieldVal.value.floating, rowFieldRef.rowid, rowFieldRef.engineid);
532  }
533 
534  break;
535 
536  case CHAR:
537  if (indexPtr->isunique==true) // delete unique
538  {
539  indexPtr->deleteUniqueEntry(rowFieldRef.fieldVal.value.character);
540  // process lock queue
541  processIndexLockQueue(rowFieldRef.tableid,
542  rowFieldRef.fieldid,
543  &rowFieldRef.fieldVal);
544  }
545  else if (rowFieldRef.deleteindexentry==true) // delete non-unique
546  {
547  indexPtr->deleteNonuniqueEntry(rowFieldRef.fieldVal.value.character, rowFieldRef.rowid, rowFieldRef.engineid);
548  }
549  else // add non-unique
550  {
551  indexPtr->insertNonuniqueEntry(rowFieldRef.fieldVal.value.character, rowFieldRef.rowid, rowFieldRef.engineid);
552  }
553 
554  break;
555 
556  case CHARX:
557  if (indexPtr->isunique==true) // delete unique
558  {
559  indexPtr->deleteUniqueEntry(&rowFieldRef.fieldVal.str);
560  // process lock queue
561  processIndexLockQueue(rowFieldRef.tableid,
562  rowFieldRef.fieldid,
563  &rowFieldRef.fieldVal);
564  }
565  else if (rowFieldRef.deleteindexentry==true) // delete non-unique
566  {
567  indexPtr->deleteNonuniqueEntry(&rowFieldRef.fieldVal.str,
568  rowFieldRef.rowid,
569  rowFieldRef.engineid);
570  }
571  else // add non-unique
572  {
573  indexPtr->insertNonuniqueEntry(&rowFieldRef.fieldVal.str,
574  rowFieldRef.rowid,
575  rowFieldRef.engineid);
576  }
577 
578  break;
579 
580  case VARCHAR:
581  if (indexPtr->isunique==true) // delete unique
582  {
583  indexPtr->deleteUniqueEntry(&rowFieldRef.fieldVal.str);
584  // process lock queue
585  processIndexLockQueue(rowFieldRef.tableid,
586  rowFieldRef.fieldid,
587  &rowFieldRef.fieldVal);
588  }
589  else if (rowFieldRef.deleteindexentry==true) // delete non-unique
590  {
591  indexPtr->deleteNonuniqueEntry(&rowFieldRef.fieldVal.str,
592  rowFieldRef.rowid,
593  rowFieldRef.engineid);
594  }
595  else // add non-unique
596  {
597  indexPtr->insertNonuniqueEntry(&rowFieldRef.fieldVal.str,
598  rowFieldRef.rowid,
599  rowFieldRef.engineid);
600  }
601 
602  break;
603 
604  default:
605  fprintf(logfile, "anomaly: %i %s %i\n", indexPtr->fieldtype,
606  __FILE__, __LINE__);
607  }
608  }
609  }
610 
611  // rollback & unlock are fire and forget
612  if ((enginecmd_e)subtransactionCmdRef.transactionStruct.transaction_enginecmd == COMMITCMD)
613  {
614  replyTransaction((void *) new class MessageCommitRollback);
615  }
616  }
617  break;
618 
619  default:
620  fprintf(logfile, "anomaly: %i %s %i\n",
621  msgrcv->messageStruct.payloadtype, __FILE__, __LINE__);
622  }
623 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SubTransaction::replyTransaction ( void *  data)
private

reply to calling TransactionAgent

Parameters
dataMessage variant to send

Definition at line 1779 of file SubTransaction.cc.

References Topology::partitionAddress::address, MessageTransaction::transaction_s::engineinstance, enginePtr, Engine::mboxes, Message::messageStruct, msgrcv, Engine::myIdentity, Engine::partitionid, Message::message_s::payloadtype, subtransactionid, MessageTransaction::transaction_s::subtransactionid, taAddr, Mboxes::toActor(), Message::message_s::topic, TOPIC_TRANSACTION, MessageTransaction::transaction_s::transaction_pendingcmdid, MessageTransaction::transaction_s::transaction_tacmdentrypoint, MessageTransaction::transaction_s::transactionid, and MessageTransaction::transactionStruct.

Referenced by drainIndexLockQueue(), drainRowLockQueue(), and processTransactionMessage().

1780 {
1781  class MessageTransaction &msgref = *(class MessageTransaction *)data;
1782  class MessageTransaction &msgrcvRef =
1783  *(class MessageTransaction *)msgrcv;
1784  msgref.messageStruct.topic = TOPIC_TRANSACTION;
1785  msgref.messageStruct.payloadtype = msgrcvRef.messageStruct.payloadtype;
1786  msgref.transactionStruct.transactionid =
1787  msgrcvRef.transactionStruct.transactionid;
1788  msgref.transactionStruct.subtransactionid = subtransactionid;
1789  msgref.transactionStruct.engineinstance = enginePtr->partitionid;
1790  msgref.transactionStruct.transaction_tacmdentrypoint =
1791  msgrcvRef.transactionStruct.transaction_tacmdentrypoint;
1792  msgref.transactionStruct.transaction_pendingcmdid =
1793  msgrcvRef.transactionStruct.transaction_pendingcmdid;
1794 
1795  enginePtr->mboxes.toActor(enginePtr->myIdentity.address, taAddr,
1796  *((class Message *)data));
1797 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SubTransaction::replyTransaction ( class MessageTransaction &  sndRef,
class MessageTransaction &  rcvRef 
)
private

reply to calling TransactionAgent

for draining queue of old transactions. state from old subtransaction is kept in the original received Message variant

Parameters
sndRefMessage variant to send
rcvReforiginal received Message variant

Definition at line 1800 of file SubTransaction.cc.

References Topology::partitionAddress::address, MessageTransaction::transaction_s::engineinstance, enginePtr, Engine::mboxes, Message::messageStruct, Engine::myIdentity, Engine::partitionid, Message::message_s::payloadtype, subtransactionid, MessageTransaction::transaction_s::subtransactionid, taAddr, Mboxes::toActor(), Message::message_s::topic, TOPIC_TRANSACTION, MessageTransaction::transaction_s::transaction_pendingcmdid, MessageTransaction::transaction_s::transaction_tacmdentrypoint, MessageTransaction::transaction_s::transactionid, and MessageTransaction::transactionStruct.

1802 {
1803  sndRef.messageStruct.topic = TOPIC_TRANSACTION;
1804  sndRef.messageStruct.payloadtype = rcvRef.messageStruct.payloadtype;
1805  sndRef.messageStruct.payloadtype = rcvRef.messageStruct.payloadtype;
1806  sndRef.transactionStruct.transactionid =
1807  rcvRef.transactionStruct.transactionid;
1808  sndRef.transactionStruct.subtransactionid = subtransactionid;
1809  sndRef.transactionStruct.engineinstance = enginePtr->partitionid;
1810  sndRef.transactionStruct.transaction_tacmdentrypoint =
1811  rcvRef.transactionStruct.transaction_tacmdentrypoint;
1812  sndRef.transactionStruct.transaction_pendingcmdid =
1813  rcvRef.transactionStruct.transaction_pendingcmdid;
1814 
1815  enginePtr->mboxes.toActor(enginePtr->myIdentity.address, taAddr, sndRef);
1816 }

Here is the call graph for this function:

void SubTransaction::searchReturn1 ( int64_t  tableid,
int64_t  fieldid,
locktype_e  locktype,
searchParams_s &  searchParams,
vector< returnRow_s > &  returnRows 
)
private

search index for and return matching rows

rows are distributed across partitions by field 0 hash this function performs index lookup and data return in 1 step for selects against field 0

Parameters
tableidtableid
fieldidfieldid
locktypelock type
searchParamssearch parameters
returnRowsrows to return

Definition at line 2323 of file SubTransaction.cc.

References indexSearch(), returnRow_s::locktype, msgrcv, NOTFOUNDLOCK, nonLockingIndexEntry_s::rowid, MessageSubtransactionCmd::rowids, selectrows(), MessageTransaction::transaction_s::transaction_pendingcmdid, and MessageTransaction::transactionStruct.

Referenced by processTransactionMessage().

2327 {
2328  vector<nonLockingIndexEntry_s> indexHits;
2329 
2330  indexSearch(tableid, fieldid, &searchParams, &indexHits);
2331 
2332  if (indexHits.size()==1)
2333  {
2334  nonLockingIndexEntry_s &hit = indexHits[0];
2335  class MessageSubtransactionCmd &msgrcvRef =
2336  *(class MessageSubtransactionCmd *)msgrcv;
2337  vector<int64_t> rowids(1, hit.rowid);
2338  selectrows(tableid, &rowids, locktype, msgrcvRef.transactionStruct.transaction_pendingcmdid,
2339  &returnRows);
2340  }
2341  else
2342  {
2343  // NOTFOUNDLOCK result
2344  returnRow_s returnRow = {};
2345  returnRow.locktype = NOTFOUNDLOCK;
2346  returnRows.push_back(returnRow);
2347  }
2348 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SubTransaction::selectrows ( int64_t  tableid,
vector< int64_t > *  rowids,
locktype_e  locktype,
int64_t  pendingcmdid,
vector< returnRow_s > *  returnRows 
)
private

return rows

Parameters
tableidtableid
rowidslist of rowids to return
locktypelock type
pendingcmdidpending commad of sending Transaction
returnRowsrows to return

Definition at line 2313 of file SubTransaction.cc.

References msgrcv, schemaPtr, Table::selectrows(), subtransactionid, and Schema::tables.

Referenced by processTransactionMessage(), and searchReturn1().

2316 {
2317  int64_t tacmd = ((class MessageTransaction *)msgrcv)->transactionStruct.transaction_tacmdentrypoint;
2318  class Table &tableRef = *schemaPtr->tables[tableid];
2319  tableRef.selectrows(rowids, locktype, subtransactionid, pendingcmdid,
2320  returnRows, tacmd);
2321 }

Here is the call graph for this function:

Here is the caller graph for this function:

locktype_e SubTransaction::uniqueIndex ( int64_t  tableid,
int64_t  fieldid,
int64_t  rowid,
int64_t  engineid,
fieldValue_s *  val 
)
private

new unique index entry

Parameters
tableidtableid
fieldidfieldid
rowidrowid
engineidengineid
valfield value
Returns

Definition at line 625 of file SubTransaction.cc.

References fieldInput_u::boolean, Index::boolLockQueue, fieldInput_u::character, Index::charLockQueue, lockingIndexEntry::engineid, lockQueueIndexEntry::entry, fieldInput_u::floating, Index::floatLockQueue, INDEXLOCK, Index::indexmaptype, INDEXPENDINGLOCK, fieldInput_u::integer, Index::intLockQueue, msgrcv, NOLOCK, NOTFOUNDLOCK, lockQueueIndexEntry::pendingcmdid, lockingIndexEntry::rowid, schemaPtr, fieldValue_s::str, Index::stringLockQueue, lockingIndexEntry::subtransactionid, subtransactionid, Schema::tables, lockQueueIndexEntry::tacmdentrypoint, MessageTransaction::transaction_s::transaction_pendingcmdid, MessageTransaction::transaction_s::transaction_tacmdentrypoint, MessageTransaction::transactionStruct, trimspace(), fieldInput_u::uinteger, Index::uintLockQueue, uniquebool, Index::uniqueBoolIndex, uniquechar, Index::uniqueCharIndex, uniquecharx, uniquefloat, Index::uniqueFloatIndex, uniqueint, Index::uniqueIntIndex, Index::uniqueStringIndex, uniqueuint, Index::uniqueUintIndex, uniquevarchar, unorderedbool, Index::unorderedBoolIndex, unorderedchar, Index::unorderedCharIndex, unorderedcharx, unorderedfloat, Index::unorderedFloatIndex, unorderedint, Index::unorderedIntIndex, Index::unorderedStringIndex, unordereduint, Index::unorderedUintIndex, unorderedvarchar, and fieldValue_s::value.

Referenced by processTransactionMessage().

628 {
629  class MessageSubtransactionCmd &subtransactionCmdRef =
630  *((class MessageSubtransactionCmd *)msgrcv);
631  lockQueueIndexEntry queueEntry = {};
632  queueEntry.pendingcmdid =
633  subtransactionCmdRef.transactionStruct.transaction_pendingcmdid;
634  queueEntry.tacmdentrypoint =
635  subtransactionCmdRef.transactionStruct.transaction_tacmdentrypoint;
636  queueEntry.entry.engineid = engineid;
637  queueEntry.entry.rowid = rowid;
638  queueEntry.entry.subtransactionid = subtransactionid;
639 
640  class Index &indexRef = schemaPtr->tables[tableid]->fields[fieldid].index;
641 
642  switch (indexRef.indexmaptype)
643  {
644  case uniqueint:
645  {
646  if (!indexRef.uniqueIntIndex->count(val->value.integer))
647  {
648  // there is no entry, so stage one and lock it
649  indexRef.uniqueIntIndex->operator [](val->value.integer) =
650  queueEntry.entry;
651  return INDEXLOCK;
652  }
653 
654  if (indexRef.uniqueIntIndex->at(val->value.integer).subtransactionid)
655  {
656  // there is already a staged, locked entry, so go into the lock queue
657  indexRef.intLockQueue->operator [](val->value.integer).push(queueEntry);
658  return INDEXPENDINGLOCK;
659  }
660 
661  // there is an entry that is not locked: constraint violation
662  return NOLOCK;
663  }
664  break;
665 
666  case unorderedint:
667  {
668  if (!indexRef.unorderedIntIndex->count(val->value.integer))
669  {
670  // there is no entry, so stage one and lock it
671  indexRef.unorderedIntIndex->operator [](val->value.integer) =
672  queueEntry.entry;
673  return INDEXLOCK;
674  }
675 
676  if (indexRef.unorderedIntIndex->at(val->value.integer).subtransactionid)
677  {
678  // there is already a staged, locked entry, so go into the lock queue
679  indexRef.intLockQueue->operator [](val->value.integer).push(queueEntry);
680  return INDEXPENDINGLOCK;
681  }
682 
683  // there is an entry that is not locked: constraint violation
684  return NOLOCK;
685  }
686  break;
687 
688  case uniqueuint:
689  {
690  if (!indexRef.uniqueUintIndex->count(val->value.uinteger))
691  {
692  // there is no entry, so stage one and lock it
693  indexRef.uniqueUintIndex->operator [](val->value.uinteger) =
694  queueEntry.entry;
695  return INDEXLOCK;
696  }
697 
698  if (indexRef.uniqueUintIndex->at(val->value.uinteger).subtransactionid)
699  {
700  // there is already a staged, locked entry, so go into the lock queue
701  indexRef.uintLockQueue->operator [](val->value.uinteger).
702  push(queueEntry);
703  return INDEXPENDINGLOCK;
704  }
705 
706  // there is an entry that is not locked, so that means constraint violation
707  return NOLOCK;
708  }
709  break;
710 
711  case unordereduint:
712  {
713  if (!indexRef.unorderedUintIndex->count(val->value.uinteger))
714  {
715  // there is no entry, so stage one and lock it
716  indexRef.unorderedUintIndex->operator [](val->value.uinteger) =
717  queueEntry.entry;
718  return INDEXLOCK;
719  }
720 
721  if (indexRef.unorderedUintIndex->at(val->value.uinteger).subtransactionid)
722  {
723  // there is already a staged, locked entry, so go into the lock queue
724  indexRef.uintLockQueue->operator [](val->value.uinteger).push(queueEntry);
725  return INDEXPENDINGLOCK;
726  }
727 
728  // there is an entry that is not locked: constraint violation
729  return NOLOCK;
730  }
731  break;
732 
733  case uniquebool:
734  {
735  if (!indexRef.uniqueBoolIndex->count(val->value.boolean))
736  {
737  // there is no entry, so stage one and lock it
738  indexRef.uniqueBoolIndex->operator [](val->value.boolean) =
739  queueEntry.entry;
740  return INDEXLOCK;
741  }
742 
743  if (indexRef.uniqueBoolIndex->at(val->value.boolean).subtransactionid)
744  {
745  // there is already a staged, locked entry, so go into the lock queue
746  indexRef.boolLockQueue->operator [](val->value.boolean).push(queueEntry);
747  return INDEXPENDINGLOCK;
748  }
749 
750  // there is an entry that is not locked: constraint violation
751  return NOLOCK;
752  }
753  break;
754 
755  case unorderedbool:
756  {
757  if (!indexRef.unorderedBoolIndex->count(val->value.boolean))
758  {
759  // there is no entry, so stage one and lock it
760  indexRef.unorderedBoolIndex->operator [](val->value.boolean) =
761  queueEntry.entry;
762  return INDEXLOCK;
763  }
764 
765  if (indexRef.unorderedBoolIndex->at(val->value.boolean).subtransactionid)
766  {
767  // there is already a staged, locked entry, so go into the lock queue
768  indexRef.boolLockQueue->operator [](val->value.boolean).
769  push(queueEntry);
770  return INDEXPENDINGLOCK;
771  }
772 
773  // there is an entry that is not locked, so that means constraint violation
774  return NOLOCK;
775  }
776  break;
777 
778  case uniquefloat:
779  {
780  if (!indexRef.uniqueFloatIndex->count(val->value.floating))
781  {
782  // there is no entry, so stage one and lock it
783  indexRef.uniqueFloatIndex->operator [](val->value.floating) =
784  queueEntry.entry;
785  return INDEXLOCK;
786  }
787 
788  if (indexRef.uniqueFloatIndex->at(val->value.floating).subtransactionid)
789  {
790  // there is already a staged, locked entry, so go into the lock queue
791  indexRef.floatLockQueue->operator [](val->value.floating).
792  push(queueEntry);
793  return INDEXPENDINGLOCK;
794  }
795 
796  // there is an entry that is not locked: constraint violation
797  printf("%s %i NOLOCK float %Lf\n", __FILE__, __LINE__,
798  val->value.floating);
799  return NOLOCK;
800  }
801  break;
802 
803  case unorderedfloat:
804  {
805  if (!indexRef.unorderedFloatIndex->count(val->value.floating))
806  {
807  // there is no entry, so stage one and lock it
808  indexRef.unorderedFloatIndex->operator [](val->value.floating) =
809  queueEntry.entry;
810  return INDEXLOCK;
811  }
812 
813  if (indexRef.unorderedFloatIndex->at(val->value.floating).
814  subtransactionid)
815  {
816  // there is already a staged, locked entry, so go into the lock queue
817  indexRef.floatLockQueue->operator [](val->value.floating).push(queueEntry);
818  return INDEXPENDINGLOCK;
819  }
820 
821  // there is an entry that is not locked: constraint violation
822  return NOLOCK;
823  }
824  break;
825 
826  case uniquechar:
827  {
828  if (!indexRef.uniqueCharIndex->count(val->value.character))
829  {
830  // there is no entry, so stage one and lock it
831  indexRef.uniqueCharIndex->operator [](val->value.character) =
832  queueEntry.entry;
833  return INDEXLOCK;
834  }
835 
836  if (indexRef.uniqueCharIndex->at(val->value.character).subtransactionid)
837  {
838  // there is already a staged, locked entry, so go into the lock queue
839  indexRef.charLockQueue->operator [](val->value.character).
840  push(queueEntry);
841  return INDEXPENDINGLOCK;
842  }
843 
844  // there is an entry that is not locked: constraint violation
845  printf("%s %i NOLOCK char %c\n", __FILE__, __LINE__,
846  val->value.character);
847  return NOLOCK;
848  }
849  break;
850 
851  case unorderedchar:
852  {
853  if (!indexRef.unorderedCharIndex->count(val->value.character))
854  {
855  // there is no entry, so stage one and lock it
856  indexRef.unorderedCharIndex->operator [](val->value.character) =
857  queueEntry.entry;
858  return INDEXLOCK;
859  }
860 
861  if (indexRef.unorderedCharIndex->at(val->value.character).
862  subtransactionid)
863  {
864  // there is already a staged, locked entry, so go into the lock queue
865  indexRef.charLockQueue->operator [](val->value.character).
866  push(queueEntry);
867  return INDEXPENDINGLOCK;
868  }
869 
870  // there is an entry that is not locked, so that means constraint
871  // violation
872  return NOLOCK;
873  }
874  break;
875 
876  case uniquecharx:
877  {
878  trimspace(val->str);
879 
880  if (!indexRef.uniqueStringIndex->count(val->str))
881  {
882  // there is no entry, so stage one and lock it
883  indexRef.uniqueStringIndex->operator [](val->str) =
884  queueEntry.entry;
885  return INDEXLOCK;
886  }
887 
888  if (indexRef.uniqueStringIndex->at(val->str).subtransactionid)
889  {
890  // there is already a staged, locked entry, so go into the lock queue
891  indexRef.stringLockQueue->operator [](val->str).push(queueEntry);
892  return INDEXPENDINGLOCK;
893  }
894 
895  // there is an entry that is not locked: constraint violation
896  printf("%s %i NOLOCK charx '%s'\n", __FILE__, __LINE__,
897  val->str.c_str());
898  return NOLOCK;
899  }
900  break;
901 
902  case unorderedcharx:
903  {
904  if (!indexRef.unorderedStringIndex->count(val->str))
905  {
906  // there is no entry, so stage one and lock it
907  indexRef.unorderedStringIndex->operator [](val->str) =
908  queueEntry.entry;
909  return INDEXLOCK;
910  }
911 
912  if (indexRef.unorderedStringIndex->at(val->str).subtransactionid)
913  {
914  // there is already a staged, locked entry, so go into the lock queue
915  indexRef.stringLockQueue->operator [](val->str).push(queueEntry);
916  return INDEXPENDINGLOCK;
917  }
918 
919  // there is an entry that is not locked, so that means constraint
920  // violation
921  return NOLOCK;
922  }
923  break;
924 
925  case uniquevarchar:
926  {
927  trimspace(val->str);
928 
929  if (!indexRef.uniqueStringIndex->count(val->str))
930  {
931  // there is no entry, so stage one and lock it
932  indexRef.uniqueStringIndex->operator [](val->str) =
933  queueEntry.entry;
934  return INDEXLOCK;
935  }
936 
937  if (indexRef.uniqueStringIndex->at(val->str).subtransactionid)
938  {
939  // there is already a staged, locked entry, so go into the lock queue
940  indexRef.stringLockQueue->operator [](val->str).push(queueEntry);
941  return INDEXPENDINGLOCK;
942  }
943 
944  // there is an entry that is not locked: constraint violation
945  printf("%s %i NOLOCK varchar '%s'\n", __FILE__, __LINE__,
946  val->str.c_str());
947  return NOLOCK;
948  }
949  break;
950 
951  case unorderedvarchar:
952  {
953  if (!indexRef.unorderedStringIndex->count(val->str))
954  {
955  // there is no entry, so stage one and lock it
956  indexRef.unorderedStringIndex->operator [](val->str) =
957  queueEntry.entry;
958  return INDEXLOCK;
959  }
960 
961  if (indexRef.unorderedStringIndex->at(val->str).subtransactionid)
962  {
963  // there is already a staged, locked entry, so go into the lock queue
964  indexRef.stringLockQueue->operator [](val->str).push(queueEntry);
965  return INDEXPENDINGLOCK;
966  }
967 
968  // there is an entry that is not locked, so that means constraint
969  // violation
970  return NOLOCK;
971  }
972  break;
973 
974  default:
975  printf("%s %i anomaly %i\n", __FILE__, __LINE__, indexRef.indexmaptype);
976  }
977 
978  return NOTFOUNDLOCK;
979 }

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t SubTransaction::updaterow ( int64_t  tableid,
int64_t  rowid,
std::string *  row 
)
private

modify row

Parameters
tableidtableid
rowidrowid
rownew row
Returns

Definition at line 2292 of file SubTransaction.cc.

References schemaPtr, subtransactionid, Schema::tables, and Table::updaterow().

Referenced by processTransactionMessage().

2293 {
2294  class Table &tableRef = *schemaPtr->tables[tableid];
2295  return tableRef.updaterow(rowid, subtransactionid, row);
2296 }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class Engine
friend

Definition at line 55 of file SubTransaction.h.

Member Data Documentation

int64_t SubTransaction::domainid
private

Definition at line 214 of file SubTransaction.h.

Referenced by SubTransaction().

class Engine* SubTransaction::enginePtr
private

Definition at line 216 of file SubTransaction.h.

Referenced by drainIndexLockQueue(), drainRowLockQueue(), replyTransaction(), SubTransaction(), and ~SubTransaction().

class Message* SubTransaction::msgrcv
private

Definition at line 215 of file SubTransaction.h.

Referenced by processTransactionMessage(), replyTransaction(), searchReturn1(), selectrows(), and uniqueIndex().

class Schema* SubTransaction::schemaPtr
private

Definition at line 217 of file SubTransaction.h.

Referenced by commitRollbackUnlock(), deleterow(), drainIndexLockQueue(), drainRowLockQueue(), indexSearch(), newrow(), processTransactionMessage(), selectrows(), SubTransaction(), uniqueIndex(), and updaterow().

int64_t SubTransaction::subtransactionid
private

Definition at line 211 of file SubTransaction.h.

Referenced by commitRollbackUnlock(), deleterow(), newrow(), processTransactionMessage(), replyTransaction(), selectrows(), SubTransaction(), uniqueIndex(), updaterow(), and ~SubTransaction().

Topology::addressStruct SubTransaction::taAddr
private

Definition at line 212 of file SubTransaction.h.

Referenced by replyTransaction().

int64_t SubTransaction::transactionid
private

Definition at line 213 of file SubTransaction.h.

Referenced by drainIndexLockQueue(), and drainRowLockQueue().

The documentation for this class was generated from the following files: