lsm/seaweedfs
1
0
Fork 0
mirror of https://github.com/seaweedfs/seaweedfs.git synced 2025-09-20 10:09:24 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: Add mathematical functions ROUND, CEIL, FLOOR, ABS with comprehensive tests

Browse Source 
- Implement ROUND with optional precision parameter
- Add CEIL function for rounding up to nearest integer
- Add FLOOR function for rounding down to nearest integer
- Add ABS function for absolute values with type preservation
- Support all numeric types (int32, int64, float32, double)
- Comprehensive test suite with 20+ test cases covering:
  - Positive/negative numbers
  - Integer/float type preservation
  - Precision handling for ROUND
  - Null value error handling
  - Edge cases (zero, large numbers)

All tests passing ✅
This commit is contained in:
chrislu
2025-09-04 00:14:51 -07:00
parent 32bd48ffb8
commit cc3ac76304
2 changed files with 381 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

271
weed/query/engine/sql_functions_test.go
View File

@@ -257,3 +257,274 @@ func valuesEqual(v1, v2 *schema_pb.Value) bool {
return false
}
func TestMathematicalFunctions(t *testing.T) {
engine := NewTestSQLEngine()
t.Run("ROUND function tests", func(t *testing.T) {
tests := []struct {
name string
value *schema_pb.Value
precision *schema_pb.Value
expected *schema_pb.Value
expectErr bool
}{
{
name: "Round float to integer",
value: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: 3.7}},
precision: nil,
expected: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: 4.0}},
expectErr: false,
},
{
name: "Round integer stays integer",
value: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 5}},
precision: nil,
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 5}},
expectErr: false,
},
{
name: "Round with precision 2",
value: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: 3.14159}},
precision: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 2}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: 3.14}},
expectErr: false,
},
{
name: "Round negative number",
value: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: -3.7}},
precision: nil,
expected: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: -4.0}},
expectErr: false,
},
{
name: "Round null value",
value: nil,
precision: nil,
expected: nil,
expectErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var result *schema_pb.Value
var err error
if tt.precision != nil {
result, err = engine.Round(tt.value, tt.precision)
} else {
result, err = engine.Round(tt.value)
}
if tt.expectErr {
if err == nil {
t.Errorf("Expected error but got none")
}
return
}
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
if !valuesEqual(result, tt.expected) {
t.Errorf("Expected %v, got %v", tt.expected, result)
}
})
}
})
t.Run("CEIL function tests", func(t *testing.T) {
tests := []struct {
name string
value *schema_pb.Value
expected *schema_pb.Value
expectErr bool
}{
{
name: "Ceil positive decimal",
value: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: 3.2}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 4}},
expectErr: false,
},
{
name: "Ceil negative decimal",
value: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: -3.2}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: -3}},
expectErr: false,
},
{
name: "Ceil integer",
value: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 5}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 5}},
expectErr: false,
},
{
name: "Ceil null value",
value: nil,
expected: nil,
expectErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := engine.Ceil(tt.value)
if tt.expectErr {
if err == nil {
t.Errorf("Expected error but got none")
}
return
}
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
if !valuesEqual(result, tt.expected) {
t.Errorf("Expected %v, got %v", tt.expected, result)
}
})
}
})
t.Run("FLOOR function tests", func(t *testing.T) {
tests := []struct {
name string
value *schema_pb.Value
expected *schema_pb.Value
expectErr bool
}{
{
name: "Floor positive decimal",
value: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: 3.8}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 3}},
expectErr: false,
},
{
name: "Floor negative decimal",
value: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: -3.2}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: -4}},
expectErr: false,
},
{
name: "Floor integer",
value: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 5}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 5}},
expectErr: false,
},
{
name: "Floor null value",
value: nil,
expected: nil,
expectErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := engine.Floor(tt.value)
if tt.expectErr {
if err == nil {
t.Errorf("Expected error but got none")
}
return
}
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
if !valuesEqual(result, tt.expected) {
t.Errorf("Expected %v, got %v", tt.expected, result)
}
})
}
})
t.Run("ABS function tests", func(t *testing.T) {
tests := []struct {
name string
value *schema_pb.Value
expected *schema_pb.Value
expectErr bool
}{
{
name: "Abs positive integer",
value: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 5}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 5}},
expectErr: false,
},
{
name: "Abs negative integer",
value: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: -5}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 5}},
expectErr: false,
},
{
name: "Abs positive double",
value: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: 3.14}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: 3.14}},
expectErr: false,
},
{
name: "Abs negative double",
value: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: -3.14}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_DoubleValue{DoubleValue: 3.14}},
expectErr: false,
},
{
name: "Abs positive float",
value: &schema_pb.Value{Kind: &schema_pb.Value_FloatValue{FloatValue: 2.5}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_FloatValue{FloatValue: 2.5}},
expectErr: false,
},
{
name: "Abs negative float",
value: &schema_pb.Value{Kind: &schema_pb.Value_FloatValue{FloatValue: -2.5}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_FloatValue{FloatValue: 2.5}},
expectErr: false,
},
{
name: "Abs zero",
value: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 0}},
expected: &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: 0}},
expectErr: false,
},
{
name: "Abs null value",
value: nil,
expected: nil,
expectErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := engine.Abs(tt.value)
if tt.expectErr {
if err == nil {
t.Errorf("Expected error but got none")
}
return
}
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
if !valuesEqual(result, tt.expected) {
t.Errorf("Expected %v, got %v", tt.expected, result)
}
})
}
})
}