Rishabh Bisht

Product Manager

[Time series](https://www.mongodb.com/time-series) data is a set of data points collected at regular intervals. It’s a common use case in many industries such as finance, IoT, and telecommunications. MongoDB provides powerful features for handling time series data, and in this tutorial, we will show you how to build a C++ console application that uses MongoDB to store time series data, related to the Air Quality Index (AQI) for a given location. We will also take a look at [MongoDB Charts](https://www.mongodb.com/docs/charts/) to visualize the data saved in the time series.

Libraries used in this tutorial:
1. [MongoDB C Driver version: 1.23.0](https://github.com/mongodb/mongo-c-driver/releases)
2. [MongoDB C++ Driver version: 3.7.0](https://github.com/mongodb/mongo-cxx-driver/releases)
3. [cpr library](https://github.com/libcpr/cpr)
4. [vcpkg](https://vcpkg.io/en/index.html)
5. Language standard:  C++17

This tutorial uses Microsoft Windows 11 and [Microsoft Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) but the code used in this tutorial should work on any operating system and IDE, with minor changes.

## Prerequisites
1. [MongoDB Atlas account](https://www.mongodb.com/developer/products/atlas/free-atlas-cluster/) with a cluster created.
2. Microsoft Visual Studio setup with MongoDB C and C++ Driver installed. Follow the instructions in [Getting Started with MongoDB and C++](https://www.mongodb.com/developer/products/mongodb/getting-started-mongodb-c/) to install MongoDB C/C++ drivers and set up the dev environment in Visual Studio.
3. Your machine’s IP address is [whitelisted](https://www.mongodb.com/docs/guides/atlas/network-connections/). Note: You can add 0.0.0.0/0 as the IP address, which should allow access from any machine. This setting is not recommended for production use.
4. API token is generated using [Air Quality Open Data Platform API Token Request Form](https://aqicn.org/data-platform/token/) to fetch AQI for a given location.

## Installation: Libraries
Launch powershell/terminal as an administrator and execute commands shared below.

Step 1: Install [vcpkg](https://vcpkg.io/en/index.html).

```
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
```

Step 2: Install [libcpr/cpr](https://github.com/libcpr/cpr).

```
./vcpkg install cpr:x64-windows
```

This tutorial assumes we are working with x64 architecture. If you are targeting x86, please use this command:

```
./vcpkg install cpr
```

Note: Below warning (if encountered) can be ignored.

```
# this is heuristically generated, and may not be correct
find_package(cpr CONFIG REQUIRED)
target_link_libraries(main PRIVATE cpr::cpr)
```

## Building the application

> Source code available [here](https://github.com/mongodb-developer/get-started-cxx/blob/main/aqi-monitor-console-app/AQIMonitor.cpp)

In this tutorial, we will build an [Air Quality Index](https://en.wikipedia.org/wiki/Air_quality_index) (AQI) monitor that will save the AQI of a given location to a time series collection.
 
The AQI is a measure of the quality of the air in a particular area, with higher numbers indicating worse air quality. The AQI is based on a scale of 0 to 500 and is calculated based on the levels of several pollutants in the air. 

We are going to build a console application from scratch. Follow the steps on how to set up the development environment in Visual Studio from our previous article [Getting Started with MongoDB and C++](https://www.mongodb.com/developer/products/mongodb/getting-started-mongodb-c/), under the section “[Visual Studio: Setting up the dev environment](https://www.mongodb.com/developer/products/mongodb/getting-started-mongodb-c/#visual-studio--setting-up-the-dev-environment).”

### Helper functions
Once we have set up a Visual Studio solution, let’s start with adding the necessary headers and writing the helper functions.
* Make sure to include `<cpr/cpr.h>` to access methods provided by the *cpr* library. 

Note: Since we installed the cpr library with vcpkg, it automatically adds the needed include paths and dependencies to Visual Studio.

* [Get the connection string](https://www.mongodb.com/docs/guides/atlas/connection-string/) (URI) to the cluster and create a new environment variable with key as `“MONGODB_URI”` and value as the connection string (URI). It’s a good practice to keep the connection string decoupled from the code.
Similarly, save the API token obtained in the Prerequisites section with the key as `“AQICN_TOKEN”`.

Navigate to the Solution Explorer panel, right-click on the solution name, and click “Properties.” Go to Configuration Properties > Debugging > Environment to add these environment variables as shown below.

![Setting environment variables in Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/setting_environment_variables_3aee66f0ef.png)

* `“getAQI”` function makes use of the *cpr* library to make a call to the REST API, fetching the AQI data. The response to the request is then parsed to get the AQI figure.
* `“saveToCollection”` function saves the given AQI figure to the time series collection. Please note that adding the `“timestamp”` key-value pair is mandatory. A missing timestamp will lead to an exception being thrown. Check out different `“timeseries”` Object Fields in [Create and Query a Time Series Collection — MongoDB Manual](https://www.mongodb.com/docs/manual/core/timeseries/timeseries-procedures/#std-label-timeseries-create-query-procedures). 

```
#pragma once


#include <mongocxx/client.hpp>
#include <bsoncxx/builder/list.hpp>
#include <bsoncxx/builder/stream/document.hpp>
#include <bsoncxx/json.hpp>
#include <mongocxx/uri.hpp>
#include <mongocxx/instance.hpp>


#include <iostream>
#include <cpr/cpr.h>


using namespace std;


std::string getEnvironmentVariable(std::string environmentVarKey)
{
	char* pBuffer = nullptr;
	size_t size = 0;
	auto key = environmentVarKey.c_str();
	
	// Use the secure version of getenv, ie. _dupenv_s to fetch environment variable.  
	if (_dupenv_s(&pBuffer, &size, key) == 0 && pBuffer != nullptr)
	{
		std::string environmentVarValue(pBuffer);
		free(pBuffer);
		return environmentVarValue;
	}
	else
	{
		return "";
	}
}


int getAQI(std::string city, std::string apiToken)
{
	// Call the API to get the air quality index.
	std::string aqiUrl = "https://api.waqi.info/feed/" + city + "/?token=" + apiToken;
	auto aqicnResponse = cpr::Get(cpr::Url{ aqiUrl });


	// Get the AQI from the response
	if(aqicnResponse.text.empty())
	{
		cout << "Error: Response is empty." << endl;
		return -1;
	}
	bsoncxx::document::value aqicnResponseBson = bsoncxx::from_json(aqicnResponse.text);
	auto aqi = aqicnResponseBson.view()["data"]["aqi"].get_int32().value;
	return aqi;
}


void saveToCollection(mongocxx::collection& collection, int aqi)
{
	auto timeStamp = bsoncxx::types::b_date(std::chrono::system_clock::now());


	bsoncxx::builder::stream::document aqiDoc = bsoncxx::builder::stream::document{};
	aqiDoc << "timestamp" << timeStamp << "aqi" << aqi;
	collection.insert_one(aqiDoc.view());


	// Log to the console window.
	cout << " TimeStamp: " << timeStamp << " AQI: " << aqi << endl;
}
```

### The main() function
With all the helper functions in place, let’s write the main function that will drive this application.
* The main function creates/gets the time series collection by specifying the `“collection_options”` to the `“create_collection”` method. 
Note: MongoDB creates collections implicitly when you first reference the collection in a command, however a time series collection needs to be created explicitly with “[create_collection](https://mongocxx.org/api/mongocxx-3.7.0/classmongocxx_1_1database.html#a9ee98d7fb1fc703d262764c2643361f8)”. 
* Every 30 minutes, the program gets the AQI figure and updates it into the time series collection. Feel free to modify the time interval as per your liking by changing the value passed to `“sleep_for”`.

```
int main()
{
	// Get the required parameters from environment variable.
	auto mongoURIStr = getEnvironmentVariable("MONGODB_URI");
	auto apiToken = getEnvironmentVariable("AQICN_TOKEN");
	std::string city = "Delhi";
	static const mongocxx::uri mongoURI = mongocxx::uri{ mongoURIStr };


	if (mongoURI.to_string().empty() || apiToken.empty())
	{
		cout << "Invalid URI or API token. Please check the environment variables." << endl;
		return 0;
	}


	// Create an instance.
	mongocxx::instance inst{};
	mongocxx::options::client client_options;
	auto api = mongocxx::options::server_api{ mongocxx::options::server_api::version::k_version_1 };
	client_options.server_api_opts(api);
	mongocxx::client conn{ mongoURI, client_options };


	// Setup Database and Collection.
	const string dbName = "AQIMonitor";
	const string timeSeriesCollectionName = "AQIMonitorCollection";


	// Setup Time Series collection options.
	bsoncxx::builder::document timeSeriesCollectionOptions =
	{
	   "timeseries",
		{
		  "timeField", "timestamp",
		  "granularity", "minutes"
		}
	};


	auto aqiMonitorDB = conn[dbName];
	auto aqiMonitorCollection = aqiMonitorDB.has_collection(timeSeriesCollectionName)
		? aqiMonitorDB[timeSeriesCollectionName]
		: aqiMonitorDB.create_collection(timeSeriesCollectionName, timeSeriesCollectionOptions.view().get_document().value);


	// Fetch and update AQI every 30 minutes.
	while (true)
	{ 
		auto aqi = getAQI(city, apiToken);
		saveToCollection(aqiMonitorCollection, aqi);
		std::this_thread::sleep_for(std::chrono::minutes(30));
	}


	return 0;
}
```

When this application is executed, you can see the below activity in the console window.

![AQI Monitor application in C++ with MongoDB time series](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/aqi_monitor_application_d8d0541782.png)

You can also see the time series collection in Atlas reflecting any change made via the console application.

![MongoDB time series in MongoDB Atlas](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_time_series_04e5ef6c59.png)

## Visualizing the data with MongoDB Charts
We can make use of MongoDB Charts to visualize the AQI data and run aggregation on top of it.

Step 1: Go to [MongoDB Charts](https://cloud.mongodb.com/charts/) and click on “Add Dashboard” to create a new dashboard — name it “AQI Monitor”.

Step 2: Click on “Add Chart”.

Step 3: In the “Select Data Source” dialog, go to the “Project” tab and navigate to the time series collection created by our code.

![Selecting data source for MongoDB Charts](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/selecting_data_source_5050d98116.png)

Step 4: Change the chart type to “Continuous Line”. We will use this chart to display the AQI trends over time.

Step 5: Drag and drop the “timestamp” and “aqi” fields into the X axis and Y axis respectively. You can customize the look and feel (like labels, color, and data format) in the “Customize” tab. Click “Save and close” to save the chart.

![MongoDB Charts with time series](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_charts_497c6bda95.gif)

Step 6: Let’s add another chart to display the maximum AQI — click on “Add Chart” and select the same data source as before.

Step 7: Change the chart type to “Number”.

Step 8: Drag and drop the “aqi” field into “Aggregation” and change Aggregate to “MAX”.

![MongoDB Charts with time series](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/charts_with_time_series_73f28aed56.gif)

Step 9: We can customize the chart text to change color based on the AQI values. Let’s make the text green if AQI is less than or equal to 100, and red otherwise. We can perform this action with the conditional formatting option under Customize tab.

![Formatting options in MongoDB Charts](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/formatting_options_e6d6330e57.png)

Step 10: Similarly, we can add charts for minimum and average AQI. The dashboard should finally look something like this:

![MongoDB Charts dashboard](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_charts_dashboard_3fb5198f14.png)

Tip: Change the dashboard’s auto refresh settings from “Refresh settings” button to choose a refresh time interval of your choice for the charts.

![MongoDB Charts refresh settings](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_charts_refresh_settings_c528f263bc.png)

## Conclusion
With this article, we covered creating an application in C++ that writes data to a MongoDB time series collection, and used it further to create a MongoDB Charts dashboard to visualize the data in a meaningful way. The application can be further expanded to save other parameters like [PM2.5](https://en.wikipedia.org/wiki/Particulates#Size,_shape_and_solubility_matter) and temperature. 

Now that you've learned how to create an application using the MongoDB C++ driver and MongoDB time series, put your new skills to the test by building your own unique application. Share your creation with the [community](https://www.mongodb.com/community/forums/) and let us know how it turned out!


In this tutorial, we will show you how to build a C++ console application that uses MongoDB to store time series data, related to the Air Quality Index (AQI) for a given location. 

MongoDB Time Series with C++

The PHP team is happy to announce that version [4.2](https://github.com/mongodb/laravel-mongodb/releases/tag/4.2.0) of the [Laravel MongoDB integration](https://github.com/mongodb/laravel-mongodb) is now available!

## Highlights

**Laravel 11 support**

The MongoDB Laravel integration now supports [Laravel 11](https://blog.laravel.com/laravel-11-now-available), ensuring compatibility with the latest framework version and enabling developers to leverage its new features and enhancements. To apply transformation on model attributes, the new recommended way is to declare the [Model::casts](https://laravel.com/docs/11.x/eloquent-mutators#attribute-casting) method.

**Fixed transaction issue with firstOrCreate()**

Previously, using firstOrCreate() in a transaction would result in an error. This problem has been resolved by implementing the underlying Model::createOrFirst() method with the atomic operation [findOneAndUpdate](https://www.mongodb.com/docs/php-library/current/reference/method/MongoDBCollection-findOneAndUpdate).

**Support for whereAll and whereAny**

The library now supports the new methods [whereAll and whereAny](https://laravel.com/docs/10.x/queries#where-any-all-clauses), introduced in Laravel 10.47.

## Installation

This library may be installed or upgraded with:

```
composer require mongodb/laravel-mongodb:4.2.0
```

## Resources

Documentation and other resources to get you started with Laravel and MongoDB databases are shared below:

- [Laravel MongoDB documentation](https://www.mongodb.com/docs/drivers/php/laravel-mongodb/)
- [Quick Start with MongoDB and Laravel](https://www.mongodb.com/docs/drivers/php/laravel-mongodb/current/quick-start/)
- [Release notes](https://github.com/mongodb/laravel-mongodb/releases) 

Give it a try today and let us know what you think! Please report any ideas, bugs, or feedback in the [GitHub repository](https://github.com/mongodb/laravel-mongodb/issues) or the [PHPORM](https://jira.mongodb.org/projects/PHPORM/issues/) Jira project, as we continue to improve and enhance the integration.

Laravel MongoDB 4.2 Released, With Laravel 11 Support

In modern applications, storing and retrieving binary files efficiently is a crucial requirement. MongoDB enables this with binary data type in the [BSON](https://www.mongodb.com/docs/manual/core/document/) which is a binary serialization format used to store documents in MongoDB. A BSON binary value is a byte array and has a subtype (like generic binary subtype, UUID, MD5, etc.) that indicates how to interpret the binary data. See [BSON Types — MongoDB Manual](https://www.mongodb.com/docs/manual/reference/bson-types/#binary-data) for more information.

In this tutorial, we will write a console application in C++, using the [MongoDB C++ driver](https://www.mongodb.com/docs/drivers/cxx/) to upload and download binary data. 

**Note**: 

- When using this method, remember that the BSON document size limit in MongoDB is 16 MB. If your binary files are larger than this limit, consider using [GridFS](https://www.mongodb.com/developer/products/mongodb/storing-large-objects-and-files/) for more efficient handling of large files. See [GridFS example in C++](https://github.com/mongodb/mongo-cxx-driver/blob/master/examples/mongocxx/gridfs.cpp) for reference.
- Developers often weigh the [trade-offs and strategies](https://alexmarquardt.com/2017/03/02/trade-offs-to-consider-when-storing-binary-data-in-mongodb/) when storing binary data in MongoDB. It's essential to ensure that you have also considered different strategies to optimize your data management approach.

## Prerequisites

1. [MongoDB Atlas account](https://www.mongodb.com/developer/products/atlas/free-atlas-cluster/) with a cluster created.
2. IDE (like Microsoft Visual Studio or Microsoft Visual Studio Code) setup with the MongoDB C and C++ Driver installed. Follow the instructions in [Getting Started with MongoDB and C++](https://www.mongodb.com/developer/products/mongodb/getting-started-mongodb-c/) to install MongoDB C/C++ drivers and set up the dev environment in Visual Studio. Installation instructions [for other platforms](https://mongocxx.org/mongocxx-v3/installation/) are available.
3. Compiler with C++17 support (for using `std::filesystem` operations).
4. Your machine’s IP address [whitelisted](https://www.mongodb.com/docs/guides/atlas/network-connections/). Note: You can add *0.0.0.0/0* as the IP address, which should allow access from any machine. This setting is not recommended for production use.

## Building the application

> Source code available [**here**](https://github.com/mongodb-developer/get-started-cxx/blob/main/file-manager/fileManager.cpp).

As part of the [different BSON types](https://mongocxx.org/mongocxx-v3/working-with-bson/#bson-types), the C++ driver provides the [b_binary struct](https://github.com/mongodb/mongo-cxx-driver/blob/master/src/bsoncxx/types.hpp#L222) that can be used for storing binary data value in a BSON document. See the [API reference](http://mongocxx.org/api/current/structbsoncxx_1_1types_1_1b__binary.html).

We start with defining the structure of our BSON document. We have defined three keys: `name`, `path`, and `data`. These contain the name of the file being uploaded, its full path from the disk, and the actual file data respectively. See a sample document below:

![Sample document with binary data.][1]

In the code, these are defined with a `#define` so that it’s easy to modify them from a single place.

### Helper functions

Let’s add a helper function, `upload`, which accepts a file path and a MongoDB collection as inputs. Its primary purpose is to upload the file to the specified MongoDB collection by converting the file into a BSON binary value and constructing a BSON document to represent the file's metadata and content. Here are the key steps within the `upload` function:

1. Open the file at the given path and get its size.
    1. The file's size is determined by moving the file pointer to the end of the file and then retrieving the current position, which corresponds to the file's size.
    2. The file pointer is then reset to the beginning of the file to read the content later.
2. Read File Content into a Buffer: A `std::vector<char>` buffer is created with a size equal to the file's size to hold the file's binary data.
3. Create the BSON binary value.
    1. To represent the file content as BSON binary value, the code creates a `bsoncxx::types::b_binary` object.
    2. The b_binary object includes the binary subtype (set to `bsoncxx::binary_sub_type::k_binary`), the file's size, and data.
4. Create a BSON document with three fields: `name`, `path`, and `data`.
5. Insert the document into the collection.

```cpp
#include <mongocxx/client.hpp>
#include <bsoncxx/builder/basic/document.hpp>
#include <mongocxx/uri.hpp>
#include <mongocxx/instance.hpp>

#include <iostream>
#include <fstream>
#include <vector>
#include <filesystem>

#define FILE_NAME "name"
#define FILE_PATH "path"
#define FILE_DATA "data"

using bsoncxx::builder::basic::kvp; 
using bsoncxx::builder::basic::make_document;

// Upload a file to the collection.
bool upload(const std::string& filePath, mongocxx::collection& collection)
{
    // Open the binary file
    std::ifstream file(filePath, std::ios::binary | std::ios::ate);
    if (!file) 
    {
        std::cout << "Failed to open the file: " << filePath << std::endl;
        return false;
    }

    // Get the file size.
    std::streamsize fileSize = file.tellg();
    file.seekg(0, std::ios::beg);

    // Read the file content into a buffer
    std::vector<char> buffer(fileSize);
    if (!file.read(buffer.data(), fileSize)) 
    {
        std::cout << "Failed to read the file: " << filePath << std::endl;
        return false;
    }

    // Create the binary object for bsoncxx.
    bsoncxx::types::b_binary data{bsoncxx::binary_sub_type::k_binary, static_cast<std::uint32_t>(fileSize), reinterpret_cast<const std::uint8_t*>(buffer.data())};

    // Create a document with the file name and file content.

    auto doc = make_document(
        kvp(FILE_NAME, std::filesystem::path(filePath).filename()),
        kvp(FILE_PATH, filePath),
        kvp(FILE_DATA, data));

    // Insert the document into the collection.
    collection.insert_one(doc.view());

    std::cout << "Upload successful for: " << filePath << std::endl;
    return true;
}
```

Let’s write a similar helper function to perform the download. The code below takes the file name, destination folder, and a MongoDB collection as inputs. This function searches for a file by its name in the specified MongoDB collection, extracts its binary data, and saves it to the specified destination folder. 

Here are the key steps within the `download` function:

1. Create a filter query to find the file.
2. Use the query to find the document in the collection.
3. Extract and save binary data — the binary data is accessed using `bsoncxx::document::view` and then retrieved from the document using `binaryDocView[FILE_DATA].get_binary()`.
4. Create a file in the destination folder and write the binary content into the file.

```cpp
// Download a file from a collection to a given folder.
bool download(const std::string& fileName, const std::string& destinationFolder, mongocxx::collection& collection)
{
    // Create a query to find the file by filename
    auto filter = make_document(kvp(FILE_NAME, fileName));

    // Find the document in the collection
    auto result = collection.find_one(filter.view());

    if (result) 
    {
        // Get the binary data from the document
        bsoncxx::document::view binaryDocView = result->view();
        auto binaryData = binaryDocView[FILE_DATA].get_binary();

        // Create a file to save the binary data
        std::ofstream file(destinationFolder + fileName, std::ios::binary);
        if (!file) 
        {
            std::cout << "Failed to create the file: " << fileName << " at " << destinationFolder << std::endl;
            return false;
        }

        // Write the binary data to the file
        file.write(reinterpret_cast<const char*>(binaryData.bytes), binaryData.size);

        std::cout << "Download successful for: " << fileName << " at " << destinationFolder << std::endl;
        return true;
    } 
    else 
    {
        std::cout << "File not found in the collection: " << fileName << std::endl;
        return false;
    }
}
```

### The main() function

With the helper functions in place to perform upload and download, let’s write the main function that will drive this application. Here are the key steps within the `main` function:

1. Connect to MongoDB: Establish a connection to MongoDB by creating a mongocxx::client instance.

2. Fetch the database (`fileStorage`) and collection (`files`) to store the files.

3. Upload all files found in the specified uploadFolder: Recursively iterate through the folder using `std::filesystem::recursive_directory_iterator`. For each file found, call the upload function to `upload` the file to the MongoDB collection.

4. Download specific files with known filenames (`fileName1` and `fileName2`) by calling `download` function to retrieve and save the files to the `downloadFolder`.

5. Similarly, download all files in the collection by calling `find({})` to get a cursor and iterate through each document in the collection, extracting the file name and then calling `download` function to download and save the file to the `downloadFolder`.

    Note: In a real-world situation, calling `find({})` should be done with some kind of filtering/pagination to avoid issues with memory consumption and performance.

Make sure to [get the connection string](https://www.mongodb.com/docs/guides/atlas/connection-string/) (URI), update it to `mongoURIStr`, and set the different path and filenames to the ones on your disk.

```cpp
int main()
{
    try
    {
        auto mongoURIStr = "<Insert MongoDB Connection String>";
        static const mongocxx::uri mongoURI = mongocxx::uri{ mongoURIStr };
        
        // Create an instance.
        mongocxx::instance inst{};
        
        mongocxx::options::client client_options;
        auto api = mongocxx::options::server_api{ mongocxx::options::server_api::version::k_version_1 };
        client_options.server_api_opts(api);
        mongocxx::client conn{ mongoURI, client_options};
        
        const std::string dbName = "fileStorage";
        const std::string collName = "files";
        
        auto fileStorageDB = conn.database(dbName);
        auto filesCollection = fileStorageDB.collection(collName);
        // Drop previous data.
        filesCollection.drop();

        // Upload all files in the upload folder.
        const std::string uploadFolder = "/Users/bishtr/repos/fileStorage/upload/";
        for (const auto & filePath : std::filesystem::directory_iterator(uploadFolder))
        {
            if(std::filesystem::is_directory(filePath))
                continue;

            if(!upload(filePath.path().string(), filesCollection))
            {
                std::cout << "Upload failed for: " << filePath.path().string() << std::endl;
            }
        }

        // Download files to the download folder.
        const std::string downloadFolder = "/Users/bishtr/repos/fileStorage/download/";
        
        // Search with specific filenames and download it.
        const std::string fileName1 = "image-15.jpg", fileName2 = "Hi Seed Shaker 120bpm On Accents.wav";
        for ( auto fileName : {fileName1, fileName2} )
        {
            if (!download(fileName, downloadFolder, filesCollection))
            {
                std::cout << "Download failed for: " << fileName << std::endl;
            } 
        }
        
        // Download all files in the collection.
        auto cursor = filesCollection.find({});
        for (auto&& doc : cursor) 
        {
            auto fileName = std::string(doc[FILE_NAME].get_string().value);
            if (!download(fileName, downloadFolder, filesCollection))
            {
                std::cout << "Download failed for: " << fileName << std::endl;
            } 
        }
    }
    catch(const std::exception& e)
    {
        std::cout << "Exception encountered: " << e.what() << std::endl;
    }

    return 0;
}
```

## Application in action

Before executing this application, add some files (like images or audios) under the `uploadFolder` directory. 

![Files to be uploaded from local disk to MongoDB.][2]

Execute the application and you’ll observe output like this, signifying that the files are successfully uploaded and downloaded.

![Application output showing successful uploads and downloads.][3]

You can see the collection in [Atlas](https://www.mongodb.com/docs/atlas/atlas-ui/databases/) or [MongoDB Compass](https://www.mongodb.com/products/compass) reflecting the files uploaded via the application.

![Collection with binary data in MongoDB Compass.][4]

You will observe the files getting downloaded into the specified `downloadFolder` directory.

![Files downloaded from MongoDB to local disk.][5]

## Conclusion

With this article, we covered storing and retrieving binary data from a MongoDB database, using the MongoDB C++ driver. MongoDB's robust capabilities, combined with the ease of use provided by the [C++ driver](https://www.mongodb.com/docs/drivers/cxx/), offer a powerful solution for handling file storage in C++ applications. We can't wait to see what you build next! Share your creation with the [community](https://www.mongodb.com/community/forums/) and let us know how it turned out!


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt24f4df95c9cee69a/6504c0fd9bcd1b134c1d0e4b/image1.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt7c530c1eb76f566c/6504c12df4133500cb89250f/image3.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt768d2c8c6308391e/6504c153b863d9672da79f4c/image5.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt8c199ec2272f2c4f/6504c169a8cf8b4b4a3e1787/image2.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt78bb48b832d91de2/6504c17fec9337ab51ec845e/image4.png

Learn how to store binary data to MongoDB using the C++ driver.

Storing Binary Data with MongoDB and C++

This article will show you how to utilize Microsoft Visual Studio to compile and install the [MongoDB C](https://www.mongodb.com/docs/drivers/c/) and [C++ drivers](https://www.mongodb.com/docs/drivers/cxx/) on Windows, and use these drivers to create a console application that can interact with your MongoDB data by performing basic [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) operations.

Tools and libraries used in this tutorial:

1. Microsoft Windows 11
2. Microsoft Visual Studio 2022 17.3.6
3. Language standard: C++17
4. MongoDB C Driver version: 1.23
5. MongoDB C++ Driver version: 3.7.0
6. boost: 1.80.0
7. Python: 3.10
8. CMake: 3.25.0

## Prerequisites

1. [MongoDB Atlas account](https://www.mongodb.com/developer/products/atlas/free-atlas-cluster/) with a cluster created.
2. *(Optional)* [Sample dataset](https://www.mongodb.com/developer/products/atlas/atlas-sample-datasets/) loaded into the Atlas cluster.
3. Your machine’s IP address is [whitelisted](https://www.mongodb.com/docs/guides/atlas/network-connections/). Note: You can add *0.0.0.0/0* as the IP address, which should allow access from any machine. This setting is not recommended for production use.

## Installation: IDE and tools

Step 1: Install Visual Studio: [Download Visual Studio Tools - Install Free for Windows, Mac, Linux](https://visualstudio.microsoft.com/downloads/).

In the Workloads tab during installation, select “Desktop development with C++.”

![Microsoft Visual Studio installation](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/microsoft_visual_studio_installation_4e60668543.png)

Step 2: Install CMake: [Download \| CMake](https://cmake.org/download/)

* For simplicity, choose the installer.
* In the setup, make sure to select “Add CMake to the system PATH for all users.” This enables the CMake executable to be easily accessible.

![Install options for CMake](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/install_options_for_cmake_37b887a6fb.png)

Step 3: Install Python 3: [Download Python](https://www.python.org/downloads/).

Step 4: *(Optional)* Download boost library from [Boost Downloads](https://www.boost.org/users/download/) and extract it to *C:\boost*.

## Installation: Drivers

> Detailed instructions and configurations available here:
> 
> 
> * [Installing the mongocxx driver](https://mongocxx.org/mongocxx-v3/installation/)
> * [Installing the MongoDB C Driver (libmongoc) and BSON library (libbson)](http://mongoc.org/libmongoc/current/installing.html)

### Step 1: Install C Driver

C++ Driver has a dependency on C driver. Hence, we need to install C Driver first.

* Download C Driver
    * Check compatibility at [Windows - Installing the mongocxx driver](https://mongocxx.org/mongocxx-v3/installation/windows/) for the driver to download.
    * Download release tarball — [Releases · mongodb/mongo-c-driver](https://github.com/mongodb/mongo-c-driver/releases) — and extract it to *C:\Repos\mongo-c-driver-1.23.0*.
* Setup build via CMake
    * Launch powershell/terminal as an administrator.
    * Navigate to *C:\Repos\mongo-c-driver-1.23.0* and create a new folder named *cmake-build* for the build files.
    * Navigate to *C: \Repos\mongo-c-driver-1.23.0\cmake-build*.
    * Run the below command to configure and generate build files using CMake. 
    
```
cmake -G "Visual Studio 17 2022" -A x64 -S "C:\Repos\mongo-c-driver-1.23.0" -B "C:\Repos\mongo-c-driver-1.23.0\cmake-build"
```

![Setting up MongoDB C driver build via CMake and Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/setting_up_mongodb_0ac90dc0aa.png)

Note: Build setup can be done with the CMake GUI application, as well.
* Execute build
    * Visual Studio’s default build type is Debug. A release build with debug info is recommended for production use.
    * Run the below command to build and install the driver

```
cmake --build . --config RelWithDebInfo --target install
```

![Building MongoDB C driver via CMake and Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/building_mongodb_c_driver_229ac4305d.png)

* You should now see libmongoc and libbson installed in *C:/Program Files/mongo-c-driver*.

![Building MongoDB C driver via CMake and Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/building_driver_via_cmake_125384ad15.png)

* Move the *mongo-c-driver* to *C:/* for convenience. Hence, C Driver should now be present at *C:/mongo-c-driver*.

### Step 2: Install C++ Driver

* Download C++ Driver
    * Download release tarball — [Releases · mongodb/mongo-cxx-driver](https://github.com/mongodb/mongo-cxx-driver/releases) — and extract it to *C:\Repos\mongo-cxx-driver-r3.7.0*.
* Set up build via CMake
    * Launch powershell/terminal as an administrator.
    * Navigate to *C:\Repos\mongo-cxx-driver-r3.7.0\build*.
    * Run the below command to generate and configure build files via CMake.

```
cmake .. -G "Visual Studio 17 2022" -A x64 -DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_FLAGS="/Zc:__cplusplus /EHsc" -DCMAKE_PREFIX_PATH=C:\mongo-c-driver -DCMAKE_INSTALL_PREFIX=C:\mongo-cxx-driver
```

![Setting up MongoDB C++ driver build via CMake and Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/setting_up_mongodb_driver_81d2b9aa2d.png)

Note: Setting *DCMAKE_CXX_FLAGS* should not be required for C++ driver version 3.7.1 and above.

* Execute build
    * Run the below command to build and install the driver
    
```
cmake --build . --config RelWithDebInfo --target install
```

* You should now see C++ driver installed in *C:\mongo-cxx-driver*.

## Visual Studio: Setting up the dev environment

* Create a new project in Visual Studio.
* Select *Console App* in the templates.

![New project options in Microsoft Visual Studio](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/create_new_project_7c956cf247.png)

* Visual Studio should create a new project and open a .cpp file which prints “Hello World.” Navigate to the Solution Explorer panel, right-click on the solution name (*MongoCXXGettingStarted*, in this case), and click Properties.

![Microsoft Visual Studio solution properties](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/solution_properties_af0de46243.png)

* Go to *Configuration Properties > C/C++ > General > Additional Include Directories* and add the include directories from the C and C++ driver installation folders, as shown below.

![Microsoft Visual Studio include directories](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/include_directories_da1b8bf333.png)

* Go to *Configuration Properties > C/C++ > Language* and change the *C++ Language Standard* to C++17.

![Microsoft Visual Studio C++ language standard](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/language_standard_7bceb02aac.png)

* Go to *Configuration Properties > C/C++ > Command Line* and add */Zc:\_\_cplusplus* in the *Additional Options* field. This flag is needed to opt into the [correct definition of \_\_cplusplus](https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/).
* Go to *Configuration Properties > Linker > Input* and add the driver libs in *Additional Dependencies* section, as shown below.

![Microsoft Visual Studio linker dependencies](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/linker_dependencies_26269dcc28.png)

* Go to *Configuration Properties > Debugging > Environment* to add a path to the driver executables, as shown below.

![Microsoft Visual Studio debugging environment](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/debugging_environment_6de4cc98b8.png)

## Building the console application

> Source available [here](https://github.com/mongodb-developer/get-started-cxx/blob/main/student-records-console-app/studentRecordsConsoleApp.cpp)

Let’s build an application that maintains student records. We will input student data from the user, save them in the database, and perform different CRUD operations on the database.

### Connecting to the database

Let’s start with a simple program to connect to the MongoDB Atlas cluster and access the databases. [Get the connection string](https://www.mongodb.com/docs/guides/atlas/connection-string/) (URI) to the cluster and create a new environment variable with key as *“MONGODB\_URI”* and value as the connection string (URI). It’s a good practice to keep the connection string decoupled from the code.

Tip: Restart your machine after creating the environment variable in case the *“getEnvironmentVariable”* function fails to retrieve the environment variable.

```
#include <mongocxx/client.hpp>
#include <bsoncxx/builder/stream/document.hpp>
#include <bsoncxx/json.hpp>
#include <mongocxx/uri.hpp>
#include <mongocxx/instance.hpp>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
std::string getEnvironmentVariable(std::string environmentVarKey)
{
	char* pBuffer = nullptr;
	size_t size = 0;
	auto key = environmentVarKey.c_str();
	// Use the secure version of getenv, ie. _dupenv_s to fetch environment variable.
	if (_dupenv_s(&pBuffer, &size, key) == 0 && pBuffer != nullptr)
	{
		std::string environmentVarValue(pBuffer);
		free(pBuffer);
		return environmentVarValue;
	}
	else
	{
		return "";
	}
}
auto mongoURIStr = getEnvironmentVariable("MONGODB_URI");
static const mongocxx::uri mongoURI = mongocxx::uri{ mongoURIStr };
// Get all the databases from a given client.
vector<string> getDatabases(mongocxx::client& client)
{
	return client.list_database_names();
}
int main()
{
    // Create an instance.
    mongocxx::instance inst{};
    mongocxx::options::client client_options;
    auto api = mongocxx::options::server_api{ mongocxx::options::server_api::version::k_version_1 };
    client_options.server_api_opts(api);
    mongocxx::client conn{ mongoURI, client_options}
     auto dbs = getDatabases(conn);
     for (auto db : dbs)
     {
         cout << db << endl;
      }
      return 0;
}
```

Click on “Launch Debugger” to launch the console application. The output should looks something like this:

![Microsoft Visual Studio debug console](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/debug_console_9e7e46dd0e.png)

### CRUD operations

> [Full tutorial](https://mongocxx.org/mongocxx-v3/tutorial/)

Since the database is successfully connected to our application, let’s write some helper functions to interact with the database, performing CRUD operations.

#### Create

```
// Create a new collection in the given database.
void createCollection(mongocxx::database& db, const string& collectionName)
{
	db.create_collection(collectionName);
}
// Create a document from the given key-value pairs.
bsoncxx::document::value createDocument(const vector<pair<string, string>>& keyValues)
{
	bsoncxx::builder::stream::document document{};
	for (auto& keyValue : keyValues)
	{
		document << keyValue.first << keyValue.second;
	}
	return document << bsoncxx::builder::stream::finalize;
}
// Insert a document into the given collection.
void insertDocument(mongocxx::collection& collection, const bsoncxx::document::value& document)
{
	collection.insert_one(document.view());
}
```

#### Read

```
// Print the contents of the given collection.
void printCollection(mongocxx::collection& collection)
{
	// Check if collection is empty.
	if (collection.count_documents({}) == 0)
	{
		cout << "Collection is empty." << endl;
		return;
	}
	auto cursor = collection.find({});
	for (auto&& doc : cursor)
	{
		cout << bsoncxx::to_json(doc) << endl;
	}
}
// Find the document with given key-value pair.
void findDocument(mongocxx::collection& collection, const string& key, const string& value)
{
	// Create the query filter
	auto filter = bsoncxx::builder::stream::document{} << key << value << bsoncxx::builder::stream::finalize;
	//Add query filter argument in find
	auto cursor = collection.find({ filter });
	for (auto&& doc : cursor)
	{
          cout << bsoncxx::to_json(doc) << endl;
	}
}
```

#### Update

```
// Update the document with given key-value pair.
void updateDocument(mongocxx::collection& collection, const string& key, const string& value, const string& newKey, const string& newValue)
{
	collection.update_one(bsoncxx::builder::stream::document{} << key << value << bsoncxx::builder::stream::finalize,
		bsoncxx::builder::stream::document{} << "$set" << bsoncxx::builder::stream::open_document << newKey << newValue << bsoncxx::builder::stream::close_document << bsoncxx::builder::stream::finalize);
}
```

#### Delete

```
// Delete a document from a given collection.
void deleteDocument(mongocxx::collection& collection, const bsoncxx::document::value& document)
{
	collection.delete_one(document.view());
}
```

### The main() function

With all the helper functions in place, let’s create a menu in the main function which we can use to interact with the application.

```
// ********************************************** I/O Methods **********************************************
// Input student record.
void inputStudentRecord(mongocxx::collection& collection)
{
	string name, rollNo, branch, year;
	cout << "Enter name: ";
	cin >> name;
	cout << "Enter roll number: ";
	cin >> rollNo;
	cout << "Enter branch: ";
	cin >> branch;
	cout << "Enter year: ";
	cin >> year;
	insertDocument(collection, createDocument({ {"name", name}, {"rollNo", rollNo}, {"branch", branch}, {"year", year} }));
}
// Update student record.
void updateStudentRecord(mongocxx::collection& collection)
{
	string rollNo, newBranch, newYear;
	cout << "Enter roll number: ";
	cin >> rollNo;
	cout << "Enter new branch: ";
	cin >> newBranch;
	cout << "Enter new year: ";
	cin >> newYear;
	updateDocument(collection, "rollNo", rollNo, "branch", newBranch);
	updateDocument(collection, "rollNo", rollNo, "year", newYear);
}
// Find student record.
void findStudentRecord(mongocxx::collection& collection)
{
	string rollNo;
	cout << "Enter roll number: ";
	cin >> rollNo;
	findDocument(collection, "rollNo", rollNo);
}
// Delete student record.
void deleteStudentRecord(mongocxx::collection& collection)
{
	string rollNo;
	cout << "Enter roll number: ";
	cin >> rollNo;
	deleteDocument(collection, createDocument({ {"rollNo", rollNo} }));
}
// Print student records.
void printStudentRecords(mongocxx::collection& collection)
{
	printCollection(collection);
}
// ********************************************** Main **********************************************
int main()
{
     if(mongoURI.to_string().empty())
    {
	cout << "URI is empty";
	return 0;
    }
    // Create an instance.
    mongocxx::instance inst{};
    mongocxx::options::client client_options;
    auto api = mongocxx::options::server_api{ mongocxx::options::server_api::version::k_version_1 };
    client_options.server_api_opts(api);
    mongocxx::client conn{ mongoURI, client_options};
	const string dbName = "StudentRecords";
	const string collName = "StudentCollection";
	auto dbs = getDatabases(conn);
	// Check if database already exists.
	if (!(std::find(dbs.begin(), dbs.end(), dbName) != dbs.end()))
	{
		// Create a new database & collection for students.
conn[dbName];
	}
	auto studentDB = conn.database(dbName);
	auto allCollections = studentDB.list_collection_names();
	// Check if collection already exists.
	if (!(std::find(allCollections.begin(), allCollections.end(), collName) != allCollections.end()))
	{
		createCollection(studentDB, collName);
	}
	auto studentCollection = studentDB.collection(collName);
	// Create a menu for user interaction
	 int choice = -1;
	 do while (choice != 0)
	 {
		 //system("cls");
		 cout << endl << "**************************************************************************************************************" << endl;
		 cout << "Enter 1 to input student record" << endl;
		 cout << "Enter 2 to update student record" << endl;
		 cout << "Enter 3 to find student record" << endl;
		 cout << "Enter 4 to delete student record" << endl;
		 cout << "Enter 5 to print all student records" << endl;
		 cout << "Enter 0 to exit" << endl;
		 cout << "Enter Choice : "; 
		 cin >> choice;
		 cout << endl;
		 switch (choice)
		 {
		 case 1:
			 inputStudentRecord(studentCollection);
			 break;
		 case 2:
			 updateStudentRecord(studentCollection);
			 break;
		 case 3:
			 findStudentRecord(studentCollection);
			 break;
		 case 4:
			 deleteStudentRecord(studentCollection);
			 break;
		 case 5:
			 printStudentRecords(studentCollection);
			 break;
		 case 0:
			 break;
		 default:
			 cout << "Invalid choice" << endl;
			 break;
		 }
	 } while (choice != 0);
	 return 0;
}
```

## Application in action

When this application is executed, you can manage the student records via the console interface. Here’s a demo:

:youtube[]{vid=JsHdysx8yyw}

You can also see the collection in Atlas reflecting any change made via the console application.

![Student Records collection in Atlas](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/student_records_collection_atlas_f120e465fe.png)

## Wrapping up
With this article, we covered installation of C/C++ driver and creating a console application in Visual Studio that connects to MongoDB Atlas to perform basic CRUD operations.

More information about the C++ driver is available at [MongoDB C++ Driver](https://www.mongodb.com/docs/drivers/cxx/). 

This article will show you how to utilize Microsoft Visual Studio to compile and install the MongoDB C and C++ drivers on Windows, and use these drivers to create a console application that can interact with your MongoDB data.

Rishabh Bisht

Content by Rishabh Bisht

MongoDB Time Series with C++

Laravel MongoDB 4.2 Released, With Laravel 11 Support

Storing Binary Data with MongoDB and C++

Getting Started with MongoDB and C++