### Navigation

- index
- next |
- previous |
- MongoEngine 0.6.13 documentation »

# API Reference

## Connecting

`mongoengine.``connect`(db, alias='default', **kwargs)

  Connect to the database specified by the ‘db’ argument.

  Connection settings may be provided here as well if the database is not running on the default port on localhost. If authentication is needed, provide username and password arguments as well.

  Multiple databases are supported by using aliases. Provide a separate alias to connect to a different instance of mongod.

  Changed in version 0.6: - added multiple database support.

`mongoengine.``register_connection`(alias, name, host='localhost', port=27017, is_slave=False, read_preference=False, slaves=None, username=None, password=None, **kwargs)

  Add a connection.

  Parameters:

  - alias – the name that will be used to refer to this connection throughout MongoEngine
  - name – the name of the specific database to use
  - host – the host name of the mongod instance to connect to
  - port – the port that the mongod instance is running on
  - is_slave – whether the connection can act as a slave ** Depreciated pymongo 2.0.1+
  - read_preference – The read preference for the collection ** Added pymongo 2.1
  - slaves – a list of aliases of slave connections; each of these must be a registered connection that has `is_slave` set to `True`
  - username – username to authenticate with
  - password – password to authenticate with
  - kwargs – allow ad-hoc parameters to be passed into the pymongo driver

## Documents

class `mongoengine.``Document`(**values)

  The base class used for defining the structure and properties of collections of documents stored in MongoDB. Inherit from this class, and add fields as class attributes to define a document’s structure. Individual documents may then be created by making instances of the `Document` subclass.

  By default, the MongoDB collection used to store documents created using a `Document` subclass will be the name of the subclass converted to lowercase. A different collection may be specified by providing `collection` to the `meta` dictionary in the class definition.

  A `Document` subclass may be itself subclassed, to create a specialised version of the document that will be stored in the same collection. To facilitate this behaviour, _cls and _types fields are added to documents (hidden though the MongoEngine interface though). To disable this behaviour and remove the dependence on the presence of _cls and _types, set `allow_inheritance` to `False` in the `meta` dictionary.

  A `Document` may use a Capped Collection by specifying `max_documents` and `max_size` in the `meta` dictionary. `max_documents` is the maximum number of documents that is allowed to be stored in the collection, and `max_size` is the maximum size of the collection in bytes. If `max_size` is not specified and `max_documents` is, `max_size` defaults to 10000000 bytes (10MB).

  Indexes may be created by specifying `indexes` in the `meta` dictionary. The value should be a list of field names or tuples of field names. Index direction may be specified by prefixing the field names with a + or - sign.

  Automatic index creation can be disabled by specifying attr:auto_create_index in the `meta` dictionary. If this is set to False then indexes will not be created by MongoEngine. This is useful in production systems where index creation is performed as part of a deployment system.

  By default, _types will be added to the start of every index (that doesn’t contain a list) if allow_inheritance is True. This can be disabled by either setting types to False on the specific index or by setting index_types to False on the meta dictionary for the document.

  `objects`

    A `QuerySet` object that is created lazily on access.

  `cascade_save`(*args, **kwargs)

    Recursively saves any references / generic references on an object

  `delete`(safe=False)

    Delete the `Document` from the database. This will only take effect if the document has been previously saved.

    Parameters: | safe – check if the operation succeeded before returning

  classmethod `drop_collection`()

    Drops the entire collection associated with this `Document` type from the database.

  classmethod `register_delete_rule`(document_cls, field_name, rule)

    This method registers the delete rules to apply when removing this object.

  `reload`(max_depth=1)

    Reloads all attributes from the database.

    New in version 0.1.2.

    Changed in version 0.6: Now chainable

  `save`(safe=True, force_insert=False, validate=True, write_options=None, cascade=None, cascade_kwargs=None, _refs=None)

    Save the `Document` to the database. If the document already exists, it will be updated, otherwise it will be created.

    If `safe=True` and the operation is unsuccessful, an `OperationError` will be raised.

    Parameters:

    - safe – check if the operation succeeded before returning
    - force_insert – only try to create a new document, don’t allow updates of existing documents
    - validate – validates the document; set to `False` to skip.
    - write_options – Extra keyword arguments are passed down to `save()` OR `insert()` which will be used as options for the resultant `getLastError` command. For example, `save(..., write_options={w: 2, fsync: True}, ...)` will wait until at least two servers have recorded the write and will force an fsync on each server being written to.
    - cascade – Sets the flag for cascading saves. You can set a default by setting “cascade” in the document __meta__
    - cascade_kwargs – optional kwargs dictionary to be passed throw to cascading saves
    - _refs – A list of processed references used in cascading saves

    Changed in version 0.5: In existing documents it only saves changed fields using set / unset Saves are cascaded and any `DBRef` objects that have changes are saved as well.

    Changed in version 0.6: Cascade saves are optional = defaults to True, if you want fine grain control then you can turn off using document meta[‘cascade’] = False Also you can pass different kwargs to the cascade save using cascade_kwargs which overwrites the existing kwargs with custom values

  `select_related`(max_depth=1)

    Handles dereferencing of `DBRef` objects to a maximum depth in order to cut down the number queries to mongodb.

    New in version 0.5.

  `to_dbref`()

    Returns an instance of `DBRef` useful in __raw__ queries.

  `update`(**kwargs)

    Performs an update on the `Document` A convenience wrapper to `update()`.

    Raises `OperationError` if called on an object that has not yet been saved.

