sql: add minimal sql support

This patch adds the support of SQL in connector.
Added support of positional and named arguments.
Added ExecuteTyped() method for use with custom
packing/unpacking for a type.
Added all required constants to const.go for encoding SQL
in msgpack and decoding response.

Fixes #62

Author: vr009

connector.go

@@ -17,6 +17,7 @@ type Connector interface {
 	Call(functionName string, args interface{}) (resp *Response, err error)
 	Call17(functionName string, args interface{}) (resp *Response, err error)
 	Eval(expr string, args interface{}) (resp *Response, err error)
+	Execute(expr string, args interface{}) (resp *Response, err error)
 
 	GetTyped(space, index interface{}, key interface{}, result interface{}) (err error)
 	SelectTyped(space, index interface{}, offset, limit, iterator uint32, key interface{}, result interface{}) (err error)

const.go

@@ -11,6 +11,7 @@ const (
 	EvalRequest      = 8
 	UpsertRequest    = 9
 	Call17Request    = 10
+	ExecuteRequest   = 11
 	PingRequest      = 64
 	SubscribeRequest = 66
 
@@ -29,6 +30,19 @@ const (
 	KeyDefTuple     = 0x28
 	KeyData         = 0x30
 	KeyError        = 0x31
+	KeyMetaData     = 0x32
+	KeySQLText      = 0x40
+	KeySQLBind      = 0x41
+	KeySQLInfo      = 0x42
+
+	KeyFieldName               = 0x00
+	KeyFieldType               = 0x01
+	KeyFieldColl               = 0x02
+	KeyFieldIsNullable         = 0x03
+	KeyIsAutoincrement         = 0x04
+	KeyFieldSpan               = 0x05
+	KeySQLInfoRowCount         = 0x00
+	KeySQLInfoAutoincrementIds = 0x01
 
 	// https://github.com/fl00r/go-tarantool-1.6/issues/2
 
@@ -49,4 +63,6 @@ const (
 	OkCode            = uint32(0)
 	ErrorCodeBit      = 0x8000
 	PacketLengthBytes = 5
+	ErSpaceExistsCode = 0xa
+	IteratorCode      = 0x14
 )

multi/multi.go

@@ -340,6 +340,13 @@ func (connMulti *ConnectionMulti) Eval(expr string, args interface{}) (resp *tar
 	return connMulti.getCurrentConnection().Eval(expr, args)
 }
 
+// Execute passes sql expression to Tarantool for execution.
+//
+// Since 1.6.0
+func (connMulti *ConnectionMulti) Execute(expr string, args interface{}) (resp *tarantool.Response, err error) {
+	return connMulti.getCurrentConnection().Execute(expr, args)
+}
+
 // GetTyped performs select (with limit = 1 and offset = 0) to box space and
 // fills typed result.
 func (connMulti *ConnectionMulti) GetTyped(space, index interface{}, key interface{}, result interface{}) (err error) {

request.go

@@ -2,6 +2,8 @@ package tarantool
 
 import (
 	"errors"
+	"reflect"
+	"strings"
 	"time"
 
 	"gopkg.in/vmihailenco/msgpack.v2"
@@ -120,6 +122,14 @@ func (conn *Connection) Eval(expr string, args interface{}) (resp *Response, err
 	return conn.EvalAsync(expr, args).Get()
 }
 
+// Execute passes sql expression to Tarantool for execution.
+//
+// It is equal to conn.ExecuteAsync(expr, args).Get().
+// Since 1.6.0
+func (conn *Connection) Execute(expr string, args interface{}) (resp *Response, err error) {
+	return conn.ExecuteAsync(expr, args).Get()
+}
+
 // single used for conn.GetTyped for decode one tuple.
 type single struct {
 	res   interface{}
@@ -212,6 +222,16 @@ func (conn *Connection) EvalTyped(expr string, args interface{}, result interfac
 	return conn.EvalAsync(expr, args).GetTyped(result)
 }
 
+// ExecuteTyped passes sql expression to Tarantool for execution.
+//
+// In addition to error returns sql info and columns meta data
+// Since 1.6.0
+func (conn *Connection) ExecuteTyped(expr string, args interface{}, result interface{}) (SQLInfo, []ColumnMetaData, error) {
+	fut := conn.ExecuteAsync(expr, args)
+	err := fut.GetTyped(&result)
+	return fut.resp.SQLInfo, fut.resp.MetaData, err
+}
+
 // SelectAsync sends select request to Tarantool and returns Future.
 func (conn *Connection) SelectAsync(space, index interface{}, offset, limit, iterator uint32, key interface{}) *Future {
 	future := conn.newFuture(SelectRequest)
@@ -346,9 +366,111 @@ func (conn *Connection) EvalAsync(expr string, args interface{}) *Future {
 	})
 }
 
+// ExecuteAsync sends a sql expression for execution and returns Future.
+// Since 1.6.0
+func (conn *Connection) ExecuteAsync(expr string, args interface{}) *Future {
+	future := conn.newFuture(ExecuteRequest)
+	return future.send(conn, func(enc *msgpack.Encoder) error {
+		enc.EncodeMapLen(2)
+		enc.EncodeUint64(KeySQLText)
+		enc.EncodeString(expr)
+		enc.EncodeUint64(KeySQLBind)
+		return encodeSQLBind(enc, args)
+	})
+}
+
+// KeyValueBind is a type for encoding named SQL parameters
+type KeyValueBind struct {
+	Key   string
+	Value interface{}
+}
+
 //
 // private
 //
+func encodeSQLBind(enc *msgpack.Encoder, from interface{}) error {
+	// internal function for encoding single map in msgpack
+	encodeKeyVal := func(enc *msgpack.Encoder, key string, val reflect.Value) error {
+		if err := enc.EncodeMapLen(1); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(key); err != nil {
+			return err
+		}
+		if err := enc.EncodeValue(val); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	encodeNamedFromMap := func(val reflect.Value) error {
+		if err := enc.EncodeSliceLen(val.Len()); err != nil {
+			return err
+		}
+		it := val.MapRange()
+		for it.Next() {
+			k := ":" + it.Key().String()
+			v := it.Value()
+			if err := encodeKeyVal(enc, k, v); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	encodeNamedFromStruct := func(val reflect.Value) error {
+		if err := enc.EncodeSliceLen(val.NumField()); err != nil {
+			return err
+		}
+		for i := 0; i < val.NumField(); i++ {
+			key := val.Type().Field(i).Name
+			k := ":" + strings.ToLower(key)
+			v := reflect.ValueOf(from).FieldByName(key)
+			if err := encodeKeyVal(enc, k, v); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	val := reflect.ValueOf(from)
+	switch val.Kind() {
+	case reflect.Map:
+		if err := encodeNamedFromMap(val); err != nil {
+			return err
+		}
+	case reflect.Struct:
+		if err := encodeNamedFromStruct(val); err != nil {
+			return err
+		}
+	case reflect.Slice, reflect.Array:
+		if err := enc.EncodeSliceLen(val.Len()); err != nil {
+			return err
+		}
+		castedSlice, ok := from.([]interface{})
+		if !ok {
+			castedKVSlice := from.([]KeyValueBind)
+			for _, v := range castedKVSlice {
+				castedSlice = append(castedSlice, v)
+			}
+		}
+
+		for i := 0; i < len(castedSlice); i++ {
+			if kvb, ok := castedSlice[i].(KeyValueBind); ok {
+				k := ":" + kvb.Key
+				v := kvb.Value
+				if err := encodeKeyVal(enc, k, reflect.ValueOf(v)); err != nil {
+					return err
+				}
+			} else {
+				if err := enc.Encode(castedSlice[i]); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
 
 func (fut *Future) pack(h *smallWBuf, enc *msgpack.Encoder, body func(*msgpack.Encoder) error) (err error) {
 	rid := fut.requestId

response.go

@@ -9,10 +9,94 @@ import (
 type Response struct {
 	RequestId uint32
 	Code      uint32
-	Error     string // Error message.
-	// Data contains deserialized data for untyped requests.
-	Data []interface{}
-	buf  smallBuf
+	Error     string // error message
+	// Data contains deserialized data for untyped requests
+	Data     []interface{}
+	MetaData []ColumnMetaData
+	SQLInfo  SQLInfo
+	buf      smallBuf
+}
+
+type ColumnMetaData struct {
+	FieldName            string
+	FieldType            string
+	FieldCollation       string
+	FieldIsNullable      bool
+	FieldIsAutoincrement bool
+	FieldSpan            string
+}
+
+type SQLInfo struct {
+	AffectedCount        uint64
+	InfoAutoincrementIds []uint64
+}
+
+func (meta *ColumnMetaData) DecodeMsgpack(d *msgpack.Decoder) error {
+	var err error
+	var l int
+	if l, err = d.DecodeMapLen(); err != nil {
+		return err
+	}
+	if l == 0 {
+		return fmt.Errorf("map len doesn't match: %d", l)
+	}
+	for i := 0; i < l; i++ {
+		var mk uint64
+		var mv interface{}
+		if mk, err = d.DecodeUint64(); err != nil {
+			return fmt.Errorf("failed to decode meta data")
+		}
+		if mv, err = d.DecodeInterface(); err != nil {
+			return fmt.Errorf("failed to decode meta data")
+		}
+		switch mk {
+		case KeyFieldName:
+			meta.FieldName = mv.(string)
+		case KeyFieldType:
+			meta.FieldType = mv.(string)
+		case KeyFieldColl:
+			meta.FieldCollation = mv.(string)
+		case KeyFieldIsNullable:
+			meta.FieldIsNullable = mv.(bool)
+		case KeyIsAutoincrement:
+			meta.FieldIsAutoincrement = mv.(bool)
+		case KeyFieldSpan:
+			meta.FieldSpan = mv.(string)
+		default:
+			return fmt.Errorf("failed to decode meta data")
+		}
+	}
+	return nil
+}
+
+func (info *SQLInfo) DecodeMsgpack(d *msgpack.Decoder) error {
+	var err error
+	var l int
+	if l, err = d.DecodeMapLen(); err != nil {
+		return err
+	}
+	if l == 0 {
+		return fmt.Errorf("map len doesn't match")
+	}
+	for i := 0; i < l; i++ {
+		var mk uint64
+		if mk, err = d.DecodeUint64(); err != nil {
+			return fmt.Errorf("failed to decode meta data")
+		}
+		switch mk {
+		case KeySQLInfoRowCount:
+			if info.AffectedCount, err = d.DecodeUint64(); err != nil {
+				return fmt.Errorf("failed to decode meta data")
+			}
+		case KeySQLInfoAutoincrementIds:
+			if err = d.Decode(&info.InfoAutoincrementIds); err != nil {
+				return fmt.Errorf("failed to decode meta data")
+			}
+		default:
+			return fmt.Errorf("failed to decode meta data")
+		}
+	}
+	return nil
 }
 
 func (resp *Response) smallInt(d *msgpack.Decoder) (i int, err error) {
@@ -86,6 +170,14 @@ func (resp *Response) decodeBody() (err error) {
 				if resp.Error, err = d.DecodeString(); err != nil {
 					return err
 				}
+			case KeySQLInfo:
+				if err = d.Decode(&resp.SQLInfo); err != nil {
+					return err
+				}
+			case KeyMetaData:
+				if err = d.Decode(&resp.MetaData); err != nil {
+					return err
+				}
 			default:
 				if err = d.Skip(); err != nil {
 					return err
@@ -121,6 +213,14 @@ func (resp *Response) decodeBodyTyped(res interface{}) (err error) {
 				if resp.Error, err = d.DecodeString(); err != nil {
 					return err
 				}
+			case KeySQLInfo:
+				if err = d.Decode(&resp.SQLInfo); err != nil {
+					return err
+				}
+			case KeyMetaData:
+				if err = d.Decode(&resp.MetaData); err != nil {
+					return err
+				}
 			default:
 				if err = d.Skip(); err != nil {
 					return err