ColdFusion and MongoDB

Overview

MongoDB is a cross-platform document-based NoSQL database. It uses JSON/BSON like documents with schema.

  • MongoDB stores data in flexible, JSON-like documents, meaning fields can vary from document to document and data structure can be changed over time.
  • The document model maps to the objects in your application code, making data easy to work with.
  • Ad hoc queries, indexing, and real time aggregation provide powerful ways to access and analyze your data.
  • MongoDB is a distributed database at its core, so high availability, horizontal scaling, and geographic distribution are built in and easy to use.

Features of MongoDB

The following are some of the features of MongoDB.

  • Queries: MongoDb supports ad-hoc queries and document-based queries. It also supports searching by field, range queries, and regular expressions.
  • Indexing: You can index any field in the document.
  • Replication: MongoDB supports master slave replication. MongoDB uses native application to maintain multiple copies of data.
  • Multiple Servers: The database can run over multiple servers. Data is duplicated to bullet proof the system in case of hardware failure.
  • Auto-Sharding: This process distributes data across multiple physical partitions called shards. Due to sharding, MongoDB has an automatic load-balancing feature.
  • MapReduce: Supports MapReduce and flexible aggregation tools.

For more information on the features of MongoDB, see the MongoDB official website.

Install MongoDB

To install MongoDB for your OS, see the MongoDB download center.

MongoDB vs RDBMS – a comparison

RDBMS

MongoDB

Database

Database

Table

Collection

Tuple/Row

Document

column

Field

Table Join

Embedded Documents

Primary Key

Primary Key (Default key _id provided by mongodb itself)

In MongoDB, ObjectIds or primary keys are 12 bytes long, made up of several 2-4 byte chains. The following values make up the full 12 byte combination:

  • a 4-byte value representing the seconds since the Unix epoch
  • a 3-byte machine identifier
  • a 2-byte process id
  • a 3-byte counter, starting with a random value

Install cfmongodb package

Adobe ColdFusion (2021 release) is modularized. By default, the module for MongoDB is not installed. The first step is to install the MongoDB package in ColdFusion.

The package for SQS is called cfmongodb.

To install the package cfmongodb, follow the steps below:

  1. Navigate to <CF_HOME>/cfusion/bin.
  2. Enter the command:
    1. Windows: cfpm.bat
    2. Linux: cfpm.sh
  3. Enter the command, install cfmongodb.

Wait for the MongoDB package to get installed.

Install from ColdFusion Administrator

  1. In ColdFusion Administrator > Package Manager, expand the section Available Packages.
  2. From the list of packages, select cfmongodb.
  3. Click Install.

Integration with ColdFusion

In Application.cfc, in the property datasources, create a connection to MongoDB by specifying the MongoDB host (server/localhost) and port, as shown below:

component { 
 this.name = "mongotest77123"; 
 this.serialization.preservecaseforstructkey=true 
 this.enableNullSupport=true 
 
 this.datasources = {  
  "local"= { 
   type="mongodb" 
  }, 
  "mymongodb"= { 
   type="mongodb", 
   host="mongodb://127.0.0.1:27017/", 
   "init"= true 
  } 
 } 
}

Create MongoDB datasource via ColdFusion Administrator

In ColdFusion Administrator, click Data & Services > NoSQL Data Sources.

Add and manage your NoSql data source connections and Data Source Names (DSNs).

Enter the name of the datasource and choose Driver as MongoDB.

Click Add.

Add the configuration details, such as, host, port, Enable SSL, etc. For more information, see the NoSQL options.

Create MongoDB datasource via Admin APIs

CFC: CFIDE.adminapi.nosql_datasource

setMongoDataSource

Creates or modifies a MongoDb datasource.

Syntax

