Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

27.0 KB
Raw Blame
package querybuilder

import (
	"fmt"
	"strconv"
	"strings"

	"github.com/SigNoz/signoz/pkg/errors"
	grammar "github.com/SigNoz/signoz/pkg/parser/filterquery/grammar"
	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
	"github.com/antlr4-go/antlr/v4"
)

// FieldConstraint represents a constraint on a field.
type FieldConstraint struct {
	Field    string
	Operator qbtypes.FilterOperator
	Value    any
	Values   []any // For IN, NOT IN operations
}

// ConstraintSet represents a set of constraints that must all be true (AND).
type ConstraintSet struct {
	Constraints map[string][]FieldConstraint // field -> constraints
}

// LogicalContradictionDetector implements the visitor pattern to detect logical contradictions.
type LogicalContradictionDetector struct {
	grammar.BaseFilterQueryVisitor
	constraintStack []*ConstraintSet // Stack of constraint sets for nested expressions
	contradictions  []string
	notContextStack []bool // Stack to track NOT contexts
}

// DetectContradictions analyzes a query string and returns any contradictions found.
func DetectContradictions(query string) ([]string, error) {
	// Setup ANTLR parsing pipeline
	input := antlr.NewInputStream(query)
	lexer := grammar.NewFilterQueryLexer(input)

	// Error handling
	lexerErrorListener := NewErrorListener()
	lexer.RemoveErrorListeners()
	lexer.AddErrorListener(lexerErrorListener)

	tokens := antlr.NewCommonTokenStream(lexer, 0)
	parser := grammar.NewFilterQueryParser(tokens)

	parserErrorListener := NewErrorListener()
	parser.RemoveErrorListeners()
	parser.AddErrorListener(parserErrorListener)

	// Parse the query
	tree := parser.Query()

	// Check for syntax errors
	if len(parserErrorListener.SyntaxErrors) > 0 {
		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "syntax errors: %v", parserErrorListener.SyntaxErrors)
	}

	// Create detector and visit tree
	detector := &LogicalContradictionDetector{
		constraintStack: []*ConstraintSet{
			{Constraints: make(map[string][]FieldConstraint)},
		},
		contradictions:  []string{},
		notContextStack: []bool{false},
	}

	detector.Visit(tree)

	// Deduplicate contradictions
	seen := make(map[string]bool)
	unique := []string{}
	for _, c := range detector.contradictions {
		if !seen[c] {
			seen[c] = true
			unique = append(unique, c)
		}
	}

	return unique, nil
}

// Helper methods for constraint stack.
func (d *LogicalContradictionDetector) currentConstraints() *ConstraintSet {
	return d.constraintStack[len(d.constraintStack)-1]
}

// Helper methods for NOT context.
func (d *LogicalContradictionDetector) inNotContext() bool {
	return d.notContextStack[len(d.notContextStack)-1]
}

func (d *LogicalContradictionDetector) pushNotContext(value bool) {
	d.notContextStack = append(d.notContextStack, value)
}

func (d *LogicalContradictionDetector) popNotContext() {
	if len(d.notContextStack) > 1 {
		d.notContextStack = d.notContextStack[:len(d.notContextStack)-1]
	}
}

// Visit dispatches to the appropriate visit method.
func (d *LogicalContradictionDetector) Visit(tree antlr.ParseTree) any {
	if tree == nil {
		return nil
	}
	return tree.Accept(d)
}

// VisitQuery is the entry point.
func (d *LogicalContradictionDetector) VisitQuery(ctx *grammar.QueryContext) any {
	d.Visit(ctx.Expression())
	// Check final constraints
	d.checkContradictions(d.currentConstraints())
	return nil
}

// VisitExpression just passes through to OrExpression.
func (d *LogicalContradictionDetector) VisitExpression(ctx *grammar.ExpressionContext) any {
	return d.Visit(ctx.OrExpression())
}

