From 306ef7137d35aa3b6d370fc319d394513ea208f7 Mon Sep 17 00:00:00 2001 From: Oleg Jukovec Date: Mon, 13 Mar 2023 17:40:20 +0300 Subject: [PATCH 1/5] crud: remove NewEncoder/NewDecoder from the API This is only needed for tests. Let it be private API. Part of #271 --- crud/msgpack.go | 6 ------ crud/msgpack_helper_test.go | 10 ++++++++++ crud/msgpack_v5.go | 6 ------ crud/msgpack_v5_helper_test.go | 10 ++++++++++ crud/request_test.go | 4 ++-- crud/tarantool_test.go | 2 +- 6 files changed, 23 insertions(+), 15 deletions(-) create mode 100644 crud/msgpack_helper_test.go create mode 100644 crud/msgpack_v5_helper_test.go diff --git a/crud/msgpack.go b/crud/msgpack.go index fe65bd154..be1c88f7f 100644 --- a/crud/msgpack.go +++ b/crud/msgpack.go @@ -4,8 +4,6 @@ package crud import ( - "io" - "gopkg.in/vmihailenco/msgpack.v2" ) @@ -23,7 +21,3 @@ type MapObject map[string]interface{} func (o MapObject) EncodeMsgpack(enc *encoder) { enc.Encode(o) } - -func NewEncoder(w io.Writer) *encoder { - return msgpack.NewEncoder(w) -} diff --git a/crud/msgpack_helper_test.go b/crud/msgpack_helper_test.go new file mode 100644 index 000000000..7d3998fc6 --- /dev/null +++ b/crud/msgpack_helper_test.go @@ -0,0 +1,10 @@ +//go:build !go_tarantool_msgpack_v5 +// +build !go_tarantool_msgpack_v5 + +package crud_test + +import ( + "gopkg.in/vmihailenco/msgpack.v2" +) + +var newEncoder = msgpack.NewEncoder diff --git a/crud/msgpack_v5.go b/crud/msgpack_v5.go index bfa936a83..3bbbf09fd 100644 --- a/crud/msgpack_v5.go +++ b/crud/msgpack_v5.go @@ -4,8 +4,6 @@ package crud import ( - "io" - "github.com/vmihailenco/msgpack/v5" ) @@ -23,7 +21,3 @@ type MapObject map[string]interface{} func (o MapObject) EncodeMsgpack(enc *encoder) { enc.Encode(o) } - -func NewEncoder(w io.Writer) *encoder { - return msgpack.NewEncoder(w) -} diff --git a/crud/msgpack_v5_helper_test.go b/crud/msgpack_v5_helper_test.go new file mode 100644 index 000000000..f3700bebc --- /dev/null +++ b/crud/msgpack_v5_helper_test.go @@ -0,0 +1,10 @@ +//go:build go_tarantool_msgpack_v5 +// +build go_tarantool_msgpack_v5 + +package crud_test + +import ( + "github.com/vmihailenco/msgpack/v5" +) + +var newEncoder = msgpack.NewEncoder diff --git a/crud/request_test.go b/crud/request_test.go index c27b8c4ae..f7af05223 100644 --- a/crud/request_test.go +++ b/crud/request_test.go @@ -94,12 +94,12 @@ var resolver ValidSchemeResolver func assertBodyEqual(t testing.TB, reference tarantool.Request, req tarantool.Request) { t.Helper() - reqBody, err := test_helpers.ExtractRequestBody(req, &resolver, crud.NewEncoder) + reqBody, err := test_helpers.ExtractRequestBody(req, &resolver, newEncoder) if err != nil { t.Fatalf("An unexpected Response.Body() error: %q", err.Error()) } - refBody, err := test_helpers.ExtractRequestBody(reference, &resolver, crud.NewEncoder) + refBody, err := test_helpers.ExtractRequestBody(reference, &resolver, newEncoder) if err != nil { t.Fatalf("An unexpected Response.Body() error: %q", err.Error()) } diff --git a/crud/tarantool_test.go b/crud/tarantool_test.go index 1323b33e9..33959a026 100644 --- a/crud/tarantool_test.go +++ b/crud/tarantool_test.go @@ -123,7 +123,7 @@ func BenchmarkCrud(b *testing.B) { buf := bytes.Buffer{} buf.Grow(512 * 1024 * 1024) // Avoid allocs in test. - enc := crud.NewEncoder(&buf) + enc := newEncoder(&buf) b.ResetTimer() From 48337a48eab1cc4efe7e12010f93b67a2b6c37d9 Mon Sep 17 00:00:00 2001 From: Oleg Jukovec Date: Mon, 13 Mar 2023 17:25:02 +0300 Subject: [PATCH 2/5] crud: improve Result* types Now a user can specify his custom type as a type for rows. The patch also removes unnecessary types to make it easier for a user to work with the API. Part of #271 --- crud/delete.go | 3 - crud/error.go | 24 +++++++ crud/example_test.go | 150 +++++++++++++++++++++++++++++++++++++++++ crud/get.go | 3 - crud/insert.go | 6 -- crud/insert_many.go | 6 -- crud/max.go | 3 - crud/min.go | 3 - crud/msgpack.go | 6 ++ crud/msgpack_v5.go | 6 ++ crud/replace.go | 6 -- crud/replace_many.go | 6 -- crud/result.go | 125 ++++++++++------------------------ crud/select.go | 3 - crud/tarantool_test.go | 14 ++-- crud/update.go | 3 - crud/upsert.go | 6 -- crud/upsert_many.go | 6 -- 18 files changed, 229 insertions(+), 150 deletions(-) create mode 100644 crud/example_test.go diff --git a/crud/delete.go b/crud/delete.go index 6592d1519..1fe8a3fe0 100644 --- a/crud/delete.go +++ b/crud/delete.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// DeleteResult describes result for `crud.delete` method. -type DeleteResult = Result - // DeleteOpts describes options for `crud.delete` method. type DeleteOpts = SimpleOperationOpts diff --git a/crud/error.go b/crud/error.go index 467c350a4..12d416cfd 100644 --- a/crud/error.go +++ b/crud/error.go @@ -75,6 +75,30 @@ type ErrorMany struct { Errors []Error } +// DecodeMsgpack provides custom msgpack decoder. +func (e *ErrorMany) DecodeMsgpack(d *decoder) error { + l, err := d.DecodeArrayLen() + if err != nil { + return err + } + + var errs []Error + for i := 0; i < l; i++ { + var crudErr *Error = nil + if err := d.Decode(&crudErr); err != nil { + return err + } else if crudErr != nil { + errs = append(errs, *crudErr) + } + } + + if len(errs) > 0 { + *e = ErrorMany{Errors: errs} + } + + return nil +} + // Error converts an Error to a string. func (errs ErrorMany) Error() string { var str []string diff --git a/crud/example_test.go b/crud/example_test.go new file mode 100644 index 000000000..fade59ae8 --- /dev/null +++ b/crud/example_test.go @@ -0,0 +1,150 @@ +package crud_test + +import ( + "fmt" + "reflect" + "time" + + "github.com/tarantool/go-tarantool" + "github.com/tarantool/go-tarantool/crud" +) + +const ( + exampleServer = "127.0.0.1:3013" + exampleSpace = "test" +) + +var exampleOpts = tarantool.Opts{ + Timeout: 500 * time.Millisecond, + User: "test", + Pass: "test", +} + +func exampleConnect() *tarantool.Connection { + conn, err := tarantool.Connect(exampleServer, exampleOpts) + if err != nil { + panic("Connection is not established: " + err.Error()) + } + return conn +} + +// ExampleResult_rowsInterface demonstrates how to use a helper type Result +// to decode a crud response. In this example, rows are decoded as an +// interface{} type. +func ExampleResult_rowsInterface() { + conn := exampleConnect() + req := crud.NewReplaceRequest(exampleSpace). + Tuple([]interface{}{uint(2010), nil, "bla"}) + + ret := crud.Result{} + if err := conn.Do(req).GetTyped(&ret); err != nil { + fmt.Printf("Failed to execute request: %s", err) + return + } + + fmt.Println(ret.Metadata) + fmt.Println(ret.Rows) + // Output: + // [{id unsigned false} {bucket_id unsigned true} {name string false}] + // [[2010 45 bla]] +} + +// ExampleResult_rowsCustomType demonstrates how to use a helper type Result +// to decode a crud response. In this example, rows are decoded as a +// custom type. +func ExampleResult_rowsCustomType() { + conn := exampleConnect() + req := crud.NewReplaceRequest(exampleSpace). + Tuple([]interface{}{uint(2010), nil, "bla"}) + + type Tuple struct { + _msgpack struct{} `msgpack:",asArray"` //nolint: structcheck,unused + Id uint64 + BucketId uint64 + Name string + } + ret := crud.MakeResult(reflect.TypeOf(Tuple{})) + + if err := conn.Do(req).GetTyped(&ret); err != nil { + fmt.Printf("Failed to execute request: %s", err) + return + } + + fmt.Println(ret.Metadata) + rows := ret.Rows.([]Tuple) + fmt.Println(rows) + // Output: + // [{id unsigned false} {bucket_id unsigned true} {name string false}] + // [{{} 2010 45 bla}] +} + +// ExampleResult_many demonstrates that there is no difference in a +// response from *ManyRequest. +func ExampleResult_many() { + conn := exampleConnect() + req := crud.NewReplaceManyRequest(exampleSpace). + Tuples([]crud.Tuple{ + []interface{}{uint(2010), nil, "bla"}, + []interface{}{uint(2011), nil, "bla"}, + }) + + ret := crud.Result{} + if err := conn.Do(req).GetTyped(&ret); err != nil { + fmt.Printf("Failed to execute request: %s", err) + return + } + + fmt.Println(ret.Metadata) + fmt.Println(ret.Rows) + // Output: + // [{id unsigned false} {bucket_id unsigned true} {name string false}] + // [[2010 45 bla] [2011 4 bla]] +} + +// ExampleResult_error demonstrates how to use a helper type Result +// to handle a crud error. +func ExampleResult_error() { + conn := exampleConnect() + req := crud.NewReplaceRequest("not_exist"). + Tuple([]interface{}{uint(2010), nil, "bla"}) + + ret := crud.Result{} + if err := conn.Do(req).GetTyped(&ret); err != nil { + crudErr := err.(crud.Error) + fmt.Printf("Failed to execute request: %s", crudErr) + } else { + fmt.Println(ret.Metadata) + fmt.Println(ret.Rows) + } + // Output: + // Failed to execute request: ReplaceError: Space "not_exist" doesn't exist +} + +// ExampleResult_errorMany demonstrates how to use a helper type Result +// to handle a crud error for a *ManyRequest. +func ExampleResult_errorMany() { + conn := exampleConnect() + initReq := crud.NewReplaceRequest("not_exist"). + Tuple([]interface{}{uint(2010), nil, "bla"}) + if _, err := conn.Do(initReq).Get(); err != nil { + fmt.Printf("Failed to initialize the example: %s\n", err) + } + + req := crud.NewInsertManyRequest(exampleSpace). + Tuples([]crud.Tuple{ + []interface{}{uint(2010), nil, "bla"}, + []interface{}{uint(2010), nil, "bla"}, + }) + ret := crud.Result{} + if err := conn.Do(req).GetTyped(&ret); err != nil { + crudErr := err.(crud.ErrorMany) + // We need to trim the error message to make the example repeatable. + errmsg := crudErr.Error()[:10] + fmt.Printf("Failed to execute request: %s", errmsg) + } else { + fmt.Println(ret.Metadata) + fmt.Println(ret.Rows) + } + // Output: + // Failed to execute request: CallError: +} diff --git a/crud/get.go b/crud/get.go index 4234431f6..0c15bf9a9 100644 --- a/crud/get.go +++ b/crud/get.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// GetResult describes result for `crud.get` method. -type GetResult = Result - // GetOpts describes options for `crud.get` method. type GetOpts struct { // Timeout is a `vshard.call` timeout and vshard diff --git a/crud/insert.go b/crud/insert.go index 480300249..20b441261 100644 --- a/crud/insert.go +++ b/crud/insert.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// InsertResult describes result for `crud.insert` method. -type InsertResult = Result - // InsertOpts describes options for `crud.insert` method. type InsertOpts = SimpleOperationOpts @@ -65,9 +62,6 @@ func (req *InsertRequest) Context(ctx context.Context) *InsertRequest { return req } -// InsertObjectResult describes result for `crud.insert_object` method. -type InsertObjectResult = Result - // InsertObjectOpts describes options for `crud.insert_object` method. type InsertObjectOpts = SimpleOperationObjectOpts diff --git a/crud/insert_many.go b/crud/insert_many.go index 11784f660..98931a3c8 100644 --- a/crud/insert_many.go +++ b/crud/insert_many.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// InsertManyResult describes result for `crud.insert_many` method. -type InsertManyResult = ResultMany - // InsertManyOpts describes options for `crud.insert_many` method. type InsertManyOpts = OperationManyOpts @@ -65,9 +62,6 @@ func (req *InsertManyRequest) Context(ctx context.Context) *InsertManyRequest { return req } -// InsertObjectManyResult describes result for `crud.insert_object_many` method. -type InsertObjectManyResult = ResultMany - // InsertObjectManyOpts describes options for `crud.insert_object_many` method. type InsertObjectManyOpts = OperationObjectManyOpts diff --git a/crud/max.go b/crud/max.go index 842f24d5a..73660a205 100644 --- a/crud/max.go +++ b/crud/max.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// MaxResult describes result for `crud.max` method. -type MaxResult = Result - // MaxOpts describes options for `crud.max` method. type MaxOpts = BorderOpts diff --git a/crud/min.go b/crud/min.go index 720b6f782..b9f4c0f41 100644 --- a/crud/min.go +++ b/crud/min.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// MinResult describes result for `crud.min` method. -type MinResult = Result - // MinOpts describes options for `crud.min` method. type MinOpts = BorderOpts diff --git a/crud/msgpack.go b/crud/msgpack.go index be1c88f7f..b9696b15e 100644 --- a/crud/msgpack.go +++ b/crud/msgpack.go @@ -5,6 +5,7 @@ package crud import ( "gopkg.in/vmihailenco/msgpack.v2" + msgpcode "gopkg.in/vmihailenco/msgpack.v2/codes" ) type encoder = msgpack.Encoder @@ -21,3 +22,8 @@ type MapObject map[string]interface{} func (o MapObject) EncodeMsgpack(enc *encoder) { enc.Encode(o) } + +func msgpackIsArray(code byte) bool { + return code == msgpcode.Array16 || code == msgpcode.Array32 || + msgpcode.IsFixedArray(code) +} diff --git a/crud/msgpack_v5.go b/crud/msgpack_v5.go index 3bbbf09fd..393e359c3 100644 --- a/crud/msgpack_v5.go +++ b/crud/msgpack_v5.go @@ -5,6 +5,7 @@ package crud import ( "github.com/vmihailenco/msgpack/v5" + "github.com/vmihailenco/msgpack/v5/msgpcode" ) type encoder = msgpack.Encoder @@ -21,3 +22,8 @@ type MapObject map[string]interface{} func (o MapObject) EncodeMsgpack(enc *encoder) { enc.Encode(o) } + +func msgpackIsArray(code byte) bool { + return code == msgpcode.Array16 || code == msgpcode.Array32 || + msgpcode.IsFixedArray(code) +} diff --git a/crud/replace.go b/crud/replace.go index 811a08eb8..d803bfaa6 100644 --- a/crud/replace.go +++ b/crud/replace.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// ReplaceResult describes result for `crud.replace` method. -type ReplaceResult = Result - // ReplaceOpts describes options for `crud.replace` method. type ReplaceOpts = SimpleOperationOpts @@ -65,9 +62,6 @@ func (req *ReplaceRequest) Context(ctx context.Context) *ReplaceRequest { return req } -// ReplaceObjectResult describes result for `crud.replace_object` method. -type ReplaceObjectResult = Result - // ReplaceObjectOpts describes options for `crud.replace_object` method. type ReplaceObjectOpts = SimpleOperationObjectOpts diff --git a/crud/replace_many.go b/crud/replace_many.go index 36350ac4b..503c1e5c3 100644 --- a/crud/replace_many.go +++ b/crud/replace_many.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// ReplaceManyResult describes result for `crud.replace_many` method. -type ReplaceManyResult = ResultMany - // ReplaceManyOpts describes options for `crud.replace_many` method. type ReplaceManyOpts = OperationManyOpts @@ -65,9 +62,6 @@ func (req *ReplaceManyRequest) Context(ctx context.Context) *ReplaceManyRequest return req } -// ReplaceObjectManyResult describes result for `crud.replace_object_many` method. -type ReplaceObjectManyResult = ResultMany - // ReplaceObjectManyOpts describes options for `crud.replace_object_many` method. type ReplaceObjectManyOpts = OperationObjectManyOpts diff --git a/crud/result.go b/crud/result.go index 356e2a817..5ee556a5f 100644 --- a/crud/result.go +++ b/crud/result.go @@ -2,6 +2,7 @@ package crud import ( "fmt" + "reflect" ) // FieldFormat contains field definition: {name='...',type='...'[,is_nullable=...]}. @@ -48,7 +49,15 @@ func (format *FieldFormat) DecodeMsgpack(d *decoder) error { // Result describes CRUD result as an object containing metadata and rows. type Result struct { Metadata []FieldFormat - Rows []interface{} + Rows interface{} + rowType reflect.Type +} + +// MakeResult create a Result object with a custom row type for decoding. +func MakeResult(rowType reflect.Type) Result { + return Result{ + rowType: rowType, + } } // DecodeMsgpack provides custom msgpack decoder. @@ -93,8 +102,19 @@ func (r *Result) DecodeMsgpack(d *decoder) error { r.Metadata = metadata case "rows": - if err = d.Decode(&r.Rows); err != nil { - return err + if r.rowType != nil { + tuples := reflect.New(reflect.SliceOf(r.rowType)) + if err = d.DecodeValue(tuples); err != nil { + fmt.Println(tuples) + return err + } + r.Rows = tuples.Elem().Interface() + } else { + var decoded []interface{} + if err = d.Decode(&decoded); err != nil { + return err + } + r.Rows = decoded } default: if err := d.Skip(); err != nil { @@ -103,96 +123,27 @@ func (r *Result) DecodeMsgpack(d *decoder) error { } } - var crudErr *Error = nil - - if err := d.Decode(&crudErr); err != nil { - return err - } - - for i := 2; i < arrLen; i++ { - if err := d.Skip(); err != nil { - return err - } - } - - if crudErr != nil { - return crudErr - } - - return nil -} - -// ResultMany describes CRUD result as an object containing metadata and rows. -type ResultMany struct { - Metadata []FieldFormat - Rows []interface{} -} - -// DecodeMsgpack provides custom msgpack decoder. -func (r *ResultMany) DecodeMsgpack(d *decoder) error { - arrLen, err := d.DecodeArrayLen() + code, err := d.PeekCode() if err != nil { return err } - if arrLen < 2 { - return fmt.Errorf("array len doesn't match: %d", arrLen) - } - - l, err := d.DecodeMapLen() - if err != nil { - return err - } - - for i := 0; i < l; i++ { - key, err := d.DecodeString() - if err != nil { + var retErr error + if msgpackIsArray(code) { + var crudErr *ErrorMany + if err := d.Decode(&crudErr); err != nil { return err } - - switch key { - case "metadata": - metadataLen, err := d.DecodeArrayLen() - if err != nil { - return err - } - - metadata := make([]FieldFormat, metadataLen) - - for i := 0; i < metadataLen; i++ { - fieldFormat := FieldFormat{} - if err = d.Decode(&fieldFormat); err != nil { - return err - } - - metadata[i] = fieldFormat - } - - r.Metadata = metadata - case "rows": - if err = d.Decode(&r.Rows); err != nil { - return err - } - default: - if err := d.Skip(); err != nil { - return err - } + if crudErr != nil { + retErr = *crudErr } - } - - errLen, err := d.DecodeArrayLen() - if err != nil { - return err - } - - var errs []Error - for i := 0; i < errLen; i++ { - var crudErr *Error = nil - + } else { + var crudErr *Error if err := d.Decode(&crudErr); err != nil { return err - } else if crudErr != nil { - errs = append(errs, *crudErr) + } + if crudErr != nil { + retErr = *crudErr } } @@ -202,11 +153,7 @@ func (r *ResultMany) DecodeMsgpack(d *decoder) error { } } - if len(errs) > 0 { - return &ErrorMany{Errors: errs} - } - - return nil + return retErr } // NumberResult describes CRUD result as an object containing number. diff --git a/crud/select.go b/crud/select.go index 5ada1aa99..3f06ff91d 100644 --- a/crud/select.go +++ b/crud/select.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// SelectResult describes result for `crud.select` method. -type SelectResult = Result - // SelectOpts describes options for `crud.select` method. type SelectOpts struct { // Timeout is a `vshard.call` timeout and vshard diff --git a/crud/tarantool_test.go b/crud/tarantool_test.go index 33959a026..c889cdc72 100644 --- a/crud/tarantool_test.go +++ b/crud/tarantool_test.go @@ -215,12 +215,12 @@ var testResultWithErrCases = []struct { }{ { "BaseResult", - &crud.SelectResult{}, + &crud.Result{}, crud.NewSelectRequest(invalidSpaceName).Opts(selectOpts), }, { "ManyResult", - &crud.ReplaceManyResult{}, + &crud.Result{}, crud.NewReplaceManyRequest(invalidSpaceName).Opts(opManyOpts), }, { @@ -691,18 +691,18 @@ func TestBaseResult(t *testing.T) { defer conn.Close() req := crud.NewSelectRequest(spaceName).Opts(selectOpts) - resp := crud.SelectResult{} + resp := crud.Result{} testCrudRequestPrepareData(t, conn) err := conn.Do(req).GetTyped(&resp) if err != nil { - t.Fatalf("Failed to Do CRUD request: %s", err.Error()) + t.Fatalf("Failed to Do CRUD request: %s", err) } require.ElementsMatch(t, resp.Metadata, expectedMetadata) - if len(resp.Rows) != 10 { + if len(resp.Rows.([]interface{})) != 10 { t.Fatalf("Unexpected rows: %#v", resp.Rows) } @@ -734,7 +734,7 @@ func TestManyResult(t *testing.T) { defer conn.Close() req := crud.NewReplaceManyRequest(spaceName).Tuples(tuples).Opts(opManyOpts) - resp := crud.ReplaceResult{} + resp := crud.Result{} testCrudRequestPrepareData(t, conn) @@ -745,7 +745,7 @@ func TestManyResult(t *testing.T) { require.ElementsMatch(t, resp.Metadata, expectedMetadata) - if len(resp.Rows) != 10 { + if len(resp.Rows.([]interface{})) != 10 { t.Fatalf("Unexpected rows: %#v", resp.Rows) } diff --git a/crud/update.go b/crud/update.go index 09df6612d..f1d30eb50 100644 --- a/crud/update.go +++ b/crud/update.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// UpdateResult describes result for `crud.update` method. -type UpdateResult = Result - // UpdateOpts describes options for `crud.update` method. type UpdateOpts = SimpleOperationOpts diff --git a/crud/upsert.go b/crud/upsert.go index 07c373b68..e66b14ecd 100644 --- a/crud/upsert.go +++ b/crud/upsert.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// UpsertResult describes result for `crud.upsert` method. -type UpsertResult = Result - // UpsertOpts describes options for `crud.upsert` method. type UpsertOpts = SimpleOperationOpts @@ -76,9 +73,6 @@ func (req *UpsertRequest) Context(ctx context.Context) *UpsertRequest { return req } -// UpsertObjectResult describes result for `crud.upsert_object` method. -type UpsertObjectResult = Result - // UpsertObjectOpts describes options for `crud.upsert_object` method. type UpsertObjectOpts = SimpleOperationOpts diff --git a/crud/upsert_many.go b/crud/upsert_many.go index b7bdcad81..37d533d4a 100644 --- a/crud/upsert_many.go +++ b/crud/upsert_many.go @@ -6,9 +6,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// UpsertManyResult describes result for `crud.upsert_many` method. -type UpsertManyResult = ResultMany - // UpsertManyOpts describes options for `crud.upsert_many` method. type UpsertManyOpts = OperationManyOpts @@ -74,9 +71,6 @@ func (req *UpsertManyRequest) Context(ctx context.Context) *UpsertManyRequest { return req } -// UpsertObjectManyResult describes result for `crud.upsert_object_many` method. -type UpsertObjectManyResult = ResultMany - // UpsertObjectManyOpts describes options for `crud.upsert_object_many` method. type UpsertObjectManyOpts = OperationManyOpts From 6d684abfbad3ad0d414a78b51220af7a6e65f614 Mon Sep 17 00:00:00 2001 From: Oleg Jukovec Date: Tue, 14 Mar 2023 12:07:19 +0300 Subject: [PATCH 3/5] crud: allow any type as Tuple This is necessary to use a custom types with custom encoders as tuples. Part of #271 --- crud/common.go | 3 --- crud/delete.go | 2 +- crud/get.go | 2 +- crud/insert.go | 2 +- crud/replace.go | 2 +- crud/tarantool_test.go | 2 +- crud/tuple.go | 5 +++++ crud/unflatten_rows.go | 9 ++------- crud/update.go | 2 +- crud/upsert.go | 2 +- 10 files changed, 14 insertions(+), 17 deletions(-) create mode 100644 crud/tuple.go diff --git a/crud/common.go b/crud/common.go index 877ac2d4a..51271761a 100644 --- a/crud/common.go +++ b/crud/common.go @@ -59,9 +59,6 @@ import ( "github.com/tarantool/go-tarantool" ) -// Tuple is a type to describe tuple for CRUD methods. -type Tuple = []interface{} - type baseRequest struct { impl *tarantool.CallRequest } diff --git a/crud/delete.go b/crud/delete.go index 1fe8a3fe0..b388858aa 100644 --- a/crud/delete.go +++ b/crud/delete.go @@ -29,7 +29,7 @@ func NewDeleteRequest(space string) *DeleteRequest { req := new(DeleteRequest) req.initImpl("crud.delete") req.setSpace(space) - req.key = Tuple{} + req.key = []interface{}{} req.opts = DeleteOpts{} return req } diff --git a/crud/get.go b/crud/get.go index 0c15bf9a9..f2c9ae732 100644 --- a/crud/get.go +++ b/crud/get.go @@ -64,7 +64,7 @@ func NewGetRequest(space string) *GetRequest { req := new(GetRequest) req.initImpl("crud.get") req.setSpace(space) - req.key = Tuple{} + req.key = []interface{}{} req.opts = GetOpts{} return req } diff --git a/crud/insert.go b/crud/insert.go index 20b441261..121bcbd65 100644 --- a/crud/insert.go +++ b/crud/insert.go @@ -29,7 +29,7 @@ func NewInsertRequest(space string) *InsertRequest { req := new(InsertRequest) req.initImpl("crud.insert") req.setSpace(space) - req.tuple = Tuple{} + req.tuple = []interface{}{} req.opts = InsertOpts{} return req } diff --git a/crud/replace.go b/crud/replace.go index d803bfaa6..51da7a614 100644 --- a/crud/replace.go +++ b/crud/replace.go @@ -29,7 +29,7 @@ func NewReplaceRequest(space string) *ReplaceRequest { req := new(ReplaceRequest) req.initImpl("crud.replace") req.setSpace(space) - req.tuple = Tuple{} + req.tuple = []interface{}{} req.opts = ReplaceOpts{} return req } diff --git a/crud/tarantool_test.go b/crud/tarantool_test.go index c889cdc72..34c7f9184 100644 --- a/crud/tarantool_test.go +++ b/crud/tarantool_test.go @@ -347,7 +347,7 @@ var testGenerateDataCases = []struct { func generateTuples() []crud.Tuple { tpls := []crud.Tuple{} for i := 1010; i < 1020; i++ { - tpls = append(tpls, crud.Tuple{uint(i), nil, "bla"}) + tpls = append(tpls, []interface{}{uint(i), nil, "bla"}) } return tpls diff --git a/crud/tuple.go b/crud/tuple.go new file mode 100644 index 000000000..61291cbb0 --- /dev/null +++ b/crud/tuple.go @@ -0,0 +1,5 @@ +package crud + +// Tuple is a type to describe tuple for CRUD methods. It can be any type that +// msgpask can encode. +type Tuple = interface{} diff --git a/crud/unflatten_rows.go b/crud/unflatten_rows.go index 2efb65999..67ebb2b69 100644 --- a/crud/unflatten_rows.go +++ b/crud/unflatten_rows.go @@ -8,20 +8,15 @@ import ( func UnflattenRows(tuples []interface{}, format []interface{}) ([]MapObject, error) { var ( ok bool - tuple Tuple fieldName string fieldInfo map[interface{}]interface{} ) objects := []MapObject{} - for _, rawTuple := range tuples { + for _, tuple := range tuples { object := make(map[string]interface{}) - if tuple, ok = rawTuple.(Tuple); !ok { - return nil, fmt.Errorf("Unexpected tuple format: %q", rawTuple) - } - - for fieldIdx, field := range tuple { + for fieldIdx, field := range tuple.([]interface{}) { if fieldInfo, ok = format[fieldIdx].(map[interface{}]interface{}); !ok { return nil, fmt.Errorf("Unexpected space format: %q", format) } diff --git a/crud/update.go b/crud/update.go index f1d30eb50..05a0188e2 100644 --- a/crud/update.go +++ b/crud/update.go @@ -31,7 +31,7 @@ func NewUpdateRequest(space string) *UpdateRequest { req := new(UpdateRequest) req.initImpl("crud.update") req.setSpace(space) - req.key = Tuple{} + req.key = []interface{}{} req.operations = []Operation{} req.opts = UpdateOpts{} return req diff --git a/crud/upsert.go b/crud/upsert.go index e66b14ecd..9f4723b88 100644 --- a/crud/upsert.go +++ b/crud/upsert.go @@ -31,7 +31,7 @@ func NewUpsertRequest(space string) *UpsertRequest { req := new(UpsertRequest) req.initImpl("crud.upsert") req.setSpace(space) - req.tuple = Tuple{} + req.tuple = []interface{}{} req.operations = []Operation{} req.opts = UpsertOpts{} return req From 3a98b2c7654fde22b1e40d1f344ccb27a7d0a733 Mon Sep 17 00:00:00 2001 From: Oleg Jukovec Date: Tue, 14 Mar 2023 12:44:42 +0300 Subject: [PATCH 4/5] crud: make less allocations In this patch, we try to make less allocations per a request. Part of #271 --- crud/common.go | 14 ++-- crud/count.go | 20 +++-- crud/delete.go | 4 +- crud/get.go | 16 ++-- crud/insert.go | 8 +- crud/insert_many.go | 8 +- crud/len.go | 4 +- crud/max.go | 4 +- crud/min.go | 4 +- crud/options.go | 164 +++++++++++++++++++++++------------------ crud/replace.go | 8 +- crud/replace_many.go | 8 +- crud/request_test.go | 40 ++++++++++ crud/select.go | 24 ++++-- crud/stats.go | 6 +- crud/storage_info.go | 2 +- crud/tarantool_test.go | 51 +++---------- crud/truncate.go | 4 +- crud/update.go | 4 +- crud/upsert.go | 8 +- crud/upsert_many.go | 8 +- go.mod | 8 +- go.sum | 31 +------- request.go | 7 +- 24 files changed, 236 insertions(+), 219 deletions(-) diff --git a/crud/common.go b/crud/common.go index 51271761a..2c4a3030c 100644 --- a/crud/common.go +++ b/crud/common.go @@ -63,22 +63,22 @@ type baseRequest struct { impl *tarantool.CallRequest } -func (req *baseRequest) initImpl(methodName string) { - req.impl = tarantool.NewCall17Request(methodName) +func newCall(method string) *tarantool.CallRequest { + return tarantool.NewCall17Request(method) } // Code returns IPROTO code for CRUD request. -func (req *baseRequest) Code() int32 { +func (req baseRequest) Code() int32 { return req.impl.Code() } // Ctx returns a context of CRUD request. -func (req *baseRequest) Ctx() context.Context { +func (req baseRequest) Ctx() context.Context { return req.impl.Ctx() } // Async returns is CRUD request expects a response. -func (req *baseRequest) Async() bool { +func (req baseRequest) Async() bool { return req.impl.Async() } @@ -86,7 +86,3 @@ type spaceRequest struct { baseRequest space string } - -func (req *spaceRequest) setSpace(space string) { - req.space = space -} diff --git a/crud/count.go b/crud/count.go index 2a3992389..01768dd53 100644 --- a/crud/count.go +++ b/crud/count.go @@ -42,17 +42,23 @@ type CountOpts struct { func (opts CountOpts) EncodeMsgpack(enc *encoder) error { const optsCnt = 9 - options := [optsCnt]option{opts.Timeout, opts.VshardRouter, - opts.Mode, opts.PreferReplica, opts.Balance, - opts.YieldEvery, opts.BucketId, opts.ForceMapCall, - opts.Fullscan} names := [optsCnt]string{timeoutOptName, vshardRouterOptName, modeOptName, preferReplicaOptName, balanceOptName, yieldEveryOptName, bucketIdOptName, forceMapCallOptName, fullscanOptName} values := [optsCnt]interface{}{} + exists := [optsCnt]bool{} + values[0], exists[0] = opts.Timeout.Get() + values[1], exists[1] = opts.VshardRouter.Get() + values[2], exists[2] = opts.Mode.Get() + values[3], exists[3] = opts.PreferReplica.Get() + values[4], exists[4] = opts.Balance.Get() + values[5], exists[5] = opts.YieldEvery.Get() + values[6], exists[6] = opts.BucketId.Get() + values[7], exists[7] = opts.ForceMapCall.Get() + values[8], exists[8] = opts.Fullscan.Get() - return encodeOptions(enc, options[:], names[:], values[:]) + return encodeOptions(enc, names[:], values[:], exists[:]) } // CountRequest helps you to create request object to call `crud.count` @@ -73,8 +79,8 @@ type countArgs struct { // NewCountRequest returns a new empty CountRequest. func NewCountRequest(space string) *CountRequest { req := new(CountRequest) - req.initImpl("crud.count") - req.setSpace(space) + req.impl = newCall("crud.count") + req.space = space req.conditions = nil req.opts = CountOpts{} return req diff --git a/crud/delete.go b/crud/delete.go index b388858aa..502419316 100644 --- a/crud/delete.go +++ b/crud/delete.go @@ -27,8 +27,8 @@ type deleteArgs struct { // NewDeleteRequest returns a new empty DeleteRequest. func NewDeleteRequest(space string) *DeleteRequest { req := new(DeleteRequest) - req.initImpl("crud.delete") - req.setSpace(space) + req.impl = newCall("crud.delete") + req.space = space req.key = []interface{}{} req.opts = DeleteOpts{} return req diff --git a/crud/get.go b/crud/get.go index f2c9ae732..d7096d52f 100644 --- a/crud/get.go +++ b/crud/get.go @@ -33,15 +33,19 @@ type GetOpts struct { func (opts GetOpts) EncodeMsgpack(enc *encoder) error { const optsCnt = 7 - options := [optsCnt]option{opts.Timeout, opts.VshardRouter, - opts.Fields, opts.BucketId, opts.Mode, - opts.PreferReplica, opts.Balance} names := [optsCnt]string{timeoutOptName, vshardRouterOptName, fieldsOptName, bucketIdOptName, modeOptName, preferReplicaOptName, balanceOptName} values := [optsCnt]interface{}{} + exists := [optsCnt]bool{} + values[0], exists[0] = opts.Timeout.Get() + values[1], exists[1] = opts.VshardRouter.Get() + values[1], exists[1] = opts.BucketId.Get() + values[2], exists[2] = opts.Mode.Get() + values[3], exists[3] = opts.PreferReplica.Get() + values[4], exists[4] = opts.Balance.Get() - return encodeOptions(enc, options[:], names[:], values[:]) + return encodeOptions(enc, names[:], values[:], exists[:]) } // GetRequest helps you to create request object to call `crud.get` @@ -62,8 +66,8 @@ type getArgs struct { // NewGetRequest returns a new empty GetRequest. func NewGetRequest(space string) *GetRequest { req := new(GetRequest) - req.initImpl("crud.get") - req.setSpace(space) + req.impl = newCall("crud.get") + req.space = space req.key = []interface{}{} req.opts = GetOpts{} return req diff --git a/crud/insert.go b/crud/insert.go index 121bcbd65..4fcc1ebb9 100644 --- a/crud/insert.go +++ b/crud/insert.go @@ -27,8 +27,8 @@ type insertArgs struct { // NewInsertRequest returns a new empty InsertRequest. func NewInsertRequest(space string) *InsertRequest { req := new(InsertRequest) - req.initImpl("crud.insert") - req.setSpace(space) + req.impl = newCall("crud.insert") + req.space = space req.tuple = []interface{}{} req.opts = InsertOpts{} return req @@ -83,8 +83,8 @@ type insertObjectArgs struct { // NewInsertObjectRequest returns a new empty InsertObjectRequest. func NewInsertObjectRequest(space string) *InsertObjectRequest { req := new(InsertObjectRequest) - req.initImpl("crud.insert_object") - req.setSpace(space) + req.impl = newCall("crud.insert_object") + req.space = space req.object = MapObject{} req.opts = InsertObjectOpts{} return req diff --git a/crud/insert_many.go b/crud/insert_many.go index 98931a3c8..b6695ebba 100644 --- a/crud/insert_many.go +++ b/crud/insert_many.go @@ -27,8 +27,8 @@ type insertManyArgs struct { // NewInsertManyRequest returns a new empty InsertManyRequest. func NewInsertManyRequest(space string) *InsertManyRequest { req := new(InsertManyRequest) - req.initImpl("crud.insert_many") - req.setSpace(space) + req.impl = newCall("crud.insert_many") + req.space = space req.tuples = []Tuple{} req.opts = InsertManyOpts{} return req @@ -83,8 +83,8 @@ type insertObjectManyArgs struct { // NewInsertObjectManyRequest returns a new empty InsertObjectManyRequest. func NewInsertObjectManyRequest(space string) *InsertObjectManyRequest { req := new(InsertObjectManyRequest) - req.initImpl("crud.insert_object_many") - req.setSpace(space) + req.impl = newCall("crud.insert_object_many") + req.space = space req.objects = []Object{} req.opts = InsertObjectManyOpts{} return req diff --git a/crud/len.go b/crud/len.go index 6a8c85a2a..9d409e40d 100644 --- a/crud/len.go +++ b/crud/len.go @@ -28,8 +28,8 @@ type lenArgs struct { // NewLenRequest returns a new empty LenRequest. func NewLenRequest(space string) *LenRequest { req := new(LenRequest) - req.initImpl("crud.len") - req.setSpace(space) + req.impl = newCall("crud.len") + req.space = space req.opts = LenOpts{} return req } diff --git a/crud/max.go b/crud/max.go index 73660a205..5ea44878a 100644 --- a/crud/max.go +++ b/crud/max.go @@ -27,8 +27,8 @@ type maxArgs struct { // NewMaxRequest returns a new empty MaxRequest. func NewMaxRequest(space string) *MaxRequest { req := new(MaxRequest) - req.initImpl("crud.max") - req.setSpace(space) + req.impl = newCall("crud.max") + req.space = space req.index = []interface{}{} req.opts = MaxOpts{} return req diff --git a/crud/min.go b/crud/min.go index b9f4c0f41..88fba9e0c 100644 --- a/crud/min.go +++ b/crud/min.go @@ -27,8 +27,8 @@ type minArgs struct { // NewMinRequest returns a new empty MinRequest. func NewMinRequest(space string) *MinRequest { req := new(MinRequest) - req.initImpl("crud.min") - req.setSpace(space) + req.impl = newCall("crud.min") + req.space = space req.index = []interface{}{} req.opts = MinOpts{} return req diff --git a/crud/options.go b/crud/options.go index c0a201033..9bec34754 100644 --- a/crud/options.go +++ b/crud/options.go @@ -1,11 +1,5 @@ package crud -import ( - "errors" - - "github.com/markphelps/optional" -) - const ( timeoutOptName = "timeout" vshardRouterOptName = "vshard_router" @@ -25,86 +19,95 @@ const ( batchSizeOptName = "batch_size" ) -type option interface { - getInterface() (interface{}, error) -} - // OptUint is an optional uint. type OptUint struct { - optional.Uint + value uint + exist bool } -// NewOptUint creates an optional uint from value. -func NewOptUint(value uint) OptUint { - return OptUint{optional.NewUint(value)} +// MakeOptUint creates an optional uint from value. +func MakeOptUint(value uint) OptUint { + return OptUint{ + value: value, + exist: true, + } } -func (opt OptUint) getInterface() (interface{}, error) { - return opt.Get() +// Get returns the integer value or an error if not present. +func (opt OptUint) Get() (uint, bool) { + return opt.value, opt.exist } // OptInt is an optional int. type OptInt struct { - optional.Int + value int + exist bool } -// NewOptInt creates an optional int from value. -func NewOptInt(value int) OptInt { - return OptInt{optional.NewInt(value)} +// MakeOptInt creates an optional int from value. +func MakeOptInt(value int) OptInt { + return OptInt{ + value: value, + exist: true, + } } -func (opt OptInt) getInterface() (interface{}, error) { - return opt.Get() +// Get returns the integer value or an error if not present. +func (opt OptInt) Get() (int, bool) { + return opt.value, opt.exist } // OptString is an optional string. type OptString struct { - optional.String + value string + exist bool } -// NewOptString creates an optional string from value. -func NewOptString(value string) OptString { - return OptString{optional.NewString(value)} +// MakeOptString creates an optional string from value. +func MakeOptString(value string) OptString { + return OptString{ + value: value, + exist: true, + } } -func (opt OptString) getInterface() (interface{}, error) { - return opt.Get() +// Get returns the string value or an error if not present. +func (opt OptString) Get() (string, bool) { + return opt.value, opt.exist } // OptBool is an optional bool. type OptBool struct { - optional.Bool + value bool + exist bool } -// NewOptBool creates an optional bool from value. -func NewOptBool(value bool) OptBool { - return OptBool{optional.NewBool(value)} +// MakeOptBool creates an optional bool from value. +func MakeOptBool(value bool) OptBool { + return OptBool{ + value: value, + exist: true, + } } -func (opt OptBool) getInterface() (interface{}, error) { - return opt.Get() +// Get returns the boolean value or an error if not present. +func (opt OptBool) Get() (bool, bool) { + return opt.value, opt.exist } // OptTuple is an optional tuple. type OptTuple struct { - tuple []interface{} + tuple interface{} } -// NewOptTuple creates an optional tuple from tuple. -func NewOptTuple(tuple []interface{}) OptTuple { +// MakeOptTuple creates an optional tuple from tuple. +func MakeOptTuple(tuple interface{}) OptTuple { return OptTuple{tuple} } // Get returns the tuple value or an error if not present. -func (o *OptTuple) Get() ([]interface{}, error) { - if o.tuple == nil { - return nil, errors.New("value not present") - } - return o.tuple, nil -} - -func (opt OptTuple) getInterface() (interface{}, error) { - return opt.Get() +func (o *OptTuple) Get() (interface{}, bool) { + return o.tuple, o.tuple != nil } // BaseOpts describes base options for CRUD operations. @@ -121,11 +124,13 @@ type BaseOpts struct { func (opts BaseOpts) EncodeMsgpack(enc *encoder) error { const optsCnt = 2 - options := [optsCnt]option{opts.Timeout, opts.VshardRouter} names := [optsCnt]string{timeoutOptName, vshardRouterOptName} values := [optsCnt]interface{}{} + exists := [optsCnt]bool{} + values[0], exists[0] = opts.Timeout.Get() + values[1], exists[1] = opts.VshardRouter.Get() - return encodeOptions(enc, options[:], names[:], values[:]) + return encodeOptions(enc, names[:], values[:], exists[:]) } // SimpleOperationOpts describes options for simple CRUD operations. @@ -146,13 +151,16 @@ type SimpleOperationOpts struct { func (opts SimpleOperationOpts) EncodeMsgpack(enc *encoder) error { const optsCnt = 4 - options := [optsCnt]option{opts.Timeout, opts.VshardRouter, - opts.Fields, opts.BucketId} names := [optsCnt]string{timeoutOptName, vshardRouterOptName, fieldsOptName, bucketIdOptName} values := [optsCnt]interface{}{} + exists := [optsCnt]bool{} + values[0], exists[0] = opts.Timeout.Get() + values[1], exists[1] = opts.VshardRouter.Get() + values[2], exists[2] = opts.Fields.Get() + values[3], exists[3] = opts.BucketId.Get() - return encodeOptions(enc, options[:], names[:], values[:]) + return encodeOptions(enc, names[:], values[:], exists[:]) } // SimpleOperationObjectOpts describes options for simple CRUD @@ -177,13 +185,17 @@ type SimpleOperationObjectOpts struct { func (opts SimpleOperationObjectOpts) EncodeMsgpack(enc *encoder) error { const optsCnt = 5 - options := [optsCnt]option{opts.Timeout, opts.VshardRouter, - opts.Fields, opts.BucketId, opts.SkipNullabilityCheckOnFlatten} names := [optsCnt]string{timeoutOptName, vshardRouterOptName, fieldsOptName, bucketIdOptName, skipNullabilityCheckOnFlattenOptName} values := [optsCnt]interface{}{} - - return encodeOptions(enc, options[:], names[:], values[:]) + exists := [optsCnt]bool{} + values[0], exists[0] = opts.Timeout.Get() + values[1], exists[1] = opts.VshardRouter.Get() + values[2], exists[2] = opts.Fields.Get() + values[3], exists[3] = opts.BucketId.Get() + values[4], exists[4] = opts.SkipNullabilityCheckOnFlatten.Get() + + return encodeOptions(enc, names[:], values[:], exists[:]) } // OperationManyOpts describes options for CRUD operations with many tuples. @@ -209,13 +221,17 @@ type OperationManyOpts struct { func (opts OperationManyOpts) EncodeMsgpack(enc *encoder) error { const optsCnt = 5 - options := [optsCnt]option{opts.Timeout, opts.VshardRouter, - opts.Fields, opts.StopOnError, opts.RollbackOnError} names := [optsCnt]string{timeoutOptName, vshardRouterOptName, fieldsOptName, stopOnErrorOptName, rollbackOnErrorOptName} values := [optsCnt]interface{}{} - - return encodeOptions(enc, options[:], names[:], values[:]) + exists := [optsCnt]bool{} + values[0], exists[0] = opts.Timeout.Get() + values[1], exists[1] = opts.VshardRouter.Get() + values[2], exists[2] = opts.Fields.Get() + values[3], exists[3] = opts.StopOnError.Get() + values[4], exists[4] = opts.RollbackOnError.Get() + + return encodeOptions(enc, names[:], values[:], exists[:]) } // OperationObjectManyOpts describes options for CRUD operations @@ -245,15 +261,19 @@ type OperationObjectManyOpts struct { func (opts OperationObjectManyOpts) EncodeMsgpack(enc *encoder) error { const optsCnt = 6 - options := [optsCnt]option{opts.Timeout, opts.VshardRouter, - opts.Fields, opts.StopOnError, opts.RollbackOnError, - opts.SkipNullabilityCheckOnFlatten} names := [optsCnt]string{timeoutOptName, vshardRouterOptName, fieldsOptName, stopOnErrorOptName, rollbackOnErrorOptName, skipNullabilityCheckOnFlattenOptName} values := [optsCnt]interface{}{} - - return encodeOptions(enc, options[:], names[:], values[:]) + exists := [optsCnt]bool{} + values[0], exists[0] = opts.Timeout.Get() + values[1], exists[1] = opts.VshardRouter.Get() + values[2], exists[2] = opts.Fields.Get() + values[3], exists[3] = opts.StopOnError.Get() + values[4], exists[4] = opts.RollbackOnError.Get() + values[5], exists[5] = opts.SkipNullabilityCheckOnFlatten.Get() + + return encodeOptions(enc, names[:], values[:], exists[:]) } // BorderOpts describes options for `crud.min` and `crud.max`. @@ -272,19 +292,21 @@ type BorderOpts struct { func (opts BorderOpts) EncodeMsgpack(enc *encoder) error { const optsCnt = 3 - options := [optsCnt]option{opts.Timeout, opts.VshardRouter, opts.Fields} names := [optsCnt]string{timeoutOptName, vshardRouterOptName, fieldsOptName} values := [optsCnt]interface{}{} + exists := [optsCnt]bool{} + values[0], exists[0] = opts.Timeout.Get() + values[1], exists[1] = opts.VshardRouter.Get() + values[2], exists[2] = opts.Fields.Get() - return encodeOptions(enc, options[:], names[:], values[:]) + return encodeOptions(enc, names[:], values[:], exists[:]) } -func encodeOptions(enc *encoder, options []option, names []string, values []interface{}) error { +func encodeOptions(enc *encoder, names []string, values []interface{}, exists []bool) error { mapLen := 0 - for i, opt := range options { - if value, err := opt.getInterface(); err == nil { - values[i] = value + for _, exist := range exists { + if exist { mapLen += 1 } } @@ -295,7 +317,7 @@ func encodeOptions(enc *encoder, options []option, names []string, values []inte if mapLen > 0 { for i, name := range names { - if values[i] != nil { + if exists[i] { enc.EncodeString(name) enc.Encode(values[i]) } diff --git a/crud/replace.go b/crud/replace.go index 51da7a614..49be0a18f 100644 --- a/crud/replace.go +++ b/crud/replace.go @@ -27,8 +27,8 @@ type replaceArgs struct { // NewReplaceRequest returns a new empty ReplaceRequest. func NewReplaceRequest(space string) *ReplaceRequest { req := new(ReplaceRequest) - req.initImpl("crud.replace") - req.setSpace(space) + req.impl = newCall("crud.replace") + req.space = space req.tuple = []interface{}{} req.opts = ReplaceOpts{} return req @@ -83,8 +83,8 @@ type replaceObjectArgs struct { // NewReplaceObjectRequest returns a new empty ReplaceObjectRequest. func NewReplaceObjectRequest(space string) *ReplaceObjectRequest { req := new(ReplaceObjectRequest) - req.initImpl("crud.replace_object") - req.setSpace(space) + req.impl = newCall("crud.replace_object") + req.space = space req.object = MapObject{} req.opts = ReplaceObjectOpts{} return req diff --git a/crud/replace_many.go b/crud/replace_many.go index 503c1e5c3..cf95e89b2 100644 --- a/crud/replace_many.go +++ b/crud/replace_many.go @@ -27,8 +27,8 @@ type replaceManyArgs struct { // NewReplaceManyRequest returns a new empty ReplaceManyRequest. func NewReplaceManyRequest(space string) *ReplaceManyRequest { req := new(ReplaceManyRequest) - req.initImpl("crud.replace_many") - req.setSpace(space) + req.impl = newCall("crud.replace_many") + req.space = space req.tuples = []Tuple{} req.opts = ReplaceManyOpts{} return req @@ -83,8 +83,8 @@ type replaceObjectManyArgs struct { // NewReplaceObjectManyRequest returns a new empty ReplaceObjectManyRequest. func NewReplaceObjectManyRequest(space string) *ReplaceObjectManyRequest { req := new(ReplaceObjectManyRequest) - req.initImpl("crud.replace_object_many") - req.setSpace(space) + req.impl = newCall("crud.replace_object_many") + req.space = space req.objects = []Object{} req.opts = ReplaceObjectManyOpts{} return req diff --git a/crud/request_test.go b/crud/request_test.go index f7af05223..fe36a861b 100644 --- a/crud/request_test.go +++ b/crud/request_test.go @@ -109,6 +109,46 @@ func assertBodyEqual(t testing.TB, reference tarantool.Request, req tarantool.Re } } +func BenchmarkLenRequest(b *testing.B) { + buf := bytes.Buffer{} + buf.Grow(512 * 1024 * 1024) // Avoid allocs in test. + enc := newEncoder(&buf) + + b.ResetTimer() + + for i := 0; i < b.N; i++ { + buf.Reset() + req := crud.NewLenRequest(spaceName). + Opts(crud.LenOpts{ + Timeout: crud.MakeOptUint(3), + }) + if err := req.Body(nil, enc); err != nil { + b.Error(err) + } + } +} + +func BenchmarkSelectRequest(b *testing.B) { + buf := bytes.Buffer{} + buf.Grow(512 * 1024 * 1024) // Avoid allocs in test. + enc := newEncoder(&buf) + + b.ResetTimer() + + for i := 0; i < b.N; i++ { + buf.Reset() + req := crud.NewSelectRequest(spaceName). + Opts(crud.SelectOpts{ + Timeout: crud.MakeOptUint(3), + VshardRouter: crud.MakeOptString("asd"), + Balance: crud.MakeOptBool(true), + }) + if err := req.Body(nil, enc); err != nil { + b.Error(err) + } + } +} + func TestRequestsCodes(t *testing.T) { tests := []struct { req tarantool.Request diff --git a/crud/select.go b/crud/select.go index 3f06ff91d..e9c1f7681 100644 --- a/crud/select.go +++ b/crud/select.go @@ -45,19 +45,27 @@ type SelectOpts struct { func (opts SelectOpts) EncodeMsgpack(enc *encoder) error { const optsCnt = 12 - options := [optsCnt]option{opts.Timeout, opts.VshardRouter, - opts.Fields, opts.BucketId, - opts.Mode, opts.PreferReplica, opts.Balance, - opts.First, opts.After, opts.BatchSize, - opts.ForceMapCall, opts.Fullscan} names := [optsCnt]string{timeoutOptName, vshardRouterOptName, fieldsOptName, bucketIdOptName, modeOptName, preferReplicaOptName, balanceOptName, firstOptName, afterOptName, batchSizeOptName, forceMapCallOptName, fullscanOptName} values := [optsCnt]interface{}{} + exists := [optsCnt]bool{} + values[0], exists[0] = opts.Timeout.Get() + values[1], exists[1] = opts.VshardRouter.Get() + values[2], exists[2] = opts.Fields.Get() + values[3], exists[3] = opts.BucketId.Get() + values[4], exists[4] = opts.Mode.Get() + values[5], exists[5] = opts.PreferReplica.Get() + values[6], exists[6] = opts.Balance.Get() + values[7], exists[7] = opts.First.Get() + values[8], exists[8] = opts.After.Get() + values[8], exists[8] = opts.BatchSize.Get() + values[8], exists[8] = opts.ForceMapCall.Get() + values[8], exists[8] = opts.Fullscan.Get() - return encodeOptions(enc, options[:], names[:], values[:]) + return encodeOptions(enc, names[:], values[:], exists[:]) } // SelectRequest helps you to create request object to call `crud.select` @@ -78,8 +86,8 @@ type selectArgs struct { // NewSelectRequest returns a new empty SelectRequest. func NewSelectRequest(space string) *SelectRequest { req := new(SelectRequest) - req.initImpl("crud.select") - req.setSpace(space) + req.impl = newCall("crud.select") + req.space = space req.conditions = nil req.opts = SelectOpts{} return req diff --git a/crud/stats.go b/crud/stats.go index 939ed32ce..72be6a309 100644 --- a/crud/stats.go +++ b/crud/stats.go @@ -16,21 +16,21 @@ type StatsRequest struct { // NewStatsRequest returns a new empty StatsRequest. func NewStatsRequest() *StatsRequest { req := new(StatsRequest) - req.initImpl("crud.stats") + req.impl = newCall("crud.stats") return req } // Space sets the space name for the StatsRequest request. // Note: default value is nil. func (req *StatsRequest) Space(space string) *StatsRequest { - req.space = NewOptString(space) + req.space = MakeOptString(space) return req } // Body fills an encoder with the call request body. func (req *StatsRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := []interface{}{} - if value, err := req.space.Get(); err == nil { + if value, ok := req.space.Get(); ok { args = []interface{}{value} } req.impl.Args(args) diff --git a/crud/storage_info.go b/crud/storage_info.go index a52ca710c..2858d3e46 100644 --- a/crud/storage_info.go +++ b/crud/storage_info.go @@ -103,7 +103,7 @@ type storageInfoArgs struct { // NewStorageInfoRequest returns a new empty StorageInfoRequest. func NewStorageInfoRequest() *StorageInfoRequest { req := new(StorageInfoRequest) - req.initImpl("crud.storage_info") + req.impl = newCall("crud.storage_info") req.opts = StorageInfoOpts{} return req } diff --git a/crud/tarantool_test.go b/crud/tarantool_test.go index 34c7f9184..f30b7d5c2 100644 --- a/crud/tarantool_test.go +++ b/crud/tarantool_test.go @@ -1,7 +1,6 @@ package crud_test import ( - "bytes" "fmt" "log" "os" @@ -47,43 +46,43 @@ var operations = []crud.Operation{ } var selectOpts = crud.SelectOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var countOpts = crud.CountOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var getOpts = crud.GetOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var minOpts = crud.MinOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var maxOpts = crud.MaxOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var baseOpts = crud.BaseOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var simpleOperationOpts = crud.SimpleOperationOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var simpleOperationObjectOpts = crud.SimpleOperationObjectOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var opManyOpts = crud.OperationManyOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var opObjManyOpts = crud.OperationObjectManyOpts{ - Timeout: crud.NewOptUint(timeout), + Timeout: crud.MakeOptUint(timeout), } var conditions = []crud.Condition{ @@ -105,36 +104,6 @@ var object = crud.MapObject{ "name": "bla", } -func BenchmarkCrud(b *testing.B) { - var err error - - conn := test_helpers.ConnectWithValidation(b, server, opts) - defer conn.Close() - - _, err = conn.Replace(spaceName, tuple) - if err != nil { - b.Error(err) - } - req := crud.NewLenRequest(spaceName). - Opts(crud.LenOpts{ - Timeout: crud.NewOptUint(3), - VshardRouter: crud.NewOptString("asd"), - }) - - buf := bytes.Buffer{} - buf.Grow(512 * 1024 * 1024) // Avoid allocs in test. - enc := newEncoder(&buf) - - b.ResetTimer() - - for i := 0; i < b.N; i++ { - err := req.Body(nil, enc) - if err != nil { - b.Error(err) - } - } -} - var testProcessDataCases = []struct { name string expectedRespLen int diff --git a/crud/truncate.go b/crud/truncate.go index e2d6b029d..6d00540d4 100644 --- a/crud/truncate.go +++ b/crud/truncate.go @@ -28,8 +28,8 @@ type truncateArgs struct { // NewTruncateRequest returns a new empty TruncateRequest. func NewTruncateRequest(space string) *TruncateRequest { req := new(TruncateRequest) - req.initImpl("crud.truncate") - req.setSpace(space) + req.impl = newCall("crud.truncate") + req.space = space req.opts = TruncateOpts{} return req } diff --git a/crud/update.go b/crud/update.go index 05a0188e2..8fa676ffd 100644 --- a/crud/update.go +++ b/crud/update.go @@ -29,8 +29,8 @@ type updateArgs struct { // NewUpdateRequest returns a new empty UpdateRequest. func NewUpdateRequest(space string) *UpdateRequest { req := new(UpdateRequest) - req.initImpl("crud.update") - req.setSpace(space) + req.impl = newCall("crud.update") + req.space = space req.key = []interface{}{} req.operations = []Operation{} req.opts = UpdateOpts{} diff --git a/crud/upsert.go b/crud/upsert.go index 9f4723b88..15c3c9fd2 100644 --- a/crud/upsert.go +++ b/crud/upsert.go @@ -29,8 +29,8 @@ type upsertArgs struct { // NewUpsertRequest returns a new empty UpsertRequest. func NewUpsertRequest(space string) *UpsertRequest { req := new(UpsertRequest) - req.initImpl("crud.upsert") - req.setSpace(space) + req.impl = newCall("crud.upsert") + req.space = space req.tuple = []interface{}{} req.operations = []Operation{} req.opts = UpsertOpts{} @@ -96,8 +96,8 @@ type upsertObjectArgs struct { // NewUpsertObjectRequest returns a new empty UpsertObjectRequest. func NewUpsertObjectRequest(space string) *UpsertObjectRequest { req := new(UpsertObjectRequest) - req.initImpl("crud.upsert_object") - req.setSpace(space) + req.impl = newCall("crud.upsert_object") + req.space = space req.object = MapObject{} req.operations = []Operation{} req.opts = UpsertObjectOpts{} diff --git a/crud/upsert_many.go b/crud/upsert_many.go index 37d533d4a..d2089b09a 100644 --- a/crud/upsert_many.go +++ b/crud/upsert_many.go @@ -34,8 +34,8 @@ type upsertManyArgs struct { // NewUpsertManyRequest returns a new empty UpsertManyRequest. func NewUpsertManyRequest(space string) *UpsertManyRequest { req := new(UpsertManyRequest) - req.initImpl("crud.upsert_many") - req.setSpace(space) + req.impl = newCall("crud.upsert_many") + req.space = space req.tuplesOperationsData = []TupleOperationsData{} req.opts = UpsertManyOpts{} return req @@ -99,8 +99,8 @@ type upsertObjectManyArgs struct { // NewUpsertObjectManyRequest returns a new empty UpsertObjectManyRequest. func NewUpsertObjectManyRequest(space string) *UpsertObjectManyRequest { req := new(UpsertObjectManyRequest) - req.initImpl("crud.upsert_object_many") - req.setSpace(space) + req.impl = newCall("crud.upsert_object_many") + req.space = space req.objectsOperationsData = []ObjectOperationsData{} req.opts = UpsertObjectManyOpts{} return req diff --git a/go.mod b/go.mod index ac2f980d2..ee97cb2a1 100644 --- a/go.mod +++ b/go.mod @@ -3,17 +3,15 @@ module github.com/tarantool/go-tarantool go 1.11 require ( - github.com/google/go-cmp v0.5.7 // indirect github.com/google/uuid v1.3.0 - github.com/markphelps/optional v0.10.0 // indirect github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect - github.com/pkg/errors v0.9.1 // indirect github.com/shopspring/decimal v1.3.1 - github.com/stretchr/testify v1.7.1 // indirect + github.com/stretchr/testify v1.7.1 github.com/tarantool/go-openssl v0.0.8-0.20230307065445-720eeb389195 github.com/vmihailenco/msgpack/v5 v5.3.5 + golang.org/x/net v0.0.0-20201021035429-f5854403a974 // indirect + golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4 // indirect google.golang.org/appengine v1.6.7 // indirect gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect gopkg.in/vmihailenco/msgpack.v2 v2.9.2 - gotest.tools/v3 v3.2.0 // indirect ) diff --git a/go.sum b/go.sum index c819e6e50..733f1f96e 100644 --- a/go.sum +++ b/go.sum @@ -1,35 +1,23 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o= -github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/markphelps/optional v0.10.0 h1:vTaMRRTuN7aPY5X8g6K82W23qR4VMqBNyniC5BIJlqo= -github.com/markphelps/optional v0.10.0/go.mod h1:Fvjs1vxcm7/wDqJPFGEiEM1RuxFl9GCyxQlj9M9YMAQ= github.com/mattn/go-pointer v0.0.1 h1:n+XhsuGeVO6MEAp7xyEukFINEa+Quek5psIR/ylA6o0= github.com/mattn/go-pointer v0.0.1/go.mod h1:2zXcozF6qYGgmsG+SeTZz3oAbFLdD3OWqnUbNvJZAlc= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8= github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 h1:RC6RW7j+1+HkWaX/Yh71Ee5ZHaHYt7ZP4sQgUrm6cDU= github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572/go.mod h1:w0SWMsp6j9O/dk4/ZpIhL+3CkG8ofA2vuv7k+ltqUMc= -github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= @@ -39,45 +27,28 @@ github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9 github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc= github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g= github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds= -github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190603091049-60506f45cf65 h1:+rhAzEzT3f4JtomfC371qB+0Ola2caSKcY69NUBZrRQ= golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974 h1:IX6qOQeG5uLjB/hjjwjedwfjND0hgjPMMyO1RoIXQNI= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb h1:fgwFCsaw9buMuxNd6+DQfAuSFqbNiQZpcgJQAgJsK6k= golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4 h1:myAQVi0cGEoqQVR5POX+8RR2mrocKqNN1hmeMqhX27k= golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c= google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/vmihailenco/msgpack.v2 v2.9.2 h1:gjPqo9orRVlSAH/065qw3MsFCDpH7fa1KpiizXyllY4= gopkg.in/vmihailenco/msgpack.v2 v2.9.2/go.mod h1:/3Dn1Npt9+MYyLpYYXjInO/5jvMLamn+AEGwNEOatn8= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gotest.tools/v3 v3.2.0 h1:I0DwBVMGAx26dttAj1BtJLAkVGncrkkUXfJLC4Flt/I= -gotest.tools/v3 v3.2.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= diff --git a/request.go b/request.go index f6d3cc245..7c79c5863 100644 --- a/request.go +++ b/request.go @@ -1120,7 +1120,6 @@ func NewCallRequest(function string) *CallRequest { req := new(CallRequest) req.requestCode = CallRequestCode req.function = function - req.args = []interface{}{} return req } @@ -1133,7 +1132,11 @@ func (req *CallRequest) Args(args interface{}) *CallRequest { // Body fills an encoder with the call request body. func (req *CallRequest) Body(res SchemaResolver, enc *encoder) error { - return fillCall(enc, req.function, req.args) + args := req.args + if args == nil { + args = []interface{}{} + } + return fillCall(enc, req.function, args) } // Context sets a passed context to the request. From 48f383a38ceb6e3c502c694670cc371bb765b022 Mon Sep 17 00:00:00 2001 From: Oleg Jukovec Date: Wed, 15 Mar 2023 10:22:59 +0300 Subject: [PATCH 5/5] crud: make requests immutable Closes #271 --- crud/count.go | 14 +- crud/delete.go | 18 +-- crud/example_test.go | 12 +- crud/get.go | 18 +-- crud/insert.go | 36 +++--- crud/insert_many.go | 36 +++--- crud/len.go | 12 +- crud/max.go | 15 +-- crud/min.go | 15 +-- crud/replace.go | 36 +++--- crud/replace_many.go | 36 +++--- crud/request_test.go | 284 ++++++++++++++++++++--------------------- crud/select.go | 14 +- crud/stats.go | 18 +-- crud/storage_info.go | 12 +- crud/tarantool_test.go | 77 ++++++----- crud/truncate.go | 12 +- crud/update.go | 20 +-- crud/upsert.go | 40 +++--- crud/upsert_many.go | 30 ++--- 20 files changed, 394 insertions(+), 361 deletions(-) diff --git a/crud/count.go b/crud/count.go index 01768dd53..68e29f9fb 100644 --- a/crud/count.go +++ b/crud/count.go @@ -76,9 +76,9 @@ type countArgs struct { Opts CountOpts } -// NewCountRequest returns a new empty CountRequest. -func NewCountRequest(space string) *CountRequest { - req := new(CountRequest) +// MakeCountRequest returns a new empty CountRequest. +func MakeCountRequest(space string) CountRequest { + req := CountRequest{} req.impl = newCall("crud.count") req.space = space req.conditions = nil @@ -88,27 +88,27 @@ func NewCountRequest(space string) *CountRequest { // Conditions sets the conditions for the CountRequest request. // Note: default value is nil. -func (req *CountRequest) Conditions(conditions []Condition) *CountRequest { +func (req CountRequest) Conditions(conditions []Condition) CountRequest { req.conditions = conditions return req } // Opts sets the options for the CountRequest request. // Note: default value is nil. -func (req *CountRequest) Opts(opts CountOpts) *CountRequest { +func (req CountRequest) Opts(opts CountOpts) CountRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *CountRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req CountRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := countArgs{Space: req.space, Conditions: req.conditions, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *CountRequest) Context(ctx context.Context) *CountRequest { +func (req CountRequest) Context(ctx context.Context) CountRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/delete.go b/crud/delete.go index 502419316..5859d3d6b 100644 --- a/crud/delete.go +++ b/crud/delete.go @@ -24,39 +24,41 @@ type deleteArgs struct { Opts DeleteOpts } -// NewDeleteRequest returns a new empty DeleteRequest. -func NewDeleteRequest(space string) *DeleteRequest { - req := new(DeleteRequest) +// MakeDeleteRequest returns a new empty DeleteRequest. +func MakeDeleteRequest(space string) DeleteRequest { + req := DeleteRequest{} req.impl = newCall("crud.delete") req.space = space - req.key = []interface{}{} req.opts = DeleteOpts{} return req } // Key sets the key for the DeleteRequest request. // Note: default value is nil. -func (req *DeleteRequest) Key(key Tuple) *DeleteRequest { +func (req DeleteRequest) Key(key Tuple) DeleteRequest { req.key = key return req } // Opts sets the options for the DeleteRequest request. // Note: default value is nil. -func (req *DeleteRequest) Opts(opts DeleteOpts) *DeleteRequest { +func (req DeleteRequest) Opts(opts DeleteOpts) DeleteRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *DeleteRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req DeleteRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.key == nil { + req.key = []interface{}{} + } args := deleteArgs{Space: req.space, Key: req.key, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *DeleteRequest) Context(ctx context.Context) *DeleteRequest { +func (req DeleteRequest) Context(ctx context.Context) DeleteRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/example_test.go b/crud/example_test.go index fade59ae8..3f2ebbf88 100644 --- a/crud/example_test.go +++ b/crud/example_test.go @@ -33,7 +33,7 @@ func exampleConnect() *tarantool.Connection { // interface{} type. func ExampleResult_rowsInterface() { conn := exampleConnect() - req := crud.NewReplaceRequest(exampleSpace). + req := crud.MakeReplaceRequest(exampleSpace). Tuple([]interface{}{uint(2010), nil, "bla"}) ret := crud.Result{} @@ -54,7 +54,7 @@ func ExampleResult_rowsInterface() { // custom type. func ExampleResult_rowsCustomType() { conn := exampleConnect() - req := crud.NewReplaceRequest(exampleSpace). + req := crud.MakeReplaceRequest(exampleSpace). Tuple([]interface{}{uint(2010), nil, "bla"}) type Tuple struct { @@ -82,7 +82,7 @@ func ExampleResult_rowsCustomType() { // response from *ManyRequest. func ExampleResult_many() { conn := exampleConnect() - req := crud.NewReplaceManyRequest(exampleSpace). + req := crud.MakeReplaceManyRequest(exampleSpace). Tuples([]crud.Tuple{ []interface{}{uint(2010), nil, "bla"}, []interface{}{uint(2011), nil, "bla"}, @@ -105,7 +105,7 @@ func ExampleResult_many() { // to handle a crud error. func ExampleResult_error() { conn := exampleConnect() - req := crud.NewReplaceRequest("not_exist"). + req := crud.MakeReplaceRequest("not_exist"). Tuple([]interface{}{uint(2010), nil, "bla"}) ret := crud.Result{} @@ -124,13 +124,13 @@ func ExampleResult_error() { // to handle a crud error for a *ManyRequest. func ExampleResult_errorMany() { conn := exampleConnect() - initReq := crud.NewReplaceRequest("not_exist"). + initReq := crud.MakeReplaceRequest("not_exist"). Tuple([]interface{}{uint(2010), nil, "bla"}) if _, err := conn.Do(initReq).Get(); err != nil { fmt.Printf("Failed to initialize the example: %s\n", err) } - req := crud.NewInsertManyRequest(exampleSpace). + req := crud.MakeInsertManyRequest(exampleSpace). Tuples([]crud.Tuple{ []interface{}{uint(2010), nil, "bla"}, []interface{}{uint(2010), nil, "bla"}, diff --git a/crud/get.go b/crud/get.go index d7096d52f..9f65a34fd 100644 --- a/crud/get.go +++ b/crud/get.go @@ -63,39 +63,41 @@ type getArgs struct { Opts GetOpts } -// NewGetRequest returns a new empty GetRequest. -func NewGetRequest(space string) *GetRequest { - req := new(GetRequest) +// MakeGetRequest returns a new empty GetRequest. +func MakeGetRequest(space string) GetRequest { + req := GetRequest{} req.impl = newCall("crud.get") req.space = space - req.key = []interface{}{} req.opts = GetOpts{} return req } // Key sets the key for the GetRequest request. // Note: default value is nil. -func (req *GetRequest) Key(key Tuple) *GetRequest { +func (req GetRequest) Key(key Tuple) GetRequest { req.key = key return req } // Opts sets the options for the GetRequest request. // Note: default value is nil. -func (req *GetRequest) Opts(opts GetOpts) *GetRequest { +func (req GetRequest) Opts(opts GetOpts) GetRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *GetRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req GetRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.key == nil { + req.key = []interface{}{} + } args := getArgs{Space: req.space, Key: req.key, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *GetRequest) Context(ctx context.Context) *GetRequest { +func (req GetRequest) Context(ctx context.Context) GetRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/insert.go b/crud/insert.go index 4fcc1ebb9..b8c34c9bd 100644 --- a/crud/insert.go +++ b/crud/insert.go @@ -24,39 +24,41 @@ type insertArgs struct { Opts InsertOpts } -// NewInsertRequest returns a new empty InsertRequest. -func NewInsertRequest(space string) *InsertRequest { - req := new(InsertRequest) +// MakeInsertRequest returns a new empty InsertRequest. +func MakeInsertRequest(space string) InsertRequest { + req := InsertRequest{} req.impl = newCall("crud.insert") req.space = space - req.tuple = []interface{}{} req.opts = InsertOpts{} return req } // Tuple sets the tuple for the InsertRequest request. // Note: default value is nil. -func (req *InsertRequest) Tuple(tuple Tuple) *InsertRequest { +func (req InsertRequest) Tuple(tuple Tuple) InsertRequest { req.tuple = tuple return req } // Opts sets the options for the insert request. // Note: default value is nil. -func (req *InsertRequest) Opts(opts InsertOpts) *InsertRequest { +func (req InsertRequest) Opts(opts InsertOpts) InsertRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *InsertRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req InsertRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.tuple == nil { + req.tuple = []interface{}{} + } args := insertArgs{Space: req.space, Tuple: req.tuple, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *InsertRequest) Context(ctx context.Context) *InsertRequest { +func (req InsertRequest) Context(ctx context.Context) InsertRequest { req.impl = req.impl.Context(ctx) return req @@ -80,39 +82,41 @@ type insertObjectArgs struct { Opts InsertObjectOpts } -// NewInsertObjectRequest returns a new empty InsertObjectRequest. -func NewInsertObjectRequest(space string) *InsertObjectRequest { - req := new(InsertObjectRequest) +// MakeInsertObjectRequest returns a new empty InsertObjectRequest. +func MakeInsertObjectRequest(space string) InsertObjectRequest { + req := InsertObjectRequest{} req.impl = newCall("crud.insert_object") req.space = space - req.object = MapObject{} req.opts = InsertObjectOpts{} return req } // Object sets the tuple for the InsertObjectRequest request. // Note: default value is nil. -func (req *InsertObjectRequest) Object(object Object) *InsertObjectRequest { +func (req InsertObjectRequest) Object(object Object) InsertObjectRequest { req.object = object return req } // Opts sets the options for the InsertObjectRequest request. // Note: default value is nil. -func (req *InsertObjectRequest) Opts(opts InsertObjectOpts) *InsertObjectRequest { +func (req InsertObjectRequest) Opts(opts InsertObjectOpts) InsertObjectRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *InsertObjectRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req InsertObjectRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.object == nil { + req.object = MapObject{} + } args := insertObjectArgs{Space: req.space, Object: req.object, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *InsertObjectRequest) Context(ctx context.Context) *InsertObjectRequest { +func (req InsertObjectRequest) Context(ctx context.Context) InsertObjectRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/insert_many.go b/crud/insert_many.go index b6695ebba..9d2194642 100644 --- a/crud/insert_many.go +++ b/crud/insert_many.go @@ -24,39 +24,41 @@ type insertManyArgs struct { Opts InsertManyOpts } -// NewInsertManyRequest returns a new empty InsertManyRequest. -func NewInsertManyRequest(space string) *InsertManyRequest { - req := new(InsertManyRequest) +// MakeInsertManyRequest returns a new empty InsertManyRequest. +func MakeInsertManyRequest(space string) InsertManyRequest { + req := InsertManyRequest{} req.impl = newCall("crud.insert_many") req.space = space - req.tuples = []Tuple{} req.opts = InsertManyOpts{} return req } // Tuples sets the tuples for the InsertManyRequest request. // Note: default value is nil. -func (req *InsertManyRequest) Tuples(tuples []Tuple) *InsertManyRequest { +func (req InsertManyRequest) Tuples(tuples []Tuple) InsertManyRequest { req.tuples = tuples return req } // Opts sets the options for the InsertManyRequest request. // Note: default value is nil. -func (req *InsertManyRequest) Opts(opts InsertManyOpts) *InsertManyRequest { +func (req InsertManyRequest) Opts(opts InsertManyOpts) InsertManyRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *InsertManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req InsertManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.tuples == nil { + req.tuples = []Tuple{} + } args := insertManyArgs{Space: req.space, Tuples: req.tuples, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *InsertManyRequest) Context(ctx context.Context) *InsertManyRequest { +func (req InsertManyRequest) Context(ctx context.Context) InsertManyRequest { req.impl = req.impl.Context(ctx) return req @@ -80,39 +82,41 @@ type insertObjectManyArgs struct { Opts InsertObjectManyOpts } -// NewInsertObjectManyRequest returns a new empty InsertObjectManyRequest. -func NewInsertObjectManyRequest(space string) *InsertObjectManyRequest { - req := new(InsertObjectManyRequest) +// MakeInsertObjectManyRequest returns a new empty InsertObjectManyRequest. +func MakeInsertObjectManyRequest(space string) InsertObjectManyRequest { + req := InsertObjectManyRequest{} req.impl = newCall("crud.insert_object_many") req.space = space - req.objects = []Object{} req.opts = InsertObjectManyOpts{} return req } // Objects sets the objects for the InsertObjectManyRequest request. // Note: default value is nil. -func (req *InsertObjectManyRequest) Objects(objects []Object) *InsertObjectManyRequest { +func (req InsertObjectManyRequest) Objects(objects []Object) InsertObjectManyRequest { req.objects = objects return req } // Opts sets the options for the InsertObjectManyRequest request. // Note: default value is nil. -func (req *InsertObjectManyRequest) Opts(opts InsertObjectManyOpts) *InsertObjectManyRequest { +func (req InsertObjectManyRequest) Opts(opts InsertObjectManyOpts) InsertObjectManyRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *InsertObjectManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req InsertObjectManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.objects == nil { + req.objects = []Object{} + } args := insertObjectManyArgs{Space: req.space, Objects: req.objects, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *InsertObjectManyRequest) Context(ctx context.Context) *InsertObjectManyRequest { +func (req InsertObjectManyRequest) Context(ctx context.Context) InsertObjectManyRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/len.go b/crud/len.go index 9d409e40d..8ebea253c 100644 --- a/crud/len.go +++ b/crud/len.go @@ -25,9 +25,9 @@ type lenArgs struct { Opts LenOpts } -// NewLenRequest returns a new empty LenRequest. -func NewLenRequest(space string) *LenRequest { - req := new(LenRequest) +// MakeLenRequest returns a new empty LenRequest. +func MakeLenRequest(space string) LenRequest { + req := LenRequest{} req.impl = newCall("crud.len") req.space = space req.opts = LenOpts{} @@ -36,20 +36,20 @@ func NewLenRequest(space string) *LenRequest { // Opts sets the options for the LenRequest request. // Note: default value is nil. -func (req *LenRequest) Opts(opts LenOpts) *LenRequest { +func (req LenRequest) Opts(opts LenOpts) LenRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *LenRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req LenRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := lenArgs{Space: req.space, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *LenRequest) Context(ctx context.Context) *LenRequest { +func (req LenRequest) Context(ctx context.Context) LenRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/max.go b/crud/max.go index 5ea44878a..fda960040 100644 --- a/crud/max.go +++ b/crud/max.go @@ -24,39 +24,38 @@ type maxArgs struct { Opts MaxOpts } -// NewMaxRequest returns a new empty MaxRequest. -func NewMaxRequest(space string) *MaxRequest { - req := new(MaxRequest) +// MakeMaxRequest returns a new empty MaxRequest. +func MakeMaxRequest(space string) MaxRequest { + req := MaxRequest{} req.impl = newCall("crud.max") req.space = space - req.index = []interface{}{} req.opts = MaxOpts{} return req } // Index sets the index name/id for the MaxRequest request. // Note: default value is nil. -func (req *MaxRequest) Index(index interface{}) *MaxRequest { +func (req MaxRequest) Index(index interface{}) MaxRequest { req.index = index return req } // Opts sets the options for the MaxRequest request. // Note: default value is nil. -func (req *MaxRequest) Opts(opts MaxOpts) *MaxRequest { +func (req MaxRequest) Opts(opts MaxOpts) MaxRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *MaxRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req MaxRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := maxArgs{Space: req.space, Index: req.index, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *MaxRequest) Context(ctx context.Context) *MaxRequest { +func (req MaxRequest) Context(ctx context.Context) MaxRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/min.go b/crud/min.go index 88fba9e0c..53794b21e 100644 --- a/crud/min.go +++ b/crud/min.go @@ -24,39 +24,38 @@ type minArgs struct { Opts MinOpts } -// NewMinRequest returns a new empty MinRequest. -func NewMinRequest(space string) *MinRequest { - req := new(MinRequest) +// MakeMinRequest returns a new empty MinRequest. +func MakeMinRequest(space string) MinRequest { + req := MinRequest{} req.impl = newCall("crud.min") req.space = space - req.index = []interface{}{} req.opts = MinOpts{} return req } // Index sets the index name/id for the MinRequest request. // Note: default value is nil. -func (req *MinRequest) Index(index interface{}) *MinRequest { +func (req MinRequest) Index(index interface{}) MinRequest { req.index = index return req } // Opts sets the options for the MinRequest request. // Note: default value is nil. -func (req *MinRequest) Opts(opts MinOpts) *MinRequest { +func (req MinRequest) Opts(opts MinOpts) MinRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *MinRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req MinRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := minArgs{Space: req.space, Index: req.index, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *MinRequest) Context(ctx context.Context) *MinRequest { +func (req MinRequest) Context(ctx context.Context) MinRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/replace.go b/crud/replace.go index 49be0a18f..378a1ae22 100644 --- a/crud/replace.go +++ b/crud/replace.go @@ -24,39 +24,41 @@ type replaceArgs struct { Opts ReplaceOpts } -// NewReplaceRequest returns a new empty ReplaceRequest. -func NewReplaceRequest(space string) *ReplaceRequest { - req := new(ReplaceRequest) +// MakeReplaceRequest returns a new empty ReplaceRequest. +func MakeReplaceRequest(space string) ReplaceRequest { + req := ReplaceRequest{} req.impl = newCall("crud.replace") req.space = space - req.tuple = []interface{}{} req.opts = ReplaceOpts{} return req } // Tuple sets the tuple for the ReplaceRequest request. // Note: default value is nil. -func (req *ReplaceRequest) Tuple(tuple Tuple) *ReplaceRequest { +func (req ReplaceRequest) Tuple(tuple Tuple) ReplaceRequest { req.tuple = tuple return req } // Opts sets the options for the ReplaceRequest request. // Note: default value is nil. -func (req *ReplaceRequest) Opts(opts ReplaceOpts) *ReplaceRequest { +func (req ReplaceRequest) Opts(opts ReplaceOpts) ReplaceRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *ReplaceRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req ReplaceRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.tuple == nil { + req.tuple = []interface{}{} + } args := replaceArgs{Space: req.space, Tuple: req.tuple, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *ReplaceRequest) Context(ctx context.Context) *ReplaceRequest { +func (req ReplaceRequest) Context(ctx context.Context) ReplaceRequest { req.impl = req.impl.Context(ctx) return req @@ -80,39 +82,41 @@ type replaceObjectArgs struct { Opts ReplaceObjectOpts } -// NewReplaceObjectRequest returns a new empty ReplaceObjectRequest. -func NewReplaceObjectRequest(space string) *ReplaceObjectRequest { - req := new(ReplaceObjectRequest) +// MakeReplaceObjectRequest returns a new empty ReplaceObjectRequest. +func MakeReplaceObjectRequest(space string) ReplaceObjectRequest { + req := ReplaceObjectRequest{} req.impl = newCall("crud.replace_object") req.space = space - req.object = MapObject{} req.opts = ReplaceObjectOpts{} return req } // Object sets the tuple for the ReplaceObjectRequest request. // Note: default value is nil. -func (req *ReplaceObjectRequest) Object(object Object) *ReplaceObjectRequest { +func (req ReplaceObjectRequest) Object(object Object) ReplaceObjectRequest { req.object = object return req } // Opts sets the options for the ReplaceObjectRequest request. // Note: default value is nil. -func (req *ReplaceObjectRequest) Opts(opts ReplaceObjectOpts) *ReplaceObjectRequest { +func (req ReplaceObjectRequest) Opts(opts ReplaceObjectOpts) ReplaceObjectRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *ReplaceObjectRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req ReplaceObjectRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.object == nil { + req.object = MapObject{} + } args := replaceObjectArgs{Space: req.space, Object: req.object, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *ReplaceObjectRequest) Context(ctx context.Context) *ReplaceObjectRequest { +func (req ReplaceObjectRequest) Context(ctx context.Context) ReplaceObjectRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/replace_many.go b/crud/replace_many.go index cf95e89b2..511d60575 100644 --- a/crud/replace_many.go +++ b/crud/replace_many.go @@ -24,39 +24,41 @@ type replaceManyArgs struct { Opts ReplaceManyOpts } -// NewReplaceManyRequest returns a new empty ReplaceManyRequest. -func NewReplaceManyRequest(space string) *ReplaceManyRequest { - req := new(ReplaceManyRequest) +// MakeReplaceManyRequest returns a new empty ReplaceManyRequest. +func MakeReplaceManyRequest(space string) ReplaceManyRequest { + req := ReplaceManyRequest{} req.impl = newCall("crud.replace_many") req.space = space - req.tuples = []Tuple{} req.opts = ReplaceManyOpts{} return req } // Tuples sets the tuples for the ReplaceManyRequest request. // Note: default value is nil. -func (req *ReplaceManyRequest) Tuples(tuples []Tuple) *ReplaceManyRequest { +func (req ReplaceManyRequest) Tuples(tuples []Tuple) ReplaceManyRequest { req.tuples = tuples return req } // Opts sets the options for the ReplaceManyRequest request. // Note: default value is nil. -func (req *ReplaceManyRequest) Opts(opts ReplaceManyOpts) *ReplaceManyRequest { +func (req ReplaceManyRequest) Opts(opts ReplaceManyOpts) ReplaceManyRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *ReplaceManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req ReplaceManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.tuples == nil { + req.tuples = []Tuple{} + } args := replaceManyArgs{Space: req.space, Tuples: req.tuples, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *ReplaceManyRequest) Context(ctx context.Context) *ReplaceManyRequest { +func (req ReplaceManyRequest) Context(ctx context.Context) ReplaceManyRequest { req.impl = req.impl.Context(ctx) return req @@ -80,39 +82,41 @@ type replaceObjectManyArgs struct { Opts ReplaceObjectManyOpts } -// NewReplaceObjectManyRequest returns a new empty ReplaceObjectManyRequest. -func NewReplaceObjectManyRequest(space string) *ReplaceObjectManyRequest { - req := new(ReplaceObjectManyRequest) +// MakeReplaceObjectManyRequest returns a new empty ReplaceObjectManyRequest. +func MakeReplaceObjectManyRequest(space string) ReplaceObjectManyRequest { + req := ReplaceObjectManyRequest{} req.impl = newCall("crud.replace_object_many") req.space = space - req.objects = []Object{} req.opts = ReplaceObjectManyOpts{} return req } // Objects sets the tuple for the ReplaceObjectManyRequest request. // Note: default value is nil. -func (req *ReplaceObjectManyRequest) Objects(objects []Object) *ReplaceObjectManyRequest { +func (req ReplaceObjectManyRequest) Objects(objects []Object) ReplaceObjectManyRequest { req.objects = objects return req } // Opts sets the options for the ReplaceObjectManyRequest request. // Note: default value is nil. -func (req *ReplaceObjectManyRequest) Opts(opts ReplaceObjectManyOpts) *ReplaceObjectManyRequest { +func (req ReplaceObjectManyRequest) Opts(opts ReplaceObjectManyOpts) ReplaceObjectManyRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *ReplaceObjectManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req ReplaceObjectManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.objects == nil { + req.objects = []Object{} + } args := replaceObjectManyArgs{Space: req.space, Objects: req.objects, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *ReplaceObjectManyRequest) Context(ctx context.Context) *ReplaceObjectManyRequest { +func (req ReplaceObjectManyRequest) Context(ctx context.Context) ReplaceObjectManyRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/request_test.go b/crud/request_test.go index fe36a861b..3198a39c0 100644 --- a/crud/request_test.go +++ b/crud/request_test.go @@ -118,7 +118,7 @@ func BenchmarkLenRequest(b *testing.B) { for i := 0; i < b.N; i++ { buf.Reset() - req := crud.NewLenRequest(spaceName). + req := crud.MakeLenRequest(spaceName). Opts(crud.LenOpts{ Timeout: crud.MakeOptUint(3), }) @@ -137,7 +137,7 @@ func BenchmarkSelectRequest(b *testing.B) { for i := 0; i < b.N; i++ { buf.Reset() - req := crud.NewSelectRequest(spaceName). + req := crud.MakeSelectRequest(spaceName). Opts(crud.SelectOpts{ Timeout: crud.MakeOptUint(3), VshardRouter: crud.MakeOptString("asd"), @@ -154,29 +154,29 @@ func TestRequestsCodes(t *testing.T) { req tarantool.Request code int32 }{ - {req: crud.NewInsertRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewInsertObjectRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewInsertManyRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewInsertObjectManyRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewGetRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewUpdateRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewDeleteRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewReplaceRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewReplaceObjectRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewReplaceManyRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewReplaceObjectManyRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewUpsertRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewUpsertObjectRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewUpsertManyRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewUpsertObjectManyRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewMinRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewMaxRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewSelectRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewTruncateRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewLenRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewCountRequest(validSpace), code: CrudRequestCode}, - {req: crud.NewStorageInfoRequest(), code: CrudRequestCode}, - {req: crud.NewStatsRequest(), code: CrudRequestCode}, + {req: crud.MakeInsertRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeInsertObjectRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeInsertManyRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeInsertObjectManyRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeGetRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeUpdateRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeDeleteRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeReplaceRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeReplaceObjectRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeReplaceManyRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeReplaceObjectManyRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeUpsertRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeUpsertObjectRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeUpsertManyRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeUpsertObjectManyRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeMinRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeMaxRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeSelectRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeTruncateRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeLenRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeCountRequest(validSpace), code: CrudRequestCode}, + {req: crud.MakeStorageInfoRequest(), code: CrudRequestCode}, + {req: crud.MakeStatsRequest(), code: CrudRequestCode}, } for _, test := range tests { @@ -191,29 +191,29 @@ func TestRequestsAsync(t *testing.T) { req tarantool.Request async bool }{ - {req: crud.NewInsertRequest(validSpace), async: false}, - {req: crud.NewInsertObjectRequest(validSpace), async: false}, - {req: crud.NewInsertManyRequest(validSpace), async: false}, - {req: crud.NewInsertObjectManyRequest(validSpace), async: false}, - {req: crud.NewGetRequest(validSpace), async: false}, - {req: crud.NewUpdateRequest(validSpace), async: false}, - {req: crud.NewDeleteRequest(validSpace), async: false}, - {req: crud.NewReplaceRequest(validSpace), async: false}, - {req: crud.NewReplaceObjectRequest(validSpace), async: false}, - {req: crud.NewReplaceManyRequest(validSpace), async: false}, - {req: crud.NewReplaceObjectManyRequest(validSpace), async: false}, - {req: crud.NewUpsertRequest(validSpace), async: false}, - {req: crud.NewUpsertObjectRequest(validSpace), async: false}, - {req: crud.NewUpsertManyRequest(validSpace), async: false}, - {req: crud.NewUpsertObjectManyRequest(validSpace), async: false}, - {req: crud.NewMinRequest(validSpace), async: false}, - {req: crud.NewMaxRequest(validSpace), async: false}, - {req: crud.NewSelectRequest(validSpace), async: false}, - {req: crud.NewTruncateRequest(validSpace), async: false}, - {req: crud.NewLenRequest(validSpace), async: false}, - {req: crud.NewCountRequest(validSpace), async: false}, - {req: crud.NewStorageInfoRequest(), async: false}, - {req: crud.NewStatsRequest(), async: false}, + {req: crud.MakeInsertRequest(validSpace), async: false}, + {req: crud.MakeInsertObjectRequest(validSpace), async: false}, + {req: crud.MakeInsertManyRequest(validSpace), async: false}, + {req: crud.MakeInsertObjectManyRequest(validSpace), async: false}, + {req: crud.MakeGetRequest(validSpace), async: false}, + {req: crud.MakeUpdateRequest(validSpace), async: false}, + {req: crud.MakeDeleteRequest(validSpace), async: false}, + {req: crud.MakeReplaceRequest(validSpace), async: false}, + {req: crud.MakeReplaceObjectRequest(validSpace), async: false}, + {req: crud.MakeReplaceManyRequest(validSpace), async: false}, + {req: crud.MakeReplaceObjectManyRequest(validSpace), async: false}, + {req: crud.MakeUpsertRequest(validSpace), async: false}, + {req: crud.MakeUpsertObjectRequest(validSpace), async: false}, + {req: crud.MakeUpsertManyRequest(validSpace), async: false}, + {req: crud.MakeUpsertObjectManyRequest(validSpace), async: false}, + {req: crud.MakeMinRequest(validSpace), async: false}, + {req: crud.MakeMaxRequest(validSpace), async: false}, + {req: crud.MakeSelectRequest(validSpace), async: false}, + {req: crud.MakeTruncateRequest(validSpace), async: false}, + {req: crud.MakeLenRequest(validSpace), async: false}, + {req: crud.MakeCountRequest(validSpace), async: false}, + {req: crud.MakeStorageInfoRequest(), async: false}, + {req: crud.MakeStatsRequest(), async: false}, } for _, test := range tests { @@ -228,29 +228,29 @@ func TestRequestsCtx_default(t *testing.T) { req tarantool.Request expected context.Context }{ - {req: crud.NewInsertRequest(validSpace), expected: nil}, - {req: crud.NewInsertObjectRequest(validSpace), expected: nil}, - {req: crud.NewInsertManyRequest(validSpace), expected: nil}, - {req: crud.NewInsertObjectManyRequest(validSpace), expected: nil}, - {req: crud.NewGetRequest(validSpace), expected: nil}, - {req: crud.NewUpdateRequest(validSpace), expected: nil}, - {req: crud.NewDeleteRequest(validSpace), expected: nil}, - {req: crud.NewReplaceRequest(validSpace), expected: nil}, - {req: crud.NewReplaceObjectRequest(validSpace), expected: nil}, - {req: crud.NewReplaceManyRequest(validSpace), expected: nil}, - {req: crud.NewReplaceObjectManyRequest(validSpace), expected: nil}, - {req: crud.NewUpsertRequest(validSpace), expected: nil}, - {req: crud.NewUpsertObjectRequest(validSpace), expected: nil}, - {req: crud.NewUpsertManyRequest(validSpace), expected: nil}, - {req: crud.NewUpsertObjectManyRequest(validSpace), expected: nil}, - {req: crud.NewMinRequest(validSpace), expected: nil}, - {req: crud.NewMaxRequest(validSpace), expected: nil}, - {req: crud.NewSelectRequest(validSpace), expected: nil}, - {req: crud.NewTruncateRequest(validSpace), expected: nil}, - {req: crud.NewLenRequest(validSpace), expected: nil}, - {req: crud.NewCountRequest(validSpace), expected: nil}, - {req: crud.NewStorageInfoRequest(), expected: nil}, - {req: crud.NewStatsRequest(), expected: nil}, + {req: crud.MakeInsertRequest(validSpace), expected: nil}, + {req: crud.MakeInsertObjectRequest(validSpace), expected: nil}, + {req: crud.MakeInsertManyRequest(validSpace), expected: nil}, + {req: crud.MakeInsertObjectManyRequest(validSpace), expected: nil}, + {req: crud.MakeGetRequest(validSpace), expected: nil}, + {req: crud.MakeUpdateRequest(validSpace), expected: nil}, + {req: crud.MakeDeleteRequest(validSpace), expected: nil}, + {req: crud.MakeReplaceRequest(validSpace), expected: nil}, + {req: crud.MakeReplaceObjectRequest(validSpace), expected: nil}, + {req: crud.MakeReplaceManyRequest(validSpace), expected: nil}, + {req: crud.MakeReplaceObjectManyRequest(validSpace), expected: nil}, + {req: crud.MakeUpsertRequest(validSpace), expected: nil}, + {req: crud.MakeUpsertObjectRequest(validSpace), expected: nil}, + {req: crud.MakeUpsertManyRequest(validSpace), expected: nil}, + {req: crud.MakeUpsertObjectManyRequest(validSpace), expected: nil}, + {req: crud.MakeMinRequest(validSpace), expected: nil}, + {req: crud.MakeMaxRequest(validSpace), expected: nil}, + {req: crud.MakeSelectRequest(validSpace), expected: nil}, + {req: crud.MakeTruncateRequest(validSpace), expected: nil}, + {req: crud.MakeLenRequest(validSpace), expected: nil}, + {req: crud.MakeCountRequest(validSpace), expected: nil}, + {req: crud.MakeStorageInfoRequest(), expected: nil}, + {req: crud.MakeStatsRequest(), expected: nil}, } for _, test := range tests { @@ -266,29 +266,29 @@ func TestRequestsCtx_setter(t *testing.T) { req tarantool.Request expected context.Context }{ - {req: crud.NewInsertRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewInsertObjectRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewInsertManyRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewInsertObjectManyRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewGetRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewUpdateRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewDeleteRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewReplaceRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewReplaceObjectRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewReplaceManyRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewReplaceObjectManyRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewUpsertRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewUpsertObjectRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewUpsertManyRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewUpsertObjectManyRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewMinRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewMaxRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewSelectRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewTruncateRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewLenRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewCountRequest(validSpace).Context(ctx), expected: ctx}, - {req: crud.NewStorageInfoRequest().Context(ctx), expected: ctx}, - {req: crud.NewStatsRequest().Context(ctx), expected: ctx}, + {req: crud.MakeInsertRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeInsertObjectRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeInsertManyRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeInsertObjectManyRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeGetRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeUpdateRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeDeleteRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeReplaceRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeReplaceObjectRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeReplaceManyRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeReplaceObjectManyRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeUpsertRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeUpsertObjectRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeUpsertManyRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeUpsertObjectManyRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeMinRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeMaxRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeSelectRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeTruncateRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeLenRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeCountRequest(validSpace).Context(ctx), expected: ctx}, + {req: crud.MakeStorageInfoRequest().Context(ctx), expected: ctx}, + {req: crud.MakeStatsRequest().Context(ctx), expected: ctx}, } for _, test := range tests { @@ -308,139 +308,139 @@ func TestRequestsDefaultValues(t *testing.T) { name: "InsertRequest", ref: tarantool.NewCall17Request("crud.insert").Args([]interface{}{validSpace, []interface{}{}, map[string]interface{}{}}), - target: crud.NewInsertRequest(validSpace), + target: crud.MakeInsertRequest(validSpace), }, { name: "InsertObjectRequest", ref: tarantool.NewCall17Request("crud.insert_object").Args([]interface{}{validSpace, map[string]interface{}{}, map[string]interface{}{}}), - target: crud.NewInsertObjectRequest(validSpace), + target: crud.MakeInsertObjectRequest(validSpace), }, { name: "InsertManyRequest", ref: tarantool.NewCall17Request("crud.insert_many").Args([]interface{}{validSpace, []interface{}{}, map[string]interface{}{}}), - target: crud.NewInsertManyRequest(validSpace), + target: crud.MakeInsertManyRequest(validSpace), }, { name: "InsertObjectManyRequest", ref: tarantool.NewCall17Request("crud.insert_object_many").Args([]interface{}{validSpace, []map[string]interface{}{}, map[string]interface{}{}}), - target: crud.NewInsertObjectManyRequest(validSpace), + target: crud.MakeInsertObjectManyRequest(validSpace), }, { name: "GetRequest", ref: tarantool.NewCall17Request("crud.get").Args([]interface{}{validSpace, []interface{}{}, map[string]interface{}{}}), - target: crud.NewGetRequest(validSpace), + target: crud.MakeGetRequest(validSpace), }, { name: "UpdateRequest", ref: tarantool.NewCall17Request("crud.update").Args([]interface{}{validSpace, []interface{}{}, []interface{}{}, map[string]interface{}{}}), - target: crud.NewUpdateRequest(validSpace), + target: crud.MakeUpdateRequest(validSpace), }, { name: "DeleteRequest", ref: tarantool.NewCall17Request("crud.delete").Args([]interface{}{validSpace, []interface{}{}, map[string]interface{}{}}), - target: crud.NewDeleteRequest(validSpace), + target: crud.MakeDeleteRequest(validSpace), }, { name: "ReplaceRequest", ref: tarantool.NewCall17Request("crud.replace").Args([]interface{}{validSpace, []interface{}{}, map[string]interface{}{}}), - target: crud.NewReplaceRequest(validSpace), + target: crud.MakeReplaceRequest(validSpace), }, { name: "ReplaceObjectRequest", ref: tarantool.NewCall17Request("crud.replace_object").Args([]interface{}{validSpace, map[string]interface{}{}, map[string]interface{}{}}), - target: crud.NewReplaceObjectRequest(validSpace), + target: crud.MakeReplaceObjectRequest(validSpace), }, { name: "ReplaceManyRequest", ref: tarantool.NewCall17Request("crud.replace_many").Args([]interface{}{validSpace, []interface{}{}, map[string]interface{}{}}), - target: crud.NewReplaceManyRequest(validSpace), + target: crud.MakeReplaceManyRequest(validSpace), }, { name: "ReplaceObjectManyRequest", ref: tarantool.NewCall17Request("crud.replace_object_many").Args([]interface{}{validSpace, []map[string]interface{}{}, map[string]interface{}{}}), - target: crud.NewReplaceObjectManyRequest(validSpace), + target: crud.MakeReplaceObjectManyRequest(validSpace), }, { name: "UpsertRequest", ref: tarantool.NewCall17Request("crud.upsert").Args([]interface{}{validSpace, []interface{}{}, []interface{}{}, map[string]interface{}{}}), - target: crud.NewUpsertRequest(validSpace), + target: crud.MakeUpsertRequest(validSpace), }, { name: "UpsertObjectRequest", ref: tarantool.NewCall17Request("crud.upsert_object").Args([]interface{}{validSpace, map[string]interface{}{}, []interface{}{}, map[string]interface{}{}}), - target: crud.NewUpsertObjectRequest(validSpace), + target: crud.MakeUpsertObjectRequest(validSpace), }, { name: "UpsertManyRequest", ref: tarantool.NewCall17Request("crud.upsert_many").Args([]interface{}{validSpace, []interface{}{}, map[string]interface{}{}}), - target: crud.NewUpsertManyRequest(validSpace), + target: crud.MakeUpsertManyRequest(validSpace), }, { name: "UpsertObjectManyRequest", ref: tarantool.NewCall17Request("crud.upsert_object_many").Args([]interface{}{validSpace, []interface{}{}, map[string]interface{}{}}), - target: crud.NewUpsertObjectManyRequest(validSpace), + target: crud.MakeUpsertObjectManyRequest(validSpace), }, { name: "SelectRequest", ref: tarantool.NewCall17Request("crud.select").Args([]interface{}{validSpace, nil, map[string]interface{}{}}), - target: crud.NewSelectRequest(validSpace), + target: crud.MakeSelectRequest(validSpace), }, { name: "MinRequest", ref: tarantool.NewCall17Request("crud.min").Args([]interface{}{validSpace, - []interface{}{}, map[string]interface{}{}}), - target: crud.NewMinRequest(validSpace), + nil, map[string]interface{}{}}), + target: crud.MakeMinRequest(validSpace), }, { name: "MaxRequest", ref: tarantool.NewCall17Request("crud.max").Args([]interface{}{validSpace, - []interface{}{}, map[string]interface{}{}}), - target: crud.NewMaxRequest(validSpace), + nil, map[string]interface{}{}}), + target: crud.MakeMaxRequest(validSpace), }, { name: "TruncateRequest", ref: tarantool.NewCall17Request("crud.truncate").Args([]interface{}{validSpace, map[string]interface{}{}}), - target: crud.NewTruncateRequest(validSpace), + target: crud.MakeTruncateRequest(validSpace), }, { name: "LenRequest", ref: tarantool.NewCall17Request("crud.len").Args([]interface{}{validSpace, map[string]interface{}{}}), - target: crud.NewLenRequest(validSpace), + target: crud.MakeLenRequest(validSpace), }, { name: "CountRequest", ref: tarantool.NewCall17Request("crud.count").Args([]interface{}{validSpace, nil, map[string]interface{}{}}), - target: crud.NewCountRequest(validSpace), + target: crud.MakeCountRequest(validSpace), }, { name: "StorageInfoRequest", ref: tarantool.NewCall17Request("crud.storage_info").Args( []interface{}{map[string]interface{}{}}), - target: crud.NewStorageInfoRequest(), + target: crud.MakeStorageInfoRequest(), }, { name: "StatsRequest", ref: tarantool.NewCall17Request("crud.stats").Args( []interface{}{}), - target: crud.NewStatsRequest(), + target: crud.MakeStatsRequest(), }, } @@ -460,120 +460,120 @@ func TestRequestsSetters(t *testing.T) { { name: "InsertRequest", ref: tarantool.NewCall17Request("crud.insert").Args([]interface{}{spaceName, tuple, expectedOpts}), - target: crud.NewInsertRequest(spaceName).Tuple(tuple).Opts(simpleOperationOpts), + target: crud.MakeInsertRequest(spaceName).Tuple(tuple).Opts(simpleOperationOpts), }, { name: "InsertObjectRequest", ref: tarantool.NewCall17Request("crud.insert_object").Args([]interface{}{spaceName, reqObject, expectedOpts}), - target: crud.NewInsertObjectRequest(spaceName).Object(reqObject).Opts(simpleOperationObjectOpts), + target: crud.MakeInsertObjectRequest(spaceName).Object(reqObject).Opts(simpleOperationObjectOpts), }, { name: "InsertManyRequest", ref: tarantool.NewCall17Request("crud.insert_many").Args([]interface{}{spaceName, tuples, expectedOpts}), - target: crud.NewInsertManyRequest(spaceName).Tuples(tuples).Opts(opManyOpts), + target: crud.MakeInsertManyRequest(spaceName).Tuples(tuples).Opts(opManyOpts), }, { name: "InsertObjectManyRequest", ref: tarantool.NewCall17Request("crud.insert_object_many").Args([]interface{}{spaceName, reqObjects, expectedOpts}), - target: crud.NewInsertObjectManyRequest(spaceName).Objects(reqObjects).Opts(opObjManyOpts), + target: crud.MakeInsertObjectManyRequest(spaceName).Objects(reqObjects).Opts(opObjManyOpts), }, { name: "GetRequest", ref: tarantool.NewCall17Request("crud.get").Args([]interface{}{spaceName, key, expectedOpts}), - target: crud.NewGetRequest(spaceName).Key(key).Opts(getOpts), + target: crud.MakeGetRequest(spaceName).Key(key).Opts(getOpts), }, { name: "UpdateRequest", ref: tarantool.NewCall17Request("crud.update").Args([]interface{}{spaceName, key, operations, expectedOpts}), - target: crud.NewUpdateRequest(spaceName).Key(key).Operations(operations).Opts(simpleOperationOpts), + target: crud.MakeUpdateRequest(spaceName).Key(key).Operations(operations).Opts(simpleOperationOpts), }, { name: "DeleteRequest", ref: tarantool.NewCall17Request("crud.delete").Args([]interface{}{spaceName, key, expectedOpts}), - target: crud.NewDeleteRequest(spaceName).Key(key).Opts(simpleOperationOpts), + target: crud.MakeDeleteRequest(spaceName).Key(key).Opts(simpleOperationOpts), }, { name: "ReplaceRequest", ref: tarantool.NewCall17Request("crud.replace").Args([]interface{}{spaceName, tuple, expectedOpts}), - target: crud.NewReplaceRequest(spaceName).Tuple(tuple).Opts(simpleOperationOpts), + target: crud.MakeReplaceRequest(spaceName).Tuple(tuple).Opts(simpleOperationOpts), }, { name: "ReplaceObjectRequest", ref: tarantool.NewCall17Request("crud.replace_object").Args([]interface{}{spaceName, reqObject, expectedOpts}), - target: crud.NewReplaceObjectRequest(spaceName).Object(reqObject).Opts(simpleOperationObjectOpts), + target: crud.MakeReplaceObjectRequest(spaceName).Object(reqObject).Opts(simpleOperationObjectOpts), }, { name: "ReplaceManyRequest", ref: tarantool.NewCall17Request("crud.replace_many").Args([]interface{}{spaceName, tuples, expectedOpts}), - target: crud.NewReplaceManyRequest(spaceName).Tuples(tuples).Opts(opManyOpts), + target: crud.MakeReplaceManyRequest(spaceName).Tuples(tuples).Opts(opManyOpts), }, { name: "ReplaceObjectManyRequest", ref: tarantool.NewCall17Request("crud.replace_object_many").Args([]interface{}{spaceName, reqObjects, expectedOpts}), - target: crud.NewReplaceObjectManyRequest(spaceName).Objects(reqObjects).Opts(opObjManyOpts), + target: crud.MakeReplaceObjectManyRequest(spaceName).Objects(reqObjects).Opts(opObjManyOpts), }, { name: "UpsertRequest", ref: tarantool.NewCall17Request("crud.upsert").Args([]interface{}{spaceName, tuple, operations, expectedOpts}), - target: crud.NewUpsertRequest(spaceName).Tuple(tuple).Operations(operations).Opts(simpleOperationOpts), + target: crud.MakeUpsertRequest(spaceName).Tuple(tuple).Operations(operations).Opts(simpleOperationOpts), }, { name: "UpsertObjectRequest", ref: tarantool.NewCall17Request("crud.upsert_object").Args([]interface{}{spaceName, reqObject, operations, expectedOpts}), - target: crud.NewUpsertObjectRequest(spaceName).Object(reqObject).Operations(operations).Opts(simpleOperationOpts), + target: crud.MakeUpsertObjectRequest(spaceName).Object(reqObject).Operations(operations).Opts(simpleOperationOpts), }, { name: "UpsertManyRequest", ref: tarantool.NewCall17Request("crud.upsert_many").Args([]interface{}{spaceName, tuplesOperationsData, expectedOpts}), - target: crud.NewUpsertManyRequest(spaceName).TuplesOperationsData(tuplesOperationsData).Opts(opManyOpts), + target: crud.MakeUpsertManyRequest(spaceName).TuplesOperationsData(tuplesOperationsData).Opts(opManyOpts), }, { name: "UpsertObjectManyRequest", ref: tarantool.NewCall17Request("crud.upsert_object_many").Args([]interface{}{spaceName, reqObjectsOperationsData, expectedOpts}), - target: crud.NewUpsertObjectManyRequest(spaceName).ObjectsOperationsData(reqObjectsOperationsData).Opts(opManyOpts), + target: crud.MakeUpsertObjectManyRequest(spaceName).ObjectsOperationsData(reqObjectsOperationsData).Opts(opManyOpts), }, { name: "SelectRequest", ref: tarantool.NewCall17Request("crud.select").Args([]interface{}{spaceName, conditions, expectedOpts}), - target: crud.NewSelectRequest(spaceName).Conditions(conditions).Opts(selectOpts), + target: crud.MakeSelectRequest(spaceName).Conditions(conditions).Opts(selectOpts), }, { name: "MinRequest", ref: tarantool.NewCall17Request("crud.min").Args([]interface{}{spaceName, indexName, expectedOpts}), - target: crud.NewMinRequest(spaceName).Index(indexName).Opts(minOpts), + target: crud.MakeMinRequest(spaceName).Index(indexName).Opts(minOpts), }, { name: "MaxRequest", ref: tarantool.NewCall17Request("crud.max").Args([]interface{}{spaceName, indexName, expectedOpts}), - target: crud.NewMaxRequest(spaceName).Index(indexName).Opts(maxOpts), + target: crud.MakeMaxRequest(spaceName).Index(indexName).Opts(maxOpts), }, { name: "TruncateRequest", ref: tarantool.NewCall17Request("crud.truncate").Args([]interface{}{spaceName, expectedOpts}), - target: crud.NewTruncateRequest(spaceName).Opts(baseOpts), + target: crud.MakeTruncateRequest(spaceName).Opts(baseOpts), }, { name: "LenRequest", ref: tarantool.NewCall17Request("crud.len").Args([]interface{}{spaceName, expectedOpts}), - target: crud.NewLenRequest(spaceName).Opts(baseOpts), + target: crud.MakeLenRequest(spaceName).Opts(baseOpts), }, { name: "CountRequest", ref: tarantool.NewCall17Request("crud.count").Args([]interface{}{spaceName, conditions, expectedOpts}), - target: crud.NewCountRequest(spaceName).Conditions(conditions).Opts(countOpts), + target: crud.MakeCountRequest(spaceName).Conditions(conditions).Opts(countOpts), }, { name: "StorageInfoRequest", ref: tarantool.NewCall17Request("crud.storage_info").Args([]interface{}{expectedOpts}), - target: crud.NewStorageInfoRequest().Opts(baseOpts), + target: crud.MakeStorageInfoRequest().Opts(baseOpts), }, { name: "StatsRequest", ref: tarantool.NewCall17Request("crud.stats").Args([]interface{}{spaceName}), - target: crud.NewStatsRequest().Space(spaceName), + target: crud.MakeStatsRequest().Space(spaceName), }, } diff --git a/crud/select.go b/crud/select.go index e9c1f7681..97048a365 100644 --- a/crud/select.go +++ b/crud/select.go @@ -83,9 +83,9 @@ type selectArgs struct { Opts SelectOpts } -// NewSelectRequest returns a new empty SelectRequest. -func NewSelectRequest(space string) *SelectRequest { - req := new(SelectRequest) +// MakeSelectRequest returns a new empty SelectRequest. +func MakeSelectRequest(space string) SelectRequest { + req := SelectRequest{} req.impl = newCall("crud.select") req.space = space req.conditions = nil @@ -95,27 +95,27 @@ func NewSelectRequest(space string) *SelectRequest { // Conditions sets the conditions for the SelectRequest request. // Note: default value is nil. -func (req *SelectRequest) Conditions(conditions []Condition) *SelectRequest { +func (req SelectRequest) Conditions(conditions []Condition) SelectRequest { req.conditions = conditions return req } // Opts sets the options for the SelectRequest request. // Note: default value is nil. -func (req *SelectRequest) Opts(opts SelectOpts) *SelectRequest { +func (req SelectRequest) Opts(opts SelectOpts) SelectRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *SelectRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req SelectRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := selectArgs{Space: req.space, Conditions: req.conditions, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *SelectRequest) Context(ctx context.Context) *SelectRequest { +func (req SelectRequest) Context(ctx context.Context) SelectRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/stats.go b/crud/stats.go index 72be6a309..aa4184746 100644 --- a/crud/stats.go +++ b/crud/stats.go @@ -13,33 +13,33 @@ type StatsRequest struct { space OptString } -// NewStatsRequest returns a new empty StatsRequest. -func NewStatsRequest() *StatsRequest { - req := new(StatsRequest) +// MakeStatsRequest returns a new empty StatsRequest. +func MakeStatsRequest() StatsRequest { + req := StatsRequest{} req.impl = newCall("crud.stats") return req } // Space sets the space name for the StatsRequest request. // Note: default value is nil. -func (req *StatsRequest) Space(space string) *StatsRequest { +func (req StatsRequest) Space(space string) StatsRequest { req.space = MakeOptString(space) return req } // Body fills an encoder with the call request body. -func (req *StatsRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { - args := []interface{}{} +func (req StatsRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { if value, ok := req.space.Get(); ok { - args = []interface{}{value} + req.impl = req.impl.Args([]interface{}{value}) + } else { + req.impl = req.impl.Args([]interface{}{}) } - req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *StatsRequest) Context(ctx context.Context) *StatsRequest { +func (req StatsRequest) Context(ctx context.Context) StatsRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/storage_info.go b/crud/storage_info.go index 2858d3e46..625029b51 100644 --- a/crud/storage_info.go +++ b/crud/storage_info.go @@ -100,9 +100,9 @@ type storageInfoArgs struct { Opts StorageInfoOpts } -// NewStorageInfoRequest returns a new empty StorageInfoRequest. -func NewStorageInfoRequest() *StorageInfoRequest { - req := new(StorageInfoRequest) +// MakeStorageInfoRequest returns a new empty StorageInfoRequest. +func MakeStorageInfoRequest() StorageInfoRequest { + req := StorageInfoRequest{} req.impl = newCall("crud.storage_info") req.opts = StorageInfoOpts{} return req @@ -110,20 +110,20 @@ func NewStorageInfoRequest() *StorageInfoRequest { // Opts sets the options for the torageInfoRequest request. // Note: default value is nil. -func (req *StorageInfoRequest) Opts(opts StorageInfoOpts) *StorageInfoRequest { +func (req StorageInfoRequest) Opts(opts StorageInfoOpts) StorageInfoRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *StorageInfoRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req StorageInfoRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := storageInfoArgs{Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *StorageInfoRequest) Context(ctx context.Context) *StorageInfoRequest { +func (req StorageInfoRequest) Context(ctx context.Context) StorageInfoRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/tarantool_test.go b/crud/tarantool_test.go index f30b7d5c2..71f7d62b1 100644 --- a/crud/tarantool_test.go +++ b/crud/tarantool_test.go @@ -112,21 +112,21 @@ var testProcessDataCases = []struct { { "Select", 2, - crud.NewSelectRequest(spaceName). + crud.MakeSelectRequest(spaceName). Conditions(conditions). Opts(selectOpts), }, { "Get", 2, - crud.NewGetRequest(spaceName). + crud.MakeGetRequest(spaceName). Key(key). Opts(getOpts), }, { "Update", 2, - crud.NewUpdateRequest(spaceName). + crud.MakeUpdateRequest(spaceName). Key(key). Operations(operations). Opts(simpleOperationOpts), @@ -134,46 +134,56 @@ var testProcessDataCases = []struct { { "Delete", 2, - crud.NewDeleteRequest(spaceName). + crud.MakeDeleteRequest(spaceName). Key(key). Opts(simpleOperationOpts), }, { "Min", 2, - crud.NewMinRequest(spaceName).Index(indexName).Opts(minOpts), + crud.MakeMinRequest(spaceName).Opts(minOpts), + }, + { + "Min", + 2, + crud.MakeMinRequest(spaceName).Index(indexName).Opts(minOpts), }, { "Max", 2, - crud.NewMaxRequest(spaceName).Index(indexName).Opts(maxOpts), + crud.MakeMaxRequest(spaceName).Opts(maxOpts), + }, + { + "Max", + 2, + crud.MakeMaxRequest(spaceName).Index(indexName).Opts(maxOpts), }, { "Truncate", 1, - crud.NewTruncateRequest(spaceName).Opts(baseOpts), + crud.MakeTruncateRequest(spaceName).Opts(baseOpts), }, { "Len", 1, - crud.NewLenRequest(spaceName).Opts(baseOpts), + crud.MakeLenRequest(spaceName).Opts(baseOpts), }, { "Count", 2, - crud.NewCountRequest(spaceName). + crud.MakeCountRequest(spaceName). Conditions(conditions). Opts(countOpts), }, { "Stats", 1, - crud.NewStatsRequest().Space(spaceName), + crud.MakeStatsRequest().Space(spaceName), }, { "StorageInfo", 1, - crud.NewStorageInfoRequest().Opts(baseOpts), + crud.MakeStorageInfoRequest().Opts(baseOpts), }, } @@ -185,22 +195,22 @@ var testResultWithErrCases = []struct { { "BaseResult", &crud.Result{}, - crud.NewSelectRequest(invalidSpaceName).Opts(selectOpts), + crud.MakeSelectRequest(invalidSpaceName).Opts(selectOpts), }, { "ManyResult", &crud.Result{}, - crud.NewReplaceManyRequest(invalidSpaceName).Opts(opManyOpts), + crud.MakeReplaceManyRequest(invalidSpaceName).Opts(opManyOpts), }, { "NumberResult", &crud.CountResult{}, - crud.NewCountRequest(invalidSpaceName).Opts(countOpts), + crud.MakeCountRequest(invalidSpaceName).Opts(countOpts), }, { "BoolResult", &crud.TruncateResult{}, - crud.NewTruncateRequest(invalidSpaceName).Opts(baseOpts), + crud.MakeTruncateRequest(invalidSpaceName).Opts(baseOpts), }, } @@ -217,7 +227,7 @@ var testGenerateDataCases = []struct { "Insert", 2, 1, - crud.NewInsertRequest(spaceName). + crud.MakeInsertRequest(spaceName). Tuple(tuple). Opts(simpleOperationOpts), }, @@ -225,7 +235,7 @@ var testGenerateDataCases = []struct { "InsertObject", 2, 1, - crud.NewInsertObjectRequest(spaceName). + crud.MakeInsertObjectRequest(spaceName). Object(object). Opts(simpleOperationObjectOpts), }, @@ -233,7 +243,7 @@ var testGenerateDataCases = []struct { "InsertMany", 2, 10, - crud.NewInsertManyRequest(spaceName). + crud.MakeInsertManyRequest(spaceName). Tuples(tuples). Opts(opManyOpts), }, @@ -241,7 +251,7 @@ var testGenerateDataCases = []struct { "InsertObjectMany", 2, 10, - crud.NewInsertObjectManyRequest(spaceName). + crud.MakeInsertObjectManyRequest(spaceName). Objects(objects). Opts(opObjManyOpts), }, @@ -249,7 +259,7 @@ var testGenerateDataCases = []struct { "Replace", 2, 1, - crud.NewReplaceRequest(spaceName). + crud.MakeReplaceRequest(spaceName). Tuple(tuple). Opts(simpleOperationOpts), }, @@ -257,7 +267,7 @@ var testGenerateDataCases = []struct { "ReplaceObject", 2, 1, - crud.NewReplaceObjectRequest(spaceName). + crud.MakeReplaceObjectRequest(spaceName). Object(object). Opts(simpleOperationObjectOpts), }, @@ -265,7 +275,7 @@ var testGenerateDataCases = []struct { "ReplaceMany", 2, 10, - crud.NewReplaceManyRequest(spaceName). + crud.MakeReplaceManyRequest(spaceName). Tuples(tuples). Opts(opManyOpts), }, @@ -273,7 +283,7 @@ var testGenerateDataCases = []struct { "ReplaceObjectMany", 2, 10, - crud.NewReplaceObjectManyRequest(spaceName). + crud.MakeReplaceObjectManyRequest(spaceName). Objects(objects). Opts(opObjManyOpts), }, @@ -281,7 +291,7 @@ var testGenerateDataCases = []struct { "Upsert", 2, 1, - crud.NewUpsertRequest(spaceName). + crud.MakeUpsertRequest(spaceName). Tuple(tuple). Operations(operations). Opts(simpleOperationOpts), @@ -290,7 +300,7 @@ var testGenerateDataCases = []struct { "UpsertObject", 2, 1, - crud.NewUpsertObjectRequest(spaceName). + crud.MakeUpsertObjectRequest(spaceName). Object(object). Operations(operations). Opts(simpleOperationOpts), @@ -299,7 +309,7 @@ var testGenerateDataCases = []struct { "UpsertMany", 2, 10, - crud.NewUpsertManyRequest(spaceName). + crud.MakeUpsertManyRequest(spaceName). TuplesOperationsData(tuplesOperationsData). Opts(opManyOpts), }, @@ -307,7 +317,7 @@ var testGenerateDataCases = []struct { "UpsertObjectMany", 2, 10, - crud.NewUpsertObjectManyRequest(spaceName). + crud.MakeUpsertObjectManyRequest(spaceName). ObjectsOperationsData(objectsOperationData). Opts(opManyOpts), }, @@ -476,7 +486,6 @@ func TestCrudProcessData(t *testing.T) { resp, err := conn.Do(testCase.req).Get() testCrudRequestCheck(t, testCase.req, resp, err, testCase.expectedRespLen) - for i := 1010; i < 1020; i++ { conn.Delete(spaceName, nil, []interface{}{uint(i)}) } @@ -522,7 +531,7 @@ func TestUnflattenRows(t *testing.T) { defer conn.Close() // Do `replace`. - req := crud.NewReplaceRequest(spaceName). + req := crud.MakeReplaceRequest(spaceName). Tuple(tuple). Opts(simpleOperationOpts) resp, err := conn.Do(req).Get() @@ -595,7 +604,7 @@ func TestBoolResult(t *testing.T) { conn := test_helpers.ConnectWithValidation(t, server, opts) defer conn.Close() - req := crud.NewTruncateRequest(spaceName).Opts(baseOpts) + req := crud.MakeTruncateRequest(spaceName).Opts(baseOpts) resp := crud.TruncateResult{} testCrudRequestPrepareData(t, conn) @@ -618,7 +627,7 @@ func TestNumberResult(t *testing.T) { conn := test_helpers.ConnectWithValidation(t, server, opts) defer conn.Close() - req := crud.NewCountRequest(spaceName).Opts(countOpts) + req := crud.MakeCountRequest(spaceName).Opts(countOpts) resp := crud.CountResult{} testCrudRequestPrepareData(t, conn) @@ -659,7 +668,7 @@ func TestBaseResult(t *testing.T) { conn := test_helpers.ConnectWithValidation(t, server, opts) defer conn.Close() - req := crud.NewSelectRequest(spaceName).Opts(selectOpts) + req := crud.MakeSelectRequest(spaceName).Opts(selectOpts) resp := crud.Result{} testCrudRequestPrepareData(t, conn) @@ -702,7 +711,7 @@ func TestManyResult(t *testing.T) { conn := test_helpers.ConnectWithValidation(t, server, opts) defer conn.Close() - req := crud.NewReplaceManyRequest(spaceName).Tuples(tuples).Opts(opManyOpts) + req := crud.MakeReplaceManyRequest(spaceName).Tuples(tuples).Opts(opManyOpts) resp := crud.Result{} testCrudRequestPrepareData(t, conn) @@ -727,7 +736,7 @@ func TestStorageInfoResult(t *testing.T) { conn := test_helpers.ConnectWithValidation(t, server, opts) defer conn.Close() - req := crud.NewStorageInfoRequest().Opts(baseOpts) + req := crud.MakeStorageInfoRequest().Opts(baseOpts) resp := crud.StorageInfoResult{} err := conn.Do(req).GetTyped(&resp) diff --git a/crud/truncate.go b/crud/truncate.go index 6d00540d4..1cd343a4d 100644 --- a/crud/truncate.go +++ b/crud/truncate.go @@ -25,9 +25,9 @@ type truncateArgs struct { Opts TruncateOpts } -// NewTruncateRequest returns a new empty TruncateRequest. -func NewTruncateRequest(space string) *TruncateRequest { - req := new(TruncateRequest) +// MakeTruncateRequest returns a new empty TruncateRequest. +func MakeTruncateRequest(space string) TruncateRequest { + req := TruncateRequest{} req.impl = newCall("crud.truncate") req.space = space req.opts = TruncateOpts{} @@ -36,20 +36,20 @@ func NewTruncateRequest(space string) *TruncateRequest { // Opts sets the options for the TruncateRequest request. // Note: default value is nil. -func (req *TruncateRequest) Opts(opts TruncateOpts) *TruncateRequest { +func (req TruncateRequest) Opts(opts TruncateOpts) TruncateRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *TruncateRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req TruncateRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := truncateArgs{Space: req.space, Opts: req.opts} req.impl = req.impl.Args(args) return req.impl.Body(res, enc) } // Context sets a passed context to CRUD request. -func (req *TruncateRequest) Context(ctx context.Context) *TruncateRequest { +func (req TruncateRequest) Context(ctx context.Context) TruncateRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/update.go b/crud/update.go index 8fa676ffd..40951c95a 100644 --- a/crud/update.go +++ b/crud/update.go @@ -26,12 +26,11 @@ type updateArgs struct { Opts UpdateOpts } -// NewUpdateRequest returns a new empty UpdateRequest. -func NewUpdateRequest(space string) *UpdateRequest { - req := new(UpdateRequest) +// MakeUpdateRequest returns a new empty UpdateRequest. +func MakeUpdateRequest(space string) UpdateRequest { + req := UpdateRequest{} req.impl = newCall("crud.update") req.space = space - req.key = []interface{}{} req.operations = []Operation{} req.opts = UpdateOpts{} return req @@ -39,27 +38,30 @@ func NewUpdateRequest(space string) *UpdateRequest { // Key sets the key for the UpdateRequest request. // Note: default value is nil. -func (req *UpdateRequest) Key(key Tuple) *UpdateRequest { +func (req UpdateRequest) Key(key Tuple) UpdateRequest { req.key = key return req } // Operations sets the operations for UpdateRequest request. // Note: default value is nil. -func (req *UpdateRequest) Operations(operations []Operation) *UpdateRequest { +func (req UpdateRequest) Operations(operations []Operation) UpdateRequest { req.operations = operations return req } // Opts sets the options for the UpdateRequest request. // Note: default value is nil. -func (req *UpdateRequest) Opts(opts UpdateOpts) *UpdateRequest { +func (req UpdateRequest) Opts(opts UpdateOpts) UpdateRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *UpdateRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req UpdateRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.key == nil { + req.key = []interface{}{} + } args := updateArgs{Space: req.space, Key: req.key, Operations: req.operations, Opts: req.opts} req.impl = req.impl.Args(args) @@ -67,7 +69,7 @@ func (req *UpdateRequest) Body(res tarantool.SchemaResolver, enc *encoder) error } // Context sets a passed context to CRUD request. -func (req *UpdateRequest) Context(ctx context.Context) *UpdateRequest { +func (req UpdateRequest) Context(ctx context.Context) UpdateRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/upsert.go b/crud/upsert.go index 15c3c9fd2..c116bbca5 100644 --- a/crud/upsert.go +++ b/crud/upsert.go @@ -26,12 +26,11 @@ type upsertArgs struct { Opts UpsertOpts } -// NewUpsertRequest returns a new empty UpsertRequest. -func NewUpsertRequest(space string) *UpsertRequest { - req := new(UpsertRequest) +// MakeUpsertRequest returns a new empty UpsertRequest. +func MakeUpsertRequest(space string) UpsertRequest { + req := UpsertRequest{} req.impl = newCall("crud.upsert") req.space = space - req.tuple = []interface{}{} req.operations = []Operation{} req.opts = UpsertOpts{} return req @@ -39,27 +38,30 @@ func NewUpsertRequest(space string) *UpsertRequest { // Tuple sets the tuple for the UpsertRequest request. // Note: default value is nil. -func (req *UpsertRequest) Tuple(tuple Tuple) *UpsertRequest { +func (req UpsertRequest) Tuple(tuple Tuple) UpsertRequest { req.tuple = tuple return req } // Operations sets the operations for the UpsertRequest request. // Note: default value is nil. -func (req *UpsertRequest) Operations(operations []Operation) *UpsertRequest { +func (req UpsertRequest) Operations(operations []Operation) UpsertRequest { req.operations = operations return req } // Opts sets the options for the UpsertRequest request. // Note: default value is nil. -func (req *UpsertRequest) Opts(opts UpsertOpts) *UpsertRequest { +func (req UpsertRequest) Opts(opts UpsertOpts) UpsertRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *UpsertRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req UpsertRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.tuple == nil { + req.tuple = []interface{}{} + } args := upsertArgs{Space: req.space, Tuple: req.tuple, Operations: req.operations, Opts: req.opts} req.impl = req.impl.Args(args) @@ -67,7 +69,7 @@ func (req *UpsertRequest) Body(res tarantool.SchemaResolver, enc *encoder) error } // Context sets a passed context to CRUD request. -func (req *UpsertRequest) Context(ctx context.Context) *UpsertRequest { +func (req UpsertRequest) Context(ctx context.Context) UpsertRequest { req.impl = req.impl.Context(ctx) return req @@ -93,12 +95,11 @@ type upsertObjectArgs struct { Opts UpsertObjectOpts } -// NewUpsertObjectRequest returns a new empty UpsertObjectRequest. -func NewUpsertObjectRequest(space string) *UpsertObjectRequest { - req := new(UpsertObjectRequest) +// MakeUpsertObjectRequest returns a new empty UpsertObjectRequest. +func MakeUpsertObjectRequest(space string) UpsertObjectRequest { + req := UpsertObjectRequest{} req.impl = newCall("crud.upsert_object") req.space = space - req.object = MapObject{} req.operations = []Operation{} req.opts = UpsertObjectOpts{} return req @@ -106,27 +107,30 @@ func NewUpsertObjectRequest(space string) *UpsertObjectRequest { // Object sets the tuple for the UpsertObjectRequest request. // Note: default value is nil. -func (req *UpsertObjectRequest) Object(object Object) *UpsertObjectRequest { +func (req UpsertObjectRequest) Object(object Object) UpsertObjectRequest { req.object = object return req } // Operations sets the operations for the UpsertObjectRequest request. // Note: default value is nil. -func (req *UpsertObjectRequest) Operations(operations []Operation) *UpsertObjectRequest { +func (req UpsertObjectRequest) Operations(operations []Operation) UpsertObjectRequest { req.operations = operations return req } // Opts sets the options for the UpsertObjectRequest request. // Note: default value is nil. -func (req *UpsertObjectRequest) Opts(opts UpsertObjectOpts) *UpsertObjectRequest { +func (req UpsertObjectRequest) Opts(opts UpsertObjectOpts) UpsertObjectRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *UpsertObjectRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req UpsertObjectRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { + if req.object == nil { + req.object = MapObject{} + } args := upsertObjectArgs{Space: req.space, Object: req.object, Operations: req.operations, Opts: req.opts} req.impl = req.impl.Args(args) @@ -134,7 +138,7 @@ func (req *UpsertObjectRequest) Body(res tarantool.SchemaResolver, enc *encoder) } // Context sets a passed context to CRUD request. -func (req *UpsertObjectRequest) Context(ctx context.Context) *UpsertObjectRequest { +func (req UpsertObjectRequest) Context(ctx context.Context) UpsertObjectRequest { req.impl = req.impl.Context(ctx) return req diff --git a/crud/upsert_many.go b/crud/upsert_many.go index d2089b09a..a195f5efa 100644 --- a/crud/upsert_many.go +++ b/crud/upsert_many.go @@ -31,9 +31,9 @@ type upsertManyArgs struct { Opts UpsertManyOpts } -// NewUpsertManyRequest returns a new empty UpsertManyRequest. -func NewUpsertManyRequest(space string) *UpsertManyRequest { - req := new(UpsertManyRequest) +// MakeUpsertManyRequest returns a new empty UpsertManyRequest. +func MakeUpsertManyRequest(space string) UpsertManyRequest { + req := UpsertManyRequest{} req.impl = newCall("crud.upsert_many") req.space = space req.tuplesOperationsData = []TupleOperationsData{} @@ -44,20 +44,20 @@ func NewUpsertManyRequest(space string) *UpsertManyRequest { // TuplesOperationsData sets tuples and operations for // the UpsertManyRequest request. // Note: default value is nil. -func (req *UpsertManyRequest) TuplesOperationsData(tuplesOperationData []TupleOperationsData) *UpsertManyRequest { +func (req UpsertManyRequest) TuplesOperationsData(tuplesOperationData []TupleOperationsData) UpsertManyRequest { req.tuplesOperationsData = tuplesOperationData return req } // Opts sets the options for the UpsertManyRequest request. // Note: default value is nil. -func (req *UpsertManyRequest) Opts(opts UpsertManyOpts) *UpsertManyRequest { +func (req UpsertManyRequest) Opts(opts UpsertManyOpts) UpsertManyRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *UpsertManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req UpsertManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := upsertManyArgs{Space: req.space, TuplesOperationsData: req.tuplesOperationsData, Opts: req.opts} req.impl = req.impl.Args(args) @@ -65,7 +65,7 @@ func (req *UpsertManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) e } // Context sets a passed context to CRUD request. -func (req *UpsertManyRequest) Context(ctx context.Context) *UpsertManyRequest { +func (req UpsertManyRequest) Context(ctx context.Context) UpsertManyRequest { req.impl = req.impl.Context(ctx) return req @@ -96,9 +96,9 @@ type upsertObjectManyArgs struct { Opts UpsertObjectManyOpts } -// NewUpsertObjectManyRequest returns a new empty UpsertObjectManyRequest. -func NewUpsertObjectManyRequest(space string) *UpsertObjectManyRequest { - req := new(UpsertObjectManyRequest) +// MakeUpsertObjectManyRequest returns a new empty UpsertObjectManyRequest. +func MakeUpsertObjectManyRequest(space string) UpsertObjectManyRequest { + req := UpsertObjectManyRequest{} req.impl = newCall("crud.upsert_object_many") req.space = space req.objectsOperationsData = []ObjectOperationsData{} @@ -109,21 +109,21 @@ func NewUpsertObjectManyRequest(space string) *UpsertObjectManyRequest { // ObjectOperationsData sets objects and operations // for the UpsertObjectManyRequest request. // Note: default value is nil. -func (req *UpsertObjectManyRequest) ObjectsOperationsData( - objectsOperationData []ObjectOperationsData) *UpsertObjectManyRequest { +func (req UpsertObjectManyRequest) ObjectsOperationsData( + objectsOperationData []ObjectOperationsData) UpsertObjectManyRequest { req.objectsOperationsData = objectsOperationData return req } // Opts sets the options for the UpsertObjectManyRequest request. // Note: default value is nil. -func (req *UpsertObjectManyRequest) Opts(opts UpsertObjectManyOpts) *UpsertObjectManyRequest { +func (req UpsertObjectManyRequest) Opts(opts UpsertObjectManyOpts) UpsertObjectManyRequest { req.opts = opts return req } // Body fills an encoder with the call request body. -func (req *UpsertObjectManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { +func (req UpsertObjectManyRequest) Body(res tarantool.SchemaResolver, enc *encoder) error { args := upsertObjectManyArgs{Space: req.space, ObjectsOperationsData: req.objectsOperationsData, Opts: req.opts} req.impl = req.impl.Args(args) @@ -131,7 +131,7 @@ func (req *UpsertObjectManyRequest) Body(res tarantool.SchemaResolver, enc *enco } // Context sets a passed context to CRUD request. -func (req *UpsertObjectManyRequest) Context(ctx context.Context) *UpsertObjectManyRequest { +func (req UpsertObjectManyRequest) Context(ctx context.Context) UpsertObjectManyRequest { req.impl = req.impl.Context(ctx) return req