2 changed files with 486 additions and 3 deletions
@ -0,0 +1,245 @@ |
|||
package engine |
|||
|
|||
import ( |
|||
"testing" |
|||
|
|||
"github.com/seaweedfs/seaweedfs/weed/pb/schema_pb" |
|||
) |
|||
|
|||
func TestArithmeticExpressionParsing(t *testing.T) { |
|||
tests := []struct { |
|||
name string |
|||
expression string |
|||
expectNil bool |
|||
leftCol string |
|||
rightCol string |
|||
operator string |
|||
}{ |
|||
{ |
|||
name: "simple addition", |
|||
expression: "id+user_id", |
|||
expectNil: false, |
|||
leftCol: "id", |
|||
rightCol: "user_id", |
|||
operator: "+", |
|||
}, |
|||
{ |
|||
name: "simple subtraction", |
|||
expression: "col1-col2", |
|||
expectNil: false, |
|||
leftCol: "col1", |
|||
rightCol: "col2", |
|||
operator: "-", |
|||
}, |
|||
{ |
|||
name: "multiplication with spaces", |
|||
expression: "a * b", |
|||
expectNil: false, |
|||
leftCol: "a", |
|||
rightCol: "b", |
|||
operator: "*", |
|||
}, |
|||
{ |
|||
name: "string concatenation", |
|||
expression: "first_name||last_name", |
|||
expectNil: false, |
|||
leftCol: "first_name", |
|||
rightCol: "last_name", |
|||
operator: "||", |
|||
}, |
|||
{ |
|||
name: "string concatenation with spaces", |
|||
expression: "prefix || suffix", |
|||
expectNil: false, |
|||
leftCol: "prefix", |
|||
rightCol: "suffix", |
|||
operator: "||", |
|||
}, |
|||
{ |
|||
name: "not arithmetic", |
|||
expression: "simple_column", |
|||
expectNil: true, |
|||
}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
result := parseArithmeticExpression(tt.expression) |
|||
|
|||
if tt.expectNil { |
|||
if result != nil { |
|||
t.Errorf("Expected nil for %s, got %v", tt.expression, result) |
|||
} |
|||
return |
|||
} |
|||
|
|||
if result == nil { |
|||
t.Errorf("Expected arithmetic expression for %s, got nil", tt.expression) |
|||
return |
|||
} |
|||
|
|||
if result.Operator != tt.operator { |
|||
t.Errorf("Expected operator %s, got %s", tt.operator, result.Operator) |
|||
} |
|||
|
|||
// Check left operand
|
|||
if leftCol, ok := result.Left.(*ColName); ok { |
|||
if leftCol.Name.String() != tt.leftCol { |
|||
t.Errorf("Expected left column %s, got %s", tt.leftCol, leftCol.Name.String()) |
|||
} |
|||
} else { |
|||
t.Errorf("Expected left operand to be ColName, got %T", result.Left) |
|||
} |
|||
|
|||
// Check right operand
|
|||
if rightCol, ok := result.Right.(*ColName); ok { |
|||
if rightCol.Name.String() != tt.rightCol { |
|||
t.Errorf("Expected right column %s, got %s", tt.rightCol, rightCol.Name.String()) |
|||
} |
|||
} else { |
|||
t.Errorf("Expected right operand to be ColName, got %T", result.Right) |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
func TestArithmeticExpressionEvaluation(t *testing.T) { |
|||
engine := NewSQLEngine("") |
|||
|
|||
// Create test data
|
|||
result := HybridScanResult{ |
|||
Values: map[string]*schema_pb.Value{ |
|||
"id": {Kind: &schema_pb.Value_Int64Value{Int64Value: 10}}, |
|||
"user_id": {Kind: &schema_pb.Value_Int64Value{Int64Value: 5}}, |
|||
"price": {Kind: &schema_pb.Value_DoubleValue{DoubleValue: 25.5}}, |
|||
"qty": {Kind: &schema_pb.Value_Int64Value{Int64Value: 3}}, |
|||
"first_name": {Kind: &schema_pb.Value_StringValue{StringValue: "John"}}, |
|||
"last_name": {Kind: &schema_pb.Value_StringValue{StringValue: "Doe"}}, |
|||
"prefix": {Kind: &schema_pb.Value_StringValue{StringValue: "Hello"}}, |
|||
"suffix": {Kind: &schema_pb.Value_StringValue{StringValue: "World"}}, |
|||
}, |
|||
} |
|||
|
|||
tests := []struct { |
|||
name string |
|||
expression string |
|||
expected interface{} |
|||
}{ |
|||
{ |
|||
name: "integer addition", |
|||
expression: "id+user_id", |
|||
expected: int64(15), |
|||
}, |
|||
{ |
|||
name: "integer subtraction", |
|||
expression: "id-user_id", |
|||
expected: int64(5), |
|||
}, |
|||
{ |
|||
name: "mixed types multiplication", |
|||
expression: "price*qty", |
|||
expected: float64(76.5), |
|||
}, |
|||
{ |
|||
name: "string concatenation", |
|||
expression: "first_name||last_name", |
|||
expected: "JohnDoe", |
|||
}, |
|||
{ |
|||
name: "string concatenation with spaces", |
|||
expression: "prefix || suffix", |
|||
expected: "HelloWorld", |
|||
}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
// Parse the arithmetic expression
|
|||
arithmeticExpr := parseArithmeticExpression(tt.expression) |
|||
if arithmeticExpr == nil { |
|||
t.Fatalf("Failed to parse arithmetic expression: %s", tt.expression) |
|||
} |
|||
|
|||
// Evaluate the expression
|
|||
value, err := engine.evaluateArithmeticExpression(arithmeticExpr, result) |
|||
if err != nil { |
|||
t.Fatalf("Failed to evaluate expression: %v", err) |
|||
} |
|||
|
|||
if value == nil { |
|||
t.Fatalf("Got nil value for expression: %s", tt.expression) |
|||
} |
|||
|
|||
// Check the result
|
|||
switch expected := tt.expected.(type) { |
|||
case int64: |
|||
if intVal, ok := value.Kind.(*schema_pb.Value_Int64Value); ok { |
|||
if intVal.Int64Value != expected { |
|||
t.Errorf("Expected %d, got %d", expected, intVal.Int64Value) |
|||
} |
|||
} else { |
|||
t.Errorf("Expected int64 result, got %T", value.Kind) |
|||
} |
|||
case float64: |
|||
if doubleVal, ok := value.Kind.(*schema_pb.Value_DoubleValue); ok { |
|||
if doubleVal.DoubleValue != expected { |
|||
t.Errorf("Expected %f, got %f", expected, doubleVal.DoubleValue) |
|||
} |
|||
} else { |
|||
t.Errorf("Expected double result, got %T", value.Kind) |
|||
} |
|||
case string: |
|||
if stringVal, ok := value.Kind.(*schema_pb.Value_StringValue); ok { |
|||
if stringVal.StringValue != expected { |
|||
t.Errorf("Expected %s, got %s", expected, stringVal.StringValue) |
|||
} |
|||
} else { |
|||
t.Errorf("Expected string result, got %T", value.Kind) |
|||
} |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
func TestSelectArithmeticExpression(t *testing.T) { |
|||
// Test parsing a SELECT with arithmetic and string concatenation expressions
|
|||
stmt, err := ParseSQL("SELECT id+user_id, user_id*2, first_name||last_name FROM test_table") |
|||
if err != nil { |
|||
t.Fatalf("Failed to parse SQL: %v", err) |
|||
} |
|||
|
|||
selectStmt := stmt.(*SelectStatement) |
|||
if len(selectStmt.SelectExprs) != 3 { |
|||
t.Fatalf("Expected 3 select expressions, got %d", len(selectStmt.SelectExprs)) |
|||
} |
|||
|
|||
// Check first expression (id+user_id)
|
|||
aliasedExpr1 := selectStmt.SelectExprs[0].(*AliasedExpr) |
|||
if arithmeticExpr1, ok := aliasedExpr1.Expr.(*ArithmeticExpr); ok { |
|||
if arithmeticExpr1.Operator != "+" { |
|||
t.Errorf("Expected + operator, got %s", arithmeticExpr1.Operator) |
|||
} |
|||
} else { |
|||
t.Errorf("Expected arithmetic expression, got %T", aliasedExpr1.Expr) |
|||
} |
|||
|
|||
// Check second expression (user_id*2)
|
|||
aliasedExpr2 := selectStmt.SelectExprs[1].(*AliasedExpr) |
|||
if arithmeticExpr2, ok := aliasedExpr2.Expr.(*ArithmeticExpr); ok { |
|||
if arithmeticExpr2.Operator != "*" { |
|||
t.Errorf("Expected * operator, got %s", arithmeticExpr2.Operator) |
|||
} |
|||
} else { |
|||
t.Errorf("Expected arithmetic expression, got %T", aliasedExpr2.Expr) |
|||
} |
|||
|
|||
// Check third expression (first_name||last_name)
|
|||
aliasedExpr3 := selectStmt.SelectExprs[2].(*AliasedExpr) |
|||
if arithmeticExpr3, ok := aliasedExpr3.Expr.(*ArithmeticExpr); ok { |
|||
if arithmeticExpr3.Operator != "||" { |
|||
t.Errorf("Expected || operator, got %s", arithmeticExpr3.Operator) |
|||
} |
|||
} else { |
|||
t.Errorf("Expected string concatenation expression, got %T", aliasedExpr3.Expr) |
|||
} |
|||
} |
Write
Preview
Loading…
Cancel
Save
Reference in new issue