Loading...
Searching...
No Matches
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");
bson_cursor_get_boolean
gboolean bson_cursor_get_boolean(const bson_cursor *c, gboolean *dest)
Get the value stored at the cursor, as a boolean.
Definition bson.c:1114
bson_cursor_get_int64
gboolean bson_cursor_get_int64(const bson_cursor *c, gint64 *dest)
Get the value stored at the cursor, as a 64-bit integer.
Definition bson.c:1241
bson_cursor_get_string
gboolean bson_cursor_get_string(const bson_cursor *c, const gchar **dest)
Get the value stored at the cursor, as string.
Definition bson.c:1008
bson_cursor_get_document
gboolean bson_cursor_get_document(const bson_cursor *c, bson **dest)
Get the value stored at the cursor, as a BSON document.
Definition bson.c:1035
bson_cursor_free
void bson_cursor_free(bson_cursor *c)
Delete a cursor, and free up all resources used by it.
Definition bson.c:800
bson_cursor_find
gboolean bson_cursor_find(bson_cursor *c, const gchar *name)
Move the cursor to a given key.
Definition bson.c:936
bson_find
bson_cursor * bson_find(const bson *b, const gchar *name)
Create a new cursor positioned at a given key.
Definition bson.c:956
bson_free
void bson_free(bson *b)
Free the memory associated with a BSON object.
Definition bson.c:579
}

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;
}
mongo_sync_connect
mongo_sync_connection * mongo_sync_connect(const gchar *address, gint port, gboolean slaveok)
Synchronously connect to a MongoDB server.
Definition mongo-sync.c:201

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"));
mongo_sync_cmd_create
gboolean mongo_sync_cmd_create(mongo_sync_connection *conn, const gchar *db, const gchar *coll, gint flags,...)
Create a new MongoDB collection.
Definition mongo-sync.c:1181
mongo_sync_cmd_exists
bson * mongo_sync_cmd_exists(mongo_sync_connection *conn, const gchar *db, const gchar *coll)
Check whether a collection exists in MongoDB.
Definition mongo-sync.c:1255
MONGO_COLLECTION_DEFAULTS
@ MONGO_COLLECTION_DEFAULTS
Default options.
Definition mongo-sync.h:404

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"));
MONGO_COLLECTION_CAPPED
@ MONGO_COLLECTION_CAPPED
The collection is capped.
Definition mongo-sync.h:406

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",
MONGO_COLLECTION_CAPPED_MAX
@ MONGO_COLLECTION_CAPPED_MAX
The collection is capped by element number aswell.
Definition mongo-sync.h:408

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"));
MONGO_COLLECTION_SIZED
@ MONGO_COLLECTION_SIZED
The collection needs to be pre-allocated.
Definition mongo-sync.h:412

And that's about it, really.

mongo_sync_disconnect (conn);
return 0;
}
mongo_sync_disconnect
void mongo_sync_disconnect(mongo_sync_connection *conn)
Close and free a synchronous MongoDB connection.
Definition mongo-sync.c:396