mongodb 常用接口封装测试

就项目中使用mongodb最常用的接口封装了一下,在初始化连接时可设置支持多线程,使用的是mongodb内部连接池,注意未做异常处理:

// mongodb_test.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "DBCore.h"
#include <boost/timer.hpp>

using namespace mongo;

int _tmain(int argc, _TCHAR* argv[])
{
    DBCore db;
    std::string dbname("testdb");
    db.init(std::string("127.0.0.1:27017"), dbname);
    db.ensure_index(dbname, BSON("_id"<<1), "_index_id");

    int tcont = 1000;
    printf("test count: %d\n", tcont);
    boost::timer tt;

    for (int i = 0; i<tcont;i++)
    {
        db.insert(dbname, BSON("_id"<< i<< "_str"<<"test"));
    }

    printf("insert time: %lf(s)\n", tt.elapsed());

    tt.restart();
    for (int i = 0; i<tcont;i++)
    {
        db.update(dbname, BSON("_id"<<i), BSON("_str"<<"abcd"));
    }
    
    printf("update time: %lf(s)\n", tt.elapsed());
    
    
    tt.restart();
    for (int i = 0; i<tcont;i++)
    {
        db.find(dbname, BSON("_id"<< i));
    }

    printf("find time: %lf(s)\n", tt.elapsed());

    tt.restart();
    for (int i = 0; i<tcont;i++)
    {
        db.remove(dbname, BSON("_id"<< i));
    }

    printf("remove time: %lf(s)\n", tt.elapsed());

    getchar();

    return 0;
}

#pragma once

#include <mongo/db/jsobj.h>

#include <boost/smart_ptr.hpp>
#include <string>
#include <vector>

#ifdef _DEBUG
#pragma comment(lib, "mongodb_driver_d.lib")
#else
#pragma comment(lib, "mongodb_driver.lib")
#endif // DEBUG

#pragma comment(lib, "dbghelp.lib")

namespace mongo
{
    class ScopedDbConnection;
}

class DBCore
{
public:
    DBCore(void);
    ~DBCore(void);

    void init(std::string& _db_addr, std::string& _db_name, bool _thread = false);

    std::string insert(const std::string& table_name, const mongo::BSONObj& bObj);

    mongo::BSONObj find(const std::string& table_name, const mongo::BSONObj& bObj, const mongo::BSONObj* bField = nullptr);

    void find(std::vector<mongo::BSONObj>& vec,const std::string& table_name, const mongo::BSONObj& bObj, const mongo::BSONObj* bField = nullptr,
        int toReturn = 0, int toSkip = 0, const mongo::BSONObj* bSort = nullptr);

    std::string update(const std::string& table_name, const mongo::BSONObj& bObj, const mongo::BSONObj& bUp, bool upsert = true, bool multi = false);
    
    std::string remove(const std::string& table_name, const mongo::BSONObj& bObj, bool justone = false);

    bool ensure_index(const std::string& table_name, const mongo::BSONObj& bKey, const std::string& index_name, bool unique = false);

private:
    boost::shared_ptr<mongo::ScopedDbConnection> get_conn(bool _thread = false);

    std::string db_name;
    std::string db_addr;
    std::string db_err;
    bool b_init;
    bool b_thread;
    boost::shared_ptr<mongo::ScopedDbConnection> m_conn;
};

#include "stdafx.h"
#include "DBCore.h"

#include <mongo/client/connpool.h>
#include <boost/bind.hpp>

using namespace mongo;
using namespace std;

DBCore::DBCore(void)
{
    b_init = false;
    db_err = "db not init!";
    b_thread = false;
    m_conn = nullptr;
}


DBCore::~DBCore(void)
{
}


void release_conn(ScopedDbConnection* dbconn)
{
    if(dbconn)
    {
        dbconn->done();
        delete dbconn;
        dbconn = nullptr;
    }
}

void DBCore::init(string& _db_addr, string& _db_name, bool _thread)
{
    db_addr = _db_addr;
    db_name = _db_name + ".";
    db_err = "db null conn!";    
    b_thread = _thread;
    b_init = true;

    if(!b_thread)
        m_conn = get_conn(true);
}

string DBCore::insert(const string& table_name, const BSONObj& bObj)
{
    auto pcon = get_conn();
    if(pcon && pcon->get())
    {
        pcon->get()->insert(db_name+table_name, bObj);
        return pcon->get()->getLastError();
    }
    return db_err;
}

BSONObj DBCore::find(const string& table_name, const BSONObj& bObj, const BSONObj* bField)
{
    auto pcon = get_conn();
    BSONObj b;
    if(pcon && pcon->get())
    {
        auto ret = pcon->get()->query(db_name+table_name, Query(bObj), 1, 0, bField);
        if(ret->more())
        {
            b = ret->nextSafe().copy();
        }
        ret.reset();
    }
    return b;
}

void DBCore::find(vector<BSONObj>& vec,const string& table_name, const BSONObj& bObj, const BSONObj* bField,
                  int toReturn, int toSkip, const BSONObj* bSort)
{
    auto pcon = get_conn();
    if(pcon && pcon->get())
    {
        Query q(bObj);
        if(bSort)
        {
            q = q.sort(*bSort);
        }
        vec.reserve(toReturn);
        auto ret = pcon->get()->query(db_name+table_name, q, toReturn, toSkip, bField);
        while(ret->more())
        {
            vec.push_back(ret->nextSafe().copy());
        }
        ret.reset();
    }
}

string DBCore::update(const string& table_name, const BSONObj& bObj, const BSONObj& bUp, bool upsert, bool multi)
{
    auto pcon = get_conn();
    if(pcon && pcon->get())
    {
        pcon->get()->update(db_name+table_name, Query(bObj), bUp, upsert, multi);
        return pcon->get()->getLastError();
    }
    return db_err;
}

string DBCore::remove(const string& table_name, const BSONObj& bObj, bool justone)
{
    auto pcon = get_conn();
    if(pcon && pcon->get())
    {
        pcon->get()->remove(db_name+table_name, Query(bObj), justone);
        return pcon->get()->getLastError();
    }
    return db_err;
}

bool DBCore::ensure_index(const string& table_name, const BSONObj& bKey, const string& index_name, bool unique)
{
    auto pcon = get_conn();
    if(pcon && pcon->get())
    {
        return pcon->get()->ensureIndex(db_name+table_name, bKey, unique, index_name);
    }
    return false;
}

boost::shared_ptr<ScopedDbConnection> DBCore::get_conn(bool _thread)
{
    if(!b_init)
        return nullptr;

    if(b_thread || _thread)
        return boost::shared_ptr<ScopedDbConnection>(ScopedDbConnection::getScopedDbConnection(db_addr), boost::bind(&release_conn, _1));
    
    return m_conn;
}