// VisitOrExpression handles OR logic.
func (d *LogicalContradictionDetector) VisitOrExpression(ctx *grammar.OrExpressionContext) any {
	andExpressions := ctx.AllAndExpression()

	if len(andExpressions) == 1 {
		// Single AND expression, just visit it
		return d.Visit(andExpressions[0])
	}

	// Multiple AND expressions connected by OR
	// Visit each branch to find contradictions within branches
	for _, andExpr := range andExpressions {
		// Save current constraints
		savedConstraints := d.cloneConstraintSet(d.currentConstraints())

		// Visit the AND expression
		d.Visit(andExpr)

		// Restore constraints for next branch
		d.constraintStack[len(d.constraintStack)-1] = savedConstraints
	}

	return nil
}

// VisitAndExpression handles AND logic (including implicit AND).
func (d *LogicalContradictionDetector) VisitAndExpression(ctx *grammar.AndExpressionContext) any {
	unaryExpressions := ctx.AllUnaryExpression()

	// Visit each unary expression, accumulating constraints
	for _, unaryExpr := range unaryExpressions {
		d.Visit(unaryExpr)
	}

	return nil
}

// VisitUnaryExpression handles NOT operator.
func (d *LogicalContradictionDetector) VisitUnaryExpression(ctx *grammar.UnaryExpressionContext) any {
	hasNot := ctx.NOT() != nil

	if hasNot {
		// Push new NOT context (toggle current value)
		d.pushNotContext(!d.inNotContext())
	}

	result := d.Visit(ctx.Primary())

	if hasNot {
		// Pop NOT context
		d.popNotContext()
	}

	return result
}

// VisitPrimary handles different primary expressions.
func (d *LogicalContradictionDetector) VisitPrimary(ctx *grammar.PrimaryContext) any {
	if ctx.OrExpression() != nil {
		// Parenthesized expression
		// If we're in an AND context, we continue with the same constraint set
		// Otherwise, we need to handle it specially
		return d.Visit(ctx.OrExpression())
	} else if ctx.Comparison() != nil {
		return d.Visit(ctx.Comparison())
	} else if ctx.FunctionCall() != nil {
		// Handle function calls if needed
		return nil
	} else if ctx.SearchCall() != nil {
		// search() spans all fields; it can never be a logical contradiction
		return nil
	} else if ctx.FullText() != nil {
		// Handle full text search if needed
		return nil
	}

	return nil
}

