Armazenar dados binários com MongoDB e C++

Rishabh Bisht6 min read • Published Sep 18, 2023 • Updated Sep 18, 2023

C++Atlas

Avalie esse Tutorial

Em aplicativos modernos, armazenar e recuperar arquivos binários de forma eficiente é um requisito crucial. O MongoDB permite isso com tipo de dados binários no BSON, que é um formato de serialização binária usado para armazenar documentos no MongoDB. Um valor binário BSON é uma array de bytes e tem um subtipo (como subtipo binário genérico, UUID, MD5 etc.) que indica como interpretar os dados binários. Consulte BSON types — MongoDB Manual para obter mais informações.

Neste tutorial, escreveremos um aplicativo de console em C++, usando o driver MongoDB C++ para carregar e baixar dados binários.

Observação:

Ao usar este método, lembre-se que o limite de tamanho do documento BSON no MongoDB é 16 MB. Se seus arquivos binários forem maiores que esse limite, considere usar o GridFS para um tratamento mais eficiente de arquivos grandes. Consulte o exemplo do GridFS em C++ para referência.
Os desenvolvedores costumam avaliar as vantagens e desvantagens ao armazenar dados binários no MongoDB. É essencial garantir que você também considerou diferentes estratégias para otimizar sua abordagem de gerenciamento de dados.

Pré-requisitos

Conta do MongoDB Atlas com um cluster criado.
Configuração IDE (como o Microsoft Visual Studio ou o Microsoft Visual Studio Code) com o driver MongoDB C e C++ instalado. Siga as instruções em Introdução ao MongoDB e C++ para instalar os drivers do MongoDB C/C++ e configurar o ambiente de desenvolvimento no Visual Studio. Instruções de instalação para outras plataformas estão disponíveis.
Compilador com suporte a C++17 (para usar operaçõesstd::filesystem ).
O endereço IP da sua máquina está na lista de permissões. Nota: Você pode adicionar 0.0.0.0/0 como o endereço IP, que deve permitir o acesso de qualquer máquina. Essa configuração não é recomendada para uso em produção.

Criando o aplicativo

Código fonte disponível aqui.

Como parte dos BSON types, o driver C++ fornece a estrutura b_binary que pode ser usada para armazenar valor de dados binários em um documento BSON. Consulte a API.

Começamos definindo a estrutura do nosso documento BSON. Definimos três chaves: name, pathe data. Eles contêm o nome do arquivo que está sendo carregado, seu caminho completo do disco e os dados reais do arquivo, respectivamente. Veja um documento de exemplo abaixo:

No código, eles são definidos com um #define para que seja fácil modificá-los a partir de um único local.

Funções auxiliares

Vamos adicionar uma função auxiliar, upload, que aceita um caminho de arquivo e uma coleção MongoDB como entradas. Seu objetivo principal é carregar o arquivo na coleção MongoDB especificada convertendo o arquivo em um valor binário BSON e construindo um documento BSON para representar os metadados e o conteúdo do arquivo. Aqui estão as principais etapas dentro da funçãoupload:

Abra o arquivo no caminho fornecido e obtenha seu tamanho.
1. O tamanho do arquivo é determinado movendo o ponteiro do arquivo para o final do arquivo e, em seguida, recuperando a posição atual, que corresponde ao tamanho do arquivo.
2. O ponteiro do arquivo é então redefinido para o início do arquivo para ler o conteúdo posteriormente.
Ler conteúdo do arquivo em um buffer: um buffer std::vector<char> é criado com um tamanho igual ao tamanho do arquivo para manter os dados binários do arquivo.
Crie o valor binário BSON.
1. Para representar o conteúdo do arquivo como valor binário BSON, o código cria um objetobsoncxx::types::b_binary .
2. O objeto b_binary inclui o subtipo binário (definido como bsoncxx::binary_sub_type::k_binary), o tamanho do arquivo e os dados.
Crie um documento BSON com três campos: name, pathe data.
Inserir o documento na coleção.

