InfiniSQL  v0.1.2-alpha
Massive Scale Transaction Processing
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Index.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013 Mark Travis <mtravis15432+src@gmail.com>
3  * All rights reserved. No warranty, explicit or implicit, provided.
4  *
5  * This file is part of InfiniSQL(tm).
6 
7  * InfiniSQL is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 3
9  * as published by the Free Software Foundation.
10  *
11  * InfiniSQL is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with InfiniSQL. If not, see <http://www.gnu.org/licenses/>.
18  */
19 
28 #ifndef INFINISQLINDEX_H
29 #define INFINISQLINDEX_H
30 
31 #include "gch.h"
32 
37 typedef struct
38 {
39  int64_t rowid;
40  int16_t engineid;
41  int64_t subtransactionid;
42  int64_t previoussubtransactionid;
43 } lockingIndexEntry;
44 
49 typedef struct
50 {
51  int64_t pendingcmdid;
52  int64_t tacmdentrypoint;
53  lockingIndexEntry entry;
54 } lockQueueIndexEntry;
55 
56 // buncha index types!
57 typedef std::map<int64_t, lockingIndexEntry> uniqueIntMap;
58 typedef std::multimap<int64_t, nonLockingIndexEntry_s> nonuniqueIntMap;
59 typedef boost::unordered_map<int64_t, lockingIndexEntry> unorderedIntMap;
60 typedef std::map<uint64_t, lockingIndexEntry> uniqueUintMap;
61 typedef std::multimap<uint64_t, nonLockingIndexEntry_s> nonuniqueUintMap;
62 typedef boost::unordered_map<uint64_t, lockingIndexEntry> unorderedUintMap;
63 typedef std::map<bool, lockingIndexEntry> uniqueBoolMap;
64 typedef std::multimap<bool, nonLockingIndexEntry_s> nonuniqueBoolMap;
65 typedef boost::unordered_map<bool, lockingIndexEntry> unorderedBoolMap;
66 typedef std::map<long double, lockingIndexEntry> uniqueFloatMap;
67 typedef std::multimap<long double, nonLockingIndexEntry_s> nonuniqueFloatMap;
68 typedef boost::unordered_map<long double, lockingIndexEntry> unorderedFloatMap;
69 typedef std::map<char, lockingIndexEntry> uniqueCharMap;
70 typedef std::multimap<char, nonLockingIndexEntry_s> nonuniqueCharMap;
71 typedef boost::unordered_map<char, lockingIndexEntry> unorderedCharMap;
72 typedef std::map<std::string, lockingIndexEntry> uniqueStringMap;
73 typedef std::multimap<std::string, nonLockingIndexEntry_s>
74  nonuniqueStringMap;
75 typedef boost::unordered_map<std::string, lockingIndexEntry>
76  unorderedStringMap;
77 
85 class Index
86 {
87 public:
88  Index();
89  virtual ~Index();
90 
91  friend class Transaction;
92  friend class Field;
93  friend class SubTransaction;
94 
95  //private:
96 
103  void makeindex(indextype_e indextypearg, fieldtype_e fieldtypearg);
104 
111  template < typename T >
112  void getequal(T input, std::vector<indexEntry_s> *returnEntries)
113  {
114  getequal_f(input, returnEntries);
115  }
116 
123  template < typename T >
124  void getin(T input, vector<indexEntry_s> *returnEntries)
125  {
126  // input needs to be a vector of the appropriate type
127  for (size_t n=0; n < input->size(); n++)
128  {
129  getequal_f(input->at(n), returnEntries);
130  }
131  }
132 
133  // getequal_f always called by getequal or get in, which do their own
134  // clearing of returnEntries vector
141  void getnotequal(int64_t input, vector<indexEntry_s> *returnEntries);
148  void getnotequal(uint64_t input, vector<indexEntry_s> *returnEntries);
155  void getnotequal(bool input, vector<indexEntry_s> *returnEntries);
162  void getnotequal(long double input, vector<indexEntry_s> *returnEntries);
169  void getnotequal(char input, vector<indexEntry_s> *returnEntries);
176  void getnotequal(string input, vector<indexEntry_s> *returnEntries);
182  void getnotnulls(vector<indexEntry_s> *returnEntries);
190  void comparison(int64_t input, operatortypes_e op,
191  vector<indexEntry_s> *returnEntries);
199  void comparison(uint64_t input, operatortypes_e op,
200  vector<indexEntry_s> *returnEntries);
208  void comparison(bool input, operatortypes_e op,
209  vector<indexEntry_s> *returnEntries);
217  void comparison(long double input, operatortypes_e op,
218  vector<indexEntry_s> *returnEntries);
226  void comparison(char input, operatortypes_e op,
227  vector<indexEntry_s> *returnEntries);
235  void comparison(string *input, operatortypes_e op,
236  vector<indexEntry_s> *returnEntries);
248  void between(int64_t lower, int64_t upper,
249  vector<indexEntry_s> *returnEntries);
261  void between(uint64_t lower, uint64_t upper,
262  vector<indexEntry_s> *returnEntries);
274  void between(bool lower, bool upper,
275  vector<indexEntry_s> *returnEntries);
287  void between(long double lower, long double upper,
288  vector<indexEntry_s> *returnEntries);
300  void between(char lower, char upper,
301  vector<indexEntry_s> *returnEntries);
313  void between(string lower, string upper,
314  vector<indexEntry_s> *returnEntries);
315 
327  template <class T>
328  void notbetween(T lower, T upper, vector<indexEntry_s> *returnEntries)
329  {
330  comparison(lower, OPERATOR_LT, returnEntries);
331  comparison(upper, OPERATOR_GT, returnEntries);
332  }
333 
342  void regex(string *regexStr, vector<indexEntry_s> *returnEntries);
351  void like(string &likeStr, vector<indexEntry_s> *returnEntries);
358  void notlike(string &likeStr, vector<indexEntry_s> *returnEntries);
365  void getnotin(vector<int64_t> &entries,
366  vector<indexEntry_s> *returnEntries);
373  void getnotin(vector<uint64_t> &entries,
374  vector<indexEntry_s> *returnEntries);
381  void getnotin(vector<bool> &entries,
382  vector<indexEntry_s> *returnEntries);
389  void getnotin(vector<long double> &entries,
390  vector<indexEntry_s> *returnEntries);
397  void getnotin(vector<char> &entries,
398  vector<indexEntry_s> *returnEntries);
405  void getnotin(vector<string> &entries,
406  vector<indexEntry_s> *returnEntries);
407 
415  void commitRollback(int64_t input, int64_t subtransactionid,
416  enginecmd_e cmd);
424  void commitRollback(uint64_t input, int64_t subtransactionid,
425  enginecmd_e cmd);
433  void commitRollback(bool input, int64_t subtransactionid,
434  enginecmd_e cmd);
442  void commitRollback(long double input, int64_t subtransactionid,
443  enginecmd_e cmd);
451  void commitRollback(char input, int64_t subtransactionid,
452  enginecmd_e cmd);
460  void commitRollback(string input, int64_t subtransactionid,
461  enginecmd_e cmd);
473  void replaceUnique(int64_t newrowid, int64_t newengineid,
474  int64_t input);
486  void replaceUnique(int64_t newrowid, int64_t newengineid,
487  uint64_t input);
499  void replaceUnique(int64_t newrowid, int64_t newengineid,
500  bool input);
512  void replaceUnique(int64_t newrowid, int64_t newengineid,
513  long double input);
525  void replaceUnique(int64_t newrowid, int64_t newengineid,
526  char input);
538  void replaceUnique(int64_t newrowid, int64_t newengineid,
539  string &input);
553  void replaceNonunique(int64_t oldrowid, int64_t oldengineid,
554  int64_t newrowid, int64_t newengineid,
555  int64_t input);
569  void replaceNonunique(int64_t oldrowid, int64_t oldengineid,
570  int64_t newrowid, int64_t newengineid,
571  uint64_t input);
585  void replaceNonunique(int64_t oldrowid, int64_t oldengineid,
586  int64_t newrowid, int64_t newengineid,
587  bool input);
601  void replaceNonunique(int64_t oldrowid, int64_t oldengineid,
602  int64_t newrowid, int64_t newengineid,
603  long double input);
617  void replaceNonunique(int64_t oldrowid, int64_t oldengineid,
618  int64_t newrowid, int64_t newengineid,
619  char input);
633  void replaceNonunique(int64_t oldrowid, int64_t oldengineid,
634  int64_t newrowid, int64_t newengineid,
635  string &input);
648  void replaceNull(int64_t oldrowid, int64_t oldengineid,
649  int64_t newrowid, int64_t newengineid);
650 
656  void getnulls(vector<indexEntry_s> *returnEntries);
664  void insertNonuniqueEntry(int64_t entry, int64_t rowid, int64_t engineid);
672  void insertNonuniqueEntry(uint64_t entry, int64_t rowid, int64_t engineid);
680  void insertNonuniqueEntry(bool entry, int64_t rowid, int64_t engineid);
688  void insertNonuniqueEntry(long double entry, int64_t rowid,
689  int64_t engineid);
697  void insertNonuniqueEntry(char entry, int64_t rowid, int64_t engineid);
705  void insertNonuniqueEntry(string *entry, int64_t rowid, int64_t engineid);
713  void deleteNonuniqueEntry(int64_t entry, int64_t rowid, int64_t engineid);
721  void deleteNonuniqueEntry(uint64_t entry, int64_t rowid, int64_t engineid);
729  void deleteNonuniqueEntry(bool entry, int64_t rowid, int64_t engineid);
737  void deleteNonuniqueEntry(long double entry, int64_t rowid,
738  int64_t engineid);
746  void deleteNonuniqueEntry(char entry, int64_t rowid, int64_t engineid);
754  void deleteNonuniqueEntry(string * engry, int64_t rowid, int64_t engineid);
760  void deleteUniqueEntry(int64_t entry);
766  void deleteUniqueEntry(uint64_t entry);
772  void deleteUniqueEntry(bool entry);
778  void deleteUniqueEntry(long double entry);
784  void deleteUniqueEntry(char entry);
790  void deleteUniqueEntry(string *entry);
797  void insertNullEntry(int64_t rowid, int64_t engineid);
804  void deleteNullEntry(int64_t rowid, int64_t engineid);
810  void getall(vector<indexEntry_s> *returnEntries);
811 
826  locktype_e checkAndLock(int64_t entry, int64_t rowid, int64_t engineid,
827  int64_t subtransactionid, int64_t pendingcmdid,
828  int64_t tacmdentrypoint);
843  locktype_e checkAndLock(uint64_t entry, int64_t rowid, int64_t engineid,
844  int64_t subtransactionid, int64_t pendingcmdid,
845  int64_t tacmdentrypoint);
860  locktype_e checkAndLock(bool entry, int64_t rowid, int64_t engineid,
861  int64_t subtransactionid, int64_t pendingcmdid,
862  int64_t tacmdentrypoint);
877  locktype_e checkAndLock(long double entry, int64_t rowid, int64_t engineid,
878  int64_t subtransactionid, int64_t pendingcmdid,
879  int64_t tacmdentrypoint);
894  locktype_e checkAndLock(char entry, int64_t rowid, int64_t engineid,
895  int64_t subtransactionid, int64_t pendingcmdid,
896  int64_t tacmdentrypoint);
911  locktype_e checkAndLock(string *entry, int64_t rowid, int64_t engineid,
912  int64_t subtransactionid, int64_t pendingcmdid,
913  int64_t tacmdentrypoint);
920  void getequal_f(int64_t entry, vector<indexEntry_s> *returnEntries);
927  void getequal_f(uint64_t entry, vector<indexEntry_s> *returnEntries);
934  void getequal_f(bool entry, vector<indexEntry_s> *returnEntries);
941  void getequal_f(long double entry, vector<indexEntry_s> *returnEntries);
948  void getequal_f(char entry, vector<indexEntry_s> *returnEntries);
955  void getequal_f(string entry, vector<indexEntry_s> *returnEntries);
956 
957  // apply unique index not null
968  bool addifnotthere(fieldValue_s &val, int64_t rowid, int16_t engineid,
969  int64_t subtransactionid);
977  bool checkifthere(fieldValue_s & val);
985  bool checkifthere(int64_t val);
993  bool checkifthere(uint64_t val);
1001  bool checkifthere(bool val);
1009  bool checkifthere(long double val);
1017  bool checkifthere(char val);
1025  bool checkifthere(string &val);
1035  bool checkifmatch(fieldValue_s &val, int64_t rowid, int64_t engineid);
1045  bool checkifmatch(int64_t val, int64_t rowid, int64_t engineid);
1055  bool checkifmatch(uint64_t val, int64_t rowid, int64_t engineid);
1065  bool checkifmatch(bool val, int64_t rowid, int64_t engineid);
1075  bool checkifmatch(long double val, int64_t rowid, int64_t engineid);
1085  bool checkifmatch(char val, int64_t rowid, int64_t engineid);
1095  bool checkifmatch(string &val, int64_t rowid, int64_t engineid);
1101  void rm(fieldValue_s &val);
1107  void rm(int64_t val);
1113  void rm(uint64_t val);
1119  void rm(bool val);
1125  void rm(long double val);
1131  void rm(char val);
1137  void rm(string &val);
1147  int64_t getprevioussubtransactionid(fieldValue_s &val);
1148  int64_t getprevioussubtransactionid(int64_t val);
1149  int64_t getprevioussubtransactionid(uint64_t val);
1150  int64_t getprevioussubtransactionid(bool val);
1151  int64_t getprevioussubtransactionid(long double val);
1152  int64_t getprevioussubtransactionid(char val);
1153  int64_t getprevioussubtransactionid(string &val);
1154 
1163  template <class T, class U, class V>
1164  void getIterators(string *regexStr, T mapPtr, U itBegin, V itEnd)
1165  {
1166  if (!regexStr->size())
1167  {
1168  return;
1169  }
1170 
1171  string tmpStr = *regexStr;
1172 
1173  if (tmpStr[0]=='^')
1174  {
1175  tmpStr.erase(0, 1);
1176  }
1177 
1178  size_t n = tmpStr.find_first_of("[\\^$.|?*+()", 0);
1179 
1180  if (!n) // no beginning search string
1181  {
1182  *itBegin = mapPtr->begin();
1183  *itEnd = mapPtr->end();
1184  return;
1185  }
1186 
1187  string beginStr(tmpStr, 0, std::min(n, regexStr->size()));
1188  string endStr = beginStr;
1189 
1190  if (endStr[endStr.size()-1] == 255)
1191  {
1192  endStr.append(1, 1);
1193  }
1194  else
1195  {
1196  endStr[endStr.size()-1]++;
1197  }
1198 
1199  *itBegin = mapPtr->find(beginStr);
1200 
1201  if (*itBegin == mapPtr->end())
1202  {
1203  *itBegin = mapPtr->upper_bound(beginStr);
1204  }
1205 
1206  *itEnd = mapPtr->lower_bound(endStr);
1207  }
1208 
1209  indextype_e indextype;
1210  fieldtype_e fieldtype; // if simple, otherwise string
1211  maptype_e maptype;
1212  bool notNull;
1213  bool isunique;
1214  indexmaptype_e indexmaptype;
1215  // buncha index types! INT, UINT, BOOL, FLOAT, CHAR, CHARX, VARCHAR
1216  uniqueIntMap *uniqueIntIndex;
1217  nonuniqueIntMap *nonuniqueIntIndex;
1218  unorderedIntMap *unorderedIntIndex;
1219  uniqueUintMap *uniqueUintIndex;
1220  nonuniqueUintMap *nonuniqueUintIndex;
1221  unorderedUintMap *unorderedUintIndex;
1222  uniqueBoolMap *uniqueBoolIndex;
1223  nonuniqueBoolMap *nonuniqueBoolIndex;
1224  unorderedBoolMap *unorderedBoolIndex;
1225  uniqueFloatMap *uniqueFloatIndex;
1226  nonuniqueFloatMap *nonuniqueFloatIndex;
1227  unorderedFloatMap *unorderedFloatIndex;
1228  uniqueCharMap *uniqueCharIndex;
1229  nonuniqueCharMap *nonuniqueCharIndex;
1230  unorderedCharMap *unorderedCharIndex;
1231  uniqueStringMap *uniqueStringIndex;
1232  nonuniqueStringMap *nonuniqueStringIndex;
1233  unorderedStringMap *unorderedStringIndex;
1234  unorderedIntMap *intIndexShadow;
1235  unorderedUintMap *uintIndexShadow;
1236  unorderedBoolMap *boolIndexShadow;
1237  unorderedFloatMap *floatIndexShadow;
1238  unorderedCharMap *charIndexShadow;
1239  unorderedStringMap *stringIndexShadow;
1240  // these are used for either "unique" or unordered" indices
1241  boost::unordered_map< int64_t, std::queue<lockQueueIndexEntry> >
1242  *intLockQueue;
1243  boost::unordered_map< uint64_t, std::queue<lockQueueIndexEntry> >
1244  *uintLockQueue;
1245  boost::unordered_map< bool, std::queue<lockQueueIndexEntry> >
1246  *boolLockQueue;
1247  boost::unordered_map< long double, std::queue<lockQueueIndexEntry> >
1248  *floatLockQueue;
1249  boost::unordered_map< char, std::queue<lockQueueIndexEntry> >
1250  *charLockQueue;
1251  boost::unordered_map< std::string, std::queue<lockQueueIndexEntry> >
1252  *stringLockQueue;
1253  // // field [0] is rowid, [1] is engineid, just need 1 type,
1254  // since the entry is null
1255  // // and might as well make it with the index, instead of having it
1256  // as a pointer
1257  // // just less code...
1258  boost::unordered_set< vector<int64_t> > nulls;
1259 };
1260 
1261 #endif /* INFINISQLINDEX_H */