Main Page   Class Hierarchy   Compound List   File List   Compound Members  

database.h

00001 //-< DATABASE.H >----------------------------------------------------*--------*
00002 // GigaBASE                  Version 1.0         (c) 1999  GARRET    *     ?  *
00003 // (Post Relational Database Management System)                      *   /\|  *
00004 //                                                                   *  /  \  *
00005 //                          Created:     20-Nov-98    K.A. Knizhnik  * / [] \ *
00006 //                          Last update: 14-Feb-99    K.A. Knizhnik  * GARRET *
00007 //-------------------------------------------------------------------*--------*
00008 // Database management
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; // typical nr. of objects in db
00026 
00030 const size_t dbDefaultExtensionQuantum = 1*512*1024;  // alloc per half meg.
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; // log(sizeof(offs_t))
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;  // current root
00114     int4   dirty; // database was not closed normally
00115     int4   initialized; // database is initiliazed
00116 #if dbDatabaseOffsetBits > 32 && defined(ALIGN_HEADER)
00117     int4   pad1;
00118 #endif
00119     struct {
00120         offs_t size;            // database file size
00121         offs_t index;           // offset to object index
00122         offs_t shadowIndex;     // offset to shadow index
00123         oid_t  indexSize;       // size of object index
00124         oid_t  shadowIndexSize; // size of object index
00125         oid_t  indexUsed;       // used part of the index
00126         oid_t  freeList;        // L1 list of free object identifiers
00127         oid_t  bitmapEnd;       // index of last allocated bitmap page
00128 #ifdef DO_NOT_REUSE_OID_WITHIN_SESSION
00129         struct {
00130             oid_t head;
00131             oid_t tail;
00132         } sessionFreeList;  // L1 list of object identifiers deallocated within this session
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; // used for multiclient access 
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,            //< just export all tables. Default
00715         sel_all_except,     //< '-' Export all tables except the named tables
00716         sel_named_only      //< '+' Only export explicitly named tables.
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, // autodetect size of available memory
00748                size_t dbExtensionQuantum = dbDefaultExtensionQuantum,
00749                size_t dbInitIndexSize = dbDefaultInitIndexSize,
00750                int nThreads = 1
00751                // Do not specify the last parameter - it is only for checking
00752                // that application and GigaBASE library were built with the
00753                // same compiler options (-DNO_PTHREADS is critical)
00754                // Mismached parameters should cause linker error
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;           // database header information
00771     int4*     dirtyPagesMap;    // bitmap of changed pages in current index
00772     unsigned  parThreads;
00773     bool      modified;
00774     
00775     int       curr;             // copy of header->root, used to allow read access to the database 
00776                                 // during transaction commit
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;  //current bitmap page for allocating records
00790     size_t    currRBitmapOffs;  //offset in current bitmap page for allocating
00791                                 //unaligned records
00792     oid_t     currPBitmapPage;  //current bitmap page for allocating page objects
00793     size_t    currPBitmapOffs;  //offset in current bitmap page for allocating
00794                                 //page objects
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     // object used to notify delayed commit thread to schdule delayed commit
00834     dbEvent                   delayedCommitStartTimerEvent; 
00835     // object used by delaued commit thread to wait for sepcified timeout
00836     dbEvent                   delayedCommitStopTimerEvent; 
00837     dbDatabaseThreadContext*  delayedCommitContext;     // save context of delayed transaction
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; // temporary keys were created for using index with LIKE operation
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 

Generated on Thu Feb 14 21:46:03 2008 for GigaBASE by doxygen1.2.18