Cleanup

Author: trzysiek

platform/frontend_connectors/search.go

@@ -623,13 +623,7 @@ func (q *QueryRunner) handleSearchCommon(ctx context.Context, indexPattern strin
 		pushSecondaryInfo(q.debugInfoCollector, id, "", path, bodyAsBytes, queriesBody, responseBody, startTime)
 		return responseBody, errors.New(string(responseBody))
 	}
-	for _, query := range plan.Queries {
-		fmt.Println("PRE", query.SelectCommand.String())
-	}
 	err = q.transformQueries(ctx, plan)
-	for _, query := range plan.Queries {
-		fmt.Println("POST", query.SelectCommand.String())
-	}
 	if err != nil {
 		return responseBody, err
 	}

platform/frontend_connectors/search_test.go

@@ -859,10 +859,6 @@ func TestSearchTrackTotalCount(t *testing.T) {
 	for i, tt := range testdata.FullSearchRequests {
 		for _, handlerName := range handlers {
 			t.Run(strconv.Itoa(i)+" "+tt.Name, func(t *testing.T) {
-				fmt.Println("test i", i)
-				if i != 6 {
-					//t.Skip()
-				}
 				test(handlerName, tt)
 			})
 		}

platform/model/bucket_aggregations/dateRange.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"github.com/QuesmaOrg/quesma/platform/logger"
 	"github.com/QuesmaOrg/quesma/platform/model"
-	"github.com/k0kubun/pp"
 	"time"
 )
 
@@ -86,7 +85,6 @@ func (query DateRange) TranslateSqlResponseToJson(rows []model.QueryResultRow) m
 	}
 	for intervalIdx, columnIdx := 0, startIteration; intervalIdx < len(query.intervals); intervalIdx++ {
 		responseForInterval, nextColumnIdx := query.responseForInterval(&rows[0], intervalIdx, columnIdx)
-		fmt.Println("responseForInterval", responseForInterval)
 		response = append(response, responseForInterval)
 		columnIdx = nextColumnIdx
 	}
