lmdb 0.7.3 → 0.8.0

data/spec/pseudo_transactions_spec.rb

@@ -0,0 +1,237 @@
+require 'helper'
+require 'lmdb'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.describe 'LMDB pseudo-transactions (RO nested inside RW)' do
+  let(:path) { Dir.mktmpdir }
+  let(:env)  { LMDB.new(path, mapsize: 2**20) }
+  let(:db)   { env.database('test', create: true) }
+
+  before(:each) { db } # ensure db is opened inside a txn before tests run
+
+  after(:each) do
+    env.close rescue nil
+    FileUtils.rm_rf path
+  end
+
+  it 'should not have anything in the readers' do
+    expect(env.info[:numreaders]).to eq(0)
+    expect(env.reader_check).to eq(0)
+    expect(env.reader_list.first).to eq("(no active readers)\n")
+  end
+
+  # -----------------------------------------------------------------------
+  # The core bug: RO transaction nested inside RW must not abort the RW txn
+  # when the RO block raises.
+  # -----------------------------------------------------------------------
+
+  it 'does not abort the outer RW transaction when the inner RO block raises' do
+
+    # warn env.reader_list.inspect
+
+    expect {
+      env.transaction do
+
+        db['key'] = 'value'
+
+        # This inner RO transaction raises. Before the fix this silently
+        # aborted the outer RW transaction, causing the subsequent write
+        # to produce EINVAL / "Invalid argument".
+        begin
+          env.transaction(true) do
+            # warn env.reader_list.inspect
+            raise 'deliberate error inside RO block'
+          end
+        rescue RuntimeError
+          # swallow — the outer RW transaction should survive this
+        end
+
+        # This write must succeed. If the outer txn was aborted by the
+        # inner RO block's exception, this raises LMDB::Error::BadTxn or
+        # produces "Invalid argument".
+        db['key2'] = 'value2'
+      end
+    }.not_to raise_error
+
+    # And the writes must have actually committed
+    env.transaction(true) do
+      expect(db['key']).to  eq 'value'
+      expect(db['key2']).to eq 'value2'
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # commit/abort on a pseudo-txn are no-ops: the outer RW txn survives
+  # -----------------------------------------------------------------------
+
+  it 'treats txn.commit inside a pseudo-transaction as a no-op' do
+    env.transaction do
+      db['before'] = 'yes'
+
+      env.transaction(true) do |pseudo|
+        # explicit commit on a pseudo-txn should be a no-op, not an error,
+        # and must not commit the outer RW transaction prematurely
+        pseudo.commit
+      end
+
+      # outer txn still alive — this must not raise
+      db['after'] = 'yes'
+    end
+
+    env.transaction(true) do
+      expect(db['before']).to eq 'yes'
+      expect(db['after']).to  eq 'yes'
+    end
+  end
+
+  it 'treats txn.abort inside a pseudo-transaction as a no-op' do
+    env.transaction do
+      db['key'] = 'written'
+
+      env.transaction(true) do |pseudo|
+        # explicit abort on a pseudo-txn must not roll back the outer txn
+        pseudo.abort
+      end
+
+      # outer txn still alive
+      db['key2'] = 'also written'
+    end
+
+    env.transaction(true) do
+      expect(db['key']).to  eq 'written'
+      expect(db['key2']).to eq 'also written'
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # pseudo-txn correctly reflects the read view of the enclosing RW txn
+  # -----------------------------------------------------------------------
+
+  it 'can read writes made in the outer RW transaction via the pseudo-transaction' do
+    env.transaction do
+      db['visible'] = 'yes'
+
+      result = env.transaction(true) do |pseudo|
+        # writes made in the outer txn should be visible here since
+        # we are using the same underlying MDB_txn
+        db['visible']
+      end
+
+      expect(result).to eq 'yes'
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # break from pseudo-txn exits only the inner block; outer RW continues
+  # -----------------------------------------------------------------------
+  it 'break from a pseudo-transaction exits only the inner block' do
+    outer_continued = false
+
+    env.transaction do
+      db['key'] = 'value'
+
+      env.transaction(true) do
+        break
+      end
+
+      outer_continued = true
+      db['key2'] = 'value2'
+    end
+
+    expect(outer_continued).to be true
+    env.transaction(true) do
+      expect(db['key']).to  eq 'value'
+      expect(db['key2']).to eq 'value2'
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # pseudo-txn finished? predicate
+  # -----------------------------------------------------------------------
+
+  it 'marks the pseudo-transaction as finished after the block exits' do
+    pseudo_ref = nil
+
+    env.transaction do
+      env.transaction(true) do |pseudo|
+        pseudo_ref = pseudo
+        expect(pseudo_ref.finished?).to be false
+      end
+    end
+
+    # After the pseudo block exits, txn should be terminated
+    expect(pseudo_ref.finished?).to be true
+  end
+
+  # -----------------------------------------------------------------------
+  # Nested pseudo-txns (RO inside RO inside RW) also work correctly
+  # -----------------------------------------------------------------------
+
+  it 'handles doubly-nested pseudo-transactions without corrupting the txn chain' do
+    env.transaction do
+      db['key'] = 'value'
+
+      env.transaction(true) do
+        env.transaction(true) do
+          expect(db['key']).to eq 'value'
+        end
+        # still inside the first RO pseudo here
+        expect(db['key']).to eq 'value'
+      end
+
+      # outer RW still alive
+      db['key2'] = 'value2'
+    end
+
+    env.transaction(true) do
+      expect(db['key']).to  eq 'value'
+      expect(db['key2']).to eq 'value2'
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # The original store-digest scenario: exception inside a method that
+  # opens its own RO transaction while called from inside a RW transaction.
+  # This is the real-world pattern that was failing.
+  # -----------------------------------------------------------------------
+
+  it 'survives the mark_meta_deleted pattern: RO read inside a RW write block' do
+    # Simulate the pattern from store-digest's v1.rb:
+    #   mark_meta_deleted opens @lmdb.transaction (RW)
+    #     then calls get_meta which opens @lmdb.transaction(true) (RO)
+    #     get_meta raises
+    #   mark_meta_deleted should survive and continue
+
+    def read_with_possible_raise(env, db, should_raise)
+      env.transaction(true) do
+        raise 'record not found' if should_raise
+        db['key']
+      end
+    end
+
+    expect {
+      env.transaction do
+        db['key'] = 'value'
+
+        # First inner RO call raises — simulates get_meta failing
+        begin
+          read_with_possible_raise(env, db, true)
+        rescue RuntimeError
+          # expected, swallow it
+        end
+
+        # Second inner RO call succeeds — simulates a subsequent read
+        val = read_with_possible_raise(env, db, false)
+        expect(val).to eq 'value'
+
+        db['key2'] = 'also committed'
+      end
+    }.not_to raise_error
+
+    env.transaction(true) do
+      expect(db['key']).to  eq 'value'
+      expect(db['key2']).to eq 'also committed'
+    end
+  end
+end