// VisitComparison extracts constraints from comparisons.
func (d *LogicalContradictionDetector) VisitComparison(ctx *grammar.ComparisonContext) any {
	if ctx.Key() == nil {
		return nil
	}

	field := ctx.Key().GetText()
	notContext := d.inNotContext()

	// Handle EXISTS
	if ctx.EXISTS() != nil {
		operator := qbtypes.FilterOperatorExists
		if ctx.NOT() != nil {
			operator = qbtypes.FilterOperatorNotExists
		}
		// Apply NOT context
		if notContext {
			operator = negateOperator(operator)
		}
		constraint := FieldConstraint{
			Field:    field,
			Operator: operator,
		}
		d.addConstraint(constraint)
		return nil
	}

	// Handle IN/NOT IN
	if ctx.InClause() != nil {
		values := d.extractValueList(ctx.InClause().(*grammar.InClauseContext).ValueList())
		operator := qbtypes.FilterOperatorIn
		if notContext {
			operator = negateOperator(operator)
		}
		constraint := FieldConstraint{
			Field:    field,
			Operator: operator,
			Values:   values,
		}
		d.addConstraint(constraint)
		return nil
	}

	if ctx.NotInClause() != nil {
		values := d.extractValueList(ctx.NotInClause().(*grammar.NotInClauseContext).ValueList())
		operator := qbtypes.FilterOperatorNotIn
		if notContext {
			operator = negateOperator(operator)
		}
		constraint := FieldConstraint{
			Field:    field,
			Operator: operator,
			Values:   values,
		}
		d.addConstraint(constraint)
		return nil
	}

	// Handle BETWEEN
	if ctx.BETWEEN() != nil {
		values := ctx.AllValue()
		if len(values) == 2 {
			val1 := d.extractValue(values[0])
			val2 := d.extractValue(values[1])
			operator := qbtypes.FilterOperatorBetween
			if ctx.NOT() != nil {
				operator = qbtypes.FilterOperatorNotBetween
			}
			// Apply NOT context
			if notContext {
				operator = negateOperator(operator)
			}
			constraint := FieldConstraint{
				Field:    field,
				Operator: operator,
				Values:   []any{val1, val2},
			}
			d.addConstraint(constraint)
		}
		return nil
	}

	// Handle regular comparisons
	values := ctx.AllValue()
	if len(values) > 0 {
		value := d.extractValue(values[0])
		var operator qbtypes.FilterOperator

		if ctx.EQUALS() != nil {
			operator = qbtypes.FilterOperatorEqual
		} else if ctx.NOT_EQUALS() != nil || ctx.NEQ() != nil {
			operator = qbtypes.FilterOperatorNotEqual
		} else if ctx.LT() != nil {
			operator = qbtypes.FilterOperatorLessThan
		} else if ctx.LE() != nil {
			operator = qbtypes.FilterOperatorLessThanOrEq
		} else if ctx.GT() != nil {
			operator = qbtypes.FilterOperatorGreaterThan
		} else if ctx.GE() != nil {
			operator = qbtypes.FilterOperatorGreaterThanOrEq
		} else if ctx.LIKE() != nil {
			operator = qbtypes.FilterOperatorLike
			if ctx.NOT() != nil {
				operator = qbtypes.FilterOperatorNotLike
			}
		} else if ctx.ILIKE() != nil {
			operator = qbtypes.FilterOperatorILike
			if ctx.NOT() != nil {
				operator = qbtypes.FilterOperatorNotILike
			}
		} else if ctx.REGEXP() != nil {
			operator = qbtypes.FilterOperatorRegexp
			if ctx.NOT() != nil {
				operator = qbtypes.FilterOperatorNotRegexp
			}
		} else if ctx.CONTAINS() != nil {
			operator = qbtypes.FilterOperatorContains
			if ctx.NOT() != nil {
				operator = qbtypes.FilterOperatorNotContains
			}
		}

		if operator != qbtypes.FilterOperatorUnknown {
			// Apply NOT context if needed
			if notContext {
				operator = negateOperator(operator)
			}

			constraint := FieldConstraint{
				Field:    field,
				Operator: operator,
				Value:    value,
			}
			d.addConstraint(constraint)
		}
	}

	// Check for contradictions after adding this constraint
	d.checkContradictions(d.currentConstraints())

	return nil
}

// extractValue extracts the actual value from a ValueContext.
func (d *LogicalContradictionDetector) extractValue(ctx grammar.IValueContext) any {
	if ctx.QUOTED_TEXT() != nil {
		text := ctx.QUOTED_TEXT().GetText()
		// Remove quotes
		if len(text) >= 2 {
			return text[1 : len(text)-1]
		}
		return text
	} else if ctx.NUMBER() != nil {
		return ctx.NUMBER().GetText()
	} else if ctx.BOOL() != nil {
		return ctx.BOOL().GetText()
	} else if ctx.KEY() != nil {
		return ctx.KEY().GetText()
	}
	return ""
}

// extractValueList extracts values from a ValueListContext.
func (d *LogicalContradictionDetector) extractValueList(ctx grammar.IValueListContext) []any {
	if ctx == nil {
		return nil
	}

	values := []any{}
	for _, val := range ctx.AllValue() {
		values = append(values, d.extractValue(val))
	}
	return values
}

