[BACK]Return to pa_db_connection.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/Attic/pa_db_connection.C between versions 1.18 and 1.36

version 1.18, 2001/10/27 10:14:45 version 1.36, 2002/02/08 07:27:47
Line 1 Line 1
 /** @file  /** @file
         Parser: sql driver connection implementation.          Parser: sql driver connection implementation.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)          Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)
   
         $Id$          $Id$
   
           developed with LIBDB 2.7.4
 */  */
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
 #ifdef HAVE_LIBDB  #ifdef DB2
   
 #include "pa_db_connection.h"  #include "pa_db_connection.h"
 #include "pa_db_table.h"  #include "pa_db_table.h"
Line 16 Line 18
 #include "pa_threads.h"  #include "pa_threads.h"
 #include "pa_stack.h"  #include "pa_stack.h"
 #include "pa_common.h"  #include "pa_common.h"
   #include "pa_vtable.h"
   
 // defines  // defines
   
 #define DB_ERROR_PREFIX "db_err: "  
 #define DB_EXCEPTION_NO_LOG_MESSAGE1 DB_ERROR_PREFIX"Ignoring log file"  
 #define DB_EXCEPTION_NO_LOG_MESSAGE2 DB_ERROR_PREFIX"log_get: unable to find checkpoint record"  
   
 // consts  // consts
   
 /// @test increase  /// @test increase
