Tutorial

Este guia oferece uma breve introdução ao Driver MongoDB C.

Para obter mais informações sobre a C,API consulte API a.

Instalando

Para obter instruções detalhadas sobre como instalar o driver MongoDB C em uma plataforma específica, consulte oguia de instalação .

Iniciando o MongoDB

Para executar os exemplos neste tutorial, o MongoDB deve estar instalado e em execução no localhost na porta padrão, 27017. Para verificar se está instalado e funcionando, conecte-se a ele com o shell do MongoDB.

$ mongosh --host localhost --port 27017 --quiet
Enterprise rs0 [direct: primary] test> db.version()
7.0.0
>

Inclua e vincule a libmongoc em seu programa C

Incluir mongoc.h

Todas as funções e tipos de libmongoc estão disponíveis em um arquivo de cabeçalho. Basta incluir mongoc/mongoc.h:

#include <mongoc/mongoc.h>

CCriar

A instalação da libmongoc inclui um pacote de arquivo de configuração CMake, para que você possa usar o find_package do CMake comando para importar o destino CMake do libmongoc e vincular para libmongoc (como uma biblioteca compartilhada):

CMakeLists.txt

# Specify the minimum version you require.
find_package (mongoc-1.0 1.7 REQUIRED)
# The "hello_mongoc.c" sample program is shared among four tests.
add_executable (hello_mongoc ../../hello_mongoc.c)
target_link_libraries (hello_mongoc PRIVATE mongo::mongoc_shared)

Você também pode usar libmongoc como uma biblioteca estática: use o destino CMake mongo::mongoc_static :

# Specify the minimum version you require.
find_package (mongoc-1.0 1.7 REQUIRED)
# The "hello_mongoc.c" sample program is shared among four tests.
add_executable (hello_mongoc ../../hello_mongoc.c)
target_link_libraries (hello_mongoc PRIVATE mongo::mongoc_static)

pacote-config

Se você não estiver usando o CMake, use pkg-config na linha de comando para definir os caminhos do cabeçalho e da biblioteca:

gcc -o hello_mongoc hello_mongoc.c $(pkg-config --libs --cflags libmongoc-1.0)

Ou para vincular estaticamente à libmongoc:

gcc -o hello_mongoc hello_mongoc.c $(pkg-config --libs --cflags libmongoc-static-1.0)

Especificando cabeçalho e incluindo caminhos manualmente

Se você não estiver usando o CMake ou o pkg-config, os caminhos e as bibliotecas poderão ser gerenciados manualmente.

$ gcc -o hello_mongoc hello_mongoc.c \
    -I/usr/local/include/libbson-1.0 -I/usr/local/include/libmongoc-1.0 \
    -lmongoc-1.0 -lbson-1.0
$ ./hello_mongoc
{ "ok" : 1.000000 }

Para usuários do Windows, o código pode ser compilado e executado com os seguintes comandos. (Isto pressupõe que o MongoDB C Driver tenha sido instalado no C:\mongo-c-driver; altere o diretório de inclusão conforme necessário.)

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 hello_mongoc.c
C:\> hello_mongoc
{ "ok" : 1.000000 }

Usar libmongoc em um projeto do Microsoft Visual Studio

Consulte o guia libmongoc e Visual Studio.

Estabelecendo uma conexão

Acessar o MongoDB com um mongoc_client_t. Ele se conecta transparentemente a servidores autônomo , conjuntos de réplicas e clusters fragmentados sob demanda. Para executar operações em um banco de dados de dados ou collection, crie um mongoc_database_t ou mongoc_collection_t estrutura do mongoc_client_t.

No início de um aplicação, chame mongoc_init antes de quaisquer outras funções da libmongoc. No final, chame a função de destruição apropriada para cada coleção, banco de dados de dados ou identificador de cliente , na ordem inversa de como foram construídos. Ligue para mongoc_cleanup antes de sair.

O exemplo abaixo estabelece uma conexão com um servidor standalone no localhost, registra o aplicativo cliente como "connect-example" e executa um comando simples.

