Support decimals

Follows up tarantool/tarantool#692

Author: ligurio

decimal/config.lua

@@ -0,0 +1,47 @@
+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 })
+box.schema.user.grant('guest', 'read,write', 'space', 'testDecimal', { if_not_exists = true })
+
+--s:insert({ decimal.new(-12.34) })
+--s:insert({ decimal.new(1) })
+--s:insert({ decimal.new(2) })
+--s:insert({ decimal.new(0) })
+
+-- 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,233 @@
+package decimal
+
+import (
+	"errors"
+	"strings"
+	"strconv"
+	"fmt"
+	"reflect"
+
+	"github.com/shopspring/decimal"
+	"gopkg.in/vmihailenco/msgpack.v2"
+)
+
+var (
+	ErrNumberIsNotADecimal = errors.New("Number is not a decimal.")
+	ErrWrongExponentaRange = errors.New("Exponenta has a wrong range.")
+)
+
+// Decimal external type
+// Supported since Tarantool 2.2. See more details in issue
+// https://github.com/tarantool/tarantool/issues/692
+//
+// Documentation:
+// https://www.tarantool.io/en/doc/latest/dev_guide/internals/msgpack_extensions/#the-decimal-type
+
+const Decimal_extId = 1
+
+func mpEncodeExtType(l int) byte {
+	if l == 1 {
+		return 0xd4
+	} else if l == 2 {
+		return 0xd5
+	} else if l > 2 && l <= 4 {
+		return 0xd6
+	} else if l > 4 && l <= 8 {
+		return 0xd7
+	} else if l > 8 && l <= 16 {
+		return 0xd8
+	}
+
+	panic("Unreachable")
+}
+
+var hex_sign = map[rune]byte{
+	'+': 0x0a,
+	'-': 0x0b,
+}
+
+var hex_digit = map[rune]byte{
+	'1': 0x1,
+	'2': 0x2,
+	'3': 0x3,
+	'4': 0x4,
+	'5': 0x5,
+	'6': 0x6,
+	'7': 0x7,
+	'8': 0x8,
+	'9': 0x9,
+	'0': 0x0,
+}
+
+func mpEncodeNumberToBCD(buf string) []byte {
+	scale := 0
+	sign := '+'
+	nibble_idx := 2 /* First nibble is for sign */
+	byte_buf := make([]byte, 1)
+	fmt.Println("To encode string:", buf)
+	for i, ch := range buf {
+		// TODO: ignore leading zeroes
+		fmt.Printf("index %d, ch %c\n", i, ch)
+		if (i == 0) && (ch == '-' || ch == '+') {
+			sign = ch
+			continue
+		}
+		if ch == '.' {
+			scale = len(buf) - i - 1
+			continue
+		}
+
+		digit := hex_digit[ch]
+		fmt.Printf("digit %x\n", digit)
+		high_half_nibble := nibble_idx%2 != 0
+		last_byte := len(byte_buf) - 1
+		if high_half_nibble {
+			digit = digit << 4
+			byte_buf = append(byte_buf, digit)
+		} else {
+			if nibble_idx == 2 {
+				byte_buf[0] = digit
+			} else {
+				byte_buf[last_byte] = byte_buf[last_byte] | digit
+			}
+		}
+		nibble_idx += 1
+		fmt.Printf("byte_buf %x\n", byte_buf)
+	}
+	if nibble_idx%2 != 0 {
+		byte_buf = append(byte_buf, hex_sign[sign])
+	} else {
+		last_byte := len(byte_buf) - 1
+		byte_buf[last_byte] = byte_buf[last_byte] | hex_sign[sign]
+	}
+	scale_hex := byte(0x02) /* FIXME */
+	byte_buf = append([]byte{scale_hex}, byte_buf...)
+	fmt.Println("Scale:", scale)
+	fmt.Printf("Final byte_buf %x\n", byte_buf)
+
+	return byte_buf
+}
+
+func encodeDecimal(e *msgpack.Encoder, v reflect.Value) error {
+	number := v.Interface().(decimal.Decimal)
+	dec := number.String()
+	bcd_buf := mpEncodeNumberToBCD(dec)
+	fmt.Printf("bcd_buf %x\n", bcd_buf)
+	fmt.Println("Encoded bytes (expected 1, 2, 1, 23, 4d):", bcd_buf)
+	_, err := e.Writer().Write(bcd_buf)
+	if err != nil {
+		return fmt.Errorf("msgpack: can't write bytes to encoder writer: %w", err)
+	}
+
+	return nil
+}
+
+func highHalfByte(b byte) byte {
+	return b >> 4
+}
+
+func lowHalfByte(b byte) byte {
+	return b & 0x0f
+}
+
+func isNegative(b byte) bool {
+	b = lowHalfByte(b)
+	switch b {
+	case 0x0a:
+		return false
+	case 0x0b:
+		return true
+	case 0x0c:
+		return false
+	case 0x0d:
+		return true
+	case 0x0e:
+		return false
+	case 0x0f:
+		return false
+	default:
+		panic("Sign is undefined")
+	}
+}
+
+
+// TODO: BitReader https://go.dev/play/p/Wyr_K9YAro
+// The first byte of the BCD array contains the first digit of the number.
+// 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 that represents the number's sign.
+func DecodeNumberFromBCD(bcd_buf []byte, length int, scale int32) ([]string, error) {
+	var digits []string
+	//for i, bcd_byte := range bcd_buf {
+	for i := 0; i < length; i++ {
+		bcd_byte := bcd_buf[i]
+		fmt.Printf("bcd_byte %x\n", bcd_byte)
+		if int(bcd_byte) == 0 {
+			continue
+		}
+		high := int(highHalfByte(bcd_byte))
+		if high != 0 {
+			digits = append(digits, strconv.Itoa(high))
+		}
+
+		low := int(lowHalfByte(bcd_byte))
+		if i != len(bcd_buf)-1 {
+			digits = append(digits, strconv.Itoa(low))
+		}
+		/* Make sure every digit is less than 9 */
+	}
+
+	digits = append(digits[:scale+1], digits[scale:]...)
+	digits[scale] = "."
+
+	last_byte := bcd_buf[length - 1]
+	fmt.Println("Last byte", last_byte)
+	if isNegative(last_byte) {
+		digits = append([]string{"-"}, digits...)
+	}
+
+	return digits, nil
+}
+
+
+func decodeDecimal(d *msgpack.Decoder, v reflect.Value) error {
+	var bytesCount int = 8
+	b := make([]byte, bytesCount)
+
+	n, err := d.Buffered().Read(b)
+	if err != nil {
+		return fmt.Errorf("msgpack: can't read bytes on datetime decode: %w", err)
+	}
+	fmt.Printf("decodeDecimal(): n %d, b %x\n", n, b)
+
+	// Maximum decimal digits taken by a decimal representation.
+	const DecimalMaxDigits = 38
+
+	// scale = -exponent, the exponent must be in range
+	// [ -DecimalMaxDigits; DecimalMaxDigits )
+	scale := int32(b[0])
+	fmt.Println("decodeDecimal() scale (exp 2)", scale)
+	if scale < -DecimalMaxDigits || scale >= DecimalMaxDigits {
+		return ErrWrongExponentaRange
+	}
+
+	bcd_buf := b[1:]
+	fmt.Printf("decodeDecimal(): bcd_buf %x\n", bcd_buf)
+	digits, err := DecodeNumberFromBCD(bcd_buf, 3, scale)
+	if err != nil {
+		return err
+	}
+	dec, err := decimal.NewFromString(strings.Join(digits, ""))
+	if err == nil {
+		return 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))
+}