couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/examples/managing_buckets.rb

@@ -0,0 +1,47 @@
+require 'couchbase'
+include Couchbase
+
+def measure(msg)
+  start = Time.now
+  yield
+  printf "%s in %.2f seconds\n", msg, Time.now - start
+end
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+bucket_name = "new_bucket"
+
+all_buckets = cluster.buckets.get_all_buckets
+puts "There are #{all_buckets.size} buckets on the cluster"
+all_buckets.each do |bucket|
+  puts " * #{bucket.name} (type: #{bucket.bucket_type}, quota: #{bucket.ram_quota_mb} MB)"
+end
+
+if all_buckets.any? { |bucket| bucket.name == bucket_name }
+  measure("Bucket #{bucket_name.inspect} removed") { cluster.buckets.drop_bucket(bucket_name) }
+end
+
+settings = Management::BucketSettings.new
+settings.name = bucket_name
+settings.ram_quota_mb = 100
+settings.flush_enabled = true
+measure("New bucket #{bucket_name.inspect} created") { cluster.buckets.create_bucket(settings) }
+
+sleep(1)
+
+settings = cluster.buckets.get_bucket(bucket_name)
+puts "Bucket #{bucket_name.inspect} settings:"
+puts " * healthy?           : #{settings.healthy?}"
+puts " * RAM quota          : #{settings.ram_quota_mb}"
+puts " * number of replicas : #{settings.num_replicas}"
+puts " * flush enabled:     : #{settings.flush_enabled}"
+puts " * max TTL            : #{settings.max_expiry}"
+puts " * compression mode   : #{settings.compression_mode}"
+puts " * replica indexes    : #{settings.replica_indexes}"
+puts " * ejection policy    : #{settings.ejection_policy}"
+
+measure("Bucket #{bucket_name.inspect} flushed") { cluster.buckets.flush_bucket(bucket_name) }
+
+cluster.disconnect

data/examples/managing_collections.rb

@@ -0,0 +1,58 @@
+require 'couchbase'
+include Couchbase
+
+def measure(msg)
+  start = Time.now
+  yield
+  printf "%s in %.2f seconds\n", msg, Time.now - start
+end
+
+bucket_name = "travel-sample"
+scope_name = "myapp"
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+bucket = cluster.bucket(bucket_name)
+
+
+scopes = bucket.collections.get_all_scopes
+puts "There are #{scopes.size} on the bucket \"#{bucket_name}\""
+
+scopes.each do |scope|
+  puts "  * \"#{scope.name}\" (#{scope.collections.size})"
+  scope.collections.each do |collection|
+    puts "    * \"#{collection.name}\""
+  end
+end
+
+if scopes.any? {|scope| scope.name == scope_name }
+  measure("Scope \"#{scope_name}\" has been removed") { bucket.collections.drop_scope(scope_name) }
+end
+measure("Scope \"#{scope_name}\" has been created") { bucket.collections.create_scope(scope_name) }
+
+scope = bucket.collections.get_scope(scope_name)
+puts "Scope \"#{scope_name}\" has #{scope.collections.size} collections"
+
+collection = Management::CollectionSpec.new
+collection.scope_name = scope_name
+collection.name = "users"
+measure("Collection \"#{collection.name}\" on scope \"#{collection.scope_name}\" has been created") do
+  bucket.collections.create_collection(collection)
+end
+
+scope = bucket.collections.get_scope(scope_name)
+puts "Scope \"#{scope_name}\" has #{scope.collections.size} collections"
+scope.collections.each do |collection|
+  puts "  * \"#{collection.name}\""
+end
+
+measure("Collection \"#{collection.name}\" on scope \"#{collection.scope_name}\" has been dropped") do
+  bucket.collections.drop_collection(collection)
+end
+
+scope = bucket.collections.get_scope(scope_name)
+puts "Scope \"#{scope_name}\" has #{scope.collections.size} collections"
+scope.collections.each do |collection|
+  puts "  * \"#{collection.name}\""
+end