public void setMongoDataSource ( required string name, required string type, required string host, string port="27017", string replicaSet, boolean ssl, boolean dnsSeedList, string authMechanism, string username, string password, string authSource, string gssapiServiceName, string readConcern, string readPreference, string w, string wtimeout, boolean j, string connectTimeout, string maxPoolSize, string minPoolSize, string maxConnectionLifeTime, string maxConnectionIdleTime, string maxWaitQueueTimeout, string maxWaitQueueSize, string heartbeatFrequency, string minHeartbeatFrequency 

Parameters

  • name: string, required, name - ColdFusion datasource name.
  • type: string, required, type - Database type.
  • host: string, required, host - Database server host name or IP address.
  • port: string, optional, port - Port that is used to access the database server. (default 27017)
  • replicaSet: string, optional, replicaSet - Specifies the name of the replica set, if the mongod is a member of a replica set.
  • ssl: boolean, optional, ssl - Whether to enable or disable TLS/SSL for the connection
  • dnsSeedList: boolean, optional, dnsSeedList
  • authMechanism: string, optional, authMechanism
  • username: string, optional, username
  • password: string, optional, password
  • authSource: string, optional, authSource
  • gssapiServiceName: string, optional,  - Specify the GSSAPI service name if the authMechanism is gssapi.
  • readConcern: string, optional, readConcern - Read Concern allows clients to choose a level of isolation for their reads from replica sets.
  • readPreference: string, optional, readPreference - Read preferences describe the behavior of read operations with regards to replica sets.
  • w: string, optional, w - The w option requests acknowledgement that the write operation has propagated to a specified number of mongod instances or to mongod instances with specified tags.
  • wtimeout: string, optional, wtimeout - This specifies a time limit, in milliseconds, for the write concern.
  • j: boolean, optional, j - The journal option requests acknowledgement from MongoDB that the write operation has been written to the journal.
  • connectTimeout: string, optional, connectTimeout - The time in milliseconds to attempt a connection before timing out.
  • maxPoolSize: string, optional, maxPoolSize - The maximum number of connections in the connection pool.
  • minPoolSize: string, optional, minPoolSize - The minimum number of connections in the connection pool.
  • maxConnectionLifeTime: string, optional, maxConnectionLifeTime - The maximum lifetime of a connection.
  • maxConnectionIdleTime: string, optional, maxConnectionIdleTime - The maximum number of milliseconds that a connection can remain idle in the pool before being removed and closed.
  • maxWaitQueueTimeout: string, optional, maxWaitQueueTimeout
  • maxWaitQueueSize: string, optional, maxWaitQueueSize - The maximum number of connections in the connection pool.
  • heartbeatFrequency: string, optional, heartbeatFrequency - Heartbeat frequency controls when the driver checks the state of the MongoDB deployment.
  • minHeartbeatFrequency: string, optional, minHeartbeatFrequency

Example

<cfscript> 
  // Create an object of administrator component and call the login method 
  adminObj = createObject("component","cfide.adminapi.administrator"); 
  adminObj.login("admin"); 
  
  // Create an object of datasource component 
  dsnObj = createObject("component","cfide.adminapi.nosql_datasource"); 
  
  // Setting up the parameter values for mongodb datasource 
  mongoDSN.name  = "mongo1" 
  mongoDSN.type = "mongodb" 
  mongoDSN.host = "127.0.0.1" 
  mongoDSN.port = "27017" 
  mongoDSN.caseSensitivity = "false" 
  
  // Create MongoDB datasource 
  mResponse=dsnObj.setMongoDataSource(mongoDSN.name,mongoDSN.type,mongoDSN.host, 
  mongoDSN.port,mongoDSN.caseSensitivity) 
</cfscript>

getDataSources

Returns a structure containing all data sources or a specified data source.

Syntax

public any getDatasources (dsnName)

Parameters

  • dsnName: any, optional, dsnName - The name of the data source for which a structure is returned.

Example

<cfscript> 
  // Create an object of administrator component and call the login method 
  adminObj = createObject("component","cfide.adminapi.administrator"); 
  adminObj.login("admin"); 
  
  // Create an object of datasource component 
  dsnObj = createObject("component","cfide.adminapi.nosql_datasource"); 
  
  res=dsnObj.getDatasources() 
  writeDump(res) 
</cfscript>

deleteMongoDatasource

Deletes the specified data source.

Syntax

public void deleteMongoDatasource ( required dsnName )

Parameters

  •  dsnName: any, required, dsnName - The name of the data source to be deleted.

Example

<cfscript> 
  // Create an object of administrator component and call the login method 
  adminObj = createObject("component","cfide.adminapi.administrator"); 
  adminObj.login("admin"); 
  
  // Create an object of datasource component 
  dsnObj = createObject("component","cfide.adminapi.nosql_datasource"); 
  
  // Get datasource 
  res=dsnObj.getDatasources() 
  writedump(res) 
  
  // Delete datasource ds1 
  dsnObj.deleteMongoDatasource(res.ds1.name) 
   
</cfscript>

verifyMongoDatasource

Verifies a given data source name.

Syntax

public Any verifyMongoDatasource ( required dsnName )

Parameters

  • dsnName: any, required, dsnName - Name that ColdFusion uses to connect to the data source.

Example

<cfscript> 
  // Create an object of administrator component and call the login method 
  adminObj = createObject("component","cfide.adminapi.administrator"); 
  adminObj.login("admin"); 
  
  // Create an object of datasource component 
  dsnObj = createObject("component","cfide.adminapi.nosql_datasource"); 
  
  // Get datasource 
  res=dsnObj.getDatasources() 
  writedump(res) 
  
  // Verify datasource ds1 
  verifyRes=dsnObj.verifyMongoDatasource(res.ds1.name)  
  writeDump(verifyRes) 
</cfscript> 

Add datasource using CFSetup

add nosql name=testset mongoport=27017 mongoHost=see-wv-a403 driverName=MONGODB maxStalenessSeconds=2000 MAXWAITQUEUETIMEOUT=2000 MAXWAITQUEUESIZE=10 MAXPOOLSIZE=20 MAXCONNECTIONLIFETIME=2000 HEARTBEATFREQUENCY=10  MAXCONNECTIONIDLETIME=2000 MINHEARTBEATFREQUENCY=2 CONNECTTIMEOUT=2000 READPREFERENCE=PRIMARY SSL=YES  REPLICASET=replica READCONCERN=majority dnsSeedList=true <alias>

Collection

A collection is equivalent to a table of a relational db. A collection stores documents that do not conform to a structure. This is because MongoDB is a schema-free database.

Create a collection

To create a collection, you must create a MongoDB database object and create the collection inside the db. A db can consist of multiple collections. See the code below for the syntax:

<cfscript> 
 // mymongodb is the name of the connection to MongoDB, defined in Application.cfc 
  
 db = getMongoService("mymongodb").db("newdb") // create a db 
 db.createCollection("Coll_1") // create a collection 
 db.createCollection("Coll_2") // create another collection 
</cfscript>

Create a document

Once you create a collection, you must insert one or more documents into the collection.

Insert one document

Here is how you can insert a single document in a collection using the insert method.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.createCollection("newcolThree") // create a collection 
 // insert a single document 
 db.newcolThree.insert({ 
  "_id": 1, 
  "name":"John Lennon", 
  "band":"Beatles" 
 }) 
</cfscript> 

Note: If you do not explicitly set an Objectid set when defining the document, MongoDB, by default, assigns one to the document. The snippet contains an explicitly set Objectid, which gets displayed.

Insert many documents

You can insert multiple documents, as an array of structs, in a collection using the insertMany method.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.newcolThree.drop() // drop the collection 
 db.createCollection("newcolThree") // create a collection 
 // insert a single document 
 db.newcolThree.insert({ 
  "_id": 1, 
  "name":"John Lennon", 
  "band":"Beatles" 
 }) 
 // insert another document 
 db.newcolThree.insertOne({ 
  "_id": 2, 
  "name":"Paul McCartney", 
  "band":"Beatles" 
 }) 
 // insert many documents 
 db.newcolThree.insertMany([ 
  { 
   "_id": 3, 
   "name":"George Harrison", 
   "band":"Beatles" 
  }, 
  { 
   "_id": 4, 
   "name":"Ringo Starr", 
   "band":"Beatles" 
  } 
 ]) 
</cfscript>

Create a capped collection

Capped collections are fixed-size circular collections that follow the insertion order to support high performance for create, read, and delete operations. By circular, it means that when the fixed size allocated to the collection is exhausted, it will start deleting the oldest document in the collection without providing any explicit commands.

Capped collections restrict updates to the documents if the update results in increased document size. Since capped collections store documents in the

order of the disk storage, it ensures that the document size does not increase the size allocated on the disk. Capped collections are best for storing log information, cache data, or any other high volume data.

For more information, see Capped collections in MongoDB.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 // create a capped collection by passing capped flag as true,  
 // size of collection, 
 // and max number of documents 
 db.createCollection("cappedLogCollection",{capped:true,size:10000,max:1000}) 
</cfscript>

If you set capped to true, you must also set a maximum size in the size field.

To check if a collection is capped, use the method isCapped.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 ifCapped=db.cappedLogCollection.isCapped() 
 writeOutput("Is collection capped: "& ifCapped) 
</cfscript>

To convert an existing non-capped collection to a capped one, use the code below. You can use the convertToCapped method to convert to a capped collection.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.convertToCapped.drop() 
 // create an un-capped collection 
 db.createCollection("convertToCapped") // create a collection 
 //convert an existing non-capped collection to a capped collection 
 db.convertToCapped({"convertToCapped":"posts",size:10000}) 
</cfscript>

Query a collection

The find method selects documents in a collection or returns a cursor to the selected documents.

The find method has two parameters, query struct and projection, both optional. For more information, see the doc for find.

In the sample below, the find method does not use any parameter.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.createCollection("colFindDemo") // create a collection 
 db.colFindDemo.insertMany([ 
   
   { "_id" : 1, "name" : "Ian Gillan", "instrument" : "Vocals","born": 1945 }, 
   { "_id" : 2, "name" : "Ian Paice", "instrument" : "Drums", "born" : 1948 }, 
   { "_id" : 3, "name" : "Roger Glover", "instrument" : "Bass", "born" : 1945 }, 
   { "_id" : 4, "name" : "Steve Morse", "instrument" : "Guitar", "born" : 1954 }, 
   { "_id" : 5, "name" : "Don Airey", "instrument" : "Keyboards", "born" : 1948 }, 
   { "_id" : 6, "name" : "Jeff Martin", "instrument" : "Vocals", "born" : 1969 }, 
   { "_id" : 7, "name" : "Jeff Burrows", "instrument" : "Drums", "born" : 1968 }, 
   { "_id" : 8, "name" : "Stuart Chatwood", "instrument" : "Bass", "born" : 1969 } 
   
 ]) 
 // return all documents 
 db.colFindDemo.find() 
</cfscript>

To find the document(s) that match a query criteria, for example, where _id equals 4, see the sample below:

<cfscript>

       db.colFindDemo.find({"_id":4})

</cfscript>

Another example that matches the criteria where instrument equals drums is shown below:

<cfscript>

       db.colFindDemo.find({"instrument":"Drums"})

</cfscript> 

Find using query operators

The examples below show the usage of query operators to find documents in a collection.

<cfscript>

       df.colFindDemo.find({"_id":{$gt:4}}) // find _ids greater than 4

</cfscript>

<cfscript>

       df.colFindDemo.find({"instrument":{$regex:"^B"}}) // find instruments that start with B

</cfscript>

<cfscript>

       db.colFindDemo.find({"name":{$in:["Ian Gillan","Ian Paice"]}}) // find documents that match the names

</cfscript>

<cfscript>

       db.colFindDemo.find({"born":{$all:[1948]}}) // find documents that match born, which contains the year 1948

</cfscript>

Update a collection

You can update a collection using these methods:

  • update
  • updateOne
  • updateMany

update

The update method modifies an existing document or documents in a collection. For more information, see update method docs.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.colUpdDemo.drop() 
 db.createCollection("colUpdDemo") // create a collection 
 db.colUpdDemo.insertMany([ 
  { 
    "_id":1, 
    "product_name": "sildenafil citrate", 
    "supplier": "Wisozk Inc", 
    "quantity": 261, 
    "unit_cost": "$10.47" 
  },  
  { 
    "_id":2, 
    "product_name": "Mountain Juniperus ashei", 
    "supplier": "Keebler-Hilpert", 
    "quantity": 292, 
    "unit_cost": "$8.74" 
  },  
  { 
    "_id":3, 
    "product_name": "Dextromathorphan HBr", 
    "supplier": "Schmitt-Weissnat", 
    "quantity": 211, 
    "unit_cost": "$20.53" 
  } 
]) 
 // increment quantity by 10 for _id:1 
 db.colUpdDemo.update({"_id":1},{$inc:{"quantity":10}}) 
 // update unit cost from 8.74 to 10.74 
 db.colUpdDemo.update({"_id":2},{$set:{"unit_cost": "$10.74"}}) 
</cfscript>

update with pipeline

The aggregation pipeline is a framework that is modeled on the idea of data processing via pipelines in stages. Documents enter a multi-stage pipeline that transforms the documents into aggregated results.

For more information, see Aggregated pipelines in MongoDB.

<cfscript> 
 db = getmongoservice("mymongodb").db("imdb"); 
 db.members.drop() 
 
 res = db.members.insertMany([ 
     { "_id" : 1, "member" : "abc123", "status" : "A", "points" : 2, "misc1" : "note to self: confirm status", "misc2" : "Need to activate" }, 
     { "_id" : 2, "member" : "xyz123", "status" : "A", "points" : 60, "misc1" : "reminder: ping me at 100pts", "misc2" : "Some random comment" } 
 ]) 
 
 writedump(res) 
 
 db.members.find().foreach((s) => { 
 writedump(s) 
 }) 
 
 writeoutput("apply update pipeline") 
 
 res = db.members.update( 
    { }, 
    [ 
      { $set: { status: "Modified", comments: [ "$misc1", "$misc2" ] } }, 
      { $unset: [ "misc1", "misc2" ] } 
    ], 
    { multi: true } 
 ) 
 
 writedump(res) 
 
 db.members.find().foreach((s) => { 
  writedump(s) 
}) 
 
 db.members.drop() 
</cfscript>

updateOne

The method, based on a specified filter, updates a single document in a collection. For more information, see updateOne method docs.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.colUpdDemo.drop() 
 db.createCollection("colUpdDemo") // create a collection 
 db.colUpdDemo.insertMany([ 
  { 
    "_id":1, 
    "product_name": "sildenafil citrate", 
    "supplier": "Wisozk Inc", 
    "quantity": 261, 
    "unit_cost": "$10.47", 
    "stock":10000 
  },  
  { 
    "_id":2, 
    "product_name": "Mountain Juniperus ashei", 
    "supplier": "Keebler-Hilpert", 
    "quantity": 292, 
    "unit_cost": "$8.74", 
    "stock":15000 
  },  
  { 
    "_id":3, 
    "product_name": "Dextromathorphan HBr", 
    "supplier": "Schmitt-Weissnat", 
    "quantity": 211, 
    "unit_cost": "$20.53", 
    "stock":20000 
  } 
]) 
    db.colUpdDemo.updateOne({"supplier": "Keebler-Hilpert"},{$set:{"stock":16000}}) 
</cfscript> 

Using Try-Catch

Using try-catch statements, you can handle certain exceptions when a certain value is missing or incorrect. For example,

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.colUpdOneDemo.drop() 
 db.createCollection("colUpdOneDemo") // create a collection 
 db.colUpdOneDemo.insertMany([ 
  { "_id" : 1, "name" : "Central Perk Cafe", "Borough" : "Manhattan" }, 
  { "_id" : 2, "name" : "Rock A Feller Bar and Grill", "Borough" : "Queens", "violations" : 2 }, 
  { "_id" : 3, "name" : "Empire State Pub", "Borough" : "Brooklyn", "violations" : 0 } 
 ]) 
 try { 
    db.restaurant.updateOne( 
        { "name" : "Central Perk Cafe New" }, // specify incorrect value 
        { $set: { "violations" : 3 } } 
    ) 
 }  
 catch (any e) { 
    WriteOutput("Error: " & e.message) 
} 
</cfscript>

updateMany

The method, based on a specified filter, updates multiple documents in a collection. For more information, see updateMany method docs.

<cfscript> 
       db = getmongoservice("mymongodb").db("newdb") // create a db 
       db.colUpdManyDemo.drop() 
       db.createCollection("colUpdManyDemo") // create a collection 
       db.colUpdManyDemo.insertMany([ 
             { 
             "_id":1, 
             "product_name": "sildenafil citrate", 
             "supplier": "Wisozk Inc", 
             "quantity": 261, 
             "unit_cost": "$10.47", 
             "stock":10000 
             },  
             { 
             "_id":2, 
             "product_name": "Mountain Juniperus ashei", 
             "supplier": "Keebler-Hilpert", 
             "quantity": 292, 
             "unit_cost": "$8.74", 
             "stock":15000 
             },  
             { 
             "_id":3, 
             "product_name": "Dextromathorphan HBr", 
             "supplier": "Schmitt-Weissnat", 
             "quantity": 211, 
             "unit_cost": "$20.53", 
             "stock":20000 
             } 
       ]) 
       // update more than one document based on the specified filter 
       db.collection.updateMany( {"quantity" : {$gt: 250 }}, {$set: { "stock" : 50000 } } ); 
</cfscript>

Support for advanced data types

Employee.cfc

component accessors="true" 
{ 
    property string empName; 
    property numeric age; 
    property string dept; 
}

Serialize CFC object

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    emp = new Employee({empName="James", age=26, dept="000"}); 
    serializedStr = serializeJSON(emp); 
    collection.insertMany([{ 
        key: serializedStr, 
        name: "John Doe" 
    }]); 
    //Read from mongo 
    result = collection.find({"name" : {$eq:   "John Doe"}}).first() 
   
    fileDataFromMongo = structFind(result, "key"); 
    fileInJSON =  DeserializeJSON(fileDataFromMongo); 
</cfscript>

CFC JSON

test.cfc

{ 
     name="John", 
     age="26" 
}

cfcjson.cfm

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    fileToRead = "#ExpandPath('./test.cfc')#"; 
    jsonContent = FileRead(fileToRead); 
    serializedStr = serializeJSON(jsonContent); 
    collection.insertMany([{ 
        key: serializedStr, 
        name: "John Doe" 
    }]); 
    //Read from mongo 
    result = collection.find({"name" : {$eq:   "John Doe"}}).first() 
   
    fileDataFromMongo = structFind(result, "key"); 
    fileInJSON =  DeserializeJSON(fileDataFromMongo); 
</cfscript>

Serialize Array

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    percentages =  [22.5 , 33 , 45]; 
    collection.insertMany([{ 
        name: "John Doe", 
 marks:{ 
     total: 15, 
     percentage : percentages 
 } 
   }]); 
    //Read from mongo 
    result = collection.find().first() 
    writedump(result) 
</cfscript>

Serialize BigDecimal

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    percent = 3333333444222244.457777778900673 
    collection.insertMany([{ 
        name: "John Doe", 
 marks:{ 
     total: 15, 
     percent = 3333333444222244.457777778900673 
 } 
   }]); 
    //Read from mongo 
    result = collection.find({"name" : {$eq:   "John Doe"}}).first() 
    writedump(result) 
</cfscript>

Serialize PDF

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
     
    collection.insertMany([{ 
        name: "John Doe", 
 marks:{ 
     key: test, 
     name:"John Doe" 
 } 
   }]); 
    //Read from mongo 
    result = collection.find({"name" : {$eq:   "John Doe"}}).first() 
    writedump(result) 
    fileDataFromMongo = structFind(result, "key"); 
    myFile=GetDirectoryFromPath(GetCurrentTemplatePath()) & "test.pdf" 
    FileWrite(file=myFile, data= fileDataFromMongo) 
</cfscript> 
<cfpdf action="extracttext" pages = "1" source="#myFile#" name="myXML" />

Serialize Query

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    myquery = QueryExecute('SELECT * FROM artists', [], {datasource = 'cfartgallery'}) 
    jsonqueryresult =  SerializeJSON(myquery) 
</cfscript> 
<cfset Start = 1> 
<cfset End = 1> 
<cfloop query="myquery" startRow = "#Start#" endRow = "#End#"> 
    <cfset address =    #myquery.ADDRESS#> 
</cfloop> 
<cfscript> 
    collection.insertMany([{ 
        key: myquery, 
        name: "John Doe", 
   }]); 
    //Read from mongo 
    result = collection.find({"name" : {$eq:   "John Doe"}}).first() 
    fileDataFromMongo = structFind(result, "key") 
</cfscript>

Serialize Image

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    fileToRead = "#ExpandPath('./test1.png')#" 
    myfile = FileOpen(fileToRead, "readBinary"); 
    binaryFileContent = FileRead(myfile, 1000); 
    stringContentForBinaryFile = toString(binaryFileContent) 
     
    collection.insertMany([{ 
        key: binaryFileContent, 
        name: "John Doe" 
   }]); 
    //Read from mongo 
    result = collection.find({"name" : {$eq:   "John Doe"}}).first() 
    fileDataFromMongo = structFind(result, "key"); 
    fileInString = ToString(ToBinary(fileDataFromMongo)) 
</cfscript>

Serialize Spreadsheet

<cfscript>  
    theDir=GetDirectoryFromPath(GetCurrentTemplatePath());  
    theFile=theDir & "courses.xls";  
</cfscript> 
<cfspreadsheet action="read" src="#theFile#" sheetname="courses" name="spreadsheetData"> 
<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    data = spreadsheetData 
         
    collection.insertMany([{ 
        key: data, 
        name: "John Doe" 
   }]); 
    //Read from mongo 
    result = collection.find({"name" : {$eq:   "John Doe"}}).first() 
    MongoResultSheet = spreadsheetRead(result.key) 
    writedump(MongoResultSheet.ROWCOUNT) 
</cfscript>

Serialize XML

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    myxml = fileRead(expandPath("./supportFiles/test.xml")); 
    mydoc = XmlParse(myxml) 
            
    collection.insertMany([{ 
        key: mydoc , 
        name: "John Doe" 
   }]); 
    //Read from mongo 
    result = collection.find({"name" : {$eq:   "John Doe"}}).first() 
    fileDataFromMongo = structFind(result, "key"); 
    fileInXML =  DeserializeXML(fileDataFromMongo) 
</cfscript>

Serialize RegEx

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    percent = 44 
    collection.insertMany([{ 
       name: "John Doe", 
       marks:{ 
     total: 15, 
     percentage: 66-22 
        }  
   }]); 
    //Read from mongo 
    result = collection.find({"name" : {$eq:   "John Doe"}}).first() 
    if( result.marks.percentage eq percent){ 
           writeoutput("Pass"); 
    } 
</cfscript>

GetMongoBsonMinKey and GetMongoBsonMaxKey

<cfscript> 
    // Retrieve database connection 
    db = getmongoservice("mymongodb").db("cf_local") 
    collection = db.students 
    // Insert many documents 
    res = collection.insertMany([{ 
        enrollno: "110470116021", 
        name: "John Adams", 
        college: GetMongoBsonMinKey() 
    }, 
    { 
        enrollno: "110470116022", 
        name: "Jane Madison", 
        college: GetMongoBsonMaxKey() 
    }]) 
    res = collection.find().toArray() 
</cfscript>

Other data types

  • Date
  • BigInt
  • MongoObjectIdNew
  • MongoRegExpNew
  • MongoDBRefNew
  • MongoBsonJSNew
  • DataBaseReference

Database operations

Create a database

To create a db in MongoDB, use the service handler function getmongoservice and create the database.

<cfscript> 
       db = getmongoservice("mymongodb").db("mynewdb") // create a db  
       writeDump(db) 
</cfscript>

Create a collection

After you create a database, you must insert a collection in the database. To create a collection, you must create a MongoDB database object and create the collection inside the db. A db can consist of multiple collections.

<cfscript> 
       db = getmongoservice("mymongodb").db("mynewdb") // create a db 
       db.createCollection("mynewdbcollection") // create a collection called mynewdbcollection 
</cfscript>

Drop a database

<cfscript> 
       db = getmongoservice("mymongodb").db("mynewdb") // create a db 
       db.dropDatabase() // Removes the database 
</cfscript>

Get the name of a database

Use the getName method to retrieve the name of the database. For more information, see Get name of a database.

<cfscript> 
       db = getmongoservice("mymongodb").db("deeppurple") // create a db 
       db.createCollection("members") // create a collection 
       db.members.insertMany([ 
              
                    { "_id" : 1, "name" : "Ian Gillan", "instrument" : "Vocals","born": 1945 }, 
                    { "_id" : 2, "name" : "Ian Paice", "instrument" : "Drums", "born" : 1948 }, 
                    { "_id" : 3, "name" : "Roger Glover", "instrument" : "Bass", "born" : 1945 }, 
                    { "_id" : 4, "name" : "Steve Morse", "instrument" : "Guitar", "born" : 1954 }, 
                    { "_id" : 5, "name" : "Don Airey", "instrument" : "Keyboards", "born" : 1948 }, 
                    { "_id" : 6, "name" : "Jeff Martin", "instrument" : "Vocals", "born" : 1969 }, 
                    { "_id" : 7, "name" : "Jeff Burrows", "instrument" : "Drums", "born" : 1968 }, 
                    { "_id" : 8, "name" : "Stuart Chatwood", "instrument" : "Bass", "born" : 1969 } 
              
       ]) 
       get_name=db.members.getName() 
       writeOutput("The name of the database is: " & get_name) 
</cfscript>

Get the names of collections in a database

Use the getCollectionNames method to retrieve the names of all the collections in a database. For more information, see getCollectionNames docs. The output is an array of collection names.

<cfscript> 
       db = getmongoservice("mymongodb").db("rockband") // create a db 
       db.deeppurple.drop() 
       db.kingcrimson.drop() 
       db.createCollection("deeppurple") // create a collection 
       db.deeppurple.insertMany([ 
              
                    { "_id" : 1, "name" : "Ian Gillan", "instrument" : "Vocals","born": 1945 }, 
                    { "_id" : 2, "name" : "Ian Paice", "instrument" : "Drums", "born" : 1948 }, 
                    { "_id" : 3, "name" : "Roger Glover", "instrument" : "Bass", "born" : 1945 }, 
                    { "_id" : 4, "name" : "Steve Morse", "instrument" : "Guitar", "born" : 1954 }, 
                    { "_id" : 5, "name" : "Don Airey", "instrument" : "Keyboards", "born" : 1948 }, 
                    { "_id" : 6, "name" : "Jeff Martin", "instrument" : "Vocals", "born" : 1969 }, 
                    { "_id" : 7, "name" : "Jeff Burrows", "instrument" : "Drums", "born" : 1968 }, 
                    { "_id" : 8, "name" : "Stuart Chatwood", "instrument" : "Bass", "born" : 1969 } 
              
       ]) 
       db.createCollection("kingcrimson") // create another collection 
       db.kingcrimson.insertMany([ 
             {"_id":1,"name":"Robert Fripp","instrument":"Guitar", 
             "_id":2, "name": "Greg Lake","instrument":"Bass", 
             "_id":3, "name": "Ian McDonald","instrument":"Keyboard", 
             "_id":4, "name": "Michael Giles", "instrument":"Drums"} 
       ]) 
       collection_names=db.getCollectionNames() 
       writeDump(collection_names) 
</cfscript>

Get information about a collection

The getCollectionInfos method returns an array of documents with collection or view information, such as name and options, for the current database. For more information, see getCollectionInfos docs.

<cfscript> 
       // The following returns information for all collections in the rockband database 
       db = getmongoservice("mymongodb").db("rockband") 
       all_collections=db.getCollectionInfos() 
       writeDump(all_collections) 
</cfscript>

To request collection information for a specific collection, specify the collection name when calling the function.

<cfscript> 
       // The following returns information for all collections in the rockband database 
       db = getmongoservice("mymongodb").db("rockband") 
       out=db.getCollectionInfos({"born":1948}) 
       writeDump(out) 
</cfscript>

Collection- CRUD methods

db.collection.count

Counts the number of documents in a collection. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // Members collection 
  countResponse=db.members.count() 
  writeDump(countResponse) // Returns all documents in the collection 
  // Count all documents that match a query 
  countResponse1=db.members.count( { born: { $gt: 1950 } } ) 
  writeDump(countResponse1) // Returns documents that match the criteria 
</cfscript>

db.collection.countdocuments

This function returns the count of documents that match the query for a collection.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // Members collection 
  countResponse=db.members.countDocuments() 
  writeDump(countResponse) // Returns all documents in the collection 
  // Count all documents that match a query 
  countResponse1=db.members.countDocuments( { born: { $gt: 1950 } } ) 
  writeDump(countResponse1) // Returns documents that match the criteria 
</cfscript>

db.collection.estimatedDocumentCount

This function returns the count of documents in a collection or view.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // Members collection 
  countResponse=db.members.countDocuments() 
  writeDump(countResponse) // Returns all documents in the collection 
  // Count all documents that match a query 
  countResponse1=db.members.estimatedDocumentCount( { born: { $gt: 1950 } } ) 
  writeDump(countResponse1) // Returns documents that match the criteria 
</cfscript>

db.collection.deleteOne

This function Removes a single document from a collection.

<cfscript> 
    // Retrieve database 
    db = getmongoservice("cosmos").db("mydb") 
    collection = db.collection 
    collection.drop() 
    writeOutput("number of documents in the collection: <b>" & collection.count() & " </b><br/>") 
    writeOutput("<b> Insert a document </b><br/>") 
    // Insert many documents 
    res = collection.insertMany([{ 
        enrollno: "1001", 
        name: "John Doe", 
        college: "Any college", 
        course: { 
            courseName: "Any course", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Any city", 
            state: "Any state", 
        country: "Any country" 
        } 
    }, 
    { 
    enrollno: "1002", 
    name: "Jane Doe", 
    college: "Some college", 
    course: { 
        courseName: "Some course", 
        duration: "4 Years" 
    }, 
    address: { 
        city: "Some city", 
        state: "Some state", 
        country: "Some country" 
    } 
    }]) 
    //count number of documents in the collection 
    writeOutput("number of documents in the collection: <b>" & collection.count() & " </b><br/>") 
    writeOutput("<b> Delete a document </b><br/>") 
    collection.deleteOne({name: MongoRegExp("John Doe","i")}) 
    writeOutput("number of documents in the collection: <b>" & collection.count() & " </b><br/>") 
</cfscript>

db.collection.deleteOne

This function removes all documents that match a filter condition from a collection.

<cfscript> 
   db = getmongoservice("mongodb").db("imdb"); 
   db.orders.drop() 
   db.orders.insertOne({ 
   _id: MongoObjectId("563237a41a4d68582c2509da"), 
   stock: "Brent Crude Futures", 
   qty: 250, 
   type: "buy-limit", 
   limit: 48.90, 
   creationts: ParseDateTime("2015-11-01T12:30:15Z"), 
   expiryts: ParseDateTime("2015-11-01T12:35:15Z"), 
   client: "Crude Traders Inc." 
   }) 
   writeoutput("count: " & db.orders.count() & " <br/>"); 
   res = db.orders.deleteMany( { "client" : "Crude Traders Inc." } ); 
   writedump(Res) 
   writeoutput("count: " & db.orders.count() & " <br/>"); 
   res = db.orders.deleteMany( { "stock" : "Brent Crude Futures", "limit" : { $gt : 48.88 } } ); 
   writedump(Res) 
   res = db.orders.deleteMany( 
   { "client" : "Crude Traders Inc." }, 
   { w : "majority", wtimeout : 100 } 
   ); 
   writedump(Res) 
   writeoutput("collation example") 
   db.mycoll.drop(); 
   res = db.mycoll.insert([{ _id: 1, category: "café", status: "A" }, 
   { _id: 2, category: "cafe", status: "a" }, 
   { _id: 3, category: "cafE", status: "a" }]) 
   writedump(res) 
   res = db.myColl.deleteMany( 
   { category: "cafe", status: "A" }, 
   { collation: { locale: "fr", strength: 1 } } 
   ) 
   writedump(res) 
   db.myColl.find().foreach((s) => { 
   writedump(s) 
   }) 
   db.mycoll.drop(); 
   db.orders.drop() 
</cfscript>

db.collection.distinct

This function finds distinct values for a specified field in a single collection.

<cfscript> 
    db = getmongoservice("mymongodb").db("imdb"); 
 
    res = db.myColl1.insertMany([ 
        { _id: 1, category: "café", status: 01 }, 
        { _id: 2, category: "cafe", status: 02 }, 
        { _id: 3, category: "cafE", status: 03 } 
    ]) 
    res = db.myColl1.distinct( "category", {}, { collation: { locale: "fr", strength: 1 } } ) 
    writedump(res) 
</cfscript>

db.collection.drop

This function removes a collection from a database.

<cfscript> 
 db = getmongoservice("mymongodb").db("mynewdb") // create a db 
 db.createCollection("mynewdbcollection") // create a collection called mynewdbcollection 
  
 try { 
  db.mynewdbcollection.drop() // Removes the collection 
  writeOutput("Collection removed sucessfully.") 
 } 
  
 catch (any e){ 
  writeOutput("Unable to remove collection.") 
 } 
 // 
</cfscript>

db.collection.explain

This function returns information for the mthods listed in this doc.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // Members collection 
  // Count function 
  explainResponse1=db.members.explain().count({ 
    born:{$gt:1950} 
  }) 
  writeDump(explainResponse1) 
</cfscript>

db.collection.find

This function selects documents in a collection or view. For more information, see db.collection.fine.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 //db.colFindDemo.drop() 
 db.createCollection("colFindDemo") // create a collection 
 db.colFindDemo.insertMany([ 
   
   { "_id" : 1, "name" : "Ian Gillan", "instrument" : "Vocals","born": 1945 }, 
   { "_id" : 2, "name" : "Ian Paice", "instrument" : "Drums", "born" : 1948 }, 
   { "_id" : 3, "name" : "Roger Glover", "instrument" : "Bass", "born" : 1945 }, 
   { "_id" : 4, "name" : "Steve Morse", "instrument" : "Guitar", "born" : 1954 }, 
   { "_id" : 5, "name" : "Don Airey", "instrument" : "Keyboards", "born" : 1948 }, 
   { "_id" : 6, "name" : "Jeff Martin", "instrument" : "Vocals", "born" : 1969 }, 
   { "_id" : 7, "name" : "Jeff Burrows", "instrument" : "Drums", "born" : 1968 }, 
   { "_id" : 8, "name" : "Stuart Chatwood", "instrument" : "Bass", "born" : 1969 } 
   
 ]) 
 // return all documents 
 db.colFindDemo.find() 
 writedump(res) 
</cfscript>

Other snippets-

<cfscript> 
 db.colFindDemo.find({"_id":4}) 
</cfscript> 
 
<cfscript> 
 db.colFindDemo.find({"instrument":"Drums"}) 
</cfscript> 
 
<cfscript> 
 df.colFindDemo.find({"_id":{$gt:4}}) // find _ids greater than 4 
</cfscript> 
 
<cfscript> 
 df.colFindDemo.find({"instrument":{$regex:"^B"}}) // find instruments that start with B 
</cfscript> 
 
<cfscript> 
 db.colFindDemo.find({"name":{$in:["Ian Gillan","Ian Paice"]}}) // find documents that match the names 
</cfscript> 
 
<cfscript> 
 db.colFindDemo.find({"born":{$all:[1948]}}) // find documents that match born, which contains the year 1948 
</cfscript> 
 
<cfscript> 
 // find all documents where instrument is Drums or the year of birth is 1948 
 db.colFindDemo.find({$or:[{"instrument":"Drums"},{"born":1948}]}) 
</cfscript>

db.collection.insert

This function inserts a document or documents into a collection.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.createCollection("newcolThree") // create a collection 
 // insert a single document 
 db.newcolThree.insert({ 
  "_id": 1, 
  "name":"John Lennon", 
  "band":"Beatles" 
 }) 
</cfscript> 

db.collection.insertOne

This function inserts a single document into a collection.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.newcolThree.drop() // drop the collection 
 db.createCollection("newcolThree") // create a collection 
 // insert a single document 
 db.newcolThree.insert({ 
  "_id": 1, 
  "name":"John Lennon", 
  "band":"Beatles" 
 }) 
 // insert another document 
 db.newcolThree.insertOne({ 
  "_id": 2, 
  "name":"Paul McCartney", 
  "band":"Beatles" 
 }) 
 // insert many documents 
 db.newcolThree.insertMany([ 
  { 
   "_id": 3, 
   "name":"George Harrison", 
   "band":"Beatles" 
  }, 
  { 
   "_id": 4, 
   "name":"Ringo Starr", 
   "band":"Beatles" 
  } 
 ]) 
</cfscript>

db.collection.insertMany

This function inserts multiple documents into a collection.

<cfscript> 
 db = getmongoservice("mymongodb").db("newdb") // create a db 
 db.newcolThree.drop() // drop the collection 
 db.createCollection("newcolThree") // create a collection 
 // insert a single document 
 db.newcolThree.insert({ 
  "_id": 1, 
  "name":"John Lennon", 
  "band":"Beatles" 
 }) 
 // insert another document 
 db.newcolThree.insertOne({ 
  "_id": 2, 
  "name":"Paul McCartney", 
  "band":"Beatles" 
 }) 
 // insert many documents 
 db.newcolThree.insertMany([ 
  { 
   "_id": 3, 
   "name":"George Harrison", 
   "band":"Beatles" 
  }, 
  { 
   "_id": 4, 
   "name":"Ringo Starr", 
   "band":"Beatles" 
  } 
 ]) 
</cfscript>

db.collection.isCapped

This function checks if a collection is a capped collection.

<cfscript> 
    db = getmongoservice("mymongodb").db("newdb") // create a db 
    ifCapped=db.cappedLogCollection.isCapped() 
    writeOutput("Is collection capped: "& ifCapped) 
</cfscript>

db.collection.latencyStats

This function returns the latency statistics of a collection. For more information, see db.collection.latencyStats.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // Members collection 
  latencyStatsResponse=db.members.latencyStats( { histograms: true } ) 
  writedump(latencyStatsResponse) 
</cfscript>

db.collection.remove

This function removes documents from a collection.

<cfscript> 
    db = getmongoservice("mymongodb").db("db_source") // create a db 
    db.createCollection("mycolone") // create a collection 
    // insert a single document 
    db.mycolone.insert({ 
        "_id": 1, 
        "name":"John Lennon", 
        "band":"Beatles" 
    }) 
    // insert another document 
    db.mycolone.insertOne({ 
        "_id": 2, 
        "name":"Paul McCartney", 
        "band":"Beatles" 
    }) 
    // insert many documents 
    db.mycolone.insertMany([ 
        { 
            "_id": 3, 
            "name":"George Harrison", 
            "band":"Beatles" 
        }, 
        { 
            "_id": 4, 
            "name":"Ringo Starr", 
            "band":"Beatles" 
        } 
    ]) 
    // remove a document 
    try{ 
        db.mycolone.remove({}) 
        writeOutput("Document removed sucessfully") 
    } 
    catch ( any e) { 
        writeDump(e) 
    } 
</cfscript>

db.collection.renameCollection

This function renames a collection.

<cfscript> 
    db = getmongoservice("mymongodb").db("db_source") // create a db 
    // create a collection 
    db.createCollection("coll_old") 
    renameRes=db.coll_old.renameCollection("coll_new") 
    writeDump(renameRes) 
</cfscript>

db.collection.replaceOne

This function replaces a single document in the collection based on a filter.

<cfscript> 
   db = getmongoservice("mongodb").db("imdb"); 
   //db.restaurant.drop() 
 
   res = db.restaurant.insertMany([ 
      { "_id" : 1, "name" : "Central Perk Cafe", "Borough" : "Manhattan" }, 
      { "_id" : 2, "name" : "Rock A Feller Bar and Grill", "Borough" : "Queens", "violations" : 2 }, 
      { "_id" : 3, "name" : "Empire State Pub", "Borough" : "Brooklyn", "violations" : 0 }]) 
 
   // writedump(res) 
 
   db.restaurant.find().foreach((s) => { 
    writedump(s) 
   }) 
 
   res = db.restaurant.replaceOne( 
      { "name" : "Central Perk Cafe" }, 
      { "name" : "Central Pork Cafe", "Borough" : "Manhattan", "violations": 10 } 
   ) 
   writedump(res) 
</cfscript>

db.collection.stats

This function returns statistics of a collection. For more information, see db.collection.stats.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  statsResponse=db.articles.stats()  
  writeDump(statsResponse) 
</cfscript>

db.collection.storageSize

This function returns the size of the storage of a document in a collection.

<cfscript> 
    db = getmongoservice("mymongodb").db("imdb"); 
    db.log.drop() 
    col = db.createCollection("log", { capped : true, size : 5242880, max : 3 } ).count(); 
    //writedump(col); 
 
    res = db.log.insertMany([ 
        { _id: 1, category: "café", status: 01 }, 
        { _id: 2, category: "cafe", status: 02 }, 
        { _id: 3, category: "cafE", status: 03 } 
    ]) 
    //writedump(res); 
    writedump(db.log.storageSize()) 
</cfscript>

db.collection.storageSize

This function returns the total size in bytes of the data in the collection.

<cfscript> 
    db = getmongoservice("mymongodb").db("imdb"); 
    db.log.drop() 
    col = db.createCollection("log", { capped : true, size : 5242880, max : 3 } ).count(); 
    //writedump(col); 
    res = db.log.insertMany([ 
        { _id: 1, category: "café", status: 01 }, 
        { _id: 2, category: "cafe", status: 02 }, 
        { _id: 3, category: "cafE", status: 03 } 
    ]) 
    //writedump(res); 
    writedump(db.log.totalSize()) 
</cfscript>

db.collection.update

This function modifies a document or documents in a collection.

<cfscript> 
    db = getmongoservice("mymongodb").db("newdb") // create a db 
    db.colUpdDemo.drop() 
    db.createCollection("colUpdDemo") // create a collection 
    db.colUpdDemo.insertMany([ 
        { 
          "_id":1, 
          "product_name": "sildenafil citrate", 
          "supplier": "Wisozk Inc", 
          "quantity": 261, 
          "unit_cost": "$10.47" 
        }, 
        { 
          "_id":2, 
          "product_name": "Mountain Juniperus ashei", 
          "supplier": "Keebler-Hilpert", 
          "quantity": 292, 
          "unit_cost": "$8.74" 
        }, 
        { 
          "_id":3, 
          "product_name": "Dextromathorphan HBr", 
          "supplier": "Schmitt-Weissnat", 
          "quantity": 211, 
          "unit_cost": "$20.53" 
        } 
]) 
    // increment quantity by 10 for _id:1 
    db.colUpdDemo.update({"_id":1},{$inc:{"quantity":10}}) 
    // update unit cost from 8.74 to 10.74 
    db.colUpdDemo.update({"_id":2},{$set:{"unit_cost": "$10.74"}}) 
</cfscript>

db.collection.updateOne

This function modifies a single document in a collection based on a filter.

<cfscript> 
    db = getmongoservice("mymongodb").db("newdb") // create a db 
    db.colUpdDemo.drop() 
    db.createCollection("colUpdDemo") // create a collection 
    db.colUpdDemo.insertMany([ 
        { 
          "_id":1, 
          "product_name": "sildenafil citrate", 
          "supplier": "Wisozk Inc", 
          "quantity": 261, 
          "unit_cost": "$10.47", 
          "stock":10000 
        }, 
        { 
          "_id":2, 
          "product_name": "Mountain Juniperus ashei", 
          "supplier": "Keebler-Hilpert", 
          "quantity": 292, 
          "unit_cost": "$8.74", 
          "stock":15000 
        }, 
        { 
          "_id":3, 
          "product_name": "Dextromathorphan HBr", 
          "supplier": "Schmitt-Weissnat", 
          "quantity": 211, 
          "unit_cost": "$20.53", 
          "stock":20000 
        } 
]) 
    db.colUpdDemo.updateOne({"supplier": "Keebler-Hilpert"},{$set:{"stock":16000}}) 
</cfscript>

db.collection.updateMany

This function modifies all documents in a collection based on a filter.

<cfscript> 
       db = getmongoservice("mymongodb").db("newdb") // create a db 
       db.colUpdManyDemo.drop() 
       db.createCollection("colUpdManyDemo") // create a collection 
       db.colUpdManyDemo.insertMany([ 
             { 
             "_id":1, 
             "product_name": "sildenafil citrate", 
             "supplier": "Wisozk Inc", 
             "quantity": 261, 
             "unit_cost": "$10.47", 
             "stock":10000 
             },  
             { 
             "_id":2, 
             "product_name": "Mountain Juniperus ashei", 
             "supplier": "Keebler-Hilpert", 
             "quantity": 292, 
             "unit_cost": "$8.74", 
             "stock":15000 
             },  
             { 
             "_id":3, 
             "product_name": "Dextromathorphan HBr", 
             "supplier": "Schmitt-Weissnat", 
             "quantity": 211, 
             "unit_cost": "$20.53", 
             "stock":20000 
             } 
       ]) 
       // update more than one document based on the specified filter 
       db.colUpdManyDemo.updateMany( {"quantity" : {$gt: 250 }}, {$set: { "stock" : 50000 } } ); 
</cfscript>

db.collection.validate

This function scans a collection and decides if the collection is a valid one.

<cfscript> 
    db = getmongoservice("mymongodb").db("newdb") // create a db 
    db.colUpdManyDemo.drop() 
    db.createCollection("colUpdManyDemo") // create a collection 
    db.colUpdManyDemo.insertMany([ 
          { 
          "_id":1, 
          "product_name": "sildenafil citrate", 
          "supplier": "Wisozk Inc", 
          "quantity": 261, 
          "unit_cost": "$10.47", 
          "stock":10000 
          },  
          { 
          "_id":2, 
          "product_name": "Mountain Juniperus ashei", 
          "supplier": "Keebler-Hilpert", 
          "quantity": 292, 
          "unit_cost": "$8.74", 
          "stock":15000 
          },  
          { 
          "_id":3, 
          "product_name": "Dextromathorphan HBr", 
          "supplier": "Schmitt-Weissnat", 
          "quantity": 211, 
          "unit_cost": "$20.53", 
          "stock":20000 
          } 
    ]) 
    // update more than one document based on the specified filter 
    db.colUpdManyDemo.updateMany( {"quantity" : {$gt: 250 }}, {$set: { "stock" : 50000 } } ); 
    isValidate=db.colUpdManyDemo.validate() 
    writeDump(isValidate) 
</cfscript>

Collection- Advanced methods

db.collection.bulkWrite

This function performs multiple write operations enabling you to define the order of execution.

<cfscript> 
   // Retrieve database  
   db = getmongoservice("mymongodb").db("imdb") 
   db.characters.drop() 
   db.characters.insert([ 
      { "_id" : 1, "char" : "Brisbane", "class" : "monk", "lvl" : 4 }, 
      { "_id" : 2, "char" : "Eldon", "class" : "alchemist", "lvl" : 3 }, 
      { "_id" : 3, "char" : "Meldane", "class" : "ranger", "lvl" : 3 } 
      ]) 
 
   res = db.characters.bulkWrite([ 
      { insertOne: { "document": { "_id": 4, "char": "Dithras", "class": "barbarian", "lvl": 4 } } }, 
      { insertOne: { "document": { "_id": 5, "char": "Taeln", "class": "fighter", "lvl": 3 } } }, 
      { updateOne : { 
         "filter" : { "char" : "Eldon" }, 
         "update" : { $set : { "status" : "Critical Injury" } } 
      } }, 
      { deleteOne : { "filter" : { "char" : "Brisbane"} } }, 
      { replaceOne : { 
         "filter" : { "char" : "Meldane" }, 
         "replacement" : { "char" : "Tanys", "class" : "oracle", "lvl": 4 } 
      } } 
   ]) 
   writedump(res) 
</cfscript>

db.collection.findAndModify

This function modifies and returns a single document. For more information, see db.collection.findandmodify.

<cfscript> 
    db = getmongoservice("mymongodb").db("student_db") 
    db.students.drop() 
    // create a collection 
    db.createCollection("students") 
    // Insert many documents 
    // Insert many documents 
    db.students.insertMany([ 
    { 
        enrollno: "1001", 
        name: "John Doe", 
        college: "Amherst", 
        course: { 
            courseName: "Math", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Any city", 
            state: "Any state", 
            country: "USA" 
        } 
    }, 
    { 
        enrollno: "1002", 
        name: "Jane Doe", 
        college: "Vassar", 
        course: { 
            courseName: "Physics", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Some city", 
            state: "Some state", 
            country: "USA" 
        } 
    }]) 
    try{ 
        res = db.students.findAndModify({ $and : [{ "enrollno" : {$gt : "1002"}} , {"name" : {$eq:"Jane Smith"}}]}) 
        writeDump(res) 
        writeOutput("Record modified successfully") 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

db.collection.findOne

This function returns a single document based on a filter. For more information, see db.collection.findone.

<cfscript> 
    db = getmongoservice("mymongodb").db("newdb") // create a db 
 //db.music.drop() 
 db.createCollection("music") // create a collection 
 db.music.insertMany([ 
   
   { "_id" : 1, "name" : "Ian Gillan", "instrument" : "Vocals","born": 1945 }, 
   { "_id" : 2, "name" : "Ian Paice", "instrument" : "Drums", "born" : 1948 }, 
   { "_id" : 3, "name" : "Roger Glover", "instrument" : "Bass", "born" : 1945 }, 
   { "_id" : 4, "name" : "Steve Morse", "instrument" : "Guitar", "born" : 1954 }, 
   { "_id" : 5, "name" : "Don Airey", "instrument" : "Keyboards", "born" : 1948 }, 
   { "_id" : 6, "name" : "Jeff Martin", "instrument" : "Vocals", "born" : 1969 }, 
   { "_id" : 7, "name" : "Jeff Burrows", "instrument" : "Drums", "born" : 1968 }, 
   { "_id" : 8, "name" : "Stuart Chatwood", "instrument" : "Bass", "born" : 1969 } 
   
    ]) 
    try{ 
        res = db.music.findOne( {"name" : {$eq:"Ian Gillan"}}) 
        writeDump(res) 
        writeOutput("Record returned successfully") 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

db.collection.findOneAndDelete

This function deletes a single document based on a filter. For more information, see db.collection.findoneanddelete.

<cfscript> 
    db = getmongoservice("mymongodb").db("student_db") 
    db.students.drop() 
    // create a collection 
    db.createCollection("students") 
    // Insert many documents 
     
    db.students.insertMany([ 
    { 
        enrollno: "1001", 
        name: "John Doe", 
        college: "Amherst", 
        course: { 
            courseName: "Math", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Any city", 
            state: "Any state", 
            country: "USA" 
        } 
    }, 
    { 
        enrollno: "1002", 
        name: "Jane Doe", 
        college: "Vassar", 
        course: { 
            courseName: "Physics", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Some city", 
            state: "Some state", 
            country: "USA" 
        } 
    }]) 
    try{ 
        res = db.students.findOneAndDelete({ $and : [{ "enrollno" : {$gt : "1000"}} , {"name" : {$eq:"Jane Doe"}}]}) 
        writeDump(res) 
        writeOutput("Record deleted successfully") 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

db.collection.findOneAndReplace

This function replaces a single document based on a filter. For more information, see db.collection.findoneandreplace.

<cfscript> 
    db = getmongoservice("mymongodb").db("newdb") 
    //db.team.drop() 
    // create a collection 
    db.createCollection("team") 
    // Insert many documents 
    db.team.insertMany([ 
        { "_id" : 1521, "team" : "Fearful Mallards", "score" : 25000 }, 
        { "_id" : 2231, "team" : "Tactful Mooses", "score" : 23500 }, 
        { "_id" : 4511, "team" : "Aquatic Ponies", "score" : 19250 }, 
        { "_id" : 5331, "team" : "Cuddly Zebras", "score" : 15235 }, 
        { "_id" : 3412, "team" : "Garrulous Bears", "score" : 22300 } 
    ]) 
    try{ 
        res = db.team.findOneAndReplace( 
                { "score" : { $lt : 30000 } }, 
                { "team" : "Observant Badgers", "score" : 20000 , "owner" : "disney"}, 
                { sort : { "score" : -1 }, projection: { "_id" : 0, "team" : 1 } } 
        ) 
        writeOutput("Record returned successfully") 
        writeDump(res) 
    } 
    catch (any e) { 
        writeDump(e) 
    } 
</cfscript>

db.collection.findOneAndUpdate

This function updates a single document based on a filter. For more information, see db.collection.findoneandupdate.

<cfscript> 
    db = getmongoservice("mymongodb").db("newdb") 
    //db.grades.drop() 
 
    db.createCollection("grades") 
  
    // Insert many documents 
    db.grades.insertMany([ 
        { _id: 6305, name : "A. MacDyver", "assignment" : 5, "points" : 24 }, 
        { _id: 6308, name : "B. Batlock", "assignment" : 3, "points" : 22 }, 
        { _id: 6312, name : "M. Tagnum", "assignment" : 5, "points" : 30 }, 
        { _id: 6319, name : "R. Stiles", "assignment" : 2, "points" : 12 }, 
        { _id: 6322, name : "A. MacDyver", "assignment" : 2, "points" : 14 }, 
        { _id: 6234, name : "R. Stiles", "assignment" : 1, "points" : 10 } 
    ]) 
 
    // with find records - records exists , use options  
    try{ 
        res = db.grades.findOneAndUpdate( 
                { "name" : "A. MacDyver" }, 
                { $inc : { "points" : 5 } }, 
                { sort : { "points" : 1 }, projection: { "assignment" : 1, "points" : 1 } } 
        ) 
        writeOutput("Record updated successfully") 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

Aggregate methods

db.collection.aggregate

This function aggregates values for data in a collection. For more information, see db.collection.aggregate.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  db.scores.drop() 
  // create a collection 
  db.createCollection("scores") 
  db.scores.insertMany([ 
  { 
      _id: 1, 
      student: "Maya", 
      homework: [ 10, 5, 10 ], 
      quiz: [ 10, 8 ], 
      extraCredit: 0 
  }, 
  { 
    _id: 2, 
    student: "Ryan", 
    homework: [ 5, 6, 5 ], 
    quiz: [ 8, 8 ], 
    extraCredit: 8 
 } 
 ]) 
 addFieldsResponse=db.scores.aggregate( [ 
   { 
     $addFields: { 
       totalHomework: { $sum: "$homework" } , 
       totalQuiz: { $sum: "$quiz" } 
     } 
   }, 
   { 
     $addFields: { totalScore: 
       { $add: [ "$totalHomework", "$totalQuiz", "$extraCredit" ] } } 
   } 
] ) 
 writeDump(addFieldsResponse) 
</cfscript>

db.collection.distinct

This function returns the distinct values in a collection. For more information, see the official docs.

<cfscript> 
    db = mongoservice("mymongodb").db("db_source") // create a db 
    // Members collection 
    distinctResponse=db.members.distinct("instrument") 
    writeDump(distinctResponse) 
</cfscript>

db.collection.count

Counts the number of documents in a collection. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // Members collection 
  countResponse=db.members.count() 
  writeDump(countResponse) // Returns all documents in the collection 
  // Count all documents that match a query 
  countResponse1=db.members.count( { born: { $gt: 1950 } } ) 
  writeDump(countResponse1) // Returns documents that match the criteria 
</cfscript>

db.collection.mapReduce

This function acts as a wrapper for mapReduce function. For more information, see the official docs.

<cfscript> 
    try 
    { 
        db = getmongoservice("mymongodb").db("mrd") 
        collection_orders = db.collection("orders") 
        //writedump(collection_orders); 
        collection_orders.insertmany([ 
        { 
            _id: CreateUUID(), 
            cust_id: "abc123", 
            ord_date:DateFormat("Oct 04, 2012"), 
            status: 'A', 
            price: 25, 
            items: [  
                { sku: "mmm", qty: 5, price: 2.5 }, 
                { sku: "nnn", qty: 5, price: 2.5 } ] 
        }, 
        { 
            _id: CreateUUID(), 
            cust_id: "def123", 
            ord_date:DateFormat("Oct 04, 2012"), 
            status: 'A', 
            price: 25, 
            items: [  
                { sku: "mmm", qty: 5, price: 2.5 }, 
                { sku: "nnn", qty: 5, price: 2.5 } ] 
        } 
    ]) 
    mapFunction1 = function() { 
            emit(this.cust_id, this.price); 
    } 
    reduceFunction1 = function(keyCustId, valuesPrices){ 
            return Array.sum(valuesPrices); 
    } 
    res = collection_orders.mapReduce( 
            "#mapFunction1#", 
            "#reduceFunction1#", 
            { out: "sample_output"}) 
    writeoutput("No of records fetched after map-reduce:" & res.len()); 
    writeoutput("<br>Value returned from records:" & res[1].value & "," & res[2].value) 
    } 
    catch(any e){ 
        writedump(e) 
    } 
    finally{ 
        db.orders.drop(); 
        db.runCommand({dropDatabase:1}); 
    } 
</cfscript>

Stream method

In MongoDB, streams enable applications to stream real-time data changes by using MongoDB’s replication capabilities. Streams help in updating data in real time so that applications access the most recent data. For example, trading systems, IOT data use data streams extensively.

Change streams notify your application of all writes to documents and provide access to information as and when changes occur, without any polling of data.

Collections.watch

This function opens a change stream for a collection. For more information, see db.collection.watch.

<cfscript> 
    // Retrieve database 
    db = getmongoservice("sharded").db("streamtest"); 
    res = db.adminCommand( { 
        enableSharding: "streamtest" 
    } ) 
    collection = db.Students; 
    res = db.adminCommand( { shardCollection: "streamtest.Students", key: { enrollno: 1 } } ); 
    cursor = collection.watch(); 
    // Insert many documents 
    res = collection.insertMany([{ 
        enrollno: "1001", 
        name: "John Doe", 
        college: "Amherst", 
        course: { 
            courseName: "Math", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Any city", 
            state: "Any state", 
            country: "USA" 
        } 
    }]) 
    streamRes = cursor.Next(); 
    writedump(var=streamRes , label="Cursor.next"); 
</cfscript>

Query caching

You can implement caching in MongoDB with the help of the following:

CachedAfter: You can cache a MongoDB query using the cachedAfter attribute. If the query was last run after the supplied date, cached data is used. Otherwise the query is re-run.

CachedWithin: The cachedWithin attribute instructs ColdFusion to execute a MongoDB query ONLY if it does not have a result set from that exact query in memory already.

CachedAfter

<cfscript> 
    db = getmongoservice("mymongodb").db("db_cache") // create a db 
    collection = db.students 
    // Insert many documents 
    collection.insertMany([ 
    { 
        enrollno: "1001", 
        name: "John Doe", 
        college: "Amherst", 
        course: { 
            courseName: "Math", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Any city", 
            state: "Any state", 
            country: "USA" 
        } 
    }, 
    { 
        enrollno: "1002", 
        name: "Jane Doe", 
        college: "Vassar", 
        course: { 
            courseName: "Physics", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Some city", 
            state: "Some state", 
            country: "USA" 
        } 
    }]) 
    currentDate = now(); 
    res1 = collection.find({ $and : [{ "enrollno" : {$gt : "1000"}} , {"name" : {$eq: "John Doe"}}]}).cachedAfter(DateAdd("s",3,currentDate)).toArray(); 
    writeOutput("<br/>Reading from db... Count is " & ArrayLen(res1)); 
    collection.insertMany([{ 
        enrollno: "1001", 
        name: "John Doe", 
        college: "Amherst", 
        course: { 
            courseName: "Math", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Any city", 
            state: "Any state", 
            country: "USA" 
        } 
    }]) 
    sleep(1000); 
    res = collection.find({ $and : [{ "enrollno" : {$gt : "1000"}} , {"name" : {$eq: "John Doe"}}]}).cachedAfter(DateAdd("s",3,currentDate)).toArray(); 
    writeOutput("<br/>reading from db before cacheAfter time... Count is " & ArrayLen(res)); 
</cfscript>

CachedWithin

<cfscript> 
    db = getmongoservice("mymongodb").db("db_cache") // create a db 
    collection = db.students 
    // Insert many documents 
    collection.insertMany([ 
    { 
        enrollno: "1001", 
        name: "John Doe", 
        college: "Amherst", 
        course: { 
            courseName: "Math", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Any city", 
            state: "Any state", 
            country: "USA" 
        } 
    }, 
    { 
        enrollno: "1002", 
        name: "Jane Doe", 
        college: "Vassar", 
        course: { 
            courseName: "Physics", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Some city", 
            state: "Some state", 
            country: "USA" 
        } 
    }]) 
    currentDate = now(); 
    res1 = collection.find({ $and : [{ "enrollno" : {$gt : "1000"}} , {"name" : {$eq: "John Doe"}}]}).cachedAfter(DateAdd("s",3,currentDate)).toArray(); 
    writeOutput("<br/>Reading from db... Count is " & ArrayLen(res1)); 
    collection.insertMany([{ 
        enrollno: "1001", 
        name: "John Doe", 
        college: "Amherst", 
        course: { 
            courseName: "Math", 
            duration: "4 Years" 
        }, 
        address: { 
            city: "Any city", 
            state: "Any state", 
            country: "USA" 
        } 
    }]) 
    sleep(1000) 
    res = collection.find({ $and : [{ "enrollno" : {$gt : "1000"}} , {"name" : {$eq: "John Doe"}}]}).cachedWithin(createTimespan(0, 0, 0, 5)).toArray(); 
    writeOutput("<br/>reading from cache... Count is " & ArrayLen(res)); 
</cfscript>

GRIDFS methods

GridFS stores files in chunks, instead of storing a file in a single document. Each chunk is stored as a separate document. For more information, see GridFS.

Instead of storing a file in a single document, GridFS divides the file into parts, or chunks [1], and stores each chunk as a separate document.

db.createBucket

GridFS stores collections in a bucket. This function creates indexes on a collection. 

<cfscript> 
    db=getmongoservice("mymongodb").db("newdb") 
    try{ 
        res=db.createBucket("newbucket") // create bucket 
        writeOutput("Bucket created successfully") 
        writeDump(res) 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
    finally{ 
        res.drop() 
    } 
</cfscript>

bucket.upload

Upload a file in a bucket.

<cfscript> 
    bucket = getmongoservice("mymongodb").db("newdb").createbucket("bucket3"); 
     
    try{ 
        returnId = bucket.upload(expandPath(".") & "/exception.log") 
        writeOutput("File uploaded successfully") 
        writeDump(returnId) 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

bucket.download

Download a file from a bucket.

<cfscript> 
    bucket = getmongoservice("mymongodb").db("newdb").createbucket("bucket"); 
    // upload a file 
    returnId = bucket.upload(expandPath(".") & "/exception.log") 
    try{ 
        result = bucket.download(expandPath("."), mongoObjectId(returnId)) 
        writeOutput("File downloaded successfully") 
        writeDump(result) 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

bucket.rename

Renames a file in a bucket.

<cfscript> 
    bucket = getmongoservice("mymongodb").db("newdb").createbucket("bucket") 
    // upload a file 
    returnId = bucket.upload(expandPath(".") & "/exception.log") 
    // rename the file in the bucket 
    try{ 
        bucket.rename(returnId, "exceptionNew.log") 
        writeOutput("File renamed successfully") 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

bucket.find

Searches for a file in a bucket.

<cfscript> 
    bucket = getmongoservice("mymongodb").db("newdb").createbucket("bucket") 
    // upload a file 
    returnId = bucket.upload(expandPath(".") & "/exception.log") 
    // rename the file in the bucket 
    bucket.rename(returnId, "exceptionNew.log") 
    try{ 
        res = bucket.find({filename: "exceptionNew.log"}).toArray() // find the file 
        if(res[1].filename == "exceptionNew.log") 
        {  
            writeoutput("File has been found.") 
        } 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

bucket.delete

Deletes a file in a bucket.

<cfscript> 
    bucket = getmongoservice("mymongodb").db("newdb").createbucket("bucket") 
    // upload a file 
    returnId = bucket.upload(expandPath(".") & "/exception.log") 
    try{ 
        res = bucket.delete(returnId) 
        if(res.name == "bucket"){ 
            writeoutput("File deleted successfully") 
        } 
    } 
    catch (any e){ 
        writeDump(e) 
    } 
</cfscript>

bucket.drop

Deletes a bucket.

<cfscript> 
    bucket = getmongoservice("mymongodb").db("newdb").createbucket("bucket") 
    try{ 
        res = bucket.drop() 
        if(res.name == "bucket"){ 
            writeoutput("Bucket is deleted successfully") 
        } 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

Index methods

db.collection.createIndex

This function creates indexes on a collection. For more information, see the official docs.

<cfscript> 
 db = getmongoservice("mymongodb").db("imdb"); 
 //db.products.drop() 
 db.createCollection("products") 
 // insert documents 
 db.products.insertMany([ 
     { "_id" : 1, "item" : "apple", "type" : "honey crisp", "price" : 1.99 }, 
     { "_id" : 2, "item" : "apple", "type" : "fuji", "price" : 1.99 }, 
     { "_id" : 3, "item" : "apple", "type" : "jonagold", "price" : 1.29 }, 
     { "_id" : 4, "item" : "apple", "type" : "jonathan", "price" : 1.29 }, 
     { "_id" : 5, "item" : "apple", "type" : "mcintosh", "price" : 1.29 }, 
     { "_id" : 6, "item" : "apple", "type" : "cortland", "price" : 1.29 }, 
     { "_id" : 7, "item" : "orange", "type" : "cara cara", "price" : 2.99 }, 
     { "_id" : 9, "item" : "orange", "type" : "satsuma", "price" : 1.99 }, 
     { "_id" : 8, "item" : "orange", "type" : "valencia", "price" : 0.99 }, 
     { "_id" : 10, "item" : "orange", "type" : "navel", "price" : 1.39 } 
 ]) 
 // create indexes 
 indexRes = db.products.createIndex( [ 
     { "item" : 1, "type" : 1 }, 
     { "item" : 1, "type" : -1 }, 
     { "price" : 1 } 
 ]) 
 
 writedump(indexRes) 
</cfscript>

db.collection.createIndexes

This function creates one or more indexes on a collection. For more information, see the official docs.

<cfscript> 
 db = getmongoservice("mymongodb").db("imdb"); 
 //db.products.drop() 
 db.createCollection("products") 
 // insert documents 
 db.products.insertMany([ 
     { "_id" : 1, "item" : "apple", "type" : "honey crisp", "price" : 1.99 }, 
     { "_id" : 2, "item" : "apple", "type" : "fuji", "price" : 1.99 }, 
     { "_id" : 3, "item" : "apple", "type" : "jonagold", "price" : 1.29 }, 
     { "_id" : 4, "item" : "apple", "type" : "jonathan", "price" : 1.29 }, 
     { "_id" : 5, "item" : "apple", "type" : "mcintosh", "price" : 1.29 }, 
     { "_id" : 6, "item" : "apple", "type" : "cortland", "price" : 1.29 }, 
     { "_id" : 7, "item" : "orange", "type" : "cara cara", "price" : 2.99 }, 
     { "_id" : 9, "item" : "orange", "type" : "satsuma", "price" : 1.99 }, 
     { "_id" : 8, "item" : "orange", "type" : "valencia", "price" : 0.99 }, 
     { "_id" : 10, "item" : "orange", "type" : "navel", "price" : 1.39 } 
 ]) 
 // create indexes 
 indexRes = db.products.createIndexes( [ 
     { "item" : 1, "type" : 1 }, 
     { "item" : 1, "type" : -1 }, 
     { "price" : 1 } 
 ]) 
 
 writedump(indexRes) 
</cfscript>

db.collection.dropIndex

This function removes a specified index from a collection. For more information, see the official docs.

<cfscript> 
 db = getmongoservice("mymongodb").db("imdb"); 
 //db.products.drop() 
 db.createCollection("products") 
 // insert documents 
 db.products.insertMany([ 
     { "_id" : 1, "item" : "apple", "type" : "honey crisp", "price" : 1.99 }, 
     { "_id" : 2, "item" : "apple", "type" : "fuji", "price" : 1.99 }, 
     { "_id" : 3, "item" : "apple", "type" : "jonagold", "price" : 1.29 }, 
     { "_id" : 4, "item" : "apple", "type" : "jonathan", "price" : 1.29 }, 
     { "_id" : 5, "item" : "apple", "type" : "mcintosh", "price" : 1.29 }, 
     { "_id" : 6, "item" : "apple", "type" : "cortland", "price" : 1.29 }, 
     { "_id" : 7, "item" : "orange", "type" : "cara cara", "price" : 2.99 }, 
     { "_id" : 9, "item" : "orange", "type" : "satsuma", "price" : 1.99 }, 
     { "_id" : 8, "item" : "orange", "type" : "valencia", "price" : 0.99 }, 
     { "_id" : 10, "item" : "orange", "type" : "navel", "price" : 1.39 } 
 ]) 
 // create indexes 
 createIdx=db.products.createIndex( [ 
     { "item" : 1, "type" : 1 }, 
     { "item" : 1, "type" : -1 }, 
     { "price" : 1 } 
 ]) 
 
 // drop index 
        db.products.dropIndex(createIdx) 
</cfscript>

db.collection.dropIndexes

This function removes a specified index or indexes from a collection. For more information, see the official docs.

<cfscript> 
 db = getmongoservice("mymongodb").db("imdb"); 
 //db.products.drop() 
 db.createCollection("products") 
 // insert documents 
 db.products.insertMany([ 
     { "_id" : 1, "item" : "apple", "type" : "honey crisp", "price" : 1.99 }, 
     { "_id" : 2, "item" : "apple", "type" : "fuji", "price" : 1.99 }, 
     { "_id" : 3, "item" : "apple", "type" : "jonagold", "price" : 1.29 }, 
     { "_id" : 4, "item" : "apple", "type" : "jonathan", "price" : 1.29 }, 
     { "_id" : 5, "item" : "apple", "type" : "mcintosh", "price" : 1.29 }, 
     { "_id" : 6, "item" : "apple", "type" : "cortland", "price" : 1.29 }, 
     { "_id" : 7, "item" : "orange", "type" : "cara cara", "price" : 2.99 }, 
     { "_id" : 9, "item" : "orange", "type" : "satsuma", "price" : 1.99 }, 
     { "_id" : 8, "item" : "orange", "type" : "valencia", "price" : 0.99 }, 
     { "_id" : 10, "item" : "orange", "type" : "navel", "price" : 1.39 } 
 ]) 
 // create indexes 
 createIdx=db.products.createIndex( [ 
     { "item" : 1, "type" : 1 }, 
     { "item" : 1, "type" : -1 }, 
     { "price" : 1 } 
 ]) 
 
 // drop index 
        db.products.dropIndexes(createIdx) 
</cfscript>

db.collection.getIndexes

This function decribes the existing indexes on a collection. For more information, see the official docs.

<cfscript> 
    db = getmongoservice("mymongodb").db("imdb"); 
    // db.products.drop() 
    db.createCollection("products") 
    // insert documents 
    db.products.insertMany([ 
           { "_id" : 1, "item" : "apple", "type" : "honey crisp", "price" : 1.99 }, 
           { "_id" : 2, "item" : "apple", "type" : "fuji", "price" : 1.99 }, 
           { "_id" : 3, "item" : "apple", "type" : "jonagold", "price" : 1.29 }, 
           { "_id" : 4, "item" : "apple", "type" : "jonathan", "price" : 1.29 }, 
           { "_id" : 5, "item" : "apple", "type" : "mcintosh", "price" : 1.29 }, 
           { "_id" : 6, "item" : "apple", "type" : "cortland", "price" : 1.29 }, 
           { "_id" : 7, "item" : "orange", "type" : "cara cara", "price" : 2.99 }, 
           { "_id" : 9, "item" : "orange", "type" : "satsuma", "price" : 1.99 }, 
           { "_id" : 8, "item" : "orange", "type" : "valencia", "price" : 0.99 }, 
           { "_id" : 10, "item" : "orange", "type" : "navel", "price" : 1.39 } 
    ]) 
    // create indexes 
    db.products.createIndexes( [ 
           { "item" : 1, "type" : 1 }, 
           { "item" : 1, "type" : -1 }, 
           { "price" : 1 } 
    ]) 
  
    // get index 
    getRes=db.products.getIndexes() 
    writeDump(getRes) 
</cfscript>

db.collection.reIndex

This function removes all indexes on a collection and rebuilds them.. For more information, see the official docs.

<cfscript> 
    db = getmongoservice("mymongodb").db("imdb"); 
    // db.products.drop() 
    db.createCollection("products") 
    // insert documents 
    db.products.insertMany([ 
           { "_id" : 1, "item" : "apple", "type" : "honey crisp", "price" : 1.99 }, 
           { "_id" : 2, "item" : "apple", "type" : "fuji", "price" : 1.99 }, 
           { "_id" : 3, "item" : "apple", "type" : "jonagold", "price" : 1.29 }, 
           { "_id" : 4, "item" : "apple", "type" : "jonathan", "price" : 1.29 }, 
           { "_id" : 5, "item" : "apple", "type" : "mcintosh", "price" : 1.29 }, 
           { "_id" : 6, "item" : "apple", "type" : "cortland", "price" : 1.29 }, 
           { "_id" : 7, "item" : "orange", "type" : "cara cara", "price" : 2.99 }, 
           { "_id" : 9, "item" : "orange", "type" : "satsuma", "price" : 1.99 }, 
           { "_id" : 8, "item" : "orange", "type" : "valencia", "price" : 0.99 }, 
           { "_id" : 10, "item" : "orange", "type" : "navel", "price" : 1.39 } 
    ]) 
    // create indexes 
    db.products.createIndexes( [ 
           { "item" : 1, "type" : 1 }, 
           { "item" : 1, "type" : -1 }, 
           { "price" : 1 } 
    ]) 
  
    // re index 
    try{ 
        res=db.products.reIndex() 
        writeOutput("Indexes removed and re-created successfully") 
        writeDump(res) 
    } 
    catch(any e){ 
        writeDump(e) 
    } 
</cfscript>

db.collection.totalIndexSize

This function returns the total size of all the indexes in a collection.. For more information, see the official docs.

<cfscript> 
    db = getmongoservice("mymongodb").db("imdb"); 
    // db.products.drop() 
    db.createCollection("products") 
    // insert documents 
    db.products.insertMany([ 
           { "_id" : 1, "item" : "apple", "type" : "honey crisp", "price" : 1.99 }, 
           { "_id" : 2, "item" : "apple", "type" : "fuji", "price" : 1.99 }, 
           { "_id" : 3, "item" : "apple", "type" : "jonagold", "price" : 1.29 }, 
           { "_id" : 4, "item" : "apple", "type" : "jonathan", "price" : 1.29 }, 
           { "_id" : 5, "item" : "apple", "type" : "mcintosh", "price" : 1.29 }, 
           { "_id" : 6, "item" : "apple", "type" : "cortland", "price" : 1.29 }, 
           { "_id" : 7, "item" : "orange", "type" : "cara cara", "price" : 2.99 }, 
           { "_id" : 9, "item" : "orange", "type" : "satsuma", "price" : 1.99 }, 
           { "_id" : 8, "item" : "orange", "type" : "valencia", "price" : 0.99 }, 
           { "_id" : 10, "item" : "orange", "type" : "navel", "price" : 1.39 } 
    ]) 
    // create indexes 
    db.products.createIndexes( [ 
           { "item" : 1, "type" : 1 }, 
           { "item" : 1, "type" : -1 }, 
           { "price" : 1 } 
    ]) 
  
    totSize=db.products.totalIndexSize() 
    writeDump(totSize) 
</cfscript>

Database methods

db.adminCommand

The db.adminCommand provides a helper function to run database commands. For more information, see the official docs.

The example below uses db.adminCommand() to execute the renameCollection database command to rename the collection collection1 in the db_source database to collection11.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  renameResponse=  db.adminCommand( 
  { 
     renameCollection: "db_source.collection1", 
     to: "db_source.collection11" 
  } 
) 
  writeDump(renameResponse) 
</cfscript>

db.createCollection

Creates a collection. You can also use this method to create a capped collection. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  isSuccessful=db.createCollection("log", { capped : true, size : 5242880, max : 5000 } ) 
  writeDump(isSuccessful) 
</cfscript>

db.createView

This function Creates a view as the result of the applying the specified aggregation pipeline to the source collection or view. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // create a collection 
  db.createCollection("survey") 
  db.survey.insertMany([ 
    { _id: 1, empNumber: "abc123", feedback: { management: 3, environment: 3 }, department: "A" }, 
    { _id: 2, empNumber: "xyz987", feedback: { management: 2, environment: 3 }, department: "B" }, 
    { _id: 3, empNumber: "ijk555", feedback: { management: 3, environment: 4 }, department: "A" } 
  ]) 
  // create view 
  viewResponse=db.createView( 
   "managementFeedback", 
   "survey", 
   [ { $project: { "management": "$feedback.management", department: 1 } } ] 
  ) 
  writeDump(viewResponse) 
</cfscript>

db.currentOp

This function Returns a document that contains information on in-progress operations for the database instance. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // The following example returns information on all active operations for 
  // database db_source that have been running longer than 3 seconds 
  currentOpResponse=db.currentOp( 
   { 
     "active" : true, 
     "secs_running" : { "$gt" : 3 }, 
     "ns" : /^db_source\./ 
   } 
) 
writeDump(currentOpResponse) 
</cfscript>

db.getCollection

This function returns a collection object for any collection in the database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  collectionResponse=db.getCollection("survey") 
  writeDump(collectionResponse) 
</cfscript>

db.getCollectionInfos

This function returns an array of documents with collection or view information, such as name and options, for the current database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  collInfoResponse=db.getCollectionInfos() 
  writeDump(collInfoResponse) 
</cfscript>

db.getCollectionNames

This function returns an array containing the names of all collections and views in the current database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  collNamesResponse=db.getCollectionNames() 
  writeDump(collNamesResponse) 
</cfscript>

db.getMongo

This function returns the current database connection. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  mongoResponse=db.getMongo() 
  writeDump(mongoResponse) 
</cfscript>

db.getName

This function returns the current name of the database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  nameResponse=db.getName() 
  writeDump(nameResponse) 
</cfscript>

db.getSiblingDB

This function returns a database object. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  siblingResponse=db.getSiblingDB("db_source") 
  writeDump(siblingResponse) 
</cfscript>

db.hostInfo

This function returns an array with system information that the mongod or mongos runs on. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  hostInfoResponse=db.hostInfo() 
  writeDump(hostInfoResponse) 
</cfscript>

db.isMaster

This function returns an array that describes the mongod session. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  isMasterResponse=db.isMaster() 
  writeDump(isMasterResponse) 
</cfscript>

db.runCommand

This function acts as a helper for the following database commands:

Command

Description

logout

Terminates the current authenticated session.

createUser

Creates a new user.

dropAllUsersFromDatabase

Deletes all users associated with a database.

dropUser

Removes a single user.

grantRolesToUser

Grants a role and its privileges to a user.

revokeRolesFromUser

Removes a role from a user.

updateUser

Updates a user’s data.

usersInfo

Returns information about the specified users.

createUser

Creates a new user.

dropAllUsersFromDatabase

Deletes all users associated with a database.

dropUser

Removes a single user.

grantRolesToUser

Grants a role and its privileges to a user.

revokeRolesFromUser

Removes a role from a user.

updateUser

Updates a user’s data.

usersInfo

Returns information about the specified users.

createRole

Creates a role and specifies its privileges.

dropRole

Deletes the user-defined role.

dropAllRolesFromDatabase

Deletes all user-defined roles from a database.

grantPrivilegesToRole

Assigns privileges to a user-defined role.

grantRolesToRole

Specifies roles from which a user-defined role inherits privileges.

invalidateUserCache

Flushes the in-memory cache of user information, including credentials and roles.

revokePrivilegesFromRole

Removes the specified privileges from a user-defined role.

revokeRolesFromRole

Removes specified inherited roles from a user-defined role.

rolesInfo

Returns information for the specified role or roles.

updateRole

Updates a user-defined role.

delete

Deletes one or more documents.

find

Selects documents in a collection or a view.

findAndModify

Returns and modifies a single document.

getLastError

Returns the success status of the last operation.

insert

Inserts one or more documents.

resetError

Resets the last error status.

update

Updates one or more documents.

This command will fail in some cases when unordered structs are sent to it. MongoDB functions accepts keys in a certain order and while sending them via ColdFusion. Ensure that these keys are ordered. Hence for all these commands, use ordered structs .

For example,

res = db.runCommand 
([ 
    "createUser" : "mongouser2", 
    "pwd" : "testpassword", 
    "customData" : {"testUser":"ok"}, 
    "roles": [["role":"readWrite","db":dbName]] 
])

db.serverBuildInfo

This function returns a document that contains an overview of parameters used to compile this mongod instance. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  buildResponse=db.serverBuildInfo() 
  writeDump(buildResponse) 
</cfscript>

db.serverStatus

This function returns a struct that provides an overview of the database process’s state. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  serverResponse=db.serverStatus() 
  writeDump(serverResponse) 
</cfscript>

db.stats

This function returns statistics for a database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  statsResponse=db.stats(1024) // To display kilobytes rather than bytes, specify a scale value of 1024. 
  writeDump(statsResponse) 
</cfscript>

db.version

This function returns the version of the mongo instance. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  versionResponse=db.version() 
  writeDump(versionResponse) 
</cfscript>

User Management methods

db.changeUserPassword

This function updates the password of a user.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  db.changeUserPassword("username","password") 
</cfscript>
<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  db.changeUserPassword("username",passwordPrompt()) // Prompt for a new password 
</cfscript>

db.createUser

This function creates a new user for the database on which the method is run. For more information, see the official docs.

<cfscript> 
    db = getmongoservice("mymongodb").db("db_source") // create a db 
    createResponse=db.createUser( 
   { 
     user: "User1", 
     pwd: "admin123", 
     roles: [ "readWrite", "dbAdmin" ] 
   } 
   ) 
   writeDump(createResponse) 
</cfscript>

db.dropUser

This function removes a user from the current database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  dropResponse=db.dropUser("User1") 
  writeDump(dropResponse) 
</cfscript>

db.dropAllUsers

This function drops all users in a database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // create three users 
  db.createUser( 
 { 
   user: "User1", 
   pwd: "admin123", 
   roles: [ "readWrite", "dbAdmin" ] 
 } 
 ) 
 db.createUser( 
{ 
  user: "User2", 
  pwd: "admin123", 
  roles: [ "readWrite", "dbAdmin" ] 
} 
) 
db.createUser( 
{ 
 user: "User3", 
 pwd: "admin123", 
 roles: [ "readWrite", "dbAdmin" ] 
} 
) 
dropAllResponse=db.dropAllUsers({w: "majority", wtimeout: 5000}) 
writeDump(dropAllResponse) 
</cfscript> 

db.getUser

This function returns information about a specified user. For more information, see the official docs.

<cfscript> 
    db = getmongoservice("mymongodb").db("db_source") // create a db 
    // create a user 
    db.createUser( 
    { 
         user: "User1", 
         pwd: "admin123", 
         roles: [ "readWrite", "dbAdmin" ] 
    } 
    ) 
    getUserResponse=db.getUser("User1") 
    writeDump(getUserResponse) 
</cfscript>

db.getUsers

This function returns information about all users in the database. For more information, see the official docs.

<cfscript> 
db = getmongoservice("mymongodb").db("db_source") // create a db 
// create three users 
db.createUser( 
{ 
 user: "User11", 
 pwd: "admin123", 
 roles: [ "readWrite", "dbAdmin" ] 
} 
) 
db.createUser( 
{ 
user: "User12", 
pwd: "admin123", 
roles: [ "readWrite", "dbAdmin" ] 
} 
) 
db.createUser( 
{ 
user: "User13", 
pwd: "admin123", 
roles: [ "readWrite", "dbAdmin" ] 
} 
) 
getUsersResponse=db.getUsers() 
writeDump(getUsersResponse) 
</cfscript>

db.grantRolesToUser

This function grants roles to a user. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  // create a user 
  db.createUser( 
  { 
   user: "User001", 
   pwd: "admin123", 
   roles: ["dbAdmin"] 
  } 
  ) 
  grantRoleResponse=db.grantRolesToUser("User001",["read","readWrite"]) 
  writeDump(grantRoleResponse) 
</cfscript>

db.revokeRolesFromUser

This function removes a one or more roles from a user on the current database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  revokeRoleResponse=db.revokeRolesFromUser("User001",["read","readWrite"]) 
  writeDump(revokeRoleResponse) 
</cfscript>

db.updateUser

This function updates the user’s profile on the database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  updateRole={ 
    roles:["read","readWrite"] 
  } 
  updateUserResponse=db.updateUser("User001",updateRole) 
  writeDump(updateUserResponse) 
</cfscript>

Role Management methods

db.createRole

This function creates a role in the database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  roleDocument={ 
    "role": "newRead", 
    "privileges": [ 
    [ resource: [ db: "db_source" , collection: "" ], 
       actions: [ "find", "createCollection", "dbStats", "collStats" ] ] 
    ], 
    "roles":[] 
  } 
  createRoleResponse=db.createRole(roleDocument) 
  writeDump(createRoleResponse) 
</cfscript>

db.dropRole

This function deletes a user-defined role from the database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source_1") // create a db 
  // create a user defined role 
  dbName="db_source_1" 
  db.createRole( 
[ 
  role: "customrole1", 
  privileges: [ 
       [ resource: [ db: dbName , collection: "" ], 
         actions: [ "find", "createCollection", "dbStats", "collStats" ] ], 
       [ resource: [ db: dbName, collection: "logs" ], 
         actions: [ "insert" ] ], 
       [ resource: [ db: dbName, collection: "data" ], 
         actions: [ "insert", "update", "remove", "compact" ] ], 
       [ resource: [ db: dbName, collection: "system.js" ], 
         actions: [ "find" ] ] 
  ], 
  roles : [["role":"userAdmin","db":dbName], 
  ["role":"readWrite","db":dbName] 
 ] 
]) 
    dropRoleResponse=db.dropRole("customrole1") 
    writeDump(dropRoleResponse) 
</cfscript> 

db.dropAllRoles

This function deletes all user-defined roles on the database.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source_1") // create a db 
  dbName="db_source_1" 
  // create three custom roles 
  db.createRole( 
[ 
  role: "customrole11", 
  privileges: [ 
       [ resource: [ db: dbName , collection: "" ], 
         actions: [ "find", "createCollection", "dbStats", "collStats" ] ], 
       [ resource: [ db: dbName, collection: "logs" ], 
         actions: [ "insert" ] ], 
       [ resource: [ db: dbName, collection: "data" ], 
         actions: [ "insert", "update", "remove", "compact" ] ], 
       [ resource: [ db: dbName, collection: "system.js" ], 
         actions: [ "find" ] ] 
  ], 
  roles : [["role":"userAdmin","db":dbName], 
  ["role":"readWrite","db":dbName] 
 ] 
]) 
 
db.createRole( 
[ 
role: "customrole12", 
privileges: [ 
     [ resource: [ db: dbName , collection: "" ], 
       actions: [ "find", "createCollection", "dbStats", "collStats" ] ], 
     [ resource: [ db: dbName, collection: "logs" ], 
       actions: [ "insert" ] ], 
     [ resource: [ db: dbName, collection: "data" ], 
       actions: [ "insert", "update", "remove", "compact" ] ], 
     [ resource: [ db: dbName, collection: "system.js" ], 
       actions: [ "find" ] ] 
], 
roles : [["role":"userAdmin","db":dbName], 
["role":"readWrite","db":dbName] 
] 
]) 
    dropAllRolesResponse=db.dropAllRoles({ w: "majority" }) 
    writeDump(dropAllRolesResponse) 
</cfscript> 

db.getRole

This function returns the roles from which this role inherits privileges. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source_1") // create a db 
  getRoleResponse=db.getRole("newRead",{ 
    "showBuiltinRoles":true, 
    "showPrivileges":true 
  }) 
  writeDump(getRoleResponse) 
</cfscript>

db.getRoles

This function retrieves information of all the roles in the database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source_1") // create a db 
  getAllRolesResponse=db.getRoles( 
  { 
    rolesInfo: 1, 
    showPrivileges:true, 
    showBuiltinRoles: true 
  } 
  ) 
  writeDump(getAllRolesResponse) 
</cfscript>

db.grantPrivilegesToRole

This function grants additional privileges to a user-defined role. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  dbName="db_source" 
  grantResponse=db.grantPrivilegesToRole("newRead", 
  [ 
  { 
    resource: { db: dbName, collection: "" }, 
    actions: [ "insert" ] 
  }, 
  { 
    resource: { db: dbName, collection: "system.js" }, 
    actions: [ "find" ] 
  } 
] 
  ) 
  writeDump(grantResponse) 
</cfscript>

db.revokePrivilegesFromRole

This function removes specified specified privileges from the user-defined role on the database. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  dbName="db_source" 
  // create a user defined role 
  db.createrole( 
  [ 
  role: "customrole005", 
  privileges: [ 
       [ resource: [ db: dbName , collection: "" ], 
         actions: [ "find", "createCollection", "dbStats", "collStats" ] ], 
       [ resource: [ db: dbName, collection: "logs" ], 
         actions: [ "insert" ] ], 
       [ resource: [ db: dbName, collection: "data" ], 
         actions: [ "insert", "update", "remove", "compact" ] ], 
       [ resource: [ db: dbName, collection: "system.js" ], 
         actions: [ "find" ] ] 
  ], 
  roles : [["role":"userAdmin","db":dbName], 
  ["role":"readWrite","db":dbName] 
 ] 
]) 
  revokeResponse=db.revokePrivilegesFromRole("customrole002", 
  [ 
  { 
    resource: { db: dbName, collection: "" }, 
    actions: [ "find","createCollection" ] 
  }, 
  { 
    resource: { db: dbName, collection: "system.js" }, 
    actions: [ "find" ] 
  } 
] 
  ) 
  writeDump(revokeResponse) 
</cfscript>

db.grantRolesToRole

This function grants roles to a user-defined role. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  grantRoleUDR=db.grantRolesToRole("customrole005",["read"]) 
  writeDump(grantRoleUDR) 
</cfscript>

db.revokeRolesFromRole

This function removes the specified inherited roles from a role. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  revokeRoleUDR=db.revokeRolesFromRole("customrole005",["read"]) 
  writeDump(revokeRoleUDR) 
</cfscript>

db.updateRole

This function updates a user-defined role. For more information, see the official docs.

<cfscript> 
  db = getmongoservice("mymongodb").db("db_source") // create a db 
  dbName="db_source" 
  roleDocument={ 
    privileges:[ 
    [ resource: [ db: dbName , collection: "" ], 
       actions: [ "find", "createCollection", "dbStats", "collStats" ] ] 
    ], 
    roles:["read","readWrite"] 
  } 
  updateRoleResponse=db.updateRole("customrole005",roleDocument) 
  writeDump(updateRoleResponse) 
</cfscript>

Limitations

GSSAPI authentication is not supported in MongoDB.

شعار Adobe

تسجيل الدخول إلى حسابك