feat(interactive): support extract intervals from temporal types in GIE

docs/interactive_engine/neo4j/supported_cypher.md

@@ -100,6 +100,7 @@ Note that some Aggregator operators, such as `max()`, we listed here are impleme
 | List | Fold expressions into a single list | [] | [] | <input type="checkbox" disabled checked /> |   |
 | Labels | Get label name of a vertex type | labels() | labels() | <input type="checkbox" disabled checked /> |   |
 | Type | Get label name of an edge type | type() | type() | <input type="checkbox" disabled checked /> |   |
+| Extract | Get interval value from a temporal type | \<temporal\>.\<interval\> | \<temporal\>.\<interval\> | <input type="checkbox" disabled checked /> |   |
 
 
 

flex/codegen/src/graph_types.h

@@ -40,9 +40,9 @@ enum class DataType {
   kVertexId = 8,
   kEdgeId = 9,
   kLength = 10,
-  kTime = 11,
-  kDate = 12,
-  kDateTime = 13,
+  kDate = 11,
+  kTime = 12,
+  kTimeStamp = 13,
   kLabelId = 14
 };
 
@@ -78,8 +78,12 @@ static codegen::DataType common_data_type_pb_2_data_type(
     return codegen::DataType::kInt32Array;
   case common::DataType::BOOLEAN:
     return codegen::DataType::kBoolean;
-  case common::DataType::DATE:
+  case common::DataType::DATE32:
     return codegen::DataType::kDate;
+  case common::DataType::TIME32:
+    return codegen::DataType::kTime;
+  case common::DataType::TIMESTAMP:
+    return codegen::DataType::kTimeStamp;
   default:
     // LOG(FATAL) << "unknown data type";
     throw std::runtime_error(
@@ -106,11 +110,10 @@ static std::string single_common_data_type_pb_2_str(
     return "std::vector<int64_t>";
   case common::DataType::INT32_ARRAY:
     return "std::vector<int32_t>";
-  case common::DataType::DATE:
+  case common::DataType::DATE32:
     return "Date";
+    // TODO: support time32 and timestamp
   default:
-    // LOG(FATAL) << "unknown data type";
-    // return "";
     throw std::runtime_error(
         "unknown data type when convert common data type to string:" +
         std::to_string(static_cast<int>(data_type)));

flex/codegen/src/hqps/hqps_expr_builder.h

@@ -111,7 +111,7 @@
   case common::Logical::WITHIN:
     return "< WithIn > ";
   case common::Logical::ISNULL:
-    return "IsNull";
+    return "NONE ==";  // Convert
   default:
     throw std::runtime_error("unknown logical");
   }
@@ -180,67 +180,67 @@
 }
 
 // Evaluate expression and return the result data type.
 static common::DataType eval_expr_return_type(const common::Expression& expr) {
   std::stack<common::ExprOpr> operator_stack;
   std::stack<common::ExprOpr> tmp_stack;
   for (auto& opr : expr.operators()) {
     auto item_case = opr.item_case();
     VLOG(10) << "got opr: " << opr.DebugString();
     if (item_case == common::ExprOpr::kBrace) {
       auto brace = opr.brace();
       if (brace == common::ExprOpr::Brace::ExprOpr_Brace_LEFT_BRACE) {
         operator_stack.push(opr);
       } else {
         while (!operator_stack.empty() &&
                operator_stack.top().item_case() != common::ExprOpr::kBrace) {
           tmp_stack.push(operator_stack.top());
           operator_stack.pop();
         }
         CHECK(!operator_stack.empty() &&
               operator_stack.top().item_case() == common::ExprOpr::kBrace &&
               operator_stack.top().brace() ==
                   common::ExprOpr::Brace::ExprOpr_Brace_LEFT_BRACE)
             << "no left brace found";
         operator_stack.pop();
       }
     } else if (item_case == common::ExprOpr::kLogical ||
                common::ExprOpr::kArith) {
       operator_stack.push(opr);
     } else if (item_case == common::ExprOpr::kConst ||
                item_case == common::ExprOpr::kVar ||
                item_case == common::ExprOpr::kVars ||
                item_case == common::ExprOpr::kVarMap ||
                item_case == common::ExprOpr::kParam) {
       tmp_stack.push(opr);
     } else {
       LOG(WARNING) << "not recognized expr opr: " << opr.DebugString();
       throw std::runtime_error("not recognized expr opr");
     }
   }
   while (!operator_stack.empty()) {
     tmp_stack.push(operator_stack.top());
     operator_stack.pop();
   }
   {
     // print tmp_stack
     std::stack<common::ExprOpr> tmp_stack_copy = tmp_stack;
     std::stringstream ss;
     while (!tmp_stack_copy.empty()) {
       ss << tmp_stack_copy.top().DebugString() << std::endl;
       tmp_stack_copy.pop();
     }
     VLOG(10) << "tmp_stack: " << ss.str();
   }
 
   return tmp_stack.top().node_type().data_type();
 }
 
 // Simlutate the calculation of expression, return the result data type.
 // convert to prefix expression
 
 /*Build a expression struct from expression*/
 class ExprBuilder {
  public:
   ExprBuilder(BuildingContext& ctx, int var_id = 0, bool no_build = false)
       : ctx_(ctx) {
     if (!no_build) {
@@ -284,10 +284,21 @@
         }
         if (j == size) {
           LOG(WARNING) << "no right brace found" << j << "size: " << size;
-          // just add true, since the current expresion has no other expr_oprs
+          // just add true, since the current expresion has no other expr_ops
           AddExprOpr(std::string("true"));
           i = j;
         }
+      } else if (expr.has_extract()) {
+        // special case for extract
+        auto extract = expr.extract();
+        if (i + 1 >= size) {
+          throw std::runtime_error("extract must have a following var/expr");
+        } else if (expr_ops[i + 1].item_case() != common::ExprOpr::kVar) {
+          throw std::runtime_error("extract must have a following var/expr");
+        } else {
+          AddExtractOpr(extract, expr_ops[i + 1]);
+          i += 2;
+        }
       } else {
         AddExprOpr(expr_ops[i]);
         ++i;
@@ -398,28 +409,8 @@
     }
 
     case common::ExprOpr::kExtract: {
-      auto extract = opr.extract();
-      auto interval = extract.interval();
-      auto data_time = extract.data_time();
-      CHECK(data_time.operators_size() == 1)
-          << "Currently only support one var in extract";
-      auto expr_opr = data_time.operators(0);
-      CHECK(expr_opr.item_case() == common::ExprOpr::kVar)
-          << "Currently only support var in extract";
-      auto expr_var = expr_opr.var();
-      auto param_const = variable_to_param_const(expr_var, ctx_);
-      make_var_name_unique(param_const);
-      func_call_vars_.push_back(param_const);
-
-      boost::format formater(EXTRACT_TEMPLATE_STR);
-      formater % interval_to_str(interval) % param_const.var_name;
-      auto extract_node_str = formater.str();
-      expr_nodes_.emplace_back(extract_node_str);
-
-      tag_selectors_.emplace_back(
-          variable_to_tag_id_property_selector(ctx_, expr_var));
-      VLOG(10) << "extract opr: " << extract_node_str;
-      break;
+      LOG(FATAL) << "Should not reach here, Extract op should be handled "
+                    "separately";
     }
 
     default:
@@ -428,6 +419,28 @@
     }
   }
 
