MongoCloudConnector (Mule Mongo Connector 4.0.2 API)

java.lang.Object
- org.mule.modules.mongo.MongoCloudConnector

@Connector(name="mongo",
           schemaVersion="2.0",
           friendlyName="Mongo DB",
           minMuleVersion="3.6")
@ReconnectOn(exceptions=java.lang.IllegalStateException.class)
@RequiresEnterpriseLicense
public class MongoCloudConnector
extends Object

MongoDB is an open source, high-performance, schema-free, document-oriented database that manages collections of BSON documents.

Author:: Mulesoft
Javadoc.url:: org.bson[https://api.mongodb.org/java/3.1/];, com.mongodb[https://api.mongodb.org/java/3.1/];

Constructor Summary

Constructors
Constructor and Description

MongoCloudConnector()

Constructors
Constructor and Description
`MongoCloudConnector()`

Method Summary

Methods
Modifier and Type	Method and Description
`org.bson.Document`	`addUser(String newUsername, String newPassword)` Adds a new user for this db
`long`	`countDocuments(String collection, org.bson.conversions.Bson query)` Counts the number of documents that match the given query.
`void`	`createCollection(String collection, boolean capped, Integer maxObjects, Integer size)` Creates a new collection.
`com.mongodb.DBObject`	`createFileFromPayload(Object payload, String filename, String contentType, com.mongodb.DBObject metadata)` Creates a new GridFSFile in the database, saving the given content, filename, contentType, and extraData, and answers it.
`void`	`createIndex(String collection, String field, IndexOrder order)` Creates a new index
`void`	`dropCollection(String collection)` Deletes a collection and all the objects it contains.
`void`	`dropDatabase()` Drop the current database
`void`	`dropIndex(String collection, String index)` Drops an existing index
`void`	`dump(String outputDirectory, String outputName, boolean zip, boolean oplog, int threads)` Executes a dump of the database to the specified output directory.
`org.bson.Document`	`executeCommand(String commandName, String commandValue)` Executes a command on the database
`boolean`	`existsCollection(String collection)` Answers if a collection exists given its name
`Iterable<org.bson.Document>`	`findDocuments(String collection, org.bson.Document query, List<String> fields, Integer numToSkip, Integer limit, org.bson.Document sortBy)` Finds all documents that match a given query.
`Iterable<com.mongodb.DBObject>`	`findFiles(com.mongodb.DBObject query)` Lists all the files that match the given query
`org.bson.Document`	`findOneDocument(String collection, org.bson.Document query, List<String> fields, Boolean failOnNotFound)` Finds the first document that matches a given query.
`com.mongodb.DBObject`	`findOneFile(com.mongodb.DBObject query)` Answers the first file that matches the given query.
`Config`	`getConfig()`
`InputStream`	`getFileContent(com.mongodb.DBObject query)` Answers an inputstream to the contents of the first file that matches the given query.
`void`	`incrementalDump(String outputDirectory, String incrementalTimestampFile)` Executes an incremental dump of the database
`String`	`insertDocument(String collection, org.bson.Document document)` Inserts a document in a collection, setting its id if necessary.
`Iterable<String>`	`listCollections()` Lists names of collections available at this database
`Iterable<com.mongodb.DBObject>`	`listFiles(com.mongodb.DBObject query)` Lists all the files that match the given query, sorting them by filename.
`Collection<org.bson.Document>`	`listIndices(String collection)` List existent indices in a collection
`Iterable<org.bson.Document>`	`mapReduceObjects(String collection, String mapFunction, String reduceFunction, String outputCollection)` Transforms a collection into a collection of aggregated groups, by applying a supplied element-mapping function to each element, that transforms each one into a key-value pair, grouping the resulting pairs by key, and finally reducing values in each group applying a suppling 'reduce' function.
`static org.mule.api.transformer.Transformer`	`mongoTransformerResolver(org.mule.api.transformer.DataType<?> source, org.mule.api.transformer.DataType<?> result, org.mule.api.MuleContext muleContext)`
`void`	`removeDocuments(String collection, org.bson.Document query)` Removes all the documents that match the a given optional query.
`void`	`removeFiles(com.mongodb.DBObject query)` Removes all the files that match the given query.
`void`	`restore(String inputPath, boolean drop, boolean oplogReplay)` Takes the output from the dump and restores it.
`void`	`saveDocument(String collection, org.bson.Document document)` Inserts or updates a document based on its object _id.
`void`	`setConfig(Config config)`
`org.bson.Document`	`updateDocuments(String collection, org.bson.Document query, org.bson.Document element, boolean multi)` Updates documents that matches the given query.
`org.bson.Document`	`updateDocumentsByFunction(String collection, String function, org.bson.Document query, org.bson.Document element, boolean upsert, boolean multi)` Update documents using a mongo function.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- MongoCloudConnector
```
public MongoCloudConnector()
```

Method Detail

getConfig
```
public Config getConfig()
```

setConfig
```
public void setConfig(Config config)
```

addUser
```
@Processor
public org.bson.Document addUser(String newUsername,
                                  String newPassword)
```
Adds a new user for this db

Parameters:
newUsername - Name of the user
newPassword - Password that will be used for authentication

Returns:
Result of the operation

dropDatabase
```
@Processor
public void dropDatabase()
```
Drop the current database

listCollections
```
@Processor
public Iterable<String> listCollections()
```
Lists names of collections available at this database

Returns:
the list of names of collections available at this database

existsCollection

@Processor
public boolean existsCollection(@Default(value="#[payload]")
                                 String collection)

Answers if a collection exists given its name

Parameters:: collection - the name of the collection
Returns:: if the collection exists

dropCollection
```
@Processor
public void dropCollection(@Default(value="#[payload]")
                            String collection)
```
Deletes a collection and all the objects it contains. If the collection does not exist, does nothing.

Parameters:
collection - the name of the collection to drop

createCollection

@Processor
public void createCollection(String collection,
                              @Default(value="false")
                              boolean capped,
                              @Optional
                              Integer maxObjects,
                              @Optional
                              Integer size)

Creates a new collection. If the collection already exists, a MongoException will be thrown.

Parameters:: collection - the name of the collection to create; capped - if the collection will be capped; maxObjects - the maximum number of documents the new collection is able to contain; size - the maximum size of the new collection

insertDocument
```
@Processor
public String insertDocument(String collection,
                              @RefOnly@Default(value="#[payload]")
                              org.bson.Document document)
```
Inserts a document in a collection, setting its id if necessary.

Parameters:
collection - the name of the collection where to insert the given document.
document - a Document instance.

Returns:
the id that was just inserted

updateDocuments
```
@Processor
public org.bson.Document updateDocuments(String collection,
                                          @RefOnly@Optional
                                          org.bson.Document query,
                                          @RefOnly@Default(value="#[payload]")
                                          org.bson.Document element,
                                          @Default(value="true")
                                          boolean multi)
```
Updates documents that matches the given query. If query is not specified, all documents are retrieved. If parameter multi is set to false, only the first document matching it will be updated. Otherwise, all the documents matching it will be updated.

Parameters:
collection - the name of the collection to update
query - the Document query object used to detect the element to update.
element - the Document mandatory object that will replace that one which matches the query.
multi - if all or just the first document matching the query will be updated

Returns:
a Document with the update status

updateDocumentsByFunction

@Processor
public org.bson.Document updateDocumentsByFunction(String collection,
                                                    String function,
                                                    @RefOnly@Optional
                                                    org.bson.Document query,
                                                    @RefOnly@Default(value="#[payload]")
                                                    org.bson.Document element,
                                                    @Default(value="false")
                                                    boolean upsert,
                                                    @Default(value="true")
                                                    boolean multi)

Update documents using a mongo function. If query is not specified, all documents are retrieved.

Parameters:: collection - the name of the collection to update; function - the function used to execute the update; query - the Document query document used to detect the element to update.; element - the Document mandatory document that will replace that one which matches the query.; upsert - if the database should create the element if it does not exist.; multi - if all or just the first document matching the query will be updated.
Returns:: a Document with the update status.

saveDocument
```
@Processor
public void saveDocument(String collection,
                          @RefOnly@Default(value="#[payload]")
                          org.bson.Document document)
```
Inserts or updates a document based on its object _id.

Parameters:
collection - the collection where to insert the object
document - the mandatory Document document to insert.

removeDocuments
```
@Processor
public void removeDocuments(String collection,
                             @RefOnly@Default(value="#[payload]")
                             org.bson.Document query)
```
Removes all the documents that match the a given optional query. If query is not specified, all documents are removed. However, please notice that this is normally less performant that dropping the collection and creating it and its indices again

Parameters:
collection - the collection whose elements will be removed
query - the optional Document query object. Documents that match it will be removed.

mapReduceObjects
```
@Processor
public Iterable<org.bson.Document> mapReduceObjects(String collection,
                                                     String mapFunction,
                                                     String reduceFunction,
                                                     @Optional
                                                     String outputCollection)
```
Transforms a collection into a collection of aggregated groups, by applying a supplied element-mapping function to each element, that transforms each one into a key-value pair, grouping the resulting pairs by key, and finally reducing values in each group applying a suppling 'reduce' function.
Each supplied function is coded in JavaScript.
Note that the correct way of writing those functions may not be obvious; please consult MongoDB documentation for writing them.

Parameters:
collection - the name of the collection to map and reduce
mapFunction - a JavaScript encoded mapping function
reduceFunction - a JavaScript encoded reducing function
outputCollection - the name of the output collection to write the results, replacing previous collection if existed, mandatory when results may be larger than 16MB. If outputCollection is unspecified, the computation is performed in-memory and not persisted.

Returns:
an iterable that retrieves the resulting collection of Document

countDocuments
```
@Processor
public long countDocuments(String collection,
                            @RefOnly@Default(value="#[payload]")
                            org.bson.conversions.Bson query)
```
Counts the number of documents that match the given query. If no query is passed, returns the number of elements in the collection

Parameters:
collection - the target collection
query - the optional Document query for counting documents. Only documents matching it will be counted. If unspecified, all documents are counted.

Returns:
the amount of documents that matches the query

findDocuments

@Processor
public Iterable<org.bson.Document> findDocuments(String collection,
                                                  @Default(value="#[payload]")@RefOnly
                                                  org.bson.Document query,
                                                  @Placement(group="Fields")@Optional
                                                  List<String> fields,
                                                  @Optional
                                                  Integer numToSkip,
                                                  @Optional
                                                  Integer limit,
                                                  @RefOnly@Optional
                                                  org.bson.Document sortBy)

Finds all documents that match a given query. If no query is specified, all documents of the collection are retrieved. If no fields object is specified, all fields are retrieved.

Parameters:: collection - the target collection; query - the optional Document query document. If unspecified, all documents are returned.; fields - alternative way of passing fields as a literal List; numToSkip - number of documents skip (offset); limit - limit of documents to return; sortBy - indicates the Document used to sort the results
Returns:: an iterable of Document

findOneDocument

@Processor
public org.bson.Document findOneDocument(String collection,
                                          @RefOnly@Default(value="#[payload]")
                                          org.bson.Document query,
                                          @Placement(group="Fields")@Optional
                                          List<String> fields,
                                          @Default(value="true")
                                          Boolean failOnNotFound)

Finds the first document that matches a given query. Throws a MongoException if no one matches the given query

Parameters:: collection - the target collection; query - the mandatory Document query document that the returned object matches.; fields - alternative way of passing fields as a literal List; failOnNotFound - Flag to specify if an exception will be thrown when no object is found. For backward compatibility the default value is true.
Returns:: a Document that matches the query. If nothing matches and the failOnNotFound is set to false, null will be returned

createIndex

@Processor
public void createIndex(String collection,
                         String field,
                         @Default(value="ASC")
                         IndexOrder order)

Creates a new index

Parameters:: collection - the name of the collection where the index will be created; field - the name of the field which will be indexed; order - the indexing order

dropIndex
```
@Processor
public void dropIndex(String collection,
                       String index)
```
Drops an existing index

Parameters:
collection - the name of the collection where the index is
index - the name of the index to drop

listIndices
```
@Processor
public Collection<org.bson.Document> listIndices(String collection)
```
List existent indices in a collection

Parameters:
collection - the name of the collection

Returns:
a collection of Document with indices information

createFileFromPayload

@Processor
public com.mongodb.DBObject createFileFromPayload(@Default(value="#[payload]")@RefOnly
                                                   Object payload,
                                                   String filename,
                                                   @Optional
                                                   String contentType,
                                                   @RefOnly@Optional
                                                   com.mongodb.DBObject metadata)
                                           throws IOException

Creates a new GridFSFile in the database, saving the given content, filename, contentType, and extraData, and answers it.

Parameters:: payload - the mandatory content of the new gridfs file. It may be a java.io.File, a byte[] or an InputStream.; filename - the mandatory name of new file.; contentType - the optional content type of the new file; metadata - the optional Document metadata of the new content type
Returns:: the new GridFSFile DBObject
Throws:: IOException - IOException

findFiles

@Processor
@NoMetaData
public Iterable<com.mongodb.DBObject> findFiles(@RefOnly@Default(value="#[payload]")
                                                            com.mongodb.DBObject query)

Lists all the files that match the given query

Parameters:: query - a DBObject query the optional query
Returns:: a DBObject files iterable

findOneFile

@Processor
@NoMetaData
public com.mongodb.DBObject findOneFile(@RefOnly@Default(value="#[payload]")
                                                    com.mongodb.DBObject query)

Answers the first file that matches the given query. If no object matches it, a MongoException is thrown.

Parameters:: query - the DBObject mandatory query
Returns:: a DBObject

getFileContent
```
@Processor
@NoMetaData
public InputStream getFileContent(@RefOnly@Default(value="#[payload]")
                                              com.mongodb.DBObject query)
```
Answers an inputstream to the contents of the first file that matches the given query. If no object matches it, a MongoException is thrown.

Parameters:
query - the DBObject mandatory query

Returns:
an InputStream to the file contents

listFiles
```
@Processor
@NoMetaData
public Iterable<com.mongodb.DBObject> listFiles(@RefOnly@Default(value="#[payload]")
                                                            com.mongodb.DBObject query)
```
Lists all the files that match the given query, sorting them by filename. If no query is specified, all files are listed.

Parameters:
query - the DBObject optional query

Returns:
an iterable of DBObject

removeFiles
```
@Processor
@NoMetaData
public void removeFiles(@RefOnly@Default(value="#[payload]")
                                    com.mongodb.DBObject query)
```
Removes all the files that match the given query. If no query is specified, all files are removed

Parameters:
query - the DBObject optional query

executeCommand

@Processor
public org.bson.Document executeCommand(String commandName,
                                         @Optional
                                         String commandValue)

Executes a command on the database

Parameters:: commandName - The command to execute on the database; commandValue - The value for the command
Returns:: The result of the command

dump
```
@Processor
public void dump(@Default(value="dump")
                  String outputDirectory,
                  @Optional
                  String outputName,
                  @Default(value="false")
                  boolean zip,
                  @Default(value="false")
                  boolean oplog,
                  @Default(value="5")
                  int threads)
          throws IOException
```
Executes a dump of the database to the specified output directory. If no output directory is provided then the default /dump directory is used.

Parameters:
outputDirectory - output directory path, if no output directory is provided the default /dump directory is assumed
outputName - output file name, if it's not specified the database name is used
zip - whether to zip the created dump file or not
oplog - point in time backup (requires an oplog)
threads - amount of threads to execute the dump

Throws:

IOException - if an error occurs during the dump

incrementalDump
```
@Processor
public void incrementalDump(@Default(value="dump")
                             String outputDirectory,
                             @Optional
                             String incrementalTimestampFile)
                     throws IOException
```
Executes an incremental dump of the database

Parameters:
outputDirectory - output directory path, if no output directory is provided the default /dump directory is assumed
incrementalTimestampFile - file that keeps track of the last timestamp processed, if no file is provided one is created on the output directory

Throws:

IOException - if an error occurs during the incremental dump

restore
```
@Processor
public void restore(@Default(value="dump")
                     String inputPath,
                     @Default(value="false")
                     boolean drop,
                     @Default(value="false")
                     boolean oplogReplay)
             throws IOException
```
Takes the output from the dump and restores it. Indexes will be created on a restore. It only does inserts with the data to restore, if existing data is there, it will not be replaced.

Parameters:
inputPath - input path to the dump files, it can be a directory, a zip file or just a bson file
drop - whether to drop existing collections before restore
oplogReplay - replay oplog for point-in-time restore

Throws:

IOException - if an error occurs during restore of the database

mongoTransformerResolver

@TransformerResolver
public static org.mule.api.transformer.Transformer mongoTransformerResolver(org.mule.api.transformer.DataType<?> source,
                                                                                org.mule.api.transformer.DataType<?> result,
                                                                                org.mule.api.MuleContext muleContext)
                                                                     throws org.mule.api.MuleException

Throws:: org.mule.api.MuleException

Class MongoCloudConnector

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MongoCloudConnector

Method Detail

getConfig

setConfig

addUser

dropDatabase

listCollections

existsCollection

dropCollection

createCollection

insertDocument

updateDocuments

updateDocumentsByFunction

saveDocument

removeDocuments

mapReduceObjects

countDocuments

findDocuments

findOneDocument

createIndex

dropIndex

listIndices

createFileFromPayload

findFiles

findOneFile

getFileContent

listFiles

removeFiles

executeCommand

dump

incrementalDump

restore

mongoTransformerResolver