Implemented type casting

.gitignore

@@ -1,6 +1,7 @@
 *.swp
 *.so
 
+build
 _build
 _build.log
 _install

src/common/filter/Expressions.cpp

@@ -715,13 +715,41 @@ std::string columnTypeToString(ColumnType type) {
 
 
 std::string TypeCastingExpression::toString() const {
- return "";
+ std::string buf;
+ buf.reserve(256);
+
+ buf += "(";
+ buf += columnTypeToString(type_);
+ buf += ")";
+ buf += operand_->toString();
+
+ return buf;
 }
 
+
 OptVariantType TypeCastingExpression::eval() const {
- return OptVariantType(toString());
+ auto result = operand_->eval();
+ if (!result.ok()) {
+ return result;
+ }
+
+ switch (type_) {
+ case INT:
+ case TIMESTAMP:
+ return Expression::toInt(result.value());
+ case STRING:
+ return Expression::toString(result.value());
+ case DOUBLE:
+ return Expression::toDouble(result.value());
+ case BOOL:
+ return Expression::toBool(result.value());
+ case BIGINT:
+ return Status::Error("Type bigint not supported yet");
+ }
+ LOG(FATAL) << "casting to unknown type: " << static_cast<int>(type_);
 }
 
+
 Status TypeCastingExpression::prepare() {
  return operand_->prepare();
 }

src/common/filter/Expressions.h

@@ -148,6 +148,7 @@ class Expression {
  */
  static StatusOr<std::unique_ptr<Expression>> decode(folly::StringPiece buffer) noexcept;
 
+ // Procedures used to do type conversions only between compatible ones.
  static int64_t asInt(const VariantType &value) {
  return boost::get<int64_t>(value);
  }
@@ -204,6 +205,57 @@ class Expression {
  return std::abs(left - right) < EPSILON;
  }
 
+ // Procedures used to do type casting
+ static std::string toString(const VariantType &value) {
+ char buf[1024];
+ switch (value.which()) {
+ case 0:
+ return folly::to<std::string>(boost::get<int64_t>(value));
+ case 1:
+ return folly::to<std::string>(boost::get<double>(value));
+ case 2:
+ snprintf(buf, sizeof(buf), "%s", boost::get<bool>(value) ? "true" : "false");
+ return buf;
+ case 3:
+ return boost::get<std::string>(value);
+ }
+ LOG(FATAL) << "unknown type: " << value.which();
+ }
+
+ static bool toBool(const VariantType &value) {
+ return asBool(value);
+ }
+
+ static double toDouble(const VariantType &value) {
+ switch (value.which()) {
+ case 0:
+ return static_cast<double>(boost::get<int64_t>(value));
+ case 1:
+ return boost::get<double>(value);
+ case 2:
+ return boost::get<bool>(value) ? 1.0 : 0.0;
+ case 3:
+ // TODO(dutor) error handling
+ return folly::to<double>(boost::get<std::string>(value));
+ }
+ LOG(FATAL) << "unknown type: " << value.which();
+ }
+
+ static int64_t toInt(const VariantType &value) {
+ switch (value.which()) {
+ case 0:
+ return boost::get<int64_t>(value);
+ case 1:
+ return static_cast<int64_t>(boost::get<double>(value));
+ case 2:
+ return boost::get<bool>(value) ? 1.0 : 0.0;
+ case 3:
+ // TODO(dutor) error handling
+ return folly::to<int64_t>(boost::get<std::string>(value));
+ }
+ LOG(FATAL) << "unknown type: " << value.which();
+ }
+
  static void print(const VariantType &value);
 
  enum Kind : uint8_t {

src/graph/test/YieldTest.cpp

@@ -40,11 +40,11 @@ TEST_F(YieldTest, Basic) {
  }
  {
  cpp2::ExecutionResponse resp;
- std::string query = "YIELD 1+1";
+ std::string query = "YIELD 1+1, '1+1', (int)3.14, (string)(1+1), (string)true";
  auto code = client->execute(query, resp);
  ASSERT_EQ(cpp2::ErrorCode::SUCCEEDED, code);
- std::vector<std::tuple<int64_t>> expected{
- {2}
+ std::vector<std::tuple<int64_t, std::string, int64_t, std::string, std::string>> expected{
+ {2, "1+1", 3, "2", "true"}
  };
  ASSERT_TRUE(verifyResult(resp, expected));
  }