class `mongoengine.``EmbeddedDocument`(*args, **kwargs)

  A `Document` that isn’t stored in its own collection. `EmbeddedDocument`s should be used as fields on `Document`s through the `EmbeddedDocumentField` field type.

class `mongoengine.``DynamicDocument`(**values)

  A Dynamic Document class allowing flexible, expandable and uncontrolled schemas. As a `Document` subclass, acts in the same way as an ordinary document but has expando style properties. Any data passed or set against the `DynamicDocument` that is not a field is automatically converted into a `DynamicField` and data can be attributed to that field.

  ..note:

      There is one caveat on Dynamic Documents: fields cannot start with `_`

class `mongoengine.``DynamicEmbeddedDocument`(*args, **kwargs)

  A Dynamic Embedded Document class allowing flexible, expandable and uncontrolled schemas. See `DynamicDocument` for more information about dynamic documents.

class `mongoengine.document.``MapReduceDocument`(document, collection, key, value)

  A document returned from a map/reduce query.

  Parameters:

  - collection – An instance of `Collection`
  - key – Document/result key, often an instance of `ObjectId`. If supplied as an `ObjectId` found in the given `collection`, the object can be accessed via the `object` property.
  - value – The result(s) for this key.

  New in version 0.3.

  `object`

    Lazy-load the object referenced by `self.key`. `self.key` should be the `primary_key`.

class `mongoengine.``ValidationError`(message='', **kwargs)

  Validation exception.

  May represent an error validating a field or a document containing fields with validation errors.

  Variables: | errors – A dictionary of errors for fields within this document or list, or None if the error is for an individual field.

  `to_dict`()

    Returns a dictionary of all errors within a document

    Keys are field names or list indices and values are the validation error messages, or a nested dictionary of errors for an embedded document or list.

## Querying

