Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Rework API for node-rel-evaluator #1763

Merged
merged 9 commits into from
Jul 6, 2023
Merged

Rework API for node-rel-evaluator #1763

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
b2411cd
Add node & rel evaluator
andyfengHKU Jun 29, 2023
8ea5d0f
Node.js and Python tests pass.
mewim Jul 5, 2023
d58977b
Fix C API tests
mewim Jul 5, 2023
08dfe04
Fix Java tests
mewim Jul 5, 2023
1de4ba9
Merge remote-tracking branch 'origin/node-rel-evaluator' into node-re…
mewim Jul 5, 2023
bfb486e
Format
mewim Jul 6, 2023
d0ff70c
X
mewim Jul 6, 2023
cc51ad8
Improve efficiency of getters for APIs.
mewim Jul 6, 2023
3622664
Merge remote-tracking branch 'origin/node-rel-evaluator' into node-re…
mewim Jul 6, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
183 changes: 46 additions & 137 deletions src/c_api/value.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -79,20 +79,6 @@ kuzu_value* kuzu_value_create_internal_id(kuzu_internal_id_t val_) {
return c_value;
}

kuzu_value* kuzu_value_create_node_val(kuzu_node_val* val_) {
auto* c_value = (kuzu_value*)calloc(1, sizeof(kuzu_value));
auto node_val = std::make_unique<NodeVal>(*static_cast<NodeVal*>(val_->_node_val));
c_value->_value = new Value(std::move(node_val));
return c_value;
}

kuzu_value* kuzu_value_create_rel_val(kuzu_rel_val* val_) {
auto* c_value = (kuzu_value*)calloc(1, sizeof(kuzu_value));
auto rel_val = std::make_unique<RelVal>(*static_cast<RelVal*>(val_->_rel_val));
c_value->_value = new Value(std::move(rel_val));
return c_value;
}

