void
tut_sync_query_simple (void)
{
mongo_sync_connection *conn;
mongo_packet *p;
mongo_sync_cursor *cursor;
bson *query;
gint i = 0;
conn = mongo_sync_connect ("localhost", 27017, FALSE);
if (!conn)
{
perror ("mongo_sync_connect()");
exit (1);
}
query = bson_new ();
bson_finish (query);
p = mongo_sync_cmd_query (conn, "tutorial.docs", 0,
0, 10, query, NULL);
if (!p)
{
perror ("mongo_sync_cmd_query()");
exit (1);
}
bson_free (query);
cursor = mongo_sync_cursor_new (conn, "tutorial.docs", p);
if (!cursor)
{
perror ("mongo_sync_cursor_new()");
exit (1);
}
while (mongo_sync_cursor_next (cursor))
{
bson *result = mongo_sync_cursor_get_data (cursor);
bson_cursor *c;
if (!result)
{
perror ("mongo_sync_cursor_get_data()");
exit (1);
}
printf ("Keys in document #%d:\n", i);
c = bson_cursor_new (result);
while (bson_cursor_next (c))
printf ("\t%s\n", bson_cursor_key (c));
i++;
bson_cursor_free (c);
bson_free (result);
}
mongo_sync_cursor_free (cursor);
mongo_sync_disconnect (conn);
}
static void
do_query (mongo_sync_connection *conn)
{
mongo_sync_cursor *c;
bson *query;
gchar *error = NULL;
query = bson_build
(BSON_TYPE_TIMESTAMP, "processed", 1294860709000,
BSON_TYPE_NONE);
bson_finish (query);
c = mongo_sync_cursor_new (conn, "blahblah.plurals",
mongo_sync_cmd_query (conn, "blahblah.plurals", 0,
0, 10, query, NULL));
if (!c)
{
fprintf (stderr, "Error creating the query cursor: %s\n",
strerror (errno));
exit (1);
}
bson_free (query);
while (mongo_sync_cursor_next (c))
{
bson *b = mongo_sync_cursor_get_data (c);
bson_cursor *bc;
gint32 w_t;
gint64 w_i;
if (!b)
{
int e = errno;
mongo_sync_cmd_get_last_error (conn, "blahblah.plurals", &error);
fprintf (stderr, "Error retrieving cursor data: %s\n",
(error) ? error : strerror (e));
exit (1);
}
bc = bson_find (b, "word_type");
bson_cursor_get_int32 (bc, &w_t);
printf ("\rWord type: %d\n", w_t);
bc = bson_find (b, "word_id");
bson_cursor_get_int64 (bc, &w_i);
printf ("\rWord id: %d\n", (int)w_i);
bson_cursor_free (bc);
bson_free (b);
}
printf ("\n");
mongo_sync_cursor_free (c);
}
static void
do_query (mongo_sync_connection *conn)
{
mongo_sync_cursor *c;
bson *query;
gchar *error = NULL;
query = bson_build
(BSON_TYPE_STRING, "tutorial-program", "tut_hl_client.c", -1,
BSON_TYPE_NONE);
bson_finish (query);
c = mongo_sync_cursor_new (conn, "lmc.tutorial",
mongo_sync_cmd_query (conn, "lmc.tutorial", 0,
0, 10, query, NULL));
if (!c)
{
fprintf (stderr, "Error creating the query cursor: %s\n",
strerror (errno));
exit (1);
}
bson_free (query);
while (mongo_sync_cursor_next (c))
{
bson *b = mongo_sync_cursor_get_data (c);
bson_cursor *bc;
gint32 cnt;
if (!b)
{
int e = errno;
mongo_sync_cmd_get_last_error (conn, "lmc", &error);
fprintf (stderr, "Error retrieving cursor data: %s\n",
(error) ? error : strerror (e));
exit (1);
}
bc = bson_find (b, "counter");
bson_cursor_get_int32 (bc, &cnt);
printf ("\rCounter: %d", cnt);
bson_cursor_free (bc);
bson_free (b);
}
printf ("\n");
mongo_sync_cursor_free (c);
}
void mmg_destroy(mmg_conn *db)
{
if (!db) return;
if (db->c) {
mongo_sync_cursor_free(db->c);
db->c = NULL;
}
/* TODO packet */
if (db->docs) {
bson_free(db->docs);
db->docs = NULL;
}
if (db->docq) {
bson_free(db->docq);
db->docq = NULL;
}
mongo_sync_disconnect(db->con);
}
NEOERR* mmg_custom(mmg_conn *db, char *dbname,
char *prefix, HDF *outnode, char *command)
{
mongo_packet *p;
mongo_sync_cursor *c;
bson *doc;
NEOERR *err;
MCS_NOT_NULLC(db, dbname, command);
mtc_noise("custom %s %s", dbname, command);
/*
* doc
*/
doc = mbson_new_from_string(command, true);
if (!doc) return nerr_raise(NERR_ASSERT, "build doc custom %s", command);
p = mongo_sync_cmd_custom(db->con, dbname, doc);
bson_free(doc);
if (!p)
return nerr_raise(NERR_DB, "sync_cmd_custom: %s %s", command, strerror(errno));
c = mongo_sync_cursor_new(db->con, dbname, p);
if (!c) return nerr_raise(NERR_DB, "cursor: %s", strerror(errno));
if (outnode) {
if (mongo_sync_cursor_next(c)) {
doc = mongo_sync_cursor_get_data(c);
if (!doc) return nerr_raise(NERR_DB, "doc: %s", strerror(errno));
err = mbson_export_to_hdf(outnode, doc, prefix, MBSON_EXPORT_TYPE, true);
if (err != STATUS_OK) return nerr_pass(err);
} else return nerr_raise(NERR_DB, "cursor next: %s", strerror(errno));
}
mongo_sync_cursor_free(c);
return STATUS_OK;
}
void
mongo_gridfs_get (config_t *config, gint argc, gchar *argv[])
{
mongo_sync_gridfs *gfs;
mongo_sync_gridfs_chunked_file *gfile;
mongo_sync_cursor *cursor;
gint64 n = 0;
bson *query;
int fd;
gchar *gfn, *ofn;
if (argc < 4)
{
fprintf (stderr, "Usage: %s get GRIDFS_FILENAME OUTPUT_FILENAME\n",
argv[0]);
exit (1);
}
gfn = argv[2];
ofn = argv[3];
gfs = mongo_gridfs_connect (config);
VLOG ("Trying to find '%s'...\n", gfn);
query = bson_build (BSON_TYPE_STRING, "filename", gfn, -1,
BSON_TYPE_NONE);
bson_finish (query);
gfile = mongo_sync_gridfs_chunked_find (gfs, query);
if (!gfile)
mongo_gridfs_error (errno);
bson_free (query);
VLOG ("Opening output file '%s'...\n", ofn);
fd = open (ofn, O_RDWR | O_CREAT | O_TRUNC, 0600);
if (fd == -1)
{
fprintf (stderr, "Error opening output file '%s': %s\n",
ofn, strerror (errno));
exit (1);
}
VLOG ("Writing '%s' -> '%s' (%" G_GINT64_FORMAT " bytes in %" G_GINT64_FORMAT
" chunks)\n", gfn, ofn,
mongo_sync_gridfs_file_get_length (gfile),
mongo_sync_gridfs_file_get_chunks (gfile));
cursor = mongo_sync_gridfs_chunked_file_cursor_new (gfile, 0, 0);
if (!cursor)
mongo_gridfs_error (errno);
while (mongo_sync_cursor_next (cursor))
{
gint32 size;
guint8 *data;
VLOG ("\rWriting chunk %" G_GINT64_FORMAT "...", n++);
data = mongo_sync_gridfs_chunked_file_cursor_get_chunk (cursor, &size);
if (!data)
mongo_gridfs_error (errno);
if (write (fd, data, size) != size)
{
perror ("write()");
exit (1);
}
g_free (data);
}
mongo_sync_cursor_free (cursor);
mongo_sync_gridfs_chunked_file_free (gfile);
close (fd);
mongo_sync_gridfs_free (gfs, TRUE);
VLOG("\n");
}
void free_cursor(struct db_cursor *db_c)
{
mongo_sync_cursor_free (db_c->cursor);
free(db_c);
}
void
mongo_dump (config_t *config)
{
mongo_sync_connection *conn;
mongo_sync_cursor *cursor;
bson *b;
int fd;
glong cnt, pos = 0;
gchar *error = NULL;
int e;
if (config->port == MONGO_CONN_LOCAL)
{
VLOG ("Connecting to %s/%s.%s...\n", config->addr, config->db,
config->coll);
}
else
{
VLOG ("Connecting to %s:%d/%s.%s...\n", config->addr, config->port,
config->db, config->coll);
}
conn = mongo_sync_connect (config->addr, config->port, config->slaveok);
if (!conn)
{
e = errno;
mongo_sync_cmd_get_last_error (conn, config->db, &error);
fprintf (stderr, "Error connecting to %s:%d: %s\n", config->addr,
config->port, (error) ? error : strerror (e));
g_free (error);
exit (1);
}
if (config->master_sync)
{
VLOG ("Syncing to master...\n");
conn = mongo_sync_reconnect (conn, TRUE);
if (!conn)
{
e = errno;
mongo_sync_cmd_get_last_error (conn, config->db, &error);
fprintf (stderr, "Error reconnecting to the master of %s:%d: %s\n",
config->addr, config->port, (error) ? error : strerror (e));
exit (1);
}
}
VLOG ("Counting documents...\n");
cnt = mongo_sync_cmd_count (conn, config->db, config->coll, NULL);
if (cnt < 0)
{
e = errno;
mongo_sync_cmd_get_last_error (conn, config->db, &error);
fprintf (stderr, "Error counting documents in %s.%s: %s\n",
config->db, config->coll, (error) ? error : strerror (e));
mongo_sync_disconnect (conn);
exit (1);
}
VLOG ("Opening output file '%s'...\n", config->output);
if (strcmp (config->output, "-") == 0)
fd = 1;
else
{
fd = open (config->output, O_RDWR | O_CREAT | O_TRUNC, 0600);
if (fd == -1)
{
fprintf (stderr, "Error opening output file '%s': %s\n",
config->output, strerror (errno));
mongo_sync_disconnect (conn);
exit (1);
}
}
VLOG ("Launching initial query...\n");
b = bson_new ();
bson_finish (b);
cursor = mongo_sync_cursor_new (conn, config->ns,
mongo_sync_cmd_query (conn, config->ns,
MONGO_WIRE_FLAG_QUERY_NO_CURSOR_TIMEOUT,
0, 10, b, NULL));
bson_free (b);
while ((pos < cnt) && mongo_sync_cursor_next (cursor))
{
bson *b = mongo_sync_cursor_get_data (cursor);
pos++;
if (!b)
{
e = errno;
mongo_sync_cmd_get_last_error (conn, config->db, &error);
fprintf (stderr, "Error advancing the cursor: %s\n",
(error) ? error : strerror (e));
mongo_sync_disconnect (conn);
exit (1);
}
if (pos % 10 == 0)
VLOG ("\rDumping... %03.2f%%", (pos * 1.0) / (cnt * 1.0) * 100);
if (write (fd, bson_data (b), bson_size (b)) != bson_size (b))
{
perror ("write()");
exit (1);
}
bson_free (b);
}
VLOG ("\rDumping... %03.2f%%\n", (double)((pos / cnt) * 100));
mongo_sync_cursor_free (cursor);
close (fd);
mongo_sync_disconnect (conn);
}
void
tut_sync_query_complex (void)
{
mongo_sync_connection *conn;
mongo_packet *p;
mongo_sync_cursor *cursor;
bson *query, *select;
gint i = 0;
conn = mongo_sync_connect ("localhost", 27017, FALSE);
if (!conn)
{
perror ("mongo_sync_connect()");
exit (1);
}
query = bson_build_full (BSON_TYPE_DOCUMENT, "$query", TRUE,
bson_build (BSON_TYPE_BOOLEAN, "yes?", FALSE,
BSON_TYPE_NONE),
BSON_TYPE_DOCUMENT, "$orderby", TRUE,
bson_build (BSON_TYPE_INT32, "n", 1,
BSON_TYPE_NONE),
BSON_TYPE_NONE);
bson_finish (query);
select = bson_build (BSON_TYPE_INT32, "hello", 1,
BSON_TYPE_INT32, "n", 1,
BSON_TYPE_INT32, "yes?", 1,
BSON_TYPE_NONE);
bson_finish (select);
p = mongo_sync_cmd_query (conn, "tutorial.docs", 0,
0, 10, query, select);
if (!p)
{
perror ("mongo_sync_cmd_query()");
exit (1);
}
bson_free (query);
bson_free (select);
cursor = mongo_sync_cursor_new (conn, "tutorial.docs", p);
if (!cursor)
{
perror ("mongo_sync_cursor_new()");
exit (1);
}
while (mongo_sync_cursor_next (cursor))
{
const char *hello;
gint32 n;
gboolean yes;
bson *result;
bson_cursor *c;
result = mongo_sync_cursor_get_data (cursor);
if (!result)
{
perror ("mongo_sync_cursor_get_data()");
exit (1);
}
c = bson_find (result, "hello");
if (!bson_cursor_get_string (c, &hello))
{
perror ("bson_cursor_get_string()");
exit (1);
}
bson_cursor_free (c);
c = bson_find (result, "n");
if (!bson_cursor_get_int32 (c, &n))
{
perror ("bson_cursor_get_int32()");
exit (1);
}
bson_cursor_free (c);
c = bson_find (result, "yes?");
if (!bson_cursor_get_boolean (c, &yes))
{
perror ("bson_cursor_get_boolean()");
exit (1);
}
bson_cursor_free (c);
printf ("Document #%d: hello=%s; n=%d; yes?=%s\n",
i, hello, n, (yes) ? "TRUE" : "FALSE");
bson_free (result);
i++;
}
mongo_sync_cursor_free (cursor);
mongo_sync_disconnect (conn);
}
NEOERR* mmg_query(mmg_conn *db, char *dsn, char *prefix, HDF *outnode)
{
int count;
char key[LEN_HDF_KEY];
HDF *node, *cnode;
bson *doc;
NEOERR *err;
MCS_NOT_NULLB(db, dsn);
db->p = mongo_sync_cmd_query(db->con, dsn, db->flags & 0x3FF, db->skip, db->limit,
db->docq, db->docs);
if (!db->p) {
if (errno == ENOENT) {
mtc_noise("queried %s 0 result", dsn);
if (db->flags & MMG_FLAG_EMPTY) {
if (db->query_callback && !db->incallback) {
/*
* empty result, call callback
*/
db->incallback = true;
err = db->query_callback(db, NULL, true);
TRACE_NOK(err);
db->incallback = false;
db->query_callback = NULL;
db->callbackdata = NULL;
}
return STATUS_OK;
}
return nerr_raise(NERR_NOT_FOUND, "无此记录");
}
return nerr_raise(NERR_DB, "query: %s %d", strerror(errno), errno);
}
/*
* process result
*/
if (outnode || (db->query_callback && !db->incallback)) {
if (outnode) node = outnode; /* need store result */
else hdf_init(&node);
db->c = mongo_sync_cursor_new(db->con, dsn, db->p);
if (!db->c) return nerr_raise(NERR_DB, "cursor: %s", strerror(errno));
cnode = NULL;
count = 0;
while (mongo_sync_cursor_next(db->c) && count < db->limit) {
memset(key, sizeof(key), 0x0);
if (prefix) {
if (!(db->flags & MMG_FLAG_MIXROWS) && db->limit > 1)
snprintf(key, sizeof(key), "%s.%d", prefix, count);
else snprintf(key, sizeof(key), "%s", prefix);
} else {
if (!(db->flags & MMG_FLAG_MIXROWS) && db->limit > 1)
sprintf(key, "%d", count);
else key[0] = '\0';
}
doc = mongo_sync_cursor_get_data(db->c);
err = mbson_export_to_hdf(node, doc, key, MBSON_EXPORT_TYPE, true);
if (err != STATUS_OK) return nerr_pass(err);
if (!cnode) cnode = hdf_get_obj(node, key);
count++;
}
db->rescount = count;
mongo_sync_cursor_free(db->c);
db->c = NULL;
db->p = NULL;
mtc_noise("queried %s %d result", dsn, count);
/*
* call callback at last. because we don't want declare more mmg_conn*
* it's safe to do new query in callback on result stored (db->c freeed)
* we can call mmg_query() recursive, the callback won't.
*/
if (db->query_callback && !db->incallback) {
db->incallback = true;
count = 0;
while (cnode) {
count++;
if (db->rescount == count) err = db->query_callback(db, cnode, true);
else err = db->query_callback(db, cnode, false);
TRACE_NOK(err);
cnode = hdf_obj_next(cnode);
}
db->incallback = false;
/*
* query_callback can't be shared with multiply query
* later query must set them again even if TheSameOne
*/
db->query_callback = NULL;
db->callbackdata = NULL;
}
if (!outnode) hdf_destroy(&node);
} else {
/* don't need result */
mongo_wire_packet_free(db->p);
db->c = NULL;
db->p = NULL;
}
return STATUS_OK;
}