Endtoend tests: bunch of ydb e2e tests + some engine and types fixes

internal/codegen/golang/gen.go

@@ -218,6 +218,8 @@ func generate(req *plugin.GenerateRequest, options *opts.Options, enums []Enum,
 		}
 	}
 
+	isYDBEngine := func() bool { return options.Engine == "ydb" }
+
 	funcMap := template.FuncMap{
 		"lowerTitle": sdk.LowerTitle,
 		"comment":    sdk.DoubleSlashComment,
@@ -232,6 +234,7 @@ func generate(req *plugin.GenerateRequest, options *opts.Options, enums []Enum,
 		"emitPreparedQueries": tctx.codegenEmitPreparedQueries,
 		"queryMethod":         tctx.codegenQueryMethod,
 		"queryRetval":         tctx.codegenQueryRetval,
+		"isYDBEngine":         isYDBEngine,
 	}
 
 	tmpl := template.Must(

internal/codegen/golang/imports.go

@@ -149,6 +149,7 @@ func (i *importer) dbImports() fileImports {
 var stdlibTypes = map[string]string{
 	"json.RawMessage":  "encoding/json",
 	"time.Time":        "time",
+	"time.Duration":    "time",
 	"net.IP":           "net",
 	"net.HardwareAddr": "net",
 	"netip.Addr":       "net/netip",
@@ -232,6 +233,10 @@ func buildImports(options *opts.Options, queries []Query, uses func(string) bool
 	if uses("pgvector.Vector") && !overrideVector {
 		pkg[ImportSpec{Path: "github.com/pgvector/pgvector-go"}] = struct{}{}
 	}
+	_, overrideDecimal := overrideTypes["types.Decimal"]
+	if uses("types.Decimal") && !overrideDecimal {
+		pkg[ImportSpec{Path: "github.com/ydb-platform/ydb-go-sdk/v3/table/types"}] = struct{}{}
+	}
 
 	// Custom imports
 	for _, override := range options.Overrides {
@@ -404,7 +409,7 @@ func (i *importer) queryImports(filename string) fileImports {
 	}
 
 	sqlpkg := parseDriver(i.Options.SqlPackage)
-	if sqlcSliceScan() && !sqlpkg.IsPGX() && !sqlpkg.IsYDBGoSDK() {
+	if sqlcSliceScan() && !sqlpkg.IsPGX() && !sqlpkg.IsYDBGoSDK() && i.Options.Engine != "ydb" {
 		std["strings"] = struct{}{}
 	}
 	if sliceScan() && !sqlpkg.IsPGX() && !sqlpkg.IsYDBGoSDK() {
@@ -413,17 +418,25 @@ func (i *importer) queryImports(filename string) fileImports {
 
 	if sqlpkg.IsYDBGoSDK() {
 		hasParams := false
+		hasManyQueries := false
 		for _, q := range gq {
 			if !q.Arg.isEmpty() {
 				hasParams = true
-				break
+			}
+			if q.Cmd == metadata.CmdMany {
+				hasManyQueries = true
 			}
 		}
 		if hasParams {
 			pkg[ImportSpec{Path: "github.com/ydb-platform/ydb-go-sdk/v3"}] = struct{}{}
 		}
 		pkg[ImportSpec{Path: "github.com/ydb-platform/ydb-go-sdk/v3/query"}] = struct{}{}
 		pkg[ImportSpec{Path: "github.com/ydb-platform/ydb-go-sdk/v3/pkg/xerrors"}] = struct{}{}
+
+		if hasManyQueries {
+			std["errors"] = struct{}{}
+			std["io"] = struct{}{}
+		}
 	}
 
 	if i.Options.WrapErrors {

internal/codegen/golang/opts/options.go

@@ -47,6 +47,7 @@ type Options struct {
 	Initialisms                 *[]string         `json:"initialisms,omitempty" yaml:"initialisms"`
 
 	InitialismsMap map[string]struct{} `json:"-" yaml:"-"`
+	Engine         string              `json:"-" yaml:"-"`
 }
 
 type GlobalOptions struct {
@@ -72,6 +73,11 @@ func Parse(req *plugin.GenerateRequest) (*Options, error) {
 		}
 		maps.Copy(options.Rename, global.Rename)
 	}
+
+	if req.Settings != nil {
+		options.Engine = req.Settings.Engine
+	}
+
 	return options, nil
 }
 

internal/codegen/golang/query.go

@@ -307,7 +307,7 @@ func ydbBuilderMethodForColumnType(dbType string) string {
 		return "Int32"
 	case "uint16":
 		return "Uint16"
-	case "int16", "smallserial","serial2":
+	case "int16", "smallserial", "serial2":
 		return "Int16"
 	case "uint8":
 		return "Uint8"
@@ -321,8 +321,10 @@ func ydbBuilderMethodForColumnType(dbType string) string {
 		return "JSON"
 	case "jsondocument":
 		return "JSONDocument"
-	case "utf8", "text", "string":
+	case "utf8", "text":
 		return "Text"
+	case "string":
+		return "Bytes"
 	case "date":
 		return "Date"
 	case "date32":
@@ -342,8 +344,18 @@ func ydbBuilderMethodForColumnType(dbType string) string {
 	case "yson":
 		return "YSON"
 
+	case "integer": // LIMIT/OFFSET parameters support
+		return "Uint64"
+
+	case "Integer": // Invalid YDB type - fallback to Uint64
+		return "Uint64"
+
 	//TODO: support other types
 	default:
+		// Check for decimal types
+		if strings.HasPrefix(baseType, "decimal") {
+			return "Decimal"
+		}
 		return ""
 	}
 }
@@ -405,6 +417,21 @@ func (v QueryValue) YDBParamsBuilder() string {
 		isPtr := strings.HasPrefix(goType, "*")
 		isArray := field.Column.IsArray || field.Column.IsSqlcSlice
 
+		if method == "Decimal" {
+			if isArray {
+				lines = append(lines, fmt.Sprintf("\tvar list = parameters.Param(%s).BeginList()", paramName))
+				lines = append(lines, fmt.Sprintf("\tfor _, param := range %s {", variable))
+				lines = append(lines, "\t\tlist = list.Add().Decimal(param.Bytes, param.Precision, param.Scale)")
+				lines = append(lines, "\t}")
+				lines = append(lines, "\tparameters = list.EndList()")
+			} else if isPtr {
+				lines = append(lines, fmt.Sprintf("\tparameters = parameters.Param(%s).BeginOptional().Decimal(&%s.Bytes, %s.Precision, %s.Scale).EndOptional()", paramName, variable, variable, variable))
+			} else {
+				lines = append(lines, fmt.Sprintf("\tparameters = parameters.Param(%s).Decimal(%s.Bytes, %s.Precision, %s.Scale)", paramName, variable, variable, variable))
+			}
+			return true
+		}
+
 		if isArray {
 			lines = append(lines, fmt.Sprintf("\tvar list = parameters.Param(%s).BeginList()", paramName))
 			lines = append(lines, fmt.Sprintf("\tfor _, param := range %s {", variable))

internal/codegen/golang/templates/stdlib/queryCode.tmpl

@@ -125,7 +125,7 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{ dbarg }} {{.Arg.Pair}}
 {{end}}
 
 {{define "queryCodeStdExec"}}
-    {{- if .Arg.HasSqlcSlices }}
+    {{- if and (not isYDBEngine) .Arg.HasSqlcSlices }}
         query := {{.ConstantName}}
         var queryParams []interface{}
         {{- if .Arg.Struct }}

internal/codegen/golang/templates/ydb-go-sdk/interfaceCode.tmpl

@@ -3,30 +3,30 @@
     {{- $dbtxParam := .EmitMethodsWithDBArgument -}}
     {{- range .GoQueries}}
         {{- if and (eq .Cmd ":one") ($dbtxParam) }}
-            {{range .Comments}}//{{.}}
-            {{end -}}
+            {{- range .Comments}}//{{.}}
+            {{- end}}
             {{.MethodName}}(ctx context.Context, db DBTX, {{if not .Arg.IsEmpty}}{{.Arg.Pair}}, {{end}}opts ...query.ExecuteOption) ({{.Ret.DefineType}}, error)
         {{- else if eq .Cmd ":one"}}
-            {{range .Comments}}//{{.}}
-            {{end -}}
+            {{- range .Comments}}//{{.}}
+            {{- end}}
             {{.MethodName}}(ctx context.Context, {{if not .Arg.IsEmpty}}{{.Arg.Pair}}, {{end}}opts ...query.ExecuteOption) ({{.Ret.DefineType}}, error)
         {{- end}}
         {{- if and (eq .Cmd ":many") ($dbtxParam) }}
-            {{range .Comments}}//{{.}}
-            {{end -}}
+            {{- range .Comments}}//{{.}}
+            {{- end}}
             {{.MethodName}}(ctx context.Context, db DBTX, {{if not .Arg.IsEmpty}}{{.Arg.Pair}}, {{end}}opts ...query.ExecuteOption) ([]{{.Ret.DefineType}}, error)
         {{- else if eq .Cmd ":many"}}
             {{range .Comments}}//{{.}}
             {{end -}}
             {{.MethodName}}(ctx context.Context, {{if not .Arg.IsEmpty}}{{.Arg.Pair}}, {{end}}opts ...query.ExecuteOption) ([]{{.Ret.DefineType}}, error)
         {{- end}}
         {{- if and (eq .Cmd ":exec") ($dbtxParam) }}
-            {{range .Comments}}//{{.}}
-            {{end -}}
+            {{- range .Comments}}//{{.}}
+            {{- end}}
             {{.MethodName}}(ctx context.Context, db DBTX, {{if not .Arg.IsEmpty}}{{.Arg.Pair}}, {{end}}opts ...query.ExecuteOption) error
         {{- else if eq .Cmd ":exec"}}
-            {{range .Comments}}//{{.}}
-            {{end -}}
+            {{- range .Comments}}//{{.}}
+            {{- end}}
             {{.MethodName}}(ctx context.Context, {{if not .Arg.IsEmpty}}{{.Arg.Pair}}, {{end}}opts ...query.ExecuteOption) error
         {{- end}}
     {{- end}}

internal/codegen/golang/templates/ydb-go-sdk/queryCode.tmpl

@@ -107,7 +107,11 @@ func (q *Queries) {{.MethodName}}(ctx context.Context, {{if $.EmitMethodsWithDBA
     {{else}}
     var items []{{.Ret.DefineType}}
     {{end -}}
-	for row, err := range result.Rows(ctx) {
+	for {
+        row, err := result.NextRow(ctx)
+        if errors.Is(err, io.EOF) {
+            break
+        }
 		if err != nil {
 			{{- if $.WrapErrors}}
             return nil, xerrors.WithStackTrace(fmt.Errorf("query {{.MethodName}}: %w", err))

internal/codegen/golang/ydb_type.go

@@ -72,25 +72,37 @@ func YDBType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.Col
 		return "*int64"
 
 	case "uint8":
+		if notNull {
+			return "uint8"
+		}
 		if emitPointersForNull {
 			return "*uint8"
 		}
-		return "uint8"
+		return "*uint8"
 	case "uint16":
+		if notNull {
+			return "uint16"
+		}
 		if emitPointersForNull {
 			return "*uint16"
 		}
-		return "uint16"
+		return "*uint16"
 	case "uint32":
+		if notNull {
+			return "uint32"
+		}
 		if emitPointersForNull {
 			return "*uint32"
 		}
-		return "uint32"
+		return "*uint32"
 	case "uint64":
+		if notNull {
+			return "uint64"
+		}
 		if emitPointersForNull {
 			return "*uint64"
 		}
-		return "uint64"
+		return "*uint64"
 
 	case "float":
 		if notNull {
@@ -114,7 +126,7 @@ func YDBType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.Col
 		return "*float64"
 
 	// string types
-	case "string", "utf8", "text":
+	case "utf8", "text":
 		if notNull {
 			return "string"
 		}
@@ -163,7 +175,7 @@ func YDBType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.Col
 		}
 		return "*string"
 
-	case "date", "date32", "datetime", "timestamp", "tzdate", "tztimestamp", "tzdatetime":
+	case "date", "date32", "datetime", "timestamp", "tzdate", "tztimestamp", "tzdatetime", "datetime64", "timestamp64", "tzdate32", "tzdatetime64", "tztimestamp64":
 		if notNull {
 			return "time.Time"
 		}
@@ -172,6 +184,15 @@ func YDBType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.Col
 		}
 		return "*time.Time"
 
+	case "interval", "interval64":
+		if notNull {
+			return "time.Duration"
+		}
+		if emitPointersForNull {
+			return "*time.Duration"
+		}
+		return "*time.Duration"
+
 	case "uuid":
 		if notNull {
 			return "uuid.UUID"
@@ -181,7 +202,7 @@ func YDBType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.Col
 		}
 		return "*uuid.UUID"
 
-	case "yson":
+	case "yson", "string":
 		if notNull {
 			return "[]byte"
 		}
@@ -197,7 +218,28 @@ func YDBType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.Col
 	case "any":
 		return "interface{}"
 
+	case "integer":
+		// integer type is used for LIMIT/OFFSET parameters - use uint64 for semantic correctness
+		if notNull {
+			return "uint64"
+		}
+		if emitPointersForNull {
+			return "*uint64"
+		}
+		return "*uint64"
+
 	default:
+		if strings.HasPrefix(columnType, "decimal") {
+			if notNull {
+				return "types.Decimal"
+			}
+
+			if emitPointersForNull {
+				return "*types.Decimal"
+			}
+			return "*types.Decimal"
+		}
+
 		if debug.Active {
 			log.Printf("unknown YDB type: %s\n", columnType)
 		}