Esempio n. 1
0
 OSS_INLINE BOOLEAN operator<(const _monStorageUnit &r) const
 {
    SINT32 rc = ossStrncmp( _name, r._name, sizeof(_name))<0 ;
    if ( !rc )
       return _sequence < r._sequence ;
    return rc ;
 }
Esempio n. 2
0
 INT32 _qgmOptiNLJoin::handleHints( QGM_HINS &hints )
 {
    PD_TRACE_ENTRY( SDB__QGMOPTINLJOIN_HANDLEHINTS ) ;
    INT32 rc = SDB_OK ;
    if ( SQL_GRAMMAR::INNERJOIN != _joinType)
    {
       goto done ;
    }
    {
    QGM_HINS::iterator itr = hints.begin() ;
    for ( ; itr != hints.end(); itr++ )
    {
       if ( 0 == ossStrncmp( itr->value.begin(),
                             QGM_HINT_HASHJOIN,
                             itr->value.size() ))
       {
          if ( NULL != _condition &&
               SQL_GRAMMAR::EG == _condition->type )
          {
             SDB_ASSERT( NULL != _condition->left &&
                         NULL != _condition->right, "impossible") ;
             if ( SQL_GRAMMAR::DBATTR == _condition->left->type &&
                  SQL_GRAMMAR::DBATTR == _condition->right->type )
             {
                qgmHint hint = *itr ;
                _hints.push_back( hint ) ;
             }
          }
       }
    }
    }
 done:
    PD_TRACE_EXITRC( SDB__QGMOPTINLJOIN_HANDLEHINTS, rc ) ;
    return rc ;
 }
Esempio n. 3
0
int main ( int argc, char **argv )
{
   INT32 rc = SDB_OK ;
   OSSNPIPE handle ;
   if ( argc != 2 )
   {
      printf ( "Syntax: %s <pipe name>"OSS_NEWLINE,
               argv[0] ) ;
      return 0 ;
   }
   CHAR *pPipeName = argv[1] ;
   ossPrintf ( "Open named pipe: %s"OSS_NEWLINE, pPipeName ) ;
   rc = ossOpenNamedPipe ( pPipeName, OSS_NPIPE_DUPLEX | OSS_NPIPE_BLOCK,
                           OSS_NPIPE_INFINITE_TIMEOUT,
                           handle ) ;
   if ( rc && SDB_FE != rc )
   {
      PD_LOG ( PDERROR, "Failed to create named pipe: %s, rc %d"OSS_NEWLINE,
               pPipeName, rc ) ;
      goto open_error ;
   }

   ossPrintf ( "Write to named pipe: %s"OSS_NEWLINE, pPipeName ) ;
   while ( TRUE )
   {
      rc = readInput ( "Input", 1 ) ;
      if ( rc )
      {
         PD_LOG ( PDERROR, "Failed to read from command line" ) ;
         goto error ;
      }
      rc = ossWriteNamedPipe ( handle, receiveBuffer,
                               ossStrlen ( receiveBuffer ) + 1,
                               NULL ) ;
      if ( rc )
      {
         PD_LOG ( PDERROR, "Failed to read packet size"OSS_NEWLINE ) ;
         goto error ;
      }
      if ( ossStrncmp ( receiveBuffer, EXIT_CODE, sizeof(EXIT_CODE) ) == 0 )
         break ;
   }
error :
   rc = ossCloseNamedPipe ( handle ) ;
   if ( rc )
   {
      PD_LOG ( PDERROR, "Failed to close named pipe"OSS_NEWLINE ) ;
      goto open_error ;
   }
open_error :
   return rc ;
}
Esempio n. 4
0
   BSONObj qgmUseIndexHintToBson( const qgmHint &h )
   {
      BSONObjBuilder builder ;
      qgmField f ;
      if ( 1 == h.param.size() )
      {
         f = h.param.at( 0 ).value.attr() ;
      }
      else if ( 2 == h.param.size() )
      {
         f = h.param.at( 1 ).value.attr() ;
      }
      else
      {
         goto done ;
      }

      if ( 0 == ossStrncmp( f.begin(),
                            "null",
                            f.size() ) ||
           0 == ossStrncmp( f.begin(),
                            "NULL",
                            f.size() ) )
      {
         builder.appendNull("") ;
      }
      else
      {
         builder.appendStrWithNoTerminating( "",
                                             f.begin(),
                                             f.size() ) ;
      }

   done:
      return builder.obj() ;
   }
