db.createCollection()

Definition

db.createCollection(name, options)

Creates a new collection or view. For views, see also db.createView().

Because MongoDB creates a collection implicitly when the collection is first referenced in a command, this method is used primarily for creating new collections that use specific options. For example, you use db.createCollection() to create a capped collection, or to create a new collection that uses document validation.

db.createCollection() is a wrapper around the database command create.

The db.createCollection() method has the following prototype form:

Note

Starting in MongoDB 4.2

MongoDB removes the MMAPv1 storage engine and the MMAPv1 specific options paddingFactor, paddingBytes, preservePadding for db.createCollection().

db.createCollection( <name>,
   {
     capped: <boolean>,
     timeseries: {                  // Added in MongoDB 5.0
        timeField: <string>,        // required for time series collections
        metaField: <string>,
        granularity: <string>
     },
     expireAfterSeconds: <number>,
     autoIndexId: <boolean>,
     size: <number>,
     max: <number>,
     storageEngine: <document>,
     validator: <document>,
     validationLevel: <string>,
     validationAction: <string>,
     indexOptionDefaults: <document>,
     viewOn: <string>,              // Added in MongoDB 3.4
     pipeline: <pipeline>,          // Added in MongoDB 3.4
     collation: <document>,         // Added in MongoDB 3.4
     writeConcern: <document>
   }
)

The db.createCollection() method has the following parameters:

Parameter	Type	Description
name	string	The name of the collection to create. See Naming Restrictions.
options	document	Optional. Configuration options for creating a capped collection, for preallocating space in a new collection, or for creating a view.

The options document contains the following fields:

Field	Type	Description
capped	boolean	Optional. To create a capped collection, specify true. If you specify true, you must also set a maximum size in the size field.
timeseries.timeField	string	Required when creating a time series collection. The name of the field which contains the date in each time series document. Documents in a time series collection must have a valid BSON date as the value for the timeField.
timeseries.metaField	string	Optional. The name of the field which contains metadata in each time series document. The metadata in the specified field should be data that is used to label a unique series of documents. The metadata should rarely, if ever, change. The name of the specified field may not be _id or the same as the timeseries.timeField. The field can be of any type except array.
timeseries.granularity	string	Optional. Possible values are "seconds" (default), "minutes", and "hours". Set the granularity to the value that is the closest match to the time span between consecutive incoming measurements. Setting the granularity parameter improves performance by optimizing how data in the time series collection is stored internally.
expireAfterSeconds	number	Optional. Enable the automatic deletion of documents in a time series collection by specifying the number of seconds after which documents expire. MongoDB deletes expired documents automatically.
autoIndexId	boolean	Optional. Specify false to disable the automatic creation of an index on the _id field. Important Starting in MongoDB 4.0, you cannot set the option autoIndexId to false when creating collections in databases other than the local database. Deprecated since version 3.2.
size	number	Optional. Specify a maximum size in bytes for a capped collection. Once a capped collection reaches its maximum size, MongoDB removes the older documents to make space for the new documents. The size field is required for capped collections and ignored for other collections.
max	number	Optional. The maximum number of documents allowed in the capped collection. The size limit takes precedence over this limit. If a capped collection reaches the size limit before it reaches the maximum number of documents, MongoDB removes old documents. If you prefer to use the max limit, ensure that the size limit, which is required for a capped collection, is sufficient to contain the maximum number of documents.
storageEngine	document	Optional. Available for the WiredTiger storage engine only. Allows users to specify configuration to the storage engine on a per-collection basis when creating a collection. The value of the storageEngine option should take the following form: { <storage-engine-name>: <options> } Storage engine configuration specified when creating collections are validated and logged to the oplog during replication to support replica sets with members that use different storage engines. Tip See also: Specify Storage Engine Options
validator	document	Optional. Allows users to specify validation rules or expressions for the collection. For more information, see Schema Validation. New in version 3.2. The validator option takes a document that specifies the validation rules or expressions. You can specify the expressions using the same operators as the query operators with the exception of $near, $nearSphere, $text, and $where. Note Validation occurs during updates and inserts. Existing documents do not undergo validation checks until modification. You cannot specify a validator for collections in the admin, local, and config databases. You cannot specify a validator for system.* collections.
validationLevel	string	Optional. Determines how strictly MongoDB applies the validation rules to existing documents during an update. New in version 3.2. validationLevel Description "off" No validation for inserts or updates. "strict" Default Apply validation rules to all inserts and all updates. "moderate" Apply validation rules to inserts and to updates on existing valid documents. Do not apply rules to updates on existing invalid documents.
validationAction	string	Optional. Determines whether to error on invalid documents or just warn about the violations but allow invalid documents to be inserted. New in version 3.2. Important Validation of documents only applies to those documents as determined by the validationLevel. validationAction Description "error" Default Documents must pass validation before the write occurs. Otherwise, the write operation fails. "warn" Documents do not have to pass validation. If the document fails validation, the write operation logs the validation failure.
indexOptionDefaults	document	Optional. Allows users to specify a default configuration for indexes when creating a collection. The indexOptionDefaults option accepts a storageEngine document, which should take the following form: { <storage-engine-name>: <options> } Storage engine configuration specified when creating indexes are validated and logged to the oplog during replication to support replica sets with members that use different storage engines. New in version 3.2.
viewOn	string	The name of the source collection or view from which to create the view. The name is not the full namespace of the collection or view; i.e. does not include the database name and implies the same database as the view to create. You must create views in the same database as the source collection. See also db.createView(). New in version 3.4.
pipeline	array	An array that consists of the aggregation pipeline stage(s). db.createView() creates the view by applying the specified pipeline to the viewOn collection or view. The view definition pipeline cannot include the $out or the $merge stage. If the view definition includes nested pipeline (e.g. the view definition includes $lookup or $facet stage), this restriction applies to the nested pipelines as well. The view definition is public; i.e. db.getCollectionInfos() and explain operations on the view will include the pipeline that defines the view. As such, avoid referring directly to sensitive fields and values in view definitions. See also db.createView(). New in version 3.4.
collation	document	Specifies the default collation for the collection. Collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks. The collation option has the following syntax: collation: { locale: <string>, caseLevel: <boolean>, caseFirst: <string>, strength: <int>, numericOrdering: <boolean>, alternate: <string>, maxVariable: <string>, backwards: <boolean> } When specifying collation, the locale field is mandatory; all other collation fields are optional. For descriptions of the fields, see Collation Document. If you specify a collation at the collection level: Indexes on that collection will be created with that collation unless the index creation operation explicitly specify a different collation. Operations on that collection use the collection's default collation unless they explicitly specify a different collation. You cannot specify multiple collations for an operation. For example, you cannot specify different collations per field, or if performing a find with a sort, you cannot use one collation for the find and another for the sort. If no collation is specified for the collection or for the operations, MongoDB uses the simple binary comparison used in prior versions for string comparisons. For a collection, you can only specify the collation during the collection creation. Once set, you cannot modify the collection's default collation. For an example, see Specify Collation. New in version 3.4.
writeConcern	document	Optional. A document that expresses the write concern for the operation. Omit to use the default write concern. When issued on a sharded cluster, mongos converts the write concern of the create command and its helper db.createCollection() to "majority".

