sql: adding minimal sql support

That patch adds the support of SQL in connector.

Fixes #62

Author: vr009

README.md

@@ -282,6 +282,24 @@ func main() {
 	log.Println("Error", err)
 	log.Println("Code", resp.Code)
 	log.Println("Data", resp.Data)
+	
+	// prepare map for sql bind
+	sqlBind := map[string]interface{}{
+        "id":   1,
+        "name": "test",
+	} 
+	// insert data using sql query
+    resp, err = client.Execute("INSERT INTO SQL_TEST VALUES (:id, :name);", sqlBind)
+    log.Println("Execute Error", err)
+    log.Println("Execute Code", resp.Code)
+    log.Println("Execute Data", resp.Data)
+
+    sqlBind = map[string]interface{}{"name": "test"}
+    // select data using sql query
+    resp, err = client.Execute("SELECT id, name FROM SQL_TEST WHERE name=:name", sqlBind)
+    log.Println("Execute Error", err)
+    log.Println("Execute Code", resp.Code)
+    log.Println("Execute Data", resp.Data)
 }
 ```
 

config.lua

@@ -40,6 +40,22 @@ box.once("init", function()
     })
     st:truncate()
 
+    local st = box.schema.space.create('SQL_TEST', {
+        id = 515,
+        temporary = true,
+        if_not_exists = true,
+        field_count = 2,
+        format = {
+            {name = "ID", type = "unsigned"},
+            {name = "NAME", type = "string"},
+        },
+    })
+    st:create_index('primary', {
+        type = 'tree',
+        parts = {1, 'uint'},
+        unique = true,
+        if_not_exists = true,
+    })
     --box.schema.user.grant('guest', 'read,write,execute', 'universe')
     box.schema.func.create('box.info')
     box.schema.func.create('simple_incr')
@@ -49,6 +65,7 @@ box.once("init", function()
     box.schema.user.grant('test', 'execute', 'universe')
     box.schema.user.grant('test', 'read,write', 'space', 'test')
     box.schema.user.grant('test', 'read,write', 'space', 'schematest')
+    box.schema.user.grant('test', 'read,write', 'space', 'SQL_TEST')
 end)
 
 local function simple_incr(a)

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,24 +11,31 @@ const (
 	EvalRequest      = 8
 	UpsertRequest    = 9
 	Call17Request    = 10
+	ExecuteRequest   = 11
 	PingRequest      = 64
 	SubscribeRequest = 66
 
-	KeyCode         = 0x00
-	KeySync         = 0x01
-	KeySpaceNo      = 0x10
-	KeyIndexNo      = 0x11
-	KeyLimit        = 0x12
-	KeyOffset       = 0x13
-	KeyIterator     = 0x14
-	KeyKey          = 0x20
-	KeyTuple        = 0x21
-	KeyFunctionName = 0x22
-	KeyUserName     = 0x23
-	KeyExpression   = 0x27
-	KeyDefTuple     = 0x28
-	KeyData         = 0x30
-	KeyError        = 0x31
+	KeyCode                    = 0x00
+	KeySync                    = 0x01
+	KeySpaceNo                 = 0x10
+	KeyIndexNo                 = 0x11
+	KeyLimit                   = 0x12
+	KeyOffset                  = 0x13
+	KeyIterator                = 0x14
+	KeyKey                     = 0x20
+	KeyTuple                   = 0x21
+	KeyFunctionName            = 0x22
+	KeyUserName                = 0x23
+	KeyExpression              = 0x27
+	KeyDefTuple                = 0x28
+	KeyData                    = 0x30
+	KeyError                   = 0x31
+	KeyMetaData                = 0x32
+	KeySQLText                 = 0x40
+	KeySQLBind                 = 0x41
+	KeySQLInfo                 = 0x42
+	KeySQLInfoRowCount         = 0x00
+	KeySQLInfoAutoIncrementIDS = 0x01
 
 	// https://github.com/fl00r/go-tarantool-1.6/issues/2
 

example_test.go

@@ -168,6 +168,24 @@ func Example() {
 	fmt.Println("Eval Code", resp.Code)
 	fmt.Println("Eval Data", resp.Data)
 
+	// prepare map for sql bind
+	sqlBind := map[string]interface{}{
+		"id":   1,
+		"name": "test",
+	}
+	// insert data using sql query
+	resp, err = client.Execute("INSERT INTO SQL_TEST VALUES (:id, :name);", sqlBind)
+	fmt.Println("Execute Error", err)
+	fmt.Println("Execute Code", resp.Code)
+	fmt.Println("Execute Data", resp.Data)
+
+	sqlBind = map[string]interface{}{"name": "test"}
+	// select data using sql query
+	resp, err = client.Execute("SELECT id, name FROM SQL_TEST WHERE name=:name", sqlBind)
+	fmt.Println("Execute Error", err)
+	fmt.Println("Execute Code", resp.Code)
+	fmt.Println("Execute Data", resp.Data)
+
 	resp, err = client.Replace("test", &Tuple{Id: 11, Msg: "test", Name: "eleven"})
 	resp, err = client.Replace("test", &Tuple{Id: 12, Msg: "test", Name: "twelve"})
 
@@ -215,6 +233,12 @@ func Example() {
 	// Eval Error <nil>
 	// Eval Code 0
 	// Eval Data [3]
+	// Execute Error <nil>
+	// Execute Code 0
+	// Execute Data []
+	// Execute Error <nil>
+	// Execute Code 0
+	// Execute Data [[1 test]]
 	// Fut 0 Error <nil>
 	// Fut 0 Data [{{} 12 test twelve} {{} 11 test eleven}]
 	// Fut 1 Error <nil>

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,7 @@ package tarantool
 
 import (
 	"errors"
+	"reflect"
 	"time"
 
 	"gopkg.in/vmihailenco/msgpack.v2"
@@ -120,6 +121,13 @@ 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) {
+	return conn.ExecuteAsync(expr, args).Get()
+}
+
 // single used for conn.GetTyped for decode one tuple
 type single struct {
 	res   interface{}
@@ -346,10 +354,39 @@ 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)
+	bind := makeSQLBind(args)
+	return future.send(conn, func(enc *msgpack.Encoder) error {
+		enc.EncodeMapLen(2)
+		enc.EncodeUint64(KeySQLText)
+		enc.EncodeString(expr)
+		enc.EncodeUint64(KeySQLBind)
+		return enc.Encode(bind)
+	})
+}
+
 //
 // private
 //
 
+func makeSQLBind(from interface{}) interface{} {
+	val := reflect.ValueOf(from)
+	arr := []map[string]interface{}{}
+
+	if val.Kind() == reflect.Map {
+		for _, e := range val.MapKeys() {
+			mp := map[string]interface{}{}
+			v := val.MapIndex(e)
+			t := v.Interface()
+			mp[":"+e.String()] = t
+			arr = append(arr, mp)
+		}
+	}
+	return arr
+}
+
 func (fut *Future) pack(h *smallWBuf, enc *msgpack.Encoder, body func(*msgpack.Encoder) error) (err error) {
 	rid := fut.requestId
 	hl := h.Len()