9 - Added ReSQL - DuckDB support

README.md

@@ -474,3 +474,6 @@ Then re-run the start script:
 ## Smart Contract ##
 If you want to use smart contracts, please go to:
 https://blog.resilientdb.com/2025/02/14/GettingStartedSmartContract.html
+
+
+# New Change

WORKSPACE

@@ -177,6 +177,9 @@ http_archive(
     sha256 = "91844808532e5ce316b3c010929493c0244f3d37593afd6de04f71821d5136d9",
     strip_prefix = "zlib-1.2.12",
     urls = [
+        "https://zlib.net/fossils/zlib-1.2.12.tar.gz",
+        "https://downloads.sourceforge.net/project/libpng/zlib/1.2.12/zlib-1.2.12.tar.gz",
+        "https://zlib.net/fossils/zlib-1.2.12.tar.gz",
         "https://storage.googleapis.com/bazel-mirror/zlib.net/zlib-1.2.12.tar.gz",
     ],
 )
@@ -188,6 +191,19 @@ http_archive(
     strip_prefix = "leveldb-1.23",
     url = "https://github.com/google/leveldb/archive/refs/tags/1.23.zip",
 )
+http_archive(
+    name = "duckdb",
+    urls = [
+        # pick one version and stick to it
+        "https://github.com/duckdb/duckdb/releases/download/v1.4.0/libduckdb-src.zip",
+    ],
+    # This zip is just flat: duckdb.cpp, duckdb.hpp, duckdb.h at the root.
+    # So no strip_prefix is needed.
+    build_file = "//third_party:duckdb.BUILD",
+    # Optional: you can add sha256 once Bazel prints it for you.
+    # sha256 = "<FILL_ME_FROM_BAZEL_ERROR>",
+)
+
 
 bind(
     name = "snappy",

chain/storage/BUILD

@@ -81,3 +81,49 @@ cc_test(
         "//platform/statistic:stats",
     ],
 )
+
+cc_library(
+    name = "duckdb_storage",
+    srcs = ["duckdb.cpp"],
+    hdrs = ["duckdb.h"],
+    deps = [
+        ":storage",
+        "//chain/storage/proto:duckdb_config_cc_proto",
+        "//third_party:duckdb",
+        "//common:glog",
+    ],
+)
+
+cc_binary(
+    name = "duckdb_test",
+    srcs = ["duckdb_test.cpp"],
+    deps = [
+        ":duckdb_storage",
+        "//third_party:duckdb",
+        "//common:glog",
+        "//chain/storage/proto:duckdb_config_cc_proto",
+    ],
+)
+
+cc_library(
+    name = "duckdb_storage",
+    srcs = ["duckdb.cpp"],
+    hdrs = ["duckdb.h"],
+    deps = [
+        ":storage",
+        "//chain/storage/proto:duckdb_config_cc_proto",
+        "//third_party:duckdb",
+        "//common:glog",
+    ],
+)
+
+cc_binary(
+    name = "duckdb_test",
+    srcs = ["duckdb_test.cpp"],
+    deps = [
+        ":duckdb_storage",
+        "//third_party:duckdb",
+        "//common:glog",
+        "//chain/storage/proto:duckdb_config_cc_proto",
+    ],
+)

chain/storage/duckdb.cpp

@@ -0,0 +1,99 @@
+#include "chain/storage/duckdb.h"
+
+#include <glog/logging.h>
+
+#include <exception>
+#include <memory>
+#include <string>
+
+#include "duckdb.hpp"
+
+namespace resdb {
+namespace storage {
+
+std::unique_ptr<Storage> NewResQL(const std::string& path,
+                                  const DuckDBInfo& config) {
+  DuckDBInfo cfg = config;
+  cfg.set_path(path);
+
+  return std::make_unique<ResQL>(cfg);
+}
+
+ResQL::ResQL(const DuckDBInfo& config) : config_(config) {
+  std::string path = "/tmp/resql-duckdb";
+  if (!config.path().empty()) {
+    path = config.path();
+  }
+  CreateDB(config);
+}
+
+ResQL::~ResQL() = default;
+
+void ResQL::CreateDB(const DuckDBInfo& config) {
+  std::string db_path = config.path();
+
+  duckdb::DBConfig db_config;
+
+  if (config.has_max_memory()) {
+    db_config.SetOption("max_memory", duckdb::Value(config.max_memory()));
+  }
+
+  LOG(INFO) << "Initializing DuckDB at "
+            << (db_path.empty() ? "in-memory" : db_path)
+            << " (autoload/autoinstall extensions enabled)";
+
+  if (db_path.empty()) {
+    db_ = std::make_unique<duckdb::DuckDB>(nullptr, &db_config);
+  } else {
+    db_ = std::make_unique<duckdb::DuckDB>(db_path, &db_config);
+  }
+
+  // Ensure extension auto-install/load is enabled at the connection level too.
+  try {
+    duckdb::Connection init_conn(*db_);
+    init_conn.Query("SET autoload_known_extensions=1");
+    init_conn.Query("SET autoinstall_known_extensions=1");
+  } catch (const std::exception& e) {
+    LOG(ERROR) << "Failed to set DuckDB extension auto-load/install flags: "
+               << e.what();
+  }
+}
+
+std::string ResQL::ExecuteSQL(const std::string& sql_string){
+    if (sql_string.empty()) {
+        return "Error: empty SQL query";
+    }
+
+    if (!db_) {
+        LOG(ERROR) << "DuckDB is not initialized";
+        return "Error: database not initialized";
+    }
+
+    try {
+        LOG(INFO) << "Executing SQL: " << sql_string;
+        conn_ = std::make_unique<duckdb::Connection> (*db_);
+        auto result = conn_->Query(sql_string);
+
+        if (!result) {
+            LOG(ERROR) << "Query returned nullptr";
+            return "Error: query returned no result";
+        }
+
+        if (result->HasError()) {
+            LOG(ERROR) << "SQL Error: " << result->GetError();
+            return "Error: " + result->GetError();
+        }
+
+        std::string response = result->ToString();
+        LOG(INFO) << "SQL succeeded. Rows: " << result->RowCount()
+                  << " Cols: " << result->ColumnCount();
+        LOG(INFO) << "SQL Result:\n" << response;
+        return response;
+    } catch (const std::exception& e) {
+        LOG(ERROR) << "SQL execution threw: " << e.what();
+        return std::string("Error: ") + e.what();
+    }
+}
+
+}  // namespace storage
+}  // namespace resdb