Mais informações sobre operações de banco de dados podem ser encontradas nas seções Operações CRUD e Execução de comandos . Exemplos de conexão a conjuntos de réplicas e clusters fragmentados podem ser encontrados na página Conexões avançadas , enquanto exemplos de compactação de dados podem ser encontrados na página Compressão de dados .

hello_mongoc.c

#include <mongoc/mongoc.h>
int
main (int argc, char *argv[])
{
   const char *uri_string = "mongodb://localhost:27017";
   mongoc_uri_t *uri;
   mongoc_client_t *client;
   mongoc_database_t *database;
   mongoc_collection_t *collection;
   bson_t *command, reply, *insert;
   bson_error_t error;
   char *str;
   bool retval;
   /*
    * Required to initialize libmongoc's internals
    */
   mongoc_init ();
   /*
    * Optionally get MongoDB URI from command line
    */
   if (argc > 1) {
      uri_string = argv[1];
   }
   /*
    * Safely create a MongoDB URI object from the given string
    */
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   /*
    * Create a new client instance
    */
   client = mongoc_client_new_from_uri (uri);
   if (!client) {
      return EXIT_FAILURE;
   }
   /*
    * Register the application name so we can track it in the profile logs
    * on the server. This can also be done from the URI (see other examples).
    */
   mongoc_client_set_appname (client, "connect-example");
   /*
    * Get a handle on the database "db_name" and collection "coll_name"
    */
   database = mongoc_client_get_database (client, "db_name");
   collection = mongoc_client_get_collection (client, "db_name", "coll_name");
   /*
    * Do work. This example pings the database, prints the result as JSON and
    * performs an insert
    */
   command = BCON_NEW ("ping", BCON_INT32 (1));
   retval = mongoc_client_command_simple (client, "admin", command, NULL, &reply, &error);
   if (!retval) {
      fprintf (stderr, "%s\n", error.message);
      return EXIT_FAILURE;
   }
   str = bson_as_json (&reply, NULL);
   printf ("%s\n", str);
   insert = BCON_NEW ("hello", BCON_UTF8 ("world"));
   if (!mongoc_collection_insert_one (collection, insert, NULL, NULL, &error)) {
      fprintf (stderr, "%s\n", error.message);
   }
   bson_destroy (insert);
   bson_destroy (&reply);
   bson_destroy (command);
   bson_free (str);
   /*
    * Release our handles and clean up libmongoc
    */
   mongoc_collection_destroy (collection);
   mongoc_database_destroy (database);
   mongoc_uri_destroy (uri);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

Criando documentos BSON

Os documentos são armazenados no formato de dados do MongoDB, BSON. O driver C usa o libbson para criar documentos BSON. Existem várias maneiras de construí-los: anexando pares de valores-chave, usando BCON ou analisando JSON.

Anexando BSON

Um documento BSON , representado como um bson_t em código, pode ser construído um campo de cada vez usando as funções append da libbson.

Por exemplo, para criar um documento como este:

{
   born : ISODate("1906-12-09"),
   died : ISODate("1992-01-01"),
   name : {
      first : "Grace",
      last : "Hopper"
   },
   languages : [ "MATH-MATIC", "FLOW-MATIC", "COBOL" ],
   degrees: [ { degree: "BA", school: "Vassar" }, { degree: "PhD", school: "Yale" } ]
}

Use o seguinte código:

#include <bson/bson.h>
int
main (void)
{
   struct tm born = {0};
   struct tm died = {0};
   const char *lang_names[] = {"MATH-MATIC", "FLOW-MATIC", "COBOL"};
   const char *schools[] = {"Vassar", "Yale"};
   const char *degrees[] = {"BA", "PhD"};
   uint32_t i;
   bson_t *document;
   bson_t child;
   bson_array_builder_t *bab;
   char *str;
   document = bson_new ();
   /*
    * Append { "born" : ISODate("1906-12-09") } to the document.
    * Passing -1 for the length argument tells libbson to calculate the
    * string length.
    */
   born.tm_year = 6; /* years are 1900-based */
   born.tm_mon = 11; /* months are 0-based */
   born.tm_mday = 9;
   bson_append_date_time (document, "born", -1, mktime (&born) * 1000);
   /*
    * Append { "died" : ISODate("1992-01-01") } to the document.
    */
   died.tm_year = 92;
   died.tm_mon = 0;
   died.tm_mday = 1;
   /*
    * For convenience, this macro passes length -1 by default.
    */
   BSON_APPEND_DATE_TIME (document, "died", mktime (&died) * 1000);
   /*
    * Append a subdocument.
    */
   BSON_APPEND_DOCUMENT_BEGIN (document, "name", &child);
   BSON_APPEND_UTF8 (&child, "first", "Grace");
   BSON_APPEND_UTF8 (&child, "last", "Hopper");
   bson_append_document_end (document, &child);
   /*
    * Append array of strings. Generate keys "0", "1", "2".
    */
   BSON_APPEND_ARRAY_BUILDER_BEGIN (document, "languages", &bab);
   for (i = 0; i < sizeof lang_names / sizeof (char *); ++i) {
      bson_array_builder_append_utf8 (bab, lang_names[i], -1);
   }
   bson_append_array_builder_end (document, bab);
   /*
    * Array of subdocuments:
    *    degrees: [ { degree: "BA", school: "Vassar" }, ... ]
    */
   BSON_APPEND_ARRAY_BUILDER_BEGIN (document, "degrees", &bab);
   for (i = 0; i < sizeof degrees / sizeof (char *); ++i) {
      bson_array_builder_append_document_begin (bab, &child);
      BSON_APPEND_UTF8 (&child, "degree", degrees[i]);
      BSON_APPEND_UTF8 (&child, "school", schools[i]);
      bson_array_builder_append_document_end (bab, &child);
   }
   bson_append_array_builder_end (document, bab);
   /*
    * Print the document as a JSON string.
    */
   str = bson_as_canonical_extended_json (document, NULL);
   printf ("%s\n", str);
   bson_free (str);
   /*
    * Clean up allocated bson documents.
    */
   bson_destroy (document);
   return 0;
}

Consulte a documentação da libbson para todos os tipos que podem ser anexados a um bson_t.

Usando BCON

BSON C Object Notation, BCON para abreviar, é uma maneira alternativa de construir documentos BSON de uma maneira mais próxima do formato pretendido. Tem menos segurança de tipo do que as funções de anexação do BSON, mas resulta em menos código.

#include <bson/bson.h>
int
main (int   argc,
      char *argv[])
{
   struct tm born = { 0 };
   struct tm died = { 0 };
   bson_t   *document;
   char     *str;
   born.tm_year = 6;
   born.tm_mon = 11;
   born.tm_mday = 9;
   died.tm_year = 92;
   died.tm_mon = 0;
   died.tm_mday = 1;
   document = BCON_NEW (
      "born", BCON_DATE_TIME (mktime (&born) * 1000),
      "died", BCON_DATE_TIME (mktime (&died) * 1000),
      "name", "{",
      "first", BCON_UTF8 ("Grace"),
      "last", BCON_UTF8 ("Hopper"),
      "}",
      "languages", "[",
      BCON_UTF8 ("MATH-MATIC"),
      BCON_UTF8 ("FLOW-MATIC"),
      BCON_UTF8 ("COBOL"),
      "]",
      "degrees", "[",
      "{", "degree", BCON_UTF8 ("BA"), "school", BCON_UTF8 ("Vassar"), "}",
      "{", "degree", BCON_UTF8 ("PhD"), "school", BCON_UTF8 ("Yale"), "}",
      "]");
   /*
    * Print the document as a JSON string.
    */
   str = bson_as_canonical_extended_json (document, NULL);
   printf ("%s\n", str);
   bson_free (str);
   /*
    * Clean up allocated bson documents.
    */
   bson_destroy (document);
   return 0;
}

Observe que o BCON pode criar arrays, subdocumentos e campos arbitrários.

Criando BSON a partir de JSON

Para documentos únicos , o BSON pode ser criado a partir de strings JSON via bson_new_from_json.

#include <bson/bson.h>
int
main (int   argc,
      char *argv[])
{
   bson_error_t error;
   bson_t      *bson;
   char        *string;
   const char *json = "{\"name\": {\"first\":\"Grace\", \"last\":\"Hopper\"}}";
   bson = bson_new_from_json ((const uint8_t *)json, -1, &error);
   if (!bson) {
      fprintf (stderr, "%s\n", error.message);
      return EXIT_FAILURE;
   }
   string = bson_as_canonical_extended_json (bson, NULL);
   printf ("%s\n", string);
   bson_free (string);
   return 0;
}

Para inicializar BSON a partir de uma sequência de documentos JSON, utilize bson_json_reader_t.

Operações CRUD básicas

Esta seção demonstra as noções básicas de uso do C Driver para interagir com o MongoDB.

Inserindo um documento

Para inserir documentos em uma coleção, primeiro obtenha um identificador para mongoc_collection_t por meio de um mongoc_client_t. Em seguida, use mongoc_collection_insert_one para adicionar documentos BSON à collection. Este exemplo insere no banco de banco de dados "mydb" e na collection "mycoll".

Quando terminar, certifique-se de que as estruturas alocadas sejam liberadas usando suas respectivas funções de destruição.

#include <bson/bson.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
int
main (int   argc,
      char *argv[])
{
    mongoc_client_t *client;
    mongoc_collection_t *collection;
    bson_error_t error;
    bson_oid_t oid;
    bson_t *doc;
    mongoc_init ();
    client = mongoc_client_new ("mongodb://localhost:27017/?appname=insert-example");
    collection = mongoc_client_get_collection (client, "mydb", "mycoll");
    doc = bson_new ();
    bson_oid_init (&oid, NULL);
    BSON_APPEND_OID (doc, "_id", &oid);
    BSON_APPEND_UTF8 (doc, "hello", "world");
    if (!mongoc_collection_insert_one (
           collection, doc, NULL, NULL, &error)) {
        fprintf (stderr, "%s\n", error.message);
    }
    bson_destroy (doc);
    mongoc_collection_destroy (collection);
    mongoc_client_destroy (client);
    mongoc_cleanup ();
    return 0;
}

Compile o código e execute-o:

$ gcc -o insert insert.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./insert

No Windows:

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 insert.c
C:\> insert

Para verificar se a inserção foi bem-sucedida, conecte-se ao shell do MongoDB.

$ mongo
MongoDB shell version: 3.0.6
connecting to: test
> use mydb
switched to db mydb
> db.mycoll.find()
{ "_id" : ObjectId("55ef43766cb5f36a3bae6ee4"), "hello" : "world" }
>

Encontrando um documento

Para consultar uma coleção MongoDB com o driver C, use a função mongoc_collection_find_with_opts. Isso retorna um cursor aos documentos correspondentes. Os exemplos a seguir iteram pelos cursores de resultados e imprimem as correspondências com stdout como strings JSON.

Usar um documento como especificador de query; por exemplo,

{ "color" : "red" }

corresponderá a qualquer documento com um campo chamado "cor" com o valor "vermelho". Um documento vazio {} pode ser usado para corresponder a todos os documentos.

Este primeiro exemplo usa um especificador de query vazio para localizar todos os documentos no banco de dados "mydb" e na collection "mycoll".

#include <bson/bson.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
int
main (int argc, char *argv[])
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   mongoc_cursor_t *cursor;
   const bson_t *doc;
   bson_t *query;
   char *str;
   mongoc_init ();
   client =
      mongoc_client_new ("mongodb://localhost:27017/?appname=find-example");
   collection = mongoc_client_get_collection (client, "mydb", "mycoll");
   query = bson_new ();
   cursor = mongoc_collection_find_with_opts (collection, query, NULL, NULL);
   while (mongoc_cursor_next (cursor, &doc)) {
      str = bson_as_canonical_extended_json (doc, NULL);
      printf ("%s\n", str);
      bson_free (str);
   }
   bson_destroy (query);
   mongoc_cursor_destroy (cursor);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return 0;
}

