ar_cache 1.2.0 → 2.1.0

data/lib/ar_cache/configuration.rb

@@ -1,59 +1,64 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module ArCache
   class Configuration
-    singleton_class.attr_accessor :disabled, :select_disabled, :expires_in, :read_uncommitted, :index_column_max_size
-    singleton_class.attr_reader :cache_store, :tables_options, :coder
+    class << self
+      attr_writer :cache_lock, :lock_statement
+      attr_reader :cache_store, :tables_options
+      attr_accessor :disabled, :select_disabled, :expires_in
 
-    def self.configure
-      block_given? ? yield(self) : self
-    end
+      def configure
+        block_given? ? yield(self) : self
+      end
 
-    def self.cache_store=(cache_store)
-      unless cache_store.is_a?(ActiveSupport::Cache::Store)
-        raise ArgumentError, 'The cache_store must be an ActiveSupport::Cache::Store object'
+      def cache_lock?
+        @cache_lock
       end
 
-      @cache_store = cache_store
-    end
+      def redis?
+        @redis
+      end
 
-    def self.tables_options=(options)
-      options.each do |name, hash|
-        raise ArgumentError, "The #{name.inspect} must be converted to Symbol type" unless name.is_a?(Symbol)
+      def memcached?
+        @memcached
+      end
 
-        hash.each_key do |k|
-          raise ArgumentError, "The #{k.inspect} must be converted to Symbol type" unless k.is_a?(Symbol)
+      def cache_store=(cache_store)
+        if !cache_store.is_a?(ActiveSupport::Cache::Store) # rubocop:disable Style/GuardClause
+          raise ArgumentError, 'The cache_store must be an ActiveSupport::Cache::Store object'
+        elsif cache_store.class.name == 'ActiveSupport::Cache::RedisCacheStore' # rubocop:disable Style/ClassEqualityComparison
+          @redis = true
+        elsif cache_store.class.name == 'ActiveSupport::Cache::MemCacheStore' # rubocop:disable Style/ClassEqualityComparison
+          @memcached = true
         end
-      end
 
-      @tables_options = options
-    end
+        @cache_store = cache_store
+      end
 
-    def self.coder=(coder)
-      raise ArgumentError, 'The coder only support use YAML or JSON' unless [::YAML, ::JSON].include?(coder)
+      def tables_options=(options)
+        @tables_options = options.deep_symbolize_keys
+      end
 
-      @coder = coder
-    end
+      def get_table_options(name)
+        options = tables_options[name.to_sym] || {}
+        options[:disabled] = disabled unless options.key?(:disabled)
+        options[:select_disabled] = select_disabled unless options.key?(:select_disabled)
+        options[:unique_indexes] = Array(options[:unique_indexes]).map { |index| Array(index).map(&:to_s).uniq }.uniq
+        options
+      end
 
-    def self.get_table_options(name)
-      options = tables_options[name.to_sym] || {}
-      options[:disabled] = disabled unless options.key?(:disabled)
-      options[:select_disabled] = select_disabled unless options.key?(:select_disabled)
-      options[:ignored_columns] = Array(options[:ignored_columns]).map(&:to_s)
-      options[:unique_indexes] = Array(options[:unique_indexes]).map { |index| Array(index).map(&:to_s).uniq }.uniq
-      options
+      def lock_statement
+        @lock_statement ||= case ::ActiveRecord::Base.connection.class.name
+                            when 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter'
+                              'FOR SHARE'
+                            when 'ActiveRecord::ConnectionAdapters::Mysql2Adapter'
+                              'LOCK IN SHARE MODE'
+                            when 'ActiveRecord::ConnectionAdapters::SQLite3Adapter'
+                              raise "SQLite3 don't support lock statement, please use cache lock."
+                            else
+                              raise "Arcache can't identify database, please defined lock statement or use cache lock"
+                            end
+      end
     end
