couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/json_streaming_lexer.cxx

@@ -0,0 +1,398 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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.
+ */
+
+#include "json_streaming_lexer.hxx"
+#include "core/logger/logger.hxx"
+
+#include "third_party/jsonsl/jsonsl.h"
+
+#include <stdexcept>
+
+namespace couchbase::core::utils::json
+{
+namespace detail
+{
+
+static void
+noop_on_complete(std::error_code /* ec */, std::size_t /* number_of_rows */, std::string&& /* meta */)
+{ /* do nothing */
+}
+
+static stream_control
+noop_on_row(std::string&& /* row */)
+{
+    return stream_control::next_row;
+}
+
+#define STATE_MARKER_ROOT (reinterpret_cast<void*>(1))
+#define STATE_MARKER_ROWSET (reinterpret_cast<void*>(2))
+
+struct streaming_lexer_impl {
+    streaming_lexer_impl(jsonsl_t lexer, jsonsl_jpr_t pointer)
+      : lexer_(lexer)
+      , pointer_(pointer)
+    {
+    }
+
+    streaming_lexer_impl(streaming_lexer_impl& other) = delete;
+    const streaming_lexer_impl& operator=(const streaming_lexer_impl& other) = delete;
+    streaming_lexer_impl(streaming_lexer_impl&& other) noexcept = delete;
+    const streaming_lexer_impl& operator=(streaming_lexer_impl&& other) = delete;
+
+    ~streaming_lexer_impl()
+    {
+        jsonsl_jpr_destroy(pointer_);
+        jsonsl_jpr_match_state_cleanup(lexer_);
+        jsonsl_destroy(lexer_);
+    }
+
+    void validate_root(struct jsonsl_state_st* state, jsonsl_jpr_match_t match)
+    {
+        if (root_has_been_validated_) {
+            return;
+        }
+        root_has_been_validated_ = true;
+
+        if (state->type != JSONSL_T_OBJECT) {
+            error_ = errc::streaming_json_lexer::root_is_not_an_object;
+            return;
+        }
+
+        if (match != JSONSL_MATCH_POSSIBLE) {
+            error_ = errc::streaming_json_lexer::root_does_not_match_json_pointer;
+            return;
+        }
+        /* tag the state */
+        state->data = STATE_MARKER_ROOT;
+    }
+
+    [[nodiscard]] std::string_view get_buffer_region(std::size_t pos, std::size_t desired = 0) const
+    {
+        if (min_pos_ > pos) {
+            /* swallowed */
+            return { nullptr, 0 };
+        }
+
+        const char* ret = buffer_.c_str() + pos - min_pos_;
+        const char* end = buffer_.c_str() + buffer_.size();
+        if (ret >= end) {
+            return { nullptr, 0 };
+        }
+        auto len = static_cast<std::size_t>(end - ret);
+        if (desired > 0 && len > desired) {
+            len = desired;
+        }
+        return { ret, len };
+    }
+
+    jsonsl_t lexer_{};
+    jsonsl_jpr_t pointer_{};
+    std::string meta_buffer_{};
+
+    std::size_t number_of_rows_{};
+    /**
+     * whether to emit next row
+     */
+    bool emit_next_row_{ true };
+
+    bool meta_complete_{ false };
+
+    /**
+     * size of the metadata header chunk (i.e. everything until the opening
+     * bracket of "rows" [
+     */
+    std::size_t meta_header_length_{};
+
+    /**
+     * Position of last row returned. If there are no subsequent rows, this
+     * signals the beginning of the metadata trailer
+     */
+    std::size_t last_row_end_position_{};
+
+    /** absolute position offset corresponding to the first byte in current_buf */
+    std::size_t min_pos_{};
+
+    /** minimum (absolute) position to keep */
+    std::size_t keep_position_{};
+
+    std::string buffer_{};
+    std::string last_key_{};
+    std::error_code error_{};
+    std::function<void(std::error_code, std::size_t, std::string&&)> on_complete_{ noop_on_complete };
+    std::function<stream_control(std::string&&)> on_row_{ noop_on_row };
+    bool root_has_been_validated_{ false };
+};
+} // namespace detail
+
+static std::error_code
+convert_status(jsonsl_error_t error)
+{
+    switch (error) {
+        case JSONSL_ERROR_SUCCESS:
+            return {};
+
+        case JSONSL_ERROR_GARBAGE_TRAILING:
+            return errc::streaming_json_lexer::garbage_trailing;
+
+        case JSONSL_ERROR_SPECIAL_EXPECTED:
+            return errc::streaming_json_lexer::special_expected;
+
+        case JSONSL_ERROR_SPECIAL_INCOMPLETE:
+            return errc::streaming_json_lexer::special_incomplete;
+
+        case JSONSL_ERROR_STRAY_TOKEN:
+            return errc::streaming_json_lexer::stray_token;
+
+        case JSONSL_ERROR_MISSING_TOKEN:
+            return errc::streaming_json_lexer::missing_token;
+
+        case JSONSL_ERROR_CANT_INSERT:
+            return errc::streaming_json_lexer::cannot_insert;
+
+        case JSONSL_ERROR_ESCAPE_OUTSIDE_STRING:
+            return errc::streaming_json_lexer::escape_outside_string;
+
+        case JSONSL_ERROR_KEY_OUTSIDE_OBJECT:
+            return errc::streaming_json_lexer::key_outside_object;
+
+        case JSONSL_ERROR_STRING_OUTSIDE_CONTAINER:
+            return errc::streaming_json_lexer::string_outside_container;
+
+        case JSONSL_ERROR_FOUND_NULL_BYTE:
+            return errc::streaming_json_lexer::found_null_byte;
+
+        case JSONSL_ERROR_LEVELS_EXCEEDED:
+            return errc::streaming_json_lexer::levels_exceeded;
+
+        case JSONSL_ERROR_BRACKET_MISMATCH:
+            return errc::streaming_json_lexer::bracket_mismatch;
+
+        case JSONSL_ERROR_HKEY_EXPECTED:
+            return errc::streaming_json_lexer::object_key_expected;
+
+        case JSONSL_ERROR_WEIRD_WHITESPACE:
+            return errc::streaming_json_lexer::weird_whitespace;
+
+        case JSONSL_ERROR_UESCAPE_TOOSHORT:
+            return errc::streaming_json_lexer::unicode_escape_is_too_short;
+
+        case JSONSL_ERROR_ESCAPE_INVALID:
+            return errc::streaming_json_lexer::escape_invalid;
+
+        case JSONSL_ERROR_TRAILING_COMMA:
+            return errc::streaming_json_lexer::trailing_comma;
+
+        case JSONSL_ERROR_INVALID_NUMBER:
+            return errc::streaming_json_lexer::invalid_number;
+
+        case JSONSL_ERROR_VALUE_EXPECTED:
+            return errc::streaming_json_lexer::value_expected;
+
+        case JSONSL_ERROR_PERCENT_BADHEX:
+            return errc::streaming_json_lexer::percent_bad_hex;
+
+        case JSONSL_ERROR_JPR_BADPATH:
+            return errc::streaming_json_lexer::json_pointer_bad_path;
+
+        case JSONSL_ERROR_JPR_DUPSLASH:
+            return errc::streaming_json_lexer::json_pointer_duplicated_slash;
+
+        case JSONSL_ERROR_JPR_NOROOT:
+            return errc::streaming_json_lexer::json_pointer_missing_root;
+
+        case JSONSL_ERROR_ENOMEM:
+            return errc::streaming_json_lexer::not_enough_memory;
+
+        case JSONSL_ERROR_INVALID_CODEPOINT:
+            return errc::streaming_json_lexer::invalid_codepoint;
+
+        case JSONSL_ERROR_GENERIC:
+            return errc::streaming_json_lexer::generic;
+
+        default:
+            break;
+    }
+    return errc::streaming_json_lexer::generic;
+}
+
+static int
+error_callback(jsonsl_t lexer, jsonsl_error_t error, struct jsonsl_state_st* /* state */, jsonsl_char_t* /* at */)
+{
+    auto* impl = static_cast<detail::streaming_lexer_impl*>(lexer->data);
+
+    impl->error_ = convert_status(error);
+    impl->on_complete_(impl->error_, impl->number_of_rows_, {});
+    impl->on_complete_ = detail::noop_on_complete;
+
+    return 0;
+}
+
+static void
+meta_header_complete_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct jsonsl_state_st* state, const jsonsl_char_t* /* at */)
+{
+    auto* impl = static_cast<detail::streaming_lexer_impl*>(lexer->data);
+
+    impl->meta_buffer_.append(impl->buffer_.c_str(), state->pos_begin);
+    impl->meta_header_length_ = state->pos_begin;
+    lexer->action_callback_PUSH = nullptr;
+}
+
+static void
+trailer_pop_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct jsonsl_state_st* state, const jsonsl_char_t* /* at */)
+{
+    if (state->data != STATE_MARKER_ROOT) {
+        return;
+    }
+
+    auto* impl = static_cast<detail::streaming_lexer_impl*>(lexer->data);
+
+    if (impl->meta_complete_) {
+        return;
+    }
+
+    impl->meta_buffer_.resize(impl->meta_header_length_);
+    impl->meta_buffer_.append(impl->get_buffer_region(impl->last_row_end_position_));
+    impl->meta_complete_ = true;
+    impl->on_complete_({}, impl->number_of_rows_, std::move(impl->meta_buffer_));
+}
+
+static void
+row_pop_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct jsonsl_state_st* state, const jsonsl_char_t* /* at */)
+{
+    auto* impl = static_cast<detail::streaming_lexer_impl*>(lexer->data);
+
+    if (impl->error_) {
+        return;
+    }
+
+    impl->keep_position_ = lexer->pos;
+    impl->last_row_end_position_ = lexer->pos;
+
+    if (state->data == STATE_MARKER_ROWSET) {
+        lexer->action_callback_POP = trailer_pop_callback;
+        lexer->action_callback_PUSH = nullptr;
+        if (impl->number_of_rows_ == 0) {
+            /* While the entire meta is available to us, the _closing_ part
+             * of the meta is handled in a different callback. */
+            impl->meta_buffer_.append(impl->buffer_.c_str(), lexer->pos);
+            impl->meta_header_length_ = lexer->pos;
+        }
+        return;
+    }
+
+    impl->number_of_rows_++;
+    if (impl->meta_complete_) {
+        return;
+    }
+
+    if (impl->emit_next_row_) {
+        auto row = impl->get_buffer_region(state->pos_begin, lexer->pos - state->pos_begin + (state->type == JSONSL_T_SPECIAL ? 0 : 1));
+        auto rc = impl->on_row_(std::string(row));
+        impl->emit_next_row_ = rc == stream_control::next_row;
+        if (!impl->emit_next_row_) {
+            impl->on_row_ = detail::noop_on_row;
+        }
+    }
+}
+
+static void
+initial_action_pop_callback(jsonsl_t lexer, jsonsl_action_t action, struct jsonsl_state_st* state, const jsonsl_char_t* at)
+{
+    auto* impl = static_cast<detail::streaming_lexer_impl*>(lexer->data);
+
+    if (impl->error_) {
+        return;
+    }
+
+    if (state->type == JSONSL_T_HKEY) {
+        impl->last_key_ = impl->buffer_.substr(state->pos_begin + 1, state->pos_cur - state->pos_begin - 1);
+    }
+
+    if (state->data == STATE_MARKER_ROOT) {
+        trailer_pop_callback(lexer, action, state, at);
+    }
+}
+
+static void
+initial_action_push_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct jsonsl_state_st* state, const jsonsl_char_t* /* at */)
+{
+    auto* impl = static_cast<detail::streaming_lexer_impl*>(lexer->data);
+
+    if (impl->error_) {
+        return;
+    }
+
+    jsonsl_jpr_match_t match = JSONSL_MATCH_UNKNOWN;
+    if (state->type != JSONSL_T_HKEY) {
+        auto key = std::move(impl->last_key_);
+        jsonsl_jpr_match_state(lexer, state, key.data(), key.size(), &match);
+    }
+    impl->validate_root(state, match);
+    if (state->type == JSONSL_T_LIST && match == JSONSL_MATCH_POSSIBLE) {
+        /* we have a match, e.g. "rows:[]" */
+        lexer->action_callback_POP = row_pop_callback;
+        lexer->action_callback_PUSH = meta_header_complete_callback;
+        state->data = STATE_MARKER_ROWSET;
+    }
+}
+
+json::streaming_lexer::streaming_lexer(const std::string& pointer_expression, std::uint32_t depth)
+{
+    jsonsl_error_t error = JSONSL_ERROR_SUCCESS;
+    jsonsl_jpr_t ptr = jsonsl_jpr_new(pointer_expression.c_str(), &error);
+    if (ptr == nullptr) {
+        throw std::invalid_argument("unable to allocate JSON pointer");
+    }
+    if (error != JSONSL_ERROR_SUCCESS) {
+        throw std::invalid_argument(std::string("unable to create JSON pointer: ") + jsonsl_strerror(error));
+    }
+
+    impl_ = std::make_shared<detail::streaming_lexer_impl>(jsonsl_new(512), ptr);
+    impl_->lexer_->data = impl_.get();
+    impl_->lexer_->action_callback_PUSH = initial_action_push_callback;
+    impl_->lexer_->action_callback_POP = initial_action_pop_callback;
+    impl_->lexer_->error_callback = error_callback;
+    jsonsl_jpr_match_state_init(impl_->lexer_, &impl_->pointer_, 1);
+    jsonsl_enable_all_callbacks(impl_->lexer_);
+    impl_->lexer_->max_callback_level = depth;
+}
+
+void
+streaming_lexer::feed(std::string_view data)
+{
+    impl_->buffer_.append(data);
+    jsonsl_feed(impl_->lexer_, data.data(), data.size());
+
+    /* Do we need to cut off some bytes? */
+    if (impl_->keep_position_ > impl_->min_pos_) {
+        impl_->buffer_.erase(0, impl_->keep_position_ - impl_->min_pos_);
+    }
+    impl_->min_pos_ = impl_->keep_position_;
+}
+
+void
+streaming_lexer::on_complete(std::function<void(std::error_code, std::size_t, std::string&&)> handler)
+{
+    impl_->on_complete_ = std::move(handler);
+}
+
+void
+streaming_lexer::on_row(std::function<stream_control(std::string&&)> handler)
+{
+    impl_->on_row_ = std::move(handler);
+}
+} // namespace couchbase::core::utils::json

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/json_streaming_lexer.hxx

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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 "json_stream_control.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace couchbase::core::utils::json
+{
+namespace detail
+{
+struct streaming_lexer_impl;
+} // namespace detail
+
+/**
+ * The streaming JSON lexer consumes chunks of data, and invokes given handler for each "row", and "complete".
+ *
+ * It is guaranteed that on_complete callback will be invoked exactly once.
+ */
+class streaming_lexer
+{
+  public:
+    /**
+     * @param pointer_expression expression that describes where the "row" objects are located.
+     * @param depth stop emitting JSON events starting from this depth. Level 1 is root of the object.
+     *
+     * @throws std::invalid_argument if pointer cannot be created from the expression.
+     */
+    streaming_lexer(const std::string& pointer_expression, std::uint32_t depth);
+
+    void feed(std::string_view data);
+
+    void on_complete(std::function<void(std::error_code ec, std::size_t number_of_rows, std::string&& meta)> handler);
+    void on_row(std::function<stream_control(std::string&& row)> handler);
+
+  private:
+    std::shared_ptr<detail::streaming_lexer_impl> impl_{};
+};
+} // namespace couchbase::core::utils::json

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/movable_function.hxx

