ar_cache 1.0.0

data/lib/ar_cache/active_record/connection_adapters/abstract/transaction.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module ConnectionAdapters
+      module NullTransaction
+        def add_ar_cache_keys(keys, delay: false) # rubocop:disable Lint/UnusedMethodArgument
+          ArCache::Store.delete_multi(keys)
+        end
+
+        def add_ar_cache_table(table, delay: false) # rubocop:disable Lint/UnusedMethodArgument
+          table.update_version
+        end
+
+        def add_changed_table(_); end
+      end
+
+      module Transaction
+        include NullTransaction
+
+        def initialize(...)
+          super
+          @ar_cache_keys = []
+          @ar_cache_tables = []
+        end
+
+        def add_ar_cache_keys(keys, delay: false)
+          super if !delay && read_uncommitted?
+          @ar_cache_keys.push(*keys)
+        end
+
+        def add_ar_cache_table(table, delay: false)
+          add_changed_table(table.name) unless delay
+
+          super if !delay && read_uncommitted?
+          @ar_cache_tables.push(table)
+        end
+
+        def add_changed_table(table_name)
+          connection.transaction_manager.add_changed_table(table_name)
+        end
+
+        # FIXME: Cache update and transaction commit may cause dirty reads during this period!
+        def commit
+          super
+        ensure
+          if @run_commit_callbacks
+            @ar_cache_tables.uniq(&:name).each(&:update_version) if @ar_cache_tables.any?
+            ArCache::Store.delete_multi(@ar_cache_keys.uniq) if @ar_cache_keys.any?
+          else
+            transaction = connection.current_transaction
+            @ar_cache_tables.each { |table| transaction.add_ar_cache_table(table, delay: true) }
+            transaction.add_ar_cache_keys(@ar_cache_keys, delay: true)
+          end
+        end
+
+        def read_uncommitted?
+          ArCache::Configuration.read_uncommitted ||
+            isolation_level == :read_uncommitted ||
+            !connection.transaction_manager.fully_joinable?
+        end
+      end
+
+      module TransactionManager
+        def initialize(...)
+          super
+          @changed_tables = {}
+        end
+
+        def add_changed_table(table_name)
+          @changed_tables[table_name] = true if fully_joinable?
+        end
+
+        def changed_table?(table_name)
+          @changed_tables.key?(table_name)
+        end
+
+        def fully_joinable?
+          @stack.all?(&:joinable?)
+        end
+
+        def within_new_transaction(...)
+          super
+        ensure
+          @changed_tables = {} if @stack.count(&:joinable?).zero?
+        end
+      end
+    end
+  end
+end

data/lib/ar_cache/active_record/core.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module Core
+      module ClassMethods
+        delegate :skip_ar_cache, to: :all
+
+        # The #find use statement cache execute querying first, so need force skip.
+        def find(...)
+          ar_cache_table.enabled? ? all.find(...) : super
+        end
+
+        # The #find_by use statement cache execute querying first, so need force skip.
+        def find_by(...)
+          ar_cache_table.enabled? ? all.find_by(...) : super
+        end
+      end
+    end
+  end
+end

data/lib/ar_cache/active_record/insert_all.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module InsertAll
+      def execute
+        super.tap do
+          if on_duplicate == :update
+            connection.current_transaction.add_ar_cache_table(model.ar_cache_table)
+          else
+            connection.transaction_manager.add_changed_table(model.table_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ar_cache/active_record/model_schema.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module ModelSchema
+      module ClassMethods
+        def table_name=(...)
+          super.tap { remove_instance_variable(:@ar_cache_table) if defined?(@ar_cache_table) }
+        end
+
+        def ar_cache_table
+          @ar_cache_table ||= begin
+            if abstract_class? || self == ArCache::Record
+              ArCache::MockTable
+            else
+              ArCache::Table.new(table_name)
+            end
+          end
+        end
+      end
+
+      def ar_cache_table
+        self.class.ar_cache_table
+      end
+    end
+  end
+end

data/lib/ar_cache/active_record/persistence.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module Persistence
+      def reload(options = nil)
+        self.class.connection.clear_query_cache
+
+        fresh_object =
+          if options && options[:lock]
+            self.class.unscoped { self.class.skip_ar_cache.lock(options[:lock]).find(id) }
+          else
+            self.class.unscoped { self.class.skip_ar_cache.find(id) }
+          end
+
+        @attributes = fresh_object.instance_variable_get(:@attributes)
+        @new_record = false
+        @previously_new_record = false
+        self
+      end
+    end
+  end
+end

data/lib/ar_cache/active_record/relation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ArCache
+  module ActiveRecord
+    module Relation
+      def skip_ar_cache
+        tap { @skip_ar_cache = true }
+      end
+
+      def explain
+        @skip_ar_cache = true
+        super
+      end
+
+      private def exec_queries(&block) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        skip_query_cache_if_necessary do
+          records =
+            if where_clause.contradiction?
+              []
+            elsif eager_loading?
+              apply_join_dependency do |relation, join_dependency|
+                if relation.null_relation?
+                  []
+                else
+                  relation = join_dependency.apply_column_aliases(relation)
+                  rows = connection.select_all(relation.arel, 'SQL')
+                  join_dependency.instantiate(rows, strict_loading_value, &block)
+                end.freeze
+              end
+            elsif @skip_ar_cache ||
+                  klass.ar_cache_table.disabled? ||
+                  connection.transaction_manager.changed_table?(table_name)
+              klass.find_by_sql(arel, &block).freeze
+            else
+              ArCache::Query.new(self).exec_queries(&block).freeze
+            end
+
+          preload_associations(records) unless skip_preloading_value
+
+          records.each(&:readonly!) if readonly_value
+          records.each(&:strict_loading!) if strict_loading_value
+
+          records
+        end
+      end
+    end
+  end
+end

data/lib/ar_cache/configuration.rb

@@ -0,0 +1,59 @@
+# 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
+
+    def self.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'
+      end
+
+      @cache_store = cache_store
+    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)
+
+        hash.each_key do |k|
+          raise ArgumentError, "The #{k.inspect} must be converted to Symbol type" unless k.is_a?(Symbol)
+        end
+      end
+
+      @tables_options = options
+    end
+
+    def self.coder=(coder)
+      raise ArgumentError, 'The coder only support use YAML or JSON' unless [::YAML, ::JSON].include?(coder)
+
+      @coder = coder
+    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
+    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/log_subscriber.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# TODO
+module ArCache
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    attach_to :ar_cache
+  end
+end