Compile o código e execute-o:

$ gcc -o find find.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./find
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

No Windows:

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 find.c
C:\> find
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

Para procurar um documento específico, adicione um especificador a query. Este exemplo adiciona uma chamada a BSON_APPEND_UTF8() para procurar todos os documentos correspondentes a {"hello" : "world"}.

#include <bson/bson.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
int
main (int argc, char *argv[])
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   mongoc_cursor_t *cursor;
   const bson_t *doc;
   bson_t *query;
   char *str;
   mongoc_init ();
   client = mongoc_client_new (
      "mongodb://localhost:27017/?appname=find-specific-example");
   collection = mongoc_client_get_collection (client, "mydb", "mycoll");
   query = bson_new ();
   BSON_APPEND_UTF8 (query, "hello", "world");
   cursor = mongoc_collection_find_with_opts (collection, query, NULL, NULL);
   while (mongoc_cursor_next (cursor, &doc)) {
      str = bson_as_canonical_extended_json (doc, NULL);
      printf ("%s\n", str);
      bson_free (str);
   }
   bson_destroy (query);
   mongoc_cursor_destroy (cursor);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return 0;
}

$ gcc -o find-specific find-specific.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./find-specific
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 find-specific.c
C:\> find-specific
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

Atualizando um documento

Este trecho de código fornece um exemplo do uso de mongoc_collection_update_one para atualizar os campos de um documento.

