couchbase 3.0.0.alpha.5-x86_64-linux → 3.5.1-x86_64-linux

data/ext/couchbase/operations/document_exists.hxx

@@ -1,82 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <document_id.hxx>
-#include <protocol/cmd_exists.hxx>
-
-namespace couchbase::operations
-{
-
-struct exists_response {
-    enum class observe_status { invalid, found, not_found, persisted, logically_deleted };
-
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
-    std::uint16_t partition_id{};
-    std::uint64_t cas{};
-    observe_status status{ observe_status::invalid };
-};
-
-struct exists_request {
-    using encoded_request_type = protocol::client_request<protocol::exists_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::exists_response_body>;
-
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.opaque(opaque);
-        encoded.body().id(partition, id);
-    }
-};
-
-exists_response
-make_response(std::error_code ec, exists_request& request, exists_request::encoded_response_type encoded)
-{
-    exists_response response{ request.id, encoded.opaque(), ec, request.partition };
-    if (!ec) {
-        response.cas = encoded.body().cas();
-        response.partition_id = encoded.body().partition_id();
-        switch (encoded.body().status()) {
-            case 0x00:
-                response.status = exists_response::observe_status::found;
-                break;
-            case 0x01:
-                response.status = exists_response::observe_status::persisted;
-                break;
-            case 0x80:
-                response.status = exists_response::observe_status::not_found;
-                break;
-            case 0x81:
-                response.status = exists_response::observe_status::logically_deleted;
-                break;
-            default:
-                spdlog::warn("invalid observe status for \"{}\": {:x}", request.id, encoded.body().status());
-                response.status = exists_response::observe_status::invalid;
-                break;
-        }
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/document_get.hxx

@@ -1,64 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <document_id.hxx>
-#include <protocol/cmd_get.hxx>
-
-namespace couchbase::operations
-{
-
-struct get_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
-    std::string value{};
-    std::uint64_t cas{};
-    std::uint32_t flags{};
-};
-
-struct get_request {
-    using encoded_request_type = protocol::client_request<protocol::get_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::get_response_body>;
-
-    document_id id;
-    uint16_t partition{};
-    uint32_t opaque{};
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.opaque(opaque);
-        encoded.partition(partition);
-        encoded.body().id(id);
-    }
-};
-
-get_response
-make_response(std::error_code ec, get_request& request, get_request::encoded_response_type encoded)
-{
-    get_response response{ request.id, encoded.opaque(), ec };
-    if (!ec) {
-        response.value = std::move(encoded.body().value());
-        response.cas = encoded.cas();
-        response.flags = encoded.body().flags();
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/document_get_and_lock.hxx

@@ -1,66 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <document_id.hxx>
-#include <protocol/cmd_get_and_lock.hxx>
-
-namespace couchbase::operations
-{
-
-struct get_and_lock_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
-    std::string value{};
-    std::uint64_t cas{};
-    std::uint32_t flags{};
-};
-
-struct get_and_lock_request {
-    using encoded_request_type = protocol::client_request<protocol::get_and_lock_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::get_and_lock_response_body>;
-
-    document_id id;
-    uint16_t partition{};
-    uint32_t opaque{};
-    uint32_t lock_time{};
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.opaque(opaque);
-        encoded.partition(partition);
-        encoded.body().id(id);
-        encoded.body().lock_time(lock_time);
-    }
-};
-
-get_and_lock_response
-make_response(std::error_code ec, get_and_lock_request& request, get_and_lock_request::encoded_response_type encoded)
-{
-    get_and_lock_response response{ request.id, encoded.opaque(), ec };
-    if (!ec) {
-        response.value = std::move(encoded.body().value());
-        response.cas = encoded.cas();
-        response.flags = encoded.body().flags();
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/document_get_and_touch.hxx

@@ -1,66 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <document_id.hxx>
-#include <protocol/cmd_get_and_touch.hxx>
-
-namespace couchbase::operations
-{
-
-struct get_and_touch_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
-    std::string value{};
-    std::uint64_t cas{};
-    std::uint32_t flags{};
-};
-
-struct get_and_touch_request {
-    using encoded_request_type = protocol::client_request<protocol::get_and_touch_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::get_and_touch_response_body>;
-
-    document_id id;
-    uint16_t partition{};
-    uint32_t opaque{};
-    uint32_t expiration{};
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.opaque(opaque);
-        encoded.partition(partition);
-        encoded.body().id(id);
-        encoded.body().expiration(expiration);
-    }
-};
-
-get_and_touch_response
-make_response(std::error_code ec, get_and_touch_request& request, get_and_touch_request::encoded_response_type encoded)
-{
-    get_and_touch_response response{ request.id, encoded.opaque(), ec };
-    if (!ec) {
-        response.value = std::move(encoded.body().value());
-        response.cas = encoded.cas();
-        response.flags = encoded.body().flags();
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/document_get_projected.hxx

@@ -1,244 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <document_id.hxx>
-#include <protocol/cmd_lookup_in.hxx>
-
-namespace couchbase::operations
-{
-
-struct get_projected_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
-    std::string value{};
-    std::uint64_t cas{};
-    std::uint32_t flags{};
-    std::optional<std::uint32_t> expiration{};
-};
-
-struct get_projected_request {
-    using encoded_request_type = protocol::client_request<protocol::lookup_in_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::lookup_in_response_body>;
-
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::vector<std::string> projections{};
-    bool with_expiration{ false };
-    std::vector<std::string> effective_projections{};
-    bool preserve_array_indexes{ false };
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.opaque(opaque);
-        encoded.partition(partition);
-        encoded.body().id(id);
-
-        effective_projections = projections;
-        std::size_t num_projections = effective_projections.size();
-        if (with_expiration) {
-            num_projections++;
-        }
-        if (num_projections > 16) {
-            // too many subdoc operations, better fetch full document
-            effective_projections.clear();
-        }
-
-        protocol::lookup_in_request_body::lookup_in_specs specs{};
-        if (with_expiration) {
-            specs.add_spec(protocol::subdoc_opcode::get, true, "$document.exptime");
-        }
-        if (effective_projections.empty()) {
-            specs.add_spec(protocol::subdoc_opcode::get_doc, false, "");
-        } else {
-            for (const auto& path : effective_projections) {
-                specs.add_spec(protocol::subdoc_opcode::get, false, path);
-            }
-        }
-        encoded.body().specs(specs);
-    }
-};
-
-namespace priv
-{
-
-std::optional<tao::json::value>
-subdoc_lookup(tao::json::value& root, const std::string& path)
-{
-    std::string::size_type offset = 0;
-    tao::json::value* cur = &root;
-
-    while (offset < path.size()) {
-        std::string::size_type idx = path.find_first_of(".[]", offset);
-
-        if (idx == std::string::npos) {
-            std::string key = path.substr(offset);
-            auto* val = cur->find(key);
-            if (val != nullptr) {
-                return *val;
-            }
-            break;
-        }
-
-        if (path[idx] == '.' || path[idx] == '[') {
-            std::string key = path.substr(offset, idx - offset);
-            auto* val = cur->find(key);
-            if (val == nullptr) {
-                break;
-            }
-            cur = val;
-        } else if (path[idx] == ']') {
-            if (!cur->is_array()) {
-                break;
-            }
-            std::string key = path.substr(offset, idx - offset);
-            int array_index = std::stoi(key);
-            if (array_index == -1) {
-                cur = &cur->get_array().back();
-            } else if (static_cast<std::size_t>(array_index) < cur->get_array().size()) {
-                cur = &cur->get_array().back();
-            } else {
-                break;
-            }
-            if (idx < path.size() - 1) {
-                return *cur;
-            }
-            idx += 1;
-        }
-        offset = idx + 1;
-    }
-
-    return {};
-}
-
-void
-subdoc_apply_projection(tao::json::value& root, const std::string& path, tao::json::value& value, bool preserve_array_indexes)
-{
-    std::string::size_type offset = 0;
-    tao::json::value* cur = &root;
-
-    while (offset < path.size()) {
-        std::string::size_type idx = path.find_first_of(".[]", offset);
-
-        if (idx == std::string::npos) {
-            cur->operator[](path.substr(offset)) = value;
-            break;
-        }
-
-        if (path[idx] == '.') {
-            std::string key = path.substr(offset, idx - offset);
-            tao::json::value* child = cur->find(key);
-            if (child == nullptr) {
-                cur->operator[](key) = tao::json::empty_object;
-                child = cur->find(key);
-            }
-            cur = child;
-        } else if (path[idx] == '[') {
-            std::string key = path.substr(offset, idx - offset);
-            tao::json::value* child = cur->find(key);
-            if (child == nullptr) {
-                cur->operator[](key) = tao::json::empty_array;
-                child = cur->find(key);
-            }
-            cur = child;
-        } else if (path[idx] == ']') {
-            tao::json::value child;
-            if (idx == path.size() - 1) {
-                child = value;
-            } else if (path[idx + 1] == '.') {
-                child = tao::json::empty_object;
-            } else if (path[idx + 1] == '[') {
-                child = tao::json::empty_array;
-            } else {
-                Expects(false);
-            }
-            if (preserve_array_indexes) {
-                int array_index = std::stoi(path.substr(offset, idx - offset));
-                if (array_index >= 0) {
-                    if (static_cast<std::size_t>(array_index) >= cur->get_array().size()) {
-                        cur->get_array().resize(static_cast<std::size_t>(array_index + 1), tao::json::null);
-                    }
-                    cur->at(static_cast<std::size_t>(array_index)) = child;
-                    cur = &cur->at(static_cast<std::size_t>(array_index));
-                } else {
-                    // index is negative, just append and let user decide what it means
-                    cur->get_array().push_back(child);
-                    cur = &cur->get_array().back();
-                }
-            } else {
-                cur->get_array().push_back(child);
-                cur = &cur->get_array().back();
-            }
-            ++idx;
-        }
-        offset = idx + 1;
-    }
-}
-} // namespace priv
-
-get_projected_response
-make_response(std::error_code ec, get_projected_request& request, get_projected_request::encoded_response_type encoded)
-{
-    get_projected_response response{ request.id, encoded.opaque(), ec };
-    if (!ec) {
-        response.cas = encoded.cas();
-        if (request.with_expiration) {
-            response.expiration = gsl::narrow_cast<std::uint32_t>(std::stoul(encoded.body().fields()[0].value));
-        }
-        if (request.effective_projections.empty()) {
-            // from full document
-            if (request.projections.empty() && request.with_expiration) {
-                // special case when user only wanted full+expiration
-                response.value = encoded.body().fields()[1].value;
-            } else {
-                tao::json::value full_doc = tao::json::from_string(encoded.body().fields()[request.with_expiration ? 1 : 0].value);
-                tao::json::value new_doc;
-                for (const auto& projection : request.projections) {
-                    auto value_to_apply = priv::subdoc_lookup(full_doc, projection);
-                    if (value_to_apply) {
-                        priv::subdoc_apply_projection(new_doc, projection, *value_to_apply, request.preserve_array_indexes);
-                    } else {
-                        response.ec = std::make_error_code(error::key_value_errc::path_not_found);
-                        return response;
-                    }
-                }
-                response.value = tao::json::to_string(new_doc);
-            }
-        } else {
-            tao::json::value new_doc = tao::json::empty_object;
-            std::size_t offset = request.with_expiration ? 1 : 0;
-            for (const auto& projection : request.projections) {
-                auto& field = encoded.body().fields()[offset++];
-                if (field.status == protocol::status::success && !field.value.empty()) {
-                    auto value_to_apply = tao::json::from_string(field.value);
-                    priv::subdoc_apply_projection(new_doc, projection, value_to_apply, request.preserve_array_indexes);
-                } else {
-                    response.ec = std::make_error_code(error::key_value_errc::path_not_found);
-                    return response;
-                }
-            }
-            response.value = tao::json::to_string(new_doc);
-        }
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/document_increment.hxx

@@ -1,84 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <protocol/cmd_increment.hxx>
-#include <protocol/durability_level.hxx>
-#include <operations.hxx>
-#include <protocol/client_response.hxx>
-
-namespace couchbase::operations
-{
-
-struct increment_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
-    std::uint64_t content{};
-    std::uint64_t cas{};
-    mutation_token token{};
-};
-
-struct increment_request {
-    using encoded_request_type = protocol::client_request<protocol::increment_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::increment_response_body>;
-
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::uint32_t expiration{ 0 };
-    std::uint64_t delta{ 1 };
-    std::optional<std::uint64_t> initial_value{};
-    protocol::durability_level durability_level{ protocol::durability_level::none };
-    std::optional<std::uint16_t> durability_timeout{};
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.opaque(opaque);
-        encoded.partition(partition);
-        encoded.body().id(id);
-        encoded.body().delta(delta);
-        if (initial_value) {
-            encoded.body().initial_value(initial_value.value());
-            encoded.body().expiration(expiration);
-        } else {
-            encoded.body().initial_value(0);
-            encoded.body().expiration(0xffff'ffff);
-        }
-        if (durability_level != protocol::durability_level::none) {
-            encoded.body().durability(durability_level, durability_timeout);
-        }
-    }
-};
-
-increment_response
-make_response(std::error_code ec, increment_request& request, increment_request::encoded_response_type encoded)
-{
-    increment_response response{ request.id, encoded.opaque(), ec };
-    if (!ec) {
-        response.cas = encoded.cas();
-        response.content = encoded.body().content();
-        response.token = encoded.body().token();
-        response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
-    }
-    return response;
-}
-
-} // namespace couchbase::operations

data/ext/couchbase/operations/document_insert.hxx

@@ -1,76 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2020 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 <document_id.hxx>
-#include <protocol/cmd_insert.hxx>
-#include <protocol/durability_level.hxx>
-
-namespace couchbase::operations
-{
-
-struct insert_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
-    std::uint64_t cas{};
-    mutation_token token{};
-};
-
-struct insert_request {
-    using encoded_request_type = protocol::client_request<protocol::insert_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::insert_response_body>;
-
-    document_id id;
-    std::string value;
-    uint16_t partition{};
-    uint32_t opaque{};
-    uint32_t flags{ 0 };
-    uint32_t expiration{ 0 };
-    protocol::durability_level durability_level{ protocol::durability_level::none };
-    std::optional<std::uint16_t> durability_timeout{};
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
-
-    void encode_to(encoded_request_type& encoded)
-    {
-        encoded.opaque(opaque);
-        encoded.partition(partition);
-        encoded.body().id(id);
-        encoded.body().expiration(expiration);
-        encoded.body().flags(flags);
-        encoded.body().content(value);
-        if (durability_level != protocol::durability_level::none) {
-            encoded.body().durability(durability_level, durability_timeout);
-        }
-    }
-};
-
-insert_response
-make_response(std::error_code ec, insert_request& request, insert_request::encoded_response_type encoded)
-{
-    insert_response response{ request.id, encoded.opaque(), ec };
-    if (!ec) {
-        response.cas = encoded.cas();
-        response.token = encoded.body().token();
-        response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
-    }
-    return response;
-}
-
-} // namespace couchbase::operations