# tMongoDBInput properties for Apache Spark Streaming (deprecated) Availability-note[Deprecated](https://help.talend.com/r/en-US/Cloud/labels-on-talend-help-center/availability-deprecated) This content is deprecated. These properties are used to configure tMongoDBInput running in the Spark Streaming Job framework. Information noteDeprecation: Spark Streaming is deprecated beginning with the R2026-09 release. Use Spark Structured Streaming instead. The Spark Streaming tMongoDBInput component belongs to the Databases family. In this type of Job, tMongDBInput is used to provide lookup data, when the size of the lookup data fits the amount of memory allocated for the execution of the Job. It is executed once to read data from MongoDB and store the data in memory so that the micro-batches from the main flow can easily access the data. If the lookup data is too large to be stored in memory, it is recommended to use tMongoDBLookupInput instead, which loads only the data matching the lookup join key. This component is available in Talend Real-Time Big Data Platform and Talend Data Fabric. ## Basic settings | Properties | Description | | --- | --- | | Property type | Either Built-In or Repository.


Built-In: No property data stored centrally.


Repository: Select the repository file where the
properties are stored. | | MongoDB configuration | Select this check box and in the Component
List drop-down list, select the desired connection component to
reuse the connection details you already defined. | | Schema and Edit
Schema | A schema is a row description. It defines the number of fields
(columns) to be processed and passed on to the next component. When you create a Spark
Job, avoid the reserved word line when naming the
fields.

Click Edit
schema to make changes to the schema. If the current schema is of the Repository type, three options are available:



If a column in the database is a JSON document and you need to read
the entire document, put an asterisk (\*) in the DB
column column, without quotation marks around. | | Collection | Enter the name of the collection to be used.

A MongoDB collection is the equivalent of an RDBMS table and contains
documents.

If the collection to be used is not shared, it is recommended to add the
*mongo.input.split\_size* property to the Advanced Hadoop MongoDB properties table. This
parameter determines how the collection is going to be partitioned and read by the
Spark executors. The number of partitions of the input collection can be calculated
using the following formula:

```
Number of partitions = Collection size in MB / mongo.input.split_size
```


Without
this property, Spark uses the default value, 8 MB, for the partition size.

For
example:

```
mongo.input.split_size 1
```


In this
example, Spark dispatches 1 MB to each Spark executor in order to read the
non-shared collection in parallel. If the collection size is 10 MB, 10 executors are
employed. | | Set read preference | Select this check box and from the Read preference
drop-down list that is displayed, select the member to which you need to direct the read
operations.

If you leave this check box clear, the Job uses the default Read preference, that is to
say, uses the primary member in a replica set.

For further information, see MongoDB's documentation about Replication and its Read
preferences. | | Query | Specify the query statement to select documents from the collection specified in the
Collection field. For example, type in "{'id':'4'}" to retrieve the record whose
*id* is
*4* from the
collection.

The default query, {} within double quotation marks provided with this
component, means to select all of the files. You can also apply a regular expression by
putting {'filename':{'$regex':'REGEX\_PATTERN'}} to define the file names to be
used.

Different from the query statements required in the MongoDB client software, the query
here refers to the contents inside find(), such as the query
{'filename':{'$regex':'REGEX\_PATTERN'}} here is the equivalent of
db.blog.find({filename:{$regex:REGEX\_PATTERN}}) in the MongoDB client
query. | | Mapping | Each column of the schema defined for this component represents a field of the documents
to be read. In this table, you need to specify the parent nodes of these fields, if
any.

For example, in the document reading as
follows

```
{
_id: ObjectId("5099803df3f4948bd2f98391"),
person: { first: "Joe", last: "Walker" }
}
```


The
*first* and the *last*
fields have *person* as their parent node but the *\_id* field does not have any parent node. So once completed, this
Mapping table should read as
follows:

```
Column Parent node path
_id
first "person"
last "person"
``` | | Limit | Enter the maximum number of records to be retrieved. | ## Advanced settings | Properties | Description | | --- | --- | | Advanced Hadoop MongoDB
properties | Add properties to define extra operations you need tMongoDBInput to perform when reading data.

The available properties are listed and explained in [MongoDB Connector for
Hadoop](https://github.com/mongodb/mongo-hadoop/wiki/Configuration-Reference).

If the collection to be used is not shared, it is recommended to add the
*mongo.input.split\_size* property to the Advanced Hadoop MongoDB properties table. This
parameter determines how the collection is going to be partitioned and read by the
Spark executors. The number of partitions of the input collection can be calculated
using the following formula:

```
Number of partitions = Collection size in MB / mongo.input.split_size
```


Without
this property, Spark uses the default value, 8 MB, for the partition size.

For
example:

```
mongo.input.split_size 1
```


In this
example, Spark dispatches 1 MB to each Spark executor in order to read the
non-shared collection in parallel. If the collection size is 10 MB, 10 executors are
employed. | ## Usage | Usage guidance | Description | | --- | --- | | **Usage rule** | This component is used to provide lookup data, when the size of the lookup data fits the
amount of memory allocated for the execution of the Job. It is executed once to read data
from MongDB and store the data in memory so that the micro-batches from the main flow can
easily access the data. If the lookup data is too large to be stored in memory, it is
recommended to use tMongoDBLookupInput instead, which loads only the data
matching the lookup join key.

This component is used as a start component and requires an output link.

This component should use a tMongoDBConfiguration component present in the same Job to connect
to a MongoDB database. You need to drop a tMongoDBConfiguration component alongside this component and
configure the Basic settings of this component
to use tMongoDBConfiguration.

This component, along with the Spark Streaming component Palette it belongs to, appears
only when you are creating a Spark Streaming Job.

Note that in this documentation, unless otherwise explicitly stated, a scenario presents
only Standard Jobs, that is to say traditional
Talend
data
integration Jobs. | | Spark Connection | In the Spark
Configuration tab in the Run
view, define the connection to a given Spark cluster for the whole Job. In
addition, since the Job expects its dependent jar files for execution, you must
specify the directory in the file system to which these jar files are
transferred so that Spark can access these files:



This connection is effective on a per-Job basis. |