chain/storage/duckdb.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+
+#include "chain/storage/proto/duckdb_config.pb.h"
+
+#include "storage.h"
+#include "duckdb.hpp"
+
+namespace resdb {
+namespace storage {
+
+class ResQL : public Storage {
+ public:
+  explicit ResQL(const DuckDBInfo& config);
+  ~ResQL() override;
+
+  // Main functionality
+  std::string ExecuteSQL(const std::string& sql_string) override;
+  void CreateDB(const DuckDBInfo& config);
+
+  // No-op overrides
+  int SetValue(const std::string&, const std::string&) override { return 0; }
+  std::string GetValue(const std::string&) override { return ""; }
+  std::string GetAllValues() override { return ""; }
+  std::string GetRange(const std::string&, const std::string&) override {
+    return "";
+  }
+  int SetValueWithVersion(const std::string&, const std::string&, int) override {
+    return 0;
+  }
+  std::pair<std::string, int> GetValueWithVersion(const std::string&,
+                                                  int) override {
+    return {"", 0};
+  }
+  std::map<std::string, std::pair<std::string, int>> GetAllItems() override {
+    return {};
+  }
+  std::map<std::string, std::pair<std::string, int>> GetKeyRange(
+      const std::string&, const std::string&) override {
+    return {};
+  }
+  std::vector<std::pair<std::string, int>> GetHistory(const std::string&, int,
+                                                      int) override {
+    return {};
+  }
+  std::vector<std::pair<std::string, int>> GetTopHistory(const std::string&,
+                                                         int) override {
+    return {};
+  }
+  bool Flush() override { return true; }
+
+ private:
+  std::unique_ptr<duckdb::DuckDB> db_;
+  std::unique_ptr<duckdb::Connection> conn_;
+  std::optional<DuckDBInfo> config_;
+};
+
+
+// Factory function
+std::unique_ptr<Storage> NewResQL(
+    const std::string& path,
+    const DuckDBInfo& config = DuckDBInfo());
+}  // namespace storage
+}  // namespace resdb

chain/storage/duckdb_test.cpp

@@ -0,0 +1,53 @@
+#include "chain/storage/duckdb.h"
+#include "chain/storage/proto/duckdb_config.pb.h"
+
+#include <iostream>
+#include <iterator>
+#include <memory>
+#include <string>
+
+int main() {
+    using namespace resdb::storage;
+
+    // 1. Create a DuckDBInfo proto for file-backed DB
+    DuckDBInfo config;
+    config.set_path("/home/aryan/resilientdb-resql/dtest/dtest.db");
+
+    // 2. Construct ResQL instance
+    std::unique_ptr<ResQL> my_db;
+    try {
+        my_db = std::make_unique<ResQL>(config);
+        std::cout << "ResQL (DuckDB) created successfully!" << std::endl;
+    } catch (std::exception& e) {
+        std::cerr << "Failed to create ResQL: " << e.what() << std::endl;
+        return 1;
+    }
+
+    {
+        std::string create_sql =
+            "CREATE TABLE IF NOT EXISTS users ("
+            "id INTEGER, "
+            "name TEXT"
+            ");";
+
+        std::string resp = my_db->ExecuteSQL(create_sql);
+        std::cout << "CREATE: " << resp << std::endl;
+    }
+
+    {
+        std::string insert_sql =
+            "INSERT INTO users VALUES (1, 'batman');";
+
+        std::string resp = my_db->ExecuteSQL(insert_sql);
+        std::cout << "INSERT: " << resp << std::endl;
+    }
+
+    {
+        std::string select_sql = "SELECT * FROM users;";
+
+        std::string resp = my_db->ExecuteSQL(select_sql);
+        std::cout << "SELECT: " << resp << std::endl;
+    }
+
+    return 0;
+}

chain/storage/proto/BUILD

@@ -42,3 +42,14 @@ cc_proto_library(
     name = "leveldb_config_cc_proto",
     deps = [":leveldb_config_proto"],
 )
+
+proto_library(
+    name = "duckdb_config_proto",
+    srcs = ["duckdb_config.proto"],
+)
+
+cc_proto_library(
+    name = "duckdb_config_cc_proto",
+    deps = [":duckdb_config_proto"],
+)
+

chain/storage/proto/duckdb_config.proto

@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+syntax = "proto3";
+
+package resdb.storage;
+
+message DuckDBInfo {
+  string path = 1;
+  optional bool use_wal = 2;
+  optional string max_memory = 3;
+  optional uint32 threads = 4;
+}

chain/storage/storage.h

@@ -59,6 +59,9 @@ class Storage {
   virtual std::vector<std::pair<std::string, int>> GetTopHistory(
       const std::string& key, int number) = 0;
 
+  // Default no-op SQL execution for non-SQL backends.
+  virtual std::string ExecuteSQL(const std::string& sql_string) { return ""; }
+
   virtual bool Flush() { return true; };
 
   virtual uint64_t GetLastCheckpoint() { return 0; }