lutaml-store 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6d1582c83685b6c2944eccf8c9c986aeba99e639e923dda11336551c696f459
-  data.tar.gz: 91b2b36840f8303f1a70e094b4f7f50151665dcc21fa7a837e2b33c4e92400aa
+  metadata.gz: f523f159520c178e2855aa2070f1f7c19b39c4e6ddb21dd6efb9ee00dd786c55
+  data.tar.gz: 2184b3afe0a9fb1d697fd8fdf8f2f09f1d8664f30e389c3c41d7e33945f2f704
 SHA512:
-  metadata.gz: d772bb3840f661fbad608973396ca00ae324950fa368ed9aaa14b53eab69e4b6618ec8cd57f9d2d29ffbc6f5ba93a138ca76fc176113d9a2a163ebf228df63cb
-  data.tar.gz: b4822cac5f262a2a4235b7fd16455da525fa3c0405de17ed374cfd9327eeebc89cb22052243e0a04a1cd7fc00832f306b0c0bc9552c1faa967011f31a01066d7
+  metadata.gz: b63ebe9a382678154f315a5716c49ecfe7481ba3ec8d08b703cd89870e50cec980af56ade9cddb7f368e0e5e8f5798aa61b53061f9348c9a2d2335852d553859
+  data.tar.gz: ac4351a3a80e045d254a057026309b2e2cd4228598adfff7ff20ddd45b247b9ecbab82b92413a7acb99e14f20dcaa45b5ab30d5c40a2bb7b4ede64f0e4533262

data/Rakefile

@@ -10,3 +10,48 @@ require "rubocop/rake_task"
 RuboCop::RakeTask.new
 
 task default: %i[spec rubocop]
+
+desc "Run adapter benchmarks and print a comparison report"
+task :"performance:compare" do
+  $LOAD_PATH.unshift(File.expand_path("lib", __dir__))
+  require "lutaml/store"
+  require "tmpdir"
+  require "fileutils"
+
+  ops = 2000
+  data = Array.new(100) { |i| { "id" => i, "name" => "item-#{i}" } }
+
+  measure = lambda do |label, &operation|
+    GC.start
+    t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    operation.call
+    format("%<label>-34s %<us>9.1fus/op", label: label,
+                                          us: (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1_000_000 / ops)
+  end
+
+  results = []
+  Dir.mktmpdir do |dir|
+    memory = Lutaml::Store::Adapter::Memory.new
+    results << measure.call("memory set") { ops.times { |i| memory.set("k#{i}", data[i % 100]) } }
+    results << measure.call("memory get") { ops.times { |i| memory.get("k#{i % 500}") } }
+
+    fs = Lutaml::Store::Adapter::FileSystem.new(path: File.join(dir, "fs"))
+    results << measure.call("filesystem set") { ops.times { |i| fs.set("k#{i}", data[i % 100]) } }
+    results << measure.call("filesystem set (unchanged)") { ops.times { |i| fs.set("k#{i}", data[i % 100]) } }
+    results << measure.call("filesystem get") { ops.times { |i| fs.get("k#{i % 500}") } }
+    fs.close
+    FileUtils.rm_rf(File.join(dir, "fs"))
+
+    begin
+      require "sqlite3"
+      sqlite = Lutaml::Store::Adapter::Sqlite.new(path: File.join(dir, "db.sqlite3"))
+      results << measure.call("sqlite set") { ops.times { |i| sqlite.set("k#{i}", data[i % 100]) } }
+      results << measure.call("sqlite get") { ops.times { |i| sqlite.get("k#{i % 500}") } }
+      sqlite.close
+    rescue LoadError
+      results << "sqlite3 gem unavailable, sqlite benchmarks skipped"
+    end
+  end
+
+  puts results
+end

data/lib/lutaml/store/adapter/filesystem.rb

@@ -53,6 +53,7 @@ module Lutaml
           @integrity_algorithm = @config.fetch(:integrity_algorithm, "sha256")
           @lock_path = File.expand_path(File.join(@root_path, LOCK_FILE))
           @monitor = self.class.monitor_for(@lock_path)
+          @metadata_cache = {}
 
           setup_directory_structure
         end
@@ -72,7 +73,16 @@ module Lutaml
 
         def set(key, value)
           content, format = encode_value(value)
-          with_lock(:ex) { write_entry(key, content, format) }
+          with_lock(:ex) do
+            # Writing costs two fsync-backed temp files plus renames, and
+            # idempotent rewrites (periodic model saves of unchanged data)
+            # gain nothing from them, so an entry whose stored bytes and
+            # metadata are both unchanged is left untouched
+            file_path = existing_path_for_key(key)
+            next value if file_path && entry_unchanged?(file_path, content, format)
+
+            write_entry(key, content, format)
+          end
           value
         end
 
@@ -283,7 +293,7 @@ module Lutaml
 
         def read_verified_at(file_path, _key)
           data = file_safe_read(file_path)
-          metadata = read_metadata(metadata_path_for(file_path))
+          metadata = cached_metadata(file_path)
 
           begin
             verify_data_integrity(data, metadata)
@@ -294,6 +304,11 @@ module Lutaml
           [:ok, decode_value(data, metadata[:format])]
         end
 
+        def entry_unchanged?(file_path, content, format)
+          File.binread(file_path) == content &&
+            read_metadata(metadata_path_for(file_path))[:format] == format
+        end
+
         def write_entry(key, content, format)
           file_path = path_for_key(key)
           metadata_path = metadata_path_for(file_path)
@@ -434,6 +449,30 @@ module Lutaml
           {}
         end
 
+        # Reading and parsing the metadata sidecar costs a read and a JSON
+        # parse on every get; the cached copy is validated against the
+        # file's mtime, so rewrites by this or another process invalidate
+        # it. Bounded like every cache fontist/lutaml hosts live with.
+        METADATA_CACHE_MAX = 1024
+
+        def cached_metadata(file_path)
+          metadata_path = metadata_path_for(file_path)
+          return {} unless File.exist?(metadata_path)
+
+          mtime = File.mtime(metadata_path)
+          entry = @metadata_cache[metadata_path]
+          if entry&.fetch(:mtime, nil) == mtime
+            @metadata_cache.delete(metadata_path)
+            @metadata_cache[metadata_path] = entry
+            return entry[:metadata]
+          end
+
+          metadata = read_metadata(metadata_path)
+          @metadata_cache.shift while @metadata_cache.size >= METADATA_CACHE_MAX
+          @metadata_cache[metadata_path] = { mtime: mtime, metadata: metadata }
+          metadata
+        end
+
         # ── Files ──
 
         def ensure_directory_exists(dir_path)

data/lib/lutaml/store/adapter/sqlite.rb

@@ -111,10 +111,11 @@ module Lutaml
         def bulk_set(key_value_pairs)
           @db.transaction do
             key_value_pairs.each do |key, value|
-              serialized_value = value.is_a?(String) ? value : JSON.generate(value)
+              is_string = value.is_a?(String)
+              serialized_value = is_string ? value : JSON.generate(value)
               execute_statement(
-                "INSERT OR REPLACE INTO #{@table_name} (key, value, updated_at) VALUES (?, ?, ?)",
-                [key, serialized_value, Time.now.to_f]
+                "INSERT OR REPLACE INTO #{@table_name} (key, value, is_json, updated_at) VALUES (?, ?, ?, ?)",
+                [key, serialized_value, is_string ? 0 : 1, Time.now.to_f]
               )
             end
           end

data/lib/lutaml/store/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Store
-    VERSION = "0.3.5"
+    VERSION = "0.3.7"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-store
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - Ronald Tse