13930913017

Committed 18 Mar 2025 06:33PM UTC coverage: 75.939% (+0.08%) from 75.863%

Build Type

github

Committed by maksim.konovalov

Commit Message

pool: Pooler interface supports GetInfo method in TopologyEditor

Pull Request Pull Request #435: pool: Pooler interface supports GetInfo method in TopologyEditor

Run Details

2992 of 3940 relevant lines covered (75.94%)

9863.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.36

/response.go

package tarantool

import (
        "fmt"
        "io"

        "github.com/tarantool/go-iproto"
        "github.com/vmihailenco/msgpack/v5"
)

// Response is an interface with operations for the server responses.
type Response interface {
        // Header returns a response header.
        Header() Header
        // Decode decodes a response.
        Decode() ([]interface{}, error)
        // DecodeTyped decodes a response into a given container res.
        DecodeTyped(res interface{}) error
}

type baseResponse struct {
        // header is a response header.
        header Header
        // data contains deserialized data for untyped requests.
        data []interface{}
        buf  smallBuf
        // Was the Decode() func called for this response.
        decoded bool
        // Was the DecodeTyped() func called for this response.
        decodedTyped bool
        err          error
}

func createBaseResponse(header Header, body io.Reader) (baseResponse, error) {
        if body == nil {
                return baseResponse{header: header}, nil
        }
        if buf, ok := body.(*smallBuf); ok {
                return baseResponse{header: header, buf: *buf}, nil
        }
        data, err := io.ReadAll(body)
        if err != nil {
                return baseResponse{}, err
        }
        return baseResponse{header: header, buf: smallBuf{b: data}}, nil
}

// DecodeBaseResponse parse response header and body.
func DecodeBaseResponse(header Header, body io.Reader) (Response, error) {
        resp, err := createBaseResponse(header, body)
        return &resp, err
}

// SelectResponse is used for the select requests.
// It might contain a position descriptor of the last selected tuple.
//
// You need to cast to SelectResponse a response from SelectRequest.
type SelectResponse struct {
        baseResponse
        // pos contains a position descriptor of last selected tuple.
        pos []byte
}

// PrepareResponse is used for the prepare requests.
// It might contain meta-data and sql info.
//
// Be careful: now this is an alias for `ExecuteResponse`,
// but it could be changed in the future.
// You need to cast to PrepareResponse a response from PrepareRequest.
type PrepareResponse ExecuteResponse

