* Added experimental method for execute query and read only one row from result:

  * `query/Client.ReadRow`
  * `query/Session.ReadRow`
  * `query/Transaction.ReadRow`
* Added experimental method for execute query and read only one result set from result:
  * `query/Client.ReadResultSet`
  * `query/Session.ReadResultSet`
  * `query/Transaction.ReadResultSet`
* Added experimental `sugar.UnmarshallRow[T]` and `sugar.UnmarshallResultSet[T]` helpers for converts YDB rows to typed objects

Author: asmyasnikov

CHANGELOG.md

@@ -1,4 +1,12 @@
-* Added experimental `query.ReadRow` method for execute query and read only one row from result
+* Added experimental method for execute query and read only one row from result:
+  * `query/Client.ReadRow`
+  * `query/Session.ReadRow`
+  * `query/Transaction.ReadRow`
+* Added experimental method for execute query and read only one result set from result:
+  * `query/Client.ReadResultSet`
+  * `query/Session.ReadResultSet`
+  * `query/Transaction.ReadResultSet`
+* Added experimental `sugar.UnmarshallRow[T]` and `sugar.UnmarshallResultSet[T]` helpers for converts YDB rows to typed objects
 
 ## v3.68.1
 * Downgraded minimal version of Go to 1.20

internal/query/client.go

