wip PHPC-2474: BinaryVector support

Author: jmikola

php_phongo.c

@@ -235,6 +235,7 @@ PHP_MINIT_FUNCTION(mongodb) /* {{{ */
 	php_phongo_document_init_ce(INIT_FUNC_ARGS_PASSTHRU);
 
 	php_phongo_binary_init_ce(INIT_FUNC_ARGS_PASSTHRU);
+	php_phongo_binaryvector_init_ce(INIT_FUNC_ARGS_PASSTHRU);
 	php_phongo_dbpointer_init_ce(INIT_FUNC_ARGS_PASSTHRU);
 	php_phongo_decimal128_init_ce(INIT_FUNC_ARGS_PASSTHRU);
 	php_phongo_int64_init_ce(INIT_FUNC_ARGS_PASSTHRU);

src/BSON/Binary.c

@@ -20,12 +20,14 @@
 
 #include "php_phongo.h"
 #include "phongo_error.h"
+#include "Binary.h"
 #include "Binary_arginfo.h"
-
-#define PHONGO_BINARY_UUID_SIZE 16
+#include "BinaryVector_arginfo.h"
 
 zend_class_entry* php_phongo_binary_ce;
 
+static phongo_bson_vector_type_t phongo_binary_get_vector_type_from_data(const uint8_t* data, uint32_t data_len);
+
 /* Initialize the object and return whether it was successful. An exception will
  * be thrown on error. */
 static bool php_phongo_binary_init(php_phongo_binary_t* intern, const char* data, size_t data_len, zend_long type)
@@ -40,6 +42,11 @@ static bool php_phongo_binary_init(php_phongo_binary_t* intern, const char* data
 		return false;
 	}
 
+	if ((type == BSON_SUBTYPE_VECTOR) && phongo_binary_get_vector_type_from_data((const uint8_t*) data, data_len) == PHONGO_BSON_VECTOR_TYPE_INVALID) {
+		phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT, "Binary vector data is invalid");
+		return false;
+	}
+
 	intern->data     = estrndup(data, data_len);
 	intern->data_len = data_len;
 	intern->type     = (uint8_t) type;
