couchbase 3.8.2 → 3.9.1

data/ext/couchbase/core/protostellar/query_converter.hxx

@@ -0,0 +1,265 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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
+
+// Translates the core N1QL query request/response to and from the couchbase.query.v1 protobuf
+// messages. Rows arrive across streamed QueryResponse messages and are buffered into
+// query_response::rows when no callback is provided, or delivered incrementally to row_callback
+// when present; the terminal message carries the metadata. Deliberately does not reuse the
+// MCBP-bound encode_to/make_response (those build an HTTP body + parse a JSON reply).
+//
+// Query features with no couchbase2 equivalent are reported by can_encode() so the component can
+// surface feature_not_available rather than silently dropping them: the `raw` passthrough map,
+// use_replica, node targeting via send_to_node, and tuning values too large for the proto's
+// uint32 fields.
+
+#include "core/json_string.hxx"
+#include "core/operations/document_query.hxx"
+#include "core/protostellar/json_payload.hxx"
+#include "core/protostellar/query_proto.hxx"
+
+#include <couchbase/query_profile.hxx>
+#include <couchbase/query_scan_consistency.hxx>
+
+#include <chrono>
+#include <cstdint>
+#include <limits>
+#include <optional>
+#include <string>
+
+namespace couchbase::core::protostellar::query
+{
+namespace v1 = ::couchbase::query::v1;
+
+// The proto's tuning fields are uint32 while the core request holds them as uint64, so a value
+// that does not fit is not encodable: casting it would ask the gateway to use the wrapped number.
+[[nodiscard]] inline auto
+fits_uint32(const std::optional<std::uint64_t>& value) -> bool
+{
+  return !value.has_value() || *value <= std::numeric_limits<std::uint32_t>::max();
+}
+
+// Query request features the couchbase2 gateway schema cannot express yet. The component maps this
+// to feature_not_available instead of silently ignoring the caller's intent.
+[[nodiscard]] inline auto
+can_encode(const operations::query_request& request) -> bool
+{
+  return request.raw.empty() && !request.use_replica.value_or(false) &&
+         !request.send_to_node.has_value() && fits_uint32(request.max_parallelism) &&
+         fits_uint32(request.pipeline_batch) && fits_uint32(request.pipeline_cap) &&
+         fits_uint32(request.scan_cap);
+}
+
+// Split the SDK query_context ("default:`bucket`.`scope`") into the proto's bucket_name/scope_name.
+// Any pair of backtick-delimited identifiers is accepted; a value that does not parse leaves both
+// unset (the statement is then expected to be fully qualified).
+inline void
+apply_query_context(const std::string& query_context, v1::QueryRequest& proto)
+{
+  std::string bucket;
+  std::string scope;
+  std::string* current = &bucket;
+  bool inside = false;
+  int identifiers = 0;
+  for (const char c : query_context) {
+    if (c == '`') {
+      if (inside) { // closing backtick ends an identifier
+        ++identifiers;
+        if (identifiers == 1) {
+          current = &scope;
+        }
+      }
+      inside = !inside;
+      continue;
+    }
+    if (inside) {
+      current->push_back(c);
+    }
+  }
+  // A well-formed context is exactly two balanced backtick-delimited identifiers
+  // (`bucket`.`scope`). Anything else -- unbalanced, too few, or too many -- leaves both unset
+  // rather than routing on a half- or mis-parsed context.
+  if (!inside && identifiers == 2 && !bucket.empty() && !scope.empty()) {
+    proto.set_bucket_name(bucket);
+    proto.set_scope_name(scope);
+  }
+}
+
+inline auto
+encode(const operations::query_request& request) -> v1::QueryRequest
+{
+  v1::QueryRequest proto;
+  proto.set_statement(request.statement);
+  if (request.client_context_id.has_value()) {
+    proto.set_client_context_id(*request.client_context_id);
+  }
+  if (request.query_context.has_value()) {
+    apply_query_context(*request.query_context, proto);
+  }
+  proto.set_read_only(request.readonly);
+  proto.set_flex_index(request.flex_index);
+  proto.set_preserve_expiry(request.preserve_expiry);
+  // adhoc=false means "use a prepared statement" on the MCBP path; the gateway prepares/caches on
+  // its side, so we only signal intent.
+  if (!request.adhoc) {
+    proto.set_prepared(true);
+  }
+
+  if (request.scan_consistency.has_value()) {
+    switch (*request.scan_consistency) {
+      case query_scan_consistency::not_bounded:
+        proto.set_scan_consistency(v1::QueryRequest_ScanConsistency_SCAN_CONSISTENCY_NOT_BOUNDED);
+        break;
+      case query_scan_consistency::request_plus:
+        proto.set_scan_consistency(v1::QueryRequest_ScanConsistency_SCAN_CONSISTENCY_REQUEST_PLUS);
+        break;
+    }
+  }
+  // A non-empty mutation_state carries at_plus scan vectors; the gateway takes them as
+  // consistent_with mutation tokens.
+  for (const auto& token : request.mutation_state) {
+    auto* proto_token = proto.add_consistent_with();
+    proto_token->set_bucket_name(token.bucket_name());
+    proto_token->set_vbucket_id(token.partition_id());
+    proto_token->set_vbucket_uuid(token.partition_uuid());
+    proto_token->set_seq_no(token.sequence_number());
+  }
+
+  if (request.profile.has_value()) {
+    switch (*request.profile) {
+      case query_profile::off:
+        proto.set_profile_mode(v1::QueryRequest_ProfileMode_PROFILE_MODE_OFF);
+        break;
+      case query_profile::phases:
+        proto.set_profile_mode(v1::QueryRequest_ProfileMode_PROFILE_MODE_PHASES);
+        break;
+      case query_profile::timings:
+        proto.set_profile_mode(v1::QueryRequest_ProfileMode_PROFILE_MODE_TIMINGS);
+        break;
+    }
+  }
+
+  for (const auto& parameter : request.positional_parameters) {
+    proto.add_positional_parameters(json_payload(parameter));
+  }
+  for (const auto& [name, value] : request.named_parameters) {
+    (*proto.mutable_named_parameters())[name] = json_payload(value);
+  }
+
+  // Tuning options: the SDK's `metrics` flag defaults to off, so disable_metrics is its inverse.
+  auto* tuning = proto.mutable_tuning_options();
+  tuning->set_disable_metrics(!request.metrics);
+  if (request.max_parallelism.has_value()) {
+    tuning->set_max_parallelism(static_cast<std::uint32_t>(*request.max_parallelism));
+  }
+  if (request.pipeline_batch.has_value()) {
+    tuning->set_pipeline_batch(static_cast<std::uint32_t>(*request.pipeline_batch));
+  }
+  if (request.pipeline_cap.has_value()) {
+    tuning->set_pipeline_cap(static_cast<std::uint32_t>(*request.pipeline_cap));
+  }
+  if (request.scan_cap.has_value()) {
+    tuning->set_scan_cap(static_cast<std::uint32_t>(*request.scan_cap));
+  }
+  if (request.scan_wait.has_value()) {
+    const auto secs = std::chrono::duration_cast<std::chrono::seconds>(*request.scan_wait);
+    const auto nanos =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(*request.scan_wait - secs);
+    auto* scan_wait = tuning->mutable_scan_wait();
+    scan_wait->set_seconds(secs.count());
+    scan_wait->set_nanos(static_cast<std::int32_t>(nanos.count()));
+  }
+
+  return proto;
+}
+
+// google.protobuf.Duration -> nanoseconds.
+[[nodiscard]] inline auto
+to_nanoseconds(const google::protobuf::Duration& duration) -> std::chrono::nanoseconds
+{
+  return std::chrono::seconds{ duration.seconds() } + std::chrono::nanoseconds{ duration.nanos() };
+}
+
+[[nodiscard]] inline auto
+status_to_string(v1::QueryResponse_MetaData_Status status) -> std::string
+{
+  switch (status) {
+    case v1::QueryResponse_MetaData_Status_STATUS_RUNNING:
+      return "running";
+    case v1::QueryResponse_MetaData_Status_STATUS_SUCCESS:
+      return "success";
+    case v1::QueryResponse_MetaData_Status_STATUS_ERRORS:
+      return "errors";
+    case v1::QueryResponse_MetaData_Status_STATUS_COMPLETED:
+      return "completed";
+    case v1::QueryResponse_MetaData_Status_STATUS_STOPPED:
+      return "stopped";
+    case v1::QueryResponse_MetaData_Status_STATUS_TIMEOUT:
+      return "timeout";
+    case v1::QueryResponse_MetaData_Status_STATUS_CLOSED:
+      return "closed";
+    case v1::QueryResponse_MetaData_Status_STATUS_FATAL:
+      return "fatal";
+    case v1::QueryResponse_MetaData_Status_STATUS_ABORTED:
+      return "aborted";
+    default:
+      return "unknown";
+  }
+}
+
+// Fill a query_meta_data from the terminal QueryResponse.MetaData message.
+inline void
+decode_meta_data(const v1::QueryResponse_MetaData& proto,
+                 operations::query_response::query_meta_data& meta)
+{
+  meta.request_id = proto.request_id();
+  meta.client_context_id = proto.client_context_id();
+  meta.status = status_to_string(proto.status());
+  if (!proto.signature().empty()) {
+    meta.signature = proto.signature();
+  }
+  if (!proto.profile().empty()) {
+    meta.profile = proto.profile();
+  }
+  if (proto.has_metrics()) {
+    const auto& m = proto.metrics();
+    operations::query_response::query_metrics metrics;
+    metrics.elapsed_time = to_nanoseconds(m.elapsed_time());
+    metrics.execution_time = to_nanoseconds(m.execution_time());
+    metrics.result_count = m.result_count();
+    metrics.result_size = m.result_size();
+    metrics.sort_count = m.sort_count();
+    metrics.mutation_count = m.mutation_count();
+    metrics.error_count = m.error_count();
+    metrics.warning_count = m.warning_count();
+    meta.metrics = metrics;
+  }
+  if (proto.warnings_size() > 0) {
+    std::vector<operations::query_response::query_problem> warnings;
+    warnings.reserve(static_cast<std::size_t>(proto.warnings_size()));
+    for (const auto& w : proto.warnings()) {
+      operations::query_response::query_problem problem;
+      problem.code = w.code();
+      problem.message = w.message();
+      warnings.push_back(std::move(problem));
+    }
+    meta.warnings = std::move(warnings);
+  }
+}
+
+} // namespace couchbase::core::protostellar::query