// ExecuteResponse is used for the execute requests.
// It might contain meta-data and sql info.
//
// You need to cast to ExecuteResponse a response from ExecuteRequest.
type ExecuteResponse struct {
        baseResponse
        metaData []ColumnMetaData
        sqlInfo  SQLInfo
}

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 iproto.MetadataKey(mk) {
                case iproto.IPROTO_FIELD_NAME:
                        meta.FieldName = mv.(string)
                case iproto.IPROTO_FIELD_TYPE:
                        meta.FieldType = mv.(string)
                case iproto.IPROTO_FIELD_COLL:
                        meta.FieldCollation = mv.(string)
                case iproto.IPROTO_FIELD_IS_NULLABLE:
                        meta.FieldIsNullable = mv.(bool)
                case iproto.IPROTO_FIELD_IS_AUTOINCREMENT:
                        meta.FieldIsAutoincrement = mv.(bool)
                case iproto.IPROTO_FIELD_SPAN:
                        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 iproto.SqlInfoKey(mk) {
                case iproto.SQL_INFO_ROW_COUNT:
                        if info.AffectedCount, err = d.DecodeUint64(); err != nil {
                                return fmt.Errorf("failed to decode meta data")
                        }
                case iproto.SQL_INFO_AUTOINCREMENT_IDS:
                        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 smallInt(d *msgpack.Decoder, buf *smallBuf) (i int, err error) {
        b, err := buf.ReadByte()
        if err != nil {
                return
        }
        if b <= 127 {
                return int(b), nil
        }
        buf.UnreadByte()
        return d.DecodeInt()
}

func decodeHeader(d *msgpack.Decoder, buf *smallBuf) (Header, iproto.Type, error) {
        var l int
        var code int
        var err error
        d.Reset(buf)
        if l, err = d.DecodeMapLen(); err != nil {
                return Header{}, 0, err
        }
        decodedHeader := Header{Error: ErrorNo}
        for ; l > 0; l-- {
                var cd int
                if cd, err = smallInt(d, buf); err != nil {
                        return Header{}, 0, err
                }
                switch iproto.Key(cd) {
                case iproto.IPROTO_SYNC:
                        var rid uint64
                        if rid, err = d.DecodeUint64(); err != nil {
                                return Header{}, 0, err
                        }
                        decodedHeader.RequestId = uint32(rid)
                case iproto.IPROTO_REQUEST_TYPE:
                        if code, err = d.DecodeInt(); err != nil {
                                return Header{}, 0, err
                        }
                        if code&int(iproto.IPROTO_TYPE_ERROR) != 0 {
                                decodedHeader.Error = iproto.Error(code &^ int(iproto.IPROTO_TYPE_ERROR))
                        } else {
                                decodedHeader.Error = ErrorNo
                        }
                default:
                        if err = d.Skip(); err != nil {
                                return Header{}, 0, err
                        }
                }
        }
        return decodedHeader, iproto.Type(code), nil
}

type decodeInfo struct {
        stmtID             uint64
        bindCount          uint64
        serverProtocolInfo ProtocolInfo
        errorExtendedInfo  *BoxError

        decodedError string
}

func (info *decodeInfo) parseData(resp *baseResponse) error {
        if info.stmtID != 0 {
                stmt := &Prepared{
                        StatementID: PreparedID(info.stmtID),
                        ParamCount:  info.bindCount,
                }
                resp.data = []interface{}{stmt}
                return nil
        }

        // Tarantool may send only version >= 1.
        if info.serverProtocolInfo.Version != ProtocolVersion(0) ||
                info.serverProtocolInfo.Features != nil {
                if info.serverProtocolInfo.Version == ProtocolVersion(0) {
                        return fmt.Errorf("no protocol version provided in Id response")
                }
                if info.serverProtocolInfo.Features == nil {
                        return fmt.Errorf("no features provided in Id response")
                }
                resp.data = []interface{}{info.serverProtocolInfo}
                return nil
        }
        return nil
}

func decodeCommonField(d *msgpack.Decoder, cd int, data *[]interface{},
        info *decodeInfo) (bool, error) {
        var feature iproto.Feature
        var err error

        switch iproto.Key(cd) {
        case iproto.IPROTO_DATA:
                var res interface{}
                var ok bool
                if res, err = d.DecodeInterface(); err != nil {
                        return false, err
                }
                if *data, ok = res.([]interface{}); !ok {
                        return false, fmt.Errorf("result is not array: %v", res)
                }
        case iproto.IPROTO_ERROR:
                if info.errorExtendedInfo, err = decodeBoxError(d); err != nil {
                        return false, err
                }
        case iproto.IPROTO_ERROR_24:
                if info.decodedError, err = d.DecodeString(); err != nil {
                        return false, err
                }
        case iproto.IPROTO_STMT_ID:
                if info.stmtID, err = d.DecodeUint64(); err != nil {
                        return false, err
                }
        case iproto.IPROTO_BIND_COUNT:
                if info.bindCount, err = d.DecodeUint64(); err != nil {
                        return false, err
                }
        case iproto.IPROTO_VERSION:
                if err = d.Decode(&info.serverProtocolInfo.Version); err != nil {
                        return false, err
                }
        case iproto.IPROTO_FEATURES:
                var larr int
                if larr, err = d.DecodeArrayLen(); err != nil {
                        return false, err
                }

                info.serverProtocolInfo.Features = make([]iproto.Feature, larr)
                for i := 0; i < larr; i++ {
                        if err = d.Decode(&feature); err != nil {
                                return false, err
                        }
                        info.serverProtocolInfo.Features[i] = feature
                }
        case iproto.IPROTO_AUTH_TYPE:
                var auth string
                if auth, err = d.DecodeString(); err != nil {
                        return false, err
                }
                found := false
                for _, a := range [...]Auth{ChapSha1Auth, PapSha256Auth} {
                        if auth == a.String() {
                                info.serverProtocolInfo.Auth = a
                                found = true
                        }
                }
                if !found {
                        return false, fmt.Errorf("unknown auth type %s", auth)
                }
        default:
                return false, nil
        }
        return true, nil
}

func (resp *baseResponse) Decode() ([]interface{}, error) {
        if resp.decoded {
                return resp.data, resp.err
        }

        resp.decoded = true
        var err error
        if resp.buf.Len() > 2 {
                offset := resp.buf.Offset()
                defer resp.buf.Seek(offset)

                var l int
                info := &decodeInfo{}

                d := msgpack.NewDecoder(&resp.buf)
                d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
                        return dec.DecodeUntypedMap()
                })

                if l, err = d.DecodeMapLen(); err != nil {
                        resp.err = err
                        return nil, resp.err
                }
                for ; l > 0; l-- {
                        var cd int
                        if cd, err = smallInt(d, &resp.buf); err != nil {
                                resp.err = err
                                return nil, resp.err
                        }
                        decoded, err := decodeCommonField(d, cd, &resp.data, info)
                        if err != nil {
                                resp.err = err
                                return nil, resp.err
                        }
                        if !decoded {
                                if err = d.Skip(); err != nil {
                                        resp.err = err
                                        return nil, resp.err
                                }
                        }
                }
                err = info.parseData(resp)
                if err != nil {
                        resp.err = err
                        return nil, resp.err
                }

                if info.decodedError != "" {
                        resp.err = Error{resp.header.Error, info.decodedError,
                                info.errorExtendedInfo}
                }
        }
        return resp.data, resp.err
}

func (resp *SelectResponse) Decode() ([]interface{}, error) {
        if resp.decoded {
                return resp.data, resp.err
        }

        resp.decoded = true
        var err error
        if resp.buf.Len() > 2 {
                offset := resp.buf.Offset()
                defer resp.buf.Seek(offset)

                var l int
                info := &decodeInfo{}

                d := msgpack.NewDecoder(&resp.buf)
                d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
                        return dec.DecodeUntypedMap()
                })

                if l, err = d.DecodeMapLen(); err != nil {
                        resp.err = err
                        return nil, resp.err
                }
                for ; l > 0; l-- {
                        var cd int
                        if cd, err = smallInt(d, &resp.buf); err != nil {
                                resp.err = err
                                return nil, resp.err
                        }
                        decoded, err := decodeCommonField(d, cd, &resp.data, info)
                        if err != nil {
                                resp.err = err
                                return nil, err
                        }
                        if !decoded {
                                switch iproto.Key(cd) {
                                case iproto.IPROTO_POSITION:
                                        if resp.pos, err = d.DecodeBytes(); err != nil {
                                                resp.err = err
                                                return nil, fmt.Errorf("unable to decode a position: %w", resp.err)
                                        }
                                default:
                                        if err = d.Skip(); err != nil {
                                                resp.err = err
                                                return nil, resp.err
                                        }
                                }
                        }
                }
                err = info.parseData(&resp.baseResponse)
                if err != nil {
                        resp.err = err
                        return nil, resp.err
                }

                if info.decodedError != "" {
                        resp.err = Error{resp.header.Error, info.decodedError,
                                info.errorExtendedInfo}
                }
        }
        return resp.data, resp.err
}

