lutaml-store 0.2.1 → 0.2.4

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

@@ -3,136 +3,145 @@
 module Lutaml
   module Store
     module Adapter
+      # In-memory key-value adapter optimized for read-heavy workloads.
+      # Writes are synchronized; reads are lock-free using snapshot copies.
       class Memory < Base
         def initialize(config = {})
           super
           @data = {}
-          @mutex = Mutex.new
+          @write_mutex = Mutex.new
+          @read_snapshot = {}.freeze
+          @snapshot_stale = true
           @ttl_enabled = @config.fetch(:ttl_enabled, false)
-          @ttl_data = {} if @ttl_enabled
+          @ttl_data = @ttl_enabled ? {} : nil
           @default_ttl = @config[:default_ttl] || 3600
         end
 
+        # ── Read operations (lock-free via snapshot) ──
+
         def get(key)
-          @mutex.synchronize do
-            return nil unless @data.key?(key)
+          cleanup_expired_if_needed
+          snapshot[key]
+        end
 
-            if @ttl_enabled && expired?(key)
-              @data.delete(key)
-              @ttl_data.delete(key)
-              return nil
-            end
+        def exists?(key)
+          cleanup_expired_if_needed
+          snapshot.key?(key)
+        end
+
+        def all
+          cleanup_expired_if_needed
+          snapshot.dup
+        end
+
+        def size
+          cleanup_expired_if_needed
+          snapshot.size
+        end
+
+        def keys
+          cleanup_expired_if_needed
+          snapshot.keys
+        end
 
-            @data[key]
+        def each_key(&block)
+          cleanup_expired_if_needed
+          snapshot.each_key(&block)
+        end
+
+        def bulk_get(keys)
+          cleanup_expired_if_needed
+          snap = snapshot
+          keys.each_with_object({}) do |k, h|
+            h[k] = snap[k]
           end
         end
 
+        # ── Write operations (synchronized) ──
+
         def set(key, value, metadata = {})
-          @mutex.synchronize do
+          @write_mutex.synchronize do
             @data[key] = value
+            invalidate_snapshot
 
             if @ttl_enabled
               ttl_value = metadata[:ttl] || @default_ttl
               @ttl_data[key] = Time.now + ttl_value if ttl_value
             end
-
-            value
           end
+          value
         end
 
         def delete(key)
-          @mutex.synchronize do
+          @write_mutex.synchronize do
             existed = @data.key?(key)
             @data.delete(key)
-            @ttl_data.delete(key) if @ttl_enabled
+            @ttl_data&.delete(key)
+            invalidate_snapshot
             existed
           end
         end
 
-        def exists?(key)
-          @mutex.synchronize do
-            return false unless @data.key?(key)
-
-            if @ttl_enabled && expired?(key)
-              @data.delete(key)
-              @ttl_data.delete(key)
-              return false
-            end
-
-            true
-          end
-        end
-
-        def all
-          @mutex.synchronize do
-            cleanup_expired if @ttl_enabled
-            @data.dup
-          end
-        end
-
         def clear
-          @mutex.synchronize do
+          @write_mutex.synchronize do
             count = @data.size
             @data.clear
-            @ttl_data.clear if @ttl_enabled
+            @ttl_data&.clear
+            invalidate_snapshot
             count
           end
         end
 
-        def size
-          @mutex.synchronize do
-            cleanup_expired if @ttl_enabled
-            @data.size
+        def close
+          @write_mutex.synchronize do
+            @data.clear
+            @ttl_data&.clear
+            invalidate_snapshot
           end
         end
 
-        def keys
-          @mutex.synchronize do
-            cleanup_expired if @ttl_enabled
-            @data.keys
-          end
-        end
+        def bulk_set(key_value_pairs, ttl: nil)
+          @write_mutex.synchronize do
+            key_value_pairs.each do |key, value|
+              @data[key] = value
 