Trecho de código

#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;
}

Vamos escrever uma função auxiliar semelhante para executar o download. O código abaixo usa o nome do arquivo, a pasta de destino e uma coleção MongoDB como entradas. Esta função procura um arquivo por seu nome na coleção MongoDB especificada, extrai seus dados binários e os salva na pasta de destino especificada.

Aqui estão as principais etapas da funçãodownload:

Crie uma consulta de filtro para encontrar o arquivo.
Use a consulta para encontrar o documento na coleção.
Extrair e salvar dados binários — os dados binários são acessados usando bsoncxx::document::view e, em seguida, recuperados do documento usando binaryDocView[FILE_DATA].get_binary().
Crie um arquivo na pasta de destino e grave o conteúdo binário no arquivo.

Trecho de código

// 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;
    }
}

A função main()

Com as funções auxiliares em vigor para realizar upload e download, vamos escrever a função principal que executará esse aplicativo. Aqui estão as principais etapas dentro da funçãomain:

Conecte-se ao MongoDB: Estabeleça uma conexão com o MongoDB criando uma instância mongocxx::client.
Obtenha o banco de dados (fileStorage) e a collection (files) para armazenar os arquivos.
Carregar todos os arquivos encontrados na uploadFolder especificada: iterar recursivamente pela pasta usando std::filesystem::recursive_directory_iterator. Para cada arquivo encontrado, chame a função de upload para upload o arquivo na coleção MongoDB.
Faça o download de arquivos específicos com nomes de arquivos conhecidos (fileName1 e fileName2) chamando a funçãodownload para recuperar e salvar os arquivos no downloadFolder.
Da mesma forma, baixe todos os arquivos na coleção chamando find({}) para obter um cursor e iterar por cada documento na coleção, extraindo o nome do arquivo e, em seguida, chamando a funçãodownload para baixar e salvar o arquivo no downloadFolder.
Observação: em uma situação do mundo real, a chamada find({}) deve ser feita com algum tipo de filtragem/paginação para evitar problemas com o consumo de memória e o desempenho.

Certifique-se de obter a string de conexão (URI), atualizá-la para mongoURIStr e definir o caminho e os nomes de arquivo diferentes para os que estão em seu disco.

Trecho de código

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;
}

Aplicativo em ação

Antes de executar este aplicativo, adicione alguns arquivos (como imagens ou áudios) no diretóriouploadFolder .

Execute o aplicativo e você observará uma saída como esta, significando que os arquivos foram carregados e baixados com êxito.

Você pode ver a coleção no Atlas ou MongoDB Compass refletindo os arquivos carregados por meio do aplicativo.

Você observará os arquivos sendo baixados no diretóriodownloadFolderespecificado.

Conclusão

Com este artigo, abordamos o armazenamento e a recuperação de dados binários de um MongoDB database, usando o MongoDB C++ driver. Os recursos robustos do MongoDB, combinados com a facilidade de uso fornecida pelo C++ driver, oferecem uma solução poderosa para lidar com o armazenamento de arquivos em aplicativos C++. Nós mal podemos esperar para ver o que você construirá a seguir! Compartilhe sua criação com a comunidade e conte para nós como ficou!

Avalie esse Tutorial

Relacionado

Tutorial

Impulsionando a IA: construa um chatbot sobre seus dados com o MongoDB Atlas Vector Search e os modelos LangChain usando o padrão RAG

Sep 18, 2024 | 7 min read

Artigo

Colocando o RAG em produção com o chatbot de IA da documentação do MongoDB

Aug 29, 2024 | 11 min read

Tutorial

Migrar do Azure CosmosDB para o MongoDB Atlas usando o Apache Kafka

May 09, 2022 | 3 min read

Tutorial

Consulta flexível com Atlas Search

Jul 12, 2024 | 3 min read