Updated PHPUnit to version 7 + gh-24 + gh-42 + gh-85 + gh-83 + gh-71

.gitignore

@@ -21,6 +21,7 @@ Makefile.in
 /config.nice
 /config.status
 /config.sub
+/configure.ac
 /configure.in
 /libtool
 /ltmain.sh

lib/tarantool_server.py

@@ -95,17 +95,17 @@ def execute_no_reconnect(self, command):
         if not command:
             return
         cmd = command.replace('\n', ' ') + '\n'
-        self.socket.sendall(cmd)
+        self.socket.sendall(cmd.encode())
 
         bufsiz = 4096
-        res = ""
+        res = b''
 
         while True:
             buf = self.socket.recv(bufsiz)
             if not buf:
                 break
             res = res + buf
-            if (res.rfind("\n...\n") >= 0 or res.rfind("\r\n...\r\n") >= 0):
+            if (res.rfind(b'\n...\n') >= 0 or res.rfind(b'\r\n...\r\n') >= 0):
                 break
 
         return yaml.load(res)
@@ -245,7 +245,7 @@ def start(self):
         self.generate_configuration()
         if self.script:
             shutil.copy(self.script, self.script_dst)
-            os.chmod(self.script_dst, 0777)
+            os.chmod(self.script_dst, 511)
         args = self.prepare_args()
         self.process = subprocess.Popen(args,
                 cwd = self.vardir,

src/tarantool.c

@@ -391,6 +391,7 @@ static zend_object *tarantool_create(zend_class_entry *entry) {
 	obj = (tarantool_object *)pecalloc(1, sizeof(tarantool_object) +
 		sizeof(zval) * (entry->default_properties_count - 1), 0);
 	zend_object_std_init(&obj->zo, entry);
+	object_properties_init(&obj->zo, entry);
 	obj->zo.handlers = &tarantool_obj_handlers;
 
 	return &obj->zo;
@@ -628,6 +629,55 @@ int convert_iterator(zval *iter, int all) {
 	return -1;
 }
 
+int obtain_space_by_spaceno(tarantool_connection *obj, uint32_t space_no) {
+	if (tarantool_schema_has_space_no(obj->schema, space_no)) {
+		return 0;
+	}
+
+	tarantool_tp_update(obj->tps);
+	tp_select(obj->tps, SPACE_SPACE, INDEX_SPACE_NO, 0, 4096);
+	tp_key(obj->tps, 1);
+	tp_encode_uint(obj->tps, space_no);
+	tp_reqid(obj->tps, TARANTOOL_G(sync_counter)++);
+
+	obj->value->len = tp_used(obj->tps);
+	tarantool_tp_flush(obj->tps);
+
+	if (tarantool_stream_send(obj) == FAILURE)
+		return FAILURE;
+
+	char pack_len[5] = {0, 0, 0, 0, 0};
+	if (tarantool_stream_read(obj, pack_len, 5) == FAILURE)
+		return FAILURE;
+	size_t body_size = php_mp_unpack_package_size(pack_len);
+	smart_string_ensure(obj->value, body_size);
+	if (tarantool_stream_read(obj, obj->value->c,
+				body_size) == FAILURE)
+		return FAILURE;
+
+	struct tnt_response resp; memset(&resp, 0, sizeof(struct tnt_response));
+	if (php_tp_response(&resp, obj->value->c, body_size) == -1) {
+		tarantool_throw_parsingexception("query");
+		return FAILURE;
+	}
+
+	if (resp.error) {
+		tarantool_throw_clienterror(resp.code, resp.error,
+					    resp.error_len);
+		return FAILURE;
+	}
+
+	if (tarantool_schema_add_spaces(obj->schema, resp.data, resp.data_len)) {
+		tarantool_throw_parsingexception("schema (space)");
+		return FAILURE;
+	}
+	if (!tarantool_schema_has_space_no(obj->schema, space_no)) {
+		THROW_EXC("No space %u defined", space_no);
+		return FAILURE;
+	}
+	return 0;
+}
+
 int get_spaceno_by_name(tarantool_connection *obj, zval *name) {
 	if (Z_TYPE_P(name) == IS_LONG)
 		return Z_LVAL_P(name);
@@ -694,6 +744,11 @@ int get_indexno_by_name(tarantool_connection *obj, int space_no,
 		THROW_EXC("Index ID must be String or Long");
 		return FAILURE;
 	}
+
+	if (obtain_space_by_spaceno(obj, space_no) == FAILURE) {
+		return FAILURE;
+	}
+
 	int32_t index_no = tarantool_schema_get_iid_by_string(obj->schema,
 			space_no, Z_STRVAL_P(name), Z_STRLEN_P(name));
 	if (index_no != FAILURE)

src/tarantool_proto.h

@@ -12,6 +12,8 @@
 #define SPACE_SPACE 281
 #define SPACE_INDEX 289
 
+#define INDEX_SPACE_NO      0
+#define INDEX_INDEX_NO      0
 #define INDEX_SPACE_NAME    2
 #define INDEX_INDEX_NAME    2
 

src/tarantool_schema.c

@@ -14,27 +14,41 @@
 #define MUR_SEED 13
 #include "third_party/msgpuck.h"
 
-int mh_indexcmp_eq(
-		const struct schema_index_value **lval,
-		const struct schema_index_value **rval,
-		void *arg
-) {
-	(void )arg;
-	if ((*lval)->key.id_len != (*rval)->key.id_len)
-		return 0;
-	return !memcmp((*lval)->key.id, (*rval)->key.id, (*rval)->key.id_len);
-}
+#define MH_DEFINE_CMPFUNC(NAME, TYPE)								\
+	int mh_##NAME##cmp_eq(const TYPE **lval, const TYPE **rval, void *arg) {		\
+		(void *) arg;									\
+		if ((*lval)->key.id_len != (*rval)->key.id_len)					\
+			return 0;								\
+		return !memcmp((*lval)->key.id, (*rval)->key.id, (*rval)->key.id_len);		\
+	}											\
+												\
+	int mh_##NAME##cmp_key_eq(const struct schema_key *key, const TYPE **val, void *arg) {  \
+		(void *) arg;									\
+		if (key->id_len != (*val)->key.id_len)						\
+			return 0;								\
+		return !memcmp(key->id, (*val)->key.id, key->id_len);				\
+	}
+MH_DEFINE_CMPFUNC(field, struct schema_field_value);
+MH_DEFINE_CMPFUNC(index, struct schema_index_value);
+MH_DEFINE_CMPFUNC(space, struct schema_space_value);
+#undef MH_DEFINE_CMPFUNC
 
-int mh_indexcmp_key_eq(
-		const struct schema_key *key,
-		const struct schema_index_value **val,
-		void *arg
-) {
-	(void )arg;
-	if (key->id_len != (*val)->key.id_len)
-		return 0;
-	return !memcmp(key->id, (*val)->key.id, key->id_len);
-}
+#define mh_arg_t void *
+
+#define mh_eq(a, b, arg)     mh_fieldcmp_eq(a, b, arg)
+#define mh_eq_key(a, b, arg) mh_fieldcmp_key_eq(a, b, arg)
+#define mh_hash(x, arg)      PMurHash32(MUR_SEED, (*x)->key.id, (*x)->key.id_len)
+#define mh_hash_key(x, arg)  PMurHash32(MUR_SEED, (x)->id, (x)->id_len);
+
+#define mh_node_t struct schema_field_value *
+#define mh_key_t  struct schema_key *
+
+#define MH_CALLOC(x, y) pecalloc((x), (y), 1)
+#define MH_FREE(x)      pefree((x), 1)
+
+#define mh_name               _schema_field
+#define MH_SOURCE             1
+#include                      "third_party/mhash.h"
 
 #define mh_arg_t void *
 
@@ -79,7 +93,7 @@ schema_index_free(struct mh_schema_index_t *schema) {
 		do {
 			struct schema_key key_number = {
 				(void *)&(ivalue->index_number),
-				sizeof(uint32_t), 0
+				sizeof(ivalue->index_number), 0
 			};
 			index_slot = mh_schema_index_find(schema, &key_number,
 							  NULL);
@@ -106,28 +120,6 @@ schema_index_free(struct mh_schema_index_t *schema) {
 	}
 }
 
-int
-mh_spacecmp_eq(
-		const struct schema_space_value **lval,
-		const struct schema_space_value **rval,
-		void *arg) {
-	(void )arg;
-	if ((*lval)->key.id_len != (*rval)->key.id_len)
-		return 0;
-	return !memcmp((*lval)->key.id, (*rval)->key.id, (*rval)->key.id_len);
-}
-
-int
-mh_spacecmp_key_eq(
-		const struct schema_key *key,
-		const struct schema_space_value **val,
-		void *arg) {
-	(void )arg;
-	if (key->id_len != (*val)->key.id_len)
-		return 0;
-	return !memcmp(key->id, (*val)->key.id, key->id_len);
-}
-
 #define mh_arg_t void *
 
 #define mh_eq(a, b, arg)      mh_spacecmp_eq(a, b, arg)
@@ -158,6 +150,9 @@ schema_space_value_free(const struct schema_space_value *val) {
 			schema_index_free(val->index_hash);
 			mh_schema_index_delete(val->index_hash);
 		}
+		if (val->schema_hash) {
+			mh_schema_field_delete(val->schema_hash);
+		}
 	}
 }
 
