Creating collections

In this simple example we'll learn how to explicitly create collections with the library, be those normal collections, capped ones or simply preallocated.

Our application will attempt to create a normal collection, a capped one, a capped one that's also capped on the number of entries, and a pre-allocated (but uncapped) collection.

It will print these properties of the collections aswell, so that we can verify that the creation did indeed work.

#include <mongo.h>

#include <errno.h>
#include <stdio.h>

First of all, we need a function that prints the collection properties. Because we're lazy, it will take a BSON object, as returned by mongo_sync_cmd_exists().

The output of said command is a BSON object that has a name field, which is the full name of the collection, the database part included; and an options subdocument, which lists various options specified during creating, such as cappedness, size and maximum number of elements.

Our very simple function will extract all these and print what's appropriate. It will also free the BSON object it was given, so that we don't leak memory.

static void
print_coll_info (bson *info)
{
  bson_cursor *c = NULL;
  bson *options = NULL;

  const gchar *name;
  gboolean capped = FALSE;
  gint64 size = -1;
  gint64 max = -1;

  c = bson_find (info, "name");
  bson_cursor_get_string (c, &name);
  bson_cursor_find (c, "options");

  bson_cursor_get_document (c, &options);

  printf ("Options for %s:\n", name);

  bson_cursor_free (c);
  bson_free (info);

  c = bson_find (options, "capped");
  bson_cursor_get_boolean (c, &capped);
  bson_cursor_free (c);

  c = bson_find (options, "size");
  bson_cursor_get_int64 (c, &size);
  bson_cursor_free (c);

  c = bson_find (options, "max");
  bson_cursor_get_int64 (c, &max);
  bson_cursor_free (c);

  bson_free (options);

  printf ("\tCapped: %s\n", (capped) ? "yes" : "no");
  if (size > 0)
    printf ("\tSize  : %lu\n", size);
  if (max > 0)
    printf ("\tMax   : %lu\n", max);
  printf ("\n");
}

With that done, lets get down to business, and create the collections, after connecting to the server, of course.

int
main (void)
{
  mongo_sync_connection *conn;

  conn = mongo_sync_connect ("localhost", 27017, FALSE);
  if (!conn)
    {
      fprintf (stderr, "Connection failed: %s\n", strerror (errno));
      return 1;
    }

First we create a completely normal collection, with the default settings:

  mongo_sync_cmd_create (conn, "lmc", "cmd_create", MONGO_COLLECTION_DEFAULTS);
  print_coll_info (mongo_sync_cmd_exists (conn, "lmc", "cmd_create"));

Then a capped collection:

  mongo_sync_cmd_create (conn, "lmc", "cmd_create_capped",
                         MONGO_COLLECTION_CAPPED, 655360);
  print_coll_info (mongo_sync_cmd_exists (conn, "lmc", "cmd_create_capped"));

Followed by another capped collection, one that is also capped by the number of elements, not only by size:

  mongo_sync_cmd_create (conn, "lmc", "cmd_create_capped_max",
                         MONGO_COLLECTION_CAPPED | MONGO_COLLECTION_CAPPED_MAX,
                         655360, 100);
  print_coll_info (mongo_sync_cmd_exists (conn, "lmc",

And finally, we create a pre-allocated collection:

                                          "cmd_create_capped_max"));

  mongo_sync_cmd_create (conn, "lmc", "cmd_create_sized",
                         MONGO_COLLECTION_SIZED, 655360);
  print_coll_info (mongo_sync_cmd_exists (conn, "lmc", "cmd_create_sized"));

And that's about it, really.

  mongo_sync_disconnect (conn);

  return 0;
}