Usando o banco de dados "mydb", o exemplo a seguir insere um documento de exemplo na coleção "mycoll". Em seguida, usando seu campo _id , o documento é atualizado com valores diferentes e um novo campo.

#include <bson/bson.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
int
main (int argc, char *argv[])
{
   mongoc_collection_t *collection;
   mongoc_client_t *client;
   bson_error_t error;
   bson_oid_t oid;
   bson_t *doc = NULL;
   bson_t *update = NULL;
   bson_t *query = NULL;
   mongoc_init ();
   client =
      mongoc_client_new ("mongodb://localhost:27017/?appname=update-example");
   collection = mongoc_client_get_collection (client, "mydb", "mycoll");
   bson_oid_init (&oid, NULL);
   doc = BCON_NEW ("_id", BCON_OID (&oid), "key", BCON_UTF8 ("old_value"));
   if (!mongoc_collection_insert_one (collection, doc, NULL, &error)) {
      fprintf (stderr, "%s\n", error.message);
      goto fail;
   }
   query = BCON_NEW ("_id", BCON_OID (&oid));
   update = BCON_NEW ("$set",
                      "{",
                      "key",
                      BCON_UTF8 ("new_value"),
                      "updated",
                      BCON_BOOL (true),
                      "}");
   if (!mongoc_collection_update_one (
          collection, query, update, NULL, NULL, &error)) {
      fprintf (stderr, "%s\n", error.message);
      goto fail;
   }
fail:
   if (doc)
      bson_destroy (doc);
   if (query)
      bson_destroy (query);
   if (update)
      bson_destroy (update);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return 0;
}

