query_options.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *   Copyright 2020-Present Couchbase, Inc.
 *
 *   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.
 */
 
#pragma once
 
#include <couchbase/common_options.hxx>
#include <couchbase/error.hxx>
#include <couchbase/mutation_state.hxx>
#include <couchbase/query_profile.hxx>
#include <couchbase/query_result.hxx>
#include <couchbase/query_scan_consistency.hxx>
#include <couchbase/query_stream_result.hxx>
 
#include <chrono>
#include <functional>
#include <map>
#include <optional>
#include <vector>
 
namespace couchbase
{
namespace codec
{
class tao_json_serializer;
} // namespace codec

struct query_options : public common_options<query_options> {
  struct built : public common_options<query_options>::built {
    const bool adhoc;
    const bool metrics;
    const bool readonly;
    const bool flex_index;
    const bool preserve_expiry;
    std::optional<bool> use_replica;
    std::optional<std::uint64_t> max_parallelism;
    std::optional<std::uint64_t> scan_cap;
    std::optional<std::chrono::milliseconds> scan_wait;
    std::optional<std::uint64_t> pipeline_batch;
    std::optional<std::uint64_t> pipeline_cap;
    std::optional<std::string> client_context_id;
    std::optional<query_scan_consistency> scan_consistency;
    std::vector<mutation_token> mutation_state;
    std::optional<query_profile> profile;
    std::vector<codec::binary> positional_parameters;
    std::map<std::string, codec::binary, std::less<>> named_parameters;
    std::map<std::string, codec::binary, std::less<>> raw;
  };

  [[nodiscard]] auto build() const -> built
  {
    return {
      build_common_options(),
      adhoc_,
      metrics_,
      readonly_,
      flex_index_,
      preserve_expiry_,
      use_replica_,
      max_parallelism_,
      scan_cap_,
      scan_wait_,
      pipeline_batch_,
      pipeline_cap_,
      client_context_id_,
      scan_consistency_,
      mutation_state_,
      profile_,
      positional_parameters_,
      named_parameters_,
      raw_,
    };
  }

  auto adhoc(bool adhoc) -> query_options&
  {
    adhoc_ = adhoc;
    return self();
  }

  auto metrics(bool metrics) -> query_options&
  {
    metrics_ = metrics;
    return self();
  }

  auto profile(query_profile profile) -> query_options&
  {
    profile_ = profile;
    return self();
  }

  auto readonly(bool readonly) -> query_options&
  {
    readonly_ = readonly;
    return self();
  }

  auto flex_index(bool flex_index) -> query_options&
  {
    flex_index_ = flex_index;
    return self();
  }

  auto preserve_expiry(bool preserve_expiry) -> query_options&
  {
    preserve_expiry_ = preserve_expiry;
    return self();
  }

  auto use_replica(bool use_replica) -> query_options&
  {
    use_replica_ = use_replica;
    return self();
  }

  auto max_parallelism(std::uint64_t max_parallelism) -> query_options&
  {
    max_parallelism_ = max_parallelism;
    return self();
  }

  auto scan_cap(std::uint64_t scan_cap) -> query_options&
  {
    scan_cap_ = scan_cap;
    return self();
  }

  auto scan_wait(std::chrono::milliseconds wait) -> query_options&
  {
    if (scan_consistency_ == query_scan_consistency::not_bounded) {
      scan_wait_.reset();
    } else {
      scan_wait_ = wait;
    }
    return self();
  }

  auto pipeline_batch(std::uint64_t pipeline_batch) -> query_options&
  {
    pipeline_batch_ = pipeline_batch;
    return self();
  }

  auto pipeline_cap(std::uint64_t pipeline_cap) -> query_options&
  {
    pipeline_cap_ = pipeline_cap;
    return self();
  }

  auto client_context_id(std::string client_context_id) -> query_options&
  {
    if (client_context_id.empty()) {
      client_context_id_.reset();
    } else {
      client_context_id_ = std::move(client_context_id);
    }
    return self();
  }

  auto scan_consistency(query_scan_consistency scan_consistency) -> query_options&
  {
    scan_consistency_ = scan_consistency;
    mutation_state_.clear();
    return self();
  }

