>, >=, <, <= operator

Author: codechenx

README.md

@@ -344,12 +344,17 @@ Show only rows where specific columns match your criteria. **Supports filtering
 | **OR** | `term1 OR term2` | Same cell contains either term | `error OR warning` → cell has "error" or "warning" |
 | **AND** | `term1 AND term2` | Same cell contains both terms | `user AND admin` → cell has both words |
 | **ROR** | `term1 ROR term2` | Keeps all rows matching any term | `high ROR critical` → rows with "high" + rows with "critical" |
+| **>** | `>value` | Numeric: greater than (number columns only) | `>30` → values greater than 30 |
+| **<** | `<value` | Numeric: less than (number columns only) | `<50` → values less than 50 |
+| **>=** | `>=value` | Numeric: greater than or equal (number columns only) | `>=100` → values 100 or more |
+| **<=** | `<=value` | Numeric: less than or equal (number columns only) | `<=75` → values 75 or less |
 
 **Key Differences:**
 - **OR vs ROR**: OR checks if a single cell contains either term. ROR combines rows where any cell matches any term (row-level union).
-- All operators must be **UPPERCASE** and surrounded by spaces
-- Search terms are case-insensitive
-- All matching is partial (substring)
+- **Numeric operators** (`>`, `<`, `>=`, `<=`): Only work on numeric and date columns (automatically detected). Perform numeric comparisons instead of text matching.
+- All operators must be **UPPERCASE** and surrounded by spaces (except numeric operators)
+- Search terms are case-insensitive (except numeric comparisons)
+- All matching is partial (substring) for text, exact comparison for numeric operators
 - **Visual indicator**: Filtered column headers show 🔎 icons and orange background
 
 **Examples:**
@@ -371,11 +376,28 @@ Navigate to "Description" column → f → type "user AND admin" → Enter
 Navigate to "Priority" column → f → type "high ROR critical" → Enter
 # Result: All rows with "high" + all rows with "critical" (union)
 
+# Numeric comparison - greater than
+Navigate to "Age" column → f → type ">30" → Enter
+# Result: Rows where Age is greater than 30
+
+# Numeric comparison - less than or equal
+Navigate to "Score" column → f → type "<=85" → Enter
+# Result: Rows where Score is 85 or less
+
+# Numeric comparison - greater than or equal
+Navigate to "Salary" column → f → type ">=50000" → Enter
+# Result: Rows where Salary is 50000 or more
+
 # Multi-column filtering
 Navigate to "City" column → f → type "New York" → Enter
 Navigate to "Department" column → f → type "Engineering" → Enter
 # Result: Rows where City="New York" AND Department contains "Engineering"
 
+# Multi-column with numeric filter
+Navigate to "Age" column → f → type ">25" → Enter
+Navigate to "Score" column → f → type ">80" → Enter
+# Result: Rows where Age > 25 AND Score > 80
+
 # Edit existing filter
 Navigate to filtered column → f → modify text → Enter
 # Or enter empty text to remove that column's filter
@@ -393,6 +415,7 @@ Navigate to each filtered column → Press r on each
 - Use **OR** when a single field can have alternative values
 - Use **AND** when a single field must meet multiple criteria
 - Use **ROR** when you want to combine different categories of results
+- Use **numeric operators** (`>`, `<`, `>=`, `<=`) to filter by numeric ranges on number or date columns
 - Use **multi-column filters** to narrow down data by multiple dimensions (e.g., location AND department AND status)
 
 **Visual Feedback:**

buffer.go

@@ -575,6 +575,12 @@ func (b *Buffer) filterByColumn(colIndex int, query string, caseSensitive bool)
 		return filtered
 	}
 
