Merge branch 'standardization' into DOCSP-45205

Author: lindseymoore

source/includes/indexes/compound.rb

@@ -0,0 +1,40 @@
+require 'mongo'
+
+# Replace the placeholders with your credentials
+uri = "<connection string>"
+
+# Sets the server_api field of the options object to Stable API version 1
+options = { server_api: { version: "1" }}
+
+# Creates a new client and connect to the server
+client = Mongo::Client.new(uri, options)
+
+# start-sample-data
+database = client.use('sample_mflix')
+collection = database[:movies]
+# end-sample-data
+
+# Creates an index on the "runtime" and "year" field
+# start-index-compound
+collection.indexes.create_one({ runtime: -1, year: 1 })
+# end-index-compound
+
+# Finds a document with the specified runtime and release year by using the newly created index
+# start-index-compound-query
+filter = { '$and' => [
+    { runtime: { '$gt' => 90 } },
+    { year: { '$gt' => 2005 } }
+  ] }
+doc = collection.find(filter).first
+
+if doc
+  puts doc.to_json
+else
+  puts "No document found"
+end
+# end-index-compound-query
+
+# Lists all indexes on the collection
+# start-check-compound-index
+puts collection.indexes.collect(&:to_json)
+# end-check-compound-index

source/includes/read/count.rb

@@ -0,0 +1,45 @@
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'mongo'
+end
+
+uri = '<connection string>'
+
+Mongo::Client.new(uri) do |client|
+  # start-db-coll
+  database = client.use('sample_training')
+  collection = database['companies']
+  # end-db-coll
+
+  # Counts all documents in the collection
+  # start-count-all
+  result = collection.count_documents
+  puts "Number of documents: #{result}"
+  # end-count-all
+
+  # Counts documents that have a "founded_year" value of 2010
+  # start-count-accurate
+  result = collection.count_documents(founded_year: 2010)
+  puts "Number of companies founded in 2010: #{result}"
+  # end-count-accurate
+
+  # Counts a maximum of 100 documents that have a "number_of_employees" value of 50
+  # start-modify-accurate
+  result = collection.count_documents({ number_of_employees: 50 }, limit: 100)
+  puts "Number of companies with 50 employees: #{result}"
+  # end-modify-accurate
+
+  # Estimates the number of documents in the collection
+  # start-count-estimate
+  result = collection.estimated_document_count
+  puts "Estimated number of documents: #{result}"
+  # end-count-estimate
+
+  # Estimates the number of documents in the collection and sets a time limit on the operation
+  # start-modify-estimate
+  result = collection.estimated_document_count(max_time_ms: 1000)
+  puts "Estimated number of documents: #{result}"
+  # end-modify-estimate
+end

source/includes/read/distinct.rb

@@ -0,0 +1,44 @@
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'mongo'
+end
+
+uri = '<connection string>'
+
+Mongo::Client.new(uri) do |client|
+  # Access the database and collection
+  # start-db-coll
+  database = client.use('sample_restaurants')
+  collection = database[:restaurants]
+  # end-db-coll
+
+  # Retrieves distinct values of the "borough" field
+  # start-distinct
+  results = collection.distinct('borough')
+  results.each do |value|
+    puts value
+  end
+  # end-distinct
+
+  # Retrieves distinct "borough" field values for documents with a "cuisine" value of "Italian"
+  # start-distinct-with-query
+  results = collection.distinct('borough', { cuisine: 'Italian' })
+  results.each do |value|
+    puts value
+  end
+  # end-distinct-with-query
+
+  # Retrieves distinct "name" field values for documents matching the "borough" and "cuisine" fields query
+  # and uses primary preferred read preference
+  # start-distinct-with-opts
+  filter = { borough: 'Bronx', cuisine: 'Pizza' }
+  options = { read: { mode: :primary_preferred } }
+  results = collection.distinct('name', filter, options)
+  
+  results.each do |value|
+    puts value
+  end
+  # end-distinct-with-opts
+end

