Method handle_range_scan_op

src/connection.cxx:478–590

}

PyObject*
Connection::handle_range_scan_op(PyObject* kwargs)
{
  try {
    PyObject* pyObj_bucket = PyDict_GetItemString(kwargs, "bucket");
    PyObject* pyObj_scope = PyDict_GetItemString(kwargs, "scope");
    PyObject* pyObj_collection = PyDict_GetItemString(kwargs, "collection_name");

    if (!pyObj_bucket || !pyObj_scope || !pyObj_collection) {
      return raise_invalid_argument(
        "bucket, scope, and collection are required", __FILE__, __LINE__);
    }

    std::string bucket_name = PyUnicode_AsUTF8(pyObj_bucket);
    std::string scope_name = PyUnicode_AsUTF8(pyObj_scope);
    std::string collection_name = PyUnicode_AsUTF8(pyObj_collection);

    PyObject* pyObj_scan_type = PyDict_GetItemString(kwargs, "scan_type");
    if (!pyObj_scan_type) {
      return raise_invalid_argument("scan_type is required", __FILE__, __LINE__);
    }
    int py_scan_type = PyLong_AsLong(pyObj_scan_type);

    PyObject* pyObj_scan_config = PyDict_GetItemString(kwargs, "scan_config");
    if (!pyObj_scan_config || !PyDict_Check(pyObj_scan_config)) {
      return raise_invalid_argument("scan_config must be a dictionary", __FILE__, __LINE__);
    }

    PyObject* pyObj_orchestrator_opts = PyDict_GetItemString(kwargs, "orchestrator_options");
    if (nullptr != pyObj_orchestrator_opts && !PyDict_Check(pyObj_orchestrator_opts)) {
      return raise_invalid_argument(
        "orchestrator_options must be a dictionary", __FILE__, __LINE__);
    }

    auto barrier = std::make_shared<std::promise<
      std::pair<std::error_code, std::shared_ptr<couchbase::core::topology::configuration>>>>();
    auto f = barrier->get_future();
    cluster_.with_bucket_configuration(bucket_name,
                                       [barrier](std::error_code ec, auto config) mutable {
                                         barrier->set_value({ ec, std::move(config) });
                                       });
    auto [ec, bucket_config] = f.get();

    if (ec) {
      return build_exception(
        ec, __FILE__, __LINE__, "Failed to get bucket configuration for range scan");
    }
    if (!bucket_config->capabilities.supports_range_scan()) {
      return raise_feature_unavailable(
        "The server does not support key-value scan operations.", __FILE__, __LINE__);
    }
    if (!bucket_config->vbmap || bucket_config->vbmap->empty()) {
      return raise_unsuccessful_operation(
        "Cannot perform kv range scan operation.  Unable to get vbucket map.", __FILE__, __LINE__);
    }

    auto agent_group =
      couchbase::core::agent_group(io_, couchbase::core::agent_group_config{ { cluster_ } });