ar_cache 1.0.0

data/lib/ar_cache/record.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ArCache
+  class Record < ActiveRecord::Base # rubocop:disable Rails/ApplicationRecord
+    self.table_name = 'ar_cache_records'
+
+    default_scope { skip_ar_cache }
+
+    def self.get(table_name)
+      find_by(table_name: table_name)
+    end
+
+    def self.version(table)
+      (get(table.name) || store(table)).version
+    end
+
+    def self.update_version(table)
+      record = get(table.name)
+      return store(table).version unless record
+
+      record.update_version
+      record.version
+    end
+
+    def self.store(table)
+      record = get(table.name) || new(table_name: table.name)
+      record.store(table)
+      record
+    end
+
+    def store(table)
+      with_optimistic_retry do
+        self.version += 1 unless table_md5 == table.md5
+        self.table_md5 = table.md5
+
+        save! if changed?
+      end
+    end
+
+    def update_version
+      with_optimistic_retry do
+        self.version += 1
+        save!
+      end
+    end
+
+    private def with_optimistic_retry
+      yield
+    rescue ::ActiveRecord::StaleObjectError
+      reload
+      retry
+    end
+  end
+end

data/lib/ar_cache/store.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ArCache
+  class Store
+    @options = { raw: true, expires_in: ArCache::Configuration.expires_in }.freeze
+
+    class << self
+      delegate :delete, :delete_multi, :clear, :exist?, to: 'ArCache::Configuration.cache_store'
+
+      def write(name, value)
+        ArCache::Configuration.cache_store.write(name, dump(value), @options)
+      end
+
+      def write_multi(hash)
+        hash.each { |k, v| hash[k] = dump(v) }
+        ArCache::Configuration.cache_store.write_multi(hash, @options)
+      end
+
+      def read(name)
+        load(ArCache::Configuration.cache_store.read(name, @options))
+      end
+
+      def read_multi(names)
+        entries = ArCache::Configuration.cache_store.read_multi(*names, @options)
+        entries.each { |k, v| entries[k] = load(v) }
+        entries
+      end
+
+      private def dump(value)
+        ArCache::Configuration.coder.dump(value)
+      end
+
+      private def load(value)
+        ArCache::Configuration.coder.load(value) if value
+      end
+    end
+  end
+end

data/lib/ar_cache/table.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+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
+      end
+    end
+
+    def initialize(table_name)
+      @name = table_name
+      @cache_key_prefix = "arcache:#{@name}:version"
+      @primary_key = connection.primary_key(@name)
+      columns = connection.columns(@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
+      @column_indexes = @unique_indexes.flatten.uniq.freeze
+      coder = ArCache::Configuration.coder
+      @md5 = Digest::MD5.hexdigest("#{coder}-#{@disabled}-#{columns.to_json}-#{@ignored_columns.to_json}")
+
+      ArCache::Record.store(self)
+
+      self.class.all << self
+    end
+
+    def disabled?
+      @disabled
+    end
+
+    def enabled?
+      !disabled?
+    end
+
+    def select_disabled?
+      @select_disabled
+    end
+
+    def select_enabled?
+      !@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
+
+      version
+    end
+
+    def update_version
+      return -1 if disabled?
+
+      version = ArCache::Record.update_version(self)
+      ArCache::Store.write(cache_key_prefix, version)
+      version
+    end
+
+    def primary_cache_key(id)
+      "#{cache_key_prefix}:#{version}:#{primary_key}=#{id}"
+    end
+
+    def cache_key(where_values_hash, index, multi_values_key = nil, key_value = nil)
+      where_value = index.map do |column|
+        value = column == multi_values_key ? key_value : where_values_hash[column]
+        "#{column}=#{value}"
+      end.sort.join('&')
+
+      "#{cache_key_prefix}:#{version}:#{where_value}"
+    end
+
+    private def normalize_unique_indexes(indexes, columns)
+      indexes = indexes.empty? ? query_unique_indexes(columns) : custom_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|
+        next unless index.unique
+
+        index.columns.each do |column|
+          column = columns.find { |c| c.name == column }
+          next if column.null
+          next if column.type == :datetime
+        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
+        end
+      end
+    end
+  end
+end

data/lib/ar_cache/version.rb

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

data/lib/ar_cache/where_clause.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module ArCache
+  class WhereClause
+    attr_reader :klass, :table, :predicates
+
+    def initialize(klass, predicates)
+      @klass = klass
+      @table = klass.ar_cache_table
+      @predicates = predicates
+      @missed_values = []
+    end
+
+    def cacheable?
+      return @cacheable if defined?(@cacheable)
+
+      @cacheable = predicates.any? && where_values_hash.length == predicates.length && hit_unique_index?
+    end
+
+    def hit_unique_index?
+      table.unique_indexes.each do |index|
+        @index = index
+        @multi_values_key = nil
+        count = 0
+
+        bool = index.all? do |column|
+          where_values_hash[column].tap do |value|
+            if value.is_a?(Array)
+              @multi_values_key = column
+              count += 1
+            end
+          end
+        end
+
+        return true if bool && count < 2
+      end
+
+      false
+    end
+
+    def single?
+      @multi_values_key.nil?
+    end
+
+    def primary_key_index?
+      (@multi_values_key || @index.first) == table.primary_key
+    end
+
+    def cache_hash
+      return @cache_hash if defined?(@cache_hash)
+
+      @cache_hash = {}
+      multi_values_key = @multi_values_key || @index.first
+
+      Array(where_values_hash[multi_values_key]).each do |v|
+        @cache_hash[table.cache_key(where_values_hash, @index, multi_values_key, v)] = v
+      end
+
+      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 = @cache_hash.invert
+
+      @cache_hash
+    end
+
+    def cache_keys
+      keys = cache_hash.keys
+      keys += cache_hash.values unless primary_key_index?
+
+      keys
+    end
+
+    def missed_hash
+      @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]
+      else
+        @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
+    end
+
+    def delete_invalid_keys
+      ArCache::Store.delete_multi(@invalid_keys) if @invalid_keys
+    end
+
+    # This module is based on ActiveRecord::Relation::WhereClause modified
+    module Raw
+      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.index_column_max_size
+
+          hash[name] = value
+        end
+      rescue NoMethodError, ActiveModel::RangeError
+        @where_values_hash = {}
+      end
+      alias to_h where_values_hash
+
+      private def equalities(predicates)
+        equalities = []
+
+        predicates.each do |node|
+          if equality_node?(node)
+            equalities << node
+          elsif node.is_a?(Arel::Nodes::And)
+            equalities.concat equalities(node.children)
+          end
+        end
+
+        equalities
+      end
+
+      private def equality_node?(node)
+        !node.is_a?(String) && node.equality?
+      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
+
+        value.is_a?(Date) ? value.to_s : value
+      end
+    end
+    include Raw
+  end
+end