class `mongoengine.queryset.``QuerySet`(document, collection)

  A set of results returned from a query. Wraps a MongoDB cursor, providing `Document` objects as the results.

  `__call__`(q_obj=None, class_check=True, slave_okay=False, **query)

    Filter the selected documents by calling the `QuerySet` with a query.

    Parameters:

    - q_obj – a `Q` object to be used in the query; the `QuerySet` is filtered multiple times with different `Q` objects, only the last one will be used
    - class_check – If set to False bypass class name check when querying collection
    - slave_okay – if True, allows this query to be run against a replica secondary.
    - query – Django-style query keyword arguments

  `all`()

    Returns all documents.

  `all_fields`()

    Include all fields. Reset all previously calls of .only() and .exclude().

        post = BlogPost.objects(...).exclude("comments").only("title").all_fields()

    New in version 0.5.

  `average`(field)

    Average over the values of the specified field.

    Parameters: | field – the field to average over; use dot-notation to refer to embedded document fields

    Changed in version 0.5: - updated to map_reduce as db.eval doesnt work with sharding.

  `clone`()

    Creates a copy of the current `QuerySet`

    New in version 0.5.

  `count`()

    Count the selected elements in the query.

  `create`(**kwargs)

    Create new object. Returns the saved object instance.

    New in version 0.4.

  `delete`(safe=False)

    Delete the documents matched by the query.

    Parameters: | safe – check if the operation succeeded before returning

  `distinct`(field)

    Return a list of distinct values for a given field.

    Parameters: | field – the field to select distinct values from

    New in version 0.4.

    Changed in version 0.5: - Fixed handling references

  `ensure_index`(key_or_list, drop_dups=False, background=False, **kwargs)

    Ensure that the given indexes are in place.

    Parameters: | key_or_list – a single index key or a list of index keys (to construct a multi-field index); keys may be prefixed with a + or a - to determine the index ordering

  `exclude`(*fields)

    Opposite to .only(), exclude some document’s fields.

        post = BlogPost.objects(...).exclude("comments")

    Parameters: | fields – fields to exclude

    New in version 0.5.

  `exec_js`(code, *fields, **options)

    Execute a Javascript function on the server. A list of fields may be provided, which will be translated to their correct names and supplied as the arguments to the function. A few extra variables are added to the function’s scope: `collection`, which is the name of the collection in use; `query`, which is an object representing the current query; and `options`, which is an object containing any options specified as keyword arguments.

    As fields in MongoEngine may use different names in the database (set using the `db_field` keyword argument to a `Field` constructor), a mechanism exists for replacing MongoEngine field names with the database field names in Javascript code. When accessing a field, use square-bracket notation, and prefix the MongoEngine field name with a tilde (~).

    Parameters:

    - code – a string of Javascript code to execute
    - fields – fields that you will be using in your function, which will be passed in to your function as arguments
    - options – options that you want available to the function (accessed in Javascript through the `options` object)

  `explain`(format=False)

    Return an explain plan record for the `QuerySet`‘s cursor.

    Parameters: | format – format the plan before returning it

  `fields`(**kwargs)

    Manipulate how you load this document’s fields. Used by .only() and .exclude() to manipulate which fields to retrieve. Fields also allows for a greater level of control for example:

    Retrieving a Subrange of Array Elements:

    You can use the $slice operator to retrieve a subrange of elements in an array

        post = BlogPost.objects(...).fields(slice__comments=5) // first 5 comments

    Parameters: | kwargs – A dictionary identifying what to include

    New in version 0.5.

  `filter`(*q_objs, **query)

    An alias of `__call__()`

  `first`()

    Retrieve the first object matching the query.

  `get`(*q_objs, **query)

    Retrieve the the matching object raising `MultipleObjectsReturned` or DocumentName.MultipleObjectsReturned exception if multiple results and `DoesNotExist` or DocumentName.DoesNotExist if no results are found.

    New in version 0.3.

  `get_or_create`(write_options=None, auto_save=True, *q_objs, **query)

    Retrieve unique object or create, if it doesn’t exist. Returns a tuple of `(object, created)`, where `object` is the retrieved or created object and `created` is a boolean specifying whether a new object was created. Raises `MultipleObjectsReturned` or DocumentName.MultipleObjectsReturned if multiple results are found. A new document will be created if the document doesn’t exists; a dictionary of default values for the new document may be provided as a keyword argument called `defaults`.

    Note

    This requires two separate operations and therefore a

    race condition exists. Because there are no transactions in mongoDB other approaches should be investigated, to ensure you don’t accidently duplicate data when using this method.

    Parameters: | write_options – optional extra keyword arguments used if we have to create a new document. Passes any write_options onto `save()`

    New in version 0.3.

    Parameters: | auto_save – if the object is to be saved automatically if not found.

    New in version 0.6.

  `hint`(index=None)

    Added ‘hint’ support, telling Mongo the proper index to use for the query.

    Judicious use of hints can greatly improve query performance. When doing a query on multiple fields (at least one of which is indexed) pass the indexed field as a hint to the query.

    Hinting will not do anything if the corresponding index does not exist. The last hint applied to this cursor takes precedence over all others.

    New in version 0.5.

  `in_bulk`(object_ids)

    Retrieve a set of documents by their ids.

    Parameters: | object_ids – a list or tuple of `ObjectId`s
    Return type: | dict of ObjectIds as keys and collection-specific Document subclasses as values.

    New in version 0.3.

  `insert`(doc_or_docs, load_bulk=True, safe=False, write_options=None)

    bulk insert documents

    If `safe=True` and the operation is unsuccessful, an `OperationError` will be raised.

    Parameters:

    - docs_or_doc – a document or list of documents to be inserted
    - (optional) (load_bulk) – If True returns the list of document instances
    - safe – check if the operation succeeded before returning
    - write_options – Extra keyword arguments are passed down to `insert()` which will be used as options for the resultant `getLastError` command. For example, `insert(..., {w: 2, fsync: True})` will wait until at least two servers have recorded the write and will force an fsync on each server being written to.

    By default returns document instances, set `load_bulk` to False to return just `ObjectIds`

    New in version 0.5.

  `item_frequencies`(field, normalize=False, map_reduce=True)

    Returns a dictionary of all items present in a field across the whole queried set of documents, and their corresponding frequency. This is useful for generating tag clouds, or searching documents.

    Note

    Can only do direct simple mappings and cannot map across `ReferenceField` or `GenericReferenceField` for more complex counting a manual map reduce call would is required.

    If the field is a `ListField`, the items within each list will be counted individually.

    Parameters:

    - field – the field to use
    - normalize – normalize the results so they add to 1.0
    - map_reduce – Use map_reduce over exec_js

    Changed in version 0.5: defaults to map_reduce and can handle embedded document lookups

  `limit`(n)

    Limit the number of returned documents to n. This may also be achieved using array-slicing syntax (e.g. `User.objects[:5]`).

    Parameters: | n – the maximum number of objects to return

  `map_reduce`(map_f, reduce_f, output, finalize_f=None, limit=None, scope=None)

    Perform a map/reduce query using the current query spec and ordering. While `map_reduce` respects `QuerySet` chaining, it must be the last call made, as it does not return a maleable `QuerySet`.

    See the `test_map_reduce()` and `test_map_advanced()` tests in `tests.queryset.QuerySetTest` for usage examples.

    Parameters:

    - map_f – map function, as `Code` or string
    - reduce_f – reduce function, as `Code` or string
    - output – output collection name, if set to ‘inline’ will try to use `inline_map_reduce`
    - finalize_f – finalize function, an optional function that performs any post-reduction processing.
    - scope – values to insert into map/reduce global scope. Optional.
    - limit – number of objects from current query to provide to map/reduce method

    Returns an iterator yielding `MapReduceDocument`.

    Note

    Map/Reduce changed in server version >= 1.7.4. The PyMongo `map_reduce()` helper requires PyMongo version >= 1.11.

    Changed in version 0.5: - removed `keep_temp` keyword argument, which was only relevant for MongoDB server versions older than 1.7.4

    New in version 0.3.

  `next`()

    Wrap the result in a `Document` object.

  `only`(*fields)

    Load only a subset of this document’s fields.

        post = BlogPost.objects(...).only("title", "author.name")

    Parameters: | fields – fields to include

    New in version 0.3.

    Changed in version 0.5: - Added subfield support

  `order_by`(*keys)

    Order the `QuerySet` by the keys. The order may be specified by prepending each of the keys by a + or a -. Ascending order is assumed.

    Parameters: | keys – fields to order the query results by; keys may be prefixed with + or - to determine the ordering direction

  `rewind`()

    Rewind the cursor to its unevaluated state.

    New in version 0.3.

  `scalar`(*fields)

    Instead of returning Document instances, return either a specific value or a tuple of values in order.

    This effects all results and can be unset by calling `scalar` without arguments. Calls `only` automatically.

    Parameters: | fields – One or more fields to return instead of a Document.

  `select_related`(max_depth=1)

    Handles dereferencing of `DBRef` objects to a maximum depth in order to cut down the number queries to mongodb.

    New in version 0.5.

  `skip`(n)

    Skip n documents before returning the results. This may also be achieved using array-slicing syntax (e.g. `User.objects[5:]`).

    Parameters: | n – the number of objects to skip before returning results

  `slave_okay`(enabled)

    Enable or disable the slave_okay when querying.

    Parameters: | enabled – whether or not the slave_okay is enabled

  `snapshot`(enabled)

    Enable or disable snapshot mode when querying.

    Parameters: | enabled – whether or not snapshot mode is enabled

    ..versionchanged:: 0.5 - made chainable

  `sum`(field)

    Sum over the values of the specified field.

    Parameters: | field – the field to sum over; use dot-notation to refer to embedded document fields

    Changed in version 0.5: - updated to map_reduce as db.eval doesnt work with sharding.

  `timeout`(enabled)

    Enable or disable the default mongod timeout when querying.

    Parameters: | enabled – whether or not the timeout is used

    ..versionchanged:: 0.5 - made chainable

  `update`(safe_update=True, upsert=False, multi=True, write_options=None, **update)

    Perform an atomic update on the fields matched by the query. When `safe_update` is used, the number of affected documents is returned.

    Parameters:

    - safe_update – check if the operation succeeded before returning
    - upsert – Any existing document with that “_id” is overwritten.
    - write_options – extra keyword arguments for `update()`

    New in version 0.2.

  `update_one`(safe_update=True, upsert=False, write_options=None, **update)

    Perform an atomic update on first field matched by the query. When `safe_update` is used, the number of affected documents is returned.

    Parameters:

    - safe_update – check if the operation succeeded before returning
    - upsert – Any existing document with that “_id” is overwritten.
    - write_options – extra keyword arguments for `update()`
    - update – Django-style update keyword arguments

    New in version 0.2.

  `values_list`(*fields)

    An alias for scalar

  `where`(where_clause)

    Filter `QuerySet` results with a `$where` clause (a Javascript expression). Performs automatic field name substitution like `mongoengine.queryset.Queryset.exec_js()`.

    Note

    When using this mode of query, the database will call your function, or evaluate your predicate clause, for each object in the collection.

    New in version 0.5.

  `with_id`(object_id)

    Retrieve the object matching the id provided. Uses object_id only and raises InvalidQueryError if a filter has been applied.

    Parameters: | object_id – the value for the id of the document to look up

    Changed in version 0.6: Raises InvalidQueryError if filter has been set