source/includes/read/limit-skip-sort.rb

@@ -0,0 +1,51 @@
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'mongo'
+end
+
+uri = '<connection string>'
+
+Mongo::Client.new(uri) do |client|
+  # Access the database and collection
+  # start-db-coll
+  database = client.use('sample_restaurants')
+  collection = database[:restaurants]
+  # end-db-coll
+
+  # Retrieves 5 documents that have a "cuisine" value of "Italian"
+  # start-limit
+  filter = { cuisine: 'Italian' }
+  collection.find(filter)
+            .limit(5)
+            .each { |doc| puts doc }
+  # end-limit
+
+  # Retrieves documents with a "cuisine" value of "Italian" and sorts in ascending "name" order
+  # start-sort
+  filter = { cuisine: 'Italian' }
+  collection.find(filter)
+            .sort(name: 1)
+            .each { |doc| puts doc }
+  # end-sort
+
+  # Retrieves documents with a "borough" value of "Manhattan" but skips the first 10 results
+  # start-skip
+  filter = { borough: 'Manhattan' }
+  collection.find(filter)
+            .skip(10)
+            .each { |doc| puts doc }
+  # end-skip
+
+  # Retrieves 5 documents with a "cuisine" value of "Italian", skips the first 10 results,
+  # and sorts by ascending "name" order
+  # start-limit-sort-skip
+  filter = { cuisine: 'Italian' }
+  collection.find(filter)
+            .limit(5)
+            .skip(10)
+            .sort(name: 1)
+            .each { |doc| puts doc }
+  # end-limit-sort-skip
+end

source/includes/read/project.rb

@@ -0,0 +1,43 @@
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'mongo'
+end
+
+uri = '<connection string>'
+
+Mongo::Client.new(uri) do |client|
+    # Access database and collection
+    # start-db-coll
+    database = client.use('sample_restaurants')
+    collection = database[:restaurants]
+    # end-db-coll
+  
+    # Retrieves documents matching the "name" field query
+    # and projects their "name", "cuisine", and "borough" values
+    # start-project-include
+    opts = { projection: { name: 1, cuisine: 1, borough: 1 } }
+    collection.find({ name: 'Emerald Pub' }, opts).each do |doc|
+      puts doc
+    end
+    # end-project-include
+  
+    # Retrieves documents matching the "name" field query
+    # and projects their "name", "cuisine", and "borough" values while excluding the "_id" values
+    # start-project-include-without-id
+    opts = { projection: { name: 1, cuisine: 1, borough: 1, _id: 0 } }
+    collection.find({ name: 'Emerald Pub' }, opts).each do |doc|
+      puts doc
+    end
+    # end-project-include-without-id
+  
+    # Retrieves documents matching the "name" field query
+    # and excludes their "grades" and "address" values when printing
+    # start-project-exclude
+    opts = { projection: { grades: 0, address: 0 } }
+    collection.find({ name: 'Emerald Pub' }, opts).each do |doc|
+      puts doc
+    end
+    # end-project-exclude
+  end

source/includes/read/specify-queries.rb

