couchbase 4.0.0 → 4.1.2

package/deps/couchbase-cxx-client/couchbase/utils/connection_string.cxx

@@ -193,6 +193,18 @@ parse_option(tls_verify_mode& receiver, const std::string& /* name */, const std
     }
 }
 
+void
+parse_option(io::ip_protocol& receiver, const std::string& /* name */, const std::string& value)
+{
+    if (value == "any") {
+        receiver = io::ip_protocol::any;
+    } else if (value == "force_ipv4") {
+        receiver = io::ip_protocol::force_ipv4;
+    } else if (value == "force_ipv6") {
+        receiver = io::ip_protocol::force_ipv6;
+    }
+}
+
 void
 parse_option(std::size_t& receiver, const std::string& name, const std::string& value)
 {
@@ -294,7 +306,16 @@ extract_options(connection_string& connstr)
             /**
              * Sets the SDK configuration to do IPv4 Name Resolution
              */
-            parse_option(connstr.options.force_ipv4, name, value);
+            bool force_ipv4 = false;
+            parse_option(force_ipv4, name, value);
+            if (force_ipv4) {
+                connstr.options.use_ip_protocol = io::ip_protocol::force_ipv4;
+            }
+        } else if (name == "ip_protocol") {
+            /**
+             * Controls preference of IP protocol for name resolution
+             */
+            parse_option(connstr.options.use_ip_protocol, name, value);
         } else if (name == "config_poll_interval") {
             parse_option(connstr.options.config_poll_interval, name, value);
         } else if (name == "config_poll_floor") {

package/deps/couchbase-cxx-client/couchbase/utils/json.cxx

@@ -46,7 +46,7 @@ struct last_key_wins : Consumer {
 };
 
 tao::json::value
-parse(const std::string& input)
+parse(std::string_view input)
 {
     return tao::json::from_string<utils::json::last_key_wins>(input);
 }
@@ -68,4 +68,214 @@ generate(const tao::json::value& object)
 {
     return tao::json::to_string(object);
 }
+
+class to_byte_vector
+{
+  private:
+    std::vector<std::byte>& buffer_;
+    bool first_{ true };
+
+    void next()
+    {
+        if (!first_) {
+            buffer_.emplace_back(std::byte{ ',' });
+        }
+    }
+
+    void write(tao::binary_view data)
+    {
+        buffer_.reserve(buffer_.size() + data.size());
+        std::copy(data.begin(), data.end(), std::back_inserter(buffer_));
+    }
+
+    void write(std::string_view data)
+    {
+        buffer_.reserve(buffer_.size() + data.size());
+        std::transform(data.begin(), data.end(), std::back_inserter(buffer_), [](auto ch) { return static_cast<std::byte>(ch); });
+    }
+
+    inline void escape(const std::string_view s)
+    {
+        static std::array h{
+            std::byte{ '0' }, std::byte{ '1' }, std::byte{ '2' }, std::byte{ '3' }, std::byte{ '4' }, std::byte{ '5' },
+            std::byte{ '6' }, std::byte{ '7' }, std::byte{ '8' }, std::byte{ '9' }, std::byte{ 'a' }, std::byte{ 'b' },
+            std::byte{ 'c' }, std::byte{ 'd' }, std::byte{ 'e' }, std::byte{ 'f' },
+        };
+
+        const char* p = s.data();
+        const char* l = p;
+        const char* const e = p + s.size();
+        while (p != e) {
+            const char c = *p;
+            if (c == '\\' || c == '"') {
+                write({ l, static_cast<std::size_t>(p - l) });
+                l = ++p;
+                buffer_.emplace_back(std::byte{ '\\' });
+                buffer_.emplace_back(static_cast<std::byte>(c));
+            } else if (c < 32 || c == 127) {
+                write({ l, static_cast<std::size_t>(p - l) });
+                l = ++p;
+                switch (c) {
+                    case '\b':
+                        write("\\b");
+                        break;
+                    case '\f':
+                        write("\\f");
+                        break;
+                    case '\n':
+                        write("\\n");
+                        break;
+                    case '\r':
+                        write("\\r");
+                        break;
+                    case '\t':
+                        write("\\t");
+                        break;
+                    default:
+                        write(std::array{
+                          std::byte{ '\\' },
+                          std::byte{ 'u' },
+                          std::byte{ '0' },
+                          std::byte{ '0' },
+                          std::byte{ h[(c & 0xf0) >> 4] },
+                          std::byte{ h[c & 0x0f] },
+                        });
+                        write("\\u00");
+                }
+            } else {
+                ++p;
+            }
+        }
+        write({ l, static_cast<std::size_t>(p - l) });
+    }
+
+  public:
+    explicit to_byte_vector(std::vector<std::byte>& output) noexcept
+      : buffer_(output)
+    {
+    }
+
+    void null()
+    {
+        next();
+        static std::array literal_null{
+            std::byte{ 'n' },
+            std::byte{ 'u' },
+            std::byte{ 'l' },
+            std::byte{ 'l' },
+        };
+        write(literal_null);
+    }
+
+    void boolean(const bool v)
+    {
+        next();
+        if (v) {
+            static std::array literal_true{
+                std::byte{ 't' },
+                std::byte{ 'r' },
+                std::byte{ 'u' },
+                std::byte{ 'e' },
+            };
+            write(literal_true);
+        } else {
+            static std::array literal_false{
+                std::byte{ 'f' }, std::byte{ 'a' }, std::byte{ 'l' }, std::byte{ 's' }, std::byte{ 'e' },
+            };
+            write(literal_false);
+        }
+    }
+
+    void number(const std::int64_t v)
+    {
+        next();
+        char b[24]{};
+        const char* s = tao::json::itoa::i64toa(v, b);
+        write({ b, static_cast<std::size_t>(s - b) });
+    }
+
+    void number(const std::uint64_t v)
+    {
+        next();
+        char b[24]{};
+        const char* s = tao::json::itoa::u64toa(v, b);
+        write({ b, static_cast<std::size_t>(s - b) });
+    }
+
+    void number(const double v)
+    {
+        next();
+        if (!std::isfinite(v)) {
+            // if this throws, consider using non_finite_to_* transformers
+            throw std::runtime_error("non-finite double value invalid for JSON string representation");
+        }
+        char b[28];
+        const auto s = tao::json::ryu::d2s_finite(v, b);
+        write({ b, s });
+    }
+
+    void string(const std::string_view v)
+    {
+        next();
+        buffer_.emplace_back(std::byte{ '"' });
+        escape(v);
+        buffer_.emplace_back(std::byte{ '"' });
+    }
+
+    void binary(const tao::binary_view /*unused*/) // NOLINT(readability-convert-member-functions-to-static)
+    {
+        // if this throws, consider using binary_to_* transformers
+        throw std::runtime_error("binary data invalid for JSON string representation");
+    }
+
+    void begin_array(const std::size_t /*unused*/ = 0)
+    {
+        next();
+        buffer_.emplace_back(std::byte{ '[' });
+        first_ = true;
+    }
+
+    void element() noexcept
+    {
+        first_ = false;
+    }
+
+    void end_array(const std::size_t /*unused*/ = 0)
+    {
+        buffer_.emplace_back(std::byte{ ']' });
+    }
+
+    void begin_object(const std::size_t /*unused*/ = 0)
+    {
+        next();
+        buffer_.emplace_back(std::byte{ '{' });
+        first_ = true;
+    }
+
+    void key(const std::string_view v)
+    {
+        string(v);
+        buffer_.emplace_back(std::byte{ ':' });
+        first_ = true;
+    }
+
+    void member() noexcept
+    {
+        first_ = false;
+    }
+
+    void end_object(const std::size_t /*unused*/ = 0)
+    {
+        buffer_.emplace_back(std::byte{ '}' });
+    }
+};
+
+std::vector<std::byte>
+generate_binary(const tao::json::value& object)
+{
+    std::vector<std::byte> out;
+    tao::json::events::transformer<to_byte_vector> consumer(out);
+    tao::json::events::from_value(consumer, object);
+    return out;
+}
 } // namespace couchbase::utils::json

