Cleanup

Author: trzysiek

quesma/model/bucket_aggregations/date_histogram.go

@@ -83,14 +83,10 @@ func (query *DateHistogram) TranslateSqlResponseToJson(rows []model.QueryResultR
 	// Implement default when query.minDocCount == DefaultMinDocCount, we need to return
 	// all buckets between the first bucket that matches documents and the last one.
 
-	fmt.Println("rowsy", rows)
-
 	if query.minDocCount == 0 {
 		rows = query.NewRowsTransformer().Transform(query.ctx, rows)
 	}
 
-	fmt.Println("rowsy", rows)
-
 	var response []model.JsonMap
 	for _, row := range rows {
 		docCount := row.LastColValue()

quesma/model/bucket_aggregations/filters.go

@@ -10,16 +10,24 @@ import (
 )
 
 type Filters struct {
-	Ctx     context.Context
+	ctx     context.Context
 	Filters []Filter
 }
 
 func NewFiltersEmpty(ctx context.Context) Filters {
-	return Filters{Ctx: ctx}
+	return Filters{ctx: ctx}
 }
 
 func NewFilters(ctx context.Context, filters []Filter) Filters {
-	return Filters{Ctx: ctx, Filters: filters}
+	return Filters{ctx: ctx, Filters: filters}
+}
+
+func (query Filters) NewFiltersSingleFilter(idx int) Filters {
+	if idx < 0 || idx >= len(query.Filters) {
+		logger.ErrorWithCtx(query.ctx).Msgf("invalid index %d for filters aggregation", idx)
+		return NewFiltersEmpty(query.ctx)
+	}
+	return NewFilters(query.ctx, []Filter{query.Filters[idx]})
 }
 
 type Filter struct {
@@ -41,7 +49,7 @@ func (query Filters) TranslateSqlResponseToJson(rows []model.QueryResultRow) mod
 		if len(rows[0].Cols) > 0 {
 			value = rows[0].Cols[len(rows[0].Cols)-1].Value
 		} else {
-			logger.ErrorWithCtx(query.Ctx).Msgf("unexpected number of columns in filters aggregation response, len(rows[0].Cols): %d", len(rows[0].Cols))
+			logger.ErrorWithCtx(query.ctx).Msgf("unexpected number of columns in filters aggregation response, len(rows[0].Cols): %d", len(rows[0].Cols))
 		}
 	}
 	return model.JsonMap{
@@ -58,7 +66,6 @@ func (query Filters) DoesNotHaveGroupBy() bool {
 }
 
 func (query Filters) CombinatorGroups() (result []CombinatorGroup) {
-	fmt.Println("combining groups", query.Filters)
 	for filterIdx, filter := range query.Filters {
 		prefix := fmt.Sprintf("filter_%d__", filterIdx)
 		if len(query.Filters) == 1 {
@@ -80,8 +87,8 @@ func (query Filters) CombinatorTranslateSqlResponseToJson(subGroup CombinatorGro
 
 func (query Filters) CombinatorSplit() []model.QueryType {
 	result := make([]model.QueryType, 0, len(query.Filters))
-	for _, filter := range query.Filters {
-		result = append(result, NewFilters(query.Ctx, []Filter{filter}))
+	for i := range query.Filters {
+		result = append(result, query.NewFiltersSingleFilter(i))
 	}
 	return result
 }

quesma/queryparser/aggregation_parser_test.go

@@ -666,7 +666,6 @@ func allAggregationTests() []testdata.AggregationTestCase {
 	add(kibana_visualize.PipelineAggregationTests, "kibana-visualize/pipeline_agg_req")
 	add(clients.KunkkaTests, "clients/kunkka")
 	add(clients.OpheliaTests, "clients/ophelia")
-	add(clients.OpheliaTests, "clients/ophelia")
 	add(clients.CloverTests, "clients/clover")
 
 	return allTests

quesma/queryparser/pancake_json_rendering.go

@@ -5,7 +5,6 @@ package queryparser
 import (
 	"context"
 	"fmt"
-	"github.com/k0kubun/pp"
 	"quesma/logger"
 	"quesma/model"
 	"quesma/model/bucket_aggregations"
@@ -185,12 +184,7 @@ func (p *pancakeJSONRenderer) combinatorBucketToJSON(remainingLayers []*pancakeM
 	case bucket_aggregations.CombinatorAggregationInterface:
 		var bucketArray []model.JsonMap
 		for _, subGroup := range queryType.CombinatorGroups() {
-			fmt.Println("subGroup", subGroup, rows)
 			selectedRowsWithoutPrefix := p.selectPrefixRows(subGroup.Prefix, rows)
-			if len(selectedRowsWithoutPrefix) == 0 || len(selectedRowsWithoutPrefix[0].Cols) == 0 {
-				selectedRowsWithoutPrefix = rows // haaaack
-			}
-			fmt.Println("selectedRowsWithoutPrefix", selectedRowsWithoutPrefix)
 
 			subAggr, err := p.layerToJSON(remainingLayers[1:], selectedRowsWithoutPrefix)
 			if err != nil {
@@ -254,11 +248,8 @@ func (p *pancakeJSONRenderer) layerToJSON(remainingLayers []*pancakeModelLayer,
 
 	if layer.nextBucketAggregation != nil {
 		// sampler and filter are special
-		pp.Println("DoesHaveGroupBy", layer.nextBucketAggregation.DoesHaveGroupBy())
 		if !layer.nextBucketAggregation.DoesHaveGroupBy() {
-			fmt.Println("jestem :blush:")
 			json, err := p.combinatorBucketToJSON(remainingLayers, rows)
-			pp.Println("json", json)
 			if err != nil {
 				return nil, err
 			}
@@ -293,7 +284,6 @@ func (p *pancakeJSONRenderer) layerToJSON(remainingLayers []*pancakeModelLayer,
 		bucketRows, subAggrRows = p.potentiallyRemoveExtraBucket(layer, bucketRows, subAggrRows)
 
 		buckets := layer.nextBucketAggregation.queryType.TranslateSqlResponseToJson(bucketRows)
-		fmt.Println("buckets", buckets)
 
 		if len(buckets) == 0 { // without this we'd generate {"buckets": []} in the response, which Elastic doesn't do.
 			if layer.nextBucketAggregation.metadata != nil {

quesma/queryparser/pancake_model.go

@@ -20,15 +20,13 @@ type pancakeModel struct {
 	sampleLimit int
 }
 
-func (p *pancakeModel) ShallowClone() *pancakeModel {
+func (p *pancakeModel) Clone() *pancakeModel {
 	layers := make([]*pancakeModelLayer, len(p.layers))
 	for i, layer := range p.layers {
-		layers[i] = &pancakeModelLayer{
-			nextBucketAggregation:        layer.nextBucketAggregation,
-			currentMetricAggregations:    layer.currentMetricAggregations,
-			currentPipelineAggregations:  layer.currentPipelineAggregations,
-			childrenPipelineAggregations: layer.childrenPipelineAggregations,
-		}
+		layers[i] = newPancakeModelLayer(layer.nextBucketAggregation)
+		layers[i].currentMetricAggregations = p.layers[i].currentMetricAggregations
+		layers[i].currentPipelineAggregations = p.layers[i].currentPipelineAggregations
+		layers[i].childrenPipelineAggregations = p.layers[i].childrenPipelineAggregations
 	}
 	return &pancakeModel{
 		layers:      layers,

quesma/queryparser/pancake_transformer.go

@@ -453,17 +453,17 @@ func (a *pancakeTransformer) createFiltersPancakes(pancake *pancakeModel) (resul
 	if len(firstLayer.currentMetricAggregations) == 0 && len(firstLayer.currentPipelineAggregations) == 0 && len(pancake.layers) > 1 { // maybe secondLayer, not first?
 		// If filter is in the first layer, we can just add it to the where clause
 		fmt.Println("jestem tu?", len(filters.Filters))
-		for _, filter := range filters.Filters[1:] {
-			newPancake := pancake.ShallowClone()
+		for i, filter := range filters.Filters[1:] {
+			newPancake := pancake.Clone()
 			// new (every) pancake has only 1 filter instead of all
 			bucketAggr := newPancake.layers[0].nextBucketAggregation.ShallowClone()
-			bucketAggr.queryType = bucket_aggregations.NewFilters(filters.Ctx, []bucket_aggregations.Filter{filter})
+			bucketAggr.queryType = filters.NewFiltersSingleFilter(i + 1) // +1 because we iterate over [1:]
 			pp.Println("new filter", bucketAggr.queryType)
 			newPancake.layers[0] = newPancakeModelLayer(&bucketAggr)
 			newPancake.whereClause = model.And([]model.Expr{newPancake.whereClause, filter.Sql.WhereClause})
 			result = append(result, newPancake)
 		}
-		pancake.layers[0].nextBucketAggregation.queryType = bucket_aggregations.NewFilters(filters.Ctx, []bucket_aggregations.Filter{filters.Filters[0]})
+		pancake.layers[0].nextBucketAggregation.queryType = filters.NewFiltersSingleFilter(0)
 		pp.Println("hoho", filters)
 	}
 	return