lwtarantool 0.0.2

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_schema.c

@@ -0,0 +1,334 @@
+#include <stdio.h>
+#include <string.h>
+#include <stddef.h>
+#include <inttypes.h>
+#include <assert.h>
+#include <stdint.h>
+
+#include <msgpuck.h>
+
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+#include <tarantool/tnt_buf.h>
+#include <tarantool/tnt_object.h>
+#include <tarantool/tnt_proto.h>
+#include <tarantool/tnt_schema.h>
+#include <tarantool/tnt_mem.h>
+#include <tarantool/tnt_select.h>
+
+#include "tnt_assoc.h"
+
+static inline void
+tnt_schema_ival_free(struct tnt_schema_ival *val) {
+	if (val) tnt_mem_free((void *)val->name);
+	tnt_mem_free(val);
+}
+
+static inline void
+tnt_schema_index_free(struct mh_assoc_t *schema) {
+	mh_int_t pos = 0;
+	mh_int_t index_slot = 0;
+	mh_foreach(schema, pos) {
+		struct tnt_schema_ival *ival =
+			(*mh_assoc_node(schema, pos))->data;
+		struct assoc_val *av1 = NULL, *av2 = NULL;
+		do {
+			struct assoc_key key_number = {
+				(void *)&(ival->number),
+				sizeof(uint32_t)
+			};
+			index_slot = mh_assoc_find(schema, &key_number, NULL);
+			if (index_slot == mh_end(schema))
+				break;
+			av1 = *mh_assoc_node(schema, index_slot);
+			mh_assoc_del(schema, index_slot, NULL);
+		} while (0);
+		do {
+			struct assoc_key key_string = {
+				ival->name,
+				ival->name_len
+			};
+			index_slot = mh_assoc_find(schema, &key_string, NULL);
+			if (index_slot == mh_end(schema))
+				break;
+			av2 = *mh_assoc_node(schema, index_slot);
+			mh_assoc_del(schema, index_slot, NULL);
+		} while (0);
+		tnt_schema_ival_free(ival);
+		if (av1) tnt_mem_free((void *)av1);
+		if (av2) tnt_mem_free((void *)av2);
+	}
+}
+
+static inline void
+tnt_schema_sval_free(struct tnt_schema_sval *val) {
+	if (val) {
+		tnt_mem_free(val->name);
+		if (val->index) {
+			tnt_schema_index_free(val->index);
+			mh_assoc_delete(val->index);
+		}
+	}
+	tnt_mem_free(val);
+}
+
+static inline void
+tnt_schema_space_free(struct mh_assoc_t *schema) {
+	mh_int_t pos = 0;
+	mh_int_t space_slot = 0;
+	mh_foreach(schema, pos) {
+		struct tnt_schema_sval *sval = NULL;
+		sval = (*mh_assoc_node(schema, pos))->data;
+		struct assoc_val *av1 = NULL, *av2 = NULL;
+		do {
+			struct assoc_key key_number = {
+				(void *)&(sval->number),
+				sizeof(uint32_t)
+			};
+			space_slot = mh_assoc_find(schema, &key_number, NULL);
+			if (space_slot == mh_end(schema))
+				break;
+			av1 = *mh_assoc_node(schema, space_slot);
+			mh_assoc_del(schema, space_slot, NULL);
+		} while (0);
+		do {
+			struct assoc_key key_string = {
+				sval->name,
+				sval->name_len
+			};
+			space_slot = mh_assoc_find(schema, &key_string, NULL);
+			if (space_slot == mh_end(schema))
+				break;
+			av2 = *mh_assoc_node(schema, space_slot);
+			mh_assoc_del(schema, space_slot, NULL);
+		} while (0);
+		tnt_schema_sval_free(sval);
+		if (av1) tnt_mem_free((void *)av1);
+		if (av2) tnt_mem_free((void *)av2);
+	}
+}
+
+static inline int
+tnt_schema_add_space(struct mh_assoc_t *schema, const char **data)
+{
+	struct tnt_schema_sval *space = NULL;
+	struct assoc_val *space_string = NULL, *space_number = NULL;
+	const char *tuple = *data;
+	if (mp_typeof(*tuple) != MP_ARRAY)
+		goto error;
+	uint32_t tuple_len = mp_decode_array(&tuple); (void )tuple_len;
+	space = tnt_mem_alloc(sizeof(struct tnt_schema_sval));
+	if (!space)
+		goto error;
+	memset(space, 0, sizeof(struct tnt_schema_sval));
+	if (mp_typeof(*tuple) != MP_UINT)
+		goto error;
+	space->number = mp_decode_uint(&tuple);
+	mp_next(&tuple); /* skip owner id */
+	if (mp_typeof(*tuple) != MP_STR)
+		goto error;
+	const char *name_tmp = mp_decode_str(&tuple, &space->name_len);
+	space->name = tnt_mem_alloc(space->name_len);
+	if (!space->name)
+		goto error;
+	memcpy(space->name, name_tmp, space->name_len);
+
+	space->index = mh_assoc_new();
+	if (!space->index)
+		goto error;
+	space_string = tnt_mem_alloc(sizeof(struct assoc_val));
+	if (!space_string)
+		goto error;
+	space_string->key.id     = space->name;
+	space_string->key.id_len = space->name_len;
+	space_string->data = space;
+	space_number = tnt_mem_alloc(sizeof(struct assoc_val));
+	if (!space_number)
+		goto error;
+	space_number->key.id = (void *)&(space->number);
+	space_number->key.id_len = sizeof(space->number);
+	space_number->data = space;
+	mh_assoc_put(schema, (const struct assoc_val **)&space_string,
+		     NULL, NULL);
+	mh_assoc_put(schema, (const struct assoc_val **)&space_number,
+		     NULL, NULL);
+	mp_next(data);
+	return 0;
+error:
+	mp_next(data);
+	tnt_schema_sval_free(space);
+	if (space_string) tnt_mem_free(space_string);
+	if (space_number) tnt_mem_free(space_number);
+	return -1;
+}
+
+int tnt_schema_add_spaces(struct tnt_schema *schema_obj, struct tnt_reply *r) {
+	struct mh_assoc_t *schema = schema_obj->space_hash;
+	const char *tuple = r->data;
+	if (mp_check(&tuple, tuple + (r->data_end - r->data)))
+		return -1;
+	tuple = r->data;
+	if (mp_typeof(*tuple) != MP_ARRAY)
+		return -1;
+	uint32_t space_count = mp_decode_array(&tuple);
+	while (space_count-- > 0) {
+		if (tnt_schema_add_space(schema, &tuple))
+			return -1;
+	}
+	return 0;
+}
+
+static inline int
+tnt_schema_add_index(struct mh_assoc_t *schema, const char **data) {
+	const struct tnt_schema_sval *space = NULL;
+	struct tnt_schema_ival *index = NULL;
+	struct assoc_val *index_number = NULL, *index_string = NULL;
+	const char *tuple = *data;
+	if (mp_typeof(*tuple) != MP_ARRAY)
+		goto error;
+	int64_t tuple_len = mp_decode_array(&tuple); (void )tuple_len;
+	uint32_t space_number = mp_decode_uint(&tuple);
+	if (mp_typeof(*tuple) != MP_UINT)
+		goto error;
+	struct assoc_key space_key = {
+		(void *)&(space_number),
+		sizeof(uint32_t)
+	};
+	mh_int_t space_slot = mh_assoc_find(schema, &space_key, NULL);
+	if (space_slot == mh_end(schema))
+		return -1;
+	space = (*mh_assoc_node(schema, space_slot))->data;
+	index = tnt_mem_alloc(sizeof(struct tnt_schema_ival));
+	if (!index)
+		goto error;
+	memset(index, 0, sizeof(struct tnt_schema_ival));
+	if (mp_typeof(*tuple) != MP_UINT)
+		goto error;
+	index->number = mp_decode_uint(&tuple);
+	if (mp_typeof(*tuple) != MP_STR)
+		goto error;
+	const char *name_tmp = mp_decode_str(&tuple, &index->name_len);
+	index->name = tnt_mem_alloc(index->name_len);
+	if (!index->name)
+		goto error;
+	memcpy((void *)index->name, name_tmp, index->name_len);
+
+	index_string = tnt_mem_alloc(sizeof(struct assoc_val));
+	if (!index_string) goto error;
+	index_string->key.id     = index->name;
+	index_string->key.id_len = index->name_len;
+	index_string->data = index;
+	index_number = tnt_mem_alloc(sizeof(struct assoc_val));
+	if (!index_number) goto error;
+	index_number->key.id     = (void *)&(index->number);
+	index_number->key.id_len = sizeof(uint32_t);
+	index_number->data = index;
+	mh_assoc_put(space->index, (const struct assoc_val **)&index_string,
+		     NULL, NULL);
+	mh_assoc_put(space->index, (const struct assoc_val **)&index_number,
+		     NULL, NULL);
+	mp_next(data);
+	return 0;
+error:
+	mp_next(data);
+	if (index_string) tnt_mem_free(index_string);
+	if (index_number) tnt_mem_free(index_number);
+	tnt_schema_ival_free(index);
+	return -1;
+}
+
+int tnt_schema_add_indexes(struct tnt_schema *schema_obj, struct tnt_reply *r) {
+	struct mh_assoc_t *schema = schema_obj->space_hash;
+	const char *tuple = r->data;
+	if (mp_check(&tuple, tuple + (r->data_end - r->data)))
+		return -1;
+	tuple = r->data;
+	if (mp_typeof(*tuple) != MP_ARRAY)
+		return -1;
+	uint32_t space_count = mp_decode_array(&tuple);
+	while (space_count-- > 0) {
+		if (tnt_schema_add_index(schema, &tuple))
+			return -1;
+	}
+	return 0;
+}
+
+int32_t tnt_schema_stosid(struct tnt_schema *schema_obj, const char *name,
+			  uint32_t name_len) {
+	struct mh_assoc_t *schema = schema_obj->space_hash;
+	struct assoc_key space_key = {name, name_len};
+	mh_int_t space_slot = mh_assoc_find(schema, &space_key, NULL);
+	if (space_slot == mh_end(schema))
+		return -1;
+	const struct tnt_schema_sval *space =
+		(*mh_assoc_node(schema, space_slot))->data;
+	return space->number;
+}
+
+int32_t tnt_schema_stoiid(struct tnt_schema *schema_obj, uint32_t sid,
+			  const char *name, uint32_t name_len) {
+	struct mh_assoc_t *schema = schema_obj->space_hash;
+	struct assoc_key space_key = {(void *)&sid, sizeof(uint32_t)};
+	mh_int_t space_slot = mh_assoc_find(schema, &space_key, NULL);
+	if (space_slot == mh_end(schema))
+		return -1;
+	const struct tnt_schema_sval *space =
+		(*mh_assoc_node(schema, space_slot))->data;
+	struct assoc_key index_key = {name, name_len};
+	mh_int_t index_slot = mh_assoc_find(space->index, &index_key, NULL);
+	if (index_slot == mh_end(space->index))
+		return -1;
+	const struct tnt_schema_ival *index =
+		(*mh_assoc_node(space->index, index_slot))->data;
+	return index->number;
+}
+
+struct tnt_schema *tnt_schema_new(struct tnt_schema *s) {
+	int alloc = (s == NULL);
+	if (!s) {
+		s = tnt_mem_alloc(sizeof(struct tnt_schema));
+		if (!s) return NULL;
+	}
+	s->space_hash = mh_assoc_new();
+	s->alloc = alloc;
+	return s;
+}
+
+void tnt_schema_flush(struct tnt_schema *obj) {
+	tnt_schema_space_free(obj->space_hash);
+}
+
+void tnt_schema_free(struct tnt_schema *obj) {
+	if (obj == NULL)
+		return;
+	tnt_schema_space_free(obj->space_hash);
+	mh_assoc_delete(obj->space_hash);
+}
+
+ssize_t
+tnt_get_space(struct tnt_stream *s)
+{
+	struct tnt_stream *obj = tnt_object(NULL);
+	if (obj == NULL)
+		return -1;
+
+	tnt_object_add_array(obj, 0);
+	ssize_t retval = tnt_select(s, tnt_vsp_space, tnt_vin_name,
+				    UINT32_MAX, 0, TNT_ITER_ALL, obj);
+	tnt_stream_free(obj);
+	return retval;
+}
+
+ssize_t
+tnt_get_index(struct tnt_stream *s)
+{
+	struct tnt_stream *obj = tnt_object(NULL);
+	if (obj == NULL)
+		return -1;
+
+	tnt_object_add_array(obj, 0);
+	ssize_t retval = tnt_select(s, tnt_vsp_index, tnt_vin_name,
+				    UINT32_MAX, 0, TNT_ITER_ALL, obj);
+	tnt_stream_free(obj);
+	return retval;
+}

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_select.c

@@ -0,0 +1,58 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include <string.h>
+#include <stdbool.h>
+#include <sys/types.h>
+
+#include <msgpuck.h>
+
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+#include <tarantool/tnt_buf.h>
+#include <tarantool/tnt_object.h>
+#include <tarantool/tnt_select.h>
+
+#include "tnt_proto_internal.h"
+
+ssize_t
+tnt_select(struct tnt_stream *s, uint32_t space, uint32_t index,
+	   uint32_t limit, uint32_t offset, uint8_t iterator,
+	   struct tnt_stream *key)
+{
+	if (tnt_object_verify(key, MP_ARRAY))
+		return -1;
+	struct tnt_iheader hdr;
+	struct iovec v[4]; int v_sz = 4;
+	char *data = NULL;
+	encode_header(&hdr, TNT_OP_SELECT, s->reqid++);
+	v[1].iov_base = (void *)hdr.header;
+	v[1].iov_len  = hdr.end - hdr.header;
+	char body[64]; data = body;
+
+	data = mp_encode_map(data, 6);
+	data = mp_encode_uint(data, TNT_SPACE);
+	data = mp_encode_uint(data, space);
+	data = mp_encode_uint(data, TNT_INDEX);
+	data = mp_encode_uint(data, index);
+	data = mp_encode_uint(data, TNT_LIMIT);
+	data = mp_encode_uint(data, limit);
+	data = mp_encode_uint(data, TNT_OFFSET);
+	data = mp_encode_uint(data, offset);
+	data = mp_encode_uint(data, TNT_ITERATOR);
+	data = mp_encode_uint(data, iterator);
+	data = mp_encode_uint(data, TNT_KEY);
+	v[2].iov_base = body;
+	v[2].iov_len  = data - body;
+	v[3].iov_base = TNT_SBUF_DATA(key);
+	v[3].iov_len  = TNT_SBUF_SIZE(key);
+
+	size_t package_len = 0;
+	for (int i = 1; i < v_sz; ++i)
+		package_len += v[i].iov_len;
+	char len_prefix[9];
+	char *len_end = mp_encode_luint32(len_prefix, package_len);
+	v[0].iov_base = len_prefix;
+	v[0].iov_len = len_end - len_prefix;
+	return s->writev(s, v, v_sz);
+}

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_stream.c