data/vendor/liblmdb/VERSION

@@ -0,0 +1 @@
+LMDB_0.9.35

data/vendor/{libraries/liblmdb → liblmdb}/lmdb.h

@@ -53,15 +53,14 @@
  *
  *	  Fix: Check for stale readers periodically, using the
  *	  #mdb_reader_check function or the \ref mdb_stat_1 "mdb_stat" tool.
- *	  Stale writers will be cleared automatically on most systems:
+ *	  Stale writers will be cleared automatically on some systems:
  *	  - Windows - automatic
- *	  - BSD, systems using SysV semaphores - automatic
  *	  - Linux, systems using POSIX mutexes with Robust option - automatic
+ *	  - not on BSD, systems using POSIX semaphores.
  *	  Otherwise just make all programs using the database close it;
  *	  the lockfile is always reset on first open of the environment.
  *
- *	- On BSD systems or others configured with MDB_USE_SYSV_SEM or
- *	  MDB_USE_POSIX_SEM,
+ *	- On BSD systems or others configured with MDB_USE_POSIX_SEM,
  *	  startup can fail due to semaphores owned by another userid.
  *
  *	  Fix: Open and close the database as the user which owns the
@@ -167,8 +166,6 @@
 #define _LMDB_H_
 
 #include <sys/types.h>
-#include <inttypes.h>
-#include <limits.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -181,32 +178,6 @@ typedef	int	mdb_mode_t;
 typedef	mode_t	mdb_mode_t;
 #endif
 
