db_mongoc.h

Go to the documentation of this file.

 
#ifndef CCGL_DB_MONGOC_H
#define CCGL_DB_MONGOC_H
#ifdef USE_MONGODB
 
#include <vector>
#include <map>
#include <iostream>
 
#include <mongoc.h>
 
#include "basic.h"
 
using std::string;
using std::vector;
using std::map;
using std::cout;
using std::endl;
 
namespace ccgl {
namespace db_mongoc {
class MongoGridFs;
 
class MongoClient: NotCopyable {
public:
    MongoClient(const char* host, vuint16_t port);
 
    MongoClient(mongoc_client_t* conn);
 
    static MongoClient* Init(const char* host, vuint16_t port);
 
    ~MongoClient();
 
    void Destroy();
 
    mongoc_client_t* GetConn() { return conn_; }
 
    mongoc_database_t* GetDatabase(string const& dbname);
 
    mongoc_collection_t* GetCollection(string const& dbname, string const& collectionname);
 
    mongoc_gridfs_t* GetGridFs(string const& dbname, string const& gfsname);
 
    MongoGridFs* GridFs(string const& dbname, string const& gfsname);
 
    void GetDatabaseNames(vector<string>& dbnames);
 
    void GetCollectionNames(string const& dbname, vector<string>& collnames);
 
    void GetGridFsFileNames(string const& dbname, string const& gfsname, vector<string>& gfs_exists);
 
private:
    const char* host_;      
    vuint16_t port_;        
    mongoc_client_t* conn_; 
};
 
class MongoDatabase: NotCopyable {
public:
    explicit MongoDatabase(mongoc_database_t* db);
 
    MongoDatabase(mongoc_client_t* conn, string& dbname);
 
    ~MongoDatabase();
 
    void GetCollectionNames(vector<string>& collnames);
 
private:
    mongoc_database_t* db_; 
    string dbname_;         
};
 
class MongoCollection {
public:
    explicit MongoCollection(mongoc_collection_t* coll);
 
    ~MongoCollection();
 
    mongoc_cursor_t* ExecuteQuery(const bson_t* b, const bson_t* opts = nullptr);
 
    vint QueryRecordsCount();
private:
    mongoc_collection_t* collection_; 
};
 
class MongoGridFs {
public:
    explicit MongoGridFs(mongoc_gridfs_t* gfs = NULL);
 
    ~MongoGridFs();
 
    mongoc_gridfs_t* GetGridFs() { return gfs_; }
 
    mongoc_gridfs_file_t* GetFile(string const& gfilename, mongoc_gridfs_t* gfs = NULL,
                                  const STRING_MAP& opts = STRING_MAP());
 
    bool RemoveFile(string const& gfilename, mongoc_gridfs_t* gfs = NULL,
                    STRING_MAP opts = STRING_MAP());
 
    void GetFileNames(vector<string>& files_existed, mongoc_gridfs_t* gfs = NULL,
                    STRING_MAP opts = STRING_MAP());
 
    bson_t* GetFileMetadata(string const& gfilename, mongoc_gridfs_t* gfs = NULL,
                            STRING_MAP opts = STRING_MAP());
 
    bool GetStreamData(string const& gfilename, char*& databuf, vint& datalength,
                       mongoc_gridfs_t* gfs = NULL,
                       const STRING_MAP* opts = nullptr);
 
