graph_info.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 <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "graphar/fwd.h"
 
namespace graphar {
 
class Property {
 public:
  std::string name;                // property name
  std::shared_ptr<DataType> type;  // property data type
  bool is_primary;                 // primary key tag
  bool is_nullable;                // nullable tag for non-primary key
 
  explicit Property(const std::string& name,
                    const std::shared_ptr<DataType>& type = nullptr,
                    bool is_primary = false, bool is_nullable = true)
      : name(name),
        type(type),
        is_primary(is_primary),
        is_nullable(!is_primary && is_nullable) {}
};
 
bool operator==(const Property& lhs, const Property& rhs);
 
class PropertyGroup {
 public:
  explicit PropertyGroup(const std::vector<Property>& properties,
                         FileType file_type, const std::string& prefix = "");
 
  const std::vector<Property>& GetProperties() const;
 
  bool HasProperty(const std::string& property_name) const;
 
  inline FileType GetFileType() const { return file_type_; }
 
  inline const std::string& GetPrefix() const { return prefix_; }
 
  bool IsValidated() const;
 
  friend std::ostream& operator<<(std::ostream& stream,
                                  const PropertyGroup& pg) {
    for (size_t i = 0; i < pg.properties_.size(); ++i) {
      stream << pg.properties_[i].name;
      if (i != pg.properties_.size() - 1) {
        stream << "_";
      }
    }
    return stream;
  }
 
 private:
  std::vector<Property> properties_;
  FileType file_type_;
  std::string prefix_;
};
 
bool operator==(const PropertyGroup& lhs, const PropertyGroup& rhs);
 
class AdjacentList {
 public:
  explicit AdjacentList(AdjListType type, FileType file_type,
                        const std::string& prefix = "");
 
  inline AdjListType GetType() const { return type_; }
 
  inline FileType GetFileType() const { return file_type_; }
 
  inline const std::string& GetPrefix() const { return prefix_; }
 
  bool IsValidated() const;
 
 private:
  AdjListType type_;
  FileType file_type_;
  std::string prefix_;
};
 
class VertexInfo {
 public:
  explicit VertexInfo(const std::string& label, IdType chunk_size,
                      const PropertyGroupVector& property_groups,
                      const std::string& prefix = "",
                      std::shared_ptr<const InfoVersion> version = nullptr);
 
  ~VertexInfo();
 
  Result<std::shared_ptr<VertexInfo>> AddPropertyGroup(
      std::shared_ptr<PropertyGroup> property_group) const;
 
  const std::string& GetLabel() const;
 
  IdType GetChunkSize() const;
 
  const std::string& GetPrefix() const;
 
  const std::shared_ptr<const InfoVersion>& version() const;
 
  int PropertyGroupNum() const;
 
  const PropertyGroupVector& GetPropertyGroups() const;
 
  std::shared_ptr<PropertyGroup> GetPropertyGroup(
      const std::string& property_name) const;
 
  std::shared_ptr<PropertyGroup> GetPropertyGroupByIndex(int index) const;
 
  Result<std::shared_ptr<DataType>> GetPropertyType(
      const std::string& property_name) const;
 
  bool HasProperty(const std::string& property_name) const;
 
  Status Save(const std::string& file_name) const;
 
  Result<std::string> Dump() const noexcept;
 
  bool IsPrimaryKey(const std::string& property_name) const;
 
  bool IsNullableKey(const std::string& property_name) const;
 
  bool HasPropertyGroup(
      const std::shared_ptr<PropertyGroup>& property_group) const;
 
  Result<std::string> GetFilePath(std::shared_ptr<PropertyGroup> property_group,
                                  IdType chunk_index) const;
 
  Result<std::string> GetPathPrefix(
      std::shared_ptr<PropertyGroup> property_group) const;
 
  Result<std::string> GetVerticesNumFilePath() const;
 
  bool IsValidated() const;
 
  static Result<std::shared_ptr<VertexInfo>> Load(std::shared_ptr<Yaml> yaml);
 
  static Result<std::shared_ptr<VertexInfo>> Load(const std::string& input);
 
 private:
  class Impl;
  std::unique_ptr<Impl> impl_;
};
 
class EdgeInfo {
 public:
  explicit EdgeInfo(const std::string& src_label, const std::string& edge_label,
                    const std::string& dst_label, IdType chunk_size,
                    IdType src_chunk_size, IdType dst_chunk_size, bool directed,
                    const AdjacentListVector& adjacent_lists,
                    const PropertyGroupVector& property_groups,
                    const std::string& prefix = "",
                    std::shared_ptr<const InfoVersion> version = nullptr);
 
  ~EdgeInfo();
 
  Result<std::shared_ptr<EdgeInfo>> AddAdjacentList(
      std::shared_ptr<AdjacentList> adj_list) const;
 
  Result<std::shared_ptr<EdgeInfo>> AddPropertyGroup(
      std::shared_ptr<PropertyGroup> property_group) const;
 
  const std::string& GetSrcLabel() const;
 
  const std::string& GetEdgeLabel() const;
 