data/examples/managing_query_indexes.rb

@@ -0,0 +1,63 @@
+require 'couchbase'
+include Couchbase
+
+def measure(msg)
+  start = Time.now
+  yield
+  printf "%s in %.2f seconds\n", msg, Time.now - start
+end
+
+def display_indexes(indexes, bucket_name)
+  puts "There are #{indexes.size} query indexes in the bucket \"#{bucket_name}\":"
+  indexes.each do |index|
+    print "  * [#{index.state}] #{index.name}"
+    if index.primary?
+      print " (primary)"
+    end
+    unless index.index_key.empty?
+      print " on [#{index.index_key.join(", ")}]"
+    end
+    if index.condition
+      print " where #{index.condition}"
+    end
+    puts
+  end
+end
+
+bucket_name = "beer-sample"
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+display_indexes(cluster.query_indexes.get_all_indexes(bucket_name), bucket_name)
+
+index_name = "demo_index"
+options = Management::QueryIndexManager::DropIndexOptions.new
+options.ignore_if_does_not_exist = true
+measure("Index \"#{index_name}\" has been dropped") { cluster.query_indexes.drop_index(bucket_name, index_name, options) }
+
+options = Management::QueryIndexManager::CreateIndexOptions.new
+options.ignore_if_exists = true
+options.condition = "abv > 2"
+measure("Index \"#{index_name}\" has been created") { cluster.query_indexes.create_index(bucket_name, index_name, %w[`type` `name`], options) }
+
+options = Management::QueryIndexManager::DropPrimaryIndexOptions.new
+options.ignore_if_does_not_exist = true
+measure("Primary index \"#{bucket_name}\" has been dropped") { cluster.query_indexes.drop_primary_index(bucket_name, options) }
+
+options = Management::QueryIndexManager::CreatePrimaryIndexOptions.new
+options.deferred = true
+measure("Primary index \"#{bucket_name}\" has been created") { cluster.query_indexes.create_primary_index(bucket_name, options) }
+
+display_indexes(cluster.query_indexes.get_all_indexes(bucket_name), bucket_name)
+
+measure("Build of the indexes for \"#{bucket_name}\" has been triggered") { cluster.query_indexes.build_deferred_indexes(bucket_name) }
+
+display_indexes(cluster.query_indexes.get_all_indexes(bucket_name), bucket_name)
+
+options = Management::QueryIndexManager::WatchIndexesOptions.new
+options.watch_primary = true
+measure("Watching for primary index build completion for \"#{bucket_name}\" has been finished") { cluster.query_indexes.watch_indexes(bucket_name, [], 10_000_000, options) }
+
+display_indexes(cluster.query_indexes.get_all_indexes(bucket_name), bucket_name)

data/examples/managing_search_indexes.rb

@@ -0,0 +1,62 @@
+require "couchbase"
+include Couchbase
+
+def measure(msg)
+  start = Time.now
+  yield
+  printf "%s in %.2f seconds\n", msg, Time.now - start
+end
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+search_indexes = cluster.search_indexes.get_all_indexes
+puts "There are #{search_indexes.size} search indexes on the cluster"
+search_indexes.each do |index|
+  num_docs = cluster.search_indexes.get_indexed_documents_count(index.name)
+  puts "* #{index.name.inspect} contains #{num_docs} documents"
+end
+
+search_index_name = "my_index"
+begin
+  index = cluster.search_indexes.get_index(search_index_name)
+  measure("index #{index.name.inspect} has been dropped") do
+    cluster.search_indexes.drop_index(index.name)
+  end
+rescue Error::IndexNotFound
+  # Ignored
+end
+
+index = Management::SearchIndex.new
+index.type = "fulltext-index"
+index.name = search_index_name
+index.source_type = "couchbase"
+index.source_name = "beer-sample"
+
+measure("index #{search_index_name.inspect} has been created") do
+  cluster.search_indexes.upsert_index(index)
+end
+num_indexed = 0
+loop do
+  sleep(1)
+  num = cluster.search_indexes.get_indexed_documents_count(search_index_name)
+  break if num_indexed == num
+  num_indexed = num
+  puts "#{index.name.inspect} indexed #{num_indexed}"
+end
+
+search_indexes = cluster.search_indexes.get_all_indexes
+puts "There are #{search_indexes.size} search indexes on the cluster"
+search_indexes.each do |index|
+  num_docs = cluster.search_indexes.get_indexed_documents_count(index.name)
+  puts "* #{index.name.inspect} contains #{num_docs} documents"
+end
+
+document = {
+    title: "Hello world",
+    content: "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
+}
+analysis = cluster.search_indexes.analyze_document(search_index_name, document)
+puts "Analysis of document using definition of the index #{search_index_name}:"
+pp analysis

