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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2f04fbb0e401e651bfd4bd2dbf4c007bd4477535bcbcb034a05cafb30073e60
-  data.tar.gz: 2ac189a752cd13ff5818cb2e0d24f4987b7489d9ec750cf0c609a0b54270d357
+  metadata.gz: 2f04be590e37a0caa7dcc5370465f12bb342472b27a038a1eda9313aa2d9c350
+  data.tar.gz: 68c6fa7619fed0e1120e02b12b7801bd8a290af5c245c0bd903bec3f6f384c56
 SHA512:
-  metadata.gz: 958e94982f6b1c65a00848611262fa88553bdd2e73bf7c607cd89c4b1f7fe765b836fecd822e3511196ae946491b392b2b066c6e7d60ea7f4b6bbd010dce48cd
-  data.tar.gz: 53b1c9c2fca60c958fb9c221fbb7bb46011e6cb224cc218fe818fe08c4d310c481c3166ef7391239ecbe9e2e6ec57ac6f631158426d379594022b12e65298aef
+  metadata.gz: 516c34d37074c8f6688e89c4ce00680ec4f1e33b2ff48e559d127a0fb63e20bd6cc5f71dc7c36808c53a59c6706541de2e184bb497db2c239badbb7bf1ba358a
+  data.tar.gz: e02e2c184b0057029274f723b0d28027d77022c84bb99fc5111867011532f3d4f34380a647368e0a38997d610db1e9649b66298a75a63a7ff4d7e459a578b220

data/README.md

