Fix queries not showing in UI (#1374)

I'll write a short fix + some test for it. Some long user story below:

I haven't used `common_table` a lot yet, even though recently I found
the feature very useful. I didn't have any problems in a few of my
encounters with it, but now I misconfigured something a bit and what our
debug interface shows in the scenario, seems not enough for me.

Simplest for me will be I think to provide a user story:
1. I personally wanted to test/add a test case for `DateTime64(9)` field
in Clickhouse.
2. I started Quesma, set in config:
```
'*':
          useCommonTable: true
          target: [ my-clickhouse-data-source ]
```
3. Then what I've did in Clickhouse: (all 3 steps of course)
<img width="675" alt="Screenshot 2025-03-16 at 13 20 24"
src="https://github.com/user-attachments/assets/54d26478-6e82-4d64-a12b-2317257339d2"
/>

4. Then added data view to kibana for table `q` and I see no data. It's
probably fine, but anyway I think it'll be worth to spend a bit time
thinking how to make user experience more friendly and give the user
some hints in most frequent use cases. Or a message to contact us for
help.
<img width="1728" alt="Screenshot 2025-03-16 at 17 18 49"
src="https://github.com/user-attachments/assets/17c742da-b9b2-495f-8308-3a6a0227b6be"
/>
5. But what really convinced I need to tackle the issue is our Debug UI:
nothing, no traffic.
Even though there are requests flowing and (empty, but still) responses
from Quesma:

<img width="615" alt="Screenshot 2025-03-16 at 17 21 32"
src="https://github.com/user-attachments/assets/1d0fca92-6ec3-40a9-b85b-8047b3dbfeec"
/>
<img width="1728" alt="Screenshot 2025-03-16 at 17 21 26"
src="https://github.com/user-attachments/assets/b618b4a2-59e1-4b6b-89ee-b00914063e39"
/>


After - queries show up in the UI:
![Screenshot 2025-03-21 at 13 35
33](https://github.com/user-attachments/assets/3ef9bf24-a069-4ced-bd95-3b48729780a3)

---------

Co-authored-by: trzysiek <[email protected]>

Author: trzysiek

platform/frontend_connectors/search.go

@@ -454,39 +454,62 @@ func (q *QueryRunner) executePlan(ctx context.Context, plan *model.ExecutionPlan
 	}
 }
 
-func (q *QueryRunner) handleSearchCommon(ctx context.Context, indexPattern string, body types.JSON, optAsync *AsyncQuery) ([]byte, error) {
+func (q *QueryRunner) handleSearchCommon(ctx context.Context, indexPattern string, body types.JSON, optAsync *AsyncQuery) (resp []byte, err error) {
+	var (
+		id                  = "FAKE_ID"
+		path                = ""
+		startTime           = time.Now()
+		resolvedIndexes     []string
+		queryTranslator     IQueryTranslator
+		plan                *model.ExecutionPlan
+		clickhouseConnector *quesma_api.ConnectorDecisionClickhouse
+		table               *clickhouse.Table // TODO we should use schema here only
+		tables              clickhouse.TableMap
+		currentSchema       schema.Schema
+	)
+
+	if val := ctx.Value(tracing.RequestIdCtxKey); val != nil {
+		if str, ok := val.(string); ok {
+			id = str
+		}
+	}
+	if val := ctx.Value(tracing.RequestPath); val != nil {
+		if str, ok := val.(string); ok {
+			path = str
+		}
+	}
 
 	decision := q.tableResolver.Resolve(quesma_api.QueryPipeline, indexPattern)
 
 	if decision.Err != nil {
-
-		var resp []byte
 		if optAsync != nil {
 			resp, _ = elastic_query_dsl.EmptyAsyncSearchResponse(optAsync.asyncId, false, 200)
 		} else {
 			resp = elastic_query_dsl.EmptySearchResponse(ctx)
 		}
-		return resp, decision.Err
+		err = decision.Err
+		goto logErrorAndReturn
 	}
 
 	if decision.IsEmpty {
 		if optAsync != nil {
-			return elastic_query_dsl.EmptyAsyncSearchResponse(optAsync.asyncId, false, 200)
+			resp, err = elastic_query_dsl.EmptyAsyncSearchResponse(optAsync.asyncId, false, 200)
 		} else {
-			return elastic_query_dsl.EmptySearchResponse(ctx), nil
+			resp = elastic_query_dsl.EmptySearchResponse(ctx)
 		}
+		goto logErrorAndReturn
 	}
 
 	if decision.IsClosed {
-		return nil, quesma_errors.ErrIndexNotExists() // TODO
+		err = quesma_errors.ErrIndexNotExists() // TODO
+		goto logErrorAndReturn
 	}
 
 	if len(decision.UseConnectors) == 0 {
-		return nil, end_user_errors.ErrSearchCondition.New(fmt.Errorf("no connectors to use"))
+		err = end_user_errors.ErrSearchCondition.New(fmt.Errorf("no connectors to use"))
+		goto logErrorAndReturn
 	}
 
-	var clickhouseConnector *quesma_api.ConnectorDecisionClickhouse
-
 	for _, connector := range decision.UseConnectors {
 		switch c := connector.(type) {
 
@@ -499,53 +522,43 @@ func (q *QueryRunner) handleSearchCommon(ctx context.Context, indexPattern strin
 			// This code lives only to postpone bigger refactor of `handleSearchCommon` which also supports async and A/B testing
 
 		default:
-			return nil, fmt.Errorf("unknown connector type: %T", c)
+			err = fmt.Errorf("unknown connector type: %T", c)
+			goto logErrorAndReturn
 		}
 	}
 
 	if clickhouseConnector == nil {
 		logger.Warn().Msgf("multi-search payload contains Elasticsearch-targetted query")
-		return nil, fmt.Errorf("quesma-processed _msearch payload contains Elasticsearch-targetted query")
+		err = fmt.Errorf("quesma-processed _msearch payload contains Elasticsearch-targetted query")
+		goto logErrorAndReturn
 	}
 
-	var responseBody []byte
-
-	startTime := time.Now()
-	id := "FAKE_ID"
-	if val := ctx.Value(tracing.RequestIdCtxKey); val != nil {
-		id = val.(string)
-	}
-	path := ""
-	if value := ctx.Value(tracing.RequestPath); value != nil {
-		if str, ok := value.(string); ok {
-			path = str
-		}
-	}
-
-	tables, err := q.logManager.GetTableDefinitions()
+	startTime = time.Now()
+	tables, err = q.logManager.GetTableDefinitions()
 	if err != nil {
-		return nil, err
+		goto logErrorAndReturn
 	}
 
-	var table *clickhouse.Table // TODO we should use schema here only
-	var currentSchema schema.Schema
-	resolvedIndexes := clickhouseConnector.ClickhouseIndexes
+	resolvedIndexes = clickhouseConnector.ClickhouseIndexes
 
 	if !clickhouseConnector.IsCommonTable {
 		if len(resolvedIndexes) < 1 {
-			return []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load [%s] schema", resolvedIndexes)).Details("Table: [%v]", resolvedIndexes)
+			resp, err = []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load [%s] schema", resolvedIndexes)).Details("Table: [%v]", resolvedIndexes)
+			goto logErrorAndReturn
 		}
 		indexName := resolvedIndexes[0] // we got exactly one table here because of the check above
 		resolvedTableName := q.cfg.IndexConfig[indexName].TableName(indexName)
 
 		resolvedSchema, ok := q.schemaRegistry.FindSchema(schema.IndexName(indexName))
 		if !ok {
-			return []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load %s schema", resolvedTableName)).Details("Table: %s", resolvedTableName)
+			resp, err = []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load %s schema", resolvedTableName)).Details("Table: %s", resolvedTableName)
+			goto logErrorAndReturn
 		}
 
 		table, _ = tables.Load(resolvedTableName)
 		if table == nil {
-			return []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load %s table", resolvedTableName)).Details("Table: %s", resolvedTableName)
+			resp, err = []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load %s table", resolvedTableName)).Details("Table: %s", resolvedTableName)
+			goto logErrorAndReturn
 		}
 
 		currentSchema = resolvedSchema
@@ -567,15 +580,17 @@ func (q *QueryRunner) handleSearchCommon(ctx context.Context, indexPattern strin
 
 		if len(resolvedIndexes) == 0 {
 			if optAsync != nil {
-				return elastic_query_dsl.EmptyAsyncSearchResponse(optAsync.asyncId, false, 200)
+				resp, err = elastic_query_dsl.EmptyAsyncSearchResponse(optAsync.asyncId, false, 200)
 			} else {
-				return elastic_query_dsl.EmptySearchResponse(ctx), nil
+				resp, err = elastic_query_dsl.EmptySearchResponse(ctx), nil
 			}
+			goto logErrorAndReturn
 		}
 
 		commonTable, ok := tables.Load(common_table.TableName)
 		if !ok {
-			return []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load %s table", common_table.TableName)).Details("Table: %s", common_table.TableName)
+			resp, err = []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load %s table", common_table.TableName)).Details("Table: %s", common_table.TableName)
+			goto logErrorAndReturn
 		}
 
 		// Let's build a  union of schemas
@@ -591,7 +606,8 @@ func (q *QueryRunner) handleSearchCommon(ctx context.Context, indexPattern strin
 		for _, idx := range resolvedIndexes {
 			scm, ok := schemas[schema.IndexName(idx)]
 			if !ok {
-				return []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load %s schema", idx)).Details("Table: %s", idx)
+				resp, err = []byte{}, end_user_errors.ErrNoSuchTable.New(fmt.Errorf("can't load %s schema", idx)).Details("Table: %s", idx)
+				goto logErrorAndReturn
 			}
 
 			for fieldName := range scm.Fields {
@@ -604,9 +620,9 @@ func (q *QueryRunner) handleSearchCommon(ctx context.Context, indexPattern strin
 		table = commonTable
 	}
 
-	queryTranslator := NewQueryTranslator(ctx, currentSchema, table, q.logManager, q.DateMathRenderer, resolvedIndexes)
+	queryTranslator = NewQueryTranslator(ctx, currentSchema, table, q.logManager, q.DateMathRenderer, resolvedIndexes)
 
-	plan, err := queryTranslator.ParseQuery(body)
+	plan, err = queryTranslator.ParseQuery(body)
 
 	if err != nil {
 		logger.ErrorWithCtx(ctx).Msgf("parsing error: %v", err)
@@ -617,15 +633,14 @@ func (q *QueryRunner) handleSearchCommon(ctx context.Context, indexPattern strin
 			queriesBody[i].Query = []byte(query.SelectCommand.String())
 			queriesBodyConcat += query.SelectCommand.String() + "\n"
 		}
-		responseBody = []byte(fmt.Sprintf("Invalid Queries: %v, err: %v", queriesBody, err))
+		resp = []byte(fmt.Sprintf("Invalid Queries: %v, err: %v", queriesBody, err))
+		err = errors.New(string(resp))
 		logger.ErrorWithCtxAndReason(ctx, "Quesma generated invalid SQL query").Msg(queriesBodyConcat)
-		bodyAsBytes, _ := body.Bytes()
-		pushSecondaryInfo(q.debugInfoCollector, id, "", path, bodyAsBytes, queriesBody, responseBody, startTime)
-		return responseBody, errors.New(string(responseBody))
+		goto logErrorAndReturn
 	}
 	err = q.transformQueries(plan)
 	if err != nil {
-		return responseBody, err
+		goto logErrorAndReturn
 	}
 	plan.IndexPattern = indexPattern
 	plan.StartTime = startTime
@@ -636,6 +651,10 @@ func (q *QueryRunner) handleSearchCommon(ctx context.Context, indexPattern strin
 	}
 	return q.executePlan(ctx, plan, queryTranslator, table, body, optAsync, nil, true)
 
+logErrorAndReturn:
+	bodyAsBytes, _ := body.Bytes()
+	pushSecondaryInfo(q.debugInfoCollector, id, "", path, bodyAsBytes, []diag.TranslatedSQLQuery{}, resp, startTime)
+	return resp, err
 }
 
 func (q *QueryRunner) storeAsyncSearch(qmc diag.DebugInfoCollector, id, asyncId string,