data/examples/managing_view_indexes.rb

@@ -0,0 +1,54 @@
+require "couchbase"
+include Couchbase
+
+def measure(msg)
+  start = Time.now
+  yield
+  printf "%s in %.2f seconds\n", msg, Time.now - start
+end
+
+def display_indexes(manager, namespace)
+  indexes = manager.get_all_design_documents(namespace)
+  puts "\"#{namespace}\" namespace of the bucket \"#{manager.bucket_name}\" contains #{indexes.size} design documents:"
+  indexes.each do |index|
+    puts "  * #{index.name} (#{index.views.size} views)"
+    index.views.each do |name, view|
+      puts "    - #{name}"
+      puts "      map:\n#{view.map.strip.gsub(/^/, "      | ")}" if view.has_map?
+      puts "      reduce:\n#{view.reduce.strip.gsub(/^/, "      | ")}" if view.has_reduce?
+    end
+  end
+end
+
+bucket_name = "beer-sample"
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+bucket = cluster.bucket(bucket_name)
+manager = bucket.view_indexes
+
+display_indexes(manager, :production)
+
+design_document_name = "test"
+begin
+  manager.drop_design_document(design_document_name, :development)
+rescue Error::DesignDocumentNotFound
+  # ignore
+end
+
+view = Management::View.new
+view.map_function = "function (doc, meta) { emit(meta.id, null) }"
+
+design_document = Management::DesignDocument.new
+design_document.name = design_document_name
+design_document.views["get_all"] = view
+
+manager.upsert_design_document(design_document, :development)
+
+display_indexes(manager, :development)
+
+# copy design document from development namespace to production
+manager.publish_design_document(design_document_name)
+display_indexes(manager, :production)

data/examples/query.rb

@@ -1,5 +1,4 @@
 require 'couchbase'
-require 'byebug'
 
 include Couchbase
 
@@ -7,11 +6,13 @@ options = Cluster::ClusterOptions.new
 options.authenticate("Administrator", "password")
 cluster = Cluster.connect("couchbase://localhost", options)
 
+cluster.bucket("travel-sample") # this is necessary for 6.0.x
+
 options = Cluster::QueryOptions.new
 options.named_parameters({type: "hotel"})
 options.metrics = true
 res = cluster.query("SELECT * FROM `travel-sample` WHERE type = $type LIMIT 10", options)
 res.rows.each do |row|
-  puts "#{row['country']}. #{row['name']}"
+  puts "#{row["travel-sample"]["country"]}. #{row["travel-sample"]["name"]}"
 end
 puts "Status: #{res.meta_data.status}. Execution time: #{res.meta_data.metrics.execution_time}"

data/examples/query_with_consistency.rb