+	// Get column type for numeric comparisons
+	colType := colTypeStr
+	if colIndex < len(b.colType) {
+		colType = b.colType[colIndex]
+	}
+
 	// Filter data rows for OR/AND/simple filters
 	startRow := b.rowFreeze
 	for i := startRow; i < b.rowLen; i++ {
@@ -585,7 +591,7 @@ func (b *Buffer) filterByColumn(colIndex int, query string, caseSensitive bool)
 		cellValue := b.cont[i][colIndex]
 
 		// Evaluate filter condition
-		if evaluateFilter(cellValue, query, caseSensitive, hasOR, hasAND) {
+		if evaluateFilter(cellValue, query, caseSensitive, hasOR, hasAND, colType) {
 			filtered.cont = append(filtered.cont, b.cont[i])
 			filtered.rowLen++
 		}
@@ -595,8 +601,45 @@ func (b *Buffer) filterByColumn(colIndex int, query string, caseSensitive bool)
 }
 
 // evaluateFilter checks if a cell value matches the filter query
-// Supports simple matching, OR logic, and AND logic
-func evaluateFilter(cellValue, query string, caseSensitive, hasOR, hasAND bool) bool {
+// Supports simple matching, OR logic, AND logic, and numeric comparisons (>, <, >=, <=)
+func evaluateFilter(cellValue, query string, caseSensitive, hasOR, hasAND bool, colType int) bool {
+	// Check for numeric comparison operators (>, <, >=, <=) for numeric columns
+	if colType == colTypeFloat || colType == colTypeDate {
+		query = trimSpace(query)
+		
+		// Check for >= operator
+		if len(query) >= 2 && query[0] == '>' && query[1] == '=' {
+			threshold := trimSpace(query[2:])
+			cellVal := parseNumericValueFast(cellValue)
+			thresholdVal := parseNumericValueFast(threshold)
+			return cellVal >= thresholdVal
+		}
+		
+		// Check for <= operator
+		if len(query) >= 2 && query[0] == '<' && query[1] == '=' {
+			threshold := trimSpace(query[2:])
+			cellVal := parseNumericValueFast(cellValue)
+			thresholdVal := parseNumericValueFast(threshold)
+			return cellVal <= thresholdVal
+		}
+		
+		// Check for > operator
+		if len(query) >= 1 && query[0] == '>' {
+			threshold := trimSpace(query[1:])
+			cellVal := parseNumericValueFast(cellValue)
+			thresholdVal := parseNumericValueFast(threshold)
+			return cellVal > thresholdVal
+		}
+		
+		// Check for < operator
+		if len(query) >= 1 && query[0] == '<' {
+			threshold := trimSpace(query[1:])
+			cellVal := parseNumericValueFast(cellValue)
+			thresholdVal := parseNumericValueFast(threshold)
+			return cellVal < thresholdVal
+		}
+	}
+	
 	// Handle OR operator (takes precedence)
 	if hasOR {
 		// Split by OR (uppercase only)

filter_test.go

@@ -285,3 +285,152 @@ func TestBuffer_filterByColumn_EdgeCases(t *testing.T) {
 		}
 	})
 }
+
+func TestBuffer_filterByColumn_NumericComparison(t *testing.T) {
+	tests := []struct {
+		name         string
+		data         [][]string
+		colIndex     int
+		query        string
+		expectedRows int // including header
+	}{
+		{
+			name: "Filter > operator",
+			data: [][]string{
+				{"Name", "Age", "Score"},
+				{"Alice", "30", "85"},
+				{"Bob", "25", "90"},
+				{"Charlie", "35", "78"},
+				{"David", "28", "92"},
+			},
+			colIndex:     1, // Age column
+			query:        ">28",
+			expectedRows: 3, // header + Alice (30), Charlie (35)
+		},
+		{
+			name: "Filter < operator",
+			data: [][]string{
+				{"Name", "Age", "Score"},
+				{"Alice", "30", "85"},
+				{"Bob", "25", "90"},
+				{"Charlie", "35", "78"},
+				{"David", "28", "92"},
+			},
+			colIndex:     1, // Age column
+			query:        "<30",
+			expectedRows: 3, // header + Bob (25), David (28)
+		},
+		{
+			name: "Filter >= operator",
+			data: [][]string{
+				{"Name", "Age", "Score"},
+				{"Alice", "30", "85"},
+				{"Bob", "25", "90"},
+				{"Charlie", "35", "78"},
+				{"David", "28", "92"},
+			},
+			colIndex:     1, // Age column
+			query:        ">=30",
+			expectedRows: 3, // header + Alice (30), Charlie (35)
+		},
+		{
+			name: "Filter <= operator",
+			data: [][]string{
+				{"Name", "Age", "Score"},
+				{"Alice", "30", "85"},
+				{"Bob", "25", "90"},
+				{"Charlie", "35", "78"},
+				{"David", "28", "92"},
+			},
+			colIndex:     1, // Age column
+			query:        "<=28",
+			expectedRows: 3, // header + Bob (25), David (28)
+		},
+		{
+			name: "Filter > with decimals",
+			data: [][]string{
+				{"Name", "Score"},
+				{"Alice", "85.5"},
+				{"Bob", "90.2"},
+				{"Charlie", "78.8"},
+				{"David", "92.1"},
+			},
+			colIndex:     1, // Score column
+			query:        ">85",
+			expectedRows: 4, // header + Alice (85.5), Bob (90.2), David (92.1)
+		},
+		{
+			name: "Filter < with decimals",
+			data: [][]string{
+				{"Name", "Score"},
+				{"Alice", "85.5"},
+				{"Bob", "90.2"},
+				{"Charlie", "78.8"},
+				{"David", "92.1"},
+			},
+			colIndex:     1, // Score column
+			query:        "<85",
+			expectedRows: 2, // header + Charlie (78.8)
+		},
+		{
+			name: "Filter > on string column (should not match)",
+			data: [][]string{
+				{"Name", "Status"},
+				{"Alice", "Active"},
+				{"Bob", "Inactive"},
+				{"Charlie", "Pending"},
+			},
+			colIndex:     1, // Status column (string type)
+			query:        ">5",
+			expectedRows: 1, // header only (string column, no numeric comparison)
+		},
+		{
+			name: "Filter > with spaces",
+			data: [][]string{
+				{"Name", "Age"},
+				{"Alice", "30"},
+				{"Bob", "25"},
+				{"Charlie", "35"},
+			},
+			colIndex:     1, // Age column
+			query:        "> 28",
+			expectedRows: 3, // header + Alice (30), Charlie (35)
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create buffer with test data
+			b, err := createNewBufferWithData(tt.data, false)
+			if err != nil {
+				t.Fatalf("Failed to create buffer: %v", err)
+			}
+			b.rowFreeze = 1 // Set header row
+			
+			// Detect column types
+			b.detectAllColumnTypes()
+
+			// Apply filter
+			filtered := b.filterByColumn(tt.colIndex, tt.query, false)
+
+			// Check result
+			if filtered.rowLen != tt.expectedRows {
+				t.Errorf("Expected %d rows (including header), got %d", tt.expectedRows, filtered.rowLen)
+				// Print actual data for debugging
+				t.Logf("Actual rows:")
+				for i := 0; i < filtered.rowLen; i++ {
+					t.Logf("  Row %d: %v", i, filtered.cont[i])
+				}
+			}
+
+			// Verify header is preserved
+			if filtered.rowLen > 0 {
+				for col := 0; col < filtered.colLen && col < len(tt.data[0]); col++ {
+					if filtered.cont[0][col] != tt.data[0][col] {
+						t.Errorf("Header not preserved: expected %s, got %s", tt.data[0][col], filtered.cont[0][col])
+					}
+				}
+			}
+		})
+	}
+}