Annotation of parser3/src/include/pa_db_table.h, revision 1.12

1.1       paf         1: /** @file
                      2:        Parser: sql db decl.
                      3: 
                      4:        Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
1.8       paf         5:        Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)
1.1       paf         6: 
1.12    ! paf         7:        $Id: pa_db_table.h,v 1.11 2001/12/15 21:28:19 paf Exp $
1.1       paf         8: */
                      9: 
                     10: #ifndef PA_DB_TABLE_H
                     11: #define PA_DB_TABLE_H
                     12: 
1.3       paf        13: #include "pa_globals.h"
1.1       paf        14: #include "pa_pool.h"
                     15: 
1.5       paf        16: #ifdef DB2
1.1       paf        17: #      include <db.h>
1.6       paf        18: #      if DB_VERSION_MAJOR != 2
                     19: #              error Parser needs DB 2.x.x version of libdb to compile
                     20: #      endif
1.1       paf        21: #endif
                     22: 
                     23: // defines
                     24: 
                     25: #define PA_DB_ACCESS_METHOD DB_BTREE
                     26: 
                     27: // forwards
                     28: 
1.3       paf        29: class DB_Connection;
                     30: 
                     31: class DB_Table_ptr;
1.2       paf        32: class DB_Transaction;
1.1       paf        33: class DB_Cursor;
                     34: 
                     35: // class
                     36: 
                     37: /// DB table. handy wrapper around low level <db.h> calls
                     38: class DB_Table : public Pooled {
1.7       paf        39:        friend class DB_Table_ptr;
                     40:        friend class DB_Transaction;
                     41:        friend class DB_Cursor;
1.1       paf        42: public:
                     43: 
1.3       paf        44:        DB_Table(Pool& apool, const String& afile_name, DB_Connection& aconnection);
                     45:        ~DB_Table();
                     46: 
                     47:        const String& file_name() { return ffile_name; }
1.1       paf        48: 
                     49:        bool expired(time_t older_dies) {
1.3       paf        50:                return !used && time_used<older_dies;
1.1       paf        51:        }
1.8       paf        52:        time_t get_time_used() { return time_used; }
                     53:        int get_users_count() { return used; }
1.1       paf        54: 
1.9       paf        55:        void put(DB_Transaction *t, const String& key, const String& data, time_t lifespan);
                     56:        String *get(DB_Transaction *t, Pool& pool, const String& key, time_t lifespan);
1.3       paf        57:        void remove(DB_Transaction *t, const String& key);
                     58: 
                     59: private: // table usage methods
                     60: 
                     61:        void use();
                     62:        void unuse();
1.1       paf        63: 
1.3       paf        64: private: // table usage data
1.1       paf        65: 
1.3       paf        66:        int used;
1.1       paf        67: 
                     68: private:
                     69: 
                     70:        DB_Connection& fconnection;
                     71:        DB_ENV& dbenv;
1.3       paf        72:        const String& ffile_name; const char *file_name_cstr;
1.1       paf        73:        DB *db;
                     74:        time_t time_used;
                     75: 
                     76: private:
                     77: 
                     78:        void check(const char *operation, const String *source, int error);
                     79:        /// pass empty dbt, would fill it from string
                     80:        void key_string_to_dbt(const String& key_string, DBT& key_result);
                     81:        /// @returns new string
1.3       paf        82:        String& key_dbt_to_string(Pool& pool, const DBT& key_dbt);
1.1       paf        83:        /// pass empty dbt, would fill it from string
1.9       paf        84:        void data_string_to_dbt(const String& data_string,  time_t lifespan, 
1.1       paf        85:                DBT& data_result);
                     86:        /// @returns new string if it not expired
1.9       paf        87:        String *data_dbt_to_string(Pool& pool, const DBT& data_dbt, time_t lifespan);
1.1       paf        88: 
                     89: };
                     90: 
