cpp/src/Freeze/IndexI.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <Freeze/IndexI.h>
  11 #include <Freeze/Util.h>
  12 #include <Freeze/ObjectStore.h>
  13 #include <Freeze/EvictorI.h>
  14
  15 #include <Ice/StringConverter.h>
  16
  17 using namespace Freeze;
  18 using namespace Ice;
  19 using namespace std;
  20
  21
  22 static int
  23 callback(Db* secondary, const Dbt* key, const Dbt* value, Dbt* result)
  24 {
  25     void* indexObj = secondary->get_app_private();
  26     IndexI* index = static_cast<IndexI*>(indexObj);
  27     assert(index != 0);
  28     return index->secondaryKeyCreate(secondary, key, value, result);
  29 }
  30
  31
  32 Freeze::IndexI::IndexI(Index& index) :
  33     _index(index),
  34     _store(0)
  35 {
  36 }
  37
  38 vector<Identity>
  39 Freeze::IndexI::untypedFindFirst(const Key& bytes, Int firstN) const
  40 {
  41     DeactivateController::Guard
  42         deactivateGuard(_store->evictor()->deactivateController());
  43
  44     Dbt dbKey;
  45     initializeInDbt(bytes, dbKey);
  46     //
  47     // When we have a custom-comparison function, Berkeley DB returns
  48     // the key on-disk (when it finds one). We disable this behavior:
  49     // (ref Oracle SR 5925672.992)
  50     //
  51     dbKey.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL);
  52
  53     Key pkey(1024);
  54     Dbt pdbKey;
  55     initializeOutDbt(pkey, pdbKey);
  56
  57     Dbt dbValue;
  58     dbValue.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL);
  59
  60     Ice::CommunicatorPtr communicator = _store->communicator();
  61
  62     TransactionIPtr transaction = _store->evictor()->beforeQuery();
  63     DbTxn* tx = transaction == 0 ? 0 : transaction->dbTxn();
  64
  65     vector<Identity> identities;
  66
  67     try
  68     {
  69         for(;;)
  70         {
  71             Dbc* dbc = 0;
  72             identities.clear();
  73
  74             try
  75             {
  76                 //
  77                 // Move to the first record
  78                 //
  79                 _db->cursor(tx, &dbc, 0);
  80                 u_int32_t flags = DB_SET;
  81
  82                 bool found;
  83
  84                 do
  85                 {
  86                     for(;;)
  87                     {
  88                         try
  89                         {
  90                             //
  91                             // It is critical to set key size to key capacity before the
  92                             // get, as a resize that increases the size inserts 0
  93                             //
  94                             pkey.resize(pkey.capacity());
  95
  96                             found = (dbc->pget(&dbKey, &pdbKey, &dbValue, flags) == 0);
  97                             if(found)
  98                             {
  99                                 pkey.resize(pdbKey.get_size());
 100
 101                                 Ice::Identity ident;
 102                                 ObjectStoreBase::unmarshal(ident, pkey, communicator);
 103                                 identities.push_back(ident);
 104                                 flags = DB_NEXT_DUP;
 105                             }
 106                             break; // for(;;)
 107                         }
 108                         catch(const DbDeadlockException&)
 109                         {
 110                             throw;
 111                         }
 112                         catch(const DbException& dx)
 113                         {
 114                             handleDbException(dx, pkey, pdbKey, __FILE__, __LINE__);
 115                         }
 116                     }
 117                 }
 118                 while((firstN <= 0 || identities.size() < static_cast<size_t>(firstN)) && found);
 119
 120                 Dbc* toClose = dbc;
 121                 dbc = 0;
 122                 toClose->close();
 123                 break; // for (;;)
 124             }
 125             catch(const DbDeadlockException&)
 126             {
 127                 if(dbc != 0)
 128                 {
 129                     try
 130                     {
 131                         dbc->close();
 132                     }
 133                     catch(const DbDeadlockException&)
 134                     {
 135                         if(tx != 0)
 136                         {
 137                             throw;
 138                         }
 139                         // Else ignored
 140                     }
 141                 }
 142
 143                 if(_store->evictor()->deadlockWarning())
 144                 {
 145                     Warning out(_store->communicator()->getLogger());
 146                     out << "Deadlock in Freeze::IndexI::untypedFindFirst while searching \""
 147                         << _store->evictor()->filename() + "/" + _dbName << "\"; retrying ...";
 148                 }
 149
 150                 if(tx != 0)
 151                 {
 152                     throw;
 153                 }
 154                 // Else retry
 155             }
 156             catch(...)
 157             {
 158                 if(dbc != 0)
 159                 {
 160                     try
 161                     {
 162                         dbc->close();
 163                     }
 164                     catch(const DbDeadlockException&)
 165                     {
 166                         if(tx != 0)
 167                         {
 168                             throw;
 169                         }
 170                         // Else ignored
 171                     }
 172                 }
 173                 throw;
 174             }
 175         }
 176     }
 177     catch(const DbDeadlockException& dx)
 178     {
 179         throw DeadlockException(__FILE__, __LINE__, dx.what(), transaction);
 180     }
 181     catch(const DbException& dx)
 182     {
 183         handleDbException(dx, __FILE__, __LINE__);
 184     }
 185
 186     return identities;
 187 }
 188
 189 vector<Identity>
 190 Freeze::IndexI::untypedFind(const Key& bytes) const
 191 {
 192     return untypedFindFirst(bytes, 0);
 193 }
 194
 195 Int
 196 Freeze::IndexI::untypedCount(const Key& bytes) const
 197 {
 198     DeactivateController::Guard
 199         deactivateGuard(_store->evictor()->deactivateController());
 200
 201     Dbt dbKey;
 202     initializeInDbt(bytes, dbKey);
 203     //
 204     // When we have a custom-comparison function, Berkeley DB returns
 205     // the key on-disk (when it finds one). We disable this behavior:
 206     // (ref Oracle SR 5925672.992)
 207     //
 208     dbKey.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL);
 209
 210     Dbt dbValue;
 211     dbValue.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL);
 212
 213     TransactionIPtr transaction = _store->evictor()->beforeQuery();
 214     DbTxn* tx = transaction == 0 ? 0 : transaction->dbTxn();
 215
 216     Int result = 0;
 217
 218     try
 219     {
 220         for(;;)
 221         {
 222             Dbc* dbc = 0;
 223
 224             try
 225             {
 226                 //
 227                 // Move to the first record
 228                 //
 229                 _db->cursor(tx, &dbc, 0);
 230                 bool found = (dbc->get(&dbKey, &dbValue, DB_SET) == 0);
 231
 232                 if(found)
 233                 {
 234                     db_recno_t count = 0;
 235                     dbc->count(&count, 0);
 236                     result = static_cast<Int>(count);
 237                 }
 238
 239                 Dbc* toClose = dbc;
 240                 dbc = 0;
 241                 toClose->close();
 242                 break; // for (;;)
 243             }
 244             catch(const DbDeadlockException&)
 245             {
 246                 if(dbc != 0)
 247                 {
 248                     try
 249                     {
 250                         dbc->close();
 251                     }
 252                     catch(const DbDeadlockException&)
 253                     {
 254                         if(tx != 0)
 255                         {
 256                             throw;
 257                         }
 258                         // Else ignored
 259                     }
 260                 }
 261
 262                 if(_store->evictor()->deadlockWarning())
 263                 {
 264                     Warning out(_store->communicator()->getLogger());
 265                     out << "Deadlock in Freeze::IndexI::untypedCount while searching \""
 266                         << _store->evictor()->filename() + "/" + _dbName << "\"; retrying ...";
 267                 }
 268
 269                 if(tx != 0)
 270                 {
 271                     throw;
 272                 }
 273                 // Else retry
 274
 275             }
 276             catch(...)
 277             {
 278                 if(dbc != 0)
 279                 {
 280                     try
 281                     {
 282                         dbc->close();
 283                     }
 284                     catch(const DbDeadlockException&)
 285                     {
 286                         if(tx != 0)
 287                         {
 288                             throw;
 289                         }
 290                         // Else ignored
 291                     }
 292                 }
 293                 throw;
 294             }
 295         }
 296     }
 297     catch(const DbDeadlockException& dx)
 298     {
 299         throw DeadlockException(__FILE__, __LINE__, dx.what(), transaction);
 300     }
 301     catch(const DbException& dx)
 302     {
 303         DatabaseException ex(__FILE__, __LINE__);
 304         ex.message = dx.what();
 305         throw ex;
 306     }
 307
 308     return result;
 309 }
 310
 311 void
 312 Freeze::IndexI::associate(ObjectStoreBase* store, DbTxn* txn,
 313                           bool createDb, bool populateIndex)
 314 {
 315     assert(txn != 0);
 316     _store = store;
 317     _index._communicator = store->communicator();
 318
 319     _db.reset(new Db(store->evictor()->dbEnv()->getEnv(), 0));
 320     _db->set_flags(DB_DUP | DB_DUPSORT);
 321     _db->set_app_private(this);
 322
 323     _dbName = EvictorIBase::indexPrefix + store->dbName() + "." + _index.name();
 324
 325     Ice::PropertiesPtr properties = store->communicator()->getProperties();
 326     string propPrefix = "Freeze.Evictor." + store->evictor()->filename() + ".";
 327
 328     int btreeMinKey = properties->getPropertyAsInt(propPrefix + _dbName + ".BtreeMinKey");
 329     if(btreeMinKey > 2)
 330     {
 331         if(store->evictor()->trace() >= 1)
 332         {
 333             Trace out(store->evictor()->communicator()->getLogger(), "Freeze.Evictor");
 334             out << "Setting \"" << store->evictor()->filename() + "." + _dbName << "\"'s btree minkey to " << btreeMinKey;
 335         }
 336         _db->set_bt_minkey(btreeMinKey);
 337     }
 338
 339     bool checksum = properties->getPropertyAsInt(propPrefix + "Checksum") > 0;
 340     if(checksum)
 341     {
 342         //
 343         // No tracing on purpose
 344         //
 345
 346         _db->set_flags(DB_CHKSUM);
 347     }
 348
 349     //
 350     // pagesize can't change
 351     //
 352
 353     u_int32_t flags = 0;
 354     if(createDb)
 355     {
 356         flags = DB_CREATE;
 357     }
 358
 359     //
 360     // We keep _dbName as a native string here, while it might have
 361     // been better to convert it to UTF-8, changing this isn't
 362     // possible without potentially breaking backward compatibility
 363     // with deployed databases.
 364     //
 365     _db->open(txn, Ice::nativeToUTF8(store->communicator(), store->evictor()->filename()).c_str(), _dbName.c_str(),
 366               DB_BTREE, flags, FREEZE_DB_MODE);
 367
 368     flags = 0;
 369     if(populateIndex)
 370     {
 371         flags = DB_CREATE;
 372     }
 373     store->db()->associate(txn, _db.get(), callback, flags);
 374 }
 375
 376 int
 377 Freeze::IndexI::secondaryKeyCreate(Db* secondary, const Dbt* dbKey,
 378                                    const Dbt* dbValue, Dbt* result)
 379 {
 380     Ice::CommunicatorPtr communicator = _store->communicator();
 381
 382     ObjectRecord rec;
 383     Byte* first = static_cast<Byte*>(dbValue->get_data());
 384     Value value(first, first + dbValue->get_size());
 385     ObjectStoreBase::unmarshal(rec, value, communicator);
 386
 387     Key bytes;
 388     if(_index.marshalKey(rec.servant, bytes))
 389     {
 390         result->set_flags(DB_DBT_APPMALLOC);
 391         void* data = malloc(bytes.size());
 392         memcpy(data, &bytes[0], bytes.size());
 393         result->set_data(data);
 394         result->set_size(static_cast<u_int32_t>(bytes.size()));
 395         return 0;
 396     }
 397     else
 398     {
 399         //
 400         // Don't want to index this one
 401         //
 402         return DB_DONOTINDEX;
 403     }
 404 }
 405
 406 void
 407 Freeze::IndexI::close()
 408 {
 409     if(_db.get() != 0)
 410     {
 411         try
 412         {
 413             _db->close(0);
 414         }
 415         catch(const DbException& dx)
 416         {
 417             throw DatabaseException(__FILE__, __LINE__, dx.what());
 418         }
 419         _db.reset(0);
 420     }
 421 }