Merge pull request suketa#938 from suketa/instance_cache

create DuckDB::InstanceCache class.

Author: suketa

ext/duckdb/duckdb.c

@@ -39,4 +39,7 @@ Init_duckdb_native(void) {
     rbduckdb_init_duckdb_config();
     rbduckdb_init_duckdb_converter();
     rbduckdb_init_duckdb_extracted_statements();
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+    rbduckdb_init_duckdb_instance_cache();
+#endif
 }

ext/duckdb/instance_cache.c

@@ -0,0 +1,70 @@
+#include "ruby-duckdb.h"
+
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+VALUE cDuckDBInstanceCache;
+
+static void deallocate(void * ctx);
+static VALUE allocate(VALUE klass);
+static size_t memsize(const void *p);
+static VALUE duckdb_instance_cache_initialize(VALUE self);
+static VALUE duckdb_instance_cache_destroy(VALUE self);
+
+static const rb_data_type_t instance_cache_data_type = {
+    "DuckDB/InstanceCache",
+    {NULL, deallocate, memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static void deallocate(void * ctx) {
+    rubyDuckDBInstanceCache *p = (rubyDuckDBInstanceCache *)ctx;
+
+    if (p->instance_cache) {
+        duckdb_destroy_instance_cache(&(p->instance_cache));
+    }
+    xfree(p);
+}
+
+static size_t memsize(const void *p) {
+    return sizeof(rubyDuckDBInstanceCache);
+}
+
+static VALUE allocate(VALUE klass) {
+    rubyDuckDBInstanceCache *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBInstanceCache));
+    return TypedData_Wrap_Struct(klass, &instance_cache_data_type, ctx);
+}
+
+static VALUE duckdb_instance_cache_initialize(VALUE self) {
+    rubyDuckDBInstanceCache *ctx;
+
+    TypedData_Get_Struct(self, rubyDuckDBInstanceCache, &instance_cache_data_type, ctx);
+
+    ctx->instance_cache = duckdb_create_instance_cache();
+    if (ctx->instance_cache == NULL) {
+        rb_raise(eDuckDBError, "Failed to create instance cache");
+    }
+
+    return self;
+}
+
+static VALUE duckdb_instance_cache_destroy(VALUE self) {
+    rubyDuckDBInstanceCache *ctx;
+    TypedData_Get_Struct(self, rubyDuckDBInstanceCache, &instance_cache_data_type, ctx);
+
+    if (ctx->instance_cache) {
+        duckdb_destroy_instance_cache(&(ctx->instance_cache));
+        ctx->instance_cache = NULL;
+    }
+
+    return Qnil;
+}
+
+void rbduckdb_init_duckdb_instance_cache(void) {
+#if 0
+    VALUE mDuckDB = rb_define_module("DuckDB");
+#endif
+    cDuckDBInstanceCache = rb_define_class_under(mDuckDB, "InstanceCache", rb_cObject);
+    rb_define_method(cDuckDBInstanceCache, "initialize", duckdb_instance_cache_initialize, 0);
+    rb_define_method(cDuckDBInstanceCache, "destroy", duckdb_instance_cache_destroy, 0);
+    rb_define_alloc_func(cDuckDBInstanceCache, allocate);
+}
+#endif

ext/duckdb/instance_cache.h

@@ -0,0 +1,17 @@
+#ifndef RUBY_DUCKDB_INSTANCE_CACHE_H
+#define RUBY_DUCKDB_INSTANCE_CACHE_H
+
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+
+struct _rubyDuckDBInstanceCache {
+    duckdb_instance_cache instance_cache;
+};
+
+typedef struct _rubyDuckDBInstanceCache rubyDuckDBInstanceCache;
+
+void rbduckdb_init_duckdb_instance_cache(void);
+
+#endif
+
+#endif
+

ext/duckdb/ruby-duckdb.h

@@ -32,6 +32,10 @@
 #include "./appender.h"
 #include "./config.h"
 
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+#include "./instance_cache.h"
+#endif
+
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;
 extern VALUE cDuckDBConnection;
@@ -43,4 +47,8 @@ extern VALUE cDuckDBPreparedStatement;
 extern VALUE PositiveInfinity;
 extern VALUE NegativeInfinity;
 
+#ifdef HAVE_DUCKDB_H_GE_V1_2_0
+extern VALUE cDuckDBInstanceCache;
+#endif
+
 #endif

test/duckdb_test/instance_cache_test.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+if defined?(DuckDB::InstanceCache)
+
+module DuckDBTest
+  class InstanceCacheTest < Minitest::Test
+    def test_s_new
+      assert_instance_of DuckDB::InstanceCache, DuckDB::InstanceCache.new
+    end
+
+    def test_destroy
+      cache = DuckDB::InstanceCache.new
+      assert_nil cache.destroy
+    end
+  end
+end
+
+end