-#ifdef _WIN32
-# define MDB_FMT_Z	"I"
-#else
-# define MDB_FMT_Z	"z"			/**< printf/scanf format modifier for size_t */
-#endif
-
-#ifndef MDB_VL32
-/** Unsigned type used for mapsize, entry counts and page/transaction IDs.
- *
- *	It is normally size_t, hence the name. Defining MDB_VL32 makes it
- *	uint64_t, but do not try this unless you know what you are doing.
- */
-typedef size_t	mdb_size_t;
-# define MDB_SIZE_MAX	SIZE_MAX	/**< max #mdb_size_t */
-/** #mdb_size_t printf formats, \b t = one of [diouxX] without quotes */
-# define MDB_PRIy(t)	MDB_FMT_Z #t
-/** #mdb_size_t scanf formats, \b t = one of [dioux] without quotes */
-# define MDB_SCNy(t)	MDB_FMT_Z #t
-#else
-typedef uint64_t	mdb_size_t;
-# define MDB_SIZE_MAX	UINT64_MAX
-# define MDB_PRIy(t)	PRI##t##64
-# define MDB_SCNy(t)	SCN##t##64
-# define mdb_env_create	mdb_env_create_vl32	/**< Prevent mixing with non-VL32 builds */
-#endif
-
 /** An abstraction for a file handle.
  *	On POSIX systems file handles are small integers. On Windows
  *	they're opaque pointers.
@@ -229,7 +200,7 @@ typedef int mdb_filehandle_t;
 /** Library minor version */
 #define MDB_VERSION_MINOR	9
 /** Library patch version */
-#define MDB_VERSION_PATCH	70
+#define MDB_VERSION_PATCH	35
 
 /** Combine args a,b,c into a single integer for easy version comparisons */
 #define MDB_VERINT(a,b,c)	(((a) << 24) | ((b) << 16) | (c))
@@ -239,7 +210,7 @@ typedef int mdb_filehandle_t;
 	MDB_VERINT(MDB_VERSION_MAJOR,MDB_VERSION_MINOR,MDB_VERSION_PATCH)
 
 /** The release date of this library version */
-#define MDB_VERSION_DATE	"December 19, 2015"
+#define MDB_VERSION_DATE	"Jan 27, 2026"
 
 /** A stringifier for the version info */
 #define MDB_VERSTR(a,b,c,d)	"LMDB " #a "." #b "." #c ": (" d ")"