data/ext/couchbase/core/protostellar/query_index_admin_converter.hxx

@@ -0,0 +1,291 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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
+
+// Translates core query index management requests to and from couchbase.admin.query.v1 (unary
+// admin RPCs). The proto IndexType / IndexState enums have no `unknown` sentinel; they map to the
+// lowercase strings the rest of the SDK uses.
+//
+// The gateway builds the N1QL statement from the request rather than taking one, so the encode
+// side owns everything the statement's shape depends on: which RPC a primary index goes to, and
+// how an index key is escaped.
+
+#include "core/operations/management/query_index_build_deferred.hxx"
+#include "core/operations/management/query_index_create.hxx"
+#include "core/operations/management/query_index_drop.hxx"
+#include "core/operations/management/query_index_get_all.hxx"
+#include "couchbase/management/query_index.hxx"
+
+#include <couchbase/admin/query/v1/query.pb.h>
+
+#include <cstddef>
+#include <string>
+
+namespace couchbase::core::protostellar::query_index_admin
+{
+namespace v1 = ::couchbase::admin::query::v1;
+namespace om = ::couchbase::core::operations::management;
+
+// Whether the key is already one complete escaped identifier: an opening backtick, a body in which
+// every backslash escapes the character after it and every backtick is escaped or doubled, and the
+// closing backtick at the very end of the key.
+//
+// Ending exactly at the end is the whole question. A key whose identifier closes early -- "`a`,`b`"
+// -- leaves the remainder as loose statement text, and a key ending in a lone backslash -- "`a\" --
+// escapes its own closing backtick and swallows what follows it.
+[[nodiscard]] inline auto
+is_escaped_identifier(const std::string& key) -> bool
+{
+  if (key.size() < 2 || key.front() != '`' || key.back() != '`') {
+    return false;
+  }
+  const auto last = key.size() - 1;
+  for (std::size_t i = 1; i < last;) {
+    if (key[i] == '\\') {
+      if (i + 1 >= last) {
+        return false;
+      }
+      i += 2;
+      continue;
+    }
+    if (key[i] == '`') {
+      if (i + 1 < last && key[i + 1] == '`') {
+        i += 2;
+        continue;
+      }
+      return false;
+    }
+    i += 1;
+  }
+  return true;
+}
+
+// Escapes one index key into exactly one N1QL identifier token.
+//
+// This is the transport's only client-supplied statement text. The gateway builds the statement
+// itself and joins the field list with commas verbatim (gocbcorex cbqueryx), so whatever arrives in
+// `fields` is spliced between the parentheses of CREATE INDEX unchanged. A key that closed its own
+// quoting would add terms to the index -- or change the statement -- rather than name a field.
+//
+// The escape is the one the query parser reads back: a backslash escapes the character after it
+// (parser/n1ql/util.go), so a backtick and a backslash each arrive prefixed by one. Doubling the
+// backtick instead would parse, but reads back as two backticks in the name rather than one, and
+// leaving the backslash bare makes the parser reject the whole statement. Anything else inside the
+// quotes -- spaces, commas, parentheses, newlines -- is part of the identifier and needs no escape,
+// which is why "two words" is a key and not a syntax error.
+//
+// A key that is already one complete identifier is passed through, because that is the form
+// GetAllIndexes reports keys in and the classic query path accepts. "Already" is verified rather
+// than assumed: is_escaped_identifier() is what separates a caller's pre-quoted key from a key
+// carrying quotes that end early.
+[[nodiscard]] inline auto
+encode_index_key(const std::string& key) -> std::string
+{
+  if (is_escaped_identifier(key)) {
+    return key;
+  }
+  std::string escaped;
+  escaped.reserve(key.size() + 2);
+  escaped.push_back('`');
+  for (const auto c : key) {
+    if (c == '\\' || c == '`') {
+      escaped.push_back('\\');
+    }
+    escaped.push_back(c);
+  }
+  escaped.push_back('`');
+  return escaped;
+}
+
+// Copies the keyspace onto a request whose scope/collection fields are `optional string`. An empty
+// name is left unset: the gateway reads an unset scope as "the whole bucket", and a present-but-
+// empty one as a scope literally named "", which it rejects.
+template<typename Proto>
+void
+apply_keyspace(const std::string& bucket_name,
+               const std::string& scope_name,
+               const std::string& collection_name,
+               Proto& proto)
+{
+  proto.set_bucket_name(bucket_name);
+  if (!scope_name.empty()) {
+    proto.set_scope_name(scope_name);
+  }
+  if (!collection_name.empty()) {
+    proto.set_collection_name(collection_name);
+  }
+}
+
+// couchbase2 CreateIndexRequest has no condition field, so a secondary index with a WHERE clause
+// cannot be expressed at all -- encoding one would create an index over the whole collection under
+// the name the caller asked for. A primary index has no condition to lose.
+[[nodiscard]] inline auto
+can_encode(const om::query_index_create_request& request) -> bool
+{
+  return request.is_primary || !request.condition.has_value();
+}
+
+[[nodiscard]] inline auto
+encode_get_all(const om::query_index_get_all_request& request) -> v1::GetAllIndexesRequest
+{
+  v1::GetAllIndexesRequest proto;
+  apply_keyspace(request.bucket_name, request.scope_name, request.collection_name, proto);
+  return proto;
+}
+
+[[nodiscard]] inline auto
+encode_create_primary(const om::query_index_create_request& request)
+  -> v1::CreatePrimaryIndexRequest
+{
+  v1::CreatePrimaryIndexRequest proto;
+  apply_keyspace(request.bucket_name, request.scope_name, request.collection_name, proto);
+  // An unset name asks the server for its own default (#primary); an empty one is not a name.
+  if (!request.index_name.empty()) {
+    proto.set_name(request.index_name);
+  }
+  if (request.num_replicas.has_value()) {
+    proto.set_num_replicas(*request.num_replicas);
+  }
+  if (request.deferred.has_value()) {
+    proto.set_deferred(*request.deferred);
+  }
+  proto.set_ignore_if_exists(request.ignore_if_exists);
+  return proto;
+}
+
+[[nodiscard]] inline auto
+encode_create(const om::query_index_create_request& request) -> v1::CreateIndexRequest
+{
+  v1::CreateIndexRequest proto;
+  apply_keyspace(request.bucket_name, request.scope_name, request.collection_name, proto);
+  proto.set_name(request.index_name);
+  for (const auto& key : request.keys) {
+    proto.add_fields(encode_index_key(key));
+  }
+  if (request.num_replicas.has_value()) {
+    proto.set_num_replicas(*request.num_replicas);
+  }
+  if (request.deferred.has_value()) {
+    proto.set_deferred(*request.deferred);
+  }
+  proto.set_ignore_if_exists(request.ignore_if_exists);
+  return proto;
+}
+
+[[nodiscard]] inline auto
+encode_drop_primary(const om::query_index_drop_request& request) -> v1::DropPrimaryIndexRequest
+{
+  v1::DropPrimaryIndexRequest proto;
+  apply_keyspace(request.bucket_name, request.scope_name, request.collection_name, proto);
+  if (!request.index_name.empty()) {
+    proto.set_name(request.index_name);
+  }
+  proto.set_ignore_if_missing(request.ignore_if_does_not_exist);
+  return proto;
+}
+
+[[nodiscard]] inline auto
+encode_drop(const om::query_index_drop_request& request) -> v1::DropIndexRequest
+{
+  v1::DropIndexRequest proto;
+  apply_keyspace(request.bucket_name, request.scope_name, request.collection_name, proto);
+  proto.set_name(request.index_name);
+  proto.set_ignore_if_missing(request.ignore_if_does_not_exist);
+  return proto;
+}
+
+[[nodiscard]] inline auto
+encode_build_deferred(const om::query_index_build_deferred_request& request)
+  -> v1::BuildDeferredIndexesRequest
+{
+  v1::BuildDeferredIndexesRequest proto;
+  apply_keyspace(request.bucket_name,
+                 request.scope_name.value_or(std::string{}),
+                 request.collection_name.value_or(std::string{}),
+                 proto);
+  return proto;
+}
+
+[[nodiscard]] inline auto
+index_type_to_string(v1::IndexType type) -> std::string
+{
+  switch (type) {
+    case v1::INDEX_TYPE_VIEW:
+      return "view";
+    case v1::INDEX_TYPE_GSI:
+      return "gsi";
+    default:
+      return "unknown";
+  }
+}
+
+[[nodiscard]] inline auto
+index_state_to_string(v1::IndexState state) -> std::string
+{
+  switch (state) {
+    case v1::INDEX_STATE_DEFERRED:
+      return "deferred";
+    case v1::INDEX_STATE_BUILDING:
+      return "building";
+    case v1::INDEX_STATE_PENDING:
+      return "pending";
+    case v1::INDEX_STATE_ONLINE:
+      return "online";
+    case v1::INDEX_STATE_OFFLINE:
+      return "offline";
+    case v1::INDEX_STATE_ABRIDGED:
+      return "abridged";
+    case v1::INDEX_STATE_SCHEDULED:
+      return "scheduled";
+    default:
+      return "unknown";
+  }
+}
+
+[[nodiscard]] inline auto
+decode_index(const v1::GetAllIndexesResponse_Index& proto) -> couchbase::management::query_index
+{
+  couchbase::management::query_index index;
+  index.is_primary = proto.is_primary();
+  index.name = proto.name();
+  index.type = index_type_to_string(proto.type());
+  index.state = index_state_to_string(proto.state());
+  index.bucket_name = proto.bucket_name();
+  if (!proto.scope_name().empty()) {
+    index.scope_name = proto.scope_name();
+  }
+  if (!proto.collection_name().empty()) {
+    index.collection_name = proto.collection_name();
+  }
+  for (const auto& field : proto.fields()) {
+    index.index_key.push_back(field);
+  }
+  // Presence, not emptiness: condition and partition are `optional string`, so an index that has
+  // no WHERE clause is a different answer from one whose clause the server reports as empty.
+  // scope_name and collection_name above carry no presence, so there an empty name is the only
+  // form "not collection-qualified" can arrive in.
+  if (proto.has_condition()) {
+    index.condition = proto.condition();
+  }
+  if (proto.has_partition()) {
+    index.partition = proto.partition();
+  }
+  return index;
+}
+
+} // namespace couchbase::core::protostellar::query_index_admin

