lmdb 0.7.5 → 0.8.0

data/ext/lmdb_ext/lmdb_ext.h

@@ -1,6 +1,7 @@
 #ifndef _LMDB_EXT_H
 #define _LMDB_EXT_H
 
+#include <errno.h>
 #include "ruby.h"
 #include "lmdb.h"
 
@@ -29,24 +30,28 @@
 #  define RARRAY_AREF(ary,n) (RARRAY_PTR(ary)[n])
 #endif
 
-#define ENVIRONMENT(var, var_env)                       \
-        Environment* var_env;                           \
-        Data_Get_Struct(var, Environment, var_env);     \
+#define ENVIRONMENT(var, type, var_env)                        \
+        Environment* var_env;                                  \
+        TypedData_Get_Struct(var, Environment, type, var_env); \
         environment_check(var_env)
 
-#define DATABASE(var, var_db)                   \
-        Database* var_db;                       \
-        Data_Get_Struct(var, Database, var_db);
+#define DATABASE(var, type, var_db)                  \
+        Database* var_db;                            \
+        TypedData_Get_Struct(var, Database, type, var_db)
 
-#define TRANSACTION(var, var_txn)                       \
+#define TRANSACTION(var, type, var_txn)                 \
         Transaction* var_txn;                           \
-        Data_Get_Struct(var, Transaction, var_txn)
+        TypedData_Get_Struct(var, Transaction, type, var_txn)
 
-#define CURSOR(var, var_cur)                    \
-        Cursor* var_cur;                        \
-        Data_Get_Struct(var, Cursor, var_cur);  \
+#define CURSOR(var, type, var_cur)                   \
+        Cursor* var_cur;                             \
+        TypedData_Get_Struct(var, Cursor, type, var_cur); \
         cursor_check(var_cur)
 