// addConstraint adds a constraint to the current set.
func (d *LogicalContradictionDetector) addConstraint(constraint FieldConstraint) {
	constraints := d.currentConstraints()

	// For positive operators that imply existence, add an implicit EXISTS constraint
	// This mirrors the behavior of AddDefaultExistsFilter in the FilterOperator type
	if constraint.Operator.AddDefaultExistsFilter() && !isNegativeOperator(constraint.Operator) {
		// The field must exist for positive predicates
		// This helps detect contradictions like: field = "value" AND field NOT EXISTS
		existsConstraint := FieldConstraint{
			Field:    constraint.Field,
			Operator: qbtypes.FilterOperatorExists,
		}
		constraints.Constraints[constraint.Field] = append(
			constraints.Constraints[constraint.Field],
			existsConstraint,
		)
	}

	constraints.Constraints[constraint.Field] = append(
		constraints.Constraints[constraint.Field],
		constraint,
	)
}

// checkContradictions checks the given constraint set for contradictions.
func (d *LogicalContradictionDetector) checkContradictions(constraintSet *ConstraintSet) {
	for field, constraints := range constraintSet.Constraints {
		if len(constraints) < 2 {
			continue
		}

		// Check for contradictions in this field's constraints
		contradictions := d.findContradictionsInConstraints(field, constraints)
		d.contradictions = append(d.contradictions, contradictions...)
	}
}