kuzu_value* kuzu_value_create_date(kuzu_date_t val_) {
auto* c_value = (kuzu_value*)calloc(1, sizeof(kuzu_value));
auto date = date_t(val_.days);
Expand Down Expand Up @@ -215,20 +201,6 @@ kuzu_internal_id_t kuzu_value_get_internal_id(kuzu_value* value) {
return c_id;
}

kuzu_node_val* kuzu_value_get_node_val(kuzu_value* value) {
auto node_val = static_cast<Value*>(value->_value)->getValue<NodeVal>();
auto* c_node_val = (kuzu_node_val*)calloc(1, sizeof(kuzu_node_val));
c_node_val->_node_val = new NodeVal(node_val);
return c_node_val;
}

kuzu_rel_val* kuzu_value_get_rel_val(kuzu_value* value) {
auto rel_val = static_cast<Value*>(value->_value)->getValue<RelVal>();
auto* c_rel_val = (kuzu_rel_val*)calloc(1, sizeof(kuzu_rel_val));
c_rel_val->_rel_val = new RelVal(rel_val);
return c_rel_val;
}

kuzu_date_t kuzu_value_get_date(kuzu_value* value) {
auto date_val = static_cast<Value*>(value->_value)->getValue<date_t>();
kuzu_date_t c_date;
Expand Down Expand Up @@ -266,185 +238,122 @@ char* kuzu_value_to_string(kuzu_value* value) {
return c_string;
}

kuzu_node_val* kuzu_node_val_create(kuzu_internal_id_t id, const char* label) {
auto id_val = std::make_unique<Value>(internalID_t(id.offset, id.table_id));
auto label_val = std::make_unique<Value>(label);
auto* node_val = new NodeVal(std::move(id_val), std::move(label_val));
auto* c_node_val = (kuzu_node_val*)calloc(1, sizeof(kuzu_node_val));
c_node_val->_node_val = node_val;
return c_node_val;
}

kuzu_node_val* kuzu_node_val_clone(kuzu_node_val* node_val) {
auto* c_node_val = (kuzu_node_val*)calloc(1, sizeof(kuzu_node_val));
c_node_val->_node_val = new NodeVal(*static_cast<NodeVal*>(node_val->_node_val));
return c_node_val;
}

void kuzu_node_val_destroy(kuzu_node_val* node_val) {
if (node_val == nullptr) {
return;
}
if ((node_val->_node_val != nullptr) && (!node_val->_is_owned_by_cpp)) {
delete static_cast<NodeVal*>(node_val->_node_val);
}
free(node_val);
}

kuzu_value* kuzu_node_val_get_id_val(kuzu_node_val* node_val) {
auto id_val = static_cast<NodeVal*>(node_val->_node_val)->getNodeIDVal();
kuzu_value* kuzu_node_val_get_id_val(kuzu_value* node_val) {
auto id_val = NodeVal::getNodeIDVal(static_cast<Value*>(node_val->_value));
auto* c_value = (kuzu_value*)malloc(sizeof(kuzu_value));
c_value->_value = id_val;
c_value->_is_owned_by_cpp = true;
c_value->_value = id_val.release();
c_value->_is_owned_by_cpp = false;
return c_value;
}

kuzu_value* kuzu_node_val_get_label_val(kuzu_node_val* node_val) {
auto label_val = static_cast<NodeVal*>(node_val->_node_val)->getLabelVal();
kuzu_value* kuzu_node_val_get_label_val(kuzu_value* node_val) {
auto label_val = NodeVal::getLabelVal(static_cast<Value*>(node_val->_value));
auto* c_value = (kuzu_value*)malloc(sizeof(kuzu_value));
c_value->_value = label_val;
c_value->_is_owned_by_cpp = true;
c_value->_value = label_val.release();
c_value->_is_owned_by_cpp = false;
return c_value;
}

kuzu_internal_id_t kuzu_node_val_get_id(kuzu_node_val* node_val) {
auto id = static_cast<NodeVal*>(node_val->_node_val)->getNodeID();
kuzu_internal_id_t kuzu_node_val_get_id(kuzu_value* node_val) {
auto id = NodeVal::getNodeID(static_cast<Value*>(node_val->_value));
kuzu_internal_id_t c_id;
c_id.offset = id.offset;
c_id.table_id = id.tableID;
return c_id;
}

char* kuzu_node_val_get_label_name(kuzu_node_val* node_val) {
auto label = static_cast<NodeVal*>(node_val->_node_val)->getLabelName();
auto* c_string = (char*)malloc(label.size() + 1);
strcpy(c_string, label.c_str());
char* kuzu_node_val_get_label_name(kuzu_value* node_val) {
auto label_name = NodeVal::getLabelName(static_cast<Value*>(node_val->_value));
auto* c_string = (char*)malloc(label_name.size() + 1);
strcpy(c_string, label_name.c_str());
return c_string;
}

uint64_t kuzu_node_val_get_property_size(kuzu_node_val* node_val) {
return static_cast<NodeVal*>(node_val->_node_val)->getProperties().size();
uint64_t kuzu_node_val_get_property_size(kuzu_value* node_val) {
return NodeVal::getNumProperties(static_cast<Value*>(node_val->_value));
}

char* kuzu_node_val_get_property_name_at(kuzu_node_val* node_val, uint64_t index) {
auto name = static_cast<NodeVal*>(node_val->_node_val)->getProperties().at(index).first;
char* kuzu_node_val_get_property_name_at(kuzu_value* node_val, uint64_t index) {
auto name = NodeVal::getPropertyName(static_cast<Value*>(node_val->_value), index);
auto* c_string = (char*)malloc(name.size() + 1);
strcpy(c_string, name.c_str());
return c_string;
}

kuzu_value* kuzu_node_val_get_property_value_at(kuzu_node_val* node_val, uint64_t index) {
auto& value = static_cast<NodeVal*>(node_val->_node_val)->getProperties().at(index).second;
kuzu_value* kuzu_node_val_get_property_value_at(kuzu_value* node_val, uint64_t index) {
auto value = NodeVal::getPropertyValueReference(static_cast<Value*>(node_val->_value), index);
auto* c_value = (kuzu_value*)malloc(sizeof(kuzu_value));
c_value->_value = value.get();
c_value->_value = value;
c_value->_is_owned_by_cpp = true;
return c_value;
}

void kuzu_node_val_add_property(kuzu_node_val* node_val, const char* name, kuzu_value* property) {
auto value_ = std::make_unique<Value>(*static_cast<Value*>(property->_value));
static_cast<NodeVal*>(node_val->_node_val)->addProperty(std::string(name), std::move(value_));
}

char* kuzu_node_val_to_string(kuzu_node_val* node_val) {
auto string_val = static_cast<NodeVal*>(node_val->_node_val)->toString();
char* kuzu_node_val_to_string(kuzu_value* node_val) {
auto string_val = NodeVal::toString(static_cast<Value*>(node_val->_value));
auto* c_string = (char*)malloc(string_val.size() + 1);
strcpy(c_string, string_val.c_str());
return c_string;
}

kuzu_rel_val* kuzu_rel_val_create(
kuzu_internal_id_t src_id, kuzu_internal_id_t dst_id, const char* label) {
auto src_id_val = std::make_unique<Value>(internalID_t(src_id.offset, src_id.table_id));
auto dst_id_val = std::make_unique<Value>(internalID_t(dst_id.offset, dst_id.table_id));
auto label_val =
std::make_unique<Value>(LogicalType{LogicalTypeID::STRING}, std::string(label));
auto* c_rel_val = (kuzu_rel_val*)calloc(1, sizeof(kuzu_rel_val));
c_rel_val->_rel_val =
new RelVal(std::move(src_id_val), std::move(dst_id_val), std::move(label_val));
return c_rel_val;
}

kuzu_rel_val* kuzu_rel_val_clone(kuzu_rel_val* rel_val) {
auto* c_rel_val = (kuzu_rel_val*)calloc(1, sizeof(kuzu_rel_val));
c_rel_val->_rel_val = new RelVal(*static_cast<RelVal*>(rel_val->_rel_val));
return c_rel_val;
}

void kuzu_rel_val_destroy(kuzu_rel_val* rel_val) {
if (rel_val == nullptr) {
return;
}
if ((rel_val->_rel_val != nullptr) && (!rel_val->_is_owned_by_cpp)) {
delete static_cast<RelVal*>(rel_val->_rel_val);
}
free(rel_val);
}

kuzu_value* kuzu_rel_val_get_src_id_val(kuzu_rel_val* rel_val) {
auto src_id_val = static_cast<RelVal*>(rel_val->_rel_val)->getSrcNodeIDVal();
kuzu_value* kuzu_rel_val_get_src_id_val(kuzu_value* rel_val) {
auto src_id_val = RelVal::getSrcNodeIDVal(static_cast<Value*>(rel_val->_value));
auto* c_value = (kuzu_value*)malloc(sizeof(kuzu_value));
c_value->_value = src_id_val;
c_value->_is_owned_by_cpp = true;
c_value->_value = src_id_val.release();
c_value->_is_owned_by_cpp = false;
return c_value;
}

kuzu_value* kuzu_rel_val_get_dst_id_val(kuzu_rel_val* rel_val) {
auto dst_id_val = static_cast<RelVal*>(rel_val->_rel_val)->getDstNodeIDVal();
kuzu_value* kuzu_rel_val_get_dst_id_val(kuzu_value* rel_val) {
auto dst_id_val = RelVal::getDstNodeIDVal(static_cast<Value*>(rel_val->_value));
auto* c_value = (kuzu_value*)malloc(sizeof(kuzu_value));
c_value->_value = dst_id_val;
c_value->_is_owned_by_cpp = true;
c_value->_value = dst_id_val.release();
c_value->_is_owned_by_cpp = false;
return c_value;
}

kuzu_internal_id_t kuzu_rel_val_get_src_id(kuzu_rel_val* rel_val) {
auto id = static_cast<RelVal*>(rel_val->_rel_val)->getSrcNodeID();
kuzu_internal_id_t kuzu_rel_val_get_src_id(kuzu_value* rel_val) {
auto id = RelVal::getSrcNodeID(static_cast<Value*>(rel_val->_value));
kuzu_internal_id_t c_id;
c_id.offset = id.offset;
c_id.table_id = id.tableID;
return c_id;
}

kuzu_internal_id_t kuzu_rel_val_get_dst_id(kuzu_rel_val* rel_val) {
auto id = static_cast<RelVal*>(rel_val->_rel_val)->getDstNodeID();
kuzu_internal_id_t kuzu_rel_val_get_dst_id(kuzu_value* rel_val) {
auto id = RelVal::getDstNodeID(static_cast<Value*>(rel_val->_value));
kuzu_internal_id_t c_id;
c_id.offset = id.offset;
c_id.table_id = id.tableID;
return c_id;
}

char* kuzu_rel_val_get_label_name(kuzu_rel_val* rel_val) {
auto label = static_cast<RelVal*>(rel_val->_rel_val)->getLabelName();
char* kuzu_rel_val_get_label_name(kuzu_value* rel_val) {
auto label = RelVal::getLabelName(static_cast<Value*>(rel_val->_value));
auto* c_string = (char*)malloc(label.size() + 1);
strcpy(c_string, label.c_str());
return c_string;
}

uint64_t kuzu_rel_val_get_property_size(kuzu_rel_val* rel_val) {
return static_cast<RelVal*>(rel_val->_rel_val)->getProperties().size();
uint64_t kuzu_rel_val_get_property_size(kuzu_value* rel_val) {
return RelVal::getNumProperties(static_cast<Value*>(rel_val->_value));
}
char* kuzu_rel_val_get_property_name_at(kuzu_rel_val* rel_val, uint64_t index) {
auto& name = static_cast<RelVal*>(rel_val->_rel_val)->getProperties().at(index).first;
char* kuzu_rel_val_get_property_name_at(kuzu_value* rel_val, uint64_t index) {
auto name = RelVal::getPropertyName(static_cast<Value*>(rel_val->_value), index);
auto* c_string = (char*)malloc(name.size() + 1);
strcpy(c_string, name.c_str());
return c_string;
}

kuzu_value* kuzu_rel_val_get_property_value_at(kuzu_rel_val* rel_val, uint64_t index) {
auto& value = static_cast<RelVal*>(rel_val->_rel_val)->getProperties().at(index).second;
kuzu_value* kuzu_rel_val_get_property_value_at(kuzu_value* rel_val, uint64_t index) {
auto value = RelVal::getPropertyValueReference(static_cast<Value*>(rel_val->_value), index);
auto* c_value = (kuzu_value*)malloc(sizeof(kuzu_value));
c_value->_value = value.get();
c_value->_value = value;
c_value->_is_owned_by_cpp = true;
return c_value;
}

void kuzu_rel_val_add_property(kuzu_rel_val* rel_val, const char* name, kuzu_value* property) {
auto value_ = std::make_unique<Value>(*static_cast<Value*>(property->_value));
static_cast<RelVal*>(rel_val->_rel_val)->addProperty(std::string(name), std::move(value_));
}

char* kuzu_rel_val_to_string(kuzu_rel_val* rel_val) {
auto string_val = static_cast<RelVal*>(rel_val->_rel_val)->toString();
char* kuzu_rel_val_to_string(kuzu_value* rel_val) {
auto string_val = RelVal::toString(static_cast<Value*>(rel_val->_value));
auto* c_string = (char*)malloc(string_val.size() + 1);
strcpy(c_string, string_val.c_str());
return c_string;
Expand Down
30 changes: 18 additions & 12 deletions src/common/arrow/arrow_row_batch.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -226,14 +226,17 @@ void ArrowRowBatch::templateCopyNonNullValue<LogicalTypeID::INTERNAL_ID>(
template<>
void ArrowRowBatch::templateCopyNonNullValue<LogicalTypeID::NODE>(
ArrowVector* vector, const main::DataTypeInfo& typeInfo, Value* value, std::int64_t pos) {
appendValue(
vector->childData[0].get(), *typeInfo.childrenTypesInfo[0], value->nodeVal->getNodeIDVal());
appendValue(
vector->childData[1].get(), *typeInfo.childrenTypesInfo[1], value->nodeVal->getLabelVal());
appendValue(vector->childData[0].get(), *typeInfo.childrenTypesInfo[0],
NodeVal::getNodeIDVal(value).get());
appendValue(vector->childData[1].get(), *typeInfo.childrenTypesInfo[1],
NodeVal::getLabelVal(value).get());
std::int64_t propertyId = 2;
for (auto& [name, val] : value->nodeVal->getProperties()) {
appendValue(vector->childData[propertyId].get(), *typeInfo.childrenTypesInfo[propertyId],
val.get());
auto numProperties = NodeVal::getNumProperties(value);
for (auto i = 0u; i < numProperties; i++) {
auto name = NodeVal::getPropertyName(value, i);
auto val = NodeVal::getPropertyValueReference(value, i);
appendValue(
vector->childData[propertyId].get(), *typeInfo.childrenTypesInfo[propertyId], val);
propertyId++;
}
}
Expand All @@ -242,13 +245,16 @@ template<>
void ArrowRowBatch::templateCopyNonNullValue<LogicalTypeID::REL>(
ArrowVector* vector, const main::DataTypeInfo& typeInfo, Value* value, std::int64_t pos) {
appendValue(vector->childData[0].get(), *typeInfo.childrenTypesInfo[0],
value->relVal->getSrcNodeIDVal());
RelVal::getSrcNodeIDVal(value).get());
appendValue(vector->childData[1].get(), *typeInfo.childrenTypesInfo[1],
value->relVal->getDstNodeIDVal());
RelVal::getDstNodeIDVal(value).get());
std::int64_t propertyId = 2;
for (auto& [name, val] : value->relVal->getProperties()) {
appendValue(vector->childData[propertyId].get(), *typeInfo.childrenTypesInfo[propertyId],
val.get());
auto numProperties = NodeVal::getNumProperties(value);
for (auto i = 0u; i < numProperties; i++) {
auto name = NodeVal::getPropertyName(value, i);
auto val = NodeVal::getPropertyValueReference(value, i);
appendValue(
vector->childData[propertyId].get(), *typeInfo.childrenTypesInfo[propertyId], val);
propertyId++;
}
}
Expand Down
Loading
Loading