@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2022 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 <functional>
+#include <gsl/assert>
+#include <memory>
+
+/* replace with standard version once http://wg21.link/P0288 will be accepted and implemented */
+namespace couchbase::core::utils
+{
+template<typename Signature>
+class movable_function : public std::function<Signature>
+{
+    template<typename Functor, typename En = void>
+    struct wrapper;
+
+    template<typename Functor>
+    struct wrapper<Functor, std::enable_if_t<std::is_copy_constructible_v<Functor>>> {
+        Functor fn;
+
+        template<typename... Args>
+        auto operator()(Args&&... args)
+        {
+            return fn(std::forward<Args>(args)...);
+        }
+    };
+
+    template<typename Functor>
+    struct copy_wrapper {
+        Functor fn;
+
+        explicit copy_wrapper(Functor&& f)
+          : fn(std::move(f))
+        {
+        }
+    };
+
+    template<typename Functor>
+    struct wrapper<Functor, std::enable_if_t<!std::is_copy_constructible_v<Functor> && std::is_move_constructible_v<Functor>>> {
+        std::shared_ptr<copy_wrapper<Functor>> fnPtr;
+
+        explicit wrapper(Functor&& f)
+          : fnPtr(new copy_wrapper<Functor>(std::move(f)))
+        {
+        }
+
+        wrapper(wrapper&& /* other */) noexcept = default;
+        wrapper& operator=(wrapper&& /* other */) noexcept = default;
+
+        wrapper(const wrapper& other) = default;
+        wrapper& operator=(const wrapper& /* other */) = default;
+
+        template<typename... Args>
+        auto operator()(Args&&... args)
+        {
+            return std::move(fnPtr->fn)(std::forward<Args>(args)...);
+        }
+    };
+
+    using base = std::function<Signature>;
+
+  public:
+    movable_function() noexcept = default;
+    movable_function(std::nullptr_t) noexcept
+      : base(nullptr)
+    {
+    }
+
+    template<typename Functor>
+    movable_function(Functor&& f)
+      : base(wrapper<Functor>{ std::forward<Functor>(f) })
+    {
+    }
+
+    movable_function(movable_function&& /* other */) noexcept = default;
+    movable_function& operator=(movable_function&& /* other */) noexcept = default;
+
+    movable_function& operator=(std::nullptr_t /* other */)
+    {
+        base::operator=(nullptr);
+        return *this;
+    }
+
+    template<typename Functor>
+    movable_function& operator=(Functor&& f)
+    {
+        base::operator=(wrapper<Functor>{ std::forward<Functor>(f) });
+        return *this;
+    }
+
+    using base::operator();
+};
+
+} // namespace couchbase::core::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/mutation_token.cxx

