types.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#pragma once
 
#include <map>
#include <memory>
#include <string>
#include <utility>
 
#include "graphar/fwd.h"
#include "graphar/macros.h"
 
// forward declaration
namespace arrow {
class DataType;
}
 
namespace graphar {
 
enum class Type {
  BOOL = 0,
 
  INT32,
 
  INT64,
 
  FLOAT,
 
  DOUBLE,
 
  STRING,
 
  LIST,
 
  DATE,
 
  TIMESTAMP,
 
  USER_DEFINED,
 
  // Leave this at the end
  MAX_ID,
};
 
class DataType {
 public:
  DataType() : id_(Type::BOOL) {}
 
  explicit DataType(Type id, const std::string& user_defined_type_name = "")
      : id_(id),
        child_(nullptr),
        user_defined_type_name_(user_defined_type_name) {}
 
  explicit DataType(Type id, const std::shared_ptr<DataType>& child)
      : id_(id), child_(std::move(child)), user_defined_type_name_("") {}
 
  DataType(const DataType& other)
      : id_(other.id_),
        child_(other.child_),
        user_defined_type_name_(other.user_defined_type_name_) {}
 
  explicit DataType(DataType&& other)
      : id_(other.id_),
        child_(std::move(other.child_)),
        user_defined_type_name_(std::move(other.user_defined_type_name_)) {}
 
  inline DataType& operator=(const DataType& other) = default;
 
  bool Equals(const DataType& other) const {
    return id_ == other.id_ &&
           user_defined_type_name_ == other.user_defined_type_name_;
  }
 
  bool Equals(const std::shared_ptr<DataType>& other) const {
    if (!other) {
      return false;
    }
    return Equals(*other.get());
  }
 
  const std::shared_ptr<DataType>& value_type() const { return child_; }
 
  bool operator==(const DataType& other) const { return Equals(other); }
 
  bool operator!=(const DataType& other) const { return !Equals(other); }
 
  static std::shared_ptr<arrow::DataType> DataTypeToArrowDataType(
      const std::shared_ptr<DataType>& type);
 
  static std::shared_ptr<DataType> ArrowDataTypeToDataType(
      const std::shared_ptr<arrow::DataType>& type);
 
  static std::shared_ptr<DataType> TypeNameToDataType(const std::string& str);
 
  Type id() const { return id_; }
 
  std::string ToTypeName() const;
 
 private:
  Type id_;
  std::shared_ptr<DataType> child_;
  std::string user_defined_type_name_;
};  // struct DataType
 
// Define a Timestamp class to represent timestamp data type value
class Timestamp {
 public:
  using c_type = int64_t;
  explicit Timestamp(c_type value) : value_(value) {}
 
  c_type value() const { return value_; }
 
 private:
  c_type value_;
};
 
// Define a Date class to represent date data type value
class Date {
 public:
  using c_type = int32_t;
  explicit Date(c_type value) : value_(value) {}
 
  c_type value() const { return value_; }
 
 private:
  c_type value_;
};
 
enum class AdjListType : std::uint8_t {
  unordered_by_source = 0b00000001,
  unordered_by_dest = 0b00000010,
  ordered_by_source = 0b00000100,
  ordered_by_dest = 0b00001000,
};
 
constexpr AdjListType operator|(AdjListType lhs, AdjListType rhs) {
  return static_cast<AdjListType>(
      static_cast<std::underlying_type_t<AdjListType>>(lhs) |
      static_cast<std::underlying_type_t<AdjListType>>(rhs));
}
 
constexpr AdjListType operator&(AdjListType lhs, AdjListType rhs) {
  return static_cast<AdjListType>(
      static_cast<std::underlying_type_t<AdjListType>>(lhs) &
      static_cast<std::underlying_type_t<AdjListType>>(rhs));
}
 
static inline const char* AdjListTypeToString(AdjListType adj_list_type) {
  static const std::map<AdjListType, const char*> adj_list2string{
      {AdjListType::unordered_by_source, "unordered_by_source"},
      {AdjListType::unordered_by_dest, "unordered_by_dest"},
      {AdjListType::ordered_by_source, "ordered_by_source"},
      {AdjListType::ordered_by_dest, "ordered_by_dest"}};
  return adj_list2string.at(adj_list_type);
}
 
static inline AdjListType OrderedAlignedToAdjListType(
    bool ordered, const std::string& aligned) {
  if (ordered) {
    return aligned == "src" ? AdjListType::ordered_by_source
                            : AdjListType::ordered_by_dest;
  }
  return aligned == "src" ? AdjListType::unordered_by_source
                          : AdjListType::unordered_by_dest;
}
 
static inline std::pair<bool, std::string> AdjListTypeToOrderedAligned(
    AdjListType adj_list_type) {
  switch (adj_list_type) {
  case AdjListType::unordered_by_source:
    return std::make_pair(false, "src");
  case AdjListType::unordered_by_dest:
    return std::make_pair(false, "dst");
  case AdjListType::ordered_by_source:
    return std::make_pair(true, "src");
  case AdjListType::ordered_by_dest:
    return std::make_pair(true, "dst");
  default:
    return std::make_pair(false, "dst");
  }
}
 
static inline FileType StringToFileType(const std::string& str) {
  static const std::map<std::string, FileType> str2file_type{
      {"csv", FileType::CSV},
      {"json", FileType::JSON},
      {"parquet", FileType::PARQUET},
      {"orc", FileType::ORC}};
  try {
    return str2file_type.at(str.c_str());
  } catch (const std::exception& e) {
    throw std::runtime_error("KeyError: " + str);
  }
}
 
static inline const char* FileTypeToString(FileType file_type) {
  static const std::map<FileType, const char*> file_type2string{
      {FileType::CSV, "csv"},
      {FileType::JSON, "json"},
      {FileType::PARQUET, "parquet"},
      {FileType::ORC, "orc"}};
  return file_type2string.at(file_type);
}
 
}  // namespace graphar