Access Control

If the deployment enforces authentication/authorization, db.createCollection() requires the following privileges:

A user with the readWrite built in role on the database has the required privileges to run the listed operations. Either create a user with the required role or grant the role to an existing user.

Behavior

Examples

db.createCollection("log", { capped : true, size : 5242880, max : 5000 } )

db.createCollection(
    "weather24h",
    {
       timeseries: {
          timeField: "timestamp",
          metaField: "data",
          granularity: "hours"
       },
       expireAfterSeconds: 86400
    }
)

db.createCollection( "contacts", {
   validator: { $jsonSchema: {
      bsonType: "object",
      required: [ "phone" ],
      properties: {
         phone: {
            bsonType: "string",
            description: "must be a string and is required"
         },
         email: {
            bsonType : "string",
            pattern : "@mongodb\.com$",
            description: "must be a string and match the regular expression pattern"
         },
         status: {
            enum: [ "Unknown", "Incomplete" ],
            description: "can only be one of the enum values"
         }
      }
   } }
} )

db.contacts.insertOne( { name: "Amanda", status: "Updated" } )

Uncaught:
MongoServerError: Document failed validation
Additional information: {
  failingDocumentId: ObjectId("61a8f4847a818411619e952e"),
  details: {
    operatorName: '$jsonSchema',
    schemaRulesNotSatisfied: [
      {
        operatorName: 'properties',
        propertiesNotSatisfied: [
          {
            propertyName: 'status',
            description: 'can only be one of the enum values',
            details: [ [Object] ]
          }
        ]
      },
      {
        operatorName: 'required',
        specifiedAs: { required: [ 'phone' ] },
        missingProperties: [ 'phone' ]
      }
    ]
  }
}

db.createCollection( "myColl", { collation: { locale: "fr" } } );

{ _id: 1, category: "café" }
{ _id: 2, category: "cafe" }
{ _id: 3, category: "cafE" }

db.myColl.find().sort( { category: 1 } )

{ "_id" : 2, "category" : "cafe" }
{ "_id" : 3, "category" : "cafE" }
{ "_id" : 1, "category" : "café" }

{ "_id" : 3, "category" : "cafE" }
{ "_id" : 2, "category" : "cafe" }
{ "_id" : 1, "category" : "café" }

db.createCollection(
   "users",
   { storageEngine: { wiredTiger: { configString: "<option>=<setting>" } } }
)