    bool WriteStreamData(const string& gfilename, char*& buf, vint length,
                         const bson_t* p, mongoc_gridfs_t* gfs = NULL);
 
private:
    mongoc_gridfs_t* gfs_; 
};
 
void AppendStringOptionsToBson(bson_t* bson_opts, const STRING_MAP& opts,
                               const string& prefix = string());
 
template <typename T>
bool GetNumericFromBsonIterator(bson_iter_t* iter, T& numericvalue) {
    const bson_value_t* vv = bson_iter_value(iter);
    if (vv->value_type == BSON_TYPE_INT32) {
        numericvalue = static_cast<T>(vv->value.v_int32);
    } else if (vv->value_type == BSON_TYPE_INT64) {
        numericvalue = static_cast<T>(vv->value.v_int64);
    } else if (vv->value_type == BSON_TYPE_DOUBLE) {
        numericvalue = static_cast<T>(vv->value.v_double);
    } else if (vv->value_type == BSON_TYPE_UTF8) {
        string tmp = vv->value.v_utf8.str;
        if (tmp.find_first_of("0123456789") == string::npos) {
            cout << "bson iterator isn't or not contains a numeric value." << endl;
            return false;
        }
        char* end = nullptr;
        numericvalue = static_cast<T>(strtod(tmp.c_str(), &end));
    } else {
        cout << "bson iterator isn't or not contains a numeric value." << endl;
        return false;
    }
    return true;
}
 
template<typename T>
void GetVectorFromBsonIter(bson_iter_t* iter, vector<T>& out){
    const bson_value_t* vv = bson_iter_value(iter);
    T value;
    if (vv->value_type == BSON_TYPE_ARRAY) {
        bson_iter_t sub_iter;
        bson_iter_recurse(iter, &sub_iter);
        while (bson_iter_next(&sub_iter)) {
            const bson_value_t* sub_vv = bson_iter_value(&sub_iter);
            if (sub_vv->value_type == BSON_TYPE_INT32) {
                out.emplace_back(CVT_INT(sub_vv->value.v_int32));
            } else if (sub_vv->value_type == BSON_TYPE_INT64) {
                out.emplace_back(CVT_INT(sub_vv->value.v_int64));
            } else if (sub_vv->value_type == BSON_TYPE_DOUBLE) {
                out.emplace_back(sub_vv->value.v_double);
            } else {
                StatusMessage("Failed in get vector value in the inner loop of GetVectorFromBsonIter.");
            }
        }
    }
    else if (GetNumericFromBsonIterator(iter, value)){
        out.emplace_back(value);
    }
    else {
        StatusMessage("Failed in get vector value in the outer loop of GetVectorFromBsonIter.");
    }
}
 
template<typename T>
void GetVectorVectorFromBsonIter(bson_iter_t* iter, vector<vector<T>>& out){
    const bson_value_t* vv = bson_iter_value(iter);
    T value;
    if (vv->value_type == BSON_TYPE_ARRAY) {
        bson_iter_t sub_iter;
        bson_iter_recurse(iter, &sub_iter);
        while (bson_iter_next(&sub_iter)) {
            vector<T> tmp;
            GetVectorFromBsonIter(&sub_iter, tmp);
            out.emplace_back(tmp);
        }
    }
    else if (GetNumericFromBsonIterator(iter, value)) {
        vector<T> tmp;
        tmp.emplace_back(value);
        out.emplace_back(tmp);
    }
    else {
        StatusMessage("Failed in get vector value.");
    }
}
 
template <typename T>
bool GetNumericFromBson(bson_t* bmeta, const char* key, T& numericvalue) {
    bson_iter_t iter;
    if (bson_iter_init(&iter, bmeta) && bson_iter_find(&iter, key)) {
        return GetNumericFromBsonIterator(&iter, numericvalue);
    }
    StatusMessage(("WARNING: GetNumericFromBson, Failed in get value of: " + string(key) + "\n").c_str());
    return false;
}
 
string GetStringFromBsonIterator(bson_iter_t* iter);
 
string GetStringFromBson(bson_t* bmeta, const char* key);
 
bool GetBoolFromBsonIterator(bson_iter_t* iter);
 
bool GetBoolFromBson(bson_t* bmeta, const char* key);
 
time_t GetDatetimeFromBsonIterator(bson_iter_t* iter);
 
time_t GetDatetimeFromBson(bson_t* bmeta, const char* key);
} /* namespace: db_mongoc */
} /* namespace: ccgl */
 
#endif /* USE_MONGODB */
#endif /* CCGL_DB_MONGOC_H */