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;
}