@@ -299,6 +306,7 @@ bool phongo_binary_new(zval* object, const char* data, size_t data_len, bson_sub
 {
 	php_phongo_binary_t* intern;
 
+	// TODO: Support BinaryVector
 	object_init_ex(object, php_phongo_binary_ce);
 
 	intern           = Z_BINARY_OBJ_P(object);
@@ -308,3 +316,250 @@ bool phongo_binary_new(zval* object, const char* data, size_t data_len, bson_sub
 
 	return true;
 }
+
+/* MongoDB\BSON\BinaryVector implementation */
+
+zend_class_entry* php_phongo_binaryvector_ce;
+
+static PHP_METHOD(MongoDB_BSON_BinaryVector, __construct)
+{
+	php_phongo_binary_t* intern;
+	zval*                vector;
+	zend_long            vector_type;
+
+	intern = Z_BINARY_OBJ_P(getThis());
+
+	PHONGO_PARSE_PARAMETERS_START(2, 2)
+	Z_PARAM_ARRAY(vector)
+	Z_PARAM_LONG(vector_type)
+	PHONGO_PARSE_PARAMETERS_END();
+
+	if (!zend_array_is_list(Z_ARRVAL_P(vector))) {
+		phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT, "Expected vector to be a list");
+		return;
+	}
+
+	const size_t vector_len = zend_array_count(Z_ARRVAL_P(vector));
+
+	/*
+	bson_t doc = BSON_INITIALIZER;
+
+	php_phongo_zval_to_bson(vector, PHONGO_BSON_NONE, &doc, NULL);
+
+	if (EG(exception)) {
+		return;
+	}
+
+	bson_iter_t iter;
+	bson_error_t error;
+
+	bson_iter_init(&iter, &doc);
+
+	if (!BSON_APPEND_VECTOR_INT8_FROM_ARRAY(&bson, "vector", &iter, &err)) {
+		phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT, "%s", error.message);
+		return;
+	}
+*/
+
+	bson_t doc = BSON_INITIALIZER;
+
+	if (vector_type == PHONGO_BSON_VECTOR_TYPE_INT8) {
+		bson_vector_int8_view_t view;
+
+		if (!BSON_APPEND_VECTOR_INT8_UNINIT(&doc, "vector", vector_len, &view)) {
+			phongo_throw_exception(PHONGO_ERROR_UNEXPECTED_VALUE, "BSON_APPEND_VECTOR_INT8_UNINIT failed for vector of size %zu", vector_len);
+			RETURN_THROWS();
+		}
+
+		zval*  val;
+		size_t i = 0;
+
+		ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(vector), val)
+		{
+			if (Z_TYPE_P(val) != IS_LONG) {
+				phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT, "Expected vector[%zu] to be an integer, %s given", i, zend_zval_type_name(val));
+				RETURN_THROWS();
+			}
+
+			if (Z_LVAL_P(val) < INT8_MIN || Z_LVAL_P(val) > INT8_MAX) {
+				phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT, "Expected vector[%zu] to be a signed 8-bit integer, %" PHONGO_LONG_FORMAT " given", i, Z_LVAL_P(val));
+				RETURN_THROWS();
+			}
+
+			int8_t v = (int8_t) Z_LVAL_P(val);
+
+			if (!bson_vector_int8_view_write(view, &v, 1, i)) {
+				phongo_throw_exception(PHONGO_ERROR_UNEXPECTED_VALUE, "bson_vector_int8_view_write failed to write vector[%zu]", i);
+				RETURN_THROWS();
+			}
+
+			i += 1;
+		}
+		ZEND_HASH_FOREACH_END();
+	} else {
+		// TODO: Support PHONGO_BSON_VECTOR_TYPE_FLOAT32 and PHONGO_BSON_VECTOR_TYPE_PACKED_BIT
+		phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT, "Unsupported vector type: %" PHONGO_LONG_FORMAT, vector_type);
+		RETURN_THROWS();
+	}
+
+	bson_iter_t iter;
+
+	if (bson_iter_init_find(&iter, &doc, "vector") && BSON_ITER_HOLDS_BINARY(&iter)) {
+		uint32_t       data_len;
+		const uint8_t* data;
+
+		bson_iter_binary(&iter, NULL, &data_len, &data);
+		php_phongo_binary_init(intern, (const char*) data, data_len, BSON_SUBTYPE_VECTOR);
+	}
+}
+
+static phongo_bson_vector_type_t phongo_binary_get_vector_type_from_data(const uint8_t* data, uint32_t data_len)
+{
+	if (bson_vector_int8_const_view_init(NULL, data, data_len)) {
+		return PHONGO_BSON_VECTOR_TYPE_INT8;
+	}
+
+	if (bson_vector_float32_const_view_init(NULL, data, data_len)) {
+		return PHONGO_BSON_VECTOR_TYPE_FLOAT32;
+	}
+
+	if (bson_vector_packed_bit_const_view_init(NULL, data, data_len)) {
+		return PHONGO_BSON_VECTOR_TYPE_PACKED_BIT;
+	}
+
+	return PHONGO_BSON_VECTOR_TYPE_INVALID;
+}
+
+static phongo_bson_vector_type_t phongo_binary_get_vector_type(const php_phongo_binary_t* intern)
+{
+	return phongo_binary_get_vector_type_from_data((const uint8_t*) intern->data, intern->data_len);
+}
+
+static PHP_METHOD(MongoDB_BSON_BinaryVector, getVectorType)
+{
+	PHONGO_PARSE_PARAMETERS_NONE();
+
+	php_phongo_binary_t*      intern = Z_BINARY_OBJ_P(getThis());
+	phongo_bson_vector_type_t type   = phongo_binary_get_vector_type(intern);
+
+	// The vector should always be valid by this point, but check for an error
+	if (type == PHONGO_BSON_VECTOR_TYPE_INVALID) {
+		phongo_throw_exception(PHONGO_ERROR_UNEXPECTED_VALUE, "Binary vector data is invalid");
+		RETURN_THROWS();
+	}
+
+	RETURN_LONG(type);
+}
+
+static PHP_METHOD(MongoDB_BSON_BinaryVector, toArray)
+{
+	PHONGO_PARSE_PARAMETERS_NONE();
+
+	php_phongo_binary_t*      intern = Z_BINARY_OBJ_P(getThis());
+	phongo_bson_vector_type_t type   = phongo_binary_get_vector_type(intern);
+
+	// The vector should always be valid by this point, but check for an error
+	if (type == PHONGO_BSON_VECTOR_TYPE_INVALID) {
+		phongo_throw_exception(PHONGO_ERROR_UNEXPECTED_VALUE, "Binary vector data is invalid");
+		RETURN_THROWS();
+	}
+
+	bson_t doc = BSON_INITIALIZER;
+
+	if (type == PHONGO_BSON_VECTOR_TYPE_INT8) {
+		bson_vector_int8_const_view_t view;
+
+		if (!bson_vector_int8_const_view_init(&view, (const uint8_t*) intern->data, intern->data_len) ||
+			!BSON_APPEND_ARRAY_FROM_VECTOR_INT8(&doc, "vector", view)) {
+			phongo_throw_exception(PHONGO_ERROR_UNEXPECTED_VALUE, "Failed to convert binary vector data to an array");
+			bson_destroy(&doc);
+			RETURN_THROWS();
+		}
+	} else if (type == PHONGO_BSON_VECTOR_TYPE_FLOAT32) {
+		bson_vector_float32_const_view_t view;
+
+		if (!bson_vector_float32_const_view_init(&view, (const uint8_t*) intern->data, intern->data_len) ||
+			!BSON_APPEND_ARRAY_FROM_VECTOR_FLOAT32(&doc, "vector", view)) {
+			phongo_throw_exception(PHONGO_ERROR_UNEXPECTED_VALUE, "Failed to convert binary vector data to an array");
+			bson_destroy(&doc);
+			RETURN_THROWS();
+		}
+	} else if (type == PHONGO_BSON_VECTOR_TYPE_PACKED_BIT) {
+		bson_vector_packed_bit_const_view_t view;
+
+		if (!bson_vector_packed_bit_const_view_init(&view, (const uint8_t*) intern->data, intern->data_len) ||
+			!BSON_APPEND_ARRAY_FROM_VECTOR_PACKED_BIT(&doc, "vector", view)) {
+			phongo_throw_exception(PHONGO_ERROR_UNEXPECTED_VALUE, "Failed to convert binary vector data to an array");
+			bson_destroy(&doc);
+			RETURN_THROWS();
+		}
+	}
+
+	php_phongo_bson_state state;
+	PHONGO_BSON_INIT_STATE(state);
+	state.is_visiting_array = true;
+
+	if (!php_phongo_bson_to_zval_ex(&doc, &state)) {
+		// Exception already thrown
+		bson_destroy(&doc);
+		zval_ptr_dtor(&state.zchild);
+		php_phongo_bson_typemap_dtor(&state.map);
+		RETURN_THROWS();
+	}
+
+	bson_destroy(&doc);
+	php_phongo_bson_typemap_dtor(&state.map);
+
+	RETURN_ZVAL(&state.zchild, 0, 1);
+}
+
+static PHP_METHOD(MongoDB_BSON_BinaryVector, __set_state)
+{
+	php_phongo_binary_t* intern;
+	HashTable*           props;
+	zval*                array;
+
+	PHONGO_PARSE_PARAMETERS_START(1, 1)
+	Z_PARAM_ARRAY(array)
+	PHONGO_PARSE_PARAMETERS_END();
+
+	/* This implementation is similar to Binary::__set_state(), except that we
+	 * initialize a BinaryVector object and also validate its data. */
+	object_init_ex(return_value, php_phongo_binaryvector_ce);
+
+	intern = Z_BINARY_OBJ_P(return_value);
+	props  = Z_ARRVAL_P(array);
+
+	php_phongo_binary_init_from_hash(intern, props);
+
+	if (intern->type != BSON_SUBTYPE_VECTOR || phongo_binary_get_vector_type(intern) == PHONGO_BSON_VECTOR_TYPE_INVALID) {
+		phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT, "Binary vector data is invalid");
+		RETURN_THROWS();
+	}
+}
+
+/* MongoDB\BSON\BinaryVector object handlers */
+static zend_object_handlers php_phongo_handler_binaryvector;
+
+static zend_object* php_phongo_binaryvector_create_object(zend_class_entry* class_type)
+{
+	php_phongo_binary_t* intern = zend_object_alloc(sizeof(php_phongo_binary_t), class_type);
+
+	zend_object_std_init(&intern->std, class_type);
+	object_properties_init(&intern->std, class_type);
+
+	intern->std.handlers = &php_phongo_handler_binaryvector;
+
+	return &intern->std;
+}
+
+void php_phongo_binaryvector_init_ce(INIT_FUNC_ARGS)
+{
+	php_phongo_binaryvector_ce                = register_class_MongoDB_BSON_BinaryVector(php_phongo_binary_ce);
+	php_phongo_binaryvector_ce->create_object = php_phongo_binaryvector_create_object;
+
+	memcpy(&php_phongo_handler_binaryvector, &php_phongo_handler_binary, sizeof(zend_object_handlers));
+	// TODO: Override debug and prop handlers to include vector
+	//php_phongo_handler_binaryvector.get_debug_info = php_phongo_binaryvector_get_debug_info;
+	//php_phongo_handler_binaryvector.get_properties = php_phongo_binaryvector_get_properties;
+}

