added support for setting result' unmarshal mode for the whole connection

Author: Speshal71

call17_test.go

@@ -141,7 +141,7 @@ func TestCall17(t *testing.T) {
 		}
 		res := conn.Exec(context.Background(), params.query, opts...)
 
-		if assert.NoError(err) {
+		if assert.NoError(res.Error) {
 			assert.Equal(params.expectedData, res.Data)
 			assert.Equal(params.expectedRawData, res.RawData)
 		}

call_test.go

@@ -104,7 +104,7 @@ func TestCall(t *testing.T) {
 		}
 		res := conn.Exec(context.Background(), params.query, opts...)
 
-		if assert.NoError(err) {
+		if assert.NoError(res.Error) {
 			assert.Equal(params.expectedData, res.Data)
 			assert.Equal(params.expectedRawData, res.RawData)
 		}

connect_test.go

@@ -1,6 +1,7 @@
 package tarantool
 
 import (
+	"context"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -118,3 +119,51 @@ func TestConnectOptionsDSN(t *testing.T) {
 	}
 
 }
+
+// TestConnectionWithDefaultResultUnmarshalMode tests that
+// overwriting the result' unmarshal mode doesn't interferer with internal queries
+// like auth and schema pulling.
+func TestConnectionWithDefaultResultUnmarshalMode(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+
+	config := `
+	local s = box.schema.space.create('tester', {id = 42})
+	s:create_index('tester_id', {
+		type = 'hash',
+		parts = {1, 'NUM'}
+	})
+	local t = s:insert({33, 45})
+
+	box.schema.user.create("tester", {password = "12345678"})
+	box.schema.user.grant('tester', 'read', 'space', 'tester')
+	`
+
+	box, err := NewBox(config, nil)
+	require.NoError(err)
+	defer box.Close()
+
+	conn, err := Connect(box.Addr(), &Options{
+		DefaultSpace:        "tester",
+		User:                "tester",
+		Password:            "12345678",
+		ResultUnmarshalMode: ResultAsRawData,
+	})
+	require.NoError(err)
+	defer conn.Close()
+
+	res := conn.Exec(context.Background(), &Select{
+		Key:   33,
+		Index: "tester_id",
+	})
+	require.NoError(res.Error)
+	assert.Nil(res.Data)
+	assert.Equal([]interface{}{[]interface{}{int64(33), int64(45)}}, res.RawData)
+
+	tuples, err := conn.Execute(&Select{
+		Key:   33,
+		Index: "tester_id",
+	})
+	require.NoError(err)
+	assert.Equal([][]interface{}{{int64(33), int64(45)}}, tuples)
+}

connection.go

@@ -37,6 +37,8 @@ type Options struct {
 	// that can be added to packet pool.
 	// If the packet size is 0, option is ignored.
 	PoolMaxPacketSize int
+
+	ResultUnmarshalMode resultUnmarshalMode // Result unmarshal mode for user made requests
 }
 
 type Greeting struct {
@@ -57,14 +59,15 @@ type Connection struct {
 	ccw io.Writer
 
 	// options
-	queryTimeout      time.Duration
-	greeting          *Greeting
-	packData          *packData
-	remoteAddr        string
-	firstError        error
-	firstErrorLock    *sync.Mutex
-	perf              PerfCount
-	poolMaxPacketSize int
+	queryTimeout        time.Duration
+	greeting            *Greeting
+	packData            *packData
+	remoteAddr          string
+	firstError          error
+	firstErrorLock      *sync.Mutex
+	perf                PerfCount
+	poolMaxPacketSize   int
+	resultUnmarshalMode resultUnmarshalMode
 }
 
 // Connect to tarantool instance with options using the provided context.
@@ -125,16 +128,17 @@ func newConn(ctx context.Context, scheme, addr string, opts Options) (conn *Conn
 	}()
 
 	conn = &Connection{
-		remoteAddr:        addr,
-		requests:          newRequestMap(),
-		writeChan:         make(chan *request, 256),
-		exit:              make(chan bool),
-		closed:            make(chan bool),
-		firstErrorLock:    &sync.Mutex{},
-		packData:          newPackData(opts.DefaultSpace),
-		queryTimeout:      opts.QueryTimeout,
-		perf:              opts.Perf,
-		poolMaxPacketSize: opts.PoolMaxPacketSize,
+		remoteAddr:          addr,
+		requests:            newRequestMap(),
+		writeChan:           make(chan *request, 256),
+		exit:                make(chan bool),
+		closed:              make(chan bool),
+		firstErrorLock:      &sync.Mutex{},
+		packData:            newPackData(opts.DefaultSpace),
+		queryTimeout:        opts.QueryTimeout,
+		perf:                opts.Perf,
+		poolMaxPacketSize:   opts.PoolMaxPacketSize,
+		resultUnmarshalMode: opts.ResultUnmarshalMode,
 	}
 
 	d := &net.Dialer{

execute.go

@@ -140,6 +140,7 @@ func (conn *Connection) Exec(ctx context.Context, q Query, options ...ExecOption
 
 	request := requestPool.Get()
 	request.replyChan = replyChan
+	request.resultMode = conn.resultUnmarshalMode // could also by overwritten by options
 	for i := 0; i < len(options); i++ {
 		options[i].apply(request)
 	}
@@ -195,6 +196,7 @@ func (conn *Connection) ExecAsync(
 	request := requestPool.Get()
 	request.opaque = opaque
 	request.replyChan = replyChan
+	request.resultMode = conn.resultUnmarshalMode // could also by overwritten by options
 	for i := 0; i < len(options); i++ {
 		options[i].apply(request)
 	}
@@ -206,6 +208,6 @@ func (conn *Connection) ExecAsync(
 }
 
 func (conn *Connection) Execute(q Query) ([][]interface{}, error) {
-	res := conn.Exec(context.Background(), q)
+	res := conn.Exec(context.Background(), q, ResultModeExecOption(ResultDefaultMode))
 	return res.Data, res.Error
 }