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,10 @@ func (connMulti *ConnectionMulti) Eval(expr string, args interface{}) (resp *tar
 	return connMulti.getCurrentConnection().Eval(expr, args)
 }
 
+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 for execution.
+//
+// It is equal to conn.ExecuteAsync(space, tuple).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 {
+	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() {
+			if err := enc.EncodeMapLen(1); err != nil {
+				return err
+			}
+			if err := enc.EncodeValue(reflect.ValueOf(":" + it.Key().String())); err != nil {
+				return err
+			}
+			if err := enc.EncodeValue(reflect.ValueOf(it.Value().Interface())); err != nil {
+				return err
+			}
+		}
+	case reflect.Struct:
+		if err := enc.EncodeSliceLen(val.NumField()); err != nil {
+			return err
+		}
+		for i := 0; i < val.NumField(); i++ {
+			if err := enc.EncodeMapLen(1); err != nil {
+				return err
+			}
+			key := val.Type().Field(i).Name
+			if err := enc.EncodeValue(reflect.ValueOf(":" + strings.ToLower(key))); err != nil {
+				return err
+			}
+			if err := enc.EncodeValue(reflect.ValueOf(from).FieldByName(key)); err != nil {
+				return err
+			}
+		}
+	case reflect.Slice, reflect.Array:
+		if val.Len() > 0 {
+			slType := reflect.ValueOf(val.Index(0).Interface()).Kind()
+			if slType != 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).Interface()
+			if err := enc.EncodeMapLen(1); err != nil {
+				return err
+			}
+			if err := enc.EncodeValue(reflect.ValueOf(":" + k)); err != nil {
+				return err
+			}
+			if err := enc.EncodeValue(reflect.ValueOf(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

@@ -2,7 +2,6 @@ package tarantool
 
 import (
 	"fmt"
-
 	"gopkg.in/vmihailenco/msgpack.v2"
 )
 
@@ -11,8 +10,75 @@ type Response struct {
 	Code      uint32
 	Error     string // error message
 	// Data contains deserialized data for untyped requests
-	Data []interface{}
-	buf  smallBuf
+	Data     []interface{}
+	MetaData SQLMetaData
+	SQLInfo  SQLInfo
+	buf      smallBuf
+}
+
+type SQLMetaData struct {
+	ColumnsInfo []ColumnMetaData
+}
+
+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{}) SQLMetaData {
+	metaData := SQLMetaData{
+		ColumnsInfo: []ColumnMetaData{},
+	}
+
+	arr := from.([]interface{})
+
+	for i := 0; i < len(arr); i++ {
+		mp := arr[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.ColumnsInfo = append(metaData.ColumnsInfo, cd)
+	}
+
+	return metaData
+}
+
+func parseSQLInfo(from interface{}) SQLInfo {
+	info := SQLInfo{}
+	mp, ok := from.(map[interface{}]interface{})
+	if ok {
+		info.AffectedCount = mp[uint64(KeySQLInfoRowCount)].(uint64)
+		if mp[uint64(KeySqlInfoAutoincrementIds)] != nil {
+			t := mp[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 +156,22 @@ func (resp *Response) decodeBody() (err error) {
 				if resp.Error, err = d.DecodeString(); err != nil {
 					return err
 				}
+			case KeySQLInfo:
+				var res interface{}
+				if res, err = d.DecodeInterface(); err != nil {
+					return err
+				}
+				resp.SQLInfo = parseSQLInfo(res)
+			case KeyMetaData:
+				var res interface{}
+				var ok bool
+				if res, err = d.DecodeInterface(); err != nil {
+					return err
+				}
+				if _, ok = res.([]interface{}); !ok {
+					return fmt.Errorf("result is not array: %v", res)
+				}
+				resp.MetaData = parseMetaData(res.([]interface{}))
 			default:
 				if err = d.Skip(); err != nil {
 					return err