@@ -2,7 +2,6 @@ package query
 
 import (
 	"context"
-	"io"
 
 	"github.com/ydb-platform/ydb-go-genproto/Ydb_Query_V1"
 	"google.golang.org/grpc"
@@ -149,65 +148,62 @@ func doTx(
 	return attempts, nil
 }
 
-func readRow(ctx context.Context,
-	pool *pool.Pool[*Session, Session],
-	q string,
-	t *trace.Query,
-	opts ...options.ExecuteOption,
-) (row query.Row, err error) {
-	_, err = do(ctx, pool, func(ctx context.Context, s query.Session) (err error) {
-		_, r, err := s.Execute(ctx, q, opts...)
-		if err != nil {
-			return xerrors.WithStackTrace(err)
-		}
-		defer func() {
-			_ = r.Close(ctx)
-		}()
-		rs, err := r.NextResultSet(ctx)
-		if err != nil {
-			return xerrors.WithStackTrace(err)
-		}
-		row, err = rs.NextRow(ctx)
-		if err != nil {
-			return xerrors.WithStackTrace(err)
-		}
+// ReadRow is a helper which read only one row from first result set in result
+func (c *Client) ReadRow(ctx context.Context, q string, opts ...options.ExecuteOption) (row query.Row, err error) {
+	ctx, cancel := xcontext.WithDone(ctx, c.done)
+	defer cancel()
 
-		if _, err = rs.NextRow(ctx); err == nil || !xerrors.Is(err, io.EOF) {
-			return xerrors.WithStackTrace(errMoreThanOneRow)
-		}
+	onDone := trace.QueryOnReadRow(c.config.Trace(), &ctx,
+		stack.FunctionID("github.com/ydb-platform/ydb-go-sdk/3/internal/query.(*Client).ReadRow"),
+		q,
+	)
+	defer func() {
+		onDone(err)
+	}()
 
-		if _, err = r.NextResultSet(ctx); err == nil || !xerrors.Is(err, io.EOF) {
-			return xerrors.WithStackTrace(errMoreThanOneResultSet)
+	_, err = do(ctx, c.pool, func(ctx context.Context, s query.Session) (err error) {
+		row, err = s.ReadRow(ctx, q, opts...)
+		if err != nil {
+			return xerrors.WithStackTrace(err)
 		}
 
-		return r.Err()
-	}, t)
+		return nil
+	}, c.config.Trace())
 	if err != nil {
 		return nil, xerrors.WithStackTrace(err)
 	}
 
 	return row, nil
 }
 
-// ReadRow is a helper which read only one row from first result set in result
-func (c *Client) ReadRow(ctx context.Context, q string, opts ...options.ExecuteOption) (row query.Row, err error) {
+// ReadResultSet is a helper which read all rows from first result set in result
+func (c *Client) ReadResultSet(
+	ctx context.Context, q string, opts ...options.ExecuteOption,
+) (rs query.ResultSet, err error) {
 	ctx, cancel := xcontext.WithDone(ctx, c.done)
 	defer cancel()
 
-	onDone := trace.QueryOnReadRow(c.config.Trace(), &ctx,
-		stack.FunctionID("github.com/ydb-platform/ydb-go-sdk/3/internal/query.(*Client).ReadRow"),
+	onDone := trace.QueryOnReadResultSet(c.config.Trace(), &ctx,
+		stack.FunctionID("github.com/ydb-platform/ydb-go-sdk/3/internal/query.(*Client).ReadResultSet"),
 		q,
 	)
 	defer func() {
 		onDone(err)
 	}()
 
-	row, err = readRow(ctx, c.pool, q, c.config.Trace(), opts...)
+	_, err = do(ctx, c.pool, func(ctx context.Context, s query.Session) (err error) {
+		rs, err = s.ReadResultSet(ctx, q, opts...)
+		if err != nil {
+			return xerrors.WithStackTrace(err)
+		}
+
+		return nil
+	}, c.config.Trace())
 	if err != nil {
 		return nil, xerrors.WithStackTrace(err)
 	}
 
-	return row, nil
+	return rs, nil
 }
 
 func (c *Client) DoTx(ctx context.Context, op query.TxOperation, opts ...options.DoTxOption) (err error) {

internal/query/client_test.go

@@ -3,7 +3,6 @@ package query
 import (
 	"context"
 	"errors"
-	"io"
 	"testing"
 	"time"
 
@@ -257,237 +256,3 @@ func TestDoTx(t *testing.T) {
 		require.Equal(t, 10, counter)
 	})
 }
-
-func TestReadRow(t *testing.T) {
-	ctx := xtest.Context(t)
-	t.Run("HappyWay", func(t *testing.T) {
-		ctrl := gomock.NewController(t)
-		row, err := readRow(ctx, testPool(ctx, func(ctx context.Context) (*Session, error) {
-			stream := NewMockQueryService_ExecuteQueryClient(ctrl)
-			stream.EXPECT().Recv().Return(&Ydb_Query.ExecuteQueryResponsePart{
-				Status: Ydb.StatusIds_SUCCESS,
-				TxMeta: &Ydb_Query.TransactionMeta{
-					Id: "456",
-				},
-				ResultSetIndex: 0,
-				ResultSet: &Ydb.ResultSet{
-					Columns: []*Ydb.Column{
-						{
-							Name: "a",
-							Type: &Ydb.Type{
-								Type: &Ydb.Type_TypeId{
-									TypeId: Ydb.Type_UINT64,
-								},
-							},
-						},
-						{
-							Name: "b",
-							Type: &Ydb.Type{
-								Type: &Ydb.Type_TypeId{
-									TypeId: Ydb.Type_UTF8,
-								},
-							},
-						},
-					},
-					Rows: []*Ydb.Value{
-						{
-							Items: []*Ydb.Value{{
-								Value: &Ydb.Value_Uint64Value{
-									Uint64Value: 1,
-								},
-							}, {
-								Value: &Ydb.Value_TextValue{
-									TextValue: "1",
-								},
-							}},
-						},
-					},
-				},
-			}, nil)
-			stream.EXPECT().Recv().Return(nil, io.EOF)
-			client := NewMockQueryServiceClient(ctrl)
-			client.EXPECT().ExecuteQuery(gomock.Any(), gomock.Any()).Return(stream, nil)
-
-			return &Session{
-				id:         "123",
-				statusCode: statusIdle,
-				cfg:        config.New(),
-				grpcClient: client,
-			}, nil
-		}), "", nil)
-		require.NoError(t, err)
-		var (
-			a uint64
-			b string
-		)
-		err = row.Scan(&a, &b)
-		require.NoError(t, err)
-		require.EqualValues(t, 1, a)
-		require.EqualValues(t, "1", b)
-	})
-	t.Run("MoreThanOneRow", func(t *testing.T) {
-		ctrl := gomock.NewController(t)
-		row, err := readRow(ctx, testPool(ctx, func(ctx context.Context) (*Session, error) {
-			stream := NewMockQueryService_ExecuteQueryClient(ctrl)
-			stream.EXPECT().Recv().Return(&Ydb_Query.ExecuteQueryResponsePart{
-				Status: Ydb.StatusIds_SUCCESS,
-				TxMeta: &Ydb_Query.TransactionMeta{
-					Id: "456",
-				},
-				ResultSetIndex: 0,
-				ResultSet: &Ydb.ResultSet{
-					Columns: []*Ydb.Column{
-						{
-							Name: "a",
-							Type: &Ydb.Type{
-								Type: &Ydb.Type_TypeId{
-									TypeId: Ydb.Type_UINT64,
-								},
-							},
-						},
-						{
-							Name: "b",
-							Type: &Ydb.Type{
-								Type: &Ydb.Type_TypeId{
-									TypeId: Ydb.Type_UTF8,
-								},
-							},
-						},
-					},
-					Rows: []*Ydb.Value{
-						{
-							Items: []*Ydb.Value{{
-								Value: &Ydb.Value_Uint64Value{
-									Uint64Value: 1,
-								},
-							}, {
-								Value: &Ydb.Value_TextValue{
-									TextValue: "1",
-								},
-							}},
-						},
-						{
-							Items: []*Ydb.Value{{
-								Value: &Ydb.Value_Uint64Value{
-									Uint64Value: 2,
-								},
-							}, {
-								Value: &Ydb.Value_TextValue{
-									TextValue: "2",
-								},
-							}},
-						},
-					},
-				},
-			}, nil)
-			client := NewMockQueryServiceClient(ctrl)
-			client.EXPECT().ExecuteQuery(gomock.Any(), gomock.Any()).Return(stream, nil)
-
-			return &Session{
-				id:         "123",
-				statusCode: statusIdle,
-				cfg:        config.New(),
-				grpcClient: client,
-			}, nil
-		}), "", nil)
-		require.ErrorIs(t, err, errMoreThanOneRow)
-		require.Nil(t, row)
-	})
-	t.Run("MoreThanOneResultSet", func(t *testing.T) {
-		ctrl := gomock.NewController(t)
-		row, err := readRow(ctx, testPool(ctx, func(ctx context.Context) (*Session, error) {
-			stream := NewMockQueryService_ExecuteQueryClient(ctrl)
-			stream.EXPECT().Recv().Return(&Ydb_Query.ExecuteQueryResponsePart{
-				Status: Ydb.StatusIds_SUCCESS,
-				TxMeta: &Ydb_Query.TransactionMeta{
-					Id: "456",
-				},
-				ResultSetIndex: 0,
-				ResultSet: &Ydb.ResultSet{
-					Columns: []*Ydb.Column{
-						{
-							Name: "a",
-							Type: &Ydb.Type{
-								Type: &Ydb.Type_TypeId{
-									TypeId: Ydb.Type_UINT64,
-								},
-							},
-						},
-						{
-							Name: "b",
-							Type: &Ydb.Type{
-								Type: &Ydb.Type_TypeId{
-									TypeId: Ydb.Type_UTF8,
-								},
-							},
-						},
-					},
-					Rows: []*Ydb.Value{
-						{
-							Items: []*Ydb.Value{{
-								Value: &Ydb.Value_Uint64Value{
-									Uint64Value: 1,
-								},
-							}, {
-								Value: &Ydb.Value_TextValue{
-									TextValue: "1",
-								},
-							}},
-						},
-					},
-				},
-			}, nil)
-			stream.EXPECT().Recv().Return(&Ydb_Query.ExecuteQueryResponsePart{
-				Status: Ydb.StatusIds_SUCCESS,
-				TxMeta: &Ydb_Query.TransactionMeta{
-					Id: "456",
-				},
-				ResultSetIndex: 0,
-				ResultSet: &Ydb.ResultSet{
-					Columns: []*Ydb.Column{
-						{
-							Name: "a",
-							Type: &Ydb.Type{
-								Type: &Ydb.Type_TypeId{
-									TypeId: Ydb.Type_UINT64,
-								},
-							},
-						},
-						{
-							Name: "b",
-							Type: &Ydb.Type{
-								Type: &Ydb.Type_TypeId{
-									TypeId: Ydb.Type_UTF8,
-								},
-							},
-						},
-					},
-					Rows: []*Ydb.Value{
-						{
-							Items: []*Ydb.Value{{
-								Value: &Ydb.Value_Uint64Value{
-									Uint64Value: 1,
-								},
-							}, {
-								Value: &Ydb.Value_TextValue{
-									TextValue: "1",
-								},
-							}},
-						},
-					},
-				},
-			}, nil)
-			client := NewMockQueryServiceClient(ctrl)
-			client.EXPECT().ExecuteQuery(gomock.Any(), gomock.Any()).Return(stream, nil)
-
-			return &Session{
-				id:         "123",
-				statusCode: statusIdle,
-				cfg:        config.New(),
-				grpcClient: client,
-			}, nil
-		}), "", nil)
-		require.ErrorIs(t, err, errMoreThanOneRow)
-		require.Nil(t, row)
-	})
-}

internal/query/errors.go

@@ -11,4 +11,5 @@ var (
 	errWrongResultSetIndex     = errors.New("critical violation of the logic - wrong result set index")
 	errMoreThanOneRow          = errors.New("unexpected more than one row in result set")
 	errMoreThanOneResultSet    = errors.New("unexpected more than one result set")
+	errNoResultSets            = errors.New("no result sets")
 )