@@ -0,0 +1,76 @@
+require 'couchbase'
+
+include Couchbase
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+options = Management::QueryIndexManager::CreatePrimaryIndexOptions.new
+options.ignore_if_exists = true
+cluster.query_indexes.create_primary_index("default", options)
+
+collection = cluster.bucket("default").default_collection
+
+# METHOD 1
+#
+# The easiest way to enforce consistency is just set scan_consistency option to :request_plus
+# Note: it waits until all documents queued to be indexed when the request has been receive,
+# will be proceed and stored in the index. Often more granular approach is possible (skip to the next section)
+puts "METHOD 1: using :request_plus"
+
+random_number = rand(0..1_000_000_000)
+collection.upsert("user:#{random_number}", {
+    "name" => ["Brass", "Doorknob"],
+    "email" => "brass.doorknob@example.com",
+    "data" => random_number,
+})
+
+options = Cluster::QueryOptions.new
+options.timeout = 10_000
+options.positional_parameters(["Brass"])
+options.scan_consistency = :request_plus
+res = cluster.query("SELECT name, email, data, META(`default`).id FROM `default` WHERE $1 IN name", options)
+res.rows.each do |row|
+  puts "Name: #{row["name"].join(" ")}, e-mail: #{row["email"]}, data: #{row["data"]}"
+  if row["data"] == random_number
+    puts "--- Found our newly created document!"
+  end
+  if ENV['REMOVE_DOOR_KNOBS']
+    puts "Removing #{row["id"]} (requested via env)"
+    collection.remove(row["id"])
+  end
+end
+
+# METHOD 2
+#
+# More granular and light-weight approach is to use AT_PLUS consistency.
+# The application need to to know exactly which mutation affect the result,
+# and supply mutation tokens from those operations.
+puts "METHOD 2: using MutationState"
+
+random_number = rand(0..1_000_000_000)
+res = collection.upsert("user:#{random_number}", {
+    "name" => ["Brass", "Doorknob"],
+    "email" => "brass.doorknob@example.com",
+    "data" => random_number,
+})
+
+state = MutationState.new(res.mutation_token)
+# state.add(*tokens) could be used to add more tokens
+
+options = Cluster::QueryOptions.new
+options.timeout = 10_000
+options.positional_parameters(["Brass"])
+options.consistent_with(state)
+res = cluster.query("SELECT name, email, data, META(`default`).id FROM `default` WHERE $1 IN name", options)
+res.rows.each do |row|
+  puts "Name: #{row["name"].join(" ")}, e-mail: #{row["email"]}, data: #{row["data"]}"
+  if row["data"] == random_number
+    puts "--- Found our newly created document!"
+  end
+  if ENV['REMOVE_DOOR_KNOBS']
+    puts "Removing #{row["id"]} (requested via env)"
+    collection.remove(row["id"])
+  end
+end

data/examples/search.rb

