Implement cast expressions correctly

src/engine/sparqlExpressions/ConvertToNumericExpression.cpp

@@ -5,11 +5,14 @@
 #include "engine/sparqlExpressions/NaryExpressionImpl.h"
 
 namespace sparqlExpression {
+namespace detail::string_expressions {
+class StrExpressionImpl;
+}
 namespace detail::to_numeric {
 
 // class that converts an input `int64_t`, `double` or `std::string`
 // to a numeric value `int64_t` or `double`
-template <typename T>
+template <typename T, bool AllowExponentialNotation = true>
 requires std::same_as<int64_t, T> || std::same_as<double, T>
 class ToNumericImpl {
  private:
@@ -24,7 +27,14 @@ class ToNumericImpl {
         return Id::makeFromInt(resT);
       }
     } else {
-      auto conv = absl::from_chars(strStart, strEnd, resT);
+      // Abseil doesn't match leading + signs, so we skip them.
+      if (!str.empty() && str.at(0) == '+') {
+        strStart++;
+      }
+      auto conv = absl::from_chars(strStart, strEnd, resT,
+                                   AllowExponentialNotation
+                                       ? absl::chars_format::general
+                                       : absl::chars_format::fixed);
       if (conv.ec == std::error_code{} && conv.ptr == strEnd) {
         return Id::makeFromDouble(resT);
       }
@@ -61,9 +71,38 @@ class ToNumericImpl {
 
 using ToInteger = NARY<1, FV<ToNumericImpl<int64_t>, ToNumericValueGetter>>;
 using ToDouble = NARY<1, FV<ToNumericImpl<double>, ToNumericValueGetter>>;
+using ToDecimal =
+    NARY<1, FV<ToNumericImpl<double, false>, ToNumericValueGetter>>;
 }  // namespace detail::to_numeric
 
+namespace detail::to_boolean {
+class ToBooleanImpl {
+ public:
+  Id operator()(IntDoubleStr value) const {
+    if (std::holds_alternative<std::string>(value)) {
+      const std::string& str = std::get<std::string>(value);
+      if (str == "true" || str == "1") {
+        return Id::makeFromBool(true);
+      }
+      if (str == "false" || str == "0") {
+        return Id::makeFromBool(false);
+      }
+      return Id::makeUndefined();
+    } else if (std::holds_alternative<int64_t>(value)) {
+      return Id::makeFromBool(std::get<int64_t>(value) != 0);
+    } else if (std::holds_alternative<double>(value)) {
+      return Id::makeFromBool(std::get<double>(value) != 0);
+    } else {
+      AD_CORRECTNESS_CHECK(std::holds_alternative<std::monostate>(value));
+      return Id::makeUndefined();
+    }
+  }
+};
+using ToBoolean = NARY<1, FV<ToBooleanImpl, ToNumericValueGetter>>;
+}  // namespace detail::to_boolean
+
 using namespace detail::to_numeric;
+using namespace detail::to_boolean;
 using Expr = SparqlExpression::Ptr;
 
 Expr makeConvertToIntExpression(Expr child) {
@@ -73,4 +112,12 @@ Expr makeConvertToIntExpression(Expr child) {
 Expr makeConvertToDoubleExpression(Expr child) {
   return std::make_unique<ToDouble>(std::move(child));
 }
+
+Expr makeConvertToDecimalExpression(Expr child) {
+  return std::make_unique<ToDecimal>(std::move(child));
+}
+
+Expr makeConvertToBooleanExpression(Expr child) {
+  return std::make_unique<ToBoolean>(std::move(child));
+}
 }  // namespace sparqlExpression

src/engine/sparqlExpressions/NaryExpression.h

@@ -96,6 +96,9 @@ SparqlExpression::Ptr makeSHA256Expression(SparqlExpression::Ptr child);
 SparqlExpression::Ptr makeSHA384Expression(SparqlExpression::Ptr child);
 SparqlExpression::Ptr makeSHA512Expression(SparqlExpression::Ptr child);
 
+SparqlExpression::Ptr makeConvertToStringExpression(
+    SparqlExpression::Ptr child);
+
 SparqlExpression::Ptr makeIfExpression(SparqlExpression::Ptr child1,
                                        SparqlExpression::Ptr child2,
                                        SparqlExpression::Ptr child3);
@@ -104,6 +107,10 @@ SparqlExpression::Ptr makeIfExpression(SparqlExpression::Ptr child1,
 SparqlExpression::Ptr makeConvertToIntExpression(SparqlExpression::Ptr child);
 SparqlExpression::Ptr makeConvertToDoubleExpression(
     SparqlExpression::Ptr child);
+SparqlExpression::Ptr makeConvertToDecimalExpression(
+    SparqlExpression::Ptr child);
+SparqlExpression::Ptr makeConvertToBooleanExpression(
+    SparqlExpression::Ptr child);
 
 // Implemented in RdfTermExpressions.cpp
 SparqlExpression::Ptr makeDatatypeExpression(SparqlExpression::Ptr child);

src/engine/sparqlExpressions/StringExpressions.cpp

@@ -619,4 +619,8 @@ Expr makeSHA384Expression(Expr child) { return make<SHA384Expression>(child); }
 
 Expr makeSHA512Expression(Expr child) { return make<SHA512Expression>(child); }
 
+Expr makeConvertToStringExpression(Expr child) {
+  return std::make_unique<StrExpressionImpl>(std::move(child));
+}
+
 }  // namespace sparqlExpression

src/parser/sparqlParser/SparqlQleverVisitor.cpp

@@ -158,11 +158,28 @@ ExpressionPtr Visitor::processIriFunctionCall(
       checkNumArgs(1);
       return sparqlExpression::makeConvertToIntExpression(
           std::move(argList[0]));
-    } else if (functionName == "double" || functionName == "decimal") {
+    }
+    if (functionName == "decimal") {
+      checkNumArgs(1);
+      return sparqlExpression::makeConvertToDecimalExpression(
+          std::move(argList[0]));
+    }
+    // We currently don't have a float type, so we just convert to double.
+    if (functionName == "double" || functionName == "float") {
       checkNumArgs(1);
       return sparqlExpression::makeConvertToDoubleExpression(
           std::move(argList[0]));
     }
+    if (functionName == "boolean") {
+      checkNumArgs(1);
+      return sparqlExpression::makeConvertToBooleanExpression(
+          std::move(argList[0]));
+    }
+    if (functionName == "string") {
+      checkNumArgs(1);
+      return sparqlExpression::makeConvertToStringExpression(
+          std::move(argList[0]));
+    }
   }
 
   // QLever-internal functions.

test/SparqlAntlrParserTest.cpp

@@ -1799,7 +1799,7 @@ TEST(SparqlParser, FunctionCall) {
   expectFunctionCall(absl::StrCat(xsd, "double>(?x)"),
                      matchUnary(&makeConvertToDoubleExpression));
   expectFunctionCall(absl::StrCat(xsd, "decimal>(?x)"),
-                     matchUnary(&makeConvertToDoubleExpression));
+                     matchUnary(&makeConvertToDecimalExpression));
 
   // Wrong number of arguments.
   expectFunctionCallFails(absl::StrCat(geof, "distance>(?a)"));