Compile o código e execute-o:

$ gcc -o update update.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./update

No Windows:

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 update.c
C:\> update
{ "_id" : { "$oid" : "55ef43766cb5f36a3bae6ee4" }, "hello" : "world" }

Para verificar se a atualização foi bem-sucedida, conecte-se ao shell do MongoDB.

$ mongo
MongoDB shell version: 3.0.6
connecting to: test
> use mydb
switched to db mydb
> db.mycoll.find({"updated" : true})
{ "_id" : ObjectId("55ef549236fe322f9490e17b"), "updated" : true, "key" : "new_value" }
>

Excluindo um documento

Este exemplo ilustra o uso de mongoc_collection_delete_one para excluir um documento.

O código a seguir insere um documento de amostra no banco de banco de dados "mydb" e na coleção "mycoll". Em seguida, ele exclui todos os documentos correspondentes a {"hello" : "world"}.

#include <bson/bson.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
int
main (int argc, char *argv[])
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   bson_error_t error;
   bson_oid_t oid;
   bson_t *doc;
   mongoc_init ();
   client =
      mongoc_client_new ("mongodb://localhost:27017/?appname=delete-example");
   collection = mongoc_client_get_collection (client, "test", "test");
   doc = bson_new ();
   bson_oid_init (&oid, NULL);
   BSON_APPEND_OID (doc, "_id", &oid);
   BSON_APPEND_UTF8 (doc, "hello", "world");
   if (!mongoc_collection_insert_one (collection, doc, NULL, &error)) {
      fprintf (stderr, "Insert failed: %s\n", error.message);
   }
   bson_destroy (doc);
   doc = bson_new ();
   BSON_APPEND_OID (doc, "_id", &oid);
   if (!mongoc_collection_delete_one (
          collection, doc, NULL, NULL, &error)) {
      fprintf (stderr, "Delete failed: %s\n", error.message);
   }
   bson_destroy (doc);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return 0;
}