@@ -0,0 +1,33 @@
+/* -*- 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.
+ */
+
+#include "mutation_token.hxx"
+
+namespace couchbase::utils
+{
+[[nodiscard]] auto
+build_mutation_token(const mutation_token& source, std::uint16_t partition_id, std::string bucket_name) -> mutation_token
+{
+    return mutation_token{ source.partition_uuid(), source.sequence_number(), partition_id, std::move(bucket_name) };
+}
+
+[[nodiscard]] auto
+build_mutation_token(std::uint64_t partition_uuid, std::uint64_t sequence_number) -> mutation_token
+{
+    return mutation_token{ partition_uuid, sequence_number, 0, {} };
+}
+} // namespace couchbase::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/mutation_token.hxx

@@ -0,0 +1,29 @@
+/* -*- 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/mutation_token.hxx>
+
+namespace couchbase::utils
+{
+[[nodiscard]] auto
+build_mutation_token(const mutation_token& source, std::uint16_t partition_id, std::string bucket_name) -> mutation_token;
+
+[[nodiscard]] auto
+build_mutation_token(std::uint64_t partition_uuid, std::uint64_t sequence_number) -> mutation_token;
+} // namespace couchbase::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/utils/name_codec.hxx

@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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 <sstream>
+#include <string>
+
+namespace couchbase::core::utils
+{
+struct analytics {
+    static std::string uncompound_name(const std::string& name)
+    {
+        std::stringstream ss;
+        ss << '`';
+        for (const auto symbol : name) {
+            if (symbol == '/') {
+                ss << "`.`";
+            } else {
+                ss << symbol;
+            }
+        }
+        ss << '`';
+        return ss.str();
+    }
+};
+} // namespace couchbase::core::utils