// findContradictionsInConstraints checks if a set of constraints on the same field contradict.
func (d *LogicalContradictionDetector) findContradictionsInConstraints(field string, constraints []FieldConstraint) []string {
	contradictions := []string{}

	// Group constraints by type for easier checking
	var equalConstraints []FieldConstraint
	var notEqualConstraints []FieldConstraint
	var rangeConstraints []FieldConstraint
	var inConstraints []FieldConstraint
	var notInConstraints []FieldConstraint
	var existsConstraints []FieldConstraint
	var notExistsConstraints []FieldConstraint
	var betweenConstraints []FieldConstraint
	var notBetweenConstraints []FieldConstraint
	var likeConstraints []FieldConstraint

	for _, c := range constraints {
		switch c.Operator {
		case qbtypes.FilterOperatorEqual:
			equalConstraints = append(equalConstraints, c)
		case qbtypes.FilterOperatorNotEqual:
			notEqualConstraints = append(notEqualConstraints, c)
		case qbtypes.FilterOperatorIn:
			inConstraints = append(inConstraints, c)
		case qbtypes.FilterOperatorNotIn:
			notInConstraints = append(notInConstraints, c)
		case qbtypes.FilterOperatorExists:
			existsConstraints = append(existsConstraints, c)
		case qbtypes.FilterOperatorNotExists:
			notExistsConstraints = append(notExistsConstraints, c)
		case qbtypes.FilterOperatorBetween:
			betweenConstraints = append(betweenConstraints, c)
		case qbtypes.FilterOperatorNotBetween:
			notBetweenConstraints = append(notBetweenConstraints, c)
		case qbtypes.FilterOperatorLike, qbtypes.FilterOperatorILike,
			qbtypes.FilterOperatorNotLike, qbtypes.FilterOperatorNotILike:
			likeConstraints = append(likeConstraints, c)
		default:
			// Handle range operators
			if isRangeOperator(c.Operator) {
				rangeConstraints = append(rangeConstraints, c)
			}
		}
	}

	// Check for multiple different equality constraints
	if len(equalConstraints) > 1 {
		values := make(map[string]bool)
		for _, c := range equalConstraints {
			values[fmt.Sprintf("%v", c.Value)] = true
		}
		if len(values) > 1 {
			contradictions = append(contradictions,
				fmt.Sprintf("Field '%s' cannot equal multiple different values", field))
		}
	}

	// Check equality vs not-equality
	for _, eq := range equalConstraints {
		for _, neq := range notEqualConstraints {
			if fmt.Sprintf("%v", eq.Value) == fmt.Sprintf("%v", neq.Value) {
				contradictions = append(contradictions,
					fmt.Sprintf("Field '%s' cannot both equal and not equal '%v'", field, eq.Value))
			}
		}
	}

	// Check equality vs IN/NOT IN
	for _, eq := range equalConstraints {
		// Check against NOT IN
		for _, notIn := range notInConstraints {
			for _, v := range notIn.Values {
				if fmt.Sprintf("%v", eq.Value) == fmt.Sprintf("%v", v) {
					contradictions = append(contradictions,
						fmt.Sprintf("Field '%s' equals '%v' but is in NOT IN list", field, eq.Value))
				}
			}
		}

		// Check against IN
		for _, in := range inConstraints {
			found := false
			for _, v := range in.Values {
				if fmt.Sprintf("%v", eq.Value) == fmt.Sprintf("%v", v) {
					found = true
					break
				}
			}
			if !found {
				contradictions = append(contradictions,
					fmt.Sprintf("Field '%s' equals '%v' but is not in IN list", field, eq.Value))
			}
		}
	}

	// Check IN vs NOT IN overlap
	for _, in := range inConstraints {
		for _, notIn := range notInConstraints {
			overlap := []string{}
			for _, inVal := range in.Values {
				for _, notInVal := range notIn.Values {
					if fmt.Sprintf("%v", inVal) == fmt.Sprintf("%v", notInVal) {
						overlap = append(overlap, fmt.Sprintf("%v", inVal))
					}
				}
			}
			if len(overlap) > 0 {
				contradictions = append(contradictions,
					fmt.Sprintf("Field '%s' has overlapping IN and NOT IN values: %v", field, overlap))
			}
		}
	}

	// Check range contradictions
	if len(rangeConstraints) > 0 {
		if impossible := d.checkRangeContradictions(rangeConstraints); impossible {
			contradictions = append(contradictions,
				fmt.Sprintf("Field '%s' has contradictory range constraints", field))
		}
	}

	// Check equality vs range
	for _, eq := range equalConstraints {
		if !d.valuesSatisfyRanges(eq.Value, rangeConstraints) {
			contradictions = append(contradictions,
				fmt.Sprintf("Field '%s' equals '%v' which violates range constraints", field, eq.Value))
		}
	}

	// Check EXISTS contradictions
	if len(existsConstraints) > 0 && len(notExistsConstraints) > 0 {
		contradictions = append(contradictions,
			fmt.Sprintf("Field '%s' cannot both exist and not exist", field))
	}

	// Check if NOT EXISTS contradicts with operators that imply existence
	if len(notExistsConstraints) > 0 {
		for _, c := range constraints {
			if c.Operator.AddDefaultExistsFilter() && !isNegativeOperator(c.Operator) {
				contradictions = append(contradictions,
					fmt.Sprintf("Field '%s' has NOT EXISTS but also has %v which implies existence",
						field, c.Operator))
				break
			}
		}
	}

	// Check BETWEEN contradictions - need to check if ALL ranges have a common intersection
	if len(betweenConstraints) >= 2 {
		if !d.hasCommonIntersection(betweenConstraints) {
			contradictions = append(contradictions,
				fmt.Sprintf("Field '%s' has non-overlapping BETWEEN ranges", field))
		}
	}

	// Check BETWEEN vs equality
	for _, eq := range equalConstraints {
		satisfiesAny := false
		for _, between := range betweenConstraints {
			if d.valueSatisfiesBetween(eq.Value, between) {
				satisfiesAny = true
				break
			}
		}
		if len(betweenConstraints) > 0 && !satisfiesAny {
			contradictions = append(contradictions,
				fmt.Sprintf("Field '%s' equals '%v' which is outside BETWEEN range(s)", field, eq.Value))
		}
	}

	// Check NOT BETWEEN vs equality
	for _, eq := range equalConstraints {
		for _, notBetween := range notBetweenConstraints {
			if d.valueSatisfiesBetween(eq.Value, notBetween) {
				contradictions = append(contradictions,
					fmt.Sprintf("Field '%s' equals '%v' which is excluded by NOT BETWEEN range", field, eq.Value))
			}
		}
	}

	// Check if BETWEEN and NOT BETWEEN ranges make it impossible to have any value
	if len(betweenConstraints) > 0 && len(notBetweenConstraints) > 0 {
		// Check if the NOT BETWEEN completely covers the BETWEEN range
		for _, between := range betweenConstraints {
			if len(between.Values) == 2 {
				bMin, err1 := parseNumericValue(between.Values[0])
				bMax, err2 := parseNumericValue(between.Values[1])
				if err1 == nil && err2 == nil {
					// Check if this BETWEEN range has any values not excluded by NOT BETWEEN
					hasValidValue := false
					// Simple check: see if the endpoints or midpoint are valid
					testValues := []float64{bMin, bMax, (bMin + bMax) / 2}
					for _, testVal := range testValues {
						valid := true
						for _, notBetween := range notBetweenConstraints {
							if d.valueSatisfiesBetween(testVal, notBetween) {
								valid = false
								break
							}
						}
						if valid {
							hasValidValue = true
							break
						}
					}
					if !hasValidValue {
						contradictions = append(contradictions,
							fmt.Sprintf("Field '%s' has BETWEEN and NOT BETWEEN ranges that exclude all values", field))
					}
				}
			}
		}
	}

	// Check LIKE pattern contradictions with exact values
	for _, eq := range equalConstraints {
		for _, like := range likeConstraints {
			if like.Operator == qbtypes.FilterOperatorLike || like.Operator == qbtypes.FilterOperatorILike {
				pattern := fmt.Sprintf("%v", like.Value)
				value := fmt.Sprintf("%v", eq.Value)
				if !d.matchesLikePattern(value, pattern) {
					contradictions = append(contradictions,
						fmt.Sprintf("Field '%s' equals '%v' which doesn't match LIKE pattern '%v'",
							field, eq.Value, like.Value))
				}
			}
		}
	}

	return contradictions
}