1.3       paf        91: /// Auto-object used to track DB_Table usage
                     92: class DB_Table_ptr {
                     93:        DB_Table *ftable;
                     94: public:
                     95:        explicit DB_Table_ptr(DB_Table *atable) : ftable(atable) {
                     96:                ftable->use();
                     97:        }
                     98:        ~DB_Table_ptr() {
                     99:                ftable->unuse();
                    100:        }
                    101:        DB_Table* operator->() {
                    102:                return ftable;
                    103:        }
                    104:        DB_Table& operator*() {
                    105:                return *ftable;
                    106:        }
                    107: 
                    108:        // copying
                    109:        DB_Table_ptr(const DB_Table_ptr& src) : ftable(src.ftable) {
                    110:                ftable->use();
                    111:        }
                    112:        DB_Table_ptr& operator =(const DB_Table_ptr& src) {
                    113:                // may do without this=src check
                    114:                ftable->unuse();
                    115:                ftable=src.ftable;
                    116:                ftable->use();
                    117: 
                    118:                return *this;
                    119:        }
                    120: };
                    121: 
1.1       paf       122: ///    Auto-object used for temporary changing DB_Table::tid.
1.2       paf       123: class DB_Transaction {
1.1       paf       124: public:
1.3       paf       125: 
                    126:        DB_Transaction(Pool& apool, DB_Table& atable, DB_Transaction *& aparent_ref);
                    127:        ~DB_Transaction();
                    128:        DB_TXN *id() { return fid; }
                    129:        void mark_to_rollback();
                    130: 
1.9       paf       131:        void put(const String& key, const String& data, time_t lifespan) {
                    132:                ftable.put(this, key, data, lifespan);
1.3       paf       133:        }
1.9       paf       134:        String *get(const String& key, time_t lifespan) {
                    135:                return ftable.get(this, fpool, key, lifespan);
1.1       paf       136:        }
1.3       paf       137:        void remove(const String& key) {
                    138:                ftable.remove(this, key);
1.1       paf       139:        }
1.3       paf       140: 
                    141: private:
                    142: 
                    143:        void check(const char *operation, const String *source, int error) {
                    144:                ftable.check(operation, source, error);
1.1       paf       145:        }
1.3       paf       146: 
                    147: private:
                    148: 
                    149:        Pool& fpool;
                    150:        DB_Table& ftable;
                    151:        DB_Transaction *parent;
                    152:        DB_Transaction *& fparent_ref;
                    153:        DB_TXN *fid;
                    154:        bool marked_to_rollback;
                    155: 
1.1       paf       156: };
                    157: 
                    158: /// DB cursor. handy wrapper around low level <db.h> calls
                    159: class DB_Cursor {
                    160: public:
1.3       paf       161:        DB_Cursor(DB_Table& atable, DB_Transaction *transaction, const String *asource);
1.1       paf       162:        ~DB_Cursor();
                    163:        /// pass empty strings to key&data, would fill them
1.3       paf       164:        bool get(Pool& pool, String *& key, String *& data, u_int32_t flags);
1.4       paf       165:        bool move(u_int32_t flags);
1.1       paf       166:        void remove(u_int32_t flags);
                    167: private:
                    168:        const String *fsource;
                    169:        DB_Table& ftable;
                    170:        DBC *cursor;
                    171: private:
                    172:        void check(const char *operation, const String *source, int error) {
                    173:                ftable.check(operation, source, error);
                    174:        }
                    175:        /// @returns new string
1.3       paf       176:        String& key_dbt_to_string(Pool& pool, DBT& key_dbt) {
                    177:                return ftable.key_dbt_to_string(pool, key_dbt);
1.1       paf       178:        }
                    179:        /// @returns new string if it not expired
1.9       paf       180:        String *data_dbt_to_string(Pool& pool, const DBT& data_dbt, time_t lifespan) {  
                    181:                return ftable.data_dbt_to_string(pool, data_dbt, lifespan);
1.1       paf       182:        }
                    183: };
                    184: 
                    185: #endif

E-mail: