Is there support of built-in UUID type?

[pashinin]

How can I insert uuid field from Golang?

[funny-falcon]

Do you mean tarantool/tarantool@d68fc29 ?

Certainly one could introduce such type by hands with such ext encoding.

I'll think about soon.

[pashinin]

Yes

and it is now possible to insert UUIDs into spaces, but only into unindexed fields

and I wanted to insert into an indexed UUID field.

Edit: can you give an example of how to do it?

[Totktonada]

2.4.0-182-gd68fc2924 allows to insert an UUID value into an unindexed field, but 2.4.0-183-gb238def80 enables support of indexing of such values.

[pashinin]

@Totktonada fine. I do not understand what to pass to "insert".

Example:

// insert new tuple { 10, 1 }
resp, err = client.Insert(spaceNo, []interface{}{uint(10), 1})
// or
resp, err = client.Insert("test", []interface{}{uint(10), 1})

How to insert UUID:

resp, err = client.Insert("test", []interface{}{?????-????-????-??????, 1})

I tried:

"github.com/satori/go.uuid"

uuid.NewV4().String(),
// uuid.NewV4().Bytes(),
// uuid.NewV4(),

[funny-falcon]

Type should be registered in messagepack library.
See "Old way to to register types": https://github.com/tarantool/go-tarantool#custom-unpacking-and-typed-selects-and-function-calls

[pashinin]

You better know in what format it should be. Look at this please:

First I wirte MP_EXT, then MP_UUID and then bytes of UUID but something is wrong.

func encodeUUID(e *msgpack.Encoder, v reflect.Value) error {
	m := v.Interface().(uuid.UUID)
	// MP_EXT = 10
	if err := e.EncodeUint8(10); err != nil {
		return err
	}

	// MP_UUID = 2
	if err := e.EncodeUint8(2); err != nil {
		return err
	}

	if err := e.EncodeBytes(m.Bytes()); err != nil {
		return err
	}

	return nil
}

Have this error now:

Invalid MsgPack - packet body (0x14)

[eaglemoor]

Why u can't use uuid as string ?

[funny-falcon]

Sorry, but I don't understand your code. It doesn't coherent with messagepack specification

It seems vmihailenko's msgpack defines special way to register EXT types:
https://github.com/vmihailenco/msgpack/blob/v2.9.1/ext.go#L26
And then define encoder with format like https://github.com/tarantool/tarantool/blob/master/src/lib/uuid/mp_uuid.c#L42-L74

[funny-falcon]

But looks like it still will be decoded in a strange way in a generic result:
https://github.com/vmihailenco/msgpack/blob/v2.9.1/ext_test.go#L112

[AmsTaFFix]

hi all, we found a way to send uuid to tarantool with vmihailenco/msgpack.v2

Library: https://github.com/citilinkru/uuid-msgpack

@pashinin
Your example will not work because of method EncodeBytes will always add len of array first, so you get additional 2 bytes + 16 bytes and it's invalid msgpack.

Update msgpack and use code below

app.lua

box.cfg({
    listen = 3301,
    memtx_memory=128 * 1024 * 1024,
    read_only=false,
    log_level=2,
    log_format='json',
})

box.once('bootstrap', function()
    box.schema.user.create('test_user', { password = 'test_password' })
    box.schema.user.grant('test_user', 'read,write,execute', 'universe')
end)

local uuid = require("uuid")
local log = require("log")
api = {}
api.test = function(id)
    log.error("is uuid " .. tostring(uuid.is_uuid(id)))
    log.error("type is " .. type(id))
    log.error("id is " .. id:str())

    return id
end

main.go prototype

package main

import (
	"github.com/google/uuid"
	"github.com/tarantool/go-tarantool"
	"gopkg.in/vmihailenco/msgpack.v2"
	"log"
	"reflect"
)

const extId = 2

func init() {
	msgpack.Register(reflect.TypeOf((*uuid.UUID)(nil)).Elem(),
		func(e *msgpack.Encoder, v reflect.Value,) error {
			id := v.Interface().(uuid.UUID)
			bytes, err := id.MarshalBinary()
			if err != nil {
				return err
			}
			_, err = e.Writer().Write(bytes)
			if err != nil {
				return err
			}

			return nil
		},
		func(d *msgpack.Decoder, v reflect.Value) error {
			bytes := make([]byte, 18)
			_, err := d.Buffered().Read(bytes)
			if err != nil {
				return fmt.Errorf("can't read bytes: %w", err)
			}

			if bytes[0] != codes.FixExt16 {
				return fmt.Errorf("wrong ext len '%d'", bytes[0])
			}

			if bytes[1] != extId {
				return fmt.Errorf("wrong ext id '%d'", bytes[1])
			}

			id, err := uuid.FromBytes(bytes[2:])
			if err != nil {
				return fmt.Errorf("can't create uuid from bytes: %w", err)
			}

			v.Set(reflect.ValueOf(id))
			return nil
		},
	)
	msgpack.RegisterExt(extId, (*uuid.UUID)(nil))
}

func main() {
	tntClient, err := tarantool.Connect("localhost:3301", tarantool.Opts{User: "test_user", Pass: "test_password"})
	if err != nil {
		log.Fatalf("can't connect to tarantool: %s", err)
	}

	id := uuid.New()
	log.Printf("uuid as string is '%s'", id.String())
	resp, err := tntClient.Call17("api.test", []interface{}{id})
	if err != nil {
		log.Fatalf("can't call api.test: %s", err)
	}
	idFromTnt := (resp.Data[0]).(uuid.UUID)
	log.Printf("id returned from tnt as string is '%s'", idFromTnt)
}

[Maximilan4]

@AmsTaFFix I have a problem with your decoder example, when trying to decode map to struct. Then I have two additional fixed bytes too, as you described above. I add this before uuid.FromBytes(bytes):

if bytes.Equal(buffer[:2], []byte{0xd8, 0x2}) {
    twoMore := make([]byte, 2)
    _, err = d.Buffered().Read(twoMore)

    if err != nil {
	return err
    }
    bytes = append(bytes, twoMore...)
    bytes = bytes[2:]
}

[AmsTaFFix]

@Maximilan4 thank you, i fixed my example. And we created lib for that - https://github.com/citilinkru/uuid-msgpack