// hasCommonIntersection checks if all BETWEEN ranges have a common intersection.
func (d *LogicalContradictionDetector) hasCommonIntersection(betweens []FieldConstraint) bool {
	if len(betweens) == 0 {
		return true
	}

	// Find the intersection of all ranges
	var intersectionMin, intersectionMax float64
	initialized := false

	for _, b := range betweens {
		if len(b.Values) != 2 {
			continue
		}

		min, err1 := parseNumericValue(b.Values[0])
		max, err2 := parseNumericValue(b.Values[1])
		if err1 != nil || err2 != nil {
			continue // Skip non-numeric ranges
		}

		if !initialized {
			intersectionMin = min
			intersectionMax = max
			initialized = true
		} else {
			// Update intersection
			if min > intersectionMin {
				intersectionMin = min
			}
			if max < intersectionMax {
				intersectionMax = max
			}
		}
	}

	// If intersection is empty, ranges don't all overlap
	return !initialized || intersectionMin <= intersectionMax
}

// checkRangeContradictions checks if range constraints are satisfiable.
func (d *LogicalContradictionDetector) checkRangeContradictions(constraints []FieldConstraint) bool {
	// We need to find if there's any value that satisfies all constraints

	var lowerBounds []struct {
		value     float64
		inclusive bool
	}
	var upperBounds []struct {
		value     float64
		inclusive bool
	}

	for _, c := range constraints {
		val, err := parseNumericValue(c.Value)
		if err != nil {
			continue // Skip non-numeric values
		}

		switch c.Operator {
		case qbtypes.FilterOperatorGreaterThan:
			lowerBounds = append(lowerBounds, struct {
				value     float64
				inclusive bool
			}{val, false})
		case qbtypes.FilterOperatorGreaterThanOrEq:
			lowerBounds = append(lowerBounds, struct {
				value     float64
				inclusive bool
			}{val, true})
		case qbtypes.FilterOperatorLessThan:
			upperBounds = append(upperBounds, struct {
				value     float64
				inclusive bool
			}{val, false})
		case qbtypes.FilterOperatorLessThanOrEq:
			upperBounds = append(upperBounds, struct {
				value     float64
				inclusive bool
			}{val, true})
		}
	}

	// Find the most restrictive lower bound
	var effectiveLower *float64
	lowerInclusive := false
	for _, lb := range lowerBounds {
		if effectiveLower == nil || lb.value > *effectiveLower ||
			(lb.value == *effectiveLower && !lb.inclusive && lowerInclusive) {
			effectiveLower = &lb.value
			lowerInclusive = lb.inclusive
		}
	}

	// Find the most restrictive upper bound
	var effectiveUpper *float64
	upperInclusive := false
	for _, ub := range upperBounds {
		if effectiveUpper == nil || ub.value < *effectiveUpper ||
			(ub.value == *effectiveUpper && !ub.inclusive && upperInclusive) {
			effectiveUpper = &ub.value
			upperInclusive = ub.inclusive
		}
	}

	// Check if we have both bounds and they're contradictory
	if effectiveLower != nil && effectiveUpper != nil {
		if *effectiveLower > *effectiveUpper {
			return true
		}
		if *effectiveLower == *effectiveUpper && (!lowerInclusive || !upperInclusive) {
			return true
		}
	}

	return false
}

