client.hpp

Go to the documentation of this file.

/*******************************************************************************

   Copyright (C) 2011-2018 SequoiaDB Ltd.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*******************************************************************************/


#ifndef CLIENT_HPP__
#define CLIENT_HPP__
#include "core.hpp"
#include "clientDef.h"
#if defined (SDB_ENGINE) || defined (SDB_CLIENT)
#include "../bson/bson.h"
#include "../util/fromjson.hpp"
#else
#include "bson/bson.hpp"
#include "fromjson.hpp"
#endif
#include "spd.h"
#include <map>
#include <string>
#include <vector>

#define RELEASE_INNER_HANDLE( handle ) \
do                                     \
{                                      \
   if ( handle )                       \
   {                                   \
      delete handle ;                  \
      handle = NULL ;                  \
   }                                   \
} while( 0 )

#define DLLEXPORT SDB_EXPORT

#define SDB_PAGESIZE_4K           4096

#define SDB_PAGESIZE_8K           8192

#define SDB_PAGESIZE_16K          16384

#define SDB_PAGESIZE_32K          32768

#define SDB_PAGESIZE_64K          65536

#define SDB_PAGESIZE_DEFAULT      0


#define FLG_INSERT_CONTONDUP      0x00000001

#define FLG_INSERT_RETURNNUM      0x00000002

#define FLG_INSERT_REPLACEONDUP   0x00000004

#define FLG_INSERT_RETURN_OID     0x10000000

// client socket timeout value
// since client and server may not sit in the same network, we need
// to set this value bigger than engine socket timeout
// this value is in millisec
// set to 10 seconds timeout
#define SDB_CLIENT_SOCKET_TIMEOUT_DFT 10000

#define sdbReplicaNode         sdbNode

#define QUERY_FORCE_HINT                  0x00000080

#define QUERY_PARALLED                    0x00000100

#define QUERY_WITH_RETURNDATA             0x00000200

#define QUERY_PREPARE_MORE                0x00004000

#define QUERY_KEEP_SHARDINGKEY_IN_UPDATE  0x00008000

#define QUERY_FOR_UPDATE                  0x00010000


#define UPDATE_KEEP_SHARDINGKEY           QUERY_KEEP_SHARDINGKEY_IN_UPDATE

#define UPDATE_ONE                        0x00000002

#define UPDATE_RETURNNUM                  0x00000004

#define FLG_DELETE_ONE                    0x00000002

#define FLG_DELETE_RETURNNUM              0x00000004

#define SDB_INDEX_SORT_BUFFER_DEFAULT_SIZE   64

enum _SDB_LOB_OPEN_MODE
{
   SDB_LOB_CREATEONLY = 0x00000001, 
   SDB_LOB_READ       = 0x00000004, 
   SDB_LOB_WRITE      = 0x00000008, 
   SDB_LOB_SHAREREAD  = 0x00000040  
} ;
typedef enum _SDB_LOB_OPEN_MODE SDB_LOB_OPEN_MODE ;

enum _SDB_LOB_SEEK
{
   SDB_LOB_SEEK_SET = 0, 
   SDB_LOB_SEEK_CUR,     
   SDB_LOB_SEEK_END      
} ;
typedef enum _SDB_LOB_SEEK SDB_LOB_SEEK ;

namespace sdbclient
{
   const static bson::BSONObj _sdbStaticObject ;
   const static bson::OID _sdbStaticOid ;
   const static std::vector<INT32> _sdbStaticVec ;
   const static std::vector<UINT32> _sdbStaticUINT32Vec ;
   class _sdbCursor ;
   class _sdbCollection ;
   class sdb ;
   class _sdb ;
   class _ossSocket ;
   class _sdbLob ;
   class sdbLob ;

   typedef void (*ERROR_ON_REPLY_FUNC)( const CHAR *pErrorObj,
                                        UINT32 objSize,
                                        INT32 flag,
                                        const CHAR *pDescription,
                                        const CHAR *pDetail ) ;

   SDB_EXPORT void sdbSetErrorOnReplyCallback( ERROR_ON_REPLY_FUNC func ) ;

   class DLLEXPORT _sdbCursor
   {
   private :
      _sdbCursor ( const _sdbCursor& other ) ;
      _sdbCursor& operator=( const _sdbCursor& ) ;
   public :
      _sdbCursor () {}
      virtual ~_sdbCursor () {}
      virtual INT32 next          ( bson::BSONObj &obj, BOOLEAN getOwned = TRUE ) = 0 ;
      virtual INT32 current       ( bson::BSONObj &obj, BOOLEAN getOwned = TRUE ) = 0 ;
      virtual INT32 close () = 0 ;
   } ;

   class DLLEXPORT sdbCursor
   {
   private :
      sdbCursor ( const sdbCursor& other ) ;
      sdbCursor& operator=( const sdbCursor& ) ;
   public :
      _sdbCursor *pCursor ;

      sdbCursor ()
      {
         pCursor = NULL ;
      }

      ~sdbCursor ()
      {
         if ( pCursor )
         {
            delete pCursor ;
         }
      }

      INT32 next ( bson::BSONObj &obj, BOOLEAN getOwned = TRUE )
      {
         if ( !pCursor )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCursor->next ( obj, getOwned ) ;
      }

      INT32 current ( bson::BSONObj &obj, BOOLEAN getOwned = TRUE )
      {
         if ( !pCursor )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCursor->current ( obj, getOwned ) ;
      }

      INT32 close ()
      {
         if ( !pCursor )
         {
            return SDB_OK ;
         }
         return pCursor->close () ;
      }
   } ;

   class DLLEXPORT _sdbCollection
   {
   private :
      _sdbCollection ( const _sdbCollection& other ) ;
      _sdbCollection& operator=( const _sdbCollection& ) ;
   public :
      _sdbCollection () {}
      virtual ~_sdbCollection () {}
      // get the total number of records for a given condition, if the condition
      // is NULL then match all records in the collection
      virtual INT32 getCount ( SINT64 &count,
                               const bson::BSONObj &condition = _sdbStaticObject,
                               const bson::BSONObj &hint = _sdbStaticObject ) = 0 ;
      // insert a bson object into current collection
      // given:
      // object ( required )
      // returns id as the pointer pointing to _id bson element
      virtual INT32 insert ( const bson::BSONObj &obj, bson::OID *id = NULL ) = 0 ;
      virtual INT32 insert ( const bson::BSONObj &obj,
                             INT32 flags,
                             bson::BSONObj *pResult = NULL ) = 0 ;
      virtual INT32 insert ( const bson::BSONObj &obj,
                             const bson::BSONObj &hint,
                             INT32 flags,
                             bson::BSONObj *pResult = NULL ) = 0 ;
      virtual INT32 insert ( std::vector<bson::BSONObj> &objs,
                             INT32 flags = 0,
                             bson::BSONObj *pResult = NULL ) = 0 ;
      virtual INT32 insert ( std::vector<bson::BSONObj> &objs,
                             const bson::BSONObj &hint,
                             INT32 flags = 0,
                             bson::BSONObj *pResult = NULL ) = 0 ;
      virtual INT32 insert ( const bson::BSONObj objs[],
                             INT32 size,
                             INT32 flags = 0,
                             bson::BSONObj *pResult = NULL ) = 0 ;
      virtual INT32 bulkInsert ( SINT32 flags,
                                 std::vector<bson::BSONObj> &obj
                               ) = 0 ;
      // update bson object from current collection
      // given:
      // update rule ( required )
      // update condition ( optional )
      // hint ( optional )
      // flag ( optional )
      // pResult ( optional )
      virtual INT32 update ( const bson::BSONObj &rule,
                             const bson::BSONObj &condition = _sdbStaticObject,
                             const bson::BSONObj &hint      = _sdbStaticObject,
                             INT32 flag = 0,
                             bson::BSONObj *pResult = NULL
                           ) = 0 ;

      // update bson object from current collection, if there's nothing match
      // then insert an record that modified from empty BSON object
      // given:
      // update rule ( required )
      // update condition ( optional )
      // hint ( optional )
      // setOnInsert ( optional )
      // flag ( optional )
      // pResult ( optional )
      virtual INT32 upsert ( const bson::BSONObj &rule,
                             const bson::BSONObj &condition = _sdbStaticObject,
                             const bson::BSONObj &hint      = _sdbStaticObject,
                             const bson::BSONObj &setOnInsert = _sdbStaticObject,
                             INT32 flag                     = 0,
                             bson::BSONObj *pResult         = NULL
                           ) = 0 ;

      // delete bson objects from current collection
      // given:
      // delete condition ( optional )
      // hint ( optional )
      // flag ( optional )
      // pResult ( optional )
      virtual INT32 del ( const bson::BSONObj &condition = _sdbStaticObject,
                          const bson::BSONObj &hint      = _sdbStaticObject,
                          INT32 flag                     = 0,
                          bson::BSONObj *pResult         = NULL
                        ) = 0 ;

      // query objects from current collection
      // given:
      // query condition ( optional )
      // query selected def ( optional )
      // query orderby ( optional )
      // hint ( optional )
      // output: _sdbCursor ( required )
      virtual INT32 query  ( _sdbCursor **cursor,
                             const bson::BSONObj &condition = _sdbStaticObject,
                             const bson::BSONObj &selected  = _sdbStaticObject,
                             const bson::BSONObj &orderBy   = _sdbStaticObject,
                             const bson::BSONObj &hint      = _sdbStaticObject,
                             INT64 numToSkip    = 0,
                             INT64 numToReturn  = -1,
                             INT32 flags        = 0
                           ) = 0 ;

      virtual INT32 query  ( sdbCursor &cursor,
                             const bson::BSONObj &condition = _sdbStaticObject,
                             const bson::BSONObj &selected  = _sdbStaticObject,
                             const bson::BSONObj &orderBy   = _sdbStaticObject,
                             const bson::BSONObj &hint      = _sdbStaticObject,
                             INT64 numToSkip    = 0,
                             INT64 numToReturn  = -1,
                             INT32 flags        = 0
                           ) = 0 ;

      virtual INT32 queryOne( bson::BSONObj &obj,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selected  = _sdbStaticObject,
                              const bson::BSONObj &orderBy   = _sdbStaticObject,
                              const bson::BSONObj &hint      = _sdbStaticObject,
                              INT64 numToSkip    = 0,
                              INT32 flags        = 0 ) = 0 ;

      // query objects from current collection and update
      // given:
      // update rule ( required )
      // query condition ( optional )
      // query selected def ( optional )
      // query orderby ( optional )
      // hint ( optional )
      // flags( optional )
      // returnNew ( optioinal )
      // output: sdbCursor ( required )
      virtual INT32 queryAndUpdate  ( _sdbCursor **cursor,
                                      const bson::BSONObj &update,
                                      const bson::BSONObj &condition = _sdbStaticObject,
                                      const bson::BSONObj &selected  = _sdbStaticObject,
                                      const bson::BSONObj &orderBy   = _sdbStaticObject,
                                      const bson::BSONObj &hint      = _sdbStaticObject,
                                      INT64 numToSkip                = 0,
                                      INT64 numToReturn              = -1,
                                      INT32 flag                     = 0,
                                      BOOLEAN returnNew              = FALSE
                                   ) = 0 ;

      // query objects from current collection and remove
      // given:
      // query condition ( optional )
      // query selected def ( optional )
      // query orderby ( optional )
      // hint ( optional )
      // flags( optional )
      // output: sdbCursor ( required )
      virtual INT32 queryAndRemove  ( _sdbCursor **cursor,
                                      const bson::BSONObj &condition = _sdbStaticObject,
                                      const bson::BSONObj &selected  = _sdbStaticObject,
                                      const bson::BSONObj &orderBy   = _sdbStaticObject,
                                      const bson::BSONObj &hint      = _sdbStaticObject,
                                      INT64 numToSkip                = 0,
                                      INT64 numToReturn              = -1,
                                      INT32 flag                     = 0
                                   ) = 0 ;

      //virtual INT32 rename ( const CHAR *pNewName ) = 0 ;
      // create an index for the current collection
      // given:
      // index definition ( required )
      // index name ( required )
      // uniqueness ( required )
      // enforceness ( required )
      virtual INT32 createIndex ( const bson::BSONObj &indexDef,
                                  const CHAR *pName,
                                  BOOLEAN isUnique,
                                  BOOLEAN isEnforced,
                                  INT32 sortBufferSize ) = 0 ;
      virtual INT32 createIndex ( const bson::BSONObj &indexDef,
                                  const CHAR *pName,
                                  const bson::BSONObj &options ) = 0 ;
      virtual INT32 getIndexes ( _sdbCursor **cursor,
                                 const CHAR *pName ) = 0 ;
      virtual INT32 getIndexes ( sdbCursor &cursor,
                                 const CHAR *pIndexName ) = 0 ;
      virtual INT32 getIndexes ( std::vector<bson::BSONObj> &infos ) = 0 ;
      virtual INT32 getIndex ( const CHAR *pIndexName, bson::BSONObj &info ) = 0 ;
      virtual INT32 dropIndex ( const CHAR *pIndexName ) = 0 ;
      virtual INT32 create () = 0 ;
      virtual INT32 drop () = 0 ;
      virtual const CHAR *getCollectionName () = 0 ;
      virtual const CHAR *getCSName () = 0 ;
      virtual const CHAR *getFullName () = 0 ;
      virtual INT32 split ( const CHAR *pSourceGroupName,
                            const CHAR *pTargetGroupName,
                            const bson::BSONObj &splitConditon,
                            const bson::BSONObj &splitEndCondition = _sdbStaticObject) = 0 ;
      virtual INT32 split ( const CHAR *pSourceGroupName,
                            const CHAR *pTargetGroupName,
                            FLOAT64 percent ) = 0 ;
      virtual INT32 splitAsync ( SINT64 &taskID,
                            const CHAR *pSourceGroupName,
                            const CHAR *pTargetGroupName,
                            const bson::BSONObj &splitCondition,
                            const bson::BSONObj &splitEndCondition = _sdbStaticObject) = 0 ;
      virtual INT32 splitAsync ( const CHAR *pSourceGroupName,
                            const CHAR *pTargetGroupName,
                            FLOAT64 percent,
                            SINT64 &taskID ) = 0 ;
      virtual  INT32 aggregate ( _sdbCursor **cursor,
                                std::vector<bson::BSONObj> &obj
                               )  = 0 ;
      virtual  INT32 aggregate ( sdbCursor &cursor,
                                std::vector<bson::BSONObj> &obj
                               )  = 0 ;
      virtual INT32 getQueryMeta  ( _sdbCursor **cursor,
                             const bson::BSONObj &condition = _sdbStaticObject,
                             const bson::BSONObj &orderBy   = _sdbStaticObject,
                             const bson::BSONObj &hint  = _sdbStaticObject,
                             INT64 numToSkip    = 0,
                             INT64 numToReturn  = -1
                           ) = 0 ;
      virtual INT32 getQueryMeta  ( sdbCursor &cursor,
                             const bson::BSONObj &condition = _sdbStaticObject,
                             const bson::BSONObj &orderBy   = _sdbStaticObject,
                             const bson::BSONObj &hint  = _sdbStaticObject,
                             INT64 numToSkip    = 0,
                             INT64 numToReturn  = -1
                           ) = 0 ;
      virtual INT32 attachCollection ( const CHAR *subClFullName,
                                      const bson::BSONObj &options) = 0 ;
      virtual INT32 detachCollection ( const CHAR *subClFullName) = 0 ;