@@ -96,7 +94,7 @@ func (query DateRange) TranslateSqlResponseToJson(rows []model.QueryResultRow) m
 }
 
 func (query DateRange) String() string {
-	return "date_range, intervals: " + fmt.Sprintf("%v", query.intervals)
+	return fmt.Sprintf("date_range, intervals: %v", query.intervals)
 }
 
 func (query DateRange) responseForInterval(row *model.QueryResultRow, intervalIdx, columnIdx int) (
@@ -185,7 +183,6 @@ func (query DateRange) CombinatorTranslateSqlResponseToJson(subGroup CombinatorG
 
 	// TODO: we need translate relative to real time
 	interval := query.intervals[subGroup.idx]
-	pp.Println(interval, model.AsString(interval.begin), model.AsString(interval.end))
 	if interval.begin != UnboundedInterval {
 		response["from"] = model.AsString(interval.begin)
 		response["from_as_string"] = interval.begin

platform/model/expr_string_renderer.go

@@ -67,7 +67,6 @@ func (v *renderer) VisitFunction(e FunctionExpr) interface{} {
 }
 
 func (v *renderer) VisitLiteral(l LiteralExpr) interface{} {
-	fmt.Println("VisitLiteral", l)
 	switch val := l.Value.(type) {
 	case string:
 		switch l.EscapeType {

platform/model/where_visitor.go

@@ -19,19 +19,11 @@ func FindTimestampLowerBound(field ColumnRef, whereClause Expr) (lowerBoundTs ti
 		if columnRef, ok := e.Left.(ColumnRef); ok && columnRef == field && e.Op == ">=" || e.Op == ">" {
 			if fun, ok := e.Right.(FunctionExpr); ok && fun.Name == FromUnixTimestampMs && len(fun.Args) == 1 {
 				if rhs, ok := fun.Args[0].(LiteralExpr); ok {
-					var tim time.Time
-					switch v := rhs.Value.(type) {
-					case time.Time:
-						tim = v
-					case TimeLiteral:
-						tim = v.Value
-					default:
-						return nil
-					}
-
-					if !found || tim.Before(lowerBoundTs) {
-						lowerBoundTs = tim
-						found = true
+					if timestamp, ok := rhs.Value.(TimeLiteral); ok {
+						if !found || timestamp.Value.Before(lowerBoundTs) {
+							lowerBoundTs = timestamp.Value
+							found = true
+						}
 					}
 				}
 			}

platform/parsers/elastic_query_dsl/aggregation_date_range_parser.go

@@ -35,7 +35,7 @@ func (cw *ClickhouseQueryTranslator) parseDateRangeAggregation(aggregation *panc
 		const defaultIntervalBound = bucket_aggregations.UnboundedIntervalString
 		var intervalBegin model.Expr
 		if from := cw.parseStringField(rangeMap, "from", defaultIntervalBound); from != defaultIntervalBound {
-			intervalBegin, err = cw.parseDateTimeInClickhouseMathLanguage(colRef, from)
+			intervalBegin, err = cw.parseDateTimeInClickhouseMathLanguage(from, colRef)
 			if err != nil {
 				return err
 			}
@@ -44,7 +44,7 @@ func (cw *ClickhouseQueryTranslator) parseDateRangeAggregation(aggregation *panc
 
 		var intervalEnd model.Expr
 		if to := cw.parseStringField(rangeMap, "to", defaultIntervalBound); to != defaultIntervalBound {
-			intervalEnd, err = cw.parseDateTimeInClickhouseMathLanguage(colRef, to)
+			intervalEnd, err = cw.parseDateTimeInClickhouseMathLanguage(to, colRef)
 			if err != nil {
 				return err
 			}
@@ -60,12 +60,12 @@ func (cw *ClickhouseQueryTranslator) parseDateRangeAggregation(aggregation *panc
 // parseDateTimeInClickhouseMathLanguage parses dateTime from Clickhouse's format
 // It's described here: https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-daterange-aggregation.html
 // Maybe not 100% of it is implemented, not sure.
-func (cw *ClickhouseQueryTranslator) parseDateTimeInClickhouseMathLanguage(field model.ColumnRef, dateTime string) (model.Expr, error) {
+func (cw *ClickhouseQueryTranslator) parseDateTimeInClickhouseMathLanguage(dateTime string, field model.ColumnRef) (model.Expr, error) {
 	// So far we've seen only either:
 	// 1. 2024-01-01 format TODO update
 	dateManager := NewDateManager(cw.Ctx)
-	if funcName, expr := dateManager.ParseDateUsualFormat(dateTime, field); expr != nil {
-		return model.NewFunction(funcName, expr), nil
+	if parsed := dateManager.ParseDateUsualFormat(dateTime, field); parsed != nil {
+		return parsed, nil
 	}
 	// 2. expressions like now() or now()-1d
 	res, err := cw.parseDateMathExpression(dateTime, field)

platform/parsers/elastic_query_dsl/dates.go

@@ -64,11 +64,11 @@ func (dm DateManager) parseStrictDateOptionalTimeOrEpochMillis(date any) (utcTim
 // ParseDateUsualFormat parses date expression, which is in [strict_date_optional_time || epoch_millis] format
 // (https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html)
 // It's most usual format for date in Kibana, used e.g. in Query DSL's range, or date_histogram.
-func (dm DateManager) ParseDateUsualFormat(exprFromRequest any, field model.ColumnRef) (funcName string, resultExpr model.Expr) {
+func (dm DateManager) ParseDateUsualFormat(exprFromRequest any, field model.ColumnRef) (resultExpr model.Expr) {
 	if unixTsInMs, success := dm.parseStrictDateOptionalTimeOrEpochMillis(exprFromRequest); success {
-		return model.FromUnixTimestampMs, model.NewTimeLiteral(unixTsInMs, field)
+		return model.NewFunction(model.FromUnixTimestampMs, model.NewTimeLiteral(unixTsInMs, field))
 	}
-	return model.FromUnixTimestampMs, nil // todo usunac te funkcje jak zawsze zwracam to samo? xD
+	return nil
 
 	/*
 		if utcTs, success := dm.parseStrictDateOptionalTimeOrEpochMillis(exprFromRequest); success {

platform/parsers/elastic_query_dsl/query_parser.go

@@ -817,17 +817,16 @@ func (cw *ClickhouseQueryTranslator) parseRange(queryMap QueryMap) model.SimpleQ
 			switch fieldType {
 			case clickhouse.DateTime, clickhouse.DateTime64:
 				// TODO add support for "time_zone" parameter in ParseDateUsualFormat
-				funcName, finalValue = dateManager.ParseDateUsualFormat(value, model.NewColumnRef(fieldName)) // stage 1
-				if !areWeDoneParsing() && (op == "gte" || op == "lte" || op == "gt" || op == "lt") {          // stage 2
+				finalValue = dateManager.ParseDateUsualFormat(value, model.NewColumnRef(fieldName))  // stage 1
+				if !areWeDoneParsing() && (op == "gte" || op == "lte" || op == "gt" || op == "lt") { // stage 2
 					parsed, err := cw.parseDateMathExpression(value, model.NewColumnRef(fieldName))
 					fmt.Println("QQQ parsed: ", parsed, funcName, cw.DateMathRenderer)
 					if err == nil {
-						funcName = "" // date math expressions don't need function name
 						finalValue = parsed
 					}
 				}
 				if !areWeDoneParsing() && isQuoted { // stage 3
-					funcName, finalValue = dateManager.ParseDateUsualFormat(value[1:len(value)-1], model.NewColumnRef(fieldName))
+					finalValue = dateManager.ParseDateUsualFormat(value[1:len(value)-1], model.NewColumnRef(fieldName))
 				}
 			case clickhouse.Invalid:
 				if isQuoted {