// valuesSatisfyRanges checks if a value satisfies all range constraints.
func (d *LogicalContradictionDetector) valuesSatisfyRanges(value any, constraints []FieldConstraint) bool {
	val, err := parseNumericValue(value)
	if err != nil {
		return true // If not numeric, we can't check
	}

	for _, c := range constraints {
		cVal, err := parseNumericValue(c.Value)
		if err != nil {
			continue
		}

		switch c.Operator {
		case qbtypes.FilterOperatorGreaterThan:
			if val <= cVal {
				return false
			}
		case qbtypes.FilterOperatorGreaterThanOrEq:
			if val < cVal {
				return false
			}
		case qbtypes.FilterOperatorLessThan:
			if val >= cVal {
				return false
			}
		case qbtypes.FilterOperatorLessThanOrEq:
			if val > cVal {
				return false
			}
		}
	}

	return true
}

// valueSatisfiesBetween checks if a value is within a BETWEEN range.
func (d *LogicalContradictionDetector) valueSatisfiesBetween(value any, between FieldConstraint) bool {
	if len(between.Values) != 2 {
		return false
	}

	val, err := parseNumericValue(value)
	if err != nil {
		return true // Can't check non-numeric
	}

	min, err1 := parseNumericValue(between.Values[0])
	max, err2 := parseNumericValue(between.Values[1])

	if err1 != nil || err2 != nil {
		return true
	}

	return val >= min && val <= max
}

// matchesLikePattern is a simple pattern matcher for LIKE.
func (d *LogicalContradictionDetector) matchesLikePattern(value, pattern string) bool {
	// Simple implementation - just check prefix/suffix with %
	if strings.HasPrefix(pattern, "%") && strings.HasSuffix(pattern, "%") {
		return strings.Contains(value, pattern[1:len(pattern)-1])
	} else if strings.HasPrefix(pattern, "%") {
		return strings.HasSuffix(value, pattern[1:])
	} else if strings.HasSuffix(pattern, "%") {
		return strings.HasPrefix(value, pattern[:len(pattern)-1])
	}
	return value == pattern
}