+  // Add extract operator with var. Currently not support extract on a compicate
+  // expression.
+  void AddExtractOpr(const common::Extract& extract_opr,
+                     const common::ExprOpr& expr_opr) {
+    CHECK(expr_opr.item_case() == common::ExprOpr::kVar)
+        << "Currently only support var in extract";
+    auto interval = extract_opr.interval();
+    auto expr_var = expr_opr.var();
+    auto param_const = variable_to_param_const(expr_var, ctx_);
+    make_var_name_unique(param_const);
+    func_call_vars_.push_back(param_const);
+
+    boost::format formater(EXTRACT_TEMPLATE_STR);
+    formater % interval_to_str(interval) % param_const.var_name;
+    auto extract_node_str = formater.str();
+    expr_nodes_.emplace_back(extract_node_str);
+
+    tag_selectors_.emplace_back(
+        variable_to_tag_id_property_selector(ctx_, expr_var));
+    VLOG(10) << "extract opr: " << extract_node_str;
+  }
+
   // get expr nodes
   const std::vector<std::string>& GetExprNodes() const { return expr_nodes_; }
 

flex/engines/hqps_db/core/null_record.h

@@ -88,10 +88,20 @@ bool operator==(const T& lhs, const None& rhs) {
   return IsNull(lhs);
 }
 
+template <typename T>
+bool operator==(const None& lhs, const T& rhs) {
+  return IsNull(rhs);
+}
+
 template <typename T>
 bool operator!=(const T& lhs, const None& rhs) {
   return !IsNull(lhs);
 }
+
+template <typename T>
+bool operator!=(const None& lhs, const T& rhs) {
+  return !IsNull(rhs);
+}
 }  // namespace gs
 
 #endif  // ENGINES_HQPS_ENGINE_NULL_RECORD_H_