`mongoengine.queryset.``queryset_manager`(func)

  Decorator that allows you to define custom QuerySet managers on `Document` classes. The manager must be a function that accepts a `Document` class as its first argument, and a `QuerySet` as its second argument. The method function should return a `QuerySet`, probably the same one that was passed in, but modified in some way.

## Fields

class `mongoengine.``StringField`(regex=None, max_length=None, min_length=None, **kwargs)

  A unicode string field.

class `mongoengine.``URLField`(verify_exists=False, **kwargs)

  A field that validates input as an URL.

  New in version 0.3.

class `mongoengine.``EmailField`(regex=None, max_length=None, min_length=None, **kwargs)

  A field that validates input as an E-Mail-Address.

  New in version 0.4.

class `mongoengine.``IntField`(min_value=None, max_value=None, **kwargs)

  An integer field.

class `mongoengine.``FloatField`(min_value=None, max_value=None, **kwargs)

  An floating point number field.

class `mongoengine.``DecimalField`(min_value=None, max_value=None, **kwargs)

  A fixed-point decimal number field.

  New in version 0.3.

class `mongoengine.``DateTimeField`(db_field=None, name=None, required=False, default=None, unique=False, unique_with=None, primary_key=False, validation=None, choices=None, verbose_name=None, help_text=None)

  A datetime field.

  Note: Microseconds are rounded to the nearest millisecond.
    Pre UTC microsecond support is effecively broken. Use `ComplexDateTimeField` if you need accurate microsecond support.