@@ -1,22 +1,29 @@
-# Couchbase Ruby Client [![tests](https://github.com/couchbase/couchbase-ruby-client/workflows/tests/badge.svg)](https://github.com/couchbase/couchbase-ruby-client/actions?query=workflow%3Atests)
+# Couchbase Ruby Client
+
+[![license](https://img.shields.io/github/license/couchbase/couchbase-ruby-client?color=brightgreen)](https://opensource.org/licenses/Apache-2.0)
+[![gem](https://img.shields.io/gem/v/couchbase?color=brightgreen)](https://rubygems.org/gems/couchbase)
+[![commits](https://img.shields.io/github/commits-since/couchbase/couchbase-ruby-client/latest?color=brightgreen)](https://github.com/couchbase/couchbase-ruby-client/commits/main)
+[![linters](https://img.shields.io/github/actions/workflow/status/couchbase/couchbase-ruby-client/linters.yml?branch=main&label=linters)](https://github.com/couchbase/couchbase-ruby-client/actions?query=workflow%3Alinters)
 
 This repository contains the third generation of the official Couchbase SDK for Ruby (aka. SDKv3)
 
 ## Support and Feedback
 
-If you find an issue, please file it in [our JIRA issue tracker](http://couchbase.com/issues/browse/RCBC).
-Also you are always welcome on [our forum](https://forums.couchbase.com/c/ruby-sdk).
+If you find an issue, please file it in [our JIRA issue tracker](https://couchbase.com/issues/browse/RCBC). Also you are
+always welcome on [our forum](https://forums.couchbase.com/c/ruby-sdk) and [Discord](https://discord.com/invite/sQ5qbPZuTh).
 
-Please attach version information to ticket/post. To obtain this information use the following command:
+Please attach version information to the ticket/post. To obtain this information, use the following command:
 
     $ ruby -r couchbase -e 'p Couchbase::VERSION'
 
 ## Installation
 
+The library has been tested with MRI 3.0, 3.1, 3.2 and 3.3. Supported platforms are Linux and MacOS.
+
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.0.0.alpha.5"
+gem "couchbase", "3.5.1"
 ```
 
 And then execute:
@@ -25,21 +32,94 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install --pre couchbase
+    $ gem install couchbase
+
+For some platforms we precompile binary packages. When, for some reason, binary packages cannot be used, pass
+`--platform=ruby` to the `gem install` command (or check the `specific_platform` and `force_ruby_platform` options of Bundler).
+In latter case, see the [Development](#development) section for build dependencies.
 
-For some platforms we precompile binary packages. When, for some reason, binary package cannot be used, pass
-`--platform=ruby` to `gem install` command (or check `specific_platform` and `force_ruby_platform` options of Bundler).
-In latter case, see [Development](#development) section for build dependencies.
+## Usage
+
+Here are some basic steps demonstrating basic operations with data:
+
+```ruby
+require "couchbase"
+include Couchbase # include Couchbase module for brevity
+
+# initialize library
+cluster = Cluster.connect("couchbase://127.0.0.1", "Administrator", "password")
+
+# open bucket and collection for data operations
+bucket = cluster.bucket("my_bucket")
+collection = bucket.default_collection
+
+# update or insert the document
+res = collection.upsert("foo", {"bar" => 42})
+res.cas
+#=> 22120998714646
+
+# retrieve document from the collection
+res = collection.get("foo")
+res.cas
+#=> 22120998714646
+res.content
+#=> {"bar"=>42}
+
+# remove document
+res = collection.remove("foo")
+res.cas
+#=> 47891154812182
+
+# fetch top-3 cities by number of hotels in the collection
+res = cluster.query("
+          SELECT city, COUNT(*) AS cnt FROM `travel-sample`
+          WHERE type = $type
+          GROUP BY city
+          ORDER BY cnt DESC
+          LIMIT 3",
+        Options::Query(named_parameters: {type: "hotel"}, metrics: true))
+res.rows.each do |row|
+  p row
+end
+#=> {"city"=>"San Francisco", "cnt"=>132}
+#   {"city"=>"London", "cnt"=>67}
+#   {"city"=>"Paris", "cnt"=>64}
+```
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive
 prompt that will allow you to experiment.
 
-Part of the library is written in C++, and requires both C and C++ compilers installed on the system. To configure build
-environment, it uses `cmake`. When these tools installed, the build process is easy:
+### Compiling
+
+Part of the library is written in C++, and requires both C and C++ compilers installed on the system. To configure the build
+environment it uses `cmake`. When these tools are installed, the build process is easy:
+
+    $ bundle exec rake compile
+
+### Testing
+
+By default, a mock cluster is used for testing. If you wish to use a real cluster, you can define the
+`TEST_CONNECTION_STRING` environment variable (e.g. `TEST_CONNECTION_STRING=couchbase://localhost`). You might also need to set the values for the `TEST_USERNAME`, `TEST_PASSWORD`, and `TEST_BUCKET`
+ environment variables.
 
-    $ rake compile
+To run the tests:
+
+    $ bundle exec rake test
+
+### Linting
+
+We use the [RuboCop linter](https://rubocop.org/). To run it:
+
+    $ bundle exec rubocop
+
+### Packaging
+
+To build and install the Ruby gem (where `VERSION` is the current version of the SDK):
+
+    $ gem build couchbase.gemspec
+    $ gem install couchbase-VERSION.snapshot.gem
 
 ## Generate Documentation
 
@@ -51,10 +131,24 @@ The following steps will generate API reference for selected git tag:
 
     $ rake doc
 
-Now the API reference is accessible using web browser (where `VERSION` is current version of the SDK)
+Now the API reference is accessible using a web browser (where `VERSION` is the current version of the SDK)
 
     $ firefox doc/couchbase-ruby-client-VERSION/index.html
 
 ## License
 
 The gem is available as open source under the terms of the [Apache2 License](https://opensource.org/licenses/Apache-2.0).
+
+    Copyright 2011-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.

data/ext/extconf.rb

@@ -1,47 +0,0 @@
-require "mkmf"
-require "fileutils"
-require "tempfile"
-
-unless find_executable("cmake")
-  abort "ERROR: CMake is required to build couchbase extension."
-end
-
-def sys(*cmd)
-  puts "-- #{Dir.pwd}"
-  puts "-- #{cmd.join(" ")}"
-  system(*cmd)
-end
-
-
-build_type = ENV["DEBUG"] ? "Debug" : "RelWithDebInfo"
-cmake_flags = [
-  "-DCMAKE_BUILD_TYPE=#{build_type}",
-  "-DRUBY_HDR_DIR=#{RbConfig::CONFIG["rubyhdrdir"]}",
-  "-DRUBY_ARCH_HDR_DIR=#{RbConfig::CONFIG["rubyarchhdrdir"]}",
-  "-DTAOCPP_JSON_BUILD_TESTS=OFF",
-  "-DTAOCPP_JSON_BUILD_EXAMPLES=OFF",
-  "-DSNAPPY_BUILD_TESTS=OFF",
-  "-DSNAPPY_INSTALL=OFF",
-]
-openssl_root = `brew --prefix openssl 2> /dev/null`.strip
-unless openssl_root.empty?
-  cmake_flags << "-DOPENSSL_ROOT_DIR=#{openssl_root}"
-end
-
-project_path = File.expand_path(File.join(__dir__))
-build_dir = ENV['EXT_BUILD_DIR'] || File.join(Dir.tmpdir, "couchbase-rubygem-#{build_type}-#{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}")
-FileUtils.mkdir_p(build_dir)
-Dir.chdir(build_dir) do
-  sys("cmake", *cmake_flags, project_path)
-  sys("make -j4 VERBOSE=1")
-end
-extension_name = "libcouchbase.#{RbConfig::CONFIG["SOEXT"]}"
-extension_path = File.expand_path(File.join(build_dir, extension_name))
-unless File.file?(extension_path)
-  abort "ERROR: failed to build extension in #{extension_path}"
-end
-extension_name.gsub!(/\.dylib/, '.bundle')
-install_path = File.expand_path(File.join(__dir__, "..", "lib", "couchbase", extension_name))
-puts "-- copy extension to #{install_path}"
-FileUtils.cp(extension_path, install_path)
-create_makefile("libcouchbase")

data/lib/active_support/cache/couchbase_store.rb

@@ -0,0 +1,339 @@
+#  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.
+
+require "couchbase"
+require "digest/sha2"
+require "active_support/cache"
+
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores data in Couchbase: https://couchbase.com
+    #
+    # * Local cache. Hot in-memory primary cache within block/middleware scope.
+    # * +read_multi+ and +write_multi+ support.
+    # * +delete_matched+ support using N1QL queries.
+    # * +clear+ for erasing whole collection (optionally can flush the bucket).
+    #
+    # To use this store, add the select it in application config
+    #
+    #     config.cache_store = :couchbase_store, {
+    #       connection_string: "couchbase://localhost",
+    #       username: "app_cache_user",
+    #       password: "s3cret",
+    #       bucket: "app_cache"
+    #     }
+    #
+    # @see https://guides.rubyonrails.org/caching_with_rails.html#cache-stores
+    class CouchbaseStore < Store
+      MAX_KEY_BYTESIZE = 250
+      DEFAULT_ERROR_HANDLER = lambda do |method:, returning:, exception:, logger: CouchbaseStore.logger|
+        logger&.error { "CouchbaseStore: #{method} failed, returned #{returning.inspect}: #{exception.class}: #{exception.message}" }
+      end
+
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
+      prepend Strategy::LocalCache
+
+      def initialize(options = nil)
+        super
+        @error_handler = @options.delete(:error_handler) { DEFAULT_ERROR_HANDLER }
+        @couchbase_options = {}
+        @couchbase_options[:connection_string] =
+          @options.delete(:connection_string) do
+            raise ArgumentError, "Missing connection string for Couchbase cache store. Use :connection_string in the store options"
+          end
+        @couchbase_options[:username] =
+          @options.delete(:username) do
+            raise ArgumentError, "Missing username for Couchbase cache store. Use :username in the store options"
+          end
+        @couchbase_options[:password] =
+          @options.delete(:password) do
+            raise ArgumentError, "Missing password for Couchbase cache store. Use :password in the store options"
+          end
+        @couchbase_options[:bucket] =
+          @options.delete(:bucket) { raise ArgumentError, "Missing bucket for Couchbase cache store. Use :bucket in the store options" }
+        @couchbase_options[:scope] = @options.delete(:scope) if @options.key?(:scope)
+        @couchbase_options[:collection] = @options.delete(:collection) if @options.key?(:collection)
+        @last_mutation_token = nil
+      end
+
+      def collection
+        @collection ||= build_collection
+      end
+
+      def cluster
+        @cluster ||= build_cluster
+      end
+
+      def inspect
+        "#<#{self.class} options=#{options.inspect} collection=#{@collection.inspect}>"
+      end
+
+      # Deletes all entries with keys matching the regular expression.
+      #
+      # The +matcher+ must be valid pattern for N1QL +REGEXP_MATCHES+ function. More info at
+      # https://docs.couchbase.com/server/current/n1ql/n1ql-language-reference/patternmatchingfun.html#section_regex_matches
+      #
+      # Because the operation performed on query engine, and it might take time to propagate changes
+      # from key/value engine to the indexer. Therefore the keys, that were created a moment ago
+      # might not be deleted.
+      #
+      # Also this method assumes, that primary index created on the target bucket
+      def delete_matched(matcher, _options = nil)
+        pattern =
+          case matcher
+          when Regexp
+            matcher.inspect[1..-2]
+          when String
+            matcher.tr("?", ".").gsub("*", ".*")
+          else
+            raise NotImplementedError, "Unable to convert #{matcher.inspect} to Regexp pattern"
+          end
+        operation_options = ::Couchbase::Options::Query(named_parameters: {"pattern" => pattern}, metrics: true)
+        operation_options.consistent_with(::Couchbase::MutationState.new(@last_mutation_token)) if @last_mutation_token
+        begin
+          result = cluster.query("DELETE FROM #{scope_qualifier} cache WHERE REGEXP_MATCHES(META(cache).id, $pattern)", operation_options)
+          result.meta_data.metrics.mutation_count
+        rescue ::Couchbase::Error::ParsingFailure, ::Couchbase::Error::ServiceNotAvailable
+          raise NotImplementedError, "The server does not support delete_matched operation"
+        end
+      end
+
+      # Increments an integer value in the cache.
+      #
+      # Note that it uses binary collection interface, therefore will fail if the value is not
+      # represented as ASCII-encoded number using +:raw+.
+      def increment(name, amount = 1, expires_in: nil, initial: nil, **options)
+        instrument :increment, name, amount: amount do
+          failsafe :increment do
+            key = normalize_key(name, options)
+            res = collection.binary.increment(
+              key, ::Couchbase::Options::Increment(delta: amount, expiry: expires_in, initial: initial)
+            )
+            @last_mutation_token = res.mutation_token
+            res.content
+          end
+        end
+      end
+
+      # Decrements an integer value in the cache.
+      #
+      # Note that it uses binary collection interface, therefore will fail if the value is not
+      # represented as ASCII-encoded number using +:raw+.
+      #
+      # Note that the counter represented by non-negative number on the server, and it will not
+      # cycle to maximum integer when decrementing zero.
+      def decrement(name, amount = 1, expires_in: nil, initial: nil, **_options)
+        instrument :decrement, name, amount: amount do
+          failsafe :decrement do
+            key = normalize_key(name, options)
+            res = collection.binary.decrement(
+              key, ::Couchbase::Options::Decrement(delta: amount, expiry: expires_in, initial: initial)
+            )
+            @last_mutation_token = res.mutation_token
+            res.content
+          end
+        end
+      end
+
+      # Clears the entire cache. Be careful with this method since it could
+      # affect other processes if shared cache is being used.
+      #
+      # When +use_flush+ option set to +true+ it will flush the bucket. Otherwise, it uses N1QL query
+      # and relies on default index.
+      def clear(use_flush: false, **_options)
+        failsafe(:clear) do
+          if use_flush
+            cluster.buckets.flush_bucket(@couchbase_options[:bucket_name])
+          else
+            operation_options = ::Couchbase::Options::Query.new
+            operation_options.consistent_with(::Couchbase::MutationState.new(@last_mutation_token)) if @last_mutation_token
+            cluster.query("DELETE FROM #{scope_qualifier}", operation_options)
+          end
+        end
+      end
+
+      private
+
+      def deserialize_entry(payload, raw: false, **)
+        if payload && raw
+          Entry.new(payload, compress: false)
+        else
+          super(payload)
+        end
+      end
+
+      def serialize_entry(entry, raw: false, **options)
+        if raw
+          entry.value.to_s
+        else
+          super(entry, **options)
+        end
+      end
+
+      def serialize_entries(entries, **options)
+        entries.transform_values do |entry|
+          serialize_entry(entry, **options)
+        end
+      end
+
+      # Reads an entry from the cache
+      def read_entry(key, **options)
+        deserialize_entry(read_serialized_entry(key, **options), **options)
+      end
+
+      def read_serialized_entry(key, **)
+        failsafe(:read_entry, returning: nil) do
+          res = collection.get(key, ::Couchbase::Options::Get(transcoder: nil))
+          res.content
+        end
+      end
+
+      # Reads multiple entries from the cache implementation. Subclasses MAY
+      # implement this method.
+      def read_multi_entries(names, **options)
+        return {} if names.empty?
+
+        keys = names.map { |name| normalize_key(name, options) }
+        return_value = {}
+        failsafe(:read_multi_entries, returning: return_value) do
+          results = collection.get_multi(keys, ::Couchbase::Options::GetMulti(transcoder: nil))
+          results.each_with_index do |result, index|
+            next unless result.success?
+
+            entry = deserialize_entry(result.content, raw: options[:raw])
+            unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(names[index], options))
+              return_value[names[index]] = entry.value
+            end
+          end
+          return_value
+        end
+      end
+
+      # Writes an entry to the cache
+      def write_entry(key, entry, raw: false, **options)
+        write_serialized_entry(key, serialize_entry(entry, raw: raw, **options), raw: raw, **options)
+      end
+
+      def write_serialized_entry(key, payload, expires_in: nil, race_condition_ttl: nil, raw: false, **)
+        if race_condition_ttl && expires_in && expires_in.positive? && !raw
+          # Add few minutes to expiry in the future to support race condition TTLs on read
+          expires_in += 5.minutes
+        end
+        failsafe(:write_entry, returning: false) do
+          res = collection.upsert(key, payload, ::Couchbase::Options::Upsert(transcoder: nil, expiry: expires_in))
+          @last_mutation_token = res.mutation_token
+          true
+        end
+      end
+
+      def write_multi_entries(entries, **options)
+        return 0 if entries.empty?
+
+        return super if local_cache
+
+        expires_in = options[:expires_in]
+        if options[:race_condition_ttl] && expires_in && expires_in.positive?
+          # Add few minutes to expiry in the future to support race condition TTLs on read
+          expires_in += 5.minutes
+        end
+        operation_options = ::Couchbase::Options::UpsertMulti(transcoder: nil, expiry: expires_in)
+        failsafe(:write_multi_entries, returning: nil) do
+          successful = collection.upsert_multi(serialize_entries(entries, **options), operation_options).select(&:success?)
+          return 0 if successful.empty?
+
+          @last_mutation_token = successful.max_by { |r| r.mutation_token.sequence_number }
+          successful.count
+        end
+      end
+
+      # Deletes an entry from the cache implementation. Subclasses must
+      # implement this method.
+      def delete_entry(key, **_options)
+        failsafe(:delete_entry, returning: false) do
+          res = collection.remove(key)
+          @last_mutation_token = res.mutation_token
+          true
+        end
+      end
+
+      # Deletes multiple entries in the cache. Returns the number of entries deleted.
+      def delete_multi_entries(entries, **_options)
+        return if entries.empty?
+
+        failsafe(:delete_multi_entries, returning: nil) do
+          successful = collection.remove_multi(entries).select(&:success?)
+          return 0 if successful.empty?
+
+          @last_mutation_token = successful.max_by { |r| r.mutation_token.sequence_number }
+          successful.count
+        end
+      end
+
+      def failsafe(method, returning: nil)
+        yield
+      rescue ::Couchbase::Error::CouchbaseError => e
+        ActiveSupport.error_reporter&.report(e, handled: true, severity: :warning)
+        @error_handler&.call(method: method, exception: e, returning: returning)
+        returning
+      end
+
+      # Truncate keys that exceed 250 characters
+      def normalize_key(key, options)
+        truncate_key super
+      end
+
+      def truncate_key(key)
+        if key && key.bytesize > MAX_KEY_BYTESIZE
+          suffix = ":sha2:#{::Digest::SHA2.hexdigest(key)}"
+          truncate_at = MAX_KEY_BYTESIZE - suffix.bytesize
+          "#{key.mb_chars.limit(truncate_at)}#{suffix}"
+        else
+          key
+        end
+      end
+
+      # Connects to the Couchbase cluster
+      def build_cluster
+        ::Couchbase::Cluster.connect(
+          @couchbase_options[:connection_string],
+          ::Couchbase::Options::Cluster(authenticator: ::Couchbase::PasswordAuthenticator.new(
+            @couchbase_options[:username], @couchbase_options[:password]
+          ))
+        )
+      end
+
+      # Connects to the Couchbase cluster, opens specified bucket and returns collection object.
+      def build_collection
+        bucket = cluster.bucket(@couchbase_options[:bucket])
+        if @couchbase_options[:scope] && @couchbase_options[:collection]
+          bucket.scope(@couchbase_options[:scope]).collection(@couchbase_options[:collection])
+        else
+          bucket.default_collection
+        end
+      end
+
+      def scope_qualifier
+        if @couchbase_options[:scope] && @couchbase_options[:collection]
+          "`#{@couchbase_options[:bucket]}`.#{@couchbase_options[:scope]}.#{@couchbase_options[:collection]}"
+        else
+          "`#{@couchbase_options[:bucket]}`"
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/analytics_options.rb

@@ -1,4 +1,4 @@
-#    Copyright 2020 Couchbase, Inc.
+#  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.
@@ -12,67 +12,10 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-require 'couchbase/json_transcoder'
+require "couchbase/json_transcoder"
 
 module Couchbase
   class Cluster
-    class AnalyticsOptions
-      # @return [Integer] Timeout in milliseconds
-      attr_accessor :timeout
-
-      # @return [String] Provides a custom client context ID for this query
-      attr_accessor :client_context_id
-
-      # @return [:not_bounded, :request_plus] specifies level of consistency for the query
-      attr_accessor :scan_consistency
-
-      # @return [Integer] The maximum duration (in milliseconds) the query engine is willing to wait before failing.
-      attr_accessor :scan_wait
-
-      # @return [Boolean] Allows explicitly marking a query as being readonly and not mutating and documents on the server side.
-      attr_accessor :readonly
-
-      # @return [Boolean] Allows to give certain requests higher priority than others
-      attr_accessor :priority
-
-      # @return [JsonTranscoder] transcoder to use on rows
-      attr_accessor :transcoder
-
-      # @yieldparam [AnalyticsOptions] self
-      def initialize
-        @transcoder = JsonTranscoder.new
-        @raw_parameters = {}
-        @positional_parameters = nil
-        @named_parameters = nil
-        @scan_consistency = nil
-        yield self if block_given?
-      end
-
-      # Sets positional parameters for the query
-      #
-      # @param [Array] positional the list of parameters that have to be substituted in the statement
-      def positional_parameters(positional)
-        @positional_parameters = positional
-        @named_parameters = nil
-      end
-
-      # Sets named parameters for the query
-      #
-      # @param [Hash] named the key/value map of the parameters to substitute in the statement
-      def named_parameters(named)
-        @named_parameters = named
-        @positional_parameters = nil
-      end
-
-      # Allows providing custom JSON key/value pairs for advanced usage
-      #
-      # @param [String] key the parameter name (key of the JSON property)
-      # @param [Object] value the parameter value (value of the JSON property)
-      def raw(key, value)
-        @raw_parameters[key] = JSON.generate(value)
-      end
-    end
-
     class AnalyticsWarning
       # @return [Integer]
       attr_accessor :code
@@ -162,4 +105,3 @@ module Couchbase
     end
   end
 end
-