data/ext/couchbase/core/protostellar/query_proto.hxx

@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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
+
+// The one place the generated couchbase.query.v1 headers are included. Include this instead of
+// <couchbase/query/v1/query.pb.h> or <couchbase/query/v1/query.grpc.pb.h>.
+//
+// protobuf emits a class-scoped alias for every enum value ("static constexpr Status STATUS_TIMEOUT
+// = ..."), and the Windows SDK spells much of that same STATUS_* namespace as object-like macros:
+// <winnt.h> defines STATUS_TIMEOUT as ((DWORD)0x00000102L), and asio and gRPC reach <winnt.h>
+// transitively. On MSVC the alias then expands into a parenthesised constant and the generated
+// header does not parse. No other compiler is affected, so the Linux and macOS legs cannot catch
+// it.
+//
+// The whole QueryResponse.MetaData.Status family is suppressed, not just the one name that collides
+// today: <ntstatus.h> covers far more of the STATUS_* namespace than <winnt.h> does (STATUS_SUCCESS
+// among it) and any dependency may start pulling it in. push_macro/pop_macro keeps the suppression
+// scoped to the includes below, so a translation unit that includes this header does not silently
+// lose a macro it uses elsewhere -- which a bare #undef in a header would do. Pushing and popping a
+// macro that is not defined is a no-op, so this needs no _MSC_VER guard.
+//
+// When the schema pin in cmake/Protostellar.cmake moves, bin/check-proto-macro-collisions reports
+// generated aliases that collide with a Windows macro, including families other than this one.
+
+#pragma push_macro("STATUS_ABORTED")
+#pragma push_macro("STATUS_CLOSED")
+#pragma push_macro("STATUS_COMPLETED")
+#pragma push_macro("STATUS_ERRORS")
+#pragma push_macro("STATUS_FATAL")
+#pragma push_macro("STATUS_RUNNING")
+#pragma push_macro("STATUS_STOPPED")
+#pragma push_macro("STATUS_SUCCESS")
+#pragma push_macro("STATUS_TIMEOUT")
+#pragma push_macro("STATUS_UNKNOWN")
+#undef STATUS_ABORTED
+#undef STATUS_CLOSED
+#undef STATUS_COMPLETED
+#undef STATUS_ERRORS
+#undef STATUS_FATAL
+#undef STATUS_RUNNING
+#undef STATUS_STOPPED
+#undef STATUS_SUCCESS
+#undef STATUS_TIMEOUT
+#undef STATUS_UNKNOWN
+
+#include <couchbase/query/v1/query.grpc.pb.h>
+#include <couchbase/query/v1/query.pb.h>
+
+#pragma pop_macro("STATUS_UNKNOWN")
+#pragma pop_macro("STATUS_TIMEOUT")
+#pragma pop_macro("STATUS_SUCCESS")
+#pragma pop_macro("STATUS_STOPPED")
+#pragma pop_macro("STATUS_RUNNING")
+#pragma pop_macro("STATUS_FATAL")
+#pragma pop_macro("STATUS_ERRORS")
+#pragma pop_macro("STATUS_COMPLETED")
+#pragma pop_macro("STATUS_CLOSED")
+#pragma pop_macro("STATUS_ABORTED")