Merged pull request #98

Author: derickr

src/MongoDB/Driver/BulkWrite.cpp

@@ -34,6 +34,8 @@ IMPLEMENT_GET_CLASS(MongoDBDriverBulkWriteData);
 const StaticString s_MongoDBDriverBulkWrite_ordered("ordered");
 const StaticString s_MongoDBDriverBulkWrite_bypassDocumentValidation("bypassDocumentValidation");
 
+#define BYPASS_UNSET -1
+
 void HHVM_METHOD(MongoDBDriverBulkWrite, __construct, const Variant &bulkWriteOptions)
 {
 	MongoDBDriverBulkWriteData* data = Native::data<MongoDBDriverBulkWriteData>(this_);
@@ -48,13 +50,14 @@ void HHVM_METHOD(MongoDBDriverBulkWrite, __construct, const Variant &bulkWriteOp
 
 	data->m_bulk = mongoc_bulk_operation_new(b_ordered);
 	data->m_num_ops = 0;
+	data->m_ordered = b_ordered;
+	data->m_bypass = BYPASS_UNSET;
 
 	if (!options.isNull()) {
 		if (options.exists(s_MongoDBDriverBulkWrite_bypassDocumentValidation)) {
-			mongoc_bulk_operation_set_bypass_document_validation(
-				data->m_bulk,
-				options[s_MongoDBDriverBulkWrite_bypassDocumentValidation].toBoolean()
-			);
+			bool bypass = !!options[s_MongoDBDriverBulkWrite_bypassDocumentValidation].toBoolean();
+			mongoc_bulk_operation_set_bypass_document_validation(data->m_bulk, bypass);
+			data->m_bypass = bypass;
 		}
 	}
 }
@@ -184,6 +187,7 @@ const StaticString
 	s_database("database"),
 	s_collection("collection"),
 	s_ordered("ordered"),
+	s_bypassDocumentValidation("bypassDocumentValidation"),
 	s_executed("executed"),
 	s_server_id("server_id"),
 	s_write_concern("write_concern");
@@ -193,20 +197,27 @@ Array HHVM_METHOD(MongoDBDriverBulkWrite, __debugInfo)
 	MongoDBDriverBulkWriteData* data = Native::data<MongoDBDriverBulkWriteData>(this_);
 	Array retval = Array::Create();
 
-	if (data->m_bulk->database) {
-		retval.set(s_database, data->m_bulk->database);
+	if (data->m_database) {
+		retval.set(s_database, data->m_database);
 	} else {
 		retval.set(s_database, Variant());
 	}
 
-	if (data->m_bulk->collection) {
-		retval.set(s_collection, data->m_bulk->collection);
+	if (data->m_collection) {
+		retval.set(s_collection, data->m_collection);
 	} else {
 		retval.set(s_collection, Variant());
 	}
 
-	retval.set(s_ordered, data->m_bulk->flags.ordered);
-	retval.set(s_executed, data->m_bulk->executed);
+	retval.set(s_ordered, data->m_ordered);
+
+	if (data->m_bypass != BYPASS_UNSET) {
+		retval.set(s_bypassDocumentValidation, (bool) !!data->m_bypass);
+	} else {
+		retval.set(s_bypassDocumentValidation, Variant());
+	}
+
+	retval.set(s_executed, data->m_executed);
 	retval.set(s_server_id, (int64_t) mongoc_bulk_operation_get_hint(data->m_bulk));
 
 	if (mongoc_bulk_operation_get_write_concern(data->m_bulk)) {

src/MongoDB/Driver/BulkWrite.h

@@ -30,17 +30,32 @@ class MongoDBDriverBulkWriteData
 		static const StaticString s_className;
 
 		mongoc_bulk_operation_t *m_bulk;
-		size_t m_num_ops;
+		size_t                   m_num_ops;
+		bool                     m_ordered;
+		int                      m_bypass;
+		char                    *m_database;
+		char                    *m_collection;
+		bool                     m_executed;
 
 		static Class* getClass();
 
 		void sweep() {
 			mongoc_bulk_operation_destroy(m_bulk);
+
+			if (m_database) {
+				free(m_database);
+			}
+			if (m_collection) {
+				free(m_collection);
+			}
 		}
 
 		MongoDBDriverBulkWriteData() {
 			m_bulk = NULL;
 			m_num_ops = 0;
+			m_database = NULL;
+			m_collection = NULL;
+			m_executed = false;
 		}
 
 		~MongoDBDriverBulkWriteData() {

utils.cpp

@@ -184,19 +184,25 @@ HPHP::Object Utils::doExecuteBulkWrite(const HPHP::String ns, mongoc_client_t *c
 {
 	HPHP::MongoDBDriverBulkWriteData* bulk_data = HPHP::Native::data<HPHP::MongoDBDriverBulkWriteData>(bulk.get());
 	bson_error_t error;
-	char *database;
-	char *collection;
 	int success;
 	bson_t reply = BSON_INITIALIZER;
 
+	/* Free previous database/collection, until PHPC-676 and HHVM-222 are resolved */
+	if (bulk_data->m_database) {
+		free(bulk_data->m_database);
+	}
+	if (bulk_data->m_collection) {
+		free(bulk_data->m_collection);
+	}
+
 	/* Prepare */
-	if (!MongoDriver::Utils::splitNamespace(ns, &database, &collection)) {
+	if (!MongoDriver::Utils::splitNamespace(ns, &bulk_data->m_database, &bulk_data->m_collection)) {
 		throw throwInvalidArgumentException("Invalid namespace provided: " + ns);
 	}
 
 	/* Setup operation */
-	mongoc_bulk_operation_set_database(bulk_data->m_bulk, database);
-	mongoc_bulk_operation_set_collection(bulk_data->m_bulk, collection);
+	mongoc_bulk_operation_set_database(bulk_data->m_bulk, bulk_data->m_database);
+	mongoc_bulk_operation_set_collection(bulk_data->m_bulk, bulk_data->m_collection);
 	mongoc_bulk_operation_set_client(bulk_data->m_bulk, client);
 
 	/* Deal with write concerns */
@@ -213,6 +219,7 @@ HPHP::Object Utils::doExecuteBulkWrite(const HPHP::String ns, mongoc_client_t *c
 
 	/* Run operation */
 	success = mongoc_bulk_operation_execute(bulk_data->m_bulk, &reply, &error);
+	bulk_data->m_executed = true;
 
 	/* Prepare result */
 	HPHP::Object obj = HPHP::hippo_write_result_init(&reply, &error, client, mongoc_bulk_operation_get_hint(bulk_data->m_bulk), success, write_concern);