src/BSON/Binary.h

@@ -19,6 +19,13 @@
 
 #define PHONGO_BINARY_UUID_SIZE 16
 
+typedef enum {
+	PHONGO_BSON_VECTOR_TYPE_INVALID    = 0,
+	PHONGO_BSON_VECTOR_TYPE_INT8       = 0x03,
+	PHONGO_BSON_VECTOR_TYPE_FLOAT32    = 0x27,
+	PHONGO_BSON_VECTOR_TYPE_PACKED_BIT = 0x10,
+} phongo_bson_vector_type_t;
+
 bool phongo_binary_new(zval* object, const char* data, size_t data_len, bson_subtype_t type);
 
 #endif /* PHONGO_BSON_BINARY_H */

src/BSON/Binary.stub.php

@@ -7,7 +7,7 @@
 
 namespace MongoDB\BSON;
 
-final class Binary implements BinaryInterface, \JsonSerializable, Type, \Stringable
+class Binary implements BinaryInterface, \JsonSerializable, Type, \Stringable
 {
     /**
      * @var int
@@ -63,19 +63,25 @@ final class Binary implements BinaryInterface, \JsonSerializable, Type, \Stringa
      */
     public const TYPE_SENSITIVE = UNKNOWN;
 
+    /**
+     * @var int
+     * @cvalue BSON_SUBTYPE_VECTOR
+     */
+    public const TYPE_VECTOR = UNKNOWN;
+
     /**
      * @var int
      * @cvalue BSON_SUBTYPE_USER
      */
     public const TYPE_USER_DEFINED = UNKNOWN;
 
-    final public function __construct(string $data, int $type = Binary::TYPE_GENERIC) {}
+    public function __construct(string $data, int $type = Binary::TYPE_GENERIC) {}
 
     final public function getData(): string {}
 
     final public function getType(): int {}
 
-    final public static function __set_state(array $properties): Binary {}
+    public static function __set_state(array $properties): Binary {}
 
     final public function __toString(): string {}
 

src/BSON/BinaryVector.stub.php

@@ -0,0 +1,37 @@
+<?php
+
+/**
+ * @generate-class-entries static
+ * @generate-function-entries static
+ */
+
+namespace MongoDB\BSON;
+
+class BinaryVector extends Binary
+{
+    /**
+     * @var int
+     * @cvalue PHONGO_BSON_VECTOR_TYPE_INT8
+     */
+    public const VECTOR_TYPE_INT8 = UNKNOWN;
+
+    /**
+     * @var int
+     * @cvalue PHONGO_BSON_VECTOR_TYPE_FLOAT32
+     */
+    public const VECTOR_TYPE_FLOAT32 = UNKNOWN;
+
+    /**
+     * @var int
+     * @cvalue PHONGO_BSON_VECTOR_TYPE_PACKED_BIT
+     */
+    public const VECTOR_TYPE_PACKED_BIT = UNKNOWN;
+
+    final public function __construct(array $vector, int $type) {}
+
+    final public function getVectorType(): int {}
+
+    final public function toArray(): array {}
+
+    final public static function __set_state(array $properties): BinaryVector {}
+}