flex/engines/hqps_db/core/sync_engine.h

@@ -684,7 +684,7 @@ class SyncEngine : public BaseEngine {
   template <
       int... in_col_id, typename CTX_HEAD_T, int cur_alias, int base_tag,
       typename... CTX_PREV, typename EXPR, typename... SELECTOR,
-      typename std::enable_if<((sizeof...(in_col_id) > 1) &&
+      typename std::enable_if<((sizeof...(in_col_id) >= 1) &&
                                (sizeof...(in_col_id) ==
                                 sizeof...(SELECTOR)))>::type* = nullptr,
       typename RES_T = Context<CTX_HEAD_T, cur_alias, base_tag, CTX_PREV...>>

flex/tests/hqps/match_query.h

@@ -644,7 +644,6 @@ struct MatchQuery11Expr1 {
  private:
 };
 
-// Auto generated query class definition
 class MatchQuery11 : public HqpsAppBase<gs::MutableCSRInterface> {
  public:
   using Engine = SyncEngine<gs::MutableCSRInterface>;
@@ -744,5 +743,63 @@ class MatchQuery11 : public HqpsAppBase<gs::MutableCSRInterface> {
   }
 };
 
+struct MatchQuery12Expr0 {
+ public:
+  using result_t = bool;
+  MatchQuery12Expr0() {}
+
+  inline auto operator()(Date var0) const {
+    return gs::DateTimeExtractor<Interval::MONTH>::extract(var0) == 7;
+  }
+
+ private:
+};
+
+struct MatchQuery12Expr1 {
+ public:
+  using result_t = int64_t;
+  MatchQuery12Expr1() {}
+
+  inline auto operator()(Date var1) const {
+    return gs::DateTimeExtractor<Interval::MONTH>::extract(var1);
+  }
+
+ private:
+};
+
+class MatchQuery12 : public HqpsAppBase<gs::MutableCSRInterface> {
+ public:
+  using Engine = SyncEngine<gs::MutableCSRInterface>;
+  using label_id_t = typename gs::MutableCSRInterface::label_id_t;
+  using vertex_id_t = typename gs::MutableCSRInterface::vertex_id_t;
+  // Query function for query class
+  results::CollectiveResults Query(const gs::MutableCSRInterface& graph) const {
+    auto ctx0 = Engine::template ScanVertex<gs::AppendOpt::Persist>(
+        graph, 1, Filter<TruePredicate>());
+
+    auto ctx1 = Engine::Project<PROJ_TO_NEW>(
+        graph, std::move(ctx0),
+        std::tuple{gs::make_mapper_with_variable<INPUT_COL_ID(0)>(
+            gs::PropertySelector<Date>("birthday"))});
+    auto expr0 = gs::make_filter(MatchQuery12Expr0(),
+                                 gs::PropertySelector<Date>("None"));
+    auto ctx2 = Engine::template Select<INPUT_COL_ID(0)>(graph, std::move(ctx1),
+                                                         std::move(expr0));
+
+    auto ctx3 = Engine::Project<PROJ_TO_NEW>(
+        graph, std::move(ctx2),
+        std::tuple{gs::make_mapper_with_expr<0>(
+            MatchQuery12Expr1(), gs::PropertySelector<Date>("None"))});
+    return Engine::Sink(ctx3, std::array<int32_t, 1>{2});
+  }
+  // Wrapper query function for query class
+  results::CollectiveResults Query(const gs::MutableCSRInterface& graph,
+                                   Decoder& decoder) const override {
+    // decoding params from decoder, and call real query func
+
+    return Query(graph);
+  }
+};
+
 }  // namespace gs
 #endif  // TESTS_HQPS_MATCH_QUERY_H_

flex/tests/hqps/query_test.cc

@@ -211,7 +211,20 @@ int main(int argc, char** argv) {
 
     gs::MutableCSRInterface graph(sess);
     query.Query(graph, input);
-    LOG(INFO) << "Finish MatchQuery10 test";
+    LOG(INFO) << "Finish MatchQuery11 test";
+  }
+
+  {
+    gs::MatchQuery12 query;
+    std::vector<char> encoder_array;
+    gs::Encoder input_encoder(encoder_array);
+    std::vector<char> output_array;
+    gs::Encoder output(output_array);
+    gs::Decoder input(encoder_array.data(), encoder_array.size());
+
+    gs::MutableCSRInterface graph(sess);
+    query.Query(graph, input);
+    LOG(INFO) << "Finish MatchQuery12 test";
   }
 
   LOG(INFO) << "Finish context test.";

interactive_engine/common/src/main/java/com/alibaba/graphscope/groot/common/schema/wrapper/DataType.java

@@ -35,7 +35,9 @@
     DOUBLE_LIST(13),
     STRING_LIST(14),
     BYTES_LIST(15),
-    DATE(16);
+    DATE(16), // represent DATE32
+    TIME32(17),
+    TIMESTAMP(18);
 
     private final byte type;
 
@@ -115,74 +117,74 @@
         }
     }
 
     public static DataType parseFromDataType(
             com.alibaba.graphscope.groot.common.meta.DataType dataType) {
         InternalDataType internalDataType = dataType.getType();
         switch (internalDataType) {
             case BOOL:
                 return DataType.BOOL;
 
             case CHAR:
                 return DataType.CHAR;
 
             case SHORT:
                 return DataType.SHORT;
 
             case INT:
                 return DataType.INT;
 
             case LONG:
                 return DataType.LONG;
 
             case FLOAT:
                 return DataType.FLOAT;
 
             case DOUBLE:
                 return DataType.DOUBLE;
 
             case STRING:
 
             case DATE:
                 return DataType.STRING;
 
             case BYTES:
                 return DataType.BYTES;
 
             case LIST:
                 {
                     switch (InternalDataType.valueOf(dataType.getExpression())) {
                         case INT:
                             {
                                 return DataType.INT_LIST;
                             }
                         case LONG:
                             {
                                 return DataType.LONG_LIST;
                             }
                         case FLOAT:
                             {
                                 return DataType.FLOAT_LIST;
                             }
                         case DOUBLE:
                             {
                                 return DataType.DOUBLE_LIST;
                             }
                         case STRING:
                             {
                                 return DataType.STRING_LIST;
                             }
                         default:
                             {
                                 throw new IllegalArgumentException(
                                         "Unsupported property data type " + dataType);
                             }
                     }
                 }
             default:
                 {
                     throw new IllegalArgumentException(
                             "Unsupported property data type " + dataType);
                 }
         }
     }
 }