data/lib/ar_cache/marshal.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ArCache
+  module Marshal
+    def delete(*ids)
+      return -1 if disabled?
+
+      ArCache::Store.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
+
+        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
+        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) }
+
+      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)
+
+        if wrong_key
+          where_clause.add_missed_values(k)
+          where_clause.add_invalid_keys(k) if column_indexes.include?(wrong_key)
+        else
+          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)
+      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)
+        else
+          return k unless v == value
+        end
+      end
+    end
+
+    private def instantiate(klass, attributes, &block)
+      attributes.except!(*klass.ignored_columns) if klass.ignored_columns.any?
+
+      return klass.instantiate(attributes, &block) if attributes.key?(klass.inheritance_column)
+
+      klass.send(:instantiate_instance_of, klass, attributes, &block)
+    end
+  end
+end

data/lib/ar_cache/mock_table.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ArCache
+  class MockTable
+    class << self
+      def disabled?
+        true
+      end
+
+      def enabled?
+        false
+      end
+
+      def select_disabled?
+        true
+      end
+
+      def select_enabled?
+        false
+      end
+
+      def version
+        -1
+      end
+
+      def update_version(...)
+        -1
+      end
+
+      def primary_key
+        ''
+      end
+
+      def primary_cache_key(...)
+        ''
+      end
+
+      def cache_key(...)
+        ''
+      end
+
+      def write(...)
+        -1
+      end
+
+      def delete(...)
+        -1
+      end
+
+      def read(...)
+        []
+      end
+    end
+  end
+end

data/lib/ar_cache/query.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ArCache
+  class Query
+    attr_reader :relation, :table, :where_clause
+
+    def initialize(relation)
+      @relation = relation
+      @table = @relation.klass.ar_cache_table
+      @where_clause = ArCache::WhereClause.new(@relation.klass, @relation.where_clause.send(:predicates))
+    end
+
+    def exec_queries(&block)
+      return relation.skip_ar_cache.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)
+        end
+        records += relation.find_by_sql(missed_relation.arel, &block).tap { |rs| table.write(rs) }
+      end
+
+      records_order(records)
+    end
+
+    private def exec_queries_cacheable? # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      return false if relation.skip_query_cache_value
+      return false if relation.lock_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 unless relation.from_clause.empty?
+      return false unless where_clause.cacheable?
+      return false unless select_values_cacheable?
+      return false unless order_values_cacheable?
+      return false unless limit_value_cacheable?
+
+      true
+    end
+
+    private def select_values_cacheable?
+      return true if relation.select_values.empty?
+      return false if table.select_disabled?
+
+      @select_values = relation.select_values.map(&:to_s)
+      (@select_values - table.column_names).empty?
+    end
+
+    private def order_values_cacheable?
+      return true if where_clause.single?
+
+      size = relation.order_values.size
+      return true if size.zero?
+      return false if size > 1
+
+      first_order_value = relation.order_values.first
+      case first_order_value
+      when Arel::Nodes::Ordering
+        @order_name = first_order_value.expr.name
+        @order_desc = first_order_value.descending?
+      when String
+        @order_name, @order_desc = first_order_value.downcase.split
+        return false unless table.column_names.include?(@order_name)
+
+        @order_desc = @order_desc == 'desc'
+      else
+        return false
+      end
+
+      true
+    end
+
+    private def limit_value_cacheable?
+      where_clause.single? || relation.limit_value.nil?
+    end
+
+    private def records_order(records)
+      return records if records.size < 2
+
+      method = "#{@order_name || table.primary_key}_for_database"
+      return records.sort! { |a, b| b.send(method) <=> a.send(method) } if @order_desc
+
+      records.sort! { |a, b| a.send(method) <=> b.send(method) }
+    end
+  end
+end