static void copy_labels_plus_unknown_commit_result (const bson_t *src, bson_t *dst) { bson_iter_t iter; bson_iter_t src_label; bson_t dst_labels; char str[16]; uint32_t i = 0; const char *key; BSON_APPEND_ARRAY_BEGIN (dst, "errorLabels", &dst_labels); BSON_APPEND_UTF8 (&dst_labels, "0", UNKNOWN_COMMIT_RESULT); /* append any other errorLabels already in "src" */ if (bson_iter_init_find (&iter, src, "errorLabels") && bson_iter_recurse (&iter, &src_label)) { while (bson_iter_next (&src_label) && BSON_ITER_HOLDS_UTF8 (&src_label)) { if (strcmp (bson_iter_utf8 (&src_label, NULL), UNKNOWN_COMMIT_RESULT) != 0) { i++; bson_uint32_to_string (i, &key, str, sizeof str); BSON_APPEND_UTF8 ( &dst_labels, key, bson_iter_utf8 (&src_label, NULL)); } } } bson_append_array_end (dst, &dst_labels); }
void SettingsOutput::SetSubbasinIDs() { bson_t *b = bson_new(); bson_t *child = bson_new(); bson_t *child2 = bson_new(); bson_t *child3 = bson_new(); BSON_APPEND_DOCUMENT_BEGIN(b, "$query", child); BSON_APPEND_DOCUMENT_BEGIN(child, PARAM_FLD_NAME, child2); BSON_APPEND_ARRAY_BEGIN(child2, "$in", child3); BSON_APPEND_UTF8(child3,PARAM_FLD_NAME, VAR_OUTLETID); BSON_APPEND_UTF8(child3,PARAM_FLD_NAME, VAR_SUBBSNID_NUM); bson_append_array_end(child2, child3); bson_append_document_end(child, child2); bson_append_document_end(b, child); //printf("%s\n",bson_as_json(b,NULL)); mongoc_cursor_t *cursor; const bson_t *bsonTable; mongoc_collection_t *collection; collection = mongoc_client_get_collection(m_conn, m_dbName.c_str(), DB_TAB_PARAMETERS); cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, b, NULL, NULL); bson_iter_t iter; while (mongoc_cursor_more(cursor) && mongoc_cursor_next(cursor, &bsonTable)) { string nameTmp = ""; int numTmp = -1; if (bson_iter_init_find(&iter, bsonTable, PARAM_FLD_NAME)) nameTmp = GetStringFromBSONITER(&iter); if (bson_iter_init_find(&iter, bsonTable, PARAM_FLD_VALUE)) numTmp = GetIntFromBSONITER(&iter); if(!StringMatch(nameTmp, "") && numTmp != -1) { if(StringMatch(nameTmp, VAR_OUTLETID)) m_outletID = GetIntFromBSONITER(&iter); else if (StringMatch(nameTmp, VAR_SUBBSNID_NUM)) m_nSubbasins = GetIntFromBSONITER(&iter); } else throw ModelException("SettingOutput","SetSubbasinIDs","No valid values found in MongoDB!"); } bson_destroy(child); bson_destroy(child2); bson_destroy(child3); bson_destroy(b); mongoc_collection_destroy(collection); mongoc_cursor_destroy(cursor); return; }
static bool with_transaction_fail_transient_txn (mongoc_client_session_t *session, void *ctx, bson_t **reply, bson_error_t *error) { bson_t labels; _mongoc_usleep (session->with_txn_timeout_ms * 1000); *reply = bson_new (); BSON_APPEND_ARRAY_BEGIN (*reply, "errorLabels", &labels); BSON_APPEND_UTF8 (&labels, "0", TRANSIENT_TXN_ERR); return false; }
static void append_documents_from_cmd (const mongoc_cmd_t *cmd, mongoc_apm_command_started_t *event) { int32_t doc_len; bson_t doc; const uint8_t *pos; const char *field_name; bson_t bson; char str[16]; const char *key; uint32_t i; if (!cmd->payload || !cmd->payload_size) { return; } if (!event->command_owned) { event->command = bson_copy (event->command); event->command_owned = true; } /* make array from outgoing OP_MSG payload type 1 on an "insert", * "update", or "delete" command. */ field_name = _mongoc_get_documents_field_name (cmd->command_name); BSON_ASSERT (field_name); BSON_ASSERT (BSON_APPEND_ARRAY_BEGIN (event->command, field_name, &bson)); pos = cmd->payload; i = 0; while (pos < cmd->payload + cmd->payload_size) { memcpy (&doc_len, pos, sizeof (doc_len)); doc_len = BSON_UINT32_FROM_LE (doc_len); BSON_ASSERT (bson_init_static (&doc, pos, (size_t) doc_len)); bson_uint32_to_string (i, &key, str, sizeof (str)); BSON_APPEND_DOCUMENT (&bson, key, &doc); pos += doc_len; i++; } bson_append_array_end (event->command, &bson); }
bool bson_append_int32_array_from_s (bson_t *bson, const char *key, const char *value) { bool ret = true; bson_t child; char *s, *p; if (value && strcmp ("\\N", value) != 0) { s = strdup (value); BSON_APPEND_ARRAY_BEGIN (bson, key, &child); p = strtok (s, "{,}"); while (p) { ret = bson_append_int32_from_s (&child, "0", p); p = strtok (NULL, "{,}"); } bson_append_array_end (bson, &child); free (s); } return ret; }
bool bson_append_point_from_s (bson_t *bson, const char *key, const char *value) { bool ret = true; bson_t child; char *s, *p; if (value && strcmp ("\\N", value) != 0) { s = strdup (value); BSON_APPEND_ARRAY_BEGIN (bson, key, &child); p = strtok (s, "(,)"); if (!p) DIE; ret = bson_append_double_from_s (&child, "0", p); p = strtok (NULL, "(,)"); if (!p) DIE; ret = ret && bson_append_double_from_s (&child, "1", p); bson_append_array_end (bson, &child); free (s); } return ret; }
void switch_value(lua_State *L, int index, bson_t* bson, int level, const char* key) { switch(lua_type(L, index)) { case LUA_TTABLE: { int is_a=is_array(L, index); if (is_a) { bson_t child; //start array BSON_APPEND_ARRAY_BEGIN(bson, key, &child); iterate_table(L, index, &child, 0, level+1, NULL); bson_append_array_end(bson, &child); } else { bson_t child; //start map BSON_APPEND_DOCUMENT_BEGIN(bson, key, &child); iterate_table(L, index, &child, 1, level+1, NULL); bson_append_document_end(bson, &child); } break; } case LUA_TNIL: { BSON_APPEND_NULL(bson, key); break; } case LUA_TNUMBER: { BSON_APPEND_DOUBLE(bson, key, lua_tonumber(L, index)); break; } case LUA_TBOOLEAN: { BSON_APPEND_BOOL(bson, key, lua_toboolean(L, index)); break; } case LUA_TSTRING: { BSON_APPEND_UTF8(bson, key, lua_tostring(L, index)); break; } case LUA_TUSERDATA: { // switch userdata type if (luaL_checkudata_ex(L, index, REGEX_METATABLE)) { cbson_regex_t* regex = check_cbson_regex(L, index); BSON_APPEND_REGEX (bson, key, regex->regex, regex->options); } else if (luaL_checkudata_ex(L, index, OID_METATABLE)) { cbson_oid_t* oid = check_cbson_oid(L, index); bson_oid_t boid; bson_oid_init_from_string (&boid, oid->oid); BSON_APPEND_OID (bson, key, &boid); } else if (luaL_checkudata_ex(L, index, BINARY_METATABLE)) { cbson_binary_t* bin = check_cbson_binary(L, index); size_t binary_len = b64_pton (bin->data, NULL, 0); unsigned char* buf=malloc(binary_len+1); b64_pton(bin->data, buf, binary_len+1); BSON_APPEND_BINARY(bson, key, bin->type, buf, binary_len); free(buf); } else if (luaL_checkudata_ex(L, index, SYMBOL_METATABLE)) { cbson_symbol_t* sym = check_cbson_symbol(L, index); BSON_APPEND_SYMBOL(bson, key, sym->symbol); } else if (luaL_checkudata_ex(L, index, REF_METATABLE)) { cbson_ref_t* ref = check_cbson_ref(L, index); bson_oid_t boid; bson_oid_init_from_string (&boid, ref->id); BSON_APPEND_DBPOINTER(bson, key, ref->ref, &boid); } else if (luaL_checkudata_ex(L, index, MINKEY_METATABLE)) { check_cbson_minkey(L, index); BSON_APPEND_MINKEY(bson, key); } else if (luaL_checkudata_ex(L, index, MAXKEY_METATABLE)) { check_cbson_maxkey(L, index); BSON_APPEND_MAXKEY(bson, key); } else if (luaL_checkudata_ex(L, index, TIMESTAMP_METATABLE)) { cbson_timestamp_t* time = check_cbson_timestamp(L, index); BSON_APPEND_TIMESTAMP(bson, key, time->timestamp, time->increment); } else if (luaL_checkudata_ex(L, index, INT64_METATABLE) || luaL_checkudata_ex(L, index, UINT64_METATABLE)) { cbson_int64_t i = cbson_int64_check(L, index); if (i < INT32_MIN || i > INT32_MAX) { BSON_APPEND_INT64(bson, key, i); } else { BSON_APPEND_INT32(bson, key, (int32_t)i); } } else if (luaL_checkudata_ex(L, index, CODE_METATABLE)) { cbson_code_t* code = check_cbson_code(L, index); BSON_APPEND_CODE(bson, key, code->code); } else if (luaL_checkudata_ex(L, index, CODEWSCOPE_METATABLE)) { cbson_codewscope_t* code = check_cbson_codewscope(L, index); BSON_APPEND_CODE_WITH_SCOPE(bson, key, code->code, NULL); } else if (luaL_checkudata_ex(L, index, UNDEFINED_METATABLE)) { check_cbson_undefined(L, index); BSON_APPEND_UNDEFINED(bson, key); } else if (luaL_checkudata_ex(L, index, DATE_METATABLE)) { BSON_APPEND_DATE_TIME(bson, key, cbson_date_check(L, index)); } break; } case LUA_TFUNCTION: case LUA_TTHREAD: case LUA_TLIGHTUSERDATA: default: break; // or bail out? } }
void transaction_bson(struct transaction const* tx, bson_t* out) { char key[9]; bson_t* input_list = bson_new(); // Version BSON_APPEND_INT32(out, "version", (int)transaction_version(tx)); // Inputs BSON_APPEND_ARRAY_BEGIN(out, "inputs", input_list); size_t num_inputs = transaction_num_inputs(tx); for(size_t i = 0; i < num_inputs; i++) { struct transaction_input* input = transaction_input(tx, i); bson_snprintf(key, sizeof(key), "%u", (unsigned int)i); key[sizeof(key) - 1] = '\0'; bson_t* member = bson_new(); bson_append_document_begin(input_list, key, -1, member); // Output Reference struct transaction_output_reference* output_reference = transaction_input_output_reference(input); unsigned char prevout_hash[32]; transaction_output_reference_hash(output_reference, prevout_hash); bson_t* prevout = bson_new(); bson_append_document_begin(member, "output_reference", -1, prevout); BSON_APPEND_BINARY(prevout, "hash", BSON_SUBTYPE_BINARY, (uint8_t*)prevout_hash, 32); BSON_APPEND_INT32(prevout, "index", transaction_output_reference_index(output_reference)); bson_append_document_end(member, prevout); // Script struct script* script = transaction_input_script(input); BSON_APPEND_BINARY(member, "script", BSON_SUBTYPE_BINARY, (uint8_t*)script_data(script), script_size(script)); // Sequence BSON_APPEND_INT32(member, "sequence", transaction_input_sequence(input)); bson_append_document_end(input_list, member); } bson_append_array_end(out, input_list); // Outputs bson_t* output_list = bson_new(); BSON_APPEND_ARRAY_BEGIN(out, "outputs", output_list); size_t num_outputs = transaction_num_outputs(tx); for(size_t i = 0; i < num_outputs; i++) { struct transaction_output* output = transaction_output(tx, i); bson_snprintf(key, sizeof(key), "%u", (unsigned int)i); key[sizeof(key) - 1] = '\0'; bson_t* member = bson_new(); bson_append_document_begin(output_list, key, -1, member); // Value BSON_APPEND_INT64(member, "value", transaction_output_value(output)); // Script struct script* script = transaction_output_script(output); BSON_APPEND_BINARY(member, "script", BSON_SUBTYPE_BINARY, (uint8_t*)script_data(script), script_size(script)); bson_append_document_end(output_list, member); } bson_append_array_end(out, output_list); // Lock time BSON_APPEND_INT32(out, "lock_time", (int)transaction_lock_time(tx)); }
/* Uses old way of querying system.namespaces. */ bson_t * _mongoc_database_get_collection_info_legacy (mongoc_database_t *database, const bson_t *filter, bson_error_t *error) { mongoc_collection_t *col; mongoc_cursor_t *cursor; mongoc_read_prefs_t *read_prefs; uint32_t dbname_len; const bson_t *doc; bson_t legacy_filter; bson_iter_t iter; const char *name; const char *col_filter; bson_t q = BSON_INITIALIZER; bson_t *ret = NULL; bson_t col_array = BSON_INITIALIZER; const char *key; char keystr[16]; uint32_t n_cols = 0; BSON_ASSERT (database); col = mongoc_client_get_collection (database->client, database->name, "system.namespaces"); BSON_ASSERT (col); dbname_len = (uint32_t)strlen (database->name); /* Filtering on name needs to be handled differently for old servers. */ if (filter && bson_iter_init_find (&iter, filter, "name")) { /* on legacy servers, this must be a string (i.e. not a regex) */ if (!BSON_ITER_HOLDS_UTF8 (&iter)) { bson_set_error (error, MONGOC_ERROR_NAMESPACE, MONGOC_ERROR_NAMESPACE_INVALID_FILTER_TYPE, "On legacy servers, a filter on name can only be a string."); goto cleanup_filter; } BSON_ASSERT (BSON_ITER_HOLDS_UTF8 (&iter)); col_filter = bson_iter_utf8 (&iter, NULL); bson_init (&legacy_filter); bson_copy_to_excluding_noinit (filter, &legacy_filter, "name", NULL); /* We must db-qualify filters on name. */ bson_string_t *buf = bson_string_new (database->name); bson_string_append_c (buf, '.'); bson_string_append (buf, col_filter); BSON_APPEND_UTF8 (&legacy_filter, "name", buf->str); bson_string_free (buf, true); filter = &legacy_filter; } read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY); cursor = mongoc_collection_find (col, MONGOC_QUERY_NONE, 0, 0, 0, filter ? filter : &q, NULL, read_prefs); ret = bson_new(); BSON_APPEND_ARRAY_BEGIN (ret, "collections", &col_array); while (mongoc_cursor_more (cursor) && !mongoc_cursor_error (cursor, error)) { if (mongoc_cursor_next (cursor, &doc)) { /* 2 gotchas here. * 1. need to ignore any system collections (prefixed with $) * 2. need to remove the database name from the collection so that clients * don't need to specialize their logic for old versions of the server. */ if (bson_iter_init_find (&iter, doc, "name") && BSON_ITER_HOLDS_UTF8 (&iter) && (name = bson_iter_utf8 (&iter, NULL)) && !strchr (name, '$') && (0 == strncmp (name, database->name, dbname_len))) { bson_t nprefix_col = BSON_INITIALIZER; bson_copy_to_excluding_noinit (doc, &nprefix_col, "name", NULL); BSON_APPEND_UTF8 (&nprefix_col, "name", name + (dbname_len + 1)); /* +1 for the '.' */ /* need to construct a key for this array element. */ bson_uint32_to_string(n_cols, &key, keystr, sizeof (keystr)); BSON_APPEND_DOCUMENT (&col_array, key, &nprefix_col); ++n_cols; } } } bson_append_array_end (ret, &col_array); mongoc_cursor_destroy (cursor); mongoc_read_prefs_destroy (read_prefs); cleanup_filter: mongoc_collection_destroy (col); return ret; }
static bool appendBsonValue(bson_t *bson, const QString &key, const QVariant &value) { const QLatin1String oidkey("_id"); bool ok = true; int type = value.type(); // _id if (key == oidkey) { QByteArray oidVal = value.toByteArray(); if (oidVal.length() == 24) { // ObjectId bson_oid_t oid; bson_oid_init_from_string(&oid, oidVal.data()); BSON_APPEND_OID(bson, oidkey.latin1(), &oid); } else { int id = value.toInt(&ok); if (ok) { BSON_APPEND_INT32(bson, oidkey.latin1(), id); } else { BSON_APPEND_UTF8(bson, oidkey.latin1(), value.toString().toUtf8().data()); } } return true; } switch (type) { case QVariant::Int: BSON_APPEND_INT32(bson, qPrintable(key), value.toInt(&ok)); break; case QVariant::String: BSON_APPEND_UTF8(bson, qPrintable(key), value.toString().toUtf8().data()); break; case QVariant::LongLong: BSON_APPEND_INT64(bson, qPrintable(key), value.toLongLong(&ok)); break; case QVariant::Map: BSON_APPEND_DOCUMENT(bson, qPrintable(key), (const bson_t *)TBson::toBson(value.toMap()).constData()); break; case QVariant::Double: BSON_APPEND_DOUBLE(bson, qPrintable(key), value.toDouble(&ok)); break; case QVariant::Bool: BSON_APPEND_BOOL(bson, qPrintable(key), value.toBool()); break; case QVariant::DateTime: { #if QT_VERSION >= 0x040700 BSON_APPEND_DATE_TIME(bson, qPrintable(key), value.toDateTime().toMSecsSinceEpoch()); #else QDateTime utcDate = value.toDateTime().toUTC(); qint64 ms = utcDate.time().msec(); qint64 tm = utcDate.toTime_t() * 1000LL; if (ms > 0) { tm += ms; } BSON_APPEND_DATE_TIME(bson, qPrintable(key), tm); #endif break; } case QVariant::ByteArray: { QByteArray ba = value.toByteArray(); BSON_APPEND_BINARY(bson, qPrintable(key), BSON_SUBTYPE_BINARY, (uint8_t *)ba.constData(), ba.length()); break; } case QVariant::List: // FALL THROUGH case QVariant::StringList: { bson_t child; BSON_APPEND_ARRAY_BEGIN(bson, qPrintable(key), &child); int i = 0; for (auto &var : value.toList()) { appendBsonValue(&child, QString::number(i++), var); } bson_append_array_end(bson, &child); break; } case QVariant::Invalid: BSON_APPEND_UNDEFINED(bson, qPrintable(key)); break; default: tError("toBson() failed to convert name:%s type:%d", qPrintable(key), type); ok = false; break; } return ok; }