Merge pull request #59 from v3io/development

Igor Makhlin · web-flow · commit af5a59804c4e · 2018-08-19T10:11:36.000+03:00
dev-&gt;master
diff --git a/pkg/aggregate/aggregate.go b/pkg/aggregate/aggregate.go
@@ -103,6 +103,22 @@ func getAggrFullName(field config.SchemaField, col string) config.SchemaField {
 
 func (a AggrType) String() string { return aggrToString[a] }
 
+func AggregatorsToStringList(aggregators string) ([]string, error) {
+	aggrs := strings.Split(aggregators, ",")
+	aggType, err := AggrsFromString(aggrs)
+	if err != nil {
+		return nil, err
+	}
+	var list []string
+	for _, aggr := range rawAggregators {
+		if aggr&aggType != 0 {
+			list = append(list, aggrToString[aggr])
+		}
+	}
+
+	return list, nil
+}
+
 // convert comma separated string to aggregator mask
 func AggrsFromString(split []string) (AggrType, error) {
 	var aggrList AggrType
@@ -132,13 +148,13 @@ func NewAggregatorList(aggrType AggrType) *AggregatorList {
 		list = append(list, &SqrAggregator{FloatAggregator{attr: "sqr"}})
 	}
 	if (aggrType & aggrTypeMin) != 0 {
-		list = append(list, &MinAggregator{FloatAggregator{attr: "min", val: math.MaxFloat64}}) // TODO: use math.Inf(1)
+		list = append(list, &MinAggregator{FloatAggregator{attr: "min", val: math.Inf(1)}})
 	}
 	if (aggrType & aggrTypeMax) != 0 {
-		list = append(list, &MaxAggregator{FloatAggregator{attr: "max", val: -math.MaxFloat64}}) // TODO: use math.Inf(-1)
+		list = append(list, &MaxAggregator{FloatAggregator{attr: "max", val: math.Inf(-1)}})
 	}
 	if (aggrType & aggrTypeLast) != 0 {
-		list = append(list, &LastAggregator{FloatAggregator{attr: "last"}, 0})
+		list = append(list, &LastAggregator{FloatAggregator{attr: "last", val: math.Inf(-1)}, 0})
 	}
 	return &list
 }
diff --git a/pkg/aggregate/functions.go b/pkg/aggregate/functions.go
@@ -75,14 +75,14 @@ func (a *FloatAggregator) UpdateExpr(col string, bucket int) string {
 }
 
 func (a *FloatAggregator) InitExpr(col string, buckets int) string {
-	return fmt.Sprintf("_%s_%s=init_array(%d,'double');", col, a.attr, buckets)
+	return fmt.Sprintf("_%s_%s=init_array(%d,'double',%f);", col, a.attr, buckets, a.val)
 }
 
 // Sum Aggregator
 type SumAggregator struct{ FloatAggregator }
 
 func (a *SumAggregator) Aggregate(t int64, v float64) {
-	if !math.IsNaN(v) {
+	if utils.IsDefined(v) {
 		a.val += v
 	}
 }
@@ -91,18 +91,18 @@ func (a *SumAggregator) Aggregate(t int64, v float64) {
 type SqrAggregator struct{ FloatAggregator }
 
 func (a *SqrAggregator) Aggregate(t int64, v float64) {
-	if !math.IsNaN(v) {
+	if utils.IsDefined(v) {
 		a.val += v * v
 	}
 }
 
 // Minimum Aggregator
 type MinAggregator struct{ FloatAggregator }
 
-func (a *MinAggregator) Clear() { a.val = math.MaxFloat64 } // TODO: use math.Inf(1)
+func (a *MinAggregator) Clear() { a.val = math.Inf(1) }
 
 func (a *MinAggregator) Aggregate(t int64, v float64) {
-	if !math.IsNaN(v) && (math.IsNaN(a.val) || v < a.val) {
+	if v < a.val {
 		a.val = v
 	}
 }
@@ -114,10 +114,10 @@ func (a *MinAggregator) UpdateExpr(col string, bucket int) string {
 // Maximum Aggregator
 type MaxAggregator struct{ FloatAggregator }
 
-func (a *MaxAggregator) Clear() { a.val = -math.MaxFloat64 } // TODO: use math.Inf(-1)
+func (a *MaxAggregator) Clear() { a.val = math.Inf(-1) }
 
 func (a *MaxAggregator) Aggregate(t int64, v float64) {
-	if !math.IsNaN(v) && (math.IsNaN(a.val) || v > a.val) {
+	if v > a.val {
 		a.val = v
 	}
 }
@@ -132,7 +132,7 @@ type LastAggregator struct {
 	lastT int64
 }
 
-func (a *LastAggregator) Clear() { a.val = -math.MaxFloat64 } // TODO: use math.Inf(1)
+func (a *LastAggregator) Clear() { a.val = math.Inf(-1) }
 
 func (a *LastAggregator) Aggregate(t int64, v float64) {
 	if t > a.lastT {
@@ -142,7 +142,7 @@ func (a *LastAggregator) Aggregate(t int64, v float64) {
 }
 
 func (a *LastAggregator) UpdateExpr(col string, bucket int) string {
-	if math.IsNaN(a.val) {
+	if utils.IsUndefined(a.val) {
 		return ""
 	}
 
diff --git a/pkg/appender/store.go b/pkg/appender/store.go
@@ -274,7 +274,7 @@ func (cs *chunkStore) WriteChunks(mc *MetricsCache, metric *MetricState) (bool,
 	var pendingSamplesCount int
 
 	// loop over pending samples, add to chunks & aggregates (create required update expressions)
-	for pendingSampleIndex < len(cs.pending) && pendingSamplesCount < mc.cfg.BatchSize && partition.InRange(cs.pending[pendingSampleIndex].t) {
+	for {
 		sampleTime := cs.pending[pendingSampleIndex].t
 
 		if sampleTime <= cs.initMaxTime && !mc.cfg.OverrideOld {
@@ -308,6 +308,7 @@ func (cs *chunkStore) WriteChunks(mc *MetricsCache, metric *MetricState) (bool,
 		if (pendingSampleIndex == len(cs.pending)-1) || pendingSamplesCount == mc.cfg.BatchSize-1 || !partition.InRange(cs.pending[pendingSampleIndex+1].t) {
 			expr = expr + cs.aggrList.SetOrUpdateExpr("v", bucket, isNewBucket)
 			expr = expr + cs.appendExpression(activeChunk)
+			cs.aggrList.Clear()
 			pendingSampleIndex++
 			pendingSamplesCount++
 			break
@@ -333,7 +334,6 @@ func (cs *chunkStore) WriteChunks(mc *MetricsCache, metric *MetricState) (bool,
 		pendingSamplesCount++
 	}
 
-	cs.aggrList.Clear()
 	if pendingSampleIndex == len(cs.pending) {
 		cs.pending = cs.pending[:0]
 	} else {
diff --git a/pkg/config/config.go b/pkg/config/config.go
@@ -56,8 +56,8 @@ type V3ioConfig struct {
 }
 
 type Rollup struct {
-	Aggregators            string `json:"aggregators"`
-	AggregatorsGranularity string `json:"aggregatorsGranularity"`
+	Aggregators            []string `json:"aggregators"`
+	AggregatorsGranularity string   `json:"aggregatorsGranularity"`
 	//["cloud","local"] for the aggregators and sample chucks
 	StorageClass string `json:"storageClass"`
 	//in hours. 0  means no need to save samples
diff --git a/pkg/formatter/type.go b/pkg/formatter/type.go
@@ -43,8 +43,7 @@ func (f baseFormatter) timeString(t int64) string {
 	if f.cfg.TimeFormat == "" {
 		return strconv.Itoa(int(t))
 	}
-
-	return time.Unix(t/1000, 0).Format(f.cfg.TimeFormat)
+	return time.Unix(t/1000, 0).UTC().Format(f.cfg.TimeFormat)
 }
 
 func labelsToStr(labels utils.Labels) (string, string) {
diff --git a/pkg/partmgr/partmgr.go b/pkg/partmgr/partmgr.go
@@ -227,7 +227,8 @@ func (p *DBPartition) GetShardingKeys(name string) []string {
 	shardingKeysNum := p.manager.cfg.TableSchemaInfo.ShardingBuckets
 	var res = make([]string, 0, shardingKeysNum)
 	for i := 0; i < shardingKeysNum; i++ {
-		res = append(res, fmt.Sprintf("%s_%x", name, i))
+		// Trailing dot for rangescan queries
+		res = append(res, fmt.Sprintf("%s_%x.", name, i))
 	}
 
 	return res
diff --git a/pkg/querier/querier.go b/pkg/querier/querier.go
@@ -139,7 +139,7 @@ func (q *V3ioQuerier) LabelValues(name string) ([]string, error) {
 
 	list := []string{}
 	input := v3io.GetItemsInput{Path: q.cfg.Path + "/names/", AttributeNames: []string{"__name"}, Filter: ""}
-	iter, err := utils.NewAsyncItemsCursor(q.container, &input, q.cfg.QryWorkers, []string{})
+	iter, err := utils.NewAsyncItemsCursor(q.container, &input, q.cfg.QryWorkers, []string{}, q.logger)
 	q.logger.DebugWith("GetItems to read names", "input", input, "err", err)
 	if err != nil {
 		return list, err
diff --git a/pkg/querier/seriesset.go b/pkg/querier/seriesset.go
@@ -73,7 +73,7 @@ func (s *V3ioSeriesSet) getItems(partition *partmgr.DBPartition, name, filter st
 
 	s.logger.DebugWith("Select - GetItems", "path", path, "attr", attrs, "filter", filter, "name", name)
 	input := v3io.GetItemsInput{Path: path, AttributeNames: attrs, Filter: filter, ShardingKey: name}
-	iter, err := utils.NewAsyncItemsCursor(container, &input, workers, shardingKeys)
+	iter, err := utils.NewAsyncItemsCursor(container, &input, workers, shardingKeys, s.logger)
 	if err != nil {
 		return err
 	}
diff --git a/pkg/tsdb/tsdbtest/tsdbtest.go b/pkg/tsdb/tsdbtest/tsdbtest.go
@@ -143,7 +143,7 @@ func ValidateCountOfSamples(t testing.TB, adapter *V3ioAdapter, metricName strin
 	}
 
 	if expected != actual {
-		t.Fatalf("Check failed: actual result is not as expected (%d != %d)", expected, actual)
+		t.Fatalf("Check failed: actual result is not as expected [%d(actual) != %d(expected)]", actual, expected)
 	}
 }
 
@@ -155,8 +155,12 @@ func NormalizePath(path string) string {
 }
 
 func CreateSchema(t testing.TB, agg string) config.Schema {
+	rollups, err := aggregate.AggregatorsToStringList(agg)
+	if err != nil {
+		t.Fatal(err)
+	}
 	defaultRollup := config.Rollup{
-		Aggregators:            agg,
+		Aggregators:            rollups,
 		AggregatorsGranularity: "1h",
 		StorageClass:           "local",
 		SampleRetention:        0,
@@ -166,21 +170,20 @@ func CreateSchema(t testing.TB, agg string) config.Schema {
 	tableSchema := config.TableSchema{
 		Version:             0,
 		RollupLayers:        []config.Rollup{defaultRollup},
-		ShardingBuckets:     1,
+		ShardingBuckets:     8,
 		PartitionerInterval: "2d",
 		ChunckerInterval:    "1h",
 	}
 
-	aggrs := []string{"*"}
-	fields, err := aggregate.SchemaFieldFromString(aggrs, "v")
+	fields, err := aggregate.SchemaFieldFromString(rollups, "v")
 	if err != nil {
 		t.Fatal("Failed to create aggregators list", err)
 	}
 	fields = append(fields, config.SchemaField{Name: "_name", Type: "string", Nullable: false, Items: ""})
 
 	partitionSchema := config.PartitionSchema{
 		Version:                tableSchema.Version,
-		Aggregators:            aggrs,
+		Aggregators:            rollups,
 		AggregatorsGranularity: "1h",
 		StorageClass:           "local",
 		SampleRetention:        0,
diff --git a/pkg/tsdb/v3iotsdb.go b/pkg/tsdb/v3iotsdb.go
@@ -181,7 +181,7 @@ func (a *V3ioAdapter) DeleteDB(configExists bool, force bool, fromTime int64, to
 	for _, part := range partitions {
 		if toTime == 0 || part.GetEndTime() < toTime {
 			a.logger.Info("Delete partition %s", part.GetTablePath())
-			err := utils.DeleteTable(a.container, part.GetTablePath(), "", a.cfg.QryWorkers)
+			err := utils.DeleteTable(a.logger, a.container, part.GetTablePath(), "", a.cfg.QryWorkers)
 			if err != nil && !force {
 				return err
 			}
@@ -191,7 +191,7 @@ func (a *V3ioAdapter) DeleteDB(configExists bool, force bool, fromTime int64, to
 	}
 	path := a.cfg.Path + "/names/"
 	a.logger.Info("Delete metric names in path %s", path)
-	err := utils.DeleteTable(a.container, path, "", a.cfg.QryWorkers)
+	err := utils.DeleteTable(a.logger, a.container, path, "", a.cfg.QryWorkers)
 	if err != nil && !force {
 		return err
 	}
@@ -218,7 +218,7 @@ func (a *V3ioAdapter) CountMetrics(part string) (int, error) {
 	partitions := a.partitionMngr.GetPartitions()
 	for _, part := range partitions {
 		input := v3io.GetItemsInput{Path: part.GetTablePath(), Filter: "", AttributeNames: []string{"__size"}}
-		iter, err := utils.NewAsyncItemsCursor(a.container, &input, a.cfg.QryWorkers, []string{})
+		iter, err := utils.NewAsyncItemsCursor(a.container, &input, a.cfg.QryWorkers, []string{}, a.logger)
 		if err != nil {
 			return 0, err
 		}
diff --git a/pkg/tsdbctl/add.go b/pkg/tsdbctl/add.go
@@ -136,18 +136,19 @@ func (ac *addCommandeer) add() error {
 		return err
 	}
 
-	ac.appendMetrics(append, lset)
+	err = ac.appendMetrics(append, lset)
+	if err != nil {
+		return err
+	}
 
 	// make sure all writes are committed
 	_, err = append.WaitForCompletion(0)
-
-	if err == nil {
-		fmt.Println("\nDone!")
-	} else {
-		fmt.Printf("operation timed out. Error: %v", err)
+	if err != nil {
+		return errors.Wrap(err, "operation timed out")
 	}
 
-	return err
+	ac.rootCommandeer.logger.Info("Done!")
+	return nil
 }
 
 func (ac *addCommandeer) appendMetrics(append tsdb.Appender, lset utils.Labels) error {
@@ -159,7 +160,7 @@ func (ac *addCommandeer) appendMetrics(append tsdb.Appender, lset utils.Labels)
 	} else {
 		fp, err = os.Open(ac.inFile)
 		if err != nil {
-			return errors.Wrapf(err, "cant open/read CSV input file: %s", ac.inFile)
+			return errors.Wrapf(err, "failed to open CSV")
 		}
 	}
 	defer fp.Close()
diff --git a/pkg/tsdbctl/check.go b/pkg/tsdbctl/check.go
@@ -124,7 +124,7 @@ func (cc *checkCommandeer) check() error {
 				iter := chunk.Iterator()
 				for iter.Next() {
 					t, v := iter.At()
-					tstr := time.Unix(int64(t/1000), 0).Format(time.RFC3339)
+					tstr := time.Unix(int64(t/1000), 0).UTC().Format(time.RFC3339)
 					fmt.Printf("unix=%d, t=%s, v=%.4f \n", t, tstr, v)
 					count++
 				}
diff --git a/pkg/tsdbctl/create.go b/pkg/tsdbctl/create.go
@@ -28,7 +28,6 @@ import (
 	"github.com/v3io/v3io-tsdb/pkg/config"
 	"github.com/v3io/v3io-tsdb/pkg/tsdb"
 	"strconv"
-	"strings"
 )
 
 const schemaVersion = 0
@@ -67,7 +66,7 @@ func newCreateCommandeer(rootCommandeer *RootCommandeer) *createCommandeer {
 	cmd.Flags().StringVarP(&commandeer.defaultRollups, "rollups", "r", "",
 		"Default aggregation rollups, comma seperated: count,avg,sum,min,max,stddev")
 	cmd.Flags().StringVarP(&commandeer.rollupInterval, "rollup-interval", "i", "1h", "aggregation interval")
-	cmd.Flags().IntVarP(&commandeer.shardingBuckets, "sharding-buckets", "b", 1, "number of buckets to split key")
+	cmd.Flags().IntVarP(&commandeer.shardingBuckets, "sharding-buckets", "b", 8, "number of buckets to split key")
 	cmd.Flags().IntVarP(&commandeer.sampleRetention, "sample-retention", "a", 0, "sample retention in hours")
 
 	commandeer.cmd = cmd
@@ -83,19 +82,24 @@ func (cc *createCommandeer) create() error {
 	}
 
 	if err := cc.validateFormat(cc.partitionInterval); err != nil {
-		return errors.Wrap(err, "Failed to parse partition interval")
+		return errors.Wrap(err, "failed to parse partition interval")
 	}
 
 	if err := cc.validateFormat(cc.chunkInterval); err != nil {
-		return errors.Wrap(err, "Failed to parse chunk interval")
+		return errors.Wrap(err, "failed to parse chunk interval")
 	}
 
 	if err := cc.validateFormat(cc.rollupInterval); err != nil {
-		return errors.Wrap(err, "Failed to parse rollup interval")
+		return errors.Wrap(err, "failed to parse rollup interval")
+	}
+
+	rollups, err := aggregate.AggregatorsToStringList(cc.defaultRollups)
+	if err != nil {
+		return errors.Wrap(err, "failed to parse default rollups")
 	}
 
 	defaultRollup := config.Rollup{
-		Aggregators:            cc.defaultRollups,
+		Aggregators:            rollups,
 		AggregatorsGranularity: cc.rollupInterval,
 		StorageClass:           defaultStorageClass,
 		SampleRetention:        cc.sampleRetention,
@@ -110,16 +114,15 @@ func (cc *createCommandeer) create() error {
 		ChunckerInterval:    cc.chunkInterval,
 	}
 
-	aggrs := strings.Split(cc.defaultRollups, ",")
-	fields, err := aggregate.SchemaFieldFromString(aggrs, "v")
+	fields, err := aggregate.SchemaFieldFromString(rollups, "v")
 	if err != nil {
-		return errors.Wrap(err, "Failed to create aggregators list")
+		return errors.Wrap(err, "failed to create aggregators list")
 	}
 	fields = append(fields, config.SchemaField{Name: "_name", Type: "string", Nullable: false, Items: ""})
 
 	partitionSchema := config.PartitionSchema{
 		Version:                tableSchema.Version,
-		Aggregators:            aggrs,
+		Aggregators:            rollups,
 		AggregatorsGranularity: cc.rollupInterval,
 		StorageClass:           defaultStorageClass,
 		SampleRetention:        cc.sampleRetention,
diff --git a/pkg/tsdbctl/time.go b/pkg/tsdbctl/time.go
@@ -51,7 +51,7 @@ func newTimeCommandeer(rootCommandeer *RootCommandeer) *timeCommandeer {
 
 			tint, err := strconv.Atoi(args[0])
 			if err == nil {
-				fmt.Println(time.Unix(int64(tint), 0).Format(time.RFC3339))
+				fmt.Println(time.Unix(int64(tint), 0).UTC().Format(time.RFC3339))
 				return nil
 			}
 
diff --git a/pkg/utils/asynciter.go b/pkg/utils/asynciter.go
diff --git a/pkg/utils/container.go b/pkg/utils/container.go
diff --git a/pkg/utils/misc.go b/pkg/utils/misc.go
diff --git a/test/benchmark/testdata/v3io.yaml b/test/benchmark/testdata/v3io.yaml

Original file line number	Diff line number	Diff line change
`@@ -75,14 +75,14 @@ func (a *FloatAggregator) UpdateExpr(col string, bucket int) string {`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`func (a *FloatAggregator) InitExpr(col string, buckets int) string {`
`78`		`- return fmt.Sprintf("_%s_%s=init_array(%d,'double');", col, a.attr, buckets)`
	`78`	`+ return fmt.Sprintf("_%s_%s=init_array(%d,'double',%f);", col, a.attr, buckets, a.val)`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`// Sum Aggregator`
`82`	`82`	`type SumAggregator struct{ FloatAggregator }`
`83`	`83`
`84`	`84`	`func (a *SumAggregator) Aggregate(t int64, v float64) {`
`85`		`- if !math.IsNaN(v) {`
	`85`	`+ if utils.IsDefined(v) {`
`86`	`86`	`a.val += v`
`87`	`87`	`}`
`88`	`88`	`}`
`@@ -91,18 +91,18 @@ func (a *SumAggregator) Aggregate(t int64, v float64) {`
`91`	`91`	`type SqrAggregator struct{ FloatAggregator }`
`92`	`92`
`93`	`93`	`func (a *SqrAggregator) Aggregate(t int64, v float64) {`
`94`		`- if !math.IsNaN(v) {`
	`94`	`+ if utils.IsDefined(v) {`
`95`	`95`	`a.val += v * v`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`// Minimum Aggregator`
`100`	`100`	`type MinAggregator struct{ FloatAggregator }`
`101`	`101`
`102`		`-func (a *MinAggregator) Clear() { a.val = math.MaxFloat64 } // TODO: use math.Inf(1)`
	`102`	`+func (a *MinAggregator) Clear() { a.val = math.Inf(1) }`
`103`	`103`
`104`	`104`	`func (a *MinAggregator) Aggregate(t int64, v float64) {`
`105`		`- if !math.IsNaN(v) && (math.IsNaN(a.val) \|\| v < a.val) {`
	`105`	`+ if v < a.val {`
`106`	`106`	`a.val = v`
`107`	`107`	`}`
`108`	`108`	`}`
`@@ -114,10 +114,10 @@ func (a *MinAggregator) UpdateExpr(col string, bucket int) string {`
`114`	`114`	`// Maximum Aggregator`
`115`	`115`	`type MaxAggregator struct{ FloatAggregator }`
`116`	`116`
`117`		`-func (a *MaxAggregator) Clear() { a.val = -math.MaxFloat64 } // TODO: use math.Inf(-1)`
	`117`	`+func (a *MaxAggregator) Clear() { a.val = math.Inf(-1) }`
`118`	`118`
`119`	`119`	`func (a *MaxAggregator) Aggregate(t int64, v float64) {`
`120`		`- if !math.IsNaN(v) && (math.IsNaN(a.val) \|\| v > a.val) {`
	`120`	`+ if v > a.val {`
`121`	`121`	`a.val = v`
`122`	`122`	`}`
`123`	`123`	`}`
`@@ -132,7 +132,7 @@ type LastAggregator struct {`
`132`	`132`	`lastT int64`
`133`	`133`	`}`
`134`	`134`
`135`		`-func (a *LastAggregator) Clear() { a.val = -math.MaxFloat64 } // TODO: use math.Inf(1)`
	`135`	`+func (a *LastAggregator) Clear() { a.val = math.Inf(-1) }`
`136`	`136`
`137`	`137`	`func (a *LastAggregator) Aggregate(t int64, v float64) {`
`138`	`138`	`if t > a.lastT {`
`@@ -142,7 +142,7 @@ func (a *LastAggregator) Aggregate(t int64, v float64) {`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`func (a *LastAggregator) UpdateExpr(col string, bucket int) string {`
`145`		`- if math.IsNaN(a.val) {`
	`145`	`+ if utils.IsUndefined(a.val) {`
`146`	`146`	`return ""`
`147`	`147`	`}`
`148`	`148`
Original file line number	Diff line number	Diff line change
`@@ -43,8 +43,7 @@ func (f baseFormatter) timeString(t int64) string {`
`43`	`43`	`if f.cfg.TimeFormat == "" {`
`44`	`44`	`return strconv.Itoa(int(t))`
`45`	`45`	`}`
`46`		`-`
`47`		`- return time.Unix(t/1000, 0).Format(f.cfg.TimeFormat)`
	`46`	`+ return time.Unix(t/1000, 0).UTC().Format(f.cfg.TimeFormat)`
`48`	`47`	`}`
`49`	`48`
`50`	`49`	`func labelsToStr(labels utils.Labels) (string, string) {`
Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,8 @@ func (p *DBPartition) GetShardingKeys(name string) []string {`
`227`	`227`	`shardingKeysNum := p.manager.cfg.TableSchemaInfo.ShardingBuckets`
`228`	`228`	`var res = make([]string, 0, shardingKeysNum)`
`229`	`229`	`for i := 0; i < shardingKeysNum; i++ {`
`230`		`- res = append(res, fmt.Sprintf("%s_%x", name, i))`
	`230`	`+ // Trailing dot for rangescan queries`
	`231`	`+ res = append(res, fmt.Sprintf("%s_%x.", name, i))`
`231`	`232`	`}`
`232`	`233`
`233`	`234`	`return res`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ func (s V3ioSeriesSet) getItems(partition partmgr.DBPartition, name, filter st`
`73`	`73`
`74`	`74`	`s.logger.DebugWith("Select - GetItems", "path", path, "attr", attrs, "filter", filter, "name", name)`
`75`	`75`	`input := v3io.GetItemsInput{Path: path, AttributeNames: attrs, Filter: filter, ShardingKey: name}`
`76`		`- iter, err := utils.NewAsyncItemsCursor(container, &input, workers, shardingKeys)`
	`76`	`+ iter, err := utils.NewAsyncItemsCursor(container, &input, workers, shardingKeys, s.logger)`
`77`	`77`	`if err != nil {`
`78`	`78`	`return err`
`79`	`79`	`}`