Fetching contributors…
Cannot retrieve contributors at this time
1093 lines (898 sloc) 45.1 KB
.. Link to other glossary terms when possible.
Reserve the "See" text at the end of the entry to link to topics in the manual.
.. default-domain:: mongodb
.. contents:: On this page
:backlinks: none
:depth: 1
:class: singlecol
.. glossary::
A special virtual :term:`collection` that exposes MongoDB's
:term:`database commands <database command>`.
To use database commands, see :ref:`issue-commands`.
A field required in every MongoDB :term:`document`. The
:ref:`_id <document-id-field>` field must have a unique value. You can
think of the ``_id`` field as the document's :term:`primary key`.
If you create a new document without an ``_id`` field, MongoDB
automatically creates the field and assigns a unique
BSON :term:`ObjectId`.
An :term:`expression` in the :term:`aggregation framework` that
maintains state between documents in the aggregation
:term:`pipeline`. For a list of accumulator operations, see
An operation the user can perform on a resource. Actions and
:term:`resources <resource>` combine to create :term:`privileges
<privilege>`. See :doc:`action </reference/privilege-actions>`.
admin database
A privileged database. Users
must have access to the ``admin`` database to run certain
administrative commands. For a list of administrative commands,
see :ref:`admin-commands`.
Any of a variety of operations that reduces and summarizes large
sets of data. MongoDB's :method:`~db.collection.aggregate()` and
:method:`~db.collection.mapReduce()` methods are two
examples of aggregation operations. For more information, see
aggregation framework
The set of MongoDB operators that let you calculate aggregate
values without having to use :term:`map-reduce`. For a list of
operators, see :doc:`/reference/aggregation`.
A member of a :term:`replica set` that exists solely to vote in
:term:`elections <election>`. Arbiters do not replicate data. See
Verification of the user identity. See
Provisioning of access to databases and operations. See
An internal MongoDB process that runs in the context of a
:term:`sharded cluster` and manages the migration of :term:`chunks
<chunk>`. Administrators must disable the balancer for all
maintenance operations on a sharded cluster. See
A serialization format used to store :term:`documents <document>` and make
remote procedure calls in MongoDB. "BSON" is a portmanteau of the words
"binary" and "JSON". Think of BSON as a binary representation
of JSON (JavaScript Object Notation) documents. See
:doc:`/reference/bson-types` and
BSON types
The set of types supported by the :term:`BSON` serialization
format. For a list of BSON types, see :doc:`/reference/bson-types`.
A data structure commonly used by database management systems to
store indexes. MongoDB uses B-trees for its indexes.
CAP Theorem
Given three properties of computing systems, consistency,
availability, and partition tolerance, a distributed computing
system can provide any two of these features, but never all
capped collection
A fixed-sized :term:`collection <collection>` that automatically
overwrites its oldest entries when it reaches its maximum size.
The MongoDB :term:`oplog` that is used in :term:`replication` is a
capped collection. See :doc:`/core/capped-collections`.
The measure of the number of elements within a set of values.
For example, the set ``A = { 2, 4, 6 }`` contains 3 elements,
and has a cardinality of 3. See :ref:`shard-key-cardinality`.
A calculated value used to ensure data integrity.
The :term:`md5` algorithm is sometimes used as a checksum.
A contiguous range of :term:`shard key` values within a particular
:term:`shard`. Chunk ranges are inclusive of the lower boundary
and exclusive of the upper boundary. MongoDB splits chunks when
they grow beyond the configured chunk size, which by default is
64 megabytes. MongoDB migrates chunks when a shard contains too
many chunks of a collection relative to other shards. See
:ref:`sharding-data-partitioning` and :ref:`sharding-balancing`.
The application layer that uses a database for data persistence
and storage. :term:`Drivers <driver>` provide the interface
level between the application layer and the database server.
Client can also refer to a single thread or process.
See :term:`sharded cluster`.
A grouping of MongoDB :term:`documents <document>`. A collection
is the equivalent of an :term:`RDBMS` table. A collection exists
within a single :term:`database`. Collections do not enforce a
schema. Documents within a collection can have different fields.
Typically, all documents in a collection have a similar or related
purpose. See :ref:`faq-dev-namespace`.
collection scan
Collection scans are a query execution strategy where MongoDB must
inspect every document in a collection to see if it matches the
query criteria. These queries are very inefficient and do not use
indexes. See :doc:`/core/query-optimization` for details about
query execution strategies.
compound index
An :term:`index` consisting of two or more keys. See
concurrency control
Concurrency control ensures that database operations can be
executed concurrently without compromising correctness.
Pessimistic concurrency control, such as used in systems
with :term:`locks <lock>`, will block any potentially
conflicting operations even if they may not turn out to
actually conflict. Optimistic concurrency control, the approach
used by :ref:`WiredTiger <storage-wiredtiger>`, will delay
checking until after a conflict may have occurred, aborting and
retrying one of the operations involved in any :term:`write
conflict` that arises.
config database
An internal database that holds the metadata associated with a
:term:`sharded cluster`. Applications and administrators should
not modify the ``config`` database in the course of normal
operation. See :doc:`/reference/config-database`.
config server
A :program:`mongod` instance that stores all the metadata
associated with a :term:`sharded cluster`.
See :ref:`sharding-config-server`.
init script
A simple shell script, typically located in the ``/etc/rc.d`` or
``/etc/init.d`` directory, and used by the system's initialization
process to start, restart or stop a :term:`daemon` process.
An acronym for the fundamental operations of a database: Create,
Read, Update, and Delete. See :doc:`/crud`.
A text-based data format consisting of comma-separated values.
This format is commonly used to exchange data between relational
databases since the format is well-suited to tabular data. You can
import CSV files using :program:`mongoimport`.
A pointer to the result set of a :term:`query`. Clients can
iterate through a cursor to retrieve results. By default, cursors
timeout after 10 minutes of inactivity. See
The conventional name for a background, non-interactive
data directory
The file-system location where the :program:`mongod` stores data
files. The :setting:`~storage.dbPath` option specifies the data directory.
data partition
A distributed system architecture that splits data into ranges.
:term:`Sharding` uses partitioning. See
data-center awareness
A property that allows clients to address members in a system
based on their locations. :term:`Replica sets <replica set>`
implement data-center awareness using :term:`tagging <tag>`. See
A physical container for :term:`collections <collection>`.
Each database gets its own set of files on the file
system. A single MongoDB server typically has multiple
database command
A MongoDB operation, other than an insert, update, remove, or
query. For a list of database commands, see
:doc:`/reference/command`. To use database commands, see
database profiler
A tool that, when enabled, keeps a record on all long-running
operations in a database's ``system.profile`` collection. The
profiler is most often used to diagnose slow queries. See
A set of values used to define measurements on the earth. MongoDB
uses the :term:`WGS84` datum in certain :term:`geospatial`
calculations. See :doc:`/applications/geospatial-indexes`.
The location of MongoDB's data file storage. See
delayed member
A :term:`replica set` member that cannot become primary and
applies operations at a specified delay. The delay is useful for
protecting data from human error (i.e. unintentionally deleted
databases) or updates that have unforeseen effects on the
production database. See :ref:`replica-set-delayed-members`.
diagnostic log
A verbose log of operations stored in the :term:`dbpath`.
See the :option:`--diaglog <mongod --diaglog>` option.
A record in a MongoDB :term:`collection` and the basic unit of
data in MongoDB. Documents are analogous to :term:`JSON` objects
but exist in the database in a more type-rich format known as
:term:`BSON`. See :doc:`/core/document`.
dot notation
MongoDB uses the dot notation to access the elements of an array
and to access the fields of an embedded document. See
The process of removing or "shedding" :term:`chunks <chunk>` from
one :term:`shard` to another. Administrators must drain shards
before removing them from the cluster. See
A client library for interacting with MongoDB in a particular
language. See :doc:`/applications/drivers`.
A write operation is durable when it will persist across a
shutdown (or crash) and restart of one or more server processes.
For a single :program:`mongod` server, a write operation is
considered durable when it has been written to the server's
:term:`journal` file. For a :doc:`replica set
</replication>`, a write operation is
considered durable once the write operation is durable on a
majority of voting nodes; i.e. written to a majority of voting
nodes' journals.
The process by which members of a :term:`replica set` select a
:term:`primary` on startup and in the event of a failure. See
unix epoch
January 1st, 1970 at 00:00:00 UTC. Commonly used in expressing time,
where the number of seconds or milliseconds since this point is counted.
eventual consistency
A property of a distributed system that allows changes to the
system to propagate gradually. In a database system, this means
that readable members are not required to reflect the latest
writes at all times.
.. include:: /includes/extracts/replica-read-consistency-single-primary.rst
In the context of :term:`aggregation framework`, expressions are
the stateless transformations that operate on the data that passes
through a :term:`pipeline`. See :doc:`/core/aggregation-pipeline`.
The process that allows a :term:`secondary` member of a
:term:`replica set` to become :term:`primary` in the event of a
failure. See :ref:`replica-set-failover`.
A name-value pair in a :term:`document <document>`. A document has
zero or more fields. Fields are analogous to columns in relational
databases. See :ref:`document-structure`.
field path
Path to a field in the document. To specify a field path, use a
string that prefixes the field name with a dollar sign (``$``).
A system level networking filter that restricts access based on,
among other things, IP address. Firewalls form a part of an
effective network security strategy. See
A system call that flushes all dirty, in-memory pages to
disk. MongoDB calls ``fsync()`` on its database files at least
every 60 seconds. See :dbcommand:`fsync`.
A geohash value is a binary representation of the location on a
coordinate grid. See :ref:`geospatial-indexes-geohash`.
A :term:`geospatial` data interchange format based on JavaScript
Object Notation (:term:`JSON`). GeoJSON is used in
:doc:`geospatial queries </applications/geospatial-indexes>`. For
supported GeoJSON objects, see :ref:`geo-overview-location-data`.
For the GeoJSON format specification, see
Data that relates to geographical location. In MongoDB, you may
store, index, and query data according to geographical parameters.
See :doc:`/applications/geospatial-indexes`.
A convention for storing large files in a MongoDB database. All of
the official MongoDB drivers support this convention, as does the
:program:`mongofiles` program. See :doc:`/core/gridfs`.
hashed shard key
A special type of :term:`shard key` that uses a hash of the value
in the shard key field to distribute documents among members of
the :term:`sharded cluster`. See :ref:`index-type-hashed`.
haystack index
A :term:`geospatial` index that enhances searches by creating
"buckets" of objects grouped by a second criterion. See
hidden member
A :term:`replica set` member that cannot become :term:`primary`
and are invisible to client applications. See
The quality of an operation to produce the same result given the
same input, whether run once or run multiple times.
A data structure that optimizes queries. See :doc:`/indexes`.
initial sync
The :term:`replica set` operation that replicates data from an
existing replica set member to a new or restored replica set
member. See :ref:`replica-set-initial-sync`.
intent lock
A :term:`lock` on a resource that indicates that the holder
of the lock will read (intent shared) or write (intent
exclusive) the resource using :term:`concurrency control` at
a finer granularity than that of the resource with the intent
lock. Intent locks allow concurrent readers and writers of a
resource. See :ref:`faq-concurrency-locking`.
A revision to the IP (Internet Protocol) standard that
provides a significantly larger address space to more effectively
support the number of hosts on the contemporary Internet.
The international date format used by :program:`mongo`
to display dates. The format is: ``YYYY-MM-DD HH:MM.SS.millis``.
interrupt point
A point in an operation's lifecycle when it can
safely abort. MongoDB only terminates an operation
at designated interrupt points. See
A popular scripting language originally designed for web
browsers. The MongoDB shell and certain server-side functions use
a JavaScript interpreter. See
:doc:`/core/server-side-javascript` for more information.
A sequential, binary transaction log used to bring the database
into a valid state in the event of a hard shutdown.
Journaling writes data first to the journal and then to the core
data files. MongoDB enables journaling by default for 64-bit
builds of MongoDB version 2.0 and newer. Journal files are
pre-allocated and exist as files in the :term:`data directory`.
See :doc:`/core/journaling/`.
JavaScript Object Notation. A human-readable, plain text format
for expressing structured data with support in many programming
languages. For more information, see `<>`_.
Certain MongoDB tools render an approximation of MongoDB
:term:`BSON` documents in JSON format. See
JSON document
A :term:`JSON` document is a collection of fields and values in a
structured format. For sample JSON documents, see
:term:`JSON` with Padding. Refers to a method of injecting JSON
into applications. **Presents potential security concerns**.
least privilege
An authorization policy that gives a user only the amount of access
that is essential to that user's work and no more.
legacy coordinate pairs
The format used for :term:`geospatial` data prior to MongoDB
version 2.4. This format stores geospatial data as points on a
planar coordinate system (e.g. ``[ x, y ]``). See
A LineString is defined by an array of two or more positions. A
closed LineString with four or more positions is called a
LinearRing, as described in the GeoJSON LineString specification:
`<>`_. To use a
LineString in MongoDB, see
MongoDB uses locks to ensure that :doc:`concurrency </faq/concurrency>`
does not affect correctness. MongoDB uses :term:`read locks
<read lock>`, :term:`write locks <write lock>` and
:term:`intent locks <intent lock>`. For more information, see
Logical volume manager. LVM is a program that abstracts disk
images from physical devices and provides a number of raw disk
manipulation and snapshot capabilities useful for system
management. For information on LVM and MongoDB, see
mapping type
A Structure in programming languages that associate keys with
values, where keys may nest other pairs of keys and values
(e.g. dictionaries, hashes, maps, and associative arrays).
The properties of these structures depend on the language
specification and implementation. Generally the order of keys in
mapping types is arbitrary and not guaranteed.
A data processing and aggregation paradigm consisting of a "map"
phase that selects data and a "reduce" phase that transforms the
data. In MongoDB, you can run arbitrary aggregations over data
using map-reduce. For map-reduce implementation, see
:doc:`/core/map-reduce`. For all approaches to aggregation,
see :doc:`/aggregation`.
The database that receives all writes in a conventional
master-:term:`slave` replication. In MongoDB, :term:`replica
sets <replica set>` replace master-slave replication for most use
cases. For more information on master-slave replication, see
A hashing algorithm used to efficiently provide
reproducible unique strings to identify and :term:`checksum`
data. MongoDB uses md5 to identify chunks of data for
:term:`GridFS`. See :doc:`/reference/command/filemd5`.
Management Information Base. MongoDB uses MIB files to define the type of
data tracked by SNMP in the MongoDB Enterprise edition.
Multipurpose Internet Mail Extensions. A standard set of type and
encoding definitions used to declare the encoding and type of data
in multiple data storage, transmission, and email contexts. The
:program:`mongofiles` tool provides an option to specify a MIME
type to describe a file inserted into :term:`GridFS` storage.
The MongoDB shell. The :program:`mongo` process starts the MongoDB
shell as a daemon connected to either a :program:`mongod` or
:program:`mongos` instance. The shell has a JavaScript interface.
See :doc:`/reference/program/mongo` and :doc:`/reference/method`.
The MongoDB database server. The :program:`mongod` process starts
the MongoDB server as a daemon. The MongoDB server manages data
requests and formats and manages background operations. See
An open-source document-based database system. "MongoDB" derives
from the word "humongous" because of the database's ability to
scale up with ease and hold very large amounts of data. MongoDB
stores :term:`documents <document>` in :term:`collections
<collection>` within databases.
MongoDB Enterprise
A commercial edition of MongoDB that includes additional features. For
more information, see `MongoDB Subscriptions
The routing and load balancing process that acts an interface
between an application and a MongoDB :term:`sharded cluster`. See
The canonical name for a collection or index in MongoDB.
The namespace is a combination of the database name and
the name of the collection or index, like so:
``[database-name].[collection-or-index-name]``. All documents
belong to a namespace. See :ref:`faq-dev-namespace`.
natural order
The order in which the database refers to documents on disk. This is the
default sort order. See :operator:`$natural` and
network partition
A network failure that separates a distributed system into
partitions such that nodes in one partition cannot communicate
with the nodes in the other partition.
Sometimes, partitions are partial or asymmetric. An example of a
partial partition would be a division of the nodes of a network
into three sets, where members of the first set cannot
communicate with members of the second set, and vice versa, but
all nodes can communicate with members of the third set. In an
asymmetric partition, communication may be possible only when it
originates with certain nodes. For example, nodes on one side of
the partition can communicate to the other side only if they
originate the communications channel.
storage order
See :term:`natural order`.
A special 12-byte :term:`BSON` type that guarantees uniqueness
within the :term:`collection`. The ObjectId is generated based on
timestamp, machine ID, process ID, and a process-local incremental
counter. MongoDB uses ObjectId values as the default values for
:term:`_id` fields.
A keyword beginning with a ``$`` used to express an update,
complex query, or data transformation. For example, ``$gt`` is the
query language's "greater than" operator. For available operators,
see :doc:`/reference/operator`.
A :term:`capped collection` that stores an ordered history of
logical writes to a MongoDB database. The oplog is the
basic mechanism enabling :term:`replication` in MongoDB.
See :doc:`/core/replica-set-oplog`.
ordered query plan
A query plan that returns results in the order consistent with the
:method:`~cursor.sort()` order. See
orphaned document
In a sharded cluster, orphaned documents are those documents on a
shard that also exist in chunks on other shards as a result of
failed migrations or incomplete migration cleanup due to abnormal
shutdown. Delete orphaned documents using
:dbcommand:`cleanupOrphaned` to reclaim disk space and reduce
The extra space allocated to document on the disk to prevent
moving a document when it grows as the result of
operations. See :ref:`record-allocation-strategies`.
padding factor
An automatically-calibrated constant used to determine how much
extra space MongoDB should allocate per document container on disk.
A padding factor of 1 means that MongoDB will allocate only the
amount of space needed for the document. A padding factor of 2
means that MongoDB will allocate twice the amount of space
required by the document. See
page fault
.. include:: /includes/fact-page-fault.rst
See :ref:`administration-monitoring-page-faults` and
passive member
A member of a :term:`replica set` that cannot become primary
because its :rsconf:`members[n].priority` is
``0``. See :doc:`/core/replica-set-priority-0-member`.
A packet-capture format that :program:`mongoreplay` can use to
produce a BSON-formatted playback file to play back to another
MongoDB instance. See: :toolcommand:`mongoreplay record <record>`
for more information.
A process identifier. UNIX-like systems assign a unique-integer
PID to each running process. You can use a PID to inspect a
running process and send signals to it. See
A communication channel in UNIX-like systems allowing independent
processes to send and receive data. In the UNIX shell, piped
operations allow users to direct the output of one command into
the input of another.
A series of operations in an :term:`aggregation` process.
See :doc:`/core/aggregation-pipeline`.
A single coordinate pair as described in the GeoJSON Point
specification: `<>`_. To
use a Point in MongoDB, see
An array of :term:`LinearRing <LineString>` coordinate arrays, as
described in the GeoJSON Polygon specification:
`<>`_. For Polygons
with multiple rings, the first must be the exterior ring and
any others must be interior rings or holes.
MongoDB does not permit the exterior ring to self-intersect.
Interior rings must be fully contained within the outer loop and
cannot intersect or overlap with each other. See
A per-collection setting that changes and normalizes the way
MongoDB allocates space for each :term:`document`, in an effort to
maximize storage reuse and to reduce fragmentation. This is the
default for :doc:`TTL Collections </tutorial/expire-data>`. See
:doc:`/reference/command/collMod` and
prefix compression
Reduces memory and disk consumption by storing any identical index
key prefixes only once, per page of memory. See:
:ref:`storage-wiredtiger-compression` for more about WiredTiger's
compression behavior.
An operation performed before inserting data that divides the
range of possible shard key values into chunks to facilitate easy
insertion and high write throughput. In some cases pre-splitting
expedites the initial distribution of documents in :term:`sharded
cluster` by manually dividing the collection rather than waiting
for the MongoDB :term:`balancer` to do so. See
In a :term:`replica set`, the primary member is the current
:term:`master` instance, which receives all write operations.
See :ref:`replica-set-primary-member`.
primary key
A record's unique immutable identifier. In an :term:`RDBMS`, the primary
key is typically an integer stored in each row's ``id`` field.
In MongoDB, the :term:`_id` field holds a document's primary
key which is usually a BSON :term:`ObjectId`.
primary shard
The :term:`shard` that holds all the un-sharded collections. See
A configurable value that helps determine which members in
a :term:`replica set` are most likely to become :term:`primary`.
See :rsconf:`members[n].priority`.
A combination of specified :term:`resource <resource>` and
:term:`actions <action>` permitted on the resource. See
:ref:`privilege <privileges>`.
A document given to a :term:`query` that specifies which fields
MongoDB returns in the result set. See :ref:`projection`. For a
list of projection operators, see
A read request. MongoDB uses a :term:`JSON`-like query language
that includes a variety of :term:`query operators <operator>` with
names that begin with a ``$`` character. In the :program:`mongo`
shell, you can issue queries using the
:method:`db.collection.find()` and
:method:`db.collection.findOne()` methods. See
query optimizer
A process that generates query plans. For each query, the
optimizer generates a plan that matches the query to the index
that will return results as efficiently as possible. The
optimizer reuses the query plan each time the query runs. If a
collection changes significantly, the optimizer creates a new
query plan. See :ref:`read-operations-query-optimization`.
query shape
A combination of query predicate, sort, and projection
For the query predicate, only the structure of the predicate,
including the field names, are significant; the values in the
query predicate are insignificant. As such, a query predicate ``{
type: 'food' }`` is equivalent to the query predicate ``{ type:
'utensil' }`` for a query shape.
read concern
Specifies a level of isolation for read operations. For example,
you can use read concern to only read data that has propagated to
a majority of nodes in a :term:`replica set`. See
read preference
A setting that determines how clients direct read operations.
Read preference affects all replica sets, including shard replica
sets. By default, MongoDB directs reads to :term:`primaries
<primary>`. However, you may also direct reads to secondaries for
:term:`eventually consistent <eventual consistency>` reads. See
:doc:`Read Preference </core/read-preference>`.
read lock
A shared :term:`lock` on a resource such as a collection or
database that, while held, allows concurrent readers but no
writers. See :ref:`faq-concurrency-locking`.
Relational Database Management System. A database management
system based on the relational model, typically using
:term:`SQL` as the query language.
record size
The space allocated for a document including the padding. For more
information on padding, see :ref:`record-allocation-strategies`
and :doc:`/reference/command/compact`.
A :term:`replica set` member status indicating that a member
is not ready to begin normal activities of a secondary or primary.
Recovering members are unavailable for reads.
replica pairs
The precursor to the MongoDB :term:`replica sets <replica set>`.
.. deprecated:: 1.6
replica set
A cluster of MongoDB servers that implements master-slave
replication and automated failover. MongoDB's recommended
replication strategy. See :doc:`/replication`.
A feature allowing multiple database servers to share the same
data, thereby ensuring redundancy and facilitating load balancing.
See :doc:`/replication`.
replication lag
The length of time between the last operation in the
:term:`primary's <primary>` :term:`oplog` and the last operation
applied to a particular :term:`secondary`. In general, you want to
keep replication lag as small as possible. See :ref:`Replication
Lag <replica-set-replication-lag>`.
resident memory
The subset of an application's memory currently stored in
physical RAM. Resident memory is a subset of :term:`virtual memory`,
which includes memory mapped to physical RAM and to disk.
A database, collection, set of collections, or cluster. A
:term:`privilege` permits :term:`actions <action>` on a specified
resource. See :ref:`resource <resource-document>`.
An API design pattern centered around the idea of resources and the
:term:`CRUD` operations that apply to them. Typically REST is
implemented over HTTP. MongoDB provides a simple HTTP REST
interface that allows HTTP clients to run commands against the
server. See :ref:`rest-api`.
.. include:: /includes/fact-deprecated-http-interface.rst
A set of privileges that permit :term:`actions <action>` on
specified :term:`resources <resource>`. Roles assigned to a user
determine the user's access to resources and operations. See
A process that reverts writes operations to ensure the consistency
of all replica set members. See :ref:`replica-set-rollback`.
A :term:`replica set` member that replicates the contents of the
master database. Secondary members may handle read requests, but
only the :term:`primary` members can handle write operations. See
secondary index
A database :term:`index` that improves query performance by
minimizing the amount of work that the query engine must perform
to fulfill a query. See :doc:`/indexes`.
set name
The arbitrary name given to a replica set. All members of a
replica set must have the same name specified with the
:setting:`~replication.replSetName` setting or the :option:`--replSet <mongod --replSet>` option.
A single :program:`mongod` instance or :term:`replica set` that
stores some portion of a :term:`sharded cluster's <sharded
cluster>` total data set. In production, all shards should be
replica sets. See :doc:`/core/sharded-cluster-shards`.
shard key
The field MongoDB uses to distribute documents among members of a
:term:`sharded cluster`. See :ref:`shard-key`.
sharded cluster
The set of nodes comprising a :term:`sharded <sharding>` MongoDB
deployment. A sharded cluster consists of config servers,
shards, and one or more :program:`mongos`
routing processes. See :doc:`/core/sharded-cluster-components`.
A database architecture that partitions data by key ranges and
distributes the data among two or more database instances.
Sharding enables horizontal scaling. See :doc:`/sharding`.
shell helper
A method in the ``mongo`` shell that provides a more concise
syntax for a :doc:`database command <command>`. Shell helpers
improve the general interactive experience. See
single-master replication
A :term:`replication` topology where only a single database
instance accepts writes. Single-master replication ensures
consistency and is the replication topology employed by MongoDB.
See :doc:`/core/replica-set-primary`.
A read-only database that replicates operations from a
:term:`master` database in conventional master/slave replication.
In MongoDB, :term:`replica sets <replica set>` replace
master/slave replication for most use cases. However, for
information on master/slave replication, see
A compression/decompression library designed to balance
efficient computation requirements with reasonable compression rates.
Snappy is the default compression
library for MongoDB's use of :ref:`WiredTiger
<storage-wiredtiger>`. See `Snappy
<>`_ and the :wtdocs:`WiredTiger compression
documentation </compression.html>`
for more information.
The division between :term:`chunks <chunk>` in a :term:`sharded
cluster`. See :doc:`/core/sharding-data-partitioning`.
Structured Query Language (SQL) is a common special-purpose
programming language used for interaction with a relational
database, including access control, insertions,
updates, queries, and deletions. There are some similar
elements in the basic SQL syntax supported by different database
vendors, but most implementations have their own dialects, data
types, and interpretations of proposed SQL standards. Complex
SQL is generally not directly portable between major
:term:`RDBMS` products. ``SQL`` is often used as
metonym for relational databases.
Solid State Disk. A high-performance disk drive that uses solid
state electronics for persistence, as opposed to the rotating platters
and movable read/write heads used by traditional mechanical hard drives.
An instance of :program:`mongod` that is running as a single
server and not as part of a :term:`replica set`. To convert a
standalone into a replica set, see
storage engine
The part of a database that is responsible for managing how data
is stored and accessed, both in memory and on disk. Different
storage engines perform better for specific workloads. See
:doc:`/core/storage-engines` for specific details on the built-in
storage engines in MongoDB.
strict consistency
A property of a distributed system requiring that all members
always reflect the latest changes to the system. In a database
system, this means that any system that can provide data must
reflect the latest writes at all times.
.. include:: /includes/extracts/replica-read-consistency-single-primary.rst
Refers to the amount of time a :term:`secondary` member of a
:term:`replica set` trails behind the current state of the
:term:`primary's <primary>`\ :term:`oplog`. If a secondary
becomes too stale, it can no longer use replication to catch up
to the current state of the primary. See
:doc:`/core/replica-set-oplog` and :doc:`/core/replica-set-sync`
for more information.
The :term:`replica set` operation where members replicate data
from the :term:`primary`. Sync first occurs when MongoDB creates
or restores a member, which is called :term:`initial sync`. Sync
then occurs continually to keep the member updated with changes to
the replica set's data. See :doc:`/core/replica-set-sync`.
On UNIX-like systems, a logging process that provides a uniform
standard for servers and processes to submit logging information.
MongoDB provides an option to send output to the host’s syslog
system. See :setting:`~systemLog.syslogFacility`.
A label applied to a replica set member and used by
clients to issue data-center-aware operations. For more information
on using tags with replica sets, see the following
sections of this manual: :ref:`replica-set-read-preference-tag-sets`.
.. versionchanged:: 3.4
In MongoDB 3.4, sharded cluster :term:`zones <zone>` replace
:term:`tags <tag>`.
tag set
A document containing zero or more :term:`tags <tag>`.
tailable cursor
For a :term:`capped collection`, a tailable cursor is a cursor that
remains open after the client exhausts the results in the initial
cursor. As clients insert new documents into the capped collection,
the tailable cursor continues to retrieve documents.
The state of a deployment of MongoDB instances, including
the type of deployment (i.e. standalone, replica set, or sharded
cluster) as well as the availability of servers, and the role of
each server (i.e. :term:`primary`, :term:`secondary`,
:term:`config server`, or :program:`mongos`.)
A text-based data format consisting of tab-separated values.
This format is commonly used to exchange data between relational
databases, since the format is well-suited to tabular data. You can
import TSV files using :program:`mongoimport`.
Stands for "time to live" and represents an expiration time or
period for a given piece of information to remain in a cache or
other temporary storage before the system deletes it or ages it
out. MongoDB has a TTL collection feature. See
unique index
An index that enforces uniqueness for a particular field across
a single collection. See :ref:`index-type-unique`.
unordered query plan
A query plan that returns results in an order inconsistent with the
:method:`~cursor.sort()` order.
See :ref:`read-operations-query-optimization`.
An option for update operations; e.g.
:method:`~db.collection.findAndModify()`. If set to true, the
update operation will either update the document(s) matched by
the specified query or if no documents match, insert a new
document. The new document will have the fields indicated in the
operation. See :ref:`upsert-parameter`.
virtual memory
An application's working memory, typically residing on both
disk an in physical RAM.
The default :term:`datum` MongoDB uses to calculate geometry over
an Earth-like sphere. MongoDB uses the WGS84 datum for
:term:`geospatial` queries on :term:`GeoJSON` objects. See
the "EPSG:4326: WGS 84" specification:
working set
The data that MongoDB uses most often. This data is preferably
held in RAM, solid-state drive (SSD), or other fast media. See
write concern
Specifies whether a write operation has succeeded. Write concern
allows your application to detect insertion errors or unavailable
:program:`mongod` instances. For :term:`replica sets <replica
set>`, you can configure write concern to confirm replication to a
specified number of members. See :doc:`/reference/write-concern`.
write conflict
A situation in which two concurrent operations, at least
one of which is a write, attempt to use a resource in a way
that would violate constraints imposed by a storage engine
using optimistic :term:`concurrency control`. MongoDB will
transparently abort and retry one of the conflicting operations.
write lock
An exclusive :term:`lock` on a resource such as a collection
or database. When a process writes to a resource, it takes
an exclusive write lock to prevent other processes from writing
to or reading from that resource. For more information on
locks, see :doc:`/faq/concurrency`.
The process within the sharding system that ensures that writes
issued to a :term:`shard` that *is not* responsible for the
relevant chunk get applied to the proper shard. For related
information, see :ref:`faq-writebacklisten` and
A data compression library that provides higher compression rates
at the cost of more CPU, compared to MongoDB's use of
:term:`snappy`. You can configure :ref:`WiredTiger
<storage-wiredtiger>` to use zlib as its compression library. See and the :wtdocs:`WiredTiger compression documentation
</compression.html>` for more
.. versionadded:: 3.4
A grouping of documents based on ranges of :term:`shard key` values
for a given sharded collection. Each shard in the sharded cluster can
associate with one or more zones. In a balanced cluster, MongoDB
directs reads and writes covered by a zone only to those shards
inside the zone. See the :ref:`zone-sharding` manual page for more
Zones supersede functionality described by :term:`tags <tag>` in
MongoDB 3.2.
.. [#edge-cases-2-primaries]
.. include:: /includes/footnote-two-primaries-edge-cases.rst