// cloneConstraintSet creates a deep copy of a constraint set.
func (d *LogicalContradictionDetector) cloneConstraintSet(set *ConstraintSet) *ConstraintSet {
	newSet := &ConstraintSet{
		Constraints: make(map[string][]FieldConstraint),
	}

	for field, constraints := range set.Constraints {
		newConstraints := make([]FieldConstraint, len(constraints))
		copy(newConstraints, constraints)
		newSet.Constraints[field] = newConstraints
	}

	return newSet
}

// parseNumericValue attempts to parse a value as a number.
func parseNumericValue(value any) (float64, error) {
	switch v := value.(type) {
	case float64:
		return v, nil
	case int:
		return float64(v), nil
	case string:
		return strconv.ParseFloat(v, 64)
	default:
		return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "not a numeric value")
	}
}

// negateOperator returns the negated version of an operator.
func negateOperator(op qbtypes.FilterOperator) qbtypes.FilterOperator {
	switch op {
	case qbtypes.FilterOperatorEqual:
		return qbtypes.FilterOperatorNotEqual
	case qbtypes.FilterOperatorNotEqual:
		return qbtypes.FilterOperatorEqual
	case qbtypes.FilterOperatorLessThan:
		return qbtypes.FilterOperatorGreaterThanOrEq
	case qbtypes.FilterOperatorLessThanOrEq:
		return qbtypes.FilterOperatorGreaterThan
	case qbtypes.FilterOperatorGreaterThan:
		return qbtypes.FilterOperatorLessThanOrEq
	case qbtypes.FilterOperatorGreaterThanOrEq:
		return qbtypes.FilterOperatorLessThan
	case qbtypes.FilterOperatorIn:
		return qbtypes.FilterOperatorNotIn
	case qbtypes.FilterOperatorNotIn:
		return qbtypes.FilterOperatorIn
	case qbtypes.FilterOperatorExists:
		return qbtypes.FilterOperatorNotExists
	case qbtypes.FilterOperatorNotExists:
		return qbtypes.FilterOperatorExists
	case qbtypes.FilterOperatorLike:
		return qbtypes.FilterOperatorNotLike
	case qbtypes.FilterOperatorNotLike:
		return qbtypes.FilterOperatorLike
	case qbtypes.FilterOperatorILike:
		return qbtypes.FilterOperatorNotILike
	case qbtypes.FilterOperatorNotILike:
		return qbtypes.FilterOperatorILike
	case qbtypes.FilterOperatorBetween:
		return qbtypes.FilterOperatorNotBetween
	case qbtypes.FilterOperatorNotBetween:
		return qbtypes.FilterOperatorBetween
	case qbtypes.FilterOperatorRegexp:
		return qbtypes.FilterOperatorNotRegexp
	case qbtypes.FilterOperatorNotRegexp:
		return qbtypes.FilterOperatorRegexp
	case qbtypes.FilterOperatorContains:
		return qbtypes.FilterOperatorNotContains
	case qbtypes.FilterOperatorNotContains:
		return qbtypes.FilterOperatorContains
	default:
		return op
	}
}

// isRangeOperator returns true if the operator is a range comparison operator.
func isRangeOperator(op qbtypes.FilterOperator) bool {
	switch op {
	case qbtypes.FilterOperatorLessThan,
		qbtypes.FilterOperatorLessThanOrEq,
		qbtypes.FilterOperatorGreaterThan,
		qbtypes.FilterOperatorGreaterThanOrEq:
		return true
	default:
		return false
	}
}

// isNegativeOperator returns true if the operator is a negative/exclusion operator.
func isNegativeOperator(op qbtypes.FilterOperator) bool {
	switch op {
	case qbtypes.FilterOperatorNotEqual,
		qbtypes.FilterOperatorNotIn,
		qbtypes.FilterOperatorNotExists,
		qbtypes.FilterOperatorNotLike,
		qbtypes.FilterOperatorNotILike,
		qbtypes.FilterOperatorNotBetween,
		qbtypes.FilterOperatorNotRegexp,
		qbtypes.FilterOperatorNotContains:
		return true
	default:
		return false
	}
}