bool
_mongoc_convert_timestamp (mongoc_client_t *client,
const bson_iter_t *iter,
mongoc_timestamp_t *timestamp,
bson_error_t *error)
{
bson_iter_timestamp (iter, ×tamp->timestamp, ×tamp->increment);
return true;
}
types::b_timestamp element::get_timestamp() const {
CITER;
uint32_t timestamp;
uint32_t increment;
bson_iter_timestamp(&iter, ×tamp, &increment);
return types::b_timestamp{timestamp, increment};
}
types::b_timestamp element::get_timestamp() const {
BSONCXX_TYPE_CHECK(k_timestamp);
BSONCXX_CITER;
uint32_t timestamp;
uint32_t increment;
bson_iter_timestamp(&iter, ×tamp, &increment);
return types::b_timestamp{timestamp, increment};
}
void bsonToMongoTimestamp(bson_iter_t* iter, Array* output) {
uint32_t timestamp;
uint32_t increment;
bson_iter_timestamp(iter, ×tamp, &increment);
bsonToObject(iter, output,
&s_MongoTimestamp,
make_packed_array((int64_t)timestamp, (int64_t)increment)
);
}
int monary_load_timestamp_value(const bson_iter_t* bsonit,
monary_column_item* citem,
int idx)
{
uint32_t timestamp;
uint32_t increment;
char* dest; // Would be void*, but Windows compilers complain
dest = (char*) citem->storage + idx*sizeof(int64_t);
if (BSON_ITER_HOLDS_TIMESTAMP(bsonit)) {
bson_iter_timestamp(bsonit, ×tamp, &increment);
memcpy(dest, ×tamp, sizeof(int32_t));
memcpy(dest + sizeof(int32_t), &increment, sizeof(int32_t));
return 1;
} else {
return 0;
}
}
bool
_mongoc_parse_cluster_time (const bson_t *cluster_time,
uint32_t *timestamp,
uint32_t *increment)
{
bson_iter_t iter;
char *s;
if (!cluster_time ||
!bson_iter_init_find (&iter, cluster_time, "clusterTime") ||
!BSON_ITER_HOLDS_TIMESTAMP (&iter)) {
s = bson_as_json (cluster_time, NULL);
MONGOC_ERROR ("Cannot parse cluster time from %s\n", s);
bson_free (s);
return false;
}
bson_iter_timestamp (&iter, timestamp, increment);
return true;
}
static void
tail_collection (mongoc_collection_t *collection)
{
mongoc_cursor_t *cursor;
uint32_t last_time;
const bson_t *doc;
bson_error_t error;
bson_iter_t iter;
BSON_ASSERT (collection);
last_time = (uint32_t) time (NULL);
while (true) {
cursor = query_collection (collection, last_time);
while (!mongoc_cursor_error (cursor, &error) &&
mongoc_cursor_more (cursor)) {
if (mongoc_cursor_next (cursor, &doc)) {
if (bson_iter_init_find (&iter, doc, "ts") &&
BSON_ITER_HOLDS_TIMESTAMP (&iter)) {
bson_iter_timestamp (&iter, &last_time, NULL);
}
print_bson (doc);
}
}
if (mongoc_cursor_error (cursor, &error)) {
if (error.domain == MONGOC_ERROR_SERVER) {
fprintf (stderr, "%s\n", error.message);
exit (1);
}
}
mongoc_cursor_destroy (cursor);
sleep (1);
}
}
void
_mongoc_timestamp_set_from_bson (mongoc_timestamp_t *timestamp,
bson_iter_t *iter)
{
bson_iter_timestamp (iter, &(timestamp->timestamp), &(timestamp->increment));
}
/*!
* \brief Convert rows from mongodb to db API representation
* \param _h database connection
* \param _r database result set
* \return 0 on success, negative on failure
*/
static int db_mongodb_convert_bson(const db1_con_t* _h, db1_res_t* _r,
int _row, const bson_t *_rdoc)
{
static str dummy_string = {"", 0};
int col;
db_mongodb_result_t *mgres;
const char *colname;
bson_type_t coltype;
bson_iter_t riter;
bson_iter_t citer;
bson_iter_t *piter;
db_val_t* dval;
uint32_t i32tmp;
bson_subtype_t subtype;
bson_t *cdoc;
mgres = (db_mongodb_result_t*)RES_PTR(_r);
if(mgres->nrcols==0) {
LM_ERR("no fields to convert\n");
return -1;
}
if(mgres->colsdoc==NULL) {
cdoc = (bson_t*)_rdoc;
} else {
cdoc = (bson_t*)mgres->colsdoc;
}
if (!bson_iter_init (&citer, cdoc)) {
LM_ERR("failed to initialize columns iterator\n");
return -3;
}
if(mgres->colsdoc) {
if (!bson_iter_init (&riter, _rdoc)) {
LM_ERR("failed to initialize result iterator\n");
return -3;
}
}
if (db_allocate_row(_r, &(RES_ROWS(_r)[_row])) != 0) {
LM_ERR("could not allocate row: %d\n", _row);
return -2;
}
col = 0;
while (bson_iter_next (&citer)) {
if(col >= RES_COL_N(_r)) {
LM_ERR("invalid number of columns (%d/%d)\n", col, RES_COL_N(_r));
return -4;
}
colname = bson_iter_key (&citer);
LM_DBG("looking for field[%d] named: %s\n", col, colname);
if(mgres->colsdoc) {
if(!bson_iter_find(&riter, colname)) {
LM_ERR("field [%s] not found in result iterator\n",
colname);
return -4;
}
piter = &riter;
} else {
piter = &citer;
}
coltype = bson_iter_type(piter);
dval = &(ROW_VALUES(&(RES_ROWS(_r)[_row]))[col]);
VAL_TYPE(dval) = RES_TYPES(_r)[col];
switch(coltype) {
case BSON_TYPE_BOOL:
VAL_INT(dval) = (int)bson_iter_bool (piter);
break;
case BSON_TYPE_INT32:
VAL_INT(dval) = bson_iter_int32 (piter);
break;
case BSON_TYPE_TIMESTAMP:
bson_iter_timestamp (piter,
(uint32_t*)&VAL_INT(dval), &i32tmp);
break;
case BSON_TYPE_INT64:
VAL_BIGINT(dval) = bson_iter_int64 (piter);
break;
case BSON_TYPE_DOUBLE:
VAL_DOUBLE(dval) = bson_iter_double (piter);
break;
case BSON_TYPE_DATE_TIME:
VAL_TIME(dval) = (time_t)(bson_iter_date_time (piter)/1000);
break;
case BSON_TYPE_BINARY:
bson_iter_binary (piter, &subtype,
(uint32_t*)&VAL_BLOB(dval).len, (const uint8_t**)&VAL_BLOB(dval).s);
break;
case BSON_TYPE_UTF8:
VAL_STRING(dval) = (char*)bson_iter_utf8 (piter, &i32tmp);
break;
case BSON_TYPE_OID:
break;
case BSON_TYPE_NULL:
memset(dval, 0, sizeof(db_val_t));
/* Initialize the string pointers to a dummy empty
* string so that we do not crash when the NULL flag
* is set but the module does not check it properly
*/
VAL_STRING(dval) = dummy_string.s;
VAL_STR(dval) = dummy_string;
VAL_BLOB(dval) = dummy_string;
VAL_TYPE(dval) = RES_TYPES(_r)[col];
VAL_NULL(dval) = 1;
break;
#if 0
case BSON_TYPE_EOD:
case BSON_TYPE_DOCUMENT:
case BSON_TYPE_ARRAY:
case BSON_TYPE_UNDEFINED:
case BSON_TYPE_REGEX:
case BSON_TYPE_DBPOINTER:
case BSON_TYPE_CODE:
case BSON_TYPE_SYMBOL:
case BSON_TYPE_CODEWSCOPE:
case BSON_TYPE_MAXKEY:
case BSON_TYPE_MINKEY:
#endif
default:
LM_WARN("unhandled data type column (%.*s) type id (%d), "
"use DB1_STRING as default\n", RES_NAMES(_r)[col]->len,
RES_NAMES(_r)[col]->s, coltype);
RES_TYPES(_r)[col] = DB1_STRING;
break;
}
LM_DBG("RES_NAMES(%p)[%d]=[%.*s] (%d)\n", RES_NAMES(_r)[col], col,
RES_NAMES(_r)[col]->len, RES_NAMES(_r)[col]->s, coltype);
col++;
}
return 0;
}
