@graphscope-neug/osx-arm64 0.1.2

package/src/neug_binding.cc

@@ -0,0 +1,65 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed 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.
+ */
+
+#include <napi.h>
+
+#include <iostream>
+#include <string>
+
+#include <glog/logging.h>
+
+#include "neug/utils/exception/exception.h"
+#include "node_connection.h"
+#include "node_database.h"
+#include "node_query_request.h"
+#include "node_query_result.h"
+
+namespace neug {
+
+void SetupLogging() {
+  google::InitGoogleLogging("neug");
+  const char* debug = std::getenv("DEBUG");
+
+  if (debug) {
+    std::string mode = debug;
+    if (mode == "1" || mode == "true" || mode == "ON") {
+      FLAGS_minloglevel = 0;     // 0 for verbose
+      FLAGS_logtostderr = true;  // Log to stderr
+    } else {
+      std::cerr << "Invalid DEBUG value: " << mode
+                << ". Expected '1', 'true', or 'ON'." << std::endl;
+      FLAGS_minloglevel = 2;      // 2 for error
+      FLAGS_logtostderr = false;  // Log to file instead of stderr
+    }
+  } else {
+    FLAGS_minloglevel = 2;      // 2 for error
+    FLAGS_logtostderr = false;  // Log to file instead of stderr
+  }
+}
+
+}  // namespace neug
+
+static Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
+  neug::NodeDatabase::Init(env, exports);
+  neug::NodeConnection::Init(env, exports);
+  neug::NodeQueryResult::Init(env, exports);
+  neug::NodeQueryRequest::Init(env, exports);
+
+  neug::SetupLogging();
+
+  return exports;
+}
+
+NODE_API_MODULE(neug_node_bind, InitAll)

package/src/node_connection.cc

@@ -0,0 +1,114 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed 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.
+ */
+
+#include "node_connection.h"
+
+#include <memory>
+#include <string>
+
+#include "neug/execution/common/params_map.h"
+#include "neug/main/neug_db.h"
+#include "neug/utils/exception/exception.h"
+#include "neug/utils/pb_utils.h"
+#include "neug/utils/yaml_utils.h"
+#include "node_query_request.h"
+
+#include <rapidjson/document.h>
+
+namespace neug {
+
+Napi::FunctionReference NodeConnection::constructor;
+
+Napi::Object NodeConnection::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "NodeConnection",
+      {
+          InstanceMethod("execute", &NodeConnection::Execute),
+          InstanceMethod("getSchema", &NodeConnection::GetSchema),
+          InstanceMethod("close", &NodeConnection::Close),
+      });
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("NodeConnection", func);
+  return exports;
+}
+
+NodeConnection::NodeConnection(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<NodeConnection>(info), db_(nullptr), conn_(nullptr) {}
+
+void NodeConnection::SetConnection(NeugDB* db,
+                                   std::shared_ptr<Connection> conn) {
+  db_ = db;
+  conn_ = std::move(conn);
+  if (!conn_) {
+    THROW_RUNTIME_ERROR("Connection is null");
+  }
+}
+
+Napi::Object NodeConnection::NewInstance(Napi::Env env, NeugDB& db,
+                                         std::shared_ptr<Connection> conn) {
+  Napi::Object obj = constructor.New({});
+  NodeConnection* wrapped = Napi::ObjectWrap<NodeConnection>::Unwrap(obj);
+  wrapped->SetConnection(&db, std::move(conn));
+  return obj;
+}
+
+Napi::Value NodeConnection::Execute(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Query string required")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string query_string = info[0].As<Napi::String>().Utf8Value();
+  std::string access_mode = "";
+  if (info.Length() >= 2 && info[1].IsString()) {
+    access_mode = info[1].As<Napi::String>().Utf8Value();
+  }
+
+  // Parse parameters from JavaScript object
+  rapidjson::Document params_json;
+  if (info.Length() >= 3 && info[2].IsObject()) {
+    Napi::Object params_obj = info[2].As<Napi::Object>();
+    Napi::Array keys = params_obj.GetPropertyNames();
+    for (uint32_t i = 0; i < keys.Length(); ++i) {
+      std::string key = keys.Get(i).As<Napi::String>().Utf8Value();
+      Napi::Value value = params_obj.Get(key);
+      NodeParameterSerializer::SerializeParameter(params_json, key, value);
+    }
+  }
+
+  auto query_result = conn_->Query(query_string, access_mode, params_json);
+  if (!query_result) {
+    return NodeQueryResult::NewInstanceFromStatus(env, query_result.error());
+  }
+  return NodeQueryResult::NewInstance(env, std::move(query_result.value()));
+}
+
+Napi::Value NodeConnection::GetSchema(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), conn_->GetSchema());
+}
+
+Napi::Value NodeConnection::Close(const Napi::CallbackInfo& info) {
+  if (conn_) {
+    db_->RemoveConnection(conn_);
+    conn_.reset();
+  }
+  return info.Env().Undefined();
+}
+
+}  // namespace neug

