couchbase 3.0.0.alpha.5 → 3.0.3

data/examples/managing_buckets.rb

@@ -1,47 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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,18 +0,0 @@
-require 'couchbase'
-
-include Couchbase
-
-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["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

@@ -1,76 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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