desktop/source/deployment/misc/db.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: db.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_desktop.hxx"
  33
  34 #include <db.hxx>
  35
  36 #include <rtl/alloc.h>
  37 #include <cstring>
  38 #include <errno.h>
  39
  40 namespace berkeleydbproxy {
  41
  42 //----------------------------------------------------------------------------
  43     namespace db_internal
  44     {
  45         static void raise_error(int dberr, const char * where);
  46
  47         static inline int check_error(int dberr, const char * where)
  48         {
  49             if (dberr) raise_error(dberr,where);
  50             return dberr;
  51         }
  52     }
  53
  54 //----------------------------------------------------------------------------
  55
  56 char *DbEnv::strerror(int error) {
  57     return (db_strerror(error));
  58 }
  59
  60 //----------------------------------------------------------------------------
  61
  62 Db::Db(DbEnv* pDbenv,u_int32_t flags)
  63 : m_pDBP(0)
  64 {
  65     db_internal::check_error( db_create(&m_pDBP,pDbenv ? pDbenv->m_pDBENV:0,flags),"Db::Db" );
  66 }
  67
  68
  69 Db::~Db()
  70 {
  71     if (m_pDBP)
  72     {
  73         // should not happen
  74         // TODO: add assert
  75     }
  76
  77 }
  78
  79
  80 int Db::close(u_int32_t flags)
  81 {
  82     int error = m_pDBP->close(m_pDBP,flags);
  83     m_pDBP = 0;
  84     return db_internal::check_error(error,"Db::close");
  85 }
  86
  87 int Db::open(DB_TXN *txnid,
  88              const char *file,
  89              const char *database,
  90              DBTYPE type,
  91              u_int32_t flags,
  92              int mode)
  93 {
  94     int err = m_pDBP->open(m_pDBP,txnid,file,database,type,flags,mode);
  95     return db_internal::check_error( err,"Db::open" );
  96 }
  97
  98
  99 int Db::get(DB_TXN *txnid, Dbt *key, Dbt *data, u_int32_t flags)
 100 {
 101     int err = m_pDBP->get(m_pDBP,txnid,key,data,flags);
 102
 103     // these are non-exceptional outcomes
 104     if (err != DB_NOTFOUND && err != DB_KEYEMPTY)
 105         db_internal::check_error( err,"Db::get" );
 106
 107     return err;
 108 }
 109
 110 int Db::put(DB_TXN* txnid, Dbt *key, Dbt *data, u_int32_t flags)
 111 {
 112     int err = m_pDBP->put(m_pDBP,txnid,key,data,flags);
 113
 114     if (err != DB_KEYEXIST) // this is a non-exceptional outcome
 115         db_internal::check_error( err,"Db::put" );
 116     return err;
 117 }
 118
 119 int Db::cursor(DB_TXN *txnid, Dbc **cursorp, u_int32_t flags)
 120 {
 121     DBC * dbc = 0;
 122     int error = m_pDBP->cursor(m_pDBP,txnid,&dbc,flags);
 123
 124     if (!db_internal::check_error(error,"Db::cursor"))
 125         *cursorp = new Dbc(dbc);
 126
 127     return error;
 128 }
 129
 130
 131 #define DB_INCOMPLETE           (-30999)/* Sync didn't finish. */
 132
 133 int Db::sync(u_int32_t flags)
 134 {
 135     int err;
 136     DB *db = m_pDBP;
 137
 138     if (!db) {
 139         db_internal::check_error(EINVAL,"Db::sync");
 140         return (EINVAL);
 141     }
 142     if ((err = db->sync(db, flags)) != 0 && err != DB_INCOMPLETE) {
 143         db_internal::check_error(err, "Db::sync");
 144         return (err);
 145     }
 146     return (err);
 147 }
 148
 149 int Db::del(Dbt *key, u_int32_t flags)
 150 {
 151     DB *db = m_pDBP;
 152     int err;
 153
 154     if ((err = db->del(db, 0, key, flags)) != 0) {
 155         // DB_NOTFOUND is a "normal" return, so should not be
 156         // thrown as an error
 157         //
 158         if (err != DB_NOTFOUND) {
 159             db_internal::check_error(err, "Db::del");
 160             return (err);
 161         }
 162     }
 163     return (err);
 164 }
 165
 166 //----------------------------------------------------------------------------
 167
 168 Dbc::Dbc(DBC * dbc)
 169 : m_pDBC(dbc)
 170 {
 171 }
 172
 173 Dbc::~Dbc()
 174 {
 175 }
 176
 177 int Dbc::close()
 178 {
 179     int err = m_pDBC->c_close(m_pDBC);
 180     delete this;
 181     return db_internal::check_error( err,"Dbcursor::close" );
 182 }
 183
 184 int Dbc::get(Dbt *key, Dbt *data, u_int32_t flags)
 185 {
 186     int err = m_pDBC->c_get(m_pDBC,key,data,flags);
 187
 188     // these are non-exceptional outcomes
 189     if (err != DB_NOTFOUND && err != DB_KEYEMPTY)
 190         db_internal::check_error( err, "Dbcursor::get" );
 191
 192     return err;
 193 }
 194
 195 //----------------------------------------------------------------------------
 196
 197 Dbt::Dbt()
 198 {
 199     using namespace std;
 200     DBT * thispod = this;
 201     memset(thispod, 0, sizeof *thispod);
 202 }
 203
 204
 205 Dbt::Dbt(void *data_arg, u_int32_t size_arg)
 206 {
 207     using namespace std;
 208     DBT * thispod = this;
 209     memset(thispod, 0, sizeof *thispod);
 210     this->set_data(data_arg);
 211     this->set_size(size_arg);
 212 }
 213
 214 Dbt::Dbt(const Dbt & other)
 215 {
 216     using namespace std;
 217     const DBT *otherpod = &other;
 218     DBT *thispod = this;
 219     memcpy(thispod, otherpod, sizeof *thispod);
 220 }
 221
 222 Dbt& Dbt::operator = (const Dbt & other)
 223 {
 224     if (this != &other)
 225     {
 226         using namespace std;
 227         const DBT *otherpod = &other;
 228         DBT *thispod = this;
 229         memcpy(thispod, otherpod, sizeof *thispod);
 230     }
 231     return *this;
 232 }
 233
 234 Dbt::~Dbt()
 235 {
 236 }
 237
 238 void * Dbt::get_data() const
 239 {
 240     return this->data;
 241 }
 242
 243 void Dbt::set_data(void *value)
 244 {
 245     this->data = value;
 246 }
 247
 248 u_int32_t Dbt::get_size() const
 249 {
 250     return this->size;
 251 }
 252
 253 void Dbt::set_size(u_int32_t value)
 254 {
 255     this->size = value;
 256 }
 257
 258 //----------------------------------------------------------------------------
 259 void db_internal::raise_error(int dberr, const char * where)
 260 {
 261     if (!where) where = "<unknown>";
 262
 263     const char * dberrmsg = db_strerror(dberr);
 264     if (!dberrmsg || !*dberrmsg) dberrmsg = "<unknown DB error>";
 265
 266     rtl::OString msg = where;
 267     msg += ": ";
 268     msg += dberrmsg;
 269
 270     throw DbException(msg);
 271 }
 272
 273 //----------------------------------------------------------------------------
 274 } // namespace ecomp
 275