      virtual INT32 alterCollection ( const bson::BSONObj &options ) = 0 ;
      virtual INT32 explain ( sdbCursor &cursor,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &select    = _sdbStaticObject,
                              const bson::BSONObj &orderBy   = _sdbStaticObject,
                              const bson::BSONObj &hint      = _sdbStaticObject,
                              INT64 numToSkip                = 0,
                              INT64 numToReturn              = -1,
                              INT32 flag                     = 0,
                              const bson::BSONObj &options   = _sdbStaticObject ) = 0 ;

      virtual INT32 explain ( _sdbCursor **cursor,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &select    = _sdbStaticObject,
                              const bson::BSONObj &orderBy   = _sdbStaticObject,
                              const bson::BSONObj &hint      = _sdbStaticObject,
                              INT64 numToSkip                = 0,
                              INT64 numToReturn              = -1,
                              INT32 flag                     = 0,
                              const bson::BSONObj &options   = _sdbStaticObject ) = 0 ;
      virtual INT32 createLob( sdbLob &lob, const bson::OID *oid = NULL ) = 0 ;

      virtual INT32 removeLob( const bson::OID &oid ) = 0 ;

      virtual INT32 truncateLob( const bson::OID &oid, INT64 length ) = 0 ;

      virtual INT32 openLob( sdbLob &lob, const bson::OID &oid,
                             SDB_LOB_OPEN_MODE mode = SDB_LOB_READ ) = 0 ;

      virtual INT32 openLob( sdbLob &lob, const bson::OID &oid,
                             INT32 mode ) = 0 ;

      virtual INT32 listLobs( sdbCursor &cursor,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selected  = _sdbStaticObject,
                              const bson::BSONObj &orderBy   = _sdbStaticObject,
                              const bson::BSONObj &hint      = _sdbStaticObject,
                              INT64 numToSkip    = 0,
                              INT64 numToReturn  = -1 ) = 0 ;

      virtual INT32 listLobs( _sdbCursor **cursor,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selected  = _sdbStaticObject,
                              const bson::BSONObj &orderBy   = _sdbStaticObject,
                              const bson::BSONObj &hint      = _sdbStaticObject,
                              INT64 numToSkip    = 0,
                              INT64 numToReturn  = -1 ) = 0 ;

      virtual INT32 createLobID( bson::OID &oid, const CHAR *pTimeStamp = NULL ) = 0 ;

      virtual INT32 listLobPieces(
                              _sdbCursor **cursor,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selected  = _sdbStaticObject,
                              const bson::BSONObj &orderBy   = _sdbStaticObject,
                              const bson::BSONObj &hint      = _sdbStaticObject,
                              INT64 numToSkip    = 0,
                              INT64 numToReturn  = -1 ) = 0 ;

      virtual INT32 listLobPieces(
                              sdbCursor &cursor,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selected  = _sdbStaticObject,
                              const bson::BSONObj &orderBy   = _sdbStaticObject,
                              const bson::BSONObj &hint      = _sdbStaticObject,
                              INT64 numToSkip    = 0,
                              INT64 numToReturn  = -1 ) = 0 ;

      virtual INT32 truncate() = 0 ;

      virtual INT32 createIdIndex( const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 dropIdIndex() = 0 ;

      virtual INT32 createAutoIncrement( const bson::BSONObj &options ) = 0;

      virtual INT32 createAutoIncrement( const std::vector<bson::BSONObj> &options ) = 0;

      virtual INT32 dropAutoIncrement( const CHAR *fieldName ) = 0;

      virtual INT32 dropAutoIncrement( const std::vector<const CHAR*> &fieldNames ) = 0;

      virtual INT32 pop ( const bson::BSONObj &option = _sdbStaticObject ) = 0 ;

      virtual INT32 enableSharding ( const bson::BSONObj &options ) = 0 ;

      virtual INT32 disableSharding () = 0 ;

      virtual INT32 enableCompression ( const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 disableCompression () = 0 ;

      virtual INT32 setAttributes ( const bson::BSONObj &options ) = 0 ;

      virtual INT32 getDetail ( _sdbCursor **cursor ) = 0 ;

      virtual INT32 getDetail ( sdbCursor &cursor ) = 0 ;

      virtual INT32 getIndexStat ( const CHAR *pIndexName, bson::BSONObj &result ) = 0 ;

      virtual void setVersion( INT32 clVersion ) = 0;
      virtual INT32 getVersion() = 0;
   } ;

   class DLLEXPORT sdbCollection
   {
   private :
      sdbCollection ( const sdbCollection& other ) ;

      sdbCollection& operator=( const sdbCollection& ) ;
   public :
      _sdbCollection *pCollection ;

      sdbCollection ()
      {
         pCollection = NULL ;
      }

      ~sdbCollection ()
      {
         if ( pCollection )
         {
            delete pCollection ;
         }
      }

      INT32 getCount ( SINT64 &count,
                       const bson::BSONObj &condition = _sdbStaticObject,
                       const bson::BSONObj &hint = _sdbStaticObject )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->getCount ( count, condition, hint ) ;
      }

      INT32 split ( const CHAR *pSourceGroupName,
                    const CHAR *pTargetGroupName,
                    const bson::BSONObj &splitCondition,
                    const bson::BSONObj &splitEndCondition = _sdbStaticObject)
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->split ( pSourceGroupName,
                                     pTargetGroupName,
                                     splitCondition,
                                     splitEndCondition) ;
      }

      INT32 split ( const CHAR *pSourceGroupName,
                    const CHAR *pTargetGroupName,
                    FLOAT64 percent )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->split ( pSourceGroupName,
                                     pTargetGroupName,
                                     percent ) ;
      }