@@ -0,0 +1,71 @@
+
+/*
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the
+ *    following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <sys/types.h>
+
+#include <tarantool/tnt_mem.h>
+#include <tarantool/tnt_proto.h>
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+
+uint32_t
+tnt_stream_reqid(struct tnt_stream *s, uint32_t reqid)
+{
+	uint32_t old = s->reqid;
+	s->reqid = reqid;
+	return old;
+}
+
+struct tnt_stream*
+tnt_stream_init(struct tnt_stream *s)
+{
+	int alloc = (s == NULL);
+	if (alloc) {
+		s = tnt_mem_alloc(sizeof(struct tnt_stream));
+		if (s == NULL)
+			return NULL;
+	}
+	memset(s, 0, sizeof(struct tnt_stream));
+	s->alloc = alloc;
+	return s;
+}
+
+void tnt_stream_free(struct tnt_stream *s) {
+	if (s == NULL)
+		return;
+	if (s->free)
+		s->free(s);
+	if (s->alloc)
+		tnt_mem_free(s);
+}

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_update.c

@@ -0,0 +1,247 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include <sys/types.h>
+
+#include <tarantool/tnt_mem.h>
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+#include <tarantool/tnt_buf.h>
+#include <tarantool/tnt_object.h>
+#include <tarantool/tnt_update.h>
+
+#include "tnt_proto_internal.h"
+
+ssize_t
+tnt_update(struct tnt_stream *s, uint32_t space, uint32_t index,
+	   struct tnt_stream *key, struct tnt_stream *ops)
+{
+	if (tnt_object_verify(key, MP_ARRAY))
+		return -1;
+	if (tnt_object_verify(ops, MP_ARRAY))
+		return -1;
+	struct tnt_iheader hdr;
+	struct iovec v[6]; int v_sz = 6;
+	char *data = NULL, *body_start = NULL;
+	encode_header(&hdr, TNT_OP_UPDATE, s->reqid++);
+	v[1].iov_base = (void *)hdr.header;
+	v[1].iov_len  = hdr.end - hdr.header;
+	char body[64]; body_start = body; data = body;
+
+	data = mp_encode_map(data, 4);
+	data = mp_encode_uint(data, TNT_SPACE);
+	data = mp_encode_uint(data, space);
+	data = mp_encode_uint(data, TNT_INDEX);
+	data = mp_encode_uint(data, index);
+	data = mp_encode_uint(data, TNT_KEY);
+	v[2].iov_base = (void *)body_start;
+	v[2].iov_len  = data - body_start;
+	body_start = data;
+	v[3].iov_base = TNT_SBUF_DATA(key);
+	v[3].iov_len  = TNT_SBUF_SIZE(key);
+	data = mp_encode_uint(data, TNT_TUPLE);
+	v[4].iov_base = (void *)body_start;
+	v[4].iov_len  = data - body_start;
+	body_start = data;
+	v[5].iov_base = TNT_SBUF_DATA(ops);
+	v[5].iov_len  = TNT_SBUF_SIZE(ops);
+
+	size_t package_len = 0;
+	for (int i = 1; i < v_sz; ++i)
+		package_len += v[i].iov_len;
+	char len_prefix[9];
+	char *len_end = mp_encode_luint32(len_prefix, package_len);
+	v[0].iov_base = len_prefix;
+	v[0].iov_len = len_end - len_prefix;
+	return s->writev(s, v, v_sz);
+}
+
+ssize_t
+tnt_upsert(struct tnt_stream *s, uint32_t space,
+	   struct tnt_stream *tuple, struct tnt_stream *ops)
+{
+	if (tnt_object_verify(tuple, MP_ARRAY))
+		return -1;
+	if (tnt_object_verify(ops, MP_ARRAY))
+		return -1;
+	struct tnt_iheader hdr;
+	struct iovec v[6]; int v_sz = 6;
+	char *data = NULL, *body_start = NULL;
+	encode_header(&hdr, TNT_OP_UPSERT, s->reqid++);
+	v[1].iov_base = (void *)hdr.header;
+	v[1].iov_len  = hdr.end - hdr.header;
+	char body[64]; body_start = body; data = body;
+
+	data = mp_encode_map(data, 3);
+	data = mp_encode_uint(data, TNT_SPACE);
+	data = mp_encode_uint(data, space);
+	data = mp_encode_uint(data, TNT_TUPLE);
+	v[2].iov_base = (void *)body_start;
+	v[2].iov_len  = data - body_start;
+	body_start = data;
+	v[3].iov_base = TNT_SBUF_DATA(tuple);
+	v[3].iov_len  = TNT_SBUF_SIZE(tuple);
+	data = mp_encode_uint(data, TNT_OPS);
+	v[4].iov_base = (void *)body_start;
+	v[4].iov_len  = data - body_start;
+	body_start = data;
+	v[5].iov_base = TNT_SBUF_DATA(ops);
+	v[5].iov_len  = TNT_SBUF_SIZE(ops);
+
+	size_t package_len = 0;
+	for (int i = 1; i < v_sz; ++i)
+		package_len += v[i].iov_len;
+	char len_prefix[9];
+	char *len_end = mp_encode_luint32(len_prefix, package_len);
+	v[0].iov_base = len_prefix;
+	v[0].iov_len = len_end - len_prefix;
+	return s->writev(s, v, v_sz);
+}
+
+static ssize_t tnt_update_op_len(char op) {
+	switch (op) {
+	case (TNT_UOP_ADDITION):
+	case (TNT_UOP_SUBSTRACT):
+	case (TNT_UOP_AND):
+	case (TNT_UOP_XOR):
+	case (TNT_UOP_OR):
+	case (TNT_UOP_DELETE):
+	case (TNT_UOP_INSERT):
+	case (TNT_UOP_ASSIGN):
+		return 3;
+	case (TNT_UOP_SPLICE):
+		return 5;
+	default:
+		return -1;
+	}
+}
+
+struct tnt_stream *tnt_update_container(struct tnt_stream *ops) {
+	ops = tnt_object(ops);
+	if (!ops) return NULL;
+	tnt_object_type(ops, TNT_SBO_SPARSE);
+	if (tnt_object_add_array(ops, 0) == -1) {
+		tnt_stream_free(ops);
+		return NULL;
+	}
+	return ops;
+}
+
+int tnt_update_container_close(struct tnt_stream *ops) {
+	struct tnt_sbuf_object *opob = TNT_SOBJ_CAST(ops);
+	opob->stack->size = ops->wrcnt - 1;
+	tnt_object_container_close(ops);
+	return 0;
+}
+
+int tnt_update_container_reset(struct tnt_stream *ops) {
+	tnt_object_reset(ops);
+	tnt_object_type(ops, TNT_SBO_SPARSE);
+	if (tnt_object_add_array(ops, 0) == -1) {
+		tnt_stream_free(ops);
+		return -1;
+	}
+	return 0;
+}
+
+static ssize_t
+tnt_update_op(struct tnt_stream *ops, char op, uint32_t fieldno,
+	      const char *opdata, size_t opdata_len) {
+	struct iovec v[2]; size_t v_sz = 2;
+	char body[64], *data; data = body;
+	data = mp_encode_array(data, tnt_update_op_len(op));
+	data = mp_encode_str(data, &op, 1);
+	data = mp_encode_uint(data, fieldno);
+	v[0].iov_base = body;
+	v[0].iov_len  = data - body;
+	v[1].iov_base = (void *)opdata;
+	v[1].iov_len  = opdata_len;
+
+	return ops->writev(ops, v, v_sz);
+}
+
+ssize_t
+tnt_update_bit(struct tnt_stream *ops, uint32_t fieldno, char op,
+	       uint64_t value) {
+	if (op != '&' && op != '^' && op != '|') return -1;
+	char body[10], *data; data = body;
+	data = mp_encode_uint(data, value);
+	return tnt_update_op(ops, op, fieldno, body, data - body);
+}
+
+ssize_t
+tnt_update_arith_int(struct tnt_stream *ops, uint32_t fieldno, char op,
+		     int64_t value) {
+	if (op != '+' && op != '-') return -1;
+	char body[10], *data; data = body;
+	if (value >= 0)
+		data = mp_encode_uint(data, value);
+	else
+		data = mp_encode_int(data, value);
+	return tnt_update_op(ops, op, fieldno, body, data - body);
+}
+
+ssize_t
+tnt_update_arith_float(struct tnt_stream *ops, uint32_t fieldno, char op,
+		       float value) {
+	if (op != '+' && op != '-') return -1;
+	char body[10], *data; data = body;
+	data = mp_encode_float(data, value);
+	return tnt_update_op(ops, op, fieldno, body, data - body);
+}
+
+ssize_t
+tnt_update_arith_double(struct tnt_stream *ops, uint32_t fieldno, char op,
+		        double value) {
+	if (op != '+' && op != '-') return -1;
+	char body[10], *data; data = body;
+	data = mp_encode_double(data, value);
+	return tnt_update_op(ops, op, fieldno, body, data - body);
+}
+
+ssize_t
+tnt_update_delete(struct tnt_stream *ops, uint32_t fieldno,
+		  uint32_t fieldcount) {
+	char body[10], *data; data = body;
+	data = mp_encode_uint(data, fieldcount);
+	return tnt_update_op(ops, '#', fieldno, body, data - body);
+}
+
+ssize_t
+tnt_update_insert(struct tnt_stream *ops, uint32_t fieldno,
+		  struct tnt_stream *val) {
+	if (tnt_object_verify(val, -1))
+		return -1;
+	return tnt_update_op(ops, '!', fieldno, TNT_SBUF_DATA(val),
+			     TNT_SBUF_SIZE(val));
+}
+
+ssize_t
+tnt_update_assign(struct tnt_stream *ops, uint32_t fieldno,
+		  struct tnt_stream *val) {
+	if (tnt_object_verify(val, -1))
+		return -1;
+	return tnt_update_op(ops, '=', fieldno, TNT_SBUF_DATA(val),
+			     TNT_SBUF_SIZE(val));
+}
+
+ssize_t
+tnt_update_splice(struct tnt_stream *ops, uint32_t fieldno,
+		  uint32_t position, uint32_t offset,
+		  const char *buffer, size_t buffer_len) {
+	size_t buf_size = mp_sizeof_uint(position) +
+		          mp_sizeof_uint(offset) +
+			  mp_sizeof_str(buffer_len);
+	char *buf = tnt_mem_alloc(buf_size), *data = NULL;
+	if (!buf) return -1;
+	data = buf;
+	data = mp_encode_uint(data, position);
+	data = mp_encode_uint(data, offset);
+	data = mp_encode_str(data, buffer, buffer_len);
+	ssize_t retval = tnt_update_op(ops, ':', fieldno, buf, buf_size);
+	tnt_mem_free(buf);
+	return retval;
+}