[cassandra] Refactor TagFilter to accept dbmodel.Span (jaegertracing#7707)

## Which problem is this PR solving?
- Fixes a part of: jaegertracing#6458

## Description of the changes
- This is a blocker of jaegertracing#7699, we need to refactor `TagFilter` to accept
`dbmodel.Span` rather than `model.Span`

## How was this change tested?
- Unit And Integration Tests

## Checklist
- [x] I have read
https://github.com/jaegertracing/jaeger/blob/master/CONTRIBUTING_GUIDELINES.md
- [x] I have signed all commits
- [x] I have added unit tests for the new functionality
- [x] I have run lint and test steps successfully
  - for `jaeger`: `make lint test`
  - for `jaeger-ui`: `npm run lint` and `npm run test`

---------

Signed-off-by: Manik Mehta <mehtamanik96@gmail.com>
Signed-off-by: SoumyaRaikwar <somuraik@gmail.com>

Author: Manik2708

internal/storage/v1/cassandra/spanstore/dbmodel/model.go

@@ -7,6 +7,10 @@ package dbmodel
 import (
 	"bytes"
 	"encoding/binary"
+	"encoding/hex"
+	"sort"
+	"strconv"
+	"strings"
 
 	"github.com/jaegertracing/jaeger-idl/model/v1"
 )
@@ -53,6 +57,96 @@ type KeyValue struct {
 	ValueBinary  []byte  `cql:"value_binary"`
 }
 
+func (t *KeyValue) compareValues(that *KeyValue) int {
+	switch t.ValueType {
+	case stringType:
+		return strings.Compare(t.ValueString, that.ValueString)
+	case boolType:
+		if t.ValueBool != that.ValueBool {
+			if !t.ValueBool {
+				return -1
+			}
+			return 1
+		}
+	case int64Type:
+		return int(t.ValueInt64 - that.ValueInt64)
+	case float64Type:
+		if t.ValueFloat64 != that.ValueFloat64 {
+			if t.ValueFloat64 < that.ValueFloat64 {
+				return -1
+			}
+			return 1
+		}
+	case binaryType:
+		return bytes.Compare(t.ValueBinary, that.ValueBinary)
+	default:
+		return -1 // theoretical case, not stating them equal but placing the base pointer before other
+	}
+	return 0
+}
+
+func (t *KeyValue) Compare(that any) int {
+	if that == nil {
+		if t == nil {
+			return 0
+		}
+		return 1
+	}
+	that1, ok := that.(*KeyValue)
+	if !ok {
+		that2, ok := that.(KeyValue)
+		if !ok {
+			return 1
+		}
+		that1 = &that2
+	}
+	if that1 == nil {
+		if t == nil {
+			return 0
+		}
+		return 1
+	} else if t == nil {
+		return -1
+	}
+	if cmp := strings.Compare(t.Key, that1.Key); cmp != 0 {
+		return cmp
+	}
+	if cmp := strings.Compare(t.ValueType, that1.ValueType); cmp != 0 {
+		return cmp
+	}
+	return t.compareValues(that1)
+}
+
+func (t *KeyValue) Equal(that any) bool {
+	return t.Compare(that) == 0
+}
+
+func (t *KeyValue) AsString() string {
+	switch t.ValueType {
+	case stringType:
+		return t.ValueString
+	case boolType:
+		if t.ValueBool {
+			return "true"
+		}
+		return "false"
+	case int64Type:
+		return strconv.FormatInt(t.ValueInt64, 10)
+	case float64Type:
+		return strconv.FormatFloat(t.ValueFloat64, 'g', 10, 64)
+	case binaryType:
+		return hex.EncodeToString(t.ValueBinary)
+	default:
+		return "unknown type " + t.ValueType
+	}
+}
+
+func SortKVs(kvs []KeyValue) {
+	sort.Slice(kvs, func(i, j int) bool {
+		return kvs[i].Compare(kvs[j]) < 0
+	})
+}
+
 // Log is the UDT representation of a Jaeger Log.
 type Log struct {
 	Timestamp int64      `cql:"ts"` // microseconds since epoch