func (resp *ExecuteResponse) Decode() ([]interface{}, error) {
        if resp.decoded {
                return resp.data, resp.err
        }

        resp.decoded = true
        var err error
        if resp.buf.Len() > 2 {
                offset := resp.buf.Offset()
                defer resp.buf.Seek(offset)

                var l int
                info := &decodeInfo{}

                d := msgpack.NewDecoder(&resp.buf)
                d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
                        return dec.DecodeUntypedMap()
                })

                if l, err = d.DecodeMapLen(); err != nil {
                        resp.err = err
                        return nil, resp.err
                }
                for ; l > 0; l-- {
                        var cd int
                        if cd, err = smallInt(d, &resp.buf); err != nil {
                                resp.err = err
                                return nil, resp.err
                        }
                        decoded, err := decodeCommonField(d, cd, &resp.data, info)
                        if err != nil {
                                resp.err = err
                                return nil, resp.err
                        }
                        if !decoded {
                                switch iproto.Key(cd) {
                                case iproto.IPROTO_SQL_INFO:
                                        if err = d.Decode(&resp.sqlInfo); err != nil {
                                                resp.err = err
                                                return nil, resp.err
                                        }
                                case iproto.IPROTO_METADATA:
                                        if err = d.Decode(&resp.metaData); err != nil {
                                                resp.err = err
                                                return nil, resp.err
                                        }
                                default:
                                        if err = d.Skip(); err != nil {
                                                resp.err = err
                                                return nil, resp.err
                                        }
                                }
                        }
                }
                err = info.parseData(&resp.baseResponse)
                if err != nil {
                        resp.err = err
                        return nil, resp.err
                }

                if info.decodedError != "" {
                        resp.err = Error{resp.header.Error, info.decodedError,
                                info.errorExtendedInfo}
                }
        }
        return resp.data, resp.err
}

func decodeTypedCommonField(d *msgpack.Decoder, res interface{}, cd int,
        info *decodeInfo) (bool, error) {
        var err error

        switch iproto.Key(cd) {
        case iproto.IPROTO_DATA:
                if err = d.Decode(res); err != nil {
                        return false, err
                }
        case iproto.IPROTO_ERROR:
                if info.errorExtendedInfo, err = decodeBoxError(d); err != nil {
                        return false, err
                }
        case iproto.IPROTO_ERROR_24:
                if info.decodedError, err = d.DecodeString(); err != nil {
                        return false, err
                }
        default:
                return false, nil
        }
        return true, nil
}

func (resp *baseResponse) DecodeTyped(res interface{}) error {
        resp.decodedTyped = true

        var err error
        if resp.buf.Len() > 0 {
                offset := resp.buf.Offset()
                defer resp.buf.Seek(offset)

                info := &decodeInfo{}
                var l int

                d := msgpack.NewDecoder(&resp.buf)
                d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
                        return dec.DecodeUntypedMap()
                })

                if l, err = d.DecodeMapLen(); err != nil {
                        return err
                }
                for ; l > 0; l-- {
                        var cd int
                        if cd, err = smallInt(d, &resp.buf); err != nil {
                                return err
                        }
                        decoded, err := decodeTypedCommonField(d, res, cd, info)
                        if err != nil {
                                return err
                        }
                        if !decoded {
                                if err = d.Skip(); err != nil {
                                        return err
                                }
                        }
                }
                if info.decodedError != "" {
                        err = Error{resp.header.Error, info.decodedError, info.errorExtendedInfo}
                }
        }
        return err
}

func (resp *SelectResponse) DecodeTyped(res interface{}) error {
        resp.decodedTyped = true

        var err error
        if resp.buf.Len() > 0 {
                offset := resp.buf.Offset()
                defer resp.buf.Seek(offset)

                info := &decodeInfo{}
                var l int

                d := msgpack.NewDecoder(&resp.buf)
                d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
                        return dec.DecodeUntypedMap()
                })

                if l, err = d.DecodeMapLen(); err != nil {
                        return err
                }
                for ; l > 0; l-- {
                        var cd int
                        if cd, err = smallInt(d, &resp.buf); err != nil {
                                return err
                        }
                        decoded, err := decodeTypedCommonField(d, res, cd, info)
                        if err != nil {
                                return err
                        }
                        if !decoded {
                                switch iproto.Key(cd) {
                                case iproto.IPROTO_POSITION:
                                        if resp.pos, err = d.DecodeBytes(); err != nil {
                                                return fmt.Errorf("unable to decode a position: %w", err)
                                        }
                                default:
                                        if err = d.Skip(); err != nil {
                                                return err
                                        }
                                }
                        }
                }
                if info.decodedError != "" {
                        err = Error{resp.header.Error, info.decodedError, info.errorExtendedInfo}
                }
        }
        return err
}

func (resp *ExecuteResponse) DecodeTyped(res interface{}) error {
        resp.decodedTyped = true

        var err error
        if resp.buf.Len() > 0 {
                offset := resp.buf.Offset()
                defer resp.buf.Seek(offset)

                info := &decodeInfo{}
                var l int

                d := msgpack.NewDecoder(&resp.buf)
                d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {
                        return dec.DecodeUntypedMap()
                })

                if l, err = d.DecodeMapLen(); err != nil {
                        return err
                }
                for ; l > 0; l-- {
                        var cd int
                        if cd, err = smallInt(d, &resp.buf); err != nil {
                                return err
                        }
                        decoded, err := decodeTypedCommonField(d, res, cd, info)
                        if err != nil {
                                return err
                        }
                        if !decoded {
                                switch iproto.Key(cd) {
                                case iproto.IPROTO_SQL_INFO:
                                        if err = d.Decode(&resp.sqlInfo); err != nil {
                                                return err
                                        }
                                case iproto.IPROTO_METADATA:
                                        if err = d.Decode(&resp.metaData); err != nil {
                                                return err
                                        }
                                default:
                                        if err = d.Skip(); err != nil {
                                                return err
                                        }
                                }
                        }
                }
                if info.decodedError != "" {
                        err = Error{resp.header.Error, info.decodedError, info.errorExtendedInfo}
                }
        }
        return err
}