@@ -0,0 +1,187 @@
+require 'couchbase'
+
+include Couchbase
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+# create index definition, if it does not exist already
+search_index_name = "beer_search"
+
+begin
+  cluster.search_indexes.get_index(search_index_name)
+rescue Error::IndexNotFound
+  index = Management::SearchIndex.new
+  index.type = "fulltext-index"
+  index.name = search_index_name
+  index.source_type = "couchbase"
+  index.source_name = "beer-sample"
+  index.params = {
+      mapping: {
+          default_datetime_parser: "dateTimeOptional",
+          types: {
+              "beer" => {
+                  properties: {
+                      "abv" => {
+                          fields: [
+                              {
+                                  name: "abv",
+                                  type: "number",
+                                  include_in_all: true,
+                                  index: true,
+                                  store: true,
+                                  docvalues: true,
+                              }
+                          ]
+                      },
+                      "category" => {
+                          fields: [
+                              {
+                                  name: "category",
+                                  type: "text",
+                                  include_in_all: true,
+                                  include_term_vectors: true,
+                                  index: true,
+                                  store: true,
+                                  docvalues: true,
+                              }
+                          ]
+                      },
+                      "description" => {
+                          fields: [
+                              {
+                                  name: "description",
+                                  type: "text",
+                                  include_in_all: true,
+                                  include_term_vectors: true,
+                                  index: true,
+                                  store: true,
+                                  docvalues: true,
+                              }
+                          ]
+                      },
+                      "name" => {
+                          fields: [
+                              {
+                                  name: "name",
+                                  type: "text",
+                                  include_in_all: true,
+                                  include_term_vectors: true,
+                                  index: true,
+                                  store: true,
+                                  docvalues: true,
+                              }
+                          ]
+                      },
+                      "style" => {
+                          fields: [
+                              {
+                                  name: "style",
+                                  type: "text",
+                                  include_in_all: true,
+                                  include_term_vectors: true,
+                                  index: true,
+                                  store: true,
+                                  docvalues: true,
+                              }
+                          ]
+                      },
+                      "updated" => {
+                          fields: [
+                              {
+                                  name: "updated",
+                                  type: "datetime",
+                                  include_in_all: true,
+                                  index: true,
+                                  store: true,
+                                  docvalues: true,
+                              }
+                          ]
+                      },
+                  }
+              }
+          }
+      }
+  }
+
+  cluster.search_indexes.upsert_index(index)
+
+  num_indexed = 0
+  loop do
+    sleep(1)
+    num = cluster.search_indexes.get_indexed_documents_count(search_index_name)
+    break if num_indexed == num
+    num_indexed = num
+    puts "indexing #{search_index_name.inspect}: #{num_indexed} documents"
+  end
+end
+
+# search with facets advanced sort
+query = Cluster::SearchQuery.match_phrase("hop beer")
+options = Cluster::SearchOptions.new
+options.limit = 10
+options.fields = %w[name]
+options.highlight_style = :html
+options.highlight_fields = %w[name description]
+options.sort = [
+    Cluster::SearchSort.field("abv") do |spec|
+      spec.type = :number
+    end,
+    Cluster::SearchSort.score do |spec|
+      spec.desc = true
+    end,
+    "category",
+    Cluster::SearchSort.id,
+]
+
+res = cluster.search_query(search_index_name, query, options)
+res.rows.each_with_index do |row, idx|
+  document = row.fields
+  puts "\n#{idx}. #{document["name"]} (id: #{row.id.inspect})"
+  row.fragments.each do |field, fragments|
+    puts "  * #{field}"
+    fragments.each do |fragment|
+      puts "      - #{fragment.gsub(/\n/, ' ')}"
+    end
+  end
+end
+
+# search with facets
+query = Cluster::SearchQuery.term("beer")
+query.field = "type"
+
+options = Cluster::SearchOptions.new
+options.facets = {}
+
+term_facet = Cluster::SearchFacet.term("name")
+term_facet.size = 3
+options.facets["by_name"] = term_facet
+
+date_facet = Cluster::SearchFacet.date_range("updated")
+date_facet.add("old", nil, Time.new(2013, 1, 1))
+date_facet.size = 3
+options.facets["by_time"] = date_facet
+
+numeric_facet = Cluster::SearchFacet.numeric_range("abv")
+numeric_facet.size = 3
+numeric_facet.add("strong", 4.9, nil)
+numeric_facet.add("light", nil, 4.89)
+options.facets["by_strength"] = numeric_facet
+
+res = cluster.search_query(search_index_name, query, options)
+
+puts "\n==== Top 3 beer names (out of #{res.facets["by_name"].total}):"
+res.facets["by_name"].terms.each_with_index do |term, idx|
+  puts "#{idx}. #{term.term} (#{term.count} records)"
+end
+
+puts "\n==== Beer by strength (out of #{res.facets["by_strength"].total}):"
+res.facets["by_strength"].numeric_ranges.each_with_index do |range, idx|
+  puts "#{idx}. #{range.name}, ABV: [#{range.min}..#{range.max}] (#{range.count} records)"
+end
+
+puts "\n==== The most recently updated (out of #{res.facets["by_time"].total}):"
+res.facets["by_time"].date_ranges.each_with_index do |range, idx|
+  puts "#{idx}. #{range.name} [#{range.start_time}..#{range.end_time}] (#{range.count} records)"
+end