package/src/node_connection.h

@@ -0,0 +1,55 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed 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.
+ */
+
+#ifndef TOOLS_NODEJS_BIND_SRC_NODE_CONNECTION_H_
+#define TOOLS_NODEJS_BIND_SRC_NODE_CONNECTION_H_
+
+#include <napi.h>
+
+#include <memory>
+#include <string>
+
+#include "neug/execution/common/types/value.h"
+#include "neug/main/connection.h"
+#include "neug/main/neug_db.h"
+#include "node_query_result.h"
+
+namespace neug {
+
+class NodeConnection : public Napi::ObjectWrap<NodeConnection> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  static Napi::Object NewInstance(Napi::Env env, NeugDB& db,
+                                  std::shared_ptr<Connection> conn);
+
+  NodeConnection(const Napi::CallbackInfo& info);
+  ~NodeConnection() = default;
+
+  void SetConnection(NeugDB* db, std::shared_ptr<Connection> conn);
+
+ private:
+  static Napi::FunctionReference constructor;
+
+  Napi::Value Execute(const Napi::CallbackInfo& info);
+  Napi::Value GetSchema(const Napi::CallbackInfo& info);
+  Napi::Value Close(const Napi::CallbackInfo& info);
+
+  NeugDB* db_{nullptr};
+  std::shared_ptr<Connection> conn_;
+};
+
+}  // namespace neug
+
+#endif  // TOOLS_NODEJS_BIND_SRC_NODE_CONNECTION_H_

package/src/node_database.cc