@@ -332,8 +303,6 @@ typedef void (MDB_rel_func)(MDB_val *item, void *oldptr, void *newptr, void *rel
 #define MDB_NORDAHEAD	0x800000
 	/** don't initialize malloc'd memory before writing to datafile */
 #define MDB_NOMEMINIT	0x1000000
-	/** use the previous snapshot rather than the latest one */
-#define MDB_PREVSNAPSHOT	0x2000000
 /** @} */
 
 /**	@defgroup	mdb_dbi_open	Database Flags
@@ -343,8 +312,7 @@ typedef void (MDB_rel_func)(MDB_val *item, void *oldptr, void *newptr, void *rel
 #define MDB_REVERSEKEY	0x02
 	/** use sorted duplicates */
 #define MDB_DUPSORT		0x04
-	/** numeric keys in native byte order, either unsigned int or #mdb_size_t.
-	 *	(lmdb expects 32-bit int <= size_t <= 32/64-bit mdb_size_t.)
+	/** numeric keys in native byte order: either unsigned int or size_t.
 	 *  The keys must all be of the same size. */
 #define MDB_INTEGERKEY	0x08
 	/** with #MDB_DUPSORT, sorted dup items have fixed size */
@@ -480,10 +448,8 @@ typedef enum MDB_cursor_op {
 #define MDB_BAD_VALSIZE		(-30781)
 	/** The specified DBI was changed unexpectedly */
 #define MDB_BAD_DBI		(-30780)
-	/** Unexpected problem - txn should abort */
-#define MDB_PROBLEM		(-30779)
 	/** The last defined error code */
-#define MDB_LAST_ERRCODE	MDB_PROBLEM
+#define MDB_LAST_ERRCODE	MDB_BAD_DBI
 /** @} */
 
 /** @brief Statistics for a database in the environment */
@@ -491,18 +457,18 @@ typedef struct MDB_stat {
 	unsigned int	ms_psize;			/**< Size of a database page.
 											This is currently the same for all databases. */
 	unsigned int	ms_depth;			/**< Depth (height) of the B-tree */
-	mdb_size_t		ms_branch_pages;	/**< Number of internal (non-leaf) pages */
-	mdb_size_t		ms_leaf_pages;		/**< Number of leaf pages */
-	mdb_size_t		ms_overflow_pages;	/**< Number of overflow pages */
-	mdb_size_t		ms_entries;			/**< Number of data items */
+	size_t		ms_branch_pages;	/**< Number of internal (non-leaf) pages */
+	size_t		ms_leaf_pages;		/**< Number of leaf pages */
+	size_t		ms_overflow_pages;	/**< Number of overflow pages */
+	size_t		ms_entries;			/**< Number of data items */
 } MDB_stat;
 
 /** @brief Information about the environment */
 typedef struct MDB_envinfo {
 	void	*me_mapaddr;			/**< Address of map, if fixed */
-	mdb_size_t	me_mapsize;				/**< Size of the data memory map */
-	mdb_size_t	me_last_pgno;			/**< ID of the last used page */
-	mdb_size_t	me_last_txnid;			/**< ID of the last committed transaction */
+	size_t	me_mapsize;				/**< Size of the data memory map */
+	size_t	me_last_pgno;			/**< ID of the last used page */
+	size_t	me_last_txnid;			/**< ID of the last committed transaction */
 	unsigned int me_maxreaders;		/**< max reader slots in the environment */
 	unsigned int me_numreaders;		/**< max reader slots used in the environment */
 } MDB_envinfo;
@@ -648,12 +614,6 @@ int  mdb_env_create(MDB_env **env);
 	 *		caller is expected to overwrite all of the memory that was
 	 *		reserved in that case.
 	 *		This flag may be changed at any time using #mdb_env_set_flags().
-	 *	<li>#MDB_PREVSNAPSHOT
-	 *		Open the environment with the previous snapshot rather than the latest
-	 *		one. This loses the latest transaction, but may help work around some
-	 *		types of corruption. If opened with write access, this must be the
-	 *		only process using the environment. This flag is automatically reset
-	 *		after a write transaction is successfully committed.
 	 * </ul>
 	 * @param[in] mode The UNIX permissions to set on created files and semaphores.
 	 * This parameter is ignored on Windows.
@@ -882,7 +842,7 @@ int  mdb_env_get_fd(MDB_env *env, mdb_filehandle_t *fd);
 	 *   	an active write transaction.
 	 * </ul>
 	 */
-int  mdb_env_set_mapsize(MDB_env *env, mdb_size_t size);
+int  mdb_env_set_mapsize(MDB_env *env, size_t size);
 
 	/** @brief Set the maximum number of threads/reader slots for the environment.
 	 *
@@ -995,10 +955,6 @@ int  mdb_env_set_assert(MDB_env *env, MDB_assert_func *func);
 	 * <ul>
 	 *	<li>#MDB_RDONLY
 	 *		This transaction will not perform any write operations.
-	 *	<li>#MDB_NOSYNC
-	 *		Don't flush system buffers to disk when committing this transaction.
-	 *	<li>#MDB_NOMETASYNC
-	 *		Flush system buffers but omit metadata flush when committing this transaction.
 	 * </ul>
 	 * @param[out] txn Address where the new #MDB_txn handle will be stored
 	 * @return A non-zero error value on failure and 0 on success. Some possible
@@ -1031,7 +987,7 @@ MDB_env *mdb_txn_env(MDB_txn *txn);
 	 * @param[in] txn A transaction handle returned by #mdb_txn_begin()
 	 * @return A transaction ID, valid if input is an active transaction.
 	 */
-mdb_size_t mdb_txn_id(MDB_txn *txn);
+size_t mdb_txn_id(MDB_txn *txn);
 
 	/** @brief Commit all the operations of a transaction into the database.
 	 *
@@ -1141,8 +1097,7 @@ int  mdb_txn_renew(MDB_txn *txn);
 	 *		keys must be unique and may have only a single data item.
 	 *	<li>#MDB_INTEGERKEY
 	 *		Keys are binary integers in native byte order, either unsigned int
-	 *		or #mdb_size_t, and will be sorted as such.
-	 *		(lmdb expects 32-bit int <= size_t <= 32/64-bit mdb_size_t.)
+	 *		or size_t, and will be sorted as such.
 	 *		The keys must all be of the same size.
 	 *	<li>#MDB_DUPFIXED
 	 *		This flag may only be used in combination with #MDB_DUPSORT. This option
@@ -1587,7 +1542,7 @@ int  mdb_cursor_del(MDB_cursor *cursor, unsigned int flags);
 	 *	<li>EINVAL - cursor is not initialized, or an invalid parameter was specified.
 	 * </ul>
 	 */
-int  mdb_cursor_count(MDB_cursor *cursor, mdb_size_t *countp);
+int  mdb_cursor_count(MDB_cursor *cursor, size_t *countp);
 
 	/** @brief Compare two data items according to a particular database.
 	 *