Line 43  static void db_paniccall(DB_ENV *dbenv, Line 42  static void db_paniccall(DB_ENV *dbenv,
 static void db_errcall(const char *, char *buffer) {  static void db_errcall(const char *, char *buffer) {
         throw Exception(0, 0,           throw Exception(0, 0, 
                 0,                   0, 
                 DB_ERROR_PREFIX "%s",                   "db_err: %s", 
                 buffer);                  buffer);
 }  }
   
 static void expire_table(const Hash::Key& key, Hash::Val *& value, void *info) {  static void expire_table(const Hash::Key& key, Hash::Val *& value, void *info) {
         DB_Connection& table=*static_cast<DB_Connection *>(value);          DB_Table *table=static_cast<DB_Table *>(value);
         time_t older_dies=reinterpret_cast<time_t>(info);          time_t older_dies=reinterpret_cast<time_t>(info);
   
         if(table.expired(older_dies)) {          if(table->expired(older_dies)) {
                 table.~DB_Connection();  value=0;                  table->~DB_Table();  value=0;
         }          }
 }  }
   
Line 60  static void expire_table(const Hash::Key Line 59  static void expire_table(const Hash::Key
   
 DB_Connection::DB_Connection(Pool& apool, const String& adb_home) : Pooled(apool),  DB_Connection::DB_Connection(Pool& apool, const String& adb_home) : Pooled(apool),
         time_used(0),          time_used(0),
         fdb_home(adb_home),           fdb_home(adb_home), used(0),
         table_cache(apool),          table_cache(apool),
         prev_expiration_pass_time(0) {          prev_expiration_pass_time(0) {
         //_asm  int 3;          //_asm  int 3;
         char DB_DATA_DIR__VALUE[MAX_STRING];          char DB_DATA_DIR__VALUE[MAX_STRING];
         char DB_LOG_DIR__VALUE[MAX_STRING];  
         char DB_TMP_DIR__VALUE[MAX_STRING];          char DB_TMP_DIR__VALUE[MAX_STRING];
   
         const char *db_home_cstr=fdb_home.cstr(String::UL_FILE_SPEC);          const char *db_home_cstr=fdb_home.cstr(String::UL_FILE_SPEC);
   
         snprintf(DB_DATA_DIR__VALUE, MAX_STRING, "DB_DATA_DIR %s", db_home_cstr);          snprintf(DB_DATA_DIR__VALUE, MAX_STRING, "DB_DATA_DIR %s", db_home_cstr);
         snprintf(DB_LOG_DIR__VALUE, MAX_STRING, "DB_LOG_DIR %s", db_home_cstr);  
         snprintf(DB_TMP_DIR__VALUE, MAX_STRING, "DB_TMP_DIR %s", db_home_cstr);          snprintf(DB_TMP_DIR__VALUE, MAX_STRING, "DB_TMP_DIR %s", db_home_cstr);
   
         char *db_config[] = {          char *db_config[] = {
                 DB_DATA_DIR__VALUE,                  DB_DATA_DIR__VALUE,
                 DB_LOG_DIR__VALUE,  
                 DB_TMP_DIR__VALUE,                   DB_TMP_DIR__VALUE, 
                 0                  0
         };          };
   
         u_int32_t flags=          u_int32_t flags=
                 DB_THREAD                  (parser_multithreaded?DB_THREAD:0)
                 | DB_CREATE                   | DB_CREATE 
                 | DB_INIT_MPOOL | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_TXN;                  | DB_INIT_MPOOL;
   
         // trying to open with SOFT RECOVER option set          // prepare dbenv structure
         memset(&dbenv, 0, sizeof(dbenv));          memset(&dbenv, 0, sizeof(dbenv));
                   
         // error handlers          // error handlers
   #if DB_VERSION_MINOR >= 7
         dbenv.db_paniccall=db_paniccall;          dbenv.db_paniccall=db_paniccall;
   #endif
         dbenv.db_errcall=db_errcall;          dbenv.db_errcall=db_errcall;
   
           // lockdetector flags
           dbenv.lk_detect=DB_LOCK_RANDOM;
   
         // init          // init
         check("db_appinit", &fdb_home, db_appinit(          check("db_appinit", &fdb_home, db_appinit(
                 db_home_cstr,                  db_home_cstr,
Line 105  DB_Connection::DB_Connection(Pool& apool Line 106  DB_Connection::DB_Connection(Pool& apool
 DB_Connection::~DB_Connection() {  DB_Connection::~DB_Connection() {
         // close tables          // close tables
         table_cache.for_each(expire_table,           table_cache.for_each(expire_table, 
                 reinterpret_cast<void *>(0/* =in the past = expire[close] all*/));                  reinterpret_cast<void *>(time(0)+1/* =future= expire[close] all*/));
                   
         // destroy connection data          // destroy connection data
         check("db_appexit", &fdb_home, db_appexit(&dbenv));          check("db_appexit", &fdb_home, db_appexit(&dbenv));
Line 119  void DB_Connection::check(const char *op Line 120  void DB_Connection::check(const char *op
                 break;                   break; 
                   
         default:          default:
                 throw Exception(0, 0,                   if(error<0)
                         source,                           throw Exception(0, 0, 
                         "db %s error: %s (%d)",                                   source, 
                         operation, strerror(error), error);                                  "db %s error: %d", 
                                   operation, error);
                   else
                           throw Exception(0, 0, 
                                   source, 
                                   "db %s error: %s (%d)", 
                                   operation, strerror(error), error);
         }          }
 }  }
   
 DB_Table_ptr DB_Connection::get_table_ptr(const String& request_file_name, const String *source) {  DB_Table_ptr DB_Connection::get_table_ptr(const String& request_file_name, const String *source) {
         // checkpoint  
         check("checkpoint", source,   
                 txn_checkpoint(dbenv.tx_info, 0/*kbyte*/, DB_CHECKPOINT_MINUTES/*min*/));  
   
         // first trying to get cached table          // first trying to get cached table
         DB_Table *result=get_table_from_cache(request_file_name);          DB_Table *result=get_table_from_cache(request_file_name);
         if(!result) { // no cached table          if(!result) { // no cached table
                 // make global_file_name C-string on global pool                  // make global_file_name C-string on global pool
                 const char *request_file_name_cstr=request_file_name.cstr(String::UL_AS_IS);                  const char *request_file_name_cstr=request_file_name.cstr();
                 char *global_file_name_cstr=(char *)malloc(strlen(request_file_name_cstr)+1);                  char *global_file_name_cstr=(char *)malloc(strlen(request_file_name_cstr)+1);
                 strcpy(global_file_name_cstr, request_file_name_cstr);                  strcpy(global_file_name_cstr, request_file_name_cstr);
                 // make global_file_name string on global pool                  // make global_file_name string on global pool
Line 180  void DB_Connection::maybe_expire_table_c Line 183  void DB_Connection::maybe_expire_table_c
         }          }
 }  }
   
   static void add_table_to_status_table(const Hash::Key& key, Hash::Val *& value, void *info) {
           DB_Table *db_table=static_cast<DB_Table *>(value);
           Table& status_table=*static_cast<Table *>(info);
           Pool& pool=status_table.pool();
   
           Array& row=*new(pool) Array(pool);
   
           // name
           row+=&db_table->file_name();
           // time
           time_t time_stamp=db_table->get_time_used();
           const char *unsafe_time_cstr=ctime(&time_stamp);
           int time_buf_size=strlen(unsafe_time_cstr);
           char *safe_time_buf=(char *)pool.malloc(time_buf_size);
           memcpy(safe_time_buf, unsafe_time_cstr, time_buf_size);
           row+=new(pool) String(pool, safe_time_buf, time_buf_size);
           // users
           char *users_buf=(char *)pool.malloc(MAX_NUMBER);
           row+=new(pool) String(pool, 
                   users_buf, snprintf(users_buf, MAX_NUMBER, "%d", db_table->get_users_count()));
   
           status_table+=&row;
   }
   Value& DB_Connection::get_status(Pool& pool, const String *source) {
           Array& columns=*new(pool) Array(pool);
           columns+=new(pool) String(pool, "name");
           columns+=new(pool) String(pool, "time");
           columns+=new(pool) String(pool, "users");
           Table& table=*new(pool) Table(pool, 0, &columns, table_cache.size());
   
           table_cache.for_each(add_table_to_status_table, &table);
   
           return *new(pool) VTable(pool, &table);
   }
   
 #endif  #endif
Removed from v.1.18  
changed lines
  Added in v.1.36

E-mail: