fix: updating collector version

go.mod

@@ -10,7 +10,8 @@ require (
 	github.com/ClickHouse/clickhouse-go/v2 v2.30.0
 	github.com/DATA-DOG/go-sqlmock v1.5.2
 	github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd
-	github.com/SigNoz/signoz-otel-collector v0.111.16
+	github.com/SigNoz/signoz-otel-collector v0.111.39-beta.1
+	github.com/antlr4-go/antlr/v4 v4.13.1
 	github.com/antonmedv/expr v1.15.3
 	github.com/cespare/xxhash/v2 v2.3.0
 	github.com/coreos/go-oidc/v3 v3.11.0
@@ -89,10 +90,9 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.0 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 // indirect
 	github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 // indirect
-	github.com/ClickHouse/ch-go v0.61.5 // indirect
+	github.com/ClickHouse/ch-go v0.63.1 // indirect
 	github.com/alecthomas/units v0.0.0-20240927000941-0f3dac36c52b // indirect
 	github.com/andybalholm/brotli v1.1.1 // indirect
-	github.com/antlr4-go/antlr/v4 v4.13.1 // indirect
 	github.com/armon/go-metrics v0.4.1 // indirect
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
 	github.com/aws/aws-sdk-go v1.55.5 // indirect

go.sum

@@ -85,8 +85,8 @@ github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 h1:XHOnouVk1mx
 github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/ClickHouse/ch-go v0.61.5 h1:zwR8QbYI0tsMiEcze/uIMK+Tz1D3XZXLdNrlaOpeEI4=
-github.com/ClickHouse/ch-go v0.61.5/go.mod h1:s1LJW/F/LcFs5HJnuogFMta50kKDO0lf9zzfrbl0RQg=
+github.com/ClickHouse/ch-go v0.63.1 h1:s2JyZvWLTCSAGdtjMBBmAgQQHMco6pawLJMOXi0FODM=
+github.com/ClickHouse/ch-go v0.63.1/go.mod h1:I1kJJCL3WJcBMGe1m+HVK0+nREaG+JOYYBWjrDrF3R0=
 github.com/ClickHouse/clickhouse-go/v2 v2.30.0 h1:AG4D/hW39qa58+JHQIFOSnxyL46H6h2lrmGGk17dhFo=
 github.com/ClickHouse/clickhouse-go/v2 v2.30.0/go.mod h1:i9ZQAojcayW3RsdCb3YR+n+wC2h65eJsZCscZ1Z1wyo=
 github.com/Code-Hex/go-generics-cache v1.5.1 h1:6vhZGc5M7Y/YD8cIUcY8kcuQLB4cHR7U+0KMqAA0KcU=
@@ -100,8 +100,8 @@ github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd h1:Bk43AsDYe0fhkbj57eGXx8H3ZJ4zhmQXBnrW523ktj8=
 github.com/SigNoz/govaluate v0.0.0-20240203125216-988004ccc7fd/go.mod h1:nxRcH/OEdM8QxzH37xkGzomr1O0JpYBRS6pwjsWW6Pc=
-github.com/SigNoz/signoz-otel-collector v0.111.16 h1:535uKH5Oux+35EsI+L3C6pnAP/Ye0PTCbVizXoL+VqE=
-github.com/SigNoz/signoz-otel-collector v0.111.16/go.mod h1:HJ4m0LY1MPsuZmuRF7Ixb+bY8rxgRzI0VXzOedESsjg=
+github.com/SigNoz/signoz-otel-collector v0.111.39-beta.1 h1:ZpSNrOZBOH2iCJIPeER5X0mfxOe64yP3JRX7FzBNfwY=
+github.com/SigNoz/signoz-otel-collector v0.111.39-beta.1/go.mod h1:DCu/D+lqhsPNSGS4IMD+4gn7q06TGzOCKazSy+GURVc=
 github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
@@ -820,8 +820,8 @@ github.com/prometheus/prometheus v0.300.1/go.mod h1:gtTPY/XVyCdqqnjA3NzDMb0/nc5H
 github.com/puzpuzpuz/xsync/v3 v3.5.0 h1:i+cMcpEDY1BkNm7lPDkCtE4oElsYLn+EKF8kAu2vXT4=
 github.com/puzpuzpuz/xsync/v3 v3.5.0/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA=
 github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
-github.com/redis/go-redis/v9 v9.6.1 h1:HHDteefn6ZkTtY5fGUE8tj8uy85AHk6zP7CpzIAM0y4=
-github.com/redis/go-redis/v9 v9.6.1/go.mod h1:0C0c6ycQsdpVNQpxb1njEQIqkx5UcsM8FJCQLgE9+RA=
+github.com/redis/go-redis/v9 v9.6.3 h1:8Dr5ygF1QFXRxIH/m3Xg9MMG1rS8YCtAgosrsewT6i0=
+github.com/redis/go-redis/v9 v9.6.3/go.mod h1:0C0c6ycQsdpVNQpxb1njEQIqkx5UcsM8FJCQLgE9+RA=
 github.com/rhnvrm/simples3 v0.6.1/go.mod h1:Y+3vYm2V7Y4VijFoJHHTrja6OgPrJ2cBti8dPGkC3sA=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=

pkg/query-service/app/clickhouseReader/reader.go

@@ -406,9 +406,7 @@ func (r *ClickHouseReader) buildResourceSubQuery(tags []model.TagQueryParam, svc
 		&filterSet,
 		[]v3.AttributeKey{},
 		v3.AttributeKey{},
-		false,
-		false,
-	)
+		false)
 	if err != nil {
 		zap.L().Error("Error in processing sql query", zap.Error(err))
 		return "", err
@@ -3758,7 +3756,7 @@ func (r *ClickHouseReader) GetLatestReceivedMetric(
 
 	quotedMetricNames := []string{}
 	for _, m := range metricNames {
-		quotedMetricNames = append(quotedMetricNames, utils.ClickHouseFormattedValue(m, false))
+		quotedMetricNames = append(quotedMetricNames, utils.ClickHouseFormattedValue(m))
 	}
 	commaSeparatedMetricNames := strings.Join(quotedMetricNames, ", ")
 
@@ -4017,16 +4015,16 @@ func (r *ClickHouseReader) FetchRelatedValues(ctx context.Context, req *v3.Filte
 			}
 			switch v := item.Value.(type) {
 			case string:
-				fmtVal := utils.ClickHouseFormattedValue(v, false)
+				fmtVal := utils.ClickHouseFormattedValue(v)
 				addCondition(fmtVal)
 			case []string:
 				for _, val := range v {
-					fmtVal := utils.ClickHouseFormattedValue(val, false)
+					fmtVal := utils.ClickHouseFormattedValue(val)
 					addCondition(fmtVal)
 				}
 			case []interface{}:
 				for _, val := range v {
-					fmtVal := utils.ClickHouseFormattedValue(val, false)
+					fmtVal := utils.ClickHouseFormattedValue(val)
 					addCondition(fmtVal)
 				}
 			}
@@ -5123,7 +5121,7 @@ func (r *ClickHouseReader) ReadRuleStateHistoryByRuleID(
 			if op == v3.FilterOperatorContains || op == v3.FilterOperatorNotContains {
 				toFormat = fmt.Sprintf("%%%s%%", toFormat)
 			}
-			fmtVal := utils.ClickHouseFormattedValue(toFormat, false)
+			fmtVal := utils.ClickHouseFormattedValue(toFormat)
 			switch op {
 			case v3.FilterOperatorEqual:
 				conditions = append(conditions, fmt.Sprintf("JSONExtractString(labels, '%s') = %s", item.Key.Key, fmtVal))

pkg/query-service/app/integrations/messagingQueues/queues/sql.go

@@ -28,15 +28,15 @@ func generateOverviewSQL(start, end int64, item []v3.FilterItem) string {
 	for _, filter := range item {
 		switch filter.Key.Key {
 		case "service.name":
-			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "service_name", format.ClickHouseFormattedValue(filter.Value, false)))
+			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "service_name", format.ClickHouseFormattedValue(filter.Value)))
 		case "name":
-			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "span_name", format.ClickHouseFormattedValue(filter.Value, false)))
+			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "span_name", format.ClickHouseFormattedValue(filter.Value)))
 		case "destination":
-			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "destination", format.ClickHouseFormattedValue(filter.Value, false)))
+			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "destination", format.ClickHouseFormattedValue(filter.Value)))
 		case "queue":
-			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "messaging_system", format.ClickHouseFormattedValue(filter.Value, false)))
+			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "messaging_system", format.ClickHouseFormattedValue(filter.Value)))
 		case "kind_string":
-			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "kind_string", format.ClickHouseFormattedValue(filter.Value, false)))
+			whereClauses = append(whereClauses, fmt.Sprintf("%s IN (%s)", "kind_string", format.ClickHouseFormattedValue(filter.Value)))
 		}
 	}
 

pkg/query-service/app/logparsingpipeline/pipelineBuilder.go

@@ -131,9 +131,11 @@ func getOperators(ops []pipelinetypes.PipelineOperator) ([]pipelinetypes.Pipelin
 					)
 				}
 				operator.If = fmt.Sprintf(
-					`%s && %s matches "^\\s*{.*}\\s*$"`, parseFromNotNilCheck, operator.ParseFrom,
+					`%s && (
+						(typeOf(%s) == "string" && %s matches "^\\s*{.*}\\s*$" ) || 
+						typeOf(%s) == "map[string]any"
+					)`, parseFromNotNilCheck, operator.ParseFrom, operator.ParseFrom, operator.ParseFrom,
 				)
-
 			} else if operator.Type == "add" {
 				if strings.HasPrefix(operator.Value, "EXPR(") && strings.HasSuffix(operator.Value, ")") {
 					expression := strings.TrimSuffix(strings.TrimPrefix(operator.Value, "EXPR("), ")")

pkg/query-service/app/logparsingpipeline/pipelineBuilder_test.go

@@ -646,7 +646,7 @@ func TestMembershipOpInProcessorFieldExpressions(t *testing.T) {
 	require := require.New(t)
 
 	testLogs := []model.SignozLog{
-		makeTestSignozLog("test log", map[string]interface{}{
+		makeTestSignozLog("test log", map[string]any{
 			"http.method":    "GET",
 			"order.products": `{"ids": ["pid0", "pid1"]}`,
 		}),

pkg/query-service/app/logs/v3/json_filter.go

@@ -131,7 +131,7 @@ func GetPathIndexFilter(path string) string {
 	return ""
 }
 
-func GetJSONFilter(item v3.FilterItem, isEscaped bool) (string, error) {
+func GetJSONFilter(item v3.FilterItem) (string, error) {
 
 	dataType := item.Key.DataType
 	isArray := false
@@ -166,13 +166,13 @@ func GetJSONFilter(item v3.FilterItem, isEscaped bool) (string, error) {
 		case v3.FilterOperatorExists, v3.FilterOperatorNotExists:
 			filter = fmt.Sprintf(logsOp, key, GetPath(strings.Split(item.Key.Key, ".")[1:]))
 		case v3.FilterOperatorRegex, v3.FilterOperatorNotRegex, v3.FilterOperatorHas, v3.FilterOperatorNotHas:
-			fmtVal := utils.ClickHouseFormattedValue(value, isEscaped)
+			fmtVal := utils.ClickHouseFormattedValue(value)
 			filter = fmt.Sprintf(logsOp, key, fmtVal)
 		case v3.FilterOperatorContains, v3.FilterOperatorNotContains:
 			val := utils.QuoteEscapedString(fmt.Sprintf("%v", item.Value))
 			filter = fmt.Sprintf("%s %s '%%%s%%'", key, logsOp, val)
 		default:
-			fmtVal := utils.ClickHouseFormattedValue(value, isEscaped)
+			fmtVal := utils.ClickHouseFormattedValue(value)
 			filter = fmt.Sprintf("%s %s %s", key, logsOp, fmtVal)
 		}
 	} else {

pkg/query-service/app/logs/v3/json_filter_test.go

@@ -331,7 +331,7 @@ var testGetJSONFilterData = []struct {
 func TestGetJSONFilter(t *testing.T) {
 	for _, tt := range testGetJSONFilterData {
 		Convey("testGetJSONFilter", t, func() {
-			filter, err := GetJSONFilter(tt.FilterItem, false)
+			filter, err := GetJSONFilter(tt.FilterItem)
 			if tt.Error {
 				So(err, ShouldNotBeNil)
 			} else {

pkg/query-service/app/logs/v3/query_builder.go

@@ -168,7 +168,7 @@ func buildLogsTimeSeriesFilterQuery(fs *v3.FilterSet, groupBy []v3.AttributeKey,
 	if fs != nil && len(fs.Items) != 0 {
 		for _, item := range fs.Items {
 			if item.Key.IsJSON {
-				filter, err := GetJSONFilter(item, false)
+				filter, err := GetJSONFilter(item)
 				if err != nil {
 					return "", err
 				}
@@ -193,7 +193,7 @@ func buildLogsTimeSeriesFilterQuery(fs *v3.FilterSet, groupBy []v3.AttributeKey,
 					conditions = append(conditions, GetExistsNexistsFilter(op, item))
 				case v3.FilterOperatorRegex, v3.FilterOperatorNotRegex:
 					columnName := getClickhouseColumnName(item.Key)
-					fmtVal := utils.ClickHouseFormattedValue(value, false)
+					fmtVal := utils.ClickHouseFormattedValue(value)
 					conditions = append(conditions, fmt.Sprintf(logsOp, columnName, fmtVal))
 				case v3.FilterOperatorContains, v3.FilterOperatorNotContains:
 					columnName := getClickhouseColumnName(item.Key)
@@ -206,7 +206,7 @@ func buildLogsTimeSeriesFilterQuery(fs *v3.FilterSet, groupBy []v3.AttributeKey,
 					}
 				default:
 					columnName := getClickhouseColumnName(item.Key)
-					fmtVal := utils.ClickHouseFormattedValue(value, false)
+					fmtVal := utils.ClickHouseFormattedValue(value)
 
 					// for use lower for like and ilike
 					if op == v3.FilterOperatorLike || op == v3.FilterOperatorNotLike {
@@ -444,7 +444,7 @@ func Having(items []v3.Having) string {
 	// aggregate something and filter on that aggregate
 	var having []string
 	for _, item := range items {
-		having = append(having, fmt.Sprintf("value %s %s", item.Operator, utils.ClickHouseFormattedValue(item.Value, false)))
+		having = append(having, fmt.Sprintf("value %s %s", item.Operator, utils.ClickHouseFormattedValue(item.Value)))
 	}
 	return strings.Join(having, " AND ")
 }

pkg/query-service/app/logs/v4/json_filter.go

@@ -30,7 +30,7 @@ var jsonLogOperators = map[v3.FilterOperator]string{
 	v3.FilterOperatorNotHas:          "NOT has(%s, %s)",
 }
 
-func GetJSONFilter(item v3.FilterItem, isEscaped bool) (string, error) {
+func GetJSONFilter(item v3.FilterItem) (string, error) {
 
 	dataType := item.Key.DataType
 	isArray := false
@@ -65,13 +65,13 @@ func GetJSONFilter(item v3.FilterItem, isEscaped bool) (string, error) {
 		case v3.FilterOperatorExists, v3.FilterOperatorNotExists:
 			filter = fmt.Sprintf(logsOp, key, logsV3.GetPath(strings.Split(item.Key.Key, ".")[1:]))
 		case v3.FilterOperatorRegex, v3.FilterOperatorNotRegex, v3.FilterOperatorHas, v3.FilterOperatorNotHas:
-			fmtVal := utils.ClickHouseFormattedValue(value, isEscaped)
+			fmtVal := utils.ClickHouseFormattedValue(value)
 			filter = fmt.Sprintf(logsOp, key, fmtVal)
 		case v3.FilterOperatorContains, v3.FilterOperatorNotContains:
 			val := utils.QuoteEscapedString(fmt.Sprintf("%v", item.Value))
 			filter = fmt.Sprintf("%s %s '%%%s%%'", key, logsOp, val)
 		default:
-			fmtVal := utils.ClickHouseFormattedValue(value, isEscaped)
+			fmtVal := utils.ClickHouseFormattedValue(value)
 			filter = fmt.Sprintf("%s %s %s", key, logsOp, fmtVal)
 		}
 	} else {

pkg/query-service/app/logs/v4/json_filter_test.go

@@ -253,7 +253,7 @@ var testGetJSONFilterData = []struct {
 func TestGetJSONFilter(t *testing.T) {
 	for _, tt := range testGetJSONFilterData {
 		Convey("testGetJSONFilter", t, func() {
-			filter, err := GetJSONFilter(tt.FilterItem, false)
+			filter, err := GetJSONFilter(tt.FilterItem)
 			if tt.Error {
 				So(err, ShouldNotBeNil)
 			} else {

pkg/query-service/app/logs/v4/query_builder.go

@@ -113,7 +113,7 @@ func getExistsNexistsFilter(op v3.FilterOperator, item v3.FilterItem) string {
 	return fmt.Sprintf(logOperators[op], columnType, columnDataType, item.Key.Key)
 }
 
-func buildAttributeFilter(item v3.FilterItem, isEscaped bool) (string, error) {
+func buildAttributeFilter(item v3.FilterItem) (string, error) {
 	// check if the user is searching for value in all attributes
 	key := item.Key.Key
 	op := v3.FilterOperator(strings.ToLower(string(item.Operator)))
@@ -133,12 +133,12 @@ func buildAttributeFilter(item v3.FilterItem, isEscaped bool) (string, error) {
 		if (op != v3.FilterOperatorEqual && op != v3.FilterOperatorContains) || item.Key.DataType != v3.AttributeKeyDataTypeString {
 			return "", fmt.Errorf("only = operator and string data type is supported for __attrs")
 		}
-		val := utils.ClickHouseFormattedValue(item.Value, isEscaped)
+		val := utils.ClickHouseFormattedValue(item.Value)
 		return fmt.Sprintf("has(mapValues(attributes_string), %s)", val), nil
 	}
 
 	keyName := getClickhouseKey(item.Key)
-	fmtVal := utils.ClickHouseFormattedValue(value, isEscaped)
+	fmtVal := utils.ClickHouseFormattedValue(value)
 
 	if logsOp, ok := logOperators[op]; ok {
 		switch op {
@@ -148,16 +148,8 @@ func buildAttributeFilter(item v3.FilterItem, isEscaped bool) (string, error) {
 
 			return fmt.Sprintf(logsOp, keyName, fmtVal), nil
 		case v3.FilterOperatorContains, v3.FilterOperatorNotContains:
-			var val string
-			if !isEscaped {
-				val = utils.QuoteEscapedString(fmt.Sprintf("%s", item.Value))
-			} else {
-				val = fmt.Sprintf("%s", item.Value)
-			}
-
-			// we want to treat %, _ as literals for contains
-			val = utils.EscapedStringForContains(val, false)
-
+			// we also want to treat %, _ as literals for contains
+			val := utils.QuoteEscapedStringForContains(fmt.Sprintf("%s", item.Value), false)
 			// for body the contains is case insensitive
 			if keyName == BODY {
 				logsOp = strings.Replace(logsOp, "ILIKE", "LIKE", 1) // removing i from ilike and not ilike
@@ -167,12 +159,7 @@ func buildAttributeFilter(item v3.FilterItem, isEscaped bool) (string, error) {
 			}
 		case v3.FilterOperatorLike, v3.FilterOperatorNotLike:
 			// for body use lower for like and ilike
-			var val string
-			if isEscaped {
-				val = utils.QuoteEscapedString(fmt.Sprintf("%s", item.Value))
-			} else {
-				val = fmt.Sprintf("%s", item.Value)
-			}
+			val := utils.QuoteEscapedString(fmt.Sprintf("%s", item.Value))
 			if keyName == BODY {
 				logsOp = strings.Replace(logsOp, "ILIKE", "LIKE", 1) // removing i from ilike and not ilike
 				return fmt.Sprintf("lower(%s) %s lower('%s')", keyName, logsOp, val), nil
@@ -187,7 +174,7 @@ func buildAttributeFilter(item v3.FilterItem, isEscaped bool) (string, error) {
 	}
 }
 
-func buildLogsTimeSeriesFilterQuery(fs *v3.FilterSet, groupBy []v3.AttributeKey, aggregateAttribute v3.AttributeKey, isEscaped bool) (string, error) {
+func buildLogsTimeSeriesFilterQuery(fs *v3.FilterSet, groupBy []v3.AttributeKey, aggregateAttribute v3.AttributeKey) (string, error) {
 	var conditions []string
 
 	if fs == nil || len(fs.Items) == 0 {
@@ -202,7 +189,7 @@ func buildLogsTimeSeriesFilterQuery(fs *v3.FilterSet, groupBy []v3.AttributeKey,
 
 		// if the filter is json filter
 		if item.Key.IsJSON {
-			filter, err := GetJSONFilter(item, isEscaped)
+			filter, err := GetJSONFilter(item)
 			if err != nil {
 				return "", err
 			}
@@ -211,7 +198,7 @@ func buildLogsTimeSeriesFilterQuery(fs *v3.FilterSet, groupBy []v3.AttributeKey,
 		}
 
 		// generate the filter
-		filter, err := buildAttributeFilter(item, isEscaped)
+		filter, err := buildAttributeFilter(item)
 		if err != nil {
 			return "", err
 		}
@@ -355,7 +342,7 @@ func generateAggregateClause(aggOp v3.AggregateOperator,
 	}
 }
 
-func buildLogsQuery(panelType v3.PanelType, start, end, step int64, mq *v3.BuilderQuery, graphLimitQtype string, isEscaped bool) (string, error) {
+func buildLogsQuery(panelType v3.PanelType, start, end, step int64, mq *v3.BuilderQuery, graphLimitQtype string) (string, error) {
 	// timerange will be sent in epoch millisecond
 	logsStart := utils.GetEpochNanoSecs(start)
 	logsEnd := utils.GetEpochNanoSecs(end)
@@ -368,7 +355,7 @@ func buildLogsQuery(panelType v3.PanelType, start, end, step int64, mq *v3.Build
 	timeFilter := fmt.Sprintf("(timestamp >= %d AND timestamp <= %d) AND (ts_bucket_start >= %d AND ts_bucket_start <= %d)", logsStart, logsEnd, bucketStart, bucketEnd)
 
 	// build the where clause for main table
-	filterSubQuery, err := buildLogsTimeSeriesFilterQuery(mq.Filters, mq.GroupBy, mq.AggregateAttribute, isEscaped)
+	filterSubQuery, err := buildLogsTimeSeriesFilterQuery(mq.Filters, mq.GroupBy, mq.AggregateAttribute)
 	if err != nil {
 		return "", err
 	}
@@ -377,7 +364,7 @@ func buildLogsQuery(panelType v3.PanelType, start, end, step int64, mq *v3.Build
 	}
 
 	// build the where clause for resource table
-	resourceSubQuery, err := resource.BuildResourceSubQuery(DB_NAME, DISTRIBUTED_LOGS_V2_RESOURCE, bucketStart, bucketEnd, mq.Filters, mq.GroupBy, mq.AggregateAttribute, false, isEscaped)
+	resourceSubQuery, err := resource.BuildResourceSubQuery(DB_NAME, DISTRIBUTED_LOGS_V2_RESOURCE, bucketStart, bucketEnd, mq.Filters, mq.GroupBy, mq.AggregateAttribute, false)
 	if err != nil {
 		return "", err
 	}
@@ -459,14 +446,14 @@ func buildLogsQuery(panelType v3.PanelType, start, end, step int64, mq *v3.Build
 	return query, nil
 }
 
-func buildLogsLiveTailQuery(mq *v3.BuilderQuery, isEscaped bool) (string, error) {
-	filterSubQuery, err := buildLogsTimeSeriesFilterQuery(mq.Filters, mq.GroupBy, v3.AttributeKey{}, isEscaped)
+func buildLogsLiveTailQuery(mq *v3.BuilderQuery) (string, error) {
+	filterSubQuery, err := buildLogsTimeSeriesFilterQuery(mq.Filters, mq.GroupBy, v3.AttributeKey{})
 	if err != nil {
 		return "", err
 	}
 
 	// no values for bucket start and end
-	resourceSubQuery, err := resource.BuildResourceSubQuery(DB_NAME, DISTRIBUTED_LOGS_V2_RESOURCE, 0, 0, mq.Filters, mq.GroupBy, mq.AggregateAttribute, true, isEscaped)
+	resourceSubQuery, err := resource.BuildResourceSubQuery(DB_NAME, DISTRIBUTED_LOGS_V2_RESOURCE, 0, 0, mq.Filters, mq.GroupBy, mq.AggregateAttribute, true)
 	if err != nil {
 		return "", err
 	}
@@ -504,14 +491,14 @@ func PrepareLogsQuery(start, end int64, queryType v3.QueryType, panelType v3.Pan
 	// }
 
 	if options.IsLivetailQuery {
-		query, err := buildLogsLiveTailQuery(mq, options.ValuesEscaped)
+		query, err := buildLogsLiveTailQuery(mq)
 		if err != nil {
 			return "", err
 		}
 		return query, nil
 	} else if options.GraphLimitQtype == constants.FirstQueryGraphLimit {
 		// give me just the group_by names (no values)
-		query, err := buildLogsQuery(panelType, start, end, mq.StepInterval, mq, options.GraphLimitQtype, options.ValuesEscaped)
+		query, err := buildLogsQuery(panelType, start, end, mq.StepInterval, mq, options.GraphLimitQtype)
 		if err != nil {
 			return "", err
 		}
@@ -519,14 +506,14 @@ func PrepareLogsQuery(start, end int64, queryType v3.QueryType, panelType v3.Pan
 
 		return query, nil
 	} else if options.GraphLimitQtype == constants.SecondQueryGraphLimit {
-		query, err := buildLogsQuery(panelType, start, end, mq.StepInterval, mq, options.GraphLimitQtype, options.ValuesEscaped)
+		query, err := buildLogsQuery(panelType, start, end, mq.StepInterval, mq, options.GraphLimitQtype)
 		if err != nil {
 			return "", err
 		}
 		return query, nil
 	}
 
-	query, err := buildLogsQuery(panelType, start, end, mq.StepInterval, mq, options.GraphLimitQtype, options.ValuesEscaped)
+	query, err := buildLogsQuery(panelType, start, end, mq.StepInterval, mq, options.GraphLimitQtype)
 	if err != nil {
 		return "", err
 	}

pkg/query-service/app/logs/v4/query_builder_test.go

@@ -169,8 +169,7 @@ func Test_getExistsNexistsFilter(t *testing.T) {
 
 func Test_buildAttributeFilter(t *testing.T) {
 	type args struct {
-		item      v3.FilterItem
-		isEscaped bool
+		item v3.FilterItem
 	}
 	tests := []struct {
 		name    string
@@ -298,42 +297,10 @@ func Test_buildAttributeFilter(t *testing.T) {
 			},
 			want: "lower(body) LIKE lower('test')",
 		},
-		{
-			name: "build attribute filter contains- body escaped",
-			args: args{
-				item: v3.FilterItem{
-					Key: v3.AttributeKey{
-						Key:      "body",
-						DataType: v3.AttributeKeyDataTypeString,
-						IsColumn: true,
-					},
-					Operator: v3.FilterOperatorContains,
-					Value:    `{\\"hello\\": \\"wo_rld\\"}`,
-				},
-				isEscaped: true,
-			},
-			want: `lower(body) LIKE lower('%{\\"hello\\": \\"wo\_rld\\"}%')`,
-		},
-		{
-			name: "build attribute filter eq- body escaped",
-			args: args{
-				item: v3.FilterItem{
-					Key: v3.AttributeKey{
-						Key:      "body",
-						DataType: v3.AttributeKeyDataTypeString,
-						IsColumn: true,
-					},
-					Operator: v3.FilterOperatorEqual,
-					Value:    `{\\"hello\\": \\"wo_rld\\"}`,
-				},
-				isEscaped: true,
-			},
-			want: `body = '{\\"hello\\": \\"wo_rld\\"}'`,
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := buildAttributeFilter(tt.args.item, tt.args.isEscaped)
+			got, err := buildAttributeFilter(tt.args.item)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("buildAttributeFilter() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -350,7 +317,6 @@ func Test_buildLogsTimeSeriesFilterQuery(t *testing.T) {
 		fs                 *v3.FilterSet
 		groupBy            []v3.AttributeKey
 		aggregateAttribute v3.AttributeKey
-		isEscaped          bool
 	}
 	tests := []struct {
 		name    string
@@ -470,7 +436,7 @@ func Test_buildLogsTimeSeriesFilterQuery(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := buildLogsTimeSeriesFilterQuery(tt.args.fs, tt.args.groupBy, tt.args.aggregateAttribute, tt.args.isEscaped)
+			got, err := buildLogsTimeSeriesFilterQuery(tt.args.fs, tt.args.groupBy, tt.args.aggregateAttribute)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("buildLogsTimeSeriesFilterQuery() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -675,7 +641,6 @@ func Test_buildLogsQuery(t *testing.T) {
 		step            int64
 		mq              *v3.BuilderQuery
 		graphLimitQtype string
-		isEscaped       bool
 	}
 	tests := []struct {
 		name    string
@@ -820,7 +785,7 @@ func Test_buildLogsQuery(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := buildLogsQuery(tt.args.panelType, tt.args.start, tt.args.end, tt.args.step, tt.args.mq, tt.args.graphLimitQtype, tt.args.isEscaped)
+			got, err := buildLogsQuery(tt.args.panelType, tt.args.start, tt.args.end, tt.args.step, tt.args.mq, tt.args.graphLimitQtype)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("buildLogsQuery() error = %v, wantErr %v", err, tt.wantErr)
 				return

pkg/query-service/app/metrics/v3/query_builder.go

@@ -296,7 +296,7 @@ func orderByAttributeKeyTags(items []v3.OrderBy, tags []v3.AttributeKey) string
 func having(items []v3.Having) string {
 	var having []string
 	for _, item := range items {
-		having = append(having, fmt.Sprintf("%s %s %v", "value", item.Operator, utils.ClickHouseFormattedValue(item.Value, false)))
+		having = append(having, fmt.Sprintf("%s %s %v", "value", item.Operator, utils.ClickHouseFormattedValue(item.Value)))
 	}
 	return strings.Join(having, " AND ")
 }

pkg/query-service/app/metrics/v4/helpers/sub_query.go

@@ -282,7 +282,7 @@ func PrepareTimeseriesFilterQuery(start, end int64, mq *v3.BuilderQuery) (string
 			}
 			var fmtVal string
 			if op != v3.FilterOperatorExists && op != v3.FilterOperatorNotExists {
-				fmtVal = utils.ClickHouseFormattedValue(toFormat, false)
+				fmtVal = utils.ClickHouseFormattedValue(toFormat)
 			}
 			switch op {
 			case v3.FilterOperatorEqual:
@@ -364,7 +364,7 @@ func PrepareTimeseriesFilterQueryV3(start, end int64, mq *v3.BuilderQuery) (stri
 			if op == v3.FilterOperatorContains || op == v3.FilterOperatorNotContains {
 				toFormat = fmt.Sprintf("%%%s%%", toFormat)
 			}
-			fmtVal := utils.ClickHouseFormattedValue(toFormat, false)
+			fmtVal := utils.ClickHouseFormattedValue(toFormat)
 			switch op {
 			case v3.FilterOperatorEqual:
 				conditions = append(conditions, fmt.Sprintf("JSONExtractString(labels, '%s') = %s", item.Key.Key, fmtVal))

pkg/query-service/app/parser.go

@@ -889,7 +889,7 @@ func ParseQueryRangeParams(r *http.Request) (*v3.QueryRangeParamsV3, *model.ApiE
 		if queryRangeParams.CompositeQuery.QueryType == v3.QueryTypePromQL {
 			formattedVars[name] = metrics.PromFormattedValue(value)
 		} else if queryRangeParams.CompositeQuery.QueryType == v3.QueryTypeClickHouseSQL {
-			formattedVars[name] = utils.ClickHouseFormattedValue(value, queryRangeParams.ValuesEscaped)
+			formattedVars[name] = utils.ClickHouseFormattedValue(value)
 		}
 	}
 

pkg/query-service/app/querier/helper.go

@@ -45,7 +45,7 @@ func prepareLogsQuery(_ context.Context,
 			params.CompositeQuery.QueryType,
 			params.CompositeQuery.PanelType,
 			builderQuery,
-			v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit, ValuesEscaped: params.ValuesEscaped},
+			v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit},
 		)
 		if err != nil {
 			return query, err
@@ -56,7 +56,7 @@ func prepareLogsQuery(_ context.Context,
 			params.CompositeQuery.QueryType,
 			params.CompositeQuery.PanelType,
 			builderQuery,
-			v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit, ValuesEscaped: params.ValuesEscaped},
+			v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit},
 		)
 		if err != nil {
 			return query, err
@@ -71,7 +71,7 @@ func prepareLogsQuery(_ context.Context,
 		params.CompositeQuery.QueryType,
 		params.CompositeQuery.PanelType,
 		builderQuery,
-		v3.QBOptions{ValuesEscaped: params.ValuesEscaped},
+		v3.QBOptions{},
 	)
 	if err != nil {
 		return query, err
@@ -184,7 +184,7 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit, ValuesEscaped: params.ValuesEscaped},
+				v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit},
 			)
 			if err != nil {
 				ch <- channelResult{Err: err, Name: queryName, Query: limitQuery, Series: nil}
@@ -195,7 +195,7 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit, ValuesEscaped: params.ValuesEscaped},
+				v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit},
 			)
 			if err != nil {
 				ch <- channelResult{Err: err, Name: queryName, Query: limitQuery, Series: nil}
@@ -208,7 +208,7 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				v3.QBOptions{ValuesEscaped: params.ValuesEscaped},
+				v3.QBOptions{},
 			)
 			if err != nil {
 				ch <- channelResult{Err: err, Name: queryName, Query: query, Series: nil}

pkg/query-service/app/querier/v2/helper.go

@@ -44,7 +44,7 @@ func prepareLogsQuery(_ context.Context,
 			params.CompositeQuery.QueryType,
 			params.CompositeQuery.PanelType,
 			builderQuery,
-			v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit, ValuesEscaped: params.ValuesEscaped},
+			v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit},
 		)
 		if err != nil {
 			return query, err
@@ -55,7 +55,7 @@ func prepareLogsQuery(_ context.Context,
 			params.CompositeQuery.QueryType,
 			params.CompositeQuery.PanelType,
 			builderQuery,
-			v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit, ValuesEscaped: params.ValuesEscaped},
+			v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit},
 		)
 		if err != nil {
 			return query, err
@@ -70,7 +70,7 @@ func prepareLogsQuery(_ context.Context,
 		params.CompositeQuery.QueryType,
 		params.CompositeQuery.PanelType,
 		builderQuery,
-		v3.QBOptions{ValuesEscaped: params.ValuesEscaped},
+		v3.QBOptions{},
 	)
 	if err != nil {
 		return query, err
@@ -184,7 +184,7 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit, ValuesEscaped: params.ValuesEscaped},
+				v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit},
 			)
 			if err != nil {
 				ch <- channelResult{Err: err, Name: queryName, Query: limitQuery, Series: nil}
@@ -195,7 +195,7 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit, ValuesEscaped: params.ValuesEscaped},
+				v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit},
 			)
 			if err != nil {
 				ch <- channelResult{Err: err, Name: queryName, Query: limitQuery, Series: nil}
@@ -208,7 +208,7 @@ func (q *querier) runBuilderQuery(
 				end,
 				params.CompositeQuery.PanelType,
 				builderQuery,
-				v3.QBOptions{ValuesEscaped: params.ValuesEscaped},
+				v3.QBOptions{},
 			)
 			if err != nil {
 				ch <- channelResult{Err: err, Name: queryName, Query: query, Series: nil}

pkg/query-service/app/queryBuilder/query_builder.go

@@ -193,12 +193,12 @@ func (qb *QueryBuilder) PrepareQueries(params *v3.QueryRangeParamsV3) (map[strin
 					// for ts query with group by and limit form two queries
 					if compositeQuery.PanelType == v3.PanelTypeGraph && query.Limit > 0 && len(query.GroupBy) > 0 {
 						limitQuery, err := qb.options.BuildTraceQuery(start, end, compositeQuery.PanelType, query,
-							v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit, ValuesEscaped: params.ValuesEscaped})
+							v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit})
 						if err != nil {
 							return nil, err
 						}
 						placeholderQuery, err := qb.options.BuildTraceQuery(start, end, compositeQuery.PanelType,
-							query, v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit, ValuesEscaped: params.ValuesEscaped})
+							query, v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit})
 						if err != nil {
 							return nil, err
 						}
@@ -206,7 +206,7 @@ func (qb *QueryBuilder) PrepareQueries(params *v3.QueryRangeParamsV3) (map[strin
 						queries[queryName] = query
 					} else {
 						queryString, err := qb.options.BuildTraceQuery(start, end, compositeQuery.PanelType,
-							query, v3.QBOptions{GraphLimitQtype: "", ValuesEscaped: params.ValuesEscaped})
+							query, v3.QBOptions{GraphLimitQtype: ""})
 						if err != nil {
 							return nil, err
 						}
@@ -215,18 +215,18 @@ func (qb *QueryBuilder) PrepareQueries(params *v3.QueryRangeParamsV3) (map[strin
 				case v3.DataSourceLogs:
 					// for ts query with limit replace it as it is already formed
 					if compositeQuery.PanelType == v3.PanelTypeGraph && query.Limit > 0 && len(query.GroupBy) > 0 {
-						limitQuery, err := qb.options.BuildLogQuery(start, end, compositeQuery.QueryType, compositeQuery.PanelType, query, v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit, ValuesEscaped: params.ValuesEscaped})
+						limitQuery, err := qb.options.BuildLogQuery(start, end, compositeQuery.QueryType, compositeQuery.PanelType, query, v3.QBOptions{GraphLimitQtype: constants.FirstQueryGraphLimit})
 						if err != nil {
 							return nil, err
 						}
-						placeholderQuery, err := qb.options.BuildLogQuery(start, end, compositeQuery.QueryType, compositeQuery.PanelType, query, v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit, ValuesEscaped: params.ValuesEscaped})
+						placeholderQuery, err := qb.options.BuildLogQuery(start, end, compositeQuery.QueryType, compositeQuery.PanelType, query, v3.QBOptions{GraphLimitQtype: constants.SecondQueryGraphLimit})
 						if err != nil {
 							return nil, err
 						}
 						query := fmt.Sprintf(placeholderQuery, limitQuery)
 						queries[queryName] = query
 					} else {
-						queryString, err := qb.options.BuildLogQuery(start, end, compositeQuery.QueryType, compositeQuery.PanelType, query, v3.QBOptions{GraphLimitQtype: "", ValuesEscaped: params.ValuesEscaped})
+						queryString, err := qb.options.BuildLogQuery(start, end, compositeQuery.QueryType, compositeQuery.PanelType, query, v3.QBOptions{GraphLimitQtype: ""})
 						if err != nil {
 							return nil, err
 						}

pkg/query-service/app/resource/resource_query_builder.go

@@ -28,14 +28,14 @@ var resourceLogOperators = map[v3.FilterOperator]string{
 }
 
 // buildResourceFilter builds a clickhouse filter string for resource labels
-func buildResourceFilter(logsOp string, key string, op v3.FilterOperator, value interface{}, isEscaped bool) string {
+func buildResourceFilter(logsOp string, key string, op v3.FilterOperator, value interface{}) string {
 	// for all operators except contains and like
 	searchKey := fmt.Sprintf("simpleJSONExtractString(labels, '%s')", key)
 
 	// for contains and like it will be case insensitive
 	lowerSearchKey := fmt.Sprintf("simpleJSONExtractString(lower(labels), '%s')", key)
 
-	chFmtVal := utils.ClickHouseFormattedValue(value, isEscaped)
+	chFmtVal := utils.ClickHouseFormattedValue(value)
 
 	lowerValue := strings.ToLower(fmt.Sprintf("%s", value))
 
@@ -47,25 +47,14 @@ func buildResourceFilter(logsOp string, key string, op v3.FilterOperator, value
 	case v3.FilterOperatorRegex, v3.FilterOperatorNotRegex:
 		return fmt.Sprintf(logsOp, searchKey, chFmtVal)
 	case v3.FilterOperatorContains, v3.FilterOperatorNotContains:
-
-		var val string
-		if !isEscaped {
-			val = utils.QuoteEscapedString(lowerValue)
-		} else {
-			val = lowerValue
-		}
-
+		// this is required as clickhouseFormattedValue add's quotes to the string
 		// we also want to treat %, _ as literals for contains
-		val = utils.EscapedStringForContains(val, false)
-		return fmt.Sprintf("%s %s '%%%s%%'", lowerSearchKey, logsOp, val)
+		escapedStringValue := utils.QuoteEscapedStringForContains(lowerValue, false)
+		return fmt.Sprintf("%s %s '%%%s%%'", lowerSearchKey, logsOp, escapedStringValue)
 	case v3.FilterOperatorLike, v3.FilterOperatorNotLike:
-		var val string
-		if !isEscaped {
-			val = utils.QuoteEscapedString(lowerValue)
-		} else {
-			val = lowerValue
-		}
-		return fmt.Sprintf("%s %s '%s'", lowerSearchKey, logsOp, val)
+		// this is required as clickhouseFormattedValue add's quotes to the string
+		escapedStringValue := utils.QuoteEscapedString(lowerValue)
+		return fmt.Sprintf("%s %s '%s'", lowerSearchKey, logsOp, escapedStringValue)
 	default:
 		return fmt.Sprintf("%s %s %s", searchKey, logsOp, chFmtVal)
 	}
@@ -74,7 +63,7 @@ func buildResourceFilter(logsOp string, key string, op v3.FilterOperator, value
 // buildIndexFilterForInOperator builds a clickhouse filter string for in operator
 // example:= x in a,b,c = (labels like '%"x"%"a"%' or labels like '%"x":"b"%' or labels like '%"x"="c"%')
 // example:= x nin a,b,c = (labels nlike '%"x"%"a"%' AND labels nlike '%"x"="b"' AND labels nlike '%"x"="c"%')
-func buildIndexFilterForInOperator(key string, op v3.FilterOperator, value interface{}, isEscaped bool) string {
+func buildIndexFilterForInOperator(key string, op v3.FilterOperator, value interface{}) string {
 	conditions := []string{}
 	separator := " OR "
 	sqlOp := "like"
@@ -103,18 +92,8 @@ func buildIndexFilterForInOperator(key string, op v3.FilterOperator, value inter
 	// if there are no values to filter on, return an empty string
 	if len(values) > 0 {
 		for _, v := range values {
-
-			var val string
-			if !isEscaped {
-				val = utils.QuoteEscapedString(v)
-			} else {
-				val = v
-			}
-
-			// we also want to treat %, _ as literals for contains
-			val = utils.EscapedStringForContains(val, true)
-
-			conditions = append(conditions, fmt.Sprintf("labels %s '%%\"%s\":\"%s\"%%'", sqlOp, key, val))
+			value := utils.QuoteEscapedStringForContains(v, true)
+			conditions = append(conditions, fmt.Sprintf("labels %s '%%\"%s\":\"%s\"%%'", sqlOp, key, value))
 		}
 		return "(" + strings.Join(conditions, separator) + ")"
 	}
@@ -128,18 +107,10 @@ func buildIndexFilterForInOperator(key string, op v3.FilterOperator, value inter
 // for like/contains we will use lower index
 // we can use lower index for =, in etc but it's difficult to do it for !=, NIN etc
 // if as x != "ABC" we cannot predict something like "not lower(labels) like '%%x%%abc%%'". It has it be "not lower(labels) like '%%x%%ABC%%'"
-func buildResourceIndexFilter(key string, op v3.FilterOperator, value interface{}, isEscaped bool) string {
+func buildResourceIndexFilter(key string, op v3.FilterOperator, value interface{}) string {
 	// not using clickhouseFormattedValue as we don't wan't the quotes
 	strVal := fmt.Sprintf("%s", value)
-
-	var fmtValEscapedForContains string
-	if !isEscaped {
-		fmtValEscapedForContains = utils.QuoteEscapedString(strVal)
-	} else {
-		fmtValEscapedForContains = strVal
-	}
-
-	fmtValEscapedForContains = utils.EscapedStringForContains(fmtValEscapedForContains, true)
+	fmtValEscapedForContains := utils.QuoteEscapedStringForContains(strVal, true)
 	fmtValEscapedForContainsLower := strings.ToLower(fmtValEscapedForContains)
 	fmtValEscapedLower := strings.ToLower(utils.QuoteEscapedString(strVal))
 
@@ -161,7 +132,7 @@ func buildResourceIndexFilter(key string, op v3.FilterOperator, value interface{
 		// don't try to do anything for regex.
 		return ""
 	case v3.FilterOperatorIn, v3.FilterOperatorNotIn:
-		return buildIndexFilterForInOperator(key, op, value, isEscaped)
+		return buildIndexFilterForInOperator(key, op, value)
 	default:
 		return fmt.Sprintf("labels like '%%%s%%'", key)
 	}
@@ -169,7 +140,7 @@ func buildResourceIndexFilter(key string, op v3.FilterOperator, value interface{
 
 // buildResourceFiltersFromFilterItems builds a list of clickhouse filter strings for resource labels from a FilterSet.
 // It skips any filter items that are not resource attributes and checks that the operator is supported and the data type is correct.
-func buildResourceFiltersFromFilterItems(fs *v3.FilterSet, isEscaped bool) ([]string, error) {
+func buildResourceFiltersFromFilterItems(fs *v3.FilterSet) ([]string, error) {
 	var conditions []string
 	if fs == nil || len(fs.Items) == 0 {
 		return nil, nil
@@ -204,11 +175,11 @@ func buildResourceFiltersFromFilterItems(fs *v3.FilterSet, isEscaped bool) ([]st
 
 		if logsOp, ok := resourceLogOperators[op]; ok {
 			// the filter
-			if resourceFilter := buildResourceFilter(logsOp, keyName, op, value, isEscaped); resourceFilter != "" {
+			if resourceFilter := buildResourceFilter(logsOp, keyName, op, value); resourceFilter != "" {
 				conditions = append(conditions, resourceFilter)
 			}
 			// the additional filter for better usage of the index
-			if resourceIndexFilter := buildResourceIndexFilter(keyName, op, value, isEscaped); resourceIndexFilter != "" {
+			if resourceIndexFilter := buildResourceIndexFilter(keyName, op, value); resourceIndexFilter != "" {
 				conditions = append(conditions, resourceIndexFilter)
 			}
 		} else {
@@ -240,12 +211,12 @@ func buildResourceFiltersFromAggregateAttribute(aggregateAttribute v3.AttributeK
 	return ""
 }
 
-func BuildResourceSubQuery(dbName, tableName string, bucketStart, bucketEnd int64, fs *v3.FilterSet, groupBy []v3.AttributeKey, aggregateAttribute v3.AttributeKey, isLiveTail bool, isEscaped bool) (string, error) {
+func BuildResourceSubQuery(dbName, tableName string, bucketStart, bucketEnd int64, fs *v3.FilterSet, groupBy []v3.AttributeKey, aggregateAttribute v3.AttributeKey, isLiveTail bool) (string, error) {
 
 	// BUILD THE WHERE CLAUSE
 	var conditions []string
 	// only add the resource attributes to the filters here
-	rs, err := buildResourceFiltersFromFilterItems(fs, isEscaped)
+	rs, err := buildResourceFiltersFromFilterItems(fs)
 	if err != nil {
 		return "", err
 	}

pkg/query-service/app/resource/resource_query_builder_test.go

@@ -9,11 +9,10 @@ import (
 
 func Test_buildResourceFilter(t *testing.T) {
 	type args struct {
-		logsOp    string
-		key       string
-		op        v3.FilterOperator
-		value     interface{}
-		isEscaped bool
+		logsOp string
+		key    string
+		op     v3.FilterOperator
+		value  interface{}
 	}
 	tests := []struct {
 		name string
@@ -89,7 +88,7 @@ func Test_buildResourceFilter(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := buildResourceFilter(tt.args.logsOp, tt.args.key, tt.args.op, tt.args.value, tt.args.isEscaped); got != tt.want {
+			if got := buildResourceFilter(tt.args.logsOp, tt.args.key, tt.args.op, tt.args.value); got != tt.want {
 				t.Errorf("buildResourceFilter() = %v, want %v", got, tt.want)
 			}
 		})
@@ -98,10 +97,9 @@ func Test_buildResourceFilter(t *testing.T) {
 
 func Test_buildIndexFilterForInOperator(t *testing.T) {
 	type args struct {
-		key       string
-		op        v3.FilterOperator
-		value     interface{}
-		isEscaped bool
+		key   string
+		op    v3.FilterOperator
+		value interface{}
 	}
 	tests := []struct {
 		name string
@@ -144,20 +142,10 @@ func Test_buildIndexFilterForInOperator(t *testing.T) {
 			},
 			want: `(labels not like '%"service.name":"application\'\\\\"\_s"%')`,
 		},
-		{
-			name: "test nin string with escaped quotes",
-			args: args{
-				key:       "service.name",
-				op:        v3.FilterOperatorNotIn,
-				value:     `application\'"_s`,
-				isEscaped: true,
-			},
-			want: `(labels not like '%"service.name":"application\'\\\\"\_s"%')`,
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := buildIndexFilterForInOperator(tt.args.key, tt.args.op, tt.args.value, tt.args.isEscaped); got != tt.want {
+			if got := buildIndexFilterForInOperator(tt.args.key, tt.args.op, tt.args.value); got != tt.want {
 				t.Errorf("buildIndexFilterForInOperator() = %v, want %v", got, tt.want)
 			}
 		})
@@ -166,10 +154,9 @@ func Test_buildIndexFilterForInOperator(t *testing.T) {
 
 func Test_buildResourceIndexFilter(t *testing.T) {
 	type args struct {
-		key       string
-		op        v3.FilterOperator
-		value     interface{}
-		isEscaped bool
+		key   string
+		op    v3.FilterOperator
+		value interface{}
 	}
 	tests := []struct {
 		name string
@@ -248,20 +235,10 @@ func Test_buildResourceIndexFilter(t *testing.T) {
 			},
 			want: `labels like '%service.name%Application\\\\"%'`,
 		},
-		{
-			name: "test eq with escaped quotes",
-			args: args{
-				key:       "service.name",
-				op:        v3.FilterOperatorEqual,
-				value:     `App\\lication"`,
-				isEscaped: true,
-			},
-			want: `labels like '%service.name%App\\lication\\\\"%'`,
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := buildResourceIndexFilter(tt.args.key, tt.args.op, tt.args.value, tt.args.isEscaped); got != tt.want {
+			if got := buildResourceIndexFilter(tt.args.key, tt.args.op, tt.args.value); got != tt.want {
 				t.Errorf("buildResourceIndexFilter() = %v, want %v", got, tt.want)
 			}
 		})
@@ -270,8 +247,7 @@ func Test_buildResourceIndexFilter(t *testing.T) {
 
 func Test_buildResourceFiltersFromFilterItems(t *testing.T) {
 	type args struct {
-		fs        *v3.FilterSet
-		isEscaped bool
+		fs *v3.FilterSet
 	}
 	tests := []struct {
 		name    string
@@ -359,7 +335,7 @@ func Test_buildResourceFiltersFromFilterItems(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := buildResourceFiltersFromFilterItems(tt.args.fs, tt.args.isEscaped)
+			got, err := buildResourceFiltersFromFilterItems(tt.args.fs)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("buildResourceFiltersFromFilterItems() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -463,7 +439,6 @@ func Test_buildResourceSubQuery(t *testing.T) {
 		fs                 *v3.FilterSet
 		groupBy            []v3.AttributeKey
 		aggregateAttribute v3.AttributeKey
-		isEscaped          bool
 	}
 	tests := []struct {
 		name    string
@@ -522,7 +497,7 @@ func Test_buildResourceSubQuery(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := BuildResourceSubQuery("signoz_logs", "distributed_logs_v2_resource", tt.args.bucketStart, tt.args.bucketEnd, tt.args.fs, tt.args.groupBy, tt.args.aggregateAttribute, false, tt.args.isEscaped)
+			got, err := BuildResourceSubQuery("signoz_logs", "distributed_logs_v2_resource", tt.args.bucketStart, tt.args.bucketEnd, tt.args.fs, tt.args.groupBy, tt.args.aggregateAttribute, false)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("buildResourceSubQuery() error = %v, wantErr %v", err, tt.wantErr)
 				return

pkg/query-service/app/traces/v3/query_builder.go

@@ -162,7 +162,7 @@ func buildTracesFilterQuery(fs *v3.FilterSet) (string, error) {
 				}
 			}
 			if val != nil {
-				fmtVal = utils.ClickHouseFormattedValue(val, false)
+				fmtVal = utils.ClickHouseFormattedValue(val)
 			}
 			if operator, ok := tracesOperatorMappingV3[item.Operator]; ok {
 				switch item.Operator {
@@ -459,7 +459,7 @@ func Having(items []v3.Having) string {
 	// aggregate something and filter on that aggregate
 	var having []string
 	for _, item := range items {
-		having = append(having, fmt.Sprintf("value %s %s", item.Operator, utils.ClickHouseFormattedValue(item.Value, false)))
+		having = append(having, fmt.Sprintf("value %s %s", item.Operator, utils.ClickHouseFormattedValue(item.Value)))
 	}
 	return strings.Join(having, " AND ")
 }

pkg/query-service/app/traces/v4/query_builder.go

@@ -87,7 +87,7 @@ func existsSubQueryForFixedColumn(key v3.AttributeKey, op v3.FilterOperator) (st
 	}
 }
 
-func buildTracesFilterQuery(fs *v3.FilterSet, isEscaped bool) (string, error) {
+func buildTracesFilterQuery(fs *v3.FilterSet) (string, error) {
 	var conditions []string
 
 	if fs != nil && len(fs.Items) != 0 {
@@ -111,21 +111,13 @@ func buildTracesFilterQuery(fs *v3.FilterSet, isEscaped bool) (string, error) {
 				}
 			}
 			if val != nil {
-				fmtVal = utils.ClickHouseFormattedValue(val, isEscaped)
+				fmtVal = utils.ClickHouseFormattedValue(val)
 			}
 			if operator, ok := tracesOperatorMappingV3[item.Operator]; ok {
 				switch item.Operator {
 				case v3.FilterOperatorContains, v3.FilterOperatorNotContains:
 					// we also want to treat %, _ as literals for contains
-					var val string
-					if !isEscaped {
-						val = utils.QuoteEscapedString(fmt.Sprintf("%s", item.Value))
-					} else {
-						val = fmt.Sprintf("%s", item.Value)
-					}
-
-					// we want to treat %, _ as literals for contains
-					val = utils.EscapedStringForContains(val, false)
+					val := utils.QuoteEscapedStringForContains(fmt.Sprintf("%s", item.Value), false)
 					conditions = append(conditions, fmt.Sprintf("%s %s '%%%s%%'", columnName, operator, val))
 				case v3.FilterOperatorRegex, v3.FilterOperatorNotRegex:
 					conditions = append(conditions, fmt.Sprintf(operator, columnName, fmtVal))
@@ -156,7 +148,7 @@ func buildTracesFilterQuery(fs *v3.FilterSet, isEscaped bool) (string, error) {
 	return queryString, nil
 }
 
-func handleEmptyValuesInGroupBy(groupBy []v3.AttributeKey, isEscaped bool) (string, error) {
+func handleEmptyValuesInGroupBy(groupBy []v3.AttributeKey) (string, error) {
 	// TODO(nitya): in future when we support user based mat column handle them
 	// skipping now as we don't support creating them
 	filterItems := []v3.FilterItem{}
@@ -175,7 +167,7 @@ func handleEmptyValuesInGroupBy(groupBy []v3.AttributeKey, isEscaped bool) (stri
 			Operator: "AND",
 			Items:    filterItems,
 		}
-		return buildTracesFilterQuery(&filterSet, isEscaped)
+		return buildTracesFilterQuery(&filterSet)
 	}
 	return "", nil
 }
@@ -256,7 +248,7 @@ func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, panelType v3.
 
 	timeFilter := fmt.Sprintf("(timestamp >= '%d' AND timestamp <= '%d') AND (ts_bucket_start >= %d AND ts_bucket_start <= %d)", tracesStart, tracesEnd, bucketStart, bucketEnd)
 
-	filterSubQuery, err := buildTracesFilterQuery(mq.Filters, options.ValuesEscaped)
+	filterSubQuery, err := buildTracesFilterQuery(mq.Filters)
 	if err != nil {
 		return "", err
 	}
@@ -264,7 +256,7 @@ func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, panelType v3.
 		filterSubQuery = " AND " + filterSubQuery
 	}
 
-	emptyValuesInGroupByFilter, err := handleEmptyValuesInGroupBy(mq.GroupBy, options.ValuesEscaped)
+	emptyValuesInGroupByFilter, err := handleEmptyValuesInGroupBy(mq.GroupBy)
 	if err != nil {
 		return "", err
 	}
@@ -272,7 +264,7 @@ func buildTracesQuery(start, end, step int64, mq *v3.BuilderQuery, panelType v3.
 		filterSubQuery = filterSubQuery + " AND " + emptyValuesInGroupByFilter
 	}
 
-	resourceSubQuery, err := resource.BuildResourceSubQuery("signoz_traces", "distributed_traces_v3_resource", bucketStart, bucketEnd, mq.Filters, mq.GroupBy, mq.AggregateAttribute, false, options.ValuesEscaped)
+	resourceSubQuery, err := resource.BuildResourceSubQuery("signoz_traces", "distributed_traces_v3_resource", bucketStart, bucketEnd, mq.Filters, mq.GroupBy, mq.AggregateAttribute, false)
 	if err != nil {
 		return "", err
 	}

pkg/query-service/app/traces/v4/query_builder_test.go

@@ -193,8 +193,7 @@ func Test_getSelectLabels(t *testing.T) {
 
 func Test_buildTracesFilterQuery(t *testing.T) {
 	type args struct {
-		fs        *v3.FilterSet
-		isEscaped bool
+		fs *v3.FilterSet
 	}
 	tests := []struct {
 		name    string
@@ -272,32 +271,10 @@ func Test_buildTracesFilterQuery(t *testing.T) {
 			},
 			want: "mapContains(attributes_string, 'host') AND mapContains(attributes_number, 'duration') AND NOT mapContains(attributes_bool, 'isDone') AND NOT mapContains(attributes_string, 'host1') AND `attribute_string_path` = '' AND http_url = '' AND `attribute_string_http$$route` = ''",
 		},
-		{
-			name: "Test with isEscaped contains",
-			args: args{
-				fs: &v3.FilterSet{Operator: "AND", Items: []v3.FilterItem{
-					{Key: v3.AttributeKey{Key: "name", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag}, Value: `hello\name_`, Operator: v3.FilterOperatorContains},
-				}},
-				isEscaped: true,
-			},
-			want:    `name ILIKE '%hello\name\_%'`,
-			wantErr: false,
-		},
-		{
-			name: "Test with isEscaped eq",
-			args: args{
-				fs: &v3.FilterSet{Operator: "AND", Items: []v3.FilterItem{
-					{Key: v3.AttributeKey{Key: "name", DataType: v3.AttributeKeyDataTypeString, Type: v3.AttributeKeyTypeTag}, Value: `hello\name_`, Operator: v3.FilterOperatorEqual},
-				}},
-				isEscaped: true,
-			},
-			want:    `name = 'hello\name_'`,
-			wantErr: false,
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := buildTracesFilterQuery(tt.args.fs, tt.args.isEscaped)
+			got, err := buildTracesFilterQuery(tt.args.fs)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("buildTracesFilterQuery() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -338,7 +315,7 @@ func Test_handleEmptyValuesInGroupBy(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := handleEmptyValuesInGroupBy(tt.args.groupBy, false)
+			got, err := handleEmptyValuesInGroupBy(tt.args.groupBy)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("handleEmptyValuesInGroupBy() error = %v, wantErr %v", err, tt.wantErr)
 				return

pkg/query-service/model/v3/v3.go

@@ -420,7 +420,6 @@ type FilterAttributeValueResponse struct {
 }
 
 type QueryRangeParamsV3 struct {
-	ValuesEscaped  bool                   `json:"valuesEscaped"`
 	Start          int64                  `json:"start"`
 	End            int64                  `json:"end"`
 	Step           int64                  `json:"step"` // step is in seconds; used for prometheus queries
@@ -1476,5 +1475,4 @@ type URLShareableOptions struct {
 type QBOptions struct {
 	GraphLimitQtype string
 	IsLivetailQuery bool
-	ValuesEscaped   bool
 }

pkg/query-service/utils/filter_conditions.go

@@ -28,7 +28,7 @@ func BuildFilterConditions(fs *v3.FilterSet, skipKey string) ([]string, error) {
 		if op == v3.FilterOperatorContains || op == v3.FilterOperatorNotContains {
 			toFormat = fmt.Sprintf("%%%s%%", toFormat)
 		}
-		fmtVal := ClickHouseFormattedValue(toFormat, false)
+		fmtVal := ClickHouseFormattedValue(toFormat)
 
 		// Determine if the key is a JSON key or a normal column
 		isJSONKey := false

pkg/query-service/utils/format.go

@@ -159,7 +159,10 @@ func QuoteEscapedString(str string) string {
 	return str
 }
 
-func EscapedStringForContains(str string, isIndex bool) string {
+func QuoteEscapedStringForContains(str string, isIndex bool) string {
+	// https: //clickhouse.com/docs/en/sql-reference/functions/string-search-functions#like
+	str = QuoteEscapedString(str)
+
 	// we are adding this because if a string contains quote `"` it will be stored as \" in clickhouse
 	// to query that using like our query should be \\\\"
 	if isIndex {
@@ -174,7 +177,7 @@ func EscapedStringForContains(str string, isIndex bool) string {
 }
 
 // ClickHouseFormattedValue formats the value to be used in clickhouse query
-func ClickHouseFormattedValue(v interface{}, isEscaped bool) string {
+func ClickHouseFormattedValue(v interface{}) string {
 	// if it's pointer convert it to a value
 	v = getPointerValue(v)
 
@@ -184,11 +187,7 @@ func ClickHouseFormattedValue(v interface{}, isEscaped bool) string {
 	case float32, float64:
 		return fmt.Sprintf("%f", x)
 	case string:
-		if !isEscaped {
-			return fmt.Sprintf("'%s'", QuoteEscapedString(x))
-		} else {
-			return fmt.Sprintf("'%s'", x)
-		}
+		return fmt.Sprintf("'%s'", QuoteEscapedString(x))
 	case bool:
 		return fmt.Sprintf("%v", x)
 
@@ -200,11 +199,7 @@ func ClickHouseFormattedValue(v interface{}, isEscaped bool) string {
 		case string:
 			str := "["
 			for idx, sVal := range x {
-				if !isEscaped {
-					str += fmt.Sprintf("'%s'", QuoteEscapedString(sVal.(string)))
-				} else {
-					str += fmt.Sprintf("'%s'", sVal.(string))
-				}
+				str += fmt.Sprintf("'%s'", QuoteEscapedString(sVal.(string)))
 				if idx != len(x)-1 {
 					str += ","
 				}
@@ -223,11 +218,7 @@ func ClickHouseFormattedValue(v interface{}, isEscaped bool) string {
 		}
 		str := "["
 		for idx, sVal := range x {
-			if !isEscaped {
-				str += fmt.Sprintf("'%s'", QuoteEscapedString(sVal))
-			} else {
-				str += fmt.Sprintf("'%s'", sVal)
-			}
+			str += fmt.Sprintf("'%s'", QuoteEscapedString(sVal))
 			if idx != len(x)-1 {
 				str += ","
 			}
@@ -243,13 +234,13 @@ func ClickHouseFormattedValue(v interface{}, isEscaped bool) string {
 func ClickHouseFormattedMetricNames(v interface{}) string {
 	if name, ok := v.(string); ok {
 		if newName, ok := metrics.MetricsUnderTransition[name]; ok {
-			return ClickHouseFormattedValue([]interface{}{name, newName}, false)
+			return ClickHouseFormattedValue([]interface{}{name, newName})
 		} else {
-			return ClickHouseFormattedValue([]interface{}{name}, false)
+			return ClickHouseFormattedValue([]interface{}{name})
 		}
 	}
 
-	return ClickHouseFormattedValue(v, false)
+	return ClickHouseFormattedValue(v)
 }
 
 func AddBackTickToFormatTag(str string) string {

pkg/query-service/utils/format_test.go

@@ -317,10 +317,9 @@ var oneString = "1"
 var trueBool = true
 
 var testClickHouseFormattedValueData = []struct {
-	name      string
-	value     interface{}
-	want      interface{}
-	isEscaped bool
+	name  string
+	value interface{}
+	want  interface{}
 }{
 	{
 		name:  "int",
@@ -395,21 +394,12 @@ var testClickHouseFormattedValueData = []struct {
 		},
 		want: "['test\\'1','test\\'2']",
 	},
-	{
-		name: "[]interface{} with string with single quote escaped",
-		value: []interface{}{
-			`test\\'1`,
-			`test\\'2`,
-		},
-		isEscaped: true,
-		want:      `['test\\'1','test\\'2']`,
-	},
 }
 
 func TestClickHouseFormattedValue(t *testing.T) {
 	for _, tt := range testClickHouseFormattedValueData {
 		t.Run(tt.name, func(t *testing.T) {
-			got := ClickHouseFormattedValue(tt.value, tt.isEscaped)
+			got := ClickHouseFormattedValue(tt.value)
 			if !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("ClickHouseFormattedValue() = %v, want %v", got, tt.want)
 			}

pkg/telemetrytraces/condition_builder.go

@@ -0,0 +1,352 @@
+package telemetrytraces
+
+import (
+	"context"
+	"fmt"
+
+	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/huandu/go-sqlbuilder"
+)
+
+var (
+	indexV3Columns = map[string]*schema.Column{
+		"ts_bucket_start":      {Name: "ts_bucket_start", Type: schema.ColumnTypeUInt64},
+		"resource_fingerprint": {Name: "resource_fingerprint", Type: schema.ColumnTypeString},
+
+		// intrinsic columns
+		"timestamp":          {Name: "timestamp", Type: schema.DateTime64ColumnType{Precision: 9, Timezone: "UTC"}},
+		"trace_id":           {Name: "trace_id", Type: schema.FixedStringColumnType{Length: 32}},
+		"span_id":            {Name: "span_id", Type: schema.ColumnTypeString},
+		"trace_state":        {Name: "trace_state", Type: schema.ColumnTypeString},
+		"parent_span_id":     {Name: "parent_span_id", Type: schema.ColumnTypeString},
+		"flags":              {Name: "flags", Type: schema.ColumnTypeUInt32},
+		"name":               {Name: "name", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"kind":               {Name: "kind", Type: schema.ColumnTypeInt8},
+		"kind_string":        {Name: "kind_string", Type: schema.ColumnTypeString},
+		"duration_nano":      {Name: "duration_nano", Type: schema.ColumnTypeUInt64},
+		"status_code":        {Name: "status_code", Type: schema.ColumnTypeInt16},
+		"status_message":     {Name: "status_message", Type: schema.ColumnTypeString},
+		"status_code_string": {Name: "status_code_string", Type: schema.ColumnTypeString},
+
+		// attributes columns
+		"attributes_string": {Name: "attributes_string", Type: schema.MapColumnType{
+			KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+			ValueType: schema.ColumnTypeString,
+		}},
+		"attributes_number": {Name: "attributes_number", Type: schema.MapColumnType{
+			KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+			ValueType: schema.ColumnTypeFloat64,
+		}},
+		"attributes_bool": {Name: "attributes_bool", Type: schema.MapColumnType{
+			KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+			ValueType: schema.ColumnTypeBool,
+		}},
+		"resources_string": {Name: "resources_string", Type: schema.MapColumnType{
+			KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+			ValueType: schema.ColumnTypeString,
+		}},
+
+		"events": {Name: "events", Type: schema.ArrayColumnType{
+			ElementType: schema.ColumnTypeString,
+		}},
+		"links": {Name: "links", Type: schema.ColumnTypeString},
+		// derived columns
+		"response_status_code": {Name: "response_status_code", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"external_http_url":    {Name: "external_http_url", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"http_url":             {Name: "http_url", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"external_http_method": {Name: "external_http_method", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"http_method":          {Name: "http_method", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"http_host":            {Name: "http_host", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"db_name":              {Name: "db_name", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"db_operation":         {Name: "db_operation", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"has_error":            {Name: "has_error", Type: schema.ColumnTypeBool},
+		"is_remote":            {Name: "is_remote", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		// materialized columns
+		"resource_string_service$$name":         {Name: "resource_string_service$$name", Type: schema.ColumnTypeString},
+		"attribute_string_http$$route":          {Name: "attribute_string_http$$route", Type: schema.ColumnTypeString},
+		"attribute_string_messaging$$system":    {Name: "attribute_string_messaging$$system", Type: schema.ColumnTypeString},
+		"attribute_string_messaging$$operation": {Name: "attribute_string_messaging$$operation", Type: schema.ColumnTypeString},
+		"attribute_string_db$$system":           {Name: "attribute_string_db$$system", Type: schema.ColumnTypeString},
+		"attribute_string_rpc$$system":          {Name: "attribute_string_rpc$$system", Type: schema.ColumnTypeString},
+		"attribute_string_rpc$$service":         {Name: "attribute_string_rpc$$service", Type: schema.ColumnTypeString},
+		"attribute_string_rpc$$method":          {Name: "attribute_string_rpc$$method", Type: schema.ColumnTypeString},
+		"attribute_string_peer$$service":        {Name: "attribute_string_peer$$service", Type: schema.ColumnTypeString},
+
+		// deprecated intrinsic columns
+		"traceID":          {Name: "traceID", Type: schema.FixedStringColumnType{Length: 32}},
+		"spanID":           {Name: "spanID", Type: schema.ColumnTypeString},
+		"parentSpanID":     {Name: "parentSpanID", Type: schema.ColumnTypeString},
+		"spanKind":         {Name: "spanKind", Type: schema.ColumnTypeString},
+		"durationNano":     {Name: "durationNano", Type: schema.ColumnTypeUInt64},
+		"statusCode":       {Name: "statusCode", Type: schema.ColumnTypeInt16},
+		"statusMessage":    {Name: "statusMessage", Type: schema.ColumnTypeString},
+		"statusCodeString": {Name: "statusCodeString", Type: schema.ColumnTypeString},
+
+		// deprecated derived columns
+		"references":         {Name: "references", Type: schema.ColumnTypeString},
+		"responseStatusCode": {Name: "responseStatusCode", Type: schema.ColumnTypeString},
+		"externalHttpUrl":    {Name: "externalHttpUrl", Type: schema.ColumnTypeString},
+		"httpUrl":            {Name: "httpUrl", Type: schema.ColumnTypeString},
+		"externalHttpMethod": {Name: "externalHttpMethod", Type: schema.ColumnTypeString},
+		"httpMethod":         {Name: "httpMethod", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"httpHost":           {Name: "httpHost", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"dbName":             {Name: "dbName", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"dbOperation":        {Name: "dbOperation", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"hasError":           {Name: "hasError", Type: schema.ColumnTypeBool},
+		"isRemote":           {Name: "isRemote", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"serviceName":        {Name: "serviceName", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"httpRoute":          {Name: "httpRoute", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"msgSystem":          {Name: "msgSystem", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"msgOperation":       {Name: "msgOperation", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"dbSystem":           {Name: "dbSystem", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"rpcSystem":          {Name: "rpcSystem", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"rpcService":         {Name: "rpcService", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"rpcMethod":          {Name: "rpcMethod", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+		"peerService":        {Name: "peerService", Type: schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString}},
+
+		// materialized exists columns
+		"resource_string_service$$name_exists":         {Name: "resource_string_service$$name_exists", Type: schema.ColumnTypeBool},
+		"attribute_string_http$$route_exists":          {Name: "attribute_string_http$$route_exists", Type: schema.ColumnTypeBool},
+		"attribute_string_messaging$$system_exists":    {Name: "attribute_string_messaging$$system_exists", Type: schema.ColumnTypeBool},
+		"attribute_string_messaging$$operation_exists": {Name: "attribute_string_messaging$$operation_exists", Type: schema.ColumnTypeBool},
+		"attribute_string_db$$system_exists":           {Name: "attribute_string_db$$system_exists", Type: schema.ColumnTypeBool},
+		"attribute_string_rpc$$system_exists":          {Name: "attribute_string_rpc$$system_exists", Type: schema.ColumnTypeBool},
+		"attribute_string_rpc$$service_exists":         {Name: "attribute_string_rpc$$service_exists", Type: schema.ColumnTypeBool},
+		"attribute_string_rpc$$method_exists":          {Name: "attribute_string_rpc$$method_exists", Type: schema.ColumnTypeBool},
+		"attribute_string_peer$$service_exists":        {Name: "attribute_string_peer$$service_exists", Type: schema.ColumnTypeBool},
+	}
+)
+
+// interface check
+var _ qbtypes.ConditionBuilder = &conditionBuilder{}
+
+type conditionBuilder struct {
+}
+
+func NewConditionBuilder() qbtypes.ConditionBuilder {
+	return &conditionBuilder{}
+}
+
+func (c *conditionBuilder) GetColumn(ctx context.Context, key *telemetrytypes.TelemetryFieldKey) (*schema.Column, error) {
+
+	switch key.FieldContext {
+	case telemetrytypes.FieldContextResource:
+		return indexV3Columns["resources_string"], nil
+	case telemetrytypes.FieldContextScope:
+		// we don't have scope data stored in the spans yet
+		return nil, qbtypes.ErrColumnNotFound
+	case telemetrytypes.FieldContextAttribute:
+		switch key.FieldDataType {
+		case telemetrytypes.FieldDataTypeString:
+			return indexV3Columns["attributes_string"], nil
+		case telemetrytypes.FieldDataTypeInt64, telemetrytypes.FieldDataTypeFloat64, telemetrytypes.FieldDataTypeNumber:
+			return indexV3Columns["attributes_number"], nil
+		case telemetrytypes.FieldDataTypeBool:
+			return indexV3Columns["attributes_bool"], nil
+		}
+	case telemetrytypes.FieldContextSpan:
+		col, ok := indexV3Columns[key.Name]
+		if !ok {
+			return nil, qbtypes.ErrColumnNotFound
+		}
+		return col, nil
+	}
+
+	return nil, qbtypes.ErrColumnNotFound
+}
+
+func (c *conditionBuilder) GetTableFieldName(ctx context.Context, key *telemetrytypes.TelemetryFieldKey) (string, error) {
+	column, err := c.GetColumn(ctx, key)
+	if err != nil {
+		return "", err
+	}
+
+	switch column.Type {
+	case schema.ColumnTypeString,
+		schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+		schema.ColumnTypeUInt64,
+		schema.ColumnTypeUInt32,
+		schema.ColumnTypeInt8,
+		schema.ColumnTypeInt16,
+		schema.ColumnTypeBool,
+		schema.DateTime64ColumnType{Precision: 9, Timezone: "UTC"},
+		schema.FixedStringColumnType{Length: 32}:
+		return column.Name, nil
+	case schema.MapColumnType{
+		KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+		ValueType: schema.ColumnTypeString,
+	}:
+		// a key could have been materialized, if so return the materialized column name
+		if key.Materialized {
+			return telemetrytypes.FieldKeyToMaterializedColumnName(key), nil
+		}
+		return fmt.Sprintf("%s['%s']", column.Name, key.Name), nil
+	case schema.MapColumnType{
+		KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+		ValueType: schema.ColumnTypeFloat64,
+	}:
+		// a key could have been materialized, if so return the materialized column name
+		if key.Materialized {
+			return telemetrytypes.FieldKeyToMaterializedColumnName(key), nil
+		}
+		return fmt.Sprintf("%s['%s']", column.Name, key.Name), nil
+	case schema.MapColumnType{
+		KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+		ValueType: schema.ColumnTypeBool,
+	}:
+		// a key could have been materialized, if so return the materialized column name
+		if key.Materialized {
+			return telemetrytypes.FieldKeyToMaterializedColumnName(key), nil
+		}
+		return fmt.Sprintf("%s['%s']", column.Name, key.Name), nil
+	}
+	// should not reach here
+	return column.Name, nil
+}
+
+func (c *conditionBuilder) GetCondition(
+	ctx context.Context,
+	key *telemetrytypes.TelemetryFieldKey,
+	operator qbtypes.FilterOperator,
+	value any,
+	sb *sqlbuilder.SelectBuilder,
+) (string, error) {
+	column, err := c.GetColumn(ctx, key)
+	if err != nil {
+		return "", err
+	}
+
+	tblFieldName, err := c.GetTableFieldName(ctx, key)
+	if err != nil {
+		return "", err
+	}
+
+	tblFieldName, value = telemetrytypes.DataTypeCollisionHandledFieldName(key, value, tblFieldName)
+
+	// regular operators
+	switch operator {
+	// regular operators
+	case qbtypes.FilterOperatorEqual:
+		return sb.E(tblFieldName, value), nil
+	case qbtypes.FilterOperatorNotEqual:
+		return sb.NE(tblFieldName, value), nil
+	case qbtypes.FilterOperatorGreaterThan:
+		return sb.G(tblFieldName, value), nil
+	case qbtypes.FilterOperatorGreaterThanOrEq:
+		return sb.GE(tblFieldName, value), nil
+	case qbtypes.FilterOperatorLessThan:
+		return sb.LT(tblFieldName, value), nil
+	case qbtypes.FilterOperatorLessThanOrEq:
+		return sb.LE(tblFieldName, value), nil
+
+	// like and not like
+	case qbtypes.FilterOperatorLike:
+		return sb.Like(tblFieldName, value), nil
+	case qbtypes.FilterOperatorNotLike:
+		return sb.NotLike(tblFieldName, value), nil
+	case qbtypes.FilterOperatorILike:
+		return sb.ILike(tblFieldName, value), nil
+	case qbtypes.FilterOperatorNotILike:
+		return sb.NotILike(tblFieldName, value), nil
+
+	case qbtypes.FilterOperatorContains:
+		return sb.ILike(tblFieldName, value), nil
+	case qbtypes.FilterOperatorNotContains:
+		return sb.NotILike(tblFieldName, value), nil
+
+	case qbtypes.FilterOperatorRegexp:
+		exp := fmt.Sprintf(`match(%s, %s)`, tblFieldName, sb.Var(value))
+		return sb.And(exp), nil
+	case qbtypes.FilterOperatorNotRegexp:
+		exp := fmt.Sprintf(`not match(%s, %s)`, tblFieldName, sb.Var(value))
+		return sb.And(exp), nil
+
+	// between and not between
+	case qbtypes.FilterOperatorBetween:
+		values, ok := value.([]any)
+		if !ok {
+			return "", qbtypes.ErrBetweenValues
+		}
+		if len(values) != 2 {
+			return "", qbtypes.ErrBetweenValues
+		}
+		return sb.Between(tblFieldName, values[0], values[1]), nil
+	case qbtypes.FilterOperatorNotBetween:
+		values, ok := value.([]any)
+		if !ok {
+			return "", qbtypes.ErrBetweenValues
+		}
+		if len(values) != 2 {
+			return "", qbtypes.ErrBetweenValues
+		}
+		return sb.NotBetween(tblFieldName, values[0], values[1]), nil
+
+	// in and not in
+	case qbtypes.FilterOperatorIn:
+		values, ok := value.([]any)
+		if !ok {
+			return "", qbtypes.ErrInValues
+		}
+		return sb.In(tblFieldName, values...), nil
+	case qbtypes.FilterOperatorNotIn:
+		values, ok := value.([]any)
+		if !ok {
+			return "", qbtypes.ErrInValues
+		}
+		return sb.NotIn(tblFieldName, values...), nil
+
+	// exists and not exists
+	// in the query builder, `exists` and `not exists` are used for
+	// key membership checks, so depending on the column type, the condition changes
+	case qbtypes.FilterOperatorExists, qbtypes.FilterOperatorNotExists:
+		var value any
+		switch column.Type {
+		case schema.ColumnTypeString,
+			schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+			schema.FixedStringColumnType{Length: 32},
+			schema.DateTime64ColumnType{Precision: 9, Timezone: "UTC"}:
+			value = ""
+			if operator == qbtypes.FilterOperatorExists {
+				return sb.NE(tblFieldName, value), nil
+			} else {
+				return sb.E(tblFieldName, value), nil
+			}
+		case schema.ColumnTypeUInt64,
+			schema.ColumnTypeUInt32,
+			schema.ColumnTypeUInt8,
+			schema.ColumnTypeInt8,
+			schema.ColumnTypeInt16,
+			schema.ColumnTypeBool:
+			value = 0
+			if operator == qbtypes.FilterOperatorExists {
+				return sb.NE(tblFieldName, value), nil
+			} else {
+				return sb.E(tblFieldName, value), nil
+			}
+		case schema.MapColumnType{
+			KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+			ValueType: schema.ColumnTypeString,
+		}, schema.MapColumnType{
+			KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+			ValueType: schema.ColumnTypeBool,
+		}, schema.MapColumnType{
+			KeyType:   schema.LowCardinalityColumnType{ElementType: schema.ColumnTypeString},
+			ValueType: schema.ColumnTypeFloat64,
+		}:
+			leftOperand := fmt.Sprintf("mapContains(%s, '%s')", column.Name, key.Name)
+			if key.Materialized {
+				leftOperand = telemetrytypes.FieldKeyToMaterializedColumnNameForExists(key)
+			}
+			if operator == qbtypes.FilterOperatorExists {
+				return sb.E(leftOperand, true), nil
+			} else {
+				return sb.NE(leftOperand, true), nil
+			}
+		default:
+			return "", fmt.Errorf("exists operator is not supported for column type %s", column.Type)
+		}
+	}
+	return "", nil
+}

pkg/telemetrytraces/condition_builder_test.go

@@ -0,0 +1,298 @@
+package telemetrytraces
+
+import (
+	"context"
+	"testing"
+
+	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/huandu/go-sqlbuilder"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetFieldKeyName(t *testing.T) {
+	ctx := context.Background()
+	conditionBuilder := &conditionBuilder{}
+
+	testCases := []struct {
+		name           string
+		key            telemetrytypes.TelemetryFieldKey
+		expectedResult string
+		expectedError  error
+	}{
+		{
+			name: "Simple column type - timestamp",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "timestamp",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			expectedResult: "timestamp",
+			expectedError:  nil,
+		},
+		{
+			name: "Map column type - string attribute",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "user.id",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+			},
+			expectedResult: "attributes_string['user.id']",
+			expectedError:  nil,
+		},
+		{
+			name: "Map column type - number attribute",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "request.size",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeNumber,
+			},
+			expectedResult: "attributes_number['request.size']",
+			expectedError:  nil,
+		},
+		{
+			name: "Map column type - bool attribute",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "request.success",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeBool,
+			},
+			expectedResult: "attributes_bool['request.success']",
+			expectedError:  nil,
+		},
+		{
+			name: "Map column type - resource attribute",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "service.name",
+				FieldContext: telemetrytypes.FieldContextResource,
+			},
+			expectedResult: "resources_string['service.name']",
+			expectedError:  nil,
+		},
+		{
+			name: "Non-existent column",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "nonexistent_field",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			expectedResult: "",
+			expectedError:  qbtypes.ErrColumnNotFound,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := conditionBuilder.GetTableFieldName(ctx, &tc.key)
+
+			if tc.expectedError != nil {
+				assert.Equal(t, tc.expectedError, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tc.expectedResult, result)
+			}
+		})
+	}
+}
+
+func TestGetCondition(t *testing.T) {
+	ctx := context.Background()
+	conditionBuilder := NewConditionBuilder()
+
+	testCases := []struct {
+		name          string
+		key           telemetrytypes.TelemetryFieldKey
+		operator      qbtypes.FilterOperator
+		value         any
+		expectedSQL   string
+		expectedError error
+	}{
+		{
+			name: "Not Equal operator - timestamp",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "timestamp",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			operator:      qbtypes.FilterOperatorNotEqual,
+			value:         uint64(1617979338000000000),
+			expectedSQL:   "timestamp <> ?",
+			expectedError: nil,
+		},
+		{
+			name: "Greater Than operator - number attribute",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "request.duration",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeNumber,
+			},
+			operator:      qbtypes.FilterOperatorGreaterThan,
+			value:         float64(100),
+			expectedSQL:   "attributes_number['request.duration'] > ?",
+			expectedError: nil,
+		},
+		{
+			name: "Less Than operator - number attribute",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "request.size",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeNumber,
+			},
+			operator:      qbtypes.FilterOperatorLessThan,
+			value:         float64(1024),
+			expectedSQL:   "attributes_number['request.size'] < ?",
+			expectedError: nil,
+		},
+		{
+			name: "Greater Than Or Equal operator - timestamp",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "timestamp",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			operator:      qbtypes.FilterOperatorGreaterThanOrEq,
+			value:         uint64(1617979338000000000),
+			expectedSQL:   "timestamp >= ?",
+			expectedError: nil,
+		},
+		{
+			name: "Less Than Or Equal operator - timestamp",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "timestamp",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			operator:      qbtypes.FilterOperatorLessThanOrEq,
+			value:         uint64(1617979338000000000),
+			expectedSQL:   "timestamp <= ?",
+			expectedError: nil,
+		},
+		{
+			name: "ILike operator - string attribute",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "user.id",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+			},
+			operator:      qbtypes.FilterOperatorILike,
+			value:         "%admin%",
+			expectedSQL:   "WHERE LOWER(attributes_string['user.id']) LIKE LOWER(?)",
+			expectedError: nil,
+		},
+		{
+			name: "Not ILike operator - string attribute",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "user.id",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+			},
+			operator:      qbtypes.FilterOperatorNotILike,
+			value:         "%admin%",
+			expectedSQL:   "WHERE LOWER(attributes_string['user.id']) NOT LIKE LOWER(?)",
+			expectedError: nil,
+		},
+		{
+			name: "Between operator - timestamp",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "timestamp",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			operator:      qbtypes.FilterOperatorBetween,
+			value:         []any{uint64(1617979338000000000), uint64(1617979348000000000)},
+			expectedSQL:   "timestamp BETWEEN ? AND ?",
+			expectedError: nil,
+		},
+		{
+			name: "Between operator - invalid value",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "timestamp",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			operator:      qbtypes.FilterOperatorBetween,
+			value:         "invalid",
+			expectedSQL:   "",
+			expectedError: qbtypes.ErrBetweenValues,
+		},
+		{
+			name: "Between operator - insufficient values",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "timestamp",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			operator:      qbtypes.FilterOperatorBetween,
+			value:         []any{uint64(1617979338000000000)},
+			expectedSQL:   "",
+			expectedError: qbtypes.ErrBetweenValues,
+		},
+		{
+			name: "Not Between operator - timestamp",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "timestamp",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			operator:      qbtypes.FilterOperatorNotBetween,
+			value:         []any{uint64(1617979338000000000), uint64(1617979348000000000)},
+			expectedSQL:   "timestamp NOT BETWEEN ? AND ?",
+			expectedError: nil,
+		},
+		{
+			name: "Exists operator - map field",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "user.id",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+			},
+			operator:      qbtypes.FilterOperatorExists,
+			value:         nil,
+			expectedSQL:   "mapContains(attributes_string, 'user.id') = ?",
+			expectedError: nil,
+		},
+		{
+			name: "Not Exists operator - map field",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "user.id",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+			},
+			operator:      qbtypes.FilterOperatorNotExists,
+			value:         nil,
+			expectedSQL:   "mapContains(attributes_string, 'user.id') <> ?",
+			expectedError: nil,
+		},
+		{
+			name: "Contains operator - map field",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:          "user.id",
+				FieldContext:  telemetrytypes.FieldContextAttribute,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+			},
+			operator:      qbtypes.FilterOperatorContains,
+			value:         "admin",
+			expectedSQL:   "WHERE LOWER(attributes_string['user.id']) LIKE LOWER(?)",
+			expectedError: nil,
+		},
+		{
+			name: "Non-existent column",
+			key: telemetrytypes.TelemetryFieldKey{
+				Name:         "nonexistent_field",
+				FieldContext: telemetrytypes.FieldContextSpan,
+			},
+			operator:      qbtypes.FilterOperatorEqual,
+			value:         "value",
+			expectedSQL:   "",
+			expectedError: qbtypes.ErrColumnNotFound,
+		},
+	}
+
+	for _, tc := range testCases {
+		sb := sqlbuilder.NewSelectBuilder()
+		t.Run(tc.name, func(t *testing.T) {
+			cond, err := conditionBuilder.GetCondition(ctx, &tc.key, tc.operator, tc.value, sb)
+			sb.Where(cond)
+
+			if tc.expectedError != nil {
+				assert.Equal(t, tc.expectedError, err)
+			} else {
+				require.NoError(t, err)
+				sql, _ := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+				assert.Contains(t, sql, tc.expectedSQL)
+			}
+		})
+	}
+}

pkg/telemetrytraces/tables.go

@@ -0,0 +1,10 @@
+package telemetrytraces
+
+const (
+	DBName                        = "signoz_traces"
+	SpanIndexV3TableName          = "distributed_signoz_index_v3"
+	SpanIndexV3LocalTableName     = "signoz_index_v3"
+	TagAttributesV2TableName      = "distributed_tag_attributes_v2"
+	TagAttributesV2LocalTableName = "tag_attributes_v2"
+	TopLevelOperationsTableName   = "distributed_top_level_operations"
+)