-
-    # The set default values
-    @cache_store = defined?(Rails) ? Rails.cache : ActiveSupport::Cache::MemoryStore.new
-    @tables_options = {}
-    @coder = ::YAML
-    @disabled = false
-    @select_disabled = true
-    @expires_in = 604_800 # 1 week
-    @read_uncommitted = false
-    @index_column_max_size = 64
   end
 end

data/lib/ar_cache/marshal.rb

@@ -2,65 +2,75 @@
 
 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)
+    def write(records) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
       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])
+        stringify_attributes = dump_attributes(attributes)
+        bool = ArCache.write(key, stringify_attributes, unless_exist: cache_lock?, raw: true, expires_in: expires_in)
+        if cache_lock? && !bool
+          value = ArCache.read(key, raw: true)
+          next if value == ArCache::PLACEHOLDER
+          next ArCache.lock_key(key) if value != stringify_attributes
+        end
 
         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/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]
+
+        case v
+        when nil
+          where_clause.add_missed_values(k)
+        when 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|
         value = entry[k]
-        next if value.nil?
 
         if v.is_a?(Array)
           return k unless v.include?(value)

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,8 @@
 
 module ArCache
   class Query
+    delegate :lock_statement, :cache_lock?, to: ArCache::Configuration
+
     attr_reader :relation, :table, :where_clause
 
     def initialize(relation)
@@ -12,21 +14,22 @@ 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
-        if table.ignored_columns.any? && relation.select_values.any?
-          missed_relation = missed_relation.reselect(table.column_names)
+      if where_clause.missed_hash.any?
+        missed_relation = relation.rewhere(where_clause.missed_hash).reselect('*')
+        missed_relation = missed_relation.lock(lock_statement) unless cache_lock?
+        missed_relation.arel.singleton_class.attr_accessor(:klass_and_select_values)
+        missed_relation.arel.klass_and_select_values = [relation.klass, @select_values]
+        if cache_lock?
+          records += missed_relation.find_by_sql(missed_relation.arel, &block)
+        else
+          missed_relation.connection.transaction do
+            records += missed_relation.find_by_sql(missed_relation.arel, &block)
+          end
         end
-        records += relation.find_by_sql(missed_relation.arel, &block).tap { |rs| table.write(rs) }
       end
 
       records_order(records)
@@ -39,16 +42,17 @@ module ArCache
       records
     end
 
-    private def exec_queries_cacheable? # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-      return false if relation.klass.ar_cache_table.disabled?
+    def exec_queries_cacheable? # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      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
       return false if relation.group_values.any?
       return false if relation.joins_values.any?
       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?
@@ -66,7 +70,7 @@ module ArCache
       (@select_values - table.column_names).empty?
     end
 
-    private def order_values_cacheable?
+    private def order_values_cacheable? # rubocop:disable Metrics/CyclomaticComplexity
       return true if where_clause.single?
 
       size = relation.order_values.size
@@ -81,6 +85,7 @@ module ArCache
       when String
         @order_name, @order_desc = first_order_value.downcase.split
         return false unless table.column_names.include?(@order_name)
+        return false unless ['asc', 'desc', nil].include?(@order_desc)
 
         @order_desc = @order_desc == 'desc'
       else

data/lib/ar_cache/table.rb

@@ -4,42 +4,45 @@ module ArCache
   class Table
     include Marshal
 
-    OPTIONS = %i[disabled select_disabled unique_indexes ignored_columns].freeze
-
     singleton_class.attr_reader :all
 
-    attr_reader :name, :primary_key, :unique_indexes, :column_indexes, :column_names, :md5,
-                :ignored_columns, :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) - @ignored_columns).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}-#{@ignored_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?
@@ -50,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: 20.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)
@@ -78,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)
-      indexes.each do |index|
-        index.each do |column|
-          column = columns.find { |c| c.name == column }
-          raise ArgumentError, "The #{name} table not found #{column.inspect} column" if column.nil?
-
-          if column.type == :datetime
-            raise ArgumentError, "The #{column.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