package/deps/couchbase-cxx-client/couchbase/utils/json.hxx

@@ -24,7 +24,7 @@
 namespace couchbase::utils::json
 {
 tao::json::value
-parse(const std::string& input);
+parse(std::string_view input);
 
 tao::json::value
 parse(const json_string& input);
@@ -34,4 +34,7 @@ parse(const char* input, std::size_t size);
 
 std::string
 generate(const tao::json::value& object);
+
+std::vector<std::byte>
+generate_binary(const tao::json::value& object);
 } // namespace couchbase::utils::json

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

@@ -39,7 +39,7 @@ noop_on_row(std::string&& /* row */)
 }
 
 #define STATE_MARKER_ROOT (reinterpret_cast<void*>(1))
-#define STATE_MARKER_ROWSET (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)
@@ -310,7 +310,7 @@ row_pop_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct jsonsl_sta
 }
 
 static void
-initial_action_pop_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct jsonsl_state_st* state, const jsonsl_char_t* /* at */)
+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);
 
@@ -321,6 +321,10 @@ initial_action_pop_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct
     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

package/deps/couchbase-cxx-client/couchbase/utils/unsigned_leb128.hxx

@@ -50,20 +50,20 @@ template<class T>
 typename std::enable_if_t<std::is_unsigned_v<T>, std::pair<T, std::string_view>>
 decode_unsigned_leb128(std::string_view buf, struct Leb128NoThrow /* unused */)
 {
-    T rv = static_cast<uint8_t>(buf[0]) & 0x7fULL;
+    T rv = static_cast<std::byte>(buf[0]) & std::byte{ 0b0111'1111 };
     size_t end = 0;
-    if ((static_cast<uint8_t>(buf[0]) & 0x80ULL) == 0x80ULL) {
+    if ((static_cast<std::byte>(buf[0]) & std::byte{ 0b1000'0000 }) == std::byte{ 0b1000'0000 }) {
         T shift = 7;
         // shift in the remaining data
         for (end = 1; end < buf.size(); end++) {
-            rv |= (static_cast<uint8_t>(buf[end]) & 0x7fULL) << shift;
-            if ((static_cast<uint8_t>(buf[end]) & 0x80ULL) == 0) {
+            rv |= (static_cast<std::byte>(buf[end]) & std::byte{ 0b0111'1111 }) << shift;
+            if ((static_cast<std::byte>(buf[end]) & std::byte{ 0b1000'0000 }) == std::byte{ 0 }) {
                 break; // no more
             }
             shift += 7;
         }
 
-        // We should of stopped for a stop byte, not the end of the buffer
+        // We should be stopped for a stop byte, not the end of the buffer
         if (end == buf.size()) {
             return { 0, std::string_view{} };
         }
@@ -87,7 +87,7 @@ template<class T>
 typename std::enable_if_t<std::is_unsigned_v<T>, std::pair<T, std::string_view>>
 decode_unsigned_leb128(std::string_view buf)
 {
-    if (buf.size() > 0) {
+    if (!buf.empty()) {
         auto rv = decode_unsigned_leb128<T>(buf, Leb128NoThrow());
         if (rv.second.data()) {
             return rv;
@@ -123,17 +123,17 @@ class unsigned_leb128<T, typename std::enable_if_t<std::is_unsigned_v<T>>>
     explicit unsigned_leb128(T in)
     {
         while (in > 0) {
-            auto byte = gsl::narrow_cast<uint8_t>(in & 0x7fULL);
+            auto byte = gsl::narrow_cast<std::byte>(in) & std::byte{ 0b0111'1111 };
             in >>= 7;
 
             // In has more data?
             if (in > 0) {
-                byte |= 0x80;
-                encodedData[encodedSize - 1U] = byte;
+                byte |= std::byte{ 0b1000'0000 };
+                encoded_data_[encoded_size_ - 1U] = byte;
                 // Increase the size
-                encodedSize++;
+                encoded_size_++;
             } else {
-                encodedData[encodedSize - 1U] = byte;
+                encoded_data_[encoded_size_ - 1U] = byte;
             }
         }
     }
@@ -143,29 +143,29 @@ class unsigned_leb128<T, typename std::enable_if_t<std::is_unsigned_v<T>>>
         return { begin(), end() };
     }
 
-    [[nodiscard]] const uint8_t* begin() const
+    [[nodiscard]] const std::byte* begin() const
     {
-        return encodedData.data();
+        return encoded_data_.data();
     }
 
-    [[nodiscard]] const uint8_t* end() const
+    [[nodiscard]] const std::byte* end() const
     {
-        return encodedData.data() + encodedSize;
+        return encoded_data_.data() + encoded_size_;
     }
 
-    [[nodiscard]] const uint8_t* data() const
+    [[nodiscard]] const std::byte* data() const
     {
-        return encodedData.data();
+        return encoded_data_.data();
     }
 
-    [[nodiscard]] size_t size() const
+    [[nodiscard]] std::size_t size() const
     {
-        return encodedSize;
+        return encoded_size_;
     }
 
-    constexpr static size_t getMaxSize()
+    constexpr static std::size_t get_max_size()
     {
-        return maxSize;
+        return max_size;
     }
 
   private:
@@ -173,9 +173,9 @@ class unsigned_leb128<T, typename std::enable_if_t<std::is_unsigned_v<T>>>
     static_assert(sizeof(T) <= 8, "Class is only valid for uint 8/16/64");
 
     // value is large enough to store ~0 as leb128
-    static constexpr size_t maxSize = sizeof(T) + (((sizeof(T) + 1) / 8) + 1);
-    std::array<uint8_t, maxSize> encodedData{};
-    uint8_t encodedSize{ 1 };
+    static constexpr std::size_t max_size = sizeof(T) + (((sizeof(T) + 1) / 8) + 1);
+    std::array<std::byte, max_size> encoded_data_{};
+    std::size_t encoded_size_{ 1 };
 };
 
 } // namespace couchbase::utils

package/deps/couchbase-cxx-client/couchbase/utils/url_codec.cxx

@@ -68,7 +68,7 @@ template<typename T>
 inline bool
 is_already_escape(T first, T last)
 {
-    first++; // ignore '%'
+    ++first; // ignore '%'
     std::size_t jj = 0;
     for (; first != last && jj < 2; ++jj, ++first) {
         if (!isxdigit(*first)) {
@@ -148,12 +148,12 @@ url_decode(Ti first, Ti last, To out, std::size_t& nout)
         if (*first == '%') {
             char nextbuf[3] = { 0 };
             std::size_t jj = 0;
-            first++;
+            ++first;
             nextbuf[0] = *first;
             for (; first != last && jj < 2; ++jj) {
                 nextbuf[jj] = *first;
                 if (jj != 1) {
-                    first++;
+                    ++first;
                 }
             }
             if (jj != 2) {
@@ -171,7 +171,7 @@ url_decode(Ti first, Ti last, To out, std::size_t& nout)
             *out = *first;
         }
 
-        out++;
+        ++out;
         nout++;
     }
     return true;

package/deps/couchbase-cxx-client/couchbase/view_scan_consistency.hxx

@@ -0,0 +1,27 @@
+/* -*- 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
+
+namespace couchbase
+{
+enum class view_scan_consistency {
+    not_bounded = 0,
+    update_after,
+    request_plus,
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/view_sort_order.hxx

@@ -0,0 +1,23 @@
+/* -*- 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
+
+namespace couchbase
+{
+enum class view_sort_order { ascending = 0, descending };
+} // namespace couchbase

package/deps/couchbase-cxx-client/test/CMakeLists.txt

@@ -10,6 +10,7 @@ integration_test(durability)
 integration_test(arithmetic)
 integration_test(collections)
 integration_test(subdoc)
+integration_test(analytics)
 
 unit_test(connection_string)
 unit_test(utils)

package/deps/couchbase-cxx-client/test/benchmark_integration_get.cxx

@@ -30,7 +30,7 @@ TEST_CASE("benchmark: get a document", "[benchmark]")
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::upsert_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::json::generate_binary(value) };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);