Compile o código e execute-o:

$ gcc -o delete delete.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./delete

No Windows:

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 delete.c
C:\> delete

Use a MongoDB shell para provar que os documentos foram removidos com sucesso.

$ mongo
MongoDB shell version: 3.0.6
connecting to: test
> use mydb
switched to db mydb
> db.mycoll.count({"hello" : "world"})
0
>

Contando documentos

Contar o número de documentos em uma collection do MongoDB é semelhante a executar uma operação de busca. Este exemplo conta o número de documentos correspondentes a {"hello" : "world"} no banco de banco de dados "mydb" e na collection "mycoll".

#include <bson/bson.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
int
main (int argc, char *argv[])
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   bson_error_t error;
   bson_t *doc;
   int64_t count;
   mongoc_init ();
   client =
      mongoc_client_new ("mongodb://localhost:27017/?appname=count-example");
   collection = mongoc_client_get_collection (client, "mydb", "mycoll");
   doc = bson_new_from_json (
      (const uint8_t *) "{\"hello\" : \"world\"}", -1, &error);
   count = mongoc_collection_count (
      collection, MONGOC_QUERY_NONE, doc, 0, 0, NULL, &error);
   if (count < 0) {
      fprintf (stderr, "%s\n", error.message);
   } else {
      printf ("%" PRId64 "\n", count);
   }
   bson_destroy (doc);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return 0;
}

Compile o código e execute-o:

$ gcc -o count count.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./count
1

No Windows:

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 count.c
C:\> count
1

Executando comandos

O driver fornece funções auxiliares para executar comandos MongoDB em estruturas de cliente, banco de dados e coleção. As variantes _simple retornam booleanos indicando sucesso ou falha.

Este exemplo executa o comando ping no banco de banco de dados "mydb".

#include <bson/bson.h>
#include <mongoc/mongoc.h>
#include <stdio.h>
int
main (void)
{
   mongoc_client_t *client;
   bson_error_t error;
   bson_t *command;
   bson_t reply;
   char *str;
   mongoc_init ();
   client = mongoc_client_new ("mongodb://localhost:27017/?appname=executing-example");
   command = BCON_NEW ("ping", BCON_INT32 (1));
   if (mongoc_client_command_simple (client, "mydb", command, NULL, &reply, &error)) {
      str = bson_as_canonical_extended_json (&reply, NULL);
      printf ("%s\n", str);
      bson_free (str);
   } else {
      fprintf (stderr, "Failed to run command: %s\n", error.message);
   }
   bson_destroy (command);
   bson_destroy (&reply);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return 0;
}

Compile o código e execute-o:

$ gcc -o executing executing.c $(pkg-config --cflags --libs libmongoc-1.0)
$ ./executing
{ "ok" : { "$numberDouble" : "1.0" }, "$clusterTime" : { "clusterTime" : { "$timestamp" : { "t" : 1682609211, "i" : 1 } }, "signature" : { "hash" : { "$binary" : { "base64" : "AAAAAAAAAAAAAAAAAAAAAAAAAAA=", "subType" : "00" } }, "keyId" : { "$numberLong" : "0" } } }, "operationTime" : { "$timestamp" : { "t" : 1682609211, "i" : 1 } } }

No Windows:

C:\> cl.exe /IC:\mongo-c-driver\include\libbson-1.0 /IC:\mongo-c-driver\include\libmongoc-1.0 executing.c
C:\> executing
{ "ok" : { "$numberDouble" : "1.0" }, "$clusterTime" : { "clusterTime" : { "$timestamp" : { "t" : 1682609211, "i" : 1 } }, "signature" : { "hash" : { "$binary" : { "base64" : "AAAAAAAAAAAAAAAAAAAAAAAAAAA=", "subType" : "00" } }, "keyId" : { "$numberLong" : "0" } } }, "operationTime" : { "$timestamp" : { "t" : 1682609211, "i" : 1 } } }