class `mongoengine.``ComplexDateTimeField`(separator=', ', **kwargs)

  ComplexDateTimeField handles microseconds exactly instead of rounding like DateTimeField does.

  Derives from a StringField so you can do gte and lte filtering by using lexicographical comparison when filtering / sorting strings.

  The stored string has the following format:

  > YYYY,MM,DD,HH,MM,SS,NNNNNN

  Where NNNNNN is the number of microseconds of the represented datetime. The , as the separator can be easily modified by passing the separator keyword when initializing the field.

  New in version 0.5.

class `mongoengine.``ListField`(field=None, **kwargs)

  A list field that wraps a standard field, allowing multiple instances of the field to be used as a list in the database.

  Note

  Required means it cannot be empty - as the default for ListFields is []

class `mongoengine.``SortedListField`(field, **kwargs)

  A ListField that sorts the contents of its list before writing to the database in order to ensure that a sorted list is always retrieved.

  Warning

  There is a potential race condition when handling lists. If you set / save the whole list then other processes trying to save the whole list as well could overwrite changes. The safest way to append to a list is to perform a push operation.

  New in version 0.4.

  Changed in version 0.6: - added reverse keyword

class `mongoengine.``DictField`(basecls=None, field=None, *args, **kwargs)

  A dictionary field that wraps a standard Python dictionary. This is similar to an embedded document, but the structure is not defined.

  Note

  Required means it cannot be empty - as the default for ListFields is []

  New in version 0.3.

  Changed in version 0.5: - Can now handle complex / varying types of data

