[ecommerce] Fix failing panels when filtering an Array(String) (#1366)

I think code is clearer now, and of course some bugs also seem fixed.

Before: 3 panels started failing when I choose any of the array filters,
as I discovered and showed you on last learn.
<img width="602" alt="Screenshot 2025-03-13 at 11 58 52"
src="https://github.com/user-attachments/assets/2d2ba2a4-e118-4e45-b2fd-30c97ba32c1f"
/>.
<img width="1611" alt="Screenshot 2025-03-13 at 11 58 57"
src="https://github.com/user-attachments/assets/3481506d-ba31-4507-b8ce-766ead9b8f41"
/>

After: they all load again. 
<img width="1623" alt="Screenshot 2025-03-13 at 11 59 40"
src="https://github.com/user-attachments/assets/ec5ebf13-3d65-420b-8545-d514d87296be"
/>

---------

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

Author: trzysiek

platform/clickhouse/type_adapter.go

@@ -40,7 +40,8 @@ func (c SchemaTypeAdapter) Convert(s string) (schema.QuesmaType, bool) {
 		return schema.QuesmaTypeDate, true
 	case "Point":
 		return schema.QuesmaTypePoint, true
-	case "Map(String, Nullable(String))", "Map(String, String)", "Map(LowCardinality(String), Nullable(String))", "Map(LowCardinality(String), String)":
+	case "Map(String, Nullable(String))", "Map(String, String)", "Map(LowCardinality(String), Nullable(String))", "Map(LowCardinality(String), String)",
+		"Map(String, Int)", "Map(LowCardinality(String), Int)", "Map(String, Nullable(Int))", "Map(LowCardinality(String), Nullable(Int))":
 		return schema.QuesmaTypeMap, true
 	default:
 		return schema.QuesmaTypeUnknown, false

platform/frontend_connectors/schema_transformer.go

@@ -1070,47 +1070,68 @@ func (s *SchemaCheckPass) applyMatchOperator(indexSchema schema.Schema, query *m
 
 	visitor.OverrideVisitInfix = func(b *model.BaseExprVisitor, e model.InfixExpr) interface{} {
 		var (
-			lhs              = e.Left
-			rhs, okRight     = e.Right.(model.LiteralExpr)
-			col, okLeft      = e.Left.(model.ColumnRef)
-			lhsIsArrayAccess bool
+			lhs                                       = e.Left
+			rhs, okRight                              = e.Right.(model.LiteralExpr)
+			lhsCol                                    model.ColumnRef
+			okLeft, lhsIsArrayAccess, colIsAttributes bool
 		)
 
-		if !okLeft {
-			if arrayAccess, ok := lhs.(model.ArrayAccess); ok {
-				lhsIsArrayAccess = true
-				okLeft = true
-				col = arrayAccess.ColumnRef
+		// try to extract column from lhs
+		switch lhsT := lhs.(type) {
+		case model.ColumnRef:
+			lhsCol = lhsT
+			okLeft = true
+		case model.FunctionExpr:
+			if len(lhsT.Args) >= 1 {
+				if col, ok := lhsT.Args[0].(model.ColumnRef); ok {
+					lhsCol = col
+					okLeft = true
+				} else if f2, ok := lhsT.Args[0].(model.FunctionExpr); ok && len(f2.Args) == 1 {
+					if col, ok := f2.Args[0].(model.ColumnRef); ok {
+						lhsCol = col
+						okLeft = true
+					}
+				}
 			}
+		case model.ArrayAccess:
+			lhsIsArrayAccess = true
+			okLeft = true
+			lhsCol = lhsT.ColumnRef
+		default:
+			return model.NewInfixExpr(e.Left.Accept(b).(model.Expr), e.Op, e.Right.Accept(b).(model.Expr))
 		}
 
-		if okLeft && okRight && e.Op == model.MatchOperator {
-			if _, ok := rhs.Value.(string); !ok {
+		rhsValue, ok := rhs.Value.(string)
+		if !ok {
+			if e.Op == model.MatchOperator {
 				// only strings can be ILIKEd, everything else is a simple =
-				return model.NewInfixExpr(lhs, "=", rhs.Clone())
+				return model.NewInfixExpr(e.Left.Accept(b).(model.Expr), "=", e.Right.Accept(b).(model.Expr))
+			} else {
+				return model.NewInfixExpr(e.Left.Accept(b).(model.Expr), e.Op, e.Right.Accept(b).(model.Expr))
 			}
+		}
 
-			var colIsAttributes bool
-			field, found := indexSchema.ResolveFieldByInternalName(col.ColumnName)
+		if okLeft && okRight && e.Op == model.MatchOperator {
+			field, found := indexSchema.ResolveFieldByInternalName(lhsCol.ColumnName)
 			if !found {
 				// indexSchema won't find attributes columns, that's why this check
-				if clickhouse.IsColumnAttributes(col.ColumnName) {
+				if clickhouse.IsColumnAttributes(lhsCol.ColumnName) {
 					colIsAttributes = true
 				} else {
-					logger.Error().Msgf("Field %s not found in schema for table %s, should never happen here", col.ColumnName, query.TableName)
+					logger.Error().Msgf("Field %s not found in schema for table %s, should never happen here", lhsCol.ColumnName, query.TableName)
+					goto experimental
 				}
 			}
 
-			rhsValue := rhs.Value.(string) // checked above
 			rhsValue = strings.TrimPrefix(rhsValue, "'")
 			rhsValue = strings.TrimSuffix(rhsValue, "'")
 
 			ilike := func() model.Expr {
-				return model.NewInfixExpr(lhs, "ILIKE", model.NewLiteralWithEscapeType(rhsValue, rhs.EscapeType))
+				return model.NewInfixExpr(lhs, "ILIKE", rhs.Clone())
 			}
 			equal := func() model.Expr {
 				rhsValue = strings.Trim(rhsValue, "%")
-				return model.NewInfixExpr(lhs, "=", model.NewLiteral(rhsValue))
+				return model.NewInfixExpr(lhs, "=", rhs.Clone())
 			}
 
 			// handling case when e.Left is an array access
@@ -1132,6 +1153,7 @@ func (s *SchemaCheckPass) applyMatchOperator(indexSchema schema.Schema, query *m
 			}
 		}
 
+	experimental:
 		if s.isFieldMapSyntaxEnabled(query) {
 			// special case where left side is arrayElement,
 			// arrayElement comes from applyFieldEncoding function
@@ -1173,7 +1195,7 @@ func (s *SchemaCheckPass) applyMatchOperator(indexSchema schema.Schema, query *m
 		}
 
 		if e.Op == model.MatchOperator {
-			logger.Error().Msgf("Match operator is not supported for column %v", col)
+			logger.Error().Msgf("Match operator is not supported for column %v (expr: %v)", lhsCol, e)
 		}
 		return model.NewInfixExpr(e.Left.Accept(b).(model.Expr), e.Op, e.Right.Accept(b).(model.Expr))
 	}

platform/frontend_connectors/schema_transformer_test.go

@@ -1202,7 +1202,7 @@ func Test_applyMatchOperator(t *testing.T) {
 					WhereClause: model.NewInfixExpr(
 						model.NewColumnRef("count"),
 						"=",
-						model.NewLiteral("123"),
+						model.NewLiteral("'123'"),
 					),
 				},
 			},
@@ -1457,6 +1457,7 @@ func Test_checkAggOverUnsupportedType(t *testing.T) {
 
 func Test_mapKeys(t *testing.T) {
 
+	// logger.InitSimpleLoggerForTestsWarnLevel()
 	indexConfig := map[string]config.IndexConfiguration{
 		"test":  {EnableFieldMapSyntax: true},
 		"test2": {EnableFieldMapSyntax: false},
@@ -1509,8 +1510,8 @@ func Test_mapKeys(t *testing.T) {
 					Columns:    []model.Expr{model.NewColumnRef("foo")},
 					WhereClause: model.NewInfixExpr(
 						model.NewFunction("arrayElement", model.NewColumnRef("foo"), model.NewLiteral("'bar'")),
-						"iLIKE",
-						model.NewLiteral("'%baz%'"),
+						"ILIKE",
+						model.NewLiteral("'baz'"),
 					),
 				},
 			},
@@ -1526,7 +1527,7 @@ func Test_mapKeys(t *testing.T) {
 					WhereClause: model.NewInfixExpr(
 						model.NewColumnRef("sizes.bar"),
 						model.MatchOperator,
-						model.NewLiteral("1"),
+						model.NewLiteralWithEscapeType("1", model.FullyEscaped),
 					),
 				},
 			},
@@ -1537,8 +1538,8 @@ func Test_mapKeys(t *testing.T) {
 					Columns:    []model.Expr{model.NewColumnRef("foo")},
 					WhereClause: model.NewInfixExpr(
 						model.NewFunction("arrayElement", model.NewColumnRef("sizes"), model.NewLiteral("'bar'")),
-						"=",
-						model.NewLiteral("1"),
+						"ILIKE",
+						model.NewLiteralWithEscapeType("1", model.FullyEscaped),
 					),
 				},
 			},