/* {{{ proto void BulkWrite::update(array|object $query, array|object $newObj[, array $updateOptions = array()])
Adds an update operation to bulk */
PHP_METHOD(BulkWrite, update)
{
php_phongo_bulkwrite_t *intern;
zval *query;
zval *newObj;
zval *updateOptions = NULL;
mongoc_update_flags_t flags = MONGOC_UPDATE_NONE;
bson_t *bquery;
bson_t *bupdate;
SUPPRESS_UNUSED_WARNING(return_value_ptr) SUPPRESS_UNUSED_WARNING(return_value) SUPPRESS_UNUSED_WARNING(return_value_used)
intern = Z_BULKWRITE_OBJ_P(getThis());
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "AA|a!", &query, &newObj, &updateOptions) == FAILURE) {
return;
}
bquery = bson_new();
bupdate = bson_new();
phongo_zval_to_bson(query, PHONGO_BSON_NONE, bquery, NULL TSRMLS_CC);
phongo_zval_to_bson(newObj, PHONGO_BSON_NONE, bupdate, NULL TSRMLS_CC);
if (updateOptions) {
flags |= php_array_fetch_bool(updateOptions, "multi") ? MONGOC_UPDATE_MULTI_UPDATE : 0;
flags |= php_array_fetch_bool(updateOptions, "upsert") ? MONGOC_UPDATE_UPSERT : 0;
}
if (flags & MONGOC_UPDATE_MULTI_UPDATE) {
mongoc_bulk_operation_update(intern->bulk, bquery, bupdate, !!(flags & MONGOC_UPDATE_UPSERT));
} else {
bson_iter_t iter;
zend_bool replaced = 0;
if (bson_iter_init(&iter, bupdate)) {
while (bson_iter_next (&iter)) {
if (!strchr (bson_iter_key (&iter), '$')) {
mongoc_bulk_operation_replace_one(intern->bulk, bquery, bupdate, !!(flags & MONGOC_UPDATE_UPSERT));
replaced = 1;
break;
}
}
}
if (!replaced) {
mongoc_bulk_operation_update_one(intern->bulk, bquery, bupdate, !!(flags & MONGOC_UPDATE_UPSERT));
}
}
intern->num_ops++;
bson_clear(&bquery);
bson_clear(&bupdate);
}
int
lua_mongo_collection_update (lua_State *L)
{
collection_t *collection;
bson_t filter = BSON_INITIALIZER;
bson_t update = BSON_INITIALIZER;
bool upsert;
bool update_many;
bson_error_t error;
bool ret;
mongoc_bulk_operation_t *bulk_update = NULL;
bson_t reply = BSON_INITIALIZER;
bool throw_error = false;
collection = (collection_t *)luaL_checkudata(L, 1, "lua_mongoc_collection");
if (!(lua_isnil(L, 2))) {
if (!(lua_table_to_bson(L, &filter, 2, false, &error))) {
throw_error = true;
goto DONE;
}
}
if (lua_isnil(L, 3)) {
luaL_error(L, "update parameters must be included");
} else {
if (!(lua_table_to_bson(L, &update, 3, false, &error))) {
throw_error = true;
goto DONE;
}
}
if ((lua_isboolean(L, 4))) {
upsert = lua_toboolean(L, 4);
} else {
luaL_error(L, "upsert parameter must be a boolean");
}
if ((lua_isboolean(L, 5))) {
update_many = lua_toboolean(L, 5);
} else {
luaL_error(L, "update_many parameter must be a boolean");
}
bulk_update = mongoc_collection_create_bulk_operation
(collection->c_collection,
false, NULL);
if (update_many) {
mongoc_bulk_operation_update(bulk_update, &filter, &update, upsert);
} else {
mongoc_bulk_operation_update_one(bulk_update, &filter, &update, upsert);
}
ret = mongoc_bulk_operation_execute (bulk_update, &reply, &error);
if (!ret) {
throw_error = true;
goto DONE;
}
if (!(bson_document_or_array_to_table(L, &reply, true, &error))) {
throw_error = true;
goto DONE;
}
DONE:
bson_destroy(&filter);
bson_destroy(&update);
bson_destroy(&reply);
if (bulk_update) {
mongoc_bulk_operation_destroy (bulk_update);
}
if (throw_error) {
luaL_error(L, error.message);
}
return 1;
}
static void
test_bulk (void)
{
mongoc_bulk_operation_t *bulk;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error;
bson_iter_t iter;
bson_t reply;
bson_t child;
bson_t del;
bson_t up;
bson_t doc = BSON_INITIALIZER;
bool r;
client = mongoc_client_new (gTestUri);
assert (client);
collection = get_test_collection (client, "test_bulk");
assert (collection);
bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);
assert (bulk);
mongoc_bulk_operation_insert (bulk, &doc);
mongoc_bulk_operation_insert (bulk, &doc);
mongoc_bulk_operation_insert (bulk, &doc);
mongoc_bulk_operation_insert (bulk, &doc);
bson_init (&up);
bson_append_document_begin (&up, "$set", -1, &child);
bson_append_int32 (&child, "hello", -1, 123);
bson_append_document_end (&up, &child);
mongoc_bulk_operation_update (bulk, &doc, &up, false);
bson_destroy (&up);
bson_init (&del);
BSON_APPEND_INT32 (&del, "hello", 123);
mongoc_bulk_operation_delete (bulk, &del);
bson_destroy (&del);
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
assert (r);
assert (bson_iter_init_find (&iter, &reply, "nInserted"));
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (bson_iter_int32 (&iter) == 4);
/*
* This may be omitted if we talked to a (<= 2.4.x) node, or a mongos
* talked to a (<= 2.4.x) node.
*/
if (bson_iter_init_find (&iter, &reply, "nModified")) {
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (bson_iter_int32 (&iter) == 4);
}
assert (bson_iter_init_find (&iter, &reply, "nRemoved"));
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (4 == bson_iter_int32 (&iter));
assert (bson_iter_init_find (&iter, &reply, "nMatched"));
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (4 == bson_iter_int32 (&iter));
assert (bson_iter_init_find (&iter, &reply, "nUpserted"));
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (!bson_iter_int32 (&iter));
bson_destroy (&reply);
r = mongoc_collection_drop (collection, &error);
assert (r);
mongoc_bulk_operation_destroy (bulk);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&doc);
}
static void
test_index_offset (void)
{
mongoc_bulk_operation_t *bulk;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error;
bson_iter_t iter;
bson_iter_t ar;
bson_iter_t citer;
bson_t reply;
bson_t *sel;
bson_t *doc;
bool r;
client = mongoc_client_new (gTestUri);
assert (client);
collection = get_test_collection (client, "test_index_offset");
assert (collection);
doc = bson_new ();
BSON_APPEND_INT32 (doc, "abcd", 1234);
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, doc, NULL, &error);
assert (r);
bson_destroy (doc);
bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);
assert (bulk);
sel = BCON_NEW ("abcd", BCON_INT32 (1234));
doc = BCON_NEW ("$set", "{", "hello", "there", "}");
mongoc_bulk_operation_delete_one (bulk, sel);
mongoc_bulk_operation_update (bulk, sel, doc, true);
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
assert (r);
assert (bson_iter_init_find (&iter, &reply, "nUpserted"));
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (bson_iter_int32 (&iter) == 1);
assert (bson_iter_init_find (&iter, &reply, "nMatched"));
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (bson_iter_int32 (&iter) == 0);
assert (bson_iter_init_find (&iter, &reply, "nRemoved"));
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (bson_iter_int32 (&iter) == 1);
assert (bson_iter_init_find (&iter, &reply, "nInserted"));
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (bson_iter_int32 (&iter) == 0);
if (bson_iter_init_find (&iter, &reply, "nModified")) {
assert (BSON_ITER_HOLDS_INT32 (&iter));
assert (bson_iter_int32 (&iter) == 0);
}
assert (bson_iter_init_find (&iter, &reply, "upserted"));
assert (BSON_ITER_HOLDS_ARRAY (&iter));
assert (bson_iter_recurse (&iter, &ar));
assert (bson_iter_next (&ar));
assert (BSON_ITER_HOLDS_DOCUMENT (&ar));
assert (bson_iter_recurse (&ar, &citer));
assert (bson_iter_next (&citer));
assert (BSON_ITER_IS_KEY (&citer, "index"));
assert (bson_iter_int32 (&citer) == 1);
assert (bson_iter_next (&citer));
assert (BSON_ITER_IS_KEY (&citer, "_id"));
assert (BSON_ITER_HOLDS_OID (&citer));
assert (!bson_iter_next (&citer));
assert (!bson_iter_next (&ar));
assert (bson_iter_init_find (&iter, &reply, "writeErrors"));
assert (BSON_ITER_HOLDS_ARRAY (&iter));
assert (bson_iter_recurse (&iter, &ar));
assert (!bson_iter_next (&ar));
bson_destroy (&reply);
r = mongoc_collection_drop (collection, &error);
assert (r);
mongoc_bulk_operation_destroy (bulk);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (doc);
bson_destroy (sel);
}
