Execution plan refactor (#566)

This PR adds the ability to execute an alternative execution plan in
parallel. The results of the main and alternative plans are compared.

There is no alternative plan enabled at this point.

quesma/clickhouse/quesma_communicator.go

@@ -164,7 +164,9 @@ func executeQuery(ctx context.Context, lm *LogManager, query *model.Query, field
 			settings[k] = v
 		}
 
-		queryAsString = queryAsString + "\n-- optimizations: " + strings.Join(query.OptimizeHints.OptimizationsPerformed, ", ") + "\n"
+		if len(query.OptimizeHints.OptimizationsPerformed) > 0 {
+			queryAsString = queryAsString + "\n-- optimizations: " + strings.Join(query.OptimizeHints.OptimizationsPerformed, ", ") + "\n"
+		}
 	}
 
 	queryID := getQueryId(ctx)

quesma/eql/query_translator.go

@@ -4,6 +4,7 @@ package eql
 
 import (
 	"context"
+	"fmt"
 	"quesma/clickhouse"
 	"quesma/elasticsearch"
 	"quesma/eql/transform"
@@ -73,31 +74,30 @@ func (cw *ClickhouseEQLQueryTranslator) MakeSearchResponse(queries []*model.Quer
 	}
 }
 
-func (cw *ClickhouseEQLQueryTranslator) ParseQuery(body types.JSON) (*model.ExecutionPlan, bool, error) {
+func (cw *ClickhouseEQLQueryTranslator) ParseQuery(body types.JSON) (*model.ExecutionPlan, error) {
 	simpleQuery, queryInfo, highlighter, err := cw.parseQuery(body)
 
 	if err != nil {
 		logger.ErrorWithCtx(cw.Ctx).Msgf("error parsing query: %v", err)
-		return nil, false, err
+		return nil, err
 	}
 
 	var query *model.Query
 	var queries []*model.Query
-	canParse := false
 
 	if simpleQuery.CanParse {
-		canParse = true
+
 		query = query_util.BuildHitsQuery(cw.Ctx, cw.Table.Name, "*", &simpleQuery, queryInfo.I2)
 		queryType := typical_queries.NewHits(cw.Ctx, cw.Table, &highlighter, query.SelectCommand.OrderByFieldNames(), true, false, false, cw.Table.Name)
 		query.Type = &queryType
 		query.Highlighter = highlighter
 		query.SelectCommand.OrderBy = simpleQuery.OrderBy
 		queries = append(queries, query)
-		return &model.ExecutionPlan{Queries: queries}, canParse, nil
+		return &model.ExecutionPlan{Queries: queries}, nil
 
 	}
 
-	return nil, false, err
+	return nil, fmt.Errorf("could not parse query")
 }
 
 func (cw *ClickhouseEQLQueryTranslator) parseQuery(queryAsMap types.JSON) (query model.SimpleQuery, searchQueryInfo model.SearchQueryInfo, highlighter model.Highlighter, err error) {

quesma/model/query.go

@@ -4,6 +4,7 @@ package model
 
 import (
 	"context"
+	"time"
 )
 
 const (
@@ -80,7 +81,14 @@ type QueryRowsTransfomer interface {
 	Transform(ctx context.Context, rows []QueryResultRow) []QueryResultRow
 }
 
+const MainExecutionPlan = "main"
+const AlternativeExecutionPlan = "alternative"
+
 type ExecutionPlan struct {
+	Name string
+
+	IndexPattern string
+
 	Queries []*Query
 
 	QueryRowsTransformers []QueryRowsTransfomer
@@ -89,6 +97,7 @@ type ExecutionPlan struct {
 
 	// add more fields here
 	// JSON renderers
+	StartTime time.Time
 }
 
 func NewQueryExecutionHints() *QueryOptimizeHints {

quesma/queryparser/aggregation_parser_test.go

@@ -807,9 +807,8 @@ func Test2AggregationParserExternalTestcases(t *testing.T) {
 			body, parseErr := types.ParseJSON(test.QueryRequestJson)
 			assert.NoError(t, parseErr)
 
-			plan, canParse, err := cw.ParseQuery(body)
+			plan, err := cw.ParseQuery(body)
 			queries := plan.Queries
-			assert.True(t, canParse)
 			assert.NoError(t, err)
 			assert.Len(t, test.ExpectedResults, len(queries))
 			sortAggregations(queries) // to make test runs deterministic

quesma/queryparser/query_parser.go

@@ -34,16 +34,16 @@ func NewEmptyHighlighter() model.Highlighter {
 	}
 }
 
-func (cw *ClickhouseQueryTranslator) ParseQuery(body types.JSON) (*model.ExecutionPlan, bool, error) {
+func (cw *ClickhouseQueryTranslator) ParseQuery(body types.JSON) (*model.ExecutionPlan, error) {
 	if cw.SchemaRegistry == nil {
 		logger.Error().Msg("Schema registry is not set")
-		return &model.ExecutionPlan{}, false, errors.New("schema registry is not set")
+		return &model.ExecutionPlan{}, errors.New("schema registry is not set")
 	}
 
 	simpleQuery, queryInfo, highlighter, err := cw.parseQueryInternal(body)
 	if err != nil || !simpleQuery.CanParse {
 		logger.WarnWithCtx(cw.Ctx).Msgf("error parsing query: %v", err)
-		return &model.ExecutionPlan{}, false, err
+		return &model.ExecutionPlan{}, err
 	}
 
 	var queries []*model.Query
@@ -86,7 +86,7 @@ func (cw *ClickhouseQueryTranslator) ParseQuery(body types.JSON) (*model.Executi
 		QueryRowsTransformers: queryResultTransformers,
 	}
 
-	return plan, true, err
+	return plan, err
 }
 
 func (cw *ClickhouseQueryTranslator) buildListQueryIfNeeded(

quesma/queryparser/query_parser_test.go

@@ -73,9 +73,8 @@ func TestQueryParserStringAttrConfig(t *testing.T) {
 		t.Run(fmt.Sprintf("%s(%d)", tt.Name, i), func(t *testing.T) {
 			body, parseErr := types.ParseJSON(tt.QueryJson)
 			assert.NoError(t, parseErr)
-			plan, canParse, errQuery := cw.ParseQuery(body)
+			plan, errQuery := cw.ParseQuery(body)
 			queries := plan.Queries
-			assert.True(t, canParse, "can parse")
 			assert.NoError(t, errQuery, "no ParseQuery error")
 			assert.True(t, len(queries) > 0, "len queries > 0")
 			var simpleListQuery *model.Query
@@ -139,10 +138,9 @@ func TestQueryParserNoFullTextFields(t *testing.T) {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
 			body, parseErr := types.ParseJSON(tt.QueryJson)
 			assert.NoError(t, parseErr)
-			plan, canParse, errQuery := cw.ParseQuery(body)
+			plan, errQuery := cw.ParseQuery(body)
 			queries := plan.Queries
 			assert.NoError(t, errQuery, "no error in ParseQuery")
-			assert.True(t, canParse, "can parse")
 			assert.True(t, len(queries) > 0, "len queries > 0")
 			whereClause := model.AsString(queries[0].SelectCommand.WhereClause)
 			assert.Contains(t, tt.WantedSql, whereClause, "contains wanted sql")
@@ -207,10 +205,9 @@ func TestQueryParserNoAttrsConfig(t *testing.T) {
 		t.Run(tt.Name, func(t *testing.T) {
 			body, parseErr := types.ParseJSON(tt.QueryJson)
 			assert.NoError(t, parseErr)
-			plan, canParse, errQuery := cw.ParseQuery(body)
+			plan, errQuery := cw.ParseQuery(body)
 			queries := plan.Queries
 			assert.NoError(t, errQuery, "no error in ParseQuery")
-			assert.True(t, canParse, "can parse")
 			assert.True(t, len(queries) > 0, "len queries > 0")
 			whereClause := model.AsString(queries[0].SelectCommand.WhereClause)
 			assert.Contains(t, tt.WantedSql, whereClause)

quesma/quesma/query_translator.go

@@ -21,7 +21,7 @@ import (
 // 2. ClickhouseEQLQueryTranslator (implements only a subset of methods)
 
 type IQueryTranslator interface {
-	ParseQuery(body types.JSON) (*model.ExecutionPlan, bool, error)
+	ParseQuery(body types.JSON) (*model.ExecutionPlan, error)
 	MakeSearchResponse(queries []*model.Query, ResultSets [][]model.QueryResultRow) *model.SearchResp
 }