-        def each_key(&block)
-          current_keys = @mutex.synchronize do
-            cleanup_expired if @ttl_enabled
-            @data.keys
+              if @ttl_enabled
+                ttl_value = ttl || @default_ttl
+                @ttl_data[key] = Time.now + ttl_value if ttl_value
+              end
+            end
+            invalidate_snapshot
           end
-          current_keys.each(&block)
         end
 
-        def close
-          @mutex.synchronize do
-            @data.clear
-            @ttl_data.clear if @ttl_enabled
+        def bulk_delete(keys)
+          @write_mutex.synchronize do
+            result = {}
+            keys.each do |key|
+              result[key] = @data.delete(key)
+              @ttl_data&.delete(key)
+            end
+            invalidate_snapshot
+            result
           end
         end
 
-        def stats
-          @mutex.synchronize do
-            cleanup_expired if @ttl_enabled
-            super.merge(
-              size: @data.size,
-              ttl_enabled: @ttl_enabled,
-              expired_keys: @ttl_enabled ? count_expired_keys : 0
-            )
-          end
-        end
+        # ── TTL operations ──
 
         def cleanup_expired
           return unless @ttl_enabled
 
-          @mutex.synchronize do
-            expired_keys = []
-            @ttl_data.each do |key, expiry_time|
-              expired_keys << key if Time.now > expiry_time
+          @write_mutex.synchronize do
+            now = Time.now
+            expired_keys = @ttl_data.each_with_object([]) do |(key, expiry_time), arr|
+              arr << key if now > expiry_time
             end
 
             expired_keys.each do |key|
               @data.delete(key)
               @ttl_data.delete(key)
             end
-
+            invalidate_snapshot unless expired_keys.empty?
             expired_keys.size
           end
         end
@@ -140,7 +149,7 @@ module Lutaml
         def set_ttl(key, ttl)
           return false unless @ttl_enabled
 
-          @mutex.synchronize do
+          @write_mutex.synchronize do
             return false unless @data.key?(key)
 
             if ttl
@@ -148,7 +157,7 @@ module Lutaml
             else
               @ttl_data.delete(key)
             end
-
+            invalidate_snapshot
             true
           end
         end
@@ -156,76 +165,159 @@ module Lutaml
         def get_ttl(key)
           return nil unless @ttl_enabled
 
-          @mutex.synchronize do
-            return nil unless @ttl_data.key?(key)
+          snap = snapshot
+          return nil unless snap.key?(key)
+          return nil unless @ttl_data.key?(key)
+
+          remaining = @ttl_data[key] - Time.now
+          remaining.positive? ? remaining : nil
+        end
+
+        # ── Query operations (lock-free via snapshot) ──
+
+        def execute_query(query)
+          cleanup_expired_if_needed
+          snap = snapshot
+          model_name = query.model_class.name
+          preds = query.predicates
+
+          results = []
+          snap.each do |key, value|
+            parsed = StorageKey.parse(key.to_s)
+            next unless parsed.class_name == model_name
+            next unless preds_all_match?(preds, value)
 
-            expiry_time = @ttl_data[key]
-            remaining = expiry_time - Time.now
-            remaining.positive? ? remaining : nil
+            results << [key, value]
           end
+
+          results = apply_sort(results, query.orders)
+          results = apply_pagination(results, query.limit_value, query.offset_value)
         end
 
-        def bulk_set(key_value_pairs, ttl: nil)
-          @mutex.synchronize do
-            key_value_pairs.each do |key, value|
-              @data[key] = value
+        def count_query(query)
+          cleanup_expired_if_needed
+          snap = snapshot
+          model_name = query.model_class.name
+          preds = query.predicates
 
-              if @ttl_enabled
-                ttl_value = ttl || @default_ttl
-                @ttl_data[key] = Time.now + ttl_value if ttl_value
-              end
-            end
+          count = 0
+          snap.each do |key, value|
+            parsed = StorageKey.parse(key.to_s)
+            next unless parsed.class_name == model_name
+            next unless preds_all_match?(preds, value)
+
+            count += 1
           end