@@ -0,0 +1,79 @@
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'mongo'
+end
+
+uri = '<connection string>'
+
+Mongo::Client.new(uri) do |client|
+  # start-setup
+  database = client.use('db')
+  collection = database[:fruits]
+
+  # Inserts documents representing fruits
+  fruits = [
+  { _id: 1, name: 'apples', qty: 5, rating: 3, color: 'red', type: ['fuji', 'honeycrisp'] },
+  { _id: 2, name: 'bananas', qty: 7, rating: 4, color: 'yellow', type: ['cavendish'] },
+  { _id: 3, name: 'oranges', qty: 6, rating: 2, type: ['naval', 'mandarin'] },
+  { _id: 4, name: 'pineapples', qty: 3, rating: 5, color: 'yellow' }
+  ]
+
+  collection.insert_many(fruits)
+  # end-setup
+
+  # Retrieves documents in which the "color" value is "yellow"
+  # start-find-exact
+  filter = { color: 'yellow' }
+  results = collection.find(filter)
+  results.each do |doc|
+    puts doc
+  end
+  # end-find-exact
+
+  # Retrieves and prints documents in which the "rating" value is greater than 2
+  # start-find-comparison
+  filter = { rating: { '$gt' => 2 } }
+  results = collection.find(filter)
+  results.each do |doc|
+    puts doc
+  end
+  # end-find-comparison
+
+  # Retrieves and prints documents that match one or both query filters
+  # start-find-logical
+  filter = { '$or' => [{ qty: { '$gt' => 5 } }, { color: 'yellow' }] }
+  results = collection.find(filter)
+  results.each do |doc|
+    puts doc
+  end
+  # end-find-logical
+
+  # Retrieves and prints documents in which the "type" array has 2 elements
+  # start-find-array
+  filter = { type: { '$size' => 2 } }
+  results = collection.find(filter)
+  results.each do |doc|
+    puts doc
+  end
+  # end-find-array
+
+  # Retrieves and prints documents that have a "color" field
+  # start-find-element
+  filter = { color: { '$exists' => true } }
+  results = collection.find(filter)
+  results.each do |doc|
+    puts doc
+  end
+  # end-find-element
+
+  # Retrieves and prints documents in which the "name" value has at least two consecutive "p" characters
+  # start-find-evaluation
+  filter = { name: /p{2,}/ }
+  results = collection.find(filter)
+  results.each do |doc|
+    puts doc
+  end
+  # end-find-evaluation
+end

source/includes/write/delete.rb

@@ -0,0 +1,33 @@
+require 'bundler/inline'
+gemfile do
+  source 'https://rubygems.org'
+  gem 'mongo'
+end
+
+uri = "<connection string URI>"
+
+Mongo::Client.new(uri) do |client|
+  # start-db-coll
+  database = client.use('sample_restaurants')
+  collection = database[:restaurants]
+  # end-db-coll
+
+  # start-delete-one
+  filter = { name: 'Happy Garden' }
+  result = collection.delete_one(filter)
+  puts "Deleted #{result.deleted_count} document(s)"
+  # end-delete-one
+
+  # start-delete-many
+  filter = { name: 'Starbucks', borough: 'Brooklyn' }
+  result = collection.delete_many(filter)
+  puts "Deleted #{result.deleted_count} document(s)"
+  # end-delete-many
+
+  # start-delete-options
+  filter = { name: /Red/ }
+  options = { hint: 'name_index' }
+  result = collection.delete_many(filter, options)
+  puts "Deleted #{result.deleted_count} document(s)"
+  # end-delete-options
+end

source/includes/write/replace.rb

@@ -0,0 +1,29 @@
+require 'bundler/inline'
+gemfile do
+  source 'https://rubygems.org'
+  gem 'mongo'
+end
+
+uri = "<connection string URI>"
+
+Mongo::Client.new(uri) do |client|
+  # start-db-coll
+  database = client.use('sample_restaurants')
+  collection = database[:restaurants]
+  # end-db-coll
+
+  # Replaces a single document in the collection
+  # start-replace-one
+  filter = { name: 'Primola Restaurant' }
+  new_document = { name: 'Frutti Di Mare', cuisine: 'Seafood', borough: 'Queens' }
+  result = collection.replace_one(filter, new_document)
+  puts "Replaced #{result.modified_count} document(s)"
+  # end-replace-one
+
+  # Uses the upsert option to replace a single document in the collection
+  # start-replace-options
+  options = { upsert: true }
+  result = collection.replace_one(filter, new_document, options)
+  puts "Replaced #{result.upserted_count} document(s)"
+  # end-replace-options
+end