func (resp *baseResponse) Header() Header {
        return resp.header
}

// Pos returns a position descriptor of the last selected tuple for the SelectResponse.
// If the response was not decoded, this method will call Decode().
func (resp *SelectResponse) Pos() ([]byte, error) {
        if !resp.decoded && !resp.decodedTyped {
                resp.Decode()
        }
        return resp.pos, resp.err
}

// MetaData returns ExecuteResponse meta-data.
// If the response was not decoded, this method will call Decode().
func (resp *ExecuteResponse) MetaData() ([]ColumnMetaData, error) {
        if !resp.decoded && !resp.decodedTyped {
                resp.Decode()
        }
        return resp.metaData, resp.err
}

// SQLInfo returns ExecuteResponse sql info.
// If the response was not decoded, this method will call Decode().
func (resp *ExecuteResponse) SQLInfo() (SQLInfo, error) {
        if !resp.decoded && !resp.decodedTyped {
                resp.Decode()
        }
        return resp.sqlInfo, resp.err
}

// String implements Stringer interface.
func (resp *baseResponse) String() (str string) {
        if resp.header.Error == ErrorNo {
                return fmt.Sprintf("<%d OK %v>", resp.header.RequestId, resp.data)
        }
        return fmt.Sprintf("<%d ERR %s %v>", resp.header.RequestId, resp.header.Error, resp.err)
}

