decimal: add support decimal type in msgpack

This patch provides decimal support for all space operations and as
function return result. Decimal type was introduced in Tarantool 2.2.
See more about decimal type in [1] and [2].

To use decimal with github.com/shopspring/decimal in msgpack, import
tarantool/decimal submodule.

1. https://www.tarantool.io/en/doc/latest/book/box/data_model/
2. https://www.tarantool.io/en/doc/latest/dev_guide/internals/msgpack_extensions/#the-decimal-type
3. https://github.com/douglascrockford/DEC64/blob/663f562a5f0621021b98bfdd4693571993316174/dec64_test.c#L62-L104
4. https://github.com/shopspring/decimal/blob/v1.3.1/decimal_test.go#L27-L64
5. https://github.com/tarantool/tarantool/blob/60fe9d14c1c7896aa7d961e4b68649eddb4d2d6c/test/unit/decimal.c#L154-L171

Lua snippet for encoding number to MsgPack representation:

local decimal = require('decimal')

local function mp_encode_dec(num)
    local dec = msgpack.encode(decimal.new(num))
    return dec:gsub('.', function (c)
        return string.format('%02x', string.byte(c))
    end)
end
print(mp_encode_dec(-12.34)) -- 0xd6010201234d

Follows up tarantool/tarantool#692
Closes #96

Author: ligurio

CHANGELOG.md

