Skip to content

Commit 9a30626

Browse files
lixingwanglixingwang
authored
Merge pull request #246 from TIBCOSoftware/issue-245
Fixed #245, convert int to float once there is int comparing with float.
2 parents c1d22d5 + 28991b6 commit 9a30626

File tree

2 files changed

+247
-69
lines changed

2 files changed

+247
-69
lines changed

‎core/mapper/exprmapper/expression/expr/expr.go

+204-69
Original file line numberDiff line numberDiff line change
@@ -348,6 +348,7 @@ func (f *Expression) run(left interface{}, op OPERATIOR, right interface{}) (int
348348
case MULTIPLICATION:
349349
return multiplication(left, right)
350350
case DIVISION:
351+
//TODO
351352
return div(left, right)
352353
case INT_DIVISTION:
353354
//TODO....
@@ -398,17 +399,34 @@ func ConvertToSameType(left interface{}, right interface{}) (interface{}, interf
398399
var err error
399400
switch t := left.(type) {
400401
case int:
401-
rightValue, err = data.CoerceToInteger(right)
402-
if err != nil {
403-
err = fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
402+
if isDoubleType(right) {
403+
leftValue, err = data.CoerceToDouble(left)
404+
if err != nil {
405+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
406+
}
407+
rightValue = right
408+
} else {
409+
rightValue, err = data.CoerceToInteger(right)
410+
if err != nil {
411+
err = fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
412+
}
413+
leftValue = t
404414
}
405-
leftValue = t
415+
406416
case int64:
407-
rightValue, err = data.CoerceToInteger(right)
408-
if err != nil {
409-
err = fmt.Errorf("Convert right expression to type int64 failed, due to %s", err.Error())
417+
if isDoubleType(right) {
418+
leftValue, err = data.CoerceToDouble(left)
419+
if err != nil {
420+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
421+
}
422+
rightValue = right
423+
} else {
424+
rightValue, err = data.CoerceToInteger(right)
425+
if err != nil {
426+
err = fmt.Errorf("Convert right expression to type int64 failed, due to %s", err.Error())
427+
}
428+
leftValue = t
410429
}
411-
leftValue = t
412430
case float64:
413431
rightValue, err = data.CoerceToNumber(right)
414432
if err != nil {
@@ -483,28 +501,59 @@ func gt(left interface{}, right interface{}, includeEquals bool) (bool, error) {
483501
rightType := getType(right)
484502
switch le := left.(type) {
485503
case int:
486-
//We should conver to int first
487-
rightValue, err := data.CoerceToInteger(right)
488-
if err != nil {
489-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
490-
}
491-
if includeEquals {
492-
return le >= rightValue, nil
504+
//For int float compare, convert int to float to compare
505+
if isDoubleType(right) {
506+
leftValue, err := data.CoerceToDouble(left)
507+
if err != nil {
508+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
509+
}
510+
rightValue := right.(float64)
511+
if includeEquals {
512+
return leftValue >= rightValue, nil
513+
514+
} else {
515+
return leftValue > rightValue, nil
516+
}
493517

494518
} else {
495-
return le > rightValue, nil
519+
//We should conver to int first
520+
rightValue, err := data.CoerceToInteger(right)
521+
if err != nil {
522+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
523+
}
524+
if includeEquals {
525+
return le >= rightValue, nil
526+
527+
} else {
528+
return le > rightValue, nil
529+
}
496530
}
497531

498532
case int64:
499-
rightValue, err := data.CoerceToInteger(right)
500-
if err != nil {
501-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
502-
}
503-
if includeEquals {
504-
return int(le) >= rightValue, nil
533+
if isDoubleType(right) {
534+
leftValue, err := data.CoerceToDouble(left)
535+
if err != nil {
536+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
537+
}
538+
rightValue := right.(float64)
539+
if includeEquals {
540+
return leftValue >= rightValue, nil
541+
542+
} else {
543+
return leftValue > rightValue, nil
544+
}
505545

506546
} else {
507-
return int(le) > rightValue, nil
547+
rightValue, err := data.CoerceToInteger(right)
548+
if err != nil {
549+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
550+
}
551+
if includeEquals {
552+
return int(le) >= rightValue, nil
553+
554+
} else {
555+
return int(le) > rightValue, nil
556+
}
508557
}
509558
case float64:
510559
rightValue, err := data.CoerceToNumber(right)
@@ -555,26 +604,54 @@ func lt(left interface{}, right interface{}, includeEquals bool) (bool, error) {
555604

556605
switch le := left.(type) {
557606
case int:
558-
rightValue, err := data.CoerceToInteger(right)
559-
if err != nil {
560-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
561-
}
562-
if includeEquals {
563-
return le <= rightValue, nil
564-
607+
if isDoubleType(right) {
608+
leftValue, err := data.CoerceToDouble(left)
609+
if err != nil {
610+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
611+
}
612+
rightValue := right.(float64)
613+
if includeEquals {
614+
return leftValue <= rightValue, nil
615+
616+
} else {
617+
return leftValue < rightValue, nil
618+
}
565619
} else {
566-
return le < rightValue, nil
620+
rightValue, err := data.CoerceToInteger(right)
621+
if err != nil {
622+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
623+
}
624+
if includeEquals {
625+
return le <= rightValue, nil
626+
627+
} else {
628+
return le < rightValue, nil
629+
}
567630
}
568631
case int64:
569-
rightValue, err := data.CoerceToInteger(right)
570-
if err != nil {
571-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
572-
}
573-
if includeEquals {
574-
return int(le) <= rightValue, nil
575-
632+
if isDoubleType(right) {
633+
leftValue, err := data.CoerceToDouble(left)
634+
if err != nil {
635+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
636+
}
637+
rightValue := right.(float64)
638+
if includeEquals {
639+
return leftValue <= rightValue, nil
640+
641+
} else {
642+
return leftValue < rightValue, nil
643+
}
576644
} else {
577-
return int(le) < rightValue, nil
645+
rightValue, err := data.CoerceToInteger(right)
646+
if err != nil {
647+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
648+
}
649+
if includeEquals {
650+
return int(le) <= rightValue, nil
651+
652+
} else {
653+
return int(le) < rightValue, nil
654+
}
578655
}
579656
case float64:
580657
rightValue, err := data.CoerceToNumber(right)
@@ -660,20 +737,37 @@ func additon(left interface{}, right interface{}) (interface{}, error) {
660737

661738
switch le := left.(type) {
662739
case int:
663-
rightValue, err := data.CoerceToInteger(right)
664-
if err != nil {
665-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
666-
}
740+
if isDoubleType(right) {
741+
leftValue, err := data.CoerceToDouble(left)
742+
if err != nil {
743+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
744+
}
745+
rightValue := right.(float64)
746+
return leftValue + rightValue, nil
747+
} else {
748+
rightValue, err := data.CoerceToInteger(right)
749+
if err != nil {
750+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
751+
}
667752

668-
return le + rightValue, nil
753+
return le + rightValue, nil
754+
}
669755

670756
case int64:
671-
rightValue, err := data.CoerceToInteger(right)
672-
if err != nil {
673-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
757+
if isDoubleType(right) {
758+
leftValue, err := data.CoerceToDouble(left)
759+
if err != nil {
760+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
761+
}
762+
rightValue := right.(float64)
763+
return leftValue + rightValue, nil
764+
} else {
765+
rightValue, err := data.CoerceToInteger(right)
766+
if err != nil {
767+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
768+
}
769+
return int(le) + rightValue, nil
674770
}
675-
676-
return int(le) + rightValue, nil
677771
case float64:
678772
rightValue, err := data.CoerceToNumber(right)
679773
if err != nil {
@@ -712,19 +806,35 @@ func sub(left interface{}, right interface{}) (interface{}, error) {
712806

713807
switch le := left.(type) {
714808
case int:
715-
rightValue, err := data.CoerceToInteger(right)
716-
if err != nil {
717-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
809+
if isDoubleType(right) {
810+
leftValue, err := data.CoerceToDouble(left)
811+
if err != nil {
812+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
813+
}
814+
rightValue := right.(float64)
815+
return leftValue - rightValue, nil
816+
} else {
817+
rightValue, err := data.CoerceToInteger(right)
818+
if err != nil {
819+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
820+
}
821+
return le - rightValue, nil
718822
}
719-
720-
return le - rightValue, nil
721823
case int64:
722-
rightValue, err := data.CoerceToInteger(right)
723-
if err != nil {
724-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
824+
if isDoubleType(right) {
825+
leftValue, err := data.CoerceToDouble(left)
826+
if err != nil {
827+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
828+
}
829+
rightValue := right.(float64)
830+
return leftValue - rightValue, nil
831+
} else {
832+
rightValue, err := data.CoerceToInteger(right)
833+
if err != nil {
834+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
835+
}
836+
return int(le) - rightValue, nil
725837
}
726-
727-
return int(le) - rightValue, nil
728838
case float64:
729839
rightValue, err := data.CoerceToNumber(right)
730840
if err != nil {
@@ -764,19 +874,36 @@ func multiplication(left interface{}, right interface{}) (interface{}, error) {
764874

765875
switch le := left.(type) {
766876
case int:
767-
rightValue, err := data.CoerceToInteger(right)
768-
if err != nil {
769-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
877+
if isDoubleType(right) {
878+
leftValue, err := data.CoerceToDouble(left)
879+
if err != nil {
880+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
881+
}
882+
rightValue := right.(float64)
883+
return leftValue * rightValue, nil
884+
} else {
885+
rightValue, err := data.CoerceToInteger(right)
886+
if err != nil {
887+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
888+
}
889+
return le * rightValue, nil
770890
}
771-
772-
return le * rightValue, nil
773891
case int64:
774-
rightValue, err := data.CoerceToInteger(right)
775-
if err != nil {
776-
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
777-
}
892+
if isDoubleType(right) {
893+
leftValue, err := data.CoerceToDouble(left)
894+
if err != nil {
895+
err = fmt.Errorf("Convert left expression to type float64 failed, due to %s", err.Error())
896+
}
897+
rightValue := right.(float64)
898+
return leftValue * rightValue, nil
899+
} else {
900+
rightValue, err := data.CoerceToInteger(right)
901+
if err != nil {
902+
return false, fmt.Errorf("Convert right expression to type int failed, due to %s", err.Error())
903+
}
778904

779-
return int(le) * rightValue, nil
905+
return int(le) * rightValue, nil
906+
}
780907
case float64:
781908
rightValue, err := data.CoerceToNumber(right)
782909
if err != nil {
@@ -855,3 +982,11 @@ func div(left interface{}, right interface{}) (interface{}, error) {
855982
func getType(in interface{}) reflect.Type {
856983
return reflect.TypeOf(in)
857984
}
985+
986+
func isDoubleType(in interface{}) bool {
987+
switch in.(type) {
988+
case float64:
989+
return true
990+
}
991+
return false
992+
}

‎core/mapper/exprmapper/expression/expression_test.go

+43
Original file line numberDiff line numberDiff line change
@@ -804,6 +804,49 @@ func TestExpressionWithNegtiveNumber(t *testing.T) {
804804
assert.Equal(t, true, v)
805805
}
806806

807+
func TestFloatWithInt(t *testing.T) {
808+
expr, _ := ParseExpression("1 == 1.23")
809+
fmt.Println(fmt.Sprintf("%+v", expr))
810+
i, err := expr.Eval()
811+
if err != nil {
812+
t.Fatalf("error %s\n", err)
813+
}
814+
res := i.(bool)
815+
if res {
816+
t.Errorf("Expected false, got : %t\n ", res)
817+
}
818+
819+
expr, _ = ParseExpression("1 < 1.23")
820+
i, err = expr.Eval()
821+
if err != nil {
822+
t.Fatalf("error %s\n", err)
823+
}
824+
res = i.(bool)
825+
if !res {
826+
t.Errorf("Expected true, got : %t\n ", res)
827+
}
828+
829+
expr, _ = ParseExpression("1.23 == 1")
830+
i, err = expr.Eval()
831+
if err != nil {
832+
t.Fatalf("error %s\n", err)
833+
}
834+
res = i.(bool)
835+
if res {
836+
t.Errorf("Expected false, got : %t\n ", res)
837+
}
838+
839+
expr, _ = ParseExpression("1.23 > 1")
840+
i, err = expr.Eval()
841+
if err != nil {
842+
t.Fatalf("error %s\n", err)
843+
}
844+
res = i.(bool)
845+
if !res {
846+
t.Errorf("Expected true, got : %t\n ", res)
847+
}
848+
}
849+
807850
func GetSimpleScope(name, value string) data.Scope {
808851
a, _ := data.NewAttribute(name, data.TypeObject, value)
809852
maps := make(map[string]*data.Attribute)

0 commit comments

Comments
 (0)