  const std::string& GetDstLabel() const;
 
  IdType GetChunkSize() const;
 
  IdType GetSrcChunkSize() const;
 
  IdType GetDstChunkSize() const;
 
  const std::string& GetPrefix() const;
 
  bool IsDirected() const;
 
  const std::shared_ptr<const InfoVersion>& version() const;
 
  bool HasAdjacentListType(AdjListType adj_list_type) const;
 
  bool HasProperty(const std::string& property_name) const;
 
  bool HasPropertyGroup(
      const std::shared_ptr<PropertyGroup>& property_group) const;
 
  std::shared_ptr<AdjacentList> GetAdjacentList(
      AdjListType adj_list_type) const;
 
  int PropertyGroupNum() const;
 
  const PropertyGroupVector& GetPropertyGroups() const;
 
  std::shared_ptr<PropertyGroup> GetPropertyGroup(
      const std::string& property) const;
 
  std::shared_ptr<PropertyGroup> GetPropertyGroupByIndex(int index) const;
 
  Result<std::string> GetVerticesNumFilePath(AdjListType adj_list_type) const;
 
  Result<std::string> GetEdgesNumFilePath(IdType vertex_chunk_index,
                                          AdjListType adj_list_type) const;
 
  Result<std::string> GetAdjListFilePath(IdType vertex_chunk_index,
                                         IdType edge_chunk_index,
                                         AdjListType adj_list_type) const;
 
  Result<std::string> GetAdjListPathPrefix(AdjListType adj_list_type) const;
 
  Result<std::string> GetAdjListOffsetFilePath(IdType vertex_chunk_index,
                                               AdjListType adj_list_type) const;
 
  Result<std::string> GetOffsetPathPrefix(AdjListType adj_list_type) const;
 
  Result<std::string> GetPropertyFilePath(
      const std::shared_ptr<PropertyGroup>& property_group,
      AdjListType adj_list_type, IdType vertex_chunk_index,
      IdType edge_chunk_index) const;
 
  Result<std::string> GetPropertyGroupPathPrefix(
      const std::shared_ptr<PropertyGroup>& property_group,
      AdjListType adj_list_type) const;
 
  Result<std::shared_ptr<DataType>> GetPropertyType(
      const std::string& property_name) const;
  bool IsPrimaryKey(const std::string& property_name) const;
 
  bool IsNullableKey(const std::string& property_name) const;
 
  Status Save(const std::string& file_name) const;
 
  Result<std::string> Dump() const noexcept;
 
  bool IsValidated() const;
 
  static Result<std::shared_ptr<EdgeInfo>> Load(std::shared_ptr<Yaml> yaml);
 
  static Result<std::shared_ptr<EdgeInfo>> Load(const std::string& input);
 
 private:
  class Impl;
  std::unique_ptr<Impl> impl_;
};
 
class GraphInfo {
 public:
  explicit GraphInfo(
      const std::string& graph_name, VertexInfoVector vertex_infos,
      EdgeInfoVector edge_infos, const std::string& prefix = "./",
      std::shared_ptr<const InfoVersion> version = nullptr,
      const std::unordered_map<std::string, std::string>& extra_info = {});
 
  ~GraphInfo();
 
  static Result<std::shared_ptr<GraphInfo>> Load(const std::string& path);
 
  static Result<std::shared_ptr<GraphInfo>> Load(
      const std::string& input, const std::string& relative_path);
 
  Result<std::shared_ptr<GraphInfo>> AddVertex(
      std::shared_ptr<VertexInfo> vertex_info) const;
 
  Result<std::shared_ptr<GraphInfo>> AddEdge(
      std::shared_ptr<EdgeInfo> edge_info) const;
 
  const std::string& GetName() const;
 
  const std::string& GetPrefix() const;
 
  const std::shared_ptr<const InfoVersion>& version() const;
 
  const std::unordered_map<std::string, std::string>& GetExtraInfo() const;
 
  std::shared_ptr<VertexInfo> GetVertexInfo(const std::string& label) const;
 
  std::shared_ptr<EdgeInfo> GetEdgeInfo(const std::string& src_label,
                                        const std::string& edge_label,
                                        const std::string& dst_label) const;
 
  int GetVertexInfoIndex(const std::string& label) const;
 
  int GetEdgeInfoIndex(const std::string& src_label,
                       const std::string& edge_label,
                       const std::string& dst_label) const;
 
  int VertexInfoNum() const;
 
  int EdgeInfoNum() const;
 
  const std::shared_ptr<VertexInfo> GetVertexInfoByIndex(int index) const;
 
  const std::shared_ptr<EdgeInfo> GetEdgeInfoByIndex(int index) const;
 
  const VertexInfoVector& GetVertexInfos() const;
 
  const EdgeInfoVector& GetEdgeInfos() const;
 
  Status Save(const std::string& path) const;
 
  Result<std::string> Dump() const;
 
  bool IsValidated() const;
 
 private:
  class Impl;
  std::unique_ptr<Impl> impl_;
};
 
}  // namespace graphar