diff --git a/source/includes/indexes/compound.rb b/source/includes/indexes/compound.rb new file mode 100644 index 00000000..4c0f9a26 --- /dev/null +++ b/source/includes/indexes/compound.rb @@ -0,0 +1,40 @@ +require 'mongo' + +# Replace the placeholders with your credentials +uri = "" + +# 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 diff --git a/source/indexes.txt b/source/indexes.txt index 454bb8fd..a6f0ef95 100644 --- a/source/indexes.txt +++ b/source/indexes.txt @@ -23,7 +23,7 @@ Optimize Queries by Using Indexes :maxdepth: 1 Single Field -.. Compound + Compound .. Multikey .. Atlas Search diff --git a/source/indexes/compound-index.txt b/source/indexes/compound-index.txt new file mode 100644 index 00000000..426fea72 --- /dev/null +++ b/source/indexes/compound-index.txt @@ -0,0 +1,123 @@ +.. _ruby-compound-index: + +================ +Compound Indexes +================ + +.. contents:: On this page + :local: + :backlinks: none + :depth: 2 + :class: singlecol + +.. facet:: + :name: genre + :values: reference + +.. meta:: + :keywords: index, query, optimization, efficiency + +Overview +-------- + +**Compound indexes** hold references to multiple +fields within a collection's documents, improving query and sort +performance. + +When creating a compound index, you must specify the following details: + +- The fields on which to create the index + +- The sort order for each field (ascending or descending) + +Sample Data +~~~~~~~~~~~ + +The examples in this guide use the ``movies`` collection in the +``sample_mflix`` database from the :atlas:`Atlas sample datasets +`. To access this collection from your {+language+} +application, create a ``Mongo::Client`` object that connects to +an Atlas cluster and assign the following values to your ``database`` +and ``collection`` +variables: + +.. literalinclude:: /includes/indexes/single-field.rb + :start-after: start-sample-data + :end-before: end-sample-data + :language: ruby + :copyable: + +To learn how to create a free MongoDB Atlas cluster and +load the sample datasets, see the :atlas:`Get Started with Atlas +` guide. + +Create a Compound Index +----------------------- + +Use the ``create_one`` method to create a compound index. The following +example creates an index in descending order on the ``runtime`` field and +in ascending order on the ``year`` field: + +.. literalinclude:: /includes/indexes/compound.rb + :start-after: start-index-compound + :end-before: end-index-compound + :language: ruby + :copyable: + +Verify Index Creation +--------------------- + +You can verify that the index was created by listing the indexes in the +collection. You should see an index for ``runtime`` and ``year`` in the list, +as shown in the following output: + +.. io-code-block:: + :copyable: true + + .. input:: /includes/indexes/compound.rb + :start-after: start-check-compound-index + :end-before: end-check-compound-index + :language: ruby + + .. output:: + :visible: true + + {"v": 2, "key": {"runtime": -1, "year": 1}, "name": "runtime_-1_year_1"} + +Example Query +------------- + +The following is an example of a query that is covered by the index +created on the ``runtime`` and ``year`` fields: + +.. io-code-block:: + :copyable: true + + .. input:: /includes/indexes/compound.rb + :start-after: start-index-compound-query + :end-before: end-index-compound-query + :language: ruby + + .. output:: + :visible: false + + {"_id":...,"runtime": 91,...,"title": "Monster House",...,"year": 2006,...} + +Additional Information +---------------------- + +To view runnable examples that demonstrate how to manage indexes, see +:ref:`ruby-indexes`. + +To learn more about compound indexes, see :manual:`Compound +Indexes ` in the {+mdb-server+} manual. + +API Documentation +~~~~~~~~~~~~~~~~~ + +To learn more about any of the methods discussed in this guide, see the +following API documentation: + +- `indexes <{+api-root+}/Mongo/Collection.html#indexes-instance_method>`__ +- `create_one <{+api-root+}/Mongo/Index/View.html#create_one-instance_method>`__ +- `find <{+api-root+}/Mongo/Collection.html#find-instance_method>`__ diff --git a/source/indexes/single-field-index.txt b/source/indexes/single-field-index.txt index 61cf10d5..57bfc66e 100644 --- a/source/indexes/single-field-index.txt +++ b/source/indexes/single-field-index.txt @@ -20,7 +20,7 @@ Single Field Indexes Overview -------- -Single field indexes are indexes with a reference to a single field of a +**Single field indexes** are indexes with a reference to a single field of a document in a collection. These indexes improve single field query and sort performance. They also support :manual:`TTL Indexes ` that automatically remove documents from a collection after a certain