Esempio n. 5
0
 INT32 _omaTaskMgr::removeTask ( const CHAR *pTaskName )
 {
    INT32 rc = SDB_OK ;
    std::map<INT64, _omaTask*>::iterator it = _taskMap.begin() ;
    PD_LOG( PDDEBUG, "There are [%d] task kept in task manager, "
            "the removing task is[%s]", _taskMap.size(), pTaskName ) ;
    for ( ; it != _taskMap.end(); it++ )
    {
       _omaTask *pTask = it->second ;
       const CHAR *name = pTask->getTaskName() ;
       PD_LOG ( PDDEBUG, "The task is [%s]", name ) ;
       if ( 0 == ossStrncmp( name, pTaskName, ossStrlen(pTaskName) ) )
       {
          rc = removeTask( pTask ) ;
          break ;
       }
    }
    return rc ;
 }
Esempio n. 6
0
INT32 _qgmOptiNLJoin::_handleHints( _qgmOptiTreeNode *sub,
                                    const QGM_HINS &hint )
{
    INT32 rc = SDB_OK ;
    QGM_HINS copy ;
    const qgmField &alias = sub->getAlias() ;
    QGM_HINS::const_iterator itr = hint.begin() ;
    for ( ; itr != hint.end(); itr++ )
    {
        if ( 0 == ossStrncmp( itr->value.begin(),
                              QGM_HINT_USEINDEX,
                              itr->value.size() ) &&
                2 == itr->param.size() )
        {
            const qgmField &tName = itr->param.begin()->value.attr() ;
            if ( alias == tName )
            {
                copy.push_back( *itr ) ;
                break ;
            }
        }
    }

    if ( copy.empty() )
    {
        goto done ;
    }

    rc = sub->handleHints( copy ) ;
    if ( SDB_OK != rc )
    {
        PD_LOG( PDERROR, "failed to handle hint in sub node:%d", rc ) ;
        goto error ;
    }
done:
    return rc ;
error:
    goto done ;
}
Esempio n. 7
0
 BOOLEAN qgmUtilSame( const CHAR *src, UINT32 srcLen,
                      const CHAR *dst, UINT32 dstLen )
 {
    return srcLen == dstLen ?
           SDB_OK == ossStrncmp( src, dst, srcLen ) : FALSE ;
 }