@@ -0,0 +1,265 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed 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.
+ */
+
+#include "node_database.h"
+
+#include <unistd.h>
+
+#include <string>
+
+#include "neug/config.h"
+#include "neug/utils/exception/exception.h"
+
+namespace neug {
+
+Napi::FunctionReference NodeDatabase::constructor;
+
+Napi::Object NodeDatabase::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "NodeDatabase",
+      {
+          InstanceMethod("connect", &NodeDatabase::Connect),
+          InstanceMethod("close", &NodeDatabase::Close),
+          InstanceMethod("serve", &NodeDatabase::Serve),
+          InstanceMethod("stopServing", &NodeDatabase::StopServing),
+          StaticMethod("cpuCount", &NodeDatabase::GetCpuCount),
+      });
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("NodeDatabase", func);
+  return exports;
+}
+
+NodeDatabase::NodeDatabase(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<NodeDatabase>(info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsObject()) {
+    Napi::TypeError::New(env, "Options object required")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Object opts = info[0].As<Napi::Object>();
+
+  // Parse options
+  std::string database_path = "";
+  if (opts.Has("databasePath") && opts.Get("databasePath").IsString()) {
+    database_path = opts.Get("databasePath").As<Napi::String>().Utf8Value();
+  }
+
+  int32_t max_thread_num = 0;
+  if (opts.Has("maxThreadNum") && opts.Get("maxThreadNum").IsNumber()) {
+    max_thread_num = opts.Get("maxThreadNum").As<Napi::Number>().Int32Value();
+  }
+
+  std::string mode = "r";
+  if (opts.Has("mode") && opts.Get("mode").IsString()) {
+    mode = opts.Get("mode").As<Napi::String>().Utf8Value();
+  }
+
+  std::string planner = "gopt";
+  if (opts.Has("planner") && opts.Get("planner").IsString()) {
+    planner = opts.Get("planner").As<Napi::String>().Utf8Value();
+  }
+
+  bool checkpoint_on_close = true;
+  if (opts.Has("checkpointOnClose") && opts.Get("checkpointOnClose").IsBoolean()) {
+    checkpoint_on_close = opts.Get("checkpointOnClose").As<Napi::Boolean>().Value();
+  }
+
+  std::string buffer_strategy = "M_FULL";
+  if (opts.Has("bufferStrategy") && opts.Get("bufferStrategy").IsString()) {
+    buffer_strategy = opts.Get("bufferStrategy").As<Napi::String>().Utf8Value();
+  }
+
+  // Parse mode
+  neug::DBMode mode_;
+  if (mode == "read" || mode == "r" || mode == "read-only" ||
+      mode == "read_only") {
+    mode_ = DBMode::READ_ONLY;
+  } else if (mode == "read_write" || mode == "rw" || mode == "w" ||
+             mode == "wr" || mode == "write" || mode == "readwrite" ||
+             mode == "read-write") {
+    mode_ = DBMode::READ_WRITE;
+  } else {
+    Napi::Error::New(env, "Invalid mode: " + mode)
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  db_dir_ = database_path;
+  database = std::make_unique<NeugDB>();
+  NeugDBConfig config(db_dir_, max_thread_num);
+  config.mode = mode_;
+  config.planner_kind = planner;
+  config.checkpoint_on_close = checkpoint_on_close;
+  try {
+    config.memory_level = ParseBufferStrategy(buffer_strategy);
+    database->Open(config);
+  } catch (const neug::exception::Exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+    database.reset();
+    return;
+  } catch (const std::exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+    database.reset();
+    return;
+  }
+}
+
+NodeDatabase::~NodeDatabase() {
+  std::lock_guard<std::recursive_mutex> lock(mtx_);
+#ifdef BUILD_HTTP_SERVER
+  if (service_) {
+    service_->Stop();
+    service_.reset();
+  }
+#endif
+  if (database) {
+    database->Close();
+    database.reset();
+  }
+}
+
+Napi::Value NodeDatabase::Connect(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (!database) {
+    Napi::Error::New(env, "Database is not initialized.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  try {
+    auto conn = database->Connect();
+    return NodeConnection::NewInstance(env, *database, conn);
+  } catch (const neug::exception::Exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+    return env.Null();
+  } catch (const std::exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+}
+
+Napi::Value NodeDatabase::Close(const Napi::CallbackInfo& info) {
+  std::lock_guard<std::recursive_mutex> lock(mtx_);
+#ifdef BUILD_HTTP_SERVER
+  if (service_) {
+    service_->Stop();
+    service_.reset();
+  }
+#endif
+  if (database) {
+    database->Close();
+    database.reset();
+  }
+  return info.Env().Undefined();
+}
+
+Napi::Value NodeDatabase::Serve(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+#ifdef BUILD_HTTP_SERVER
+  if (!database) {
+    Napi::Error::New(env, "Database is not initialized.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  if (service_) {
+    Napi::Error::New(env, "Server is already running.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int port = 10000;
+  std::string host = "localhost";
+  int32_t num_thread = 0;
+  bool blocking = false;
+
+  if (info.Length() >= 1 && info[0].IsNumber()) {
+    port = info[0].As<Napi::Number>().Int32Value();
+  }
+  if (info.Length() >= 2 && info[1].IsString()) {
+    host = info[1].As<Napi::String>().Utf8Value();
+  }
+  if (info.Length() >= 3 && info[2].IsNumber()) {
+    num_thread = info[2].As<Napi::Number>().Int32Value();
+  }
+  if (info.Length() >= 4 && info[3].IsBoolean()) {
+    blocking = info[3].As<Napi::Boolean>().Value();
+  }
+
+  std::lock_guard<std::recursive_mutex> lock(mtx_);
+  database->Close();
+  database->Open(database->config());
+
+  neug::ServiceConfig config;
+  config.query_port = port;
+  config.host_str = host;
+  config.shard_num =
+      (num_thread == 0) ? std::thread::hardware_concurrency() : num_thread;
+#ifdef __APPLE__
+  if (host == "localhost") {
+    config.host_str = "127.0.0.1";
+  }
+#endif
+
+  service_ = std::make_unique<neug::NeugDBService>(*database, config);
+  if (blocking) {
+    service_->run_and_wait_for_exit();
+    return Napi::String::New(env, "");
+  }
+  return Napi::String::New(env, service_->Start());
+#else
+  Napi::Error::New(env, "HTTP server is not enabled in this build.")
+      .ThrowAsJavaScriptException();
+  return env.Null();
+#endif
+}
+
+Napi::Value NodeDatabase::StopServing(const Napi::CallbackInfo& info) {
+  std::lock_guard<std::recursive_mutex> lock(mtx_);
+#ifdef BUILD_HTTP_SERVER
+  if (service_) {
+    service_->Stop();
+    service_.reset();
+  }
+#endif
+  return info.Env().Undefined();
+}
+
+Napi::Value NodeDatabase::GetCpuCount(const Napi::CallbackInfo& info) {
+  long n = sysconf(_SC_NPROCESSORS_ONLN);
+  if (n < 1) {
+    n = 1;
+  }
+  return Napi::Number::New(info.Env(), static_cast<int32_t>(n));
+}
+
+MemoryLevel NodeDatabase::ParseBufferStrategy(const std::string& level) {
+  if (level == "InMemory" || level == "inmemory" || level == "in_memory" ||
+      level == "M_FULL") {
+    return MemoryLevel::kInMemory;
+  } else if (level == "SyncToFile" || level == "synctofile" ||
+             level == "sync_to_file" || level == "M_LAZY") {
+    return MemoryLevel::kSyncToFile;
+  } else if (level == "HugePagePreferred" || level == "hugepagepreferred" ||
+             level == "huge_page_preferred" || level == "M_HUGE") {
+    return MemoryLevel::kHugePagePreferred;
+  } else {
+    THROW_INVALID_ARGUMENT_EXCEPTION("Invalid memory level: " + level);
+  }
+}
+
+}  // namespace neug

package/src/node_database.h

@@ -0,0 +1,61 @@
+/** Copyright 2020 Alibaba Group Holding Limited.
+ *
+ * Licensed 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.
+ */
+
+#ifndef TOOLS_NODEJS_BIND_SRC_NODE_DATABASE_H_
+#define TOOLS_NODEJS_BIND_SRC_NODE_DATABASE_H_
+
+#include <napi.h>
+
+#include <memory>
+#include <mutex>
+#include <string>
+
+#include "neug/main/neug_db.h"
+#ifdef BUILD_HTTP_SERVER
+#include "neug/server/neug_db_service.h"
+#endif
+#include "node_connection.h"
+
+namespace neug {
+
+class NodeDatabase : public Napi::ObjectWrap<NodeDatabase> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  static Napi::Value GetCpuCount(const Napi::CallbackInfo& info);
+
+  NodeDatabase(const Napi::CallbackInfo& info);
+  ~NodeDatabase();
+
+  Napi::Value Connect(const Napi::CallbackInfo& info);
+  Napi::Value Close(const Napi::CallbackInfo& info);
+  Napi::Value Serve(const Napi::CallbackInfo& info);
+  Napi::Value StopServing(const Napi::CallbackInfo& info);
+
+ private:
+  static Napi::FunctionReference constructor;
+
+  MemoryLevel ParseBufferStrategy(const std::string& level);
+
+  std::recursive_mutex mtx_;
+  std::string db_dir_;
+  std::unique_ptr<NeugDB> database;
+#ifdef BUILD_HTTP_SERVER
+  std::unique_ptr<NeugDBService> service_;
+#endif
+};
+
+}  // namespace neug
+
+#endif  // TOOLS_NODEJS_BIND_SRC_NODE_DATABASE_H_