class `mongoengine.``MapField`(field=None, *args, **kwargs)

  A field that maps a name to a specified field type. Similar to a DictField, except the ‘value’ of each item must match the specified field type.

  New in version 0.5.

class `mongoengine.``ObjectIdField`(db_field=None, name=None, required=False, default=None, unique=False, unique_with=None, primary_key=False, validation=None, choices=None, verbose_name=None, help_text=None)

  An field wrapper around MongoDB’s ObjectIds.

class `mongoengine.``ReferenceField`(document_type, reverse_delete_rule=0, **kwargs)

  A reference to a document that will be automatically dereferenced on access (lazily).

  Use the reverse_delete_rule to handle what should happen if the document the field is referencing is deleted. EmbeddedDocuments, DictFields and MapFields do not support reverse_delete_rules and an InvalidDocumentError will be raised if trying to set on one of these Document / Field types.

  The options are:

  > - DO_NOTHING - don’t do anything (default).
  > - NULLIFY - Updates the reference to null.
  > - CASCADE - Deletes the documents associated with the reference.
  > - DENY - Prevent the deletion of the reference object.
  > - PULL - Pull the reference from a `ListField` of references

  Alternative syntax for registering delete rules (useful when implementing bi-directional delete rules)

      class Bar(Document):
          content = StringField()
          foo = ReferenceField('Foo')

      Bar.register_delete_rule(Foo, 'bar', NULLIFY)

  Changed in version 0.5: added reverse_delete_rule

class `mongoengine.``GenericReferenceField`(db_field=None, name=None, required=False, default=None, unique=False, unique_with=None, primary_key=False, validation=None, choices=None, verbose_name=None, help_text=None)

  A reference to any `Document` subclass that will be automatically dereferenced on access (lazily).

  ..note :: Any documents used as a generic reference must be registered in the document registry. Importing the model will automatically register it.

  ..note :: You can use the choices param to limit the acceptable Document types

  New in version 0.3.

class `mongoengine.``EmbeddedDocumentField`(document_type, **kwargs)

  An embedded document field - with a declared document_type. Only valid values are subclasses of `EmbeddedDocument`.

class `mongoengine.``GenericEmbeddedDocumentField`(db_field=None, name=None, required=False, default=None, unique=False, unique_with=None, primary_key=False, validation=None, choices=None, verbose_name=None, help_text=None)

  A generic embedded document field - allows any `EmbeddedDocument` to be stored.

  Only valid values are subclasses of `EmbeddedDocument`.

  ..note :: You can use the choices param to limit the acceptable EmbeddedDocument types

class `mongoengine.``BooleanField`(db_field=None, name=None, required=False, default=None, unique=False, unique_with=None, primary_key=False, validation=None, choices=None, verbose_name=None, help_text=None)

  A boolean field type.

  New in version 0.1.2.

class `mongoengine.``FileField`(db_alias='default', collection_name='fs', **kwargs)

  A GridFS storage field.

  New in version 0.4.

  Changed in version 0.5: added optional size param for read

  Changed in version 0.6: added db_alias for multidb support

class `mongoengine.``BinaryField`(max_bytes=None, **kwargs)

  A binary data field.

class `mongoengine.``GeoPointField`(db_field=None, name=None, required=False, default=None, unique=False, unique_with=None, primary_key=False, validation=None, choices=None, verbose_name=None, help_text=None)

  A list storing a latitude and longitude.

  New in version 0.4.

class `mongoengine.``SequenceField`(collection_name=None, db_alias=None, *args, **kwargs)

  Provides a sequental counter (see http://www.mongodb.org/display/DOCS/Object+IDs#ObjectIDs-SequenceNumbers)

  Note

  Although traditional databases often use increasing sequence numbers for primary keys. In MongoDB, the preferred approach is to use Object IDs instead. The concept is that in a very large cluster of machines, it is easier to create an object ID than have global, uniformly increasing sequence numbers.

  New in version 0.5.

### Navigation

- index
- next |
- previous |
- MongoEngine 0.6.13 documentation »