Esempio n. 8
0
INT32 _qgmOptiNLJoin::handleHints( QGM_HINS &hints )
{
    PD_TRACE_ENTRY( SDB__QGMOPTINLJOIN_HANDLEHINTS ) ;
    INT32 rc = SDB_OK ;
    if ( SQL_GRAMMAR::INNERJOIN != _joinType)
    {
        goto done ;
    }
    {
        QGM_HINS::iterator itr = hints.begin() ;
        for ( ; itr != hints.end(); itr++ )
        {
            if ( 0 == ossStrncmp( itr->value.begin(),
                                  QGM_HINT_HASHJOIN,
                                  itr->value.size() ))
            {
                if ( NULL != _condition &&
                        SQL_GRAMMAR::EG == _condition->type )
                {
                    SDB_ASSERT( NULL != _condition->left &&
                                NULL != _condition->right, "impossible") ;
                    if ( SQL_GRAMMAR::DBATTR == _condition->left->type &&
                            SQL_GRAMMAR::DBATTR == _condition->right->type )
                    {
                        qgmHint hint = *itr ;
                        _hints.push_back( hint ) ;
                    }
                }
            }
        }
    }

    if ( 2 != _children.size() )
    {
        goto done ;
    }

    if ( QGM_OPTI_TYPE_SCAN == _children[0]->getType() )
    {
        rc = _handleHints( _children[0], hints ) ;
        if ( SDB_OK != rc )
        {
            PD_LOG( PDERROR, "sub node failed to handle hint:%d", rc ) ;
            goto error ;
        }
    }

    if ( QGM_OPTI_TYPE_SCAN == _children[1]->getType() )
    {
        rc = _handleHints( _children[1], hints ) ;
        if ( SDB_OK != rc )
        {
            PD_LOG( PDERROR, "sub node failed to handle hint:%d", rc ) ;
            goto error ;
        }
    }
done:
    PD_TRACE_EXITRC( SDB__QGMOPTINLJOIN_HANDLEHINTS, rc ) ;
    return rc ;
error:
    goto done ;
}
Esempio n. 9
0
   INT32 restAdaptor::appendHttpHeader( pmdRestSession *pSession,
                                        const CHAR *pKey,
                                        const CHAR *pValue )
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY( SDB__RESTADP_APPENDHEADER ) ;
      SDB_ASSERT ( pSession, "pSession is NULL" ) ;
      INT32 keySize = ossStrlen( pKey ) ;
      INT32 valueSize = ossStrlen( pValue ) ;
      INT32 newHeaderSize = keySize + valueSize + 2 ;
      INT32 tempSize = 0 ;
      CHAR *pNewHeaderBuf = NULL ;
      CHAR *pNewKey = NULL ;
      CHAR *pNewValue = NULL ;
      httpConnection *pHttpCon = pSession->getRestConn() ;
      COLNAME_MAP_IT it ;

      if( REST_STRING_TRANSFER_SIZE == ossStrlen( pKey ) && 
          0 == ossStrncmp( pKey, REST_STRING_TRANSFER,
                           REST_STRING_TRANSFER_SIZE ) &&
          REST_STRING_CHUNKED_SIZE == ossStrlen( pValue ) &&
          0 == ossStrncmp( pValue, REST_STRING_CHUNKED,
                           REST_STRING_CHUNKED_SIZE ) )
      {
         pHttpCon->_isChunk = TRUE ;
      }

      it = pHttpCon->_responseHeaders.find( pKey ) ;
      if ( it == pHttpCon->_responseHeaders.end() )
      {
         rc = pSession->allocBuff( newHeaderSize, &pNewHeaderBuf, tempSize ) ;
         if ( rc )
         {
            PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
                     newHeaderSize, rc ) ;
            goto error ;
         }

         pNewKey = pNewHeaderBuf ;
         pNewValue = pNewHeaderBuf + keySize + 1 ;
         ossStrncpy( pNewKey, pKey, keySize ) ;
         ossStrncpy( pNewValue, pValue, valueSize ) ;
         pNewKey[ keySize ] = 0 ;
         pNewValue[ valueSize ] = 0 ;
         pHttpCon->_responseHeaders.insert(
               std::make_pair( pNewKey, pNewValue ) ) ;
      }
      else
      {
         rc = pSession->allocBuff( valueSize + 1, &pNewValue, tempSize ) ;
         if ( rc )
         {
            PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
                     valueSize, rc ) ;
            goto error ;
         }
         ossStrncpy( pNewValue, pValue, valueSize ) ;
         pNewValue[ valueSize ] = 0 ;
         it->second = pNewValue ;
      }

   done:
      PD_TRACE_EXITRC( SDB__RESTADP_APPENDHEADER, rc ) ;
      return rc ;
   error:
      goto done ;
   }