data/lib/generators/ar_cache/install_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'rails/generators/active_record/migration'
+
+module ArCache
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      include ::ActiveRecord::Generators::Migration
+
+      source_root File.expand_path('templates', __dir__)
+
+      def copy_initializer_file
+        copy_file 'configuration.rb', 'config/initializers/ar_cache.rb'
+
+        migration_template 'migrate/create_ar_cache_records.rb', 'db/migrate/create_ar_cache_records.rb'
+      end
+    end
+  end
+end

data/lib/generators/ar_cache/templates/configuration.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# For more information, please see: https://github.com/OuYangJinTing/ar_cache/README.md
+ArCache.configure do |config|
+  # WARNING: The should uncomment only when your database default isolation level is "READ UNCOMMITTED"!
+  # config.read_uncommitted = true # defaul false
+
+  # config.cache_store = ActiveSupport::Cache::Store # default Rails.cache || ActiveSupport::Cache::MemoryStore.new
+
+  # Cache key automatic expiration time.
+  # config.expires_in = Numeric # default 1 week
+
+  # Serialize and deserialize cached data.
+  # config.coder = [YAML|JSON] # default YAML
+
+  # Support the maximum length of index column value.
+  # config.index_column_max_size = Integer # default 64
+
+  # ArCache switch.
+  # config.disabled = Boolean # default false
+
+  # Whether to support selecct columns query
+  # config.select_disabled = Boolean # default true
+
+  # config.tables_options = {
+  #   table_name: {
+  #     disabled: Boolean,
+  #     select_disabled: Boolean,
+  #     unique_indexes: Array # eg: [:id, [:name, :statue]], The default is the unique index column of the table.
+  #     ignored_columns: Array # eg: [:created_at, :updated_at], defaule [].
+  #   },
+  #   ...
+  # }
+end

data/lib/generators/ar_cache/templates/migrate/create_ar_cache_records.rb.tt

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateArCacheMonitors < ActiveRecord::Migration[<%= ActiveRecord::VERSION::MAJOR %>.<%= ActiveRecord::VERSION::MINOR %>]
+  def change
+    create_table :ar_cache_records do |t|
+      t.string  :table_name, null: false
+      t.string  :table_md5, null: false, limit: 32, default: '0' * 32
+      t.integer :version, null: false, default: 0
+      t.integer :lock_version, null: false, default: 0
+
+      t.timestamps null: false
+
+      t.index :table_name, unique: true
+    end
+  end
+end