  auto consistent_with(const mutation_state& state) -> query_options&
  {
    mutation_state_ = state.tokens();
    scan_consistency_.reset();
    return self();
  }

  template<typename Serializer = codec::tao_json_serializer,
           typename Value,
           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
  auto raw(std::string name, const Value& value) -> query_options&
  {
    raw_[std::move(name)] = std::move(Serializer::template serialize<const Value&>(value));
    return self();
  }

  template<typename Serializer = codec::tao_json_serializer,
           typename... Parameters,
           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
  auto positional_parameters(const Parameters&... parameters) -> query_options&
  {
    positional_parameters_.clear();
    encode_positional_parameters<Serializer>(parameters...);
    return self();
  }

  template<typename Serializer = codec::tao_json_serializer,
           typename... Parameters,
           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
  auto named_parameters(const Parameters&... parameters) -> query_options&
  {
    named_parameters_.clear();
    encode_named_parameters<Serializer>(parameters...);
    return self();
  }

  template<typename Serializer = codec::tao_json_serializer,
           typename Parameter,
           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
  auto add_positional_parameter(const Parameter& parameter) -> query_options&
  {
    encode_positional_parameters<Serializer>(parameter);
    return self();
  }

  template<typename Serializer = codec::tao_json_serializer,
           typename Value,
           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
  auto add_named_parameter(const std::string& name, const Value& value) -> query_options&
  {
    encode_named_parameters<Serializer>(std::make_pair(name, value));
    return self();
  }

  auto clear_positional_parameters() -> query_options&
  {
    positional_parameters_.clear();
    return self();
  }

  auto clear_named_parameters() -> query_options&
  {
    named_parameters_.clear();
    return self();
  }

  auto encoded_raw_options(std::map<std::string, codec::binary, std::less<>> options)
    -> query_options&
  {
    raw_ = std::move(options);
    return self();
  }

  auto encoded_positional_parameters(std::vector<codec::binary> parameters) -> query_options&
  {
    positional_parameters_ = std::move(parameters);
    return self();
  }

  auto encoded_named_parameters(std::map<std::string, codec::binary, std::less<>> parameters)
    -> query_options&
  {
    named_parameters_ = std::move(parameters);
    return self();
  }
 
private:
  template<typename Serializer = codec::tao_json_serializer,
           typename Parameter,
           typename... Rest,
           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
  void encode_positional_parameters(const Parameter& parameter, Rest... args)
  {
    positional_parameters_.emplace_back(
      std::move(Serializer::template serialize<const Parameter&>(parameter)));
    if constexpr (sizeof...(args) > 0) {
      encode_positional_parameters<Serializer>(args...);
    }
  }
 
  template<typename Serializer = codec::tao_json_serializer,
           typename Name,
           typename Parameter,
           typename... Rest,
           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
  void encode_named_parameters(const std::pair<Name, Parameter>& parameter, Rest... args)
  {
    named_parameters_[parameter.first] =
      std::move(Serializer::template serialize<Parameter>(parameter.second));
    if constexpr (sizeof...(args) > 0) {
      encode_named_parameters<Serializer>(args...);
    }
  }
 
  bool adhoc_{ true };
  bool metrics_{ false };
  bool readonly_{ false };
  bool flex_index_{ false };
  bool preserve_expiry_{ false };
  std::optional<bool> use_replica_{};
  std::optional<std::uint64_t> max_parallelism_{};
  std::optional<std::uint64_t> scan_cap_{};
  std::optional<std::uint64_t> pipeline_batch_{};
  std::optional<std::uint64_t> pipeline_cap_{};
  std::optional<std::string> client_context_id_{};
  std::optional<std::chrono::milliseconds> scan_wait_{};
  std::optional<query_scan_consistency> scan_consistency_{};
  std::vector<mutation_token> mutation_state_{};
  std::optional<query_profile> profile_{};
  std::vector<codec::binary> positional_parameters_{};
  std::map<std::string, codec::binary, std::less<>> raw_{};
  std::map<std::string, codec::binary, std::less<>> named_parameters_{};
};

using query_handler = std::function<void(error, query_result)>;

using query_stream_handler = std::function<void(error, query_stream_result)>;
} // namespace couchbase