+          count
         end
 
-        def bulk_get(keys)
-          @mutex.synchronize do
-            result = {}
-            keys.each do |key|
-              if @data.key?(key)
-                if @ttl_enabled && expired?(key)
-                  @data.delete(key)
-                  @ttl_data.delete(key)
-                  result[key] = nil
-                else
-                  result[key] = @data[key]
-                end
-              else
-                result[key] = nil
-              end
-            end
-            result
+        def batch_query(query, after: nil, limit: 1000)
+          cleanup_expired_if_needed
+          snap = snapshot
+          model_name = query.model_class.name
+          preds = query.predicates
+
+          sorted_keys = snap.keys.sort_by(&:to_s)
+          sorted_keys = sorted_keys.select { |k| k.to_s > after } if after
+
+          results = []
+          sorted_keys.each do |key|
+            parsed = StorageKey.parse(key.to_s)
+            next unless parsed.class_name == model_name
+
+            value = snap[key]
+            next unless value
+            next unless preds_all_match?(preds, value)
+
+            results << [key.to_s, value]
+            break if results.size >= limit
           end
+          results
         end
 
-        def bulk_delete(keys)
-          @mutex.synchronize do
-            result = {}
-            keys.each do |key|
-              result[key] = @data.delete(key)
-              @ttl_data.delete(key) if @ttl_enabled
+        def stats
+          cleanup_expired_if_needed
+          snap = snapshot
+          super.merge(
+            size: snap.size,
+            ttl_enabled: @ttl_enabled,
+            expired_keys: @ttl_enabled ? count_expired_keys : 0
+          )
+        end
+
+        private
+
+        # Frozen snapshot — lock-free reads. Rebuilt lazily after writes.
+        def snapshot
+          if @snapshot_stale
+            @write_mutex.synchronize do
+              if @snapshot_stale
+                @read_snapshot = @data.dup.freeze
+                @snapshot_stale = false
+              end
             end
-            result
           end
+          @read_snapshot
         end
 
-        private
+        def invalidate_snapshot
+          @snapshot_stale = true
+        end
 
-        def expired?(key)
-          return false unless @ttl_enabled
-          return false unless @ttl_data.key?(key)
+        def cleanup_expired_if_needed
+          return unless @ttl_enabled
+
+          now = Time.now
+          return unless @ttl_data.any? { |_k, expiry| now > expiry }
 
-          Time.now > @ttl_data[key]
+          cleanup_expired
         end
 
         def count_expired_keys
           return 0 unless @ttl_enabled
 
-          count = 0
-          @ttl_data.each_value do |expiry_time|
-            count += 1 if Time.now > expiry_time
+          now = Time.now
+          @ttl_data.count { |_k, expiry| now > expiry }
+        end
+
+        # Inline predicate evaluation — avoids method dispatch overhead in tight loops
+        def preds_all_match?(predicates, value)
+          predicates.all? { |p| p.match?(value) }
+        end
+
+        def apply_sort(results, orders)
+          return results if orders.empty?
+
+          results.sort do |a, b|
+            orders.reduce(0) do |cmp, o|
+              break cmp unless cmp.zero?
+
+              va = a.last.is_a?(Hash) ? a.last[o.field.to_s] : nil
+              vb = b.last.is_a?(Hash) ? b.last[o.field.to_s] : nil
+
+              cmp_val = compare_values(va, vb)
+              o.direction == :desc ? -cmp_val : cmp_val
+            end
           end
-          count
+        end
+
+        def compare_values(val_a, val_b)
+          if val_a.nil? && val_b.nil?
+            0
+          elsif val_a.nil?
+            1
+          elsif val_b.nil?
+            -1
+          else
+            val_a <=> val_b || 0
+          end
+        end
+
+        def apply_pagination(results, limit, offset)
+          start = offset || 0
+          results = results[start..] || []
+          results = results.first(limit) if limit
+          results
         end
       end
     end

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

@@ -23,9 +23,11 @@ module Lutaml
           setup_database
         end
 
+        # ── Key-value operations ──
+
         def get(key)
           result = nil
-          execute_query("SELECT value FROM #{@table_name} WHERE key = ?", [key]) do |row|
+          execute_query_raw("SELECT value FROM #{@table_name} WHERE key = ?", [key]) do |row|
             value = row[0]
             begin
               result = JSON.parse(value)
@@ -55,7 +57,7 @@ module Lutaml
         end
 
         def exists?(key)
-          execute_query("SELECT 1 FROM #{@table_name} WHERE key = ? LIMIT 1", [key]) do |_row|
+          execute_query_raw("SELECT 1 FROM #{@table_name} WHERE key = ? LIMIT 1", [key]) do |_row|
             return true
           end
           false
@@ -63,7 +65,7 @@ module Lutaml
 
         def all
           result = {}
-          execute_query("SELECT key, value FROM #{@table_name}") do |row|
+          execute_query_raw("SELECT key, value FROM #{@table_name}") do |row|
             result[row[0]] = row[1]
           end
           result
@@ -76,7 +78,7 @@ module Lutaml
         end
 
         def size
-          execute_query("SELECT COUNT(*) FROM #{@table_name}") do |row|
+          execute_query_raw("SELECT COUNT(*) FROM #{@table_name}") do |row|
             return row[0]
           end
           0
@@ -84,7 +86,7 @@ module Lutaml
 
         def keys
           result = []
-          execute_query("SELECT key FROM #{@table_name}") do |row|
+          execute_query_raw("SELECT key FROM #{@table_name}") do |row|
             result << row[0]
           end
           result
@@ -132,6 +134,56 @@ module Lutaml
           result
         end
 
+        # ── Query operations ──
+
+        def execute_query(query)
+          sql, params = build_select_sql(query)
+          results = []
+          execute_query_raw(sql, params) do |row|
+            key = row[0]
+            value = parse_json_value(row[1])
+            results << [key, value]
+          end
+          results
+        end
+
+        def count_query(query)
+          sql, params = build_count_sql(query)
+          execute_query_raw(sql, params) do |row|
+            return row[0]
+          end
+          0
+        end
+
+        def batch_query(query, after: nil, limit: 1000)
+          conditions, params = build_conditions(query)
+
+          if after
+            conditions << "key > ?"
+            params << after
+          end
+
+          sql = "SELECT key, value FROM #{@table_name}"
+          sql += " WHERE #{conditions.join(" AND ")}" unless conditions.empty?
+          sql += " ORDER BY key ASC"
+          sql += " LIMIT ?"
+          params << limit
+
+          results = []
+          execute_query_raw(sql, params) do |row|
+            key = row[0]
+            value = parse_json_value(row[1])
+            results << [key, value]
+          end
+          results
+        end
+
+        def transaction(&block)
+          @db.transaction(&block)
+        rescue SQLite3::Exception => e
+          raise BackendError, "Transaction failed: #{e.message}"
+        end
+
         private
 
         def setup_database
@@ -161,7 +213,129 @@ module Lutaml
           @db.execute("CREATE INDEX IF NOT EXISTS idx_#{@table_name}_updated_at ON #{@table_name} (updated_at)")
         end
 
