Support datetime type in msgpack

This patch provides datetime support for all space operations and as
function return result. Datetime type was introduced in Tarantool 2.10.
See more in issue [1].

1. tarantool/tarantool#5946

Closes #118

Author: ligurio

README.md

@@ -698,9 +698,11 @@ and call
 ```bash
 go clean -testcache && go test -v
 ```
-Use the same for main `tarantool` package and `queue` and `uuid` subpackages.
+Use the same for main `tarantool` package, `queue`, `uuid` and `datetime` subpackages.
 `uuid` tests require
 [Tarantool 2.4.1 or newer](https://github.com/tarantool/tarantool/commit/d68fc29246714eee505bc9bbcd84a02de17972c5).
+`datetime` tests require
+[Tarantool 2.10 or newer](https://github.com/tarantool/tarantool/issues/5946).
 
 ## Alternative connectors
 

datetime/config.lua

@@ -0,0 +1,44 @@
+local datetime = require('datetime')
+local msgpack = require('msgpack')
+
+-- Do not set listen for now so connector won't be
+-- able to send requests until everything is configured.
+box.cfg{
+    work_dir = os.getenv("TEST_TNT_WORK_DIR"),
+}
+
+box.schema.user.create('test', { password = 'test' , if_not_exists = true })
+box.schema.user.grant('test', 'execute', 'universe', nil, { if_not_exists = true })
+
+local datetime_msgpack_supported = pcall(msgpack.encode, datetime.new())
+if not datetime_msgpack_supported then
+    error('Datetime unsupported, use Tarantool 2.10 or newer')
+end
+
+local s = box.schema.space.create('testDatetime', {
+    id = 524,
+    if_not_exists = true,
+})
+s:create_index('primary', {
+    type = 'TREE',
+    parts = {
+        {
+            field = 1,
+            type = 'datetime',
+        },
+    },
+    if_not_exists = true
+})
+s:truncate()
+
+box.schema.user.grant('test', 'read,write', 'space', 'testDatetime', { if_not_exists = true })
+box.schema.user.grant('guest', 'read,write', 'space', 'testDatetime', { if_not_exists = true })
+
+s:insert({ datetime.new() })
+
+-- Set listen only when every other thing is configured.
+box.cfg{
+    listen = os.getenv("TEST_TNT_LISTEN"),
+}
+
+require('console').start()

datetime/datetime.go

@@ -0,0 +1,96 @@
+package datetime
+
+import (
+	"fmt"
+	"reflect"
+
+	"encoding/binary"
+
+	"gopkg.in/vmihailenco/msgpack.v2"
+)
+
+// Datetime external type
+// Supported since Tarantool 2.10. See more details in issue
+// https://github.com/tarantool/tarantool/issues/5946
+
+const Datetime_extId = 4
+
+const (
+	SEC_LEN       = 8
+	NSEC_LEN      = 4
+	TZ_OFFSET_LEN = 2
+	TZ_INDEX_LEN  = 2
+)
+
+/**
+ * datetime structure keeps number of seconds and
+ * nanoseconds since Unix Epoch.
+ * Time is normalized by UTC, so time-zone offset
+ * is informative only.
+ */
+type EventTime struct {
+	// Seconds since Epoch
+	Seconds int64
+	// Nanoseconds, if any
+	Nsec int32
+	// Offset in minutes from UTC
+	TZOffset int16
+	// Olson timezone id
+	TZIndex int16
+}
+
+func encodeDatetime(e *msgpack.Encoder, v reflect.Value) error {
+	tm := v.Interface().(EventTime)
+
+	var payloadLen = 8
+	if tm.Nsec != 0 || tm.TZOffset != 0 || tm.TZIndex != 0 {
+		payloadLen = 16
+	}
+
+	b := make([]byte, payloadLen)
+	binary.LittleEndian.PutUint64(b, uint64(tm.Seconds))
+
+	if payloadLen == 16 {
+		binary.LittleEndian.PutUint32(b[NSEC_LEN:], uint32(tm.Nsec))
+		binary.LittleEndian.PutUint16(b[TZ_OFFSET_LEN:], uint16(tm.TZOffset))
+		binary.LittleEndian.PutUint16(b[TZ_INDEX_LEN:], uint16(tm.TZIndex))
+	}
+
+	_, err := e.Writer().Write(b)
+	if err != nil {
+		return fmt.Errorf("msgpack: can't write bytes to encoder writer: %w", err)
+	}
+
+	return nil
+}
+
+func decodeDatetime(d *msgpack.Decoder, v reflect.Value) error {
+	var tm EventTime
+	var err error
+
+	tm.Seconds, err = d.DecodeInt64()
+	if err != nil {
+		return fmt.Errorf("msgpack: can't read bytes on datetime seconds decode: %w", err)
+	}
+
+	tm.Nsec, err = d.DecodeInt32()
+	if err == nil {
+            tm.TZOffset, err = d.DecodeInt16()
+            if err != nil {
+                    return fmt.Errorf("msgpack: can't read bytes on datetime tzoffset decode: %w", err)
+            }
+            tm.TZIndex, err = d.DecodeInt16()
+            if err != nil {
+                    return fmt.Errorf("msgpack: can't read bytes on datetime tzindex decode: %w", err)
+            }
+        }
+
+	v.Set(reflect.ValueOf(tm))
+
+	return nil
+}
+
+func init() {
+	msgpack.Register(reflect.TypeOf((*EventTime)(nil)).Elem(), encodeDatetime, decodeDatetime)
+	msgpack.RegisterExt(Datetime_extId, (*EventTime)(nil))
+}

datetime/datetime_test.go

@@ -0,0 +1,193 @@
+package datetime_test
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"testing"
+	"time"
+
+	. "github.com/tarantool/go-tarantool"
+	"github.com/tarantool/go-tarantool/datetime"
+	"github.com/tarantool/go-tarantool/test_helpers"
+	"gopkg.in/vmihailenco/msgpack.v2"
+)
+
+// There is no way to skip tests in testing.M,
+// so we use this variable to pass info
+// to each testing.T that it should skip.
+var isDatetimeSupported = false
+
+var server = "127.0.0.1:3013"
+var opts = Opts{
+	Timeout: 500 * time.Millisecond,
+	User:    "test",
+	Pass:    "test",
+}
+
+var space = "testDatetime"
+var index = "primary"
+
+type TupleDatetime struct {
+	tm datetime.EventTime
+}
+
+func (t *TupleDatetime) DecodeMsgpack(d *msgpack.Decoder) error {
+	var err error
+	var l int
+	if l, err = d.DecodeSliceLen(); err != nil {
+		return err
+	}
+	if l != 1 {
+		return fmt.Errorf("array len doesn't match: %d", l)
+	}
+
+	res, err := d.DecodeInterface()
+	if err != nil {
+		return err
+	}
+	t.tm = res.(datetime.EventTime)
+
+	return nil
+}
+
+func connectWithValidation(t *testing.T) *Connection {
+	conn, err := Connect(server, opts)
+	if err != nil {
+		t.Errorf("Failed to connect: %s", err.Error())
+	}
+	if conn == nil {
+		t.Errorf("conn is nil after Connect")
+	}
+	return conn
+}
+
+func tupleValueIsDatetime(t *testing.T, tuples []interface{}, tm datetime.EventTime) {
+	if tpl, ok := tuples[0].([]interface{}); !ok {
+		t.Errorf("Unexpected return value body")
+	} else {
+		if len(tpl) != 1 {
+			t.Errorf("Unexpected return value body (tuple len)")
+		}
+		if val, ok := tpl[0].(datetime.EventTime); !ok || val != tm {
+			t.Errorf("Unexpected return value body (tuple 0 field)")
+		}
+	}
+}
+
+func BytesToString(data []byte) string {
+	return string(data[:])
+}
+
+func TestSelect(t *testing.T) {
+	if isDatetimeSupported == false {
+		t.Skip("Skipping test for Tarantool without decimanl support in msgpack")
+	}
+
+	conn := connectWithValidation(t)
+	defer conn.Close()
+
+	tm := datetime.EventTime{0, 0, 0, 0}
+
+	var offset uint32 = 0
+	var limit uint32 = 1
+	resp, errSel := conn.Select(space, index, offset, limit, IterEq, []interface{}{tm})
+	if errSel != nil {
+		t.Errorf("Datetime select failed: %s", errSel.Error())
+	}
+	if resp == nil {
+		t.Errorf("Response is nil after Select")
+	}
+	tupleValueIsDatetime(t, resp.Data, tm)
+
+	var tuples []TupleDatetime
+	errTyp := conn.SelectTyped(space, index, 0, 1, IterEq, []interface{}{tm}, &tuples)
+	if errTyp != nil {
+		t.Errorf("Failed to SelectTyped: %s", errTyp.Error())
+	}
+	if len(tuples) != 1 {
+		t.Errorf("Result len of SelectTyped != 1")
+	}
+	if tuples[0].tm != tm {
+		t.Errorf("Bad value loaded from SelectTyped: %d", tuples[0].tm.Seconds)
+	}
+}
+
+func TestReplace(t *testing.T) {
+        t.Skip("Not imeplemented")
+
+	if isDatetimeSupported == false {
+		t.Skip("Skipping test for Tarantool without decimal support in msgpack")
+	}
+
+	conn := connectWithValidation(t)
+	defer conn.Close()
+
+	/*
+		number, err := decimal.NewFromString("-12.34")
+		if err != nil {
+			t.Errorf("Failed to prepare test decimal: %s", err)
+		}
+
+		respRep, errRep := conn.Replace(space, []interface{}{number})
+		if errRep != nil {
+			t.Errorf("Decimal replace failed: %s", errRep)
+		}
+		if respRep == nil {
+			t.Errorf("Response is nil after Replace")
+		}
+		tupleValueIsDatetime(t, respRep.Data, number)
+
+		respSel, errSel := conn.Select(space, index, 0, 1, IterEq, []interface{}{number})
+		if errSel != nil {
+			t.Errorf("Decimal select failed: %s", errSel)
+		}
+		if respSel == nil {
+			t.Errorf("Response is nil after Select")
+		}
+		tupleValueIsDatetime(t, respSel.Data, number)
+	*/
+}
+
+// runTestMain is a body of TestMain function
+// (see https://pkg.go.dev/testing#hdr-Main).
+// Using defer + os.Exit is not works so TestMain body
+// is a separate function, see
+// https://stackoverflow.com/questions/27629380/how-to-exit-a-go-program-honoring-deferred-calls
+func runTestMain(m *testing.M) int {
+	isLess, err := test_helpers.IsTarantoolVersionLess(2, 2, 0)
+	if err != nil {
+		log.Fatalf("Failed to extract Tarantool version: %s", err)
+	}
+
+	if isLess {
+		log.Println("Skipping datetime tests...")
+		isDatetimeSupported = false
+		return m.Run()
+	} else {
+		isDatetimeSupported = true
+	}
+
+	instance, err := test_helpers.StartTarantool(test_helpers.StartOpts{
+		InitScript:   "config.lua",
+		Listen:       server,
+		WorkDir:      "work_dir",
+		User:         opts.User,
+		Pass:         opts.Pass,
+		WaitStart:    100 * time.Millisecond,
+		ConnectRetry: 3,
+		RetryTimeout: 500 * time.Millisecond,
+	})
+	defer test_helpers.StopTarantoolWithCleanup(instance)
+
+	if err != nil {
+		log.Fatalf("Failed to prepare test Tarantool: %s", err)
+	}
+
+	return m.Run()
+}
+
+func TestMain(m *testing.M) {
+	code := runTestMain(m)
+	os.Exit(code)
+}