Merge master cpp module API
This commit is contained in:
Marko Budiselic
commit
bb6cf35441
693
include/_mgp.hpp
Normal file
693
include/_mgp.hpp
Normal file
@ -0,0 +1,693 @@
|
||||
// Copyright 2022 Memgraph Ltd.
|
||||
//
|
||||
// Use of this software is governed by the Business Source License
|
||||
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
|
||||
// License, and you may not use this file except in compliance with the Business Source License.
|
||||
//
|
||||
// As of the Change Date specified in that file, in accordance with
|
||||
// the Business Source License, use of this software will be governed
|
||||
// by the Apache License, Version 2.0, included in the file
|
||||
// licenses/APL.txt.
|
||||
|
||||
/// @file _mgp.hpp
|
||||
///
|
||||
/// The file contains methods that connect mg procedures and the outside code
|
||||
/// Methods like mapping a graph into memory or assigning new mg results or
|
||||
/// their properties are implemented.
|
||||
#pragma once
|
||||
|
||||
#include "mg_exceptions.hpp"
|
||||
#include "mg_procedure.h"
|
||||
|
||||
namespace mgp {
|
||||
|
||||
namespace {
|
||||
void MgExceptionHandle(mgp_error result_code) {
|
||||
switch (result_code) {
|
||||
case mgp_error::MGP_ERROR_UNKNOWN_ERROR:
|
||||
throw mg_exception::UnknownException();
|
||||
case mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE:
|
||||
throw mg_exception::AllocationException();
|
||||
case mgp_error::MGP_ERROR_INSUFFICIENT_BUFFER:
|
||||
throw mg_exception::InsufficientBufferException();
|
||||
case mgp_error::MGP_ERROR_OUT_OF_RANGE:
|
||||
throw mg_exception::OutOfRangeException();
|
||||
case mgp_error::MGP_ERROR_LOGIC_ERROR:
|
||||
throw mg_exception::LogicException();
|
||||
case mgp_error::MGP_ERROR_DELETED_OBJECT:
|
||||
throw mg_exception::DeletedObjectException();
|
||||
case mgp_error::MGP_ERROR_INVALID_ARGUMENT:
|
||||
throw mg_exception::InvalidArgumentException();
|
||||
case mgp_error::MGP_ERROR_KEY_ALREADY_EXISTS:
|
||||
throw mg_exception::KeyAlreadyExistsException();
|
||||
case mgp_error::MGP_ERROR_IMMUTABLE_OBJECT:
|
||||
throw mg_exception::ImmutableObjectException();
|
||||
case mgp_error::MGP_ERROR_VALUE_CONVERSION:
|
||||
throw mg_exception::ValueConversionException();
|
||||
case mgp_error::MGP_ERROR_SERIALIZATION_ERROR:
|
||||
throw mg_exception::SerializationException();
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename TResult, typename TFunc, typename... TArgs>
|
||||
TResult MgInvoke(TFunc func, TArgs... args) {
|
||||
TResult result{};
|
||||
|
||||
auto result_code = func(args..., &result);
|
||||
MgExceptionHandle(result_code);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
template <typename TFunc, typename... TArgs>
|
||||
void MgInvokeVoid(TFunc func, TArgs... args) {
|
||||
auto result_code = func(args...);
|
||||
MgExceptionHandle(result_code);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
// mgp_value
|
||||
|
||||
// Make value
|
||||
|
||||
mgp_value *value_make_null(mgp_memory *memory) { return MgInvoke<mgp_value *>(mgp_value_make_null, memory); }
|
||||
|
||||
mgp_value *value_make_bool(int val, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_value *>(mgp_value_make_bool, val, memory);
|
||||
}
|
||||
|
||||
mgp_value *value_make_int(int64_t val, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_value *>(mgp_value_make_int, val, memory);
|
||||
}
|
||||
|
||||
mgp_value *value_make_double(double val, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_value *>(mgp_value_make_double, val, memory);
|
||||
}
|
||||
|
||||
mgp_value *value_make_string(const char *val, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_value *>(mgp_value_make_string, val, memory);
|
||||
}
|
||||
|
||||
mgp_value *value_make_list(mgp_list *val) { return MgInvoke<mgp_value *>(mgp_value_make_list, val); }
|
||||
|
||||
mgp_value *value_make_map(mgp_map *val) { return MgInvoke<mgp_value *>(mgp_value_make_map, val); }
|
||||
|
||||
mgp_value *value_make_vertex(mgp_vertex *val) { return MgInvoke<mgp_value *>(mgp_value_make_vertex, val); }
|
||||
|
||||
mgp_value *value_make_edge(mgp_edge *val) { return MgInvoke<mgp_value *>(mgp_value_make_edge, val); }
|
||||
|
||||
mgp_value *value_make_path(mgp_path *val) { return MgInvoke<mgp_value *>(mgp_value_make_path, val); }
|
||||
|
||||
mgp_value *value_make_date(mgp_date *val) { return MgInvoke<mgp_value *>(mgp_value_make_date, val); }
|
||||
|
||||
mgp_value *value_make_local_time(mgp_local_time *val) { return MgInvoke<mgp_value *>(mgp_value_make_local_time, val); }
|
||||
|
||||
mgp_value *value_make_local_date_time(mgp_local_date_time *val) {
|
||||
return MgInvoke<mgp_value *>(mgp_value_make_local_date_time, val);
|
||||
}
|
||||
|
||||
mgp_value *value_make_duration(mgp_duration *val) { return MgInvoke<mgp_value *>(mgp_value_make_duration, val); }
|
||||
|
||||
// Copy value
|
||||
|
||||
// TODO: implement within MGP API
|
||||
// with primitive types ({bool, int, double, string}), create a new identical value
|
||||
// otherwise call mgp_##TYPE_copy and convert tpye
|
||||
mgp_value *value_copy(mgp_value *val, mgp_memory *memory) { return MgInvoke<mgp_value *>(mgp_value_copy, val, memory); }
|
||||
|
||||
// Destroy value
|
||||
|
||||
void value_destroy(mgp_value *val) { mgp_value_destroy(val); }
|
||||
|
||||
// Get value of type
|
||||
|
||||
mgp_value_type value_get_type(mgp_value *val) { return MgInvoke<mgp_value_type>(mgp_value_get_type, val); }
|
||||
|
||||
bool value_get_bool(mgp_value *val) { return MgInvoke<int>(mgp_value_get_bool, val); }
|
||||
|
||||
int64_t value_get_int(mgp_value *val) { return MgInvoke<int64_t>(mgp_value_get_int, val); }
|
||||
|
||||
double value_get_double(mgp_value *val) { return MgInvoke<double>(mgp_value_get_double, val); }
|
||||
|
||||
const char *value_get_string(mgp_value *val) { return MgInvoke<const char *>(mgp_value_get_string, val); }
|
||||
|
||||
mgp_list *value_get_list(mgp_value *val) { return MgInvoke<mgp_list *>(mgp_value_get_list, val); }
|
||||
|
||||
mgp_map *value_get_map(mgp_value *val) { return MgInvoke<mgp_map *>(mgp_value_get_map, val); }
|
||||
|
||||
mgp_vertex *value_get_vertex(mgp_value *val) { return MgInvoke<mgp_vertex *>(mgp_value_get_vertex, val); }
|
||||
|
||||
mgp_edge *value_get_edge(mgp_value *val) { return MgInvoke<mgp_edge *>(mgp_value_get_edge, val); }
|
||||
|
||||
mgp_path *value_get_path(mgp_value *val) { return MgInvoke<mgp_path *>(mgp_value_get_path, val); }
|
||||
|
||||
mgp_date *value_get_date(mgp_value *val) { return MgInvoke<mgp_date *>(mgp_value_get_date, val); }
|
||||
|
||||
mgp_local_time *value_get_local_time(mgp_value *val) {
|
||||
return MgInvoke<mgp_local_time *>(mgp_value_get_local_time, val);
|
||||
}
|
||||
|
||||
mgp_local_date_time *value_get_local_date_time(mgp_value *val) {
|
||||
return MgInvoke<mgp_local_date_time *>(mgp_value_get_local_date_time, val);
|
||||
}
|
||||
|
||||
mgp_duration *value_get_duration(mgp_value *val) { return MgInvoke<mgp_duration *>(mgp_value_get_duration, val); }
|
||||
|
||||
// Check type of value
|
||||
|
||||
bool value_is_null(mgp_value *val) { return MgInvoke<int>(mgp_value_is_null, val); }
|
||||
|
||||
bool value_is_bool(mgp_value *val) { return MgInvoke<int>(mgp_value_is_bool, val); }
|
||||
|
||||
bool value_is_int(mgp_value *val) { return MgInvoke<int>(mgp_value_is_int, val); }
|
||||
|
||||
bool value_is_double(mgp_value *val) { return MgInvoke<int>(mgp_value_is_double, val); }
|
||||
|
||||
bool value_is_string(mgp_value *val) { return MgInvoke<int>(mgp_value_is_string, val); }
|
||||
|
||||
bool value_is_list(mgp_value *val) { return MgInvoke<int>(mgp_value_is_list, val); }
|
||||
|
||||
bool value_is_map(mgp_value *val) { return MgInvoke<int>(mgp_value_is_map, val); }
|
||||
|
||||
bool value_is_vertex(mgp_value *val) { return MgInvoke<int>(mgp_value_is_vertex, val); }
|
||||
|
||||
bool value_is_edge(mgp_value *val) { return MgInvoke<int>(mgp_value_is_edge, val); }
|
||||
|
||||
bool value_is_path(mgp_value *val) { return MgInvoke<int>(mgp_value_is_path, val); }
|
||||
|
||||
bool value_is_date(mgp_value *val) { return MgInvoke<int>(mgp_value_is_date, val); }
|
||||
|
||||
bool value_is_local_time(mgp_value *val) { return MgInvoke<int>(mgp_value_is_local_time, val); }
|
||||
|
||||
bool value_is_local_date_time(mgp_value *val) { return MgInvoke<int>(mgp_value_is_local_date_time, val); }
|
||||
|
||||
bool value_is_duration(mgp_value *val) { return MgInvoke<int>(mgp_value_is_duration, val); }
|
||||
|
||||
// Get type
|
||||
|
||||
mgp_type *type_any() { return MgInvoke<mgp_type *>(mgp_type_any); }
|
||||
|
||||
mgp_type *type_bool() { return MgInvoke<mgp_type *>(mgp_type_bool); }
|
||||
|
||||
mgp_type *type_string() { return MgInvoke<mgp_type *>(mgp_type_string); }
|
||||
|
||||
mgp_type *type_int() { return MgInvoke<mgp_type *>(mgp_type_int); }
|
||||
|
||||
mgp_type *type_float() { return MgInvoke<mgp_type *>(mgp_type_float); }
|
||||
|
||||
mgp_type *type_number() { return MgInvoke<mgp_type *>(mgp_type_number); }
|
||||
|
||||
mgp_type *type_list(mgp_type *element_type) { return MgInvoke<mgp_type *>(mgp_type_list, element_type); }
|
||||
|
||||
mgp_type *type_map() { return MgInvoke<mgp_type *>(mgp_type_map); }
|
||||
|
||||
mgp_type *type_node() { return MgInvoke<mgp_type *>(mgp_type_node); }
|
||||
|
||||
mgp_type *type_relationship() { return MgInvoke<mgp_type *>(mgp_type_relationship); }
|
||||
|
||||
mgp_type *type_path() { return MgInvoke<mgp_type *>(mgp_type_path); }
|
||||
|
||||
mgp_type *type_date() { return MgInvoke<mgp_type *>(mgp_type_date); }
|
||||
|
||||
mgp_type *type_local_time() { return MgInvoke<mgp_type *>(mgp_type_local_time); }
|
||||
|
||||
mgp_type *type_local_date_time() { return MgInvoke<mgp_type *>(mgp_type_local_date_time); }
|
||||
|
||||
mgp_type *type_duration() { return MgInvoke<mgp_type *>(mgp_type_duration); }
|
||||
|
||||
mgp_type *type_nullable(mgp_type *type) { return MgInvoke<mgp_type *>(mgp_type_nullable, type); }
|
||||
|
||||
// mgp_graph
|
||||
|
||||
bool graph_is_mutable(mgp_graph *graph) { return MgInvoke<int>(mgp_graph_is_mutable, graph); }
|
||||
|
||||
mgp_vertex *graph_create_vertex(mgp_graph *graph, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_vertex *>(mgp_graph_create_vertex, graph, memory);
|
||||
}
|
||||
|
||||
void graph_delete_vertex(mgp_graph *graph, mgp_vertex *vertex) { MgInvokeVoid(mgp_graph_delete_vertex, graph, vertex); }
|
||||
|
||||
void graph_detach_delete_vertex(mgp_graph *graph, mgp_vertex *vertex) {
|
||||
MgInvokeVoid(mgp_graph_detach_delete_vertex, graph, vertex);
|
||||
}
|
||||
|
||||
mgp_edge *graph_create_edge(mgp_graph *graph, mgp_vertex *from, mgp_vertex *to, mgp_edge_type type,
|
||||
mgp_memory *memory) {
|
||||
return MgInvoke<mgp_edge *>(mgp_graph_create_edge, graph, from, to, type, memory);
|
||||
}
|
||||
|
||||
void graph_delete_edge(mgp_graph *graph, mgp_edge *edge) { MgInvokeVoid(mgp_graph_delete_edge, graph, edge); }
|
||||
|
||||
mgp_vertex *graph_get_vertex_by_id(mgp_graph *g, mgp_vertex_id id, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_vertex *>(mgp_graph_get_vertex_by_id, g, id, memory);
|
||||
}
|
||||
|
||||
mgp_vertices_iterator *graph_iter_vertices(mgp_graph *g, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_vertices_iterator *>(mgp_graph_iter_vertices, g, memory);
|
||||
}
|
||||
|
||||
// mgp_vertices_iterator
|
||||
|
||||
void vertices_iterator_destroy(mgp_vertices_iterator *it) { mgp_vertices_iterator_destroy(it); }
|
||||
|
||||
mgp_vertex *vertices_iterator_get(mgp_vertices_iterator *it) {
|
||||
return MgInvoke<mgp_vertex *>(mgp_vertices_iterator_get, it);
|
||||
}
|
||||
|
||||
mgp_vertex *vertices_iterator_next(mgp_vertices_iterator *it) {
|
||||
return MgInvoke<mgp_vertex *>(mgp_vertices_iterator_next, it);
|
||||
}
|
||||
|
||||
// mgp_edges_iterator
|
||||
|
||||
void edges_iterator_destroy(mgp_edges_iterator *it) { mgp_edges_iterator_destroy(it); }
|
||||
|
||||
mgp_edge *edges_iterator_get(mgp_edges_iterator *it) { return MgInvoke<mgp_edge *>(mgp_edges_iterator_get, it); }
|
||||
|
||||
mgp_edge *edges_iterator_next(mgp_edges_iterator *it) { return MgInvoke<mgp_edge *>(mgp_edges_iterator_next, it); }
|
||||
|
||||
// mgp_properties_iterator
|
||||
|
||||
void properties_iterator_destroy(mgp_properties_iterator *it) { mgp_properties_iterator_destroy(it); }
|
||||
|
||||
mgp_property *properties_iterator_get(mgp_properties_iterator *it) {
|
||||
return MgInvoke<mgp_property *>(mgp_properties_iterator_get, it);
|
||||
}
|
||||
|
||||
mgp_property *properties_iterator_next(mgp_properties_iterator *it) {
|
||||
return MgInvoke<mgp_property *>(mgp_properties_iterator_next, it);
|
||||
}
|
||||
|
||||
// Container {mgp_list, mgp_map} methods
|
||||
|
||||
// mgp_list
|
||||
|
||||
mgp_list *list_make_empty(size_t capacity, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_list *>(mgp_list_make_empty, capacity, memory);
|
||||
}
|
||||
|
||||
mgp_list *list_copy(mgp_list *list, mgp_memory *memory) { return MgInvoke<mgp_list *>(mgp_list_copy, list, memory); }
|
||||
|
||||
void list_destroy(mgp_list *list) { mgp_list_destroy(list); }
|
||||
|
||||
void list_append(mgp_list *list, mgp_value *val) { MgInvokeVoid(mgp_list_append, list, val); }
|
||||
|
||||
void list_append_extend(mgp_list *list, mgp_value *val) { MgInvokeVoid(mgp_list_append_extend, list, val); }
|
||||
|
||||
size_t list_size(mgp_list *list) { return MgInvoke<size_t>(mgp_list_size, list); }
|
||||
|
||||
size_t list_capacity(mgp_list *list) { return MgInvoke<size_t>(mgp_list_capacity, list); }
|
||||
|
||||
mgp_value *list_at(mgp_list *list, size_t index) { return MgInvoke<mgp_value *>(mgp_list_at, list, index); }
|
||||
|
||||
// mgp_map
|
||||
|
||||
mgp_map *map_make_empty(mgp_memory *memory) { return MgInvoke<mgp_map *>(mgp_map_make_empty, memory); }
|
||||
|
||||
mgp_map *map_copy(mgp_map *map, mgp_memory *memory) { return MgInvoke<mgp_map *>(mgp_map_copy, map, memory); }
|
||||
|
||||
void map_destroy(mgp_map *map) { mgp_map_destroy(map); }
|
||||
|
||||
void map_insert(mgp_map *map, const char *key, mgp_value *value) { MgInvokeVoid(mgp_map_insert, map, key, value); }
|
||||
|
||||
size_t map_size(mgp_map *map) { return MgInvoke<size_t>(mgp_map_size, map); }
|
||||
|
||||
mgp_value *map_at(mgp_map *map, const char *key) { return MgInvoke<mgp_value *>(mgp_map_at, map, key); }
|
||||
|
||||
const char *map_item_key(mgp_map_item *item) { return MgInvoke<const char *>(mgp_map_item_key, item); }
|
||||
|
||||
mgp_value *map_item_value(mgp_map_item *item) { return MgInvoke<mgp_value *>(mgp_map_item_value, item); }
|
||||
|
||||
mgp_map_items_iterator *map_iter_items(mgp_map *map, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_map_items_iterator *>(mgp_map_iter_items, map, memory);
|
||||
}
|
||||
|
||||
void map_items_iterator_destroy(mgp_map_items_iterator *it) { mgp_map_items_iterator_destroy(it); }
|
||||
|
||||
mgp_map_item *map_items_iterator_get(mgp_map_items_iterator *it) {
|
||||
return MgInvoke<mgp_map_item *>(mgp_map_items_iterator_get, it);
|
||||
}
|
||||
|
||||
mgp_map_item *map_items_iterator_next(mgp_map_items_iterator *it) {
|
||||
return MgInvoke<mgp_map_item *>(mgp_map_items_iterator_next, it);
|
||||
}
|
||||
|
||||
// mgp_vertex
|
||||
|
||||
mgp_vertex_id vertex_get_id(mgp_vertex *v) { return MgInvoke<mgp_vertex_id>(mgp_vertex_get_id, v); }
|
||||
|
||||
mgp_vertex *vertex_copy(mgp_vertex *v, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_vertex *>(mgp_vertex_copy, v, memory);
|
||||
}
|
||||
|
||||
void vertex_destroy(mgp_vertex *v) { mgp_vertex_destroy(v); }
|
||||
|
||||
bool vertex_equal(mgp_vertex *v1, mgp_vertex *v2) { return MgInvoke<int>(mgp_vertex_equal, v1, v2); }
|
||||
|
||||
size_t vertex_labels_count(mgp_vertex *v) { return MgInvoke<size_t>(mgp_vertex_labels_count, v); }
|
||||
|
||||
mgp_label vertex_label_at(mgp_vertex *v, size_t index) { return MgInvoke<mgp_label>(mgp_vertex_label_at, v, index); }
|
||||
|
||||
bool vertex_has_label(mgp_vertex *v, mgp_label label) { return MgInvoke<int>(mgp_vertex_has_label, v, label); }
|
||||
|
||||
bool vertex_has_label_named(mgp_vertex *v, const char *label_name) {
|
||||
return MgInvoke<int>(mgp_vertex_has_label_named, v, label_name);
|
||||
}
|
||||
|
||||
void vertex_add_label(mgp_vertex *vertex, mgp_label label) { MgInvokeVoid(mgp_vertex_add_label, vertex, label); }
|
||||
|
||||
mgp_value *vertex_get_property(mgp_vertex *v, const char *property_name, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_value *>(mgp_vertex_get_property, v, property_name, memory);
|
||||
}
|
||||
|
||||
mgp_properties_iterator *vertex_iter_properties(mgp_vertex *v, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_properties_iterator *>(mgp_vertex_iter_properties, v, memory);
|
||||
}
|
||||
|
||||
mgp_edges_iterator *vertex_iter_in_edges(mgp_vertex *v, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_edges_iterator *>(mgp_vertex_iter_in_edges, v, memory);
|
||||
}
|
||||
|
||||
mgp_edges_iterator *vertex_iter_out_edges(mgp_vertex *v, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_edges_iterator *>(mgp_vertex_iter_out_edges, v, memory);
|
||||
}
|
||||
|
||||
// mgp_edge
|
||||
|
||||
mgp_edge_id edge_get_id(mgp_edge *e) { return MgInvoke<mgp_edge_id>(mgp_edge_get_id, e); }
|
||||
|
||||
mgp_edge *edge_copy(mgp_edge *e, mgp_memory *memory) { return MgInvoke<mgp_edge *>(mgp_edge_copy, e, memory); }
|
||||
|
||||
void edge_destroy(mgp_edge *e) { mgp_edge_destroy(e); }
|
||||
|
||||
bool edge_equal(mgp_edge *e1, mgp_edge *e2) { return MgInvoke<int>(mgp_edge_equal, e1, e2); }
|
||||
|
||||
mgp_edge_type edge_get_type(mgp_edge *e) { return MgInvoke<mgp_edge_type>(mgp_edge_get_type, e); }
|
||||
|
||||
mgp_vertex *edge_get_from(mgp_edge *e) { return MgInvoke<mgp_vertex *>(mgp_edge_get_from, e); }
|
||||
|
||||
mgp_vertex *edge_get_to(mgp_edge *e) { return MgInvoke<mgp_vertex *>(mgp_edge_get_to, e); }
|
||||
|
||||
mgp_value *edge_get_property(mgp_edge *e, const char *property_name, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_value *>(mgp_edge_get_property, e, property_name, memory);
|
||||
}
|
||||
|
||||
mgp_properties_iterator *edge_iter_properties(mgp_edge *e, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_properties_iterator *>(mgp_edge_iter_properties, e, memory);
|
||||
}
|
||||
|
||||
// mgp_path
|
||||
|
||||
mgp_path *path_make_with_start(mgp_vertex *vertex, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_path *>(mgp_path_make_with_start, vertex, memory);
|
||||
}
|
||||
|
||||
mgp_path *path_copy(mgp_path *path, mgp_memory *memory) { return MgInvoke<mgp_path *>(mgp_path_copy, path, memory); }
|
||||
|
||||
void path_destroy(mgp_path *path) { mgp_path_destroy(path); }
|
||||
|
||||
void path_expand(mgp_path *path, mgp_edge *edge) { MgInvokeVoid(mgp_path_expand, path, edge); }
|
||||
|
||||
size_t path_size(mgp_path *path) { return MgInvoke<size_t>(mgp_path_size, path); }
|
||||
|
||||
mgp_vertex *path_vertex_at(mgp_path *path, size_t index) {
|
||||
return MgInvoke<mgp_vertex *>(mgp_path_vertex_at, path, index);
|
||||
}
|
||||
|
||||
mgp_edge *path_edge_at(mgp_path *path, size_t index) { return MgInvoke<mgp_edge *>(mgp_path_edge_at, path, index); }
|
||||
|
||||
bool path_equal(mgp_path *p1, mgp_path *p2) { return MgInvoke<int>(mgp_path_equal, p1, p2); }
|
||||
|
||||
// Temporal type {mgp_date, mgp_local_time, mgp_local_date_time, mgp_duration} methods
|
||||
|
||||
// mgp_date
|
||||
|
||||
mgp_date *date_from_string(const char *string, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_date *>(mgp_date_from_string, string, memory);
|
||||
}
|
||||
|
||||
mgp_date *date_from_parameters(mgp_date_parameters *parameters, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_date *>(mgp_date_from_parameters, parameters, memory);
|
||||
}
|
||||
|
||||
mgp_date *date_copy(mgp_date *date, mgp_memory *memory) { return MgInvoke<mgp_date *>(mgp_date_copy, date, memory); }
|
||||
|
||||
void date_destroy(mgp_date *date) { mgp_date_destroy(date); }
|
||||
|
||||
bool date_equal(mgp_date *first, mgp_date *second) { return MgInvoke<int>(mgp_date_equal, first, second); }
|
||||
|
||||
int date_get_year(mgp_date *date) { return MgInvoke<int>(mgp_date_get_year, date); }
|
||||
|
||||
int date_get_month(mgp_date *date) { return MgInvoke<int>(mgp_date_get_month, date); }
|
||||
|
||||
int date_get_day(mgp_date *date) { return MgInvoke<int>(mgp_date_get_day, date); }
|
||||
|
||||
int64_t date_timestamp(mgp_date *date) { return MgInvoke<int64_t>(mgp_date_timestamp, date); }
|
||||
|
||||
mgp_date *date_now(mgp_memory *memory) { return MgInvoke<mgp_date *>(mgp_date_now, memory); }
|
||||
|
||||
mgp_date *date_add_duration(mgp_date *date, mgp_duration *dur, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_date *>(mgp_date_add_duration, date, dur, memory);
|
||||
}
|
||||
|
||||
mgp_date *date_sub_duration(mgp_date *date, mgp_duration *dur, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_date *>(mgp_date_sub_duration, date, dur, memory);
|
||||
}
|
||||
|
||||
mgp_duration *date_diff(mgp_date *first, mgp_date *second, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_date_diff, first, second, memory);
|
||||
}
|
||||
|
||||
// mgp_local_time
|
||||
|
||||
mgp_local_time *local_time_from_string(const char *string, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_time *>(mgp_local_time_from_string, string, memory);
|
||||
}
|
||||
|
||||
mgp_local_time *local_time_from_parameters(mgp_local_time_parameters *parameters, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_time *>(mgp_local_time_from_parameters, parameters, memory);
|
||||
}
|
||||
|
||||
mgp_local_time *local_time_copy(mgp_local_time *local_time, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_time *>(mgp_local_time_copy, local_time, memory);
|
||||
}
|
||||
|
||||
void local_time_destroy(mgp_local_time *local_time) { mgp_local_time_destroy(local_time); }
|
||||
|
||||
bool local_time_equal(mgp_local_time *first, mgp_local_time *second) {
|
||||
return MgInvoke<int>(mgp_local_time_equal, first, second);
|
||||
}
|
||||
|
||||
int local_time_get_hour(mgp_local_time *local_time) { return MgInvoke<int>(mgp_local_time_get_hour, local_time); }
|
||||
|
||||
int local_time_get_minute(mgp_local_time *local_time) { return MgInvoke<int>(mgp_local_time_get_minute, local_time); }
|
||||
|
||||
int local_time_get_second(mgp_local_time *local_time) { return MgInvoke<int>(mgp_local_time_get_second, local_time); }
|
||||
|
||||
int local_time_get_millisecond(mgp_local_time *local_time) {
|
||||
return MgInvoke<int>(mgp_local_time_get_millisecond, local_time);
|
||||
}
|
||||
|
||||
int local_time_get_microsecond(mgp_local_time *local_time) {
|
||||
return MgInvoke<int>(mgp_local_time_get_microsecond, local_time);
|
||||
}
|
||||
|
||||
int64_t local_time_timestamp(mgp_local_time *local_time) {
|
||||
return MgInvoke<int64_t>(mgp_local_time_timestamp, local_time);
|
||||
}
|
||||
|
||||
mgp_local_time *local_time_now(mgp_memory *memory) { return MgInvoke<mgp_local_time *>(mgp_local_time_now, memory); }
|
||||
|
||||
mgp_local_time *local_time_add_duration(mgp_local_time *local_time, mgp_duration *dur, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_time *>(mgp_local_time_add_duration, local_time, dur, memory);
|
||||
}
|
||||
|
||||
mgp_local_time *local_time_sub_duration(mgp_local_time *local_time, mgp_duration *dur, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_time *>(mgp_local_time_sub_duration, local_time, dur, memory);
|
||||
}
|
||||
|
||||
mgp_duration *local_time_diff(mgp_local_time *first, mgp_local_time *second, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_local_time_diff, first, second, memory);
|
||||
}
|
||||
|
||||
// mgp_local_date_time
|
||||
|
||||
mgp_local_date_time *local_date_time_from_string(const char *string, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_date_time *>(mgp_local_date_time_from_string, string, memory);
|
||||
}
|
||||
|
||||
mgp_local_date_time *local_date_time_from_parameters(mgp_local_date_time_parameters *parameters, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_date_time *>(mgp_local_date_time_from_parameters, parameters, memory);
|
||||
}
|
||||
|
||||
mgp_local_date_time *local_date_time_copy(mgp_local_date_time *local_date_time, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_date_time *>(mgp_local_date_time_copy, local_date_time, memory);
|
||||
}
|
||||
|
||||
void local_date_time_destroy(mgp_local_date_time *local_date_time) { mgp_local_date_time_destroy(local_date_time); }
|
||||
|
||||
bool local_date_time_equal(mgp_local_date_time *first, mgp_local_date_time *second) {
|
||||
return MgInvoke<int>(mgp_local_date_time_equal, first, second);
|
||||
}
|
||||
|
||||
int local_date_time_get_year(mgp_local_date_time *local_date_time) {
|
||||
return MgInvoke<int>(mgp_local_date_time_get_year, local_date_time);
|
||||
}
|
||||
|
||||
int local_date_time_get_month(mgp_local_date_time *local_date_time) {
|
||||
return MgInvoke<int>(mgp_local_date_time_get_month, local_date_time);
|
||||
}
|
||||
|
||||
int local_date_time_get_day(mgp_local_date_time *local_date_time) {
|
||||
return MgInvoke<int>(mgp_local_date_time_get_day, local_date_time);
|
||||
}
|
||||
|
||||
int local_date_time_get_hour(mgp_local_date_time *local_date_time) {
|
||||
return MgInvoke<int>(mgp_local_date_time_get_hour, local_date_time);
|
||||
}
|
||||
|
||||
int local_date_time_get_minute(mgp_local_date_time *local_date_time) {
|
||||
return MgInvoke<int>(mgp_local_date_time_get_minute, local_date_time);
|
||||
}
|
||||
|
||||
int local_date_time_get_second(mgp_local_date_time *local_date_time) {
|
||||
return MgInvoke<int>(mgp_local_date_time_get_second, local_date_time);
|
||||
}
|
||||
|
||||
int local_date_time_get_millisecond(mgp_local_date_time *local_date_time) {
|
||||
return MgInvoke<int>(mgp_local_date_time_get_millisecond, local_date_time);
|
||||
}
|
||||
|
||||
int local_date_time_get_microsecond(mgp_local_date_time *local_date_time) {
|
||||
return MgInvoke<int>(mgp_local_date_time_get_microsecond, local_date_time);
|
||||
}
|
||||
|
||||
int64_t local_date_time_timestamp(mgp_local_date_time *local_date_time) {
|
||||
return MgInvoke<int64_t>(mgp_local_date_time_timestamp, local_date_time);
|
||||
}
|
||||
|
||||
mgp_local_date_time *local_date_time_now(mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_date_time *>(mgp_local_date_time_now, memory);
|
||||
}
|
||||
|
||||
mgp_local_date_time *local_date_time_add_duration(mgp_local_date_time *local_date_time, mgp_duration *dur,
|
||||
mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_date_time *>(mgp_local_date_time_add_duration, local_date_time, dur, memory);
|
||||
}
|
||||
|
||||
mgp_local_date_time *local_date_time_sub_duration(mgp_local_date_time *local_date_time, mgp_duration *dur,
|
||||
mgp_memory *memory) {
|
||||
return MgInvoke<mgp_local_date_time *>(mgp_local_date_time_sub_duration, local_date_time, dur, memory);
|
||||
}
|
||||
|
||||
mgp_duration *local_date_time_diff(mgp_local_date_time *first, mgp_local_date_time *second, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_local_date_time_diff, first, second, memory);
|
||||
}
|
||||
|
||||
// mgp_duration
|
||||
|
||||
mgp_duration *duration_from_string(const char *string, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_duration_from_string, string, memory);
|
||||
}
|
||||
|
||||
mgp_duration *duration_from_parameters(mgp_duration_parameters *parameters, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_duration_from_parameters, parameters, memory);
|
||||
}
|
||||
|
||||
mgp_duration *duration_from_microseconds(int64_t microseconds, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_duration_from_microseconds, microseconds, memory);
|
||||
}
|
||||
|
||||
mgp_duration *duration_copy(mgp_duration *duration, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_duration_copy, duration, memory);
|
||||
}
|
||||
|
||||
void duration_destroy(mgp_duration *duration) { mgp_duration_destroy(duration); }
|
||||
|
||||
int64_t duration_get_microseconds(mgp_duration *duration) {
|
||||
return MgInvoke<int64_t>(mgp_duration_get_microseconds, duration);
|
||||
}
|
||||
|
||||
bool duration_equal(mgp_duration *first, mgp_duration *second) {
|
||||
return MgInvoke<int>(mgp_duration_equal, first, second);
|
||||
}
|
||||
|
||||
mgp_duration *duration_neg(mgp_duration *duration, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_duration_neg, duration, memory);
|
||||
}
|
||||
|
||||
mgp_duration *duration_add(mgp_duration *first, mgp_duration *second, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_duration_add, first, second, memory);
|
||||
}
|
||||
|
||||
mgp_duration *duration_sub(mgp_duration *first, mgp_duration *second, mgp_memory *memory) {
|
||||
return MgInvoke<mgp_duration *>(mgp_duration_sub, first, second, memory);
|
||||
}
|
||||
|
||||
// Procedure
|
||||
|
||||
mgp_proc *module_add_read_procedure(mgp_module *module, const char *name, mgp_proc_cb cb) {
|
||||
return MgInvoke<mgp_proc *>(mgp_module_add_read_procedure, module, name, cb);
|
||||
}
|
||||
|
||||
mgp_proc *module_add_write_procedure(mgp_module *module, const char *name, mgp_proc_cb cb) {
|
||||
return MgInvoke<mgp_proc *>(mgp_module_add_write_procedure, module, name, cb);
|
||||
}
|
||||
|
||||
void proc_add_arg(mgp_proc *proc, const char *name, mgp_type *type) {
|
||||
MgInvokeVoid(mgp_proc_add_arg, proc, name, type);
|
||||
}
|
||||
|
||||
void proc_add_opt_arg(mgp_proc *proc, const char *name, mgp_type *type, mgp_value *default_value) {
|
||||
MgInvokeVoid(mgp_proc_add_opt_arg, proc, name, type, default_value);
|
||||
}
|
||||
|
||||
void proc_add_result(mgp_proc *proc, const char *name, mgp_type *type) {
|
||||
MgInvokeVoid(mgp_proc_add_result, proc, name, type);
|
||||
}
|
||||
|
||||
void proc_add_deprecated_result(mgp_proc *proc, const char *name, mgp_type *type) {
|
||||
MgInvokeVoid(mgp_proc_add_deprecated_result, proc, name, type);
|
||||
}
|
||||
|
||||
bool must_abort(mgp_graph *graph) { return mgp_must_abort(graph); }
|
||||
|
||||
// mgp_result
|
||||
|
||||
void result_set_error_msg(mgp_result *res, const char *error_msg) {
|
||||
MgInvokeVoid(mgp_result_set_error_msg, res, error_msg);
|
||||
}
|
||||
|
||||
mgp_result_record *result_new_record(mgp_result *res) {
|
||||
return MgInvoke<mgp_result_record *>(mgp_result_new_record, res);
|
||||
}
|
||||
|
||||
void result_record_insert(mgp_result_record *record, const char *field_name, mgp_value *val) {
|
||||
MgInvokeVoid(mgp_result_record_insert, record, field_name, val);
|
||||
}
|
||||
|
||||
// Function
|
||||
|
||||
mgp_func *module_add_function(mgp_module *module, const char *name, mgp_func_cb cb) {
|
||||
return MgInvoke<mgp_func *>(mgp_module_add_function, module, name, cb);
|
||||
}
|
||||
|
||||
void func_add_arg(mgp_func *func, const char *name, mgp_type *type) {
|
||||
MgInvokeVoid(mgp_func_add_arg, func, name, type);
|
||||
}
|
||||
|
||||
void func_add_opt_arg(mgp_func *func, const char *name, mgp_type *type, mgp_value *default_value) {
|
||||
MgInvokeVoid(mgp_func_add_opt_arg, func, name, type, default_value);
|
||||
}
|
||||
|
||||
void func_result_set_error_msg(mgp_func_result *res, const char *msg, mgp_memory *memory) {
|
||||
MgInvokeVoid(mgp_func_result_set_error_msg, res, msg, memory);
|
||||
}
|
||||
|
||||
void func_result_set_value(mgp_func_result *res, mgp_value *value, mgp_memory *memory) {
|
||||
MgInvokeVoid(mgp_func_result_set_value, res, value, memory);
|
||||
}
|
||||
|
||||
} // namespace mgp
|
||||
57
include/mg_exceptions.hpp
Normal file
57
include/mg_exceptions.hpp
Normal file
@ -0,0 +1,57 @@
|
||||
// Copyright 2022 Memgraph Ltd.
|
||||
//
|
||||
// Use of this software is governed by the Business Source License
|
||||
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
|
||||
// License, and you may not use this file except in compliance with the Business Source License.
|
||||
//
|
||||
// As of the Change Date specified in that file, in accordance with
|
||||
// the Business Source License, use of this software will be governed
|
||||
// by the Apache License, Version 2.0, included in the file
|
||||
// licenses/APL.txt.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <exception>
|
||||
#include <iostream>
|
||||
|
||||
namespace mg_exception {
|
||||
struct NotEnoughMemoryException : public std::exception {
|
||||
const char *what() const throw() { return "Not enough memory!"; }
|
||||
};
|
||||
struct UnknownException : public std::exception {
|
||||
const char *what() const throw() { return "Unknown exception!"; }
|
||||
};
|
||||
struct AllocationException : public std::exception {
|
||||
const char *what() const throw() { return "Could not allocate memory!"; }
|
||||
};
|
||||
struct InsufficientBufferException : public std::exception {
|
||||
const char *what() const throw() { return "Buffer is not sufficient to process procedure!"; }
|
||||
};
|
||||
struct OutOfRangeException : public std::exception {
|
||||
const char *what() const throw() { return "Index out of range!"; }
|
||||
};
|
||||
struct LogicException : public std::exception {
|
||||
const char *what() const throw() { return "Logic exception, check the procedure signature!"; }
|
||||
};
|
||||
struct DeletedObjectException : public std::exception {
|
||||
const char *what() const throw() { return "Object is deleted!"; }
|
||||
};
|
||||
struct InvalidArgumentException : public std::exception {
|
||||
const char *what() const throw() { return "Invalid argument!"; }
|
||||
};
|
||||
struct InvalidIDException : public std::exception {
|
||||
const char *what() const throw() { return "Invalid ID!"; }
|
||||
};
|
||||
struct KeyAlreadyExistsException : public std::exception {
|
||||
const char *what() const throw() { return "Key you are trying to set already exists!"; }
|
||||
};
|
||||
struct ImmutableObjectException : public std::exception {
|
||||
const char *what() const throw() { return "Object you are trying to change is immutable!"; }
|
||||
};
|
||||
struct ValueConversionException : public std::exception {
|
||||
const char *what() const throw() { return "Error in value conversion!"; }
|
||||
};
|
||||
struct SerializationException : public std::exception {
|
||||
const char *what() const throw() { return "Error in serialization!"; }
|
||||
};
|
||||
} // namespace mg_exception
|
||||
@ -171,6 +171,8 @@ enum mgp_value_type {
|
||||
MGP_VALUE_TYPE_DURATION,
|
||||
};
|
||||
|
||||
enum mgp_error mgp_value_copy(struct mgp_value *val, struct mgp_memory *memory, struct mgp_value **result);
|
||||
|
||||
/// Free the memory used by the given mgp_value instance.
|
||||
void mgp_value_destroy(struct mgp_value *val);
|
||||
|
||||
@ -406,6 +408,8 @@ enum mgp_error mgp_value_get_duration(struct mgp_value *val, struct mgp_duration
|
||||
/// mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE is returned if unable to allocate a mgp_list.
|
||||
enum mgp_error mgp_list_make_empty(size_t capacity, struct mgp_memory *memory, struct mgp_list **result);
|
||||
|
||||
enum mgp_error mgp_list_copy(struct mgp_list *list, struct mgp_memory *memory, struct mgp_list **result);
|
||||
|
||||
/// Free the memory used by the given mgp_list and contained elements.
|
||||
void mgp_list_destroy(struct mgp_list *list);
|
||||
|
||||
@ -444,6 +448,8 @@ enum mgp_error mgp_list_at(struct mgp_list *list, size_t index, struct mgp_value
|
||||
/// mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE is returned if unable to allocate a mgp_map.
|
||||
enum mgp_error mgp_map_make_empty(struct mgp_memory *memory, struct mgp_map **result);
|
||||
|
||||
enum mgp_error mgp_map_copy(struct mgp_map *map, struct mgp_memory *memory, struct mgp_map **result);
|
||||
|
||||
/// Free the memory used by the given mgp_map and contained items.
|
||||
void mgp_map_destroy(struct mgp_map *map);
|
||||
|
||||
|
||||
2800
include/mgp.hpp
Normal file
2800
include/mgp.hpp
Normal file
File diff suppressed because it is too large
Load Diff
@ -8,29 +8,40 @@ disallow_in_source_build()
|
||||
|
||||
# Everything that is installed here, should be under the "query_modules" component.
|
||||
set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME "query_modules")
|
||||
|
||||
add_library(example SHARED example.c)
|
||||
target_include_directories(example PRIVATE ${CMAKE_SOURCE_DIR}/include)
|
||||
target_compile_options(example PRIVATE -Wall)
|
||||
|
||||
# Strip the library in release build.
|
||||
string(TOLOWER ${CMAKE_BUILD_TYPE} lower_build_type)
|
||||
if (lower_build_type STREQUAL "release")
|
||||
add_custom_command(TARGET example POST_BUILD
|
||||
COMMAND strip -s $<TARGET_FILE:example>
|
||||
COMMENT "Stripping symbols and sections from example module")
|
||||
endif()
|
||||
|
||||
install(PROGRAMS $<TARGET_FILE:example>
|
||||
add_library(example_c SHARED example.c)
|
||||
target_include_directories(example_c PRIVATE ${CMAKE_SOURCE_DIR}/include)
|
||||
target_compile_options(example_c PRIVATE -Wall)
|
||||
# Strip C example in release build.
|
||||
if (lower_build_type STREQUAL "release")
|
||||
add_custom_command(TARGET example_c POST_BUILD
|
||||
COMMAND strip -s $<TARGET_FILE:example_c>
|
||||
COMMENT "Stripping symbols and sections from the C example module")
|
||||
endif()
|
||||
install(PROGRAMS $<TARGET_FILE:example_c>
|
||||
DESTINATION lib/memgraph/query_modules
|
||||
RENAME example.so)
|
||||
RENAME example_c.so)
|
||||
# Also install the source of the example, so user can read it.
|
||||
install(FILES example.c DESTINATION lib/memgraph/query_modules/src)
|
||||
|
||||
# Install the Python example
|
||||
install(FILES example.py DESTINATION lib/memgraph/query_modules RENAME py_example.py)
|
||||
add_library(example_cpp SHARED example.cpp)
|
||||
target_include_directories(example_cpp PRIVATE ${CMAKE_SOURCE_DIR}/include)
|
||||
target_compile_options(example_cpp PRIVATE -Wall)
|
||||
# Strip C++ example in release build.
|
||||
if (lower_build_type STREQUAL "release")
|
||||
add_custom_command(TARGET example_cpp POST_BUILD
|
||||
COMMAND strip -s $<TARGET_FILE:example_cpp>
|
||||
COMMENT "Stripping symbols and sections from the C++ example module")
|
||||
endif()
|
||||
install(PROGRAMS $<TARGET_FILE:example_cpp>
|
||||
DESTINATION lib/memgraph/query_modules
|
||||
RENAME example_cpp.so)
|
||||
# Also install the source of the example, so user can read it.
|
||||
install(FILES example.cpp DESTINATION lib/memgraph/query_modules/src)
|
||||
|
||||
# Install the Python modules
|
||||
# Install the Python example and modules
|
||||
install(FILES example.py DESTINATION lib/memgraph/query_modules RENAME py_example.py)
|
||||
install(FILES graph_analyzer.py DESTINATION lib/memgraph/query_modules)
|
||||
install(FILES mgp_networkx.py DESTINATION lib/memgraph/query_modules)
|
||||
install(FILES nxalg.py DESTINATION lib/memgraph/query_modules)
|
||||
|
||||
103
query_modules/example.cpp
Normal file
103
query_modules/example.cpp
Normal file
@ -0,0 +1,103 @@
|
||||
// Copyright 2022 Memgraph Ltd.
|
||||
//
|
||||
// Use of this software is governed by the Business Source License
|
||||
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
|
||||
// License, and you may not use this file except in compliance with the Business Source License.
|
||||
//
|
||||
// As of the Change Date specified in that file, in accordance with
|
||||
// the Business Source License, use of this software will be governed
|
||||
// by the Apache License, Version 2.0, included in the file
|
||||
// licenses/APL.txt.
|
||||
|
||||
#include <mgp.hpp>
|
||||
|
||||
void ProcImpl(std::vector<mgp::Value> arguments, mgp::Graph graph, mgp::RecordFactory record_factory) {
|
||||
auto record = record_factory.NewRecord();
|
||||
record.Insert("out", true);
|
||||
}
|
||||
|
||||
void SampleReadProc(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *result, mgp_memory *memory) {
|
||||
try {
|
||||
mgp::memory = memory;
|
||||
|
||||
std::vector<mgp::Value> arguments;
|
||||
for (size_t i = 0; i < mgp::list_size(args); i++) {
|
||||
auto arg = mgp::Value(mgp::list_at(args, i));
|
||||
arguments.push_back(arg);
|
||||
}
|
||||
|
||||
ProcImpl(arguments, mgp::Graph(memgraph_graph), mgp::RecordFactory(result));
|
||||
} catch (const std::exception &e) {
|
||||
mgp::result_set_error_msg(result, e.what());
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void AddXNodes(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *result, mgp_memory *memory) {
|
||||
mgp::memory = memory;
|
||||
auto graph = mgp::Graph(memgraph_graph);
|
||||
|
||||
std::vector<mgp::Value> arguments;
|
||||
for (size_t i = 0; i < mgp::list_size(args); i++) {
|
||||
auto arg = mgp::Value(mgp::list_at(args, i));
|
||||
arguments.push_back(arg);
|
||||
}
|
||||
|
||||
for (int i = 0; i < arguments[0].ValueInt(); i++) {
|
||||
graph.CreateNode();
|
||||
}
|
||||
}
|
||||
|
||||
void Multiply(mgp_list *args, mgp_func_context *ctx, mgp_func_result *res, mgp_memory *memory) {
|
||||
mgp::memory = memory;
|
||||
|
||||
std::vector<mgp::Value> arguments;
|
||||
for (size_t i = 0; i < mgp::list_size(args); i++) {
|
||||
auto arg = mgp::Value(mgp::list_at(args, i));
|
||||
arguments.push_back(arg);
|
||||
}
|
||||
|
||||
auto result = mgp::Result(res);
|
||||
|
||||
auto first = arguments[0].ValueInt();
|
||||
auto second = arguments[1].ValueInt();
|
||||
|
||||
result.SetValue(first * second);
|
||||
}
|
||||
|
||||
extern "C" int mgp_init_module(struct mgp_module *module, struct mgp_memory *memory) {
|
||||
try {
|
||||
mgp::memory = memory;
|
||||
|
||||
AddProcedure(SampleReadProc, "return_true", mgp::ProdecureType::Read,
|
||||
{mgp::Parameter("param_1", mgp::Type::Int), mgp::Parameter("param_2", mgp::Type::Double, 2.3)},
|
||||
{mgp::Return("out", mgp::Type::Bool)}, module, memory);
|
||||
} catch (const std::exception &e) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
try {
|
||||
mgp::memory = memory;
|
||||
|
||||
mgp::AddProcedure(AddXNodes, "add_x_nodes", mgp::ProdecureType::Write, {mgp::Parameter("param_1", mgp::Type::Int)},
|
||||
{}, module, memory);
|
||||
|
||||
} catch (const std::exception &e) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
try {
|
||||
mgp::memory = memory;
|
||||
|
||||
mgp::AddFunction(Multiply, "multiply",
|
||||
{mgp::Parameter("int", mgp::Type::Int), mgp::Parameter("int", mgp::Type::Int, (int64_t)3)}, module,
|
||||
memory);
|
||||
|
||||
} catch (const std::exception &e) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int mgp_shutdown_module() { return 0; }
|
||||
@ -98,9 +98,15 @@ install(PROGRAMS $<TARGET_FILE:memgraph>
|
||||
# Install Python source for supporting our embedded Python.
|
||||
install(FILES ${CMAKE_SOURCE_DIR}/include/mgp.py
|
||||
DESTINATION lib/memgraph/python_support)
|
||||
# Install the include file for writing custom procedures.
|
||||
# Install the includes file for writing custom procedures in C and C++>
|
||||
install(FILES ${CMAKE_SOURCE_DIR}/include/mg_procedure.h
|
||||
DESTINATION include/memgraph)
|
||||
install(FILES ${CMAKE_SOURCE_DIR}/include/_mgp.hpp
|
||||
DESTINATION include/memgraph)
|
||||
install(FILES ${CMAKE_SOURCE_DIR}/include/mg_exceptions.hpp
|
||||
DESTINATION include/memgraph)
|
||||
install(FILES ${CMAKE_SOURCE_DIR}/include/mgp.hpp
|
||||
DESTINATION include/memgraph)
|
||||
# Install the config file (must use absolute path).
|
||||
install(FILES ${CMAKE_BINARY_DIR}/config/memgraph.conf
|
||||
DESTINATION /etc/memgraph RENAME memgraph.conf)
|
||||
|
||||
@ -856,6 +856,10 @@ mgp_edge *mgp_edge::Copy(const mgp_edge &edge, mgp_memory &memory) {
|
||||
edge.to.graph->impl);
|
||||
}
|
||||
|
||||
mgp_error mgp_value_copy(mgp_value *val, mgp_memory *memory, mgp_value **result) {
|
||||
return WrapExceptions([val, memory] { return NewRawMgpObject<mgp_value>(memory, *val); }, result);
|
||||
}
|
||||
|
||||
void mgp_value_destroy(mgp_value *val) { DeleteRawMgpObject(val); }
|
||||
|
||||
mgp_error mgp_value_make_null(mgp_memory *memory, mgp_value **result) {
|
||||
@ -971,6 +975,10 @@ mgp_error mgp_list_make_empty(size_t capacity, mgp_memory *memory, mgp_list **re
|
||||
result);
|
||||
}
|
||||
|
||||
mgp_error mgp_list_copy(mgp_list *list, mgp_memory *memory, mgp_list **result) {
|
||||
return WrapExceptions([list, memory] { return NewRawMgpObject<mgp_list>(memory, *list); }, result);
|
||||
}
|
||||
|
||||
void mgp_list_destroy(mgp_list *list) { DeleteRawMgpObject(list); }
|
||||
|
||||
namespace {
|
||||
@ -1018,6 +1026,10 @@ mgp_error mgp_map_make_empty(mgp_memory *memory, mgp_map **result) {
|
||||
return WrapExceptions([&memory] { return NewRawMgpObject<mgp_map>(memory); }, result);
|
||||
}
|
||||
|
||||
mgp_error mgp_map_copy(mgp_map *map, mgp_memory *memory, mgp_map **result) {
|
||||
return WrapExceptions([map, memory] { return NewRawMgpObject<mgp_map>(memory, *map); }, result);
|
||||
}
|
||||
|
||||
void mgp_map_destroy(mgp_map *map) { DeleteRawMgpObject(map); }
|
||||
|
||||
mgp_error mgp_map_insert(mgp_map *map, const char *key, mgp_value *value) {
|
||||
|
||||
@ -330,6 +330,10 @@ target_link_libraries(${test_prefix}auth_checker mg-glue mg-auth)
|
||||
add_unit_test(auth_handler.cpp)
|
||||
target_link_libraries(${test_prefix}auth_handler mg-glue mg-auth)
|
||||
|
||||
add_unit_test(cpp_api.cpp)
|
||||
target_link_libraries(${test_prefix}cpp_api mg-query)
|
||||
target_include_directories(${test_prefix}cpp_api PRIVATE ${CMAKE_SOURCE_DIR}/include)
|
||||
|
||||
# Test mg-auth
|
||||
if(MG_ENTERPRISE)
|
||||
add_unit_test(auth.cpp)
|
||||
|
||||
308
tests/unit/cpp_api.cpp
Normal file
308
tests/unit/cpp_api.cpp
Normal file
@ -0,0 +1,308 @@
|
||||
// Copyright 2022 Memgraph Ltd.
|
||||
//
|
||||
// Use of this software is governed by the Business Source License
|
||||
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
|
||||
// License, and you may not use this file except in compliance with the Business Source License.
|
||||
//
|
||||
// As of the Change Date specified in that file, in accordance with
|
||||
// the Business Source License, use of this software will be governed
|
||||
// by the Apache License, Version 2.0, included in the file
|
||||
// licenses/APL.txt.
|
||||
|
||||
#include <queue>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
|
||||
#include <gflags/gflags.h>
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "mgp.hpp"
|
||||
#include "query/procedure/mg_procedure_impl.hpp"
|
||||
#include "storage/v2/view.hpp"
|
||||
|
||||
struct CppApiTestFixture : public ::testing::Test {
|
||||
protected:
|
||||
virtual void SetUp() { mgp::memory = &memory; }
|
||||
|
||||
mgp_graph CreateGraph(const memgraph::storage::View view = memgraph::storage::View::NEW) {
|
||||
// the execution context can be null as it shouldn't be used in these tests
|
||||
return mgp_graph{&CreateDbAccessor(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION), view, ctx_.get()};
|
||||
}
|
||||
|
||||
memgraph::query::DbAccessor &CreateDbAccessor(const memgraph::storage::IsolationLevel isolationLevel) {
|
||||
accessors_.push_back(storage.Access(isolationLevel));
|
||||
db_accessors_.emplace_back(&accessors_.back());
|
||||
return db_accessors_.back();
|
||||
}
|
||||
|
||||
memgraph::storage::Storage storage;
|
||||
mgp_memory memory{memgraph::utils::NewDeleteResource()};
|
||||
|
||||
private:
|
||||
std::list<memgraph::storage::Storage::Accessor> accessors_;
|
||||
std::list<memgraph::query::DbAccessor> db_accessors_;
|
||||
std::unique_ptr<memgraph::query::ExecutionContext> ctx_ = std::make_unique<memgraph::query::ExecutionContext>();
|
||||
};
|
||||
|
||||
TEST_F(CppApiTestFixture, TestGraph) {
|
||||
mgp_graph raw_graph = CreateGraph();
|
||||
auto graph = mgp::Graph(&raw_graph);
|
||||
|
||||
auto node_1 = graph.CreateNode();
|
||||
|
||||
ASSERT_EQ(graph.Order(), 1);
|
||||
ASSERT_EQ(graph.Size(), 0);
|
||||
|
||||
auto node_2 = graph.CreateNode();
|
||||
|
||||
ASSERT_EQ(graph.Order(), 2);
|
||||
ASSERT_EQ(graph.Size(), 0);
|
||||
|
||||
auto relationship = graph.CreateRelationship(node_1, node_2, "edge_type");
|
||||
|
||||
ASSERT_EQ(graph.Order(), 2);
|
||||
ASSERT_EQ(graph.Size(), 1);
|
||||
|
||||
ASSERT_EQ(graph.ContainsNode(node_1), true);
|
||||
ASSERT_EQ(graph.ContainsNode(node_2), true);
|
||||
|
||||
ASSERT_EQ(graph.ContainsRelationship(relationship), true);
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestId) {
|
||||
int64_t int_1 = 8;
|
||||
uint64_t int_2 = 8;
|
||||
int64_t int_3 = 7;
|
||||
uint64_t int_4 = 7;
|
||||
|
||||
auto id_1 = mgp::Id::FromInt(int_1);
|
||||
auto id_2 = mgp::Id::FromUint(int_2);
|
||||
auto id_3 = mgp::Id::FromInt(int_3);
|
||||
auto id_4 = mgp::Id::FromUint(int_4);
|
||||
|
||||
ASSERT_EQ(id_1.AsInt(), 8);
|
||||
ASSERT_EQ(id_1.AsUint(), 8);
|
||||
ASSERT_EQ(id_2.AsInt(), 8);
|
||||
ASSERT_EQ(id_2.AsUint(), 8);
|
||||
|
||||
ASSERT_EQ(id_1, id_2);
|
||||
|
||||
ASSERT_EQ(id_1 != id_2, false);
|
||||
|
||||
ASSERT_EQ(id_1 == id_3, false);
|
||||
ASSERT_EQ(id_1 == id_4, false);
|
||||
ASSERT_EQ(id_2 == id_3, false);
|
||||
ASSERT_EQ(id_2 == id_4, false);
|
||||
|
||||
ASSERT_NE(id_1, id_3);
|
||||
ASSERT_NE(id_1, id_4);
|
||||
ASSERT_NE(id_2, id_3);
|
||||
ASSERT_NE(id_2, id_4);
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestList) {
|
||||
auto list_1 = mgp::List();
|
||||
|
||||
ASSERT_EQ(list_1.Size(), 0);
|
||||
|
||||
auto list_2 = mgp::List(10);
|
||||
|
||||
ASSERT_EQ(list_2.Size(), 0);
|
||||
ASSERT_EQ(list_1, list_2);
|
||||
|
||||
auto a = mgp::Value("a");
|
||||
list_2.Append(a);
|
||||
list_2.AppendExtend(a);
|
||||
|
||||
ASSERT_EQ(list_2.Size(), 2);
|
||||
|
||||
std::vector<mgp::Value> values{mgp::Value("a"), mgp::Value("b"), mgp::Value("c")};
|
||||
auto list_3 = mgp::List(values);
|
||||
|
||||
ASSERT_EQ(list_3.Size(), 3);
|
||||
|
||||
auto list_4 = mgp::List({mgp::Value("d"), mgp::Value("e"), mgp::Value("f")});
|
||||
ASSERT_EQ(list_4.Size(), 3);
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestMap) {
|
||||
auto map_1 = mgp::Map();
|
||||
|
||||
std::map<std::string_view, mgp::Value> map_1a;
|
||||
for (const auto &e : map_1) {
|
||||
map_1a.insert(std::pair<std::string_view, mgp::Value>(e.key, e.value));
|
||||
}
|
||||
|
||||
ASSERT_EQ(map_1.Size(), 0);
|
||||
ASSERT_EQ(map_1a.size(), 0);
|
||||
|
||||
auto map_2 = mgp::Map();
|
||||
|
||||
auto y = mgp::Value("y");
|
||||
map_2.Insert("x", y);
|
||||
|
||||
ASSERT_EQ(map_2.Size(), 1);
|
||||
ASSERT_NE(map_1, map_2);
|
||||
|
||||
auto v_1 = mgp::Value("1");
|
||||
auto v_2 = mgp::Value("2");
|
||||
auto p_1 = std::pair{"a", v_1};
|
||||
auto p_2 = std::pair{"b", v_2};
|
||||
auto map_3 = mgp::Map({p_1, p_2});
|
||||
|
||||
ASSERT_EQ(map_3.Size(), 2);
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestNode) {
|
||||
mgp_graph raw_graph = CreateGraph();
|
||||
auto graph = mgp::Graph(&raw_graph);
|
||||
|
||||
auto node_1 = graph.CreateNode();
|
||||
|
||||
ASSERT_EQ(node_1.HasLabel("L1"), false);
|
||||
|
||||
node_1.AddLabel("L1");
|
||||
ASSERT_EQ(node_1.HasLabel("L1"), true);
|
||||
|
||||
node_1.AddLabel("L2");
|
||||
ASSERT_EQ(node_1.HasLabel("L1"), true);
|
||||
ASSERT_EQ(node_1.HasLabel("L2"), true);
|
||||
|
||||
ASSERT_EQ(node_1.Properties().Size(), 0);
|
||||
|
||||
auto node_2 = graph.GetNodeById(node_1.Id());
|
||||
|
||||
ASSERT_EQ(node_1, node_2);
|
||||
|
||||
int count_out_relationships = 0;
|
||||
for (const auto _ : node_1.OutRelationships()) {
|
||||
count_out_relationships++;
|
||||
}
|
||||
ASSERT_EQ(count_out_relationships, 0);
|
||||
|
||||
int count_in_relationships = 0;
|
||||
for (const auto _ : node_1.InRelationships()) {
|
||||
count_in_relationships++;
|
||||
}
|
||||
|
||||
ASSERT_EQ(count_in_relationships, 0);
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestNodeWithNeighbors) {
|
||||
mgp_graph raw_graph = CreateGraph();
|
||||
auto graph = mgp::Graph(&raw_graph);
|
||||
|
||||
auto node_1 = graph.CreateNode();
|
||||
auto node_2 = graph.CreateNode();
|
||||
|
||||
auto relationship = graph.CreateRelationship(node_1, node_2, "edge_type");
|
||||
|
||||
int count_out_relationships = 0;
|
||||
int count_in_relationships = 0;
|
||||
for (const auto &node : graph.Nodes()) {
|
||||
for (const auto _ : node.OutRelationships()) {
|
||||
count_out_relationships++;
|
||||
}
|
||||
|
||||
for (const auto _ : node.OutRelationships()) {
|
||||
count_in_relationships++;
|
||||
}
|
||||
}
|
||||
|
||||
ASSERT_EQ(count_out_relationships, 1);
|
||||
ASSERT_EQ(count_in_relationships, 1);
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestRelationship) {
|
||||
mgp_graph raw_graph = CreateGraph();
|
||||
auto graph = mgp::Graph(&raw_graph);
|
||||
|
||||
auto node_1 = graph.CreateNode();
|
||||
auto node_2 = graph.CreateNode();
|
||||
|
||||
auto relationship = graph.CreateRelationship(node_1, node_2, "edge_type");
|
||||
|
||||
ASSERT_EQ(relationship.Type(), "edge_type");
|
||||
ASSERT_EQ(relationship.Properties().Size(), 0);
|
||||
ASSERT_EQ(relationship.From().Id(), node_1.Id());
|
||||
ASSERT_EQ(relationship.To().Id(), node_2.Id());
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestPath) {
|
||||
mgp_graph raw_graph = CreateGraph();
|
||||
auto graph = mgp::Graph(&raw_graph);
|
||||
|
||||
auto node_1 = graph.CreateNode();
|
||||
auto node_2 = graph.CreateNode();
|
||||
|
||||
auto relationship = graph.CreateRelationship(node_1, node_2, "edge_type");
|
||||
|
||||
auto node_0 = graph.GetNodeById(mgp::Id::FromInt(0));
|
||||
auto path = mgp::Path(node_0);
|
||||
|
||||
ASSERT_EQ(path.Length(), 0);
|
||||
|
||||
path.Expand(relationship);
|
||||
|
||||
ASSERT_EQ(path.Length(), 1);
|
||||
ASSERT_EQ(path.GetNodeAt(0).Id(), node_0.Id());
|
||||
ASSERT_EQ(path.GetRelationshipAt(0).Id(), relationship.Id());
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestDate) {
|
||||
auto date_1 = mgp::Date("2022-04-09");
|
||||
auto date_2 = mgp::Date(2022, 4, 9);
|
||||
|
||||
auto date_3 = mgp::Date::Now();
|
||||
|
||||
ASSERT_EQ(date_1.Year(), 2022);
|
||||
ASSERT_EQ(date_1.Month(), 4);
|
||||
ASSERT_EQ(date_1.Day(), 9);
|
||||
ASSERT_EQ(date_1.Timestamp() >= 0, true);
|
||||
|
||||
ASSERT_EQ(date_1, date_2);
|
||||
ASSERT_NE(date_2, date_3);
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestLocalTime) {
|
||||
auto lt_1 = mgp::LocalTime("09:15:00");
|
||||
auto lt_2 = mgp::LocalTime(9, 15, 0, 0, 0);
|
||||
auto lt_3 = mgp::LocalTime::Now();
|
||||
|
||||
ASSERT_EQ(lt_1.Hour(), 9);
|
||||
ASSERT_EQ(lt_1.Minute(), 15);
|
||||
ASSERT_EQ(lt_1.Second(), 0);
|
||||
ASSERT_EQ(lt_1.Millisecond() >= 0, true);
|
||||
ASSERT_EQ(lt_1.Microsecond() >= 0, true);
|
||||
ASSERT_EQ(lt_1.Timestamp() >= 0, true);
|
||||
|
||||
ASSERT_EQ(lt_1, lt_2);
|
||||
ASSERT_NE(lt_2, lt_3);
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestLocalDateTime) {
|
||||
auto ldt_1 = mgp::LocalDateTime("2021-10-05T14:15:00");
|
||||
auto ldt_2 = mgp::LocalDateTime(2021, 10, 5, 14, 15, 0, 0, 0);
|
||||
|
||||
ASSERT_EQ(ldt_1.Year(), 2021);
|
||||
ASSERT_EQ(ldt_1.Month(), 10);
|
||||
ASSERT_EQ(ldt_1.Day(), 5);
|
||||
ASSERT_EQ(ldt_1.Hour(), 14);
|
||||
ASSERT_EQ(ldt_1.Minute(), 15);
|
||||
ASSERT_EQ(ldt_1.Second(), 0);
|
||||
ASSERT_EQ(ldt_1.Millisecond() >= 0, true);
|
||||
ASSERT_EQ(ldt_1.Microsecond() >= 0, true);
|
||||
ASSERT_EQ(ldt_1.Timestamp() >= 0, true);
|
||||
|
||||
ASSERT_EQ(ldt_1, ldt_2);
|
||||
}
|
||||
|
||||
TEST_F(CppApiTestFixture, TestDuration) {
|
||||
auto duration_2 = mgp::Duration("PT2M2.33S");
|
||||
auto duration_3 = mgp::Duration(1465355);
|
||||
auto duration_4 = mgp::Duration(5, 14, 15, 0, 0, 0);
|
||||
|
||||
ASSERT_EQ(duration_3.Microseconds(), 1465355);
|
||||
ASSERT_NE(duration_2, duration_3);
|
||||
ASSERT_NE(duration_3, duration_4);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user