Esempio n. 10
0
static INT32 _ossEnumFiles( const string &dirPath,
                            map<string, string> &mapFiles,
                            const CHAR *filter, UINT32 filterLen,
                            OSS_MATCH_TYPE type, UINT32 deep )
{
   INT32 rc = SDB_OK ;
   const CHAR *pFind = NULL ;

   try
   {
      fs::path dbDir ( dirPath ) ;
      fs::directory_iterator end_iter ;

      if ( 0 == deep )
      {
         goto done ;
      }

      if ( fs::exists ( dbDir ) && fs::is_directory ( dbDir ) )
      {
         for ( fs::directory_iterator dir_iter ( dbDir );
               dir_iter != end_iter; ++dir_iter )
         {
            try
            {
               if ( fs::is_regular_file ( dir_iter->status() ) )
               {
                  const std::string fileName =
                     dir_iter->path().filename().string() ;

                  if ( ( OSS_MATCH_NULL == type ) ||
                       ( OSS_MATCH_LEFT == type &&
                         0 == ossStrncmp( fileName.c_str(), filter,
                                          filterLen ) ) ||
                       ( OSS_MATCH_MID == type &&
                         ossStrstr( fileName.c_str(), filter ) ) ||
                       ( OSS_MATCH_RIGHT == type &&
                         ( pFind = ossStrstr( fileName.c_str(), filter ) ) &&
                         pFind[filterLen] == 0 ) ||
                       ( OSS_MATCH_ALL == type &&
                         0 == ossStrcmp( fileName.c_str(), filter ) )
                     )
                  {
                     mapFiles[ fileName ] = dir_iter->path().string() ;
                  }
               }
               else if ( fs::is_directory( dir_iter->path() ) && deep > 1 )
               {
                  _ossEnumFiles( dir_iter->path().string(), mapFiles,
                                 filter, filterLen, type, deep - 1 ) ;
               }
            }
            catch( std::exception &e )
            {
               PD_LOG( PDWARNING, "File or dir[%s] occur exception: %s",
                       dir_iter->path().string().c_str(),
                       e.what() ) ;
            }
         }
      }
      else
      {
         rc = SDB_INVALIDARG ;
         goto error ;
      }
   }
   catch( std::exception &e )
   {
      PD_LOG( PDERROR, "Occur exception: %s", e.what() ) ;
      rc = SDB_SYS ;
      goto error ;
   }

done:
   return rc ;
error:
   goto done ;
}
Esempio n. 11
0
   // PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLOGFILE__RESTRORE, "_dpsLogFile::_restore" )
   INT32 _dpsLogFile::_restore ()
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY ( SDB__DPSLOGFILE__RESTRORE );
      INT64 fileSize = 0 ;
      UINT64 offSet = 0 ;
      UINT64 baseOffset = 0 ;
      dpsLogRecordHeader lsnHeader ;
      CHAR *lastRecord = NULL ;
      UINT64 lastOffset = 0 ;
      UINT32 lastLen = 0 ;

      _inRestore = TRUE ;

      //Judge the length is right
      rc = ossGetFileSize( _file, &fileSize ) ;
      if ( SDB_OK != rc )
      {
         goto error ;
      }

      if ( fileSize < (INT64)( _fileSize + sizeof(dpsLogHeader) ) )
      {
         PD_LOG ( PDERROR, "DPS file size[%d] is smaller than config[%d]",
                  fileSize - sizeof(dpsLogHeader), _fileSize ) ;
         rc = SDB_DPS_FILE_SIZE_NOT_SAME ;
         goto error ;
      }

      //Init header
      rc = _readHeader() ;
      if ( SDB_OK != rc )
      {
         PD_LOG ( PDERROR, "Fail to read dps file header[rc:%d]", rc ) ;
         goto error ;
      }

      // check header info
      if ( ossStrncmp( _logHeader._eyeCatcher, DPS_LOG_HEADER_EYECATCHER,
                       sizeof( _logHeader._eyeCatcher ) ) != 0 )
      {
         PD_LOG( PDERROR, "DPS file eye catcher error" ) ;
         rc = SDB_DPS_FILE_NOT_RECOGNISE ;
         goto error ;
      }
      else if ( _logHeader._fileSize != 0 &&
                _logHeader._fileSize != _fileSize )
      {
         PD_LOG( PDERROR, "DPS file's meta size[%d] is not the same with "
                 "config[%d]", _logHeader._fileSize, _fileSize ) ;
         rc = SDB_DPS_FILE_SIZE_NOT_SAME ;
         goto error ;
      }
      else if ( _logHeader._fileNum != 0 &&
                _logHeader._fileNum != _fileNum )
      {
         PD_LOG( PDERROR, "DPS file's meta file num[%d] is not the same with "
                 "config[%d]", _logHeader._fileNum, _fileNum ) ;
         rc = SDB_INVALIDARG ;
         goto error ;
      }

      // check the real size
      if ( fileSize > (INT64)( _fileSize + sizeof(dpsLogHeader) ) )
      {
         PD_LOG( PDERROR, "DPS file real size[%d] is not the same with "
                 "config[%d]", fileSize - sizeof(dpsLogHeader),
                 _fileSize ) ;
         // start up from crash
         if ( !pmdGetStartup().isOK() )
         {
            rc = ossTruncateFile( _file, _fileSize + sizeof(dpsLogHeader) ) ;
            if ( rc )
            {
               PD_LOG( PDWARNING, "Tuncate dps file to config size failed, "
                       "rc: %d", rc ) ;
               goto error ;
            }
            PD_LOG( PDEVENT, "Tuncate dps file to config size[%d]",
                    _fileSize ) ;
         }
         else
         {
            goto error ;
         }
      }

      PD_LOG ( PDEVENT, "Header info[first lsn:%d.%lld, logID:%d]",
               _logHeader._firstLSN.version, _logHeader._firstLSN.offset,
               _logHeader._logID ) ;

      // upgrade the header
      if ( _logHeader._version != DPS_LOG_FILE_VERSION1 )
      {
         _logHeader._version = DPS_LOG_FILE_VERSION1 ;
         _logHeader._fileSize = _fileSize ;
         _logHeader._fileNum  = _fileNum ;

         rc = _flushHeader() ;
         PD_RC_CHECK( rc, PDERROR, "Failed to flush header, rc: %d", rc ) ;
      }

      if ( _logHeader._logID == DPS_INVALID_LOG_FILE_ID ||
           _logHeader._firstLSN.invalid() )
      {
         _logHeader._firstLSN.version = DPS_INVALID_LSN_VERSION ;
         _logHeader._firstLSN.offset = DPS_INVALID_LSN_OFFSET ;
         goto done ;
      }

      offSet = _logHeader._firstLSN.offset % _fileSize ;
      baseOffset = _logHeader._firstLSN.offset - offSet ;

      //analysis the file
      while ( offSet < _fileSize )
      {
         rc = read ( offSet + baseOffset , sizeof (dpsLogRecordHeader),
                     (CHAR*)&lsnHeader ) ;
         if ( SDB_OK != rc )
         {
            PD_LOG ( PDERROR, "Failed to read lsn header[offset:%lld,rc:%d]",
                     offSet, rc ) ;
            goto error ;
         }

         if ( lsnHeader._lsn != offSet + baseOffset )
         {
            PD_LOG ( PDEVENT, "LSN is not the same[%lld!=%lld]",
                     lsnHeader._lsn, offSet + baseOffset ) ;
            break ;
         }
         else if ( offSet + lsnHeader._length > _fileSize )
         {
            PD_LOG ( PDEVENT, "LSN length[%d] is over the file "
                     "size[offSet:%lld]", lsnHeader._length, offSet ) ;
            break ;
         }
         else if ( lsnHeader._length < sizeof (dpsLogRecordHeader) )
         {
            PD_LOG ( PDEVENT, "LSN length[%d] less than min[%d], invalid LSN",
                     lsnHeader._length, sizeof (dpsLogRecordHeader) ) ;
            break ;
         }

         offSet += lsnHeader._length ;
         lastOffset = offSet ;
         lastLen = lsnHeader._length ;
      }

      /// ensure that the last record is valid.
      if ( 0 < lastLen && 0 < lastOffset )
      {
         _dpsLogRecord lr ;
         lastRecord = ( CHAR * )SDB_OSS_MALLOC( lastLen ) ;
         if ( NULL == lastRecord )
         {
            PD_LOG( PDERROR, "failed to allocate mem.") ;
            rc = SDB_OOM ;
            goto error ;
         }

         rc = read( lastOffset + baseOffset - lastLen,
                    lastLen,
                    lastRecord ) ;
         if ( SDB_OK != rc )
         {
            PD_LOG( PDERROR, "failed to read dps record[%lld, rc:%d]",
                    offSet, rc ) ;
            goto error ;
         }

         rc = lr.load( lastRecord ) ;
         if ( SDB_DPS_CORRUPTED_LOG == rc )
         {
            /// the last record is corrupted. move to pre one.
            offSet -= lastLen ;
            rc = SDB_OK ;
            const dpsLogRecordHeader *corruptedHeader =
                           ( const dpsLogRecordHeader * )lastRecord ;
            PD_LOG( PDEVENT, "last log record(lsn:%lld) is corrupted.",
                    corruptedHeader->_lsn ) ;

            /// only one corrupted log in this file.
            if ( 0 == offSet )
            {
               _logHeader._firstLSN.offset = DPS_INVALID_LSN_OFFSET ;
               _logHeader._firstLSN.version = DPS_INVALID_LSN_VERSION ;
            }
         }
         else if ( SDB_OK != rc )
         {
            PD_LOG( PDERROR, "failed to load record log:%d", rc ) ;
            goto error ;
         }
      }

      _idleSize = _fileSize - offSet ;

   done:
      _inRestore = FALSE ;
      SAFE_OSS_FREE( lastRecord ) ;
      PD_TRACE_EXITRC ( SDB__DPSLOGFILE__RESTRORE, rc );
      return rc ;
   error:
      goto done ;
   }
