couchbase 3.0.0.alpha.2 → 3.0.0.alpha.3

data/ext/couchbase/protocol/cmd_get_collection_id.hxx

@@ -0,0 +1,117 @@
+/* -*- 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 <gsl/gsl_assert>
+
+#include <protocol/client_opcode.hxx>
+#include <protocol/status.hxx>
+#include <protocol/cmd_info.hxx>
+
+namespace couchbase::protocol
+{
+
+class get_collection_id_response_body
+{
+  public:
+    static const inline client_opcode opcode = client_opcode::get_collection_id;
+
+  private:
+    std::uint64_t manifest_uid_;
+    std::uint32_t collection_uid_;
+
+  public:
+    [[nodiscard]] std::uint64_t manifest_uid()
+    {
+        return manifest_uid_;
+    }
+
+    [[nodiscard]] std::uint32_t collection_uid()
+    {
+        return collection_uid_;
+    }
+
+    bool parse(protocol::status status,
+               const header_buffer& header,
+               std::uint8_t framing_extras_size,
+               std::uint16_t key_size,
+               std::uint8_t extras_size,
+               const std::vector<uint8_t>& body,
+               const cmd_info&)
+    {
+        Expects(header[1] == static_cast<uint8_t>(opcode));
+        if (status == protocol::status::success && extras_size == 12) {
+            std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size;
+
+            memcpy(&manifest_uid_, body.data() + offset, sizeof(manifest_uid_));
+            manifest_uid_ = utils::byte_swap_64(manifest_uid_);
+            offset += 8;
+
+            memcpy(&collection_uid_, body.data() + offset, sizeof(collection_uid_));
+            collection_uid_ = ntohl(collection_uid_);
+            return true;
+        }
+        return false;
+    }
+};
+
+class get_collection_id_request_body
+{
+  public:
+    using response_body_type = get_collection_id_response_body;
+    static const inline client_opcode opcode = client_opcode::get_collection_id;
+
+  private:
+    std::string key_;
+
+  public:
+    void collection_path(const std::string& path)
+    {
+        key_ = path;
+    }
+
+    const std::string& key()
+    {
+        return key_;
+    }
+
+    const std::vector<std::uint8_t>& framing_extras()
+    {
+        static std::vector<std::uint8_t> empty;
+        return empty;
+    }
+
+    const std::vector<std::uint8_t>& extras()
+    {
+        static std::vector<std::uint8_t> empty;
+        return empty;
+    }
+
+    const std::vector<std::uint8_t>& value()
+    {
+        static std::vector<std::uint8_t> empty;
+        return empty;
+    }
+
+    std::size_t size()
+    {
+        return key_.size();
+    }
+};
+
+} // namespace couchbase::protocol

data/ext/couchbase/timeout_defaults.hxx

@@ -0,0 +1,32 @@
+/* -*- 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 <chrono>
+
+namespace couchbase::timeout_defaults
+{
+constexpr std::chrono::milliseconds connect_timeout{ 10'000 };
+constexpr std::chrono::milliseconds key_value_timeout{ 2'500 };
+constexpr std::chrono::milliseconds key_value_durable_timeout{ 10'000 };
+constexpr std::chrono::milliseconds view_timeout{ 75'000 };
+constexpr std::chrono::milliseconds query_timeout{ 75'000 };
+constexpr std::chrono::milliseconds analytics_timeout{ 75'000 };
+constexpr std::chrono::milliseconds search_timeout{ 75'000 };
+constexpr std::chrono::milliseconds management_timeout{ 75'000 };
+} // namespace couchbase::timeout_defaults

data/ext/couchbase/version.hxx

@@ -18,7 +18,7 @@
 #pragma once
 
 #define BACKEND_VERSION_MAJOR 0
-#define BACKEND_VERSION_MINOR 2
+#define BACKEND_VERSION_MINOR 3
 #define BACKEND_VERSION_PATCH 0
 
 #include <build_version.hxx>

data/ext/test/main.cxx

@@ -41,21 +41,21 @@ main()
     ruby_init_loadpath();
 
     rb_require(LIBCOUCHBASE_EXT_PATH);
+    rb_require("json");
     run_script(R"(
 p Couchbase::VERSION
 )");
 
     run_script(R"(
 B = Couchbase::Backend.new
-#B.open("192.168.42.101", "Administrator", "password")
 B.open("localhost", "Administrator", "password")
 )");
 
     run_script(R"(
-p B.open_bucket("default")
-p B.document_increment("default", "_default._default", "foo", {:initial_value => 32, :expiration => 42})
-p B.document_get("default", "_default._default", "foo")
-p B.document_decrement("default", "_default._default", "foo", {:initial_value => 32, :expiration => 42})
+query = {
+    query: "hello"
+}
+p B.document_search("beers", JSON.generate(query), {})
 )");
 
     run_script(R"(

data/lib/couchbase/binary_collection.rb

@@ -49,12 +49,14 @@ module Couchbase
     #
     # @return [CounterResult]
     def increment(id, options = IncrementOptions.new)
-      resp = @backend.document_increment(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id, {
-          delta: options.delta,
-          initial_value: options.initial,
-          expiration: options.expiration,
-          durability_level: options.durability_level,
-      })
+      resp = @backend.document_increment(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id,
+                                         options.timeout,
+                                         {
+                                             delta: options.delta,
+                                             initial_value: options.initial,
+                                             expiration: options.expiration,
+                                             durability_level: options.durability_level,
+                                         })
       CounterResult.new do |res|
         res.cas = resp[:cas]
         res.content = resp[:content]
@@ -69,12 +71,14 @@ module Couchbase
     #
     # @return [CounterResult]
     def decrement(id, options = DecrementOptions.new)
-      resp = @backend.document_decrement(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id, {
-          delta: options.delta,
-          initial_value: options.initial,
-          expiration: options.expiration,
-          durability_level: options.durability_level,
-      })
+      resp = @backend.document_decrement(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id,
+                                         options.timeout,
+                                         {
+                                             delta: options.delta,
+                                             initial_value: options.initial,
+                                             expiration: options.expiration,
+                                             durability_level: options.durability_level,
+                                         })
       CounterResult.new do |res|
         res.cas = resp[:cas]
         res.content = resp[:content]

data/lib/couchbase/binary_collection_options.rb

@@ -20,6 +20,7 @@ module Couchbase
       # @return [Integer] The default CAS used (0 means no CAS in this context)
       attr_accessor :cas
 
+      # @yieldparam [AppendOptions] self
       def initialize
         yield self if block_given?
       end
@@ -29,6 +30,7 @@ module Couchbase
       # @return [Integer] The default CAS used (0 means no CAS in this context)
       attr_accessor :cas
 
+      # @yieldparam [PrependOptions] self
       def initialize
         yield self if block_given?
       end
@@ -47,6 +49,7 @@ module Couchbase
       # @return [:none, :majority, :majority_and_persist_to_active, :persist_to_majority] level of durability
       attr_accessor :durability_level
 
+      # @yieldparam [IncrementOptions] self
       def initialize
         @delta = 1
         yield self if block_given?
@@ -73,6 +76,7 @@ module Couchbase
       # @return [:none, :majority, :majority_and_persist_to_active, :persist_to_majority] level of durability
       attr_accessor :durability_level
 
+      # @yieldparam [DecrementOptions] self
       def initialize
         @delta = 1
         yield self if block_given?

data/lib/couchbase/cluster.rb

@@ -21,6 +21,8 @@ require "couchbase/management/query_index_manager"
 require "couchbase/management/analytics_index_manager"
 require "couchbase/management/search_index_manager"
 
+require "couchbase/search_options"
+
 module Couchbase
   class Cluster
     alias_method :inspect, :to_s
@@ -110,8 +112,92 @@ module Couchbase
     # @param [SearchQuery] query the query tree
     # @param [SearchOptions] options the query tree
     #
-    # @return [QueryResult]
-    def search_query(index_name, query, options = SearchOptions.new) end
+    # @return [SearchResult]
+    def search_query(index_name, query, options = SearchOptions.new)
+      resp = @backend.document_search(index_name, JSON.generate(query), {
+          timeout: options.timeout,
+          limit: options.limit,
+          skip: options.skip,
+          explain: options.explain,
+          highlight_style: options.highlight_style,
+          highlight_fields: options.highlight_fields,
+          fields: options.fields,
+          sort: options.sort&.map { |v| JSON.generate(v) },
+          facets: options.facets&.map { |(k, v)| [k, JSON.generate(v)] },
+          scan_consistency: options.instance_variable_get("@scan_consistency"),
+          mutation_state: options.instance_variable_get("@mutation_state")&.tokens&.map { |t|
+            {
+                bucket_name: t.bucket_name,
+                partition_id: t.partition_id,
+                partition_uuid: t.partition_uuid,
+                sequence_number: t.sequence_number,
+            }
+          },
+      })
+
+      SearchResult.new do |res|
+        res.meta_data = SearchMetaData.new do |meta|
+          meta.metrics.max_score = resp[:meta_data][:metrics][:max_score]
+          meta.metrics.error_partition_count = resp[:meta_data][:metrics][:error_partition_count]
+          meta.metrics.success_partition_count = resp[:meta_data][:metrics][:success_partition_count]
+          meta.metrics.took = resp[:meta_data][:metrics][:took]
+          meta.metrics.total_rows = resp[:meta_data][:metrics][:total_rows]
+        end
+        res.rows = resp[:rows].map do |r|
+          SearchRow.new do |row|
+            row.transcoder = options.transcoder
+            row.index = r[:index]
+            row.id = r[:id]
+            row.score = r[:score]
+            row.fragments = r[:fragments]
+            row.locations = SearchRowLocations.new(
+                r[:locations].map do |loc|
+                  SearchRowLocation.new do |location|
+                    location.field = loc[:field]
+                    location.term = loc[:term]
+                    location.position = loc[:position]
+                    location.start_offset = loc[:start_offset]
+                    location.end_offset = loc[:end_offset]
+                    location.array_positions = loc[:array_positions]
+                  end
+                end
+            )
+            row.instance_variable_set("@fields", r[:fields])
+            row.explanation = JSON.parse(r[:explanation]) if r[:explanation]
+          end
+        end
+        res.facets = resp[:facets]&.each_with_object({}) do |(k, v), o|
+          facet = case options.facets[k]
+                  when SearchFacet::SearchFacetTerm
+                    SearchFacetResult::TermFacetResult.new do |f|
+                      f.terms = v[:terms]&.map do |t|
+                        SearchFacetResult::TermFacetResult::TermFacet.new(t[:term], t[:count])
+                      end || []
+                    end
+                  when SearchFacet::SearchFacetDateRange
+                    SearchFacetResult::DateRangeFacetResult.new do |f|
+                      f.date_ranges = v[:date_ranges]&.map do |r|
+                        SearchFacetResult::DateRangeFacetResult::DateRangeFacet.new(r[:name], r[:count], r[:start_time], r[:end_time])
+                      end || []
+                    end
+                  when SearchFacet::SearchFacetNumericRange
+                    SearchFacetResult::NumericRangeFacetResult.new do |f|
+                      f.numeric_ranges = v[:numeric_ranges]&.map do |r|
+                        SearchFacetResult::NumericRangeFacetResult::NumericRangeFacet.new(r[:name], r[:count], r[:min], r[:max])
+                      end || []
+                    end
+                  else
+                    next # ignore unknown facet result
+                  end
+          facet.name = v[:name]
+          facet.field = v[:field]
+          facet.total = v[:total]
+          facet.missing = v[:missing]
+          facet.other = v[:other]
+          o[k] = facet
+        end
+      end
+    end
 
     # @return [Management::UserManager]
     def users
@@ -361,12 +447,6 @@ module Couchbase
       end
     end
 
-    class SearchOptions
-      def initialize
-        yield self if block_given?
-      end
-    end
-
     class DiagnosticsOptions
       # @return [String] Holds custom report id.
       attr_accessor :report_id

data/lib/couchbase/collection.rb

@@ -49,12 +49,21 @@ module Couchbase
     #
     # @return [GetResult]
     def get(id, options = GetOptions.new)
-      resp = @backend.document_get(bucket_name, "#{@scope_name}.#{@name}", id)
+      resp = if options.need_projected_get?
+               @backend.document_get_projected(bucket_name, "#{@scope_name}.#{@name}", id,
+                                               options.timeout,
+                                               options.with_expiration,
+                                               options.projections,
+                                               options.preserve_array_indexes)
+             else
+               @backend.document_get(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout)
+             end
       GetResult.new do |res|
         res.transcoder = options.transcoder
         res.cas = resp[:cas]
         res.flags = resp[:flags]
         res.encoded = resp[:content]
+        res.expiration = resp[:expiration] if resp.key?(:expiration)
       end
     end
 
@@ -66,7 +75,7 @@ module Couchbase
     #
     # @return [GetResult]
     def get_and_lock(id, lock_time, options = GetAndLockOptions.new)
-      resp = @backend.document_get_and_lock(bucket_name, "#{@scope_name}.#{@name}", id, lock_time)
+      resp = @backend.document_get_and_lock(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, lock_time)
       GetResult.new do |res|
         res.transcoder = options.transcoder
         res.cas = resp[:cas]
@@ -83,7 +92,7 @@ module Couchbase
     #
     # @return [GetResult]
     def get_and_touch(id, expiration, options = GetAndTouchOptions.new)
-      resp = @backend.document_get_and_touch(bucket_name, "#{@scope_name}.#{@name}", id, expiration)
+      resp = @backend.document_get_and_touch(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, expiration)
       GetResult.new do |res|
         res.transcoder = options.transcoder
         res.cas = resp[:cas]
@@ -115,7 +124,7 @@ module Couchbase
     #
     # @return [ExistsResult]
     def exists(id, options = ExistsOptions.new)
-      resp = @backend.document_exists(bucket_name, "#{@scope_name}.#{@name}", id)
+      resp = @backend.document_exists(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout)
       ExistsResult.new do |res|
         res.status = resp[:status]
         res.partition_id = resp[:partition_id]
@@ -130,7 +139,7 @@ module Couchbase
     #
     # @return [MutationResult]
     def remove(id, options = RemoveOptions.new)
-      resp = @backend.document_remove(bucket_name, "#{@scope_name}.#{@name}", id, {
+      resp = @backend.document_remove(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, {
           durability_level: options.durability_level
       })
       MutationResult.new do |res|
@@ -148,7 +157,7 @@ module Couchbase
     # @return [MutationResult]
     def insert(id, content, options = InsertOptions.new)
       blob, flags = options.transcoder.encode(content)
-      resp = @backend.document_insert(bucket_name, "#{@scope_name}.#{@name}", id, blob, flags, {
+      resp = @backend.document_insert(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, blob, flags, {
           durability_level: options.durability_level,
           expiration: options.expiration,
       })
@@ -167,7 +176,7 @@ module Couchbase
     # @return [MutationResult]
     def upsert(id, content, options = UpsertOptions.new)
       blob, flags = options.transcoder.encode(content)
-      resp = @backend.document_upsert(bucket_name, "#{@scope_name}.#{@name}", id, blob, flags, {
+      resp = @backend.document_upsert(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, blob, flags, {
           durability_level: options.durability_level,
           expiration: options.expiration,
       })
@@ -186,7 +195,7 @@ module Couchbase
     # @return [MutationResult]
     def replace(id, content, options = ReplaceOptions.new)
       blob, flags = options.transcoder.encode(content)
-      resp = @backend.document_replace(bucket_name, "#{@scope_name}.#{@name}", id, blob, flags, {
+      resp = @backend.document_replace(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, blob, flags, {
           durability_level: options.durability_level,
           expiration: options.expiration,
           cas: options.cas,
@@ -205,7 +214,7 @@ module Couchbase
     #
     # @return [MutationResult]
     def touch(id, expiration, options = TouchOptions.new)
-      resp = @backend.document_touch(bucket_name, "#{@scope_name}.#{@name}", id, expiration)
+      resp = @backend.document_touch(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, expiration)
       MutationResult.new do |res|
         res.cas = resp[:cas]
       end
@@ -219,7 +228,7 @@ module Couchbase
     #
     # @raise [Error::DocumentNotFound]
     def unlock(id, cas, options = UnlockOptions.new)
-      @backend.document_unlock(bucket_name, "#{@scope_name}.#{@name}", id, cas)
+      @backend.document_unlock(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, cas)
     end
 
     # Performs lookups to document fragments
@@ -231,8 +240,14 @@ module Couchbase
     # @return [LookupInResult]
     def lookup_in(id, specs, options = LookupInOptions.new)
       resp = @backend.document_lookup_in(
-          bucket_name, "#{@scope_name}.#{@name}", id, options.access_deleted,
-          specs.map { |s| {opcode: s.type, xattr: s.xattr?, path: s.path} }
+          bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, options.access_deleted,
+          specs.map { |s|
+            {
+                opcode: s.type,
+                xattr: s.xattr?,
+                path: s.path
+            }
+          }
       )
       LookupInResult.new do |res|
         res.transcoder = options.transcoder
@@ -258,9 +273,18 @@ module Couchbase
     # @return [MutateInResult]
     def mutate_in(id, specs, options = MutateInOptions.new)
       resp = @backend.document_mutate_in(
-          bucket_name, "#{@scope_name}.#{@name}", id, options.access_deleted,
-          specs.map { |s| {opcode: s.type, path: s.path, param: s.param,
-                           xattr: s.xattr?, expand_macros: s.expand_macros?, create_parents: s.create_parents?} }, {
+          bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, options.access_deleted,
+          specs.map { |s|
+            {
+                opcode: s.type,
+                path: s.path,
+                param: s.param,
+                xattr: s.xattr?,
+                expand_macros: s.expand_macros?,
+                create_parents: s.create_parents?
+            }
+          },
+          {
               durability_level: options.durability_level
           }
       )