@@ -263,6 +258,11 @@ parse_schema_space_value(struct schema_space_value *space_string,
 				goto error;
 		}
 		val->field_number = i;
+		val->key.id = val->field_name;
+		val->key.id_len = val->field_name_len;
+		mh_schema_field_put(space_string->schema_hash,
+				    (const struct schema_field_value **)&val,
+				    NULL, NULL);
 	}
 	return 0;
 error:
@@ -367,6 +367,7 @@ schema_add_space(
 		 * }
 		 */
 		case 6:
+			space_string->schema_hash = mh_schema_field_new();
 			if (parse_schema_space_value(space_string, &tuple) < 0)
 				goto error;
 			break;
@@ -398,6 +399,21 @@ schema_add_space(
 	return -1;
 }
 
+int
+tarantool_schema_has_space_no(
+		struct tarantool_schema *schema_obj,
+		uint32_t space_no) {
+	/* Prepare key for space search */
+	struct schema_key space_key;
+	space_key.number = space_no;
+	space_key.id = (void *)&(space_key.number);
+	space_key.id_len = sizeof(uint32_t);
+
+	struct mh_schema_space_t *schema = schema_obj->space_hash;
+	mh_int_t space_slot = mh_schema_space_find(schema, &space_key, NULL);
+	return (space_slot != mh_end(schema));
+}
+
 int
 tarantool_schema_add_spaces(
 		struct tarantool_schema *schema_obj,
@@ -590,23 +606,21 @@ tarantool_schema_get_fid_by_string(
 		struct tarantool_schema *schema_obj, uint32_t sid,
 		const char *field_name, uint32_t field_name_len
 ) {
-	struct mh_schema_space_t *schema = schema_obj->space_hash;
-	struct schema_key space_key = {
-		(void *)&sid,
-		sizeof(uint32_t), 0
-	};
-	mh_int_t space_slot = mh_schema_space_find(schema, &space_key, NULL);
-	if (space_slot == mh_end(schema))
+	struct mh_schema_space_t *sschema = schema_obj->space_hash;
+	struct schema_key space_key = { (void *)&sid, sizeof(uint32_t), 0 };
+	mh_int_t space_slot = mh_schema_space_find(sschema, &space_key, NULL);
+	if (space_slot == mh_end(sschema))
 		return -1;
-	const struct schema_space_value *space = *mh_schema_space_node(schema,
+	const struct schema_space_value *space = *mh_schema_space_node(sschema,
 			space_slot);
-	int i = 0;
-	for (i = 0; i < space->schema_list_len; ++i) {
-		struct schema_field_value *val = &space->schema_list[i];
-		if (strncmp(val->field_name, field_name, field_name_len) == 0)
-			return val->field_number;
-	}
-	return -1;
+	struct schema_key field_key = { field_name, field_name_len, 0 };
+	struct mh_schema_field_t *fschema = space->schema_hash;
+	mh_int_t field_slot = mh_schema_field_find(fschema, &field_key, NULL);
+	if (field_slot == mh_end(fschema))
+		return -1;
+	const struct schema_field_value *field = *mh_schema_field_node(fschema,
+			field_slot);
+	return field->field_number;
 }
 
 struct tarantool_schema *tarantool_schema_new(int is_persistent) {

src/tarantool_schema.h

@@ -14,17 +14,18 @@ enum field_type {
 };
 
 struct schema_field_value {
-	uint32_t        field_number;
-	char           *field_name;
-	uint32_t        field_name_len;
-	enum field_type field_type;
+	struct schema_key  key;
+	uint32_t           field_number;
+	char              *field_name;
+	uint32_t           field_name_len;
+	enum field_type    field_type;
 };
 
 struct schema_index_value {
 	struct schema_key          key;
+	uint32_t                   index_number;
 	char                      *index_name;
 	uint32_t                   index_name_len;
-	uint32_t                   index_number;
 	struct schema_field_value *index_parts;
 	uint32_t                   index_parts_len;
 };
@@ -33,10 +34,11 @@ struct mh_schema_index_t;
 
 struct schema_space_value {
 	struct schema_key          key;
+	uint32_t                   space_number;
 	char                      *space_name;
 	uint32_t                   space_name_len;
-	uint32_t                   space_number;
 	struct mh_schema_index_t  *index_hash;
+	struct mh_schema_field_t  *schema_hash;
 	struct schema_field_value *schema_list;
 	uint32_t                   schema_list_len;
 };
@@ -47,6 +49,9 @@ struct tarantool_schema {
 	struct mh_schema_space_t *space_hash;
 };
 
+int
+tarantool_schema_has_space_no(struct tarantool_schema *, uint32_t);
+
 int
 tarantool_schema_add_spaces(struct tarantool_schema *, const char *, uint32_t);
 int