@@ -17,6 +17,7 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
 - Go modules support (#91)
 - queue-utube handling (#85)
 - Master discovery (#113)
+- Support decimal type in msgpack (#96)
 
 ### Fixed
 

Makefile

@@ -45,6 +45,12 @@ test-main:
 	go clean -testcache
 	go test . -v -p 1
 
+.PHONY: test-decimal
+test-decimal:
+	@echo "Running tests in decimal package"
+	go clean -testcache
+	go test ./decimal/ -v -p 1
+
 .PHONY: coverage
 coverage:
 	go clean -testcache

decimal/bcd.go

@@ -0,0 +1,212 @@
+// Package implements methods to encode and decode BCD.
+//
+// BCD (Binary-Coded Decimal) is a sequence of bytes representing decimal
+// digits of the encoded number (each byte has two decimal digits each encoded
+// using 4-bit nibbles), so byte >> 4 is the first digit and byte & 0x0f is the
+// second digit. The leftmost digit in the array is the most significant. The
+// rightmost digit in the array is the least significant.
+//
+// The first byte of the BCD array contains the first digit of the number,
+// represented as follows:
+//
+//     |  4 bits           |  4 bits           |
+//        = 0x                = the 1st digit
+//
+// (The first nibble contains 0 if the decimal number has an even number of
+// digits). The last byte of the BCD array contains the last digit of the
+// number and the final nibble, represented as follows:
+//
+//     |  4 bits           |  4 bits           |
+//        = the last digit    = nibble
+//
+// The final nibble represents the number's sign: 0x0a, 0x0c, 0x0e, 0x0f stand
+// for plus, 0x0b and 0x0d stand for minus.
+//
+// Examples:
+//
+// The decimal -12.34 will be encoded as 0xd6, 0x01, 0x02, 0x01, 0x23, 0x4d:
+//
+// |MP_EXT (fixext 4) | MP_DECIMAL | scale |  1   |  2,3 |  4 (minus) |
+// |       0xd6       |    0x01    | 0x02  | 0x01 | 0x23 | 0x4d       |
+//
+// The decimal 0.000000000000000000000000000000000010 will be encoded as
+// 0xc7, 0x03, 0x01, 0x24, 0x01, 0x0c:
+//
+// | MP_EXT (ext 8) | length | MP_DECIMAL | scale |  1   | 0 (plus) |
+// |      0xc7      |  0x03  |    0x01    | 0x24  | 0x01 | 0x0c     |
+//
+// See also:
+//
+// * MessagePack extensions https://www.tarantool.io/en/doc/latest/dev_guide/internals/msgpack_extensions/
+//
+// * An implementation in C language https://github.com/tarantool/decNumber/blob/master/decPacked.c
+//
+// TODO: BitReader https://go.dev/play/p/Wyr_K9YAro
+package decimal
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+var mapRuneToByteSign = map[rune]byte{
+	'+': 0x0a,
+	'-': 0x0b,
+}
+
+var isNegative = map[byte]bool{
+	0x0a: false,
+	0x0b: true,
+	0x0c: false,
+	0x0d: true,
+	0x0e: false,
+	0x0f: false,
+}
+
+// Convert string buffer to BCD Packed Decimal.
+//
+// The number is converted to a BCD packed decimal byte array, right aligned in
+// the BCD array, whose length is indicated by the second parameter. The final
+// 4-bit nibble in the array will be a sign nibble, 0x0a for "+" and 0x0b for
+// "-". Unused bytes and nibbles to the left of the number are set to 0. scale
+// is set to the scale of the number (this is the exponent, negated).
+func EncodeStringToBCD(buf string) ([]byte, error) {
+	sign := '+' // By default number is positive.
+	if res := strings.HasPrefix(buf, "-"); res == true {
+		sign = '-'
+	}
+
+	// Calculate a number of digits in the decimal number. Leading and
+	// trialing zeros do not count.
+	// Examples:
+	// 0.0000000000000001 - 1 digit
+	// 00012.34           - 4 digits
+	// 0.340              - 2 digits
+	s := strings.ReplaceAll(buf, "-", "") // Remove a sign.
+	s = strings.ReplaceAll(s, "+", "")    // Remove a sign.
+	s = strings.ReplaceAll(s, ".", "")    // Remove a dot.
+	s = strings.TrimRight(s, "0")         // Remove trailing zeros.
+	s = strings.TrimLeft(s, "0")          // Remove leading zeros.
+	c := len(s)
+
+	// The first nibble should contain 0, if the decimal number has an even
+	// number of digits. Therefore highNibble is false when decimal number
+	// is even.
+	highNibble := true
+	if c%2 == 0 {
+		highNibble = false
+	}
+	fmt.Println("c", c, "highNibble is", highNibble)
+	scale := 0 // By default decimal number is integer.
+	var byteBuf []byte
+	for i, ch := range buf {
+		// Skip leading zeros.
+		if (len(byteBuf) == 0) && ch == '0' {
+			continue
+		}
+		if (i == 0) && (ch == '-' || ch == '+') {
+			continue
+		}
+		// Calculate a number of digits after the decimal point.
+		// TODO: len(s) - strings.IndexAny(s, ".") - 1
+		if ch == '.' {
+			scale = len(buf) - i - 1
+			fmt.Println("Scale", scale)
+			continue
+		}
+		if !unicode.IsDigit(ch) {
+			return nil, fmt.Errorf("Symbol in position %d is not a digit: %c", i, ch)
+		}
+
+		d, err := strconv.Atoi(string(ch))
+		if err != nil {
+			return nil, fmt.Errorf("Failed to convert symbol '%c' to a digit: %s", ch, err)
+		}
+		digit := byte(d)
+		if highNibble == true {
+			// High nibble.
+			digit = digit << 4
+			byteBuf = append(byteBuf, digit)
+			highNibble = false
+		} else {
+			if len(byteBuf) == 0 {
+				byteBuf = make([]byte, 1)
+			}
+			// Low nibble.
+			lowByteIdx := len(byteBuf) - 1
+			byteBuf[lowByteIdx] = byteBuf[lowByteIdx] | digit
+			highNibble = true
+		}
+		fmt.Printf("DEBUG: idx == %d, buf %x\n", i, byteBuf)
+	}
+	fmt.Printf("DEBUG: Final buf %x\n", byteBuf)
+	if highNibble == true {
+		// Put a sign to a high nibble.
+		byteBuf = append(byteBuf, mapRuneToByteSign[sign])
+	} else {
+		// Put a sign to a low nibble.
+		lowByteIdx := len(byteBuf) - 1
+		byteBuf[lowByteIdx] = byteBuf[lowByteIdx] | mapRuneToByteSign[sign]
+	}
+	byteBuf = append([]byte{byte(scale)}, byteBuf...)
+
+	return byteBuf, nil
+}
+
+// Convert BCD Packed Decimal to a string buffer.
+//
+// The BCD packed decimal byte array, together with an associated scale, is
+// converted to a string. The BCD array is assumed full of digits, and must be
+// ended by a 4-bit sign nibble in the least significant four bits of the final
+// byte. The scale is used (negated) as the exponent of the decimal number.
+// Note that zeros may have a sign and/or a scale.
+func DecodeStringFromBCD(bcdBuf []byte) (string, error) {
+	const scaleIdx = 0 // Index of a byte with scale.
+	scale := int(bcdBuf[scaleIdx])
+	// Get a BCD buffer without a byte with scale.
+	bcdBuf = bcdBuf[scaleIdx+1:]
+	length := len(bcdBuf)
+	var digits []string
+	for i, bcdByte := range bcdBuf {
+		highNibble := int(bcdByte >> 4)
+		if !(len(digits) == 0 && highNibble == 0) || len(bcdBuf) == 1 {
+			digits = append(digits, strconv.Itoa(highNibble))
+		}
+		lowNibble := int(bcdByte & 0x0f)
+		if !(len(digits) == 0 && lowNibble == 0) && i != length-1 {
+			digits = append(digits, strconv.Itoa(int(lowNibble)))
+		}
+	}
+
+	// Add missing zeros when scale is less than current length.
+	l := len(digits)
+	if scale >= l {
+		var zeros []string
+		for i := 0; i <= scale-l; i++ {
+			zeros = append(zeros, "0")
+			digits = append(zeros, digits...)
+		}
+	}
+
+	// Add a dot when number is fractional.
+	if scale != 0 {
+		idx := len(digits) - scale
+		digits = append(digits, "X")       // [1 2 3 X]
+		copy(digits[idx:], digits[idx-1:]) // [1 2 2 3]
+		digits[idx] = "."                  // [1 . 2 3]
+	}
+
+	// Add a sign, it is encoded in a low nibble of a last byte.
+	lastByte := bcdBuf[length-1]
+	sign := lastByte & 0x0f
+	if isNegative[sign] {
+		digits = append([]string{"-"}, digits...)
+	}
+
+	// Merge slice to a single string.
+	str := strings.Join(digits, "")
+
+	return str, nil
+}

decimal/config.lua

@@ -0,0 +1,41 @@
+local decimal = require('decimal')
+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 decimal_msgpack_supported = pcall(msgpack.encode, decimal.new(1))
+if not decimal_msgpack_supported then
+    error('Decimal unsupported, use Tarantool 2.2 or newer')
+end
+
+local s = box.schema.space.create('testDecimal', {
+    id = 524,
+    if_not_exists = true,
+})
+s:create_index('primary', {
+    type = 'TREE',
+    parts = {
+        {
+            field = 1,
+            type = 'decimal',
+        },
+    },
+    if_not_exists = true
+})
+s:truncate()
+
+box.schema.user.grant('test', 'read,write', 'space', 'testDecimal', { if_not_exists = true })
+
+-- Set listen only when every other thing is configured.
+box.cfg{
+    listen = os.getenv("TEST_TNT_LISTEN"),
+}
+
+require('console').start()

decimal/decimal.go

@@ -0,0 +1,70 @@
+// Package with support of Tarantool's decimal data type.
+//
+// Decimal data type supported in Tarantool since 2.2.
+//
+// Since: 1.6
+//
+// See also:
+//
+// * Tarantool MessagePack extensions https://www.tarantool.io/en/doc/latest/dev_guide/internals/msgpack_extensions/#the-decimal-type
+//
+// * Tarantool data model https://www.tarantool.io/en/doc/latest/book/box/data_model/
+//
+// * Tarantool issue for support decimal type https://github.com/tarantool/tarantool/issues/692
+package decimal
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/shopspring/decimal"
+	"gopkg.in/vmihailenco/msgpack.v2"
+)
+
+// Decimal external type.
+const decimal_extId = 1
+
+func encodeDecimal(e *msgpack.Encoder, v reflect.Value) error {
+	number := v.Interface().(decimal.Decimal)
+	strBuf := number.String()
+	bcdBuf, err := EncodeStringToBCD(strBuf)
+	if err != nil {
+		return fmt.Errorf("msgpack: can't encode string (%s) to a BCD buffer: %w", strBuf, err)
+	}
+	if _, err = e.Writer().Write(bcdBuf); err != nil {
+		return fmt.Errorf("msgpack: can't write bytes to encoder writer: %w", err)
+	}
+
+	return nil
+}
+
+func decodeDecimal(d *msgpack.Decoder, v reflect.Value) error {
+	// On attempt to decode MessagePack buffer c7030100088c (88) msgpack
+	// pass 00088a to decodeDecimal(). length field (03) is unavailable in
+	// function body.
+	// FIXME: works with -12.34 only.
+	var bytesCount int = 4
+	b := make([]byte, bytesCount)
+
+	_, err := d.Buffered().Read(b)
+	if err != nil {
+		return fmt.Errorf("msgpack: can't read bytes on decimal decode: %w", err)
+	}
+	digits, err := DecodeStringFromBCD(b)
+	if err != nil {
+		return fmt.Errorf("msgpack: can't decode string from BCD buffer (%x): %w", b, err)
+	}
+	dec, err := decimal.NewFromString(digits)
+	if err != nil {
+		return fmt.Errorf("msgpack: can't encode string (%s) to a decimal number: %w", digits, err)
+	}
+
+	v.Set(reflect.ValueOf(dec))
+
+	return nil
+}
+
+func init() {
+	msgpack.Register(reflect.TypeOf((*decimal.Decimal)(nil)).Elem(), encodeDecimal, decodeDecimal)
+	msgpack.RegisterExt(decimal_extId, (*decimal.Decimal)(nil))
+}