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

Author: asmyasnikov

CHANGELOG.md

@@ -1,3 +1,5 @@
+* Added bindings elipsis into `ydb.ParamsFromMap` for bind wide time types
+
 ## v3.104.1
 * Added export of advanced metric information for QueryService calls
 

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,6 +1,7 @@
 package bind
 
 import (
+	"database/sql/driver"
 	"time"
 
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/value"
@@ -12,6 +13,23 @@ func (m WideTimeTypes) ToYdb(sql string, args ...any) (yql string, newArgs []any
 	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:

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,83 @@ 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, 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,
+					},
+				},
+			},
+		}, 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())
+		pp, err := params.ToYDB(&allocator.Allocator{})
+		require.NoError(t, err)
+		require.EqualValues(t, 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,
+					},
+				},
+			},
+		}, 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)
+	})
+}