sql: add minimal sql support

This patch adds the support of SQL in connector.
Added support of positional and named arguments.
Added all required constants in 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

@@ -294,6 +294,11 @@ func (connMulti *ConnectionMulti) Eval(expr string, args interface{}) (resp *tar
 	return connMulti.getCurrentConnection().Eval(expr, args)
 }
 
+// Execute passes sql expression to Tarantool for execution.
+func (connMulti *ConnectionMulti) Execute(expr string, args ...interface{}) (resp *tarantool.Response, err error) {
+	return connMulti.getCurrentConnection().Execute(expr, args...)
+}
+
 func (connMulti *ConnectionMulti) GetTyped(space, index interface{}, key interface{}, result interface{}) (err error) {
 	return connMulti.getCurrentConnection().GetTyped(space, index, key, result)
 }

request.go

@@ -2,6 +2,8 @@ package tarantool
 
 import (
 	"errors"
+	"reflect"
+	"strings"
 	"time"
 
 	"gopkg.in/vmihailenco/msgpack.v2"
@@ -120,6 +122,16 @@ 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().
+func (conn *Connection) Execute(expr string, args ...interface{}) (resp *Response, err error) {
+	if len(args) > 1 {
+		return conn.ExecuteAsync(expr, args).Get()
+	}
+	return conn.ExecuteAsync(expr, args[0]).Get()
+}
+
 // single used for conn.GetTyped for decode one tuple
 type single struct {
 	res   interface{}
@@ -346,9 +358,82 @@ func (conn *Connection) EvalAsync(expr string, args interface{}) *Future {
 	})
 }
 
+// ExecuteAsync sends a sql expression for execution and returns Future.
+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)
+	})
+}
+
 //
 // private
 //
+func encodeSQLBind(enc *msgpack.Encoder, from interface{}) error {
+	// internal function for encoding single map in msgpack
+	encodeKeyVal := func(enc *msgpack.Encoder, key, val reflect.Value) error {
+		if err := enc.EncodeMapLen(1); err != nil {
+			return err
+		}
+		if err := enc.EncodeValue(key); err != nil {
+			return err
+		}
+		if err := enc.EncodeValue(val); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	val := reflect.ValueOf(from)
+	switch val.Kind() {
+	case reflect.Map:
+		if err := enc.EncodeSliceLen(val.Len()); err != nil {
+			return err
+		}
+		it := val.MapRange()
+		for it.Next() {
+			k := reflect.ValueOf(":" + it.Key().String())
+			v := it.Value()
+			if err := encodeKeyVal(enc, k, v); err != nil {
+				return err
+			}
+		}
+	case reflect.Struct:
+		if err := enc.EncodeSliceLen(val.NumField()); err != nil {
+			return err
+		}
+		for i := 0; i < val.NumField(); i++ {
+			key := val.Type().Field(i).Name
+			k := reflect.ValueOf(":" + strings.ToLower(key))
+			v := reflect.ValueOf(from).FieldByName(key)
+			if err := encodeKeyVal(enc, k, v); err != nil {
+				return err
+			}
+		}
+	case reflect.Slice, reflect.Array:
+		if val.Len() > 0 {
+			sliceType := reflect.ValueOf(val.Index(0).Interface()).Kind()
+			if sliceType != reflect.Struct {
+				return enc.Encode(from)
+			}
+		}
+		if err := enc.EncodeSliceLen(val.Len()); err != nil {
+			return err
+		}
+		for i := 0; i < val.Len(); i++ {
+			k := ":" + val.Index(i).Field(0).String()
+			v := val.Index(i).Field(1)
+			if err := encodeKeyVal(enc, reflect.ValueOf(k), v); 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

@@ -11,8 +11,65 @@ type Response struct {
 	Code      uint32
 	Error     string // error message
 	// Data contains deserialized data for untyped requests
-	Data []interface{}
-	buf  smallBuf
+	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 parseMetaData(from []interface{}) []ColumnMetaData {
+	var metaData []ColumnMetaData
+
+	for i := 0; i < len(from); i++ {
+		mp := from[i].(map[interface{}]interface{})
+		cd := ColumnMetaData{}
+		cd.FieldName = mp[uint64(KeyFieldName)].(string)
+		cd.FieldType = mp[uint64(KeyFieldType)].(string)
+		if mp[uint64(KeyFieldColl)] != nil {
+			cd.FieldCollation = mp[uint64(KeyFieldColl)].(string)
+		}
+		if mp[uint64(KeyFieldIsNullable)] != nil {
+			cd.FieldIsNullable = mp[uint64(KeyFieldIsNullable)].(bool)
+		}
+		if mp[uint64(KeyIsAutoincrement)] != nil {
+			cd.FieldIsAutoincrement = mp[uint64(KeyIsAutoincrement)].(bool)
+		}
+		if mp[uint64(KeyFieldSpan)] != nil {
+			cd.FieldSpan = mp[uint64(KeyFieldSpan)].(string)
+		}
+		metaData = append(metaData, cd)
+	}
+
+	return metaData
+}
+
+func parseSQLInfo(from map[interface{}]interface{}) SQLInfo {
+	info := SQLInfo{}
+
+	info.AffectedCount = from[uint64(KeySQLInfoRowCount)].(uint64)
+	if from[uint64(KeySqlInfoAutoincrementIds)] != nil {
+		t := from[uint64(KeySqlInfoAutoincrementIds)].([]interface{})
+		ids := make([]uint64, len(t))
+		for i := range t {
+			ids[i] = t[i].(uint64)
+		}
+		info.InfoAutoincrementIds = ids
+	}
+	return info
 }
 
 func (resp *Response) fill(b []byte) {
@@ -90,6 +147,28 @@ func (resp *Response) decodeBody() (err error) {
 				if resp.Error, err = d.DecodeString(); err != nil {
 					return err
 				}
+			case KeySQLInfo:
+				var res interface{}
+				var castedRes map[interface{}]interface{}
+				var ok bool
+				if res, err = d.DecodeInterface(); err != nil {
+					return err
+				}
+				if castedRes, ok = res.(map[interface{}]interface{}); !ok {
+					return fmt.Errorf("sql info is not a map: %v", res)
+				}
+				resp.SQLInfo = parseSQLInfo(castedRes)
+			case KeyMetaData:
+				var res interface{}
+				var castedRes []interface{}
+				var ok bool
+				if res, err = d.DecodeInterface(); err != nil {
+					return err
+				}
+				if castedRes, ok = res.([]interface{}); !ok {
+					return fmt.Errorf("meta data is not array: %v", res)
+				}
+				resp.MetaData = parseMetaData(castedRes)
 			default:
 				if err = d.Skip(); err != nil {
 					return err