Merge pull request #1697 from ydb-platform/bind-params-from-map

* Added bindings elipsis into `ydb.ParamsFromMap` for bind wide time types

Author: asmyasnikov

CHANGELOG.md

@@ -1,3 +1,6 @@
+* Added bindings options into `ydb.ParamsFromMap` for bind wide time types
+* Changed `ydb.WithWideTimeTypes(bool)` for allow boolean argument
+
 ## v3.104.1
 * Added export of advanced metric information for QueryService calls
 

dsn.go

@@ -115,7 +115,7 @@ func parseConnectionString(dataSourceName string) (opts []Option, _ error) {
 			case "numeric":
 				binders = append(binders, xsql.WithQueryBind(bind.NumericArgs{}))
 			case "wide_time_types":
-				binders = append(binders, xsql.WithQueryBind(bind.WideTimeTypes{}))
+				binders = append(binders, xsql.WithQueryBind(bind.WideTimeTypes(true)))
 			default:
 				if strings.HasPrefix(transformer, tablePathPrefixTransformer) {
 					prefix, err := extractTablePathPrefixFromBinderName(transformer)

dsn_test.go

@@ -182,7 +182,7 @@ func TestParse(t *testing.T) {
 				xsql.WithDefaultQueryMode(xtable.ScriptingQueryMode),
 				xsql.WithQueryBind(bind.PositionalArgs{}),
 				xsql.WithQueryBind(bind.AutoDeclare{}),
-				xsql.WithQueryBind(bind.WideTimeTypes{}),
+				xsql.WithQueryBind(bind.WideTimeTypes(true)),
 			},
 			err: nil,
 		},

internal/bind/bind.go

@@ -44,10 +44,10 @@ func (bindings Bindings) ToYdb(sql string, args ...any) (
 	defer buffer.Free()
 
 	for i := range bindings {
-		var e error
-		sql, args, e = bindings[len(bindings)-1-i].ToYdb(sql, args...)
-		if e != nil {
-			return "", nil, xerrors.WithStackTrace(e)
+		var err error
+		sql, args, err = bindings[len(bindings)-1-i].ToYdb(sql, args...)
+		if err != nil {
+			return "", nil, xerrors.WithStackTrace(err)
 		}
 	}
 

internal/bind/errors.go

@@ -5,4 +5,5 @@ import "errors"
 var (
 	ErrInconsistentArgs         = errors.New("inconsistent args")
 	ErrUnexpectedNumericArgZero = errors.New("unexpected numeric arg $0. Allowed only $1 and greater")
+	ErrUnsupportedBindingType   = errors.New("unsupported binding type")
 )

internal/bind/wide_time_types.go

@@ -1,17 +1,39 @@
 package bind
 
 import (
+	"database/sql/driver"
 	"time"
 
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/value"
 )
 
-type WideTimeTypes struct{}
+type WideTimeTypes bool
+
+func (b WideTimeTypes) ToYdb(sql string, args ...any) (yql string, newArgs []any, _ error) {
+	if !b {
+		return sql, args, nil
+	}
 
-func (m WideTimeTypes) ToYdb(sql string, args ...any) (yql string, newArgs []any, _ error) {
 	newArgs = make([]any, 0, len(args))
 	for _, arg := range args {
 		switch t := arg.(type) {
+		case driver.NamedValue:
+			switch tt := t.Value.(type) {
+			case time.Time:
+				newArgs = append(newArgs, driver.NamedValue{
+					Name:    t.Name,
+					Ordinal: t.Ordinal,
+					Value:   value.Timestamp64ValueFromTime(tt),
+				})
+			case time.Duration:
+				newArgs = append(newArgs, driver.NamedValue{
+					Name:    t.Name,
+					Ordinal: t.Ordinal,
+					Value:   value.Interval64ValueFromDuration(tt),
+				})
+			default:
+				newArgs = append(newArgs, arg)
+			}
 		case time.Time:
 			newArgs = append(newArgs, value.Timestamp64ValueFromTime(t))
 		case time.Duration:
@@ -24,6 +46,6 @@ func (m WideTimeTypes) ToYdb(sql string, args ...any) (yql string, newArgs []any
 	return sql, newArgs, nil
 }
 
-func (m WideTimeTypes) blockID() blockID {
+func (b WideTimeTypes) blockID() blockID {
 	return blockCastArgs
 }

internal/bind/wide_time_types_test.go

@@ -58,7 +58,7 @@ func TestWideTimeTypesBind(t *testing.T) {
 			},
 		},
 		{
-			bind: WideTimeTypes{},
+			bind: WideTimeTypes(true),
 			sql:  `SELECT ?, ?`,
 			args: []any{
 				100,
@@ -71,7 +71,7 @@ func TestWideTimeTypesBind(t *testing.T) {
 			},
 		},
 		{
-			bind: WideTimeTypes{},
+			bind: WideTimeTypes(true),
 			sql:  `SELECT ?, ?`,
 			args: []any{
 				time.Unix(123, 456),
@@ -84,7 +84,7 @@ func TestWideTimeTypesBind(t *testing.T) {
 			},
 		},
 		{
-			bind: WideTimeTypes{},
+			bind: WideTimeTypes(true),
 			sql:  `SELECT ?, ?`,
 			args: []any{
 				time.Duration(123) * time.Millisecond,

internal/xsql/options.go

@@ -38,7 +38,7 @@ type (
 	retryBudgetOption           struct {
 		budget budget.Budget
 	}
-	bindOption struct {
+	BindOption struct {
 		bind.Bind
 	}
 	queryProcessorOption Engine
@@ -57,7 +57,7 @@ func (processor queryProcessorOption) Apply(c *Connector) error {
 	return nil
 }
 
-func (opt bindOption) Apply(c *Connector) error {
+func (opt BindOption) Apply(c *Connector) error {
 	c.bindings = bind.Sort(append(c.bindings, opt.Bind))
 
 	return nil
@@ -141,7 +141,7 @@ func WithTablePathPrefix(tablePathPrefix string) QueryBindOption {
 }
 
 func WithQueryBind(bind bind.Bind) QueryBindOption {
-	return bindOption{
+	return BindOption{
 		Bind: bind,
 	}
 }

params_map.go

@@ -2,13 +2,15 @@ package ydb
 
 import (
 	"database/sql/driver"
+	"fmt"
 
 	"github.com/ydb-platform/ydb-go-genproto/protos/Ydb"
 
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/allocator"
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/bind"
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/params"
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/xerrors"
+	"github.com/ydb-platform/ydb-go-sdk/v3/internal/xsql"
 )
 
 type wrongParameters struct {
@@ -20,15 +22,32 @@ func (p wrongParameters) ToYDB(a *allocator.Allocator) (map[string]*Ydb.TypedVal
 }
 
 // ParamsFromMap build parameters from named map
-func ParamsFromMap(m map[string]any) params.Parameters {
+func ParamsFromMap(m map[string]any, bindings ...bind.Bind) params.Parameters {
+	for _, b := range bindings {
+		switch bb := b.(type) {
+		case xsql.BindOption:
+			switch bb.Bind.(type) {
+			case bind.WideTimeTypes:
+				continue
+			default:
+				return wrongParameters{
+					err: xerrors.WithStackTrace(fmt.Errorf("%T: %w", b, bind.ErrUnsupportedBindingType)),
+				}
+			}
+		default:
+			return wrongParameters{
+				err: xerrors.WithStackTrace(fmt.Errorf("%T: %w", b, bind.ErrUnsupportedBindingType)),
+			}
+		}
+	}
 	namedParameters := make([]any, 0, len(m))
 	for name, val := range m {
 		namedParameters = append(namedParameters, driver.NamedValue{Name: name, Value: val})
 	}
-	p, err := bind.Params(namedParameters...)
+	_, pp, err := bind.Bindings(bindings).ToYdb("", namedParameters...)
 	if err != nil {
 		return wrongParameters{err: xerrors.WithStackTrace(err)}
 	}
 
-	return (*params.Params)(&p)
+	return &pp
 }

params_test.go

@@ -3,13 +3,15 @@ package ydb_test
 import (
 	"fmt"
 	"testing"
+	"time"
 
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 	"github.com/ydb-platform/ydb-go-genproto/protos/Ydb"
 
 	"github.com/ydb-platform/ydb-go-sdk/v3"
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/allocator"
+	"github.com/ydb-platform/ydb-go-sdk/v3/internal/bind"
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/params"
 	"github.com/ydb-platform/ydb-go-sdk/v3/table"
 	"github.com/ydb-platform/ydb-go-sdk/v3/table/types"
@@ -218,3 +220,89 @@ func BenchmarkParams(b *testing.B) {
 		}
 	})
 }
+
+func TestParamsFromMap(t *testing.T) {
+	t.Run("DefaultTimeTypes", func(t *testing.T) {
+		params := ydb.ParamsFromMap(map[string]any{
+			"a": time.Unix(123, 456),
+			"b": time.Duration(123) * time.Microsecond,
+		})
+		pp, err := params.ToYDB(&allocator.Allocator{})
+		require.NoError(t, err)
+		require.EqualValues(t,
+			fmt.Sprintf("%+v", map[string]*Ydb.TypedValue{
+				"$a": {
+					Type: &Ydb.Type{
+						Type: &Ydb.Type_TypeId{
+							TypeId: Ydb.Type_TIMESTAMP,
+						},
+					},
+					Value: &Ydb.Value{
+						Value: &Ydb.Value_Uint64Value{
+							Uint64Value: 123000000,
+						},
+					},
+				},
+				"$b": {
+					Type: &Ydb.Type{
+						Type: &Ydb.Type_TypeId{
+							TypeId: Ydb.Type_INTERVAL,
+						},
+					},
+					Value: &Ydb.Value{
+						Value: &Ydb.Value_Int64Value{
+							Int64Value: 123,
+						},
+					},
+				},
+			}),
+			fmt.Sprintf("%+v", pp),
+		)
+	})
+	t.Run("BindWideTimeTypes", func(t *testing.T) {
+		params := ydb.ParamsFromMap(map[string]any{
+			"a": time.Date(1900, 1, 1, 0, 0, 0, 123456, time.UTC),
+			"b": time.Duration(123) * time.Nanosecond,
+		}, ydb.WithWideTimeTypes(true))
+		pp, err := params.ToYDB(&allocator.Allocator{})
+		require.NoError(t, err)
+		require.EqualValues(t,
+			fmt.Sprintf("%+v", map[string]*Ydb.TypedValue{
+				"$a": {
+					Type: &Ydb.Type{
+						Type: &Ydb.Type_TypeId{
+							TypeId: Ydb.Type_TIMESTAMP64,
+						},
+					},
+					Value: &Ydb.Value{
+						Value: &Ydb.Value_Int64Value{
+							Int64Value: -2208988799999877,
+						},
+					},
+				},
+				"$b": {
+					Type: &Ydb.Type{
+						Type: &Ydb.Type_TypeId{
+							TypeId: Ydb.Type_INTERVAL64,
+						},
+					},
+					Value: &Ydb.Value{
+						Value: &Ydb.Value_Int64Value{
+							Int64Value: 123,
+						},
+					},
+				},
+			}),
+			fmt.Sprintf("%+v", pp),
+		)
+	})
+	t.Run("WrongBindings", func(t *testing.T) {
+		params := ydb.ParamsFromMap(map[string]any{
+			"a": time.Unix(123, 456),
+			"b": time.Duration(123),
+		}, ydb.WithTablePathPrefix(""))
+		pp, err := params.ToYDB(&allocator.Allocator{})
+		require.ErrorIs(t, err, bind.ErrUnsupportedBindingType)
+		require.Nil(t, pp)
+	})
+}

query_bind_test.go

@@ -583,7 +583,7 @@ SELECT $p0;`,
 			b: testutil.QueryBind(
 				ydb.WithAutoDeclare(),
 				ydb.WithPositionalArgs(),
-				ydb.WithWideTimeTypes(),
+				ydb.WithWideTimeTypes(true),
 			),
 			sql:  `SELECT ?;`,
 			args: []interface{}{time.Unix(123, 456)},

sql.go

@@ -189,8 +189,8 @@ func WithPositionalArgs() QueryBindConnectorOption {
 	return xsql.WithQueryBind(bind.PositionalArgs{})
 }
 
-func WithWideTimeTypes() QueryBindConnectorOption {
-	return xsql.WithQueryBind(bind.WideTimeTypes{})
+func WithWideTimeTypes(b bool) QueryBindConnectorOption {
+	return xsql.WithQueryBind(bind.WideTimeTypes(b))
 }
 
 func WithNumericArgs() QueryBindConnectorOption {