Segmentação

O driver C do MongoDB não reconhece threads na grande maioria de suas operações. Isso significa que cabe ao programador garantir a segurança do thread.

No entanto, mongoc_client_pool_t é seguro para threads e é usado para buscar um de mongoc_client_t maneira segura para threads. Depois de recuperar um cliente do pool, a estrutura do cliente deve ser considerada propriedade do thread de chamada. Quando a thread terminar, o cliente deve ser colocado de volta na pool.

sample-pool.c

/* gcc example-pool.c -o example-pool $(pkg-config --cflags --libs
 * libmongoc-1.0) */
/* ./example-pool [CONNECTION_STRING] */
#include <mongoc/mongoc.h>
#include <pthread.h>
#include <stdio.h>
static pthread_mutex_t mutex;
static bool in_shutdown = false;
static void *
worker (void *data)
{
   mongoc_client_pool_t *pool = data;
   mongoc_client_t *client;
   bson_t ping = BSON_INITIALIZER;
   bson_error_t error;
   bool r;
   BSON_APPEND_INT32 (&ping, "ping", 1);
   while (true) {
      client = mongoc_client_pool_pop (pool);
      /* Do something with client. If you are writing an HTTP server, you
       * probably only want to hold onto the client for the portion of the
       * request performing database queries.
       */
      r = mongoc_client_command_simple (client, "admin", &ping, NULL, NULL, &error);
      if (!r) {
         fprintf (stderr, "%s\n", error.message);
      }
      mongoc_client_pool_push (pool, client);
      pthread_mutex_lock (&mutex);
      if (in_shutdown || !r) {
         pthread_mutex_unlock (&mutex);
         break;
      }
      pthread_mutex_unlock (&mutex);
   }
   bson_destroy (&ping);
   return NULL;
}
int
main (int argc, char *argv[])
{
   const char *uri_string = "mongodb://127.0.0.1/?appname=pool-example";
   mongoc_uri_t *uri;
   bson_error_t error;
   mongoc_client_pool_t *pool;
   pthread_t threads[10];
   unsigned i;
   void *ret;
   pthread_mutex_init (&mutex, NULL);
   mongoc_init ();
   if (argc > 1) {
      uri_string = argv[1];
   }
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   pool = mongoc_client_pool_new (uri);
   mongoc_client_pool_set_error_api (pool, 2);
   for (i = 0; i < 10; i++) {
      pthread_create (&threads[i], NULL, worker, pool);
   }
   sleep (10);
   pthread_mutex_lock (&mutex);
   in_shutdown = true;
   pthread_mutex_unlock (&mutex);
   for (i = 0; i < 10; i++) {
      pthread_join (threads[i], &ret);
   }
   mongoc_client_pool_destroy (pool);
   mongoc_uri_destroy (uri);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

Próximos passos

Para encontrar informações sobre tópicos avançados, navegue pelo restante do guia do driver C ou pela documentação oficial do MongoDB.

Para obter ajuda com problemas comuns, consulte a página Solução de problemas. Para relatar um bug ou solicitar uma nova funcionalidade, siga estas instruções.

Voltar

Suporte à Plataforma mongo-c-driver

Autenticação

Tutorial.leafygreen-ui-m0pgrr{-webkit-align-self:center;-ms-flex-item-align:center;align-self:center;padding:0 10px;visibility:hidden;}.leafygreen-ui-a30zj9{color:#889397;vertical-align:middle;margin-top:-2px;}.css-fmznk8{margin-top:-85px;position:absolute;padding-bottom:2px;}

Instalando

Iniciando o MongoDB

Inclua e vincule a libmongoc em seu programa C

Incluir mongoc.h

CCriar

pacote-config

Especificando cabeçalho e incluindo caminhos manualmente

Usar libmongoc em um projeto do Microsoft Visual Studio

Estabelecendo uma conexão

Criando documentos BSON

Anexando BSON

Usando BCON

Criando BSON a partir de JSON

Operações CRUD básicas

Inserindo um documento

Encontrando um documento

Atualizando um documento

Excluindo um documento

Contando documentos

Executando comandos

Segmentação

Próximos passos

Tutorial