1	package tarantool
2
3	import (
4	"fmt"
5	"io"
6
7	"github.com/tarantool/go-iproto"
8	"github.com/vmihailenco/msgpack/v5"
9	)
10
11	// Response is an interface with operations for the server responses.
12	type Response interface {
13	// Header returns a response header.
14	Header() Header
15	// Decode decodes a response.
16	Decode() ([]interface{}, error)
17	// DecodeTyped decodes a response into a given container res.
18	DecodeTyped(res interface{}) error
19	}
20
21	type baseResponse struct {
22	// header is a response header.
23	header Header
24	// data contains deserialized data for untyped requests.
25	data []interface{}
26	buf smallBuf
27	// Was the Decode() func called for this response.
28	decoded bool
29	// Was the DecodeTyped() func called for this response.
30	decodedTyped bool
31	err error
32	}
33
34	func createBaseResponse(header Header, body io.Reader) (baseResponse, error) {	3,250✔
35	if body == nil {	4,694✔
36	return baseResponse{header: header}, nil	1,444✔
37	}	1,444✔
38	if buf, ok := body.(*smallBuf); ok {	3,566✔
39	return baseResponse{header: header, buf: *buf}, nil	1,760✔
40	}	1,760✔
41	data, err := io.ReadAll(body)	46✔
42	if err != nil {	46✔
43	return baseResponse{}, err	×
44	}	×
45	return baseResponse{header: header, buf: smallBuf{b: data}}, nil	46✔
46	}
47
48	// DecodeBaseResponse parse response header and body.
49	func DecodeBaseResponse(header Header, body io.Reader) (Response, error) {	1,799✔
50	resp, err := createBaseResponse(header, body)	1,799✔
51	return &resp, err	1,799✔
52	}	1,799✔
53
54	// SelectResponse is used for the select requests.
55	// It might contain a position descriptor of the last selected tuple.
56	//
57	// You need to cast to SelectResponse a response from SelectRequest.
58	type SelectResponse struct {
59	baseResponse
60	// pos contains a position descriptor of last selected tuple.
61	pos []byte
62	}
63
64	// PrepareResponse is used for the prepare requests.
65	// It might contain meta-data and sql info.
66	//
67	// Be careful: now this is an alias for `ExecuteResponse`,
68	// but it could be changed in the future.
69	// You need to cast to PrepareResponse a response from PrepareRequest.
70	type PrepareResponse ExecuteResponse
71
72	// ExecuteResponse is used for the execute requests.
73	// It might contain meta-data and sql info.
74	//
75	// You need to cast to ExecuteResponse a response from ExecuteRequest.
76	type ExecuteResponse struct {
77	baseResponse
78	metaData []ColumnMetaData
79	sqlInfo SQLInfo
80	}
81
82	type ColumnMetaData struct {
83	FieldName string
84	FieldType string
85	FieldCollation string
86	FieldIsNullable bool
87	FieldIsAutoincrement bool
88	FieldSpan string
89	}
90
91	type SQLInfo struct {
92	AffectedCount uint64
93	InfoAutoincrementIds []uint64
94	}
95
96	func (meta ColumnMetaData) DecodeMsgpack(d msgpack.Decoder) error {	23✔
97	var err error	23✔
98	var l int	23✔
99	if l, err = d.DecodeMapLen(); err != nil {	23✔
100	return err	×
101	}	×
102	if l == 0 {	23✔
103	return fmt.Errorf("map len doesn't match: %d", l)	×
104	}	×
105	for i := 0; i < l; i++ {	75✔
106	var mk uint64	52✔
107	var mv interface{}	52✔
108	if mk, err = d.DecodeUint64(); err != nil {	52✔
109	return fmt.Errorf("failed to decode meta data")	×
110	}	×
111	if mv, err = d.DecodeInterface(); err != nil {	52✔
112	return fmt.Errorf("failed to decode meta data")	×
113	}	×
114	switch iproto.MetadataKey(mk) {	52✔
115	case iproto.IPROTO_FIELD_NAME:	23✔
116	meta.FieldName = mv.(string)	23✔
117	case iproto.IPROTO_FIELD_TYPE:	23✔
118	meta.FieldType = mv.(string)	23✔
119	case iproto.IPROTO_FIELD_COLL:	1✔
120	meta.FieldCollation = mv.(string)	1✔
121	case iproto.IPROTO_FIELD_IS_NULLABLE:	2✔
122	meta.FieldIsNullable = mv.(bool)	2✔
123	case iproto.IPROTO_FIELD_IS_AUTOINCREMENT:	×
124	meta.FieldIsAutoincrement = mv.(bool)	×
125	case iproto.IPROTO_FIELD_SPAN:	3✔
126	meta.FieldSpan = mv.(string)	3✔
127	default:	×
128	return fmt.Errorf("failed to decode meta data")	×
129	}
130	}
131	return nil	23✔
132	}
133
134	func (info SQLInfo) DecodeMsgpack(d msgpack.Decoder) error {	13✔
135	var err error	13✔
136	var l int	13✔
137	if l, err = d.DecodeMapLen(); err != nil {	13✔
138	return err	×
139	}	×
140	if l == 0 {	13✔
141	return fmt.Errorf("map len doesn't match")	×
142	}	×
143	for i := 0; i < l; i++ {	26✔
144	var mk uint64	13✔
145	if mk, err = d.DecodeUint64(); err != nil {	13✔
146	return fmt.Errorf("failed to decode meta data")	×
147	}	×
148	switch iproto.SqlInfoKey(mk) {	13✔
149	case iproto.SQL_INFO_ROW_COUNT:	13✔
150	if info.AffectedCount, err = d.DecodeUint64(); err != nil {	13✔
151	return fmt.Errorf("failed to decode meta data")	×
152	}	×
153	case iproto.SQL_INFO_AUTOINCREMENT_IDS:	×
154	if err = d.Decode(&info.InfoAutoincrementIds); err != nil {	×
155	return fmt.Errorf("failed to decode meta data")	×
156	}	×
157	default:	×
158	return fmt.Errorf("failed to decode meta data")	×
159	}
160	}
161	return nil	13✔
162	}
163
164	func smallInt(d msgpack.Decoder, buf smallBuf) (i int, err error) {	8,278✔
165	b, err := buf.ReadByte()	8,278✔
166	if err != nil {	8,278✔
167	return	×
168	}	×
169	if b <= 127 {	16,512✔
170	return int(b), nil	8,234✔
171	}	8,234✔
172	buf.UnreadByte()	44✔
173	return d.DecodeInt()	44✔
174	}
175
176	func decodeHeader(d msgpack.Decoder, buf smallBuf) (Header, iproto.Type, error) {	2,190✔
177	var l int	2,190✔
178	var code int	2,190✔
179	var err error	2,190✔
180	d.Reset(buf)	2,190✔
181	if l, err = d.DecodeMapLen(); err != nil {	2,190✔
182	return Header{}, 0, err	×
183	}	×
184	decodedHeader := Header{Error: ErrorNo}	2,190✔
185	for ; l > 0; l-- {	8,330✔
186	var cd int	6,140✔
187	if cd, err = smallInt(d, buf); err != nil {	6,140✔
188	return Header{}, 0, err	×
189	}	×
190	switch iproto.Key(cd) {	6,140✔
191	case iproto.IPROTO_SYNC:	2,190✔
192	var rid uint64	2,190✔
193	if rid, err = d.DecodeUint64(); err != nil {	2,190✔
194	return Header{}, 0, err	×
195	}	×
196	decodedHeader.RequestId = uint32(rid)	2,190✔
197	case iproto.IPROTO_REQUEST_TYPE:	2,190✔
198	if code, err = d.DecodeInt(); err != nil {	2,190✔
199	return Header{}, 0, err	×
200	}	×
201	if code&int(iproto.IPROTO_TYPE_ERROR) != 0 {	2,208✔
202	decodedHeader.Error = iproto.Error(code &^ int(iproto.IPROTO_TYPE_ERROR))	18✔
203	} else {	2,190✔
204	decodedHeader.Error = ErrorNo	2,172✔
205	}	2,172✔
206	default:	1,760✔
207	if err = d.Skip(); err != nil {	1,760✔
208	return Header{}, 0, err	×
209	}	×
210	}
211	}
212	return decodedHeader, iproto.Type(code), nil	2,190✔
213	}
214
215	type decodeInfo struct {
216	stmtID uint64
217	bindCount uint64
218	serverProtocolInfo ProtocolInfo
219	errorExtendedInfo *BoxError
220
221	decodedError string
222	}
223
224	func (info decodeInfo) parseData(resp baseResponse) error {	793✔
225	if info.stmtID != 0 {	795✔
226	stmt := &Prepared{	2✔
227	StatementID: PreparedID(info.stmtID),	2✔
228	ParamCount: info.bindCount,	2✔
229	}	2✔
230	resp.data = []interface{}{stmt}	2✔
231	return nil	2✔
232	}	2✔
233
234	// Tarantool may send only version >= 1.
235	if info.serverProtocolInfo.Version != ProtocolVersion(0) \|\|	791✔
236	info.serverProtocolInfo.Features != nil {	1,113✔
237	if info.serverProtocolInfo.Version == ProtocolVersion(0) {	322✔
238	return fmt.Errorf("no protocol version provided in Id response")	×
239	}	×
240	if info.serverProtocolInfo.Features == nil {	322✔
241	return fmt.Errorf("no features provided in Id response")	×
242	}	×
243	resp.data = []interface{}{info.serverProtocolInfo}	322✔
244	return nil	322✔
245	}
246	return nil	469✔
247	}
248
249	func decodeCommonField(d msgpack.Decoder, cd int, data []interface{},
250	info *decodeInfo) (bool, error) {	1,472✔
251	var feature iproto.Feature	1,472✔
252	var err error	1,472✔
253		1,472✔
254	switch iproto.Key(cd) {	1,472✔
255	case iproto.IPROTO_DATA:	439✔
256	var res interface{}	439✔
257	var ok bool	439✔
258	if res, err = d.DecodeInterface(); err != nil {	439✔
259	return false, err	×
260	}	×
261	if *data, ok = res.([]interface{}); !ok {	439✔
262	return false, fmt.Errorf("result is not array: %v", res)	×
263	}	×
264	case iproto.IPROTO_ERROR:	15✔
265	if info.errorExtendedInfo, err = decodeBoxError(d); err != nil {	15✔
266	return false, err	×
267	}	×
268	case iproto.IPROTO_ERROR_24:	17✔
269	if info.decodedError, err = d.DecodeString(); err != nil {	17✔
270	return false, err	×
271	}	×
272	case iproto.IPROTO_STMT_ID:	2✔
273	if info.stmtID, err = d.DecodeUint64(); err != nil {	2✔
274	return false, err	×
275	}	×
276	case iproto.IPROTO_BIND_COUNT:	2✔
277	if info.bindCount, err = d.DecodeUint64(); err != nil {	2✔
278	return false, err	×
279	}	×
280	case iproto.IPROTO_VERSION:	322✔
281	if err = d.Decode(&info.serverProtocolInfo.Version); err != nil {	322✔
282	return false, err	×
283	}	×
284	case iproto.IPROTO_FEATURES:	322✔
285	var larr int	322✔
286	if larr, err = d.DecodeArrayLen(); err != nil {	322✔
287	return false, err	×
288	}	×
289
290	info.serverProtocolInfo.Features = make([]iproto.Feature, larr)	322✔
291	for i := 0; i < larr; i++ {	4,116✔
292	if err = d.Decode(&feature); err != nil {	3,794✔
293	return false, err	×
294	}	×
295	info.serverProtocolInfo.Features[i] = feature	3,794✔
296	}
297	case iproto.IPROTO_AUTH_TYPE:	322✔
298	var auth string	322✔
299	if auth, err = d.DecodeString(); err != nil {	322✔
300	return false, err	×
301	}	×
302	found := false	322✔
303	for _, a := range [...]Auth{ChapSha1Auth, PapSha256Auth} {	966✔
304	if auth == a.String() {	966✔
305	info.serverProtocolInfo.Auth = a	322✔
306	found = true	322✔
307	}	322✔
308	}
309	if !found {	322✔
310	return false, fmt.Errorf("unknown auth type %s", auth)	×
311	}	×
312	default:	31✔
313	return false, nil	31✔
314	}
315	return true, nil	1,441✔
316	}
317
318	func (resp *baseResponse) Decode() ([]interface{}, error) {	2,122✔
319	if resp.decoded {	2,461✔
320	return resp.data, resp.err	339✔
321	}	339✔
322
323	resp.decoded = true	1,783✔
324	var err error	1,783✔
325	if resp.buf.Len() > 2 {	2,507✔
326	offset := resp.buf.Offset()	724✔
327	defer resp.buf.Seek(offset)	724✔
328		724✔
329	var l int	724✔
330	info := &decodeInfo{}	724✔
331		724✔
332	d := msgpack.NewDecoder(&resp.buf)	724✔
333	d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {	736✔
334	return dec.DecodeUntypedMap()	12✔
335	})	12✔
336
337	if l, err = d.DecodeMapLen(); err != nil {	724✔
338	resp.err = err	×
339	return nil, resp.err	×
340	}	×
341	for ; l > 0; l-- {	2,108✔
342	var cd int	1,384✔
343	if cd, err = smallInt(d, &resp.buf); err != nil {	1,384✔
344	resp.err = err	×
345	return nil, resp.err	×
346	}	×
347	decoded, err := decodeCommonField(d, cd, &resp.data, info)	1,384✔
348	if err != nil {	1,384✔
349	resp.err = err	×
350	return nil, resp.err	×
351	}	×
352	if !decoded {	1,388✔
353	if err = d.Skip(); err != nil {	4✔
354	resp.err = err	×
355	return nil, resp.err	×
356	}	×
357	}
358	}
359	err = info.parseData(resp)	724✔
360	if err != nil {	724✔
361	resp.err = err	×
362	return nil, resp.err	×
363	}	×
364
365	if info.decodedError != "" {	736✔
366	resp.err = Error{resp.header.Error, info.decodedError,	12✔
367	info.errorExtendedInfo}	12✔
368	}	12✔
369	}
370	return resp.data, resp.err	1,783✔
371	}
372
373	func (resp *SelectResponse) Decode() ([]interface{}, error) {	45✔
374	if resp.decoded {	51✔
375	return resp.data, resp.err	6✔
376	}	6✔
377
378	resp.decoded = true	39✔
379	var err error	39✔
380	if resp.buf.Len() > 2 {	78✔
381	offset := resp.buf.Offset()	39✔
382	defer resp.buf.Seek(offset)	39✔
383		39✔
384	var l int	39✔
385	info := &decodeInfo{}	39✔
386		39✔
387	d := msgpack.NewDecoder(&resp.buf)	39✔
388	d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {	39✔
389	return dec.DecodeUntypedMap()	×
390	})	×
391
392	if l, err = d.DecodeMapLen(); err != nil {	39✔
393	resp.err = err	×
394	return nil, resp.err	×
395	}	×
396	for ; l > 0; l-- {	82✔
397	var cd int	43✔
398	if cd, err = smallInt(d, &resp.buf); err != nil {	43✔
399	resp.err = err	×
400	return nil, resp.err	×
401	}	×
402	decoded, err := decodeCommonField(d, cd, &resp.data, info)	43✔
403	if err != nil {	43✔
404	resp.err = err	×
405	return nil, err	×
406	}	×
407	if !decoded {	47✔
408	switch iproto.Key(cd) {	4✔
409	case iproto.IPROTO_POSITION:	4✔
410	if resp.pos, err = d.DecodeBytes(); err != nil {	4✔
411	resp.err = err	×
412	return nil, fmt.Errorf("unable to decode a position: %w", resp.err)	×
413	}	×
414	default:	×
415	if err = d.Skip(); err != nil {	×
416	resp.err = err	×
417	return nil, resp.err	×
418	}	×
419	}
420	}
421	}
422	err = info.parseData(&resp.baseResponse)	39✔
423	if err != nil {	39✔
424	resp.err = err	×
425	return nil, resp.err	×
426	}	×
427
428	if info.decodedError != "" {	39✔
429	resp.err = Error{resp.header.Error, info.decodedError,	×
430	info.errorExtendedInfo}	×
431	}	×
432	}
433	return resp.data, resp.err	39✔
434	}
435
436	func (resp *ExecuteResponse) Decode() ([]interface{}, error) {	30✔
437	if resp.decoded {	30✔
438	return resp.data, resp.err	×
439	}	×
440
441	resp.decoded = true	30✔
442	var err error	30✔
443	if resp.buf.Len() > 2 {	60✔
444	offset := resp.buf.Offset()	30✔
445	defer resp.buf.Seek(offset)	30✔
446		30✔
447	var l int	30✔
448	info := &decodeInfo{}	30✔
449		30✔
450	d := msgpack.NewDecoder(&resp.buf)	30✔
451	d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {	30✔
452	return dec.DecodeUntypedMap()	×
453	})	×
454
455	if l, err = d.DecodeMapLen(); err != nil {	30✔
456	resp.err = err	×
457	return nil, resp.err	×
458	}	×
459	for ; l > 0; l-- {	75✔
460	var cd int	45✔
461	if cd, err = smallInt(d, &resp.buf); err != nil {	45✔
462	resp.err = err	×
463	return nil, resp.err	×
464	}	×
465	decoded, err := decodeCommonField(d, cd, &resp.data, info)	45✔
466	if err != nil {	45✔
467	resp.err = err	×
468	return nil, resp.err	×
469	}	×
470	if !decoded {	68✔
471	switch iproto.Key(cd) {	23✔
472	case iproto.IPROTO_SQL_INFO:	13✔
473	if err = d.Decode(&resp.sqlInfo); err != nil {	13✔
474	resp.err = err	×
475	return nil, resp.err	×
476	}	×
477	case iproto.IPROTO_METADATA:	10✔
478	if err = d.Decode(&resp.metaData); err != nil {	10✔
479	resp.err = err	×
480	return nil, resp.err	×
481	}	×
482	default:	×
483	if err = d.Skip(); err != nil {	×
484	resp.err = err	×
485	return nil, resp.err	×
486	}	×
487	}
488	}
489	}
490	err = info.parseData(&resp.baseResponse)	30✔
491	if err != nil {	30✔
492	resp.err = err	×
493	return nil, resp.err	×
494	}	×
495
496	if info.decodedError != "" {	35✔
497	resp.err = Error{resp.header.Error, info.decodedError,	5✔
498	info.errorExtendedInfo}	5✔
499	}	5✔
500	}
501	return resp.data, resp.err	30✔
502	}
503
504	func decodeTypedCommonField(d *msgpack.Decoder, res interface{}, cd int,
505	info *decodeInfo) (bool, error) {	666✔
506	var err error	666✔
507		666✔
508	switch iproto.Key(cd) {	666✔
509	case iproto.IPROTO_DATA:	665✔
510	if err = d.Decode(res); err != nil {	666✔
511	return false, err	1✔
512	}	1✔
513	case iproto.IPROTO_ERROR:	×
514	if info.errorExtendedInfo, err = decodeBoxError(d); err != nil {	×
515	return false, err	×
516	}	×
517	case iproto.IPROTO_ERROR_24:	×
518	if info.decodedError, err = d.DecodeString(); err != nil {	×
519	return false, err	×
520	}	×
521	default:	1✔
522	return false, nil	1✔
523	}
524	return true, nil	664✔
525	}
526
527	func (resp *baseResponse) DecodeTyped(res interface{}) error {	46✔
528	resp.decodedTyped = true	46✔
529		46✔
530	var err error	46✔
531	if resp.buf.Len() > 0 {	92✔
532	offset := resp.buf.Offset()	46✔
533	defer resp.buf.Seek(offset)	46✔
534		46✔
535	info := &decodeInfo{}	46✔
536	var l int	46✔
537		46✔
538	d := msgpack.NewDecoder(&resp.buf)	46✔
539	d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {	46✔
540	return dec.DecodeUntypedMap()	×
541	})	×
542
543	if l, err = d.DecodeMapLen(); err != nil {	46✔
544	return err	×
545	}	×
546	for ; l > 0; l-- {	92✔
547	var cd int	46✔
548	if cd, err = smallInt(d, &resp.buf); err != nil {	46✔
549	return err	×
550	}	×
551	decoded, err := decodeTypedCommonField(d, res, cd, info)	46✔
552	if err != nil {	47✔
553	return err	1✔
554	}	1✔
555	if !decoded {	45✔
556	if err = d.Skip(); err != nil {	×
557	return err	×
558	}	×
559	}
560	}
561	if info.decodedError != "" {	45✔
562	err = Error{resp.header.Error, info.decodedError, info.errorExtendedInfo}	×
563	}	×
564	}
565	return err	45✔
566	}
567
568	func (resp *SelectResponse) DecodeTyped(res interface{}) error {	616✔
569	resp.decodedTyped = true	616✔
570		616✔
571	var err error	616✔
572	if resp.buf.Len() > 0 {	1,232✔
573	offset := resp.buf.Offset()	616✔
574	defer resp.buf.Seek(offset)	616✔
575		616✔
576	info := &decodeInfo{}	616✔
577	var l int	616✔
578		616✔
579	d := msgpack.NewDecoder(&resp.buf)	616✔
580	d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {	616✔
581	return dec.DecodeUntypedMap()	×
582	})	×
583
584	if l, err = d.DecodeMapLen(); err != nil {	616✔
585	return err	×
586	}	×
587	for ; l > 0; l-- {	1,232✔
588	var cd int	616✔
589	if cd, err = smallInt(d, &resp.buf); err != nil {	616✔
590	return err	×
591	}	×
592	decoded, err := decodeTypedCommonField(d, res, cd, info)	616✔
593	if err != nil {	616✔
594	return err	×
595	}	×
596	if !decoded {	616✔
597	switch iproto.Key(cd) {	×
598	case iproto.IPROTO_POSITION:	×
599	if resp.pos, err = d.DecodeBytes(); err != nil {	×
600	return fmt.Errorf("unable to decode a position: %w", err)	×
601	}	×
602	default:	×
603	if err = d.Skip(); err != nil {	×
604	return err	×
605	}	×
606	}
607	}
608	}
609	if info.decodedError != "" {	616✔
610	err = Error{resp.header.Error, info.decodedError, info.errorExtendedInfo}	×
611	}	×
612	}
613	return err	616✔
614	}
615
616	func (resp *ExecuteResponse) DecodeTyped(res interface{}) error {	3✔
617	resp.decodedTyped = true	3✔
618		3✔
619	var err error	3✔
620	if resp.buf.Len() > 0 {	6✔
621	offset := resp.buf.Offset()	3✔
622	defer resp.buf.Seek(offset)	3✔
623		3✔
624	info := &decodeInfo{}	3✔
625	var l int	3✔
626		3✔
627	d := msgpack.NewDecoder(&resp.buf)	3✔
628	d.SetMapDecoder(func(dec *msgpack.Decoder) (interface{}, error) {	3✔
629	return dec.DecodeUntypedMap()	×
630	})	×
631
632	if l, err = d.DecodeMapLen(); err != nil {	3✔
633	return err	×
634	}	×
635	for ; l > 0; l-- {	7✔
636	var cd int	4✔
637	if cd, err = smallInt(d, &resp.buf); err != nil {	4✔
638	return err	×
639	}	×
640	decoded, err := decodeTypedCommonField(d, res, cd, info)	4✔
641	if err != nil {	4✔
642	return err	×
643	}	×
644	if !decoded {	5✔
645	switch iproto.Key(cd) {	1✔
646	case iproto.IPROTO_SQL_INFO:	×
647	if err = d.Decode(&resp.sqlInfo); err != nil {	×
648	return err	×
649	}	×
650	case iproto.IPROTO_METADATA:	1✔
651	if err = d.Decode(&resp.metaData); err != nil {	1✔
652	return err	×
653	}	×
654	default:	×
655	if err = d.Skip(); err != nil {	×
656	return err	×
657	}	×
658	}
659	}
660	}
661	if info.decodedError != "" {	3✔
662	err = Error{resp.header.Error, info.decodedError, info.errorExtendedInfo}	×
663	}	×
664	}
665	return err	3✔
666	}
667
668	func (resp *baseResponse) Header() Header {	56✔
669	return resp.header	56✔
670	}	56✔
671
672	// Pos returns a position descriptor of the last selected tuple for the SelectResponse.
673	// If the response was not decoded, this method will call Decode().
674	func (resp *SelectResponse) Pos() ([]byte, error) {	7✔
675	if !resp.decoded && !resp.decodedTyped {	13✔
676	resp.Decode()	6✔
677	}	6✔
678	return resp.pos, resp.err	7✔
679	}
680
681	// MetaData returns ExecuteResponse meta-data.
682	// If the response was not decoded, this method will call Decode().
683	func (resp *ExecuteResponse) MetaData() ([]ColumnMetaData, error) {	19✔
684	if !resp.decoded && !resp.decodedTyped {	19✔
685	resp.Decode()	×
686	}	×
687	return resp.metaData, resp.err	19✔
688	}
689
690	// SQLInfo returns ExecuteResponse sql info.
691	// If the response was not decoded, this method will call Decode().
692	func (resp *ExecuteResponse) SQLInfo() (SQLInfo, error) {	20✔
693	if !resp.decoded && !resp.decodedTyped {	24✔
694	resp.Decode()	4✔
695	}	4✔
696	return resp.sqlInfo, resp.err	20✔
697	}
698
699	// String implements Stringer interface.
700	func (resp *baseResponse) String() (str string) {	×
701	if resp.header.Error == ErrorNo {	×
702	return fmt.Sprintf("<%d OK %v>", resp.header.RequestId, resp.data)	×
703	}	×
704	return fmt.Sprintf("<%d ERR %s %v>", resp.header.RequestId, resp.header.Error, resp.err)	×
705	}

tarantool / go-tarantool / 13930913017

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous