ar_cache 1.5.0 → 2.0.0

data/lib/ar_cache/marshal.rb

@@ -2,66 +2,68 @@
 
 module ArCache
   module Marshal
+    delegate :expires_in, :cache_lock?, to: ArCache::Configuration
+    delegate :dump_attributes, :load_attributes, to: ArCache
+
     def delete(*ids)
       return -1 if disabled?
 
-      ArCache::Store.delete_multi(ids.map { |id| primary_cache_key(id) })
+      ArCache.delete_multi(ids.map { |id| primary_cache_key(id) })
     end
 
-    # WARNING:
-    #   In order to ensure that the written data is consistent with the database,
-    #   only the record from the query can be written.
     def write(records)
       return -1 if disabled?
 
-      cache_hash = {}
-      records.each do |record|
-        attributes = record.attributes_before_type_cast
-        key = nil
-
+      records.each do |attributes|
+        key = primary_cache_key(attributes[primary_key])
+        ArCache.write(key, dump_attributes(attributes), unless_exist: cache_lock?, raw: true, expires_in: expires_in)
         unique_indexes.each_with_index do |index, i|
-          if i.zero? # is primary key
-            key = primary_cache_key(attributes[primary_key])
-            cache_hash[key] = attributes
-          else
-            cache_hash[cache_key(attributes, index)] = key
-          end
+          # The first index is primary key, should skip it.
+          ArCache.write(cache_key(attributes, index), key, raw: true, expires_in: expires_in) unless i.zero?
         end
       end
-
-      ArCache::Store.write_multi(cache_hash)
     rescue Encoding::UndefinedConversionError
       0
     end
 
-    def read(where_clause, select_values, &block)
-      entries_hash = ArCache::Store.read_multi(where_clause.cache_hash.keys)
-      where_clause.cache_hash.each_key { |k| where_clause.add_missed_values(k) unless entries_hash.key?(k) }
+    def read(where_clause, select_values = nil, &block) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+      entries_hash = ArCache.read_multi(*where_clause.cache_hash.keys, raw: true)
+      where_clause.cache_hash.each_key do |k|
+        v = entries_hash[k]
+
+        if v.nil?
+          where_clause.add_missed_values(k)
+        elsif v == ArCache::PLACEHOLDER
+          where_clause.add_missed_values(k)
+          where_clause.add_blank_primary_cache_key(k)
+          entries_hash.delete(k)
+        else
+          entries_hash[k] = load_attributes(v)
+        end
+      end
 
       records = []
 
       entries_hash.each do |k, entry|
-        entry = entry.slice(*select_values) if select_values
-        wrong_key = detect_wrong_key(entry, where_clause.to_h)
+        wrong_key = detect_wrong_column(entry, where_clause.to_h)
 
         if wrong_key
           where_clause.add_missed_values(k)
-          where_clause.add_invalid_keys(k) if column_indexes.include?(wrong_key)
+          where_clause.add_invalid_second_cache_key(k) if column_indexes.include?(wrong_key)
         else
+          entry = entry.slice(*select_values) if select_values
           records << instantiate(where_clause.klass, entry, &block)
         end
       end
 
       where_clause.delete_invalid_keys
-
       records
     end
 
-    private def detect_wrong_key(entry, where_values_hash)
+    private def detect_wrong_column(entry, where_values_hash)
       where_values_hash.detect do |k, v|
-        next unless entry.key?(k)
-
         value = entry[k]
+
         if v.is_a?(Array)
           return k unless v.include?(value)
         else

data/lib/ar_cache/mock_table.rb

@@ -11,12 +11,12 @@ module ArCache
         true
       end
 
-      def version
-        -1
+      def cache_key_prefix
+        ''
       end
 
-      def update_version(...)
-        -1
+      def update_cache
+        ''
       end
 
       def primary_key

data/lib/ar_cache/query.rb

@@ -2,6 +2,10 @@
 
 module ArCache
   class Query
+    @lock_statement = 'FOR SHARE'
+    singleton_class.attr_accessor :lock_statement
+    delegate :lock_statement, :lock_statement=, to: 'self.class'
+
     attr_reader :relation, :table, :where_clause
 
     def initialize(relation)
@@ -12,19 +16,24 @@ module ArCache
 
     def exec_queries(&block) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
       return [] if relation.where_clause.contradiction?
-      return ArCache.skip { relation.send(:exec_queries, &block) } unless exec_queries_cacheable?
+      return ArCache.skip_cache { relation.send(:exec_queries, &block) } unless exec_queries_cacheable?
 
       records = table.read(where_clause, @select_values, &block)
 
-      missed_relation = if records.empty?
-                          relation
-                        elsif where_clause.missed_hash.any?
-                          relation.rewhere(where_clause.missed_hash)
-                        end
-
-      if missed_relation
-        records += relation.find_by_sql(missed_relation.arel, &block).tap do |rs|
-          table.write(rs) if relation.select_values.empty?
+      if where_clause.missed_hash.any?
+        begin
+          missed_relation = relation.rewhere(where_clause.missed_hash).reselect('*').lock(lock_statement)
+          missed_relation.arel.singleton_class.attr_accessor(:klass_and_select_values)
+          missed_relation.arel.klass_and_select_values = [relation.klass, @select_values]
+          missed_relation.connection.transaction do
+            records += missed_relation.find_by_sql(missed_relation.arel, &block)
+          end
+        rescue ::ActiveRecord::StatementInvalid => e
+          raise e if relation.connection.class.name != 'ActiveRecord::ConnectionAdapters::Mysql2Adapter'
+          raise e if lock_statement == 'LOCK IN SHARE MODE'
+
+          self.lock_statement = 'LOCK IN SHARE MODE'
+          retry
         end
       end
 
@@ -39,7 +48,7 @@ module ArCache
     end
 
     def exec_queries_cacheable? # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-      return false if relation.klass.ar_cache_table.disabled?
+      return false if table.disabled?
       return false if relation.skip_query_cache_value
       return false if relation.lock_value
       return false if relation.distinct_value
@@ -48,7 +57,7 @@ module ArCache
       return false if relation.left_outer_joins_values.any?
       return false if relation.offset_value
       return false if relation.eager_loading?
-      return false if relation.connection.transaction_manager.changed_table?(table.name)
+      return false if relation.connection.transaction_manager.transaction_table?(table.name)
       return false unless relation.from_clause.empty?
       return false unless where_clause.cacheable?
       return false unless select_values_cacheable?

data/lib/ar_cache/table.rb

@@ -4,41 +4,45 @@ module ArCache
   class Table
     include Marshal
 
-    OPTIONS = %i[disabled select_disabled unique_indexes].freeze
-
     singleton_class.attr_reader :all
 
-    attr_reader :name, :primary_key, :unique_indexes, :column_indexes, :column_names, :md5, :cache_key_prefix
-
-    delegate :connection, to: ActiveRecord::Base, private: true
-
     @lock = Mutex.new
-
     @all = []
 
     def self.new(table_name)
       @lock.synchronize do
-        @all.find { |table| table.name == table_name } || super
+        table = @all.find { |t| t.name == table_name }
+
+        unless table
+          table = super
+          @all << table
+        end
+
+        table
       end
     end
 
+    attr_reader :name, :primary_key, :unique_indexes, :column_indexes, :column_names, :identity_cache_key, :short_sha1
+
     def initialize(table_name)
       @name = table_name
-      @cache_key_prefix = "arcache:#{@name}:version"
-      @primary_key = connection.primary_key(@name)
-      columns = connection.columns(@name)
+      @primary_key = ::ActiveRecord::Base.connection.primary_key(@name)
+
       options = ArCache::Configuration.get_table_options(@name)
-      @unique_indexes = normalize_unique_indexes(options.delete(:unique_indexes), columns).freeze
-      options.each { |k, v| instance_variable_set("@#{k}", v) }
-      @disabled = true if @primary_key.nil? # ArCache is depend on primary key implementation.
-      @column_names = columns.map(&:name).freeze
+      @disabled = @primary_key.nil? ? true : options[:disabled] # ArCache can't work if primary key does not exist.
+      @select_disabled = options[:select_disabled]
+
+      columns = ::ActiveRecord::Base.connection.columns(@name)
+      @unique_indexes = normalize_unique_indexes(options[:unique_indexes], columns).freeze
       @column_indexes = @unique_indexes.flatten.uniq.freeze
-      coder = ArCache::Configuration.coder
-      @md5 = Digest::MD5.hexdigest("#{coder}-#{@disabled}-#{columns.to_json}")
+      @column_names = columns.map(&:name).freeze
 
-      ArCache::Record.store(self)
+      @identity_cache_key = "ar:cache:#{@name}"
+      @short_sha1 = Digest::SHA1.hexdigest("#{@disabled}:#{columns.to_json}").first(7)
 
-      self.class.all << self
+      # For avoid to skip Arcache read cache, must delete cache when disable Arcache.
+      # For keep table's schema is consistent, must delete cache after modified the table.
+      ArCache.delete(@identity_cache_key) if disabled? || !cache_key_prefix.start_with?("#{@identity_cache_key}:#{@short_sha1}") # rubocop:disable Layout/LineLength
     end
 
     def disabled?
@@ -49,26 +53,23 @@ module ArCache
       @select_disabled
     end
 
-    def version
-      version = ArCache::Store.read(cache_key_prefix)
-      unless version
-        version = ArCache::Record.version(self)
-        ArCache::Store.write(cache_key_prefix, version)
-      end
+    def cache_key_prefix
+      return '' if disabled?
 
-      version
+      ArCache.read(identity_cache_key, raw: true) || update_cache
     end
 
-    def update_version
-      return -1 if disabled?
+    # In order to avoid cache avalanche, we must set cache_key_prefix never expired.
+    def update_cache
+      return '' if disabled?
 
-      version = ArCache::Record.update_version(self)
-      ArCache::Store.write(cache_key_prefix, version)
-      version
+      key = "#{identity_cache_key}:#{short_sha1}:#{Time.now.to_f}"
+      ArCache.write(identity_cache_key, key, raw: true, expires_in: 100.years)
+      key
     end
 
     def primary_cache_key(id)
-      "#{cache_key_prefix}:#{version}:#{primary_key}=#{id}"
+      "#{cache_key_prefix}:#{primary_key}=#{id}"
     end
 
     def cache_key(where_values_hash, index, multi_values_key = nil, key_value = nil)
@@ -77,39 +78,32 @@ module ArCache
         "#{column}=#{value}"
       end.sort.join('&')
 
-      "#{cache_key_prefix}:#{version}:#{where_value}"
+      "#{cache_key_prefix}:#{where_value}"
     end
 
     private def normalize_unique_indexes(indexes, columns)
-      indexes = indexes.empty? ? query_unique_indexes(columns) : custom_unique_indexes(indexes, columns)
+      indexes = indexes.empty? ? query_unique_indexes(columns) : validate_unique_indexes(indexes, columns)
       (indexes - [primary_key]).sort_by(&:size).unshift([primary_key])
     end
 
-    private def query_unique_indexes(columns) # rubocop:disable Metrics/CyclomaticComplexity
-      connection.indexes(name).filter_map do |index|
+    private def query_unique_indexes(columns)
+      ::ActiveRecord::Base.connection.indexes(name).filter_map do |index|
         next unless index.unique
+        next unless index.columns.is_a?(Array)
 
         index.columns.each do |column|
-          column = columns.find { |c| c.name == column }
-          next if column.null
-          next if column.type == :datetime
+          next if columns.none? { |c| c.name == column }
         end
 
         index.columns
-      rescue NoMethodError # The index.columns maybe isn't Array type
-        next
       end
     end
 
-    private def custom_unique_indexes(indexes, columns)
-      indexes.each do |index|
-        index.each do |field|
-          column = columns.find { |c| c.name == field }
-          raise ArgumentError, "The #{name} table not found #{field.inspect} column" if column.nil?
-
-          if column.type == :datetime
-            raise ArgumentError, "The #{field.inspect} is datetime type, ArCache do't support datetime type"
-          end
+    private def validate_unique_indexes(indexes, columns)
+      indexes.each do |attrs|
+        attrs.each do |attr|
+          column = columns.find { |c| c.name == attr }
+          raise ArgumentError, "The #{name} table not found #{attr} column" if column.nil?
         end
       end
     end

data/lib/ar_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArCache
-  VERSION = '1.5.0'
+  VERSION = '2.0.0'
 end

data/lib/ar_cache/where_clause.rb

@@ -2,13 +2,20 @@
 
 module ArCache
   class WhereClause
-    attr_reader :klass, :table, :predicates, :invalid_keys
+    attr_reader :klass, :table, :predicates
 
     def initialize(klass, predicates)
       @klass = klass
       @table = klass.ar_cache_table
       @predicates = predicates
-      @missed_values = []
+    end
+
+    def missed_values
+      @missed_values ||= []
+    end
+
+    def invalid_keys
+      @invalid_keys ||= []
     end
 
     def cacheable?
@@ -24,7 +31,7 @@ module ArCache
         count = 0
 
         bool = index.all? do |column|
-          where_values_hash.key?(column).tap do
+          (Thread.current[:ar_cache_reflection] ? where_values_hash.key?(column) : where_values_hash[column]).tap do
             if where_values_hash[column].is_a?(Array)
               @multi_values_key = column
               count += 1
@@ -59,8 +66,8 @@ module ArCache
       return @cache_hash if primary_key_index?
 
       @original_cache_hash = @cache_hash
-      @cache_hash = ArCache::Store.read_multi(@cache_hash.keys)
-      @original_cache_hash.each { |k, v| @missed_values << v unless @cache_hash.key?(k) }
+      @cache_hash = ArCache.read_multi(*@cache_hash.keys, raw: true)
+      @original_cache_hash.each { |k, v| missed_values << v unless @cache_hash.key?(k) }
       @cache_hash = @cache_hash.invert
 
       @cache_hash
@@ -73,26 +80,28 @@ module ArCache
     end
 
     def missed_hash
-      @missed_hash ||= @missed_values.empty? ? {} : { (@multi_values_key || @index.first) => @missed_values }
+      @missed_hash ||= missed_values.empty? ? {} : { (@multi_values_key || @index.first) => missed_values }
     end
 
     def add_missed_values(key)
       if primary_key_index?
-        @missed_values << cache_hash[key]
+        missed_values << cache_hash[key]
       else
-        @missed_values << @original_cache_hash[cache_hash[key]]
+        missed_values << @original_cache_hash[cache_hash[key]]
       end
     end
 
-    def add_invalid_keys(key)
-      @invalid_keys ||= []
-      @invalid_keys << key
-      @invalid_keys << cache_hash[key] unless primary_key_index?
-      @invalid_keys
+    def add_blank_primary_cache_key(key)
+      invalid_keys << key
+    end
+
+    def add_invalid_second_cache_key(key)
+      # invalid_keys << key # The primary key index is reliable.
+      invalid_keys << cache_hash[key] unless primary_key_index?
     end
 
     def delete_invalid_keys
-      ArCache::Store.delete_multi(@invalid_keys) if @invalid_keys
+      ArCache.delete_multi(invalid_keys) if invalid_keys.any?
     end
 
     # This module is based on ActiveRecord::Relation::WhereClause modified
@@ -100,13 +109,10 @@ module ArCache
       def where_values_hash
         @where_values_hash ||= equalities(predicates).each_with_object({}) do |node, hash|
           # Don't support Arel::Nodes::NamedFunction.
-          # But we don't judge it, because it will raise exception if it is Arel::Nodes::NamedFunction object.
           next if table.name != node.left.relation.name
 
           name = node.left.name.to_s
           value = extract_node_value(node.right)
-          next if value.respond_to?(:size) && value.size > ArCache::Configuration.column_length
-
           hash[name] = value
         end
       rescue NoMethodError, ActiveModel::RangeError
@@ -133,15 +139,18 @@ module ArCache
       end
 
       private def extract_node_value(node)
-        value = case node
-                when Array
-                  node.map { |v| extract_node_value(v) }
-                when Arel::Nodes::BindParam
-                  node.value.value_for_database # Maybe raise ActiveModel::RangeError
-                when Arel::Nodes::Casted, Arel::Nodes::Quoted
-                  node.value_for_database # Maybe raise ActiveModel::RangeError
-                end
+        case node
+        when Array
+          node.map { |v| extract_node_value(v) }
+        when Arel::Nodes::BindParam
+          value_for_database(node.value)
+        when Arel::Nodes::Casted, Arel::Nodes::Quoted
+          value_for_database(node)
+        end
+      end
 
+      private def value_for_database(node)
+        value = node.value_for_database # Maybe raise ActiveModel::RangeError
         value.is_a?(Date) ? value.to_s : value
       end
     end