+#define CURSOR_NOCHECK(var, type, var_cur)               \
+        Cursor* var_cur;                                 \
+        TypedData_Get_Struct(var, Cursor, type, var_cur)
+
 /*
   hey yo if you can convince hyc to add a function like
   mdb_txn_get_flags or even mdb_txn_is_rdonly, you could probably get
@@ -92,7 +97,7 @@ typedef struct {
         VALUE self;
         const char* name;
         int argc;
-        const VALUE* argv;
+        VALUE* argv;
 } HelperArgs;
 
 typedef struct {
@@ -118,6 +123,17 @@ static VALUE cEnvironment, cDatabase, cTransaction, cCursor, cError;
 #include "errors.h"
 #undef ERROR
 
+#define GC_MARK(val) \
+    do { if ((val) && !NIL_P(val)) rb_gc_mark_movable(val); } while(0)
+
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+#define GC_MARK_MOVABLE(val) \
+    do { if ((val) && !NIL_P(val)) rb_gc_mark_movable(val); } while(0)
+
+#define GC_LOCATION(val) \
+    do { if ((val) && !NIL_P(val)) (val) = rb_gc_location(val); } while(0)
+#endif
+
 // BEGIN PROTOTYPES
 void Init_lmdb_ext();
 static MDB_txn* active_txn(VALUE self);
@@ -129,10 +145,10 @@ static VALUE cursor_close(VALUE self);
 static VALUE cursor_count(VALUE self);
 static VALUE cursor_delete(int argc, VALUE *argv, VALUE self);
 static VALUE cursor_first(VALUE self);
-static void cursor_free(Cursor* cursor);
 static VALUE cursor_get(VALUE self);
 static VALUE cursor_last(VALUE self);
-static void cursor_mark(Cursor* cursor);
+static void cursor_mark(void* ptr);
+static void cursor_free(void* ptr);
 static VALUE cursor_next(int argc, VALUE* argv, VALUE self);
 static VALUE cursor_prev(VALUE self);
 static VALUE cursor_put(int argc, VALUE* argv, VALUE self);
@@ -143,7 +159,8 @@ static VALUE database_cursor(VALUE self);
 static VALUE database_delete(int argc, VALUE *argv, VALUE self);
 static VALUE database_drop(VALUE self);
 static VALUE database_get(VALUE self, VALUE vkey);
-static void database_mark(Database* database);
+static void database_mark(void* ptr);
+static void database_free(void* ptr);
 static VALUE database_put(int argc, VALUE *argv, VALUE self);
 static VALUE database_stat(VALUE self);
 static VALUE database_get_flags(VALUE self);
@@ -158,9 +175,9 @@ static VALUE environment_copy(VALUE self, VALUE path);
 static VALUE environment_database(int argc, VALUE *argv, VALUE self);
 static VALUE environment_databases(VALUE self);
 static VALUE environment_flags(VALUE self);
-static void environment_free(Environment *environment);
+static void environment_mark(void* ptr);
+static void environment_free(void* ptr);
 static VALUE environment_info(VALUE self);
-static void environment_mark(Environment* environment);
 static VALUE environment_new(int argc, VALUE *argv, VALUE klass);
 static int environment_options(VALUE key, VALUE value, EnvironmentOptions* options);
 static VALUE environment_path(VALUE self);
@@ -174,8 +191,8 @@ static VALUE stat2hash(const MDB_stat* stat);
 static VALUE transaction_abort(VALUE self);
 static VALUE transaction_commit(VALUE self);
 static void transaction_finish(VALUE self, int commit);
-static void transaction_free(Transaction* transaction);
-static void transaction_mark(Transaction* transaction);
+static void transaction_mark(void* ptr);
+static void transaction_free(void* ptr);
 static VALUE with_transaction(VALUE venv, VALUE(*fn)(VALUE), VALUE arg, int flags);
 // END PROTOTYPES
 

data/lib/lmdb/version.rb

@@ -1,3 +1,3 @@
 module LMDB
-  VERSION = '0.7.5'.freeze
+  VERSION = '0.8.0'.freeze
 end

data/spec/gc_torture_spec.rb

@@ -0,0 +1,162 @@
+require 'helper'
+require 'lmdb'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.describe 'LMDB GC safety' do
+  let(:env)  { LMDB.new(path, mapsize: 2**24) }
+  let(:db)   { env.database('test', create: true) }
+
+  before(:each) { db }  # open db before each example
+
+  after(:each) do
+    env.close rescue nil
+    FileUtils.rm_rf path
+  end
+
+  # -----------------------------------------------------------------------
+  # 1. Basic GC.compact safety — no open transactions
+  #    Verifies compaction callbacks update all VALUE references correctly
+  # -----------------------------------------------------------------------
+  it 'survives GC.compact with no open transactions' do
+    env.transaction { db['key'] = 'value' }
+    expect { GC.compact }.not_to raise_error
+    env.transaction(true) { expect(db['key']).to eq 'value' }
+  end
+
+  # -----------------------------------------------------------------------
+  # 2. GC.compact during an open read transaction
+  #    Verifies the transaction object survives compaction
+  # -----------------------------------------------------------------------
+  it 'survives GC.compact with an open read transaction' do
+    env.transaction { db['key'] = 'value' }
+    env.transaction(true) do |txn|
+      expect { GC.compact }.not_to raise_error
+      expect(db['key']).to eq 'value'
+      expect(txn.finished?).to be false
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # 3. GC.compact between consecutive write transactions
+  #    This is the Store::Digest scenario — write, compact, write again
+  # -----------------------------------------------------------------------
+  it 'allows a new write transaction after GC.compact' do
+    env.transaction { db['key1'] = 'value1' }
+    GC.compact
+    expect {
+      env.transaction { db['key2'] = 'value2' }
+    }.not_to raise_error
+    env.transaction(true) do
+      expect(db['key1']).to eq 'value1'
+      expect(db['key2']).to eq 'value2'
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # 4. GC.compact after multiple write transactions
+  #    Stress version — compact after several writes
+  # -----------------------------------------------------------------------
+  it 'allows write transactions after repeated GC.compact calls' do
+    5.times do |i|
+      env.transaction { db["key#{i}"] = "value#{i}" }
+      GC.compact
+    end
+    env.transaction(true) do
+      5.times do |i|
+        expect(db["key#{i}"]).to eq "value#{i}"
+      end
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # 5. GC.compact with a pseudo-transaction (RO nested in RW)
+  #    Verifies pseudo-transaction compaction safety
+  # -----------------------------------------------------------------------
+  it 'survives GC.compact after pseudo-transaction use' do
+    env.transaction do
+      db['key'] = 'value'
+      env.transaction(true) do
+        expect(db['key']).to eq 'value'
+      end
+    end
+    GC.compact
+    expect {
+      env.transaction { db['key2'] = 'value2' }
+    }.not_to raise_error
+  end
+
+  # -----------------------------------------------------------------------
+  # 6. GC.compact with cursor use
+  #    Verifies cursor compaction safety
+  # -----------------------------------------------------------------------
+  it 'survives GC.compact after cursor iteration' do
+    env.transaction do
+      5.times { |i| db["key#{i}"] = "value#{i}" }
+    end
+    env.transaction(true) do
+      db.cursor do |c|
+        c.first
+        GC.compact
+        expect(c.next).not_to be_nil
+      end
+    end
+    GC.compact
+    expect {
+      env.transaction { db['new'] = 'write' }
+    }.not_to raise_error
+  end
+
+  # -----------------------------------------------------------------------
+  # 7. GC.start (sweep without compaction) — baseline
+  #    Should always pass; establishes that non-compacting GC is safe
+  # -----------------------------------------------------------------------
+  it 'survives GC.start (sweep only) between write transactions' do
+    env.transaction { db['key1'] = 'value1' }
+    GC.start
+    expect {
+      env.transaction { db['key2'] = 'value2' }
+    }.not_to raise_error
+  end
+
+  # -----------------------------------------------------------------------
+  # 8. Transaction object survives GC after finishing
+  #    Verifies that a finished transaction's Ruby object can be
+  #    collected without corrupting the environment
+  # -----------------------------------------------------------------------
+  it 'allows GC to collect finished transaction objects safely' do
+    10.times do |i|
+      env.transaction { db["key#{i}"] = "value#{i}" }
+    end
+    # force collection of all those transaction objects
+    GC.compact
+    GC.start
+    expect {
+      env.transaction { db['final'] = 'write' }
+    }.not_to raise_error
+  end
+
+  # -----------------------------------------------------------------------
+  # 9. Many databases, many transactions, GC between each
+  #    Closer to the Store::Digest workload profile
+  # -----------------------------------------------------------------------
+  it 'handles multiple named databases with GC.compact between writes' do
+    dbs = %w[alpha beta gamma delta].map do |name|
+      env.database(name, create: true)
+    end
+    GC.compact
+
+    10.times do |i|
+      env.transaction do
+        dbs.each { |d| d["key#{i}"] = "value#{i}" }
+      end
+      GC.compact
+    end
+
+    env.transaction(true) do
+      dbs.each do |d|
+        10.times { |i| expect(d["key#{i}"]).to eq "value#{i}" }
+      end
+    end
+  end
+end

data/spec/helper.rb

@@ -27,7 +27,7 @@ end
 RSpec.configure do |c|
   c.include LMDB::SpecHelper
   c.after { FileUtils.rm_rf TEMP_ROOT }
-  c.expect_with :rspec do |cc|
-    cc.syntax = :should
-  end
+  # c.expect_with :rspec do |cc|
+  #   cc.syntax = :should
+  # end
 end