-        def execute_query(sql, params = [])
+        # ── SQL generation ──
+
+        def build_select_sql(query)
+          conditions, params = build_conditions(query)
+
+          sql = "SELECT key, value FROM #{@table_name}"
+          sql += " WHERE #{conditions.join(" AND ")}" unless conditions.empty?
+          sql += build_order_clause(query.orders)
+          sql += build_limit_offset(query.limit_value, query.offset_value, params)
+
+          [sql, params]
+        end
+
+        def build_count_sql(query)
+          conditions, params = build_conditions(query)
+
+          sql = "SELECT COUNT(*) FROM #{@table_name}"
+          sql += " WHERE #{conditions.join(" AND ")}" unless conditions.empty?
+
+          [sql, params]
+        end
+
+        def build_conditions(query)
+          conditions = ["key LIKE ?"]
+          params = ["#{query.model_class.name}:%"]
+
+          query.predicates.each do |pred|
+            clause, bind = translate_predicate(pred)
+            next unless clause
+
+            conditions << clause
+            params.concat(bind)
+          end
+
+          [conditions, params]
+        end
+
+        SIMPLE_PREDICATES = {
+          Predicate::Equal => "=",
+          Predicate::NotEqual => "!=",
+          Predicate::GreaterThan => ">",
+          Predicate::LessThan => "<",
+          Predicate::GreaterThanOrEqual => ">=",
+          Predicate::LessThanOrEqual => "<="
+        }.freeze
+
+        def translate_predicate(pred)
+          field_json = "json_extract(value, '$.#{pred.field}')"
+
+          op = SIMPLE_PREDICATES[pred.class]
+          return ["#{field_json} #{op} ?", [pred.value]] if op
+
+          case pred
+          when Predicate::Between
+            ["#{field_json} BETWEEN ? AND ?", [pred.value.first, pred.value.last]]
+          when Predicate::NotBetween
+            ["#{field_json} NOT BETWEEN ? AND ?", [pred.value.first, pred.value.last]]
+          when Predicate::In
+            ["#{field_json} IN (#{in_placeholders(pred)})", pred.value]
+          when Predicate::NotIn
+            ["#{field_json} NOT IN (#{in_placeholders(pred)})", pred.value]
+          when Predicate::Matches
+            translate_matches(field_json, pred, "LIKE")
+          when Predicate::NotMatches
+            translate_matches(field_json, pred, "NOT LIKE")
+          when Predicate::Nil
+            ["#{field_json} IS NULL", []]
+          when Predicate::NotNil
+            ["#{field_json} IS NOT NULL", []]
+          end
+        end
+
+        def in_placeholders(pred)
+          pred.value.map { "?" }.join(", ")
+        end
+
+        def translate_matches(field_json, pred, op)
+          pattern = pred.value.is_a?(Regexp) ? regex_to_like(pred.value) : "%#{pred.value}%"
+          ["#{field_json} #{op} ?", [pattern]]
+        end
+
+        def pred_value(pred) # :nodoc:
+          pred.value
+        end
+
+        def build_order_clause(orders)
+          return "" if orders.empty?
+
+          clauses = orders.map do |o|
+            dir = o.direction == :desc ? "DESC" : "ASC"
+            "json_extract(value, '$.#{o.field}') #{dir} NULLS LAST"
+          end
+          " ORDER BY #{clauses.join(", ")}"
+        end
+
+        def build_limit_offset(limit, offset, params)
+          sql = ""
+          if limit
+            sql += " LIMIT ?"
+            params << limit.to_i
+          end
+          if offset
+            sql += " OFFSET ?"
+            params << offset.to_i
+          end
+          sql
+        end
+
+        def regex_to_like(regex)
+          source = regex.source
+          pattern = source.gsub(".+", "%").gsub(".*", "%").gsub(".", "_").gsub("^", "").gsub("$", "")
+          "%#{pattern}%"
+        end
+
+        def parse_json_value(raw)
+          JSON.parse(raw)
+        rescue JSON::ParserError
+          raw
+        end
+
+        # ── Raw query helpers ──
+
+        def execute_query_raw(sql, params = [])
           @db.execute(sql, params) do |row|
             yield row if block_given?
           end
@@ -182,7 +356,7 @@ module Lutaml
         end
 
         def get_schema_version
-          execute_query("PRAGMA user_version") do |row|
+          execute_query_raw("PRAGMA user_version") do |row|
             return row[0]
           end
           0