add logger-level option

src/common/types/include/types.h

@@ -8,6 +8,8 @@
 #include <string>
 #include <vector>
 
+#include "spdlog/spdlog.h"
+
 using namespace std;
 
 namespace kuzu {
@@ -123,5 +125,9 @@ string getRelDirectionAsString(RelDirection relDirection);
 
 enum class DBFileType : uint8_t { ORIGINAL = 0, WAL_VERSION = 1 };
 
+spdlog::level::level_enum convertStrToLevelEnum(string loggingLevel);
+
+string convertLevelEnumToStr(spdlog::level::level_enum);
+
 } // namespace common
 } // namespace kuzu

src/common/types/types.cpp

@@ -6,6 +6,7 @@
 #include "include/value.h"
 
 #include "src/common/include/exception.h"
+#include "src/common/include/utils.h"
 
 namespace kuzu {
 namespace common {
@@ -176,5 +177,46 @@ string getRelDirectionAsString(RelDirection direction) {
     return (FWD == direction) ? "forward" : "backward";
 }
 
+spdlog::level::level_enum convertStrToLevelEnum(string loggingLevel) {
+    StringUtils::toLower(loggingLevel);
+    if (loggingLevel == "info") {
+        return spdlog::level::level_enum::info;
+    } else if (loggingLevel == "debug") {
+        return spdlog::level::level_enum::debug;
+    } else if (loggingLevel == "err") {
+        return spdlog::level::level_enum::err;
+    }
+    throw ConversionException(
+        StringUtils::string_format("Unsupported logging level: %s.", loggingLevel.c_str()));
+}
+
+string convertLevelEnumToStr(spdlog::level::level_enum levelEnum) {
+    switch (levelEnum) {
+    case spdlog::level::level_enum::trace: {
+        return "trace";
+    }
+    case spdlog::level::level_enum::debug: {
+        return "debug";
+    }
+    case spdlog::level::level_enum::info: {
+        return "info";
+    }
+    case spdlog::level::level_enum::warn: {
+        return "warn";
+    }
+    case spdlog::level::level_enum::err: {
+        return "err";
+    }
+    case spdlog::level::level_enum::critical: {
+        return "critical";
+    }
+    case spdlog::level::level_enum::off: {
+        return "off";
+    }
+    default:
+        assert(false);
+    }
+}
+
 } // namespace common
 } // namespace kuzu

src/main/database.cpp

@@ -57,6 +57,16 @@ void Database::initLoggers() {
     LoggerUtils::getOrCreateLogger("wal");
 }
 
+void Database::setLoggingLevel(spdlog::level::level_enum loggingLevel) {
+    if (loggingLevel != spdlog::level::level_enum::debug &&
+        loggingLevel != spdlog::level::level_enum::info &&
+        loggingLevel != spdlog::level::level_enum::err) {
+        printf("Unsupported logging level: %s.", convertLevelEnumToStr(loggingLevel).c_str());
+        return;
+    }
+    spdlog::set_level(loggingLevel);
+}
+
 void Database::resizeBufferManager(uint64_t newSize) {
     systemConfig.defaultPageBufferPoolSize = newSize * StorageConfig::DEFAULT_PAGES_BUFFER_RATIO;
     systemConfig.largePageBufferPoolSize = newSize * StorageConfig::LARGE_PAGES_BUFFER_RATIO;

src/main/include/database.h

@@ -55,10 +55,12 @@ class Database {
 
     explicit Database(const DatabaseConfig& databaseConfig, const SystemConfig& systemConfig);
 
-    ~Database() = default;
+    void setLoggingLevel(spdlog::level::level_enum loggingLevel);
 
     void resizeBufferManager(uint64_t newSize);
 
+    ~Database() = default;
+
 private:
     // TODO(Semih): This is refactored here for now to be able to test transaction behavior
     // in absence of the frontend support. Consider moving this code to connection.cpp.

tools/python_api/include/py_database.h

@@ -10,6 +10,10 @@ class PyDatabase {
     friend class PyConnection;
 
 public:
+    inline void setLoggingLevel(spdlog::level::level_enum logging_level) {
+        database->setLoggingLevel(logging_level);
+    }
+
     static void initialize(py::handle& m);
 
     explicit PyDatabase(const string& databasePath, uint64_t bufferPoolSize);

tools/python_api/kuzu_binding.cpp

@@ -1,8 +1,16 @@
 #include "include/py_connection.h"
 #include "include/py_database.h"
-#include "include/py_query_result_converter.h"
+
+void bindEnumTypes(py::module& m) {
+    py::enum_<spdlog::level::level_enum>(m, "loggingLevel")
+        .value("debug", spdlog::level::level_enum::debug)
+        .value("info", spdlog::level::level_enum::info)
+        .value("err", spdlog::level::level_enum::err)
+        .export_values();
+}
 
 void bind(py::module& m) {
+    bindEnumTypes(m);
     PyDatabase::initialize(m);
     PyConnection::initialize(m);
     PyQueryResult::initialize(m);

tools/python_api/py_database.cpp

@@ -4,7 +4,8 @@ void PyDatabase::initialize(py::handle& m) {
     py::class_<PyDatabase>(m, "database")
         .def(py::init<const string&, uint64_t>(), py::arg("database_path"),
             py::arg("buffer_pool_size") = 0)
-        .def("resize_buffer_manager", &PyDatabase::resizeBufferManager, py::arg("new_size"));
+        .def("resize_buffer_manager", &PyDatabase::resizeBufferManager, py::arg("new_size"))
+        .def("set_logging_level", &PyDatabase::setLoggingLevel, py::arg("logging_level"));
 }
 
 PyDatabase::PyDatabase(const string& databasePath, uint64_t bufferPoolSize) {

tools/python_api/test/conftest.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from tools.python_api import _kuzu as gdb
+from tools.python_api import _kuzu as kuzu
 
 
 # Note conftest is the default file name for sharing fixture through multiple test files. Do not change file name.
@@ -11,8 +11,8 @@ def init_tiny_snb(tmp_path):
     if os.path.exists(tmp_path):
         os.rmdir(tmp_path)
     output_path = str(tmp_path)
-    db = gdb.database(output_path)
-    conn = gdb.connection(db)
+    db = kuzu.database(output_path)
+    conn = kuzu.connection(db)
     conn.execute("CREATE NODE TABLE person (ID INT64, fName STRING, gender INT64, isStudent BOOLEAN, isWorker BOOLEAN, "
                  "age INT64, eyeSight DOUBLE, birthdate DATE, registerTime TIMESTAMP, lastJobDuration "
                  "INTERVAL, workedHours INT64[], usedNames STRING[], courseScoresPerTerm INT64[][], PRIMARY "
@@ -27,6 +27,6 @@ def init_tiny_snb(tmp_path):
 
 @pytest.fixture
 def establish_connection(init_tiny_snb):
-    db = gdb.database(init_tiny_snb, buffer_pool_size=256 * 1024 * 1024)
-    conn = gdb.connection(db, num_threads=4)
+    db = kuzu.database(init_tiny_snb, buffer_pool_size=256 * 1024 * 1024)
+    conn = kuzu.connection(db, num_threads=4)
     return conn, db

tools/python_api/test/example.py

@@ -1,11 +1,10 @@
-from tools.python_api import _kuzu as gdb
+from tools.python_api import _kuzu as kuzu
 
-
-databaseDir = "path_to_serialized_database"
-db = gdb.database(databaseDir)
-conn = gdb.connection(db)
+databaseDir = "path to database file"
+db = kuzu.database(databaseDir)
+conn = kuzu.connection(db)
 query = "MATCH (a:person) RETURN *;"
-result = conn.query(query)
+result = conn.execute(query)
 while result.hasNext():
     print(result.getNext())
 result.close()

tools/python_api/test/test_df.py

@@ -1,6 +1,7 @@
 import numpy as np
 
 from pandas import Timestamp, Timedelta, isna
+from tools.python_api import _kuzu as kuzu
 
 
 def test_to_df(establish_connection):
@@ -77,3 +78,12 @@ def _test_to_df(conn):
     db.resize_buffer_manager(512 * 1024 * 1024)
     conn.set_max_threads_for_exec(4)
     _test_to_df(conn)
+
+    db.set_logging_level(kuzu.loggingLevel.debug)
+    _test_to_df(conn)
+
+    db.set_logging_level(kuzu.loggingLevel.info)
+    _test_to_df(conn)
+
+    db.set_logging_level(kuzu.loggingLevel.err)
+    _test_to_df(conn)

tools/shell/embedded_shell.cpp

@@ -27,8 +27,9 @@ struct ShellCommand {
     const string LIST_RELS = ":list_rels";
     const string SHOW_NODE = ":show_node";
     const string SHOW_REL = ":show_rel";
+    const string LOGGING_LEVEL = ":logging_level";
     const vector<string> commandList = {HELP, CLEAR, QUIT, THREAD, BUFFER_MANAGER_SIZE,
-        BUFFER_MANAGER_DEBUG_INFO, LIST_NODES, LIST_RELS, SHOW_NODE, SHOW_REL};
+        BUFFER_MANAGER_DEBUG_INFO, LIST_NODES, LIST_RELS, SHOW_NODE, SHOW_REL, LOGGING_LEVEL};
 } shellCommand;
 
 const char* TAB = "    ";
@@ -207,6 +208,14 @@ void EmbeddedShell::run() {
             printNodeSchema(lineStr.substr(shellCommand.SHOW_NODE.length()));
         } else if (lineStr.rfind(shellCommand.SHOW_REL) == 0) {
             printRelSchema(lineStr.substr(shellCommand.SHOW_REL.length()));
+        } else if (lineStr.rfind(shellCommand.LOGGING_LEVEL) == 0) {
+            auto logLevelStr = regex_replace(
+                lineStr.substr(shellCommand.LOGGING_LEVEL.length()), std::regex("^ +"), "");
+            try {
+                auto logLevelEnum = convertStrToLevelEnum(logLevelStr);
+                database->setLoggingLevel(logLevelEnum);
+                printf("logging level has been set to: %s.\n", logLevelStr.c_str());
+            } catch (ConversionException& e) { printf(e.what()); }
         } else if (!lineStr.empty()) {
             ss.clear();
             ss.str(lineStr);
@@ -286,6 +295,9 @@ void EmbeddedShell::printHelp() {
         shellCommand.THREAD.c_str(), TAB);
     printf("%s%s [bm_size_in_bytes] %sset buffer manager size in bytes\n", TAB,
         shellCommand.BUFFER_MANAGER_SIZE.c_str(), TAB);
+    printf("%s%s [logging_level] %sset logging level of database, available options: debug, info, "
+           "err\n",
+        TAB, shellCommand.LOGGING_LEVEL.c_str(), TAB);
     printf("%s%s %slist all node tables\n", TAB, shellCommand.LIST_NODES.c_str(), TAB);
     printf("%s%s %slist all rel tables\n", TAB, shellCommand.LIST_RELS.c_str(), TAB);
     printf("%s%s %s[table_name] show node schema\n", TAB, shellCommand.SHOW_NODE.c_str(), TAB);