nb_query.h

説明を見る。

/*
 * COPYRIGHT (C) 2017 NEC CORPORATION
 *
 * ALL RIGHTS RESERVED BY NEC CORPORATION,  THIS PROGRAM
 * MUST BE USED SOLELY FOR THE PURPOSE FOR WHICH IT WAS
 * FURNISHED BY NEC CORPORATION,  NO PART OF THIS PROGRAM
 * MAY BE REPRODUCED OR DISCLOSED TO OTHERS,  IN ANY FORM
 * WITHOUT THE PRIOR WRITTEN PERMISSION OF NEC CORPORATION.
 *
 * NEC CONFIDENTIAL AND PROPRIETARY
 */

#ifndef NECBAAS_NBQUERY_H
#define NECBAAS_NBQUERY_H

#include <string>
#include <vector>
#include <map>
#include <typeinfo>
#include <json/json.h>
#include "necbaas/nb_json_object.h"
#include "necbaas/nb_json_array.h"

namespace necbaas {

enum class NbReadPreference {
    PRIMARY,             
    SECONDARY_PREFERRED, 
};

class NbQuery {
   public:
    NbQuery();

    ~NbQuery();

    template <typename T>
    NbQuery &EqualTo(const std::string &key, T value) {
        if (!key.empty()) {
            if (typeid(T) == typeid(NbJsonObject)) {
                return AddSimpleOp("$eq", key, value);
            } else {
                return AddSimpleOp("", key, value);
            }
        }
        return *this;
    }

    template <typename T>
    NbQuery &LessThan(const std::string &key, T value) {
        return AddSimpleOp("$lt", key, value);
    }

    template <typename T>
    NbQuery &LessThanOrEqual(const std::string &key, T value) {
        return AddSimpleOp("$lte", key, value);
    }

    template <typename T>
    NbQuery &GreaterThan(const std::string &key, T value) {
        return AddSimpleOp("$gt", key, value);
    }

    template <typename T>
    NbQuery &GreaterThanOrEqual(const std::string &key, T value) {
        return AddSimpleOp("$gte", key, value);
    }

    template <typename T>
    NbQuery &NotEquals(const std::string &key, T value) {
        return AddSimpleOp("$ne", key, value);
    }

    NbQuery &In(const std::string &key, const NbJsonArray &array);

    NbQuery &All(const std::string &key, const NbJsonArray &array);

    NbQuery &Regex(const std::string &key, const std::string &regexp, const std::string &options = "");

    NbQuery &Exists(const std::string &key);

    NbQuery &NotExists(const std::string &key);

    NbQuery &Not(const std::string &key);

    NbQuery &Or(const std::vector<NbQuery> queries);

    NbQuery &And(const std::vector<NbQuery> queries);

    NbQuery &OrderBy(const std::vector<std::string> &order);

    NbQuery &Skip(int skip);

    NbQuery &Limit(int limit);

    NbQuery &DeleteMark(bool delete_mark);

    NbQuery &Projection(const std::map<std::string, bool> &projection);

    NbQuery &ReadPreference(NbReadPreference read_preference);

    NbQuery &Timeout(int timeout);

    std::string GetConditionsString() const;

    std::string GetOrderString() const;

    std::string GetSkipString() const;

    std::string GetLimitString() const;

    std::string GetDeleteMarkString() const;

    std::string GetProjectionString() const;

    std::string GetReadPreferenceString() const;

    std::string GetTimeoutString() const;

    const Json::Value &GetConditions() const;

   private:
    const static int kLimitDefault; 
    Json::Value conditions_;                   
    std::vector<std::string> order_{};         
    int skip_{0};                              
    int limit_{kLimitDefault};                 
    bool delete_mark_{false};                  
    std::map<std::string, bool> projection_{}; 
    NbReadPreference read_preference_{NbReadPreference::PRIMARY}; 
    int timeout_{0}; 
    template <typename T>
    NbQuery &AddSimpleOpPrimitive(const std::string &op, const std::string &key, T value) {
        if (!key.empty()) {
            if (op.empty()) {
                conditions_[key] = value;
            } else {
                Json::Value json;
                json[op] = value;
                conditions_[key] = json;
            }
        }
        return *this;
    }

    template <typename T>
    NbQuery &AddSimpleOpJson(const std::string &op, const std::string &key, T value) {
        if (!key.empty()) {
            if (op.empty()) {
                conditions_[key] = value.GetSubstitutableValue();
            } else {
                Json::Value json;
                json[op] = value.GetSubstitutableValue();
                conditions_[key] = json;
            }
        }
        return *this;
    }

    NbQuery &AddSimpleOp(const std::string &op, const std::string &key, int value);

    NbQuery &AddSimpleOp(const std::string &op, const std::string &key, int64_t value);

    NbQuery &AddSimpleOp(const std::string &op, const std::string &key, double value);

    NbQuery &AddSimpleOp(const std::string &op, const std::string &key, bool value);

    NbQuery &AddSimpleOp(const std::string &op, const std::string &key, const std::string &value);

    NbQuery &AddSimpleOp(const std::string &op, const std::string &key, const NbJsonObject &value);

    NbQuery &AddSimpleOp(const std::string &op, const std::string &key, const NbJsonArray &value);

    NbQuery &ConcatQueries(const std::string &op, std::vector<NbQuery> queries);
};
}  // namespace necbaas
#endif  // NECBAAS_NBQUERY_H