Esempio n. 12
0
   // PD_TRACE_DECLARE_FUNCTION ( SDB_RTNREBUILDDB, "rtnRebuildDB" )
   INT32 rtnRebuildDB ( pmdEDUCB *cb )
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY ( SDB_RTNREBUILDDB ) ;

      pmdKRCB *krcb = pmdGetKRCB () ;
      SDB_DMSCB *dmsCB = krcb->getDMSCB () ;
      SDB_RTNCB *rtnCB = krcb->getRTNCB () ;
      BSONObj dummyObj ;
      std::set<monCollectionSpace> csList ;
      std::set<monCollectionSpace>::iterator it ;
      BOOLEAN registeredRebuild = FALSE ;

      PD_LOG ( PDEVENT, "Start rebuilding database" ) ;

      rc = dmsCB->registerRebuild () ;
      if ( rc )
      {
         PD_LOG ( PDERROR, "Failed to register rebuild" ) ;
         goto error ;
      }
      registeredRebuild = TRUE ;

      dmsCB->dumpInfo ( csList, TRUE ) ;

      for ( it = csList.begin(); it != csList.end(); ++it )
      {
         const CHAR *pCSName = (*it)._name ;
         std::set<monCollection> clList ;
         std::set<monCollection>::iterator itCollection ;
         dmsStorageUnitID suID ;
         if ( ossStrlen ( pCSName ) > DMS_COLLECTION_SPACE_NAME_SZ )
         {
            PD_LOG ( PDERROR, "collection space name is not valid: %s",
                     pCSName ) ;
            continue ;
         }
         if ( ossStrncmp ( pCSName, SDB_DMSTEMP_NAME,
                           DMS_COLLECTION_SPACE_NAME_SZ ) == 0 )
         {
            continue ;
         }
         PD_LOG ( PDEVENT, "Start rebuilding collection space %s", pCSName ) ;
         dmsStorageUnit *su = NULL;
         rc = dmsCB->nameToSUAndLock ( pCSName, suID, &su ) ;
         if ( rc != SDB_OK )
         {
            PD_LOG ( PDERROR, "Failed to lock collection space %s", pCSName ) ;
            continue ;
         }

         do
         {
            su->dumpInfo ( clList ) ;
            for ( itCollection = clList.begin();
                  itCollection != clList.end();
                  ++itCollection )
            {
               dmsMBContext *mbContext = NULL ;
               UINT16 collectionFlag ;
               const CHAR *pCLNameTemp = NULL ;
               const CHAR *pCLName = (*itCollection)._name ;

               if ( ( ossStrlen ( pCLName ) > DMS_COLLECTION_FULL_NAME_SZ ) ||
                    ( NULL == ( pCLNameTemp = ossStrrchr ( pCLName, '.' ))) )
               {
                  PD_LOG ( PDERROR, "collection name is not valid: %s",
                           pCLName ) ;
                  continue ;
               }
               rc = su->data()->getMBContext( &mbContext, pCLNameTemp+1,
                                              EXCLUSIVE ) ;
               if ( rc )
               {
                  PD_LOG ( PDWARNING, "Failed to lock collection %s, rc = %d",
                           pCLName, rc ) ;
                  continue ;
               }
               collectionFlag = mbContext->mb()->_flag ;
               su->data()->releaseMBContext( mbContext ) ;

               PD_LOG ( PDEVENT, "Start rebuilding collection %s", pCLName ) ;

               if ( DMS_IS_MB_OFFLINE_REORG( collectionFlag ) ||
                    DMS_IS_MB_ONLINE_REORG ( collectionFlag ) )
               {
                  rc = rtnReorgRecover ( pCLName, cb, dmsCB, rtnCB ) ;
                  if ( rc )
                  {
                     PD_LOG ( PDERROR, "Failed to perform reorg recover: %s, "
                              "rc = %d", pCLName, rc ) ;
                     continue ;
                  }
               }
               else
               {
                  rc = rtnReorgOffline ( pCLName, dummyObj, cb,
                                         dmsCB, rtnCB, TRUE ) ;
                  if ( rc )
                  {
                     PD_LOG ( PDERROR, "Failed to perform offline reorg: %s, "
                              "rc = %d", pCLName, rc ) ;
                     continue ;
                  }
               }
               PD_LOG ( PDEVENT, "Complete rebuilding collection %s",
                        pCLName ) ;
            } // for
         } while ( 0 ) ;

         dmsCB->suUnlock ( suID ) ;
         PD_LOG ( PDEVENT, "Complete rebuilding collection space %s", pCSName ) ;
      } // end for
      PD_LOG ( PDEVENT, "Database rebuild is completed" ) ;

   done :
      if ( registeredRebuild )
      {
         dmsCB->rebuildDown () ;
      }
      PD_TRACE_EXITRC ( SDB_RTNREBUILDDB, rc ) ;
      return rc ;
   error :
      goto done ;
   }
Esempio n. 13
0
 OSS_INLINE BOOLEAN operator<(const _monCollection &r) const
 {
    return ossStrncmp( _name, r._name, sizeof(_name))<0 ;
 }