00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #ifndef __DATABASE_H__
00012 #define __DATABASE_H__
00013
00014 #include "class.h"
00015 #include "reference.h"
00016 #include "file.h"
00017 #include "pagepool.h"
00018
00019 BEGIN_GIGABASE_NAMESPACE
00020
00021 #ifdef _WINCE
00022
00025 const size_t dbDefaultInitIndexSize = 10*1024;
00026
00030 const size_t dbDefaultExtensionQuantum = 1*512*1024;
00031 #else
00032
00035 const size_t dbDefaultInitIndexSize = 512*1024;
00036
00040 const size_t dbDefaultExtensionQuantum = 4*1024*1024;
00041 #endif
00042
00046 const unsigned dbMaxParallelSearchThreads = 64;
00047
00051 enum dbHandleFlags {
00052 dbPageObjectFlag = 0x1,
00053 dbModifiedFlag = 0x2,
00054 dbFreeHandleFlag = 0x4,
00055 dbFlagsMask = 0x7,
00056 dbFlagsBits = 3
00057 };
00058
00059 const size_t dbAllocationQuantumBits = 6;
00060 const size_t dbAllocationQuantum = 1 << dbAllocationQuantumBits;
00061 const size_t dbPageBits = 13;
00062 const size_t dbPageSize = 1 << dbPageBits;
00063 const size_t dbIdsPerPage = dbPageSize / sizeof(oid_t);
00064 const size_t dbHandlesPerPage = dbPageSize / sizeof(offs_t);
00065 const size_t dbHandleBits = 1 + sizeof(offs_t)/4;
00066 const size_t dbBitmapSegmentBits = dbPageBits + 3 + dbAllocationQuantumBits;
00067 const size_t dbBitmapSegmentSize = 1 << dbBitmapSegmentBits;
00068 const size_t dbBitmapPages = 1 << (dbDatabaseOffsetBits-dbBitmapSegmentBits);
00069 const size_t dbDirtyPageBitmapSize = 1 << (dbDatabaseOidBits-dbPageBits+dbHandleBits-3);
00070 const size_t dbDefaultSelectionLimit = 2000000000;
00075 const int dbBMsearchThreshold = 512;
00079 const size_t dbIndexedMergeThreshold = 100;
00080
00081
00082 const char_t dbMatchAnyOneChar = '_';
00083 const char_t dbMatchAnySubstring = '%';
00084
00085 const int dbMaxFileSegments = 64;
00086 const int dbTableHashSize = 1009;
00087
00091 enum dbPredefinedIds {
00092 dbInvalidId,
00093 dbMetaTableId,
00094 dbBitmapId,
00095 dbFirstUserId = dbBitmapId + dbBitmapPages
00096 };
00097
00101 enum dbLockType {
00102 dbNoLock,
00103 dbSharedLock,
00104 dbUpdateLock,
00105 dbExclusiveLock
00106 };
00107
00111 class dbHeader {
00112 public:
00113 int4 curr;
00114 int4 dirty;
00115 int4 initialized;
00116 #if dbDatabaseOffsetBits > 32 && defined(ALIGN_HEADER)
00117 int4 pad1;
00118 #endif
00119 struct {
00120 offs_t size;
00121 offs_t index;
00122 offs_t shadowIndex;
00123 oid_t indexSize;
00124 oid_t shadowIndexSize;
00125 oid_t indexUsed;
00126 oid_t freeList;
00127 oid_t bitmapEnd;
00128 #ifdef DO_NOT_REUSE_OID_WITHIN_SESSION
00129 struct {
00130 oid_t head;
00131 oid_t tail;
00132 } sessionFreeList;
00133 #endif
00134 #if dbDatabaseOffsetBits > 32 && dbDatabaseOidBits <= 32 && defined(ALIGN_HEADER)
00135 oid_t pad2;
00136 #endif
00137 } root[2];
00138
00139 int4 versionMajor;
00140 int4 versionMinor;
00141 int4 transactionId;
00142 int4 mode;
00143
00144 enum {
00145 MODE_ALIGN_HEADER = 0x01,
00146 MODE_OID_64 = 0x02,
00147 MODE_OFFS_64 = 0x04,
00148 MODE_UNICODE = 0x08,
00149 MODE_AUTOINCREMENT = 0x10,
00150 MODE_RECTANGLE_DIM = 0x20,
00151 MODE_DO_NOT_REUSE_OID = 0x40
00152 };
00153
00154 int getVersion() {
00155 return versionMajor*100 + versionMinor;
00156 }
00157
00158 bool isCompatible();
00159 static int getCurrentMode();
00160
00161 bool isInitialized() {
00162 return initialized == 1
00163 && (dirty == 1 || dirty == 0)
00164 && (curr == 1 || curr == 0)
00165 && root[curr].size > root[curr].index
00166 && root[curr].size > root[curr].shadowIndex
00167 && root[curr].size > root[curr].indexSize*sizeof(offs_t)
00168 + root[curr].shadowIndexSize*sizeof(offs_t)
00169 && root[curr].indexSize >= root[curr].indexUsed
00170 && root[curr].indexUsed >= dbFirstUserId
00171 && root[curr].bitmapEnd > dbBitmapId;
00172 }
00173 };
00174
00175 class dbSynthesizedAttribute;
00176 class dbInheritedAttribute;
00177 class dbDatabaseThreadContext;
00178
00179 struct dbMemoryStatistic {
00180 offs_t used;
00181 offs_t free;
00182 offs_t nHoles;
00183 offs_t minHoleSize;
00184 offs_t maxHoleSize;
00185 size_t nHolesOfSize[dbDatabaseOffsetBits];
00186 };
00187
00188 class dbMonitor {
00189 public:
00190 dbLockType accLock;
00191
00192 dbDatabaseThreadContext* firstPending;
00193 dbDatabaseThreadContext* lastPending;
00194
00195 int nLockUpgrades;
00196
00197 int nReaders;
00198 int nWriters;
00199 int backupInProgress;
00200
00201 void wait(dbLockType type, dbMutex& mutex, dbDatabaseThreadContext* ctx);
00202
00203 dbMonitor() {
00204 firstPending = lastPending = NULL;
00205 accLock = dbNoLock;
00206 backupInProgress = 0;
00207 nReaders = nWriters = 0;
00208 nLockUpgrades = 0;
00209 }
00210 };
00211
00212
00213
00214 class dbAnyCursor;
00215 class dbQuery;
00216 class dbExprNode;
00217 class dbSearchContext;
00218 class dbXmlContext;
00219 class dbXmlScanner;
00220
00221
00222 class dbVisitedObject {
00223 public:
00224 dbVisitedObject* next;
00225 oid_t oid;
00226
00227 dbVisitedObject(oid_t oid, dbVisitedObject* chain) {
00228 this->oid = oid;
00229 next = chain;
00230 }
00231 };
00232
00236 class GIGABASE_DLL_ENTRY dbDatabase {
00237 friend class dbSelection;
00238 friend class dbAnyCursor;
00239 friend class dbHashTable;
00240 friend class dbQuery;
00241 friend class dbRtree;
00242 friend class dbRtreePage;
00243 friend class dbBtree;
00244 friend class dbBtreePage;
00245 friend class dbThickBtreePage;
00246 friend class dbInheritedAttribute;
00247 friend class dbParallelQueryContext;
00248 friend class dbServer;
00249 friend class dbPagePool;
00250
00251 friend class dbBlob;
00252 friend class dbBlobIterator;
00253 friend class dbBlobReadIterator;
00254 friend class dbBlobWriteIterator;
00255 friend class dbAnyContainer;
00256
00257 friend class dbGetTie;
00258 friend class dbPutTie;
00259
00260 friend class dbUserFunctionArgument;
00261
00262 friend class dbCLI;
00263 friend class GiSTdb;
00264
00265 friend class dbBtreeIterator;
00266 friend class dbRtreeIterator;
00267 friend class dbTableIterator;
00268 public:
00276 bool open(char_t const* databaseName, time_t transactionCommitDelay = 0, int openAttr = 0);
00277
00285 bool open(dbFile* file, time_t transactionCommitDelay = 0, bool deleteFileOnClose = false);
00286
00287 enum dbAccessType {
00288 dbReadOnly,
00289 dbAllAccess,
00290 dbMulticlientReadOnly,
00291 dbMulticlientReadWrite
00292 };
00293
00297 struct OpenParameters {
00301 char_t const* databaseName;
00302
00306 int openAttr;
00307
00311 dbFile* file;
00312
00316 time_t transactionCommitDelay;
00317
00321 bool deleteFileOnClose;
00322
00332 bool doNotReuseOidAfterClose;
00333
00337 dbAccessType accessType;
00338
00345 size_t poolSize;
00346
00350 size_t extensionQuantum;
00351
00355 size_t initIndexSize;
00356
00360 int nThreads;
00361
00362
00367 offs_t freeSpaceReuseThreshold;
00368
00369 OpenParameters() {
00370 databaseName = NULL;
00371 openAttr = 0;
00372 file = NULL;
00373 transactionCommitDelay = 0;
00374 deleteFileOnClose = false;
00375 accessType = dbAllAccess;
00376 poolSize = 0;
00377 extensionQuantum = dbDefaultExtensionQuantum;
00378 initIndexSize = dbDefaultInitIndexSize;
00379 nThreads = 1;
00380 freeSpaceReuseThreshold = dbDefaultExtensionQuantum;
00381 doNotReuseOidAfterClose = false;
00382 }
00383 };
00384
00385
00391 bool open(OpenParameters& params);
00392
00393
00397 virtual void close();
00398
00402 void commit();
00403
00407 void executeBatch();
00408
00413 void precommit();
00414
00418 void rollback();
00419
00424 void attach();
00425
00431 void attach(dbDatabaseThreadContext* ctx);
00432
00433 enum DetachFlags {
00434 COMMIT = 1,
00435 DESTROY_CONTEXT = 2
00436 };
00441 void detach(int flags = COMMIT|DESTROY_CONTEXT);
00442
00447 void lock(dbLockType type = dbExclusiveLock) { beginTransaction(type); }
00448
00457 bool backup(char_t const* backupFileName, bool compactify);
00458
00468 bool backup(dbOSFile* file, bool compactify);
00469
00476 bool restore(char_t const* backupFileName, char_t const* databaseFileName);
00477
00481 int getVersion();
00482
00487 void assign(dbTableDescriptor& desc) {
00488 assert(((void)"Table is not yet assigned to the database",
00489 desc.tableId == 0));
00490 desc.db = this;
00491 desc.fixedDatabase = true;
00492 }
00493
00500 dbTableDescriptor* lookupTable(dbTableDescriptor* desc);
00501
00506 void getMemoryStatistic(dbMemoryStatistic& stat);
00507
00515 void setConcurrency(unsigned nThreads);
00516
00521 offs_t getAllocatedSize() { return allocatedSize; }
00522
00530 void allowColumnsDeletion(bool enabled = true) {
00531 confirmDeleteColumns = enabled;
00532 }
00533
00537 void disableOidReuseOnClose(bool disabled = true) {
00538 doNotReuseOidAfterClose = disabled;
00539 }
00540
00541
00549 bool prepareQuery(dbAnyCursor* cursor, dbQuery& query);
00550
00554 enum dbErrorClass {
00555 NoError,
00556 QueryError,
00557 ArithmeticError,
00558 IndexOutOfRangeError,
00559 DatabaseOpenError,
00560 FileError,
00561 OutOfMemoryError,
00562 Deadlock,
00563 NullReferenceError,
00564 FileLimitExeeded,
00565 DatabaseReadOnly,
00566 UniqueConstraintViolation
00567 };
00568 static char const* const errorMessage[];
00569 typedef void (*dbErrorHandler)(int error, char const* msg, int msgarg, void* context);
00570
00577 dbErrorHandler setErrorHandler(dbErrorHandler newHandler, void* errorHandlerContext = NULL);
00578
00579
00586 virtual void scheduleBackup(char_t const* fileName, time_t periodSec);
00587
00588
00596 virtual void handleError(dbErrorClass error, char const* msg = NULL,
00597 int arg = 0);
00598
00599 dbAccessType accessType;
00600 size_t extensionQuantum;
00601 size_t initIndexSize;
00602 offs_t freeSpaceReuseThreshold;
00603
00604 static unsigned dbParallelScanThreshold;
00605 dbTableDescriptor* tableHash[dbTableHashSize];
00606
00617 bool insertRecord(dbTableDescriptor* table, dbAnyReference* ref,
00618 void const* record, bool batch);
00623 offs_t used();
00624
00628 bool isOpen() const { return opened; }
00629
00636 offs_t getDatabaseSize() {
00637 return header->root[1-curr].size;
00638 }
00639
00646 void setFileExtensionQuantum(offs_t quantum) {
00647 dbFileExtensionQuantum = quantum;
00648 }
00649
00654 void setFileSizeLimit(offs_t limit) {
00655 dbFileSizeLimit = limit;
00656 }
00657
00669 void createCluster(offs_t size);
00670
00671
00672 #ifndef NO_MEMBER_TEMPLATES
00673
00679 template<class T>
00680 dbReference<T> insert(T const& record) {
00681 dbReference<T> ref;
00682 insertRecord(lookupTable(&T::dbDescriptor), &ref, &record, false);
00683 return ref;
00684 }
00691 template<class T>
00692 dbReference<T> batchInsert(T const& record) {
00693 dbReference<T> ref;
00694 insertRecord(lookupTable(&T::dbDescriptor), &ref, &record, true);
00695 return ref;
00696 }
00697 #endif
00698
00704 bool isValidOid(oid_t oid) {
00705 if (oid < dbFirstUserId || oid >= currIndexSize) {
00706 return false;
00707 }
00708 offs_t pos = getPos(oid);
00709 return !(pos & (dbFreeHandleFlag|dbPageObjectFlag));
00710 }
00711
00713 enum SelectionMethod {
00714 sel_all,
00715 sel_all_except,
00716 sel_named_only
00717 };
00718
00725 void exportDatabaseToXml(FILE* out, char_t const* const* tables, size_t nTables, SelectionMethod method);
00726
00732 bool importDatabaseFromXml(FILE* in);
00733
00746 dbDatabase(dbAccessType type = dbAllAccess,
00747 size_t poolSize = 0,
00748 size_t dbExtensionQuantum = dbDefaultExtensionQuantum,
00749 size_t dbInitIndexSize = dbDefaultInitIndexSize,
00750 int nThreads = 1
00751
00752
00753
00754
00755 #ifdef NO_PTHREADS
00756 , bool usePthreads = false
00757 #endif
00758 );
00759
00763 virtual ~dbDatabase();
00764
00765 protected:
00766 dbThreadContext<dbDatabaseThreadContext> threadContext;
00767
00768 dbThreadPool threadPool;
00769
00770 dbHeader* header;
00771 int4* dirtyPagesMap;
00772 unsigned parThreads;
00773 bool modified;
00774
00775 int curr;
00776
00777
00778 int transactionId;
00779
00780 bool uncommittedChanges;
00781
00782 offs_t dbFileExtensionQuantum;
00783 offs_t dbFileSizeLimit;
00784
00785
00786 volatile int commitInProgress;
00787 volatile int concurrentTransId;
00788
00789 oid_t currRBitmapPage;
00790 size_t currRBitmapOffs;
00791
00792 oid_t currPBitmapPage;
00793 size_t currPBitmapOffs;
00794
00795
00796 struct dbLocation {
00797 offs_t pos;
00798 offs_t size;
00799 dbLocation* next;
00800 };
00801 dbLocation* reservedChain;
00802
00803 oid_t committedIndexSize;
00804 oid_t currIndexSize;
00805
00806 oid_t updatedRecordId;
00807
00808 dbFile* file;
00809 dbMutex mutex;
00810 dbSemaphore writeSem;
00811 dbSemaphore readSem;
00812 dbSemaphore upgradeSem;
00813 dbEvent backupCompletedEvent;
00814 dbMonitor monitor;
00815 dbPagePool pool;
00816 dbTableDescriptor* tables;
00817
00818 int* bitmapPageAvailableSpace;
00819 bool opened;
00820
00821 offs_t allocatedSize;
00822 offs_t deallocatedSize;
00823
00824 int forceCommitCount;
00825 time_t commitDelay;
00826 time_t commitTimeout;
00827 time_t commitTimerStarted;
00828
00829 dbMutex commitThreadSyncMutex;
00830 dbMutex delayedCommitStartTimerMutex;
00831 dbMutex delayedCommitStopTimerMutex;
00832 dbEvent commitThreadSyncEvent;
00833
00834 dbEvent delayedCommitStartTimerEvent;
00835
00836 dbEvent delayedCommitStopTimerEvent;
00837 dbDatabaseThreadContext* delayedCommitContext;
00838
00839 dbMutex backupMutex;
00840 dbEvent backupInitEvent;
00841 char_t* backupFileName;
00842 time_t backupPeriod;
00843
00844 dbThread backupThread;
00845 dbThread commitThread;
00846
00847 dbTableDescriptor* batchList;
00848
00849 int accessCount;
00850
00851 dbL2List threadContextList;
00852 dbMutex threadContextListMutex;
00853
00854 dbErrorHandler errorHandler;
00855 void* errorHandlerContext;
00856
00857 bool confirmDeleteColumns;
00858 int schemeVersion;
00859 dbVisitedObject* visitedChain;
00860
00861 int* btreeBuf;
00862 bool deleteFile;
00863 bool doNotReuseOidAfterClose;
00864 dbXmlContext* xmlContext;
00865
00866 oid_t mapId(long id);
00867 bool importField(char_t* terminator, dbFieldDescriptor* fd, byte* rec, dbXmlScanner& scanner);
00868 bool importRecord(char_t* terminator, dbFieldDescriptor* fieldList, byte* rec, dbXmlScanner& scanner);
00869 bool insertRecord(dbTableDescriptor* desc, oid_t oid, void const* record);
00870
00871
00877 dbTableDescriptor* loadMetaTable();
00878
00879 void releaseFile();
00880
00884 virtual void replicatePage(offs_t pageOffs, void* pageData);
00885
00889 void delayedCommit();
00890
00894 void backupScheduler();
00895
00896 static void thread_proc delayedCommitProc(void* arg) {
00897 ((dbDatabase*)arg)->delayedCommit();
00898 }
00899
00900 static void thread_proc backupSchedulerProc(void* arg) {
00901 ((dbDatabase*)arg)->backupScheduler();
00902 }
00903
00908 void commit(dbDatabaseThreadContext* ctx);
00909
00915 offs_t getPos(oid_t oid) {
00916 byte* p = pool.get(header->root[1-curr].index
00917 + (offs_t)(oid / dbHandlesPerPage) * dbPageSize);
00918 offs_t pos = *((offs_t*)p + oid % dbHandlesPerPage);
00919 pool.unfix(p);
00920 return pos;
00921 }
00922
00928 void setPos(oid_t oid, offs_t pos) {
00929 byte* p = pool.put(header->root[1-curr].index
00930 + (offs_t)(oid / dbHandlesPerPage) * dbPageSize);
00931 *((offs_t*)p + oid % dbHandlesPerPage) = pos;
00932 pool.unfix(p);
00933 }
00934
00941 dbRecord* getRow(dbGetTie& tie, oid_t oid) {
00942 offs_t pos = getPos(oid);
00943 assert(!(pos & (dbFreeHandleFlag|dbPageObjectFlag)));
00944 tie.set(pool, pos & ~dbFlagsMask);
00945 return (dbRecord*)tie.get();
00946 }
00947
00954 dbRecord* fetchRow(dbGetTie& tie, oid_t oid) {
00955 offs_t pos = getPos(oid);
00956 assert(!(pos & (dbFreeHandleFlag|dbPageObjectFlag)));
00957 tie.fetch(pool, pos & ~dbFlagsMask);
00958 return (dbRecord*)tie.get();
00959 }
00960
00966 void getHeader(dbRecord& rec, oid_t oid) {
00967 offs_t pos = getPos(oid);
00968 int offs = (int)pos & (dbPageSize-1);
00969 byte* p = pool.get(pos - offs);
00970 rec = *(dbRecord*)(p + (offs & ~dbFlagsMask));
00971 pool.unfix(p);
00972 }
00973
00979 byte* put(oid_t oid) {
00980 offs_t pos = getPos(oid);
00981 int offs = (int)pos & (dbPageSize-1);
00982 return pool.put(pos-offs) + (offs & ~dbFlagsMask);
00983 }
00984
00990 byte* get(oid_t oid) {
00991 offs_t pos = getPos(oid);
00992 int offs = (int)pos & (dbPageSize-1);
00993 return pool.get(pos-offs) + (offs & ~dbFlagsMask);
00994 }
00995
01003 dbRecord* putRow(dbPutTie& tie, oid_t oid, size_t newSize);
01004
01011 dbRecord* putRow(dbPutTie& tie, oid_t oid);
01012
01019 byte* put(dbPutTie& tie, oid_t oid);
01020
01025 void restoreTablesConsistency();
01026
01032 void applyIndex(dbFieldDescriptor* field, dbSearchContext& sc);
01033
01050 bool isIndexApplicable(dbAnyCursor* cursor, dbExprNode* expr, dbQuery& query,
01051 dbFieldDescriptor* &indexedField, bool& truncate, bool ascent, bool forAll);
01052
01060 bool isIndexApplicableToExpr(dbSearchContext& sc, dbExprNode* expr);
01061
01065 bool followInverseReference(dbExprNode* expr, dbExprNode* andExpr,
01066 dbAnyCursor* cursor, oid_t iref);
01067
01075 bool existsInverseReference(dbExprNode* expr, int nExistsClauses);
01076
01083 static void _fastcall execute(dbExprNode* expr,
01084 dbInheritedAttribute& iattr,
01085 dbSynthesizedAttribute& sattr);
01094 bool evaluateBoolean(dbExprNode* expr, oid_t oid, dbTableDescriptor* table, dbAnyCursor* cursor);
01095
01105 size_t evaluateString(dbExprNode* expr, oid_t oid, dbTableDescriptor* table, char_t* buf, size_t bufSize);
01106
01114 void evaluate(dbExprNode* expr, oid_t oid, dbTableDescriptor* table, dbSynthesizedAttribute& result);
01115
01120 void select(dbAnyCursor* cursor);
01121
01127 void select(dbAnyCursor* cursor, dbQuery& query);
01128
01134 void traverse(dbAnyCursor* cursor, dbQuery& query);
01135
01143 bool update(oid_t oid, dbTableDescriptor* table, void const* record);
01144
01150 void remove(dbTableDescriptor* table, oid_t oid);
01151
01159 offs_t allocate(offs_t size, oid_t oid = 0);
01160
01166 void free(offs_t pos, offs_t size);
01167
01172 void extend(offs_t size);
01173
01180 void cloneBitmap(offs_t pos, offs_t size);
01181
01186 oid_t allocateId();
01187
01192 void freeId(oid_t oid);
01193
01200 void updateCursors(oid_t oid, bool removed = false);
01201
01206 oid_t allocatePage() {
01207 oid_t oid = allocateId();
01208 setPos(oid, allocate(dbPageSize) | dbPageObjectFlag | dbModifiedFlag);
01209 return oid;
01210 }
01211
01216 void freePage(oid_t oid);
01217
01225 oid_t allocateRow(oid_t tableId, size_t size,
01226 dbTableDescriptor* desc = NULL)
01227 {
01228 oid_t oid = allocateId();
01229 allocateRow(tableId, oid, size, desc);
01230 return oid;
01231 }
01232
01241 void allocateRow(oid_t tableId, oid_t oid, size_t size, dbTableDescriptor* desc);
01242
01249 void freeRow(oid_t tableId, oid_t oid, dbTableDescriptor* desc = NULL);
01250
01255 static void deleteCompiledQuery(dbExprNode* tree);
01256
01261 void beginTransaction(dbLockType type);
01266 void endTransaction(dbDatabaseThreadContext* ctx);
01267
01271 void initializeMetaTable();
01272
01279 bool loadScheme();
01280
01286 bool completeDescriptorsInitialization();
01287
01293 void reformatTable(oid_t tableId, dbTableDescriptor* desc);
01294
01300 void addIndices(dbTableDescriptor* desc);
01301
01307 oid_t addNewTable(dbTableDescriptor* desc);
01308
01315 void updateTableDescriptor(dbTableDescriptor* desc,
01316 oid_t tableId, dbTable* table);
01317
01318
01324 void removeInverseReferences(dbTableDescriptor* desc, oid_t oid);
01325
01326
01335 void insertInverseReference(dbFieldDescriptor* desc, oid_t reverseId,
01336 oid_t targetId);
01337
01346 void removeInverseReference(dbFieldDescriptor* desc,
01347 oid_t reverseId, oid_t targetId);
01348
01353 void deleteTable(dbTableDescriptor* desc);
01354
01359 void dropTable(dbTableDescriptor* desc);
01360
01365 void createIndex(dbFieldDescriptor* fd);
01366
01371 void createHashTable(dbFieldDescriptor* fd);
01372
01377 void dropIndex(dbFieldDescriptor* fd);
01378
01383 void dropHashTable(dbFieldDescriptor* fd);
01384
01390 void linkTable(dbTableDescriptor* table, oid_t tableId);
01391
01396 void unlinkTable(dbTableDescriptor* table);
01397
01398
01405 bool wasReserved(offs_t pos, offs_t size);
01406
01415 void reserveLocation(dbLocation& location, offs_t pos, offs_t size);
01416
01421 void commitLocation();
01422
01428 dbTableDescriptor* findTable(char_t const* name);
01429
01436 dbTableDescriptor* findTableByName(char_t const* name);
01437
01438
01443 dbTableDescriptor* getTables() {
01444 return tables;
01445 }
01446
01447
01452 void cleanupOnOpenError();
01453
01457 void setDirty();
01458
01462 void refreshTable(dbTableDescriptor* desc);
01463 };
01464
01465 template<class T>
01466 dbReference<T> insert(T const& record) {
01467 dbReference<T> ref;
01468 T::dbDescriptor.getDatabase()->insertRecord(&T::dbDescriptor, &ref, &record, false);
01469 return ref;
01470 }
01471
01472 template<class T>
01473 dbReference<T> batchInsert(T const& record) {
01474 dbReference<T> ref;
01475 T::dbDescriptor.getDatabase()->insertRecord(&T::dbDescriptor, &ref, &record, true);
01476 return ref;
01477 }
01478
01479 #ifdef NO_MEMBER_TEMPLATES
01480 template<class T>
01481 dbReference<T> insert(dbDatabase& db, T const& record) {
01482 dbReference<T> ref;
01483 db.insertRecord(db.lookupTable(&T::dbDescriptor), &ref, &record, false);
01484 return ref;
01485 }
01486 template<class T>
01487 dbReference<T> batchInsert(dbDatabase& db, T const& record) {
01488 dbReference<T> ref;
01489 db.insertRecord(db.lookupTable(&T::dbDescriptor), &ref, &record, true);
01490 return ref;
01491 }
01492 #endif
01493
01494 class dbSearchContext {
01495 public:
01496 dbDatabase* db;
01497 dbExprNode* condition;
01498 dbAnyCursor* cursor;
01499 char_t* firstKey;
01500 int firstKeyInclusion;
01501 char_t* lastKey;
01502 int lastKeyInclusion;
01503 int prefixLength;
01504 int offs;
01505 int probes;
01506 bool ascent;
01507 bool tmpKeys;
01508 bool spatialSearch;
01509 bool arraySearch;
01510
01511 void operator = (dbSearchContext const& sc);
01512
01513 union {
01514 bool b;
01515 int1 i1;
01516 int2 i2;
01517 int4 i4;
01518 db_int8 i8;
01519 real4 f4;
01520 real8 f8;
01521 oid_t oid;
01522 void* raw;
01523 rectangle* rect;
01524 char_t* s;
01525 dbAnyArray* a;
01526 } literal[2];
01527 };
01528
01529 END_GIGABASE_NAMESPACE
01530
01531 #endif
01532