interactive_engine/common/src/main/java/com/alibaba/graphscope/groot/common/util/IrSchemaParser.java

@@ -146,6 +146,10 @@ private int getDataTypeId(DataType dataType) {
                 return 9;
             case DATE:
                 return 12;
+            case TIME32:
+                return 13;
+            case TIMESTAMP:
+                return 14;
             default:
                 throw new UnsupportedOperationException(
                         "convert from DataType " + dataType + " to ir core is unsupported yet");

interactive_engine/compiler/src/main/java/com/alibaba/graphscope/common/ir/meta/schema/GraphOptTable.java

@@ -125,8 +125,11 @@ private RelDataType deriveType(GraphProperty property) {
             case DOUBLE:
                 return typeFactory.createSqlType(SqlTypeName.DOUBLE);
             case DATE:
-                return typeFactory.createSqlType(
-                        SqlTypeName.DATE); // todo: support Time and DateTime in GraphSchema
+                return typeFactory.createSqlType(SqlTypeName.DATE);
+            case TIME32:
+                return typeFactory.createSqlType(SqlTypeName.TIME);
+            case TIMESTAMP:
+                return typeFactory.createSqlType(SqlTypeName.TIMESTAMP);
             default:
                 throw new UnsupportedOperationException(
                         "type " + property.getDataType().name() + " not supported");

interactive_engine/compiler/src/main/java/com/alibaba/graphscope/common/ir/meta/schema/Utils.java

@@ -161,15 +161,14 @@ public static DataType toDataType(Object type) {
                         return DataType.STRING;
                     case "DT_DATE32":
                         return DataType.DATE;
+                    case "DT_TIME32":
+                        return DataType.TIME32;
+                    case "TIMESTAMP":
+                        return DataType.TIMESTAMP;
                     default:
                         throw new UnsupportedOperationException(
                                 "unsupported primitive type: " + value);
                 }
-            } else if ((value = typeMap.get("date")) instanceof Map) {
-                Object format = ((Map) value).get("date_format");
-                if (format != null && format.toString().equals("DF_YYYY_MM_DD")) {
-                    return DataType.DATE;
-                }
             }
         }
         throw new UnsupportedOperationException("unsupported type: " + type);
@@ -275,6 +274,10 @@ public static final DataType toDataType(int ordinal) {
                 return DataType.STRING_LIST;
             case 12:
                 return DataType.DATE;
+            case 13:
+                return DataType.TIME32;
+            case 14:
+                return DataType.TIMESTAMP;
             default:
                 throw new UnsupportedOperationException(
                         "convert from ir core type " + ordinal + " to DataType is unsupported yet");