      INT32 splitAsync ( SINT64 &taskID,
                         const CHAR *pSourceGroupName,
                         const CHAR *pTargetGroupName,
                         const bson::BSONObj &splitCondition,
                         const bson::BSONObj &splitEndCondition = _sdbStaticObject )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->splitAsync ( taskID,
                                          pSourceGroupName,
                                          pTargetGroupName,
                                          splitCondition,
                                          splitEndCondition ) ;
      }

      INT32 splitAsync ( const CHAR *pSourceGroupName,
                         const CHAR *pTargetGroupName,
                         FLOAT64 percent,
                         SINT64 &taskID )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->splitAsync ( pSourceGroupName,
                                          pTargetGroupName,
                                          percent,
                                          taskID ) ;
      }

      INT32 alterCollection ( const bson::BSONObj &options )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->alterCollection ( options ) ;
      }

      INT32 insert ( const bson::BSONObj &obj, bson::OID *pId = NULL )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->insert ( obj, pId ) ;
      }

      INT32 insert ( const bson::BSONObj &obj,
                     INT32 flags,
                     bson::BSONObj *pResult = NULL )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->insert ( obj, flags, pResult ) ;
      }

      INT32 insert ( const bson::BSONObj &obj,
                     const bson::BSONObj &hint,
                     INT32 flags,
                     bson::BSONObj *pResult = NULL )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->insert ( obj, hint, flags, pResult ) ;
      }

      INT32 insert ( std::vector<bson::BSONObj> &objs,
                     INT32 flags = 0,
                     bson::BSONObj *pResult = NULL )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->insert( objs, flags, pResult ) ;
      }

      INT32 insert ( std::vector<bson::BSONObj> &objs,
                     const bson::BSONObj &hint,
                     INT32 flags = 0,
                     bson::BSONObj *pResult = NULL )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->insert( objs, hint, flags, pResult ) ;
      }

      INT32 insert ( const bson::BSONObj objs[],
                     INT32 size,
                     INT32 flags = 0,
                     bson::BSONObj *pResult = NULL )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->insert ( objs, size, flags, pResult ) ;
      }

      INT32 bulkInsert ( SINT32 flags,
                         std::vector<bson::BSONObj> &objs )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->bulkInsert ( flags, objs ) ;
      }

      INT32 update ( const bson::BSONObj &rule,
                     const bson::BSONObj &condition = _sdbStaticObject,
                     const bson::BSONObj &hint      = _sdbStaticObject,
                     INT32 flag = 0,
                     bson::BSONObj *pResult = NULL
                   )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->update ( rule, condition, hint, flag, pResult ) ;
      }

      INT32 upsert ( const bson::BSONObj &rule,
                     const bson::BSONObj &condition   = _sdbStaticObject,
                     const bson::BSONObj &hint        = _sdbStaticObject,
                     const bson::BSONObj &setOnInsert = _sdbStaticObject,
                     INT32 flag                       = 0,
                     bson::BSONObj *pResult           = NULL
                   )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->upsert ( rule, condition, hint, setOnInsert,
                                      flag, pResult ) ;
      }

      INT32 del ( const bson::BSONObj &condition = _sdbStaticObject,
                  const bson::BSONObj &hint      = _sdbStaticObject,
                  INT32 flag                     = 0,
                  bson::BSONObj *pResult         = NULL
                )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->del ( condition, hint, flag, pResult ) ;
      }

      /* \fn INT32 query  ( _sdbCursor **cursor,
                           const bson::BSONObj &condition,
                           const bson::BSONObj &selected,
                           const bson::BSONObj &orderBy,
                           const bson::BSONObj &hint,
                           INT64 numToSkip,
                           INT64 numToReturn,
                           INT32 flags
                          )
          \brief Get the matching documents in current collection
          \param [in] condition The matching rule, return all the documents if not provided
          \param [in] selected The selective rule, return the whole document if not provided
          \param [in] orderBy The ordered rule, result set is unordered if not provided
          \param [in] hint Specified the index used to scan data. e.g. {"":"ageIndex"} means
                          using index "ageIndex" to scan data(index scan);
                          {"":null} means table scan. when hint is not provided,
                          database automatically match the optimal index to scan data
          \param [in] numToSkip Skip the first numToSkip documents, default is 0
          \param [in] numToReturn Only return numToReturn documents, default is -1 for returning all results
          \param [in] flags The query flags, default to be 0. Please see the definition of follow flags for more detail. Usage: e.g. set ( QUERY_FORCE_HINT | QUERY_WITH_RETURNDATA ) to param flags
          \code
              QUERY_FORCE_HINT
              QUERY_PARALLED
              QUERY_WITH_RETURNDATA
              QUERY_FOR_UPDATE
          \endcode
          \param [out] cursor The cursor of current query
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 query  ( _sdbCursor **cursor,
                     const bson::BSONObj &condition = _sdbStaticObject,
                     const bson::BSONObj &selected  = _sdbStaticObject,
                     const bson::BSONObj &orderBy   = _sdbStaticObject,
                     const bson::BSONObj &hint      = _sdbStaticObject,
                     INT64 numToSkip          = 0,
                     INT64 numToReturn        = -1,
                     INT32 flags              = 0
                   )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->query ( cursor, condition, selected, orderBy,
                                     hint, numToSkip, numToReturn, flags ) ;
      }

      INT32 query  ( sdbCursor &cursor,
                     const bson::BSONObj &condition = _sdbStaticObject,
                     const bson::BSONObj &selected  = _sdbStaticObject,
                     const bson::BSONObj &orderBy   = _sdbStaticObject,
                     const bson::BSONObj &hint      = _sdbStaticObject,
                     INT64 numToSkip          = 0,
                     INT64 numToReturn        = -1,
                     INT32 flags              = 0
                   )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pCollection->query ( cursor, condition, selected, orderBy,
                                     hint, numToSkip, numToReturn, flags ) ;
      }

      INT32 queryOne( bson::BSONObj &obj,
                      const bson::BSONObj &condition = _sdbStaticObject,
                      const bson::BSONObj &selected  = _sdbStaticObject,
                      const bson::BSONObj &orderBy   = _sdbStaticObject,
                      const bson::BSONObj &hint      = _sdbStaticObject,
                      INT64 numToSkip    = 0,
                      INT32 flag         = 0 )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->queryOne( obj, condition, selected, orderBy,
                                       hint, numToSkip, flag ) ;
      }

      INT32 queryAndUpdate ( sdbCursor &cursor,
                             const bson::BSONObj &update,
                             const bson::BSONObj &condition = _sdbStaticObject,
                             const bson::BSONObj &selected  = _sdbStaticObject,
                             const bson::BSONObj &orderBy   = _sdbStaticObject,
                             const bson::BSONObj &hint      = _sdbStaticObject,
                             INT64 numToSkip                = 0,
                             INT64 numToReturn              = -1,
                             INT32 flag                     = 0,
                             BOOLEAN returnNew              = FALSE
                          )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pCollection->queryAndUpdate( &cursor.pCursor , update, condition,
                                             selected, orderBy, hint,
                                             numToSkip, numToReturn, flag, returnNew ) ;
      }

      INT32 queryAndRemove ( sdbCursor &cursor,
                             const bson::BSONObj &condition = _sdbStaticObject,
                             const bson::BSONObj &selected  = _sdbStaticObject,
                             const bson::BSONObj &orderBy   = _sdbStaticObject,
                             const bson::BSONObj &hint      = _sdbStaticObject,
                             INT64 numToSkip                = 0,
                             INT64 numToReturn              = -1,
                             INT32 flag                     = 0
                          )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pCollection->queryAndRemove( &cursor.pCursor , condition,
                                             selected, orderBy, hint,
                                             numToSkip, numToReturn, flag ) ;
      }

      INT32 createIndex ( const bson::BSONObj &indexDef,
                          const CHAR *pIndexName,
                          BOOLEAN isUnique,
                          BOOLEAN isEnforced,
                          INT32 sortBufferSize =
                          SDB_INDEX_SORT_BUFFER_DEFAULT_SIZE )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->createIndex ( indexDef, pIndexName, isUnique,
                                           isEnforced, sortBufferSize ) ;
      }

      INT32 createIndex ( const bson::BSONObj &indexDef,
                          const CHAR *pIndexName,
                          const bson::BSONObj &options )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->createIndex ( indexDef, pIndexName, options ) ;
      }

      /* \fn INT32 getIndexes ( _sdbCursor **cursor,
                               const CHAR *pIndexName )
          \brief Get all of or one of the indexes in current collection
          \param [in] pIndexName  The index name, returns all of the indexes if this parameter is null
          \param [out] cursor The cursor of all the result for current query
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getIndexes ( _sdbCursor **cursor,
                         const CHAR *pIndexName )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->getIndexes ( cursor, pIndexName ) ;
      }

      INT32 getIndexes ( sdbCursor &cursor,
                         const CHAR *pIndexName )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pCollection->getIndexes ( cursor, pIndexName ) ;
      }

      INT32 getIndexes ( std::vector<bson::BSONObj> &infos )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->getIndexes ( infos ) ;
      }

      INT32 getIndex ( const CHAR *pIndexName, bson::BSONObj &info )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->getIndex ( pIndexName, info ) ;
      }

      INT32 dropIndex ( const CHAR *pIndexName )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->dropIndex ( pIndexName ) ;
      }

      INT32 create ()
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->create () ;
      }

      INT32 drop ()
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->drop () ;
      }

      const CHAR *getCollectionName ()
      {
         if ( !pCollection )
         {
            return NULL ;
         }
         return pCollection->getCollectionName () ;
      }

      const CHAR *getCSName ()
      {
         if ( !pCollection )
         {
            return NULL ;
         }
         return pCollection->getCSName () ;
      }

      const CHAR *getFullName ()
      {
         if ( !pCollection )
         {
            return NULL ;
         }
         return pCollection->getFullName () ;
      }

      /* \fn INT32 aggregate ( _sdbCursor **cursor,
                               std::vector<bson::BSONObj> &obj
                             )
          \brief Execute aggregate operation in specified collection
          \param [in] obj The array of bson objects
          \param [out] cursor The cursor handle of result
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 aggregate ( _sdbCursor **cursor,
                        std::vector<bson::BSONObj> &obj
                       )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->aggregate ( cursor, obj ) ;
      }

      INT32 aggregate ( sdbCursor &cursor,
                        std::vector<bson::BSONObj> &obj
                       )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pCollection->aggregate ( cursor, obj ) ;
      }

      /* \fn  INT32 getQueryMeta ( _sdbCursor **cursor,
                                   const bson::BSONObj &condition = _sdbStaticObject,
                                   const bson::BSONObj &selected = _sdbStaticObject,
                                   const bson::BSONObj &orderBy = _sdbStaticObject,
                                   INT64 numToSkip = 0,
                                   INT64 numToReturn = -1 ) ;
          \brief Get the index blocks' or data blocks' infomation for concurrent query
          \param [in] condition The matching rule, return all the documents if not provided
          \param [in] orderBy The ordered rule, result set is unordered if not provided
          \param [in] hint Specified the index used to scan data. e.g. {"":"ageIndex"} means
                          using index "ageIndex" to scan data(index scan);
                          {"":null} means table scan. when hint is not provided,
                          database automatically match the optimal index to scan data
          \param [in] numToSkip Skip the first numToSkip documents, default is 0
          \param [in] numToReturn Only return numToReturn documents, default is -1 for returning all results
          \param [out] cursor The cursor of current query
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getQueryMeta ( _sdbCursor **cursor,
                           const bson::BSONObj &condition = _sdbStaticObject,
                           const bson::BSONObj &orderBy = _sdbStaticObject,
                           const bson::BSONObj &hint = _sdbStaticObject,
                           INT64 numToSkip = 0,
                           INT64 numToReturn = -1 )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->getQueryMeta ( cursor, condition, orderBy,
                                            hint, numToSkip, numToReturn ) ;
      }

      INT32 getQueryMeta ( sdbCursor &cursor,
                           const bson::BSONObj &condition = _sdbStaticObject,
                           const bson::BSONObj &orderBy = _sdbStaticObject,
                           const bson::BSONObj &hint = _sdbStaticObject,
                           INT64 numToSkip = 0,
                           INT64 numToReturn = -1 )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pCollection->getQueryMeta ( cursor, condition, orderBy,
                                            hint, numToSkip, numToReturn ) ;
      }

      INT32 attachCollection ( const CHAR *subClFullName,
                               const bson::BSONObj &options)
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->attachCollection ( subClFullName, options ) ;
      }

      INT32 detachCollection ( const CHAR *subClFullName)
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->detachCollection ( subClFullName ) ;
      }

      INT32 explain ( sdbCursor &cursor,
                      const bson::BSONObj &condition = _sdbStaticObject,
                      const bson::BSONObj &select    = _sdbStaticObject,
                      const bson::BSONObj &orderBy   = _sdbStaticObject,
                      const bson::BSONObj &hint      = _sdbStaticObject,
                      INT64 numToSkip                = 0,
                      INT64 numToReturn              = -1,
                      INT32 flag                     = 0,
                      const bson::BSONObj &options   = _sdbStaticObject )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pCollection->explain( cursor, condition, select, orderBy, hint,
                                      numToSkip, numToReturn, flag, options ) ;
      }

      INT32 explain ( _sdbCursor **cursor,
                      const bson::BSONObj &condition = _sdbStaticObject,
                      const bson::BSONObj &select    = _sdbStaticObject,
                      const bson::BSONObj &orderBy   = _sdbStaticObject,
                      const bson::BSONObj &hint      = _sdbStaticObject,
                      INT64 numToSkip                = 0,
                      INT64 numToReturn              = -1,
                      INT32 flag                     = 0,
                      const bson::BSONObj &options   = _sdbStaticObject )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->explain( cursor, condition, select, orderBy, hint,
                                      numToSkip, numToReturn, flag, options ) ;
      }

      INT32 createLob( sdbLob &lob, const bson::OID *oid = NULL )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->createLob( lob, oid ) ;
      }

      INT32 removeLob( const bson::OID &oid )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->removeLob( oid ) ;
      }

      INT32 truncateLob( const bson::OID &oid, INT64 length )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->truncateLob( oid, length ) ;
      }

      INT32 openLob( sdbLob &lob, const bson::OID &oid,
                     SDB_LOB_OPEN_MODE mode = SDB_LOB_READ )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->openLob( lob, oid, mode ) ;
      }

      INT32 openLob( sdbLob &lob, const bson::OID &oid, INT32 mode )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->openLob( lob, oid, mode ) ;
      }

      INT32 listLobs( sdbCursor &cursor,
                      const bson::BSONObj &condition = _sdbStaticObject,
                      const bson::BSONObj &selected  = _sdbStaticObject,
                      const bson::BSONObj &orderBy   = _sdbStaticObject,
                      const bson::BSONObj &hint      = _sdbStaticObject,
                      INT64 numToSkip    = 0,
                      INT64 numToReturn  = -1 )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pCollection->listLobs( cursor, condition, selected, orderBy,
                                       hint, numToSkip, numToReturn ) ;
      }

      INT32 listLobs( _sdbCursor **cursor,
                      const bson::BSONObj &condition = _sdbStaticObject,
                      const bson::BSONObj &selected  = _sdbStaticObject,
                      const bson::BSONObj &orderBy   = _sdbStaticObject,
                      const bson::BSONObj &hint      = _sdbStaticObject,
                      INT64 numToSkip    = 0,
                      INT64 numToReturn  = -1 )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->listLobs( cursor, condition, selected, orderBy,
                                       hint, numToSkip, numToReturn ) ;
      }

      INT32 createLobID( bson::OID &oid, const CHAR *pTimeStamp = NULL )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->createLobID( oid, pTimeStamp ) ;
      }

      INT32 truncate()
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->truncate() ;
      }

      INT32 createIdIndex( const bson::BSONObj &options = _sdbStaticObject )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->createIdIndex( options ) ;
      }

      INT32 dropIdIndex()
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->dropIdIndex() ;
      }

      INT32 createAutoIncrement ( const bson::BSONObj &options )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->createAutoIncrement( options ) ;
      }

      INT32 createAutoIncrement ( const std::vector<bson::BSONObj> &options )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->createAutoIncrement( options ) ;
      }

      INT32 dropAutoIncrement ( const CHAR * fieldName )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->dropAutoIncrement( fieldName ) ;
      }

      INT32 dropAutoIncrement ( const std::vector<const CHAR*> &fieldNames )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->dropAutoIncrement( fieldNames ) ;
      }

      INT32 enableSharding ( const bson::BSONObj & options = _sdbStaticObject )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->enableSharding( options ) ;
      }

      INT32 disableSharding ()
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->disableSharding() ;
      }

      INT32 enableCompression ( const bson::BSONObj & options = _sdbStaticObject )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->enableCompression( options ) ;
      }

      INT32 disableCompression ()
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->disableCompression() ;
      }

      INT32 setAttributes ( const bson::BSONObj &options )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->setAttributes( options ) ;
      }

      /* \fn INT32 pop( const bson::BSONObj &option )
         \brief Pop records from a capped collection
         \param [in] option The pop options as follows:

             Direction   : The direction to pop record. 1: pop forward. -1: pop backward.
                           The default value is 1.
         \retval SDB_OK Operation Success
         \retval Others Operation Fail
      */
      INT32 pop ( const bson::BSONObj &option = _sdbStaticObject )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->pop( option ) ;
      }

      INT32 listLobPieces( _sdbCursor **cursor,
                           const bson::BSONObj &condition = _sdbStaticObject,
                           const bson::BSONObj &selected  = _sdbStaticObject,
                           const bson::BSONObj &orderBy   = _sdbStaticObject,
                           const bson::BSONObj &hint      = _sdbStaticObject,
                           INT64 numToSkip    = 0,
                           INT64 numToReturn  = -1 )
      {
         if( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->listLobPieces( cursor, condition, selected,
                                            orderBy, hint, numToSkip,
                                            numToReturn ) ;
      }

      INT32 listLobPieces( sdbCursor &cursor,
                           const bson::BSONObj &condition = _sdbStaticObject,
                           const bson::BSONObj &selected  = _sdbStaticObject,
                           const bson::BSONObj &orderBy   = _sdbStaticObject,
                           const bson::BSONObj &hint      = _sdbStaticObject,
                           INT64 numToSkip    = 0,
                           INT64 numToReturn  = -1 )
      {
         if( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pCollection->listLobPieces( cursor, condition, selected,
                                            orderBy, hint, numToSkip,
                                            numToReturn ) ;
      }

      /* \fn INT32 getDetail ( _sdbCursor **cursor )
          \brief Get the detail of the collection.
          \param [out] cursor Return the all the info of current collection.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getDetail ( _sdbCursor **cursor )
      {
         if ( !pCollection )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->getDetail ( cursor ) ;
      }

      INT32 getDetail( sdbCursor &cursor )
      {
         if ( !pCollection)
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->getDetail( cursor ) ;
      }

      /* \fn INT32 getIndexStat ( const CHAR *pIndexName, bson::BSONObj &result )
          \brief Get the statistics of the index.
          \param [in] pIndexName The name of the index.
          \param [out] result The statistics of index.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getIndexStat( const CHAR *pIndexName, bson::BSONObj &result )
      {
         if ( !pCollection)
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollection->getIndexStat( pIndexName, result ) ;
      }

          /* \fn void setVersion ( INT32 clVersion )
          \brief set version to collection.
          \param [in] clVersion The collection version.
      */
      void setVersion( INT32 clVersion )
      {
          pCollection->setVersion( clVersion ) ;
      }
      /* \fn INT32 getVersion ()
          \brief get version from collection.
          \retval collection version.
      */
      INT32 getVersion()
      {
          return pCollection->getVersion() ;
      }
   } ;

   enum sdbNodeStatus
   {
      SDB_NODE_ALL = 0,
      SDB_NODE_ACTIVE,
      SDB_NODE_INACTIVE,
      SDB_NODE_UNKNOWN
   } ;

   typedef enum sdbNodeStatus sdbNodeStatus ;

   class DLLEXPORT _sdbNode
   {
   private :
      _sdbNode ( const _sdbNode& other ) ;
      _sdbNode& operator=( const _sdbNode& ) ;
   public :
      _sdbNode () {}
      virtual ~_sdbNode () {}
      // connect to the current node
      virtual INT32 connect ( _sdb **dbConn ) = 0 ;
      virtual INT32 connect ( sdb &dbConn ) = 0 ;

      // get status of the current node
      virtual sdbNodeStatus getStatus () = 0 ;

      // get host name of the current node
      virtual const CHAR *getHostName () = 0 ;

      // get service name of the current node
      virtual const CHAR *getServiceName () = 0 ;

      // get node name of the current node
      virtual const CHAR *getNodeName () = 0 ;

      // get node id of the current node
      virtual INT32 getNodeID( INT32 &nodeID ) const = 0 ;

      // stop the node
      virtual INT32 stop () = 0 ;

      // start the node
      virtual INT32 start () = 0 ;

      // modify config for the current node
/*      virtual INT32 modifyConfig ( std::map<std::string,std::string>
                                   &config ) = 0 ; */
   } ;

   class DLLEXPORT sdbNode
   {
   private :
      sdbNode ( const sdbNode& other ) ;

      sdbNode& operator=( const sdbNode& ) ;
   public :
      _sdbNode *pNode ;

      sdbNode ()
      {
         pNode = NULL ;
      }

      ~sdbNode ()
      {
         if ( pNode )
         {
            delete pNode ;
         }
      }
      /* \fn connect ( _sdb **dbConn )
          \brief Connect to the current node.
          \param [out] dbConn The database obj of current connection
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 connect ( _sdb **dbConn )
      {
         if ( !pNode )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pNode->connect ( dbConn ) ;
      }

      INT32 connect ( sdb &dbConn )
      {
         if ( !pNode )
         {
            return SDB_NOT_CONNECTED ;
         }
         // we can not use dbConn.pSDB here,
         // for sdb had not define yet.
         // RELEASE_INNER_HANDLE( dbConn.pSDB ) ;
         return pNode->connect ( dbConn ) ;
      }

      sdbNodeStatus getStatus ()
      {
         if ( !pNode )
         {
            return SDB_NODE_UNKNOWN ;
         }
         return pNode->getStatus () ;
      }

      const CHAR *getHostName ()
      {
         if ( !pNode )
         {
            return NULL ;
         }
         return pNode->getHostName () ;
      }

      const CHAR *getServiceName ()
      {
         if ( !pNode )
         {
            return NULL ;
         }
         return pNode->getServiceName () ;
      }

      const CHAR *getNodeName ()
      {
         if ( !pNode )
         {
            return NULL ;
         }
         return pNode->getNodeName () ;
      }

      INT32 getNodeID( INT32 &nodeID ) const
      {
         if ( !pNode )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pNode->getNodeID( nodeID ) ;
      }

      INT32  stop ()
      {
         if ( !pNode )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pNode->stop () ;
      }

      INT32 start ()
      {
         if ( !pNode )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pNode->start () ;
      }
/*      INT32 modifyConfig ( std::map<std::string,std::string> &config )
      {
         if ( !pNode )
         {
            return NULL ;
         }
         return pNode->modifyConfig ( config ) ;
      }*/
   } ;

   class DLLEXPORT _sdbReplicaGroup
   {
   private :
      _sdbReplicaGroup ( const _sdbReplicaGroup& other ) ;
      _sdbReplicaGroup& operator=( const _sdbReplicaGroup& ) ;
   public :
      _sdbReplicaGroup () {}
      virtual ~_sdbReplicaGroup () {}
      // get number of logical nodes
      virtual INT32 getNodeNum ( sdbNodeStatus status, INT32 *num ) = 0 ;

      // get detailed information for the set
      virtual INT32 getDetail ( bson::BSONObj &result ) = 0 ;

      // get the master node
      virtual INT32 getMaster ( _sdbNode **node ) = 0 ;
      virtual INT32 getMaster ( sdbNode &node ) = 0 ;

      // get one of the slave node
      virtual INT32 getSlave ( _sdbNode **node,
                               const vector<INT32>& positions = _sdbStaticVec ) = 0 ;
      virtual INT32 getSlave ( sdbNode &node,
                               const vector<INT32>& positions = _sdbStaticVec ) = 0 ;

      // get a given node by name
      virtual INT32 getNode ( const CHAR *pNodeName,
                              _sdbNode **node ) = 0 ;
      virtual INT32 getNode ( const CHAR *pNodeName,
                              sdbNode &node ) = 0 ;

      // get a given node by host/service name
      virtual INT32 getNode ( const CHAR *pHostName,
                              const CHAR *pServiceName,
                              _sdbNode **node ) = 0 ;
      virtual INT32 getNode ( const CHAR *pHostName,
                              const CHAR *pServiceName,
                              sdbNode &node ) = 0 ;

      // create a new node in current replica group
      virtual INT32 createNode ( const CHAR *pHostName,
                                 const CHAR *pServiceName,
                                 const CHAR *pDatabasePath,
                                 std::map<std::string,std::string> &config )= 0;

      virtual INT32 createNode ( const CHAR *pHostName,
                                 const CHAR *pServiceName,
                                 const CHAR *pDatabasePath,
                                 const bson::BSONObj &options = _sdbStaticObject )= 0;

      // remove the specified node in current replica group
      virtual INT32 removeNode ( const CHAR *pHostName,
                                 const CHAR *pServiceName,
                                 const bson::BSONObj &configure = _sdbStaticObject ) = 0 ;
      // stop the replica group
      virtual INT32 stop () = 0 ;

      // start the replica group
      virtual INT32 start () = 0 ;

      // get the replica group name
      virtual const CHAR *getName () = 0 ;

      // whether the current replica group is catalog replica group or not
      virtual BOOLEAN isCatalog () = 0 ;

      // attach node
      virtual INT32 attachNode( const CHAR *pHostName,
                                const CHAR *pSvcName,
                                const bson::BSONObj &options ) = 0 ;

      // detach node
      virtual INT32 detachNode( const CHAR *pHostName,
                                const CHAR *pSvcName,
                                const bson::BSONObj &options ) = 0 ;

      // reelect primary node
      virtual INT32 reelect( const bson::BSONObj &options = _sdbStaticObject ) = 0 ;
   } ;

   class DLLEXPORT sdbReplicaGroup
   {
   private :
      sdbReplicaGroup ( const sdbReplicaGroup& other ) ;
      sdbReplicaGroup& operator=( const sdbReplicaGroup& ) ;
   public :
      _sdbReplicaGroup *pReplicaGroup ;

      sdbReplicaGroup ()
      {
         pReplicaGroup = NULL ;
      }

      ~sdbReplicaGroup ()
      {
         if ( pReplicaGroup )
         {
            delete pReplicaGroup ;
         }
      }

      INT32 getNodeNum ( sdbNodeStatus status, INT32 *num )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->getNodeNum ( status, num ) ;
      }

      INT32 getDetail ( bson::BSONObj &result )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->getDetail ( result ) ;
      }

      /* \fn INT32 getMaster ( _sdbNode **node )
          \brief Get the master node of the current replica group.
          \param [out] node The master node.If not exit,return null.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getMaster ( _sdbNode **node )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->getMaster ( node ) ;
      }

      INT32 getMaster ( sdbNode &node )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( node.pNode ) ;
         return pReplicaGroup->getMaster ( node ) ;
      }

      /* \fn INT32 getSlave ( _sdbNode **node, const vector<INT32>& positions )
          \brief Get one of slave node of the current replica group,
                 if no slave exists then get master
          \param [in] positions The positions of nodes
          \param [out] node The slave node
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getSlave ( _sdbNode **node,
                       const vector<INT32>& positions = _sdbStaticVec )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->getSlave ( node, positions ) ;
      }

      INT32 getSlave ( sdbNode &node,
                       const vector<INT32>& positions = _sdbStaticVec )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( node.pNode ) ;
         return pReplicaGroup->getSlave ( node, positions ) ;
      }

      /* \fn INT32 getNode ( const CHAR *pNodeName,
                            _sdbNode **node )
          \brief Get specified node from current replica group.
          \param [in] pNodeName The name of the node, with the format of "hostname:port".
          \param [out] node  The specified node
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getNode ( const CHAR *pNodeName,
                      _sdbNode **node )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->getNode ( pNodeName, node ) ;
      }

      INT32 getNode ( const CHAR *pNodeName,
                      sdbNode &node )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( node.pNode ) ;
         return pReplicaGroup->getNode ( pNodeName, node ) ;
      }

      INT32 getNode ( const CHAR *pHostName,
                      const CHAR *pServiceName,
                      _sdbNode **node )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->getNode ( pHostName, pServiceName, node ) ;
      }

      INT32 getNode ( const CHAR *pHostName,
                      const CHAR *pServiceName,
                      sdbNode &node )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( node.pNode ) ;
         return pReplicaGroup->getNode ( pHostName, pServiceName, node ) ;
      }

      INT32 createNode ( const CHAR *pHostName,
                         const CHAR *pServiceName,
                         const CHAR *pDatabasePath,
                         std::map<std::string,std::string> &config )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->createNode ( pHostName, pServiceName,
                                            pDatabasePath, config ) ;
      }

      INT32 createNode ( const CHAR *pHostName,
                         const CHAR *pServiceName,
                         const CHAR *pDatabasePath,
                         const bson::BSONObj &options = _sdbStaticObject )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->createNode ( pHostName, pServiceName,
                                            pDatabasePath, options ) ;
      }

      INT32 removeNode ( const CHAR *pHostName,
                         const CHAR *pServiceName,
                         const bson::BSONObj &configure = _sdbStaticObject )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->removeNode ( pHostName, pServiceName,
                                            configure ) ;
      }
      INT32 stop ()
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->stop () ;
      }

      INT32 start ()
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->start () ;
      }

      const CHAR *getName ()
      {
         if ( !pReplicaGroup )
         {
            return NULL ;
         }
         return pReplicaGroup->getName() ;
      }

      BOOLEAN isCatalog ()
      {
         if ( !pReplicaGroup )
         {
            return FALSE ;
         }
         return pReplicaGroup->isCatalog() ;
      }

      INT32 attachNode( const CHAR *pHostName,
                        const CHAR *pSvcName,
                        const bson::BSONObj &options )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->attachNode( pHostName, pSvcName, options ) ;
      }

      INT32 detachNode( const CHAR *pHostName,
                        const CHAR *pSvcName,
                        const bson::BSONObj &options )
      {
         if ( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->detachNode( pHostName, pSvcName, options ) ;
      }

      INT32 reelect( const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pReplicaGroup )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pReplicaGroup->reelect( options ) ;
      }
   } ;

   class DLLEXPORT _sdbCollectionSpace
   {
   private :
      _sdbCollectionSpace ( const _sdbCollectionSpace& other ) ;
      _sdbCollectionSpace& operator=( const _sdbCollectionSpace& ) ;
   public :
      _sdbCollectionSpace () {}
      virtual ~_sdbCollectionSpace () {}
      // get a collection object
      virtual INT32 getCollection ( const CHAR *pCollectionName,
                                    _sdbCollection **collection,
                                    BOOLEAN checkExist = TRUE ) = 0 ;

      virtual INT32 getCollection ( const CHAR *pCollectionName,
                                    sdbCollection &collection,
                                    BOOLEAN checkExist = TRUE ) = 0 ;

      // create a new collection object with options
      virtual INT32 createCollection ( const CHAR *pCollection,
                                       const bson::BSONObj &options,
                                       _sdbCollection **collection ) = 0 ;

      virtual INT32 createCollection ( const CHAR *pCollection,
                                       const bson::BSONObj &options,
                                       sdbCollection &collection ) = 0 ;

      // create a new collection object
      virtual INT32 createCollection ( const CHAR *pCollection,
                                       _sdbCollection **collection ) = 0 ;

      virtual INT32 createCollection ( const CHAR *pCollection,
                                       sdbCollection &collection ) = 0 ;

      // drop an existing collection
      virtual INT32 dropCollection ( const CHAR *pCollection ) = 0 ;

      // create a collection space with current collection space name
      virtual INT32 create () = 0 ;
      // drop a collection space with current collection space name
      virtual INT32 drop () = 0 ;

      // get the collectonSpace's name
      virtual const CHAR *getCSName () = 0 ;

      // rename collection
      virtual INT32 renameCollection( const CHAR* oldName, const CHAR* newName,
                         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 alterCollectionSpace ( const bson::BSONObj & options ) = 0 ;

      virtual INT32 setDomain ( const bson::BSONObj & options ) = 0 ;

      virtual INT32 removeDomain () = 0 ;

      virtual INT32 enableCapped () = 0 ;

      virtual INT32 disableCapped () = 0 ;

      virtual INT32 setAttributes ( const bson::BSONObj & options ) = 0 ;
   } ;
   class DLLEXPORT sdbCollectionSpace
   {
   private :
      sdbCollectionSpace ( const sdbCollectionSpace& other ) ;

      sdbCollectionSpace& operator=( const sdbCollectionSpace& ) ;
   public :
      _sdbCollectionSpace *pCollectionSpace ;

      sdbCollectionSpace ()
      {
         pCollectionSpace = NULL ;
      }

      ~sdbCollectionSpace ()
      {
         if ( pCollectionSpace )
         {
            delete pCollectionSpace ;
         }
      }

      INT32 getCollection ( const CHAR *pCollectionName,
                            _sdbCollection **collection,
                            BOOLEAN checkExist = TRUE )
      {
         if ( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->getCollection ( pCollectionName,
                                                  collection, checkExist ) ;
      }

      INT32 getCollection ( const CHAR *pCollectionName,
                            sdbCollection &collection,
                            BOOLEAN checkExist = TRUE )
      {
         if ( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( collection.pCollection ) ;
         return pCollectionSpace->getCollection ( pCollectionName,
                                                  collection,
                                                  checkExist ) ;
      }

      INT32 createCollection ( const CHAR *pCollection,
                               const bson::BSONObj &options,
                               _sdbCollection **collection )
      {
         if ( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->createCollection ( pCollection,
                                                     options,
                                                     collection ) ;
      }

      INT32 createCollection ( const CHAR *pCollection,
                               const bson::BSONObj &options,
                               sdbCollection &collection )
      {
         if ( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( collection.pCollection ) ;
         return pCollectionSpace->createCollection ( pCollection,
                                                     options,
                                                     collection ) ;
      }

      INT32 createCollection ( const CHAR *pCollection,
                               _sdbCollection **collection )
      {
         if ( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->createCollection ( pCollection,
                                                     collection ) ;
      }

      INT32 createCollection ( const CHAR *pCollection,
                               sdbCollection &collection )
      {
         if ( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( collection.pCollection ) ;
         return pCollectionSpace->createCollection ( pCollection,
                                                     collection ) ;
      }

      INT32 dropCollection ( const CHAR *pCollection )
      {
         if ( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->dropCollection ( pCollection ) ;
      }

      INT32 create ()
      {
         if ( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->create () ;
      }

      INT32 drop ()
      {
         if ( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->drop () ;
      }

      const CHAR *getCSName ()
      {
         if ( !pCollectionSpace )
         {
            return NULL ;
         }
         return pCollectionSpace->getCSName () ;
      }

      INT32 renameCollection( const CHAR* oldName, const CHAR* newName,
                              const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->renameCollection( oldName, newName, options ) ;
      }

      INT32 alterCollectionSpace ( const bson::BSONObj & options )
      {
         if ( NULL == pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->alterCollectionSpace( options ) ;
      }

      INT32 setDomain ( const bson::BSONObj & options )
      {
         if ( NULL == pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->setDomain( options ) ;
      }

      INT32 removeDomain ()
      {
         if ( NULL == pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->removeDomain() ;
      }

      INT32 enableCapped ()
      {
         if ( NULL == pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->enableCapped() ;
      }

      INT32 disableCapped ()
      {
         if ( NULL == pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->disableCapped() ;
      }

      INT32 setAttributes ( const bson::BSONObj & options )
      {
         if ( NULL == pCollectionSpace )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pCollectionSpace->setAttributes( options ) ;
      }
   } ;

   class DLLEXPORT _sdbDomain
   {
   private :
      _sdbDomain ( const _sdbDomain& other ) ; // non construction-copyable
      _sdbDomain& operator= ( const _sdbDomain& ) ; // non copyable
   public :
      _sdbDomain () {}
      virtual ~_sdbDomain () {}

      virtual const CHAR* getName () = 0 ;

      virtual INT32 alterDomain ( const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 listCollectionSpacesInDomain ( _sdbCursor **cursor ) = 0 ;

      virtual INT32 listCollectionSpacesInDomain ( sdbCursor &cursor ) = 0 ;

      virtual INT32 listCollectionsInDomain ( _sdbCursor **cursor ) = 0 ;

      virtual INT32 listCollectionsInDomain ( sdbCursor &cursor ) = 0 ;

      virtual INT32 listReplicaGroupInDomain( _sdbCursor **cursor ) = 0 ;

      virtual INT32 listReplicaGroupInDomain( sdbCursor &cursor ) = 0 ;

      virtual INT32 addGroups ( const bson::BSONObj & options ) = 0 ;

      virtual INT32 setGroups ( const bson::BSONObj & options ) = 0 ;

      virtual INT32 removeGroups ( const bson::BSONObj & options ) = 0 ;

      virtual INT32 setAttributes ( const bson::BSONObj & options ) = 0 ;
   } ;

   class DLLEXPORT sdbDomain
   {
   private :
      sdbDomain ( const sdbDomain& ) ; // non construction-copyable
      sdbDomain& operator= ( const sdbDomain& ) ; // non copyable
   public :

      _sdbDomain *pDomain ;

      sdbDomain() { pDomain = NULL ; }

      ~sdbDomain()
      {
         if ( pDomain )
         {
            delete pDomain ;
         }
      }

      const CHAR *getName ()
      {
         if ( !pDomain )
         {
            return NULL ;
         }
         return pDomain->getName() ;
      }

      INT32 alterDomain ( const bson::BSONObj &options )
      {
         if ( !pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDomain->alterDomain ( options ) ;
      }

      INT32 addGroups ( const bson::BSONObj & options )
      {
         if ( NULL == pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDomain->addGroups( options ) ;
      }

      INT32 setGroups ( const bson::BSONObj & options )
      {
         if ( NULL == pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDomain->setGroups( options ) ;
      }

      INT32 removeGroups ( const bson::BSONObj & options )
      {
         if ( NULL == pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDomain->removeGroups( options ) ;
      }

      INT32 setAttributes ( const bson::BSONObj &options )
      {
         if ( !pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDomain->setAttributes( options ) ;
      }

      INT32 listCollectionSpacesInDomain ( sdbCursor &cursor )
      {
         if ( !pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pDomain->listCollectionSpacesInDomain ( cursor ) ;
      }

      INT32 listCollectionSpacesInDomain ( _sdbCursor **cursor )
      {
         if ( !pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDomain->listCollectionSpacesInDomain ( cursor ) ;
      }

      INT32 listCollectionsInDomain ( sdbCursor &cursor )
      {
         if ( !pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pDomain->listCollectionsInDomain ( cursor ) ;
      }

      INT32 listCollectionsInDomain ( _sdbCursor **cursor )
      {
         if ( !pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDomain->listCollectionsInDomain ( cursor ) ;
      }

      INT32 listReplicaGroupInDomain( _sdbCursor **cursor )
      {
         if ( !pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDomain->listReplicaGroupInDomain( cursor ) ;
      }

      INT32 listReplicaGroupInDomain( sdbCursor &cursor )
      {
         if ( !pDomain )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pDomain->listReplicaGroupInDomain( cursor ) ;
      }
   };

   class DLLEXPORT _sdbDataCenter
   {
   private :
      _sdbDataCenter ( const _sdbDataCenter& other ) ; // non construction-copyable
      _sdbDataCenter& operator= ( const _sdbDataCenter& ) ; // non copyable

   public :
      _sdbDataCenter () {}
      virtual ~_sdbDataCenter () {}

   public :
      virtual const CHAR *getName () = 0 ;
      virtual INT32 getDetail( bson::BSONObj &retInfo ) = 0 ;
      virtual INT32 activateDC() = 0 ;
      virtual INT32 deactivateDC() = 0 ;
      virtual INT32 enableReadOnly( BOOLEAN isReadOnly ) = 0 ;
      virtual INT32 createImage( const CHAR *pCataAddrList ) = 0 ;
      virtual INT32 removeImage() = 0 ;
      virtual INT32 enableImage() = 0 ;
      virtual INT32 disableImage() = 0 ;
      virtual INT32 attachGroups( const bson::BSONObj &info ) = 0 ;
      virtual INT32 detachGroups( const bson::BSONObj &info ) = 0 ;

   } ;

   /* \class  sdbDataCenter
       \brief Database operation interfaces of data center.
   */
   class DLLEXPORT sdbDataCenter
   {
   private :
      sdbDataCenter ( const sdbDataCenter& ) ; // non construction-copyable
      sdbDataCenter& operator= ( const sdbDataCenter& ) ; // non copyable

   public :

      _sdbDataCenter *pDC ;

      sdbDataCenter() { pDC = NULL ; }

      ~sdbDataCenter()
      {
         if ( pDC )
         {
            delete pDC ;
         }
      }

   public :

      const CHAR *getName ()
      {
         if ( NULL == pDC )
         {
            return NULL ;
         }
         return pDC->getName() ;
      }

      INT32 getDetail( bson::BSONObj &retInfo )
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->getDetail( retInfo ) ;
      }

      INT32 activateDC()
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->activateDC() ;
      }

      INT32 deactivateDC()
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->deactivateDC() ;
      }

      INT32 enableReadOnly( BOOLEAN isReadOnly )
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->enableReadOnly( isReadOnly ) ;
      }

      INT32 createImage( const CHAR *pCataAddrList )
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->createImage( pCataAddrList ) ;
      }

      INT32 removeImage()
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->removeImage() ;
      }

      INT32 enableImage()
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->enableImage() ;
      }

      INT32 disableImage()
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->disableImage() ;
      }

      INT32 attachGroups( const bson::BSONObj &info )
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->attachGroups( info ) ;
      }

      INT32 detachGroups( const bson::BSONObj &info )
      {
         if ( NULL == pDC )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pDC->detachGroups( info ) ;
      }

   };

   class DLLEXPORT _sdbLob
   {
   private :
      _sdbLob ( const _sdbLob& other ) ; // non construction-copyable
      _sdbLob& operator= ( const _sdbLob& ) ; // non copyable

   public :
      _sdbLob () {}

      virtual ~_sdbLob () {}

      virtual INT32 close () = 0 ;

      virtual INT32 read ( UINT32 len, CHAR *buf, UINT32 *read ) = 0 ;

      virtual INT32 write ( const CHAR *buf, UINT32 len ) = 0 ;

      virtual INT32 seek ( SINT64 size, SDB_LOB_SEEK whence ) = 0 ;

      virtual INT32 lock( INT64 offset, INT64 length ) = 0 ;

      virtual INT32 lockAndSeek( INT64 offset, INT64 length ) = 0 ;

      virtual INT32 isClosed( BOOLEAN &flag ) = 0 ;

      virtual INT32 getOid( bson::OID &oid ) = 0 ;

      virtual INT32 getSize( SINT64 *size ) = 0 ;

      virtual INT32 getCreateTime ( UINT64 *millis ) = 0 ;

      virtual BOOLEAN isClosed() = 0 ;

      virtual bson::OID getOid() = 0 ;

      virtual SINT64 getSize() = 0 ;

      virtual UINT64 getCreateTime () = 0 ;

      virtual UINT64 getModificationTime() = 0 ;

      virtual INT32 getPiecesInfoNum() = 0 ;

      virtual bson::BSONArray getPiecesInfo() = 0 ;

      virtual BOOLEAN isEof() = 0 ;

      virtual INT32 getRunTimeDetail( bson::BSONObj &detail ) = 0 ;

   } ;

   class DLLEXPORT sdbLob
   {
   private :
      sdbLob ( const sdbLob& ) ; // non construction-copyable
      sdbLob& operator= ( const sdbLob& ) ; // non copyable

   public :

      _sdbLob *pLob ;
      sdbLob() { pLob = NULL ; }

      ~sdbLob()
      {
         if ( pLob )
         {
            delete pLob ;
         }
      }

      INT32 close ()
      {
         if ( !pLob )
         {
            return SDB_OK ;
         }
         return pLob->close() ;
      }

      INT32 read ( UINT32 len, CHAR *buf, UINT32 *read )
      {
         if ( !pLob )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pLob->read( len, buf, read ) ;
      }

      INT32 write ( const CHAR *buf, UINT32 len )
      {
         if ( !pLob )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pLob->write( buf, len ) ;
      }

      INT32 seek ( SINT64 size, SDB_LOB_SEEK whence )
      {
         if ( !pLob )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pLob->seek( size, whence ) ;
      }

      INT32 lock ( INT64 offset, INT64 length )
      {
         if ( !pLob )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pLob->lock( offset, length ) ;
      }

      INT32 lockAndSeek ( INT64 offset, INT64 length )
      {
         if ( !pLob )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pLob->lockAndSeek( offset, length ) ;
      }

      INT32 isClosed( BOOLEAN &flag )
      {
         if ( !pLob )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pLob->isClosed ( flag ) ;
      }

      BOOLEAN isClosed()
      {
         if ( !pLob )
         {
            return TRUE ;
         }
         return pLob->isClosed () ;
      }

      INT32 getOid ( bson::OID &oid )
      {
         if ( !pLob )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pLob->getOid( oid ) ;
      }

      bson::OID getOid ()
      {
         if ( !pLob )
         {
            return bson::OID();
         }
         return pLob->getOid() ;
      }

      INT32 getSize ( SINT64 *size )
      {
         if ( !pLob )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pLob->getSize( size ) ;
      }

      SINT64 getSize ()
      {
         if ( !pLob )
         {
            return -1 ;
         }
         return pLob->getSize();
      }

      INT32 getCreateTime ( UINT64 *millis )
      {
         if ( !pLob )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pLob->getCreateTime( millis ) ;
      }

      UINT64 getCreateTime ()
      {
         if ( !pLob )
         {
            return -1 ;
         }
         return pLob->getCreateTime() ;
      }

      UINT64 getModificationTime ()
      {
         if ( !pLob )
         {
            return -1 ;
         }
         return pLob->getModificationTime() ;
      }

      INT32 getPiecesInfoNum()
      {
         if ( !pLob )
         {
            return -1 ;
         }
         return pLob->getPiecesInfoNum() ;
      }

      bson::BSONArray getPiecesInfo()
      {
         if ( !pLob )
         {
            return bson::BSONArray() ;
         }
         return pLob->getPiecesInfo() ;
      }

      BOOLEAN isEof()
      {
         if ( !pLob )
         {
            return TRUE ;
         }
         return pLob->isEof() ;
      }

      INT32 getRunTimeDetail( bson::BSONObj &detail )
      {
         if ( !pLob )
         {
            return -1 ;
         }
         return pLob->getRunTimeDetail( detail ) ;
      }

   } ;

   class DLLEXPORT _sdbSequence
   {
   private :
      _sdbSequence ( const _sdbSequence& other ) ;
      _sdbSequence& operator=( const _sdbSequence& ) ;
   public :
      _sdbSequence () {}
      virtual ~_sdbSequence () {}

      virtual INT32 setAttributes ( const bson::BSONObj &options ) = 0 ;

      virtual INT32 getNextValue ( INT64 &value ) = 0 ;

      virtual INT32 getCurrentValue ( INT64 &value ) = 0 ;

      virtual INT32 setCurrentValue ( const INT64 value ) = 0 ;

      virtual INT32 fetch( const INT32 fetchNum,
                           INT64 &nextValue,
                           INT32 &returnNum,
                           INT32 &Increment ) = 0 ;

      virtual INT32 restart( const INT64 startValue ) = 0 ;
   } ;

   class DLLEXPORT sdbSequence
   {
   private :
      sdbSequence ( const sdbSequence& other ) ;

      sdbSequence& operator=( const sdbSequence& ) ;
   public :
      _sdbSequence *pSequence ;

      sdbSequence ()
      {
         pSequence = NULL ;
      }

      ~sdbSequence ()
      {
         if ( pSequence )
         {
            delete pSequence ;
         }
      }

      INT32 setAttributes ( const bson::BSONObj & options )
      {
         if ( NULL == pSequence )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSequence->setAttributes( options ) ;
      }

      INT32 getNextValue( INT64 &value )
      {
         if ( NULL == pSequence )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSequence->getNextValue( value ) ;
      }

      INT32 getCurrentValue( INT64 &value )
      {
         if ( NULL == pSequence )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSequence->getCurrentValue( value ) ;
      }

      INT32 setCurrentValue( const INT64 value )
      {
         if ( NULL == pSequence )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSequence->setCurrentValue( value ) ;
      }

      INT32 fetch( const INT32 fetchNum, INT64 &nextValue,
                   INT32 &returnNum, INT32 &increment )
      {
         if ( NULL == pSequence )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSequence->fetch( fetchNum, nextValue, returnNum, increment ) ;
      }

      INT32 restart( const INT64 startValue )
      {
         if ( NULL == pSequence )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSequence->restart( startValue ) ;
      }
   } ;

   class DLLEXPORT _sdb
   {
   private :
      _sdb ( const _sdb& other ) ; // non construction-copyable
      _sdb& operator=( const _sdb& ) ; // non copyable
   public :
      _sdb () {}
      virtual ~_sdb () {}
      virtual INT32 connect ( const CHAR *pHostName,
                              UINT16 port
                            ) = 0 ;
      virtual INT32 connect ( const CHAR *pHostName,
                              UINT16 port,
                              const CHAR *pUsrName,
                              const CHAR *pPasswd ) = 0 ;
      virtual INT32 connect ( const CHAR *pHostName,
                              const CHAR *pServiceName ) = 0 ;
      virtual INT32 connect ( const CHAR *pHostName,
                              const CHAR *pServiceName,
                              const CHAR *pUsrName,
                              const CHAR *pPasswd ) = 0 ;
      virtual INT32 connect ( const CHAR **pConnAddrs,
                              INT32 arrSize,
                              const CHAR *pUsrName,
                              const CHAR *pPasswd ) = 0 ;
      virtual INT32 connect ( const CHAR **pConnAddrs,
                              INT32 arrSize,
                              const CHAR *pUsrName,
                              const CHAR *pToken,
                              const CHAR *pCipherFile ) = 0 ;

      virtual void disconnect () = 0 ;

      virtual UINT64 getDbStartTime() = 0 ;

      virtual void getVersion( UINT8 &version, UINT8 &subVersion,
                               UINT8 &fixVersion ) = 0 ;

      virtual INT32 createUsr( const CHAR *pUsrName,
                               const CHAR *pPasswd,
                               const bson::BSONObj &options = _sdbStaticObject
                              ) = 0 ;

      virtual INT32 removeUsr( const CHAR *pUsrName,
                               const CHAR *pPasswd ) = 0 ;

      virtual INT32 alterUsr( const CHAR *pUsrName,
                              const CHAR *pAction,
                              const bson::BSONObj &options ) = 0 ;

      virtual INT32 changeUsrPasswd( const CHAR *pUsrName,
                                     const CHAR *pOldPasswd,
                                     const CHAR *pNewPasswd ) = 0 ;

      virtual INT32 getSnapshot ( _sdbCursor **cursor,
                                  INT32 snapType,
                                  const bson::BSONObj &condition = _sdbStaticObject,
                                  const bson::BSONObj &selector  = _sdbStaticObject,
                                  const bson::BSONObj &orderBy   = _sdbStaticObject,
                                  const bson::BSONObj &hint      = _sdbStaticObject,
                                  INT64 numToSkip = 0,
                                  INT64 numToReturn = -1
                                ) = 0 ;

      virtual INT32 getSnapshot ( sdbCursor &cursor,
                                  INT32 snapType,
                                  const bson::BSONObj &condition = _sdbStaticObject,
                                  const bson::BSONObj &selector  = _sdbStaticObject,
                                  const bson::BSONObj &orderBy   = _sdbStaticObject,
                                  const bson::BSONObj &hint      = _sdbStaticObject,
                                  INT64 numToSkip = 0,
                                  INT64 numToReturn = -1
                                ) = 0 ;

      virtual INT32 resetSnapshot ( const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 getList ( _sdbCursor **cursor,
                              INT32 listType,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selector  = _sdbStaticObject,
                              const bson::BSONObj &orderBy   = _sdbStaticObject,
                              const bson::BSONObj &hint      = _sdbStaticObject,
                              INT64 numToSkip = 0,
                              INT64 numToReturn = -1
                            ) = 0 ;
      virtual INT32 getList ( sdbCursor &cursor,
                              INT32 listType,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selector  = _sdbStaticObject,
                              const bson::BSONObj &orderBy   = _sdbStaticObject,
                              const bson::BSONObj &hint      = _sdbStaticObject,
                              INT64 numToSkip = 0,
                              INT64 numToReturn = -1
                            ) = 0 ;

      virtual INT32 getCollection ( const CHAR *pCollectionFullName,
                                    _sdbCollection **collection,
                                    BOOLEAN checkExist = TRUE
                                  ) = 0 ;

      virtual INT32 getCollection ( const CHAR *pCollectionFullName,
                                    sdbCollection &collection,
                                    BOOLEAN checkExist = TRUE
                                  ) = 0 ;

      virtual INT32 getCollectionSpace ( const CHAR *pCollectionSpaceName,
                                         _sdbCollectionSpace **cs,
                                         BOOLEAN checkExist = TRUE
                                       ) = 0 ;

      virtual INT32 getCollectionSpace ( const CHAR *pCollectionSpaceName,
                                         sdbCollectionSpace &cs,
                                         BOOLEAN checkExist = TRUE
                                       ) = 0 ;

      virtual INT32 createCollectionSpace ( const CHAR *pCollectionSpaceName,
                                            INT32 iPageSize,
                                            _sdbCollectionSpace **cs
                                          ) = 0 ;

      virtual INT32 createCollectionSpace ( const CHAR *pCollectionSpaceName,
                                            INT32 iPageSize,
                                            sdbCollectionSpace &cs
                                          ) = 0 ;

      virtual INT32 createCollectionSpace ( const CHAR *pCollectionSpaceName,
                                            const bson::BSONObj &options,
                                            _sdbCollectionSpace **cs
                                          ) = 0 ;

      virtual INT32 createCollectionSpace ( const CHAR *pCollectionSpaceName,
                                            const bson::BSONObj &options,
                                            sdbCollectionSpace &cs
                                          ) = 0 ;

      virtual INT32 dropCollectionSpace (
                               const CHAR *pCollectionSpaceName,
                               const bson::BSONObj &options = _sdbStaticObject
                                        ) = 0 ;

      virtual INT32 listCollectionSpaces ( _sdbCursor **result ) = 0 ;

      virtual INT32 listCollectionSpaces ( sdbCursor &result ) = 0 ;

      // list all collections in a given database
      virtual INT32 listCollections ( _sdbCursor **result ) = 0 ;

      virtual INT32 listCollections ( sdbCursor &result ) = 0 ;

      // list all the replica groups in the given database
      virtual INT32 listReplicaGroups ( _sdbCursor **result ) = 0 ;

      virtual INT32 listReplicaGroups ( sdbCursor &result ) = 0 ;

      virtual INT32 getReplicaGroup ( const CHAR *pName,
                               _sdbReplicaGroup **result ) = 0 ;

      virtual INT32 getReplicaGroup ( const CHAR *pName,
                               sdbReplicaGroup &result ) = 0 ;

      virtual INT32 getReplicaGroup ( INT32 id,
                                _sdbReplicaGroup **result ) = 0 ;

      virtual INT32 getReplicaGroup ( INT32 id,
                               sdbReplicaGroup &result ) = 0 ;

      virtual INT32 createReplicaGroup ( const CHAR *pName,
                                  _sdbReplicaGroup **replicaGroup ) = 0 ;

      virtual INT32 createReplicaGroup ( const CHAR *pName,
                                  sdbReplicaGroup &replicaGroup ) = 0 ;

      virtual INT32 removeReplicaGroup ( const CHAR *pName ) = 0 ;

      virtual INT32 createReplicaCataGroup (  const CHAR *pHostName,
                                       const CHAR *pServiceName,
                                       const CHAR *pDatabasePath,
                                       const bson::BSONObj &configure ) =0 ;

      virtual INT32 activateReplicaGroup ( const CHAR *pName,
                                    _sdbReplicaGroup **replicaGroup ) = 0 ;
      virtual INT32 activateReplicaGroup ( const CHAR *pName,
                                    sdbReplicaGroup &replicaGroup ) = 0 ;

      virtual INT32 execUpdate( const CHAR *sql,
                                bson::BSONObj *pResult = NULL ) = 0 ;

      virtual INT32 exec( const CHAR *sql,
                          _sdbCursor **result ) = 0 ;

      virtual INT32 exec( const CHAR *sql,
                          sdbCursor &result ) = 0 ;

      virtual INT32 transactionBegin() = 0 ;

      virtual INT32 transactionCommit( const bson::BSONObj &hint = _sdbStaticObject ) = 0 ;

      virtual INT32 transactionRollback() = 0 ;

      virtual INT32 flushConfigure( const bson::BSONObj &options ) = 0 ;
      // stored procedure
      virtual INT32 crtJSProcedure ( const CHAR *code ) = 0 ;
      virtual INT32 rmProcedure( const CHAR *spName ) = 0 ;
      virtual INT32 listProcedures( _sdbCursor **cursor, const bson::BSONObj &condition ) = 0 ;
      virtual INT32 listProcedures( sdbCursor &cursor, const bson::BSONObj &condition ) = 0 ;
      virtual INT32 evalJS( const CHAR *code,
                            SDB_SPD_RES_TYPE &type,
                            _sdbCursor **cursor,
                            bson::BSONObj &errmsg ) = 0 ;
      virtual INT32 evalJS( const CHAR *code,
                            SDB_SPD_RES_TYPE &type,
                            sdbCursor &cursor,
                            bson::BSONObj &errmsg ) = 0 ;

      // bakup
      virtual INT32 backup ( const bson::BSONObj &options) = 0 ;
      virtual INT32 listBackup ( _sdbCursor **cursor,
                              const bson::BSONObj &options,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selector = _sdbStaticObject,
                              const bson::BSONObj &orderBy = _sdbStaticObject) = 0 ;
      virtual INT32 listBackup ( sdbCursor &cursor,
                              const bson::BSONObj &options,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selector = _sdbStaticObject,
                              const bson::BSONObj &orderBy = _sdbStaticObject)  = 0 ;
      virtual INT32 removeBackup ( const bson::BSONObj &options ) = 0 ;

      // task
      virtual INT32 listTasks ( _sdbCursor **cursor,
                        const bson::BSONObj &condition = _sdbStaticObject,
                        const bson::BSONObj &selector = _sdbStaticObject,
                        const bson::BSONObj &orderBy = _sdbStaticObject,
                        const bson::BSONObj &hint = _sdbStaticObject) = 0 ;


      virtual INT32 listTasks ( sdbCursor &cursor,
                        const bson::BSONObj &condition = _sdbStaticObject,
                        const bson::BSONObj &selector = _sdbStaticObject,
                        const bson::BSONObj &orderBy = _sdbStaticObject,
                        const bson::BSONObj &hint = _sdbStaticObject) = 0 ;

      virtual INT32 waitTasks ( const SINT64 *taskIDs,
                                SINT32 num ) = 0 ;

      virtual INT32 cancelTask ( SINT64 taskID,
                                 BOOLEAN isAsync ) = 0 ;
      // set session attribute
      virtual INT32 setSessionAttr ( const bson::BSONObj &options =
                                     _sdbStaticObject ) = 0 ;
      // get session attribute
      virtual INT32 getSessionAttr ( bson::BSONObj &result,
                                     BOOLEAN useCache = TRUE ) = 0 ;

      // close all cursor
      virtual INT32 closeAllCursors () = 0 ;

      // interrupt
      virtual INT32 interrupt() = 0 ;
      virtual INT32 interruptOperation() = 0 ;

      // connection is valid
      virtual INT32 isValid( BOOLEAN *result ) = 0 ;
      virtual BOOLEAN isValid() = 0 ;

      virtual BOOLEAN isClosed() = 0 ;

      // domain
      virtual INT32 createDomain ( const CHAR *pDomainName,
                                   const bson::BSONObj &options,
                                   _sdbDomain **domain ) = 0 ;

      virtual INT32 createDomain ( const CHAR *pDomainName,
                                   const bson::BSONObj &options,
                                   sdbDomain &domain ) = 0 ;

      virtual INT32 dropDomain ( const CHAR *pDomainName ) = 0 ;

      virtual INT32 getDomain ( const CHAR *pDomainName,
                                _sdbDomain **domain ) = 0 ;

      virtual INT32 getDomain ( const CHAR *pDomainName,
                                sdbDomain &domain ) = 0 ;

      virtual INT32 listDomains ( _sdbCursor **cursor,
                                  const bson::BSONObj &condition = _sdbStaticObject,
                                  const bson::BSONObj &selector = _sdbStaticObject,
                                  const bson::BSONObj &orderBy = _sdbStaticObject,
                                  const bson::BSONObj &hint = _sdbStaticObject
                                ) = 0 ;

      virtual INT32 listDomains ( sdbCursor &cursor,
                                  const bson::BSONObj &condition = _sdbStaticObject,
                                  const bson::BSONObj &selector = _sdbStaticObject,
                                  const bson::BSONObj &orderBy = _sdbStaticObject,
                                  const bson::BSONObj &hint = _sdbStaticObject
                                ) = 0 ;
      virtual INT32 getDC( _sdbDataCenter **dc ) = 0 ;
      virtual INT32 getDC( sdbDataCenter &dc ) = 0 ;

      static _sdb *getObj ( BOOLEAN useSSL = FALSE ) ;

      // get last alive time
      virtual UINT64 getLastAliveTime() const = 0 ;

      virtual INT32 syncDB(
         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 analyze(
         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 forceSession(
         SINT64 sessionID,
         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 forceStepUp(
         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 invalidateCache(
         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 reloadConfig(
         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 updateConfig ( const bson::BSONObj &configs = _sdbStaticObject,
                                   const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 deleteConfig ( const bson::BSONObj &configs = _sdbStaticObject,
                                   const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 setPDLevel( INT32 level,
         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 msg( const CHAR* msg ) = 0 ;

      virtual INT32 loadCS( const CHAR* csName,
         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 unloadCS( const CHAR* csName,
         const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 traceStart( UINT32 traceBufferSize,
                                const CHAR* component = NULL,
                                const CHAR* breakpoint = NULL,
                      const vector<UINT32> &tidVec = _sdbStaticUINT32Vec ) = 0 ;

      virtual INT32 traceStart( UINT32 traceBufferSize,
                                const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 traceStop( const CHAR* dumpFileName ) = 0 ;

      virtual INT32 traceResume() = 0 ;

      virtual INT32 traceStatus( _sdbCursor** cursor ) = 0 ;

      virtual INT32 traceStatus( sdbCursor& cursor ) = 0 ;


      virtual INT32 renameCollectionSpace( const CHAR* oldName,
                                           const CHAR* newName,
                        const bson::BSONObj &options = _sdbStaticObject ) = 0 ;

      virtual INT32 getLastErrorObj( bson::BSONObj &result ) = 0 ;
      virtual void  cleanLastErrorObj() = 0 ;

      virtual INT32 getLastResultObj( bson::BSONObj &result,
                                      BOOLEAN getOwned = FALSE ) const = 0 ;

      // create a new sequence object
      virtual INT32 createSequence( const CHAR *pSequenceName,
                                    const bson::BSONObj &options,
                                    _sdbSequence **sequence ) = 0 ;

      virtual INT32 createSequence( const CHAR *pSequenceName,
                                    const bson::BSONObj &options,
                                    sdbSequence &sequence ) = 0 ;

      virtual INT32 createSequence( const CHAR *pSequenceName,
                                    sdbSequence &sequence ) = 0 ;

      // get a sequence object
      virtual INT32 getSequence( const CHAR *pSequenceName,
                                 _sdbSequence **sequence ) = 0 ;

      virtual INT32 getSequence( const CHAR *pSequenceName,
                                 sdbSequence &sequence ) = 0 ;

      virtual INT32 renameSequence( const CHAR *pOldName,
                                    const CHAR *pNewName ) = 0 ;

      virtual INT32 dropSequence( const CHAR *pSequenceName ) = 0 ;
   } ;
   typedef class _sdb _sdb ;
   class DLLEXPORT sdb
   {
   private:
      sdb ( const sdb& other ) ;
      sdb& operator=( const sdb& ) ;
   public :
      _sdb *pSDB ;

      sdb ( BOOLEAN useSSL = FALSE ) :
      pSDB ( _sdb::getObj( useSSL ) )
      {
      }

      ~sdb ()
      {
         if ( pSDB )
         {
            delete pSDB ;
         }
      }

      INT32 connect ( const CHAR *pHostName,
                      UINT16 port
                    )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->connect ( pHostName, port ) ;
      }

      INT32 connect ( const CHAR *pHostName,
                      UINT16 port,
                      const CHAR *pUsrName,
                      const CHAR *pPasswd
                      )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->connect ( pHostName, port,
                                pUsrName, pPasswd ) ;
      }

      INT32 connect ( const CHAR *pHostName,
                      const CHAR *pServiceName
                    )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->connect ( pHostName, pServiceName ) ;
      }

      INT32 connect ( const CHAR *pHostName,
                      const CHAR *pServiceName,
                      const CHAR *pUsrName,
                      const CHAR *pPasswd )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->connect ( pHostName, pServiceName,
                                 pUsrName, pPasswd ) ;
      }

      INT32 connect ( const CHAR **pConnAddrs,
                      INT32 arrSize,
                      const CHAR *pUsrName,
                      const CHAR *pPasswd )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->connect ( pConnAddrs, arrSize,
                                 pUsrName, pPasswd ) ;
      }

      INT32 connect ( const CHAR **pConnAddrs,
                      INT32 arrSize,
                      const CHAR *pUsrName,
                      const CHAR *pToken,
                      const CHAR *pCipherFile )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->connect ( pConnAddrs, arrSize,
                                 pUsrName, pToken, pCipherFile ) ;
      }

      UINT64 getDbStartTime ()
      {
         if ( !pSDB )
         {
            return -1 ;
         }
         return pSDB->getDbStartTime() ;
      }

      void getVersion ( UINT8 &version, UINT8 &subVersion, UINT8 &fixVersion )
      {
         if ( !pSDB )
         {
            return ;
         }
         pSDB->getVersion( version, subVersion, fixVersion ) ;
      }

      INT32 createUsr( const CHAR *pUsrName,
                       const CHAR *pPasswd,
                       const bson::BSONObj &options = _sdbStaticObject )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->createUsr( pUsrName, pPasswd, options ) ;
      }

      INT32 removeUsr( const CHAR *pUsrName,
                       const CHAR *pPasswd )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->removeUsr( pUsrName, pPasswd ) ;
      }

      INT32 alterUsr( const CHAR *pUsrName,
                      const CHAR *pAction,
                      const bson::BSONObj &options )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->alterUsr( pUsrName, pAction, options ) ;
      }

      INT32 changeUsrPasswd( const CHAR *pUsrName,
                             const CHAR *pOldPasswd,
                             const CHAR *pNewPasswd )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->changeUsrPasswd( pUsrName, pOldPasswd, pNewPasswd ) ;
      }

      void disconnect ()
      {
         if ( !pSDB )
         {
            return ;
         }
         pSDB->disconnect () ;
      }

      INT32 getSnapshot ( sdbCursor &cursor,
                          INT32 snapType,
                          const bson::BSONObj &condition = _sdbStaticObject,
                          const bson::BSONObj &selector  = _sdbStaticObject,
                          const bson::BSONObj &orderBy   = _sdbStaticObject,
                          const bson::BSONObj &hint      = _sdbStaticObject,
                          INT64 numToSkip = 0,
                          INT64 numToReturn = -1 )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->getSnapshot ( cursor, snapType, condition,
                                    selector, orderBy, hint,
                                    numToSkip, numToReturn ) ;
      }

      /* \fn  INT32 getSnapshot ( _sdbCursor **cursor,
                                  INT32 snapType,
                                  const bson::BSONObj &condition,
                                  const bson::BSONObj &selector,
                                  const bson::BSONObj &orderBy,
                                  const bson::BSONObj &hint,
                                  INT64 numToSkip,
                                  INT64 numToReturn
                                 )
          \brief Get the snapshots of specified type.
          \param [in] snapType The snapshot type as below

              SDB_SNAP_CONTEXTS         : Get the snapshot of all the contexts
              SDB_SNAP_CONTEXTS_CURRENT : Get the snapshot of current context
              SDB_SNAP_SESSIONS         : Get the snapshot of all the sessions
              SDB_SNAP_SESSIONS_CURRENT : Get the snapshot of current session
              SDB_SNAP_COLLECTIONS      : Get the snapshot of all the collections
              SDB_SNAP_COLLECTIONSPACES : Get the snapshot of all the collection spaces
              SDB_SNAP_DATABASE         : Get the snapshot of the database
              SDB_SNAP_SYSTEM           : Get the snapshot of the system
              SDB_SNAP_CATALOG          : Get the snapshot of the catalog
              SDB_SNAP_TRANSACTIONS     : Get snapshot of transactions in current session
              SDB_SNAP_TRANSACTIONS_CURRENT : Get snapshot of all the transactions
              SDB_SNAP_ACCESSPLANS      : Get the snapshot of cached access plans
              SDB_SNAP_HEALTH           : Get snapshot of node health detection
              SDB_SNAP_CONFIGS          : Get snapshot of node configurations
              SDB_SNAP_SVCTASKS         : Get snapshot of service task
              SDB_SNAP_SEQUENCES        : Get the snapshot of sequences
              SDB_SNAP_INDEXSTATS       : Get the snapshot of index statistics

           \param [in] condition The matching rule, match all the documents if not provided.
           \param [in] select The selective rule, return the whole document if not provided.
           \param [in] orderBy The ordered rule, result set is unordered if not provided.
           \param [in] hint The options provided for specific snapshot type.
                       format:{ '$Options': { <options> } }
           \param [in] numToSkip Skip the first numToSkip documents, default is 0
           \param [in] numToReturn Only return numToReturn documents, default is -1 for returning all results
           \param [out] cursor The return cursor handle of query.
           \retval SDB_OK Operation Success
           \retval Others Operation Fail
      */
      INT32 getSnapshot ( _sdbCursor **cursor,
                          INT32 snapType,
                          const bson::BSONObj &condition = _sdbStaticObject,
                          const bson::BSONObj &selector = _sdbStaticObject,
                          const bson::BSONObj &orderBy = _sdbStaticObject,
                          const bson::BSONObj &hint   = _sdbStaticObject,
                          INT64 numToSkip = 0,
                          INT64 numToReturn = -1 )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getSnapshot ( cursor, snapType, condition,
                                    selector, orderBy, hint,
                                    numToSkip, numToReturn ) ;
      }

      INT32 resetSnapshot ( const bson::BSONObj &options = _sdbStaticObject )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->resetSnapshot ( options ) ;
      }

      /* \fn INT32 getList ( _sdbCursor **cursor,
                             INT32 listType,
                             const bson::BSONObj &condition,
                             const bson::BSONObj &selector,
                             const bson::BSONObj &orderBy,
                             const bson::BSONObj &hint,
                             INT64 numToSkip,
                             INT64 numToReturn
                           )
          \brief Get the informations of specified type.
          \param [in] listType The list type as below

              SDB_LIST_CONTEXTS         : Get all contexts list
              SDB_LIST_CONTEXTS_CURRENT : Get contexts list for the current session
              SDB_LIST_SESSIONS         : Get all sessions list
              SDB_LIST_SESSIONS_CURRENT : Get the current session
              SDB_LIST_COLLECTIONS      : Get all collections list
              SDB_LIST_COLLECTIONSPACES : Get all collecion spaces' list
              SDB_LIST_STORAGEUNITS     : Get storage units list
              SDB_LIST_GROUPS           : Get replicaGroup list ( only applicable in sharding env )
              SDB_LIST_STOREPROCEDURES  : Get all the stored procedure list
              SDB_LIST_DOMAINS          : Get all the domains list
              SDB_LIST_TASKS            : Get all the running split tasks ( only applicable in sharding env )
              SDB_LIST_TRANSACTIONS     : Get all the transactions information.
              SDB_LIST_TRANSACTIONS_CURRENT : Get the transactions information of current session.
              SDB_LIST_SVCTASKS         : Get all the schedule task informations
              SDB_LIST_SEQUENCES        : Get all the sequence informations
              SDB_LIST_USERS            : Get all the user informations

         \param [in] condition The matching rule, match all the documents if null.
         \param [in] select The selective rule, return the whole document if null.
         \param [in] orderBy The ordered rule, never sort if null.
         \param [in] hint The options provided for specific list type. Reserved.
         \param [in] numToSkip Skip the first numToSkip documents.
         \param [in] numToReturn Only return numToReturn documents. -1 means return
                     all matched results.
         \param [out] cursor The return cursor handle of query.
         \retval SDB_OK Operation Success
         \retval Others Operation Fail
      */
      INT32 getList ( _sdbCursor **cursor,
                      INT32 listType,
                      const bson::BSONObj &condition = _sdbStaticObject,
                      const bson::BSONObj &selector  = _sdbStaticObject,
                      const bson::BSONObj &orderBy   = _sdbStaticObject,
                      const bson::BSONObj &hint = _sdbStaticObject,
                      INT64 numToSkip = 0,
                      INT64 numToReturn = -1
                    )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getList ( cursor, listType,
                                condition, selector, orderBy, hint,
                                numToSkip, numToReturn ) ;
      }

      INT32 getList ( sdbCursor &cursor,
                      INT32 listType,
                      const bson::BSONObj &condition = _sdbStaticObject,
                      const bson::BSONObj &selector  = _sdbStaticObject,
                      const bson::BSONObj &orderBy   = _sdbStaticObject,
                      const bson::BSONObj &hint = _sdbStaticObject,
                      INT64 numToSkip = 0,
                      INT64 numToReturn = -1
                    )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->getList ( cursor, listType,
                                condition, selector, orderBy, hint,
                                numToSkip, numToReturn ) ;
      }

      INT32 getCollection ( const CHAR *pCollectionFullName,
                            _sdbCollection **collection,
                            BOOLEAN checkExist = TRUE
                          )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getCollection ( pCollectionFullName,
                                      collection, checkExist ) ;
      }

      INT32 getCollection ( const CHAR *pCollectionFullName,
                            sdbCollection &collection,
                            BOOLEAN checkExist = TRUE
                          )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( collection.pCollection ) ;
         return pSDB->getCollection ( pCollectionFullName,
                                      collection,
                                      checkExist ) ;
      }

      INT32 getCollectionSpace ( const CHAR *pCollectionSpaceName,
                                 _sdbCollectionSpace **cs,
                                 BOOLEAN checkExist = TRUE
                               )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getCollectionSpace ( pCollectionSpaceName,
                                           cs, checkExist ) ;
      }

      INT32 getCollectionSpace ( const CHAR *pCollectionSpaceName,
                                 sdbCollectionSpace &cs,
                                 BOOLEAN checkExist = TRUE
                               )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cs.pCollectionSpace ) ;
         return pSDB->getCollectionSpace ( pCollectionSpaceName,
                                           cs, checkExist ) ;
      }

      /* \fn INT32 createCollectionSpace ( const CHAR *pCollectionSpaceName,
                                          INT32 iPageSize,
                                          _sdbCollectionSpace **cs
                                        )
          \brief Create collection space with specified pagesize.
          \param [in] pCollectionSpaceName The name of collection space.
          \param [in] iPageSize The Page Size as below

              SDB_PAGESIZE_4K
              SDB_PAGESIZE_8K
              SDB_PAGESIZE_16K
              SDB_PAGESIZE_32K
              SDB_PAGESIZE_64K
              SDB_PAGESIZE_DEFAULT
          \param [out] cs The return collection space handle of creation.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 createCollectionSpace ( const CHAR *pCollectionSpaceName,
                                    INT32 iPageSize,
                                    _sdbCollectionSpace **cs
                                  )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->createCollectionSpace ( pCollectionSpaceName,
                                              iPageSize,
                                              cs ) ;
      }

      INT32 createCollectionSpace ( const CHAR *pCollectionSpaceName,
                                    INT32 iPageSize,
                                    sdbCollectionSpace &cs
                                  )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cs.pCollectionSpace ) ;
         return pSDB->createCollectionSpace ( pCollectionSpaceName,
                                              iPageSize, cs ) ;
      }

      INT32 createCollectionSpace ( const CHAR *pCollectionSpaceName,
                                    const bson::BSONObj &options,
                                    _sdbCollectionSpace **cs
                                  )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->createCollectionSpace ( pCollectionSpaceName,
                                              options, cs ) ;
      }

      INT32 createCollectionSpace ( const CHAR *pCollectionSpaceName,
                                    const bson::BSONObj &options,
                                    sdbCollectionSpace &cs
                                  )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cs.pCollectionSpace ) ;
         return pSDB->createCollectionSpace ( pCollectionSpaceName,
                                              options, cs ) ;
      }

      INT32 dropCollectionSpace (
                               const CHAR *pCollectionSpaceName,
                               const bson::BSONObj &options = _sdbStaticObject )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }

         return pSDB->dropCollectionSpace ( pCollectionSpaceName, options ) ;
      }

      INT32 listCollectionSpaces ( _sdbCursor **result )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->listCollectionSpaces ( result ) ;
      }

      INT32 listCollectionSpaces ( sdbCursor &cursor )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->listCollectionSpaces ( cursor ) ;
      }

      /* \fn INT32 listCollections ( _sdbCursor **result )
          \brief list all collections in current database.
          \param [out] result The return cursor handle of query.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 listCollections ( _sdbCursor **result )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->listCollections ( result ) ;
      }

      INT32 listCollections ( sdbCursor &cursor )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->listCollections ( cursor ) ;
      }

      /* \fn INT32 listReplicaGroups ( _sdbCursor **result )
          \brief List all replica groups of current database.
          \param [out] result The return cursor handle of query.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 listReplicaGroups ( _sdbCursor **result )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->listReplicaGroups ( result ) ;
      }


      INT32 listReplicaGroups ( sdbCursor &cursor )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->listReplicaGroups ( cursor ) ;
      }

      /* \fn INT32 getReplicaGroup ( const CHAR *pName, _sdbReplicaGroup **result )
          \brief Get the specified replica group.
          \param [in] pName The name of replica group.
          \param [out] result The sdbReplicaGroup object.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getReplicaGroup ( const CHAR *pName, _sdbReplicaGroup **result )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getReplicaGroup ( pName, result ) ;
      }


      INT32 getReplicaGroup ( const CHAR *pName, sdbReplicaGroup &group )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( group.pReplicaGroup ) ;
         return pSDB->getReplicaGroup ( pName, group ) ;
      }

      /* \fn INT32 getReplicaGroup ( INT32 id, _sdbReplicaGroup **result )
          \brief Get the specified replica group.
          \param [in] id The id of replica group.
          \param [out] result The _sdbReplicaGroup object.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getReplicaGroup ( INT32 id, _sdbReplicaGroup **result )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getReplicaGroup ( id, result ) ;
      }

      INT32 getReplicaGroup ( INT32 id, sdbReplicaGroup &group )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( group.pReplicaGroup ) ;
         return pSDB->getReplicaGroup ( id, group ) ;
      }

      /* \fn INT32 createReplicaGroup ( const CHAR *pName, _sdbReplicaGroup **replicaGroup )
          \brief Create the specified replica group.
          \param [in] pName The name of the replica group.
          \param [out] replicaGroup The return _sdbReplicaGroup object.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 createReplicaGroup ( const CHAR *pName, _sdbReplicaGroup **replicaGroup )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->createReplicaGroup ( pName, replicaGroup ) ;
      }

      INT32 createReplicaGroup ( const CHAR *pName, sdbReplicaGroup &group )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( group.pReplicaGroup ) ;
         return pSDB->createReplicaGroup ( pName, group ) ;
      }

      INT32 removeReplicaGroup ( const CHAR *pName )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->removeReplicaGroup ( pName ) ;
      }

      INT32 createReplicaCataGroup (  const CHAR *pHostName,
                               const CHAR *pServiceName,
                               const CHAR *pDatabasePath,
                               const bson::BSONObj &configure )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->createReplicaCataGroup ( pHostName, pServiceName,
                                        pDatabasePath, configure ) ;
      }

      INT32 activateReplicaGroup ( const CHAR *pName, _sdbReplicaGroup **replicaGroup )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->activateReplicaGroup ( pName, replicaGroup ) ;
      }

      INT32 activateReplicaGroup ( const CHAR *pName, sdbReplicaGroup &replicaGroup )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( replicaGroup.pReplicaGroup ) ;
         return pSDB->activateReplicaGroup ( pName, replicaGroup ) ;
      }

      INT32 execUpdate( const CHAR *sql, bson::BSONObj *pResult = NULL )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->execUpdate( sql, pResult ) ;
      }

      /* \fn INT32 exec( const CHAR *sql,
                        _sdbCursor **result )
          \brief Executing SQL command.
          \param [in] sql The SQL command.
          \param [out] result The return cursor handle of matching documents.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 exec( const CHAR *sql,
                  _sdbCursor **result )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->exec( sql, result ) ;
      }

      INT32 exec( const CHAR *sql,
                  sdbCursor &cursor )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->exec( sql, cursor ) ;
      }

      INT32 transactionBegin()
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->transactionBegin() ;
      }

      INT32 transactionCommit( const bson::BSONObj &hint = _sdbStaticObject )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->transactionCommit( hint ) ;
      }

      INT32 transactionRollback()
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->transactionRollback() ;
      }
      INT32 flushConfigure( const bson::BSONObj &options )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->flushConfigure( options ) ;
      }

      INT32 crtJSProcedure ( const CHAR *code )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->crtJSProcedure( code ) ;
      }

      INT32 rmProcedure( const CHAR *spName )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->rmProcedure( spName ) ;
      }

      INT32 listProcedures( _sdbCursor **cursor, const bson::BSONObj &condition )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->listProcedures( cursor, condition ) ;
      }

      INT32 listProcedures( sdbCursor &cursor, const bson::BSONObj &condition )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->listProcedures( cursor, condition ) ;
      }

     INT32 evalJS( const CHAR *code,
                   SDB_SPD_RES_TYPE &type,
                   _sdbCursor **cursor,
                   bson::BSONObj &errmsg )
     {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->evalJS( code, type, cursor, errmsg ) ;
     }

     INT32 evalJS( const CHAR *code, SDB_SPD_RES_TYPE &type,
                   sdbCursor &cursor,
                   bson::BSONObj &errmsg )
     {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->evalJS( code, type, cursor, errmsg ) ;
     }

      INT32 backupOffline ( const bson::BSONObj &options)
      {
         return backup( options ) ;
      }

      INT32 backup ( const bson::BSONObj &options)
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->backup( options ) ;
      }


      INT32 listBackup ( _sdbCursor **cursor,
                              const bson::BSONObj &options,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selector = _sdbStaticObject,
                              const bson::BSONObj &orderBy = _sdbStaticObject)
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->listBackup( cursor, options, condition, selector, orderBy ) ;
      }

      INT32 listBackup ( sdbCursor &cursor,
                              const bson::BSONObj &options,
                              const bson::BSONObj &condition = _sdbStaticObject,
                              const bson::BSONObj &selector = _sdbStaticObject,
                              const bson::BSONObj &orderBy = _sdbStaticObject)
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->listBackup( cursor, options, condition, selector, orderBy ) ;
      }

      INT32 removeBackup ( const bson::BSONObj &options)
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->removeBackup( options ) ;
      }

      INT32 listTasks ( _sdbCursor **cursor,
                        const bson::BSONObj &condition = _sdbStaticObject,
                        const bson::BSONObj &selector = _sdbStaticObject,
                        const bson::BSONObj &orderBy = _sdbStaticObject,
                        const bson::BSONObj &hint = _sdbStaticObject)
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->listTasks ( cursor,
                                  condition,
                                  selector,
                                  orderBy,
                                  hint ) ;
      }
      INT32 listTasks ( sdbCursor &cursor,
                        const bson::BSONObj &condition = _sdbStaticObject,
                        const bson::BSONObj &selector = _sdbStaticObject,
                        const bson::BSONObj &orderBy = _sdbStaticObject,
                        const bson::BSONObj &hint = _sdbStaticObject)
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->listTasks ( cursor,
                                  condition,
                                  selector,
                                  orderBy,
                                  hint ) ;
      }

      INT32 waitTasks ( const SINT64 *taskIDs,
                        SINT32 num )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->waitTasks ( taskIDs,
                                  num ) ;
      }

      INT32 cancelTask ( SINT64 taskID,
                         BOOLEAN isAsync )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->cancelTask ( taskID,
                                   isAsync ) ;
      }

      INT32 setSessionAttr ( const bson::BSONObj &options = _sdbStaticObject )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->setSessionAttr ( options ) ;
      }

      INT32 getSessionAttr ( bson::BSONObj & result,
                             BOOLEAN useCache = TRUE )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getSessionAttr( result, useCache ) ;
      }

      INT32 closeAllCursors ()
      {
         return interrupt() ;
      }

      INT32 interrupt()
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->interrupt () ;
      }

      INT32 interruptOperation()
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->interruptOperation () ;
      }

      INT32 isValid ( BOOLEAN *result )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->isValid ( result ) ;
      }

      BOOLEAN isValid ()
      {
         if ( !pSDB )
         {
            return FALSE ;
         }
         return pSDB->isValid () ;
      }

      BOOLEAN isClosed()
      {
         if (!pSDB)
         {
            return TRUE ;
         }
         return pSDB->isClosed() ;
      }

      INT32 createDomain ( const CHAR *pDomainName,
                           const bson::BSONObj &options,
                           sdbDomain &domain )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( domain.pDomain ) ;
         return pSDB->createDomain ( pDomainName, options, domain ) ;
      }

      INT32 createDomain ( const CHAR *pDomainName,
                           const bson::BSONObj &options,
                           _sdbDomain **domain )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->createDomain ( pDomainName, options, domain ) ;
      }

      INT32 dropDomain ( const CHAR *pDomainName )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->dropDomain ( pDomainName ) ;
      }

      INT32 getDomain ( const CHAR *pDomainName,
                        _sdbDomain **domain )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getDomain ( pDomainName, domain ) ;
      }

      INT32 getDomain ( const CHAR *pDomainName,
                        sdbDomain &domain )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( domain.pDomain ) ;
         return pSDB->getDomain ( pDomainName, domain ) ;
      }

      INT32 listDomains ( _sdbCursor **cursor,
                          const bson::BSONObj &condition = _sdbStaticObject,
                          const bson::BSONObj &selector = _sdbStaticObject,
                          const bson::BSONObj &orderBy = _sdbStaticObject,
                          const bson::BSONObj &hint = _sdbStaticObject )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->listDomains ( cursor, condition, selector, orderBy, hint ) ;
      }

      INT32 listDomains ( sdbCursor &cursor,
                          const bson::BSONObj &condition = _sdbStaticObject,
                          const bson::BSONObj &selector = _sdbStaticObject,
                          const bson::BSONObj &orderBy = _sdbStaticObject,
                          const bson::BSONObj &hint = _sdbStaticObject )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->listDomains ( cursor, condition, selector, orderBy, hint ) ;
      }

      /* \fn INT32 getDC( sdbDataCenter &dc )
          \brief Get current data center.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getDC( sdbDataCenter &dc )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( dc.pDC ) ;
         return pSDB->getDC ( dc ) ;
      }

      /* \fn INT32 getDC( _sdbDataCenter **dc )
          \brief Get current data center.
          \retval SDB_OK Operation Success
          \retval Others Operation Fail
      */
      INT32 getDC( _sdbDataCenter **dc )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getDC ( dc ) ;
      }

      UINT64 getLastAliveTime() const { return pSDB->getLastAliveTime(); }

      INT32 syncDB( const bson::BSONObj &options = _sdbStaticObject )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->syncDB ( options ) ;
      }

      INT32 analyze ( const bson::BSONObj &options = _sdbStaticObject )
      {
         if ( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->analyze ( options ) ;
      }

      INT32 forceSession( SINT64 sessionID,
                          const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->forceSession( sessionID, options ) ;
      }

      INT32 forceStepUp( const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->forceStepUp( options ) ;
      }

      INT32 invalidateCache( const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->invalidateCache( options ) ;
      }

      INT32 reloadConfig( const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->reloadConfig( options ) ;
      }

      INT32 updateConfig( const bson::BSONObj &configs = _sdbStaticObject,
                          const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->updateConfig( configs, options ) ;
      }

      INT32 deleteConfig( const bson::BSONObj &configs = _sdbStaticObject,
                          const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->deleteConfig( configs, options ) ;
      }

      INT32 setPDLevel( INT32 level,
                        const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->setPDLevel( level, options ) ;
      }

      INT32 msg( const CHAR* msg )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->msg( msg ) ;
      }

      INT32 loadCS( const CHAR* csName,
                    const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->loadCS( csName, options ) ;
      }

      INT32 unloadCS( const CHAR* csName,
                      const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->unloadCS( csName, options ) ;
      }

      INT32 traceStart( UINT32 traceBufferSize,
                        const CHAR* component = NULL,
                        const CHAR* breakpoint = NULL,
                        const vector<UINT32> &tidVec = _sdbStaticUINT32Vec )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->traceStart( traceBufferSize, component,
                                  breakpoint, tidVec ) ;
      }

      INT32 traceStart( UINT32 traceBufferSize,
                        const bson::BSONObj &options )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->traceStart( traceBufferSize, options ) ;
      }

      INT32 traceStop( const CHAR* dumpFileName )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->traceStop( dumpFileName ) ;
      }

      INT32 traceResume()
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->traceResume() ;
      }

      INT32 traceStatus( sdbCursor& cursor )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         RELEASE_INNER_HANDLE( cursor.pCursor ) ;
         return pSDB->traceStatus( cursor ) ;
      }

      INT32 traceStatus( _sdbCursor** cursor )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->traceStatus( cursor ) ;
      }

      INT32 renameCollectionSpace( const CHAR* oldName,
                                   const CHAR* newName,
                                   const bson::BSONObj &options = _sdbStaticObject )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->renameCollectionSpace( oldName, newName, options ) ;
      }

      INT32 getLastErrorObj( bson::BSONObj &errObj )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getLastErrorObj( errObj ) ;
      }

      void cleanLastErrorObj()
      {
         if( !pSDB )
         {
            return ;
         }
         return pSDB->cleanLastErrorObj() ;
      }

      INT32 getLastResultObj( bson::BSONObj &result,
                              BOOLEAN getOwned = FALSE ) const
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getLastResultObj( result, getOwned ) ;
      }

      INT32 createSequence( const CHAR *pSequenceName,
                            const bson::BSONObj &options,
                            _sdbSequence **sequence )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->createSequence( pSequenceName, options, sequence ) ;
      }

      INT32 createSequence( const CHAR *pSequenceName,
                            const bson::BSONObj &options,
                            sdbSequence &sequence )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->createSequence( pSequenceName, options, sequence ) ;
      }

      INT32 createSequence( const CHAR *pSequenceName,
                            sdbSequence &sequence )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->createSequence( pSequenceName, sequence ) ;
      }

      INT32 getSequence( const CHAR *pSequenceName,
                         _sdbSequence **sequence )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getSequence( pSequenceName, sequence ) ;
      }

      INT32 getSequence( const CHAR *pSequenceName,
                         sdbSequence &sequence )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->getSequence( pSequenceName, sequence ) ;
      }

      INT32 renameSequence( const CHAR *pOldName, const CHAR *pNewName )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->renameSequence( pOldName, pNewName ) ;
      }

      INT32 dropSequence( const CHAR *pSequenceName )
      {
         if( !pSDB )
         {
            return SDB_NOT_CONNECTED ;
         }
         return pSDB->dropSequence( pSequenceName ) ;
      }
   } ;

   typedef class sdb sdb ;

   SDB_EXPORT INT32 initClient( sdbClientConf* config ) ;

}

#endif